Рубрики
Без рубрики

Тип проверки в Python

Получите практические, реальные навыки Python на наших ресурсах и пути

Автор оригинала: Mike Driscoll.

Проверка типа или наметка – более новая особенность Python, которая была добавлена в Python 3.5. Тип намекания также известен как Тип аннотации Отказ Тип намекает на добавление специального синтаксиса на функции и переменные объявления, которые говорят разработчику, какой тип аргумента или переменной.

Python не применяет подсказки типа. Вы все еще можете изменить типы по воле в Python из-за этого. Однако некоторые интегрированные среды разработки, такие как Pycharm, подсказку подсветки, и будут выделять ошибки ввода. Вы также можете использовать инструмент под названием Marpy Чтобы проверить вашу печатать для вас. Вы узнаете больше об этом инструменте позже в этой статье.

Вы будете изучать следующее:

  • Плюсы и минусы подсказки
  • Встроенный тип подсказки/переменная аннотация
  • Тип коллекции намекает
  • Значения, которые могут быть Никто
  • Тип подсказки
  • Что делать, когда все сложно
  • Классы
  • Декораторы
  • Псевдонима
  • Другие виды подсказки
  • Введите комментарии
  • Статический тип проверки

Давайте начнем!

Плюсы и минусы подсказки

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

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

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

  • Код более многословным и, возможно, сложнее писать
  • Тип подсказки добавляет время разработки
  • Тип подсказки работают только в Python 3.5+. До этого вам пришлось использовать тип комментариев
  • Тип намеканий может иметь незначительное запуск времени наказания в коде, который использует его, особенно если вы импортируете Набрав модуль.

Когда вы должны использовать тип намекания тогда? Вот некоторые примеры:

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

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

Давайте проведем остальную часть этой статьи, узнав, как использовать тип подсказки!

Встроенный тип подсказки/переменная аннотация

Вы можете добавить типу намекания со следующими встроенными типами:

  • int.
  • плавать
  • бол
  • ул
  • байты

Они могут быть использованы как в функциях, так и в переменной аннотации. Концепция переменной аннотации была добавлена к языку Python в 3.6. Переменная аннотация позволяет добавлять тип подсказки к переменным.

Вот некоторые примеры:

x: int  # a variable named x without initialization
y: float = 1.0  # a float variable, initialized to 1.0
z: bool = False
a: str = 'Hello type hinting'

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

Давайте посмотрим, как вы бы добавили тип подсказки для коллекций рядом!

Тип последовательности намекает

Коллекция – это группа предметов в Python. Общие коллекции или последовательности – Список , Диктовать , кортеж и Установить Отказ Однако вы не можете аннотировать переменные, используя эти встроенные типы. Вместо этого вы должны использовать Набрав модуль.

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

>>> from typing import List
>>> names: List[str] = ['Mike']
>>> names
['Mike']

Здесь вы создали Список с одним ул ...| в этом. Это указывает, что вы создаете Список струн. Если вы знаете, что список всегда будет одинаковым размером, вы можете указать тип каждого элемента в списке: 

>>> from typing import List
>>> names: List[str, str] = ['Mike', 'James']

Доверительные кортежи очень похожи:

>>> from typing import Tuple
>>> s: Tuple[int, float, str] = (5, 3.14, 'hello')

Словари немного отличаются тем, что вы должны подсказки в виде подсказки Ключ и значения:

>>> from typing import Dict
>>> d: Dict[str, int] = {'one': 1}

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

>>> from typing import Tuple
>>> t: Tuple[int, ...] = (4, 5, 6)

Теперь давайте узнаем, что делать, если элемент имеет тип типа Нет !

Значения намеканий, которые могут быть ни одного

Иногда значение должно быть инициализировано как Нет , но когда он станет позже, вы хотите, чтобы это было что-то еще.

Для этого вы можете использовать Необязательно :

>>> from typing import Optional
>>> result: Optional[str] = my_function()

С другой стороны, если значение никогда не может быть Нет , вы должны добавить Assert к вашему коду:

>>> assert result is not None

Давайте узнаем, как аннотировать функции рядом!

Тип подсказки

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

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

def adder(x: int, y: int) -> None:
    print(f'The total of {x} + {y} = {x+y}')

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

Скажем, что вы хотите назначить сумматор () функция для переменной. Вы можете аннотировать переменную как Callable как это:

from typing import Callable

def adder(x: int, y: int) -> None:
    print(f'The total of {x} + {y} = {x+y}')

a: Callable[[int, int], None] = adder

Callable принимает список аргументов для функции. Это также позволяет вам указать тип возврата.

Давайте посмотрим на еще один пример, где вы проходите в более сложных аргументах:

from typing import Tuple, Optional


def some_func(x: int, y: Tuple[str, str], 
              z: Optional[float]: = None): -> Optional[str]:
    if x > 10:
        return None
    return 'You called some_func'

Для этого примера вы создали uvere_func () Принимает 3 аргумента:

  • int.
  • Двухместный кортеж строки
  • Дополнительный плавать это по умолчанию для Никто

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

Это также возвращает либо Нет или строка.

Давайте продолжим и обнаружим, что делать в еще более сложных ситуациях!

Что делать, когда все сложно

Вы уже узнали, что делать, когда значение может быть Нет , но что еще вы можете сделать, когда все сложнее? Например, что вы делаете, если аргумент пропускается, может быть несколько различных типов?

Для этого конкретного использования вы можете использовать Союз :

>>> from typing import Union
>>> z: Union[str, int]

Что означает этот тип подсказки, это то, что переменная, z , может быть ни строкой, либо целым числом.

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

x: Any = some_function()

Использовать Любой С осторожностью, потому что вы не можете действительно сказать, что вы возвращаетесь. Поскольку это может быть «любой» тип, это похоже на ловить все исключения с голым кроме Отказ Вы не знаете, какой исключение вы ловите это, и вы также не знаете, какой тип вы намекаете, когда вы используете Любой Отказ

Классы

Если у вас есть Класс Что вы написали, вы можете создать аннотацию для него.

>>> class Test:
...     pass
... 
>>> t: Test = Test()

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

Декораторы

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

Добавление типа подсказки к декораторам видят уродливый.

Давайте взглянем:

>>> from typing import Any, Callable, TypeVar, cast
>>> F = TypeVar('F', bound=Callable[..., Any])
>>> def my_decorator(func: F) -> F:
        def wrapper(*args, **kwds):
            print("Calling", func)
            return func(*args, **kwds)
        return cast(F, wrapper)

А Typevar это способ указать пользовательский тип. Вы создаете пользовательский Callable Тип, который может предпринять в любом количестве аргументов и возврат Любой Отказ Затем вы создаете декоратор и добавьте новый тип в виде подсказки типа для первого аргумента, а также типа возврата.

литой Функция используется MAPY, только статическая утилита проверки кода. Он используется для размещения значения указанному типу. В этом случае вы отличаете обертка Функция как тип F Отказ

Псевдонима

Вы можете создать новое имя для типа. Например, давайте переименуемся Список Тип к Вектор :

>>> from typing import List
>>> Vector = List[int]
>>> def some_function(a: Vector) -> None:
...     print(a)

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

Набрав Документация имеет хороший пример, который воспроизводится ниже:

from typing import Dict, Tuple

ConnectionOptions = Dict[str, str]
Address = Tuple[str, int]
Server = Tuple[Address, ConnectionOptions]

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

Другие виды подсказки

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

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

Проверьте полную документацию для всех деталей всех различных типов:

Введите комментарии

Python 2.7 Development Закончил 1 января 2020 года. Однако будет много линий Устана Кода Python 2, который придется работать с годами. Тип подсказки никогда не был добавлен в Python 2. Но вы можете использовать аналогичный синтаксис в качестве комментариев.

Вот пример:

def some_function(a):
    # type: str -> None
    print(a)

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

def some_function(a, b, c):
    # type: (str, int, int) -> None
    print(a)

Некоторые IDes Python могут поддерживать подсказку в DOCSTRING. Pycharm позволяет вам сделать следующее, например:

def some_function(a, b):
    """
    @type a: int
    @type b: float
    """

Mypy будет работать над другими комментариями, но не на них. Если вы используете Pycharm, вы можете использовать либо форму типового намекания.

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

Статический тип проверки

Вы видели Marpy, уже несколько раз уже несколько раз. Вы можете прочитать все это здесь:

Если вы хотите запустить MAPY в своем собственном коде, вам нужно будет установить его, используя Пип :

$ pip install mypy

Как только у вас есть Marpy Установлен, вы можете запустить инструмент, как это:

$ mypy my_program.py

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

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

Давайте напишем плохо наведите указанную функцию и сохранить его в файл с именем bad_type_hinting.py :

# bad_type_hinting.py

def my_function(a: str, b: str) -> None:
    return a.keys() + b.keys()

Теперь, когда у вас есть код, вы можете запустить MyPy против него:

$ mypy bad_type_hinting.py 
bad_type_hinting.py:4: error: "str" has no attribute "keys"
Found 1 error in 1 file (checked 1 source file)

Этот вывод говорит вам, что есть проблема в строке 4. Строки не имеют Клавиши () атрибут.

Давайте обновим код, чтобы удалить вызовы в несуществующую Клавиши () метод. Вы можете сохранить эти изменения в новом файле с именем bad_type_hinting2.py :

# bad_type_hinting2.py

def my_function(a: str, b: str) -> None:
    return a + b

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

$ mypy bad_type_hinting2.py 
bad_type_hinting2.py:4: error: No return value expected
Found 1 error in 1 file (checked 1 source file)

Упс! Там все еще ошибка. На этот раз вы знаете, что вы не ожидали, что эта функция что-нибудь вернет. Вы можете исправить код, чтобы он ничего не возвращал, либо вы можете исправить подсказку типа, чтобы он возвращает ул ...| Отказ

Вы должны попробовать делать последние и сохранить следующий код для good_type_hinting.py :

# good_type_hinting.py

def my_function(a: str, b: str) -> str:
    return a + b

Теперь запустите Mypy против этого нового файла:

$ mypy good_type_hinting.py 
Success: no issues found in 1 source file

На этот раз ваш код не имеет проблем!

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

Обертывание

Теперь вы знаете, какой тип намекания или аннотации есть и как это сделать. Фактически, вы узнали все основы, которые вам нужно эффективно подсказывать типом.

В этой статье вы узнали о:

  • Плюсы и минусы подсказки
  • Встроенный тип подсказки/переменная аннотация
  • Тип коллекции намекает
  • Значения, которые могут быть Никто
  • Тип подсказки
  • Что делать, когда все сложно
  • Классы
  • Декораторы
  • Псевдонима
  • Другие виды подсказки
  • Введите комментарии
  • Статический тип проверки

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

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

Читайте ещё по теме: