def hello(self):print("hello")
Person = type('Person',(object, ), {'country':'China', 'hello':hello})
p1 = Person()
print(p1.country)
p1.hello()

测试结果：

China
hello

3.什么是元类？

# 实现单例模式的方法:
#       1. 装饰器
#       2. new魔术方法
#       3. metaclass自定义元类class Singleton(type):"""type(name, bases, attrs)自定义元类实现单例模式, 父类是type"""# 所有类和实例化对象之间的关系; eg: {'Person': Pseron()}cache = {}# 1). 为什么是__call__魔术方法?def __call__(cls):# 判断类是否已经实例化， 如果没有， 实例化后存储到缓存中。 最后将缓存的信息返回给用户。if cls not in  cls.cache:cls.cache[cls] = super(Singleton, cls).__call__()return  cls.cache[cls]# type('Pseron', (), {})
# 创建以各类Person, 指定创建Person类的类(元类)是type.
# 2. metaclass是在做什么? 指定元类为Singleton。
class Person(object, metaclass=Singleton):  # Person = Singleton.__new__(Person, (objects, ), {})pass# Person是Singleton元类实例化出的对象, Person()就是对象(), 执行Singleton.__call__魔术方法.
p1 = Person()
p2 = Person()
print(p1, p2)

<__main__.Person object at 0x00000241B3386C50> <__main__.Person object at 0x00000241B3386C50>

import abc
class Human(metaclass=abc.ABCMeta):"""基类， 定义一个抽象类"""@abc.abstractmethod               #规定子类必须有名为introduce的实例方法def introduce(self):print("introduce.....")@abc.abstractmethoddef hello(self):print('hello')class Person(Human):# 1).规定继承类必须具有抽象基类指定的方法def introduce(self):print('person')def hello(self):print('person hello')# 2). 抽象基类无法实例化
# h = Human()
p = Person()
p.introduce()
p.hello()

person
person hello

四、__slots__

python中的new-style class要求继承Python中的一个内建类型，一般继承object，也可以继承list或者dict等其他的内建类型。
在python新式类中，可以定义一个变量__slots__，它的作用是阻止在实例化类时为实例分配dict，

默认情况下每个类都会有一个dict,通过__dict__访问，这个dict维护了这个实例的所有属性，举例如下：

class base(object):  var=9 #类变量  def __init__(self):  pass  b=base()  
print b.__dict__  
b.x=2 #添加实例变量  
print b.__dict__  

 运行结果：

{ }
{'x': 2}

可见：实例的dict只保持实例的变量，对于类的属性是不保存的，类的属性包括变量和函数。由于每次实例化一个类都要分配一个新的dict，因此存在空间的浪费，因此有了__slots__。
__slots__是一个元组，包括了当前能访问到的属性。
当定义了slots后，slots中定义的变量变成了类的描述符，相当于java，c++中的成员变量声明，类的实例只能拥有slots中定义的变量，不能再增加新的变量。注意：定义了slots后，就不再有dict。如下：

class base(object):  __slots__=('x')  var=8  def __init__(self):  pass  b=base()  
b.x=88 #添加实例变量  
print b.x  
#b.y=99 #无法添加slots之外的变量 (AttributeError: 'base' object has no attribute 'y')  
#print b.__dict__ #定义了__slots__后，就不再有__dict__ (AttributeError: 'base' object has no attribute '__dict__') 

运行结果：

88

如果类变量与slots中的变量同名，则该变量被设置为readonly！！！如下：

class base(object):  __slots__=('y')  y=22 # y是类变量,y与__slots__中的变量同名  var=11  def __init__(self):  pass  b=base()  
print b.y  
print base.y  
#b.y=66 #AttributeError: 'base' object attribute 'y' is read-only

 运行结果：

22
22

Python是一门动态语言，可以在运行过程中，修改实例的属性和增删方法。一般，任何类的实例包含一个字典__dict__,
Python通过这个字典可以将任意属性绑定到实例上。有时候我们只想使用固定的属性，而不想任意绑定属性，
这时候我们可以定义一个属性名称集合，只有在这个集合里的名称才可以绑定。__slots__就是完成这个功能的。

class test_slots(object):  __slots__='x','y'  def printHello(self):  print 'hello!'  class test(object):  def printHello(self):  print 'hello'  print dir(test_slots) #可以看到test_slots类结构里面包含__slots__,x,y  
print dir(test)#test类结构里包含__dict__  
print '**************************************'  
ts=test_slots()  
t=test()  
print dir(ts) #可以看到ts实例结构里面包含__slots__,x,y，不能任意绑定属性  
print dir(t) #t实例结构里包含__dict__,可以任意绑定属性  
print '***************************************'  
ts.x=11 #只能绑定__slots__名称集合里的属性  
t.x=12 #可以任意绑定属性  
print ts.x,t.x  
ts.y=22 #只能绑定__slots__名称集合里的属性  
t.y=23  #可以任意绑定属性  
print ts.y,t.y  
#ts.z=33 #无法绑定__slots__集合之外的属性(AttributeError: 'test_slots' object has no attribute 'z')  
t.z=34 #可以任意绑定属性  
print t.z 

运行结果：

['__class__', '__delattr__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__slots__', '__str__', '__subclasshook__', 'printHello', 'x', 'y']
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'printHello']
**************************************
['__class__', '__delattr__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__slots__', '__str__', '__subclasshook__', 'printHello', 'x', 'y']
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'printHello']
***************************************
11 12
22 23
34

正如上面所说的，默认情况下,Python的新式类和经典类的实例都有一个dict来存储实例的属性。这在一般情况下还不错，而且非常灵活，
乃至在程序中可以随意设置新的属性。但是，对一些在”编译”前就知道有几个固定属性的小class来说，这个dict就有点浪费内存了。
当需要创建大量实例的时候，这个问题变得尤为突出。一种解决方法是在新式类中定义一个__slots__属性。
__slots__声明中包含若干实例变量，并为每个实例预留恰好足够的空间来保存每个变量；这样Python就不会再使用dict，从而节省空间。

import time
from datetime import  dateclass Date(object):# __slots__ 来限制该对象能添加的属性信息__slots__ =  '__year', '__month', '__day'def __new__(cls, year, month, day):self = object.__new__(cls)self.__year = yearself.__month = monthself.__day = dayreturn  self@propertydef year(self):return  self.__year@propertydef month(self):return self.__month@propertydef day(self):return self.__day@classmethoddef today(cls):time_t = time.localtime()return  cls(time_t.tm_year, time_t.tm_mon, time_t.tm_mday)def __str__(self):return  '%s-%s-%s' %(self.__year, self.__month, self.__day)d = Date(2019, 10, 10)
print("对象类型: ", type(d))        # <class 'datetime.date'>
print("判断是否有year这个属性?", hasattr(d, 'year')) # True
print("判断是否有time这个属性?", hasattr(d, 'time')) # Falseprint(Date.today())

运行结果：

对象类型:  <class '__main__.Date'>
判断是否有year这个属性? True
判断是否有time这个属性? False
2020-1-7