python自动化测试第 6 章.面向对象基础

作者: 失忆的蝴蝶 | 来源:发表于2021-11-27 11:27 被阅读0次

1. 类

前面学习的基本数据类型用来表示最常见的信息。但是信息有无穷多种，为了更好的表达信息，我们可以创建自定义数据类型，每一个数据类型就是一个类。

1.1 类的概念

一种数据类型就是一个类。例如整数（int），浮点数（float），字符串（str）等等。

1.2 类的定义

为了方便使用，python内置已经定义好了一些常见的类（如：int、float、str），但是在实际编程中，也会遇到很多类似的情况，所以为了方便编程，可以自行创建自己所需要的数据类型（如：动物类、植物类等等）。
python 中通过关键字 class 可以定义一个自定义数据类型，基本语法如下：

class 类名:
    属性
    方法

注意：python 中类名规则同变量，一般使用大驼峰（首个英文字母大写）来表示。
案例
例如：创建一个 Point 类用于表示平面坐标系中的一个点

class Point:
    """
创建一个 Point 类
    """
       
print(Point) # 打印这个创建的类，输出<class '__main__.Point'>
print(int)   # 对比整数类，打印出输出<class 'int'>

2. 对象

2.1 对象的概念

某种数据类型的一个具体的数据称为这个类的一个对象或者实例。通过类创建对象叫做实例化。如：任意一个整数（如：10）是int的一个对象或者叫实例，任意一个字符串是str的一个对象，任意一个浮点数就是float的一个对象，任意一个动物（如：老虎）就是动物类的一个对象或者叫实例。

所谓的面向对象，就是把一些数据抽象成类的思想。

python 是一门面向对象的编程语言，python 中一切皆对象。

前面学习的函数也是 python 中的一个类，定义的某个函数就是函数类的一个具体实例。

def func():
    pass
print(type(func)) #<class 'function'>

2.2 实例化

除了基本数据类型实例化的过程中用到的特殊的语法规范外，所有自定义类型进行实例化都是通过调用类名来实现的，非常简单，语法如下：

类名(参数)

看起来和调用函数一样。
案例
给上面创建的 Point 类创建一个实例。

point = Point() # 类名(参数)，因为定义的这个类没有参数，所以实例化的时候括号内容为空
print(type(point))#<class 'main.Point'>

3. 属性

类和对象的特征数据称为属性。

3.1 类属性

类的特征称为类属性。

3.1.1 类属性的定义

直接在类中定义的变量（与 class 语句只有一个缩进），就是类属性。

案例：
给 Point 类创建一个 name 属性用来表示名称。

class Point:
    """
    创建一个 Point 类
    """
    name = '点 '

3.1.2 类属性的访问

类属性可以直接通过类名和对象以句点法访问，语法格式如下：

类名.类属性名
对象.类属性名
案例：

print(Point.name)  # 直接通过类名访问类属性
point=Point()  # 创建一个实例
print(point.name)     # 通过对象访问类属性

输出：
点
点
注意：如果不存在属性则抛出 AttributeError 的异常

3.2 对象属性

对象的特征数据称为对象属性。

3.2.1 对象属性的定义

对象属性一般定义在构造方法中，详见下面构造方法一节。

通过句点法对象.对象属性 以赋值的方式可以直接定义对象属性。

案例：
平面坐标系中的每个点都有 x 坐标和 y 坐标，通过类 Point 创建一个对象表示点（x=1，y=2）

point = Point()
# 通过赋值直接定义对象属性
point.x = 1
point.y = 2

注意：在定义对象属性时如果和类属性同名，那么通过对象将无法访问到类属性。

3.2.2 对象属性的访问

通过句点法 对象.对象属性 可以访问对象属性。

案例：
访问上面案例中 point 的 x 坐标和 y 坐标

print(point.x)
print(point.y)
1
2

访问对象属性时，首先会检查对象是否拥有此属性，如果没有则去创建对象的类中查找有没有同名的类属性，如果有则返回，如果都找不到则抛出 AttributeError 的异常

4. 方法

定义在类中的函数称为方法。通过调用的方式的不同，分为对象方法，类方法，静态方法和魔术方法。

4.1 对象方法

定义在类中的普通方法，一般通过对象调用称为对象方法。

4.1.1 对象方法的定义

为了讲清楚对象方法的定义和调用，我们先看下面的案例。

案例：
定义函数 my_print，它接收一个 Point 对象，然后打印这个点的 x，y 坐标。

class Point:
    """

    """
    name = '点 '


def my_print(Point):
    print('({},{})'.format(Point.x, Point.y))


point = Point()
point.x = 1
point.y = 2

my_print(point)

定义函数 distance，它接收两个 Point 对象，然后返回这两个点的距离。

class Point:
    """

    """
    name = '点 '


def my_print(Point):
    print('({},{})'.format(Point.x, Point.y))


def distance(p1, p2):
    return ((p1.x-p2.x)**2+(p1.y-p2.y)**2)**0.5



point1 = Point()
point1.x = 0
point1.y = 0

point2 = Point()
point2.x = 3
point2.y = 4
res = distance(point1, point2)
print(res)

观察上面的两个函数，发现它们都接收一个或多个 Point 的对象作为参数。为了显式的加强这样的联系，我们可以将它们定义在 Point 的类中。
下面使用面向对象的思想对上面两个例子进行改编，把函数定义在类中

class Point:
    """
    表示平面坐标系中的一个点
    """
    name = '点'

    def my_print(point):
        print('({},{})'.format(point.x, point.y))

    def distance(p1, p2):
        return ((p1.x-p2.x)**2 + (p1.y-p2.y)**2)**0.5

4.1.2 对象方法的调用

对象方法向属性一样，可以通过句点法进行调用。

方法1：类名.方法名(参数)
方法2：对象.方法名(参数)，一般使用此方法

类名.方法名(参数)
对象.方法名(参数)
通过类名调用方法时，和普通函数没有区别，参数放在后面的括号中

point1 = Point()
point1.x = 0
point1.y = 0

point2 = Point()
point2.x = 3
point2.y = 4
Point.my_print(point1)  # 类名.方法名(参数)  (0,0)
res = Point.distances(point1, point2)   # 类名.方法名(参数)
print(res)

通过对象调用方法时，对象本身会被隐式的传给方法的第一个参数

point.my_print()
res = p1.distance(p2)
print(res)

因此，定义对象方法会习惯性的把第一个形参定义为 self，表示调用对象本身

class Point:
    """

    """
    name = '点 '

    def my_print(self):
        print('({},{})'.format(self.x, self.y))

    def distances(self,p2):
        return ((self.x-p2.x)**2+(self.y-p2.y)**2)**0.5


point1 = Point()
point1.x = 0
point1.y = 0

point2 = Point()
point2.x = 3
point2.y = 4
# 调用方法
point1.my_print()  # 对象.方法名(参数)   (0,0)
Point.my_print(point1)  # 类名.方法名(参数)  (0,0)

res = Point.distances(point1, point2)   # 类名.方法名(参数)
print(res)
res1 = point1.distances(point2)  # 对象.方法名(参数)
print(res1)

4.2 类方法

在类中通过装饰器 classmethod 可以把一个方法变成类方法。

一个类方法把类自己作为第一个实参，就像一个实例方法把实例自己作为第一个实参。

案例
给Point类定义一个类方法，用来返回坐标原点。
通过类本身或者是该类的实例都可以调用类方法。

class Point:
    """
    Point表示平面坐标系中的一个点
    """

    name = '点'

    def my_print(self):
        print('({},{})'.format(self.x, self.y))

    def distance(self, pp):
        return ((self.x - pp.x) ** 2 + (self.y - pp.y) ** 2) ** 0.5

    @classmethod
    def base_point(cls):
        bp = cls()
        bp.x = 0
        bp.y = 0
        return bp

# 通过类本身或者是该类的实例都可以调用类方法。
res = Point.base_point()
res.my_print()
b = Point
b.base_point().my_print()

调用方法
类名.类方法(参数)
对象.类方法(参数)
两个调用方式都会隐式的把类本身传递给类方法的第一个参数，所以这个参数默认定义为cls表示类本身
类方法一般都用来生成特殊对象。

4.3 特殊方法（魔术方法）

在类中可以定义一些特殊的方法用来实现特殊的功能，也称为魔术方法。这些方法一般都以双下划线 __ 开头，下面介绍两种魔术方法

4.3.1 第一种常用魔术方法`init`

__init__ 又叫构造方法，初始化方法，在调用类名实例化对象时，构造方法会被调用，类名括号 () 后的参数会传递给构造方法，对象属性一般在这个方法中定义。
当创建对象的时候它会被自动调用，创建的对象会被传递个第一个参数，会接受类名括号里传入的参数（从第二个参数开始传）
案例：
上面案例中的 Point 类实例化后，需要手动创建对象属性 x 和 y，这显然容易出错和不规范，正确的做法应该是在构造方法中定义属性 x 和 y。

class Point:
    """
    创建一个类
    """
    name = '点'  # 类的属性

    def __init__(self, x, y):
        self.x = x
        self.y = y
        print('我执行了初始化方法')

    def my_print(self):     # 对象方法
        print('({},{})'.format(self.x, self.y))

    def distance(self, pp):
        return ((self.x - pp.x) ** 2 + (self.y - pp.y) ** 2) ** 0.5


# 实例化
p1 = Point(0, 0)
p2 = Point(x=3, y=4)
p1.my_print()
p3 = Point(6, 8)
res0 = p1.distance(p2)
res1 = p1.distance(p3)
print(res0, res1)

实例化创建对象时，会把对象传递给__init__中的self，比如：p3 = Point(6, 8)，会把实例化的对象Point传递给__init__中的self，把6传递给x，把8传递给y

4.3.2 第二种常用魔术方法`str`

__str__ 方法在对象被 print 函数打印时被调用，print 输出__str__方法返回的字符串。
print一个对象的时候，实际上会调用这个对象的str方法，打印这个方法的返回值
案例：
直接使用print函数打印实例化的对象，会输出类及创建对象的内存地址，如;

p1 = Point(0, 0)
print(p1)  #输出<__main__.Point object at 0x000001C34CC0BB00>

上面案例中 Point 类里的 my_print 方法可以去掉，定义一个__str__方法，就可以实现打印对象是打印一个点的形式，见如下代码：

class Point:
    """
    创建一个类
    """
    name = '点'  # 类的属性

    def __init__(self, x, y):
        self.x = x
        self.y = y
        print('我执行了初始化方法')

    def __str__(self):
        return '({},{})'.format(self.x, self.y)

    def distance(self, pp):
        return ((self.x - pp.x) ** 2 + (self.y - pp.y) ** 2) ** 0.5

# 实例化
p1 = Point(0, 0)
print(p1)  # 输出(0, 0)

其实我们之前所学的基本数据类型的方法也都是有__str__方法的，否则也无法输出对应的格式，比如，以字符串和列表为例

# 字符串：打印的时候为了方便，隐藏了.__str__()
print('123') #等价于print('123'.__str__())，隐藏了.__str__()
print('123'.__str__())
# 列表：打印的时候为了方便，隐藏了.__str__()
print([1, 2, 3])  # 等价于print([1, 2, 3].__str__())，隐藏了.__str__()
print([1, 2, 3].__str__())

print(dir(str)) # 可以查看到字符串这个类也是有__str__方法的
print(dir(list)) # 可以查看到l列表这个类也是有__str__方法的

通过上面的例子可以了解到，其实所有的类（包括基本数据类型：字符串、列表、字典等等）中都是有__str__方法的，不同的类（数据类型）要区别打印出来的形式，比如：元组是小括号，列表是中括号。
都可以发现，print的时候，都省略了.__str__()，看起来就像是没有调用的样子。这就是魔术方法与众不同的地方，不用显式调用就是魔术

创建一个类的时候，如果需要打印出这个类，就需要在类中创建一个__str__方法来定义这个类的表现形式（如：元组是小括号，列表是中括号等等）

更多的魔术（特殊）方法详见官方文档

4.4 静态方法

在类中通过装饰器 staticmethod 可以把一个方法变静态方法。

静态方法不会接收隐式的第一个参数，它和普通的函数一样，只是被封装到类中。

通过类和对象都可以调用。

案例：
在 Point 类中定义一个静态方法，用来计算两个数的和。

class Point:
    """
    创建一个类
    """
    name = '点'  # 类的属性

    def __init__(self, x, y):
        self.x = x
        self.y = y
        print('我执行了初始化方法')

    def __str__(self):
        return '({},{})'.format(self.x, self.y)

    # def my_print(self):     # 对象方法
    #     print('({},{})'.format(self.x, self.y))

    def distance(self, pp):
        return ((self.x - pp.x) ** 2 + (self.y - pp.y) ** 2) ** 0.5

    @classmethod
    def base_point(cls):
        bp = cls()
        bp.x = 0
        bp.y = 0
        return bp

    @staticmethod
    def my_sum(x, y):
        return x+y


res = Point.my_sum(1, 2)
print(res)

p = Point(2, 3)
res1 = p.my_sum(4, 5)
print(res1)

5. 类的继承

类还有一个重要的特性是继承。

5.1 继承

当定义一个类时，可以从现有的类继承，新的类称为子类(Subclass)，被继承的类称为基类，父类或超类(Base class,Super class).

子类可以继承父类的属性和方法。

案例：
创建一个类用来表示三维的点。

class Point:
    """
    创建一个类
    """
    name = '点'  # 类的属性

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

    def __str__(self):
        return '({},{})'.format(self.x, self.y)

    def distance(self, pp):
        return ((self.x - pp.x) ** 2 + (self.y - pp.y) ** 2) ** 0.5

    @classmethod
    def base_point(cls):
        bp = cls(0, 0)
        return bp

    @staticmethod
    def my_sum(x, y):
        return x+y


class ThPoint(Point):       # 继承Point类
    """
    创建一个类用来表示三维的点
    """


print(ThPoint.name)  # 可以调用父类中的属性
print(ThPoint.base_point())     # 可以调用父类中的类方法
print(ThPoint.my_sum(1, 2))     # 可以调用父类中的静态方法

在上面的案例中 TdPoint 类继承了 Point 类。对于 TdPoint 来说 Point 是它的父类，对于 Point 类来说 TdPoint 是他的子类。

print(dir(TdPoint))

['class', 'delattr', 'dict', 'dir', 'doc', 'eq', 'format', 'ge', 'getattribute', 'gt', 'hash', 'init', 'init_subclass', 'le', 'lt', 'module', 'ne', 'new', 'reduce', 'reduce_ex', 'repr', 'setattr', 'sizeof', 'str', 'subclasshook', 'weakref', 'base_point', 'distance', 'name', 'sum']

虽然在 TdPoint 类中没有定义任何的属性和方法，但它自动继承了父类 Point 的属性和方法。

5.2 重写

在上面的案例中，虽然 TdPoint 类继承了 Point 的属性和方法，但是三维的点比二维的点多了一个纬度，所以大部分方法和属性不合适，需要重写。

在子类中定义同名的方法和属性会覆盖父类的方法和属性。
案例：
因为三维的点比二维的点多了一个纬度，而在__init__初始化时父类是只定义了x,y，没有z，所以，子类ThPoint中需要重写__init__方法

class Point:
    """
    创建一个类
    """
    name = '点'  # 类的属性

    def __init__(self, x, y):
        self.x = x
        self.y = y
        print('我执行了初始化方法')

    def __str__(self):
        return '({},{})'.format(self.x, self.y)

    # def my_print(self):     # 对象方法
    #     print('({},{})'.format(self.x, self.y))

    def distance(self, pp):
        return ((self.x - pp.x) ** 2 + (self.y - pp.y) ** 2) ** 0.5

    @classmethod
    def base_point(cls):
        bp = cls()
        bp.x = 0
        bp.y = 0
        return bp

    @staticmethod
    def my_sum(x, y):
        return x+y


class ThPoint(Point):
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

实例化并打印一个三维的点

p1 = ThPoint(1, 2, 3)
print(p1)

上面的print(p1)打印的结果是（1，2）这是为什么呢？p1实例化ThPoint(1, 2, 3)已经传了z=3，而实际结果只输出了二位的（1，2）？
原因是执行print(p1)时，先从子类ThPoint中寻找__str__方法，但是ThPoint中并没有此方法，所以到父类中寻找__str__方法，而父类中的__str__方法中只return了x坐标和y坐标，并没有z坐标，所以必须要更改__str__方法，让其返回z坐标。但是不能直接在父类Point中更改__str__方法，因为如果改了，就无法满足输出二维的点了，要同时满足既可以输入二维的点，又可以输出三维的点。解决的方法就是重写：在子类ThPoint中写一个__str__方法，打印三维点的数据格式，这样要打印三维点的时候，实例化T和Point后，遵循就近原则，先从当前的子类中寻找__str__方法，对上面代码进行修改，在子类中添加__str__方法：

class Point:
    """
    创建一个类
    """
    name = '点'  # 类的属性

    def __init__(self, x, y):
        self.x = x
        self.y = y
        print('我执行了初始化方法')

    def __str__(self):
        return '({},{})'.format(self.x, self.y)

    # def my_print(self):     # 对象方法
    #     print('({},{})'.format(self.x, self.y))

    def distance(self, pp):
        return ((self.x - pp.x) ** 2 + (self.y - pp.y) ** 2) ** 0.5

    @classmethod
    def base_point(cls):
        bp = cls()
        bp.x = 0
        bp.y = 0
        return bp

    @staticmethod
    def my_sum(x, y):
        return x+y


class ThPoint(Point):
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

    def __str__(self):
        return '({},{},{})'.format(self.x, self.y, self.z)

    def distance(self, p2):
        return ((self.x - p2.x) ** 2 + (self.y - p2.y) ** 2 + (self.z - p2.z) ** 2) ** 0.5

    @classmethod
    def base_point(cls):
        return cls(0, 0, 0)

上面的代码中 TdPoint 类重写了父类中的init,str,distance,base_point 三个方法

p1 = TdPoint(0,0,0)
p2 = TdPoint(2,3,4)

print(p1)

(0,0,0)

print(p1.distance(p2))

5.385164807134504

5.3 super 方法

重写了父类方法后如果又要调用父类的方法怎么解决呢？

例如，三维点在计算点与点的距离时，要求同时返回投射到二维平面的点的距离。

super() 函数是用于调用父类(超类)的一个方法。

super() 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。

MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

方法一：直接通过类名的方式调用对应的方法（不推荐，因为不知道调用的方法的父类是哪层的，可能是父类，也可能是父类的父类）

class Point:
    """
    创建一个类
    """
    name = '点'  # 类的属性

    def __init__(self, x, y):
        self.x = x
        self.y = y
        print('我执行了初始化方法')

    def __str__(self):
        return '({},{})'.format(self.x, self.y)

    # def my_print(self):     # 对象方法
    #     print('({},{})'.format(self.x, self.y))

    def distance(self, pp):
        return ((self.x - pp.x) ** 2 + (self.y - pp.y) ** 2) ** 0.5

    @classmethod
    def base_point(cls):
        bp = cls()
        bp.x = 0
        bp.y = 0
        return bp

    @staticmethod
    def my_sum(x, y):
        return x+y


class ThPoint(Point):
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

    def __str__(self):
        return '({},{},{})'.format(self.x, self.y, self.z)

    def distance(self, p2):
        ds2 = Point.distance(self, p2)  #直接通过类名的方式调用对应的方法
        ds3 = ((self.x - p2.x) ** 2 + (self.y - p2.y) ** 2 + (self.z - p2.z) ** 2) ** 0.5
        return ds2,ds3

    @classmethod
    def base_point(cls):
        return cls(0, 0, 0)


p1 = ThPoint(0, 0, 0)
p2 = ThPoint(3, 4, 0)
print(p1.distance(p2))

方法二：使用super调用父类中的方法

class Point:
    """
    创建一个类
    """
    name = '点'  # 类的属性

    def __init__(self, x, y):
        self.x = x
        self.y = y
        print('我执行了初始化方法')

    def __str__(self):
        return '({},{})'.format(self.x, self.y)

    # def my_print(self):     # 对象方法
    #     print('({},{})'.format(self.x, self.y))

    def distance(self, pp):
        return ((self.x - pp.x) ** 2 + (self.y - pp.y) ** 2) ** 0.5

    @classmethod
    def base_point(cls):
        bp = cls()
        bp.x = 0
        bp.y = 0
        return bp

    @staticmethod
    def my_sum(x, y):
        return x+y


class ThPoint(Point):
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

    def __str__(self):
        return '({},{},{})'.format(self.x, self.y, self.z)

    def distance(self, p2):
        ds2 = super().distance(p2)  #使用super调用父类中的方法
        ds3 = ((self.x - p2.x) ** 2 + (self.y - p2.y) ** 2 + (self.z - p2.z) ** 2) ** 0.5
        return ds2,ds3

    @classmethod
    def base_point(cls):
        return cls(0, 0, 0)


p1 = ThPoint(0, 0, 0)
p2 = ThPoint(3, 4, 0)
print(p1.distance(p2))

使用super调用父类方法的好处：
在具有单继承的类层级结构中，super 可用来引用父类而不必显式地指定它们的名称，从而令代码更易维护。
super()会返回一个代理对象，它会将方法调用委托给父类，这对于访问已在类中被重载的父类方法很有用。

5.4 多态

python 是一门动态语言，严格的来说 python 不存在多态。

Java中多态性的表现：多态性，可以理解为一个事物的多种形态。同样python中也支持多态，但是是有限的的支持多态性，主要是因为python中变量的使用不用声明，所以不存在父类引用指向子类对象的多态体现，同时python不支持重载。在python中多态的使用不如Java中那么明显，所以python中刻意谈到多态的意义不是特别大。

class Animal:
    def bark(self):
        print('嗷嗷叫！')

class Dog(Animal):
    def bark(self):
        print('汪汪叫！')

class Cat(Animal):
    def bark(self):
        print('喵喵叫！')

class Duck(Animal):
    def bark(self):
        print('嘎嘎叫！')

#实例化
dog = Dog()
cat = Cat()
duck = Duck()
#调用方法
bark(dog)
bark(cat)
bark(duck)

输出
汪汪叫！
喵喵叫！
嘎嘎叫！

上面的案例中 dog 是 Dog 类型的一个实例，同时它也是 Animal 的一个实例。但是反过来不成立。

对于静态语言来说函数 bark 如果需要传入 Animal 类型，则传入的对象必须是 Animal 类型或者它的子类，否则，不能调用 bark。

dog，cat，duck 都是 Animal 类型，但是它们执行 bark 后的输出又各不相同。一个类型多种形态，这就是多态。

对于 python 这样的动态语言来说，则不需要传入的一定是 Animal 类型，只要它具有一个 bark 方法就可以了。

class SomeClass:
    def bark(self):
        print('随便叫！')

sc = SomeClass()
bark(sc)

5.5 私有化

python 中不存在那种只能在仅限从一个对象内部访问的私有变量。

但是，大多数 Python 代码都遵循这样一个约定：以一个下划线开头的名称 (例如 _spam) 应该被当作是 API 的非公有部分 (无论它是函数、方法或是数据成员)。这应当被视为一个实现细节，可能不经通知即加以改变。

class A:
    _arg1 = 'A'

    def _method1(self):
        print('我是私有方法')


a = A()
print(a._arg1)
a._method1()

这种以一个下划线开头的属性可以被类和实例调用。只是在 from xxx import * 时不会被导入。

还有一种定义私有属性的方法是以两个下划线开头的名称（例如__spam)，这种方式定义的私有变量只能在类的内部访问。

class A:
    __arg1 = 'A'
  
    def __method1(self):
        print('我是私有方法')

a = A()
# res = a.__arg1
a.__method1()

AttributeError: 'A' object has no attribute '__method1'

原因：
这种限制访问的原理是，以双下划线开头的属性名(至少带有两个前缀下划线，至多一个后缀下划线)会被改写成 _classname__spam，所以在类外部通过原名称反问不到，但在类的内部使用原名称可以访问。
在方法或者属性前面加上_类名，就可以访问了

a = A()
res = a._A__arg1
print(res)
a._A__method1()