python——函数

1.函数的创建

　　函数是可以调用的（可能带有参数，也可能无参），它执行某种行动并且返回一个值。一般来说，内建的callable函数可以用来判断函数是否可调用。

>>> import math
>>> x = 1
>>> y = math.sqrt
>>> callable(x)
False
>>> callable(y)
True

　　注意：callable函数在python3.0中不可使用，需要使用表达式hasattr(func,_call_)代替。

　　运用函数实现斐波那契数列

# 实现斐波那契数列函数
def fibs(num):
    result = [0,1]
    for i in range(num-2):
        result.append(result[-2]+result[-1])
    return result
# 掉用斐波那契函数
result = fibs(10)
print(result)

　　1.文档化函数

　　为了让其他人使用该函数的时候理解，可以加注释。还有另外一种方法是直接写上字符串。实例如下：

　　

def fibs(num):
    '该函数用于实现斐波那契数列'
    result = [0,1]
    for i in range(num-2):
        result.append(result[-2]+result[-1])
    return result
# 查看函数说明
print(fibs.__doc__)

-----
输出结果：
D:\Python27\python.exe D:/pythonwork/test01/function_1.py
该函数用于实现斐波那契数列

　　2.并非真正函数的函数

　　数学意义上的函数，总是在计算其参数后返回点什么。Python的有些函数却并非返回任何东西。在其他语言中，这类函数有可能有其他名字，比如过程。但是python的函数就是函数，基本在数学意义上不是。

　　没有return语句，或者虽有return语句但是return后面没有跟任何值的函数不返回值：

>>> def test():
...     print('hello python')
...     # 这里的return语句只起到结束函数的作用
...     return
...     print('hi python')
...
>>> test()
hello python
>>> x = test()
　　hello python
　>>> print(x)
　　None

　　test函数其实返回了一个值“None”

　　注意：千万不要被默认行为所迷惑。如果if语句内返回值，那么要确保其他分支也有其他返回值，这样一来当调用者期待一个序列的时候，就不会意外地返回None。

2.参数魔法

　　1.简单区分形参和实参

　　在python写在def语句中函数名后面的变量通常叫做函数的形参，而调用函数时提供的值是实参，或者称为参数。

　　2.能改变参数吗？

　　在函数内为参数赋值不会影响外部任何变量的值：

>>> def try_to_change(n):
...     n = 'Mr.Gumby'
...
>>> name = 'Mr.Entity'
>>> try_to_change(name)
>>> name
'Mr.Entity'
>>>

　　为了方便理解，可以不用函数模拟一下

>>> name = 'Mr.Entity'
>>> n = name #这就话的作用基本上等于传参数
>>> n = 'Mr.Gumby' #在函数内部完成的
>>> name
'Mr.Entity'

　　注意：参数存储在局部作用域（local scope）内。

　　如果将可变的数据结构如列表用作参数的时候会发生什么：

>>> def change(n):
...     n[0] = 'Mr.Gumby'
...
>>> names = ['Mr.G','Mr.Thing']
>>> change(names)
>>> names
['Mr.Gumby', 'Mr.Thing']
>>>

　　可以看到例子中参数发生了改变，解决这样的问题，可以先用切片的方法复制一个副本，然后对副本进行操作。这样就不影响原始数据了。

　　3.为什么要修改参数

　　使用函数改变数据结构（比如字典和列表）是一种将程序抽象化的好方法。

　　假设需要编写一个存储名字并且能用名字、中间名或者姓查询联系人的程序，可以使用下面数据结构：

storage = {}
storage['frist'] = {}
storage['middle'] = {}
storage['last'] = {}

　　storage这个数据结构是带有3个键'first'、'middle'、'last'的字典。每个键下面都又存储一个字典。字典中，可以使用名字（名字、中间名或姓）作为键，插入联系人列表作为值。比如要把一个英文名字加入这个数据，可以按如下操作：

me = 'Magnus Lie Hetland'
storage['first']['Magnus'] = [me]
storage['first']['middle'] = [me]
storage['first']['last'] = [me]
print(storage['first']['Magnus'])
print(storage['first']['middle'])
print(storage['first']['last'])

-------
结果如下：
D:\Python27\python.exe D:/pythonwork/test01/function_1.py
['Magnus Lie Hetland']
['Magnus Lie Hetland']
['Magnus Lie Hetland']

　　将人名加到列表中的步骤有点枯燥无味，尤其是要加入很多人名的时候。代码如下：

my_sister = 'Anne Lie Hetland'
storage['first'].setdefault('Anne', []).append(my_sister)
storage['middle'].setdefault('Lie', []).append(my_sister)
storage['last'].setdefault('Hetland', []).append(my_sister)
print(storage['middle']['Lie'])
print(storage['first']['Anne'])

----------
结果如下：
D:\Python27\python.exe D:/pythonwork/test01/function_1.py
['Magnus Lie Hetland', 'Anne Lie Hetland']
['Anne Lie Hetland']

　　如果写大程序来这样更新列表，那么很显然程序很快就会得臃肿不堪。

　　怎么却解决呢，那么就要用到抽象了，抽象的要点就是隐藏更新时繁琐的细节，可以用函数来实现这个过程。

　　实现一个添加查找用户名的程序，代码如下：

# 创建初始化结构的函数
def init(data):
    data['first'] = {}
    data['middle'] = {}
    data['last'] = {}

# 创建查询函数
def lookup(data, label, name):
    return data[label].get(name)

# 编写增加用户名的函数
def store(data, full_name):                # 使用参数data和full_name进入这个函数，这两个参数被设置为函数在外部获得的一些值。
    names = full_name.split()              # 通过拆分full_name，得到一个叫做names的列表
    if len(names) == 2:                    # 如果names的长度为2，那么插入一个字符串作为中间名
        names.insert(1, '')
    labels = ('first', 'middle', 'last')
    for label, name in zip(labels, names): # 使用zip函数联合表情和名字，对每一个（label,name）对，进行处理
        people = lookup(data, label, name) # 调用查询函数，如果存在列表则追加，不存在则创建
        if people:
            people.append(full_name)
        else:
            data[label][name] = [full_name]

#####################################主函数#########################################
MyNames = {}
# 引用初始化结构函数
init(MyNames)
# 调用存储函数
store(MyNames, 'Naguns Lie Hetland')
store(MyNames, 'Anne Lie Hetland')
store(MyNames, 'MyNames, Robin Hood')
# 调用查询函数
name = lookup(MyNames, 'middle', 'Lie')
print(name)

　　4.如果参数是不可变的呢

　　在python中：函数只能修改参数对象本身。但是如果你的参数不可变（比如数字），又该怎么办呢？

　　不好意思，没有办法。

 将变量的数值增1的函数可以按如下方式来写
 1 >>> def inc(x): return x+1
...
>>> inc(10)
11
>>> x
>>> foo = inc(10)
>>> foo
11
 如果真的像改变参数，那么可以使用一点小技巧，将值放置在列表中：
>>> def inc_2(x): x[0] = x[0] + 1
...
>>> foo = inc_2(10)
>>> foo = inc_2([10])
>>> foo
>>> foo = [10]
>>> inc_2(foo)
>>> foo
[11]
>>>

　　

　　5.关键字参数和默认值

　　目前为止我们所使用的参数都叫做位置参数，因为他们的位置很重要，事实上比他们的名字还重要。

　　如以下例子：

def hello_1(greeting, name):
    print('%s,%s!' % (greeting, name))


def hello_2(name, greeting):
    print('%s,%s!' % (name, greeting))


hello_1('hello', 'python')

hello_2('hello', 'python')

-----------------
结果：（两个代码显示的功能是一样的）
D:\Python27\python.exe D:/pythonwork/test01/function_2.py
hello,python!
hello,python!

　　参数的顺序很难记住，为了让事情简单些，可以提供参数的名字：

def hello_1(greeting='hello', name='python'):
    print('%s,s%'%(greeting, name))
    
# 这样一来顺序就完全没有影响了
# 但参数值一定要对应

　　这类使用参数名提供的参数叫做关键字参数。他的主要作用在于可以明确每个参数的作用。避免调用错参数。

　　关键字参数最厉害的地方在于可以在函数中给参数提供默认值：

>>> def hello_3(greeting='Hello', name='python'):
...     print('%s,%s!'%(greeting, name))
...
>>> hello_3()
Hello,python!

　　

　　6.收集参数

　　以下写法可以给函数提供多个参数

　　def print_params(*params):

　　　　print(params)

　　“*”的意义就是“收集其余的位置参数”。如果不提供任何供收集的元素，params就是个空元祖

　　那么能不能处理关键字参数呢？见如下代码：

>>> print_params_2('Hmm...', something=42)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'print_params_2' is not defined
>>>

　　很明显是不行的，所以我们需要采用另外一种方法来处理关键字参数的“收集”。这是就需要用到“**”

　　事例如下：

>>> def print_params_3(**params):
...     print(params)
...
>>> print_params_3(x=1,y=2,z=3)
{'x': 1, 'z': 3, 'y': 2}
>>>

　　测试证明是可行的。反悔的是字典，而不是元组。

　　那么放在一起是否可行呢？

>>> def print_params_4(x,y,z=3,*pospar, **keypar):
...     print(x,y,z)
...     print(pospar)
...     print(keypar)
...
>>> print_params_4(1,2,3,4,5,foo=1,bar=2)
1 2 3
(4, 5)
{'foo': 1, 'bar': 2}

 　　回到之前怎么实现多个名字同时存储的问题上。解决方案如下：

# 编写增加用户名的函数
def store(data, *full_names):                  # 使用“*full_names”收集参数，实现多个名字同时存储。
    for full_name in full_names:               # 使用参数data和full_name进入这个函数，这两个参数被设置为函数在外部获得的一些值。
        names = full_name.split()              # 通过拆分full_name，得到一个叫做names的列表
        if len(names) == 2:                    # 如果names的长度为2，那么插入一个字符串作为中间名
            names.insert(1, '')
        labels = ('first', 'middle', 'last')
        for label, name in zip(labels, names):  # 使用zip函数联合表情和名字，对每一个（label,name）对，进行处理
            people = lookup(data, label, name)  # 调用查询函数，如果存在列表则追加，不存在则创建
            if people:
                people.append(full_name)
            else:
                data[label][name] = [full_name]

　　

　　7.参数收集的逆过程

>>> params = {'name':'Sir Robin','greeting':'Well met'}
>>> hello_3(**params)
Well met,Sir Robin!
>>>

　　在定义或者调用函数时使用星号（或者双星号）仅传递元组或字典。

　　星号只用在定义函数（允许使用不定数目的参数）或者调用（“分割”字典或者序列）时才有用。

　　提示：

　　使用拼接（splicing）操作符“传递”参数很有用，因为这样一来就不用关心参数的个数之类的问题了，例如：

def foo(x, y, z, m=0, n=0):
    print(x, y, z, m, n)


def call_foo(*args, **kwds):
    print('Calling foo!')
    foo(*args, **kwds)

　　

　　8.使用参数例子：

def story(**kwds):
    return 'Once upon a time, there was a %(job)s called %(name)s.' % kwds


def power(x, y, *others):
    # 如果为类型
    if others:
        print('Received redundant parameters:', others)
    return pow(x, y)


def interval(start, stop=None, step=1):  # start开始值, stop结束值, step步长
    'Imitates range() for step >0 '      # 函数的用途
    if stop is None:                     # 如果没有为stop提供直...
        start, stop = 0, start           # 指定参数
    result = []                          # 定义列表
    i = start                            # 计算索引
    while i < stop:                      # 直到检索到stop的索引
        result.append(i)                 # 将索引添加到result内
        i += step                        # 用step增加索引i
    return result                        # 以列表的形式返回结果

 

小结：

• 抽象：抽象是隐藏多余细节的艺术。定义处理细节的函数可以让程序更加抽象。
• 函数定义：函数使用def语句定义。他们是由语句组成的块，可以从“外部世界”获取值（参数），也可以返回一个或者多个值作为运算结果。
• 参数：函数从参数中得到需要的信息，也就是函数调用时设定的变量。Python中有两类参数：位置参数和关键字参数。参数在给定默认值时是可选的。