16--常用模块01：time、random、os、sys、shutil

1 time与datetime模块

1.1 三种格式

# 时间模块优先掌握的操作
import time

# 一：time

# 时间分为三种格式：
# 1.时间戳：从1970年到现在经过的秒数  返回的是float类型
    作用：用于时间间隔的计算

print(time.time())


# 2.格式化字符串时间
    作用：用于展示时间，按照某种格式显示的时间：2020-03-30 11:11:11

print(time.strftime('%Y-%m-%d %H:%M:%S %p'))  
print(time.strftime('%Y-%m-%d %X'))  ====》 %X = %H:%M:%S   显示为时分秒

        
# 3.结构化的时间
    # struct_time元组共有9个元素：年月日、时分秒、本周第几天、本年第几天的格式 格式化
    作用：用于单独获取时间的某一部分

res=time.localtime()  
print(res)  
# time.struct_time(tm_year=2021, tm_mon=5, tm_mday=16, tm_hour=22, tm_min=50, tm_sec=16, tm_wday=6, tm_yday=136, tm_isdst=0)

print(res.tm_year)
print(res.tm_yday)


# 二：datetime
import datetime

# 获取当前时间
print(datetime.datetime.now())

# 获取三天后的时间  进行时间的加减
print(datetime.datetime.now() + datetime.timedelta(days=3)) 
print(datetime.datetime.now() + datetime.timedelta(weeks=1)) # 一周后的时间

1.2 时间格式的转换

# 时间模块需要掌握的操作
import time

# 时间格式的转换
转换关系是 时间戳(time)<===>结构化时间(struct_time)<===>格式化字符串形式的时间(strftime)

# 1.时间戳(time)<===>结构化时间(struct_time)

# 结构化时间(struct_time)->时间戳(time)
  time.mktime()
    
s_time=time.localtime()
print(time.mktime(s_time))    

# 时间戳(time)->结构化时间(struct_time)
  time.localtime()
    
tp_time=time.time()
print(time.localtime(tp_time))   


# 补充：世界标准时间与本地时间
print(time.localtime())   # 本地时间
print(time.gmtime())      # 世界标准时间，了解
print(time.localtime(333333333))
print(time.gmtime(333333333))



# 2.结构化时间(struct_time)<===>格式化字符串形式的时间(strftime)

# 结构化时间(struct_time)->格式化字符串时间(strftime)
  time.strftime()
    
s_time=time.localtime()
print(time.strftime('%Y-%m-%d %H:%M:%S',s_time))  

# 格式化字符串时间(strftime)->结构化时间(struct_time)
  time.strptime()
print(time.strptime('1988-03-03 11:11:11','%Y-%m-%d %H:%M:%S')) 



# !!!真正需要掌握的只有一条：字符串时间(format string)<--->时间戳(timestamp)
不能直接转化，必须借助结构化时间

# eg：文件里的时间，再加上7天
  '1988-03-03 11:11:11'+7
  思路：先将字符串时间，转化为结构化时间，再转化为时间戳后进行时间计算，再逆向转换，写入文件

# format string--->struct_time--->timestamp
struct_time=time.strptime('1988-03-03 11:11:11','%Y-%m-%d %H:%M:%S')
timestamp=time.mktime(struct_time)+7*86400

# format string<---struct_time<---timestamp
res=time.strftime('%Y-%m-%d %X',time.localtime(timestamp))
print(res)  #'1988-03-010 11:11:11'

1.3 了解知识

import time

# 程序暂停3秒
time.sleep(3)  

# 字符串时间的另一种格式(linux系统显示)：Sun May 16 23:21:06 2021
print(time.asctime())    


import datetime

# 本地时间
print(datetime.datetime.now()) 
# 国际时间
print(datetime.datetime.utcnow())  
# 将时间戳格式 直接转化成 字符串格式时间  但 固定格式：年月日 时分秒
print(datetime.datetime.fromtimestamp(333333))  

2 random模块

# 随机模块，用来取随机值

# (0,1)--->float  大于0且小于1之间的小数
print(random.random())  

# [1,3]   大于等于1且小于等于3之间的整数  (头尾都能取到)
print(random.randint(1, 3))  

# [1,3)   大于等于1且小于3之间的整数   (取头不取尾)
print(random.randrange(1, 3))  

# 1或者'aaa'或者[4,5]  (从...随机取出一个)
print(random.choice([111, 'aaa', [4, 5]]))  

# 列表元素任意2个组合  (从...随机取出n个)
print(random.sample([111, 'aaa', 'ccc','ddd'],2)) 

# 大于1小于3的小数，如1.927109612082716
print(random.uniform(1, 3))  

# 打乱item的顺序,相当于"洗牌"
item = [1, 3, 5, 7, 9]
random.shuffle(item)  
print(item)

# 应用：随机验证码

# 最好记住 65~90：大写字母  97~122：小写字母  chr(65)=='A'  ord('z')===122

import random

def make_code(size=4):
    res = ''
    for i in range(size):
        s1 = chr(random.randint(65, 90))   # 随机取出一个大写字母
        s2 = str(random.randint(0, 9))
        res += random.choice([s1, s2])
    return res

print(make_code(6))

3 os模块

# os模块 是与操作系统交互的一个接口

import os

# 获取某一个文件夹下所有的子文件以及子文件夹的名字
res=os.listdir('.')   # 获取当前文件下的所有子文件及子目录
print(res)

# 删除一个文件    (不能删除文件夹)
os.remove('文件位置')  

# 重命名文件/目录  (直接将执行程序的环境变量sys.path下的文件/目录，改名)
os.rename("oldname","newname")  

# 执行系统shell命令   (应用程序提交一条系统命令，让操作系统去执行)
os.system("dir ")

# 查看系统环境变量  (规定：key与value必须都为字符串)
print(os.environ)

    # 作用：可将某些整个系统/软件都需要的变量值，都添加进去，这样整个系统都可以使用  
    例如，某些功能必须登录后才能操作，就可以将登录后的用户名与密码加进去，然后退出时就删除。
    跟自己之前实现时一样，我是实现将登录后用户设置成全局变量
    os.environ['aaaaaaaaaa']='111'
    
    # 注意: sys.path 的区别：sys.path 是当前程序的环境变量，
           而os.environ 是整个操作系统的环境变量 

# 获取某个路径下的文件夹路径   (都是文件夹，也是一样的， 就是最后一个斜杠符之前的)
print(os.path.dirname(r'/a/b/c/d.txt'))    ===》'/a/b/c/'
print(os.path.dirname(r'/a/b/c'))    ===》'/a/b'

# 获取某个路径下的文件名字   (就是最后一个斜杠符之后的)
print(os.path.basename(r'/a/b/c/d.txt'))   ===>'d.txt'
print(os.path.basename(r'/a/b/c'))    ===》'c'

# 判断是否是存在的文件
print(os.path.isfile(r'笔记.txt'))  # True
print(os.path.isfile(r'aaa'))      # False  

# 判断是否是存在的文件夹
print(os.path.isdir(r'aaa'))

# 将各个字符串拼接成路径  （若某个字符串是盘符，则以该盘符作为起始位置）
print(os.path.join('a','c:','b','c','d'))   # 'c:b\c\d'

# 获取文件的大小
size=os.path.getsize(r'/Users/linhaifeng/PycharmProjects/s14/day22/01 时间模块.py')
print(size)

# 规范化路径 (按照当前操作系统)
os.path.normpath(r'c/\a/b/c\d')       # 'c\a\b\c\d'
os.path.normpath(r'\210307\day22\03.os模块.py\..\..')  # '\210307'

# 获取项目的路径  (当前执行文件父级的父级 路径)

    # 第一种  (推荐用这种, 兼容python2)
    BASE_DIR=os.path.dirname(os.path.dirname(__file__))
    print(BASE_DIR)

    # 第二种  (将当前执行文件的路径，拼接两个'..'后，规范化路径)
    BASE_DIR=os.path.normpath(os.path.join(__file__,'..', '..'))
    print(BASE_DIR)

    # 第三种  （在python3.5之后，推出了一个新的模块pathlib）
    from pathlib import Path

    res = Path(__file__).parent.parent
    print(res)


# pathlib模块下的Path  (了解)

# 拼接路径
from pathlib import Path
res=Path('/a/b/c', 'd/e.txt')
print(res)    #  '\a\b\c\d\e.txt'

# 规范化路径
print(res.resolve())    'F:\a\b\c\d\e.txt'

4 sys模块

import sys 

# 获取系统执行python文件的参数变量   （是解释器后参数值）
sys.argv   
# 列表形式:第一个参数为 执行程序的路径，后续参数变量是 以执行cmd命令时 空格为分隔符 切割

# 运行cmd命令： 'python run.py 1 2 3'
print(sys.agrv)   # ['run.py', '1', '2', '3']   

# 返回当前执行脚本的 模块搜索路径
sys.path

# 以下了解
sys.exit(n)   # 退出程序，正常退出时exit(0)
sys.version   # 获取Python解释程序的版本信息
sys.maxint    # 最大的Int值
sys.platform  # 返回操作系统平台名称

'\' 转义符

# 知识回顾：'\' 转义符
  # \r 代表回车的意思，即光标会移动到初始的位置
       打印后续的东西就会产生覆盖掉之前的内容的效果
        
  # \n 代表换行的意思
  print('ab\nc\rnihao')  
    ab
    nihao  # c 打印不出来，被\r 覆盖了

# 故：若是不换行打印，且在字符串开头加上'\r',
     就会实现打印的一行覆盖上一行的效果====》用来实现进度条或倒数秒等

    
# 打印进度条
res = ''
for i in range(50):
    res += '#'
    time.sleep(0.5)
    
    # 在同一行开始打印，固定50位，且靠左打印
    print('\r[%-50s]' % res,end='') 
    # 格式是 { :填充的内容(空格) < 填充从右侧开始，50 一共多少位}
	print('\r[{x: <50}]'.format(x=res), end='')  
    # 也可以不写关键字 x ，'\r[{: <50}]'.format(res)


# 打印倒数秒
import time
for i in range(10):
    print('\r倒计时：{}秒'.format(10-i), end='')
    time.sleep(1)
    
    
# 模拟下载+打印进度条
import time

def progress(percent):
    if percent > 1:
        percent = 1
    res = int(50 * percent) * '#'
    print('\r[%-50s] %d%%' % (res, int(100 * percent)), end='')

recv_size=0
total_size=1025011

while recv_size < total_size:
    time.sleep(0.01)  # 下载了1024个字节的数据
    recv_size+=1024  # recv_size=2048
    percent = recv_size / total_size   # 1024 / 333333
    progress(percent)     # 打印进度条    

5 shutil模块（了解）

高级的文件 文件夹 压缩包处理模块
# 主要实现文件的拷贝、移动、压缩与解压的操作等（详见博客，需要使用时，再去了解）

import shutil

# 将文件内容拷贝到另一个文件中
shutil.copyfileobj(fsrc, fdst[, length])

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


# 拷贝文件
shutil.copyfile(src, dst)

shutil.copyfile('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')


# 递归的去移动文件，它类似mv命令，其实就是重命名。
shutil.move(src, dst)

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


# 打包(创建压缩包) 并返回文件路径，例如：zip、tar
shutil.make_archive(base_name, format,...)

ret = shutil.make_archive("/tmp/data_bak", 'gztar', root_dir='/data')


# shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：见6

6 tarfile 压缩解压缩

import tarfile

# 压缩
t=tarfile.open('/tmp/egon.tar','w')
t.add('/test1/a.py',arcname='a.bak')
t.add('/test1/b.py',arcname='b.bak')
t.close()


# 解压
t=tarfile.open('/tmp/egon.tar','r')
t.extractall('/egon')   # extract n. 提取
t.close()