十、 模块 和 包
10.1 单例模式
'''
单例模式： --》 开发模式
通常，每创建一个对象，会默认去调用__new__方法来分配一个内存空间，而在单例模式下，通过重写__new__方法，只会创建一块内存空间
目的：
优化内存地址
'''
class Singleton:
#私有化，存单例的地址，默认为None
__instance = None
name = 'Jack'
#重写父类__new__
def __new__(cls):
if cls.__instance is None:
#如果__instance为None，则利用object给其赋值
cls.__instance = object.__new__(cls)
# 将值返出来给__init__()，然后赋值给s 或s1
return cls.__instance
def show(self,n):
print('--->show',Singleton.name,n)
s = Singleton()
s1 = Singleton()
#创建2次对象，使用的是同一个内存地址
print(s) # <__main__.Singleton object at 0x000002B5C583D518>
print(s1) #<__main__.Singleton object at 0x000002B5C583D518>
#调用的依然是同一块内存空间
s.show(2) #--->show Jack 2
s1.show(5) #--->show Jack 5
10.2 模块
在python中，模块是代码组织的一种方式，把功能相近的函数放到一个文件中，一个文件.py 就是一个模块 module。模块名就是文件名去掉后缀.py, 这样做的好处是：
提高代码的可复用、可维护性，一个模块编写完成后，可以很方便的在其他项目中导入
解决了命名冲突，不同模块中，相同的名字不会冲突
'''
1,自定义模块
2，系统模块
导入模块：
1，import 模块名
使用：模块名.变量 模块名.函数 模块名.类
2，from 模块名 import 变量 | 函数 | 类
可以直接使用 变量、函数或类
3，from 模块名 import * （*导入全部）
该模块中所有内容
如果想要限制获取的内容，可以在模块中使用 __all__ = [使用*可以访问到的内容]
4, 无论是import 或 from 的形式，都会将模块内容全部加载到内存
如果不希望进行语句的调用，就会使用到 if __name__ == '__main__':
在自己的模块中，__name__ 叫__main__
如果在其他模块通过导入引用，__name__ 叫 模块名
'''
先定义一个calculate模块：
#使用*可以访问到的内容
__all__ = ['add','substract']
#变量
name = 'Jack'
number = 100
#函数
def add(*args):
sum = 0
if len(args) > 1:
for i in args:
sum += i
return sum
else:
print('请至少传入2个参数')
return 0
def substract(*args):
substrction = 0
if len(args) > 1:
for i in args:
substrction -= i
return substrction
else:
print('请至少传入2个参数')
return 0
#类
class Calculate:
def __init__(self,num):
self.num = num
def test(self):
print('你正在调用类中的函数')
@classmethod
def test1(cls):
print('你正在使用类中发方法')
def test():
print('这是一个测试')
print('__name__:',__name__) #外部调用 __name__: calculate #内部调用 __name__: __main__
#模块里调用了自身，外部导入的话，也会被执行
# test()
#如果不想被外部引用模块内的函数执行，将其加入到__name__
if __name__ == '__main__':
test()
print('__name__:',__name__) #内部调用 __name__: __main__
在另一个模块中来调用calculate模块：
list1 = [1,3,5,7,9]
#导入模块
import calculate
# from calculate import add
# from calculate import *
#*list1拆包，calculate.add 调用模块中的函数 ，模块名.函数名
result = calculate.add(*list1)
print(result)
result = calculate.substract(*list1)
print(result)
#调用模块中的bianl
print(calculate.name,calculate.number)
#调用模块中的类
cal = calculate.Calculate(5)
print(cal)
cal.test()
#不需创建对象即可调用
calculate.Calculate.test1()
10.3 包
''''
文件夹 vs 包
存放非py文件 存放py文件
无init文件 有init文件
一个包中可以存放多个模块
项目 > 包 > 模块 > 类 函数 变量
层级结构：
project
article
|--__init__.py
|--models.py
|--Article
|--......
user
|--__init__.py
|--models.py
|--User
|--test.py
|--......
package.py
from 包.模块 import 类 函数 变量
from 包.模块 import *
from 包 import 模块
'''
from article.models import Article
from user.models import User
#创建用户和文章对象
user = User('admin', '123456')
#发表文章
article = Article('钢铁洪流','Jim')
user.publish_article(article)
上面的内容引用到了两个包中的模块，一个是article，另一个是user，项目中需要有此2包，才可以正常引用。
article 包下的models模块：
class Article:
def __init__(self,title,author):
self.title = title
self.author = author
def publish(self):
print(f'{self.author}发布了一篇文章：{self.title}')
user包下的models模块：
class User:
def __init__(self,username,password):
self.username = username
self.password = password
def user(self,username,password):
if self.username == username and self.password == password:
print('用户{self.username}登录成功')
def publish_article(self,article):
print(f'{self.username}发布了文章：{article.title}')
10.3.1 init 文件的作用
'''
__init__.py 文件
当导入包的时候，默认会执行包中的__init__.py 文件
作用：
1，当导入包时，把一些初始化的函数、变量定义在__init__.py 文件中
2，函数、变量等的访问，只需要通过 包名.函数
3，from 模块 import * --》默认可以使用模块中的所有函数，结合 __all__来控制可访问的函数
如果没有定义__all__，所有的都可以访问
如果定义了__all__，那么只有__all__ = [...] 列表中的内容可以访问
from 包 import * --》 默认不可以使用包中的任何模块，需要在__init__.py 文件中结合 __all__=[可以通过*来访问的模块] 来使用
如果没有定义__all__，访问不了任何模块
如果定义了__all__，那么只有__all__ = [...] 列表中的模块可以访问
'''
10.4 模块的循环导入
循环导入模块1
'''
循环导入：在大型的python项目中，需要很多的py文件，由于架构不当，可能会出现模块之间的循环导入
A: 模块
def test():
f()
B: 模块
def f():
test()
避免产生循环导入的方法：
1，架构重构
2，将导入的动作语句放到函数里面
3，把导入语句放到模块的最后
'''
from cycle_import2 import func
def task1():
print('------task1--------')
def task2():
print('------task2--------')
func()
if __name__ == '__main__':
task1()
task2()
循环导入模块2
def func():
print('--------循环导入2里的func-1 ----------')
#解决循环调用的问题
from cycle_import import task1
task1()
print('--------循环导入2里的func-2 ----------')
if __name__ == '__main__':
func()
10.5 sys模块
系统相关的操作，可以调用sys模块来完成，比如路劲添加，查看版本和添加运行参数等。
import sys
print(sys.path) #查看运行环境路劲
print(sys.version) #查看python版本
print(sys.argv) #运行程序是的参数，argv是一个列表
10.6 time 和 datetime 模块
'''
time 模块:
1,时间戳
重点：time, sleep,strftime
datetime模块： time模块的升级
time 时间
date 日期 （data数据）
datetime 日期时间
timedelta 时间差 (days,weeks,hours....)
'''
import time,datetime
#时间戳
t = time.time()
print(t) #1658211832.2382739
time.sleep(0.5)
t1 = time.time()
#时间戳转字符串
s = time.ctime(t)
print(s)
#将时间戳转为元组的方式
t2 = time.localtime(t)
y = t2.tm_year #单独获取到年份
print(t2,y) #time.struct_time(tm_year=2022, tm_mon=7, tm_mday=19, tm_hour=14, tm_min=37, tm_sec=57, tm_wday=1, tm_yday=200, tm_isdst=0) 2022
#把元组时间转为时间戳
s2 = time.mktime(t2)
print(s2)
#把元组时间转为字符串
s3 = time.strftime('%Y-%m-%d %H:%M:%S')
print(s3)
#将字符串转成元组的方式
r = time.strptime('2022/07/19','%Y/%m/%d')
print(r) #time.struct_time(tm_year=2022, tm_mon=7, tm_mday=19, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=1, tm_yday=200, tm_isdst=-1)
#datetime
print(datetime.time.hour) #对象 <attribute 'hour' of 'datetime.time' objects>
print(time.localtime().tm_hour) #打印小时数
#datetime，timedelta
d = datetime.date.today()
print(d) #当前日期2022-07-19
#时间差值，hours,weeks,days....
timedel = datetime.timedelta(hours=2)
timedel1 = datetime.timedelta(days=3,hours=10)
print(timedel)
#获取当前的日期和时间
now = datetime.datetime.now()
print(now) #2022-07-19 14:55:52.425880
#时间运算，支持+ -
result = now - timedel
result1 = now + timedel1
print(result) #当前时间减去2小时的时间 2022-07-19 12:55:52.425880
#使用场景：缓存，redis.set(key,value,时间差)
# 会话：session
print(result1) #2022-07-23 01:01:45.330700
10.7 random模块
import random
r = random.random() #0-1 之间的随机小数
print(r)
r = random.randrange(1,10,2) # 1-10之间的随机数，步长2，不含10 randrange(start,stop,steps)
print(r)
r = random.randint(1,10) #产生1-10之间的随机整数，包含10
print(r)
s = 'QWERTYUIOPASDFGHJKLZXVBNM1234567890'
r = random.choice(s) #从字符串中随机选一个值
print(r)
#洗牌
lists = ['A','2','3','4','5','6','7','8','9','10','J','Q','K']
r = random.shuffle(lists) #打乱lists 顺序
print(lists) #['2', 'K', '4', '7', '9', 'Q', 'A', '3', '6', 'J', '8', '5', '10']
#验证码， 大小写字符与数字的组合
def func():
code = ''
for i in range(4):
ran1 = str(random.randint(0,9))
ran2 = chr(random.randint(65,90)) #ascii字符转换，大写字母
ran3 = chr(random.randint(97,122)) #ascii字符转换，小写字母
r = random.choice([ran1,ran2,ran3])
code += r
return code
code = func()
print(code)
10.8 hashlib模块
#ord
# 标准库 print input list set tuple str dict isinstance
print(chr(65)) #A
print(ord('B')) #66
print(ord('甘')) #29976
print(chr(29976)) #甘
#hashlib库
import hashlib
#加密算法 md5 sha1 sha256 都是单向不可逆的算法
#md5 加密
msg = 'test123'
md5 = hashlib.md5(msg.encode('utf-8'))
print(md5) #<md5 HASH object @ 0x000002DF4A1AA580>
print(md5.hexdigest()) #cc03e747a6afbbcbf8be7668acfebee5
sha1 = hashlib.sha1(msg.encode('utf-8'))
print(sha1) #<sha1 HASH object @ 0x000001F3A24E9AD0>
print(sha1.hexdigest()) #7288edd0fc3ffcbe93a0cf06e3568e28521687bc
sha256 = hashlib.sha256(msg.encode('utf-8'))
print(sha256) #<sha256 HASH object @ 0x000001EF6C2B9CB0>
print(sha256.hexdigest()) #ecd71870d1963316a97e3ac3408c9835ad8cf0f3c1bc703527c30265534f75ae
#解密
#密码匹配，先将密码加密存库，用户输入密码后，再次加密，然后将加密后的数据同数据库中的数据进行比较，相同则通过
pwd = '123456'
list1 = []
sha256 = hashlib.sha256(pwd.encode('utf-8'))
list1.append(sha256.hexdigest())
print(list1)
pwd1 = input('输入密码：')
sha256 = hashlib.sha256(pwd1.encode('utf-8'))
pwd1 = sha256.hexdigest()
print(pwd1)
for i in list1:
if pwd1 == i:
print('登录成功！')
10.9 第三方库
需要通过pip或pycharm环境中的settings-->Project --> Python Interpreter 去安装。
# import pillow # pip install pillow 图片处理模块
import requests #接口处理
response = requests.get('https://www.baidu.com')
content = response.text
print(content)