Python——追加学习笔记(四）

函数

1、python里的函数可以返回一个值或者对象，知识在返回一个容器对象的时候有点不同，看起来像是能返回多个对象。

>>> def bar():
...     return 'abc', '123'
...
>>> bar()
('abc', '123')
>>> type(bar())   #返回的其实是元组
<type 'tuple'>

简而言之，如果没有显式的返回于元素或者若果返回None时，python会返回一个None。如果函数返回多个对象，python把他们聚集起来并以一个元组返回。

调用函数

1、以一对圆括号调用函数.

>>> bar()
('abc', '123')

创建函数

1、def 语句

语法：

def function_name(arguments):
    "function_documentation_string"  #函数注释
    function_body_suite

示例：

>>> def bar():
...     "return a tuple"    #函数注释
...     return 'abc', '123'
...
>>> bar()       #函数调用
('abc', '123')

2、前向引用

语言已经无法表达了。

>>> def foo():
...     print 'In foo()'
...     bar()
...
>>> def bar():
...     print 'In bar()'
...
>>> foo()
In foo()
In bar()

3、函数属性

>>> def foo():
...     print 'In foo()'
... 
>>> foo.__doc__     #函数注释
>>> foo.__name__    #函数名字
'foo'
>>> foo.version = 0.1   #函数版本
>>> foo.__doc__ = 'Make a test function'
>>> help(foo)   #可以输出函数的注释文本

4、内部/内嵌函数

eg.
python解释器输出：

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

将上述函数整合为一个模块：#inner.py

#!/usr/bin/env python 
# -*- coding:utf-8 -*- 
# Script_Name: inner.py
def foo():
    def sar():
        print 'sar() called'
    print 'foo() called'
    sar()
    
if __name__ == '__main__':
    foo()
    sar()

带有内嵌函数的外部函数，其执行顺序依然是顺序执行。
执行inner.py结果：

foo() called
sar() called
Traceback (most recent call last):
  File ".\inner.py", line 18, in <module>
    bar()
NameError: name 'sar' is not defined

内嵌函数整个函数体都是在外部函数的作用域之内的，如果没有对内部函数的外部引用，那么除了函数体内，任何地方都不会对其起作用。

5、内嵌函数体补充

• func1():

>>> def func1():
...     def fo():
...         print 'fo() called'
...     return fo
...
>>> func1()
<function fo at 0x7fa699baab90>
>>> result = fun1c()
>>> type(result)
<type 'function'>

这里return fo返回的是一个函数对象的引用。

• func2():

>>> def func2():
...     def fo():
...         print 'fo() called'
...     return fo()
...
>>> func2()
fo() called

这里的返回[return fo()]的是一个函数（对象）的调用。

6、传递函数（函数对象的引用和函数对象的调用）

当对一个对象赋值时，世纪时将相同对象的引用复制给这个变量，如果这个对象是一个函数时，这个对象所有的别名都是可调用的。
eg:

>>> def foo():
...     print 'in foo()'
...
>>> bar = foo #实际上是bar和foo引用了同一个函数对象，foo是函数对象的引用
>>> foo()   #foo()是函数对象的调用
in foo()
>>> bar()
in foo()
>>>
>>> def bar(argfunc):   #传入的参数：argfunc就是函数对象foo
...     argfunc()   #()双圆括号是函数调用的操作符，函数调用
...
>>> bar(foo)
in foo()

7、默认参数

实际上就是定义函数时允许设定默认的参数，如下例中的rate=0.0825.

>>> def taxMe(cost, rate=0.0825):
...     return cost + (cost * rate)
...
>>> taxMe(100)
108.25
>>> taxMe(100, 0.05)
105.0

切记:所有必须的参数都要在默认参数之前，也就是说默认参数在最后。这是强制规定。

>>> def taxMe(cost = 100, rate):
...     return cost + (cost * rate)
...
  File "<stdin>", line 1
SyntaxError: non-default argument follows default argument

8、可变长度的参数

• 非关键字可变长参数参数（元组）
  函数调用时可以接受一个非固定数目的参数，其使用元组的方式。
  可变长参数元组必须在位置和默认参数之后，且使用星号操作符，*（星号操作符）之后的形参座位元组传递给函数，元组保存了所有的传递给函数的额外的参数，如果没有给出额外的参数，那么元组为空。

>>> def test(arg1, arg2 = 'default', *args):
...     print 'arg1 ——>> ', arg1
...     print 'arg2 ——>> ', arg2
...     for each in args:
...             print 'another arg ——>> ', each
...
>>> test('abc')
arg1 ———>>  abc
arg1 2— —  default
>>> test('abc', '123')
arg1 ———>>  abc
arg1 2— —  123
>>> test('abc', '123', 'def', 456)
arg1 ———>>  abc
arg1 2— —  123
another arg ——>>  def
another arg ——>>  456

• 关键字变量参数（字典）
  与非关键字可变长参数参数（元组）类似，只不过换成了**表示了。依然放在最后面,在存在元组的情况下依然在最后。

>>> def test(arg1, arg2 = 'default', **args):
...     print 'arg1 -->> %s' % arg1
...     print 'arg2 -->> %s' % arg2
...     for each in args:
...             print '%s -->> %s' % (each, args[each])
...
>>> test(123, 456, a=789)
arg1 -->> 123
arg2 -->> 456
a -->> 789
>>> test(123, 456, a=789, b=101112)
arg1 -->> 123
arg2 -->> 456
a -->> 789
b -->> 101112
>>> test(123, 456, a=789, b=101112, c='abcdefg')
arg1 -->> 123
arg2 -->> 456
a -->> 789
c -->> abcdefg
b -->> 101112

元组和字典参数共同存在的情况下：

>>> def test(arg1, arg2 = 'default', *argt, **args):
...     print 'arg1 -->> %s' % arg1
...     print 'arg2 -->> %s' % arg2
...     for each in argt:
...             print 'Tuple -->> %s' % each
...     for each in args:
...             print '%s -->> %s' % (each, args[each])
...
>>> test(123, 456, 789, dict='abc')
arg1 -->> 123
arg2 -->> 456
Tuple -->> 789
dict -->> abc
>>> test(123, 456, 789, 'abc', dict1='abc', dict2=135)
arg1 -->> 123
arg2 -->> 456
Tuple -->> 789
Tuple -->> abc
dict1 -->> abc
dict2 -->> 135

• 调用带有可变长参数对象函数
  我们将非关键字参数放在元组中，将关键字参数放在字典中。

>>> def test(arg1, arg2 = 'default', *argt, **args):
...     print 'arg1 -->> %s' % arg1
...     print 'arg2 -->> %s' % arg2
...     for each in argt:
...             print 'Tuple -->> %s' % each
...     for each in args:
...             print '%s -->> %s' % (each, args[each])
...
>>>
>>>
>>> test(10, 20, 30)
arg1 -->> 10
arg2 -->> 20
Tuple -->> 30
>>> test(10, 20, 30, 40)
arg1 -->> 10
arg2 -->> 20
Tuple -->> 30
Tuple -->> 40
>>> test(10, 20, 30, 40, foo=50)
arg1 -->> 10
arg2 -->> 20
Tuple -->> 30
Tuple -->> 40
foo -->> 50
>>> test(10, 20, 30, 40, foo=50, bar=60)
arg1 -->> 10
arg2 -->> 20
Tuple -->> 30
Tuple -->> 40
foo -->> 50
bar -->> 60
>>> test(10, 20, *(30, 40), **('foo':50, 'bar':60))     #字典使用{}花括号，元组使用()圆括号
  File "<stdin>", line 1
    test(10, 20, *(30, 40), **('foo':50, 'bar':60))
                                    ^
SyntaxError: invalid syntax
>>> test(10, 20, *(30, 40), **{'foo':50, 'bar':60})
arg1 -->> 10
arg2 -->> 20
Tuple -->> 30
Tuple -->> 40
foo -->> 50
bar -->> 60

此外，我们还可以在函数调用之外创建元组和字典：

>>> t = (30, 40)
>>> d = {'foo':50, 'bar':60}
>>> test(10, 20, *t, **d)
arg1 -->> 10
arg2 -->> 20
Tuple -->> 30
Tuple -->> 40
foo -->> 50
bar -->> 60

8、函数式编程

• 匿名函数和lambda
  lamdba 表达式运行起来就像一个函数，当被调用时，创建一个框架对象。
  语法格式：

lambda [arg1[, arg2, arg3,....argN]] : expression

示例：

>>> lambda x, y : x + y
<function <lambda> at 0x6ffffe276e0>

lambda 表达式可以用来赋值给一个如列表和元组的数据结构。

>>> n = lambda *z : z
>>> n('a', 'b')
('a', 'b')
>>> m = lambda **y : y.keys()
>>> m(a=123)
['a']
>>> m(a=123, b=456)
['a', 'b']
>>> p=lambda x : x + x
>>> p(1)
2
>>> p('a')
'aa'

• 内建函数filter()、map()、reduce()

1、filter()

filter()是一个过滤函数。

filter(func, seq) #func判断的布尔函数， seq需要过滤的序列

调用一个布尔函数func来迭代遍历每个seq中的元素，返回一个使func返回值为true的元素的序列。
eg:

>>> def tell(x):
...     return x % 2
...
>>> filter(tell, range(10))
[1, 3, 5, 7, 9]
#   可以与lambda表达式结合
>>> filter(lambda x:x%2, range(10))     
[1, 3, 5, 7, 9]
# 更简单的过滤方法
>>> [x for x in range(10) if x % 2]
[1, 3, 5, 7, 9]

2、map()

实际上就是一个针对所有的数据进行遍历的函数。

map(func, seq)  

eg:

>>> map((lambda x: x+3), range(10))
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
>>> def foo(x, y):
...     return x+y
...
>>> map(foo, range(10), range(10))      #这里的func是foo而不是foo(),这点要特别注意，在之前的笔记中有提到，foo是函数的引用，foo()是函数对象的调用，这里只能是引用，函数对象的调用需要有参数，如果你执行调用会报错
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
>>> map((foo(x, y)), range(10), range(10))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'y' is not defined
# 使用函数对象的调用会报错

3、reduce()

语法格式：

reduce(func, seq[, init])

将二元函数作用于seq序列的元素，每次携带一对（先前的结果以及下一个序列元素），连续地将现有的结果和下一个之作用在获得的随后的结果上，最后减少我们的序列为一个单一的返回值；如果返回值init给定，第一个比较会是init和第一个序列元素而不是序列的头两个元素。

reduce()实际上就是一个迭代器，对seq进行逐个迭代，其中前两个作为初始值。从seq[]中依此选择两个值传入func函数，得出新的结果，并将seq中被选择的两个数值替换为新的结果，然后重复上述过程，直至结束。典型的例子就是数列求和：

#求[0, 1, ..., 9]的和：
>>> reduce((lambda x, y : x + y), range(10))
45

9、偏函数

好吧，实际上我也不是很懂。。。。。。。。。。。。。。。

>>> from operator import add, mul
>>> from functools import partial
# 泛化偏函数（PFA）使用partial，可以简化代码
>>> add1 = partial(add, 1)    # add1(x) == add(1, x)
>>> mul100 = partial(mul, 100)    #mul100(x) == mul(100, x)
>>>
>>> add1(10)
11
>>> mul100(10)
1000

• 简单GUI

from functools import partial
import Tkinter

root = Tkinter.Tk()
MyButton = partial(Tkinter.Button, root, fg='white', bg='blue')
# MyButton(x) == TKinter.Button(root, fg='white', bg='blue', x)
b1 = MyButton(text='Button1')
b2 = MyButton(text='Button2')
qb = MyButton(text='QUIT', bg='red', command=root.quit)

b1.pack()
b2.pack()
qb.pack(fill=Tkinter.X, expand=True)
root.title('PFAs!')
root.mainloop()

运行截图：

10、变量作用域

• 全局变量和局部变量
  定义在函数内的变量有局部作用域，在一个模块中的最高级的变量有全局作用域。
  全局变量的一个特征就是除非被剔除掉，否则它们会存活到脚本运行结束，且对于所有的函数，他们的值都是可以被访问的。而局部变量，仅仅是暂时存在的，只依赖于定义他们的函数现阶段是否处于活动。当一个函数调用出现时，其局部变量就进入声明他们的作用域。在那一刻，一个新的局部变量名为那个对象创建了，一旦函数完成，框架被释放，变量就会离开作用域。

• global 语句
  如果将全局变量的名字声明在一个函数体内的时候，全局变量的名字能被局部变量给覆盖掉。

>>> is_this_global = 'xyz'
>>> def  foo():
...         this_is_local = 'abc'
...         is_this_global = 'def'  #局部变量覆盖了全局变量
...         print this_is_local + is_this_global
...
>>> foo()
abcdef

为了明确地引用一个已经命名的全局变量，必须使用global语句。

global var1[, var2, ..., varN]

>>> is_this_global = 'xyz'
>>> def  foo():
...         global is_this_global
...         this_is_local = 'abc'
...         is_this_global = 'def'
...         print this_is_local + is_this_global
...
>>> foo()
abcdef

• 闭包
  在一个内部函数内，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包(closure)。
  定义在外部函数内但由内部函数引用或者使用的变量称为自由变量。
  故闭包所满足的条件是：

1. 必须有一个内嵌函数
2. 内嵌函数必须引用外部函数中的变量
3. 外部函数的返回值必须是内嵌函数

>>> def counter(start_at=0):
...     count = [start_at]
...     def incr():
...             count[0] += 1
...             return count[0]
...     return incr
...
>>> count = counter(5)
>>> count()
6
>>> count()
7
>>> count2 = counter(25)
>>> count2()
26
>>> count2()
27
>>> count3 = counter(5) # 每次调用counter()都会返回一个新的函数，即使传入相同的参数也是不同。
>>> count == count3
False

11、生成器

• 1、yield 是一个关键字。带有yield的函数不再是一个函数，而是一个生成器，可用于迭代。其迭代的关键是next()方法，工作原理就是通过重复调用next()方法，直至捕捉一个异常。
• 2、yield是一个类似return的关键字，迭代一次返回yield后面的值（yield后面也可以是一个函数的调用或者表达式），然后脚本就会在这里停止，当再次迭代后，从下一行开始。
• 3、yield是类似return一样返回一个值，如果yield和它后面的值被赋值给其他变量，那么这个新的变量就是None，除非是用send()方法才能将yield后面的值赋给新的变量。
• 4、第一次调用时必须先next()或者send(None),否则会报错。

>>> def g():
...     print '1'
...     x = yield 'hello'
...     print '2', 'x = ', x
...     y = 5 + (yield x)
...     print '3', 'y = ', y
...
>>> f = g()
>>> f.send(2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't send non-None value to a just-started generator
>>> f.send(None)
1
'hello'

示例代码过程解读：

# next()方法
>>> def g():
...     print '1'
...     x = yield 'hello'
...     print '2', 'x = ', x
...     y = 5 + (yield x)
...     print '3', 'y = ', y
...
>>> f = g()
>>> f.next()  #第一次迭代时[yield 'hello']返回['hello']，并赋值x为None，程序执行进程停止
1
'hello'
>>> f.next()    #第二次迭代，从第一次停止的下一行开始，从输出可以看出x的值为None
2 x =  None

# send()方法
>>> def g():
...     print '1'
...     x = yield 'hello'
...     print '2', 'x = ', x
...     y = 5 + (yield x)
...     print '3', 'y = ', y
...
>>> f = g()
>>> f.next()
1
'hello'
>>> f.send(5)   #send()方法会重置第一次迭代的yield，并重新赋值为send传递的新值，而且此时x会被赋值为新的值，且程序将向下执行，直到遇见新的yield。
2 x =  5
5
>>> f.send(2)   # 上次使用send()方法后yield x返回5，并在此处停止，在send(2)后，重置(yield x)为新值2.
3 y =  7
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration