Справочник функций

Символом [] в заголовках подразделов отмечены опциональные аргументы. Их можно не указывать, если вам подходит значение по умолчанию.

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

Символом # отмечены комментарии (пояснения) к коду.

Общее

len(seq)

Возвращает длину массива, количество ключей словаря или длину строки.

>>> len([1, 2, 3])
3

>>> len('привет')
6

int(v)

Преобразует аргумент в целое число.

>>> int(10.2)
10

>>> int('10')
10

>>> '10' + 2
102

>>> int('10') + 2
12

float(v)

Преобразует аргумент в дробное число.

>>> float('10.2')
10.2

str(v)

Преобразует аргумент в строку.

>>> str(10.2)
10.2

pretty(container, [delimiter])

Форматирует число, массив или словарь, используя в качестве разделителя элементов delimiter.

>>> 12345678 | pretty
12 345 678

>>> 12345678 | pretty('\'')
12'345'678

>>> ['один', 'два', 'три'] | pretty
один, два, три

>>> d = dict()
>>> d['x'] = 10
>>> d['y'] = 20

>>> d | pretty
x: 10
y: 20

Арифметика

round(v, [nd])

Округляет значение v до nd знаков после запятой. Если второй аргумент не указан — округляет до целого.

>>> round(10.2)
10

>>> round(10.992)
11

>>> round(10.992, 2)
10.99

floor(v)

Округляет аргумент вниз до целого.

>>> floor(10.9)
10

ceil(v)

Округляет аргумент вверх до целого.

>>> ceil(10.2)
11

abs(v)

Возвращает абсолютное значение

>>> abs(-5)
5

min(a, b, ...)

Возвращает минимальный аргумент.

>>> min(1, 2, 3)
1

max(a, b, ...)

Возвращает максимальный аргумент.

>>> max(1, 2, 3)
3

rand()

Возвращает дробное число в полуинтервале [0, 1).

>>> rand()
0.43463103446060180612420253964955918490886688232421875

rand(a, b)

Возвращает целое число в интервале [a, b].

>>> rand(1, 10)
10

rand(arr)

Возвращает случайный элемент массива.

>>> rand([1, 2, 3])
3

Работа со строками

startswith(container, s)

Проверяет, что строка container начинается с подстроки s.

>>> 'привет мир'.startswith('прив')
True

endswith(container, s)

Проверяет, что строка container заканчивается подстрокой s.

>>> 'привет мир'.endswith('мир')
True

lower(s)

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

>>> 'ПрИвЕт' | lower
привет

>>> 'ПрИвЕт' == 'привет'
False

>>> 'ПрИвЕт' | lower == 'привет'
True

upper(s)

Преобразует строку в верхний регистр.

>>> 'ПрИвЕт' | upper
ПРИВЕТ

strip(s)

Удаляет лишние пробелы в начале и в конце строки.

>>> '  привет     ' | strip
привет

split(s, [[sep=' ', [max_split=-1]])

Преобразует строку в массив, разделяя её по указанному символу sep (по умолчанию — пробел), так же можно указать max_split — максимальное число делений.

>>> 'раз два три' | split
['раз', 'два', 'три']

>>> 'раз два три' | split(' ', 1)
['раз', 'два три']

replace(s, old, new, [count=-1])

Заменяет подстроку old в строке s на строку new. По умолчанию (если не указан count) заменяются все вхождения подстроки.

>>> 'Привет, Вася'.replace('Вася', 'Петя')
Привет, Петя

>>> 'тест, тест, тест'.replace('тест', 'test')
'test, test, test'

>>> 'тест, тест, тест'.replace('тест', 'test', 1)
'test, тест, тест'

Регулярные выражения

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

Подробнее можно почитать тут: https://ru.wikipedia.org/wiki/Регулярные_выражения

Проверить работу своих регулярных выражений можно тут: https://regex101.com

match(s, pattern, [flags])

Находит в строке s подстроку соответствующую регулярному выражению pattern. Если такой подстроки нет, возвращается None.

Поддерживаемые флаги:

• i — не учитывать регистр

• m — многострочный матчинг

• s — . (точка) матчит переносы строк

>>> 'привет, мир' | match(r'мир')
мир

>>> 'привет, мир' | match(r'тест')
None

# поиск числа в строке
>>> 'пополнить, 500' | match(r'\d+')
500

# выделяем email из строки
>>> 'Моя почта: [e-mail]' | match(r'\S+@\S+')
[e-mail]

# поиск с учётом регистра (по-умолчанию)
>>> 'ТЕСТ' | match(r'тест')
None

# без учёта регистра
>>> 'ТЕСТ' | match(r'тест', 'i')
ТЕСТ

# ^$ означают, что вся строка должна удовлетворять фильтру
>>> 'пополнить, 500' | match(r'^пополнить, \d+$')
пополнить, 500

# лишний текст не удовлетворяет фильтру
>>> 'пополнить, 500 какой-то лишний текст' | match(r'^пополнить, \d+$')
None

match_groups(s, pattern, [flags])

Находит в строке s подстроку соответствующую регулярному выражению pattern. Если такой подстроки нет, возвращается None.

В отличие от match() возвращает не подстроку, а массив групп. Причём первым элементом массива является вся найденная подстрока.

Поддерживаемые флаги:

• i — не учитывать регистр

• m — многострочный матчинг

• s — . (точка) матчит переносы строк

# выделяем 2 группы: число и валюту
>>> 'пополнить на 100 рублей' | match_groups(r'(\d+) (\w+)')
['100 рублей', '100', 'рублей']

match_all(s, pattern, [flags])

Находит в строке s все подстроки соответствующие регулярному выражению pattern.

Поддерживаемые флаги:

• i — не учитывать регистр

• m — многострочный матчинг

• s — . (точка) матчит переносы строк

# находим все числа в строке
>>> '1, 2, 3, 4, 5' | match_all(r'\d+')
['1', '2', '3', '4', '5']

Работа с массивами

Операторы

>>> arr = [1, 2, 3]

# получение значения по индексу
>>> arr[0]
1

# последний элемент массива можно получить так:
>>> arr[-1]
3

# проверка наличия значения в массиве
>>> 3 in arr
True

# проверка отсутствия значения в массиве
>>> 4 not in arr
True

# изменение значения по индексу
>>> arr[0] = 100
>>> arr
[100, 2, 3]

# удаление значения по индексу
>>> del arr[0]
>>> arr
[2, 3]

Слайсы

>>> arr = [1, 2, 3, 4, 5]

# элементы массива, начиная с указанного индекса
>>> arr[2:]
[3, 4, 5]

# элементы массива до указанного индекса
>>> arr[:2]
[1, 2]

# каждый второй элемент массива
>>> arr[::2]
[1, 3, 5]

# переворот массива
>>> arr[::-1]
[5, 4, 3, 2, 1]

push(arr, v)

Добавляет элемент v в конец массива arr.

>>> arr = [1, 2]
>>> arr.push(3)
>>> arr
[1, 2, 3]

pop(arr, [i])

Удаляет элемент с индексом i. Если i не указан, то удаляется последний элемент массива.

>>> arr = [1, 2, 3]
>>> arr.pop()
>>> arr
[1, 2]

>>> arr = [1, 2, 3]
>>> arr.pop(0)
>>> arr
[2, 3]

insert(arr, i, v)

Вставляет значение v на место i.

>>> arr = [1, 2, 3]
>>> arr.insert(0, 100)
>>> arr
[100, 1, 2, 3]

remove(arr, v)

Удаляет первое вхождение элемента со значением v.

>>> arr = [1, 2, 100, 3]
>>> arr.remove(100)
>>> arr
[1, 2, 3]

sorted(arr)

Возвращает копию массива, значения в котором упорядочены по возрастанию.

>>> arr = [2, 10, 1]
>>> arr | sorted
[1, 2, 10]

sorted(arr, key, reversed=False)

Возвращает копию массива, значения в котором упорядочены по возрастанию (или убыванию, если reversed равно True). key — функция, которая возвращает значение по котором нужно выполнять сортировку.

# сортируем по полю 'x'
>>> [{'x': 30}, {'x': 10}, {'x': 20}] | sorted(el => el['x'])
[{'x': 10}, {'x': 20}, {'x': 30}]

# сортируем по полю 'x' в обратном направлении
>>> [{'x': 30}, {'x': 10}, {'x': 20}] | sorted(el => el['x'], True)
[{'x': 30}, {'x': 20}, {'x': 10}]

# просто сортируем по убыванию
[30, 10, 20] | sorted(None, False)
[30, 20, 10]

reversed(arr)

Возвращает копию массива, значения в котором находятся в обратном порядке.

>>> arr = [2, 10, 1]
>>> arr | reversed
[1, 10, 2]

enumerate(arr)

Возвращает массив пар (индекс, значение).

>>> arr = [2, 10, 1]
>>> arr | enumerate
[(0, 2), (1, 10), (2, 1)]

shuffle(arr)

Возвращает копию массива, отсортированную в случайном порядке.

>>> arr = [2, 10, 1]
>>> arr | shuffle
[10, 1, 2]

index_of(arr, value)

Возвращает индекс первого элемента массива, равного указанному значению value. Если элемента с указанным значением в массиве нет, возвращается None.

>>> arr = [2, 10, 1]
>>> arr | index_of('10')
1

join(arr, [sep])

Объединяет элементы массива в одну строку, используя сепаратор sep.

>>> arr = [1, 2, 3]
>>> arr | join
1
2
3

>>> arr | join(':')
1:2:3

sum(arr)

Возвращает сумму элементов массива.

>>> [1, 2, 3] | sum
6

map(arr, l)

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

# умножим каждый элемент на 2
>>> [1, 2, 3] | map(v => v * 2)
[2, 4, 6]

filter(arr, l)

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

# отфильтруем значения, большие, чем 5
>>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] | filter(v => v > 5)
[6, 7, 8, 9, 10]

reduce(arr, l)

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

# сумма значение
>>> [1, 2, 3] | reduce((acc, v) => acc + v)
6

# произведение значение
>>> [1, 2, 3] | reduce((acc, v) => acc * v)
6

# сумма строк
>>> [1, 2, 3] | reduce((acc, v) => str(acc) + v)
123

Работа со словарями

Операторы

# объявление словаря
>>> корзина = {'хлеб': 3, 'греча': 10}

# получение значения по ключу
>>> корзина['хлеб']
3

# проверка наличия ключа в словаре
>>> 'хлеб' in корзина
True

# изменение значения по ключу
>>> корзина['хлеб'] = 2
>>> корзина
{'хлеб': 2, 'греча': 10}

# удаление значения по индексу
>>> del корзина['греча']
>>> корзина
{'хлеб': 2}

get(k, [default])

Возвращает значение по ключу k. Если такого ключа в словаре нет, возвращается значение default.

>>> корзина = {'хлеб': 3, 'греча': 10}
>>> корзина.get('хлеб')
3
>>> корзина.get('сосиски', 100)
100

keys(d)

Возвращает массив ключей словаря.

>>> корзина = {'хлеб': 3, 'греча': 10}
>>> корзина | keys
['хлеб', 'греча']

values(d)

Возвращает массив значений словаря.

>>> корзина = {'хлеб': 3, 'греча': 10}
>>> корзина | values
[3, 10]

map(d, l)

Возвращает массив, полученный в результате применения лямбда-функции l к каждой паре ключ-значение (k, v).

>>> корзина | map((k, v) => k + ': ' + v + ' шт') | join
хлеб: 3 шт
греча: 10 шт

sorted(d, key, reversed=False)

Возвращает копию словаря, значения в котором упорядочены по возрастанию (или убыванию, если reversed равно True). key — функция, которая возвращает значение по которому нужно выполнять сортировку.

# сортируем по значению
>>> {'Vasja': 10, 'Tom': 5} | sorted((k, v) => v)
{'Tom': 5, 'Vasja': 10}

# сортируем по значению (по убыванию)
>>> {'Vasja': 10, 'Tom': 5} | sorted((k, v) => v, True)
{'Vasja': 10, 'Tom': 5}