Кортеж в питоне: Кортежи. Курс «Python. Введение в программирование»

Кортежи. Курс «Python. Введение в программирование»

Кортежи (tuple) в Python – это те же списки за одним исключением. Кортежи неизменяемые структуры данных. Так же как списки они могут состоять из элементов разных типов, перечисленных через запятую. Кортежи заключаются в круглые, а не квадратные скобки.

>>> a = (10, 2.13, "square", 89, 'C')
>>> a
(10, 2.13, 'square', 89, 'C')

Из кортежа можно извлекать элементы и брать срезы:

>>> a[3]
89
>>> a[1:3]
(2.13, 'square')

Однако изменять его элементы нельзя:

>>> a[0] = 11
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not 
support item assignment

Также у типа tuple нет методов для добавления и удаления элементов.

Возникает резонный вопрос. Зачем в язык программирования был введен этот тип данных, по-сути представляющий собой неизменяемый список? Дело в том, что иногда надо защитить список от изменений.

>>> a = (10, 2.13, "square", 89, 'C')
>>> b = [1, 2, 3]
>>> c = list(a)
>>> d = tuple(b)
>>> c
[10, 2.13, 'square', 89, 'C']
>>> d
(1, 2, 3)

Рассмотрим случай, когда уместно использовать кортежи. В Python изменяемые объекты передаются в функцию по ссылке. Это значит, что не создается копия объекта, а переменной-параметру присваивается ссылка на уже существующий объект. В итоге, если в теле функции объект изменяется, то эти изменения касаются глобального объекта.

def addNum(seq, num):
    for i in range(len(seq)):
        seq[i] += num
    return seq
 
origin = [3, 6, 2, 6]
changed = addNum(origin, 3)
 
print(origin)
print(changed)

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

[6, 9, 5, 9]
[6, 9, 5, 9]

То есть исходный список был также изменен. Параметр seq содержал ссылку не на свой локальный список, а на список-оригинал. Таким образом, в операторе return здесь нет смыла. Если функция замысливалась как изменяющая глобальный список, то программа должна выглядеть так:

def addNum(seq, num):
    for i in range(len(seq)):
        seq[i] += num
 
origin = [3, 6, 2, 6]
addNum(origin, 3)
print(origin)

Что делать, если все же требуется не изменять исходный список, а сформировать по нему новый. Задачу можно решить несколькими способами. Во первых, в функции можно создать локальный список, после чего возвращать его:

def addNum(seq, num):
    new_seq = []
    for i in seq:
        new_seq.append(i + num)
    return new_seq
 
origin = [3, 6, 2, 6]
changed = addNum(origin, 3)
 
print(origin)
print(changed)

Результат:

[3, 6, 2, 6]
[6, 9, 5, 9]

Исходный список в функции не меняется. Его элементы лишь перебираются.

Второй способ защитить список-оригинал – использовать кортеж. Этот способ более надежный, так как в больших программах трудно отследить, что ни одна функция не содержит команд изменения глобальных данных.

Хотя преобразовывать к кортежу можно как при передаче в функцию, так и в самой функции, лучше сразу делать глобальный список кортежем. Поскольку неизменяемые объекты передаются по значению, а не по ссылке, то в функцию будет поступать копия структуры, а не оригинал. Даже если туда передается оригинал, изменить его невозможно. Можно лишь, как вариант, скопировать его и/или изменить тип, создав тем самым локальную структуру, и делать с ней все, что заблагорассудится.

def addNum(seq, num):
    seq = list(seq)
    for i in range(len(seq)):
        seq[i] += num
    return seq
 
origin = (3, 6, 2, 6)
changed = addNum(origin, 3)
 
print(origin)
print(changed)

Списки в кортежах

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

>>> nested = (1, "do", ["param", 10, 20])

Как вы думаете, можем ли мы изменить список ["param", 10, 20] вложенный в кортеж nested? Список изменяем, кортеж – нет. Если вам кажется, что нельзя, то вам кажется неправильно. На самом деле можно:

>>> nested[2][1] = 15
>>> nested
(1, 'do', ['param', 15, 20])

Примечание. Выражения типа nested[2][1] используются для обращения к вложенным объектам. Первый индекс указывает на позицию вложенного объекта, второй – индекс элемента внутри вложенного объекта. Так в данном случае сам список внутри кортежа имеет индекс 2, а элемент списка 10 – индекс 1 в списке.

Странная ситуация. Кортеж неизменяем, но мы все-таки можем изменить его. На самом деле кортеж остается неизменяемым. Просто в нем содержится не сам список, а ссылка на него. Ее изменить нельзя. Но менять сам список можно.

Чтобы было проще понять, перепишем кортеж так:

>>> l = ["param", 10, 20]
>>> t = (1, "do", l)
>>> t
(1, 'do', ['param', 10, 20])

Кортеж содержит переменную-ссылку. Поменять ее на другую ссылку нельзя. Но кортеж не содержит самого списка. Поэтому его можно менять как угодно:

>>> l.pop(0)
'param'
>>> t
(1, 'do', [10, 20])

Однако такой номер не проходит с неизменяемыми типами:

>>> a = "Kat"
>>> t = (a, l)
>>> t
('Kat', [10, 20])
>>> a = "Bat"
>>> t
('Kat', [10, 20])

Они передаются в кортеж как и в функцию – по значению. То есть их значение копируется в момент передачи.

Практическая работа

1. Чтобы избежать изменения исходного списка, не обязательно использовать кортеж. Можно создать его копию с помощью метода списка copy() или взять срез от начала до конца [:]. Скопируйте список первым и вторым способом и убедитесь, что изменение копий никак не отражается на оригинале.

2. Заполните один кортеж десятью случайными целыми числами от 0 до 5 включительно.

   Также заполните второй кортеж числами от -5 до 0. Для заполнения кортежей числами напишите одну функцию. Объедините два кортежа с помощью оператора +, создав тем самым третий кортеж. С помощью метода кортежа count() определите в нем количество нулей. Выведите на экран третий кортеж и количество нулей в нем.

Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса

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

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

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

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

Кортеж Python

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

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

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

<class 'tuple'>

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

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

mixed_type = ('C',0,0,'K','I','E')

for i in mixed_type:
    print(i,":",type(i))
 

C : <class 'str'>
0 : <class 'int'>
0 : <class 'int'>
K : <class 'str'>
I : <class 'str'>
E : <class 'str'>

mixed_type[1] = "O"

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-16-dec28c299a95> in <module>()
----> 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))

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

<ipython-input-26-e48876d745ce> in <module>()
      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 = (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)

<ipython-input-40-3cd388e024ff> in <module>()
----> 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)

<ipython-input-55-d442c6414a4c> in <module>()
      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))

<class 'tuple'>

min() и max()

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

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

5
A

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

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

Кортежи в python — теория, задачи и тест по tuples()

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

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

Где используется?

Кортежи — распространенная структура данных для хранения последовательностей в Python.

• .index() — используется для вывода индекса элемента.
• .count() — используется для подсчета количества элементов в кортеже.
• sum() — складывает все элементы кортежа.
• min() — показывает элемент кортежа с наименьшим значением.
• max() — показывает элемент кортежа с максимальным значением.
• len() — показывает количество элементов кортежа.

Рекомендации по работе с кортежами

1. Кортежи создаются с помощью круглых скобок: ();
2. Элементы внутри кортежей разделяются запятыми;
3. Важно соблюдать особенности синтаксиса, характерные для каждого отдельного типа данных в кортеже — кавычки для строк, числа и булевые значения без кавычек и так далее.

Дальше — кортеж, включающий элементы разных типов:

>>> p_tup = ("Лондон", "Пекин", 44, True)
>>> print(p_tup)
('Лондон', 'Пекин', 44, True)

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

Например, для получения элемента «Лондон» нужно использовать следующий индекс: p_tup[0]

А для 44: p_tup[2]

Последний элемент следующего кортежа — булево True. Доступ к нему мы получаем с помощью функции print.

>>> p_tup = ("Лондон", "Пекин", 44, True)
>>> print(p_tup[3])
True

Пример получения первого элемента кортежа.

>>> p_tup = ("Лондон", "Пекин", 44, True)
>>> print(p_tup[0])
'Лондон'

Советы:

1. Обратное индексирование: по аналогии с элементами списка элементы кортежа также можно получить с помощью обратного индексирования. Оно начинается с -1. Это значение указывает на последний элемент.
   Так, для получения последнего элемент p_tup нужно писать p_tup[-1]. p_tup[-2] вернет второй элемент с конца и так далее.
2. Главное отличие кортежей от списков — они неизменяемые. Кортежам нельзя добавлять или удалять элементы.
   Поэтому эта структура используется, когда известно, что элементы не будут меняться в процессе работы программы.

>>> p_tup = ("Лондон", "Пекин", 44, True)
>>> print(p_tup[-1])
True

Функция .index()

.index() — полезный метод, используемый для получения индекса конкретного элемента в кортеже.

Посмотрим на примере.

>>> p_tup = ("Лондон", "Пекин", 44, True)
>>> print(p_tup.index("Лондон"))
0

Функция .count()

Метод .count() подходит для определения количества вхождений определенного элемента в кортеже.

В примере ниже можно увидеть, что считается количество вхождений числа 101 в списке p_cup. Результат — 2.

>>> p_tup = (5, 101, 42, 3, 101)
>>> print(p_tup.count(101))
2

Функция sum()

Функция sum() возвращает общую сумму чисел внутри кортежа.

>>> lucky_numbers = (5, 55, 4, 3, 101, 42)
>>> print(sum(lucky_numbers))
210

Функция min()

Функция min() вернет элемент с самым маленьким значением в кортеже.

>>> lucky_numbers = (5, 55, 4, 3, 101, 42)
>>> print(min(lucky_numbers))
5

Функция max()

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

>>> lucky_numbers = (5, 55, 4, 3, 101, 42)
>>> print(max(lucky_numbers))
101

Задачи к уроку

Попробуйте решить задачи к этому уроку для закрепления знаний.

1. Создайте кортеж с цифрами от 0 до 9 и посчитайте сумму.

# данный код
numbers =
print(sum(numbers))
# требуемый вывод:
# 45

2. Введите статистику частотности букв в кортеже.

# данный код
long_word = (
    'т', 'т', 'а', 'и', 'и', 'а', 'и', 
    'и', 'и', 'т', 'т', 'а', 'и', 'и',
    'и', 'и', 'и', 'т', 'и'
)

print("Количество 'т':", )
print("Количество 'a':", )
print("Количество 'и':", )
# требуемый вывод:
# Колличество 'т': 5
# Колличество 'а': 3
# Колличество 'и': 11

3. Допишите скрипт для расчета средней температуры.
   Постарайтесь посчитать количество дней на основе week_temp. Так наш скрипт сможет работать с данными за любой период.

# данный код
week_temp = (26, 29, 34, 32, 28, 26, 23)
sum_temp =
days =
mean_temp = sum_temp / days
print(int(mean_temp))
# требуемый вывод:
# 28

Файл со всем заданиями: https://gitlab.com/PythonRu/python-dlya-nachinayushih/-/blob/master/lesson_7.py.

Тест по кортежам

Пройдите тест к этому уроку для проверки знаний. В тесте 5 вопросов, количество попыток неограниченно.

Выберете верное утверждение. Одно.

Продолжить

Когда точно нужно использовать кортеж? Выберите один ответ.

Продолжить

sample = (10, 20, 30)
sample.append(60)
print(sample)

Продолжить

Какая функция создаст пустой кортеж?

Продолжить

lake = ("Python", 51, False, "22")

Продолжить

Продолжить

{{title}}

{{image}}

{{content}}

Поделиться результатами через

Повторить

Работа с кортежами в Python (tuple): как создать кортеж, добавить элемент

Представьте себя функцией. Да, это не просто, и все же…

Вас зовут get_contacts и вы умеете находить контакты человека по email-адресу: его адрес, имя и номер телефона. Вы не прочь поделиться информацией с другими, но Python вам это запрещает. Нельзя возвращать так много данных разом, результат у функции может быть только один. Вы можете выбрать что-то одно, самое важное: адрес, имя, или телефон человека. Или можете проявить изобретательность и упаковать все свои данные в одну переменную.

Как упаковать данные в кортеж

Для функции get_contacts(email) доступны несколько способов упаковки данных в более сложную структуру: словарь dict(), кортеж tuple() и еще несколько других. Рассмотрим подробнее последний вариант — tuple, или по-русски кортеж.

Предположим, вы вызвали функцию get_contacts('[email protected]'), она нашла такого человека и хочет вернуть его контакты:

full_name = 'Никифоров Дмитрий Анатольевич'
city = 'Москва'
phone_number = '929-876-54-32'

Функция создает кортеж — tuple() —, чтобы поместить в него все контакты:

contacts = (full_name, city, phone_number)

Круглые скобки и запятые указывают Python, что из перечисленных переменных full_name, city и phone_number нужно создать новую структуру данных:

print(type(contacts))  
print(contacts)

Последний вызов print() выведет на экран такое:

('Никифоров Дмитрий Анатольевич', 'Москва', '929-876-54-32')

Теперь функция get_contacts сможет вернуть любое количество данных. Все они будут упакованы в один кортеж — tuple.

Что делать, если получили tuple

Разберем как работать с tuple на примере стандартной функции divmod. Она возвращает результат деления с остатком:

divmod(100, 3)  
divmod(2, 3) 

Функция divmod возвращает кортеж из двух чисел — результата целочисленного деления и остаток от деления.

Мы можем сохранить результат в переменную:

div_tuple = divmod(100, 3)
print(div_tuple)  

Добраться до каждого из двух чисел можно по индексу:

div_tuple = divmod(100, 3)
print(div_tuple[0])  
print(div_tuple[1])  

Индексы в коде [0] и [1] сильно осложняют чтение, поэтому полезно давать говорящие названия:

div_tuple = divmod(100, 3)
int_division = div_tuple[0]
remainder = div_tuple[1]

print(int_division)  
print(remainder)  

Распаковка кортежа

При работе с кортежами очень часто приходится доставать все данные в отдельные переменные:

int_division = div_tuple[0]
remainder = div_tuple[1]

Это встречается настолько часто, что в Python ввели упрощенную короткую запись:

(int_division, remainder) = divmod(100, 3)
print(int_division)  
print(remainder)  

Запись похожа на создание кортежа — те же скобки и запятые, но работает это в обратную сторону. Называется “распаковкой”.

Если в кортеже больше одного элемента, то скобки указывать необязательно. Python любит чистый код:

int_division, remainder = divmod(100, 3)
print(int_division)  
print(remainder)  

Последняя форма записи распаковки наиболее распространена и рекомендуется к использованию.

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

contacts = full_name, city, phone_number

В коде внутри функций часто встречается еще более короткая запись:

return full_name, city, phone_number

Вызов return сообщает интерпретатору Python, что функция завершает свою работу и хочет вернуть результат. А все перечисленное справо от return будет упаковано в кортеж — tuple.

Как добавить элемент в кортеж

Добавить в кортеж ничего нельзя. Он неизменяемый, однажды созданный кортеж никак нельзя изменить. Зато можно создать новый:

old_tuple = (1, 2)
new_tuple = old_tuple + (3, 4)
print(new_tuple)  

Если вы хотите добавить только один элемент, то велик соблазн написать так:

old_tuple = (1, 2)
new_tuple = old_tuple + 3

TypeError: can only concatenate tuple (not "int") to tuple

Эта ошибка значит, что вы попытались сложить кортеж и число, а Python умеет складывать только кортежи. Поэтому придётся сделать из вашего элемента кортеж, но с одним элементом внутри:

old_tuple = (1, 2)
new_tuple = old_tuple + (3,)
print(new_tuple)  

Что ещё почитать

Кортежи (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. Часть 7. Кортежи и множества

Вы уже знаете, что такое списки в Питоне и как с ними можно работать (если еще нет — вот урок по спискам). Помимо списков в Питоне есть еще такие структуры данных, как кортежи и множества.

Видео: Глеб Лиманский

В видео при создании словаря пропущена функция dict(). Приносим извинение за ошибку!

Кортежи (Tuples) 

Кортеж похож на список, но у них есть принципиальное различие: список — изменяемый тип данных, а кортеж нет. В этом различии кроется суть кортежей: они защищают данные от непреднамеренных изменений. Вторая причина, по которой используют кортежи, это экономия места. Они занимают меньше объема в памяти, чем списки.

Вспомним, как в уроке по спискам вы удаляли один элемент:

Cоздаем с аналогичным содержанием кортеж. Делаем это с помощью круглых скобок, а не квадратных, как в списке (для создания пустого кортежа тоже используются круглые скобки). Пытаемся так же удалить тройку и получаем ошибку.

Что тогда вообще можно делать с кортежами, если они не изменяемы?

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

И можем еще просто удалить кортеж целиком:

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

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

Давайте создадим словарь с примерным автопарком Владимира Путина: это его личные автомобили из декларации и еще те, на которых он ездит.

Так как мы удалили предыдущий словарь, можем создать новый с таким же названием. Создаем список с автомобилями. И «сшиваем» с помощью функции-молнии — zip() — кортеж и список в словарь (можно было так соединить и два списка):

Словарь готов! Запомните эту функцию-молнию, она очень полезная.

Множества (Sets)

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

Создать пустое множество можно с помощью функции set(). А если с элементами, то с помощью их перечисления в фигурных скобках, как у словаря:

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

Получаем множество с уникальными элементами. Вернем его обратно в список с помощью функции list():

С множествами можно делать множество операций (избитая фраза, но все равно самая точная).

От самых простых таких, как добавление элемента и удаления:

Проверки наличия элемента в множестве:

До более сложных. Например, можно посмотреть пересечения множеств: то есть какие элементы входят в оба множества с помощью функции intersection():

Можем объединить два множества и получить третье, в котором останутся только уникальные элементы, использовав union():

А с помощью функции difference() узнаем разницy множеств: set1. difference(set2) даст нам ответ, какие элементы первого множества отсутствуют во втором множестве.

Если же хотим симметричную разницу между множествами: то есть все элементы, которые у них различны, а не общие. Применяем функцию symmetric_difference():

Все операции, доступные для множеств, можно посмотреть здесь.

Закончим на множестве, которое не изменяется, как и кортеж. Это frozenset. Преобразовываем свое множество во frozenset. И все: из него уже нельзя ничего удалить.

Тетрадка Jupyter Notebook с этого урока доступна на нашем GitHub.

Кортежи | Python

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

>>> t = (1, 2, 3, 4)
>>> t
(1, 2, 3, 4)

Чтобы создать пустой кортеж достаточно указать пару пустых круглых скобок:

>>> t = ()
>>> t
()
>>>
>>> type(t)
<class 'tuple'>

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

>>> t = (1,)
>>> t
(1,)

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

>>> (1 + 1)
2

А запятые:

>>> 1 + 1,
(2,)
>>>
>>> (1 + 1,)
(2,)

Поэтому, очень часто скобки вообще не используются:

>>> t = 1, 2, 3, 4
>>> t
(1, 2, 3, 4)

Однако, в зависимости от контекста, круглые скобки указывать все же приходится, например, запись вида func(x, y) будет означать что данной функции передано два аргумента, а запись func((x, y)) будет означать, что функции передан кортеж.

Кортежи могут быть созданы с помощью функции tuple(). Если вызвать данную функцию без аргументов, то она вернет пустой кортеж:

>>> t = tuple()
>>> t
()

Если передать tuple() итерируемый объект, то она попытается преобразовать его в кортеж:

>>> tuple('abcd')
('a', 'b', 'c', 'd')
>>>
>>> tuple(range(5))
(0, 1, 2, 3, 4)
>>>
>>> tuple(dict(a=1, b=2, c=3))
('a', 'b', 'c')

Ну а если передать tuple() кортеж, то будет возвращена его поверхностная копия.

Кортежи не могут быть созданы с помощью генераторов, так как генераторы заключенные в круглые скобки являются «выражениями генераторами»

>>> (i**2 for i in range(10))
<generator object <genexpr> at 0x013DC680>

Поскольку кортежи являются последовательностями, то они поддерживают оператор извлечения среза [START:STOP:STEP] (и индексируются так же как и списки), так же они поддерживают оператор проверки на вхождение in и not in, функцию измерения размера (длины) len(), а так же механиз итерирования с помощью конструкции for... in....

Неизменяемость кортежей

Кортежи, в отлие от списков являются неизменяемыми:

>>> l = [0, 1, 2]
>>> l[0] = 111
>>> l
[111, 1, 2]
>>>
>>>
>>> t = (1, 2, 3)
>>> t[0] = 111
TypeError: 'tuple' object does not support item assignment

Но так же как и строки, они могут служить «сырьем» для новых объектов:

>>> t
(1, 2, 3)
>>>
>>> t = (111,) + t[1:]
>>> t
(111, 2, 3)
>>>
>>>
>>> t = t[0:1] + (222,) + t[2:]
>>> t
(111, 222, 3)

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

>>> t = list(t)
>>> t[2] = 333
>>> t = tuple(t)
>>> t
(111, 222, 333)

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

>>> t = (1, 2, [3, 4])
>>> 
>>> t[2][1] = 4444
>>>
>>> t
(1, 2, [3, 4444])

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

Так как кортежи являются неизменяемыми, то они имеют всего два метода: .count(x) и .index(x).

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

Кортежи (и списки) могут учавствовать в операциях присваивания:

>>> a, b, c = 1, 2, 3
>>> a, b, c
(1, 2, 3)

Данный механизм очень удобен для обмена значениями между переменными:

>>> a, b, c = c, b, a
>>> a, b, c
(3, 2, 1)

Если слева от оператора = элементов меньше чем справа, то можно воспользоваться оператором * для указания элементу которому может быть присвоено более одного значения:

>>> *a, b, c = (1, 2, 3, 4)
>>> a, b, c
([1, 2], 3, 4)
>>>
>>> a, *b, c = (1, 2, 3, 4)
>>> a, b, c
(1, [2, 3], 4)
>>>
>>> a, b, *c = (1, 2, 3, 4)
>>> a, b, c
(1, 2, [3, 4])

Использование помеченных * переменных, так же позволяет указывать слева от = больше элементов чем справа:

>>> *a, b, c, d, e = (1, 2, 3, 4)
>>> a, b, c, d
([], 1, 2, 3)
>>>
>>> a, b, *c, d, e = (1, 2, 3, 4)
>>> a, b, c, d
(1, 2, [], 3)

Процесс упвковки кортежей, позволяет связываеть воедино разные переменные:

>>> a, b, c, x, y, z = 1, 2, 3, 4, 5, 6
>>>
>>> t1 = a, x
>>>
>>> t2 = x, c, z, b
>>>
>>> t1
(1, 4)
>>>
>>> t2
(4, 3, 6, 2)

Механизм распаковки кортежей может использоваться в конструкциях for... in...:

>>> for x, y in ((1, 2), (1, 3), (1, 4)):
...     print(x, '+', y, '=', x + y)
...
1 + 2 = 3
1 + 3 = 4
1 + 4 = 5

Это может быть очень удобно при работе с некоторыми генераторами:

>>> for x, y in zip('abcd', range(1, 5)):
...     print(x*y)
...
a
bb
ccc
dddd

Именованные кортежи

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

>>> t = (('mod_1', 8.71, (-1.32, 23.87)), ('mod_2', 5.12, (-0.41, 19.86)))
>>> t
(('mod_1', 8.71, (-1.32, 23.87)), ('mod_2', 5.12, (-0.41, 19.86)))

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

>>> t[0][2][1]
23.87

С другой стороны, можно попытаться придать индексам какие-то осмысленные обозначения:

>>> model_1, model_2 = 0, 1
>>> name, mean, min_max = 0, 1, 2
>>> minimum, maximum = 0, 1

Теперь обращение к элементам t может выглядеть чуть логичнее:

>>> t[model_1][min_max][maximum]
23.87

Но самый простой способ это использование встроенного модуля collections из стандартной библиотеки. Благодаря ему «очень легко» создать структуру кортежа из примера выше:

>>> import collections
>>>
>>> models = collections.namedtuple('models', 'model_1 model_2')
>>> params = collections.namedtuple('params', 'name mean min_max')
>>> limit = collections.namedtuple('limit', 'minimum maximum')

Потом, точно также «очень легко» создать сам именованный кортеж:

>>> Models = models(params('mod_1', 8.71, limit(-1.32, 23.87)),
...                 params('mod_2', 5.12, limit(-0.41, 19.86)))

А вот извлекать элементы из такого кортежа, действительно легко:

>>> Models.model_1.min_max.maximum
23.87

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

кортежей в Python — GeeksforGeeks

Кортеж — это набор объектов Python, разделенных запятыми. В некотором смысле кортеж похож на список с точки зрения индексации, вложенных объектов и повторения, но кортеж неизменен, в отличие от изменяемых списков.

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

Выход:

900

tup = 'python' , 'geeks'

print (tup)

tup = ( ) python ' , ' geeks ' )

print (tup)

Вывод

 (' python ',' geeks ')
('python', 'geeks') 

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

Объединение кортежей

Выход:

(0, 1, 2, 3, 'python', 'geek') 

Вложение кортежей

Вывод:

 ((0, 1, 2, 3), ('python', 'geek') )) 

Повторение в кортежах

Вывод

 ('python', 'python', 'python') 

Попробуйте выполнить вышеуказанное без запятой и проверьте.Вы получите tuple3 как строку «pythonpythonpython».

Неизменяемые кортежи

Выход

 Отслеживание (последний вызов последний):
  Файл "e0eaddff843a8695575daec34506f126.py ", строка 3, в
    tuple1 [0] = 4
TypeError: объект 'tuple' не поддерживает назначение элементов 

Нарезка кортежей

Вывод

 (1, 2, 3)
(3, 2, 1, 0)
(2, 3) 

Удаление кортежа

Ошибка:

 Отслеживание (последний вызов последний):
  Файл "d92694727db1dc9118a5250bf04dafbd.py ", строка 6, в 
    печать (кортеж3)
NameError: имя 'tuple3' не определено 

Вывод:

 (0, 1) 

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

Выход

 2 

Список преобразования в кортеж

Выход

 (0, 1, 2)
('p', 'y', 't', 'h', 'o', 'n') 

Принимает единственный параметр, который может быть списком, строкой, набором или даже словарем (в качестве elements) и преобразует их в кортеж.

Кортежи в цикле

Выход:

 (('geek',),)
((('Компьютерщик',),),)
(((('Компьютерщик',),),),)
((((('Компьютерщик',),),),),)
(((((('Компьютерщик',),),),),),)
 

Использование cmp (), max (), min ()

Выход

 Не то же самое
Максимальный элемент в кортежах 1,2: python, coder
Минимальный элемент в кортежах 1,2: geek, 1
 

Примечание: max () и min () проверяют на основе значений ASCII.Если в кортеже две строки, то проверяется первый другой символ в строках.

Автор статьи Шри Санкет Уппалапати. Пожалуйста, напишите комментарий, если вы обнаружите что-то неправильное, или если вы хотите поделиться дополнительной информацией по теме, обсужденной выше.

Внимание компьютерщик! Укрепите свои основы с помощью курса Python Programming Foundation и изучите основы.

Для начала подготовьтесь к собеседованию. Расширьте свои концепции структур данных с помощью курса Python DS .И чтобы начать свое путешествие по машинному обучению, присоединяйтесь к Машинному обучению — курс базового уровня

Кортеж Python с примером

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

1. Кортеж против списка

1. Элементы списка являются изменяемыми, тогда как элементы кортежа неизменяемы.
2. Когда мы не хотим изменять данные с течением времени, предпочтительным типом данных является кортеж , тогда как, когда нам нужно изменить данные в будущем, разумным вариантом будет список .
3. Перебор элементов кортежа выполняется быстрее по сравнению с перебором списка .
4. Элементы кортежа заключаются в круглые скобки, тогда как элементы списка заключаются в квадратные скобки.

2. Как создать кортеж в Python

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

2.1 Пример — создание кортежа

В этом примере мы создаем несколько кортежей. У нас может быть кортеж элементов данных одного типа, а также элементы данных смешанного типа. В этом примере также показан вложенный кортеж (кортежи как элементы данных в другом кортеже).

 # кортеж строк
my_data = («привет», «привет», «пока»)
печать (my_data)

# кортеж из int, float, string
my_data2 = (1, 2.8, «Привет, мир»)
печать (my_data2)

# кортеж из строки и списка
my_data3 = ("Книга", [1, 2, 3])
печать (my_data3)

# кортежей внутри другого кортежа
# вложенный кортеж
my_data4 = ((2, 3, 4), (1, 2, "привет"))
печать (my_data4) 

Выход:

 («привет», «привет», «пока»)
(1, 2.8, «Привет, мир»)
('Книга', [1, 2, 3])
((2, 3, 4), (1, 2, 'привет')) 

2.2 Пустой кортеж:

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

2.3 Кортеж с единственным элементом:

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

 # кортеж с одним элементом данных
my_data = (99,) 

Если мы не поставим запятую после 99 в приведенном выше примере, тогда python будет рассматривать my_data как переменную типа int, а не как кортеж.

3. Как получить доступ к элементам кортежа

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

3.1 Доступ к элементам кортежа с использованием положительных индексов

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

 # кортеж строк
my_data = («привет», «привет», «пока»)

# отображение всех элементов
печать (my_data)

# доступ к первому элементу
# печать "привет"
печать (my_data [0])

# доступ к третьему элементу
# выводит "пока"
печать (my_data [2]) 

Выход:

 («привет», «привет», «пока»)
Привет
до свидания 

Примечание:
1. TypeError : Если вы не используете целочисленные индексы в кортеже. Например, my_data [2.0] вызовет эту ошибку. Индекс всегда должен быть целым числом.
2. IndexError : Индекс вне допустимого диапазона. Эта ошибка возникает, когда мы упоминаем индекс, который не входит в диапазон. Например, если кортеж состоит из 5 элементов, и мы пытаемся получить доступ к 7-му элементу, возникнет эта ошибка.

3.2 Отрицательные индексы в кортежах

Подобно списку и строкам, мы можем использовать отрицательные индексы для доступа к элементам кортежа с конца.
-1 для доступа к последнему элементу, -2 для доступа ко второму последнему и так далее.

 my_data = (1, 2, «Кевин», 8.9)

# доступ к последнему элементу
# отпечатков 8,9
печать (my_data [-1])

# отпечатков 2
print (my_data [-3]) 

Выход:

 8,9
2 

3.3 Доступ к элементам из вложенных кортежей

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

В следующем примере, когда я использовал my_data [2] [1], он получил доступ ко второму элементу вложенного кортежа. Поскольку 2 представляет третий элемент основного кортежа, который является кортежем, а 1 представляет второй элемент этого кортежа.

 my_data = (1, «Стив», (11, 22, 33))

# выводит 'v'
печать (my_data [1] [3])

# отпечатков 22
print (my_data [2] [1]) 

Выход:

 v
22 

4. Операции, которые могут быть выполнены с кортежем в Python

Давайте посмотрим, какие операции можно выполнять с кортежами в Python.

4.1 Изменение элементов кортежа

Мы не можем изменить элементы кортежа, потому что элементы кортежа неизменяемы. Однако мы можем изменить изменяемые элементы вложенных элементов. Например, в следующем коде мы меняем элемент списка, который присутствует внутри кортежа. Элементы списка изменяемы, поэтому это разрешено.

 my_data = (1, [9, 8, 7], «Мир»)
печать (my_data)

# изменение элемента списка
# это верно, потому что список изменяемый
my_data [1] [2] = 99
печать (my_data)

# изменение элемента кортежа
# Это недопустимо, поскольку элементы кортежа неизменяемы
# TypeError: объект 'tuple' не поддерживает назначение элементов
# my_data [0] = 101
# print (my_data) 

Выход:

 (1, [9, 8, 7], "мир")
(1, [9, 8, 99], «Мир») 

4.2 Операция удаления кортежа

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

 my_data = (1, 2, 3, 4, 5, 6)
печать (my_data)

# невозможно
# ошибка
# del my_data [2]

# возможно удаление всего кортежа
дель my_data

# невозможно
# ошибка
# потому что my_data удалена
# print (my_data) 

Выход:

 (1, 2, 3, 4, 5, 6) 

4.3 Операция нарезки кортежей

 my_data = (11, 22, 33, 44, 55, 66, 77, 88, 99)
печать (my_data)

# элементы с 3-го по 5-й
# отпечатки (33, 44, 55)
печать (my_data [2: 5])

# элементов от начала до 4-го
# отпечатки (11, 22, 33, 44)
печать (my_data [: 4])

# элемент с 5-го до конца
# отпечатков (55, 66, 77, 88, 99)
печать (my_data [4:])

# элементы с 5-го по второй последний
# отпечатки (55, 66, 77, 88)
печать (my_data [4: -1])

# отображение всего кортежа
print (my_data [:]) 

Выход:

 (11, 22, 33, 44, 55, 66, 77, 88, 99)
(33, 44, 55)
(11, 22, 33, 44)
(55, 66, 77, 88, 99)
(55, 66, 77, 88)
(11, 22, 33, 44, 55, 66, 77, 88, 99) 

4.4 Тест на членство в кортежах

из : проверяет, существует ли элемент в указанном кортеже.
не в : проверяет, не существует ли элемент в указанном кортеже.

 my_data = (11, 22, 33, 44, 55, 66, 77, 88, 99)
печать (my_data)

# правда
печать (22 в my_data)

# ложный
печать (2 в my_data)

# ложный
print (88 нет в my_data)

# правда
print (101 не в my_data) 

Выход:

 (11, 22, 33, 44, 55, 66, 77, 88, 99)
Правда
Ложь
Ложь
Правда 

4.5 Итерация кортежа

 # кортеж фруктов
my_tuple = («Яблоко», «Апельсин», «Виноград», «Банан»)

# перебор элементов кортежа
для фруктов в my_tuple:
     печать (фрукты) 

Выход:

 Яблоко
апельсин
Виноград
Банан 

Списки и кортежи в Python — Real Python

Список может содержать любой набор объектов. Все элементы списка могут быть одного типа:

  >>> a = [2, 4, 6, 8]
>>> а
[2, 4, 6, 8]
  

  >>> a = [21.42, 'foobar', 3, 4, 'bark', Ложь, 3.14159]
>>> а
[21.42, 'foobar', 3, 4, 'bark', Ложь, 3.14159]
  

Списки могут даже содержать сложные объекты, такие как функции, классы и модули, о которых вы узнаете в следующих руководствах:

  >>> int
<класс 'int'>
>>> len
<встроенная функция len>
>>> def foo ():
...     проходить
...
>>> фу
<функция foo в 0x035B9030>
>>> импорт математики
>>> математика
<модуль 'math' (встроенный)>

>>> a = [int, len, foo, math]
>>> а
[<класс 'int'>, <встроенная функция len>, <функция foo в 0x02CA2618>,
<модуль 'math' (встроенный)>]
  

Список может содержать любое количество объектов, от нуля до того количества, которое позволяет память вашего компьютера:

  >>> a = []
>>> а
[]

>>> а = ['фу']
>>> а
['фу']

>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
... 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
... 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
... 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
... 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]
>>> а
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
97, 98, 99, 100]
  

Объекты списка не обязательно должны быть уникальными.Данный объект может появляться в списке несколько раз:

Кортежей Python

Резюме : в этом руководстве вы узнаете о кортежах Python и о том, как их эффективно использовать.

Введение в кортежи Python

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

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

Определение кортежа

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

В следующем примере определяется кортеж с именем rgb :

 
  rgb = ('красный', 'зеленый', 'синий')  
  Язык кода: Python (python)  

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

 
  rgb = ('красный', 'зеленый', 'синий')

печать (rgb [0])
печать (RGB [1])
print (rgb [2])  
  Язык кода: Python (python)  

Outptut:

 
  красный
зеленый
синий  
  Язык кода: Python (python)  

Поскольку кортеж неизменяем, вы не можете изменять его элементы.В следующем примере предпринимается попытка изменить первый элемент кортежа rgb на 'yellow' :

 
  rgb = ('красный', 'зеленый', 'синий')
rgb [0] = 'yellow'  
  Язык кода: Python (python)  

И это приводит к ошибке:

 
  TypeError: объект 'tuple' не поддерживает назначение элементов  
  Язык кода: Python (python)  

Определение кортежа с одним элементом

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

 
  чисел = (3,)
print (тип (числа))  
  Язык кода: Python (python)  

Вывод:

 
    
  Язык кода: Python (python)  

Если исключить завершающий запятая, тип чисел будет int , что означает целое число. Его значение равно 3. Python не создаст кортеж, содержащий число 3:

 
  чисел = (3)
print (type (числа))  
  Язык кода: Python (python)  

Вывод:

 
    
  Язык кода: Python (python)  

Назначение кортежа

Даже если вы не можете изменить кортеж, вы можете назначить новый кортеж переменной, которая ссылается на кортеж.Например:

 
  цветов = ('красный', 'зеленый', 'синий')
печать (цвета)

colors = ('Голубой', 'Пурпурный', 'Желтый', 'черный')
print (colors)  
  Язык кода: Python (python)  

Резюме

• Кортежи — это неизменяемые списки.
• Используйте кортежи, если вы хотите определить список, который нельзя изменить.

Вы нашли это руководство полезным?

Работа с кортежами в Python

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

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

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

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

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

Таким же образом, как и для списков, мы можем индексировать значения, указывая их положение в скобках. Мы можем просто получить первое число из кортежа x , написав x [0].

Кроме того, мы также можем размещать кортежи в списках.И затем каждый кортеж становится отдельным элементом в списке, как вы можете видеть на рисунке ниже.

Кортежи похожи на списки, но есть некоторые тонкие различия, которые мы не должны игнорировать. Они могут быть весьма полезны при работе с разными , разделенными запятыми значениями . Например, предположим, что у нас есть age и years_of_school в качестве переменных, и у нас есть соответствующие числа в строковом формате, разделенные запятой.

Метод .split () с правильным указанием в скобках назначит 30 как значение для age и 17 как значение для years_of_school .

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

Наконец, функции могут предоставлять кортежи в качестве возвращаемых значений. Это полезно, потому что функция, которая в противном случае может возвращать только одно значение, может создать кортеж, содержащий нескольких значений.Давайте создадим следующую функцию, где A — это площадь, а P — периметр:

  def square_info (x):  

Когда мы вводим только длину стороны квадрата, на выходе функции square_info () будет кортеж. Он сообщит нам площадь и периметр квадрата.

Таким образом, всякий раз, когда вам нужно сохранить определенное количество элементов, которые не будут изменены в будущем, вы можете использовать кортежи в Python.Работа с ними может быть чрезвычайно полезной, когда функция должна возвращать более одного значения. Если вы нашли эту статью интересной, вы можете перейти к неизвестной концепции хранения набора значений в так называемом словаре.

***

Если вы с энтузиазмом относитесь к расширению своих знаний Python, ознакомьтесь с нашими супер практическими руководствами !

Кортежи Python — javatpoint

<класс 'кортеж'>
<класс 'кортеж'>
<класс 'кортеж'>
 

<класс 'str'>
<класс 'кортеж'>
 

(10, 20, 30, 40, 50, 60)
tuple1 [0] = 10
tuple1 [1] = 20
tuple1 [2] = 30
tuple1 [3] = 40
tuple1 [4] = 50
tuple1 [5] = 60
 

Введите элементы кортежа ... 123456
('1', '2', '3', '4', '5', '6')
tuple1 [0] = 1
tuple1 [1] = 2
tuple1 [2] = 3
tuple1 [3] = 4
tuple1 [4] = 5
tuple1 [5] = 6
 

1
2
3
индекс кортежа вне допустимого диапазона
 

(2, 3, 4, 5, 6, 7)
(1, 2, 3, 4)
(1, 2, 3, 4)
(1, 3, 5)
 

5
2
(3, 4)
(1, 2, 3, 4)
(4, 5)
 

(1, 2, 3, 4, 5, 6)
Отслеживание (последний вызов последний):
  Файл "tuple.py", строка 4, в 
    печать (кортеж1)
NameError: имя 'tuple1' не определено
 

 T1 * 2 = (1, 2, 3, 4, 5, 1, 2, 3, 4, 5) 

 Т1 + Т2 = (1, 2, 3, 4, 5, 6, 7, 8, 9) 

 print (2 in T1) печатает True. 

 для i в T1:
    печать (я) 

 1
2
3
4
5 

 длина (T1) = 5 

Кортеж Python — Изучение на примере

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

Кортеж — это упорядоченный набор значений.

Кортежи во многом похожи на списки:

• Кортежи упорядочены — Кортежи поддерживают позиционный порядок слева направо среди элементов, которые они содержат.
• Доступ по индексу — Доступ к элементам в кортеже можно получить с помощью индекса.
• Кортежи могут содержать объекты любого типа. — Это могут быть числа, строки, списки и даже другие кортежи.

за исключением:

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

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

Вы можете создать кортеж, поместив последовательность элементов, разделенных запятыми, в круглые скобки () .

  # Кортеж целых чисел
Т = (1, 2, 3)

# Кортеж строк
T = ('красный', 'зеленый', 'синий')  

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

  # Кортеж со смешанными типами данных
T = (1, 'abc', 1.23, True)  

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

Синтаксически кортеж — это просто Список значений, разделенных запятыми.

  # Кортеж без скобок
T = 1, 'abc', 1.23, True  

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

Singleton Tuple

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

  Т = (4,)
печать (введите (T))
# Prints   

В противном случае Python будет думать, что вы только что ввели значение в обычных круглых скобках.

  # Не кортеж
Т = (4)
печать (введите (T))
# Печатает   

Конструктор tuple ()

Вы можете преобразовать другие типы данных в кортежи с помощью конструктора Python tuple ().

  # Преобразовать список в кортеж
T = кортеж ([1, 2, 3])
печать (T)
# Печать (1, 2, 3)  

  # Преобразование строки в кортеж
T = кортеж ('abc')
печать (T)
# Prints ('a', 'b', 'c')  

Вложенные кортежи

Кортеж может содержать подкортеж, который, в свою очередь, может содержать сами подкортежи, и так далее. Это называется вложенным кортежем . Вы можете использовать их для упорядочивания данных в иерархические структуры.

  T = ('красный', ('зеленый', 'синий'), 'желтый')  

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

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

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

  T = («красный», «зеленый», «синий», «голубой»)
печать (T)
# Печатает ('красный', 'зеленый', 'синий', 'голубой')  

В приведенном выше примере значения «красный», «зеленый», «синий» и «голубой» упакованы вместе в кортеж.

Распаковка кортежа

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

  T = («красный», «зеленый», «синий», «голубой»)
(a, b, c, d) = T

печать (а)
# Печатает красным

печать (б)
# Печатает зеленым

печать (с)
# Печать синего цвета

печать (d)
# Печатает голубой цвет  

В приведенном выше примере кортеж T распакован в переменные a, b, c и d.

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

  # Типичные ошибки при распаковке кортежей

T = ('красный', 'зеленый', 'синий', 'голубой')
(а, б) = Т
# Triggers ValueError: слишком много значений для распаковки

T = ('красный', 'зеленый', 'синий')
(a, b, c, d) = T
# Triggers ValueError: недостаточно значений для распаковки (ожидается 4, получено 3)  

Использование

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

  # Поменять местами значения 'a' и 'b'
а = 1
b = 99

а, б = б, а

печать (а)
# Печать 99

печать (б)
# Выводит 1  

При распаковке кортежа правая часть может быть любой последовательностью (кортеж, строка или список).

  # Разделить адрес электронной почты на имя пользователя и домен
адрес = '[email protected]'
пользователь, домен = addr.split ('@')

печать (пользователь)
# Печатает боб

печать (домен)
# Печатает python.org  

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

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

Индексы для элементов в кортеже показаны ниже:

  T = ('красный', 'зеленый', 'синий', 'желтый', 'черный')

печать (T [0])
# Печатает красным

печать (T [2])
# Печатает синим цветом  

Вы также можете получить доступ к кортежу с помощью отрицательной индексации. Отрицательные индексы отсчитываются в обратном порядке от конца кортежа. Итак, T [-1] относится к последнему элементу, T [-2] является вторым последним и так далее.

  T = («красный», «зеленый», «синий», «желтый», «черный»)

печать (T [-1])
# Печать черных

печать (T [-2])
# Печатает желтый  

Нарезка кортежа

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

  T = ('a', 'b', 'c', 'd', 'e', ​​'f')

печать (T [2: 5])
# Печать ('c', 'd', 'e')

печать (T [0: 2])
# Печатает ('a', 'b')

печать (T [3: -1])
# Prints ('d', 'e')  

Изменить элементы кортежа

Кортежи неизменяемы (неизменяемы). Созданный кортеж нельзя изменить.

  T = («красный», «зеленый», «синий»)
T [0] = "черный"
# Триггеры TypeError: объект 'tuple' не поддерживает присвоение элемента  

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

  T = (1, [2, 3], 4)
Т [1] [0] = "хх"
печать (T)
# Prints (1, ['xx', 3], 4)  

Удалить кортеж

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

  T = («красный», «зеленый», «синий»)
del T  

Объединение и повторение кортежей

Кортежи могут быть объединены с помощью оператора объединения + или оператора репликации *

  # Concatenate
T = ('красный', 'зеленый', 'синий') + (1, 2, 3)
печать (T)
# Печать ('красный', 'зеленый', 'синий', 1, 2, 3)

# Репликация
Т = ('красный',) * 3
печать (T)
# Prints ('red', 'red', 'red')  

Найти длину кортежа

Чтобы узнать, сколько элементов в кортеже, используйте метод len ().

  T = («красный», «зеленый», «синий»)
печать (len (T))
# Prints 3  

Проверить, существует ли элемент в кортеже

Чтобы определить, находится ли значение в кортеже или нет, вы можете использовать операторы in и not in с оператором if.

  # Проверить наличие
T = ('красный', 'зеленый', 'синий')
если красный в T:
    печать ('да')

# Проверить на отсутствие
T = ('красный', 'зеленый', 'синий')
если «желтый» отсутствует в T:
    print ('yes')  

Перебор кортежа

Чтобы перебрать элементы кортежа, используйте простой цикл for.

  T = («красный», «зеленый», «синий»)
для элемента в T:
    печать (элемент)
# Печатает красный зеленый синий  

Сортировка кортежей

Существует два метода сортировки кортежа.

Метод 1 : Используйте встроенный метод sorted (), который принимает любой объект последовательности.

  T = ('cc', 'aa', 'dd', 'bb')
print (кортеж (отсортировано (T)))
# Печать ('aa', 'bb', 'cc', 'dd')  

Метод 2 : преобразовать кортеж в изменяемый объект, например список (с помощью конструктора списка), получить доступ к вызову метода сортировки ( sort ()) и преобразовать обратно в кортеж.

  T = ('cc', 'aa', 'dd', 'bb')
tmp = list (T) # преобразовать кортеж в список
tmp.sort () # список сортировки
T = tuple (tmp) # преобразовать список в кортеж
print (T) # Prints ('aa', 'bb', 'cc', 'dd')  

Кортежные методы Python

Python имеет набор встроенных методов, которые можно вызывать для объектов кортежей.

Встроенный- in Функции с кортежем

Python также имеет набор встроенных функций, которые можно использовать с объектами кортежей.