python面向对象编程(封装与继承)_使用py的面向对象编程,类的封装和继承代码

m0_60575487

已于 2024-04-12 02:44:12 修改

阅读量826

点赞数 8

分类专栏： 2024年程序员学习文章标签： python 开发语言

于 2024-04-12 02:44:11 首次发布

本文链接：https://blog.csdn.net/m0_60575487/article/details/137660415

版权

2024年程序员学习专栏收录该内容

249 篇文章 0 订阅

订阅专栏

"""
创建一个类People,拥有的属性为姓名， 性别和年龄， 拥有的方法为购物,玩游戏,学习;实例化
对象,执行相应的方法。 显示如下:
小明,18岁,男,去西安赛格购物广场购物
小王,20岁,男,去西安赛格购物广场购物
小红,22岁,女,在西部开源学习
提示:
属性:name,age,gender
方法:shopping(), playGame(), learning()
"""
class People:
    def \_\_init\_\_(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

    def shopping(self):
        print(f'{self.name},{self.age}岁，{self.gender}，去西安赛格购物广场购物')

    def learning(self):
        print(f'{self.name},{self.age}岁,{self.gender},在西部开源学习')
p1 = People('小明','18','男')
p2 = People('小王','20','男')
p3 = People('小红','22','女')

p1.shopping()
p2.shopping()
p3.learning()

代码运行结果：
在这里插入图片描述

3 . 继承特性

面向对象的三大特性是指：封装、继承和多态

继承
多继承
私有属性与私有方法

继承描述的是事物之间的所属关系,当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类、扩展类(Subclass),而被继承的class称为基类、父类或超类(Baseclass、
Superclass)。

问题一: 如何让实现继承?
子类在继承的时候,在定义类时,小括号()中为父类的名字
问题二: 继承的工作机制是什么?
父类的属性、方法,会被继承给子类。举例如下: 如果子类没有定义__init__方法,父类有,那么在子类继承父类的时候这个方法就被继承了,所以只要创建对象,就默认执行了那个继承过来的__init__方法

class Student:
    def \_\_init\_\_(self,name,age):
        self.name = name
        self.age = age
    def learning(self):
        print(f'{self.name}正在学习')
class MathStudent(Student):
    """MathStudent的父类是student"""
    pass

#实例化
m1 = MathStudent('华罗庚',88)
print(m1.name)
print(m1.age)
m1.learning()    #子类没有就会去父类找
# m1.choice\_course() #子类和父类都没有就会报错

代码运行结果：
在这里插入图片描述

4 . 重写父类方法

就是子类中,有一个和父类相同名字的方法,在子类中的方法会覆盖掉父类中同名的方法。

class Student:
    def \_\_init\_\_(self,name,age):
        self.name = name
        self.age = age
    def learning(self):
        print(f'{self.name}正在学习')

    def choice\_course(self):
        print('正在选课中'.center(50,'\*'))

class MathStudent(Student):
    """MathStudent的父类是student"""
    def choice\_course(self):
        # 需求：先执行父类的方法choice\_course，再个性化执行自己的方法
        #Student.choice\_course(self) #方法1：直接执行父类的方法，但不建议
        #方法2：通过super找到父类的方法，再执行（）中的。
        super(MathStudent,self).choice_course()
        info = """
 课程表
 1. 高数
 2. 线性代数
 3. 概率论
 """
        print(info)

#实例化
m1 = MathStudent('华罗庚',88)
m1.choice_course()

代码运行结果：
在这里插入图片描述

5 . 练习

两数相加力扣网址
在这里插入图片描述
直接在力扣上做,代码如下：

#Definition for singly-linked list.
# class ListNode:
# def \_\_init\_\_(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        res = 0
        l3 = ListNode()
        cur = l3
        while(l1 or l2):
             if(l1):
                 res += l1.val  # res=2
                 l1 = l1.next
             if(l2):
                 res += l2.val # res=2+5=7
                 l2 = l2.next
        # res=10, val=0, res=>val val=res%10
        # res=14, val=4, 14%10=4
             l3.next = ListNode(res%10)
             l3 = l3.next
        # res=10, 进位为1， 10//10=1
        # res=14, 进位为1， 14//10=1
             res  //= 10
        if res == 1:
            l3.next = ListNode(1)
        return cur.next

在这里插入图片描述

6 . 链表的封装

"""
参考链接 https://www.cnblogs.com/klyjb/p/11237361.html
数组: 需要连续的内存空间
链表: 不需要连续的内存空间
 数组 链表
增加元素 O(n) O(1)
删除元素 O(n) O(1)
修改元素 O(1) O(n)
查看元素 O(1) O(n)
"""

# 封装节点类
class ListNode:
    def \_\_init\_\_(self, val=0, next=None):
        self.val = val
        self.next = next

    def travel(self, head):
        """遍历链表里面的每一个元素"""
        while head:
            print(head.val, end=',')
            head = head.next

def create\_l1():
    # l1 = 2,4,3
    # l2 = 5, 6, 4
    l1 = ListNode()
    node1 = ListNode(val=2)
    node2 = ListNode(val=4)
    node3 = ListNode(val=3)
    l1.next = node1
    node1.next = node2
    node2.next = node3
    return  l1.next

def create\_l2():
    # l1 = 2,4,3
    # l2 = 5, 6, 4
    l2 = ListNode()
    node1 = ListNode(val=5)
    node2 = ListNode(val=6)
    node3 = ListNode(val=4)
    l2.next = node1
    node1.next = node2
    node2.next = node3
    return  l2.next

def addTwoNumbers(l1: ListNode, l2: ListNode) -> ListNode:
    res = 0
    l3 = ListNode()
    cur = l3
    while(l1 or l2):
        if(l1):
            res += l1.val  # res=2
            l1 = l1.next
        if(l2):
            res += l2.val # res=2+5=7
            l2 = l2.next
        # res=10, val=0, res=>val val=res%10
        # res=14, val=4, 14%10=4
        l3.next = ListNode(res%10)
        l3 = l3.next
        # res=10, 进位为1， 10//10=1
        # res=14, 进位为1， 14//10=1
        res  //= 10
    if res == 1:
        l3.next = ListNode(1)
    return cur.next
    
if __name__ == '\_\_main\_\_':
    l1 = create_l1()
    l2 = create_l2()
    l3 = addTwoNumbers(l1, l2)
    l3.travel(l3)

7. 多继承

多继承,即子类有多个父类,并且具有它们的特征

在Python 2及以前的版本中，由任意内置类型派生出的类，都属于“新式
类”
，都会获得所有“新式类”的特性；反之，即不由任意内置类型派生出的类，
则称之为“经典类”。
在这里插入图片描述
“新式类”和“经典类”的区分在Python 3之后就已经不存在，在Python 3.x之后的版本，因为所有的类都派生自内置类型object(即使没有显示的继承object类型)，即所有的类都是“新式类”。
最明显的区别在于继承搜索的顺序不同，即：
经典类多继承搜索顺序(深度优先算法):先深入继承树左侧查找，然后再返回，开始查找右侧。
新式类多继承搜索顺序(广度优先算法):先在水平方向查找，然后再向上查找，
在这里插入图片描述

"""
新式类: 广度优先算法
经典类： 深度优先算法(py2中的部分类属于经典类)

python3所有的类都属于新式类。新式类的继承算法是广度优先。

# 分析多继承的相关代码
>pip install djangorestframework
from rest\_framework import viewsets
viewsets.ModelViewSet
"""

class D(object):
    def hello(self):
        print('D')
class C(D):
    # def hello(self):
    # print('C')
    pass
class B(D):
    pass
    # def hello(self):
    # print('B')
class A(B, C):
    pass
    # def hello(self):
    # print('A')
a = A()
a.hello()

四、私有属性和私有方法

默认情况下,属性在 Python 中都是“public”，大多数 OO 语言提供“访问控制符”来限定成员函数的访问。
在 Python 中,实例的变量名如果以 __ 开头,就变成了一个私有变量/属性
(private),实例的函数名如果以 __ 开头,就变成了一个私有函数/方法(private)只
有内部可以访问,外部不能访问。

class Student:
    """父类Student"""
    def \_\_init\_\_(self, name, age, score):
        self.name = name
        self.age = age
        # 私有属性，以双下划线开头。
        # 工作机制: 类的外部(包括子类)不能访问和操作，类的内部可以访问和操作。
        self.__score = score

    def learning(self):
        print(f'{self.name}正在学习')

    def get\_score(self):
        self.__modify_score()
        return  self.__score

    # 私有方法是以双下划线开头的方法,
    #工作机制: 类的外部(包括子类)不能访问和操作，类的内部可以访问和操作。
    def \_\_modify\_score(self):
        self.__score += 20

class MathStudent(Student):
    """MathStudent的父类是Student"""
    def get\_score(self):
        self.__modify_score()
        return  self.__score

# 报错原因: 子类无法继承父类的私有属性和私有方法。
s1 = MathStudent('张三', 18, 100)
score = s1.get_score()
print(score)

优势

确保了外部代码不能随意修改对象内部的状态,这样通过访问限制的保护, 代码更加健壮。
如果又要允许外部代码修改属性怎么办?可以给类增加专门设置属性方
法。为什么大费周折?因为在方法中,可以对参数做检查,避免传入无效的参数。

五、多态特性

多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。通俗来说：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。

多态的好处就是，当我们需要传入更多的子类，只需要继承父类就可以了，而方法既可以直接不重写（即使用父类的），也可以重写一个特有的。这就是多态的意思。调用方只管调用，不管细节，而当我们新增一种的子类时，只要确保新方法编写正确，而不用管原来的代码。这就是著名的“开闭”原则：
对扩展开放（Open for extension）：允许子类重写方法函数
对修改封闭（Closed for modification）：不重写，直接继承父类方法函数

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Python开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024c （备注Python）

文末有福利领取哦~

👉一、Python所有方向的学习路线

Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

👉二、Python必备开发工具

👉三、Python视频合集

观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

👉 四、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。（文末领读者福利）

👉五、Python练习题

检查学习结果。

👉六、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

👉因篇幅有限，仅展示部分资料，这份完整版的Python全套学习资料已经上传

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

👉因篇幅有限，仅展示部分资料，这份完整版的Python全套学习资料已经上传

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
[外链图片转存中…(img-W9PkNxPZ-1712861035053)]

m0_60575487

关注

8
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
python面向对象编程(封装与继承)_使用py的面向对象编程,类的封装和继承代码

多态的好处就是，当我们需要传入更多的子类，只需要继承父类就可以了，而方法既可以直接不重写（即使用父类的），也可以重写一个特有的。“新式类”和“经典类”的区分在Python 3之后就已经不存在，在Python 3.x之后的版本，因为所有的类都派生自内置类型object(即使没有显示的继承object类型)，即所有的类都是“新式类”。Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
复制链接

扫一扫

专栏目录