Most Used Built-in functions in Python in
Tags: programming, python, beginners, functional
Published: 2021-11-11 17:27:15

In this article we will going to look some very useful built-in functions that will always come handly in your python journey,
these functions will save you writing extra lines of code,

We will going to understand the defination and look some useful use-cases for each built-in function.

We will going to go through the following built-in functions :-

* **map()**
* **filter()**
* **reduce()**
* **zip()**
* **enumerate()**
* **all()**
* **any()**

### 1. *map()*

* map() is a built-in Python function that takes in two or more arguments: a function and one or more iterables, in the form:
**Syntax :- *map(callable, iterable)**

* map() returns an **iterator** - that is, map() returns a special object that yields one result at a time as needed.
if you're not fimiliar with *iterator* :-
refer to this post :- [iterator,iterable in python](https://dev.to/adarshrawat7400/what-is-iterableiterator-in-python-3325)

* for n size of input , it will return n size output

let's see some example of *map()*

**Task :- convert list of string integer to to int**
###Example:-
```
lst_of_str_ints = ['1','2','3','4','5','6','7','8','9','10']
print("list of str ints :- ",lst_of_str_ints)

lst_of_ints = list(map(int, lst_of_str_ints))
print("list of ints :- ",lst_of_ints)

Output :-
list of str ints :-  ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
list of ints :-  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
```

we passed *int* object as first argument in the map function, second argument is the *list_of_str_int*, in this example
the iterator iterate each element at a time and map it to the corresponding callable argument *int()* passed as first argument,
then after iterating over all the elements, the *map()* function returns  a *map* object will can then be *casted* to iterable like 
*(list,tuple,set)*.

we can perform the same task using *lambda function*:-
###Example:-
```
lst_of_str_ints = ['1','2','3','4','5','6','7','8','9','10']
print("list of str ints :- ",lst_of_str_ints)

lst_of_ints = list(map(lambda x:int(x), lst_of_str_ints))
print("list of ints :- ",lst_of_ints)

Output :-
list of str ints :-  ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
list of ints :-  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
```

###Example :-
**Task :- we will convert temprature from celsius to fahrenheit**
```
temps_in_celsius = [0, 22.5, 40, 100]
print("temprature in celsius :-",temps_in_celsius)

temps_in_fahrenheit = list(map(lambda celsius : (9/5)*celsius + 32, temps_in_celsius))
print("temprature in fahrenheit :-",temps_in_fahrenheit)

Output :-
temprature in celsius :- [0, 22.5, 40, 100]
temprature in fahrenheit :- [32.0, 72.5, 104.0, 212.0]

```
In the above example we converted *list of temperature in celsius* to "temprature in fahrenheit"


### Example :-
**Task :- capitalize each name in a list to uppercase**
```
names = ['Ram','Shyam','Abhiansh','Raven','Marcus']
print("Original list :-",names)

upper_cased_names = list(map(lambda x : x.upper(), names))
print("Upper case name :-",upper_cased_names)

Output :-
Original list :- ['Ram', 'Shyam', 'Abhiansh', 'Raven', 'Marcus']
Upper case name :- ['RAM', 'SHYAM', 'ABHIANSH', 'RAVEN', 'MARCUS']
```

### 2. *filter()*

* *filter(function, iterable)( offers a efficient way to filter out all the elements of an iterable, based on if a condition evaluates to treu
**Syntax :- *filter(callable, iterable)**

* It takes first argument as function which evaluates to some boolean condition *(True or False)*, second argument as *iterable* 

* The element will only be included if the function return **

* for n size of input , it will return **n-m** size output
where m is the no. of element for which the function evaluates to *False*

let's see some example of *filter()*
**Task :- fitler ints from a list of object of various type i.e. (float,string,lst,...)**
### Example :-
```
lst = [12, 43.42, 'hello', [1,3,4], 54,92, (1,2), 12.22, 9]
print("Orignal list of object without filteration :- ",lst)

lst_of_ints = list(filter(lambda x:type(x)== int, lst))
print("Updated list of ints  :- ",lst_of_ints)

Output :-
Orignal list of object without filteration :-  [12, 43.42, 'hello', [1, 3, 4], 54, 92, (1, 2), 12.22, 9]
Updated list of ints  :-  [12, 54, 92, 9]
```
In the above example we have filtered *ints* from  a list of objects of different *type*, we used the same approch as in the previous example, but not here we're using a function which evaluates to two condition ,*i.e., if the type of object is int then it returning True, and that element get included in the result list , Otherwise if the type in not int then it returning False , means item will not be included in  the result list*

let's see some other example :-

**Task :- filter even integer from a list of integers**
### Example :-
```
list_of_ints = [1,2,3,4,5,6,7,8,9,10]

print("Orignal list of ints :- ",list_of_ints)

list_of_even_ints = list(filter(lambda x: x % 2 ==0, list_of_ints))
print("Updated list of only even ints  :- ",list_of_even_ints)

Output :- 
Orignal list of ints :-  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Updated list of only even ints  :-  [2, 4, 6, 8, 10]
```
In the above example we filtered list of even integer from a  list of integers.

**Task :- we have a list of random emails, so of which are valid and some are invalid , we have to filter out only valid emails**
### Example :-
```
import re
list_of_emails = ['nullchar@aol.com',
                  'salesgeek@yahoo.com',
                  'luebkehotmail.com',
                  'fmergeslive.com',
                  'jonathan@outlook.com',
                  'lydia@gmail.com',
                  'grdschl@comcast.net',
                  'catalogsbcglobal.net',
                  'glenz@outlook.com',
                  'cumarana@outlook.com',
                  'rsteinericloud.com',
                  'mosses@mac.com']

email_regex = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'

print("Orignal list of emails :- ",list_of_emails,"\n")

valid_emails = list(filter(lambda email:re.match(email_regex, email), list_of_emails))
print("Updated list of valid emails  :- ",valid_emails)

Output :-
Orignal list of emails :-  ['nullchar@aol.com', 'salesgeek@yahoo.com', 'luebkehotmail.com', 'fmergeslive.com', 'jonathan@outlook.com', 'lydia@gmail.com', 'grdschl@comcast.net', 'catalogsbcglobal.net', 'glenz@outlook.com', 'cumarana@outlook.com', 'rsteinericloud.com', 'mosses@mac.com']

Updated list of valid emails  :-  ['nullchar@aol.com', 'salesgeek@yahoo.com', 'jonathan@outlook.com', 'lydia@gmail.com', 'grdschl@comcast.net', 'glenz@outlook.com', 'cumarana@outlook.com', 'mosses@mac.com']
```

In the above example we make use of *re* regex module to match if the email is valid or not using the **regular expression** in *email_regex* variable, and after iterating over each element at matching it to the *email_regex* we get a list of valid emails


### 3. *reduce()*

* The function *reduce(function, sequence)* continually applies the function to the sequence. It then returns a single value.
**Syntax :- *reduce(callable, iterable)**

i.e., If seq = [ s1, s2, s3, ... , sn ], calling reduce(function, sequence) works like this:
   1. At first the first two elements of seq will be applied to function, i.e. func(s1,s2)
   2. The list on which reduce() works looks now like this: [ 
function(s1, s2), s3, ... , sn ]
   3. In the next step the function will be applied on the previous result and the third element of the list, i.e. function(function(s1, s2),s3)
   4. The list looks like this now: [ function(function(s1, s2),s3), ... , sn ]
5. It continues like this until just one element is left and return this element as the result of reduce()


let's see some example of *reduce()*
**Task :- reduce a list of int to a single integer using + operator** 
### Example :-
```
from functools import reduce

lst =[47,11,42,13]
print("Original list :- ",lst)
print("reduced value :- ",reduce(lambda x,y: x+y,lst))

Output :-
Original list :-  [47, 11, 42, 13]
reduced value :-  113
```
let me explain what is going on in the above example 
```
45    11     42    13
 \    /      /     /
  \  /      /     /
   58      /     /
    \     /     /
     \   /     /
      100     /
       \     /
        \   /
         \ /
         113

numbers at index 0 and 1 first added
then their sum added with value at index 3
then their sum added with value at index 4
then after completing the sequence 
we the reduced value  :- 113

```
let's see one more example of reduce
**Task :- reduce a list of int to a single integer using * operator**
```
from functools import reduce

lst =[47,11,42,13]
print("Original list :- ",lst)
print("reduced value :- ",reduce(lambda x,y: x*y,lst))

Output :-
Original list :-  [47, 11, 42, 13]
reduced value :-  282282
```
The visual that i have demostrated in the previous example ,in this example the same process going , but this time using *x* operator.


### 4. *zip()*

* The function *zip()* makes an iterator that combines elements from each of the iterables
**Syntax :- zip(iter1, iter2, iter3, iter4....)**

* *zip()* function return *zip object* which iterate over a list of *tuples*  where tuples size is equal to the no. of list passed in the *zip()* function.

* The iterator stops when the shortest input iterable is exhausted
*i.e it will return list of tuples of size equal to the length of (minimum size *iterable* among all the *iterables* passed in the *zip()* function)*




let's see some example of *zip()*
**Task :- we will combine user firstname,lastname,hometown using 
zip() function**
### Example :-
```
first_names = ['ram','shyam','ajay','bipin','manoj','alex']
print("list of first names :- ", first_names,"\n")

last_names = ['gupta','tiwari','yadav','rawat','desai','khan','raven']
print("list of first names :- ", last_names,"\n")

home_towns = ['ayodhya','vrindavan','bihar','jhnasi','boston','delhi','lanka']
print("list of hometowns :-" , home_towns,"\n")


persons_info = list(zip(first_names,last_names,home_towns))
print("data after using zip() function :-",persons_info)

Output :-
list of first names :-  ['ram', 'shyam', 'ajay', 'bipin', 'manoj', 'alex'] 

list of first names :-  ['gupta', 'tiwari', 'yadav', 'rawat', 'desai', 'khan', 'raven'] 

list of hometowns :- ['ayodhya', 'vrindavan', 'bihar', 'jhnasi', 'boston', 'delhi', 'lanka'] 

data after using zip() function :- [('ram', 'gupta', 'ayodhya'), ('shyam', 'tiwari', 'vrindavan'), ('ajay', 'yadav', 'bihar'), ('bipin', 'rawat', 'jhnasi'), ('manoj', 'desai', 'boston'), ('alex', 'khan', 'delhi')]

```
In the above example we have combined inforation from three iterable (firstnames,lastnames,hometowns) into list of tuples with information combined from all three iterables.

also notice that,
*it has returned a list of tuples of size equal to the length of (minimum size *iterable* among all the *iterables* passed in the *zip()* function)
i.e 
    * *first_names* list has *length* of 6
    * *last_names* list has *length* of 6
    * *home_town* list has *length* of 7

### 5. *enumerate()*

* The function *enumerate()* return an iterates to a list of tuples , where  first element of each tuple is it's corresponding index (by default is 0) and second element is the value at store at the index
**Syntax :- enumerate(iterable, start)**

* the second argument *start* denotes from where the index start 
*i.e.,* if start = 4 then [(value1,4), (value2,5), (value3,6)...]

let's us take an example with start argument and without start arguement

**Task :- without start argument**
### Example :-
```
names = ['ram','shyam','ajay','bipin','manoj','alex']

names_with_indexes = list(enumerate(names))
for name in names_with_indexes:
  print(name)

Output :-
(0, 'ram')
(1, 'shyam')
(2, 'ajay')
(3, 'bipin')
(4, 'manoj')
(5, 'alex')
```

**Task :- with start argument**
### Example :-
```
names = ['ram','shyam','ajay','bipin','manoj','alex']

names_with_indexes = list(enumerate(names, 4))
for name in names_with_indexes:
  print(name)

Output :-
(4, 'ram')
(5, 'shyam')
(6, 'ajay')
(7, 'bipin')
(8, 'manoj')
(9, 'alex')
```
you can see the difference in the above two examples


### 6. *all()*

* *all()* are built-in functions that allow us to conveniently check for boolean matching in an iterable.
**Syntax :- all(iterable)**

* all() will return True if all elements in an iterable are True.

let's understand with examples
### Example :-
```
lst = [True,True,False,True]
print(all(lst))

Output :-
False
```
Since element at index 2 is false , *all()* returned *False*

###Example
```
lst = [True,True,True,True]
print(all(lst))

Output :-
True
```
Now the result is *True*

###Example 
```
lst = [True,[],[1,2,3],True]

print(all(lst))

Output :-
False
```
if any one coufused why the result is *False*, there is a concept of *Truthy and Falsy* in python.
here is a good example your can check [*Truthy and Falsy* in python](https://stackoverflow.com/questions/39983695/what-is-truthy-and-falsy-how-is-it-different-from-true-and-false)



### 7. *any()*

* *any()* are built-in functions that allow us to conveniently check for boolean matching in an iterable.
**Syntax :- any(iterable)**

* any() will return True if any elements in an iterable are True.

let's understand with examples
### Example :-
```
lst = [True,False,False,False]
print(any(lst))

Output :-
True
```
Since element at index 0 is True, *any()* returned *True*

###Example
```
lst = [False,False,False,False]
print(any(lst))

Output :-
False
```
Now the result is *False*

###Example 
```
lst = [(),[],[1,2,3],False]

print(any(lst))

Output :-
True
```
Now the result is true because at index 2, there is a *list* of size greater than 0 , which is a Truthy value.


with this example we have come to an end,
we have covered various useful *built-in* functions
which are very useful in certain scenarios

Hope you all have learned some useful stuff today. :-)