Python heapq.nlargest() and heapq.nsmallest() capacities Examples: Here, we will figure out how to discover N biggest and littlest components?

Here, we figure out how to discover the N biggest and littlest components from the list? Where list and N are given by the client, N might be any value yet not exactly the list length.

### Depiction:

**There are two different ways,**

### 1st, By characterizing a capacity:

## Procedure:

- Characterize the capacity name
**largest_ele**and**smallest_ele**. - Pass two contentions in a capacity
**(l,n)**: l is the list and n is the number of components. - Run the for circle n times
- Tuned in locate the limit of the given list and affix it to another list
- What’s more, in the wake of affixing to another list expel the most extreme component from the list

### By the inbuilt module heapq module:

On the off chance that you are searching for the N littlest or biggest things and N is little contrasted with the general size of the assortment, these capacities give predominant execution.

- Import the heapq module
- Give the list
- Presently utilize the capacity heapq.nlargest(n,l) and heapq.nsmallest(n,l) from the module to locate the biggest and the littlest numbers.

### Python code:

```
# N largest and smallest element in a list
# by function and by the help of heapq module
#function to find n largest element
def largest_ele(l,n):
s=[]
for i in range(n):
s.append(max(l)) #append max of list in a new list
l.remove(max(l)) #remove max of list from the list
print('by largest_ele function: ',s)
#function to find n largest element
def smallest_ele(m,n):
t=[]
for i in range(n):
t.append(min(m))#append min of list in a new list
m.remove(min(m))#remove min of list from the list
print('by smallest_ele function: ',t)
l=[2,4,6,8,10]
m=[0,1,2,3,4,5,6]
n=2
largest_ele(l,n)
smallest_ele(m,n)
# using the inbuilt module function
# heapq.nlargest and heapq.nsmallest
import heapq
nums = [1, 8, 2, 23, 7, -4, 18, 23, 42, 37, 2]
print('BY heapq.nlargest: ',heapq.nlargest(3, nums)) # Prints [42, 37, 23]
print('BY heapq.nsmallest: ',heapq.nsmallest(3, nums)) # Prints [-4, 1, 2]
```

### Output:

```
by largest_ele function: [10, 8]
by smallest_ele function: [0, 1]
BY heapq.nlargest: [42, 37, 23]
BY heapq.nsmallest: [-4, 1, 2]
```

**Note**: The** nlargest()** and** nsmallest()** capacities are generally proper in the event that you are attempting to discover a moderately modest number of things. On the off chance that you are just attempting to locate the single littlest or biggest thing **(N=1)**, it is quicker to utilize** min() **and** max()**.