一、使用动态创建类：

　　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()

二、类装饰器

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 函数--

三、对象池

GC机制（垃圾回收机制）
    内存泄露
    1、引用计数的处理
        增加
            创建对象出来引用计数 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


    2、隔代回收的处理
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.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.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)

六、集合

#    集合
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)