python 声明dict key

一、实例创建

在创建实例时，调用__new__方法和__init__方法，这两个方法在没有定义时，是自动调用了object来实现的。python3默认创建的类是继承了object。

classA(object):def __init__(self, *args, **kwargs):
self.name, self.age, self.gender= args[:3]def __new__(cls, *args, **kwargs):print("__new__ has called.")return super(A, cls).__new__(cls)#可写为 super().__new__(cls) 或 object.__new__(cls)
a= A("Li", 27, "male")print(a.name, a.age, a.gender)"""__new__ has called.
Li 27 male"""
二、类的创建
以class关键字开头的上下文在定义时就已经被解释执行。而函数(包括匿名函数)在没被调用时是不执行的。这个过程本质上做了一件事情：从元类type那里创建了一个名为A的类，开辟类内存空间，并读取class语句的上下文，将类属性和方法写进去。
print("--解释器开始执行--")deffunc():print("what the hell?")print("--开始读取class关键字的上下文--")classA:
name= "A"func()print("--上下文结束--")deffn1():print("--开始读取匿名函数--")deffn2():pass
pass
print("--读取结束--")print("--解释器执行结束--")"""--解释器开始执行--
--开始读取class关键字的上下文--
what the hell?
--上下文结束--
--解释器执行结束--"""
" 使用class语句定义新类时，将会发生很多事情。首先，类主体将为作其自己的私有字典内的一系列语句来执行。其内容里语句的执行与正常代码中的执行过程相同，只是增加了会在私有成员(名称以__开头)上发生的名称变形。然后，类的名称、基类列表和字典将传递给元类的解构函数，以创建相应的类对象。最后，调用元类type()，这里可以自定义。在python3中，使用class Foo(metaclass=type)来显式地指定元类。如果没有找到任何__metaclass__值，Python将使用默认的元类type。"  -- <>
class_name = "Foo" #类名
class_parents = (object, ) #基类#类主体
class_body = """name = "Foo"
def __init__(self, x):
self.x = x
def hello(self):
print("Hello")"""class_dict={}#在局部字典class_dict中执行类主体
exec(class_body, globals(), class_dict)#创建类对象Foo
Foo = type(class_name, class_parents, class_dict) #type可以指定
Foo("X").hello()#Hello
type类创建类时，指定了类的三个部分: class_name, class_parent, class_dict。这一步是在底层实现的。


string = """name = 'Li'
age = 2712"""
#字符串必须是换行符或分号分割
dic ={}exec(string, globals()) #globals表示执行字符串后的结果保存到全局命名空间中
print(name, age)print(dic)exec(string, globals(), dic) #locals表示执行字符串后的结果保存到局部一个映射对象中
print(dic)"""Li 2712
{}
{'name': 'Li', 'age': 2712}"""
exec函数用法
我们可以用type动态地创建类。你可以用上面的方式去实现类的上下文，也可以直接定义函数并给到字典里，尽管它看起来有些"污染"全局空间:
class_name = "A"class_parent=()
label= "hello world"
definit(self, name, age):
self.name=name
self.age=agedefhello(self):print("Hello, i'm %s, %s." %(self.name, self.age))
A= type(class_name, class_parent, {"__init__": init, "hello": hello, "label": label})
a= A("Li", 18)
a.hello()print(a.label)"""Hello, i'm Li, 18.
hello world"""
三、元类的实现过程
复制代码print("First...")classMyType(type):print("MyType begin ...")def __init__(self, *args, **kwargs):print("Mytype __init__", self, *args, **kwargs , sep="\r\n", end="\r\n\r\n")
type.__init__(self, *args, **kwargs) #调用type.__init__
def __call__(self, *args, **kwargs):print("Mytype __call__", *args, **kwargs)
obj= self.__new__(self) #第一个self是Foo，第二个self是F("Alex")
print("obj",obj, *args, **kwargs)print(self)
self.__init__(obj,*args, **kwargs)returnobjdef __new__(cls, *args, **kwargs):print("Mytype __new__", cls, *args, **kwargs, sep="\r\n", end="\r\n\r\n")return type.__new__(cls, *args, **kwargs)print("MyType end ...")print('Second...')class Foo(metaclass=MyType):print("begin...")def __init__(self, name):
self.name=nameprint("Foo __init__")def __new__(cls, *args, **kwargs):print("Foo __new__", end="\r\n\r\n")return object.__new__(cls)print("over...")def __call__(self, *args, **kwargs):print("Foo __call__", self, *args, **kwargs, end="\r\n\r\n")print("third...")
f= Foo("Alex")print("f",f, end="\r\n\r\n")
f()print("fname",f.name)"""First...
MyType begin ...
MyType end ...
Second...
begin...
over...
Mytype __new__
Foo
()
{'__module__': '__main__', '__qualname__': 'Foo', '__init__': , '__new__': , '__call__': }
Mytype __init__
Foo
()
{'__module__': '__main__', '__qualname__': 'Foo', '__init__': , '__new__': , '__call__': }
third...
Mytype __call__ Alex
Foo __new__
obj <__main__.foo object at> Alex
Foo __init__
f <__main__.foo object at>
Foo __call__ <__main__.foo object at>
fname Alex"""

假设MyType是type类，type有三个特殊方法__init__、__call__、__new__。

首先, First请忽略掉吧。假设底层就这样搞了一个type类，它的名字叫MyType。

其次，Second这一步。解释器发现class和Foo()，会知道要从元类MyType中"实例化"一个类对象。

它会首先扫描class Foo()的整个上下文，并分成三部分，类名、基类元组，和私有字典。

然后它会告诉解释器，马上调用MyType(就是Type)类来创建一个名为Foo的类，来开辟内存空间，把这个Foo的私有字典(包括属性和方法)给放进去。

于是解释器执行了MyType.__new__，并继续执行MyType.__init__。来创建一个名为Foo的类对象。

再次，Third这一步。

首先通过Foo()来调用MyType.__call__，来实例化一个Foo类。它相当于Foo = Type()

然后依次执行Foo.__new__和Foo.__init__，来实例化一个实例对象。

Foo()相当于: MyType()()，而MyType()就是F。于是，在a = Foo()，实际上执行了MyType()()。前面说过，实例+()会调用所属类的__call__方法，同样地，类 + ()会调用类所属元类(MyType)的__call__方法。

至此，一个实例就算创建完成了。

四、抽象基类

抽象基类有两个特点：

1.规定继承类必须具有抽象基类指定的方法

2.抽象基类无法实例化

基于上述两个特点，抽象基类主要用于接口设计

实现抽象基类可以使用内置的abc模块

importabcclass Human(metaclass=abc.ABCMeta):
@abc.abstractmethod#规定子类必须有名为introduce的实例方法
defintroduce(self):[e-mail]#规定子类必须有名为country的装饰器方法
defcountry(self):[e-mail]#规定子类必须有名为gender的类方法
defgender(cls):[e-mail]#规定子类必须有名为hello的静态方法
defhello():pass
classPerson(Human):__country = "China"
def __init__(self, name, age):
self.name=name
self.age=agedefintroduce(self):return "I'm {}, {}.".format(self.name, self.age)
@propertydefcountry(self):return Person.__country@classmethoddefgender(cls):return "female"@staticmethoddefhello():print("What the hell?")
person= Person("Li", 24)print(person.introduce())print(person.country)print(Person.gender())
person.hello()#I'm Li, 24.#China#female#What the hell?
collections.abc模块收集了常用的抽象基类。感兴趣的话可以打开collections.abc查看源码。
__all__ = ["Awaitable", "Coroutine","AsyncIterable", "AsyncIterator", "AsyncGenerator","Hashable", "Iterable", "Iterator", "Generator", "Reversible","Sized", "Container", "Callable", "Collection","Set", "MutableSet","Mapping", "MutableMapping","MappingView", "KeysView", "ItemsView", "ValuesView","Sequence", "MutableSequence","ByteString",
]