python-测试相关基础知识-补充

1.面向对象

1.1 基础概念

面向函数的编程方式

1. 把要完成的需求所有步骤按顺序逐步实现；
2. 根据开发需求，可以把需求拆分成多个具有独立功能的函数；
3. 实现需求代码就是顺序调用不同功能的函数；

面向对象概念

1. 在执行某个需求之前，先确定职责（方法）；
2. 根据职责确定不同的对象，在对象内部封装不同的方法；
3. 实现需求就是顺序的让不同对象调用不同的方法；

面向对象的核心概念：类和对象

• 类：对一群具有相同属性和特征的事务的统称，抽象且不能直接使用；
• 对象：由类创建的具体的存在，可直接使用

类和对象的关系

• 类是模板，对象根据这个模板被创建出来，先有类再有对象；
• 根据一个类可以创建多个对象；
• 不同对象的属性可以不同；

类的设计三要素

1. 类名：这类事物的名称；
2. 属性：这类事物的特征；
3. 方法：这类事物的行为；

1.2 python 面向对象关键字

在python中定义一个类注意

操作	说明
类名：	类名应该是有意义的，并且能够反映类的功能。按照惯例，类名通常以大写字母开头。class：类名
初始化方法：	__init__方法是一个特殊的方法，它在创建类的新实例时被调用。你可以在这个方法中定义必要的初始化工作。def __init__(self):
属性：	属性是类的数据成员，可以是公共的或私有的。在Python中，以双下划线开头的名称被视为私有的。self.__name = name
方法：	类是行为的封装，因此你应该在类中定义必要的方法。和属性一样，方法也可以是公共的或私有的。def get_name(self):
继承：	你可以通过继承来创建一个类，继承类会继承父类的所有属性和方法。在Python中，你可以使用extends关键字来实现继承。class Dog(Animal): 3w2qq,l.k;
封装：	在Python中，你可以使用双下划线开头的方式将属性或方法标记为私有的，这样可以保护它们不被外部访问或修改。
多态：	多态是面向对象编程的一个重要特性，它允许你使用父类引用来指向子类对象。在Python中，你可以通过定义特殊方法__instancecheck__和__subclasscheck__来实现多态。
异常处理：	你应该在代码中正确地处理可能出现的异常。在Python中，你可以使用try-except语句块来处理异常。
文档字符串：	你应该为类、方法和属性提供有意义的文档字符串，以便其他开发人员理解它们的功能和用法。
类变量：	类变量是在所有实例之间共享的变量，它们可以被所有实例访问和修改。在Python中，你可以使用class关键字来定义类变量。

继承

# 定义一个父类  
class Animal:  
    def __init__(self, name):  
        self.name = name  
  
    def speak(self):  
        print("An animal speaks.")  
  
# 定义一个子类，继承自Animal类  
class Dog(Animal):  
    def __init__(self, name, breed):  
        super().__init__(name)  
        self.breed = breed  
  
    def bark(self):  
        print("Woof!")  
  
# 创建一个Dog对象  
my_dog = Dog("Buddy", "Golden Retriever")  
  
# 访问父类的属性和方法  
print(my_dog.name)  # 输出：Buddy  
my_dog.speak()  # 输出：An animal speaks.  
  
# 访问子类的属性和方法  
print(my_dog.breed)  # 输出：Golden Retriever  
my_dog.bark()  # 输出：Woof!

1.2.1 class关键字

类和方法的定义说明

⽅法的定义格式和之前学习过的函数⼏乎⼀样 ;
区别在于第⼀个参数必须是 self

格式

class 类名:
	def 方法1(self,参数列表)：
		pass
		

案例1：猫类的定义

class cat:
	def eat(self):
		print("汤姆爱吃鱼")
	def drink(self):
		print("汤姆爱喝水")

类的使用-创建对象

1. 实例------通过类创建出来的对象叫做类的实例；
2. 实例化------创建对象的动作叫做实例化 。

# 创建 lazy_cat 对象
lazy_cat = cat()
# 调用对象的 eat 方法
lazy_cat.eat()
# 调用对象的 drink 方法
lazy_cat.drink()

self参数的使用说明

• 在类的封装方法内部，self就表示调用方法的自己对象；
• 调用方法时，不需要为self传递参数；
• 方法内部可以通过self.来访问对象的属性；
• 在方法内部可以通过 self. 调⽤对象的⽅法；
• 在类的外部，通过 对象名. 访问对象的属性和⽅法

# 定义 cat 类
class cat:
	def set_name(self, name):
		# 给 cat 类添加一个属性 name
		self.name = name
	def eat(self):
		print("%s 爱吃鱼" % self.name)
	def drink(self):
		print("%s 爱喝水" % self.name)

1.2.2 __init__初始化方法

概念

__init__就是类的初始化方法，是对象的内置方法； 当用类名创建对象时，会自动执⾏以下操作：

1. 为对象在内存中分配空间 —创建对象；
2. 系统自动调用方法（init）

案例：cat 类增加__init__方法

# 定义 cat 类
class cat:
	# 初始化方法
	def __init__(self):
		print("初始化方法")
	def eat(self):
		print("小猫爱吃鱼")
	def drink(self):
		print("小猫爱喝水")
		
# 创建对象的同时，初始化方法被自动调用
lazy_cat = cat()

案例：带有参数的初始化方法

# 定义 cat 类
class cat:
	# 带有参数初始化方法
	def __init__(self, name):
		self.name = name
		print("%s 的带有参数的初始化方法" % self.name)
	def eat(self):
		print("%s 爱吃鱼" % self.name)
	def drink(self):
		print("%s 爱喝水" % self.name)
		
lazy_cat = cat("tom")

初始化方法的缺省参数

# 定义 cat 类
class cat:
	# 带有缺省参数初始化方法
	def __init__(self, name = "猫"):
		self.name = name
		print("%s 的带有参数的初始化方法" % self.name)
	def eat(self):
		print("%s 爱吃鱼" % self.name)
	def drink(self):
		print("%s 爱喝水" % self.name)
		
# 没有指定 name 的值，此时 name 等于缺省值
lazy_cat = cat()

1.2.3 __del__销毁方法

概念

• __del__方式只能有一个参数 self；
• 当对象在内存中被销毁的时候，__del__方法被系统自动调用；
• 当使⽤ 类名() 创建对象时，为对象分配完空间后，⾃动调⽤ init ⽅法；
• 当⼀个对象被从内存中销毁前，会⾃动调⽤ del ⽅法 ；
• ⼀个对象的 del ⽅法⼀旦被调⽤，对象的生命周期结束；

注意

• del 对象在内存中销毁的时候自动调用del
• 不要理解成调用del是把对象从内存中删除了
• 对象即使没有del,同样会被销毁
• 当对象从内存中销毁的时候,有机会能执行一些代码

class cat:
	def __init__(self, name = "tom"):
		self.name = name
	def show_name