三大特性
面向对象编程（OOP）的三大特性是封装、继承和多态。这些特性共同构成了OOP的基础，使得软件设计更加灵活、可维护和可扩展。
封装
封装的定义
封装是创建对象的过程，这些对象将数据（属性）和行为（方法）组合在一起。封装的目的是：
保护数据：防止对象的内部数据被外部代码直接访问和修改。
提供接口：只允许外部代码通过对象提供的方法来访问和修改数据。
封装的好处
减少耦合：对象之间的依赖关系减少，因为外部代码不直接依赖于内部实现。
提高可维护性：对象的内部实现可以独立于外部代码进行修改，只要接口保持不变。
增强安全性：通过隐藏内部实现，可以防止外部代码意外破坏对象的状态。
封装的实现
class Person:
def __init__(self, name, age, sex, height):
self.name = name
self.__age = age
self.__sex = sex
self.__height = height
# 获取时触发
@property
def height(self):
return self.__height
# 设置时触发
@height.setter
def height(self, height):
if 0 < int(height) < 300:
self.__height = height
else:
print(f"{height} ??? 你看看你还是人吗")
def set_age(self, age):
self.__age = age
def get_age(self):
return self.__age
def __set_sex(self, sex):
if sex in ["男", "女"]:
self.__sex = sex
else:
print("你看看你是森么")
def __get_sex(self):
return self.__sex
# 通过 property 方法 设置私有属性 以达到 即可方便 访问 又可 过滤设置的一些不合法信息 安全的双重保障
sex = property(__get_sex, __set_sex)
def set_name(self, name):
self.name = name
def get_name(self):
return self.name
def __str__(self):
return f'姓名：{self.get_name()} 年龄：{self.get_age()} 性别：{self.__get_sex()}'
# 公有属性 方便调用 相较于 私有属性来说 但容易产生不合法数据
p1 = Person("刘备", 20, "男", 175)
p1.name = "曹操"
# 私有属性只能通过 set get 方法设置或调用 过滤设置的一些不合法信息
p1.set_age(25)
print(p1)
print(p1.sex)
p1.sex = "嘿嘿"
print(p1.sex)
# 装饰器 更方便
print(p1.height)
p1.height = "180"
print(p1.height)
print(p1.height)
p1.height = "520"
print(p1.height)
结论
封装是OOP中的关键概念，它有助于创建模块化、易于维护和安全的代码。通过使用私有属性、属性装饰器、自定义的访问和设置方法，以及__slots__，Python提供了多种机制来实现封装。
继承
继承是面向对象编程（OOP）中的一个基本概念，它允许我们基于现有类创建新类，这种新类称为子类或派生类，而现有的类称为基类或父类。继承是一种代码复用机制，它提供了一种方式来扩展或修改现有类的行为。
继承的基本概念
基类（Base Class）：定义了通用属性和方法的类。
子类（Derived Class）：从基类继承并可能添加或修改属性和方法的类。
派生类（Subclass）：继承自另一个类的类。
超类（Superclass）：被另一个类继承的类。
继承的特点
代码复用：子类可以复用基类的代码，减少重复代码的编写。
扩展性：子类可以扩展基类的功能，添加新的属性和方法。
可维护性：对基类的修改会自动反映到所有子类中，简化了维护工作。
多态性：子类可以重写基类的方法，实现多态性。
继承实现
"""
object 是所有 类 的 父类
子类拥有父类的功能方法
.__class__ 判断 类
.__base__ 类 的 父类
.__bases__ 类 的 父类们
"""
# 单继承
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return f"人 {self.name} {self.age}"
def eat(self):
return print(f'{self.name} eat food')
def sad(self):
return print(f"{self.name}：红红上仙好漂亮")
p = Person("权贵", 20)
print(p)
p.sad()
p.eat()
# Person 子类
class SuperPerson(Person):
def __init__(self, name, age, skill):
super().__init__(name, age)
self.skill = skill
def __str__(self):
return f"超{super().__str__()} 技能 {self.skill}"
def sad(self):
return print(f"{self.name}：红红好漂亮")
def work(self):
return print(f"{self.name} 修炼")
sp = SuperPerson("月初", 999, "虚空之泪")
print(sp)
sp.sad()
sp.work()
class SuperMan(Person):
def __init__(self, name, age, sex):
super().__init__(name, age)
self.sex = sex
sm = SuperMan('光头强', 20, "男")
print(sm)
# 多继承
class MoveAble:
def __init__(self, speed):
self.speed = speed
def move(self):
return print(f"{self.speed} km/h")
class EatAble:
def __init__(self, eat):
self.eat = eat
def eat_good(self):
return print(f"{self.eat} lead me strong")
def __str__(self):
return f"EarAble 类"
class Attack:
def __init__(self, ack):
self.ack = ack
class Person(MoveAble, EatAble):
def __init__(self, name, speed, eat):
self.name = name
MoveAble.__init__(self, speed)
EatAble.__init__(self, eat)
def sad(self):
return print(f"{self.name} have {self.speed} km/h go to eat {self.eat} ")
def __str__(self):
return f"Person 类"
p = Person("aa", 30, "炒鸡")
p.sad()
p.eat_good()
p.move()
e = EatAble("炒鸡")
e.eat_good()
class PersonSon(Person, Attack):
def __init__(self, name, speed, eat, ack):
Person.__init__(self, name, speed, eat)
Attack.__init__(self, ack)
def __str__(self):
return f'{self.name} {self.eat} milk'
ps = PersonSon("海尔", 1, "eat", "100")
print(ps)
# 多继承 mro()：method(方法) retrieval(检索) order(顺序)
# Method Resolution Order，简称MRO
# Python3 使用 C3线性化算法
# 通过一个类的.__mro__属性或者.mro()方法来查看类的MRO
print(PersonSon.mro())
多态
多态的定义
多态性意味着“多种形式”。在编程中，多态性主要体现在以下几个方面：
编译时多态：通过函数重载（在某些语言中）实现，即同一个函数名可以有多个实现，根据不同的参数类型来调用不同的版本 python通过*args 形参来实现
运行时多态：通过方法重写（子类重写父类的方法）和动态绑定实现，即在运行时根据对象的实际类型来调用相应的方法。
多态的好处
提高代码的灵活性：可以使用统一的接口来处理不同类型的对象。
减少代码冗余：避免了为每种类型编写特定的代码。
提高代码的可扩展性：新增对象类型时，不需要修改现有的代码，只需要确保它们遵循相同的接口。
多态实现
class Animal:
def walk(self):
print("走")
class Cat(Animal):
def walk(self):
print("窜来窜去")
class Chicken(Animal):
def walk(self, speed):
speed = speed
print("唱跳rap", speed)
def attack(self, *args):
return print(*args)
# 父子类多态，函数名参数都相同，但是实现不同
c = Chicken()
c.walk(2.5)
# 通过*args实现
c.attack("击 击 击 ")
c.attack("坤拳", "铁山靠")
结论
多态是OOP中的一个重要特性，它提高了代码的灵活性和可扩展性。在Python中，多态性主要通过方法重写和动态绑定实现，这使得我们可以使用统一的接口来处理不同类型的对象。鸭子类型的概念进一步强化了Python中多态性的应用，使得我们更加关注对象的行为而非类型。
四、结语
面向对象编程是一种强大的工具，它可以帮助我们以一种更加模块化和可重用的方式来构建软件。Python的OOP特性使得它成为实现面向对象设计的优选语言之一。通过掌握类、继承、封装和多态，你可以编写更加灵活和可维护的代码。
