Типы данных в Python
Кортежи в Python – это один из четырех встроенных типов данных, которые используются для того, чтобы хранить наборы данных. К остальным типам данных относятся списки, множества и словари. У каждого из типов данных есть свои уникальные особенности, и каждый из них используется по-своему.
Иллюстрация списка, кортежа и множества
Списки – это изменяемые упорядоченные последовательности элементов. Как правило, они используются для того, чтобы хранить однотипные данные. Тем не менее, их также можно использовать для хранения элементов, которые имеют разные типы данных.
my_list = [1, 2, 3, 4, 5]
print(my_list)Списки в Python
Множества – это изменяемые неупорядоченные наборы уникальных элементов. Этот тип данных полезен для выполнения математических операций с данными.
my_set = {"apple", "banana", "cherry", "apple"}
print(my_set)Множества в Python
Если вы выполните код, приведенный выше, второе вхождение слова "apple" в множестве будет проигнорировано, так как множества хранят только уникальные элементы.
Словари – это изменяемые неупорядоченные наборы пар ключ-значение. Они используются для того, чтобы можно было связать ключ со значением (все как в реальном словаре).
my_dict = {"Alice": 25, "Bob": 30, "Charlie": 35}
print(my_dict)Словари в Python
Кортежи – это неизменяемые упорядоченные последовательности элементов. Они полезны для хранения и передачи связанных фрагментов данных, которые не подлежат изменениям после того, как они были созданы.
my_tuple = ("apple", "banana", "cherry")
print(my_tuple)Кортежи в Python
Если вы создаете кортеж с несколькими элементами, то скобки можно не использовать, хотя их довольно часто используют для того, чтобы внести ясность.
my_tuple = 1, 2, 3
print(my_tuple)При создании кортежи могут быть записаны как с помощью круглых скобок, так и без них
Что такое кортеж?
Как мы уже говорили выше, кортеж – это упорядоченная и неизменяемая последовательность элементов. Это значит, что после того, как кортеж будет создан, элементы в нем менять будет нельзя.
Ниже приведен код для создания кортежа:
my_tuple = (1, 2, 3, 'four', 5.0)В нашем случае my_tuple - это кортеж, который содержит пять элементов. Обратите внимание, что элементы в кортеже могут быть разных типов. Например, в примере выше кортеж содержит три значения типа integer, одно – типа string, и одно – типа float (или double).
Получить доступ к элементам кортежа довольно просто. Для того, чтобы это сделать, вам нужно их просто проиндексировать, как в обычном списке.
print(my_tuple[0]) # outputs 1
print(my_tuple[3]) # outputs 'four'Обращение к элементу в кортеже
Можно обратиться сразу к нескольким элементам кортежа. Сделать это можно с помощью срезов.
print(my_tuple[1:3]) # outputs (2, 3)Срезы кортежа
Возьмите код, который приведен выше, и попробуйте получить доступ к элементу, чей индекс выходит за пределы диапазона кортежа. Например, попробуйте обратиться к элементу с индексом 6. Получите ли вы ошибку? Попробуйте выяснить!
Одно из основных преимуществ использования кортежей (по сравнению со списками) заключается в том, что их можно быстрее перебирать, и они более эффективно используют память. Именно поэтому они считаются отличным вариантом для хранения какого-то фиксированного набора значений, который не нужно менять.
Но, поскольку кортежи неизменяемы, то после его создания вы не сможете изменять элементы. В связи с этим, если ваша задача подразумевает изменение набора элементов, то вместо кортежей вам придется использовать списки.
Основные функции
Ниже перечислены некоторые примеры использования функций и методов для кортежей в Python:
- len(tuple): возвращает длину кортежа.
my_tuple = (1, 2, 3, 'four', 5.0)
print(len(my_tuple)) # outputs 5Получение длины кортежа
- tuple(seq): преобразует последовательность (например, список или строку) в кортеж.
my_list = [1, 2, 3]
my_tuple = tuple(my_list)
print(my_tuple) # outputs (1, 2, 3)
my_string = 'hello'
my_tuple = tuple(my_string)
print(my_tuple) # outputs ('h', 'e', 'l', 'l', 'o')Преобразование последовательности в кортеж
- tuple.count(value): возвращает количество вхождений указанного значения в кортеж.
my_tuple = (1, 2, 3, 2, 2, 'hello')
print(my_tuple.count(2)) # outputs 3
print(my_tuple.count('goodbye')) # outputs 0Подсчет количества вхождений указанного значения
Так как в кортеже my_tuple нет слова goodbye, то вывод для конкретно этого оператора равен 0 (строка 3).
- tuple.index(value): возвращает индекс первого вхождения указанного значения в кортеж.
my_tuple = (1, 2, 3, 2, 2, 'hello')
print(my_tuple.index(2)) # outputs 1
print(my_tuple.index('hello')) # outputs 5
#print(my_tuple.index(4)) # will throw an errorПолучение индекса указанного значения
Обратите внимание, что если вы будете выполнять поиск для значения, которого нет в кортеже my_tuple, то вы получите сообщение об ошибке "x not in tuple". Если вы раскомментируете последнюю строку кода, то сможете это увидеть.
- Функции max(tuple) и min(tuple) возвращают максимальное и минимальное значения в кортеже соответственно. Если кортеж состоит только из строк, то функция min(tuple) вернет строку, которая будет первой в алфавитном порядке, а функция max(tuple) - ту, которая будет последней. И последнее, если кортеж состоит как из чисел, так и из строк, то обе функции выдадут ошибку.
my_tuple = (1, 2, 3, 4, 5)
print(max(my_tuple)) # outputs 5
print(min(my_tuple)) # outputs 1
alphabetical_tuple = ("apple", "banana", "giraffe", "fox", "eel")
print(max(alphabetical_tuple)) # outputs giraffe
print(min(alphabetical_tuple)) # outputs apple
alphanumeric_tuple = (1, "apple", 2, "dog")
#print(max(alphanumeric_tuple)) # error
#print(min(alphanumeric_tuple)) # errorПолучение максимального и минимального значения в кортеже
- sorted(tuple): возвращает новый отсортированный список из элементов кортежа.
my_tuple = (3, 1, 4, 1, 5, 9, 2)
sorted_tuple = sorted(my_tuple)
print(sorted_tuple) # outputs [1, 1, 2, 3, 4, 5, 9]Сортировка элементов в кортеже
- any(tuple): если хотя бы один элемент в кортеже истинен, возвращает True, в противном случае - False.
Примечание: многие значения в Python могут расцениваться как True или False.
- True и False – это логические литералы, которые определяют истину и ложь соответственно.
- Целые числа 0 и 1 расцениваются как False и True соответственно.
- Пустая срока "" расценивается как False, а любая непустая строка – как True.
- Пустой кортеж () или список [] расценивается как False, а любой непустой кортеж или список – как True.
- None расценивается как False.
Получается, что для такого кортежа, как (0, False, "", None), функция any() вернет False, так как все элементы кортежа расцениваются как False. Однако для такого кортежа, как (1, True, "hello"), функция any() вернет True, так как хотя бы один элемент кортежа имеет значение True.
my_tuple1 = (False, 0, None, '', ())
my_tuple2 = (False, 0, None, '', (), True)
print(any(my_tuple1)) # outputs False
print(any(my_tuple2)) # outputs TrueПрименение функции any()
- all(tuple): если все элементы кортежа истины, возвращает True, в противном случае - False. Обратите внимание, что пустая строка считается ложным значением (False).
my_tuple1 = (True, 1, 'hello', [1, 2, 3])
my_tuple2 = (True, 1, '', [1, 2, 3])
print(all(my_tuple1)) # outputs True
print(all(my_tuple2)) # outputs FalseПрименение функции all()
- Сложение кортежей применяется для объединения двух и более кортежей в один.
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
tuple3 = tuple1 + tuple2
print(tuple3) #outputs (1, 2, 3, 4, 5, 6)Сложение двух кортежей
- Умножение кортежа на число применяется для создания нового кортежа, который будет состоять из элементов уже существующего кортежа, повторенных определенное количество раз.
my_tuple = ("apple", "banana")
new_tuple = my_tuple * 3
print(new_tuple) # outputs ('apple', 'banana', 'apple', 'banana', 'apple', 'banana')Умножение кортежа на целое число
В примере выше мы определили кортеж my_tuple, который содержит два строковых значения. После чего мы используем оператор * для того, чтобы создать новый кортеж new_tuple путем трехкратного повторения элементов кортежа my_tuple.
Обратите внимание, что tuple1 + tuple2 и tuple1 * n в приведенных выше примерах – это обычные выражения, которые объединяют или делают срезы кортежей и не требуют использования каких-то дополнительных функций или методов.
Упаковка и распаковка кортежей
Упаковка подразумевает объединение последовательности значений в один кортеж. Для того, чтобы это сделать, необходимо записать значения через запятую в круглых скобках.
my_tuple = (1, 2, 'three')Упаковка кортежа
В данном случае значения 1, 2 и 'three' были объединены в кортеж, который, в свою очередь, был присвоен переменной my_tuple.
Что же касается распаковки, то она подразумевает извлечение значений из кортежа и присваивание их отдельным переменным. Это можно выполнить, указав в левой части оператора присваивания несколько имен переменных через запятую и присвоив им кортеж. В предыдущем примере мы присваивали некоторые значения переменной my_tuple. В данном примере кортеж my_tuple распаковывается, и эти значения присваиваются переменным a, b и c соответственно.
a, b, c = my_tuple
print(a) #outputs 1
print(b) #outputs 2
print(c) #outputs 'three'Распаковка кортежа
Что произойдет, если мы в приведенном выше коде для распаковки значений кортежа my_tuple будем использовать только переменные a и b? Напомню, что кортеж my_tuple содержит три элемента. Если вы так сделаете, то получите сообщение об ошибке ValueError: too many values to unpack (expected 2). Вы можете попробовать это сами, подкорректировав приведенный выше код. Также можете посмотреть, что будет, если вы будете использовать четыре переменные - a, b, c и d.
Упаковка и распаковка
Вложенные кортежи
Вложенные кортежи – это кортежи, которые в качестве элементов содержат другие кортежи.
Для того, чтобы создать вложенный кортеж, нужно просто добавить один или несколько кортежей через запятую в другой кортеж:
my_tuple = ((1, 2), (3, 4), (5, 6))Вложенный кортеж
my_tuple в примере выше – это вложенный кортеж, который в качестве элементов содержит три кортежа, каждый из которых, в свою очередь, содержит по два целых числа.
Для того, чтобы обратиться к элементам вложенного кортежа, используется либо обычное индексирование, либо вложенное.
print(my_tuple[0]) # outputs (1, 2)
print(my_tuple[1][0]) # outputs 3
print(my_tuple[2][1]) # outputs 6Обращение к элементам во вложенном кортеже
Первый оператор print печатает первый элемент кортежа my_tuple, то есть кортеж (1, 2). Во втором операторе используется вложенная индексация, с помощью которой мы обращаемся к первому элементу второго кортежа, то есть 3. В третьем операторе также используется вложенная индексация, но здесь мы обращаемся ко второму элементу третьего кортежа, то есть 6.
Кортежи как ключи в словаре
Помимо всего прочего, кортежи можно использовать в качестве ключей в словаре. Так как кортежи не могут быть изменены после того, как будут созданы, их можно смело использовать в качестве надежного и неизменяемого ключа в словаре.
Ниже приведен пример создания словаря с кортежами в качестве ключей:
my_dict = {('apple', 1): 'red', ('banana', 2): 'yellow', ('orange', 3): 'orange'}Ключ в данном случае – это кортеж, который содержит некоторый фрукт и число. А значения – это строки, которые определяют цвета фруктов.
Обратиться к значениям словаря можно с помощью кортежей, которые выступают в роли ключей:
print(my_dict[('apple', 1)]) # outputs 'red'
print(my_dict[('banana', 2)]) # outputs 'yellow'
print(my_dict[('orange', 3)]) # outputs 'orange'Использование кортежей в качестве ключей в словаре
Преимущества кортежей
Кортежи имеют ряд преимуществ в сравнении с другими типами данных, например,
- Неизменяемость. Кортежи неизменяемы, то есть вы не можете изменить их содержимое после того, как создадите. За счет этой особенности кортежи считаются более безопасным типом данных, который не подвержен частым ошибкам в отличие от изменяемых типов данных, таких как списки. Последние могут быть непреднамеренно изменены в других частях программы.
Кортежи неизменяемы
- Упорядоченность. Кортежи – это упорядоченные наборы элементов, которые могут оказаться очень полезными, если вам нужно хранить связанные фрагменты данных, обращаться к которым нужно в определенном порядке.
- Лучшая производительность. Кортежи работают куда быстрее, чем списки, так как требуют меньшего объема памяти и могут быть оптимизированы интерпретатором Python.
- Подходят в качестве ключей. Кортежи можно использовать в качестве ключей в словарях, а вот списки – нельзя. А значит, если вы хотите создать словарь, который бы сопоставлял связанные фрагменты данных друг с другом, то в качестве ключей словаря вы можете использовать кортежи.
- Результаты работы функции. Зачастую кортежи используют для того, чтобы функция могла возвращать несколько значений, так как они могут содержать любое количество элементов и легко подлежат распаковке. Ниже приведен пример, в котором функция возвращает несколько значений, упакованных в кортеж return_tuple.
def calculate_statistics(numbers):
n = len(numbers)
total = sum(numbers)
mean = total / n
variance = sum((x - mean) ** 2 for x in numbers) / n
stdev = variance ** 0.5
return_tuple = (total, mean, stdev)
return return_tuple
my_numbers = [1, 2, 3, 4, 5]
total, mean, stdev = calculate_statistics(my_numbers)
print("Total:", total)
print("Mean:", mean)
print("Standard deviation:", stdev)Недостатки кортежей
Несмотря на то, что у кортежей есть несколько преимуществ (по сравнению с другими типами данных в Python), у них также есть и недостатки. Вот некоторые из них:
- Неизменяемость. Неизменяемость может быть как преимуществом, так и недостатком. Так как кортежи неизменяемы, то для того, чтобы внести в него некоторые изменения, приходится создавать новый кортеж. И если вы будете создавать много кортежей, это может оказаться довольно затратным по времени и привести к увеличению количества используемой памяти.
- Ограниченная функциональность. Если сравнивать кортежи с другими типами данных, например, списками, то они имеют ограниченную функциональность. Например, у кортежей нет таких методов, как append(), insert() или remove(), которые есть у списков.
- Не подходят для больших наборов данных. Кортежи не подходят для больших наборов данных, так как они хранятся в памяти и, если они будут содержать слишком большое количество элементов, то будут занимать много места. В ситуациях с большими наборами данных, больше подойдут такие типы данных, как массивы или генераторы.
Не подходят для больших наборов данных
- Неудобны для чтения. В некоторых ситуациях кортежи читать труднее, чем другие типы данных, например, списки (особенно если в кортеже содержится много элементов). Это объясняется тем, что кортежи, как правило, записываются в круглых скобках и через запятые, что может зрительно сбивать с толку некоторых программистов.
Заключение и основные моменты
Кортежи – это основной тип данных Python, с помощью которого можно хранить наборы значений и управлять ими. В этой статье мы рассмотрели основные принципы создания обычных и вложенных кортежей, обращения к ним, упаковки и распаковки кортежей, а также использования кортежей в качестве ключей в словарях.
Вот некоторые ключевые моменты, о которых не стоит забывать:
- Кортежи неизменяемы.
- Доступ к отдельным элементам кортежа можно получить с помощью индексов (как и в случае со списками).
- Кортежи можно использовать в качестве ключей в словарях, что делает их отличным инструментом для управления данными.
- Упаковка кортежей позволяет объединять несколько значений в один кортеж.
- Распаковка кортежей позволяет присваивать элементы кортежа нескольким переменным за раз.
- Вложенные кортежи могу использоваться для представления более сложных структур данных.
