Introduction to 5 commonly used built-in higher-order functions in Python (with code)

This article brings you an introduction to 5 commonly used built-in high-order functions in Python (with code). It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you. help.

Python has built-in commonly used higher-order functions:

1. Functional programming

The function itself can be assigned to a variable, and the variable becomes a function after the assignment;

Allows the function itself to be passed into another function as a parameter;

allows a function to be returned.

1. map() function

is a built-in higher-order function in Python. It receives a function f and a list,

and passes Function f acts on each element of the list in turn, obtains a new list and returns

def add(x):
    return x+x

print(map(add,[1, 2, 3]))
# Out:

2, reduce() function

The reduce() function is also a high-order function built into Python.

The parameters received by the reduce() function are similar to map(), a function f and a list, but the behavior is different from map(). The function f passed in by reduce() must receive two parameters,

reduce() repeatedly calls function f on each element of the list and returns the final result value.

In Python3, the reduce() function has been removed from the global namespace. It is now placed in the functools module. If you want to use it,

You need to import it through functools module to call the reduce() function:

from functools import reduce


def prod(x, y):
    return x*y


print(reduce(prod, [2, 4, 5, 7, 12]))
# Out:3360  # 2*4*5*7*12
# reduce()还可以接收第3个可选参数，作为计算的初始值。如果把初始值设为100
print(reduce(prod, [2, 4, 5, 7, 12], 100))
# Out:336000    # 2*4*5*7*12*100

3, filter() function

is another useful built-in Python A higher-order function, the filter() function receives a function f and a list.

The function of this function f is to judge each element and return True or False. filter() automatically filters out the elements based on the judgment result. For elements that do not meet the conditions,

returns a new list consisting of elements that meet the conditions.

import math

def is_sqr(x):
    return math.sqrt(x) == int(math.sqrt(x))

print(list(filter(is_sqr, range(1, 101))))
# Out:[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

4, sorted() function

Performs sorting operation on all iterable objects.

The difference between sort and sorted:

sort is a method applied to a list, and sorted can sort all iterable objects. The sort method of

list returns an operation on an existing list, while the built-in function sorted method returns a new list rather than an operation based on the original one.

sorted(iterable, key=None, reverse=False)

iterable -- Iterable object.

key -- Mainly used for comparison elements, with only one parameter. The parameters of the specific function are taken from the iterable object, and an element in the iterable object is specified for sorting.

reverse -- Sorting rule, reverse = True for descending order, reverse = False for ascending order (default).

Return the reordered list

print(sorted([5, 2, 3, 1, 4]))
# Out:[1, 2, 3, 4, 5]
print(sorted({1:'D', 2:'B', 3:'B', 4:'E', 5: 'A'}))
# Out:[1, 2, 3, 4, 5]

Use key to sort in reverse order

example_list = [5, 0, 6, 1, 2, 7, 3, 4]
result_list = sorted(example_list, key=lambda x: x*-1)
print(result_list)

To reverse sort, you can also pass in The third parameter reverse=True:

example_list = [5, 0, 6, 1, 2, 7, 3, 4]
print(sorted(example_list, reverse=True))
# Out:[7, 6, 5, 4, 3, 2, 1, 0]

5. Python functions can not only return data types such as int, str, list, dict, etc., but also return functions!

Please pay attention to distinguishing the return function and the return value:

def my_abs():
    return abs  # 返回函数，返回函数可以把一些计算延迟

def my_abs2(x):
    return abs(x)   # 返回函数调用的结果，返回值是一个数值

def calc_prod(lst):
    def lazy_prod():
        prod = 1
        for i in lst:
            prod = prod*i
        return prod
    return lazy_prod
f = calc_prod([1, 2, 3, 4])
print(f())
# Out:24

5.1. Why define the lazy_prod() function and the return function cal_prod()?

Python supports the basic syntax of the return function

def f():
    print('call f()...')
    # 定义函数g:
    def g():
        print('call g()...')
    # 返回函数g:
    return g

Only the role of the return function:

The return function can delay the execution of some calculations. For example, if you define a normal sum function:

def calc_sum(lst):
    return sum(lst)
print(calc_sum([1,2,3,4]))
# Out:10

def calc_sum(lst):
    def lazy_sum():
        return sum(lst)
    return lazy_sum

f = calc_sum([1, 2, 3, 4])
print(f)    # 代码并没有对函数进行执行计算出结果，而是返回函数,所以打印出来的是类型
#Out: .lazy_sum at 0x000001FF43462E18>
print(f())      # 对返回的函数进行调用时，才计算出结果
# Out:10

The above is the detailed content of Introduction to 5 commonly used built-in higher-order functions in Python (with code). For more information, please follow other related articles on the PHP Chinese website!