import random #取随机数的模块

取随机小数

 print(random.random()) #取0-1之间小数
 print(random.uniform(1,2)) #取一个范围内的小数

取随机整数

 print(random.randint(1,2)) #顾头也顾尾
 print(random.randrange(1,2)) #顾头不顾尾

从一个列表中随机抽取值

 lst = [ a , b ,(1,2,3),4]
 print(random.choice(lst)) #随机抽取一个值
 print(random.sample(lst,2)) #取多个， 不允许重复

打乱一个列表的顺序

在原列表的基础仧直接进行修改， 节省空间

 lst = [ a , b ,(1,2,3),4]
 random.shuffle(lst)
 print(lst)

时间模块 time

import time
time.sleep(2) # 程序走到这会等待2s钟
time 模块主要用来和时间打交道

时间格式

 2018-8-20           字符串数据类型 格式化时间
 time.localtime  结构化时间
 print(time.time())  #1630918859.481213 浮点型数据类型 以秒为单位 时间戳时间 给机器计算用的
 print(time.strftime( %Y-%m-%d %H-%M-%S )) #2021-09-06 #2021-09-06 17-09-52
 print(time.strftime( %c ))  #Mon Sep  6 17:10:14 2021
 print(time.localtime())
time.struct_time(tm_year=2021, tm_mon=9, tm_mday=6, tm_hour=17, tm_min=6, tm_sec=56, tm_wday=0, tm_yday=249, tm_isdst=0)

random

random常用于获取随机数，以及打散一些可变数据类型

import random

# 获取0.0到1.0范围内的浮点数
print(random.random())

# 获取指定范围内的浮点数
print(random.uniform(100, 200))

# 获取指定范为内（100-200）之间的一个随机整数
print(random.randint(100, 200))

# 将一个可变数据打散
l1 = list(range(10))
random.shuffle(l1)
print(l1)

# l1列表中随机输出三个元素
l1 = list(range(10))
print(random.sample(l1, 3))

time

time常用于获取一些时间信息

import time

# 获取时间戳
# 时间戳：从时间元年（1970-1-1 00:00:00）到目前经过的秒数。
print(time.time())

# 获取格式化时间对象
print(time.gmtime())  # 获取GMT时间（东八区时间）
print(time.gmtime(1))  # 获取距离时间戳1秒后的日期
print(time.localtime())  # 获取本地时间
print(time.strftime( %Y-%m-%d %H:%M:%S ))  # 格式化时间对象和字符串之间的转换

# 把时间字符串转换成时间对象
time_obj=time.strptime( 2020 10 10 , %Y %m %d )
print(time_obj)

# 代码休眠指定时间
time.sleep(3)
print( 三秒之后执行的此代码 )



# 输出如下：
1622714606.9619033
time.struct_time(tm_year=2021, tm_mon=6, tm_mday=3, tm_hour=10, tm_min=3, tm_sec=26, tm_wday=3, tm_yday=154, tm_isdst=0)
time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=1, tm_wday=3, tm_yday=1, tm_isdst=0)
time.struct_time(tm_year=2021, tm_mon=6, tm_mday=3, tm_hour=18, tm_min=3, tm_sec=26, tm_wday=3, tm_yday=154, tm_isdst=0)
2021-06-03 18:03:26
time.struct_time(tm_year=2020, tm_mon=10, tm_mday=10, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=5, tm_yday=284, tm_isdst=-1)

shutil模块

import shutil

   
shutil模块主要是对文件及目录的一些操作
所有源路径及目标路径，既可以写绝对路径，也可以写相对路径
这里只是记录下常用的操作，有些方法还支持传入其他参数
具体可以自行查看定义方法的代码
   

# 拷贝文件（源路径，目标路径）
shutil.copy2(r C:UsersAdministratorDesktopauth.log , r C:UsersAdministratorDesktopauth_copy.log )

# 拷贝目录（源路径，目标路径）
shutil.copytree(r C:UsersAdministratorDesktop	emp , r C:UsersAdministratorDesktop	emp2 )

# 删除目录，ignore_errors=True：表明如果这个文件正在使用，无法删除，则忽略这个错误
shutil.rmtree(r C:UsersAdministratorDesktop	emp2 , ignore_errors=True)

# 移动文件或目录（源路径，目标路径）
shutil.move(r"C:UsersAdministratorDesktop
egistry.log", r"C:UsersAdministratorDesktop
egistry_new.log")
shutil.move(r"C:UsersAdministratorDesktop	emp", r"C:UsersAdministratorDesktop	emp2")

# 更改属主及数组
shutil.chown( path , user , group ) 

# 查找命令绝对路径
print(shutil.which( cmd ) )


# 获取磁盘使用情况
total, used, free = shutil.disk_usage( . )  # . 表明当前工作路径所在磁盘
print("当前磁盘共: %iGB, 已使用: %iGB, 剩余: %iGB" % (total / 1073741824, used / 1073741824, free / 1073741824))
total, used, free = shutil.disk_usage(r C: )  # 这是获取C盘的磁盘使用情况
print("当前磁盘共: %iGB, 已使用: %iGB, 剩余: %iGB" % (total / 1073741824, used / 1073741824, free / 1073741824))


# 获取当前系统支持的解包文件格式（后缀）
print(shutil.get_unpack_formats())     

# 获取当前系统支持的压缩文件格式（后缀）
print(shutil.get_archive_formats())

# 压缩文件（要压缩的包名字，注意不用加后缀，中间是压缩的格式，可以查看make_archive方法的定义，获取其支持的格式，后面是要打包的目录）
# 源码中定义支持的格式为：
#  format  is the archive format: one of "zip", "tar", "gztar","bztar", or "xztar".  Or any other registered format.
shutil.make_archive(r"C:UsersAdministratorDesktop	emp2_yasuo",  zip , r"C:UsersAdministratorDesktop	emp2")

# 解压文件（要解压的包，解压到哪里）
# 也支持传入压缩包格式，默认以压缩包的后缀作为其格式
# 可以自行查看源码
shutil.unpack_archive(r C:UsersAdministratorDesktop	emp2_yasuo.zip , r C:UsersAdministratorDesktop	mp )

logging模块

import logging

logging.debug( debug message )
logging.info( info message )
logging.warning( warning message )    # WARNING:root:warning message
logging.error( error message )    # ERROR:root:error message
logging.critical( critical message )    # CRITICAL:root:critical message

默认情况下Python的logging模块将日志打印到了标准输出中，且只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING（日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG），默认的日志格式为日志级别：Logger名称：用户输出消息。

日志格式配置

1、日志写入文件中
下面的日志格式可直接用于项目代码中：

import logging

# 定义日志格式相关，并将日志写入registry.log文件中
# filename：指定日志路径，可以写相对路径
file_handler = logging.FileHandler(filename=r C:UsersAdministratorDesktop
egistry.log , mode= a ,
                                   encoding= utf-8 , )
logging.basicConfig(
    format= %(asctime)s %(name)s %(levelname)s %(module)s (line: %(lineno)d):  %(message)s ,  # 设置日志格式
    datefmt= %Y-%m-%d %H:%M:%S ,  # 设置上面asctime时间格式
    handlers=[file_handler, ],  # 设置handlers
    level=logging.DEBUG  # 设置日志等级：CRITICAL、ERROR、WARNING、INFO、DEBUG
)

# 打印日志
logging.debug( 调试信息 )
logging.error( 错误信息 )



# 文件内容如下：
2021-06-11 17:11:09 root DEBUG demo_01 (line: 10):  调试信息
2021-06-11 17:11:09 root ERROR demo_01 (line: 11):  错误信息

日志直接输出到控制台

import logging

#file_handler = logging.FileHandler(filename= registry.log , mode= a , encoding= utf-8 , )
logging.basicConfig(
    format= %(asctime)s %(name)s %(levelname)s %(module)s [line: %(lineno)d]:  %(message)s ,
    datefmt= %Y-%m-%d %H:%M:%S ,
    # handlers=[file_handler, ],     # 不将定义的file_handler传入到handlers即可，默认输出到控制台
    level=logging.DEBUG
)
logging.debug( 调试信息 )
logging.error( 错误信息 )

同时打印到控制台及文件中

import logging

file_handler = logging.FileHandler(filename= registry.log , mode= a , encoding= utf-8 , )
stream_handler = logging.StreamHandler()
logging.basicConfig(
    format= %(asctime)s %(name)s %(levelname)s %(module)s [line: %(lineno)d]:  %(message)s ,
    datefmt= %Y-%m-%d %H:%M:%S ,
    handlers=[file_handler, stream_handler],
    level=logging.DEBUG
)
logging.debug( 调试信息 )
logging.error( 错误信息 )

配置参数

logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有：

filename：用指定的文件名创建FiledHandler，这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format：指定handler使用的日志显示格式。
datefmt：指定日期时间格式。
level：设置日志级别
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件(f=open(‘test.log’,’w’))，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。

format参数中可能用到的格式化串：
%(name)s Logger的名字
%(levelno)s 数字形式的日志级别
%(levelname)s 文本形式的日志级别
%(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
%(filename)s 调用日志输出函数的模块的文件名
%(module)s 调用日志输出函数的模块名
%(funcName)s 调用日志输出函数的函数名
%(lineno)d 调用日志输出函数的语句所在的代码行
%(created)f 当前时间，用UNIX标准的表明时间的浮 点数表明
%(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数
%(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d 线程ID。可能没有
%(threadName)s 线程名。可能没有
%(process)d 进程ID。可能没有
%(message)s用户输出的消息

argparse模块

argparse 是 Python 内置的一个用于命令项选项与参数解析的模块，通过在程序中定义好我们需要的参数，argparse 将会从 sys.argv 中解析出这些参数，并自动生成协助和使用信息。当然，Python 也有第三方的库可用于命令行解析，而且功能也更加强劲，列如 docopt，Click。

接下来，我们就来看看argparse模块究竟如何使用。

argparse使用步骤：

import argparse 第一导入模块；
parser = argparse.ArgumentParser（） 创建一个解析对象；
parser.add_argument() 向该对象中添加你要关注的命令行参数和选项；
parser.parse_args() 进行解析；

传入一个参数
先来一个最简单的例子

# -*-coding:utf-8 -*-

import argparse

parser = argparse.ArgumentParser(description= 命令行中传入一个字符 )
# type是要传入的参数的数据类型  help是该参数的提示信息
parser.add_argument( strings , type=str, help= 传入的字符 )

args = parser.parse_args()

# 打印传入的参数
print(args)

   
# 执行： python2 test.py test_str
# 输出：Namespace(strings= test_str )


# 执行： python2 test.py -h
# 输出如下：
usage: test.py [-h] strings

命令行中传入一个字符

positional arguments:
  strings   传入的字符

optional arguments:
  -h, --help  show this help message and exit

   

操作args字典

我们在上面得到的 Namespace(strings= test_str ) 是一种类似于python字典的数据类型。
我们可以使用arg.参数名来提取这个参数：

# -*- coding:utf-8 -*-

import argparse

parser = argparse.ArgumentParser(description= 命令行中传入一个字符 )
# type是要传入的参数的数据类型  help是该参数的提示信息

parser.add_argument("strings", type=str, help= 传入一个字符 )
args = parser.parse_args()

# 获取strings参数
print(args.strings)

在命令行中运行 python2 test.py dfe , 运行结果为:

dfe

传入多个参数

目前在命令行中给test.py 传入多个参数，例如传入1，2，3，4四个数字

python test.py 1 2 3 4

运行报错如下：

usage: test.py [-h] strings
test.py: error: unrecognized arguments: 2 3 4

不能识别2 3 4，看源代码我们知道integers这个参数是位置参数，
说明第一个数1是能识别。这里我们需要重新更改test.py代码如下

import argparse

parser = argparse.ArgumentParser(description= 命令行中传入一个数字 )
parser.add_argument( integers , type=str, nargs= + ,help= 传入的数字 )
args = parser.parse_args()

print(args.integers)

当增加nargs选项后，再次运行，则输出如下：

 $ python2 test.py 1 2 3 4
[ 1 ,  2 ,  3 ,  4 ]

改变数据类型

add_argument中有type参数可以设置传入参数的数据类型。我们看到代码中有type这个关键词，该关键词可以传入list, str, tuple, set, dict等。例如我们把上面的type=str，改成type=int,这时候我们就可以进行四则运算。

# -*- coding:utf-8 -*-

import argparse

parser = argparse.ArgumentParser(description= 命令行中传入一个数字 )
# type是要传入的参数的数据类型  help是该参数的提示信息

parser.add_argument("integers", type=int, nargs= + , help= 传入一个数字 )
args = parser.parse_args()

# 对传入的数据进行加总
print(sum(args.integers))

位置参数

# -*- coding:utf-8 -*-
import argparse

parser = argparse.ArgumentParser(description= 姓名 )
parser.add_argument( param1 , type=str, help= 姓 )
parser.add_argument( param2 , type=str, help= 名 )
args = parser.parse_args()

# 打印姓名
print(args.param1 + args.param2)

可选参数

# -*- coding:utf-8 -*-
import argparse

parser = argparse.ArgumentParser(description= The name )
parser.add_argument( -f ,  --family , type=str, help= surname )
parser.add_argument( -n ,  --name , type=str, help= name )
args = parser.parse_args()

# 打印姓名
print(args.family + args.name)

默认值

add_argument中有一个default参数。有的时候需要对某个参数设置默认值，即如果命令行中没有传入该参数的值，
程序使用默认值。如果命令行传入该参数，则程序使用传入的值。具体请看下面的例子：

# -*- coding:utf-8 -*-
import argparse

parser = argparse.ArgumentParser(description= The name )
parser.add_argument( -f ,  --family , type=str, default= li , help= surname )
parser.add_argument( -n ,  --name , type=str, default= si , help= name )
args = parser.parse_args()

# 打印姓名
print(args.family + args.name)

必需参数

# -*- coding:utf-8 -*-
import argparse

parser = argparse.ArgumentParser(description= The name )
parser.add_argument( -f ,  --family , type=str, help= surname )
parser.add_argument( -n ,  --name , type=str, required=True, default=  , help= name )
args = parser.parse_args()

# 打印姓名
print(args.family + args.name)

执行报错

usage: test.py [-h] [-f FAMILY] -n NAME
test.py: error: argument -n/--name is required

由于可选参数name的required=True，所以必须要传入。如果将其更改为False

configparser 模块

# 注释1
; 注释2

[section1]
k1 = v1
k2:v2
user=egon
age=18
is_admin=true
salary=31

[section2]
k1 = v1

读取

import configparser

config=configparser.ConfigParser()
config.read( a.cfg )

#查看所有的标题
res=config.sections() #[ section1 ,  section2 ]
print(res)

#查看标题section1下所有key=value的key
options=config.options( section1 )
print(options) #[ k1 ,  k2 ,  user ,  age ,  is_admin ,  salary ]

#查看标题section1下所有key=value的(key,value)格式
item_list=config.items( section1 )
print(item_list) #[( k1 ,  v1 ), ( k2 ,  v2 ), ( user ,  egon ), ( age ,  18 ), ( is_admin ,  true ), ( salary ,  31 )]

#查看标题section1下user的值=>字符串格式
val=config.get( section1 , user )
print(val) #egon

#查看标题section1下age的值=>整数格式
val1=config.getint( section1 , age )
print(val1) #18

#查看标题section1下is_admin的值=>布尔值格式
val2=config.getboolean( section1 , is_admin )
print(val2) #True

#查看标题section1下salary的值=>浮点型格式
val3=config.getfloat( section1 , salary )
print(val3) #31.0

改写

import configparser

config=configparser.ConfigParser()
config.read( a.cfg ,encoding= utf-8 )


#删除整个标题section2
config.remove_section( section2 )

#删除标题section1下的某个k1和k2
config.remove_option( section1 , k1 )
config.remove_option( section1 , k2 )

#判断是否存在某个标题
print(config.has_section( section1 ))

#判断标题section1下是否有user
print(config.has_option( section1 ,  ))


#添加一个标题
config.add_section( egon )

#在标题egon下添加name=egon,age=18的配置
config.set( egon , name , egon )
config.set( egon , age ,18) #报错,必须是字符串


#最后将修改的内容写入文件,完成最终的修改
config.write(open( a.cfg , w ))

logging模块

import logging

logger = logging.getLogger(__file__)
h1 = logging.StreamHandler()
formmater1 = logging.Formatter( %(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s ,
                              datefmt= %Y-%m-%d %H:%M:%S %p , )
h1.setFormatter(formmater1)
logger.addHandler(h1)
logger.setLevel(logging.DEBUG)



"""
复制代码
#logger：产生日志的对象

#Filter：过滤日志的对象

#Handler：接收日志然后控制打印到不同的地方，FileHandler用来打印到文件中，StreamHandler用来打印到终端

#Formatter对象：可以定制不同的日志格式对象，然后绑定给不同的Handler对象使用，以此来控制不同的Handler的日志格式

"""
   
critical=50
error =40
warning =30
info = 20
debug =10
   


import logging

#1、logger对象：负责产生日志，然后交给Filter过滤，然后交给不同的Handler输出
logger=logging.getLogger(__file__)

#2、Filter对象：不常用，略

#3、Handler对象：接收logger传来的日志，然后控制输出
h1=logging.FileHandler( t1.log ) #打印到文件
h2=logging.FileHandler( t2.log ) #打印到文件
h3=logging.StreamHandler() #打印到终端

#4、Formatter对象：日志格式
formmater1=logging.Formatter( %(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s ,
                    datefmt= %Y-%m-%d %H:%M:%S %p ,)

formmater2=logging.Formatter( %(asctime)s :  %(message)s ,
                    datefmt= %Y-%m-%d %H:%M:%S %p ,)

formmater3=logging.Formatter( %(name)s %(message)s ,)


#5、为Handler对象绑定格式
h1.setFormatter(formmater1)
h2.setFormatter(formmater2)
h3.setFormatter(formmater3)

#6、将Handler添加给logger并设置日志级别
logger.addHandler(h1)
logger.addHandler(h2)
logger.addHandler(h3)
logger.setLevel(10)

#7、测试
logger.debug( debug )
logger.info( info )
logger.warning( warning )
logger.error( error )
logger.critical( critical )

应用

import logging

# 1、创建一个logger
logger = logging.getLogger( mylogger )
logger.setLevel(logging.DEBUG)

# 2、创建一个handler，用于写入日志文件
fh = logging.FileHandler( test.log )
fh.setLevel(logging.DEBUG)

# 再创建一个handler，用于输出到控制台
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)

# 3、定义handler的输出格式（formatter）
formatter = logging.Formatter( %(asctime)s - %(name)s - %(levelname)s - %(message)s )

# 4、给handler添加formatter
fh.setFormatter(formatter)
ch.setFormatter(formatter)

# 5、给logger添加handler
logger.addHandler(fh)
logger.addHandler(ch)