>>> class ObjectCreator(object):

…       pass

class Test1(object):

    name="alex"

    age = 30

Test2 = type("Test2",(object,),{"name":"alex","age":30})

# 析构方法

def __init__(self,name,age):

    self.name = name

    self.age = age

# 实例方法

def foo(self):

    print("in the foo",self)

# 类方法

@classmethod

def bar(cls):

    print("in the foo",cls)

#静态方法

@staticmethod

def cal():

    print("in the cal")

Test =type("Test",(object,),{"info":"这是一个type实例化的类","foo":foo,"bar":bar,"cal":cal,"__init__":__init__})

test = Test("alex",22)

test.bar()

test.foo()

test.cal()

MyClass = MetaClass()  # 使用元类创建出一个对象，这个对象称为“类”

my_object = MyClass()  # 使用“类”来创建出实例对象

MyClass = type('MyClass', (), {})

class MyType(type):

    def __new__(cls,name,prants,attrs):

        print("in the MyType..")

        return type(name,prants,attrs)

    pass

class Foo(object,metaclass=MyType):

    pass

print(Foo.__class__)

class UpperAttrMetaClass(type):

    # __new__ 是在__init__之前被调用的特殊方法

    # __new__是用来创建对象并返回之的方法

    # 而__init__只是用来将传入的参数初始化给对象

    # 你很少用到__new__，除非你希望能够控制对象的创建

    # 这里，创建的对象是类，我们希望能够自定义它，所以我们这里改写__new__

    # 如果你希望的话，你也可以在__init__中做些事情

    # 还有一些高级的用法会涉及到改写__call__特殊方法，但是我们这里不用

    def __new__(cls, class_name, class_parents, class_attr):

        # 遍历属性字典，把不是__开头的属性名字变为大写

        new_attr = {}

        for name, value in class_attr.items():

            if not name.startswith("__"):

                new_attr[name.upper()] = value

        # 方法1：通过'type'来做类对象的创建

        return type(class_name, class_parents, new_attr)

        # 方法2：复用type.__new__方法

        # 这就是基本的OOP编程，没什么魔法

        # return type.__new__(cls, class_name, class_parents, new_attr)

# python3的用法

class Foo(object, metaclass=UpperAttrMetaClass):

    bar = 'bip'

# python2的用法

# class Foo(object):

#     __metaclass__ = UpperAttrMetaClass

#     bar = 'bip'

print(hasattr(Foo, 'bar'))

# 输出: False

print(hasattr(Foo, 'BAR'))

# 输出:True

f = Foo()

print(f.BAR)

# 输出:'bip'

class ModelMetaclass(type):

    def __new__(cls, name, bases, attrs):

        mappings = dict()

        # 判断是否需要保存

        for k, v in attrs.items():

            # 判断是否是指定的StringField或者IntegerField的实例对象

            if isinstance(v, tuple):

                print('Found mapping: %s ==> %s' % (k, v))

                mappings[k] = v

        # 删除这些已经在字典中存储的属性

        for k in mappings.keys():

            attrs.pop(k)

        # 将之前的uid/name/email/password以及对应的对象引用、类名字

        attrs['__mappings__'] = mappings  # 保存属性和列的映射关系

        attrs['__table__'] = name  # 假设表名和类名一致

        return type.__new__(cls, name, bases, attrs)

class User(metaclass=ModelMetaclass):

    uid = ('uid', "int unsigned")

    name = ('username', "varchar(30)")

    email = ('email', "varchar(30)")

    password = ('password', "varchar(30)")

    # 当指定元类之后，以上的类属性将不在类中，而是在__mappings__属性指定的字典中存储

    # 以上User类中有

    # __mappings__ = {

    #     "uid": ('uid', "int unsigned")

    #     "name": ('username', "varchar(30)")

    #     "email": ('email', "varchar(30)")

    #     "password": ('password', "varchar(30)")

    # }

    # __table__ = "User"

    def __init__(self, **kwargs):

        for name, value in kwargs.items():

            setattr(self, name, value)

    def save(self):

        fields = []  # 用来存储获取的字段名

        args = []  # 用来存储值

        for k, v in self.__mappings__.items():

            fields.append(v[0])

            args.append(getattr(self, k, None))

        # 由于传入的值需为字符串类型则进行转换

        args_temp = list()

        for temp in args:

            # 判断入如果是数字类型

            if isinstance(temp, int):

                args_temp.append(str(temp))

            elif isinstance(temp, str):

                args_temp.append("""'%s'""" % temp)

        sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(args_temp))

        print('SQL: %s' % sql)

u = User(uid=12345, name='Michael', email='test@orm.org', password='my-pwd')

# print(u.__dict__)

u.save()