Первые принципы Python, часть 3: типы данных

Типы данных

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

В Python существует 5 примитивных типов, используемых для представления значений: целые числа, числа с плавающей запятой, логические значения, строки и NoneType (указывающий отсутствие значения). Каждый из типов примитивов обладает различными атрибутами, обеспечивающими уникальную функциональность. Примитивные типы — это предопределенные в языке объекты, из которых состоят все остальные дополнительные типы. Например, в китайском языке определенные предложения будут построены в зависимости от конкретной комбинации используемых символов. Тип также может быть определен явно:

explicitly_defined_type: int = 1
print(explicitly_defined_type)
>>> 1

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

Типы

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

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

Использование функции Type()

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

print(type('Hello World'))
print(type(1))
print(type(1.0))
print(type(True))
>>> <class 'str'>
>>> <class 'int'>
>>> <class 'float'>
>>> <class 'bool'>

Выходные данные <class ‘type’> представляют категорию типа, с которым связано значение. Когда вы имеете дело с большими кодовыми базами или программами, обычно проверяют тип переменной или значения, поскольку они содержат множество различных определенных переменных.

Целые числа

В Python объекты, являющиеся целыми числами, типа int, представляют положительные и отрицательные действительные целые числа. Например, целые числа состоят из таких цифр, как -1, 0, 1, 100, -1000:

print(type(-1))
print(type(0))
print(type(1))
print(type(100))
print(type(-1000))
>>> <class 'int'>
>>> <class 'int'>
>>> <class 'int'>
>>> <class 'int'>
>>> <class 'int'>

В Python большие целые числа, 10100, не могут быть разделены запятыми, как в математике, 10 100. Запятые между числами, 10,100, означают для Python, что объект данных является кортежем, а символы подчеркивания могут использоваться для представления больших целых чисел 10_100. Подчеркивания используются только для удобства чтения кода:

tuple_with_commas = 10,100
integer_with_underscores = 10_100
print(tuple_with_commas)
print(type(tuple_with_commas))
print(integer_with_underscores)
print(type(integer_with_underscores))
>>> (10, 100)
>>> <class 'tuple'>
>>> 10100
>>> <class 'int'>

Целочисленные значения не могут иметь 0, за которым непосредственно следует другая цифра, 5, без возникновения ошибки:

print(01)
>>> SyntaxError: leading zeros in decimal integer literals are not >>> permitted; use an 0o prefix for octal integers

Вы можете указать отрицательное целое число, поместив - перед цифрой 1:

print(-1)
>>> -1

Размещение + перед цифрой 1 приводит к тому же положительному целому числу, что и простое использование самой цифры без знака:

print(+1)
>>> 1

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

int_one = 1
int_two = 2
add_two_ints = int_one + int_two
multiply_two_ints = int_one * int_two
subtract_two_ints = int_one - int_two
print(add_two_ints)
print(type(add_two_ints))
print(multiply_two_ints)
print(type(multiply_two_ints))
print(subtract_two_ints)
print(type(subtract_two_ints))
>>> 3
>>> <class 'int'>
>>> 2
>>> <class 'int'>
>>> -1
>>> <class 'int'>

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

Числа с плавающей запятой

В Python объекты, представляющие собой числа с плавающей запятой, типа float, имеют значения, ссылающиеся на положительные и отрицательные десятичные числа, а также на рациональные числа. Примеры поплавков: 1.0, -5.0 и 1.111111.

float_one = 1.0
float_two = -5.0
float_three = 1.111111
float_one_type = type(float_one)
float_two_type = type(float_two)
float_three_type = type(float_three)
print(float_one_type)
print(float_two_type)
print(float_three_type)
>>> <class 'float'>
>>> <class 'float'>
>>> <class 'float'>

Если бы вам нужно было разделить два целых числа 1 и 1, ожидали бы вы получить целое число 1? В Python при делении двух целых чисел вместо этого остается число с плавающей запятой.

int_one = 1
int_two = 1
divide_two_ints = int_one / int_two
print(divide_two_ints)
>>> 1.0

Разделив целое число 1 на число с плавающей запятой 1.0, вы получите тот же результирующий тип числа с плавающей запятой:

int_one = 1
float_one = 1.0
divide_int_by_float = int_one / float_one
print(divide_int_by_float)
print(type(divide_int_by_float))
>>> 1.0
>>> <class 'float'>

Переменная int_one представляет тип объекта данных, отличный от переменных float_one и divide_int_by_float. Почти любое вычисление или операцию, которые можно выполнить над целым числом, можно выполнить и над числом с плавающей запятой:

int_one = 2
int_two = 2
float_one = 2.0
float_two = 2.0
add_two_ints = int_one + int_two
add_two_floats = float_one + float_two
print(add_two_ints)
print(add_two_floats)
>>> 4
>>> 4.0

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

high_decimal_value = 3.141592653589793
print(high_decimal_value)
>>> 3.141592653589793

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

В Python комплексные числа — это тип данных, состоящий из действительных и мнимых чисел, и возникающий при нахождении квадратного корня из отрицательного числа. Python следует соглашению по электротехнике, используя j для обозначения комплексных чисел вместо i, которое обычно используется в математике. Комплексные числа представлены в виде a + bj. Квадратный корень из -1 будет представлен как 1j в Python. Вы можете проверить, что тип сложного числа 1 + 1j:

a = 1
b = 1j
print(a + b)
print(type(a + b))
>>> (1+1j)
>>> <class 'complex'>

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

a = 1
b = 3
complex_number = complex(a, b)
print(complex_number)
print(type(complex_number))
  
>>> (1+3j)
>>> <class 'complex'>

Комплексные числа в Python представлены 32 байтами памяти.

Булевы значения

В Python тип данных Boolean (bool) действует как логический оператор, представляющий два значения: True или False. Первая буква, T или F, всегда заглавная. Проверьте типы True и False:

print(type(True))
print(type(False))
>>> <class 'bool'>
>>> <class 'bool'>

Логические объекты данных обычно используются для сравнения или если логика выражения верна. Проверить, больше ли одно число 2, чем другое число 1. Вычисляется как True:

first_number = 2
second_number = 1
greater_than = first_number > second_number
print(greater_than)
print(type(greater_than))
>>> True
>>> <class 'bool'>

Оценивается как False:

first_number = 1
second_number = 2
greater_than = first_number > second_number
print(greater_than)
print(type(greater_than))
>>> False
>>> <class 'bool'>

Струны

В Python тип данных String (str) состоит из последовательности символов, заключенных либо в одинарные, ‘’, либо в двойные, “”, кавычки:

string_with_single_quotes = 'Single quotes'
string_with_double_quotes = "Double quotes"
print(string_with_single_quotes)
print(string_with_double_quotes)
>>> Single quotes
>>> Double quotes

Кавычки должны быть согласованными, а одинарные и двойные кавычки нельзя использовать вместе для формирования строки. Например, строка не может быть сформирована с использованием ‘my_string” или “my_string’ без возникновения синтаксической ошибки:

mixed_quotes_one = 'my_string"
mixed_quotes_two = "my_string'
print(mixed_quotes_one)
print(mixed_quotes_two)
>>> SyntaxError: EOL while scanning string literal

Хотя одинарные и двойные кавычки могут использоваться друг в друге:

single_inside_double = "'Single quotes inside double quotes'"
double_inside_single = '"Double quotes inside single quotes"'
print(single_inside_double)
print(double_inside_single)
>>> 'Single quotes inside double quotes'
>>> "Double quotes inside single quotes"

Строки могут состоять только из одного символа клавиатуры:

single_character = 's'
print(single_character)
>>> s

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

multiple_words = 'This string has many different words.'
print(multiple_words)
>>> This string has many different words.

Или даже просто пустое место:

empty_string = ''
print(empty_string)
>>>

В первых принципах Python, часть 1, вы уже напечатали строку ‘Hello World’:

print('Hello World')
>>> Hello World

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

НетТип

В Python вы можете присвоить специальное значение None, которое имеет тип NoneType, переменной, если вы хотите оставить ее пустой. Проверьте тип None:

print(type(None))
>>> <class 'NoneType'>

Присвойте None переменной non_type, распечатайте значение и введите его в терминал:

none_type = None
print(none_type)
print(type(none_type))
>>> None
>>> <class 'NoneType'>

Преобразование типа

Вы можете изменить тип или преобразование типа значения объекта данных, используя функцию ключевого слова типа, такую ​​как int(), bool(), float(), str() и т. д., поскольку python динамически типизируется. В других языках программирования со статической типизацией переменная не может изменить свой тип после ее определения.

Использование int() для преобразования типа числа с плавающей запятой усекает десятичную точку и сохраняет первую цифру целого числа:

float_to_int_1 = int(1.9)
float_to_int_2 = int(100.1)
float_to_int_3 = int(3.14)
float_to_int_4 = int(1.0e2)
print(float_to_int_1)
print(type(float_to_int_1))
print(float_to_int_2)
print(type(float_to_int_2))
print(float_to_int_3)
print(type(float_to_int_3))
print(float_to_int_4)
print(type(float_to_int_4))
>>> 1
>>> <class 'int'>
>>> 100
>>> <class 'int'>
>>> 3
>>> <class 'int'>
>>> 100
>>> <class 'int'>

Python также имеет автоматическое преобразование типов при смешивании различных числовых типов значений. При объединении float и int Python не будет усекать значение, чтобы сохранить информацию, которая может быть потеряна:

a = 1
b = 1.1
type_conversion_addition = a + b
type_conversion_subtraction = a - b
print(type_conversion_addition)
print(type(type_conversion_addition))
print(type_conversion_subtraction)
print(type(type_conversion_subtraction))
>>> 2.1
>>> <class 'float'>
>>> -0.10000000000000009
>>> <class 'float'>

Преобразование int в float расширит целое число, добавив .0 к цифре:

int_to_float_1 = float(1)
int_to_float_2 = float(150)
print(int_to_float_1)
print(type(int_to_float_1))
print(int_to_float_2)
print(type(int_to_float_2))
>>> 1.0
>>> <class 'float'>
>>> 150.0
>>> <class 'float'>

Преобразование int в int или типа в себя не изменит тип или вывод:

int_to_int = int(1)
float_to_float = float(1.0)
print(int_to_int)
print(type(int_to_int))
print(float_to_float)
print(type(float_to_float))
>>> 1
>>> <class 'int'>
>>> 1.0
>>> <class 'float'>

Вы можете преобразовать число с плавающей запятой в строку, str(1.1):

convert_float_to_string = str(1.1)
print(convert_float_to_string)
print(type(convert_float_to_string))
>>> 1.1
>>> <class 'str'>

Но вы получите ошибку при преобразовании строки, содержащей десятичные знаки:

convert_string_with_decimals = int('1.1')
print(convert_string_with_decimals)
>>> convert_string_with_decimals = int('1.1')
>>> ValueError: invalid literal for int() with base 10: '1.1'

Или показатель:

convert_string_with_exponent = int('1.0e2')
print(convert_string_with_exponent)
>>> convert_string_with_exponent = int('1.0e2')
>>> ValueError: invalid literal for int() with base 10: '1.0e2'

Логические значения, приведенные к целым числам, будут оцениваться как 1 для True и 0 для False:

true_bool_to_int = int(True)
false_bool_to_int = int(False)
print(true_bool_to_int)
print(type(true_bool_to_int))
print(false_bool_to_int)
print(type(false_bool_to_int))
>>> 1
>>> <class 'int'>
>>> 0
>>> <class 'int'>

А преобразование целого числа 1 или 0 в логическое значение приведет к тем же обратным значениям True и False:

int_to_true_bool = bool(1)
int_to_false_bool = bool(0)
print(int_to_true_bool)
print(type(int_to_true_bool))
print(int_to_false_bool)
print(type(int_to_false_bool))
>>> True
>>> <class 'bool'>
>>> False
>>> <class 'bool'>

Приведение типа float, 1.0 или 0.0, к логическому значению приводит к тому же результату, что и int:

float_to_true_bool = bool(1.0)
float_to_false_bool = bool(0.0)
print(float_to_true_bool)
print(type(float_to_true_bool))
print(float_to_false_bool)
print(type(float_to_false_bool))
>>> True
>>> <class 'bool'>
>>> False
>>> <class 'bool'>

Вы можете преобразовать строки, представляющие целые числа, в целые числа:

str_to_int_1 = int('1')
str_to_int_2 = int('-1')
str_to_int_3 = int('1_000')
print(str_to_int_1)
print(type(str_to_int_1))
print(str_to_int_2)
print(type(str_to_int_2))
print(str_to_int_3)
print(type(str_to_int_3))
>>>1
>>> <class 'int'>
>>> -1
>>> <class 'int'>
>>> 1000
>>> <class 'int'>

Вы получите ошибку, если попытаетесь преобразовать тип пустой строки в int():

empty_string_conversion = int('')
int_and_string_conversion = int('1 and a string does not work')
print(empty_string_conversion)
print(int_and_string_conversion)    
>>> empty_string_conversion = int('')
>>> ValueError: invalid literal for int() with base 10: ''

Или нецифровой символ, int(‘x’):

convert_non_digit = int('x')
print(convert_non_digit)
>>> convert_non_digit = int('x')
>>> ValueError: invalid literal for int() with base 10: 'x'

Или int, за которым следует множество разных символов:

# empty_string_conversion = int('')
int_and_string_conversion = int('1 and a string does not work')
# print(empty_string_conversion)
print(int_and_string_conversion)
>>> int_and_string_conversion = int('1 and a string does not work')
>>> ValueError: invalid literal for int() with base 10: '1 and a   >>> string does not work'

Следующая часть

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

Предыдущие части

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

Первые принципы Python, часть 0

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

Первые принципы Python, часть 1

Создайте программу на Python, напишите код в файле .py, успешно скомпилируйте программу без ошибок и выведите текст Hello, World! до терминала здесь.

Первые принципы Python, часть 2

Узнайте, как создавать переменные с осмысленными именами и правильным синтаксисом здесь.

Спасибо за чтение

Если вы нашли эту статью полезной, пожалуйста, поделитесь ею со своими коллегами.

Социальные медиа

Или подпишитесь на меня в социальных сетях, чтобы получать дополнительные бесплатные образовательные материалы и обновления:

Подстек

"Середина"

Твиттер

Инстаграм