что относится к кортежам
Кортежи (tuple) в C#
Основные свойства кортежей:
кортежи определяются с неограниченным количеством элементов.
Кортежи являются типом значений.
Значения кортежей являются общедоступными полями.
Возможно определение типа для каждого из значений. Для этого перед именем кортежа в скобках указываются типы для каждого значения.
Для каждого значения кортежа предусмотрена возможность индивидуального именования. Заданное имя элемента называется именем кандидата. Оно является дубликатором другого явного или неявного имени поля кортежа.
Для определения кортежей можно применять переменные, с которыми в дальнейшем можно производить операции.
Применение кортежей
Кортежи могут передаваться в метод в качестве параметров и служить возвращаемым результатом. В частности, очень удобно возвращать кортеж в качестве результата в том случае, если метод возвращает только одно значение.
В следующем примере кортеж передается в метод в качестве параметра.
Присваивание кортежей
В кортежах предусмотрена возможность присваивания. Для этого оба кортежа должны иметь одинаковое количество элементов, типы соответствующих значений должны совпадать или иметь возможность неявного приведения друг к другу. Значения присваиваются в порядке их расположения. При присвоении имена полей не учитываются.
Деконструкция кортежей
Деконструкцией кортежей называется операция присваивания экземпляра кортежа в отдельные переменные.
Проверка кортежей на равенство
Имена полей кортежей при сравнении не учитываются.
Условия возможности сравнения кортежей:
Оба кортежа содержат одинаковое количество элементов.
Элементы должны соответствовать возможности сравнения.
Кортежи в качестве параметров вывода
При выполнении рефакторинга метода, имеющего параметры out они могут иметь тип кортежа.
Различия между типами кортежей System.ValueTuple и SystemTuple
Основные различия заключаются в следующем:
Значениями типов ValueTuple являются поля. Значениями типов Tuple являются свойства.
Список использованных источников
Кортежи в Python (tuple)
Кортеж (tuple) — ещё один вид последовательностей в Python.
Как видно, в литеральной форме кортеж python 3 записывается в виде последовательности элементов в круглых скобках, в то время как для списков характерны квадратные.
👉 Некоторые особенности кортежей:
Примеры кортежей
Зачем использовать кортеж вместо списка?
Тем, кто уже успел познакомиться со списками в Python, может показаться не очевидным смысл использования кортежей. Ведь фактически, списки могут делать всё то же самое и даже больше. Это вполне естественный вопрос, но, разумеется, у создателей языка найдётся на него ответ:
💡 Кроме того, кортежи удобно использовать, когда необходимо вернуть из функции несколько значений:
def get_status(service_name): return None, f»service
Работа с кортежами
Создание
Как и другие коллекции языка Питон, кортеж можно создать двумя способами.
Способ №1 : Литеральное объявление:
literal_creation = (‘any’, ‘object’) print(literal_creation) > (‘any’, ‘object’) print(type(literal_creation)) >
Способ №2 : Через функцию tuple() :
tuple_creation = tuple(‘any iterable object’) print(tuple_creation) > (‘a’, ‘n’, ‘y’, ‘ ‘, ‘i’, ‘t’, ‘e’, ‘r’, ‘a’, ‘b’, ‘l’, ‘e’, ‘ ‘, ‘o’, ‘b’, ‘j’, ‘e’, ‘c’, ‘t’) print(type(tuple_creation)) >
💁♀️ Важно, чтобы аргумент, передаваемый в tuple() был итерируемым объектом:
incorrect_creation = tuple(777) > Traceback (most recent call last): incorrect_creation = tuple(777) TypeError: ‘int’ object is not iterable
Упаковка
Упаковкой кортежа называют присваивание его какой-то переменной, что, по сути, совпадает с операцией объявления.
Стоит обратить внимание 2 момента:
Распаковка
Обратная операция, смысл которой в том, чтобы присвоить значения элементов кортежа отдельным переменным.
notes = (‘Do’, ‘Re’, ‘Mi’, ‘Fa’, ‘Sol’, ‘La’, ‘Si’) do, re, mi, fa, sol, la, si = notes print(mi) > Mi
Количество переменных должно совпадать с числом элементов tuple
Однако, если необходимо получить лишь какие-то отдельные значения, то в качестве «ненужных» переменных позволено использовать символ нижнего подчеркивания » _ «:
night_sky = ‘Moon’, ‘Stars’ moon, _ = night_sky print(moon) > Moon
Обращение к элементу и поиск в кортеже
Обратиться к элементу кортежа можно по номеру его позиции. Причём как с начала, так и с конца:
Если элемент кортежа есть вложенный кортеж, то применяются дополнительные квадратные скобки (в зависимости от уровня вложенности). Например, чтобы обратиться ко второму элементу второго элемента, следует поступить так:
input_box = (‘firstbox’, (15, 150)) # помним про индексацию, ведущую своё начало с 0 print(input_box[1][1]) > 150
Узнать, присутствует ли объект среди элементов кортежа, можно с помощью оператора in:
song = (‘Roses’, ‘are’, ‘Red’) print(‘Red’ in song) print(‘Violet’ in song) > True > False
Сравнение
Перебор
Наиболее простым и очевидным способом перебрать элементы кортежа является обход его в цикле for :
my_tuple = (‘Wise’, ‘men’, ‘say’, ‘only’, ‘fools’, ‘rush’, ‘in’) # Вывести все элементы кортежа for word in my_tuple: print(word) > Wise men say only fools rush in
Сортировка
Нет ничего проще, чем отсортировать готовый кортеж. В этом наш друг и помощник — прекрасная функция sorted() :
not_sorted_tuple = (10**5, 10**2, 10**1, 10**4, 10**0, 10**3) print(not_sorted_tuple) > (100000, 100, 10, 10000, 1, 1000) sorted_tuple = tuple(sorted(not_sorted_tuple)) print(sorted_tuple) > (1, 10, 100, 1000, 10000, 100000)
Удаление
Добавить или удалить элемент содержащийся в tuple нельзя, по причине всё той же неизменяемости. Однако сам кортеж стереть с цифрового лица Земли возможно. Оператор del к нашим услугам:
some_useless_stuff = (‘sad’, ‘bad things’, ‘trans fats’) del some_useless_stuff print(some_useless_stuff) > Traceback (most recent call last): print(some_useless_stuff) NameError: name ‘some_useless_stuff’ is not defined
Методы и особые операции
Слайсы кортежей предельно похожи на таковые у строк, а выглядят они следующим образом:
Где start — начальный элемент среза (включительно), fin — конечный (не включительно) и step — «шаг» среза.
Длина кортежа
php = (‘p’, ‘h’, ‘p’) print(len(php)) > 3
Конкатенация
Для tuple определена операция конкатенации:
storm_1 = (‘Lightning’)Union = (‘ and ‘) storm_2 = (‘Thunder’) print(storm_1 + Union + storm_2) > Lightning and Thunder
Повторение
Как и в случае с конкатенацией, для кортежей, впрочем, как и для строк, определена операция повторения:
dog_do = (‘woof!’,) print(dog_do * 3) > (‘woof!’, ‘woof!’, ‘woof!’)
Индекс заданного элемента
Метод index() позволяет получить индекс элемента. Достаточно передать нужное значение элемента, как аргумент метода:
rom = (‘I’, ‘II’, ‘III’, ‘IV’, ‘V’, ‘VI’, ‘VII’, ‘VIII’, ‘IX’, ‘X’) print(rom.index(‘X’)) > 9
Число вхождений элемента
Метод count() ведёт подсчет числа вхождений элемента в кортеж.
AT = (‘Finn’, ‘Jake’, ‘BiMo’, ‘Marceline’, ‘Princess Bubblegum’, ‘BiMo’) print(AT.count(‘Finn’)) > 1 print(AT.count(‘BiMo’)) > 2
Преобразование
Tuple to Str
Представляем вашему вниманию лёгкий способ преобразовать кортеж в строку при помощи метода join() :
game_name = (‘Breath’, ‘ ‘, ‘of’, ‘ ‘, ‘the’, ‘ ‘, ‘Wild’) game_name = ».join(game_name) print(game_name) > Breath of the Wild
Tuple to List
Тут всё ещё проще. Для такой конвертации необходимо всего лишь передать кортеж, как аргумент функции list() :
dig_tuple = (1111, 2222, 3333) print(dig_tuple) > (1111, 2222, 3333) dig_list = list(dig_tuple) print(dig_list) > [1111, 2222, 3333]
Tuple to Dict
А вот для преобразования кортежа в словарь придётся применить небольшую хитрость, а именно — генератор словарей:
score = ((‘Eric’, 65000), (‘Stephany’, 87000)) score_dict = dict((x, y) for x, y in score) print(score_dict) >
Именованные кортежи
Мощная особенность и настоящая гордость языка.
Именованный кортеж (или named tuple) позволяет программисту обращаться к элементу кортежа не по индексу, а через удобочитаемый заранее заданный идентификатор.
Покажем на примере:
# для начала импортируем сам модуль from collections import namedtuple citizen = namedtuple(«Citizen», «name age status») Alex = citizen(name=’Alex Mercer’, age=27, status=’show businessman’) print(Alex.name) > Alex Mercer print(Alex.status) > show businessman
Точечная нотация при обращении к свойству объекта может вызвать невольную ассоциацию с классами. В общем-то одно из применений namedtuple как раз связано с ситуациями, когда нужно передать несколько свойств объекта одним куском.
Tuple index out of range
Такая ошибка может возникнуть, например, при запуске следующего кода:
i_initiate_error = (‘west’, ‘north’, ‘east’, ‘south’) print(i_initiate_error[4])
Причина её возникновения в том, что нельзя получить доступ к индексу кортежа за пределами его длины. Эта ошибка может возникать и при совсем нетривиальных обстоятельствах, однако суть её останется прежней. Начинающим программистам стоит помнить, что индексация кортежей начинается с 0, а не с 1.
Кортежи весьма похожи на списки, но очень сложно спорить с тем, что гибкость и функционал последних намного выше. Поэтому, при написании программ, следует, в основном, пользоваться ими, а не кортежами.
Кортежи в языках программирования. Часть 1
Сейчас во многих языках программирования существует такая конструкция, как кортежи (tuples). Где-то кортежи в той или иной мере встроены в язык, иногда — опять же в той или иной мере — реализуются средствами библиотек. C++, C#, D, Python, Ruby, Go, Rust, Swift (а также Erlang, F#, Groovy, Haskell, Lisp, OCaml и многие другие)…
Что же такое кортеж? В Википедии дается достаточно точное определение: кортеж — упорядоченный набор фиксированной длины. Определение хоть и точное, но для нас пока бесполезное, и вот почему: задумывается ли большинство программистов, зачем понадобилась эта сущность? В программировании существует множество структур данных, как фиксированной, так и переменной длины; они позволяют хранить различные значения — как однитипные, так и разных типов. Всевозможные массивы, ассоциативные массивы, списки, структуры… зачем еще и кортежи? А в языках со слабой типизацией — и тем более, разница между кортежами и списками/векторами совсем размытая… ну нельзя добавлять в кортеж элементы, ну и что с того? Это может ввести в некоторое заблуждение. Поэтому стоит копнуть глубже и разобраться, зачем же на самом деле нужны кортежи, чем они отличаются от других языковых конструкций, и как сформировать идеальный синтаксис и семантику кортежей в идеальном (или близком к идеальному) языке программирования.
В первой части мы рассмотрим кортежи и кортежеподобные конструкции в распространенных и не очень языках программирования. Во второй части я попытаюсь обобщить и расширить и предложить наиболее универсальный синтаксис и семантику кортежей.
Первая важная вещь, о которой на Википедии не упомянули: кортеж — это структура времени компиляции. Иными словами, это некая сущность, объединяющая некоторые объекты на этапе компиляции. И это очень важно. Кортежи неявно используются во всех языках программирования, даже в Си и Ассемблере. Давайте поищем их в том же Си, С++, в любом компилируемом языке.
Так, список аргументов функции — это кортеж;
Список инициализации структуры или массива — это тоже кортеж;
Список аргументов шаблона или макроса — тоже кортеж
Описание структуры, и даже обычный блок кода — это тоже кортеж; только элементами его являются не объекты, а синтаксические конструкции.
Кортежей в программе гораздо больше чем кажется на первый взгляд. Но они все неявные; так или иначе они являются жестко прикрученными к каким-то синтаксическим конструкциям. Явное использование кортежей в старых языках было не предусмотрено. В более современных языках некоторые возможности явного использования стали появляться — но далеко не все. Здесь мы будем рассматривать в основном кортежи значений — или переменных, или констант. Возможно, в следующих частях я рассмотрю и кортежи произвольных синтаксических элементов.
Начнем с самого очевидного — возврата нескольких значений из функции. Еще со школьных времен меня удивляла такая несправедливость: почему функция может принимать сколько угодно значений, а возвращать только одно? В самом деле, почему y=x*x — нормальная парабола, а y = sqrt(x) — какая-то обрезанная наполовину фигня? Разве это не нарушение математической гармонии? В программировании конечно можно возвратить структурный объект, но суть остается та же: возвращается один объект, а не несколько.
Непосредственная реализация множественного возврата есть в Go. Функция может явно вернуть несколько значений. Синтаксис позволяет присвоить эти несколько значений нескольким переменным, а также выполнять групповые присваивания и даже перестановки аргументов за одну операцию. Однако, никаких других групповых действий кроме присваивания не предусмотрено.
Интересная возможность, на которую следует обратить внимание — «пакетная» передача нескольких возвращаемых значений одной функции в другую функцию.
Такая пакетная передача сама по себе крайне интересна. С одной стороны, она кажется весьма элегантной; но с другой — она слишком «неявная», неуниверсальная. Например, если попытаться добавить в bar третий аргумент, и попытаться совместить «пакетную» передачу и обычную
то ничего не получится — ошибка компиляции.
Еще один интересный аспект — неиспользование возвращаемых значений. Вспомним С/С++. В них (а также в подавляющем большинстве других языков — Java, C#, ObjC, D. ) можно было спокойно игнорировать возвращаемые значения при вызове функции. В Go такое тоже возможно, причем можно игнорировать как единственное возвращаемое значение, так и группу. Однако, попытка использовать первое возвращаемое значение и неявно проигнорировать второе приводит к ошибке компиляции. Игнорировать возможно, но явно — с использованием специального символа «_»:
Т.е. работает принцип «все или ничего»: можно или игнорировать все возвращаемые значения, или использовать — но также все.
В Rust имеются схожие возможности. Точно также функции могут возвращать несколько значений; также можно инициализировать ими новые значения. При этом множественное присваивание как таковое отсутствует, возможна только инициализация. Аналогично можно использовать символ «_» для неиспользуемых значений. Аналогично можно игнорировать возвращаемые значения полностью, или получать их также все полностью. Также кортежи можно сравнивать:
Отметим этот факт: мы встретили первую операцию над кортежами, отличную от присваивания. Также здесь наблюдается еще одна интересная возможность — создание именованных кортежей и их последующее использование «как единого целого».
В языке Swift возможности в целом аналогичны. Из интересного — обращение к элементам кортежа по константному индексу через точку; возможность назначать элементам кортежа имена и обращаться к элементам через них.
Такие кортежи уже близки к структурам, но все-же структурами не являются. И здесь я бы хотел отойти от примеров и перейти к своим собственным мыслям. Разница между кортежами и структурами в том, что кортеж — это не тип данных, это нечто более низкоуровневое; можно сказать — что кортеж — это просто (возможно именованная) группа (возможно именованных) объектов времени компиляции. В этом месте вспомним языки C/С++. Простейшие конструкции инициализации массива и структуры выглядят так:
Обратите внимание, списки инициализации в данном случае вообще идентичны. И тем ни менее, они инициализируют совершенно разные объекты данных. Такое поведение в общем нетипично для типа данных. Но зато это близко к другой интересной фиче, которая иногда (но редко) встречается в языках программирования — структурной типизации. Конструкция в фигурных скобках — типичный кортеж. Кстати, в Си есть именованная инициализация полей структуры (идея кстати весьма похожа на Swift), которую пока так и не протащили в C++17:
В С++ пошли немного в другом направлении: ввели понятие » унифицированный синтаксис инициализации и списки инициализации». Синтаксически это те же кортежи, которые можно использовать для инициализации объектов; в дополнение к старым возможностям, унифицированный синтаксис инициализации позволяет передавать объекты в функции и возвращать из функций в виде кортежей.
Другая интересная возможность — списки инициализации.Они используются для начальной инициализации динамических структур данных — таких как вектора и списки. Списки инициализации в С++ должны быть однородными, то есть все элементы списка должны быть одного типа. Технически такие списки формируют константные массивы в памяти, для доступа к которым применяются итераторы std::initializer_list. Можно сказать, что шаблонный тип std::initializer_list — специальный определенный на уровне компилятора интерфейс к однородным кортежам (а фактически к константным массивам). Разумеется, списки инициализации можно использовать не только в конструкторах, но и как аргументы любых функций и методов. Думаю, если бы в С++ изначально был бы некий шаблонный тип данных, соответствующий литеральному массиву и содержащий информацию о длине этого массива, он бы вполне подошел на роль std::initializer_list.
Также в стандартной библиотеке С++ (и в Boost) существуют кортежи, реализованные с помощью шаблонов. Поскольку такая реализация не является частью языка, синтаксис получился слегка громоздким и неуниверсальным. Так, тип кортежа приходится объявлять явно с указанием типов всех полей; для конструирования объектов применяется функция std::make_tuple; для создания кортежа «на лету» (из существующих переменных) применяется другой шаблон — tie, а получение доступа к элементам осуществляется с помощью специального шаблонного метода, который требует константного индекса.
В примере применяется распаковка со специальным значением std::ignore. Это в точности соответствует символу подчеркивания «_», применяемому для тех же целей при групповых возвратах из функций в Go и Rust.
Похожим способом (хотя и упрощенно по сравнению с С++) реализованы кортежи в C#. Для создания используются методы Tuple.Create(), набора шаблонных классов Tuple<>, для доступа к элементам — поля с фиксированными именами Item1… item8 (чем достигается константность индекса).
В языке D есть достаточно богатая поддержка кортежей. С помощью конструкции tuple можно сформировать кортеж, и — в том числе — осуществить множественный возврат из функции. Для доступа к элементам кортежа используется индексация константными индексами. Также кортеж можно сконструировать с помощью шаблона Tuple, что позволяет создать кортеж с именованными полями.
Кортежи можно передавать в функции. Для этого применяется индексация с диапазоном. Синтаксически это выглядит как будто передается один аргумент, а на самом деле кортеж раскрывается сразу в несколько аргументов. При этом в D, в отличие от Go, нет требования точного равенства количества аргументов функции и элементов кортежа, то есть можно смешивать передачу одиночных аргументов и кортежей.
В D существует еще множество возможностей, связанных с кортежами — Compile-time foreach для обхода кортежей на этапе компиляции, шаблон AliasSeq, оператор tupleof… в общем все это требует отдельной большой статьи.
А напоследок рассмотрим реализацию кортежей в малоизвестном расширении языка Си — CForAll или C∀ (забавно, но на момент написания статьи я не смог нагуглить сайт языка — весьма вероятно что он давно закрылся и упоминаний просто не осталось; вот поэтому я регулярно сканирую сеть в поисках новых языков программирования и скачиваю все до чего смогу дотянуться).
Кортежи в C∀можно объявить на уровне языка, заключив список объектов в квадратные скобки. Тип кортежа создается аналогично — в квадратные скобки заключается список типов. Объекты и типы кортежей можно объявлять явно. Кортежи можно передавать в функции, где они разворачиваются в списки аргументов (в отличие от Go, где такое возможно только при точном совпадении кортежа и списка аргументов функции).
Еще одна интересная тема — вложенные кортежи и правила их раскрытия. В С/С++ также применяется вложенность — при инициализации массивов структур, элементы которых также являются массивами и структурами. В C∀ существуют правила, называемые «tuple coercions», в частности — раскрытие кортежей с внутренней структурой (flattering) и наоборот, структурирование (structuring), когда «плоский» кортеж подстраивается под сложную внутреннюю структуру (хотя эта возможность весьма спорная, обсуждение будет в следующей части). И все это относится лишь к присваиванию, никаких упоминаний использования этих возможностей с другими операциями нет.
В C∀ предусмотрено как групповое, так и множественное присваивание.
и даже использование кортежей для доступа к полям структур
Ввиду отсутствия компилятора проверить все эти возможности на практике не удалось, но это безусловно отличная пища для размышлений. Собственно, этим размышлениям и будет посвящена следующая часть статьи.
Python. Урок 8. Кортежи (tuple)
Данный урок посвящен кортежам (tuple) в Python. Основное внимание уделено вопросу использования кортежей, почему иногда лучше применять их, а не списки, рассмотрены способы создания и основные приемы работы с кортежами. Также затронем тему преобразования кортежа в список и обратно.
Что такое кортеж (tuple) в Python?
Кортеж (tuple) – это неизменяемая структура данных, которая по своему подобию очень похожа на список. Как вы наверное знаете, а если нет, то, пожалуйста, ознакомьтесь с седьмым уроком, список – это изменяемый тип данных. Т.е. если у нас есть список a = [1, 2, 3] и мы хотим заменить второй элемент с 2 на 15, то мы может это сделать, напрямую обратившись к элементу списка.
С кортежем мы не можем производить такие операции, т.к. элементы его изменять нельзя.
Зачем нужны кортежи в Python?
Существует несколько причин, по которым стоит использовать кортежи вместо списков. Одна из них – это обезопасить данные от случайного изменения. Если мы получили откуда-то массив данных, и у нас есть желание поработать с ним, но при этом непосредственно менять данные мы не собираемся, тогда, это как раз тот случай, когда кортежи придутся как нельзя кстати. Используя их в данной задаче, мы дополнительно получаем сразу несколько бонусов – во-первых, это экономия места. Дело в том, что кортежи в памяти занимают меньший объем по сравнению со списками.
Во-вторых – прирост производительности, который связан с тем, что кортежи работают быстрее, чем списки (т.е. на операции перебора элементов и т.п. будет тратиться меньше времени). Важно также отметить, что кортежи можно использовать в качестве ключа у словаря.
Создание, удаление кортежей и работа с его элементами
Создание кортежей
Для создания пустого кортежа можно воспользоваться одной из следующих команд.
Кортеж с заданным содержанием создается также как список, только вместо квадратных скобок используются круглые.
При желании можно воспользоваться функцией tuple().
Доступ к элементам кортежа
Доступ к элементам кортежа осуществляется также как к элементам списка – через указание индекса. Но, как уже было сказано – изменять элементы кортежа нельзя!
Удаление кортежей
Удалить отдельные элементы из кортежа невозможно.
Но можно удалить кортеж целиком.
Преобразование кортежа в список и обратно
На базе кортежа можно создать список, верно и обратное утверждение. Для превращения списка в кортеж достаточно передать его в качестве аргумента функции tuple().
Обратная операция также является корректной.
P.S.
Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”. 
Python. Урок 8. Кортежи (tuple) : 5 комментариев
Сорян за глупый вопрос, но я только начинаю изучать Python.
И так, есть два или более кортежей и нужно найти элементы, общие для этих кортежей, т е. взять пересечение множеств. Существует ли в питоне для этого оператор (функция, метод, …) или нужно самому “городить” такую функцию? Или может есть какая-нибудь подключаемая библиотека с такой функцией?
Добрый день!
Если вы хотите выполнять операции пересечения и т.п. лучше для этих целей использовать тип данных не кортеж (tuple), а множество (set)
Смотри, t1 = (1,2,3)
t2 = (2,3,4)
print (tuple(set(t1)|set(t2)) это объединение НО set удаляет повторящафся элементы & это перечение
Есть какая то возможность сформировать кортеж для последующего использования в качестве строки аргументов функции?
def f( f, a, b):
print(f, a, b)
opt = tuple( (some_a, 2, lst_arg) )
f(opt)
Пока нарываюсь на ошибку:
TypeError: f() missing 2 required positional arguments: ‘a’ and ‘b’
Буду очень признателен за ответ!