装饰器、管理内存

# -*- coding: utf-8 -*-
class People(object):

    def __init__(self, name, age):

        self.name = name
        self.age = age
        # 私有属性
        self.__number = 0

    # 这俩函数的作用，就是在为了在类声明的外部，可以访问到私有属性
    # 专门定义函数获取私有属性值
    # def num(self):
    #     # 返回私有属性值
    #     return self.__number
    #
    # # 专门定义函数设置私有属性值
    # # qwer是一个函数名  随便取
    # def qwer(self,value):
    #     # 给对象的属性赋值
    #     self.__number = value
    # # 专门定义函数删除私有属性
    # def delete_attr(self):
    #     # 删除属性
    #     del self.__number

    # 获取私有属性值  number = p1.number 会执行这个函数
    @property
    def number(self):
        # 返回私有属性值
        return self.__number

    # 设置私有属性值  p1.number = 666
    @number.setter
    def number(self, value):
        # 设置__number的值
        self.__number = value

    # 删除私有属性  del p1.number 会执行这个函数
    @number.deleter
    def number(self):
        # 删除属性
        del self.__number


    # @property
    # def work(self): # 当rs = 对象.work  会执行这个函数
    #     print('执行了@property装饰的work函数')
    #
    # @work.setter  # 当对象.work = 值  会执行这个函数
    # def work(self, value):
    #     print('执行了@work.setter装饰的work函数')
    #
    # @work.deleter # 当 del 对象.work  会执行这个函数
    # def work(self):
    #     print('执行了@work.deleter装饰的work函数')

p1 = People('张三', 22)
# 执行@property装饰的函数
# p1.work
# 执行@work.setter装饰的函数
# p1.work = 2000
# 执行@work.deleter装饰的函数
# del p1.work

# 在类声明的外部，无法直接访问私有属性
# number = p1.num()
# print(number)
# 在类声明的外部，无法直接访问私有属性
# p1.__number = 1000
# p1.qwer(1000)
# number = p1.num()
# print(number)
# 在类声明的外部，无法直接访问私有属性
# del p1.__number
# p1.delete_attr()


# 正常的对象属性赋值
# 对象.属性名 = 属性值
p1.name = '李四'
# 获取对象的属性值
name = p1.name
# 删除对象的属性
del p1.name


# 私有属性升级版
# 会去执行@property装饰number函数，函数执行完成后返回一个结果
num = p1.number
print(num)

# 会去执行@number.setter装饰的number函数，在函数中设置__number属性的值
p1.number = 666

# 会去执行@property装饰number函数，函数执行完成后返回一个结果
print(p1.number)

# 会去执行@number.deleter装饰的number函数，在函数中会将__number属性删除
del p1.number

# 会去执行@property装饰number函数，函数执行完成后返回一个结果
print(p1.number)
 class People(object):    '''        给_name属性赋值，值必须是字符串，否则抛出异常        给age属性赋值，值必须是整数，否则抛出异常    '''    def __init__(self, a, b):        # 执行@name.setter装饰的name函数，在函数中给_name属性赋值        self.name = a        self.age = b    # 获取_name属性的值    @property    def name(self):        # 返回属性值时，也可以添加一些额外的功能        _name = self._name        # 把姓氏换成*        _name = _name.replace(_name[0:3],'*')        # 返回_name属性的值        return _name    # 设置_name属性的值    @name.setter    def name(self, value):        # 在赋值之前添加判断        if not isinstance(value, str):            # 抛出异常            raise TypeError('People object.name, name must be a str !')        # 设置_name属性值        self._name = value        # 还可以继续添加其他的功能    # 删除_name属性    @name.deleter    def name(self):        # 添加一些额外的功能        if not hasattr(self,'_name'):            raise AttributeError('People object has no attribute "_name"')        # 删除_name属性        del self._namep1 = People('张三', 23)# _name的属性值 必须是一个字符串。否则抛出异常p1.name= '魑星星'print(p1.name)# 删除对象的_name属性del p1.name
# -*- coding: utf-8 -*-

# python中自动管理内存的
# 自动管理内存编程语言 例如：object-c python
# 手动管理内存编程语言 例如：c


# python中的内存管理采用的'引用计数'的方式, 如果一个对象的引用计数为0，该对象占用的内存会被python解释器清空，对象也会消失，如果一个对象的引用计数超过0，这个对象会一直存放在内存中

# Python中是自动管理内存的，实际上是通过"引用计数"的方式来管理内存。当一个对象被创建出来的时候，引用计数为1，当对象被其他对象引用时，引用计数会加1，当对象的引用被删除时，引用计数会-1，当对象的引用计数为0时，该对象所在内存会被系统在合适时间回收

'''
    对象在内存无法释放的情况，称之为内存泄露，内存泄露会导致程序占用内存过多，程序出现卡顿的情况，严重情况可能会导致内存崩溃，程序结束或者闪退

    对象多次删除，导致引用计数过渡减少，在之后的代码中有可能导致该对象不可用

'''
# sys 操作系统模块
import sys

class People(object):
    pass


# 当创建一个对象时，这个对象的计数为1
p1 = People()
# 通过个函数可以查看对象的引用计数
# ps：在这查到的是2，自己创建对象的时候+1，编译程序的时候，解释器+1(不需要我们管理)
number = sys.getrefcount(p1)
print(number)
# 当对象被引用的时候，引用计数会+1
p2 = p1

del p1
del p2

# print(p2)



# print(sys.getrefcount(p1))
# # 把对象放入列表中，也会造成计数+1
# list1 = [p1]
# print(sys.getrefcount(p1))
# # 创建对象
# p3 = People()
# # 给p3添加obj属性，属性值是一个p1对象 也会计数+1
# p3.obj = p1
# print(sys.getrefcount(p1))

# 当引用被删除的时候，引用计数-1
# del p2
# print(sys.getrefcount(p1))
#
# # 从列表中移除  引用计数-1
# del list1[0]
# print(sys.getrefcount(p1))
#
# # 删除对象属性
# del p3.obj
# print(sys.getrefcount(p1))
# # 删除创建时的引用计数，p1对象会被从内存中移除
#
# del p1
# # 删除之后，对象不可用
# print(sys.getrefcount(p1))



# 删除对象
class Man(object):
    # 当对象被创建的时候，回去执行初始化函数
    def __init__(self):

        print('Man类的对象被创建了')

    def eat(self):
        print('执行了Man类的eat函数...')
    # 当对象被删除(清除内存)的时候，会执行del函数
    def __del__(self):
        # 可以在对象被删除时，添加一些功能：例如，保存数据.....
        print('Man类的对象被清除了')

m = Man()
m.eat()
m1 = m
# 手动删除对象 引用计数-1
del m
m1.eat()
# 手动删除对象  应用计数-1  为0 对象被清除
del m1