Set
a = set('abcd')
b = set('cdef')
# 交集 同时在 a b 中
a & b
a.intersection(b)
> {'c', 'd'}
# 返回只保留含有b中元素的a
a.intersection_update(b)
a &= b
# 并集 ab中所有元素的集合
a | b
a.union(b)
> {'a', 'b', 'c', 'd', 'e', 'f'}
# 返回增加了 b 中元素的a
a.update(b)
a |= b
# 差集 在 a 中 但不在 b 中
a - b
a.difference(b)
> {'a', 'b'}
# 返回删除了 b 中含有的元素后的 a
a.difference_update(b)
a -= b
# 返回删除了b中元素集合的a
a.difference_update(b)
a -= b
# 对称差集 没有同时在ab中
a ^ b
a.symmetric_difference(b)
> {'a', 'b', 'e', 'f'}
# 返回含有 b 或者 a 中有而不是两者都有的元素的 a
a.symmetric_difference_update(b)
a ^= b
# 测试 a 中的每个元素都在b中
a <= b
a.issubset(b)
# 测试b中的每个元素都在a中
a >= b
a.issuperset(b)
List
# 行列转换
a=[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
for i in map(list, zip(*a)):
print(i)
# 求list中的元素的乘积
from functools import reduce
data = [1,2,3]
reduce(lambda x,y : x * y, data)
itertools
无穷迭代器：
| 迭代器 | 实参 | 结果 | 示例 |
|---|---|---|---|
count() |
start, [step] | start, start+step, start+2*step, ... | count(10) --> 10 11 12 13 14 ... |
cycle() |
p | p0, p1, ... plast, p0, p1, ... | cycle('ABCD') --> A B C D A B C D ... |
repeat() |
elem [,n] | elem, elem, elem, ... 重复无限次或n次 | repeat(10, 3) --> 10 10 10 |
根据最短输入序列长度停止的迭代器：
| 迭代器 | 实参 | 结果 | 示例 |
|---|---|---|---|
accumulate() |
p [,func] | p0, p0+p1, p0+p1+p2, ... | accumulate([1,2,3,4,5]) --> 1 3 6 10 15 |
chain() |
p, q, ... | p0, p1, ... plast, q0, q1, ... | chain('ABC', 'DEF') --> A B C D E F |
chain.from_iterable() |
iterable | p0, p1, ... plast, q0, q1, ... | chain.from_iterable(['ABC', 'DEF']) --> A B C D E F |
compress() |
data, selectors | (d[0] if s[0]), (d[1] if s[1]), ... | compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F |
dropwhile() |
pred, seq | seq[n], seq[n+1], ... 从pred首次真值测试失败开始 | dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1 |
filterfalse() |
pred, seq | seq中pred(x)为假值的元素，x是seq中的元素。 | filterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8 |
groupby() |
iterable[, key] | 根据key(v)值分组的迭代器 | |
islice() |
seq, [start,] stop [, step] | seq[start:stop:step]中的元素 | islice('ABCDEFG', 2, None) --> C D E F G |
starmap() |
func, seq | func(seq[0]), func(seq[1]), ... | starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000 |
takewhile() |
pred, seq | seq[0], seq[1], ..., 直到pred真值测试失败 | takewhile(lambda x: x<5, [1,4,6,4,1]) --> 1 4 |
tee() |
it, n | it1, it2, ... itn 将一个迭代器拆分为n个迭代器 | |
zip_longest() |
p, q, ... | (p[0], q[0]), (p[1], q[1]), ... | zip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D- |
排列组合迭代器：
| 迭代器 | 实参 | 结果 |
|---|---|---|
product() |
p, q, ... [repeat=1] | 笛卡尔积，相当于嵌套的for循环 |
permutations() |
p[, r] | 长度r元组，所有可能的排列，无重复元素 |
combinations() |
p, r | 长度r元组，有序，无重复元素 |
combinations_with_replacement() |
p, r | 长度r元组，有序，元素可重复 |
| 例子 | 结果 |
|---|---|
product('ABCD', repeat=2) |
AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD |
permutations('ABCD', 2) |
AB AC AD BA BC BD CA CB CD DA DB DC |
combinations('ABCD', 2) |
AB AC AD BC BD CD |
combinations_with_replacement('ABCD', 2) |
AA AB AC AD BB BC BD CC CD DD |
statistics
mean() |
数据的算术平均数（“平均数”）。 |
|---|---|
fmean() |
快速的，浮点算数平均数。 |
geometric_mean() |
数据的几何平均数 |
harmonic_mean() |
数据的调和均值 |
median() |
数据的中位数（中间值） |
median_low() |
数据的低中位数 |
median_high() |
数据的高中位数 |
median_grouped() |
分组数据的中位数，即第50个百分点。 |
mode() |
离散的或标称的数据的单模（最常见的值）。 |
multimode() |
离散的或标称的数据的模式列表（最常见的值）。 |
quantiles() |
将数据以相等的概率分为多个间隔。 |
pstdev() |
数据的总体标准差 |
pvariance() |
数据的总体方差 |
stdev() |
数据的样本标准差 |
variance() |
数据的样本方差 |
math
| ceil(x) | 返回 x 的上限，即大于或者等于 x 的最小整数 |
| comb(x) | 返回不重复且无顺序地从 n 项中选择 k 项的方式总数。(3.8) |
| fabs(x) | 绝对值 |
| factorial(x) | 阶乘 |
| floor(x) | 向下取整，小于或等于 x 的最大整数 |
| fsum(iterable) | 返回迭代中的精确浮点值。 |
| gcd(a,b) | 最大公约数 |
| prod(iterable, start=1) | 乘积 |
| exp(x) | e的x次幂 |
| log(x, base) | base的对数x，默认为e |
| log2(x) | 返回 x 以2为底的对数 |
| log10(x) | 返回 x 底为10的对数。 |
| pow(x,y) | x的y次幂 |
| sqrt(x) | 返回 x 的平方根。 |
| acos(x) | 以弧度为单位返回 x 的反余弦值。 |
| asin(x) | 以弧度为单位返回 x 的反正弦值。 |
| atan(x) | 以弧度为单位返回 x 的反正切值。 |
| atan(x,y) | 以弧度为单位返回 atan(y / x) 。结果是在 -pi 和 pi 之间。 |
| cos(x) | 返回 x 弧度的余弦值。 |
| dist(p,q) | 返回 p 与 q 两点之间的欧几里得距离，以一个坐标序列（或可迭代对象）的形式给出。 两个点必须具有相同的维度。 |
| sin(x) | 返回 x 弧度的正弦值。 |
| tan(x) | 返回 x 弧度的正切值。 |
functools
# 缓存下计算的值
@lru_cache(maxsize=32)
def fib(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
return fib(n-1) + fib(n-2)
%timeit fib(10)
# 对列表中的元素的没项值进行相加
reduce(lambda x,y: x+y, range(4), 1)
# 定义一个泛型函数
from functools import singledispatch
@singledispatch
def fun(arg, verbose=False):
if verbose:
print("Let me just say,", end=" ")
print(arg)
@fun.register
def _(arg: int, verbose=False):
if verbose:
print("Strength in numbers, eh?", end=" ")
print(arg)
def nothing(arg, verbose=False):
print("Nothing.")
fun.register(type(None), nothing)
fun("test.", verbose=True)
fun.registry.keys()
fun.registry[object]
from functools import wraps
def my_decorator(f):
@wraps(f)
def wrapper(*args, **kwds):
print('Calling decorated function')
return f(*args, **kwds)
return wrapper
@my_decorator
def example():
"""Docstring"""
print('Called example function')
example()
example.__name__
# example
example.__doc__
# Docstring
collections
namedtuple() |
创建命名元组子类的工厂函数 |
|---|---|
deque |
类似列表(list)的容器，实现了在两端快速添加(append)和弹出(pop) |
ChainMap |
类似字典(dict)的容器类，将多个映射集合到一个视图里面 |
Counter |
字典的子类，提供了可哈希对象的计数功能 |
OrderedDict |
字典的子类，保存了他们被添加的顺序 |
defaultdict |
字典的子类，提供了一个工厂函数，为字典查询提供一个默认值 |
UserDict |
封装了字典对象，简化了字典子类化 |
UserList |
封装了列表对象，简化了列表子类化 |
UserString |
封装了列表对象，简化了字符串子类化 |
Counter
一个计数器工具提供快速和方便的计数。
from collections import Counter
counter = Counter(A=2, B=2, C=1)
counter = Counter("AABBC")
# 返回前n项
counter.most_common()
deque
返回一个新的双向队列对象，从左到右初始化，从 iterable （迭代对象) 数据创建。
defaultdict
返回一个新的类似字典的对象。defaultdict 是内置 dict 类的子类。它重载了一个方法并添加了一个可写的实例变量。
namedtuple
命名元组赋予每个位置一个含义，提供可读性和自文档性。它们可以用于任何普通元组，并添加了通过名字获取值的能力，通过索引值也是可以的。
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(11, y=22)
t = [11, 22]
p = Point._make(t) # 类方法从存在的序列或迭代实例创建一个新实例。
d = {'x': 11, 'y': 22}
p = Point(**d) # 从字典创建
p._asdict() # 返回一个新的 dict ，它将字段名称映射到它们对应的值：
p._replace(x=33) # 返回一个新的命名元组实例，并将指定域替换为新的值
p._fields # 字符串元组列出了域名。
Account = namedtuple('Account', ['type', 'balance'], defaults=[0])
Account._field_defaults # {'balance': 0}
Account('premium') # Account(type='premium', balance=0)
class Point(namedtuple('Point', ['x', 'y'])):
# 上面的子类设置 __slots__ 为一个空元组。通过阻止创建实例字典保持了较低的内存开销。
__slots__ = ()
@property
def hypot(self):
return (self.x ** 2 + self.y ** 2) ** 0.5
def __str__(self):
return 'Point: x=%6.3f y=%6.3f hypot=%6.3f' % (self.x, self.y, self.hypot)
for p in Point(3, 4), Point(14, 5/7):
print(p)
# Point: x= 3.000 y= 4.000 hypot= 5.000
# Point: x=14.000 y= 0.714 hypot=14.018
OrderDict
有序词典就像常规词典一样，但有一些与排序操作相关的额外功能。