📜 Читайте также: Python: как преобразовать список в строку
Если вы только начинаете свой путь в Python, разнообразие доступных типов данных поначалу может сбить с толку — в языке их действительно много.
Каждая переменная в Python представляет собой зарезервированную область памяти. Тип переменной определяет, какой объем памяти будет выделен под данные и каким образом будет происходить взаимодействие с ними.
Соответственно, для полноценной работы с языком необходимо знать все реализованные в нем типы — именно на них основывается механизм хранения и преобразования информации в любом приложении.
Все типы данных Python можно разделить на 2 основные группы: встроенные и специализированные.
Первые существуют в языке по умолчанию и служат основой для всех возможных операций. Вторые же построены на базе первых, имеют дополнительную логику и становятся доступны только после подключения соответствующих модулей. К тому же специализированные типы могут быть созданы пользователями.
Вот полный список встроенных типов:
- Числа — int, float, complex
- Логические — true, false
- Строки — str
- Списки — list
- Кортежи — tuple
- Словари — dict
- Множества — set, frozenset
- Диапазоны — range
- Байты — bytes, bytearray
- NoneType — None
А вон некоторые из специализированных типов:
- Дата и время — date, time, timedelta, timezone
- Коллекции — ChainMap, Counter, UserList, UserString
Кстати, вывести в консоль название типа конкретной переменной можно с помощью простой команды:
print(type(1)) # в качестве аргумента было передано целое число.
Название типа выводится в таком формате:
<class 'int'>
Числа (Numbers)
Два основных числовых типа — int и float. Первый представляет собой целое число, а второй — число с плавающей запятой, которое имеет более высокую точность значения.
В Python переменные объявляются через присвоение конкретного значения:
variable = 1 # переменная типа int
variable = 1.5 # переменная типа float
С помощью специальных операторов над числами можно выполнять основные математические операции:
variable = 1 + 2 + 3 # операция сложения
print(type(variable)) # вывод: <class 'int'>
print(variable) # выводим значение переменной в консоль: 6
В процессе изменения значений переменные могут менять свои типы, резервируя больше памяти. Например, «легким движением руки» int может превратиться во float:
variable = 5 * 2 # операция умножения
print(type(variable)) # вывод: <class 'int'>
variable += 0.1
print(type(variable)) # вывод: <class 'float'>
Тем не менее, возможно выполнить и обратное преобразование типа:
variable = 6 / 2 # операция деления
print(type(variable)) # вывод: <class 'int'>
variable += 0.1
print(type(variable)) # вывод: <class 'float'>
print(variable) # вывод: 10.1
variable = int(variable) # присваиваем переменной value1 преобразованное в int ее же значение, которое обрезается до целых
print(variable) # вывод: 10
print(type(variable)) # вывод: <class 'int'>
Вот таблица, демонстрирующая возможные математические операции с числами:
Кстати, с помощью специальной функции можно округлять значение переменной, указывая количество цифр после запятой:
print(round(9/4.0, 2)) # вывод: 2.25
print(round(9/4.0, 1)) # вывод: 2.2
Можно также получить двоичное или шестнадцатеричное представление числа в формате строки str:
print(bin(8)) # вывод: 0b1000
print(hex(10)) # вывод: 0xa
Более сложные операции выполняются с помощью модуля math, который предварительно импортируется:
import math
print(math.sqrt(9)) # вывод: 3.0
Более подробно об этом модуле можно узнать в официальной документации.
Логические (Boolean)
Всего лишь две константы являются булевыми значениями — true и false. При этом, различные другие типы значений могут аналогично интерпретироваться как булевые.
К истинным значениям относится:
- true
- Ненулевое число
- Непустая строка
- Непустой объект
К ложным, соответственно, относится:
- false
- 0
- None
- пустая строка
- пустой объект
Чтобы узнать, является ли значение истинным или ложным, используется простая функция:
full_list = [1, 2, 3] # объявляем заполненный список
empty_list = [] # объявляем пустой список
print(bool(full_list)) # вывод: True
print(bool(empty_list)) # вывод: False
print(bool(0)) # вывод: False
print(bool(1)) # вывод: True
Строки (Strings)
Строки в Python можно указывать двумя типами кавычек:
string1 = “first” # двойные кавычки
string2 = ‘second’ # одинарные кавычки
Есть и другой способ — указание строки вместе с изначальным форматированием:
# можно использовать как “”” так и ‘’’
string1 = """
first line
second line
third line"""
print(string1) # вывод сохраняет все указанные отступы, пробелы и переносы строк
С помощью оператора суммирования строки можно объединять в одну:
string1 = "first"
string2 = "second"
print(string1 + string2) # соединяем две строки
print(string1 + ' ' + string2) # соединяем три строки
Умножение строки на число приводит к ее повторению соответствующее количество раз:
string1 = “repeat”
print(string1 * 3) # вывод: repeatrepeatrepeat
К конкретным символам строки можно обращаться как с начала строки, так и с конца. При этом нумерация начинается с нуля:
string1 = “word”
print(string1[0]) # вывод: w
print(string1[-1]) # вывод: d
Списки (Lists)
Списками в Python являются любые последовательности элементов. Во многих других языках программирования (в C++, например) такие последовательности называют массивами — они аналогично указываются через запятую внутри квадратных скобок.
listNumbers = [5, 7, 9, 11] # список цифр
listStrings = ['first', 'second', 'third'] # список строк
listMixed = [12, 2.5, 'string'] # список смешанных типов
Разумеется, к элементам списка можно обращаться по индексу:
listMixed = [12, 2.5, 'string']
print(listMixed[0]) # вывод: 12
print(listMixed[1]) # вывод: 2.5
print(listMixed[2]) # вывод: string
print(listMixed[-1]) # вывод: string
Аналогичным образом значение элементов можно менять:
listNumbers = [1, 2, 3, 4, 5]
print(listNumbers) # вывод: [1, 2, 3, 4, 5]
listNumbers[0] = 10
print(listNumbers) # вывод: [10, 2, 3, 4, 5]
Также вы можете получить доступ только к определенным элементам списка:
listNumbers = [1, 2, 3, 4, 5]
# положительное значение перед :: указывает количество исключаемых элементов сначала
print(listNumbers[1::]) # вывод: [2, 3, 4, 5]
# отрицательное значение перед :: указывает количество включаемых элементов с конца
print(listNumbers[-2::]) # вывод: [4, 5]
# положительное значение после :: указывает шаг списка с начала
print(listNumbers[::2]) # вывод: [1, 3, 5]
# отрицательно значение после :: указывает шаг списка с конца (т.е. инвертирует список)
print(listNumbers[::-2]) # вывод: [5, 3, 1]
# просто инвертированный список
print(listNumbers[::-1]) # вывод: [5, 4, 3, 2, 1]
С другой стороны, для инвертирования списка лучше использовать специальную функцию:
listNumbers = [1, 2, 3]
print(listNumbers) # вывод: [1, 2, 3]
listNumbers.reverse()
print(listNumbers) # вывод: [3, 2, 1]
Количество элементов тоже можно узнать:
listNumbers = [1, 2, 3]
print(len(listNumbers))
Вложенные списки тоже возможны — по сути, это классические многомерные массивы:
listNested = [[1, 2], [3, 4], [5, 6]]
print(listNested[0][0]) # вывод: 1
print(listNested[0][1]) # вывод: 2
print(listNested[1][0]) # вывод: 3
print(listNested[1][1]) # вывод: 4
print(listNested[2][0]) # вывод: 5
print(listNested[2][1]) # вывод: 6
Кортежи (Tuples)
Кортежами являются листы, которые нельзя изменить после инициализации. Для объявления кортежа используются круглые скобки:
listConstant1 = tuple()
listConstant2 = ('Alex', 'Mike')
print(listConstant1) # вывод: ()
print(listConstant2[0]) # вывод: Alex
Словари (Dictionaries)
Словари в какой-то степени похожи на списки с тем лишь исключением, что обращение к данным внутри выполняется не по индексу, а по ключу. При этом данные внутри словаря располагаются в том же порядке, в каком они были добавлены.
Таким образом, любые данные в словаре представляют собой пару «ключ-значение». Ключом может выступать только неизменяемый тип — число, строка, кортеж.
Если для списков выше мы приводили аналогию массивов в других языках программирования, то словари в данном случае представляют собой ассоциативные массивы.
Словарь объявляется следующим образом:
# запись в одну строку
personal1 = { 'country': 'Russia', 'city': 'Moscow', 'name': 'Ivan' }
# запись в несколько строк
personal2 = {
'country': 'Russia',
'city': 'Moscow',
'name': 'Ivan'
}
Обращение к значением аналогично спискам с помощью квадратных скобок, но по ключу:
personal = { 'country': 'Russia', 'city': 'Moscow', 'name': 'Ivan' }
print(personal['country']) # вывод: Russia
print(personal['city']) # вывод: Moscow
Добавить новые значение можно также по ключу — уже после инициализации:
personal = { 'country': 'Russia', 'city': 'Moscow', 'name': 'Ivan' }
personal[‘age’] = 26
print(personal) # вывод: {'country': 'Russia', 'city': 'Moscow', 'name': 'Ivan', 'age': 26}
Как и со списками, вы можете добавлять вложенные словари и получать значения из них:
personal = {
'country': 'Russia',
'city': 'Moscow',
'name': 'Ivan',
'child1': { 'country': 'Russia', 'city': 'Moscow', 'name': 'Alex' },
'child2': { 'country': 'Russia', 'city': 'Moscow', 'name': 'Mike' }
}
print(personal['child1']['name']) # вывод: Alex
print(personal['child2']['name']) # вывод: Mike
Множества (Sets)
Как и словари, множества похожи на листы. Разница лишь в том, что во множествах одинаковые элементы не дублируются.
Как и словарь, множество объявляется с помощью фигурных скобок, но без указания ключей:
set1 = { 1, 2, 3 }
set2 = { 1, 2, 3, 1 }
print(set1) # вывод: {1, 2, 3}
print(set2) # вывод: {1, 2, 3}
Добавить новый элемент во множество можно с помощью специальной функции:
set1 = { 1, 2, 3 }
set1.add(4)
set1.add(5)
print(set1) # вывод: {1, 2, 3, 4, 5}
С помощью специальных операторов можно проверить наличие определенного значения внутри множества:
set1 = { 1, 2, 3 }
print(1 in set1) # вывод: True
print(4 not in set1) # вывод: True
Чтобы сделать множество неизменяемым, нужно использовать отдельный тип frozenset:
set1 = { 1, 2, 3 }
set2 = frozenset(set1)
set1.add(7) # работает
set2.add(7) # ошибка
Диапазоны (Ranges)
Диапазон является неизменяемым типом в виде простого набора чисел. Есть несколько способов задать диапазон:
# диапазон от 0 до 4
range1 = range(4)
print(*range1) # вывод: 0, 1, 2, 3
# диапазон от 1 до 4
range2 = range(1, 4)
print(*range2) # вывод: 1, 2, 3
# диапазон от 2 до 8 с шагом 2
range3 = range(2, 8, 2)
print(*range3) # вывод: 2, 4, 6
# диапазон от 8 до 2 с шагом 2
range4 = range(8, 2, -2)
print(*range4) # вывод: 8, 6, 4
# символ * необходим для распаковки диапазона данных
Чаще всего диапазоны применяются в циклах для обработки каких-либо данных:
for i in range(4):
print(i) # тут также может быть какая-нибудь логика
# вывод: 0, 1, 2, 3
Байты (Bytes)
В Python есть отдельные типы для работы с «низкоуровневыми» байтовыми данными напрямую.
Во многом эти типы двоичных данных похожи на строки. Ведь с точки зрения памяти строки представляют собой именно последовательно байтов — только обрабатываются другими языковыми конструкциями.
Существует как изменяемый (bytearray), так и неизменяемый (bytes) байтовый тип. Только в отличие от строк, элементы байтовых массивов представляются в виде целых чисел со значениями от 0 до 255.
bytes1 = b"first bytes sequence" # инициализация с помощью литерала b
bytes2 = bytes(“second bytes sequence”, "utf_8") # инициализация через функцию с обязательным указанием кодировки
bytes3 = bytes(4) # инициализация с заполнением всей длины нулями
print(bytes1) # вывод: b'first bytes sequence'
print(bytes2) # вывод: b'second bytes sequence'
print(bytes3) # вывод: b'\x00\x00\x00\x00'
# байтовая последовательность с преобразованием в шестнадцатеричный формат
print(bytes3.hex()) # вывод: 00000000
Тип bytearray в этом смысле отличается только тем, что изменение ранее установленных значений не вызывает ошибку:
by = bytearray("any string", "utf_8")
print(by) # вывод: bytearray(b'any string')
by[0] = 65 # меняем первый байт на A через указание ASCII номера
print(by) # вывод: bytearray(b'Any string')
by[0] = ord("a") # меняем первый байт на a с использованием функции конвертации символа в число
print(by) # вывод: bytearray(b'any string')
NoneType (None)
Тип None используется для установки пустой переменной. По сути, это аналог Null в других языках программирования. Есть огромное количество случаев, когда может понадобиться проверка переменной на предмет ее «пустости».
Например, некая функция подключения к удаленному серверу может возвращать «пустой» результат в случае ошибки соединения. В таком случае можно проверить успешность операции.
connection = None # здесь может быть некая функция подключения connectToServer()
if connection is None:
print('Error')
else:
print('success')
Кстати, аналогично другим типам None можно проверить с помощью функции type:
anyVariable = 2
print(type(anyVariable)) # вывод: <class 'Int'>
anyVariable = None # тип поменялся на None
print(type(anyVariable)) # вывод:<class 'NoneType'>
Заключение
Как и в любом языке программирования, в Python есть базовые типы данных, на основе которых выстраивается логика приложений. В этой статье были показаны лишь основные свойства существующих типов данных.
Дополнением к базовым типам выступают модули Python, содержащие объекты с более специализированным функционалом. Так или иначе, более информативным источником всегда выступает официальная документация Python — там можно найти свежие данные по новым и старым модулям, специальным функциям, свойствам операторов и литералов.
В этом смысле, язык Python разительно отличается от того же C++ — документация выступает более «централизованным» источником знаний, нежели официальные стандарты C++, следуют которым в полной мере далеко не все производители компиляторов.
Кстати, в официальном канале Timeweb Cloud собрали комьюнити из специалистов, которые говорят про IT-тренды, делятся полезными инструкциями и даже приглашают к себе работать.💥
