Как найти кортеж числа

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

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

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

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

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

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

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

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

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

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

C : 
0 : 
0 : 
K : 
I : 
E : 

# Попробуйте изменить 0 на «O»
mixed_type[1] = "O"

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

TypeError                                 Traceback (most recent call last)

 in ()
----> 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))

Кортежи против списков

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

numbers_tuple = (1,2,3,4,5)
numbers_list = [1,2,3,4,5]

# Добавим число в кортеж
numbers_tuple.append(6)

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

AttributeError                            Traceback (most recent call last)

 in ()
      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' со списком в качестве одного из его элементов.
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)

 in ()
----> 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)

 in ()
      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))

min() и max()

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

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

5
A

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

# Строка «Apple» автоматически преобразуется в последовательность символов.
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. Что такое кортежи, как их создавать, когда их использовать и какие существуют методы кортежей.

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

Как создать кортеж

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

Кортеж может иметь любое количество элементов разных типов (целые числа, числа с плавающей точкой, списки, строки и т. д).

# Разные типы кортежей

# Пустой кортеж
my_tuple = ()
print(my_tuple)

# Кортеж с целыми числами
my_tuple = (1, 2, 3)
print(my_tuple)

# Кортеж с разными типами данных
my_tuple = (1, "Привет", 3.4)
print(my_tuple)

# Вложенный кортеж
my_tuple = ("мышь", [8, 4, 6], (1, 2, 3))
print(my_tuple)

Вывод:

()
(1, 2, 3)
(1, 'Привет', 3.4)
('мышь', [8, 4, 6], (1, 2, 3))

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

# упаковываем кортеж
my_tuple = 3, 4.6, "собака"
print(my_tuple)

# точно так же можно распаковать кортеж
a, b, c = my_tuple

print(a)      # 3
print(b)      # 4.6
print(c)      # собака

Вывод:

(3, 4.6, 'собака')
3
4.6
собака

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

my_tuple = ("привет")
print(type(my_tuple))  # <class 'str'>

# Создаем кортеж с одним элементом
my_tuple = ("привет",)
print(type(my_tuple))  # <class 'tuple'>

# Можно и без скобок
my_tuple = "привет",
print(type(my_tuple))  # <class 'tuple'>

Вывод:

<class 'str'>
<class 'tuple'>
<class 'tuple'>

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

1. По индексу

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

Примечание. Обратите внимание, что индексирование кортежа начинается с 0. То есть первый элемент кортежа имеет индекс 0.

Кортеж из 9 элементов будет иметь индексы от 0 до 8. Попытка получить доступ к индексу за пределами диапазона индексов кортежа (в нашем случае 9, 10 и т. д.) приведет к ошибке IndexeError.

Индекс должен быть целым числом, поэтому мы не можем использовать float или другие типы в качестве индекса. Это приведет к ошибке TypeError.

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

my_tuple = ('c', 'o', 'd', 'e', 'c', 'h', 'i', 'c', 'k')

print(my_tuple[0])   # 'c' 
print(my_tuple[5])   # 'h'

# Вызов print(my_tuple[9]) приведет к ошибке
# IndexError: list index out of range

# Вызов my_tuple[2.0] приведет к ошибке
# TypeError: list indices must be integers, not float
# Индекс должен быть целым числом

# вложенный кортеж
n_tuple = ("мышь", [8, 4, 6], (1, 2, 3))

# вложенное индексирование
print(n_tuple[0][3])       # 'ь'
print(n_tuple[1][1])       # 4

Вывод:

c
h
ь
4

2. По отрицательному индексу

Python допускает отрицательную индексацию коллекций (наборов значений). Она работает и с кортежами. 

Индекс -1 отсылает к последнему элементу, -2 — ко второму элементу с конца и так далее.

my_tuple = ('c', 'o', 'd', 'e', 'c', 'h', 'i', 'c', 'k')

# Вывод: 'k'
print(my_tuple[-1])

# Вывод: 'c'
print(my_tuple[-9])

Вывод:

k
c

3. С помощью срезов

Получить доступ к диапазону элементов в кортеже можно с помощью оператора срезов :. 

Использование срезов еще называют слайсингом, от английского slicing — «нарезка».

my_tuple = ('c', 'o', 'd', 'e', 'c', 'h', 'i', 'c', 'k')

# элементы со 2 по 4
# Вывод: ('o', 'd', 'e')
print(my_tuple[1:4])

# элементы от начала и до второго элемента
# Вывод: ('c', 'o')
print(my_tuple[:-7])

# два последних элемента
# Вывод: ('c', 'k')
print(my_tuple[7:])

# все элементы от начала до конца
# Вывод: ('c', 'o', 'd', 'e', 'c', 'h', 'i', 'c', 'k')
print(my_tuple[:])

Вывод:

('o', 'd', 'e')
('c', 'o')
('c', 'k')
('c', 'o', 'd', 'e', 'c', 'h', 'i', 'c', 'k')

Как изменить кортеж

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

Переназначить кортеж тоже можно.

my_tuple = (4, 2, 3, [6, 5])

# my_tuple[1] = 9
# Эта строка приведет к ошибке
# TypeError: 'tuple' object does not support item assignment

# Значения изменяемого элемента менять можно
my_tuple[3][0] = 9    # Вывод: (4, 2, 3, [9, 5])
print(my_tuple)

# Можно переназначить кортеж
my_tuple = ('c', 'o', 'd', 'e', 'c', 'h', 'i', 'c', 'k')

# Вывод: ('c', 'o', 'd', 'e', 'c', 'h', 'i', 'c', 'k')
print(my_tuple)

Вывод:

(4, 2, 3, [9, 5])
('c', 'o', 'd', 'e', 'c', 'h', 'i', 'c', 'k')

В Python кортежи можно объединить с помощью оператора +. Это называется конкатенацией.

С помощью оператора * можно повторить элементы в кортеже заданное количество раз. 

Оба оператора + и * приводят к созданию нового кортежа. 

# Конкатенация
#Вывод: (1, 2, 3, 4, 5, 6)
print((1, 2, 3) + (4, 5, 6))

# Повторение
# Вывод: ('Повторить', 'Повторить', 'Повторить')
print(("Повторить",) * 3)

Вывод:

(1, 2, 3, 4, 5, 6)
('Повторить', 'Повторить', 'Повторить')

Как удалить кортеж

Изменять элементы кортежа нельзя. Это значит, что удалять их тоже нельзя.

В Python можно только полностью удалить кортеж — с помощью ключевого слова del.

my_tuple = ('c', 'o', 'd', 'e', 'c', 'h', 'i', 'c', 'k')

# нельзя удалить элементы кортежа
# TypeError: 'tuple' object doesn't support item deletion
# del my_tuple[3]

# зато можно удалить кортеж полностью
del my_tuple

# вызов приведет к ошибке NameError: name 'my_tuple' is not defined
print(my_tuple)

Вывод:

Traceback (most recent call last):
  File "<string>", line 12, in <module>
NameError: name 'my_tuple' is not defined

Методы кортежа

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

Для кортежа существует только два метода: .count() и .index(). 

my_tuple = ('я', 'б', 'л', 'о', 'к', 'о',)

print(my_tuple.count('о'))  # Вывод: 2
print(my_tuple.index('к'))  # Вывод: 4

Вывод:

2
4

Другие операции с кортежами

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

Мы можем проверить, существует ли тот или иной элемент в кортеже или нет, с помощью ключевого слова in и not in.

my_tuple = ('я', 'б', 'л', 'о', 'к', 'о',)

print('я' in my_tuple)
print('х' in my_tuple)
print('п' not in my_tuple)

Вывод:

True
False
True

2. Итерирование по кортежу

Для перебора элементов кортежа можно использовать цикл for. 

for name in ('Андрей', 'Маша'):
    print("Привет, ", name)

Вывод:

Привет, Андрей
Привет, Маша

Преимущества кортежа над списком

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