前段时间准备第十五届蓝桥杯python a组，因为赛中不允许导包，因此对py中的标准库进行了笔记和总结，即不导包即可使用的常用方法。包含了内置函数、math、random、datetime、os、sys、re、queue、collections、itertools库的常用方法，以当工具博客方便查阅。

内置函数

数学函数

abs() 函数：取绝对值

print(abs(-1))
# 1

divmod() 函数 ：同时取商和余数

print(divmod(7,2))
# (3, 1)

sum() 函数 ：求和计算

print(sum([1,2,3]))
# 6

round() 函数： 四舍五入

print(round(5.4))# 5
print(round(5.5))# 6

pow() 函数 ：计算任意N次方值

print(pow(2,3))# 2^3 = 8
# 也可以使用‘**’
print(2**3)

min()、max() 函数 ：获取最小、最大值

print(min(9,5,2,7))# 2
print(max(9,5,2,7))# 9

数据转换函数

hex() 函数： 十转十六进制

print(hex(100)) # 0x64

oct() 函数： 十转八进制

print(oct(100)) # 0o144 

bin() 函数 ：十进制转换成二进制

print(bin(100)) # 0b1100100

bool() 函数 ：将指定的参数转换成布尔类型

float() 函数 ：转换成浮点数

ord() 函数 ：获取单个字符的ASCII数值

print(ord('A')) # 65

chr() 函数： 转换一个整数并返回所对应的字符

print(chr(65)) # A

list() 函数： 将可迭代对象转换为列表

print(list(range(1,10)))
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

对象创建函数

range()函数：创建一个可迭代对象,内容是指定范围内的连续整数

for i in range(5):print(i)
'''
0
1
2
3
4
'''

set()函数：创建一个无序不重复元素集合，可用作去重

set([1,2,1,1,3,4,4,6,5])
# {1, 2, 3, 4, 5, 6}

迭代器操作函数

all() 函数： 判断指定序列中的所有元素是否都为 True，则返回 True，如果有一个为 False，则返回 False。

a = [1,2,0]
print(all(a))
# False

any()函数： 判断指定序列中的所有元素是否都为 False，则返回 False，如果有一个为 True，则返回 True。

a = [1,0,0]
print(any(a))
# True

sorted() 函数： 对可迭代对象进行临时排序

a = [3,1,4,2]
print(sorted(a))
# [1, 2, 3, 4]

len()函数： 返回一个对象的元素或项目个数

print(len([1,2,3,4]))
# 4

map()函数： 通过自定义函数实现对序列的元素映射操作并返回操作后的结果

list(map(int,['1','2','3']))
# [1, 2, 3]

字符串操作函数

format( )函数： 格式化数据

"{} {}".format("hello", "world")
# 'hello world'
print("{:.2f}".format(3.1415926));
# 3.14
a = "good"
b = "luck"
t = "{} {}".format(a,b)
# good luck
t = f"{a.title()} {b}"
# 可以引入.title()来改写字符串格式，这里需要注意的是，f字符串是有py3.6引入的
# Good luck

count( ), 返回子串str2 在 str1 里面出现的次数

str1 = 'dsaddddd'
str2 = 'd'
print(str1.count(str2, 0, len(str1))) # 6
print(str1.count(str2, 0, 3)) # 1

endswith() 用于检查字符串是否以指定的后缀结束，如果字符串以指定的后缀结束，则返回 True，否则返回 False。

my_str = "Hello, world!"
print(my_str.endswith("world!"))  # True
print(my_str.endswith("Python"))  # False

find( ), 检测 子字符串是否包含在指定字符串中，find到返回开始的索引值，否则返回-1

str1 = 'dsaddddd'
str2 = 'd'
print(str1.find(str2, 0, len(str1))) # 0
print(str1.find(str2, 1, 3)) # -1

join(), 以 接收可选的参数 sep作为分隔符，将接受的一个可迭代对象（如列表、元组等）将参数中所有的元素(的字符串表示)合并为一个新的字符串

my_list = ["Hello", "world", "!"]
str1 = ' '
result = str1.join(my_list)
print(result)  # 输出："Hello|world|!"
str2 = '@'
result = str2.join(my_list)
print(result)  # 输出："Hello@world@!"

对字符串进行大小写改写操作

t = "good Luck"
t.title( ) 
#对每个单词首字母改为大写,Good Luck
t.upper( ) 
#字母全大写,GOOD LUCK
t.lower( ) 
#字母全小写,good luck
t.swapcase()
# 翻转大小写,GOOD lUCK

删除字符串空白：

t = " python "
print(t.lstrip())
# 对开头空白进行删除
print(t.rstrip())
# 对末尾空白进行删除
print(t.strip())
# 对两端空白进行删除

需要注意的是，上述的三个方法只是暂时的，并没有改变原来的内容

math库

提供数学相关的函数，如三角函数、指数函数、对数函数等

数学常数

math.e：自然常数 e 的值，约等于 2.71828。

math.pi：圆周率 π 的值，约等于 3.14159。

import math
print(math.e) # 2.718281828459045
print(math.pi) # 3.141592653589793

常用数学函数

math.sqrt(x)：返回 x 的平方根。

math.pow(x, y)：返回 x 的 y 次方。

math.exp(x)：返回 e 的 x 次方。

math.log(x, base=math.e)：返回 x 的对数。base 参数为对数的底数，默认为自然对数 e。

math.sin(x)、math.cos(x)、math.tan(x)：返回 x 的正弦、余弦和正切值。

math.asin(x)、math.acos(x)、math.atan(x)：返回 x 的反正弦、反余弦和反正切值。

import mathprint(math.sqrt(9)) # 3.0 类型为float
print(math.pow(2, 3)) # 8.0 类型为float
print(math.exp(1)) # 2.71828182845904523536963
print(math.log(2, 10)) # log10^2print(math.sin(math.pi / 2))
print(math.cos(math.pi / 3))
print(math.tan(math.pi / 4))
# 1.0
# 0.5000000000000001
# 0.9999999999999999print(math.asin(1))
print(math.acos(1))
print(math.atan(1))
# 1.5707963267948966
# 0.0
# 0.5707963267948966

数值运算函数

math.ceil(x)：返回不小于 x 的最小整数。

import math
print(math.ceil(3.14))  # 输出：4
print(math.ceil(-3.14))  # 输出：-3

math.floor(x)：返回不大于 x 的最大整数。

import math
print(math.floor(3.14))  # 输出：3
print(math.floor(-3.14))  # 输出：-4

math.trunc(x)：返回 x 的整数部分。

math.modf(x)：返回 x 的小数部分和整数部分，以元组形式返回。

import mathprint(math.trunc(3.14))  # 输出：3
print(math.modf(3.14))  # 输出：(0.14000000000000012, 3.0)

math.fabs(x)：返回 x 的绝对值。

math.factorial(x)：返回 x 的阶乘。

math.gcd(a, b)：返回 a 和 b 的最大公约数。

import math
print(math.fabs(-3.14))  # 输出：3.14
print(math.factorial(5))  # 输出：1*2*3*4*5=120print(math.gcd(12, 15))  # 输出：3

特殊函数

math.erf(x)

误差函数返回了给定值 x 的误差，即标准正态分布中，比 x 大的概率。

import math# 计算 2 的误差函数
print(math.erf(2))  # 输出：0.9953222650189345

math.erfc(x)

余误差函数返回了给定值 x 的余误差，即标准正态分布中，比 x 小的概率。

import math# 计算 2 的余误差函数
print(math.erfc(2))  # 输出：0.00467773498106536

math.gamma(x)

伽马函数是阶乘函数的拓展版本，可以用于计算组合数。

import math# 计算 5 的伽马函数
print(math.gamma(5))  # 输出：24

math.lgamma(x)

伽马函数的自然对数。

import math# 计算 5 的伽马函数的自然对数
print(math.lgamma(5))  # 输出：2.302585092994046

random库

提供随机数相关的函数，如生成随机整数、随机浮点数、随机序列等

random.randint(a, b)：返回一个范围为 [a, b] 的随机整数。

import random
print(random.randint(1, 10))  # 输出：一个介于 1 和 10 之间的随机整数，包括 1 和 10

random.uniform(a, b)：返回一个范围为 [a, b] 的随机浮点数。

import random
print(random.uniform(1, 10))  # 输出：一个介于 1 和 10 之间的随机浮点数，包括 1 和 10

random.choice(sequence)：从给定的序列（如列表、元组等）中随机选择一个元素。

import randommy_list = [1, 2, 3, 4, 5]
print(random.choice(my_list))  # 输出：my_list 中的一个随机元素

random.shuffle(x[, random])：将给定的列表或元组进行随机排序。

import randommy_list = [1, 2, 3, 4, 5]
random.shuffle(my_list)
print(my_list)  # 输出：一个随机排序后的列表

datatime库

提供日期和时间相关的函数，如获取当前日期、时间差计算、日期格式化等

datetime.datetime.now()：返回当前的日期和时间

from datetime import datetime
print(datetime.now())

timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)：创建一个时间间隔

from datetime import datetime, timedelta# 创建一个表示 7 天的时间间隔
seven_days = timedelta(days=7)
# 获取当前时间
now = datetime.now()# 计算 7 天后的时间
future = now + seven_days
print(future)

datetime.strftime('%Y-%m-%d %H:%M:%S')：将日期和时间格式化为字符串

from datetime import datetime# 获取当前时间
now = datetime.now()# 将当前时间格式化为字符串
formatted_now = now.strftime('%Y-%m-%d %H:%M:%S')
print(formatted_now)

os库

提供操作系统相关的函数，如文件和目录操作、进程管理等

os.getcwd()：获取当前工作目录

os.listdir()：列出当前目录下的所有文件和子目录

import oscurrent_dir = os.getcwd()
print("当前工作目录:", current_dir)files_and_dirs = os.listdir(current_dir)
print("当前目录下的文件和子目录:", files_and_dirs)

os.path.join()：将多个路径组件连接在一起

import ospath1 = "/home"
path2 = "user"
path3 = "documents"full_path = os.path.join(path1, path2, path3)
print("完整路径:", full_path)

os.path.exists()：检查一个路径是否存在

import ospath = "/home/user/documents"
if os.path.exists(path):print("路径存在")
else:print("路径不存在")

os.system()：运行一个系统命令

import oscommand = "ls -l"
result = os.system(command)
print("命令结果:", result)

sys库

提供与 Python 解释器相关的函数和变量，如获取命令行参数、获取系统版本等

sys.argv[]：获取命令行参数

import sys
print("命令行参数:", sys.argv)

sys.version_info.major：获取Python版本的主要部分

import sys
version_major = sys.version_info.major
print("Python版本主要部分:", version_major)

sys.exit()：退出程序，将导致程序立即退出，不再执行后续代码，可以当强化版break

import sysprint('live')
sys.exit()
print('kill')

re库

提供正则表达式相关的函数，用于字符串匹配和替换等操作

^：匹配字符串开头
" * " 匹配前面的子表达式零次或多次
" + " 匹配前面的子表达式一次或多次
" ？ " 匹配前面的子表达式零次或一次
" [abc]" ：方括号表示字符集合，例子表示一个字符串有一个 “a” 或 “b” 或 “c” 等价于 [a|b|c]
" [a-z]“： 表示一个字符串中存在一个 a 和 z 之间的所有字母
" [^a-z]” ：表示一个字符串中不应该出现 a 到 z 之间的任意一个字母
" [0-9]“： 表示一个字符串中存在一个 0 和 9 之间的所有数字
" \d " 匹配一个数字字符，等价[0-9]
" \D " 匹配一个非数字字符，等价[^0-9]
" \w” 匹配包括下划线的任何单词字符。等价于“[A-Za-z0-9_]”
" \W" 匹配任何非单词字符。等价于“[^A-Za-z0-9_]”

group()是正则表达式匹配对象的方法，用于获取匹配到的字符串。

re.match(pattern, string[, flags])：从字符串的开头开始匹配，如果开头部分匹配成功，返回一个匹配对象，否则返回None。

其中，pattern是正则表达式，string是需要匹配的字符串，flags是可选的匹配标志。

import repattern = r'[a-z]+'
text = 'abc567aa'match = re.match(pattern, text)
if match:print("匹配成功:", match.group())
else:print("匹配失败")
# 匹配成功: abc

re.search(pattern, string[, flags])：在整个字符串中搜索匹配的子串，如果找到，返回一个匹配对象，否则返回None。

import repattern = r'\d+'
text = 'abc123def'search = re.search(pattern, text)
if search:print("匹配成功:", search.group())
else:print("匹配失败")# 匹配成功: 123

re.findall(pattern, string[, flags])：返回字符串中所有匹配的子串，返回一个列表。

import repattern = r'\d+'
text = 'abc123def456'findall = re.findall(pattern, text)
print("匹配成功:", findall)
# 匹配成功: ['123', '456']

re.sub(pattern, repl, string[, count, flags])：替换字符串中所有匹配的子串。函数的第一个参数是正则表达式模式，第二个参数是要替换的字符串。

其中，pattern是正则表达式，repl是替换字符串，string是需要匹配的字符串，count是可选的替换次数，默认是0

import repattern = r'\d+'
text = 'abc123def456'
replace = re.sub(pattern, 'X', text[6:])
print("替换成功:", replace)
# 替换成功: defX

queue库

使用更高级的队列和栈数据结构

queue模块提供了多种队列实现方式，包括先进先出队列（FIFO）、后进先出队列（LIFO）和优先级队列。队列实现是线程安全的，因此适用于多线程编程。

queue.Queue()：这是一个标准的队列实现，遵循先进先出（FIFO）的规则

import queueq = queue.Queue()
q.put('a')
q.put('b')
q.put('c')while not q.empty():print(q.get())
'''
a
b
c
'''

queue.LifoQueue()：后进先出（LIFO）队列

import queueq = queue.LifoQueue()
q.put('a')
q.put('b')
q.put('c')while not q.empty():print(q.get())
'''
c
b
a
'''

queue.PriorityQueue()：优先级队列。元素被赋予优先级，优先级高的元素会被优先处理。

import queueq = queue.PriorityQueue()
q.put((1, 'a'))
q.put((3, 'b'))
q.put((2, 'c'))while not q.empty():print(q.get())
'''
(1, 'a')
(2, 'c')
(3, 'b')
'''

collections库

deque双端队列

允许从两端添加或删除元素，在某些方面类似于列表，但它更适用于需要频繁从两端添加或删除元素的场合。deque的实现使用了append()和pop()方法来添加和删除元素，这些操作的时间复杂度为O(1)。因此，deque在处理大量数据时比列表更高效。

以下是deque的一些常用用法：

创建一个双端队列：

from collections import deque
d = deque([1, 2, 3])

添加元素到队列的两端：

d.append(4)  # 在队列末尾添加元素
d.appendleft(0)  # 在队列开头添加元素
print(d)  # deque([0, 1, 2, 3, 4])

从队列的两端删除元素：

d.pop()  # 删除并返回队列末尾的元素
d.popleft()  # 删除并返回队列开头的元素
print(d)  # deque([1, 2, 3])

切片操作：

d[0]  # 获取队列开头的元素
d[-1]  # 获取队列末尾的元素
d[1:3]  # 获取队列中索引为1到2的元素，即元素2和3

索引操作：

d.index(2)  # 返回队列中元素2的索引

计数操作：

d.count(2)  # 返回队列中元素2的个数

这些操作与列表的操作类似，但deque在处理大量数据时更高效。

Counter计数字典

跟踪可迭代对象中元素的出现次数。

例如，我们可以使用Counter来统计一个列表中每个元素出现的次数：

from collections import Counterlst = [1, 2, 3, 1, 2, 3, 1, 2, 3]
counter = Counter(lst)print(counter)  # 输出：Counter({1: 3, 2: 3, 3: 3})

Counter对象可以进行许多操作，例如：

• 元素个数：len(counter)
• 某个元素出现的次数：counter[element]
• 添加新元素：counter[element] += 1
• 删除元素：del counter[element]
• 元素迭代：for element in counter
• 元素计数：sum(counter.values())

namedtuple具有字段名的元组

例如，我们可以使用namedtuple来创建一个表示点的坐标：

from collections import namedtuplePoint = namedtuple('Point', ['x', 'y'])
p = Point(3, 4)print(p)  # 输出：Point(x=3, y=4)

namedtuple创建的类型具有与元组相同的内存结构，但可以更方便地访问其字段。例如，我们可以直接使用p.x和p.y来访问点的坐标，而不需要使用索引。

此外，namedtuple还支持一些其他操作，例如：

• 字段名索引：p[0]、p[1]
• 切片：p[:2]、p[1:]
• 迭代：for field in p
• 元素计数：len(p)
• 元素测试：3 in p

itertools库

itertools是Python的一个标准库，它提供了一系列用于高效循环迭代的工具。

itertools中的函数和类主要用于生成迭代器，这些迭代器可以用于循环、迭代以及其他需要重复执行操作的场景。

以下是一些常用的itertools库中的函数和类：

chain(*iterables)：创建一个迭代器，将多个可迭代对象连接起来。

from itertools import chaina = [1, 2, 3]
b = [4, 5, 6]for x in chain(a, b):print(x)  # 输出：1 2 3 4 5 6

combinations(iterable, r)：创建一个迭代器，返回可迭代对象中元素的所有r长度组合。

from itertools import combinationsfor x in combinations([1, 2, 3], 2):print(x)  # 输出：(1, 2) (1, 3) (2, 3)

permutations(iterable, r=None)：创建一个迭代器，返回可迭代对象中元素的所有r长度排列。

from itertools import permutationsfor x in permutations([1, 2, 3], 2):print(x)  # 输出：(1, 2) (1, 3) (2, 1) (2, 3) (3, 1) (3, 2)

product(iterable, repeat=1)：创建一个迭代器，返回可迭代对象中元素的所有组合。

from itertools import productfor x in product([1, 2], ['a', 'b'], repeat=2):print(x)  
# 输出：(1, 'a', 1, 'a') (1, 'a', 1, 'b') (1, 'a', 2, 'a') (1, 'a', 2, 'b') (1, 'b', 1, 'a') (1, 'b', 1, 'b') (1, 'b', 2, 'a') (1, 'b', 2, 'b') (2, 'a', 1, 'a') (2, 'a', 1, 'b') (2, 'a', 2, 'a') (2, 'a', 2, 'b') (2, 'b', 1, 'a') (2, 'b', 1, 'b') (2, 'b', 2, 'a') (2, 'b', 2, 'b')

cycle(iterable)：创建一个迭代器，返回可迭代对象中元素无限循环的迭代器。

from itertools import cyclefor x in cycle([1, 2, 3]):print(x)  # 输出：1 2 3 1 2 3 1 2 3 ...

groupby(iterable, key=None)：创建一个迭代器，将可迭代对象中具有相同键值的元素分组。

from itertools import groupbyfor x in groupby([1, 2, 2, 3, 3, 3], key=lambda x: x):print(x)  # 输出：((1,), (2, 2), (3, 3, 3))

islice(iterable, start, stop=None, step=1)：创建一个迭代器，返回可迭代对象中指定范围内的元素。

from itertools import islicefor x in islice([1, 2, 3, 4, 5], 2, 5):print(x)  # 输出：2 3 4