Кортеж в python: Кортежи (tuple) | Python 3 для начинающих и чайников
Кортежи (tuple) | Python 3 для начинающих и чайников
Сегодня я расскажу о таком типе данных, как кортежи (tuple) и о том, где они применяются.
Кортеж, по сути — неизменяемый список.
Зачем нужны кортежи, если есть списки?
- Защита от дурака. То есть кортеж защищен от изменений, как намеренных (что плохо), так и случайных (что хорошо).
- Меньший размер. Дабы не быть голословным:
>>> a = (1, 2, 3, 4, 5, 6) >>> b = [1, 2, 3, 4, 5, 6] >>> a.__sizeof__() 36 >>> b.__sizeof__() 44
- Возможность использовать кортежи в качестве ключей словаря:
>>> d = {(1, 1, 1) : 1}
>>> d
{(1, 1, 1): 1}
>>> d = {[1, 1, 1] : 1}
Traceback (most recent call last):
File "", line 1, in
d = {[1, 1, 1] : 1}
TypeError: unhashable type: 'list'Как работать с кортежами?
С преимуществами кортежей разобрались, теперь встает вопрос — а как с ними работать. Примерно так же, как и со списками.
Создаем пустой кортеж:
>>> a = tuple() # С помощью встроенной функции tuple() >>> a () >>> a = () # С помощью литерала кортежа >>> a () >>>
Создаем кортеж из одного элемента:
>>> a = ('s')
>>> a
's'Стоп. Получилась строка. Но как же так? Мы же кортеж хотели! Как же нам кортеж получить?
>>> a = ('s', )
>>> a
('s',)Ура! Заработало! Все дело — в запятой. Сами по себе скобки ничего не значат, точнее, значат то, что внутри них находится одна инструкция, которая может быть отделена пробелами, переносом строк и прочим мусором. Кстати, кортеж можно создать и так:
>>> a = 's',
>>> a
('s',)Но все же не увлекайтесь, и ставьте скобки, тем более, что бывают случаи, когда скобки необходимы.
Ну и создать кортеж из итерируемого объекта можно с помощью все той же пресловутой функции tuple()
>>> a = tuple('hello, world!')
>>> a
('h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!')Операции с кортежами
Все операции над списками, не изменяющие список (сложение, умножение на число, методы index() и count() и некоторые другие операции). Можно также по-разному менять элементы местами и так далее.
Например, гордость программистов на python — поменять местами значения двух переменных:
a, b = b, a
Кортежи python для начинающих. Функции и основные операции с tuples
По аналогии со списками кортежи в Python — это стандартный тип, позволяющий хранить значения в виде последовательности. Они полезны в тех случаях, когда необходимо передать данные, не позволяя изменять их. Эти данные могут быть использованы, но в оригинальной структуре изменения не отобразятся.
В этом руководстве вы познакомитесь с кортежами Python в подробностях:
- Узнаете, как их создавать. Увидите, что значит неизменяемый тип на примерах
- Разберетесь, чем кортежи в Python отличаются от списков
- Познакомитесь с операциями: срезами, конкатенацией, умножением и так далее
- Увидите встроенные функции
- Научитесь присваивать сразу несколько значений кортежами
Кортеж Python
Эта структура данных используется для хранения последовательности упорядоченных и неизменяемых элементов.
Кортежи создают с помощью круглых скобок (). Для создания нужно написать следующее:
cake = ('c','a','k','e')
print(type(cake))
<class 'tuple'>
Примечание: type() — это встроенная функция для проверки типа данных переданного параметра.
Кортежи могут включать однородные и разнородные значения. Но после объявления их уже нельзя будет поменять:
mixed_type = ('C',0,0,'K','I','E')
for i in mixed_type:
print(i,":",type(i))
C : <class 'str'>
0 : <class 'int'>
0 : <class 'int'>
K : <class 'str'>
I : <class 'str'>
E : <class 'str'>
mixed_type[1] = "O"
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-16-dec28c299a95> in <module>()
----> 1 mixed_type[1] = 'O' # Попробуйте изменить 0 на «O»
TypeError: 'tuple' object does not support item assignment
Последняя ошибка появилась из-за попытки поменять значения внутри кортежа.
Кортежи можно создавать и вот так:
numbers_tuple = 1,2,3,4,5
print(type(numbers_tuple))
<class 'tuple'>
Кортежи против списков
Подписывайтесь на телеграм каналы
Как вы могли заметить, кортежи очень похожи на списки. По сути, они являются неизменяемыми списками. Это значит, что после создания кортежа хранимые в нем значения нельзя удалять или менять. Добавлять новые также нельзя:
numbers_tuple = (1,2,3,4,5)
numbers_list = [1,2,3,4,5]
numbers_tuple.append(6)
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-26-e48876d745ce> in <module>()
3
4 # Добавим число в кортеж
----> 5 numbers_tuple.append(6)
AttributeError: 'tuple' object has no attribute 'append'
Ошибка появляется, потому что нельзя добавлять новые элементы в кортеж, что работает в случае со списками.
numbers_list.append(6)
numbers_list.append(7)
numbers_list.append(8)
numbers_list.remove(7)
print(numbers_list)
[1, 2, 3, 4, 5, 6, 8]
Но зачем использовать этот тип данных, если он неизменяемый?
Кортежи не только предоставляют доступ только для чтения к элементам, но и работают быстрее списков. Рассмотрим в качестве примера следующий код:
>>> import timeit
>>> timeit.timeit('x=(1,2,3,4,5,6,7,8,9)', number=100000)
0.0018976779974764213
>>> timeit.timeit('x=[1,2,3,4,5,6,7,8,9]', number=100000)
0.019868606992531568
Какую роль играет неизменяемость в случае с кортежами?
Согласно официальной документации Python неизменяемый — это «объект с фиксированным значением», но в отношении кортежей «значение» — это чересчур размытый термин. Лучше использовать id. id определяет расположения объекта в памяти.
Рассмотрим подробнее:
n_tuple = (1, 1, [3,4])
id(n_tuple[0]) == id(n_tuple[1])
True
id(n_tuple[0]) == id(n_tuple[2])
False
print(id(n_tuple[0]), id(n_tuple[2]))
4297148528, 4359711048
n_tuple.append(5)
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-40-3cd388e024ff> in <module>()
----> 1 n_tuple.append(5)
AttributeError: 'tuple' object has no attribute 'append'
Добавить элемент в кортеж нельзя, поэтому появляется последняя ошибка AttributeError. Вот почему эта структура данных неизменна. Но всегда можно сделать вот так:
n_tuple[2].append(5)
n_tuple
(1, 1, [3, 4, 5])
Это позволяет изменять оригинальный кортеж? Куда в таком случае делась их неизменяемость?
Суть в том, что id списка в кортеже не меняется несмотря на добавленный в него элемент 5.
id(n_tuple[2])
4359711048
Теперь вы знаете следующее:
Некоторые кортежи (которые содержат только неизменяемые объекты: строки и так далее) — неизменяемые, а другие (содержащие изменяемые типы, например, списки) изменяемые. Но это очень обсуждаемая тема среди программистов на Python и необходимы кое-какие познания, чтобы полностью понять ее. В целом же кортежи неизменяемые.
- Вы не можете добавлять в них новые элементы. У этого типа нет методов
append()илиextend() - Удалять элементы тоже нельзя, также из-за неизменяемости. Методов
remove()иpop()здесь нет - Искать элементы в кортеже можно, потому что этот процесс его не меняет
- Разрешено использовать оператор
inдля проверки наличия элемента в кортеже
Так что если вы планируете использовать постоянный набор значений для перебора, используйте кортеж вместо списка. Он будет работать быстрее. Плюс, это безопаснее, ведь такой тип данных защищен от записи.
Если вы хотите узнать больше о списках Python, обязательно ознакомьтесь с этим руководством!
Стандартные операции с кортежами
Python предоставляет несколько способов для управления кортежами. Рассмотрим их на примерах.
Срезы
Значение индекса первого элемента в кортеже — 0. По аналогии со списками эти значения можно использовать с квадратными скобками [] для получения доступа к кортежам:
numbers = (0,1,2,3,4,5)
numbers[0]
0
Можно использовать и отрицательные значения:
numbers[-1]
5
Индексы позволяют получать отдельные элементы, а с помощью срезов становятся доступны и подмножества. Для этого нужно использовать диапазоны индексов:
[Начальный индекст (включен):Конечный индекс (исключен):Частота]
Частота в данном случае является опциональным параметром, а его значение по умолчанию равно 1.
# Элемент с индексом 4 исключен
numbers[1:4]
(1, 2, 3)
numbers[:]
(0, 1, 2, 3, 4, 5)
# Частота = 2
numbers[::2]
(0, 2, 4)
Совет: значение частоты может быть и негативным, чтобы развернуть кортеж.
numbers[::-1]
(5, 4, 3, 2, 1, 0)
Объединение кортежей
Можно объединять кортежи для создания нового объекта. Операция объединения выполняет конкатенацию двух кортежей.
x = (1,2,3,4)
y = (5,6,7,8)
z = x + y
print(z)
(1, 2, 3, 4, 5, 6, 7, 8)
y = [5,6,7,8]
z = x + y
print(z)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-55-d442c6414a4c> in <module>()
1 y = [5,6,7,8]
----> 2 z = x + y
3 print(z)
TypeError: can only concatenate tuple (not "list") to tuple
Разрешается объединять только определенные типы данных. Так, попытка соединить кортеж и список закончится ошибкой.
Умножение кортежей
Операция умножения приводит к тому, что кортеж повторяется несколько раз.
x = (1,2,3,4)
z = x*2
print(z)
(1, 2, 3, 4, 1, 2, 3, 4)
Функции кортежей
В отличие от списков у кортежей нет методов, таких как append(), remove(), extend(), insert() или pop() опять-таки из-за их неизменяемости. Но есть другие:
count() и len()
count() возвращает количество повторений элемента в кортеже.
a = [1,2,3,4,5,5]
a.count(5)
2
len() — длину кортежа:
a = (1,2,3,4,5)
print(len(a))
5
any()
Функцию any() можно использовать, чтобы определить являются ли элементы кортежа итерируемыми. Если да, то она вернет True.
a = (1,)
print(any(a))
True
Обратите внимание на запятую (,) в объявлении кортежа a. Если ее не указать при создании объекта с одним элементом? Python предположит, что вы по ошибке добавили лишнюю пару скобок (это ни на что не влияет), но тип данных в таком случае — это не кортеж. Поэтому важно не забывать использовать запятую при объявлении кортежа с одним элементом.
И снова к функции any. В булевом контексте значение элемента не имеет значения. Пустой кортеж вернет False, а кортеж с хотя бы одним элементом — True.
b = ()
print(any(b))
False
Функция может быть полезной, если кортеж вызывается? и нужно удостовериться, что он не пустой.
tuple()
Функция tuple() используется для конвертации данных в кортеж. Например, так можно превратить список в кортеж.
a_list = [1,2,3,4,5]
b_tuple = tuple(a_list)
print(type(b_tuple))
<class 'tuple'>
min() и max()
Функция max()q возвращает самый большой элемент последовательности, а min() — самый маленький. Возьмем следующий пример:
print(max(a))
print(min(a))
5
A
Эти функции можно использовать и для кортежей со строками.
a = ('Apple')
print(max(a))
p
sum()
С помощью этой функции можно вернуть сумму элементов в кортеже. Работает только с числовыми значениями.
sum(a)
28
sorted()
Чтобы получить кортеж с отсортированными элементами, используйте sorted() как в следующем примере:
a = (6,7,4,2,1,5,3)
sorted(a)
[1, 2, 3, 4, 5, 6, 7]
Но важно отметить, что возвращаемый тип — список, а не кортеж. При этом последовательность в оригинальном объекте неизменна, а сам он остается кортежем.
Присваивание несколько кортежей
Кортежи можно использовать для присваивания нескольких значений одновременно. Вот так:
a = (1,2,3)
(one,two,three) = a
print(one)
1
a — это кортеж из трех элементов и (one, two, three) — кортеж трех переменных. Присваивание (one, two, three) кортежу a присваивает каждое значение a каждой переменной: one, two и three по очереди. Это удобно, если нужно присвоить определенному количеству переменных значений в кортеже.
Выводы
Теперь вы знаете, что такое кортежи, как их создавать, какие самые распространенные операции, и как ими можно управлять. Также — распространенные методы структур Python. А в качестве бонуса научились присваивать нескольким переменным разные значения.
Python. Урок 8. Кортежи (tuple)
Данный урок посвящен кортежам (tuple) в Python. Основное внимание уделено вопросу использования кортежей, почему иногда лучше применять их, а не списки, рассмотрены способы создания и основные приемы работы с кортежами. Также затронем тему преобразования кортежа в список и обратно.
Что такое кортеж (tuple) в Python?
Кортеж (tuple) – это неизменяемая структура данных, которая по своему подобию очень похожа на список. Как вы наверное знаете, а если нет, то, пожалуйста, ознакомьтесь с седьмым уроком, список – это изменяемый тип данных. Т.е. если у нас есть список a = [1, 2, 3] и мы хотим заменить второй элемент с 2 на 15, то мы может это сделать, напрямую обратившись к элементу списка.
>>> a = [1, 2, 3] >>> print(a) [1, 2, 3] >>> a[1] = 15 >>> print(a) [1, 15, 3]
С кортежем мы не можем производить такие операции, т.к. элементы его изменять нельзя.
>>> b = (1, 2, 3)
>>> print(b)
(1, 2, 3)
>>> b[1] = 15
Traceback (most recent call last):
File "<pyshell#6>", line 1, in <module>
b[1] = 15
TypeError: 'tuple' object does not support item assignment
Зачем нужны кортежи в Python?
Существует несколько причин, по которым стоит использовать кортежи вместо списков. Одна из них – это обезопасить данные от случайного изменения. Если мы получили откуда-то массив данных, и у нас есть желание поработать с ним, но при этом непосредственно менять данные мы не собираемся, тогда, это как раз тот случай, когда кортежи придутся как нельзя кстати. Используя их в данной задаче, мы дополнительно получаем сразу несколько бонусов – во-первых, это экономия места. Дело в том, что кортежи в памяти занимают меньший объем по сравнению со списками.
>>> lst = [10, 20, 30] >>> tpl = (10, 20, 30) >>> print(lst.__sizeof__()) 32 >>> print(tpl.__sizeof__()) 24
Во-вторых – прирост производительности, который связан с тем, что кортежи работают быстрее, чем списки (т.е. на операции перебора элементов и т.п. будет тратиться меньше времени). Важно также отметить, что кортежи можно использовать в качестве ключа у словаря.
Создание, удаление кортежей и работа с его элементами
Создание кортежей
Для создания пустого кортежа можно воспользоваться одной из следующих команд.
>>> a = () >>> print(type(a)) <class 'tuple'> >>> b = tuple() >>> print(type(b)) <class 'tuple'>
Кортеж с заданным содержанием создается также как список, только вместо квадратных скобок используются круглые.
>>> a = (1, 2, 3, 4, 5) >>> print(type(a)) <class 'tuple'> >>> print(a) (1, 2, 3, 4, 5)
При желании можно воспользоваться функцией tuple().
>>> a = tuple((1, 2, 3, 4)) >>> print(a) (1, 2, 3, 4)
Доступ к элементам кортежа
Доступ к элементам кортежа осуществляется также как к элементам списка – через указание индекса. Но, как уже было сказано – изменять элементы кортежа нельзя!
>>> a = (1, 2, 3, 4, 5)
>>> print(a[0])
1
>>> print(a[1:3])
(2, 3)
>>> a[1] = 3
Traceback (most recent call last):
File "<pyshell#24>", line 1, in <module>
a[1] = 3
TypeError: 'tuple' object does not support item assignment
Удаление кортежей
Удалить отдельные элементы из кортежа невозможно.
>>> a = (1, 2, 3, 4, 5)
>>> del a[0]
Traceback (most recent call last):
File "<pyshell#26>", line 1, in <module>
del a[0]
TypeError: 'tuple' object doesn't support item deletion
Но можно удалить кортеж целиком.
>>> del a
>>> print(a)
Traceback (most recent call last):
File "<pyshell#28>", line 1, in <module>
print(a)
NameError: name 'a' is not defined
Преобразование кортежа в список и обратно
На базе кортежа можно создать список, верно и обратное утверждение. Для превращения списка в кортеж достаточно передать его в качестве аргумента функции tuple().
>>> lst = [1, 2, 3, 4, 5] >>> print(type(lst)) <class 'list'> >>> print(lst) [1, 2, 3, 4, 5] >>> tpl = tuple(lst) >>> print(type(tpl)) <class 'tuple'> >>> print(tpl) (1, 2, 3, 4, 5)
Обратная операция также является корректной.
>>> tpl = (2, 4, 6, 8, 10) >>> print(type(tpl)) <class 'tuple'> >>> print(tpl) (2, 4, 6, 8, 10) >>> lst = list(tpl) >>> print(type(lst)) <class 'list'> >>> print(lst) [2, 4, 6, 8, 10]
P.S.
Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.
<<< Python. Урок 7. Работа со списками (list) Python. Урок 9. Словари (dict)>>>
урок по работе с кортежами для начинающих ~ PythonRu
Предыдущий урок: Списки (list)
Кортеж — это упорядоченная последовательность, неизменяемая. В Python кортежи пишутся в круглых скобках.
Создание кортежа:
thistuple = ("помидор", "огурец", "лук")
print(thistuple)
Вывод:
('помидор', 'огурец', 'лук')
Доступ к элементам кортежа
Вы можете получить доступ к элементам кортежа с помощью индекса.
Вывести элемент с индексом 1:
thistuple = ("помидор", "огурец", "лук")
print(thistuple[1])
Вывод:
огурец
Изменить элемент корежа
После создания кортежа вы не можете вносить изменения в него. Кортеж — неизменяемый.
thistuple = ("помидор", "огурец", "лук")
thistuple[1] = "морковка"
Вывод:
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
thistuple[1] = "морковка"
TypeError: 'tuple' object does not support item assignment
Итерация по кортежу
Вы можете перебирать элементы кортежа с помощью цикла for.
thistuple = ("помидор", "огурец", "лук")
for x in thistuple:
print(x)
Вывод:
помидор
огурец
лук
Подписывайтесь на телеграм каналы
Узнать больше о цикле for вы можете в разделе Python цикл For.
Длина кортежа
Для определения количества элементов списка, используйте метод len().
Выведите количество элементов в кортеже:
thistuple = ("помидор", "огурец", "лук")
print(len(thistuple))
Вывод:
3
Добавление элементов
После создания кортежа, вы не можете добавлять в него элементы. Кортеж — неизменяемый.
thistuple = ("помидор", "огурец", "лук")
thistuple[3] = "морковка"
Вывод:
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
thistuple[3] = "морковка"
TypeError: 'tuple' object does not support item assignment
Удаление элементов
Вы не можете удалять элементы по отдельности, но вы можете полностью удалить кортеж:
Ключевое слово del может полностью удалить кортеж:
thistuple = ("помидор", "огурец", "лук")
del thistuple
print(thistuple)
Конструктор tuple()
Так же конструктор tuple() можно использовать для создания кортежа.
thistuple = tuple(("помидор", "огурец", "лук"))
print(thistuple)
Методы кортежа
В Python так же существуют два встроенных метода, которые вы можете использовать при работе.
| Метод | Значение |
|---|---|
| count() | Возвращает количество раз, которое указанный элемент встречается в кортеже |
| index() | Ищет кортеж по указанному значению и возвращает его индекс |
Далее: Множества (set)
Кортежи (tuple) в Python
Введение
Примеры
Индексирование кортежей
x = (1, 2, 3)
x[0] # 1
x[1] # 2
x[2] # 3
x[3] # IndexError: tuple index out of range
Индексирование с отрицательными числами начнется с последнего элемента как -1:
x[-1] # 3
x[-2] # 2
x[-3] # 1
x[-4] # IndexError: tuple index out of range
Индексирование ряда элементов
print(x[:-1]) # (1, 2)
print(x[-1:]) # (3,)
print(x[1:3]) # (2, 3) Кортежи неизменны
Одним из основных отличий между list s и tuple с в Python является то , что кортежи являются неизменяемыми, то есть, один не может добавлять или изменять элементы , как только кортеж инициализируются. Например:
>>> t = (1, 4, 9)
>>> t[0] = 2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
Точно так же, кортежи не имеют .append и .extend методы , как list делает. Используя += возможно, но он изменяет связывание переменной, а не сам кортеж:
>>> t = (1, 2)
>>> q = t
>>> t += (3, 4)
>>> t
(1, 2, 3, 4)
>>> q
(1, 2)
Будьте осторожны при размещении изменяемых объектов, таких как lists , внутри кортежей. Это может привести к очень запутанным результатам при их изменении. Например:
>>> t = (1, 2, 3, [1, 2, 3])
(1, 2, 3, [1, 2, 3])
>>> t[3] += [4, 5]
Будет как поднимать ошибку и изменить содержимое списка в кортеже:
TypeError: 'tuple' object does not support item assignment
>>> t
(1, 2, 3, [1, 2, 3, 4, 5])
Вы можете использовать += оператору «добавить» в кортеж — это работает, создавая новый кортеж с новым элементом вы «добавленным» и назначить его в текущей переменной; старый кортеж не изменен, но заменен!
Это позволяет избежать преобразования в список и из списка, но это медленный процесс, и это плохая практика, особенно если вы собираетесь добавлять несколько раз.
Кортеж является элементарным измеримым и уравновешенным
hash( (1, 2) ) # ok
hash( ([], {"hello"}) # not ok, since lists and sets are not hashabe
Таким образом, кортеж можно поставить внутри set или в качестве ключа в dict только тогда , когда каждый из его элементов может.
{ (1, 2) } # ok
{ ([], {"hello"}) ) # not ok Кортеж
Синтаксически, кортеж — это список значений через запятую:
t = 'a', 'b', 'c', 'd', 'e'
Хотя это и необязательно, обычно заключать кортежи в скобки:
t = ('a', 'b', 'c', 'd', 'e')
Создайте пустой кортеж с круглыми скобками:
t0 = ()
type(t0) # <type 'tuple'>
Чтобы создать кортеж с одним элементом, необходимо добавить заключительную запятую:
t1 = 'a',
type(t1) # <type 'tuple'>
Обратите внимание, что одно значение в скобках не является кортежем:
t2 = ('a')
type(t2) # <type 'str'>
Для создания одноэлементного кортежа необходимо использовать завершающую запятую.
t2 = ('a',)
type(t2) # <type 'tuple'>
Обратите внимание , что для одноэлементных кортежей рекомендуется (см PEP8 на задней запятые ) использовать круглые скобки. Кроме того , ни один белый пробел после запятой ведомой (см PEP8 на пробельных символов )
t2 = ('a',) # PEP8-compliant
t2 = 'a', # this notation is not recommended by PEP8
t2 = ('a', ) # this notation is not recommended by PEP8
Другой способ создать кортеж является встроенной функцией tuple .
t = tuple('lupins')
print(t) # ('l', 'u', 'p', 'i', 'n', 's')
t = tuple(range(3))
print(t) # (0, 1, 2)
Эти примеры основаны на материалах из книги Думай Python Аллен B. Дауни .
Упаковка и распаковка кортежей
Кортежи в Python — это значения, разделенные запятыми. Заключение круглых скобок для ввода кортежей не является обязательным, поэтому два назначения
a = 1, 2, 3 # a is the tuple (1, 2, 3)
а также
a = (1, 2, 3) # a is the tuple (1, 2, 3)
эквивалентны. Присваивания a = 1, 2, 3 также называют упаковки , потому что пакеты значения вместе в кортеже.
Обратите внимание, что кортеж с одним значением также является кортежем. Чтобы сообщить Python, что переменная является кортежем, а не единственным значением, вы можете использовать запятую
a = 1 # a is the value 1
a = 1, # a is the tuple (1,)
Запятая нужна также, если вы используете скобки
a = (1,) # a is the tuple (1,)
a = (1) # a is the value 1 and not a tuple
Для распаковки значений из кортежа и выполнения нескольких назначений используйте
# unpacking AKA multiple assignment
x, y, z = (1, 2, 3)
# x == 1
# y == 2
# z == 3
Символ _ может быть использован в качестве одноразового использования имени переменной , если нужно только некоторые элементы кортежа, действуя в качестве заполнителя:
a = 1, 2, 3, 4
_, x, y, _ = a
# x == 2
# y == 3
Одноэлементные кортежи:
x, = 1, # x is the value 1
x = 1, # x is the tuple (1,)
В Python 3 целевой переменной с * префикс может быть использован в качестве вдогонку всех переменных (см https://codecamp.ru/documentation/python/809/compatibility-between-python-3-and-python-2/2845 / распаковка-итерируемые ):
первый, * еще, последний = (1, 2, 3, 4, 5) # первый == 1 # еще == [2, 3, 4] # последний == 5
Реверсивные элементы
Обратные элементы в кортеже
colors = "red", "green", "blue"
rev = colors[::-1]
# rev: ("blue", "green", "red")
colors = rev
# colors: ("blue", "green", "red")
Или с использованием обратного (обратное дает итерацию, которая преобразуется в кортеж):
rev = tuple(reversed(colors))
# rev: ("blue", "green", "red")
colors = rev
# colors: ("blue", "green", "red") Встроенные функции кортежей
Кортежи поддерживают следующие встроенные функции
Если элементы одного типа, python выполняет сравнение и возвращает результат. Если элементы разных типов, он проверяет, являются ли они числами.
- Если числа, проведите сравнение.
- Если один из элементов является числом, то возвращается другой элемент.
- В противном случае типы сортируются по алфавиту.
Если мы достигли конца одного из списков, более длинный список будет «больше». Если оба списка одинаковы, возвращается 0.
tuple1 = ('a', 'b', 'c', 'd', 'e')
tuple2 = ('1','2','3')
tuple3 = ('a', 'b', 'c', 'd', 'e')
cmp(tuple1, tuple2)
Out: 1
cmp(tuple2, tuple1)
Out: -1
cmp(tuple1, tuple3)
Out: 0
Функция len возвращает общую длину кортежа
len(tuple1)
Out: 5
Функция max возвращает элемент из кортежа с максимальным значением
max(tuple1)
Out: 'e'
max(tuple2)
Out: '3'
Функция min возвращает элемент из кортежа со значением min
min(tuple1)
Out: 'a'
min(tuple2)
Out: '1'
Встроенная функция tuple преобразует список в кортеж.
list = [1,2,3,4,5]
tuple(list)
Out: (1, 2, 3, 4, 5)
Используйте + для конкатенации двух кортежей
создание и приведение к списку
Чтобы усовершенствовать программный код, добавить в него новые важные функции используются разнообразные методы. К ним относится: создание списков, кортежей или словарей. В данной статье рассмотрим, когда используются, чем они отличаются, как создать и как работать с кортежами в Python 3.
Что такое кортеж
Кортеж – это неизменная структура заданных заранее значений. Он очень похож на список, но последний подвержен изменениям. Так, если нужно исправить какой-то элемент списка, можно сделать это, напрямую указав:
b = [4, 6, 8] print(b) [4, 6, 8] b[1] = 13 print(b) [4, 13, 8]
Если же записать подобный код, но попытаться применить его к кортежу, ничего не выйдет, а на экране появится надпись об ошибке. Считается, что это важно, поскольку таким образом данные невозможно будет изменить как случайно, так и намеренно. Также в python добавление элемента в кортеж невозможно. Правда можно привести его в список, добавить элемент. После этого полученный список преобразовать обратно.
Выгодное преимущество кортежа состоит также в том, что он имеет меньший размер, что проверяется применением команды sizeof. Она показывает, сколько занимает объект в байтах:
a = (2, 4, 6, 8, 10, 12) b = [2, 4, 6, 8, 10, 12] a.__sizeof__() 36 b.__sizeof__() 44
Из этого кода видно, что кортеж (в круглых скобках) занимает 36 байтов, а список (в квадратных скобках) – 44 байта.
Создание
Кортеж определяется точно так же, как и список, однако перечисление происходит в круглых, а не квадратных скобках. Элементы будут стоять в определенном порядке, а их нумерация всегда начинается с нуля. А точнее для непустого кортежа первым элементом будет являться ноль. Отрицательный индекс позволит отсчитывать все с конца (с правой стороны).
Приведем пример создания в Python обычного кортежа:
a = (1,2,3)
Можно преобразовать список в кортеж следующим образом:
a = tuple([1,2,3])
Рассмотрим кортеж с отрицательным индексом:
n = ("a", "b", "с", "d", "e")
print(n[-1])
'e'То есть на экране отобразился первый не с начала, а с конца элемент.
Чтобы создать кортеж с одним элементом, нужно сделать такую запись:
a =(3,) print(a[0]) 3
Нужно обратить особое внимание на то, что даже если элемент один, после него все равно должна стоять запятая.
Иногда для создания кортежей используются генераторы. Обычно они служат, чтобы компактно и удобно создать необходимую коллекцию элементов. Приведем пример:
a = tuple(i for i in range(0, 10)) print(a) (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
Выше представлен генератор кортежа. То есть мы создали генератор. После этого преобразовали его к кортежу с помощью ключевого слова tuple.
Помните, что к генератору нельзя применить срезы. Если потребуется – то можно привести генератор к кортежу и только потом сделать срез.
Подробнее о срезах описано ниже в пункте “Обращение к элементу”.
Использование генераторов кортежей аналогично генераторам списка.
Обращение к элементу
У каждого элемента есть свой индекс. То есть, в Python для обращения к элементу кортежа, нужно просто указать его индекс. Напомним, что счет начинается с нуля. Посмотрим на код:
b = (4, 6, 8) print(b[0]) print(b[1]) 4 6
Из кортежа можно извлечь как элемент, так и срез. В этом случае мы получим кортеж, состоящий из элементов, расположенных в промежутке среза. Следует уточнить, что при указании среза используются не номера элементов, а номера промежутков между ними. Перед первым элементом находится промежуток с индексом 0. Рассмотрим пример:
b = (5, 3.6, "квадрат", 15, 'В')
print(b[1])
print(b[2:4])
3.6
('квадрат', 15)Методы
Кортежи в python имеют только два метода: index() и count(). Первый применяется, чтобы узнать, какой индекс у определенного элемента. Например:
a = (32, 33, 34, 33, 34, 33) print(a.index(33)) 1
Элементов «33» в кортеже несколько, но на экран будет выведен индекс первого из них.
Метод count используется, если нужно узнать, сколько определенных элементов имеется в кортеже.
a = (32, 33, 34, 33, 34, 33) print(a.count(33)) 3
На экране перед пользователем появится именно число 3, потому что в кортеже искомое число 33 повторяется 3 раза.
Помните, что в кортежах нет методов добавления и удаления элементов.
Именованные кортежи
Данный класс не получил широкого применения среди программистов, хотя он и является достаточно важным и полезным. Именованные кортежи в python (или namedtuple) в каком-то смысле являются расширениями для обычных. Так, огромной проблемой считается то, что получать данные из кортежа можно только при помощи числовых индексов. А что делать, если хочется для наглядности кода обращаться к элементам, используя строковое наименование. Такое обращение значительно улучшит читаемость кода. Для этого на помощь приходит namedtuple.
Для того, чтобы использовать namedtuple, необходимо подключить библиотеку collections. Это делается с помощью import collecions *. В этом случае обращаться к namedtuple будет необходимо следующим образом: collections.namedtuple( [параметры] ). Другой вариант подключения библиотеки приведен в примере ниже.
Каждый элемент, сохраненный в именованном кортеже, доступен через определенный идентификатор. Посмотрим на примере кода:
from collections import namedtuple
Flower = namedtuple('Flower' , 'color cost comment')
rose = Flower('red', 5, 'beautiful')
print(rose.cost)
5Наименования полей были перечислены через пробел. Вместо этой строки можно было передать список со строками. В конструкторе namedtuple разобьет полученную строку с помощью split. В качестве примера было приведено обращение к элементу cost. К остальным обращение аналогично: rose.color, rose.comment.
Таким образом, именованный кортеж делает вид программного кода более читаемым. Так, в вышеуказанном коде можно увидеть наименования color, cost и comment. И при всем при этом, сохраняется возможность обращения к элементам по индексу, например дописав к предыдущему коду:
print(rose[0]) red
Список кортежей
Иногда бывают задачи, в которых нужно хранить таблицы с данными, которые называются матрицами (или двумерными массивами). Для работы с массивами используется библиотека array. К сожалению, не получится с ее помощью сделать массив кортежей. Потому что элементом массива не может быть кортеж.
Из этой ситуации есть выход – создание в Python списка кортежей. Вариант объявления такого списка представлен ниже:
a = [(1,2,3),(4,5,6)]
Cортировка
Иногда нужно отсортировать имеющиеся элементы списка. Благодаря встроенной функции sorted, все это делается достаточно легко:
a = ('One', 'Two', 'Three')
a = tuple(sorted(a))
print(a)
('One', 'Three', 'Two')Видно, что произошла сортировка кортежа Python по алфавиту. Стандартную сортировку можно провести и по числовым элементом. Посмотрим на пример:
a = (3, 1, 5 ,2, 6, 7) a = tuple(sorted(a)) print(a) (1, 2, 3, 5, 6, 7)
Заметим, что произошла сортировка по возрастанию.
Обратите внимание, что функция sorted возвращает список, но с помощью tuple мы приводим результат сортировки к кортежу.
В список
Кортеж можно переделать в список:
a = (1,2,3) a = list(a) print(a) [1, 2, 3]
Таким образом, кортеж был преобразован в список Python, который можно изменить. Теперь рассмотрим обратное действие — преобразование списка в кортеж:
a = [1, 2.6, "квадрат"] a = tuple(a) print(a) (1, 2.6, "квадрат")
В словарь
Словарь – это еще одна структура используемая в Python. Он, как и список, является изменяемым, но при этом неупорядоченным. Это значит, что обратиться к определенному элементу посредством указания индекса – не получится. Чтобы лучше понять, можно провести аналогию с обычным англо-русским словарем. В нем для каждого слова есть перевод: house –дом, flat – квартира, window – окно. Если перенести такую структуру в программный код, то получится такая запись, оформляемая фигурными скобками:
{'house': 'дом', 'flat': 'квартира', 'window': 'окно'}Последовательность пар при выводе на экран не определяется никаким правилом, отображаются они в произвольном порядке.
Для того, чтобы в Python преобразовать кортеж в словарь, необходимо использовать приведение типов с помощью dict.
a = (('a', 2),('b', 4))
a = dict(a)
print(a)
{'a': 2, 'b': 4}Как видно, для создания словаря понадобился кортеж кортежей. Причем вложенные кортежи состоят из двух элементов каждый. Иначе не получается провести преобразование к словарю.
В строку
Чтобы вывести в python кортеж в одну строку, используется функция join. Посмотрим на примере:
a = ('one','two','three')
b = ''.join(a)
c = ','.join(a)
print(b)
print(c)
onetwothree
one,two,threeПосле выполнения кода на дисплее появится запись всех элементов в одну строку с указанным разделителем. В первом случае – без пробелов, а во втором случае – через запятую.
Чем же кортежи удобнее? Работа с ними проходит быстрее, чем, например, со списками. Если программисту нужно определить постоянный набор значений, чтобы затем их перебирать, то лучше будет сделать это с его помощью. Плюс – это экономия оперативной памяти, так как они занимают меньше места, чем списки.
Кортежи(tuple) в Python — все что нужно знать: список и строки, добавление, преобразование и удаление
- Кортеж Python — неизменная последовательность.
- Кортеж создается со значениями, разделенными запятой.
- Поскольку он неизменен, мы не можем добавлять или удалять его элементы.
- Если элементы кортежа не являются неизменяемыми, их свойства можно изменить. Но мы не можем напрямую изменить элемент кортежа.
- Мы можем создавать вложенные кортежи.
- Мы можем получить доступ к элементам через их индекс. Он также поддерживает отрицательную индексацию для ссылки на элементы от конца до начала.
- Мы также можем распаковать элементы в значения, разделенные запятыми.
- Кортежи обычно создаются для хранения разнородных элементов. У них также может быть None.
- Поддерживают два оператора: + для объединения и * для повторения элементов.
- Поддерживает нарезку для создания другого кортежа из исходного.
- Мы можем использовать операторы «in» и «not in», чтобы проверить, присутствует ли элемент в кортеже или нет.
- Мы можем перебирать его элементы с помощью цикла for.
- Класс кортежей Python имеет две функции —
count()иindex().
Как создать кортеж в Python?
Мы можем создать кортеж, поместив все его элементы в круглые скобки, разделенные запятыми.
tuple_numbers = (1, 2, 3, 1)
Мы можем хранить разные типы объектов.
tup = 1, 2, 3, 1, None, "Hello"
Давайте посмотрим на пример вложенного кортежа.
nested_tuple = ((1, 2), ("Hello", "Hi"), "Python")
Мы можем создать пустой кортеж, не имея никаких элементов внутри круглых скобок.
empty_tuple =()
Использование круглых скобок для создания границы необязательно. Однако лучше всего его использовать. Если вы печатаете кортеж, элементы всегда печатаются в круглых скобках.
>>> tup = 1, 2, "Hello" >>> print(tup) (1, 2, 'Hello') >>>
Создание кортежа из одного элемента немного сложно. Если вы поместите одно значение в круглые скобки, оно не создаст его. Он создаст объект типа значения. Давайте проверим это на простом примере.
single_item_tuple = ("Hello")
print(type(single_item_tuple))
single_item_tuple = (10)
print(type(single_item_tuple))
Вывод:
Мы можем добавить запятую после значения, чтобы создать кортеж из одного элемента.
single_item_tuple = "Hello", print(type(single_item_tuple)) single_item_tuple = 10, print(type(single_item_tuple))
Как получить доступ к элементам кортежа?
Мы можем получить доступ к элементам кортежа через их индекс. Значение индекса начинается с 0 до длины кортежа — 1.
tuple_numbers = (1, 2, 3, 4)
print(f'First element in tuple is {tuple_numbers[0]}')
print(f'Third element in tuple is {tuple_numbers[3]}')
Если размер меньше указанного индекса, выдается «IndexError: индекс кортежа вне допустимого диапазона».
>>> tuple_numbers = (1, 2, 3, 4) >>> tuple_numbers[10] Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: tuple index out of range >>>
Tuple также поддерживает отрицательную индексацию. В этом случае элемент извлекается от конца до начала. Отрицательный индекс начинается с -1 до — (длина кортежа).
tuple_numbers = (1, 2, 3, 4)
print(f'Last element in tuple is {tuple_numbers[-1]}')
print(f'Second Last element in tuple is {tuple_numbers[-2]}')
print(f'First element in tuple is {tuple_numbers[-4]}')
Если у нас есть вложенный кортеж, мы можем получить доступ к его элементам через вложенные индексы.
>>> nested_tuple = (1, 2, (3, 4), (5, 6, 7)) >>> nested_tuple[2][0] 3 >>> nested_tuple[2][1] 4 >>> nested_tuple[3][0] 5 >>> nested_tuple[3][1] 6 >>> nested_tuple[3][2] 7 >>>
Мы также можем использовать отрицательные индексы с вложенными кортежами.
>>> nested_tuple = (1, 2, (3, 4), (5, 6, 7)) >>> >>> nested_tuple[-1][-1] 7 >>> nested_tuple[-2][1] 4 >>> nested_tuple[-2][-1] 4 >>> nested_tuple[3][-2] 6 >>>
На изображении ниже показано, как работают индексы.
Нарезка
Мы можем использовать нарезку для создания подмножества кортежа. Это полезно при создании нового кортежа из исходного кортежа. Техника нарезки содержит два индекса, разделенных двоеточием. Левый индекс включен, а правый индекс исключен из результата.
tuple_numbers = (1, 2, 3, 4, 5, 6, 7, 8) print(tuple_numbers[1:3]) print(tuple_numbers[:4]) print(tuple_numbers[5:]) print(tuple_numbers[:-5])
Вывод:
Неизменность
Кортеж неизменен по своей природе. Поэтому мы не можем добавлять, обновлять или удалять его элементы. Однако, если элемент является изменяемым, его свойства могут измениться.
>>> tup = (1,2) >>> tup[0] = 10 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment
Давайте посмотрим на пример, в котором элементы являются изменяемыми, и мы меняем их свойства.
list_fruits = ["Apple"]
tup = ("Hello", list_fruits)
print(tup)
list_fruits.append("Banana")
print(tup)
Вывод:
Удаление
Мы не можем удалять элементы. Но мы можем удалить сам кортеж с помощью оператора del.
>>> tup = (1,2) >>> print(tup) (1, 2) >>> del tup >>> print(tup) Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'tup' is not defined >>>
Объединение кортежей (оператор +)
Мы можем объединить элементы кортежа для создания нового с помощью оператора +.
>>> tuple1 = (1, 2) >>> tuple2 = (3, 4) >>> tuple3 = (5, 6, 7) >>> >>> tuple_all = tuple1 + tuple2 + tuple3 >>> print(tuple_all) (1, 2, 3, 4, 5, 6, 7) >>>
Повторяющиеся элементы (оператор *)
Tuple также поддерживает оператор * для создания нового кортежа с элементами, повторяющимися заданное количество раз.
>>> tup = (1, 2, (3, 4)) >>> >>> tup1 = tup * 3 >>> >>> print(tup1) (1, 2, (3, 4), 1, 2, (3, 4), 1, 2, (3, 4)) >>>
Функции
Класс кортежа выполняет две функции.
- count (x): возвращает количество вхождений данного элемента.
- index (x, start, end): возвращает первый индекс значения. Мы можем указать начальный и конечный индексы для поиска значения. Если значение не найдено, то вызывается ValueError.
>>> tup = (1, 2, 3, 1, 2, 1, 3, 2, 1) >>> >>> tup.count(1) 4 >>> tup.count(2) 3 >>> tup.index(2) 1 >>> tup.index(2, 2) 4 >>> tup.index(2, 2, 6) 4 >>> tup.index(20) Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: tuple.index(x): x not in tuple >>>
Проверка содержит ли кортеж элемент?
Мы можем проверить, содержит ли кортеж элемент, используя оператор «in». Точно так же мы можем использовать оператор «not in», чтобы проверить, отсутствует ли элемент в кортеже.
>>> vowels = ("a", "e", "i", "o", "u")
>>>
>>> "a" in vowels
True
>>> "x" in vowels
False
>>>
>>> "a" not in vowels
False
>>> "x" not in vowels
True
Итерации
Мы можем использовать цикл for для перебора элементов.
vowels = ("a", "e", "i", "o", "u")
for v in vowels:
print(v)
Если вы хотите перебирать в обратном порядке, вы можете использовать функцию reversed().
for v in reversed(vowels):
print(v)
Кортеж или список — сравнение
- Кортеж неизменен, а список — изменчив.
- Кортеж предпочтительнее списка для хранения различных типов данных в последовательности.
- Поскольку кортеж неизменяем, итерация по кортежу выполняется немного быстрее, чем по списку.
- Кортеж имеет больше памяти и оптимизирован по пространству, чем список.
- Если вы хотите добавить, удалить элементы из последовательности используйте List.
Встроенная функция tuple()
Мы также можем использовать функцию tuple() для создания кортежа. Он принимает повторяющийся аргумент, такой как List и String. Это полезно при преобразовании других типов последовательностей.
1. Список
list_numbers = [1, 2, 3] tuple_numbers = tuple(list_numbers) print(tuple_numbers) # (1, 2, 3)
2. Строка
s = "ABCD"
tuple_str = tuple(s)
print(tuple_str) # ('A', 'B', 'C', 'D')
3. Диапазон
r = range(1, 10) tuple_range = tuple(r) print(tuple_range)
Кортежей Python
Кортеж
Кортеж — это набор, который упорядочен и неизменен . В Python кортежи записываются в круглые скобки.
Пример
Создать кортеж:
thistuple = («яблоко», «банан», «вишня»)
печать (thistuple)
Попробуй сам »
Доступ к элементам кортежа
Вы можете получить доступ к элементам кортежа, указав номер индекса внутри квадрата
скобки:
Пример
Вывести второй элемент кортежа:
thistuple = («яблоко», «банан», «вишня»)
печать (thistuple [1])
Попробуй сам »
Отрицательное индексирование
Отрицательная индексация означает начало с конца, -1 относится к последнему элементу,
-2 относится ко второму последнему элементу и т. Д.
Пример
Вывести последний элемент кортежа:
thistuple = («яблоко», «банан», «вишня»)
печать (thistuple [-1])
Попробуй сам »
Диапазон индексов
Вы можете указать диапазон индексов, указав, где начать и где
конец диапазона.
При указании диапазона возвращаемое значение будет новым кортежем с
указанные предметы.
Пример
Верните третий, четвертый и пятый предмет:
thistuple = («яблоко», «банан», «вишня», «апельсин», «киви», «дыня», «манго»)
печать (thistuple [2: 5])
Попробуй сам »
Примечание: Поиск начнется с индекса 2 (включен) и закончится с индексом 5 (не включен).
Помните, что первый элемент имеет индекс 0.
Диапазон отрицательных индексов
Укажите отрицательные индексы, если вы хотите начать поиск с конца
кортеж:
Пример
В этом примере возвращаются элементы от индекса -4 (включен) до индекса -1 (исключен)
thistuple = («яблоко», «банан», «вишня», «апельсин», «киви», «дыня», «манго»)
печать (число [-4: -1])
Попробуй сам »
Изменить значения кортежа
После создания кортежа вы не можете изменить его значения.Кортежи неизменные ,
или неизменный , как его еще называют.
Но есть обходной путь. Вы можете преобразовать кортеж в список, изменив
list и преобразовать список обратно в кортеж.
Пример
Преобразуйте кортеж в список, чтобы иметь возможность его изменять:
x = («яблоко», «банан», «вишня»)
y = список (x)
y [1] = «киви»
x =
кортеж (y)
печать (x)
Попробуй сам »
Цикл через кортеж
Вы можете перебирать элементы кортежа, используя цикл для .
Пример
Перебрать элементы и распечатать значения:
thistuple = («яблоко», «банан», «вишня»)
для x в этой тройке:
print (x)
Попробуй сам »
Вы узнаете больше о циклах для в нашей главе Python For Loops.
Проверить, существует ли элемент
Чтобы определить, присутствует ли указанный элемент в кортеже, используйте ключевое слово in :
Пример
Проверить, присутствует ли «яблоко» в кортеже:
thistuple = («яблоко», «банан», «вишня»)
если «яблоко» в этой строке:
print («Да,« яблоко »находится в кортеже фруктов»)
Попробуй сам »
Длина кортежа
Чтобы определить, сколько элементов в кортеже, используйте метод len () :
Пример
Выведите количество элементов в кортеже:
thistuple = («яблоко», «банан», «вишня»)
печать (лен (чертополох))
Попробуй сам »
Добавить товары
После создания кортежа вы не можете добавлять в него элементы.Кортежи неизменяемые .
Пример
Вы не можете добавлять элементы в кортеж:
thistuple = («яблоко», «банан», «вишня»)
thistuple [3] = «orange» # Это вызовет ошибку
print (thistuple)
Попробуй сам »
Создать кортеж с одним элементом
Чтобы создать кортеж только с одним элементом, вы должны добавить запятую после элемента,
иначе Python не распознает его как кортеж.
Пример
Кортеж из одного элемента, запомните запятую:
thistuple = («яблоко»,)
print (type (thistuple))
# НЕ кортеж
thistuple = («apple»)
print (тип (thistuple))
Попробуй сам »
Удалить элементы
Примечание: Вы не можете удалить элементы в кортеже.
Кортежи неизменяемые , поэтому вы не можете удалять элементы
из него, но вы можете полностью удалить кортеж:
Пример
Ключевое слово del может удалить кортеж
полностью:
thistuple = («яблоко», «банан», «вишня»)
дель
чертополох
принт (чертополох)
# это вызовет ошибку, потому что кортеж больше не существует
Попробуй сам »
Объединить две кортежи
Для объединения двух или более кортежей вы можете использовать +
оператор:
Пример
Соединить два кортежа:
tuple1 = («a», «b», «c»)
tuple2 = (1, 2, 3)
tuple3 = tuple1 + tuple2
печать (кортеж3)
Попробуй сам »
Конструктор tuple ()
Также можно использовать конструктор tuple () для создания кортежа.
Пример
Использование метода tuple () для создания кортежа:
thistuple = tuple ((«яблоко», «банан», «вишня»)) # обратите внимание на двойные круглые скобки
печать (thistuple)
Попробуй сам »
Кортежные методы
Python имеет два встроенных метода, которые можно использовать с кортежами.
| Метод | Описание |
|---|---|
| count () | Возвращает количество раз, когда указанное значение встречается в кортеже |
| index () | Ищет указанное значение в кортеже и возвращает позицию, где оно было найдено |
.
Кортеж Python (с примерами)
Кортеж в Python похож на список. Разница между ними заключается в том, что мы не можем изменять элементы кортежа после его назначения, тогда как мы можем изменять элементы списка.
Создание кортежа
Кортеж создается путем помещения всех элементов (элементов) в круглые скобки () , разделенных запятыми. Скобки необязательны, однако их рекомендуется использовать.
Кортеж может иметь любое количество элементов, и они могут быть разных типов (целые числа, числа с плавающей запятой, список, строка и т. Д.)).
# Различные типы кортежей
# Пустой кортеж
my_tuple = ()
печать (my_tuple)
# Кортеж с целыми числами
my_tuple = (1, 2, 3)
печать (my_tuple)
# кортеж со смешанными типами данных
my_tuple = (1, «Привет», 3.4)
печать (my_tuple)
# вложенный кортеж
my_tuple = ("мышь", [8, 4, 6], (1, 2, 3))
печать (my_tuple) Выход
()
(1, 2, 3)
(1, 'Привет', 3.4)
('мышь', [8, 4, 6], (1, 2, 3)) Кортеж также можно создать без использования круглых скобок.Это известно как упаковка кортежей.
my_tuple = 3, 4.6, "собака"
печать (my_tuple)
# также возможна распаковка кортежей
a, b, c = my_tuple
печать (а) # 3
print (b) # 4.6
print (c) # собака Выход
(3, 4.6, 'собака') 3 4.6 собака
Создание кортежа с одним элементом немного сложно.
Одного элемента в скобках недостаточно. Нам понадобится конечная запятая, чтобы указать, что это на самом деле кортеж.
my_tuple = ("привет")
print (type (my_tuple)) # <класс 'str'>
# Создание кортежа с одним элементом
my_tuple = ("привет",)
print (type (my_tuple)) # <класс 'кортеж'>
# Скобки не обязательны
my_tuple = "привет",
print (type (my_tuple)) # Выход
<класс 'str'> <класс 'кортеж'> <класс 'кортеж'>
Доступ к элементам кортежа
Существуют различные способы доступа к элементам кортежа.
1. Индексирование
Мы можем использовать оператор индекса [] для доступа к элементу в кортеже, где индекс начинается с 0.
Итак, кортеж, состоящий из 6 элементов, будет иметь индексы от 0 до 5. Попытка получить доступ к индексу за пределами диапазона индекса кортежа (6,7, … в этом примере) вызовет IndexError .
Индекс должен быть целым числом, поэтому мы не можем использовать float или другие типы. Это приведет к TypeError .
Аналогичным образом, доступ к вложенным кортежам осуществляется с помощью вложенной индексации, как показано в примере ниже.
# Доступ к элементам кортежа с помощью индексации
my_tuple = ('p', 'e', 'r', 'm', 'i', 'т')
print (my_tuple [0]) # 'p'
print (my_tuple [5]) # 'т'
# IndexError: список индекса вне допустимого диапазона
# print (my_tuple [6])
# Индекс должен быть целым числом
# TypeError: индексы списка должны быть целыми числами, а не с плавающей запятой
# my_tuple [2.0]
# вложенный кортеж
n_tuple = ("мышь", [8, 4, 6], (1, 2, 3))
# вложенный индекс
print (n_tuple [0] [3]) # 's'
print (число [1] [1]) # 4 Выход
с. т s 4
2.Отрицательное индексирование
Python допускает отрицательную индексацию своих последовательностей.
Индекс -1 относится к последнему элементу, -2 — ко второму последнему элементу и так далее.
# Отрицательная индексация для доступа к элементам кортежа
my_tuple = ('p', 'e', 'r', 'm', 'i', 'т')
# Вывод: 't'
печать (my_tuple [-1])
# Вывод: 'p'
печать (my_tuple [-6]) Выход
т п
3. Нарезка
Мы можем получить доступ к диапазону элементов в кортеже, используя оператор среза двоеточие : .
# Доступ к элементам кортежа с помощью нарезки
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
# элементы со второго по четвертый
# Вывод: ('r', 'o', 'g')
печать (my_tuple [1: 4])
# элементов начиная со 2-го
# Вывод: ('p', 'r')
печать (my_tuple [: - 7])
# элементы с 8-го по конец
# Вывод: ('i', 'z')
печать (my_tuple [7:])
# элемента от начала до конца
# Вывод: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
print (my_tuple [:]) Выход
('г', 'о', 'г')
('п', 'г')
('я', 'я')
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z') Нарезку лучше всего визуализировать, считая, что индекс находится между элементами, как показано ниже.Итак, если мы хотим получить доступ к диапазону, нам нужен индекс, который будет вырезать часть из кортежа.
Нарезка элементов в Python
Изменение кортежа
В отличие от списков, кортежи неизменяемы.
Это означает, что элементы кортежа не могут быть изменены после того, как они были назначены. Но если элемент сам по себе является изменяемым типом данных, например списком, его вложенные элементы могут быть изменены.
Мы также можем присвоить кортежу разные значения (переназначение).
# Изменение значений кортежа
my_tuple = (4, 2, 3, [6, 5])
# TypeError: объект 'tuple' не поддерживает назначение элементов
# my_tuple [1] = 9
# Однако, элемент изменяемого элемента можно изменить
my_tuple [3] [0] = 9 # Вывод: (4, 2, 3, [9, 5])
печать (my_tuple)
# Кортежи можно переназначить
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
# Вывод: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
печать (my_tuple) Выход
(4, 2, 3, [9, 5])
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z') Мы можем использовать оператор + для объединения двух кортежей.Это называется конкатенацией .
Мы также можем повторить элементов в кортеже заданное количество раз, используя оператор * .
Обе операции + и * приводят к созданию нового кортежа.
# Конкатенация
# Вывод: (1, 2, 3, 4, 5, 6)
печать ((1, 2, 3) + (4, 5, 6))
# Повторение
# Вывод: ('Repeat', 'Repeat', 'Repeat')
print (("Повторить",) * 3) Выход
(1, 2, 3, 4, 5, 6) («Повторить», «Повторить», «Повторить»)
Удаление кортежа
Как обсуждалось выше, мы не можем изменять элементы в кортеже.Это означает, что мы не можем удалять или удалять элементы из кортежа.
Однако можно полностью удалить кортеж с помощью ключевого слова del.
# Удаление кортежей
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
# невозможно удалить элементы
# TypeError: объект 'tuple' не поддерживает удаление элемента
# del my_tuple [3]
# Можно удалить весь кортеж
дель my_tuple
# NameError: имя my_tuple не определено
печать (my_tuple) Выход
Traceback (последний звонок последний): Файл «<строка>», строка 12, в <модуле> NameError: имя my_tuple не определено
Кортежные методы
Методы добавления или удаления элементов недоступны для кортежа.Доступны только два следующих метода.
Некоторые примеры методов кортежа Python:
my_tuple = ('а', 'р', 'р', 'л', 'е',)
print (my_tuple.count ('p')) # Вывод: 2
print (my_tuple.index ('l')) # Вывод: 3 Выход
2 3
Другие операции с кортежами
1. Тест на членство в кортеже
Мы можем проверить, существует ли элемент в кортеже или нет, используя ключевое слово в .
# Тест на членство в кортеже
my_tuple = ('а', 'р', 'р', 'л', 'е',)
# В действии
print ('a' в my_tuple)
print ('b' в my_tuple)
# Не работает
print ('g' отсутствует в my_tuple) Выход
Верно Ложь Правда
2. Итерация по кортежу
Мы можем использовать цикл для для перебора каждого элемента в кортеже.
# Использование цикла for для перебора кортежа
для имени в ('Джон', 'Кейт'):
print («Привет», имя) Выход
Привет, Джон Привет Кейт
Преимущества кортежа над списком
Поскольку кортежи очень похожи на списки, оба они используются в аналогичных ситуациях.Однако есть определенные преимущества реализации кортежа над списком. Ниже перечислены некоторые из основных преимуществ:
- Обычно мы используем кортежи для разнородных (разных) типов данных и списки для однородных (похожих) типов данных.
- Поскольку кортежи неизменяемы, итерация по кортежу выполняется быстрее, чем со списком. Так что есть небольшой прирост производительности.
- Кортежи, содержащие неизменяемые элементы, можно использовать в качестве ключа для словаря. Со списками это невозможно.
- Если у вас есть данные, которые не изменяются, реализация их в виде кортежа гарантирует, что они останутся защищенными от записи.
.
Python Tuple с примером
В Python кортеж похож на List, за исключением того, что объекты в кортеже неизменяемы, что означает, что мы не можем изменить элементы однажды назначенного кортежа. С другой стороны, мы можем изменить элементы списка.
1. Кортеж против списка
1. Элементы списка являются изменяемыми, тогда как элементы кортежа неизменяемы.
2. Когда мы не хотим изменять данные с течением времени, предпочтительным типом данных является кортеж , тогда как, когда нам нужно изменить данные в будущем, разумным вариантом будет список .
3. Перебор элементов кортежа выполняется быстрее, чем перебор списка .
4. Элементы кортежа заключены в круглые скобки, тогда как элементы списка заключены в квадратные скобки.
2. Как создать кортеж в Python
Чтобы создать кортеж в Python, поместите все элементы в круглые скобки (), разделенные запятыми. Кортеж может иметь разнородные элементы данных, кортеж также может содержать строку и список в качестве элементов данных.
2.1 Пример — создание кортежа
В этом примере мы создаем несколько кортежей. У нас может быть кортеж элементов данных одного типа, а также элементы данных смешанного типа. В этом примере также показан вложенный кортеж (кортежи как элементы данных в другом кортеже).
# кортеж строк
my_data = («привет», «привет», «пока»)
печать (my_data)
# кортеж из числа int, float, string
my_data2 = (1, 2.8, «Привет, мир»)
печать (my_data2)
# кортеж строки и списка
my_data3 = ("Книга", [1, 2, 3])
печать (my_data3)
# кортежей внутри другого кортежа
# вложенный кортеж
my_data4 = ((2, 3, 4), (1, 2, "привет"))
печать (my_data4) Выход:
(«привет», «привет», «пока»)
(1, 2.8, 'Hello World')
('Книга', [1, 2, 3])
((2, 3, 4), (1, 2, 'привет')) 2.2 Пустой кортеж:
# пустой кортеж my_data = ()
2.3 Кортеж с единственным элементом:
Примечание. Когда кортеж содержит только один элемент, мы должны поставить запятую после элемента, иначе Python не будет рассматривать его как кортеж.
# кортеж с одним элементом данных my_data = (99,)
Если мы не поставим запятую после 99 в приведенном выше примере, тогда python будет рассматривать my_data как переменную типа int, а не как кортеж.
3. Как получить доступ к элементам кортежа
Мы используем индексы для доступа к элементам кортежа. Давайте рассмотрим несколько примеров, чтобы понять работу.
3.1 Доступ к элементам кортежа с использованием положительных индексов
У нас также могут быть отрицательные индексы в кортеже, мы обсудили это в следующем разделе. Индексы начинаются с 0, поэтому мы используем 0 для доступа к первому элементу кортежа, 1 для доступа ко второму элементу и так далее.
# кортеж строк my_data = («привет», «привет», «пока») # отображение всех элементов печать (my_data) # доступ к первому элементу # печать "привет" печать (my_data [0]) # доступ к третьему элементу # выводит "пока" печать (my_data [2])
Выход:
(«привет», «привет», «пока») Здравствуй до свидания
Примечание:
1. TypeError : Если вы не используете целочисленные индексы в кортеже. Например, my_data [2.0] вызовет эту ошибку. Индекс всегда должен быть целым числом.
2. IndexError : Индекс вне допустимого диапазона. Эта ошибка возникает, когда мы упоминаем индекс, не входящий в диапазон. Например, если в кортеже 5 элементов, и мы пытаемся получить доступ к 7-му элементу, возникнет эта ошибка.
3.2 Отрицательные индексы в кортежах
Подобно списку и строкам, мы можем использовать отрицательные индексы для доступа к элементам кортежа с конца.
-1 для доступа к последнему элементу, -2 для доступа ко второму последнему и так далее.
my_data = (1, 2, «Кевин», 8.9) # доступ к последнему элементу # отпечатков 8,9 печать (my_data [-1]) # отпечатков 2 печать (my_data [-3])
Выход:
8,9 2
3.3 Доступ к элементам из вложенных кортежей
Давайте разберемся, как двойные индексы используются для доступа к элементам вложенного кортежа. Первый индекс представляет элемент основного кортежа, а второй индекс представляет элемент вложенного кортежа.
В следующем примере, когда я использовал my_data [2] [1], он получил доступ ко второму элементу вложенного кортежа. Потому что 2 представляет третий элемент основного кортежа, который является кортежем, а 1 представляет второй элемент этого кортежа.
my_data = (1, «Стив», (11, 22, 33)) # выводит 'v' печать (my_data [1] [3]) # отпечатков 22 print (my_data [2] [1])
Выход:
в 22
4. Операции, которые могут быть выполнены с кортежем в Python
Давайте посмотрим, какие операции можно выполнять с кортежами в Python.
4.1 Изменение элементов кортежа
Мы не можем изменить элементы кортежа, потому что элементы кортежа неизменяемы. Однако мы можем изменить изменяемые элементы вложенных элементов. Например, в следующем коде мы изменяем элемент списка, который присутствует внутри кортежа. Элементы списка можно изменять, поэтому это разрешено.
my_data = (1, [9, 8, 7], «Мир») печать (my_data) # изменение элемента списка # это верно, потому что список изменяемый my_data [1] [2] = 99 печать (my_data) # изменение элемента кортежа # Это недопустимо, поскольку элементы кортежа неизменяемы # TypeError: объект 'tuple' не поддерживает назначение элементов # my_data [0] = 101 # print (my_data)
Выход:
(1, [9, 8, 7], "мир") (1, [9, 8, 99], «Мир»)
4.2 Операция удаления кортежа
Мы уже обсуждали выше, что элементы кортежа неизменяемы, что также означает, что мы не можем удалить элементы кортежа. Однако возможно удаление всего кортежа.
my_data = (1, 2, 3, 4, 5, 6) печать (my_data) # невозможно # ошибка # del my_data [2] # возможно удаление всего кортежа дель my_data # невозможно # ошибка # потому что my_data удалена # print (my_data)
Выход:
(1, 2, 3, 4, 5, 6)
4.3 Операция нарезки кортежей
my_data = (11, 22, 33, 44, 55, 66, 77, 88, 99) печать (my_data) # элементы с 3-го по 5-й # отпечатков (33, 44, 55) печать (my_data [2: 5]) # элементов от начала до четвертого # отпечатки (11, 22, 33, 44) печать (my_data [: 4]) # элемент с 5-го до конца # отпечатков (55, 66, 77, 88, 99) печать (my_data [4:]) # элемент с 5-го по второй последний # отпечатки (55, 66, 77, 88) печать (my_data [4: -1]) # отображение всего кортежа print (my_data [:])
Выход:
(11, 22, 33, 44, 55, 66, 77, 88, 99) (33, 44, 55) (11, 22, 33, 44) (55, 66, 77, 88, 99) (55, 66, 77, 88) (11, 22, 33, 44, 55, 66, 77, 88, 99)
4.4 Тест на членство в кортежах
из : проверяет, существует ли элемент в указанном кортеже.
не в : проверяет, не существует ли элемент в указанном кортеже.
my_data = (11, 22, 33, 44, 55, 66, 77, 88, 99) печать (my_data) # правда печать (22 в my_data) # ложный печать (2 в my_data) # ложный print (88 нет в my_data) # правда print (101 нет в my_data)
Выход:
(11, 22, 33, 44, 55, 66, 77, 88, 99) Правда Ложь Ложь Правда
4.5 Итерация кортежа
# кортеж фруктов
my_tuple = («Яблоко», «Апельсин», «Виноград», «Банан»)
# перебор элементов кортежа
для фруктов в my_tuple:
печать (фрукты) Выход:
Яблоко оранжевый Виноград Банан
.
Структура данных кортежа Python, объясненная на примерах
В этом классе вы узнаете, что такое кортеж Python, что вы можете с ним делать и как использовать в программах. Более того, вы, по сути, узнаете, как создавать кортежи и выполнять различные операции, такие как упаковка, распаковка, нарезка, сравнение и удаление.
Кортеж Python — пошаговое обучение
Что такое кортеж в Python?
Кортеж Python — это структура данных типа коллекции, которая неизменна по дизайну и содержит последовательность разнородных элементов.Он работает почти как список Python , но со следующими отличиями.
- Кортежи хранят фиксированный набор элементов и не допускают изменений, тогда как в списке есть возможность обновлять его содержимое.
- В списке используются квадратные скобки для открытия и закрытия, тогда как в кортеже круглые скобки обозначают вложение.
Кортеж может пригодиться программистам в разных ситуациях. Мы обсудим их позже в этом руководстве.
Структура данных кортежа Python
Как создать экземпляр кортежа в Python?
Вы можете создать кортеж, поместив последовательность желаемых элементов, разделенных запятыми, внутри пары круглых скобок (), т.е.е., круглые скобки.
Обратите внимание, что вы можете создать кортеж даже без скобок. Кроме того, элементы кортежа могут иметь любые допустимые типы данных Python в диапазоне от чисел , строк , списков и т. Д.
Простые примеры создания кортежа с разными входами
# создаем пустой кортеж
py_tuple = ()
print ("Пустой кортеж:", py_tuple)
# создаем кортеж без круглых скобок
py_tuple = 33, 55, 77
print ("Набор кортежей без скобок:", py_tuple, "type:", type (py_tuple))
# создаем кортеж чисел
py_tuple = (33, 55, 77)
print ("Набор чисел:", py_tuple)
# создаем кортеж из смешанных чисел
# например integer, float, мнимый
py_tuple = (33, 3.3, 3 + 3j)
print ("Набор смешанных чисел:", py_tuple)
# создаем кортеж из смешанных типов данных
# такие как числа, строки, списки
py_tuple = (33, "33", [3, 3])
print ("Кортеж смешанных типов данных:", py_tuple)
# создаем кортеж из кортежей
# т.е. вложенный кортеж
py_tuple = (('х', 'y', 'z'), ('X', 'Y', 'Z'))
print ("Кортеж кортежей:", py_tuple) Выполнение приведенного выше фрагмента кода приведет к следующему результату.
# output Пустой кортеж: () Набор кортежей без скобок: (33, 55, 77) type:Набор чисел: (33, 55, 77) Набор смешанных чисел: (33, 3.3, (3 + 3j)) Кортеж смешанных типов данных: (33, '33', [3, 3]) Кортеж кортежей: (('x', 'y', 'z'), ('X', 'Y', 'Z'))
Использование встроенной функции «tuple ()» для создания кортежа
Мы можем вызвать функцию кортежа и получить желаемый результат. См. Пример ниже.
# создание кортежа из набора
>>> py_tuple = кортеж ({33, 55, 77})
>>> тип (py_tuple)
<класс 'кортеж'>
>>> py_tuple
(33, 77, 55)
# создание кортежа из списка
>>> py_tuple = кортеж ([33, 55, 77])
>>> тип (py_tuple)
<класс 'кортеж'>
>>> py_tuple
(33, 55, 77) Создание кортежа первого размера
В приведенном ниже примере мы пытаемся создать кортеж из одного элемента.Достичь этого не так просто, как кажется.
# Одиночный элемент, окруженный круглыми скобками, создаст строку вместо кортежа
>>> py_tuple = ('одиночный')
>>> тип (py_tuple)
<класс 'str'>
# Вам нужно поставить запятую после первого элемента, чтобы создать кортеж размером "один"
>>> py_tuple = ('одиночный',)
>>> тип (py_tuple)
<класс 'кортеж'>
# Вы можете использовать список из одного элемента и преобразовать его в кортеж
>>> py_tuple = кортеж (['одиночный'])
>>> тип (py_tuple)
<класс 'кортеж'>
# Вы можете использовать набор из одного элемента и преобразовать его в кортеж
>>> py_tuple = кортеж ({'одиночный'})
>>> тип (py_tuple)
<класс 'кортеж'> Как получить доступ к кортежу в Python?
Python предоставляет различные интуитивно понятные механизмы для доступа к одному или нескольким элементам из кортежа.
Через индексирование
Самым простым из них является метод прямого доступа, при котором вы используете оператор индекса [] для выбора элемента из кортежа. Вы можете начать индексацию с 0-й позиции.
Это означает, что если кортеж содержит десять элементов, то индекс будет начинаться с 0-го и заканчиваться на 9-й позиции. Нарушение границ кортежа приведет к IndexError.
Обратите внимание, что индекс всегда является целым числом. Вы не должны использовать числа с плавающей запятой или любую другую форму чисел для индексации.Это приведет к ошибке TypeError.
Далее, если кортеж содержит другие кортежи в качестве своих элементов, вам нужно будет индексировать элементы кортеж за кортежем.
vowel_tuple = ('а', 'е', 'я', 'о', 'и')
print ("Кортеж:", vowel_tuple, "Length:", len (vowel_tuple))
# Индексирование первого элемента
print ("OP (vowel_tuple [0]):", vowel_tuple [0])
# Индексирование последнего элемента
print ("OP (vowel_tuple [длина-1]):", vowel_tuple [len (vowel_tuple) - 1])
# Индексирование несуществующего члена
# вызовет IndexError
пытаться:
печать (набор_гласных [набор_гласных) +1])
кроме исключения как ex:
print ("OP (vowel_tuple [длина + 1]) Ошибка:", пример)
# Индексирование с нецелым индексом
# вызовет TypeError
пытаться:
print (vowel_tuple [0.0])
кроме исключения как ex:
print ("OP (vowel_tuple [0.0]) Ошибка:", пример)
# Индексирование кортежа кортежей
t_o_t = (('янь', 'фев', 'мар'), ('вс', 'пн', 'ср'))
# Доступ к элементам из первого подкортежа
print ("OP (t_o_t [0] [2]):", t_o_t [0] [2])
# Доступ к элементам из второго подкортежа
print ("OP (t_o_t [1] [2]):", t_o_t [1] [2]) После выполнения приведенного выше примера кода будет показан следующий результат:
# output
Кортеж: ('a', 'e', 'i', 'o', 'u') Длина: 5
OP (vowel_tuple [0]): а
OP (vowel_tuple [длина-1]): u
OP (vowel_tuple [length + 1]) Ошибка: индекс кортежа вне допустимого диапазона
OP (vowel_tuple [0.0]) Ошибка: индексы кортежа должны быть целыми числами или фрагментами, а не с плавающей точкой.
OP (t_o_t [0] [2]): мар
OP (t_o_t [1] [2]): ср Через обратную индексацию
Кортеж
Python поддерживает обратную индексацию, то есть доступ к элементам с использованием значений индекса (-ve).
Обратное индексирование работает следующим образом.
- Индекс -1 представляет последний элемент.
- Индекс со значением -2 будет относиться ко второму элементу с задней стороны.
Для большей ясности просмотрите приведенный ниже пример.
>>> гласные = ('a', 'e', 'i', 'o', 'u')
>>> гласные
('а', 'е', 'я', 'о', 'и')
>>> гласные [-1]
'ты'
>>> гласные [-2]
'о'
>>> гласные [-5]
'а'
>>> гласные [-6]
Отслеживание (последний вызов последний):
Файл "", строка 1, в
гласные [-6]
IndexError: индекс кортежа вне диапазона Через оператор нарезки
Если вам нужно получить доступ не к одному, а к нескольким элементам кортежа, можно использовать оператор среза Python.
Единственное двоеточие, т. Е. «:», Представляет оператор нарезки в Python.
Давайте посмотрим, как можно использовать оператор «:» на примере ниже.
>>> будние дни = ('пн', 'вт', 'ср', 'чт', 'пт', 'сб', 'вс')
>>> будни
('пн', 'вт', 'ср', 'чт', 'пт', 'сб', 'вс')
# доступ к элементам, оставляя первый
>>> будние дни [1:]
(Вт, ср, чт, пт, сб, вс)
# доступ к элементам между первой и пятой позициями
# без учета первой и пятой позиции
>>> будни [1: 5]
(Вт, ср, чт, пт)
# доступ к элементам после пятой позиции
>>> будни [5:]
('сидел', 'солнце')
# доступ к первым пяти элементам
>>> будни [: 5]
('пн', 'вт', 'ср', 'чт', 'пт')
# доступ к элементам, которые появляются после
# считая пять с тыла
>>> будние дни [: - 5]
('пн', 'вт')
# доступ к пяти элементам сзади
>>> будние дни [-5:]
('ср', 'чт', 'пт', 'сб', 'вс')
# доступ к элементам от начала до конца
>>> будние дни [:]
('пн', 'вт', 'ср', 'чт', 'пт', 'сб', 'вс') Как изменить / обновить кортеж в Python?
Поскольку кортежи неизменяемы, кажется, что нет возможности их изменить.
После того, как вы назначите набор элементов кортежу, Python не позволит ему измениться. Но есть одна загвоздка: что, если элементы, которые вы устанавливаете, можно изменять.
Если есть такой случай, вы можете изменить элементы вместо непосредственного изменения кортежа.
Более того, вы даже можете установить для кортежа разные значения. Посмотрите на пример ниже.
py_tuple = (22, 33, 55, 66, [88, 99])
print ("Кортеж перед изменением:", py_tuple)
# Попробуем изменить py_tuple
# Он вернет TypeError
пытаться:
py_tuple [0] = 11
кроме исключения как ex:
print ("Ошибка OP (py_tuple [0]):", пример)
# Мы можем изменить значения изменяемых
# элементов внутри py_tuple i.е. список
py_tuple [4] [0] = 77
py_tuple [4] [1] = 88
print ("Кортеж после модификации:", py_tuple)
# Мы можем присвоить кортежу новые данные
py_tuple = ('пн', 'вт,' ср ')
print ("Кортеж после переназначения:", py_tuple) После выполнения пример даст следующий результат.
# output
Кортеж перед изменением: (22, 33, 55, 66, [88, 99])
OP (py_tuple [0]) Ошибка: объект "кортеж" не поддерживает назначение элементов.
Кортеж после модификации: (22, 33, 55, 66, [77, 88])
Кортеж после переназначения: ('пн', 'вт', 'ср') Более того, вы можете расширить поведение кортежа с помощью операторов + (конкатенация) и * (повторение) .
Оператор «плюс» помогает объединить два отдельных кортежа.
>>> first_tuple = ('р', 'у', 'т')
>>> second_tuple = ('ч', 'о', 'п')
>>> full_tuple = first_tuple + second_tuple
>>> full_tuple
('p', 'y', 't', 'h', 'o', 'n')
>>> И оператор звездочки помогает вам повторять элементы в кортеже указанное количество раз.
>>> init_tuple = ("вилка",)
>>> fork_tuple = init_tuple * 5
>>> fork_tuple
('вилка', 'вилка', 'вилка', 'вилка', 'вилка')
>>> Как удалить / удалить кортеж в Python?
Неизменяемость кортежа снова помешает вам удалить его в программе Python.Вы не можете удалить кортеж напрямую, но вот кое-что, что может помочь.
Ключевое слово del в Python может заставить вас удалить кортеж. Посмотрите на пример ниже.
py_tuple = ('р', 'у', 'т', 'ч', 'о', 'н')
# нельзя удалить конкретный элемент из кортежа
пытаться:
дель py_tuple [0]
кроме исключения как ex:
print ("Ошибка OP (del py_tuple [0]):", пример)
# но вы можете удалить весь кортеж
дель py_tuple
пытаться:
печать (py_tuple)
кроме исключения как ex:
print ("print (py_tuple) => Ошибка:", например) Выполнение вышеуказанного кода даст вам следующий результат.
# output del py_tuple [0] => Ошибка: объект 'tuple' не поддерживает удаление элемента print (py_tuple) => Ошибка: имя 'py_tuple' не определено
Первая строка вывода сообщает, что мы не можем удалить определенный элемент из кортежа. Но во второй строке написано, что мы уже удалили его и пытаемся распечатать неопределенный объект.
Разные операции с кортежами
Тестирование членства в кортеже Python
Так же, как мы это сделали в Python, установили , здесь также ключевое слово «in» поможет нам выполнить тест членства в кортеже.
>>> py_tuple = ('р', 'у', 'т', 'ч', 'о', 'н')
>>> print ("Первый тест: существует ли 'p'?", 'p' в py_tuple)
Первый тест: существует ли «p»? Правда
>>> print ("Второй тест: существует ли 'z'?", 'z' в py_tuple)
Второй тест: существует ли «z»? Ложь
>>> print («Третий тест: существует ли 'n'?», 'n' в py_tuple)
Третий тест: существует ли «н»? Правда
>>> print («Последний тест: не существует?», «t» нет в py_tuple)
Последний тест: "Не существует"? Ложь
>>> Обход кортежа Python
Вы можете сформировать цикл for и один за другим обращаться ко всем элементам в кортеже.
>>> py_tuple = ('р', 'у', 'т', 'ч', 'о', 'н')
>>> для элемента в py_tuple:
print ("Элемент:", элемент)
Пункт: p
Пункт: y
Пункт: т
Пункт: h
Пункт: o
Артикул: n Использование кортежей Python
Используется для группировки данных
Кортеж обеспечивает быстрый способ группировки и упорядочивания данных. Он может помочь вам объединить любое количество элементов в единое целое.
Они могут помочь нам представить информацию в форме записей, таких как запись о сотруднике.Кортеж позволяет нам группировать связанную информацию и использовать ее как единое целое.
>>> emp_records = ('john', 'hr', 2010, 'robert', 'account', 2015, 'bill', 'mis', 2018)
>>> emp_records [3]
'Роберт' Присвойте кортежу
Кортеж
Python поддерживает очень интуитивно понятную функцию, известную как «присвоение кортежей». Это позволяет нам назначить кортеж переменных слева от оператора для инициализации из кортежа справа.
>>> emp_records = ('john', 'hr', 2010, 'robert', 'account', 2015, 'bill', 'mis', 2018)
>>> (emp_name, emp_dept, emp_join_date) = emp_records [0: 3]
>>> emp_name
'Джон'
>>> emp_dept
'час'
>>> emp_join_date
2010 Использование кортежей в функциях как возвращаемых значений
Обычно функция возвращает только одно значение.Однако мы можем ввести кортеж и установить его как возвращаемое значение для функции.
Это означает, что мы можем объединить несколько значений и сохранить их в кортеж и, наконец, вернуть его. Это может быть очень удобно в ситуациях, когда мы хотим узнать часы, минуты, секунды, затраченные на работу, или чтобы получить количество различных типов аксессуаров или цены на несколько книг, написанных определенным автором.
def квадрат (n1, n2):
возврат (n1 * n1, n2 * n2)
print (введите (квадрат (2, 3))) # output <класс 'кортеж'>
Смешанные структуры данных в виде кортежей
Кортежи — это тип контейнера, который может включать другой кортеж как элемент.Мы называем такой объект вложенным кортежем.
Это может помочь в визуализации информации на более широком уровне. Например, если нам нужно вести подсчет сотрудников в каждом отделе вместе с их именами, должностями и зарплатами, вложенные кортежи могут позволить нам делать это эффективно.
сотрудников = [
("HR", 2, [('david', 'manager', 100000), ('bruno', 'asst. Manager', 50000)])
("ИТ", 2, [('Кирк', 'руководитель группы', 150000), ('Мэтт', 'инженер', 45000)])
("Продажи", 2, [('билли', 'руководитель отдела продаж', 250000), ('Том', 'руководитель', 95000)])
] Быстрое завершение — кортеж Python
В этом руководстве мы рассмотрели «Кортеж Python» , который является одной из основных доступных структур данных.Следовательно, крайне необходимо, чтобы вы знали, как кортежи работают в Python.
Теперь, если вы узнали что-то из этого класса, поделитесь этим со своими коллегами. Кроме того, подключитесь к нашим учетным записям в социальных сетях ( Facebook / Twitter ), чтобы получать своевременные обновления.
Бест,
TechBeamers
.