1. function
A function is a section with a characteristic function 、 Reusable statement groups .
stay Python The key words are used in the function def start , After the space, connect the function name with the parentheses (), The last colon : ending .
Function names can only contain strings 、 Underscores and numbers and can't start with numbers . Although the function name can be arbitrarily named , But let's name the function as short as possible , And express function function .
Each function should have a corresponding description of the function and parameters , It should be written in the first line below the function . To enhance code readability .
def strlen(s):
“”“ calulate the length of the string ”“”
len = 0
for x in s:
len = len + 1
return len
Empty function
def null_fun():
"""This is a null fun"""
pass #pass Sentences do nothing , It's actually used as a place holder
Don't write return And write return None The effect is the same , All that comes back is None
Just write a return When you don't add anything, write return None The effect is the same
If you have more than one in a function return, Only the first one return.
Multiple return function
def mult_return():
name='Lily'
age=18
return name, age
c= mult_return()
print(c)
# ('Lily', 18)
n, a = mult_return()
print(n, a)
# Lily 18
When a variable is used to receive the return value , Received a tuple . This is because in the python To divide with commas Multiple values are considered a tuple .
When the return value has more than one variable to receive , Then the number of returned values should be exactly the same as the number of received variables .
Function call
s='hello world!'
length=strlen(s) # Call the one written above strlen function
print(length) # Printout 12
Function parameter
The parameter installation type of function can be divided into formal parameter and actual parameter ( Variable type and immutable type ).
Immutable type ( Such as Integers 、 character string 、 Tuples ) It's just passing its value , It doesn't affect the object itself . If you change its value inside a function , It is equivalent to creating a new one .
Variable types are similar to C++ By reference , As listing , Dictionaries . It's actually passing the parameters through , After modification, external parameter variables will also be affected .
def invariableFun(i):
i=100 # The parameter is of immutable type , Internal changes in functions do not affect external parameters
a=1
print(a)
invariableFun(a)
print(a)
# The output is as follows
1
1
def variantFun(list):
list.append('python') # The parameter is of variable type , Internal changes in functions affect external parameters
mylist=['Lily', 'James']
print(mylist)
variantFun(mylist)
print(mylist)
# The output is as follows
['Lily', 'James']
['Lily', 'James', 'python']
Parameters can also be divided into required parameters , Key parameters , Default parameters and variable length parameters .
1) Required parameters
Necessary parameters , That is, the parameter that must be passed when the function is called .
2) Default parameters
The required parameters are in front , The default parameter is after , otherwise python The interpreter will report an error .
The default parameter must point to the invariant object ！ Point to the invariant object ！ Point to the invariant object ！
def student(name, age=18):
print(name, age)
student("Lily")
student("Lily", 20)
# The output is as follows ：
Lily 18
Lily 20
3) Key parameters
In fact, the keyword parameter already appears in the default parameter ！ The keyword parameter is when the function is called , Pass in the argument with the parameter name , The arguments passed in this way are called keyword arguments .
Using keyword parameters allows the order of parameters when a function is called to be different from when it is declared , because Python The interpreter can match parameter values with parameter names .
def student(name, age=18):
print(name, age)
student(age=22, name='Lily')
# The output is as follows ：
Lily 22
4) Indefinite length parameter
There are two kinds of indefinite length parameters ：
a. Allows multiple “ Non key words ” Parameters ,python These extra parameters will be put into a tuple .
def tupleVarArgs(arg1, arg2='default arg2', *other):
print('arg1: ', arg1)
print('arg2: ', arg2)
for x in other:
print('other arg: ', x)
# The output of the call is as follows ：
tupleVarArgs('Lily')
arg1: Lily
arg2: default arg2
tupleVarArgs('Lily', 'Sandy')
arg1: Lily
arg2: Sandy
tupleVarArgs('Lily', 'Sandy', 'James', 'Curry')
arg1: Lily
arg2: Sandy
other arg: James
other arg: Curry
b. Allows multiple “ keyword ” Parameters ,python It's going to add up < Parameter name , Parameter values > Put it in a dictionary . It should be noted that , Keyword variable parameter should be the last parameter defined by the function , belt **.
def dictVarArgs(arg1, arg2='default arg2', **otherArgs):
print('arg1: ', arg1)
print('arg2: ', arg2)
for x in otherArgs.keys():
print('other arg: <%s : %s> '% (x, str(otherArgs[x])))
# The output of the call is as follows ：
dictVarArgs('Lily')
arg1: Lily
arg2: default arg2
dictVarArgs('Lily', 'Sandy')
arg1: Lily
arg2: Sandy
dictVarArgs('Lily', 'Sandy', name1='James', name2='Curry')
arg1: Lily
arg2: Sandy
other arg: <name1 : James>
other arg: <name2 : Curry>