python-07

一、函数

引用：例，定义一个foo函数，然后让bar引用foo 

>>> def foo(): print 'hello world!'
... 
>>> bar = foo
>>> bar()
hello world!
>>> foo()
hello world!

二、关键字参数

例：func1需要有一个参数，该参数必须提供，否则出现异常

>>> def func1(x):
...      print '
KeyboardInterrupt
>>> def func1(x): print '*' * x
... 
>>> func1()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: func1() takes exactly 1 argument (0 given)
>>> func1(5)
*****

例2：如何提供了多个值，这些值将依次传递给每个参数。值的数目要求和参数否则仍然有错误。

>>> def func2(x, y): print x * y
... 
>>> func2(3, 4)
12
>>> func2('#', 4)
####

三、默认参数

在默认值的参数不能出现在没有默认值的参数之前。

例子中，只提供一个值，该值赋值给name, age使用默认值： 如何提供了两个值，第二个值将会赋值给age

>>> def func3(name, age = 7): print '%s: %d' % (name, age)
... 
>>> func3('tom')
tom: 7
>>> func3('tom', 8)
tom: 8

例2：如何提供了多个默认值，那么在调用函数的时候，值依次传入给每个参数。如果想跳过对某一个默认参数的赋值，直接为下一个参数赋值，那么要写明到底是把值赋值给哪个参数

>>> def hosts(name, port): print '%s listen on %s' % (name, port)
... 
>>> hosts('http', 80)
http listen on 80
>>> hosts(80, 'http')
80 listen on http
>>> hosts(port = 80, name = 'http')
http listen on 80

四、参数个数未知的函数定义

>>> def func5(*args):
...     for i in args:
...         print i
... 
>>> func5()
>>> func5('abcd')
abcd
>>> func5('abcd', 'efg', 7)
abcd
efg
7

五、使用字典接收参数

>>> def func6(**kwargs):
...     for i in kwargs:
...         print '%s: %s' % (i, kwargs[i])
... 
>>> func6()
>>> func6(name = 'bob', age = 10)
age: 10
name: bob

六、元组、字典结合使用       注意：在使用的时候，需把元组放在前面，字典放在后面

>>> def func7(*a, **b):
...     for i in a:
...         print i
...     for m, n in enumerate(b):
...         print '%s: %s' % (m, n)
... 
>>> func7('hello', 'tom', host = 'servera', port = 80)
hello
tom
0: host
1: port

综合练习

#!/usr/bin/env python
from operator import add, sub
from random import randint, choice
ops = {'+': add, '-': sub}
maxtries = 2
def doprob():
    op = choice('+-')
    nums = [randint(1,10) for i in range(2)]
    nums.sort(reverse = True)
    ans = ops[op](*nums)
    pr = '%d %s %d = ' % (nums[0], op, nums[1])
    oops = 0
    while True:
        try:
            if int(raw_input(pr)) == ans:
                print 'correct'
                break
            if oops == maxtries:
                print 'answer
%s%d' % (pr, ans)
                break
            else:
                print 'incorrect... try again'
                oops += 1
        except (KeyboardInterrupt, EOFError, ValueError):
            print 'invalid input... try again'
def main():
    while True:
        doprob()
        try:
            opt = raw_input('Again? [y]').lower()
            if opt and opt[0] == 'n':
                break
        except (KeyboardInterrupt, EOFError):
            break
if __name__ == '__main__':
    main()

八、变量的作用域

#!/usr/bin/env python
x = 10
def foo():
    print x
foo()

#!/usr/bin/env python
x = 10
def foo():
    x = 5
    print 'x=', x
foo()

以上程序执行，打印出来的x值是5。如果函数内有一个和全局同名的变量，那么函数内的变量将会覆盖全局变量

九、global语句

#!/usr/bin/env python
x = 10
def foo():
    x = 5
    print 'x=', x
foo()
print x

最终打印出来x的值仍然是10。如果需要真正的在函数内部将全部变量的值修改。那么执行以下程序：

#!/usr/bin/env python
x = 10
def foo():
    global x
    x = 5
foo()
print x

程序执行时，打印出来x的值是5

十、lambda匿名函数

#!/usr/bin/env python
def a(x, y):
    return x + y
print a(3, 4

可以使用lamdba简化为：

#!/usr/bin/env python
a = lambda x, y: x + y
print a(3, 4)

过滤一个列表，只把奇数留下来： 

#!/usr/bin/env python
alist = [23, 33, 22, 433, 55, 44]
def func1(num):
    if num % 2 == 1:
        return True
    else:
         return False
blist = filter(func1, alist)
print blist

使用lambda替换：

#!/usr/bin/env python
alist = [23, 33, 22, 433, 55, 44]
blist = filter(lambda num: num % 2, alist)
print blist

对一个列表实现累加，返回最好终结果：

#!/usr/bin/env python
alist = [1, 44, 2, 55]
def add(x, y):
    return x + y
result =reduce(add, alist)
print result

使用lamdba实现：

#!/usr/bin/env python
alist = [1, 44, 2, 55]
result = reduce(lambda x, y : x + y, alist)
print result

来自为知笔记(Wiz)