python基础day03 -单例模式- 异常

new 方法

1. 概念
在类中默认 有个 __new__ 方法(object上的), 该方法用于开辟对象的内存空间.

注意:
    1. __new__方法先调用开辟内存, 再调用 __init__ 初始化


2. 作用: 单例模式 中要使用

class Student(object):
    # 重写__new__方法: 
    def __new__(cls,*args,**kwargs):  # 用以接受所有类型的参数
        # 执行自定义代码块之后,要实现原本__new__开辟内存空间的功能, 就使用super调用父类上的 __new__
        return super().__new__(cls)

    def __init__(self, name, age):  
        # 属性的初始化
        self.name = name
        self.age = age


# 创建对象
stu = Student("张飞", 18)
print(stu)
print(stu.name)
print(stu.age)

单例模式(23种设计模式中的简单一种)

1. 概念
单例模式: 指一个类有且只能创建一个对象, 目的为了节约内存空间

例如: 回收站, 有且只需要一个就能实现所需的功能,没有必要创建多个,浪费内存资源

2. 实现单例模式

# 定义一个父类
class Singleton(object):
    # 定义2个类属性
    __instance = None  # 实例化
    __isinit = False  # 是否初始化

    # 父类上的 __new__ 不满足需求, 要子类重写
    def __new__(cls, *args, **kwargs):
        """
        在类cls上绑定一个私有的类属性 __instance 表示对象空间
        如果cls.__instance 为 None 说明没有绑定, 就绑定
        如果cls.__instance 不为None 说明已经绑定
        无论如何都要返回创建的对象空间
        """
        if cls.__instance is None:  # 没有类属性 __instance
            # 绑定对象空间到类型属性 __instance 上
            cls.__instance = super().__new__(cls)  # 调用父类上的 __new__ 用于开辟对象空间,并赋值给__instance

        # 无论如何都要返回创建的对象空间
        return cls.__instance

    def __init__(self,name):
        # 判断是否初始化
        if Singleton.__isinit is False:
            # 初始化
            self.name = name
            # 改变 __isinit的值
            Singleton.__isinit = True

# 两对象的空间地址要一致
s1 = Singleton("张飞")
s2 = Singleton("李四")
print(s1, s2)
print(s1.name, s2.name)

# class Recycle(Singleton):
#     def __init__(self,name):
#         self.name = name
#
# r1 = Recycle("回收站")
# r2 = Recycle("回收站")
# print(r1,r2)

异常

1. 概念
什么是异常: 错误就是异常(出现错误,以异常的形式抛出)
底层实现(了解): 通过对象的形式实现(  异常对象=异常类名() )

作用: 工作中不可能应为或大或小的错误 就抛出异常, 因为异常一旦抛出终止代码向下执行.
因此, 我们需要捕获异常, 捕获异常后异常就不会抛出, 代码就能继续执行.

2. 捕获异常的基本语法
try:
    可能抛出异常的代码块
except: # 捕获
    # 如果捕获异常,执行这里的代码块
    # 可以写入日志文件(xxx.log), 输出, 继续抛出

备注:
    1. 如果 try中的代码块出现异常, 终止try代码块往下执行
    2. 不是所有的错误都能捕获, 语法错误是捕获不了, 执行的时候的错误才能捕获

# 异常会中断代码执行,捕获异常时,异常后面的代码不执行,跳到except继续执行
try:
    print(111)
    print(aaa)
    print(222)
except:
    print("代码出现错误")

print(333)
print(444)

异常的类型

1. 概念:
异常(错误) 是分类型, 异常有很多类(class)
常见类型: FileNotFoundError,NameError,IndexError
注意: 异常有很多类型, 我们只捕获 Exception 类型及其子类型的错误

2. 捕获指定类型的错误
try:
    可能出现异常的代码块
except 异常类名 as e:  # 通过 异常类名() 创建对象 赋值 给临时变量 e
    # 处理异常
except (异常类名1,异常类名2) as e:  # 通过 异常类名() 创建对象 赋值 给临时变量 e
    # 处理异常

注意:
    1. 将所有的代码错误都捕获, 只需要将异常类写成 Exception

# open("./xxx.txt") FileNotFoundError: [Errno 2] No such file or directory: './xxx.txt'
# print(a)
# a = [1,2,3]
# print(a[5])

# 捕获所有代码中的错误
try:
    # open("./xxx.txt")
    print(aaa)
except Exception as e:
    print("错误!",e)


try:
    print(aaa)
    open("./xxx.txt")
except (FileNotFoundError,NameError) as e:
    print(f"错误!{e}")


# 捕获所有类型的错误
import time
while True:
    try:
        print("你好")
        time.sleep(1)
    except:
        print("代码错误")

异常的完整语法:

try:
可能错误的代码块
except 异常类名 as e:
# 捕获指定类型的错误
except (异常类名1,异常类名2) as e:
# 捕获多种类型的错误
except Exception as e:
# 捕获所有代码类型的错误
else:
# 如果没有错误就执行这里的代码块 了解
finally:
# 无论如何都执行

# 打开文件
fp = open("./data.txt", "w", encoding="utf-8")
try:
    # 写入文件内容
    fp.write(aaa)
except FileNotFoundError as e:
    print("写入文件失败!", e)
else:
    # 没有异常执行
    print("写入文件成功!")
finally:
    # 无论如何都执行
    # 关闭文件
    print("关闭文件")
    fp.close()

手动抛出异常

1. 语法:
raise 异常类名("自定义错误提示信息")

方式二:
    在 except 中如果想要继续抛出异常,直接使用 raise

# 验证身高是否符合要求 160
height = 165


def check(height):
    if height < 160:
        # 错误, 抛出异常
        raise Exception("身高不符合要求!")


try:
    check(height)
except Exception as e:
    print(e)
else:
    print("身高符合要求")

# 录入年龄,验证年龄是否合法
age = input("请输入年龄:")
try:
    age = int(age)
except Exception as e:
    # 处理异常: 写入日志,输出,继续抛出
    print("年龄不合法", e)
    # raise # 继续抛

模块和包的 概念

1. 模块的概念(module)
a. 团队开发, 不可能将所有的代码写到同一个文件, 分文件存放
b. 我们自己可能使用到别人写的代码(在一个文件中)
c. 人类掌握的基本单词太少了, 及其容易造成命名冲突, 分文件存放

在python中 一个py文件就是一个模块
备注: 模块和包的命名符合 标识符命名规范(注意不能以数字开头)

2. 包的概念(package 包)
包: 其实就是一个文件夹,存储多个模块. 标准的包 中创建一个 __init__.py 文件

好处:
    1. 方便管理多个模块
    2. 解决模块重名的问题

模块的操作

1. 模拟
a. 创建一个py文件, 写 函数,类,变量,输出(文件名不能以数字开头)
b. 在自己的文件中,导入别人的模块(mymodule)
    导入语法:
        import 模块名  # py文件名,没有后缀
        from ... import ...  # 指定导入
        from 模块名 import 函数/类/变量
c. 使用导入的内容
    技巧: import 后面接什么,就用什么 (对象.成员)


2. 模块测试代码(执行代码)的书写位置
补充 魔术变量: __name__ : 其值由python自动赋值
    (1): 当 当前文件 作为主执行文件(python 解释器后接的文件为主执行文件),
     __name__等于__main__
    (2): 当 当前文件为 被导入的文件,__name__的值为模块名

# 定义代码: 类/函数/变量 的定义

if __name__ == "__main__":
    # 执行的代码块

# 导入模块
import mymodule

if __name__ == '__main__':  # 如果文件是主执行文件
    mymodule.show()
    mymodule.Student.show()
    print(mymodule.name)

# 指定导入
# from mymodule import show,Student,name
# 使用
# show()
# Student.show()
# print(name)