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

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

Что такое типы данных в Python

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

• изменяемые (множества, списки, словари);
• неизменяемые (кортежи, строки, числа);
• упорядоченные (списки, строки, кортежи, словари);
• неупорядоченные (множества).

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

• Для примера:
• int a = 10
• Процесс объявления переменной в Python очень простой:
• Например,
• a = 10

Топ-30 самых востребованных и высокооплачиваемых профессий 2023

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

Подборка 50+ бесплатных нейросетей для упрощения работы и увеличения заработка

Только проверенные нейросети с доступом из России и свободным использованием

ТОП-100 площадок для поиска работы от GeekBrains

Список проверенных ресурсов реальных вакансий с доходом от 210 000 ₽

Получить подборку бесплатно Уже скачали 23256

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

1. Например,
2. a = «Welcome»
3. a = 1
4. Сильная (иначе строгая) типизация говорит о том, что в Python нельзя смешивать типы данных. Если переменная была определена как число, то сложить её со строкой не получится:
5. К примеру,
6. a = 10
7. print(‘Десять = ‘ + a)
8. Благодаря этому повышается надёжность кода, потому что приходится явно преобразовывать число к строке:
9. Например,
10. a = 10
11. print(‘Десять = ‘ + str(a))

Модель данных

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

Модель данных

• Для объявления переменной в Python, надо обозначить её имя, разместить знак присваивания (=) и ввести значение, которое сохранится в переменной.
• К примеру,
• a = 10

Переменная под именем «а» получила число 10. Целочисленное значение 10 представляет собой объект, как всё в языке Python (числа, строки, списки и прочее). Объект – это абстракция данных. Под данными подразумеваются не только объекты, но и отношения между ними. В объект входит три компонента: тип, идентификатор и значение.

Во время создания переменной на уровне интерпретатора формируется целочисленный объект 10, который откладывается где-то в памяти. У этого объекта есть идентификатор, значение 10 и целочисленный тип. Через оператора присваивания (=) генерируется ссылка между переменной a и объектом 10, целочисленного типа.

Название переменной обязательно должно отличаться от ключевых слов Python. Для проверки можно использовать способ iskeyword() из модуля keyword.

1. К примеру,
2. import keyword
3. keyword.iskeyword(«for») # => True
4. Приведём ещё один пример, чтобы лучше разобраться в операции присвоения в Python:
5. Например,
6. a = 5
7. b = 10
8. print(id(a)) # => 140732499849616
9. print(id(b)) # => 140732499849776
10. a = b
11. print(id(a)) # => 140732499849776

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

Для вас подарок! В свободном доступе до 15.10

Скачайте ТОП-10 бесплатных нейросетей для программирования

Помогут писать код быстрее на 25%

Скачать файл

• Для выяснения типа переменной можно использовать опцию type():
• К примеру,
• a = 5
• print(type(a)) # =>
• Итак, мы можем перейти к разбору типов данных в языке программирования Python.

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

1. Для выяснения класса переменной или значения можно воспользоваться опцией type(), а функцией isinstance(), чтобы проверить, к какому классу принадлежит объект:
2. >>> a = 5
3. >>> print(a, «is of type», type(a))
4. 5 is of type
5. >>> a = 2.0
6. >>> print(a, «is of type», type(a))
7. 2.0 is of type
8. >>> a = 1+2j
9. >>> print(a, «is complex number?», isinstance(1+2j, complex))
10. (1+2j) is complex number? True
11. У целых чисел может быть любая длина и всё, что их ограничивает, это доступная память.

У чисел с плавающей запятой ограниченная точность. Различить целое число и число с плавающей запятой в консоли можно по внешнему виду (а точнее по точке): 1 – целое число, 1.0 – с плавающей запятой.

Дарим скидку от 60% на обучение «Веб-разработчик» до 15 октября

Уже через 9 месяцев сможете устроиться на работу с доходом от 150 000 рублей

Забронировать скидку

• Для комплексных чисел существует формат записи: x + yj, где х является действительной частью числа, а у – мнимой. Ниже приведены несколько примеров:
• >>> a = 1234567890123456789
• >>> a
• 1234567890123456789
• >>> b = 0.1234567890123456789
• >>> b
• 0.12345678901234568
• >>> c = 1+2j
• >>> c
• (1+2j)
• Как можно заметить, значение переменной b было усечено.

Списки

Список – это организованная последовательность элементов. Составляющие списка могут относиться к разным типам.

Списки

1. Сделать объявление списка совершенно несложно. Для этого используются квадратные скобки, внутри которых необходимо расположить элементы списка через запятую:
2. >>> a = [1, 2.2, ‘python’]
3. Есть вариант воспользоваться оператором [], чтобы извлечь из списка элемент (данный процесс называют «доступ по индексу») либо диапазон элементов (это называется «извлечение среза»).
4. >>> a = [5,10,15,20,25,30,35,40]
5. >>> print(«a[2] =», a[2])
6. a[2] = 15
7. >>> print(«a[0:3] =», a[0:3])
8. a[0:3] = [5, 10, 15]
9. >>> print(«a[5:] =», a[5:])
10. a[5:] = [30, 35, 40]

Только до 16.10

Скачай подборку материалов, чтобы гарантированно найти работу в IT за 14 дней

Список документов:

ТОП-100 площадок для поиска работы от GeekBrains 20 профессий 2023 года, с доходом от 150 000 рублей Чек-лист «Как успешно пройти собеседование» Анкета

• Списки относятся к изменяемому типу данных в Python. Это говорит о том, что значения его составляющих можно менять:
• >>> a = [1,2,3]
• >>> a[2] = 4
• >>> a
• [1, 2, 4]

Кортежи

1. Кортежи (tuple) представляют собой такие же списки, но они являются неизменяемым типом данных в Python.

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

2. some_tuple = (‘p’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’)
3. #крайний элемент кортежа
4. last_element = some_tuple[-1]
5. print(last_element)
6. #срез кортежа с первого по третий элемент
7. tuple_slice = some_tuple[0:3]
8. print(tuple_slice)
9. #изменяем значение первого компонента
10. some_tuple[0] = ‘c’
11. Во время попытки поменять элемент «р» на «с» Python выдаёт ошибку:
12. TypeError: ‘tuple’ object does not support item assignment

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

Словари

Словарь (dict) является неупорядоченной коллекцией пар «ключ – значение». Ключами могут быть любые постоянные объекты: числа, строки и даже кортежи.

• Пользоваться элементами, удалять и генерировать новые достаточно легко:
• #словарь с данными об ученике GeekBrains
• some_dict = {‘first_name’:’Алексей’,
• ‘age’:35, ‘is_paid’:True,
• ‘courses’:[‘python’, ‘javascript’, ‘html/css’], }
• print(some_dict)
• #элемент с ключом ‘last_name’
• print(some_dict[‘first_name’]) # ‘Алексей’
• #создать элемент, присвоив значение несуществующему ключу
• some_dict[‘second_name’] = ‘Петров’
• print(some_dict)
• #{‘first_name’: ‘Алексей’, ‘age’: 35, ‘is_paid’: True, ‘courses’: [‘python’, ‘javascript’, ‘html/css’], ‘second_name’: ‘Петров’}
• del some_dict[‘is_paid’]
• print(some_dict)
• #{‘first_name’: ‘Алексей’, ‘age’: 35, ‘courses’: [‘python’, ‘javascript’, ‘html/css’], ‘second_name’: ‘Петров’}

Значениями в словаре могут быть объекты, относящиеся к разным типам (в том числе и другие словари). Лимита вложенности нет.

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

Строка – ещё один тип данных в программировании Python, который представляет собой последовательность символов. Чтобы создать строку, используют одинарные или двойные кавычки. Для обозначения многострочных кавычек можно пользоваться тройными кавычками, »’ либо «»»:

1. >>> s = «Простая строка»
2. >>> s = »’Многострочная
3. строка»’

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

Множества

• Множества относятся к неупорядоченной уникализированной последовательности. В процессе объявления множества используют элементы через запятую внутри фигурных скобок:
• >>> a = {5,2,3,1,4}
• #вывод переменной множества
• >>> print(«a =», a)
• a = {1, 2, 3, 4, 5}
• #тип данных переменной а
• >>> print(type(a))
• К множествам можно применять такие процессы, как объединение и пересечение. Из-за обязательной уникальности элементов множества, дубликаты автоматически удаляются:
• >>> a = {1,2,2,3,3,3}
• >>> a
• {1, 2, 3}
• Так как множество – это неупорядоченная последовательность, воспользоваться оператором извлечения не получится:
• >>> a = {1,2,3}
• >>> a[1]
• Traceback (most recent call last):
• File «», line 1, in
• TypeError: ‘set’ object does not support indexing

Что важно запомнить про типы данных Python

• У каждого объекта в Python свой уникальный тип данных (int, string, list и прочие), и генерируются они конструкторами соответствующих классов.
• Переменные в языке Python являются названиями для области хранения данных вычислительной машины. Каждая переменная в коде имеет личный тип данных, по которому можно понять, какие значения могут находиться в этой переменной и сколько памяти ей необходимо.
• К неизменяемым объектам относятся те, состояние и содержимое которых нельзя менять. Если попытаться изменить значение такого объекта, создастся новый объект с необходимым значение и с таким же названием. Неизменные объекты включают в себя число, строку, кортеж.

Что важно запомнить про типы данных Python

• Изменяемыми называют те объекты, значения которых можно поменять после их создания. В их числе список, словарь или множества.
• Числовым типом данных, используемым в Python, являются числа целые, с плавающей запятой и комплексные.
• В логическом типе данных есть лишь два значения – True и False.
• В строковом типе данных хранятся текстовые сведения или последовательность байтов.
• Списки в Python представляют собой упорядоченную систему элементов, которые могут относиться к разным типам данных.
• Кортежи в Python являются такими же списками, но с одним лишь отличием – менять их нельзя.
• Словарями называют неупорядоченный перечень пар в формате ключ-значение.
• Множество представляет собой комплекс уникальных и неупорядоченных элементов, которые относятся к неизменяемому типу.

Язык программирования Python является объектно-ориентированным, то есть в его основе находятся объекты и классы. Объектом называют область хранения информации в компьютере, которую описывают через тип (иначе класс) и значение. В то же время тип влияет на область значений объекта, процессы и методы, которые на нём можно использовать. У Python есть большое количество встроенных типов данных. Это позволяет программисту реже писать собственные классы во время решения простых задач.

1. Типы данных — документация Python Lessons

Python Lessons

Примечание

Статья в разработке…

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

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

Это не совсем верное определение, но оно дает общее представление о картине в целом.

Присвоение значения переменной:

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

Знак равенства ( = ) используется
для присвоения значения переменной.
Операнд по левую сторону от знака равно ( = ) это имя переменной, операнд по правую сторону — значение присвоенное
этой переменной.

Таблица — Обзор встроенных типов объектов

Имя
Тип
Описание и пример

Целые Числа	int	Целые положительные или отрицательные числа-35, 0, 24, 123467890033373747428
Числа с плавающей точкой	float	Дробные числа 3.14, 2.5, -2.33333, 0.12334
Строки	str	Строки «asdf», «Hello world», «123456»
Списки	list	последовательность элементов[«hello», -123, 0.34, «345»]
Словарь	dict	Последовательность пар элементов содержаших ключ-значение (key-value) {«Language»: «Python», «Version»: «3.8»}
Кортеж (Tuple)	tup	Неизменяемая упорядоченная последовательность элементов («hostname», 1234, -0.45, -32)
Множество	set	Изменяемая неупоряоченная последовательностьэлементов {10, «Name», -30, 4.02, 100}
Булевые значения	bool	Тип данных принимающий одно из двух значенийtrue — истина false — ложь

Числа — Это не изменяемый тип данных.
Числа в Python бывают трёх типов: целые, с плавающей точкой и комплексные.
* Примером целого числа может служить 2.
* Примерами чисел с плавающей точкой (или «плавающих» для краткости) могут быть 3.23 и 52.3E-4. Обозначение E показывает степени числа 10. В данном случае 52.3E-4 означает 52.3 · 10−4.
* Примерыкомплексныхчисел:(-5+4j)и(2.3-4.6j)

Примечание

Нет отдельного типа ‘long int’ (длинное целое). Целые числа по умолчанию могут быть произвольной длины.

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

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

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

Строки можно суммировать. Тогда они объединяются в одну строку, такая операция называется «Конкатенацией строк»:

firts_string = «asdfgh»
second_string = «oiuytr»
print(firts_string + second_string)

Примечание

В Python 3 нет ASCII-строк, потому что Unicode является надмножеством (включает в себя) ASCII. Если необходимо получить
строку строго в кодировке ASCII, используйте str.encode(«ascii»). По умолчанию все строки в Unicode.

Предупреждение

Нельзя производить арифметтические операции над строкам и числами
Например:
«qwerty» + 3
Это вызовет ошибку, Но строки можно перемножать
«#» * 10
выведет на экран строку
##########

Физическая строка – это то, что вы видите, когда набираете программу. Логическая стро- ка – это то, что Python видит как единое предложение. Python неявно предполагает, что каждой физической строке соответствует логическая строка.

Примером логической строки может служить предложение print(„Привет, Мир!“) – ес- ли оно на одной строке (как вы видите это в редакторе), то эта строка также соответствует физической строке.
Python неявно стимулирует использование по одному предложению на строку, что об- легчает чтение кода.

Чтобы записать более одной логической строки на одной физической строке, вам придёт- ся явно указать это при помощи точки с запятой (;), которая отмечает конец логической строки/предложения. Например:

i=5
print(i)
#то же самое, что
i = 5; print(i);
#и то же самое может быть записано в виде
i = 5; print(i);

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

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

Это называется явным объединением строк.

s = 'Это строка.
Это строка продолжается.'
print(s) #Это строка. Это строка продолжается.

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

#!/usr/bin/env python3
# -*- coding: utf-8 -*- simple_string = 'Spam'
len(simple_string)
# 4
simple_string[0]
# 'S'
simple_string[1]
# 'p'

Нумерация всех символов в строке идет с нуля. Но, если нужно обратиться к какому-то по счету символу, начиная с конца,
то можно указывать отрицательные значения (на этот раз с единицы).

simple_string = «StringBody»
simple_string[1]
# t simple_string[-1]
# y

Кроме обращения к конкретному символу, можно делать срезы строк, указав диапазон номеров (срез выполняется по второе число, не включая его):

example_string = «Lorem Ipsum is simply dummy text of the printing and typesetting»
example_string[0:9]
# 'Lorem Ips' example_string[10:22]
# 'm is simply ' # Если не указывается второе число, то срез будет до конца строки:
example_string[-3:]
# 'ing'

Также в срезе можно указывать шаг:

# Так можно получить нечетные числа
a = '0123456789'
a[1::2]
# '13579' # А таким образом можно получить все четные числа строки a:
a[::2]
# '02468' # Срезы также можно использовать для получения строки в обратном порядке:
a[::-1]
# '9876543210'

Методы upper, lower, swapcase, capitalize

Методы upper(), lower(), swapcase(), capitalize() выполняют преобразование регистра строки:

string1 = 'FastEthernet' string1.upper()
#'FASTETHERNET' string1.lower()
#'fastethernet' string1.swapcase()
#'fASTeTHERNET' string2 = 'tunnel 0' string2.capitalize()
#'Tunnel 0' #Очень важно обращать внимание на то, что часто методы возвращают преобразованную строку. И, значит, надо не забыть присвоить ее какой-то переменной (можно той же).
string1 = string1.upper()
print(string1)
#FASTETHERNET

Метод count

Метод count() используется для подсчета того, сколько раз символ или подстрока встречаются в строке:

string1 = 'Hello, hello, hello, hello'
string1.count('hello') # 3
string1.count('ello') # 4
string1.count('l') # 8

Метод find

Методу find() можно передать подстроку или символ, и он покажет, на какой позиции находится первый символ подстроки (для первого совпадения):

string1 = 'interface FastEthernet0/1'
string1.find('Fast') # 10
string1[string1.find('Fast')::] # 'FastEthernet0/1'

Методы startswith, endswith

Проверка на то, начинается или заканчивается ли строка на определенные символы (методы startswith(), endswith()):

string1 = 'FastEthernet0/1'
string1.startswith('Fast') # True
string1.startswith('fast') # False
string1.endswith('0/1') # True
string1.endswith('0/2') # False

Метод replace

Замена последовательности символов в строке на другую последовательность (метод replace()):

string1 = 'FastEthernet0/1'
string1.replace('Fast', 'Gigabit') # 'GigabitEthernet0/1'

Метод strip

Часто при обработке файла файл открывается построчно. Но в конце каждой строки, как правило, есть какие-то спецсимволы (а могут быть и в начале). Например, перевод строки.

Для того, чтобы избавиться от них, очень удобно использовать метод strip():

string1 = '
interface FastEthernet0/1
'
print(string1)
#
#interface FastEthernet0/1
# string1.strip()
#'interface FastEthernet0/1'

• Примечание
• По умолчанию метод strip() убирает пробельные символы. В этот набор символов входят: tnrfv
• Методу strip можно передать как аргумент любые символы. Тогда в начале и в конце строки будут удалены все символы, которые были указаны в строке:

Метод strip() убирает спецсимволы и в начале, и в конце строки. Если необходимо убрать символы только слева или только справа, можно использовать, соответственно, методы lstrip() и rstrip().

Метод split

Метод split() разбивает строку на части, используя как разделитель какой-то символ (или символы) и возвращает список строк:

string1 = 'switchport trunk allowed vlan 10,20,30,100-200'
commands = string1.split()
print(commands) # ['switchport', 'trunk', 'allowed', 'vlan', '10,20,30,100-200'] #По умолчанию в качестве разделителя используются пробельные символы (пробелы, табы, перевод строки), но в скобках можно указать любой разделитель:
vlans = commands[-1].split(',')
print(vlans) #['10', '20', '30', '100-200']

Метод join

Метод join() позволяет объеденить список, кортеж или словарь в строку разделяя ее елементы другой строкой.

myTuple = («John», «Peter», «Vicky»)
x = «-«.join(myTuple)
print(x) #John-Peter-Vicky

1. Метод format
2. Метод format() позволяет подставлять в отмеченные в строке области символами «{}» значени из списка аргументов
3. например:

price = 49
txt = «The price is {} dollars»
print(txt.format(price))

Так же можно указать тип подставлемых значений:

#Строковые занчения
'{} {}'.format('one', 'two') #one two #Числовые значения
'{} {}'.format(1, 2) #1 2 #порядок значений можно указывать
'{1} {0}'.format('one', 'two') #two one #Можно так же подставлять значения классов
class Data(object): def __str__(self): return 'str' def __repr__(self): return 'repr' '{0!s} {0!r}'.format(Data()) #str repr #Отступы и выравнивания
#по правому краю
'{:>10}'.format('test') # test #по левому краю
'{:_

Список типов данных в Python

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

https://www.youtube.com/watch?v=bpASbXwjSp4\u0026pp=ygUf0KLQuNC_0Ysg0LTQsNC90L3Ri9GFINCyIFB5dGhvbg%3D%3D

Проиллюстрировать фундаментальность объектов в разрезе Питона можно, приведя пример общего вида программы на этом языке. Итак:

1. Программа состоит из модулей;
2. Модуль, в свою очередь, представляет собой набор инструкций;
3. Инструкции содержат выражения;
4. Выражения служат для создания и обработки объектов;

Объекты — базовое понятие в Python.

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

Что такое динамическая типизация

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

• типизированные языки;
• нетипизированные (бестиповые) языки.

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

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

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

Python же — язык типизированный. А, раз в нём определено понятие «типа», то должен существовать и процесс распознавания и верификации этих самых «типов». В противном случае вероятны ситуации, когда логика кода окажется нарушенной, а программа выполнится некорректно.

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

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

a = 1
print(type(a))

a = 'one'
print(type(a))

a = {1: 'one'}
print(type(a))

В языке со статической типизацией такой фокус не пройдёт:

// код на C++
int main() {
int b = 2;
cout ['Zelda', 'Master Sword']

print(alin)
> ['Zelda', 'Master Sword']

Поскольку списки — это ссылочные объекты, то вполне закономерно, что после присваивания переменной link переменной alin передалась именно ссылка на объект list-а и, при печати, на экран были выведены две одинаковые надписи.

Собственно, в этом и вся разница.

Числовые типы

«Все сущее есть Число» — сказал однажды мудрый грек по имени Пифагор. Числа — важнейший и фундаментальнейший из всех типов данных для всех языков программирования. В Python для их представления служит числовой тип данных.

int (целое число)

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

# примеры целых чисел
a = -3000
b = 0
c = 9000

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

float (число с плавающей точкой)

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

print(0.3 + 0.3 + 0.3)
> 0.8999999999999999

print(0.3 * 3 == 0.9)
> False

В плане записи, float ничем не отличаются от int:

# примеры вещественных чисел
zero = 0.0
pi = 3.14
e = 2.71

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

complex (комплексное число)

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

https://www.youtube.com/watch?v=bpASbXwjSp4\u0026pp=YAHIAQE%3D

В Python комплексные числа задаются с помощью функции complex():

# пример комплексного числа
z = complex(1, 2)
print(z)
> (1+2j)

# вещественная часть
print(z.real)
> 1.0

# мнимая часть
print(z.imag)
> 2.0

# сопряженное комплексное число
print(z.conjugate())
> (1-2j)

Помните, что операция сравнения для комплексных чисел не определена:

z1 = complex(4, 5)
z2 = complex(100, 200)
print(z1 > z2)

>
Traceback (most recent call last):
print(z1> z2)
TypeError: '>' not supported between instances of 'complex' and 'complex'

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

bool (логический тип данных)

В каком-то смысле наиболее простой и самый понятный из всех типов данных. У bool есть всего два значения:

• Истина (True);
• Ложь (False).

Однако за этой простотой кроется колоссальный пласт теории в виде булевой алгебры.

# пример bool
pravda = True
lozh = False

Переменные логического типа нужны для реализации ветвлений, они применяются для установки флажков, фиксирующих состояния программы, а также используются в качестве возвращаемых значений для функций, названия которых, зачастую, начинаются на «is» (isPrime, isEqual, isDigit). То есть тех, которые, на человеческом языке, отвечали бы на вопрос одним словом «Да» или «Нет».

Последовательности

Ещё одно понятие из математики. Там, последовательность — есть нумерованный набор элементов, в котором возможны их повторения, а порядок имеет значение. Определение Питона схоже с математическим: здесь последовательностью зовётся упорядоченная коллекция объектов.

str (строка)

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

строка — это последовательность односимвольных строк.s = 'Hello, friend.

You are my world'
print(type(s))

>

Важность строк велика в первую очередь для людей, ведь понятно, что вся письменная речь может рассматриваться, как множество строк.

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

list (список)

Список — это ещё один вид последовательностей… Здесь стоит остановиться и отметить, что последовательности в Python бывают изменяемыми и неизменяемыми. Список — изменяемая последовательность, а строки и кортежи — нет. Таким образом, список можно определить, как упорядоченную и изменяемую коллекцию, состоящую из объектов произвольных типов.

# пример списка
list_of_lists = [['code alpha', 'code beta'], [553, 434]]
list_of_lists[0][1] = 'code omega'

print(list_of_lists)
> [['code alpha', 'code omega'], [553, 434]]

Само название списков говорит об их предназначении быть объектами для хранения наборов данных. Список покупок, подарков, результатов матчей, ip клиентов или объектов типа Student. Списки в Python — это эдакие массивы из прочих языков «на максималках».

tuple (кортеж)

Кортежи в языке Python можно рассматривать, как неизменяемые списки со всеми вытекающими:

# пример кортежа
tup = ('i', 'j')
# мы можем получить первый элемент
print(tup[0])
> i

# но изменить его не получится
tup[0] = 'k'

>
Traceback (most recent call last):
tup[0] = 'k'
TypeError: 'tuple' object does not support item assignment

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

dict (словарь)

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

# пример простого словаря
dictionary = {'Огонёк': 'уменьш. от слова «Огонь»'}

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

set (множество)

Ещё один «набор, но не последовательность».

# пример множества
integer_num_set = {-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5}

Мы хотим видеть множество, если нам не существенен порядок элементов, но важна их уникальность.

# свойство уникальности
unique_set = {6, 6, 6, 5}

print(unique_set)
> {5, 6}

Файл

Работа с файлами, хранящимися где-то на внешнем носителе, в Python реализована в виде объектов-файлов. Они относятся к объектам базового типа, но обладают весьма характерной чертой: нельзя создать экземпляр объекта-файла при помощи литералов.

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

f = open('filename.txt', 'w')

Операции с файлами могут быть разными, а, следовательно, разными могут быть и режимы работы с ними:

• r — выбирается по умолчанию, означает открытие файла для чтения;
• w — файл открывается для записи (если не существует, то создаётся новый);
• x — файл открывается для записи (если не существует, то генерируется исключение);
• a — режим записи, при котором информация добавляется в конец файла, а не затирает уже имеющуюся;
• b — открытие файла в двоичном режиме;
• t — ещё одно значение по умолчанию, означающее открытие файла в текстовом режиме;
• + — читаем и записываем.

range object (a type of iterable)

Крутая особенность языка Python состоит в наличии в нём встроенной функции range(), которая способна генерировать непрерывную последовательность целых чисел:

r = range(10)
print(r)
> range(0, 10)

for i in r:
print(i, end=' ')
> 0 1 2 3 4 5 6 7 8 9

Она крайне удобна для создания циклов for.

None

None — специальный объект внутри Питона. Он означает пустоту, всегда считается «Ложью» и может рассматриваться в качестве аналога NULL для языка C/С++. Помимо этого, None возвращается функциями, как объект по умолчанию.

null = None

print(type(null))
>

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

Работа с типами в Python

Как проверить тип данных

Нет ничего проще, чем узнать тип данных объекта в Python:

# достаточно воспользоваться встроенный функции type()
my_list = {'Python': 'The best!'}

print(type(my_list))
>

Как поменять тип данных

В богатом арсенале Питона есть встроенные функции для приведения типов — int(), list(), set(), tuple(), str(), bin().

☝️ Обратите внимание: встроенная функция для приведения типа не модифицирует переданное значение, а возвращает новое значение другого типа.

# int() — преобразует числовую строку в целое число
seven = '7'
new_seven = int(seven)

print(new_seven, type(new_seven))
> 7 # list() — приведение итерируемого объекта к списку
nums = (11, 12)
new_nums = list(nums)

print(new_nums, type(new_nums))
> [11, 12] # set() — трансформация итерируемого объекта во множество
vegetables = ['carrot', 'tomato', 'cucumber']
new_vegetables = set(vegetables)

print(new_vegetables, type(new_vegetables))
> {'cucumber', 'carrot', 'tomato'} # tuple() — аналогично, но в кортеж
python = 'Python'
new_python = tuple(python)

print(new_python, type(new_python))
> ('P', 'y', 't', 'h', 'o', 'n') # str() — приведение к строковому типу
ex_dict = {'qiwi': 1453}
new_ex_dict = str(ex_dict)

print(new_ex_dict, type(new_ex_dict))
> {'qiwi': 1453} # bin() — преобразует десятичное число в двоичный формат
dec = 10
new_dec = bin(dec)

print(new_dec)
> 0b1010

Отличие type() от isinstance()

В отличие от type(), функция isinstance() возвращает не тип данных аргумента, а булево значение, говорящее о том, принадлежит объект к определенному классу или нет:

num = 4.44
print(isinstance(num, float))

> True

А ещё isinstance() умеет проверять принадлежность объекта хотя к одному типу из кортежа, переданного в качестве второго аргумента:

name = 'Ash'
print(isinstance(name, (float, int, complex)))
> False

print(isinstance(name, (float, int, complex, str)))
> True

Важным отличием также является то, что isinstance() «знает» о наследовании. Функция воспринимает объект производного класса, как объект базового.

class BaseExample:
pass

class DerivedExample(BaseExample):
pass

test = DerivedExample()
print(isinstance(test, BaseExample))

> True

А вот вывод результата работы функции type():

print(type(test))
>

Здесь видно, что для type() производный класс есть производный.