python高级特性+函数式编程

函数参数

1.可变参数

def print_args(*args):
	print(args)
print_args(1,2,3,4)
#结果：1 2 3 4

2.关键字参数(两种方法)

def print_args(**args):
	print(args)
print_args(name='adam',age=12,ID = '123456')
#结果：{'name': 'adam', 'age': 12, 'ID': '123456'}

_args = {'name': 'adam', 'age': 12, 'ID': '123456'}
print_args(**_args)
#结果：{'name': 'adam', 'age': 12, 'ID': '123456'}

迭代器

1.利用for迭代（可迭代：）任何可以迭代的对象（srt,dict,list）

_args = {'name': 'adam', 'age': 12, 'ID': '123456'}
for i in _args:
    print(i)
结果：
name
age
ID

2.dict迭代

_args.items()
结果：dict_items([('name', 'adam'), ('age', 12), ('ID', '123456')])

_args.keys()
结果：dict_keys(['name', 'age', 'ID'])

_args.values()
结果：dict_values(['adam', 12, '123456'])

3.迭代处理（enumerate）

>>> for i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C

4.生成器（yield）

def triangles():
    L=[1]
    while True:
        yield L
        L = [1]+[L[x]+L[x+1] for x in range(len(L)-1)]+[1]
for x,y in enumerate(g()):
     if(x==10):
         break
     print(y)
结果：
[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]
[1, 7, 21, 35, 35, 21, 7, 1]
[1, 8, 28, 56, 70, 56, 28, 8, 1]
[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]

L = [x for x in range(10)]
print(L)
结果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> g = (x * x for x in range(10))
>>> for n in g:
...     print(n)
... 
0
1
4
9
16
25
36
49
64
81

map/reduce(被移除，目前位于：from functools import reduce)

1.map接受两个参数（function，iter），将可迭代的对象的每一个迭代元素，生成新的元素。

L= [1, 9, 36, 84, 126, 126, 84, 36, 9, 1]
def up(x):
    return x+1
list(map(up,L))
结果：[2, 10, 37, 85, 127, 127, 85, 37, 10, 2]

2.reduce(function,iter)作用类似于求和,以指定的函数方法进行求和。

filter 过滤元素

L= [1, 9, 36, 84, 126, 126, 84, 36, 9, 1]
def check(x):
	return x%2==0
list(filter(check,L))
结果：[36, 84, 126, 126, 84, 36]

sorted排序

#reverse=True是否逆序，keys指定用于排序的值
X = {"name":12,"HH":1,"AA":15,"BB":5,"CC":3}
def AB(x):
     return x[-1]
sorted(X.items(),key=AB)
结果：[('HH', 1), ('CC', 3), ('BB', 5), ('name', 12), ('AA', 15)]

返回函数

将函数作为返回值。

def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
    return fs
>>> f1, f2, f3 = count()
>>> f1()
1
>>> f2()
4
>>> f3()
9

可以在闭包函数中使用nonlocal 修饰全局变量取消其全局性。
关于global，nonlocal，local的使用

lambda匿名函数

list(filter(lambda n:n%2, range(1, 20)))
结果：[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

装饰器

动态扩展已经定义好的函数，简单来说就是函数嵌套函数。

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

上面的代码就对func函数进行的装饰（扩展），返回为扩展后的函数方法。

偏函数

小知识：int(str,base=?),可以将str按特定进制（base）转换为的整数。
类似于装饰器，可以说是其的简化版,其可以降低函数的调用难度
示例

def int2(x, base=2):
    return int(x, base)
>>> int2('1000000')
64
>>> int2('1010101')
85