标签：tm 模块 time print import os

目录

• 一.模块分类
• 二.模块的查找顺序
• 三.__all__作用
• 四.time模块
• 五.datetime模块
• 六.random模块
• 七.序列化模块(json)
• 八.序列化模块(pickle)
• 九.序列化模块(shelve)
• 十.os模块
• 十一.sys模块
• 十二.hashlib模块
• 十三.collections模块

一.模块分类

在python中，模块分为三类。

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

二.模块的查找顺序

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

1. 内存中已经加载的模块(sys.modules)
2. 内置模块(python解释器自带的)
3. sys.path路径中包含的模块(自定义模块、第三方模块)

# 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'>

十.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})

标签：tm,模块,time,print,import,os
来源： https://www.cnblogs.com/gaoyukun/p/11253110.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。