Нахождение наибольшего элемента в массиве Python: полное руководство

Поиск наибольшего элемента по ключу (например, в списке словарей)

Функция max() принимает аргумент key, который задаёт функцию, вычисляющую критерий сравнения.

students = [
    {'name': 'Alice', 'grade': 88},
    {'name': 'Bob', 'grade': 95},
    {'name': 'Charlie', 'grade': 72}
]
best_student = max(students, key=lambda s: s['grade'])
print(best_student)  # {'name': 'Bob', 'grade': 95}

{'name': 'Bob', 'grade': 95}

Пояснение: Аргумент key=lambda s: s['grade'] заставляет max() сравнивать значения поля 'grade'. Возвращается сам словарь с максимальной оценкой.

Получение N наибольших элементов с помощью heapq.nlargest

Для извлечения нескольких наибольших элементов (например, топ-3) используется модуль heapq.

import heapq

numbers = [3, 7, 2, 9, 5, 1, 8]
top3 = heapq.nlargest(3, numbers)
print(top3)  # [9, 8, 7]

[9, 8, 7]

Пояснение: nlargest возвращает список из трёх наибольших элементов в порядке убывания. Эффективно даже для больших списков, так как использует кучу.

Поиск наибольшего элемента с фильтрацией (условие)

Можно комбинировать max() с генераторным выражением, чтобы найти максимум среди элементов, удовлетворяющих условию.

numbers = [3, 7, 2, 9, 5, 1, 8]
largest_even = max(num for num in numbers if num % 2 == 0)
print(largest_even)  # 8

8

Пояснение: Генератор передаёт только чётные числа, и среди них max() находит наибольшее. Если ни одно число не удовлетворяет условию, будет ошибка ValueError; можно добавить default.

Поиск наибольшего элемента в двумерном списке (матрице)

Для плоского поиска по всем элементам матрицы можно использовать max() с генератором двойного цикла.

matrix = [
    [1, 8, 3],
    [9, 2, 6],
    [4, 5, 7]
]
max_value = max(max(row) for row in matrix)
print(max_value)  # 9

9

Пояснение: Сначала max(row) для каждой строки находит локальный максимум, затем внешний max выбирает наибольший среди них. Альтернатива: max(max(matrix, key=max)) или генератором всех элементов.

Поиск наибольшего элемента в списке пользовательских объектов (класс)

Если класс имеет переопределённые методы сравнения (__lt__, __gt__), max() работает напрямую. Иначе используйте key.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __lt__(self, other):
        return (self.x + self.y) < (other.x + other.y)

points = [Point(1,2), Point(4,1), Point(0,5)]
largest_point = max(points)
print(largest_point.x, largest_point.y)  # 4 1

4 1

Пояснение: Благодаря __lt__ max() использует определённое нами правило сравнения. В данном случае точка (4,1) имеет сумму 5, (1,2) сумму 3, (0,5) сумму 5, но (4,1) выбран, так как при равенстве используется первый встреченный.

Сравнение производительности методов на большом списке

Для демонстрации различий во времени выполнения можно использовать модуль timeit.

import timeit, random, heapq
from functools import reduce

data = [random.randint(0, 1000000) for _ in range(500000)]

def manual_max(lst):
    if not lst:
        return None
    m = lst[0]
    for x in lst[1:]:
        if x > m:
            m = x
    return m

t_max = timeit.timeit('max(data)', globals=globals(), number=1000)
t_manual = timeit.timeit('manual_max(data)', globals=globals(), number=1000)
t_sort = timeit.timeit('sorted(data)[-1]', globals=globals(), number=1000)
t_reduce = timeit.timeit('reduce(lambda a,b: a if a>b else b, data)', globals=globals(), number=1000)

print(f'max: {t_max:.3f}, manual: {t_manual:.3f}, sort: {t_sort:.3f}, reduce: {t_reduce:.3f}')

Примерный вывод (зависит от системы):
max: 0.051, manual: 0.092, sort: 0.324, reduce: 0.105

Пояснение: Встроенная max() самая быстрая. Ручной перебор немного медленнее. Сортировка проигрывает из-за сложности O(n log n). reduce занимает среднее положение из-за накладных расходов на вызов lambda для каждого элемента.