Защо диапазонът (начало, край) не включва край?

Тъй като е по-често да се извиква range(0, 10), което връща [0,1,2,3,4,5,6,7,8,9], което съдържа 10 елемента, което е равно на len(range(0, 10)). Не забравяйте, че програмистите предпочитат индексиране, базирано на 0.

Освен това вземете предвид следния често срещан кодов фрагмент:

for i in range(len(li)):
    pass

Можете ли да видите, че ако range() отиде точно до len(li), това ще бъде проблематично? Програмистът ще трябва изрично да извади 1. Това също следва общата тенденция програмистите да предпочитат for(int i = 0; i < 10; i++) пред for(int i = 0; i <= 9; i++).

Ако често извиквате диапазон с начало 1, може да искате да дефинирате своя собствена функция:

>>> def range1(start, end):
...     return range(start, end+1)
...
>>> range1(1, 10)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

public class EmployeeMaster{
    private String employee_id;
    private String first_name;
    private String last_name;
    private List<UserMaster> userMaster = new ArrayList<UserMaster>();

    @OneToMany(fetch = FetchType.LAZY, mappedBy = "employeeMaster")
    @Cascade(value = {CascadeType.SAVE_UPDATE,CascadeType.DELETE_ORPHAN})   
    public  List<UserMaster> getUserMaster() {
        return userMaster;
    }
    public void setUserMaster(List<UserMaster> userMaster) {
        this.userMaster = userMaster;
    }
}

xsession.saveOrUpdate(employeeMaster);

Въпреки че тук има някои полезни алгоритмични обяснения, мисля, че може да помогне да добавите някои прости разсъждения от „реалния живот“ защо работи по този начин, което намерих за полезно, когато представям темата на млади новодошли:

С нещо като "диапазон (1,10)" може да възникне объркване от мисленето, че двойката параметри представлява "начало и край".

Всъщност е старт и "стоп".

Сега, ако беше "крайната" стойност, тогава, да, може да очаквате, че това число ще бъде включено като окончателен запис в поредицата. Но това не е "краят".

Други погрешно наричат ​​този параметър "брой", защото ако някога използвате само "диапазон (n)", тогава той, разбира се, повтаря "n" пъти. Тази логика се разпада, когато добавите началния параметър.

Така че ключовият момент е да запомните името му: „стоп“. Това означава, че това е точката, в която, когато се достигне, итерацията ще спре незабавно. Неследтози момент.

Така че, докато "старт" наистина представлява първата стойност, която трябва да бъде включена, при достигане на стойността "стоп" тя "се прекъсва", вместо да продължи да обработва "и тази" преди да спре.

Една аналогия, която използвах, обяснявайки това на децата, е, че по ирония на съдбата то се държи по-добре от децата! Не спира след както е трябвало - спира незабавно, без да завърши това, което е правил. (Те разбират това ;) )

Друга аналогия - когато карате кола, не подминавате знак за спиране/пропускане/„даване на път“ и в крайна сметка той стои някъде до или зад, твоята кола. Технически все още не сте го достигнали, когато спрете. Не е включено в „нещата, които сте преминали по време на вашето пътуване“.

Надявам се част от това да помогне при обяснението на Pythonitos/Pythonitas!

Изключителните гами имат някои предимства:

От една страна всеки елемент в range(0,n) е валиден индекс за списъци с дължина n.

Също така range(0,n) има дължина n, а не n+1, което би включвал диапазон.

Работи добре в комбинация с нулево индексиране и len(). Например, ако имате 10 елемента в списък x, те са номерирани 0-9. range(len(x)) ви дава 0-9.

Разбира се, хората ще ви кажат, че е по-Pythonic да правите for item in x или for index, item in enumerate(x), а не for i in range(len(x)).

Срязването също работи по този начин: foo[1:4] са елементи 1-3 от foo (имайки предвид, че елемент 1 всъщност е вторият елемент поради индексирането на базата на нула). За последователност и двете трябва да работят по един и същи начин.

Мисля за това като: "първото число, което искате, последвано от първото число, което не искате." Ако искате 1-10, първото число, което не искате, е 11, така че е range(1, 11).

Ако стане тромаво в конкретно приложение, е достатъчно лесно да напишете малка помощна функция, която добавя 1 към крайния индекс и извиква range().

Също така е полезно за разделяне на диапазони; range(a,b) може да се раздели на range(a, x) и range(x, b), докато с включващ диапазон бихте написали x-1 или x+1. Въпреки че рядко се налага да разделяте диапазони, вие сте склонни да разделяте списъци доста често, което е една от причините нарязването на списък l[a:b] да включва a-тия елемент, но не и b-тия. Тогава range със същото свойство го прави добре последователен.

Дължината на диапазона е горната стойност минус долната стойност.

Много е подобно на нещо като:

for (var i = 1; i < 11; i++) {
    //i goes from 1 to 10 in here
}

на език в стил C.

Също като гамата на Ruby:

1...11 #this is a range from 1 to 10

Въпреки това, Ruby разпознава, че много пъти ще искате да включите терминалната стойност и предлага алтернативния синтаксис:

1..10 #this is also a range from 1 to 10

Помислете за кода

for i in range(10):
    print "You'll see this 10 times", i

Идеята е да получите списък с дължина y-x, който можете (както виждате по-горе) да итерирате.

Прочетете документите на python за обхват - те смятат итерацията за цикъл за основна употреба.

По принцип в python range(n) повтаря n пъти, което е от изключителен характер, поради което не дава последна стойност, когато се отпечатва, можем да създадем функция, която дава включваща стойност, което означава, че ще отпечата и последната стойност, спомената в диапазона.

def main():
    for i in inclusive_range(25):
        print(i, sep=" ")


def inclusive_range(*args):
    numargs = len(args)
    if numargs == 0:
        raise TypeError("you need to write at least a value")
    elif numargs == 1:
        stop = args[0]
        start = 0
        step = 1
    elif numargs == 2:
        (start, stop) = args
        step = 1
    elif numargs == 3:
        (start, stop, step) = args
    else:
        raise TypeError("Inclusive range was expected at most 3 arguments,got {}".format(numargs))
    i = start
    while i <= stop:
        yield i
        i += step


if __name__ == "__main__":
    main()

Просто е по-удобно да се разсъждава в много случаи.

По принцип можем да мислим за диапазон като интервал между start и end. Ако start <= end, дължината на интервала между тях е end - start. Ако len действително беше дефинирано като дължина, ще имате:

len(range(start, end)) == start - end

Ние обаче броим целите числа, включени в диапазона, вместо да измерваме дължината на интервала. За да запазим горното свойство вярно, трябва да включим една от крайните точки и да изключим другата.

Добавянето на параметъра step е като въвеждане на единица за дължина. В такъв случай бихте очаквали

len(range(start, end, step)) == (start - end) / step

за дължина. За да получите броя, просто използвате целочислено деление.

range(n) в python се връща от 0 до n-1. Съответно range(1,n) от 1 до n-1. Така че, ако искате да пропуснете първата стойност и да получите и последната стойност (n), можете да го направите много просто, като използвате следния код.

for i in range(1, n + 1):
        print(i) #prints from 1 to n