ЛМНты Python, 91 - 95

>>> Две или больше, the Python way

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

>>> letters = ['a', 'b', 'c']
>>> for x in letters:
...     pass
...

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

>>> numbers = [1, 2, 3]
>>> for i in range(len(letters)):
...     letter = letters[i]
...     number = numbers[i]
...

ЛМНты Python, 86 - 90

>>> Стиль имеет значение

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

i
name
full_name

Использование однобуквенных переменных l (эл), O (оу) и I (ай) считается злом, так как их непросто отличить от цифр 1 и 0 или друг от друга (l и I).

ЛМНты Python, 81 - 85

>>> Глубина копирования

Метод copy выполняет поверхностное копирование, связывая атрибуты объекта-копии с теми же объектами, с которыми связаны атрибуты объекта-оригинала. Иными словами, объекты, на которые ссылаются атрибуты копируемого объекта, не копируются:

>>> a = [
...     [1, 2, 3],
...     [4, 5, 6]
... ]
>>>
>>> b = a.copy()
>>> b[1][0] = -4
>>> b[1][1] = -5
>>> b[1][2] = -6
>>>
>>> b
[[1, 2, 3], [-4, -5, -6]]
>>> a
[[1, 2, 3], [-4, -5, -6]]
>>>
>>> a[1] is b[1]
True

ЛМНты Python, 76 - 80

>>> Разоблачение operator.itemgetter

Боюсь, последний пример с функцикй itemgetter непонятен или не нагляден.

Функция itemgetter возвращает функцию (точнее, callable объект), которая принимает на вход последовательность и возвращает элемент последовательности с нужным индексом:

>>> from operator import itemgetter
>>>
>>> getitem2 = itemgetter(2)
>>> getitem2(['a','b','c'])
'c'
>>> itemgetter(0)(['a','b','c'])
'a'
>>> itemgetter(1)(['a','b','c'])
'b'

ЛМНты Python, 71 - 75

>>> Ваша правда

В отлиичие от пустых объектов стандартных классов, объект вашего класса по умолчанию оценивается как True:

>>> class B(object):
...     pass
...
>>> b = B()
>>> if b:
...     print('True')
...
True
>>> bool(b)
True

Для того, чтобы ваш объект был оценен как False, его метод __len__ должен возвращать 0 или метод __bool__ – возвращать False.

ЛМНты Python, 66 - 70

>>> Ещё множества могут

С помощью расширенных операторов присваивания (или соответствующих им методов) можно присваивать левому множеству результат операции над ним и правым множеством:

>>> a, b = ({1, 2, 3}, {3, 4, 5})
>>> # объединение
... a |= b
>>> a.update(b)
>>> a
{1, 2, 3, 4, 5}
>>>
>>> a, b = ({1, 2, 3}, {3, 4, 5})
>>> # пересечение
... a &= b
>>> a.intersection_update(b)
>>> a
{3}
>>>
>>> a, b = ({1, 2, 3}, {3, 4, 5})
>>> # разность
... a -= b
>>> a.difference_update(b)
>>> a
{1, 2}
>>>
>>> a, b = ({1, 2, 3}, {3, 4, 5})
>>> # симметрическая разность
... a ^= b
>>> a.symmetric_difference_update(b)
>>> a
{1, 2, 3}

См. также лмнт Множества могут.

ЛМНты Python, 61 - 65

>>> Декоратор lru_cache

Еще один полезный декоратор из модуля functools стандартной библиотеки Python – это lru_cache(maxsize=128, typed=False). Этот декоратор запоминает до maxsize последних результатов, возвращаемых декорированной функцией для различных аргументов и, в случае повторного обращения к функции с теми же аргументами, возвращает результат из кэша вместо того, чтобы вызывать функцию.

Воспользуемся им, чтобы кэшировать значения чисел Фибоначчи, рассчитанные функцией fibc.

ЛМНты Python, 56 - 60

>>> Значение параметра по умолчанию

В следующем определении функции параметр c имеет значение по умолчанию:

>>> def fun(a, b, c=True):
...     return a if c else b
...
>>> fun(1, 2)
1
>>> fun(1, 2, 2<1)
2

Значения параметров по умолчанию вычисляются один раз в момент выполнения предложения def. Из этого следует, что

• в них можно использовать видимые на этот момент имена и
• они могут изменяться уже после определения функции, если являются изменяемыми (mutable) объектами.

ЛМНты Python, 51 - 55

>>> Как замыкания

Интересно, что во вложенных функциях используемые нелокальные переменные точно так же доступны через locals(), как это происходит в замыканиях с бесплатными переменными:

>>> def f():
...     one = 1
...     print('f:', locals())
...     def g():
...         two = one + 1
...         print('g:', locals())
...         def h():
...             three = two + 1
...             print('h:', locals())
...         h()
...     g()
...
>>> f()
f: {'one': 1}
g: {'two': 2, 'one': 1}
h: {'three': 3, 'two': 2}

Вложенные функции, даже не потерявшие связь с контекстом, в котором они созданы, выглядят как замыкания.

ЛМНты Python, 46 - 50

>>> Нелокальное имя

Имя x, созданное операцией присваивания в начале функции fun, внутри вложенной функции fun2 экранируется другим именем x:

>>> def fun():
...     x = 'fun'
...     def fun2():
...         x = 'fun2'
...         print(x)
...     fun2()
...     print(x)
...
>>> fun()
fun2
fun

ЛМНты Python, 41 - 45

>>> Генератор

Объект-генератор можно создать не только с помощью генераторного выражения, но и с помощью функции с предложением yield внутри:

>>> def down5():
...     n = 5
...     while n:
...         yield n
...         n -= 1
...
>>> type(down5)
<class 'function'>
>>> d5 = down5()
>>> type(d5)
<class 'generator'>

ЛМНты Python, 36 - 40

>>> Две или больше

Функции map можно подать на вход больше одной последовательности и обработать их параллельно. Например, просуммировать поэлементно две последовательности:

>>> s1 = [1, 2, 3]
>>> s2 = [4, 5, 6, 7]
>>> m = map(lambda x, y: x+y, s1, s2)
>>> list(m)
[5, 7, 9]

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

>>> z = zip(s1, range(5))
>>> list(z)
[(1, 0), (2, 1), (3, 2)]
>>> m = map(lambda x, y: (x, y), s1, range(5))
>>> list(m)
[(1, 0), (2, 1), (3, 2)]