Ython function
Functions are well-organized, reusable pieces of code that are used to implement a single, or associated function.
Functions can improve the modularity of the application, and the reuse of the code. You already know that Python provides a number of built-in functions, such as print (). But you can also create your own functions, which are called user-defined functions.
Defining functions
def functionname():"Function _ Document String"return[expression]
A function document is similar to a comment, which is used to understand function functions. You can use functionname.__doc__ to print out the contents of a function document.
Calling functions
#!/usr/bin/python #-*-Coding:utf-8-*- # define functions def Printme ( str print Str;return; # call function printme ( "I want to invoke a user-defined function!") printme ( "call the same function again"
Note: Forward references are not allowed in Python, that is, the function is not allowed to be called until the function is defined. That is, the function must be defined before the function is called.
function parameters
First understand the concepts of the following formal parameters and arguments:
The parameters in the function definition procedure are called parameters, and the arguments passed in when the function is called are called arguments, which are the specific parameter values.
There are four types of function definition parameters:
1. Position parameters
The required parameters must be passed into the function in the correct order. The number of calls must be the same as when declared.
2. Default parameters
Parameters are assigned initial values during parameter definition, and when the function is called, the default value is used instead of assigning a value to the parameter.
3. Keyword parameters
Parameters that need to be assigned are specified by the parameter name, and the order of arguments is not consistent with the declaration when using the keyword argument, because the Python interpreter can match the parameter value with the name of the argument.
def printme():"Print any incoming string" Print str; return; #调用printme函数printme(="My string");
4. Variable parameters (collect parameters)
def functionname([Formal_args,]*):"Function _ Document String"return[expression]
Variable names with an asterisk (*) will hold all unnamed variable arguments. In fact, Python is a collection of parameters as a tuple processing.
If you need to add additional custom parameters after collecting the parameters, you will need to assign values using the keyword parameter when assigning them. Try to set default values for these custom parameters when defining functions, preventing errors.
function return value
Def back ():
return [1, ' s ', 2]
Def back ():
Return, ' s '
Multiple data separated by commas, in fact, to return a tuple
function Scope
Global variables VS Local variables
We usually make variables defined outside the function as global variables, variables defined within the function are called local variables, and as the name implies, the scope of the global variable is the entire code snippet, and the scope of the local variable is only in the code segment to which it belongs, and the variable is only valid in its scope.
Note: Global variables can be accessed within a function, but cannot be modified. If you forcibly modify a global variable, Python automatically creates a local variable with the same name as the global variable within the function, and the local variable is modified, and the global variable does not change.
Global keyword
As you can see from the code in the above lesson, if the variable name declared in the function is duplicated with the existing global variable name, then the local variable overwrites the global variable. If you want to use global variables in the body of a function, you need to use the global statement to declare the variable that is used before it is a globally variable.
inline functions
Internal functions The entire scope is within the outer function
Def fun1 ():
Print (' fun1 () is being called ... ')
Def fun2 ():
Print (' fun2 () is being called ... ')
Fun2 ()
FUN1 ()
FUN1 () is being called ...
Fun2 () is being called ...
Fun2 ()
Error, hint fun2 not defined
Intrinsic functions can only be called within the body of an external function, and will be an error if used outside the external function.
Closures (closure)
If, in an intrinsic function, a reference is made to a variable in the outer scope, then the intrinsic function is a closure
def funx (x):
def funy (y):
Return X*y
Return Funy
Funx (3) returns the function type
Print (Funx (3) (4)) prints out 12
Def fun1 ():
X=5
Def fun2 ():
X*=x
return x
Return fun2 ()
FUN1 () error, because in fun2, the variable x that called and changed the external function
Def fun1 ():
X=5
Def fun2 ():
nonlocal x
X*=x
return x
Return fun2 ()
Print (FUN1 ()) to perform normally
Lambda expression (anonymous function)
The main function is to simplify the code, not to mention the problem of function names.
Python3 Basics-function