DAY 28 类的定义和方法

 知识点回顾：

1. 类的定义
2. pass占位语句
3. 类的初始化方法
4. 类的普通方法
5. 类的继承：属性的继承、方法的继承

类的定义 

 类是对属性和方法的封装，可以理解为模板，通过对模板实例化可以实现调用这个类的属性和方法。比如创建一个随机森林类，然后就可以调用他的训练和预测方法。

一个常见的类的定义包括了：

1. 关键字class
2. 类名
3. 语法固定符号冒号(:)
4. 一个初始化函数__init__(self)  

注意：init左右各有两个下划线__，需要传入self这个特殊的参数。

Pass占位符和缩进

class ClassName: # 类名通常遵循大驼峰命名法 (UpperCamelCase)，即每个单词的首字母都大写，class是定义类的关键词
    # 类的代码块 (可以包含属性定义、方法定义等)
    pass # pass 是一个占位符，表示这里暂时没有任何内容

许多时候，当规划好准备写一个函数、或者一个类，关键词定义后，会先用pass占位，避免运行错误，等到想好写什么再去补上

比如def、class这些定义的关键词后，必须有一个有占据缩进位置的代码块。

Python 通过缩进来定义代码块的结构。当解释器遇到像 def, class, if, for 这样的语句，并且后面跟着冒号 : 时，它就期望接下来会有一个或多个缩进的语句来构成这个代码块。如果它没有找到任何缩进的语句（即代码块是空的），就无法确定这个结构的范围，因此会抛出IndentationError。

pass 语句的存在就是为了解决这个问题：它本身不执行任何操作，但它是一个有效的 Python 语句。所以，当你需要一个语法上存在的代码块，但又暂时不想在其中放入任何实际的逻辑时，pass 就是一个完美的占位符，它告诉解释器：“这里有一个代码块，但它什么也不做。”

 

类有2种方法：

类的初始化方法 

初始化方法又叫构造方法、特殊方

class Teacher: # 这里不需要括号
  def __init__(self): #初始化方法，这里没有传入参数
    self.name = "Susan" # 给类定义一些属性
    self.subject = "English"
    self.age = 33

Teacher = Teacher() # 创建一个Teacher类的实例
print(Teacher.name) # 输出: Susan

class Teacher:
    def __init__(self, name, age):# 初始化方法，传入了参数
        self.name = name # 外界的参数，需要通过self.xxx来复制给类自己的属性
        self.age = age
        self.subject = "English"  # 这个属性仍然是在创建时就设定好的

# 创建一个Teacher对象的例子，构造方法的参数必须
teacher = Teacher("Susan", 33) # 如果在初始化方法中设置了非默认的参数，那么外界就必须要传入才行
print(teacher.name)  # 输出: Susan
print(teacher.age)   # 输出: 33
print(teacher.subject)  # 输出: English

其中，self.xx是用来表明这个属性“归属于”这个类自己的（self）。比如self.name，就代表着：“自己的名字”，self等于“自己”，这个self指向类的实例化地址，传入的self.xx是它的属性。

以后要是用它的属性值，即使是从外界参数传入的，前面也必须加上self.xx，否则传入的参数没价值（例外的情况我们不提）

类的普通方法

除了初始化方法（init方法，又名构造方法），还包含一些普通方法（自己定义）

普通方法和init方法的差别在于：

• init方法是类的构造方法，当创建对象时，会自动调用init方法——只要创建这个类对象，这个init函数就会执行。
• 普通方法是只有调用类的这个方法的时候，函数才会执行。

class Teacher:
    def __init__(self):
        self.name = "Susan"
        self.subject = "English"
        self.age = 33
    def teach_lesson(self):
        print("上课中")
    def criticize(self):
        print("批评人") 
t = Teacher()
t.teach_lesson() # 调用类的方法
t.criticize()
print(t.name)

class Teacher:
    # 初始化方法接受参数以动态设置教师的属性
    def __init__(self, name, subject, age):
        self.name = name
        self.subject = subject
        self.age = age

    # 不是init的都叫做普通方法
    # 普通方法，模拟教师上课的行为
    def teach_lesson(self):
        print(f"{self.name}正在教{self.subject}。")

    # 另一个普通方法，模拟教师批评学生的行为
    def criticize(self, student_name):
        print(f"{self.name}正在批评{student_name}。")


# 创建Teacher类的实例
teacher = Teacher("Susan", "English", 33)

# 调用教师的方法
teacher.teach_lesson()
teacher.criticize("John")#普通方法的参可以等到调用该方法的时候再传

类的继承 

在面向对象编程中，继承允许一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码复用和功能扩展。子类可以：

1. 复用父类的代码（无需重新实现）。
2. 重写父类的方法（修改或增强功能）。
3. 添加新的方法和属性（扩展功能）。

重写父类的方法，也包含2种

1. 直接重写：本质是会优先用子类的同名方法，完全替代父类方法，父类逻辑不会执行。

   # 先沿用之前定义的teacher类
   class Teacher:
       def __init__(self, name, subject, age):
           self.name = name
           self.subject = subject
           self.age = age
   
       def teach_lesson(self):
           print(f"{self.name}正在教{self.subject}。")
   
       def criticize(self, student_name):
           print(f"{self.name}正在批评{student_name}。")
   
   # 继承 Teacher 类，起名特级教师
   class MasterTeacher(Teacher): # 1. 继承需要在括号中指定父类
       def __init__(self, name, subject, age, experience_years):# 2. 继承的时候需要调用父类的构造方法，所以需要传入父类的参数，同时也可以传入自己的参数
           # 调用父类的构造方法初始化基本属性
           super().__init__(name, subject, age) # 3. 调用父类的构造方法，这里的super()是一个内置函数，返回父类的实例
           # 4. 此时子类自动拥有了父类的属性和方法
           # 添加子类特有的属性
   
           self.experience_years = experience_years # 5. 子类特有的属性可以在这里定义
   
       # 重写父类方法，增强功能-----如果子类定义了与父类同名的方法，子类实例会优先调用子类的方法。
       def teach_lesson(self): # 6. 重写父类的方法
           print(f"{self.name}（特级教师）正在用高级方法教授{self.subject}。")
   
       # 新增子类特有的方法
       def give_lecture(self, topic): 
           print(f"{self.name}正在举办关于{topic}的讲座。")
   
   # 创建子类实例
   master = MasterTeacher("王教授", "数学", 45, 20)
   
   # 调用继承的方法
   master.teach_lesson()     # 调用重写的父类的方法
   master.criticize("李同学")  # 调用父类的方法，如果不修改方法，则可以直接继承父类的方法
   
   # 调用子类特有的方法
   master.give_lecture("微积分")  # 调用子类新增的方法

作业

题目1：定义圆（Circle）类

要求：

1. 包含属性：半径 radius。
2. 初始化时需传入半径，默认值为 1。
3. 包含方法：

• calculate_area()：计算圆的面积（公式：πr²）。
• calculate_circumference()：计算圆的周长（公式：2πr）。

import math

class Circle:
    def __init__(self, radius=1):
        self.radius = radius  # 初始化半径，默认值为1
    
    def calculate_area(self):
        return math.pi * (self.radius ** 2)  # 计算圆面积：πr²
    
    def calculate_circumference(self):
        return 2 * math.pi * self.radius  # 计算圆周长：2πr

# 示例用法
circle = Circle(5)
print(f"半径为 {circle.radius} 的圆：")
print(f"面积 = {circle.calculate_area():.2f}")        # 输出：78.54
print(f"周长 = {circle.calculate_circumference():.2f}")  # 输出：31.42

题目2：定义长方形（Rectangle）类

1. 包含属性：长 length、宽 width。
2. 初始化时需传入长和宽，默认值均为 1。
3. 包含方法：

• calculate_area()：计算面积（公式：长×宽）。
• calculate_perimeter()：计算周长（公式：2×(长+宽)）。 is_square() 方法，判断是否为正方形（长 == 宽）。

class Rectangle:
    def __init__(self, length=1, width=1):
        self.length = length  # 初始化长，默认值为1
        self.width = width    # 初始化宽，默认值为1
    
    def calculate_area(self):
        return self.length * self.width  # 计算面积：长×宽
    
    def calculate_perimeter(self):
        return 2 * (self.length + self.width)  # 计算周长：2×(长+宽)
    
    def is_square(self):
        return self.length == self.width  # 判断是否为正方形：长==宽

# 示例用法
rectangle1 = Rectangle(4, 5)
print(f"长方形1（长={rectangle1.length}, 宽={rectangle1.width}）：")
print(f"面积 = {rectangle1.calculate_area()}")         # 输出：20
print(f"周长 = {rectangle1.calculate_perimeter()}")     # 输出：18
print(f"是否为正方形 = {rectangle1.is_square()}")       # 输出：False

rectangle2 = Rectangle(3, 3)
print(f"\n长方形2（长={rectangle2.length}, 宽={rectangle2.width}）：")
print(f"面积 = {rectangle2.calculate_area()}")         # 输出：9
print(f"周长 = {rectangle2.calculate_perimeter()}")     # 输出：12
print(f"是否为正方形 = {rectangle2.is_square()}")       # 输出：True

题目3：图形工厂

创建一个工厂函数 create_shape(shape_type, *args)，根据类型创建不同图形对象：图形工厂（函数或类）

shape_type="circle"：创建圆（参数：半径）。

shape_type="rectangle"：创建长方形（参数：长、宽）。

import math

class Circle:
    def __init__(self, radius=1):
        self.radius = radius
    
    def calculate_area(self):
        return math.pi * (self.radius ** 2)
    
    def calculate_circumference(self):
        return 2 * math.pi * self.radius

class Rectangle:
    def __init__(self, length=1, width=1):
        self.length = length
        self.width = width
    
    def calculate_area(self):
        return self.length * self.width
    
    def calculate_perimeter(self):
        return 2 * (self.length + self.width)
    
    def is_square(self):
        return self.length == self.width

def create_shape(shape_type, *args):
    """
    图形工厂函数，根据类型创建对应的图形对象
    
    参数:
    - shape_type: 图形类型，支持 "circle" 或 "rectangle"
    - *args: 传递给对应图形构造函数的参数
    
    返回:
    - 对应类型的图形对象实例
    """
    if shape_type == "circle":
        return Circle(*args)
    elif shape_type == "rectangle":
        return Rectangle(*args)
    else:
        raise ValueError(f"不支持的图形类型: {shape_type}")

# 示例用法
circle = create_shape("circle", 5)
print(f"圆面积: {circle.calculate_area():.2f}")  # 输出: 78.54

rectangle = create_shape("rectangle", 4, 5)
print(f"长方形周长: {rectangle.calculate_perimeter()}")  # 输出: 18

@浙大疏锦行