#  #











 `__metaclass__` 

metaclass





metaclassmetaclass

metaclass

metaclass 

 metaclass 

```python
class MyObject(object):
    __metaclass__ = something
[]
```

Python  MyObject

 `class MyObject(object)` MyObject P

ython  `__metaclass__` Python  MyObject type 

![__metaclass__](https://user-gold-cdn.xitu.io/2017/9/6/06c5a4390887abd3d79401848742f5ce)




```python
class Foo(Bar):
    pass
```



 Foo  `__metaclass__` Python  `__metaclass__`  Foo  Python `__metaclass__`  Bar`__metaclass__`  Python `__metaclass__`  `__metaclass__` ` ` `__metaclass__` ,Python  type 

 `__metaclass__`  class  class  instance metaclass  class class  metaclass  instance


 `__metaclass__` 

type type  type 

****

API `__metaclass__` 

`__metaclass__` 

```python
# type
def upper_attr(future_class_name, future_class_parents, future_class_attr):
    ''''''
    #  '__'
    attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))
```


```python
# 
uppercase_attr = dict((name.upper(), value) for name, value in attrs)
 
# 'type'
return type(future_class_name, future_class_parents, uppercase_attr)
 
__metaclass__ = upper_attr  
#  
 
class Foo(object):
    # __metaclass__
    bar = 'bip'
```

```python
print hasattr(Foo, 'bar')
# : False
print hasattr(Foo, 'BAR')
# :True
 
f = Foo()
print f.BAR
# :'bip'
```

 class 

```python
# 'type''str''int'
# type
class UpperAttrMetaClass(type):
    # __new__ __init__
    # __new__
    # __init__
    # __new__
    # __new__
    # __init__
    # __call__
    def __new__(upperattr_metaclass, future_class_name, future_class_parents, future_class_attr):
        attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))
        uppercase_attr = dict((name.upper(), value) for name, value in attrs)
        return type(future_class_name, future_class_parents, uppercase_attr)

```

 OOP type `__new__` :

```python

class UpperAttrMetaclass(type):
    def __new__(upperattr_metaclass, future_class_name, future_class_parents, future_class_attr):
        attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))
        uppercase_attr = dict((name.upper(), value) for name, value in attrs)
 
        # type.__new__
        # OOP
        return type.__new__(upperattr_metaclass, future_class_name, future_class_parents, uppercase_attr)
```

 `upperattr_metaclass`  self  self 

```python
class UpperAttrMetaclass(type):
    def __new__(cls, name, bases, dct):
        attrs = ((name, value) for name, value in dct.items() if not name.startswith('__')
        uppercase_attr  = dict((name.upper(), value) for name, value in attrs)
        return type.__new__(cls, name, bases, uppercase_attr)

```

 super  type 

```python
class UpperAttrMetaclass(type):
    def __new__(cls, name, bases, dct):
        attrs = ((name, value) for name, value in dct.items() if not name.startswith('__'))
        uppercase_attr = dict((name.upper(), value) for name, value in attrs)
        return super(UpperAttrMetaclass, cls).__new__(cls, name, bases, uppercase_attr)
```



* 
* 
*