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

Содержание

Кортежи 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
  1. Допишите скрипт для расчета средней температуры. 
    Постарайтесь посчитать количество дней на основе 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}}
 {{/global}}
Поделиться результатами через
 Повторить
Списки и кортежи в Python для начинающих
Списки и кортежи в Python для начинающих
Предположим, что вы составляете список гостей на свадьбу. Этот список постоянно меняется: добавились друзья семьи Дима и Света, не смогут прийти троюродные сестры со стороны жены Лида с Наташей.
Для представления таких данных из реального мира в Python отлично подходят списки. Списки — это
 еще один встроенный тип данных Python.
Создать, или другими словами, объявить список в Python можно двумя способами, так:
my_list = list()

или так:
my_list = []

Вернемся, однако, к гостям на свадьбе. Для создания списка гостей, сразу же при создании помещаем внутрь скобок строки с именами через запятую.
guests = ['Родители', 'Одноклассники', 'Лида и Наташа']
print(guests)

Операции с элементами списка
В нашем списке три элемента: «Родители», «Одноклассники», «Лида и Наташа», — которые хранятся внутри списка именно в таком порядке. Если только вы не измените порядок списка, «Родители» всегда будет первым элементом, «Одноклассники» — вторым и «Лида и Наташа» — третьим. Родители представляет собой начало списка, а Лида и Наташа — конец. Мы помним, что Лида и Наташа не смогут прийти, и их нужно удалить из списка.
С помощью метода remove можно удалить последний элемент в списке.
guests = ['Родители', 'Одноклассники', 'Лида и Наташа']
print(guests)  # ['Родители', 'Одноклассники', 'Лида и Наташа']
guests.remove("Лида и Наташа")
print(guests)  # ['Родители', 'Одноклассники', 'Лида и Наташа']

Но не забываем, нужно еще добавить в список двух гостей. Добавление новых элементов в конец списка происходит при помощи метода append.
guests = ['Родители', 'Одноклассники', 'Лида и Наташа']
print(guests)  # ['Родители', 'Одноклассники', 'Лида и Наташа']
guests.remove("Лида и Наташа")
print(guests)  # ['Родители', 'Одноклассники']
guests.append('Дима')
guests.append('Света')
print(guests)  # ['Родители', 'Одноклассники', 'Дима', 'Света']

В список можно не только добавить элемент, но и изменить одно из его значений на другое, согласно индексу элемента.
guests = ['Родители', 'Одноклассники', 'Дима', 'Света']
print(guests)  # ['Родители', 'Одноклассники', 'Лида и Наташа']
guests[2] = 'Коллеги'
print(guests)  # ['Родители', 'Одноклассники', 'Коллеги', 'Света']

И так, список — это контейнер, хранящий объекты в определенном порядке. Обратите внимание, что в отличие
 от строк, методы списка меняют исходный список. Есть однако у списков кое‑что общее. Это доступ к элементу
 по индексу и срезы. Все это работает в списках точно так же, как и в строках.
guests = ['Родители', 'Одноклассники', 'Дима', 'Света']
print(guests[0])  # Родители
print(guests[-1])  # Света
print(guests[:2])  # ['Родители', 'Одноклассники']

Кортежи
Кортежи — это контейнеры, хранящие объекты в определенном порядке. В отличие от списков, кортежи неизменяемы.
Как только вы создали кортеж, значение какого‑либо его элемента уже нельзя изменить, как нельзя добавлять и удалять элементы. Кортежи объявляются с помощью круглых скобок. Элементы в кортеже должны быть разделены запятыми.
Для создания кортежей также используют один из двух вариантов синтаксиса. Первый:
my_tuple = tuple()

И второй:
my_tuple = ()

Чтобы добавить в кортеж новые объекты, создайте его вторым способом,
 указав через запятую каждый желаемый элемент.
data = ('И. Иванов', 1958, True)
print(data)  # ('И. Иванов', 1958, True)

Даже если кортеж содержит только один элемент, после этого элемента все равно нужно поставить запятую. Таким образом Python отличает кортеж от числа в скобках, определяющих порядок выполнения операций.
Получить элементы кортежа можно так же, как и элементы списка, указывая индекс элемента.
books = ("1984", "О дивный новый мир", "451 градус по Фаренгейту")
print(books[2])  # 451 градус по Фаренгейту

Ключевое слово in / not in
Проверить, содержится ли элемент в кортеже, можно с помощью ключевого слова in.
books = ("1984", "О дивный новый мир", "451 градус по Фаренгейту")
print("1984" in books)  # True
print("Незнайка на луне" in books)  # False

Поместите перед in ключевое слово not для проверки отсутствия элемента в кортеже.
books = ("1984", "О дивный новый мир", "451 градус по Фаренгейту")
print("Незнайка на луне" not in books)  # True

Те же операции с ключевыми словами in и not in сработают и со списками.
Сложение кортежей и списков
При помощи оператора сложения можно соединять друг с другом две одинаковые структуры данных. Пример ниже со списками также будет работать и с кортежами:
colors1 = ["синий", "зеленый", "желтый"]
colors2 = ["оранжевый", "розовый", "черный"]
print(colors1 + colors2)  # ['синий', 'зеленый', 'желтый', 'оранжевый', 'розовый', 'черный']

На данном этапе вам может стать интересно, зачем использовать структуры данных, которые кажутся менее гибкими, чем списки? На самом же деле, кортежи удобны, когда вы имеете дело со значениями, которые никогда не изменятся. Примером таких данных для кортежа могут быть географические координаты. Долготу и широту города следует сохранить в кортеже, поскольку эти значения никогда не изменятся, а сохранение в кортеже будет гарантировать, что другие части программы случайно их не изменят.
Итерирование
Строки, списки и кортежи поддерживают итерирование (программа может их перебирать, значение за значением), то есть к каждому их элементу можно получить доступ через цикл — такие объекты называются итерируемыми. Каждый элемент в итерируемом объекте, как мы уже знаем, имеет свой порядковый индекс.
В следующем примере элемент Москва записан в списке с индексом 0, Хельсинки с индексом 1, а ‘Анкара’ с индексом 2.
cities = ['Москва', 'Хельсинки' ,'Анкара']
for city in cities:
    print(city)

# Москва
# Хельсинки
# Анкара


Вот мы и познакомились с оператором for — циклом, перебирающим итерируемый объект. Цикл for можно использовать, чтобы определять инструкции, которые будут выполняться один раз для каждого элемента в итерируемом объекте, и с помощью таких инструкций вы можете получать доступ ко всем этим элементам и осуществлять операции с ними.
Например, с помощью цикла for, выполняющего перебор списка строк, и метода upper() можно сделать символы каждой строки прописными:
cities = ['Москва', 'Хельсинки' ,'Анкара']
for city in cities:
    print(city.upper())

# МОСКВА
# ХЕЛЬСИНКИ
# АНКАРА


Как показано в примерах выше, цикл for определяется синтаксисом: for имя_переменной in имя_итерируемого_объекта: где *имя_переменной – выбранное вами имя переменной, в которую каждую итерацию
 цикла будет записываться очередное значение из итерируемого объекта.
Зачем нам нужны кортежи в Python (или любой другой неизменяемый тип данных)?
Я прочитал несколько учебников python (например, погружение в Python) и справочник по языку Python.org — я не понимаю, зачем языку нужны кортежи.
Кортежи не имеют методов по сравнению со списком или набором, и если я должен преобразовать Кортеж в набор или список, чтобы иметь возможность сортировать их, то какой смысл использовать Кортеж в первую очередь?
Неизменность?
Почему кого-то волнует, что переменная живет в другом месте в памяти, чем когда она была первоначально выделена? Вся эта история с неизменностью в Python, кажется, слишком подчеркнута.
В C/C++, если я выделяю указатель и указываю на некоторую допустимую память, мне все равно, где находится адрес, пока он не будет null, прежде чем я его использую.
Всякий раз, когда я ссылаюсь на эту переменную, мне не нужно знать, указывает ли указатель на исходный адрес или нет. Я просто проверяю null и использую его (или нет).
В Python, когда я выделяю строку (или кортеж), назначаю ее x, а затем изменяю строку, почему меня волнует, является ли она исходным объектом? Пока переменная указывает на мои данные, это все, что имеет значение.
>>> x='hello'
>>> id(x)
1234567
>>> x='good bye'
>>> id(x)
5432167

x все еще ссылается на нужные мне данные, почему кому-то нужно заботиться о том, совпадает ли его идентификатор или отличается?
 python
 tuples
 Поделиться
 Источник

 pyNewGuy    
 01 февраля 2010 в 01:08
 9 ответов
 
  •  Зачем нам нужен другой тип данных для указателя?
     В основном указатель-это переменная, используемая для хранения адреса памяти ,который всегда является шестнадцатеричным(адрес памяти) , тогда зачем нам нужен другой тип данных для хранения адреса. EX:int *a; можем ли мы использовать этот a для хранения адреса float.
  •  Зачем нам нужны протоколы pop3 или Imap?
     Нам нужен протокол Smtp, потому что мы хотим отправлять электронные письма на другие серверы. Но зачем нам нужны протоколы pop3 или Imap для написания почтовых серверов? Если я храню сообщения на своем сервере,разве я не могу получить к ним прямой доступ? Когда пользователь захочет загрузить…

126
  1. неизменяемые объекты могут позволить существенную оптимизацию; по-видимому, именно поэтому строки также неизменяемы в Java, разработаны совершенно отдельно, но примерно в то же время, что и Python, и почти все неизменяемо в действительно функциональных языках.
  2. в частности, в Python хэшируемыми могут быть только неизменяемые объекты (и, следовательно, члены наборов или ключи в словарях). Опять же, это позволяет оптимизировать, но гораздо больше, чем просто «substantial» (разработка приличных таблиц hash, хранящих полностью изменяемые объекты, — это кошмар-либо вы снимаете копии всего, как только вы это сделаете, либо кошмар проверки того, изменился ли hash объекта с тех пор, как вы в последний раз ссылались на него, поднимает свою уродливую голову).
Пример проблемы оптимизации:
$ python -mtimeit '["fee", "fie", "fo", "fum"]'
1000000 loops, best of 3: 0.432 usec per loop
$ python -mtimeit '("fee", "fie", "fo", "fum")'
10000000 loops, best of 3: 0.0563 usec per loop

 Поделиться

 Alex Martelli    
 01 февраля 2010 в 01:23

42
Ни один из приведенных выше ответов не указывает на реальную проблему кортежей и списков, которую многие новички в Python, похоже, не до конца понимают.
Кортежи и списки служат разным целям. Списки хранят однородные данные. У вас может и должен быть такой список:
["Bob", "Joe", "John", "Sam"]

Причина правильного использования списков заключается в том, что все они представляют собой однородные типы данных, в частности имена людей. Но возьмите такой список:
["Billy", "Bob", "Joe", 42]

Этот список-полное имя одного человека и его возраст. Это не один тип данных. Правильный способ хранения этой информации-либо в кортеже, либо в объекте. Допустим, у нас есть несколько :
[("Billy", "Bob", "Joe", 42), ("Robert", "", "Smith", 31)]

Неизменность и изменчивость кортежей и списков не является главным отличием. Список-это список однотипных элементов: файлов, имен, объектов. Кортежи — это группа объектов различных типов. Они имеют различное применение, и многие кодеры Python злоупотребляют списками для того, для чего предназначены кортежи.
Пожалуйста, не надо.
Редактировать:
Я думаю, что это сообщение в блоге объясняет, почему я думаю об этом лучше, чем раньше:  http://news.e-scribe.com/397
 Поделиться

 Grant Paul    
 01 февраля 2010 в 01:50

24
если я должен преобразовать кортеж в набор или список, чтобы иметь возможность сортировать их, какой смысл использовать кортеж в первую очередь?
В данном конкретном случае, вероятно, в этом нет смысла. Это не проблема, потому что это не один из случаев, когда вы рассматриваете возможность использования кортежа.
Как вы указываете, кортежи неизменны. Причины наличия неизменяемых типов применимы к кортежам:
  • эффективность копирования: вместо копирования неизменяемого объекта вы можете создать для него псевдоним (привязать переменную к ссылке)
  • эффективность сравнения: при использовании copy-by-reference вы можете сравнить две переменные, сравнивая местоположение, а не содержимое
  • интернирование: вам нужно сохранить не более одной копии любого неизменяемого значения
  • нет необходимости синхронизировать доступ к неизменяемым объектам в параллельном коде
  • корректность const: некоторые значения не должны изменяться. Это (для меня) является основной причиной неизменяемых типов.
Обратите внимание, что конкретная реализация Python может не использовать все вышеперечисленные функции.
Ключи словаря должны быть неизменяемыми, иначе изменение свойств ключевого объекта может привести к недействительности инвариантов базовой структуры данных. Таким образом, кортежи потенциально могут использоваться в качестве ключей. Это следствие корректности const.
См .Также » Введение кортежей «, из  Погружения в Python .
 Поделиться

 outis    
 01 февраля 2010 в 01:23
  •  Зачем нам нужны Hadoop дистрибутивов?
     Я новичок в Hadoop. Итак, пожалуйста, кто-нибудь может объяснить мне, зачем нам нужны cloudera или Hortonworks? Мы можем скачать каждый проект Apache и использовать эти библиотеки для создания проекта больших данных, верно? И, кроме того, если я уже использую linux OS, должен ли я использовать…
  •  Зачем нам нужны структуры данных, отличные от HashMap
     Map (или HashMap) занимает постоянное время для вставки, удаления и извлечения. В то время как все другие структуры данных, которые я знаю до сих пор, не занимают постоянного времени, и их время для вышеуказанных операций зависит от размера входных данных. Итак, зачем нам вообще нужны все…

15
Иногда нам нравится использовать объекты в качестве ключей словаря
Как бы то ни было, кортежи в последнее время (2.6+) выросли index() и count() методов
 Поделиться

 John La Rooy    
 01 февраля 2010 в 01:16

9
Я всегда считал, что наличие двух совершенно разных типов для одной и той же базовой структуры данных (массивов) является неудобным дизайном, но не реальной проблемой на практике.  (У каждого языка есть свои бородавки, включая Python, но это не важно.)
Почему кого-то волнует, что переменная находится в другом месте в памяти, чем когда она была первоначально выделена? Вся эта история с неизменностью в Python, кажется, слишком подчеркнута.
Это разные вещи.  Изменчивость не связана с местом, где она хранится в памяти; это означает, что материал, на который она указывает , не может измениться.
Python объекты не могут изменить местоположение после их создания, изменчивы они или нет.  (Точнее, значение id() не может измениться-на практике то же самое.)  Внутреннее хранилище изменяемых объектов может изменяться, но это скрытая деталь реализации.
>>> x='hello'
>>> id(x)
1234567
>>> x='good bye'
>>> id(x)
5432167

Это не изменение («mutating») переменной; это создание новой переменной с тем же именем и удаление старой.  Сравните с операцией мутации:
>>> a = [1,2,3]
>>> id(a)
3084599212L
>>> a[1] = 5
>>> a
[1, 5, 3]
>>> id(a)
3084599212L

Как указывали другие, это позволяет использовать массивы в качестве ключей к словарям и другим структурам данных, которые нуждаются в неизменяемости.
Обратите внимание, что ключи для словарей не обязательно должны быть полностью неизменяемыми.  Только та его часть, которая используется в качестве ключа, должна быть неизменной; для некоторых применений это важное различие.  Например, у вас может быть класс, представляющий пользователя, который сравнивает равенство и hash по уникальному имени пользователя.  Затем вы можете повесить другие изменяемые данные на класс — «пользователь вошел в систему» и т. Д.  Поскольку это не влияет на равенство или hash, можно и вполне допустимо использовать это в качестве ключа в словаре.  Это не слишком часто требуется в Python; Я просто указываю на это, так как несколько человек утверждали, что ключи должны быть «immutable», что только частично верно.  Однако я много раз использовал это с картами и наборами C++.
 Поделиться

 Glenn Maynard    
 01 февраля 2010 в 02:06

7
Как гнибблер предложил в комментарии, у Гвидо было  мнение , которое не полностью accepted/appreciated: “lists are for homogeneous data, tuples are for heterogeneous data”. Конечно, многие из противников интерпретировали это как означающее, что все элементы списка должны быть одного типа.
Мне нравится смотреть на это по-другому, не в отличие от  других , которые тоже были в прошлом:
blue= 0, 0, 255
alist= ["red", "green", blue]

Обратите внимание, что я считаю alist однородным, даже если тип(alist[1]) != тип(alist[2]).
Если я смогу изменить порядок элементов, и у меня не будет проблем в коде (кроме предположений, например “он должен быть отсортирован”), затем следует использовать список. Если нет (как в кортеже blue выше), то я должен использовать кортеж.
 Поделиться

 tzot    
 01 февраля 2010 в 10:41

6
Они важны, поскольку гарантируют вызывающему, что объект, который они передают, не будет мутирован.
 Если вы сделаете это:
a = [1,1,1]
doWork(a)

У вызывающего абонента нет гарантии значения a после вызова.
 Однако,
a = (1,1,1)
doWorK(a)

Теперь вы, как вызывающий абонент или читатель этого кода, знаете, что a -это одно и то же.
 Вы всегда могли бы для этого сценария сделать копию списка и передать его, но теперь вы тратите циклы вместо того, чтобы использовать языковую конструкцию, которая имеет больше семантического смысла.
 Поделиться

 Matthew Manela    
 01 февраля 2010 в 02:01

1
вы можете посмотреть  здесь , чтобы обсудить это
 Поделиться

 ghostdog74    
 01 февраля 2010 в 01:17

1
Ваш вопрос (и последующие комментарии) сосредоточены на том, изменяется ли id() во время задания. Сосредоточение внимания на этом последующем эффекте разницы между заменой неизменяемого объекта и модификацией изменяемого объекта, а не на самой разнице, возможно, не является лучшим подходом.
Прежде чем мы продолжим, убедитесь, что поведение, показанное ниже, соответствует тому, что вы ожидаете от Python.
>>> a1 = [1]
>>> a2 = a1
>>> print a2[0]
1
>>> a1[0] = 2
>>> print a2[0]
2

В этом случае содержимое a2 было изменено, хотя только a1 было присвоено новое значение. В отличие от следующих:
>>> a1 = (1,)
>>> a2 = a1
>>> print a2[0]
1
>>> a1 = (2,)
>>> print a2[0]
1

В этом последнем случае мы заменили весь список, а не обновили его содержимое. С неизменяемыми типами, такими как кортежи, это единственное допустимое поведение.
Почему это имеет значение? Допустим, у вас есть диктант:
>>> t1 = (1,2)
>>> d1 = { t1 : 'three' }
>>> print d1
{(1,2): 'three'}
>>> t1[0] = 0  ## results in a TypeError, as tuples cannot be modified
>>> t1 = (2,3) ## creates a new tuple, does not modify the old one
>>> print d1   ## as seen here, the dict is still intact
{(1,2): 'three'}

Используя кортеж, словарь безопасен от изменения его ключей «out from under it» на элементы, которые hash имеют другое значение. Это крайне важно для обеспечения эффективной реализации.
 Поделиться

 Charles Duffy    
 01 февраля 2010 в 03:42
Похожие вопросы:
Зачем нам нужны C профсоюзов?
 Когда следует использовать профсоюзы? Зачем они нам нужны?
Рубист в Pythonland: что такое реальный пример кортежа?
 Возможный Дубликат : Зачем нам нужны кортежи в Python (или любой другой неизменяемый тип данных)? Я изучаю Python и имею опыт работы в Ruby. Никогда не имея кортежей, я не могу себе представить,…
Зачем нам нужен неизменяемый класс?
 Я не могу понять, каковы сценарии, в которых нам нужен неизменяемый класс. Вы когда-нибудь сталкивались с таким требованием? или, пожалуйста, приведите нам какой-нибудь реальный пример, где мы…
Зачем нам нужен другой тип данных для указателя?
 В основном указатель-это переменная, используемая для хранения адреса памяти ,который всегда является шестнадцатеричным(адрес памяти) , тогда зачем нам нужен другой тип данных для хранения адреса….
Зачем нам нужны протоколы pop3 или Imap?
 Нам нужен протокол Smtp, потому что мы хотим отправлять электронные письма на другие серверы. Но зачем нам нужны протоколы pop3 или Imap для написания почтовых серверов? Если я храню сообщения на…
Зачем нам нужны Hadoop дистрибутивов?
 Я новичок в Hadoop. Итак, пожалуйста, кто-нибудь может объяснить мне, зачем нам нужны cloudera или Hortonworks? Мы можем скачать каждый проект Apache и использовать эти библиотеки для создания…
Зачем нам нужны структуры данных, отличные от HashMap
 Map (или HashMap) занимает постоянное время для вставки, удаления и извлечения. В то время как все другие структуры данных, которые я знаю до сих пор, не занимают постоянного времени, и их время для…
Зачем нам нужны сопрограммы в python?
 Я давно слышал о совместных процедурах, но никогда ими не пользовался. Как я знаю, копрограммы подобны генераторам. Зачем нам нужны совместные процедуры в Python?
Зачем нам нужны эпохи?
 В курсах нет ничего о эпохах, но на практике они везде используются. Зачем они нам нужны, если оптимизатор находит лучший вес за один проход. Почему модель улучшается?
Зачем нам нужны воздушные крючки?
 Док говорит:: Крючки интерфейсы с внешними приложениями и базами данных как Hive, С3, MySQL, Postgres, и HDFS, и свинья. Крючки реализуют общий интерфейс, когда это возможно, и действуют как…
Python. Кортежи. Основные понятия. Свойства кортежей
Содержание
Поиск на других ресурсах:
1. Понятие кортежа. Примеры. Необходимость применения кортежей
В языке Python кортеж – это группа объектов разных типов, взятых в круглые скобки которая не допускает изменения (есть неизменяемой). Кортежи имеют много свойств. С кортежами можно применять различные операции.
Согласно документации Python, общая форма описания класса кортежа следующая:
class tuple([iterable])
где iterable – некоторая последовательность объектов.
Кортежи необходимы в случаях, когда нужно использовать фиксированные наборы объектов. Одним из примеров может быть использование кортежей в качестве ключей к элементам словарей (ключе нельзя изменять). Также использование кортежей есть важным, когда в задаче нужно обеспечить поддержку целостности, то есть кортеж не может быть изменен из другой ссылки.
Если в задаче нужно использовать коллекции объектов, которые могут быть изменены, то для этих случаев нужно использовать списки.
Примеры кортежей.
() # пустой кортеж
(2.3,'ABCDE', False) # кортеж из 3-х элементов разных типов
('world', (2.88, "bestprog"), 3.141592) # вложенный кортеж
(3.88, 2,) # Кортеж из двух элементов
  ⇑
2. Свойства кортежей
Для кортежей выделяют следующие свойства:
  • 1. Кортежи – это упорядоченные коллекции объектов произвольных типов. Коллекции объектов упорядочены слева направо.
  • 2. В кортежах доступ к элементам обеспечивается по смещению. Кортежи поддерживают операции, которые используются по смещению элементов, например, вытягивание среза, индексирование и т.п..
  • 3. Кортежи относятся к категории неизменяемых последовательностей. К кортежам невозможно применить операции непосредственного изменения. Однако, если элементом кортежа есть изменяемый элемент (например список), то этот элемент можно изменять в кортеже.
  • 4. Кортежи гетерогенны. Термин «гетерогенный» означает, что кортежи могут содержать другие составные объекты, например, списки, строки или другие кортежи.
  • 5. Кортежи поддерживают произвольное количество вложений.
  • 6. Кортежи имеют фиксированную длину. Если нужно изменить длину кортежа, то при этом обязательно создается копия кортежа в новом месте памяти, длина которой иная.
  • 7. Кортежи можно представлять как массивы ссылок на объекты.
  ⇑
3. Отличия между кортежами и списками
Между кортежами и списками можно выделить следующие отличия:
  • кортеж формируется в круглых скобках (), список формируется в квадратных скобках [];
  • кортежи относятся к неизменяемым последовательностям, списки относятся к изменяемым последовательностям. К кортежам невозможно применить операции, которые непосредственно их изменяют. К спискам такие операции применять можно;
  • кортежи имеют фиксированную длину (количество элементов), списки имеют переменную длину. Если нужно увеличить размер кортежа, то нужно создать копию.
  ⇑
4. Что есть общего между кортежами и списками?
Между кортежами и списками можно выделить следующие общие особенности:
  1. Списки и кортежи являются коллекциями объектов или последовательностями.
  2. Списки и кортежи обеспечивают приведение в порядок своих объектов слева направо.
  3. Кортежи и списки могут содержать элементы (объекты) любого типа.
  4. В кортежах и списках доступ к элементам осуществляется по смещению.
  5. Кортежи и списки поддерживают одинаковые операции, основанные на использовании смещения. Например, индексирование, получение среза и т.п.
  6. Кортежи и списки есть гетерогенными. Это значит, что кортежи и списки могут содержать другие составные элементы (строки, списки, кортежи).
  7. Кортежи и списки поддерживают произвольное количество вложений.
  8. Кортежи и списки позволяют сохранять массивы ссылок на другие сложные объекты, которые, в свою очередь также могут быть кортежами, списками или строками.
  ⇑
5. Способы (операции) создания кортежа
Создать кортеж можно одним из 4 способов приведенных ниже.
1. С помощью пары пустых скобок ().
В этом случае создается пустой кортеж. Например
() # создается пустой кортеж
2. В случае одиночного кортежа с помощью запятой в конце элемента, взятого в круглые скобки.
Например.
(2,)
(True, )
 
3. С помощью использования нескольких элементов разделенных запятой и взятых в круглые скобки.
Например.
(2.5, -11, 3)
(a, True, "Tuples")
 
4. С помощью встроенной функции tuple().
Например.
# Создание вложенных кортежей с помощью операции =
a = (2.5, -11, 3)
b = (a, True, "Tuples") # b = ((2.5, -11, 3), True, 'Tuples')
c = tuple(b) # c = ((2.5, -11, 3), True, 'Tuples')
  ⇑
6. Пример создания кортежа, содержащего целые случайные числа
# Создать кортеж из последовательности 5 целых чисел,
# которые лежат в диапазоне от 0 до 10.

# Для использования случайных чисел нужно
# подключить модуль random
import random

# 1. Создать список из чисел
lst = [] # сначала пустой список
i = 0
while i < 5:
    num = random.randint(0,10)
    lst = lst + [num]
    i = i+1

# 2. Создать кортеж из элементов списка
a = tuple(lst)

print("a = ", a) # a = (3, 0, 2, 6, 2)
Результат работы программы
a = (4, 1, 4, 5, 7)
  ⇑
7. Пример поиска заданного элемента в кортеже
# Поиск заданного элемента в кортеже
# 1. Заданный кортеж из строк
a = ('ab', 'abcd', 'cde', 'abc', 'def')

# 2. Ввод искомой строки
s = str(input("s = "))

# 3. Цикл обхода кортежа
result = False # результат
i = 0
while i < len(a): # len(a) - количество элементов в кортеже
    if (a[i]==s):
        result = True
        break
    i = i+1

if (result):
    print("Yes")
else:
    print("No")
  ⇑
8. Функция len(). Количество элементов в кортеже
Для определения длины кортежа (количество элементов в кортеже) используется стандартная функция len().
Пример.
# Функция len() - количество элементов в кортеже

a = () # пустой кортеж
l = len(a) # l = 0

b = (1, 3, 7, 13, 'abc', True)
l = len(b) # l = 6

# Вложенный кортеж
c = (a, b, "Hello", 2.33)
l = len(c) # l = 4
  ⇑
9. Представление кортежей с одним элементом
Чтобы указать, что объект есть кортежем, нужно после элемента указать символ ‘ , ‘ (запятая). В противном случае объект будет восприниматься как число.
Например.
# Отличие между объектом, взятым в скобки () и кортежем.
# Число num1 имеющее значение 255
num1 = (255)
num2 = num1 + 5 # num2 = 255 + 5 = 260 - суммирование обычных целых чисел

# Кортеж содержащий число 255 - в конце указывается запятая
A = (255,)
# B = A + 5 - запрещено, исключительная ситуация
  ⇑
Связанные темы
  ⇑
 
 
Кортежи | 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 3: кортежи (tuple) и операции с ними: len, del, count, index
На этом занятии
 мы познакомимся с еще одной коллекцией данных в Python – словарем. В
 отличие от списков
 
Кортеж – это
 упорядоченная неизменяемая коллекция произвольных данных.
Для задания
 кортежа достаточно перечислить значения через запятую:
 
или же, это
 эквивалентно такой записи:
 
Чтобы присвоить
 только одно значение кортежу, используется такой синтаксис:
 
b = 1,     или    b = (1,)
 
то есть,
 последняя запятая указывает, что 1 следует воспринимать как первый элемент
 кортежа. Если записать просто 1, то оно будет восприниматься как обычное число.
 
Если записать
 переменные через запятую, то им можно присвоить значения из кортежа:
 
Но вот так:
 
уже возникнет
 ошибка, т.к. число значений в кортеже меньше числа переменных.
 
Для определения
 длины кортежа (числа его элементов), используется уже знакомая вам функция 
 
Далее, доступ к
 элементам кортежа осуществляется также как и к элементам списков:
 
— по индексу:
 
— через срезы:
 
a[1:2]
a[0:-1]
a[:3]
a[1:]
a[:]
О срезах мы
 подробно говорили, когда рассматривали списки, поэтому не вижу смысла
 дублировать здесь эту информацию. Обратите лишь внимание на то, что вот такая
 операция
 
не создает копию кортежа – это будут ссылки на один и тот же кортеж:
 
увидим одно и то
 же значение id.
 
Если кортежи так
 похожи на списки, то в чем их преимущество перед ними? Другими словами: в каких
 случаях следует использовать кортеж вместо списка? Во-первых, кортеж – это
 неизменяемый тип, то есть, мы в отличие от списков, не можем выполнять такие
 операции:
 
это приведет к
 ошибке. Значит, кортеж можно использовать, когда необходимо «запретить»
 программисту менять значения элементов списка. Во-вторых, кортежи можно
 использовать в качестве ключей у словарей, например, так:
 
d = {}
d[a] = "кортеж"
В-третьих,
 кортеж занимает меньше памяти, чем такой же список, например:
 
lst=[1,2,3]
t = (1,2,3)
print(lst.__sizeof__())
print(t.__sizeof__())
Как видите,
 размер кортежа меньше, чем списка. Здесь использован метод __sizeof__, который
 возвращает размер данных в байтах.
 
И, наконец,
 в-четвертых, операции с кортежами выполняются быстрее, чем со списками,
 например, перебор элементов или доступ к отдельному элементу.
 
Отсюда
 получается такой один общий, глобальный вывод: если мы работаем с неизменяемым
 упорядоченным списком, то предпочтительнее использовать кортеж.
 
Чтобы создать
 пустой кортеж можно использовать такие конструкции:
 
a = ()
b = tuple()
print(type(a), type(b))
Спрашивается:
 зачем создавать пустой кортеж, если он относится к неизменяемым типам. В
 действительности, мы лишь не можем менять уже существующие элементы в кортеже,
 но можем добавлять новые, используя оператор +:
 
или для
 добавления в начало кортежа:
 
Также можно
 добавить вложенный кортеж:
 
или делать дубли
 в кортеже:
 
b = (0,)*10
b = ("hello", "world")*5
Все эти операции
 вполне допустимы. 
 
Далее, функция tuple позволяет
 создавать кортежи на основе любых упорядоченных списков:
 
a = tuple([1,2,3])
a = tuple("Привет мир")
И обратно, из
 кортежа можно сформировать список:
 
t = (1,2,3)
lst = list(t)
Также кортежи
 могут хранить самые разные данные:
 
a = (True, [1,2,3], "hello", 5, {"house": "дом"})
Причем,
 смотрите, если обратиться, например, к списку:
 
то сам по себе
 список – это изменяемый тип, следовательно, его значение даже в кортеже мы
 можем спокойно менять:
 
То есть,
 неизменяемость кортежа относится к его структуре элементов и переменным
 
которые ссылаются
 на конкретные объекты. Но, если объекты могут изменяться, то это никто не
 запрещает делать.
 
Так как сам
 кортеж – неизменяемый объект, то удалить отдельные его элементы невозможно:
 
но можно удалить
 его целиком:
 
после этого
 кортеж a перестанет
 существовать.
 
Методы кортежа
У кортежа
 имеется два таких метода:
 
a = ("abc", 2, [1,2], True, 2, 5)
a.count("abc")
a.count(2)
который
 возвращает число найденных элементов с указанным значением. Если элемент не
 найден:
 
то возвращается
 число 0.
 
Следующий метод:
 
возвращает
 индекс первого найденного элемента с указанным значением. Второй необязательный
 параметр
 
позволяет
 задавать индекс начала поиска элемента. В данном случае поиск будет начинаться
 с третьего индекса. А последний третий аргумент:
 
определяет
 индекс, до которого идет поиск (не включая его). Если же записать вот так:
 
то возникнет
 ошибка, т.к. в поиск будет включен только 3-й индекс и там нет значения 2.
 
Задания для самопроверки
1. Дан кортеж:
 
p =
 («+792345678», «+792345478», «+792355678»,
 «+592345678», «+392345678», «+7923456558»)
 
Нужно вывести
 все номера, начинающиеся с «+7».
 
2. Имеется набор
 оценок в виде строки:
 
«Оценки: 5,
 4, 3, 4, 2, 4, 5, 4″
 
Необходимо
 создать кортеж, в котором находились бы только оценки в виде целых чисел:
 
(5, 4, 3, 4, 2,
 4, 5, 4)
 
3. Вывести
 значения кортежа:
 
((1,2,3),(3,4,5),(6,7,8))
 
в виде таблицы:
 
1 – 2 – 3
 
4 – 5 – 6
 
7 – 8 – 9
 
 кортежей Python: пошаговое руководство 
  Кортежи Python — это структура данных, в которой хранится упорядоченная последовательность значений. Кортежи неизменяемы. Это означает, что вы не можете изменять значения в кортеже. Кортежи обозначаются круглыми скобками. 
 Найди свой матч на тренировочном лагере
  •  
 Шоколад Ваниль Мята Клубника Choc-Chip
 1 2 3 4
 Шоколадный Ваниль Мятный Клубничный Choc-Chip
-5-4-3-2-1
  empty_tuple   =   () 
  print   (empty_tuple) 
    •   
      tup   =   'python'  ,   'geeks' 
         
      tup   =   (  'python'  ,   'geeks'  ) 
      print   (tup Output) 
    0
  • 2
    •   
      кортеж1   =   (  0  ,               ) 
      кортеж2   =   (  'питон'  ,   'компьютерщик'  ) 
      
               
      
      кортеж1   =   (  0   0     1  ,   2  ,   3  ) 
      кортеж2   =   (  'питон'  ,  ''   =   (кортеж1, кортеж2) 
      печать   (кортеж3) 
      
      tuple3   =   ( ' python ' , print   , print    9 0154  (tuple3) 
      
      кортеж1   =   (  0  ,  , 2    , 2    , 2     1  
      кортеж1 [  0  ]   =   4 
      печать   (кортеж1) 
      
      tuple1   =   (  0, 1   0, 1   2  ,   3  ) 
      печать   (кортеж1 [  1  :]) 
      печать   (кортеж1  :: -   [-   :: -   ]) 
      печать   (кортеж1 [  2  :   4  ]) 
      
      кортеж3   =   (  0  ,         1  tuple3 
      print   (tuple3) 
      
      tuple2   =   =   =    'python'  ,   'geek'  ) 
      print   (  len   (tuple2)) 
      
      list1   =   [  0  ,   1  ,   2         кортеж   (список1)) 
      печать   (  кортеж   (  'python'  )) 
     9 0071
      
      tup   =   (  'geek'  ,)  
     9000
      для   i   в диапазоне     (  int   (n)): 
        tup   =   (tup,)         (tup) 
      
      tuple1   =   (  'python'  ,  ) 
      кортеж2   =   (  'кодер'  ,   1  ) 
      
      
      если   (кортеж  !   =   0  ): 
      
      
      
        печать   (    еще 5 
        печать   (  'То же'  ) 
      печать   (  'Максимальный элемент в тупе les 1,2: '  + 
        str   (  max   (tuple1))   +  ', '  + 
      90r154   max   (кортеж2))) 
      print   (  'Минимальный элемент в кортежах 1,2:'   + 
        str   (  min ( ) min (  min (  min (  min) )   +   ','   +   str   (  min   (tuple2))) 
     Оператор Пример
     Оператор  +  возвращает кортеж, содержащий все элементы первого и второго объекта кортежа.
      >>> t1 = (1,2,3)
>>> t2 = (4,5,6)
>>> t1 + t2
(1, 2, 3, 4, 5, 6)
>>> t2 + (7,)
(4, 5, 6, 7)  
     Оператор  *  объединяет несколько копий одного и того же кортежа.
      >>> t1 = (1,2,3)
>>> t1 * 4
(1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3)  
     Оператор  []  Возвращает элемент по заданному индексу.Отрицательный индекс отсчитывает позицию с правой стороны.
      >>> t1 = (1,2,3,4,5,6)
>>> t1 [3]
4
>>> t1 [-2]
5  
     Оператор  [:]  возвращает элементы в диапазоне, заданном двумя индексными операндами, разделенными символом : .
     Если первый операнд опущен, диапазон начинается с нуля.
     Если второй операнд опущен, диапазон увеличивается до конца кортежа.
      >>> t1 = (1,2,3,4,5,6)
>>> t1 [1: 3]
(2, 3)
>>> t1 [3:]
(4, 5, 6)
>>> t1 [: 3]
(1, 2, 3)  
     Оператор  в  возвращает истину, если элемент существует в данном кортеже.
      >>> t1 = (1,2,3,4,5,6)
>>> 5 в t1
Правда
>>> 10 в t1
Ложь  
     Оператор  not in  возвращает true, если элемент не существует в данном кортеже.
      >>> t1 = (1,2,3,4,5,6)
>>> 4 не в t1
Ложь
>>> 10 не в t1
Правда  
     Python Tuple используется для хранения последовательности неизменяемых объектов Python.Кортеж похож на списки, поскольку значение элементов, хранящихся в списке, может быть изменено, тогда как кортеж является неизменным, а значение элементов, хранящихся в кортеже, не может быть изменено.
     Создание кортежа 
     Кортеж можно записать как набор значений, разделенных запятыми (,), заключенных в маленькие скобки (). Скобки необязательны, но их рекомендуется использовать. Кортеж можно определить следующим образом.
     T1 = (101, «Питер», 22)
     T2 = («Яблоко», «Банан», «Апельсин»)
     Т3 = 10,20,30,40,50
    печать (введите (T1))
     печать (введите (T2))
     печать (тип (Т3))
      Выход: 
     <класс 'кортеж'>
<класс 'кортеж'>
<класс 'кортеж'>
 
     Примечание. Кортеж, созданный без скобок, также известен как упаковка кортежа.
     Пустой кортеж можно создать следующим образом.
     T4 = ()
     Создание кортежа с одним элементом немного отличается. Нам нужно будет поставить запятую после элемента, чтобы объявить кортеж.
     tup1 = ("JavaTpoint")
     печать (введите (tup1))
     # Создание кортежа с одним элементом
     tup2 = ("JavaTpoint",)
     печать (введите (tup2))
      Выход: 
     <класс 'str'>
<класс 'кортеж'>
 
     Кортеж индексируется так же, как и списки.Доступ к элементам в кортеже можно получить, используя их конкретное значение индекса.
     Рассмотрим следующий пример кортежа:
     Пример - 1 
     кортеж1 = (10, 20, 30, 40, 50, 60)
     печать (кортеж1)
     count = 0
     для i в кортеже1:
     print ("tuple1 [% d] =% d"% (count, i))
     count = count + 1
      Выход: 
     (10, 20, 30, 40, 50, 60)
tuple1 [0] = 10
tuple1 [1] = 20
tuple1 [2] = 30
tuple1 [3] = 40
tuple1 [4] = 50
tuple1 [5] = 60
 
     Пример - 2 
     tuple1 = tuple (input ("Введите элементы кортежа... "))
     печать (кортеж1)
     count = 0
     для i в кортеже1:
     print ("tuple1 [% d] =% s"% (count, i))
     count = count + 1
      Выход: 
     Введите элементы кортежа ... 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
 
     Кортеж индексируется так же, как и списки. Доступ к элементам в кортеже можно получить, используя их конкретное значение индекса.
     Мы увидим все эти аспекты кортежа в этом разделе руководства.
     Индексирование и нарезка кортежей 
     Индексирование и срезы в кортеже аналогичны спискам. Индексация в кортеже начинается с 0 и продолжается до длины (кортежа) - 1.
     Доступ к элементам в кортеже можно получить с помощью оператора index []. Python также позволяет нам использовать оператор двоеточия для доступа к нескольким элементам в кортеже.
     Рассмотрите следующее изображение, чтобы подробно разобраться в индексировании и нарезке.
     Рассмотрим следующий пример:
     tup = (1,2,3,4,5,6,7)
     печать (tup [0])
     печать (tup [1])
     печать (tup [2])
     # Это выдаст IndexError
     печать (tup [8])
      Выход: 
     1
2
3
индекс кортежа вне допустимого диапазона
 
     В приведенном выше коде кортеж состоит из 7 элементов, которые обозначают от 0 до 6.Мы попытались получить доступ к элементу вне кортежа, который вызвал ошибку  IndexError .
     кортеж = (1,2,3,4,5,6,7)
     # элемент 1 до конца
     печать (кортеж [1:])
     #element от 0 до 3 element
     печать (кортеж [: 4])
     #element с 1 по 4 элемент
     печать (кортеж [1: 5])
     # элемент от 0 до 6 и сделать шаг 2
     печать (кортеж [0: 6: 2])
      Выход: 
     (2, 3, 4, 5, 6, 7)
(1, 2, 3, 4)
(1, 2, 3, 4)
(1, 3, 5)
 
     Отрицательное индексирование 
     Доступ к элементу кортежа также возможен с использованием отрицательной индексации.Индекс -1 обозначает крайний правый элемент, а -2 - второй последний элемент и так далее.
     Элементы слева направо перемещаются с использованием отрицательной индексации. Рассмотрим следующий пример:
     кортеж1 = (1, 2, 3, 4, 5)
     печать (кортеж1 [-1])
     печать (кортеж1 [-4])
     печать (кортеж1 [-3: -1])
     печать (кортеж1 [: - 1])
     печать (кортеж1 [-2:])
      Выход: 
     5
2
(3, 4)
(1, 2, 3, 4)
(4, 5)
 
     Удаление кортежа 
     В отличие от списков, элементы кортежа не могут быть удалены с помощью ключевого слова  del , поскольку кортежи неизменяемы.Чтобы удалить весь кортеж, мы можем использовать ключевое слово  del  с именем кортежа.
     Рассмотрим следующий пример.
     кортеж1 = (1, 2, 3, 4, 5, 6)
     печать (кортеж1)
     дель кортеж1 [0]
     печать (кортеж1)
     дель кортеж1
     печать (кортеж1)
      Выход: 
     (1, 2, 3, 4, 5, 6)
Отслеживание (последний вызов последний):
  Файл "tuple.py", строка 4, в 
    печать (кортеж1)
NameError: имя 'tuple1' не определено
 
     Базовые операции с кортежами 
     Такие операторы, как конкатенация (+), повторение (*), членство (в), работают так же, как они работают со списком.Для получения более подробной информации рассмотрите следующую таблицу.
     Допустим, объявлены Tuple t = (1, 2, 3, 4, 5) и Tuple t1 = (6, 7, 8, 9).
     Оператор Описание Пример
     Повтор Оператор повторения позволяет многократно повторять элементы кортежа.
     T1 * 2 = (1, 2, 3, 4, 5, 1, 2, 3, 4, 5) 
     Конкатенация Он объединяет кортеж, указанный по обе стороны от оператора.
     T1 + T2 = (1, 2, 3, 4, 5, 6, 7, 8, 9) 
     Членство Возвращает истину, если в кортеже существует конкретный элемент, в противном случае - ложь.
     print (2 in T1) печатает True. 
     Итерация Цикл for используется для перебора элементов кортежа.
     для i в T1:
    печать (я) 
      Выход 
     1
2
3
4
5 
     Длина Используется для получения длины кортежа.
     длина (T1) = 5 
     Python Кортеж встроенных функций 
     SN Функция Описание
     1 cmp (кортеж1, кортеж2) Он сравнивает два кортежа и возвращает true, если tuple1 больше, чем tuple2, в противном случае - false.
     2 len (кортеж) Вычисляет длину кортежа.
     3 макс (кортеж) Возвращает максимальный элемент кортежа
     4 мин (кортеж) Возвращает минимальный элемент кортежа.
     5 кортеж (seq) Преобразует указанную последовательность в кортеж.
     Где использовать кортеж? 
     Использование кортежа вместо списка используется в следующем сценарии.
     1. Использование кортежа вместо списка дает нам четкое представление о том, что данные кортежа постоянны и не должны изменяться.
     2. Кортеж может имитировать словарь без ключей. Рассмотрим следующую вложенную структуру, которую можно использовать как словарь.
     [(101, «Джон», 22), (102, «Майк», 28), (103, «Дастин», 30)]
     Список vs.Кортеж 
     SN Список Кортеж
     1 Литеральный синтаксис списка показан []. Литеральный синтаксис кортежа показан с помощью (). 2 Список изменяемый. Кортеж неизменен. 3 Список имеет переменную длину. Кортеж имеет фиксированную длину. 4 Список предоставляет больше функций, чем кортеж. Кортеж обеспечивает меньшую функциональность, чем список. 5 Список используется в сценарии, в котором нам нужно хранить простые коллекции без ограничений, в которых значение элементов может быть изменено. Кортеж используется в случаях, когда нам нужно хранить коллекции только для чтения, т.е. значение элементов не может быть изменено. Его можно использовать как ключ внутри словаря. 6 Списки менее эффективны с точки зрения памяти, чем кортежи. Кортежи более эффективны с точки зрения памяти из-за своей неизменяемости.