模块所有方法大汇总，超详细！

keyword

• kwlist：返回Python中所有的关键字。

import keyword

# 返回Python中所有的关键字
kwlist = keyword.kwlist
print(kwlist)

random

• 生成随机数：
  • random()：生成一个0到1之间的随机实数。
  • randint(a, b)：生成[a, b]之间的随机整数。
  • uniform(a, b)：生成[a, b]之间的随机实数。
• 随机序列操作：
  • choice(seq)：从序列seq中随机选择一个元素。
  • shuffle(seq)：将序列seq中的元素随机排列，返回打乱后的序列。
  • sample(seq, n)：从序列seq中随机选择n个元素，返回一个列表。

import random

# 生成0到1之间的随机实数
rand_num = random.random()
print(rand_num)

# 生成[a, b]之间的随机整数
rand_int = random.randint(a, b)
print(rand_int)

# 生成[a, b]之间的随机实数
rand_float = random.uniform(a, b)
print(rand_float)

# 从序列seq中随机选择一个元素
seq = [1, 2, 3, 4, 5]
rand_elem = random.choice(seq)
print(rand_elem)

# 将序列seq中的元素随机排列，返回打乱后的序列
random.shuffle(seq)
print(seq)

# 从序列seq中随机选择n个元素，返回一个列表
n = 3
rand_list = random.sample(seq, n)
print(rand_list)

turtle

• 画笔控制：
  • penup()：抬起画笔，不绘制图形。
  • pendown()：放下画笔，开始绘制图形。
  • pencolor(color)：设置画笔颜色。
  • pensize(size)：设置画笔尺寸。
• 运动控制：
  • forward(distance)：前进指定距离。
  • backward(distance)：后退指定距离。
  • right(angle)：向右旋转指定角度。
  • left(angle)：向左旋转指定角度。
  • goto(x, y=None)：将画笔移动到坐标(x, y)。
  • setx(x)：将画笔的x坐标移动到指定位置。
  • sety(y)：将画笔的y坐标移动到指定位置。
• 颜色控制：
  • fillcolor(color)：设置填充颜色。
  • begin_fill()：开始填充图形。
  • end_fill()：结束填充图形。

import turtle

turtle.penup()  # 抬起画笔，不绘制图形
turtle.pendown()  # 放下画笔，开始绘制图形
turtle.pencolor("red")  # 设置画笔颜色为红色
turtle.pensize(2)  # 设置画笔尺寸为2

turtle.forward(100)  # 前进100个像素
turtle.backward(50)  # 后退50个像素
turtle.right(90)  # 向右旋转90度
turtle.left(45)  # 向左旋转45度

turtle.goto(0, 0)  # 将画笔移动到坐标(0, 0)
turtle.setx(100)  # 将画笔的x坐标移动到100
turtle.sety(200)  # 将画笔的y坐标移动到200

turtle.fillcolor("blue")  # 设置填充颜色为蓝色
turtle.begin_fill()  # 开始填充图形
# 绘制图形
turtle.circle(50)
turtle.end_fill()  # 结束填充图形

math 

• 常量：
  • pi：圆周率。
  • e：自然常数。
• 数值运算：
  • ceil(x)：返回大于等于x的最小整数。
  • floor(x)：返回小于等于x的最大整数。
  • fabs(x)：返回x的绝对值。
  • sqrt(x)：返回x的平方根。
  • exp(x)：返回e的x次幂。
  • log(x[, base])：返回以base为底数的对数，如果不指定base，则默认为e。
  • sin(x)：返回x的正弦值。
  • cos(x)：返回x的余弦值。
  • tan(x)：返回x的正切值。
  • asin(x)：返回x的反正弦值。
  • acos(x)：返回x的反余弦值。
  • atan(x)：返回x的反正切值。
  • degrees(x)：将弧度转换为角度。
  • radians(x)：将角度转换为弧度。

import math

# 圆周率
pi = math.pi
print(pi)

# 自然常数
e = math.e
print(e)

# 返回大于等于x的最小整数
ceil_num = math.ceil(x)
print(ceil_num)

# 返回小于等于x的最大整数
floor_num = math.floor(x)
print(floor_num)

# 返回x的绝对值
abs_num = math.fabs(x)
print(abs_num)

# 返回x的平方根
sqrt_num = math.sqrt(x)
print(sqrt_num)

# 返回e的x次幂
exp_num = math.exp(x)
print(exp_num)

# 返回以base为底数的对数，如果不指定base，则默认为e
log_num = math.log(x, base)
print(log_num)

# 返回x的正弦值
sin_val = math.sin(x)
print(sin_val)

# 返回x的余弦值
cos_val = math.cos(x)
print(cos_val)

# 返回x的正切值
tan_val = math.tan(x)
print(tan_val)

# 返回x的反正弦值
asin_val = math.asin(x)
print(asin_val)

# 返回x的反余弦值
acos_val = math.acos(x)
print(acos_val)

# 返回x的反正切值
atan_val = math.atan(x)
print(atan_val)

# 将弧度转换为角度
degrees_val = math.degrees(x)
print(degrees_val)

# 将角度转换为弧度
radians_val = math.radians(x)
print(radians_val)

datetime

• datetime类：表示日期和时间的类。
• date类：表示日期的类。
• time类：表示时间的类。
• timedelta类：表示时间间隔的类。
• tzinfo类：用于处理时区的类。

import datetime

# 获取当前时间的时间戳
current_time = datetime.datetime.now().timestamp()
print(current_time)

# 获取当前时间的字符串表示
current_time_str = datetime.datetime.now().ctime()
print(current_time_str)

# 将一个时间戳转换为UTC时区的struct_time对象
utc_time = datetime.datetime.utcfromtimestamp(secs)
print(utc_time)

# 将一个时间戳转换为本地时区的struct_time对象
local_time = datetime.datetime.fromtimestamp(secs)
print(local_time)

# 将struct_time对象t格式化为指定的字符串格式
formatted_time = datetime.datetime.strftime(t, format)
print(formatted_time)

# 将字符串解析为struct_time对象
parsed_time = datetime.datetime.strptime(string, format)
print(parsed_time)

time

• 时间获取：
  • time()：返回当前时间的时间戳。
  • ctime()：返回当前时间的字符串表示。
  • gmtime([secs])：将一个时间戳转换为UTC时区的struct_time对象。
  • localtime([secs])：将一个时间戳转换为本地时区的struct_time对象。
• 时间格式化：
  • strftime(format[, t])：将struct_time对象t格式化为指定的字符串格式。
  • strptime(string[, format])：将字符串解析为struct_time对象。
• 睡眠：
  • sleep(secs)：让当前线程休眠指定的秒数。

import time

# 返回当前时间的时间戳（自1970年1月1日午夜以来的秒数）
timestamp = time.time()
print(timestamp)

# 将时间戳转换为UTC时区的struct_time对象
utc_time = time.gmtime(timestamp)
print(utc_time)

# 将时间戳转换为本地时区的struct_time对象
local_time = time.localtime(timestamp)
print(local_time)

# 将struct_time对象转换为时间戳
timestamp = time.mktime(local_time)
print(timestamp)

# 将struct_time对象转换为指定格式的字符串
formatted_time = time.strftime("%Y-%m-%d %H:%M:%S", local_time)
print(formatted_time)

# 将字符串解析为struct_time对象
parsed_time = time.strptime("2022-01-01 12:00:00", "%Y-%m-%d %H:%M:%S")
print(parsed_time)

# 暂停指定秒数的执行
time.sleep(3)

# 返回一个计时器的值，单位为秒（浮点数）
start_time = time.perf_counter()
# 执行一些操作
end_time = time.perf_counter()
elapsed_time = end_time - start_time
print(elapsed_time)

calendar

• 日历输出：
  • calendar(year, w=2, l=1, c=6)：返回指定年份的完整日历文本。
• 时间操作：
  • isleap(year)：判断指定年份是否为闰年。
  • leapdays(y1, y2)：返回[y1, y2]之间的闰年总数。

import calendar

# 返回指定年份的完整日历文本
year = 2022
cal_text = calendar.calendar(year)
print(cal_text)

# 判断指定年份是否为闰年
is_leap = calendar.isleap(year)
print(is_leap)

# 返回[y1, y2]之间的闰年总数
leap_years = calendar.leapdays(y1, y2)
print(leap_years)

json

• 编码：
  • dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)：将Python对象obj编码为JSON格式的字符串。
  • dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)：将Python对象obj编码为JSON格式并写入文件fp中。
• 解码：
  • loads(s, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)：将JSON格式的字符串s解码为Python对象。
  • load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)：从文件fp中读取JSON格式的字符串并解码为Python对象。

import json

# 将Python对象obj编码为JSON格式的字符串
data = {"name": "John", "age": 30}
json_str = json.dumps(data)
print(json_str)

# 将Python对象obj编码为JSON格式并写入文件fp中
with open("data.json", "w") as fp:
    json.dump(data, fp)

# 将JSON格式的字符串s解码为Python对象
json_data = '{"name": "John", "age": 30}'
py_obj = json.loads(json_data)
print(py_obj)

# 从文件fp中读取JSON格式的字符串并解码为Python对象
with open("data.json", "r") as fp:
    py_obj = json.load(fp)
print(py_obj)

pickle

• 序列化：
  • dump(obj, file, protocol=None, *, fix_imports=True)：将Python对象obj序列化为字节流并保存到文件file中。
  • dumps(obj, protocol=None, *, fix_imports=True)：将Python对象obj序列化为字节流并返回。
• 反序列化：
  • load(file, *, fix_imports=True, encoding="ASCII", errors="strict")：从文件file中读取字节流并反序列化为Python对象。
  • loads(bytes_object, *, fix_imports=True, encoding="ASCII", errors="strict")：从字节流bytes_object中反序列化为Python对象。

import pickle

# 将Python对象obj序列化为字节流并保存到文件file中
data = {"name": "John", "age": 30}
with open("data.pkl", "wb") as file:
    pickle.dump(data, file)

# 将Python对象obj序列化为字节流并返回
bytes_obj = pickle.dumps(data)
print(bytes_obj)

# 从文件file中读取字节流并反序列化为Python对象
with open("data.pkl", "rb") as file:
    py_obj = pickle.load(file)
print(py_obj)

# 从字节流bytes_object中反序列化为Python对象
py_obj = pickle.loads(bytes_obj)
print(py_obj)

csv

• 读取CSV文件：
  • reader(csvfile, dialect="excel", **fmtparams)：返回一个reader对象，可用于逐行读取CSV文件。
  • DictReader(csvfile, fieldnames=None, restkey=None, restval=None, dialect="excel", *args, **kwds)：返回一个DictReader对象，将CSV文件的每一行转换为字典形式。
• 写入CSV文件：
  • writer(csvfile, dialect="excel", **fmtparams)：返回一个writer对象，可用于逐行写入CSV文件。
  • DictWriter(csvfile, fieldnames, restval="", extrasaction="raise", dialect="excel", *args, **kwds)：返回一个DictWriter对象，将字典形式的数据写入CSV文件。

import csv

# 读取CSV文件
with open("data.csv", "r") as csvfile:
    reader = csv.reader(csvfile)
    for row in reader:
        print(row)

# 将CSV文件的每一行转换为字典形式
with open("data.csv", "r") as csvfile:
    reader = csv.DictReader(csvfile)
    for row in reader:
        print(row)

# 写入CSV文件
data = [{"name": "John", "age": 30}, {"name": "Jane", "age": 25}]
fieldnames = ["name", "age"]
with open("data.csv", "w", newline="") as csvfile:
    writer = csv.writer(csvfile)
    writer.writerow(fieldnames)
    for row in data:
        writer.writerow(row)

# 将字典形式的数据写入CSV文件
data = [{"name": "John", "age": 30}, {"name": "Jane", "age": 25}]
fieldnames = ["name", "age"]
with open("data.csv", "w", newline="") as csvfile:
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
    writer.writeheader()
    writer.writerows(data)

urllib

• 发送HTTP请求：
  • urlopen(url, data=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT, *, cafile=None, capath=None, cadefault=False, context=None)：打开指定的URL并返回响应对象。
• 解析URL：
  • parse_qs(qs, *, keep_blank_values=False, strict_parsing=False, encoding="utf-8", errors="replace")：将一个查询字符串解析为字典形式。
  • parse_qsl(qs, *, keep_blank_values=False, strict_parsing=False, encoding="utf-8", errors="replace")：将一个查询字符串解析为键值对的列表。
  • urlsplit(url, scheme="", allow_fragments=True)：将一个URL分解为5个部分，返回一个SplitResult对象。
  • urljoin(base, url, allow_fragments=True)：以base为基础，将相对路径url解析为绝对路径。

import urllib.parse
import urllib.request

# 打开指定的URL并返回响应对象
response = urllib.request.urlopen(url)
html = response.read()
print(html)

# 将一个查询字符串解析为字典形式
query_string = "name=John&age=30"
query_dict = urllib.parse.parse_qs(query_string)
print(query_dict)

# 将一个查询字符串解析为键值对的列表
query_list = urllib.parse.parse_qsl(query_string)
print(query_list)

# 将一个URL分解为5个部分，返回一个SplitResult对象
url = "https://www.example.com/path/?name=John"
split_result = urllib.parse.urlsplit(url)
print(split_result)

# 以base为基础，将相对路径url解析为绝对路径
base_url = "https://www.example.com"
relative_url = "/path"
absolute_url = urllib.parse.urljoin(base_url, relative_url)
print(absolute_url)

sys

• 系统操作：
  • exit([arg])：退出Python解释器，可选地指定一个退出码。
  • argv：命令行参数列表，第一个元素为程序本身路径。
  • path：模块搜索路径，可以通过修改该列表来添加或删除Python模块搜索的位置。

import sys

# 退出Python解释器，可选地指定一个退出码
sys.exit()

# 命令行参数列表，第一个元素为程序本身路径
args = sys.argv
print(args)

# 模块搜索路径，可以通过修改该列表来添加或删除Python模块搜索的位置
module_path = sys.path
print(module_path)

如果这篇文章对你有帮助，还请帮忙点赞关注。您的支持是我更新的最大动力！