Руководство по основным типам данных в Python с примерами

Введение в типы данных Python

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

Один из способов классифицировать эти основные типы данных состоит в одной из четырех групп:

Числовые : int , float и менее часто встречающиеся сложные
Последовательность : str (строка), список и кортеж
Boolean : ( True или False )
Словарь : dict (словарь) тип данных, состоящий из (ключ, значение) пар

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

Не менее важно отметить, что Python является “слабо/слабо типизированным” языком программирования, что означает, что переменная может изменять свой тип в ходе выполнения программы, чего нельзя сказать о “строго типизированных” языках программирования (таких как Java или C++).

Таким образом, то, что было int , может легко стать str , если вы присвоите ему строковое значение.

В наших примерах мы будем иногда использовать функцию type(variable) , которая возвращает тип переменной, которую мы ей передали.

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

Числовые Типы данных

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

Целочисленный Тип данных – int

Тип данных int имеет дело с целыми числами. Это означает такие значения, как 0, 1 , -2 и -15 , а не такие числа, как 0.5, 1.01, -10.8 , и т. д.

Если вы дадите Python следующий код, он сделает вывод, что a является целым числом, и присвоит ему тип данных int :

>>> x = 5
>>> type(x)

Мы могли бы быть более конкретными и сказать что-то в этом роде, чтобы убедиться, что Python понял наш 5 однако как целое число он автоматически сделает то же самое под капотом:

>>> x = int(5)
>>> type(x)

Стоит отметить, что Python рассматривает любую последовательность чисел (без префикса) как десятичное число. Эта последовательность, по сути, ничем не ограничена.

То есть, в отличие от некоторых других языков, таких как Java, значение int не имеет максимального значения – оно неограниченно.

Тогда sys.maxsize может показаться нелогичным, поскольку он подразумевает, что это максимальное значение целого числа, хотя это не так.

>>> x = sys.maxsize
>>> x
2147483647

Это, по-видимому, 32-битное знаковое двоичное целое значение, хотя давайте посмотрим, что произойдет, если мы назначим более высокое число x :

>>> x = sys.maxsize
>>> x+1
2147483648

На самом деле, мы можем даже зайти так далеко, как:

>>> y = sys.maxsize + sys.maxsize
>>> y
4294967294

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

Префиксация Целых чисел

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

Более конкретно, префиксы:

0b или 0B – Превратит ваше целое число в двоичное
0o или 0O – Превратит ваше целое число в восьмеричное
0x или 0X – Превратит ваше целое число в шестнадцатеричное

Итак, давайте попробуем вот это:

# Decimal value of 5
>>> x = 5
>>> x
5

# Binary value of 1
>>> x = 0b001
>>> x
1

# Octal value of 5
>>> x = 0o5
>>> x
5

# Hexadecimal value of 10
>>> x = 0x10
>>> x
16

Тип данных с плавающей запятой – float

Тип данных float может представлять числа с плавающей запятой до 15 знаков после запятой. Это означает, что он может охватывать такие числа, как 0.3, -2.8, 5.542315467 , и т. д., но также и целые числа.

Числа, которые имеют более 15 чисел после точки, будут усечены. Например, Python без труда правильно понимает следующее как float :

>>> y = 2.3
>>> type(y)

>>> y = 5/4
>>> type(y)

Однако, как уже упоминалось ранее, если мы только скажем 5 Python будет считать его типом данных int . Если по какой-то причине нам нужна переменная float , имеющая значение 5 , нам нужно было бы явно сообщить Python об этом:

>>> y = 5.0
>>> type(y)

>>> y = float(5)
>>> type(y)

Этот тип данных может быть использован для представления некоторых специальных “чисел”, таких как NaN (“Не число”), +/- бесконечность и экспоненты:

>>> y = float('-infinity')
>>> y
-inf
>>> y = float(5e-3)
>>> y
0.005
>>> y = float('nan')
>>> y
nan

Одно интересное замечание здесь заключается в том, как ведет себя NaN . А именно, запуск y('nan') вернет False , хотя y – это, ну, не число.

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

>>> x = float('nan')
>>> x == float('nan')
False
>>> x == x
False
>>> x is x
True

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

Если вы не знакомы с разницей между операторами == и is , ознакомьтесь с нашим руководством по сравнению объектов в Python – is !

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

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

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

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

Давайте посмотрим, как мы можем объявить комплексные числа в Python:

# Assigning a value of 0r and 1j to `com`
>>> com = 1j

# Printing `com`s value
>>> com
1j

# Multiplying complex numbers
>>> com*com
(-1+0j)

# Assigning a value to a new `com` number
>>> com2 = 3 + 1j

# Adding two complex numbers
>>> com+com2
(3+2j)

# Assigning a new value to `com`
>>> com = complex(1 + 2j)

# Printing `com`
>>> com
(1+2j)

Типы данных Последовательности

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

ул

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

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

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

>>> my_string = 'some sequence of characters'
>>> my_string
'some sequence of characters'
>>> type(my_string)

Они также могут содержать специальные значения, некоторые из которых являются \n , если мы хотим, чтобы строка при печати имела новую строку или если мы хотим использовать специальные символы, такие как \ , ' или " нам нужно добавить перед ними обратную косую черту, например \ .

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

>>> my_string = "adding a new line \n and some double quotes \" to the string"
>>> print(my_string)
adding a new line 
 and some double quotes " to the string

Другой способ не беспокоиться о добавлении обратной косой черты перед каждым ' или " – это использовать вместо этого "' (тройные кавычки), и Python добавит обратную косую черту везде, где это необходимо для нас:

>>> my_string = '''No need to worry about any ' or " we might have'''
>>> my_string
'No need to worry about any \' or " we might have'

Мы можем продемонстрировать “слабую типизированную” природу Python при преобразовании a float в a str :

# Assigning float value to `z`
>>> z = 5.2

# Checking for the type of `z`
>>> type(z)


# Printing the value of `z`
>>> z
5.2

# Changing `z` into a string
>>> z = str(z)

# Checking the type of `z`
>>> type(z)


# Printing the value of `z`
>>> z
'5.2'

Мы видим, что z изменил свой тип без особых проблем.

список

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

Они создаются путем предоставления элементов списка между [] , например [element1, element2] или простым написанием [] и добавлением элементов позже.

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

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

Чтобы увидеть первый элемент списка (если он не пуст) для списка с именем some_list , вы можете использовать some_list[0] и то же самое относится ко всем остальным элементам списка.

Эти элементы также можно изменить в индексе i , написав some_list[i] .

Давайте составим список и выполним над ним некоторые операции:

# Making an empty list
>>> some_list = []

# Printing the value of the list
>>> some_list
[]

# Checking the type of the list
>>> type(some_list)


# Appending an integer to the list
>>> some_list.append(5)

# Printing the value of the list
>>> some_list
[5]

# Inserting an element at the `0`th index
>>> some_list.insert(0, 'some string')

# Printing the value of the list
>>> some_list
['some string', 5]

# Printing the value of the element on the `1`st index
>>> some_list[1]
5

# Appending another element ot the list
>>> some_list.append(123)

# Printing the value of the list
>>> some_list
['some string', 5, 123]

# Assigning the second element, an already existing value, to a new value
>>> some_list[2] = 'a'

# Printing the value of the list
>>> some_list
['some string', 5, 'a']

Однако, если вы попытаетесь отсортировать список с несовпадающими типами:

>>> some_list.sort()
Traceback (most recent call last):
  File "", line 1, in 
TypeError: '<' not supported between instances of 'int' and 'str'

Поскольку int нельзя сравнить с str с оператором < – возникает ошибка. Хотя, если бы мы это сделали:

>>> some_list = [1, 6, 4, 2, 8, 7]
>>> some_list
[1, 6, 4, 2, 8, 7]
>>> some_list.sort()
>>> some_list
[1, 2, 4, 6, 7, 8]

Мы могли бы разобраться.

кортеж

Тип данных tuple очень похож на списки, с той лишь разницей, что он неизменяем и создается с помощью () вместо [] . Это означает , что как только вы создадите кортеж , вы не сможете изменить содержащиеся в нем значения.

Они в большинстве случаев немного быстрее списков и используются для защиты данных от изменения:

# Creating a tuple
>>> some_tuple = ("some string", 5, True, float('nan'))

# Printing the value of a tuple
>>> some_tuple
('some string', 5, True, nan)

# Accessing an element of a tuple
>>> some_tuple[0]
'some string'

# Accessing elements from given index to the end of the tuple
>>> some_tuple[1:]
(5, True, nan)

# Accessing elements from given index to another given index
>>> some_tuple[1:3]
(5, True)

# Trying to assign a new value to the element at the `0`th index
>>> some_tuple[0] = 'some other string' # Causes an error

Логический тип – bool

Тип данных bool используется для представления логических значений – True или False . Тип данных не может содержать никакого другого значения.

Однако Python снова без особых проблем преобразует большинство вещей в bool . А именно, если вы случайно скажете bool(5) , Python будет считать , что True , в то время как bool(0) будет считаться False .

В основном, 0 является ложным и 1 это правда. Что-нибудь за пределами 1 также трактуется как True . То же самое происходит и со строками, где, если вы назначаете пустую строку, она обрабатывается как False .

Это booleanification (также называемое truthiness в Python) выполняется неявно в любом контексте, где Python ожидает значение bool . Например, высказывание if(5) имеет тот же эффект , что и if(bool(5)) , то есть if(True) .

Давайте посмотрим, как мы можем объявить и использовать boolean:

# Declaring a boolean
>>> some_bool = True

# Printing a boolean's value
>>> some_bool
True

# Checking a boolean's type
>>> type(some_bool)


# Assigning an empty string to a boolean
>>> some_bool = bool('')

# Checking the boolean's value
>>> some_bool
False

Обратите внимание, что True и False являются ключевыми словами, и что вы не можете сказать true или false :

>>> some_bool = false
# Throws an error

Тип словаря – dict

В отличие от группы последовательностей типов данных, dict s (словари) представляют собой неупорядоченные коллекции. В частности, неупорядоченные коллекции пар (ключ, значение) . Это означает, что, в отличие, например, от списков, значения связаны с ключами, а не с целочисленными индексами.

Словарь имеет следующую структуру:

{
	key1 : value1,
	key2 : value2,
	....
	keyN : valueN
}

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

Словари могут быть созданы либо добавлением (ключ, значение) пар между {} (помните, [] для списков и () для кортежей), либо просто написанием пустого {} и добавлением пар позже.

Ключи и значения могут иметь различные типы данных:

# Checking the value of a dict
>>> type({})


# Assigning keys and values to a dict
>>> some_dict = { 5 : 'five', 4 : 'four'}

# Printing the value of a dict
>>> some_dict
{5: 'five', 4: 'four'}

# Accessing a dict element via its key
>>> some_dict[5]
'five'

# Assigning a new value to a key
>>> some_dict[6] = 'six'

# Printing the value of the dict
>>> some_dict
{5: 'five', 4: 'four', 6: 'six'}

# Removing the (key, value) pair that has the key 5 (this also returns the value)
>>> some_dict.pop(5) 
'five'

# Trying to access an element with the key 5
>>> some_dict[5] # Raises an error since the key 5 no longer exists

Вывод

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

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