Документация по языку python3
Содержание:
- Содержание
- Разница между атомарными и структурными типы данных
- Разбор цикла for
- Передача аргументов функции
- внешние ссылки
- Таблица «методы списков»
- Добавить комментарий
- Что такое списки?
- Создание Shadow DOM
- Использование операторов is, in, not, and, or и операторов сравнения.
- Перегрузка арифметических операторов
- Цикл for в Python
- Оператор член Python
- Нововведения Python 3.9.0
- Функции, которые когда-нибудь можно выучить
- *args и **kwargs
- Логические операторы
- Вывод
Содержание
Функция print
Формат вызова:
print(value, …, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)
выводит в файл file значение value, добавляя в конце вывода строку end
элементы value разделены строкой sep. Если flush=True, тогда после
выполнения команды посылается команда очистки буферов ввода/вывода.
value может быть любым объектом python
чаще всего эта функция используется для вывода строковых сообщений.
форматрирование строк
для того, чтобы вывести форматированную строку на экран, нужно использовать строку с символами форматирования:
%s — подстановка строки
%d — подстановка целого числа
%f — подстановка числа с плавающей точкой
Подстановочные аргументы передаются в строку форматирования с помощью оператора %, за которым следует кортеж с постановочными аргументами.
Функция input
Формат вызова:
input(prompt=None, /)
Читает строку со стандартного ввода. Символ перевода строки опускается.
Если prompt указан, то он выводится в стандартный вывод без символа перевода строки.
Если пользователь послал сигнал EOF (*nix: Ctrl-D, Windows: Ctrl-Z-Return), вызывает исключение EOFError. На *nix системах используется библиотека readline, если таковая установлена.
Оператор присваивания
Оператор присваивания в Python, как и во многих других языках программирования это .
Поскольку все в Python объекты, операция присваивания копирует ссылку на объект. Это так в случае изменяемых объектов (), однако для неизменяемых, таких как , происходит создание нового объекта.
While loop
Выражение или цикл «пока» имеет следующий вид:
Цикл выполняется, пока истинно, если условие нарушается, выполняется блок и осуществляется выход из цикла
Пример:
For loop
В питоне цикл используется для прохода всех элементов в последовательности (строка, список, кортеж) или другого итерируемого объекта.
вычисляется один раз; оно должно вернуть итерируемый объект. Suite выполняется каждый раз для каждого элемента из итератора. Каждый элемент итератора в свою очередь присваивается и затем выполняется .
Когда элементы итератора исчерпываются (когда последовательность заканчивается или итератор вызывает исключение), выполняется из ветки и цикл завершается.
Если в теле цикла вызывается , она завершает цикл, без выполнения ветки . в теле цикла пропускает оставшуюся часть кода до новой итерации или до ветки , если новой итерации нет.
Цикл присваивает значения переменным из . Это действие переписывает все предыдущие присваивания переменным, включае те, что были сделаны в теле цикла.
имена из не удаляются по завершении цикла, но если итерируемая последовательность пуста, они не будут инициализированы.
функция возвращает итератор, с помощью которого можно с эмулировать работу цикла в паскале. .
Если мы итерируем по mutable объекту и нам нужно удалять или вставлять туда элементы, то цикл вида:
будет выполняться неверно, поскольку при удалении из списка его размер уменьшится, и в позиции, куда указывает итератор, будет стоять следующий элемент. На следующем шаге позиция итератора снова сдвинется, приведя к тому, что один элемент будет пропущен.
То же касается и вставки.
Выход из решения — создать временную копию списка, например с помощью сечения.
Здесь мы итерировать будем копию списка, а удалять элементы из оригинала.
Разница между атомарными и структурными типы данных
По одной из классификаций все типы данных в Python делятся на атомарные и ссылочные.
Атомарные:
- числа;
- строки;
Ссылочные:
- списки;
- кортежи;
- словари;
- функции;
- классы;
Разница между этими двумя группами уходит глубоко в корни языка. Вкратце:
Из результатов видно, что переменной было присвоено именно значение, содержащееся в atom, а не ссылка, указывающая на область памяти.
Посмотрим, как это работает для структурных типов:
Поскольку списки – это ссылочные объекты, то вполне закономерно, что после присваивания переменной переменной передалась именно ссылка на объект list-а и, при печати, на экран были выведены две одинаковые надписи.
Собственно, в этом и вся разница.
Разбор цикла for
В этом разделе мы разберем цикл for и пройдемся по инструкциям, которые интерпретатор исполняет при выполнении цикла for. Мы будем использовать модуль dis для разборки цикла for. Чтобы быть точным, мы будем использовать метод dis.dis, чтобы получить удобочитаемое представление дизассемблированного байт-кода.
Мы будем использовать тот же простой цикл for, который мы рассматривали до сих пор. Запишем следующий цикл for в файл for_loop.py.
for word in :
print(word)
else:
print("See you later!")
Теперь мы можем получить читаемую форму байт-кода, вызвав dis.dismethod. Запустим следующую команду в терминале.
$ python3 -m dis for_loop.py
1 0 SETUP_LOOP 28 (to 30)
2 LOAD_CONST 0 (('You', 'are', 'awesome!'))
4 GET_ITER
>> 6 FOR_ITER 12 (to 20)
8 STORE_NAME 0 (word)
2 10 LOAD_NAME 1 (print)
12 LOAD_NAME 0 (word)
14 CALL_FUNCTION 1
16 POP_TOP
18 JUMP_ABSOLUTE 6
>> 20 POP_BLOCK
4 22 LOAD_NAME 1 (print)
24 LOAD_CONST 1 ('See you later!')
26 CALL_FUNCTION 1
28 POP_TOP
>> 30 LOAD_CONST 2 (None)
32 RETURN_VALUE
Каждый из столбцов в разобранном виде представляет следующее:
- Колонка 1: номер строки кода.
- Колонка 2: знак «>>», если инструкция является целью перехода.
- Колонка 3: смещение байт кода в байтах.
- Колонка 4: инструкция байт-кода.
- Колонка 5: аргументы инструкции. В скобках отображается более понятный для человека имя аргументов.
Теперь давайте шаг за шагом пройдемся по нашему разобранному байт-коду и попытаемся понять, что на самом деле происходит.В этом описание термин TOS означает вершина стека (top of the stack)
строка 1, “for word in :” переводится как:0 SETUP_LOOP 28 (to 30)Этот оператор помещает блок для цикла for в стек. Блок занимает от этой инструкции до 28 байт, то есть до «30»
Это означает, что если в цикле for есть оператор break, управление переместится на «30» байт
Обратите внимание, блок else, будет пропущен если встретится оператор break. 2 LOAD_CONST 0 ((‘You’, ‘are’, ‘awesome!’))
4 GET_ITER
6 FOR_ITER 12 (to 20)Эта инструкция получает TOS, который на данный момент является нашим итератором, и вызывает для него метод next()
Если next() возвращает значение, оно помещается в стек, и будет выполнена следующая инструкция «8 STORE_NAME».
Как только функция next() указывает, что итератор исчерпан (т. к. сработал StopItered), TOS (а именно итератор) будет извлечен из стека, а счетчик байтового кода будет увеличен на 12. Это означает, что элемент управления перейдет к инструкция «20 POP_BLOCK».
8 STORE_NAME 0 (word)
строка 2, “print(word)” переводится как:10 LOAD_NAME 1 (print)
12 LOAD_NAME 0 (word)
14 CALL_FUNCTION 1Это команда вызывает функцию с позиционными аргументами.
Аргументы, связанные с функцией, будут присутствовать в TOS, как мы видели в предыдущей инструкции. Все аргументы выталкиваются до тех пор, пока не получит вызываемый объект, то есть print.
Как только он получает вызываемый объект, он вызывается путем передачи ему всех аргументов.
Как только вызов выполнен, его возвращаемое значение будет передано в TOS. В текущий момент это будет None.
16 POP_TOP
18 JUMP_ABSOLUTE 6Счетчик байт-кода теперь установлен на «6». Это означает, что следующая выполняемая инструкция будет «6 FOR_ITER». Вот так цикл проходит по элементам итератора.
Обратите внимание, что инструкция «6 FOR_ITER» заставит программу выйти из этого цикла и перейти к «20 POP_BLOCK», как только все элементы итератора будут исчерпаны.
20 POP_BLOCK
Обратите внимание, что номер строки 3, т.е., else, не имеет каких-либо конкретных инструкций, связанных с этим. Управление программой естественным образом переходит к следующей инструкции, которая в основном состоит из операторов, связанных с else.
строка 4, “print(“See you later!”)” переводится как:22 LOAD_NAME 1 (print)
24 LOAD_CONST 1 (‘See you later!’)
26 CALL_FUNCTION 1
28 POP_TOP
Следующие две инструкции в основном загружают возвращаемое значение нашего скрипта (None) в стек и возвращают его.30 LOAD_CONST 2 (None)
32 RETURN_VALUE
Вув! Итак, мы закончили с разборкой инструкций для цикла for. Я надеюсь, что это поможет немного лучше понять работу цикла for.
Передача аргументов функции
Теперь мы готовы узнать о том, как создать функцию, которая может получать доступ к аргументам, а также узнаем, как передать аргументы функции. Создадим простую функцию, которая может суммировать два числа:
Python
def add(a, b):
return a + b
print( add(1, 2) ) # 3
|
1 |
defadd(a,b) returna+b print(add(1,2))# 3 |
Каждая функция выдает определенный результат. Если вы не указываете на выдачу конкретного результата, она, тем не менее, выдаст результат None (ничего). В нашем примере мы указали выдать результат a + b. Как вы видите, мы можем вызвать функцию путем передачи двух значений. Если вы передали недостаточно, или слишком много аргументов для данной функции, вы получите ошибку:
Python
add(1)
Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: add() takes exactly 2 arguments (1 given)
|
1 |
add(1) Traceback(most recent call last) File»<string>»,line1,in<fragment> TypeErroradd()takes exactly2arguments(1given) |
Вы также можете вызвать функцию, указав наименование аргументов:
Python
print( add(a = 2, b = 3) ) # 5
total = add(b = 4, a = 5)
print(total) # 9
|
1 |
print(add(a=2,b=3))# 5 total=add(b=4,a=5) print(total)# 9 |
Стоит отметить, что не важно, в каком порядке вы будете передавать аргументы функции до тех пор, как они называются корректно. Во втором примере мы назначили результат функции переменной под названием total
Это стандартный путь вызова функции в случае, если вы хотите дальше использовать её результат.
Вы, возможно, подумаете: «А что, собственно, произойдет, если мы укажем аргументы, но они названы неправильно? Это сработает?» Давайте попробуем на примере:
Python
add(c=5, d=2)
Traceback (most recent call last):
File «<string>», line 1, in <fragment>
TypeError: add() got an unexpected keyword argument ‘c’
|
1 |
add(c=5,d=2) Traceback(most recent call last) File»<string>»,line1,in<fragment> TypeErroradd()got an unexpected keywordargument’c’ |
Ошибка. Кто бы мог подумать? Это значит, что мы указали ключевой аргумент, который функция не распознала. Кстати, ключевые аргументы описана ниже.
внешние ссылки
Таблица «методы списков»
| Метод | Что делает |
|---|---|
| list.append(x) | Добавляет элемент в конец списка |
| list.extend(L) | Расширяет список list, добавляя в конец все элементы списка L |
| list.insert(i, x) | Вставляет на i-ый элемент значение x |
| list.remove(x) | Удаляет первый элемент в списке, имеющий значение x. ValueError, если такого элемента не существует |
| list.pop() | Удаляет i-ый элемент и возвращает его. Если индекс не указан, удаляется последний элемент |
| list.index(x, ]) | Возвращает положение первого элемента со значением x (при этом поиск ведется от start до end) |
| list.count(x) | Возвращает количество элементов со значением x |
| list.sort() | Сортирует список на основе функции |
| list.reverse() | Разворачивает список |
| list.copy() | Поверхностная копия списка |
| list.clear() | Очищает список |
Нужно отметить, что методы списков, в отличие от строковых методов, изменяют сам список, а потому результат выполнения не нужно записывать в эту переменную.
>>> l = 1, 2, 3, 5, 7 >>> l.sort() >>> l >>> l = l.sort() >>> print(l) None
И, напоследок, примеры работы со списками:
>>> a = 66.25, 333, 333, 1, 1234.5
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
>>> a.index(333)
1
>>> a.remove(333)
>>> a
>>> a.reverse()
>>> a
>>> a.sort()
>>> a
Изредка, для увеличения производительности, списки заменяют гораздо менее гибкими массивами (хотя в таких случаях обычно используют сторонние библиотеки, например NumPy).
Добавить комментарий
Что такое списки?
Списки в Python — упорядоченные изменяемые коллекции объектов произвольных типов (почти как массив, но типы могут отличаться).
Чтобы использовать списки, их нужно создать. Создать список можно несколькими способами. Например, можно обработать любой итерируемый объект (например, строку) встроенной функцией list:
>>> list('список')
Список можно создать и при помощи литерала:
>>> s = [] # Пустой список >>> l = 's', 'p', 'isok'], 2 >>> s [] >>> l , 2]
Как видно из примера, список может содержать любое количество любых объектов (в том числе и вложенные списки), или не содержать ничего.
И еще один способ создать список — это генераторы списков. Генератор списков — способ построить новый список, применяя выражение к каждому элементу последовательности. Генераторы списков очень похожи на цикл for.
>>> c = c * 3 for c in 'list' >>> c
Возможна и более сложная конструкция генератора списков:
>>> c = c * 3 for c in 'list' if c != 'i' >>> c >>> c = c + d for c in 'list' if c != 'i' for d in 'spam' if d != 'a' >>> c
Создание Shadow DOM
Использование операторов is, in, not, and, or и операторов сравнения.
Условия, используемые в операторах и могут содержать любые операторы, а не только операторы сравнения.
Применение оператора :
Операторы и проверяют, входит/не входит ли значение в последовательность.
>>> basket = 'orange', 'banana', 'pear', 'apple' # вхождение/наличие элемента в списке >>> 'orange' in basket # True >>> 'crabgrass' in basket # False >>> 'banana' not in basket # False
Применение оператора :
Операторы и сравнивают, действительно ли два объекта являются одним и тем же объектом (идентичным). Это имеет значение только для изменяемых объектов, таких как списки.
var = None >>> var is None # True >>> var is not None # False
Применение операторов сравнения:
Все операторы сравнения имеют одинаковый приоритет. Сравнения могут быть записаны как цепочки сравнений. Например выражение проверяет, меньше ли , чем , и кроме того сравнивает равно ли и .
Применение булевых операторов:
Сравнения могут быть объединены с помощью булевых операторов и , а результат сравнения или любого другого булева выражения может быть сведен на НЕТ с помощью оператора . Они имеют более низкие приоритеты, чем операторы сравнения. Из булевых операторов, имеет самый высокий приоритет, а самый низкий, так что эквивалентно . Как всегда, скобки могут быть использованы для выражения желаемого приоритета в операциях.
Булевы операторы и являются так называемыми операторами замыкания: их аргументы вычисляются слева направо и вычисление прекращается, как только результат определен. Например, если и истинны , а ложно , то выражение не вычисляет .
Можно присвоить переменной результат сравнения или другое логическое выражение (типа тернарных операций в языке C — но это не то же самое!!!). При использовании логического выражения в качестве получения значения для присваивания переменной, возвращаемое значение будет равно последнему вычисляемому аргументу в логическом выражении. За подробностями обратитесь к описанию логических операторов.
Например:
>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance' >>> non_null = string1 or string2 or string3 >>> non_null # 'Trondheim'
Обратите внимание, что в Python, в отличие от языка , присваивание внутри выражений должно выполняться явно с помощью выражения присваивания (моржового оператора). Это позволяет избежать распространенного класса проблем, встречающихся в программах на языке :
Перегрузка арифметических операторов
__add__(self, other) — сложение. x + y вызывает x.__add__(y).
__sub__(self, other) — вычитание (x — y).
__mul__(self, other) — умножение (x * y).
__truediv__(self, other) — деление (x / y).
__floordiv__(self, other) — целочисленное деление (x // y).
__mod__(self, other) — остаток от деления (x % y).
__divmod__(self, other) — частное и остаток (divmod(x, y)).
__pow__(self, other) — возведение в степень (x ** y, pow(x, y)).
__lshift__(self, other) — битовый сдвиг влево (x << y).
__rshift__(self, other) — битовый сдвиг вправо (x >> y).
__and__(self, other) — битовое И (x & y).
__xor__(self, other) — битовое ИСКЛЮЧАЮЩЕЕ ИЛИ (x ^ y).
__or__(self, other) — битовое ИЛИ (x | y).
Пойдём дальше.
__radd__(self, other),
__rsub__(self, other),
__rmul__(self, other),
__rtruediv__(self, other),
__rfloordiv__(self, other),
__rmod__(self, other),
__rdivmod__(self, other),
__rpow__(self, other),
__rlshift__(self, other),
__rrshift__(self, other),
__rand__(self, other),
__rxor__(self, other),
__ror__(self, other) — делают то же самое, что и арифметические операторы, перечисленные выше, но для аргументов, находящихся справа, и только в случае, если для левого операнда не определён соответствующий метод.
Например, операция x + y будет сначала пытаться вызвать x.__add__(y), и только в том случае, если это не получилось, будет пытаться вызвать y.__radd__(x). Аналогично для остальных методов.
Идём дальше.
__iadd__(self, other) — +=.
__isub__(self, other) — -=.
__imul__(self, other) — *=.
__itruediv__(self, other) — /=.
__ifloordiv__(self, other) — //=.
__imod__(self, other) — %=.
__ipow__(self, other) — **=.
__ilshift__(self, other) — <<=.
__irshift__(self, other) — >>=.
__iand__(self, other) — &=.
__ixor__(self, other) — ^=.
__ior__(self, other) — |=.
__neg__(self) — унарный -.
__pos__(self) — унарный +.
__abs__(self) — модуль (abs()).
__invert__(self) — инверсия (~).
__complex__(self) — приведение к complex.
__int__(self) — приведение к int.
__float__(self) — приведение к float.
__round__(self) — округление.
__enter__(self), __exit__(self, exc_type, exc_value, traceback) — реализация менеджеров контекста.
Рассмотрим некоторые из этих методов на примере двухмерного вектора, для которого переопределим некоторые методы:
import math
class Vector2D
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return 'Vector2D({}, {})'.format(self.x, self.y)
def __str__(self):
return '({}, {})'.format(self.x, self.y)
def __add__(self, other):
return Vector2D(self.x + other.x, self.y + other.y)
def __iadd__(self, other):
self.x += other.x
self.y += other.y
return self
def __sub__(self, other):
return Vector2D(self.x - other.x, self.y - other.y)
def __isub__(self, other):
self.x -= other.x
self.y -= other.y
return self
def __abs__(self):
return math.hypot(self.x, self.y)
def __bool__(self):
return self.x != or self.y !=
def __neg__(self):
return Vector2D(-self.x, -self.y)
>>> x = Vector2D(3, 4)
>>> x
Vector2D(3, 4)
>>> print(x)
(3, 4)
>>> abs(x)
5.0
>>> y = Vector2D(5, 6)
>>> y
Vector2D(5, 6)
>>> x + y
Vector2D(8, 10)
>>> x - y
Vector2D(-2, -2)
>>> -x
Vector2D(-3, -4)
>>> x += y
>>> x
Vector2D(8, 10)
>>> bool(x)
True
>>> z = Vector2D(, )
>>> bool(z)
False
>>> -z
Vector2D(, )
В заключение хочу сказать, что перегрузка специальных методов — вещь хорошая, но не стоит ей слишком злоупотреблять. Перегружайте их только тогда, когда вы уверены в том, что это поможет пониманию программного кода.
Цикл for в Python
Оператор for является одним из двух операторов, используемых для создания циклов в Python, другим является оператор while. Если вы совсем не знакомы с итерациями в Python, то рекомендуем почитать статью Итерации в Python: операторы for, while, break и continue которая будет хорошей отправной точкой для изучения циклов и итераций.
Простой цикл for
Давайте начнем с простого цикла for, который перебирает список строк и печатает каждую строку.
>>> for word in : ... print(word) ... You are awesome!
Как видите, цикл перебирает все слова в списке и печатает их. То есть на каждом шаге цикла переменной word присваивается элемент списка, а затем выполняется кодовый блок. Поскольку список — это упорядоченная последовательность элементов, цикл проходит по ним в том же порядке.
Цикл for с условием else
В Python цикл for может иметь необязательное условие else. Кодовый блок в предложении else выполняется после завершения цикла for, то есть после того, как все элементы итерируемого элемента были исчерпаны. Теперь давайте посмотрим, как мы можем расширить предыдущий пример, чтобы включить условие else.
>>> for word in :
... print(word)
... else:
... print("See you later!")
...
You
are
awesome!
See you later!
Когда полезно условие else?
Как вы могли заметить, блок else выполняется после завершения цикла for. Так какой смысл использовать блок else? Разве не будет выполнен следующий набор операторов после цикла for?
Ну, во многих случаях у нас возникают ситуации, когда нам нужно выйти из цикла for, когда выполняется определенное условие. И если это условие никогда не выполняется, но нам все равно нужно выполнить набор операторов. Для этого мы обычно используем логический флаг. Давайте посмотрим на пример.
def search(search_list, search_item):
found_item = False
for word in search_list:
if word == search_item:
found_item = True
print("Found word '{}'".format(search_item))
break
if not found_item:
print("Word '{}' was not found!".format(search_item))
Использование:
>>> search(, "are") Found word 'are' >>> search(, "we") Word 'we' was not found!
С помощью блока else мы можем избежать использования логического флага found_item. Давайте посмотрим, как мы можем переписать вышеуказанный метод с помощью else
Обратите внимание, что блок else будет пропущен, если в цикле for встречается оператор break
def search(search_list, search_item):
for word in search_list:
if word == search_item:
print("Found word '{}'".format(search_item))
break
else:
print("Word '{}' was not found!".format(search_item))
Таким образом, блок else действительно полезен, только если у нас есть оператор break в цикле for, и нам нужно, чтобы выполнился набор операторов, если условие break никогда не выполнялось.
В противном случае операторы, связанные с else, просто выполняются в конце цикла for. Вы увидите это, когда мы разберем байт-код в последнем разделе этой статьи.
Синтаксис цикла for
Теперь, когда мы рассмотрели несколько основных примеров, давайте завершим этот раздел синтаксисом цикла for.
for <element> in <iterable>:
<set_of_statements_1>
else:
<set_of_statements_2>
По сути, для каждого итерируемого элемента выполняется set_of_statements_1. Как только все элементы исчерпаны, управление переходит к блоку else и выполняется set_of_statements_2.
Обратите внимание, что предложение else является необязательным. Если блок else отсутствует, цикл завершается после того, как все элементы будут пройдены, и управление переходит к следующему оператору программы
Оператор член Python
В дополнение к некоторым из перечисленных выше операторов, Python также поддерживает оператор-член, тест содержит ряд элементов, включая строки, списки или кортежи.
| операторы | описание | примеров |
|---|---|---|
| в | Если вы нашли значение в указанной последовательности возвращает значение ИСТИНА, в противном случае значение False. | х в у последовательности, возвращает истину, если х в у последовательности. |
| а не в | Если значение не найден в указанной последовательности Возвращает значение True, в противном случае значение False. | х не у последовательности, если х не у последовательность возвращает значение True. |
Следующий пример демонстрирует все члены действий оператора Python:
#!/usr/bin/python # -*- coding: UTF-8 -*- a = 10 b = 20 list = ; if ( a in list ): print "1 - 变量 a 在给定的列表中 list 中" else: print "1 - 变量 a 不在给定的列表中 list 中" if ( b not in list ): print "2 - 变量 b 不在给定的列表中 list 中" else: print "2 - 变量 b 在给定的列表中 list 中" # 修改变量 a 的值 a = 2 if ( a in list ): print "3 - 变量 a 在给定的列表中 list 中" else: print "3 - 变量 a 不在给定的列表中 list 中"
Примеры вышеуказанного вывода:
1 - 变量 a 不在给定的列表中 list 中 2 - 变量 b 不在给定的列表中 list 中 3 - 变量 a 在给定的列表中 list 中
Нововведения Python 3.9.0
Начиная с недавно вышедшей версии Python 3.9, у разработчиков больше нет необходимости импортировать абстрактные коллекции для описания типов. Теперь вместо можно использовать , то же самое происходит с , , и т.д. Полное описание этого нововведения можно прочитать тут: PEP-585.
Также добавили аннотации типов, которые в дальнейшем могут быть использованы инструментами статического анализа. где — тип переменной , а — некоторые метаданные для переменной. По оценкам некоторых авторов, эти метаданные могут быть использованы также и во время выполнения (подробности смотрите в PEP-593).
Функции, которые когда-нибудь можно выучить
Следующие встроенные функции Python определённо не бесполезны, но они более специализированы.
Эти функции вам, возможно, будут нужны, но также есть шанс, что вы никогда не прибегнете к ним в своём коде.
- : возвращает итератор (список, набор и т. д.);
- : возвращает , если аргумент является вызываемым;
- and : вместо них рекомендуется использовать генератор-выражения;
- : округляет число;
- : эта функция выполняет деление без остатка () и операцию по модулю () одновременно;
- , и : служат для отображения чисел в виде строки в двоичной, восьмеричной или шестнадцатеричной форме;
- : возвращает абсолютное значение числа (аргумент может быть целым или числом с плавающей запятой, если аргумент является комплексным числом, его величина возвращается);
- ;
- .
*args и **kwargs
Вы также можете настроить функцию на прием любого количества аргументов, или ключевых аргументов, при помощи особого синтаксиса. Чтобы получить бесконечное количество аргументов, мы используем *args, а чтобы получить бесконечное количество ключевых аргументов, мы используем *kwargs. Сами слова “args” и “kwargs” не так важны. Это просто сокращение. Вы можете назвать их *lol и *omg, и они будут работать таким же образом. Главное здесь – это количество звездочек
Обратите внимание: в дополнение к конвенциям *args и *kwargs, вы также, время от времени, будете видеть andkw. Давайте взглянем на следующий пример:
Python
def many(*args, **kwargs):
print( args )
print( kwargs )
many(1, 2, 3, name=»Mike», job=»programmer»)
# Результат:
# (1, 2, 3)
# {‘job’: ‘programmer’, ‘name’: ‘Mike’}
|
1 |
defmany(*args,**kwargs) print(args) print(kwargs) many(1,2,3,name=»Mike»,job=»programmer») |
Сначала мы создали нашу функцию, при помощи нового синтаксиса, после чего мы вызвали его при помощи трех обычных аргументов, и двух ключевых аргументов. Функция показывает нам два типа аргументов. Как мы видим, параметр args превращается в кортеж, а kwargs – в словарь. Вы встретите такой тип кодинга, если взгляните на исходный код Пайтона, или в один из сторонних пакетов Пайтон.
Логические операторы
Говоря на естественном языке (например, русском) мы обозначаем сравнения словами «равно», «больше», «меньше». В языках программирования используются специальные знаки, подобные тем, которые используются в математике: > (больше), < (меньше), >= (больше или равно), <= (меньше или равно), == (равно), != (не равно).
Не путайте операцию присваивания значения переменной, обозначаемую в языке Python одиночным знаком «равно», и операцию сравнения (два знака «равно»). Присваивание и сравнение – разные операции.
>>> a = 10 >>> b = 5 >>> a + b > 14 True >>> a < 14 - b False >>> a <= b + 5 True >>> a != b True >>> a == b False >>> c = a == b >>> a, b, c (10, 5, False)
В данном примере выражение состоит из двух подвыражений. Сначала происходит сравнение (==) переменных и . После этого результат логической операции присваивается переменной c. Выражение просто выводит значения переменных на экран.
