Search…
Справочник функций
Символом [] в заголовках подразделов отмечены опциональные аргументы. Их можно не указывать, если вам подходит значение по умолчанию.
Символом >>> в примерах ниже отмечен ввод пользователя, а на строку ниже указан результат вычисления этого выражения.
Символом # отмечены комментарии (пояснения) к коду.

Общее

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 из строки
>>> 'Моя почта: [email protected]' | match(r'\[email protected]\S+')
# поиск с учётом регистра (по-умолчанию)
>>> 'ТЕСТ' | match(r'тест')
None
# без учёта регистра
>>> 'ТЕСТ' | match(r'тест', 'i')
ТЕСТ
# ^$ означают, что вся строка должна удовлетворять фильтру
>>> 'пополнить, 500' | match(r'^пополнить, \d+#x27;)
пополнить, 500
# лишний текст не удовлетворяет фильтру
>>> 'пополнить, 500 какой-то лишний текст' | match(r'^пополнить, \d+#x27;)
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}
Copy link
Outline
Общее
len(seq)
int(v)
float(v)
str(v)
pretty(container, [delimiter])
Арифметика
round(v, [nd])
floor(v)
ceil(v)
abs(v)
min(a, b, ...)
max(a, b, ...)
rand()
rand(a, b)
rand(arr)
Работа со строками
startswith(container, s)
endswith(container, s)
lower(s)
upper(s)
strip(s)
split(s, [[sep=' ', [max_split=-1]])
replace(s, old, new, [count=-1])
Регулярные выражения
match(s, pattern, [flags])
match_groups(s, pattern, [flags])
match_all(s, pattern, [flags])
Работа с массивами
Операторы
Слайсы
push(arr, v)
pop(arr, [i])
insert(arr, i, v)
remove(arr, v)
sorted(arr)
sorted(arr, key, reversed=False)
reversed(arr)
enumerate(arr)
shuffle(arr)
index_of(arr, value)
join(arr, [sep])
sum(arr)
map(arr, l)
filter(arr, l)
reduce(arr, l)
Работа со словарями
Операторы
get(k, [default])
keys(d)
values(d)
map(d, l)
sorted(d, key, reversed=False)