day17

## 复习

```python
'''
1. 导入模块的加载顺序：内存 > 内置 > sys.path
2. 导入模块的执行流程：遇到导模块 -> 直接就进入模块文件，从上执行执行导入 -> 在遇到导包，再进入执行
3. 循环导入：1.形成了环状导入；2.使用名字时名字未产生 -> 延后导入
4. 包及包的概念：一系列模块的集合体，__init__.py就是一个模块，只是其名称空间可以被包名指向
5. 绝对导入：import 导入 和 from 不是以.开头的导入，都是绝对导入, 和sys.path息息相关
6. 相对导入：from .开头的导入，这样的文件不能作为可执行文件，所以是包内语法
# 1.包内语法：不止init文件可以使用，包内的所有模块都可以使用
# 2..是当前目录，..是上一级目录，以此类推
'''

## time模块

```python
'''
时间戳(timestamp)：time.time()
延迟线程的运行：time.sleep(secs)
(指定时间戳下的)当前时区时间：time.localtime([secs])
(指定时间戳下的)格林威治时间：time.gmtime([secs])
(指定时间元组下的)格式化时间：time.strftime(fmt[,tupletime])
'''

'''
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
'''

calendar:日历
'''
判断闰年：calendar.isleap(year)
查看某年某月日历：calendar.month(year, mouth)
查看某年某月起始星期与当月天数：calendar.monthrange(year, mouth)
查看某年某月某日是星期几：calendar.weekday(year, month, day)
'''
datatime:可以运算的时间
'''
当前时间：datetime.datetime.now()
昨天：datetime.datetime.now() + datetime.timedelta(days=-1)
修改时间：datatime_obj.replace([...])
格式化时间戳：datetime.date.fromtimestamp(timestamp)
'''

```

```python
import time
print(time)

print('暂停开始')
secs=1

time.sleep(secs) #延迟线程的运行
print('暂停结束')

# 重点：时间戳 可以作为数据的唯一标识，是相对于1970-1-1-0：0：0
print(time.time())

# 当前时区时间:东八区（上海时区）
print(time.localtime()) #元组的形式装着多个参数
# 年
print(time.localtime()[0])
print(time.localtime().tm_year)

# 格林威治
print(time.gmtime())

# 可以将时间戳转换为时区的time
print(time.localtime(time.time())) #获取当前时间的转换为格式换时间

#应用场景=》通过时间戳，获取该时间能反映出的年月日等信息
# 5656565653(秒)是哪一年
print(time.localtime(5656565653).tm_year)

#格式化时间
# 格式化的字符串，时间tuple
res=time.strftime('%Y-%m-%d') # 默认当前时间 也就是今年
print(res)
res=time.strftime('%Y-%m-%d %j days') ## 读取的是二进制，所以不能写中文 %j今年的第几天

t=(2020,4,10,10,19,22,2,200,0)
res=time.strftime('%Y-%m-%d %j days',t)# 没有确保数据的安全性，只是将元组信息转化为时间格式的字符串
print(res)

# 需求：输入一个年份，判断其是否是闰年
# 1.能被400整除 year%400==0
#2.能被4整除不能被100整除 year%4==0 and year %100!=0

'''
year=int(input('year:'))
b1=year%400==0
b2=year%4==0 and year%100!=0
if b1 or b2:
print('是闰年')
else:
print('不是闰年')

import calendar # 求闰年
print(calendar.isleap(year))
'''

'''
判断闰年：calendar.isleap(year)
查看某年某月日历：calendar.month(year, month)
查看某年某月起始星期与当月天数：calendar.monthrange(year, month)
查看某年某月某日是星期几：calendar.weekday(year, month, day)
'''
'''
import calendar
print(calendar.month(2019, 4))
print(calendar.monthrange(2019, 4))
print(calendar.weekday(2018, 8, 8))
'''
import calendar

print(calendar.month(2019,4))
print(calendar.monthrange(2019,4))
print(calendar.weekday(2018,8,8))

import datetime
print(datetime.datetime.now())# 默认格式化，有自己的类型，datetime

day=datetime.timedelta(days=1)
print(day,type(day))

# tm与day都是对象，可以直接做运算
tm=datetime.datetime.now()
print(tm-day)

import datetime

tm = datetime.datetime.now()
print(tm, type(tm))

# import time
# print(type(time.time()))

'''
当前时间：datetime.datetime.now()
昨天：datetime.datetime.now() + datetime.timedelta(days=-1)
修改时间：datatime_obj.replace([...])
格式化时间戳：datetime.date.fromtimestamp(timestamp)
'''
# tm是对象，还可以接着调用方法
print(tm.replace(year=2200))

print(datetime.date.fromtimestamp(5656565653))
```

## sys模块

```python
'''
命令行参数List，第一个元素是程序本身路径：sys.argv
退出程序，正常退出时exit(0)：sys.exit(n)
获取Python解释程序的版本信息：sys.version
最大int值：sys.maxsize | sys.maxint
环境变量：sys.path
操作系统平台名称：sys.platform
'''
```

```python
# os.apth有自己的查询机制，操作系统的管理 os为操作系统，sys为系统 os大于sys

import sys
print(sys.argv)
print(sys.path) # *****
# print(sys.exit(0)) # 手动退出程序
print(sys.version)
print(sys.maxsize)
```

## os模块

```python
os:操作系统
'''
生成单级目录：os.mkdir('dirname')
生成多层目录：os.makedirs('dirname1/.../dirnamen2')
重命名：os.rename("oldname","newname")
工作目录：os.getcwd()
删除单层空目录：os.rmdir('dirname')
移除多层空目录：os.removedirs('dirname1/.../dirnamen')
列举目录下所有资源：os.listdir('dirname')
路径分隔符：os.sep
行终止符：os.linesep
文件分隔符：os.pathsep
操作系统名：os.name
操作系统环境变量：os.environ
执行shell脚本：os.system()
'''
os.path:系统路径操作
'''
执行文件的当前路径：__file__
返回path规范化的绝对路径：os.path.abspath(path)
将path分割成目录和文件名二元组返回：os.path.split(path)
上一级目录：os.path.dirname(path)
最后一级名称：os.path.basename(path)
指定路径是否存在：os.path.exists(path)
是否是绝对路径：os.path.isabs(path)
是否是文件：os.path.isfile(path)
是否是路径：os.path.isdir(path)
路径拼接：os.path.join(path1[, path2[, ...]])
最后存取时间：os.path.getatime(path)
最后修改时间：os.path.getmtime(path)
目标大小：os.path.getsize(path)
'''
'''
normcase函数
在Linux和Mac平台上，该函数会原样返回path，在windows平台上会将路径中所有字符转换为小写，并将所有斜杠转换为饭斜杠。
>>> os.path.normcase('c:/windows\system32\')
'c:\windows\system32\'

normpath函数
规范化路径，如..和/
>>> os.path.normpath('c://windows\System32\../Temp/')
'c:\windows\Temp'

>>> a='/Users/jieli/test1/\a1/\\aa.py/../..'
>>> print(os.path.normpath(a))
/Users/jieli/test1
'''
```

```python
import os ## 能创建文件夹

# 生成单级目录：os.mkdir('dirname') # 创建的是文件夹
import os
supper=os.mkdir(r'E:代码part1yaya.py')
print(supper)

import os
os.mkdir('a/b/c') # 确保a,b,两个文件夹存在，创建c文件，c必须不存在
os.makedirs('a/b/c') #全存在，则报错，a,b,存在与否是不一定的

# 生成多层目录：os.makedirs('dirname1/.../dirnamen2')

import os
supper=os.makedirs(r'yayaee') # 默认执行文件目录下创建 yaya中包含子包ee,创建出来的也是文件夹
print(supper)

import os
supper=os.makedirs(r'E:代码代码part1yayaee') # yaya前没加，就变成在指定路径E:代码代码下创个part1yaya包含ee
print(supper)

import os
supper=os.makedirs(r'E:代码代码part1yayaee') # 指定路径E:代码代码下创个yaya包含ee
print(supper)

# 重命名：os.rename("oldname","newname")
import os
os.rename(r'E:代码yayaname.py',"name.py") # 是将旧的文件删除，创建一个新的文件并且重命名，而且会将旧文件下的内容复制过来
# 指定文件夹下的文件重命名，如果新的名字文件没有指定路径，会默认创建文件在执行文件的目录下添加，并且会重命名
os.rename(r'E:代码yayaname.py','name') # 没有表明py文件，所以就会默认txt文件
os.rename(r'yayaname.py','name.py') # 如果没有指定旧名字的Py文件的文件路径，就会报错说找不到
os.rename('__file__','name.py') # 说明在当前文件改名，默认路径也是当前文件
os.rename('E:代码yayaname.py',r'E:代码 ame.py') # 指定路径下创建文件

# 工作目录：os.getcwd() + 路径 （相对，绝对都行，图片文件都行）可以做运算，可以在目录下添加要加入文件夹下的东西

# 删除单层空目录：os.rmdir('dirname')
import os
os.rmdir(r'E:代码代码part1dada')
os.rmdir(r'dada')

# 移除多层空目录：os.removedirs('dirname1/.../dirnamen')
# os.removedirs('a/b/c') # c空，删c，b也变成空，也可以被删除，以此类推，如果b不为空，删除c后就停止操作
# 也就是如果不在执行文件下的目录，要指定删除文件的目录，要写上绝对路径

# 列举目录下所有资源：os.listdir('dirname')
# 获取文件夹目录下的所有文件以及子文件夹，并且是文件的名字而不是路径，并且将其以列表的形式返回
res=os.listdir(r'C:') # 查看C盘下的目录，以列表的形式显示目录
print(res)
# res = os.listdir(r'C:')
# print(res)

# 三者都是手动拼接字符串也就是路径
# 路径分隔符：os.sep
# 行终止符：os.linesep
# 文件分隔符：os.pathsep
# print(os.sep) #
# print(ascii(os.linesep)) #
# print(os.pathsep) # ;
import os
print(ascii(os.linesep)) # 加ascii,不然读不出来，

# 操作系统名：print(os.name) 就是执行文件的操作系统名
# 操作系统环境变量：os.environ
# 执行shell脚本：os.system('ls') windows系统是'dir'获取当前目录的所有文件
# print(sys.platform) 查看当前执行文件的运行平台，注意这是sys模块

import sys
sys.path.clear() # sys.path字典控制包的导入

import os.path as os_path

print(os_path.isdir(r'D:fullstack_s4day17代码part1时间模块.py')) # 判断是否为文件夹
print(os_path.isfile(r'D:fullstack_s4day17代码part1时间模块.py'))
print(os_path.exists(r'D:fullstack_s4day17代码part1时间模块.py'))

print(os_path.isdir(r'D:fullstack_s4day17代码part1'))
print(os_path.isfile(r'D:fullstack_s4day17代码part1'))
print(os_path.exists(r'D:fullstack_s4day17代码part1'))

print(os_path.exists(r'a'))
print(os_path.isabs(r'a'))# 是不是绝对路径
print(os_path.isabs(r'D:fullstack_s4day17代码part1a'))

print(os_path.abspath(r'a')) # 打印绝对路径

# 执行文件的当前路径：__file__
path=os.path.dirname(__file__)
print(path)
# 返回path规范化的绝对路径：os.path.abspath(path)
res=os.path.abspath(r'E:代码a.py')
print(res)

'''
# 将path分割成目录和文件名二元组返回：os.path.split(path) 不管是\ / //Windows都可以识别出来，
# 都可以被切，就是最后一个例子比较特殊，末尾不能写，要写双杆

# ('D:\fullstack_s4\day17\代码\part1', '系统模块.py')
print(os.path.split(r'D:fullstack_s4day17代码part1系统模块.py'))
# ('D:/fullstack_s4/day17/代码/part1', '系统模块.py')
print(os.path.split(r'D:/fullstack_s4/day17/代码/part1/系统模块.py'))
# ('D:/fullstack_s4/day17/代码/part1', '系统模块.py')
print(os.path.split(r'D:fullstack_s4day17代码/part1'))
# ('D:\fullstack_s4\day17\代码/part1', '')
print(os.path.split(r'D:fullstack_s4day17代码part1\'))
'''
# 上一级目录：os.path.dirname(path)
import os
supper=os.path.dirname(r'E:代码代码part1m0.py')
print(supper)
# 结果是E:代码代码part1

# 最后一级名称：os.path.basename(path)
import os
supper=os.path.basename(r'E:代码代码part1m0.py')
print(supper)
# 结果是m0.py

# 指定路径是否存在：os.path.exists(path)

# 是否是绝对路径：os.path.isabs(path) 作为判断条件，返回True,False

# 是否是文件：os.path.isfile(path)

# 是否是路径：os.path.isdir(path)

# 路径拼接：os.path.join(path1[, path2[, ...]])
# 先将项目的根目录设置为常量 -> 项目中的所有目录与文件都应该参照次目录进行导包
BASE_PATH = os_path.dirname(os_path.dirname(__file__))
print(BASE_PATH)
sys.path.append(BASE_PATH)
# 重点：将项目目录添加至环境变量

# 拼接项目中某一文件或文件夹的绝对路径
file_path = os_path.join(BASE_PATH, 'part1', '时间模块.py')
print(file_path)
print(os_path.exists(file_path))

# 最后存取时间：os.path.getatime(path)
# 最后修改时间：os.path.getmtime(path)
print(os.path.getmtime(r'D:fullstack_s4day17代码part1时间模块.py'))
# 目标大小：os.path.getsize(path)
# 辅助上传下载进度
print(os.path.getsize(r'D:fullstack_s4day17代码part1时间模块.py'))

'''
normcase函数
在Linux和Mac平台上，该函数会原样返回path，在windows平台上会将路径中所有字符转换为小写，并将所有斜杠转换为饭斜杠。
>> > os.path.normcase('c:/windows\system32\')
'c:\windows\system32\'

normpath函数
规范化路径，如..和 /
>> > os.path.normpath('c://windows\System32\../Temp/')
'c:\windows\Temp'

>> > a = '/Users/jieli/test1/\a1/\\aa.py/../..'
>> > print(os.path.normpath(a))
/ Users / jieli / test1
'''

import os
def func(path,l=[]):
if not os.path.exists(path):
return []
if os.path.isfile(path):
return[path]
files=os.listdir(path)
for f in files:
file=os.path.join(path,f)
if os.path.isfile(file):
l.append(file)
else:
func(path)
return l

res=func(r'E:代码代码part6')
print(res)

# 重点：
BASE_PATH = os_path.dirname(os_path.dirname(__file__))
sys.path.append(BASE_PATH)
BASE_PATH1 = os_path.normpath(os_path.join(__file__, '..', '..'))
sys.path.append(BASE_PATH1)
```

## 序列化

```python
json:序列化
# json: {} 与 [] 嵌套的数据
# 注：json中的字符串必须全部用""来标识
'''
序列化：对象 => 字符串
序列化成字符串：json.dumps(json_obj)
序列化字符串到文件中：json.dump(json_obj, write_file)

# 注：字符形式操作
反序列化成对象：json.loads(json_str)
从文件读流中反序列化成对象：json.load(read_file)
'''
pickle:序列化
'''
序列化：对象 => 字符串
序列化成字符串：pickle.dumps(obj)
序列化字符串到文件中：pickle.dump(obj, write_bytes_file)

# 注：字节形式操作
反序列化成对象：pickle.loads(bytes_str)
从文件读流中反序列化成对象：pickle.load(read_bytes_file)
'''
```

# 反序列化
json_str = '''{"a": 1, "b": ['1', 2, 3, 4, 5]}'''
json_str = "{'a': 1, 'b': [1, 2, 3, 4, 5]}"
json_str = '''{"a": 1, "b": [1, 2, 3, 4, 5]}'''
new_dic = json.loads(json_str) # json类型的字符串不认''
print(new_dic, type(new_dic))

with open('1', 'r', encoding='utf-8') as r:
res = json.load(r)
print(res)

import pickle
# 可以将任意类型对象与字符串进行转换
dic = {
'a': 1,
'b': [1, 2, 3, 4, 5]
}
res = pickle.dumps(dic)
print(res)

with open('2', 'wb') as w:
pickle.dump(dic, w)

print(pickle.loads(res))
with open('2', 'rb') as r:
print(pickle.load(r))
```