Как найти максимальное значение последовательности

Чтобы найти индекс наибольшего элемента последовательности, можно использовать встроенную функцию max():

numbers = map(int, iter(input, '0'))
index, max_value = max(enumerate(numbers), key=lambda i_v: i_v[1])
print(index)

Код принимает целые числа от пользователя—одно число на каждой новой строчке, пока не встретится ноль ('0'). Встроенная функция iter(function, end_value) генерирует последовательность, вызывая функцию function() до тех пор пока не встретится end_value.

Встроенная функция map() преобразует строки в числа в данном случае.

Встроенная функция enumerate() генерирует пары индекс, значение. lambda i_v: i_v[1] функция извлекает значение из пары, служа ключём для сравнения, таким образом пары сравниваются по соответствующим значениям.

max() возвращает пару с наибольшим значением.

Использование max() в Питон коде более предпочтительно по сравнению с while-циклом более подходящим для C кода для решения задачи «Поиск наибольшего элемента в последовательности» в Питоне. Старайтесь использовать подходящие идиомы для выбранного языка. Если сама задача неинтересна, а просто ошибку в while-цикле хотите найти, то спрашивайте именно об этом.

using System;

using System.Linq;

using System.Collections.Generic;

public class Employee {

    public int emp_id

    {

        get;

        set;

    }

    public string emp_name

    {

        get;

        set;

    }

    public string emp_gender

    {

        get;

        set;

    }

    public string emp_hire_date

    {

        get;

        set;

    }

    public int emp_salary

    {

        get;

        set;

    }

}

class GFG {

    static public void Main()

    {

        List<Employee> emp = new List<Employee>() {

            new Employee() { emp_id = 209, emp_name = "Anjita", emp_gender = "Female", emp_hire_date = "12/3/2017", emp_salary = 20000 },

                new Employee() { emp_id = 210, emp_name = "Soniya", emp_gender = "Female", emp_hire_date = "22/4/2018", emp_salary = 30000 },

                new Employee() { emp_id = 211, emp_name = "Rohit", emp_gender = "Male", emp_hire_date = "3/5/2016", emp_salary = 40000 },

                new Employee() { emp_id = 212, emp_name = "Supriya", emp_gender = "Female", emp_hire_date = "4/8/2017", emp_salary = 40000 },

                new Employee() { emp_id = 213, emp_name = "Anil", emp_gender = "Male", emp_hire_date = "12/1/2016", emp_salary = 40000 },

                new Employee() { emp_id = 214, emp_name = "Anju", emp_gender = "Female", emp_hire_date = "17/6/2015", emp_salary = 50000 },

        };

        var res = emp.Max(a => a.emp_salary);

        Console.WriteLine("Maximum Salary of the Employee: {0}", res);

    }

}

Находит максимальное значение элемента в последовательности.

Синтаксис:

max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])

Параметры:

• iterable — итерируемый объект,
• key — должна быть функцией (принимает один аргумент), используется для порядка сравнения элементов итерируемого объекта. Функция вычисляется один раз,
• default — значение по умолчанию, если итерируемый объект окажется пустым,
• arg1...argN — позиционный аргумент,
• *args — список позиционных аргументов.

Возвращаемое значение:

• наибольшее значение объекта.

Описание:

Функция max() возвращает наибольшее значение элемента итерируемого объекта или самое большое из двух или более переданных позиционных аргументов.

• Если указан один позиционный аргумент, он должен быть итерируемым объектом (список, кортеж, словарь и т.д.).
• Если в функцию передается два или более позиционных аргумента, возвращается самый большой из них.
• В случае, когда максимальное значение имеют сразу несколько аргументов. Возвращает первый по порядку элемент с максимальным значением. Это согласуется с другими инструментами сохранения стабильности сортировки, такими как sorted(iterable, key=keyfunc, reverse=True)[0] и heapq.nlargest(1, iterable, key=keyfunc)

Аргумент key — функция подобная той, которая используется в дополнительном методе списков list.sort(). Функция принимает один аргумент и используется для упорядочивания элементов.

>>> x = ['4', '11', '6', '31']
# функция `max` сравнивает
# числа как строки
>>> max(x)
'6'

# функция 'key=lambda i: int(i)' применяется
# к каждому элементу списка 'x', преобразуя 
# строки в тип 'int' и теперь функция `max`
# сравнивает элементы списка как числа.
>>> max(x, key=lambda i: int(i))
'31'

# или другое применение функции 'key'
# выбор списка с наибольшей суммой элементов 
>>> max([1,2,3,4], [3,4,5], key=sum)
[3, 4, 5]

Аргумент default по умолчанию указывает объект, который нужно вернуть, если предоставленный итерируемый объект пуст. Если итерация пуста и значение по умолчанию не указано, то возникает ошибка ValueError.

# Значение по умолчанию
>>> max([], default=10)
10

Функция max() сравнивает элементы, используя оператор <. Поэтому, все передаваемые в них значения должны быть сопоставимы друг с другом и одного типа, иначе бросается исключение TypeError

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

>>> x = list('abcdifgh')
>>> max(x)
# 'i'

Изменено в Python 3.8: Аргумент key может быть None.

Примеры поиска максимального значения в последовательности.

• Нахождение самой длинной строки в списке строк;
• Нахождение максимального значения в списке строк, записанных как целые числа;
• Нахождения максимального значения в строке, которая состоит из чисел и строк;
• Определение индекса у максимального значения в списке;
• Выбор максимального значения для ключа или значения в словаре;
• Нахождение списка с наибольшей суммой элементов в списке списков;
• Нахождение списка с наибольшим количеством элементов в списке списков.

# использование позиционных аргументов
>>> max(5, 3, 6, 5, 6)
# 6

# использование в качестве аргумента - список
>>> max([1.2, 1.3, 1.5, 2, 5.52])
# 5.52

# комбинирование позиционных аргументов и списка
# при передаче списка 'x' происходит его распаковка
>>> x = (1.2, 1.3, 1.5, 2, 5.52)
>>> max(5, 3, 5, *x)
# 5,52

Нахождение самой длинной строки в списке строк.

Найдем самую длинную строку. В качестве ключевой функции используем len(). Она посчитает количество символов в строке каждого элемента списка строк, а функция max() выберет максимальное число. Строки можно передать например как позиционные аргументы, так и списком ['Jul', 'John', 'Vicky'], результат будет тот же.

>>> line = ['Jul', 'John', 'Vicky'] 
>>> max(line, key=len)
# 'Vicky'

Нахождение max() в списке строк, записанных как целые числа.

Есть список строк чисел и необходимо найти максимум, как если бы они были целыми числами? Если применить функцию max() к исходному списку «как есть», то она выберет наибольшее значение списка исходя из лексикографической сортировки. Для нахождения максимума, как числа, применим функцию lambda i: int(i) в качестве ключа key, которая «на лету» преобразует элементы списка в целые числа, тогда функция max() выберет то что нам нужно.

>>> x = ['4', '11', '6', '31']
>>> max(x)
# '6'

>>> max(x, key = lambda i: int(i))
# '31'

Нахождения max() в строке, которая состоит из чисел и строк.

Что бы найти максимум в строке, которая состоит из чисел и строк, необходимо сначала разделить исходную строку на список подстрок. Используем приемы, описанные в примерах функции sum():

• по разделителю, например пробелу ' ' или ';' методом строки str.split(),
• вытащить все цифры из исходной строки при помощи функцией re.findall().

Затем в цикле перебрать полученный список и все строки с цифрами преобразовать в соответствующие числовые типы и уже потом применить функцию

# исходная строка
>>> line = '12; 12,5; 14; один; 15.6; два'
# способы преобразования строки в список строк
# 1 способ по разделителю ';'
>>> line.split(';')
# ['12', ' 12,5', ' 14', ' один', ' 15.6', ' два']

# 2 способ по регулярному выражению
>>> import re
>>> match = re.findall(r'[d.?,?]+', line)
>>> list(match)
# ['12', '12,5', '14', '15.6']

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

Задача усложняется тем, что вещественные числа в строках записаны как через запятую, так и через точку. Для необходимых проверок и преобразований определим функцию str_to_num().

>>> def str_to_num(str, chars=['.', ',']):
...     # убираем начальные и конечные пробелы
...     str = str.strip()
...     if (any(char in str for char in chars) and
...         str.replace('.', '').replace(',', '').isdigit()):
...          # если в строке есть точка или запятая и при их замене на ''
...          # строка состоит только из цифр то это тип float 
...         return float(str.replace(',', '.'))
...     elif str.isdigit():
...          # если строка состоит только из цифр то это тип int 
...         return int(str)

# полученный список строк 1-м способом
>>> str_list = ['12', ' 12,5', ' 14', ' один', ' 15.6', ' два']
# новый список чисел, где будем искать максимум
>>> num_list = []
>>> for i in str_list:
...     # применим функцию преобразования строки в число
...     n = str_to_num(i)
...     if n is not None:
...         # если функция возвращает число,
...         #  то добавляем в новый список
...         num_list.append(str_to_num(i))

>>> num_list
# [12, 12.5, 14, 15.6]
>>> max(num_list)
# 15.6

Определение индекса у максимального значения в списке.

Допустим есть список чисел и стоит задача, определить индекс максимального значения в этом списке. Для решения этой задачи необходимо пронумеровать список, т.е. создать кортеж — индекс/число, а затем найти максимум, используя в качестве ключа key=lambda i : i[1].

>>> lst = [1, 5, 3, 6, 9, 7]
# пронумеруем список 
>>> lst_num = list(enumerate(lst, 0))
>>> lst_num
# [(0, 1), (1, 5), (2, 3), (3, 6), (4, 9), (5, 7)]

# найдем максимум (из второго значения кортежей)
>>> t_max = max(lst_num, key=lambda i : i[1])
>>> t_max
# (4, 9)

# индекс максимального значения 
>>> t_max[0]
# 4

Нахождение max() для ключа или значения в словаре dict.

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

# имеем словарь
>>> d = {1: 3, 2: 4, 1: 9, 4: 1}
# преобразуем его в список отображение 
>>> key_val = d.items()
# преобразуем отображение в список
# кортежей (ключ, значение)
>>> key_val_list = list(key_val)
# [(1, 9), (2, 4), (4, 1)]

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

Но если необходимо получить пару (key, value), у которого наибольшее значение имеет значение ключа (второй элемент), то для этого нужно применить лямбда-функцию lambda i : i[1] в качестве аргумента key функции max(), которая укажет, из какого элемента кортежа выбирать наибольшее значение.

# происходит сравнение по 
# первым элементам кортежа 
>>> kv = max(key_val_list)
>>> kv
# (4, 1)

# максимальное значение ключа в словаре
>>> kv[0]
# 4


# меняем порядок сравнения
>>> kv = max(key_val_list, key=lambda i : i[1])
>>> kv
# (1, 9)

# максимальное значение в словаре
>>> kv[1]
# 9

# ключ этого значения в словаре
>>> kv[0]
# 1

# получаем максимальное значение из словаря
>>> d[kv[0]]
# 9

Нахождение списка с наибольшей суммой элементов в списке списков.

Для выполнения данной задачи, используем функцию max(), а в качестве ключевой функции применим встроенную функцию sum().

# исходный список
>>> lst = [[1, 2, 3], [4, 5], [1, 3, 4, 5], [10, 20]]
# выбираем список с наибольшей суммой элементов
>>> max(lst, key=sum)
# [10, 20]

Выбор списка с наибольшим количеством элементов из списка списков.

Для выполнения данной задачи, используем функцию max(), а в качестве ключевой функции применим встроенную функцию len().

# исходный список
>>> lst = [[1, 2, 3], [4, 5], [1, 3, 4, 5], [10, 20]]
# выбираем список с наибольшим количеством элементов
>>> max(lst, key=len)
# [1, 3, 4, 5]

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

Сначала давайте вкратце рассмотрим, что такое список в Python и как найти в нем максимальное значение или просто наибольшее число.

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

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

list1 = ["Виктор", "Артем", "Роман"]
list2 = [16, 78, 32, 67]
list3 = ["яблоко", "манго", 16, "вишня", 3.4]

Далее мы рассмотрим возможные варианты кода на Python, реализующего поиск наибольшего элемента в списке, состоящем из сравниваемых элементов. В наших примерах будут использоваться следующие методы/функции:

1. Встроенная функция max()
2. Метод грубой силы (перебора)
3. Функция reduce()
4. Алгоритм Heap Queue (очередь с приоритетом)
5. Функция sort()
6. Функция sorted()
7. Метод хвостовой рекурсии

№1 Нахождение максимального значения с помощью функции max()

Это самый простой и понятный подход к поиску наибольшего элемента. Функция Python max() возвращает самый большой элемент итерабельного объекта. Ее также можно использовать для поиска максимального значения между двумя или более параметрами.

В приведенном ниже примере список передается функции max в качестве аргумента.

list1 = [3, 2, 8, 5, 10, 6]
max_number = max(list1)
print("Наибольшее число:", max_number)

Наибольшее число: 10

Если элементы списка являются строками, то сначала они упорядочиваются в алфавитном порядке, а затем возвращается наибольшая строка.

list1 = ["Виктор", "Артем", "Роман"]
max_string = max(list1, key=len)
print("Самая длинная строка:", max_string)

Самая длинная строка: Виктор

№2 Поиск максимального значения перебором

Это самая простая реализация, но она немного медленнее, чем функция max(), поскольку мы используем этот алгоритм в цикле.

В примере выше для поиска максимального значения нами была определена функция large(). Она принимает список в качестве единственного аргумента. Для сохранения найденного значения мы используем переменную max_, которой изначально присваивается первый элемент списка. В цикле for каждый элемент сравнивается с этой переменной. Если он больше max_, то мы сохраняем значение этого элемента в нашей переменной. После сравнения со всеми членами списка в max_ гарантировано находится наибольший элемент.

def large(arr): 
    max_ = arr[0]
    for ele in arr:
        if ele > max_:
           max_ = ele
    return max_ 


list1 = [1,4,5,2,6]
result = large(list1)
print(result)  # вернется 6

№3 Нахождение максимального значения с помощью функции reduce()

В функциональных языках reduce() является важной и очень полезной функцией. В Python 3 функция reduce() перенесена в отдельный модуль стандартной библиотеки под названием functools. Это решение было принято, чтобы поощрить разработчиков использовать циклы, так как они более читабельны. Рассмотрим приведенный ниже пример использования reduce() двумя разными способами.

В этом варианте reduce() принимает два параметра. Первый — ключевое слово max, которое означает поиск максимального числа, а второй аргумент — итерабельный объект.

from functools import reduce


list1 = [-1, 3, 7, 99, 0]
print(reduce(max, list1))  # вывод: 99

Другое решение показывает интересную конструкцию с использованием лямбда-функции. Функция reduce() принимает в качестве аргумента лямбда-функцию, а та в свою очередь получает на вход условие и список для проверки максимального значения.

from functools import reduce


list1 = [-1, 3, 7, 99, 0]
print(reduce(lambda x, y: x if x > y else y, list1))  # -> 99

№4 Поиск максимального значения с помощью приоритетной очереди

Heapq — очень полезный модуль для реализации минимальной очереди. Если быть более точным, он предоставляет реализацию алгоритма очереди с приоритетом на основе кучи, известного как heapq. Важным свойством такой кучи является то, что ее наименьший элемент всегда будет корневым элементом. В приведенном примере мы используем функцию heapq.nlargest() для нахождения максимального значения.

import heapq


list1 = [-1, 3, 7, 99, 0]
print(heapq.nlargest(1, list1))  # -> [99]

Приведенный выше пример импортирует модуль heapq и принимает на вход список. Функция принимает n=1 в качестве первого аргумента, так как нам нужно найти одно максимальное значение, а вторым аргументом является наш список.

№5 Нахождение максимального значения с помощью функции sort()

Этот метод использует функцию sort() для поиска наибольшего элемента. Он принимает на вход список значений, затем сортирует его в порядке возрастания и выводит последний элемент списка. Последним элементом в списке является list[-1].

list1 = [10, 20, 4, 45, 99]
list1.sort()
print("Наибольшее число:", list1[-1])

Наибольшее число: 99

№6 Нахождение максимального значения с помощью функции sorted()

Этот метод использует функцию sorted() для поиска наибольшего элемента. В качестве входных данных он принимает список значений. Затем функция sorted() сортирует список в порядке возрастания и выводит наибольшее число.

list1=[1,4,22,41,5,2]
sorted_list = sorted(list1)
result = sorted_list[-1]
print(result)  # -> 41

№7 Поиск максимального значения с помощью хвостовой рекурсии

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

def find_max(arr, max_=None):
    if max_ is None:
        max_ = arr.pop()
    current = arr.pop()
    if current > max_:
        max_ = current
    if arr:
        return find_max(arr, max_)
    return max_


list1=[1,2,3,4,2]
result = find_max(list1)
print(result)  # -> 4

Заключение

В этой статье мы научились находить максимальное значение из заданного списка с помощью нескольких встроенных функций, таких как max(), sort(), reduce(), sorted() и других алгоритмов. Мы написали свои код, чтобы попробовать метод перебора, хвостовой рекурсии и алгоритма приоритетной очереди.