详解Python中的各种函数的使⽤
函数是有组织的，可重复使⽤的代码，⽤于执⾏⼀个单⼀的，相关的动作的块。函数为应⽤程序和代码重⽤的⾼度提供了更好的模块。
正如我们知道的，Python的print()等许多内置函数，但也可以创建⾃⼰的函数。这些函数称为⽤户定义函数。
定义⼀个函数
可以定义函数，以提供所需的功能。下⾯是简单的规则来定义Python函数。
函数块以开始关键字def后跟函数名和括号中(())。
任何输⼊参数或参数应该放在这些括号内。还可以定义这些括号内的参数。
函数的第⼀个语句可以是??⼀个可选的声明 - 该函数或⽂档字符串的⽂档字符串。
每个函数中的代码块以冒号(:)开头并缩进。
该语句返回[表达式]退出功能，可选地传递回⼀个表达式给调⽤者。不带参数return语句返回None。
语法:
def functionname( parameters ):
"function_docstring"
function_suite
return [expression]
默认情况下，参数具有⼀个位置的⾏为和需要，它们被定义为通知他们以相同的顺序。
例⼦：
这是最简单的Python函数形式。这个函数接受⼀个字符串作为输⼊参数，并打印标准的屏幕上。
def printme( str ):
"This prints a passed string into this function"
print str
return
调⽤函数
定义⼀个函数只给出它的名称，指定要被包括在功能和结构的代码块的参数。
⼀旦函数的基本结构确定后，可以通过从其他函数或直接从Python提⽰符调⽤它执⾏它。以下是⽰例调⽤printme()函数：
#!/usr/bin/python
# Function definition is here
def printme( str ):
"This prints a passed string into this function"
print str;
return;
# Now you can call printme function
printme("I'm first call to user defined function!");
printme("Again second call to the same function");
当执⾏上⾯的代码中，产⽣以下结果：
I'm first call to user defined function!
Again second call to the same function
引⽤VS值传递
所有参数（参数）在Python语⾔是通过引⽤传递。这意味着，如果你在⼀个函数中改变了⼀个参数的值，变化也反映了在调⽤函数中。例如：
#!/usr/bin/python
# Function definition is here
def changeme( mylist ):
"This changes a passed list into this function"
mylist.append([1,2,3,4]);
print "Values inside the function: ", mylist
return
# Now you can call changeme function
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist
这⾥，我们保持传递的对象的参考，并在同⼀个对象附加的值。这样，这将产⽣以下结果：
Values inside the function: [10, 20, 30, [1, 2, 3, 4]]
Values outside the function: [10, 20, 30, [1, 2, 3, 4]]
还有就是参数通过引⽤传递和引⽤被覆盖在被调⽤的函数⾥⾯⼀个例⼦。
#!/usr/bin/python
# Function definition is here
def changeme( mylist ):
"This changes a passed list into this function"
mylist = [1,2,3,4]; # This would assig new reference in mylist
print "Values inside the function: ", mylist
return
# Now you can call changeme function
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist
参数myList上局部函数changeme。更改函数内mylist不影响mylist。函数没有作⽤，最后这会产⽣以下结果：Values inside the function: [1, 2, 3, 4]
Values outside the function: [10, 20, 30]
函数参数：
可以通过使⽤形参的类型如下调⽤函数：
必需的参数
关键字参数
默认参数
可变长度参数
必需的参数：
所需的参数为传递给正确的位置顺序的函数的参数。这⾥，在函数调⽤的参数的数⽬应与函数定义完全匹配。调⽤函数printme()，⼀定要传递⼀个参数，否则会如下给出⼀个语法错误：
#!/usr/bin/python
# Function definition is here
def printme( str ):
"This prints a passed string into this function"
print str;
return;
# Now you can call printme function
printme();
当执⾏上⾯的代码，产⽣以下结果：
Traceback (most recent call last):
File "test.py", line 11, in <module>
printme();
TypeError: printme() takes exactly 1 argument (0 given)
关键字参数：
关键字参数是关系到函数调⽤。当在⼀个函数调⽤中使⽤关键字参数，调⽤者通过参数名称标识的参数。
这可以跳过参数或脱离顺序，因为Python解释器能够使⽤提供的参数使⽤匹配的值的关键字。还可以使关键字调⽤在以下⽅⾯printme()函数：
#!/usr/bin/python
# Function definition is here
def printme( str ):
"This prints a passed string into this function"
print str;
return;
# Now you can call printme function
printme( str = "My string");
当执⾏上⾯的代码中，产⽣以下结果：
My string
下⾯的例⼦给出了更清晰的画⾯。请注意，这⾥跟参数秩序没有关系。
#!/usr/bin/python
# Function definition is here
def printinfo( name, age ):
"This prints a passed info into this function"
print "Name: ", name;
print "Age ", age;
return;
# Now you can call printinfo function
printinfo( age=50, name="miki" );
当执⾏上⾯的代码，产⽣以下结果：
Name: miki
Age 50
默认参数：
默认参数是，假设⼀个默认值，如果不提供的函数调⽤的参数值的参数。下⾯的例⼦给出了默认参数⼀个主意，它会默认打印age，如果不通过传值：
#!/usr/bin/python
# Function definition is here
def printinfo( name, age = 35 ):
"This prints a passed info into this function"
print "Name: ", name;
print "Age ", age;
return;
# Now you can call printinfo function
printinfo( age=50, name="miki" );
printinfo( name="miki" );
当执⾏上⾯的代码，产⽣以下结果：
Name: miki
Age 50
Name: miki
Age 35
可变长度参数：
可能需要处理函数⽐在定义函数指定多个参数。这些参数被称为可变长度参数，在函数定义没有被命名，不像必需默认参数。
⾮关键字可变参数的函数的⼀般语法是这样的：
def functionname([formal_args,] *var_args_tuple ):
"function_docstring"
function_suite
return [expression]
星号（*）被放置，将持有的所有⾮关键字变量参数的值在变量名前。该元组保持为空，如果函数调⽤期间没有指定任何其他参数。下⾯是⼀个简单的例⼦：
python中lambda怎么使用
#!/usr/bin/python
# Function definition is here
def printinfo( arg1, *vartuple ):
"This prints a variable passed arguments"
print "Output is: "
print arg1
for var in vartuple:
print var
return;
# Now you can call printinfo function
printinfo( 10 );
printinfo( 70, 60, 50 );
当执⾏上⾯的代码，产⽣以下结果：
Output is:
10
Output is:
70
60
50
匿名函数：
可以使⽤lambda关键字来创建⼩的匿名函数。这些函数被称为匿名，因为它们不是以标准⽅式通过使⽤def关键字声明。
Lambda形式可以采取任何数量的参数，但在表现形式上只返回⼀个值。它们不能包含命令或多个表达式。
匿名函数不能直接调⽤打印，因为需要lambda表达式。
lambda函数都有⾃⼰的命名空间，并且不能访问变量⾼于在其参数列表和那些在全局命名空间等。
尽管似乎lambda是⼀个函数的单⾏版本，它们不是在C或C++，其宗旨是通过调⽤出于性能原因在传递函数的堆栈分配相当于⼀⾏的声明。
语法
lambda函数的语法仅包含单个语句，如下：
lambda [arg1 [,arg2,.....argn]]:expression
以下为例⼦来说明函数lambda形式是如何⼯作的：
#!/usr/bin/python
# Function definition is here
sum = lambda arg1, arg2: arg1 + arg2;
# Now you can call sum as a function
print "Value of total : ", sum( 10, 20 )
print "Value of total : ", sum( 20, 20 )
当执⾏上⾯的代码，产⽣以下结果：
Value of total : 30
Value of total : 40
return语句：
该语句返回[表达式]退出功能，可选地传递回⼀个表达式给调⽤者。不带参数return语句返回None。
以上所有的例⼦都没有返回任何值，但如果喜欢，可以从⼀个函数返回值：
#!/usr/bin/python
# Function definition is here
def sum( arg1, arg2 ):
# Add both the parameters and return them."
total = arg1 + arg2
print "Inside the function : ", total
return total;
# Now you can call sum function
total = sum( 10, 20 );
print "Outside the function : ", total
当执⾏上⾯的代码，产⽣以下结果：
Inside the function : 30
Outside the function : 30
变量的作⽤域：
程序中的所有变量可能不会在该程序中的所有位置进⾏访问。这取决于所声明的变量。
变量的作⽤域确定了程序，可以访问⼀个特定的标识符的⼀部分。在Python中的变量两个基本范畴：
全局变量
局部变量
全局与局部变量：
这是⼀个函数体内部定义的变量具有局部范围，⽽那些之外定义具有全局范围。
局部变量只能在函数内部被声明和访问，⽽全局变量可以在整个程序主体由所有函数进⾏访问。当调⽤⼀个函数，它⾥⾯声明的变量都纳⼊范围。下⾯是⼀个简单的例⼦：
#!/usr/bin/python
total = 0; # This is global variable.
# Function definition is here
def sum( arg1, arg2 ):
# Add both the parameters and return them."
total = arg1 + arg2; # Here total is local variable.
print "Inside the function local total : ", total
return total;
# Now you can call sum function
sum( 10, 20 );
print "Outside the function global total : ", total
当执⾏上⾯的代码，产⽣以下结果：
Inside the function local total : 30
Outside the function global total : 0