一.functools模块
1.reduce函数:
参见python函数部分
2.偏函数partial:用于固定函数的某些参数
partial(<func>[,*args,**kwargs])
#参数说明:
func:该参数为1个函数
args:用于接收func的位置参数
kwargs:用于接收func的关键字参数
#实例:
>>> from functools import partial
>>> def add(x,y):
... return x+y
...
>>> func=partial(add,1)#第2个参数作为函数的第1个参数
>>> print(func(1))
2
>>> print(func(2))
3
3.wraps函数:
在Python中,使用了装饰器的函数其实已经是另1个函数了(函数名等属性会发生改变).为此,functools模块中提供了1个名为wraps()的装饰器来
消除这些副作用:
>>> import functools
>>> def my_decorator(func):
... def wrapper(*args,**kwargs):
... print('Calling decorated function...')
... return func(*args,**kwargs)
... return wrapper
...
>>> @my_decorator
... def example():
... print('Called example function')
...
>>> print(example.__name__,example.__doc__)
wrapper decorator
>>> def my_decorator(func):
... @functools.wraps(func)
... def wrapper(*args,**kwargs):
... print('Calling decorated function...')
... return func(*args,**kwargs)
... return wrapper
...
>>> @my_decorator
... def example():
... print('Called example function')
...
>>> print(example.__name__,example.__doc__)
example Docstring
二.itertools模块
1.简介
(1)简介:
itertools模块是用于高效循环的迭代器的集合(以下每个迭代器实际上都是1个类)
(2)导入:
import itertools
2.无限迭代器(Infinite Iterators)
(1)数值迭代:
创建无限数值迭代器:itertools.count([start=0,step=1])
#start,start+step,start+2*step...
#参数说明:
start:指定迭代的起始位置;为num
step:指定步长;为num
#均可为位置参数
#实例:
>>> for i in itertools.count():
... print(i)
...
0
1
...#此处省略
8294
8295
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
KeyboardInterrupt
>>> for i in itertools.count(5.2,2.4):
... print(i)
...
5.2
7.6
...#此处省略
5395.599999999912
5397.999999999912
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
KeyboardInterrupt
(2)序列迭代:
创建无限循环迭代器:itertools.cycle(<p>)
#p0,p1...pn,p0,p1...pn,p0...
#参数说明:
p:指定要循环的序列;为iterable object
#实例:
>>> for i in itertools.cycle([1,2,3]):
... print(i)
...
1
2
3
1
...#此处省略
2
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
KeyboardInterrupt
(3)单值迭代:
创建无限重复迭代器:itertools.repeat(object=None[,times=None])
#elem,elem...
#参数说明:
object:指定要重复的元素
times:指定要重复的次数;为int,默认为无穷大
#均可为位置参数
#实例:
>>> for i in itertools.repeat("a",6):
... print(i)
...
a
a
a
a
a
a
3.序列迭代器(Iterators terminating on the shortest input sequence)
(1)多序列串联迭代:
利用多个彼此串联的序列创建迭代器:itertools.chain([*iterables])
#iterable11,iterable12...iterable1i,iterable21,iterable22...iterable2j...
#参数说明:
iterables:指定用于创建迭代的序列;为iterable object
#实例:
>>> for i in itertools.chain("abcd","123",["a",2,[]]):
... print(i)
...
a
b
c
d
1
2
3
a
2
[]
(2)序列选择迭代:
利用序列中指定的元素创建迭代器:itertools.compress(data=None,selectors=None)
#data[0] if selectors[0],data[1] if selectors[1]...
#参数说明:
data:指定序列;为iterable object
selectors:指定使用<data>中的哪些元素创建迭代器;为iterable object
#如果selectors[i]为True,那么生成的迭代器中就会包含data[i]
#均可为位置参数
#实例:
>>> for i in itertools.compress("asdasd",[1,1,0,1,0,0]):
... print(i)
...
a
s
a
######################################################################################################################
创建去除了序列头部指定元素的迭代器:itertools.dropwhile(<predicate>,<iterable>)
#参数说明:
predicate:指定条件;为function
#如果predicate返回True,就丢弃该元素,直到遇到第1个使predicate返回False的元素
#即去除序列头部所有满足条件的元素,返回由首个不满足条件的元素及其后所有元素构成的序列
#或者说,获取itertools.takewhile丢弃的部分
iterable:指定序列;为iterable object
#实例:
>>> def func(x):
... return x>0
...
>>> for i in itertools.dropwhile(func,[1,2,3,2,1,0,-1,-2,-1,0,1,2]):
... print(i)
...
0
-1
-2
-1
0
1
2
######################################################################################################################
创建由序列头部指定元素构成的迭代器:itertools.takewhile(<predicate>,<iterable>)
#参数说明:
predicate:指定条件;为function
#如果predicate返回True,就在结果中加入该元素,直到遇到第1个使predicate返回False的元素
#即获得序列头部所有满足条件的元素,丢弃从首个不满足条件的元素开始的所有元素
#或者说,获取itertools.dropwhile丢弃的部分
iterable:指定序列;为iterable object
#实例:
>>> def func(x):
... return x>0
...
>>> for i in itertools.takewhile(func,[3,2,1,0,-1,0,1]):
... print(i)
...
3
2
1
######################################################################################################################
itertools.ifilter和itertools.ifilterfalse在Python3中已被删除
######################################################################################################################
利用子序列创建迭代器:itertools.islice(<iterable>[,<start>],<stop>[,<step>])
#iterable[start],iterable[start+step],iterable[start+2*step]...iterable[stop]
#参数说明:
iterable:指定序列;为iterable object
start:指定子序列的起始位置(含);为int,默认为0
stop:指定子序列的结束位置(不含);为int
step:指定步长;为int,默认为1
#实例:
>>> for i in itertools.islice([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],4):
... print(i)
...
1
2
3
4
(3)分组迭代:
创建序列的分组迭代器:itertools.groupby(iterable=None[,key=lambda x:x])
#函数会根据传入key()后得到的返回值将序列中的元素分组,每组形成1个迭代器,这些迭代器构成了最终返回的迭代器
#参数说明:
iterable:指定序列;为iterable object
key:指定分组条件;为function,默认根据<iterable>中元素的值分组
#注意:不是将返回值相同的元素都放入同1组.而是从首元素开始依次判断,如果某个元素的结果与上1个不同,就创建1个新组(即使之前已经
# 创建了该值的组,也会再创建1个)并放入;否则,就放入上1个元素所在的组
#均可为位置参数
#实例:
>>> for i in itertools.groupby("aabbcccd"):
... print(i)
...
('a', <itertools._grouper object at 0x000001AFA6E75F40>)
('b', <itertools._grouper object at 0x000001AFA6E756A0>)
('c', <itertools._grouper object at 0x000001AFA6E75F40>)
('d', <itertools._grouper object at 0x000001AFA6E756A0>)
>>> for i in itertools.groupby(iterable="aabbcccd"):
... print(i)
...
('a', <itertools._grouper object at 0x000001AFA6E75610>)
('b', <itertools._grouper object at 0x000001AFA6D0EFD0>)
('c', <itertools._grouper object at 0x000001AFA6E75610>)
('d', <itertools._grouper object at 0x000001AFA6D0EFD0>)
>>> for i in itertools.groupby(iterable="aabbcccd"):
... for j in i[1]:
... print(j)
...
a
a
b
b
c
c
c
d
>>> def func(x):
... if x.islower():
... return True
... else:
... return False
...
>>> for i in itertools.groupby(iterable=["aa","Ds","ER","as"],key=func):
... print(i)
...
(True, <itertools._grouper object at 0x000001AFA6E756D0>)
(False, <itertools._grouper object at 0x000001AFA6E75340>)
(True, <itertools._grouper object at 0x000001AFA6E756D0>)
>>> for i in itertools.groupby(iterable=["aa","Ds","ER","as"],key=func):
... for j in i[1]:
... print(j)
...
aa
Ds
ER
as
(4)多序列并联(复合)迭代:
itertools.imap在Python3中已被删除
######################################################################################################################
通过对作为序列元素的序列进行复合从而创建迭代器:itertools.starmap(<func>,<iterable>)
#func(*seq[0]),func(*seq[1])...
#参数说明:
func:指定复合方法;为function
iterable:指定序列;为iterable object,其中的元素也为iterable objects
#实例:
>>> def func(*args):
... return len(args)
...
>>> for i in itertools.starmap(func,[(1,2,3),(1,2)]):
... print(i)
...
3
2
######################################################################################################################
itertools.izip和itertools.izip_longest在Python3中已被删除
(5)单序列重复迭代:
将1个迭代器复制为多个:itertools.tee(<iterable>[,<n>])
#返回由得到的所有迭代器构成的tuple
#iterable[0],iterable[1]...iterable[n],iterable[0]...
#参数说明:
iterable:指定要复制的迭代器;为iterable object
n:指定复制为几个迭代器;为int,默认为len(<iterable>)
#实例:
>>> for i in itertools.tee([1,2,3,4,5],4):
... print(i)
... for j in i:
... print(j)
...
<itertools._tee object at 0x000001AFA6E973C0>
1
2
3
4
5
<itertools._tee object at 0x000001AFA6E97200>
1
2
3
4
5
<itertools._tee object at 0x000001AFA6E97400>
1
2
3
4
5
<itertools._tee object at 0x000001AFA6E97280>
1
2
3
4
5
>>> itertools.tee([1,2,3,4,5],4)
(<itertools._tee object at 0x000001AFA6E97200>, <itertools._tee object at 0x000001AFA6E97480>, <itertools._tee object at 0x000001AFA6E972C0>, <itertools._tee object at 0x000001AFA6E97440>)
4.组合生成器(Combinatoric generators)
(1)笛卡尔积:
多个序列的笛卡尔积构成的迭代器:itertools.product([*iterables,repeat=1])
#参数说明:
iterables:指定参与组合的序列;为多个iterable object
repeat:指定进行几次笛卡尔积;为int
#[第1次笛卡尔积的结果]=iterable[0]×iterable[1]×...
#[第n+1次笛卡尔积的结果]=[第n次笛卡尔积的结果]×[第n次笛卡尔积的结果]
#实例:
>>> for i in itertools.product([1,2],[2,1],['s','d']):
... print(i)
...
(1, 2, 's')
(1, 2, 'd')
(1, 1, 's')
(1, 1, 'd')
(2, 2, 's')
(2, 2, 'd')
(2, 1, 's')
(2, 1, 'd')
>>> for i in itertools.product([1,2],[2,1],repeat=2):
... print(i)
...
(1, 2, 1, 2)
(1, 2, 1, 1)
(1, 2, 2, 2)
(1, 2, 2, 1)
(1, 1, 1, 2)
(1, 1, 1, 1)
(1, 1, 2, 2)
(1, 1, 2, 1)
(2, 2, 1, 2)
(2, 2, 1, 1)
(2, 2, 2, 2)
(2, 2, 2, 1)
(2, 1, 1, 2)
(2, 1, 1, 1)
(2, 1, 2, 2)
(2, 1, 2, 1)
(2)排列:
序列的全排列构成的迭代器:itertools.permutations(iterable=None[,r=len(iterable)])
#参数说明:
iterable:指定序列;为iterable object
r:指定使用序列的前几个元素进行全排列;为int
#均可为位置参数
#实例:
>>> for i in itertools.permutations(iterable=[1,2,3]):
... print(i)
...
(1, 2, 3)
(1, 3, 2)
(2, 1, 3)
(2, 3, 1)
(3, 1, 2)
(3, 2, 1)
>>> for i in itertools.permutations(iterable=[1,2,3],r=2):
... print(i)
...
(1, 2)
(1, 3)
(2, 1)
(2, 3)
(3, 1)
(3, 2)
(3)组合:
序列的全部可能的无放回抽样结果构成的迭代器:itertools.combinations(iterable=None,r=None)
#不考虑排列顺序
#参数说明:
iterable:指定序列;为iterable object
r:指定每次抽样抽几个元素;为int
#实例:
>>> for i in itertools.combinations([1,2,3],2):
... print(i)
...
(1, 2)
(1, 3)
(2, 3)
######################################################################################################################
序列的全部可能的有放回抽样结果构成的迭代器:itertools.combinations_with_replacement(iterable=None,r=None)
#不考虑排列顺序
#参数说明:
iterable:指定序列;为iterable object
r:指定每次抽样抽几个元素;为int
#实例:
>>> for i in itertools.combinations_with_replacement([1,2,3],2):
... print(i)
...
(1, 1)
(1, 2)
(1, 3)
(2, 2)
(2, 3)
(3, 3)
三.operator模块
1.简介
(1)简介:
operator模块提供了1套与Python的内置运算符相对应的函数
(2)方法汇总:
__all__ = ['abs', 'add', 'and_', 'attrgetter', 'concat', 'contains', 'countOf',
'delitem', 'eq', 'floordiv', 'ge', 'getitem', 'gt', 'iadd', 'iand',
'iconcat', 'ifloordiv', 'ilshift', 'imatmul', 'imod', 'imul',
'index', 'indexOf', 'inv', 'invert', 'ior', 'ipow', 'irshift',
'is_', 'is_not', 'isub', 'itemgetter', 'itruediv', 'ixor', 'le',
'length_hint', 'lshift', 'lt', 'matmul', 'methodcaller', 'mod',
'mul', 'ne', 'neg', 'not_', 'or_', 'pos', 'pow', 'rshift',
'setitem', 'sub', 'truediv', 'truth', 'xor']
(3)导入:
import operator
2.方法总结
(1)比较运算:
a<b --> operator.lt(a,b)
a<=b --> operator.le(a,b)
a==b --> operator.eq(a,b)
a!=b --> operator.ne(a,b)
a>=b --> operator.ge(a,b)
a>b --> operator.gt(a,b)
(2)逻辑运算:
not a --> operator.not_(a)
True if a else False --> operator.truth(a)
a is b --> operator.is_(a,b)
a is not b --> operator.is_not(a,b)
(3)数学运算:
abs(a) --> operator.abs(a,b)
a+b --> operator.add(a,b)
a//b --> operator.floordiv(a,b)
a.__index__() --> operator.index(a)
a%b --> operator.mod(a,b)
a*b --> operator.mul(a,b)
a@b --> operator.matmul(a,b)
-a --> operator.neg(a)
+a --> operator.pos(a)
a**b --> operator.pow(a,b)
a-b --> operator.sub(a,b)
a/b --> operator.truediv(a,b)
(4)位运算:
a&b --> operator.and_(a,b)
~a --> operator.inv(a,b) or operator.invert(a,b)
a<<b --> operator.lshift(a,b)
a|b --> operator.or_(a,b)
a>>b --> operator.rshift(a,b)
a^b --> operator.xor(a,b)
(5)序列运算:
a+b --> operator.concat(a,b)#a,b均为序列
b in a --> operator.contains(a,b)
b在a中的个数 --> operator.countOf(a,b)
del a[b] --> operator.delitem(a,b)
a[b] --> operator.getitem(a,b)
查找b首次出现在a中的位置的索引 --> operator.indexOf(a,b)
a[b]=c --> operator.setitem(a,b,c)
评估obj的长度 --> operator.length_hint(obj[,default=0])
#注意:如果obj支持使用len(),就会得到准确长度;否则可能存在误差
(6)就地运算:
a+=b --> operator.iadd(a,b)
a&=b --> operator.iand(a,b)
a+=b --> operator.iconcat(a,b)#a,b均为sequence
a//=b --> operator.ifloordiv(a,b)
a<<=b --> operator.ilshift(a,b)
a%=b --> operator.imod(a,b)
a*= --> operator.imul(a,b)
a@=b --> operator.imatnul(a,b)
a|= --> operator.ior(a,b)
a**=b --> operator.ipow(a,b)
a>>=b --> operator.irshift(a,b)
a-=b --> operator.isub(a,b)
a/=b --> operator.itruediv(a,b)
a^= --> operator.ixor(a,b)
(7)通用查找对象:
operator.attrgetter(attr[,*attrs])
#Return a callable object that fetches the given attribute(s) from its operand.
#After f = attrgetter('name'), the call f(r) returns r.name.
#After g = attrgetter('name', 'date'), the call g(r) returns (r.name, r.date).
#After h = attrgetter('name.first', 'name.last'), the call h(r) returns (r.name.first, r.name.last).
operator.itemgetter(item[,*items])
#Return a callable object that fetches the given item(s) from its operand.
#After f = itemgetter(2), the call f(r) returns r[2].
#After g = itemgetter(2, 5, 3), the call g(r) returns (r[2], r[5], r[3])
operator.methodcaller(name[,*args,**kwargs])
#Return a callable object that calls the given method on its operand.
#After f = methodcaller('name'), the call f(r) returns r.name().
#After g = methodcaller('name', 'date', foo=1), the call g(r) returns r.name('date', foo=1).
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
