Python编程学习-基础笔记08

十、 模块 和 包

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)