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)