Предыдущий урок: Списки (list)
Кортеж — это упорядоченная последовательность, неизменяемая. В Python кортежи пишутся в круглых скобках.
Создание кортежа:
thistuple = ("помидор", "огурец", "лук")
print(thistuple)
Вывод:
('помидор', 'огурец', 'лук')
Доступ к элементам кортежа
Вы можете получить доступ к элементам кортежа с помощью индекса.
Вывести элемент с индексом 1:
thistuple = ("помидор", "огурец", "лук")
print(thistuple[1])
Вывод:
огурец
Изменить элемент корежа
После создания кортежа вы не можете вносить изменения в него. Кортеж — неизменяемый.
thistuple = ("помидор", "огурец", "лук")
thistuple[1] = "морковка"
Вывод:
Traceback (most recent call last):
File "", line 1, in
thistuple[1] = "морковка"
TypeError: 'tuple' object does not support item assignment
Итерация по кортежу
Вы можете перебирать элементы кортежа с помощью цикла for
.
thistuple = ("помидор", "огурец", "лук")
for x in thistuple:
print(x)
Вывод:
помидор
огурец
лук
Узнать больше о цикле for
вы можете в разделе Python цикл For.
Длина кортежа
Для определения количества элементов списка, используйте метод len()
.
Выведите количество элементов в кортеже:
thistuple = ("помидор", "огурец", "лук")
print(len(thistuple))
Вывод:
3
Добавление элементов
После создания кортежа, вы не можете добавлять в него элементы. Кортеж — неизменяемый.
thistuple = ("помидор", "огурец", "лук")
thistuple[3] = "морковка"
Вывод:
Traceback (most recent call last):
File "", line 1, in
thistuple[3] = "морковка"
TypeError: 'tuple' object does not support item assignment
Удаление элементов
Вы не можете удалять элементы по отдельности, но вы можете полностью удалить кортеж:
Ключевое слово del
может полностью удалить кортеж:
thistuple = ("помидор", "огурец", "лук")
del thistuple
print(thistuple) # эта команда вызовет ошибку, так как thistuple больше не существует
Конструктор tuple()
Так же конструктор tuple()
можно использовать для создания кортежа.
thistuple = tuple(("помидор", "огурец", "лук")) # Обратите внимание на двойные круглые скобки
print(thistuple)
Методы кортежа
В Python так же существуют два встроенных метода, которые вы можете использовать при работе.
Метод | Значение |
---|---|
count() | Возвращает количество раз, которое указанный элемент встречается в кортеже |
index() | Ищет кортеж по указанному значению и возвращает его индекс |
Далее: Множества (set)
Обучение с трудоустройством
Содержание:развернуть
- Примеры кортежей
- Зачем использовать кортеж вместо списка?
- Работа с кортежами
-
Создание
-
Упаковка
-
Распаковка
-
Обращение к элементу и поиск в кортеже
-
Сравнение
-
Перебор
-
Сортировка
-
Удаление
- Методы и особые операции
-
Срез
-
Длина кортежа
-
Конкатенация
-
Повторение
-
Индекс заданного элемента
-
Число вхождений элемента
- Преобразование
-
tuple → str
-
tuple → list
-
tuple → dict
- Именованные кортежи
- Tuple index out of range
Кортеж (tuple) — ещё один вид последовательностей в Python.
По своей природе они очень схожи со списками, но, в отличие от последних, являются неизменяемыми.
# кортеж
immutable_tuple = (4, 5, 6)
immutable_tuple[0] = 404
>
Traceback (most recent call last):
immutable_tuple[0] = 404
TypeError: 'tuple' object does not support item assignment# список
mutable_list = [7, 8, 9]
mutable_list[0] = 1
print(mutable_list)
> [1, 8, 9]
Как видно, в литеральной форме кортеж python 3 записывается в виде последовательности элементов в круглых скобках, в то время как для списков характерны квадратные.
👉 Некоторые особенности кортежей:
- они упорядочены по позициям;
- tuple могут хранить и содержать внутри себя объекты любых типов (и даже составных);
- доступ к элементам происходит по смещению, а не по ключу;
- в рамках этой структуры данных определены все операции, основанные на применении смещения (индексирование, срез);
- кортежи поддерживают неограниченное количество уровней вложенности;
- кортежи хранят указатели на другие объекты, а значит их можно представлять, как массивы ссылок;
- они позволяют очень просто менять местами значения двух переменных.
x = 100
y = 200
x, y = y, x
print(x)
> 200
print(y)
> 100
Примеры кортежей
# пустой кортеж
empty_tuple = ()
# кортеж из 4-х элементов разных типов
four_el_tuple = (36.6, 'Normal', None, False)
# пример tuple, что содержит вложенные элементы
nested_elem_tuple = (('one', 'two'), ['three', 'four'], {'five': 'six'}, (('seven', 'eight'), ('nine', 'ten')))
print(nested_elem_tuple)
> (('one', 'two'), ['three', 'four'], {'five': 'six'}, (('seven', 'eight'), ('nine', 'ten')))
Зачем использовать кортеж вместо списка?
Тем, кто уже успел познакомиться со списками в Python, может показаться не очевидным смысл использования кортежей. Ведь фактически, списки могут делать всё то же самое и даже больше. Это вполне естественный вопрос, но, разумеется, у создателей языка найдётся на него ответ:
- Неизменяемость — именно это свойство кортежей, порой, может выгодно отличать их от списков.
- Скорость — кортежи быстрее работают. По причине неизменяемости кортежи хранятся в памяти особым образом, поэтому операции с их элементами выполняются заведомо быстрее, чем с компонентами списка.
- Безопасность — неизменяемость также позволяет им быть идеальными кандидатами на роль констант. Константы, заданные кортежами, позволяют сделать код более читаемым и безопасным.
- Использование tuple в других структурах данных — кортежи применимы в отдельных структурах данных, от которых python требует неизменяемых значений. Например ключи словарей (dicts) должны состоять исключительно из данных immutable-типа.
💡 Кроме того, кортежи удобно использовать, когда необходимо вернуть из функции несколько значений:
def get_status(service_name):
return None, f"service {service_name} is OK!"
print(type(get_status('nginx')))
> <class 'tuple'>
error, message = get_status('nginx')
print(error)
print(message)
> None
> service nginx is OK!
Работа с кортежами
Создание
Как и другие коллекции языка Питон, кортеж можно создать двумя способами.
Способ №1: Литеральное объявление:
literal_creation = ('any', 'object')
print(literal_creation)
> ('any', 'object')
print(type(literal_creation))
> <class 'tuple'>
Способ №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))
> <class 'tuple'>
💁♀️ Важно, чтобы аргумент, передаваемый в tuple()
был итерируемым объектом:
incorrect_creation = tuple(777)
>
Traceback (most recent call last):
incorrect_creation = tuple(777)
TypeError: 'int' object is not iterable
Упаковка
Упаковкой кортежа называют присваивание его какой-то переменной, что, по сути, совпадает с операцией объявления.
Стоит обратить внимание 2 момента:
- Выражения
some_tuple = (11, 12, 13)
иsome_tuple = 11, 12, 13
тождественны. - Для объявления кортежа, включающего один единственный элемент, нужно использовать завершающую запятую:
is_tuple = ('a',)
is_tuple_too = 'b',
not_a_tuple = 'c'
print(type(is_tuple))
print(type(is_tuple_too))
print(type(not_a_tuple))
> <class 'tuple'>
> <class 'tuple'>
> <class 'str'>
Распаковка
Обратная операция, смысл которой в том, чтобы присвоить значения элементов кортежа отдельным переменным.
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
Обращение к элементу и поиск в кортеже
Обратиться к элементу кортежа можно по номеру его позиции. Причём как с начала, так и с конца:
# Mike - [0], Leo - [1], Don - [2], Raph - [3]
turtles = ('Mike', 'Leo', 'Don', 'Raph')
# Mike - [-4], Leo - [-3], Don - [-2], Raph - [-1]
print(turtles[1])
print(turtles[-2])
print(turtles[2] == turtles[-2])
> Leo
> Don
> True
Если элемент кортежа есть вложенный кортеж, то применяются дополнительные квадратные скобки (в зависимости от уровня вложенности). Например, чтобы обратиться ко второму элементу второго элемента, следует поступить так:
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
Сравнение
tuple_A = 2 * 2,
tuple_B = 2 * 2 * 2,
tuple_C = 'a',
tuple_D = 'z',
tuple_E = (42, 'maximum')
tuple_F = (42, 'minimum')
tuple_Z = 999,
# при сравнении кортежей, числа сравниваются по значению
print(tuple_A < tuple_B)
> True
# строки в лексикографическом порядке
print(tuple_C < tuple_D)
> True
# при равенстве элементов на одинаковых позициях, сравниваются элементы на следующих
print(tuple_E < tuple_F)
> True
# сравнение элементов продолжается до первого неравенства
print(tuple_Z < tuple_F)
> 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
Методы и особые операции
Срез
Слайсы кортежей предельно похожи на таковые у строк, а выглядят они следующим образом:
tuple[start:fin:step]
Где start
— начальный элемент среза (включительно), fin
— конечный (не включительно) и step
— “шаг” среза.
float_tuple = (1.1, 0.5, 45.5, 33.33, 9.12, 3.14, 2.73)
print(float_tuple[0:3])
> (1.1, 0.5, 45.5)
# тождественная запись
print(float_tuple[:3])
> (1.1, 0.5, 45.5)
# если не указывать конечное значение, будут выведены все элементы до конца
print(float_tuple[0:])
> (1.1, 0.5, 45.5, 33.33, 9.12, 3.14, 2.73)
# не указывать начальное - с начала
print(float_tuple[:])
> (1.1, 0.5, 45.5, 33.33, 9.12, 3.14, 2.73)
# выведем элементы с шагом 2
print(float_tuple[-7::2])
> (1.1, 45.5, 9.12, 2.73)
# отрицательный шаг позволит вывести tuple в обратном порядке
print(float_tuple[::-1])
> (2.73, 3.14, 9.12, 33.33, 45.5, 0.5, 1.1)
Длина кортежа
Используя функцию len()
, получаем длину/количество элементов:
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 → str
Представляем вашему вниманию лёгкий способ преобразовать кортеж в строку при помощи метода join()
:
game_name = ('Breath', ' ', 'of', ' ', 'the', ' ', 'Wild')
game_name = ''.join(game_name)
print(game_name)
> Breath of the Wild
tuple → 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 → dict
А вот для преобразования кортежа в словарь придётся применить небольшую хитрость, а именно — генератор словарей:
score = (('Eric', 65000), ('Stephany', 87000))
score_dict = dict((x, y) for x, y in score)
print(score_dict)
> {'Eric': 65000, 'Stephany': 87000}
Именованные кортежи
Мощная особенность и настоящая гордость языка.
Именованный кортеж (или 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.
Кортежи весьма похожи на списки, но очень сложно спорить с тем, что гибкость и функционал последних намного выше. Поэтому, при написании программ, следует, в основном, пользоваться ими, а не кортежами.
Improve Article
Save Article
Like Article
Improve Article
Save Article
Like Article
While working with tuples many times we need to find the length of the tuple, and, instead of counting the number of elements with loops, we can also use Python len(). We will learn about the len() method used for tuples in Python.
Python tuple len() Method
Syntax: len(object)
Parameters:
- object: Any iterable like Tuple, List, etc.
Return type: the number of elements in the tuple.
Example
Tuple =( 1, 0, 4, 2, 5, 6, 7, 5)
Input: len(Tuple)
Output: 8
Explanation:
The len() method returns the total number of elements in the given tuple.
Example 1
Here we are finding the length of a particular tuple.
Python3
Tuple
=
(
1
,
3
,
4
,
2
,
5
,
6
)
res
=
len
(
Tuple
)
print
(
'Length of Tuple is'
, res)
Output:
Length of Tuple is 6
Example 2
Here we are finding the number of elements of the tuple that constitutes string elements.
Python3
Tuple
=
(
"Geeks"
,
"For"
,
"Geeks"
,
"GeeksForGeeks"
)
res
=
len
(
Tuple
)
print
(
'Length of Tuple is'
, res)
Output:
Length of Tuple is 4
Example 3
Here we are finding the length of the nested tuples.
Python3
alphabets
=
((
'G'
,
'F'
,
'G'
), (
'g'
,
'f'
,
'g'
),
(
'g'
,
'F'
,
'g'
),
'GfG'
,
'Gfg'
)
res
=
len
(alphabets)
print
(
'Length of Tuple is'
, res)
res_nested
=
len
(alphabets[
0
])
print
(
'Length of nested tuple is'
, res_nested)
Output:
Length of Tuple is 5 Length of nested tuple is 3
Last Updated :
07 Nov, 2022
Like Article
Save Article
Python имеет несколько последовательных типов данных, которые позволяют хранить коллекции данных организованным и эффективным способом. Основные типы последовательностей — это строки, списки, кортежи и объекты диапазонов.
В этой статье вы познакомитесь с основами кортежей Python. Мы покажем вам, как создать кортеж, получить доступ к элементам, распаковать кортеж и многое другое.
Кортежи похожи на списки с основным отличием в том, что списки изменяемы, а кортежи неизменны. Это означает, что кортежи не могут быть изменены после создания.
Кортежи могут хранить как разнородные, так и однородные данные, но обычно используются для хранения коллекций разнородных элементов.
Создание кортежей
Кортежи создаются путем помещения элементов в круглые скобки []
, разделенных запятыми. В них может быть любое количество предметов, которые могут быть разных типов. Вот пример:
colors = ('orange', 'white', 'green')
Кортеж может содержать элементы со смешанными типами данных. Вы также можете объявлять вложенные кортежи, где еще одним из его элементов являются списки, кортежи или словари:
my_tuple = (1, False, ["red", "blue"], ("foo", "bar"))
Круглые скобки без элементов между ними обозначают пустой кортеж:
Чтобы создать кортеж только с одним элементом, вы должны добавить запятую после элемента:
my_tuple = (1)
type(my_tuple)
my_tuple = (1,)
type(my_tuple)
<class 'int'>
<class 'tuple'>
Кортежи также можно создавать с помощью конструктора tuple()
:
colors_list = ['orange', 'white', 'green']
colors_typle = tuple(colors_list)
print(type(colors_typle))
<class 'tuple'>
Другой способ создания кортежа — использовать функцию упаковки кортежа, которая позволяет вам создать кортеж из последовательности объектов, разделенных запятыми:
directions = "North", "South", "East", "West"
print(type(directions))
<class 'tuple'>
Доступ к элементам кортежа
На элемент кортежа можно ссылаться по его индексу. Индексы являются целыми числами и начинаются от 0
до n-1
где n
— количество элементов:
my_tuple = ["a", "b", "c", "d"]
0 1 2 3
В Python индексы указываются в квадратных скобках:
Например, чтобы получить доступ к третьему элементу кортежа, вы должны tuple_name[2]
:
directions = ("North", "South", "East", "West")
directions[2]
'East'
Если вы ссылаетесь на несуществующий индекс, IndexError
исключение IndexError:
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
Для доступа к элементам во вложенном кортеже используйте несколько индексов:
my_tuple = (1, False, ["red", "blue"], ("foo", "bar"))
my_tuple[3][1]
'bar'
Вы также можете получить доступ к элементам кортежа, используя отрицательные индексы. Последний элемент обозначается как -1
, второй последний элемент — как -2
и так далее:
my_tuple = ("a", "b", "c", "d")
-4 -3 -2 -1
directions = ("North", "South", "East", "West")
directions[-2]
'East'
Нарезка кортежей
В Python вы можете разрезать кортеж и другие последовательные типы данных, используя следующую форму:
sequence[start:stop:step]
start
— это индекс, с которого начинается извлечение. Когда используется отрицательный индекс, он указывает смещение от конца кортежа. Если этот аргумент опущен, нарезка начинается с индекса 0.stop
— индекс, до которого следует завершить извлечение; результат не включает элемент «стоп». Когда используется отрицательный индекс, он указывает смещение от конца кортежа. Если этот аргумент опущен или превышает длину кортежа, нарезка выполняется до конца кортежа.step
— необязательный аргумент, указывающий шаг нарезки. Если не указано, по умолчанию используется 1. Если используется отрицательное значение, срез принимает элементы в обратном порядке.
Результатом нарезки кортежа является новый кортеж, содержащий извлеченные элементы.
Следующие формы допустимы в Python:
T[:] # copy whole tuple
T[start:] # slice the tuple starting from the element with index "start" to the end of the tuple.
T[:stop] # slice the tuple starting from the begging up to but not including the element with index "stop".
T[start:stop] # slice the tuple starting from the element with index "start" up to but not including the element with index "stop".
stop"
T[::step] # slice the tuple with a stride of "step"
Ниже приведен пример того, как нарезать кортеж, начиная с элемента с индексом 1 до элемента с индексом 4, но не включая его:
vegetables = ('Potatoes', 'Garlic', 'Celery', 'Carrots', 'Broccoli')
vegetables[1:4]
('Garlic', 'Celery', 'Carrots')
Распаковка кортежей
Распаковка последовательности в функции Python, которая позволяет вам назначать объекты последовательности переменным. Вот пример:
colors = ('orange', 'white', 'green')
a, b, c = colors
print(a)
print(b)
print(c)
Значения элементов кортежа в соответствии с их положением присваиваются переменным слева:
orange
white
green
При распаковке кортежей количество переменных в левом кортеже должно быть таким же, как количество элементов кортежа. В противном случае вы получите исключение ValueError
colors = ('orange', 'white', 'green')
a, b = colors
ValueError: too many values to unpack (expected 2)
Распаковка удобна, когда метод или функция возвращает последовательность объектов:
def square_area_circumference(side_lenght):
return side_lenght * side_lenght, side_lenght * 4
area, circumference = square_area_circumference(5)
print(area)
print(circumference)
25
20
Изменение кортежа
Поскольку кортежи являются неизменяемыми структурами данных, мы не можем обновлять их напрямую. Вы не можете добавлять, изменять, удалять элементы в кортежах.
Если вы попытаетесь изменить элемент кортежа, вы получите исключение TypeError
colors = ("orange", "white", "green")
colors[1] = "blue"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
Элементы изменяемого кортежа могут быть изменены. Например, если кортеж имеет список в качестве одного из его элементов, вы можете обновить элементы списка:
my_tuple = (1, 2, [5, 6, 7])
my_tuple[2][1] = 4
print(my_tuple)
(1, 2, [5, 4, 7])
Длина кортежа
Встроенная len()
возвращает общее количество элементов данного объекта.
Чтобы найти длину кортежа, передайте его в качестве аргумента функции len()
:
Вот пример:
colors = ("orange", "white", "green")
lenght = len(colors)
print(lenght)
3
Итерация по кортежу
Чтобы перебрать все элементы в кортеже, вы можете использовать цикл for
directions = ("North", "South", "East", "West")
for direction in directions:
print(direction)
North
South
East
West
Если вам нужны индексы, в вашем распоряжении есть несколько методов. Наиболее распространенные способы — комбинировать функции range()
и len()
или использовать встроенную функцию enumerate()
В приведенном ниже примере показано, как получить индекс и значение каждого элемента в кортеже:
directions = ("North", "South", "East", "West")
for i in range(len(directions)):
print("Index {} : Value {}".format(i, directions[i]))
Index 0 : Value North
Index 1 : Value South
Index 2 : Value East
Index 3 : Value West
Вместо использования range(len(...))
вы можете использовать enumerate()
для перебора кортежа более питоническим способом:
directions = ("North", "South", "East", "West")
for index, value in enumerate(directions):
print("Index {} : Value {}".format(index, value))
Index 0 : Value North
Index 1 : Value South
Index 2 : Value East
Index 3 : Value West
Проверить, существует ли элемент
Чтобы проверить, существует ли элемент в кортеже, вы можете использовать операторы in
а not in
colors = ("orange", "white", "green")
print("orange" in colors)
Результатом будет True
или False
:
True
Вот еще один пример с использованием оператора if
:
colors = ("orange", "white", "green")
if "blue" not in colors:
print("no")
else:
print("yes")
no
Кортежные методы
Объект кортежа принимает следующие методы:
count(x)
— возвращает количество раз, когда «x» встречается в кортеже.index(x)
— возвращает позицию первого вхождения элемента со значением ‘x’.
Ниже приведен простой пример, показывающий, как использовать эти методы:
my_tuple = ("a", "s", "s", "q", "a", "n")
print(my_tuple.count('a'))
print(my_tuple.index('a'))
2
0
Вывод
В Python кортежи — это неизменяемые последовательности объектов, которые нельзя изменить после создания.
Если у вас есть какие-либо вопросы или отзывы, не стесняйтесь оставлять комментарии.
Функция len() в Python принимает объект в качестве аргумента и возвращает длину этого объекта. Например, функция len() может возвращать количество элементов в списке.
Синтаксис функции len() имеет следующий вид:
len(object)
Функция len()
принимает один аргумент, который может быть:
- последовательностью — строки, байтовые строки, итерируемые последовательности типа списка или кортежа;
- коллекцией — словари, множества, замороженные множества и так далее.
А возвращает len()
количество элементов в объекте, который передан в качестве аргумента.
Если мы не передаем никакого аргумента или аргумент имеет недопустимый тип, это вызовет исключение TypeError
.
Ошибка TypeError возникает, когда тип данных не является коллекцией или последовательностью. Например, логическое значение, int и т. д.
Например:
print(len(False)) print(len(1212))
Результат:
TypeError: object of type 'bool' has no len() TypeError: object of type 'int' has no len()
Давайте найдем количество элементов внутри списка, иными словами — длину списка.
fruits = ['Bananas', 'Apples', 'Mangoes'] # вычисляем длину списка фруктов l = len(fruits) # выводим длину списка на экран print(l) # Результат: # 3
Что собой представляет функция len() в Python?
len()
— это встроенная функция Python, которая принимает объект в качестве аргумента и возвращает его длину. Например, она может возвращать количество элементов в списке Python.
help(len)
Результат:
Help on built-in function len in module builtins: len(obj, /) Return the number of items in an object.
Всякий раз, когда мы используем встроенные и внешние типы данных с функцией len()
, она не производит итерацию по структуре данных. Длина объекта-контейнера хранится как атрибут данного объекта. Значение этого атрибута изменяется каждый раз, когда элементы добавляются или удаляются из структуры данных, и len()
просто возвращает данное значение. Это гарантирует, что функция len() работает быстро и эффективно.
Как применяется функция len()
Использование функции len() со встроенными последовательностями
Последовательность — это объект, содержащий элементы в упорядоченном виде. Списки, кортежи и строки являются основными примерами встроенных последовательностей в Python, а функция len() используется для вычисления длин этих последовательностей.
# Строка с именем name = "Andrew" print(len(name)) # 6 # Список продуктов food_items = ["Pizza", "Burger", "French Fries"] print(len(food_items)) # 3 # Кортеж с координатами coordinates = (51, 24) print(len(coordinates)) # 2 # Пустая строка print(len("")) # 0 # Пустой список print(len([])) # 0 # Пустой кортеж print(len()) # 0
Объяснение кода:
В приведенном выше фрагменте кода, чтобы найти длину строки name
, списка food_items
и кортежа coordinates
, мы используем len()
. Все эти три типа данных являются допустимыми аргументами для функции len()
. Данная функция возвращает целое число, так как подсчитывает количество элементов в объекте, который передается ей в качестве аргумента. Если аргумент является пустой последовательностью, функция len()
возвращает 0
.
Для создания последовательностей в определенном диапазоне мы также можем использовать функцию range()
. Данная функция не хранит свои значения, а генерирует их по мере необходимости. Однако мы можем найти длину такой последовательности при помощи функции len()
.
print(len(range(1, 10))) # Результат: # 9
Объяснение кода:
Этот диапазон чисел включает целые числа от 1 до 9 (10 исключается). Мы можем задавать длину объекта функции range()
, используя ее аргументы start
, stop
и step
.
Использование функции len() со встроенными коллекциями
Коллекции в Python — это типы данных, построенные на базе контейнеров. Это списки, множества, кортежи и словари. Все коллекции имеют определенные характеристики, основанные на их объявлении и использовании в программе. Например, списки объявляются в квадратных скобках. Они изменяемы, хранят повторяющиеся значения, а к их элементам можно обращаться при помощи индексов.
Пример 1. Определение длины коллекции, сгенерированной при помощи модуля random
В данном примере мы сначала используем функцию randint
модуля random
для создания списка случайных целых чисел, а затем применим функцию len()
, чтобы найти количество элементов в коллекции.
import random # Создаем список из 10 случайных чисел nums = [random.randint(1, 10) for _ in range(10)] print(nums) # Создаем множество, которое содержит только уникальные элементы списка unique = set(nums) # Выводим на экран множество и его длину print(unique) print(len(unique))
Результат:
[9, 1, 8, 6, 8, 8, 1, 9, 3, 10] {1, 3, 6, 8, 9, 10} 6
Объяснение кода:
В приведенной выше программе мы сгенерировали список из 10 случайных чисел в диапазоне от 1 до 10, используя представление списков. Результат будет отличаться при каждом новом запуске кода, поскольку мы генерируем случайные числа. В данном случае множество содержит 6 уникальных чисел.
Пример 2. Определение количества элементов в словаре
Словарь — это встроенный тип данных в Python, который используется для хранения элементов в виде пар ключ-значение. Когда мы используем словарь в качестве аргумента для len()
, функция возвращает количество элементов (пар ключ-значение) в словаре.
# Словарь, содержащий продукты питания print(len({"Potato": 10, "Onion": 12, "Tomato": 11})) # Пустой словарь print(len({})) # Результат: # 3 # 0
Объяснение кода:
В выводе первым мы получили число 3
. Это означает, что в словаре с продуктами есть три пары ключ-значение. Как и в случае с последовательностями, функция len()
возвращает 0
, если аргументом является либо пустой словарь, либо пустое множество.
Использование функции len() с другими встроенными типами данных
Типы данных, которые не хранят в себе более одного элемента, не могут использоваться в качестве аргумента для функции len()
.
print(len(False)) print(len(1))
Результат:
TypeError: object of type 'bool' has no len() TypeError: object of type 'int' has no len()
Целочисленные, вещественные, логические и сложные типы являются примерами встроенных типов данных, которые нельзя использовать с функцией len()
. Функция вызывает TypeError, когда в нее передается аргумент недопустимого типа данных.
Использование функции len() со сторонними библиотеками
Мы также можем использовать функцию len()
для объектов из различных сторонних библиотек. В этом разделе мы рассмотрим примеры использования len()
с типами данных из двух популярных библиотек — NumPy и pandas.
Пример 1. Использование функции len() с массивом NumPy
Библиотека NumPy используется для выполнения ресурсоемких задач и является строительным блоком для различных типов данных.
Применив функцию NumPy np.array(), мы можем создать объект типа <np.ndarray>
, используя переданный в качестве аргумента список.
import numpy as np nums = np.array([1, 7, 11, 2, 9, 25]) print(type(nums)) print(len(nums)) # Результат: # <class 'numpy.ndarray'> # 6
Объяснение кода:
Мы создали одномерный массив длины 6
, используя функцию np.array()
, и вычислили его тип и длину, используя функции type()
и len()
соответственно.
Пример 2. Использование функции len() с Pandas DataFrame
Pandas DataFrame — это двумерная структура данных с помеченными осями (строками и столбцами). Данные внутри Pandas DataFrame выровнены табличным образом по строкам и столбцам. Датафреймы (DataFrame) широко используются в машинном обучении, научных вычислениях и многих других областях, связанных с интенсивным использованием данных.
import pandas as pd # Создаем словарь marks = { "Ash": [60, 75, 90], "Gary": [78, 55, 87], "Max": [47, 96, 85], "Tyson": [68, 88, 69], } # Создаем из словаря датафрейм df = pd.DataFrame(marks, index=["Maths", "Physics", "Chemistry"]) print(df) # Выводим на экран длину датафрейма print(len(df)) # Выводим на экран размеры датафрейма print(df.shape)
Результат:
Ash Gary Max Tyson Maths 60 78 47 68 Physics 75 55 96 88 Chemistry 90 87 85 69 3 (3, 4)
Объяснение кода:
Ключи нашего словаря, содержащего отметки, представляют собой строки, являющиеся именами студентов. Значение каждого ключа представляет собой список, в котором хранятся оценки по трем предметам: математике, физике и химии.
При создании датафрейма с использованием этого словаря в качестве аргумента в функции pd.DataFrame()
мы также должны определить индекс, используя список, содержащий три учебных предмета.
Созданный датафрейм содержит три строки и четыре столбца. Функция len()
возвращает количество строк в датафрейме. Pandas DataFrame имеет свойство .shape
, которое можно использовать для вывода количества строк и столбцов датафрейма в кортеже из двух элементов.
Использование функции len() в пользовательских классах
Встроенная в Python функция len()
вызывает в нашем классе метод с именем __len__()
. Такие методы, имеющие двойное подчеркивание в начале и конце имени, называются магическими.
Реализация этого метода позволит вызову len()
работать с нашим классом. Если данный метод не будет реализован, вызов функции len()
завершится ошибкой AttributeError. Встроенная в Python функция len()
вызывает метод .__len__()
своего аргумента.
class Order: def __init__(self, count): self.count = count def __len__(self): return self.count myOrder = Order(7) print(len(myOrder)) # Результат: # 7
Объяснение кода:
В вышеприведенной программе есть класс Order
с атрибутом count
. Мы также реализовали магическую функцию __len__()
, которая возвращает общее количество заказов, переданных ей в качестве аргумента. Далее мы создали экземпляр нашего класса с именем myOrder
, передав в него аргумент count
, равный семи. И при вызове функции len() было возвращено значение данного атрибута.
Заключение
В данной статье мы рассмотрели, как использовать функцию len() в Python для определения количества элементов в последовательностях, коллекциях и сторонних типах данных.
Функция len() принимает объект в качестве аргумента и возвращает длину этого объекта.
Функцию len() можно использовать для:
- встроенных типов данных;
- типов данных из сторонних библиотек (например Numpy или pandas);
- заданных пользователем классов (для этого в классе необходимо реализовать магический метод
__len__()
);
Перевод статьи «len() Function in Python».