Python自动化测试之类、对象、属性与方法知识讲解

一、前言

小伙伴们大家好呀，笔者呢又给大家带来了一篇文章，这篇文章主要是讲解python中类、对象、属性与方法的知识点内容，废话不多说我们直接开始吧。

 

二、知识合集

2.1 类与对象基础

2.1.1 类和对象的概述

类：类是具备共同特征和共同行为的事物统称，物以类聚，人以群分，在这里就能够很好的体现出来，鸡、鸭我们可以划分到家禽类，小猫小狗也可以划到宠物类，兰博基尼、布加迪威龙我们可以划分到跑车类等等，只要具有相同特征或行为的都可以划分到一个类中。

类往往是很广泛的，例如跑车类，会有很多很多的跑车，那么两个跑车，一个跑车是否可以成为类呢，其实也是可以的，两个跑车具备共同特征和特性，我们可以称之为类，只有一个跑车的时候也可以称之为类，可能是奇葩类、也可能是传奇类，比如传闻中的：黄金跑车，它已经达到了世界之最，具有唯一或特例之处，也可以单独的成为一个类，我们把这种情况称之为单例。

 对象：对象是一类事务中的一个成员，一个单独的个体，对象又被称为实例。说的通俗易懂些，对象就是类中的一个成员，跑车类中有很多跑车，那么其中的某一个车就是一个成员，也就是一个对象，一个实例。

2.1.2 一个简单的类和对象

一个简单的类和对象如下所示：

"""
格式为：
class Car():
	类主体
"""
class Car():
    pass

print(Car)  # 类
print(Car())  # 对象

2.1.3 类的命名规范

类的命名与变量、函数、模块、包不同，通常而言变量、函数等我们采用蛇形命名，又称下划线命名，而类主要是采用驼峰命名：

"""
蛇形命名，单词使用下划线拼接，全部为小写
"""
add_number
str_add
number_add_no1_with

"""
驼峰命名，单词拼接，首字母大写
"""
class AutoCar:
    pass

class NumberAdd:
    pass

class CaseTest:
    pass

2.1.4 类和对象的另一种表达形式

除了上述的打印，我们也可以把类、对象赋值给一个变量，然后通过打印变量得到这个类或对象，不仅可以赋值给一个，还可以赋值给不同的多个变量，而且是独立的，对象从内存地址不同可以看出区别：

class Car:
    pass

demo1_class = Car
demo2_class = Car()
demo3_class = Car()
print(demo1_class)
print(demo2_class)
print(demo3_class)

2.2 属性与方法讲解

2.2.1 类属性

类是具备共同特征和共同行为的事物统称，属性就表示类或对象的某种特征，而一个类所具有的特征，我们把它称之为类属性，好比汽车类的共同特征都有方向盘、都有车轮等等，那么这些就是类属性：

既然拥有类属性，那么我们也可以获取一个类属性，通过类名.属性进行获取：

class Car:
    """类属性"""
    steering_wheel = True  # 方向盘
    tyre_number = 4  # 车轮个数
    engine = True  # 发动机
    material = ["铁", "橡胶", "玻璃", "塑料", "铝合金"]  # 材料

"""获取类属性"""
print(Car.steering_wheel)
print(Car.tyre_number)
print(Car.engine)
print(Car.material)

类属性与函数相同，都是独立的，与全局变量互不影响：

class Car:
    tyre_number = 4  # 车轮个数

tyre_number = 5
print(Car.tyre_number)
print(tyre_number)

我们也可以通过对象去获取类属性，除此之外我们还可以修改一个类属性，但我们修改类属性只能通过类来修改，不能通过对象进行修改：

class Car:
    tyre_number = 4  # 车轮个数

my_car = Car()
print(my_car.tyre_number)


"""修改类属性"""
Car.tyre_number = 3
print(f"修改后的轮子数量是:{Car.tyre_number}")
"""新增属性"""
Car.steering_wheel = True
print(Car.steering_wheel)

2.2.2 类属性的定义

类属性除了在类中进行定义，也可以在全局中进行定义：

class Car:
    pass


# 全局中定义类属性
Car.wheel = True
print(Car.wheel)

2.2.3 实例方法调用

方法就是类的行为，使用函数的语法，方法就是一个函数，方法有个固定的参数self，方法可以自定义，self代表实例、对象。 如果我想调用一个方法，如下代码所示，这种形式我们也称之为实例方法：

"""
实例方法：通过对象.方法()进行调用
"""
class Car:
    """方法"""
    def drive(self):
        print("滴滴，开始开车")


# 调用方法
my_car = Car()
my_car.drive()

2.2.4 类方法调用

类方法通过类.方法()进行调用，一个类方法的表示是一个装饰器的方式表示为@classmethod，self替换为cls，则表示为一个类方法：

"""
类方法：通过类.方法()进行调用
"""
class Car:
    pass

    @classmethod
    def color(cls):
        my_color = "我是红色，一个类方法"
        return my_color


print(Car.color())

2.2.5 静态方法调用

静态方法与类方法类似，静态方法也需要有装饰器，静态方法没有固定参数，静态方法的装饰器表示为@staticmethod，静态方法类和实例都可以调用，静态方法和类、对象没有直接性的关系，可以移出类的管理进行定义：

class Car:
    pass


    """静态方法"""
    @staticmethod
    def color():
        color = "绿色，我是静态方法"
        return color


print(Car.color())

2.2.6 方法继承

方法是可以继承的，好比儿子继承了父亲的财产一样，那么可以随意使用父亲的财产，A类如果继承了B类，那么同样的A类可以使用B类的所有方法、对象：

class Car:

    def driver(self):
        print("开车")
    def stop(self):
        print("停车")


"""
继承
Car:父类
SuperCar:子类
子类可以使用父类所有的属性和方法
"""
class SuperCar(Car):
    """所有Car的属性和行为，SuperCar全部继承"""
    pass


Ferrari = SuperCar()
Ferrari.driver()

2.2.7 方法重写

当子类和父类用同名方法时，优先使用自己的，我们把这种方式称之为重写：

class Car:

    def driver(self):
        print("开车")
    def stop(self):
        print("停车")


"""
继承
Car:父类
SuperCar:子类
子类可以使用父类所有的属性和方法
"""
class SuperCar(Car):
    """所有Car的属性和行为，SuperCar全部继承"""
    def driver(self):
        print("跑车开起来飞快")



Ferrari = SuperCar()
Ferrari.driver()

2.2.8 超级重写

当子类和父类用同名方法时，优先会使用自身的，我们也可以拥有自身的，同时拥有父类的，这种情况我们称之为超级重写：

class Car:

    def driver(self):
        print("开车")
    def stop(self):
        print("停车")


"""
继承
Car:父类
SuperCar:子类
子类可以使用父类所有的属性和方法
"""
class SuperCar(Car):
    """所有Car的属性和行为，SuperCar全部继承"""
    def driver(self):
        """超级重写，super()代表父类"""
        super().driver()
        print("跑车开起来飞快")



Ferrari = SuperCar()
Ferrari.driver()

2.3 对象初始化与实例属性讲解

2.3.1 对象初始化

一个对象从无到有就是一个生产过程，生产后得到一个对象，我们把这种情况称之为对象的初始化，而初始化后的对象会自动调用类下面的魔法函数 init，我们在打印对象时执行了魔法函数中的代码段，函数中的self是代表一个对象产生之前的标记，而产生之后如下代码所示就赋值给了object1：

class Car:
    tyre_number = 4  # 车轮个数
    def __init__(self):
        print("I love you")


object1 = Car()  # 我们把Car()的产生称之为对象初始化

print(object1)

init函数与普通的函数不同，init函数不能有返回值，默认为None不可为其他，否则会报错：

class Car:
    wheel = True

    def __init__(self):
        self.wheel = True
        return "a"


print(Car().wheel)

2.3.2 类属性与实例属性

首先要明确一个概念，实例属性就是对象属性，对象就是实例，实例属性表示这个成员，物体个人具备的属性、特有属性，而类属性是共有属性，大家都有的特征。

一个实例属性是这样的：

class Car:
    tyre_number = 4  # 类属性
    def __init__(self):
        """实例属性，self.对象属性"""
        self.color = "红色"  # 实例属性
        self.price = "190w"

如果类属性和实例属性的名字相同，那么实例属性会优先使用自己的，我们也可以使用位置参数的方式，来提高便捷性：

class Car:
    tyre_number = 4  # 车轮个数
    def __init__(self, car_color, car_price):
        """实例属性，self.对象属性"""
        self.color = car_color
        self.price = car_price


my_car = Car("黄金色", "3500w")

print(f"这台车的颜色是{my_car.color}")
print(f"这台车的价格是{my_car.price}")

2.4 对象赋值

对象与类不同，对象的赋值是不相等的，而类的赋值是相等的，如下代码所示，类赋值给了3个变量，是完全相同的内存地址，证明这3个变量都代表同1个类，但对象赋值均是在不同的内存地址，故此可以得知对象所赋值的三个变量均是不同的对象：

class Car:
    pass


my_car1 = Car
my_car2 = Car
my_car3 = Car
my_obj1_car = Car()
my_obj2_car = Car()
my_obj3_car = Car()

print(id(my_car1))
print(id(my_car2))
print(id(my_car3))
print(my_obj1_car)
print(my_obj2_car)
print(my_obj3_car)

2.4.1 类属性与实例属性的访问

如果我们要访问一个类属性，可以通过类或对象去获取：

class Car:
    wheel = True


print(Car.wheel)
print(Car().wheel)

2.5 类和对象的作用

类、对象和函数相似，调用来调用去，为何我们需要学习类和对象，好处在哪里，其实本质上来说差别不大，明显的地方就在于，类更方便管理，并且在调用时更加简洁了，我们能够接受定义的复杂，但不能接受调用的复杂，因为定义只有一次，而调用有无数次，如果一个函数中有100个形式参数，那么我们调用函数时就需要传100个实际参数，但在类中我们可以一口气定义好100个实例属性，从而简化调用的流程，可以在调用时少传参数甚至不传参数，虽然函数也可以写成默认参数和关键字参数，但阅读性不高，并不会像类一样清晰、直接，这就是我们使用类和对象的最直接的原因。

类和对象只不过是比函数的调用流程更加简洁化了，这并不意味着我们在真实的项目中一定要用类和对象，相同的功能我们同样可以使用函数实现，小到一个脚本，大到一个测试框架，类和对象所减少的代码量不会有很大差距，从效率来讲，类和对象的方式和函数无差别，但我们仍然有必要学习，因为能够更加方便的调用，理解成本也会相对降低。

三、总结

这篇文章的分享就到这里了哟，喜欢的小伙伴可以点赞收藏评论哟，希望这篇文章可以帮助到正在学习python自动化测试的小伙伴哟。