模块

(1)模块

定义 : 用一段代码实现某个功能的代码集合，对于一个复杂的功能来，可能需要多个函数才能完成（函数又可以在不同的.py文件中），n个 .py 文件组成的代码集合就称为模块。

常见的模块 : os>>>>>>>>>>>>>>系统模块

　　　　　　file>>>>>>>>>>>>>>文件操作相关模块

按性质可分为三种: 自定义模块, 内置模块, 第三方模块

(2)模块导入方法

1.import(在同个包里用import调用文件名)

import方法实质就是按照系统的环境变量sys.path中去寻找调用的文件

注意:在当前目录下存在与要引入的模块同名的文件,就会把要引入的模块屏蔽掉.(time,sys除外)

环境变量修改:

1 import sys,os
2 
3 BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
4 sys.path.append(BASE_DIR)

2.包(package)

定义：按目录来组织模块的方法，称为包

引入了包以后，只要顶层的包名不与别人冲突，那所有模块都不会与别人冲突。

每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录(文件夹)，而不是一个包。__init__.py可以是空文件，也可以有Python代码，因为__init__.py本身就是一个模块，而它的模块名就是对应包的名字。

3.if__name__ == "__main__":

作用：作为调试代码时使用，声明在它下面的代码作为调试作用，在执行页name系统默认等于“main”,在调用页name=路径4.，显然与__main__不相等，这样别人在调用的时候，不会将调试代码执行

4.time模块

import time#调用系统内置time模块（time模块是用C语言编写的，与程序同在，并不是调用py文件来实现的）

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

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

 1 import time
 2 #time.sleep()#推迟指定的时间运行
 3 print(time.time())#打印从1970年1月日凌晨至现在的时间用秒表示
 4 #1481537054.002029
 5 print(time.localtime())#将一个时间戳结构化，默认以当前时间为准
 6 #time.struct_time(tm_year=2016, tm_mon=12, tm_mday=12, tm_hour=18, tm_min=4, tm_sec=14, tm_wday=0, tm_yday=347, tm_isdst=0)
 7 print(time.gmtime())#将一个时间戳转换为当前UTC时区，默认格林尼治时间
 8 #time.struct_time(tm_year=2016, tm_mon=12, tm_mday=12, tm_hour=10, tm_min=5, tm_sec=12, tm_wday=0, tm_yday=347, tm_isdst=0)
 9 print(time.mktime(time.localtime()))#将结构化时间转换为时间戳
10 #1481537602.0
11 print(time.strftime("%Y-%m-%d %X",time.localtime()))#将结构化时间以自定义格式转换为字符串时间
12 #2016-12-12 18:15:35
13 print(time.strptime("2016-09-12 12:03:24","%Y-%m-%d %X"))#将字符串时间按格式转换为结构化时间
14 #time.struct_time(tm_year=2016, tm_mon=9, tm_mday=12, tm_hour=12, tm_min=3, tm_sec=24, tm_wday=0, tm_yday=256, tm_isdst=-1)
15 print(time.clock())#cpu运行时间
16 #1.61984329635951e-06
17 print(time.ctime())#将时间戳直接转换为字符串时间
18 #Mon Dec 12 18:22:42 2016
19 print(time.asctime())#将时间戳直接转换为字符串时间
20 #Mon Dec 12 18:24:06 2016

time方法

另外，调用datetime可以直接将当前时间直接以字符串形式显示

1 1 import datetime
2 2 print(datetime.datetime.now())#以字符串形式显示当前时间
3 3 #2016-12-12 18:26:56.154939

5.random(随机数模块)

import random#导入random模块

 1 import random#导入random模块
 2 print(random.random())#随机产生一个浮点数，只能在0-1之间取
 3 
 4 print(random.uniform(1,3))#在指定范围内随机产生一个浮点数
 5 
 6 print(random.randint(1,3))#在范围内随机产生一个整形数，两边都可取到
 7 
 8 print(random.choice("hello"))#在可迭代对象内随机取出一个对象
 9 #h
10 print(random.randrange(1,5))#在范围内随机产生一个整形数，右边为闭区间
11 
12 v = [1,2,3,4,5]
13 random.shuffle(v)#打乱原有次序
14 print(v)
15 #[2, 1, 5, 3, 4]
16 
17 print(random.sample([1,2,3,4],2))#在对象中随机取出指定个数元素
18 #[4, 1]

random

import random
def cod():
    s = ""
    for i in range(5):
        ret = random.choice([(random.randint(0,9)),chr(random.randint(66,122)),chr(random.randint(97,122))])
        s += str(ret)
    print(s)
cod()

6.os模块

os模块时与系统交互的一个接口

 1 os.getcwd()# 获取当前工作目录，即当前python脚本工作的目录路径
 2 os.chdir("dirname")  #改变当前脚本工作目录；相当于shell下cd
 3 os.curdir  #返回当前目录: ('.')
 4 os.pardir  #获取当前目录的父目录字符串名：('..')
 5 os.makedirs('dirname1/dirname2')    #可生成多层递归目录
 6 os.removedirs('dirname1')    #若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
 7 os.mkdir('dirname')    #生成单级目录；相当于shell中mkdir dirname
 8 os.rmdir('dirname')    #删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
 9 os.listdir('dirname')    #列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
10 os.remove()  #删除一个文件
11 os.rename("oldname","newname")  #重命名文件/目录
12 os.stat('path/filename')  #获取文件/目录信息
13 os.sep    #输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
14 os.linesep    #输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
15 os.pathsep    #输出用于分割文件路径的字符串 win下为;,Linux下为:
16 os.name    #输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
17 os.system("bash command")  #运行shell命令，直接显示
18 os.environ  #获取系统环境变量
19 os.path.abspath(path)  #返回path规范化的绝对路径
20 os.path.split(path)  #将path分割成目录和文件名二元组返回
21 os.path.dirname(path)  #返回path的目录。其实就是os.path.split(path)的第一个元素
22 os.path.basename(path)  #返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
23 os.path.exists(path)  #如果path存在，返回True；如果path不存在，返回False
24 os.path.isabs(path)  #如果path是绝对路径，返回True
25 os.path.isfile(path) # 如果path是一个存在的文件，返回True。否则返回False
26 os.path.isdir(path)  #如果path是一个存在的目录，则返回True。否则返回False
27 os.path.join(path1[, path2[, ...]])  #将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
28 os.path.getatime(path)  #返回path所指向的文件或者目录的最后存取时间
29 os.path.getmtime(path)  #返回path所指向的文件或者目录的最后修改时间

os

7.sys模块

1 sys.argv           命令行参数List，第一个元素是程序本身路径#在调试时，可以在前面定义参数，不用再执行过程中一个个添加
2 sys.exit(n)        退出程序，正常退出时exit(0)
3 sys.version        获取Python解释程序的版本信息
4 sys.maxint         最大的Int值
5 sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
6 sys.platform       返回操作系统平台名称

进度条

1 import sys,time
2 for i in range(50):
3     sys.stdout.write("%")
4     sys.stdout.flush()
5     time.sleep(1)

8.json/pickle

json可以将特殊字符串及普通字符串序列化

如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

1 import json
2 dic = {"a":"b"}
3 print(type(dic))#<class 'dict'>
4 v = json.dumps(dic)
5 print(type(v))#<class 'str'>#json将对象通过json特有的方法处理成了能被各种语言识别的字符串形式

1 f=open('序列化对象','w')
2 f.write(j)  #-------------------等价于json.dump(dic,f)
3 f.close()
4 #-----------------------------反序列化<br>
5 import json
6 f=open('序列化对象')
7 data=json.loads(f.read())#  等价于data=json.load(f)

pickle

 1 ##----------------------------序列化
 2 import pickle
 3  
 4 dic={'name':'alvin','age':23,'sex':'male'}
 5  
 6 print(type(dic))#<class 'dict'>
 7  
 8 j=pickle.dumps(dic)
 9 print(type(j))#<class 'bytes'>
10  
11  
12 f=open('序列化对象_pickle','wb')#注意是w是写入str,wb是写入bytes,j是'bytes'
13 f.write(j)  #-------------------等价于pickle.dump(dic,f)
14  
15 f.close()
16 #-------------------------反序列化
17 import pickle
18 f=open('序列化对象_pickle','rb')
19  
20 data=pickle.loads(f.read())#  等价于data=pickle.load(f)
21  
22  
23 print(data['age'])    
24       Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。

9.shelve模块

shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写;key必须为字符串，而值可以是python所支持的数据类型

 1 import shelve
 2  
 3 f = shelve.open(r'shelve.txt')
 4  
 5 # f['stu1_info']={'name':'alex','age':'18'}
 6 # f['stu2_info']={'name':'alvin','age':'20'}
 7 # f['school_info']={'website':'oldboyedu.com','city':'beijing'}
 8 #
 9 #
10 # f.close()
11  
12 print(f.get('stu_info')['age'])

10.hashlib模块>>>>>加密操作

主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

 1 import hashlib
 2  
 3 m=hashlib.md5()# m=hashlib.sha256()
 4  
 5 m.update('hello'.encode('utf8'))
 6 print(m.hexdigest())  #5d41402abc4b2a76b9719d911017c592
 7  
 8 m.update('alvin'.encode('utf8'))
 9  
10 print(m.hexdigest())  #92a7e713c30abbb0319fa07da2a5c4af
11  
12 m2=hashlib.md5()
13 m2.update('helloalvin'.encode('utf8'))
14 print(m2.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af

以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。

1 import hashlib
2  
3 # ######## 256 ########
4  
5 hash = hashlib.sha256('898oaFs09f'.encode('utf8'))
6 hash.update('alvin'.encode('utf8'))
7 print (hash.hexdigest())#e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7

python 还有一个 hmac 模块，它内部对我们创建 key 和 内容 再进行处理然后再加密:

1 import hmac
2 h = hmac.new('alvin'.encode('utf8'))
3 h.update('hello'.encode('utf8'))
4 print (h.hexdigest())#320df9832eab4c038b6c1d7ed73a5940

 

转载于:https://www.cnblogs.com/lovezwfjc/p/9326764.html