python-基本内容

一、函数定义与测试

def print_hi(name):  # 定义函数print_hi，参数是name
    print(f"Hi, {name}")  # 函数功能：打印"Hi, 传入的参数值"
    
if __name__ == '__main__':  # 判断当前文件是否是"直接运行"
    print_hi('PyCharm')  # 如果是直接运行，就调用函数，传入实参'PyCharm'

name 是 Python 的内置变量：
当直接运行这个文件时，name 的值会变成 ‘main’，所以这部分代码会执行；当这个文件被作为模块导入到其他文件时，name 会变成文件名，这部分代码就不会执行。可以用来测试

二、变量：动态类型的灵活使用

Python 是动态类型语言，变量类型无需显式声明，赋值时自动确定类型。

def test_variable():
    x = 1  # int型（Python3中无大小限制）
    print(x)
    
    x = 'aaa'  # str型（字符串）
    print(x)
    
    x = 1.5  # float型（浮点数）
    print(x)
    
    x = True  # bool型（仅True/False两个值）
    print(x)
    
    x = None  # None型（表示空值，非0/空字符串）
    print(x)

三、条件语句：if-elif-else 分支逻辑

通过if-elif-else实现多分支条件判断，匹配到首个满足的分支后执行并跳出。

def test_ifelse():
    x = 1
    if x == 1:
        print('x is 1')
    elif x == 2:
        print('x is 2')
    else:
        print('x is not 1 or 2')

四、匹配语句：match-case（替代 switch）

Python 3.10 + 新增match-case语法，替代其他语言的switch，支持模式匹配。

def test_switch():
    x = 1
    match x:
        case 2:
            return 'x is 2'
        case 1:
            return 'x is 1'
        case 1:  # 前面已匹配，此分支不会执行
            return 'x is 1'
        case _:  # 通配符，匹配所有未覆盖的情况
            return 'x is not 1 or 2'

五、for 循环：遍历可迭代对象

for循环用于遍历序列、集合等可迭代对象，常用range()生成整数序列（左闭右开区间）。

def test_for():
    # range(3)生成0、1、2
    for i in range(3):
        print(i)

六、while 循环：条件驱动的循环

while循环在条件为True时持续执行，需手动控制循环终止条件（避免无限循环）。

def test_while():
    i = 0
    # 条件i < 3为真时执行循环体
    while i < 3:
        print(i)
        i += 1  # 控制循环次数

python-面向对象的编程

一、引入类的概念

class Dog:
    def __init__(self, name, age):
        self.name=name
        self.age=age
    def info(self):         # 方法：显示动物信息（封装）
        print(f"{self.name} ({self.age} 岁)")
    def speak(self):
        print("汪汪！")
        
        
if __name__ == '__main__':
    dog = Dog('小黄','2')
    dog.info()

__init__是类的构造方法（初始化方法），创建对象时会自动执行。
self代表当前创建的对象本身，必须作为第一个参数；name和age是创建对象时需要传入的参数。

二、引入类的继承

# 定义一个基类：动物
class Animal(ABC):
    def __init__(self, name, age):
        self.name = name  # 实例变量：名字
        self.age = age  # 实例变量：年龄

    @abstractmethod  # 抽象方法装饰器
    def speak(self):  # 方法：动物叫声（多态的基础）
        pass  # 不需要具体实现

    def info(self):  # 方法：显示动物信息（封装）
        print(f"{self.name} ({self.age} 岁)")


class Dog(Animal):
    def __init__(self, name, age):
        super().__init__(name, age)
        self.name=name
        self.age=age 
    def speak(self):    # 方法重写（多态）
        print("汪汪！")
        

if __name__ == '__main__':
    dog = Dog('小黄','2')
    dog.info()
    dog.speak()

ABC 和 abstractmethod 是 Python 中实现抽象类的核心工具。ABC让普通类变成抽象类，抽象类无法直接实例化，只能被继承;@abstractmethod标记抽象方法，强制子类必须实现该方法，否则子类也无法实例化（保证多态）.

class Animal(ABC),就是Animial也是从别的地方继承的,Animal 类确实是从 ABC 这个类继承来的，但这不是普通的业务逻辑继承（比如 Dog 继承 Animal），而是为了让 Animal 获得「抽象类」的特殊能力.

没有继承 ABC 的类（普通类）：就是 “直接能用” 的 —— 可以直接实例化（obj = 类名()），也能被其他类继承；继承了 ABC 的类（抽象类）：就是 “专门给别人继承用” 的 —— 自己不能直接实例化，唯一价值是作为父类，强制子类实现指定方法。

PS: 子类既可以复用父类的属性 / 方法，也能新增自己特有的内容。

三、引入多态的概念

# 定义一个基类：动物
class Animal(ABC):
    def __init__(self, name, age):
        self.name = name  # 实例变量：名字
        self.age = age  # 实例变量：年龄

    @abstractmethod  # 抽象方法装饰器
    def speak(self):  # 方法：动物叫声（多态的基础）
        pass  # 不需要具体实现

    def info(self):  # 方法：显示动物信息（封装）
        print(f"{self.name} ({self.age} 岁)")


# 继承自动物类的子类
class Dog(Animal):
    def __init__(self, name, age):
        super().__init__(name, age)  # 调用父类构造函数 
    def speak(self):                # 方法重写（多态）
        return "汪汪！" 

# 另一个子类
class Cat(Animal):
    def __init__(self, name, age, color):
        super().__init__(name, age)
        self.color = color 
    def speak(self):                # 方法重写（多态）
        return "喵～" 

# 使用示例
if __name__ == "__main__":
    # 创建实例
    my_dog = Dog("小黑", 3 )
    my_cat = Cat("雪球", 2, "白色") 

    # 多态演示
    animals = [my_dog, my_cat]
    for animal in animals:
        print(f"{animal.name} 说：{animal.speak()}")

这段代码里的多态，核心是：不同的子类对象（Dog、Cat），都属于 “Animal” 这个父类类型，调用同一个父类定义的方法（speak）时，会自动执行各自子类里的实现逻辑，呈现出不同的行为结果。