python函数

一、函数：

创建函数：使用def语句

举例：定义一个返回斐波那楔数列列表的函数

def fibs(num):
    result = [0,1]
    for i in range(num-2):
        result.append(result[-2]+result[-1])
    print(result)
fibs(10)

>>>
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
>>>

文档化函数：对函数进行说明，写在函数开头的字符串，它会作为函数的一部分进行存储，称为文档字符串。

举例：给square()函数进行注释

def square(x):
    '''calculates the square of the nmber x'''
    return x*x

#使用此方法访问：
>>> square.__doc__
'calculates the square of the nmber x'
>>> 

return语句：函数的返回值，起到结束函数的作用，不需要返回时，返回为None

举例：

def test():
    print('pass')
    return
    print('nothing')
x = test()
print(x)

>>>
pass
None
>>> 

参数：

形参：函数名后面的变量通常叫做函数的形参；

实参：调用函数时提供的值称为实参；

说明：在函数内为参数赋值新值不会改变外部任何变量的值；

举例：

#不可变参数：字符串、数字和元组
def change(n):
    n = 'zyj'
    print(n)

name = 'sl'
change(name)
print(name)
>>>
zyj
sl
>>>

#可变参数如列表
def change(n):
n[0] = 'zyj'
print(n[0])

name = ['sl','xm']
change(name)
print(name)

>>>
zyj
['zyj', 'xm']
>>>

# 保留原始变量的办法：
def change(n):
n[0] = 'zyj'
print(n[0])

name = ['sl','xm']
change(name[:])
print(name)

zyj
['sl', 'xm']
>>>

使用函数改变数据结构的实现举例

要求：编写一个存储名字，并且能根据条件查找对应的名字

实现：定义数据结构类型为字典，通过键值（first，second）查找对应的name。

def init(data):
    '''初始化数据结构的函数'''
    data['first'] = {}
    data['second'] = {}
def lookup(data,lable,name):
    '''查找人名相同函数'''
    return data[lable].get(name)
def store(data,full_name):
    '''将输入名字存储在数据库中函数'''
    names = full_name.split()
    if len(names) == 1:
        names.insert(1, '')
    labels = 'first','second'
    for label,name in zip(labels,names):
        peole = lookup(data,label,name)
        if peole:
            peole.append(full_name)
        else:
            data[label][name]=[full_name]

>>> storage = {}
>>> init(storage)
>>> storage
{'first': {}, 'second': {}}
>>> store(storage, 'zhao yujiao')
>>> lookup(storage,'second','yujiao')
['zhao yujiao']
>>> store(storage, 'zhao qiaojiao')
>>> lookup(storage,'second','yujiao')
['zhao yujiao']
>>> storage
{'first': {'zhao': ['zhao yujiao', 'zhao qiaojiao']}, 'second': {'yujiao': ['zhao yujiao'], 'qiaojiao': ['zhao qiaojiao']}}
>>> lookup(storage,'first','yujiao')
>>> lookup(storage,'first','zhao')
['zhao yujiao', 'zhao qiaojiao']
>>> store(storage, 'song qiaojiao')
>>> storage
{'first': {'zhao': ['zhao yujiao', 'zhao qiaojiao'], 'song': ['song qiaojiao']}, 'second': {'yujiao': ['zhao yujiao'], 'qiaojiao': ['zhao qiaojiao', 'song qiaojiao']}}
>>> lookup(storage,'second','qiaojiao')
['zhao qiaojiao', 'song qiaojiao']
>>> store(storage, 'qiaojiao')
>>> storage
{'first': {'zhao': ['zhao yujiao', 'zhao qiaojiao'], 'qiaojiao': ['qiaojiao'], 'song': ['song qiaojiao']}, 'second': {'': ['qiaojiao'], 'yujiao': ['zhao yujiao'], 'qiaojiao': ['zhao qiaojiao', 'song qiaojiao']}}

关键字参数：可以明确每个参数的作用，不需要在乎参数的位置。

def hello_1(greeting,name):
    print("%s,%s!" % (greeting,name))
def hello_2(name,greeting):
    print("%s,%s!" % (name,greeting))
hello_1("Hello","World")
hello_1(greeting="Hello",name="World")
>>>
Hello,World!
Hello,World!
>>>

关键字参数可以在函数中给参数提供默认值，此时调用的时候可以不用提供参数，提供一些或提供所有参数

def hello_3(greeting="Hello",name="World"):
    print("%s,%s!" % (greeting,name))
hello_3()
hello_3("greetings")
hello_3("greetings",'zyj')
hello_3(name='zyj')
>>>
Hello,World!
greetings,World!
greetings,zyj!
Hello,zyj!
>>> 

位置参数和关键字参数结合使用

def hello_3(name,greeting="Hello",p='!'):
    print("%s,%s%s" % (greeting,name,p))
hello_3("zyj")
hello_3("zyj",p='!!!')
hello_3(name='zyj')
>>>
Hello,zyj!
Hello,zyj!!!
Hello,zyj!
>>> 

收集参数：参数前加星号将所有值放置在同一个元组中。一个参数里面传递多个值。

def print_params(*params):
    print(params)
print_params('zyj')
print_params(1,2,3)
print_params([1],[2],[3])
print_params((1,2),(2,3))
def print_params(title,*params):
    print(title)
    print(params)
print_params('name:','zyj','sl','sb')
print_params('name:')
>>>
('zyj',)
(1, 2, 3)
([1], [2], [3])
((1, 2), (2, 3))
name:
('zyj', 'sl', 'sb')
name:
()
>>> 

收集关键字参数：使用**，返回的是字典

def print_params(**params):
    print(params)
print_params(x=1,y=2,z=3)
print_params(x=[1],y=[2],z=[3])
print_params(x=(1,2),y=(2,3))
def print_params(x,y,z=9,*params,**key):
    print(x,y,z)
    print(params)
    print(key)
print_params(1,2,3,4,5,6,foo=1,bar=2)
print_params(1,2)
>>>
{'x': 1, 'y': 2, 'z': 3}
{'x': [1], 'y': [2], 'z': [3]}
{'x': (1, 2), 'y': (2, 3)}
1 2 3
(4, 5, 6)
{'foo': 1, 'bar': 2}
1 2 9
()
{}
>>> 

参数收集的逆过程：在定义或者调用参数时使用星号或者双星号传递元组或字典。

def add(x,y):
    return x+y
params = (1,2)

def hello_3(name,greeting="Hello",p='!'):
    print("%s,%s%s" % (greeting,name,p))
params = {'name':"zyj"}

>>> add(*params)
3
>>> hello_3(**params)
Hello,zyj!
>>> 

作用域：

1、局部变量：函数内部的变量

2、全局变量：具有全局作用域的变量

def foo():
    x = 42
x = 1
foo()
>>> x
1
>>> 　　

当局部变量或者参数的名字和要访问的全局变量名相同时，不能直接访问全局变量，因为全局变量将被局部变量屏蔽

解决办法：使用globals()函数获取全局变量

vars():返回全局变量的字典；

locals():返回局部变量的字典

def combine(params):
    print(params+params)
params = 'zyj'
combine('hello')
def combine(params):
    print(params+globals()['params'])
params = 'zyj'
combine('hello')
>>>
hellohello
hellozyj
>>> 

如何改变全局变量的值：

x = 1
def change_global():
    global x
    x = x + 1
change_global()
>>> x
2
>>> 

函数的嵌套：一般用于需要用一个函数创建另一个的时候；

说明：一个函数位于另一个里面，外层函数返回里层函数，函数本身被返回，但并没有被调用，同时返回的函数可以访问它的定义所在的作用域，来自外部作用域的变量会被内层函数访问。

类似 multiplyByFactor函数存储子封闭作用域的行为叫做闭包。

def multiplier(factor):
    def multiplyByFactor(number):
        return number*factor
    return multiplyByFactor
>>> double = multiplier(2)
>>> double(5)
10
>>> triple = multiplier(3)
>>> triple(3)
9
>>> multiplier(5)(4)
20
>>> 

递归：调用自身即函数可以调用自身

无穷递归：会导致程序崩溃或最终返回“超过最大递归深度”的错误信息提示

def foo():
    return foo()
>>> foo()
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    foo()
  File "C:\Users\七彩蜗牛\Desktop\抽象.py", line 2, in foo
    return foo()
  File "C:\Users\七彩蜗牛\Desktop\抽象.py", line 2, in foo
    return foo()
    ......
RuntimeError: maximum recursion depth exceeded
>>> 

有用的递归：递归实例，包括一个或多个问题较小部分的递归调用

使用递归实现阶乘：函数调用了fact(n)和fact(n-1)两个不同的实体。

def factorial(n):
    result = n
    for i in range(1,n):
        result *= i
    return result

def fact(n):
    if n == 1:
        return 1
    else:
        return n * fact(n-1)
>>> factorial(10)
3628800
>>> fact(10)
3628800
>>> 

使用递归实现幂：函数调用了p(x,n)和p(x,n-1)两个不同的实体。

def power(x,n):
    result = 1
    for i in range(n):
        result *= x
    return result
def p(x,n):
    if n == 0:
        return 1
    else:
        return x * p(x,n-1)
>>>
>>> power(2,3)
8
>>> p(2,3)
8
>>> power(3,0)
1
>>> p(3,0)
1
>>> 

函数属性：

命名空间：使用句点属性标识创建不同的名字空间领域。句点属性标识对于两个模块意味不同的命名空间

def foo():
    ''' foo()---properly created doc string '''
def bar():
    pass
bar.__doc__ = 'hello'
bar.version = 0.1
>>>
>>> help(foo)
Help on function foo in module __main__:

foo()
    foo()---properly created doc string

>>> foo()
>>> print(foo())
None
>>> print(bar.version)
0.1
>>> print(bar.__doc__)
hello
>>> help(bar)
Help on function bar in module __main__:

bar()
    hello

>>> bar.__doc__
'hello'
>>> bar.__dict__
{'version': 0.1}
>>> foo.__dict__
{}
>>>