Как изменить тип элементов списка python

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

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

Преобразование числовых типов

В Python есть два числовых типа данных: целые числа (integer) и числа с плавающей запятой (float). 

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

Преобразование целых чисел в числа с плавающей запятой

Метод Python float() преобразует целые числа в числа с плавающей запятой. Чтобы использовать эту функцию, добавьте в скобки целое число:

float(57)

В этом случае 57 будет преобразовано в 57.0.

Этот метод можно использовать и с переменной. Объявим f равным 57, а затем выведем новое значение с плавающей запятой:

f = 57
print(float(f))

Результат:

 57.0

Используя функцию float(), мы можем преобразовывать целые числа в числа с плавающей запятой.

Преобразование чисел с плавающей запятой в ​​целые числа

Python также имеет встроенную функцию для преобразования чисел с плавающей запятой в целые числа: int().

Функция  int() работает аналогично функции float(). Чтобы преобразовать десятичную дробь в целое число, вы можете добавить его внутрь скобок:

int(390.8)

В этом случае 390.8 будет преобразовано в 390.

Эту функцию можно использовать и с переменными. Давайте объявим b равным 125.0, а c — равным 390.8, а затем применим к переменным функцию int():

b = 125.0
c = 390.8

print(int(b))
print(int(c))

Результат:

 125
 390

При преобразовании чисел с плавающей запятой в целые числа с помощью функции int() Python отсекает все, что идет после запятой. Мы можем ожидать, что 390,8 округлится до 391, но с применением только лишь функции int() этого не произойдет.

Преобразование чисел путем деления

В Python 3 при делении одного целого числа на другое целое число результат преобразуется в число с плавающей запятой. То есть, если разделить 5 на 2, в Python 3 вы получите число с плавающей запятой:

a = 5 / 2
print(a)

 2.5

В Python 2, так как вы имели дело с двумя целыми числами, вы получите ответ в виде целого числа: 5 / 2 = 2. Прочтите «Python 2 vs Python 3: Практические соображения» для получения дополнительной информации о различиях между Python 2 и Python 3.

Преобразования со строками

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

Преобразование чисел в строки

Числа в строки можно преобразовать с помощью метода str(). Мы передаем число или переменную в скобки метода, а на выходе получаем строковое значение.

Давайте сначала рассмотрим преобразование целых чисел. Чтобы преобразовать целое число 12 в строку, передадим его в метод str():

str(12)

При запуске str(12) в интерактивной оболочке Python (чтобы войти в оболочку, введите python в окне терминала) вы получите следующий вывод:

 '12'

Кавычки вокруг числа 12 означают, что оно теперь является строковым значением, а не целым числом.

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

user = "Sammy"
lines = 50

print("Congratulations, " + user + "! You just wrote " + lines + " lines of code.")

Когда мы запускаем этот код, мы получаем следующую ошибку:

 TypeError: Can't convert 'int' object to str implicitly

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

user = "Sammy"
lines = 50

print("Congratulations, " + user + "! You just wrote " + str(lines) + " lines of code.")

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

 Congratulations, Sammy! You just wrote 50 lines of code.

Если мы хотим преобразовать в строку не целое число, а число с плавающей запятой, порядок действий остается прежним. Мы передаем в метод str() число с плавающей запятой, а возвращено будет строковое значение. Передавать в метод можно как само число, так и переменную:

print(str(421.034))

f = 5524.53
print(str(f))

 '421.034'
 '5524.53'

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

f = 5524.53
print("Sammy has " + str(f) + " points.")

 Sammy has 5524.53 points.

Мы можем быть уверены, что наш float был правильно преобразован в строку, потому что конкатенация была выполнена без ошибок.

Преобразование строк в числа

Строки могут быть преобразованы в числа при помощи методов int() и float().

Если в вашей строке нет десятичных знаков, вы, скорее всего, захотите преобразовать ее в целое число с помощью метода int().

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

lines_yesterday = "50"
lines_today = "108"

lines_more = lines_today - lines_yesterday

print(lines_more)

 TypeError: unsupported operand type(s) for -: 'str' and 'str'

Поскольку два числовых значения хранились в строках, мы получили ошибку. Операнд «-» для вычитания не является допустимым операндом для двух строковых значений.

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

lines_yesterday = "50"
lines_today = "108"

lines_more = int(lines_today) - int(lines_yesterday)

print(lines_more)

 58

Переменная lines_more автоматически является целым числом, и в этом примере она равна числовому значению 58.

В приведенном выше примере мы также можем преобразовать строчные значения в числа с плавающей запятой, используя метод float() вместо метода int(). В этом случае вместо 58 мы получим число с плавающей запятой —  58.0. Пользователь Сэмми зарабатывает очки в дробных числах:

total_points = "5524.53"
new_points = "45.30"

new_total_points = total_points + new_points

print(new_total_points)

 5524.5345.30

В этом случае использование операнда «+» с двумя строками является допустимой операцией. Но эта операция объединяет две строки, а не складывает два числовых значения вместе. В результате наш output выглядит необычно, поскольку это просто два значения рядом друг с другом.

Перед выполнением любых математических операций нам нужно преобразовать эти строки в числа с плавающей запятой с помощью метода float():

total_points = "5524.53"
new_points = "45.30"

new_total_points = float(total_points) + float(new_points)

print(new_total_points)

 5569.83

Теперь, когда мы преобразовали две строки в числа с плавающей запятой, мы получаем ожидаемый результат: сумму чисел 45.30 и 5524.53.

Если мы попытаемся при помощи метода int() конвертировать строку, представляющую собой десятичную дробь, в целое число, мы получим ошибку:

f = "54.23"
print(int(f))

 ValueError: invalid literal for int() with base 10: '54.23'

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

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

Вы можете использовать методы list() и tuple() для преобразования переданных им значений в тип данных списка и кортежа соответственно. В Python:

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

Преобразование в кортежи

Начнем с преобразования списка в кортеж. Поскольку кортеж — это неизменяемый тип данных, такое преобразование может способствовать существенной оптимизации наших программ. Метод tuple() возвращает «кортежную» версию переданного ему значения.

print(tuple(['pull request', 'open source', 'repository', 'branch']))

 ('pull request', 'open source', 'repository', 'branch')

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

Давайте используем tuple() с переменной, представляющей список:

sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp']
print(tuple(sea_creatures))

 ('shark', 'cuttlefish', 'squid', 'mantis shrimp')

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

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

print(tuple('Sammy'))

 ('S', 'a', 'm', 'm', 'y')

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

print(tuple(5000))

 TypeError: 'int' object is not iterable

Можно преобразовать целое число в строку, а затем в кортеж:  tuple(str(5000)). Но лучше выбрать читаемый код, а не сложные преобразования.

Преобразование в списки

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

Давайте преобразуем кортеж в список. Будьте внимательны со скобками: одна пара для кортежа, вторая — для метода  list(), а третья — для метода print():

print(list(('blue coral', 'staghorn coral', 'pillar coral')))

 ['blue coral', 'staghorn coral', 'pillar coral']

Квадратные скобки сигнализируют о том, что кортеж, переданный в метод  list(), преобразован в список.

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

coral = ('blue coral', 'staghorn coral', 'pillar coral')
list(coral)

Если мы выведем list(coral), мы получим тот же результат, что и выше.

В список можно преобразовать не только кортеж, но и строку:

print(list('shark'))

 ['s', 'h', 'a', 'r', 'k']

Заключение

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

В Python любые данные являются объектами с определенным классом. Следовательно типы данных являются классами, а переменные — это экземпляры или объекты этих классов.

С помощью функции type() можно определить к какому классу относится переменная:

my_str = 'строка'
my_list = ['один', 'два', 'три']
my_tuple = (1, 2, 3)
my_set = {1, 2, 3}
my_dict = {'Sasha': 35, 'Maxim': 30, 'Ivan': 20}
print(type(my_str))
print(type(my_list))
print(type(my_tuple))
print(type(my_set))
print(type(my_dict))
#<class 'str'>
#<class 'list'>
#<class 'tuple'>
#<class 'set'>
#<class 'dict'>

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

Тип данных переменной определяется автоматически, во время присваивания значения переменной.

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

a = 100
print(type(a))
a = 'Текст'
print(type(a))
a = [1, 2, 3]
print(type(a))
#<class 'int'>
#<class 'str'>
#<class 'list'>

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

Атомарные и структурные типы данных

В Python типы данных делятся на 2 вида: атомарные и ссылочные.

Атомарные типы данных:

• числа;
• строки;
• булевы;
• None.

Ссылочные типы данных:

• списки;
• множества;
• кортежи;
• словари;
• функции;
• классы;

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

Пример:

a = 1
b = a
a = 2
print(a)
print(b)
#2
#1

Здесь наглядно видно, что переменной b было присвоено именно значение переменной a, а не ссылка на область памяти.

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

my_list = [1, 2, 3]
my_list_2 = my_list
my_list[0] = 0
print(my_list)
print(my_list_2)
#[0, 2, 3]
#[0, 2, 3]

Переменной my_list_2 мы присвоили значение переменной my_list, т.е. список, далее изменили первый элемент списка (под 0 индексом) — это привело к тому, что значение переменной my_list_2 тоже изменилось.
Все потому, что это ссылочные типы данных и, мы передали ссылку на область памяти, а не само значение переменной.

Если нам нужно, чтобы значение в списке не менялось, то следует использовать метод list.copy(), а не присваивание:

my_list = [1, 2, 3]
my_list_2 = my_list.copy()
my_list[0] = 0
print(my_list)
print(my_list_2)
#[0, 2, 3]
#[1, 2, 3]

Основные типы данных Python

К стандартным типам данных в Python относятся:

• Числа.
• Строки.
• Списки.
• Кортежи.
• Словари.
• Множества.

Разберем подробнее каждый тип данных.

Числа

Числовой тип данных представляет из себя:

• Целые числа
• Вещественные числа
• Комплексные числа

Целые числа

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

Целые числа имею тип данных int:

a = 200
b = -34
c = 0
print(type(a))
print(type(b))
print(type(c))
#<class 'int'>
#<class 'int'>
#<class 'int'>

Вещественные числа

Это числа с плавающей точкой, т.е. числа с дробной частью.

Вещественные числа имеют тип данных float:

a = 200.1543
b = -34.0
c = 0.9
print(type(a))
print(type(b))
print(type(c))
#<class 'float'>
#<class 'float'>
#<class 'float'>

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

Эти числа записываются в формате x+yj, где x — действительная часть, а y — мнимая часть числа.

Комплексные числа имеют тип данных complex:

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

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

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

Этот тип данных имеет только 2 значения: False и True (истина и ложь).

Также стоит заметить, что True и False обязательно пишутся с большой буквы, иначе вы получите ошибку NameError: name ‘true’ is not defined.

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

Строки

Строка — неизменяемая упорядоченная последовательность символов.

Строки имеют тип данных str:

my_str = 'текст'
print(type(my_str))
#<class 'str'>

Списки

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

Списки имеют тип данных list:

my_list = ['текст', 1, 100, -5.43]
print(type(my_list))
#<class 'list'>

Кортежи

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

Кортежи имеют тип данных tuple:

my_tuple = ('текст', 1, 100, -5.43)
print(type(my_tuple))
#<class 'tuple'>

Словари

Словари — неупорядоченный набор пар ключ:значение.

Словари имеют тип данных dict:

my_dict = {'ключ1':'значение1', 'ключ2':'значение2', 'ключ3':'значение3'}
print(type(my_dict))
#<class 'dict'>

Множества

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

Множества имеют тип данных dict:

my_set = {1, 2, 3, 4}
print(type(my_set))
#<class 'set'>

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

Преобразование типов данных — это конвертация объекта из одного типа данных в другой.

В Python имеется 2 способа преобразования:

1. Неявное преобразование типов.
2. Явное приведение типов.

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

Пример:

a = 1
b = 2.2
a = a + b
print(a)
print(type(a))
print(type(b))
#3.2
#<class 'float'>
#<class 'float'>

У нас есть переменная a, которая имеет тип int, т.к. ей присвоено целое число. И есть переменная b с типом данных float.
После того, как мы сложили эти две переменные и эту сумму присвоили переменной a — у нее изменился тип на float.

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

При явном приведении типов, программист сам меняет тип данных с помощью функций int(), float(), str() и т.д.

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

Преобразовать х в целое число: int(х)

Поменяем тип float на int:

a = 10.8
b = int(a)
print(b)
print(type(a))
print(type(b))
#10
#<class 'float'>
#<class 'int'>

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

Преобразовать х в вещественное число: float(x)

Поменяем тип int на float:

a = 15
b = float(a)
print(b)
print(type(a))
print(type(b))
#15.0
#<class 'int'>
#<class 'float'>

Преобразовывать х в строку: str(x)

Поменяем тип int на str:

a = 15
b = str(a)
print(b)
print(type(a))
print(type(b))
#15
#<class 'int'>
#<class 'str'>

Преобразовать s в кортеж: tuple(s)

Поменяем тип str на tuple:

a = 'текст'
b = tuple(a)
print(b)
print(type(a))
print(type(b))
#('т', 'е', 'к', 'с', 'т')
#<class 'str'>
#<class 'tuple'>

Преобразовать s в список: list(s)

Поменяем тип str на list:

a = 'текст'
b = list(a)
print(b)
print(type(a))
print(type(b))
#['т', 'е', 'к', 'с', 'т']
#<class 'str'>
#<class 'list'>

Преобразовать s в словарь: dict(s)

Преобразуем список кортежей list в словарь dict:

a = [(1, 2), (3, 4)]
b = dict(a)
print(b)
print(type(a))
print(type(b))
#{1: 2, 3: 4}
#<class 'list'>
#<class 'dict'>