Python——标准库函数

标准库函数

基本介绍

Python语言的核心只包含数字、字符串、列表、字典、文件等常见类型和函数，而标准库补充提供了系统管理、网络通信、文本处理、数据库接口、图形系统、XML处理等额外的功能

具体模块函数讲解

math模块

该模块提供了对C标准定义的数学函数的访问
这些函数不适用于复数；如果你需要计算复数，请使用 cmath 模块中的同名函数

1.ceil（）

作用
向上取整，得到大于等于参数的最小的整数

返回值
int类型对象

案例

from math import ceil

c1 = ceil(3.2)
c2 = ceil(3.9)
c3 = ceil(3)
print(c1,c2,c3)

#输出结果：4 4 3

2.floor（）

作用
向下取整，得到小于等于参数的最大的整数

返回值
int类型对象

案例

from math import floor

f1 = floor(2.2)
f2 = floor(2.9)
f3 = floor(3)
print(f1,f2,f3)

#输出结果：2 2 3

3.factorial（）

作用
传入一个非负整数，得出所输入数字的阶乘

返回值
int类型对象

案例

from math import factorial

f1 = factorial(0)
f2 = factorial(4)
print(f1,f2)

#输出结果：1 24

4.prod（）

作用
计算一个可迭代对象中所有元素（与函数起始值）的积
有start关键字形参，默认值为1
如果可迭代对象为空，返回初始值

返回值
累乘之后的计算结果

案例

from math import prod

p1 = prod([1,2,3,4])
print(p1)

#输出结果：24

p1 = prod([[1,2]],start = 3)
print(p1)

#输出结果：[1, 2, 1, 2, 1, 2]

p1 = prod([3],start = [1,2])
print(p1)

#输出结果：[1, 2, 1, 2, 1, 2]

p1 = prod([],start = [1,2])
print(p1)

#输出结果：[1,2]

5.gcd（）

作用
计算多个数的最大公约数

Python 3.8 (包括3.8)之前的标准库math中提供了gcd（）函数可以计算两个整数的最大公约数，Python 3.9之后的版本中该函数可以计算任意多个整数的最大公约数

返回值
int类型对象

案例

from math import gcd

g1 = gcd(3,4,8)
g2 = gcd(2,4,8)
print(g1,g2)

#输出结果：1 2

6.isclose（）

作用
判断两个数字是否接近（可能是使用相对接近的标准，也可能是使用绝对接近的标准，看哪一个标准对应的判断数值比较大）

关键字形参rel_tol被视为"close"的相对差异（为一个百分数），相对于输入值的大小，默认值为1e-09，相对差值的计算公式为rel_tol * max(abs(a), abs(b))
关键字形参abs_tol被视为"close"的绝对差异（即为绝对差值），与输入值的大小无关，默认值为abs_tol=0.0

最终isclose函数把相对差值和绝对差值的较大值N作为比较两个被比较数字是否接近的标准，如果两个数字的差值小于N，说明两个数字彼此足够接近函数，返回结果即为True，反之为False

返回值
布尔类型对象 True 或者 False

案例

from math import isclose

b1 = isclose(999,1000,abs_tol=1)
b2 = isclose(999,1000)
print(b1,b2)

#输出结果：True False

7.radians（）

作用
将角度转化为对应的弧度

返回值
float类型对象

案例

from math import radians
from math import pi         #即为数学中的Π

r = radians(30)
d = pi/6
print(r == d)

#输出结果：True

8.degrees（）

作用
将弧度转化为对应的角度

返回值
float类型对象

案例

from math import degrees
from math import pi         #即为数学中的Π

d = degrees(pi/6)
d_round = round(d)
r = 30
print(d)
print(r == d_round)

#输出结果：
"""
29.999999999999996
True
"""

9.sin（）

作用
计算一个弧度对应的sin值

返回值
float类型对象

案例

from math import sin
from math import pi         #即为数学中的Π

s = sin(pi/6)
print(s)

#输出结果：0.49999999999999994

10.acos（）

作用
计算arccos值

返回值
float类型对象

案例

from math import acos
from math import degrees
from math import pi         #即为数学中的Π

ac = degrees(acos(0.5))
print(ac)

#输出结果：60.00000000000001

operator模块

operator 模块提供了一套与Python的内置运算符对应的高效率函数
函数包含的种类有：对象的比较运算、逻辑运算、数学运算以及序列运算

1.add（）

作用
计算两个对象的和

返回值
两个对象的和

案例

from operator import add

a1 = add(1, 2.3)
a2 = add([1,2], [3,4])
print(a1, a2)

#输出结果：3.3 [1, 2, 3, 4]

2.sub（）

作用
计算两个对象的差

返回值
两个对象的差

案例

from operator import sub

s1 = sub(2, 1.3)
s2 = sub({1, 2, 3, 4}, {1, 2})
print(s1, s2)

#输出结果：0.7 {3, 4}

3.mul（）

作用
计算两个对象的积

返回值
两个对象的积

案例

from operator import mul

m1 = mul(2, 1.3)
m2 = mul([1, 2], 2)
print(m1, m2)

#输出结果：2.6 [1, 2, 1, 2]

4.truediv（）

作用
计算两个对象的真除

返回值
两个对象的真除

案例

from operator import truediv

t = truediv(5, 2)
print(t)

#输出结果：2.5

5.floordiv（）

作用
计算两个对象的地板除

返回值
两个对象的地板除

案例

from operator import floordiv

t = floordiv(5, 2)
print(t)

#输出结果：2

6.or_（）

作用
计算两个对象的按位或

返回值
两个对象的按位或

案例

from operator import or_

t1 = or_(5, 2)
t2 = or_({1, 2}, {3, 4})
print(t1, t2)

#输出结果：7 {1, 2, 3, 4}

7.and_（）

作用
计算两个对象的按位与

返回值
两个对象的按位与

案例

from operator import and_

t1 = and_(7, 5)
t2 = and_({1, 2, 3}, {3, 4, 5})
print(t1, t2)

#输出结果：5 {3}

8.gt（）

作用
判断是否前一个实参大于后一个实参

返回值
布尔类型对象 True 或者 False

案例

from operator import gt

t1 = gt(5, 7)
t2 = gt({1, 2, 3}, {1, 2})
print(t1, t2)

#输出结果：False True

9.lt（）

作用
判断是否前一个实参小于后一个实参

返回值
布尔类型对象 True 或者 False

案例

from operator import lt

t1 = lt(7, 5)
t2 = lt({1, 2}, {1, 2 ,3})
print(t1, t2)

#输出结果：False True

10.itemgetter（）

作用
传入几个int类型对象，得到一个可调用对象
这个可调用对象的作用：以一个可迭代对象为参数来调用该对象时，会根据当初创建该对象时的整数，返回一个由这几个整数作为下标对应的可迭代对象元素所组成的元组类型对象

返回值
元组类型对象

案例

from operator import itemgetter

f = itemgetter(1,3,2)
t = f([1,2,3,4,5,6])
print(t)

#输出结果：(2, 4, 3)

f = itemgetter(4,-1,2)
t = f([1,2,3,4,5,6])
print(t)

#输出结果：(5, 6, 3)

itertools模块

本模块标准化了一个快速、高效利用内存的核心工具集，这些工具本身或组合都很有用，同时也能很好地与 operator 模块中的高效函数配合使用

1.zip_longest（）

作用
类似于内置函数中的zip函数，进行两个可迭代对象的缝合，将两个对象的对应元素打包成一个元组，到最长的序列元素耗尽为止，较短的序列耗尽而产生的空缺默认使用填充值None填补（可以传入关键字参数进行填充值的指定）

返回值
itertools.zip_longest类型对象 一个迭代器对象

案例

from itertools import zip_longest

iterator = zip_longest(range(1,4), range(3,8))
print(list(iterator))

#输出结果：[(1, 3), (2, 4), (3, 5), (None, 6), (None, 7)]

iterator = zip_longest(range(1, 4), range(3, 8), fillvalue = 0)
print(list(iterator))

#输出结果：[(1, 3), (2, 4), (3, 5), (0, 6), (0, 7)]

2.filterfalse（）

作用
类似于内置函数中的filter函数，传入一个可迭代对象，取出可迭代对象中布尔值为Flase的所有元素（可以先经过函数处理，查看函数的返回结果的布尔值，判断该元素是否要取出），将所有取出的元素作为filterfalse类型对象的元素
值得注意的是，如果不想指定函数，也必须传入一个None，否则会抛出异常

返回值
itertools.filterfalse类型对象 一个迭代器对象

案例

from itertools import filterfalse

iterator = filterfalse(None,range(10))
print(list(iterator))

#输出结果：[0]

iterator = filterfalse(lambda item: item%2 ,range(10))
print(list(iterator))

#输出结果：[0, 2, 4, 6, 8]

3.accumulate（）

作用
对于一个初始值以及可迭代对象中的所有元素，不断累计调用一个具有两个形参的计算函数，最后将整个过程中计算函数调用的结果作为一个迭代器对象的元素，将这个迭代器对象进行返回

默认的计算函数为求和函数，可以进行指定

返回值
itertools.accumulate类型对象 一个迭代器对象

案例

from itertools import accumulate

iterator = accumulate(range(4))
print(list(iterator))

#输出结果：[0, 1, 3, 6]

iterator = accumulate(range(1, 4), func=lambda a, b : a * b)
print(list(iterator))

#输出结果：[1, 2, 6]

4.combinations（）

作用
传入一个可迭代对象和一个正整数n，返回由可迭代对象中数量为n的元素的所有可能组合组成的一个迭代器对象

将（A, B）和（B, A）看作同一种组合

返回值
itertools.combinations类型对象 一个迭代器对象

案例

from itertools import combinations

iterator = combinations([1, 2, 3, 4, 5], 3)
print(list(iterator))

#输出结果：[(1, 2, 3), (1, 2, 4), (1, 2, 5), (1, 3, 4), (1, 3, 5), (1, 4, 5), (2, 3, 4), (2, 3, 5), (2, 4, 5), (3, 4, 5)]

iterator = accumulate(range(1, 4), func=lambda a, b : a * b)
print(list(iterator))

#输出结果：[1, 2, 6]

5.permutations（）

作用
传入一个可迭代对象和一个正整数n，返回由可迭代对象中数量为n的元素的所有可能组合（）组成的一个迭代器对象

将（A, B）和（B, A）看作不同组合

返回值
itertools.permutations类型对象 一个迭代器对象

案例

from itertools import permutations

iterator = permutations([1, 2, 3, 4], 3)
L_iterator = list(iterator)
print(L_iterator, len(L_iterator))

#输出结果：[(1, 2, 3), (1, 2, 4), (1, 3, 2), (1, 3, 4), (1, 4, 2), (1, 4, 3), (2, 1, 3), (2, 1, 4), (2, 3, 1), (2, 3, 4), (2, 4, 1), (2, 4, 3), (3, 1, 2), (3, 1, 4), (3, 2, 1), (3, 2, 4), (3, 4, 1), (3, 4, 2), (4, 1, 2), (4, 1, 3), (4, 2, 1), (4, 2, 3), (4, 3, 1), (4, 3, 2)] 24

6.count（）

作用
传入一个初始值，一个步长（二者必须皆为整数类型），可以无限提供数字

将（A, B）和（B, A）看作不同组合

等价于（此为生成器，未学过的同学请移步Python——生成器）

  def count(firstval=0, step=1):
          x = firstval
          while 1:
              yield x
              x += step

返回值
itertools.count类型对象 一个迭代器对象

案例

from itertools import count

iterator = count(0,2)
for i in iterator:
    print(i)

#输出结果：无法展示，请自行尝试

7.product（）

作用

• product(A, B) 等价于 ((x,y) for x in A for y in B)
• product(A, repeat=4) 等价于 product(A, A, A, A)

返回值
itertools.product类型对象 一个迭代器对象

案例

from itertools import product

iterator = product(range(3),["1","2"])
print(list(iterator))

#输出结果：[(0, '1'), (0, '2'), (1, '1'), (1, '2'), (2, '1'), (2, '2')]

iterator = product(range(3))
print(list(iterator))

#输出结果：[(0,), (1,), (2,)]

8.cycle（）

作用
对同一个可迭代对象进行循环遍历

返回值
itertools.cycle类型对象 一个迭代器对象

案例

from itertools import cycle

lst = [[1,2],[3,4]]
iterator = cycle(lst)
for i in iterator:
    print(i)
    
#输出结果：无法展示，请自行尝试

lst = [[1,2],[3,4]]
iterator = cycle(lst)
for i in range(4):
    print(next(iterator))
    if i%2 :
        lst[0].pop()
        
#输出结果：
"""
[1, 2]
[3, 4]
[1]
[3, 4]
"""

9.chain（）

作用
将多个可迭代对象的元素都取出，作为一个迭代器对象的元素

返回值
itertools.cycle类型对象 一个迭代器对象

案例

from itertools import chain

lst1 = [[1, 2], 3, 4]
lst2 = [[5, 6, 7], 8]
iterator = chain(lst1, lst2)
print(list(iterator))

#输出结果：[[1, 2], 3, 4, [5, 6, 7], 8]

functools模块

functools 模块应用于高阶函数，即参数或（和）返回值为其他函数的函数。 通常来说，此模块的功能适用于所有可调用对象

1.reduce（）

作用
对于一个初始值（）以及可迭代对象中的所有元素，不断累计调用一个具有两个形参的计算函数，最后将整个过程的最终计算结果进行返回（注意，每一次计算的结果将作为第一个形参对应的实参，而不是第二个）

无默认的计算函数，必须进行指定

返回值
函数累计计算的结果

案例

from functools import reduce

d = reduce(lambda a, b : a + b, [1, 2, 3, 4])
print(d)

#输出结果：10

d = reduce(lambda a, b : a * b, [1, 2, 3, 4])
print(d)

#输出结果：24

d = reduce(lambda a, b : a * b, [1, 2, 3, 4], 2)
print(d)

#输出结果：48

2.partial（）

作用
Partial function意思为偏函数，可以对现有函数进行加强

可以先行将一个可确定要放入的参数先放入函数中，创建一个传入了一部分参数的可调用的对象，后续要使用时，可以调用该对象，并传入剩余的参数，实现原函数的功能

返回值
一个可调用对象

案例

from functools import partial

def f(a, b = 1):
    print(a ,b)
    
f_new = partial(f, 2)
f_new(3)

#输出结果：2 3

random模块

1.shuffle（）

作用
原地随机打乱一个列表

返回值
空类型对象 None

案例

from random import shuffle

lst = [1, 2, 3, 4]
for i in range(3):
    shuffle(lst)
    print(lst)

#输出结果：
"""
[4, 3, 1, 2]
[3, 4, 2, 1]
[1, 4, 2, 3]
"""

2.randint（）

作用
从指定的[a，b]中随机得到一个int类型对象

返回值
int类型对象

案例

from random import randint

for i in range(3):
    num = randint(1,2)
    print(num)

#输出结果：
"""
1
2
2
"""

2.randrange（）

作用
从指定的[a，b)中随机得到一个int类型对象

返回值
int类型对象

案例

from random import randrange

for i in range(3):
    num = randrange(1,2)
    print(num)

#输出结果：
"""
1
1
1
"""

3.choice（）

作用
从一个序列中随机选择1个元素

返回值
被随机选中的对象

案例

from random import choice

lst = [1,2,3,4]
obj = choice(lst)
print(obj)

#输出结果：3

lst = [[1],[2],[3],[4]]
obj = choice(lst)
print(obj)

#输出结果：[4]

4.choices（）

作用
从一个列表/元组/字符串中随机选择k次，默认选择一次

每次选取都是独立的，每一次选取都是基于原序列，每一次选取的元素对应原序列中元素的下标可能相同

返回值
列表类型对象

案例

from random import choices

lst = [1, 2, 3, 4]
obj = choices(lst, k = 6)
print(obj)

#输出结果：[1, 4, 3, 4, 3, 3]

from random import choices

lst = [1, 2, 3, 4]
obj = choices(lst)
print(obj)

#输出结果：[1]

5.sample（）

作用
从一个列表/元组/字符串中随机选择k次，无默认值，必须要对k进行指定

选取k次，每一次选取会影响下一次选取的对象，每一次选取的元素对应原序列中元素的下标必定不同，于是k值不能超出序列的元素总数

sample(['red', 'blue'], counts=[4, 2], k=5)

等价于

sample(['red', 'red', 'red', 'red', 'blue', 'blue'], k=5)

返回值
列表类型对象

案例

from random import choices

lst = [1, 2, 3, 4]
obj = choices(lst, k = 6)
print(obj)

#输出结果：[1, 4, 3, 4, 3, 3]

from random import choices

lst = [1, 2, 3, 4]
obj = choices(lst)
print(obj)

#输出结果：[1]

collections模块

Counter（）

作用
先将一个可迭代对象的元素以及对应元素的个数进行映射，再进行存储

选取k次，每一次选取会影响下一次选取的对象，每一次选取的元素对应原序列中元素的下标必定不同，于是k值不能超出序列的元素总数

返回值
collections.Counter类型对象 可迭代对象

案例

from collections import Counter

c = Counter("12312312")
d = dict(c)
print(d)

#输出结果：{'1': 3, '2': 3, '3': 2}

os模块

os 模块提供了一种使用与操作系统相关的功能的便捷式途径，提供了大量的文件和文件夹操作函数。对于高级文件和目录处理，请参阅 shutil 模块

1.chdir（）

作用
传入一个指定路径path，把指定路径设置为当前的工作目录

返回值
空类型对象 None

案例

import os

os.chdir(r'D:\\')
fp = open('test.txt', 'w')

#代码效果：如果名称为'test.txt'的文件存在于r'D:\\'路径中，则打开文件；如果不存在，则创建

2.getcwd（）

作用
得到当前的工作目录

返回值
字符串类型对象 当前工作目录

案例

import os

os.chdir(r'D:\\')		#修改当前工作目录
cur_path = os.getcwd()
print(cur_path)			#打印当前工作目录

#输出结果：D:\

3.listdir（）

作用
传入一个指定path，得到指定path目录下的文件和目录列表，只能返回第一层级的内容，而不能列出子文件夹中的内容

不会显示出系统文件，这也是一种保护措施，以免我们误操作对系统造成损害

返回值
列表类型对象 该指定路径下，第一层的文件（包含文件后缀名）和文件夹名字的列表

案例

import os

path_list = os.listdir(r'C:\\')
print(path_list)

#输出结果：r'C:\\'路径下的第一层的文件和文件夹名字的列表

4.remove（）

作用
删除指定的文件，要求用户必须拥有删除文件的权限，并且文件没有只读或其他特殊属性，否则会抛出异常

不会显示出系统文件，这也是一种保护措施，以免我们误操作对系统造成损害

返回值
列表类型对象 该指定路径下，第一层的文件（包含文件后缀名）和文件夹名字的列表

案例

import os

os.remove(r'test.txt')

#代码效果：删除当前运行的目录下名称为'test.txt'的文件

5.rename（）

作用
重命名文件或目录，可以实现文件的移动（因为文件名就表明了文件所处位置），若目标文件已存在则抛出异常，不能跨越磁盘或分区

返回值
列表类型对象 该指定路径下，第一层的文件（包含文件后缀名）和文件夹名字的列表

案例

import os

os.rename(r'D:\first\test.txt', r'D:\second\test.txt')	#此时'D:\second'中不存在同名文件

#代码效果：将位于'D:\first'中名称为'test.txt'，转移到'D:\second'中

os.rename(r'D:\first\test.txt', r'C:\first\test.txt')

#引发异常：[WinError 17] 系统无法将文件移到不同的磁盘驱动器。: 'D:\\first\\test.txt' -> 'C:\\first\\test.txt'

os.rename(r'D:\first\test.txt', r'D:\second\test.txt')	#此时'D:\second'中存在同名文件

#引发异常：[WinError 183] 当文件已存在时，无法创建该文件。: 'D:\\first\\test.txt' -> 'D:\\second\\test.txt'

6.startfile（）

作用
使用关联的应用程序打开指定文件或启动指定应用程序

返回值
空类型对象 None

案例

import os

os.startfile(r'D:\test.txt')

#代码效果：打开文本文件'D:\test.txt'

7.mkdir（）

作用
传入一个指定路径path，根据在指定路径下创建指定文件夹名的文件夹，其中的mode形参在Windows系统下无效

当文件夹已存在时，无法创建该文件夹

返回值
空类型对象 None

案例

import os

os.mkdir(r'C:\\test')	#此时'C:\'路径下不存在同名文件夹

#代码效果：在'C:\'路径下创建一个名称为test的文件夹

os.mkdir(r'C:\\test')	#此时'C:\'路径下存在同名文件夹

#引发异常：[WinError 183] 当文件已存在时，无法创建该文件。: 'C:\\\\test'

8.basename（）

作用
传入一个指定路径，得到指定路径的最后一个组成部分，即最后一个路径分隔符后面的部分（通常为文件名）

返回值
字符串类型对象 文件名（包含文件后缀名）

案例

from os import path

file_name = path.basename(r'C:\\test.txt')
print(file_name)

#输出结果：test.txt

9.dirname（）

作用
传入一个指定路径，得到给定路径的最后一个路径分隔符前面的所有路径信息

返回值
字符串类型对象 最后一个路径分隔符前面的所有路径信息

案例

from os import path

dir_name = path.dirname(r'C:\\first\\test.txt')
print(dir_name)

#输出结果：C:\\first

10.exists（）

作用
传入一个指定路径，判断文件或者文件夹是否存在

返回值
布尔类型对象 True 或 False

案例

from os import path

b = path.exists(r'D:\\test.txt')	#查看在路径'D:\'是否具有名称为test.txt的文件
print(b)

#输出结果：True

b = path.exists(r'D:\\test')	#查看在路径'D:\'是否具有名称为test的文件夹
print(b)

#输出结果：True

11.getmtime（）

作用
传入一个指定路径，得到该文件的最后修改时间（时间戳（秒数），可以使用时间戳在线工具转换一下）

返回值
布尔类型对象 True 或 False

案例

from os import path

time = path.getmtime(r'D:\\test.txt')
print(time)

#输出结果：1676635755.5998702

12.getsize

作用
传入一个指定路径，得到该文件的大小

返回值
int对象 指定文件的大小

案例

from os import path

size = path.getsize(r'D:\\test.txt')
print(size)

#输出结果：14

13.isdir

作用
传入一个指定路径path，判断指定路径是否为文件夹

返回值
布尔类型对象 True 或 False

案例

from os import path

b = path.isdir(r'D:\\test.txt')
print(b)

#输出结果：False

b = path.isdir(r'D:\\test')
print(b)

#输出结果：True

14.isfile

作用
传入一个指定路径path，判断指定路径是否为文件

返回值
布尔类型对象 True 或 False

案例

from os import path

b = path.isfile(r'D:\\test.txt')
print(b)

#输出结果：True

b = path.isfile(r'D:\\test')
print(b)

#输出结果：False

15.join

作用
连接两个或多个path形成一个完整的路径，并同时插入适当的路径分隔符（在Windows操作系统下为反斜线）

返回值
字符串类型对象 形成的完整路径

案例

from os import path

path = path.join(r'C:\\', r'first', r'test.txt')
print(path)

#输出结果：C:\\first\test.txt

16.split

作用
以最后一个路径分隔符为界，把路径分隔成两部分，以元组形式返回

返回值
元组类型对象 一个保存着两部分路径的元组

案例

from os import path

path_tuple = path.split(r'C:\first\test.txt')
print(path_tuple)

#输出结果：('C:\\first', 'test.txt')

17.splitext

作用
把路径中的文件扩展名和前面的部分分割成两部分，用于从路径中分隔文件的扩展名，以元组形式返回

返回值
元组类型对象 一个保存着两部分路径和文件扩展名的元组

案例

from os import path

path_tuple = path.splitext(r'C:\first\test.txt')
print(path_tuple)

#输出结果：('C:\\first\\test', '.txt')