Shulou(Shulou.com)06/02 Report--

This article mainly introduces "what built-in functions are there in Python". In daily operation, I believe many people have doubts about what built-in functions there are in Python. The editor consulted all kinds of materials and sorted out simple and easy-to-use methods of operation. I hope it will be helpful to answer the questions of "what built-in functions are there in Python?" Next, please follow the editor to study!

01 once used: lambda

Many languages have anonymous functions. Python's anonymous functions are written in lambda, and lambda is the best choice when you need to implement a def function that does not want to be "high-profile".

The grammatical format generally looks like this:

Lambda x:x**2 #

You can also assign it to a variable that can be used to call this anonymous function in subsequent programs because everything in python is an object.

F = lambda x:x**2 f (2) # 4

Of course, there is no need to use lambda to implement it here, because since you want to call it explicitly, you might as well just write an explicit function. The wider application scenario of the lambda function is that when the anonymous function is passed as a parameter of another function, the application is more appropriate. For example, if you use lambda as the key parameter of the sort () function, you can sort specific functions.

Dyct = {'avell2,' bounded dyct.items 1, 'caterpillar dyct.items 5} sorted (dyct.items (), key = lambda XRV x [1]) # [(' baked, 1), ('ajar, 2), (' caterpillar, 5)]

02 Intelligent decompression: zip

The zip function, like its name, is a packaged or unpackaged function that accepts more than 2 iterable variables and outputs the iteration type after the corresponding position is formed into a tuple. For example:

A = ['axiao,' baked,'c'] b = (4, 5, 6) zip (Arecoverb) # list (zip (arecalb)) # [('ajun, 4), (' baked, 5), ('cased, 6)] tuple (zip (arelb)) # ((' ajun, 4), ('baked, 5), (' cynical, 6))

It is also possible to accept more than 2 input iterable variables, and there will be no error if the length of each iterative variable is inconsistent, but the return of the iterative variable depends on the one with the shortest total input length. For example:

A = ['True,' baked, 'caged,' dashed,'e'] b = (4, 5, 6, 7) c = [True, False, True] list (zip (a-dagger, 4, True)) # (('Abel, 5, False), (' cased, 6, True))

The corresponding use of zip packaging is unpacking, that is, unpacking a packaged element in turn and returning multiple new lists. For example:

AZip = (('True, 4, True), (' baked, 5, False), ('True, 6, True)) a, b, c = zip (* aZip) # a: (' averse, 'baked,' c') # b: (4, 5, 6) # c: (True, False, True)

03-11 mapping: map

The map function, like its name, is an iterative variable that takes the accepted iterative variable through some mapping in turn and outputs the mapped variable. For example, if you evaluate a variable in a list in turn and return a new list, you can apply map:

A = [1,2,3,4] map (str, a) # list (map (str, a)) # ['1','2','3','4']

This is a typical use of the map function: take two arguments, the first parameter (the str () function in the above example) is a function to act on, and the second argument is an iterable variable.

Map can also accept more arguments when the argument to the first function is a multivariable function. For example:

A = [1,2,3,4] b = [2,2,3,3] list (map (lambda x, y:x**y, a, b)) # [1,4,27,64]

Similar to the zip function, the error will not be reported when the length of the function parameters in map does not match, but the output result will be determined by the shortest one:

A = [1,2,3,4] b = [2,2] list (map (lambda x, y:x**y, a, b)) # [1,4]

04 as long as one person guards: filter

Similar to the map function, the filter function takes a function and its variables as arguments, but requires that the return result of the function is Bool, and the result of the bool is used to determine the choice of the output. For example, you need to filter an input list, requiring you to retain a multiple of 3:

A = range (10) filter (lambda x:x%3==0, a) # list (filter (lambda x:x%3==0, a)) # [0,3,6,9]

Note here that when the return value of the first function of filter is not Bool, it will not report an error, but it will be transformed into a Bool judgment. If the judgment result is not False (variables that will be judged as False in python include 0, None, [], etc.), it will be output, otherwise it will be filtered out:

A = range (10) list (filter (lambda x:x%3, a)) # [1,2,4,5,7,8]

50000 swords returned to the family: reduce

Both map and filter functions are multi-input and multi-output, which essentially completes a specific transformation or filtering. Reduce is a reduction function, which converts a series of input variables into a result output after a specific function. However, due to the limited application scenarios, reduce is no longer a global calling function in python3. You must import it from the functools package before you can use it:

From functools import reduce a = range (5) reduce (lambda x, y: Xeroy, a) # 10

The reduce function can also accept an optional initial value as an argument. Many small trick can be implemented by using the reduce function, depending on whether you can think of it or not:

From functools import reduce s = 'abcdefg' reduce (lambda x, y: yellowx, s,' AA') # 'gfedcbaAA' here, the study of "what built-in functions are in Python" is over, hoping to solve everyone's doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.