类的介绍

类是对一类事物的抽象描述（如“微波炉”“机器人”），把它们的共同特征和行为封装在一起。

要点：

1.类是相同事物的集合，包含属性（数据）和方法（功能）。

2.对象是类的具体实例，如 "hello"是 str类的实例， 123是 int类的实例。

创建类

用 class保留字定义一个类，写明类名、说明文档、初始化方法和其它方法。

要点：

1.class 类名():类名首字母通常大写，遵循变量命名规则。

2.三引号 ‘’‘说明文档’''描述类的功能。

3.init(self, 参数…)是固定初始化方法，self代表实例自身。

4.方法定义：def 方法名(self, 参数…):代码块。

5.三引号引起来的字符串，主要用于创建类的功能和方法使用说明

6.类的初始化方法要使用固定的方法名__init__,且括号中的第1个形参变量名为self，表示自己本身

class Dog:
    """狗狗类：有名字和年龄，可以叫"""
    def __init__(self, name, age):
        self.name = name   # 属性
        self.age = age
    
    def bark(self):
        print(self.name, "汪汪!")

创建对象

用类名加实参创建类的实例（对象），通过对象调用方法或访问属性。

要点：

1.对象 = 类名(实参)创建对象。

2.对象.方法名(参数)调用方法，对象.属性访问属性。

d = Dog("旺财", 3)   # 创建对象
d.bark()            # 输出：旺财 汪汪!
print(d.name)        # 输出：旺财

类的属性

属性是对象的标签信息（数据），可在初始化或方法中赋值。
要点：

1.访问：对象.属性。

2.修改：对象.属性 = 新值。

3.获取文档说明：类名.doc。

print(Dog.__doc__)   # 输出：狗狗类：有名字和年龄，可以叫

d = Dog("小白", 2)
d.age = 4            # 修改属性
print(d.age)         # 输出：4

属性的修改

修改基本数据类型属性

class Dog:
    def __init__(self, name, age):
        self.name = name  # 字符串属性
        self.age = age    # 整数属性

# 1. 创建对象
d = Dog("旺财", 3)
print("创建时：", d.name, ",", d.age, "岁") # 输出：创建时： 旺财 , 3 岁

# 2. 直接修改属性
d.name = "小白"  # 将 name 属性从 "旺财" 改为 "小白"
d.age = 5        # 将 age 属性从 3 改为 5

# 3. 验证修改结果
print("修改后：", d.name, ",", d.age, "岁") # 输出：修改后： 小白 , 5 岁

获取类的文档说明

核心方法：使用 __doc__属性
在Python中，任何对象（包括类、函数、模块）都可以通过其特殊的 __doc__属性来获取其文档字符串（Docstring）。

语法：类名.__doc__或 对象.class.doc

class Dog:
    """狗狗类：有名字和年龄，可以叫。
    
    这个类用于模拟一个宠物的基本行为和信息。
    属性:
        name (str): 狗狗的名字。
        age (int): 狗狗的年龄。
    方法:
        bark(): 让狗狗叫一声。
    """
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def bark(self):
        print(self.name, "汪汪!")


# --- 获取文档说明 ---

# 方法一：通过类名直接访问 (最常用)
print(Dog.__doc__)

初始化方法调用其他方法

__init__和其它方法可互相调用，类中的方法都能调用别的方法。

class Cat:
    def __init__(self, name):
        self.name = name
        self.say_hi()
    
    def say_hi(self):
        print("Hi, 我是", self.name)

c = Cat("咪咪")      # 输出：Hi, 我是 咪咪

类的继承

子类继承父类，自动拥有父类的属性和方法，并可新增或覆盖方法。
要点：

1.class 子类(父类):括号中写父类名。

2.子类 __init__中可用 super().init(父参数)调用父类初始化。

3.子类可添加新方法，也可重写父类方法覆盖。

class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        print(self.name, "发出声音")

class Bird(Animal):
    def __init__(self, name, can_fly):
        super().__init__(name)
        self.can_fly = can_fly
    def speak(self):          # 覆盖父类方法
        print(self.name, "啾啾!")

b = Bird("鹦鹉", True)
b.speak()                  # 输出：鹦鹉 啾啾!

使用继承方式创建新类（子类）是为了复用现有类（父类）的代码和功能。它与完全从头开始写一个全新的类，主要有以下两点关键区别：
1.类定义语法不同

语法：class 子类名(父类名):

核心：子类名后的括号 (父类名)是其标志性特征，它明确告诉Python这个类“是谁的孩子”，即它继承了哪个父类。

关键点：在同一文件中,父类的代码必须在子类之前定义。你必须先有父类这个“模板”才行。

# 1. 必须先定义父类
class Animal:
    def __init__(self, name):
        self.name = name

# 2. 子类定义时，在括号内指明继承自哪个父类
class Dog(Animal): #  这里的 (Animal) 是关键
    pass

直接创建新类（非继承）：

语法：class 类名():或 class 类名:

核心：括号内为空或不写，表示这个类不从任何其他类那里继承特定的属性和方法，它是一个独立的起点。

2.初始化方法 __init__的逻辑不同
这是继承中最核心的操作，目的是让子类“拥有”父类的特征。

继承方式（子类 init）：

在子类 __init__方法的开头，必须使用 super().init(父参数)来调用父类的初始化方法。可以理解为在创建子类对象时，先“借用”父类的构造函数来初始化从父类继承来的那部分属性。

参数传递：

子类的 __init__方法需要接收所有创建父类对象和子类对象所必需的参数。也就是说，它的参数列表必须包含父类的参数。

super().init(父参数)中的 父参数正是从子类接收到的参数中挑选出来的，传递给父类。

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

class Dog(Animal):
    # 子类参数必须包含父类的参数(name)，并可以添加自己特有的参数(breed)
    def __init__(self, name, breed): 
        # 首行调用父类构造器，将子类接收到的 'name' 参数传过去
        super().__init__(name) 

        # 然后再初始化子类自己特有的属性
        self.breed = breed 

my_dog = Dog("旺财", "金毛")
print(my_dog.name)  # 输出：旺财 (继承自Animal)
print(my_dog.breed) # 输出：金毛 (Dog类自己的)

导入其他文件中的类

用 import或 from … import …引入其他 .py文件的类。

要点：

1.import 模块→ 模块.类名()

2.from 模块 import 类名→ 直接用类名

3.from 模块 import *→ 导入全部类（不推荐）

4.as 别名→ 简化名称

# 方法1：导入模块
import dog
d = dog.Dog("阿黄", 5)

# 方法2：导入指定类
from dog import Dog
d = Dog("阿黄", 5)

# 方法3：别名
from dog import Dog as D
d = D("阿黄", 5)

在类中使用另一个类的方法

在一个类中创建另一个类的实例，调用它的方法。
在子类中新创建的方法无法在父类中使用，而父类中创建的方法可以在子类中使用。

class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        print(self.name, "发出声音")

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed
    def wag_tail(self):
        print(self.name, "摇尾巴")

# 父类不能用子类方法
a = Animal("动物")
a.speak()
# a.wag_tail()  # 报错

# 子类可用父类方法 + 自己的方法
d = Dog("旺财", "金毛")
d.speak()
d.wag_tail()

覆盖父类中的方法

1.需要对父类的方法进行修改、调整
假设我们有一个 父类 Animal，它有一个 speak()方法，功能是打印“发出声音”。

但是不同的动物叫声不一样，比如狗应该叫“汪汪”，鸟应该叫“啾啾”。

这时我们就需要对父类的方法做修改或调整，让它适合具体的动物。

2.通过子类重新编写父类中的方法
我们可以在子类里写一个跟父类方法同名的方法，把实现改成我们需要的。

这个过程就是“重新编写父类中的方法”。

3.执行子类方法时自动覆盖父类方法
当我们用子类的对象去调用这个方法时，Python 会自动执行子类的版本，而不是父类的版本，这就是“覆盖”。

父类的方法还在，只是对子类对象来说被“挡住”了。

class Animal:
    def speak(self):
        print("发出声音")      # 父类的原始方法

class Dog(Animal):
    def speak(self):           # 重新编写父类的方法（修改成狗叫）
        print("汪汪!")         # 调整后的功能

class Bird(Animal):
    def speak(self):           # 重新编写父类的方法（修改成鸟叫）
        print("啾啾!")         # 调整后的功能

# 父类对象 → 用父类方法
a = Animal()
a.speak()    # 输出：发出声音

# 子类对象 → 自动覆盖为子类方法
d = Dog()
d.speak()    # 输出：汪汪!

b = Bird()
b.speak()    # 输出：啾啾!

类的文件模块化

类的文件模块化就是把庞大的功能按类别拆分到不同文件夹和文件中，例如 openpyxl 库的 cell 文件夹定义操作单元格的类、chart 文件夹定义操作图表的类，这些类文件之间可互相调用方法；当文件夹中有 init.py时，Python 会将其视为一个整体模块，用户只需 import openpyxl就能直接使用整个库的功能，无需关心内部复杂的文件结构，从而实现代码的组织、管理与便捷使用。

项目案例：快递机器人

功能：模拟填单和生成取件单号。

class Robot():
    def __init__(self):
        print('我是您的快递小助手')
        self.bill = 20230100
        self.postage = {'北京':15,'上海':12,'广东':13}
        self.q_number = [100,101,104,105]
 
    def send_ex(self):
        print('请填写您的寄件信息')
        self.addr = input('您的寄件地址:')
        self.number = input('您的手机号码:')
        self.name = input('您的姓名:')
        print('您需要支付',self.postage[ self.addr[:2] ] ,'元')
        self.bill +=1
        print('账单生成中...\n您的寄件单号:',self.bill)
 
    def collect_ex(self):
        self.c_list = int(input('请输入您的取件号:'))
        if self.c_list in self.q_number:
            print('您的快递已找到，请扫码领取。')
            self.q_number.pop()
        else:
            print('未找到您的快递')
 
a = Robot()
a.send_ex()