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

Типы данных в 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
• Реклама на сайте

Создание пользовательских типов растров в Python

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

Кроме обработки и считывания метаданных из файла, растровый тип также задает шаблоны обработки, которые могут применяться к считываемому типу данных. Шаблоны обработки могут объединять различные фрагменты информации из источников для создания более значимых выходных данных, которые лучше подходят для отображения и последующего анализа. Большинство растровых типов, основанных на данных сенсоров, используют шаблон Мультиспектральный в качестве одного из рабочих. В зависимости от типов данных, доступных для продукта, можно задать множество других шаблонов. Например, растровый тип Landsat 8 задает различные шаблоны, такие как Мультиспектральный, Панхроматический, Панхроматическое слияние, Растительность, Перистые облака и Снег/Лед.

Дополнительные сведения о растровых типах ArcGIS, имеющихся в Python, см. в разделе Растровые типы Github.

Свойства растрового типа

• Свойства канала – имя канала, минимальная и максимальная длины волн, поверхностная плотность потока солнечного излучения
• Шаблон обработки – шаблоны растровых функций, содержащие входные данные, функции и значения переменных
• Дополнительные поля – добавляются в набор данных мозаики
• Дополнительные входные данные – дополнительные сведения, необходимые для растрового типа для полного описания источника данных, например, ЦМР, которая должна быть применена к исходному набору данных для ортотрансформации изображения

Реализация пользовательского растрового типа

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

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

• RasterTypeFactory API
• Builder API
• Crawler_API (дополнительно)

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

Методика реализации растрового типа в Python является интуитивно понятной. ArcGIS предлагает адаптер растровых типов, который взаимодействует с системой ArcGIS и модулем Python для реализации растрового типа. Адаптер загружает модуль Python и находит RasterTypeFactory для определения растровых типов, использующихся в этом модуле. RasterTypeFactory должен содержать хотя бы одну открытую функцию, getRasterTypesInfo , которая возвращает информацию обо всех растровых типах, входящих в фабрику. Функция getRasterTypesInfo возвращает словарь RasterTypeDefinitions . Затем адаптер извлекает информацию о RasterTypes и обрабатывает растровые типы на основе Python так же, как и любые другие растровые типы, встречающиеся в ArcGIS. Затем среда ArcGIS взаимодействует с растровым типом на основе Python, используя Builder API и Crawler API.

После реализации вашего растрового типа с помощью Python, разместите модуль Python в папке [InstallDirectory]\Resources\Raster\Types .

Среда обработки растровых типов ArcGIS считывает все файлы *.py из этой папки и проверяет, имеются ли в них допустимые растровые типы. Если допустимые растровые типы найдены, они будут добавлены к списку поддерживаемых растровых типов в инструменте Добавить растры в набор данных мозаики .

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

Связанные разделы

Создание пользовательских типов данных в 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
• Динамическая типизация в Python
• О приведении типов в Python
• Получение помощи по объектам в Python
• Краткие итоги параграфа
• Вопросы и задания для самоконтроля

Как данные представлены в Python?

Когда мы имеем дело со значениями в программе, например, присваивая их для хранения переменной или передавая в качестве аргументов функции, нам приходится манипулировать различными типами этих значений ( ) такими, например, как числа или строки. В Python , как и в других языках программирования, имеется как встроенный комплект стандартных типов данных, так и возможность определять собственные пользо­вательские типы данных. При этом следует помнить про одну важную особенность – все данные в Python представлены в виде объектов, которые представляют собой выделенные области памяти со значениями данного типа и определенными для этих значений наборами операций (см. пример №1 ).

Код Результат pythonCodes

# Импортируем модуль. import sys # Интерпретатор автоматически выделит под значения в памяти # место, определит тип значений и набор операций для их # обработки, т.е. создаст в памяти два объекта. str_1 = 'Большой ' str_2 = 'дом.' # Выведем на экран типы этих значений. Для этого используем # общедоступную встроенную функцию type(obj) print('Тип объекта str_1: ', type(str_1)) print('Тип объекта str_2: ', type(str_2), end='\n\n') # Выведем объемы занимаемой значениями памяти. Метод getsizeof(obj) # модуля sys стандартной библиотеки возвращает размер объекта в байтах. print('Объем str_1: ', sys.getsizeof(str_1), 'байт') print('Объем str_2: ', sys.getsizeof(str_2), 'байт', end='\n\n') # Объединим эти строки в одну и выведем на экран. print(str_1 + str_2, end='\n\n') # Узнаем, что еще можно делать, например, с первым объектом. print(dir(str_1))

Тип значения в переменной str_1: Тип значения в переменной str_2: Объем памяти, занимаемый str_1: 90 байт Объем памяти, занимаемый str_2: 82 байт Большой дом. ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'] 

Пример №1. Определение типа и размера данных.

Как видим, Python предоставляет нам довольно обширный стандартный набор операций над строковыми объектами (надеюсь вы не забыли про кнопку «Результат» ). Тоже самое касается и других встроенных типов. Если же программисту вдруг станет тесно, он всегда может разработать собственный тип данных и определить для него необходимый набор операций.

Базовые типы данных Python

Давайте с целью первичного ознакомления перечислим некоторые основные типы данных встроенные в Python .

• Числа – это целые ( -8 , 0 , 47 ), вещественные ( -0.54 или -.54 , 0.0 , 2.475 ) и комплексные числа ( -3+5j , 77+2j ). Все они относятся к неизменяемым типам данных.
• Строки – это текст произвольной длины, взятый в одинарные, двойные или тройные кавычки. Например, ’25 яблок’ , «Ok, Python!» , »’Строка в тройных кавычках так»’ , «»»или так.»»» . Строки также являются неизменяемым типом данных, хотя получить доступ к символу строки можно по его индексу.
• Списки – это упорядоченные неименованные изменяемые коллекции значений (объектов), например, [‘A’, ‘B’, ‘C’] или [2, [True, False], «house»] . Литерал списка задается квадратными скобками, внутри которых через запятую перечисляются значения любых типов данных включая и сами списки. Доступ к значениям списка осуществляется по индексам (об этом чуть позже).
• Кортежи – это упорядоченные неименованные неизменяемые коллекции значений (объектов), например, (‘A’, ‘B’, ‘C’) или (2, «house», True) . Литерал кортежа задается круглыми скобками, внутри которых через запятую перечисляются значения неизменяемых типов данных. Доступ к значениям осуществляется по индексам. Но, т.к. кортежи являются неизменяемыми последовательностями, то добавлять или удалять элементы из них нельзя.
• Словари – это именованные изменяемые неупорядоченные коллекции значений (объектов), например, . Литерал словаря задается фигурными скобками, внутри которых через запятую перечисляются пары ключ: значение . В качестве ключей в принципе можно использовать любые неизменяемые уникальные значения, например, числа или строки, а в качестве значений вообще любые типы объектов, включая другие словари. Доступ к значениям в словаре осуществляется по ключам.
• Множества – это неименованные и неупорядоченные изменяемые коллекции уникальных и неизменяемых значений (объектов), например, . Литерал множества задается фигурными скобками, внутри которых через запятую перечисляются значения неизменяемых типов данных. Сами множества являются изменяемыми коллекциями значений, но вот значения в коллекции должны относиться к неизменяемым типам вроде чисел и строк.
• Логические значения – этот тип данных содержит всего две булевых константы: True и False .
• NoneType – специальное значение None , которое означает отсутствие значения.

Чтобы узнать тип объекта, используемого в программе, можно воспользоваться встроенной функцией type(obj) , которой в качестве аргумента нужно передать интересующий нас объект (см. пример №2 ). Функция является встроенной в интерпретатор Питона , поэтому ее не нужно импортировать и она общедоступна для использования из любой точки программы. Посмотреть весь список встроенных функций можно в справочнике стандартной библиотеки в разделе Built-in Functions.

Код Результат pythonCodes

# Не забываем про кнопку Результат! # Именованный аргумент end задает концовку вывода. # Здесь мы задали двойной перевод строки end='\n\n'. print('--- Числа ---', end='\n\n') # Выводим тип целого числа. print('5: ', type(5)) # Выводим тип числа с плавающей точкой. print('7.033: ', type(7.033)) # Выводим тип комплексного числа. print('-0.2+3j: ', type(-0.2+3j), end='\n\n') print('--- Строки ---', end='\n\n') # Строка в одинарных кавычках. print('\'Строка\': ', type('Строка')) # Строка в двойных кавычках. print('"Строка": ', type("Строка")) # Строка в тройных кавычках. print('"""Строка""": ', type("""Строка"""), end='\n\n') print('--- Списки ---', end='\n\n') # Проверим, является ли этот литерал списком. print('["one", [1,2], 0]: ', type(["one", [1,2], 0])) # Так можно задавать пустой список. print('[]: ', type([]), end='\n\n') print('--- Кортежи ---', end='\n\n') # Проверим, является ли этот литерал кортежем. print('("one", (1,2), 0): ', type(("one", (1,2), 0))) # Так можно задавать пустой кортеж. print('(): ', type(()), end='\n\n') print('--- Словари ---', end='\n\n') # Проверим, является ли этот литерал словарем. dict = print(": ", type(dict)) # Так можно задавать пустой словарь. print('<>: ', type(<>), end='\n\n') print('--- Множества ---', end='\n\n') # Проверим, является ли этот литерал множеством. print(": ", type()) # Так можно задавать пустое множество (литерала нет). print('set(): ', type(set()), end='\n\n') print('--- Булевы значения ---', end='\n\n') # Проверим, являются ли эти литералы булевыми значениями. print('True: ', type(True)) print('False: ', type(False), end='\n\n') print('--- Значение None ---', end='\n\n') # Проверим, является ли этот литерал NoneType. print('None: ', type(None), end='\n\n')

--- Числа --- 5: 7.033: -0.2+3j: --- Строки --- 'Строка': "Строка": """Строка""": --- Списки --- ["one", [1,2], 0]: []: --- Кортежи --- ("one", (1,2), 0): (): --- Словари --- : <>: --- Множества --- : set(): --- Булевы значения --- True: False: --- Значение None --- None:

Пример №2. Литералы встроенных типов данных в исходном коде.

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

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

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

– это прием, при котором переменная связывается с типом в момент присваивания значения, а не в момент объявления переменной.

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

Объем памяти, занимаемой любым объектом, можно узнать при помощи метода sys.getsizeof(obj) модуля sys стандартной библиотеки, который возвращает размер объекта в байтах. В качестве аргумента методу необходимо передать интересующий нас объект.

Проверить объект на принадлежность к типу можно при помощи встроенной функции isinstance(obj, type) , которой в качестве аргументов нужно передать проверяемый объект, а также имя типа. Если имя типа объекта совпадает с типом объекта, то функция вернет True , иначе – False .

Код Результат pythonCodes

# Импортируем модуль sys стандартной библиотеки. import sys # Присвоим переменной целое число. d = 33 # Проверим тип переменной. print('Тип переменной d: ', type(d)) # Узнаем ее размер в байтах. print('Размер d в байтах: ', sys.getsizeof(d), end='\n\n') # Теперь присвоим той же переменной словарь. d = # Тип по-прежнему int? print("Тип d все еще int?: ", isinstance(d, int)) # А какой тогда? print("Новый тип переменной d: ", type(d)) # А размер изменился? print('Новый размер d в байтах: ', sys.getsizeof(d))

Тип переменной d: Размер d в байтах: 28 Тип d все еще int?: False Новый тип d: Новый размер переменной d в байтах: 232 

Пример №3. Динамическая типизация в действии.

Как видим, интерпретатор все сделал за нас. Однако при этом не стоит забывать, что мы сами должны следить за тем, чтобы в выражениях использовались значения допустимых типов (см. пример №4 ). Например, если в текущем фрагменте кода мы делим переменные, следует самим следить за тем, чтобы в обоих на момент выполнения операции хранились числа, иначе может возникнуть ошибка.

Код Результат pythonCodes

# Присвоим переменной число с плавающей точкой. d = 33.47 # Присвоим переменной строку. s = '33.47' # Попробуем сложить res = d + s # и затем вывести результат на экран. print(res) # Получили вполне ожидаемую ошибку.

unsupported operand type(s) for +: 'float' and 'str' 

Пример №4. Неправильное использование значений различных типов.

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

О приведении типов в Python

Довольно часто в программе требуется преобразовать значение одного типа данных в другой. Например, когда пользователь вводит данные для вычислений в строковом виде, перед вычислениями возникает необходимость преобразования строки в число (см. пример №5 ). Если этого не сделать, то мы получим либо ошибку (как в предыдущем примере), либо совсем неожиданный результат.

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

Код Результат pythonCodes

# Просим ввести 1-е число с плавающей точкой. d = input('Введите 1-е вещественное число: ') # Просим ввести 2-е число с плавающей точкой. s = input('Введите 2-е вещественное число: ') # Я ввел 2.44 и 3.27 (см. Результат). # Преобразуем строки в вещественые числа. d = float(d) s = float(s) # А вот теперь сложим res = d + s # и выведем результат на экран. print('d + s =', res) 

Введите 1-е вещественное число: 2.44 Введите 2-е вещественное число: 3.27 d + s = 5.71 

Пример №5. Приведение типов в Python (часть 1).

В примере выше для преобразования строки в число мы использовали встроенную функцию float() . Кроме того, для преобразования различных типов данных между собой всегда доступны и другие встроенные функции (конструкторы типов): bool() , int() , complex() , str() , tuple() , list() , dict() или set() (см. пример №6 ). О каждой из них мы поговорим подробнее, когда будем рассматривать вопрос приведения типов в конце этой главы.

Код Результат pythonCodes

# Преобразуем строку в список. li = list('abc') # Посмотрим, что получилось. print('Строка -> список: ', li, end='\n\n') # Вещественное число преобразуем в целое. int_num = int(11.24) print('float -> int: ', int_num) # Строковое представление числа в число. float_num = float("11.24") print('"11.24" -> float: ', float_num, end='\n\n') # Преобразуем что-то в логический тип. bool_1 = bool(1) print('1 -> bool: ', bool_1) bool_2 = bool(0) print('0 -> bool: ', bool_2) # Строку с буквами в bool. bool_3 = bool('яблоко') print('str -> bool: ', bool_3) # Пустой объект в bool ('', [], <> и т.д.). bool_4 = bool([]) print('[] -> bool: ', bool_4, end='\n\n') # А вот здесь получим ошибки преобразования. # Число не является итерируемым объектом. li_1 = list(5) # Буквы не получится преобразовать, нужно число. int_num = int('яблоко') 

Строка -> список: ['a', 'b', 'c'] float -> int: 11 "11.24" -> float: 11.24 1 -> bool: True 0 -> bool: False str -> bool: True [] -> bool: False 'int' object is not iterable 

Пример №6. Приведение типов в Python (часть 2).

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

Получение помощи по объектам Python

Ранее мы уже отмечали, что в языке Python повсюду присутствуют объекты, которые представляют собой данные и наборы операций (методы) для обработки этих данных. Методы и данные, кстати, называют атрибутами объекта. Доступ к атрибутам любого объекта осуществляется через точку и имя атрибута. А чтобы узнать, какие атрибуты имеет данный объект, можно воспользоваться очередной встроенной функцией dir() , которой в качестве аргумента следует передать требуемый объект. Результатом будет словарь со всеми атрибутами объекта (см. пример №7 ).

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

Код Результат pythonCodes

# Давайте создадим строковый объект. str_1 = 'Конь в пальто!' # Выведем все атрибуты на экран и поэкспериментируем с ними. print(dir(str_1), end='\n\n') # Поищем подстроку па (выведет нам 7, т.е. индекс первого # вхождения подстроки в строке начиная с нуля). print(str_1.find('па')) # Переведем все символы строки в верхний регистр. print(str_1.upper(), end='\n\n') # Узнаем возможности типа int, используя его имя. # Ведь даже сами типы – это тоже объекты! d = dir(int) # А сколько вообще атрибутов у целочисленного типа? print('Количество атрибутов типа int:', len(d), end='\n\n') # Выведем их все на экран (см. Результат). print(d) 

['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'] 7 КОНЬ В ПАЛЬТО! Количество атрибутов типа int: 71 ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']

Пример №7. Получение атрибутов объектов.

Таким образом, если в процессе создания программы мы забудем, например, какие методы имеются в Python для обработки строк, всегда можно воспользоваться функцией dir() . Это касается объектов не только встроенных типов данных, но и созданных пользователем.

Но и это еще не все! Интерпретатор Python реально поставляется под ключ. Поэтому в комплекте имеется собственный встроенный справочник, что очень даже удобно (см. пример №8 ). Ведь типов данных довольно много и для каждого из них имеются не только общие, но и свои индивидуальные методы обработки этих данных. Так что, если информации предоставляемой функцией dir() становится недостаточно и хочется получить более подробную справку, следует обращаться за помощью к встроенной функции help() , передав ей в качестве аргумента интересующий нас объект.

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

Код Результат pythonCodes

# Давайте создадим строковый объект. str_1 = 'Конь одел кеды!' # А теперь получим подробную справку по методу find. help(str_1.find) # Просто отделим блоки информации. print('\n\n') # А давайте запросим подробную справку по всему типу. help(str) 

Help on built-in function find: find(. ) method of builtins.str instance S.find(sub[, start[, end]]) -> int Return the lowest index in S where substring sub is found, such that sub is contained within S[start:end]. Optional arguments start and end are interpreted as in slice notation. Return -1 on failure. Help on class str in module builtins: class str(object) | str(object='') -> str | str(bytes_or_buffer[, encoding[, errors]]) -> str | | Create a new string object from the given object. If encoding or | errors is specified, then the object must expose a data buffer | that will be decoded using the given encoding and error handler. | Otherwise, returns the result of object.__str__() (if defined) | or repr(object). | encoding defaults to sys.getdefaultencoding(). | errors defaults to 'strict'. | | Methods defined here: | | __add__(self, value, /) | Return self+value. | | __contains__(self, key, /) | Return key in self. | | __eq__(self, value, /) | Return self==value. -- Далее --

Пример №8. Получение справки по объектам.

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

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

Краткие итоги параграфа

• Все данные в Python представлены в виде объектов, которые представляют собой выделенные области памяти со значениями данного типа и определенными для этих значений наборами операций.
• К базовым типам данных Пайтона относятся числа ( int , float , complex ), строки ( str ), списки ( list ), кортежи ( tuple ), словари ( dict ), множества ( set ), булевы значения ( bool ) и специальное значение None ( NoneType ).
• Python относится к языкам программирования с динамической типизацией данных, поэтому программисту не нужно объявлять тип переменной в исходном коде. Интерпретатор делает это автоматически во время присвоения переменной нового значения. При этом он самостоятельно контролирует объем памяти, распределяемый под вновь создаваемый объект.
• Переменные в Python хранят не само значение, а ссылки на объект этого значения.
• Для преобразования одного встроенного типа данных в другой можно пользоваться соответствующими функциями (конструкторами типов): bool() , int() , float() , complex() , str() , tuple() , list() , dict() или set() . Однако нужно быть внимательным и во избежание ошибок проверять возможность такого преобразования.
• Для получения списка атрибутов объекта предназначена встроенная функция dir() , которой в качестве аргумента должен передаваться требуемый объект. Результатом будет словарь со всеми атрибутами объекта.
• Для получения более подробной справки по объектам следует использовать встроенную функцию help() , которой в качестве аргумента также нужно передавать требуемый объект.

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

Помогите проекту, подпишитесь!

Подписка на учебные материалы сайта оформляется сроком на один год и стоит около 5 у.е. После подписки вам станут доступны следующие возможности.

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

На страницу подписки

Вопросы и задания для самоконтроля

1. Определите устно типы следующих значений: ‘123’ , [1,2,3] , , 123 , , (1,2,3) . Показать решение.

Ответ. ‘123’ – строка (т.е. тип str ), [1,2,3] – список (т.е. тип list ), – множество (т.е. тип set ), 123 – целое число (т.е. тип int ), – словарь (т.е. тип dict ), (1,2,3) – кортеж (т.е. тип tuple ).

2. Выполните предыдущее задание, организовав вывод типов на экран при помощи скрипта. Показать решение.

Решение Результат pythonCodes

# Присвоим значения переменным. v_1 = '123' v_2 = [1,2,3] v_3 = v_4 = 123 v_5 = v_6 = (1,2,3) # Для определения типа значений используем функцию type(obj). print("Тип ", v_1, ": ", type(v_1), sep='') print("Тип ", v_2, ": ", type(v_2), sep='') print("Тип ", v_3, ": ", type(v_3), sep='') print("Тип ", v_4, ": ", type(v_4), sep='') print("Тип ", v_5, ": ", type(v_5), sep='') print("Тип ", v_6, ": ", type(v_6), sep='') 

Тип 123: Тип [1, 2, 3]: Тип : Тип 123: Тип : Тип (1, 2, 3):

3. Переменной li присвоили список [1, 2, 3] . В ходе выполения программы в список были добавлены еще два значения и он принял вид [1, 2, 3, 4, 5] . На сколько изменился объем памяти, занимаемый переменной? Показать решение.

Решение Результат pythonCodes

# Импортируем модуль sys стандартной библиотеки. import sys # Узнаем исходный размер, занимаемый переменной. li = [1, 2, 3] vol_1 = sys.getsizeof(li) # Узнаем конечный размер, занимаемый переменной. li = [1, 2, 3, 4, 5] vol_2 = sys.getsizeof(li) # Вычисляем изменение объема. v = vol_2 - vol_1 # Выводим результат на экран. print('Объем изменился на ', v, ' байт.', sep='')

Объем изменился на 16 байт.

4. Что такое динамическая типизация? Показать решение.

Ответ. – это прием, при котором переменная связывается с типом в момент присваивания значения, а не в момент объявления переменной.

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

Решение pythonCodes

# Просим ввести 1-е целое число. d = input('Введите 1-е целое число: ') # Просим ввести 2-е целое число. s = input('Введите 2-е целое число: ') # Преобразуем строки в целые числа. d = int(d) s = int(s) # Перемножим их. res = d*s # И выведем результат на экран. print('Произведение чисел равно ', res)

6. У какого типа больше атрибутов: tuple или list ? Сперва попытайтесь догадаться устно, а затем вычислите программно и выведите их атрибуты на экран. Показать решение.

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

Решение Результат pythonCodes

# Получаем словарь атрибутов типа tuple. t = dir(tuple) # Выводим их количество на экран. print('Количество атрибутов типа tuple:', len(t), end='\n\n') # Выведем все атрибуты на экран. print(t, end='\n\n') # Получаем словарь атрибутов типа list. li = dir(list) # Выводим их количество на экран. print('Количество атрибутов типа list:', len(li), end='\n\n') # Выведем все атрибуты на экран. print(li)

Количество атрибутов типа tuple: 33 ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index'] Количество атрибутов типа list: 46 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

7. Получите описание функции len , использовав встроенную справку. Показать решение.

Решение Результат pythonCodes

# Используем функцию help(). help(len) 

Help on built-in function len in module builtins: len(obj, /) Return the number of items in a container.

8. Какая из рассмотренных нами функций len() , type() , print() , isinstance() , dir() , help() или input() содержится в модуле sys ? Как мы можем получить доступ к ней? Показать решение.

Ответ. Все перечисленные функции являются встроенными и не требуют импорта модуля стандартной библиотеки sys . Но с одной такой функцией мы уже познакомились – это функция getsizeof() . Чтобы ее использовать, сперва нужно импортировать указанный модуль при помощи инструкции import sys .

Быстрый переход к другим страницам

• Синтаксис Python
• Введение в типы данных Python
• Числа в Python
• Вернуться к оглавлению учебника

okpython.net Copyright © 2022-2024.