python模块知识总结

目录

• 模块总结
  • 模块基础知识
    • 什么是模块
    • .py文件的两种功能(模块和脚本)
    • 模块的三大类
    • 四种形式
  • 模块的导入方式
    • import 模块名
    • from 模块 import *
    • from 模块 improt 方法
    • import 模块名 as 别名
  • 模块搜索顺序
  • 常用的模块
    • time模块
    • dtaetime模块
    • sys模块
    • os模块
    • random模块
    • 序列化模块
      • json模块
      • pickle模块
    • haslib模块
    • collections模块

模块总结

模块基础知识

什么是模块

• 模块是一系列功能的集合体，它包含了python定义和声明的一些文件，我们所写的文件名就是模块名加上.py后缀。

• 模块的作用

  • 可以拿别人已经写好的模块直接用就行，这样可以用来提高开发效率
  • 对于我们自己写的模块(自定义模块)便于管理和维护

.py文件的两种功能(模块和脚本)

• 脚本：一个文件就是一个程序，用来被执行的，就如我们平常在pycharm上执行的.py文件
• 模块：文件中存放在一系列功能的集合，用来被导入使用
• python提供了一个内置函数来帮助我们判断py文件a是脚本还是模块( __ name __)
  • 脚本时:__ name __ = '__ main __'
  • 模块时:__ name __ = '模块名'

模块的三大类

• 内置模块(c/c++写的)：也叫标准库，这是python解释器提供的，大概有200多个，如time，os，sys模块等等
• 第三方库(模块)：这是python大牛发表在python社区并被采纳，从而可以给全世界的python程序员下载使用的模块，通过pip install 模块名即可下载
• 自定义模块：这是我们自己在项目中定义编写的一些模块，它本质就是一个.py文件。包含可执行语句，变量定义，函数定义等等，这些统称为模块成员

四种形式

• 使用python编写的.py文件
• 已被编译为共享库或者DLL的c/c++的扩展
• 把一系列模块组织到一起的文件夹（包）
• 使用c编写并链接到python解释器的内置模块

模块的导入方式

import 模块名

• 第一次导入模块会执行三件事
  • 创建一个以模块名命名的名称空间
  • 将模块中的所有可执行代码加载到该空间中
  • 通过模块名.方法的方式引用模块中的内容(调用一次模块的属性和方法就会执行一次模块的可执行语句)

from 模块 import *

• 将模块中不是以下划线__头的名字都导入当前名称空间
  • 我们一般不提倡这种方式，因为我们不知道模块中存在什么属性和方法，如果属性名与我们自己定义的变量名或者函数名一致，就会造成不可想象的后果
  • 我们可以使用__ all __ (__ all __ =[ ])的方式控制哪些属性和方式可以被导入到名称空间中

from 模块 improt 方法

• from turtle import penup,pendown等方法

import 模块名 as 别名

• import datetime as d:建议长的模块名我们可以使用起别名的方式进行操作

模块搜索顺序

• 已经加载到内存中的模块——>>内置模块——>>sys.path路径下的模块列表

  • 在第一次导入模块时，系统会帮我们检测该模块是否已经被导入到内存中了，如果已将被导入了就直接引用内存中的模块(python解释器在启动时会自动将一些模块加载到内存中，我们可以通过sys.modules去查看(结果为一个字典))
  • 如果没有在内存中找到就去查看有没有同名的内置模块（所以我们编写自定义模块时尽量不要使用与系统同名的模块名）
  • 如果还是没有就去sys.path路径下去寻找(一般我们自定义模块会在sys.path路径下)，我们也可以通过sys.path.append(os.path.dirname(__ file __)+'模块名'的方式去将模块添加进去)

  import sys
  import os
  print(__file__)  #D:/pycharm软件/YZH_python/a.日常Py练习/随便练练.py
  print(os.getcwd())  #D:pycharm软件YZH_pythona.日常Py练习
  print(os.path.dirname(__file__))  #D:pycharm软件YZH_pythona.日常Py练习
  

常用的模块

time模块

* time.time():获取当前的时间戳，从计算机元年(1970年1月1日00:00:00)到现在经过的秒数
* time.ctime():以易读的字符串形式显示时间
* time.mktime(结构化时间time.localtime()):将结构化时间转化为时间戳
* time.gmtime():结构化的欧洲时间对象
* time.localtime():结构化的中国时间对象
* time.strftime(format,time.localtime()):将结构化时间转化为格式化时间
* time.strptime(格式化时间,format):将格式化时间转化为结构化时间
* time.sleep(s):设定休眠时间
* time.perf_count():返回一个级别的精确时间，单位为(s)

import time
#获取时间戳
print(time.time())   #1589466786.2855313
print(time.ctime())  #Thu May 14 22:33:06 2020

#将结构化时间对象转化为时间戳
print(time.mktime(time.localtime()))  #1589466786.0

#获取结构化时间对象
print(time.gmtime())     #time.struct_time(tm_year=2020, tm_mon=5, tm_mday=14, 		    tm_hour=14, tm_min=33, tm_sec=6, tm_wday=3, tm_yday=135, tm_isdst=0)
print(time.localtime())  #time.struct_time(tm_year=2020, tm_mon=5, tm_mday=14, tm_hour=22, tm_min=33, tm_sec=6, tm_wday=3, tm_yday=135, tm_isdst=0)

#将结构化时间对象转化为格式化时间对象
s=time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
print(s)  #2020-05-14 22:33:06

#将格式化结构对象转化为结构化时间对象
time_obj=time.strptime(s,'%Y-%m-%d %H:%M:%S')
print(time_obj)  #time.struct_time(tm_year=2020, tm_mon=5, tm_mday=14, tm_hour=22, tm_min=33, tm_sec=6, tm_wday=3, tm_yday=135, tm_isdst=-1)

dtaetime模块

*now=datetime.datetime.now():获取现在的时间
*datetime.datetime.date(now):获取当天的日期对象
*datetime.datetime.time(now):获取当天的时间对象
*datetime.timedelta(t=num):调整时间 t为weeks,days,hours,minutes,seconds
*datetime.datetime.now().replace(t=num,...):直接将时间调整,t为year,month,day,hour,minute, 															second
*datetime.datetime.fromtimestamp(时间戳):将时间戳转化为格式化时间(年-月-日 时:分:秒)
*datetime.date.fromtimestamp(时间戳):将时间戳转化为格式化时间(年-月-日)
*datetime.datetime.timestamp(格式化时间now):将格式化时间转化为时间戳

#获取当天的日期，时间
now_time=datetime.datetime.now()
print(now_time)   #2020-05-14 23:07:08.556418

#修改日期时间
print(now_time+datetime.timedelta(weeks=1))  #2020-05-21 23:07:08.556418
print(now_time+datetime.timedelta(weeks=-1)) #2020-05-07 23:07:08.556418
print(now_time.replace(year=1995,month=10,day=3)) #1995-10-03 23:07:08.556418

#将时间戳转化为时间
print(datetime.datetime.fromtimestamp(89899798))  #1972-11-06 20:09:58
print(datetime.date.fromtimestamp(89899798))      #1972-11-06

#将格式化时间转化为时间戳
print(datetime.datetime.timestamp(now_time))      #1589468828.556418

#其他
print(datetime.date(1995,10,3))     #1995-10-03
print(datetime.time(23,3,21))       #23:03:21
print(datetime.datetime(1995,10,3,23,3,21)) #1995-10-03 23:03:21

#format格式
%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 当前时区的名称
%% %号本身

sys模块

• sys模块是于python解释器交互的窗口

*sys.argv:命令行参数list，主要与windows命令框交互，存放的第一个元素是程序本身的路径，可以直接在windows命令框输入代码由python解释器执行
*sys.exit(n):退出程序，正常退出为exit(0)，错误退出为exit(-1)
*sys.version:获取python解释器的版本信息
*sys.platform:返回系统操作平台的名称
*sys.moudles:获取加载到内存中的模块(字典)
*sys.path:返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

os模块

• os模块是与操作系统交互的一个接口

#1.当前执行这个python文件的工作目录相关的工作路径
*os.getcwd():获取当前工作目录，即当前python脚本工作的目录路径  
*os.chdir("dirname"):改变当前脚本工作目录；相当于shell下cd  
*os.curdir:返回当前目录: ('.')  **
*os.pardir:获取当前目录的父目录字符串名：('..') 
    
#2.与文件夹相关的操作
*os.makedirs('dirnames'):创建一个多次递归目录
*os.removedirs('dirnames'): 删除一个空文件夹，如上层目录也为空也删除上层文件夹
*os.mkdir('dirname'):创建一个单级目录
*os.rmdir('dirname'):删除一个空目录
*os.listdir(path):查看当前路径下一层路径的所有文件和文件夹,包含隐藏文件/文件夹,以列表方式打印
*os.walk(path):，返回一个生成器，它会寻找该路径下的所有文件夹与文件，返回一个元组(路径，[文件夹],[文件]) 第一个元组是(本身的路径，[本身路径下的文件夹]，[本身路径下的文件])
*os.stat(path):返回一个对象，包含文件或文件夹的信息。可以通过.的方法查看信息

#3.与文件相关的操作
*os.rename(oldname,newname):重命名文件/目录(文件夹)
*os.remove(file):删除文件

#4.与路径相关的操作(path子模块)
*abs_path=os.path.abspath(path):返回绝对路径
*os.path.realpath(path):返回相对路径
*os.path.split(abs_path):将路径切分为父路径和子路径
*os.path.dirname(abs_path):返回路径的父路径
*os.path.basename(abs_path):返回路径的子路径
*os.path.join(父路径，子路径):将父路径和子路径拼接
*os.path.exists(path):判断path是否存在，存在就返回True,不存在就返回False
*os.path.isabs(path):判断path是否为绝对路径，是就返回True,不是就返回False
*os.path.isfile(path):判断path是否为文件，是就返回True,不是就返回False
*os.path.isdir(path):判断path是否为文件夹，是就返回True,不是就返回False
*os.path.getatime(path):返回path所指向的文件或者目录的最后访问时间
*os.path.getmtime(path):返回path所指向的文件或者目录的最后修改时间 
*os.path.getctime(path):返回path所指向的文件或者目录的创建时间 
*os.path.getsize(path):返回path的大小

#5.和操作系统差异相关
*os.sep    输出操作系统特定的路径分隔符，win下为"\",Linux下为"/" 
*os.linesep    输出当前平台使用的行终止符，win下为"	
",Linux下为"
" 
*os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为: 
*os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix' 

#6.和执行系统命令相关
*os.system("bash command"):运行shell命令，直接显示  
*os.popen("bash command).read():运行shell命令，获取执行结果  
*os.environ:获取系统环境变量 
*os.urandom(n):返回一个适合加密的n字节大小的字节字符串

random模块

*random.seed(n):设置一个随机种子
*random.random():返回一个(0,1)的浮点数
*random.randint(n,m):返回一个[n,m]的整数
*random.randrange(n,m):返回一个(n,m)的整数
*random.getrandbit(k):返回一个kbit长的随机整数
*random.uniform(n,m)::返回一个[n,m]的浮点数
*random.shuffle(seq):将seq序列中的元素随机打乱返回
*random.choice(seq):从seq序列中随机返回一个元素

序列化模块

• 序列化过程：将内存中的数据转化为字节串，用以保存在文件中或通过网络进行传输
• 反序列化过程：将从文件，网络中获取到的数据转换成原本的数据类型

json模块

• Json(javascript object notation):java 脚本兑换标记语言：是一个简单的数据交换格式
  • 将数据转化为字符串，用于存储或网络传输

python数据类型	json数据类型	python数据类型(反序列化)
tuple，list	array(数组)	list
dict(键不能是元组)	object(对象)	dict(键都变为字符串)
set	不支持(set)	——
int,float,bool	num(int)	int,float,bool
None	null	None
True	true	True
False	false	False

#非文件类操作(py_obj为python的数据类型,json_obj为json的数据类型)
*json.dumps(py_obj):将python数据类型转化为json数据类型
*json.loads(json_obj):将json数据类型转化为python数据类型
    
#文件操作(不可以对一个文件多次序列化)
*json.dump(py_obj,f,ensure_ascii=True):将python数据类型转化为json数型，ensure_ascii=True:只接受Ascii表的数据类型(不支持中文)，ensure_ascii=False:接受非Ascii表的数据类型(支持中文)，默认为True。
*json.load(f):将json数据类型转化为python数据类型

import json
ls=[1,2,3]
tp=(1,2,3)
s='yzh'
a=1
dic1={1:'yzh',2:'raorao'}
dic2={'name':"yzh",2:1}
ret1=json.dumps(ls)
ret2=json.dumps(tp)
ret3=json.dumps(s)
ret4=json.dumps(a)
ret5=json.dumps(dic1)
ret6=json.dumps(dic2)
print(ls,ret1,json.loads(ret1),sep='--->>>')
print(tp,ret2,json.loads(ret2),sep='--->>>')
print(s,ret3,json.loads(ret3),sep='--->>>')
print(a,ret4,json.loads(ret4),sep='--->>>')
print(dic1,ret5,json.loads(ret5),sep='--->>>')
print(dic2,ret6,json.loads(ret6),sep='--->>>')
#None,True,False
r1,r2,r3=json.dumps(None),json.dumps(True),json.dumps(False)
print(json.loads(r1),json.loads(r2),json.loads(r3))

• 对于json不能在文件中多次存取的问题设计了如下的程序解决：

import json
def f_write(f,content):
    f.write(json.dumps(content) + '
')
content1='hello'
content2='world'
with open('yzh','at',encoding='utf-8') as f1:
    f_write(f1,content1)
    f_write(f1,content2)
with open('yzh','rt',encoding='utf-8') as f1:
    for line in f1:
        print(json.loads(line.strip()))

pickle模块

• 将python中所有数据类型和对象转化为bytes类型，用以文件存储或网络传输

*#非文件类操作(py_obj为python数据类型,json_obj为bytes数据类型)
*pickle.dumps(py_obj):将python数据类型转化为bytes数据类型
*pickle.loads(bytes_obj):将bytes数据类型转化为python数据类型

#文件操作(可以对一个文件中多次序列化)
*pickle.dump(py_obj,f):将python数据类型转化为bytes数型
*pickle.load(f):将bytes数据类型转化为python数据类型

• json与pickle对比：
  • json不能将所有的python数据类型序列化，但pickle可以将所有python数据类型序列化
  • json不能对一个文件多次序列化，但pickle可以
  • json可以跨语言，pickle不能跨语言

haslib模块

• 封装了一些用于加密的类，其中包含多种算法(摘要算法，哈希算法等)，用于加密和校验使用，如md5，sha1，sha224，sha256算法等，结果越长数据越安全，但相应加密时间长
  • md5算法最终结果位32位16进制字符串
  • sha1算法最终结果位40位16进制字符串
  • sha224算法最终结果位56位16进制字符串
  • sha256算法最终结果位56位16进制字符串
• 工作原理
  • 通过一个函数将任意长度的bytes数据按一定规则转化为特定长度的字符串(一般为16进制)
• 特点
  • 把一个大的数据切分成多块，对多块数据进行分别加密再汇总后的结果与对大数据直接加密所得结果一致
  • 单向不可逆性
  • 原始数据发生一点变化将导致最终结果完全不同(雪崩效应)
• 对一个数据进行加密有三个步骤
  • 获取加密对象
  • 对该加密对象进行update( )，可进行多次update()
  • 利用对象名.hedigest()或对象名.digest()得方法获取最终加密结果

import hashlib
md=hashlib.md5()  #获取加密对象md
md.update('helloworld'.encode('utf-8'))  #对md进行update()，注意要为bytes类型
print(md.hexdigest())   #获取加密数据(结果为32位16进制字符串)
print(md.digest())      #获取加密数据(结果为16进制bytes数据类型)

#为了数据得进一步安全(如网络传输中被人截获),因此可以进行加盐处理
md=hashlib.md5('yzh'[:2].encode('utf-8'))   #加盐(salt)处理
md.update('hello'.encode('utf-8')) 
md.update('world'.encode('utf-8')) 
print(md.hexdigest()) 

collections模块

• python在原有数据类型基础之上，新增加了多种数据类型(如nametuple，deque，Counter，defaultdict，OrderDict等)，这些数据类型都放在collections模块中
  • nametuple：生成一个可以使用名字来访问元素内容的tuple
  • deque:双端队列，可以快速从两侧插入或者删除数据
  • Counter：计数器，主要用来统计数据出现次数
  • defaultdict：带默认值字典
  • OrderDict：有序字典
• nametuple

from collections import namedtuple
person=namedtuple('person',['height','weight'])  #'person'仅用于描述
p=person(180,74)
print(p.height,p.weight)

• deque
  • 我们平常使用列表进行按索引查找和修改时操作时间很短，但进行删除和增加操作时会很费时间，尤其在数据很多的情况下时，所以我们可以使用deque来进行增加和删除的操作

#append(),appendleft(),pop(),popleft()
from collections import deque
q=deque([1,2,3])
q.append(4)
print(q)
q.appendleft(0)
print(q)
q.pop()
print(q)
q.popleft()
print(q)
print(list(q))

• Counter
  • 对出现的数据进行累加计数，最后按出现次数从大到小的顺序用字典方法输出

from collections import Counter
s='huihihuguyhiopiyh'
c=Counter(s)
print(c)
for i in range(2):
    print(c.most_common(2)[i][0])

• defaultdict

from collections import defaultdict
def fun():
    return 'hello'
d=defaultdict(fun,name='yzh',age=18)
print(d['name'])
print(d['language'])
print(d)

• OrderDict
  • 字典类型在3.6版本之前是无序的，所以可以使用OrderDict来使字典有序

from collections import OrderedDict
d=OrderedDict()
d['y']=1
d['z']=2
d['h']=3
print(d)
for key in d:
    print(key,d[key],sep=':')