Python---类

创建和使用类

使用关键字class来定义一个类，然后使用关键字def来定义方法（也称为函数），并使用关键字self作为第一个参数来引用对象自身。在方法内部，可以使用关键字self来访问对象的属性。

定义属性：

• 在类的初始化方法__init__()中使用self关键字来定义属性。例如：self.name = “Tom"表示定义了一个名为name的属性，并将其初始值设为"Tom”。
• 在类定义中直接定义属性。例如：age = 18表示定义了一个名为age的属性，并将其初始值设为18。

定义方法：

• 使用def关键字定义方法，并在方法内部使用self关键字表示当前对象。例如：def speak(self):表示定义了一个名为speak的方法，其中self表示当前对象。
• 在方法内部可以使用self.属性名的方式访问当前对象的属性，或使用self.方法名()的方式调用当前对象的其他方法。

这段代码定义了一个名为__init__的特殊方法，它是Python中的构造函数。构造函数在创建一个新对象时被调用，并用于初始化对象的属性。

该构造函数接受一个名为name的参数，并将其赋值给对象的name属性。这意味着在创建新对象时，可以传入一个名字，并将其保存在对象的name属性中。
my_dog.name，在这里Python先找到实例my_dog，再查找与这个实例相关联的属性name。根据Dog类创建实例后，就可以使用句点表示法来调用Dog类中定义的任何方法，如my_dog.sit()

修改属性的值

直接修改属性的值

如果你有一个类的实例，并且想要修改它的某个属性，可以直接使用句点表示法来访问并设置属性的新值。

class Car():
    def __init__(self,make,model,year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0 # 默认里程数
my_car = Car("audi",'A6',2023)
print(f"My car's odometer_reading is {my_car.odometer_reading} miles")
#直接修改属性值
my_car.odometer_reading = 23
print(f"My car's odometer_reading is {my_car.odometer_reading} miles")

通过方法修改属性值

可以定义方法来更新属性的值，这样可以在修改属性时执行一些额外的操作，如验证新值的有效性

class Car():
    def __init__(self,make,model,year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0 # 默认里程数
    def update_odemeter(self,mileage): #修改属性前检查指定的读数是否合理
        """
        将里程表读数设置为指定值
        禁止将里程表读数往回调
        """
        if mileage >= self.odometer_reading :
            self.odometer_reading = mileage
        else:
            print("you can't roll back an odometer!")
my_car = Car("audi",'A6',2023)
my_car.update_odemeter(23)
print(f"My car's odometer_reading is {my_car.odometer_reading} miles")

通过方法增加属性值

我们有时候希望增加属性的值而不是直接设置新的值，我们可以定义方法来增加属性的值

class Car():
    def __init__(self,make,model,year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0 # 默认里程数
    def increment_odometer(self,miles):
        """ 将里程表读数增加指定的量"""
        self.odometer_reading += miles
my_car = Car("audi",'A6',2023)
my_car.increment_odometer(100)
print(f"My car's odometer_reading is {my_car.odometer_reading} miles")

修改私有属性的值

如果属性被定义为私有的（通常使用双下划线__前缀），那么直接访问或修改这些属性是不被鼓励的。在这种情况下，可以通过定义公共的方法来间接修改私有属性。

class Car():
    def __init__(self,make,model,year):
        self.make = make
        self.model = model
        self.year = year
        self.__odometer_reading = 0 # 私有属性
    def get_odemeter_reading(self):
        return self.__odometer_reading
    def set_odemeter_reading(self,mileage): #修改属性前检查指定的读数是否合理
        """
        将里程表读数设置为指定值
        禁止将里程表读数往回调
        """
        if mileage >= self.__odometer_reading :
            self.__odometer_reading = mileage
        else:
            print("you can't roll back an odometer!")
my_car = Car("audi",'A6',2023)
print(f"My car's odometer_reading is {my_car.__odometer_reading} miles")
#使用公共方法修改私有属性
my_car.set_odemeter_reading(23)
print(f"My car's odometer_reading is {my_car.__odometer_reading} miles")

继承

一个类继承另一个类时，它将获得另一个类的所有属性和方法，原有的类称为父类，而新类称为子类，子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。

创建子类时，父类必须包含在当前文件中，且位于子类前面，定义子类时，必须在括号内指定父类的名称
创建子类的实例时，Python首先要给父类的所有属性进行赋值。

给子类定义属性和方法

在下述代码中，首先定义了一个父类，它有一个属性和一个方法，然后定义了一个子类，它继承了父类，并在__init__方法中使用super()函数调用父类的__init__方法来初始化父类的属性，同时，子类还定义了一个自己特有的属性和方法，最后，分别创建了一个父类对象和一个子类对象，并调用它们的方法来验证属性和方法的定义是否成功。

class ParentClass:
    def __init__(self, parent_attr):
        self.parent_attr = parent_attr
    def parent_method(self):
        print("This is a parent method")

class ChildClass(ParentClass):
    def __init__(self, parent_attr, child_attr):
        #调用父类的__init__方法来初始化父类的属性
        super().__init__(parent_attr)
        self.child_attr = child_attr
    def child_method(self):
        print("This is a child method")

# 创建一个父类对象
parent_obj = ParentClass("Parent Attribute")
parent_obj.parent_method()
# 创建一个子类对象
child_obj = ChildClass("Parent Attribute", "Child Attribute")
child_obj.parent_method()
child_obj.child_method()

重写父类的方法

在Python中，可以通过定义一个与父类同名的方法来重写父类的方法。这样，在子类的实例中调用同名的方法时，会执行子类中的方法而不是父类中的方法。

class BaseClass:
    def greet(self):
        print("Hello from BaseClass")

class DerivedClass(BaseClass):
    def greet(self):
        print("Hello from DerivedClass")
        
# 创建子类对象
obj = DerivedClass()
# 调用重写的方法
obj.greet()
#输出结果为 Hello from DerivedClass

将实例用作属性

在Python中，我们可以将一个实例对象作为另一个类的属性。这样可以实现类的组合和复合的关系。

class Address:
    def __init__(self, street, city, state, zip_code):
        self.street = street
        self.city = city
        self.state = state
        self.zip_code = zip_code

    def full_address(self):
        return f"{self.street}, {self.city}, {self.state} {self.zip_code}"

class Person:
    def __init__(self, name, age, address):
        self.name = name
        self.age = age
        #address属性是一个Address类的实例对象
        self.address = address
        

# 创建地址对象
address = Address("123 Main St", "New York", "NY", "10001")

# 创建人物对象，并将地址对象作为属性
person = Person("Alice", 25, address)

# 打印人物的信息和地址信息
print(f"Name: {person.name}")
print(f"Age: {person.age}")
print(f"Address: {person.address.full_address()}")

导入类

一开始应让代码结构尽可能简单，先在一个文件中完成所有工作，确定一切都能正确运行后，再将类移到独立的模块中。

from module_name import Myclass
#导入整个模块，再使用句点表示法访问需要的类
import module_name
module_name.Myclass