python常用模块(模块和包的解释，time模块，sys模块，random模块，os模块，json和pickle序列化模块)

1.1模块

什么是模块：

在计算机程序的开发过程中，随着程序代码越写越多，在一个文件里代码就会越来越长，越来越不容易维护。

为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里，这样，每个文件包含的代码就相对较少，在python中。一个.py文件就称为一个模块（Module）

使用模块的好处：

提高了代码的可维护性。

其次，编写代码不必从零开始。当一个模块编写完毕，就可以被其他地方引用。我们编写程序的时候也经常引用其他模块，包括python的内置的模块和第三方模块。

包（package）的概念：

如果不同的人编写的模块名相同怎么办？

为了避免模块名冲突，python有引入了按目录组织模块的方法，称为包（Package）

一个abc.py的文件就是一个名字叫abc的模块。

假设，我们的abc和qaz这两个模块名字与其他模块冲突了，于是我们可以通过包来组织模块，避免冲突，方法是选择一个顶层的包名比如MyUser。

引入包以后，只要顶层的包名不与别人冲突，那所有的模块都不会与别人冲突。现在abc.py模块的名字就变成了MyUser.abc，qaz模块名字就变成了MyUser.qaz.

多级包结构：包.包.模块

注：每个包目录下面都会有一个——init——.py文件，这个文件是必须存在的，否则，python就把这个目录当成普通目录，而不是一个包。——init——.py可以是空文件，里面可以有程序代码，因为——init——.py就是一个模块，模块名就是MyUser

注：我们自已编写模块名时，尽量不要与内置函数或则模块名字冲突。如同与系统的模块同名，否则无法导入系统自带的模块

模块分为3种：

1.自定义模块

2.内置标准模块（又称标准库）

3.第三方模块(开源模块)

1.1.1导入模块

 #1语法import

 import  module1,module2,module3,module4

 #2from  xx import xx 语句

 from module  import   name1,name2

 #这个声明不会把module模块导入到当前的命名空间，只会把name1，name2单个引入到执行的程序

 from module.xx  import  name  as rename

 #把来自于modname.xx的name的重新改了一个名字，去掉用这个模块的方法

 from module  import   *

 #这提供了一个简单的方法来导入一个模块中的所有项目。这个导入的模块的方法一般不推荐使用，如果引入的其它来源的命名，很有可能覆盖已有的定义。

模块的运行本质

#

import  test

#2

from  modname  from  test

无论是1,还是2，首先通过sys.pyth找到test.py，然后执行test代码（全部执行）

区别是1会将test这个模块名加载到名字空间，而2只会将test这个变量名加载进来。

为模块添加路径

#模块运行时通过sys.path的路径一步一步查找模块的

#导入模块时是根据那个路径作为基准来进行的呢？即：sys.path

#如果sys.path路劲列表中没有你想要的路径，可以通过sys.path.append("路径")来添加

#当前这是临时添加，如需永久添加则需修改系统的环境变量

import os,sys

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

sys.path.append(BASE_DIR)

开源模块安装的常用方法

 1.yum

 2.pip

 3.apt-get

1.1.2name

python解释器把一个特殊变量__name__的值为__main__

#很多模块文件内容里面都有

if __name__=='__main__':

       运行测试代码程序的逻辑

如果我们写的模块文件，需要被别人调用则不会运行下面的程序的逻辑

我们自已使用用，可以些运行整体程序代码的逻辑

自已用的时候 __name__=='__main__' , __name__的变量就等于'__main__'，被当作模块导入到其他的文件里时, __name__的变量不等于'__main__'

1.2sys模块

 sys.argv   #在命令行参数是一个空列表，在其他中第一个列表元素中程序本身的路径

 sys.exit(n) #退出程序，正常退出时exit(0)

 sys.version  #获取python解释程序的版本信息

 sys.path #返回模块的搜索路径，初始化时使用python PATH环境变量的值

 sys.platform #返回操作系统平台的名称

 sys.stdin    #输入相关

 sys.stdout  #输出相关

 sys.stderror #错误相关

常用sys模块的方法

 import sys,time

 for i in range(1,20):

     sys.stdout.write("#") #显示写入

     time.sleep(0.2)

     sys.stdout.flush() # 把每次写入的东西都给刷新到屏幕

 import sys,time

 def view_bar(num, total):

     rate = float(num) / float(total)

     rate_num = int(rate * 100)

     r = '\r%d%%' % (rate_num, ) #%% 表示一个%

     sys.stdout.write(r)

     sys.stdout.flush()

 if __name__ == '__main__':

     for i in range(0, 101):

         time.sleep(0.1)

         view_bar(i, 100)

进度%比

1.3time模块

在python中，通常3种时间的表示

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

2.格式化的时间字符串 (年-月-日时:分:秒)

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

常用time模块方法

 #注：小白多用print()，查看

 1#time.time() 时间戳

 print(time.time())

 2#time.localtime(second) 加上second（时间戳）转换结构化时间，不加则显示当前的结构化时间

 print(time.localtime())

 print(time.localtime(1371643198))

 3#time.gmtime(second) #utc时区加上second（时间戳）转换结构化时间，不加则显示当前的结构化时间

 print(time.gmtime())

 print(time.gmtime(1391614837))

 4#mktime ()结构化时间转换为时间戳

 print(time.mktime(time.localtime()))

 5#time.ctime(seconds)#将加上时间戳转换为时间戳的格式化时间，不加则返回当前的的格式化时间

 print(time.time())

 print(time.ctime(1331644244))

 6#time.asctime(p_tuple)#加参数是加一个结构化时间，把加的结构化时间转换为格式化时间，不加则返回当前的格式化时间

 print(time.asctime())

 print(time.asctime(time.gmtime()))

 7#time.strftime(format,p_tuple)  #把一个结构化时间转化相应的格式时间

 print(time.strftime("%Y-%m-%d %X",time.localtime()))

 8#time.strptime(string,format) #把相应的格式时间，转换为结构化时间

 print(time.strptime("2015-5-20 20:22:36","%Y-%m-%d %X"))

 #time.struct_time(tm_year=2015, tm_mon=5, tm_mday=20, tm_hour=20, tm_min=22, tm_sec=36, tm_wday=2, tm_yday=140, tm_isdst=-1)

 9#time.sleep(second)#将程序延迟指定的秒数运行

 print(time.sleep(5))

 # 10 time.clock()

 # 这个需要注意，在不同的系统上含义不同。在UNIX系统上，它返回的是“进程时间”，它是用秒表示的浮点数（时间戳）。

 # 而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行

 # 时间，即两次时间差。

1.4random模块

 import random

 print(random.random())#随机生成一个小于1的浮点数

 print(random.randint(1,3)) #[1-3]随机生成1到3的数

 print(random.randrange(1,3)) #[1-3)随机生成1到2的数

 print(random.choice([1,'',[4,5]]))#随机在列表中选取一个元素

 print(random.sample([1,'',[4,5]],2))#随机在列表中选取2个元素

 print(random.uniform(1,3))#随机生成1-3的之间的浮点数

 print(random.shuffle([1,3,5,7,9]))#打乱列表中元素的顺序

 import random

 def v_code():

     #随机生成5位数的验证码

     code = ''

     for i in range(5):

         num=random.randint(0,9)

         alf=chr(random.randint(65,90))

         add=random.choice([num,alf])

         code += str(add)

     return code

 print(v_code())

随机生成5位数的验证码

1.5os模块

 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.environ  获取系统环境变量

 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[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

 print(os.path.join("D:\\python\\wwww","xixi"))   #做路径拼接用的

 #D:\python\wwww\xixi

 os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间

 os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间

1.6json & pickle序列化模块

JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：

json和内置函数的eval()方法，eval将一个字符串转成python对象，不过，eval 方法有局限性，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就不管用了所以eval的重点还是通常用来执行一个字符串表达式，并返回表达式的值。

 import json

 aa = '{"name":"qa","age":11}'

 xixi="[1,2,3,4,5,6]"

 bb = "('1','2')"

 print(eval(aa))

 print(json.loads(aa))

 print(type(json.loads(xixi)))

 print(type(json.loads(aa)))

 # print(type(json.loads(bb))) #报错[](){}里面所有的元素的单引号必须改为双引号，json不认单引号

 xx = "[xixi,haha]"

 # print(eval(xx)) #报错

 print(json.dumps(xx))   #"[xixi,haha]"

什么是序列化：

我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化。

反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化。

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

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

json的dumps，loads的功能：

 import json

 data = {'k1':123,'k2':456}

 s_str=json.dumps(data)  #把data对象序列化成字符串 >>>>>#序列化的过程

 # print(s_str)  #{"k2": 456, "k1": 123}

 # print(type(s_str)) str

 with open("js_new","w") as f:

     f.write(s_str)  #把json的字符串写入到文件js_new

 #注：用之前先把上面的写文件的方式给注释掉

 with open("js_new","r") as f:

     aa = json.loads(f.read())   #把字符串重新读到python原来数据对象  >>>>#反序列化过程

     print(aa)

     # print(type(aa)) #<class 'dict'>

dumps和loads

json的dump，load的功能

 import json

 data = {'k1':123,'k2':456}

 with open("json_dump","w") as f:

     json.dump(data,f)

 #json.dump(x,f) x是python原来数据的对象，f是文件对象 主要是用来写python对象到文件里面

 with open("json_dump","r") as f:

     bb = json.load(f)

     print(bb)

     print(type(bb))  #<class 'dict'>

 #json.read(f) #f是文件对象，把文件对象的数据读取成原来python对象的类型

dump 和 read

json的dumps，loads，dump，load功能总结

json.dumps(x) 把python的(x)原对象转换成json字符串的对象，主要用来写入文件。

json.loads(f) 把json字符串(f)对象转换成python原对象，主要用来读取文件和json字符串

json.dump(x,f)　　把python的(x)原对象,f是文件对象，写入到f文件里面，主要用来写入文件的

json.load(file)　　把json字符串的文件对象，转换成python的原对象，只是读文件

pickle的功能

pickle和json的用法类似。

这里我就不一一举列了

 li = "[1,2,3,4,5,6,'aa']"

 aa = pickle.dumps(li)

 print(type(aa)) #<class 'bytes'>

 # print(pickle.dumps(li)) #bytes对象

 with open("pickle_new","wb") as p: #注意w是写入str，wb时写入字节 ,wb写入文件是二进制，

                                         # 我们看不到里面的里面写入的文件内容pickle_new

     pickle.dump(li,p)

 with open("pickle_new","rb") as p_b: #以二进制方式读取

     # print(pickle.load(p_b))  #[1,2,3,4,5,6,'aa']

     print(pickle.loads(p_b.read()))  #[1,2,3,4,5,6,'aa']

pickle用法

注：pickle的问题和所有其他编程语言特有的序列化的问题一样，就是pickle它只能用于python，并且可能不同版本的python彼此都不兼容，因此，只能用pickle保存那些不重要的数据，不能成功的反序列化也没关系。