python基础学习总结(十)

​

面向对象

一. 内置内属性

属性|定义

----|----

dict | 类的属性（包含一个字典，由类的数据属性组成）

doc | 类的文档字符串

name | 类名

module | 类定义所在的模块（类的全名是’main.className’，如果类位于一个导入模块mymod中，那么className.module 等于 mymod）

bases | 类的所有父类构成元素（包含了一个由所有父类组成的元组）

# 实例 1

class Employee:

    """所有员工的基类"""

    empCount = 0

    def __init__(self, name, salary):

        self.name = name

        self.salary = salary

        Employee.empCount += 1

    def displayCount(self):

        print("Total Employee %d" % Employee.empCount)

    def displayEmployee(self):

        print("Name : ", self.name, ", Salary: ", self.salary)

print("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 内部记录着所有使用中的对象各有多少引用。

一个内部跟踪变量，称为一个引用计数器。

当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的引用计数变为0 时， 它被垃圾回收。但是回收不是"立即"的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收。

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

析构函数 del ，__del__在对象销毁的时候被调用，当对象不再被使用时，__del__方法运行：

# 实例 2

class Point:

    def __init__( self, x=0, y=0):

        self.x = x

        self.y = y

    def __del__(self):

        class_name = self.__class__.__name__

        print(class_name, "销毁")

pt1 = Point()

pt2 = pt1

pt3 = pt1

print(id(pt1), id(pt2), id(pt3))

# 打印对象的id)

del pt1

del pt2

del pt3

注意： 通常你需要在单独的文件中定义一个类

三. 类的继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。

通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类。

继承语法

class 派生类名(基类名)

在python中继承中的一些特点：

1. 如果在子类中需要父类的构造方法就需要显式的调用父类的构造方法，或者不重写父类的构造方法。详细说明可查看：python 子类继承父类构造函数说明。

2. 在调用基类的方法时，需要加上基类的类名前缀，且需要带上 self 参数变量。区别在于类中调用普通函数时并不需要带上 self 参数

3. Python 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。

# 实例 3

class Parent:

    # 定义父类

    parentAttr = 100

    def __init__(self):

        print("调用父类构造函数")

    def parentMethod(self):

        print("调用父类方法")

    def setAttr(self, attr):

        Parent.parentAttr = attr

    def getAttr(self):

        print("父类属性 :", Parent.parentAttr)

# 定义子类

class Child(Parent):

    def __init__(self):

        print("调用子类构造方法")

    def childMethod(self):

        print("调用子类方法")


 

c = 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() | 布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)

isinstance(obj, Class) |布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。

四. 方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法：

# 实例 4

class Parent:

    # 定义父类

    def myMethod(self):

        print('调用父类方法')

class Child(Parent):

    # 定义子类

    def myMethod(self):

        print('调用子类方法')

       

c = Child() # 子类实例

c.myMethod() # 子类调用重写方法

1. 基础重载方法

下表列出了一些通用的功能，你可以在自己的类重写：

序号| 方法|描述|调用

–|—|—|----

1|init ( self [,args…] ) |构造函数| obj = className(args)

2| del( self )| 析构方法|删除一个对象 | del obj

3| repr( self )| 转化为供解释器读取的形式|repr(obj)

4|str( self )| 用于将值转化为适于人阅读的形式| str(obj)

5| cmp ( self, x ) |对象比较| cmp(obj, x)

2. 运算符重载

Python同样支持运算符重载

# 实例 5

class Vector:

    def __init__(self, a, b):

        self.a = a

        self.b = b

    def __str__(self):

        return 'Vector (%d, %d)' % (self.a, self.b)

    def __add__(self,other):

        return Vector(self.a + other.a, self.b + other.b)

   

v1 = Vector(2,10)

v2 = Vector(5,-2)

print(v1 + v2)

3. 类的属性和方法

1. 类的私有属性

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

2. 类的方法

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

3. 类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用 self.__private_methods。

# 实例 5

class JustCounter:

    __secretCount = 0 # 私有变量

    publicCount = 0 # 公开变量

    def count(self):

        self.__secretCount += 1

        self.publicCount += 1

        print(self.__secretCount)

counter = JustCounter()

counter.count()

counter.count()

print(counter.publicCount)

print(counter.__secretCount) # 报错，实例不能访问私有变量

Python不允许实例化的类访问私有数据，但你可以使用 object._className__attrName（ 对象名._类名__私有属性名 ），访问属性。

# 实例 6

class baidu:

    __site = "www.baidu.com"

baidu = baidu()

print(baidu._baidu__site)

五. 下划线说明

单下划线、双下划线、头尾双下划线说明：

1. foo : 定义的是特殊方法，一般是系统定义名字 ，类似 init() 之类的。

2. _foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *

3. __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

​