2. 程式人生 > >（轉）元類metaclass

（轉）元類metaclass

阿新 • • 發佈：2018-08-17
def ati tac nes 代碼 img 運行程序 use ssm

閱讀目錄

  • 一 前言
  • 二 什麽是元類
  • 三 class關鍵字創建類的流程分析
  • 五 自定義元類控制類OldboyTeacher的創建
  • 六 自定義元類控制類OldboyTeacher的調用
  • 六 再看屬性查找
  • 七 練習題

一 前言

元類屬於python面向對象編程的深層魔法，99%的人都不得要領，一些自以為搞明白元類的人其實也只是自圓其說、點到為止，從對元類的控制上來看就破綻百出、邏輯混亂，今天我就來帶大家來深度了解python元類的來龍去脈。

筆者深入淺出的背後是對技術一日復一日的執念，希望可以大家可以尊重原創，為大家能因此文而解開對元類所有的疑惑而感到開心！！！

二 什麽是元類

一切源自於一句話：python中一切皆為對象。讓我們先定義一個類，然後逐步分析

技術分享圖片 
class OldboyTeacher(object):
    school=‘oldboy‘

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print(‘%s says welcome to the oldboy to learn Python‘ %self.name)
技術分享圖片

所有的對象都是實例化或者說調用類而得到的（調用類的過程稱為類的實例化），比如對象t1是調用類OldboyTeacher得到的

t1=OldboyTeacher(‘
 
egon‘,18)
print(type(t1)) #查看對象t1的類是<class ‘__main__.OldboyTeacher‘>

如果一切皆為對象，那麽類OldboyTeacher本質也是一個對象，既然所有的對象都是調用類得到的，那麽OldboyTeacher必然也是調用了一個類得到的，這個類稱為元類

於是我們可以推導出===>產生OldboyTeacher的過程一定發生了：OldboyTeacher=元類(...)

print(type(OldboyTeacher)) # 結果為<class ‘type‘>，證明是調用了type這個元類而產生的OldboyTeacher，即默認的元類為type

技術分享圖片

三 class關鍵字創建類的流程分析

上文我們基於python中一切皆為對象的概念分析出：我們用class關鍵字定義的類本身也是一個對象，負責產生該對象的類稱之為元類（元類可以簡稱為類的類），內置的元類為type

class關鍵字在幫我們創建類時，必然幫我們調用了元類OldboyTeacher=type(...)，那調用type時傳入的參數是什麽呢？必然是類的關鍵組成部分，一個類有三大組成部分，分別是

1、類名class_name=‘OldboyTeacher‘

2、基類們class_bases=(object,)

3、類的名稱空間class_dic，類的名稱空間是執行類體代碼而得到的

調用type時會依次傳入以上三個參數

綜上，class關鍵字幫我們創建一個類應該細分為以下四個過程

技術分享圖片 補充：exec的用法 技術分享圖片 
#exec：三個參數

#參數一：包含一系列python代碼的字符串

#參數二：全局作用域（字典形式），如果不指定，默認為globals()

#參數三：局部作用域（字典形式），如果不指定，默認為locals()

#可以把exec命令的執行當成是一個函數的執行，會將執行期間產生的名字存放於局部名稱空間中
g={
    ‘x‘:1,
    ‘y‘:2
}
l={}

exec(‘‘‘
global x,z
x=100
z=200

m=300
‘‘‘,g,l)

print(g) #{‘x‘: 100, ‘y‘: 2,‘z‘:200,......}
print(l) #{‘m‘: 300}
技術分享圖片

五 自定義元類控制類OldboyTeacher的創建

一個類沒有聲明自己的元類，默認他的元類就是type，除了使用內置元類type，我們也可以通過繼承type來自定義元類，然後使用metaclass關鍵字參數為一個類指定元類

技術分享圖片 
class Mymeta(type): #只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類
    pass

class OldboyTeacher(object,metaclass=Mymeta): # OldboyTeacher=Mymeta(‘OldboyTeacher‘,(object),{...})
    school=‘oldboy‘

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print(‘%s says welcome to the oldboy to learn Python‘ %self.name)
技術分享圖片

自定義元類可以控制類的產生過程，類的產生過程其實就是元類的調用過程,即OldboyTeacher=Mymeta(‘OldboyTeacher‘,(object),{...})，調用Mymeta會先產生一個空對象OldoyTeacher，然後連同調用Mymeta括號內的參數一同傳給Mymeta下的__init__方法，完成初始化，於是我們可以

技術分享圖片 
class Mymeta(type): #只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類
    def __init__(self,class_name,class_bases,class_dic):
        # print(self) #<class ‘__main__.OldboyTeacher‘>
        # print(class_bases) #(<class ‘object‘>,)
        # print(class_dic) #{‘__module__‘: ‘__main__‘, ‘__qualname__‘: ‘OldboyTeacher‘, ‘school‘: ‘oldboy‘, ‘__init__‘: <function OldboyTeacher.__init__ at 0x102b95ae8>, ‘say‘: <function OldboyTeacher.say at 0x10621c6a8>}
        super(Mymeta, self).__init__(class_name, class_bases, class_dic)  # 重用父類的功能

        if class_name.islower():
            raise TypeError(‘類名%s請修改為駝峰體‘ %class_name)

        if ‘__doc__‘ not in class_dic or len(class_dic[‘__doc__‘].strip(‘ \n‘)) == 0:
            raise TypeError(‘類中必須有文檔註釋，並且文檔註釋不能為空‘)

class OldboyTeacher(object,metaclass=Mymeta): # OldboyTeacher=Mymeta(‘OldboyTeacher‘,(object),{...})
    """
    類OldboyTeacher的文檔註釋
    """
    school=‘oldboy‘

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print(‘%s says welcome to the oldboy to learn Python‘ %self.name)
技術分享圖片

六 自定義元類控制類OldboyTeacher的調用

儲備知識：__call__

技術分享圖片 
class Foo:
    def __call__(self, *args, **kwargs):
        print(self)
        print(args)
        print(kwargs)

obj=Foo()
#1、要想讓obj這個對象變成一個可調用的對象，需要在該對象的類中定義一個方法__call__方法，該方法會在調用對象時自動觸發
#2、調用obj的返回值就是__call__方法的返回值
res=obj(1,2,3,x=1,y=2)
技術分享圖片

由上例得知，調用一個對象，就是觸發對象所在類中的__call__方法的執行，如果把OldboyTeacher也當做一個對象，那麽在OldboyTeacher這個對象的類中也必然存在一個__call__方法

技術分享圖片 
class Mymeta(type): #只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類
    def __call__(self, *args, **kwargs):
        print(self) #<class ‘__main__.OldboyTeacher‘>
        print(args) #(‘egon‘, 18)
        print(kwargs) #{}
        return 123

class OldboyTeacher(object,metaclass=Mymeta):
    school=‘oldboy‘

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print(‘%s says welcome to the oldboy to learn Python‘ %self.name)



# 調用OldboyTeacher就是在調用OldboyTeacher類中的__call__方法
# 然後將OldboyTeacher傳給self,溢出的位置參數傳給*，溢出的關鍵字參數傳給**
# 調用OldboyTeacher的返回值就是調用__call__的返回值
t1=OldboyTeacher(‘egon‘,18)
print(t1) #123
技術分享圖片

默認地，調用t1=OldboyTeacher(‘egon‘,18)會做三件事

1、產生一個空對象obj

2、調用__init__方法初始化對象obj

3、返回初始化好的obj

對應著，OldboyTeacher類中的__call__方法也應該做這三件事

技術分享圖片 
class Mymeta(type): #只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類
    def __call__(self, *args, **kwargs): #self=<class ‘__main__.OldboyTeacher‘>
        #1、調用__new__產生一個空對象obj
        obj=self.__new__(self) # 此處的self是類OldoyTeacher，必須傳參，代表創建一個OldboyTeacher的對象obj

        #2、調用__init__初始化空對象obj
        self.__init__(obj,*args,**kwargs)

        #3、返回初始化好的對象obj
        return obj

class OldboyTeacher(object,metaclass=Mymeta):
    school=‘oldboy‘

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print(‘%s says welcome to the oldboy to learn Python‘ %self.name)

t1=OldboyTeacher(‘egon‘,18)
print(t1.__dict__) #{‘name‘: ‘egon‘, ‘age‘: 18}
技術分享圖片

上例的__call__相當於一個模板，我們可以在該基礎上改寫__call__的邏輯從而控制調用OldboyTeacher的過程，比如將OldboyTeacher的對象的所有屬性都變成私有的

技術分享圖片 
class Mymeta(type): #只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類
    def __call__(self, *args, **kwargs): #self=<class ‘__main__.OldboyTeacher‘>
        #1、調用__new__產生一個空對象obj
        obj=self.__new__(self) # 此處的self是類OldoyTeacher，必須傳參，代表創建一個OldboyTeacher的對象obj

        #2、調用__init__初始化空對象obj
        self.__init__(obj,*args,**kwargs)

        # 在初始化之後，obj.__dict__裏就有值了
        obj.__dict__={‘_%s__%s‘ %(self.__name__,k):v for k,v in obj.__dict__.items()}
        #3、返回初始化好的對象obj
        return obj

class OldboyTeacher(object,metaclass=Mymeta):
    school=‘oldboy‘

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print(‘%s says welcome to the oldboy to learn Python‘ %self.name)

t1=OldboyTeacher(‘egon‘,18)
print(t1.__dict__) #{‘_OldboyTeacher__name‘: ‘egon‘, ‘_OldboyTeacher__age‘: 18}
技術分享圖片

上例中涉及到查找屬性的問題，比如self.__new__，請看下一小節

六 再看屬性查找

結合python繼承的實現原理+元類重新看屬性的查找應該是什麽樣子呢？？？

在學習完元類後，其實我們用class自定義的類也全都是對象（包括object類本身也是元類type的 一個實例，可以用type(object)查看），我們學習過繼承的實現原理，如果把類當成對象去看，將下述繼承應該說成是：對象OldboyTeacher繼承對象Foo，對象Foo繼承對象Bar，對象Bar繼承對象object

技術分享圖片 
class Mymeta(type): #只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類
    n=444

    def __call__(self, *args, **kwargs): #self=<class ‘__main__.OldboyTeacher‘>
        obj=self.__new__(self)
        self.__init__(obj,*args,**kwargs)
        return obj

class Bar(object):
    n=333

class Foo(Bar):
    n=222

class OldboyTeacher(Foo,metaclass=Mymeta):
    n=111

    school=‘oldboy‘

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print(‘%s says welcome to the oldboy to learn Python‘ %self.name)


print(OldboyTeacher.n) #自下而上依次註釋各個類中的n=xxx，然後重新運行程序，發現n的查找順序為OldboyTeacher->Foo->Bar->object->Mymeta->type
技術分享圖片

於是屬性查找應該分成兩層，一層是對象層（基於c3算法的MRO）的查找，另外一個層則是類層（即元類層）的查找

技術分享圖片

#查找順序：
#1、先對象層：OldoyTeacher->Foo->Bar->object
#2、然後元類層：Mymeta->type

依據上述總結，我們來分析下元類Mymeta中__call__裏的self.__new__的查找

技術分享圖片 
class Mymeta(type): 
    n=444

    def __call__(self, *args, **kwargs): #self=<class ‘__main__.OldboyTeacher‘>
        obj=self.__new__(self)
        print(self.__new__ is object.__new__) #True


class Bar(object):
    n=333

    # def __new__(cls, *args, **kwargs):
    #     print(‘Bar.__new__‘)

class Foo(Bar):
    n=222

    # def __new__(cls, *args, **kwargs):
    #     print(‘Foo.__new__‘)

class OldboyTeacher(Foo,metaclass=Mymeta):
    n=111

    school=‘oldboy‘

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print(‘%s says welcome to the oldboy to learn Python‘ %self.name)


    # def __new__(cls, *args, **kwargs):
    #     print(‘OldboyTeacher.__new__‘)


OldboyTeacher(‘egon‘,18) #觸發OldboyTeacher的類中的__call__方法的執行，進而執行self.__new__開始查找
技術分享圖片

總結，Mymeta下的__call__裏的self.__new__在OldboyTeacher、Foo、Bar裏都沒有找到__new__的情況下，會去找object裏的__new__，而object下默認就有一個__new__，所以即便是之前的類均未實現__new__,也一定會在object中找到一個，根本不會、也根本沒必要再去找元類Mymeta->type中查找__new__

我們在元類的__call__中也可以用object.__new__(self)去造對象

技術分享圖片

但我們還是推薦在__call__中使用self.__new__（self）去創造空對象，因為這種方式會檢索三個類OldboyTeacher->Foo->Bar,而object.__new__則是直接跨過了他們三個

最後說明一點

技術分享圖片 
class Mymeta(type): #只有繼承了type類才能稱之為一個元類，否則就是一個普通的自定義類
    n=444

    def __new__(cls, *args, **kwargs):
        obj=type.__new__(cls,*args,**kwargs) # 必須按照這種傳值方式
        print(obj.__dict__)
        # return obj # 只有在返回值是type的對象時，才會觸發下面的__init__
        return 123

    def __init__(self,class_name,class_bases,class_dic):
        print(‘run。。。‘)


class OldboyTeacher(object,metaclass=Mymeta): #OldboyTeacher=Mymeta(‘OldboyTeacher‘,(object),{...})
    n=111

    school=‘oldboy‘

    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print(‘%s says welcome to the oldboy to learn Python‘ %self.name)


print(type(Mymeta)) #<class ‘type‘>
# 產生類OldboyTeacher的過程就是在調用Mymeta，而Mymeta也是type類的一個對象，那麽Mymeta之所以可以調用，一定是在元類type中有一個__call__方法
# 該方法中同樣需要做至少三件事：
# class type:
#     def __call__(self, *args, **kwargs): #self=<class ‘__main__.Mymeta‘>
#         obj=self.__new__(self,*args,**kwargs) # 產生Mymeta的一個對象
#         self.__init__(obj,*args,**kwargs) 
#         return obj
技術分享圖片

七 練習題

練習一：在元類中控制把自定義類的數據屬性都變成大寫

技術分享圖片 
class Mymetaclass(type):
    def __new__(cls,name,bases,attrs):
        update_attrs={}
        for k,v in attrs.items():
            if not callable(v) and not k.startswith(‘__‘):
                update_attrs[k.upper()]=v
            else:
                update_attrs[k]=v
        return type.__new__(cls,name,bases,update_attrs)

class Chinese(metaclass=Mymetaclass):
    country=‘China‘
    tag=‘Legend of the Dragon‘ #龍的傳人
    def walk(self):
        print(‘%s is walking‘ %self.name)


print(Chinese.__dict__)
‘‘‘
{‘__module__‘: ‘__main__‘,
 ‘COUNTRY‘: ‘China‘, 
 ‘TAG‘: ‘Legend of the Dragon‘,
 ‘walk‘: <function Chinese.walk at 0x0000000001E7B950>,
 ‘__dict__‘: <attribute ‘__dict__‘ of ‘Chinese‘ objects>,                                         
 ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Chinese‘ objects>,
 ‘__doc__‘: None}
‘‘‘
View Code

練習二：在元類中控制自定義的類無需__init__方法

　　1.元類幫其完成創建對象，以及初始化操作；

　　2.要求實例化時傳參必須為關鍵字形式，否則拋出異常TypeError: must use keyword argument

　　3.key作為用戶自定義類產生對象的屬性，且所有屬性變成大寫

技術分享圖片 
class Mymetaclass(type):
    # def __new__(cls,name,bases,attrs):
    #     update_attrs={}
    #     for k,v in attrs.items():
    #         if not callable(v) and not k.startswith(‘__‘):
    #             update_attrs[k.upper()]=v
    #         else:
    #             update_attrs[k]=v
    #     return type.__new__(cls,name,bases,update_attrs)

    def __call__(self, *args, **kwargs):
        if args:
            raise TypeError(‘must use keyword argument for key function‘)
        obj = object.__new__(self) #創建對象，self為類Foo

        for k,v in kwargs.items():
            obj.__dict__[k.upper()]=v
        return obj

class Chinese(metaclass=Mymetaclass):
    country=‘China‘
    tag=‘Legend of the Dragon‘ #龍的傳人
    def walk(self):
        print(‘%s is walking‘ %self.name)


p=Chinese(name=‘egon‘,age=18,sex=‘male‘)
print(p.__dict__)
View Code

練習三：在元類中控制自定義的類產生的對象相關的屬性全部為隱藏屬性

技術分享圖片 
class Mymeta(type):
    def __init__(self,class_name,class_bases,class_dic):
        #控制類Foo的創建
        super(Mymeta,self).__init__(class_name,class_bases,class_dic)

    def __call__(self, *args, **kwargs):
        #控制Foo的調用過程，即Foo對象的產生過程
        obj = self.__new__(self)
        self.__init__(obj, *args, **kwargs)
        obj.__dict__={‘_%s__%s‘ %(self.__name__,k):v for k,v in obj.__dict__.items()}

        return obj

class Foo(object,metaclass=Mymeta):  # Foo=Mymeta(...)
    def __init__(self, name, age,sex):
        self.name=name
        self.age=age
        self.sex=sex


obj=Foo(‘egon‘,18,‘male‘)
print(obj.__dict__)
View Code

練習四：基於元類實現單例模式

技術分享圖片 
#步驟五：基於元類實現單例模式
# 單例：即單個實例，指的是同一個類實例化多次的結果指向同一個對象，用於節省內存空間
# 如果我們從配置文件中讀取配置來進行實例化，在配置相同的情況下，就沒必要重復產生對象浪費內存了
#settings.py文件內容如下
HOST=‘1.1.1.1‘
PORT=3306

#方式一:定義一個類方法實現單例模式
import settings

class Mysql:
    __instance=None
    def __init__(self,host,port):
        self.host=host
        self.port=port

    @classmethod
    def singleton(cls):
        if not cls.__instance:
            cls.__instance=cls(settings.HOST,settings.PORT)
        return cls.__instance


obj1=Mysql(‘1.1.1.2‘,3306)
obj2=Mysql(‘1.1.1.3‘,3307)
print(obj1 is obj2) #False

obj3=Mysql.singleton()
obj4=Mysql.singleton()
print(obj3 is obj4) #True



#方式二：定制元類實現單例模式
import settings

class Mymeta(type):
    def __init__(self,name,bases,dic): #定義類Mysql時就觸發

        # 事先先從配置文件中取配置來造一個Mysql的實例出來
        self.__instance = object.__new__(self)  # 產生對象
        self.__init__(self.__instance, settings.HOST, settings.PORT)  # 初始化對象
        # 上述兩步可以合成下面一步
        # self.__instance=super().__call__(*args,**kwargs)


        super().__init__(name,bases,dic)

    def __call__(self, *args, **kwargs): #Mysql(...)時觸發
        if args or kwargs: # args或kwargs內有值
            obj=object.__new__(self)
            self.__init__(obj,*args,**kwargs)
            return obj

        return self.__instance




class Mysql(metaclass=Mymeta):
    def __init__(self,host,port):
        self.host=host
        self.port=port



obj1=Mysql() # 沒有傳值則默認從配置文件中讀配置來實例化，所有的實例應該指向一個內存地址
obj2=Mysql()
obj3=Mysql()

print(obj1 is obj2 is obj3)

obj4=Mysql(‘1.1.1.4‘,3307)



#方式三:定義一個裝飾器實現單例模式
import settings

def singleton(cls): #cls=Mysql
    _instance=cls(settings.HOST,settings.PORT)

    def wrapper(*args,**kwargs):
        if args or kwargs:
            obj=cls(*args,**kwargs)
            return obj
        return _instance

    return wrapper


@singleton # Mysql=singleton(Mysql)
class Mysql:
    def __init__(self,host,port):
        self.host=host
        self.port=port

obj1=Mysql()
obj2=Mysql()
obj3=Mysql()
print(obj1 is obj2 is obj3) #True

obj4=Mysql(‘1.1.1.3‘,3307)
obj5=Mysql(‘1.1.1.4‘,3308)
print(obj3 is obj4) #False
View Code

轉自：
元類metaclass - linhaifeng - 博客園
http://www.cnblogs.com/linhaifeng/articles/8029564.html

（轉）元類metaclass

相關推薦

（轉）元類metaclass

def ati tac nes 代碼 img 運行程序 use ssm 閱讀目錄一 前言二 什麽是元類三 class關鍵字創建類的流程分析五 自定義元類控制類OldboyTeacher的創建六 自定義元類控制類OldboyTeacher的調用六 再看屬性查找七 練習題一 前

《Python高階程式設計》（五）元類

元類 定義 類與物件 使用type建立類 編寫元類 type建立類和class建立類的比較 對元類理解 使用元類 何時使用元類 定義 物件例項化原理：物件例項化過程中會呼叫_

（轉）建立類模式總結篇

建立類模式主要關注物件的建立過程，將物件的建立過程進行封裝，使客戶端可以直接得到物件，而不用去關心如何建立物件。建立類模式有5種，分別是： 單例模式：用於得到記憶體中的唯一物件。用於建立複雜物件。用於建立一組相關或相互依賴的複雜物件。建造者模式：用於建立模組化的更加複雜的

（轉）基類解構函式必須為虛擬函式否則會造成記憶體洩漏

看看下面程式有什麼錯誤： #include <iostream> using namespace std; class Father { public: Father(){}; ~Father(){}; }; class Son:public

深刻理解Python中的元類(metaclass)（轉）

pytho light turn 理解 war highlight 參數 實例化 type 轉載地址：http://blog.jobbole.com/21351/ 另外有幾點理解記錄下： 創建一個實例時，有時會傳入參數，這些參數會同時傳入 __init__() 和 __

MySQL表類型MyISAM/InnoDB的區別（解決事務不回滾的問題）（轉）

span into article one 工具 tab select var pan MyISAM：這個是默認類型，它是基於傳統的ISAM類型，ISAM是Indexed Sequential Access Method （有索引的順序訪問方法) 的縮寫，它是存儲記錄和文件

用C++設計一個不能被繼承的類（轉）

它的 設計 指定 基於 構造 重寫 rtu 構造函數、析構函數 析構函數 在Java 中定義了關鍵字final，被final修飾的類不能被繼承。 首先想到的是在C++中，子類的構造函數會自動調用父類的構造函數。同樣，子類的析構函數也會自動調用父類的析構函數。要想一個類不能

JVM類加載機制（轉）

代碼 text 情況 c++實現 調用 初始化 它的 spa hotspot 原文出自：http://www.cnblogs.com/ityouknow/p/5603287.html 1、什麽是類的加載 類的加載指的是將類的.class文件中的二進制數據讀入到內存中，將其放

如何查找Linux中一些特殊數據類型定義，比如pid_t和uid_t（轉）

分享 文件 技術分享 定義 log 相關 uid linux源碼 pid 1. 查看man手冊，找到pid_t，可以通過getpid函數來看 2. 打開sys/types.h 3. 打開bits/types.h 4.

delphi中的各類文件類型（轉）

控件 圖形 ont 界面 dci 存在 ati delphi7 工程文件 1.DPR: Delphi Project文件，包含了Pascal代碼。應用系統的工程文件2.PAS: Pascal文件，Pascal單元的源代碼，可以是與窗體有關的單元或是獨立的單元。3.DFM：

測試數據科學家聚類技術的40個問題（附答案和分析）（轉）

sqs fib method 描述 只有一個 聚類分析 iap 角度 技術 本文作者 Saurav Kaushik 是數據科學愛好者，還有一年他就從新德裏 MAIT 畢業了，喜歡使用機器學習和分析來解決復雜的數據問題。看看以下40道題目，測試下你能答對多少。 作者

MySQL 數據類型（轉）

mysq tiny edi arc 字符串存儲 大數 順序存儲 存儲 ace MySQL 數據類型 在 MySQL 中，有三種主要的類型：文本、數字和日期/時間類型。 Text 類型： 數據類型描述備註 CHAR(size) 保存固定長度的字符串（可包含字母、數字

（轉）Mat, vector<point2f>，Iplimage等等常見類型轉換

圖像 程序 col logs -s cnblogs 類型 tor nbsp 在mfc c++ 以及opencv 編寫程序當中，很多常用的類型轉換，現在總結一下。(註意加相應的頭文件，這裏不羅嗦） 提綱： 1. Mat ---> Iplimage 2. Iplimage

（轉）Spring 的優秀工具類盤點

空白 nts tee 環境 fin 編寫 and 程序調試 word 第 1 部分: 文件資源操作和 Web 相關工具類 http://www.ibm.com/developerworks/cn/java/j-lo-spring-utils1/ 文件資源操作 文件資源的操作

（轉）android:inputType參數類型說明

網頁 char xtu cnblogs div 日期 mes signed rac android:inputType參數類型說明 android:inputType="none"--輸入普通字符 android:inputType="text"--輸入普通字符 a

java----FileInputStream類與FileReader類的區別（轉）

unicode ams 缺陷 自己 enc odin 通訊 n) get FileInputStream類與FileReader類的區別：兩個類的構造函數的形式和參數都是相同的，參數為File對象或者表示路徑的String，它們到底有何區別呢？? Readers and

（轉）Java接口與抽象類的區別

構造 request 現在 exceptio 創建 使用 javac 不存在 serializa 很多常見的面試題都會出諸如抽象類和接口有什麽區別，什麽情況下會使用抽象類和什麽情況你會使用接口這樣的問題。本文我們將仔細討論這些話題。 在討論它們之間的不同點之前，我們先看

Java基本數據類型與包裝類型（轉）

最大值 lib short static false boolean 面向對象 val int操作 基本數據類型的包裝類 為什麽需要包裝類？ Java並不是純面向對象的語言。Java語言是一個面向對象的語言，但是Java的基本數據類型卻不是面向對象的。但是我們在實際使

C#可擴展編程之MEF學習筆記（三）：導出類的方法和屬性（轉）

學習 說了 如何 mod ati dem ont num imp 前面說完了導入和導出的幾種方法，如果大家細心的話會註意到前面我們導出的都是類，那麽方法和屬性能不能導出呢？？？答案是肯定的，下面就來說下MEF是如何導出方法和屬性的。 　　還是前面的代碼，第二篇中已經提供了下

js(jQuery)獲取時間的方法及常用時間類（轉）

tin isnan gettime max etsec 信息 eva bsp 分割 轉自：http://blog.csdn.net/weiming8517/article/details/25604551 感謝作者分享$(function(){ var mydate =