黑马python第二阶段第一章

类

定义和调用

# 定义一个类
class Dog:
    # 成员变量，类的属性
    breed = "Golden Retriever"
    
    # 成员方法，类的行为
    def bark(self, sound):
        # 通过 self 访问成员变量，访问类内的成员变量时需要加self，外部参数不需要
        print(f"The {self.breed} says {sound}")

# 创建类的实例
my_dog = Dog()

# 调用成员方法，self不需要传
my_dog.bark("Woof!")

构造方法

# 定义一个类
class Dog:
    # 构造方法
    def __init__(self, breed, age):
        # 使用 self 初始化成员变量
        self.breed = breed
        self.age = age
    
    # 成员方法
    def display_info(self):
        print(f"This dog is a {self.breed} and is {self.age} years old.")

# 创建类的实例，并传递参数给构造方法
my_dog = Dog("Golden Retriever", 3)

# 调用成员方法
my_dog.display_info()

其他类内置方法（魔术方法）

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"{self.name} is {self.age} years old"

    def __lt__(self, other):
        return self.age < other.age

    def __le__(self, other):
        return self.age <= other.age

    def __eq__(self, other):
        return self.age == other.age

# 创建两个 Dog 对象
dog1 = Dog("Buddy", 5)
dog2 = Dog("Max", 3)

# 使用 __str__ 方法
print(dog1)  # 输出: Buddy is 5 years old

# 使用 __lt__ 方法
print(dog1 < dog2)  # 输出: False

# 使用 __le__ 方法
print(dog1 <= dog2)  # 输出: False

# 使用 __eq__ 方法
print(dog1 == dog2)  # 输出: False

当没有使用__eq__方法时若使用==，则对比的是内存地址。

私有成员

class Dog:
    def __init__(self, name, age):
        self.name = name  # 公有成员变量
        self.__age = age  # 私有成员变量

    def display_info(self):
        # 类内部可以访问私有成员变量
        print(f"{self.name} is {self.__age} years old")

    def __private_method(self):
        # 私有方法
        print("This is a private method")

    def public_method(self):
        # 公有方法可以调用私有方法
        self.__private_method()

# 创建 Dog 对象
my_dog = Dog("Buddy", 5)

# 访问公有成员变量和方法
print(my_dog.name)  # 输出: Buddy
my_dog.display_info()  # 输出: Buddy is 5 years old

# 尝试访问私有成员变量（会报错）
# print(my_dog.__age)  # AttributeError: 'Dog' object has no attribute '__age'

# 尝试调用私有方法（会报错）
# my_dog.__private_method()  # AttributeError: 'Dog' object has no attribute '__private_method'

# 通过公有方法调用私有方法
my_dog.public_method()  # 输出: This is a private method

私有方法可以调用公开变量，公开方法也可以调用私有变量。在类的内部，无论是私有方法还是公开方法，都可以访问类的所有成员变量。这是因为访问权限的限制主要是针对类的外部，而不是类的内部。

继承

# 第一个父类
class A:
    def method(self):
        return "Method from class A"

# 第二个父类
class B:
    def method(self):
        return "Method from class B"

# 子类继承多个父类
class C(A, B):
# 通常用作占位符，用于在语法上需要语句但不需要执行任何操作的地方。
    pass

# 创建子类对象
my_object = C()
print(my_object.method())  # 输出: Method from class A

当两个类中有相同的成员或方法名时，左边的优先级更高。

复写

# 父类
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return f"{self.name} makes a sound"

# 子类
class Dog(Animal):
    def __init__(self, name, breed):
        # 使用 super() 调用父类的构造方法
        super().__init__(name)
        self.breed = breed

    def speak(self):
        # 复写父类的 speak 方法
        # 使用 super() 调用父类的 speak 方法
        parent_speak = super().speak()
        # 使用父类名调用父类的 speak 方法（效果与 super() 相同）
        parent_speak_alt = Animal.speak(self)
        return f"{parent_speak} and {self.name} barks (breed: {self.breed})"

# 创建子类对象
my_dog = Dog("Buddy", "Golden Retriever")

# 调用复写后的方法
print(my_dog.speak())
# 输出: Buddy makes a sound and Buddy barks (breed: Golden Retriever)

类型注解

# 变量的类型注解
name: str = "Alice"
age: int = 25
# 注释中的注解也可以被IDE识别，但如果标错了也不会报错
height = 170  # type: int

# 函数的类型注解
def greet(name: str) -> str:
    return f"Hello, {name}"

def add(a: int, b: int) -> int:
    return a + b

# 类型注解的灵活性
def multiply(a: int, b: int) -> int:
    return a * b

# 调用函数
print(greet("Bob"))  # 输出: Hello, Bob
print(add(3, 5))     # 输出: 8

# 即使传入的参数类型与注解不匹配，也不会报错
result = multiply(3.5, 2.5)  # 输出: 8.75
print(result)

总结

• 类型注解不会影响运行时的行为。
• 静态类型检查工具：可以在开发阶段发现类型不匹配的问题，但不会影响代码运行。
• Python的动态特性：Python允许在运行时传入任何类型的参数，只要操作是合法的。
  如果希望强制类型检查，可以使用静态类型检查工具（如 mypy），或者在运行时手动检查类型（例如使用 isinstance）。

联合类型注解

from typing import Union

# 变量的联合类型注解
value: Union[int, str] = 42
value = "hello"

# 函数的联合类型注解
def process_value(input_value: Union[int, str]) -> Union[int, str]:
    if isinstance(input_value, int):
        return input_value * 2
    elif isinstance(input_value, str):
        return input_value.upper()

# 使用示例
print(process_value(10))      # 输出: 20
print(process_value("hello")) # 输出: HELLO

多态和抽象类

1. 多态

• 同一行为，不同对象表现不同。

2. 抽象类

• 包含未实现的方法（pass），用于定义标准，子类必须实现。

3. 作用

• 多态：灵活调用。
• 抽象类：规范设计。