常用模块-- time os sys 递归 序列化

time：时间

时间戳(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 当前时区的名称
%% %号本身

# 重点：时间戳 -> 可以作为数据的唯一标识 是相对于1970-1-1-0:0:0 时间插值
------------------time.time()--------------------
import time
print(time)  #<module 'time' (built-in)>
print(time.time())   #1554879042.493756（至2019.4.10的秒数，精确到秒后6位小数）

#将时间戳转化为时区
------------------time.localtime()--------------------
print(time.localtime(1554879042).tm_year)  #2019
print(time.localtime(1554879042))  
print(time.localtime(time.time()))  #time.struct_time(tm_year=2019, tm_mon=4, tm_mday=10, tm_hour=15, tm_min=4, tm_sec=29, tm_wday=2, tm_yday=100, tm_isdst=0)

print(time.localtime()) #当前时区时间：东八区（上海时区）time.struct_time(tm_year=2019, tm_mon=4, tm_mday=10, tm_hour=14, tm_min=55, tm_sec=7, tm_wday=2, tm_yday=100, tm_isdst=0)
print(time.localtime()[0])           #2019
print(time.localtime().tm_year)  #2019

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

# 格式化时间
# 格式化的字符串，时间tuple
------------------time.strftime()--------------------
res = time.strftime('%Y-%m-%d %j days')
print(res) #2019-04-10 100 days 只支持ASCII，即英文、特殊符号

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

 

calendar：日历

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

# 需求：输入一个年份，判断其是否是闰年
# 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(2018))
>>>False

import calendar

print(calendar.month(2019,4))
print(calendar.monthrange(2019,4))
print(calendar.weekday(2019,4,10))
--------------------------------------------
     April 2019
Mo Tu We Th Fr Sa Su
 1  2  3  4  5  6  7
 8  9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30

(0, 30)

2

#周一：0

 

datatime：可以运算的时间

当前时间：datetime.datetime.now()
昨天：datetime.datetime.now() + datetime.timedelta(days=-1)
修改时间：datatime_obj.replace([...])
格式化时间戳：datetime.date.fromtimestamp(timestamp)

tm = datetime.datetime.now()+ datetime.timedelta(days=-1)
print(tm) #datetime <class 'datetime.datetime'> 2019-04-10 16:07:31.071055

day = datetime.timedelta(days=1)
print(day, type(day))  # 1 day, 0:00:00 <class 'datetime.timedelta'>

# tm与day都是对象，可以直接做运算
print(tm - day)  #2019-04-09 16:03:57.318889

# tm是对象，还可以接着调用方法
print(tm.replace(year=2200))  #2200-04-09 16:03:57.318889

print(datetime.date.fromtimestamp(5656565653)) #2149-04-01
----------------------------------------------------------

 

模块time、calendar、datetime的对比：

import time
tm_t=time.time()
print('time',type(tm_t),tm_t)

import calendar
tm_c=calendar.calendar(2019)
print('calendar',type(tm_c), tm_c)

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

-----------------------------------------------
time.time() <class 'float'> 1554882569.767177

calendar.calendar(2019) <class 'str'>  2019日历表

datetime.datetime.now() <class 'datetime.datetime'> 2019-04-10 15:49:29.781145

 

 sys：系统

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

import sys

print(sys.argv)  # ['当前文件的绝对路径']*****
# print(sys.exit(0))  # 手动退出程序
print(sys.version) # 版本
print(sys.maxsize) # 9223372036854775807
a=922337203685477580712345
print(a,type(a))
print(sys.platform) # win32

import sys 
sys.path.clear()  # sys.path字典（环境变量目录）控制包的导入

 

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()

print(os.getcwd())  # 当前工作目录
print(__file__)  # 当前工作的文件的绝对路径
os.mkdir('aaa')  # 不存在创建，存在抛异常
os.rename("111","222")  # 重名名
os.remove('222')  # 删除文件
os.rmdir(r'D:\fullstack_s4\day17\代码\part1\bbb')  # 删除文件夹

os.rmdir('aaa/bbb')
os.remove('aaa/bbb.py')
os.rmdir('aaa')

os.mkdir('a/b/c')  # a,b必须存在，c必须不存在
os.makedirs('a/b/c')  # 全存在，则报错，a，b存在与否不是一定的

os.removedirs('a/b/c')  # c空，删c，b也变成空，也可以被删除，以此类推，如果b不为空，删除c后就停止操作

print(os.sep)  # \
print(ascii(os.linesep))  # \r\n
print(os.pathsep)  # ;

print(os.system('dir')) #执行括号内的命令

res = os.listdir(r'C:')
print(res) #输出该盘下的文件目录，包括隐藏文件目录

 

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)

----------------目录和文件名二元组返回：os.path.split(path)--------------------
import os.path
print(os.path.split(r'D:\\fullstack_s4\\day17\\代码\\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_s4/day17/代码/part1/系统模块.py'))      # ('D:/fullstack_s4/day17/代码/part1', '系统模块.py')
print(os.path.split(r'D:\fullstack_s4\day17\代码\part1'))                 # ('D:\\fullstack_s4\\day17\\代码', 'part1')
print(os.path.split(r'D:\fullstack_s4\day17\代码\part1\\'))               # ('D:\\fullstack_s4\\day17\\代码\\part1', '')


----------------------最后一级名称，上一级目录，路径拼接---------------------
print(os.path.basename(r'D:\fullstack_s4\day17\代码\part1\a\b'))                # b
print(os.path.dirname(os.path.dirname(r'D:\fullstack_s4\day17\代码\part1\a\b')))# D:\fullstack_s4\day17\代码\part1
print(os.path.dirname(r'D:\fullstack_s4\day17\代码\part1\a\b'))                 # D:\fullstack_s4\day17\代码\part1\a
print(os.path.join(r'D:\fullstack_s4\day17\代码\part1','a','b'))                # D:\fullstack_s4\day17\代码\part1\a\b

 

将项目目录添加至环境变量*****

 

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

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

print(os.path.getmtime(r'D:\fullstack_s4\day17\代码\part1\时间模块.py'))

# 辅助上传下载进度
print(os.path.getsize(r'D:\fullstack_s4\day17\代码\part1\时间模块.py'))


print(os.path.normcase('c:/windows\\system32\\'))
# 通过normcase来添加项目根目录到环境变量
BASE_PATH1 = os.path.normpath(os.path.join(__file__, '..', '..'))
sys.path.append(BASE_PATH1)


# 重点：
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)

 

递归遍历

import os
def ls(path,files=[]):
    if not os.path.exists(path):  # 指定路径 存在？
        return []                 # × 返回[]
    if os.path.isfile(path):      # 文件 ？
        return [path]             # ✔ [文件路径]
    file_list=os.listdir(path)    # 列举目录下的所有资源  => 资源列表file_list
    for v in file_list:           # 遍历
        file_path=os.path.join(path,v)  # 路径拼接 => 绝对路径
        if os.path.isfile(file_path):   # 文件？
            files.append(file_path)     # ✔ 加入files
        else:
            ls(file_path)               # × 将路径重新作为函数参数，再执行函数
    return files

res=ls(r'D:\fullstack_s4\day17\代码\part1\pk')  #指定文件夹，查找其下及子文件夹的文件
print(res)  #返回文件列表

 

json：序列化

json: {} 与 [] 嵌套形成的数据（python中建议数据从{}开始）

序列化: 将python的字典转化为字符串传递给其他语言或保存

注：json中的字符串必须全部用""来标识

dic = {
    'a': 1,
    'b': [1, 2, 3, 4, 5]
}
json_str = json.dumps(dic)
print(json_str)     #'{"a": 1, "b": [1, 2, 3, 5, 7]}'

with open('1', 'w', encoding='utf-8') as w:
    json.dump(dic, w)  # 先将dic对象转化为字符串，再写入文件
    # w.write(dic)


# 反序列化
json_str1 = '''{"a": 1, "b": ['1', 2, 3, 4, 5]}'''  #×  json内部的字符只能用双引号
json_str2 = "{'a': 1, 'b': [1, 2, 3, 4, 5]}"      #×  json内部的字符只能用双引号
json_str = '''{"a": 1, "b": [1, 2, 3, 4, 5]}'''
new_dic = json.loads(json_str)  ①  # json类型的字符串不认''
new_dic=eval(json_str)          ②  
print(new_dic, type(new_dic))

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


????读入读出文件json.dump() json.load()   直接操作字符串json.dumps()   json.loads()  

 

pickle：序列化

可以将任意类型对象与字符串进行转换

序列化：对象 => 字符串
序列化成字符串：pickle.dumps(obj)
序列化字符串到文件中：pickle.dump(obj, write_bytes_file)

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

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))