Индексирование кортежей

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')