exec , 元类,__new__, __call__ , 单例模式 , 异常

1,类也是对象

'''
动态语言
    可以在运行期间 动态生成类 修改对象属性
静态语言
'''''
 
'''
type(object_or_name, bases, dict)
type(object) -> the object's type
type(name, bases, dict) -> a new type
'''
obj = type("TestClass",(object,),{})
print(obj)          #<class '__main__.TestClass'>
 
class B(object):    #type("B",(object,),{"name":"rose"})
    name = "rose"
 
#模拟解释器创建类的过程
def test1(a):
    print(a)
 
def test2(self,b):
    print(self,b)
 
class_name = "C"
bases = (object,)
name_dic = {"name":"jack","test1":test1,"test2":test2}
 
C = type(class_name,bases,name_dic)
# print(C)    #<class '__main__.C'>
c1 = C()
print(c1)      #<__main__.C object at 0x000001EFEC877550>
c1.test2(100)   #<__main__.C object at 0x0000021F31807550> 100

2 , exec

glob = {}
locl = {}
 
code = """
def test(a):
    print(a)
"""
 
exec(code,glob,locl)
 
# print(glob)   #打印系统内置函数
print(locl)     #{'test': <function test at 0x000001376F36C2F0>}
locl["test"](100)
 
#exec 可以执行字符串形式的python代码,并且会把执行过程中产生的名字,放到局部名称空间中
class_test = """
class A:
    def test(self):
        print(self)
"""
loca2 = {}
exec(class_test,None,loca2)
print(loca2)        #{'A': <class '__main__.A'>}
 
# eval(class_test)  #报错,eval用于处理单行字符串的表达式

3,元类

class person():
 
    def __init__(self,name):
        self.name = name
 
    def SAYHI(self):
        print(self.name)
 
'''
类名必须大写开头,方法名必须全部小写
应用场景:用于限制类,满足某些条件,例如上述要求
type类已经具备了创建类的能力,但是现在不能满足我们的要求
需要对已有的功能进行扩展或修改
方式:
    1,直接修改源代码 ,行不通
    2,自定义新的元类
'''
class MyMetaClass(type):
    pass
 
#默认创建类时,是找的type来实例化的
class Person(metaclass=MyMetaClass):
    pass
 
class Student:
    def __init__(self):
        pass
 
print(type(Person))     #<class '__main__.MyMetaClass'>
print(type(Student))    #<class 'type'>
 
s = Student()           #实例化对象时, 1,产生空对象,2,自动执行__init__
 
#创建类对象时也是一样的,会先创建空的类对象,在调用__init__()方法
# Person = MyMetaClass()

class MyMetaClass(type):
    def __init__(self,class_name,bases,name_dic):
        #元类中的self表示的都是类对象
        print(self)     #<class '__main__.Student'>
 
        #不要忘记调用父类的初始化
        super().__init__(class_name,bases,name_dic)
        print(name_dic)
 
        #类名必须首字母大写,否则直接抛出异常
        if not class_name.istitle():
            print('类名必须大写!')
            raise Exception
 
        #控制类中方法名必须全部小写
        for k in name_dic:
            if str(type(name_dic[k])) == "<class 'function'>":
                if not k.islower():
                    raise Exception('方法名必须全小写!')
 
#会自动调用其元类中的__init__方法传入,类对象本身,类名称,父类们,名称空间
class Student(object,metaclass=MyMetaClass):    #MyMetaClass("Student",(object,),{})
    NAME = 10
    def asdfA(self):
        print('SNY')

3 , 元类中 __new__

class MeMetaClass(type):
 
    def __init__(self,class_name,bases,name_dic):
         # super().__init__(class_name,bases,name_dic)
         print("init")
 
    #该方法会在实例化类对象时自动调用并且在__init__之前调用
    #其作用是用于创建新的类对象的
    #注意这里必须调用type类中的__new__否则将无法产生类对象,并且返回其结果
    def __new__(cls, *args, **kwargs):
        #cls 表示元类自己即MyMetaClass
        print("new")
        print(args,kwargs)      #('Person', (), {'__module__': '__main__', '__qualname__': 'Person'}) {}
        return type.__new__(cls,*args,**kwargs)   #如果覆盖__new__一定要写上这行代码
 
class Person(metaclass=MeMetaClass):
    pass
 
print(Person)   #<class '__main__.Person'>
 
#就算__init__中什么都不写,这个类对象其实已经创建完成了,该有的属性都有了
#这是与普通类不同之处
 
print(Person.__name__)  #不会报错
 
class Student:
    def __init__(self,name):
        pass
 
s = Student('张三')
# s.name      #报错

#练习1:
 
#需求:要求每个类必须包含__doc__属性,__doc__用于访问一个对象的注释信息
class A:
    '''
    this is A
    '''
    pass
 
print(A.__doc__)
 
#如果你要控制类的创建,那就自定义元类 覆盖__init__
class DocMetaClass(type):
    def __init__(self,class_name,bases,name_dic):
        super().__init__(class_name,bases,name_dic)
 
        # if not("__doc__" in name_dic and name_dic["__doc__"]):
        #     raise Exception
 
        #如果doc为空,则抛异常
        if not self.__doc__:
            raise Exception
 
class Person(metaclass=DocMetaClass):
    pass
 
print(type(object))

4 , 元类中 __call__

class Person:
    #调用对象时,会执行对象所在类中的__call__方法
    def __call__(self, *args, **kwargs):
        print("call")
        print(args)
        print(kwargs)
 
p = Person()
p()
 
'''
练习:将类中的为字符串的属性名转为大写
'''
class MyMeta(type):
    #获得某个类的实例
    def __call__(self, *args, **kwargs):
        print("call")
        # return super().__call__(*args,**kwargs)
        print(args)     #('jack', 'women', 18)
        print(kwargs)   #{}
 
        new_args = []
        for i in args:
            if isinstance(i,str):
                new_args.append(i.upper())
            else:
                new_args.append(i)
        print(new_args)     #['JACK', 'WOMEN', 18]
        return super().__call__(*new_args,**kwargs)
 
#注意:__new__  __init__是创建类对象时还会执行
#__call__ 类对象要产生实例时执行
 
class Student(metaclass=MyMeta):
    def __init__(self,name,gender,age):
        self.name = name
        self.gender = gender
        self.age = age
 
s = Student('jack','women',18)
print(s.age)        #
print(s.gender)     #WOMEN
 
class Person(metaclass=MyMeta):
    def __init__(self,name,gender):
        self.name = name
        self.gender = gender
 
p = Person('rose','name')
print(p.name)   #ROSE

5, 单例模式

'''
单例模式
    是一种设计模式,是单个实例的意思
    当你需要 让你的类仅有一个实例时,那就可以使用单例模式
'''''
class Person:
    obj = None
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
 
    def say(self):
        print('my name is %s my 姑姑 is 龙妈'%self.name)
 
    @classmethod
    def get_instance(cls):
        if not cls.obj:
            obj = cls('小龙女',19,'women')
            cls.obj = obj
            print('创建新的了')
        return cls.obj
 
# 调用了多次,产生了多个实例  (地址不一样)
p1 = Person('姬如雪','','women')
p1.say()
p2 = Person('姬如雪','','women')
p2.say()
print(p1,p2)  #<__main__.Person object at 0x000001A5A87076A0> <__main__.Person object at 0x000001A5A8707710>
 
#限制了类的实例化,如果为同一个类则只实例化一次 (地址一样)
p1 = Person.get_instance()
p1.say()
p2 = Person.get_instance()
p2.say()
 
print(p1)   #<__main__.Person object at 0x000002396C2F75C0>
print(p2)   #<__main__.Person object at 0x000002396C2F75C0>

6 , 元类实现单例

class SingMeta(type):
    # 创建类时会执行__init__,在这为每一类设置一个obj属性 默认为None
    def __init__(self, a, b, c):
        super().__init__(a, b, c)
        self.obj = None
        print(self.obj)
 
    # 当类要创建对象时会执行该方法
    def __call__(self, *args, **kwargs):
        # 判断这个类如果已经有了实例了就直接返回,从而实现单例
        if self.obj:
            return self.obj
 
        # 如果没有,则创建新的实例保存到类中
        obj = type.__call__(self, *args, **kwargs)
        self.obj = obj
        return obj
 
class Person(metaclass=SingMeta):
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
 
    def say(self):
        print("my name is %s  my 姑姑 is 龙妈" % self.name)
 
class Student(metaclass=SingMeta):
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender=gender
 
    def say(self):
        print("my name is %s  my 姑姑 is 龙妈" % self.name)
 
p1 = Person('姬如雪',20,'women')
p2 = Person('姬如雪',20,'women')
print(p1)       #<__main__.Person object at 0x000001F512867668>
print(p2)       #<__main__.Person object at 0x000001F512867668>
 
stu1 = Student('史蒂夫',18,'man')
stu2 = Student('史蒂夫',18,'man')
print(stu1)     #<__main__.Student object at 0x0000013B18EB7780>
print(stu2)     #<__main__.Student object at 0x0000013B18EB7780>

7, 单例案例:

class Single(type):
    def __init__(self,a,b,c):
        super().__init__(a,b,c)
        self.obj = None
 
    def __call__(self, *args, **kwargs):
        if self.obj:
            return self.obj
 
        obj = type.__call__(self,*args,**kwargs)
        self.obj = obj
        return obj
 
class QQPlayer(metaclass=Single):
    def __init__(self,voice_value,repeat=False):
        self.voice_value =voice_value
        self.repeat = repeat
 
    def play(self,file_path):
        if hasattr(self,'file_path'):
            self.stop()
 
        print('正在播放%s'%file_path)
        self.file_path = file_path
 
    def stop(self):
        print('%s--停止播放'%self.file_path)
 
#问题:每次播放一次,都是实例化一次
ply = QQPlayer(100,True)
ply.play('如果.mp3')
 
ply1 = QQPlayer(100,True)
ply1.play('后来.mp3')
 
ply2 = QQPlayer(100,True)
ply2.play('田鸥.mp3')
 
print(ply)      #<__main__.QQPlayer object at 0x000002B349C87550>
print(ply1)     #<__main__.QQPlayer object at 0x000002B349C87550>
print(ply2)     #<__main__.QQPlayer object at 0x000002B349C87550>

8, 常见异常

'''
语法错误: SyntaxError: invalid syntax
'''''
# if num > 1
 
# print('hello')
# a =
# b = 10
 
'''
类型错误: TypeError: 'int' object is not subscriptable
'''
# 1[:]
 
'''
下标错误: IndexError: list index out of range
'''
# li = [1,2,3,4]
# print(li[10])
 
'''
KeyError: 'xxx'
'''
# {'name':1}['xxx']
 
'''
FileNotFoundError: [Errno 2] No such file or directory: 'xxx'
'''
# with open('xxx')as f:
#     pass
 
'''
NameError: name 'name' is not defined
'''
# def func():
#     name
#     pass
# func()
 
'''
1,捕捉异常
'''
#语法一:
try:
    print('start')
    {'name':1}['xxx']
    print('over')
except:
    print(' key 不存在')
 
#语法二: 在except 中指定要处理的异常类型
try:
    print('start')
    {'name':1}['xxx']
    1[:]
    print('over')
except KeyError:
    print('出问题了')
 
#语法三 : 在except中可以指定多种异常类型,使用统一的处理方案,没啥用
try:
    print('start')
    {'name':1}['xxx']
    1[:]
    print('over')
except(KeyError,TypeError):
    print('出问题了')
 
#语法四 : 一个try可以跟多个except语句 每个处理不同的异常
try:
    print('start')
    {'name': 1}['xxx']
    1[:]
    print('over')
except KeyError:
    print('Key 不存在!')
except TypeError:
    print('要操作的类型不对啊!')
 
# 语法5 万能异常   尽量少用 因为 无法知道具体原因
try:
    print("start")
    # {"name":1}["xxx"]
    # 1[:]
    # name
    print("over")
except Exception:
    print("不知道啥原因 反正有问题!")
 
# 语法6 给异常对象取别名 从而访问一异常对象
# 之所以 能处理任何类型 是因为  Exception 是所有异常类的父类
try:
    print("start")
    # {"name":1}["xxx"]
    1[:]
    # name
    print("over")
except Exception as e:
    print("有问题! 原因为%s" % e)
    print(type(e))
 
# 最常用的方式 在处理异常时 一定要记得打印一下异常信息   否则 你的程序不会出问题  但是也不会正常运行
try:
    name
except NameError as e:
    print(e)
 
# 观光语法  else 将在代码没有异常时执行
try:
    a = 10
except Exception as e:
    print(e)
else:
    print("else???????? ")
 
class FileTypeException(Exception):
    pass
 
class Player:
    def play(self,path):
        if not path.endswith("mp3"):
            # print("文件类错误!")
            # z主动抛出异常
            raise FileTypeException("仅能播放mp3格式.....")
        print("播放%s" % path)
 
        assert path.endswith("mp3")
        print("播放%s" % path)
 
p = Player()
p.play("xxx.mp4")