python私有化,import,封装,继承,多态

本文深入讲解面向对象编程的三大特性:封装、继承和多态。通过具体实例演示如何使用Python实现这些特性,包括类的定义、方法重写及多态应用。

 

 

封装就是拿面向过程的全局变量和函数搞成面向对象中类的属性和方法。

继承:减少代码重复量。减少代码的冗余。

多态就是一个子类继承了父类。但是每一个子类中都可以改写父类的方法。比如A子类改写了父类的C方法,B子类也改写了父类的C方法。那么再把改了父类C方法的子类传到H类中,在H类中调用这两个子类的C方法得到的结果就会不一样。但是调用父类其他方法还是得到的结果还是一样的。多态概括起来就是一个函数有多种形态,如上面说的父类的C方法。可以是A子类的C方法

也可以是B子类的C方法,也可以是它自己的C方法。这样一个方法在不同的情况下就有多种形态了。

 

python里面没有重载,只有重写。重载的意思是调用的函数名一样,但是传的实参不一样,得到的结果也会不一样。

python里面不允许函数重名,所以没有重载。但是可以对父类的函数进行重写。

 

#_author:'DJS'
#date:2018-12-10
#import xxx  然后用xxx里面的方法,xxx.sss,xxx.sss=[x,c,d] 可以在当前文件和xxx模块里面改变sss的值(自己写的模块或者.py文件)
#from xxx import sss   然后用xxx里面的方法,sss=[x,c,d],这样的话只能改变当前文件sss变量的值
#改变不了xxx模块里面sss的值 ssss是一个列表。sss.append()那么可以往模块里面添加值

import sys
from imp import reload
reload(sys)#表示的是重新加载模块,导入模块的时候有时候导入不进来就重新加载。
#可以实时加载模块里面修改的代码,必须import xxx这种方式导入的才可以用,from那种不可以。先导入再加载
print(sys.path) #查看导入模块的先后路径

class huwei():
    #huuwei操作系统
    def __init__(self,name):
        self.name = name
        self.apps = []  #安装的应用程序的名称列表

    def __str__(self): #魔法方法,魔法方法都是实例化对象就会自动执行的
        return "%s 安装软件列表为 %s" %(self.name,str(self.apps))

    def install_app(self,app):
        #判断是否安装了软件
        if app.name in self.apps:
            print("已经安装了%s无需再次安装"% app.name) #__str__打印类的时候就会出来
        else:
            app.install()
            self.apps.append(app.name)

class App():
    def __init__(self,name,version,desc):
        self.name = name
        self.version = version
        self.desc = desc

    def __str__(self):
        return "%s 的版本是 %s-%s" %(self.name,self.version,self.desc)

    def install(self): #多态主要体现在这里,重写父类的install方法
        print("将 %s [%s] 的执行程序复制到软件目录..." %(self.name,self.version))

class Pycharm(App):
    pass

class Chrome(App):
    def install(self):
        print("正在解压安装程序...")
        super().install()

czxt = huwei("华为操作系统")
# print(czxt)
pycharm = Pycharm("PyCharm","1.0","python 开发的IDE环境")
chrome = Chrome("Chrome","70.0","谷歌浏览器")

czxt.install_app(pycharm) #调用czxt里面的install_app方法再传入参数,类中那些魔法方法会自动执行。
##传参的时候如果是个实例化对象,则是先执行实例化对象里面的方法,在执行被传参的函数。
czxt.install_app(chrome)
czxt.install_app(chrome)

print(czxt)

## 参数,*args,*kwargs ,python中有*的表示python解析器会特殊对待对待

def tests(a,b,*args,**kwargs): #,*args,*kwargs
    print(a)
    print(b)
    print(args)
    print(kwargs)
tests(22,33,44,66,77)

##property属性

class Good():

    @property
    def size(self): #这里面只能传递一个参数,多的话就会报错
        return 100

ret = Good()
ret = ret.size#调用属性  #property的目的是让代码的可读性更高,这里可以直接看做为调用一个属性
#而不是一个方法的返回值
print(ret)

class Good():
    #python3默认继承object类,所以在python3中有xx@setter xx@deleter
    @property
    def price(self): #设置方法
        print('@property')

    @price.setter #获取方法
    def price(self,value):
        print("@price.setter")

    @price.deleter #删除方法
    def price(self):
        print("@price.deleter")

print(help(property)) #help能查看一个对象接收多少个参数






 

 

 

 

 

 

 

 

 

 

 

 

 

<think> 我们刚刚讨论了类方法、静态方法实例方法的区别,现在用户转向了面向对象的三大特性:封装继承多态。用户要求详细介绍这三个概念在Python中的实现应用。 从引用内容看,用户提供的资料已经涵盖了三大特性的基本定义简单示例: 1. 引用[1][2]精炼地定义了封装继承多态 2. 引用[3]展示了多重继承及其方法解析顺序 3. 引用[4][5]通过动物/形状等经典案例演示了多态 我的回答需要系统化组织这些知识点,特别注意: - 封装要强调名称修饰(伪私有属性)property装饰器 - 继承需说明方法解析顺序(MRO)super()机制 - 多态要突出"鸭子类型"这个Python特色 结构上采用分章节形式,每个特性包含: 1) 基本概念 2) Python实现方式 3) 应用场景 4) 注意事项(如多重继承的风险) 最后用综合示例展示三大特性协同工作的场景,并生成相关问题供深入学习。 </think> ### Python面向对象三大特性:封装继承多态详解 #### 一、封装(Encapsulation) **定义**:将数据(属性)行为(方法)捆绑为独立单元,隐藏内部实现细节[^1][^2]。 **核心实现**: ```python class BankAccount: def __init__(self, owner, balance=0): self._owner = owner # 受保护属性 self.__balance = balance # 私有属性(名称修饰) # 公开接口方法 def deposit(self, amount): if amount > 0: self.__balance += amount def withdraw(self, amount): if 0 < amount <= self.__balance: self.__balance -= amount return amount return 0 # 属性访问控制 @property def balance(self): return self.__balance # 只读访问 # 使用示例 account = BankAccount("Alice", 1000) account.deposit(500) print(account.balance) # 1500 (通过属性访问) # account.__balance = 0 # 错误!无法直接访问私有属性 ``` **关键特性**: 1. **访问控制**: - `__var`:私有属性(实际被重命名为`_ClassName__var`) - `_var`:受保护属性(约定俗成,非强制) - `var`:公开属性 2. **属性装饰器**: - `@property`:定义获取方法 - `@var.setter`:定义设置方法 - `@var.deleter`:定义删除方法 3. **优势**: - 防止外部意外修改数据[^1] - 简化接口复杂度 - 实现数据校验逻辑(如在setter中) --- #### 二、继承(Inheritance) **定义**:创建新类(子类)基于已有类(父类),实现代码复用层次扩展[^1][^3]。 **实现方式**: ```python class Animal: # 父类 def __init__(self, name): self.name = name def speak(self): raise NotImplementedError("子类必须实现此方法") class Dog(Animal): # 单继承 def speak(self): return "汪汪!" class Cat(Animal): def speak(self): return "喵喵!" # 多重继承示例 class Robot: def beep(self): return "哔哔!" class RoboDog(Dog, Robot): # 多重继承 def speak(self): return super().speak() + self.beep() # 使用 buddy = Dog("Buddy") print(buddy.speak()) # 汪汪! robo = RoboDog("Astro") print(robo.speak()) # 汪汪!哔哔! ``` **关键机制**: 1. **方法重写(Override)**: - 子类可重新定义父类方法 2. **super()函数**: - 调用父类方法:`super().method()` 3. **多重继承**: - 方法解析顺序(MRO):按`__mro__`元组顺序查找[^3] ```python print(RoboDog.__mro__) # (<class '__main__.RoboDog'>, <class '__main__.Dog'>, # <class '__main__.Animal'>, <class '__main__.Robot'>, # <class 'object'>) ``` 4. **抽象基类(ABC)**: ```python from abc import ABC, abstractmethod class Shape(ABC): @abstractmethod def area(self): pass ``` **注意事项**: - 避免过度使用多重继承(易导致"菱形继承问题") - 优先使用组合而非继承实现代码复用[^3] --- #### 三、多态(Polymorphism) **定义**:不同对象对同一方法调用产生不同行为[^1][^4][^5]。 **实现方式**: ```python def animal_sound(animal): print(animal.speak()) # 不检查类型,只依赖方法存在 class Duck: def speak(self): return "嘎嘎!" # 使用 animals = [Dog("Buddy"), Cat("Whiskers"), Duck()] for a in animals: animal_sound(a) # 输出: # 汪汪! # 喵喵! # 嘎嘎! ``` **Python特色(鸭子类型)**: ```python class Car: def speak(self): # 非动物但实现speak return "嘀嘀!" animal_sound(Car()) # 嘀嘀!(只要实现speak方法即可) ``` **核心特点**: 1. **动态绑定**:运行时确定调用哪个方法 2. **接口协议**:不强制类型,只要求实现特定方法 3. **优势**: - 增强代码扩展性 - 降低模块耦合度 - 支持开放封闭原则(对扩展开放,对修改封闭) --- ### 三大特性协同示例 ```python class Employee: # 封装 def __init__(self, name, salary): self.__name = name self.__salary = salary @property def salary(self): return self.__salary def work(self): return "处理一般事务" class Developer(Employee): # 继承 def work(self): # 多态 return "编写代码" class Manager(Employee): def work(self): return "管理团队" def company_work(employees): for emp in employees: print(f"{emp.name}: {emp.work()}") # 使用 dev = Developer("张三", 15000) mgr = Manager("李四", 30000) company_work([dev, mgr]) ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值