Как найти два максимальных элемента массива python

JacobM’s answer is absolutely the way to go. However, there are a few things to keep in mind while implementing what he described. Here’s a little play-along-at-home tutorial to guide you through the trickier parts of solving this problem.

If this code is meant for production use, please use one of the more efficient/concise answers listed. This answer is targetted at someone new to programming.

The idea

The idea is simple.

• Keep two variables: largest and second_largest.
• Go through the list.
  • If an item is greater than largest, assign it to largest.
  • If an item is greater than second_largest, but less than largest, assign it to second_largest.

Getting started

Let’s start.

def two_largest(inlist):
    """Return the two largest items in the sequence. The sequence must
    contain at least two items."""
    for item in inlist:
        if item > largest:
            largest = item
        elif largest > item > second_largest:
            second_largest = item
    # Return the results as a tuple
    return largest, second_largest

# If we run this script, it will should find the two largest items and
# print those
if __name__ == "__main__":
    inlist = [3, 2, 1]
    print two_largest(inlist)

Okay, we now have JacobM’s answer as a Python function. What happens when we try to run it?

Traceback (most recent call last):
  File "twol.py", line 10, in <module>
    print two_largest(inlist)
  File "twol.py", line 3, in two_largest
    if item > largest:
UnboundLocalError: local variable 'largest' referenced before assignment

Apparently, we need to set largest before we start the loop. This probably means we should set second_largest too.

Initializing variables

Let’s set largest and second_largest to 0.

def two_largest(inlist):
    """Return the two largest items in the sequence. The sequence must
    contain at least two items."""
    largest = 0 # NEW!
    second_largest = 0 # NEW!
    for item in inlist:
        if item > largest:
            largest = item
        elif largest > item > second_largest:
            second_largest = item
    # Return the results as a tuple
    return largest, second_largest

# If we run this script, it will should find the two largest items and
# print those
if __name__ == "__main__":
    inlist = [3, 2, 1]
    print two_largest(inlist)

Good. Let’s run it.

(3, 2)

Great! Now let’s test with inlist being [1, 2, 3]

    inlist = [1, 2, 3] # CHANGED!

Let’s try it.

(3, 0)

…Uh oh.

Fixing the logic

The largest value (3) seems correct. The second-largest value is completely wrong though. What’s going on?

Let’s work through what the function is doing.

• When we start, largest is 0 and second_largest is also 0.
• The first item in the list we look at is 1, so largest becomes 1.
• The next item is 2, so largest becomes 2.

But what about second_largest?

When we assign a new value to largest, the largest value actually becomes second-largest. We need to show that in the code.

def two_largest(inlist):
    """Return the two largest items in the sequence. The sequence must
    contain at least two items."""
    largest = 0
    second_largest = 0
    for item in inlist:
        if item > largest:
            second_largest = largest # NEW!
            largest = item
        elif largest > item > second_largest:
            second_largest = item
    # Return the results as a tuple
    return largest, second_largest

# If we run this script, it will should find the two largest items and
# print those
if __name__ == "__main__":
    inlist = [1, 2, 3]
    print two_largest(inlist)

Let’s run it.

(3, 2)

Fantastic.

Initializing variables, part 2

Now let’s try it with a list of negative numbers.

    inlist = [-1, -2, -3] # CHANGED!

Let’s run it.

(0, 0)

That’s not right at all. Where did these zeroes come from?

It turns out that the starting values for largest and second_largest were actually larger than all the items in the list. The first thing you might consider is setting largest and second_largest to the lowest values possible in Python. Unfortunately, Python doesn’t have a smallest possible value. That means that, even if you set both of them to -1,000,000,000,000,000,000, you can have a list of values smaller than that.

So what’s the best thing to do? Let’s try setting largest and second_largest to the first and second items in the list. Then, to avoid double-counting any items in the list, we only look at the part of the list after the second item.

def two_largest(inlist):
    """Return the two largest items in the sequence. The sequence must
    contain at least two items."""
    largest = inlist[0] # CHANGED!
    second_largest = inlist[1] # CHANGED!
    # Only look at the part of inlist starting with item 2
    for item in inlist[2:]: # CHANGED!
        if item > largest:
            second_largest = largest
            largest = item
        elif largest > item > second_largest:
            second_largest = item
    # Return the results as a tuple
    return largest, second_largest

# If we run this script, it will should find the two largest items and
# print those
if __name__ == "__main__":
    inlist = [-1, -2, -3]
    print two_largest(inlist)

Let’s run it.

(-1, -2)

Great! Let’s try with another list of negative numbers.

    inlist = [-3, -2, -1] # CHANGED!

Let’s run it.

(-1, -3)

Wait, what?

Initializing variables, part 3

Let’s step through our logic again.

• largest is set to -3
• second_largest is set to -2

Wait right there. Already, this seems wrong. -2 is larger than -3. Is this what caused the problem? Let’s continue.

• largest is set to -1; second_largest is set to the old value of largest, which is -3

Yes, that looks to be the problem. We need to ensure that largest and second_largest are set correctly.

def two_largest(inlist):
    """Return the two largest items in the sequence. The sequence must
    contain at least two items."""
    if inlist[0] > inlist[1]: # NEW
        largest = inlist[0]
        second_largest = inlist[1]
    else: # NEW
        largest = inlist[1] # NEW
        second_largest = inlist[0] # NEW
    # Only look at the part of inlist starting with item 2
    for item in inlist[2:]:
        if item > largest:
            second_largest = largest
            largest = item
        elif largest > item > second_largest:
            second_largest = item
    # Return the results as a tuple
    return largest, second_largest

# If we run this script, it will should find the two largest items and
# print those
if __name__ == "__main__":
    inlist = [-3, -2, -1]
    print two_largest(inlist)

Let’s run it.

(-1, -2)

Excellent.

Conclusion

So here’s the code, nicely commented and formatted. It’s also had all the bugs I could find beaten from it. Enjoy.

However, assuming this really is a homework question, I hope you get some useful experience from seeing an imperfect piece of code slowly improved. I hope some of these techniques will be useful in future programming assignments.

---

Efficiency

Not very efficient. But for most purposes, it should be okay: on my computer (Core 2 Duo), a list of 100 000 items can be processed in 0.27 seconds (using timeit, averaged over 100 runs).

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

В этой статье мы расскажем, как можно найти второе по величине число в списке Python с помощью следующих принципов:

1. Сортировка списка и печать предпоследнего числа списка.
2. Удаление максимального элемента.
3. Нахождение максимального элемента.
4. Перемещение по списку.

Давайте разберем первый подход.

Сортировка списка и печать предпоследнего числа

Следующая программа показывает, как это можно сделать на Python.

Пример –

 
#program to find the second largest number of list 
# declaring the list 
list_val = [20, 30, 40, 25, 10] 
# sorting the list 
list_val.sort() 
#displaying the second last element of the list 
print("The second largest element of the list is:", list_val[-2]) 

Выход:

The second largest element of the list is: 30 

Объяснение –

1. Мы объявили список, из которого хотим изъять второй элемент, начиная с конца списка.
2. После этого мы использовали метод сортировки, чтобы все элементы нашего списка располагались в порядке возрастания.
3. Теперь мы используем отрицательную индексацию, так как второе по величине число будет на предпоследней позиции.

Второй метод – получить второй по величине элемент списка, удалив максимальный элемент.

Давайте посмотрим, как мы можем это сделать.

Удаление максимального элемента

Пример –

 
#program to find the second largest number of list 
 
# declaring the list 
list_val = [20, 30, 40, 25, 10] 
 
# new_list is a set of list1 
res_list = set(list_val) 
 
#removing the maximum element 
res_list.remove(max(res_list)) 
 
#printing the second largest element  
print(max(res_list)) 

Выход:

30 

Объяснение –

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

1. Мы объявили список, из которого хотим изъять второй по величине элемент.
2. После этого мы использовали метод set, чтобы взять все уникальные элементы списка.
3. Теперь мы используем max(), чтобы получить максимальное значение из списка, а затем удаляем его.
4. После этого мы печатаем максимум результирующего списка, который даст нам второе по величине число.

В третьем методе мы будем использовать цикл for и и с его помощью найдем второй максимум из списка.

Нахождение максимального элемента

Пример –

 
# declaring empty list 
list_val = [] 
 
# user provides the number of elements to be added in the list 
num_list = int(input("Enter number of elements in list: ")) 
 
 
for i in range(1, num_list + 1): 
 element = int(input("Enter the elements: ")) 
 list_val.append(element) 
 
 
# sort the list 
list_val.sort() 
 
# print second largest element 
print("Second largest element is:", list_val[-2]) 

Выход:

Enter number of elements in list: 5 
 
Enter the elements: 10 
 
Enter the elements: 20 
 
Enter the elements: 30 
 
Enter the elements: 40 
 
Enter the elements: 50 
The second largest element is: 40 

Объяснение –

1. Мы объявили пустой список, в который будем вставлять элементы.
2. После этого мы просим пользователя предоставить нам количество элементов, которые мы хотели бы добавить в наш список.
3. Используем метод сортировки, чтобы все элементы нашего списка располагались в порядке возрастания.
4. Теперь мы применим отрицательную индексацию, так как второе по величине число будет на второй последней позиции.

Перемещение по списку

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

Следующая программа это проиллюстрирует:

 
def calc_largest(arr): 
 second_largest = arr[0] 
 largest_val = arr[0] 
 for i in range(len(arr)): 
 if arr[i] > largest_val: 
 largest_val = arr[i] 
 
 for i in range(len(arr)): 
 if arr[i] > second_largest and arr[i] != largest_val: 
 second_largest = arr[i] 
 
 return second_largest 
print(calc_largest([20, 30, 40, 25, 10])) 

Выход:

30 

Объяснение –

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

1. Первый шаг – создать функцию, которая проверяет наибольшее число из списка, просматривая его.
2. В следующем цикле for мы снова просматриваем список для поиска наибольшего числа, но на этот раз исключаем предыдущий, так как здесь наша цель – найти вторую по величине функцию.
3. Наконец, мы передаем наш список в функцию.

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