Python--元類

1、使用動態建立類：

　　1.類也是對象(屬於元類的對象)

　　　　#打印字符串(字符串是對象)

　　　　print("HelloWorld")

　　　　#打印類名,類一樣爲一個對象

　　　　print(Person)

　　2.使用動態建立類：

　　　語法：

　　　　type(類名，由父類名稱組成的元組（能夠爲空），包含屬性的字典（名稱和 值）)  

　　　　2.1 使用type建立類 

class Person(object):
    pass
p = Person()
print(p)
# 動態建立Person1
Person1 = type("Person1",(),{})
p1 = Person1()
print(p1)

　　　　2.2 使用type建立帶有屬性(方法)的類

# 定義一個函數
def show(self):
    print("---name---%s"%self.name)
# 使用type建立一個帶有屬性的類
Person2 = type('Person2',(),{'show':show,'name':'xxx'})
# 使用type建立的類，來建立一個對象p2
p2 = Person2()
# p2.name = 'xxx'
# 添加屬性
# setattr(p2,'name','xxx')
p2.show()

　　　　2.3 使用type動態建立一個繼承指定類的類

class Animal():
    def __init__(self,color="Yellow"):
        self.color = color
    def eat(self):
        print("吃死你")
Dog = type("Dog",(Animal,),{})
dog = Dog()
dog.eat()
print(dog.color)

　　　　2.4 手動指定元類

def test123(name,parents,attr):
    # 默認須要三個參數
    return type(name,parents,{})
# 經過metaclass手動指定父類
class Animal(object,metaclass=test123):
    def __init__(self,color="Yellow"):
        self.color = color
    def eat(self):
        print("吃")
a = Animal()
a.eat()

2、類裝飾器

class Test(object):
    def __init__(self,func):
        print("--初始化--")
        print("func name is %s"%func.__name__)
        self.__func = func
    # 重寫該方法後，對象能夠直接進行調用
    def __call__(self):
        print("--裝飾器中的功能--")
        self.__func()
# @Test 等價於  test = Test(test) 裝飾器特性
@Test
def test():
    print('--test 函數---')
# 自己test指向函數test，可是裝飾器將test指向了對象。
#  對象自己不能夠被調用，可是重寫__call__方法以後則會被調用
test()
執行結果：
--初始化-
func name is test
--裝飾器中的功能-
--test 函數--

3、對象池

GC機制（垃圾回收機制）
    內存泄露
    一、引用計數的處理
        增長
            建立對象出來引用計數 1
                d = Dog()
            多一個多想使用，引用計數+1
             b = d;
            加到列表中，引用計數+1
                list1 = [d]
            方法調用，+1
                show(d)
        減小：
            引用計數-1
                del  d
            指向改變：引用計數-1
                d = Dog()
                d = Cat()
            引用計數-1
                list1.remove(d)
            方法使用完畢,計數-1


    二、隔代回收的處理

import gc
class AAA():
    def __init__(self):
        print('object: born at:%s' % hex(id(self)))
def start():
    gc.set_threshold(200, 10, 10)
    for i in range(200):
        a = AAA()
        b = AAA()
        a.v = b
        b.v = a
        # 獲取內存狀況
        print(gc.get_count())
        # 打印垃圾回收頻率
        print(gc.get_threshold())
        del a
        del b

# 關閉gc機制
# gc.disable()
start()

# 查看某個對象的引用計數
import sys
str1 = "洪文"
print(sys.getrefcount(str1))
list1 = []
list1.append(str1)
print(sys.getrefcount(str1))
list1.remove(str1)
print(sys.getrefcount(str1))

4、內建屬性

　　4.1 經常使用內置類屬性

　　__dict__:類的屬性（包含一個字典，由類的數據屬性組成）

　　__doc__: 類的文檔字符串

　　__name__:  類名

　　__module__: 類定義所在的模塊

　　__bases__: 類的全部父類構成元素（包含了以個由全部父類組成的元組）

 　　4.2  屬性攔截器__getattribute__ 

class Test(object):
    def __init__(self,var1):
        self.var1 = var1
    #  該方法在獲取對象屬性的時候會被調用，
    def __getattribute__(self,obj):
        if obj == 'var2':
            print("屬性var1攔截成功")
            return '我是攔截後替換的數據'
        else:
            # 若是攔截不成功，能夠調用父類的方法，這時候obj的值就是
init中的值
            return object.__getattribute__(self,obj)
            # 若是在__getattribute__方法中，
            # 使用使用self訪問屬性，或者方法，都會致使程序崩潰
            # return self.var1
    def show(self):
        print("我是show方法")
 
s = Test("python")
# 成員變量 var1會被以字符串的形式（'var1'）傳遞給__getattribute__方
法的obj
print(s.var1)
# 方法的訪問也能夠經過屬性攔截器進行攔截
s.show()

5、內建函數

　　5.1經常使用內建函數：

　　　　1.range()

　　　　2.map() 

　　　　map(function,iterable...)
    　　function ---函數
    　　iterable ---一個或多個序列 ，返回的是迭代對象

from collections import Iterable
from collections import Iterator
def func(x,y):
    return x * y

v = map(lambda x:x*2,[1,2,3])
print(type(v))
print(isinstance(v,Iterable))
print(isinstance(v,Iterator))
for i in v:
    print(i)
v1 = map(func,[1,2,3],[4,5,6])
v2 = list(v1)
print(type(v2))

　　　　3.filter() 

　　　　filter(function,iterable)
    　　function --判斷函數
    　　iterable --可迭代對象

def func2(x):
    return x % 2 == 0
# 1 - 100 中的偶數
list2 = filter(func2,[x for x in range(1,101)])
print(isinstance(list2,Iterator))
for i in list2:
    print(i)

　　　　4.reduce()

#求1+2+...+100
from functools import reduce
result = reduce(lambda x,y:x+y,[x for x in range(1,101)])
print("result:%d"%result)

result1 = reduce(lambda x,y:x+y,['1','2','3'],'4')
print(result1)

　　　　5.sorted()　　

　　　　　　　　sort 與 sorted 區別： sort 是應用在 list 上的方法，sorted 能夠對全部可迭代的對象進行排序操做。　　　　

　　　　　　　　list 的 sort 方法返回的是對已經存在的列表進行操做， 而內建函數 sorted 方法返回的是一個新的 list，而不是在原來的基礎上進行
　　　　　　的操做

class Stu():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return self.name + str(self.age)
students = [("john",'A',15),('jane', 'B', 12), ('dave', 'B', 10)]
students = sorted(students,key = lambda s:s[1])
print(students)
# 自定義對象排序，要引用函數
students = [Stu('aa',12),Stu('sf',24),Stu('fh',45)]
students1 = sorted(students,key = lambda x:x.name)
for s in students1:
    print(s)

6、集合

#    集合v1 = {1}print(type(v1))# 添加元素v1.add(4)v1.add(5)v1.add(6)# 重複元素沒法添加進去v1.add(1)v1.update()# 刪除元素v1.remove(1)print(v1)# 定義兩個集合set1 = {1,2,3}set2 = {3,4,5}#  & 丨 - ^print(set1 & set2)print(set1 | set2)print(set1-set2)print(set1 ^ set2)