Как создать свой тип данных python

Python. Урок 3. Типы и модель данных

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

Немного о типизации языков программирования

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

Неявная типизация означает, что при объявлении переменной вам не нужно указывать её тип, при явной – это делать необходимо. В качестве примера языков с явной типизацией можно привести Java, C++. Вот как будет выглядеть объявление целочисленной переменной в Java и Python.

int a = 1;

a = 1

Также языки бывают с динамической и статической типизацией. В первом случае тип переменной определяется непосредственно при выполнении программы, во втором – на этапе компиляции (о компиляции и интерпретации кратко рассказано в уроке 2). Как уже было сказано Python – это динамически типизированный язык, такие языки как С, C#, Java – статически типизированные.

Сильная типизация не позволяет производить операции в выражениях с данными различных типов, слабая – позволяет. В языках с сильной типизацией вы не можете складывать например строки и числа, нужно все приводить к одному типу. К первой группе можно отнести Python, Java, ко второй – С и С++.

За более подробным разъяснением данного вопроса советуем обратиться к статье “Ликбез по типизации в языках программирования” .

Типы данных в Python

В Python типы данных можно разделить на встроенные в интерпретатор (built-in) и не встроенные, которые можно использовать при импортировании соответствующих модулей.

К основным встроенным типам относятся:

None (неопределенное значение переменной)
Логические переменные (Boolean Type)
Числа (Numeric Type)
1. int – целое число
2. float – число с плавающей точкой
3. complex – комплексное число
1. list – список
2. tuple – кортеж
3. range – диапазон
1. str
1. bytes – байты
2. bytearray – массивы байт
3. memoryview – специальные объекты для доступа к внутренним данным объекта через protocol buffer
1. set – множество
2. frozenset – неизменяемое множество
1. dict – словарь
Модель данных

Рассмотрим как создаются объекты в памяти, их устройство, процесс объявления новых переменных и работу операции присваивания.

Для того, чтобы объявить и сразу инициализировать переменную необходимо написать её имя, потом поставить знак равенства и значение, с которым эта переменная будет создана. Например строка:
```
b = 5 
```
объявляет переменную b и присваивает ей значение 5.

Целочисленное значение 5 в рамках языка Python по сути своей является объектом. Объект, в данном случае – это абстракция для представления данных, данные – это числа, списки, строки и т.п. При этом, под данными следует понимать как непосредственно сами объекты, так и отношения между ними (об этом чуть позже). Каждый объект имеет три атрибута – это идентификатор, значение и тип. Идентификатор – это уникальный признак объекта, позволяющий отличать объекты друг от друга, а значение – непосредственно информация, хранящаяся в памяти, которой управляет интерпретатор.

При инициализации переменной, на уровне интерпретатора, происходит следующее:
- создается целочисленный объект 5 (можно представить, что в этот момент создается ячейка и 5 кладется в эту ячейку);
- данный объект имеет некоторый идентификатор, значение: 5, и тип: целое число;
- посредством оператора “=” создается ссылка между переменной b и целочисленным объектом 5 (переменная b ссылается на объект 5).
Имя переменной не должно совпадать с ключевыми словами интерпретатора Python. Список ключевых слов можно найти здесь . Также его можно получить непосредственно в программе, для этого нужно подключить модуль keyword и воспользоваться командой keyword.kwlist.
```
>>> import keyword >>> print("Python keywords: ", keyword.kwlist)
```
Проверить является или нет идентификатор ключевым словом можно так:
```
>>> keyword.iskeyword("try") True >>> keyword.iskeyword("b") False 
```
Для того, чтобы посмотреть на объект с каким идентификатором ссылается данная переменная, можно использовать функцию id().
```
>>> a = 4 >>> b = 5 >>> id(a) 1829984576 >>> id(b) 1829984592 >>> a = b >>> id(a) 1829984592 
```
Как видно из примера, идентификатор – это некоторое целочисленное значение, посредством которого уникально адресуется объект. Изначально переменная a ссылается на объект 4 с идентификатором 1829984576, переменная b – на объект с id = 1829984592. После выполнения операции присваивания a = b, переменная a стала ссылаться на тот же объект, что и b.

Тип переменной можно определить с помощью функции type(). Пример использования приведен ниже.
```
>>> a = 10 >>> b = "hello" >>> c = (1, 2) >>> type(a) class 'int'> >>> type(b) class 'str'> >>> type(c) class 'tuple'> 
```
Изменяемые и неизменяемые типы данных

В Python существуют изменяемые и неизменяемые типы.

К неизменяемым (immutable) типам относятся: целые числа (int), числа с плавающей точкой (float), комплексные числа (complex), логические переменные (bool), кортежи (tuple), строки (str) и неизменяемые множества (frozen set).

К изменяемым (mutable) типам относятся: списки (list), множества (set), словари (dict).

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

Неизменяемость типа данных означает, что созданный объект больше не изменяется. Например, если мы объявим переменную k = 15, то будет создан объект со значением 15, типа int и идентификатором, который можно узнать с помощью функции id().
```
>>> k = 15 >>> id(k) 1672501744 >>> type(k) class 'int'> 
```
Объект с id = 1672501744 будет иметь значение 15 и изменить его уже нельзя.

Если тип данных изменяемый, то можно менять значение объекта. Например, создадим список [1, 2], а потом заменим второй элемент на 3.
```
>>> a = [1, 2] >>> id(a) 47997336 >>> a[1] = 3 >>> a [1, 3] >>> id(a) 47997336 
```
Как видно, объект на который ссылается переменная a, был изменен. Это можно проиллюстрировать следующим рисунком.

В рассмотренном случае, в качестве данных списка, выступают не объекты, а отношения между объектами. Т.е. в переменной a хранятся ссылки на объекты содержащие числа 1 и 3, а не непосредственно сами эти числа.

P.S.

Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.

Раздел: Python Уроки по Python Метки: Python, Уроки Python

Python. Урок 3. Типы и модель данных : 12 комментариев
1. Артем 25.04.2018 У Вас в коде
  >>> print “Python keywords: “, keyword.kwlist
  не хватает круглых скобок:
  >>> print(“Python keywords: “, keyword.kwlist)
1. writer 25.04.2018 Спасибо! Поправил.
Создание пользовательских типов данных в Python

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

Содержание:
- Зачем нужны пользовательские типы данных;
- Определение пользовательского типа данных;
- Инициализация пользовательского типа данных;
- Доступ к полям объекта пользовательского класса данных;
- Пользовательские типы данных и функции;
- Вложенные пользовательские типы данных.
Зачем нужны пользовательские типы данных?

Например, для представления одной книги, в книжном магазине, необходимо указать название книги, год издания, авторов (их может быть несколько), количество экземпляров этой книги, цена за единицу, общую стоимость всех книг или любую другую информацию:
```
book_title = 'Название книги' book_date = '01-01-2019' book_author = ['Автор 1', 'Автор 2'] book_price = 256 book_num = 9 book_total = book_price * book_num 
```
Теперь есть шесть отдельных независимых переменных. Если надо будет передавать информацию о книге в какую-то функцию для дальнейшей обработки, то придется передавать каждую переменную по отдельности. Кроме того, если необходимо хранить информацию о какой-то еще книге, то придется дополнительно объявить еще шесть переменных! Такая реализация не очень эффективна и вообще, в итоге можно запутаться.

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

Определение пользовательского типа данных.

Пользовательские типы данных создаются программистом с использованием синтаксиса класса:
```
class Book: def __init__(self, title=None, date=None, authors=None, price=0, num=0): self.title = title self.date = date self.price = price self.num = num self.total = self.price * self.num if authors is None: self.authors = [] else: self.authors = authors def __repr__(self): return f'self.__class__.__name__>(title=self.title>, date=self.date>, \ authors=self.authors>, price=self.price>, num=self.num>, total=self.total>)' 
```
Код выше определяет тип данных Book , для хранения информации о книге в книжном магазине. Но такая запись пользовательского типа данных очень многословна, что совсем не по питонически. Для упрощенного и удобного создания пользовательских типов данных, с версии Python 3.7 введен встроенный модуль dataclasses . Этот модуль использует декоратор @dataclass и несколько вспомогательных функций для упрощенного написания пользовательских типов данных.

Посмотрим, на сколько короче можно записать тип данных Book , представленный выше:
```
from dataclasses import dataclass, field @dataclass class Book(): """Тип данных книга""" title: str = None date: str = None authors: list = field(default_factory=list) price: float = 0 num: int = 0 total: float = field(init=False) def __post_init__(self): # инициализация переменной `total` self.total = self.price * self.num 
```
И это все! Коротко? На самом деле, модуль класса данных dataclasses автоматически добавит сгенерированные специальные методы __init__() и __repr__() . Этот модуль дает очень много дополнительных возможностей и полезных фич при создании собственных типов данных, а вызов функции dataclasses.field() для определенного поля, поможет его кастомизировать под свои нужды. При создании своих типов данных, обязательно используете этот модуль, т.к. он защитит вас от многих распространенных ошибок (например объявления изменчивых типов данных по умолчанию).

Примечание. модуль dataclasses не проверяет, указанный в аннотации тип переменной!

Вернемся к пользовательским типам. И так, объявленный тип содержит шесть переменных:
- title — название книги,
- date — дата выхода книги,
- authors — авторы книги.
- price — стоимость одной книги,
- num — количество книг в магазине,
- total — общая стоимость книг.
Эти переменные называются полями типа данных. Код класса Book — это простое объявление типа. Чтобы использовать тип данных Book() , необходимо просто создать его экземпляр:
```
>>> book = Book() 
```
Инициализация пользовательского типа данных.

Инициализация пользовательского типа путем присваивания значений каждому члену по порядку — занятие неблагодарное и довольно громоздкое (особенно, если много полей), поэтому легче инициализировать тип сразу, при создании экземпляра класса данных. Это позволяет инициализировать некоторые или сразу все поля объявленного типа:
```
# создаем отдельную переменную типа Book, например для книги gold_key >>> gold_key = Book('Золотой ключик', '1989', ['А. Толстой'], 512, 7) >>> gold_key # Book(title='Золотой ключик', date='1989', authors=['А. Толстой'], # price=512, num=7, total=3584) # создаем отдельную переменную типа Book для day_watch >>> day_watch = Book('Дневной Дозор', '2006', ['В. Васильев', 'С. Лукьяненко'], 1024, 9) >>> day_watch # Book(title='Дневной Дозор', date='2006', authors=['В. Васильев', 'С. Лукьяненко'], # price=1024, num=9, total=9216) 
```
Доступ к полям объекта пользовательского класса данных.

Для того, чтобы получить доступ к отдельным полям типа данных, используется точечная нотация. Например, в коде, приведенном ниже, используется точка для выбора значения каждого поля пользовательского типа данных:
```
>>> gold_key.title # 'Золотой ключик' >>> gold_key.price # 512 >>> gold_key.authors # ['А. Толстой'] >>> day_watch.title # 'Дневной Дозор' >>> day_watch.date # '2006' >>> day_watch.authors[0] # 'В. Васильев' >>> day_watch.authors # ['В. Васильев', 'С. Лукьяненко'] 
```
В этом примере, легко определить, какая переменная относится к типу gold_key , а какая к day_watch . Это обеспечивает гораздо более высокий уровень организации, чем в случае с обычными отдельными переменными.

Переменные — поля типа данных работают так же, как и простые переменные, поэтому с ними можно выполнять обычные операции доступные типу данных, к которому они относятся:
```
# присвоение новых значений >>> gold_key.title = 'Современный золотой ключик' >>> gold_key.title # 'Современный золотой ключик' >>> gold_key.authors.append('Неизвестный соавтор') >>> gold_key.authors # ['А. Толстой', 'Неизвестный соавтор'] >>> gold_key.date = 2021 >>> gold_key # Book(title='Золотой ключик', date=2021, authors=['А. Толстой', 'Неизвестный соавтор'], # price=512, num=7, total=3584) # операции сравнения отдельных полей >>> gold_key.total  day_watch.total # True 
```
Модуль класса данных dataclasses добавляет возможность сравнения самих типов данных с использованием хэша на основе их местоположения в памяти, как два обычных объекта.

Пользовательские типы данных и функции.

Большим преимуществом использования пользовательских типов данных является возможность передать сразу весь тип в функцию, а не по одной переменной:
```
from dataclasses import dataclass, field @dataclass class Book(): """Тип данных книга""" title: str = None date: str = None authors: list = field(default_factory=list) price: float = 0 num: int = 0 total: float = field(init=False) def __post_init__(self): # инициализация переменной `total` self.total = self.price * self.num def print_state_book(book): """Печать сведений о книге""" print(f'Название: book.title>') print('Авторы:') for author in book.authors: print(' '*2, author) print(f'Стоимость книги: book.price:0.2f>') print(f'Количество: book.num>') print(f'Итого: book.total:0.2f>') >>> gold_key = Book('Золотой ключик', '1989', ['А. Толстой'], 512, 7) >>> day_watch = Book('Дневной Дозор', '2006', ['В. Васильев', 'С. Лукьяненко'], 1024, 9) >>> print_state_book(gold_key) # Название: Золотой ключик # Авторы: # А. Толстой # Стоимость книги: 512.00 # Количество: 7 # Итого: 3584.00 >>> print_state_book(day_watch) # Название: Дневной Дозор # Авторы: # В. Васильев # С. Лукьяненко # Стоимость книги: 1024.00 # Количество: 9 # Итого: 9216.00 
```
Вложенные пользовательские типы данных.

Одни пользовательские типы данных могут создаваться на основе других. Такое поведение хорошо прослеживается на примере с точкой на плоскости и координатами прямоугольника.
```
from dataclasses import dataclass, field @dataclass class Point: """Точка на плоскости""" x: int = 0 y: int = 0 @dataclass class Rect: """Прямоугольник на плоскости""" top_left: Point = field(default=Point) bottom_right: Point = field(default=Point) # создаем точки на плоскости >>> point1 = Point(10, 20) >>> point2 = Point(30, 55) # чертим прямоугольник >>> rect = Rect(point1, point2) >>> rect Rect(top_left=Point(x=10, y=20), bottom_right=Point(x=30, y=55)) 
```
Пользовательские типы данных, так же можно наследовать. Например из точки на плоскости можно создать точку в пространстве, а потом нарисовать прямоугольный параллелепипед.

Примечание: мы не сильны в стереометрии и возможно нужны дополнительные данные для типа RectBox . Этот класс создан чисто в учебных целях, что бы в совокупности проследить наследование пользовательских типов, а также создание одного типа на основе другого.
```
from dataclasses import dataclass, field @dataclass class Point: """Точка на плоскости""" x: int = 0 y: int = 0 # наследуемся от пользовательского типа `Point` @dataclass class SpacePoint(Point): """Точка в пространстве""" z: int = 0 # создаем тип `RectBox` на # основе типа `SpacePoint` @dataclass class RectBox: """Прямоугольный параллелепипед""" front_top_left: SpacePoint = field(default=SpacePoint) back_bottom_right: SpacePoint = field(default=SpacePoint) # создаем точки в пространстве >>> space_point1 = SpacePoint(10, 20, 10) >>> space_point2 = SpacePoint(30, 55, 80) # рисуем прямоугольный параллелепипед >>> rect_box = RectBox(space_point1, space_point2) >>> rect_box # RectBox(front_top_left=SpacePoint(x=10, y=20, z=10), # back_bottom_right=SpacePoint(x=30, y=55, z=80)) # изменим одну координату >>> rect_box.front_top_left.y = 10 >>> rect_box # RectBox(front_top_left=SpacePoint(x=10, y=10, z=10), # back_bottom_right=SpacePoint(x=30, y=55, z=80)) 
```
- ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
- Пространство имен и область видимости в классах
- Определение классов
- Объект класса и конструктор класса
- Создание экземпляра класса
- Метод экземпляра класса
- Что такое метод класса и зачем нужен
- Что такое статический метод в классах Python и зачем нужен
- Атрибуты класса и переменные экземпляра класса
- Кэширование методов экземпляра декоратором lru_cache
- Закрытые/приватные методы и переменные класса Python
- Наследование классов
- Множественное наследование классов
- Абстрактные классы
- Перегрузка методов в классе Python
- Что такое миксины и как их использовать
- Класс Python как структура данных, подобная языку C
- Создание пользовательских типов данных
- Специальные (магические) методы класса Python
- Базовая настройка классов Python магическими методами
- Настройка доступа к атрибутам класса Python
- Дескриптор класса для чайников
- Протокол дескриптора класса
- Практический пример дескриптора
- Использование метода .__new__() в классах Python
- Специальный атрибут __slots__ класса Python
- Специальный метод __init_subclass__ класса Python
- Определение метаклассов metaclass
- Эмуляция контейнерных типов в классах Python
- Другие специальные методы класса
- Как Python ищет специальные методы в классах
- Шаблон проектирования Фабрика и его реализация
Типы данных в Python для начинающих: какие бывают и как с ними работать

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

Иллюстрация: Оля Ежак для Skillbox Media

Антон Сёмин

Пишет об истории IT, разработке и советской кибернетике. Знает Python, JavaScript и немного C++, но предпочитает писать на русском.

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

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

Из этой статьи вы узнаете:
- что такое строгая динамическая типизация в Python;
- что такое изменяемые и неизменяемые типы данных;
- какие встроенные типы данных есть в Python;
- что почитать про типы данных в Python.
Что такое строгая динамическая типизация

Python — язык программирования со строгой динамической типизацией.

«Строгая» означает, что язык не производит неявные преобразования типов и не создаёт сюрпризов при их случайном смешении.

Чтобы понять, о чём идёт речь, запустите этот код на Python и JavaScript, а затем сравните результаты:

Изменяемые и неизменяемые типы данных

Типы данных в Python можно разделить на изменяемые и неизменяемые.

Когда мы присваиваем новое значение неизменяемому объекту, Python не перезаписывает его, а создаёт новый объект с тем же именем. Чтобы в этом убедиться, достаточно проверить id — уникальный номер, который присваивается каждому объекту в Python:

Строки

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

Рассмотрим основные операции со строками в Python:

Списки

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

Над списками можно производить те же операции, что и над строками:

Кортежи

Кортежи (tuple) — это те же списки, только неизменяемые. Над ними можно производить те же операции, что и над списками, — кроме тех, которые изменяют кортеж:

Что почитать про типы данных в Python

Теперь вы знаете о типах в Python достаточно, чтобы решать простейшие задачи и даже ответить на вопросы на собеседовании. Если хотите узнать о системе типов ещё больше — почитайте классические источники:
- «Изучаем Python 3», Часть II. Типы и операции, М. Лутц;
- «Программирование на Python 3», Глава 2. Типы данных, М. Саммерфилд;
- документацию Python, раздел «Built-in Types».
Больше интересного про код в нашем телеграм-канале. Подписывайтесь!

Читайте также:
- Где учить Python: 7 курсов, чтобы освоить язык с нуля и устроиться на работу
- Создаём первую игру на Python и Pygame
- Как работает Docker: подробный гайд от техлида
Числа, состоящие из действительной и мнимой части. Применяются в теории колебаний, квантовой механике и при обработке сигналов.

Типы данных в Python

Ключевое слово null обычно используется во многих языках программирования, таких как Java, C++, C# и JavaScript. Это значение, которое присваивается переменной.

Концепция ключевого слова null в том, что она дает переменной нейтральное или «нулевое» поведение.

А что же в Python?

Числа: целые, вещественные, комплексные

Числа в Python 3: целые, вещественные, комплексные. Работа с числами и операции над ними.

Исключения в python. Конструкция try — except для обработки исключений

Исключения (exceptions) — ещё один тип данных в python. Исключения необходимы для того, чтобы сообщать программисту об ошибках.

Байты (bytes и bytearray)

Байтовые строки в Python — что это такое и с чем это едят? Байтовые строки очень похожи на обычные строки, но с некоторыми отличиями. Попробуем выяснить, с какими.

Файлы. Работа с файлами.

В данной статье мы рассмотрим встроенные средства python для работы с файлами: открытие / закрытие, чтение и запись.

Множества (set и frozenset)

Доброго времени суток! Сегодня я расскажу о работе с множествами в python, операциях над ними и покажу примеры их применения.

Функции и их аргументы

В этой статье я планирую рассказать о функциях, именных и анонимных, инструкциях def, return и lambda, обязательных и необязательных аргументах функции, функциях с произвольным числом аргументов.

Кортежи (tuple)

Сегодня я расскажу о таком типе данных, как кортежи (tuple) и о том, где они применяются.

Словари (dict) и работа с ними. Методы словарей

Сегодня я расскажу о таком типе данных, как словари, о работе со словарями, операциях над ними, методах, о генераторах словарей.

Списки (list). Функции и методы списков

Сегодня я расскажу о таком типе данных, как списки, операциях над ними и методах, о генераторах списков и о применении списков.
- Книги о Python
- GUI (графический интерфейс пользователя)
- Курсы Python
- Модули
- Новости мира Python
- NumPy
- Обработка данных
- Основы программирования
- Примеры программ
- Типы данных в Python
- Видео
- Python для Web
- Работа для Python-программистов
- Сделай свой вклад в развитие сайта!
- Самоучитель Python
- Карта сайта
- Отзывы на книги по Python
- Реклама на сайте
Похожие публикации: