Python面向对象编程全攻略

Python面向对象一文精通

面向对象与面向过程对比

面向过程：以函数为中心，强调步骤和逻辑顺寻，适合一些简单的任务。

面型对象：以类和对象为中心，强调数据和行为的封装，适合复杂系统开发

面向过程以步骤为中心，注重流程和函数调用，适合简单逻辑。面向对象以对象为中心，强调数据和行为的封装，适合复杂系统设计。面向对象通过类和对象组织代码，提高复用性和可维护性。

类与实例

类是对象的蓝图，封装、定义了属性和方法。

实例是类的具体对象，拥有独立（类中所有）的数据。

通过class关键字定义类，__init__方法初始化实例属性：

class Person:
def __init__(self, name):
self.name = name
person = Person("zsh")

其中person为class Person类的实例对象

魔法函数汇总

魔法函数以双下划线命名，用于定制类行为。常见魔法函数：

__str__：定义对象的字符串表示

__len__：返回对象长度

__getitem__：支持索引访问

__eq__(self, other)：重载 == 运算符。

__ne__(self, other)：重载 != 运算符。

__lt__(self, other)：重载 < 运算符。

__gt__(self, other)：重载 > 运算符。

__le__(self, other)：重载 <= 运算符。

__ge__(self, other)：重载 >= 运算符。

__add__(self, other)：重载 + 运算符。

__sub__(self, other)：重载 – 运算符。

__mul__(self, other)：重载 * 运算符。

__truediv__(self, other)：重载 / 运算符（Python 3 除法）。

__floordiv__(self, other)：重载 // 运算符（地板除）。

__mod__(self, other)：重载 % 运算符（取模）。

__pow__(self, other[, modulo])：重载 ** 运算符（幂运算）。

重新定义运算、比较魔法函数：

class Person:
def __init__(self, name, age):
# print("__init__")
self.name = name
self.age = age

def __str__(self):
return "person"

def __repr__(self):
return "Person()"

def __gt__(self, other):
"""
比较大小 grate than
"""
return self.age > other.age

def __lt__(self, other):
"""
less than
"""
return self.age < other.age

def __ge__(self, other):
"""
grate equal
"""
return self.age >= other.age

def __le__(self, other):
"""
less equal
"""
return self.age <= other.age

def __eq__(self, other):
"""
equal
"""
return self.age == other.age

def __ne__(self, other):
"""
not equal
"""
return self.age != other.age

def __add__(self, other):
return self.age + other.age

def __sub__(self, other):
return self.age – other.age

def __mul__(self, other):
return self.age * other.age

def __truediv__(self, other):
return self.age / other.age

def __floordiv__(self, other):
return self.age // other.age

def __pow__(self, power):
return self.age ** power.age

def __mod__(self, other):
return self.age % other.age

p1 = Person("小明", 30)
p2 = Person("马云", 4)

print(p1 + p2)
print(p1 – p2)
print(p1 * p2)
print(p1 ** p2)
print(p1 / p2)
print(p1 // p2)
print(p1 % p2)

# print(p2 > p1)
# print(p1 < p2)
# print(p1 <= p2)
# print(p1 >= p2)
# print(p1 == p2)
# print(p1 != p2)

# print(int(10) > int(20))

# datas = [p2, p1]
# datas.sort()
# print(datas)

上下文管理：

__enter__(self)：定义 with 语句进入时的操作。

__exit__(self, exc_type, exc_val, exc_tb)：定义 with 语句退出时的操作。

class Timer:
def __enter__(self):
self.start = time.time()
return self

def __exit__(self, exc_type, exc_val, exc_tb):
end = time.time()
print(end – self.start)

封装

封装隐藏对象内部细节，通过公有方法暴露接口。使用单下划线_表示受保护成员，双下划线__表示私有成员：

# 类封装数据 name 以及 操作数据的方法 get_name set_name
class Person:
def __init__(self, name):
print(f"初始化函数执行了")
self.name = name
print(f"初始化完成", self.name)

def set_name(self, name):
"""
方式二： 在类内 封装 修改实例数据的方法
"""
self.name = name

def get_name(self):
return self.name

p1 = Person("张三")
print(p1.name)

继承

子类继承父类属性和方法，实现代码复用。通过super()调用父类方法：

class Point:
def __init__(self, x, y):
self.x = x
self.y = y

def show(self):
return self.x, self.y

class Circle(Point):
def __init__(self,x,y, radius):
super().__init__(x,y)
self.radius = radius

def show(self):
return f'圆心（{self.x}, {self.y}）,半径：{self.radius}'

class Rectangle(Point):
def __init__(self,x,y, width, height):
super().__init__(x,y)
self.width = width
self.height = height

def show(self):
return f'原点（{super().show()}） 长{self.height} 宽{self.width}'

p = Point(66,666)
print(p.show())

c = Circle(6,6,666)
print(c.show())

r = Rectangle(6,6,666,666)
print(r.show())

多态

不同类对象对相同方法调用表现出不同行为。通过方法重写实现：

class Person:

def say(self, *args):
print(args)

p = Person()
p.say("哈喽")

class SuperPerson(Person):
def say(self, msg):
print(msg)

sp = SuperPerson()
sp.say("哈喽")

多继承

类可继承多个父类，方法解析顺序(优先级从左向右变低)决定调用顺序：

class Person:
def __init__(self,name,age):
self.name=name
self.age=age

def walk(self):
print("走")

def __str__(self):
return f"{self.name} {self.age}"

class Flyer:
def __init__(self,speed):
self.speed=speed

def fly(self):
print(f"飞行{self.speed}")

def __str__(self):
return f"{self.speed}"

class SuperMen(Person,Flyer):
def __init__(self,name,age,speed):
Person.__init__(self,name,age)
Flyer.__init__(self,speed)

sp = SuperMen("xdd",26,360)
sp.walk()
sp.fly()

抽象类

包含抽象方法的类不能实例化，需子类实现所有抽象方法：

抽象类必须继承ABC,抽象方法必须加装饰器 @abstractmethod

class Shape(ABC):
@abstractmethod
def area(self,*args,**kwargs):
pass

@abstractmethod
def perimeter(self,*args,**kwargs):
pass

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

def perimeter(self):
return (self.width+self.height)*2

class Circle(Shape):
def __init__(self,r):
self.r = r
def area(self):
return self.r**2*math.pi

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

rectangle = Rectangle(10, 66)
print(rectangle.area())
print(rectangle.perimeter())

circle = Circle(66)
print(circle.area())
print(circle.perimeter())

枚举类

定义一组命名常量，提高代码可读性：

枚举罗列所有可能性,

枚举类必须继承Enum

from enum import Enum

class GameState(Enum):
Ready = "准备"
Gaming = "游戏中"
End = "结算"

state = GameState.Ready

while True:
option = input("输入数字")
if option == "1" and state == GameState.Ready:
state = GameState.Gaming
print(f"进入游戏")
elif option == "2" and state == GameState.Gaming:
state = GameState.End
print(f"正在结算")
elif option == "3" and state == GameState.End:
state = GameState.Ready
print(f"准备中")

数据的访问级别

Python通过命名约定实现访问控制：

• 公有成员：无前缀，正常命名变量名 类内和类外和子类都能够访问
• 受保护成员：_前缀(单下划线) ，类内和子类能过访问修改，类外也可以，但不推荐。
• 私有成员：__前缀(双下划线) 私有成员，只有在类内访问使用

4个Attr函数

动态属性访问控制：

 __getattr__：访问不存在的属性时调用

 __setattr__：设置属性时调用

 __delattr__：删除属性时调用

 __getattribute__：访问任何属性时调用

class Person:
MAX_AGE = 300

@classmethod
def get_info(cls):
return cls.__name__

@staticmethod
def get_max(a, b):
return a if a > b else b

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

def get_name(self):
return self.name
p = Person("张三")
print(hasattr(p, "name"), hasattr(p, "get_name"))
print(hasattr(p, "MAX_AGE"), hasattr(Person, "MAX_AGE"))
print(hasattr(p, "get_info"), hasattr(Person, "get_info"))
print(hasattr(p, "get_max"), hasattr(Person, "get_max"))

实例中有 实例数据 实例方法 类属性 类方法 静态方法
类中有 实例方法 类属性 类方法 静态方法

setattr(Person, "NAME_LENGTH", 10)
print(hasattr(Person, "NAME_LENGTH"))
print(getattr(Person, "NAME_LENGTH"))
delattr(Person, "NAME_LENGTH")
print(hasattr(Person, "NAME_LENGTH"))

hasattr(Person, "say_hello")
setattr(Person, "say_hello", lambda :print("哈喽"))
print(hasattr(Person, "say_hello"))

r = getattr(Person, "say_hello")
r()

类中成员

类的成员： 类中都可以编写那些那内容

属性：

        实例属性：实例中拥有的数据

        类属性： 直接定义在类中，属于类，通过类名获取和修改

        实例可以获取类属性，但不能修改类属性

方法：

        实例方法：实例中拥有的方法 第一个形参是self

        类方法：属于类 一般获取类属性（类名、类注释、父……）

                第一个形参cls（完全等同于类） 必须带有装饰器 @classmethod

        静态方法：属于类， 对参数没有要求 必须有装饰器 @staticmethod

                一般用于作用类，封装一些操作方法

类成员属于类本身，所有实例共享：

class Game:
"""
游戏
"""
level = 66
def __init__(self,name):
self.name = name

def getname(self):
return self.name

def play(self):
return f' {self.getname()} {self.level}'
@classmethod
def get_game_msg(cls):
return {
"doc":cls.__doc__,
"class":cls,
"bases":cls.__bases__,
}
@staticmethod
def running():
print("ing")
game = Game("cs")
print(game.play())

Game.level = 666
print(game.play())

print(Game.get_game_msg())

动态添加类成员

运行时可为类或实例添加属性和方法：

import types

class Person:
NAME_LENGTH_MAX = 10

@staticmethod
def say_hello(msg):
print(msg)

@classmethod
def get_info(cls):
return {
"name": cls.__name__,
"bases": cls.__bases__
}

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

def get_name(self):
return self.name

p = Person("张三")
p2 = Person("李四")
print(p.name, p.get_name())
# 动态添加实例数据 其他实例不受影响
p.age = 20
print(p.age)

# p.get_age = lambda self:self.age
# p.get_age(p)

# 动态添加实例方法
# p.get_age = types.MethodType(lambda self: self.age, p)

def get_age6666(self):
return self.age
p.get_age = types.MethodType(get_age6666, p)

print(p.get_age())

# 类属性 直接添加
Person.MAX_AGE = 100
print(Person.MAX_AGE, p.MAX_AGE, p2.MAX_AGE)

@classmethod
def get_info(cls):
return cls.__name__

# 类方法 直接添加 添加的方法需要有装饰器和cls参数
Person.get_info = get_info

print(Person.get_info())

@staticmethod
def get_max(a, b):
return a if a > b else b

# 静态方法 直接添加 添加的方法需要有装饰器 对参数没要求
Person.get_max = get_max

print(Person.get_max(10, 50), p.get_max(10, 60))