Python - 常用模块

自定义模块day16
# 什么是模块?
# 分类  认证 ,视频 ,评论

# 模块能干什么?

# 1.文件化管理 提高可读性,避免重复代码
# 2.拿来就用 (避免重复造轮子) python中类库特别多

# 定义一个模块
# 一个文件就是一个模块  (模块就是一个工具箱  工具(函数))

# import时会做三件事:
# 1.将test.py文件中所有代码读取到当前文件
# 2.当前文件开辟空间
# 3.等待被调用

# import 导入同一个模块名是,只执行一次
import test as t  # 工具箱名字过长可以起别名

# import 和 from 的区别:
# 1.from只能执行导入的工具
# 2.import 能够执行整个模块中所有的功能
# 3.from容易将当前文件中定义的工能覆盖
# 4.from比import灵活

# import 只能导入当前文件夹下的模块

# import 后边不能加点操作

模块导入顺序:
#sys.path.append(r"C:\Users\oldboy\Desktop")
# 内存 > 内置 > 第三方> 自定义
#sys.path.insert(0,r"C:\Users\oldboy\Desktop")
# 内存 > 自定义 > 内置 > 第三方

模块的两种用法: if __name__ == "__main__"
# 1.当做模块被导入   import from
# 2.当做脚本被被执行

只有py文件当做模块被导入时,字节码才会进行保留


 以后导入模块会产生的坑:1.注意自己定义模块的名字
        2.注意自己的思路 -- 循环导入时建议 导入模式放在需要的地方
        通过__all__ 控制要导入的内容

time模块

import time  # 内置模块 -- 标准库

# print(time.time())  # 时间戳  浮点数  秒
# time.sleep(3)  # 秒

# 将时间戳转换成结构化时间
# print(time.localtime(time.time()))   # 命名元组
# print(time.localtime(time.time())[0])
# print(time.localtime(time.time()).tm_year)

# 将结构化时间转换成字符串
# time_g = time.localtime()
# print(time.strftime("%Y-%m-%d %H:%M:%S",time_g))

# 将字符串转换成结构化时间
# str_time = "2018-10-1 10:11:12"
# time_g = time.strptime(str_time,"%Y-%m-%d %H:%M:%S")

# 将结构化时间转换成时间戳
# print(time.mktime(time_g))

# str_time = "2016-10-1 10:11:12"
# time_int = time.time() - time.mktime(time.strptime(str_time,"%Y-%m-%d %H:%M:%S"))
# print(time.localtime(time_int))

# 总结:
# time.time() 时间戳
# time.sleep() 睡眠
# time.localtime() 时间戳转结构化
# time.strftime() 结构化转字符串
# time.strptime() 字符串转结构化
# time.mktime() 结构化转时间戳
# %Y 年
# %m 月
# %d 日
# %H 时间
# %M 分钟
# %S 秒

datetime 模块


from datetime import datetime,timedelta
# print(datetime.now())  # 获取当前时间

# print(datetime(2018,10,1,10,11,12) - datetime(2011,11,1,20,10,10))
# 指定时间

# 将对象转换成时间戳
# d = datetime.now()
# print(d.timestamp())

# 将时间戳转换成对象
# import time
# f_t = time.time()
# print(datetime.fromtimestamp(f_t))

#将对象转换成字符串
# d = datetime.now()
# print(d.strftime("%Y-%m-%d %H:%M:%S"))

# 将字符串转换成对象
# s = "2018-12-31 10:11:12"
# print(datetime.strptime(s,"%Y-%m-%d %H:%M:%S"))

# 可以进行加减运算

# from datetime import datetime,timedelta
# print(datetime.now() - timedelta(days=1))
# print(datetime.now() - timedelta(hours=1))

random -- 随机数
import random

print(random.randint(1,50))
选择1-50之间随机的整数
print(random.random())
0-1 之间随机小数,不包含1
print(random.uniform(1,10))
1- 10 之间随机小数,不包含10

print(random.choice((1,2,3,4,5,7)))
从容器中随机选择一个
print(random.choices((1,2,3,4,5,7),k=3))
从容器中随机选择3个元素,以列表的形式方式,会出现重复元素
print(random.sample((1,2,3,4,5,7),k=3))
从容器中随机选择3个元素,以列表的形式方式,不会出现重复元素
print(random.randrange(1,10,2))  # 随机的奇数或随机的偶数

lst = [1,2,3,4,5,6,7]
random.shuffle(lst)
洗牌 将有序的数据打散
print(lst)

random -- 随机数
import random

print(random.randint(1,50))
选择1-50之间随机的整数
print(random.random())
0-1 之间随机小数,不包含1
print(random.uniform(1,10))
1- 10 之间随机小数,不包含10

print(random.choice((1,2,3,4,5,7)))
从容器中随机选择一个
print(random.choices((1,2,3,4,5,7),k=3))
从容器中随机选择3个元素,以列表的形式方式,会出现重复元素
print(random.sample((1,2,3,4,5,7),k=3))
从容器中随机选择3个元素,以列表的形式方式,不会出现重复元素
print(random.randrange(1,10,2))  # 随机的奇数或随机的偶数

lst = [1,2,3,4,5,6,7]
random.shuffle(lst)
洗牌 将有序的数据打散
print(lst)

软件开发规划--分文件day17

当代码存放在一个py文件中时
1.不便于管理 修改 增加
2.可读性差
3.加载速度慢

#Django  --雏形

约定俗称
1.启动文件   启动接口    
2.公共文件   大家需要的功能  
3.配置文件   (静态文件)变量
4.主逻辑     核心   
5.用户相关数据   账号和密码等文件
6.日志       记录主要信息,记录开发人员的行为

sys 模块   

#sys.path              模块查找的顺序 ***
#sys.argv              只能在终端中执行**
#sys.modules           查找加载到的内存模块
#sys.platform          查找当前操作系统平台
#sys.version           查看当前解释器的版本

序列化模块
1. json
2. pickle
#4个方法 2组
dumps    loads  ----用于网络传输
dump     load   ----用于文件存储

# s = json.dumps(lst)  #序列
# l = json.loads(s)  # 反序列

将数据类型转换成字符串(序列化),将字符串转成原数据类型(反序列)
能够序列: 字典,列表,元组序列后变成列表
dump    将源数据类型转化成字符串.写入到文件中 
load	将文件中的字符串转成源数据类型

import json
# lst = [1,2,3,4,5]
# with open("a","a",encoding="utf-8")as f:
#     f.write(json.dumps(lst)+"\n")

# with open("a","r",encoding="utf-8")as f1:
#     for i in f1:
#         l = json.loads(i)
#         print(l)


2. pickle
只要python有,几乎可以序列python中所有的数据类型,匿名函数不能序列

# import pickle
# def func():
#     print(1)
#
# a = pickle.dumps(func)   # 将原数据类型转换成类似字节的内容
# print(pickle.loads(a))   # 将类似字节的内容转换成原数据类型

os 模块


# 工作路径:
import os   # os是和操作系统做交互,给操作发指令
# print(os.getcwd())  # 获取当前文件工作的路径     ***
# os.chdir("D:\Python_s25\day16")  # 路径切换     **
# print(os.getcwd())
# print(os.curdir)
# print(os.pardir)


# 文件夹   ***
# os.mkdir("a2")  # 创建文件夹
# os.rmdir("a2")  # 删除文件夹
# os.makedirs('a1/a2/a3')  # 递归创建文件夹
# os.removedirs("a1/a2/a3") # 递归删除文件夹
# print(os.listdir(r"D:\Python_s25\day17"))  # 查看当前文件下所有的内容


# 文件 ***
# os.remove(r"D:\Python_s25\day17\a")      #删除文件,彻底删除 找不回来
# os.rename()                              # 重命名


# 路径
# print(os.path.abspath("test"))   # 返回的是绝对路径     ***
# print(os.path.split(r"D:\Python_s25\day17\test"))  #将路径分割成一个路径和一个文件名 **
# print(os.path.dirname(r"D:\Python_s25\day17\test"))  #获取到父目录                   ***
# print(os.path.basename(r"D:\Python_s25\day17\test")) #获取文件名  **
# print(os.path.join("D:\Python","day17","test"))        # 路径拼接   ***(非常重要)

# 判断
# print(os.path.exists(r"D:\Python_s25\day17\blog"))  # 判断当前路劲是否存在  **
# print(os.path.isabs(r"D:\Python_s26\day17\blog"))     # 判断是不是绝对路径  **
# print(os.path.isdir(r"D:\Python_s25\day17\blog"))        # 判断是不是文件夹 **
# print(os.path.isfile(r"D:\Python_s25\day17\blog"))           # 判断是不是文件  **

# print(os.path.getsize(r"D:\Python_s25\day17\01 今日内容.py"))  # 获取文件大小
# print(os.path.getsize(r"D:\Python_s25"))  # 获取文件大小                        ***

re 模块(正则表达式)day18

\w   匹配字母 数字 下划线 中文
\W   匹配非字母 数字 下划线 中文

\s   匹配任意的空白符
\S	 匹配非任意的空白符

\d 	 匹配数字
\D	 匹配非数字

\A	 从字符串开头匹配
\Z	 匹配字符串的结束

\n	 匹配一个换行符
\t 	 匹配一个制表符

^	 匹配字符串的开始
$	 匹配字符串的结尾

. 	 匹配任意字符,除了换行符,当re.DOTALL标记指定时,则可以匹配包括换行符的任意字符
[...]  	匹配字符组中的字符 	

...	  	匹配除了字符组中的字符的所有字符
*	 	匹配0个或多个左边的字符
+	 	匹配一个或多个左边的字符
?	 	匹配0个或1个左边的字符,非贪婪方式.

{n}	 	精准匹配n个前面的表达式.
{n,m}  	匹配n到m次由前面的正则表达式定义的片段,贪婪方式
ab	 	匹配a或者b
()	 	匹配括号内的表达式,也表示一个组

# 面试题:
# search 和 match 区别

# search 从任意位置开始查找
# match 从头开始查看,如果不符合就不继续查找了
# group()进行查看
列子:
# print(re.search("a.+","lexaaaa,bssssaaaasa,saaasaasa").group())
# print(re.match("a.+","alexalexaaa,bssssaaaasa,saaasaasa").group())

split  --  分割
 print(re.split("[:;,.!#]","alex:dsb#wusir.djb"))
    
sub -- 替换
# s = "alex:dsb#wusir.djb"
# print(re.sub("d","e",s,count=1))

compile 定义匹配规则
# s = re.compile("\w")
# print(s.findall("alex:dsb#wusir.djb"))

包day19

管理模块(文件化)
什么事包: 文件下具有__init__.py的就是一个包

__file__获取当前文件的路径

路径: 绝对路径:从最外层(bake)包.查找的就是绝对路径 相对路径:.就是相对路径, ..是上一级目录 

在使用相对路径的时候一定要在于bake同级的文件中测试 我们需要在和bake同级的test.py中测试

日志

# logging -- 日志
# 1.记录用户的信息
# 2.记录个人流水
# 3.记录软件的运行状态
# 4.记录程序员发出的指令
# 5.用于程序员代码调试

# 日志中要记录的信息
# 默认从warning开始记录

# 手动挡
# import logging
# logging.basicConfig(
#     level=logging.DEBUG,
#     format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
#                     datefmt='%Y-%m-%d %H:%M:%S',
#                     filename="test.log",
#                     filemode="a",
# )
#
#
# logging.debug("你是疯儿,我是傻") # debug 调试
# logging.info("疯疯癫癫去我家")   # info 信息
# logging.warning("缠缠绵绵到天涯")   # info 警告
# logging.error("我下不床")           # error 错误
# logging.critical("你回不了家")        # critical 危险


# 自动挡
# import logging
# # 初始化一个空日志
# logger = logging.getLogger()   # -- 创建了一个对象
# # 创建一个文件,用于记录日志信息
# fh = logging.FileHandler('test.log',encoding='utf-8')
# # 创建一个文件,用于记录日志信息
# fh1 = logging.FileHandler('test1.log',encoding='utf-8')
# # 创建一个可以在屏幕输出的东西
# ch = logging.StreamHandler()
# # 对要记录的信息定义格式
# msg = logging.Formatter('%(asctime)s - [line:%(lineno)d] %(filename)s - %(levelname)s - %(message)s')
# # 对要记录的信息定义格式
# msg1 = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
# # 设置记录等级
# logger.setLevel(10) or logger.setLevel(logging.DEBUG)
# # 等级对应表
# '''
# DEBUG - 10
# INFO - 20
# WARNING - 30
# ERROR - 40
# CRITICAL - 50
# '''
# 将咱们设置好的格式绑定到文件上
# fh.setFormatter(msg)
# fh1.setFormatter(msg)
# # 将咱们设置好的格式绑定到屏幕上
# ch.setFormatter(msg1)
# 将设置存储日志信息的文件绑定到logger日志上
# logger.addHandler(fh) #logger对象可以添加多个fh和ch对象
# logger.addHandler(fh1)
# logger.addHandler(ch)
# # 记录日志
# logger.debug([1,2,3,4,])
# logger.info('logger info message')
# logger.warning('logger warning message')
# logger.error('logger error message')
# logger.critical('logger critical message')

hashlib 加密- 校验

1.加密
2.校验

加密的方式  1.md5,sha1,sha256,sha512
		  2.sha512 加密速度慢,安全系数高
    
 明文(123adsa) -- 字节 -- 密文(bs2501153023ras32rf150q23r13ar)  

1.当要加密的内容相同是.你的秘闻一定是一样的
2.当你的名人不一样是.密文不一定一样
3不可逆

例初始
import hashlib
md5 = hashlib.md5()  <== 初始化
md5.update('alex'.encode('utf-8')) <==将明文转成字节添加到新初始化的md5中
print(md5.hexdigest()) <== 进行加密

加盐
加固定盐
import hashlib
md5 = hashlib.md5('加盐'.encode('utf-8'))
md5.update("alex".encode("utf-8")) <==将明文转换成字节添加到新初始化的md5中
print(md5.hexdigest())   # 进行加密

加动态盐
# import hashlib
# user = input("username:")
# pwd = input("password:")
#
# md5 = hashlib.md5(user.encode("utf-8"))   # 初始化
# md5.update(pwd.encode("utf-8"))   # 将明文转换成字节添加到新初始化的md5中
# print(md5.hexdigest())   # 进行加密

 校验
    
    
    # import hashlib
# md5 = hashlib.md5()
# md5.update(b"afdadfadfadsfafasd")
# print(md5.hexdigest())

# import hashlib
# def file_check(file_path):
#     with open(file_path,mode='rb') as f1:
#         md5= hashlib.md5()
#         while True:
#             content = f1.read(1024)   # 2049 1025 1
#             if content:
#                 md5.update(content)
#             else:
#                 return md5.hexdigest()
# print(file_check('python-3.6.6-amd64.exe'))

collection 基于python自带的数据类型智商额外增加的几个数据类型

# 1.namedtuple: 生成可以使用名字来访问元素内容的tuple
命名元组
 from collections import namedtuple
 limit = namedtuple("limit",["x","y"])
 l = limit(1,2)
 print(l.x)
 print(l[0])

# 2.deque: 双端队列，可以快速的从另外一侧追加和推出对象

# 双端队列
from collections import deque
 lst = [1,2,3,4]

 deque = [1,2,3,4]
 deque.append(1)
 deque.remove(1)
 print(deque)


# 3.Counter: 计数器，主要用来计数
 计数 返回一个字典
lst=[1,2,112,312,312,31,1,1,1231,23,123,1,1,1,12,32]
d = Counter(lst)
print(list(d.elements()))
print(dict(d))



# 4.OrderedDict: 有序字典
from collections import OrderedDict
有序字典(python2版本)  -- python3.6 默认是显示有序
dic = OrderedDict(k=1,v=11,k1=111)
print(dic)
print(dic.get("k"))
dic.move_to_end("k")

# 5.defaultdict: 带有默认值的字典
from collections import defaultdict
 默认字典

 dic = defaultdict(list)
 dic[1]
 print(dic)

# 队列:先进先出
# 栈:先进后出  --  栈顶

defaultdict: 带有默认值的字典
    
print(dict(Counter(s)))  # ***统计元素出现的次数