что такое for i in range в питоне

Как работает цикл for в Python

Цикл for в Python используется для повторения оператора или части программы несколько раз. Он часто используется для обхода структур данных, таких как список, кортеж или словарь.

Синтаксис цикла for в Python приведен ниже.

Блок-схема цикла for

Цикл for, использующийся в последовательности

Пример-1: Итерация строки с использованием цикла for.

Пример-2: Программа для печати таблицы с заданным числом.

Пример-3: Программа для печати суммы данного списка.

Цикл for с использованием функции range()

Функция range() используется для генерации последовательности чисел. Если мы передадим диапазон(10), он будет генерировать числа от 0 до 9. Синтаксис функции range() приведен ниже.

Рассмотрим следующие примеры:

Пример-1: Программа для последовательной печати чисел.

Пример – 2: Программа для печати таблицы с заданным номером.

Пример-3: Программа для печати четного числа, используя размер шага в диапазоне().

Мы также можем использовать функцию range() с последовательностью чисел. Функция len() сочетается с функцией range(), которая выполняет итерацию по последовательности с использованием индексации. Рассмотрим следующий пример.

Вложенный цикл for в Python

Python позволяет нам вкладывать любое количество циклов for внутри цикла for. Внутренний цикл выполняется n раз на каждой итерации внешнего цикла. Синтаксис приведен ниже.

Пример – 1: Вложенный цикл for.

Пример-2: Программа числовой пирамиды.

Использование оператора else с циклом for

В отличие от других языков, таких как C, C ++ или Java, Python позволяет нам использовать оператор else с циклом for, который может выполняться только тогда, когда все итерации исчерпаны. Здесь мы должны заметить, что если цикл содержит любой из операторов break, тогда оператор else не будет выполнен.

Цикл for полностью исчерпан, так как нет обрыва.

В приведенном выше примере цикл разорван из-за оператора break; следовательно, оператор else не будет выполняться. Оператор, находящийся рядом с блоком else, будет выполнен.

Цикл прерван из-за того, что оператор break … вышел из цикла. Мы узнаем больше об операторе break в следующем уроке.

Источник

Функция range в Python

Синтаксис

Функцию range() можно использовать с одним или несколькими параметрами. В документации Pyton синтаксис выглядит следующим образом:

class range(stop) # с одним параметров class range(start, stop[, step]) # с несколькими параметрами

У функции 3 параметра:

Функция range() возвращает объект класса range :

☝️ При работе с range() важно помнить следующее:

📃 Более подробное описание функции можно посмотреть в официальной документации или через help(«range») :

for i in range

Основной кейс — выполнение цикла N-раз:

for i in range(3): print(f»iteration #«) > iteration #1 > iteration #2 > iteration #3

С помощью range() можно перебрать все значения в последовательности:

str = ‘abcdef’ for i in range(len(str)): print(str[i], end=’ ‘) > a b c d e f

Или найти сумму первых 10-ти целых чисел.

s = 0 for i in range(11): # от 0 до 9 (11 не входит в последовательность) s += i print(s) > 55

А так можно перебрать значения последовательности через одного:

s = ‘a1b2c3d4e5f6g7h8′ for i in range(0, len(s), 2): print(s[i], end=’ ‘) > a b c d e f g h

С помощью функции range() можно организовать сдвиг букв в слове на одну позицию и получить все возможные варианты такого сдвига:

s = ‘питон’ for i in range(len(s)): s = s[1:] + s[:1] print(s, end=’ ‘) > итонп тонпи онпит нпито питон

Или получить все числа из заданного диапазона, делящиеся на любое нужное. Например, напечатаем таблицу умножения на 8:

count = 1 for i in range(8, 80, 8): print(count, ‘ * 8 = ‘, i) count += 1 > 1 * 8 = 8 > 2 * 8 = 16 > 3 * 8 = 24 > 4 * 8 = 32 > 5 * 8 = 40 > 6 * 8 = 48 > 7 * 8 = 56 > 8 * 8 = 64 > 9 * 8 = 72

Операции с range

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

>>> numbers = range(13) >>> numbers[3] # обращение к конкретному элементу 3 >>> 3 in numbers # проверка на вхождение в диапазон True >>> numbers[:4] # срез диапазона range(0, 4) >>> len(numbers) # длина диапазона 13 >>> min(numbers) # минимальный элемент диапазона 0 >>> max(numbers) # максимальный элемент диапазона 12 >>> numbers = range(0, 13, 2) >>> numbers.index(6) # индекс (позиция) числа в диапазоне 3

Также объект range можно привести к списку ( list ) или множеству ( set ):

>>> numbers = range(13) >>> numbers_list = list(numbers) >>> type(numbers_list) >>> numbers_list [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] >>> numbers_set = set(numbers) >>> type(numbers_set) >>> numbers_set

range и тип float

По умолчанию функция range() позволяет использовать только целые числа в качестве параметров. Если вы передадите значение с плавающей точкой, то Python вызовет исключение TypeError :

numbers = range(1.5) print(numbers) > Traceback (most recent call last): File «test.py», line 1, in numbers = range(1.5) TypeError: ‘float’ object cannot be interpreted as an integer

import numpy as np float_numbers = np.arange(4.6, 5.8, 0.3) print(float_numbers) > [4.6 4.9 5.2 5.5 5.8]

Если вы не хотите устанавливать библиотеку NymPy, то можно написать собственную функцию, например так:

def f_range(start, stop, step): while start [4.6, 4.9, 5.2, 5.5, 5.8]

Отличия между range в python2 и python3

Range() в Python2 и Python3 — это разные функции, которые отличаются друг от друга.

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

Таким образом, xrange() используемая в Python2 и range() в Python3 являются аналогами.

Best Practices

range в обратном порядке (python reverse range)

Получить последовательность в обратном порядке можно с помощью отрицательного аргумента step :

range включительно

По умолчанию, значение из переменной stop не входит в последовательность. Чтобы это исправить, к stop прибавьте step :

step = 2 numbers = range(2, 10 + step, step) for i in numbers: print(i, end=’ ‘) > 2 4 6 8 10

range до бесконечности

Но это можно сделать через itertools :

Или через бесконечный цикл while :

range → в список (list) или множество (set)

С помощью range можно сгенерировать список ( list ):

num_set = list(range(1, 11, 2)) # список целых чисел print(num_set) > [1, 3, 5, 7, 9]

Или сгенерировать множество ( set ):

natural_num_set = set(range(1, 11)) # множество натуральных чисел от 1 до 10 print(natural_num_set) >

Источник

Цикл «for» в Python — универсальная управляющая конструкция

Применение циклов

Концепция циклов — это не просто очередная абстрактная выдумка программистов. Повторяющиеся раз за разом операции окружают нас и в реальной жизни:

🥣 добление щепотки приправ в варящийся бульон и помешивание его до тех пор, пока пакетик специй не закончится,

🕙 следование строгому расписанию каждый будний день, пока не наступят долгожданные выходные,

🌄 даже банальная смена времён год,

— всё это циклы, и представить нормальную жизнь без них попросту невозможно.

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

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

for i in range(1, 10000000000): print(i)

Смысл её крайне прост. В основе цикла for лежат последовательности, и в примере выше это последовательность чисел от 1 до 9999999999. for поэлементно её перебирает и выполняет код, который записан в теле цикла. В частности, для решения данной задачи туда была помещена инструкция, позволяющая выводить значение элемента последовательности на экран.

Итерации

👉 Чтобы выполнить итерацию, Python делает следующее:

Пример создания итерируемого объекта Для того чтобы создать собственный класс итерируемого объекта, нужно всего лишь внутри него реализовать два метода: __iter__() и __next__() :

Создадим простой строковый итератор, который на каждой итерации, при получении следующего элемента (т.е. символа), приводит его к верхнему регистру:

class ToUpperCase: def __init__(self, string_obj, position=0): «»»сохраняем строку, полученную из конструктора, в поле string_obj и задаём начальный индекс»»» self.string_obj = string_obj self.position = position def __iter__(self): «»» возвращаем сам объект «»» return self def __next__(self): «»» метод возвращает следующий элемент, но уже приведенный к верхнему регистру «»» if self.position >= len(self.string_obj): # исключение StopIteration() сообщает циклу for о завершении raise StopIteration() position = self.position # инкрементируем индекс self.position += 1 # возвращаем символ в uppercase-e return self.string_obj[position].upper() low_python = «python» high_python = ToUpperCase(low_python) for ch in high_python: print(ch, end=»») > PYTHON

Синтаксис for

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

В простейшем случае он выглядит так:

for item in collection: # do something

aliceQuote = «The best way to explain it is to do it.» # с помощью цикла for посчитаем количество символов (с пробелами) в строке # зададим счетчик count = 0 # будем посимвольно обходить весь текст for letter in aliceQuote: # на каждой новой итерации: # в переменной letter будет храниться следующий символ предложения; # увеличиваем счетчик на 1; count += 1 print(count) > 39

range() и enumerate()

Вы уже наверняка запомнили, что for работает с последовательностями. В программировании очень часто приходится повторять какую-то операцию фиксированное количество раз. А где упоминается «количество чего-то», существует и последовательность, числовая.

👉 Для того чтобы выполнить какую-либо инструкцию строго определенное число раз, воспользуемся функцией range() :

# скажем Миру привет целых пять раз! for i in range(5): print(«Hello World!») > Hello World! Hello World! Hello World! Hello World! Hello World!

range() можно представлять, как функцию, что возвращает последовательность чисел, регулируемую количеством переданных в неё аргументов. Их может быть 1, 2 или 3:

Здесь start — это первый элемент последовательности (включительно), stop — последний (не включительно), а step — разность между следующим и предыдущим членами последовательности.

# заменим каждый пятый символ предложения, начиная с 0-го, на * text = «Это не те дроиды, которых вы ищете» new_text = «» for char in enumerate(text): if char[0] % 5 == 0: new_text += ‘*’ else: new_text += char[1] print(new_text) > *то н* те *роид*, ко*орых*вы и*ете

break и continue

Два похожих оператора, которые можно встретить и в других языках программирования.

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

# continue for num in range(40, 51): if num == 45: continue print(num) > 40 41 42 43 44 46 47 48 49 50

В случае continue происходит похожая ситуация, только прерывается лишь одна итерация, а сам же цикл продолжается.

group_of_students = [21, 18, 19, 21, 18] for age in group_of_students: if age Всё в порядке, они совершеннолетние

Best practice

Цикл по списку

Перебрать list в цикле не составляет никакого труда, поскольку список — объект итерируемый:

# есть список entities_of_warp = [«Tzeench», «Slaanesh», «Khorne», «Nurgle»] # просто берём список, «загружаем» его в цикл и без всякой задней мысли делаем обход for entity in entities_of_warp: print(entity) > Tzeench Slaanesh Khorne Nurgle

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

Цикл по словарю

Цикл, в таком случае, будет выглядеть следующим образом:

Цикл по строке

Строки, по сути своей — весьма простые последовательности, состоящие из символов. Поэтому обходить их в цикле тоже совсем несложно.

word = ‘Alabama’ for w in word: print(w, end=» «) > A l a b a m a

Как сделать цикл for с шагом

# выведем числа от 100 до 1000 с шагом 150 for nums in range(100, 1000, 150): print(nums) > 100 250 400 550 700 850

Обратный цикл for

Если вы еще не убедились в том, что range() полезна, то вот ещё пример: благодаря этой функции можно взять и обойти последовательность в обратном направлении.

for в одну строку

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

В общем виде генератор выглядит так:

[результирующее выражение | цикл | опциональное условие]

Приведем пример, в котором продублируем каждый символ строки inputString :

# здесь letter * 2 — результирующее выражение; for letter in inputString — цикл, а необязательное условие опущено double_letter = [letter * 2 for letter in «Banana»] print(double_letter) > [‘BB’, ‘aa’, ‘nn’, ‘aa’, ‘nn’, ‘aa’]

Другой пример, но теперь уже с условием:

# создадим список, что будет состоять из четных чисел от нуля до тридцати # здесь if x % 2 == 0 — необязательное условие even_nums = [x for x in range(30) if x % 2 == 0] print(even_nums) [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28]

Источник

Цикл for и функция range в Python

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

1. Цикл for в Python.

>>> cars = [‘ford’, ‘opel’, ‘audi’, ‘land rover’, ‘bmw’]
>>> for brend in cars :
. print(brend) # отступ в 4 пробела
.
ford
opel
audi
land rover
bmw

Функция print выводит свой аргумент, после чего курсор перемещает на следующую строку, но при большом количестве элементов в списке, не всегда это удобно. Можно воспользоваться аргументом end, записав его после переменной.

>>> cars = [‘ford’, ‘opel’, ‘audi’, ‘land rover’, ‘bmw’]
>>> for brend in cars :
. print(brend, end=’ ‘) # отступ в 4 пробела
.
ford opel audi land rover bmw

Во время цикла for помимо вывода элементов, с ними можно выполнять различные действия. К примеру, можно выводить сообщения с каждым проходом цикла, для этого воспользуемся f-строками.

>>> cars = [‘ford’, ‘opel’, ‘audi’, ‘land rover’, ‘bmw’]
>>> for brend in cars :
. print(f»Автомобили торговой марки очень надежные»)
.
Автомобили торговой марки Ford очень надежные
Автомобили торговой марки Opel очень надежные
Автомобили торговой марки Audi очень надежные
Автомобили торговой марки Land Rover очень надежные
Автомобили торговой марки Bmw очень надежные

Со строками цикл for работает также как и со списком.

В Python связь одной строки кода с предшествующей строкой обозначается отступами. В больших программах встречаются блоки кода с отступами в несколько разных уровней. Благодаря отступам, сильно упрощается чтение кода. Основные ошибки как раз и складываются из ошибок в пропущенных или лишних отступах.

>>> mesage = ‘Hello World!’
>>> for i in mesage :
. print(i * 5, end=’ ‘) # нет отступа в 4 пробела
File » «, line 2
print(i * 5, end=’ ‘)
^
IndentationError: expected an indented block

Для устранения этой ошибки, достаточно поставить в следующей строке после команды for 4 пробела. В основном, если вы работаете в любом современном текстовом редакторе, то после двоеточия он сам поставит отступы на следующей строке.

Встроенная функция range() используется для построения числовых последовательностей. В примере используем команду for и функцию range для выполнения ровно 10 итераций с выводом значения от 0 до 10.

>>> for x in range(10) :
. print(x, end=’ ‘)
.
0 1 2 3 4 5 6 7 8 9

При передаче только одного аргумента, последовательность будет начинаться с 0 и до значения аргумента (10), не включая его. Одна из самых распространённых ошибок, это когда разработчик предполагает, что значение аргумента функции range включается в сгенерированную последовательность.

Приведем пример с двумя аргументами. Выведем последовательность от 20 до 30.

>>> for x in range(20, 30) :
. print(x, end=’ ‘)
.
20 21 22 23 24 25 26 27 28 29

>>> numbers = list( range(5, 25) )
>>> print(numbers)
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]

>>> numbers = list( range(0, 100, 15) )
>>> print(numbers)
[0, 15, 30, 45, 60, 75, 90]

>>> a = []
>>> for i in range(1, 11) :
. a.append(i**2)
.
>>> print(a)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

На каждом цикле переменная возводится в квадрат и добавляется в список.

2.4. Перебор списка по индексам с помощью функции range

С помощью цикла for и функции range список можно перебирать по индексам и с каждым значением в списки, производить любые операции. Приведем пример, перебора списка по индексам, с помощью функции range и функции len, которая определяет длину списка.

>>> list_1 = [1, 3, 5, 10, 12, 20]
>>> for index in range ( len (list_1)):
. list_1[ index ] += 100
.
>>> print(list_1)
[101, 103, 105, 110, 112, 120]

С помощью индексов и функции range мы можем объединять информацию из разных списков. В примере ниже мы имеем список с именами, а второй список с фамилиями. Выведем на экран имя и фамилию:

>>> list_4 = [‘Artem’, ‘Serg’, ‘Georgy’, ‘Petr’]
>>> list_5 = [‘Ivanov’, ‘Petrov’, ‘Sidorov’, ‘Ulyanov’]
>>> for index in range ( len (list_4)):
. print(list_4[ index ], list_5[ index ])
.
Artem Ivanov
Serg Petrov
Georgy Sidorov
Petr Ulyanov

В результате получили общие данные на экране.

Аналогично можно создавать новые списки из двух или трех списков. Приведем пример перемножения трех списков:

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

Состоящий выше пример построения квадратов чисел в разделе 2.2 состоял из нескольких строк кода. Генератор списка позволяет сгенерировать тот же список, но всего в одной строке. Определите название списка, после откройте квадратные скобки. Запишите выражение для значений, в нашем случает i ** 2. Затем напишите цикл for для генерирования чисел, которые будут передаваться выражению и закройте квадратные скобки.

>>> a = [i ** 2 for i in range(1,11)]
>>> print(a)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Источник

Функция range() в Python

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

К концу данного руководства вы будете:

История range()

Несмотря на то, что range() в Python 2 и range() в Python 3 носят одинаковое название, они кардинально отличаются между собой. Фактически, range() в Python 3 – это просто переименованная версия функции под названием xrange в Python 2.

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Паблик VK

Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!

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

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

Обратите внимание: PEP означает Python Enhancement Proposal. Это документы, которые покрывают большое количество тем, включая недавно предоставленные новые функции, стили, философию и руководства.

Циклы

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

Рассмотрим пример цикла for в Python:

Выдача выглядит следующим образом:

Как вы видите, цикл for позволяет вам выполнять определенные части кода, столько раз, сколько вам угодно. В данном случае, мы зациклили список капитанов и вывели имена каждого из них.

Хотя Star Trek — отличная тема и все такое, вам может быть нужен более сложный цикл, чем список капитанов. Иногда вам нужно просто выполнить часть кода определенное количество раз. Циклы могут помочь вам с этим.

Попробуйте запустить следующий код с числами, кратными трем:

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

Это выдача, которая нам нужна, так что можем сказать, что цикл выполнил работу адекватно, однако есть еще один способ получения аналогично результата: использование range().

Обратите внимание: Последний пример кода содержит определенное форматирование строк. Чтобы узнать больше об этой теме, перейдите на статью F-Строки в новой версии Python.

Теперь, когда вы знакомы с циклами поближе, посмотрим, как вы можете использовать range() для упрощения жизни.

Введение в range()

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

Вот небольшой пример range() в действии:

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

Обратите внимание: хотя в этом примере показано надлежащее использование range(), его слишком часто приводят для использования в циклах.

Например, следующее использование range() едва ли можно назвать Питоническим (это плохой пример):

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

Есть три способа вызова range():

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

Как это выглядит на практике:

Выдача вашего цикла будет выглядеть так:

Проверим: у нас есть все числа от 0 до, но не включая 3 — числа, которое вы указали как конечное.

range(старт, стоп)

Вызывая range() с двумя аргументами, вам нужно решить не только, где ряд чисел должен остановиться, но и где он должен начаться, так что вам не придется начинать с нуля каждый раз. Вы можете использовать range() для генерации ряда чисел, начиная с А до Б, используя диапазон (А, Б). Давайте узнаем, как генерировать диапазон, начинающийся с 1.

Попробуем вызывать range() с двумя аргументами:

Ваша выдача будет выглядеть следующим образом:

Отлично: у вас есть все числа от 1 (число, которые вы определили как стартовое), до, но не включая, 8 (число, которые вы определили как конечное).

Но если вы добавите еще один аргумент, то вы сможете воспроизвести ранее полученный результат, когда пользуетесь списком под названием numbers_divisible_by_three.

range(старт, стоп, шаг)

Вызывая range() с тремя аргументами, вы можете выбрать не только то, где ряд чисел начнется и остановится, но также то, на сколько велика будет разница между одним числом и следующим. Если вы не задаете этот «шаг», то range() автоматически будет вести себя так, как если бы шаг был бы равен 1.

Обратите внимание: шаг может быть положительным, или отрицательным числом, но он не может равняться нулю:

Если вы попробуете использовать 0 как шаг, вы получите ошибку ValueError.

Теперь, так как вы знаете, как использовать шаг, вы можете снова использовать цикл, который мы видели ранее, с числами, кратными 3.

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

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

Инкрементация с range()

Если вы хотите выполнить инкрементацию, то вам нужно, чтобы шаг был положительным числом. Чтобы понять, что под этим имеется ввиду, введите следующий код:

Если ваш шаг равен 25, то выдача вашего цикла будет выглядеть вот так:

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

Теперь, так как вы увидели то, как именно вы можете продвигаться вперед по диапазону, настало время узнать, как двигаться в обратную сторону.

Декрементация с range()

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

В следующем примере ваш шаг будет -2. Это значит, что декрементация будет равна 2 для каждого цикла:

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

У вас есть ряд чисел, каждое из которое меньше предшествующего на 2, т. е., на абсолютное значение предоставленного вами шага.

Самый правильный способ создание диапазона декрементации, это использовать range(старт, стоп, шаг). При этом в Python есть встроенная обратная функция. Если вы завернете range() в reversed(), то вы сможете выводить целые числа в обратном порядке.

Вы получите следующее:

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

Обратите внимание: reversed() также работает со строками.

Углубляемся в range()

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

Как правило, range() используется в двух случаях:

Первое использование можно назвать самым простым, и вы можете сделать так, чтобы itertools дал вам более эффективный способ построения итераций, чем это может сделать range().

Вот еще несколько моментов, которые стоит учитывать при использовании range.

Вы можете получить доступ к объектам в range() по индексу, как если бы вы имели дело со списком:

Вы даже можете использовать срез в range(), но выдача в REPL может показаться немного странной, на первый взгляд:

Хотя эта выдача может выглядеть необычно, range() просто возвращает еще одну range().

Тот факт, что вы можете использовать элементы range() по индексу и фрагменту range() указывает на важный момент: range() весьма ленивый, в отличие от списка, но не является итератором.

float и range()

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

float

В Python, если число не является целым, оно является десятичным. Есть несколько различий между целыми и десятичными числами.

Целое число (тип данных int):

Десятичное число (тип данных float):

Попробуйте вызвать range() с десятичным числом и увидите, что будет:

Вы увидите следующее уведомление об ошибке TypeError:

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

Использование NumPy

NumPy – это сторонняя библиотека Python. Если вы собираетесь ее использовать, сначала вам нужно убедиться в том, что она установлена.

Как это сделать при помощи REPL:

Если вы получите ошибку ModuleNotFoundError, то вам нужно провести установку numpy. Чтобы сделать это, перейдите в командную строку и введите:

После установки, внесите следующее:

Если вы хотите вывести каждое число на свою строку, вы можете сделать следующее:

Выдача будет следующей:

Но откуда взялось число 0.8999999999999999?

У компьютеров есть проблемы с сохранением десятичных чисел с запятой в двоичные числа с запятой. Это приводит к разным неожиданным представлениям этих чисел.

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

Еще один вариант – использовать round(). Помните, что round() содержит собственные нюансы, которые могут приводить к неожиданным результатам!

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

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

Итоги

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

Являюсь администратором нескольких порталов по обучению языков программирования Python, Golang и Kotlin. В составе небольшой команды единомышленников, мы занимаемся популяризацией языков программирования на русскоязычную аудиторию. Большая часть статей была адаптирована нами на русский язык и распространяется бесплатно.

E-mail: vasile.buldumac@ati.utm.md

Образование
Universitatea Tehnică a Moldovei (utm.md)

Источник