前段时间准备第十五届蓝桥杯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 math
print(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^2
print(math.sin(math.pi / 2))
print(math.cos(math.pi / 3))
print(math.tan(math.pi / 4))
# 1.0
# 0.5000000000000001
# 0.9999999999999999
print(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 math
print(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=120
print(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 random
my_list = [1, 2, 3, 4, 5]
print(random.choice(my_list)) # 输出：my_list 中的一个随机元素
random.shuffle(x[, random])：将给定的列表或元组进行随机排序。
import random
my_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 os
current_dir = os.getcwd()
print("当前工作目录:", current_dir)
files_and_dirs = os.listdir(current_dir)
print("当前目录下的文件和子目录:", files_and_dirs)
os.path.join()：将多个路径组件连接在一起
import os
path1 = "/home"
path2 = "user"
path3 = "documents"
full_path = os.path.join(path1, path2, path3)
print("完整路径:", full_path)
os.path.exists()：检查一个路径是否存在
import os
path = "/home/user/documents"
if os.path.exists(path):
print("路径存在")
else:
print("路径不存在")
os.system()：运行一个系统命令
import os
command = "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 sys
print('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 re
pattern = 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 re
pattern = r'\d+'
text = 'abc123def'
search = re.search(pattern, text)
if search:
print("匹配成功:", search.group())
else:
print("匹配失败")
# 匹配成功: 123
re.findall(pattern, string[, flags])：返回字符串中所有匹配的子串，返回一个列表。
import re
pattern = 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 re
pattern = r'\d+'
text = 'abc123def456'
replace = re.sub(pattern, 'X', text[6:])
print("替换成功:", replace)
# 替换成功: defX
queue库
使用更高级的队列和栈数据结构
queue模块提供了多种队列实现方式，包括先进先出队列（FIFO）、后进先出队列（LIFO）和优先级队列。队列实现是线程安全的，因此适用于多线程编程。
queue.Queue()：这是一个标准的队列实现，遵循先进先出（FIFO）的规则
import queue
q = 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 queue
q = queue.LifoQueue()
q.put('a')
q.put('b')
q.put('c')
while not q.empty():
print(q.get())
'''
c
b
a
'''
queue.PriorityQueue()：优先级队列。元素被赋予优先级，优先级高的元素会被优先处理。
import queue
q = 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 Counter
lst = [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 namedtuple
Point = 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 chain
a = [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 combinations
for x in combinations([1, 2, 3], 2):
print(x) # 输出：(1, 2) (1, 3) (2, 3)
permutations(iterable, r=None)：创建一个迭代器，返回可迭代对象中元素的所有r长度排列。
from itertools import permutations
for 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 product
for 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 cycle
for x in cycle([1, 2, 3]):
print(x) # 输出：1 2 3 1 2 3 1 2 3 ...
groupby(iterable, key=None)：创建一个迭代器，将可迭代对象中具有相同键值的元素分组。
from itertools import groupby
for 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 islice
for x in islice([1, 2, 3, 4, 5], 2, 5):
print(x) # 输出：2 3 4
3293
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
