Как создать пустой кортеж python
Перейти к содержимому

Как создать пустой кортеж python

  • автор:

Python: Tuple (Кортежи)

Кроме изменяемых списков есть особый вид неизменяемых списков — tuple (кортежи). Кортежи обеспечивают определённую защиту от дурака — намеренных или случайных изменений, а также занимают меньше места в памяти.

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

 tuple = (1, 2, 3, 4, 5) list = [1, 2, 3, 4, 5] print(tuple.__sizeof__()) # 64 print(list.__sizeof__()) # 80 

Пустой кортеж можно создать через пустые круглые скобки.

 emptyTuple = () print(str(type(emptyTuple))) #

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

 oneTuple = ('t', ) 

Узнать длину кортежа можно через len().

 myTuple = (1, 2, 3, 4, 5) print(len(myTuple)) # 5 

Доступ к отдельному элементу осуществляется по индексу.

 myTuple = (1, 2, 3, 4, 5) print(str(myTuple)) print(myTuple[2]) # 3 

Кортежи можно использовать в словарях в качестве ключей.

 myDict = <(1, 1): "Bars">print(myDict.get((1, 1))) 

Можно проводить любые операции, которые не меняют список — методы index(), count().

Можно в один кортеж добавить другой. При этом кортеж внутри кортежа не теряет своей индивидуальности.

Допустим у нас есть старый кошкин дом. Он стал тесным и мы переселили котов в новый дом с другими жильцами.

 old_cat_house = ("Барсик", "Мурзик", "Васька") new_cat_house = ("Рыжик", "Пушок", old_cat_house) # длина нового дома - два жильца и плюс один кортеж (хотя в нём три кота) print(len(new_cat_house)) # 3 # выводим всех котов нового дома print(new_cat_house) #('Рыжик', 'Пушок', ('Барсик', 'Мурзик', 'Васька')) # выводим третий элемент кортежа, который сам является кортежем print(new_cat_house[2]) # ('Барсик', 'Мурзик', 'Васька') # узнать общую длину нового кортежа с элементами второго кортежа print(len(new_cat_house) - 1 + len(new_cat_house[2])) 

Кортеж tuple в Python

Кортежи — это неизменяемые последовательности, обычно используемые для хранения коллекций разнородных данных. Например двойной кортеж, создаваемый встроенной функцией enumerate(). Кортежи также используются в тех случаях, когда требуется неизменяемая последовательность однородных данных.

В Python кортежи представлены классом tuple() .

Кортежи могут быть созданы несколькими способами:

  1. Используя пару скобок для обозначения пустого кортежа: () .
  2. Использование запятой для одиночного кортежа: a, или (a,) .
  3. Разделение элементов запятыми: a, b, c или (a, b, c) :
    Обратите внимание, что запятая создает кортеж, а не скобки. Скобки необязательны, за исключением случая пустого кортежа, или когда они необходимы, чтобы избежать синтаксической двусмысленности.
    Например:
    • f(a, b, c) — вызов функции с тремя аргументами,
    • f((a, b, c)) — вызов функции с кортежем в качестве единственного аргумента.
  4. Использование встроенного класса tuple() :
    • tuple() — создаст пустой кортеж,
    • tuple(iterable) — преобразует контейнер, поддерживающим итерацию в кортеж.

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

Для разнородных коллекций данных, где доступ по имени более понятен, чем доступ по индексу, collections.namedtuple() может быть более подходящим выбором, чем простой объект кортежа.

Примеры использования создания кортежа и преобразования объектов к типу tuple :
# Создание кортежа тип tuple >>> () # () >>> tuple() # () >>> 105, # (105,) >>> 1, 'a', 3, 'b' # (1, 'a', 3, 'b') # Преобразование строки str в кортеж тип tuple >>> tuple('abc') # ('a',' b',' c') # Преобразование списка list в кортеж тип tuple >>> tuple([1, 2, 3]) # (1, 2, 3) # Преобразование множества set в кортеж тип tuple >>> tuple(1, 2, 3>) # (1, 2, 3) # Преобразование генератора в кортеж тип tuple >>> tuple(range(5)) # (0, 1, 2, 3, 4) 
  • КРАТКИЙ ОБЗОР МАТЕРИАЛА.
  • Утиная типизация ‘Duck Typing’
  • Что такое вызываемый объект callable?
  • Как проверить тип переменной/объекта
  • Логический тип данных bool
  • Целые числа int
  • Ограничение длины преобразования целочисленной строки
  • Вещественные числа float
  • Комплексные числа complex
  • Типы последовательностей
  • Список list
  • Кортеж tuple
  • Диапазон range
  • Текстовые строки str
  • Словарь dict
  • Множество set и frozenset
  • Итератор Iterator, протокол итератора
  • Генератор generator и выражение yield
  • Контекстный менеджер with
  • Байтовые строки bytes
  • Байтовый массив bytearray
  • Тип memoryview, буфер обмена
  • Файловый объект file object
  • Универсальный псевдоним GenericAlias
  • Объект объединения Union

Пустой кортеж в Python

Тут надо понимать разница между присваиванием значения элементу списка, и присваиванием значения срезу списка.

Если перед «равно» у вас стоит один элемент списка, то значение справа от «равно» заменяет собой это значение:

l = [1, 2, 3] l[0] = () print(l) # Выведет: [(), 2, 3] 

Но если в левой части присваивания у вас стоит срез списка, то срез — это последовательность, и заменить его можно только другой последовательностью. Поэтому интерпретатор рассматривает правую часть присваивания как последовательность, элементы которой надо присвоить срезу:

l = [1, 2, 3, 4, 5] l[:2] = (9, 9) print(l) # Выведет: [9, 9, 3, 4, 5] 

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

С пустым кортежем всё то же самое, только элементов в нём нет, и вместо взятого среза подставляется ничего.

l = [1, 2, 3, 4, 5] l[:2] = () print(l) # Выведет: [3, 4, 5] 

Соответственно, если вашей целью является заменить срез на один элемент, представляющий собой пустой кортеж, то в правой части должен быть не просто пустой кортеж, а последовательность, содержащая один пустой кортеж:

l = [1, 2, 3] l[:] = [()] print(l) # Выведет: [()] 

Кортежи (tuple) в Python

Индексирование с отрицательными числами начнется с последнего элемента как -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 "", line 1, in 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(([], ) # не ок, поскольку списки и множества не хешируемы 

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

 < (1, 2) ># ок <([], <"hello">) ) # не ок

Кортеж

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

t = 'a', 'b', 'c', 'd', 'e' 

Хотя это и необязательно, обычно заключать кортежи в скобки:

t =('a', 'b', 'c', 'd', 'e') 

Создайте пустой кортеж с круглыми скобками:

t0 = () type(t0) #

Чтобы создать кортеж с одним элементом, необходимо добавить заключительную запятую:

t1 = 'a', type(t1) #

Обратите внимание, что одно значение в скобках не является кортежем:

t2 =('a') type(t2) #

Для создания одноэлементного кортежа необходимо использовать завершающую запятую.

t2 =('a',) type(t2) #

Обратите внимание , что для одноэлементных кортежей рекомендуется (см 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') 

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *