这篇博客详细总结了Python编程中的多个模块，包括sys、os、glob、re、datetime、pprint、pickle、文件操作、json、数据库交互以及数学和随机数功能。通过实例介绍了各个模块的关键方法和应用，如sys模块的交互、os模块的文件模式匹配、正则表达式的匹配规则、datetime模块的时间日期处理、pickle模块的数据序列化、文件操作的读写以及数据库的连接和操作。此外，还涵盖了面向对象编程的概念，包括类、对象、继承和封装。
5.1sys模块
定义
sys模块主要负责与Python解释器进行交互
常用方法
import sys
#如何查看sys里面有哪些方法
#help(sys)
#利用以上的不直观，我们可以dir
print(dir(sys))
| 属性或方法 | 描述 |
|---|---|
| sys.argv | 获取命令行参数列表，第一个参数是程序本身 |
| sys.exit(n) | 退出 Python 程序，exit(0) 表示正常退出。当参数非 0 时,会引发一个 SystemExit 异常，可以在程序中捕获该异常 |
| sys.version | 获取 Python 解释程器的版本信息 |
| sys.maxsize | 最大的 Int 值，在 64 位操作系统上是 263-1 |
| sys.path | 返回模块的搜索路径，初始化时使用 PYTHONPATH 环境变量的值 |
| sys.platform | 返回操作系统平台名称 |
| sys.stdin | 输入相关 |
| sys.stdout | 输出相关 |
| sys.stderr | 错误相关 |
| len() | 获取长度 |
| sys.path.insert(index,字符) | 指定下标插入数据 |
| sys.path = [] | 删除所有路径 |
| sys.getfilesystemencoding() | 获取文件系统使用编码方式，默认是 UTF-8 |
| sys.modules | 以字典的形式返回所有当前 Python 环境中已经导入的模块 |
| sys.builtin_module_names | 返回一个列表，包含所有已经编译到 Python 解释器里的模块的名字 |
| sys.modules.keys() | 返回所有已将导入模块的key |
| sys.flags | 命令行标识状态信息列表 |
| sys.getrefcount(object) | 返回对象的引用数量 |
| sys. getrecursionlimit() | 返回 Python 最大递归深度，默认为 1000 |
| sys.getsizeof(object[, default]) | 返回对象的大小 |
| sys.getswitchinterval() | 返回线程切换时间间隔，默认为0.005秒 |
| sys.setswitchinterval(interval) | 设置线程切换的时间间隔，单位为秒 |
| sys. getwindowsversion() | 返回当前 Windows 系统的版本信息 |
| sys.hash_info | 返回 Python 默认的哈希方法的参数 |
| sys.implementation | 当前正在运行的 Python 解释器的具体实现，如 CPython |
| sys.thread_info | 当前线程信息 |
代码
此代码在vscode里面写好在cmd窗口去运行
python 文件名字 参数
D:\axc\Python\PythonTemp>python count.py 12 3 4 5
import sys
print(sys.argv)
#exit(n)退出 Python 程序，exit(0) 表示正常退出
for i in range(10):
if i==5:
exit(0)
print(i)
# sys.version | 获取 Python 解释程器的版本信息
import sys
print(sys.version) #3.7.6 (tags/v3.7.6:43364a7ae0, Dec 19 2019, 00:42:30) [MSC v.1916 64 bit (AMD64)]
# sys.maxsize | 最大的 Int 值，在 64 位操作系统上是 263-1
print(sys.maxsize) #9223372036854775807
# sys.path | 返回模块的搜索路径，初始化时使用 PYTHONPATH 环境变量的值
print(sys.path)
import sys
print('Path 包括：', len(sys.path), '个部分构成')
sys.path.insert(0,"simple") #在路径首位置添加
print(sys.path)
a = sys.builtin_module_names
print(a) #所有内建模块的名字
import sys
print(sys.modules)
print("------------------------------------------------")
print(sys.modules.keys())
#sys.getrefcount(object)返回对象的引用数量
import sys
a = [1, 2, 3]
b = a
print(sys.getrefcount(a)) # 3
注意，这个列表被a、b以及getrefcount()三个地方调用，因此输出结果为3。
练习
"""
定义一个函数，属于一个名字，查看是否是内建模块
"""
def is_module(name):
if name in a:
print("是一个模块")
else:
print("什么都不是")
is_module("time")
5.2os模块
定义
os模块与操作系统交互，提供了访问操作系统底层的接口
sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境
常用方法
| 方法或变量 | 用途 |
|---|---|
| os.mkdir(‘dirname’) | 生成单级目录，相当于shell中mkdir dirname |
| os.makedirs(‘dirname1/dirname2’) | 可生成多层递归目录 |
| os.rmdir(‘dirname’) | 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname |
| os.removedirs(‘dirname1’) | 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推 |
| os.listdir(‘dirname’) | 列出指定目录下的所有文件和子目录，包括隐藏文件并以列表方式打印 |
| os.remove() | 删除一个文件 |
| os.rename(“oldname”,“newname”) | 重命名文件/目录 |
| os.path.abspath(path) | 返回path规范化的绝对路径 os.path.split(path) 将path分割成目录和文件名二元组返回 |
| os.path.dirname(path) | 返回path的目录 |
| os.path.exists(path) | 如果path存在，返回True；如果path不存在，返回False |
| os.path.isabs(path) | 如果path是绝对路径，返回True |
| os.path.isfile(path) | 如果path是一个存在的文件，返回True。否则返回False |
| os.path.isdir(path) | 如果path是一个存在的目录，则返回True。否则返回False |
| os.path.join(path1[,path2[, …]]) | 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略 |
| os.path.getatime(path) | 返回path所指向的文件或者目录的最后访问时间 |
| os.path.getmtime(path) | 返回path所指向的文件或者目录的最后修改时间 |
| os.path.getsize(path) | 返回path的大小 |
| os.getcwd() | 获取当前工作目录，即当前python脚本工作的目录路径 |
| os.chdir(“dirname”) | 改变当前脚本工作目录；相当于shell下cd |
| os.curdir | 返回当前目录: (’.’) |
| os.pardir | 获取当前目录的父目录字符串名：(’…’) |
| os.stat(‘path/filename’) | 获取文件/目录信息 |
代码
import os
#print(os.getcwd())#获取当前目录 D:\axc\Python\PythonTemp
#print(os.chdir(r"C:\\Users\\wangyujun\\Desktop"))#切换进入到哪个目录下
#print(os.getcwd()) #print(os.getcwd())
#os.rename('本文件.py','test.py')#os.rename(old,new)将old文件重命名为new
#os.remove('test.py')#删除文件
#os.mkdir('dis')#创建单级空文件夹，目录
#os.rmdir('dis')#删除单级空目录
#os.makedirs('dis\\b')#创建多层递归目录
#os.removedirs('dis\\b')#只能删除空的文件夹
#print(os.listdir('dis'))#列出指定目录下的所有文件及文件夹，包括隐藏文件，并返回一个list
#os.system('ipconfig')#可以直接操作系统命令,os.system(command)
"""
res=os.popen('ipconfig').read()#执行操作系统命令
print(res)
"""
import os
#print(os.path.dirname('D:\\axc\\Python\\PythonTemp\\count.py'))#返回path的目录,取父目录
print(os.path.split('D:\\axc\\Python\\PythonTemp\\count.py'))#将path分割成目录和文件名，并返回一个元组
#print(os.path.join('program','python','code','student.py'))#将多个路径拼起来
#print(os.path.exists('D:\\axc\\Python\\PythonTemp\\count.py'))#判断path(文件或文件夹)是否存在
#print(os.path.isfile('D:\\axc\\Python\\PythonTemp\\count.py'))#判断path是否是文件,True
#print(os.path.isdir('D:\\axc\\Python\\PythonTemp\\count.py'))#判断path是否是目录，False
文件模式匹配：glob模块
import glob
import os
#文件下面所有py为后缀的文件
for file in glob.glob("D:\\axc\\Python\\PythonTemp\\*.py"):
print(file)
print("-------------------------")
print(os.listdir('D:\\axc\\Python\\PythonTemp'))
"""
注意这里的glob返回指定的文件完整路径名，这点和os.listdir函数不同，os.listdir只是返回文件名。
"""
5.3正则表达式
定义
普通字符和元字符构成的字符串，描述一类字符串规则
元字符
有特殊含义的字符
| 表达式 | 匹配 |
|---|---|
. |
小数点可以匹配除了换行符\n以外的任意一个字符 |
| |
逻辑或操作符 ,或 |
[] |
匹配字符集中的一个字符 |
[^] |
对字符集求反，也就是上面的反操作。尖号必须在方括号里的最前面 |
- |
定义[]里的一个字符区间，例如[a-z] |
\ |
对紧跟其后的一个字符进行转义 |
() |
对表达式进行分组，将圆括号内的内容当做一个整体，并获得匹配的值 |
import re
a = re.findall("a.c","abcdefg")
print(a) #['abc']
#匹配a或者c
a = re.findall("a|c","abdefgc")
print(a) #['a', 'c']
#匹配列表中的任意任意一个字符
a = re.findall("[acbe]","abdefgc")
print(a) #['a', 'b', 'e', 'c']
#除了a和c其余都要
a = re.findall("[^ac]","adfgcvs")
print(a) #['d', 'f', 'g', 'v', 's']
#a-c 意思是匹配abc三个字符
a = re.findall("[a-c]","adfgcvs")
print(a) #['a', 'c']
#意思是把adf作为一个整体进行输出
a = re.findall("(adf)","adfgcvs")
print(a) #['adf']
#去掉小数点的特殊含义，他就是一个小数点
a = re.findall("\.","adf.gcvs")
print(a) #['.']
转义字符
| 表达式 | 匹配 |
|---|---|
\r, \n |
匹配回车和换行符 |
\t |
匹配制表符 |
\\ |
匹配斜杠\ |
\^ |
匹配^符号 |
\$ |
匹配$符号 |
\. |
匹配小数点. |
预定义匹配字符集
| 表达式 | 匹配 |
|---|---|
\d |
任意一个数字，0~9中的任意一个 |
\w |
任意一个字母或数字或下划线，也就是AZ,az,0~9,_ 中的任意一个 |
\s |
空格、制表符、换页符等空白字符的其中任意一个 |
\D |
\d的反集，也就是非数字的任意一个字符，等同于[^\d] |
\W |
\w的反集，也就是[^\w] |
\S |
\s的反集，也就是[^\s] |
#匹配出0-9的数字a = re.findall("\d","abc1e34r")print(a) #['1', '3', '4']# `\d`的反集，也就是非数字的任意一个字符，等同于`[^\d]，除数字以外的a = re.findall("\D","abc 123")print(a) #['a', 'b', 'c', ' ']# 任意一个字母或数字或下划线，也就是A~Z,a~z,0~9,_ 中的任意一个 a = re.findall("\w","abwc1e34r_")print(a) #['a', 'b', 'w', 'c', '1', 'e', '3', '4', 'r', '_']#`\w`的反集，也就是`[^\w]` ，除字母以外的a = re.findall("\W","abwc1 e34r_")print(a) #[' ']#都可以匹配下划线了，那空格怎么匹配a = re.findall("\s","abc 123")print(a) #[' ']# `\s`的反集，也就是`[^\s]`,除空格以外 a = re.findall("\S","abc 123")print(a) #['a', 'b', 'c', '1', '2', '3']
重复匹配
| 表达式 | 匹配 |
|---|---|
{n} |
表达式重复n次，比如\d{2}相当于\d\d,a{3}相当于aaa |
{m,n} |
表达式至少重复m次，最多重复n次。比如ab{1,3}可以匹配ab或abb或abbb |
{m,} |
表达式至少重复m次，比如\w\d{2,}可以匹配a12,_1111,M123等等 |
? |
匹配表达式0次或者1次，相当于{0,1}，比如a[cd]?可以匹配a,ac,ad |
+ |
表达式至少出现1次，相当于{1,}，比如a+b可以匹配ab,aab,aaab等等 |
* |
表达式出现0次到任意次，相当于{0,}，比如\^*b可以匹配b,^^^b等等 |
import re#意思是ll要有两个a = re.findall("l{2}","yesall")print(a)#意思是l要有2个到4个a = re.findall("l{2,4}","alyesallnoalllowallll")print(a) #['ll', 'lll', 'llll']#意思是l最少要有两个，上不封顶a = re.findall("l{2,}","alyesallnoallll")print(a) #['ll', 'llll']#意思是l至少有一个a = re.findall("l+","yellowlow")print(a) #['ll', 'l']#意思是l至少有0个a = re.findall("l*","yellowlow")print(a) #['', '', 'll', '', '', 'l', '', '', '']
位置匹配
| 表达式 | 匹配 |
|---|---|
^ |
在字符串开始的地方匹配，符号本身不匹配任何字符 |
$ |
在字符串结束的地方匹配，符号本身不匹配任何字符 |
\b |
匹配一个单词边界，也就是单词和空格之间的位置，符号本身不匹配任何字符 |
\B |
匹配非单词边界，即左右两边都是\w范围或者左右两边都不是\w范围时的字符缝隙 |
#1是否在开头a = re.findall("^1","1364156")print(a) #['1']#6是否在末尾a = re.findall("6$","1364156")print(a) #['6']
贪婪模式与非贪婪模式
“贪婪模式”总是尝试匹配尽可能多的字符；“非贪婪模式”则相反，总是匹配尽可能少的字符
练习
1.长度为8-10的用户密码（以字母开头、数字、下划线）
import re#输入一个密码，验证长度为8-10的用户密码（以字母开头、数字、下划线）s = input("请输入一个密码：")a= re.findall("^[a-zA-Z]\w{7,9}",s) #从0开始print(a)
2.电子邮箱验证
#电子邮箱验证s = input("请输入一个电子邮箱：")a= re.findall("^\w+@\w+[\.]\w+$",s) #从0开始print(a) #newglf@163.com
3.电话号码的验证
s = input("请输入一个电话：")zengze = "^1[3,4,8,]\d{9}$"^1[3-9]\d{
9}a= re.findall(zengze,s) #从0开始print(a) #联通电话#130、131、132、145、155、156、166、167、171、175、176、185、186、196s = input("请输入一个电子邮箱：")zengze = "^(13[0,1,2]|14[5]|15[5,6]|16[6,7]|17[1,5,6]|18[5,6]|19[6])\d{8}$"a= re.search(zengze,s)print(a)
5.3re模块
定义
re模块是python独有的匹配字符串的模块，该模块中提供的很多功能是基于正则表达式实现的
常用方法
| 方法 | 描述 | 返回值 |
|---|---|---|
| compile(pattern) | 根据包含正则表达式的字符串创建模式对象 | re对象 |
| search(pattern, string) | 在字符串中查找 。第一个匹配到的对象或者None | 返回一个match对象 |
| match(pattern, string) | 在字符串的开始处匹配模式。 在字符串开头匹配到的对象或者None | 返回一个match对象 |
| findall(pattern, string,flags) | 列出字符串中模式的所有匹配项 | 所有匹配到的字符串列表 |
| finditer(pattern, string,flags) | 将所有匹配到的项生成一个迭代器 | 所有匹配到的字符串组合成的迭代器 |
| match.group(index) | 将match对象拆分成字符串。不写index默认是0 | 返回match object中的字符串/元组 |
| match.groups() | 将match对象转换成元组 | 返回由所有分组匹配到的字符串组成的tuple。 |
| match.start(index) | 没有参数时，返回匹配到的字符串的起始位置。指定参数（整数）时，返回该分组匹配到的字符串的起始位置 | 返回int类型 |
| match.end(index) | 没有参数时，返回匹配到的字符串的结束位置。指定参数（整数）时，返回该分组匹配到的字符串的结束位置。 | 返回int类型 |
| match.span(index) | 返回一个二元tuple表示匹配到的字符串的范围，即(start, end) | 返回元组 |
| split(pattern, string) | 根据模式的匹配项来分割字符串 | 分割后的字符串列表 |
| sub(repl, string,count=0) | 将字符串中所有的pat的匹配项用repl替换 | 完成替换后的新字符串 |
| subn(pat,repl, string) | 在替换字符串后，同时报告替换的次数 | 完成替换后的新字符串及替换次数 |
| escape（string） | 将字符串中所有特殊正则表达式字符串转义 | 转义后的字符串 |
| purge(pattern) | 清空正则表达式 | |
| template(pattern) | 编译一个匹配模板 | 模式对象 |
| fullmatch(pattern, string) | match方法的全字符串匹配版本 | 类似match的返回值 |
代码
查询模块
#compile(pattern) 根据包含正则表达式的字符串创建模式对象 re对象 r = re.compile("[0-9]")print(r) #返回一个编译正则的re对象"""re.IGNORECASE：忽略大小写，同 re.I。re.MULTILINE：多行模式，改变^和$的行为，同 re.M。re.DOTALL：点任意匹配模式，让'.'可以匹配包括'\n'在内的任意字符，同 re.S。re.LOCALE：使预定字符类\w \W \b \B \s \S 取决于当前区域设定，同 re.L。re.ASCII：使 \w \W \b \B \s \S 只匹配 ASCII 字符，而不是Unicode 字符，同 re.A。re.VERBOSE：详细模式。"""import re b = re.compile(r"[a-w]",re.I)a = b.findall("ADbcG")print(a) #['A', 'D', 'b', 'c', 'G']a = re.compile(r"""\d + # the integral part \. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*")
#search(pattern, string) 在字符串中查找 第一个匹配到的对象或者None #扫描整个字符串，并返回它找到的第一个匹配（Match object）r = re.compile("[0-9]")a = r.search("123abc456")print(a) #<re.Match object; span=(0, 1), match='1'>
#match(pattern, string) 在字符串开头匹配到的对象或者None 返回一个match对象 r = re.compile("[0-9]")a = r.match("123abc456") #a = r.match("123abc456") #开头不是数字，所以输出Noneprint(a) #<re.Match object; span=(0, 1), match='1'>
#findall(pattern, string,flags) 列出字符串中模式的所有匹配项 所有匹配到的字符串列表 r = re.compile("[0-9]")a = r.findall("123abc4567")print(a) #['1', '2', '3', '4', '5', '6', '7']
# finditer(pattern, string,flags) 将所有匹配到的项生成一个迭代器 返回一个迭代器r = re.compile("[0-9]")a = r.finditer("123abc456")print(a) #<callable_iterator object at 0x0000020C599BFA88>print(list(a))"""[<re.Match object; span=(0, 1), match='1'>, <re.Match object; span=(1, 2), match='2'>, <re.Match object; span=(2, 3), match='3'>, <re.Match object; span=(6, 7), match='4'>, <re.Match object; span=(7, 8), match='5'>, <re.Match object; span=(8, 9), match='6'>]"""
match相关方法
#match.group(index)将match对象拆分成字符串。不写index默认是0返回match object中的字符串 """分组编号从1开始，从左往右，每遇到一个左括号，分组编号+1。组0总是存在的，它就是整个表达式。没有参数时，group1默认为0，这时返回整个匹配到的字符串。"""#空格不要忘了r = re.compile(r"(\w+) (\w+)")a = r.match("I LOvE you")print(a) #<re.Match object; span=(0, 6), match='I LOvE'>print(a.group()) #I LOvE 默认是0print(a.group(1)) #Iprint(a.group(2)) #LOvEprint(a.group(3)) #报错""" 指定多个参数的时候，就返回一个元组"""print(a.group(1,2)) #('I', 'LOvE')r = re.compile(r"(\w+) (\w+)")a = r.match("I LOvE you")print(a.groups()) #('I', 'LOvE')
#match.start(index)没有参数时，返回匹配到的字符串的起始位置。指定参数（整数）时，返回该分组匹配到的字符串的起始位置r = re.compile(r"(\w+) (\w+)")a = r.match("I LOvE you") print(a.start()) #0 print(a.start(2)) #2 第二个单词的起始位置是2，下标从0开始#match.end(index)r = re.compile(r"(\w+) (\w+)")a = r.match("I LOvE you") print(a.end()) #6print(a.end(2)) #6print(a.end(1)) #1
r = re.compile(r"(\w+) (\w+)")a = r.match("I LOvE you") print(a.span()) #(0, 6)print(a.span(1)) #(0, 1)print(a.span(2)) #(2, 6)
拆分
#split(pattern, string) 根据模式的匹配项来分割字符串 分割后的字符串列表 #意思是匹配到大写的字母就拆分pattern = re.compile(r"[A-Z]+")m = pattern.split("abcDefgHijkLmnoPqrs")print(m) #['abc', 'efg', 'ijk', 'mno', 'qrs']
替换
""" sub(repl, string,count=0) 将字符串中所有的pat的匹配项用repl替换 |完成替换后的新字符串 |repl可以是一个字符串，也可以是一个函数。count用于指定最多替换次数，不指定时全部替换。""" r = re.compile(r"like", re.I)#s1 = r.sub(r"love", "I like you, do you like me?") #I love you, do you love me?#最多替换1次，所以把一个like替换了s1 = r.sub(r"love", "I like you, do you like me?",count=1)print(s1) #I love you, do you like me?#subn(repl, string) | 在替换字符串后，同时报告替换的次数 | 完成替换后的新字符串及替换次数 |#同sub()，只不过返回值是一个二元tuple，即(sub函数返回值，替换次数)。r = re.compile(r"like", re.I)"""s1 = r.subn(r"love", "I like you, do you like me?")print(s1) #('I love you, do you love me?', 2)"""s1 = r.subn(r"love", "I like you, do you like me?",count=1)print(s1) #('I love you, do you like me?', 1)
补充®
Python中字符串前面加上 r 表示原生字符串
与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符""，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。
练习
""" 匹配身份证"""import res = input("请输入身份证：")z= re.compile(r"^(\d{17})(\d|x)$",re.I)#不能使用findall，他会返回两个字符串a = re.search(z,s)print(a.group())
import re#输入一个密码，验证长度为8-10的用户密码（以字母开头、数字、下划线）s = input("请输入一个密码：")z = re.compile("^[a-zA-Z]\w{7,9}")a= re.findall(z,s) #从0开始print(a)
5.4日期时间相关：datetime模块
定义
python中的datetime模块提供了操作日期和时间功能, 该模块提供了一下类对象
| 类名 | 描述 |
|---|---|
| datetime.date | 日期类 |
| datetime.time | 时间类 |
| datetime.datetime | 日期与时间类 |
| datetime.timedelta | 表示两个date、time、datetime实例之间的时间差 |
| datetime.tzinfo | 时区相关信息对象的抽象基类。 |
| datetime.timezone | Python3.2中新增的功能，实现tzinfo抽象基类的类，表示与UTC的固定偏移量 |
两个属性
| 常量 | 功能说明 | 返回值 描述 |
|---|---|---|
| datetime.MAXYEAR | 返回能表示的最大年份 | 9999 |
| ** datetime.MINYEAR** | 返回能表示的最小年份 | 1 |
import datetimeprint(datetime.MINYEAR) #1print(datetime.MAXYEAR) #9999
datetime.date类
定义：
class datetime.date(year, month, day)
datetime模块下的日期类(date)，只能处理年月日这种日期时间，不能处理时分秒。
from datetime import date#创建一个日期对象date01 = date(year=2021, month=12, day=22)print(date01.year) #2021print(date01.month) #12print(date01.day) #22
常用的方法和属性
| 类方法**/**属性名称 | 描述 |
|---|---|
| date.max | date对象所能表示的最大日期：9999-12-31 |
| date.min | date对象所能表示的最小日期：00001-01-01 |
| date.resoluation | date对象表示的日期的最小单位：天 |
| date.today() | 返回一个表示当前本地日期的date对象 |
| date.fromtimestamp(timestamp) | 根据给定的时间戳，返回一个date对象 |
| d.year | 年 |
| d.month | 月 |
| d.day | 日 |
| d.replace(year[, month[, day]]) | 生成并返回一个新的日期对象，原日期对象不变 |
| d.timetuple() | 返回日期对应的time.struct_time对象 |
| d.toordinal() | 返回日期是是自0001-01-01开始的第多少天 |
| d.weekday() | 返回日期是星期几，[0, 6]，0表示星期一 |
| d.isoweekday() | 返回日期是星期几，[1, 7], 1表示星期一 |
| d.isocalendar() | 返回一个元组，格式为：(year, weekday, isoweekday) |
| d.isoformat() | 返回‘YYYY-MM-DD’格式的日期字符串 |
| d.strftime(format) | 返回指定格式的日期字符串，与time模块的strftime(format, struct_time)功能相同 |
代码
import timefrom datetime import dateprint(date.max) # 9999-12-31print(date.min) # 0001-01-01 print(date.resolution) # 1 day, 0:00:00print(date.today()) # 2020-03-17 print(date.fromtimestamp(time.time())) # 2020-03-17d = date.today() print(d.year) # 2020print(d.month) # 3print(d.day) # 17print(d.replace(2019)) # 2019-03-17print(d.replace(2019, 5)) # 2019-05-17print(d.replace(2019, 5, 21)) # 2019-05-21print(d.timetuple()) # time.struct_time(tm_year=2020, tm_mon=3, tm_mday=17, tm_hour=
最低0.47元/天 解锁文章
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
