Скачать ipynb
03_python_1

Python для анализа данных

1. Язык Python

При программировании на питоне первые полезные результаты начинают получаться минут через 5 после начала работы над проектом. Не надо изобретать никаких велосипедов: всё, что может понадобиться, доступно или в стандартной библиотеке, или в одном из многочисленных дополнительных пакетов. Программы получаются элегантные и лаконичные, их легко и приятно писать и читать. Имеется широкий выбор высококачественных инструментов программиста: интегрированные среды разработки, отладчики и средства тестирования и т.д. Питон прекрасно приспособлен для написания больших и сложных программных комплексов. И всё это совершенно не зависит от железа и операционной системы. Конечно, если не вызывать низкоуровневых системно-зависимыех библиотек.

Главный минус — питон, мягко говоря, не славится потрясающим быстродействием. Писать программы сложных вычислений на питоне, конечно, глупо. Но есть ряд способов обойти это ограничение. Если программа занимается регулярной обработкой больших массивов чисел с плавающей точкой, то использование numpy радикально повышает её быстродействие. Пакет numpy и его расширение scipy фактически делают matlab ненужным — дают ту же функциональность с более приятным языком программирование. Есть ряд пакетов для построения высококачественных графиков, например, matplotlib. Другое средство повышения быстродействия — cython. Пишется программа, выглядящая почти как питонская, но со вставленными статичестими декларациями типов. cython транслирует её в исходный код на C, что часто даёт быстродействие, сравнимое с вручную написанным C. Программа на cython-е может свободно вызывать функции из библиотек на C; её можно использовать из обычного питона. Ну и наконец можно написать критически важные для быстродействия системы в целом вычисления на другом языке (C например), и вызывать эти внешние программы из питона. Питон при этом выполняет роль клея — реализует логику высокого уровня, системно-независимый GUI и т.д.

Питон — сильно типизированный язык с динамической типизацией. Всё, с чем работает программа — объекты; каждый из них принадлежит определённому типу. Если программа пытается выполнить какую-то операцию над объектом такого типа, который не поддерживает эту операцию, произойдёт ошибка времени выполнения. Описаний переменных в питоне нет. Одна и та же переменная может в разные моменты иметь значения — объекты разных типов. Ошибка в типах может проявиться много времени спустя после того, как программа сдана в эксплуатацию, особенно если она происходит в редко используемом участке кода. Язык допускает ситуацию, когда мы сначала присвоим какой-то переменной целое число, потом строку, потом ещё что-то, но это плохой стиль. Переменная заводится для одного конкретного использования, и естественно, чтобы её значения в любой момент подходили для этого использования и имели одинаковый тип. В исходный текст на питоне 3.5 можно включить (необязательные) аннотации типов переменных и функций, и прогнать её через программу статической проверки типов.

Питонячий стиль кода

Обязательно прочитайте инструкцию по стилю кода: http://pep8.ru/doc/pep8/

Желательно соблюдать стиль кода. Курсы Физтех.Статистики не являются курсами по программированию, поэтому полное соблюдение стиля не требуется. Перечислим кратко основные правила:

  • Отступы составляют ровно 4 пробела, табуляции не используются. К слову, в Питоне нет ключевых слов по типу { и } в C и begin и end в Паскале. Блоки кода разделяются пробелами.
  • Все переменные должны иметь понятные названия и состоять только из строчных букв. Например, вместо того, чтобы назвать выборку как X, лучше назвать ее sample. В качестве разделителей используйте подчеркивания. В редких случаях можно и отступать от этого правила, если обозначения понятны из решаемой задачи.
  • Вокруг всех знаков арифметических операций, присваивания и пр. обязательны пробелы с двух сторон. Исключение — запись вида a=b в аргументах функции. Примеры будут далее.
  • Разделяйте логические куски программы пустыми строками. Врядли вы сможете написать код строк на 10-15, в который нельзя вставить ни одну пустую строку, разделяющую код на логические части. ПЕРЕД всеми логическими кусками кода должен быть комментарий к этому куску кода.
  • Все функции (кроме самых маленьких) должны содержать подробную документацию, написанную по правилам оформления документаций.
  • Если комментарий дается на строке с кодом, то оформить его стоит так:

код [ровно 2 пробела] # [ровно 1 пробел] комментарий

  • Если комментарий дается на отдельной строке, то он должен иметь тот же отступ, что и строка кода под ним. Скорее всего перед таким комментарием можно вставить пустую строку.
  • Не нужно комментировать очевидное.
  • Не нужно писать весь код в одной ячейке ноутбука!!!
  • Если есть возможность, при выводе десятичных чисел следует оставлять разумное число знаков после запятой.

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

2. Числа

Арифметические операции имеют ожидаемые приоритеты. При необходимости используются скобки.

In [ ]:
1 + 2 * 3
Out[ ]:
7
In [ ]:
(1 + 2) * 3
Out[ ]:
9

Возведение целого числа в целую степень даёт целое число, если показатель степени $\geqslant 0$, и число с плавающей точкой, если он $<0$. Так что тип результата невозможно определить статически, если значение переменной n неизвестно.

In [ ]:
n = 3
2 ** n
Out[ ]:
8
In [ ]:
n = -3
2 ** n
Out[ ]:
0.125

Арифметические операции можно применять к целым и числам с плавающей точкой в любых сочетаниях.

In [ ]:
n + 1.0
Out[ ]:
-2.0

Деление целых чисел всегда даёт результат с плавающей точкой, даже если они делятся нацело. Операторы // и % дают целое частное и остаток.

In [ ]:
7 / 4
Out[ ]:
1.75
In [ ]:
7 // 4
Out[ ]:
1
In [ ]:
7 % 4
Out[ ]:
3
In [ ]:
4 / 2
Out[ ]:
2.0

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

In [ ]:
x
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-10-6fcf9dfbd479> in <module>
----> 1 x

NameError: name 'x' is not defined

Операция x+=1 означает x=x+1, аналогично для других операций. В питоне строго различаются операторы (например, присваивание) и выражения, так что таких операций, как ++ в C, нет. Хотя вызов функции в выражении может приводить к побочным эффектам.

In [ ]:
x = 1
x += 1
print(x)
2
In [ ]:
x *= 2
print(x)
4

Удаление объекта

In [ ]:
del x
x
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-13-1beca76b84e9> in <module>
      1 del x
----> 2 x

NameError: name 'x' is not defined
In [ ]:
x = 4

Любопытная особенность питона: можно использовать привычные из математики сравнения вроде $x<y<z$, которые в других языках пришлось бы записывать как x<y and y<z.

In [ ]:
1 < 2 <= 2
Out[ ]:
True
In [ ]:
1 < 2 < 2
Out[ ]:
False

Логические выражения можно комбинировать с помощью and и or, причем эти операции имеют более низкий приоритет, чем сравнения. Если результат уже ясен из первого операнда, второй операнд не вычисляется. А вот так выглядит оператор if.

In [ ]:
if 1 < 2 and x < 3:
    print('T')
else:
    print('F')
F
In [ ]:
if 1 < 2 or x < 3:
    print('T')
else:
    print('F')
T

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

Оператора, аналогичного case или switch, в питоне нет. Используйте длинную последовательность if ... elif ... elif ... else.

In [ ]:
n = 4
if n == 1:
    print('один')
elif n == 2:
    print('два')
elif n == 3:
    print('три')
else:
    print('много')
много

Есть и условные выражения:

In [ ]:
(0 if x < 0 else 1) + 1
Out[ ]:
2

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

В питоне немного встроенных функций. Большинство надо импортировать. Элементарные функции импортируют из модуля math. Не нужно заниматься импортозамещением, то есть писать свою реализацию синуса.

In [ ]:
from math import sin, pi
In [ ]:
pi
Out[ ]:
3.141592653589793
In [ ]:
round(pi, 2)
Out[ ]:
3.14
In [ ]:
print('{:.2f}'.format(pi))
3.14
In [ ]:
round(sin(pi / 6), 2)
Out[ ]:
0.5

Любой объект имеет тип.

In [ ]:
type(2)
Out[ ]:
int
In [ ]:
type(int)
Out[ ]:
type
In [ ]:
type(type)
Out[ ]:
type
In [ ]:
type(2.1)
Out[ ]:
float
In [ ]:
type(True)
Out[ ]:
bool
In [ ]:
type(None)
Out[ ]:
NoneType

Имена типов по совместительству являются функциями, преобразующими в этот тип объекты других типов если такое преобразование имеет смысл.

In [ ]:
float(2)
Out[ ]:
2.0
In [ ]:
int(2.0)
Out[ ]:
2
In [ ]:
int(2.9)
Out[ ]:
2
In [ ]:
int(-2.9)
Out[ ]:
-2

Преобразование числа с плавающей точкой в целое производится путём отбрасывания дробной части, а не округления.

3. Строки

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

In [ ]:
s = 'Какая-нибудь строка \u00F6 \u03B1 \u2230 \u342A'
print(s)
Какая-нибудь строка ö α ∰ 㐪
In [ ]:
'Эта строка может содержать " внутри'
Out[ ]:
'Эта строка может содержать " внутри'
In [ ]:
"Эта строка может содержать ' внутри"
Out[ ]:
"Эта строка может содержать ' внутри"
In [ ]:
s = 'Эта содержит и \', и \"'
print(s)
Эта содержит и ', и "
In [ ]:
s = """Строка,
занимающая
несколько
строчек
"""
print(s)
Строка,
занимающая
несколько
строчек

In [ ]:
s == "Строка,\nзанимающая\nнесколько\nстрочек\n"
Out[ ]:
True

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

In [ ]:
s = 'Такие ' 'строки ' 'слипаются'
print(s)
Такие строки слипаются
In [ ]:
print('Такие\n'
      'строки\n'
      'слипаются')
Такие
строки
слипаются

В питоне нет специального типа char, его роль играют строки длины 1. Функция ord возвращает (юникодный) номер символа, а обратная ей функция chr возвращает символ (строку длины 1).

In [ ]:
n = ord('а')
n
Out[ ]:
1072
In [ ]:
chr(n)
Out[ ]:
'а'

Функция len возвращает длину строки. Она применима не только к строкам, но и к спискам, словарям и многим другим типам, про объекты которых разумно спрашивать, какая у них длина.

In [ ]:
s = '0123456789'
len(s)
Out[ ]:
10

Символы в строке индексируются с 0. Отрицательные индексы используются для счёта с конца: s[-1] — последний символ в строке, и т.д.

In [ ]:
s[0]
Out[ ]:
'0'
In [ ]:
s[3]
Out[ ]:
'3'
In [ ]:
s[-1]
Out[ ]:
'9'
In [ ]:
s[-2]
Out[ ]:
'8'

Можно выделить подстроку, указав диапазон индексов. Подстрока включает символ, соответствующий началу диапазона, но не включает соответствующий концу. Удобно представлять себе, что индексы соответствуют положениям между символами строки. Тогда подстрока s[n:m] будет расположена между индексами n и m.

In [ ]:
s[1:3]
Out[ ]:
'12'
In [ ]:
s[:3]
Out[ ]:
'012'
In [ ]:
s[3:]
Out[ ]:
'3456789'
In [ ]:
s[:-1]
Out[ ]:
'012345678'
In [ ]:
s[3:-2]
Out[ ]:
'34567'
In [ ]:
s[::2]
Out[ ]:
'02468'

Если не указано начало диапазона, подразумевается от начала строки; если не указан его конец — до конца строки.

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

In [ ]:
s = 'abc'; t = 'def'
s + t
Out[ ]:
'abcdef'
In [ ]:
s * 3
Out[ ]:
'abcabcabc'

Операция in проверяет, содержится ли символ (или подстрока) в строке.

In [ ]:
'a' in s
Out[ ]:
True
In [ ]:
'd' in s
Out[ ]:
False
In [ ]:
'ab' in s
Out[ ]:
True
In [ ]:
'b' not in s
Out[ ]:
False

У объектов типа строка есть большое количество методов. Метод lstrip удаляет все whitespace-символы (пробел, tab, newline) в начале строки; rstrip — в конце; а strip — с обеих сторон. Им можно передать необязательный аргумент — символы, которые нужно удалять.

In [ ]:
'   строка   '.lstrip()
Out[ ]:
'строка   '
In [ ]:
'   строка   '.rstrip()
Out[ ]:
'   строка'
In [ ]:
'   строка   '.strip()
Out[ ]:
'строка'

lower и upper переводят все буквы в маленькие и заглавные.

In [ ]:
'СтРоКа'.lower()
Out[ ]:
'строка'
In [ ]:
'СтРоКа'.upper()
Out[ ]:
'СТРОКА'

Проверки: буквы (маленькие и заглавные), цифры, пробелы.

In [ ]:
'АбВг'.isalpha()
Out[ ]:
True
In [ ]:
'абвг'.islower()
Out[ ]:
True
In [ ]:
'АБВГ'.isupper()
Out[ ]:
True
In [ ]:
'0123'.isdigit()
Out[ ]:
True
In [ ]:
' \t\n'.isspace()
Out[ ]:
True

Строки имеют тип str.

In [ ]:
type(s)
Out[ ]:
str
In [ ]:
s = str(123)
s
Out[ ]:
'123'
In [ ]:
n = int(s)
n
Out[ ]:
123
In [ ]:
int('123x')
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-78-1183a716c046> in <module>
----> 1 int('123x')

ValueError: invalid literal for int() with base 10: '123x'
In [ ]:
x = float('123.456E-7')
x
Out[ ]:
1.23456e-05

Метод format особенно полезен для вывода.

In [ ]:
'str: {}  int: {}  float: {}'.format(s, n, x)
Out[ ]:
'str: 123  int: 123  float: 1.23456e-05'

Ширина поля 5 (больше, если не влезет); десятичный, шестнадцатиричный и двоичный форматы.

In [ ]:
print('''{:5d}
{:5x}
{:5b}'''.format(n, n, n))
  123
   7b
1111011

Ширина поля 10 (больше, если не влезет); после десятичной точки 5 цифр; формат с фиксированной точкой или экспоненциальный.

In [ ]:
print('''{:10.5f}
{:10.5e}
{:10.5f}
{:10.5e}'''.format(x, x, 1 / x, 1 / x))
   0.00001
1.23456e-05
81000.51840
8.10005e+04

4. Списки

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

In [ ]:
l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
l
Out[ ]:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [ ]:
len(l)
Out[ ]:
10
In [ ]:
l[0]
Out[ ]:
0
In [ ]:
l[3]
Out[ ]:
3
In [ ]:
l[10]
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-84-e4a648ff0fa9> in <module>()
----> 1 l[10]

IndexError: list index out of range
In [ ]:
l[-1]
Out[ ]:
9
In [ ]:
l[-2]
Out[ ]:
8
In [ ]:
l[1:3]
Out[ ]:
[1, 2]

Обратите внимание, что l[:3]+l[3:]==l.

In [ ]:
l[:3]
Out[ ]:
[0, 1, 2]
In [ ]:
l[3:]
Out[ ]:
[3, 4, 5, 6, 7, 8, 9]
In [ ]:
l[3:3]
Out[ ]:
[]
In [ ]:
l[3:-2]
Out[ ]:
[3, 4, 5, 6, 7]
In [ ]:
l[:-2]
Out[ ]:
[0, 1, 2, 3, 4, 5, 6, 7]

Списки являются изменяемыми объектами. Это сделано для эффективности. В списке может быть 1000000 элементов. Создавать его копию каждый раз, когда мы изменили один элемент, слишком дорого.

In [ ]:
l[3] = 'три'
l
Out[ ]:
[0, 1, 2, 'три', 4, 5, 6, 7, 8, 9]

Можно заменить какой-нибудь подсписок на новый список (в том числе другой длины).

In [ ]:
l[3:3] = [0]
l
Out[ ]:
[0, 1, 2, 0, 'три', 4, 5, 6, 7, 8, 9]
In [ ]:
l[3:3] = [10, 11, 12]
l
Out[ ]:
[0, 1, 2, 10, 11, 12, 0, 'три', 4, 5, 6, 7, 8, 9]
In [ ]:
l[5:7] = [0, 0, 0, 0]
l
Out[ ]:
[0, 1, 2, 10, 11, 0, 0, 0, 0, 'три', 4, 5, 6, 7, 8, 9]
In [ ]:
l[3:] = []
l
Out[ ]:
[0, 1, 2]
In [ ]:
l[len(l):] = [3, 4]
l
Out[ ]:
[0, 1, 2, 3, 4]

Некоторые из этих операций могут быть записаны в другой форме.

In [ ]:
l = [0, 1, 2, 3, 4, 5, 6, 7]
del l[3]
l
Out[ ]:
[0, 1, 2, 4, 5, 6, 7]
In [ ]:
del l[3:5]
l
Out[ ]:
[0, 1, 2, 6, 7]
In [ ]:
l.insert(3, 0)
l
Out[ ]:
[0, 1, 2, 0, 6, 7]
In [ ]:
l.append(8)
l
Out[ ]:
[0, 1, 2, 0, 6, 7, 8]
In [ ]:
l.extend([9, 10, 11])
l
Out[ ]:
[0, 1, 2, 0, 6, 7, 8, 9, 10, 11]
In [ ]:
l.append([9, 10, 11])
l
Out[ ]:
[0, 1, 2, 0, 6, 7, 8, 9, 10, 11, [9, 10, 11]]

Элементы списка могут быть разных типов.

In [ ]:
l = [0, [1, 2, 3], 'abc']
l[1][1] = 'x'
l
Out[ ]:
[0, [1, 'x', 3], 'abc']

Когда мы пишем m=l, мы присваиваем переменной m ссылку на тот же объект, на который ссылается l. Поэтому, изменив этот объект (список) через l, мы увидим эти изменения и через m — ведь список всего один.

In [ ]:
l = [0, 1, 2, 3, 4, 5]
m = l
l[3] = 'три'
m
Out[ ]:
[0, 1, 2, 'три', 4, 5]

Операция is проверяет, являются ли m и l одним и тем же объектом.

In [ ]:
m is l
Out[ ]:
True

Если мы хотим видоизменять m и l независимо, нужно присвоить переменной m не список l, а его копию. Тогда это будут два различных списка, просто в начальный момент они состоят из одних и тех же элементов. Для этого в питоне есть идиома: l[:] - это подсписок списка l от начала до конца, а подсписок всегда копируется.

In [ ]:
m = l[:]

Теперь m и l - два независимых объекта, имеющих равные значения.

In [ ]:
m is l
Out[ ]:
False
In [ ]:
m == l
Out[ ]:
True

Их можно менять независимо.

In [ ]:
l[3] = 0
l
Out[ ]:
[0, 1, 2, 0, 4, 5]
In [ ]:
m
Out[ ]:
[0, 1, 2, 'три', 4, 5]

Как и для строк, сложение списков означает конкатенацию, а умножение на целое число - повторение списка несколько раз. Операция in проверяет, содержится ли элемент в списке.

In [ ]:
[0, 1, 2] + [3, 4, 5]
Out[ ]:
[0, 1, 2, 3, 4, 5]
In [ ]:
2 * [0, 1, 2]
Out[ ]:
[0, 1, 2, 0, 1, 2]
In [ ]:
l = [0, 1, 2]
l += [3, 4, 5]
l
Out[ ]:
[0, 1, 2, 3, 4, 5]
In [ ]:
2 in l
Out[ ]:
True

Простейший вид цикла в питоне — это цикл по элементам списка.

In [ ]:
for x in l:
    print(x)
0
1
2
3
4
5

Можно использовать цикл while. В этом примере он выполняется, пока список l не пуст. Этот цикл гораздо менее эффективен, чем предыдущий - в нём на каждом шаге меняется список l. Он тут приведён не для того, чтобы ему подражали, а просто чтобы показать синтаксис цикла while.

In [ ]:
while l:
    print(l[0])
    l = l[1:]
0
1
2
3
4
5
In [ ]:
l
Out[ ]:
[]

Очень часто используются циклы по диапазонам целых чисел.

In [ ]:
for i in range(4):
    print(i)
0
1
2
3

Функция range(n) возвращает диапазон целых чисел от 0 до $n-1$ (всего $n$ штук) в виде специального объекта range, который можно использовать в for цикле. Можно превратить этот объект в список функцией list. Но этого делать не нужно, если только такой список не нужен для проведения каких-нибудь списковых операций. Число n может быть равно 1000000. Зачем занимать память под длинный список, если он не нужен? Для написания цикла достаточно короткого объекта range, который хранит только пределы.

In [ ]:
r = range(4)
r
Out[ ]:
range(0, 4)
In [ ]:
list(r)
Out[ ]:
[0, 1, 2, 3]

Функции range можно передать первый параметр - нижний предел.

In [ ]:
for i in range(2, 4):
    print(i)
2
3
In [ ]:
r = range(2, 4)
r
Out[ ]:
range(2, 4)
In [ ]:
list(r)
Out[ ]:
[2, 3]

Можно также передать шаг третьим аргументом

In [ ]:
for i in range(1, 10, 2):
    print(i)
1
3
5
7
9
In [ ]:
r = range(1, 10, 2)
r
Out[ ]:
range(1, 10, 2)
In [ ]:
list(r)
Out[ ]:
[1, 3, 5, 7, 9]

Функция list превращает строку в список символов.

In [ ]:
l = list('абвгд')
l
Out[ ]:
['а', 'б', 'в', 'г', 'д']

Как написать цикл, если в его теле нужно использовать и номера элементов списка, и сами эти элементы? Первая идея, которая приходит в голову по аналогии с C — это использовать range.

In [ ]:
for i in range(len(l)):
    print(i, '  ', l[i])
0    а
1    б
2    в
3    г
4    д

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

In [ ]:
i = 0
for x in l:
    print(i, '  ', x)
    i += 1
0    а
1    б
2    в
3    г
4    д

Оба этих способа не есть идиоматический питон. Более изящно использовать функцию enumerate, которая на каждом шаге возвращает пару из индекса i и i-го элемента списка.

In [ ]:
for i, x in enumerate(l):
    print(i, '  ', x)
0    а
1    б
2    в
3    г
4    д

Про такие пары мы поговорим в следующем параграфе.

Довольно часто удобно использовать цикл while True:, то есть пока рак на горе не свистнет, а выход (или несколько выходов) из него устраивать в нужном месте (или местах) при помощи break.

In [ ]:
while True:
    print(l[-1])
    l = l[:-1]
    if l == []:
        break
д
г
в
б
а

Этот конкретный цикл — отнюдь не пример для подражания, он просто показывает синтаксис.

Можно строить список поэлементно.

In [ ]:
l = []
for i in range(10):
    l.append(i ** 2)
l
Out[ ]:
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Но более компактно и элегантно такой список можно создать при помощи генератора списка (list comprehension). К тому же это эффективнее — размер списка известен заранее, и не нужно много раз увеличивать его. Опытные питон-программисты используют генераторы списков везде, где это возможно (и разумно).

In [ ]:
[i ** 2 for i in range(10)]
Out[ ]:
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
In [ ]:
[[i, j] for i in range(3) for j in range(2)]
Out[ ]:
[[0, 0], [0, 1], [1, 0], [1, 1], [2, 0], [2, 1]]

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

In [ ]:
[i ** 2 for i in range(10) if i != 5]
Out[ ]:
[0, 1, 4, 9, 16, 36, 49, 64, 81]

Создадим список случайных целых чисел.

In [ ]:
from random import randint
In [ ]:
l = [randint(0, 9) for i in range(10)]
l
Out[ ]:
[5, 6, 9, 4, 8, 2, 4, 1, 0, 9]

Функция sorted возвращает отсортированную копию списка. Метод sort сортирует список на месте. Им можно передать дополнительный параметр — функцию, указывающую, как сравнивать элементы.

In [ ]:
sorted(l)
Out[ ]:
[0, 1, 2, 4, 4, 5, 6, 8, 9, 9]
In [ ]:
l
Out[ ]:
[5, 6, 9, 4, 8, 2, 4, 1, 0, 9]
In [ ]:
l.sort()
l
Out[ ]:
[0, 1, 2, 4, 4, 5, 6, 8, 9, 9]

Аналогично, функция reversed возвращает обращённый список. Точнее говоря, некий объект, который можно использовать в for цикле или превратить в список функцией list. Метод reverse обращает список на месте.

In [ ]:
list(reversed(l))
Out[ ]:
[9, 9, 8, 6, 5, 4, 4, 2, 1, 0]
In [ ]:
l
Out[ ]:
[0, 1, 2, 4, 4, 5, 6, 8, 9, 9]
In [ ]:
l.reverse()
l
Out[ ]:
[9, 9, 8, 6, 5, 4, 4, 2, 1, 0]

Метод split расщепляет строку в список подстрок. По умолчанию расщепление производится по пустым промежуткам, то есть последовательностям пробелов и символов tab и newline. Но можно передать ему дополнительный аргумент — подстроку-разделитель.

In [ ]:
s = 'abc \t def \n ghi'
l = s.split()
l
Out[ ]:
['abc', 'def', 'ghi']

Чтобы напечатать элементы списка через запятую или какой-нибудь другой символ (или строку), очень полезен метод join. Он создаёт строку из всех элементов списка, разделяя их строкой-разделителем. Запрограммировать это в виде цикла было бы существенно длиннее, и такую программу было бы сложнее читать.

In [ ]:
s = ', '.join(l)
s
Out[ ]:
'abc, def, ghi'
In [ ]:
s.split(', ')
Out[ ]:
['abc', 'def', 'ghi']

При подготовке использованы материалы https://inp.nsk.su/~grozin/python/