''''''
"""
# 生成随机验证码
大写字母 小写字母 数字
5位数的随机验证码
chr
random.choice
封装成一个函数,用户想生成几位就生成几位
# import random # 导入随机模块
# def get_code(n): # 定义一个函数，需要参数n
# code = '' # 随机码为空字符串
# for i in range(n): # 从0-n范围for循环
# # 先生成随机的大写字母 小写字母 数字
# upper_str = chr(random.randint(65,90)) # chr从ASCII码表中随机范围数字解决大写字母范围
# lower_str = chr(random.randint(97,122)) # 调用ramdon.randint 随机整数 取小写字母
# random_int = str(random.randint(0,9)) # 从0-9，随机取整数 包含首尾
# # 从上面三个中随机选择一个作为随机验证码的某一位
# code += random.choice([upper_str,lower_str,random_int]) # 随机码字符串，for循环一次，随机从列表中三个变量随机增加一个值
# return code # 返回code 随机字符串
# res = get_code(4) # 调用函数返沪随机字符串，传参4，for循环四次，即code是四位
# print(res) # 打印函数执行结果，返回的随机码
"""
'''collection 模块'''
"""
整型
浮点型
字符串
列表
字典
集合
元组
布尔值
"""
# 具名元组
'''
具名元组 collections.namedtuple （百度也有解释）
导入模块 from collections import namedtuple
对象 = namedtuple('元组名',"['1','2','3']可迭代对象") # 可迭代对象中可以指定，具名元组中需要几个值
# 具名元组对象 = 具名元组函数（具名元组名称，元组中的每个值的代表的含义）
# 构建的具名元组工厂函数 = 具名元组工厂函数（具名元组类名，各字段名字或属性）
p具名元组赋值结果 = 对象（这里给可迭代对象的元组赋值，在创建具名元组时，里面写了几个值，这里也就需要几个值）
# 具名元组 = 具名元组工厂函数（属性1的赋值，属性2的赋值）
取值方式 p.元组中元素的含义 = 给其赋的值
# 取值方式 具名元组.属性1 = 属性1的赋值
namedtuple先创建一个工厂函数，传参构建，两个参数，一个具名元组类名，一个字段名的列表（可以是可迭代对象）
给工厂函数传值赋值，按照字段名列表给字段一一赋值，可以得到具名元组，取值可以根据 具名元组.字段名 取值
具名元组取值，可以通过 具名元组函数.属性（字段名字） = 属性赋值
具名元组函数.索引 = 对应索引的字段名的值
for i in 具名元组 ： # 具名元组可迭代
print(namedtuple('坐标',['x','y','z'])(1,2,5).x) # 1
打印 （ 具名元组函数（元组名，元组值）（赋值）.元组值 ） = 给元组值赋的值
'''
# # 想表示坐标点x为1 y为2的坐标 # 需求
# # print(namedtuple('坐标',['x','y','z'])(1,2,5).x) # 1
# # 打印 （ 具名元组函数（元组名，元组值）（赋值）.元组值 ） = 给元组值赋的值
# from collections import namedtuple # 导入模块中的方法（函数）
# point = namedtuple('坐标',['x','y','z']) # 第一个参数是元组名（字符串） 第二个参数既可以传可迭代对象
# # point = namedtuple('坐标','x y z') # 也可以传字符串 但是字符串之间以空格隔开 另一种定义具名元组的写法
# print(point) # <class '__main__.坐标'>
# p = point(1,2,5) # 注意元素的个数必须跟namedtuple第二个参数里面的值数量一致，给元组赋值
# print(p) # 打印具名元组 元组名(值1 = 赋值1，值2 = 赋值2)
# print(p.x) # 具名元组取值 元组名.值1
# print(p.y)
# print(p.z)
#
# from collections import namedtuple # 导入模块
# card = namedtuple('扑克牌','color number') # 定义具名元组，返回一个
# # card1 = namedtuple('扑克牌',['color','number']) # 定义具名元组的另一种写法
# A = card('♠','A') # 给具名元组赋值 返回赋值结果的具名元组
# print(A) # 打印 赋值的具名元组 扑克牌(color='♠', number='A')
# print(A.color) #
# print(A.number) #
# city = namedtuple('日本','name person size')
# c = city('东京','R老师','L')
# print(c)
# print(c.name)
# print(c.person)
# print(c.size)
# # 队列:现进先出(FIFO first in first out)
# # import queue # 导入 queue 模块
# # q = queue.Queue() # 生成队列对象
# from queue import Queue # 从queue模块中导入方法 Queue 跟上面先导入模块 再 模块.方法 ，调用方法一样
# q = Queue() # 直接用方法，函数加括号既可以创建一个队列对象
# q.put('first') # 往队列中添加值 队列对象.put（'需要传入队列的值'） first 先进先出
# q.put('"second":1') # 可以放键值对 取到的也是 键值对
# q.put('third')
#
# print(q.get()) # 朝队列要值 队列对象.get() first 先进先出
# print(q.get()) # 取到的也是 键值对 "second":1
# print(q.get()) # 只有三个值，取完了就终止程序
# # print(q.get()) # 如果队列中的值取完了 程序会在原地等待 直到从队列中拿到值才停止 程序还在跑，在等待
# deque双端队列
"""
from collections import deque
q = deque(['a','b','c']) # 将一个列表变为双端队列，也可以将一个可迭代对象变为双端队列
append 右边加值
appendleft 左边加值
pop 右边弹出取值
popleft 左边边弹出取值
"""
# from collections import deque
# q = deque(['a','b','c']) # 将一个列表变为双端队列，也可以将一个可迭代对象变为双端队列
# q.append('右')
# q.appendleft('左')
# print(q) # deque(['左', 'a', 'b', 'c', '右'])
# print(q.pop()) # 右
# print(q.popleft()) # 左
# q.insert(2,'哈哈哈') # 特殊点:双端队列可以根据索引在任意位置插值
# print(q) # deque(['a', 'b', '哈哈哈', 'c']) # 上面把左右弹出了，添加的新值索引为2
"""
队列不应该支持任意位置插值
只能在首尾插值(不能插队)
"""
'''
from collections import OrderedDict
'''
# normal_d = dict([('a',1),('b',2),('c',3)]) # 定义一个普通字典
# print(normal_d) # 普通的无序字典 {'a': 1, 'b': 2, 'c': 3}
# from collections import OrderedDict # 调用collections 中 OrderedDict 方法
# order_d = OrderedDict([('a',1),('b',2),('c',3)])
# print(order_d) # OrderedDict([('a', 1), ('b', 2), ('c', 3)]) 打印字典 有顺序
# order_d1 = OrderedDict() # 定义一个有序空字典
# order_d1['x'] = 1 # 给有序空字典添加键值对 'x' = 1
# order_d1['y'] = 2 # 给有序空字典添加键值对 'y' = 1
# order_d1['z'] = 3 # 给有序空字典添加键值对 'z' = 1
# print(order_d1) # {'x': 1, 'y': 2, 'z': 3} 打印字典 有顺序
# for i in order_d1:
# print(i)
# print(order_d1) # OrderedDict([('x', 1), ('y', 2), ('z', 3)]) 有序字典
# print(order_d) # OrderedDict([('a', 1), ('b', 2), ('c', 3)]) 终端打印 顺序可能会乱，没有顺序的字典
# order_d1 = dict()
# order_d1['x'] = 1
# order_d1['y'] = 2
# order_d1['z'] = 3
# print(order_d1) # {'x': 1, 'y': 2, 'z': 3}
# for i in order_d1:
# print(i) # x y z 取出字典的key，有顺序
'''
默认值字典，
my_dict = defaultdict(list) # 后续该字典中新建的key对应的value默认就是列表
字典名 = defaultdict(数据类型)
创建一个默认值字典，该字典中添加新的key时，会把value设置为一个空的指定数据类型
创建一个默认值字典，指定value数据类型为list，添加值的时候，如果被添加的值是一个集合，则会变为列表加入字典的value
'''
# from collections import defaultdict
#
# values = [11, 22, 33,44,55,66,77,{88},99,90]
#
# my_dict = defaultdict(list) # 后续该字典中新建的key对应的value默认就是列表
# print(my_dict['aaa'])
# for value in values:
# if value == {88}:
# my_dict['k3'].append(value)
# elif value>66:
# my_dict['k1'].append(value)
# else:
# my_dict['k2'].append(value)
# print(my_dict)
# # defaultdict(<class 'list'>, {'aaa': [], 'k2': [11, 22, 33, 44, 55, 66], 'k1': [77, 99, 90], 'k3': [{88}]})
# # 添加值的时候，如果被添加的值是一个集合，则会变为列表加入字典的value 'k3': [{88}]}
# # 如果 values ={11, 22, 33,44,55,66,77,88,99,90} 则 给定的是一个集合，取value
# # print(my_dict)
# # defaultdict(<class 'list'>, {'aaa': [], 'k2': [33, 66, 11, 44, 22, 55], 'k1': [99, 77, 88, 90]})
#
# my_dict1 = defaultdict(int) # 创建一个默认值字典，指定value数据类型为整型，添加key时，不写value，则默认value是0
# print(my_dict1['xxx']) # 0
# print(my_dict1['yyy']) # 0
# my_dict1['zzz'] = 'haha' # 创建一个默认值字典，指定value数据类型为整型，添加key时，value是字符串，则
# print(my_dict1['zzz']) # 则不安默认值走，就是给定的字符串，数据类型也是字符串，尽可能转为指定类型，转不了就不按默认的
# print(type(my_dict1['zzz'])) # <class 'str'>
#
#
# my_dict2 = defaultdict(bool) # 创建一个默认值字典，指定value数据类型为bool，添加key时，不写value，默认是False
# print(my_dict2['kkk']) # False
#
# my_dict3 = defaultdict(tuple) # 创建一个默认值字典，指定value数据类型为tuple，添加key时，不写value，默认是空元组
# print(my_dict3['mmm']) # ()
'''
# from collections import Counter
# 直接循环计数出，字符串中不同字符各出现几次
Counter类的目的是用来跟踪值出现的次数。
它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。
计数值可以是任意的Interger（包括0和负数）。
Counter类和其他语言的bags或multisets很相似。
'''
# from collections import Counter
# s = 'abcdeabcdabcaba'
# res = Counter(s)
# print(res)
# # 结果为 Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1}) 直接循环计数出，字符串中不同字符各出现几次
# for i in res:
# print(i) # 循环取出字典中的key，字典中的key不重复
# # 先循环当前字符串 将每一个字符串都采用字典新建键值对的范式
# d = {} # 指定一个空字典
# for i in s: # 循环字符串
# d[i] = 0 # 循环到相同的key，则更新重复键的值，会针对key去重，只保留一个key
# print(d) # {'a': 0, 'b': 0, 'c': 0, 'd': 0, 'e': 0}
'''
时间模块 time datetime
'''
# time
"""
三种表现形式
1.时间戳 (timestamp) ：
通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型
2.格式化时间(用来展示给人看的)
格式化的时间字符串(Format String)： ‘1999-12-06’
3.结构化时间
元组(struct_time) ：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，本月第几周，一年中第几天等）
time.struct_time(tm_year=2019, tm_mon=7, tm_mday=18, tm_hour=19, tm_min=13, tm_sec=3, tm_wday=3, tm_yday=199, tm_isdst=0)
import time
time.time() 获取当前时间戳
time.strftime("%Y-%m-%d %H-%M-%S") 等同于 time.strftime("%Y-%m-%d %X") 获取格式化时间（-可以换成别的分隔符）
time.localtime() 获取元组 time.struct_time() 结构化时间
time.localtime(time.time()) 时间戳 转 结构化时间
time.mktime(time.localtime()) 结构化时间 转 时间戳，省略小数部分
time.strftime(格式化格式，time.localtime()) 结构化时间 转 格式化时间
time.strptime("格式化时间","格式化格式") 格式化时间 转 结构化时间
"""
# import time
# print(time.time()) # 1563448302.3551118
#
# print(time.strftime('%Y-%m-%d')) # 2019-07-18
# print(time.strftime('%Y-%m-%d %H:%M:%S')) # 2019-07-18 19:11:42
# print(time.strftime('%Y-%m-%d %X')) # %X等价于%H:%M:%S # 2019-07-18 19:11:42
# print(time.strftime('%H:%M')) # 19:11
# print(time.strftime('%Y/%m')) # 2019/07
#
# print(time.localtime())
# # time.struct_time(tm_year=2019, tm_mon=7, tm_mday=18, tm_hour=19, tm_min=13, tm_sec=3, tm_wday=3, tm_yday=199, tm_isdst=0)
#
# print(time.localtime(time.time())) # 时间戳转结构化时间
# # time.struct_time(tm_year=2019, tm_mon=7, tm_mday=18, tm_hour=19, tm_min=13, tm_sec=3, tm_wday=3, tm_yday=199, tm_isdst=0)
# res = time.localtime(time.time()) #
# print(time.time()) # 1563448383.0464137
# print(time.mktime(res)) # 1563448383.0 time.mktime(结构化时间) 结构化时间转时间戳，省略小数部分
# print(time.strftime('%Y-%m',time.localtime())) # 2019-07 结构化时间转格式化时间 time.strftime(格式化格式，结构化时间)
# print(time.strptime(time.strftime('%Y-%m',time.localtime()),'%Y-%m')) # 格式化时间转结构化时间 time.strptime("格式化时间","格式化格式")
# # time.struct_time(tm_year=2019, tm_mon=7, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=182, tm_isdst=-1)
#
#
#
#
'''
import datetime
res = datetime.datetime.today() 年月日 时分秒
res1 = datetime.date.today() 年月日
res.year res1.year 年
res.month res1.month 月
res.day res1.day 日
res.weekday() 周几 0-6表示星期 0表示周一
res.isoweekday() 周几 1-7表示星期 7就是周日
datetime.timedelta(days=7) 指定时间差为七天
日期对象 = 日期对象 +/- timedelta对象
timedelta对象 = 日期对象 +/- 日期对象
'''
# datetime
# import datetime
# print(datetime.date.today()) # date>>>:年月日 2019-07-18
# print(datetime.datetime.today()) # datetime>>>:年月日 时分秒 2019-07-18 19:32:01.734133
# res = datetime.date.today()
# res1 = datetime.datetime.today()
# print(res1.year) # 2019
# print(res1.month) # 7
# print(res1.day) # 18
# print(res1.weekday()) # 0-6表示星期 0表示周一 # 3 表示周四
#
# print(res.isoweekday()) # 1-7表示星期 7就是周日 # 4 表示周四
"""
(******)
日期对象 = 日期对象 +/- timedelta对象
timedelta对象 = 日期对象 +/- 日期对象
"""
# import datetime
# current_time = datetime.date.today() # 日期对象 年月日 2019-07-11
# timetel_t = datetime.timedelta(days=7) # timedelta对象 days=7天 七天的时间差
# res1 = current_time+timetel_t # 日期对象 从现在时间 自增长时间差
#
# print(current_time - timetel_t) # 今天减去七天 2019-07-11
# print(res1-current_time) # 自增长之后的时间减去几天 时间差是七天 7 days, 0:00:00
# 小练习 计算今天距离今年过生日还有多少天
# birth = datetime.datetime(2019,12,21,8,8,8)
# current_time = datetime.datetime.today()
# print(birth-current_time)
# # UTC时间
# import datetime
# dt_today = datetime.datetime.today()
# dt_now = datetime.datetime.now()
# dt_utcnow = datetime.datetime.utcnow()
# print(dt_utcnow) # 2019-07-18 11:42:47.516105 格林尼治时间 在0时区 我们在东八区 差八个小时
# print(dt_now) # 2019-07-18 19:42:47.516105
# print(dt_today) # 2019-07-18 19:42:47.516105
'''
random模块
random.randint(n,m) 随机取一个你提供的整数范围内的数字 包含首尾 随机整数
random.random() 随机取0-1之间小数
print(random.choice([1,2,3,4,5,6])) 摇号 随机从列表中取一个元素
random.shuffle(有序列表) 洗牌 打乱顺序，随机顺序
'''
# 随机模块
# import random
# print(random.randint(1,6)) # 随机取一个你提供的整数范围内的数字 包含首尾
# print(random.random()) # 随机取0-1之间小数
# print(random.choice([1,2,3,4,5,6])) # 摇号 随机从列表中取一个元素
# res = [1,2,3,4,5,6]
# random.shuffle(res) # 洗牌
# print(res)
"""
# 生成随机验证码
大写字母 小写字母 数字
5位数的随机验证码
chr
random.choice
封装成一个函数,用户想生成几位就生成几位
"""
# import random # 导入随机模块
# def get_code(n): # 定义一个函数，需要参数n
# code = '' # 随机码为空字符串
# for i in range(n): # 从0-n范围for循环
# # 先生成随机的大写字母 小写字母 数字
# upper_str = chr(random.randint(65,90)) # chr从ASCII码表中随机范围数字解决大写字母范围
# lower_str = chr(random.randint(97,122)) # 调用ramdon.randint 随机整数 取小写字母
# random_int = str(random.randint(0,9)) # 从0-9，随机取整数 包含首尾
# # 从上面三个中随机选择一个作为随机验证码的某一位
# code += random.choice([upper_str,lower_str,random_int]) # 随机码字符串，for循环一次，随机从列表中三个变量随机增加一个值
# return code # 返回code 随机字符串
# res = get_code(4) # 调用函数返沪随机字符串，传参4，for循环四次，即code是四位
# print(res) # 打印函数执行结果，返回的随机码
'''
os模块
# os模块:跟操作系统打交道的模块
# sys模块:跟python解释器打交道模块
BASE_DIR = os.path.dirname(__file__) 找到当前执行文件的父目录
MOVIE_DIR = os.path.join(BASE_DIR,'老师们的作品') 目录拼接
movie_list = os.listdir(MOVIE_DIR) lisdir列示目标目录下所有内容，做成列表
os.path.dirname(__file__) 找到当前执行文件的父目录，绝对路径 __file__ 当前执行文件
os.path.join(绝对路径1，路径2) 路劲拼接
os.listdir(目标目录) 列示目标目录下所有内容
os.path.exists() 判断文件是否存在
os.path.isfile() 只能判断文件
os.mkdir() 创建文件夹
os.rmdir() 删除空文件夹 目录下有内容不能删除该文件夹
os.getcwd() 获取当前所在路径
os.chdir() 切换路径 类似于cd命令
os.path.getsize() 获取文件大小
os.remove()) 文件删除
os.rename() 文件修改
'''
# import os # 导入os模块
# BASE_DIR = os.path.dirname(__file__) # 定义当前执行文件所在的父目录
# MOVIE_DIR = os.path.join(BASE_DIR,'老师们的作品') # 拼接目录，将父目录下的 老师们的作品 拼接上找到 老师们的作品的绝对路径
# movie_list = os.listdir(MOVIE_DIR) # lisdir列示目标目录下所有内容，做成列表
# while True: # 循环
# for i,j in enumerate(movie_list,1): # 枚举做索引目录
# print(i,j) # 打印索引和文件名
# choice = input('你想看谁的啊(今日热搜:tank老师)>>>:').strip() # 用户输入选择
# if choice.isdigit(): # 判断用户输入的是否是纯数字
# choice = int(choice) # 传成int类型
# if choice in range(1,len(movie_list)+1): # 判断是否在列表元素个数范围内
# # 获取用户想要看的文件名
# target_file = movie_list[choice-1] # 目标文件为 用户选择的索引取值
# # 拼接文件绝对路径
# target_path = os.path.join(MOVIE_DIR,target_file) # 目标文件绝对路径 等于 老师们的作品的绝对路径+文件名
# with open(target_path,'r',encoding='utf-8') as f: # 打开
# print(f.read()) # 读取
# os.mkdir('tank老师精选') # 自动创建文件夹
# print(os.path.exists(r'D:\Python项目\day16\rion老师精选')) # 判断文件是否存在
# print(os.path.exists(r'D:\Python项目\day16\老师们的作品\tank老师.txt')) # 判断文件是否存在
# print(os.path.isfile(r'D:\Python项目\day16\tank老师精选')) # 只能判断文件 不能判断文件夹
# print(os.path.isfile(r'D:\Python项目\day16\老师们的作品\tank老师.txt')) # 只能判断文件 不能判断文件夹
# os.rmdir(r'D:\Python项目\day16\老师们的作品') # 只能删空文件夹
# print(os.getcwd())
# print(os.chdir(r'D:\Python项目\day16\老师们的作品')) # 切换当前所在的目录
# print(os.getcwd())
# 获取文件大小
# print(os.path.getsize(r'D:\Python项目\day16\老师们的作品\tank老师.txt')) # 字节大小
# with open(r'D:\Python项目\day16\老师们的作品\tank老师.txt',encoding='utf-8') as f:
# print(len(f.read()))
''''''
'''
sys模块
# os模块:跟操作系统打交道的模块
# sys模块:跟python解释器打交道模块
import sys
sys.path.append() # 将某个路径添加到系统的环境变量中
print(sys.version) # python解释器的版本
print(sys.platform) # 操作系统信息 win32 sys.platform 系统平台
print(sys.argv)
在终端用python3执行文件时候，python后面跟绝对路径，直接回车执行，
如果文件中有print(sys.argv)，则会打印一个执行文件的绝对路径，作为一个列表的元素打印，
后面有别的输入也会在列表中一起打印
这个是文件内可以读取 执行该文件的时候输入的东西，
命令行启动文件 可以做身份的验证，校验用户在执行文件时输入的密码
'''
import sys
# sys.path.append() # 将某个路径添加到系统的环境变量中
# print(sys.platform) # 操作系统信息 win32
# print(sys.version) # python解释器的版本
# # 切到cmd或者pycharm 命令行执行这个文件，后面
# # 输入 python 该文件绝对路径（copypath） jason 123
# # 可以执行 如果输错了 则用户不存在
# import sys
# print(sys.argv) # 命令行启动文件 可以做身份的验证 显示当前执行文件绝对路径
# if len(sys.argv) <= 1:
# print('请输入用户名和密码')
# else:
# username = sys.argv[1]
# password = sys.argv[2]
# if username == 'jason' and password == '123':
# print('欢迎使用')
# # 当前这个py文件逻辑代码
# else:
# print('用户不存在 无法执行当前文件')
'''
subprocess模块
'''
# subprocess
"""
sub :子
process:进程
"""
"""
1.用户通过网络连接上了你的这台电脑
2.用户输入相应的命令 基于网络发送给了你这台电脑上某个程序
3.获取用户命令 里面subprocess执行该用户命令
4.将执行结果再基于网络发送给用户
这样就实现 用户远程操作你这台电脑的操作
stdout=subprocess.PIPE 正确命令返回的结果stdout
stderr=subprocess.PIPE 错误命令返回的结果stderr
subprocess模块
import subprocess
sub_obj = subprocess.Popen('dir',shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
print(sub_obj.stdout.read()) # 直接拿到的是一个二进制数据(该二进制的编码是参考执行该命令计算机的操作系统默认编码)
print(sub_obj.stdout.read().decode('gbk')) # 直接拿到的是一个二进制数据(该二进制的编码是参考执行该命令计算机的操作系统默认编码) windows
"""
# while True:
# cmd = input('cmd>>>:').strip()
# import subprocess
# obj = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
# # print(obj)
# print('正确命令返回的结果stdout',obj.stdout.read().decode('gbk'))
# print('错误命令返回的提示信息stderr',obj.stderr.read().decode('gbk'))
'''
序列化模块 json模块 pickle模块
'''
"""
序列化
序列:字符串
序列化:其他数据类型转换成字符串的过程
写入文件的数据必须是字符串
基于网络传输的数据必须是二进制
序列化:其他数据类型转成字符串的过程
json.dumps（数据类型） json.dump（目标数据，目标文件） pickle.dumps（数据类型） pickle.dump（目标数据，目标文件）
反序列化:字符串转成其他数据类型
json.loads（存好的字符串） json.load（目标文件） pickle.loads（存好的字符串） pickle.load（目标文件）
dumps（数据类型）:序列化 将其他数据类型转成json格式的字符串
loads（存好的字符串）:反序列化 将json格式的字符串转换成其他数据类型，转化为其原来的数据类型
dump（目标数据，目标文件）：序列化 将其他数据类型转成json格式的字符串，然后后写入文件
load（目标文件）：反序列化 将json格式的字符串转换成其他数据类型，还原文件内容，读取文件内容
用pickle操作文件的时候 文件的打开模式必须是b模式
json模块(******)
所有的语言都支持json格式
支持的数据类型很少 字符串 列表 字典 整型 元组(转成列表) 布尔值
pickle模块(****)
只支持python
python所有的数据类型都支持
"""
# import json
# d = {"name":"jason"}
# print(d)
# res = json.dumps(d) # json格式的字符串 必须是双引号 >>>: '{"name": "jason"}'
# print(res,type(res))
# res1 = json.loads(res)
# print(res1,type(res1))
# d = {"name":"jason"}
# with open('userinfo','w',encoding='utf-8') as f:
# json.dump(d,f) # 装字符串并自动写入文件
# with open('userinfo','r',encoding='utf-8') as f:
# res = json.load(f)
# print(res,type(res))
#
# with open('userinfo','w',encoding='utf-8') as f:
# json.dump(d,f) # 装字符串并自动写入文件
# json.dump(d,f) # 装字符串并自动写入文件
# with open('userinfo','r',encoding='utf-8') as f:
# res1 = json.load(f) # 不能够多次反序列化
# res2 = json.load(f)
# print(res1,type(res1))
# print(res2,type(res2))
# with open('userinfo','w',encoding='utf-8') as f:
# json_str = json.dumps(d)
# json_str1 = json.dumps(d)
# f.write('%s\n'%json_str)
# f.write('%s\n'%json_str1)
# with open('userinfo','r',encoding='utf-8') as f:
# for line in f:
# res = json.loads(line)
# print(res,type(res))
# t = (1,2,3,4)
# print(json.dumps(t))
# d1 = {'name':'朱志坚'}
# print(json.dumps(d1,ensure_ascii=False))
# pickle
# import pickle
# d = {'name':'jason'}
# res = pickle.dumps(d) # 将对象直接转成二进制
# print(pickle.dumps(d))
# res1 = pickle.loads(res)
# print(res1,type(res1))
"""
用pickle操作文件的时候 文件的打开模式必须是b模式
"""
# with open('userinfo_1','wb') as f:
# pickle.dump(d,f)
# with open('userinfo_1','rb') as f:
# res = pickle.load(f)
# print(res,type(res))
cellection模块（具名元组 双端队列 有序字典 默认值字典 counter） time datetime时间模块 random os sys subprocess 序列化模块
猜你喜欢
转载自www.cnblogs.com/xiaozhenpy/p/11220614.html
今日推荐
周排行