Python – 构造函数、继承与重载

[QPY课程团队]

构造函数：

构造函数是一个独特的函数，当一个类的对象被创建时，它会自动被调用。

–> 它用于在对象创建时初始化对象。
–> 构造函数的方法名为 __init__()

self 关键字：
–> 用于表示当前对象

• 示例：1

class Employee:
    def __init__(self, name, qual, department, year):
        self.empName = name
        self.dept = department
        self.joining_year = year
        self.qual = qual

    def work(self):
        print("工作中", self.empName, self.dept, self.joining_year)

emp1 = Employee("guru", "B.Com", "Development", 2025)
emp2 = Employee("pritha", "M.E.,", "Design", 2025)
emp1.work()

输出：

工作大师 开发 2025

• 示例：2

class Employee:
    salary = 25000
    def __init__(self, name, qual, department, year):
        self.empName = name
        self.dept = department
        self.joining_year = year
        self.qual = qual

    def work(self):

print("工作中", self.empName, self.dept, self.joining_year)
print(self.salary)
emp1 = Employee("guru", "B.Com", "Development", 2025)
emp2 = Employee("pritha", "M.E.,", "Design", 2025)
emp1.work()

输出：


工作中 guru Development 2025
25000


__dict__

__dict__ 是对象的一个特殊属性，用于以字典的形式存储所有实例属性。

• 示例：

class Employee:
    salary = 25000
    def __init__(self, name, qual, department, year):
        self.empName = name
        self.dept = department
        self.joining_year = year
        self.qual = qual

    def work(self):
        print("工作中", self.empName, self.dept, self.joining_year)
        print(self.salary)
emp1 = Employee("guru", "B.Com", "开发", 2025)
emp2 = Employee("pritha", "M.E.,", "设计", 2025)
print(Employee.__dict__)
print(emp1.__dict__)
print(emp2.__dict__)

输出：

{'__module__': '__main__', 'salary': 25000, '__init__': <function Employee.__init__ at 0x7265db745300>, 'work': <function Employee.work at 0x7265db7acea0>, '__dict__': <attribute '__dict__' of 'Employee' objects>, '__weakref__': <attribute '__weakref__' of 'Employee' objects>, '__doc__': None}
{'empName': 'guru', 'dept': 'Development', 'joining_year': 2025, 'qual': 'B.Com'}
{'empName': 'pritha', 'dept': 'Design', 'joining_year': 2025, 'qual': 'M.E.,'}

类方法与装饰器

类方法是一个操作类本身而不是实例的方法。它使用 @classmethod 装饰器定义，并将 cls（类引用）作为第一个参数。

• 示例:

class Employee:
    salary = 25000
    def __init__(self, name, qual, department, year):
        self.empName = name
        self.dept = department
        self.joining_year = year
        self.qual = qual

    @classmethod
    def credit_salary(cls):
        print("在每个月的最后一天发放工资")

    def work(self):
        print("工作中", self.empName, self.dept, self.joining_year)
        print(self.salary)
emp1 = Employee("guru", "B.Com", "Development", 2025)
emp2 = Employee("pritha", "M.E.,", "Design", 2025)
Employee.credit_salary()

输出：

每月最后一天发放工资

 

嵌套类：

嵌套类（内部类）是在另一个类内部定义的类。

• 示例：1（使用外部类的实例调用内部类）

class College:
    def init(self):
        print("学院构造函数")

    class Dept:
        def init(self):
            print("部门构造函数")

        def work(self):
            print("工作中")

principal = College()
hod = principal.Dept()
hod.work()

• 示例：2（直接使用外部类名称调用内部类）

class College:
    def __init__(self):
        print("学院构造函数")

    class Dept:
        def __init__(self):
            print("部门构造函数")

        def work(self):
            print("工作中")

hod = College().Dept()
hod.work()

输出：（两个示例的输出相同）

大学构造函数
部门构造函数
工作中

构造函数重载：

–> 构造函数重载是指在一个类中定义多个具有不同参数集的构造函数。
–> Python 不支持多个构造函数（init 方法）
–> Python 通过默认参数值和可变长度参数列表（*args 或 **kwargs）实现方法重载。

• 示例：

class SuperMarket:
    def __init__(self, product_name, price, *discount):
        self.product_name = product_name
        self.price = price

self.discount = discount

def buy(self):
    print(self.product_name, self.price, self.discount)

class Shapes:
    def find_area(self, side1, side2):
        print(side1 * side2)

class Square(Shapes):
    pass

s = Square()
s.find_area(5, 5)

class Rectangle(Shapes):
    pass

r = Rectangle()
r.find_area(10, 8)

product1 = SuperMarket("soap", 50, 10)
product2 = SuperMarket("Brush", 60, 20)
product1.buy()
product2.buy()
product3 = SuperMarket("Rice", 60)
product3.buy()

输出：

soap 50 (10,)
Brush 60 (20,)
Rice 60 ()

继承

–> 继承允许我们定义一个类，该类继承自另一个类的所有方法和属性。

–> 父类 是被继承的类，也称为基类。

–> 子类 是从另一个类继承的类，也称为派生类。

Python中的继承类型

Python支持以下类型的继承：

• • 单继承：子类从单一父类继承。

• • 多重继承：子类从多个父类继承。

• • 多级继承：子类从一个父类继承，而该父类又继承自另一个父类。

 

• 层次继承：多个子类从同一个父类继承。
• 混合继承：多种继承类型的组合。

 

• 示例:

class Shapes:
    def find_area(self, side1, side2):
        print(side1 * side2)

class Square(Shapes):
    pass

s = Square()
s.find_area(5,5)

class Rectangle(Shapes):
    pass
r = Rectangle()
r.find_area(10,8)

输出：

25
80

方法重写（运行时多态性）

–> 方法重写发生在子类提供了一个已经在其父类中定义的方法的具体实现时。
–> 子类中被重写的方法必须与父类中的方法具有相同的名称和参数。

• 方法解析顺序（MRO）
  示例：（多重继承）

class Father:
    def work(self):
        print("机械工程师")

class Mother:
    def work(self):
        print("软件工程师")

class Child(Mother, Father):
    def work(self):
        print("商人")

child = Child()
child.work()

输出：
商人

–> 子类从母类和父类派生。
–> Python 首先检查子类。
–> 如果未找到该方法，则检查母类（第一个列出的父类）。
–> 如果仍未找到，则检查父类。

如果父类中没有该方法，它会检查对象（所有Python类的基类）。

运算符重载

运算符重载允许我们为用户定义的对象重新定义运算符（+、-、*等）的行为。

print(100+200)
print("Hi"+"Hello")
print(100*3)
print("Hi"*3)

输出：

300
HiHello
300
HiHiHi

–> 运算符 + 用于将两个整数相加，以及连接两个字符串和合并两个列表。
–> 这是可实现的，因为‘+’运算符被 int 类和 str 类重载。

• 示例：

class Book:
    def __init__(self, pages):
        self.pages = pages

    def __add__(self, second):
        print(self.pages, second.pages)
        return self.pages + second.pages

book1 = Book(300)
book2 = Book(200)
print(book1 + book2)

输出：

300 200
500

class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    def __mul__(self,other):
        return self.salary * other.days

class TimeSheet:
    def __init__(self, name, days):
        self.name = name
        self.days = days

emp1 = Employee("Guru", 1000)
timesheet1 = TimeSheet("Guru", 25)
print("月薪:",emp1 * timesheet1)

输出：

月薪：25000

[作者]

帖子