В чем разница между функциями range и xrange в Python 2.X?

range создает список, поэтому если вы сделаете range(1, 10000000) , он создаст список в памяти с 9999999 элементами.

xrange — это объект последовательности, который вычисляется лениво.

В Python 3 range делает то же самое, что и xrange в Python, и чтобы получить список, вы должны использовать list(range(. )) .

Посмотрите эту запись, чтобы найти разницу между range и xrange:

range возвращает именно то, что вы думаете: список последовательных целые числа определенной длины, начинающиеся с 0. xrange , однако возвращает «объект xrange» , который очень похож на итератор

range создает список, поэтому, если вы сделаете range (1, 10000000), он создаст список в памяти с 10000000 элементов. xrange — генератор, поэтому он оценивает лениво.

Это дает вам два преимущества:

Вы можете перебирать более длинные списки, не получая MemoryError .
Поскольку каждое число лениво разрешается, если вы прекратите итерацию раньше, вы не будете тратить время на создание всего списка.

При тестировании диапазона против xrange в цикле (я знаю, что должен использовать timeit, но это было быстро взломан из памяти с помощью простого примера понимания списка) Я нашел следующее:

Или, используя xrange в цикле for:

Правильно ли тестируется мой фрагмент? Есть какие-нибудь комментарии по поводу более медленного экземпляра xrange? Или лучший пример 🙂

Range: -range заполнит все сразу. Это означает, что каждое число диапазона будет занимать память.

Xrange: -xrange — это что-то вроде генератора, он появляется, когда вы хотите диапазон чисел, но вы не хотите, чтобы они были сохранены, например, когда вы хотите использовать в for loop.so эффективное использование памяти.

Разница уменьшается для меньших аргументов до range(..) / xrange(..) :

В этом случае xrange(100) эффективнее всего на 20%.

Range генерирует весь список и возвращает его. xrange не делает — генерирует числа в списке по запросу.

Xrange использует итератор (генерирует значения на лету), range возвращает список.

xrange сохраняет только параметры диапазона и генерирует числа по запросу. Однако реализация Python на C в настоящее время ограничивает свои аргументы C longs:

Обратите внимание, что в Python 3.0 есть только range , и он ведет себя как 2.x xrange , но без ограничений на минимальную и максимальную конечные точки.

Я в шоке, никто не читал документ:

Эта функция очень похожа на range() , но возвращает список xrange вместо списка. Это непрозрачный тип последовательности, который выдает те же значения, что и соответствующий список, фактически не сохраняя их все одновременно. Преимущество xrange() перед range() минимально (поскольку xrange() все еще должен создавать значения при запросе их), за исключением случаев, когда на машине с нехваткой памяти используется очень большой диапазон или когда все элементы диапазона никогда не используются (например, когда цикл обычно заканчивается break ).

С помощью документов.

Разница очевидна. В Python 2.x range возвращает список, xrange возвращает объект xrange, который является итеративным.

В Python 3.x range становится xrange Python 2.x, а xrange удаляется.

Помните, используйте модуль timeit , чтобы проверить, какой из небольших фрагментов кода быстрее!

Лично я всегда использую .range() , если только я не имел дело с действительно огромными списками — как вы видите, со временем, для списка из миллиона записей, дополнительные накладные расходы составляют только 0,04 секунды. И как указывает Кори, в Python 3.0 .xrange() исчезнет, а .range() в любом случае даст вам хорошее поведение итератора.

Xrange возвращает итератор и сохраняет только одно число в памяти за раз. Диапазон хранит весь список чисел в памяти.

Это из соображений оптимизации.

Range () создаст список значений от начала до конца (0 .. 20 в вашем примере). Это станет дорогой операцией на очень больших диапазонах.

С другой стороны, xrange () гораздо более оптимизирован. он вычисляет следующее значение только при необходимости (через объект последовательности xrange) и не создает список всех значений, таких как range ().

range (x) возвращает список, созданный в памяти с элементами x.

xrange (x) возвращает объект xrange, который является генератором obj, который генерирует числа по запросу. они вычисляются во время цикла for (Lazy Evaluation).

Для цикла это немного быстрее, чем range () и более эффективно использовать память.

Xrange () и range () в python работают так же, как и для пользователя, но разница возникает, когда мы говорим о том, как выделяется память при использовании обеих функций.

Когда мы используем range (), мы выделяем память для всех переменных, которые он генерирует, поэтому не рекомендуется использовать с большим значением no. переменных, которые будут сгенерированы.

С другой стороны, xrange () генерирует только определенное значение за раз и может использоваться только с циклом for для печати всех требуемых значений.

По требованию к сканированию / печати 0-N предметов, range и xrange работает следующим образом.

Range () — создает новый список в памяти, принимает от 0 до N элементов (всего N + 1) и печатает их. xrange () — создает экземпляр итератора, который просматривает элементы и сохраняет в памяти только текущий обнаруженный элемент, следовательно, все время используя один и тот же объем памяти.

Если требуемый элемент находится в начале списка только тогда, он экономит много времени и памяти.

Кроме того, если do list(xrange(. )) будет эквивалентно range(. ) .

Так что list идет медленно.

Также xrange на самом деле не полностью завершает последовательность

Вот почему это не список, это xrange объект

Все это очень объяснили. Но я хотел увидеть это сам. Я использую python3. Итак, я открыл монитор ресурсов (в Windows!) И сначала выполнил следующую команду:

А затем проверил изменения в памяти «В использовании». Это было незначительно. Затем я запустил следующий код:

И это заняло большой кусок памяти для использования, мгновенно. И я был убежден. Вы можете попробовать это для себя.

Если вы используете Python 2X, то замените «range ()» на «xrange ()» в первом коде, а «list (range ())» на «range ()».

Потратьте некоторое время на Библиотечный справочник. Чем более вы знакомы с ним, тем быстрее вы сможете найти ответы на подобные вопросы. Особенно важны первые несколько глав о встроенных объектах и типах.

Преимущество типа xrange заключается в том, что объект xrange всегда будет занимать один и тот же объем памяти, независимо от размера диапазона, который он представляет. Там нет последовательных преимуществ производительности.

Другой способ найти быструю информацию о конструкции Python — это строка документации и функция справки:

Вы найдете преимущество xrange перед range в этом простом примере:

Приведенный выше пример не отражает ничего существенно лучшего в случае xrange .

Теперь посмотрим на следующий случай, когда range действительно очень медленный по сравнению с xrange .

С range он уже создает список от 0 до 100000000 (отнимает много времени), но xrange является генератором, и он генерирует числа только на основе потребности, то есть, если итерация продолжается.

В Python-3 реализация функциональности range такая же, как и в xrange в Python-2, хотя они покончили с xrange в Python-3

range(x,y) возвращает список каждого числа между x и y, если вы используете цикл for , то range медленнее. На самом деле, range имеет больший диапазон индекса. range(x.y) распечатает список всех чисел между x и y

xrange(x,y) возвращает xrange(x,y) , но если вы использовали цикл for , то xrange быстрее. xrange имеет меньший диапазон индекса. xrange не только распечатает xrange(x,y) , но и сохранит все находящиеся в нем числа.

Если вы используете цикл for , он будет работать

При использовании петель нет большой разницы, хотя есть разница только при печати!

Что ?
range возвращает статический список во время выполнения.
xrange возвращает object (который действует как генератор, хотя он определенно не один), из которого генерируются значения по мере необходимости.

Когда использовать что?

Используйте xrange , если вы хотите сгенерировать список для гигантского диапазона, скажем, 1 миллиард, особенно если у вас есть «чувствительная к памяти система», такая как мобильный телефон.
Используйте range , если вы хотите перебирать список несколько раз.

PS: функция range в Python 3.x == xrange в Python 2.x.

Range возвращает список , а xrange возвращает объект xrange , который занимает одну и ту же память независимо от размера диапазона, как в этом случае только один элемент генерируется и доступен для каждой итерации, тогда как в случае использования диапазона все элементы генерируются одновременно и доступны в памяти.

В некоторых других ответах упоминается, что Python 3 исключил 2.x range и переименовал 2.x xrange в range . Однако, если вы не используете 3.0 или 3.1 (что никто не должен), это на самом деле несколько другой тип.

Объекты Range имеют очень небольшое поведение: они поддерживают только индексацию, итерацию и функцию len .

Однако в 3.2+ range является полной последовательностью — он поддерживает расширенные срезы и все методы collections.abc.Sequence с той же семантикой, что и list . *

И, по крайней мере, в CPython и PyPy (только две реализации 3.2+, которые существуют в настоящее время), он также имеет постоянные реализации методов index и count и оператора in ( до тех пор, пока вы передаете ему только целые числа). Это означает, что писать 123456 in r разумно в 3.2+, в то время как в 2.7 или 3.1 это было бы ужасной идеей.

Чем irange () отличается от range () или xrange ()?

Это позволит нам выполнять итерацию на больших промежутках чисел без прибегая к xrange, который является ленивым списком, а не генератором.

Я не могу понять набор тестов и реализацию, описанную на этой странице. Я знаю, что irange() создает список в памяти (с точки зрения Python 2.7) и range() — генератор. Чем xrange() отличается?

2 ответа

irange() возвращает тип генератора, который может быть повторен только через . Ничего больше. После того, как вы выполните итерацию, генератор будет исчерпан и не может быть повторен снова.

Python 2 xrange() type и Python 3 range() type являются типами последовательностей они поддерживают различные операции, которые поддерживаются и другими последовательностями, такие как отчеты об их длине, проверка на наличие содержимого и индексация:

Вы можете перебирать эти объекты более одного раза:

Вы даже можете использовать reversed() функция для итерации по ним в обратном направлении , эффективно:

Тип Python 3 range() является улучшенной версией xrange() , поскольку он поддерживает больше операций с последовательностями, все еще более эффективен и может обрабатывать значения, выходящие за пределы sys.maxint (что бы быть целым числом long в Python 2).

Он поддерживает нарезку, например, что приводит к созданию объекта new range() для значений нарезки:

Вы можете использовать отрицательные индексы так же, как и с другими последовательностями Python, чтобы получить элементы, считающие с конца:

и тип поддерживает проверку на равенство; два экземпляра range() равны, если они выдают одинаковые значения:

В Python 2 единственным преимуществом генератора irange() является то, что он не страдает от ограничения на недолгий целые числа, которым xrange() подвергается:

irange предоставляет генератор, который не загружает весь результат в память. Скажем, у вас есть range(1, 1000000) в случае, если список 1000000 номеров будет загружен в память, тогда как в случае xrange(1, 1000000) , только одно число будет в памяти одновременно.

В чем разница между функциями range и xrange в Python 2.X?

диапазон создает список, поэтому, если вы делаете range(1, 10000000) он создает список в памяти с 9999999 элементами.

xrange — объект последовательности, который оценивается лениво.

Он должен быть добавлен из подсказки @Thiago, что в python3 диапазон делает эквивалент python xrange

диапазон создает список, поэтому, если вы делаете range(1, 10000000) он создает список в памяти с 9999999 элементами.

xrange ~~— это генератор, поэтому он~~ представляет собой объект последовательности , который оценивается лениво.

Это верно, но в Python 3, .range() будет реализован Python 2. .xrange() . Если вам нужно создать список, вам нужно будет:

Помните, используйте модуль timeit для проверки того, какой из небольших фрагментов кода работает быстрее!

Лично я всегда использую .range() , если только не имею дело с действительно огромными списками — как вы можете видеть, по времени, для списка из миллиона записей, дополнительные накладные расходы составляют всего 0,04 секунды. И, как указывает Кори, в Python 3.0 .xrange() исчезнет, и .range() даст вам хорошее поведение итератора в любом случае.

xrange сохраняет только параметры диапазона и генерирует числа по требованию. Однако реализация C в Python в настоящее время ограничивает свои аргументы на C longs:

Обратите внимание, что в Python 3.0 существует только range , и он ведет себя как 2.x xrange , но без ограничений на минимальные и максимальные конечные точки.

xrange возвращает итератор и сохраняет только один номер в памяти за раз. диапазон сохраняет весь список номеров в памяти.

Проведите некоторое время с Справочник по библиотеке. Чем более вы знакомы с ним, тем быстрее вы сможете найти ответы на такие вопросы. Особенно важны первые несколько глав о встроенных объектах и типах.

Преимущество типа xrange заключается в том, что объект xrange всегда будет взять тот же объем памяти, независимо от размера диапазона, который он представляет. Не существует согласованных преимуществ производительности.

Другим способом поиска быстрой информации о конструкции Python является docstring и help-function:

range() vs xrange() в python:

range() и xrange() — это две функции, которые могут использоваться для повторения определенного количества раз для циклов в Python. В Python 3 отсутствует xrange, но функция диапазона ведет себя как xrange в Python 2. Если вы хотите написать код, который будет работать как на Python 2, так и на Python 3, вы должны использовать range().

range() — возвращает список номеров, созданных с использованием функции range().

xrange() — эта функция возвращает объект-генератор, который может использоваться для отображения чисел только путем циклирования. Только конкретный диапазон отображается по запросу и, следовательно, называется «ленивая оценка».

Оба они реализованы по-разному и имеют разные характеристики, связанные с ними. Точками сравнения являются:

Тип возвращаемого значения Тип использования памяти
объем памяти
Использование
скорость

1. Тип возврата:

range() возвращает — список как возвращаемый тип.

xrange() возвращает — объект xrange().

Выход :

2. Память:

Переменная, сохраняющая диапазон, созданный диапазоном(), занимает больше памяти по сравнению с переменной, сохраняющей диапазон, используя xrange(). Основной причиной этого является тип возвращаемого значения range() — list и xrange() — объект xrange().

Выход :

3. Использование операций:

Когда range() возвращает список, все операции, которые могут быть применены в списке, могут быть использованы на нем. С другой стороны, поскольку xrange() возвращает объект xrange, операции, связанные с списком, не могут быть применены к ним, что является недостатком.

Выход :

4. Скорость:

Из-за того, что xrange() оценивает только объект-генератор, содержащий только те значения, которые требуются ленивой оценкой, поэтому быстрее в реализации, чем range().

В чем разница между функциями range и xrange в Python 2.X?

Я знаю о недостатках range в Python 2.x (он создает список, который неэффективен для больших диапазонов), и это более быстрый аналог итератора xrange . Однако в Python 3.x range является итератором, а xrange отбрасывается. Есть ли способ написать эти два цикла, написанные с помощью Python 2.x и.

Я провел пару тестов и обнаружил, что xrange() -это MUCH быстрее, чем range() (что также подтверждается различными вопросами/ответами): >>> from timeit import timeit >>> timeit(stmt = ‘x = range(1000)’, number = 10000) 0.38216601211680734 >>> timeit(stmt = ‘x =.

В Python 2.x:

range создает список, поэтому, если вы сделаете range(1, 10000000) , он создаст список в памяти с 9999999 элементами.

xrange -это объект последовательности, который лениво вычисляется.

В Python 3:

range делает эквивалент Python 2 xrange . Чтобы получить список, вы должны явно использовать list(range(. )) .
xrange больше не существует.

диапазон создает список, поэтому, если вы сделаете range(1, 10000000) , он создаст список в памяти с 9999999 элементами.

xrange — ~~это генератор, поэтому это~~ объект последовательности, который лениво вычисляет.

Это верно, но в Python 3 range() будет реализован Python 2 xrange() . Если вам действительно нужно сгенерировать список, вам нужно будет сделать:

Помните, что используйте модуль timeit , чтобы проверить, какой из небольших фрагментов кода быстрее!

Лично я всегда использую range() , если только я не имел дело с действительно огромными списками-как вы можете видеть , с точки зрения времени, для списка из миллиона записей дополнительные накладные расходы составляют всего 0.04 секунды. И, как указывает Кори, в Python 3.0 xrange() исчезнет, а range() в любом случае даст вам хорошее поведение итератора.

xrange хранит только параметры диапазона и генерирует числа по требованию. Однако реализация C Python в настоящее время ограничивает свои args C длинными:

xrange возвращает итератор и одновременно сохраняет в памяти только одно число. диапазон сохраняет весь список чисел в памяти.

Потратьте некоторое время на библиотечный справочник . Чем лучше вы с ним знакомы, тем быстрее сможете найти ответы на подобные вопросы. Особенно важны первые несколько глав о встроенных объектах и типах.

Преимущество типа xrange заключается в том, что объект xrange всегда будет занимать один и тот же объем памяти, независимо от размера диапазона, который он представляет. Нет никаких последовательных преимуществ в производительности.

Еще один способ найти быструю информацию о конструкции Python — это docstring и help-функция:

В чем разница между функциями copy.copy и copy.deepcopy в python? >>> copy.deepcopy(li) [1, 2, 3, 4] >>> copy.copy(li) [1, 2, 3, 4] оба делают одно и то же , может ли кто-нибудь сказать, что конкретно делают эти функции

Мне знакома разница между range() и xrange() . Я заметил что-то странное с xrange() : >>> xrange(1,10,2) xrange(1, 11, 2) >>> xrange(1,10,4) xrange(1, 13, 4) Функционально это правильно: >>> for item in xrange(1,10,4): . print item . 1 5 9 >>> Однако, как вы.

Я в шоке, что никто не читал дока :

Эта функция очень похожа на range() , но возвращает объект xrange вместо списка. Это непрозрачный тип последовательности, который дает те же значения, что и соответствующий список, фактически не сохраняя их все одновременно. Преимущество xrange() перед range() минимально (поскольку xrange() все еще должен создавать значения, когда их запрашивают), за исключением случаев, когда на машине с нехваткой памяти используется очень большой диапазон или когда все элементы диапазона никогда не используются (например, когда цикл обычно завершается break ).

range создает список, поэтому, если вы делаете range(1, 10000000), он создает список в памяти с 10000000 элементами. xrange-это генератор, поэтому он оценивает лениво.

Это дает вам два преимущества:

Вы можете перебирать более длинные списки, не получая MemoryError .
Поскольку он лениво решает каждое число, если вы остановите итерацию раньше, вы не будете тратить время на создание всего списка.

Вы найдете преимущество xrange над range в этом простом примере:

Приведенный выше пример не отражает ничего существенно лучшего в случае xrange .

Теперь рассмотрим следующий случай, когда range действительно очень медленный по сравнению с xrange .

С range он уже создает список от 0 до 100000000(отнимает много времени), но xrange -это генератор, и он генерирует числа только в зависимости от необходимости, то есть, если итерация продолжается.

В Python-3 реализация функциональности range такая же, как у xrange в Python-2, в то время как они покончили с xrange в Python-3

Это делается из соображений оптимизации.

range() создаст список значений от начала до конца (0 .. 20 в вашем примере). Это станет дорогостоящей операцией на очень больших диапазонах.

xrange(), с другой стороны, гораздо более оптимизирован. он будет вычислять следующее значение только при необходимости (через объект последовательности xrange) и не создает список всех значений, как это делает range().

range(x,y) возвращает список каждого числа между x и y, если вы используете цикл for , то range работает медленнее. На самом деле, range имеет больший диапазон индексов. range(x.y) выведет список всех чисел между x и y

xrange(x,y) возвращает xrange(x,y) , но если вы использовали цикл for , то xrange быстрее. xrange имеет меньший диапазон индексов. xrange не только распечатает xrange(x,y) , но и сохранит все числа, которые в нем есть.

Если вы используете цикл for , то он будет работать

Нет большой разницы при использовании циклов, хотя есть разница при простой печати!

range(): диапазон(1, 10) возвращает список от 1 до 10 чисел & держите весь список в памяти.

xrange(): как и range(), но вместо возврата списка возвращает объект, который генерирует числа в диапазоне по требованию. Для зацикливания это немного быстрее, чем range(), и более эффективно использует память. xrange() объект как итератор и генерирует числа по требованию.(Ленивая Оценка)

В некоторых других ответах упоминается, что Python 3 исключил 2.x’s range и переименовал 2.x’s xrange в range . Однако, если вы не используете 3.0 или 3.1 (чего не должно быть), на самом деле это несколько другой тип.

Как говорится в документах 3.1:

Объекты диапазона имеют очень слабое поведение: они поддерживают только индексацию, итерацию и функцию len .

Однако в 3.2+ range является полной последовательностью—он поддерживает расширенные срезы и все методы collections.abc.Sequence с той же семантикой, что и list . *

И, по крайней мере, в CPython и PyPy (единственные две реализации 3.2+, которые в настоящее время существуют), он также имеет реализации с постоянным временем методов index и count и оператора in (если вы передаете ему только целые числа). Это означает, что писать 123456 in r разумно в 3.2+, в то время как в 2.7 или 3.1 это была бы ужасная идея.

_{* Тот факт, что issubclass(xrange, collections.Sequence) возвращает True в 2.6-2.7 и 3.0-3.1, является ошибкой , которая была исправлена в 3.2 и не была перенесена обратно.}

range(x) возвращает список, созданный в памяти с элементами x.

xrange(x) возвращает объект xrange, который является генератором, генерирующим числа по требованию. они вычисляются во время for-loop(ленивая оценка).

Для зацикливания это немного быстрее, чем range(), и более эффективно использует память.

При тестировании диапазона против xrange в цикле (я знаю , что должен использовать timeit, но это было быстро взломано из памяти, используя простой пример понимания списка) Я обнаружил следующее:

Или, используя xrange в for loop:

Правильно ли тестируется мой фрагмент кода? Есть какие-либо комментарии по более медленному экземпляру xrange? Или лучший пример 🙂

xrange() и range() в python работают так же , как и для пользователя, но разница возникает, когда мы говорим о том, как выделяется память при использовании обеих функций.

Когда мы используем range(), мы выделяем память для всех переменных, которые он генерирует, поэтому не рекомендуется использовать с большим количеством генерируемых переменных.

xrange(), с другой стороны, генерирует только определенное значение за один раз и может использоваться только с for loop для печати всех требуемых значений.

range генерирует весь список и возвращает его. xrange этого не делает — он генерирует числа в списке по требованию.

xrange использует итератор (генерирует значения на лету), range возвращает список.

Что?
range возвращает статический список во время выполнения.
xrange возвращает object (который действует как генератор, хотя это, конечно, не так), из которого генерируются значения по мере необходимости.

Когда использовать какие?

Используйте xrange , если вы хотите создать список для гигантского диапазона, скажем, 1 миллиард, особенно если у вас есть «memory sensitive system», как сотовый телефон.
Используйте range , если вы хотите повторить список несколько раз.

PS: Python 3.x’s range функция == Python 2.x’s xrange функция.

Все это очень хорошо объяснили. Но я хотел, чтобы он увидел это сам. Я использую python3. Итак, я открыл монитор ресурсов (в Windows!) и сначала выполнил следующую команду:

а затем проверил изменение в памяти ‘In Use’. Это было несущественно. Затем я выполнил следующий код:

И это мгновенно потребовало большого куска памяти для использования. И я был убежден. Вы можете попробовать это сами.

Если вы используете Python 2X, то замените » range() » на » xrange() «в первом коде и» список(range()) » на «range()».

Из справочных документов.

Разница очевидна. В Python 2.x range возвращает список, xrange возвращает объект xrange, который является итерационным.

В Python 3.x range становится xrange из Python 2.x, а xrange удаляется.

Эта функция, по сути, является старой функцией range() , которая была доступна в Python 2.x и возвращает экземпляр объекта list , содержащий элементы в указанном диапазоне.

Однако эта реализация слишком неэффективна, когда дело доходит до инициализации списка с диапазоном чисел. Например, for i in range(1000000) будет очень дорогой командой для выполнения, как с точки зрения использования памяти, так и времени, поскольку она требует хранения этого списка в памяти.

Python 3.x ввел новую реализацию range() (в то время как новая реализация уже была доступна в Python 2.x через функцию xrange() ).

range() использует стратегию, известную как ленивая оценка. Вместо того чтобы создавать огромный список элементов в диапазоне, новая реализация вводит класс range , легкий объект, который представляет необходимые элементы в данном диапазоне, не сохраняя их явно в памяти (это может звучать как генераторы, но концепция ленивой оценки отличается).

В качестве примера рассмотрим следующее:

По требованию для сканирования/печати 0-N элементов диапазон и диапазон xrange работают следующим образом.

range() — создает новый список в памяти, берет от 0 до N элементов(всего N+1) и печатает их. xrange() — создает экземпляр итератора , который сканирует элементы и сохраняет в памяти только текущий обнаруженный элемент, следовательно, все время использует один и тот же объем памяти.

В случае, если требуемый элемент находится в начале списка, только тогда он экономит много времени и памяти.

Разница уменьшается для меньших аргументов до range(..) / xrange(..) :

В этом случае xrange(100) только примерно 20% более эффективен.

Диапазон возвращает список ,в то время как xrange возвращает объект xrange,который занимает одну и ту же память независимо от размера диапазона, так как в этом случае только один элемент генерируется и доступен за итерацию, тогда как в случае использования диапазона все элементы генерируются сразу и доступны в памяти.

Чем в python 2 x отличается range от xrange

В чем разница между функциями range и xrange в Python 2.X?

Чем irange () отличается от range () или xrange ()?

2 ответа

В чем разница между функциями range и xrange в Python 2.X?

В чем разница между функциями range и xrange в Python 2.X?

Похожие вопросы:

Добавить комментарий Отменить ответ