random模块，os模块，sys模块，json模块-序列化与反序列化，pickle模块，subprocess模块

random模块

import random

print(random.random())  # 随机产生一个0-1之间的小数
print(random.randint(0, 9))  # 随机产生一个0-9之间的整数
print(random.uniform(1, 3)) # 大于1小于3的小数，如1.070310748976216，随机取
print(random.choice([1, 2, "axx", 3.1]))  # 每次随机只取一个
print(random.sample([1, 2, "axx", 3.1], 2)) # 每次随机取两个拼成列表，可以指定取几个



item=[1, 3, 5, 7, 9, 'J', 'Q', 'K', 'A']
random.shuffle(item)  # 打乱item的顺序,相当于"洗牌"
print(item)


print(ord('A'))   # 65  # ord这个功能会参照ASCII码表把大写字母转成数字
print(ord('Z'))   # 90  
print(chr(65))    # A   # chr这个功能会参照ASCII码表把数字转成大写字母



# 生成随机验证码功能，数字加大写字母
def make_code(size=6):
    code = ''
    for i in range(size):
        random_int = str(random.randint(0,9))
        random_upper = chr(random.randint(65,90))
        random_lower = chr(random.randint(65,90))
        code += random.choice([random_int, random_upper, random_lower])
    return code


# 使用验证码校验
auth_code = make_code()
print('验证码：', auth_code)
auth_code1 = input("请输入验证码：").strip()
if auth_code1 == auth_code:
    print("验证成功")
else:
    print("验证失败")
    
# 随机抽取小组例会主持人
import random
five_groups = ['耿锋', '刘富强', '林天龙', '耿建', '李达标', '李厚笑', '任姣姣', '曹富康']
compere = random.choice(five_groups)
print('本次的主持人是：%s' % compere)

---

os模块

这个模块提供了一种方便的使用操作系统函数的方法。

os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口

os的用法

os.getcwd()  # 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  # 改变当前脚本工作目录；相当于shell下cd
os.curdir  # 返回当前目录: ('.')
os.pardir  # 获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')  # 可生成多层递归目录
os.removedirs('dirname1')  # 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')  # 生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')  # 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')  # 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  # 删除一个文件
os.rename("oldname","newname")  # 重命名文件/目录
os.stat('path/filename')  # 获取文件/目录信息
os.sep  # 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep  # 输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep  # 输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name  # 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  # 运行shell命令，直接显示
os.environ  # 获取系统环境变量
os.path.abspath(path)  # 返回path规范化的绝对路径
os.path.split(path)  # 将path分割成目录和文件名二元组返回
os.path.dirname(path)  # 返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path)  # 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(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的用法演示

import os
# 1.获取当前工作所在文件夹
print(os.getcwd())


# 2.创建单级目录(文件夹)
os.mkdir('今日新闻')


# 3.递归创建文件夹（多级目录）
os.makedirs("a/b/c")


# 4.递归删除文件夹（多级目录）
os.removedirs("a/b/c") 


# 5.浏览当前文件夹列表显示
res = os.listdir('.') 
print(res)


# 6.查看文件信息
print(os.stat("今日头条.txt")) 


# 7.判断当前路径是否是文件
print(os.path.isfile('今日头条.txt'))  # True 
print(os.path.isfile('今日新闻'))  # False


# 8.判断当前路径是否是文件夹
print(os.path.isdir('今日头条.txt'))  # False 
print(os.path.isdir('今日新闻'))  # True


# 9.获取文件的大小以字节显示
print(os.path.getsize("今日头条.txt")) 


# 10.获取当前文件所在的路径(可以嵌套 则为上一层路径)
BASE_DIR = os.path.dirname(__file__)
print(BASE_DIR)

# 11.判断当前路径是否存在
res = os.path.exists(r"D:\a\b")
print(res)  # True

# 12.判断当前路径是否是绝对路径
print(os.path.isabs(r"D:\a\b\c\d.txt"))  # True
print(os.path.isabs(r"c\d.txt"))  # False 


print(os.environ)  # 环境变量
os.environ["name"] = "jason"
print(os.environ)
print(os.environ['name'])



print(os.path.abspath("a/b/c"))  # 返回path规范化的绝对路径
print(os.path.split(r"D:\a\b\c\d.txt"))  # 将path分割成目录和文件名二元组返回
print(os.path.dirname(r"D:\a\b\c\d.txt"))  # 返回path的目录
print(os.path.basename(r"D:\a\b\c\d.txt"))  # 返回path最后的文件名



# 重点掌握
import os
BASE_DIR = os.path.dirname(__file__)
# 路径拼接(******)os.path.join() 能够自动识别不同操作系统分隔符问题
movie_dir = os.path.join(BASE_DIR, 'dirname1')
# os.listdir() 列举出指定路径下的文件名称(任意类型文件)
data_movie_list = os.listdir('D:\py20\dirname\dirname1')
while True:
    for i, j in enumerate(data_movie_list):
        print(i + 1, j)
    choice = input('请选择你想要看的文件编号>>>:').strip()
    if choice.isdigit():
        choice = int(choice)
        if choice in range(len(data_movie_list) + 1):
            # 获取编号对应的文件名称
            file_name = data_movie_list[choice - 1]
            # 拼接文件的完整路径(******)专门用于路径拼接 并且能够自动识别当前操作系统的路径分隔符
            file_path = os.path.join(movie_dir, file_name)
            # 利用文件操作读写文件
            with open(file_path, 'r', encoding='utf8') as f:
                print(f.read())


# 高能：os路径处理
# 方式一：
# 获取路径文件夹---》获取当前文件夹的上一级文件夹
print(os.path.dirname(os.path.dirname(__file__)))

# 方式二：
res = os.path.normpath(os.path.join(__file__,"..",'..'))
print(res)

---

sys模块

这个模块可供访问由解释器使用或维护的变量和与解释器进行交互

sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境

sys.argv  # 命令行参数List，第一个元素是程序本身路径
sys.exit(n)  # 退出程序，正常退出时exit(0)
sys.version  # 获取Python解释程序的版本信息
sys.maxint  # 最大的Int值
sys.path  # 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform  # 返回操作系统平台名称


import sys
# 获取当前执行文件的绝对路径
print(sys.argv)  # 从命令行中接收用户输入

# 示例1
try:
    username = sys.argv[1]
    password = sys.argv[2]
    if username == 'jason' and password == '123':
        print('正常执行文件内容')
    else:
        print('用户名或密码错误')
except Exception:
    print('请输入用户名和密码')
    print('目前只能让你体验一下(游客模式)')
    
    

#示例2
src_file = sys.argv[1]
dst_file = sys.argv[2]

with open(r'%s' %src_file,mode='rb') as f1,\
    open(r'%s' %dst_file,mode='wb') as f2:
    for line in f1:
        f2.write(line)

---

json模块

序列化与反序列化

什么是序列化？为什么要序列化？

• 序列化就是把内存当中的数据转成一种其它格式，这种格式可以存到文件里去
• 反序列化就是从文件里读出一种格式，可以把这种格式反解成内存当中的数据类型

1、持久保存状态需知一个程序的执行就在处理一系列状态的变化，'状态'会以各种各样有结构的数据类型的形式被保存在内存中。内存是无法永久保存数据的，当程序运行了一段时间，我们断电或者重启程序，内存中关于这个程序的之前一段时间的数据（有结构）都被清空了。在断电或重启程序之前将程序当前内存中所有的数据都保存下来（存档），以便于下次程序执行能够从文件中载入之前的数据，然后继续执行，这就是序列化。

2、跨平台数据交互序列化之后，不仅可以把序列化后的内容写入磁盘，还可以通过网络传输到别的机器上，如果收发的双方约定好实用一种序列化的格式，那么便打破了平台/语言差异化带来的限制，实现了跨平台数据交互。反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。

json模块的使用

import json
# 序列化：将python其他数据转成json格式字符串

dic = {'name': "jason", "xxx": True, "yyy": None}
dic_json = json.dumps(dic)
print(dic_json)  # {"name": "jason", "xxx": true, "yyy": null} 
print(type(dic_json)) # <class 'str'>

with open('a.json',mode='w',encoding='utf-8') as f:
   f.write(dic_json)
    
# 简写成一行代码
json.dump(dic,open('a.json',mode='w',encoding='utf-8'))


# ******************************************************************


# 反序列化：将json格式字符串转成当前语言对应的某个数据类型

with open('a.json', mode='r', encoding='utf-8') as f:
    res = f.read()
    dic = json.loads(res)
    print(dic)  # {'name': 'jason', 'xxx': True, 'yyy': None}
    print(type(dic))  # <class 'dict'>
    print(dic["xxx"])  # True    
    
# 简写成一行代码
dic = json.load(open('a.json', mode='r', encoding='utf-8'))
print(dic['xxx'])  # True



res = json.dumps((1, 2, 3)) # 序列化
print(res, type(res))  # [1, 2, 3] <class 'str'>

dic_s = json.loads('{"k":true}')  # 反序列化
print(dic_s, type(dic_s))  # {'k': True} <class 'dict'>



""" 前方高能屏住呼吸 """
# 注意：JSON不可序列化集合类型
json.dumps({1, 2, 3, 4, 5})  # 报错

json模块四个方法各自详细功能

• 序列化

  • dumps(将其他数据类型转成json格式字符串)
  • dump(将其他数据类型直接以json格式字符串写入文件)

• 反序列化

  • loads(将json格式字符串转成python对应的数据类型)
  • load(将json格式字符串转成python对应的数据类型读出文件)

"""json格式字符串最为显著的特征就是所有的引号都是双引号"""
"""
其他编程语言同样也有类似的序列化反序列化方法
    JSON.stringify()
          JSON.parse()
 
并不是所有的python基本数据类型都支持序列化
    import json
          json.JSONEncoder
"""

json与python内置数据类型的区别

Python类型	JSON类型
dict
list	[ ]
str	"string"
int 或 float	123.45
True	true
Flase	flase
None	Null

json在python里关于中文输出的问题

• python利用json中关于中文输出的问题（ensure_ascii=False）

import json
print(json.dumps("中国人不骗中国人"))

#这时候其实输出的并不是中文，而是ASCII中对应的“中国人不骗中国人”的字符码
#原因：json.dumps序列化时候对中文默认使用的ascii编码，想要输出真正的中文需要指定ensure_ascii=False


import json
print(json.dumps("中国人不骗中国人",ensure_ascii=False))

pickle模块（了解）

Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。

import pickle
# 序列化
res = pickle.dumps({1, 2, 3, 4, 5})
print(type(res))  # <class 'bytes'>
pickle.dump({1, 2, 3, 4, 5}, open('b.pkl', mode='wb'))


# 反序列化
ret = pickle.load(open('b.pkl', mode='rb'))
print(ret, type(ret))  # {1, 2, 3, 4, 5} <class 'set'>

​

subprocess模块

即允许你去创建一个新的进程让其执行另外的程序，并与它进行通信，获取标准的输入、标准输出、标准错误以及返回码等。

• Popen类

  subprocess模块中定义了一个Popen类，通过它可以来创建进程，并与其进行复杂的交互。

import subprocess
"""
1.可以基于网络连接上一台计算机(socket模块)
2.让连接上的计算机执行我们需要执行的命令
3.将命令的结果返回
"""

obj = subprocess.Popen("tasklist", 
                       # shell=True等同于调用命令解释器
                       shell=True,
                       # 管道内存正确输出结果
                       stdout=subprocess.PIPE,
                       # 管道内存错误输出结果
                       stderr=subprocess.PIPE
                       )

"""
Popen 等同于cmd.exe命令解释器

“tasklist”命令是一个用来查看运行在本地或远程计算机上的所有进程的命令行工具，带有多个执行参数。
“ps -ef”如果是mac os系统替换为此命令即可
"""

# 拿到的是subprocess的对象
print(obj)  # <subprocess.Popen object at 0x00000193E7E04BB0>


# 主进程从管道拿到子进程结果
stdout_res = obj.stdout.read()
stderr_res = obj.stderr.read()

"""subprocess使用当前系统默认编码，得到结果为bytes类型，在windows下需要用gbk解码"""
print(stdout_res.decode('gbk'))   # 获取正确命令执行之后的结果
print(stderr_res.decode('gbk'))  # 获取错误命令执行之后的结果

"""
主进程想拿到子进程运行命令的结果做进一步的处理
每启动一个进程在内存里占用一个内存空间，进程与进程之间的内存空间是相互隔离的
在子进程运行Tasklist这条命令，运行完之后这条命令的结果一定是产生在子进程的内存空间里
不可能在主进程拿到这个结果，这个就要用到共享内存了，即“管道”
"""