(一)functools:管理函数的工具

import functools

'''
functools模块提供了一些工具来管理或扩展和其他callable对象,从而不必完全重写
'''

  

1.修饰符

from functools import partial

'''
functools模块提供的主要工具就是partial类,可以用来包装一个有默认参数的callable对象。
得到的对象本身就是callable,可以把它看作是原来的参数。
'''

# 举个栗子
def foo(name, age, gender):
    print(name, age, gender)

p = partial(foo, "mashiro", 16)
p("female")  # mashiro 16 female
'''
可以看到p相当于是已经绑定了name和age的foo函数,name我们在传参的时候只需要传入一个gender就可以了
这个函数的源码实现比较复杂,但是如果以简单的装饰器的方式实现就很清晰了
'''

def my_partial(f, name, age):
    def inner(gender):
        return f(name, age, gender)
    return inner

p = my_partial(foo, "satori", 16)
p("female")  # satori 16 female
'''
可以看到,当我调用my_partial(foo, "satori", 16)的时候,返回了inner函数
此时的p相当于是inner,当我再调用p("female")的时候,等价于调用inner("female")
然后将两次传入的参数,按照顺序组合起来传递给foo函数,如果不限制参数的话就是:
def my_partial(f, *args1, **kwargs1):
    def inner(*args2, **kwargs2):
        from collections import ChainMap
        args = args1 + args2
        kwargs = dict(ChainMap(kwargs1, kwargs2))
        return f(*args, **kwargs)
    return inner

所以一定要和原函数的参数顺序保持一致,如果我传入p = my_partial("mashiro", 16),此时"mashiro"会传给name,16传给age
我再调用p(name="xxx")的话,肯定会报错的
'''

  

from functools import partial
import functools

'''
默认情况下,partial对象没有__name__属性的,如果没有这些属性,那么被修饰的函数会很难调试。
'''

def foo():
    # fucking
    pass

print(foo.__name__)  # foo
p = partial(foo)
try:
    print(p.__name__)
except AttributeError as e:
    print(e)  # 'functools.partial' object has no attribute '__name__'

# 那么如何添加呢?首先增加到包装器的属性在WRAPPER_ASSIGNMENTS中定义,另外WRAPPER_UPDATES列出了要修改的值
print("assign:", functools.WRAPPER_ASSIGNMENTS)  # assign: ('__module__', '__name__', '__qualname__', '__doc__', '__annotations__')
print("update:", functools.WRAPPER_UPDATES)  # update: ('__dict__',)

# 添加,表示从原函数将属性赋值或增加到partial对象
functools.update_wrapper(p, foo)
print(p.__name__)  # foo

  

from functools import partial

'''
可以把partial看成是一个简单的装饰器,装饰器不仅可以装饰函数,还可以装饰类,只要是callable对象,说白了只要是能加上()的都可以
这就是Python的魅力,非常的动态。比如列表进行extend, 其实不仅仅可以extend一个列表,还可以是元组,甚至是字典,只要是iterable对象都可以。
'''

class A:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def print_info(self):
        print(f"name: {self.name}, age: {self.age}, gender: {self.gender}")

p = partial(A, "mashiro", 16)
a = p("female")  # 这两步等价于 a = A("mashiro", 16, "female")
a.print_info()  # name: mashiro, age: 16, gender: female

  

from functools import partial, partialmethod

'''
partial返回一个可以直接使用的callable,partialmethod返回的callable则可以用做对象的非绑定方法
'''

# 举个例子
def standalone(self):
    print(f"self = {self}")

class A:
    method1 = partial(standalone)
    method2 = partialmethod(standalone)

a = A()
try:
    a.method1()
except TypeError as e:
    # 由于standalone需要一个参数self,我们这里没有传,因此报错
    print(e)  # standalone() missing 1 required positional argument: 'self'

# 但是我们调用method2呢?
a.method2()  # self = <__main__.A object at 0x0000000002964588>
'''
得到了一个A的实例对象。
所以,partial在哪里调用时没有区别的,必须手动显示地传递,该是几个就是几个。
但是在类中如果使用partialmethod定义的话,那么在使用实例(a)调用的话,会自动将实例传进去。
'''

  

from functools import wraps

'''
我们在知道在使用装饰器装饰完函数的时候,属性会变。比如:
'''

def deco(func):
    def inner(*args, **kwargs):
        return func(*args, **kwargs)
    return inner

@deco
def foo():
    pass

# 函数从下到下执行,加上@deco等价于,foo = deco(foo) = inner,也就是说此时的foo不再是foo了,已经是inner了
print(foo.__name__)  # inner
# 那么如何在装饰的时候,还保证原来函数的信息呢

def deco(func):
    @wraps(func)  # 只需要加上这一个装饰器即可,会自动对所修饰的函数应用update_wrapper
    def inner(*args, **kwargs):
        return func(*args, **kwargs)
    return inner

@deco
def bar():
    pass

# 可以看到原来函数的信息并没有改变
print(bar.__name__)  # bar

  

2.比较

import functools

'''
在Python2中,类可以一个__cmp__()方法,它会根据这个对象小于、等于、或者大于所比较的元素而分别返回-1、0、1.
Python2.1中引入了富比较(rich comparision)的方法。
如:__lt__(),__gt__(),__le__(),__eq__(),__ne__(),__gt__()和__ge__(),可以完成一个比较操作并返回一个bool值。
Python3已经废弃了__cmp__()方法。
另外,functools提供了一些工具,从而能更容易地编写符合新要求的类,即符合Python3中新的比较需求。
'''

@functools.total_ordering
class A:
    def __init__(self, val):
        self.val = val

    def __eq__(self, other):
        return self.val == other.val

    def __gt__(self, other):
        return self.val > other.val

a1 = A(1)
a2 = A(2)
print(a1 < a2)

'''
这个类必须提供__eq__()和另外一个富比较方法的实现,这个修饰符会自动增加其余的方法。
'''

  

import functools

'''
由于Python3废弃了老式的比较函数,sort()之类的函数中也不再支持cmp参数。
对于使用了比较函数的较老的程序,可以使用cmp_to_key()将比较函数转换为一个比对键的函数,这个键用于确定元素在最终序列中的位置
'''

def compare_obj(a, b):
    if a < b:
        return -1
    elif a > b:
        return 1
    else:
        return 0

l = [1, 5, 2, 11, 2, 44, 54, 5, 1]

print(sorted(l, key=functools.cmp_to_key(compare_obj)))  # [1, 1, 2, 2, 5, 5, 11, 44, 54]

  

3.缓存

import functools

'''
lru_cache()修饰符将一个函数包装在一个"最近最少使用的"缓存中。函数的参数用来建立一个散列键,然后映射到这个结果。
后续调用如果有相同的参数,就会从这个缓存中获取值而不会再次调用这个函数。
这个修饰符还会为函数增加方法来检查缓存的状态(cache_info)和清空缓存(cache_clear)
'''

@functools.lru_cache()  # 里面可以执行参数maxsize,默认是128
def foo(a, b):
    print(f"foo({a} * {b})")
    return a * b

print("第一次调用")
for i in range(2):
    for j in range(2):
        foo(i, j)
print(foo.cache_info())

print("\n第二次调用")
for i in range(3):
    for j in range(3):
        foo(i, j)
print(foo.cache_info())

print("清除缓存")
foo.cache_clear()
print(foo.cache_info())

print("\n第三次调用")
for i in range(2):
    for j in range(2):
        foo(i, j)
print(foo.cache_info())
'''
第一次调用
foo(0 * 0)
foo(0 * 1)
foo(1 * 0)
foo(1 * 1)
CacheInfo(hits=0, misses=4, maxsize=128, currsize=4)

第二次调用
foo(0 * 2)
foo(1 * 2)
foo(2 * 0)
foo(2 * 1)
foo(2 * 2)
CacheInfo(hits=4, misses=9, maxsize=128, currsize=9)
清除缓存
CacheInfo(hits=0, misses=0, maxsize=128, currsize=0)

第三次调用
foo(0 * 0)
foo(0 * 1)
foo(1 * 0)
foo(1 * 1)
CacheInfo(hits=0, misses=4, maxsize=128, currsize=4)
'''
# 我们观察一下第二次调用,3 * 3应该是9次,为什么只有5次,因为第一次调用有4次执行过了,放到缓存里,因此不需要执行了

  

4.reduce

import functools

'''
reduce这个函数无需介绍,在Python2中是内置的,但是在Python3中被移到functools下面
'''
l = range(100)
print(functools.reduce(lambda x, y: x+y, l))  # 4950
print(functools.reduce(lambda x, y: x+y, l, 10))  # 4960
print(functools.reduce(lambda x, y: x+y, l, 100))  # 5050

l = [1, 2, 3, 4, 5]
print(functools.reduce(lambda x, y: x*y, l))  # 120

  

5.泛型函数

import functools

'''
在类似Python的动态类型语言中,通常需要基于参数的类型完成稍有不同的操作,特别是在处理元素列表与单个元素的差别时。
直接检查参数的类型固然很简单,但是有些情况下,行为差异可能被隔离到单个的函数中。
对于这些情况,functools提供了singledispatch修饰符来注册一组泛型函数,可以根据函数第一个参数的类型自动切换
'''

@functools.singledispatch
def myfunc(arg):
    print(f"default myfunc {arg}")

@myfunc.register(int)
def myfunc1(arg):
    print(f"myfunc1 {arg}")

@myfunc.register(list)
def myfunc2(arg):
    print(f"myfunc2 {arg}")

myfunc("string")  # default myfunc string
myfunc(123)  # myfunc1 123
myfunc(["1", "2"])  # myfunc2 ['1', '2']
'''
可以看到使用signledispatch包装的是默认实现,在未指定其他类型特定函数的时候就用这个默认实现。
然后使用包装的函数这里是myfunc,通过register(数据类型)进行注册,根据所传参数的类型,从而执行对应的函数
'''

  

(二)itertools:迭代器函数

1.合并和分解迭代器

import itertools

'''
chain函数可以接收多个可迭代对象(或者迭代器)作为参数,最后返回一个迭代器。
它会生成所有输入迭代器的内容,就好像这些内容来自一个迭代器一样。
类似于collections下的ChainMap,可以合并多个字典。chain可以合并多个可迭代对象
'''

c = itertools.chain([1, 2, 3], "abc", {"k1": "v1", "k2": "v2"})
print(c)  # <itertools.chain object at 0x00000000029745F8>
for i in c:
    print(i, end=" ")  # 1 2 3 a b c k1 k2

print()
# 还可以使用chain.from_iterable,参数接收多个可迭代对象组成的一个可迭代对象
c = itertools.chain.from_iterable([[1, 2, 3], "abc", {"k1": "v1", "k2": "v2"}])
for i in c:
    print(i, end=" ")  # 1 2 3 a b c k1 k2

# 函数zip则是把多个迭代器对象组合到一个元组中
name = ["古明地觉", "椎名真白", "雪之下雪乃"]
where = ["东方地灵殿", "樱花张的宠物女孩", "春物"]
z = zip(name, where)
print("\n", z)  # <zip object at 0x0000000001DC03C8>
print(list(z))  # [('古明地觉', '东方地灵殿'), ('椎名真白', '樱花张的宠物女孩'), ('雪之下雪乃', '春物')]

# zip英文意思是拉链,很形象,就是把对应元素给组合起来
# 但如果两者长度不一致怎么办?
name = ["古明地觉", "椎名真白", "雪之下雪乃", "xxx"]
where = ["东方地灵殿", "樱花张的宠物女孩", "春物"]
print(list(zip(name, where)))  # [('古明地觉', '东方地灵殿'), ('椎名真白', '樱花张的宠物女孩'), ('雪之下雪乃', '春物')]
# 可以看到,不一致的时候,当一方结束之后就停止匹配。

# 如果想匹配长的,那么可以使用zip_longest,这个函数不像zip一样是内置的,它在itertools下面
print(list(itertools.zip_longest(name, where)))  # [('古明地觉', '东方地灵殿'), ('椎名真白', '樱花张的宠物女孩'), ('雪之下雪乃', '春物'), ('xxx', None)]
# 可以看到没有的默认赋值为None了,当然我们也可以指定填充字符
print(list(itertools.zip_longest(name, where, fillvalue="你输入的是啥啊")))
# [('古明地觉', '东方地灵殿'), ('椎名真白', '樱花张的宠物女孩'), ('雪之下雪乃', '春物'), ('xxx', '你输入的是啥啊')]

# isslice返回一个迭代器,按照索引从迭代器返回所选择的元素
num = range(20)
# 从index=5的地方选到index=10(不包含)的地方
s = itertools.islice(num, 5, 10)
print(list(s))  # [5, 6, 7, 8, 9]
#  从开头选到index=5的地方
s = itertools.islice(num, 5)
print(list(s))  # [0, 1, 2, 3, 4]
# 从index=5的地方选择到index=15的地方,步长为3
s = itertools.islice(num, 5, 15, 3)
print(list(s))  # [5, 8, 11, 14]
'''
所以除了迭代器之外,
如果只传一个参数,比如5,表示从index=0选到index=5(不包含)的地方
如果传两个参数,比如5和10,表示从index=5选到index=10(不包含)的地方
如果传三个参数,比如5和10和2,表示从index=5选到index=10(不包含)的地方,步长为2
'''
# 那么支不支持负数索引呢?答案是不支持的,因为不知道迭代器有多长,除非全部读取,可是那样的话干嘛不直接转化为列表之后再用[:]这种形式呢?
# 之所以使用isslice这种形式,就是为了在不全部读取的情况下,也能选择出我们想要的部分,所以这种方式只支持从前往后,不能从后往前读。

# tee()函数根据一个原输入迭代器返回多个独立、和原迭代器一模一样的迭代器(默认为两个)
r = [1, 2, 3, 4, 5]
i1, i2 = itertools.tee(r)
print(list(i1))  # [1, 2, 3, 4, 5]
print(list(i2))  # [1, 2, 3, 4, 5]

  

2.转换输入

import itertools

'''
内置的map()函数返回一个迭代器,它对输入迭代器中的值调用一个函数并返回结果。
输入迭代中的元素全部被消费时,map()函数就会停止
'''
l = [1, 2, 3]
map_l = map(lambda x: str(x)+"a", l)
print(list(map_l))  # ['1a', '2a', '3a']

l1 = [(0, 5), (1, 6), (2, 7)]
'''
注意map里面的函数只能有一个参数,因此不可以写成以下格式
map_l1 = map(lambda x, y: x*y, l1)
但是可以这样
'''
map_l1 = map(lambda x: x[0]*x[1], l1)
print(list(map_l1))  # [0, 6, 14]

# 但是itertools下的startmap()是支持的
l2 = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
# 注意里面的函数的参数的参数个数是由我们后面传入对象决定的,这里每个元组显然有三个元素,所以需要三个参数
map_l1 = itertools.starmap(lambda x, y, z: f"{x} + {y} + {z} = {x+y+z}", l2)
print(list(map_l1))  # ['1 + 2 + 3 = 6', '4 + 5 + 6 = 15', '7 + 8 + 9 = 24']
# map的话只能通过lambda x: x[0], x[1], x[2]这样的形式
# starmap只能对类似于[(), (), ()]这种值进行处理,比如[1, 2, 3]使用starmap是会报错的,但是[(1, ), (2, ), (3, )]不会报错

  

3.生成新值

import itertools

'''
count(start=0, step=1)函数返回一个迭代器,该迭代器能够无限地生成连续的整数。
接收两个参数:起始(默认为0)和步长(默认为1)
等价于:
def count(firstval=0, step=1):
    x = firstval
    while 1:
        yield x
        x += step
'''

'''
cycle(iterable)返回一个迭代器,会无限重复里面的内容,直到内存耗尽
'''
c2 = itertools.cycle("abc")
print(list(itertools.islice(c2, 0, 10)))  # ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c', 'a']

'''
repeat(obj, times=None),无限重复obj,除非指定times。
'''
print(list(itertools.repeat("abc", 3)))  # ['abc', 'abc', 'abc']

  

4.过滤

import itertools

l = [1, 2, 3, 4, 5]
drop_l = itertools.dropwhile(lambda x: x < 3, l)
print(list(drop_l))  # [3, 4, 5]
take_l = itertools.takewhile(lambda x: x < 3, l)
print(list(take_l))  # [1, 2]
filter_l = filter(lambda x: x < 3, l)
print(list(filter_l))  # [1, 2]
filterfalse_l = itertools.filterfalse(lambda x: x < 3, l)
print(list(filterfalse_l))  # [3, 4, 5]
'''
filter和takewhile一样,过滤出条件为True的值
filterfalse和dropwhile一样,过滤出条件为False的值
'''

# compress则提供了另一种过滤可迭代对象内容的方法。
# 举个栗子
condition = [True, False, True, True, False]
data = [1, 2, 3, 4, 5]
print(list(itertools.compress(data, condition)))  # [1, 3, 4]
# 或者
condition = [1, 0, "x", "x", {}]
print(list(itertools.compress(data, condition)))  # [1, 3, 4]

  

5.合并输入

import itertools

'''
accumulate函数处理输入迭代器,得到一个类似于斐波那契的结果
'''
print(list(itertools.accumulate(range(5))))  # [0, 1, 3, 6, 10]
print(list(itertools.accumulate("abcde")))  # ["a", "ab", "abc", "abcd", "abcde"]
# 所以这里的相加还要看具体的含义

try:
    print(list(itertools.accumulate([[1, 2], (3, 4)])))
except TypeError as e:
    print(e)  # can only concatenate list (not "tuple") to list
    # 这里就显示无法将列表和元组相加

# 当然也可以自定义
data = [1, 2, 3, 4, 5]
method = lambda x, y: x*y
print(list(itertools.accumulate(data, method)))  # [1, 2, 6, 24, 120]
# 可以看到这里的结果就改变了

'''
product则是会将多个可迭代对象组合成一个笛卡尔积
'''
print(list(itertools.product([1, 2, 3], [2, 3])))  # [(1, 2), (1, 3), (2, 2), (2, 3), (3, 2), (3, 3)]

'''
permutations函数从输入迭代器生成元素,这些元素以给定长度的排列形成组合。默认会生成所以排列的全集
'''
data = [1, 2, 3, 4]
print(list(itertools.permutations(data)))
'''
[(1, 2, 3, 4), (1, 2, 4, 3), (1, 3, 2, 4), (1, 3, 4, 2), (1, 4, 2, 3), (1, 4, 3, 2),
(2, 1, 3, 4), (2, 1, 4, 3), (2, 3, 1, 4), (2, 3, 4, 1), (2, 4, 1, 3), (2, 4, 3, 1),
(3, 1, 2, 4), (3, 1, 4, 2), (3, 2, 1, 4), (3, 2, 4, 1), (3, 4, 1, 2), (3, 4, 2, 1),
(4, 1, 2, 3), (4, 1, 3, 2), (4, 2, 1, 3), (4, 2, 3, 1), (4, 3, 1, 2), (4, 3, 2, 1)]
'''

print(list(itertools.permutations(data, 2)))
# [(1, 2), (1, 3), (1, 4), (2, 1), (2, 3), (2, 4), (3, 1), (3, 2), (3, 4), (4, 1), (4, 2), (4, 3)]

# permutations只要顺序不同就看做一种结果,combinations则保证只要元素相同就是同一种结果
data = "abcd"
print(list(itertools.combinations(data, 3)))  # [('a', 'b', 'c'), ('a', 'b', 'd'), ('a', 'c', 'd'), ('b', 'c', 'd')]
# 尽管combinations不会重复单个的输入元素,但是有时候可能也需要考虑包含重复元素的组合。
# 对于这种情况,可以使用combination_with_replacement
print(list(itertools.combinations_with_replacement(data, 3)))
'''
[('a', 'a', 'a'), ('a', 'a', 'b'), ('a', 'a', 'c'), ('a', 'a', 'd'), ('a', 'b', 'b'),
('a', 'b', 'c'), ('a', 'b', 'd'), ('a', 'c', 'c'), ('a', 'c', 'd'), ('a', 'd', 'd'),
('b', 'b', 'b'), ('b', 'b', 'c'), ('b', 'b', 'd'), ('b', 'c', 'c'), ('b', 'c', 'd'),
('b', 'd', 'd'), ('c', 'c', 'c'), ('c', 'c', 'd'), ('c', 'd', 'd'), ('d', 'd', 'd')]
'''

  

(三)operator:内置操作符的函数接口

import operator

'''
使用迭代器编程时,有时需要为简单的表达式创建小函数。
operator模块提供了一些函数,可以对应标准API中内置的算术、比较和其他操作。
注意:operator中提供的操作,都可以通过lambda函数实现,就我个人而言更喜欢lambda函数
'''

  

1.逻辑操作

import operator

'''
有些函数可以用来确定一个值得相应布尔值,将其取反以创建相反的布尔值,以及比较对象以查看它们是否相等
'''
a = -1  # 为真
b = 5  # 为真

# not为关键字,所以是not_,判断值是否为假。由于a=-1为真,不为假,所以是False
print(operator.not_(a))  # False
# truth,判断值是否为真
print(operator.truth(b))  # True
# is_, 等价于a is b
print(operator.is_(a, b))  # False
# is_not,等价于a is not b
print(operator.is_not(a, b))  # True

  

2.比较操作符

import operator

'''
支持所有的富比较操作符
'''
a = -1
b = 5
for func in ("lt", "le", "gt", "ge", "eq", "ne"):  # <, <=, >, >=, ==, !=
    print(f"{func}(a, b): {getattr(operator, func)(a, b)}")
'''
lt(a, b): True
le(a, b): True
gt(a, b): False
ge(a, b): False
eq(a, b): False
ne(a, b): True
'''

  

3.算术操作符

import operator

'''
支持处理数字值的算术操作符
'''
a = -1
b = 5.0
c = 2
d = 6

print("abs(a): ", operator.abs(a))
print("neg(a): ", operator.neg(a))
print("neg(b): ", operator.neg(b))
print("pos(a): ", operator.pos(a))
print("pos(b): ", operator.pos(b))
print("add(a, b): ", operator.add(a, b))
print("floordiv(a, b): ", operator.floordiv(a, b))
print("floordiv(a, c): ", operator.floordiv(a, c))
print("mod(a, b): ", operator.mod(a, b))
print("mul(a, b): ", operator.mul(a, b))
print("pow(c, d): ", operator.pow(c, d))
print("sub(b, a): ", operator.sub(b, a))
print("truediv(a, b): ", operator.truediv(a, b))
print("truediv(d, c): ", operator.truediv(d, c))
print("and_(c, d): ", operator.and_(c, d))
print("invert(c): ", operator.invert(c))
print("lshift(c, d): ", operator.lshift(c, d))
print("or_(c, d): ", operator.or_(c, d))
print("rshift(d, c): ", operator.rshift(d, c))
print("xor(c, d): ", operator.xor(c, d))

'''
a = -1
b = 5.0
c = 2
d = 6

abs(a):  1
neg(a):  1
neg(b):  -5.0
pos(a):  -1
pos(b):  5.0
add(a, b):  4.0
floordiv(a, b):  -1.0
floordiv(a, c):  -1
mod(a, b):  4.0
mul(a, b):  -5.0
pow(c, d):  64
sub(b, a):  6.0
truediv(a, b):  -0.2
truediv(d, c):  3.0
and_(c, d):  2
invert(c):  -3
lshift(c, d):  128
or_(c, d):  6
rshift(d, c):  1
xor(c, d):  4
'''

  

4.序列操作符

import operator

'''
处理序列的操作符可以分为四组:建立序列,搜索元素,访问内容,以及从序列删除元素
'''
a = [1, 2, 3]
b = ['a', 'b', 'c']
print("a =", a)
print("b =", b)
print("concat(a, b): ", operator.concat(a, b))
print("contains(a, 1): ", operator.contains(a, 1))
print("contains(b, 'd'): ", operator.contains(b, 'd'))
print("countOf(a, 1): ", operator.countOf(a, 1))
print("countOf(b, 'd'): ", operator.countOf(b, 'd'))
print("indexOf(a, 5): ", operator.indexOf(a, 1))
print("getitem(b, 1): ", operator.getitem(b, 1))
print("getitem(b slice(1, 3): ", operator.getitem(b, slice(1, 3)))
print("setitem(b, 1, 'd'): ", end=' ')
operator.setitem(b, 1, 'd')
print(b)
print("setitem(a, slice(1, 3), [4, 5]): ", end=' ')
operator.setitem(a, slice(1, 3), [4, 5])
print(a)

print("delitem(b, 1)", end=' ')
operator.delitem(b, 1)
print(b)
print("delitem(a, slice(1, 3): ", end=' ')
operator.delitem(b, slice(1, 3))
print(a)
# 其中的一些操作(setitem()和delitem())会原地修改序列,返回的是None
'''
a = [1, 2, 3]
b = ['a', 'b', 'c']
concat(a, b):  [1, 2, 3, 'a', 'b', 'c']
contains(a, 1):  True
contains(b, 'd'):  False
countOf(a, 1):  1
countOf(b, 'd'):  0
indexOf(a, 5):  0
getitem(b, 1):  b
getitem(b slice(1, 3):  ['b', 'c']
setitem(b, 1, 'd'):  ['a', 'd', 'c']
setitem(a, slice(1, 3), [4, 5]):  [1, 4, 5]
delitem(b, 1) ['a', 'c']
delitem(a, slice(1, 3):  [1, 4, 5]
'''

# 个人觉得这些都没有什么乱用,可以直接实现的,没必要使用这个库

  

5.原地操作符

6.排序

import operator

'''
这一节书上没有,是我自己加的。个人觉得这个库只有在这一方面会有用。
'''
l = [
    [1, 3],
    [7, 4],
    [6, 2],
    [3, 5]
]
# 现在我要将这个列表进行排序,怎么排呢?里面里面列表的第一个元素的顺序从小到大排
# 也就是说,排完序之后应该是这样的, [[1, 3], [3, 5], [6, 2], [7, 4]]
l.sort(key=operator.itemgetter(0))
# 按照key来排序,itemgetter(0),表示获取各自索引为0的元素,进行比较
print(l)  # [[1, 3], [3, 5], [6, 2], [7, 4]]

# 但是我们可以使用lambda函数来实现,而且还可以实现更加复杂的效果
l1 = [
    [1, 3],
    [7, 4],
    [6, 2],
    [3, 5]
]
l1.sort(key=lambda x: x[0])
print(l1)  # [[1, 3], [3, 5], [6, 2], [7, 4]]

l2 = [-3, -5, 3, -9, 8, 2]
# 对l2我想这样排序,首先按照正负数排序,负数排左边,正数排右边。
# 然后按照绝对值得大小排, 绝对值大的排左边,小的排右边
# 也就是说排完之后应该是这样的,[-9, -5, -3, 8, 3, 2]
l2.sort(key=lambda x: (x > 0, ~abs(x)))
print(l2)  # [-9, -5, -3, 8, 3, 2]
# 因此可以看到这个x代表的就是序列里面的元素
# 如果是字典的话,那么x就是字典里面的key

d = {"a": 4, "c": 3, "b": 2}
# 可是字典没有sort,我们如何验证呢?
import heapq
# 按照value选择两个最大的
# 参数:选择几个,从哪里选择,按照什么规则去选择
print(heapq.nlargest(2, d, key=lambda x: d[x]))  # ['a', 'c']

'''
个人总结一下哈,我个人觉得这个库是真的没有什么用,完全可以使用其他的方法代替,而且更容易理解。
当然也可能是我能力不够,这个库的更高级的用法我没有看到(雾)
'''

  

(四)contextlib:上下文管理器工具

import contextlib

'''
contextlib模块包含的工具用于处理上下文管理器和with语句
'''

1.上下文管理器API

import contextlib

'''
上下文管理器(context manager)负责管理一个代码块中的资源,会在进入代码块时创建资源,然后再退出代码后清理这个资源。
比如:文件就支持上下文管理器API,可以确保文件读写后关闭文件。
with open("xxx") as f:
    f.read()
'''

# 那么这是如何实现的呢?我们可以手动模拟一下
class Open:

    def __init__(self, filename, mode='r', encoding=None):
        self.filename = filename
        self.mode = mode
        self.encoding = encoding

    def __enter__(self):
        print("__enter__,有了这个就可以使用with Open() as xx语句,这里的xx就是我return的内容")
        return self

    def read(self):
        print(f"文件进行读操作,读取文件:{self.filename}, 模式:{self.mode}, 编码:{self.encoding}")

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("__exit__,我是用来清理资源的,当操作执行完毕之后就会执行我,比如:关闭文件")

with Open("1.xxx") as f:
    f.read()
'''
__enter__,有了这个就可以使用with Open() as xx语句,这里的xx就是我return的内容
文件进行读操作,读取文件:1.xxx, 模式:r, 编码:None
__exit__,我是用来清理资源的,当操作执行完毕之后就会执行我,比如:关闭文件
'''

  

import contextlib

# 相较于try:finally语法,结合上下文管理器和with语句是一种更加紧凑的写法,因为__exit__这个方法总是会被调用的,即使产生了异常

class Open:

    def __init__(self, filename, mode='r', encoding=None):
        self.filename = filename
        self.mode = mode
        self.encoding = encoding

    def __enter__(self):
        return 123

    def __exit__(self, exc_type, exc_val, exc_tb):
        # 注意到这里有三个参数,使用pycharm的时候,会很智能地自动帮我们加上去
        print(exc_type)
        print(exc_val)
        print(exc_tb)
        return True

with Open("1.xx") as f:
    print(f)
'''
123
None
None
None
'''

with Open("1.xx") as f:
    print(f)
    1 / 0
    print(123)
    print(456)
    print(789)
print("你猜我会被执行吗?")
'''
123
<class 'ZeroDivisionError'>
division by zero
<traceback object at 0x0000000009EDD848>
你猜我会被执行吗?
'''

'''
可以看到当我们程序没有出错的时候,打印的值全为None。一旦with语句里面出现了异常,那么会立即执行__exit__函数。
里面的参数就是:异常的类型,异常的值,异常的信息栈。
因此:当with语句结束之后会调用__exit__函数,如果with语句里面出现了错误则会立即调用__exit__函数。
但是__exit__函数返回了个True是什么意思呢?
当with语句里面出现了异常,理论上是会报错的,但是由于要执行__exit__函数,所以相当于暂时把异常塞进了嘴里。
如果__exit__函数最后返回了一个布尔类型为True的值,那么会把塞进嘴里的异常吞下去,程序不报错正常执行。如果返回布尔类型为False的值,会在执行完__exit__函数之后再把异常吐出来,引发程序崩溃。
这里我们返回了True,因此程序正常执行,最后一句话被打印了出来。
但是1/0这句代码后面的几个print却没有打印,为什么呢?
因为上下文管理执行是有顺序的,
with Open("1.xxx") as f:
    code1
    code2
先执行Open函数的__init__函数,再执行__enter__函数,把其返回值给交给f,然后执行with语句里面的代码,最后执行__exit__函数。
只要__exit__函数执行结束,那么这个with语句就算结束了。
而with语句里面如果有异常会立即进入__exit__函数,因此异常语句后面的代码是无论如何都不会被执行的。
'''

  

2.上下文管理器作为函数修饰符

import contextlib

'''
类ContextDecorator增加了对常规上下文管理器类的支持,因此不仅可以作为上下文管理器,也可以作为函数修饰符
'''

class Context(contextlib.ContextDecorator):
    def __init__(self, how_used):
        self.how_used = how_used
        print(f"__init__({self.how_used})")

    def __enter__(self):
        print(f"__enter__({self.how_used})")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(f"__exit__({self.how_used})")

# 一旦继承了ContextDecorator这个类,那么便可以作为装饰器去装饰。
# 说白了Context("as decorator")返回了Context的一个实例对象,理论上是不可调用的,但是父类实现了call方法。
# 因此如果我们自己实现了一个定义了__call__方法的类,让Context去继承,也是可以达到类似的效果
@Context("as decorator")
def func(message):
    print(message)
    '''
    __init__(as decorator)
    '''

# 当我执行执行func的时候,此时的func已经不再是原来的那个func了
# func = self(func),从而调用Context的__call__方法,可是Context没有这个方法,那么它的父类肯定有。
# 我们看看contextlib.ContextDecorator的源码,去掉了注释
'''
class ContextDecorator(object):

    def _recreate_cm(self):
        return self

    def __call__(self, func):
        @wraps(func)
        def inner(*args, **kwds):
            with self._recreate_cm():
                return func(*args, **kwds)
        return inner

可以看到首先@Context("as decorator")会执行Context的__init__方法,打印__init__(as decorator),得到实例对象self
此时等价于@self, -->func = self(func),执行__call__方法,-->func = inner
当执行inner的时候,会先调用__enter__方法,然后执行inner,最后执行__exit__方法
'''

func("doing work i the wrapped function")

# 这个无需解释
with Context("as contetx manager"):
    print("doing work in the context")
    '''
    __init__(as contetx manager)
    __enter__(as contetx manager)
    doing work in the context
    __exit__(as contetx manager)
    '''

  

3.从生成器到上下文管理器

import contextlib

'''
采用传统方式创建上下文管理器并不难,只需要包含一个__enter__方法和一个__exit__方法的类即可。
不过某些时候,如果只有很少的上下文需要管理,那么完整地写出所以代码便会成为额外的负担。
在这些情况下,可以使用contextmanager修饰符将一个生成器函数转换为上下文管理器。
代码结构:
@contextlib.contextmanager
def foo():
    print(123)
    yield 456
    print(789)

with foo() as f:
    print(f)

123
456
789

只要给函数加上这个装饰器,那么便可以使用with   as  语句。
当中的yield相当于将代码块分隔为两个战场,yield上面的代码相当于__exter__会先执行,然后将yield的值交给f,然后执行yield下面的代码块
'''

@contextlib.contextmanager
def bar(name, age):
    print(f"name is {name}, age is {age}")
    yield list
    print("我是一匹狼,却变成了狗")

with bar("mashiro", 16) as b:
    print(b("abcde"))
'''
name is mashiro, age is 16
['a', 'b', 'c', 'd', 'e']
我是一匹狼,却变成了狗
'''
# 先执行yield上面的内容,然后yield list,那么b = list,最后执行yield下面的内容

# contextmanager返回的上下文管理器排成子ContextDecorator,所以也可以被用作函数修饰符
@bar("satori", 16)
def foo():
    print("猜猜我会在什么地方输出")

foo()
'''
name is satori, age is 16
猜猜我会在什么地方输出
我是一匹狼,却变成了狗
'''
# bar中含有yield,肯定是一个生成器,所以直接@bar("satori", 16)是不会输出的。当我执行foo的时候,还会先执行bar里面yield上面的内容,
# 然后执行foo代码的内容,最后执行yield下面的内容

  

4.关闭打开的句柄

import contextlib

'''
file类直接支持上下文管理器API,但另外一些表示打开句柄的对象却并不支持。
为了确保关闭句柄,要是用closing为它创建一个上下文管理器
'''

class Door:
    def __init__(self):
        print("__init__()")
        self.status = "open"

    def close(self):
        print("close()")
        self.status = "closed"

with contextlib.closing(Door()) as door:
    print(f"{door.status}")
# 先不急看结果,先来分析一下。首先contextlib.closing本身就是一个上下文管理器
'''
class closing(AbstractContextManager):
    def __init__(self, thing):
        self.thing = thing
    def __enter__(self):
        return self.thing
    def __exit__(self, *exc_info):
        self.thing.close()
'''
# 可以看到当我with contextlib.closing(Door()) as door的时候,直接将Door的实例对象传入了closing这个类中
# 然后enter返回了self.thing也就是我们传进去的Door的实例对象,__enter__返回self.thing交给door
# 然后执行我们的逻辑,最后__exit__函数再调用self.thing.close函数,所以我们定义的类中一定要实现close函数

# 执行结果
'''
__init__()
open
close()
'''
# 先执行__init__函数,再执行我们自己的逻辑,打印"open",最后执行close函数,将状态改为"closed"。
# 怎么证明这一点呢?
print(door.status)  # closed

# 如果出现了异常怎么办呢?不用怕,依旧会执行close语句.
# 由于contextlib.closing的__exit__函数并没有返回布尔类型为True的值,所以最后还是会抛出异常,我们手动捕获一下
try:
    with contextlib.closing(Door()) as boy_next_door:
        print(123)
        1/0
        print(456)

except Exception:
    pass

print(boy_next_door.status)
'''
__init__()
123
close()
closed
'''
# 最后还是打印了"closed",所以还是执行了close()方法

  

5.忽略异常

import contextlib

'''
很多情况下,忽略库产生的异常很有用,因为这个错误可能会显示期望的状态已经被实现,否则该错误就可以被忽略。
要忽略异常,最常用的办法就是利用一个try except语句。
但是在我们此刻的主题中,try except也可以被替换成contextlib.suppress(),以更显示地抑制with块中产生的异常
'''
def foo():
    print(123)
    1 / 0
    print(456)

with contextlib.suppress(ZeroDivisionError):
    foo()
    print(789)
'''
123
'''
# 最终只输出了123,可以看到不仅1/0中下面的456没有被打印,连foo()下面的789也没有被打印

# 可以传入多个异常
with contextlib.suppress(ZeroDivisionError, BaseException, Exception):
    foo()
'''
123
'''
# 出现异常之后,会将异常全部丢弃

  

6.重定向到输出流

import contextlib
import io
import sys

'''
设计不当的代码可能会直接写sys.stdout或sys.stderr,而没有提供参数来配置不同的输出目标。
可以用redirect_stdout和redirect_stderr上下文管理器从这些函数中捕获输出,因为无法修改这个函数的源代码来接收新的输出参数
'''

def func(a):
    sys.stdout.write(f"stdout :{a}")
    sys.stderr.write(f"stderr :{a}")

capture = io.StringIO()
'''
我们执行func本来是要往sys.stdout和sys.stderr里面写的
但这是在with语句contextlib.redirect_stdout(capture), contextlib.redirect_stderr(capture)下面,
因此可以理解往sys.stdout和sys.stderr里面写的内容就被捕获到了,然后会将捕获到的内容输入到capture里面,因为我们指定了capture
'''
with contextlib.redirect_stdout(capture), contextlib.redirect_stderr(capture):
    func("蛤蛤蛤蛤")

print(capture.getvalue())  # stdout :蛤蛤蛤蛤stderr :蛤蛤蛤蛤

'''
redirect_stdout和redirect_stderr会修改全局状态,替换sys模块中的对象,可以想象gevent里面的patch_all会将Python里面socket,ssl等都换掉。
因此要使用这两个函数,必须要注意。这些函数并不保证线程安全,所以在多线程应用中调用这些函数可能会有不确定的结果。
如果有其他希望标准输出流关联到终端设备,那么redirect_stdout和redirect_stderr将会干扰和影响那些操作。
'''

  

7.动态上下文管理器栈

import contextlib

'''
大多数上下文管理器都一次处理一个对象,如单个文件或数据库句柄。
在这些情况下,对象是提前已知的,并且使用上下文管理器的代码可以建立这一对象上。
另外一些情况下,程序可能需要在一个上下文中创建未知数目的对象,控制流退出这个上下文时所有这些对象都要清理,ExitStack就是用来处理这些更动态的情况。

ExitStack实例会维护清理回调的一个栈数据结构,这些回调显示地填充在上下文中,在控制流退出上下文时会以逆序调用所有注册的回调。
结果类似于有多个嵌套的with语句,只不过它们是动态建立的。
'''

# 可以使用多种方法填充ExitStack,比如
@contextlib.contextmanager
def make_context(i):
    print(f"{i}: entering")
    yield {}
    print(f"{i}: exiting")

def variable_stack(n, msg):
    with contextlib.ExitStack() as stack:
        for i in range(n):
            stack.enter_context(make_context(i))
        print(msg)

variable_stack(2, "inside stack")
'''
contextlib.ExitStack()相当于创建了上下文管理器栈
stack.enter_context将上下文管理器放入到栈中,注意此时已经执行了
会先输出:
    0: entering
    1: entering
等于是把yield之后的结果压入栈中
然后执行后面的代码,所以会打印出msg
当里面的代码执行完毕之后,会继续执行栈里面的数据,但是栈是后入先出的。i=1后入栈,所以先执行
随意最后输出:
    1: exiting
    0: exiting
'''
# 输出结果
''''
0: entering
1: entering
inside stack
1: exiting
0: exiting
'''

  

4.Python3标准库--算法的更多相关文章

  1. 8.Python3标准库--数据持久存储与交换

    ''' 持久存储数据以便长期使用包括两个方面:在对象的内存中表示和存储格式之间来回转换数据,以及处理转换后数据的存储区. 标准库包含很多模块可以处理不同情况下的这两个方面 有两个模块可以将对象转换为一 ...

  2. Python3 标准库

    Python3标准库 更详尽:http://blog.csdn.net/jurbo/article/details/52334345 文本 string:通用字符串操作 re:正则表达式操作 diff ...

  3. python023 Python3 标准库概览

    Python3 标准库概览 操作系统接口 os模块提供了不少与操作系统相关联的函数. >>> import os >>> os.getcwd() # 返回当前的工作 ...

  4. python3标准库总结

    Python3标准库 操作系统接口 os模块提供了不少与操作系统相关联的函数. ? 1 2 3 4 5 6 >>> import os >>> os.getcwd( ...

  5. 7.Python3标准库--文件系统

    ''' Python的标准库中包含大量工具,可以处理文件系统中的文件,构造和解析文件名,还可以检查文件内容. 处理文件的第一步是要确定处理的文件的名字.Python将文件名表示为简单的字符串,另外还提 ...

  6. 1.Python3标准库--前戏

    Python有一个很大的优势便是在于其拥有丰富的第三方库,可以解决很多很多问题.其实Python的标准库也是非常丰富的,今后我将介绍一下Python的标准库. 这个教程使用的书籍就叫做<Pyth ...

  7. 比较两个文件的异同Python3 标准库difflib 实现

    比较两个文件的异同Python3 标准库difflib 实现 对于要比较两个文件特别是配置文件的差异,这种需求很常见,如果用眼睛看,真是眼睛疼. 可以使用linux命令行工具diff a_file b ...

  8. Python3标准库:heapq堆排序算法

    1. heapq堆排序算法 堆(heap)是一个树形数据结构,其中子节点与父节点有一种有序关系.二叉堆(binary heap)可以使用一个有组织的列表或数组表示,其中元素N的子元素位于2*N+1和2 ...

  9. 3.Python3标准库--数据结构

    (一)enum:枚举类型 import enum ''' enum模块定义了一个提供迭代和比较功能的枚举类型.可以用这个为值创建明确定义的符号,而不是使用字面量整数或字符串 ''' 1.创建枚举 im ...

随机推荐

  1. CF17E:Palisection——题解

    https://vjudge.net/problem/CodeForces-17E http://codeforces.com/problemset/problem/17/E 题目大意:给一个长度为n ...

  2. BZOJ2668 [cqoi2012]交换棋子 【费用流】

    题目链接 BZOJ2668 题解 容易想到由\(S\)向初始的黑点连边,由终态的黑点向\(T\)连边,然后相邻的点间连边 但是这样满足不了交换次数的限制,也无法计算答案 考虑如何满足一个点的交换次数限 ...

  3. BZOJ3156: 防御准备 【斜率优化dp】

    3156: 防御准备 Time Limit: 10 Sec  Memory Limit: 512 MB Submit: 2207  Solved: 933 [Submit][Status][Discu ...

  4. React获取组件实例

    1. 直接new Component() 组件本身也是class,可以new,这样的组件实例意义不大 componentInstance = new Component(); 2. ReactDOM. ...

  5. bzoj2326:[HNOI2011]数学作业(分段矩阵乘法)

    题目大意:输入n(n<=10^18)和m,将1~n的整数连起来模m输出,比如n=13则输出12345678910111213模m的数. 设f[i]为1~i整数连起来模m的数,i的位数为k,则有f ...

  6. AtCoder Regular Contest 081 E - Don't Be a Subsequence(字符串DP)

    引用自:onion_cyc 字符串DP一直不是强项...以后没思路的题就想DP和网络流23333333 f[i]表示从i开始的后缀非子序列的最短长度  pos[i][j]表示从i开始的j字符最早出现位 ...

  7. ucenter通信实现同步登录、同步退出(详细)

    首先,需要去官网下载一个ucenter的包.然后解压下来. 先把ucenter/ucenter这个文件夹复制到你的项目根目录下改名为uc_server;(这里只是我建议修改,以便于我下面写的配置); ...

  8. springmvc不通过controller进行页面跳转

    1.controller 继承WebMvcConfigureAdapter 然后使用ViewControllerRegistry  来进行跳转

  9. 获取文件名称 basename 用法

    <?phpheader('Content-type:text/html;charset=utf8'); $str = '2390230.png';$str_arr = explode('.',$ ...

  10. hibernate 如何配置两个属性唯一

    在单一字段的唯一性约束时,我们可以在映射文件里配置property属性的unique="true"来达到目的,但多字段的唯一性约束怎样处理呢?如 果使用复合主键可以很简单地解决这个 ...