时间、文件、系统、序列化模块

一、在python中，通常有这几种方式来表示时间：

• 时间戳

• 格式化的时间字符串

• 元祖（struct_time）共九个元素。由于Python的time模块实现主要调用C库，所以每个平台可能有所不同。

二、几个定义

　　UTC（Coordinated Universal Time，世界协调时）亦即格林威治天文时间，世界标准时间。在中国为UTC+8。DST（Daylight Saving Time）即夏令时。

　　时间戳（timestamp）的方式：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移值。我们运行type（time.time()）,返回的是float类型。

　　元祖（struct_time）方式：struct_time元祖共有9个元素，返回struct_time的函数主要有gmtime(),localtime(),strptime()。下面列出这种方式元祖中的几个元素：

属性                            值
tm_year（年）                  比如2019 
tm_mon（月）                   1 - 12
tm_mday（日）                  1 - 31
tm_hour（时）                  0 - 23
tm_min（分）                   0 - 59
tm_sec（秒）                   0 - 61
tm_wday（weekday）             0 - 6（0表示周日）
tm_yday（一年中的第几天）        1 - 366
tm_isdst（是否是夏令时）        默认为-1

一、time模块的方法

time.localtime( [secs] )
将一个时间戳转换为当前时区的struct_time，即时间数组格式的时间
参数：

sec – 转换为time.struct_time类型的对象的秒数
如果secs参数未提供，则以当前时间为准（即会默认调用time.time()）。

>>> import time
>>> time.localtime()
time.struct_time(tm_year=2019, tm_mon=1, tm_mday=23, tm_hour=10, tm_min=31, tm_sec=21, tm_wday=2, tm_yday=23, tm_isdst=0)

time.gmtime([secs])
将一个时间戳转换为UTC时区的struct_time
time.gmtime() 函数将一个时间戳转换为UTC时区（0时区）的struct_time，可选的参数sec表示从1970-1-1 00:00:00以来的秒数。其默认值为time.time()，函数返回time.struct_time类型的对象。（struct_time是在time模块中定义的表示时间的对象）。
如果secs参数未提供，则以当前时间为准。
参数：

sec – 转换为time.struct_time类型的对象的秒数

>>> time.gmtime()
time.struct_time(tm_year=2019, tm_mon=1, tm_mday=23, tm_hour=2, tm_min=34, tm_sec=6, tm_wday=2, tm_yday=23, tm_isdst=0)
>>>

time.time()

返回当前时间的时间戳

>>> time.time()
1548210925.5266087

time.mktime(t)

将一个struct_time转化为时间戳
time.mktime() 函数执行与gmtime(), localtime()相反的操作，它接收struct_time对象作为参数,返回用秒数表示时间的浮点数。
如果输入的值不是一个合法的时间，将触发 OverflowError 或 ValueError。
参数：

t – 结构化的时间或者完整的9位元组元素

>>> time.mktime(time.localtime())
1548211010.0

time.sleep(secs)

线程推迟指定的时间运行 
线程睡眠指定时间，单位为妙。

>>> time.sleep(2)  # 睡眠2秒

time.asctime( [t] )
把一个表示时间的元组或者struct_time表示为 ‘Sun Aug 23 14:31:59 2015’ 这种形式。如果没有给参数，会将time.localtime()作为参数传入。
参数：

t – 9个元素的元组或者通过函数 gmtime() 或 localtime() 返回的时间值

>>> time.asctime()
'Wed Jan 23 10:39:47 2019'

time.ctime([secs])
把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果为指定参数，将会默认使用time.time()作为参数。它的作用相当于time.asctime(time.localtime(secs))
参数：

sec – 要转换为字符串时间的秒数

>>> time.ctime()
'Wed Jan 23 10:41:58 2019'

time.strftime( format [, t] )
返回字符串表示的当地时间。
把一个代表时间的元组或者struct_time（如由time.localtime()和time.gmtime()返回）转化为格式化的时间字符串，格式由参数fORMat决定。如果未指定，将传入time.localtime()。如果元组中任何一个元素越界，就会抛出ValueError的异常。函数返回的是一个可读表示的本地时间的字符串。
参数：

format：格式化字符串
t ：可选的参数是一个struct_time对象
时间字符串支持的格式符号：（区分大小写）

%a  本地星期名称的简写（如星期四为Thu）      
%A  本地星期名称的全称（如星期四为Thursday）      
%b  本地月份名称的简写（如八月份为agu）    
%B  本地月份名称的全称（如八月份为august）       
%c  本地相应的日期和时间的字符串表示（如：15/08/27 10:20:06）       
%d  一个月中的第几天（01 - 31）  
%f  微秒（范围0.999999）    
%H  一天中的第几个小时（24小时制，00 - 23）       
%I  第几个小时（12小时制，0 - 11）       
%j  一年中的第几天（001 - 366）     
%m  月份（01 - 12）    
%M  分钟数（00 - 59）       
%p  本地am或者pm的相应符      
%S  秒（00 - 61）    
%U  一年中的星期数。（00 - 53星期天是一个星期的开始。）第一个星期天之    前的所有天数都放在第0周。     
%w  一个星期中的第几天（0 - 6，0是星期天）    
%W  和%U基本相同，不同的是%W以星期一为一个星期的开始。    
%x  本地相应日期字符串（如15/08/01）     
%X  本地相应时间字符串（如08:08:10）     
%y  去掉世纪的年份（00 - 99）两个数字表示的年份       
%Y  完整的年份（4个数字表示年份）
%z  与UTC时间的间隔（如果是本地时间，返回空字符串）
%Z  时区的名字（如果是本地时间，返回空字符串）       
%%  ‘%’字符  

time.strptime(string[,format])
将格式字符串转化成struct_time.
该函数是time.strftime()函数的逆操作。time strptime() 函数根据指定的格式把一个时间字符串解析为时间元组。所以函数返回的是struct_time对象。
参数：

string ：时间字符串
format：格式化字符串

注意在使用strptime()函数将一个指定格式的时间字符串转化成元组时，参数format的格式必须和string的格式保持一致，如果string中日期间使用“-”分隔，format中也必须使用“-”分隔，时间中使用冒号“:”分隔，后面也必须使用冒号分隔，否则会报格式不匹配的错误。

时间格式转换图：

 

二、datetime模块

• datetime模块定义了下面几个类：

• datetime.date：表示日期的类。常用的属性有year，month，day；

• datetime.time：表示时间的类。常用的属性有hour，minute，second，microsecond；

• datetime.datetime：表示日期时间。

• datetime.timedelta：表示时间间隔，即两个时间点之间的长度；

• datetime.tzinfo：与时区有关的信息。

需要记住的方法：

1. d = datetime.datetime.now() 返回当前的datetime日期类型

   • 　　d.timestamp(),d.today,d.year,d.timetuple()等方法可以调用

2. datetime.date.fromtimestamp() 把一个时间戳转为datetime日期类型

3. 时间运算

>>> datetime.datetime.now()
datetime.datetime(2019, 1, 23, 11, 3, 42, 125406)
>>> datetime.datetime.now() + datetime.timedelta(4)  # 当前时间+4天
datetime.datetime(2019, 1, 27, 11, 4, 18, 791478)
>>> datetime.datetime.now() + datetime.timedelta(hours=4)  # 当前时间+4小时
datetime.datetime(2019, 1, 23, 15, 4, 52, 988594)

　　4. 时间替换

>>> d.replace(year=1994,month=11,day=12)
datetime.datetime(1994, 11, 12, 11, 0, 27, 749344)

 

三、random模块

>>> random.randrange(0,100,2)  # 随机选取 0到100间的偶数
64
>>> random.random()  # 返回一个随机浮点数
0.2246826615173001
>>> random.choice('abc123#$%')  # 返回一个给定数据集合中的随机字符
'1'
>>> random.sample('abcdefg',3)  # 从多个字符中选取特定数量的字符
['g', 'd', 'f']
>>>
>>> # 生成随机字符串
... import string
>>> ''.join(random.sample(string.ascii_lowercase+string.digits,6))
'kwcsq4'
>>>
>>> # 洗牌
... a = [1,2,3,4,5,6,7,8,9]
>>> random.shuffle(a)
>>> a
[8, 5, 1, 6, 9, 7, 3, 4, 2]

 

四、os模块

 

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息
os.sep    输出操作系统特定的路径分隔符，win下为"\\",linux下为"/"
os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令，直接显示
os.popen("bash command)  运行shell命令，获取执行结果
os.environ  获取系统环境变量


os.path
os.path.abspath(path) 返回path规范化的绝对路径
os.path.split(path) 将path分割成目录和文件名二元组返回 os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素 
os.path.basename(path) 返回path最后的文件名。如path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)  如果path是绝对路径，返回True
os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小

 

os.stat('path\filename') 获取文件\目录信息的结构说明

stat 结构:
 
st_mode: inode 保护模式
st_ino: inode 节点号。
st_dev: inode 驻留的设备。
st_nlink: inode 的链接数。
st_uid: 所有者的用户ID。
st_gid: 所有者的组ID。
st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。
st_atime: 上次访问的时间。
st_mtime: 最后一次修改的时间。
st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，<br>在其它系统上（如windows）是创建时间（详细信息参见平台的文档）。

 

五、sys模块

import sys

sys.argv  # 命令行参数List，第一个元素是程序本身路径
sys.exit(n)  # 退出程序，正常退出时exit(0)
sys.version  # 获取Python解释程序的版本信息
sys.maxint  # 最大的Int值
sys.path  # 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform  # 返回操作系统平台名称
sys.stdout.write('please:')  # 标准输出，引出进度条的例子。注：在py3上不行，可以用print代替
val = sys.stdin.readline()[:-1]  # 标准输入
sys.getrecursionlimit()  # 获取最大递归层数
sys.setrecursionlimit(1200)  # 设置最大递归层数
sys.getdefaultencoding()  # 获取解释器默认编码
sys.getfilesystemencoding  # 获取内存数据存到文件里的默认编码

 

六、shutil模块

 高级的文件、文件夹、压缩包 处理模块

shutil.copyfileobj(fsrc,fdst[,length])

将文件内容拷贝到另一个文件中

import shutil
shutil.copyfileobj(open('old.xml','r'), open('new.xml','w'))

shutil.copyfile(src,dst)

拷贝文件

shutil.copyfile('f1.log','f2.log')  # 目标文件无需存在

shutil.copymode(src,dst)

仅拷贝权限。内容、组、用户均不变

shutil.copymode('f1.log','f2.log')  # 目标文件必须存在

shutil.copystat(src,dst)

仅拷贝状态的信息，包括：mode bits,atime,mtime,flags

shutil.copystat('f1.log','f2.log')  # 目标文件必须存在

shutil.copy(src,dst)

拷贝文件和权限

shutil.copy('f1.log','f2.log')

shutil.copy2(src,dst)

拷贝文件和状态信息

shutil.copy2('f1.log','f2.log')

shutil.ignore_patterns(*patterns)
shutil.copytree(src,dst,symlinks=False,ignore=None)

递归的去拷贝文件夹

shutil.copytree('folder1','folder2',ignore=shutil.ignore_patterns('*.pyc','tmp*'))  # 目标目录不能存在，注意对folder2目录父级目录要有可写权限，ignore的意思是排除

shutil.rmtree(path[,ignore_errors=[,onerror]])

递归的去删除文件

shutil.rmtree('folder1')

shutil.move(src,dst)

递归的去移动文件，它类似mv命令，其实就是重命名。

shutil.move('folder1','folder3')

shutil.make_archive(base_name,format,...)

创建压缩包并返回文件路径，例如：zip，tar

• base_name:压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径。如data_bak=>保存至当前路径；如/tmp/data_bak=>保存到/tmp/

• format:压缩包种类，“zip”,"tar","bztar","gztar"

• root_dir:要压缩的文件夹路径（默认当前目录）

• owner:用户，默认当前用户

• group：组，默认当前组

• logger：用于记录日志，通常的loggin.Logger对象

# 将/data 下的文件打包放置当前程序目录
ret = shutil.make_arcHive('data_bak','gztar',root_dir='/data')

# 将/data下的文件打包放置/tmp/目录
ret = shutil.make_archive('/tmp/data_bak','gztar',root_dir='/data')

shutil对压缩包的处理是调用ZipFile和TarFile两个模块来进行的

# zipfile压缩和解压缩
import zipfile
# 压缩
z = zipfile.ZipFile('aaa.zip','w')
z.write('bbb.log')
z.write('data.data')
z.close()

# 解压缩
z = zipfile.ZipFile('aaa.zip','r')
z.extractall(path='.')
z.close()

 

# tarfile压缩和解压缩
import tarfile
# 压缩
t = tarfile.open('/tmp/aaa.tar','w')
t.add('/test/a.py',arcname='a.bak')
t.add('/test/b.py',arcname='b.bak')
t.close()

# 解压缩
t = tarfile.open('/tmp/aaa.tar','r')
t.extractall('/test')
t.close()

 

七、JSON&pickle模块

什么叫序列化？序列化是指把内存里的数据类型转变成字符串，以使其能存储到硬盘或通过网络传输到远程，因为硬盘或网络传输时只能接受bytes。

用于序列化的两个模块

• json，用于字符串和python数据类型间进行转换

• pickle，用于python特有的类型和python的数据类型间进行转换

Json模块提供四个模块;dumps,dump,loads,load

pickle模块提供四个模块;dumps,dump,loads,load

import pickle
data = {'k1':123,'k2':'hello'}
# pickle.dumps 将数据通过特殊的形式转换为只有python语言认识的字符串
p_str = pickle.dumps(data)
print(p_str)
# pickle.dump 将数据通过特殊的形式转换为只有python语言认识的字符串,并写入文件
with open('test','w') as fp:
    pickle.dumps(data,fp)
    
import json
# json.dumps 将数据通过特殊的形式转换为所有程序语言认识的字符串
j_str = json.dumps(data)
print(j_str)
# json.dump 将数据通过特殊的形式转换为所有程序语言认识的字符串,并写入文件
with open('test','w') as fp:
    json.dump(data,fp)

json vs pickle:

　　JSON:

　　优点：跨语言，体积小

　　缺点：只能支持int/str/list/tuple/dict

　　Pickle:

　　优点：专为python设计，支持python所有的数据类型

　　缺点：只能在python中使用，存储数据占空间大

 

八、shelve模块

shelve模块是一个简单的k，v将内存数据通过文件持久化的模块，可以持久化任何pickle可支持的python数据格式。

序列化：

import shelve
f = shelve.open('shelve_test')  # 打开一个文件
names = ['悟空','八戒','沙僧']
info = {'name':'悟空','age':999}
f['name'] = names
f['info_dic'] = info
f.close()

反序列化：

import shelve
d = shelve.open('shelve_test')  # 打开一个文件
print(d['names'])
print(d['info_dic'])
# del d['test']   # 还可以删除

 

原文：https://blog.csdn.net/SeeTheWorld518/article/details/48314501 

 　　Https://www.cnblogs.com/tkqasn/p/6001134.html