“import 模块名”和”from 模块名 import *“的区别：
第一种方式在调用模块成员时，必须使用模块名作为前缀。不容易产生命名冲突
第二种方式在调用模块成员时，直接使用成员名即可。容易产生命名冲突（产生命名冲突时，在后面命名的成员生效）
# 比如在调用time模块时
# 第一种调用方式
import time
# 此时获取当前时间需以模块名作为前缀
t = time.time()
# 第二种方式调用时
from time import *
# 这种调用方式不需要以模块名作为前缀
t_1 = time()
# 命名冲突可以如下理解
a = 1
a = 2 # 此时变量a与之前的命名a=1冲突，会将1覆盖
print(a) # 2
# 这种情况在调用模块函数时作用机制相同
这个时候可以使用以下方法解决命名冲突：
改用import 模块名的方式导入模块
在代码编写种避免使用同名
使用别名避免冲突(from 模块名 import 方法名 as 别名/import 模块名 as 别名)
# 假设此时time函数出现冲突，可以使用别名
from time import time as tt
t_1 = tt()
使用**from 模块名 import ***时控制成员被导入：默认情况下，该模块所有的成员都会被导入。__all__是一个列表，用于表示本模块可以被外界使用的成员。元素是成员名的字符串。（这个机制只适用于这种导入模块的方式）
Random模块提供了和随机数获取相关的方法：
# random模块种常用的方法
import random
# random.random():获取[0.0,1.0)之间的随机浮点数
print(random.random()) # 0.05839914059448895
# random.randint(a,b):获取[a,b]之间的随机整数
print(random.randint(0,100)) # 87
# random.uniform(a,b):获取[a,b)之间的随机浮点数
print(random.uniform(0,5)) # 1.4588304571823811
# random.shuffle(x):把参数中的元素打乱。参数必须是一个可变的数据类型
li_1 = list(range(10))
random.shuffle(li_1)
print(li_1) # [2, 7, 3, 1, 0, 8, 9, 6, 5, 4]
# random.sample(x,k):从x中随机抽取k个数据，组成一个列表返回
li_2 = random.sample(li_1,5)
print(li_2) # [1, 9, 0, 6, 5]
time模块中提供了获取时间轴和字符串形式时间的方法
import time
# 获取时间戳
# 时间戳：从时间元年(1970.01.01 00:00:00)到现在经过的秒数
print(time.time()) # 1585290979.1096168
# 获取格式化时间对象：九个字段组成
print(time.gmtime()) # GMT 格林尼治平太阳时间
# time.struct_time(tm_year=2020, tm_mon=3, tm_mday=27, tm_hour=6, tm_min=41, tm_sec=52, tm_wday=4, tm_yday=87, tm_isdst=0)
print(time.localtime()) # 当地时间
# time.struct_time(tm_year=2020, tm_mon=3, tm_mday=27, tm_hour=14, tm_min=46, tm_sec=37, tm_wday=4, tm_yday=87, tm_isdst=0)
# 格式化时间对象向字符串转换
s = time.strftime(‘nowtime:%Y %m %d %H:%M:%S‘)
print(s) # nowtime:2020 03 27 14:52:34
# 字符串向格式化时间对象转换
time_obj = time.strptime(‘2020 3 27‘,‘%Y %m %d‘)
print(time_obj)
# time.struct_time(tm_year=2020, tm_mon=3, tm_mday=27, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=87, tm_isdst=-1)
# 暂停当前进程
time.sleep(1) # 当前进程暂停一秒
总的老说，time模块中总共由三大对象：
datetime是日期时间模块，模块里面封装了一些和日期时间相关的类。datetime中的类主要是用于数学计算的。
date类：
import datetime
# 构建一个date类的实例
d = datetime.date(2020,3,27) # 此时d是一个date类的实例
print(d) # 2020-03-27
# 获取date对象的各个属性
print(d.year) # 2020
print(d.month) # 3
print(d.day) # 27
time类：
import datetime
# 构建一个time类的实例
t = datetime.time(15,15,15) # 此时t是一个time类的实例
print(t) # 15:15:15
# 获取time对象的各个属性
print(t.hour) # 15
print(t.minute) # 15
print(t.second) # 15
datetime类：
import datetime
dt = datetime.datetime(2020,3,27,15,15,15)
print(dt) # 2020-03-27 15:15:15
# datetime有以上六种属性
timedelta类:时间的变化量
import datetime
td = datetime.timedelta(days=1)
print(td) # 1 day, 0:00:00
# 参与数学运算
# 创建时间对象
d = datetime.date(2020,3,27)
# 让日期增加一天
res = d + td
print(res) # 2020-03-28
# 检验时间变化量计算的进位
t = datetime.time(15,15,59)
td1 = datetime.timedelta(seconds=2)
print(t+td1) # 结果显示无法计算
# TypeError: unsupported operand type(s) for +: ‘datetime.time‘ and ‘datetime.timedelta‘
# 修改：
t = datetime.datetime(2020,3,27,15,15,59)
td1 = datetime.timedelta(seconds=2)
print(t+td1) # 2020-03-27 15:16:01
# 时间运算确实存在进位
os模块：封装了和操作系统相关的操作
import os
# 和文件相关的操作：重命名，删除等
os.remove(r‘file_path‘) # file_path是字符串形式的文件路径
os.rename(‘原文件名‘,‘新文件名‘) # 不改变文件内容
# 删除目录，必须是空目录
os.removedirs(‘文件夹名‘) # os中的删除目录命令只能删除空目录
# 如果要删除带内容的目录，可以使用shutil模块
import shutil
shutil.rmtree(‘要删除的目录路径‘)
和路径相关的操作，被封装到了另一个子模块中：os.path
import os
# 获取文件路径
os.path.dirname(r‘文件路径‘) # 不判断路径是否存在
# 示例
res = os.path.dirname(r‘C:/aaa/bbb/ccc/a.txt‘)
print(res) # C:/aaa/bbb/ccc
# 获取文件名
res_1 = os.path.basename(r‘C:/aaa/bbb/ccc/a.txt‘)
print(res_1) # a.txt
# 分离路径中的路径名和文件名，返回一个元组
res_2 = os.path.split(r‘C:/aaa/bbb/ccc/a.txt‘)
print(res_2) # (‘C:/aaa/bbb/ccc‘, ‘a.txt‘)
sys模块：和python解释器相关的操作
import sys
# 获取命令行方式运行的脚本后面的参数
print(sys.argv[0]) # 脚本名
print(sys.argv[1]) # 第一个参数
# 解释器寻找模块的路径
sys.path
# 返回系统中已经加载的模块
sys.modules
json已经成为一种简单的数据交换形式。
序列化：将内存中的数据，转换成字节串，用以保存在文件或网络传输，称为序列化过程。
反序列化：将从文件或网络中获取的数据转换成内存中原来的数据类型，称为反序列化过程。
json：将数据转换成字符串，用于存储或网络传输。
import json
s = json.dumps([1,2,3]) # 将指定的对象转换成json格式的字符串
print(type(s)) # <class ‘str‘>
print(s) # [1, 2, 3]
# 其实上述结果实际为‘[1,2,3]‘，这是因为解释器显示导致
s1 = json.dumps((1,2,3)) # 元组被json序列化会变成列表
print(s1) # [1,2,3]
# 集合是不可以被json序列化的数据类型
s2 = json.dumps(set(‘abc‘))
print(s2) # TypeError: Object of type set is not JSON serializable
# 将json结果写到文件中
import json
with open(‘a.txt‘,mode=‘at‘,encoding=‘utf-8‘) as f:
json.dump([1,2,3],f) # 将[1,2,3]以字符串形式写到文件中
# json反序列化
import json
res = json.dumps([1,2,3]) # 得到一个序列化的对象
# 再将序列化对象反序列化
li = json.loads(res)
print(type(li)) # <class ‘list‘>
print(li) # [1,2,3]
# 将文件中内容反序列化
import json
with open(‘a.txt‘,encoding=‘utf-8‘) as f:
res = json.load(f)
json文件通常是一次性写，一次性读。下面使用另一种方式实现多次读和多次写。
# 把需要序列化的对象，通过多次序列化的方法，用文件的write方法把多次
# 序列化的json字符串写到文件中
import json
with open(‘json.txt‘,mode=‘at‘,encoding=‘utf-8‘) as f:
f.write(json.dumps([1,2,3])+‘\n‘)
f.write(json.dumps([4,5,6])+‘\n‘)
# 把分次序列化的json字符串，反序列化回来
with open(‘json.txt‘,mode=‘rt‘,encoding=‘utf-8‘) as f:
json.loads(f.readline().strip(‘\n‘))
json.loads(f.readline().strip(‘\n‘))
pickle模块将python中所有数据类型直接转换成字节串（序列化过程），将字节串转换成python中数据类型（反序列化过程）.
import pickle
bys = pickle.dumps([1,2,3])
print(type(bys)) # <class ‘bytes‘>
print(bys) # b‘\x80\x03]q\x00(K\x01K\x02K\x03e.‘
其余情况都类似与json的使用（会保持数据类型，如元组）。pickle应用场景：和json一样，一次性写入，一次性读取。
# pickle和json的比较
"""
json:
1.不是所有的数据类型都可以序列化
2.不能多次对同一个文件序列化
3.json数据可以跨语言
pickle：
1.所有python数据类型都可以序列化，结果是字节串
2.可以多次对同一个文件序列化
3.不能跨语言
"""
hashlib模块里面封装了一些用于加密的类。
加密的目的：用于判断和验证，而并非解密。
特点：
import hashlib
# md5加密算法
# 获取一个加密对象
m = hashlib.md5()
# 使用加密对象的update，进行加密
m.update(‘abc中文‘.encode(‘utf-8‘))
# 通过hexdigest获取加密结果
res = m.hexdigest()
print(res) # 1af98e0571f7a24468a85f91b908d335
# 通过digest()方法获取加密结果
res1 = m.digest()
print(res1) # b‘\x1a\xf9\x8e\x05q\xf7\xa2Dh\xa8_\x91\xb9\x08\xd35‘
给一个数据加密的三大步骤：
加密算法不用于解密，只用于验证。如果验证结果相同则说明原文相同，反之则说明原文不同。
不同加密算法的差别就是加密结果的长度不同。
# 在创建加密对象时，可以指定参数，称为salt
import hashlib
m = hashlib.md5(b‘abc‘)
print(m.hexdigest()) # 900150983cd24fb0d6963f7d28e17f72
# 对同一字符串，分开加密和直接加密结果一致
import hashlib
# 分开加密
m = hashlib.md5()
m.update(b‘abc‘)
m.update(b‘def‘)
print(m.hexdigest()) # e80b5017098950fc58aad83c8c14978e
# 直接加密
m1 = hashlib.md5()
m1.update(b‘abcdef‘)
print(m1.hexdigest()) # e80b5017098950fc58aad83c8c14978e
# 可以看到结果确实是一样的
collections中定义了一些常用的类：
namedtuple()：命名元组
from collections import namedtuple
# 创建一个namedtuple对象
Rectangle = namedtuple(‘Rectangle_class‘,[‘length‘,‘width‘])
r = Rectangle(10,6)
# 通过属性访问元组的元素
print(r.length) # 10
print(r.width) # 6
print(r) # Rectangle_class(length=10, width=6)
# 通过索引的方式访问元素
print(r[0]) # 10
print(r[1]) # 6
defaultdict:默认值字典
from collections import defaultdict
d = defaultdict(int,name=‘Lieve‘,age=22)
print(d[‘name‘]) # Lieve
print(d[‘age‘]) # 22
# 对于字典中原本不存在的键，默认值类型为规定的数据类型(int)
print(d[‘sex‘]) # 0
# 并且默认值字典会将这个原本不存在的键值对加入到字典中
print(d)
# defaultdict(<class ‘int‘>, {‘name‘: ‘Lieve‘, ‘age‘: 22, ‘sex‘: 0})
# defaultdict第一个参数可以使用自定义函数(不能有参数)
Counter()：计数器
from collections import Counter
s = ‘abcabdabcabacbd‘
c = Counter(s)
print(c)
# Counter({‘a‘: 5, ‘b‘: 5, ‘c‘: 3, ‘d‘: 2})
# 打印次数最多的前两个
print(c.most_common(2)) # [(‘a‘, 5), (‘b‘, 5)]
原文：https://www.cnblogs.com/20-03-14/p/12586146.html