模块

参考文献：https://www.cnblogs.com/linhaifeng/articles/6384466.html
http://39.97.99.7/python/logging.html

一.模块分类

在python中，模块分为三类。

  • 第一类：内置模块，也叫标准库，此类模块时python解释器提供的。在python安装目录下Lib。
  • 第二类：第三方模块，必须通过pip指令安装的模块，比如BeautifulSoup，Django等。在python安装目录下site-packages下
  • 第三类：自定义模块。自己定义的。

二.模块的查找顺序

模块的查找顺序：(针对同名模块)

  1. 内存中已经加载的模块(sys.modules)
  2. 内置模块(python解释器自带的，也就是没有加载到内存中的，一旦import，就加载)
  3. sys.path路径中包含的模块(自定义模块、第三方模块)

文件运行时,sys内置模块就会将一些模块 自动 加载到内存(包括一些必要的内置模块，和当前py文件的父目录)如果直接引用不到某个模块，那么此模块必定不在内存中，需要手动将其添加进内存，这就用到sys.path.append().

# test.py
import time
import m1              # 将m1加载到内存
m1.f1()
time.sleep(15)
import m1              # 文件没有执行完毕，看内存中是否有正在运行的m1模块
m1.f1()

'''
查看time模块是否在内存中
import sys
print("time" in sys.modules)     
'''

三.__all__作用

__all__是针对from xx import *的，是指定调用的对象，如下例子，a.py中调用b.py中的指定对象

# a.py
from b import *
fun1()
fun2()
fun3()     # 执行fun3()会报错，因为没有调用

# b.py

__all__ = ["fun1","fun2"]      # 指定被调用的对象
def fun1():
    print("fun1")
def fun2():
    print("fun2")
def fun3():
    print("fun3")

四.time模块

time模块中对于时间可以分为三种形式：

  1. 时间戳：表示的是格林尼治时间是从1970-1-1 00:00:00开始按秒计算的偏移量，返回float类型
  2. 格式化字符串时间："1995-06-06"
  3. 结构化时间：元组(struct_time)共有9个元素(年、月、日、时、分、秒、一周中的第几天、一年中的第几天等)

time模块调用其他方式的详解

import time
time.time()      #时间戳 1500875844.800804
time.strftime("%Y-%m-%d %X")   #格式化时间 2019-08-10 18:20:00
time.strftime("%Y-%m-%d %H-%M-%S")  #格式化时间 2019-08-10 18:20:00
time.locatime()  #结构化时间
'''
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)
'''

时间格式转换

# 时间戳---> 结构化时间
time.gmtime(时间戳)   #UTC时间，与英国伦敦当地时间一致
time.localtime(时间戳) #当地时间 UTC时间+8小时=北京时间
'''
time.gmtime(1500000000)
结果：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)
'''

# 结构化时间---> 时间戳
time.mktime(结构化时间) 
'''
time.mktime(time_tuple)
结果:'2017-07-24 14:55:36'
'''

# 字符串时间--->结构化时间
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)
'''

五.datetime模块

http://39.97.99.7/python/datetime.html

六.random模块

# http://39.97.99.7/python/random.html
import random 
random.random()    		  #大于0且小于1之间的小数
random.uniform()   		  #大于1小于3的小数
random.randint(1,4)        #大于等于1且小于等于4之间的整数
random.randrange(1,10,2)   #大于等于1且小于10之间的奇数
random.choice([1,'23',[4,5]])  #1或者23或者[4,5]
random.choices([1,"23",[4,5]],2) #列表元素任意2个组合会出现重复
random.sample([1,'23',[4,5]],2) # #列表元素任意2个组合不会出现重复
item=[1,3,5,7,9]
random.shuffle(item) # 打乱次序

七.序列化模块(json)

定义

序列化：将特殊数据类型转化为一种中间格式（例如：将dict转为str存入文件）
反序列化：将中间格式转为其可接受的数据类型

json支持的数据类型

dict ,list ,tuple ,str,int,float,True,False,None

各种语言的数据类型表示方式不一，如java中的null、true、false，与之相对应的python中的就表示为None,True,False，那么怎么将java中的一些数据类型转为python中可以识别的呢？看下面例子：

x = "[null,true,false]"
print(eval(x))

以上数据类型在java中适用，eval将其转为python对象后，python是不识别的，由此，就引入了json

json总共有两对四个方法：

用于网络传输：dumps、loads

用于文件写读：dump、load

dumps,loads

  1. 将字典类型转为字符串类型
import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic)  #序列化：将一个字典转换成一个字符串
print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
#注意，json转换完的字符串类型的字典中的字符串是由""表示的
  1. 将字符串类型转为字典类型
import json
dic2 = json.loads(str_dic)  #反序列化：将一个字符串格式的字典转换成一个字典
#注意，要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
print(type(dic2),dic2)  #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

dump、load

  1. 将对象转为字符串写入到文件中
import json
f = open('json_file.json','w',encoding="utf-8")
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)  #dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
# json.dump([1,2,3,"你好"],f,ensure_ascii=False)写入文件时中文乱码，ensure_ascii=False可解决
f.close()
# json文件也是文件，就是专门存储json字符串的文件。
  1. 将文件中的字符串类型转为字典
import json
f = open('json_file.json')
dic2 = json.load(f)  #load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2)

八.序列化模块(pickle)

1.python语言遵循的一种数据转化格式，只能在python语言中使用。
2.支持python所有数据类型包括实例化对象。
3.和json用法方式相同（两对四个）

九.序列化模块(shelve)

比json更高级的序列化,类似于字典的操作方式

import shelve
info = {"age":16,"height":133,"weight":55}
info2 = {"age":20,"height":190,"weight":90}

# 序列化(会生成3个文件:db.shv.bak,db.shv.dat,db.shv.dir)
d = shelve.open("db.shv")
d["egon"] = info
d["alex"] = info2

# 反序列化
d = shevle.open("db.shv")
print(d["egon"],type(d["egon"]))  #{'age': 16, 'height': 132, 'weight': 55} <class 'dict'>
print(d["alex"],type(d["alex"]))  #{'age': 11, 'height': 178, 'weight': 90} <class 'dict'>
print(list(d.keys()))    #['egon','alex']

十.os模块

os模块是与操作系统交互的一个接口，它提供的功能多与工作目录，路径，文件等相关。

  1. 工作目录
import os
print(os.getcwd())                  # 当前工作路径
os.chdir("E:\project\oldboy\day13") # 路径切换
  1. 文件夹
import os
os.mkdir("ttt")        		#创建一个文件夹
os.rmdir("ttt")        		#删除文件夹
os.makedirs("ttt/sss/ddd")   #递归创建文件夹
os.removedirs("ttt/sss/ddd") #递归删除文件夹
print(os.listdir(r"E:\project\oldboy\day13"))   #查看子文件
  1. 文件
import os
os.rename()        # 修改名字
os.remove("info")  # 删除文件
  1. 路径
import os
print(os.path.abspath("作业.py"))  #通过相对路径获取绝对路径
# E:\project\作业.py
print(os.path.split(os.path.abspath("作业.py")))  #将路径最后一个\切割(路径，文件名)
# [E:\project,作业.py]
print(os.path.dirname("E:\project\作业.py"))  #获取路径
# E:\project
print(os.path.basename("E:\project\作业.py")) #获取文件名
# 作业.py
print(os.path.exists("E:\project\作业.py"))   #判断路径是否存在
print(os.path.isdir("E:\project"))    #判断是否是路径(路径是否存在)
print(os.path.isfile("作业.py"))      #判断是否是文件
print(os.path.isabs("E:\project\作业.py")) #判断是否是绝对路径
os.path.join("D:\\","ttt","bbb")    #路径拼接


import time 
print(os.path.getatime("E:\project\作业.py"))  #最后的修改时间
print(os.path.getctime("E:\project\作业.py"))  #最后的访问时间
print(os.path.getmtime("E:\project\作业.py"))  #最后的访问时间
print(os.path.getsize("E:\project\作业.py"))   #获取文件大小

十一.sys模块

sys --- 与python解释器交互的接口

参考链接：https://blog.csdn.net/KnownAll/article/details/81560050

import sys
print(sys.argv)   # 获取命令行参数
sys.exit(0)       # 退出
# sys.exit(1)
sys.version       #获取解释器版本
sys.path          #自定义模块查找路径
# sys.path.append()
sys.platform      #（返回当前系统的平台标识）区分操作系统然后进行相关操作

十二.hashlib模块

hash:hash是一种算法，算法接受传入的内容，经过运算得到一串固定长度的hash值

初始

1.只要传入的内容相同，得到的hash值必然相同(文件完整性校验，读取下载的文件，将其哈希，得到的哈希值和文件携带的哈希值比较，如果相同，则文件相同)
2.不能由hash值反解成内容（把密码做成hash值，不要明文传输密码）
3.只要使用的hash算法不变(md5,sha1,sha256,sha512等),无论校验的内容多大，得到的hash内容长度固定。

由上可知，可哈希不可变的解释：因为hash值相同，内容一定相同。举个例子，传入的内容是一个集合，集合是可变的，假如密码是一个集合，那么第一次转化成的hash值存入数据库，之后再输入密码，不一定能对应数据库中的哈希值。

hashlib的特征及其使用要点：

1.bytes类型数据-->通过hashlib算法-->固定长度的字符串
2.相同的加密方式，不同的编码格式，得到的hash值也是相同

简单例子

import hashlib
lib = hashlib.md5()              #新建一个加密工厂
pwd = "root"
lib.update(pwd.encode("utf-8"))  #工厂将要加密的内容处理成hash值
print(lib.hexdigest())           #得到hash值

密码加盐

import hashlib
lib = hashlib.md5()
before_pwd = "天王盖地虎"
pwd = "root"
after_pwd = "林家大小姐"

lib.update(before_pwd.encode("utf-8"))
lib.update(pwd.encode("uft-8"))
lib.update(after_pwd.encode("utf-8"))

print(lib.hexdigest())

文件校验

文件校验方法：读取文件，将得到的数据（转换成bytes类型）通过md5加密得到hash值，将此哈希值和给定的哈希值进行比较，一般都是通过文件大小来比较。

with open(file,mode="rb") as f:
    ret = hashlib.md5()
    ret.update(f1.read())         
    print(ret.hexdigest())

十三.collections模块

namedtuple

生成可以使用名字来访问元素内容的tuple

from collections import namedtuple
Test = namedtuple("Test",["x","y","z","g"])
s = Test(1,3,4,6)
print(s)           # Test(x=1,y=3,z=4,g=6)
print(tuple(s))    # (1,3,4,6)

deque

使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低

deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈

from collections import deque
q = deque(['a','b','c'])
q.append("x")
q.appendleft("y")
print(q)          # deque(['y', 'a', 'b', 'c', 'x'])

OrderedDict

使用dict时，key是无序的。在对dict做迭代时，我们无法确定key的顺序，如果要保持key的顺序，可使用OrderedDict

from collections import OrderedDict
d = dict([('a',1),('b',2),('c',3)])
print(d)     # {'a': 1, 'c': 3, 'b': 2}

od = OrderedDict([('a',1),('b',2),('c',3)])
print(od)    # OrderedDict([('a', 1), ('b', 2), ('c', 3)])

defaultdict

使用dict时，如果引用的key不存在，就会抛出KeyError，如果key不存在，使用defaultdict，就返回一个默认值

from collections import defaultdict
dd = defaultdict([])  #相当于给每个key值赋值[]
print(dd["key1"])   # []

有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。

from collections import defaultdict
values = [11,22,33,44,55,66,77,88,99]
my_dict = defaultdict([])
for value in values:
    if value > 66:
        my_dict['key1'].append(value)
    else:
        my_dict['key2'].append(value)

Counter

Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。

from collections import Counter
c = Counter('abdkdkwwwfdfdfersfsfs')
print(c)   #Counter({'f': 5, 'd': 4, 'w': 3, 's': 3, 'k': 2, 'a': 1, 'b': 1, 'e': 1, 'r': 1})

十四.re模块

元字符

匹配模式 参考:http://39.97.99.7/python/re.html

import re
# \w 匹配字母、中文、数字、下划线(匹配不到返回[])
name = "宝元-meet_123"
print(re.findall("\w",name))  #['宝', '元', 'm', 'e', 'e', 't', '_', '1', '2', '3']

# \W 匹配非字母、中文、数字、下划线(匹配不到返回[])
name1 = "宝元-\t\n"
print(re.findall("\W",name1))  #['-', '\t', '\n']

# \s 匹配任意空白符
name2 ="宝元-\t\n"
print(re.findall("\s",name2))  #['\t', '\n']

# \S 匹配任意的非空白符
name3 ="宝元-\t\n"
print(re.findall("\S",name3))  #['宝', '元', '-']

# \d匹配数字
name4 = "宝元-meet-123"
print(re.findall("\d",name4))  #['1', '2', '3']

# \D匹配非数字
name5 = "宝元-meet-123"
print(re.findall("\D",name5))  #['宝', '元', '-', 'm', 'e', 'e', 't', '-']

# \n匹配换行符
name6 = "宝元-meet-123\t\n"
print(re.findall("\n",name6))  # \n

# \t匹配制表符
name7 = "宝元-meet-123\t\n"
print(re.findall("\t",name7))  # \t

# ^从开头开始匹配(如果是则返回，没有返回[])
name8 = "宝元"
print(re.findall("^元",name8)) # []

# $从尾部开始匹配
name9 = "龅牙"
print(re.findall("牙$",name9)) # ['牙']



import re

# .匹配任意字符(换行符除外),加上参数re.DOTALL匹配任意字符
name = "宝元_123\t\n"
print(re.findall(".",name))  # ['宝', '元', '_', '1', '2', '3', '\t']
print(re.findall(".",name,re.DOTALL)) #['宝', '元', '_', '1', '2', '3', '\t', '\n']

# ?匹配前一个元素0或1个
name1 = "m-e-me-meet\t\n"
print(re.findall("me?",name1))  #['m', 'me', 'me']


# *匹配前一个元素0或多个(贪婪匹配)
name2 = "m-e-me-meet\t\n"
print(re.findall("me*",name2)) # ['m', 'me', 'mee']

# +匹配前一个元素1或多个(贪婪匹配)
name3 = "m-e-me-meet\t\n"
print(re.findall("me+",name3)) # ['me', 'mee']

# {m,n}匹配m到n个元素
name4 = "m-e-me-meet\t\n"
print(re.findall("e{1,2}",name4))  #['e', 'e', 'ee']

# .*匹配任意内容0或多个
name5 = "m-e-me-meet\t\n"
print(re.findall("m.*e",name5))  #['m-e-me-mee']

# .*?匹配任意内容0或1个
name6 = "m-e-me-meet\t\n"
print(re.findall("m.*?e",name6)) #['m-e', 'me', 'me']

# []获取括号中的内容
name7 = "m-e-me-meet-meet_123"
print(re.findall("[0-9]",name7)) #['1', '2', '3']

name8 = "m-e_123"
print(re.findall("[a-z]",name8)) # ['m', 'e']

name9 = "m-eDgGH"
print(re.findall("[a-zA-Z]",name9)) #['m', 'e', 'D', 'g', 'G', 'H']

# ^在[]中是非的意思
name10 = "m-eDgGH"
print(re.findall("[^a-z]",name10)) #['-', 'D', 'G', 'H']

十五.包

文件夹下有__init__.py方法的，此文件夹就是包。
参考文献：http://39.97.99.7/python/最新版模块和包.html

十六.logging模块

参考文献:https://www.cnblogs.com/linhaifeng/articles/6384466.html#_label12

十七.configparser模块

参考文献：https://www.cnblogs.com/linhaifeng/articles/6384466.html#_label9

十八.schedule定时器模块

https://www.cnblogs.com/longsongpong/p/10998619.html

posted @ 2019-07-26 21:49  MISF  阅读(492)  评论(0)  编辑  收藏  举报
　　 　　JS过度和变形效果演示 　　
　　
　　　　html5.png