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

Python: разница между range и xrange

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

Что такое range и xrange?

В Python 2.x у нас было два основных метода для генерации списка целых чисел в заданном диапазоне.

Однако в Python 3 xrange() переименован в range().

Следовательно, в Python 3 мы получаем единственную функцию, которая может производить числа из заданного диапазона.

Функция range() в python 3.x — это просто повторная реализация xrange() в python 2.x и она на самом деле работает так же, как xrange.

Если вы используете Python 2.x, тогда разница между xrange() и range () значима для вас.

В чем же была разница в Python 2.x

Две функции диапазона имеют много разных черт. Они могут относиться к производительности, потреблению памяти, скорости и внутреннему дизайну. Каждый из них имеет свою реализацию. Теперь давайте рассмотрим каждое из этих отличий по одному.

Операционная разница

В большинстве случаев и xrange, и range работают одинаково. Они оба дают возможность составить список чисел.

Следовательно, мы можем сказать, что оба схожи с точки зрения функциональности. Давайте сейчас посмотрим несколько примеров:

Выражение range(1, 7, 2) даст результат [1, 3, 5], а xrange(1, 7, 2) — [1, 3, 5]. Следовательно, вы можете сделать вывод, что они имеют сходную схему исполнения и выходные данные.

Возвращаемые значения и тип

Это основной источник различий между функциями xrange и range.

Range() возвращает объект типа list. Например, выражение range(1, 100, 1) создаст диапазон чисел от 0 до 99 и вернет все цифры за один раз.

>>> r = range(1, 100, 1) >>> type(r) >>> len(r) 99

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

Объект xrange допускает итерацию, индексацию и метод len(). Вы можете использовать его в цикле for, чтобы обойти и получать числа в каждой итерации.

>>> xr = xrange(1, 100, 1) >>> type(xr) >>> xr[0] 1 >>> for it in xr: . print(it) . 1 2 3 . 99

Python xrange vs. range — кто быстрее?

У нас есть модуль timeit в Python для захвата времени выполнения любой функции. Мы будем использовать его в нашем тесте и посмотрим, какой из них быстрее.

Мы выполнили range() в нашем тесте три раза, в пример ниже приведен результат и время, которое потребовалось для выполнения:

>>> import timeit >>> timeit.timeit('"-".join(str(num) for num in range(10000))', number=10000) 22.56510010000011 >>> timeit.timeit('"-".join(str(num) for num in range(10000))', number=10000) 22.796818399999893 >>> timeit.timeit('"-".join(str(num) for num in range(10000))', number=10000) 24.003325399999994

Мы снова провели один и тот же тест с xrange() три раза и записали время их выполнения.

>>> timeit.timeit('"-".join(str(num) for num in xrange(10000))', number=10000) 20.672853799999984 >>> timeit.timeit('"-".join(str(num) for num in xrange(10000))', number=10000) 20.471903500000053 >>> timeit.timeit('"-".join(str(num) for num in xrange(10000))', number=10000) 20.15995029999999

Из приведенных выше тестов и результатов вы можете оценить, что xrange быстрее, чем стандартная функция диапазона.

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

Вот некоторые факты для вашей справки:

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

Что предпочесть range или xrange?

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

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

Где предпочтительно использовать xrange()?

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

Где предпочтительно использовать range()?

• Когда вам приходится часто просматривать список, лучше использовать range(). С xrange() было бы непросто создать экземпляр целочисленного объекта для каждого запроса на индексирование.
• Если вы используете небольшой диапазон, то использование функции range() — правильная идея.
• Так как метод range возвращает объект списка, вы можете использовать все его функции. Напротив, xrange предоставляет голый целочисленный объект, который требует индексации.
• Интересно, что если вы хотите, чтобы ваш код Python 2.x был совместим с версией 3.x, вам также следует использовать метод range.

Совместимость Между Python И Xrange

В Python 3.x функция xrange не существует, тогда как она предоставляет функцию range(). Реальность такова, что название «xrange» изменилось на «range» в Python 3.x.

Таким образом, если вы выполните вызов xrange() в Python 3.x, это вызовет приведенную ниже ошибку.

NameError: name ‘xrange’ is not defined

Кроме того, если вы решите импортировать xrange, даже тогда произойдет следующая ошибка.

ImportError: No module named ‘xrange’

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

Python: функция range()

Функция range является одной из встроенных функций, доступных в Python. Он генерирует серию целых чисел, от значения start до stop, указанного пользователем. Мы можем использовать его для цикла for и обходить весь диапазон как список.

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

Существует два варианта функции range() в Python 3. Давайте проверим их синтаксис по одному.

Range(Stop)

Это самая основная форма range(). Требуется один аргумент для указания исключительного (Stop) верхнего предела.

«0» становится отправной точкой для генерации чисел. Смотрите пример ниже.

>>> robj = range(5) >>> for it in robj: . print(it, end = ",") . 0,1,2,3,4,

Посмотрите другой пример. Диапазон со стоп-значением «0» генерирует пустой диапазон, то есть нулевые элементы.

>>> r = range( 0 ) >>> print( r ) range(0, 0) >>> len( r ) 0

Если вы предоставляете нецелочисленное значение остановки, тогда оно вызывает ошибку TypeError.

>>> range(1.1) TypeError: 'float' object cannot be interpreted as an integer

Range(Start, Stop[, Step])

Это немного сложная форма функции range. Здесь вы можете создать серию чисел с общей разницей по вашему выбору.

Вы можете передать следующие три аргумента:

• ‘start’ -> Начальная точка для генерации чисел в range()
• ‘stop’ -> Это точка перед завершением range().
• ‘step’ -> Общая разница или счетчик приращений между двумя значениями

Обратите внимание на следующие моменты при использовании range() с вышеуказанной подписью.

• Значение по умолчанию «step» равно 1. Оно вступает в действие, когда аргумент step отсутствует.
• Нулевое значение для «шага» приводит к ошибке ValueError.
• Нецелое значение вызывает TypeError.
• Ненулевое целочисленное значение шага (> = стоп) по крайней мере вернет диапазон с одним элементом.

Обратите внимание, что функция range принимает только целочисленные аргументы. Чтобы создать диапазон с плавающей точкой, следуйте данному руководству: Генерация плавающего диапазона в Python

Функция Python Range() с примерами

Посмотрите примеры кода ниже, чтобы понять эту функцию немного глубже:

Использование параметров Start, Stop и Step

>>> # Range with two arguments . for it in range(1, 7): . print(it, end = ", ") . 1, 2, 3, 4, 5, 6, >>> >>> # Range with three arguments . for it in range(1, 7, 3): . print(it, end = ", ") . 1, 4, >>>

Использование отрицательных значений start, stop и step

Мы можем передавать отрицательные значения для всех параметров диапазона, таких как аргументы start, stop и step.

В приведенном ниже примере мы предоставляем отрицательное значения для stop и step, чтобы выполнить цикл в обратном направлении.

>>> # Range with -ve values . for it in range(10, -1, -2): . print(it, end = ", ") . 10, 8, 6, 4, 2, 0

Генерация диапазона как арифметический ряд

Давайте создадим арифметический ряд (i = 10, n = 100, d = 10), используя метод range().

>>> list(range( 10, 100, 10 )) [10, 20, 30, 40, 50, 60, 70, 80, 90]

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

Перебор списка с использованием range()

Мы можем использовать функцию Python range() для обхода списка. Смотрите пример ниже.

>>> books = ['python', 'data science', 'machine learning', 'AI', 'deep learning'] >>> size = len(books) >>> for it in range(0, size): . print(books[it]) . python data science machine learning AI deep learning

Преобразовать диапазон в список

Python 3 range() создает объект типа генератора. По ходу цикла он выбирает значения одно за другим, а не получает их все сразу.

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

Смотрите пример ниже.

>>> r = range( 10, 100, 10 ) >>> type( r ) >>> r = list( r ) >>> type( r ) >>> print(r) [10, 20, 30, 40, 50, 60, 70, 80, 90]

Верхний предел range включительно

По умолчанию Python range() по умолчанию исключает последнее число. Следовательно, он всегда игнорирует верхний предел своего вывода.

Однако мы можем внести следующие изменения в наш код, чтобы разрешить это.

• Увеличьте значение stop с помощью счетчика шагов
• Передайте новое значение stop в функцию range()

После внесения вышеуказанных изменений, давайте посмотрим, что происходит:

>>> start = 0 >>> stop = 7 >>> step = 1 >>> >>> stop = stop + step >>> >>> for it in range(start, stop, step): . print(it, end = ", ") . 0, 1, 2, 3, 4, 5, 6, 7

Range Python против Xrange

Мы изложили несколько отличий и некоторые ключевые факты о функциях range и xrange.

В Python 2.x было две функции диапазона: range() и xrange()

• Разница между ними заключается в том, что range() возвращает список, тогда как последний возвращает итератор.

В Python 3.x у нас есть только одна функция range(). Это реализация xrange() из версии 2.x.

• Новая функция range() не возвращает ни список, ни итератор. Он получает новый тип, известный как объект диапазона.
• Мы можем перебирать объект диапазона как список. Но это немного отличается, так как мы не можем нарезать его.
• В отличие от итераторов, которые выдают одно значение за раз, функция range() получает все числа одновременно. Следовательно, он имеет высокие требования к памяти.
• Тем не менее, диапазон работает быстрее с небольшим набором чисел.

# python 2.x >>> type(range(1)) type 'list' >>> type(xrange(10)) class 'xrange' # python 3.x >>> type(range(10)) class 'range'

Использование индекса с результатом работы range Python

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

Поскольку он действует как последовательность, мы можем получить доступ к его элементам, используя индексы. Он допускает как положительные так и отрицательные значения индекса.

# Indexing Python range object >>> print(range(0, 7)[1]) 1 >>> print(range(0, 7)[6]) 6

Объединить вывод двух функций range()

В Python нет встроенной функции для объединения результатов двух результатов range(). Тем не менее, мы все еще можем сделать это.

Существует модуль с именем ‘itertools’, который имеет функцию chain() для объединения двух объектов диапазона.

Смотрите пример ниже.

>>> from itertools import chain >>> merged = chain(range(5), range(10, 15)) >>> for it in merged: . print(it, end = ", ") . 0, 1, 2, 3, 4, 10, 11, 12, 13, 14

В заключение

Вот несколько важных фактов о функции Python range():

• В качестве аргументов допускаются только целочисленные значения.
• Мы не можем предоставить параметр типа string или float внутри функции range().
• Аргументы могут быть либо как положительные так и отрицательные.
• Он не принимает «0» в качестве значения step. Если шаг равен «0», функция генерирует ошибку ValueError.

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

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

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

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

list(range(1,100)) 

Поделиться 18 сентября 2008 в 18:08

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

$ python -m timeit 'for i in range(1000000):' ' pass' 10 loops, best of 3: 90.5 msec per loop $ python -m timeit 'for i in xrange(1000000):' ' pass' 10 loops, best of 3: 51.1 msec per loop 

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

Поделиться 18 сентября 2008 в 22:11

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

xrange(2**32-1, 2**32+1) # When long is 32 bits, OverflowError: Python int too large to convert to C long range(2**32-1, 2**32+1) # OK --> [4294967295L, 4294967296L] 

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

Поделиться 18 сентября 2008 в 18:13

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

Поделиться 18 сентября 2008 в 17:55

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

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

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

print xrange.__doc__ # def doc(x): print x.__doc__ is super useful help(xrange) 

Поделиться 18 сентября 2008 в 17:55

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

Поделиться 07 апреля 2014 в 06:25

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

import timeit t1 = timeit.default_timer() a = 0 for i in xrange(1, 100000000): pass t2 = timeit.default_timer() print "time taken: ", (t2-t1) # 4.49153590202 seconds t1 = timeit.default_timer() a = 0 for i in range(1, 100000000): pass t2 = timeit.default_timer() print "time taken: ", (t2-t1) # 7.04547905922 seconds 

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

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

import timeit t1 = timeit.default_timer() a = 0 for i in xrange(1, 100000000): if i == 10000: break t2 = timeit.default_timer() print "time taken: ", (t2-t1) # 0.000764846801758 seconds t1 = timeit.default_timer() a = 0 for i in range(1, 100000000): if i == 10000: break t2 = timeit.default_timer() print "time taken: ", (t2-t1) # 2.78506207466 seconds 

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

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

Поделиться 22 октября 2016 в 11:34

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

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

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

Поделиться 18 сентября 2008 в 18:44

Это по причинам оптимизации.

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

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

Поделиться 18 сентября 2008 в 17:59

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) , но и сохранит все числа, которые в нем находятся.

[In] range(1,10) [Out] [1, 2, 3, 4, 5, 6, 7, 8, 9] [In] xrange(1,10) [Out] xrange(1,10) 

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

[In] for i in range(1,10): print i [Out] 1 2 3 4 5 6 7 8 9 [In] for i in xrange(1,10): print i [Out] 1 2 3 4 5 6 7 8 9 

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

Поделиться 12 июля 2016 в 00:05

range(): range(1, 10) возвращает список от 1 до 10 чисел и удерживает целый список в памяти.

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

In [1]: range(1,10) Out[1]: [1, 2, 3, 4, 5, 6, 7, 8, 9] In [2]: xrange(10) Out[2]: xrange(10) In [3]: print xrange.__doc__ xrange([start,] stop[, step]) -> xrange object 

Поделиться 23 июня 2015 в 08:16

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

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

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

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

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

Поделиться 06 мая 2015 в 21:57

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

>>> a = range(5) >>> a [0, 1, 2, 3, 4] 

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

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

>>> b = xrange(5) >>> b xrange(5) 

Поделиться 28 февраля 2016 в 09:42

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

import time for x in range(1, 10): t = time.time() [v*10 for v in range(1, 10000)] print "range: %.4f" % ((time.time()-t)*100) t = time.time() [v*10 for v in xrange(1, 10000)] print "xrange: %.4f" % ((time.time()-t)*100) 

$python range_tests.py range: 0.4273 xrange: 0.3733 range: 0.3881 xrange: 0.3507 range: 0.3712 xrange: 0.3565 range: 0.4031 xrange: 0.3558 range: 0.3714 xrange: 0.3520 range: 0.3834 xrange: 0.3546 range: 0.3717 xrange: 0.3511 range: 0.3745 xrange: 0.3523 range: 0.3858 xrange: 0.3997  

range: 0.4172 xrange: 0.3701 range: 0.3840 xrange: 0.3547 range: 0.3830 xrange: 0.3862  

>>> print range.__doc__ range(stop) -> list of integers range(start, stop[, step]) -> list of integers Return a list containing an arithmetic progression of integers. range(i, j) returns [i, i+1, i+2, . j-1]; start (!) defaults to 0. When step is given, it specifies the increment (or decrement). For example, range(4) returns [0, 1, 2, 3]. The end point is omitted! These are exactly the valid indices for a list of 4 elements. >>> print xrange.__doc__ xrange(stop) -> xrange object xrange(start, stop[, step]) -> xrange object Like range(), but instead of returning a list, returns an object that generates the numbers in the range on demand. For looping, this is slightly faster than range() and more memory efficient. 

>>> print(range.__doc__) range(stop) -> range object range(start, stop[, step]) -> range object Return an object that produces a sequence of integers from start (inclusive) to stop (exclusive) by step. range(i, j) produces i, i+1, i+2, . j-1. start defaults to 0, and stop is omitted! range(4) produces 0, 1, 2, 3. These are exactly the valid indices for a list of 4 elements. When step is given, it specifies the increment (or decrement). >>> print(xrange.__doc__) Traceback (most recent call last): File "", line 1, in NameError: name 'xrange' is not defined 

# Python 2.x >>> a = range(10) >>> type(a) >>> b = xrange(10) >>> type(b)

# Python 3.x >>> a = range(10) >>> type(a)

a=0 for i in range(1,100000): a=a+i 

for i in list(range(1,100000)): a=a+i 

$ python -m timeit "for i in xrange(10111):" " for k in range(100):" " pass" 10 loops, best of 3: 59.4 msec per loop $ python -m timeit "for i in xrange(10111):" " for k in xrange(100):" " pass" 10 loops, best of 3: 46.9 msec per loop 

range(stop)

range([start], stop[, step])

 
>>> # 5 чисел начиная с 0 >>> for i in range(5): print(i) 0 1 2 3 4 >>> # числа с 3 до 6 (не включая его) >>> for i in range(3, 6): print(i) 3 4 5 >>> # числа с 4 до 10 (не включая его) с шагом 2 >>> for i in range(4, 10, 2): print(i) 4 6 8 >>> # числа с 0 до -10 (не включая его) с шагом -2 >>> for i in range(0, -10, -2): print(i) 0 -2 -4 -6 -8
А это пример итерации по списку.
 
>>> my_list = ['один', 'два', 'три', 'четыре', 'пять'] >>> my_list_len = len(my_list) >>> for i in range(0, my_list_len): print(my_list[i]) один два три четыре пять
В качестве параметра stop мы передали длину списка (5).
Range полезна в итерации с условиями. Рассмотрим примере песни “99 Bottles of Beer on the Wall…” со следующим кодом:
 
for i in range(99, 0, -1): if i == 1: print('1 bottle of beer on the wall, 1 bottle of beer!') print('So take it down, pass it around, no more bottles of beer on the wall!') elif i == 2: print('2 more bottles of beer on the wall, 2 more bottles of beer!') print('So take one down, pass it around, 1 more bottle of beer on the wall!') else: print(' bottles of beer on the wall, bottles of beer!'.format(i)) print('So take it down, pass it around, more bottles of beer on the wall!'.format(i - 1))
Мы получаем следующий результат:
99 bottles of beer on the wall, 99 bottles of beer! So take one down, pass it around, 98 more bottles of beer on the wall! 98 bottles of beer on the wall, 98 bottles of beer! So take one down, pass it around, 97 more bottles of beer on the wall! 97 bottles of beer on the wall, 97 bottles of beer! So take one down, pass it around, 96 more bottles of beer on the wall! . 3 bottles of beer on the wall, 3 bottles of beer! So take one down, pass it around, 2 more bottles of beer on the wall! 2 more bottles of beer on the wall, 2 more bottles of beer! So take one down, pass it around, 1 more bottle of beer on the wall! 1 bottle of beer on the wall, 1 bottle of beer! So take it down, pass it around, no more bottles of beer on the wall!
Прекрасно! Наконец-то вы видите настоящую силу Python. Если вы еще немного в замешательстве, рекомендую прочитать статью 99 бутылок пива (Википедия).
range против функций xrange в python
Вы должно быть слышали о функции, известной как xrange() . Эта функция представлена в Python 2.x, и была переименована в range() в Python 3.x. Так в чем же разница? В Python 2.x range() создавала список, а xrange() возвращала итератор — объект последовательности. Мы можем увидеть это в следующем примере:
# Python 3.x >>> range(1) range(0, 1) >>> type(range(1)) range'> # Python 2.x >>> range(1) [0] >>> type(range(1)) list'>
В Python 3.x. у функции range() есть свой собственный тип. Говоря языком простых терминов, если вы хотите воспользоваться range() в цикле for , вы сделаете это с легкостью. Однако вы не можете использовать его как объект списка. Например, вы не можете разбить на срезы тип range .
Когда вы используете итератор, каждый цикл оператора for выдает мгновенно последующий номер на лету. В то время как исходная функция range() производит все числа мгновенно, прежде чем цикл for начнет выполняться.
Проблема с исходной функцией range() (в Python 2.x) заключалась в том, что она требовала очень большой объем памяти при создании большого количества чисел. Однако в нем, как правило, можно работать быстрее с небольшим количеством чисел.
Обратите внимание, что в Python 3.x вы все равно можете создать список, передав генератор, возвращенный функции list() . Следующим образом:


Похожие публикации:

Как поставить свои обои на honor
Как сменить регион в google
Какая максимальная скорость ваз 2109
Какие диски подходят на ситроен джампер