一.eval与exect内置函数
eval内置函数的使用场景：
1.执行字符串会得到相应的执行结果 2.一般用于类型转化，得到dict、list、tuple等 # "{'a': 1, 'b': 2, 'c': 3}" => {'a': 1, 'b': 2, 'c': 3} data_str="{'a': 1, 'b': 2, 'c': 3}" res = eval(data_str) print(res, type(res)) #{'a': 1, 'b': 2, 'c': 3} <class 'dict'>
exec应用场景:
# 1.执行字符串没有执行结果(没有返回值) # 2.将执行的字符串中产生的名字形成对应的局部名称空间 s = ''' my_a = 10 my_b = 20 def __init__(self): pass @classmethod def print_msg(msg): print(msg) ''' l_dic = {} exec(s, {}, l_dic) #s是自定义字符串,包含属性和方法,{}是全局名称空间,设为空字典就行, #执行exec后s中的内容会给到局部名称空间l_dic字典中 print(l_dic) #{'my_a': 10, 'my_b': 20, '__init__': <function __init__ at 0x01EDEA50>...}
那么可以用exec创建一个对象的名称空间:
source = ''' name = 'Bob' age = 20 ''' #source是自定义字符串
class A: pass a = A() #这个类中没有init函数,实例化的对象没有创建名称空间
dic = {} exec(source, {}, dic) #执行exec后source中的内容会给到局部名称空间dic字典中 a.__dict__ = dic # 对象a的名称空间本来为空,现在将dic替换掉a的名称空间 print(a.__dict__) # {'name': 'Bob', 'age': 20} print(a.name) # Bob print(a.age) # 20
二.元类的基本定义:
Python中万物皆对象，所有用来创建对象的类，本身也是对象，类是type类的对象
type类叫做元类，是所有元类(包括自定义元类)的基类
元类：造类的类 - 也就是类的类
-- 控制类的产生
-- 控制类的对象的产生
三.自定义元类:
那么我们先来看一下type中有哪几个参数:
class MyMeClass(type):
#这是一个自定义元类,控制User类的产生,这里主要看参数,下面会详细介绍 def __new__(cls, *args,**kwargs): print(args) # ('User', (<class 'object'>,), {'__module__': '__main__', '__qualname__': 'User', '__init__': <function User.__init__ at 0x07F8D930>}) #第一个是类名,第二是基类,第三个是名称空间
print(kwargs) # {} return type.__new__(cls,*args,**kwargs) class User(object,metaclass=MyMeClass): def __init__(self,name ): self.name = name
用type造个类看看,利用 type(classname, basename, namespace)直接造类:
s = ''' wudaorong="小可爱" ''' namespace ={} exec(s,{},namespace) Student = type('Student',(object,),namespace) #基类可能会继承多个,所以用元组括起来,可以什么都不写,则默认是object print(Student.__dict__) stu=Student() print(stu.wudaorong)
自定义元类都是继承type的,先来看它的__init__方法:
class MyMeta(type): # 自定义元类，重写init方法的目的： # 1.该方法是从type中继承来的，所以参数同type的init # 2.最终的工作,如果开辟空间,还是要借助type # 3.在交给type最终完成工作之前，可以对类的创建加以限制 def __init__(cls, class_name, bases, namespace): # 继承type的init方法 super().__init__(class_name, bases, namespace) #可以查看每个控制的类的各参数 print(cls) print(class_name) print(bases) print(namespace) #自定义除type外新加要求: # 需求1：由给元类控制的类的类名必须首字母大写 if not class_name.istitle(): raise NameError('名字首字母必须大写') # 需求2：定义类是必须明确父类 if len(bases) == 0: raise Exception('父类必须明确') #创建类方式一: s=''' def __init__(self, name, age): self.name = name self.age = age ''' namespace={} exec(s,{},namespace) Student = MyMeta('Student', (object,), namespace ) #创建类方式二: class Student(object, metaclass=MyMeta): def __init__(self, name, age): self.name = name self.age = age #继承仍生效,同时让它也受MyMeta控制 class Xuesheng(Student, metaclass=MyMeta): pass
除了控制类,我们还可以对它实例化出来的对象进行控制(__call__方法):
class MyMeta(type): # 自定义元类，重写call方法的目的： # 1.被该元类控制的类生成对象，会调用元类的call方法 # 2.在call中的返回值就是创建的对象 # 3.在call中 # -- 通过object开辟空间产生对象 # -- 用被控制的类回调到自己的init方法完成名称空间的赋值 # -- 将修饰好的对象反馈给外界 def __call__(cls, *args, **kwargs): print('我是小胖啊') obj = object.__new__(cls) # 需求：所有通过该元类控制的类产生的对象都有meta_name该属性 obj.meta_name = cls.__name__ # obj.name = args[0] # 调回当前被控制的类自身的init方法，完成名称空间的赋值 cls.__init__(obj, *args, **kwargs) return obj class Student(object, metaclass=MyMeta): def __init__(self, name, age): self.name = name self.age = age #继承仍生效,同时让它也受MyMeta控制 class Xuesheng(Student, metaclass=MyMeta): hobby='打游戏' xs=Xuesheng('wdr',18) cls_name=xs.meta_name name=xs.name hobby=xs.hobby print(cls_name,name,hobby) print(xs.__dict__,Xuesheng.__dict__)
注: 实例化在走init方法先会被自定义元类的__call__方法修饰后才完成:
class Foo: def __init__(self): print('__init__') def __call__(self, *args, **kwargs): print('__call__') obj = Foo() # 执行 __init__ obj() # 执行 __call__
可能对__new__方法有疑惑,再来看看__new__:
1. 类一旦重写__new__方法,该类的实例化由__new__来控制,__init__会失效 class A: def __init__(self,name): self.name=name def __new__(cls, name): cls.name = name #下面的的a其实是A元类实例化出来的,即a就是A这个类本身 #把__new__写在某个类里面就是要自定义这个类 a= A('小胖') print(A.__dict__)
打印a.__dict__会报错,因为没有走__init__
2.如果还想控制这个类的对象,要借助object.__new__:
class A:
def __init__(self,name):
self.name=name
def __new__(cls, name,*args, **kwargs):
cls.name = name
obj = object.__new__(cls)
# 先利用object.__new__开辟了一个对象内存空间,然后赋予属性实例化
#这里可以可以直接给属性赋值,没有则走__init__,必须把这个对象返回
return obj
a= A('小胖')
print(A.__dict__,a.__dict__)
四.单例
单例：一个类只能产生一个实例 为什么要有单例： 1.该类需要对象的产生 2.对象一旦产生，在任何位置再实例化对象，只能得到第一次实例化出来的对象
3.在对象唯一创建后,可以通过属性修改或利用方法间接修改属性,来完成数据的更新,但不能通过实例化方式更新数据
方式1 :任何文件在任何地方通过导入拿到的是唯一对象
class Songs(): pass # s1 = Songs() # s2 = Songs() # print(s1, s2), 产生不同对象 # 对外提供的对象 song = Songs() #外界通过导包拿到这个对象都是一样的 from part1.SingleModule import song print(song) from part1.SingleModule import song print(song) from part1.SingleModule import song print(song)
方式2:用类方法来获取唯一对象
class Songs(): __instance = None @classmethod def getInstance(cls): # 对象没有创建返回，有直接返回 if cls.__instance == None: cls.__instance = cls() #把第一次实例化对象的内存地址传给类__instance属性 return cls.__instance s1 = Songs.getInstance() s2 = Songs.getInstance() print(s1, s2)
方式3:利用obj.__new__方法:
class Songs:
__instance = None
def __new__(cls, song_name, *args, **kwargs):
if cls.__instance == None:
cls.__instance = object.__new__(cls)
cls.__instance.song_name = song_name
#先利用object.__new__开辟了一个对象内存空间,然后赋予属性实例化
return cls.__instance
#通过类方法可以修改属性值
def change_song(self, song_name):
self.song_name = song_name
s1 = Songs('菊花台')
s2 = Songs('东风破')
print(s1.song_name, s2.song_name) # 菊花台 菊花台
s2.change_song('青花瓷')
print(s1.song_name, s2.song_name) # 青花瓷 青花瓷
方式4.装饰器完成单例:
def outer(cls): _instance = None def inner(*args, **kwargs): nonlocal _instance if _instance == None: _instance = cls(*args, **kwargs) return _instance return inner @outer # Songs = outer(Songs) class Songs: pass s1 = Songs() s2 = Songs() print(s1, s2)
方式5.通过元类完成单例:
class SingleMeta(type): __instance = None def __call__(cls, *args, **kwargs): if SingleMeta.__instance == None: SingleMeta.__instance = object.__new__(cls) cls.__init__(SingleMeta.__instance, *args, **kwargs) return SingleMeta.__instance class Songs(metaclass=SingleMeta): def __init__(self): pass pass s1 = Songs() s2 = Songs() print(s1, s2)