Кортеж python 3: Кортежи в Python (tuple) — методы, сортировка, сравнение, добавление

Кортежи python для начинающих. Функции и основные операции с tuples

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

В этом руководстве вы познакомитесь с кортежами Python в подробностях:

• Узнаете, как их создавать. Увидите, что значит неизменяемый тип на примерах
• Разберетесь, чем кортежи в Python отличаются от списков
• Познакомитесь с операциями: срезами, конкатенацией, умножением и так далее
• Увидите встроенные функции
• Научитесь присваивать сразу несколько значений кортежами

Кортеж Python

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

Кортежи создают с помощью круглых скобок (). Для создания нужно написать следующее:

cake = ('c','a','k','e') 
print(type(cake))

Примечание: type() — это встроенная функция для проверки типа данных переданного параметра.

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

mixed_type = ('C',0,0,'K','I','E')
for i in mixed_type:
    print(i,":",type(i))

C : 
0 : 
0 : 
K : 
I : 
E : 

# Попробуйте изменить 0 на «O»
mixed_type[1] = "O"

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
----> 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))

Кортежи против списков

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

numbers_tuple = (1,2,3,4,5)
numbers_list = [1,2,3,4,5]
# Добавим число в кортеж
numbers_tuple.append(6)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
 in ()
      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' со списком в качестве одного из его элементов.
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)
 in ()
----> 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)
 in ()
      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))

min() и max()

Функция max()q возвращает самый большой элемент последовательности, а min() — самый маленький. Возьмем следующий пример:

print(max(a))
print(min(a))

5
A

Эти функции можно использовать и для кортежей со строками.

# Строка «Apple» автоматически преобразуется в последовательность символов.
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. А в качестве бонуса научились присваивать нескольким переменным разные значения.

Кортежи (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) #output
>>> q
(1, 2) #output
 

Будьте осторожны при размещении изменяемых объектов, таких как lists , внутри кортежей. Это может привести к очень запутанным результатам при их изменении. Например:

>>> t = (1, 2, 3, [1, 2, 3])
(1, 2, 3, [1, 2, 3]) #output
>>> t[3] += [4, 5]
 

Будет как поднимать ошибку и изменить содержимое списка в кортеже:

TypeError: 'tuple' object does not support item assignment
>>> t
(1, 2, 3, [1, 2, 3, 4, 5]) #output

Вы можете использовать += оператору «добавить» в кортеж — это работает, создавая новый кортеж с новым элементом вы «добавленным» и назначить его в текущей переменной; старый кортеж не изменен, но заменен!

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

Кортеж является элементарным измеримым и уравновешенным

hash( (1, 2) )  # ok
hash(([], {"hello"})  # не ок, поскольку списки и множества не хешируемы

Таким образом, кортеж можно поставить внутри set или в качестве ключа в dict только тогда , когда каждый из его элементов может.

{ (1, 2) } #  ок
{([], {"hello"}) ) # не ок

Кортеж

Синтаксически, кортеж — это список значений через запятую:

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
t2 = 'a',             # использовать эту нотацию PEP8 не рекомендует
t2 =('a', )          # использовать эта нотацию PEP8 не рекомендует
 

Другой способ создать кортеж является встроенной функцией tuple .

t = tuple('lupins')
print(t)              #('l', 'u', 'p', 'i', 'n', 's')
t = tuple(range(3))
print(t)              # (0, 1, 2)

Эти примеры основаны на материалах из книги Think Python Аллен B. Дауни.

Упаковка и распаковка кортежей

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

a = 1, 2, 3   # a является кортежем (1, 2, 3)
 

а также

a = (1, 2, 3) # a является кортежем (1, 2, 3)
 

эквивалентны. Присваивания a = 1, 2, 3 также называют упаковки , потому что пакеты значения вместе в кортеже.

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

a = 1  # a имеет значение 1
a = 1, # a это кортеж (1,)
 

Запятая нужна также, если вы используете скобки

a = (1,) # a это кортеж (1,)
a = (1)  # a имеет значение 1 и не является кортежем
 

Для распаковки значений из кортежа и выполнения нескольких назначений используйте

# 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 это означение 1
x  = 1,  # x это кортеж (1,)
 

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

first, *more, last = (1, 2, 3, 4, 5)
#first == 1
#more == [2, 3, 4]
#last == 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) # 1
cmp(tuple2, tuple1) # -1
cmp(tuple1, tuple3) # 0
 

Длина кортежа

Функция len возвращает общую длину кортежа

len(tuple1) # 5
 

Max кортежа

Функция max возвращает элемент из кортежа с максимальным значением

max(tuple1) #'e'
max(tuple2) # '3'
 

Min кортежа

Функция min возвращает элемент из кортежа со значением min

min(tuple1) # 'a'
min(tuple2) # '1'
 

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

Встроенная функция tuple преобразует список в кортеж.

list = [1,2,3,4,5]
tuple(list)
>>>Out: (1, 2, 3, 4, 5)
 

Конкатенация кортежей

Используйте + для конкатенации двух кортежей

tuple1 + tuple2
>>>Out:('a', 'b', 'c', 'd', 'e', '1', '2', '3')

Кортеж Python 3 | Понимание переменных кортежей в Python 3

Кортеж Python 3 содержит список объектов Python, которые нельзя изменить. Как и списки, кортежи состоят из последовательностей. Наиболее существенное различие между кортежами и списками заключается в том, что кортежи, в отличие от списков, не могут быть изменены. В кортежах используются круглые скобки, а в списках — квадратные скобки. Поместить значения, разделенные запятыми, в кортеж так же просто. Эти значения, разделенные запятыми, при желании можно поместить в круглые скобки.

Что такое кортеж Python 3?

• Кортежи — это переменная, которая позволяет нам хранить множество объектов в одном месте. Tuple — один из четырех встроенных типов данных Python для хранения коллекций данных; остальные три — Dictionary, List и Set, все они имеют разные свойства и приложения.
• Круглые скобки используются для записи кратных чисел. В python кортеж аналогичен списку. Мы не можем использовать float или другие типы, потому что индекс содержит целые числа.

Python 3 Значения доступа к кортежу

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

1. Доступ к кортежам с помощью индексирования

• Мы используем оператор индекса для извлечения элемента в кортеже, где индекс начинается с 0.
• В результате индексы варьируются от 0 до 5 для кортежа с 6 элементами. Ошибка индекса будет вызвана, если мы попытаемся получить доступ к форме индекса снаружи.
• Отличие состоит в том, что после назначения кортежа мы не можем изменить его элементы, тогда как мы можем изменить содержимое списка.
• В приведенном ниже примере показан доступ к кортежам посредством индексации в python.

Код:

 py_tup = ('A', 'Q', 'S', 'T', 'B', 'N')
печать (py_tup [0])
print (py_tup [5]) 

Вывод:

2.

Доступ к кортежам с использованием отрицательной индексации

• Последовательности Python поддерживают отрицательную индексацию. Последний элемент представлен индексом -1, предпоследний элемент индексом -2 и так далее.
• В приведенном ниже примере показано, как доступ к кортежам через отрицательную индексацию в python выглядит следующим образом.

Код:

 py_tup = ('A', 'Q', 'S', 'T', 'B', 'N')
печать (py_tup [-1])
print (py_tup [-4]) 

Вывод:

3. Доступ к кортежам с помощью срезов

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

Код:

 py_tup = ('A', 'Q', 'S', 'T', 'B', 'N')
печать (py_tup [2:4])
print (py_tup [:-5]) 

Вывод:

Python 3 tuple delete

• Элементы кортежа не могут быть изменены. Из-за этого мы не можем удалять или удалять записи из кортежа.
• Невозможно удалить отдельные элементы кортежа. Конечно, нет ничего плохого в создании нового кортежа, исключающего нежелательные компоненты.
• Кортежи неизменяемы; таким образом, мы не можем удалить из них ни одного элемента. Используя метод del, мы можем удалить весь кортеж.
• В приведенном ниже примере показано, что мы не можем удалить одно значение кортежа из элемента. В приведенном ниже примере мы пытаемся удалить один элемент, но выдает ошибку.

Код:

 py_tup = ('A', 'Q', 'S', 'T', 'B', 'N')
дель py_tup (tup1 [0])
print (py_tup) 

Вывод:

• В приведенном ниже примере показано удаление всех элементов из кортежа в python. В приведенном ниже примере мы удаляем кортеж py_tup.

Код:

 py_tup = ('A', 'Q', 'S', 'T', 'B', 'N')
del py_tup 

Вывод:

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

Код:

 py_tup = ('A', 'Q', 'S', 'T', 'B', 'N')
дель py_tup
print (py_tup) 

Вывод:

Python 3 Операции с кортежами

Мы можем выполнить следующие операции с кортежами в python следующим образом.

1. Проверка членства в кортеже

Используя эту операцию кортежа в python, мы можем проверить, существует ли элемент в кортеже или нет, используя имя ключевого слова, как в.

Код:

 py_tup = ('A', 'Q', 'S', 'T', 'B', 'N')
печать («а» в py_tup)
print('A' in py_tup) 

Вывод:

2.

Итерация с использованием кортежа

Для итерации каждого элемента мы используем цикл for в python. В приведенном ниже примере показано, как итерация с использованием кортежа выглядит следующим образом.

Код:

 для stud_name в ('ABC', 'PQR'):
    print("Студент", stud_name) 

Вывод:

3. Создание кортежа

В приведенном ниже примере показано создание кортежа в python следующим образом. Мы создаем имя кортежа как py_tup. Код:

 Py_tup = ('ABC', 'PQR')
print (Py_tup) 

Вывод:

4. Объединение кортежей в Python

Мы можем объединить два кортежа в Python, используя «+». В приведенном ниже примере мы объединяем py_tup1 и py_tup2 следующим образом.

Код:

 Py_tup1 = ('ABC', 'PQR')
Py_tup2 = ('11', '12', '13')
печать (Py_tup1)
печать (Py_tup2)
print(Py_tup1 + Py_tup2) 

Вывод:

5.

Повторить элементы кортежа

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

Код:

 py_tup = ('кортеж',)*3
печать (py_tup) 

Вывод:

Функции кортежа Python 3

Ниже приведена функция кортежа Python 3 следующим образом.

1. Len – Функция Len используется для нахождения длины кортежей. В приведенном ниже примере функция len показана следующим образом.

Код:

 py_tup = ('25', '35', '45')
print(len(py_tup)) 

Вывод:

2. Max – Функция Max используется для поиска максимального количества элементов из кортежей. В приведенном ниже примере показаны функции max следующим образом.

Код:

 py_tup = ('25', '35', '45')
print(max(py_tup)) 

Вывод:

3. Min – Функция Min используется для поиска наименьшего элемента из кортежей. В приведенном ниже примере функция min показана следующим образом.

Код:

 py_tup = ('25', '35', '45')
print(min(py_tup)) 

Вывод:

4. Кортеж — Эта функция преобразует список в кортеж. В приведенном ниже примере показаны примеры функций кортежа следующим образом.

Код:

 py_tup = кортеж (('25', '35', '45'))
print (py_tup) 

Вывод:

Заключение

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

Рекомендуемые статьи

Это руководство по Python 3 Tuple. Здесь мы обсуждаем определение, что такое кортеж Python 3?, примеры с реализацией кода. Вы также можете ознакомиться со следующими статьями, чтобы узнать больше –

1. Тест Python Z
2. Целое число Python в строку
3. Ошибка памяти Python
4. Python Timeit

Кортежи Python

Предыдущий

Следующий

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

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

 tpl=() # пустой кортеж
печать (тпл)

имена = ('Джефф', 'Билл', 'Стив', 'Яш') # строковый кортеж
печать (имена)

nums = (1, 2, 3, 4, 5) # целочисленный кортеж
печать (числа)

employee=(1, 'Steve', True, 25, 12000) # разнородный кортеж данных
печать (сотрудник)
 

 ()
(«Джефф», «Билл», «Стив», «Яш»)
(1, 2, 3, 4, 5)
(1, 'Стив', Правда, 25, 12000)
 

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

 name = 'Джефф', 'Билл', 'Стив', 'Яш' # строковый кортеж
печать (имена)

nums = 1, 2, 3, 4, 5 # целочисленный кортеж
печать (числа)

employee=1, 'Steve', True, 25, 12000 # гетерогенный кортеж данных
печать (сотрудник)
 

 («Джефф», «Билл», «Стив», «Яш»)
(1, 2, 3, 4, 5)
(1, 'Стив', Правда, 25, 12000)
 

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

 name = ('Jeff') # считается строковым типом
печать (имена)
печать (тип (имена))

имена = ('Джефф',) # кортеж с одним элементом
печать (имена)
печать (тип (имена))
 

 'Джефф'
<класс 'строка'>
(Джефф)
<класс 'кортеж'>
 

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

Доступ к каждому элементу кортежа осуществляется по индексу в квадратных скобках []. Индекс начинается с нуля и заканчивается (количество элементов — 1), как показано ниже.

 имени = ("Джефф", "Билл", "Стив", "Яш")
print(names[0]) # печатает 'Джефф'
print(names[1]) # печатает 'Счет'
print(names[2]) # печатает 'Стив'
print(names[3]) # печатает 'Яш'

числа = (1, 2, 3, 4, 5)
print(nums[0]) # печатает 1
print(nums[1]) # печатает 2
print(nums[4]) # печатает 5
 

 Джефф
Билл
Стив
Яш
1
2
5
 

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

 имени = ("Джефф", "Билл", "Стив", "Яш")
print(names[-4]) # печатает 'Джефф'
print(names[-3]) # печатает 'Счет'
print(names[-2]) # печатает 'Стив'
print(names[-1]) # печатает 'Яш'
 

 Джефф
Билл
Стив
Яш
 

Если элемент с указанным индексом не существует, будет выдана ошибка «индекс вне диапазона».

 >>> имена[5]
Traceback (последний последний вызов):
Файл "", строка 1, в 
IndexError: индекс кортежа вне допустимого диапазона
 

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

 имени = ("Джефф", "Билл", "Стив", "Яш")
a, b, c, d = имена # распаковать кортеж
напечатать (а, б, в, г)
 

 Джефф Билл Стив Яш
 

Обновление или удаление элементов кортежа

Кортеж неизменяемый. Таким образом, после создания кортежа любые операции, направленные на изменение его содержимого, не допускаются. Например, попытка изменить или удалить элемент кортежа имен приведет к ошибке.

 >>> имена = ('Джефф', 'Билл', 'Стив', 'Яш')
>>> имена[0] = 'Свати'
Traceback (последний последний вызов):
Файл "", строка 1, в 
TypeError: объект 'tuple' не поддерживает назначение элементов

>>> удалить имена[0]
Traceback (последний последний вызов):
Файл "", строка 1, в 
TypeError: объект 'tuple' не поддерживает удаление элемента
 

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

 >>> удалить имена 

Класс кортежа

Базовым типом кортежа является класс кортежа. Проверьте тип переменной с помощью функции type() .

 имени = ("Джефф", "Билл", "Стив", "Яш")
print('тип имени: ', тип(имена))

числа = (1,2,3,4,5)
print('тип чисел: ', тип(числа))
 

 тип имен: 
тип чисел: 
 

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

 tpl = tuple('Hello') # преобразует строку в кортеж
печать (тпл)
tpl = tuple([1,2,3,4,5]) # преобразует список в кортеж
печать (тпл)
tpl = tuple({1,2,3,4,5}) # преобразует набор в кортеж
печать (тпл)
tpl = tuple({1:"One",2:"Two"}) # преобразует словарь в кортеж
печать (тпл)
 

 ("Ч", "е", "л", "л", "о")
(1,2,3,4,5)
(1,2,3,4,5)
(1,2)
 

Операции с кортежами

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

Оператор	Пример
Оператор + возвращает кортеж, содержащий все элементы первого и второго объекта кортежа.	>>> t1=(1,2,3) >>> t2=(4,5,6) >>> т1+т2 (1, 2, 3, 4, 5, 6) >>> t2+(7,) (4, 5, 6, 7)
Оператор * объединяет несколько копий одного и того же кортежа.	>>> t1=(1,2,3) >>> т1*4 (1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3)
[] оператор Возвращает элемент по заданному индексу. Отрицательный индекс считает позицию с правой стороны.	>>> t1=(1,2,3,4,5,6) >>> т1[3] 4 >>> т1[-2] 5
Оператор [:] возвращает элементы в диапазоне, указанном двумя индексными операндами, разделенными цифрой 9.0317 : символ . Если первый операнд опущен, диапазон начинается с нуля. Если второй операнд опущен, диапазон идет до конца кортежа.	>>> t1=(1,2,3,4,5,6) >>> t1[1:3] (2, 3) >>> т1[3:] (4, 5, 6) >>> т1[:3] (1, 2, 3)
Оператор в возвращает true, если элемент существует в данном кортеже.	>>> t1=(1,2,3,4,5,6) >>> 5 в т1 Истинный >>> 10 в т1 Ложь
Оператор не в возвращает true, если элемент не существует в данном кортеже. Оставить комментарий Добавить комментарий Отменить ответ Ваш адрес email не будет опубликован. Обязательные поля помечены * Комментарий * Имя * Email * Сайт