Общие функции и операторы коллекций

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

Размер коллекции

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

Например, определим количество элементов в множестве:

weapons = ("Меч", "Лук", "Копье")
print(len(weapons)) 
# Вывод: 3

Или количество пар «ключ-значение» в словаре:

characters = {"Аладдин": 18, "Жасмин": 15, "Джафар": 60}
print(len(characters)) 
# Вывод: 3

Максимальный и минимальный элемент коллекции

Функции max() и min() определяют, соответственно, наименьший и наибольший элемент в коллекции.

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

numbers = (21, 23, 100, 24, 25)
print(max(numbers)) 
# Вывод: 100
print(min(numbers)) 
# Вывод: 21

Строки сравниваются лексикографически, то есть символ за символом, основываясь на порядковых номерах символах в Юникоде. При этом заглавные буквы меньше строчных:

tongue_twister = ("Ехал", "Грека", "через", "реку")
print(max(tongue_twister)) 
# Вывод: через
print(min(tongue_twister)) 
# Вывод: Грека

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

poems = ["Ямб", "Хорей", "Дактиль"]
print(max(poems))  # Лексикографическое сравнение
# Вывод: Ямб
print(max(poems, key=len))  # Сравнение по длине строки
# Вывод: Дактиль

Параметр default не указан по умолчанию, и если передать функциям max() или min() пустую коллекцию, то будет вызвано исключение ValueError:

empty_lst = []
print(max(empty_lst))
# Ошибка: ValueError: max() iterable argument is empty

Однако c указанным параметром default эти функции вернут переданное значение:

empty_lst = []
print(max(empty_lst, default=None))
# Вывод: None

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

print(max(1, -1, 10, -10)) 
# Вывод: 10
print(min(10, 11, 12, -100)) 
# Вывод: -100

Следует учитывать, что функции max() и min() ожидают, что все элементы поддерживают сравнение между собой. Попытка сравнить, например, число со строкой или строку со списком приведет к исключению TypeError:

some_values = ["Это строка", 1, "Снова строка", 2]
print(max(some_values)) 
# Ошибка: TypeError: '>' not supported between instances of 'int' and 'str'

Проверка истинности элементов коллекции

Функции any() и all() очень полезны, когда нужно проверить истинность или ложность элементов коллекции. Эти функции неявно применяют функцию bool() к каждому элементу коллекции для того, чтобы получить его логическое значение – True или False. 

Так, если хотя бы один элемент в коллекции является истинным (True), то функция any() тоже возвращает True, и возвращает False. Функция all(), наоборот, проверяет истинность всех элементов коллекции и возвращает True, если все элементы истинны (True). Если хотя бы один элемент ложный (False), то она тоже возвращает False.

Вспомним, что ложными в Python считаются все пустые объекты, ноль любого типа и объект None, а все непустые объекты и ненулевые числа будут истинными:

lst = ["Хлеб", "", "Молоко", "Конфеты"]
print(any(lst))
# Вывод: True
print(all(lst))
# Вывод: False

numbers = (0, 0.0, None)
print(any(numbers))
# Вывод: False
print(all(numbers))
# Вывод: False

money = {"100 рублей", 1000, 10, 5, "1 юань"}
print(any(money))
# Вывод: True
print(all(money))
# Вывод: True

Работа функции any() похожа на последовательное применение оператора or (логическое «или») между логическими значениями элементов коллекции:

print(any([False, False, True]))
# Вывод: True
print(False or False or True)
# Вывод: True

print(any([False, False, False]))
# Вывод: False
print(False or False or False)
# Вывод: False

А работа функции all() похожа на последовательное применение оператора and (логическое «и»):

print(all([True, True, True]))
# Вывод: True
print(True and True and True)
# Вывод: True

print(all([True, True, False]))
# Вывод: False
print(True and True and False)
# Вывод: False 

Сумма элементов коллекции

Если коллекция состоит из чисел, то функция sum() поможет быстро вычислить их сумму.

Например, посчитаем сумму кортежа или значений словаря:

numbers_tuple = (10, 20, 30)
print(sum(numbers_tuple)) 
# Вывод: 60

numbers_dict = {1: 100, 2: 200, 3: 300}
print(sum(numbers_dict.values())) 
# Вывод: 600

Однако попытка сложить элементы, которые не являются числами (например, строки), приведет к ошибке TypeError:

str_numbers = "0123456789"
print(sum(str_numbers)) 
# Ошибка: TypeError: unsupported operand type(s) for +: 'int' and 'str'

Проверка принадлежности элемента коллекции

Мы уже рассматривали работу операторов сравнения и идентичности, а также логических операторов, которые возвращают True или False в зависимости от условия.

Кроме них в Python существует оператор принадлежности in (с англ. – в). Он возвращает True, если элемент присутствует в коллекции, и False в противном случае:

элемент in коллекция

Например, можно проверить содержит ли строка символ или другую строку:

print("с" in "Сладкая сирень") 
# Вывод: True

print("сирень" in "Сладкая сирень") 
# Вывод: True

Или содержит список или множество какой-либо элемент:

artifacts = ["Рог изобилия", "Бездонный графин", "Волшебная лампа"]
print("Бездонный графин" in artifacts) 
# Вывод: True

witchers = {"Геральт", "Весемир", "Эскель"}
if "Весемир" in witchers:
    print("Весемир доблестно сражался!")
# Вывод: Весемир доблестно сражался!

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

actors = {
    "Генри Кавилл": "Геральт", 
    "Аня Чалотра": "Йеннифэр", 
    "Фрейя Аллан": "Цирилла"
}
print("Генри Кавилл" in actors)  # Ищем среди ключей
# Вывод: True
print("Геральт" in actors.values())  # Ищем среди значений
# Вывод: True

А также проверить наличие пары (ключ, значение) получив их последовательность с помощью метода dict.items():

print(("Генри Кавилл", "Супермен") in actors.items()) 
# Вывод: False

Оператор in может совмещаться с логическим отрицанием (not):

элемент not in коллекция

Тогда проверяется отсутствие элемента в коллекции:

birds = ["Синица", "Снегирь", "Воробей"]
print("Голубь" not in birds) 
# Вывод: True

Распаковка коллекций

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

year, age = 2008, 16

На самом деле множественное присваивание реализуется через кортежи, и здесь происходит распаковка кортежа (2008, 16) в переменные year и age (при создании кортежа обязательна запятая, а не скобки).

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

coordinates = [10, 20, 30]
x, y, z = coordinates
print(f"x = {x}, y = {y}, z = {z}")  
# Вывод: x = 10, y = 20, z = 30

Здесь список coordinates распаковывается в переменные x, y и z в том же порядке, в котором элементы расположены в списке.

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

meals = ["Борщ", "Плов", "Пюре"]
print(*meals)
# Вывод: Борщ Плов Пюре
print(meals)
# Вывод: ['Борщ', 'Плов', 'Пюре']

Или даже создать новый список, просто распаковав другие списки в квадратных скобках:

soups = ["Борщ", "Щи", "Грибной суп"]
salads = ["Оливье", "Крабовый салат"]
menu1 = [*soups, *salads]
print(menu1)
# Вывод: ['Борщ', 'Щи', 'Грибной суп', 'Оливье', 'Крабовый салат'] 
menu2 = [soups, salads]
print(menu2)
# Вывод: [['Борщ', 'Щи', 'Грибной суп'], ['Оливье', 'Крабовый салат']]

Для словаря, представляющего собой набор пар «ключ-значение», оператор * позволяет получить последовательность объектов, являющихся ключами:

menu = {"Борщ": 75, "Куриный суп": 52, "Грибной суп": 67}
print(*menu, sep=" | ")
# Вывод: Борщ | Куриный суп | Грибной суп

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

soup_menu = {"Борщ": 75, "Куриный суп": 52, "Грибной суп": 67}
desserts_menu = {"Эклер": 56, "Шоколадный пончик": 95}
menu = {**soup_menu, **desserts_menu}
print(menu)
# Вывод: {'Борщ': 75, 'Куриный суп': 52, 'Грибной суп': 67, 'Эклер': 56, 'Шоколадный пончик': 95}

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

Упаковка коллекций

Если при множественном присваивании каждому элементу распаковываемой коллекции не соответствует своя переменная (или нам не нужны некоторые значения из этой коллекции), то оператор * может упаковать оставшиеся элементы в список:

first, *middle, last = (1, 2, 3, 4, 5)
print(f"first = {first}, middle = {middle}, last = {last}")
# Вывод: first = 1, middle = [2, 3, 4], last = 5

Оператор * можно использовать только один раз, иначе интерпретатор не поймёт, как распределить элементы. Если же элементов в коллекции недостаточно для создания списка, то создаётся пустой список:

name, *education = ("Матвей",)
print(f"Имя: {name}, образование: {education}")
# Вывод: Имя: Матвей, образование: []

Также если какие-то элементы коллекции не нужны, то их можно проигнорировать с помощью подчеркивания (_):

result = ("град", "дождь", "снег", "молоко")
weather1, *weather2, _ = result
print(f"Сначала был {weather1}, а потом - {weather2}")
# Вывод: Сначала был град, а потом - ['дождь', 'снег']

Здесь пропущен последний элемент списка, так как на его месте вместо переменной для распаковки указан символ _. Так принято обозначать переменные, которые не будут использоваться.

Примеры

Пример 1. Проверка полей формы на заполненность

Форма регистрации на сайте предлагает пользователю заполнить обязательные поля: имя пользователя, электронная почта и пароль, и дополнительные поля: возраст и номер телефона:

form_data = {
    "username": "great_wizard",
    "email": "",
    "password": "qwerty123",
    "age": "",
    "phone_number": ""
}
 
# Создаем списки для проверки
required_values = [form_data["username"], form_data["email"], form_data["password"]]
optional_values = [form_data["age"], form_data.get("phone")]
 
# Проверяем заполнение обязательных полей
all_filled = all(required_values)
print("Спасибо за регистрацию!" if all_filled else "Не все обязательные поля заполнены!")
    
# Проверяем заполнение дополнительных полей
any_filled = any(optional_values)
print("Заполнено хотя бы одно дополнительное поле:", any_filled)

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

Вывод:

Не все обязательные поля заполнены!
Заполнено хотя бы одно дополнительное поле: False

Пример 2. Анализ температурных данных

Программа определяет максимальное, минимальное и среднее значение температуры за неделю:

temperatures = [22.5, 18.3, 25.1, 19.8, 23.4, 27.9, 21.2]

hottest = max(temperatures)  # Максимальная температура
coldest = min(temperatures)  # Минимальная температура
average = sum(temperatures) / len(temperatures)  # Средняя температура

print(f"Максимальная температура: {hottest}°C")
print(f"Минимальная температура: {coldest}°C")
print(f"Средняя температура: {average:.1f}°C")

Вывод:

Максимальная температура: 27.9°C
Минимальная температура: 18.3°C
Средняя температура: 22.6°C

Пример 3. Поиск русских букв в строке

Программа считает количество русских букв в строке, которую ввёл пользователь:

russian_letters = "абвгдеёжзийклмнопрстуфхцчшщъыьэюя"
russian_letters = "абвгдеёжзийклмнопрстуфхцчшщъыьэюя"
text = input("Введите строку для подсчёта русских букв: ")

russian_letters_count = 0
for char in text:
    if char.lower() in russian_letters:
        russian_letters_count += 1
print(f"Количество русских букв: {russian_letters_count}")

Вывод:

Введите строку для подсчёта русских букв: Python - это просто awesome
Количество русских букв: 9

Итоги

• Оператор принадлежности in в конструкции элемент in коллекция возвращает True, если элемент присутствует в коллекции, иначе – False.
• Распаковка – это извлечение элементов из итерируемого объекта (например, списка, кортежа, множества), а упаковка – это объединение элементов в один объект.
• Распакованные элементы могут быть присвоены другим переменным, переданы функции или использоваться для создания новой коллекции.
• Оператор * используется для распаковки и упаковки любых коллекций.
• Оператор ** используется для распаковки словарей.

Задания для самопроверки

1. Дан список numbers = [15, 8, 23, 8, 42, 10]. Вычислите и выведите на экран размер этого списка и сумму всех элементов списка.

numbers = [15, 8, 23, 8, 42, 10]
size = len(numbers)
sum_numbers = sum(numbers)
print(f"Размер списка: {size}. Сумма элементов: {sum_numbers}")
# Вывод: Размер списка: 6. Сумма элементов: 106

2. Дан список grades = [3, 4, 5, 3, 4, None, 5, 5, None]. Проверьте все ли студенты получили какую-то оценку (не None). Результат выведите на экран.

grades = [3, 4, 5, 3, 4, None, 5, 5, None]
all_graded = all(grade is not None for grade in grades)
print(all_graded)
# Вывод: False

3. Дан кортеж fruits = ("Яблоко", "Банан", "апельсин", "киви"). Найдите и выведите на экран лексикографически наибольшее и наименьшее слово в этом кортеже.

fruits = ("Яблоко", "Банан", "апельсин", "киви")
min_fruit = min(fruits)
max_fruit = max(fruits)
print(f"Наименьшее слово: {min_fruit}. Наибольшее слово: {max_fruit}")
# Вывод: Наименьшее слово: Банан. Наибольшее слово: киви

4. Дан словарь prices = {"Авокадо": 200, "Киви": 150, "Голубика": 175}. Проверьте есть ли в словаре пара с ключом "Авокадо" и значением 125. Результат выведите на экран.

prices = {"Авокадо": 200, "Киви": 150, "Голубика": 175}
is_avocado = ("Авокадо", 125) in prices.items()
print(is_avocado)
# Вывод: False

5. Объясните своими словами, что такое распаковка и упаковка коллекций? Чем отличается распаковка словаря от распаковки списка?

6. Запросите у пользователя число n > 1 и после этого запросите на ввод n строк, которые сохраните список. Если этому списку принадлежит строка "Яблоко", то программа выводит строку "Вы любите яблоки", иначе – "Вы не любите яблоки".

n = int(input("Введите число фруктов: "))
fruits_list = [input("Введите фрукт: ") for _ in range(n)]
print("Вы любите яблоки" if "Яблоко" in fruits_list else "Вы не любите яблоки")