模块

(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个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

import time
#time.sleep()#推迟指定的时间运行
print(time.time())#打印从1970年1月日凌晨至现在的时间用秒表示
#1481537054.002029
print(time.localtime())#将一个时间戳结构化，默认以当前时间为准
#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)
print(time.gmtime())#将一个时间戳转换为当前UTC时区，默认格林尼治时间
#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)
print(time.mktime(time.localtime()))#将结构化时间转换为时间戳
#1481537602.0
print(time.strftime("%Y-%m-%d %X",time.localtime()))#将结构化时间以自定义格式转换为字符串时间
#2016-12-12 18:15:35
print(time.strptime("2016-09-12 12:03:24","%Y-%m-%d %X"))#将字符串时间按格式转换为结构化时间
#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)
print(time.clock())#cpu运行时间
#1.61984329635951e-06
print(time.ctime())#将时间戳直接转换为字符串时间
#Mon Dec 12 18:22:42 2016
print(time.asctime())#将时间戳直接转换为字符串时间
#Mon Dec 12 18:24:06 2016

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

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

5.random(随机数模块)

import random#导入random模块

import random#导入random模块
print(random.random())#随机产生一个浮点数，只能在0-1之间取

print(random.uniform(1,3))#在指定范围内随机产生一个浮点数

print(random.randint(1,3))#在范围内随机产生一个整形数，两边都可取到

print(random.choice("hello"))#在可迭代对象内随机取出一个对象
#h
print(random.randrange(1,5))#在范围内随机产生一个整形数，右边为闭区间

v = [1,2,3,4,5]
random.shuffle(v)#打乱原有次序
print(v)
#[2, 1, 5, 3, 4]

print(random.sample([1,2,3,4],2))#在对象中随机取出指定个数元素
#[4, 1]

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模块时与系统交互的一个接口

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[, ...]])  #将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  #返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)  #返回path所指向的文件或者目录的最后修改时间

7.sys模块

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

进度条

import sys,time
for i in range(50):
    sys.stdout.write("%")
    sys.stdout.flush()
    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

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

9.shelve模块

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

import shelve
 
f = shelve.open(r'shelve.txt')
 
# f['stu1_info']={'name':'alex','age':'18'}
# f['stu2_info']={'name':'alvin','age':'20'}
# f['school_info']={'website':'oldboyedu.com','city':'beijing'}
#
#
# f.close()
 
print(f.get('stu_info')['age'])

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

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

import hashlib
 
m=hashlib.md5()# m=hashlib.sha256()
 
m.update('hello'.encode('utf8'))
print(m.hexdigest())  #5d41402abc4b2a76b9719d911017c592
 
m.update('alvin'.encode('utf8'))
 
print(m.hexdigest())  #92a7e713c30abbb0319fa07da2a5c4af
 
m2=hashlib.md5()
m2.update('helloalvin'.encode('utf8'))
print(m2.hexdigest()) #92a7e713c30abbb0319fa07da2a5c4af

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

import hashlib
 
# ######## 256 ########
 
hash = hashlib.sha256('898oaFs09f'.encode('utf8'))
hash.update('alvin'.encode('utf8'))
print (hash.hexdigest())#e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7

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

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