Главная Блог Кортежи Python

Кортежи Python

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

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


my_tuple = (1, 2, 3, ‘строка’, 3.14)


Кортежи могут содержать элементы различных типов данных. Доступ к элементам кортежа осуществляется по индексу, начиная с 0. Например:


print(my_tuple[0])  # Вывод: 1

print(my_tuple[3])  # Вывод: ‘строка’


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


my_dict = {(1, 2): ‘значение’}


Кортежи – эффективный и удобный способ организации и хранения данных в Python.

Когда использовать

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


a = 1

b = 2

a, b = b, a  # Обмен значениями без временной переменной


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

Среднее время реакции на обращение: 13,5 мин.
Среднее время решения задачи: 1 час 21 мин.

Работа с кортежами

Создать кортеж

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

Пустой кортеж


empty_tuple = ()


Кортеж с одним элементом

Если у вас есть кортеж с одним элементом, вам необходимо добавить запятую после:


single_element_tuple = (42,)


Кортеж с несколькими элементами


my_tuple = (1, 2, 3, ‘строка’, 3.14)


Без использования скобок

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


my_tuple = 1, 2, 3


В данном случае my_tuple – также кортеж.

Кроме того, можно использовать встроенную функцию tuple() для создания кортежа из итерируемого объекта, например, списка:


my_list = [4, 5, 6]

converted_tuple = tuple(my_list)


Это преобразует список [4, 5, 6] в кортеж (4, 5, 6).

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

Доступ к элементам

Для этого используется индексация. Индексы начинаются с 0 для первого элемента и увеличиваются на 1 для каждого следующего элемента в кортеже. Они также могут быть отрицательными, начиная с -1 для последнего элемента, -2 – для предпоследнего и так далее.

Например:


my_tuple = (10, 20, 30, ‘строка’, 3.14)


Теперь мы можем обратиться к элементам по индексам:


print(my_tuple[0])      # Вывод: 10

print(my_tuple[3])      # Вывод: ‘строка’

print(my_tuple[-1])     # Вывод: 3.14


Также возможен доступ к подпоследовательностям элементов, используя срезы (slices). Срез возвращает новый кортеж, включающий элементы в указанном диапазоне индексов.


subset = my_tuple[1:4]  # Создает подкортеж с элементами с индексами 1, 2, 3

print(subset)           # Вывод: (20, 30, ‘строка’)


Индексы можно комбинировать со срезами для более сложного доступа к элементам:


combined = my_tuple[0:3] + my_tuple[-2:]  # Сочетание нескольких срезов

print(combined)                           # Вывод: (10, 20, 30, ‘строка’, 3.14)


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

Упаковка и распаковка

В Python существует две важные операции, связанные с кортежами – упаковка и распаковка.

Упаковка означает создание кортежа, помещая несколько значений в один кортеж. Это происходит автоматически при присваивании нескольких значений одной переменной. Например:


packed_tuple = 1, 2, ‘три’


Здесь переменная packed_tuple автоматически становится кортежем с тремя элементами.

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


x, y, z = packed_tuple


Здесь значения из packed_tuple распаковываются и присваиваются переменным x, y, и z. Теперь x равно 1, y равно 2, и z равно «три».

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


a = 5

b = 10

a, b = b, a  # Обмен значениями без временной переменной


Также, если у вас есть кортеж, который содержит больше элементов, чем переменных в левой части оператора присваивания, вы можете использовать звездочку (*) для распаковки «оставшихся» элементов:


first, *rest = (1, 2, 3, 4, 5)

print(first)  # Вывод: 1

print(rest)   # Вывод: [2, 3, 4, 5]


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

Сравнение

Операции сравнения в Python используются для сравнения двух значений и возвращают логическое значение (True или False) в зависимости от результата сравнения. Они могут применяться для сравнения кортежей между собой.

Основные операции сравнения:

  • Равенство (==);

tuple1 = (1, 2, 3)

tuple2 = (1, 2, 3)

 

result = tuple1 == tuple2  # True


  • Неравенство (!=);

tuple1 = (1, 2, 3)

tuple2 = (4, 5, 6)

 

result = tuple1 != tuple2  # True


  • Больше (>), меньше (<), больше или равно (>=), меньше или равно (<=);

tuple1 = (1, 2, 3)

tuple2 = (4, 5, 6)

 

result1 = tuple1 < tuple2   # True (поэлементное сравнение)

result2 = tuple1 >= tuple2  # False


  • Логические операторы (and, or, not);

tuple1 = (1, 2, 3)

tuple2 = (1, 2, 4)

 

result = tuple1 < tuple2 and len(tuple1) == 3  # True


  • Идентичность (is), неидентичность (is not);

tuple1 = (1, 2, 3)

tuple2 = (1, 2, 3)

 

result = tuple1 is tuple2  # False (разные объекты)


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


tuple1 = (1, 2, 3)

tuple2 = (1, 2, 4)

 

result = tuple1 < tuple2  # True, так как 3 < 4


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

Проверка принадлежности элемента

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

Приведем пример использования оператора in:


my_tuple = (1, 2, 3, ‘строка’, 3.14)

 

# Проверка принадлежности элемента к кортежу

result = 3 in my_tuple  # True


Здесь результат будет True, так как число 3 содержится в кортеже my_tuple.

Пример использования оператора not in:


my_tuple = (1, 2, 3, ‘строка’, 3.14)

 

# Проверка отсутствия элемента в кортеже

result = ‘слово’ not in my_tuple  # True


Результат будет True, так как строка «слово» не содержится в кортеже my_tuple.

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


my_tuple = (1, 2, 3, ‘строка’, 3.14)

 

# Фильтрация элементов, которые являются числами

numbers = [x for x in my_tuple if isinstance(x, int)]

# Результат: [1, 2, 3]


В этом примере создается новый список numbers, содержащий только те элементы из my_tuple, которые являются целыми числами.

Перебор элементов

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


my_tuple = (1, 2, 3, ‘строка’, 3.14)

 

# Перебор элементов кортежа

for element in my_tuple:

print(element)


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

Если вам также необходимо знать индексы элементов во время перебора, вы можете использовать функцию enumerate():


my_tuple = (1, 2, 3, ‘строка’, 3.14)

 

# Перебор элементов кортежа с индексами

for index, element in enumerate(my_tuple):

print(f»Индекс: {index}, Значение: {element}»)


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

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


my_tuple = (1, 2, 3, 4, 5)

 

# Вывести только четные числа

for element in my_tuple:

if element % 2 == 0:

print(element)


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

Перебор элементов кортежа с использованием цикла for – это мощный способ обработки данных и выполнения операций для каждого элемента в кортеже.

90% клиентов пришли к нам по рекомендации

Удаление кортежа

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

Однако, если у вас есть ссылка на кортеж, вы можете удалить саму переменную, используя оператор del. Это позволяет удалить ссылку на кортеж. Если другие переменные также ссылаются на этот него, они останутся валидными. Например:


my_tuple = (1, 2, 3, ‘строка’, 3.14)

 

# Удаление переменной, не кортежа

del my_tuple

 

# Попытка обратиться к переменной вызовет ошибку

# print(my_tuple)  # Вызовет NameError: name ‘my_tuple’ is not defined


Также, если кортеж содержится в другом объекте, например, в списке, и вы хотите удалить этот кортеж, вы можете воспользоваться методом списка remove() или использовать срезы:


my_list = [(1, 2), (3, 4), (5, 6)]

 

# Удаление кортежа из списка с использованием метода remove()

my_list.remove((3, 4))

 

# Или удаление кортежа с использованием среза

my_list = [item for item in my_list if item != (3, 4)]


В обоих случаях кортеж (3, 4) будет удален из списка my_list.

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

Конкатенация и повторение

kortezhi-python

В Python операции конкатенации и повторения позволяют объединять и создавать новые кортежи на основе существующих.

Операция конкатенации выполняется с использованием оператора +. Этот оператор объединяет два кортежа, создавая новый кортеж, содержащий все элементы из обоих исходных кортежей.

Например:


tuple1 = (1, 2, 3)

tuple2 = (‘a’, ‘b’, ‘c’)

 

concatenated_tuple = tuple1 + tuple2

print(concatenated_tuple)

# Вывод: (1, 2, 3, ‘a’, ‘b’, ‘c’)


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

К примеру:


tuple1 = (1, 2, 3)

 

repeated_tuple = tuple1 * 3

print(repeated_tuple)

# Вывод: (1, 2, 3, 1, 2, 3, 1, 2, 3)


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

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

Функции

Для определения длины кортежа используется встроенная функция len().


my_tuple = (1, 2, 3, ‘строка’, 3.14)

length = len(my_tuple)

print(length)  # Вывод: 5


Для выполнения операций сумма, минимум и максимум элементов можно использовать встроенные функции sum(), min() и max().


numeric_tuple = (1, 5, 2, 8, 3)

 

total = sum(numeric_tuple)

minimum_value = min(numeric_tuple)

maximum_value = max(numeric_tuple)

 

print(total)          # Вывод: 19

print(minimum_value)  # Вывод: 1

print(maximum_value)  # Вывод: 8


Кортежи неизменяемы, но вы можете создать новый отсортированный кортеж с использованием функции sorted().


unsorted_tuple = (4, 1, 7, 3, 9)

sorted_tuple = tuple(sorted(unsorted_tuple))

 

print(sorted_tuple)  # Вывод: (1, 3, 4, 7, 9)


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


my_tuple = (1, 2, 3, ‘строка’, 3.14)

 

subset = my_tuple[1:4]

print(subset)  # Вывод: (2, 3, ‘строка’)


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


my_tuple = (1, 2, 3)

 

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

list_version = list(my_tuple)

print(list_version)  # Вывод: [1, 2, 3]

 

# Преобразование в строку (если элементы кортежа являются строками)

string_version = str(my_tuple)

print(string_version)  # Вывод: ‘(1, 2, 3)’


Эти функции обеспечивают множество способов работы с кортежами, что делает их удобными и мощными структурами данных в Python.

Изменить элементы

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


my_tuple = (1, 2, 3, ‘строка’, 3.14)

 

# Создание нового кортежа с измененным значением на позиции 2

new_tuple = my_tuple[:2] + (10,) + my_tuple[3:]

 

print(new_tuple)

# Вывод: (1, 2, 10, ‘строка’, 3.14)


Здесь создается новый кортеж new_tuple, включающий элементы из my_tuple, за исключением элемента на позиции 2, который заменяется на новое значение 10.

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


my_tuple = (1, 2, 3, ‘строка’, 3.14)

 

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

tuple_list = list(my_tuple)

 

# Изменение значения в списке

tuple_list[2] = 10

 

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

new_tuple = tuple(tuple_list)

 

print(new_tuple)

# Вывод: (1, 2, 10, ‘строка’, 3.14)


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

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

Подытожим

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

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


my_tuple = tuple([1, 2, 3])

print(type(my_tuple))  # <class ‘tuple’>


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

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


my_tuple[0] = 10  # TypeError: ‘tuple’ object does not support item assignment


Кроме того, кортежи обладают методами, позволяющими выполнять различные операции, такие как подсчет элементов с определенным значением (count()), а также находить индексы элементов в пределах заданного диапазона (range()).


my_tuple = (1, 2, 2, 3, 4, 2)

print(my_tuple.count(2))  # 3

print(my_tuple.index(3, 1, 5))  # 3


Особенно полезным свойством кортежей является их эффективность в использовании памяти. Поскольку они неизменяемы, Python может лучше оптимизировать их хранение в памяти по сравнению со списками.

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


coordinates = (3.14, 2.71)

x, y = coordinates

print(x, y)  # 3.14 2.71


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

Остались вопросы?

Оставьте заявку и наш менеджер свяжется с Вами в течение 15 минут

    Надоели непредвиденные
    расходы на ИТ?

    • Гарантируем фиксированную стоимость обслуживания на 2 года по договору
    • Включаем в тариф неограниченное количество экстренных вызовов
    • Первый месяц обслуживания за наш счет
    Рассчитать стоимость аутсорсинга
    Нажимая кнопку «Отправить», я даю свое согласие на обработку моих персональных данных, в соответствии с Федеральным законом от 27.07.2006 года №152-ФЗ «О персональных данных», на условиях и для целей, определенных в Соглашении на обработку персональных данных