Паттерн позволяет вызывать функции объекта для его сборки цепочкой, и это может выглядеть примерно так:
UserBuilder().with_name(“Ivan“).with_email(“i_connor@mail.ru“).with_subscription().build()

Пример применения

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

• *имя: str
• *фамилия: str
• *почта: str
• подписка:
• *тип подписки: str
• *наличие подписки (да/нет): bool
• *количество бонусных баллов: int
• *адрес: str
• о себе: str
• друзья: list[str]

где * означает обязательность поля.

В формате json это выглядит так:

{
    "name": "Vova",
    "last_name": "Ivanov",
    "email": "vivanov@mail.ru",
    "subscription": {
        "type": "hd+",
        "active": True
    },
    "bonuses": 1500,
    "address": "Belgorod, Lenina str., b. 10",
    "about": "Some additional info",
    "friends": ["12354", "1435462", "626245", "62461134"]
}

Простор для перебора параметров довольно обширен. Рассмотрим несколько вариантов для параметризации теста:

1. Хранить заранее заготовленные  json-ы где-то в константах или отдельно в файлах, передавать их в тест
2. Сделать функцию / фикстуру с параметрами для нужных полей
3. Использовать faker для генерации рандомных данных и возвращать только их, без чуткого контроля над данными
4. Создать удобный конструктор, где мы можем сами контролировать нужные поля, их наличие и значения

Выберем последний вариант и имплементируем наш класс-билдер.

Перед написанием кода нам понадобится установить дополнительную библиотеку faker.
Для этого используем команду: pip install Faker

import copy
import random
from pprint import pprint
from faker import Faker


class UserBuilder:
    def __init__(self):
        self._final_dict = {}  # Изначально пустой словарь, который будет пополняться даннными
        self.faker = Faker(locale="ru_RU")

    # Ниже перечислены методы, отвечающие за интересующие нас поля для сборки финального json-а

    def with_name(self, name: str | None = None) -> "UserBuilder":
        self._final_dict["name"] = name or self.faker.first_name_female()
        return self

    def with_last_name(self, last_name: str | None = None) -> "UserBuilder":
        self._final_dict["last_name"] = last_name or self.faker.last_name_female()
        return self

    def with_email(self, email: str | None = None) -> "UserBuilder":
        self._final_dict["email"] = email or self.faker.email()
        return self

    def with_subscription(self, is_active: bool, s_type: str) -> "UserBuilder":
        self._final_dict["subscription"] = {"active": is_active, "type": s_type}
        return self

    def with_bonuses(self, amount: int | None = None) -> "UserBuilder":
        self._final_dict["bonuses"] = amount or random.randint(500, 2000)
        return self

    def with_address(self, address: str | None = None) -> "UserBuilder":
        self._final_dict["address"] = address or self.faker.address()
        return self

    def with_about(self, about: str | None = None) -> "UserBuilder":
        self._final_dict["about"] = about or self.faker.text(max_nb_chars=100)
        return self

    def with_friends(self, friends_list: list[str]) -> "UserBuilder":
        self._final_dict["friends"] = friends_list
        return self

    def build(self) -> dict:
        user_data = copy.deepcopy(self._final_dict)
        self._final_dict.clear()
        return user_data  # Финальный аккорд билдера. Возвращает собранный словарь

Коротко о том, что у нас получилось:

• Создали класс с пустым словарем в приватном атрибуте self._final_dict в __init__
• Описали поля, которыми и будет заполняться наш пустой словарик.
  - Возврат self здесь является важной особенностью, т.к. это позволяет нам вызывать методы цепочкой через точку.
  - Упрощенно: при использовании билдера мы создаем объект класса и именно его и возвращаем каждый раз при вызове методов. Это позволяет всегда иметь доступ к методам и атрибутам экземпляра класса.
  - Конструкции вида email or self.faker.email() позволяют нам использовать фейковую генерацию данных, если мы ничего не передали в аргумент метода.
• В методе build уже возвращается не экземпляр класса, а собранный нами словарь. Это завершающий метод билдера.
  Кроме того, для безопасной работы и возможности создания одного экземпляра класса UserBuilder для генерации нескольких словарей, внутри реализован механизм копирования данных в отдельную переменную, а затем очистка собранного нами словаря.

На этом кратком объяснении и остановимся, перейдем к использованию:

# Создаем экземпляр класса UserBuilder
builder = UserBuilder()


# Первый пользователь с полным набором полей
user1 = (
    builder
    .with_name("Егор")
    .with_last_name("Летов")
    .with_email("eletov@mail.ru")
    .with_subscription(is_active=True, s_type="hd+")
    .with_bonuses(2000)
    .with_address("Омск")
    .with_about("Музыкант")
    .with_friends(["1234141", "35152446"])
    .build()
)


# Второй пользователь с набором полей поменьше
user2 = (
    builder
    .with_name("Денис")
    .with_last_name("Сергеев")
    .with_email("dsergeev@mail.ru")
    .with_bonuses(1000)
    .build()
)


# Третий пользователь с полностью сгенерированными данными с использованием библиотеки faker
user3 = (
    builder
    .with_name()
    .with_last_name()
    .with_email()
    .with_address()
    .build()
)


# Распечатаем все с помощью функции pprint, которая сделает наш вывод немного красивее
pprint(user1, indent=2, sort_dicts=False)
pprint(user2, indent=2, sort_dicts=False)
pprint(user3, indent=2, sort_dicts=False)

Давайте посмотрим на результат:

{ 'name': 'Егор',
  'last_name': 'Летов',
  'email': 'eletov@mail.ru',
  'subscription': {'active': True, 'type': 'hd+'},
  'bonuses': 2000,
  'address': 'Омск',
  'about': 'Музыкант',
  'friends': ['1234141', '35152446']}
{ 'name': 'Денис',
  'last_name': 'Сергеев',
  'email': 'dsergeev@mail.ru',
  'bonuses': 1000}
{ 'name': 'Феврония',
  'last_name': 'Кузнецова',
  'email': 'naina_1999@example.com',
  'address': 'с. Ухта, ш. Революционное, д. 2 к. 4/1, 906254'}

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

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

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

Мой telegram-канал, присоединяйтесь :)

⬇⬇⬇

https://t.me/python3_with_love

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

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

Пара слов о property

Примеры сразу будем рассматривать с удобными аннотациями @property - свойствами. Это более "питонический" путь работы с поведением атрибутов, такими как получение, настройка и удаление.

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

Как связаны свойства с геттерами и сеттерами? Когда мы получаем доступ к свойству, то автоматически вызывается связанный с ним getter-метод. Когда мы пытаемся изменить свойство, соответственно будет вызван setter-метод.

А теперь перейдем к практике.

Пример использования

Создадим класс Product, чтобы мы могли провернуть с ним некоторые процедуры:

• создать конкретный продукт, задав ему имя и базовую стоимость (без НДС)
• получить стоимость продукта с / без НДС
• назначить новую цену, введя сумму с НДС, выполнить расчет базовой стоимости и записать ее в приватный атрибут.

class Product:  
    def __init__(self, name: str, base_price: float) -> None:  
        self.name = name  
        self.__base_price = base_price  
        self.__vat_percent = 0.13  
  
    @property  
    def price(self) -> float:  
        return round(self.__base_price * (1 + self.__vat_percent), 2)  
  
    @price.setter  
    def price(self, value: float) -> None:  
        # пересчитываем базовую цену, т.к. передаем в value цену с НДС
        self.__base_price = round(value / (1 + self.__vat_percent), 2)  
  
    @property  
    def base_price(self) -> float:  
        return self.__base_price

Сразу определим, что НДС будет равен 13%.

Под капотом некоторые обработки для свойств:

• Округление и рассчет цены с НДС при получении цены через свойство price
• Рассчет базовой стоимости по полученной стоимости с НДС, округление и установка значения в приватный атрибут __base_price

Класс описали, посмотрим теперь на пример использования:

coffee = Product(name="Флэт уайт", base_price=300)  # Создаем наш кофе с ценой до НДС = 300 р.

print(coffee.name)  # Флэт уайт | Здесь просто название
print(coffee.price)  # 339.0 | Цена рассчитана с НДС, это произошло автоматически
  
coffee.price = 350  # Устанавливаем новую цену для кофе, сумма сразу с НДС, чтобы произошла корректная обработка и вычисление базовой стоимости
print(coffee.price)  # >>> 349.99  | Получаем цену с НДС. Не равно 350 из-за округлений при записи
print(coffee.base_price)  # >>> 309.73  | Базовая цена без НДС

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

Маленький бонус: deleter

Хоть в нашем примере это не имеет особого смысла, но для рассмотрения еще 1 свойства можно попробовать обновить пример так, чтобы использовать deleter. Это свойство уместно, когда нужно удалить атрибут или сбросить его в изначальное состояние, или обработать удаление атрибута каким-то определенным образом.

Добавим в наш пример с Product следующее свойство:

@price.deleter
def price(self):
	self.__base_price = 0

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

del coffee.price  
print(coffee.price)  # 0.0

Выводы

Геттеры и сеттеры:

✅ помогают скрыть реализацию и сохранить инкапсуляцию
✅ позволяют валидировать или изменять данные при доступе к ним
✅ обеспечивают простой и читаемый интерфейс (без явных методов)

Лучше использовать методы вместо свойств, если:

• операция не выглядит как "доступ к данным"
• требуется более сложная логика

Мой telegram-канал, присоединяйтесь :)

⬇⬇⬇

https://t.me/python3_with_love

Что это и когда применять

Синтаксис

enumerate(iterable, start=0)

Описание

Функция enumerate() возвращает объект enumerate, который является итератором, создающим кортежи. Этот кортеж содержит счетчик от start (который по-умолчанию равен 0) и значение, полученное в результате перебора по iterable. Объект, переданный в iterable, должен быть последовательностью, итератором или другим объектом, поддерживающим метод итератора __next__().

Параметры

• iterable По сути, iterable — это любой объект, по которому можно пройтись в цикле (списки, строки, файлы и т.д.).
• start Позволяет задать начальное значение счетчика, что полезно, если нумерация должна начинаться не с 0, а с другого числа.

Если вы когда-нибудь писали цикл for и ловили себя на мысли: "Вот бы знать, на каком я сейчас шаге итерации", то enumerate — это ваш новый лучший друг. Функция позволяет избавиться от необходимости инициировать и обновлять отдельную переменную-счётчик.

Примеры

1. Перебор по списку

Давайте рассмотрим пример:

• Создадим список
• Выведем каждый элемент с индексом без enumerate
• Выведем каждый элемент с индексом с использованием enumerate

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

list_of_things_from_closet = ["толстовка", "футболка", "кепка", "шорты", "джинсы"]  
  
# Печатаем каждый элемент из списка с его индексом  
for i in range(len(list_of_things_from_closet)):  
    # i + 1, т.к. в обычной жизни мы не считаем элементы с 0, а начинаем с единицы  
    print(f"Вещь № {i + 1} - это {list_of_things_from_closet[i]}")

В консоли увидим следующее:

>>> Вещь № 1 - это толстовка
>>> Вещь № 2 - это футболка
>>> Вещь № 3 - это кепка
>>> Вещь № 4 - это шорты
>>> Вещь № 5 - это джинсы

Теперь попробуем реализовать ровно то же самое, но с помощью enumerate:

for index, element in enumerate(list_of_things_from_closet, start=1):
    print(f"Вещь № {index} - это {element}")

Вывод получим ровно такой же.

Выглядит проще и более читаемо, не так ли?

Перейдем к более реальной задаче (хотя что может быть реальней, чем перебор шкафа с вещами?!)

2. Перебор по файлу с логами

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

Создадим файл с логами

Для начала создадим текстовый файл server_logs.txt с примером логов:

2025-01-25 18:00:00 INFO: Server started
2025-01-25 18:05:23 ERROR: Disk space low
2025-01-25 18:10:45 WARNING: High CPU usage
2025-01-25 18:15:10 ERROR: Failed to connect to database
2025-01-25 18:20:30 INFO: Backup completed successfully
2025-01-25 18:25:00 ERROR: User authentication failed

Откроем файл и обработаем его с помощью enumerate

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

def get_logs_by_level(level: str, filename: str = 'server_logs.txt') -> None:  
    # Открываем файл с логами  
    with open(filename, 'r', encoding='utf-8') as file:  
        # Итерируемся по строкам с помощью enumerate  
        for line_number, line in enumerate(file, start=1):  
            # Проверяем, есть ли в строке ключевое слово, соответствующее уровню лога "level" (регистр не учитываем)  
            if level in line.upper():  
                # Выводим номер строки и само событие  
                print(f"Строка {line_number}: {line.strip()}")  


# Попробуем напечатать только логи уровня Error:  
get_logs_by_level(level="ERROR")  

# Результат:  
# Строка 2: 2025-01-25 18:05:23 ERROR: Disk space low  
# Строка 4: 2025-01-25 18:15:10 ERROR: Failed to connect to database  
# Строка 6: 2025-01-25 18:25:00 ERROR: User authentication failed  


# А теперь напечатаем строки с ворнингами:  
get_logs_by_level(level="WARNING")  
  
# Результат:  
# Строка 3: 2025-01-25 18:10:45 WARNING: High CPU usage

Класс, все работает ровно так, как нам и хотелось.

Заключение

Функция enumerate — это простой, но мощный инструмент, который помогает сделать код чище и читаемее. Она избавляет от необходимости вручную управлять индексами и делает итерацию по элементам более удобной. Кроме того, использование enumerate делает код более безопасным, так как исключает риск ошибок, связанных с некорректным обновлением индексов вручную.

Мой telegram-канал, присоединяйтесь :)

⬇⬇⬇

https://t.me/python3_with_love

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

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

Чем же плохо хранение паролей в открытом виде?

Это однозначно небезопасно и может привести к серьезным последствиям.

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

Кроме того, как мы обычно поступаем? Мы придумываем 1 пароль для многих сервисов для удобства. А если злоумышленник уже получил логин-пароль от одного сервиса, то можно считать, что он уже получил ключики от всех дверей. Осталось их только перебрать :).

Погружаемся в тему

Итак, давайте в рамках статьи представим, что у нас есть вымышленный сервис доставки dostavallo, который хранит пароли в открытом виде, примерно так:

------------------------------------------
| email | password |
| ------------------ |-------------------- |
| user1@gmail.com | my_best_password |
| user2@yandex.ru | secured_password |
------------------------------------------
Поможем ему обезопаситься и не потерять пользователей!

База

Без теории никак, поэтому немного ознакомимся с основными терминами.

Хэш-функция

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

Главная особенность полученных хэшей в том, что они односторонние, то есть расшифровать их и получить исходный пароль уже не получится.

Соль

Часто в контексте безопасного хранения паролей можно услышать фразу "Надо посолить пароль" :) Что же это значит?

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

Соль в нашем случае нужна для защиты от атак с использованием радужных таблиц.

Радужные таблицы

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

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

Почему не шифрование?

К слову, почему хэширование, а не шифрование? Потому что это односторонний процесс и восстановить исходный пароль уже вряд ли получится.
Шифрование подходит для данных, которые нужно вернуть в исходный вид, например, для передачи сообщений. В случае с паролями такой необходимости нет, поэтому хэширование предпочтительнее.

За дело берется bcrypt

bcrypt - адаптивная криптографическая хеш-функция формирования ключа, используемая для защищенного хранения паролей.

В Python уже есть готовая библиотека, которую мы и используем.

Реализация

Давайте напишем небольшой скрипт, который будет хэшировать пароли.

Для начала устанавливаем библиотеку к себе в проект:

pip install bcrypt

Попробуем посолить и хэшировать пароль:

# Наш исходный пароль: 123
password = "123"
 
# Генерируем соль, хэшируем пароль с солью и предоставляем его
# в виде строки из байткода с помощью функции decode()
hashed_password = bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode()
 
# Теперь наш пароль выглядит примерно так:
print(hashed_password)
>>> '$2b$12$G3gSjjkBe1Bq3zwOGbmIXOUQ9C48kYcB6lJndABNOiGxJdip1.EES'

Отлично! Теперь мы представили наш пароль в виде, который нельзя расшифровать, но как же теперь проверить, что наш исходный пароль соответствует хэшированному?

Все довольно просто, надо лишь использовать функцию checkpw, которая возвращает результат типа bool:

password = "123"
hashed_password = bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode()
 
# Проверяем, что указанный нами пароль соответствует хэшу
print(bcrypt.checkpw(password.encode(), hashed_password.encode()))
>>> True
 
# Попробуем указать неправильный пароль и получим False
wrong_password = "1234"
print(bcrypt.checkpw(wrong_password.encode(), hashed_password.encode()))
>>> False

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

Набираем обороты и помогаем сервису dostavallo с безопасностью

Давайте теперь рассмотрим пример посложнее, реализуем небольшое приложение командной строки, которое будет реализовывать функционал регистрации и входа в систему, а пары логин-пароль мы будем просто хранить в json-файлике.

Обратите внимание, что в реальных приложениях пароли и другие данные пользователей хранятся в защищенных базах данных, а не в файлах. :)

Пример будет рассмотрен одним блоком кода с комментариями / документацией. Погнали!

Реализация программы

import bcrypt  
import json
 

# Путь до файла, в котором будут храниться данные о пользователях  
USERS_FILEPATH = "users.json"

  
def hash_password(password: str) -> str:  
    """Функция для хэширования пароля"""  
    return bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode()  
  
  
def is_password_correct(password: str, hashed_password: str) -> bool:  
    """Функция для проверки пароля. Если ок - возвращает True"""  
    return bcrypt.checkpw(password.encode(), hashed_password.encode())  
  
  
def load_users(file_path=USERS_FILEPATH) -> dict:  
    """Функция для загрузки пользователей из файла"""  
    try:  
        with open(file_path, "r") as file:  
            return json.load(file)  
    except FileNotFoundError:  
        return {}  
  
  
def save_user(user: dict, file_path=USERS_FILEPATH) -> None:  
    """Функция для сохранения регистрационных данных пользователя (login-password) в файл"""  
    with open(file_path, "w") as file:  
        json.dump(user, file, indent=4)  
  
  
def register_user(users: dict) -> dict:  
    """
    Функция регистрации пользователя.
    Внутри происходит хэширование пароля и сохранение данных пользователя в файл.
    """
    username = input("Введите имя пользователя: ").strip()  
    if username in users:  
        print(f"Пользователь {username} уже существует.")  
        return users  
  
    password = input("Введите пароль: ").strip()  
    hashed_password = hash_password(password)  
    users[username] = hashed_password  
    save_user(users)  
    print(f"Пользователь {username} успешно зарегистрирован!")  
    return users  
  
  
def login_user(users: dict) -> None:  
    """  
    Функция для логина пользователя в систему.  
    При удачном входе, выполнение программы завершается.
    """
    username = input("Введите имя пользователя: ").strip()  
    if username not in users:  
        print(f"Пользователь {username} не найден.")  
        return  
  
    while True:  
        password = input("Введите пароль (или нажмите 'q' для возврата в главное меню): ").strip()  
        if password.lower() == 'q':  
            print("Возврат в главное меню.")  
            return  
  
        if is_password_correct(password=password, hashed_password=users[username]):  
            print(f"\nВведен Правильный пароль, вход выполнен. \nДобро пожаловать, {username}!")  
            exit()  
        else:  
            print("Неверный пароль! Попробуйте еще раз.")  
  
  
# Основной цикл программы  
def main():  
    users = load_users()  
    print("Добро пожаловать в сервис доставки 'dostavallo'!")  
    while True:  
        print("\nВыберите действие:")  
        print("1. Зарегистрироваться")  
        print("2. Войти в систему")  
        print("3. Выход")  
  
        choice = input("Ваш выбор: ").strip()  
  
        match choice:  
            case "1":  
                users = register_user(users)  
            case "2":  
                login_user(users)  
            case "3":  
                print("Выход из программы. До свидания!")  
                break  
            case _:  
                print("Неверный выбор. Попробуйте еще раз.")  
  
  
if __name__ == "__main__":  
    main()

Запускаем

Давайте залогиним моего кота в систему, чтобы он мог заказать себе вкусных рыбов.

Запустим программу:

python3 bcrypt_test.py

В зависимости от системы, здесь может быть просто python bcrypt_test.py. Также программу можно запустить через IDE.

После запуска программа дружелюбно приветствует нас:

Добро пожаловать в сервис доставки 'dostavallo'!

Выберите действие:
1. Зарегистрироваться
2. Войти в систему
3. Выход
Ваш выбор: 

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

Ваш выбор: 1    
Введите имя пользователя: Bublik
Введите пароль: Fi$h

Видим сообщение об успешной регистрации и переход в главное меню:

Пользователь Bublik успешно зарегистрирован!

Выберите действие:
1. Зарегистрироваться
2. Войти в систему
3. Выход
Ваш выбор: 

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

Ваш выбор: 2
Введите имя пользователя: Bublik
Введите пароль (или нажмите 'q' для возврата в главное меню): Fi$h

Введен Правильный пароль, вход выполнен. 
Добро пожаловать, Bublik!

Удача буквально преследует нас, все получилось!

А что с паролями для dostavallo?

Давайте откроем файлик users.json и посмотрим, как хранятся данные наших пользователей. Внутри мы увидим примерно такое:

{  
    "Bublik": "$2b$12$VgDqlE5Xcwm7ID20Aw9isuA.qQp1o.hnMN1./8xxrqS1qXdRpuCW2"  
}

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

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

Послесловие

Теперь мы знаем, что соль бывает не только поваренной, а радужные таблицы - это вовсе не про закрашенные ячейки в MS Excel :)

Познакомились поближе с хэш-функциями и спасли сервис доставки от беды, а кота - от шантажа.

Кстати, если хотите проверить, не утекал ли ваш пароль куда-нибудь, можете сделать это с помощью сайта https://haveibeenpwned.com. Просто вводите туда свою почту и получите ответ :).

Если увидели там что-то, поступаем просто - меняем пароль для указанного сервиса.

Я вот себя нашел. По информации сайта, мои данные подвергались утечке 3 раза.

Подробнее:

• https://www.securitylab.ru/blog/personal/xiaomite-journal/353801.php
• https://en.wikipedia.org/wiki/Have_I_Been_Pwned%3F

Берегите себя во всех смыслах.

Мой telegram-канал, присоединяйтесь :)
⬇⬇⬇
https://t.me/python3_with_love

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

Обычно мы получаем значение по ключу через квадратные скобки, например так:

my_dict = {"key_1": "value_1", "key_2": "value_2"}
print(my_dict["key_1"])

>>> value_1

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

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

if new_dict["key"] == "value":
    print("ok!")
else:
    print("no!")

И это будет работать ровно до того момента, пока эта пара ключ-значение есть внутри словаря. Если же ключ не найдется, мы получим исключение KeyError:

new_dict = {"another_key": "another_value"}
 
if new_dict["key"] == "value":
    print("ok!")
else:
    print("no!")

>>> KeyError: 'key'

Чтобы этого избежать, можно использовать встроенный метод словаря get():

new_dict = {"another_key": "another_value"}
 
# Проверяем ключ безопасно с помощью get()
if new_dict.get("key") == "value":
    print("ok!")
else:
    print("no!")
 
>>> no!

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

new_dict = {"another_key": "another_value"}

if new_dict.get("key"):
    ...

Здесь мы просто проверяем объект на наличие.

По умолчанию для не найденных ключей метод get() подставляет значение `None.
Вместо None можно подставить любое необходимое значение:

new_dict = {"another_key": "another_value"} 
 
# Используем значение по умолчанию для отсутствующего ключа
print(new_dict.get("key", "default_value"))
 
>>> default_value

Методы, такие как get(), делают работу со словарями в Python более безопасной. Это особенно важно при работе с данными из внешних источников, где структура словаря может быть непредсказуемой. Используя эти подходы, вы не только избежите ошибок, но и сделаете ваш код более читаемым и устойчивым к неожиданным данным.

Мой telegram-канал, присоединяйтесь :)

⬇⬇⬇

https://t.me/python3_with_love

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

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

Разбираемся с MRO на примере

Допустим, у нас есть некий класс D, который наследуется от классов B и C, которые наследуются от класса A, который ... :) пожалуй, остановимся на этом.

У этих классов определены методы who_am_i, которые просто печатают имя класса, которому они принадлежат. Классу D мы не будем создавать этот метод, а сделаем из него просто класс-заглушку:

class A:
    def who_am_i(self):
        print("A") 


class B(A): 
    def who_am_i(self):
        print("B") 


class C(A):
    def who_am_i(self):
        print("C") 


class D(B, C):
    ...

Теперь создадим экземпляр класса D и попробуем вызвать у него метод who_am_i:

d = D()
d.who_am_i()

Что произойдет? А вот что. В выводе мы увидим:

>>> B

Почему именно B, нам может рассказать MRO. Для удобства можно просто вызвать метод mro() или атрибут __mro__:

print(D.mro())  # или: print(D.__mro__)
>>> (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

Из вывода консоли можно увидеть порядок обращений. Сначала метод ищется в классе D, но его там нет, поэтому Python смотрит в следующем классе - B. Метод who_am_i есть у класса B, поэтому именно он и вызывается. Соответственно, при печати мы и видим B.

Почему MRO работает именно так?

Во всем виновата линеаризация и конкретно алгоритм C3 linearization. Разберем кратко, что это такое.

Линеаризация – это упорядочение классов (включая сам класс и его родителей) в список, отсортированный в порядке их "Удаленности". Этот список Python использует для поиска методов и атрибутов. А алгоритм C3 определяет три главные особенности такого порядка:

• устойчивый и расширяющийся (по старшинству)
• сохранение локального порядка старшинства
• монотонность

Почитать подробнее и ознакомиться с примерами можно на Вики

Таким образом, MRO определяет, как Python ищет методы и атрибуты в классах при множественном наследовании, делая этот процесс предсказуемым и логичным.

Что такое defaultdict

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

Синтаксис

from collections import defaultdict

defaultdict(default_factory=None, /, [...]) --> dict with default factory

Аргументы
Первый аргумент предоставляет начальное значение для атрибута default_factory, которое по умолчанию равно None. Все остальные аргументы обрабатываются так же, как если бы они были переданы конструктору dict.

Пара слов про метод __missing__()
Если аргумент default_factory != None, то этот метод и вызывается для предоставления значений по умолчанию, когда запрошенный ключ не найден.

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

Примеры. Какие проблемы решает defaultdict

Получаем нужное нам значение по умолчанию

Давайте создадим 2 словаря: 1 - dict, другой - defaultdict и попробуем получить значения для существующих ключей:

from collections import defaultdict  
  
dict_1 = {"first": 1, "second": 2}  
dict_2 = defaultdict(int, first=1, second=2)

print(dict_1["first"])  # 1
print(dict_2["first"])  # 1

В обоих случаях получим 1.

А что, если запросить значение для несуществующего ключа:

print(dict_1["missing_key"])  # KeyError: 'missing_key'
print(dict_2["missing_key"])  # 0

В первом случае мы получили исключение KeyError, а вот уже с defaultdict мы получили значение по умолчанию: 0.

Можно ли обойти эту ситуацию с помощью dict? Да, можно. Например, так:

print(dict_1.get("missing_key", 0))  # 0

Здесь мы явно задали значение по умолчанию в виде 0, если не получится найти ключ.

Идем дальше.

Считаем количество слов в списке

Допустим, у нас есть список из слов list_1 и надо посчитать, сколько раз каждое слово встречается в списке, затем вывести все это в формате словаря.
Как сделать это удобно? Конечно с defaultdict!

from collections import defaultdict  

list_1 = ["building", "thee", "sun", "python", "sun", "python", "python", "thee", "python"] 

# 1.
result = defaultdict(int)   

# 2.
for word in list_1:
    result[word] += 1

# 3.
print(dict(result))  # {'building': 1, 'thee': 2, 'sun': 2, 'python': 4}

Что здесь происходит?
1. Мы инициализируем defaultdict классом int для того, чтобы для каждого нового слова было задано значение по умолчанию = 0.
2. Проходимся по всем словам из списка list_1.
- Если слово не встречалось ранее, в result создается новая пара ключ-значение, где ключ - слово, а значение - 0, после чего оно сразу увеличивается на 1.
- Если слово уже есть в словаре, то его значение просто увеличивается на 1.
3. Печатаем наш результат, предварительно преобразовав наш defaultdict в обычный dict.

В результате получаем нужный нам ответ: {'building': 1, 'thee': 2, 'sun': 2, 'python': 4}.

Делаем выводы

defaultdict в Python — это удобный инструмент для создания словарей с заданным значением по умолчанию для новых ключей. Он упрощает код, позволяя избежать явных проверок на наличие ключа перед его использованием, что делает код более чистым и сокращает необходимость в дополнительных условиях.

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

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

from enum import Enum  
  
  
class MyMood(Enum):  
    HAPPY = "HAPPY"  
    SAD = "SAD"

Как красиво выйти из этой ситуации? Об этом мы и поговорим.

Функция auto()

В первую очередь, стоит обратить внимание на класс auto из Enum.

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

from enum import Enum, auto  
  
  
class MyMood(Enum):  
    HAPPY = auto()  
    SAD = auto()

Как это работает

Класс auto автоматически присваивает значение для символического имени в виде номера по порядку.
Например, для блока кода выше будут присвоены значения HAPPY = 1, SAD = 2:

print(MyMood.HAPPY.value, MyMood.SAD.value)
> 1 2

Когда это может пригодиться?

Например, когда мы перебираем Enum-ы через match-case и значения нам не важны.

А если важны?

Что делать, если в value нужно хранить именно символическое имя?

Представим ситуацию, когда нам очень нужно, чтобы name было равно value, и чтоб это value присваивалось автоматически.

Здесь нам на помощь придет переопределение метода _generate_next_value_.

Синтаксис

_generate_next_value_(name, start, count, last_values)
Этот метод и отвечает за увеличение значения символического имени на 1 в исходной реализации, но мы можем подстроить его под себя.

Это можно сделать прямо внутри нужного нам Enum-а:

class MyMood(Enum):  
    @staticmethod  
    def _generate_next_value_(name, start, count, last_values):  
        return name  
  
    HAPPY = auto()  
    SAD = auto()  

главное, переопределить метод перед членами Enum-а, иначе словим исключение `TypeError.

И тогда при выводе значений в терминал мы получим уже имена членов Enum, а не индексы:

print(MyMood.HAPPY.value, MyMood.SAD.value)
> HAPPY SAD

Если ситуация часто повторяется, то можно сделать одно общее решение для всех. Создадим класс AutoName, унаследованный от Enum и переопределим метод _generate_next_value_:

from enum import Enum, auto  


class AutoName(Enum):  
    @staticmethod  
    def _generate_next_value_(name, start, count, last_values):  
        return name  

Нам остается отнаследоваться от этого класса и использовать auto() в качестве значений символических имен Enum-а:

class MyMood(AutoName):  
    HAPPY = auto()  
    SAD = auto()

Убедимся, что наша шалость удалась:

print(MyMood.HAPPY.value, MyMood.SAD.value)
> HAPPY SAD

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

Это можно сделать с помощью классического try-except, но есть и более элегантный способ. Когда это может пригодиться и как пользоваться? Об этом и поговорим в статье.

Зачем подавлять исключения?

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

Конкретный пример:

Допустим, вы пишете автотест, и после создания некоторой сущности и выполнения манипуляций с ней, вам надо эту сущность удалить.

Все отрабатывает корректно, вот только запрос на удаление зависает в статусе pending и ответ не приходит, вызывается исключение по таймауту, но при этом сущность удаляется.

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

Как это сделать?

Рассмотрим 2 способа: канонический try-except и contextlib.suppress

Классический способ

try:
    requests.delete(url=https://example.com/users/user1)
except requests.TimeoutException:
    pass

contextlib.suppress

Синтаксис

contextlib.suppress(*exceptions)

Пример:

from contextlib import suppress

with suppress(requests.TimeoutException):
    requests.delete(url=https://example.com/users/user1)

suppress возвращает контекстный менеджер, который подавляет переданные исключения, если они встречаются в теле выражения with.

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

Lambda или анонимные функции - это по сути небольшие функции без имени, написанные в одну строку.

Для их объявления нам не нужно следовать классической схеме - указывать литерал def и имя будущей функции. Нам достаточно следовать такой конструкции:

lambda arguments: expression

Это и есть весь синтаксис лямбда-функций.

Главные моменты:

• Аргументов может быть несколько
• Выражение может быть только одно
• Выражение должно быть написано в одну строку
• Лямбда-функция всегда возвращает значение

Как и когда использовать?

Чаще всего, лямбда-функции используют в нескольких случаях:

• Как аргумент в других функциях (часто в функциях высшего порядка)
• Для создания замыканий

Рассмотрим чуть подробнее.

Лямбда-функция как аргумент в других функциях

Очень удобно применять лямбда-функции при работе с map() и filter().

Допустим, нам нужно преобразовать список. Здесь нам поможет функция map(), которая применит лямбда-функцию ко всем элементам списка:

list_1 = ["one", "two", "three"]
new_list = list(map(lambda x: "new_" + x, list_1))

print(new_list)
>>> ['new_one', 'new_two', 'new_three']

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

Эту же операцию можно решить и с помощью list comprehension (списочных выражений):

new_list = ["new_" + x for x in list_1]

Теперь рассмотрим простой пример с фильтрацией:

list_1 = ["one", "two", "three"]
new_list = list(filter(lambda x: len(x) <= 3, list_1))

print(new_list)
>>> ['one', 'two']

Мы применили функцию filter() и получили новый список с элементами, у которых количество символов меньше или равно 3.

Эту операцию тоже можно решить с помощью list comprehension:

new_list = [x for x in list_1 if len(x) <= 3]

Рассмотрим еще 1 применение при сортировке по ключу. Он будет интереснее, так как будем работать с объектами посложнее:

# Создадаем класс с атрибутами экземпляра: имя, возраст и порода
class Cat:
    def __init__(self, name: str, age: int, breed: str) -> None:
        self.name = name
        self.age = age
        self.breed = breed

    # Переопределяем магический метод __repr__, чтобы при печати экземпляров выводился сразу человекочитаемый текст
    def __repr__(self) -> str:
        return f"<<Cat {self.name}, {self.breed}, {self.age} years old>>"

# Создаем экземпляры класса Cat
cat_1 = Cat(name="Mars", age=7, breed="British Shorthair")
cat_2 = Cat(name="Oleg", age=1, breed="Devon Rex")
cat_3 = Cat(name="Bublik", age=2, breed="Russian Blue")

# Создаем неотсортированный список с питомцами
list_of_cats = [cat_3, cat_1, cat_2]

# Сортируем список по имени, возрасту и породе
name_sorted = sorted(list_of_cats, key=lambda x: x.name)
age_sorted = sorted(list_of_cats, key=lambda x: x.age)
breed_sorted = sorted(list_of_cats, key=lambda x: x.breed)

print(name_sorted, age_sorted, breed_sorted, sep="\n")

[<<Cat Bublik, Russian Blue, 2 years old>>, <<Cat Mars, British Shorthair, 7 years old>>, <<Cat Oleg, Devon Rex, 1 years old>>]
[<<Cat Oleg, Devon Rex, 1 years old>>, <<Cat Bublik, Russian Blue, 2 years old>>, <<Cat Mars, British Shorthair, 7 years old>>]
[<<Cat Mars, British Shorthair, 7 years old>>, <<Cat Oleg, Devon Rex, 1 years old>>, <<Cat Bublik, Russian Blue, 2 years old>>]

Выглядит просто, читаемо и эффективно.

Идем дальше.

Лямбда-функции и замыкания

Для начала пара слов о замыканиях.

Замыкание — это вложенная функция, которая имеет доступ к переменным внешней функции даже после закрытия этой самой внешней функции.

С помощью замыканий можно сохранять значения и состояния между вызовами функций.

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

def multiplier(x):
    return lambda y: x * y

multiply_by_2 = multiplier(x=2)
multiply_by_5 = multiplier(x=5)

print(multiply_by_2(y=2))
print(multiply_by_5(y=2))

>>> 4
>>> 10

Что происходит:

• Мы объявили функцию multiplier с параметром x, внутри которой возвращается вложенная лямбда-функция, которая умножает x на y.
• Далее мы по сути делаем из переменных multiply_by_2 и multiply_by_5 функции-перемножители, которые запоминают значение переменной x, которое будет доступно нам всегда.
• Затем вызываем уже внутреннюю лямбда-функцию, передавая перемножителю параметр y.
• В результате мы получаем произведение двух чисел - значений переменных x и y.

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

В этой статье мы окунулись в сферу применения лямбда-функций и затронули пару таких тем как функции высшего порядка и замыкания.

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