Кортеж python 3: Кортежи в Python 3 | 8HOST.COM

Первый элемент (‘blue coral’) идёт под индексом 0, а последний (‘elkhorn coral’) – под индексом 3.

При помощи индекса можно вызвать каждый отдельный элемент кортежа. Например:

print(coral[2])
pillar coral

Диапазон индексов данного кортежа – 0-3. Таким образом, чтобы вызвать любой из элементов в отдельности, можно сослаться на индекс.

coral[0] = 'blue coral'
coral[1] = 'staghorn coral'
coral[2] = 'pillar coral'
coral[3] = 'elkhorn coral'

Если вызвать индекс вне диапазона данного кортежа (в данном случае это индекс больше 3), Python выдаст ошибку:

print(coral[22])
IndexError: tuple index out of range

Также в кортежах можно использовать отрицательные индексы; для этого подсчёт ведётся в обратном направлении с конца кортежа, начиная с -1. Отрицательная индексация особенно полезна, если вы хотите определить последний элемент в конце длинного кортежа.

Кортеж coral будет иметь такие отрицательные индексы:

Чтобы запросить первый элемент, ‘blue coral’, по отрицательному индексу, нужно ввести:

print(coral[-4])
blue coral

Элементы кортежа можно склеивать со строками при помощи оператора +:

print('This reef is made up of ' + coral[1])


Также оператор + позволяет склеить два кортежа (больше информации об этом – дальше в статье).

Срез кортежа

Срез позволяет вызывать несколько значений кортежа в диапазоне [start:stop] (start – включительно, stop – исключительно).

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

print(coral[1:3])
('staghorn coral', 'pillar coral')

Как видите, первый элемент (1) включается в диапазон, а последний (3) исключается из него. Потому на экране появляются элементы 1 и 2.

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

print(coral[:3])
('blue coral', 'staghorn coral', 'pillar coral')

Чтобы вывести последние три элемента кортежа coral, нужно ввести:

print(coral[1:])
('staghorn coral', 'pillar coral', 'elkhorn coral')

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

print(coral[-3:-1])
print(coral[-2:])
('staghorn coral', 'pillar coral')
('pillar coral', 'elkhorn coral')

Третий параметр среза – это шаг:

tuple[start:stop:stride]

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

Попробуйте создать большой кортеж и создать срез с шагом:

numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
print(numbers[1:11:2])
(1, 3, 5, 7, 9)

Конструкция numbers[1:11:2] выводит каждый второй элемент кортежа, начиная с индекса 1 (включительно) и заканчивая индексом 11 (исключительно).

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12

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

print(numbers[::3])
(0, 3, 6, 9, 12)

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

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12

Конкатенация и умножение кортежей

Читайте также: Математические вычисления в Python 3

Выполнить конкатенацию или умножение кортежа можно с помощью различных операторов. Для конкатенации используется оператор +, а для умножения – оператор *.

Посмотрим, как работает оператор +, который позволяет склеить два или больше кортежей в новый кортеж.

coral = ('blue coral', 'staghorn coral', 'pillar coral', 'elkhorn coral')
kelp = ('wakame', 'alaria', 'deep-sea tangle', 'macrocystis')
coral_kelp = (coral + kelp)
print(coral_kelp)
('blue coral', 'staghorn coral', 'pillar coral', 'elkhorn coral', 'wakame', 'alaria', 'deep-sea tangle', 'macrocystis')

Оператор + объединяет кортежи и таким образом создаёт новый кортеж, однако он не может изменять существующие кортежи.

Оператор * позволяет умножать кортежи. Умножение используется, если, к примеру, вам нужно скопировать файлы в другой каталог или поделиться плейлистом с друзьями.

Попробуйте умножить кортеж coral на 2, а kelp – на 3. Присвойте полученный результат новым кортежам.

multiplied_coral = coral * 2
multiplied_kelp = kelp * 3
print(multiplied_coral)
print(multiplied_kelp)
('blue coral', 'staghorn coral', 'pillar coral', 'elkhorn coral', 'blue coral', 'staghorn coral', 'pillar coral', 'elkhorn coral')


Оператор * позволяет реплицировать кортеж указанное количество раз и создавать новые кортежи на основе исходных данных.

Функции кортежей

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

Функция len()

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

len(coral)

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

Попробуйте вывести длину кортежей kelp и numbers:

print(len(kelp))
print(len(numbers))
4
13

В кортеже kelp 4 элемента:

kelp = ('wakame', 'alaria', 'deep-sea tangle', 'macrocystis')

А в numbers их 13.

numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)

Функция len() очень полезна при работе с большими кортежами.

Функции max() и min()

При работе с кортежами, состоящими из числовых элементов (как целых, так и с плавающей точкой), функции max() и min() помогают найти самое высокое и самое низкое значение кортежа.

Эти функции полезны при работе с количественными данными (такими как результаты тестов, температура, цены и т.д.).

Рассмотрим кортеж из чисел с плавающей точкой:

more_numbers = (11.13, 34.87, 95.59, 82.49, 42.73, 11.12, 95.57)

Чтобы вывести на экран максимальное значение, нужно передать кортеж функции max(), а затем объединить её с print():

print(max(more_numbers))
95.59

Аналогичным образом работает функция min():

print(min(more_numbers))
11.12

Как и len(), функции max() и min() будут очень полезными при работе с большим количеством данных.

Чем кортежи отличаются от списков?

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

Однако вы можете объединить два или больше кортежа в новый кортеж

Рассмотрим кортеж coral:

coral = ('blue coral', 'staghorn coral', 'pillar coral', 'elkhorn coral')

К примеру, вы хотите заменить элемент ‘blue coral’ новым элементом, ‘black coral’. Попробуйте изменить его так, как вы сделали бы это со списком:

coral[0] = 'black coral'

Вы получите ошибку:

TypeError: 'tuple' object does not support item assignment

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

list(coral)

Теперь coral – список, а не кортеж:

coral = ['blue coral', 'staghorn coral', 'pillar coral']

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

Чтобы преобразовать список в кортеж, используйте функцию tuple().

Читайте также: Преобразование типов данных в Python 3

Заключение

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

Теперь вы знакомы с основными функциями кортежей и умеете выполнять базовые операции с ними (например, конкатенацию, умножение, срезы и т.п.).

Кортежи (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 3 | Понимание переменных кортежей в Python 3

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

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

• Кортежи — это переменная, которая позволяет нам хранить множество объектов в одном месте. Tuple — один из четырех встроенных типов данных Python для хранения коллекций данных; остальные три — Dictionary, List и Set, все они имеют разные свойства и приложения.
• Круглые скобки используются для записи кратных чисел. В python кортеж аналогичен списку. Мы не можем использовать float или другие типы, потому что индекс содержит целые числа.

Python 3 Значения доступа к кортежу

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

1. Доступ к кортежам с помощью индексирования

• Мы используем оператор индекса для получения элемента в кортеже, где индекс начинается с 0.
• В результате индексы варьируются от 0 до 5 для кортежа с 6 элементами. Ошибка индекса будет вызвана, если мы попытаемся получить доступ к форме индекса снаружи.
• Отличие состоит в том, что после назначения кортежа мы не можем изменить его элементы, тогда как мы можем изменить содержимое списка.
• В приведенном ниже примере показан доступ к кортежам посредством индексации в python.

Код:

 py_tup = ('A', 'Q', 'S', 'T', 'B', 'N')
печать (py_tup [0])
print (py_tup [5]) 

Вывод:

2.

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

Код:

 py_tup = ('A', 'Q', 'S', 'T', 'B', 'N')
печать (py_tup [-1])
print (py_tup [-4]) 

Вывод:

3. Доступ к кортежам с помощью срезов

• Лучший способ визуализировать срезы — представить индекс в середине элементов, как видно ниже. Если мы хотим получить доступ к диапазону, нам понадобится индекс, который разбивает кортеж на слайсы.
• Используя двоеточие оператора среза, мы можем получить доступ к различным элементам кортежа. В приведенном ниже примере показан доступ к кортежам с помощью отрицательной индексации в python следующим образом.

Код:

 py_tup = ('A', 'Q', 'S', 'T', 'B', 'N')
печать (py_tup [2:4])
print (py_tup [:-5]) 

Вывод:

Python 3 tuple delete

• Элементы кортежа не могут быть изменены. Из-за этого мы не можем удалять или удалять записи из кортежа.
• Невозможно удалить отдельные элементы кортежа. Конечно, нет ничего плохого в создании нового кортежа, исключающего нежелательные компоненты.
• Кортежи неизменяемы; таким образом, мы не можем удалить из них ни одного элемента. Используя метод del, мы можем удалить весь кортеж.
• В приведенном ниже примере показано, что мы не можем удалить одно значение кортежа из элемента. В приведенном ниже примере мы пытаемся удалить один элемент, но выдает ошибку.

Код:

 py_tup = ('A', 'Q', 'S', 'T', 'B', 'N')
дель py_tup (tup1 [0])
print (py_tup) 

Вывод:

• В приведенном ниже примере показано удаление всех элементов из кортежа в python. В приведенном ниже примере мы удаляем кортеж py_tup.

Код:

 py_tup = ('A', 'Q', 'S', 'T', 'B', 'N')
del py_tup 

Вывод:

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

Код:

 py_tup = ('A', 'Q', 'S', 'T', 'B', 'N')
дель py_tup
print (py_tup) 

Вывод:

Python 3 Операции с кортежами

Мы можем выполнить следующие операции с кортежами в python следующим образом.

1. Проверка членства в кортеже

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

Код:

 py_tup = ('A', 'Q', 'S', 'T', 'B', 'N')
печать («а» в py_tup)
print('A' in py_tup) 

Вывод:

2.

Для итерации каждого элемента мы используем цикл for в python. В приведенном ниже примере показано, как итерация с использованием кортежа выглядит следующим образом.

Код:

 для stud_name в ('ABC', 'PQR'):
    print("Студент", stud_name) 

Вывод:

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

В приведенном ниже примере показано создание кортежа в python следующим образом. Мы создаем имя кортежа как py_tup. Код:

 Py_tup = ('ABC', 'PQR')
print (Py_tup) 

Вывод:

4. Объединение кортежей в Python

Мы можем объединить два кортежа в Python, используя «+». В приведенном ниже примере мы объединяем py_tup1 и py_tup2 следующим образом.

Код:

 Py_tup1 = ('ABC', 'PQR')
Py_tup2 = ('11', '12', '13')
печать (Py_tup1)
печать (Py_tup2)
print(Py_tup1 + Py_tup2) 

Вывод:

5.

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

Код:

 py_tup = ('кортеж',)*3
печать (py_tup) 

Вывод:

Функции кортежа Python 3

Ниже приведена функция кортежа Python 3 следующим образом.

1. Len – Функция Len используется для нахождения длины кортежей. В приведенном ниже примере функция len показана следующим образом.

Код:

 py_tup = ('25', '35', '45')
print(len(py_tup)) 

Вывод:

2. Max – Функция Max используется для поиска максимального количества элементов из кортежей. В приведенном ниже примере показаны функции max следующим образом.

Код:

 py_tup = ('25', '35', '45')
print(max(py_tup)) 

Вывод:

3. Min – Функция Min используется для поиска наименьшего элемента из кортежей. В приведенном ниже примере функция min показана следующим образом.

Код:

 py_tup = ('25', '35', '45')
print(min(py_tup)) 

Вывод:

4. Кортеж — Эта функция преобразует список в кортеж. В приведенном ниже примере показаны примеры функций кортежа следующим образом.

Код:

 py_tup = кортеж (('25', '35', '45'))
print (py_tup) 

Вывод:

Заключение

Кортежи — это переменная, которая позволяет нам хранить множество объектов в одном месте. Отличие состоит в том, что после назначения кортежа мы не можем изменить его элементы, тогда как мы можем изменить содержимое списка. Мы не можем использовать float или другие типы, потому что индекс содержит целые числа.

Рекомендуемые статьи

Это руководство по Python 3 Tuple. Здесь мы обсуждаем определение, что такое кортеж Python 3?, примеры с реализацией кода. Вы также можете ознакомиться со следующими статьями, чтобы узнать больше –

1. Тест Python Z
2. Целое число Python в строку
3. Ошибка памяти Python
4. Python Timeit

Разница между списком и кортежем в Python

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

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

Что такое список в Python?

Списки — один из самых гибких и мощных контейнеров в Python. Это похоже на массив в других языках, таких как Java.

Список имеет следующие функции — 

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

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

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

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

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

Кортеж Python имеет следующие особенности: 

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

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

Синтаксис списка

Список начинается с символа [ ].

Вот пример объявления списка в python.

num_list = [1,2,3,4,5]

печать (номер_списка)

alphas_list = [‘a’,’b’,’c’,’d’,’e’]

печать (список_алфавитов)

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

смешанный_список = [‘a’, 1,’b’,2,’c’,3,’4′]

печать (смешанный_список)

Вы также можете создавать вложенные списки. Вложенный список — это список внутри списка.

вложенный_список = [1,2,3,[4,5,6],7,8]

печать (вложенный_список)

Синтаксис кортежа

Кортеж инициируется символом ().

Вот пример объявления кортежа в python.

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

печать (num_tuple)

alphas_tuple = (‘a’,’b’,’c’,’d’,’e’)

печать (alphabets_tuple)

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

смешанный_кортеж = (‘a’, 1,’b,’ 2,’c,’ 3,’4′).

печать (смешанный_кортеж)

Вы также можете создавать вложенные списки. Вложенный список — это список внутри списка.

вложенный_кортеж = (1,2,3,(4,5,6),7,8)

печать (вложенный_кортеж)

Различия в синтаксисе

Список и кортеж действуют как контейнеры для хранения объектов. Но есть разница в вариантах использования и синтаксисе.

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

Создание списка и кортежа в python.

list_numbers  = [1,2,3,4,5]

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

печать (список_номеров)

печать (числа кортежей)

Мы можем использовать функцию type для проверки типа данных любого объекта.

тип (list_numbers)

тип (tuple_numbers)

Разница между списком и кортежем в Python (подробное объяснение)

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

Содержимое кортежа не может быть изменено после его создания в Python из-за неизменяемости кортежей.

Невозможно постоянно изменять кортежи. Сообщение об ошибке при попытке изменить один из элементов:

имени = («Радж», «Джон», «Джабби», «Раджа»)

имени[2] = «Келли»

Трассировка (последний последний вызов):

Файл ««, строка 4, в

TypeError: объект ‘tuple’ не поддерживает назначение элемента

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

Причина проста: кортежи неизменяемы, то есть вы не можете изменить их содержимое после их создания. Длина кортежей также фиксирована. Они остаются одинаковой длины на протяжении всего жизненного цикла программы.

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

Разница между списком и кортежем (таблица)

Ниже приведены различия между списком и кортежем –

Изменяемый список и неизменяемые кортежи

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

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

Создайте новый список list_num и инициализируйте его 5 значениями.

list_num=[1,2,3,4,5]

Заменим 3 на 5.

list_num[2] = 5

печать (номер_списка)

[1,2,5,4,5]

Проведение аналогичной операции в кортеже.

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

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

Заменим 3 на 5.

tup_num[2] = 7

Будет следующая ошибка —

[1,2,7,4,5]

Отслеживание (последний последний вызов):

 Файл «python», строка 3, в  

TypeError: объект ‘tuple’ не поддерживает назначение элементов.

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

Доступные операции

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

добавить()

Используется для добавления элементов в список. Элементы добавляются в конец списка. Вы можете добавить только один элемент за один раз. Использование цикла позволит вам добавить сразу несколько элементов.

числовой список = [1,2,3]

numList.append(4)

numList.append(5)

numList.append(6)

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

для я в диапазоне (7, 9):

    numList.append(i)

печать (список номеров)

расширить ()

Операция расширения используется для добавления элементов в конец списка, как операция добавления. Но extend() позволяет вам добавлять сразу несколько элементов.

числовой список = [1,2,3]

numList.extend([4, 5, 6])

печать (список номеров)

вставить()

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

числовой список = [1,2,3]

numList.insert(3, 4)

numList.insert(4, 5)

numList.insert(5, 6)

печать (список номеров)

удалить()

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

stringList = [‘Список’, ‘делает обучение интересным!’, ‘для нас!’]

stringList.remove(‘делает обучение интересным!’)

печать (список строк)

поп()

Используется для удаления элементов из любой позиции в списке. Pop() принимает один аргумент — позицию элемента.

числовой список = [1,2,3,4,5]

numList.pop(4)

печать (список номеров)

срез.

Используется для печати части списка. Вы должны указать начальную позицию и конечную позицию для операции нарезки.

numList = [1,2,3,4,5,6,7,8,9]

print(numList[:9])  # печатает от начала до конца индекс

print(numList[2:])  # печатает от начального индекса до конца списка

print(numList[2:9]) # печатает от начального индекса до конечного индекса

print(numList[:])   # печатает от начала до конца списка

реверс()

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

numList = [1,2,3,4,5,6,7,8,9]

print(numList[::-1])  # не изменяет исходный список

numList.reverse()     # изменяет исходный список

печать (список номеров)

лен()

Возвращает длину списка

numList = [1,2,3,4,5,6,7,8,9]

печать (длина (номерной список))

мин()

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

печать (мин ([1, 2, 3]))

макс()

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

печать (макс. ([1, 2, 3]))

количество()

Операция Count возвращает количество указанного элемента в списке. Он принимает элемент в качестве аргумента.

числовой список = [1,2,2,4,4,6,8,8,9]

печать (numList. count (3))

объединить()

Используется для объединения двух списков в новый список. Знак + используется для объединения двух списков.

числовой список = [4,5]

stringList = [‘Python’, ‘это весело!’]

печать (число + список строк)

умножить()

Python также позволяет умножать список n раз. Результирующий список — это исходный список, повторенный n раз.

numList = [1,2,3,4,5,6,7,8,9]

печатать(numList*2)

индекс()

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

print(stringList.index(‘HelloWorld’))            # поиск во всем списке

print(stringList.index(‘HelloWorld’, 0, 2))     # поиск с 0-й по 2-ю позицию

сортировка()

Используется для сортировки списка по возрастанию. Вы можете выполнить эту операцию только над однородным списком. Использование sort() в разнородном списке вызовет ошибку.

numList = [4, 2, 6, 5, 0, 1]

numList.sort()

печать (список номеров)

очистить()

Удаляет все элементы из списка и очищает его.

numList = [1,2,3,4,5,6,7,8,9]

numList.clear()

печать (список номеров)

Неизменяемость уменьшает количество встроенных функций кортежа. Давайте посмотрим на такие операции с кортежами.

мин()

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

печать(мин((1, 2, 3)))

макс()

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

печать(макс.((1, 2, 3)))

срез.

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

myTuple = [1,2,3,4,5,6,7,8,9]

print(myTuple[:9])  # печатает от начала до конца индекс

print(myTuple[2:])  # печатает от начального индекса до конца кортежа

print(myTuple[2:9]) # печатает от начального до конечного индекса

print(myTuple[:])   # печатает от начала до конца кортежа

лен()

Возвращает длину кортежа

myTuple = [1,2,3,4,5,6,7,8,9]

печать (длина (myTuple))

дел()

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

Tuple1 = (1, 3, 4, ‘тест’, ‘красный’)

дел (Кортеж1[1])

Членство в кортеже

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

Tuple1 = (1, 3, 4, ‘тест’, ‘красный’)

печать (1 в Tuple1)

печать (5 в Tuple1)

Сравнение размеров

Между двумя структурами данных существует разница в длине. Длина кортежа фиксирована, тогда как длина списка является переменной. Следовательно, списки могут иметь разный размер, а кортежи — нет.

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

а= (1,2,3,4,5,6,7,8,9,0)

б = [1,2,3,4,5,6,7,8,9,0]

печать(‘a=’,a.__sizeof__())

печать(‘b=’,b.__sizeof__())

а=104

б=120

Различные варианты использования

Списки Python лучше всего подходят для хранения данных в следующих ситуациях: 

1. Несколько типов данных могут храниться в списках, и их индекс может использоваться для доступа к ним.
2. Списки хороши для математических операций над группой элементов, поскольку Python позволяет выполнять эти операции непосредственно над списком.
3. Если вы заранее не знаете, сколько элементов будет храниться в вашем списке, можно легко увеличить или уменьшить его размер по мере необходимости.

Кортежи Python лучше всего подходят для хранения данных в следующих ситуациях: 

1. Лучше всего использовать кортеж, когда вы знаете точную информацию, которая будет входить в поля объекта.
2. Например, если вы хотите хранить учетные данные для своего веб-сайта, можно использовать кортеж.
3. Кортежи являются неизменяемыми (неизменяемыми), поэтому их можно использовать только как ключи для словарей. Но если вы хотите использовать список в качестве ключа, сначала превратите его в кортеж.

Примеры

Кортежи как словарь

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

ключ кортежа = {}

tuplekey[(‘синий’, ‘небо’)] = ‘Хорошо’

tuplekey[(‘красный’,’кровь’)] = ‘Плохой’

печать (кортеж)

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

Упаковка и распаковка улучшают читаемость кода.

Упаковка означает присвоение кортежу нескольких значений.

Распаковка означает присвоение значений отдельным переменным.

Кортежная упаковка

человек = («Рохан», «6 футов», «Сотрудник»)

печать(лицо)

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

человек = («Рохан», «6 футов», «Сотрудник»)

(имя, рост, профессия) = человек

печать(имя)

печать(высота)

печать(профессия)

Когда использовать кортежи вместо списков?

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

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

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