下面我们来讲一些内置的模块，即不需要下载就可以使用的模块

一、sys

import sys
print(sys.argv[1])   #这的1就像shell 的$1
-----------
执行了这个脚本的时候就会看到结果

In [3]: sys.version                                                      
Out[3]: '3.7.6 (default, Dec 31 2019, 14:50:39) \n[GCC 4.8.5 20150623 (Red Hat 4.8.5-39)]'

In [4]: sys.version_info          #输出的更加的仔细易读                                          
Out[4]: sys.version_info(major=3, minor=7, micro=6, releaselevel='final', serial=0)

二、os

1.关于目录的一些操作

注意，那个递归的查找目录的方法具体应用如下
In [45]: a,b,c= os.walk('/tmp/a')

In [46]: a,b,c
Out[46]:
(('/tmp/a', ['b'], []),
('/tmp/a/b', ['f'], ['work.txt']),
('/tmp/a/b/f', [], []))

练习：
1. 在 /tmp 目录下，创建目录  a/b/c
In [12]: os.makedirs("/tmp/a/b/c")    

In [14]: !ls /tmp/a/b                                                   
c
-------------------------------------
2.进入到 /tmp/a/b 目录下，创建一个目录 f
In [14]: !ls /tmp/a/b                                                   
c

In [15]: os.chdir("/tmp/a/b")                                           

In [16]: os.getcwd()                                                    
Out[16]: '/tmp/a/b'

In [17]: os.mkdir("f")                                                  

In [18]: !ls                                                            
c  f
-----------------------------------
3.把当前的工作目录写到 f 目录下的 work.txt 文件内。
In [22]: f_obj=open("work.txt",'w',encoding="utf-8")                    

In [23]: f_obj.write('{}'.format(os.getcwd()))                          
Out[23]: 8

In [24]: f_obj.close()                                                  

In [25]: !cat work.txt                                                  
/tmp/a/b
-----------------------------------
4.删除目录 c
In [26]: os.rmdir("/tmp/a/b/c")                                         

In [27]: !ls                                                            
f  work.txt
----------------------------------
5.把 /tmp 目录下及其子目录下的所有文件和目录打印到屏幕上
root，dir，file=
In [45]: for root,dir,file in os.walk('/tmp')
               print(root ，dir，file)                                       

2.对路径的判断

os.path.exists("路径")
如果path存在，返回True；如果path不存在，返回False 在这里值得注意的是

import os
os.path.exists("/etc/passwd")               
#判断路径是否存在
print(os.path.exists("/etc/passwd"))
print(os.path.exists("etc/passwd"))#没有写全
#在Linux shell 中，Python会认为： / 左边一定是一个目录，而不是文件
[root@localhost python_learning]# /usr/local/bin/python3 /root/python_learning/内置模块.py
True
False

os.path.isdir("路径"）
如果path是一个存在的目录，则返回True。否则返回False
os.path.isfile("path")
如果path是一个存在的文件，返回True。否则返回False

In [59]: os.path.isfile("/etc/my.cnf.d/")      
Out[59]: False

In [60]: os.path.isdir("/etc/my.cnf.d/")       
Out[60]: True

os.rename("old_name", "new_name")
重命名文件名或目录名

os.path.split("path")
将 path 分割成目录和文件名二元组返回
os.path.abspath("path")
返回 文件 或 path 规范化的绝对路径

import os
os.path.split("/etc/nginx/nginx.conf")
print(os.path.split("/etc/nginx/nginx.conf"))            
#不管这个文件是否存在，只进行切割,以右边的第一个/切割，左边为目录，右边为文件
print(os.path.abspath("/path/to/file"))
#查找文件的绝对路径，然而只是一个简单的拼接过程，不管你输入的文件是否存在
print(os.path.abspath("./file"))
print(os.path.abspath("~/file"))
#只要识别到了/左边有东西就会拼接到当前目录
print(os.path.abspath("bathe/file"))
--------
[root@localhost python_learning]# /usr/local/bin/python3 /root/python_learning/内置模块.py
('/etc/nginx', 'nginx.conf')
/path/to/file
/root/python_learning/file
/root/python_learning/~/file
/root/python_learning/bathe/file

os.path.dirname(path)
以 最右侧的路径分隔符为分界符把路径分隔为两部分， 返回第一部分，就是目录部分。
不关心路径是否真实存在与系统中

print(os.path.dirname("/path/dii"))
print(os.path.dirname("path/database"))
#只会识别到从右边数第一个/并且把/和它右边的去掉
------------
/path
path

os.path.join(path1[, path2[, ...]])
将多个路径组合后返回，每个路径之间不需要加路径分隔符(\或者/)

>>> os.path.join('/home', 'tom', 'bin')
'/home/tom/bin'
>>> os.path.join('/home', '/tom', 'bin')
'/tom/bin'
>>>

三、时间模块

1.time模块

结构化的时间(struct_time)：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，当月中第几周，一年中第几天，夏令时)

time()
-----
In [80]: import time                           

In [81]: time.time()                           
Out[81]: 1578315529.3293629
*************************************
sleep
-----
In [82]: time.sleep(2)                         
*************************************
ctime
-----
In [83]: time.ctime(1845878)                   
Out[83]: 'Thu Jan 22 16:44:38 1970'
**************************
localtime
-----
In [84]: time.localtime()                      
Out[84]: time.struct_time(tm_year=2020, tm_mon=1, tm_mday=6, tm_hour=20, tm_min=59, tm_sec=46, tm_wday=0, tm_yday=6, tm_isdst=0)

属性                            值
tm_year（年）                  比如2011 
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（是否是夏令时）        默认为 0
*************************
strftime把时间格式化
-----
In [85]: time.strftime("%Y-%m-%d %X")          
Out[85]: '2020-01-06 21:03:11'

In [86]: time.strftime("%F %T")                
Out[86]: '2020-01-06 21:03:22'

In [87]:  time.strftime("%H%M%S")              
Out[87]: '210340'

image.png

>>> import time
>>> time.time()
1576917412.379858
 
# 时间戳转换为结构化时间
>>> time.localtime(1576917412.379858)
time.struct_time(tm_year=2019, tm_mon=12, tm_mday=21, tm_hour=16, tm_min=36, tm_sec=52, tm_wday=5, tm_yday=355, tm_isdst=0)
>>>
    
# 将 结构化时间或者时间戳转换为 格式化后的字符串时间
>>> time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(1576917412.379858))
'2019-12-21 16:36:52'
>>>

# 将 字符串时间转换为结构化时间
>>> time.strptime('2019-12-21 16:36:52', '%Y-%m-%d %H:%M:%S')
time.struct_time(tm_year=2019, tm_mon=12, tm_mday=21, tm_hour=16, tm_min=36, tm_sec=52, tm_wday=5, tm_yday=355, tm_isdst=-1)
>>>

# 将 指定的字符串时间转换为时间戳
>>> time.mktime(time.strptime('2019-12-21 16:36:52', '%Y-%m-%d %H:%M:%S'))
1576917412.0

2.datetime模块

2.1datatime.datetime

设计一个定时

nowtime = datetime.datetime.now()
restime = datetime.datetime.strptime("2019-09-05 12:00:00",'%Y-%m-%d %H:%M:%S')
restime - nowtime
t = restime - nowtime
print(str(t))

t.days

h,s = divmod(t.seconds, 3600)
m,s =divmod(s,60)

f"{t.days}天{h}小时{m}分{s}秒"

divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。

那么可以得到交互式是定时

import datetime

def handle_seconds(second):
    t = datetime.timedelta(seconds=second)

    # 计算多少小时，多少秒
    # 一个小时 3600 秒，这里divmod 内置函数取商数和余数
    h,s = divmod(t.seconds, 3600)

    # 计算多少分钟和多少秒
    m,s =divmod(s,60)

    if t.days > 0 :
        tpl = "{days}天{h}小时{m}分{s}秒"
        msg = tpl.format(days=t.days, h=h, m=m, s=s)
    elif t.days == 0 and h > 0:
        tpl = "{h}小时{m}分{s}秒"
        msg = tpl.format(h=h, m=m, s=s)
    elif h == 0 and m > 0:
        tpl = "{m}分{s}秒"
        msg = tpl.format(m=m, s=s)
    elif m == 0 and s > 0:
        tpl = "{s}秒"
        msg = tpl.format(s=s)
    else:
        msg = "刚刚"
    print(msg)

2.2datetime.timedelta

Python datetime之timedelta
该函数表示两个时间的间隔
参数可选、默认值都为0：datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

比如要输出当前时间一小时之后的时间：

from datetime import datetime,timedelta

time1 = datetime.now()

print time1
print time1.strftime("%y-%m-%d %H:%M:%S")
print (time1+timedelta(hours =1)).strftime("%y-%m-%d %H:%M:%S")
输出的时间比上面的的那个少了1小时

四、压缩打包模块shutil模块

文件 文件夹 压缩包 处理模块
1.copyfile('被拷贝的文件','拷贝的文件')
拷贝文件的内容到另一个文件中，参数是文件的相对路径或者绝对路径

import shutil
shutil.copyfile('./src.file','./dst.file')

2.copy2('被拷贝的文件','拷贝的文件')
拷贝文件和权限
3.copytree(src, dst, symlinks=False, ignore=None)
递归的去拷贝文件夹

ignore=shutil.ignore_patterns('排除的文件名', '排除的文件夹名') 支持通配符，假如有多个用逗号隔开
shutil.ignore_patterns(*patterns) 忽略某些文件

shutil.copytree('/home','/tmp/hbak',
                ignore=shutil.ignore_patterns('*.txt'))
# 递归拷贝一个文件夹下的所有内容到另一个目录下，目标目录应该是原来系统中不存在的

4.shutil.rmtree('/tmp/hb')
递归删除一个文件夹下的所有内容

# 最后结尾的一定是明确的文件名，不可以类似下面这样
shutil.rmtree('/tmp/hbak/*')

5.shutil.move('/home/src.file', './shark')
递归的去移动文件，它类似mv命令。

6.shutil.make_archive('shark', # 压缩后文件名 'gztar', # 指定的压缩格式 '/home/shark/') # 被压缩的文件夹名字

# 将 /home/shark 目录下的所以文件打包压缩到 /tmp 目录下，名字shark,格式 tar
shutil.make_archive( '/tmp/shark','tar','/home/shark/')

# 查看当前 python 环境下支持的压缩格式
ret = shutil.get_archive_formats()
print(ret)

7.shutil.unpack_archive('./a/b.tar.gz' #解压的文件名 , './a/c/' #解压到哪个路径下,'gztar' #压缩的格式)
解压缩

五、subprocess

subprocess 是开启一个系统基本的单个进程，执行 shell 命令,可以得到命令的执行结果。

In [21]: subprocess.getoutput('ls')                                                            
Out[21]: 'bin\ncreate.py\nlib\npackage\npage\n__pycache__\nPython-3.7.3\nPython-3.7.3.tgz\ntest.py\ntests.py\n参数.py\n操作redis.py\n调试mysql.py\n调试代码.py\n内置模块.py'

In [22]: ret = subprocess.getstatusoutput('ls')                                                

In [23]: ret = subprocess.getstatusoutput('date -u')            
#可以看看有没有执行成功，                                

In [24]: ret                                                                                   
Out[24]: (0, '2020年 01月 06日 星期一 06:28:44 UTC')
#执行成功会在前面有一个$?的返回