👀 global и nonlocal

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

def foo():
    print('x is', x)

x = 5
foo()  # напечает x is 5

Однако если в функции есть присваиваниие x после использования переменной x, то возникнет ошибка:

def foo():
    print('x is', x)
    x = 10

x = 5
foo()  # UnboundLocalError: local variable 'x' referenced before assignment

Обатите внимание, что присваивание бывает в следующих ситуациях:

x = …
x += …, x -= … и т.п.
• for x in …:
• with … as x:

Чтобы избежать ошибки, мы должны явно указать перед использованием x, что она относится к глобальной области видимости:

def foo():
    global x  # <-- тут
    print('x is', x)
    x = 10
    print('x is now', x)

x = 5
foo()  # ошибок не будет

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

def make_inc():  # внешняя ф-ция
    total = 0     # счетчик
    def helper():  # внутр. ф-ция 
        total += 1  # тут присваивание переменной
        return total 
    return helper  

f = make_inc()

print(f())  # UnboundLocalError: local variable 'total' referenced before assignment

Тут нужно другое ключевое слово – nonlocal, которое укажет, что нужно искать переменную во внешней области видимости. Такой пример будет работать, как задумано:

def make_inc():
    total = 0
    def helper():
        nonlocal total  # <- тут
        total += 1
        return total
    return helper

f = make_inc()
print(f())

Почему мы редко видим global и nonlocal?
nonlocal – специфичная вещь, обычно вместо нее создают класс.
global потакает плохим практикам программирования. Менять глобальные переменные внутри функций – плохая практика.

📎 Пример.

def foo():
    global x
    print('x is', x)
    for x in range(2):
        ...
x = 5
foo()  # x is 5
foo()  # x is 1 (испортили из-за for)

Нет ошибок выполнения, но есть логическая ошибка! После первого вызова foo() мы испортили глобальную переменную x, она стала 1 (последним значением в цикле). Надо было просто называть переменные разными именами, и global не понадобится!

Специально для канала @pyway.

@ Оператор умножения матриц

А вы знали, что помимо обыденных операторов +, -, *, / и прочих, есть еще операторы @ и @=? Нет, это не про декораторы. Задуманы эти операторы были для умножения матриц и появились в версии Python 3.5. Однако встроенного типа «матрица» в Python нет, и ни один из встроенных типов эти операторы не реализует. Поэтому, быть может, о нем и не рассказывают на курсах.

Однако оператор @ рекомендуется для умножения матриц в библиотеке numpy:

>>> import numpy as np
>>> a = np.array( [ [1, 2], [-2, 3] ] )
>>> b = np.array( [ [3, 0], [1, -3] ] )
>>> a @ b
array([[ 5, -6],
       [-3, -9]])
>>> np.matmul(a, b)
array([[ 5, -6],
       [-3, -9]])

⚠️ Обратите внимание, что это именно np.matmul, а не np.dot!

Также вы можете написать реализацию операторов @ и @= для своих классов. Для этого вам понадобятся магические методы matmul__, __imatmul__, __rmatmul__ . Смотрите пример по ссылке.

Специально для канала @pyway.

🔐 Храним секреты правильно

Наверное, каждый когда-то писал в своем коде:

DB_HOST = 'localhost'
DB_USER = 'root'
DB_PASSWORD = 'l33thAxor666'

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

Для хранения секретов и паролей придет на помощь библиотека keyring.

В зависимости от ОС и среды она использует:
• macOS Keychain
• Freedesktop Secret Service
• KDE4 & KDE5 KWallet
• Windows Credential Locker
• и другие бэкенды…

Мы храним в скрипте или конфиге только название системы и логин (можете использовать произвольные):

>>> import keyring
>>> keyring.set_password("my_system", "my_username", "password")
>>> keyring.get_password("my_system", "my_username")
'password'

Другие пользователи системы не смогут прочитать эти данные. Но от вашего имени можно получить доступ к ним даже из терминала:

$ keyring set my_system my_username
Password for 'my_username' in 'my_system':
$ keyring get my_system my_username
qwerty

Считать пароль безопасно с клавиатуры можно с помощью модуля getpass (он строен в Python). Вводимые символы не будут видны на экране:

>>> import getpass
>>> password = getpass.getpass(prompt="Enter super password:")
Enter super password:
>>> password
'qwerty'

Специально для канала @pyway.

🔢 Приоритет операций

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

2 * 2 + 2 = 6

Рассмотрим таблицу приоритета операций в языке Python. Сверху таблицы самые приоритетные операции, снизу – операции с низким приоритетом.

ОперацияОписание
( )Скобки
**Экспонента (возведение в степень)
+x, -x, ~xУнарные плюс, минус и битовое отрицание
*, /, //, %Умножение, деления, взятие остатка
+, —Сложение и вычитание
<<, >>Битовые сдвиги
&Битовое И
^Битовое исключающее ИЛИ (XOR)
|Битовое ИЛИ
==, !=, >, >=, <, <=,
is, is not,
in, not in
Сравнение, проверка идентичности,
проверка вхождения
notЛогическое НЕ
andЛогическое И
orЛогическое ИЛИ

Как видно, скобки самые главные. Скобки решают все.

Если в одном выражении идут операторы одинакового приоритета, то вычисления выполняются слева направо.

Исключение составляет оператор **. Он право-ассоциативный. Т.е. в цепочке из двух ** сначала выполнится правый, а потом левый.

>>> 3 ** 4 ** 2
43046721
>>> 3 ** (4 ** 2)
43046721
>>> (3 ** 4) ** 2
6561

Обратите внимание на приоритеты not, and и or.

not a or b and c   ===   (not a) or (b and c)

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

В случае с операторами сравнения, помните про цепочки сравнений!

         x < y < z
это ни   (x < y) < z,
ни       x < (y < z),
а        x < y and y < z

Специально для канала @pyway.

⛓ Цепочки сравнений

Распространенная ситуация: проверка того, что переменная находится в заданных пределах. Можно было бы использовать логический оператор and:

if x >= 5 and x < 20:

Однако Python предоставляет нам синтаксическое удобство, которое выглядит более «математичным». Такая запись и короче, и понятнее:

if 5 <= x < 20:

В качестве операторов сравнения могут быть любые из списка в любых сочетаниях:

">", "<", "==", ">=", "<=", "!=", "is" ["not"], ["not"] "in"

Т.е. запись вида a < b > c вполне законна, хоть и трудна для понимания.

Формально, если мы имеем N операций OP1…OPN и N + 1 выражений (a, b … y, z), то запись вида:

a OP1 b OP2 c … y OPN z 

Это эквивалентно записи:

a OP1 b and b OP2 c and … and y OPN z

📎 Примеры:

x = 5
print(1 < x < 10)
print(x < 10 < x*10 < 100)
print(10 > x <= 9)
print(5 == x > 4)
a, b, c, d, e, f = 0, 5, 12, 0, 15, 15
print(a <= b < c > d is not e is f)

Специально для канала @pyway.

Итераторы и генераторы

В чем разница между итератором и генератором? Этот вопрос можно часто услышать на собеседованиях.

Итератор – более общая концепция, чем генератор.

Итератор – это интерфейс доступа к элементам коллекций и потоков данных. Он требует реализации единственного метода – «дай мне следующий элемент». Если вы пишите свой итератор на Python 3 вам нужно реализовать в классе метод __next__. Если элементы исчерпаны итератор возбудит исключение StopIteration.

📎 Пример. Итератор счетчик – выдает числа от low до high:

class Counter:
    def __init__(self, low, high):
        self.current = low
        self.high = high
    def __iter__(self):
        return self
    def __next__(self): 
        if self.current > self.high:
            raise StopIteration
        else:
            self.current += 1
            return self.current - 1

Генератор – это итератор

Генератор – это итератор, но не наоборот. Не любой итератор является генератором.

Есть два способа получить генератор:

📎 1. Генераторное выражение (что-то типа list comprehension, но возвращает генератор, а не список). Используются круглые скобки:

>>> g = (2 * i for i in range(5))
>>> type(g)
<class 'generator'>
>>> next(g)
0
>>> next(g)
2

📎 2. Генераторные функции. Это функции, где есть хотя бы одно выражение yield. Когда мы запускаем генератор, функция выполняет до первого выражения yield. То, что мы передали в yield будет возвращено наружу. Генератор при этом встанет «на паузу» до следующей итерации. При следующей итерации выполнение генератора продолжится до очередного yield.

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

Пример. Генератор чисел Фибоначчи (бесконечный):

def fib():
    a, b = 0, 1
    while 1:
        yield a
        a, b = b, a + b

>>> fib_g = fib()
>>> next(fib_g)
0
>>> next(fib_g)
1
>>> next(fib_g)
1
>>> next(fib_g)
2
>>> next(fib_g)
3
>>> next(fib_g)
5

Вызвав генераторную функцию fib() мы получили генератор. Затем мы итерируем этот генератор функцией next().

Передача данных в генератор

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

send() – отправить данные в генератор. Переданное значение вернется из той конструкции yield, на которой возникла последняя пауза генератора. При этом генератор будет прокручен на один шаг, как если бы мы вызвали next:

val = yield i  # генератор вернет i, но внутри получит val из аргумента метода send

Пример. Этот генератор просто выдает числа от 0 и далее, при этом печатает в поток вывода все, что мы ему отправляем.

def my_gen():
    i = 0
    while True:
        val = yield i
        print('Got inside generator:', val)
        i += 1

>>> g = my_gen()
>>> next(g)
0
>>> g.send("hello")
Got inside generator: hello
1
>>> g.send("world")
Got inside generator: world
2

Обратите внимание, что первый раз нельзя посылать в генератор данные, пока мы не прокрутили его до первого yield. Нужно либо взывать next(g) или g.send(None) – это одно и тоже.

Не будет ошибкой отправлять данные генератору, который не получает их (нет использования значения конструкции yield). Например, нашему генератору fib() можно отравить все, что угодно, он просто проигнорирует.

throw() – бросить исключение внутри генератора. Исключение будет возбуждено из того выражение yield, где генератор последний раз остановился.

>>> g = my_gen()   # my_gen из прошлого примера

>>> g.throw(TypeError, 'my error')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 1, in my_gen
TypeError: my error

close() – закрыть генератор. Бросает внутри генератора особое исключение GeneratorExit. Это исключение, даже если оно не обработано, не распространится в код, вызвавший close(). Но, если мы поймали это исключение внутри генератора, то после закрытия генератора нельзя уже делать yield, рискуя получить RuntimeError. Остальные виды исключений будут распространяться из генератора в код, его вызывающий. Попытка итерировать закрытый итератор приведет к исключению StopIteration (закрытый генератор – пустой итератор).

>>> g = my_gen()
>>> next(g)
0
>>> next(g)
Got inside generator: None
1
>>> g.close()
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

Бонус

Как взять из итератора (в том числе из генератора) N первых значений?

Можно, конечно, написать свою функцию. Но зачем, если она уже есть в стандартном модуле itertools. Этот модуль содержит множество вспомогательных функций для работы с итераторами. Нам понадобится itertools.islice. Первый аргумент – итератор (ну или генератор), остальные три – как в range.

>>> list(itertools.islice(fib(), 10))
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

>>> list(itertools.islice(fib(), 10, 20, 2))
[55, 144, 377, 987, 2584]

В первом примере мы передаем в функцию itertools.islice наш генератор чисел Фибоначчи и число чисел, которые надо вычислить (в нашем случае – 10).

Мы также применяем функцию list, чтобы посмотреть список значений, потому что itertools.islice возвращает не спикок, а именно новый итератор, в котором будут только интересные нам значений из исходного итератора.

Во втором примеры аргументов 4 штуки. В этом случае второй аргумент – начальный номер = 10, третий – конечный номер = 20 – (не включительно), и четвертый – шаг = 2. (Очень похоже на range, не так ли?)

Специально для канала @pyway.

Python: is

Новички часто путаются в конструкциях is и ==. Давайте разберемся, что к чему.

Сразу к сути: == (и его антагонист !=) применяются для проверки равенства (неравенства) значения двух объектов. Значение, это непосредственно то, что лежит в переменной. Значение числа 323235 – собственно число 323235. Тавтология. Но на примерах станет яснее.

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

>>> x = 323235
>>> y = 323235
>>> x == y
True
>>> x is y
False

Видите, значение переменных равны по значению, но они ссылаются на разные объекты. Я не случайно взял большое число 323235. Дело в том, что в целях оптимизации интерпретатор Python при старте создает некоторые количество часто-используемых констант (от -5 до 256 включительно).

Следите внимательно за ловкостью рук:

>>> x = 256
>>> y = 256
>>> x is y
True
>>> x = 257
>>> y = 257
>>> x is y
False
>>> x = -5
>>> y = -5
>>> x is y
True
>>> x = -6
>>> y = -6
>>> x is y
False 

Поэтому новички часто совершают ошибку, считая, что писать == – это как-то не Python-way, а is – Python-way. Это ошибочное предположение может быть раскрыто не сразу.

Python старается кэшировать и переиспользовать строковые значения. Поэтому весьма вероятно, что переменные, содержащие одинаковые строки, будут содержать ссылки на одинаковые объекты. Но это не факт! Смотрите последний пример:

>>> x = "hello"
>>> y = "hello"
>>> x is y
True
>>> x = "hel" + "lo"
>>> y = "hello"
>>> x is y
True
>>> a = "hel"
>>> b = "lo"
>>> x = a + b
>>> y = "hello"
>>> x == y
True
>>> x is y
False

Мы составили строку из двух частей и она попала в другой объект. Python не догадался (и правильно) поискать ее в существующих строках.

Суть is (id)

В Python есть встроенная функция id. Она возвращает идентификатор объекта – некоторое число. Гарантируется, что оно будет различно для различных объектах в пределах одного интерпретатора. В реализации CPython – это просто адрес объекта в памяти интерпретатора.

Так вот:

a is b

Это тоже самое, что:

id(a) == id(b)

И все! Пример для проверки:

>>> x = 10.40
>>> y = 10.40
>>> x is y
False
>>> x == y
True

>>> id(x)
4453475504
>>> id(y)
4453475600
>>> id(x) == id(y)
False

>>> x = y
>>> x is y
True
>>> id(x)
4453475600
>>> id(y)
4453475600

Значения переменных равны, но их id – разные, и is выдает False. Как только мы к x привязали y, то ссылки стали совпадать.

Для чего можно применять is?

Если мы точно знаем уверены, что хотим проверять именно равенство ссылок на объекты (один ли это объект в памяти или разные).

Еще можно применять is для сравнения с None. None – это встроенная константа и двух None быть не может.

>>> x is None
False
>>> x = None
>>> x is None
True

Также для Ellipsis:

>>> ... is Ellipsis
True
>>> x = ...
>>> y = ...
>>> x is y
True

Я не рекомендую применять is для True и False.

Потому что короче писать if x:, чем if x is True:.

Можно применять is для сравнения типов с осторожностью (без учета наследования, т. е. проверка на точное совпадение типов):

>>> x = 10.5
>>> type(x) is float
True

С наследованием может быть конфуз:

>>> class Foo: ...
...
>>> class Bar(Foo): ...
...
>>> f = Foo()
>>> b = Bar()
>>> type(f) is Foo
True
>>> type(b) is Bar
True
>>> type(b) is Foo
False
>>> isinstance(b, Foo)
True

Не смотря на то, что Bar – наследник Foo, типы переменных foo и bar не совпадают. Если нам важно учесть наcледование, то пишите isinstance.

Нюанс: is not против is (not)

Важно знать, что is not – это один целый оператор, аналогичный id(x) != id(y). А в конструкции x is (not y) – у нас сначала будет логическое отрицание y, а потом просто оператор is.

Пример уловки:

>>> x = 10
>>> x is not None
True
>>> x is (not None)
False

Сравнение пользовательских классов

Далее речь пойдет об обычных == и !=. Можно определить магический метод __eq__, который обеспечит поведение при сравнении классов. Если он не реализован, то объекты будет сравниваться по ссылкам (как при is).

>>> class Baz: ...
...
>>> x = Baz()
>>> y = Baz()
>>> x == y
False
>>> x = y
>>> x == y
True

Если он реализован, то будет вызван метод __eq__ для левого операнда.

class Foo:
 def __init__(self, x):
  self.x = x
 def __eq__(self, other):
  print('Foo __eq__ {} and {}'.format(self, other))
  return self.x == other.x

>>> x = Foo(5)
>>> y = Foo(5)
>>> x == y
Foo __eq__ <__main__.Foo object at 0x109e9c048> and <__main__.Foo object at 0x109e8a5c0>
True

Метод __ne__ отвечает за реализацию !=. По умолчанию он вызывает not x.__eq__(y). Но рекомендуется реализовывать их оба вручную, чтобы поведение сравнения было согласовано и явно.

Вопрос к размышлению: что будет если мы сравним объекты разных классов, причем оба класса реализуют __eq__?

Что будет, если мы реализуем __ne__, но не реализуем __eq__?

А еще есть метод __cmp__. Это уже выходит за рамки статьи про is. Почитайте самостоятельно…

Специально для канала @pyway.

🎎 Множества в Python

Множество (англ. «set«) – неупорядоченная коллекция из уникальных (неповторяющихся) элементов. Элементы множества в Python должны быть немутабельны (неизменяемы), хотя само содержимое множества может меняться: можно добавлять и удалять элементы из множества.

О неизменяемых множествах написано в конце этой статьи.

CPython: внутри множества реализованы как хэш-таблицы, в которых есть только ключи без значений и добавлены некоторые оптимизации, которые используют отсутствие значений. Проверка членства выполняется за время O(1), так как поиск элементов в хэш-таблицы тоже выполняется за О(1). Если интересно, как это реализовано на С: вот ссылка.

Создание множества

Сформировать множество можно несколькими способами. Самый простой – перечислить элементы через запятую внутри фигурных скобок {}. Множество может содержать элементы разных типов, главное, чтобы они были неизменяемы. Поэтому кортеж можно поместить в множество, а список – нельзя.

>>> my_set = {1, 2, 3, 4}

>>> my_hetero_set = {"abc", 3.14, (10, 20)}  # можно с кортежем

>>> my_invalid_set = {"abc", 3.14, [10, 20]}  # нельзя со списком
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

Можно также воспользоваться встроенной функцией set, чтобы создать множество из другой коллекции: списка, кортежа или словаря. Если это будет словарь – то новое множество будет составлено только из ключей этого словаря. Можно создать множество даже из строки: будет добавлена каждая буква (но только один раз):

>>> my_set2 = set([11, 22, 33])
>>> my_set2
{33, 11, 22}

>>> my_set3 = set((1, 2, 3))
>>> my_set3
{1, 2, 3}

>>> my_set4 = set({"a": 10, "b": 20})
>>> my_set4
{'b', 'a'}

>>> my_set5 = set("hello")
>>> my_set5
{'h', 'l', 'e', 'o'}

Как создать пустое множество? {} – вернет нам пустой словарик, а не множество. Поэтому, нужно использовать set() без аргументов.

>>> is_it_a_set = {}
>>> type(is_it_a_set)
<class 'dict'>

>>> this_is_a_set = set()
>>> type(this_is_a_set)
<class 'set'>

Изменение множеств

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

Добавление одного элемента выполняется методом add(). Нескольких элементов из коллекции или нескольких коллекций – методом update():

>>> my_set = {44, 55}
>>> my_set.add(50)
>>> my_set
{50, 44, 55}

>>> my_set.update([1, 2, 3])
>>> my_set
{1, 2, 3, 44, 50, 55}

>>> my_set.update([2, 3, 6], {1, 50, 60}) 
>>> my_set
{1, 2, 3, 6, 44, 50, 55, 60}

>>> my_set.update("string")
>>> my_set
{1, 2, 3, 6, 'i', 44, 'r', 50, 's', 55, 'n', 'g', 60, 't'}

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

Удаление элементов из множества

Для удаления элемента существуют методы discard() и remove(). Делают они одно и тоже, но если удаляемого элемента нет во множестве, то discard() оставит множество неизменным молча, а remove() – бросит исключение:

>>> my_set = {1, 2, 3, 4, 5, 6}
>>> my_set.discard(2)
>>> my_set
{1, 3, 4, 5, 6}

>>> my_set.remove(4)
>>> my_set
{1, 3, 5, 6}

>>> my_set.discard(10)
>>> my_set
{1, 3, 5, 6}

>>> my_set.remove(10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 10

Также есть метод pop(), который берет какой-нибудь (первый попавшийся) элемент множества, удаляет его и возвращает как результат:

>>> my_set = {3, 4, 5, 6, 1, 2}
>>> my_set
{1, 2, 3, 4, 5, 6}
>>> my_set.pop()
1
>>> my_set
{2, 3, 4, 5, 6}

Наконец, очистить множество (т.е. удалить все его элементы) можно методом clear():

>>> my_set = {1, 2, 3}
>>> my_set.clear()
>>> my_set
set()

Проверка членства

Узнать есть ли элемент в множестве очень легко оператором in (или not in, если хотим убедиться в отсутствии элемента):

>>> s = {"banana", "apple"}
>>> "banana" in s
True
>>> "tomato" not in s
True

Таким образом проверяется членства одного элемента, если нужно узнать является ли одно множество подмножеством другого, то оператор in тут не подойдет:

>>> {1, 2} in {1, 2, 3}
False

Тут подойдут операторы < и >. Чтобы получить True, с «широкой» стороны оператора должно стоять множество, полностью содержащее множество, стоящее по «узкую» сторону галочки:

>>> {1, 2} < {1, 2, 3, 4}
True
>>> {5, 6, 7, 8} > {5, 8}
True
>>> {1, 2, 3} < {1, 2, 4}
False

Итерация множеств

Пробежаться по элементам множества также легко, как и по элементам других коллекций оператором for-in (порядок обхода не определен точно):

my_set = {"Moscow", "Paris", "London"}
for elem in my_set:
    print(elem)
Moscow
London
Paris

Операции над множествами

Самое интересное – проводить математические операции над множествами.

Рассмотрим два множества A и B:

A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

Объединение

Объединение множеств – множество, в котором есть все элементы одного и другого множеств. Это коммуникативная операция (от перемены мест ничего не меняется).

В Python используется либо метод union(), либо оператор вертикальная черта «|»:

>>> A = {1, 2, 3, 4, 5}
>>> B = {4, 5, 6, 7, 8}

>>> A | B
{1, 2, 3, 4, 5, 6, 7, 8}

>>> A.union(B)
{1, 2, 3, 4, 5, 6, 7, 8}

>>> B.union(A)
{1, 2, 3, 4, 5, 6, 7, 8}

Пересечение множеств

Пересечение множеств – множество, в которое входят только общие элементы, то есть которые есть и в первом, и во втором множестве. Также коммуникативная операция.

Пересечение вычисляют методом intersection() или оператором амперсандом «&»:

>>> A = {1, 2, 3, 4, 5}
>>> B = {4, 5, 6, 7, 8}

>>> A & B
{4, 5}

>>> B & A
{4, 5}

>>> A.intersection(B)
{4, 5}

Разность множеств

Разность множеств A и В – множество элементов из A, которых нет в B. Не коммуникативная операция!

Выполняется знаком минус «-» или оператором difference():

>>> A = {1, 2, 3, 4, 5}
>>> B = {4, 5, 6, 7, 8}

>>> A - B
{1, 2, 3}

>>> B - A
{8, 6, 7}

>>> A.difference(B)
{1, 2, 3}

>>> B.difference(A)
{8, 6, 7}

Как видно есть разница, в каком порядке идут операнды.

Симметричная разность

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

Используется метод symmetric_difference() или оператор крышка «^»:

>>> A = {1, 2, 3, 4, 5}
>>> B = {4, 5, 6, 7, 8}

>>> A ^ B
{1, 2, 3, 6, 7, 8}

>>> B ^ A
{1, 2, 3, 6, 7, 8}

>>> A.symmetric_difference(B)
{1, 2, 3, 6, 7, 8}

Обратите внимание на эквивалентность операции определениям, которые я привел в начале этого раздела:

>>> A ^ B == (A - B) | (B - A)   # объединение простых разностей
True

>>> A ^ B == (A | B) - (A & B)   # разность объединения и пересечения
True

Прочее

Ко множествам можно применять стандартные функции all(), any(), enumerate(), len(), max(), min(), sorted(), sum(). Описания их ищите тут.

Прочие методы класса set:

copy() Возвращает копию множества
difference_update(other_set)Удаляет из этого множества все элементы, которые есть во множестве, переданным в аргументе
intersection_update(other_set)Обновляет это множество элементами из пересечения множеств
isdisjoint(other_set)Возвращает True, если множества не пересекаются
issubset(other_set)Возвращает True, если это множество является подмножеством другого
issuperset(other_set)Возвращает True, если это множество является надмножеством другого
symmetric_difference_update(other_set)Добавляет в это множество симметричную разность этого и другого множеств

Замороженное множество

Замороженное множество (frozen set) также является встроенной коллекцией в Python. Обладая характеристиками обычного множества, замороженное множество не может быть изменено после создания (подобно тому, как кортеж является неизменяемой версией списка).

Будучи изменяемыми, обычные множества являются нехешируемыми (unhashable type), а значит не могут применятся как ключи словаря или элементы других множеств.

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

Создаются замороженные множества функцией frozenset(), где аргументом будет другая коллекция. Примеры:

>>> A = frozenset({1, 2, 3})
>>> A
frozenset({1, 2, 3})

>>> B = frozenset(['a', 'b', 'cd'])
>>> B
frozenset({'cd', 'b', 'a'})

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

>>> A = frozenset('hello')
>>> B = frozenset('world')
>>> A | B
frozenset({'o', 'r', 'd', 'e', 'l', 'h', 'w'})
>>> A & B
frozenset({'o', 'l'})
>>> A ^ B
frozenset({'d', 'e', 'h', 'r', 'w'})

Теперь вы знаете много о множествах в Python.

Специально для канала PyWay.

⭐ Звезды в Python

Звездочка (этот символ называется «астериск») – один из самых многоликих операторов в Python. Едва ли хватит пальцев руки, чтобы перечислить все его применения. Давайте по порядку.

Умножение и размножение

Самое простое применение одиночного астериска: умножение чисел. Двойного – возведение числа в степень.

>>> 3 * 4
12
>>> 3 ** 3
27
>>> 4 ** 0.5
2.0

Если мы умножим список (или кортеж) на целое число, то получим новый список (или кортеж), где элементы исходного повторены несколько раз. Подобное случится и со строкой. Если мы умножаем на ноль (0) или на число меньше ноля, то получим пустой список, кортеж или строку.

>>> [1, 2, 3] * 5
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> ("abc", "foo", "bar") * 3
('abc', 'foo', 'bar', 'abc', 'foo', 'bar', 'abc', 'foo', 'bar')
>>> "hello world" * 4
'hello worldhello worldhello worldhello world'
>>> [1, 2, 3] * 0
[]
>>> "wat" * -10
''

Звезды в аргументах функций

Одна звездочка позволяет получить все или некоторые позиционные аргументы функции в виде кортежа. Позиционные – это те, которые просто подряд передаются без указания имени. Те, что с именем, это аргументы ключевого слова. Разберемся сначала с первыми. Ниже идут два примера. В первом мы получаем все позиционные аргументы в кортеж с названием args. Во втором случае мы обязуем пользователя наших функций передать как минимум 2 аргумента (они попадут в x и y) и дополнительно произвольное число (можно ни одного) аргументов, которые попадут в кортеж rest. Я специально развал их по-разному, не обязательно всегда называть их args. Обратите внимание, что это всегда будет кортеж, даже если мы передадим один аргумент, то получим кортеж из одного элемента.

def foo(*args):
    print('You passed {} args, they are {}'.format(len(args), args))

def foofoo(x, y, *rest):
    print('x = {}, y = {}, rest = {}'.format(x, y, rest))

>>> foo()
You passed 0 args, they are ()
>>> foo(10, 20, "str", {})
You passed 4 args, they are (10, 20, 'str', {})

>>> foofoo(11, 22)
x = 11, y = 22, rest = ()
>>> foofoo(12, 13, 15)
x = 12, y = 13, rest = (15,)
>>> foofoo(12, 13, 15, 20)
x = 12, y = 13, rest = (15, 20)

Пример такой функции мы недавно рассматривали – это хорошо знакомый нам print. Как известно, он принимает произвольное число аргументов, пользуясь выше описанным механизмом. Можете пройти по ссылке и увить его сигнатуру.

Важно, чтобы «звездная переменная» была после всех позиционных аргументов, иначе мы получим ошибку SyntaxError.

Две звездочки перед названием аргумента позволяют нам получить произвольное число произвольно названных именованных аргументов (еще их называют аргументами ключевых слов). Такую переменную часто называют **kwargs (от key-word arguments). В нее будет записан словарик (dict) из пар название ключевого слова (строка) и значение аргумента. Давайте обратимся к примерам:

def baz(**kwargs):
    print(kwargs)

>>> baz(x=1, y=2, z="hello")
{'y': 2, 'x': 1, 'z': 'hello'}
>>> baz()
{}

Как видно, без аргументов мы получили пустой словарь. А с именованными аргументами получили словарь, где их имена – ключи-строки, а их значения – собственно сами переданные значений. В функцию baz нельзя передать аргументы без имен, будет ошибка, потому что без имен – позиционные аргументы, а мы никак их не обозначили.

def foobaz(x, y, **kwargs):
    print('x = {} and y = {}'.format(x, y))
    print('also:', kwargs)

>>> foobaz(2, 3)
x = 2 and y = 3
('also:', {})

>>> foobaz(2, 3, other=77, z=88)
x = 2 and y = 3
('also:', {'other': 77, 'z': 88})

>>> foobaz(x=100, y=200, z=300)
x = 100 and y = 200
('also:', {'z': 300})

Тут мы требуем ровно два позиционных аргумента (x и – обязательные аргументы) и любое количество аргументов ключевых слов, которые попадут в kwargs. Нюанс: мы может передать x и y по именам (последний пример), но они не попадут в kwargs, а останутся только в своих соответствующих переменных x и y, и только z попал в kwargs, потому что мы заранее его не объявили.

Можно сочетать *args и **kwags в одной функции, причем именно в этом порядке.

def megafunc(x, y, *args, **kwargs):
    print('x = {} and y = {}'.format(x, y))
    print('also args: {}'.format(args))
    print('also kwargs {}'.format(kwargs))

>>> megafunc(10, 15)
x = 10 and y = 15
also args: ()
also kwargs {}

>>> megafunc(10, 15, 20)
x = 10 and y = 15
also args: (20,)
also kwargs {}

>>> megafunc(10, 15, 20, 22)
x = 10 and y = 15
also args: (20, 22)
also kwargs {}

>>> megafunc(10, 15, 20, 25, troll=30, dwarf=40)
x = 10 and y = 15
also args: (20, 25)
also kwargs {'troll': 30, 'dwarf': 40}

Еще одно применение звездочки – заставить вызывать функцию, указывая название аргументов в обязательном порядке.

def strict_foo(x, *, cat, dog):
    print(x, cat, dog)

>>> strict_foo(1, 2, 3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: strict_foo() takes 1 positional argument but 3 were given

>>> strict_foo(1, cat=2, dog=3)
1 2 3

Имя x мы можем и не указывать, просто передадим значение, но cat и dog мы обязаны указать по имени. Зачем это надо? Если функция принимает много разных аргументов, то мы можем принудить указывать имена, чтобы пользователь не перепутал их порядок. Еще такой код просто выглядит более читаемым.

Раскрытие коллекций в аргументах функций при вызове

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

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

def foo(*args):
    print(args)

>>> foo(*[1, 2, 3])
(1, 2, 3)
>>> letters = ('a', 'b', 'c', 'd')
>>> foo(*letters)
('a', 'b', 'c', 'd')

def fixed_foo(a, b, c):
    print(a, b, c, sep=' and ')

>>> fixed_foo(*(1, 2, 3))
1 and 2 and 3
>>> fixed_foo(*(1, 2, 3, 4))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: fixed_foo() takes 3 positional arguments but 4 were given

В foo мы вольны передать список или кортеж любой длины, а в fixed_foo мы обязаны передать список или кортеж длины 3, не больше, не меньше.

Допускается использовать в одном вызове звездочку несколько раз:

>>> foo(*[1, 2, 3], *['a', 'b', 'c'])
(1, 2, 3, 'a', 'b', 'c')

Можно догадаться, что двойная звездочка несет схожую функциональность – раскрывает словарь в именованные аргументы функции.

def baz(a, b, c):
    print('a = ', a)
    print('b = ', b)
    print('c = ', c)

>>> baz(**{'a': 1, 'b': 2, 'c': 3})
a =  1
b =  2
c =  3

Если у нас нет **kwargs, то передаваемый словарь должен содержать ровно столько пар ключ-значение, сколько есть аргументов в функции (без значения по-умолчанию, естественно), причем ключи должен совпадать по именам с названиями аргументов (а вот порядок не важен). То есть при ‘a’: 1 в a попадет 1 и так далее.

>>> baz(10, **{'b': 20, 'c': 30})
a =  10
b =  20
c =  30

>>> baz(b=10, **{'a': 20, 'c': 30})
a =  20
b =  10
c =  30

В примерах выше мы передаем один аргумент явно и два аргумента словарем.

Возможны разнообразные варианты вызова функции. Даже такие:

def uber_func(a, b, c, d, x=10, y=20):
    print(f'a = {a} and b = {b} and c = {c} and d = {d}, x = {x}, y = {y}')

>>> uber_func(*[1, 2], 3, **{'d': 100, 'x': 200})
a = 1 and b = 2 and c = 3 and d = 100, x = 200, y = 20

Склеивание списков и словарей

Мы можем «встраивать» одни списки, кортежи и словари в другие с помощью астерисков. Это значит, что мы добавляем элементы одной коллекции в другую. Одинарная звездочка – для списков и кортежей:

>>> ( *(1, 2), *(3, 4) )
(1, 2, 3, 4)

>>> (1, 2) + (3, 4)  # тоже самое же?
(1, 2, 3, 4)

>>> [ *(1, 2), *[3, 4] ]
[1, 2, 3, 4]

>>> ( *[1, 2], *(3, 4) )
(1, 2, 3, 4)

Это похоже на то, как мы склеиваем коллекции оператором плюс (+), вот только плюсом нельзя соединить кортеж и список, будет ошибка. А через звездочку можно. Но согласитесь, сложение читается понятнее и легче.

Со словарями это немного полезнее. Применение двойной звезды (**) позволяет обновить один словарь элементами другого или нескольких других.

>>> d = { 'x': 10, 'y': 20 }
>>> d2 = { 'a': 100, 'b': 200 }

>>> { **d, **d2 }
{'x': 10, 'y': 20, 'a': 100, 'b': 200}

>>> { **d, **d2, 'other': 'foo' }
{'x': 10, 'y': 20, 'a': 100, 'b': 200, 'other': 'foo'}

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

>>> d_old = { 'president': 'Medvedev' }
>>> d_new = { 'president': 'Putin' }
>>> { **d_old, **d_new }
{'president': 'Putin'}

Распаковка

Позволяет раскидывать по переменным содержимое сложных структур из списков и кортежей. В переменную со звездочкой попадут в виде списка все остальные значения распакуемой структуры, кроме указанных явно. Лучше это понять на примерах:

>>> numbers = [1, 2, 3, 4, 5, 6]

>>> *a, = numbers   # да, там реально одинокая запятая после a
>>> a
[1, 2, 3, 4, 5, 6]

>>> *a, b, c = numbers
>>> a, b, c
([1, 2, 3, 4], 5, 6)

>>> a, b, *middle, c = numbers
>>> a, b, middle, c
(1, 2, [3, 4, 5], 6)

>>> [a, b, *middle, c] = numbers   # скобки можно любые
>>> a, b, middle, c
(1, 2, [3, 4, 5], 6)

Имя со звездочкой может быть как в начале, так и в конце кортежа и даже в середине. В последнем и в предпоследнем примере мы берем первый (a), второй (b) элементы; потом все, кроме последнего в middle пойдут как список, и последний в – c.

Если у нас один элемент со звездочкой и ни одного без звездочки – мы должны после него указать запятую (признак кортежа).

Не важно в какие скобки мы обернем верхний уровень: в круглые, квадратные или в никакие. Обычно скобки опускают.

На одном уровне может быть только 1 элемент со звездой.

>>> *n1, x, *n2 = numbers   # так нельзя!
  File "<stdin>", line 1
SyntaxError: two starred expressions in assignment

На нескольких уровней могут быть свои звездные выражения:

>>> a, [x, y, *rest], *others, last = 100, [20, 30, 40, 50, 60], 120, 140, 160
>>> print(a, x, y, rest, others, last)
100 20 30 [40, 50, 60] [120, 140] 160

При таком присваивании значения переменных копируются.

Справа от звездного присваиванию могут быть любые итераблы, например range:

>>> x1, *middle, x2 = range(10)
>>> x1, middle, x2
(0, [1, 2, 3, 4, 5, 6, 7, 8], 9)

Пока это все применения звездочки в Python, которые мне удалось вспомнить или найти.

Специально для канала PyWay.

🖨 Все о print

print – одна из первый функций, с которой знакомятся новички, изучающие Python.

>>> print("Hello world!")
Hello world!

Однако, print умеет больше, чем просто печатать через пробел. Взглянем на сигнатуру:

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

Именованные параметры управляют поведением функции.

Во-первых, обратим внимание на параметр sep – это строка-разделитель, она будет вставлена между каждым из неименованных параметров переданным в print (по умолчанию – одиночный пробел).

>>> print(1, 2, 3, 4, sep=" and ")
1 and 2 and 3 and 4

Если передать sep=’\n’, то каждый параметр будет выведен с новой строки.

Во-вторых, параметр end – будет выведен после печати последнего аргумента. По умолчанию, перевод строки. Например, иногда требуется печатать в одну строку: тогда передим end=»:

>>> print("Same", end=''); print("Line")
SameLine

Параметр file указывает файл или поток, в который будет выводится информация, по умолчанию, это стандартный вывод sys.stdout. Можно печатать в файл:

>>> f = open('1.txt', 'w')
>>> print("hello", file=f)
>>> f.close()

Параметр flush=True заставляет систему немедленно сбросить содержимое буфера в поток вывода. Изредка данные застревают в буфере, и этим мы их проталкиваем. Например, при end=», «1» появится только через 5 секунд сразу с «2».

>>> print('1', end=''); time.sleep(5); print('2')

Исправим это:

>>> print('1', end='', flush=True); time.sleep(5); print('2')

Наконец, не забудем, что бывает удобно печатать коллекции, передав их в print со звездочкой.

>>> arr = ["Apple", "pear", "orange"]
>>> print(*arr, sep=", ")
Apple, pear, orange