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

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

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

• Числовые : int , float и менее часто встречающиеся complex
• Последовательность : str (строка), list и tuple
• Логическое : ( True или False )
• Словарь : dict (словарь), состоящий из пар (key, value)

Важно отметить, что 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) 
 <class 'int'> 

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

 >>> x = int(5) 
 >>> type(x) 
 <class 'int'> 

Стоит отметить, что 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) 
 <class 'float'> 
 >>> y = 5/4 
 >>> type(y) 
 <class 'float'> 

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

 >>> y = 5.0 
 >>> type(y) 
 <class 'float'> 
 >>> y = float(5) 
 >>> type(y) 
 <class 'float'> 

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

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

Одно интересное примечание: как ведет себя NaN А именно, выполнение y == float('nan') вернет False , даже если y , ну, не число.

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

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

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

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

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

Последний числовой тип, который нам нужно охватить, - это 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) 
 <class 'str'> 

Они также могут содержать специальные значения, некоторые из которых являются \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 при преобразовании числа с float в str :

 # Assigning float value to `z` 
 >>> z = 5.2 
 
 # Checking for the type of `z` 
 >>> type(z) 
 <class 'float'> 
 
 # Printing the value of `z` 
 >>> z 
 5.2 
 
 # Changing `z` into a string 
 >>> z = str(z) 
 
 # Checking the type of `z` 
 >>> type(z) 
 <class 'str'> 
 
 # Printing the value of `z` 
 >>> z 
 '5.2' 

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

список

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

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

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

Доступ к элементам можно получить по их индексу в списке, причем индекс начинается с 0 .

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

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

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

 # Making an empty list 
 >>> some_list = [] 
 
 # Printing the value of the list 
 >>> some_list 
 [] 
 
 # Checking the type of the list 
 >>> type(some_list) 
 <class '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 "<stdin>", line 1, in <module> 
 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 очень похож на списки, с той лишь разницей, что он неизменяемый и создается с помощью () вместо [] . Это означает, что после создания 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 .

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

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

 # Declaring a boolean 
 >>> some_bool = True 
 
 # Printing a boolean's value 
 >>> some_bool 
 True 
 
 # Checking a boolean's type 
 >>> type(some_bool) 
 <class '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

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

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

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

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

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

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

 # Checking the value of a dict 
 >>> type({}) 
 <class 'dict'> 
 
 # 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 был написан таким образом, чтобы сделать код максимально простым для написания, не делая его слишком двусмысленным.

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