Python basic content: functions

Function is an organized, reusable code segment used to implement a single or related function. Functions can improve application modularity and code reuse. Functions created by yourself are called user-defined functions. Function definition specifications: 1. The function code block starts with the def keyword, followed by the function identifier name and parentheses ().
2. Any incoming parameters and independent variables must be placed between parentheses, and the spaces between parentheses can be used to define parameters.
3. The first line of statements of a function can optionally use a documentation string - used to store function descriptions.
4. The function content starts with a colon and is indented.
5.return [expression] ends the function and optionally returns a value to the caller. Return without an expression is equivalent to returning None.
Function definition syntax: def function name (formal parameter): function body By default, parameter values ​​and parameter names are matched in the order defined in the function declaration. Example: #You can not define formal parameters>>> def
show():... Print('show fun')...>>> show()show fun Simple calculation of area Function: >>> def
area(height,width):... a = height*width... return a...>>> area(4,5)20 function Calling a function directly uses the function name (). If the function name is used directly, the physical content address of the function is returned. When () is added, it represents the formal parameters and actual parameters of the executed function> >> def
area(height,width):... a = height*width... return a...>>> area(4,5)20 In this example, height and width are formal parameters, which are used to define the structure and logic of the function. The following 4 and 5 are actual parameters, which are the parameters actually passed in by the user when calling the function. The number of actual parameters must be the same as the formal parameters. To remain consistent, when calling, the specific values ​​of the formal parameters correspond one-to-one according to the order in which the actual parameters are passed in. For example, 4 corresponds to height and 5 corresponds to width. Keyword parameters (specified parameters) Using keyword parameters allows the parameters to be changed when the function is called. The order is inconsistent with the declaration. The specific usage is as follows>>>
def area(height,width):... a = height*width... return a...>>>
area(width = 5,height = 4)# We just need to specify the values ​​of the specific formal parameters when calling the function. Default parameters When calling a function, if no parameters are passed, the default parameters will be used. Default parameters must be defined at the end of all formal parameters>>>
def stu(name,age,grade=3):... print('name is %s,age is %s,grade is %s' %
(name,age,grade))...>>>
stu('ian',10) #No grade parameter is passed in here, grade is used by default =
3name is
ian,age is 10,grade is 3>>>
stu('isha',9,4)name is
isha,age is 9,grade is 4 Dynamic parameters #Dynamic parameter 01, add all incoming actual parameters to a primitive def main2(*arg): print(arg,type(arg))main2(1,2,3,4) #Dynamic parameter 02, will pass All the entered actual parameters are added to a dictionary def main3(**kwargs): print(kwargs,type(kwargs))main3(k1=12,k2='ian') #Dynamic parameter 03, the above two items are combined def
main4(*args,**kwargs): print(args,type(args)) print(kwargs,type(kwargs))main4(1,2,k1=12,k2='ian') #The above form The order of parameters and actual parameters here cannot be reversed, otherwise an error will be reported #Dynamic parameter 4, if the actual parameter is a variable, how to specify it in the dynamic parameter--->With *def
main4(*args,**kwargs) : print(args,type(args)) print(kwargs,type(kwargs))m = [1,2]n =
{'k1':12,'k2':'ian'}main4(*m ,**n) Summary: Python functions have a very flexible parameter form, which can not only implement simple calls, but also pass in very complex parameters. The default parameters must use immutable objects. If they are mutable objects, there will be logic errors in operation! Pay attention to the syntax for defining variable parameters and keyword parameters: *args is a variable parameter, args receives a tuple; **kwargs is a keyword parameter, and kwargs receives a dict. Using *args and **kwargs is the Python convention. Of course, other parameter names can also be used, but it is best to use the convention. Anonymous function python uses lambda
to create anonymous functions. The so-called anonymous means that you no longer use the standard form of def
statement to define a function. 1.lambda is just an expression, and the function body is much simpler than def.
2. The body of lambda is an expression, not a code block. Only limited logic can be encapsulated in lambda expressions.
3.lambda
The function has its own namespace and cannot access parameters outside its own parameter list or in the global namespace.
4. Although the lambda function seems to only be able to write one line, it is not equivalent to the inline function of C or C++. The purpose of the latter is to increase the operating efficiency by not occupying stack memory when calling small functions.
Anonymous function syntax lambda function syntax only contains one statement, as follows: lambda [arg1
[,arg2,.....argn]]:expression Example:>>>
su = lambda a,b,c: a + b + c>>> su(1,2, 3) 6 return statement return is used to exit the function. Using return [expression] will return an expression when exiting the function. Return without parameters returns none >>> def
area(height,width) :... a = height*width... return a...>>> ar =
area(4,5)>>>
print('area is', ar)area is 20 Global variables and local variables When you declare variables within a function definition, they have no relationship with other variables with the same name outside the function, that is, the variable name is
local to the function. This is called the scope of the variable. The scope of all variables is the block in which they are defined, starting from the point where their names are defined. Local variables: def func(x): print ('x is',x) x=2 print ('Changed local x to',x) x=50func(x)print ('x is still',x) The result is : x is 50Changed local x to 2x is still 50 Using the global statement If you want to assign a value to a variable defined outside the function, then you have to tell Python that the variable name is not local, but
global. We use the global statement to accomplish this function. Without the global statement, it is impossible to assign a value to a variable defined outside a function. def func(): global x print ('x is',x) x=2 print ('Changed local x to',x) x=50func()print ('x is still',x) The result is: x is 50Changed local x to 2x is still 2 #global statement is used to declare that x is global. Therefore, when we assign a value to x within the function, the value of x outside the function will also change directly

The above is the detailed content of Python basic content: functions. For more information, please follow other related articles on the PHP Chinese website!