day16,os,sys,datetime,序列化和反序列化，json，pickle，collectons模块
"""
os:和操作系统相关的操作被封装到这个模块中
"""
import os
和文件相关的，重命名，删除
删除文件
os.remove('a.txt')
重命名文件
os.rename('a.txt','b.txt')
删除目录
shutil 模块
import shutil
shutil.rmtree('aa')
不管目录是否有文件都直接删除 谨慎使用
和路径相关的操作，被封装到另一个子模块当中:os.path
找到一个路径下的上一级路径
os.path.dirname() # 不会判断路径是否存在
获取文件名，得到一个文件的最底层文件名
os.path.basename()
切割文件路径
os.path.split()
把路径中的路径名和文件名切分开，结果是元祖
路径拼接
os.path.join('d:\','a','b','t.txt')
会形成一个拼接好的路径
os.path.abspath('aaa')
得到一个基于当前路径下的另外一个路径
D:\3090\day16\aaa
判断
os.path.isabs() 是不是绝对路径
os.path.isdir() 是不是目录
os.path.exists() 判断文件或文件夹是否存在
os.path.isfile() 判断文件是不是存在
"""
sys和python解释器相关的操作
"""
获取以命令行方式运行脚本所传入的参数
sys.argv()
import sys
sys.argv[0] # 第一个为脚本名字
sys.argv[1] # 第二个为使用脚本时传入的第一个参数
sys.argv[2] # 传入的第二个参数
sys.path
解释器寻找模块的路径
sys.path是一个列表，里面是解释器寻找模块的路径，当一个模块要导入另外一个模块使用
时，得先吧这个模块的绝对路径添加sys.path中，如果是相对路径位置则不需要添加也能使用
sys.modules 查看内存中导入的模块
"""
time模块
"""
import time
获取时间戳
时间戳:从计算机元年(1970 1 1 00:00:00) 到现在所经过的秒数
time.time()
获取格式化的时间
time.localtime(),time.gmtime()
格式化的时间是由九个字段组成
获取字符串时间
格式化的时间通过strftime()的方式可以获取字符串时间
字符串时间也可以通过strptime()的方式获取格式化的时间
time.strftime('%Y-%m-%d %H-%M-%S',date)
time模块通常用于时间的相互装换例如从欧洲时间转换为亚洲时间
9 9 2010
date = time.strptime('%m-%d-%Y %H:%M:%S',data) # 结构化的时间
date = time.mktime(date) # 时间戳
date = time.localtime(date) # 结构化的时间
date = time.strftime('%Y-%m-%d %H-%M-%S',date)
"""
datetime模块
日期时间模块
封装了一些和日期，时间相关的类
date
time
datetime
timedelta
"""
import datetime
date类
d = datetime.date(2021 11 5)
d.year d.day
time类
d = datetime.time(10 10 10)
打印：10:10:10
d.hour ,d.second
datetime类
d = datetime.datetime(2021 11 5 9 41 41)
datetime中的类主要是用于时间相关的计算
通过datetime.timedelta()来计算
例如
now = datetime.datetime(2021 11 5 9 45 00)
d = datetime.timedelta(days = 20,hours = 2)
now += d
print(now)
2021-11-25 11:45:00
datetime模块练习，判断某一年是否是闰年
year = input('input a year')
d = datetime.date(yead 3 1)
t = datetime.timedelta(days = 1)
d -= t
print(d.day)
"""
序列化
把内存中的结构化的数据转化为字节串的过程叫序列化
反序列化
把字节串转换为结构化的数据叫反序列化
"""
import json
python 中json可以把结构化的数据转化为json字符串
dumps 在内存中的序列化，序列化得到的字符串也存在于内存中
s = json.dumps((1,2,3)) # 元祖序列化成一个列表
dump 把内存中的数据序列化到文件中
with open('a.txt',encoding = 'utf-8') as f:
json.dump([1,2,3],f)
load
把文件中的字节串反序列化到内存中变成结构化的数据
loads在内存中吧字节串反序列化
通过json的方法一次性写入文件
with open('a.txt',mode='at',encoding='utf-8') as f:
json.dump([1,2,3],f)
通过f.write(josn.dumps())的方式多次序列化写入文件
with open('a.txt',mode='at',encoding='utf-8') as f:
f.write(json.dumps([1,2,3])+'\n')
f.write(json.dumps([4,5,6])+'\n')
通过json.loads(f.readline().strip)的方式从文件中多次反序列化出文件中的数据
with open('a.txt','rt',encoding='utf-8') as f:
for i in f:
json.loads(i)
hashlib模块=============================================
md5加密算法
给一个数据加密的三大步骤:
1.获取一个加密对象
2.使用加密方法update()进行加密，可以调用多次
3.hexdigest()获取加密结果，或digest()方法，前者得到字符串后者是字节
"""
import hashlib
获取一个加密对象
m = hashlib.md5()
使用加密对象的update，进行加密
b不能把中文转化为字节类型，用完他用的是ASCII码不能识别中文只能中.encode的方法
m.update('abc'.encode('utf-8'))
res = m.hexdigest()
print(res.class)
给一个数据加密
验证：给另一个数据加密，如果得到的密文相同则原文相同否则不同。
不同加密算法，加密长度不同
注册和登陆
def register():
import hashlib
import pickle
name_input = hashlib.md5(input('input your name').encode('utf-8')).hexdigest()
password_input = hashlib.md5((input('input your password').strip()).encode('utf-8')).hexdigest()
res = verfication(name_input)
# res = True
if res :
# 证明用户还没有存在可以注册
with open('user_data.txt','ab') as f:
pickle.dump({'name':name_input,'password':password_input},f)
pickle.dump('\n',f)
print('注册成功')
else:
pass
def verfication(name_input):
import pickle
with open('user_data.txt','rb') as f:
file = r"user_data.txt"
# f = open(file, 'rb')
count = len(open(file, 'rb').readlines())
for line in range(count-1) :
line = pickle.load(f)
name , password = line['name'],line['password']
# f.close()
if name == name_input:
print('该用户名已经存在')
break
else:
return True
def run():
func_dic = {'0':verfication,
'1':register,
}
while True:
print('1注册,q退出')
choice = input('请输入').strip()
if choice == 'q':
break
func_dicchoice
run()
def register():
import hashlib
name_input = hashlib.md5(input('input your name').encode('utf-8'))
password_input = hashlib.md5(input('input your password').encode('utf-8'))
with open(r'date.txt', 'rt', encoding='utf-8') as f:
for line in f:
line = line.rstrip('\n')
name, password = line.split('😂
if name == name_input.hexdigest():
print('该用户已经存在')
else:
with open(r'date.txt', 'at', encoding='utf-8') as f2:
f2.write(name_input.hexdigest())
f2.write('😂
f2.write(password_input.hexdigest())
f2.write('\n')
print('注册成功')
def login():
import hashlib
name_input = hashlib.md5(input('input your name').encode('utf-8')).hexdigest()
password_input = hashlib.md5(input('input your password').encode('utf-8')).hexdigest()
with open(r'date.txt','rt',encoding='utf-8') as f:
for line in f:
line = line.strip()
name , password = line.split('😂
if name == name_input and password == password_input:
print('login!')
break
else:
print('账户或密码错误')
def run():
user_list = ['1.注册','2.登录','q推出']
limits = ['1','2']
user_dic = {
'1':register,
'2':login
}
while True:
for i in user_list:
print(i)
user_input = input('>>>')
if user_input.lower() == 'q':
break
if user_input not in limits:
print('请输入正确的指令')
else:
user_dicuser_input
run()
json,pickle模块===================================================
将python'中所有的数据类型转换成字节串,序列化过程
将字节串装换成python中的数据类型，称为反序列化过程
"""
import pickle
所有的数据类型都可以进行序列化
bys = pickle.dumps([1,2,3])
bys = pickle.dumps((1,2,3))
print(type(bys))
print(bys)
res = pickle.loads(bys)
print(type(res))
bys = pickle.dumps(set('abc'))
res = pickle.loads(bys)
print(res.class)
多次pickle序列化的内容写入文件中
with open('d.txt',mode='ab') as f:
pickle.dump({"alex":"123"},f)
pickle.dump('\n',f)
# pickle.dump('12345\n',f)
从文件中反序列化pickle数据
with open('d.txt','rb') as f:
file=r"d.txt"
count=len(open(file,'rb').readlines())
print(count)
for x in range(count):
print(pickle.load(f).class)
pickle最常用的场景是一次性写入一次读取和json一样
json , pickle的比较：
"""
1.json：不是所有的数据类型都可以序列化('字符串')，反序列化不一定能还原成当初的数据格式
2.不能多次对同一个文件进行序列化，但是可以用f.write(json.dump())的方式多次序列化
3.json数据可以跨语言
"""
pickle:
1.所有的python数据类型都能序列化，结果都是字符
2.可以多次对同一个文件序列化
3.不能夸语言,java,c++不能识别pickle序列化得到是对象
什么是序列化:
把结构化的数据拆分成字节的形式，可以通过网络进行跨语言传输或储存在文件中的过程叫序列化
从文件中或网络中获取的被序列化的数据在转换成为原来的形式，原来的数据类型称为反序列化
collection模块
collections模块
namedtuple():命名元祖
defaultdict():默认值字典
Counter():计数器
"""
import collections
from collections import *
通过属性房屋元祖的属性
namedtuple()
Rectangle = namedtuple('Rectangle_class',['length','width'])
r = Rectangle(10,5)
print(r.length)
print(r.width)
print(r)
默认字典
defaultdict:
defaultdict()
d = defaultdict(int,name='andy',age=10)
print(d['name'],d['age'])
print(d['male'])
print(d)
自定义函数充当第一个参数:
自定义函数不能有参数
def func():
return 369
d = defaultdict(func,name='alex',age=18)
print(d['name'])
print(d['male'])
Counter计数器
r = Counter('aaabbccdde')
print(r.items())
print(r.most_common(3))
浙公网安备 33010602011771号