Введение

Примеры

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

 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)

 

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

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

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

Синтаксис

Параметры

Примечания