面向对象概念 ¶

class Animal:
    # Animal类的构造方法（也称为初始化方法），用于在创建类的实例时初始化对象的状态。
    # self代表新创建的Animal实例，name是传递给构造方法的参数。
    def __init__(self, name):
        self.name = name

    # 抽象方法，用于定义动物的发声行为。
    # 它在基类中没有具体实现，而是要求派生类提供具体的实现。
    # self表示调用speak方法的Animal实例。
    def speak(self):
        raise NotImplementedError("Subclasses must implement this method")


class Dog(Animal):
    # Dog类对speak方法的实现，用于返回狗的叫声。
    # self表示调用speak方法的Dog实例。
    def speak(self):
        return "Woof!"


class Cat(Animal):
    def speak(self):
        return "Meow!"


# 创建类的实例
dog = Dog("Buddy")
cat = Cat("Whiskers")

# 调用实例的方法
print(dog.speak())  # Woof!
print(cat.speak())  # Meow!

import sys

# 创建一个列表对象
my_list = [1, 2, 3]

# 创建别名
another_list = my_list

# 修改对象
another_list.append(4)

# 打印两个名称引用的对象
print(my_list)       # [1, 2, 3, 4]
print(another_list)  # [1, 2, 3, 4]

# 查看对象的引用计数
ref_count = sys.getrefcount(my_list)
print(f"Reference count of my_list: {ref_count}")
# 3

# 全局命名空间
x = 10  # 全局变量

def foo():
    # 局部命名空间
    y = 20  # 局部变量
    print(x, y)  # 访问全局变量和局部变量

foo()  # 10 20

x = 10  # 全局作用域

def outer():
    y = 20  # 外层函数作用域

    def inner():
        z = 30  # 局部作用域
        print(x, y, z)  # 访问全局、外层和局部变量

    inner()

outer()  # 10 20 30

x = 10  # 全局变量

def outer():
    y = 20  # 外层函数变量

    def inner():
        nonlocal y  # 修改外层函数变量
        global x    # 修改全局变量
        y += 1
        x += 1
        print(x, y)

    inner()

outer()  # 11 21

x = 10  # 全局命名空间

def foo():
    y = 20  # 局部命名空间
    print(x, y)  # 访问全局和局部命名空间

foo()  # 10 20

def foo():
    x = 10  # 局部变量
    print(x)

foo()  # 10

spam = "spam out of func"  # 全局变量

def scope_test():
    spam = "test spam"  # 外层函数变量

    def do_local():
        spam = "local spam"  # 局部变量

    def do_nonlocal():
        nonlocal spam  # 修改外层函数变量
        spam = "nonlocal spam"

    def do_global():
        global spam  # 修改全局变量
        spam = "global spam"

    do_local()
    print("After local assignment:", spam)
    do_nonlocal()
    print("After nonlocal assignment:", spam)
    do_global()
    print("After global assignment:", spam)


scope_test()
print("In global scope:", spam)
# After local assignment: test spam
# After nonlocal assignment: nonlocal spam
# After global assignment: nonlocal spam
# In global scope: global spam

class ClassName:
    <statement-1>
    ...
    <statement-N>

class MyClass:
    i = 12345 # 类变量（类属性）

    # 构造方法，用于初始化类的实例
    def __init__(self, name, data):
        self.name = name  # 实例属性
        self.data = []  # 实例属性

    # 实例方法
    def append(self, value):
        self.data.append(value)

    # 实例方法
    def get_name(self):
        return self.name


# 类对象属性引用
print(MyClass.i)  # 12345
# 类对象属性被赋值
MyClass.i = 10
print(MyClass.i)
# 10

# 实例方法的引用
print(MyClass.append)  # <function MyClass.f at 0x73904bbe79a0>

# 类MyClass实例化
obj = MyClass("Example", None)
print(obj.data) # []

# 修改类变量
obj.i = 321
print(obj.i)  
# 100

# 使用实例方法 append 向 data 属性中添加数据
obj.append(10)
obj.append(20)

# 访问实例属性
print(obj.name)  # Eobjample
print(obj.data)  # [10, 20]

# 动态添加实例变量
obj.counter = 1
print(obj.counter)  # 1
obj.counter += 1
print(obj.counter)  # 2

obj = MyClass("Example", [])
obj.append(10)  # 正确的实例方法调用

def __init__(self, name, data):
    self.name = name
    self.data = []

def __str__(self):
    return f"MyClass(name={self.name}, data={self.data})"

def __repr__(self):
    return f"MyClass(name={self.name!r}, data={self.data!r})"

def __len__(self):
    return len(self.data)

def __getitem__(self, index):
    return self.data[index]

def __setitem__(self, index, value):
    self.data[index] = value

class MyClass:
    i = 12345  # 类变量

    def __init__(self, name, data):
        self.name = name  # 实例变量
        self.data = []  # 实例变量

    def append(self, value):
        self.data.append(value)

    def get_name(self):
        return self.name

    def __str__(self):
        return f"MyClass(name={self.name}, data={self.data})"

    def __repr__(self):
        return f"MyClass(name={self.name!r}, data={self.data!r})"

    def __len__(self):
        return len(self.data)

    def __getitem__(self, index):
        return self.data[index]

    def __setitem__(self, index, value):
        self.data[index] = value

# 创建 MyClass 的一个实例
obj = MyClass("Example", None)

# 使用实例方法 append 向 data 属性中添加数据
obj.append(10)
obj.append(20)

# 访问实例属性
print(obj.name)  # Example
print(obj.data)  # [10, 20]

# 使用魔术方法 __str__ 和 __repr__
print(obj)  # MyClass(name=Example, data=[10, 20])
print(repr(obj))  # MyClass(name='Example', data=[10, 20])

# 使用魔术方法 __len__
print(len(obj))  # 2

# 使用魔术方法 __getitem__ 和 __setitem__
print(obj[0])  # 10
obj[1] = 30
print(obj.data)  # [10, 30]

class MyClass:
    def __init__(self, value):
        self.value = value

    def __eq__(self, other):
        if isinstance(other, MyClass):
            return self.value == other.value
        return NotImplemented

    def __ne__(self, other):
        return not self.__eq__(other)

    def __lt__(self, other):
        if isinstance(other, MyClass):
            return self.value < other.value
        return NotImplemented

    def __le__(self, other):
        return self.__lt__(other) or self.__eq__(other)

    def __gt__(self, other):
        return not self.__le__(other)

    def __ge__(self, other):
        return not self.__lt__(other)

class MyClass:
    def __init__(self, value):
        self.value = value

    def __add__(self, other):
        if isinstance(other, MyClass):
            return MyClass(self.value + other.value)
        return NotImplemented

    def __sub__(self, other):
        if isinstance(other, MyClass):
            return MyClass(self.value - other.value)
        return NotImplemented

    def __mul__(self, other):
        if isinstance(other, MyClass):
            return MyClass(self.value * other.value)
        return NotImplemented

    def __truediv__(self, other):
        if isinstance(other, MyClass):
            if other.value == 0:
                raise ZeroDivisionError("division by zero")
            return MyClass(self.value / other.value)
        return NotImplemented

    def __floordiv__(self, other):
        if isinstance(other, MyClass):
            if other.value == 0:
                raise ZeroDivisionError("division by zero")
            return MyClass(self.value // other.value)
        return NotImplemented

    def __mod__(self, other):
        if isinstance(other, MyClass):
            if other.value == 0:
                raise ZeroDivisionError("division by zero")
            return MyClass(self.value % other.value)
        return NotImplemented

class MyClass:
    def __init__(self, value):
        self.value = value

    def __radd__(self, other):
        if isinstance(other, (int, float)):
            return MyClass(other + self.value)
        return NotImplemented

    def __rsub__(self, other):
        if isinstance(other, (int, float)):
            return MyClass(other - self.value)
        return NotImplemented

    def __rmul__(self, other):
        if isinstance(other, (int, float)):
            return MyClass(other * self.value)
        return NotImplemented

    def __rtruediv__(self, other):
        if isinstance(other, (int, float)):
            if self.value == 0:
                raise ZeroDivisionError("division by zero")
            return MyClass(other / self.value)
        return NotImplemented

    def __rfloordiv__(self, other):
        if isinstance(other, (int, float)):
            if self.value == 0:
                raise ZeroDivisionError("division by zero")
            return MyClass(other // self.value)
        return NotImplemented

    def __rmod__(self, other):
        if isinstance(other, (int, float)):
            if self.value == 0:
                raise ZeroDivisionError("division by zero")
            return MyClass(other % self.value)
        return NotImplemented

class MyClass:
    def __init__(self, value):
        self.value = value

    def __iadd__(self, other):
        if isinstance(other, MyClass):
            self.value += other.value
            return self
        return NotImplemented

    def __isub__(self, other):
        if isinstance(other, MyClass):
            self.value -= other.value
            return self
        return NotImplemented

    def __imul__(self, other):
        if isinstance(other, MyClass):
            self.value *= other.value
            return self
        return NotImplemented

    def __itruediv__(self, other):
        if isinstance(other, MyClass):
            if other.value == 0:
                raise ZeroDivisionError("division by zero")
            self.value /= other.value
            return self
        return NotImplemented

    def __ifloordiv__(self, other):
        if isinstance(other, MyClass):
            if other.value == 0:
                raise ZeroDivisionError("division by zero")
            self.value //= other.value
            return self
        return NotImplemented

    def __imod__(self, other):
        if isinstance(other, MyClass):
            if other.value == 0:
                raise ZeroDivisionError("division by zero")
            self.value %= other.value
            return self
        return NotImplemented

class MyClass:
    def __init__(self, value):
        self.value = value

    def __bool__(self):
        return self.value != 0

    def __len__(self):
        return len(self.value) if isinstance(self.value, (list, tuple, str)) else 0

class MyClass:
    def __init__(self, data):
        self.data = data

    def __iter__(self):
        self.index = 0
        return self

    def __next__(self):
        if self.index < len(self.data):
            result = self.data[self.index]
            self.index += 1
            return result
        else:
            raise StopIteration

    def __getitem__(self, key):
        return self.data[key]

    def __setitem__(self, key, value):
        self.data[key] = value

    def __delitem__(self, key):
        del self.data[key]

class MyClass:
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return f"MyClass(value={self.value})"

    def __add__(self, other):
        if isinstance(other, MyClass):
            return MyClass(self.value + other.value)
        return NotImplemented

    def __len__(self):
        return len(str(self.value))

    def my_method(self):
        """This is a method that does something."""
        return self.value * 2

print(MyClass.my_method.__name__)  # 输出: my_method

print(MyClass.my_method.__doc__)  # 输出: This is a method that does something.

import inspect

# 列出 MyClass 的所有成员
members = inspect.getmembers(MyClass)
for name, member in members:
    print(f"{name}: {member}")

# 获取 my_method 的签名
signature = inspect.signature(MyClass.my_method)
print(signature)  # 输出: (self)

print(dir(MyClass))  # 输出: ['__add__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'my_method']

print(type(MyClass.my_method))  # 输出: <class 'function'>

print(callable(MyClass.my_method))  # 输出: True

class MyClass:
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return f"MyClass(value={self.value})"

    def __add__(self, other):
        if isinstance(other, MyClass):
            return MyClass(self.value + other.value)
        return NotImplemented

    def __len__(self):
        return len(str(self.value))

    def my_method(self):
        """This is a method that does something."""
        return self.value * 2

# 创建对象
obj = MyClass(10)

# 反射：动态获取属性
value = getattr(obj, 'value')
print(value)  # 输出: 10

# 反射：动态调用方法
method = getattr(obj, 'my_method')
print(method())  # 输出: 20

# 反射：动态设置属性
setattr(obj, 'value', 20)
print(obj.value)  # 输出: 20

# 反射：动态检查属性是否存在
print(hasattr(obj, 'value'))  # 输出: True
print(hasattr(obj, 'non_existent'))  # 输出: False

# 内省：获取对象的属性和方法列表
print(dir(obj))
# 输出: ['__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__len__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'my_method', 'value']

# 内省：获取方法的文档字符串
print(obj.my_method.__doc__)
# 输出: This is a method that does something.

# 内省：获取方法的参数信息（使用 inspect 模块）
from inspect import signature
sig = signature(obj.my_method)
print(sig)
# 输出: (self)

class StandfordProfessor(object):
    university = 'Standford'

    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

    def display(self):
        print(f'Professor {self.name} says welcome to {self.university}!')

professor = StandfordProfessor('Tom', 'Male')

print(type(StandfordProfessor))
# <class 'type'>

class Mymeta(type):

    def __call__(self, *args, **kwargs):
        print(self)  # 类名
        print(args)  # 输入参数
        print(kwargs)  # 输入参数
        return 10086


class StandfordProfessor(object, metaclass=Mymeta):
    university = "Standford"

    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

    def display(self):
        print(f"Professor {self.name} says welcome to {self.university}!")


professor = StandfordProfessor("Tom", "Male")
# <class '__main__.StandfordProfessor'>
# ('Tom', 'Male')
# {}

professor = StandfordProfessor("Tom", "Male", age=30, title="Professor")
# <class '__main__.StandfordProfessor'>
# ('Tom', 'Male')
# {'age': 30, 'title': 'Professor'}

class Mymeta(type):

    def __init__(self, class_name, class_bases, class_dic):
        super(Mymeta, self).__init__(class_name, class_bases, class_dic)

        if class_name.islower():
            raise TypeError(f'Please follow Camel-Case to change class name {class_name}')
        if '__doc__' not in class_dic or len(class_dic['__doc__'].strip(' \n')) == 0:
            raise TypeError('Please add documentation in class {class_name}, which is mandatory.')


class StandfordProfessor(object, metaclass=Mymeta):
    """
    Documentation of class StanfordTeacher
    """

    university = 'Standford'

    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

    def display(self):
        print(f'Professor {self.name} says welcome to {self.university}!')


professor = StandfordProfessor('Tom', 'Male')

professor.display()
# Professor Tom says welcome to Standford!

print(professor.__dict__)
# {'name': 'Tom', 'gender': 'Male'}

StandfordProfessor.mro()
# [<class '__main__.StandfordProfessor'>, <class 'object'>]

from math import hypot

# 计算两点 `p1` 和 `p2` 之间的欧几里得距离
def distance(p1, p2):
    return hypot(p2[0] - p1[0], p2[1] - p1[1])

# 计算多边形的周长
def perimeter(polygon):
    # 生成顶点对（确保多边形闭合）
    pairs = zip(polygon, polygon[1:] + polygon[:1])
    # 计算每对顶点之间的距离并求和
    return sum(distance(p1, p2) for p1, p2 in pairs)


if __name__ == "__main__":
    # 计算多边形周长
    square = [(1, 1), (1, 2), (2, 2), (2, 1)]
    print(perimeter(square))  # 输出: 4.0
    # 计算三角形的周长
    triangle = [(0, 0), (1, 0), (0.5, 1)]
    print(perimeter(triangle))  # # 输出: 3.236...

from math import hypot

# 定义类型别名，增强代码可读性
Point = tuple[float, float]  # 点的坐标类型
Polygon = list[Point]        # 多边形的顶点列表类型

# 计算两点 `p1` 和 `p2` 之间的欧几里得距离
def distance(p1: Point, p2: Point) -> float:
    return hypot(p2[0] - p1[0], p2[1] - p1[1])

# 计算多边形的周长
def perimeter(polygon: Polygon) -> float:
    # 生成顶点对（确保多边形闭合）
    pairs = zip(polygon, polygon[1:] + polygon[:1])
    # 计算每对顶点之间的距离并求和
    return sum(distance(p1, p2) for p1, p2 in pairs)

if __name__ == "__main__":
    # 定义正方形的顶点
    square: Polygon = [(1, 1), (1, 2), (2, 2), (2, 1)]
    print(perimeter(square))  # 输出: 4.0

    # 定义三角形的顶点
    triangle: Polygon = [(0, 0), (1, 0), (0.5, 1)]
    print(perimeter(triangle))  # 输出: 3.236...

from math import hypot
from typing import List


class Point:
    def __init__(self, x: float, y: float) -> None:
        self.x = x
        self.y = y

    # 计算当前点与另一个点之间的欧几里得距离
    def distance(self, other: "Point") -> float:
        return hypot(self.x - other.x, self.y - other.y)

    # 重定义__repr__，用以输出点的坐标
    def __repr__(self):
        return f"({self.x}, {self.y})"


class Polygon:
    def __init__(self) -> None:
        self.vertices: List[Point] = []  # 初始化顶点列表为空列表

    # 向多边形中添加一个顶点
    def add_point(self, point: Point) -> None:
        self.vertices.append(point)  # 将点添加到顶点列表中

    # 计算多边形的周长
    def perimeter(self) -> float:
        # 创建一个迭代器，将顶点列表与其自身偏移一个位置的列表配对
        pairs = zip(self.vertices, self.vertices[1:] + self.vertices[:1])
        # 计算每对顶点之间的距离并求和
        return sum(p1.distance(p2) for p1, p2 in pairs)


if __name__ == "__main__":
    # 定义一个正方形的顶点
    square = Polygon()
    square.add_point(Point(1, 1))  # 添加第一个顶点
    square.add_point(Point(1, 2))  # 添加第二个顶点
    square.add_point(Point(2, 2))  # 添加第三个顶点
    square.add_point(Point(2, 1))  # 添加第四个顶点
    print(square.perimeter())  # 输出正方形的周长，结果是 4.0
    print(square.vertices)  # 输出正方形的顶点列表，结果是 [(1, 1), (1, 2), (2, 2), (2, 1)]

from math import hypot
from typing import List, Optional, Iterable


class Point:
    def __init__(self, x: float, y: float) -> None:
        self.x = x
        self.y = y

    # 计算当前点与另一个点之间的欧几里得距离
    def distance(self, other: "Point") -> float:
        return hypot(self.x - other.x, self.y - other.y)

    # 重定义__repr__，用以输出点的坐标
    def __repr__(self):
        return f"({self.x}, {self.y})"


class Polygon_2:
    def __init__(self, vertices: Optional[Iterable[Point]]) -> None:
        self.vertices = list(vertices) if vertices else []

    def perimeter(self) -> float:
        # 创建一个迭代器，将顶点列表与其自身偏移一个位置的列表配对
        pairs = zip(self.vertices, self.vertices[1:] + self.vertices[:1])
        # 计算每对顶点之间的距离并求和
        return sum(p1.distance(p2) for p1, p2 in pairs)


if __name__ == "__main__":
    # 定义一个正方形的顶点
    square = Polygon_2([Point(1, 1), Point(1, 2), Point(2, 2), Point(2, 1)])
    print(square.perimeter())  # 输出正方形的周长，结果是 4.0
    print(square.vertices)  # 输出正方形的顶点列表，结果是 [(1, 1), (1, 2), (2, 2), (2, 1)]

from math import hypot
from typing import List, Optional, Iterable, Union, Tuple

Pair = Tuple[float, float]
Point_or_Tuple = Union["Point", Pair]


class Point:
    def __init__(self, x: float, y: float) -> None:
        self.x = x
        self.y = y

    # 计算当前点与另一个点之间的欧几里得距离
    def distance(self, other: "Point") -> float:
        return hypot(self.x - other.x, self.y - other.y)

    # 重定义__repr__，用以输出点的坐标
    def __repr__(self):
        return f"({self.x}, {self.y})"


class Polygon_3:
    def __init__(self, vertices: Optional[Iterable[Point_or_Tuple]]) -> None:
        self.vertices: list[Point] = []
        if vertices:
            for Point_or_Tuple in vertices:
                self.vertices.append(self.make_point(Point_or_Tuple))

    @staticmethod
    def make_point(item: Point_or_Tuple) -> Point:
        return item if isinstance(item, Point) else Point(*item)

    def perimeter(self) -> float:
        pairs = zip(self.vertices, self.vertices[1:] + self.vertices[:1])
        return sum(p1.distance(p2) for p1, p2 in pairs)


if __name__ == "__main__":
    # 定义一个正方形的顶点，使用元组格式
    square = Polygon_3([(1, 1), (1, 2), (2, 2), (2, 1)])
    print(square.perimeter())  # 输出正方形的周长，结果是 4.0
    print(square.vertices)  # 输出正方形的顶点列表，结果是 ['(1, 1)', '(1, 2)', '(2, 2)', '(2, 1)']