Питон кортежи: Кортежи (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. Урок 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. Работа с данными”.
Книга: Pandas. Работа с данными

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

создание и приведение к списку

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

Что такое кортеж

Кортеж – это неизменная структура заданных заранее значений. Он очень похож на список, но последний подвержен изменениям. Так, если нужно исправить какой-то элемент списка, можно сделать это, напрямую указав:

b = [4, 6, 8]
print(b)
[4, 6, 8]
b[1] = 13
print(b)
[4, 13, 8]

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

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

a = (2, 4, 6, 8, 10, 12)
b = [2, 4, 6, 8, 10, 12]
a.__sizeof__()
36
b.__sizeof__()
44

Из этого кода видно, что кортеж (в круглых скобках) занимает 36 байтов, а список (в квадратных скобках) – 44 байта.

Создание

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

Приведем пример создания в Python обычного кортежа:

a = (1,2,3)

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

a = tuple([1,2,3])

Рассмотрим кортеж с отрицательным индексом:

n = ("a", "b", "с", "d", "e")
print(n[-1])

'e'

То есть на экране отобразился первый не с начала, а с конца элемент.

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

a =(3,)
print(a[0])

3

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

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

a = tuple(i for i in range(0, 10))
print(a)

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

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

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

Подробнее о срезах описано ниже в пункте “Обращение к элементу”.

Использование генераторов кортежей аналогично генераторам списка.

Обращение к элементу

У каждого элемента есть свой индекс. То есть, в Python для обращения к элементу кортежа, нужно просто указать его индекс. Напомним, что счет начинается с нуля. Посмотрим на код:

b = (4, 6, 8)
print(b[0])
print(b[1])

4
6

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

b = (5, 3.6, "квадрат", 15, 'В')
print(b[1])
print(b[2:4])

3.6
('квадрат', 15)

Методы

Кортежи в python имеют только два метода: index() и count(). Первый применяется, чтобы узнать, какой индекс у определенного элемента. Например:

a = (32, 33, 34, 33, 34, 33)
print(a.index(33))

1

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

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

a = (32, 33, 34, 33, 34, 33)
print(a.count(33))

3

На экране перед пользователем появится именно число 3, потому что в кортеже искомое число 33 повторяется 3 раза.

Помните, что в кортежах нет методов добавления и удаления элементов.

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

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

Для того, чтобы использовать namedtuple, необходимо подключить библиотеку collections. Это делается с помощью import collecions *. В этом случае обращаться к namedtuple будет необходимо следующим образом: collections.namedtuple( [параметры] ). Другой вариант подключения библиотеки приведен в примере ниже.

Каждый элемент, сохраненный в именованном кортеже, доступен через определенный идентификатор. Посмотрим на примере кода:

from collections import namedtuple
Flower = namedtuple('Flower' , 'color cost comment')
rose = Flower('red', 5, 'beautiful')
print(rose.cost)

5

Наименования полей были перечислены через пробел. Вместо этой строки можно было передать список со строками. В конструкторе namedtuple разобьет полученную строку с помощью split. В качестве примера было приведено обращение к элементу cost. К остальным обращение аналогично: rose.color, rose.comment.

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

print(rose[0])

red

Список кортежей

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

Из этой ситуации есть выход – создание в Python списка кортежей. Вариант объявления такого списка представлен ниже:

a = [(1,2,3),(4,5,6)]

Cортировка

Иногда нужно отсортировать имеющиеся элементы списка. Благодаря встроенной функции sorted, все это делается достаточно легко:

a = ('One', 'Two', 'Three')
a = tuple(sorted(a))
print(a)

('One', 'Three', 'Two')

Видно, что произошла сортировка кортежа Python по алфавиту. Стандартную сортировку можно провести и по числовым элементом. Посмотрим на пример:

a = (3, 1, 5 ,2, 6, 7)
a = tuple(sorted(a))
print(a)

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

Заметим, что произошла сортировка по возрастанию.

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

В список

Кортеж можно переделать в список:

a = (1,2,3)
a = list(a)
print(a)

[1, 2, 3]

Таким образом, кортеж был преобразован в список Python, который можно изменить. Теперь рассмотрим обратное действие — преобразование списка в кортеж:

a = [1, 2.6, "квадрат"]
a = tuple(a)
print(a)

(1, 2.6, "квадрат")

В словарь

Словарь – это еще одна структура используемая в Python. Он, как и список, является изменяемым, но при этом неупорядоченным. Это значит, что обратиться к определенному элементу посредством указания индекса – не получится. Чтобы лучше понять, можно провести аналогию с обычным англо-русским словарем. В нем для каждого слова есть перевод: house –дом, flat – квартира, window – окно. Если перенести такую структуру в программный код, то получится такая запись, оформляемая фигурными скобками:

{'house': 'дом', 'flat': 'квартира', 'window': 'окно'}

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

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

a = (('a', 2),('b', 4))
a = dict(a)
print(a)

{'a': 2, 'b': 4}

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

В строку

Чтобы вывести в python кортеж в одну строку, используется функция join. Посмотрим на примере:

a = ('one','two','three')
b = ''.join(a)
c = ','.join(a)
print(b)
print(c)

onetwothree
one,two,three

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

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

список и кортеж / Хабр

В Python, есть два похожих типа — список (list) и кортеж (tuple). Самая известная разница между ними состоит в том, что кортежи неизменяемы.

Вы не можете изменить объекты в tuple:

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

Но вы можете модифицировать изменяемые объекты внутри кортежа:
>>> b = (1,[1,2,3],3)
>>> b[1]
[1, 2, 3]
>>> b[1].append(4)
>>> b
(1, [1, 2, 3, 4], 3)

Внутри CPython (стандартного интерпретатора), список и кортеж реализованы как лист из указателей (ссылок) на Python объекты, т.е. физически они не хранят объекты рядом с друг другом. Когда вы удаляете объект из списка происходит удаление ссылки на этот объект. Если на объект ещё кто-то ссылается, то он продолжит находиться в памяти.
Кортежи

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

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

  • работаете с аргументами или параметрами (они хранятся как кортежи)
  • возвращаете две или более переменных из функции
  • итерируете ключи-значения в словаре
  • используете форматирование строк

Как правило, самый просто скрипт использует тысячи кортежей:
>>> import gc
>>> def type_stats(type_obj):
...     count = 0
...     for obj in gc.get_objects():
...         if type(obj) == type_obj:
...             count += 1
...     return count
...
>>> type_stats(tuple)
3136
>>> type_stats(list)
659
>>> import pandas
>>> type_stats(tuple)
6953
>>> type_stats(list)
2455

Пустые списки vs пустые кортежи

Пустой кортеж работает как синглтон, т.е. в памяти запущенного Python скрипта всегда находится только один пустой кортеж. Все пустые кортежи просто ссылаются на один и тот же объект, это возможно благодаря тому, что кортежи неизменяемы. Такой подход сохраняет много памяти и ускоряет процесс работы с пустыми кортежами.
>>> a = ()
>>> b = ()
>>> a is b
True
>>> id(a)
4409020488
>>> id(b)
4409020488
>>> # В CPython, функция id возвращает адрес в памяти.

Но это не работает со списками, ведь они могут быть изменены:
>>> a = []
>>> b = []
>>> a is b
False
>>> id(a)
4465566920
>>> id(b)
4465370632

Оптимизация выделения памяти для кортежей

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

Этот список разделен на 20 групп, где каждая группа представляет из себя список кортежей размера n, где n от 0 до 20. Каждая группа может хранить до 2 000 свободных кортежей. Первая группа хранит только один элемент и представляет из себя список из одного пустого кортежа.

>>> a = (1,2,3)
>>> id(a)
4427578104
>>> del a
>>> b = (1,2,4)
>>> id(b)
4427578104

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

Так как списки могут изменяться, такую же оптимизацию как в случае с кортежами провернуть уже не получится. Несмотря на это, для списков используется похожая оптимизация нацеленная на пустые списки. Если пустой список удаляется, то он так же может быть переиспользован в дальнейшем.
>>> a = []
>>> id(a)
4465566792
>>> del a
>>> b = []
>>> id(b)
4465566792

Изменение размера списка

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

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

Паттерн роста размера списка выглядит примерно так: 0, 4, 8, 16, 25, 35, 46, 58, 72, 88,…

Для примера, если вы хотите добавить новый элемент в список с 8 элементами, то свободных ячеек в нём уже не будет и Python сразу расширит его размер до 16 ячеек, где 9 из них будут заняты и видны пользователю.

Формула выбора размера написанная на Python:

>>> def get_new_size(n_items):
...     new_size = n_items + (n_items // 2 ** 3)
...     if n_items < 9:
...             new_size += 3
...     else:
...             new_size += 6
...
...     return new_size
...
>>> get_new_size(9)
16

Скорость

Если сравнивать эти два типа по скорости, то в среднем по больнице, кортежи слегка быстрее списков. У Raymond Hettinger есть отличное объяснение разницы в скорости на stackoverflow.

P.S.: Я являюсь автором этой статьи, можете задавать любые вопросы.

Кортежи (tuple) в Python — самоучитель с примерами

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

 a = 1, 2, 3   # a is the tuple (1, 2, 3)

 

а также

 a = (1, 2, 3) # a is the tuple (1, 2, 3)

 

эквивалентны. Присваивания a = 1, 2, 3 также называют упаковки , потому что пакеты значения вместе в кортеже.

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

 a = 1  # a is the value 1
a = 1, # a is the tuple (1,)

 

Запятая нужна также, если вы используете скобки

 a = (1,) # a is the tuple (1,)
a = (1)  # a is the value 1 and not a tuple


 

Для распаковки значений из кортежа и выполнения нескольких назначений используйте

 # 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 is the value 1
x  = 1,  # x is the tuple (1,)


 

В Python 3 целевой переменной с * префикс может быть использован в качестве вдогонку всех переменных (см https://codecamp.ru/documentation/python/809/compatibility-between-python-3-and-python-2/2845 / распаковка-итерируемые ):

первый, * еще, последний = (1, 2, 3, 4, 5) # первый == 1 # еще == [2, 3, 4] # последний == 5

Основы Python — кратко. Часть 3. Списки, кортежи, файлы. / Хабр
В общем-то последняя из готовых глав. Остальные будут выходить чуть реже, поскольку еще не написаны (но я уверен что будут, хотя это зависит только от ваших пожеланий, уважаемые читатели 🙂

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

В общем, те кому не интересно — читают следующую новость, а остальных — прошу пройти .

Python для начинающих. Глава третья. «List, tuple, etc.»

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

>>> t = (2, 2.05, "Hello")
>>> t
(2, 2.0499999999999998, 'Hello')
>>> (a, b, c) = t
>>> print a, b, c
2 2.05 Hello
>>> z, y, x = t
>>> print z, y, x
2 2.05 Hello
>>> a=1
>>> b=2
>>> a,b=b,a
>>> print a,b
2 1
>>> x = 12,
>>> x
(12,)

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

Списки

В Пайтоне отсутствуют массивы в традиционном понимании этого термина. Вместо них для хранения однородных (и не только) объектов используются списки. Они задаются тремя способами.

Простое перечисление:

>>> a = [2, 2.25, "Python"]
>>> a
[2, 2.25, 'Python']

Преобразуем строку в список
>>> b = list("help")
>>> b
['h', 'e', 'l', 'p']

Создание с помощью списковых включений. В данном случае мы берем кубы всех нечетных чисел от 0 до 19. Этому синтаксису я планирую посвятить отдельное занятие.
>>> c = [x ** 3 for x in range(20) if x%2==1]
>>> c
[1, 27, 125, 343, 729, 1331, 2197, 3375, 4913, 6859]

Для работы со списками определен ряд операторов и функций:
len(s) Длина последовательности s
x in s Проверка принадлежности элемента последовательности. В новых версиях Python можно проверять принадлежность подстроки строке. Возвращает True или False
x not in s = not x in s
s + s1 Конкатенация последовательностей
s*n или n*s Последовательность из n раз повторенной s. Если n
s[i] Возвращает i-й элемент s или len(s)+i-й, если i
s[i:j:d] Срез из последовательности s от i до j с шагом d будет рассматриваться ниже
min(s) Наименьший элемент s
max(s) Наибольший элемент s
s[i] = x i-й элемент списка s заменяется на x
s[i:j:d] = t Срез от i до j (с шагом d) заменяется на (список) t
del s[i:j:d] Удаление элементов среза из последовательности

Кроме того, для списков определен ряд методов.
append(x) Добавляет элемент в конец последовательности
count(x) Считает количество элементов, равных x
extend(s) Добавляет к концу последовательности последовательность s
index(x) Возвращает наименьшее i, такое, что s[i] == x. Возбуждает исключение ValueError, если x не найден в s
insert(i, x) Вставляет элемент x в i-й промежуток
pop(i) Возвращает i-й элемент, удаляя его из последовательности
reverse() Меняет порядок элементов s на обратный
sort([cmpfunc]) Сортирует элементы s. Может быть указана своя функция сравнения cmpfunc

Для преобразования кортежа в список есть функция list, для обратной операции — tuple.

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

>>> s = [0, 1, 2, 3, 4]
>>> print s[0], s[-1], s[3]
0 4 3
>>> s[2] = -2
>>> print s
[0, 1, -2, 3, 4]
>>> del s[2]
>>> print s
[0, 1, 3, 4]

Сложнее обстоят дела со срезами. Для получения срезов последовательности в Пайтоне принято указывать не номера элементов, а номера «промежутков» между ними. Перед первым элементом последовательности промежуток имеет индекс 0, перед вторым – 1 и так далее. Отрицательные значения отсчитывают элементы с конца строки.
В общем виде срез записывается в следующем виде:
список[начало: конец: шаг]
По умолчанию начало среза равно 0, конец среза равен len(список), шаг равен 1. Если шаг не указывается, второй символ «:» можно опустить.
С помощью среза можно указать подмножество для вставки списка в другой список, даже при нулевой длине. Это удобно для вставки списка в строго определенной позиции.
>>> l = range(12)
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
>>> l[1:3]
[1, 2]
>>> l[-1:]
[11]
>>> l[::2]
[0, 2, 4, 6, 8, 10]
>>> l[0:1]=[-1,-1,-1]
>>> l
[-1, -1, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
>>> del l[:3]
>>> l
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

Словари

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

Создаем хеши.

>>> h2 = {1:"one", 2:"two", 3:"three"}
>>> h3 = {0:"zero", 5:"five"}
>>> h4 = {"z":1, "y":2, "x":3}
#Цикл по паре ключ-значение
>>> for key, value in h2.items():
...     print key, " ", value
...
1   one
2   two
3   three

#Цикл по ключам
>>> for key in h3.keys():
...     print key, " ", h3[key]
...
0   zero
5   five

#Цикл по значениям
>>> for v in h4.values():
...     print v
...
2
3
1

#Добавление элементов из другого хеша
>>> h2.update(h4)

#Количество пар в хеше
>>> len(h2)
6

Тип file

Объекты этого типа предназначены для работы с внешними данными. Чаще всего данному объекту соответствует файл на диске, но это далеко не всегда так. Файловые объекты должны поддерживать основные методы: read(), write(), readline(), readlines(), seek(), tell(), close() и т.п.

Следующий пример показывает копирование файла:

f1 = open("file1.txt", "r")
f2 = open("file2.txt", "w")
for line in f1.readlines():
  f2.write(line)
f2.close()
f1.close()

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

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

import urllib
f1 = urllib.urlopen("http://python.onego.ru") 

Задачи:
— Разработать программу «массовой закачки» URL-ов из файла urls.txt
— Разработать программу, скачивающую страницу по указанному URL со всем ее содержимым.
— Написать программу, которая получив на входе произвольный список удалит из него все повторяющиеся элементы.

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


Tuple

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

Пример

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

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

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

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

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

Пример

Напечатайте второй элемент в кортеже:

thistuple = ("яблоко", "банан", "вишня")
печать (thistuple [1])

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

Отрицательная индексация

Отрицательное индексирование означает начало с конца, -1 относится к последнему пункту, -2 относится ко второму последнему пункту и т. Д.

Пример

Распечатать последний элемент кортежа:

thistuple = ("яблоко", "банан", "вишня")
печать (thistuple [-1])

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

Диапазон индексов

Вы можете указать диапазон индексов, указав, с чего начать и где конец диапазона.

При указании диапазона возвращаемым значением будет новый кортеж с указанные предметы.

Пример

Верните третий, четвертый и пятый предмет:

thistuple = ("яблоко", "банан", "вишня", "апельсин", "киви", "дыня", "манго")
Печать (thistuple [2: 5])

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

Примечание: Поиск начинается с индекса 2 (включен) и заканчивается индексом 5 (не включен).

Помните, что первый элемент имеет индекс 0.

Диапазон отрицательных индексов

Укажите отрицательные индексы, если вы хотите начать поиск с конца кортеж:

Пример

В этом примере возвращаются элементы из индекса -4 (включен) в индекс -1 (исключен)

thistuple = ("яблоко", "банан", "вишня", "апельсин", "киви", "дыня", "манго")
печать (thistuple [-4: -1])

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

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

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

Но есть обходной путь. Вы можете преобразовать кортеж в список, изменить список и преобразовать список обратно в кортеж.

Пример

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

x = ("яблоко", "банан", "вишня")
y = список (x)
y [1] = "киви"
x = кортеж (y)

print (x)

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

цикл через кортеж

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

Пример

Переберите элементы и выведите значения:

thistuple = ("яблоко", "банан", "вишня")
для х в трижды:
отпечаток (х)

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

Подробнее о для циклов вы узнаете в нашей главе Python For Loops.


Проверьте, существует ли предмет

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

Пример

Проверьте, присутствует ли «яблоко» в кортеже:

thistuple = ("яблоко", "банан", "вишня")
если «яблоко» в thistuple:
отпечаток («Да,« яблоко »в кортеже фруктов»)

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

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

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

Пример

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

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

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

Добавить товары

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

Пример

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

thistuple = ("яблоко", "банан", "вишня")
thistuple [3] = "orange" # Это вызовет ошибку
print (thistuple)

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

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

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

Пример

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

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

# НЕ кортеж
thistuple = ("apple")
печать (тип (thistuple))

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

Удалить объекты

Примечание: Невозможно удалить элементы в кортеже.

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

Пример

Ключевое слово del может удалить кортеж полностью:

thistuple = ("яблоко", "банан", "вишня")
дель thistuple
print (thistuple) # это вызовет ошибку, потому что кортеж больше не существует

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

Присоединиться к двум кортежам

Чтобы объединить два или более кортежей, вы можете использовать + оператор:

Пример

Соединить два кортежа:

tuple1 = ("a", "b", "c")
tuple2 = (1, 2, 3)

tuple3 = tuple1 + tuple2
печать (tuple3)

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

Кортеж () Конструктор

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

Пример

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

thistuple = tuple (("яблоко", "банан", "вишня")) # обратите внимание на двойные круглые скобки
печать (thistuple)

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

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

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

Метод Описание
count () Возвращает число раз, когда указанное значение встречается в кортеже
index () Выполняет поиск кортежа для указанного значения и возвращает позицию, в которой оно было найдено


,

Python Tuple (с примерами)

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


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

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

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

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

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

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

# кортеж со смешанными типами данных
my_tuple = (1, "Hello", 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
печать (б) № 4.6
print (c) # собака  

Выход

  (3, 4,6, «собака»)
3
4,6
собака  

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

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

  my_tuple = ("привет")
print (type (my_tuple)) # 

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

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

Выход

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

Access Tuple Elements

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

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

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

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

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

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

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

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

# 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  

Выход

  р
T
s
4  

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

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

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

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

# Вывод: '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])

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

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

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

Выход

  ('r', 'o', 'g')
('p', 'r')
(«я», «я»)
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')  

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

Element Slicing in Python Нарезка элементов в 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))

# Повторение
# Вывод: («Повторить», «Повторить», «Повторить»)
печать ((«Повторить»,) * 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]

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

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

Выход

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

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

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

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

  my_tuple = ('a', 'p', 'p', 'l', 'e',)

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

Выход

  2
3  

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

1. Тест членства Tuple

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

  # Членский тест в кортеже
my_tuple = ('a', 'p', 'p', 'l', 'e',)

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

# Не работает
печать («g» не в my_tuple)  

Выход

  True
Ложь
Правда  

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

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

  # Использование цикла for для итерации по кортежу
для имени в («Джон», «Кейт»):
    печать («Привет», имя)  

Выход

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

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

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

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

кортежей Python

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

Основное различие между кортежами и списками заключается в том, что списки являются изменяемыми, а кортежи - нет. Изменяемый объект - это объект, который можно изменить. Неизменяемый объект - это объект, который содержит фиксированное значение, которое не может быть изменено .Если это нужно изменить, новый объект должен быть создан.

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

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

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

дни недели = ("понедельник", "вторник", "среда", "четверг", "пятница")

На самом деле, кронштейны не являются обязательными.Таким образом, вы также можете сделать это:

дни недели = "понедельник", "вторник", "среда", "четверг", "пятница"

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

# Установите кортежи дни недели = ("понедельник", "вторник", "среда", "четверг", "пятница") выходные дни = "суббота", "воскресенье" # Распечатать кортежи печать (по рабочим дням) печать (weekenddays)

Результат

  («Понедельник», «Вторник», «Среда», «Четверг», «Пятница»)
(«Суббота», «Воскресенье»)  

кортежей одного предмета

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

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

а = ("собака") b = ("собака",) печать (тип (а)) печати (тип (б))

Результат

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

Итак, переменная без запятой оказалась строкой. Переменная с запятой стала кортежем.

Кортеж, содержащий список

Кортежи также могут содержать списки. Пример:

# Установить кортеж t = («Банан», [1, 2, 3]) # Распечатать кортеж печать (т)

Результат

  («Банан», [1, 2, 3])  

Доступ к значениям в кортеже

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

# Установить кортеж дни недели = ("понедельник", "вторник", "среда", "четверг", "пятница") # Распечатать второй элемент кортежа Печать (дни недели [1])

Результат

  вторник  

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

дни недели = ("понедельник", "вторник", "среда", "четверг", "пятница") Печать (дни недели [1: 4])

Результат

  («вторник», «среда», «четверг»)  

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

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

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

Нравится:

t = (101, 202, [«Понедельник», «Вторник», «Среда», «Четверг», «Пятница»]) печать (т [2] [1])

Результат

  вторник  

Обновление кортежа

Как уже упоминалось, кортежи содержат фиксированные элементы, и они являются неизменяемыми, что означает, что они не могут быть изменены.Таким образом, вы не можете изменить «Среда» на «Горбатый день» или что-то в этом роде.

Но вы можете переназначить кортеж. То есть вы можете назначить кортежу совершенно другой набор значений. Как это:

# Установить и распечатать исходный кортеж выходные дни = ("суббота", "воскресенье") печать (weekenddays) # Переназначить и распечатать выходные дни = ("Сб", "Солнце") печать (weekenddays)

Результат

  («суббота», «воскресенье»)
(«Сб», «Солнце»)  

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

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

# Назначить кортеж t = (101, 202, [«Понедельник», «Вторник», «Среда», «Четверг», «Пятница»]) печать (т) # Обновить третий элемент списка t [2] [2] = "Горбатый день" печать (т)

Результат

  (101, 202, [«Понедельник», «Вторник», «Среда», «Четверг», «Пятница»])
(101, 202, [«Понедельник», «Вторник», «Горбатый день», «Четверг», «Пятница»])  

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

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

# Установите два кортежа дни недели = ("понедельник", "вторник", "среда", "четверг", "пятница") выходные дни = ("суббота", "воскресенье") # Установите третий кортеж на значение двух предыдущих все дни = будни + выходные дни # Распечатать их все печать (по рабочим дням) печать (weekenddays) печать (Alldays)

Результат

  («Понедельник», «Вторник», «Среда», «Четверг», «Пятница»)
('Суббота Воскресенье')
(«Понедельник», «Вторник», «Среда», «Четверг», «Пятница», «Суббота», «Воскресенье»)  

Как видите, два исходных кортежа остаются неизменными, а третий содержит все значения из обоих.

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

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

t = (1,2,3) дель т

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

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

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

# Импортировать функцию namedtuple из модуля коллекций из коллекции импорта namedtuple # Установить кортеж Individual = namedtuple («Индивидуальный», «Имя, возраст, рост») пользователь = индивидуальный (имя = "Гомер", возраст = 37, рост = 178) # Распечатать кортеж печать (пользователь) # Распечатать каждый элемент в кортеже печать (user.name) печать (user.age) печать (user.height)

Результат

  Индивидуальный (имя = 'Гомер', возраст = 37, рост = 178)
Homer
37
178  

Таким образом, вместо print (user [0]) для ввода поля имени, мы можем использовать print (user.имя) вместо. И, конечно, то же самое относится ко всем другим областям.

Вы увидите, что в первой строке импортируется функция namedtuples из модуля коллекций . Нам нужна эта функция, прежде чем мы сможем создать наш именованный кортеж. Я объясню модули позже в этом руководстве, но сейчас главное понять, что вам нужно импортировать эту функцию, прежде чем вы сможете создать именованный кортеж.

,

кортежей Python - GeeksforGeeks

Tuple - это коллекция объектов Python, очень похожая на список. Последовательность значений, хранящихся в кортеже, может быть любого типа, и они индексируются целыми числами.
Значения кортежа синтаксически разделены «запятыми». Хотя это и не является необходимым, более обычно определить кортеж, закрыв последовательность значений в скобках. Это помогает легче понять кортежи Python.

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

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

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

Программа Python для демонстрации добавления элементов в кортеж.

Tuple1 = ()

print ( "Начальный пустой кортеж:" )

print (Tuple1)

Tuple1 = ( 'Geeks' , 'Для' )

print ( "\ nТупло с использованием строки:" )

print (Tuple1)

list1 = [ 1 , 2 , 4 , 5 , 6 ]

печать ( "\ nТуплирование с использованием списка:" )

print ( кортеж (list1))

Tuple1 = Tuple ( 'Geeks' )

print ( "\ nТупло с использованием функции:" )

print (Tuple1)

Выход:

 Начальный пустой кортеж:
()

Кортеж с использованием String:
(«Гики», «За»)

Кортеж, используя список:
(1, 2, 4, 5, 6)

Кортеж с использованием функции:
('G', 'e', ​​'e', ​​'k', 's')
 
Создание кортежа со смешанными типами данных.

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



Tuple1 = ( 5 , 'Welcome' , 7 , 'Geeks' )

print ( "\ nТуплет со смешанными типами данных:" )

print (Tuple1)

Tuple1 = ( 0 , 1 , 2 , 3 )

Tuple2 = ( 'python' , 'geek' )

Tuple3 = (Tuple1, Tuple2)

print ( "\ nТуплет с вложенными кортежами:" )

печать (Tuple3)

Tuple1 = ( 'Geeks' ,) * 3

печать ( "\ nТуплет с повторением:" )

print (Tuple1)

Tuple1 = ( 'Geeks' )

n = 5

печать ( "\ nТупле с петлей" )

для и в диапазоне ( и (n)):

Tuple1 = (Tuple1,)

печать (Tuple1)

Выход:

 Кортеж со смешанными типами данных:
(5, «Добро пожаловать», 7, «Гики»)

Кортеж с вложенными кортежами:
((0, 1, 2, 3), ('python', 'geek'))

Кортеж с повторением:
(«Гики», «Гики», «Гики»)

Кортеж с петлей
( 'Вундеркинды',)
(( 'Вундеркинды',),)
((( 'Вундеркинды',),),)
(((( 'Вундеркинды',),),),)
((((( 'Выродки',),),),),)
 

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

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

ПРИМЕЧАНИЕ : При распаковке кортежа количество переменных слева должно быть равно количеству значений в данном кортеже a.

Tuple1 = Tuple ( "Geeks" )

print ( "\ nПервый элемент кортежа:" )

print (Tuple1 [ 1 ])

Tuple1 = ( "Вундеркинды" , "Для" , "Вундеркинды" )

a, b, c = Tuple1

print ( "\ nЗначения после распаковки:" )

печать (а)

печать (b)

печать (с)

Выход:

Первый элемент Tuple:
е

Значения после распаковки:
Geeks
Для
Вундеркиндов 

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

Конкатенация кортежей - это процесс объединения двух или более кортежей.Конкатенация выполняется с помощью оператора «+». Конкатенация кортежей выполняется всегда с конца исходного кортежа. Другие арифметические операции не применяются к кортежам.
Примечание- Только конкатенация может быть объединена только с одними и теми же типами данных, при объединении списка и кортежа возникает ошибка.

Tuple1 = ( 0 , 1 , 2 , 3 )

Tuple2 = ( 'Geeks' , 'Для' , 'Geeks' )

Tuple3 = Tuple1 + Tuple2

print ( "Tuple 1:" )

print (Tuple1)

печать ( "\ nTuple2:" )

print (Tuple2)

печать ( "\ nТуплирование после объединения:" )

печать (Tuple3)

Выход:

Кортеж 1:
(0, 1, 2, 3)

Tuple2:
(«Гики», «За», «Гики»)

Кортежи после объединения:
(0, 1, 2, 3, «Гики», «За», «Гики»)
 

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

Нарезка кортежа выполняется для извлечения определенного диапазона или среза подэлементов из кортежа.Нарезка также может быть сделана для списков и массивов. Индексирование в списке приводит к извлечению одного элемента, тогда как Slicing позволяет извлекать набор элементов.
Примечание к - значения отрицательного приращения также можно использовать для изменения последовательности кортежей

Tuple1 = Tuple ( 'GEEKSFORGEEKS' )

print ( "Удаление первого элемента:" )

print (Tuple1 [ 1 :])

print ( "\ nТуплекс после изменения последовательности элементов:" )

print (Tuple1 [:: - 1 ])

print ( "\ nПечать элементов в диапазоне 4-9:" )

print (Tuple1 [ 4 : 9 ])

Выход:


Удаление первого элемента:
(«E», «E», «K», «S», «F», «O», «R», «G», «E», «E», «K», «S»)

Кортеж за последовательностью Элемента меняется на противоположный:
('S', 'K', 'E', 'E', 'G', 'R', 'O', 'F', 'S', 'K', 'E', 'E', ' ГРАММ')

Печатные элементы в диапазоне 4-9:
(«S», «F», «O», «R», «G»)
 

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

Кортежи являются неизменяемыми и, следовательно, они не допускают удаления его части.Весь кортеж удаляется с помощью метода del ().
Примечание- Печать кортежа после удаления приводит к ошибке.

Tuple1 = ( 0 , 1 , 2 , 3 , 4 )

del Tuple1

print (Tuple1)

Трассировка

(последний вызов был последним): файл
«/ home / efa50fd0709dec08434191f32275928a.py ”, строка 7, в
print (Tuple1)
NameError: имя‘ Tuple1 ’не определено

встроенных методов
. Перечислить Не более
Встроенная функция Описание
все () Возвращает true, если все элементы верны или если кортеж пуст
любой () возвращает true, если какой-либо элемент кортежа имеет значение true. если кортеж пуст, вернуть false
len () Возвращает длину кортежа или размер кортежа
() Возвращает перечислить объект кортежа
() возвращает максимальный элемент данного кортежа
мин () возвращает минимальный элемент данного кортежа
сум () Суммирует числа в кортеже
отсортировано () вводим элементы в кортеж и возвращаем новый отсортированный список
tuple () Конвертируем итерацию в кортеж.

Последние статьи на Tuple

Кортежи Программы

,

Отправить ответ

avatar
  Подписаться  
Уведомление о