# Higher order  and Partial Functions

Higher-order functions play a crucial role in `functional programming` paradigms. Higher-order functions like `filter()`, `map()`, and `reduce()` enable you to manipulate functions as `first-class objects`, allowing for more flexible and expressive programming.

## filter()

* The `filter` function selects elements from an iterable based on a given condition, returning a new iterable containing only the elements that satisfy the condition.
    
    ```python
    # Example 2: Using filter() with lambda function
    def is_even(x):
        return x % 2 == 0
    
    numbers = [1, 2, 3, 4, 5, 6]
    even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
    print(even_numbers)  # Output: [2, 4, 6]
    ```
    

## map()

* The `map` function applies a given function to each element of an iterable and returns an iterable containing the results.
    
    ```python
    def is_even(x):
        return x % 2 == 0
    
    numbers = [1, 2, 3, 4, 5, 6]
    even_numbers = list(map(lambda x: x % 2 == 0, numbers))
    print(even_numbers)  
    # Output: [False, True, False, True, False, True]
    ```
    

## reduce()

* The `reduce` function repeatedly applies a binary function to the elements of an iterable, reducing it to a single value by performing the specified operation cumulatively.
    
* Syntax : `reduce(function, list)`
    
    ```python
    import functools
    
    #Using normal function
    def sum(a, b):
        return a + b
    
    list = [2, 5, 9, 11, 13]
    val = functools.reduce(sum, list)#func takes two two element
    print(val)
    
    #Using lambda function
    list = [2, 5, 9, 11, 13]
    val = functools.reduce(lambda a, b: a+b, list)#func takes two two element
    print(val)
    ```
    
    **How it works in above example of** `reduce()`
    
    * **Step:1** = First pass 2,5 as arguments and return 2 + 5 = **7**
        
    * **Step:2** = pass 7, 9 as arguments and return 7 + 9 = **16**
        
    * **Step:3** = pass 16, 11 arguments and return 16 + 11 = **27**
        
    * **Step:4** = pass 27 , 13 27 + 13 = **40** (**Final results**)
        

## partial()

* Partial functions in Python allow you to create new functions with fewer parameters by fixing some values from an existing function.
    
* It simplifies function calls and promotes code reusability by creating specialized versions of functions with pre-filled values.
    
    ```python
    from functools import partial
    
    def sum(a,b,c,d):
        return a+b+c+d
    
    #Passing a = 1, b = 2, c = 3
    add_portion = partial(sum,1,2,3)
    
    #Now passing d = 4
    result =  add_portion(4)
    print(result)# output = 10
    ```