Python Language
Кортеж

Вступление

Синтаксис

• (1, a, "hello") # a должна быть переменной

• () # пустой кортеж

• (1,) # 1-элементный кортеж. (1) не является кортежем.

• 1, 2, 3 # 3-элементный кортеж (1, 2, 3)

замечания

Индексирующие кортежи

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)

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

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

Кортежи в 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 целевая переменная с префиксом * может использоваться как переменная catch-all (см. Раздел «Распаковка итераций» ):

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

Встроенные функции Tuple

Кортежи поддерживают следующие встроенные функции

сравнение

Если элементы одного типа, 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(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')