python基础补漏3

python基础补漏系列（三）

高级特性

切片、迭代、列表生成式、生成器、迭代器、函数式编程、map/reduce、filter、sorted、返回函数、

列表生成式

列表生成式即 List Comprehensions，是 Python 内置的非常简单却强大的可以用来创建 list 的生成式。

#列举几个转换例子
1.生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

list(range(1, 11))

2.[1x1, 2x2, 3x3, ..., 10x10]
[x * x for x in range(1, 11)]

3.2的基础上筛选出仅偶数的平方
[x * x for x in range(1, 11) if x % 2 == 0]

4.生成全排列
[m + n for m in 'ABC' for n in 'XYZ']

5.列出当前目录下的全部文件和目录名
[d for d in os.listdir('.')] # os.listdir 可以列出文件和目录

6.列表生成式也可以使用两个变量来生成 list（dict的items()可以同时迭代key和value）
>>> d = {'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']

7.把一个 list 中所有的字符串变成小写
>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']

生成器

列表确实很好，但是如果我们需要的一个列表在实际使用的过程中，我们只需要前面一小部分的内容，但是又需要使用它，由此需要生成很大的一个列表，那么回产生巨大的内存浪费，甚至超过内存限制。

python中存在一个机制，可以将某个可按照算法推算出来的列表压缩通过一边循环一边计算的方法创建不完整的list从而节省大量的空间。我们称之为生成器，generator。

创建生成器的方式和列表生成器的创建方式只是外面的括号不同而已，列表生成器是[]，生成器是()。

#生成器的操作
1.打印list的元素
    1）通过next()函数：
    >>> next(g)
    0
   
    2）通过for循环

2.定义生成器的另一种方法
	通过函数定义中包含关键字yield （有点像临时中断返回值）
	def fib(max):
        n, a, b = 0, 0, 1
        while n < max:
            yield b
            a, b = b, a + b
            n = n + 1
        return 'done'

	>>> f = fib(6)
    >>> f
    <generator object fib at 0x104feaaa0>
    
    >>> for n in fib(6):
    ... print(n)
    ...
    1
    1
    2 
    3
    5
    8

#练习编写杨辉三角形
def triangles():
    L = [1]
    while True:
        yield L
        L = [sum(i) for i in zip([0] + L, L + [0])]
        
def triangles():
    ret = [1]
    while True:
        yield ret
        for i in range(1, len(ret)):
            ret[i] = pre[i] + pre[i - 1]
        ret.append(1)
        pre = ret[:]
        
if __name__ == '__main__':
    n = 0
    for t in triangles():
        print(t)
        n = n + 1
        if n == 10:
            break

迭代器

我们把可以直接作用于 for 循环的对象统称为可迭代对象：Iterable。

可以被 next()函数调用并不断返回下一个值的对象称为迭代器：Iterator

其中包括

一类是集合数据类型，如 list、tuple、dict、set、str 等；
一类是 generator，包括生成器和带 yield 的 generator function。

生成器都是 Iterator 对象，但 list、 dict、 str 虽然是 Iterable，却不是Iterator。

我们可以通过isinstance去判断对象是否是iterable、Iterator对象。

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance([], Iterator)
False

我们可以通过iter()函数把 list、dict、str 等 Iterable 变成 Iterator 。

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

为什么可迭代对象不一定是迭代器

Python 的 Iterator 对象表示的是一个数据流，Iterator 对象可以被 next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration 错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过 next()函数实现按需计算下一个数据，所以 Iterator 的计算是惰性的，只有在需要返回下一个数据时它才会计算。Iterator 甚至可以表示一个无限大的数据流，例如全体自然数。而使用list 是永远不可能存储全体自然数的。

for循环实现方式

Python 的 for 循环本质上就是通过不断调用 next()函数实现。

for x in [1, 2, 3, 4, 5]:
pass
实际上完全等价于：
# 首先获得 Iterator 对象:
it = iter([1, 2, 3, 4, 5]) 
# 循环:
while True:
	try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到 StopIteration 就退出循环
        break	

函数式编程

高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数

编写高阶函数，就是让函数的参数能够接收别的函数。

def add(x, y, f):
	return f(x) + f(y) 

当调用add(-5, 6, abs)。

x = -5
y = 6
f = abs
f(x) + f(y) ==> abs(-5) + abs(6) ==> 11
return 11

map

map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

例
>>> def f(x):
... return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

说明：map()传入的第一个参数是 f，即函数对象本身。由于结果 r 是一个
Iterator， Iterator 是惰性序列，因此通过 list()函数让它把整个序列都
计算出来并返回一个 list。

reduce

reduce 把一个函数作用在一个序列[x1, x2, x3, …]上，这个函数必须接收两个参数，reduce 把结果继续和序列的下一个元素做累积计算。

效果：reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

#例
>>> from functools import reduce
>>> def add(x, y):
...    return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25


>>> from functools import reduce
>>> def fn(x, y):
... return x * 10 + y
...
>>> def char2num(s):
... return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, 
'7': 7, '8': 8, '9': 9}[s]
...
>>> reduce(fn, map(char2num, '13579'))
13579

from functools import reduce
def char2num(s): 
	return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
def str2int(s):
	return reduce(lambda x, y: x * 10 + y, map(char2num, s))

练习1：利用 map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']：

def normalize(name):
        name=name.title()
        print (name)
if __name__ == '__main__':
    L1 = ['adam', 'LISA', 'barT']
    L2 = list(map(normalize, L1))
    print(L2)

练习2：
def time(x,t):
    return x*t
def prod(L):
    return reduce(time,L)
if __name__ == '__main__':
    print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9]))

filter

Python 内建的 filter()函数用于过滤序列，和 map()类似， filter()也接收一个函数和一个序列。和 map()不同的时，filter()把传入的函数依次作用于每个元素，然后根据返回值是 True 还是 False 决定保留还是丢弃该元素。

filter()这个高阶函数，关键在于正确实现一个“筛选”函数。

filter()函数返回的是一个 Iterator，也就是一个惰性序列，所以要强迫 filter()完成计算结果，需要用 list()函数获得所有结果并返回 list。

#过滤掉非回数
def is_palindrome(n):
    n=str(n)
    while n==n[::-1]:
        return n
if __name__ == '__main__':
    output = filter(is_palindrome, range(1, 1000))
    print(list(output))

sorted

Python 内置的 sorted()函数就可以对 list 进行排序：

>>> sorted([36, 5, -12, 9, -21])
[-21, -12, 5, 9, 36]

sorted()函数是一个高阶函数，它可以接收一个 key 函数来实现自定义的排序，例如按绝对值大小排序：

>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]

此外，sorted还有第三个参数，reverse。可以进行反向排序。

L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
#按名字排序：
def by_name(t):
    return t[0]
#按成绩
def by_score(t):
    return t[1]

if __name__ == '__main__':
    L2 = sorted(L, key=by_name)
    print(L2)

返回函数

#示例1
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

需要注意一点，通过返回函数赋予的变量，两次执行会产生全新的环境，彼此相互的调用的结果互不影响。

>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2
False

闭包

注意到返回的函数在其定义内部引用了局部变量 args，所以，当一个函数返回了一个函数后，其内部的局部变量还被新函数引用。

返回的函数并没有立刻执行，而是直到调用了 f()才执行。

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

结果
>>> f1()
9
>>> f2()
9
>>> f3()
9

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

调用返回的函数的时候，这个函数是还未执行的，所以如果返回函数中引用了任何可能变化的变量可能会产生“奇妙”的效果。

匿名函数

当我们在传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。

关键字 lambda 表示匿名函数，冒号前面的 x 表示函数参数。

例：
>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]

匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：

>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x101c6ef28>
>>> f(5)
25

#也可以把匿名函数作为返回值返回
def build(x, y):
return lambda: x * x + y * y

装饰器

函数对象可以被赋值给变量，函数对象有一个__name__属性可以获取到函数的名字，可以对赋予函数的变量使用查看函数名。

>>> def now():
... print('2015-3-25')
...
>>> f = now
>>> f()
2015-3-25
>>> now.__name__
'now'
>>> f.__name__
'now'

但是，如果此时，我们希望调用now的时候能自动干一些别的事情，但是又不希望修改now函数的定义，这种在代码运行期间动态增加功能的方式称为“装饰器”。

示例一个装饰器（简要说明就是一个返回函数的高阶函数）：

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

#调用方法：借助 Python 的@语法，把 decorator 置于函数的定义处：
@log
def now():
    print('2015-3-25')
    
#执行
>>> now()
call now():
2015-3-25

把@log 放到 now()函数的定义处，相当于执行了语句：now = log(now)

上述内容的高阶版本：

#定义
def log(text): 
    def decorator(func):
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

#decorator 用法
@log('execute')
def now():
    print('2015-3-25')

#执行
>>> now()
execute now():
2015-3-25

#三层嵌套的逻辑
now = log('execute')(now)
->首先执行 log('execute')，返回的是decorator函数，再调用返回的函数，参数是now函数，返回值最终是wrapper函数。

上面的修饰可以实现相关的作用，但是按照上述方法经过修饰的函数，他们的__name__等属性会变化，这会对一些需要使用这些属性的函数、语句产生一些错误。我们需要依旧将这些属性复制过去，而方法在python内置的functools.wraps中已经实现。

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

#针对参数
import functools
def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
    return wrapper
return decorator

请编写一个 decorator，能在函数调用的前后打印出'begin call'和'end call'的日志。
再思考一下能否写出一个@log 的 decorator，使它既支持：
@log
def f():
    pass
又支持：
@log('execute')
def f():
    pass

第一版支持
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/12/25 19:29
# @Author  : F4sthand
# @File    : test.py
from math import *
import functools

def log(func):
    @functools.wraps(func)
    def wrapper(*args,**kw):
        print('begin call %s()' % func.__name__)
        X=func(*args,**kw)
        print('end call %s()' % func.__name__)
        return X
    return wrapper
@log
def now():
    print('2021-1-20')

if __name__ == '__main__':
    now()

第二版支持
def log(text):
    def decorator(func):
        #@functools.wraps(func)
        print('%s %s' % (text,func.__name__))
        def wrapper(*args,**kw):
            print('begin call %s()' % func.__name__)
            X=func(*args,**kw)
            print('end call %s()' % func.__name__)
            return X
        return wrapper
    return decorator if isinstance(text,str) else decorator(text)

@log('execute')
def now():
    print('2021-1-20')

if __name__ == '__main__':
    now()

偏函数

偏函数的作用就是将一个函数的某些参数固定住，不需要每次边写该函数的时候都需要设定一遍参数的值。

实现方法是使用functools.partial实现

eg：
>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85

当函数的函数个数太多，需要简化的时候，就需要使用functools.partial进行创建一个新函数，使得调用得以简化。