常用系统模块和文件操作
一、time模块
- 时间戳
用指定时间到1970年1月1日0时0秒（格林威治时间）的时间差（单位是秒）来表示时间的方式就是时间戳
注意：格林威治时间和北京时间有8小时的时差
4个字节（时间戳存储时间）
16个字节（用字符串存储时间）
import time
1. time.time() -- 获取当前时间
print(time.time()) # 1627612143.562589
2.
time.localtime() -- 获取当前时间的本地时间，返回结构体时间
time.localtime(时间戳) -- 将时间戳对应的时间转换成本地时间
t1 = time.localtime()
print(time.localtime(1627612143.562589))
print(time.localtime(0))
3. time.sleep(时间) -- 程序休眠指定时间，单位秒
time.sleep(2)
print('==========')
time.strftime(时间格式，结构体时间)结构体时间转字符串时间
xxx年xx月xx日 xx时：xx分：xx秒
‘’’
%Y - 年
%m - 月
%d - 日
%H - 时（24小时）
%I - 时（12小时）
%M - 分
%S - 秒
%p - AM、PM(上午、下午)
%a - 星期英文单词缩写
%A - 星期英文单词全拼
%b - 月份英文缩写
%B - 月份英文全拼
‘’’
result = time.strftime('%Y年%m月%d日 %H:%M:%S', t1)
print(result)
# xxxx-xx-xx xx:xx:xx
result = time.strftime('%Y-%m-%d %H:%M:%S', t1)
print(result)
result = time.strftime('%m月%d日 %p%I:%M %B', t1)
print(result)
- 将字符串时间转换成结构体时间
time.strptime(字符串时间，时间格式)
t2 = '2010-10-2'
t3 = time.strptime('2010-10-2', '%Y-%m-%d')
print(f'周{t3.tm_wday+1}')
print(t3)
6.将字符串时间转换成时间戳（先将字符串时间转换成结构体时间）
time.mktime(结构体时间) -- 将结构体时间转换成时间戳
result = time.mktime(t3)
print(result)
二、datetime模块
import datetime
from datetime import datetime
- datetime类型 – 处理包含年月日时分秒的时间
1）创建datetime时间对象
datetime(year，moth，day， hour=0， minute=0， second=0)
t1 = datetime(2010, 10, 2)
print(t1) # 2010-10-02 00:00:00
t2 = datetime(2011, 9, 30, 11, 15, 30)
print(t2) # 2011-09-30 11:15:30
2）获取时间属性
时间对象.year、时间对象.month、…
print(t2.month)
print(t2.hour)
- 获取当前时间
t3 = datetime.now()
print(t3)
- 将datetime转换成结构体时间
t4 = t3.timetuple()
print(t4)
- 将datetime转换成字符串时间
st5 = t3.strftime('%Y年%m月%d日 %a')
print(st5)
- 将字符串时间转换成datetime
st6 = '2003-7-1'
t5 = datetime.strptime(st6, '%Y-%m-%d')
print(t5)
2.timedelta - 主要用于时间加减操作
from datetime import timedelta
t6 = t5 + timedelta(days=45)
print(t6)
t7 = t5 - timedelta(hours=8)
print(t7)
t8 = t5 + timedelta(days=1, hours=5, minutes=15)
print(t8)
三、hashlib模块
import hashlib
# hashlib模块 - 用于生成数据的hash摘要
‘’’
hash加密算法主要有：md5 和 shaxxx
-
hash加密的特点：
a. 不可逆（通过原数据加密后（产生的摘要）无法还原）
b. 相同的数据通过相同的算法产生的摘要（密文）是一样的
c. 不同大小的数据在使用相同的算法产生的摘要的长度一致 -
使用hashlib产生数据的摘要
‘’’- 根据算法创建hash对象
hashlib.算法名()
hash = hashlib.md5()
2. 添加数据
hash对象.update(二进制数据)
pw = '123456'
hash.update(pw.encode())
f = open('files/text.py', 'rb')
hash.update(f.read())
3. 获取摘要
result = hash.hexdigest()
print(result)
‘’’
python二进制数据类型 – bytes
字符串和bytes的相互转换
-
str --> bytes
方法一：bytes(字符串, ‘utf-8’)
方法二：b’字符串’
方法三：字符串.encode() -
bytes --> str
方法一：str(二进制数据, ‘utf-8’)
方法二：二进制.decode()
‘’’
# 字符串转二进制
print(bytes('abc', 'utf-8')) # b'abc'
b1 = b'abc'
print(type(b1)) # <class 'bytes'>
str1 = 'abc'
print(str1.encode())
# 二进制转字符串
print(str(b1, 'utf-8'))
print(b1.decode())
四、文件操作
- 数据的存储
‘’’
程序中保存的数据默认都是存储在运行内存中，运行内存中的数据在程序结束的时候都会被释放。
如果希望程序运行过程中产生的数据在程序结束后不被销毁，就需要将数据存储到磁盘中。
将数据存储到磁盘过程叫做数据持久化、数据本地化。
数据持久化的基本原理 - 将数据通过文件存储到磁盘中。
‘’’
-
文件操作（操作文件内容）
‘’’
文件操作主要解决两个问题：a. 怎么将程序中的数据通过文件存储到磁盘中
b. 怎么在程序中使用保存在文件中的数据
‘’’ -
文件操作基本步骤
‘’’
第一步：打开文件
open(文件路径，读写模式，encoding=文件编码方式) – 以指定方式打开指定文件，返回文件对象
1）文件路径 – 文件在计算机中的位置信息，以字符串的形式提供值。
a. 绝对路径：文件在计算机中的全路径
b. 相对路径：. – 表示当前目录（当前代码文件所在的目录），./可以省略
… – 表示当前目录的上层目录
-
读写模式 – 设置打开文件后支持的是读操作还是写操作；设置操作数据的类型是字符串还是二进制
第一组值：
r – 只读
w – 只写；先清空原文件
a – 只写；保留原文件内容，在后面追加数据
第二组值：
t – 数据类型是字符串（t可以忽略）
b – 数据类型是bytes'r' == 'rt' == 'tr'注意：如果是文本文件可以用t或者b的方式打开，如果是二进制文件只能以b的方式打开
-
encoding – 文件编码方式(打开的编码方式和文件的编码方式必须一致)
以b的方式打开文件的时候encoding不能赋值
第二步：读文件、写文件
文件对象.read()
文件对象.write(数据)
第三步：关闭文件
文件对象.close()
‘’’
参数1：路径
open('files/text.py')
open('../day-14常用系统模块和文件操作/01-review.py')
参数2：读写模式
1) r -- 只读
f = open('test.py', 'r')
f.read()
2) w -- 只写； 会清空原文件
f = open('test.py', 'w')
f.write('abc')
f.read()
3) t -- 读写数据的类型是字符串
f = open('test.py', 'rt')
result = f.read()
print(type(result)) # <class 'str'>
f = open('test.py', 'at')
f.write('abc')
4) b -- 读写数据的类型是二进制
f = open('text.py', 'rb')
result = f.read()
print(type(result)) # <class 'bytes'>
f = open('test.py', 'ab')
f.write('abc'.encode())
f = open('02-time模块.py', mode='r', encoding='utf-8')
f.read()
f = open('files/text.py', 'r', encoding='utf-8')
f.read()
f = open(r'E:\壁纸\2.jpg', 'rb')
f.read()
f.close()
五、读写操作
1.读操作
‘’’
1)
文件对象.read() – 从读写位置开始读到文件结尾（读写位置默认在文件开头）
文件对象.readline() – 从读写位置开始读到一行的结尾（只有在读文本文件的时候有效）
文本对象.readlines() – 一行一行的读，读完
‘’’
f = open('files/text.py', encoding='utf-8')
result = f.read()
print(result)
print('-------------------华丽分割线--------------------')
f.seek(0) # 设置读写位置到文件开头
print(f.read())
print('-------------------华丽分割线--------------------')
f.seek(0)
print(f.readline())
print(f.readline())
print(f.readline())
print(f.readline())
print('===:', f.readline(), '====', sep='')
print('-------------------华丽分割线--------------------')
f.seek(0)
print(f.readlines())
f.close()
print('-------------------华丽分割线--------------------')
f = open('test.py', 'a', encoding='utf-8')
f.write('\nabc\n123\n456')
# f.writelines(['abc', '123', '456'])
f.close()
六、数据内存操作
数据持久化的基本步骤：
‘’’
第一步：确定需要持久化的数据（确定哪个数据在下一次运行程序的时候还要用）
第二步：创建文件保存数据初始值
第三步：在程序中需要这个数据的时候从文件中读数据
第四步：如果数据发生改变，要将最新的数据写回文件中
‘’’
练习1：写一程序打印程序运行次数
'''
第一次运行程序打印： 1
第一次运行程序打印： 2
第一次运行程序打印： 3
'''
f = open('count.txt', 'rt', encoding='utf-8')
count = int(f.read())
count += 1
print(count)
f = open('count.txt', 'w', encoding='utf-8')
f.write(str(count))
练习2：添加学生，并且在添加完成后显示所有学生信息（只需要学生名字）
'''
请输入学生姓名：小明
小明 ['小明']
请输入学生姓名：小花
小明 小花 ['小明', '小花']
请输入学生姓名：q
（程序结束）
请输入学生姓名：张三
小明 小花 张三 ['小明', '小花', '张三']
请输入学生姓名: 李四
小明 小花 张三 李四 ['小明', '小花', '张三', '李四']
请输入学生姓名:q
（程序结束）
'''
需求1：
while True:
name = input('请输入学生姓名：')
if name == 'q':
break
f = open('count.txt', 'a', encoding='utf-8')
f.write(f'{name} ')
f = open('count.txt', encoding='utf-8')
print(f.read())
需求2：
while True:
name = input('请输入学生姓名:')
if name == 'q':
break
f = open('coun1.txt', encoding='utf-8')
all_count = eval(f.read()) # '[]', "['name']"
all_count.append(name)
print(all_count)
f = open('coun1.txt', 'w', encoding='utf-8')
f.write(str(all_count))
1021
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
