Как задать тип переменной в python

Введение в аннотации типов Python

Автор иллюстрации — Magdalena Tomczyk

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

Сохраняя идею динамической утиной типизации в современных версиях Python (3.6+) поддерживает аннотации типов переменных, полей класса, аргументов и возвращаемых значений функций:

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

Меня зовут Тихонов Андрей и я занимаюсь backend-разработкой в Lamoda.

В этой статье я хочу объяснить основы использования аннотаций типов и рассмотреть типичные примеры, реализуемые аннотациями из пакета typing .

Инструменты, поддерживающие аннотации

Аннотации типов поддерживаются многими IDE для Python, которые выделяют некорректный код или выдают подсказки в процессе набора текста.

Например, так это выглядит в Pycharm:

Так же аннотации типов обрабатываются и консольными линтерами.

Вот вывод pylint:

А вот для того же файла что нашел mypy:

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

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

Основы

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

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

Аннотации для переменных пишут через двоеточие после идентификатора. После этого может идти инициализация значения. Например,

Параметры функции аннотируются так же как переменные, а возвращаемое значение указывается после стрелки -> и до завершающего двоеточия. Например,

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

Кстати, при использовании dataclass типы полей необходимо указывать именно в классе. Подробнее про dataclass

Встроенные типы

Хоть вы и можете использовать стандартные типы в качестве аннотаций, много полезного сокрыто в модуле typing .

Optional

Если вы пометите переменную типом int и попытаетесь присвоить ей None , будет ошибка:

Incompatible types in assignment (expression has type «None», variable has type «int»)

Для таких случаев предусмотрена в модуле typing аннотация Optional с указанием конкретного типа. Обратите внимание, тип опциональной переменной указывается в квадратных скобках

Иногда вы не хотите ограничивать возможные типы переменной. Например, если это действительно не важно, или если вы планируете сделать обработку разных типов самостоятельно. В этом случае, можно использовать аннотацию Any . На следующий код mypy не будет ругаться:

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

Union

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

Кстати, аннотация Optional[T] эквивалентна Union[T, None] , хотя такая запись и не рекомендуется.

Коллекции

Механизм аннотаций типов поддерживает механизм дженериков (Generics, подробнее во второй части статьи), которые позволяют специфицировать для контейнеров типы элементов, хранящихся в них.

Списки

Для того, чтобы указать, что переменная содержит список можно использовать тип list в качестве аннотации. Однако если хочется конкретизировать, какие элементы содержит список, он такая аннотация уже не подойдёт. Для этого есть typing.List . Аналогично тому, как мы указывали тип опциональной переменной, мы указываем тип элементов списка в квадратных скобках.

Предполагается, что список содержит неопределенное количество однотипных элементов. Но при этом нет ограничений на аннотацию элемента: можно использовать Any , Optional , List и другие. Если тип элемента не указан, предполагается, что это Any .

Кроме списка аналогичные аннотации есть для множеств: typing.Set и typing.FrozenSet .

Кортежи

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

Если же планируется использовать кортеж аналогично списку: хранить неизвестное количество однотипных элементов, можно воспользоваться многоточием ( . ).

Аннотация Tuple без указания типов элементов работает аналогично Tuple[Any, . ]

Словари

Для словарей используется typing.Dict . Отдельно аннотируется тип ключа и тип значений:

Аналогично используются typing.DefaultDict и typing.OrderedDict

Результат выполнения функции

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

Если функция ничего не возвращает (например, как print ), её результат всегда равен None . Для аннотации так же используем None .

Корректными вариантами завершения такой функции будут: явный возврат None , возврат без указания значения и завершение без вызова return .

Если же функция никогда не возвращает управление (например, как sys.exit ), следует использовать аннотацию NoReturn :

Если это генераторная функция, то есть её тело содержит оператор yield , для возвращаемого можно воспользоватьтся аннотацией Iterable[T] , либо Generator[YT, ST, RT] :

Вместо заключения

Для многих ситуаций в модуле typing есть подходящие типы, однако я не буду рассматривать все, так как поведение аналогично рассмотренным.
Например, есть Iterator как generic-версия для collections.abc.Iterator , typing.SupportsInt для того, чтобы указать что объект поддерживает метод __int__ , или Callable для функций и объектов, поддерживающих метод __call__

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

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

Как работать с типизацией в Python

Первые упоминания о подсказках типов в языке программирования Python появились в базе Python Enhancement Proposals (PEP-483). Такие подсказки нужны для улучшения статического анализа кода и автодополнения редакторами, что помогает снизить риски появления багов в коде.

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

Типизация в Python

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

• str
• int
• float
• bool
• complex
• bytes
• etc.

Пример использования базовых типов в python-функции:

Помимо этого, можно параметризировать более сложные типы, например, List . Такие типы могут принимать значения параметров, которые помогают более точно описать тип функции. Так, например, List[int] указывает на то, что список состоит только из целочисленных значений.

Кроме List , существуют и другие типы из модуля typing, которые можно параметризировать. Такие типы называются Generic-типами. Такого рода типа определены для многих встроенных в Python структур данных:

• Set[x]
• FrozenSet[x]
• ByteString[x]
• Dict[x, y]
• DefaultDict[x, y]
• OrderedDict[x, y]
• ChainMap[x,y]
• Counter[x, int]
• Deque[x]
• и т.д.

Как можно заметить, некоторые типы имеют несколько параметров, которые можно описать. Например, Dict[x, y] означает, что это будет словарь, где ключи будут иметь тип x , а значения – тип y .

Также есть более абстрактные типы, например:

• Mapping[x, y] – объект имеет реализации метода __getitem__ ;
• Iterable[x] – объект имеет реализацию метода __iter__ .

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

• говорит о том, что у объекта реализован метод __call__ ;
• описывает типы параметров к этому методу.

На первом месте стоит массив типов входных параметров, на втором — тип возвращаемого значения.

Про остальные абстрактные типы контейнеров можно прочитать в документации Python.

Также есть более конкретные типы, например Literal[x] , где x указывает не тип, а конкретное значение. Например Literal[3] означает цифру 3. Используют такой тип крайне редко.

Также Python позволяет определять свои Generic-типы.

В данном примере TypeVar означает переменную любого типа, которую можно подставить при указании. Например:

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

На месте KeyType или ValueType могут быть конкретные типы.

Также есть специальные конструкции, которые позволяют комбинировать типы. Например, Union[x, y, . ] — один из типов. Если переменной может быть как int , так и float , то как тип следует указать Union[int, float] . Если переменной может быть как int , так и None , то в качестве типа можно указать Union[int,None] или, что предпочтительно, Optional[int] .

Зачем это нужно

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

Допустим, у вас есть класс юзера и функция, которая преобразует json в User .

Конечно, можно написать и проще:

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

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

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

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

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

В данном примере эндпоинт /item автоматически валидирует входящий json и передает его в функцию как требуемую модель.

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

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

Нововведения Python 3.9.0

Начиная с недавно вышедшей версии Python 3.9, у разработчиков больше нет необходимости импортировать абстрактные коллекции для описания типов. Теперь вместо typing.Dict[x, y] можно использовать dict[x,y] , то же самое происходит с Deque , List , Counter и т.д. Полное описание этого нововведения можно прочитать тут: PEP-585.

Также добавили аннотации типов, которые в дальнейшем могут быть использованы инструментами статического анализа. variable: Annotated[T, x] где T — тип переменной variable , а x — некоторые метаданные для переменной. По оценкам некоторых авторов, эти метаданные могут быть использованы также и во время выполнения (подробности смотрите в PEP-593).

Заключение

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

Переменные в Питоне

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

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

Как объявить переменную в Питоне

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

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

Помимо этого, список можно «распаковать» (unpack) в несколько переменных:

Автоматическое определение типа данных

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

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

Как узнать тип переменной в Питоне

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

Присвоение и преобразование типа данных

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

Также тип данных можно изменить.

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

Именование переменных

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

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

Как задать тип переменной в python

Переменные предназначены для хранения данных. Название переменной в Python должно начинаться с алфавитного символа или со знака подчеркивания и может содержать алфавитно-цифровые символы и знак подчеркивания. И кроме того, название переменной не должно совпадать с названием ключевых слов языка Python. Ключевых слов не так много, их легко запомнить:

Например, создадим переменную:

Здесь определена переменная name , которая хранит строку «Tom».

В пайтоне применяется два типа наименования переменных: camel case и underscore notation .

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

Underscore notation подразумевает, что подслова в наименовании переменной разделяются знаком подчеркивания. Например:

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

Определив переменную, мы можем использовать в программе. Например, попытаться вывести ее содержимое на консоль с помощью встроенной функции print :

Например, определение и применение переменной в среде PyCharm:

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

Типы данных

Переменная хранит данные одного из типов данных. В Python существует множество различных типов данных. В данном случае рассмотрим только самые базовые типы: bool , int , float , complex и str .

Логические значения

Тип bool представляет два логических значения: True (верно, истина) или False (неверно, ложь). Значение True служит для того, чтобы показать, что что-то истинно. Тогда как значение False , наоборот, показывает, что что-то ложно. Пример переменных данного типа:

Целые числа

Тип int представляет целое число, например, 1, 4, 8, 50. Пример

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

Для указания, что число представляет двоичную систему, перед числом ставится префикс 0b :

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

Для указания, что число представляет шестнадцатеричную систему, перед числом ставится префикс 0x :

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

Дробные числа

Тип float представляет число с плавающей точкой, например, 1.2 или 34.76. В качесте разделителя целой и дробной частей используется точка.

Число с плавающей точкой можно определять в экспоненциальной записи:

Число float может иметь только 18 значимых символов. Так, в данном случае используются только два символа — 3.9. И если число слишком велико или слишком мало, то мы можем записывать число в подобной нотации, используя экспоненту. Число после экспоненты указывает степень числа 10, на которое надо умножить основное число — 3.9.

Комплексные числа

Тип complex представляет комплексные числа в формате вещественная_часть+мнимая_часть j — после мнимой части указывается суффикс j

Строки

Тип str представляет строки. Строка представляет последовательность символов, заключенную в одинарные или двойные кавычки, например «hello» и ‘hello’. В Python 3.x строки представляют набор символов в кодировке Unicode

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

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

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

Управляющие последовательности в строке

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

\\ : позволяет добавить внутрь строки слеш

\’ : позволяет добавить внутрь строки одинарную кавычку

\» : позволяет добавить внутрь строки двойную кавычку

\n : осуществляет переход на новую строку

\t : добавляет табуляцию (4 отступа)

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

Консольный вывод программы:

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

Здесь переменная path содержит некоторый путь к файлу. Однако внутри строки встречаются символы «\n», которые будут интерпретированы как управляющая последовательность. Так, мы получим следующий консольный вывод:

Чтобы избежать подобной ситуации, перед строкой ставится символ r

Вставка значений в строку

Python позволяет встравивать в строку значения других переменных. Для этого внутри строки переменные размещаются в фигурных скобках <>, а перед всей строкой ставится символ f :

В данном случае на место будет вставляться значение переменной userName. Аналогично на вместо будет вставляться значение переменной userAge.

Динамическая типизация

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

Тип переменной определяется исходя из значения, которое ей присвоено. Так, при присвоении строки в двойных или одинарных кавычках переменная имеет тип str . При присвоении целого числа Python автоматически определяет тип переменной как int . Чтобы определить переменную как объект float, ей присваивается дробное число, в котором разделителем целой и дробной части является точка.

При этом в процессе работы программы мы можем изменить тип переменной, присвоив ей значение другого типа:

С помощью встроенной функции type() динамически можно узнать текущий тип переменной: