Python 对象学习一

#   对象的基本理论
#   什么是对象？
#   万物皆对象
#       对象是具体物体
#                       拥有属性
#                       拥有行为
#                       把很多零散的东西，封装成为一个整体
#       举例：王二小
#                   属性
#                           姓名
#                           年龄
#                           身高
#                           体重
#                   行为
#                           走路
#                           吃饭
#                           放羊
#       Python中的体现
#                      是一门特别彻底的面向对象编程(OOP)的语言
#                                                               其他语言:基本数据类型，对象类型
#                                                               python全部类型都是对象类型
#   面向对象是面向过程的封装
#   对象和类的关系：对象 可以抽象为类 类可以实例化为对象

class Money:
    pass

print(Money)    #<class ‘__main__.Money‘>
one = Money()
print(one, type(one))   #<__main__.Money object at 0x030CFBB0> <class ‘__main__.Money‘>

class Person:
    pass

#   对象的操作：增
p = Person()
#   查看对象的所有属性
print(p.__dict__)   #{}
p.age = 18
p.height = 180
print(p.__dict__)   #{‘age‘: 18, ‘height‘: 180}

#   对象的操作：删
del p.age

#   对象的操作：改
p.height = 185  #   对象里面如果有这个属性，就是修改，否则就是增加这个属性

#   类里面的 __dict__ 不可以修改，只读的
#   对象里的 __dict__ 可以修改
class Test:
    age = 18

#Test.__dict__["age"] = 20   #TypeError: ‘mappingproxy‘ object does not support item assignment

one = Test()

one.__dict__ = {"name":"abc", "height":180} #   __dict__字典里面生存储属性的变量
print(one.__dict__)     #{‘name‘: ‘abc‘, ‘height‘: 180}

#   理解下面的内容
class Person:
    age = 10

p = Person()

print(Person.age) # 10
print(p.age)      # 10

p.age += 5 #    p.age = p.age + 5
#   要理解这个在对象和类的操作方法：首先是计算右边的值，p.age 在对象p中没有，所以他要到类中去取age = 10
#   然后变成10+5 = 15, 然后在p对象中新增加个age属性（以前说过，对象没有就是新增，有的话就是修改)

print(Person.age) # 10
print(p.age)      # 15

#   __slots__
class Person:
    __slots__ = {"age"} #只能加入age的属性

p1 = Person()
p1.age = 18
print(p1.age)

#   方法：实例方法，类方法，静态方法

class Person:
    def eat(self):
        print("这是个实例方法", self)

    @classmethod
    def eat2(cls):
        print("这是个类方法", cls)

    @staticmethod
    def eat3():
        print("这是个静态方法")

p = Person()
print(p)
p.eat()
p.eat2()
p.eat3()
# <__main__.Person object at 0x032F54F0>
# 这是个实例方法 <__main__.Person object at 0x032F54F0>
# 这是个类方法 <class ‘__main__.Person‘>
# 这是个静态方法
print("-" * 30)
#另外的调用方式：
Person.eat("123")  #这里必须要有个参数，才能调用成功
Person.eat2()
Person.eat3()

print("-" * 30)

#   实例方法，类方法，静态方法的访问权限问题（包括类属性，实例属性）
class Person:
    age = 10
    #   实例方法
    def shilie(self):
        print(self)
        print(self.age)
        print(self.num)

    #   类方法
    @classmethod
    def leifangfa(cls):
        print(cls)
        print(cls.age)
        print(cls.num)  #   不可以使用实例属性

    #   静态方法
    @staticmethod
    def jingtai():
        print(Person.age)   #   能使用类里面的属性，但很少这样去调用的

p = Person()
p.num = 11

p.shilie()  #   实例方法：可以调用实例属性和类属性
#p.leifangfa()   #   类方法：不可以使用实例属性
p.jingtai() #   静态方法：可以使用类属性，不可以使用实例属性

#   元类
num = 123
str = "abc"
print(num.__class__.__class__)  #   <class ‘type‘>
print(str.__class__.__class__)  #   <class ‘type‘>
print(Person.__class__)         #   <class ‘type‘>
print(Person.__class__.__class__)#   <class ‘type‘>
print(p.__class__.__class__)    #   <class ‘type‘>

#   ----------------------------另外一种创建类的方式-------------------------
def run(self):
    print(self)

dog = type("Dog",(),{"name":"abc","run":run}) #字典里面可以是类属性，或者类方法
print(dog.name) #abc
print(dog.run)  #<function run at 0x02B56C90>

#   ---------------------------类的创建流程----------------------------------

class Animal:
    # __metaclass__ = xxx
    pass

class Person(Animal):
    # __metaclass__ = xxx
    pass

#   -------------------------类的描述, pydoc 模块---------------------------------------
class Person:
    """
    关于类的描述，类的左右，类的构造函数
    Attribute:
        属性的描述
    """
    def run(self, distence, step):
        """
        函数的作用
        :param distence:参数含义，数据类型，默认值
        :param step:
        :return:    返回值类型
        """
        return distence / step

#   help(Person) #  可以这样看帮助文档

#   ------------------------    私有化属性（类的内部，子类内部，模块内部，模块外部）4大块   -------

class Animal:
    x = 10
    _y = 20
    __z = 30
    def test(self):
        print(Animal.x)
        print(self.x)
        print(Animal._y)
        print(self._y)
        print(Animal.__z)
        print(self.__z)
        print("-" * 30)

class Dog(Animal):
    def test2(self):
        print(Dog.x)
        print(self.x)
        print(Dog._y)
        print(self._y)
        # print(Dog.__z)  #   错误
        # print(self.__z) #   错误
        print("-" * 30)

#   类的内部访问
a = Animal()
a.test()    #   成功打印x

#   子类的内部访问
d = Dog()
d.test2()   #   成功打印x

#   模块内部访问
# print(Animal.x) #   成功打印x
# print(Dog.x)    #   成功打印x
# print(a.x)      #   成功打印x
# print(d.x)      #   成功打印x
#   print(a.__z)    #   有错误
#
# print(Animal._y) #   成功打印_y，但有警告
# print(Dog._y)    #   成功打印_y，但有警告
# print(a._y)      #   成功打印_y，但有警告
# print(d._y)      #   成功打印_y，但有警告
# print(a.__z)      #   有错误
# print(d.__z)      #   有错误

print(Animal.__dict__)
print(Animal._Animal__z)    #  伪私有 30
#   模块外的访问
import public
print(public.num)   #   成功打印num
print(public._num2)

#   另外一种模块导入方法
from public import *
#   直接写public 模块中的变量
print(num)          #   成功打印num
#   print(_num2)    #   有错误

#   ------------------------    私有化属性应用场景   ---------------------------------
#   数据保护，数据过滤
class Person:

    def __init__(self):
        self.__age = 18

    def setAge(self, value):
        if isinstance(value, int) and 0 < value < 200 :
            self.__age = value
        else:
            print("you input data error!!!")

    def getAge(self):
        print("you age is ", self.__age)
        return self.__age

p = Person()
p.setAge(100)
print(p.getAge())

#   --------------- 私有化的2个规范---------------------
#   1.  x_  这样命名的主要是区分系统的关键字，但又想用这个名字，所以在下面加下划线，比如 int_, class_
#   2.  __x__   这种命名的主要是系统的内置命名功能的变量

#   --------------- 只读属性-------------------------
#   __x 这样在类中命名的变量，既不能在实例属性中读取和修改，除非通过间接的办法来实现；
#   比如在类中通过写个函数来读取类中的 __x 变量；如果现在来改写一下只能读取的方式；
class Person:
    def __init__(self):
        self.__age = 18

    @property
    def age(self):  #   这样就可以像正常通过实例属性来访问，但却不能通过实例属性来修改和增加
        return self.__age

p = Person()
print(p.age)    #   18
#   p.age = 111 #   AttributeError: can‘t set attribute
#   上面的只读属性，也不是安全的，可以通过设置__dict__来修改
# p.__dict__["_Person__age"] = 999
p._Person__age = 888
print(p.age)    #   888

#   --------------新式类（python 3.xx，继承object） 和 经典类（python 2.xxx 默认形式不继承object）  ----------
class Person:
    pass

print(Person.__bases__) #   (<class ‘object‘>,)    3.xx默认情况

#   也可以显示的显示如下，最好这样写，可以兼容2.xx:
class Person(object):
    pass

print(Person.__bases__) #   (<class ‘object‘>,)

#   ------------- 设置只读属性的正确方法   ---------------------------
class Person:
    #   需要只读的key 列表
    attr_key = ["age","name"]

    #   当我们通过：实例.key = value 操作的时候都会调用这个方法 __setattr__
    #   在这个方法的内部，在会把key : value 这些值存储到__dict__对象里面
    def __setattr__(self, key, value):
        print(key, value)
        if key in self.attr_key and key in self.__dict__.keys() :
            print("this is {} attrute only read ".format(key))
        else:
            # self.key = value #    这样写会有问题，涉入死循环
            self.__dict__[key] = value


p = Person()
p.age = 18  #执行到这里，就会打印   age 18
print(p.age)    # 18
print(p.__dict__)   #   {‘age‘: 18}

p.age = 19  # 这里赋值后就会提示上面的错误    this is age attrute only read


#   --------------------------内置特殊属性----------------------
#类属性
    # __dict__    类的属性
    # __bases__   类的所有父类构成的属性
    # __doc__     类的文档字符串
    # __name__    类名
    # __module__  类定义中的模块
    # __str__     类定义字符串
    #__call__   实例直接调用 p()

#实例属性
    # __dict__    实例属性
    # __class__   实例属性对应的类

class Person:
    def __call__(self, *args, **kwargs):
        print(args,kwargs)

    def __str__(self):
        return "这个是个人类的类（字符串）"

    def __repr__(self):
        return "这是个_repr_"

p = Person()
p() #  类中有了__call__，就可以这样调用了，打印() {}
p("123","abc", name="cctv")  #(‘123‘, ‘abc‘) {‘name‘: ‘cctv‘}

print(p.__str__())  #这个是个人类的类（字符串）
print(p)            #这个是个人类的类（字符串）
print(p.__repr__()) #这是个_repr_
print(repr(p))      #这是个_repr_

#   ------------------------    索引操作    --------------------------------

class Person:
    def __init__(self):
        self.cache = {}

    def __setitem__(self, key, value):
        print(key, value)
        self.cache[key] = value

    def __getitem__(self, key):
        print(key)
        return self.cache[key]

    def __delitem__(self, key):
        print(key)
        del self.cache[key]

p = Person()
p["name"] = "abc"
print(p["name"])
del p["name"]

print(p.cache)  #{}

#   ---------------------   比较操作    -----------------------------------
class Person:
    #   == ，!= , >, >= , < , =<
    def __init__(self, age, height):
        self.age = age
        self.height = height

    def __eq__(self, other):
        # print(self.age, other.age)
        return self.age == other.age

    def __ne__(self, other):
        return self.age != other.age

    def __gt__(self, other):    #大于
        pass

    def __ge__(self, other):    #大于等于
        pass

    def __lt__(self, other):    #小于
        pass

    def __le__(self, other):    #小于等于
        pass

p1 = Person(18, 180)
p2 = Person(18, 190)
print(p1 == p2) # True

print(p1 != p2 ) # False

#   -------------------- 上下文的布尔判断   -----------------------------
class Person:
    def __init__(self):
        self.age = 19

    def __bool__(self):
        return self.age >= 18


p1 = Person()
if (p1):
    print("p Ture") #   p Ture

#   --------------------遍历操作    --------------------------------------
class Person:
    def __init__(self):
        self.result = 0

    #   和上面的索引操作一样
    def __getitem__(self, item):
        self.result += 1
        if (self.result > 5 ):
            raise StopIteration("停止遍历")
        return self.result

    #   这个要优先于__getitem__ 运行
    def __iter__(self):
        self.result = 0 # 迭代器次重复使用
        return self

    def __next__(self):
        self.result += 1
        if (self.result > 5):
            raise StopIteration("next停止遍历")
        return self.result

p = Person()
for v in p :
    print(v)  # 1 2 3 4,5

#   -----------------------     描述器 ---------------------------
#   方法一：举例
class Person:
    def __int__(self):
        self.__age = 18

    def get_age(self):
        return self.__age

    def set_age(self, value):
        if value < 0 :
            value = 0
        self.__age = value

    def del_age(self):
        del self.__age

    #   方法一
    age = property(get_age, set_age, del_age)

p = Person()
p.age = 10  # 一定要赋值，不然下面调用就会错误
print(p.age)

class Person:
    def __int__(self):
        self.__age = 18

    @property
    def age(self):
        return self.__age
    @age.setter

    def age(self, value):
        if value < 0:
            value = 0
        self.__age = value

    @age.deleter
    def del_age(self):
        del self.__age

p = Person()
p.age = 20  # 一定要赋值，不然下面调用就会错误
print(p.age)

#   -------------------方法二------------------------
class Age:
    def __get__(self, instance, owner):
        print("get")
        return instance.v

    def __set__(self, instance, value):
        print("set")
        instance.v = value

    def __delete__(self, instance):
        print("delete")

class Person:
    age = Age()

p = Person()
p.age = 10
print(p.age)

#   -------------------使用类，实现装饰器 -----------------------
#   以前学过通过函数来实现装饰器,如:
def checkLogin(func):
    def inner():
        print("正在登陆认证")
        func()
    return inner

@checkLogin
def fashuoshuo():
    print("发说说")

fashuoshuo()    #正在登陆认证 发说说

#   现在换成类的形式
class Check:
    def __init__(self, func):
        self.f = func

    def __call__(self, *args, **kwargs):
        print("正在登陆认证")
        self.f()

@Check
def fatupian():
    print("发图片")

fatupian()  #   正在登陆认证 发图片

#   ----------  几个监听对象生命周期的方法-------------
class Person:
    # def __new__(cls, *args, **kwargs):
    #     print("新建一个对象的时候, 但被我拦截了")
    def __init__(self):
        print("这个类被初始化了")

    def __del__(self):
        print("这个对象被释放了")

p = Person()    #   新建一个对象的时候, 但被我拦截了
print(p)        #   None
p = Person()    #这里要把 __new__ 给注释掉，不然会被拦截

#   ----------  几个监听对象生命周期的方法：小案例-------------
#   Person, 打印一下，当前这个时刻，由Person类，产生的实例，有多少个
#   创建了一个实例，计数+1，如果删除了一个实例 计数-1

class Person:
    __personCount = 0

    def __init__(self):
        self.__class__.__personCount += 1   # 和下面的Person.__personCount 的方法是一样的

    def __del__(self):
        # Person.__personCount -= Person.__personCount - 1  有些问题
        self.__class__.__personCount -= 1
    @staticmethod
    def log():
        # print("当前创建人的实例有{}个".format(Person.__personCount))
        print("当前创建人的实例有%d个"%Person.__personCount)

    #   或者写成下面的形式
    @classmethod
    def log2(cls):
        print("当前创建人的实例有%d个" % cls.__personCount)

p = Person()
p2 = Person()
Person.log()    #   当前创建人的实例有2个
Person.log2()   #   当前创建人的实例有2个
del p2
Person.log()    #   当前创建人的实例有1个
Person.log2()   #   当前创建人的实例有1个

#   ----------------对象 内存管理机制 存储  ---------------------
num1 = 1
num2 = 1
print(id(num1), id(num2) )  #相同数值的变量地址一样，访问的是同一个地址，这是Python的机制决定的，优化访问时间

class Person:
    pass

p = Person()
p2 = Person()
print(id(p), id(p2))    #   打印地址不一样

#   ----------------引用计数器   ---------------------
import sys
#
class Person:
    pass

p1 = Person()
# 获得对象的引用次数
print(sys.getrefcount(p1)) #    2

p2 = p1
print(sys.getrefcount(p1))  #   3
print(sys.getrefcount(p2))  #   3
del p1

del p2

#   -------------   引用计数器机制-特殊场景--循环引用问题-----------
#   内存管理机制：引用计数器机制 + 垃圾回收机制
#   当一个对象被引用时 +1， 删除一个引用 -1 ，0：自动释放
#   objgraph
#   objgraph.count(), 可以查看，垃圾回收器，跟踪的对象个数

import objgraph
class Person:
    pass

class Dog:
    pass

p = Person()
d = Dog()

p.pet = d
d.master = p
print(objgraph.count("Person")) #   1
print(objgraph.count("Dog"))    #   1

del p
del d
print(objgraph.count("Person")) #   1   这样就造成了内存泄露
print(objgraph.count("Dog"))    #   1

#   --------------内存管理机制    垃圾回收    如何检测循环引用    -----------
#   --------------垃圾回收机制    分代回收    ------------
#   --------------垃圾回收机制中   新增的对象个数 -  消亡的对象个数 达到一定个数才会触发垃圾检测
import gc
#查看阀值，700个对象，10次
print(gc.get_threshold())   #   (700, 10, 10)
gc.set_threshold(200,5,5)   #   设置参数
print(gc.get_threshold())   #   (200, 5, 5)

#   --------------垃圾回收机制    触发时机（自动，和手动)
import gc

#   自动回收
#   查看垃圾回收机制是否开启，默认是开启的
print(gc.isenabled()) # True
#   达到一定的阀值才会执行
#   关闭垃圾回收机制
gc.disable()

#   手动回收
import gc
import objgraph

class Person:
    pass

class Dog:
    pass

p = Person()
d = Dog()

p.pet = d
d.master = p

del p
del d
gc.disable()    #关闭垃圾回收后，下面语句也有效果
#   通过“引用计数器机制”无法回收；需要借助“垃圾回收机制”进行回收
gc.collect() #  参数有：空，0，1，2 空代表全部代的回收，0，代表0代回收，2，代表0，1，2代都回收
#   查看
print(objgraph.count("Person")) #   0
print(objgraph.count("Dog"))    #   0