【Python之旅】第三篇（一）：Python函数

说明：
使用函数可以使程序实现功能模块化，大大简洁我们的程序，这里主要讨论Python中函数的下列内容：

1.函数定义与函数参数
2.局部变量和全局变量
3.函数默认参数和关键参数
4.*args和**kwargs
5.函数返回值return与yield简单说明
6.lambda函数（匿名函数）
7.Python内置函数

因为函数部分内容跟C语言中的很多内容都十分相似，所以会结合C语言来进行对比学习。

1.函数定义与函数参数

--基本格式1：不参参数
·定义：

def sayHi():
print "Hello!"

·调用：

>>> sayHi()
Hello

--基本格式2：带一个参数
·定义：

def sayHi(name):
print "Hello, %s, how are you?" % name

·调用：

>>> sayHi('xpleaf')
Hello, xpleaf, how are you?

--基本格式3：多个参数
·定义：

def sayHi(name, age):
print "Hello, %s, how are you?" % name
print "You are %s years old." % age

·调用：

>>> sayHi('CL', 20)
Hello, CL, how are you?
You are 20 years old.

2.局部变量与全局变量

·看下面一个程序：

#!/usr/bin/env python

age = 29

def sayHi():
age = 28
print "function age:%s" % age

sayHi()
print "gloable age:",age

·执行结果如下：

xpleaf@xpleaf-machine:/mnt/hgfs/Python/day3$ python fun3.py
function age:28
gloable age: 29

·Python函数中，作用域的概念与C语言中是一样的，这里不再提及；

·有两点需要注意：
a.通过局部变量改变全局变量，可以在函数中使用global，如下代码：

def sayHi():
global age
age = 28
print "function age:%s" % age

b.全局变量没有定义，在函数中使用global定义，相当于定义全局变量，但不建议这样使用；

4.函数默认参数和关键参数

--函数默认参数
·看下面一个程序：

#!/usr/bin/env python

def users(username, group = 'GDUT'):
mydict = {}
mydict[username] = group
return mydict

print "default argument:", users('xpleaf') #use default argument

print "full argument:", users('xpleaf', 'BAT') #do not use default argument

·执行结果如下：

xpleaf@xpleaf-machine:/mnt/hgfs/Python/day3$ python default.py
default argument: {'xpleaf': 'GDUT'}
full argument: {'xpleaf': 'BAT'}

·定义函数时，参数默认赋值，在使用函数时即可以不对此类参数赋值，即为默认参数；

·使用默认参数的原则：定义函数时，非默认参数在前，默认参数在后；

·如下面即是非法的情况：

#!/usr/bin/env python

def users(group = 'GDUT', name):
mydict = {}
mydict[username] = group
return mydict

print "default argument:", users('xpleaf') #use default argument
#编译器将无法知道'xpleaf'是赋给group变量还是name变量

print "full argument:", users('xpleaf', 'BAT') #do not use default argument

·执行时提示错误：non-default argument follows default argument

xpleaf@xpleaf-machine:/mnt/hgfs/Python/day3$ python default.py
File "default.py", line 3
def users(group = 'GDUT', name):
SyntaxError: non-default argument follows default argument

--函数关键参数
·在使用多个默认参数的函数中，如下程序：

#!/usr/bin/env python

def users(name, age, group = 'GDUT', project = 'Python'):
print '''name:%s
age:%s
group:%s
project:%s''' % (name, age, group ,project)

users('xpleaf', 21)

·执行结果如下：

xpleaf@xpleaf-machine:/mnt/hgfs/Python/day3$ python default.py
name:xpleaf
age:21
group:GDUT
project:Python

-只指定第一个默认参数

·对应的users的代码修改为：

users('xpleaf', 21, 'BAT')

·执行结果如下：

xpleaf@xpleaf-machine:/mnt/hgfs/Python/day3$ python default.py
name:xpleaf
age:21
group:BAT
project:Python

-同时指定两个默认参数

·对应的users的代码修改为：

users('xpleaf', 21, 'BAT', 'stupy')

·执行结果如下：

xpleaf@xpleaf-machine:/mnt/hgfs/Python/day3$ python default.py
name:xpleaf
age:21
group:BAT
project:stupy

-只需要指定第二个默认参数

·对应的users的代码修改为：

users('xpleaf', 21, project = 'stupy')

·执行结果如下：

xpleaf@xpleaf-machine:/mnt/hgfs/Python/day3$ python default.py
name:xpleaf
age:21
group:GDUT
project:stupy

·指定第二个参数，此即为关键参数，可以不按原来参数的顺序（不指定关键参数则达不到目的）；
·也可以指定多个默认参数，从而不按原来参数的位置，users代码修改如下：

users(project = 'stupy', name = 'xpleaf', age = 21, group = 'BAT')

·执行结果如下：

xpleaf@xpleaf-machine:/mnt/hgfs/Python/day3$ python default.py
name:xpleaf
age:21
group:BAT
project:stupy

-更清晰的例子

·程序代码如下：

#!/usr/bin/env python

def func(a, b=5, c=10):
print 'a=%s, b=%s, c=%s' % (a, b, c)

func(3, 7)
func(25,c=24 )
func(c=50, a=100)

·执行结果如下：

func(3, 7) # a = 3, b=7,c=10
func(25, c=24) # a=25, b=5,c=24
func(c=50, a=100) # a=100,b=5,c=50

4.*args和**kwargs

·在参数不确定的情况下使用*args和**kwargs，前者可以输出参数对应的元组，后者可以输出参数对应的字典；

·*args演示如下：
a.程序代码

def sayHI(*args):
print args
sayHI('xpleaf',21,'GDUT')

b.执行结果

xpleaf@xpleaf-machine:/mnt/hgfs/Python/day3$ python fun2.py
('xpleaf', 21, 'GDUT')

·**kwargs演示如下：

a.程序代码

def sayHi2(**kwargs):
print kwargs

sayHi2(name = 'xpleaf', age=21, phone = 5201314)

b.执行结果

xpleaf@xpleaf-machine:/mnt/hgfs/Python/day3$ python fun2.py
{'phone': 5201314, 'age': 21, 'name': 'xpleaf'}

·由于字典是没有次序的，所以输出的顺序会跟输入的不同；
·由于kwargs是以字典的方式获取函数中的参数，这也意味前，如果原来函数就没有参数，而且在使用函数时又没有使用关键字参数的方式执行函数，是会有问题的：

>>> sayHi2('xpleaf', age=21, phone=5201314)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: sayHi2() takes exactly 0 arguments (3 given)

>>> sayHi2(name='xpleaf', age=21, phone=5201314)
{'phone': 5201314, 'age': 21, 'name': 'xpleaf'}

·如果只按照上面的写法，则说明可以不加任何参数，当然，根据此思路，我们也可以定义如def sayHi(name,age,**kwargs)等形式的；

·关于该函数参数的说明，更详细的，可以参考廖雪峰老师的相关文档，也是写得非常详细的。

·*args和**kwargs同时使用：

>>> def func(*args, **kwargs):
...   print "args is:", args
...   print "kwargs is:", kwargs
...

·演示如下：

>>> func(name="xpleaf", age=22, hobby="Python")
args is: ()
kwargs is: {'hobby': 'Python', 'age': 22, 'name': 'xpleaf'}

>>> func("cl", name="xpleaf", age=22, hobby="Python")
args is: ('cl',)
kwargs is: {'hobby': 'Python', 'age': 22, 'name': 'xpleaf'}

·需要说明的时，由于*args参数在前，**kwargs参数在后，所以在执行函数时应该要按照这个顺序填写参数，否则会报错：

>>> func(name="xpleaf", age=22, hobby="Python", "clyyh")
File "<stdin>", line 1
SyntaxError: non-keyword arg after keyword arg

5.函数返回值return与yield简单说明

--return说明
·在函数中添加return语句可以返回函数执行的某些值，但会造成阻塞问题，看下面代码：

def func():
for i in range(10):
return i
result = func()
print result

·执行结果如下：

xpleaf@xpleaf-machine:/mnt/hgfs/Python/day3/blog$ python func.py
0

·与C语言类似，函数遇到return即会结束，意味着使用return返回函数值会造成阻塞问题，即不能每执行一次循环，返回一个值，再执行其他操作，然后再去执行函数中的循环；
·可以使用yield来代替return实现上面功能；

--yield说明

-代码改写1
·上面代码改写为：

import time

def func():
for i in range(10):
time.sleep(1)
yield 'Loop', i
result = func()
print result

·执行结果如下：

xpleaf@xpleaf-machine:/mnt/hgfs/Python/day3/blog$ python func.py
<generator object func at 0x7f06d4300c80>

·由前面迭代器的知识，yield实现的就是创建一个迭代器；

-代码改写2
·上面代码改写为：

import time

def func():
for i in range(10):
time.sleep(1)
yield 'Loop', i
result = func()
print result.next()
print result.next()
print result.next()
print result.next()
print result.next()

·执行结果如下：

xpleaf@xpleaf-machine:/mnt/hgfs/Python/day3/blog$ python func.py
('Loop', 0)
('Loop', 1)
('Loop', 2)
('Loop', 3)
('Loop', 4)

·只调用了5次迭代器，因此只产生5个值；

-代码改写3
·上面代码改写为：

import time

def func():
for i in range(10):
time.sleep(1)
yield 'Loop', i
result = func()
print result.next()
print 'Upon:No.1'
print result.next()
print 'Upon:No.2'
print result.next()
print 'Upon:No.3'
print result.next()
print 'Upon:No.4'
print result.next()
print 'Upon:No.5'
print 'None'

·执行结果如下：

xpleaf@xpleaf-machine:/mnt/hgfs/Python/day3/blog$ python func.py
('Loop', 0)
Upon:No.1
('Loop', 1)
Upon:No.2
('Loop', 2)
Upon:No.3
('Loop', 3)
Upon:No.4
('Loop', 4)
Upon:No.5
None

·即可以实现前面[跳出函数-->再执行其它操作-->再回到函数]的功能；
·注意事项为：
a.用了yield就不能使用return，用了yield就表示用了迭代器
b.yield要用在函数中，不能直接在循环中写，即在不是函数内的循环中写，如：

for i in range(10):
time.sleep(1)
yield 'Loop', i

6.lambda函数（匿名函数）

--关于匿名函数的说明

lambda函数也叫匿名函数，即，函数没有具体的名称。先来看一个最简单例子：
def f(x):
return x**2
print f(4)
Python中使用lambda的话，写成这样
g = lambda x : x**2
print g(4)
那么，lambda表达式有什么用处呢？很多人提出了质疑，lambda和普通的函数相比，就是省去了函数名称而已，同时这样的匿名函数，又不能共享在别的地方调用。其实说的没错，lambda在Python这种动态的语言中确实没有起到什么惊天动地的作用，因为有很多别的方法能够代替lambda。同时，使用lambda的写法有时显得并没有那么pythonic。甚至有人提出之后的Python版本要取消lambda。
回过头来想想，Python中的lambda真的没有用武之地吗？其实不是的，至少我能想到的点，主要有：
1. 使用Python写一些执行脚本时，使用lambda可以省去定义函数的过程，让代码更加精简。
2. 对于一些抽象的，不会别的地方再复用的函数，有时候给函数起个名字也是个难题，使用lambda不需要考虑命名的问题。
3. 使用lambda在某些时候让代码更容易理解。

--lambda函数应用1：定义简单函数

·演示如下：

>>> g = lambda x:x**2
>>> g(4)
16

·关于lambda函数与普通函数的简单区别：
a.lambda执行操作时，第一次是引用变量，即引用匿名函数，往后相同操作是引用上一次的指针：

>>> g = lambda x:x**2
>>> g(4)
16
>>> g(4)
16    #直接引用上一次结果的指针
>>> g(6)
36    #新的操作，会重新引用变量

b.普通函数无论是否执行相同操作，都是直接调用函数的功能；

--lambda函数应用2：应用于map函数
·查看map函数的帮助文档：

map(...)
map(function, sequence[, sequence, ...]) -> list
#即前面第一个参数可以为一个函数，并将sequence交给该函数处理，这时可使用lambda函数

·演示如下：

>>> a = range(10)
>>> b = range(10)
>>> a,b
([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> map(lambda x:x**2,a)    #定义1个参数
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> map(lambda x,y:x**y,a,b)    #定义两个参数
[1, 1, 4, 27, 256, 3125, 46656, 823543, 16777216, 387420489]

--lambda函数应用3：应用于sorted()排序
·sorted()可对数据类型进行排序，虽然字典无序，但可以有序输出字典中的内容；
·演示如下：

>>> a = {2:'a',4:'f',8:'c',9:'e'}
>>> a
{8: 'c', 9: 'e', 2: 'a', 4: 'f'}
>>> sorted(a.items())
[(2, 'a'), (4, 'f'), (8, 'c'), (9, 'e')]

·通过sorted()结合lambda函数可以选取基于字典中key值或value值的排序：

>>> sorted(a.items(),key=lambda x:x[0])    #基于key值排序
[(2, 'a'), (4, 'f'), (8, 'c'), (9, 'e')]
>>> sorted(a.items(),key=lambda x:x[1])    #基于value值排序
[(2, 'a'), (8, 'c'), (9, 'e'), (4, 'f')]

·sorted()中的key并非特指字典中的key值，这是sorted()函数中的参数关键字：

sorted(...)
sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list

7.Python内置函数

·Python中内置函数比较多，这里不给出，参考个人的内置函数文档即可，往后学习更深入，内置函数使用更多时会再重新写一篇专门Python内置函数的文章。