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

Общее

len(seq)

Возвращает длину массива, количество ключей словаря или длину строки.
1
>>> len([1, 2, 3])
2
3
3
4
>>> len('привет')
5
6
Copied!

int(v)

Преобразует аргумент в целое число.
1
>>> int(10.2)
2
10
3
4
>>> int('10')
5
10
6
7
>>> '10' + 2
8
102
9
10
>>> int('10') + 2
11
12
Copied!

float(v)

Преобразует аргумент в дробное число.
1
>>> float('10.2')
2
10.2
Copied!

str(v)

Преобразует аргумент в строку.
1
>>> str(10.2)
2
10.2
Copied!

pretty(container, [delimiter])

Форматирует число, массив или словарь, используя в качестве разделителя элементов delimiter.
1
>>> 12345678 | pretty
2
12 345 678
3
4
>>> 12345678 | pretty('\'')
5
12'345'678
6
7
>>> ['один', 'два', 'три'] | pretty
8
один, два, три
9
10
>>> d = dict()
11
>>> d['x'] = 10
12
>>> d['y'] = 20
13
14
>>> d | pretty
15
x: 10
16
y: 20
Copied!

Арифметика

round(v, [nd])

Округляет значение v до nd знаков после запятой. Если второй аргумент не указан — округляет до целого.
1
>>> round(10.2)
2
10
3
4
>>> round(10.992)
5
11
6
7
>>> round(10.992, 2)
8
10.99
Copied!

floor(v)

Округляет аргумент вниз до целого.
1
>>> floor(10.9)
2
10
Copied!

ceil(v)

Округляет аргумент вверх до целого.
1
>>> ceil(10.2)
2
11
Copied!

abs(v)

Возвращает абсолютное значение
1
>>> abs(-5)
2
5
Copied!

min(a, b, ...)

Возвращает минимальный аргумент.
1
>>> min(1, 2, 3)
2
1
Copied!

min(arr)

Возвращает минимальный элемент массива.
1
>>> min([1, 2, 3])
2
1
Copied!

max(a, b, ...)

Возвращает максимальный аргумент.
1
>>> max(1, 2, 3)
2
3
Copied!

max(arr)

Возвращает максимальный элемент массива.
1
>>> max([1, 2, 3])
2
3
Copied!

rand()

Возвращает дробное число в полуинтервале [0, 1).
1
>>> rand()
2
0.43463103446060180612420253964955918490886688232421875
Copied!

rand(a, b)

Возвращает целое число в интервале [a, b].
1
>>> rand(1, 10)
2
10
Copied!

rand(arr)

Возвращает случайный элемент массива.
1
>>> rand([1, 2, 3])
2
3
Copied!

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

startswith(container, s)

Проверяет, что строка container начинается с подстроки s.
1
>>> 'привет мир'.startswith('прив')
2
True
Copied!

endswith(container, s)

Проверяет, что строка container заканчивается подстрокой s.
1
>>> 'привет мир'.endswith('мир')
2
True
Copied!

lower(s)

Преобразует строку в нижний регистр. Удобно для последующего сравнения с другой строкой без учёта регистра.
1
>>> 'ПрИвЕт' | lower
2
привет
3
4
>>> 'ПрИвЕт' == 'привет'
5
False
6
7
>>> 'ПрИвЕт' | lower == 'привет'
8
True
Copied!

upper(s)

Преобразует строку в верхний регистр.
1
>>> 'ПрИвЕт' | upper
2
ПРИВЕТ
Copied!

strip(s)

Удаляет лишние пробелы в начале и в конце строки.
1
>>> ' привет ' | strip
2
привет
Copied!

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

Преобразует строку в массив, разделяя её по указанному символу sep (по умолчанию — пробел), так же можно указать max_split — максимальное число делений.
1
>>> 'раз два три' | split
2
['раз', 'два', 'три']
3
4
>>> 'раз два три' | split(' ', 1)
5
['раз', 'два три']
Copied!

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

Заменяет подстроку old в строке s на строку new. По умолчанию (если не указан count) заменяются все вхождения подстроки.
1
>>> 'Привет, Вася'.replace('Вася', 'Петя')
2
Привет, Петя
3
4
>>> 'тест, тест, тест'.replace('тест', 'test')
5
'test, test, test'
6
7
>>> 'тест, тест, тест'.replace('тест', 'test', 1)
8
'test, тест, тест'
Copied!

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

Регулярные выражения позволяют проверять соответствие строки указанному шаблону, или искать подстроку по шаблону в другой строке. Это достаточно сложный, но очень мощный механизм.
Подробнее можно почитать тут: https://ru.wikipedia.org/wiki/Регулярные_выражения
Проверить работу своих регулярных выражений можно тут: https://regex101.com
Примеры использования: Работа с регулярными выражениями

match(s, pattern, [flags])

Находит в строке s подстроку соответствующую регулярному выражению pattern. Если такой подстроки нет, возвращается None.
Поддерживаемые флаги:
    i — не учитывать регистр
    m — многострочный матчинг
    s — . (точка) матчит переносы строк
1
>>> 'привет, мир' | match(r'мир')
2
мир
3
4
>>> 'привет, мир' | match(r'тест')
5
None
6
7
# поиск числа в строке
8
>>> 'пополнить, 500' | match(r'\d+')
9
500
10
11
# выделяем email из строки
12
>>> 'Моя почта: [email protected]' | match(r'\[email protected]\S+')
14
15
# поиск с учётом регистра (по-умолчанию)
16
>>> 'ТЕСТ' | match(r'тест')
17
None
18
19
# без учёта регистра
20
>>> 'ТЕСТ' | match(r'тест', 'i')
21
ТЕСТ
22
23
# ^$ означают, что вся строка должна удовлетворять фильтру
24
>>> 'пополнить, 500' | match(r'^пополнить, \d+#x27;)
25
пополнить, 500
26
27
# лишний текст не удовлетворяет фильтру
28
>>> 'пополнить, 500 какой-то лишний текст' | match(r'^пополнить, \d+#x27;)
29
None
Copied!

match_groups(s, pattern, [flags])

Находит в строке s подстроку соответствующую регулярному выражению pattern. Если такой подстроки нет, возвращается None.
В отличие от match() возвращает не подстроку, а массив групп. Причём первым элементом массива является вся найденная подстрока.
Поддерживаемые флаги:
    i — не учитывать регистр
    m — многострочный матчинг
    s — . (точка) матчит переносы строк
1
# выделяем 2 группы: число и валюту
2
>>> 'пополнить на 100 рублей' | match_groups(r'(\d+) (\w+)')
3
['100 рублей', '100', 'рублей']
Copied!

match_all(s, pattern, [flags])

Находит в строке s все подстроки соответствующие регулярному выражению pattern.
Поддерживаемые флаги:
    i — не учитывать регистр
    m — многострочный матчинг
    s — . (точка) матчит переносы строк
1
# находим все числа в строке
2
>>> '1, 2, 3, 4, 5' | match_all(r'\d+')
3
['1', '2', '3', '4', '5']
Copied!

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

Операторы

1
>>> arr = [1, 2, 3]
2
3
# получение значения по индексу
4
>>> arr[0]
5
1
6
7
# последний элемент массива можно получить так:
8
>>> arr[-1]
9
3
10
11
# проверка наличия значения в массиве
12
>>> 3 in arr
13
True
14
15
# проверка отсутствия значения в массиве
16
>>> 4 not in arr
17
True
18
19
# изменение значения по индексу
20
>>> arr[0] = 100
21
>>> arr
22
[100, 2, 3]
23
24
# удаление значения по индексу
25
>>> del arr[0]
26
>>> arr
27
[2, 3]
Copied!

Слайсы

1
>>> arr = [1, 2, 3, 4, 5]
2
3
# элементы массива, начиная с указанного индекса
4
>>> arr[2:]
5
[3, 4, 5]
6
7
# элементы массива до указанного индекса
8
>>> arr[:2]
9
[1, 2]
10
11
# каждый второй элемент массива
12
>>> arr[::2]
13
[1, 3, 5]
14
15
# переворот массива
16
>>> arr[::-1]
17
[5, 4, 3, 2, 1]
Copied!

push(arr, v)

Добавляет элемент v в конец массива arr.
1
>>> arr = [1, 2]
2
>>> arr.push(3)
3
>>> arr
4
[1, 2, 3]
Copied!

pop(arr, [i])

Удаляет элемент с индексом i. Если i не указан, то удаляется последний элемент массива.
1
>>> arr = [1, 2, 3]
2
>>> arr.pop()
3
>>> arr
4
[1, 2]
5
6
>>> arr = [1, 2, 3]
7
>>> arr.pop(0)
8
>>> arr
9
[2, 3]
Copied!

insert(arr, i, v)

Вставляет значение v на место i.
1
>>> arr = [1, 2, 3]
2
>>> arr.insert(0, 100)
3
>>> arr
4
[100, 1, 2, 3]
Copied!

remove(arr, v)

Удаляет первое вхождение элемента со значением v.
1
>>> arr = [1, 2, 100, 3]
2
>>> arr.remove(100)
3
>>> arr
4
[1, 2, 3]
Copied!

sorted(arr)

Возвращает копию массива, значения в котором упорядочены по возрастанию.
1
>>> arr = [2, 10, 1]
2
>>> arr | sorted
3
[1, 2, 10]
Copied!

sorted(arr, key, reversed=False)

Возвращает копию массива, значения в котором упорядочены по возрастанию (или убыванию, если reversed равно True). key — функция, которая возвращает значение по котором нужно выполнять сортировку.
1
# сортируем по полю 'x'
2
>>> [{'x': 30}, {'x': 10}, {'x': 20}] | sorted(el => el['x'])
3
[{'x': 10}, {'x': 20}, {'x': 30}]
4
5
# сортируем по полю 'x' в обратном направлении
6
>>> [{'x': 30}, {'x': 10}, {'x': 20}] | sorted(el => el['x'], True)
7
[{'x': 30}, {'x': 20}, {'x': 10}]
8
9
# просто сортируем по убыванию
10
[30, 10, 20] | sorted(None, False)
11
[30, 20, 10]
Copied!

reversed(arr)

Возвращает копию массива, значения в котором находятся в обратном порядке.
1
>>> arr = [2, 10, 1]
2
>>> arr | reversed
3
[1, 10, 2]
Copied!

enumerate(arr)

Возвращает массив пар (индекс, значение).
1
>>> arr = [2, 10, 1]
2
>>> arr | enumerate
3
[(0, 2), (1, 10), (2, 1)]
Copied!

shuffle(arr)

Возвращает копию массива, отсортированную в случайном порядке.
1
>>> arr = [2, 10, 1]
2
>>> arr | shuffle
3
[10, 1, 2]
Copied!

index_of(arr, value)

Возвращает индекс первого элемента массива, равного указанному значению value. Если элемента с указанным значением в массиве нет, возвращается None.
1
>>> arr = [2, 10, 1]
2
>>> arr | index_of('10')
3
1
Copied!

join(arr, [sep])

Объединяет элементы массива в одну строку, используя сепаратор sep.
1
>>> arr = [1, 2, 3]
2
>>> arr | join
3
1
4
2
5
3
6
7
>>> arr | join(':')
8
1:2:3
Copied!

sum(arr)

Возвращает сумму элементов массива.
1
>>> [1, 2, 3] | sum
2
6
Copied!

map(arr, l)

Возвращает копию массива, полученную в результате применения лямбда-функции l к каждому его элементу.
1
# умножим каждый элемент на 2
2
>>> [1, 2, 3] | map(v => v * 2)
3
[2, 4, 6]
Copied!

filter(arr, l)

Возвращает копию массива, элементы которого подходят под фильтр, заданный лямбда-функцией l.
1
# отфильтруем значения, большие, чем 5
2
>>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] | filter(v => v > 5)
3
[6, 7, 8, 9, 10]
Copied!

reduce(arr, l)

Объединяет элементы массива в единое целое, вызывая переданную лямбда-функцию l для каждого элемента. Первым аргументов лямбда-функции является накопленный на данный момент результат, вторым — очередной элемент массива.
1
# сумма значение
2
>>> [1, 2, 3] | reduce((acc, v) => acc + v)
3
6
4
5
# произведение значение
6
>>> [1, 2, 3] | reduce((acc, v) => acc * v)
7
6
8
9
# сумма строк
10
>>> [1, 2, 3] | reduce((acc, v) => str(acc) + v)
11
123
Copied!

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

Операторы

1
# объявление словаря
2
>>> корзина = {'хлеб': 3, 'греча': 10}
3
4
# получение значения по ключу
5
>>> корзина['хлеб']
6
3
7
8
# проверка наличия ключа в словаре
9
>>> 'хлеб' in корзина
10
True
11
12
# изменение значения по ключу
13
>>> корзина['хлеб'] = 2
14
>>> корзина
15
{'хлеб': 2, 'греча': 10}
16
17
# удаление значения по индексу
18
>>> del корзина['греча']
19
>>> корзина
20
{'хлеб': 2}
Copied!

get(k, [default])

Возвращает значение по ключу k. Если такого ключа в словаре нет, возвращается значение default.
1
>>> корзина = {'хлеб': 3, 'греча': 10}
2
>>> корзина.get('хлеб')
3
3
4
>>> корзина.get('сосиски', 100)
5
100
Copied!

keys(d)

Возвращает массив ключей словаря.
1
>>> корзина = {'хлеб': 3, 'греча': 10}
2
>>> корзина | keys
3
['хлеб', 'греча']
Copied!

values(d)

Возвращает массив значений словаря.
1
>>> корзина = {'хлеб': 3, 'греча': 10}
2
>>> корзина | values
3
[3, 10]
Copied!

map(d, l)

Возвращает массив, полученный в результате применения лямбда-функции l к каждой паре ключ-значение (k, v).
1
>>> корзина | map((k, v) => k + ': ' + v + ' шт') | join
2
хлеб: 3 шт
3
греча: 10 шт
Copied!

sorted(d, key, reversed=False)

Возвращает копию словаря, значения в котором упорядочены по возрастанию (или убыванию, если reversed равно True). key — функция, которая возвращает значение по которому нужно выполнять сортировку.
1
# сортируем по значению
2
>>> {'Vasja': 10, 'Tom': 5} | sorted((k, v) => v)
3
{'Tom': 5, 'Vasja': 10}
4
5
# сортируем по значению (по убыванию)
6
>>> {'Vasja': 10, 'Tom': 5} | sorted((k, v) => v, True)
7
{'Vasja': 10, 'Tom': 5}
Copied!
Last modified 3mo ago