一、类和对象的定义
类是一种抽象的数据类型，它描述了具有相同属性和方法的对象集合。而对象则是类的实例，它具有类定义的属性和方法。
类（class）：是一种自定义的数据类型。
对象（object）：是该类型的一个实例。
《先有类后又对象》
类和对象的语法格式
#类的定义语法格式
class ClassName:
# 类的定义
pass
#对象的定义语法格式
object_name = ClassName()class 是关键字， ClassName 是类的名称，冒号后面的缩进的部分是类的主体。可以包含变量、方法、类变量、类方法等
object_name 是对象的名称， ClassName()
二、类的属性和方法
类的属性指类的特征，方法指类的行为。类的属性和方法定义在类的内部，在实例化后可以通过实例对象或者类本身进行访问和调用。
属性和方法都可以分为类属性和实例属性，类属性指属于类的共享属性，实例属性指属于实例的属性。
lass ClassName:
class_attr = value # 类属性
def __init__(self, arg1, arg2): # 初始化方法，也叫构造方法
self.instance_attr1 = arg1 # 实例属性
self.instance_attr2 = arg2 # 实例属性
@classmethod
def class_method(cls, arg): # 类方法
# 可以访问类属性，不能访问实例属性
cls.class_attr = arg
def instance_method(self, arg): # 实例方法
# 可以访问实例属性和类属性
self.instance_attr1 = arg
ClassName.class_attr = arg
@staticmethod
def static_method(arg): # 静态方法
# 不能访问实例属性和类属性
print(arg)类属性
类属性是定义在类中的变量，用于表示所有实例对象共享的数据，可以通过类本身进行访问和修改。
在Python中，类属性可以通过类名或实例对象来访问，也可以通过类方法或静态方法来访问和修改。
类属性的访问方式
类属性的访问方式有以下三种
- 通过类名访问
class MyClass:
class_attr = "我是类属性"
print(MyClass.class_attr)- 通过实例对象访问
class MyClass:
class_attr = "我是类属性"
obj = MyClass()
print(obj.class_attr)- 通过类方法访问
class MyClass:
class_attr = "我是类属性"
@classmethod
def print_class_attr(cls):
print(cls.class_attr)
MyClass.print_class_attr()类属性的修改方式
类属性的修改方式有以下两种：
- 通过类名直接修改
class MyClass:
class_attr = "我是类属性"
MyClass.class_attr = "我是一个新的类属性"- 通过类方法修改
class MyClass:
class_attr = "I am a class attribute"
@classmethod
def change_class_attr(cls, new_value):
cls.class_attr = new_value
MyClass.change_class_attr("I am a new class attribute")实例属性
实例属性定义在实例对象中的变量，用于表示每个实例对象的数据，只能通过实例对象进行访问和修改。实例属性可以在类的方法中通过 self
在 Python 中，实例属性通常在类的构造函数 __init__
self
self是一个关键字，在Python中用于表示类的实例对象本身。在类定义中，self作为第一个参数传递给类的方法，用于引用该实例对象本身，以便可以访问其属性和方法。当调用类的方法时，实例对象自动传递给self参数，无需手动传递。在类的方法中，通过self来访问实例属性和调用实例方法。
__init__
__init__ 是 Python 类中的一个特殊方法（也叫构造函数），用于在创建对象时进行初始化操作。当创建一个类的实例时，__init__ 方法会自动被调用，用于对该实例进行初始化操作，比如给实例设置一些属性的初始值。__init__ 方法可以接受任意数量的参数，但是第一个参数必须是 self，表示创建的实例对象本身。其他参数可以根据需要自行添加。
例如，
"""定义了一个 Person 类，其中有一个实例属性 name，在构造函数中初始化。
该类还有一个方法 greet，用于向其他人问好，其中 self.name 表示当前实例对象的名字。"""
class Person:
def __init__(self, name):
self.name = name # 定义实例属性 name，初始化为传入的参数 name
def greet(self, other_name):
print(f"你好，{other_name}，我是{self.name}。")
# 创建两个 Person 对象，分别设置他们的名字，然后让他们互相问好。
person1 = Person("张三") # 创建 person1 实例对象，并设置 name 属性为 "张三"
person2 = Person("李四") # 创建 person2 实例对象，并设置 name 属性为 "李四"
person1.greet("李四") #输出结果：你好，李四，我是张三。
person2.greet("张三") #输出结果：你好，张三，我是李四。类方法
类方法指属于类的方法，可以通过类本身进行调用，但是不能访问实例属性，只能访问类属性。
通常使用装饰器@classmethod来定义类方法。类方法的第一个参数是类本身，通常被命名为cls。
类方法可以用于访问和修改类属性，或执行只与类有关的操作。
class MyClass:
class_attr = "I am a class attribute"
@classmethod
def class_method(cls):
print(cls.class_attr)实例方法
实例方法指属于实例对象的方法，只能通过实例对象进行调用，可以访问实例属性和类属性。
在定义实例方法时，第一个参数通常是 self，它表示实例本身。
#实例方法的语法格式
class MyClass:
def instance_method(self, arg1, arg2, ...):
# 方法体
"""self 表示实例本身，arg1、arg2 等参数为方法的输入参数，可以根据需要添加或省略。"""
"""调用实例方法时，通常不需要传入 self 参数，Python 会自动将实例对象传递给该参数。"""
my_obj = MyClass()
my_obj.instance_method(arg1, arg2, ...)
"""调用时，Python 会自动将 my_obj 传递给 self 参数，
同时将 arg1、arg2 等参数传递给 arg1、arg2 等方法参数。"""静态方法
静态方法是一种不需要实例化类就能够被调用的方法。与实例方法和类方法不同，静态方法没有访问实例或类的参数。
在 Python 中，可以使用 @staticmethod
class MyClass:
@staticmethod
def multiply(a, b):
return a * b
print(MyClass.multiply(3, 4)) # 输出 12三、类和继承
类和继承是面向对象编程的两个核心概念，类用来封装数据和方法，继承则允许一个类继承另一个类的特性。
类的继承可以帮助我们避免重复代码的编写，也可以让我们创建更加抽象和通用的类，同时也可以方便地实现多态。
在 Python 中，通过在定义类时指定基类（父类）来实现继承。子类会自动拥有父类的属性和方法，并且可以添加新的属性和方法或者修改继承自父类的属性和方法。
"""假设我们要写一个学生类（Student），它有姓名（name）、学号（id）、年龄（age）等属性，
以及查看个人信息（get_info）、修改个人信息（update_info）等方法。"""
#定义这个类
class Student:
def __init__(self, name, id, age):
self.name = name
self.id = id
self.age = age
def get_info(self):
print(f"姓名：{self.name}，学号：{self.id}，年龄：{self.age}")
def update_info(self, name, id, age):
self.name = name
self.id = id
self.age = age
print("信息已更新！")
#创建一个学生实例来使用这个类
# 创建一个学生实例
stu = Student("张三", "1001", 18)
# 查看学生信息
stu.get_info() # 姓名：张三，学号：1001，年龄：18
# 修改学生信息
stu.update_info("李四", "1002", 19)
# 再次查看学生信息
stu.get_info() # 姓名：李四，学号：1002，年龄：19四、多重继承
多重继承是指一个类可以从多个父类中继承属性和方法。在 Python 中，可以通过在类定义中指定多个父类来实现多重继承。
多重继承的语法为：class 子类名(父类1, 父类2, …)。
"""
假设我们有三个类：Person、Father和Mother。Father和Mother都继承自Person类。
现在我们要创建一个Child类，它同时继承了Father和Mother类。
"""
class Person:
def __init__(self, name):
self.name = name
def greet(self):
print(f"Hello, my name is {self.name}")
class Father(Person):
def __init__(self, name, age):
super().__init__(name)
self.age = age
def sing(self):
print("I'm singing a song")
class Mother(Person):
def __init__(self, name, hobby):
super().__init__(name)
self.hobby = hobby
def dance(self):
print("I'm dancing")
class Child(Father, Mother):
def __init__(self, name, age, hobby):
Father.__init__(self, name, age)
Mother.__init__(self, name, hobby)
def play(self):
print("I'm playing with my friends")在这个例子中，Child类同时继承了Father和Mother类，因此它有Father和Mother类中的所有方法和属性。注意，在Child类的构造函数中，我们分别调用了Father和Mother类的构造函数，以便将必要的属性传递给它们。
五、练习题
定义一个登录的测试用例类LoginCase，每一个实例对象都是一个登陆测试用例属性:用例名称预期结果实际结果(初始化时不确定值哦)
方法:运行用例说明:有2个参数:用户名和密码，能够登录成功的用户名:py58.密码:666666.通过用户名和密码正确与否来判断，是否登录成功，并返回实际结果，
ps:可以在用例内部考虑处理不符合的情况哦:密码长度不是6位/密码不正确/用户名不正确等。。
获取用例比对结果(比对预期结果和实际结果是否相等，并输出成功or失败)实例化2个测试用例，并运行用例(调用方法)，呈现用例结果(调用方法)可以向自己发送文件或转发消息
class LoginCase:
def __init__(self, name, expected,actual):
self.name = name
self.expected = expected
self.actual = None
def run(self, username, passwd):
if len(passwd) != 6:
self.actual = "密码长度不是6位"
elif username != "py58" :
self.actual = "用户名不正确"
elif passwd != "666666":
self.actual= "密码不正确"
elif username == "py58" and passwd == "666666":
self.actual="登录成功"
else:
print("异常")
return self.actual==self.expected
case={"name":"Test Case 1",
"expected":"登录成功",
"username":"py58",
"passwd":"666666"}
a=LoginCase(case["name"],case["expected"],None)
print(a.run(case["username"],case["passwd"]))
