面向对象三大特性 ¶

class Person():
    name = 'name'  # 共有属性 public
    _age = 0  # 受保护属性 protected
    __phone = 'phone'  # 私有属性 private

    def __init__(self, n, a, p):
        self.name = n
        self._age = a
        self.__phone = p

    def get_name(self):
        print(f'My name is {self.name}')

    def _get_age(self):
        print(f'My age is {self._age}') # 受保护属性，Python中是可以调用
        print(f'My age is {self.__phone}') # 可以内部调用私有属性__phone

    def __get_phone(self): # 私有属性，外部不可调用
        print(f'My phone is {self.__phone}')


tom = Person('Tom', 18, 12345678)

print(tom.name)
# 'Tom'
print(tom._age)
# 18
print(tom.__phone)
# AttributeError: 'Person' object has no attribute '__phone'
print(tom._Person__phone)
# 12345678
tom.get_name()
# My name is Tom

tom._get_age()
# My age is 18
# My age is 12345678

tom.__get_phone()
# AttributeError: 'Person' object has no attribute '__get_phone'
tom._Person__get_phone()
# My phone is 12345678

class Person:
    def __init__(self, n, a, p):
        self.name = n
        self.age = a
        self.phone = p

tom = Person("Tom", 18, 12345678)
print(tom.name)  # 输出：Tom
print(tom.age)  # 输出：18
print(tom.phone)  # 输出：12345678

class Person:
    def __init__(self, name: str) -> None:
        self._name = name
        self._age: int

    def _get_name(self):
        return self._name

    def _set_name(self, name: str) -> None:
        self._name = name


p = Person("Tom")
print(p._name)  # Tom

class Person:
    def __init__(self, name: str) -> None:
        self._name = name
        self._age: int

    def _get_age(self):
        return self._age

    def _set_age(self, age: int) -> None:
        self._age = age

    def _del_age(self):
        print(f"Deleting age: {self._age}")
        del self._age

    age = property(_get_age, _set_age, _del_age, "this is age property")


p = Person("Tom")
p.age = 30
print(p.age)  # 30
p.age = "age property"
print(p.age)  # age property
del p.age  # Deleting age: age property

class Person:
    def __init__(self, name: str) -> None:
        self._name = name
        self._age: int

    @property
    def age(self):
        """this is age property"""
        return self._age

    @age.setter
    def age(self, age: int) -> None:
        self._age = age

    @age.deleter
    def age(self):
        print(f"Deleting age: {self._age}")
        del self._age

p = Person("Tom")
p.age = 30
print(p.age)  # 30
p.age = "age property"
print(p.age)  # age property
del p.age  # Deleting age: age property

class BaseClassName():
    <statement-1>
    .
    .
    .
    <statement-N>

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

class DerivedClassName(modname.BaseClassName):

class Person:
    name = "name"  # 共有属性 public
    _age = 0  # 受保护属性 protected
    __phone = "phone"  # 私有属性 private

    def __init__(self, n, a, p):
        self.name = n
        self._age = a
        self.__phone = p

    def get_name(self):
        print(f"My name is {self.name}")

    def _get_age(self):
        print(f"My age is {self._age}")  # 受保护属性，Python中是可以调用
        print(f"My age is {self.__phone}")  # 可以内部调用私有属性__phone

    def __get_phone(self):  # 私有属性，外部不可调用
        print(f"My phone is {self.__phone}")


class Student(Person):
    def __init__(self, n, a, p, major):
        super().__init__(n, a, p)  # 调用父类的构造函数
        self.major = major  # 新增属性：专业

    def get_info(self):
        # 调用父类的get_name方法
        Person.get_name(self)  # 直接调用基类方法
        print(f"My major is {self.major}")

    def __str__(self):
        return f"Student(name={self.name}, age={self._age}, phone={self._Person__phone}, major={self.major})"


tom = Person("Tom", 18, 12345678)

print(tom.name)
# 'Tom'
print(tom._age)
# 18
print(tom.__phone)
# AttributeError: 'Person' object has no attribute '__phone'
print(tom._Person__phone)
# 12345678
tom.get_name()
# My name is Tom

tom._get_age()
# My age is 18
# My age is 12345678

tom.__get_phone()
# AttributeError: 'Person' object has no attribute '__get_phone'
tom._Person__get_phone()
# My phone is 12345678

# 创建Student实例
alice = Student("Alice", 20, 987654321, "Computer Science")

# 调用重载的方法
alice.get_info()
# My name is Alice 和 My major is Computer Science

# 使用isinstance检查实例类型
print(isinstance(alice, Student))
# True
print(isinstance(alice, Person))
# True，因为Student继承自Person

# 使用issubclass检查类的继承关系
print(issubclass(Student, Person))
# True，因为Student是Person的子类
print(issubclass(Person, Student))
# False，因为Person不是Student的子类

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

class F():

    def drink(self):
        print("Drink Beer")


class M():

    def drink(self):
        print("Drink Red Wine")


class C(F, M):

    def drink(self):
        print("Drink Water")

c = C()
c.drink()
# Drink Water

class C(F, M):

    def drink(self):
        super().drink()
        print("Drink Water")


c = C()
c.drink()
# Drink Beer
# Drink Water

C.mro()
# [<class '__main__.C'>, <class '__main__.F'>, <class '__main__.M'>, <class 'object'>]

class C(F, M):

    def drink(self):
        M.drink(self)
        print("Drink Water")


c = C()
c.drink()
# Drink Red Wine
# Drink Water

    A
   / \
  B   C
   \ /
    D

class A():
    pass


class B(A):

    def test(self):
        print("init B.test()")


class C(A):

    def test(self):
        print("init C.test()")


class D(B, C):
    pass


d = D()
d.test()
# init B.test()


D.mro()
# [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

E     F
|     |
B(E) C(F)  D
|     |    |
 \    |   /
  \   |  /
   A(B,C,D)

class D():

    def test(self):
        print("init D.test()")


class F():

    def test(self):
        print("init F.test()")


class C(F):
    pass


class E():
    pass


class B(E):
    pass


class A(B, C, D):
    pass


a = A()
a.test()
# init F.test()

A.mro()
# [<class '__main__.A'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.F'>, <class '__main__.D'>, <class 'object'>]

class Vehicle:
    def __init__(self, name):
        self.name = name

    def move(self):
        print(f"{self.name} is moving")

    def fly(self):
        """
        飞行功能相应的代码
        """
        print(f"{self.name} is flying")


# 民航飞机
class CivilAircraft(Vehicle):
    def __init__(self, name):
        super().__init__(name)


# 直升飞机
class Helicopter(Vehicle):
    def __init__(self, name):
        super().__init__(name)


# 汽车
class Car(Vehicle):
    def __init__(self, name):
        super().__init__(name)


if __name__ == "__main__":
    car = Car("Toyota")
    car.move()
    car.fly() 

# Toyota is moving
# Toyota is flying

# 交通工具
class Vehicle:
    def __init__(self, name):
        self.name = name

    def move(self):
        print(f"{self.name} is moving")


# 为当前类混入一些功能，不是一个单纯的类
class FlyableMixin:

    def fly(self):
        """
        飞行功能相应的代码
        """
        print(f"{self.name} is flying")


# 民航飞机
class CivilAircraft(FlyableMixin, Vehicle):
    def __init__(self, name):
        super().__init__(name)


# 直升飞机
class Helicopter(FlyableMixin, Vehicle):
    def __init__(self, name):
        super().__init__(name)


# 汽车
class Car(Vehicle):
    def __init__(self, name):
        super().__init__(name)


if __name__ == "__main__":
    # 创建民航飞机实例并调用飞行功能
    civil_aircraft = CivilAircraft("Boeing 747")
    civil_aircraft.move()  # Boeing 747 is moving
    civil_aircraft.fly()  # Boeing 747 is flying

    # 创建直升飞机实例并调用飞行功能
    helicopter = Helicopter("Bell 407")
    helicopter.move()  # Bell 407 is moving
    helicopter.fly()  # Bell 407 is flying

    # 创建汽车实例并尝试调用飞行功能
    car = Car("Toyota")
    car.move()  # Toyota is moving
    try:
        car.fly()
    except AttributeError as e:
        print(f"Error: {e}")  # Error: 'Car' object has no attribute 'fly'

from math import pi

class Circle():

    def __init__(self, r):
        self.r = r

    def area(self):
        return pi * self.r * self.r

    def perimeter(self):
        return 2 * pi * self.r


class Ring():

    def __init__(self, r1, r2):
        self.circle1 = Circle(r1)
        self.circle2 = Circle(r2)

    def area(self):
        return abs(self.circle1.area() - self.circle2.area())

    def permiter(self):
        return self.circle1.perimeter() + self.circle2.perimeter()


ring = Ring(5, 8)

print(ring.area())
# 122.52211349000193

print(ring.permiter())
# 81.68140899333463

class Birthday():

    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day


class Course():

    def __init__(self, course_name, course_period):
        self.course_name = course_name
        self.course_period = course_period


class Professor():

    def __init__(self, name, gender, birth, course):
        self.name = name
        self.gender = gender
        self.birth = birth # 通过self.birth访问Birthday实例的birth属性
        self.course = course # 通过self.course访问Course实例的course属性

    def teach(self):
        print(f"
              Professor name: {self.name}; 
              Gender: {self.gender}; 
              Birthday: {self.birth.year}-{self.birth.month}-{self.birth.day}, 
              Course name: {self.course.course_name} 
              and period: {self.course.course_period}
              "
              )


prof = Professor('Tom', 'Male', Birthday(1985, 5, 5), Course('Chinese', '2022/3/1 ~ 2022/6/30'))

prof.teach()
# Professor name: Tom; Gender: Male; Birthday: 1985-5-5, Course name: Chinese and period: 2022/3/1 ~ 2022/6/30

class Engine:
    def __init__(self, horsepower):
        self.horsepower = horsepower

    def start(self):
        print(f"Engine with {self.horsepower} horsepower is starting")

class Car:
    def __init__(self, make, model, engine):
        self.make = make
        self.model = model
        self.engine = engine  # Car 有一个 Engine 实例

    def drive(self):
        print(f"Driving {self.make} {self.model}")
        self.engine.start()  # 调用 Engine 实例的 start 方法

# 创建 Engine 实例
engine = Engine(300)

# 创建 Car 实例，传递 Engine 实例作为属性
car = Car("Toyota", "Corolla", engine)

# 调用 Car 实例的 drive 方法
car.drive()
# Driving Toyota Corolla
# Engine with 300 horsepower is starting

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author

    def display(self):
        print(f"Book: {self.title} by {self.author}")

class Library:
    def __init__(self):
        self.books = []

    def add_book(self, book):
        self.books.append(book)

    def list_books(self):
        for book in self.books:
            book.display()

# 创建 Book 实例
book1 = Book("1984", "George Orwell")
book2 = Book("To Kill a Mockingbird", "Harper Lee")

# 创建 Library 实例
library = Library()

# 向 Library 添加 Book 实例
library.add_book(book1)
library.add_book(book2)

# 列出 Library 中的所有 Book
library.list_books()
# Book: 1984 by George Orwell
# Book: To Kill a Mockingbird by Harper Lee

# len() being used for a string
print(len("geeks"))
# 5

# len() being used for a list
print(len([10, 20, 30]))
# 3

class India():
    # Method to print the capital of India
    def capital(self):
        print("New Delhi is the capital of India.")

    # Method to print the most widely spoken language in India
    def language(self):
        print("Hindi is the most widely spoken language of India.")

    # Method to print the type of country India is
    def type(self):
        print("India is a developing country.")


class USA():
    # Method to print the capital of USA
    def capital(self):
        print("Washington, D.C. is the capital of USA.")

    # Method to print the primary language of USA
    def language(self):
        print("English is the primary language of USA.")

    # Method to print the type of country USA is
    def type(self):
        print("USA is a developed country.")


# Create an instance of India
obj_ind = India()
# Create an instance of USA
obj_usa = USA()

# Iterate over the instances and call their methods
for country in (obj_ind, obj_usa):
    country.capital()
    country.language()
    country.type()

# New Delhi is the capital of India.
# Hindi is the most widely spoken language of India.
# India is a developing country.
# Washington, D.C. is the capital of USA.
# English is the primary language of USA.
# USA is a developed country.

class Bird:

    def intro(self):
        print("There are many types of birds.")

    def flight(self):
        print("Most of the birds can fly but some cannot.")


class sparrow(Bird):

    def flight(self):
        print("Sparrows can fly.")


class ostrich(Bird):

    def flight(self):
        print("Ostriches cannot fly.")


obj_bird = Bird()
obj_spr = sparrow()
obj_ost = ostrich()

obj_bird.intro()
# There are many types of birds.

obj_bird.flight()
# Most of the birds can fly but some cannot.

obj_spr.intro()
# There are many types of birds.

obj_spr.flight()
# Sparrows can fly.

obj_ost.intro()
# There are many types of birds.

obj_ost.flight()
# Ostriches cannot fly.

class Calculator:
    def add(self, a, b=0):  # 通过默认参数实现重载
        return a + b

calc = Calculator()
print(calc.add(2))      # 输出: 2
print(calc.add(2, 3))   # 输出: 5

class Calculator:
    def add(self, *args):  # 通过可变参数实现重载
        return sum(args)

calc = Calculator()
print(calc.add(2))      # 输出: 2
print(calc.add(2, 3))   # 输出: 5
print(calc.add(2, 3, 4))# 输出: 9

class India():

    def capital(self):
        print("New Delhi is the capital of India.")

    def language(self):
        print("Hindi is the most widely spoken language of India.")

    def type(self):
        print("India is a developing country.")


class USA():

    def capital(self):
        print("Washington, D.C. is the capital of USA.")

    def language(self):
        print("English is the primary language of USA.")

    def type(self):
        print("USA is a developed country.")


def func(obj):
    obj.capital()
    obj.language()
    obj.type()


obj_ind = India()
obj_usa = USA()

func(obj_ind)
# New Delhi is the capital of India.
# Hindi is the most widely spoken language of India.
# India is a developing country.

func(obj_usa)
# Washington, D.C. is the capital of USA.
# English is the primary language of USA.
# USA is a developed country.

class Food:
    price = 4

    def price_info(self):
        print(f"{self.__class__.__name__} price: ${self.price}")


class Clothes:
    price = 5

    def price_info(self):
        print(f"{self.__class__.__name__} price: ${self.price}")


class Coffee:
    price = 6

    def price_info(self):
        print(f"{self.__class__.__name__} price: ${self.price}")


def print_price(item):
    item.price_info()


if __name__ == "__main__":
    goods = [Food(), Clothes(), Coffee()]
    for good in goods:
        print_price(good)

# Food price: $4
# Clothes price: $5
# Coffee price: $6

from abc import ABC, abstractmethod


class PricedItem(ABC):
    @abstractmethod
    def price_info(self):
        pass


class Food(PricedItem):
    price = 4

    def price_info(self):
        print(f"{self.__class__.__name__} price: ${self.price}")


class Clothes(PricedItem):
    price = 5

    def price_info(self):
        print(f"{self.__class__.__name__} price: ${self.price}")


class Coffee(PricedItem):
    price = 6

    def price_info(self):
        print(f"{self.__class__.__name__} price: ${self.price}")


def print_price(item: PricedItem):
    item.price_info()


if __name__ == "__main__":
    goods = [Food(), Clothes(), Coffee()]
    for good in goods:
        print_price(good)

# Food price: $4
# Clothes price: $5
# Coffee price: $6

@classmethod
def fun(cls, arg1, arg2, ...):

fun: 需要转换成类方法的函数
returns: 函数的类方法

class Training:
    # 类属性
    course = "Python for Data Analysis"

    # 普通方法，接受一个参数obj，obj用于访问类属性course
    def purchase(obj):
        print("Puchase course : ", obj.course)

# 打印 purchase 方法的类型
print(type(Training.purchase))
# <class 'function'>

# 将 purchase 方法转换为类方法
Training.purchase = classmethod(Training.purchase)

# 调用类方法
Training.purchase()
# Puchase course :  Python for Data Analysis

# 再次打印 purchase 方法的类型
print(type(Training.purchase))
# <class 'method'>

class Training:
    def __init__(self, course):
        self.course = course

    @classmethod
    def purchase(cls, course): # 类方法
        return cls(course)

    def display(self):
        print('Purchase course: ', self.course)

# 创建实例
training = Training("Python for Data Analysis")
# 调用实例方法
training.display()
# 输出: Purchase course:  Python for Data Analysis

class Training:
    def __init__(self, course):
        self.course = course

    @classmethod
    def purchase(cls, course):
        # 类方法，用于创建并返回类的新实例
        return cls(course)

    def display(self):
        # 实例方法，用于打印实例属性
        print('Purchase course: ', self.course)

    @staticmethod
    def get_course_info():
        # 静态方法，用于返回课程信息
        return "This is a data analysis course."

    @classmethod
    def update_course_name(cls, new_name):
        # 类方法，用于更新课程名称
        print(f"Updating course name to: {new_name}")
        # 假设这里有一个类属性 course_name，我们更新它
        cls.course_name = new_name

# 创建实例
training = Training("Python for Data Analysis")

# 调用实例方法
training.display()
# 输出: Purchase course:  Python for Data Analysis

# 调用静态方法
info = Training.get_course_info()
print(info)
# 输出: This is a data analysis course.

# 调用类方法作为工厂方法
new_training = Training.purchase("Advanced Python for Data Science")
new_training.display()
# 输出: Purchase course:  Advanced Python for Data Science

# 调用类方法更新课程名称
Training.update_course_name("Python for Machine Learning")
# 输出: Updating course name to: Python for Machine Learning

class Training:
    def __init__(self, course):
        self.course = course

    @classmethod
    def purchase(cls, course):
        # 根据课程类型创建不同类型的实例
        if course.lower() == "python for data analysis":
            return cls(course)
        elif course.lower() == "python for machine learning":
            return cls(course)
        else:
            raise ValueError("Unsupported course type")

    def display(self):
        print(f'Purchase course: {self.course}')

# 使用类方法作为工厂方法
training1 = Training.purchase("Python for Data Analysis")
training1.display()
# 输出: Purchase course: Python for Data Analysis

training2 = Training.purchase("Python for Machine Learning")
training2.display()
# 输出: Purchase course: Python for Machine Learning

# 尝试创建一个不支持的课程类型
try:
    training3 = Training.purchase("Java for Beginners")
except ValueError as e:
    print(e)
# 输出: Unsupported course type

class Test:
    def __init__(self):
       self.a = 1

    def func1(self, x, y):
       print(x + y)


# 正常实例化
test = Test()
test.func1(1, 1)
# 2

# 修改实例
test.func1 = lambda x, y : print(x + 2 * y)
test.func1(1, 1)
# 3

# 通过修改实例，访问内部成员变量。
test.func1 = lambda x, y : print(x + 2 * y + self.a)
test.func1(1, 1)
# NameError: name 'self' is not defined
test.func1 = lambda self, x, y : print(x + 2 * y + self.a)
test.func1(test, 1, 1)
# 4

class Test:
    def __init__(self):
       self.a = 1

    def func1(self, x, y):
       print(x + y)


# 修改类成员，实例化后的结果已修改。
Test.func1 = lambda self, x, y : print(x + 2 * y)

test = Test()
test.func1(1, 1)
# 3


# 修改类成员，并访问成员变量，实例化后的结果已修改。
Test.func1 = lambda self, x, y : print(x + 2 * y + self.a)

test = Test()
test.func1(1, 1)
# 4

# 增加类成员。
Test.func2 = lambda self, p, q: print(p + 3 * q + self.a)
test = Test()
test.func1(1, 1)
# 4
test.func2(1, 3)
# 11

class Order:
    def calculate_total(self): 
        # 计算订单总价
        pass

    def print_invoice(self): 
        # 打印订单发票
        pass

    def save_to_database(self): 
        # 保存订单到数据库
        pass

class Order:
    def calculate_total(self): 
        pass

class InvoicePrinter:
    def print_invoice(self, order): 
        pass

class OrderRepository:
    def save_to_database(self, order): 
        pass

class AreaCalculator:
    def area(self, shape):
        if isinstance(shape, Rectangle):
            return shape.width * shape.height
        elif isinstance(shape, Circle):
            return 3.14 * shape.radius ** 2

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Rectangle(Shape):
    def area(self):
        return self.width * self.height

class Circle(Shape):
    def area(self):
        return 3.14 * self.radius ** 2

# 新增三角形无需修改 AreaCalculator
class Triangle(Shape):
    def area(self):
        return 0.5 * self.base * self.height

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def set_width(self, width):
        self.width = width

    def set_height(self, height):
        self.height = height

    def area(self):
        return self.width * self.height


class Square(Rectangle):
    def set_width(self, width):
        # 正方形强制将宽和高设为相同值
        self.width = width
        self.height = width

    def set_height(self, height):
        self.width = height
        self.height = height


def resize(shape: Rectangle):
    shape.set_width(5)
    shape.set_height(4)
    assert shape.area() == 20  # 若 shape 是 Square，此处断言失败！


if __name__ == "__main__":
    r = Rectangle(1, 2)
    resize(r)
    print("Rectangle pass")

    s = Square(1, 2)
    resize(s)  # 报错
    print("Square pass")

from abc import ABC, abstractmethod


# 定义抽象基类（接口），约束子类必须实现 set_dimensions 方法
class Shape(ABC):
    @abstractmethod
    def set_dimensions(self, *args):
        pass

    @abstractmethod
    def area(self):
        pass


# 矩形类：支持独立修改宽高
class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def set_dimensions(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height


# 正方形类：通过单一参数修改边长
class Square(Shape):
    def __init__(self, side):
        self.side = side

    def set_dimensions(self, side):
        self.side = side

    def area(self):
        return self.side**2


# 修改后的 resize 函数，明确区分处理逻辑
def resize(shape_type: str, shape: Shape):
    if shape_type == "rectangle":
        shape.set_dimensions(5, 4)  # 矩形设置宽高
        assert shape.area() == 20
    elif shape_type == "square":
        shape.set_dimensions(4)  # 正方形设置边长
        assert shape.area() == 16


if __name__ == "__main__":
    # 矩形测试
    r = Rectangle(1, 2)
    resize("rectangle", r)
    print("Rectangle pass")

    # 正方形测试
    s = Square(1)
    resize("square", s)
    print("Square pass")

class MultiFunctionPrinter:
    def print_document(self):
        pass

    def scan_document(self):
        pass

    def fax_document(self):
        pass

# 普通打印机被迫实现传真功能
class BasicPrinter(MultiFunctionPrinter):
    def fax_document(self):
        raise NotImplementedError("不支持传真！")

class Printer:
    def print_document(self):
        pass

class Scanner:
    def scan_document(self):
        pass

class FaxMachine:
    def fax_document(self):
        pass

class BasicPrinter(Printer):
    pass  # 只需实现打印功能

class LightBulb:
    def turn_on(self):
        print("Light on")

class Switch:
    def __init__(self):
        self.bulb = LightBulb()  # 直接依赖具体类

    def operate(self):
        self.bulb.turn_on()

class SwitchableDevice(ABC):
    @abstractmethod
    def turn_on(self):
        pass

class LightBulb(SwitchableDevice):
    def turn_on(self):
        print("Light on")

class Fan(SwitchableDevice):
    def turn_on(self):
        print("Fan on")

class Switch:
    def __init__(self, device: SwitchableDevice):  # 依赖抽象
        self.device = device

    def operate(self):
        self.device.turn_on()

# 使用
bulb = LightBulb()
switch = Switch(bulb)
switch.operate()