Выберите методы которые есть у кортежей

Кортежи в Python

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

X Скрыть Наверх

Python. Введение в программирование

7. Кортежи

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

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

Где используется?

Кортежи — распространенная структура данных для хранения последовательностей в Python.

• .index() — используется для вывода индекса элемента.
• .count() — используется для подсчета количества элементов в кортеже.
• sum() — складывает все элементы кортежа.
• min() — показывает элемент кортежа с наименьшим значением.
• max() — показывает элемент кортежа с максимальным значением.
• len() — показывает количество элементов кортежа.

Рекомендации по работе с кортежами

1. Кортежи создаются с помощью круглых скобок: () ;
2. Элементы внутри кортежей разделяются запятыми;
3. Важно соблюдать особенности синтаксиса, характерные для каждого отдельного типа данных в кортеже — кавычки для строк, числа и булевые значения без кавычек и так далее.

Дальше — кортеж, включающий элементы разных типов:

 
>>> p_tup = ("Лондон", "Пекин", 44, True) 
>>> print(p_tup) 
('Лондон', 'Пекин', 44, True) 

Доступ к элементам: получить элементы кортежа можно с помощью соответствующего индекса в квадратных скобках.
Например, для получения элемента «Лондон» нужно использовать следующий индекс: p_tup[0]
А для 44: p_tup[2]






Последний элемент следующего кортежа — булево True . Доступ к нему мы получаем с помощью функции print .
 
>>> p_tup = ("Лондон", "Пекин", 44, True) 
>>> print(p_tup[3]) 
True 

Пример получения первого элемента кортежа.
 
>>> p_tup = ("Лондон", "Пекин", 44, True) 
>>> print(p_tup[0]) 
'Лондон' 


Обратное индексирование: по аналогии с элементами списка элементы кортежа также можно получить с помощью обратного индексирования. Оно начинается с -1. Это значение указывает на последний элемент.
Так, для получения последнего элемент p_tup нужно писать p_tup[-1] . p_tup[-2] вернет второй элемент с конца и так далее.
Главное отличие кортежей от списков — они неизменяемые. Кортежам нельзя добавлять или удалять элементы.
Поэтому эта структура используется, когда известно, что элементы не будут меняться в процессе работы программы.

 
>>> p_tup = ("Лондон", "Пекин", 44, True) 
>>> print(p_tup[-1]) 
True 

Функция .index()
.index() — полезный метод, используемый для получения индекса конкретного элемента в кортеже.
Посмотрим на примере.
 
>>> p_tup = ("Лондон", "Пекин", 44, True) 
>>> print(p_tup.index("Лондон")) 
0 

Функция .count()
Метод .count() подходит для определения количества вхождений определенного элемента в кортеже.






В примере ниже можно увидеть, что считается количество вхождений числа 101 в списке p_cup . Результат — 2.
 
>>> p_tup = (5, 101, 42, 3, 101) 
>>> print(p_tup.count(101)) 
2 

Функция sum()
Функция sum() возвращает общую сумму чисел внутри кортежа.
 
>>> lucky_numbers = (5, 55, 4, 3, 101, 42) 
>>> print(sum(lucky_numbers)) 
210 

Функция min()
Функция min() вернет элемент с самым маленьким значением в кортеже.
 
>>> lucky_numbers = (5, 55, 4, 3, 101, 42) 
>>> print(min(lucky_numbers)) 
5 

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






 
>>> lucky_numbers = (5, 55, 4, 3, 101, 42) 
>>> print(max(lucky_numbers)) 
101 

Задачи к уроку
Попробуйте решить задачи к этому уроку для закрепления знаний.
1. Создайте кортеж с цифрами от 0 до 9 и посчитайте сумму.
# данный код numbers = print(sum(numbers)) # требуемый вывод: # 45
2. Введите статистику частотности букв в кортеже.
# данный код long_word = ( 'т', 'т', 'а', 'и', 'и', 'а', 'и', 'и', 'и', 'т', 'т', 'а', 'и', 'и', 'и', 'и', 'и', 'т', 'и' ) print("Количество 'т':", ) print("Количество 'a':", ) print("Количество 'и':", ) # требуемый вывод: # Колличество 'т': 5 # Колличество 'а': 3 # Колличество 'и': 11

Допишите скрипт для расчета средней температуры. 
Постарайтесь посчитать количество дней на основе week_temp . Так наш скрипт сможет работать с данными за любой период.

# данный код week_temp = (26, 29, 34, 32, 28, 26, 23) sum_temp = days = mean_temp = sum_temp / days print(int(mean_temp)) # требуемый вывод: # 28
Тест по кортежам
Пройдите тест к этому уроку для проверки знаний. В тесте 5 вопросов, количество попыток неограниченно.
Типы кортежей (справочник по C#)
Функция кортежей предоставляет краткий синтаксис для группировки нескольких элементов данных в упрощенной структуре данных. В следующем примере показано, как можно объявить переменную кортежа, инициализировать ее и получить доступ к ее элементам данных.






(double, int) t1 = (4.5, 3); Console.WriteLine($"Tuple with elements and ."); // Output: // Tuple with elements 4.5 and 3. (double Sum, int Count) t2 = (4.5, 3); Console.WriteLine($"Sum of elements is ."); // Output: // Sum of 3 elements is 4.5. 
Как показано в предыдущем примере, для определения типа кортежа необходимо указать типы всех его элементов данных и, при необходимости, имена полей. Невозможно определить методы в типе кортежа, но можно использовать методы, предоставляемые .NET, как показано в следующем примере:
(double, int) t = (4.5, 3); Console.WriteLine(t.ToString()); Console.WriteLine($"Hash code of is ."); // Output: // (4.5, 3) // Hash code of (4.5, 3) is 718460086. 
Типы кортежей поддерживают операторы == равенства и != . Дополнительные сведения см. в разделе Равенство кортежей.
Типы кортежей являются типами значений, а элементы кортежа — общедоступными полями. Поэтому кортежи представляют собой изменяемые типы значений.
Можно определить кортежи со сколь угодно большим числом элементов.
var t = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26); Console.WriteLine(t.Item26); // output: 26 
Варианты использования кортежей
Чаще всего кортежи используются как возвращаемый методом тип. То есть вместо определения параметров метода out можно сгруппировать результаты метода в возвращаемый тип кортежа, как показано в следующем примере.






int[] xs = [4, 7, 9]; var limits = FindMinMax(xs); Console.WriteLine($"Limits of [] are and "); // Output: // Limits of [4 7 9] are 4 and 9 int[] ys = [-9, 0, 67, 100]; var (minimum, maximum) = FindMinMax(ys); Console.WriteLine($"Limits of [] are and "); // Output: // Limits of [-9 0 67 100] are -9 and 100 (int min, int max) FindMinMax(int[] input) < if (input is null || input.Length == 0) < throw new ArgumentException("Cannot find minimum and maximum of a null or empty array."); >// Initialize min to MaxValue so every value in the input // is less than this initial value. var min = int.MaxValue; // Initialize max to MinValue so every value in the input // is greater than this initial value. var max = int.MinValue; foreach (var i in input) < if (i < min) < min = i; >if (i > max) < max = i; >> return (min, max); > 
Как показано в предыдущем примере, с возвращаемым экземпляром кортежа можно работать напрямую или деконструировать его в отдельные переменные.
Типы кортежей можно также использовать вместо анонимных типов, например в запросах LINQ. Дополнительные сведения см. в статье Выбор между анонимными типами и кортежами.
Как правило, кортежи используются для группирования слабо связанных элементов данных. В общедоступных API рекомендуется определить класс или тип структуры .
Имена полей кортежей
Вы явно указываете имена полей кортежей в выражении инициализации кортежа или в определении типа кортежа, как показано в следующем примере:
var t = (Sum: 4.5, Count: 3); Console.WriteLine($"Sum of elements is ."); (double Sum, int Count) d = (4.5, 3); Console.WriteLine($"Sum of elements is ."); 
Если имя поля не указано, оно может быть выведено из имени соответствующей переменной в выражении инициализации кортежа, как показано в следующем примере:






var sum = 4.5; var count = 3; var t = (sum, count); Console.WriteLine($"Sum of elements is ."); 
Это называется инициализаторами проекции кортежей. Имя переменной не проецируется на имя поля кортежа в следующих случаях:

Имя кандидата — это имя элемента типа кортежа, например Item3 , ToString или Rest .
Имя кандидата является дубликатом другого имени поля кортежа, явного или неявного.

В предыдущих случаях можно явно указать имя поля или получить доступ к полю по умолчанию.
По умолчанию поля кортежа имеют имена Item1 , Item2 , Item3 и т. д. Всегда можно использовать имя поля по умолчанию, даже если имя поля указано явно или является выводимым, как показано в следующем примере.
var a = 1; var t = (a, b: 2, 3); Console.WriteLine($"The 1st element is (same as )."); Console.WriteLine($"The 2nd element is (same as )."); Console.WriteLine($"The 3rd element is ."); // Output: // The 1st element is 1 (same as 1). // The 2nd element is 2 (same as 2). // The 3rd element is 3. 
Во время компиляции компилятор заменяет имена полей не по умолчанию соответствующими именами по умолчанию. В результате явно указанные или выводимые имена полей будут недоступны во время выполнения.
Включите правило стиля кода .NET IDE0037 , чтобы задать предпочтения для выводимых или явных имен полей кортежей.






Начиная с C# 12, можно указать псевдоним для типа кортежа с директивой using . В следующем примере добавляется global using псевдоним для типа кортежа с двумя целыми значениями допустимого Min и Max значения:
global using BandPass = (int Min, int Max); 
После объявления псевдонима можно использовать BandPass имя в качестве псевдонима для этого типа кортежа:
BandPass bracket = (40, 100); Console.WriteLine($"The bandpass filter is to "); 
Псевдоним не вводит новый тип, но создает синоним только для существующего типа. Вы можете деконструировать кортеж, объявленный псевдонимом BandPass так же, как и с его базовым типом кортежа:
(int a , int b) = bracket; Console.WriteLine($"The bracket is to "); 
Как и при назначении кортежа или деконструкции, имена элементов кортежа не должны соответствовать; Типы выполняются.






Аналогичным образом можно использовать второй псевдоним с одинаковыми типами arity и членов взаимозаменяемо с исходным псевдонимом. Можно объявить второй псевдоним:
using Range = (int Minimum, int Maximum); 
Кортеж можно назначить Range BandPass кортеже. Как и во всех назначениях кортежей, имена полей не должны совпадать, только типы и arity.
Range r = bracket; Console.WriteLine($"The range is to "); 
Псевдоним для типа кортежа предоставляет более семантические сведения при использовании кортежей. Он не вводит новый тип. Чтобы обеспечить безопасность типов, вместо этого следует объявить позиционный record элемент.
Присваивание и деконструкция кортежей
В C# поддерживается присваивание между типами кортежей, которые соответствуют обоим следующим условиям:

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

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






(int, double) t1 = (17, 3.14); (double First, double Second) t2 = (0.0, 1.0); t2 = t1; Console.WriteLine($": and "); // Output: // t2: 17 and 3.14 (double A, double B) t3 = (2.0, 3.0); t3 = t2; Console.WriteLine($": and "); // Output: // t3: 17 and 3.14 
Оператор присваивания = можно также использовать для деконструкции экземпляра кортежа в отдельные переменные. Это можно сделать различными способами:

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


var t = ("post office", 3.6); var (destination, distance) = t; Console.WriteLine($"Distance to is kilometers."); // Output: // Distance to post office is 3.6 kilometers. 
var t = ("post office", 3.6); (string destination, double distance) = t; Console.WriteLine($"Distance to is kilometers."); // Output: // Distance to post office is 3.6 kilometers. 
var t = ("post office", 3.6); (var destination, double distance) = t; Console.WriteLine($"Distance to is kilometers."); // Output: // Distance to post office is 3.6 kilometers. 
var destination = string.Empty; var distance = 0.0; var t = ("post office", 3.6); (destination, distance) = t; Console.WriteLine($"Distance to is kilometers."); // Output: // Distance to post office is 3.6 kilometers. 
Назначение деконструкционного выражения может включать как существующие переменные, так и переменные, объявленные в объявлении деконструкции.
Вы также можете объединить деконструкцию с сопоставлением шаблонов, чтобы проверить характеристики полей в кортеже. В следующем примере выполняется цикл по нескольким целым числам и выводится число, которое делится на 3. Он деконструирует результат Int32.DivRem кортежа и соответствует Remainder 0:
for (int i = 4; i < 20; i++) < if (Math.DivRem(i, 3) is ( Quotient: var q, Remainder: 0 )) < Console.WriteLine($"is divisible by 3, with quotient "); > > 
Подробнее о деконструкции кортежей с помощью и других типов см. в статье Деконструкция кортежей и других типов.






Равенство кортежей
Типы кортежей == поддерживают операторы и != операторы. Эти операторы сравнивают элементы левого операнда с соответствующими элементами правого операнда в соответствии с порядком расположения элементов кортежа.
(int a, byte b) left = (5, 10); (long a, int b) right = (5, 10); Console.WriteLine(left == right); // output: True Console.WriteLine(left != right); // output: False var t1 = (A: 5, B: 10); var t2 = (B: 5, A: 10); Console.WriteLine(t1 == t2); // output: True Console.WriteLine(t1 != t2); // output: False 
Как показано в предыдущем примере, в операциях == и != не учитываются имена полей кортежей.
Два кортежа сравнимы, если выполнены оба следующих условия:

оба кортежа содержат одинаковое количество элементов. Например, t1 != t2 не компилируется, если t1 и t2 имеют разное количество элементов.
Для каждой позиции кортежа соответствующие элементы из левого и правого операндов кортежа сравниваются с помощью операторов == и != . Например, не компилируется, (1, (2, 3)) == ((1, 2), 3) так как 1 не сравнивается с (1, 2) .

Операторы == и != сравнивают кортежи с сокращенной обработкой. Это значит, что операция останавливается, как только она соответствует паре неравных элементов или достигает конца кортежей. Однако перед любым сравнением все элементы кортежа вычисляются, как показано в следующем примере.
Console.WriteLine((Display(1), Display(2)) == (Display(3), Display(4))); int Display(int s) < Console.WriteLine(s); return s; >// Output: // 1 // 2 // 3 // 4 // False 
Кортежи как параметры вывода
Как правило, вы выполняете рефакторинг метода, имеющего параметры out , в метод, возвращающий кортеж. Однако бывают случаи, когда параметр out может иметь тип кортежа. В следующем примере показано, как работать с кортежами в виде параметров out .






var limitsLookup = new Dictionary() < [2] = (4, 10), [4] = (10, 20), [6] = (0, 23) >; if (limitsLookup.TryGetValue(4, out (int Min, int Max) limits)) < Console.WriteLine($"Found limits: min is , max is "); > // Output: // Found limits: min is 10, max is 20 
Кортежи и System.Tuple
Кортежи C# с типами System.ValueTuple, отличаются от кортежей, представленных типами System.Tuple. Основные различия заключаются в следующем.

Типы System.ValueTuple являются типами значений. Типы System.Tuple являются ссылочными типами.
Типы System.ValueTuple являются изменяемыми. Типы System.Tuple являются неизменяемыми.
Элементами данных типов System.ValueTuple являются поля. Элементами данных типов System.Tuple являются свойства.

Спецификация языка C#
Дополнительные сведения см. в разделе:

Типы кортежей
Операторы равенства кортежей

См. также

справочник по C#
Типы значений
Выбор между анонимными типами и кортежами
System.ValueTuple

Совместная работа с нами на GitHub
Источник этого содержимого можно найти на GitHub, где также можно создавать и просматривать проблемы и запросы на вытягивание. Дополнительные сведения см. в нашем руководстве для участников.
Выберите методы которые есть у кортежей
Кортеж (tuple) — упорядоченная коллекция элементов.
Кортежи очень похожи со спискама(list), за исключением следующих свойств:

Кортежи определяются путем включения элементов в круглые скобки "()" в отличии от списков, где элементы заключаются внутри квадратных скобок "[]";
Кортежи неизменяемы.

Создание кортежа
Первый способ - перечислить внутри круглых скобок элементы через запятую
>>> a = (1, True, 'hello', 5) >>> a (1, True, 'hello', 5) >>> type(a)
Второй способ создания это перечисление нескольких элементов через запятую без скобок. В таком случае все равно создаться кортеж.
>>> a = 1,True,'hello',5 >>> a (1, True, 'hello', 5)
Кортеж получится даже если вы укажите один элемент, но после него поставите запятую
>>> a = 1, >>> a (1,)
Но если вы поставите один элемент без запятой или внутри скобок, это уже будет не кортеж.
>>> a = 1 >>> a 1 >>> b = (5) >>> b 5
Также кортеж можно создать при помощи функции tuple() и передать ей итерируемый объект.
>>> a = tuple([1,2,3]) >>> a (1, 2, 3) >>> b = tuple(range(4)) >>> b (0, 1, 2, 3) >>> c = tuple('hello') >>> c ('h', 'e', 'l', 'l', 'o') >>> d = tuple(1) Traceback (most recent call last): File "", line 1, in d = tuple(1) TypeError: 'int' object is not iterable
В последнем примере мы переделали в функцию tuple() целое числа, и из-за того что оно не являются итерируемой последовательностью возникла ошибка.
Для создания пустого кортежа нужно поставить пару пустых круглых скобок или вызвать функцию tuple() без параметров:
 >>> a = () >>> a () >>> b = tuple() >>> b ()
Операции над кортежами
Нахождение длины
>>> a = (1, 2, 3) >>> len(a) 3 >>> len(()) 0
Сложение (спецление) кортежей
>>> a = (1, 2, 3) >>> b = (4, 5) >>> a+b (1, 2, 3, 4, 5) >>> b+a (4, 5, 1, 2, 3)
Дублирование кортежа
>>> a = (1, 2, 3) >>> a*2 (1, 2, 3, 1, 2, 3)
Нахождение max() и min()
Кортеж должен состоять из однотипных элементов
>>> a = (21, 32, 9, 10, 30) >>> min(a) 9 >>> max(a) 32
Применение функции sum()
>>> a = (21, 32, 9, 10, 30) >>> sum(a)
Проверка вхождения элемента в кортеж
>>> a = (1, 2, 3) >>> 2 in a True >>> 5 in a False >>> 4 not in a True
Обращение по индексу кортежа
>>> a = (1, True, 'hello', 55) >>> a[1] True >>> a[3] 55 >>> a[-2] 'hello'
Срезы индексов кортежа
>>> a = (10, 20, 5, 8, 15, 35) >>> a[1:3] (20, 5) >>> a[2:5] (5, 8, 15)
Кортеж - неизменяемый объект
Элементы кортежа нельзя изменять. При попытке сделать такое изменение выскачит исключение TypeError.
>>> a = (1, True, 'hello', 55) >>> a[3]=100 Traceback (most recent call last): File "", line 1, in a[3]=100 TypeError: 'tuple' object does not support item assignment
Методы кортежа
Метод .index(value[, start[,finish]])
Данный метод принимает обязательный параметр value и возвращает индекс первого элемента слева с таким значением. С помощью необязательных параметров start и finish можно ограничить индексы поиска. В случае если в кортеже нет значения вызывается исключение ValueError.
>>> a = (1, 2, 3, 1, 5) >>> a.index(1) 0 >>> a.index(1,2) 3 >>> a.index(4) Traceback (most recent call last): File "", line 1, in a.index(4) ValueError: tuple.index(x): x not in tuple
Метод .count(value)
Данный метод принимает обязательный параметр value и возвращает количество раз появления значения value в кортеже
>>> a (1, 2, 3, 1, 5) >>> a.count(1) 2 >>> a.count(4) 0
Обход элементов кортежа в цикле for
Обход по значениям элементов
>>> a = (1, True, 'hello', 55) >>> for i in a: print(i) 1 True hello 55
Обход по индексам элементов кортежа
>>> a = (1, True, 'hello', 55) >>> for i in range(len(a)): print(a[i]) 1 True hello 55


Похожие публикации:

Realme share что это за программа
Как выделить текст в ватсапе жирным шрифтом на айфоне
Как узнать имя файла
Что такое protect в яндексе