python学习笔记（十二）之函数

牛刀小试：

　　定义一个无参函数

>>> def myFirstFunc():
...     print("Hello python")
...     print("hello world")
...     print("hello my fist func")
... 
>>> myFirstFunc()
Hello python
hello world
hello my fist func

　　定义一个有参函数

>>> def mySecondFunc(name):
...     print("hello", name)
... 
>>> mySecondFunc('zhz')
hello zhz

函数之形参和实参

>>> def add(first, second):
...     return first + second
... 
>>> add(1, 5)
6

定义函数时，first和second就是形参，在函数调用时，传递的1和5就是实参。

函数之注释和文档

>>> def add(first,second):
...     '这是函数文档：计算两个参数的和'
...     #这是函数注释：计算两个参数的和
...     return first + second
... 

函数文档可以使用以下方式查看

>>> add.__doc__
'这是函数文档：计算两个参数的和'

>>> help(add)

Help on function add in module __main__:

add(first, second)
    这是函数文档：计算两个参数的和

 函数之关键字参数

>>> def saysome(name, words):
...     print(name, '->', words)
... 
>>> saysome('Jobs', 'stay hungry,stay foolish')
Jobs -> stay hungry,stay foolish
>>> saysome('stay hungry,stay foolish','Jobs')
stay hungry,stay foolish -> Jobs
>>> saysome(words = 'stay hungry,stay foolish',name = 'Jobs')
Jobs -> stay hungry,stay foolish

函数之默认参数

>>> def saysome(name = 'Jobs', words = 'stay hungry, stay foolish'):
...     print(name, '->', words)
... 
>>> saysome()
Jobs -> stay hungry, stay foolish
>>> saysome('nazi')
nazi -> stay hungry, stay foolish
>>> saysome(words = 'keep working')
Jobs -> keep working
>>> saysome('nazi','keep looking')
nazi -> keep looking

函数之收集参数

>>> def test(*params):
...     for i in range(len(params)):
...             print(params[i])
... 
>>> test(1, 'hello', (1,3, ['abc']))
1
hello
(1, 3, ['abc'])

收集参数后最好使用默认参数，用关键字参数调用。

函数返回值

　　python中，用return语句可以从函数返回一个对象，列表或元组。当没有显示调用return语句时，python会自动返回一个NoneType对象。所以，可以说python中只有函数，没有过程。

>>> def hello():
...     print("Hello")
... 
>>> temp = hello()
Hello
>>> print(temp)
None
>>> type(temp)
<class 'NoneType'>
>>> def back():
...     return 1,2,'abc',[1,2]
... 
>>> back()
(1, 2, 'abc', [1, 2])
>>> def back():
...     return [1, 3.14, 'abv', [2]]
... 
>>> back()
[1, 3.14, 'abv', [2]]

局部变量和全局变量

　　在函数内部声明的变量是局部变量，在函数外声明的变量是全局变量。

def discount(price,rate):
    'final_price, price, rate are local variables'
    final_price = price * rate
    return final_price
    
if __name__ == '__main__':
    'old_price, rate and new_price are global variables'
    old_price = float(input("原价："))
    rate = float(input("折扣："))
    new_price = discount(old_price, rate)
    print("折后价：", new_price)

　　在函数中试图修改一个全局变量的值时，会python创建一个和全局变量相同的局部变量，此时，修改的只是该局部变量，全局变量不变。

>>> number = 10
>>> def test():
...     number = 5
...     
... 
>>> test()
>>> number
10

　　要在函数内部修改全局变量的值，可以使用global关键字。

>>> number
10
>>> def test():
...     global number
...     number = 5
... 
>>> test()
>>> number
5

内嵌函数

　　在函数内部可以定义其他函数，这个内部函数的作用域仅限于外部函数内部。在外部函数外部的任何位置使用该内部函数，都会抛出一个异常。

>>> def funA():
...     print("funA")
...     def funB():
...             print("funB")
...     funB()
... 
>>> funA()
funA
funB
>>> funB()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'funB' is not defined

闭包

　　如果在一个内部函数里对外部作用域（非全局作用域）的变量进行引用，那么内部函数被认为是一个闭包。

>>> def funX(x):
...     def funY(y):
...             return x*y
...     return funY
... 
>>> i = funX(5)
>>> type(i)
<class 'function'>
>>> i(6)
30
>>> funX(5)(6)
30

　　同样的，在闭包内修改外部作用域变量，系统会自动创建局部变量x，屏蔽外部变量。

>>> def fun1():
...     x = 5
...     def fun2():
...             x *= x
...     fun2()
... 
>>> fun1()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 5, in fun1
  File "<stdin>", line 4, in fun2
UnboundLocalError: local variable 'x' referenced before assignment

　　此时要修改外部变量，一，可以使用列表，列表不是放在栈里。

>>> def fun1():
...     x = [5]
...     def fun2():
...             x[0] *= x[0]
...     fun2()
...     print(x)
... 
>>> fun1()
[25]

　　二，可以使用nolocal关键字

def fun1():
    x = 5
    def fun2():
        nonlocal x
        x = 50
    fun2()
    print(x)

if __name__ == '__main__':
    fun1()