2. 程式人生 > >python——type()、metaclass元類和精簡ORM框架

python——type()、metaclass元類和精簡ORM框架

阿新 • • 發佈：2018-05-09
定制 定義 attribute varchar elm cep 實例 編寫代碼 __main__

1、type（）函數

#type()函數既可以返回一個對象的類型，又可以創建出新的類型，  
# 比如，我們可以通過type()函數創建出Hello類，而無需通過class Hello(object)...的定義：  
  
def fn(self,name=‘world‘):  #先定義函數  
    print(‘Hello, %s.‘%name)  
#開始用type()  
hello = type(‘Hello‘,(object,),dict(hello=fn))  # 創建Hello class  
#要創建一個class對象，type()函數依次傳入3個參數：  
#class的名稱；  
#繼承的父類集合，註意Python支持多重繼承，如果只有一個父類，別忘了tuple的單元素寫法；  
#class的方法名稱與函數綁定，這裏我們把函數fn綁定到方法名hello上。

　

#type()函數既可以返回一個對象的類型，又可以創建出新的類型，
# 比如，我們可以通過type()函數創建出Hello類，而無需通過class Hello(object)...的定義：

def fn(self,name=‘world‘):  #先定義函數
    print(‘Hello, %s.‘%name)
#開始用type()
hello = type(‘Hello‘,(object,),dict(hello=fn))  # 創建Hello class
#要創建一個class對象，type()函數依次傳入3個參數：
#class的名稱；
#繼承的父類集合，註意Python支持多重繼承，如果只有一個父類，別忘了tuple的單元素寫法；
#class的方法名稱與函數綁定，這裏我們把函數fn綁定到方法名hello上。

　　

if __name__ == ‘__main__‘:  
    h = hello()  
    h.hello()  
    print(type(hello))  
    print(type(h))  

if __name__ == ‘__main__‘:
    h = hello()
    h.hello()
    print(type(hello))
    print(type(h))


Hello, world.  
<class ‘type‘>  
<class ‘__main__.Hello‘>  

Hello, world.
<class ‘type‘>
<class ‘__main__.Hello‘>

2、metaclass元類

#metaclass   元類   metaclass允許你創建類或者修改類  
class Listmetaclass(type):  
    def __new__(cls, name,bases,attrs):  
        attrs[‘add‘] = lambda self,value:self.append(value) #增加了add（）方法  
        return type.__new__(cls,name,bases,attrs)  
class MyList(list,metaclass=Listmetaclass):  
    pass  
#__new__()方法接收到的參數依次是：  
  
#1、當前準備創建的類的對象；  
#2、類的名字；  
#3、類繼承的父類集合；  
#4、類的方法集合。  
  
  
#元類一般情況不常用，但總會遇到需要通過metaclass修改類定義的。ORM就是一個典型的例子。  
#ORM全稱“Object Relational Mapping”，即對象-關系映射，就是把關系數據庫的一行映射為一個對象，  
# 也就是一個類對應一個表，這樣，寫代碼更簡單，不用直接操作SQL語句。  
#要編寫一個ORM框架，所有的類都只能動態定義，因為只有使用者才能根據表的結構定義出對應的類來。

　　

#metaclass   元類   metaclass允許你創建類或者修改類
class Listmetaclass(type):
    def __new__(cls, name,bases,attrs):
        attrs[‘add‘] = lambda self,value:self.append(value) #增加了add（）方法
        return type.__new__(cls,name,bases,attrs)
class MyList(list,metaclass=Listmetaclass):
    pass
#__new__()方法接收到的參數依次是：

#1、當前準備創建的類的對象；
#2、類的名字；
#3、類繼承的父類集合；
#4、類的方法集合。


#元類一般情況不常用，但總會遇到需要通過metaclass修改類定義的。ORM就是一個典型的例子。
#ORM全稱“Object Relational Mapping”，即對象-關系映射，就是把關系數據庫的一行映射為一個對象，
# 也就是一個類對應一個表，這樣，寫代碼更簡單，不用直接操作SQL語句。
#要編寫一個ORM框架，所有的類都只能動態定義，因為只有使用者才能根據表的結構定義出對應的類來。

　　

if __name__ == ‘__main__‘:  
    L = MyList()  
    L.add(2)  #增加了add（）方法  
    L.add(3)  
    print(L)  

if __name__ == ‘__main__‘:
    L = MyList()
    L.add(2)  #增加了add（）方法
    L.add(3)
    print(L)

[2, 3]


3、精簡ORM框架





#開始編寫ORM框架  
class Field(object):  
    def __init__(self,name,column_type):  
        self.name = name  
        self.column_type = column_type  
    def __str__(self):  
        return ‘<%s:%s>‘%(self.__class__.__name__,self.name)  
  
class StringField(Field):  
    def __init__(self,name):  
        super(StringField,self).__init__(name,‘varchar(100)‘)  
  
class IntegerField(Field):  
    def __init__(self,name):  
        super(IntegerField,self).__init__(name,‘bigint‘)  
#下一步，就是編寫最復雜的ModelMetaclass了：  
class ModelMetaclass(type):  
    def __new__(cls, name,bases,attrs):  
        if name == ‘Model‘:  #排除掉對Model類的修改；  
            return type.__new__(cls,name,bases,attrs)  
        print(‘Found Model: %s‘%name)  
        mappings = dict()  
        for k,v in attrs.items(): #查找定義的類的所有屬性，  
            if isinstance(v,Field): #如果找到一個Field屬性，  
                print(‘Found mapping: %s ==> %s‘ % (k, v))  
                mappings[k] = v  #就把它保存到一個__mappings__的dict中  
        for k in mappings.keys():  
            attrs.pop(k)  #同時從類屬性中刪除該Field屬性，否則，容易造成運行時錯誤（實例的屬性會遮蓋類的同名屬性）；  
        attrs[‘__mappings__‘] = mappings # 保存屬性和列的映射關系  
        attrs[‘__table__‘] = name  # 假設表名和類名一致  把表名保存到__table__中  
        return type.__new__(cls,name,bases,attrs)  
  
#基類Model  
class Model(dict,metaclass=ModelMetaclass):  
    def __init__(self,**kw):  
        super(Model,self).__init__(**kw)  
    def __getattr__(self, item):  #沒有找到的屬性，就在這裏找  
        try:  
            return self[item]  
        except KeyError:  
            raise AttributeError(r"‘Model‘ object has no attrs :‘%s‘"%item)  
  
    def __setattr__(self, key, value):  
        self[key] = value  
  
    def save(self):  
        fields = []  
        params = []  
        args = []  
        for k,v in self.__mappings__.items():  
            fields.append(v.name)  
            params.append(‘?‘)  
            args.append(getattr(self,k,None))  
        sql = ‘insert into %s (%s) values (%s)‘ % (self.__table__, ‘,‘.join(fields), ‘,‘.join(params))  
        print(‘SQL: %s‘ % sql)  
        print(‘ARGS: %s‘ % str(args))  
  
#子類User  
# 定義類的屬性到列的映射：  
class User(Model):  
    id = IntegerField(‘id‘)  
    name = StringField(‘username‘)  
    email = StringField(‘email‘)  
    password = StringField(‘password‘)  
    age = IntegerField(‘age‘)  

#開始編寫ORM框架
class Field(object):
    def __init__(self,name,column_type):
        self.name = name
        self.column_type = column_type
    def __str__(self):
        return ‘<%s:%s>‘%(self.__class__.__name__,self.name)

class StringField(Field):
    def __init__(self,name):
        super(StringField,self).__init__(name,‘varchar(100)‘)

class IntegerField(Field):
    def __init__(self,name):
        super(IntegerField,self).__init__(name,‘bigint‘)
#下一步，就是編寫最復雜的ModelMetaclass了：
class ModelMetaclass(type):
    def __new__(cls, name,bases,attrs):
        if name == ‘Model‘:  #排除掉對Model類的修改；
            return type.__new__(cls,name,bases,attrs)
        print(‘Found Model: %s‘%name)
        mappings = dict()
        for k,v in attrs.items(): #查找定義的類的所有屬性，
            if isinstance(v,Field): #如果找到一個Field屬性，
                print(‘Found mapping: %s ==> %s‘ % (k, v))
                mappings[k] = v  #就把它保存到一個__mappings__的dict中
        for k in mappings.keys():
            attrs.pop(k)  #同時從類屬性中刪除該Field屬性，否則，容易造成運行時錯誤（實例的屬性會遮蓋類的同名屬性）；
        attrs[‘__mappings__‘] = mappings # 保存屬性和列的映射關系
        attrs[‘__table__‘] = name  # 假設表名和類名一致  把表名保存到__table__中
        return type.__new__(cls,name,bases,attrs)

#基類Model
class Model(dict,metaclass=ModelMetaclass):
    def __init__(self,**kw):
        super(Model,self).__init__(**kw)
    def __getattr__(self, item):  #沒有找到的屬性，就在這裏找
        try:
            return self[item]
        except KeyError:
            raise AttributeError(r"‘Model‘ object has no attrs :‘%s‘"%item)

    def __setattr__(self, key, value):
        self[key] = value

    def save(self):
        fields = []
        params = []
        args = []
        for k,v in self.__mappings__.items():
            fields.append(v.name)
            params.append(‘?‘)
            args.append(getattr(self,k,None))
        sql = ‘insert into %s (%s) values (%s)‘ % (self.__table__, ‘,‘.join(fields), ‘,‘.join(params))
        print(‘SQL: %s‘ % sql)
        print(‘ARGS: %s‘ % str(args))

#子類User
# 定義類的屬性到列的映射：
class User(Model):
    id = IntegerField(‘id‘)
    name = StringField(‘username‘)
    email = StringField(‘email‘)
    password = StringField(‘password‘)
    age = IntegerField(‘age‘)




　



當用戶定義一個class User(Model)時，Python解釋器首先在當前類User的定義中查找metaclass，如果沒有找到，就繼續在父類Model中查找metaclass，找到了，就使用Model中定義的metaclass的ModelMetaclass來創建User類，也就是說，metaclass可以隱式地繼承到子類，但子類自己卻感覺不到。



在ModelMetaclass中，一共做了幾件事情：


    

  1. 


    排除掉對Model類的修改；
    


    2. 

  2. 


    在當前類（比如User）中查找定義的類的所有屬性，如果找到一個Field屬性，就把它保存到一個__mappings__的dict中，同時從類屬性中刪除該Field屬性，否則，容易造成運行時錯誤（實例的屬性會遮蓋類的同名屬性）；
    


    3. 

  3. 


    把表名保存到__table__中，這裏簡化為表名默認為類名。
    


    4. 





在Model類中，就可以定義各種操作數據庫的方法，比如save()，delete()，find()，update等等。



我們實現了save()方法，把一個實例保存到數據庫中。因為有表名，屬性到字段的映射和屬性值的集合，就可以構造出INSERT語句。


編寫代碼試試：
 


 




if __name__ == ‘__main__‘:  
    u = User(id = 12345,name = ‘john‘,email = ‘[email protected]‘,password = ‘666666‘)  
    u.age = 12  
    u.save()  

if __name__ == ‘__main__‘:
    u = User(id = 12345,name = ‘john‘,email = ‘[email protected]‘,password = ‘666666‘)
    u.age = 12
    u.save()






 

 



Found Model: User  
Found mapping: id ==> <IntegerField:id>  
Found mapping: name ==> <StringField:username>  
Found mapping: email ==> <StringField:email>  
Found mapping: password ==> <StringField:password>  
Found mapping: age ==> <IntegerField:age>  
SQL: insert into User (id,username,email,password,age) values (?,?,?,?,?)  
ARGS: [12345, ‘john‘, ‘[email protected]‘, ‘666666‘, 12]  

Found Model: User
Found mapping: id ==> <IntegerField:id>
Found mapping: name ==> <StringField:username>
Found mapping: email ==> <StringField:email>
Found mapping: password ==> <StringField:password>
Found mapping: age ==> <IntegerField:age>
SQL: insert into User (id,username,email,password,age) values (?,?,?,?,?)
ARGS: [12345, ‘john‘, ‘[email protected]‘, ‘666666‘, 12]




　


 即User類中做好了到列的映射的類屬性，都能添加到sql語句中，而未做好了到列的映射的類屬性：如height，則會過濾掉，實現數據庫列的字段的高度可定制






if __name__ == ‘__main__‘:  
    u = User(id = 12345,name = ‘john‘,email = ‘[email protected]‘,password = ‘666666‘,height = 180)  
    # u.age = 12  
    u.save()  

if __name__ == ‘__main__‘:
    u = User(id = 12345,name = ‘john‘,email = ‘[email protected]‘,password = ‘666666‘,height = 180)
    # u.age = 12
    u.save()




 



Found Model: User  
Found mapping: id ==> <IntegerField:id>  
Found mapping: name ==> <StringField:username>  
Found mapping: email ==> <StringField:email>  
Found mapping: password ==> <StringField:password>  
Found mapping: age ==> <IntegerField:age>  
SQL: insert into User (id,username,email,password,age) values (?,?,?,?,?)  
ARGS: [12345, ‘john‘, ‘[email protected]‘, ‘666666‘, None]  


Found Model: User
Found mapping: id ==> <IntegerField:id>
Found mapping: name ==> <StringField:username>
Found mapping: email ==> <StringField:email>
Found mapping: password ==> <StringField:password>
Found mapping: age ==> <IntegerField:age>
SQL: insert into User (id,username,email,password,age) values (?,?,?,?,?)
ARGS: [12345, ‘john‘, ‘[email protected]‘, ‘666666‘, None]




 






 即使在初始化的時候傳進了height參數，依然會被過濾掉，而定義好了到列的映射的類屬性age,即使沒有賦值，也會被默認為None，並添加到數據庫中。
 
註：可以看到，save()方法已經打印出了可執行的SQL語句，以及參數列表，只需要真正連接到數據庫，執行該SQL語句，就可以完成真正的功能。下面入庫操作，還有剩下的刪改查操作可自行解決。
python——type()、metaclass元類和精簡ORM框架
   
 
 
 
 

            
  

           

              
              

            

            
相關推薦

			   
            
            
            
 

    


    
    
python——type()、metaclass元類和精簡ORM框架

     
 定制   定義   attribute   varchar   elm   cep   實例   編寫代碼   __main__   1、type（）函數





#type()函數既可以返回一個對象的類型，又可以創建出新的類型，  
# 比如，我們可以通過type()函數創建出Hello類，而無需通過cl 



  
 

    


    
    
友元(友元函式、友元類和友元成員函式) C++

     
 
                
        有些情況下，允許特定的非成員函式訪問一個類的私有成員，同時仍阻止一般的訪問，這是很方便做到的。例如被過載的操作符，如輸入或輸出操作符，經常需要訪問類的私有資料成員。
        友元(frend)機制允許一個類將對其非公有成員的訪問權授予指定的函式或者類 



  
 

    


    
    
Python程式設計：metaclass元類實現簡單的ORM

     
 
							
							
							ORM全稱“Object Relational Mapping”，即物件-關係對映 
把關係資料庫的一行對映為一個物件，一個類對應一個表 
這樣，寫程式碼更簡單，不用直接操作SQL語句。

# -*- coding: utf-8 -*-

# @File     



  
 

    


    
    
Python元類實戰，通過元類實現資料庫ORM框架

     
 本文始發於個人公眾號：**TechFlow**，原創不易，求個關注





今天是Python專題的第19篇文章，我們一起來用元類實現一個簡易的ORM資料庫框架。
本文主要是受到了廖雪峰老師Python3入門教程的啟發，不過廖老師的部落格有些精簡，一些小白可能看起來比較吃力。我在他的基礎上做了一些補充和註釋 



  
 

    


    
    
type和metaclass元類

     
 元類type 
1. 建立類的兩種方式 (都是由type元類建立) 
方式一： 
 
 class Foo(object):      # 預設metaclass = type, 當前類, 由type類建立
    a = 'aaa'
    def func(self, x):
        return 



  
 

    


    
    
Python基礎筆記_Day12_Python元類、type動態建立類、Python動態建立方法、Python運算子、Python發郵件、簡訊

     
  
  
  
 Day12_Python元類、type動態建立類、Python動態建立方法、Python運算子過載、Python發郵件、簡訊 
 12.01_Python語言基礎(類物件)(熟悉)
12.02_Python語言基礎(動態建立類)(熟練)
12.03_Python語言基礎(type建立類)(熟 



  
 

    


    
    
Python中使用type、metaclass動態創建方法和屬性

     
 用戶   一個   基礎   元素   錯誤   raise   理解   子類   use   1: type()
我們知道動態語言和靜態語言最大的不同，就是函數和類的定義，不是編譯時定義的，而是運行時動態創建的。
比方說我們要定義一個Person的class：

class Person(obje 



  
 

    


    
    
12.python-metaclass元類

     
 *args   bject   tro   接收   自定義   all   metaclass   控制   module   1.python中一切皆是對象，類本身也是一個對象，當使用關鍵字class的時候，python解釋器在加載class的時候會創建一個對象(這裏的對象指的是類而非類的實例)

cla 



  
 

    


    
    
C++實現輸入輸出運算子過載、友元函式和成員函式實現複數類Complex

     
 
                
今天答應幫朋友做一個C++題目，頗費了一番周折，終於還是寫出來了，讓很久沒敲程式碼的我反省了一下，也回憶了以前學過的知識。
題目要求如下：

一、按下列要求編制複數類，並除錯通過：
1）  基本的建構函式；
2）  成員運算子+、-實現複數的加減運算；
3）  友元運算子+ 



  
 

    


    
    
python的metaclass(元類)

     
 
                類也是物件在理解metaclass之前，我們先要掌握python中的類(class)是什麼。python中類的概念，是借鑑自smalltalk語言。在大部分語言中，類指的是"描述如何產生一個物件(object)"的一段程式碼,這對於python也是如此。>>> 



  
 

    


    
    
廖雪峰Python學習筆記——使用元類

     
 ram   form   創建對象   字典   comm   params   int   name   學習筆記   元類(MetaClasses)
元類提供了一個改變Python類行為的有效方式。
元類的定義是“一個類的類”。任何實例是它自己的類都是元類。
class demo(object):
    



  
 

    


    
    
【練習】友元類和友元函數

     
 turn   main   spa   std   return   col   print   pri   circle   
#include <iostream>
using namespace std;
class Circle;
class Point
{
private:
    fl 



  
 

    


    
    
python 面向對象二 類和實例

     
 else   關鍵字   根據   不同   實例變量   elif   sel   student   pytho   一、類和實例
面向對象最重要的概念就是類（Class）和實例（Instance），必須牢記類是抽象的模板，比如Student類，而實例是根據類創建出來的一個個具體的“對象”，每個對象都擁有 



  
 

    


    
    
Python----面向對象---元類介紹

     
 attr   pen   .html   ash   實例   package   clas   Python全棧   reference   一、儲備知識exec
參數1：字符串形式的命令
參數2：全局作用域（字典形式），如果不指定默認就使用globals（）
參數3：局部作用域（字典形式），如果不指定默認 



  
 

    


    
    
神級程序員通過兩句話帶你完全掌握Python最難知識點——元類！

     
 item   初始化   學習   字符   生命周期   定義   username   awl   虛擬   千萬不要被所謂“元類是99%的python程序員不會用到的特性”這類的說辭嚇住。因為 每個中國人，都是天生的元類使用者
學懂元類，你只需要知道兩句話：
道生一，一生二，二生三，三生萬物
我是誰？我 



  
 

    


    
    
python學習筆記(31) 介面類和抽象類

     
 from abc import abstractmethod.ABCmeta 
class Payment(mataclass = ABCmeta):　　#元類 預設的元類 type 
　　@abstractmethod 
　　def pay(self,money):pass 
介面類或者抽象類都是為了規範子 



  
 

    


    
    
python：深度理解元類

     
  
 
  
  
 提出問題： 如何在一個類建立一個類呢？ 
 首先我們的實現方式是這樣的， 看下以下程式碼： 
 class A :
    def create_class(self,user):
        if user=="company":
            class Company 



  
 

    


    
    
python 面向物件程式設計：類和例項

     
  
 
 
 深度學習在構建網路模型時，看到用類來構建一個模型例項，清晰明瞭，所以這篇博文主要學習一下python類 
 類和例項： 
 類可以起到模板的作用，因此，可以在建立例項的時候，把一些我們認為必須繫結的屬性強制填寫進去。通過定義一個特殊的__init__(注意：特殊方法“__init__”前後分別有 



  
 

    


    
    
Python基本語法之元類

     
  
 
 
   
 什麼是元類 
        在Python中，萬物均為物件，如整數、字串、函式以及類都是物件。 
        元類就是類的類，也就說元類也是一種物件，只不過是一種特殊的物件。 
   



  
 

    


    
    
自定義元類和元類的用途

     
  
 # -*- coding:UTF-8 -*-
__autor__ = 'zhouli'
__date__ = '2018/12/3 23:13'


def create_class(name):
    if name == "user":
        class User: