内存管理机制：

    1、小整数池

        [-5,256]

    2、大整数池

    3、字符串

        intern

        相同的字符串（不包含空格，或者特殊字符），默认只保留一份

        id() 查地址

        is   判断两个对象是否为同一个

Python中的内部管理机制：

    gc机制：

        garbage collection（垃圾回收）

        1.引用计数机制

            获取引用计数

                sys.getrefcount()

            增加引用计数

                将对象计入到列表

                将对象赋值给新的对象

                将对象作为形参

            减少引用计数

                从列表中移除

                del 对象

2. 隔代回收机制

引用计数机制

原理：当引用没有被直接使用后，会被gc直接回收，引用一创建，默认计数为2；

import gc,sys

class AAA(object):
    """
    我是介绍
    """
    def __init__(self):
        print("object: born at:%s" % hex(id(self)))
        self.aaa = 1

    def __new__(cls, *args, **kwargs):
        print("new")
        return super(AAA, cls).__new__(cls)
    def __del__(self):
        print("bye bye")

a = AAA()
# 加载类注释（文档注释）
print(a.__doc__)
# 获取引用计数
print(sys.getrefcount(a))
list1 = []
# 引用计数加1
list1.append(a)
print(sys.getrefcount(a))
# 引用计数减1
list1.remove(a)
print(sys.getrefcount(a))
# 移除该引用，但是这并不意味着它就被销毁了，只是意味着a引用接下来不能用了，计数减1，如果没有小于2，那么a在堆内存中还存在；
# del a
print("-"*50)

隔代回收机制

相关代码

import gc,sys,time

class AAA(object):
    def __init__(self):
        print("object: born at:%s" % hex(id(self)))

    def __new__(cls, *args, **kwargs):
        print("new")
        return super(AAA, cls).__new__(cls)
    def __del__(self):
        print("bye bye")
def start():
    while True:
        a = AAA()
        b = AAA()
        #给a添加成员变量
        a.v = b
        #给b添加成员变量
        b.v = a
        #无法删除  只是减少引用计数
        del a
        del b
        print(gc.get_count())
        print(gc.get_threshold())
        time.sleep(0.01)


# 手动调用垃圾回收器回收一次
# gc.collect()
# 设置隔代回收阈值
# gc.set_threshold(100,5,5)
#手动关闭垃圾回收机制(开发过程禁用)  python3 默认开启
gc.disable()
start()

图解隔代回收机制

属性拦截控制

class Student(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __getattribute__(self, item):
        if item == 'age':
            return '100'
        if item == 'name':
            return '***'

stu = Student('李闹',19)
print(stu.name)
print(stu.age)

内建函数

可迭代对象中的所有元素产生规律性的变化，可以使用内建函数；

# for x in range(10):
# for x in range(0,10,2):
#     print(x)
#倒着取，注意开始以及结束
# for x in range(10,0,-2):
#     print(x)

from collections.abc import Iterator
list1 = [1,2,3,4,5]

# def func_1(x):
#     return  x * 2
#
# result = map(func_1,list1)
# if isinstance(result,Iterator):
#     print("是")
#
# for x in result:
#     print(x)


#使用匿名函数完成将列表中所有元素扩大二倍的操作
result1 = map(lambda x:x*2,list1)
for x in result1:
    print(x)

内建函数-filter,reduce,sorted

filter(func,iterable)

    使用func对iterable进行过滤，得到一个迭代器（可以迭代满足条件的数据）

Reduce

该函数用于计算

需要先导入

from functool import reduce

    需求：求一个列表中所有元素的和

sorted()

    返回一个排序后的对象,默认按自然顺序排序(从小到大)，reverse = True ，则按从大到小

sort()

相关代码：

# list1 = [x for x in range(1,101)]
# #过滤
# it = filter(lambda x:x%2==0,list1)
# for i in it:
#     print(i)

#--------------------------------

#【1，2，3，4，5，6...】
#['1','2','3','4']

# from functools import reduce
# list2 = [x for x in range(1,101)]
# result = reduce(lambda x,y:x+y,list2)
# print(result)
#
# list3 = ['1','2','3','4']
# result2 = reduce(lambda x,y:x+y,list3)
# print(type(result2))
# print(result2)
# print(int(result2))

# list3 = [1,9,3,20,100,8]
# print(list3.sort())
# result3 = sorted(list3,reverse=True)
# print(result3)

class Student():
    """
    文档注释：Student(name,age) -> new Student with name,age
    """
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __str__(self):
        return '【'+self.name+' '+str(self.age)+'】 '

stu1 = Student('bbc',18)
stu2 = Student('bac',20)
stu3 = Student('cab',17)

list4 = [stu1,stu2,stu3]
# list5 = sorted(list4,key=lambda x:x.age,reverse=True)
list5 = sorted(list4,key=lambda x:x.name,reverse=True)
# print(list5)
for stu in list5:
    print(stu)

个人总结：

Sorted的用法就像Java中的 Comparable自然排序接口

论证知识：

Java：实现Comparable接口重写compareTo方法，然后重写比较的对象的toString方法

Python：定义比较规则（匿名函数），重写类的__str__方法

集合的使用

区别于字典，Python中也有set集合

var = {1,2,3,4,2}
# print(type(var))
# print(var)

var1 = {3,4,5,6}
#set不能使用+连接
# print(var+var1)

#&  取交集
print(var & var1)

#| 取并集
print(var | var1)

#^ 从并集中排除交集
print(var ^ var1)

#- {1,2,3,4} - {3,4,5,6}   从集合1中 刨除集合中与集合2的交集
print(var - var1)

#append.extend.insert
var.add(40)
print(var)
var.remove(4)
print(var)

#set没有索引值
# print(var[0])

over......