python标准库

1、 OS标准库的主要功能

1.1 系统相关变量和操作

# 1、系统相关的内容
print(os.name)   # 操作系统名字
print(os.environ)  # 环境变量
print(os.sep)   # 分隔符
print(os.pathsep)  # path分隔符
print(os.linesep)   # 换行的分隔符；这个打印不出来可以在IDLE打印出来

1.2 文件和目录相关操作

# 2.文件和目录的操作
# os.mkdir("stddemo")  # 当前目录下创建目录
# os.rmdir("stddemo")  # 删除目录
# makedirs removedirs   创建多级目录
# os.stat # 目录的状态
print(os.getcwd())   # 打印当前目录位置
# rename  文件目录命名

# os.path   # os的子模块
file = os.getcwd()+"/1-1.py"
print(os.path.split(file))   # 分割目录,哪个是目录、文件名
print(os.path.isabs(file))    # 判断是不是绝对路径

# isdir  isfile   判断传进来的是不是目录or文件，也在子包path
# exists  判断目录是否存在
print(os.path.exists(file))

# getatime   拿到文件or目录的最后修改时间
print(os.path.getatime(file))
print(os.path.getctime(file))    # 创建时间
print(os.path.getsize(file))    # 拿到这个文件的大小 （字节）
# os.remove  解决文件删除的方法

1.3 执行命令和管理进程

调用打开文件（不太推荐这种方法）

os.system('helloworld.py')  # 调用文件
os.system('ipconfig')   # 查看ip地址

2、sys标准库的主要功能

针对Python解释器相关的变量和方法
（与程序运行相关）

print(sys.argv)  # 参数，当前执行的.py文件

hello是入口参数

后面3个是入口参数

 # 标准库sys

import sys

# 5个常用变量
print(sys.version)    # 版本号
print(sys.maxsize)   # 能够表示最大int数值
print(sys.path)   # 检索python代码查找路径
print(sys.platform)   # 运行平台
print(sys.copyright)  # 版权

print(sys.argv)  # 参数，当前执行的.py文件
sys.exit(0)   # 退出 状态码
print(sys.getdefaultencoding())  # utf-8是我们使用的默认的编码方式
print(sys.getfilesystemencoding())   # 文件系统默认的编码方式
print(sys.getrecursionlimit())   # 递归的限制（最大递归次数）
sys.setrecursionlimit(200)    # 修改递归次数
print(sys.getrecursionlimit())   # 递归的限制（最大递归次数）


def recursionFunc(i):
    print(i)
    recursionFunc(i+1)   # 递归的调用


recursionFunc(1)

3、random标准库的主要功能

主要用于生成“伪随机数”

随机数的生成过程主要取决于2方面，第一方面是算法，第二方面是算子（因子）

列出从1到100
（算头不算尾）

for i in range(1, 101):
    print(i)

3.1 生成随机的整数

# 标准库 random

import random

# 生成随机的整数
print(random.randint(1, 100))   # 1到100之间生成一个随机数
print(random.randrange(1, 101))  # 1到100之间生成一个随机数
print(random.randrange(1, 101, 2))  # 1到100之间生成一个随机数奇数
print(random.randrange(2, 101, 2))  # 1到100之间生成一个随机数偶数

3.2 生成随机的浮点数

# 生成随机的浮点数
print(random.random())   # 浮点数在 0.0到1.0之间
print(random.uniform(11.1, 13.1))

3.3 非数字类型的随机抽样

# 非数字类型的随机抽样
targetList = ['苹果', '香蕉', '橘子', '梨', '西瓜', '菠萝']
print(random.choice(targetList))

乱序

# 乱序
print(targetList)
random.shuffle(targetList)
print(targetList)

随机抽取（不改变原来样本）

print(targetList)

print(random.sample(targetList, 4))   # 随机抽取4个
print(random.sample(targetList, 6))
print(targetList)

3.4 生成类似随机密码的字符串

# 3.生成类似随机密码的字符串

import random, string
# 字符串中只包含数字和字母
# 可以指定生成字符串的位数

def gen_random_string(length):
    # 随机生成字母和数字的位数
    numcount = random.randint(1, length-1)
    lettercount = length - numcount    # 字母长度
    # 随机抽样生成数字序列
    numlist = [random.choice(string.digits) for _ in range(numcount)]
    # 随机抽样生成字母序列
    letterlist = [random.choice(string.ascii_letters) for _ in range(lettercount)]
    # 合并字母和数字
    allist = numlist + letterlist
    # 乱序
    random.shuffle(allist)
    # 生成目标结果字符串
    result = "".join([i for i in allist])

    return result

# randString = gen_random_string(32)
# print(randString)

# 生成10组32位
for i in range(10):
    print(gen_random_string(32))


# print(string.digits)     # 全部数字的集合
# print(string.ascii_letters)  # 全部字母的集合

4、标准库time

time模块中三种时间表示方式

• 时间戳 （浮点型）
• 结构化时间对象
• 格式化时间字符串

处理时间的相关方法

4.1 时间戳

import time
# 时间戳 结构化时间对象 格式化时间字符串

# 时间戳 1970.1.1 到指定时间的间隔，单位是秒

print(time.time())
print(time.time() - 3600)  # 一个小时之前的时间

4.2 结构化时间对象

import time
# 结构化时间对象 对象
st = time.localtime()
print(type(st))
print(st)  # __str__
# st 本质上是一个tuple 一共9个元素
print('今天是{}-{}-{}'.format(st[0], st[1], st[2]))  # 字符串格式化
print('今天是{}年{}月{}日'.format(st[0], st[1], st[2]))
print('今天是{}-{:02d}-{}'.format(st[0], st[1], st[2]))   # 以0来左填充，一共占两位

print('今天是 星期{}'.format(st.tm_wday + 1))   # 星期2，不过日常不能用数字来表示
# 对象的属性是只读的，不可改，本质是一个元组，不能改

4.3 格式化时间字符串

# 格式化时间字符串
print(time.ctime())

# strftime(时间格式)  '%Y-%m-%d %H:%M:%S'
# Y表示4位的、带着世纪的2020年表示，m表示月份取值01-12，d表示天01-31，M表示分钟，S表示24进制的小时，h表示12进制的小时，S表示秒
print(time.strftime('%Y-%m-%d %H:%M:%S'))
print(time.strftime('%Y年%m月%d日 %H时%M分%S秒'))
print(time.strftime('%Y-%m-%d %H:%M:%S %a'))  # a是星期的缩写
print(time.strftime('%Y-%m-%d %H:%M:%S %A'))  # A是星期的全称
print(time.strftime('%Y-%m-%d %H:%M:%S %b'))  # b是月份缩写
print(time.strftime('%Y-%m-%d %H:%M:%S %B'))
print(time.strftime('%Y-%m-%d %I:%M:%S %p'))  # I表示12小时制，p表示am pm
print(time.strftime('%Y-%m-%d %H:%M:%S %W'))  # W表示今天所在周是今年里的第几周
print(time.strftime('%Y-%m-%d %H:%M:%S %w'))  # w代表一个星期里第几天，0表示周日

睡眠

# sleep  睡眠
t1 = time.time()
print('sleep begin...')
time.sleep(1.23)  # 参数是浮点数，单位是秒
print('sleep end')
t2 = time.time()
print('执行了{:.3f}秒'.format(t2 - t1))   # 小数点后3位

4.4 三种格式之间的转换

# 三种格式之间的转换
# 时间戳 -> 结构化对象
# UTC 比我们晚8个小时
print(time.gmtime())
print(time.gmtime(time.time()))
print(time.gmtime(time.time()-3600))   # 一个小时之前

# local
print(time.localtime())
print(time.localtime(time.time()-3600))

# 结构化对象 -> 时间戳
# mktime(st)
print(time.time())
print(time.mktime(time.localtime()))

# 结构化对象 -> 格式化时间字符串
# strftime(format, st)
print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()))  # 传了一个当前时间能够转换为一个字符串
print(time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime()))

# 格式化字符串 -> 结构化时间对象
# strptime(str, format)
strtime = '2020-04-20 22:00:53'
print(time.strptime(strtime, '%Y-%m-%d %H:%M:%S'))

5、标准库 datetime

5.1 datetime标准库的类

datetime.date 只有年月日，没有时分秒

datetime.time 只有时分秒，没有年月日

datetime.datetime 有年月日和时分秒

datetime.timedelta 时间差，对以上三种进行一些时间运算

5.2 datetime.date

三种常用的生成date对象的三种方式

# 标准库 datetime

import datetime
import time
# datetime.date
# 生成日期
d = datetime.date.today()  # 生成今天的日期
print(d, type(d))
d = datetime.date(2022, 8, 24)   # 类的构造
print(d, type(d))
d = datetime.date.fromtimestamp(time.time())  # 运用时间戳生成
print(d, type(d))

类属性

# 类属性
print(datetime.date.min)  # 最小日期
print(datetime.date.max)  # 最大日期
print(datetime.date.resolution)  # 时间间隔 timedelta这个类

实例属性

# 实例属性
print(d.year)
print(d.month)
print(d.day)

常用的实例方法和其它方法

# 常用的实例方法
# datetime.date对象 -> 结构化时间对象
print(d.timetuple())

# 其他方法
# replace
print(d.replace(2022))  # 将年替换掉
print(d.replace(d.year, 9))  # 修改月的话最好将年参数带上
print(d.replace(day=20))  # 关键字参数
print(d.replace(d.year, d.month, 20))  # 等同于上一条
print(d.toordinal())  # 代表从最小日期0001-01-01到现在的天数
print(d.weekday())  # 判断是周几，0代表周一，6代表周日
print(d.isoweekday())  # 1代表周一，0代表周日
print(d.isoformat())  # 标准日期格式的返回
print(d.strftime("%Y年%m月%d日")) # 转换成汉字的年月日格式

5.3 datetime.time

# time
# 生成时间
t = datetime.time(15, 10, 45, 888888)  # 时分秒，微秒 （秒微妙毫秒都是以1000为单位）
print(t, type(t))

# 类方法
print(datetime.time.min)  # 时间最小值
print(datetime.time.max)
print(datetime.time.resolution)  # 时间相隔最小单位

# 实例属性  对象获取它元素属性
print(t.hour)
print(t.minute)
print(t.second)
print(t.microsecond)

# replace方法同date的类似

# 其他方法
print(t.isoformat())  # 标准时间格式
print(t.strftime("%H时%M分%S秒 %f微秒"))  # str代表字符串，f代表格式化

5.4 datetime.datetime

# datetime.datetime  第一个是模块名，第二个是里面的类
# 生成日期时间
dt = datetime.datetime(2020, 4, 21, 19, 20, 33, 888888)
print(dt, type(dt))
dt = datetime.datetime.today()
print(dt, type(dt))
dt = datetime.datetime.now(tz=None)  # 时区
print(dt, type(dt))
dt = datetime.datetime.utcnow()  # 格林尼治时间
print(dt, type(dt))
# 时间戳 -> dt
dt = datetime.datetime.fromtimestamp(time.time())
print(dt, type(dt))
dt = datetime.datetime.utcfromtimestamp(time.time())
print(dt, type(dt))
# 字符串 -> dt
dt = datetime.datetime.strptime("2021-04-21 11:27:20", "%Y-%m-%d %H:%M:%S")
print(dt, type(dt))
# date,time -> datetime
dt = datetime.datetime.combine(d, t)
print(dt, type(dt))

# 实例属性
print(dt.year)
print(dt.month)
print(dt.day)
print(t.hour)
print(dt.minute)
print(dt.second)
print(dt.microsecond)

# replace
print(dt.replace(second=57, day=20))

# datetime -> 结构化对象
print(dt.timetuple())
# datetime -> 时间戳
print(dt.timestamp())
# datetime -> 格式化字符串
print(dt.strftime("%Y年%m月%d日 %H时%M分%S秒 %f微秒"))

# 时间戳 -> datetime
print(datetime.datetime.fromtimestamp(time.time()))
# 格式化对象 -> datetime
print(datetime.datetime.strptime("2021-04-21 11:27:20", "%Y-%m-%d %H:%M:%S"))
# 结构化对象 -> datetime
print(datetime.datetime.fromtimestamp(time.mktime(time.localtime())))  # 先转换成时间戳

5.5 datetime.timedelta

# datetime.timedelta
# class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, hours=0, weeks=0) # 类的定义，没有年月
# 生成时间差
td = datetime.timedelta(days=10)
print(td, type(td))
td = datetime.timedelta(days=10, hours=5)
print(td, type(td))
td = datetime.timedelta(days=-5)  # 负数表示向前5天
print(td, type(td))
td = datetime.timedelta(days=-5, hours=-8)  # 向前5天再向前追8小时就是24-8为16，-6天
print(td, type(td))
td = datetime.timedelta(hours=75)  # 会转换为3天又3小时
print(td, type(td))
td = datetime.timedelta(weeks=2)  # 会转换为14天
print(td, type(td))

# 计算目标日期
dt = datetime.datetime.today()
print("现在是{}".format(dt.strftime('%Y年%m月%d日 %H时%M分%S秒')))
delta = datetime.timedelta(days=10)
target = dt + delta  # 目标时间
print("十天后是{}".format(target.strftime('%Y年%m月%d日 %H时%M分%S秒')))

dt = datetime.datetime.today()
print("现在是{}".format(dt.strftime('%Y年%m月%d日 %H时%M分%S秒')))
delta = datetime.timedelta(weeks=1)
target = dt + delta  # 目标时间
print("一周后是{}".format(target.strftime('%Y年%m月%d日 %H时%M分%S秒')))

dt = datetime.datetime.today()
print("现在是{}".format(dt.strftime('%Y年%m月%d日 %H时%M分%S秒')))
delta = datetime.timedelta(hours=-5)
target = dt + delta  # 目标时间
print("五小时之前是{}".format(target.strftime('%Y年%m月%d日 %H时%M分%S秒')))

# 计算时间差
dt1 = datetime.datetime.today()
dt2 = datetime.datetime.utcnow()
td = dt1 - dt2
print("我们与utc时间的差是：{:.0f}小时".format(td.seconds/3600)) # 小数点后一位不留

6、标准库 logging

处理日志

日志处理的方式
python：print() logging

6.1 logging库日志级别

默认日志级别是warning

# 标准库 logging

import logging

# 默认的日志输出级别为warning
# 使用basicConfig()来指定日志输出级别
print("this is a print log")
logging.basicConfig(level=logging.DEBUG)  # 指定日志输出级别为DEBUG,默认从warning开始输出
logging.debug("This is debug log")  # 调试级别的日志
logging.info("This is info log")   # 信息级别的
logging.warning("This is warning log")  # 警告级别的
logging.error("This is error log")   # 错误级别的
logging.critical("This is critical log")  # 致命错误级别的

将日志信息输入到文件里面，同级别目录下的（传入filename参数）
默认是追加模式，运行多次就直接追加到后面

logging.basicConfig(filename='demo.log', level=logging.DEBUG)

不想追加，在上述基础上，加入w，先清空再写入

logging.basicConfig(filename='demo.log', filemode='w', level=logging.DEBUG)

6.2 向日志输出变量

# 标准库 logging

import logging

# 向日志输出变量
logging.basicConfig(level=logging.DEBUG)
name = "张三"
age = 18

logging.debug("姓名 %s, 年龄 %d", name, age)  # 基本变量替换的方式
logging.debug("姓名 %s, 年龄 %d" % (name, age))  # 以百分号运算符来进行格式化字符串，参数作为元组传入
logging.debug("姓名 {}, 年龄 {}".format(name, age))  # format函数也可以
logging.debug(f"姓名 {name}, 年龄 {age}")

输出格式和添加一些信息

当下有2个公共信息，一个是日志级别debug，一个是记录器名字root

可以自己添加信息，比如时间等，格式为

format="%()s"中间是ket标识什么信息

import logging

# 输出格式和添加一些信息
logging.basicConfig(format="%(message)s", level=logging.DEBUG)  # 传入参数format让输入的显示在那
name = "张三"
age = 18
logging.debug("姓名 %s, 年龄 %d", name, age)  # 基本变量替换的方式

加入时间

logging.basicConfig(format="%(asctime)s|%(message)s", level=logging.DEBUG)

加入级别

logging.basicConfig(format="%(asctime)s|%(levelname)s|%(message)s", level=logging.DEBUG)

输出文件的第几行输出的日志

logging.basicConfig(format="%(asctime)s|%(levelname)s|%(filename)s:%(lineno)s|%(message)s", level=logging.DEBUG)

日期格式化datefmt

logging.basicConfig(format="%(asctime)s|%(levelname)s|%(filename)s:%(lineno)s|%(message)s",
                    datefmt="%Y-%m-%d %H:%M:%S", level=logging.DEBUG)  # 传入参数format让输入的显示在那

实际做项目中，这种还是不可，太繁琐，下面学习logging的高级应用

6.3 logging的高级应用

logging模块采用了模块化设计，主要包含四种组件：

Loggers：记录器，提供应用程序代码能直接使用的接口；（相当于我们写日志时所用到的笔，每一个笔相当于一个记录器，写日志时定义若干根笔，拿你需要的去写）

Handlers：处理器，将记录器产生的日志发送至目的地；（目的地最常用的是文件和标准输出，其他有email ，短信，或者http协议发送到任何网络上的位置，一个记录器可以对应多个处理器）

Filters：过滤器，提供良好的粒度控制，决定哪些日志会被输出；（上面学过的日志输出级别能够控制记录器和处理器以什么样的方式输出）

Formatters：格式化器，设置日志内容的组成结构和消息字段

如何工作的呢，工作流程

常用的几个处理器

• StreamHandler
• FileHandler
• BaseRotatingHandler
• RotatingFileHandler
• TimedRotatingFileHandler

message必须带着

logger是log这个类的一个对象

（下面这方法小项目可，大项目绝对不可，调日志级别都要改代码）

import logging

# 编程的方式来写一下高级的写法
# 1、记录器
logger = logging.getLogger('applog')  # 默认是root，命名为applog
logger.setLevel(logging.INFO)  # 最低级别改为INFO

# 2、处理器handler
consoleHandler = logging.StreamHandler()
consoleHandler.setLevel(logging.DEBUG)   # 设置为debug

# 没有给handler指定日志级别，将使用logger的级别
fileHandler = logging.FileHandler(filename='addDemo.log')  # 向文件输出

# 3、formatter格式
formatter = logging.Formatter("%(asctime)s|%(levelname)8s|%(filename)s:%(lineno)s|%(message)s")  # 用占位符将输出对齐

# 接下来将它们串起来（过滤器可以没有）

# 给处理器设置格式
consoleHandler.setFormatter(formatter)
fileHandler.setFormatter(formatter)

# 记录器要添加设置处理器,两根笔设置处理器
logger.addHandler(consoleHandler)
logger.addHandler(fileHandler)

# 定义一个过滤器（用来过滤处理器和记录器）
flt = logging.Filter("cn.cccb")   # 如果logging命名空间是以cn.cccb开头，则认为是合格,会被打印出来

# 关联过滤器
# logger.addFilter(flt)
fileHandler.addFilter(flt)

# 打印日志的代码(logger是对象，logging是模块里的函数)
logger.debug("This is debug log")  # 调试级别的日志
logger.info("This is info log")   # 信息级别的
logger.warning("This is warning log")  # 警告级别的
logger.error("This is error log")   # 错误级别的
logger.critical("This is critical log")  # 致命错误级别的

（推荐配下面这种方法）

配置文件

import logging
import logging.config  # 配置这样一个子包

# 配置文件的方式来处理日志
# 记录器

logging.config.fileConfig('logging.conf')  # 载入配置文件

rootLogger = logging.getLogger()
rootLogger.debug("This is root Logger, debug")

logger = logging.getLogger('applog')  # 默认是root，命名为applog
logger.debug("This applog, debug")

补充：

1、项目调试时用exception来打印，而不是简单用error

import logging

logger = logging.getLogger()

a = 'abc'
try:
    int(a)
except Exception as e:
    # logger.error(e)
    logger.exception(e)

2、除了编程式使用日志、logging格式的配置文件
还有字典方式的配置

logging.config.dictConfig({"loggers":"root, applog"})