python 模块基础 和常用的模块

模块的基础

模块的定义

一个模块就是以.py结尾的python 文件，用来从逻辑上组织python代码。注意，模块名和变量名一样开头不能用数字，可以是双下划线和字母。

为什么要用模块？ 将一些复杂的需要重复使用的功能进行分类，分别放到一个py文件中，需要调用的时候直接拿来用就可以了。

模块的导入方法

##模块导入的方法
1 import 模块名  可以导入多个模块，中间用逗号，但是不建议这么用。
 
　　　　　　　　　　　适用范围：需要导入一个模块中的多个函数变量时。
 
2.from 模块名  import 函数       可以跟多个函数
 
　　　　　　　　　　适用范围：需要导入一个模块的一个函数时，这样比上个方法，节省内存。
 
3. from 模块名 import *  导入这个模块的所有函数，变量，这个方法不建议使用，如果有重名的就会覆盖。它一般和__all__配合使用。__all__,是一个列表，他会把，*中的所有的变量名，方法名放进去。（这个了解一下就可以了）。
 
4. from  模块名 import 函数 as 另一个函数名     给函数重新命名 注意：当重新命名后，原函数名不能使用了。
 
　　　　　　　　　　使用范围：1.函数名特别长，2，模块函数名和程序中的函数名重名是。
 
5.__import__:  同import语句同样的功能，但__import__是一个函数，并且只接收字符串作为参数，所以它的作用就可想而知了。其实import语句就是调用这个函数进行导入工作的，import sys <==>sys = __import__('sys')

import 的本质是：把要导入的模块中的内容运行了一遍。

from module import function 的本质：只把该模块中的该函数运行了一遍，这样就大大的提高了效率。

介绍下sys.modules ，首先来说sys.modules是一个全局字典.python解释器启动的时候会把一些模块名加载进来放到字典中，注意这里加载的只是模块的名字，而不是模块，只有你import的时候才会加载模块(这里有个例外内建模块builtins中的内容可以直接使用)，还要注意一点，并不是把所有的内建的模块都加载进来，而是一部分，比如说re模块就没有加载进来，time模块就就被加载进来了。

 sys.modules是一个全局字典，该字典是python启动后就加载在内存中。每当程序员导入新的模块，sys.modules都将记录这些模块。
字典sys.modules对于加载模块起到了缓冲的作用。当某个模块第一次导入，字典sys.modules将自动记录该模块。当第二次再导入该模块时，python会直接到字典中查找，从而加快了程序运行的速度。

如果你想导入re模块其实他正确的搜索顺序是这样的:首先在sys.modules中找，没有找到，然后再去sys.path(sys.path是python的搜索模块的路径集，是一个list)中找，先找列表中的第一个路径，这个路径就是保存着的你自己写的模块，如果这时候正好你也写了一个re模块，它就会先执行你写的这个RE模块，而不是真正的RE模块，这就是为什么你自己的模块的名字不能和内建的模块名字相同的原因。python内置的模块放在了python36目录下Lib中。第三方模块放在python36目录下Lib中的site-packages 。

介绍下sys.path,   sys.path是python的搜索模块的路径集，是一个列表

['C:\\Users\\stickerzhang\\PycharmProjects\\untitled3\\算法', 
 
'C:\\Users\\stickerzhang\\PycharmProjects\\untitled3\\算法', 
 
'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\python36.zip', 
 
'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\DLLs',
 'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\lib', 
 
'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36', 
 
'C:\\Users\\stickerzhang\\AppData\\Roaming\\Python\\Python36\\site-packages',
 'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\lib\\site-packages']

可以在python 环境下使用sys.path.append(path)添加相关的路径，但在退出python环境后自己添加的路径就会自动消失！

解决方案点击

介绍下内建模块builtins(python3) 在python2中是__builtin__  注意在python3中没有__builtins__模块

Python解释器启动时会自动执行：

from builtins import *

这就是为什么内建函数不用导入就可以使用的原因吧.

这里边有149个内容

包含7个模块相关

'__build_class__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__'

4个特殊名字

欢迎界面里的copyright，credits，help，license：

6个内建常数

'True', 'False', 'None', 'Ellipsis', '__debug__', 'NotImplemented'

68个内建函数

61+3个异常

https://docs.python.org/3/library/exceptions.html#exception-hierarchy

模块导入的顺序：内置模块先从sys.modules 中寻找，找不到再从sys.path给的路经依次中寻找。

所有的内置函数都放在了builtints(python3)模块中，在python解释器启动时，这个模块就被加载过了。

pyc：是这个代码编译后的文件。当一个py文件被当做模块导入时会生成一个pyc文件，这个文件 把代码编译成字节码，再次运行该模块时会直接运行pyc文件而不需要重新在编译，这样就大大提高加载模块的速度，强调强调强调：提高的是加载速度而绝非运行速度。

我们推荐所有的模块应该这样导入：

python标准库模块

python第三方模块

python自己写的模块

需要特别注意的是：我们自定义的模块名不应该与系统内置模块重名。虽然每次都说，但是仍然会有人不停的犯错。

if __name__ == "__main__:"

在很多python脚本中在最后的部分会执行一个判断语句if __name__ == "__main__:"，之后还可能会有一些执行语句。那添加这个判断的目的何在？

在python编译器读取源文件的时候会执行它找到的所有代码，而在执行之前会根据当前运行的模块是否为主程序而定义变量__name__的值为__main__还是模块名。因此，该判断语句为真的时候，说明当前运行的脚本为主程序，而非所引用的模块。这在当你想要运行一些只有在将模块当做主程序运行时而非当做模块引用时才执行的命令，只要将它们放到if __name__ == "__main__:"判断语句之后就可以了。

举个例子，比如说你要在text2中引用text1模块，在text1模块中写入a="hello worlf">>> print（a）,然后你导入text1，然后运行text2，这时候你会发现，我还没有调用text1.a,它就会打印hello Word，但是你不想这样啊，你想什么时候调用text1.a才会打印helloWord，这该怎么办？

方法：在text1程序中，写入if __name__ == "__main__:"，然后把print(a)，放入这条件语句后，就可以 了。这样我只有运行text1程序的时候才会直接打印helloWord，导入text1程序时，只有调用text1 .a 才会打印helloWord。你会问为什么会这样？

因为当你想要运行你当前的模块而非引用的模块时，__name__的值就是"__main__"，当你在另外一个模块中导入该模块时该模块中的__name__值就变为该模块的模块名了。

举个列子：假设你在text1中写入print(__name__)>>>你会得到 "__main__".  然后你在text2文件中导入text1模块，运行text2文件，你会得到>>>text2，这个模块的文件名，这就是__name__的作用。

说了这么多废话,官方这样解释:确保服务器只会在该脚本被python解释器直接执行的时候,才会被运行,而不是作为模块导入的时候.

time模块

表示时间的三种方式

在Python中，通常有这三种方式来表示时间：时间戳、元组(struct_time)、格式化的时间字符串：

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

(2)格式化的时间字符串(Format String)： ‘1999-12-06’  注意这个的数据类型是字符串

%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 当前时区的名称
%% %号本身
 
python中时间日期格式化符号：

3)元组(struct_time) ：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）

索引（Index）	属性（Attribute）	值（Values）
0	tm_year（年）	比如2011
1	tm_mon（月）	1 - 12
2	tm_mday（日）	1 - 31
3	tm_hour（时）	0 - 23
4	tm_min（分）	0 - 59
5	tm_sec（秒）	0 - 60
6	tm_wday（weekday）	0 - 6（0表示周一）
7	tm_yday（一年中的第几天）	1 - 366
8	tm_isdst（是否是夏令时）	默认为0

首先，我们先导入time模块，来认识一下python中表示时间的几种格式：

#导入时间模块
>>>import time
 
#时间戳
>>>time.time()
1500875844.800804
 
#时间字符串
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 13:54:37'
>>>time.strftime("%Y-%m-%d %H-%M-%S")
'2017-07-24 13-55-04'
 
#时间元组:localtime将一个时间戳转换为当前时区的struct_time
time.localtime()
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24,
　　　　　　　　　　tm_hour=13, tm_min=59, tm_sec=37,
                 tm_wday=0, tm_yday=205, tm_isdst=0)

总结：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元组则是用来操作时间的

时间戳要转换成时间字符串必须经过时间元组的转化       timestamp----->struct_time---->format string

#时间戳-->结构化时间
#time.gmtime(时间戳)    #UTC时间，与英国伦敦当地时间一致
#time.localtime(时间戳) #当地时间。例如我们现在在北京执行这个方法：与UTC时间相差8小时，UTC时间+8小时 = 北京时间
>>>time.gmtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
>>>time.localtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
 
#结构化时间-->时间戳　
#time.mktime(结构化时间)
>>>time_tuple = time.localtime(1500000000)
>>>time.mktime(time_tuple)
1500000000.0

#结构化时间-->字符串时间
#time.strftime("格式定义","结构化时间")  结构化时间参数若不传，则显示当前时间
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 14:55:36'
>>>time.strftime("%Y-%m-%d",time.localtime(1500000000))
'2017-07-14'
 
#字符串时间-->结构化时间
#time.strptime(时间字符串,字符串对应格式)
>>>time.strptime("2017-03-16","%Y-%m-%d")
time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1)
>>>time.strptime("07/24/2017","%m/%d/%Y")
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)

datetime模块

datetime是Python处理日期和时间的标准库。

它包含了五个类：date，time，datetime，timedelta, tzinfo

date

date 类有三部分组成

date(year,month,day)

你也可以用这种方法来获取年

date实例化对象中包含的方法与属性

1、用于日期比较大小的方法

方法名	方法说明	用法
__eq__(…)	等于(x==y)	x.__eq__(y)
__ge__(…)	大于等于(x>=y)	x.__ge__(y)
__gt__(…)	大于(x>y)	x.__gt__(y)
__le__(…)	小于等于(x<=y)	x.__le__(y)
__lt__(…)	小于(x	x.__lt__(y)
__ne__(…)	不等于(x!=y)	x.__ne__(y)

以上方法的返回值为True\False

>>> a=datetime.date(2017,3,1)
>>> b=datetime.date(2017,3,15)
>>> a.__eq__(b)
False
>>> a.__ge__(b)
False
>>> a.__gt__(b)
False
>>> a.__le__(b)
True
>>> a.__lt__(b)
True
>>> a.__ne__(b)
True

2、获得二个日期相差多少天

>>>t
datetime.date(2018, 3, 30)
>>>b=datetime.date(2018,3,25)
>>>t.__sub__(b)
datetime.timedelta(5) #得到的是timedelta数据类型
>>>t.__sub__(b).days #如果想要获取两个日期相差多少天用这个方法
5

timedelta

timedelta是datetime中的一个对象，该对象表示两个时间的差值

举例计算当前时间三天后的时间

import datetime
t=datetime.datetime.now()
print('当前的时间%s'%t)
 
after=t+datetime.timedelta(days=3)
print('三天后的时间%s'%after)

结果：

当前的时间2018-11-15 10:24:18.626596
三天后的时间2018-11-18 10:24:18.626596

replace

我们知道timedelta只能计算的范围是周,天,小时,分钟,秒,,但是我要计算几年后,几月前怎么办呢,这时候replace就出来了

# 当前为2020计算去年
dt = datetime.datetime.now()
dt = dt.replace(year=dt.year - 1).strftime("%Y")
print(dt)
 
#结果
 
2019

日期的字符串输出

如果你想将日期对象转化为字符串,可以用到__format__(...)方法以指定格式进行日期输出

>>>t
datetime.date(2018, 3, 30)
>>>t.__format__("%Y-%m-%d")
'2018-03-30'
>>>type(t.__format__("%Y-%m-%d"))
<class 'str'>

你还可以用strftime这个方法来转化为字符串

f>>>t
datetime.date(2018, 3, 30)
>>>t.strftime("%Y-%m-%d"),type(t.strftime("%Y-%m-%d"))
'2018-03-30', <class 'str'>

如果只是相简单的获得日期的字符串，则使用__str__()

>>>t
datetime.date(2018, 3, 30)
>>>>t.__str__()
'2018-03-30'   #注意只能显示这个-的形式

os模块

os模块主要是用于对操作系统的操作

__file__:当前文件的绝对路径

print(type(__file__),__file__)

结果：

<class 'str'> C:/Users/stickerzhang/PycharmProjects/untitled3/day1/text.py

os.path模块

#以下内容都是os.path子模块中的内容
 
#abspath()  将相对路径转化为绝对路径或者是得到当前文件的绝对目录
path = './boys'#相对
result = os.path.abspath(path)
print(result)
 
#dirname()  获取完整路径当中的目录部分 也就是当前文件的目录,abspath的父目录 &  basename()获取完整路径当中的文件部分
path = '/home/sy/boys.py'
result = os.path.dirname(path)
print(result) #  /home/sy
 
result = os.path.basename(path)
print(result)  # boys.py
 
#split() 将一个完整的路径切割成目录部分和文件部分,用元组表示
path = '/home/sy/boys.py'
result = os.path.split(path)
print(result)  # ('/home/sy', 'boys.py')
 
#join() 将2个路径合并成一个
var1 = '/home/sy/'
var2 = '000.py'
result = os.path.join(var1,var2)
print(result) # /home/sy/000.py
 
#splitext() 将一个路径切割成文件后缀和其他两个部分,主要用于获取文件的后缀
path = '/home/sy/000.py'
result = os.path.splitext(path)
print(result) #('/home/sy/000', '.py')
 
#getsize()  获取文件的大小
#path = '/home/sy/000.py'
#result = os.path.getsize(path)
#print(result)
 
#isfile() 检测是否是文件
path = '/home/sy/000.py'
result = os.path.isfile(path)
print(result)
 
#isdir()  检测是否是文件夹
result = os.path.isdir(path)
print(result)
 
#islink() 检测是否是链接
path = '/initrd.img.old'
result = os.path.islink(path)
print(result)
 
#getctime() 获取文件的创建时间 get create time
#getmtime() 获取文件的修改时间 get modify time
#getatime() 获取文件的访问时间 get active time
 
import time
 
filepath = '/home/sy/下载/chls'
 
result = os.path.getctime(filepath)
print(time.ctime(result))
 
result = os.path.getmtime(filepath)
print(time.ctime(result))
 
result = os.path.getatime(filepath)
print(time.ctime(result))
 
#exists() 检测某个路径是否真实存在
filepath = '/home/sy/下载/chls'
result = os.path.exists(filepath)
print(result)
 
#isabs() 检测一个路径是否是绝对路径
path = '/boys'
result = os.path.isabs(path)
print(result)
 
#samefile() 检测2个路径是否是同一个文件
path1 = '/home/sy/下载/001'
path2 = '../../../下载/001'
result = os.path.samefile(path1,path2)
print(result)

os.environ

#os.environ 用于获取和设置系统环境变量的内置值
import os
#获取系统环境变量  getenv() 效果
print(os.environ['PATH'])
 
#设置系统环境变量 putenv()
os.environ['PATH'] += ':/home/sy/下载'
os.system('chls')

os其他的一些命令

#getcwd() 获取当前工作目录(当前工作目录默认都是当前文件所在的文件夹)
result = os.getcwd()
print(result) #C:\Users\stickerzhang\PycharmProjects\untitled3\text1\tt
 
#chdir()改变当前工作目录
os.chdir('/home/sy')
result = os.getcwd()
print(result) 
 
open('02.txt','w')
 
#操作时如果书写完整的路径则不需要考虑默认工作目录的问题,按照实际书写路径操作
open('/home/sy/下载/02.txt','w')
 
#listdir() 获取指定文件夹中所有内容的名称列表
result = os.listdir('/home/sy')
print(result)
 
#mkdir()  创建文件夹
#os.mkdir('girls')
#os.mkdir('boys',0o777)
 
#makedirs()  递归创建文件夹
#os.makedirs('/home/sy/a/b/c/d')
 
#rmdir() 删除空目录
#os.rmdir('girls')
 
#removedirs 递归删除文件夹  必须都是空目录
#os.removedirs('/home/sy/a/b/c/d')
 
#rename() 文件或文件夹重命名
#os.rename('/home/sy/a','/home/sy/alibaba'
#os.rename('02.txt','002.txt')
 
#stat() 获取文件或者文件夹的信息
#result = os.stat('/home/sy/PycharmProject/Python3/10.27/01.py)
#print(result)
 
#system() 执行系统命令(危险函数)
#result = os.system('ls -al')  #获取隐藏文件
#print(result)
 
#环境变量
'''
环境变量就是一些命令的集合
操作系统的环境变量就是操作系统在执行系统命令时搜索命令的目录的集合
'''
#getenv() 获取系统的环境变量
result = os.getenv('PATH')
print(result.split(':')) #是一个列表
 
#putenv() 将一个目录添加到环境变量中(临时增加仅对当前脚本有效)
#os.putenv('PATH','/home/sy/下载')
#os.system('syls')
 
#exit() 退出终端的命令
 
#os模块中的常用值
#curdir  表示当前文件夹   .表示当前文件夹  一般情况下可以省略
print(os.curdir)
 
#pardir  表示上一层文件夹   ..表示上一层文件夹  不可省略!
print(os.pardir)
 
#os.mkdir('../../../man')#相对路径  从当前目录开始查找
#os.mkdir('/home/sy/man1')#绝对路径  从根目录开始查找
 
#name 获取代表操作系统的名称字符串
print(os.name) #posix -> linux或者unix系统  nt -> window系统
 
#sep 获取系统路径间隔符号  window ->\    linux ->/
print(os.sep)
 
#extsep 获取文件名称和后缀之间的间隔符号  window & linux -> .
print(os.extsep)
 
#linesep  获取操作系统的换行符号  window -> \r\n  linux/unix -> \n
print(repr(os.linesep))

 os模块遇到的坑

不要这样用

path = os.path.dirname(__file__)
print(path)
 
#虽然这样能打印出结果

但是换成这种情况就不好使了：

import os
 
def test():
    print(os.path.dirname(__file__))
 
test()
 
#无结果

#应该这样写
import os
 
def test():
    print(os.path.dirname(os.path.realpath(__file__)))
 
test()

os.path.abspath()和os.path.realpath() 区别？

#他们俩都返回绝对路径，不同的是：realpath可以返回带有软连接的，连接真正的文件的路径，这个一般用不到

os.system():

可以将字符串转换成命令在服务器上运行；其原理是每一条system函数执行时，其会创建一个子进程在系统上执行命令行，子进程的执行结果无法影响主进程

import os
 
#使用它执行多条命令时：可以用分号（；）隔开，也可以用&&隔开
os.system("mkdir aa;cd aa;touch a.txt")

sys模块

sys模块主要是和解释器有关的

这里主要记住这几个参数

sys.path 返回一个列表，列表中有模块的搜索路径

sys.argv 是一个列表，第一项为文件的名字，剩下的参数是用户从控制台输入的参数。

你不能一直在pycharm中执行文件，当我们写了一个脚本时，别人用的时候需要验证用户名和密码才能执行，这时候就可以用到这个参数

import sys
argv_list=sys.argv
print('argv_list',argv_list)
if len(argv_list)==3 and argv_list[1]=='xiao'and argv_list[2]=='':
    print('程序执行')
else:
    sys.exit() #程序不执行

你在控制台terminal这样执行

C:\Users\stickerzhang\PycharmProjects\untitled3\pake\package\api>python day1.py xiao 123

结果：

argv_list ['day1.py', 'xiao', '']
程序执行

sys.module 是一个字典保存加载进来的一些内置模块，

'builtins': <module 'builtins' (built-in)>, 'sys': <module 'sys' (built-in)>, '_frozen_importlib': <module '_frozen_importlib' (frozen)>, '_imp': <module '_imp' (built-in)>, '_warnings': <module '_warnings' (built-in)>, '_thread': <module '_thread' (built-in)>, '_weakref': <module '_weakref' (built-in)>, '_frozen_importlib_external': <module '_frozen_importlib_external' (frozen)>, '_io': <module 'io' (built-in)>, 'marshal': <module 'marshal' (built-in)>, 'nt': <module 'nt' (built-in)>, 'winreg': <module 'winreg' (built-in)>, 'zipimport': <module 'zipimport' (built-in)>, 'encodings': <module 'encodings' from 'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\lib\\encodings\\__init__.py'>, 'codecs': <module 'codecs' from 'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\lib\\codecs.py'>, '_codecs': <module '_codecs' (built-in)>, 'encodings.aliases': <module 'encodings.aliases' from 'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\lib\\encodings\\aliases.py'>, 'encodings.utf_8': <module 'encodings.utf_8' from 'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\lib\\encodings\\utf_8.py'>, '_signal': <module '_signal' (built-in)>, '__main__': <module '__main__' from 'C:/Users/stickerzhang/PycharmProjects/untitled3/day1/text.py'>, 'encodings.latin_1': <module 'encodings.latin_1' from 'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\lib\\encodings\\latin_1.py'>, 'io': <module 'io' from 'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\lib\\io.py'>, 'abc': <module 'abc' from 'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\lib\\abc.py'>, '_weakrefset': <module '_weakrefset' from 'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\lib\\_weakrefset.py'>, 'site': <module 'site' from 'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\lib\\site.py'>, 'os': <module 'os' from 'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\lib\\os.py'>, 'errno': <module 'errno' (built-in)>, 'stat': <module 'stat' from 'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\lib\\stat.py'>, '_stat': <module '_stat' (built-in)>, 'ntpath': <module 'ntpath' from 'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\lib\\ntpath.py'>, 'genericpath': <module 'genericpath' from 'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\lib\\genericpath.py'>, 'os.path': <module 'ntpath' from 'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\lib\\ntpath.py'>, '_collections_abc': <module '_collections_abc' from 'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\lib\\_collections_abc.py'>, '_sitebuiltins': <module '_sitebuiltins' from 'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\lib\\_sitebuiltins.py'>, 'sysconfig': <module 'sysconfig' from 'C:\\Users\\stickerzhang\\AppData\\Local\\Programs\\Python\\Python36\\lib\\sysconfig.py'>, 'time': <module 'time' (built-in)>}