Штирлиц — Сеть печатных салонов в Перми

Весь комплекс печатных услуг в Перми. Общирная сеть печатных салонов в Перми. Цифровая печать, цветное и черно-белое копирование документов, сканирование документов, ризография в Перми

Питон кортежи: Кортежи (tuple) | Python 3 для начинающих и чайников

Содержание

Кортежи (tuple) | Python 3 для начинающих и чайников

Сегодня я расскажу о таком типе данных, как кортежи (tuple) и о том, где они применяются.

Кортеж, по сути — неизменяемый список.

Зачем нужны кортежи, если есть списки?

  • Защита от дурака. То есть кортеж защищен от изменений, как намеренных (что плохо), так и случайных (что хорошо).
  • Меньший размер. Дабы не быть голословным:
>>> a = (1, 2, 3, 4, 5, 6)
>>> b = [1, 2, 3, 4, 5, 6]
>>> a.__sizeof__()
36
>>> b.__sizeof__()
44
  • Возможность использовать кортежи в качестве ключей словаря:
>>> d = {(1, 1, 1) : 1}
>>> d
{(1, 1, 1): 1}
>>> d = {[1, 1, 1] : 1}
Traceback (most recent call last):
  File "", line 1, in
    d = {[1, 1, 1] : 1}
TypeError: unhashable type: 'list'

Как работать с кортежами?

С преимуществами кортежей разобрались, теперь встает вопрос — а как с ними работать. Примерно так же, как и со списками.

Создаем пустой кортеж:

>>> a = tuple() # С помощью встроенной функции tuple()
>>> a
()
>>> a = () # С помощью литерала кортежа
>>> a
()
>>>

Создаем кортеж из одного элемента:

>>> a = ('s')
>>> a
's'

Стоп. Получилась строка. Но как же так? Мы же кортеж хотели! Как же нам кортеж получить?

>>> a = ('s', )
>>> a
('s',)

Ура! Заработало! Все дело — в запятой. Сами по себе скобки ничего не значат, точнее, значат то, что внутри них находится одна инструкция, которая может быть отделена пробелами, переносом строк и прочим мусором. Кстати, кортеж можно создать и так:

>>> a = 's',
>>> a
('s',)

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

Ну и создать кортеж из итерируемого объекта можно с помощью все той же пресловутой функции tuple()

>>> a = tuple('hello, world!')
>>> a
('h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!')

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

Все операции над списками, не изменяющие список (сложение, умножение на число, методы index() и count() и некоторые другие операции). Можно также по-разному менять элементы местами и так далее.

Например, гордость программистов на python — поменять местами значения двух переменных:

a, b = b, a

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

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

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

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

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

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

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

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

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

list() и tuple():

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

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

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

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

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

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

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

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

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

Результат:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1. Чтобы избежать изменения исходного списка, не обязательно использовать кортеж. Можно создать его копию с помощью метода списка

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

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

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

Кортежи — Основы языка Python

До этого момента мы встречались только с примитивными типами — строка, число, булев тип. Ещё нам знакомы функции и модули с пакетами (да, в Python модули и пакеты, это тоже значения специальных встроенных типов). Но часто в программировании приходится создавать более сложные значения, чем числа и строки, и манипулировать такими значениями. Именно поэтому во многих языках программирования есть

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

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

Кортежи

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

rgb_colour = (255, 127, 64)
name_and_age = ('Bob', 42)
three_booleans = (True, False, True)
two_pairs_of_numbers = ((1, 2), (3, 4))

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

not_a_tuple = (42)  # 42

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

tuple = (42,)  # (42,)

Да, форма записи довольно необычная, но вы привыкнете 🙂

Возврат нескольких значений из функции

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

def div_mod(a, b):
    quotient = a // b
    modulo = a % b
    return (quotient, modulo)

div_mod(13, 4)  # (3, 1)

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

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

name_and_age = ('Bob', 42)

name_and_age[0]  # 'Bob'
name_and_age[1]  # 42

Также у кортежа есть длина, которую, как и для строки, можно получить с помощью функции len:

tuple = (42,)  # (42,)
len(tuple)     # 1
pair = (1, 2)  # (1, 2)
len(pair)      # 2

Деструктуризация

Обращение по индексу – это не самый удобный способ работы с кортежами. Дело в том, что кортежи часто содержат значения разных типов, и помнить, по какому индексу что лежит — очень непросто. Но есть способ лучше! Как мы кортеж собираем, так его можно и разобрать:

name_and_age = ('Bob', 42)

(name, age) = name_and_age
name  # 'Bob'
age   # 42

Именно таким способом принято получать и сразу разбирать значения, которые возвращает функция (если таковая возвращает несколько значений, конечно):

(quotient, modulo) = div_mod(13, 4)

Соответственно кортеж из одного элемента нужно разбирать так:

(a,) = (42,)
a  # 42

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

Кортежи, множественное присваивание и обмен значениями

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

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

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

a = 100
b = 'foo'

(a, b) = (b, a)
a  # 'foo'
b  # 100

Cтрочку (a, b) = (b, a) нужно понимать как «присвоить в а и b значения из кортежа, состоящего из значений переменных b и a«.

Ссылки

Остались вопросы? Задайте их в разделе «Обсуждение»

Вам ответят команда поддержки Хекслета или другие студенты.

Ошибки, сложный материал, вопросы >
Нашли опечатку или неточность?

Выделите текст, нажмите ctrl + enter и отправьте его нам. В течение нескольких дней мы исправим ошибку или улучшим формулировку.

Что-то не получается или материал кажется сложным?

Загляните в раздел «Обсуждение»:

  • задайте вопрос. Вы быстрее справитесь с трудностями и прокачаете навык постановки правильных вопросов, что пригодится и в учёбе, и в работе программистом;
  • расскажите о своих впечатлениях. Если курс слишком сложный, подробный отзыв поможет нам сделать его лучше;
  • изучите вопросы других учеников и ответы на них. Это база знаний, которой можно и нужно пользоваться.
Об обучении на Хекслете

Python. Урок 8. Кортежи (tuple)

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

Что такое кортеж (tuple) в Python?

Кортеж (tuple) – это неизменяемая структура данных, которая по своему подобию очень похожа на список. Как вы наверное знаете, а если нет, то, пожалуйста, ознакомьтесь с седьмым уроком, список – это изменяемый тип данных. Т.е. если у нас есть список a = [1, 2, 3] и мы хотим заменить второй элемент с 2 на 15, то мы может это сделать, напрямую обратившись к элементу списка.

>>> a = [1, 2, 3]
>>> print(a)
[1, 2, 3]
>>> a[1] = 15
>>> print(a)
[1, 15, 3]

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

>>> b = (1, 2, 3)
>>> print(b)
(1, 2, 3)
>>> b[1] = 15
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    b[1] = 15
TypeError: 'tuple' object does not support item assignment

Зачем нужны кортежи в Python?

Существует несколько причин, по которым стоит использовать кортежи вместо списков. Одна из них – это обезопасить данные от случайного изменения. Если мы получили откуда-то массив данных, и у нас есть желание поработать с ним, но при этом непосредственно менять данные мы не собираемся, тогда, это как раз тот случай, когда кортежи придутся как нельзя кстати. Используя их в данной задаче, мы дополнительно получаем сразу несколько бонусов – во-первых, это экономия места. Дело в том, что кортежи в памяти занимают меньший объем по сравнению со списками.

>>> lst = [10, 20, 30]
>>> tpl = (10, 20, 30)
>>> print(lst.__sizeof__())
32
>>> print(tpl.__sizeof__())
24

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

Создание, удаление кортежей и работа с его элементами

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

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

>>> a = ()
>>> print(type(a))
<class 'tuple'>
>>> b = tuple()
>>> print(type(b))
<class 'tuple'>

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

>>> a = (1, 2, 3, 4, 5)
>>> print(type(a))
<class 'tuple'>
>>> print(a)
(1, 2, 3, 4, 5)

При желании можно воспользоваться функцией tuple().

>>> a = tuple((1, 2, 3, 4))
>>> print(a)
(1, 2, 3, 4)

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

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

>>> a = (1, 2, 3, 4, 5)
>>> print(a[0])
1
>>> print(a[1:3])
(2, 3)
>>> a[1] = 3
Traceback (most recent call last):
  File "<pyshell#24>", line 1, in <module>
    a[1] = 3
TypeError: 'tuple' object does not support item assignment

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

Удалить отдельные элементы из кортежа невозможно.

>>> a = (1, 2, 3, 4, 5)
>>> del a[0]
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    del a[0]
TypeError: 'tuple' object doesn't support item deletion

Но можно удалить кортеж целиком.

>>> del a
>>> print(a)
Traceback (most recent call last):
  File "<pyshell#28>", line 1, in <module>
    print(a)
NameError: name 'a' is not defined

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

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

>>> lst = [1, 2, 3, 4, 5]
>>> print(type(lst))
<class 'list'>
>>> print(lst)
[1, 2, 3, 4, 5]
>>> tpl = tuple(lst)
>>> print(type(tpl))
<class 'tuple'>
>>> print(tpl)
(1, 2, 3, 4, 5)

Обратная операция также является корректной.

>>> tpl = (2, 4, 6, 8, 10)
>>> print(type(tpl))
<class 'tuple'>
>>> print(tpl)
(2, 4, 6, 8, 10)
>>> lst = list(tpl)
>>> print(type(lst))
<class 'list'>
>>> print(lst)
[2, 4, 6, 8, 10]

P.S.

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

<<< Python. Урок 7. Работа со списками (list)   Python. Урок 9. Словари (dict)>>>

Введение в Python. Часть 7. Кортежи и множества

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

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

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

Кортежи (Tuples) 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Кортежи (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 | Кортежи

Кортежи

Последнее обновление: 26.04.2017

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

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


user = ("Tom", 23)
print(user)

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


user = "Tom", 23
print(user)

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


user = ("Tom",)

Для создания кортежа из списка можно передать список в функцию tuple(), которая возвратит кортеж:


users_list = ["Tom", "Bob", "Kate"]
users_tuple = tuple(users_list)
print(users_tuple)      # ("Tom", "Bob", "Kate")

Обращение к элементам в кортеже происходит также, как и в списке по индексу. Индексация начинается также с нуля при получении элементов с начала списка и с -1 при получении элементов с конца списка:


users = ("Tom", "Bob", "Sam", "Kate")
print(users[0])     # Tom
print(users[2])     # Sam
print(users[-1])     # Kate

# получим часть кортежа со 2 элемента по 4
print(users[1:4])       # ("Bob", "Sam", "Kate")

Но так как кортеж — неизменяемый тип (immutable), то мы не сможем изменить его элементы. То есть следующая запись работать не будет:


users[1] = "Tim"

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


user = ("Tom", 22, False)
name, age, isMarried = user
print(name)             # Tom
print(age)              # 22
print(isMarried)        # False

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


def get_user():
    name = "Tom"
    age = 22
    is_married = False
    return name, age, is_married


user = get_user()
print(user[0])              # Tom
print(user[1])              # 22
print(user[2])              # False

С помощью встроенной функции len() можно получить длину кортежа:


user = ("Tom", 22, False)
print(len(user))		# 3

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

Для перебора кортежа можно использовать стандартные циклы for и while. С помощью цикла for:


user = ("Tom", 22, False)
for item in user:
    print(item)

С помощью цикла while:


user = ("Tom", 22, False)

i = 0
while i < len(user):
    print(user[i])
    i += 1

Как для списка с помощью выражения элемент in кортеж можно проверить наличие элемента в кортеже:


user = ("Tom", 22, False)
name = "Tom"
if name in user:
    print("Пользователя зовут Tom")
else:
    print("Пользователь имеет другое имя")

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

Один кортеж может содержать другие кортежи в виде элементов. Например:


countries = (
    ("Germany", 80.2, (("Berlin",3.326), ("Hamburg", 1.718))),
    ("France", 66, (("Paris", 2.2),("Marsel", 1.6)))
)

for country in countries:
    countryName, countryPopulation, cities = country
    print("\nCountry: {}  population: {}".format(countryName, countryPopulation))
    for city in cities:
        cityName, cityPopulation = city
        print("City: {}  population: {}".format(cityName, cityPopulation))

Здесь кортеж countries, который представляет страны, состоит из кортежей, каждый из которых — отдельная страна.

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

Кортежей Python

mytuple = («яблоко», «банан», «вишня»)

Кортеж

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

Tuple — один из 4 встроенных типов данных в Python, используемых для хранения коллекций данные, остальные 3 — список, Набор и Словарь, все с разным качеством и использованием.

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

Кортежи записываются в круглые скобки.

Пример

Создать кортеж:

thistuple = («яблоко», «банан», «вишня»)
печать (thistuple)

Попробуй сам »

Кортеж

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

Элементы кортежа проиндексированы, первый элемент имеет индекс [0] , второй элемент имеет индекс [1] и т. Д.

Заказано

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

без изменений

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

Разрешить дубликаты

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

Пример

Кортежи допускают повторяющиеся значения:

thistuple = («яблоко», «банан», «вишня», «яблоко», «вишня»)
печать (thistuple)

Попробуй сам »

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

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

Пример

Выведите количество элементов в кортеже:

thistuple = («яблоко», «банан», «вишня»)
print (len (thistuple))

Попробуй сам »

Создать кортеж с одним элементом

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

Пример

Кортеж из одного элемента, запомните запятую:

thistuple = («яблоко»,)
print (type (thistuple))

# НЕ кортеж
thistuple = («apple»)
print (type (thistuple))

Попробуй сам »

Элементы кортежа — типы данных

Элементы кортежа могут иметь любой тип данных:

Пример

Типы данных String, int и boolean:

tuple1 = («яблоко», «банан», «вишня»)
tuple2 = (1, 5, 7, 9, 3)
tuple3 = (True, False, False)

Попробуй сам »

Кортеж может содержать разные типы данных:

Пример

Кортеж со строками, целыми числами и логическими значениями:

tuple1 = («abc», 34, Истина, 40, «мужской»)

Попробуй сам »

тип ()

С точки зрения Python, кортежи определяются как объекты с типом данных «кортеж»:

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

Пример

Какой тип данных у кортежа?

mytuple = («яблоко», «банан», «вишня»)
print (type (mytuple))

Попробуй сам »

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

Также можно использовать конструктор tuple () для создания кортежа.

Пример

Использование метода tuple () для создания кортежа:

thistuple = tuple ((«яблоко», «банан», «вишня»)) # обратите внимание на двойные круглые скобки
print (thistuple)

Попробуй сам »

Коллекции Python (массивы)

В языке программирования Python существует четыре типа коллекционных данных:

  • Список — это упорядоченная и изменяемая коллекция. Позволяет дублировать участников.
  • Tuple — это упорядоченная и неизменяемая коллекция.Позволяет дублировать участников.
  • Set — это неупорядоченная и неиндексированная коллекция. Нет повторяющихся участников.
  • Словарь — это заказанный сборник * и изменчивый. Нет повторяющихся участников.

* Начиная с версии Python 3.7, словари заказаны . В Python 3.6 и ранее словари неупорядоченные .

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


Кортеж Python (с примерами)

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

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

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

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

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

# Пустой кортеж
my_tuple = ()
печать (my_tuple)

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

# кортеж со смешанными типами данных
my_tuple = (1, «Привет», 3.4)
печать (my_tuple)

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

Выход 

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

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

  my_tuple = 3, 4.6, "собака"
печать (my_tuple)

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

печать (а) # 3
print (b) # 4.6
print (c) # собака

Выход 

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

Создание кортежа с одним элементом немного сложно.

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

  my_tuple = ("привет")
print (type (my_tuple)) # <класс 'str'>

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

# Скобки не обязательны
my_tuple = "привет",
print (type (my_tuple)) # <класс 'кортеж'>

Выход 

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

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

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

1. Индексирование

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

Итак, кортеж, состоящий из 6 элементов, будет иметь индексы от 0 до 5. Попытка получить доступ к индексу за пределами диапазона индексов кортежа (6,7, … в этом примере) вызовет IndexError .

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

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

  # Доступ к элементам кортежа с помощью индексации
my_tuple = ('p', 'e', ​​'r', 'm', 'i', 'т')

print (my_tuple [0]) # 'p'
print (my_tuple [5]) # 'т'

# IndexError: список индекса вне допустимого диапазона
# print (my_tuple [6])

# Индекс должен быть целым числом
# TypeError: индексы списка должны быть целыми числами, а не с плавающей запятой
# my_tuple [2.0]

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

# вложенный индекс
print (n_tuple [0] [3]) # 's'
print (n_tuple [1] [1]) # 4

Выход 

  с
т
s
4

2.Отрицательное индексирование

Python допускает отрицательную индексацию своих последовательностей.

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

  # Отрицательная индексация для доступа к элементам кортежа
my_tuple = ('p', 'e', ​​'r', 'm', 'i', 'т')

# Вывод: 't'
печать (my_tuple [-1])

# Вывод: 'p'
печать (my_tuple [-6])

Выход 

  т
п

3. Нарезка

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

  # Доступ к элементам кортежа с помощью нарезки
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

# элементы со 2-го по 4-й
# Вывод: ('r', 'o', 'g')
печать (my_tuple [1: 4])

# элементов начиная со 2-го
# Вывод: ('p', 'r')
печать (my_tuple [: - 7])

# элементы с 8-го до конца
# Вывод: ('i', 'z')
печать (my_tuple [7:])

# элемента от начала до конца
# Вывод: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
печать (my_tuple [:])

Выход 

  ('г', 'о', 'г')
('п', 'г')
('я', 'я')
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

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

Нарезка элементов в Python

Изменение кортежа

В отличие от списков, кортежи неизменяемы.

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

Мы также можем присвоить кортежу разные значения (переназначение).

  # Изменение значений кортежа
my_tuple = (4, 2, 3, [6, 5])


# TypeError: объект 'tuple' не поддерживает назначение элементов
# my_tuple [1] = 9

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

# Кортежи можно переназначить
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

# Вывод: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
печать (my_tuple)

Выход 

  (4, 2, 3, [9, 5])
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

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

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

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

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

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

Выход 

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

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

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

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

  # Удаление кортежей
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

# невозможно удалить элементы
# TypeError: объект 'tuple' не поддерживает удаление элемента
# del my_tuple [3]

# Можно удалить весь кортеж
дель my_tuple

# NameError: имя my_tuple не определено
печать (my_tuple)

Выход 

  Traceback (последний звонок последний):
  Файл «<строка>», строка 12, в <модуле>
NameError: имя my_tuple не определено

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

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

Некоторые примеры методов кортежа Python:

  my_tuple = ('а', 'р', 'р', 'л', 'е',)

print (my_tuple.count ('p')) # Вывод: 2
print (my_tuple.index ('l')) # Вывод: 3

Выход 

  2
3

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

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

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

  # Тест на членство в кортеже
my_tuple = ('а', 'р', 'р', 'л', 'е',)

# В операции
print ('a' в my_tuple)
print ('b' в my_tuple)

# Не работает
print ('g' отсутствует в my_tuple)

Выход 

  Верно
Ложь
Правда

2. Итерация по кортежу

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

  # Использование цикла for для перебора кортежа
для имени в ('Джон', 'Кейт'):
    print ("Привет", имя)

Выход 

  Привет, Джон
Привет Кейт

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

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

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

Кортежи Python: пошаговое руководство

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

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

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

Понимание кортежей Python

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

Найдите свой учебный лагерь Match

Шоколад Ваниль Мята Клубника Choc-Chip
1 2 3 4
Шоколад Ваниль Мята Клубника Choc-Chip
-5-4-3 -2
-1

76 до получить значение в позиции индекса -1 , мы могли бы использовать следующий код:

 печать (ice_cream_flavors [-1])

Наш код возвращает: Choc-Chip .

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

Точно так же, если мы хотим получить диапазон элементов в нашем кортеже, мы можем указать диапазон индексов для извлечения. Для этого нам нужно указать, где начать и где закончить наш диапазон. Мы можем использовать следующий код для получения каждого элемента в диапазоне значений индекса 1 и 4:

 печать (ice_cream_flavors [1: 4])

Наш код возвращает: («Ваниль», «Мята», «Клубника»)

В этом примере наш код возвращает каждое значение со значением индекса от 1 до 4 , за исключением последнего значения индекса.Наш код не возвращает Choc-Chip , потому что Choc-Chip не входит в указанный диапазон.

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

 печать (ice_cream_flavors [: 2])

Наш код возвращает: («Ваниль», «Мята»)

Нарезка с отрицательными индексными числами

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

 печать (ice_cream_flavors [-2:])

Наш код возвращает: («Клубника», «Чок-чип»)

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

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

 печать (ice_cream_flavors [0: 5: 2])

Наш код возвращает: ("Шоколад", "Мята", "Чок-чип")

Первое число в нашем срезе (0) указывает, когда срез должен начинаться в массиве. 5 относится к последнему элементу, на который должен ссылаться наш фрагмент, за исключением этого элемента. Третье число ( 2 ) относится к шагу, который мы хотим использовать.Stride представляет, сколько значений после первого элемента код должен пропустить при нарезке кортежа.

Операторы кортежа

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

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

 ice_cream_flavors = ("Шоколад", "Ваниль", "Мята", "Клубника", "Чок-чип")
Experiment_flavors = ('Тесто для печенья', 'Каменистая дорога', 'Мятная шоколадная крошка')
new_menu = ice_cream_flavors + экспериментальные_flavors

печать (новое_меню)

Наш код возвращает следующее:

 («Шоколадный», «Ванильный», «Мятный», «Клубничный», «Чок-чип», «Тесто для печенья», «Рокки-роуд», «Мятный шоколадный чипс»)

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

Итерация по кортежу

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

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

 ice_cream_flavors = ("Шоколад", "Ваниль", "Мята", "Клубника", "Чок-чип")
для f в ice_cream_flavors:
print (f)

Результат нашего кода будет следующим:

 Шоколад
Ваниль
Мята
клубника
Чок-Чип

Проверить, существует ли элемент в кортеже, можно с помощью оператора if… в операторе .Оператор if… in проверяет, существует ли значение в коллекции. Вот пример оператора if… в , который используется для проверки, продает ли наше кафе-мороженое мороженое Mint :

 ice_cream_flavors = ("Шоколад", "Ваниль", "Мята", "Клубника", "Чок-чип")
если "Mint" в ice_cream_flavors:
print («Да, мятное мороженое продаем!»)

Наш код возвращает: Да, мы продаем мятное мороженое! Это потому, что «Монетный двор» в нашем списке.

Списки vs.Кортежи

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

Тем не менее, вы можете объединить два или более кортежа, что означает, что вы можете объединить два кортежа, чтобы сформировать новый.

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

Наш код возвращает список.Мы можем использовать метод tuple () для преобразования нашего значения обратно в кортеж:

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

Заключение

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

empty_tuple = ()

print (empty_tuple)

9049

tup = 'python' , 'geeks'

print (tup)

tup = ( ) python ' , ' geeks ' )

print (tup)