Tuple - это встроенный тип данных в Python, который используется для хранения набора данных. Это похоже на список, но работает немного быстрее.
Однако его ограничения делают списки более интересным в некоторых ситуациях. В этой статье я объясню все, что вам нужно знать, чтобы начать использовать кортежи.
Что такое кортеж?
Как упоминалось ранее, кортеж - это один из встроенных типов данных в Python, используемых для хранения коллекций данных. Это похоже на список Python в том смысле, что он хранит данные в повторяющемся формате, подобном массиву. Однако, в отличие от списка, кортеж неизменяем. То есть после создания их значения изменить нельзя.
Дополнительные элементы не могут быть добавлены, а существующие элементы не могут быть удалены. Таким образом, кортеж идеально подходит для хранения данных, которые не меняются. Это может быть даже набор данных разных типов. В следующем разделе мы обсудим различные способы создания кортежей в Python.
Как создать кортеж в Python?
Существует по крайней мере три способа создания кортежей в Python. В этом разделе мы рассмотрим три наиболее распространенных метода, которые вы, вероятно, будете использовать и увидите при чтении кода от других.
Для запуска следующих примеров кода вам потребуется установить Python. Если у вас еще не установлен Python, вот полезное руководство по установке Python.
# 1. Использование литерала кортежа (круглые скобки)
Наиболее распространенный способ увидеть кортежи, определенные в Python, - это поместить коллекцию значений в круглые скобки. Эти значения разделяются запятыми. Следующий пример иллюстрирует этот метод:
# Создает кортеж, помещая значения в круглые скобки
values = (1, 2, 3)
# Вывод кортежа на экран
print(values)
# Распечатка типа переменной variable
print(type(values))
Запуск этого кода приведет к следующему:
Как вы можете видеть из выходных данных, кортеж содержит значения, которыми мы его инициализировали. Это тоже типа <class 'tuple'>.
Когда вы создаете кортежи в Python, круглые скобки не нужны. Следовательно, это values = 1, 2, 3 в равной степени справедливо, как и это values = (1, 2, 3). Однако рекомендуется использовать круглые скобки, чтобы сделать ваш код более понятным.
Создание кортежей с одним элементом в Python немного сложно. Вместо того, чтобы просто заключать один элемент в круглые скобки, вам также нужно добавить запятую в конце. Вот пример для иллюстрации:
# Без завершающей запятой это не приведет к созданию кортежа
not_a_tuple = (1)
# С завершающей запятой это создаст кортеж
a_tuple = (1,)
# Печать not_a_tuple
print(not_a_tuple)
# Печать типа данных not_a_tuple
print(type(not_a_tuple))
# Печать a_tuple
print(a_tuple)
# Печать типа данных a_tuple
print(type(a_tuple))
Запустив приведенный выше код, вы увидите, что это not_a_tuple становится int значением 1. Это важно иметь в виду при создании кортежей.
#2. Использование функции конструктора
Второй метод создания кортежей в Python использует функцию конструктора кортежей. В этом методе вы вызываете функцию, передавая в качестве аргумента итеративный объект, подобный списку. Это будет преобразовано в кортеж. Вот пример:
# Создание кортежа из списка значений
values = tuple([1, 2, 3])
# Распечатка значений
print(values)
# Распечатка типа данных идентификатора значений
print(type(values))
Как вы можете видеть, использование функции приводит к тому же результату, что и использование литерала. Однако функция позволяет создавать кортеж на основе динамического значения, такого как список, значения которого известны только во время выполнения. При использовании первого метода вам нужно было бы знать значения или идентификаторы, составляющие ваш кортеж, во время написания кода.
#3. Создание пустого кортежа
При работе с кортежами в вашем коде вам может потребоваться создать пустые кортежи. Пустые кортежи создаются, как и следовало ожидать. При их создании вы можете использовать либо конструктор кортежей, либо литерал to . Вот пример, демонстрирующий, как использовать любой метод:
# Использование литерала кортежа
empty_tuple_1 = ()
# Использование конструктора
empty_tuple_2 = tuple()
Пустые кортежи полезны при представлении пустого набора результатов. Рассмотрим следующую функцию:
def create_range(start, end):
return tuple(range(start, end))
Эта функция создает кортеж со значениями от начального до конечного значения, которое вы передаете. Если бы вы хотели повторить результаты функции, вы бы использовали что-то вроде этого:
my_values = create_range(0, 5)
for value in my_values:
pass
Если бы вы указали 5 и 5 в функции create_range, результатом был бы пустой кортеж. И если бы вы попытались повторить это, у вас просто было бы ноль итераций, и ваш код продолжался бы как обычно.
С другой стороны, если бы не было пустых кортежей, и вместо этого вы получили значение None, то попытка выполнить итерацию по нему выдала бы ошибку. Чтобы предотвратить сбой программы, вам пришлось бы реализовать тест для крайнего случая, когда функция create_range возвращает None или любое другое значение, представляющее пустой кортеж.
Это привело бы к запутанному коду. В идеале, вы хотели бы максимально избегать особых случаев. Это означает, что возвращаемое значение всех функций должно иметь идентичный интерфейс, чтобы ваш код максимально работал в общем случае. В данном случае это означает постоянное возвращение кортежа, хотя иногда он будет пустым.
Как получить доступ к элементам
Есть два способа получить доступ к элементам кортежа в Python. Первый метод - по индексу, а второй - путем деструктурирования элементов. Сначала мы рассмотрим, как получить доступ к элементам по индексу.
Доступ к элементам по индексу
Доступ к элементам по индексу аналогичен тому, как вы получили бы доступ к элементам списка по индексу. Это делается с использованием обозначения в квадратных скобках. В кортежах используется система индексации на основе нуля, что означает, что первый элемент имеет индекс 0, а следующий за ним - индекс 1 до последнего элемента.
Приведенный ниже пример демонстрирует, как получить доступ к элементам по индексу:
# Создание кортежа
values = (1, 2, 3, 4)
# Доступ к первому элементу
first_element = values[0]
# Доступ к четвертому элементу (индекс 3)
fourth_element = values[3]
Вы также можете использовать отрицательную индексацию. Элемент с индексом -1 является последним элементом, а элемент с индексом -2 является вторым от последнего элемента.
# Создание кортежа
values = (1, 2, 3, 4)
# Доступ к последнему элементу
last_element = values[-1]
# Доступ ко второму из последнего элемента
second_from_last_element = values[-2]
Кроме того, вы также можете получить доступ к вложенным коллекциям элементов из кортежа, разрезав его. Это похоже на то, как вы бы нарезали список. Обозначения следующие <tuple>[<start>: <end>: <skip>]. Следующий пример демонстрирует нарезку:
# Создание кортежа
values = (1, 2, 3, 4, 5, 6, 7)
# Получение первых трех элементов
values[1: 3]
# Получение всех остальных элементов
values[::2]
Перебор элементов
Кортеж - это итеративный объект в Python. Поэтому вы можете выполнять итерации по его элементам с помощью цикла for, как показано в следующем примере:
values = (1, 2, 3, 4)
for value in values:
print(value)
Этот метод доступа к элементам идеален, когда вы хотите получить доступ ко всем элементам в кортеже.
Доступ к элементам путем деструктурирования
Чтобы объяснить деструктурирование, рассмотрим следующий сценарий, в котором мы пытаемся получить разные элементы в кортеже.
# Создание кортежа для записи информации пользователя
person_record = (1, 'Alexey Kalinkin', 'alex@yandex.ru')
# Доступ к различным элементам кортежа для использования в нашем коде
id = person_record[1]
name = person_record[2]
email = person_record[3]
Python позволяет нам использовать более удобный метод для доступа к значениям, как показано ниже:
# Создание кортежа для записи информации пользователя
person_record = (1, 'Alexey Kalinkin', 'alex@yandex.ru')
id, name, email = person_record
Это называется деструктурированием. То есть первой переменной, id в данном случае, будет присвоено первое значение в кортеже, а второй переменной - второму элементу. Это продолжается до конца кортежа. Приведенный выше пример эквивалентен этому:
id, name, email = (1, 'Alexey Kalinkin', 'alex@yandex.ru')
В этом случае, вместо сохранения кортежа в переменной, мы немедленно его разрушаем. Когда вы объедините это со знанием того, что вам не нужно использовать круглые скобки при создании кортежей, тогда вы сможете написать код, подобный этому:
id, name, email = 1, 'Alexey Kalinkin', 'alex@yandex.ru'
В конце всего этого у вас будут переменные id, name и email со значениями 1, 'Alexey Kalinkin' и 'alex@yandex.ru'. Это удобный и краткий способ создания переменных в Python, который вы увидите в производственном коде. Полезно знать, что в основе этого элегантного синтаксиса лежит концепция кортежей.
Различия между кортежем и списком
Хотя они похожи, некоторые ключевые различия делают каждый из них более подходящим для конкретного варианта использования. Понимание этих различий поможет вам выбрать наилучший тип данных для использования и написать лучший и более эффективный код.
Преимущества кортежа
#1. Это быстрее
Из-за того, как значения кортежа хранятся в непрерывной памяти, доступ к значениям происходит быстрее по сравнению со списком. Однако, поскольку после создания они не могут быть изменены, кортежи не всегда являются наилучшей структурой данных для хранения коллекций значений.
Их идеальным вариантом использования является хранение большого количества данных в памяти, которые не меняются, но к которым будут обращаться несколько раз во время выполнения программы. В этом случае ваша программа получит огромную выгоду от повышения производительности кортежей.
#2. Возвращает несколько значений
Вы можете использовать кортежи для возврата нескольких значений из функции и деструктурирования результата. Например:
from random import randint
def create_two_numbers():
first_num = randint(0, 9)
second_num = randint(0, 9)
return first_num, second_num
first_num, second_num = create_two_numbers()
В этом примере у нас есть функция, которая создает два случайных числа и возвращает их оба в виде кортежа. return first_num, second_num Оператор эквивалентен записи return (first_num, second_num). Это потому, что круглые скобки необязательны при создании кортежей. Чтобы получить доступ к результату, мы его деструктурируем.
#3. Значения защищены от записи
Кортежи неизменяемы после их создания. Поэтому они идеально подходят для хранения данных в памяти, которые не меняются во время выполнения программы. Они гарантируют, что вы случайно не перепишете данные где-нибудь еще в своем коде.
#4. Храните несколько типов данных
Кортежи позволяют хранить значения нескольких типов данных. Это позволяет создавать записи данных, например, хранить данные пользователя в кортеже. Вы также можете хранить более сложные элементы, такие как функции, словари, другие кортежи и даже списки.
Распространенные методы создания кортежей
#1. count()
Объект tuple содержит метод count, который подсчитывает, сколько раз встречается элемент. Например:
#Создание кортежа с несколькими числами
values = (1, 2, 3, 4, 5, 4, 4, 6)
# Подсчет количества четверок
n_fours = values.count(4)
# Распечатываем количество четверок
print(n_fours)
Из этого примера мы можем видеть, что число 4 встречается в нашем кортеже ровно три раза.
#2. index()
Метод index можно использовать для нахождения индекса первого вхождения значения в кортеже. Если значение не существует, будет выдано ValueError исключение. Вот некоторый код, иллюстрирующий, как работает index метод:
# Создание кортежа с несколькими числами
values = (1, 2, 3, 4, 5, 4, 4, 6)
# Поиск по индексу из 4
index_of_four = values.index(4)
print("Index of four:", index_of_four)
# Поиск по индексу 9
index_of_nine = values.index(9)
print("Index of nine:", index_of_nine)
И когда мы запускаем приведенный выше код, это результат:
В этом случае индекс 4 равен 3, и код выполнялся без проблем. Но когда дело дошло до нахождения индекса 9, программа выдала исключение. Важно обрабатывать такие исключения при написании программ на Python, использующих метод index.
#3. len()
Как и у всех итеративных объектов в Python, у кортежей есть свойство length, к которому вы можете получить доступ, передавая кортеж в качестве аргумента len() функции.
# Создание кортежа
values = (1, 2, 3, 4)
#Получение длины
length = len(values)
# Распечатайте выходные данные
print(length)
Это результат выполнения приведенного выше кода.
#4. min() и max()
Методы min и max работают путем перебора каждого элемента в итерации и сравнения, больше или меньше ли он предыдущего. В конце max вернет самый большой элемент в итерируемом, в то время как min возвращает наименьший.
С числами операция очевидна. При работе со строками Python будет использовать алфавитный порядок. Наименьшее слово, возвращаемое min, является первым словом, если строки были записаны в алфавитном порядке. В то время как самое большое слово является последним словом. Если iterable содержит сочетание разных типов данных, то обе операции завершатся неудачей, потому что Python не знает, как сравнивать разные типы данных.
Вот пример кода:
# Создание кортежа со значениями
values = (1, 2, 3, 4, 5)
# Получение наибольшего значения
largest = max(values)
# Получение наименьшего значения
smallest = min(values)
# Выводите результаты
print(largest)
print(smallest)
#5. sorted()
Функция sorted в Python принимает итерируемый объект и возвращает список отсортированных элементов. Вы можете вызвать функцию sorted, передать кортеж в качестве аргумента и получить элементы кортежа, отсортированные в списке. Чтобы преобразовать отсортированный список в кортеж, вы можете использовать функцию конструктора. Вот пример:
# Создание кортежа со значениями в случайном порядке
values = (1, 5, 3, 3, 2, 4)
# Использование sorted для сортировки значений в списке
sorted_list = sorted(values)
# Преобразование списка в кортеж
sorted_tuple = tuple(sorted_list)
# Печать выходных данных
print(sorted_tuple)
#6. Добавление и умножение кортежей
Операция сложения над двумя кортежами просто объединяет их вместе. Операция умножения повторяет элементы кортежа столько раз, сколько раз значение, на которое вы умножили. Вот пример, иллюстрирующий два примера:
# Создайте кортеж с некоторыми значениями
values = (1, 2, 3, 4, 5)
# Создайте новый кортеж, используя сложение
added = values + values
# Создайте новый кортеж, используя умножение
multiplied = values * 2
print("values + values =", added)
print("values * 2 =", multiplied)
Заключительные слова
В этой статье вы узнали, что:
- Кортежи - это объекты, похожие на списки, используемые для хранения коллекций значений.
- В отличие от списков, они неизменяемы.
- Они быстрее и эффективнее, чем списки.
- Они могут быть сконструированы с использованием круглых скобок и разделения значений запятыми.
- Они также могут быть сконструированы с помощью tuple функции конструктора.
- Вы можете получить доступ к отдельным значениям, используя систему индексов на основе нуля.
- Вы также можете деструктировать значения из кортежа.
- Вы также можете выполнять итерации по значениям, используя цикл for.
- Различные методы, которые вы можете использовать с кортежем.
