Введение в мир встроенных функций Python (Built-ins)

Добро пожаловать в двенадцатый урок нашего курса 'Python для начинающих: от основ к практике'. На данном этапе вы уже уверенно владеете базовым синтаксисом, понимаете разницу между изменяемыми (mutable) и неизменяемыми (immutable) объектами, а также умеете работать с различными структурами данных: списками, кортежами, словарями и множествами. Однако, признаком перехода разработчика от уровня 'Beginner' к уровню 'Intermediate' является не просто умение решить задачу, а умение решить ее наиболее эффективным, элегантным и быстрым способом. В мире Python это означает следование философии 'Дзена Python' (The Zen of Python), в частности принципам 'Простое лучше, чем сложное' (Simple is better than complex) и 'Должен существовать один — и, желательно, только один — очевидный способ сделать это' (There should be one-- and preferably only one --obvious way to do it).

Очень часто новички, приходящие в Python из языков вроде C++ или Java, начинают писать код, который изобилует сложными многоуровневыми циклами for и while, создают множество промежуточных переменных-счетчиков и вручную реализуют логику поиска максимального элемента, подсчета суммы или сортировки. Это классический антипаттерн, который в сообществе называется 'reinventing the wheel' (изобретение велосипеда) или 'C-style Python' (написание кода на Python в стиле языка C). Проблема такого подхода заключается не только в том, что код становится громоздким, трудночитаемым и сложным для поддержки (поддержки как вами в будущем, так и вашими коллегами при Code Review). Главная проблема кроется в производительности. Python — это интерпретируемый язык с динамической типизацией. Это означает, что каждая итерация цикла for, написанного на чистом Python, требует от интерпретатора CPython (стандартной реализации языка) выполнения множества проверок: определения типа переменной, проверки выхода за границы массива, выделения памяти и так далее. Это создает огромный 'накладной расход' (overhead).

Именно здесь на сцену выходят встроенные функции (built-in functions). Встроенные функции — это набор инструментов, которые всегда доступны в глобальной области видимости Python (вам не нужно ничего импортировать из модуля math или itertools). Такие функции, как len(), sum(), min(), max(), sorted(), any(), all(), enumerate() и zip(), написаны не на самом Python, а на высокооптимизированном языке программирования C. Когда вы вызываете встроенную функцию, вы фактически передаете управление скомпилированному C-коду, который выполняется напрямую процессором в сотни, а иногда и в тысячи раз быстрее, чем аналогичный цикл for в Python. Более того, эти функции используют самые оптимальные алгоритмы. Например, функция sorted() использует гибридный алгоритм сортировки Timsort, который адаптируется к частично отсортированным данным и работает с гарантированной сложностью O(N log N). Изучение встроенных функций — это важнейший шаг в рамках концепции Microlearning и Active Recall, так как понимание этих небольших, но невероятно мощных строительных блоков позволит вам быстро конструировать сложные архитектурные решения. Наша цель в этом уроке — не просто заучить названия функций, а детально разобрать их внутреннее устройство, понять их временную (Time Complexity) и пространственную (Space Complexity) сложность в нотации Big O, а также научиться комбинировать их с генераторами и lambda-выражениями для создания лаконичного 'Pythonic' кода.

Анатомия функции len(): Как Python так быстро считает элементы?

Давайте начнем с самой базовой, но при этом одной из самых интересных встроенных функций — len(). Её назначение предельно просто: она возвращает количество элементов (длину) переданного ей объекта. Вы можете использовать её со строками, списками, кортежами, словарями и множествами. Однако, если бы мы попросили новичка реализовать функцию подсчета элементов списка вручную, он бы написал что-то вроде цикла, в котором инициализируется переменная count = 0, затем происходит итерация по каждому элементу массива с инкрементом count += 1. В информатике такой алгоритм имеет временную сложность O(N), где N — количество элементов. Это означает, что подсчет длины списка из миллиона элементов займет в миллион раз больше времени, чем списка из одного элемента. Но функция len() в Python работает не так. Когда вы вызываете len() для стандартных структур данных, таких как список (list) или словарь (dict), операция выполняется за константное время — O(1). То есть, получение длины списка из миллиарда элементов занимает ровно столько же микросекунд, сколько и для списка из трех элементов. Как это возможно? Это не магия, это грамотная архитектура данных.

Секрет кроется в том, как устроены объекты внутри интерпретатора CPython. Каждый объект в Python (например, список) под капотом представляет собой структуру данных на языке C. Для списков эта структура называется PyVarObject. Внутри этой структуры есть специальное поле — ob_size, которое хранит текущее количество элементов в коллекции. Когда вы добавляете элемент в список с помощью метода .append(), CPython не только размещает новый элемент в памяти, но и мгновенно обновляет значение поля ob_size, прибавляя к нему единицу. Соответственно, когда вы вызываете функцию len(), она вообще не пробегает по элементам списка! Она просто обращается к объекту, смотрит в поле ob_size и мгновенно возвращает это заранее вычисленное число. Именно поэтому использование len() является невероятно эффективным.

Более того, функция len() тесно связана с объектно-ориентированной моделью Python и магическими (dunder - double underscore) методами. Когда интерпретатор видит вызов len(my_object), он на самом деле ищет метод __len__() внутри класса, к которому принадлежит my_object. Если вы создаете свой собственный пользовательский класс (например, класс ShoppingCart — корзина товаров в интернет-магазине) и хотите, чтобы к нему можно было применять функцию len(), вам достаточно определить внутри этого класса метод def __len__(self):, который будет возвращать нужное целочисленное значение (например, количество товаров в корзине). Это отличный пример концепции 'duck typing' (утиной типизации) в Python: 'Если это выглядит как утка и крякает как утка, то это утка'. Если объект реализует метод __len__, Python позволяет вызывать для него len(), независимо от его реального типа. Однако стоит помнить о важных ограничениях. Функция len() обязана возвращать целое неотрицательное число. Если метод __len__ вернет отрицательное число, строку или дробь, интерпретатор мгновенно выбросит исключение TypeError. Также важно знать, что максимальное значение, которое может вернуть len(), ограничено размером типа данных Py_ssize_t в C, что на 64-битных системах составляет огромное число (более 9 квинтиллионов), поэтому в реальной разработке вы вряд ли столкнетесь с этим лимитом, но теоретически он существует.

Функция sum(): Подводные камни сложения чисел и точность вычислений

Двигаемся дальше. Функция sum() — это мощный инструмент для сложения элементов внутри итерируемого объекта (iterable). Самый распространенный сценарий использования — это вычисление суммы элементов списка или кортежа, содержащего числа (целые или с плавающей точкой). Синтаксис функции выглядит следующим образом: sum(iterable, /, start=0). Обратите внимание на параметр start. По умолчанию он равен нулю. Функция работает так: она берет начальное значение (start) и последовательно, слева направо, прибавляет к нему каждый элемент итерируемого объекта. Это очень удобно, если вам нужно прибавить сумму списка к какому-то уже существующему базовому числу. Например, если вы считаете общую стоимость товаров в корзине пользователя, а стоимость доставки фиксированно составляет 500 рублей, вы можете написать total = sum(item_prices, 500). Это избавит вас от необходимости делать отдельную операцию сложения после вызова функции. Это и есть проявление микрообучения (Microlearning) — изучение маленьких, но крайне полезных 'фишек' языка, которые экономят строки кода и улучшают читаемость.

Однако функция sum() скрывает в себе несколько серьезных подводных камней, о которых обязан знать Intermediate-разработчик. Первый подводный камень касается использования sum() для объединения (конкатенации) списков или строк. Технически, так как оператор + перегружен в Python для списков, вы можете написать sum([[1, 2], [3, 4]], []). Параметр start здесь установлен как пустой список, и интерпретатор начнет 'прибавлять' к нему вложенные списки, в результате чего вы получите плоский список [1, 2, 3, 4]. Но делать так категорически не рекомендуется! Почему? Из-за квадратичной алгоритмической сложности O(N^2). Каждый раз, когда Python выполняет операцию list1 + list2, он создает в памяти абсолютно новый список, копируя в него элементы из обоих исходных списков. При множественном сложении это приводит к колоссальным затратам памяти и времени процессора (каждое новое копирование становится все больше и больше). Для уплощения списков (flattening) правильнее использовать itertools.chain или list comprehensions. Что касается строк, то создатели Python намеренно запретили использовать sum() для конкатенации строк. Если вы попытаетесь сделать sum(['hello', 'world'], ''), интерпретатор выдаст ошибку TypeError: sum() can't sum strings [use ''.join(seq) instead]. Разработчики языка явно указывают вам на метод .join(), который реализован на C таким образом, что он сначала подсчитывает общую длину всех строк, выделяет один большой блок памяти нужного размера, и только потом за один проход копирует туда все символы. Это работает невероятно быстро.

Второй, и еще более коварный подводный камень, касается математической точности. Вспомним стандарт IEEE 754, описывающий представление чисел с плавающей точкой (float) в памяти компьютеров. Большинство десятичных дробей не могут быть точно представлены в двоичном коде, что приводит к микроскопическим ошибкам округления. Например, 0.1 + 0.1 + 0.1 в Python не равно 0.3 (оно равно 0.30000000000000004). Если вы используете обычную функцию sum() для сложения длинного массива чисел с плавающей точкой, эти микроскопические погрешности будут накапливаться с каждой итерацией. В результате итоговая сумма может оказаться существенно искаженной, что абсолютно неприемлемо при разработке финансового программного обеспечения, банковских систем или алгоритмов Data Science, где точность критически важна. Как решить эту проблему? Разработчики Python предусмотрели это и создали специализированную функцию в модуле math. Для точного сложения чисел с плавающей точкой всегда используйте функцию math.fsum(iterable). Она отслеживает промежуточные суммы и сохраняет 'остатки' от округлений, минимизируя потери точности. Использование правильного инструмента для правильной задачи — это главный навык, который мы развиваем с помощью проектно-ориентированного подхода (Project-Based Learning). Помните об этих особенностях, и ваш код будет не только работать, но и работать правильно и безопасно.

Поиск крайностей: Глубокое погружение в min() и max()

Функции min() и max() предназначены для поиска наименьшего и наибольшего элемента соответственно. Их базовое применение тривиально: max([1, 5, 3]) вернет 5, а min(10, 20, 5) вернет 5. Обратите внимание на важную синтаксическую особенность: эти функции могут принимать либо один итерируемый объект (список, кортеж, множество), либо несколько аргументов, перечисленных через запятую (в этом случае они работают как функция с переменным количеством аргументов *args, которую мы рассматривали в практических упражнениях). Если вы передадите функции пустой итерируемый объект, например пустой список max([]), Python выбросит исключение ValueError: max() arg is an empty sequence. Это логично, ведь максимального элемента в пустоте не существует. Однако, в реальном программировании часто бывает так, что вы получаете данные из внешнего API или базы данных, и список может оказаться пустым. Чтобы программа не 'упала' с ошибкой, разработчики предусмотрели спасительный параметр default. Если вы напишете max([], default=0), функция безопасно вернет 0, предотвратив сбой (краш) приложения. Это отличная практика защитного программирования (defensive programming).

Но истинная мощь функций min() и max() раскрывается при использовании параметра key. До сих пор мы работали с простыми типами данных — числами. А что, если у нас есть список сложных объектов? Вспомним наше практическое задание из архива: у нас есть список словарей товаров: products = [{"name": "Laptop", "price": 1200}, {"name": "Mouse", "price": 400}]. Если мы просто вызовем max(products), интерпретатор 'сломается' с ошибкой TypeError: '>' not supported between instances of 'dict' and 'dict', потому что Python по умолчанию не знает, как сравнивать два словаря. По какому критерию их сравнивать? По длине названия? По цене? По алфавитному порядку ключей? Интерпретатор отказывается угадывать. Вот тут-то и нужен параметр key. Параметр key принимает функцию (callable-объект). Функция max() перед тем, как сравнить два элемента, пропускает каждый элемент через эту key-функцию и использует возвращаемое значение для реального сравнения. Чаще всего в качестве key используются анонимные lambda-функции.

Давайте разберем это на нашем примере с товарами. Если мы хотим найти самый дорогой товар, мы напишем так: max(products, key=lambda x: x['price']). Как это работает под капотом интерпретатора? Функция max() берет первый словарь (Ноутбук) и передает его в лямбда-функцию. Лямбда возвращает значение по ключу 'price' — число 1200. Затем берется второй словарь (Мышка), лямбда возвращает 400. Затем функция max(), написанная на быстром C, сравнивает эти возвращенные числа (1200 и 400). Так как 1200 больше, max() запоминает первый словарь как текущий максимум. Важно понимать, что хотя сравнение происходит по числам, сама функция max() возвращает оригинальный объект — то есть весь словарь {"name": "Laptop", "price": 1200}. Это фантастически мощный механизм. Вы можете использовать функции из встроенного модуля operator, такие как operator.itemgetter('price') вместо лямбды, что будет работать еще быстрее на C-уровне. Параметр key — это паттерн функционального программирования, который делает ваш код декларативным: вы говорите интерпретатору что вы хотите получить (самый дорогой товар), а не как перебирать элементы циклом и сравнивать переменные.

Магия сортировки: sorted() и алгоритм Timsort

Сортировка данных — одна из самых ресурсоемких и часто встречающихся задач в информатике. В Python для этого предусмотрена встроенная функция sorted(). На уровне Intermediate важно четко понимать разницу между методом списка .sort() и функцией sorted(). Метод list.sort() изменяет список 'на месте' (in-place) и возвращает None. Это экономит память, так как новый объект не создается, но при этом исходный порядок элементов безвозвратно теряется. Метод sort() применим ТОЛЬКО к спискам. Функция же sorted(iterable) работает иначе. Она принимает ЛЮБОЙ итерируемый объект (список, кортеж, множество, словарь, генератор), перебирает его элементы, создает в памяти АБСОЛЮТНО НОВЫЙ список (именно список, даже если на вход подали кортеж), сортирует его и возвращает этот новый отсортированный список. Исходный объект при этом остается нетронутым. Если у вас есть кортеж t = (3, 1, 2), и вы вызовете sorted(t), вернется список [1, 2, 3], а сам кортеж t так и останется (3, 1, 2). Это ключевой принцип работы с неизменяемыми типами данных (Immutable types).

Но что делает sorted() по-настоящему выдающейся, так это алгоритм, который она использует под капотом. В далеком 2002 году разработчик Тим Питерс (кстати, автор 'Дзена Python') создал специально для языка Python новый алгоритм сортировки, который так и назвали — Timsort. Сегодня этот алгоритм настолько хорош, что его заимствовали и используют по умолчанию в Java, Android, Google Chrome (движок V8) и Swift. Timsort — это гибридный стабильный алгоритм, который комбинирует сортировку слиянием (Merge Sort) и сортировку вставками (Insertion Sort). Его главная гениальная особенность заключается в том, что он оптимизирован под реальные данные, а не под случайный шум. В реальном мире данные часто уже частично отсортированы (содержат возрастающие или убывающие последовательности, так называемые 'runs'). Timsort сканирует массив, находит эти 'runs' (серии) и интеллектуально сливает их вместе. Благодаря этому, в лучшем случае (когда данные уже отсортированы или почти отсортированы), алгоритм работает за линейное время O(N) — это фантастическая скорость. В худшем и среднем случае сложность составляет гарантированные O(N log N). Кроме того, Timsort является 'стабильной' (stable) сортировкой. Это означает, что если два элемента равны по критерию сортировки, они сохранят свой первоначальный относительный порядок по отношению друг к другу. Это критически важно при сортировке сложных объектов по нескольким критериям.

Как и min/max, функция sorted() поддерживает параметр key, который работает точно так же: принимает функцию и сортирует элементы на основе того, что эта функция вернет. Также есть логический параметр reverse=True, который позволяет развернуть результат сортировки в обратном порядке (по убыванию). Давайте вспомним упражнение из архивных материалов: Отсортировать список кортежей [(1, 'Z'), (2, 'A'), (3, 'M')] по второму элементу (букве). Решение выглядит изящно: sorted(data, key=lambda x: x[1]). Лямбда-функция 'вытаскивает' второй элемент (индекс 1) каждого кортежа, и Timsort выстраивает элементы в алфавитном порядке этих букв. А что если нам нужно отсортировать данные по двум критериям? Например, сначала по длине слова (по возрастанию), а если длины равны — то по алфавиту? Python позволяет возвращать из lambda-функции кортеж. Сравнение кортежей в Python происходит лексикографически (поэлементно слева направо). Таким образом, sorted(words, key=lambda word: (len(word), word)) решит эту сложную задачу в одну короткую, читаемую и невероятно быструю строку кода. Это и есть настоящее мастерство Python Programming!

Логические вентили коллекций: any() и all()

В программировании часто возникают задачи валидации данных. Например, нужно проверить, все ли поля в заполненной пользователем форме (в веб-разработке) корректны, или есть ли хотя бы один товар в корзине со скидкой. Для таких 'массовых' логических проверок созданы функции any() и all(). Они принимают итерируемый объект и возвращают булево значение (True или False). Чтобы понять, как они работают, необходимо вспомнить концепцию 'Truthiness' (истинности) в Python. В Python любое значение может быть приведено к булевому типу. Число 0, пустая строка "", пустой список [], объект None и само значение False считаются 'ложными' (falsy). Все остальные объекты (непустые строки, числа отличные от нуля, заполненные коллекции) считаются 'истинными' (truthy).

Функция all(iterable) возвращает True, ТОЛЬКО ЕСЛИ ВСЕ элементы переданного объекта являются истинными (truthy). Если хотя бы один элемент ложный, функция мгновенно возвращает False. Важно отметить поведение с пустыми коллекциями: all([]) возвращает True! Это математически логично (vacuous truth - пустая истина), так как в пустом множестве нет ни одного ложного элемента, из-за которого нужно было бы вернуть False. С другой стороны, функция any(iterable) возвращает True, если ХОТЯ БЫ ОДИН элемент является истинным. Если все элементы ложные, она вернет False. Вызов any([]) для пустой коллекции вернет False, так как интерпретатор не смог найти ни одного истинного элемента.

Самая крутая архитектурная особенность any() и all() — это механизм короткого замыкания (short-circuit evaluation). Представьте, что вы передаете в функцию all() список из миллиона элементов, и уже второй элемент в этом списке равен 0 (falsy). Интерпретатор Python, написанный на умном C, не будет проверять оставшиеся 999 998 элементов! Как только он наткнется на первый ложный элемент, он поймет, что условие 'все элементы истинны' уже провалено, немедленно прервет выполнение цикла и вернет False. Это экономит огромное количество ресурсов. Именно поэтому any() и all() идеально сочетаются с выражениями-генераторами (Generator Expressions). В отличие от list comprehensions (которые сначала создают весь список в оперативной памяти), генераторы вычисляют элементы 'на лету' (lazily). Если мы напишем any(x > 100 for x in huge_data_stream), генератор будет 'выплевывать' по одному числу за раз. Как только any() встретит число больше 100, генератор остановится, и остальная часть потока данных даже не будет обрабатываться. Это высший пилотаж работы с памятью и производительностью, который отличает Senior разработчика от Junior.

Индексы и параллельная итерация: enumerate() и zip()

В языках вроде C или Java классический цикл for выглядит как управление счетчиком: for (int i = 0; i < length; i++). Когда разработчики приходят из этих языков в Python, они часто пытаются воспроизвести эту логику, используя конструкцию for i in range(len(my_list)):, а затем обращаясь к элементу по индексу my_list[i]. В сообществе Python это считается одним из самых страшных антипаттернов (bad practice). Цикл for в Python по своей природе является 'for-each' циклом — он предназначен для итерации непосредственно по самим объектам (for item in my_list:), а не по их индексам. Но что делать, если в процессе обработки вам всё же нужен порядковый номер (индекс) элемента? Например, вы выводите на экран нумерованный список товаров. Для элегантного решения этой проблемы существует встроенная функция enumerate().

Функция enumerate(iterable, start=0) принимает итерируемый объект и оборачивает его в генератор. При каждой итерации она 'выплевывает' кортеж (tuple) из двух элементов: текущий индекс (счетчик) и сам элемент из оригинальной коллекции. Используя механизм распаковки кортежей (tuple unpacking), мы можем перехватить эти два значения в переменные прямо в заголовке цикла: for index, item in enumerate(my_list):. Это делает код исключительно читаемым, избавляет от необходимости вручную управлять счетчиком (i += 1) и исключает риск ошибки на единицу (Off-by-one error). Более того, enumerate имеет удобный параметр start. Если вы формируете нумерованный список для пользователя, где отсчет должен начинаться с 1, а не с 0 (как принято у программистов), вы просто пишете enumerate(my_list, start=1).

Другая частая задача — параллельная итерация по нескольким коллекциям. Представьте, что у вас есть список имен пользователей names = ['Alice', 'Bob', 'Charlie'] и отдельный список их возрастов ages = [25, 30, 35]. Как объединить их, чтобы вывести 'Alice is 25 years old'? Использование индексов (names[i] и ages[i]) громоздко и чревато ошибкой IndexError, если списки разной длины. На помощь приходит встроенная функция zip(*iterables). Название 'zip' переводится как 'застежка-молния'. И работает она точно так же: она берет первый элемент из первого списка, первый элемент из второго списка и 'сшивает' их в кортеж ('Alice', 25). Затем переходит ко вторым элементам. Функция zip возвращает итератор (ленивый объект), поэтому она не потребляет лишнюю память. Если передать zip() в конструктор dict(), то из двух списков можно мгновенно создать словарь: ключами станут элементы первого списка, значениями — второго. Важно помнить, что стандартный zip() останавливается, как только заканчивается самая короткая коллекция из переданных. Лишние элементы из длинных коллекций просто отбрасываются. Если вам нужно сохранить данные, вам следует использовать itertools.zip_longest().

Функциональное программирование: map(), filter() и reversed()

Хотя Python является мультипарадигменным языком с сильным уклоном в объектно-ориентированное программирование, он заимствовал множество мощных концепций из функционального программирования. Встроенные функции map() и filter() — яркие тому примеры. Эти функции классифицируются как функции высшего порядка (Higher-Order Functions), так как они принимают в качестве аргумента другие функции.

Функция map(function, iterable) применяет переданную функцию (function) к каждому элементу итерируемого объекта (iterable) и возвращает новый итератор с результатами. Если вам нужно преобразовать список строк с числами в список настоящих целых чисел, вместо написания цикла, вы можете сделать так: list(map(int, ['1', '2', '3'])). Внутренне функция map написана на C, поэтому она выполняет эту трансформацию быстрее, чем обычный цикл for. Однако, с появлением в Python списковых включений (list comprehensions) [int(x) for x in ['1','2','3']], использование map стало предметом холиваров. Создатель Python, Гвидо ван Россум, предпочитает comprehensions за их читаемость. Тем не менее, map остается невероятно полезным, особенно когда вам нужно применить уже существующую (built-in) функцию ко множеству элементов.

Функция filter(function, iterable) работает как сито. Она принимает функцию-предикат (функцию, которая возвращает True или False) и применяет ее к каждому элементу. В результирующий итератор попадают только те элементы, для которых функция вернула True. Вспомним архивное задание 1.1 про фильтрацию товаров. Мы можем отфильтровать список товаров, у которых price > 500, с помощью лямбда-функции: filter(lambda p: p['price'] > 500, products). Огромное преимущество как map, так и filter заключается в их ленивости (lazy evaluation). Они не создают новый список в памяти целиком. Они возвращают итератор, который генерирует и обрабатывает элементы по одному в момент обращения к ним. Если вы фильтруете лог-файл размером в несколько гигабайт, filter() не займет оперативную память, в отличие от генератора списков (list comprehension), который попытается загрузить весь отфильтрованный массив в ОЗУ, что приведет к краху программы (Out of Memory - OOM error). Наконец, функция reversed(seq) — это самый быстрый способ обойти последовательность в обратном порядке. В отличие от среза [::-1], который копирует весь список в памяти задом наперед (создавая глубокую копию массива ссылок), reversed() просто возвращает легковесный итератор, который начинает читать оригинальный объект с конца, не дублируя данные. Опять же, экономия памяти O(1) против O(N) при использовании срезов.

Резюме и архитектурные выводы (Code Review Session)

Мы проделали огромный путь, разобрав внутреннее устройство и особенности применения ключевых встроенных функций для работы с коллекциями. Давайте подведем итоги с точки зрения архитектуры и Code Review. Написание кода на Python (как и на любом другом языке) — это не просто трансляция мыслей в синтаксис. Это проектирование системы, которая должна быть читаемой, масштабируемой и эффективной по потреблению ресурсов. Вспомним диалог из нашего архивного материала, где Senior Developer указывал на ошибку 'Mutable Default Argument' у Junior'а. Подобные ситуации постоянно возникают и при работе с коллекциями. Джуниоры часто пишут избыточный код, пытаясь контролировать каждый шаг исполнения (создают пустые списки, пишут циклы for i in range(len(...)), вручную сравнивают переменные для поиска максимума). Задача Senior'а — направить мысль в русло Pythonic way.

Когда вы видите в своем (или чужом) коде ручной счетчик индекса — заменяйте его на enumerate(). Когда видите одновременную итерацию по индексам нескольких массивов — заменяйте на zip(). Если вам нужно проверить, выполняется ли условие хотя бы для одного элемента в миллионном датасете, никогда не используйте фильтрацию всего списка с последующей проверкой длины (len([x for x in data if condition]) > 0) — это заставит интерпретатор прогнать весь миллион элементов в памяти. Вместо этого используйте ленивую проверку any(condition(x) for x in data), которая завершится за миллисекунды, наткнувшись на первое совпадение. Для сложной кастомной сортировки словарей или объектов классов всегда делегируйте тяжелую работу C-алгоритму Timsort через sorted(data, key=lambda...). И всегда помните про точность вычислений: обычный sum() коварен при работе с float-типами, используйте math.fsum(). Освоив эти 'кирпичики', вы сможете писать код, который работает быстрее, потребляет меньше памяти и вызывает восхищение у коллег. Встроенные функции — это ваша секретная суперсила, предоставленная командой разработчиков ядра CPython. Используйте ее с умом!