Python之学习笔记（函数）

闭包，匿名函数等等

函数的基本使用

# -*- coding: utf-8 -*-
import math

def add_end(L=None):#add_end(L=[]):
    L.append('END')
    return L

a = add_end([1, 2, 3])
print a
'''
1、对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，
无论它的参数是如何定义的。
2、对于函数的使用，参数顺序有：必选参数、默认参数、可变参数和关键字参数。
3、例子
>>> func(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> func(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> func(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> func(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
4、深化
默认参数一定要用不可变对象，如果是可变对象，运行会有逻辑错误！
要注意定义可变参数和关键字参数的语法：
*args是可变参数，args接收的是一个tuple；
**kw是关键字参数，kw接收的是一个dict。
以及调用函数时如何传入可变参数和关键字参数的语法：
可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过*args传入：func(*(1, 2, 3))；
关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过**kw传入：func(**{'a': 1, 'b': 2})。
使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法。
使用递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出。
针对尾递归优化的语言可以通过尾递归防止栈溢出。尾递归事实上和循环是等价的，
没有循环语句的编程语言只能通过尾递归实现循环。
Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。

'''


'''
def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s


def enroll(name,gender,age = 6,city = 'BeiJing'):
    print 'name:',name
    print 'gender:',gender
    print 'age:',age
    print 'city:',city

print power(5)
enroll('ChenYu','M')

def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

r = move(100, 100, 60, math.pi / 6)
print r

print u"输入名字："
name = raw_input()
print 'hello,',name
a = int(raw_input(u'请输入一个整数'))
print 'This is used for %s %d' % ('test',a)
print u"循环的使用for和while："
sum = 0
for x in [1,2,3,4,5,6,7,8,9,10]:
    sum = sum + x
print sum
print range(5)
sum = 0
n = 99
while  n > 0:
    sum = sum + n
    n = n -2
print sum

print u'字典的使用:'
d = {'Michael':95,'Bob':75,'Y=Tracy':69}
print d['Michael']
'''

'''
定义函数时，需要确定函数名和参数个数；

如果有必要，可以先对参数的数据类型做检查；

函数体内部可以用return随时返回函数结果；

函数执行完毕也没有return语句时，自动return None。

函数可以同时返回多个值，但其实就是一个tuple。
'''
def my_cmp(x,y):
    if not isinstance(x,(int, float)):
        raise TypeError('bad operand type')
    if not isinstance(y,(int, float)):
        raise TypeError('bad operand type')
    if x > y:
        return True
    elif x < y:
        return False
    else:
        return 0

def nop():
    pass

a = my_cmp(1,2.0)
print a

匿名函数等高级方法

# -*- coding: utf-8 -*-

import functools

def calc_sum(*args):
    ax = 0
    for n in args:
        ax = ax + n
    return ax

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

f = lazy_sum(1,3,4,5)
print f
print f()

# 闭包
# 函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，
# 当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，
# 这种称为“闭包（Closure）”的程序结构拥有极大的威力。
# 请再注意一点，当我们调用lazy_sum()时，每次调用都会返回一个新的函数，即使传入相同的参数：
# 返回函数不要引用任何循环变量，或者后续会发生变化的变量。
def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()


def count():
    fs = []
    for i in range(1, 4):
        def f(j):
            def g():
                return j*j
            return g
        fs.append(f(i))
    return fs

# 对于匿名函数的使用如下：
# 关键字lambda表示匿名函数，冒号前面的x表示函数参数。
# 匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。
# 用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。
# 此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：
f = lambda x: x * x
print f
print f(5)

def build(x,y):
    return lambda:x*x + y*y
#print build
#print build(2,3)

# 由于函数也是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用该函数。
def now():
    print '2015-5-30'
f = now
f()
#print now.__name__
#print f.__name__

def log(func):
    def wrapper(*args,**kw):
        print 'call %s()' % func.__name__
        return func(*args,**kw)
    return wrapper

# 观察上面的log，因为它是一个decorator，所以接受一个函数作为参数，并返回一个函数。
# 我们要借助Python的@语法，把decorator置于函数的定义处

# 装饰器：假设我们要增强now()函数的功能，比如，在函数调用前后自动打印日志，
# 但又不希望修改now()函数的定义，这种是代码运行期间动态增加功能的方式
@log 
def now_2():
    print '2015'
now_2()
# print now_2()

# 偏函数的使用
# 自定义int2（）
# functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，
# 可以直接使用下面的代码创建一个新的函数int2
def int2(x,base = 2):
    return int(x,base)
# 把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。

# 注意到上面的新的int2函数，仅仅是把base参数重新设定默认值为2，但也可以在函数调用时传入其他值
# functools.partial()是进行函数封装的一种方法
print int2('10000')

int2_2 = functools.partial(int,base = 2)
print int2_2('10000')