Что такое кортежи и как с ними работать в языке Python
Автор Сергей Ушаков
В прошлый раз мы говорили про методы работы со строками в языке Python. Сегодня поговорим про кортежи Python. Читайте далее про особенности создания, использования и работы с кортежами в популярном языке программирования Python.
Для чего нужны кортежи в Python
Кортеж в Python — это более быстрый и неизменяемый аналог списка. Он очень часто используется для защиты хранимых данных приложения от незапланированных или непреднамеренных изменений. Кортеж также требует выделения значительно меньшего количества памяти. Кортеж представляет собой последовательность элементов (как список), которая не позволяет удалять, добавлять или изменять свое содержимое. Таким образом, каждый кортеж создается только один раз и существует в первоначальном виде на протяжении всего цикла работы приложения.
Как работают кортежи в Python: несколько практических примеров
Существует 2 способа создания кортежа: с помощью встроенной функции tuple() и с помощью круглых скобок [1]:
a = tuple() type(a) #tuple a = () type(a) #tuple
Для наглядности создадим кортеж из одного элемента.
Стоит также отметить, что в кортежах между элементами ВСЕГДА ставится запятая (даже если кортеж состоит из одного элемента) [1]:
t = ('s')
type(t)
# Внимание: str!!!
t = ('s',)
type(t)Вышеприведенная функция tuple() часто используется для создания кортежей из различных других структур данных (например, списков):
data = ["Иван", 37, "Яндекс"]
t = tuple(data)
print(t)
#('Иван', 37, 'Яндекс')Для того, чтобы вывести отдельный элемент кортежа, достаточно указать его индекс [1]:
print(t[0]) print(t[1]) print(t[2]) # Иван #37 #Яндекс
Но так как кортеж является неизменяемой (immutable) структурой, у нас не получится изменить его содержимое. Следовательно, следующая попытка исполнения кода выдаст ошибку [1]:
t[0] = "Андрей"
Ошибка при попытке изменить содержимое кортежа
Однако, при необходимости, мы можем разложить кортеж на отдельные переменные для дальнейшей работы с ними [1]:
data = ["Иван", 37, "Яндекс"] name, age, company = tuple(data) print(name) # Иван print(age) #37 print(company) # Яндекс
Таким образом, благодаря поддержке кортежей, Python обеспечивает разработчика гарантией защиты данных от непреднамеренных изменений в приложении, что повышает его отказоустойчивость.
Это делает Python универсальным и надежным средством для работы с производительными приложениями, а также с Big Data обработкой.
Computer vision на Python
Освоить Python на профессиональном уровне в разработчика различных приложений и прочих прикладных областях Data Science вы сможете на практических курсах по Python в нашем лицензированном учебном центре обучения и повышения квалификации ИТ-специалистов в Москве:
- DPREP: Подготовка данных для Data Mining на Python
- Разработка и внедрение ML-решений
- Графовые алгоритмы. Бизнес-приложения
- Нейронные сети на Python
- NLP с Python
Записаться на курс
Смотреть раcписание
Источники
- https://metanit.com/python/tutorial/3.2.php
Списки и кортежи в Python для начинающих
Списки и кортежи в Python для начинающих
Предположим, что вы составляете список гостей на свадьбу. Этот список постоянно меняется: добавились друзья семьи Дима и Света, не смогут прийти троюродные сестры со стороны жены Лида с Наташей.
Для представления таких данных из реального мира в Python отлично подходят списки. Списки — это еще один встроенный тип данных Python.
Создать, или другими словами, объявить список в Python можно двумя способами, так:
my_list = list()
или так:
my_list = []
Вернемся, однако, к гостям на свадьбе. Для создания списка гостей, сразу же при создании помещаем внутрь скобок строки с именами через запятую.
guests = ['Родители', 'Одноклассники', 'Лида и Наташа'] print(guests)
Операции с элементами списка
В нашем списке три элемента: «Родители», «Одноклассники», «Лида и Наташа», — которые хранятся внутри списка именно в таком порядке. Если только вы не измените порядок списка, «Родители» всегда будет первым элементом, «Одноклассники» — вторым и «Лида и Наташа» — третьим. Родители представляет собой начало списка, а Лида и Наташа — конец. Мы помним, что Лида и Наташа не смогут прийти, и их нужно удалить из списка.
С помощью метода remove можно удалить последний элемент в списке.
guests = ['Родители', 'Одноклассники', 'Лида и Наташа']
print(guests) # ['Родители', 'Одноклассники', 'Лида и Наташа']
guests.remove("Лида и Наташа")
print(guests) # ['Родители', 'Одноклассники', 'Лида и Наташа']
Но не забываем, нужно еще добавить в список двух гостей. Добавление новых элементов в конец списка происходит при помощи метода append.
guests = ['Родители', 'Одноклассники', 'Лида и Наташа']
print(guests) # ['Родители', 'Одноклассники', 'Лида и Наташа']
guests.remove("Лида и Наташа")
print(guests) # ['Родители', 'Одноклассники']
guests.append('Дима')
guests.append('Света')
print(guests) # ['Родители', 'Одноклассники', 'Дима', 'Света']
В список можно не только добавить элемент, но и изменить одно из его значений на другое, согласно индексу элемента.
guests = ['Родители', 'Одноклассники', 'Дима', 'Света'] print(guests) # ['Родители', 'Одноклассники', 'Лида и Наташа'] guests[2] = 'Коллеги' print(guests) # ['Родители', 'Одноклассники', 'Коллеги', 'Света']
И так, список — это контейнер, хранящий объекты в определенном порядке.
Обратите внимание, что в отличие
от строк, методы списка меняют исходный список. Есть однако у списков кое‑что общее со строками. Это доступ к элементу
по индексу и срезы. Все это работает в списках точно так же, как и в строках.
guests = ['Родители', 'Одноклассники', 'Дима', 'Света'] print(guests[0]) # Родители print(guests[-1]) # Света print(guests[:2]) # ['Родители', 'Одноклассники']
Кортежи
Кортежи — это контейнеры, хранящие объекты в определенном порядке. В отличие от списков, кортежи неизменяемы.
Как только вы создали кортеж, значение какого‑либо его элемента уже нельзя изменить, как нельзя добавлять и удалять элементы. Кортежи объявляются с помощью круглых скобок. Элементы в кортеже должны быть разделены запятыми.
Для создания кортежей также используют один из двух вариантов синтаксиса. Первый:
my_tuple = tuple()
И второй:
my_tuple = ()
Чтобы добавить в кортеж новые объекты, создайте его вторым способом,
указав через запятую каждый желаемый элемент.
data = ('И. Иванов', 1958, True)
print(data) # ('И. Иванов', 1958, True)
Даже если кортеж содержит только один элемент, после этого элемента все равно нужно поставить запятую. Таким образом Python отличает кортеж от числа в скобках, определяющих порядок выполнения операций.
Получить элементы кортежа можно так же, как и элементы списка, указывая индекс элемента.
books = ("1984", "О дивный новый мир", "451 градус по Фаренгейту")
print(books[2]) # 451 градус по Фаренгейту
Ключевое слово in / not in
Проверить, содержится ли элемент в кортеже, можно с помощью ключевого слова in.
books = ("1984", "О дивный новый мир", "451 градус по Фаренгейту")
print("1984" in books) # True
print("Незнайка на луне" in books) # False
Поместите перед in ключевое слово not для проверки отсутствия элемента в кортеже.
books = ("1984", "О дивный новый мир", "451 градус по Фаренгейту")
print("Незнайка на луне" not in books) # True
Те же операции с ключевыми словами in и not in сработают и со списками.
Сложение кортежей и списков
При помощи оператора сложения можно соединять друг с другом две одинаковые структуры данных. Пример ниже со списками также будет работать и с кортежами:
colors1 = ["синий", "зеленый", "желтый"] colors2 = ["оранжевый", "розовый", "черный"] print(colors1 + colors2) # ['синий', 'зеленый', 'желтый', 'оранжевый', 'розовый', 'черный']
На данном этапе вам может стать интересно, зачем использовать структуры данных, которые кажутся менее гибкими, чем списки? На самом же деле, кортежи удобны, когда вы имеете дело со значениями, которые никогда не изменятся. Примером таких данных для кортежа могут быть географические координаты. Долготу и широту города следует сохранить в кортеже, поскольку эти значения никогда не изменятся, а сохранение в кортеже будет гарантировать, что другие части программы случайно их не изменят.
Итерирование
Строки, списки и кортежи поддерживают итерирование (программа может их перебирать, значение за значением), то есть к каждому их элементу можно получить доступ через цикл — такие объекты называются итерируемыми.
Каждый элемент в итерируемом объекте, как мы уже знаем, имеет свой порядковый индекс.
В следующем примере элемент Москва записан в списке с индексом 0, Хельсинки с индексом 1, а ‘Анкара’ с индексом 2.
cities = ['Москва', 'Хельсинки' ,'Анкара']
for city in cities:
print(city)
# Москва
# Хельсинки
# Анкара
Вот мы и познакомились с оператором for — циклом, перебирающим итерируемый объект. Цикл for можно использовать, чтобы определять инструкции, которые будут выполняться один раз для каждого элемента в итерируемом объекте, и с помощью таких инструкций вы можете получать доступ ко всем этим элементам и осуществлять операции с ними.
Например, с помощью цикла for, выполняющего перебор списка строк, и метода upper() можно сделать символы каждой строки прописными:
cities = ['Москва', 'Хельсинки' ,'Анкара']
for city in cities:
print(city.upper())
# МОСКВА
# ХЕЛЬСИНКИ
# АНКАРА
Как показано в примерах выше, цикл for определяется синтаксисом: for имя_переменной in имя_итерируемого_объекта: где *имя_переменной – выбранное вами имя переменной, в которую каждую итерацию
цикла будет записываться очередное значение из итерируемого объекта.
дальше
Пошаговое руководство в 2022 г. (с 14 примерами кода)
28 марта 2022 г.
При работе с коллекциями данных мы иногда сталкиваемся с ситуациями, когда мы хотим убедиться, что невозможно изменить последовательность объектов после создания.
Например, при чтении данных из базы данных в Python мы можем представить каждую запись таблицы как упорядоченную и неизменяемую последовательность объектов, поскольку нам не нужно позже изменять эту последовательность. В Python есть встроенный тип данных sequence для хранения данных в неизменном объекте, который называется 9.0007 кортеж
После того, как вы закончите это руководство по Python, вы будете знать следующее:
- Как работать с кортежами в Python
- Разница между кортежами и списками в Python
- Основные способы использования кортежей
В этом руководстве мы предполагаем, что вы знакомы с основами Python, включая переменные, типы данных и базовые структуры.
Если вы не знакомы с ними или хотели бы ознакомиться с ними, вы можете попробовать наши основы Python для анализа данных — Dataquest.
Давайте погрузимся.
Что такое кортеж Python?
Кортеж представляет собой последовательность любых объектов, разделенных запятыми и заключенных в круглые скобки. Кортеж — это неизменяемый объект , что означает, что его нельзя изменить, и мы используем его для представления фиксированных коллекций элементов.
Давайте посмотрим на несколько примеров кортежей Python:
-
()— пустой кортеж -
(1.0, 9.9, 10)— кортеж, содержащий три числовых объекта -
(«Кейси», «Дарин», «Белла», «Мехди»)— кортеж, содержащий четыре строковых объекта -
('10', 101, True)— кортеж, содержащий строку, целое число и логический объект
Кроме того, другие объекты, такие как списки и кортежи, могут содержать кортеж, например:
a_tuple = (0, [1, 2, 3], (4, 5, 6), 7,0)
Приведенный выше код создает кортеж, содержащий целое число, список, кортеж и число с плавающей запятой.
Следующий код возвращает весь кортеж и его тип данных.
печать (a_tuple) печать (тип (a_tuple))
(0, [1, 2, 3], (4, 5, 6), 7,0)
Однако ('A') не является кортежем. Давайте посмотрим на его тип данных:
печать (тип (('A'))) Итак, как мы можем объявить кортеж с одним значением? Ответ прост. Нам нужно добавить дополнительную запятую непосредственно перед закрывающей скобкой, например:
('A',)
Конечная запятая означает, что скобки содержат кортеж с одним значением, а не для увеличения приоритета математической операции. .
Индексирование и нарезка кортежа
Как упоминалось ранее, поскольку кортеж представляет собой последовательность объектов, мы можем получить доступ к этим объектам посредством индексации. Как и в случае со строками, индекс первого элемента равен 0, второго элемента — 1 и так далее. Попробуем проиндексировать кортеж:
print('Первый элемент:', a_tuple[0])
print('Последний элемент:', a_tuple[-1])
print('Тип данных второго элемента:', type(a_tuple[1])) Первый элемент: 0 Последний элемент: 7.0 Тип данных второго элемента:
0
Тип данных второго элемента: В приведенном выше коде первая и вторая инструкции возвращают значения первого и последнего элементов кортежа. Последний оператор выводит тип данных второго элемента кортежа, который является объектом списка.
Кроме того, следующий фрагмент кода показывает, как получить второй элемент внутреннего кортежа по индексу 2.
печать (a_tuple [2] [1])
5
Это означает, что мы можем получить доступ к элементу, хранящемуся во внутреннем кортеже (кортеже, хранящемуся внутри другого кортежа), выполнив ряд операций индексирования.
Разрезать кортеж так же просто, как разрезать строку Python или список по тем же правилам. Чтобы получить диапазон элементов в кортеже, мы можем указать диапазон индексов для извлечения, выбрав, где начинать (включительно) и заканчивать (исключительно) диапазон.
Давайте рассмотрим несколько примеров:
num_tuple = 2, 4, 5, 7, 8, 10 печать (num_tuple [: 3]) печать (num_tuple [4:]) печать (num_tuple [-3:]) печать (num_tuple [2: 5])
(2, 4, 5) (8, 10) (7, 8, 10) (5, 7, 8)
Первая строка кода объявляет кортеж целочисленных значений.
Хотя это необычно, это еще один способ объявить кортеж, предоставив последовательность объектов, разделенных запятыми, не заключая их в круглые скобки. Последующие операторы выводят разные фрагменты кортежа, как показано.
ПРИМЕЧАНИЕ
Если вы не знакомы с индексированием и нарезкой объекта последовательности в Python или хотели бы ознакомиться с ним, в блоге Dataquest есть хороший учебник по адресу Tutorial: Demystifying Python Lists.
Чтобы объединить два или более кортежей, мы можем использовать знак + , как и в случае со строками. Например, следующий код объединяет два кортежа:
кортеж_1 = (1, 2) кортеж_2 = (3, 4) печать (кортеж_1 + кортеж_2)
(1, 2, 3, 4)
Более того, умножение кортежа на целое число дает кортеж, содержащий исходный кортеж, повторяющийся столько раз. Попробуем:
my_tuple = (1, 7, 9, 8) печать (my_tuple * 2)
(1, 7, 9, 8, 1, 7, 9, 8)
Сжатие кортежей
Метод zip() принимает несколько объектов последовательности и возвращает итерируемый объект, сопоставляя их элементы.
Чтобы узнать больше о сжатии кортежей, рассмотрим следующий пример.
Предположим, у нас есть три разных кортежа, содержащие личные данные четырех клиентов. Мы хотим создать один кортеж, содержащий соответствующие данные для каждого клиента, включая их имя, фамилию и возраст, в виде отдельных кортежей:
first_names = ('Саймон', 'Сара', 'Мехди', 'Фатиме')
last_names = ('Синек', 'Смит', 'Лотфинеджад', 'Лопес')
возраст = (49, 55, 39, 33)
zip = zip (имя, фамилия, возраст)
печать (в архиве) Мы объявляем кортежи first_name , last_name и ages в приведенном выше коде. Метод zip() принимает три кортежа и возвращает объект zip, который является итератором. Чтобы использовать объект итератора, нам нужно преобразовать его либо в список, либо в кортеж, например:
клиентов = кортеж (сжатый) печать (клиенты)
(('Саймон', 'Синек', 49), ('Сара', 'Смит', 55), ('Мехди', 'Лотфинежад', 39), ('Фатиме', 'Лопес', 33)) Кортеж клиентов состоит из четырех объектов кортежа, каждый из которых принадлежит клиенту.
Распаковка кортежей
Распаковка кортежа позволяет нам извлечь элементы кортежа и присвоить их именованным переменным. Попробуем:
имя, фамилия, возраст = клиенты[2] print(first_name, last_name, ',', age, 'лет')
Мехди Лотфинеджад, 39 лет
Приведенный выше код извлекает элементы кортежа, хранящиеся в индексе 2 кортежа клиентов , и присваивает их переменным first_name , last_name и age .
Разница между кортежами и списками в Python
Помимо интуитивно понятной разницы между кортежами и списками, как упоминалось ранее, кортежи неизменяемы, поэтому, в отличие от списков, кортежи не могут быть изменены. Однако некоторые технические отличия делают кортежи неоспоримым преимуществом в программировании на Python.
Первое отличие, которое делает списки более предпочтительными итерируемыми объектами, чем кортежи, заключается в том, что объект-список предоставляет больше методов.
Но дополнительная функциональность имеет свою цену. Давайте сначала посмотрим на размер занимаемой памяти каждого объекта в приведенном ниже коде, а затем обсудим, почему кортежи являются лучшим выбором в некоторых ситуациях.
система импорта
a_list = ['abc', 'xyz', 123, 231, 13.31, 0.1312]
a_tuple = ('abc', 'xyz', 123, 231, 13.31, 0.1312)
print('Размер списка:', sys.getsizeof(a_list), 'байт')
print('Размер кортежа:', sys.getsizeof(a_tuple), 'bytes') Размер списка: 104 байта Размер кортежа: 88 байт
Мы видим, что объект списка занимает больше памяти, чем объект кортежа. Значение занимаемого меньшего объема памяти становится более очевидным, когда мы работаем с большими данными, а это означает, что неизменность обеспечивает значительную оптимизацию при работе с большим объемом данных.
Помимо того, что они занимают меньше памяти, обработка объектов-кортежей происходит намного быстрее, чем списков, особенно при работе с миллионами и миллионами объектов-последовательностей.
Использование кортежей Python
В этом разделе мы обсудим два интересных способа использования кортежей на практике. Давайте изучим их.
Замена элементов кортежа
Мы можем использовать кортежи для замены значений, связанных с переменными, только если переменные являются элементами кортежа. Давайте попробуем:
х = 19
у = 91
print('Перед заменой:')
печать (f'x = {x}, y = {y}')
(х, у) = (у, х)
print('После замены:')
печать (f'x = {x}, y = {y}') Перед заменой: х = 19, у = 91 После замены: х = 91, у = 19
Значение y присваивается переменной x , а значение x одновременно присваивается переменной y . Это более питонический способ замены значений.
Возврат более одного значения из функции
Функции могут возвращать только одно значение. Однако мы можем использовать кортеж и поместить в него столько значений, сколько нам нужно, а затем вернуть объект кортежа в качестве возвращаемого значения функции.
Давайте посмотрим, как мы можем использовать кортеж для возврата нескольких значений из функции в следующем коде:
по определению sum_and_avg(x, y, z):
с = х + у + г
а = с/3
возврат (ы, а)
(S, A) = сумма_и_среднее(3,8,5)
печать('Сумма =', С)
печать('Среднее =', А) Сумма = 16 Среднее = 5,3333333333333333
Функция sum_and_avg() вычисляет сумму и среднее значение трех числовых значений. Функция возвращает s и a , которые являются двумя вычисляемыми значениями в контексте объекта кортежа. На самом деле функция возвращает только одно значение, которое представляет собой объект кортежа, содержащий несколько значений. Мы также использовали метод распаковки кортежа, чтобы извлечь значения из возвращенного объекта кортежа, а затем распечатать их.
Заключение
В этом руководстве рассказывается, как создавать объекты кортежей, а также многие аспекты кортежей Python, такие как индексация, нарезка, сжатие, распаковка и т.
д. Мы также обсудили разницу между кортежами и списками. Правильное использование кортежей Python определенно сделает наш код более эффективным и надежным.
pythontuples
Об авторе
Dataquest
Dataquest учит с помощью сложных упражнений и проектов вместо видеолекций. Это самый эффективный способ приобрести навыки, необходимые для построения карьеры в сфере данных.
Как создавать и использовать кортежи в Python
Кортеж — это набор неизменяемых объектов Python. Он может содержать элементы любого произвольного типа данных (целое число, строка, число с плавающей запятой, список и т. д.), что делает его гибкой и мощной структурой данных. Он является частью основного языка Python и широко используется в программах и проектах Python.
Создание кортежа
Кортеж в Python можно создать, заключив все элементы, разделенные запятыми, в круглые скобки () .
t1 = (1, 2, 3, 4)
t2 = ("Создать", "Использовать", "Из")
t3 = (1.
2, 5.9, 5.4, 9.3) Элементы кортежа неизменяемы и упорядочены . Он допускает дублирование значений и может иметь любое количество элементов. Вы даже можете создать пустой кортеж. Элементы кортежа могут иметь любой тип данных (целое число, число с плавающей запятой, строки, кортеж и т. д.).
Создание пустого кортежа
Пустой кортеж можно создать, используя пустые открывающие и закрывающие скобки.
пустойКортеж = ()
Создание кортежа с одним элементом
Чтобы создать кортеж только из 1 элемента, вам нужно добавить запятую после элемента, чтобы Python распознал его как кортеж.
# t1 является кортежем
t1 = ( 3.14, )
print( type(t1))
# выводит
# t2 не является кортежем
t2 = ( 3.14 )
print( type (t2) )
# печатает
Примечание: type() Функция возвращает тип класса объекта, переданного в качестве параметра.
Отсутствие запятой после элемента приводит к типу класса t2 как «плавающему», поэтому обязательно использовать запятую после элемента при создании кортежа с одним значением.
Создание кортежа с различными типами данных
Элементы кортежа могут относиться к любому типу данных. Эта особенность делает кортеж универсальным.
tup1 = ('MUO', True, 3.9, 56, [1, 2, 3])
print( tup1)
# печатает
('MUO', True, 3.9, 56, [1, 2, 3] ) Создание кортежа с помощью конструктора tuple()
Кортежи также можно создавать с помощью конструктора tuple() . Используя конструктор tuple(), вы можете преобразовать последовательности, такие как список/словарь, в кортеж.
tup1 = tuple( (1, 2, 3) )
print( tup1 )
# печатает
(1, 2, 3)
Создание вложенного кортежа
Кортежи можно легко вкладывать внутрь других кортежей. Вы можете вложить кортеж на любой желаемый уровень.
tup1 = (1, 2, 3)
tup2 = ('Привет', tup1, 45)
print(tup2)
# печатает
('Hello', (1, 2, 3), 45)
Доступ к элементам кортежа
Вы можете получить доступ к элементам кортежа, используя порядковый номер в квадратных скобках.
Номер индекса начинается с 0. Кортеж также поддерживает отрицательное индексирование:
- -1: указывает на последний элемент
- -2: указывает на предпоследний элемент и т. д.
tup1 = ('M', 'A' , 'K', 'E', 'U', 'S', 'E', 'O', 'F')
print(tup1[0])
print(tup1[5])
print(tup1[ -1] )
print( tup1[-9] )
# выводит
M
S
F
M Разрезание кортежа
Вы можете получить доступ к ряду элементов в кортеже, используя оператор двоеточия : . Tuple также поддерживает операцию нарезки с использованием отрицательных индексов.
tup1 = ('M', 'A', 'K', 'E', 'U', 'S', 'E', 'O', 'F') # Печатает элементы из индекса 1 (включены ) до индекса 6 (исключено)
print( tup1[1:6] )
# Печатает элементы от начала до индекса 8 (исключено)
print( tup1[:8] )
# Печатает элементы от индекса 3 (включено) до конца
print( tup1[3:] )
# Печатает элементы от индекса -4 (включено) до индекса -1 (исключено)
print( tup1[-4: -1] )
# печатает
('A', 'K', 'E', 'U', 'S')
('M', 'A', 'K', 'E', 'U ', 'S', 'E', 'O')
('E', 'U', 'S', 'E', 'O', 'F')
('S', 'E', 'O')
Проверка существования элемента в кортеже
Вы можете проверить, существует ли элемент в кортеже, используя ключевое слово в .
tup1 = ('M', 'A', 'K', 'E', 'U', 'S', 'E', 'O', 'F')
, если 'M' в tup1:
print("Да, элемент M существует в кортеже")
else:
print("Элемент не найден в кортеже !!") # печатает
Да, элемент M существует в кортеже
Обновление кортежей
Поскольку кортежи неизменяемы, изменить их значение невозможно. Python выдает ошибку TypeError, если вы попытаетесь обновить кортеж.
tup1 = ('M', 'A', 'K', 'E', 'U', 'S', 'E', 'O', 'F')
tup1[0] = 'Z' # Выдается следующая ошибка
tup1[0] = 'Z'
TypeError: объект 'tuple' не поддерживает назначение элемента
Но есть хак, если вы хотите обновить свой кортеж.
Изменение значения элементов кортежа с помощью списков
Вы можете изменить значение элементов кортежа с помощью списков в Python. Во-первых, вам нужно преобразовать кортеж в список. Затем измените список по своему усмотрению. Наконец, преобразуйте список обратно в кортеж.
tup1 = ( 1, 2, 3 )
print( "Это старый кортеж: ")
print( tup1 )
temp = list( tup1 )
temp[0] = 4
tup1 = tuple( temp )
print ("Это обновленный кортеж:")
print( tup1 )# печатает
Это старый кортеж:
(1, 2, 3)
Это обновленный кортеж:
(4, 2, 3)
Добавление новых элементов в кортеж с помощью списков
Поскольку кортежи неизменяемы, невозможно добавлять в кортеж новые элементы.
Python выдаст ошибку:
AttributeError: объект 'tuple' не имеет атрибута 'append
Опять же, вы можете использовать наш хак (используя списки), чтобы справиться с этим. Сначала преобразуйте кортеж в список. Затем добавьте в список новые элементы. Наконец, преобразуйте список в кортеж.
Примечание. Метод append() используется в Python для добавления нового элемента в конец списка.
tup1 = ( 1, 2, 3 )
print("Это старый кортеж:")
print(tup1)
temp = list(tup1)
temp.append(4)
tup1 = tuple( temp )
print( "Это обновленный кортеж: ")
print( tup1 )# печатает
Это старый кортеж:
(1, 2, 3)
Это обновленный кортеж:
(1, 2, 3, 4)
Операция удаления над кортежами
Поскольку кортежи неизменяемы, невозможно удалить какой-либо элемент из кортежа. Если вы хотите удалить весь кортеж, это можно сделать с помощью ключевого слова del .
tup1 = ( 1, 2, 3 )
del tup1
Но вы можете использовать тот же прием (используя списки), который вы использовали для изменения и добавления элементов кортежа.
Удаление элементов из кортежа с помощью списков
Элементы могут быть удалены из кортежа с помощью списков в 3 простых шага:
Шаг 1: Преобразуйте кортеж в список.
Шаг 2: Удалите элементы из списка с помощью метода remove()
Шаг 3: Преобразуйте список в кортеж.
tup1 = ( 1, 2, 3 )
print( "Это старый кортеж: ")
print( tup1 )
temp = list( tup1 )
temp.remove(1)
tup1 = tuple( temp )
print("Это обновленный кортеж:")
print( tup1 )# печатает
Это старый кортеж:
(1, 2, 3)
Это обновленный кортеж:
(2, 3)
Упаковка и распаковка кортежей
При создании кортежа присваиваются значения. Это называется Упаковка кортежа .
# Пример упаковки кортежа
tup1 = ( 1, 2, 3)
Тогда как извлечение значений обратно в переменные называется Распаковка кортежа .
# Пример распаковки кортежа
tup1 = ( 1, 2, 3 )
( один, два, три ) = tup1 3
Циклы с помощью кортежей Python
Кортежи — это итерируемые контейнеры, как и списки в Python.