我在偷偷学Python的第二十四天（面向对象第二篇）

内置属性

• dict : 类的属性&＃xff08;包含一个字典&＃xff0c;由类的数据属性组成&＃xff09;
• doc :类的文档字符串
• name: 类名
• module: 类定义所在的模块&＃xff08;类的全名 是’main.className’&＃xff0c;如果类位于一个导入模块mymod中&＃xff0c;那么className.module 等于
  mymod&＃xff09;
• bases : 类的所有父类构成元素&＃xff08;包含了一个由所有父类组成的元组&＃xff09;

class Employee:&＃39;所有员工的基类&＃39;empCount &＃61; 0def __init__(self, name, salary):self.name &＃61; nameself.salary &＃61; salaryEmployee.empCount &＃43;&＃61; 1def displayCount(self):print"Total Employee %d" % Employee.empCountdef displayEmployee(self):print"Name : ", self.name, ", Salary: ", self.salaryprint("Employee.__doc__:", Employee.__doc__)
print("Employee.__name__:", Employee.__name__)
print("Employee.__module__:", Employee.__module__)
print("Employee.__bases__:", Employee.__bases__)
print("Employee.__dict__:", Employee.__dict__)


python对象销毁(垃圾回收)

Python 使用了引用计数这一简单技术来跟踪和回收垃圾。
在 Python 内部记录着所有使用中的对象各有多少引用。
一个内部跟踪变量&＃xff0c;称为一个引用计数器。
当对象被创建时&＃xff0c; 就创建了一个引用计数&＃xff0c; 当这个对象不再需要时&＃xff0c; 也就是说&＃xff0c; 这个对象的引用计数变为0 时&＃xff0c; 它被垃圾回收。但是回收不是"立即"的&＃xff0c; 由解释器在适当的时机&＃xff0c;将垃圾对象占用的内存空间回收。

a &＃61; 40 # 创建对象 <40>
b &＃61; a # 增加引用&＃xff0c; <40> 的计数
c &＃61; [b] # 增加引用. <40> 的计数del a # 减少引用 <40> 的计数
b &＃61; 100 # 减少引用 <40> 的计数
c[0] &＃61; -1 # 减少引用 <40> 的计数


垃圾回收机制不仅针对引用计数为0的对象&＃xff0c;同样也可以处理循环引用的情况。循环引用指的是&＃xff0c;两个对象相互引用&＃xff0c;但是没有其他变量引用他们。这种情况下&＃xff0c;仅使用引用计数是不够的。Python 的垃圾收集器实际上是一个引用计数器和一个循环垃圾收集器。作为引用计数的补充&＃xff0c; 垃圾收集器也会留心被分配的总量很大&＃xff08;即未通过引用计数销毁的那些&＃xff09;的对象。 在这种情况下&＃xff0c; 解释器会暂停下来&＃xff0c; 试图清理所有未引用的循环。

** 实例**

析构函数 del &＃xff0c;__del__在对象销毁的时候被调用&＃xff0c;当对象不再被使用时&＃xff0c;__del__方法运行&＃xff1a;

class Point:def __init__( self, x&＃61;0, y&＃61;0):self.x &＃61; xself.y &＃61; ydef __del__(self):class_name &＃61; self.__class__.__name__print class_name, "销毁"pt1 &＃61; Point()
pt2 &＃61; pt1
pt3 &＃61; pt1
print id(pt1), id(pt2), id(pt3) # 打印对象的id
del pt1
del pt2
del pt3


类的继承

面向对象的编程带来的主要好处之一是代码的重用&＃xff0c;实现这种重用的方法之一是通过继承机制。
通过继承创建的新类称为子类或派生类&＃xff0c;被继承的类称为基类、父类或超类。

继承语法

class 派生类名(基类名)...


在python中继承中的一些特点&＃xff1a;

• 1、如果在子类中需要父类的构造方法就需要显式的调用父类的构造方法&＃xff0c;或者不重写父类的构造方法。详细说明可查看&＃xff1a; python
  子类继承父类构造函数说明。
• 2、在调用基类的方法时&＃xff0c;需要加上基类的类名前缀&＃xff0c;且需要带上 self 参数变量。区别在于类中调用普通函数时并不需要带上 self 参数
• 3、Python
  总是首先查找对应类型的方法&＃xff0c;如果它不能在派生类中找到对应的方法&＃xff0c;它才开始到基类中逐个查找。&＃xff08;先在本类中查找调用的方法&＃xff0c;找不到才去基类中找&＃xff09;。

如果在继承元组中列了一个以上的类&＃xff0c;那么它就被称作"多重继承" 。
语法&＃xff1a;
派生类的声明&＃xff0c;与他们的父类类似&＃xff0c;继承的基类列表跟在类名之后&＃xff0c;如下所示&＃xff1a;

class SubClassName (ParentClass1[, ParentClass2, ...]):...


看代码&＃xff1a;

class Parent: # 定义父类parentAttr &＃61; 100def __init__(self):print "调用父类构造函数"def parentMethod(self):print &＃39;调用父类方法&＃39;def setAttr(self, attr):Parent.parentAttr &＃61; attrdef getAttr(self):print "父类属性 :", Parent.parentAttrclass Child(Parent): # 定义子类def __init__(self):print "调用子类构造方法"def childMethod(self):print &＃39;调用子类方法&＃39;c &＃61; Child() # 实例化子类
c.childMethod() # 调用子类的方法
c.parentMethod() # 调用父类方法
c.setAttr(200) # 再次调用父类的方法 - 设置属性值
c.getAttr() # 再次调用父类的方法 - 获取属性值


你可以继承多个类

class A: # 定义类 A
.....class B: # 定义类 B
.....class C(A, B): # 继承类 A 和 B
.....


你可以使用issubclass()或者isinstance()方法来检测。

• issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类&＃xff0c;语法&＃xff1a;issubclass(sub,sup)
• isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。

方法重写

如果你的父类方法的功能不能满足你的需求&＃xff0c;你可以在子类重写你父类的方法&＃xff1a;

class Parent: # 定义父类def myMethod(self):print &＃39;调用父类方法&＃39;class Child(Parent): # 定义子类def myMethod(self):print &＃39;调用子类方法&＃39;c &＃61; Child() # 子类实例
c.myMethod() # 子类调用重写方法


基础重载方法

下表列出了一些通用的功能&＃xff0c;你可以在自己的类重写&＃xff1a;

运算符重载

Python同样支持运算符重载&＃xff0c;实例如下&＃xff1a;

class Vector:def __init__(self, a, b):self.a &＃61; aself.b &＃61; bdef __str__(self):return &＃39;Vector (%d, %d)&＃39; % (self.a, self.b)def __add__(self,other):return Vector(self.a &＃43; other.a, self.b &＃43; other.b)v1 &＃61; Vector(2,10)
v2 &＃61; Vector(5,-2)
print v1 &＃43; v2


类属性与方法

类的私有属性

• __private_attrs&＃xff1a;两个下划线开头&＃xff0c;声明该属性为私有&＃xff0c;不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法

• 在类的内部&＃xff0c;使用 def 关键字可以为类定义一个方法&＃xff0c;与一般函数定义不同&＃xff0c;类方法必须包含参数 self,且为第一个参数

类的私有方法

• __private_method&＃xff1a;两个下划线开头&＃xff0c;声明该方法为私有方法&＃xff0c;不能在类的外部调用。在类的内部调用 self.__private_methods

class JustCounter:__secretCount &＃61; 0 # 私有变量publicCount &＃61; 0 # 公开变量def count(self):self.__secretCount &＃43;&＃61; 1self.publicCount &＃43;&＃61; 1print self.__secretCountcounter &＃61; JustCounter()
counter.count()
counter.count()
print counter.publicCount
print counter.__secretCount # 报错&＃xff0c;实例不能访问私有变量


Python 通过改变名称来包含类名:

1
2
2
Traceback (most recent call last):File "test.py", line 17, in <module>print counter.__secretCount # 报错&＃xff0c;实例不能访问私有变量
AttributeError: JustCounter instance has no attribute &＃39;__secretCount&＃39;


Python不允许实例化的类访问私有数据&＃xff0c;但你可以使用 object._className__attrName&＃xff08; 对象名._类名__私有属性名 &＃xff09;访问属性&＃xff0c;参考以下实例&＃xff1a;

class Runoob:__site &＃61; "www.runoob.com"runoob &＃61; Runoob()
print runoob._Runoob__site


单下划线、双下划线、头尾双下划线说明&＃xff1a;
foo: 定义的是特殊方法&＃xff0c;一般是系统定义名字 &＃xff0c;类似 init() 之类的。
_foo: 以单下划线开头的表示的是 protected 类型的变量&＃xff0c;即保护类型只能允许其本身与子类进行访问&＃xff0c;不能用于 from module import *
__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

时间&＃xff1a;2020/12/14