Python函数

函数是组织好的、可重复使用的，是用来实现单一或相关联功能的代码段。

函数能提高应用的模块性和代码的重复利用率。

Python提供了许多内建函数；也可自己创建函数，称为自定义函数。

0 系统自带函数

0.1 返回字符串长度：len()

0.2 返回切割后的字符串：spllit()

s="imsyoumch"
sub=s.split("o")
print sub    # 输出：['imsy', 'umch']

1 函数定义

1.1 自定义函数的简单规则

函数代码块以def关键词开头，后接函数标识符名称和圆括号()；

任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数；

函数的第一行语句可以选择性地使用文档字符串，用于存放函数说明；

函数内容以冒号起始，并且缩进；

Return[expression]结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

1.2 语法

def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]

默认情况下，参数值和参数名称是按函数声明中定义的的顺序匹配起来的。

1.3 实例

将一个字符串作为传入参数，再打印到标准显示设备上。

def printme( str ):
   "打印传入的字符串到标准显示设备上"
   print str
   return

2 函数调用

定义一个函数，指定函数名称，指定函数包含的参数和代码块结构。

函数基本结构完成后，可通过函数调用执行，也可直接从Python提示符执行。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 定义函数
def printme( str ):
   "打印任何传入的字符串"
   print str;
   return;
# 调用函数
printme("我要调用用户自定义函数!");
printme("再次调用同一函数");

3 按值传递参数和按引用传递参数

Python既不是值传递，也不是引用传递，而是对象传递；

Python中对象分为可变对象、不可变对象；可变对象包括list、dict、类的实例等，不可变对象包括数字、字符串、元组等；

可变对象作为参数传递时，类似于引用传递；不可变对象作为参数传递时，类似于值传递；

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 可写函数说明
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4]);
   print "函数内取值: ", mylist
   return
# 调用changeme函数
mylist = [10,20,30];
changeme( mylist );                          # 输出：函数内取值：  [10,20,30,1,2,3,4]
print "函数外取值: ", mylist                  # 输出：函数外取值：  [10,20,30,1,2,3,4]

def f(num):
    num+=1
    print "The value of local variable is ",num

num=1
f(num)
print "The value of global variable is ",num

4 参数

调用函数时可使用的正式参数类型：必备参数、命名参数、缺省参数、不定长参数；

4.1 必备参数

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

调用printme()函数，你必须传入一个参数，不然会出现语法错误：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print str;
   return;
#调用printme函数
printme();

输出：

Traceback (most recent call last):
  File "test.py", line 11, in <module>
    printme();
TypeError: printme() takes exactly 1 argument (0 given)

4.2 命名参数

命名参数和函数调用关系紧密，调用方用参数的命名确定传入的参数值。

可跳过不传的参数或者乱序传参，因为Python解释器能够用参数名匹配参数值。

用命名参数调用printme()函数：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print str;
   return;
#调用printme函数
printme( str = "My string");                 # 输出：My string

将命名参数顺序不重要展示得更清楚：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print "Name: ", name;
   print "Age: ", age;
   return;
#调用printinfo函数
printinfo( age=50, name="miki" );            # 输出：Name:  miki
                                                    Age:  50

4.3 缺省参数

调用函数时，缺省参数的值如果没有传入，则被认为是默认值。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print "Name: ", name;
   print "Age ", age;
   return;
#调用printinfo函数
printinfo( age=50, name="miki" );            
printinfo( name="miki" );

输出：

Name:  miki
Age  50
Name:  miki
Age  35

4.4 不定长参数

需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。

基本语法：

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

加了星号（*）的变量名会存放所有未命名的变量参数。选择不多传参数也可。

实例：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print "输出: "
   print arg1
   for var in vartuple:
      print var
   return;
# 调用printinfo 函数
printinfo( 10 );
printinfo( 70, 60, 50 );

输出：

输出:
10
输出:
70
60
50

4.5 关键参数

在一个自定义函数中，可通过参数名直接给参数赋值，而不用考虑位置关系；

def f(a=1,b=6,c=7):
    print a
    print b
    print c
f()                 # 使用默认参数
f(5)                # 默认第一个位置的参数a赋值为5，输出：5 6 7
f(b=7,a=8)          # 将参数b赋值为7，参数a赋值为8，而不考虑位置
f(5,c=2,b=3)        # 默认第一个位置的参数a赋值为5，c赋值为2，b赋值为3
f(b=4,c=2,a=1)
# f(b=2,c=3,2)

5 匿名函数

5.1 使用lambda创建匿名函数

lambda只是一个表达式，函数体比def简单很多；

lambda的主体是一个表达式，而不是一个代码块，仅能在lambda表达式中封装有限的逻辑进去；

lambda函数拥有自己的名字空间，且不能访问自有参数列表之外或全局名字空间里的参数；

虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

5.2 语法

lambda函数的语法只包含一个语句。

lambda [arg1 [,arg2,.....argn]]:expression

5.3 实例

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;
# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )        # 输出：相加后的值为 :  30
print "相加后的值为 : ", sum( 20, 20 )        # 输出：相加后的值为 :  40

6 return语句

return语句[表达式]退出函数，选择性地向调用方返回一个表达式。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 可写函数说明
def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print "函数内 : ", total
   return total;
# 调用sum函数
total = sum( 10, 20 );                       # 输出：函数内 :  30
print "函数外 : ", total                     # 输出：函数外 :  30  

不带参数值的return语句返回None；带参数值的return可以返回一个或多个值；

def f(i,j):
    k=i*j
    return (i,j,k)
x=f(3,5)
print x     # 输出：(3, 5, 15)

7 变量作用域

一个程序的所有的变量并不是在哪个位置都可以访问的。

访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。

两种最基本的变量作用域：

全局变量

局部变量

8 全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。

调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
total = 0; # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
   #返回2个参数的和."
   total = arg1 + arg2; # total在这里是局部变量.
   print "函数内是局部变量 : ", total
   return total;
#调用sum函数
sum( 10, 20 );                               # 输出：函数内是局部变量 :  30
print "函数外是全局变量 : ", total            # 输出：函数外是全局变量 :  0

def f():
    global i
    i=7
i=9
f()
print i   # 输出：7