Кортежи (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
pythonworld.ru
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
<<< Python. Урок 7. Работа со списками (list) Python. Урок 9. Словари (dict)>>>
devpractice.ru
список и кортеж / Habr
В 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.: Я являюсь автором этой статьи, можете задавать любые вопросы.
habr.com
создание и приведение к списку
Чтобы усовершенствовать программный код, добавить в него новые важные функции используются разнообразные методы. К ним относится: создание списков, кортежей или словарей. В данной статье рассмотрим, когда используются, чем они отличаются, как создать и как работать с кортежами в 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После выполнения кода на дисплее появится запись всех элементов в одну строку с указанным разделителем. В первом случае – без пробелов, а во втором случае – через запятую.
Чем же кортежи удобнее? Работа с ними проходит быстрее, чем, например, со списками. Если программисту нужно определить постоянный набор значений, чтобы затем их перебирать, то лучше будет сделать это с его помощью. Плюс – это экономия оперативной памяти, так как они занимают меньше места, чем списки.
all-python.ru
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, который представляет страны, состоит из кортежей, каждый из которых — отдельная страна.
Вложенные кортежи имеют три элемента: название страны, численность ее населения и города. Города представляют отдельный кортеж, где каждый отдельный город — это вложенный кортеж, содержащий название города и численность его населения.
metanit.com
Именованные кортежи. Пишем код на Python чище / Habr
В стандартной библиотеке питона содержится специализированный тип «namedtuple», который, кажется, не получает того внимания, которое он заслуживает. Это одна из прекрасных фич в питоне, которая скрыта с первого взгляда.
Именованные кортежи могут быть отличной альтернативой определению классов и они имеют некоторые другие интересные особенности, которые я хочу показать вам в этой статье.
Так что же такое именованный кортеж и что делает его таким специализированным? Хороший способ поразмышлять над этим — рассмотреть именованные кортежи как расширение над обычными кортежами.
Кортежи в питоне представляют собой простую структуру данных для группировки произвольных объектов. Кортежи являются неизменяемыми — они не могут быть изменены после их создания.
>>> tup = ('hello', object(), 42)
>>> tup
('hello', <object object at 0x105e76b70>, 42)
>>> tup[2]
42
>>> tup[2] = 23
TypeError: "'tuple' object does not support item assignment"Обратная сторона кортежей — это то, что мы можем получать данные из них используя только числовые индексы. Вы не можете дать имена отдельным элементам сохранённым в кортеже. Это может повлиять на читаемость кода.
Также, кортеж всегда является узкоспециализированной структурой. Тяжело обеспечить, что бы два кортежа имели одни и те же номера полей и одни и те же свойства сохранённые в них. Это делает их лёгкими для знакомства со “slip-of-the-mind” багами, где легко перепутать порядок полей.
Цель именованных кортежей — решить эти две проблемы.
Прежде всего, именованные кортежи являются неизменяемыми подобно обычным кортежам. Вы не можете изменять их после того, как вы что-то поместили в них.
Кроме этого, именованные кортежи это, эм…, именованные кортежи. Каждый объект сохраненный в них может быть доступен через уникальный, удобный для чтения человеком, идентификатор. Это освобождает вас от запоминания целочисленных индексов или выдумывания обходных путей типо определения целочисленных констант как мнемоник для ваших индексов.
Вот как выглядит именованный кортеж:
>>> from collections import namedtuple
>>> Car = namedtuple('Car' , 'color mileage')Чтобы использовать именованный кортеж, вам нужно импортировать модуль collections. Именованные кортежи были добавлены в стандартную библиотеку в Python 2.6. В примере выше мы определили простой тип данных «Car» с двумя полями: «color» и «mileage».
Вы можете найти синтакс немного странным здесь. Почему мы передаём поля как строку закодированную с «color mileage»?
Ответ в том, что функция фабрики именованных кортежей вызывает метод split() на строки с именами полей. Таким образом, это, действительно, просто сокращение, что бы сказать следующее:
>>> 'color mileage'.split()
['color', 'mileage']
>>> Car = namedtuple('Car', ['color', 'mileage'])Конечно, вы также можете передать список со строками имён полей напрямую, если вы предпочитаете такой стиль. Преимущество использования списка в том, что в этом случае легко переформатировать этот код, если вам понадобится разделить его на несколько линий:
>>> Car = namedtuple('Car', [
... 'color',
... 'mileage',
... ])Как бы вы ни решили, сейчас вы можете создать новые объекты «car» через фабричную функцию Car. Поведение будет такое же, как если бы вы решили определить класс Car вручную и дать ему конструктор принимающий значения «color» и «mileage»:
>>> my_car = Car('red', 3812.4)
>>> my_car.color
'red'
>>> my_car.mileage
3812.4Распаковка кортежей и оператор ‘*’ для распаковки аргументов функций также работают как ожидается:
>>> color, mileage = my_car
>>> print(color, mileage)
red 3812.4
>>> print(*my_car)
red 3812.4Несмотря на доступ к значениям сохранённым в именованном кортеже через их идентификатор, вы всё ещё можете обращаться к ним через их индекс. Это свойство именованных кортежей может быть использовано для их распаковки в обычный кортеж:
>>> my_car[0]
'red'
>>> tuple(my_car)
('red', 3812.4)Вы даже можете получить красивое строковое отображение объектов бесплатно, что сэкономит вам время и спасёт от избыточности:
>>> my_car
Car(color='red' , mileage=3812.4)Именованные кортежи, как и обычные кортежи, являются неизменяемыми. Когда вы попытаетесь перезаписать одно из их полей, вы получите исключение AttributeError:
>>> my_car.color = 'blue'
AttributeError: "can't set attribute"Объекты именованных кортежей внутренне реализуются в питоне как обычные классы. Когда дело доходит до использованию памяти, то они так же «лучше», чем обычные классы и просто так же эффективны в использовании памяти как и обычные кортежи.
Хороший путь судить о них — считать, что именованные кортежи являются краткой формой для создания вручную эффективно работающего с памятью неизменяемого класса.
Поскольку именованные кортежи построены на обычных классах, то вы можете добавить методы в класс, унаследованный от именованного кортежа.
>>> Car = namedtuple('Car', 'color mileage')
>>> class MyCarWithMethods(Car):
... def hexcolor(self):
... if self.color == 'red':
... return '#ff0000'
... else:
... return '#000000'Сейчас мы можем создать объекты MyCarWithMethods и вызвать их метод hexcolor() так, как ожидалось:
>>> c = MyCarWithMethods('red', 1234)
>>> c.hexcolor()
'#ff0000'Несмотря на то, что это может быть немного неуклюже, такая реализация может быть стоящим делом если вы хотите получить класс с неизменяемыми свойствами. Но вы легко можете прострелить себе ногу в таком случае.
Например, добавление нового неизменяемого поля является каверзной операцией из-за того как именованные кортежи устроены внутри. Более простой путь создания иерархии именованных кортежей — использование свойства ._fields базового кортежа:
>>> Car = namedtuple('Car', 'color mileage')
>>> ElectricCar = namedtuple(
... 'ElectricCar', Car._fields + ('charge',))Это даёт желаемый результат:
>>> ElectricCar('red', 1234, 45.0)
ElectricCar(color='red', mileage=1234, charge=45.0)Кроме свойства _fields каждый экземпляр именованного кортежа также предоставляет ещё несколько вспомогательных методов, которые вы можете найти полезными. Все их имена начинаются со знака подчёркивания, который говорит нам, что метод или свойство «приватное» и не является частью устоявшегося интерфейса класса или модуля.
Что касается именованных кортежей, то соглашение об именах начинающихся со знака подчёркивания здесь имеет другое значение: эти вспомогательные методы и свойства являются частью открытого интерфейса именованных кортежей. Символ подчёркивания в этих именах был использован для того, чтобы избежать коллизий имён с полями кортежа, определёнными пользователем. Так что, не стесняйтесь использовать их, если они вам понадобятся!
Я хочу показать вам несколько сценариев где вспомогательные методы именованного кортежа могут пригодиться. Давайте начнём с метода _asdict(). Он возвращает содержимое именованного кортежа в виде словаря:
>>> my_car._asdict()
OrderedDict([('color', 'red'), ('mileage', 3812.4)])Это очень здорово для избегания опечаток при создании JSON, например:
>>> json.dumps(my_car._asdict())
'{"color": "red", "mileage": 3812.4}'Другой полезный помощник — функция _replace(). Она создаёт поверхностную(shallow) копию кортежа и разрешает вам выборочно заменять некоторые поля:
>>> my_car._replace(color='blue')
Car(color='blue', mileage=3812.4)И, наконец, метод класса _make() может быть использован чтобы создать новый экземпляр именованного кортежа из последовательности:
>>> Car._make(['red', 999])
Car(color='red', mileage=999)Именованные кортежи могут быть простым способом для построения вашего кода, делая его более читаемым и обеспечивая лучшее структурирование ваших данных.
Я нахожу, например, что путь от узкоспециализированных структур данных с жёстко заданным форматом, таких как словари к именованным кортежам помогает мне выражать мои намерения более чисто. Часто когда я пытаюсь это рефакторить, то я магически достигаю лучших решений проблем, с которыми я сталкиваюсь.
Использование именованных кортежей вместо неструктурированных кортежей и словарей может также сделать жизнь моих коворкеров легче, потому что эти структуры данных помогают создавать данные понятным, самодокументирующимся(в достаточной степени) образом.
С другой стороны, я стараюсь не использовать именованные кортежи ради их пользы, если они не помогают мне писать чище, читабельнее и не делают код более лёгким в сопровождении. Слишком много хороших вещей может оказаться плохой вещью.
Однако, если вы используете их с осторожностью, то именованные кортежи, без сомнения, могут сделать ваш код на Python лучше и более выразительным.
- collections.namedtuple — краткая форма для создания вручную эффективно работающего с памятью неизменяемого класса.
- Именованные кортежи могут помочь сделать ваш код чище, обеспечивая вас более простыми в понимании структурами данных.
- Именованные кортежи предоставляют несколько полезных вспомогательных методов которые начинаются с символа подчёркивания (_), но являются частью открытого интерфейса. Использовать их — это нормальная практика.
habr.com
Основы Python — кратко. Часть 3. Списки, кортежи, файлы. / Habr
В общем-то последняя из готовых глав. Остальные будут выходить чуть реже, поскольку еще не написаны (но я уверен что будут, хотя это зависит только от ваших пожеланий, уважаемые читатели 🙂Также следует заметить что это это, видимо, последний «простой урок», дальше я постараюсь углубиться во все аспекты программирования, которые мы прошли «по верхам» и продолжить более детально.
В общем, те кому не интересно — читают следующую новость, а остальных — прошу пройти .
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 со всем ее содержимым.
— Написать программу, которая получив на входе произвольный список удалит из него все повторяющиеся элементы.
habr.com