Python декораторы.

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

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

1. Определим функцию say_hello(name), которая на вход получит имя человека:

python
def say_hello(name):
    print('Hello,', name)

say_hello('Денис')
>>> Hello, Денис

2. Отлично. А теперь определим декоратор, который скажет что-то приятное после приветствия:

def you_are_beautiful(func):  #  На вход поступает функция
    def wrapped(*args, **kwargs):  #  обрабатываем аргументы
        func(*args, **kwargs)  #  вызывает функцию извне
        print('Классно выглядишь сегодня ;)')
    
    return wrapped  #  возвращает функцию, но не вызывает!!!
                    #  (возвращает ссылку на функцию, без скобок)

Есть один нюанс, который нужно соблюсти - декоратор должен быть объявлен ДО декорируемой функции. А способов применить декоратор несколько, но для Python самый актуальный способ, так называемый «Синтаксический сахар», на примере:

#  сначала определяем декоратор
def you_are_beautiful(func):
    def wrapped(*args, **kwargs):
        func(*args, **kwargs)
        print('Классно выглядишь сегодня ;)')
    
    return wrapped 

#  далее определяем функцию и навешиваем декоратор
@you_are_beautiful  <-- наш декоратор
def say_hello(name):
    print('Hello,', name)

say_hello('Денис')
>>> Hello, Денис
>>> Классно выглядишь сегодня ;)

Под коробкой вызов функции выглядит так:

you_are_beautiful(say_hello('Денис'))

Ну и, соответственно, декораторов может быть навешано несколько:

@decorator1
@decorator2
@decorator3
@decorator4
def foo():
    pass

#  что при вызове, по сути, эквивалентно этому:
decorator1(decorator2(decorator3(decorator4(foo()))))

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

#python #github

Сегодня будет достаточно глубокий экскурс в Python исключения.ᅠ

Для кого-то эта тема может быть очевидной, но для некоторых начинающих разработчиков эта тема всё ещё не открыта. Итак, что же такое исключения?

Действия программы, которые противоречат тем или иным правилам вызывают исключения. Например попытка поделить на ноль вызовет ZeroDivisionError, а попытка сложить строку и кортеж - TypeError.

"Отловить" ошибки можно при помощи конструкции try/except/else/finally. Например:

def division(a,b):
    try:
        return a/b
    except ZeroDivisionError:
        return None

Теперь работа программы не будет ломаться при делении на ноль, а продолжит свою работу. Но это далеко не значит, что использование блока try/except - панацея. Об этом чуть позже.

Как же создать своё исключение? Легко:

class MyOwnException(Exception):
    pass

или

class MyOwnException(Exception):
    #  разный функционал, что выполнится при исключении

Как вы видите, для создания своего исключения мы создаём новый класс, который наследуем от базового класса Exception. Чтобы выбросить это исключение в программе мы воспользуемся оператором raise:

#  какое-то условие, что вызывает исключение
raise MyOwnException('Message')
>>> __main__.MyOwnException: Message

Замечательно, удобно для программиста, быстро но теперь поговорим о том почему это плохо:

1. Большое количество исключений - всегда сложно, запутывает и разработчиков, и пользователей.
2. Лучше предусмотреть альтернативный выход из исключительной ситуации.
3. Плохо влияет на будущую поддерживаемость и ясность вашего кода.
4. Все исключения всё равно не получится поймать.

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

from functools import wraps

class Error(Exception):
    
    def __repr__(self):
        return 'Error'

    def __str__(self):
        return 'Error'

def safe(func):

    @wraps(func)
    def wrapped(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except:
            return Error()

    return wrapped

@safe  #  декорируем функцию
def division(a, b):
    return a / b

division(4,0)
>>> Error

Итак, что тут происходит? Для начала о @wraps. Я еще не рассказывал о нём, но этот декоратор нужен для сохранения таких параметров функции как __name__ и __doc__, так как после декорирования эти параметры переписываются. Под коробкой этот декоратор на примере можно заменить вот так вот так:

def safe(func)
  
    def wrapped(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except:
            return Error()

    wrapped.__name__ = func.__name__
    wrapped.__doc__ = func.__doc__

    return wrapped

А теперь обо всём в целом. Мы создали декоратор safe, который позволит обезопасить любую функцию от любой ошибки. При объявлении небезопасной функции с этим декоратором мы получаем абсолютно неломаемую программу, а выглядит решение ну очень уж лаконично. Кстати, в блоке except мы можем возвращать не только наш экземпляр класса Error, но и любое другое значение, которое нам будет удобно, например float('inf'), что вернёт нам бесконечность. (Кстати, в рассмотренном примере не обязательно возвращать именно экземпляр класса. С таким же успехом можно вернуть просто строку "Error", но я оставил класс для того, чтобы вы могли легко модифицировать поведение своей ошибки)

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

Способов решить проблему исключений есть ещё много, а весь материал, что я изложил тут, чрезвычайно сжат. Новичкам я конечно же советую погрузиться в тему глубже. Это важнее, чем кажется.

А этот декоратор был бы неплохим началом для моей коллекции декораторов, да?)

#python

​Аннотации в Python.

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

Указание типа переменной происходит по определенному синтаксису, который лучше показать, чем объяснить:

def say_hello(name: str, age: int) -> None:
    print(f"Hello, {name}. I know, you're {age} years old.")

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

say_hello('Денис', 19)
>>> Hello, Денис. I know, you're 19 years old.

#  всё бы хорошо, но попробуем так:

say_hello([1, 2, 3], "СТРОКА")
>>> Hello, [1, 2, 3]. I know, you're СТРОКА years old.

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

def say_hello(name: str, age: int) -> None:
    if isinstance(name, str) and isinstance(age, int):
        print(f"Hello, {name}. I know, you're {age} years old.")
    else:
        raise TypeError('Подан неверный тип переменной')

say_hello('Денис', 19)
>>> Hello, Денис. I know, you're 19 years old.

say_hello([1, 2, 3], "СТРОКА")
>>> TypeError: Подан неверный тип переменной

Теперь наша программа прервётся, если мы подадим в функцию неправильные входные параметры. Ну и, опять же, тема очень обширная, советую ознакомиться подробнее. Спасибо, что читаете ❤️

#python

​Сегодня совсем коротко, но зато со смыслом.

Думаю, многие знают, что в Python есть такие операторы, как is и ==. Оба они идейно похожи - они указывают на равенство объектов. Казалось бы, одно и то же, но давайте на примере:

#  объявим наши переменные
#  таким образом
a = [1, 2, 3]

b = a

c = [1, 2, 3]

Отлично, проверим?

a == b
>>> True
a is b
>>> True
a == c
>>> True
a is c 
>>> False

Первые три выражения дали вполне ожидаемый ответ, а с последним всё не так однозначно.
a == b == c == [1, 2, 3] , с этим не поспорить. b = a, значит b - ссылка на объект a, следовательно обе переменные ссылаются на один и тот же список [1, 2, 3] в памяти. А вот c - это уже новый объект в памяти, и пусть даже c == a, но это разные объекты. Именно поэтому a is c ⇒ False.

В этом и заключается вся разница.

#python

​Области видимости в Python.

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

Области видимости (О.В. в примере) в языках программирования рассматриваются как некоторые сущности, знаете. Этот термин подразумевает область программы, откуда будет доступна переменная, функция и т.п. структуры.

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

#  глобальная O.B.

a = 5
b = 6

def foo():  #  foo О.В.
    c = 7
    return a * b

foo()
>>> 30
print(c)
>>> NameError: name 'c' is not defined

Что тут происходит? Всё просто: две переменные a и b мы объявляем в глобальной области видимости, а c в области видимости функции foo. И тут нужно понять, что области видимости работают по принципу вложенности: переменные из родителя доступны в ребёнке, но не наоборот (!).

Таким образом переменные a и b доступны в функции foo, но c не доступна в глобальной области видимости, переменная локальна.

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

Спасибо прочтение и классный фидбек в личных сообщениях, это дорогого стоит

#python

​Зачем нужны абстрактные методы и классы?

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

Давайте начну с примера из личного опыта. Может быть затяну из-за этого, но должно быть интересно. Так вот, недавно я работал в стартапе из кремниевой долины. Мы с командой создавали чат-бота, который будет работать во всех мессенджерах, будь то Telegram, VK, What's App, Viber или Facebook Messenger.

Как тут быть? У каждого мессенджера свой API со своими входными и выходными, мы столкнулись с проблемой стандартизации. Тогда мы просто взяли и написали свой интерфейс для каждого мессенджера. Стандартом интерфейса и стал абстрактный класс с абстрактными методами. Так что же это такое?

Абстрактный класс - класс, унаследованный от класса ABC и содержащий абстрактные методы.
Абстрактный метод - метод класса, задекорированный декоратором @abstractmethod и не имеющей реализации. Такой метод нужен только для объявления.

Давайте на примере, так будет яснее. Отдалённо повторим интерфейс мессенджера из нашего проекта:

from abc import ABC, abstractmethod

class Interface(ABC):

    @abstractmethod
    def send_message(self, chat_id, *args, **kwargs):
        pass

    @abstractmethod
    def send_photo(self, chat_id, txt=None, *args, **kvargs):
        pass
        
    @abstractmethod
    def send_file(self, file, txt=None, media=None):
        pass

    #  Ну и так далее

Что происходит в этом примере? Я объявил класс Interface, который унаследован от абстрактного класса ABC. В этом классе я объявил 3 абстрактных метода. У них нет реализации. Суть абстрактного класса заключается лишь в том, чтобы обязать наследника класса Interface реализовать все необходимые методы.

Потом мы реализуем класс, например Telegram, где реализуем метод send_message одним кодом, а в классе WhatsApp реализуем тот же метод совсем по другому. Нас не волнует как это работает внутри, мы лишь описываем необходимый интерфейс взаимодействия.

Надеюсь этот пример помог вам понять что это такое и немного разобраться.

#python