​​Расскажите про любой шаблон проектирования на ваш выбор.

Случалось слышать такое на собеседованиях? Большинство людей в этот момент начинают рассказывать про синглтон (одиночку). Потому что он... простой? Да, вообще-то не очень. Попробуйте сходу вспомнить, как там реализовать его через метакласс. Да и часто ли приходится? Скорее всего вы пользуетесь уже готовым кодом для синглтона. Его даже называют "анти-паттерном", потому что он часто маскирует плохой дизайн кода, вызывает проблемы при тестировании и нарушает принцип единственной отвественности класса (и порождает себя, и делает какую-то работу). А еще, он может вызывать проблемы с многопоточностью или "многопроцессностью" в случае с Python. Поэтому хвастать знанием синглотона – не лучшая стратегия на собеседовании...

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

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

Реализация этого шаблона может быть не только объектная, но и функциональная. С нее и начнем:

# стратегия печатать на экран
def console_writer(info):
print(info)

# стратегия выводить в файл
def file_writer(info):
with open('log.txt', 'a') as file:
file.write(info + '\n')

def client(writer):
writer('Hello world!')
writer('Good bye!')

# пользователь выбирает стратегию
if input('Write to file? [Y/N]') == 'Y':
client(writer=file_writer)
else:
client(writer=console_writer)

Стратегия выбирается пользователем, а функция client даже не знает, какой вариант алгоритма ей дадут. Она знает лишь то, что writer(info) – это некая функция, принимающая строку (это и есть общий интерфейс для всех стратегий). Таким образом, мы делегируем работу стратегиям, скрывая детали реализации каждой из них.

В объектном варианте:

class Adder:
def do_work(self, x, y):
return x + y

class Multiplicator:
def do_work(self, x, y):
return x * y

class Calculator:
def set_strategy(self, strategy):
self.strategy = strategy

def calculate(self, x, y):
print('Result is', self.strategy.do_work(x, y))

calc = Calculator()
calc.set_strategy(Adder())
calc.calculate(10, 20)

calc.set_strategy(Multiplicator())
calc.calculate(10, 20)

Мы обеспечили горячую заменя алгоритмов для класса Calculator. Для простоты, здесь я не применял наследование (спасибо динамической природе Python), но в серьезных проектах, вам следовало бы написать что-то подобное:

from abc import ABC, abstractmethod

class BaseStrategy(ABC):
@abstractmethod
def do_work(self, x, y):
pass

class Adder(BaseStrategy):
def do_work(self, x, y):
return x + y

class Multiplicator(BaseStrategy):
def do_work(self, x, y):
return x * y

class Calculator:
def set_strategy(self, strategy: BaseStrategy):
self.strategy = strategy

def calculate(self, x, y):
print('Result is', self.strategy.do_work(x, y))

Здесь мы создаем общий интерфейс стратегий BaseStrategy – как абстрактный класс ABC. Далее в каждой стратегии реализуем этот интерфейс.

Надеюсь, было полезно. Если хотите еще больше подробностей, то читайте 1, 2, 3.

Как отправить Bitcoin на Python?

1. Установим библиотеку bit: pip install bit

2. Загрузим приватный ключ из WIF:

from bit import Key
my_key = Key('L3Bc5K68nfDzaW4n4ag7eERKGw6WvsvTmqvirzn1wut7uL3sg76o')

3. Отправим монеты:

my_key.send([
('1HB5XMLmzFVj2ALj6mfBsbаfRoD4miY36v', 0.0024, 'btc'),
], message='За кофе')

Очень просто и удобно! Заинтересованы? Хотите узнать больше, о том, как работать с транзакциями Bitcoin на Python? Читайте мою новую заметку!

Вы удивитесь, когда увидите эти расчеты! А еще вы немного научитесь работать с данными, делать простые предсказания и строить графики на Python.

Лямбда или оператор?

Допустим у нас есть список напитков, где каждый элемент – кортеж (название, цена):

drinks = [
('Juice', 100),
('Beer', 200),
('Soda', 50),
('Cocktail', 400),
('Water', 20)
]

Хотим отсортировать их по цене, тогда нужно в функцию sorted передать параметр key – функцию, которая достанет из кортежа элемент с индексом 1 – цену. Можно поступить разными способами. Способ 1 – lambda:

>>> sorted(drinks, key=lambda d: d[1])
[('Water', 20), ('Soda', 50), ('Juice', 100), ('Beer', 200), ('Cocktail', 400)]

Способ 2 – operator.itemgetter:

>>> from operator import itemgetter
>>> sorted(drinks, key=itemgetter(1))
[('Water', 20), ('Soda', 50), ('Juice', 100), ('Beer', 200), ('Cocktail', 400)]

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

Какой бы способ вы предпочли?

При разборе вложенных структур из словарей и списков (например, конфигов), удобно пользоваться блоком try-except.

Ловим IndexError, если индекс отсутствует в списке, и KeyError, если ключ отсутствует в словаре. Однако, лучше ловить LookupError, который является предком обоих исключений:

>>> issubclass(KeyError, LookupError)
True
>>> issubclass(IndexError, LookupError)
True

Пример:

config = {}

try:
admin = config['db'][0]['admins']['list'][0]
except LookupError:
admin = 'all'

Альтернативно, вы можете сразу обновлять записи словаря (если они не найдены) методом dict.setdefault(key, default). Этот метод проверяет, есть ли ключ в словаре, если его нет, то в словарь добавляется значение по умолчанию, и оно же возвращается. А если ключ был в словаре, то вернется значение по этому ключу. Поэтому такой неуклюжий код:

if 'workers' not in config:
config['workers'] = 8
workers = config['workers']

Может быть переписан как:

workers = config.setdefault('workers', 8)

Заметьте, что повторный вызов с другим default не поменяет уже записанное в первый раз значение:

>>> d = {}
>>> d.setdefault('foo', 10)
10
>>> d.setdefault('foo', 20)
10

Красивого всем кода!

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

1PyWaytDDQMSsEDSpBHgfPrEUJJg8NiC9w

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

PATTERN = 'PyWay'
def predicate(addr: str):
# первый символ – ID сети, пропустим его
return addr[1:].startswith(PATTERN)

Вот код перебора:

from bit import Key
while True:
k = Key() # новый случайны ключ
if predicate(k.segwit_address):
print(f'{k.segwit_address} with WIF private key {k.to_wif()}')
break

Сразу предупреждаю, что слова длиннее 5 букв ищет очень долго (сам дождался только 5-символьного). Как только адрес найден, не забудьте сохранить приватный ключ, если хотите им пользоваться.

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

​​Показываем уведомления на рабочем столе

На macOS это очень просто, даже не нужно ставить дополнительный софт и модули, а использовать встроенный osascript.

import os

def notify_macos(title, text):
os.system("""
osascript -e 'display notification "{}" with title "{}"'
""".format(text, title))

notify_macos("Поздравляю", "Ген супер-человека найден!")

На Linux можно пойти схожим путем, задействуя программу notify-send (если у вас Ubuntu, то она почти наверняка уже установлена):

import subprocess as s

def notify_linux(message, title):
subprocess.Popen(['notify-send', title, message])
return

Разработчики на Windows, и о вас я не забуду. Попробуйте win10toast.

# pip install win10toast
from win10toast import ToastNotifier

toaster = ToastNotifier()
toaster.show_toast("Заголовок",
"Текст",
duration=5)

Есть ли кросс-платформенное решение? Да, это библиотека plyer от создателей Kivy.

# pip install plyer
from plyer import notification

notification.notify(
title='Заголовок',
message='Сообщение',
app_icon=None, # e.g. 'C:\\icon_32x32.ico'
timeout=5, # секунд
)

plyer умеет не только уведомления, но и предоставляет унифицированный интерфейс к всевозможным API декстопных и мобильных ОС.
Однако, plyer потребует установки дополнительного софта или модулей для каждой платформы. Когда вы в первый раз запустите код, не удивляйтесь ошибкам. Например, на macOS мне потребовалось установить Cython и pyobjus. Библиотека plyer сам по себе не вытягивает эти зависимости, поэтому в вашем проекте не забудьте их добавить самостоятельно (например, в requirements.txt)

Счетчик itertools.count

Если вам нужно считать неизвестное заранее количество шагов цикла while, то в место кода вида:

attempt = 1
while True:
...
attempt += 1

Можно написать более лаконично, делегировав функциональность по счету к count:

from itertools import count

for attempt in count(1):
...

count(start=0, step=1) – бесконечный итератор, который выдает возрастрающую последовательность чисел. По умолчанию счет начинается с 0 с шагом 1: 0, 1, 2, 3, 4, ... Но можно и настроить: первый аргумент – начальное значение, второй – шаг. Таким образом, count(2, 3) выдаст 2, 5, 8, 11, ...

О наследовании атрибутов

Видел тут на одном из каналов задачку про поле класса и наследование. Загадывать вам ее не буду, но объяснение приведу. Пусть:

class Abram:
foo = 10

class Barak(Abram):
pass

class Clara(Barak):
pass

print(Abram.foo, Barak.foo, Clara.foo) # 10 10 10

Тут понятно и новичку, что поле foo вроде как "наследуется" классами Barak и Clara у класса Abram. Однако, давайте попробуем его поменять:

Abram.foo = 20
print(Abram.foo, Barak.foo, Clara.foo) # 20 20 20

Barak.foo = 30
print(Abram.foo, Barak.foo, Clara.foo) # 20 30 30

Abram.foo = 40
print(Abram.foo, Barak.foo, Clara.foo) # 40 30 30

Видим, что у класса Barak и Clara значение стало 30, а Abram.foo живет своей жизнью после Barak.foo = 30 и не перестало влиять на прочие классы.

Работает это так. При поиске атрибута класса сначала спрашивается у самого класса, есть ли у него этот атрибут, если да, то он вернется, если нет, то идут к следующему классу, который старше по иерархии наследования (Clara → Barak → Abram → object). Если у него тоже нет, то идут еще дальше, пока не найдут, иначе возникнет исключение AttributeError.

В нашем примере будем рассуждать с конца. Чему равно Clara.foo? Есть ли атрибут foo у Clara? Вообще говоря, его нет, ведь мы ни разу не присваивали ничего к Clara.foo:

>>> 'foo' in Clara.__dict__
False

Предок класса Clara – класс Barak. Как только мы написали Barak.foo = 30 в классе Barak появился свой собственный foo:

>>> Barak.foo = 20
>>> 'foo' in Barak.__dict__
True

А до этого атрибут foo был изначально только у Abram. Если теперь написать Clara.foo = 50, то у каждого из классов будет свой foo.

Clara.foo = 50
print(Abram.foo, Barak.foo, Clara.foo) # 40 30 50

Вывод: как только мы присвоим атрибут, то атрибуты классов-предков перестают на него влиять. Будьте внимательны, ведь такая же логика действует и для методов класса.

Как узнать имя переменной?

Какой-то из каналов про Python писал, что это невозможно узнать имя переменной, которой мы что-то присвоили. Это не совсем так. Представляю вам функцию, которая вернет все имена, ассоциированные с переданным ей объектом. Она использует модуль inspect, который позволяет узнать о загруженном в Python коде все, что можно только придумать, в том числе и имена переменных:

def find_names(obj):
import inspect
# currentframe - текущий контекст выполнения, т.е. эта же функция
# а f_back - фрейм код, который ее вызвал
parent_frame = inspect.currentframe().f_back

# соберем все глобальные и локальные переменные вызывающего кода
# это словарь имя переменной: ее значение
search = {**parent_frame.f_globals, **parent_frame.f_locals}
for name, v in search.items():
# если переменная ЯВЛЯЕТСЯ искомым объектом вернем ее имя
if v is obj:
yield name

Тестируем:

class A: ...
x = A()
y = x
print(list(find_names(x))) # ['x', 'y']

Так как имен может быть несколько, то возвращается список. Кроме того, может быть ситуация, когда в список запрячутся посторонние имена. Например, на None могут ссылаться встроенные переменные интерпретатора:

a = None
print(list(find_names(a)))
# ['__doc__', '__package__', '__spec__', '__cached__', 'a']

Зачем это вообще нужно? Например, можно сделать функцию, что будет составлять словарь из переменных по их именам:

def make_dict(*args):
return {next(find_names(_arg)): _arg for _arg in args}

a, b, c = 10, 20, 30
d = make_dict(a, b, c)
print(d) # {'a': 10, 'b': 20, 'c': 30}

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

#хаки #секреты

NumPy-бродкастинг

Можно ли сложить NumPy-массивы совершенно разных форм?

import numpy as np
a = np.ones((8, 1, 6, 1))
b = np.ones((7, 1, 5))
(a + b).shape # ?

Оказывается, да! Не будет никаких ошибок, а форма результата будет (8, 7, 6, 5). Интересно, как это получается? Дело в том, что здесь работает механизм бродкастинга (broadcasting), когда недостающие размеры расширяются путем "копирования" данных. А когда формы массивов выровнены, происходит простое поэлементное сложение.

Чтобы бродкастинг работал, формы должны быть все-таки совместимы. Вы выравниваем их друг под другом по правому краю и начинаем сравнивать каждый столбик справа налево (от более глубоких уровней вложенности до наружных). Если числа в столбиках равны – прекрасно, действие не требуется. Если в какое-то число в столбике – единица (1), то не беда, это измерение будет копировано столько раз, сколько нужно, чтобы уравнять размеры. А если размерности не хватает, она будет добавлена (это равносильно единице).

A (4d массив): 8 x 1 x 6 x 1
B (3d массив): 7 x 1 x 5
Результат (4d массив): 8 x 7 x 6 x 5

Кстати, кто из читателей знает, как выключить бродкастинг, пишите в наш чат. Лично я не нашел способа, а предложения со Stackoverflow оказались нерабочими.

#numpy #datascience

Чтобы сохранять и загружать данные на уровне отдельных байтов пригодится модуль struct.

Форматная строка указывает в какой последовательности и какие типы данных упакованы в байты. За ней следуют сами данные. Вот пример упаковки:

>>> import struct
>>> struct.pack('>hhl', 1, 2, 3)
b'\x00\x01\x00\x02\x00\x00\x00\x03'

И распаковки:

>>> struct.unpack('>hhl', _)
(1, 2, 3)

Приглашаю прочитать статью про struct, где вы найдете:

• Объяснение форматов
• Таблицы типов данных
• Little vs big endian
• Много примеров

Задачка. Имеется такой код, где мы делаем 5 записей в словарь:

d = {}

d[float('nan')] = 1
d[float('nan')] = 2
d[1.0] = 'float'
d[1] = 'int'
d[True] = 'bool'

print(len(d))

🌷Всех дам поздравляю с Международным женским днем! 🌷
Желаю вам счастья, любви, здоровья, отличного настроения, улыбок, солнца на улице и в душе!
Мы вас очень любим и ценим!
[код]

Решение предыдущей задачи

Если кратко, то при поиске словарь проверяет сначала хэш (hash) от ключей. Разные хэши – разные ключи – разные записи. Если хэши равны, то проверяется простое равенство (==) ключей. Если и они равны, то считается, что это один и тот же ключ, и ему отвечает одна и та же запись в словаре.

Все float('nan') имеют одинаковый хэши, но значение NaN (not a number – не число), не равно никакому другому float, включая само себя и другие float('nan'), поэтому для словаря все nan – разные ключи, и каждому из них отвечает отдельная запись.

>>> float('nan') == float('nan')
False
>>> hash(float('nan'))
0
>>> {float('nan'): 1, float('nan'): 2}
{nan: 1, nan: 2}

Кстати, спрашивали, как добраться до этих nan. Вот так:

>>> keys = list(d.keys()) # список ключей
>>> d[keys[0]], d[keys[1]] # по ключам добираемся до значений
(1, 2)
>>> del d[keys[0]] # убрать одно

Теперь ситуация с ключами 1, 1.0, True. Оказывается, их хэши тоже равны между собой. Нюанс в том, что и сами они равны между собой!

>>> hash(1), hash(1.0), hash(True)
(1, 1, 1)
>>> 1 == 1.0 == True
True

Поэтому для словаря – ключи 1, 1.0, True – одинаковые и дают доступ к одной и той же записи. Фактический ключ будет тот, что был записан самым первым.

Таким образом, у нас будет 2 записи от двух nan, и одна запись от 1, 1.0, True. Итого, ответ – 3.

​​Танчики на PyGame

Занятые вышли дни, поэтому не смог написать новых статей. Но, чтобы вы не скучали, вот вам один из моих проектов – Танчики на PyGame.
Игра хоть и не доделана полностью: в ней нет меню, звуков и редактора, но геймплей вполне работоспособный. Танчики спавнятся, атакуют, взрываются, стены разрушаются.

Управление – стрелки и пробел на выстрел.

main.py – точка входа. Инициализирует PyGame, создает класс Game, обрабатывает ввод с клавиатуры.
ai.py – интеллект врагов, включая алгоритм их появления.
bonus.py – игровой объект бонуса.
bonus_field_protect.py – алгоритм работы бонуса на защиту базы.
config.py – конфигурация и ключи запуска.
discrete_map.py – объект дискретной 2D карты (нужна для карты поля боя и карты для столкновений).
explosion.py – игровой объект взрыва.
field.py – игровой объект поля боя, обрабатывает столкновения и разрушение мира.
game.py – собирает все объекты вместе и связывает события.
my_base.py – игровой объект базы игрока (орел).
projectile.py – игровой объект снаряда.
score_node.py – игровой объект очков при уничтожении врага.
spritesheet.py – загрузчик спрайтов из одной сборной текстуры.
tank.py – игровой объект любого танка (своего или вражеского).
ui.py – элементы пользовательского интерфейса.
util.py – вспомогательные функции и классы, включая аниматор, таймер и базовый игровой объект.

Возможно, кому-то код пригодится, как учебное пособие, или вдруг найдутся добровольцы, которые внесут в него свой вклад. Ссылка на GitHub.

Думаю, вы знаете, что при форматировании можно задавать параметры, например, число знаков для дробных чисел или выравнивание текста:

>>> '{:.3}'.format(2.7182)
'2.72'

>>> '{:^15}'.format('hello')
' hello '

Эти параметры тоже можно задать динамически. Нет нужды дважды вызывать format, а достаточно просто добавить фигурные скобки внутрь фигурных скобок:

>>> '{:.{prec}}'.format(2.7182, prec=3)
'2.72'
>>> '{:{align}{width}}'.format('hello', align='^', width=15)
' hello '

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

data = [4, 8, 15, 16, 23, 42]
'{d[4]} {d[5]}'.format(d=data)
# '23 42'

class Plant(object):
type = 'tree'

'{p.type}'.format(p=Plant())

С богатыми возможностями форматирования вы можете познакомиться на сайте https://pyformat.info/ (англ.)

От себя еще добавлю, что f-строки еще круче, чем ''.format(...): внутри фигурных скобок возможно поставить вообще любое валидное Python выражение, хоть вызов функций:

>>> f'2 + 2 = {2 + 2}'
'2 + 2 = 4'
>>> f'sqrt(2) = {2**0.5:.5}'
'sqrt(2) = 1.4142'
>>> data = [1, 2, 3, 4]
>>> f'data sum = {sum(data)}'
'data sum = 10'

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

>>> f'{import os}'
File "<fstring>", line 1
(import os)
^
SyntaxError: invalid syntax

Вообще, способность вычислять выражения внутри строк и подставлять результат в нужно место строки называется: "интерполяция строк". Она работает не зависимо от типа кавычек строки, главно наличии буквы f перед строкой.

📕 #Библиотека XlsxWriter

Белые воротнички не умеют читать файлы JSON? Начальник требует от вас выгружать отчеты в ламповой Эксельке? Не беда. Библиотека XlsxWriter поможет все автоматизировать без головной боли. Просто взгляните на код:

import xlsxwriter

# откроем файл на запись
workbook = xlsxwriter.Workbook('my_report.xlsx')
# создадим лист
worksheet = workbook.add_worksheet()

# данные
expenses = (
['Аренда', 1000],
['Комуналка', 100],
['Еда', 300],
['Качалка', 50],
)

# формат для денег
money = workbook.add_format({'num_format': '#,##0"₽"'})
# формат жирности шрифта
bold = workbook.add_format({'bold': True})

worksheet.write('A1', 'Наименование', bold)
worksheet.write('B1', 'Потрачено', bold)

for i, (item, cost) in enumerate(expenses, start=2):
worksheet.write(f'A{i}', item)
worksheet.write(f'B{i}', cost, money)

# колонкой ниже добавить подсчет суммы
worksheet.write('A6', 'Итого:', bold)
worksheet.write('B6', '=SUM(B2:B5)', money)

# задать колонкам от 0 до 1 каждой ширину 15
worksheet.set_column(0, 1, 15)

# сохраняем и закрываем
workbook.close()

В статье больше примеров!

#xls #excel

Python – это компилятор или интерпретатор?

Ответ неоднозначный. Python – это и первое, и второе. (Здесь мы говорим про самый распространенный CPython)
Когда вы вводите в терминале операторы по одному, то они выполняются сразу после ввода, в этом случае Python играет роль интерпретатора.
А если вы скармливаете Python исходный файл целиком, то он сначала компилирует его в промежуточное представление: низкоуровненый байт-код. Замечали файлы *.pyc? Вот это уже скомпилированный байт-код. Он выполняется виртуальной машиной Python.

Набросал для вас реализацию языка Brainfuck, причем в двух вариантах: интерпретатора и компилятора. Интерпретатор читает программу и сразу выполняет ее команда за командой, а компилятор выдает нам исполняемый файл, которым мы запускаем отдельно от компилятора. Уловили разницу?

Рассказ о том, как я автоматизировал загрузку гербов субъектов РФ из Википедии как небольшой туториал по веб-скрейпингу.