Числовые последовательности для цикла Python
Если вам нужно перебрать последовательность чисел, в этом вам поможет встроенная функция range() . Эта функция генерирует арифметические прогрессии:
>>> for i in range(5): . print(i) . 0 1 2 3 4 >>>
В примере выше, указанный аргумент range() число 5 — конечная точка, никогда не является частью сгенерированной последовательности. Например, range(10) генерирует 10 значений, для элементов последовательности длиной 10, проще для понимания от 0 до 9. В классе range() можно менять диапазон, указывая начальное значение, отличное от 0 или указать другое приращение последовательности (задать «шаг»), даже отрицательное:
range(5, 10) 5, 6, 7, 8, 9 range(0, 10, 3) 0, 3, 6, 9 range(-10, -100, -30) -10, -40, -70
Чтобы перебрать индексы последовательности, вы можете комбинировать range() ]f-range и len() следующим образом:
>>> a = ['Mary', 'had', 'a', 'little', 'lamb'] >>> for i in range(len(a)): . print(i, a[i]) . 0 Mary 1 had 2 a 3 little 4 lamb >>>
В большинстве таких случаев удобно использовать функцию enumerate() .
Странная вещь происходит, если вы просто распечатаете range(10) :
>>> print(range(10)) range(0, 10) >>>
Во многих отношениях возвращаемый объект range() ведет себя так, как будто это список, но на самом деле range() не создает список. Это объект, который возвращает элементы желаемой последовательности, только тогда, когда вы выполняете итерацию, тем самым экономя оперативную память.
Мы говорим, что такой объект является итеративным, то есть пригодным для функций или конструкции, которые ожидают что-то, из чего они могут получать последовательные элементы до тех пор, пока они не закончатся. Выше мы видели, что оператор for является такой конструкцией, а примером функции принимающей итеративный объект, является sum() :
>>> sum(range(4)) # 0 + 1 + 2 + 3 6 >>>
Позже мы увидим больше функций, которые возвращают итерируемые значения и принимают их как аргументы. И наконец, может быть, вам интересно, как получить список list() из диапазона range ?
>>> list(range(4)) [0, 1, 2, 3] >>>
Примеры использования:
>>> list(range(10)) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> list(range(1, 11)) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] >>> list(range(0, 30, 5)) [0, 5, 10, 15, 20, 25] >>> list(range(0, 10, 3)) [0, 3, 6, 9] >>> list(range(0, -10, -1)) [0, -1, -2, -3, -4, -5, -6, -7, -8, -9] >>> list(range(0)) [] >>> list(range(1, 0)) []
- ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
- Проверка условий, конструкция if/elif/else
- Конструкция if/else в одну строку
- Имитация оператора switch/case
- while, цикл по условию
- Цикл for
- Числовые последовательности для цикла Python
- Практическое применение for/in/else циклов
- Инструкции break, continue и блок else в циклах Python
- Оператор pass
- Конструкция match/case, сопоставление с образцом
Sequence (последовательность)
Последовательности могут быть как изменяемыми, так и неизменяемыми. Размерность и состав созданной однажды неизменяемой последовательности не может меняться, вместо этого обычно создаётся новая последовательность.
Последовательности поддерживают сравнение (обычно производится лексикографически).
Пользовательские последовательности подчиняются Протоколу последовательностей.
Примеры последовательностей в стандартной библиотеке:
| Список (list) | изменяемая |
| Кортеж (tuple) | неизменяемая |
| Диапазон (range) | неизменяемая |
| Строка (str, unicode) | неизменяемая |
| Массив (array.array) | изменяемая |
Адресация элементов
Доступ к значениям последовательностей производится при помощи индексов — целых чисел, означающих позиций элементов.
Нумерация индексов начинается с 0 (нуля).
Если по указанному индексу значение отсутствует, возбуждается исключение IndexError.
my_tuple = (1, 2, 3)
my_tuple[0] # 1
my_tuple[10] # IndexError
Сравнение последовательностей
При сравнение используется лексикографический порядок, сравниваются два элемента, идущих друг за другом, начиная с первого. Вложенные последовательности одинакового типа сравниваются рекурсивно. Последовательности равны, если их элементы равны.
+py3.0 При лексикографическом сравнении для строк используются номера кодовых точек Юникода.
(1, 2, 3) < (1, 2, 4)
[1, 2, 3] < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4) < (1, 2, 4)
(1, 2) < (1, 2, -1)
(1, 2, 3) == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab')) < (1, 2, ('abc', 'a'), 4)
# Python 2
[1, 'two'] < ['two', 1] # True
# Python 3
[1, 'two']
На заметку
Сравнение различных типов внутри последовательности (при помощи > и <) поддерживается, если для типов определены методы сравнения. В противном случае возбуждается TypeError (до +py3.0 порядок был произвольным, типы сравнивались по имени — list < str < tuple и т.д.). Например, численные типы сравниваются по их численному значению, то есть как 0==0.00 .
Проход по элементам
Проход по элементам последовательности производится при помощи for in:
for item in [1, 2, 3]:
print(item)
Количество элементов
Количество элементов в последовательности можно получить, используя функцию len().
len([1, 2, 3]) # 3
Слияние (конкатенация)
Конкатенация двух последовательностей производится при помощи + .
a = [3, 2, 1]
b = [4, 5, 6]
a + b # [3, 2, 1, 4, 5, 6]
Повторение
Повторение (множение) элементов последовательностей производится при помощи * .
a = [1] * 5
a # [1, 1, 1, 1, 1]
b = [1, 2] * 3
b # [1, 2, 1, 2, 1, 2]
Рекомендуемые методы
Пользовательским последовательностям по примеру таковых же из стандартной библиотеки рекомендуется реализовать следующие методы.
| Базовые | __contains__(), __iter__() |
| Для изменяемых последовательностей | append(), count(), extend(), index(), insert(), pop(), remove(), reverse(), sort() |
| Для поддержки слияния и повторения | __add__(), __iadd__(), __imul__(), __mul__(), __radd__(), __rmul__() |
На заметку
Для перегрузки математических операций (умножение — повторение, а сложение — конкатенация) следует использовать только указанные методы. Прочие методы для работы с числами реализовываться не должны.
Синонимы поиска: Sequence (последовательность), последовательность, последовательности
Статьи раздела
| list (список) | Список — изменяемая последовательность с упорядоченными элементами. |
| range (диапазон) | Диапазон — неизменяемая последовательность целых чисел. |
| sequence.index | Ищет указанное значение в последовательности. |
| str (строка) | Строка — базовый тип представляющий из себя неизменяемую последовател… |
| tuple (кортеж) | Кортеж — неизменяемая последовательность с упорядоченными элементами. |
| xrange | Диапазон — неизменяемая последовательность целых чисел. |
Последовательности
Операторы внутри цикла (что нужно повторить) пишут с отступом.
4 раза напечатать Hello:
for x in range(4): print('Hello') # Output: # Hello # Hello # Hello # Hello for переменная in последовательность : — это оператор python, который перебирает по 1 элементу из последовательности и записывает ее в переменную.
x — имя переменной. Может быть любое.
range — функция python. Она возвращает последовательность целых чисел.
Не забудьте поставить двоеточие :
for x in range(4): print(x) # Output: # 0 # 1 # 2 # 3 range(4) вернет последовательность из 0, 1, 2, 3. То есть 4 целых числа, от 0 (включая) до 4 (не включая).
Чтобы напечатать эти числа в 1 строку, будем ставить после каждого числа пробел. В функции print укажем end=’ ‘ (в конце ставить пробел, а не символ новой строки, как обычно).
for x in range(4): # переменная х равна по очереди 0 1 2 3 print(x, end=' ') # печатаем значение х и пробел print() # ПОСЛЕ цикла 1 раз печатаем \n (символ новой строки) # Output: # 0 1 2 3 Функция range(3, 10) вернет последовательность чисел от 3 (включая) до 10 (НЕ включая):
for x in range(3, 10): # переменная х равна по очереди 3 4 5 6 7 8 9 print(x, end=' ') # печатаем значение х и пробел print() # печатаем символ новой строки \n # Output: # 3 4 5 6 7 8 9 Третий аргумент функции range — на сколько увеличить число: Функция range(3, 10, 2) вернет последовательность чисел от 3 (включая) до 10 (НЕ включая) +2 каждый раз:
for x in range(3, 10, 2): # переменная х равна по очереди 3 5 7 9 print(x, end=' ') # печатаем значение х и пробел print() # печатаем символ новой строки \n # Output: # 3 5 7 9 читаем и печатаем много чисел
Даны 2 целых числа. 1 число на 1 строке. Нужно прочитать эти числа и напечатать их.
x = int(input()) # читаем первую строку, преобразуем ее к целому числу y = int(input()) # читаем вторую строку, преобразуем ее к целому числу print(x) # печатаем число print(y) # печатаем число # Input: # 3 # 5 # Output: # 3 # 5 Если числа заданы на одной строке через пробел, то их читаем так:
x, y = map(int, input().split()) print(x) print(y) # Input: # 3 5 # Output: # 3 # 5 Похоже можно прочитать много чисел на строке через пробел:
a = map(int, input().split()) for x in a: print(x) # Input: # 3 5 -2 7 1 # Output: # 3 # 5 # -2 # 7 # 1 Разберем этот код:
- input() — прочитать строку ‘3 5 -2 7 1’
- input().split() — разбить прочитанную строку по пробельным символам на строки, получится список строк; [‘3’, ‘5’, ‘-2’, ‘7’, ‘1’]
- map(функция, последовательность) — применить функцию к каждому элементу последовательности, вернуть полученную последовательность. Тут получили последовательность чисел 3 5 -2 7 1. Переменная a ссылается на эту последовательность.
К полученной последовательности можно применить оператор for..in
Генераторы — 1 раз
Генераторы — это последовательности, по которым можно пройти только один раз.
a = map(int, input().split()) for x in a: # первый цикл по map print(x) print('---') # печатаем --- чтобы отделить данные первого цикла от второго for x in a: # второй цикл по той же map, map теперь пустая print(x) # Input: # 3 5 -2 # Output: # 3 # 5 # -2 # --- Если нужно будет пройти по тем же данным несколько раз, их нужно сохранить в памяти. Например, сделать из последовательности map список list.
a = list(map(int, input().split())) for x in a: # первый цикл по списку list print(x) print('---') # печатаем --- чтобы отделить данные первого цикла от второго for x in a: # второй цикл по тому же списку print(x) # Input: # 3 5 -2 # Output: # 3 # 5 # -2 # --- # 3 # 5 # -2 :question: Зачем нужны последовательности map? Давайте сразу из map делать list.
Список хранит все свои элементы в памяти. Элементы последовательности могут вычисляться только тогда, когда потребуются («ленивые вычисления») и не занимать место в памяти. Полезно, если элементов очень много.
Еще один пример последовательностей, которые хранятся полностью в памяти — строки.
a = 'Hello' for x in a: # первый цикл по строке 'Hello' print(x) print('---') # печатаем --- чтобы отделить данные первого цикла от второго for x in a: # второй цикл по той же строке print(x) # Output: # H # e # e # l # o # --- # H # e # e # l # o Однопроходные алгоритмы
Рассмотрим простые алгоритмы, которые в 1 проход по последовательности чисел вычисляют то, что требуется в задаче.
Сумма
Дано несколько целых чисел на 1 строке через пробел. Найти сумму этих чисел.
Сумму можно найти в один проход по последовательности чисел.
Рассмотрим более простую задачу: найдем сумму чисел 3, 7, -2:
x, y, z = 3, 7, -2 res = x + y + z print(res) Если чисел много, то трудно придумывать имена переменных для каждого числа. Перепишем этот код так, чтобы использовать только 2 переменных. res — сумма, x — очередное слагаемое (а не первое слагаемое).
res = 0 # сначала сумма 0 x = 3 res += x print('x=', x, 'res=', res) # x= 3 res= 3 x = 7 res += x print('x=', x, 'res=', res) # x= 7 res= 10 x = -2 res += x print('x=', x, 'res=', res) # x= -2 res= 8 print(res) # 8 - печатаем ответ задачи Видно, что есть код, который повторяется. Сделаем из него цикл.
Код, который делаем 1 раз, пишем или до или после цикла.
Будем вводить числа с клавиатуры. Все числа на 1 строке через пробел.
a = map(int, input().split()) res = 0 # до цикла сумма равна 0 for x in a: res += x print('x=', x, 'res=', res) print(res) # после окончания цикла печатаем ответ Заметьте, этот код находит сумму любого количества чисел в строке, а не только 3 чисел.
Как мы придумали такой алгоритм?
Представим, что мы уже посчитали сумму последовательности чисел и она хранится в res . Если к последовательности добавить еще одно число (запишем его в x ), то сумма всех чисел станет res = res + x . То есть на каждом шаге цикла нужно прочитать еще одно число и добавить его к сумме.
Чему должны быть равны значения переменных ДО цикла? Представим, что чисел еще нет. Тогда их сумма 0. x до цикла нам не нужен (чисел нет). res до цикла 0.
Запишем этот алгоритм как функцию mysum от последовательности. Функция будет возвращать сумму чисел.
def mysum(a): # создаем функцию mysum res = 0 for x in a: res = res + x print('x=', x, 'res=', res) return res # конец функции mysum a = map(int, input().split()) # читаем числа с клавиатуры print('Сумма равна', mysum(a)) # вызываем функцию mysum Заметим, что функция может находить сумму последовательности любых чисел, а не только целых чисел.
def mysum(a): # создаем функцию mysum res = 0 for x in a: res = res + x print('x=', x, 'res=', res) return res # конец функции mysum a = [3, 7, -2.5, 0.16] # зададим последователность как список чиселё print('Сумма равна', mysum(a)) # вызываем функцию mysum для этого списка # Output: # x= 3 res= 3 # x= 7 res= 10 # x= -2.5 res= 7.5 # x= 0.16 res= 7.66 # Сумма равна 7.66 Максимум
Дана последовательность чисел. Найдем максимальное число.
Сначала напишем функцию max2(x, y) , которая из двух чисел возвращает максимальное.
def max2(x, y): if x > y: return x else: return y Будем думать как в алгоритме с суммой.
Пусть мы нашли максимальное число для последовательности и сохранили его в res . Нам дали еще одно число в переменной x . Тогда максимум из всех чисел — это максимум из res и x . То есть max2(res, x) .
def max2(x, y): # функция max2 - максимум из 2 чисел if x > y: return x else: return y def mymax(a): # функция mymax - максимум в последовательности а res = 0 for x in a: res = max2(res, x) # раньше при добавлении числа в последовательность # его надо было добавить к сумме, # теперь нужно найти максимум из нового числа и максимума предыдущих чисел print('x=', x, 'res=', res) return res a = map(int, input().split()) # читаем числа с клавиатуры print('Максимум равен', mymax(a)) # вызываем функцию mymax Проверяем, как работает программа:
# Input: # 3 -7 12 0 # Output: # x= 3 res= 3 # x= -7 res= 3 # x= 12 res= 12 # x= 0 res= 12 # Максимум равен 12 Проверим еще раз на последовательности отрицательных чисел.
# Input: # -3 -7 -2 -10 # Output: # x= -3 res=0 # x= -7 res=0 # x= -2 res=0 # x= -10 res=0 # Максимум равен 0 Программа работает неправильно. Максимум из отрицательных чисел не может быть 0.
Мы не подумали, чему равен максимум, если чисел нет или оно одно. Если чисел еще нет, то сумма 0, если задано одно число, то сумма равна этому числу.
Если числа не заданы. Максимума у последовательности нет. А у нас в коде написано res = 0 . Ошибка.
Если задано одно число, то это число — миниумум.
Надо научиться писать значение «не число» или брать из последовательности первый элемент.
None — значение, которого нет
В Python есть специальное значение None — «этого значения нет».
Посмотрим в интерпретаторе, как раборать с None :
>>> x = None >>> x >>> print(x) None >>> type(x) >>> x is None True >>> x is not None False >>> x == None True >>> x != None False is None и is not None — правильные проверки на None.
Если х не None, то результаты проверок:
>>> x = 7 >>> x is None False >>> x is not None True >>> x == None False >>> x != None True Перепишем программу, которая находит максимум, через None:
def max2(x, y): # функция max2 - максимум из 2 чисел if x > y: return x else: return y def mymax(a): # функция mymax - максимум в последовательности а res = None # сначала максимума нет (None) for x in a: if res is None: # если максимума еще нет (первое число) res = x # прочитанное число (первое!) - максимум res = max2(res, x) # для первого числа res и x равны print('x=', x, 'res=', res) return res a = map(int, input().split()) # читаем числа с клавиатуры print('Максимум равен', mymax(a)) # вызываем функцию mymax Проверяем, как работает программа:
# Input: # -3 -7 -2 -10 # Output: # x= -3 res= -3 # x= -7 res= -3 # x= -2 res= -2 # x= -10 res= -2 # Максимум равен -2 next(a) — взять следующий элемент последовательности
next(a) — функция языка питон, возвращает следующий элемент в последовательности.
Пусть последовательность — это числа 5, 12, -1. Переберем ее значения, используя функцию next.
>>> a = map(int, input().split()) 5 12 -1 >>> x = next(a) >>> x 5 >>> x = next(a) >>> x 12 >>> x = next(a) >>> x -1 >>> x = next(a) Traceback (most recent call last): File "", line 1, in StopIteration Когда значения в последовательности закончились, функция next не смогла вернуть элемент, и кинула исключение StopIteration . Исключения мы изучим позже.
Перепишем программу поиска максимума через next:
Перепишем программу, которая находит максимум, через None:
def max2(x, y): # функция max2 - максимум из 2 чисел if x > y: return x else: return y def mymax(a): # функция mymax - максимум в последовательности а res = next(a) # пока максимум - первое число в последовательности for x in a: # начинаем перебирать со второго числа, первое уже прочитали! res = max2(res, x) print('x=', x, 'res=', res) return res a = map(int, input().split()) # читаем числа с клавиатуры print('Максимум равен', mymax(a)) # вызываем функцию mymax Проверяем, как работает программа:
# Input: # -3 -7 -2 -10 # Output: # x= -7 res= -3 # x= -2 res= -2 # x= -10 res= -2 # Максимум равен -2 Заметим, что перебирать в for .. in мы начали с числа -7. Число -2 мы взяли из последовательности раньше.
break — закончить цикл
Даны целые числа. Есть ли среди них число 5?
Если числа 5 нет, то нужно перебрать все числа, чтобы узнать это.
Если число 5 нашли, то дальше перебирать не нужно. Мы уже нашли число.
break — закончить цикл (перейти за конец цикла)
a = map(int, input().split()) # прочитали последователность в а for x in a: # для каждого х в этих числах if x == 5: # если x равно 5 print("Есть число 5") # печатаем (один раз!) break # выходим из цикла (чтобы не печатать много раз) print(x) # печатаем каждый раз число х else: # ТОЛЬКО если break не работал print("Нет числа 5") # конец цикла # сюда выйдет break Проверим, как работет программа:
# Input: # 3 7 -2 5 10 -33 5 5 5 # Output: # 3 # 7 # -2 # Есть число 5 Заметим, мы закончили работать на первом числе 5 и следующие числа не печатали.
# Input: # 3 7 -2 0 # Output: # 3 # 7 # -2 # 0 # Нет числа 5 В for . else и while . else часть в else работает, если в цикле не работал break.
continue — продолжить цикл со следующего шага
continue — продолжить цикл со следующего шага.
Даны целые числа. Найдем в них все числа 5.
a = map(int, input().split()) # прочитали последователность в а for x in a: # для каждого х в этих числах print(x) # печатаем каждый раз число х if x != 5: # если x ненужное число continue # пропускаем его и берем другое print("Есть число 5") # печатаем Проверим, как работает программа:
# Input: # 3 5 7 -2 5 # Output: # 3 # 5 # Есть число 5 # 7 # -2 # 5 # Есть число 5 Пользовательский ввод чисел в строку
Функция input() возвращает все в виде строки, поэтому нужно выполнить явную конвертацию, чтобы получить целое число. Для этого пригодится функция int() .
# вывод суммы двух чисел, введенных пользователем
num_1 = int(input("Введите первое число: "))
num_2 = int(input("Введите второе число: "))
print("Тип num_1:", type(num_1))
print("Тип num_2:", type(num_2))
result = num_1 + num_2
print("Сумма введенных чисел:", result)int(string) конвертирует переданную строку в целое число.
Ввода числа float
По аналогии можно использовать функцию float() .
float_1 = float(input("Введите число: "))
print("Тип float_1:", type(float_1))
result = float_1 ** 2
print("Число в квадрате:", result)Введите число: 1.8 Тип float_1: Число в квадрате: 3.24Ввод чисел в строку через пробел
Но что произойдет, если вы не знаете количество элементов ввода?
Предположим, что от пользователя нужно получить список чисел и вернуть их сумму. При этом вы не знаете количество элементов в этом списке. Как же запросить ввод для него?
Для этого можно использовать split и функции map . Метод split() делит введенную строку на список подстрок. После этого map() выполняет функцию int() для каждого элемента списка.
entered_list = input("Введите список чисел, разделенных пробелом: ").split()
print("Введенный список:", entered_list)
num_list = list(map(int, entered_list))
print("Список чисел: ", num_list)
print("Сумма списка:", sum(num_list))Введите список чисел, разделенных пробелом: 1 34 4 6548 Введенный список: ['1', '34', '4', '6548'] Список чисел: [1, 34, 4, 6548] Сумма списка: 6587
- input() возвращает список, содержащий числа, разделенные запятыми.
- split() возвращает список строк, разделенных пробелами.
- map() выполняет операцию int() для всех элементов списка и возвращает объект map .
- list() конвертирует объект map снова в список.
Есть альтернативный способ получить список:
entered_list = input("Введите список чисел, разделенных пробелом: ").split()
num_list = [int(i) for i in entered_list]
print("Список чисел: ", num_list)Обработка ошибок при пользовательском вводе
Часто при конвертации типов возникает исключение ValueError .
Это происходит в тех случаях, когда введенные пользователем данные не могут быть конвертированы в конкретный тип.
Например, пользователь вводит случайную строку в качестве возраста.
num = int(input("Введите возраст: "))Функция int() ожидает целочисленное значение, обернутое в строку. Любое другое значение приводит к ошибке. Вот что будет, если, попробовать ввести «Двадцать»:
Введите возраст: Двадцать --------------------------------------------------------- ValueError Traceback (most recent call last) in ----> 1 num_1 = int(input('Введите возраст: ')) ValueError: invalid literal for int() with base 10: 'Двадцать'Чтобы убедиться, что пользователь вводит только подходящую информацию, нужно обработать массу подобных ошибок. Для этого будем использовать перехват исключений.
try:
num = int(input("Введите число: "))
print("Все верно. Число:", num)
except ValueError:
print("Это не число.")Посмотрим, как ввод «Двадцать» сработает теперь:
Введите число: Двадцать Это не число.В этом примере если пользователь вводит нечисловое значение, то возникает исключение. Однако оно перехватывается инструкцией except , которая в ответ выводит: «Это не число». Благодаря использованию конструкции try-except программа не прекратит работать при некорректном вводе.
Я создал этот блог в 2018 году, чтобы распространять полезные учебные материалы, документации и уроки на русском. На сайте опубликовано множество статей по основам python и библиотекам, уроков для начинающих и примеров написания программ.
Мои контакты: Почта
Python Q https://yandex.ru/q/loves/python Online
Python Q CEO Pythonru admin@pythonru.com https://secure.gravatar.com/avatar/b16f253879f7349f64830c64d1da4415?s=96&d=mm&r=g CEO Pythonru Python Александр Редактор https://t.me/cashncarryhttps://pythonru.com/https://yandex.ru/q/profile/cashnc/ PythonRu.com admin@pythonru.com Alex Zabrodin 2018-10-26 Online Python, Programming, HTML, CSS, JavaScript
