# 对象的基本理论
# 什么是对象？
# 万物皆对象
# 对象是具体物体
# 拥有属性
# 拥有行为
# 把很多零散的东西，封装成为一个整体
# 举例：王二小
# 属性
# 姓名
# 年龄
# 身高
# 体重
# 行为
# 走路
# 吃饭
# 放羊
# 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
