python-面向对象、栈的封装

最新推荐文章于 2022-02-22 18:02:01 发布
最新推荐文章于 2022-02-22 18:02:01 发布
阅读量126 收藏
点赞数
分类专栏： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43114229/article/details/118945316
版权

目录

1、面向对象

在这里插入图片描述

2、封装特性

在这里插入图片描述
在这里插入图片描述
实例化对象巩固练习：
在这里插入图片描述

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('小王', 22, '男')
p3 = People('小红', 10, '女')

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

3、继承特性

在这里插入图片描述

4、重写继承类方法

class Student:
    """父类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("粉条博士", 8)
m1.choice_course()

s1 = Student("粉条博士", 8)
s1.choice_course()

5、链表和数组的区别

在这里插入图片描述
数组增加
在这里插入图片描述
数组删除
在这里插入图片描述数组修改
在这里插入图片描述
链表增加
在这里插入图片描述
链表删除
在这里插入图片描述
链表查看修改需要遍历

在这里插入图片描述
在这里插入图片描述
封装练习题
在这里插入图片描述
第一步：封装

#封装节点类
class listNode:
    def __init__(self,val=None,next=None):
        self.val=val
        self.next=next
    def travel(self,head):
        while head.next:
            print(head.next.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

def create_l2():
    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

l1 = create_l1()
l2 = create_l2()

l1.travel(l1)
print()
l1.travel(l2)

# 封装节点类
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)

练习题二：
在这里插入图片描述
在这里插入图片描述

6、多继承

在这里插入图片描述
在这里插入图片描述
a找b 如果b没有找c（先找同一层的）再找d
在这里插入图片描述

7、私有属性私有方法

在这里插入图片描述
类的外部不能访问和操作如下：
在这里插入图片描述
类的内部可以访问：
在这里插入图片描述
在这里插入图片描述
私有方法是以双下划线开头得，可以在类的内部访问，不能在类的外部访问

在这里插入图片描述
可以在类的内部访问
在这里插入图片描述

在这里插入图片描述
结果得出120

报错！！ 类的外部包括子类也不能运行

在这里插入图片描述

8、多态特性

不同的对象调用同一个方法时结果是不同的，就叫做多态

9、栈的封装

在这里插入图片描述
栈的封装
在这里插入图片描述

class Stack(object):
    """栈的封装[1, 2, 3, 4]"""

    def __init__(self):
        self.stack = []

    def push(self, value):
        """入栈"""
        self.stack.append(value)
        print(f"入栈元素为{value}")

    def pop(self):
        """出栈"""
        if self.is_empty():
            raise  Exception("栈为空")
        item = self.stack.pop()
        print(f"出栈元素为{item}")
        return  item

    def is_empty(self):
        """判断栈是否为空"""
        return  len(self.stack) == 0

    def top(self):
        """返回栈顶元素"""
        if self.is_empty():
            raise  Exception("栈为空")
        return  self.stack[-1]

    def __len__(self):
        """魔术方法, len(object)自动执行的方法"""
        return  len(self.stack)

if __name__ == '__main__':
    stack = Stack()
    stack.push(1)
    stack.push(2)
    stack.push(3)
    print(len(stack))  # 3
    stack.pop()
    print(stack.is_empty()) # False
    print(stack.top())  # 2

10、队列的封装

在这里插入图片描述

在这里插入图片描述

class Queue(object):
    """
    队列的封装
    1. 列表的左侧队尾
    2. 列表的右侧队头
    """
    def __init__(self):
        self.queue = []

    def enqueue(self, value):
        """入队"""
        self.queue.insert(0, value)
        print("入队元素为:", value)

    def dequeue(self):
        """出队"""
        if self.is_empty():
            raise  Exception("队列为空")
        item = self.queue.pop()
        print("出队元素:", item)
        return  item

    def __len__(self):
        """获取队列的长度"""
        return  len(self.queue)

    def first(self):
        """获取队头元素"""
        if self.is_empty():
            raise Exception("队列为空")
        return  self.queue[-1]


    def last(self):
        """获取队尾元素"""
        if self.is_empty():
            raise Exception("队列为空")
        return  self.queue[0]

    def is_empty(self):
        """判断队列是否为空"""
        return  len(self.queue) == 0


if __name__ == '__main__':
    queue = Queue()
    queue.enqueue(1)
    queue.enqueue(2)
    queue.enqueue(3)
    print(queue.is_empty()) # False
    queue.dequeue()  # 1出队， 队列只剩32
    print(queue.first())  # 2
    print(queue.last())  # 3

11、二叉树的封装

left：左子树 right：右子树
在这里插入图片描述

"""
二叉树:
    https://www.cnblogs.com/polly333/p/4740355.html
"""

class Node(object):
    """节点类"""
    def __init__(self, val=None, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class BinaryTree(object):
    """封装二叉树"""
    def __init__(self, root):
        self.root = root

    def pre_travel(self, root):
        """先序遍历: 根左右"""
        if (root != None):
            print(root.val)
            self.pre_travel(root.left)
            self.pre_travel(root.right)


    def in_travel(self, root):
        """中序遍历: 左根右"""
        if (root != None):
            self.in_travel(root.left)
            print(root.val)
            self.in_travel(root.right)

    def last_travel(self, root):
        """后序遍历: 左右根"""
        if (root != None):
            self.last_travel(root.left)
            self.last_travel(root.right)
            print(root.val)


if __name__ == '__main__':
    node1 = Node(1)
    node2 = Node(2)
    node3 = Node(3)
    node4 = Node(4)
    node5 = Node(5)
    node6 = Node(6)
    node7 = Node(7)
    node8 = Node(8)
    node9 = Node(9)
    node10 = Node(10)

    bt = BinaryTree(root=node1)
    node1.left = node2
    node1.right = node3
    node2.left = node4
    node2.right= node5
    node3.left = node6
    node3.right = node7
    node4.left = node8
    node4.right = node9
    node5.left = node10


    # 先序遍历
    bt.pre_travel(node1)
小莫细说linux
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python数据结构-----栈1.0（栈的介绍与操作）
m0_73633088的博客
03-14 5961
详细讲解数据结构中的栈，对栈进行简单介绍，以及怎么用Python去实现栈的操作，快来看！
Python中列表对象实现压栈和出栈算法示例
04-01
使用环境：需要先安装PyCharm（请自己百度下载安装），以及然后官网上下载Python 2.7版本，以及Python 3.7版本后，安装在自己的电脑上。 使用步骤： 1、下载解压缩之后，打开PyCharm集成开发环境， 2、然后选择“open”菜单打开项目 3、在IDE中打开test_one.py文件，右键点击“Run test_one”或者直接点击右上角的播放键。 如果一切正常，那么你会在PyCharm控制台中看到运行的效果。 阅读人员：学习Python语言的小白。 目的：帮助理解列表对象实现压栈和出栈算法。
python——面向对象——实现栈
Treasured ——的博客
01-27 511
python——面向对象——实现栈 入栈 出栈 查看栈顶元素 查看栈长度 查看栈元素 class Stack(): def __init__(self): self.stack = [] def push(self,value): self.stack.append(value) return True def p...
python面向对象编程案例：栈与队列的封装
Mr_fengzi的博客
06-12 387
项目案例: 栈与队列的封装 1.封装栈的数据结构 栈是限制在一端进行插入操作和删除操作的线性表（俗称堆栈），允许进行操作的一端称为“栈顶”， 另一固定端称为“栈底”，当栈中没有元素时称为“空栈”。向一个栈内插入元素称为是进栈，push； 从一个栈删除元素称为是出栈，pop。特点 ：后进先出（LIFO）。 根据列表的数据结构封装栈的数据结构具体程序如下： class Stack(obj...
python 栈的用法--学习
qq_58372242的博客
11-26 5392
栈 栈（stack）,可以理解成一盒口香糖,想要拿出一颗,自然从顶部取走最后放入的,这里的顶部就是"栈顶";添加和移除新项都发生在栈顶,与栈顶对应的端称为“栈底”。栈这种数据结构的特点是后进先出（Last In First Out - LIFO），即最后被堆进去的数据，最先被拿出来。 从栈放入新项和从栈删除项的操作分别叫(push）和（pop）。 栈的操作 栈操作如下 Stack() 创建一个空的新栈。 push(item)将一个新项添加到栈的顶部。 pop() 从栈中删除顶部项。 peek() 从栈返回
python-面向对象（一）-12
12-20
python是一门面向对象的编程语言 所谓面向对象的语言，简单理解就是语言中的所有操作都是通过对象来进行的 面向过程 • 面向过程指将我们的程序分解为一个 一个步骤，通过对每个步骤的抽象来完成程序 • 这种编写...
python-面向对象（二）、特殊方法，封装-13
12-20
1.特殊方法 在类中可以定义一些特殊方法也称为魔术方法 在类中可以定义一些特殊方法也称为魔术方法 特殊方法都是形如 __ xxx__()这种形式 特殊方法不需要我们调用，特殊方法会在特定时候自动调用 ...
python-面向对象-08类属性
12-20
由于，类属性从属于类对象，可以被所有的实例对象所共享。 类属性的定义方法： class 类名: 类变量名 = 初始值 在类里面或者在类的外面，我们可以通过：类名.类属性名来进行读取、赋值等相关操作。 2.类属性代码...
Python-面向对象(一)
12-20
• Python是一门面向对象的编程语言 • 所谓面向对象的语言，简单理解就是语言中的所有操作都是通过对象来进行的。 • 面向过程： • 面向过程指将我们的程序分解为一个一个步骤，通过对每个步骤的抽象来完成程序。 ...
Python-面向对象(二)
12-20
特殊方法都是形如 _xxx_()这种形式特殊方法不需要我们调用，特殊方法会在特定时候自动调用，在实例对象创建以后执行。 class Person: def __init__(self,name): # 通过self向新创建的对象中初始化属性 self.name ...
Python中的栈
Just Do It
06-14 2万+
在python中，个人理解为栈可以用列表来代替服从FILO：First In Last Out其中入栈为（利用append函数）stack = [] stack.append(<item>)出栈为（利用pop函数）stack.pop(-1) #stack.pop()也可 服从FIFO：First In First Out入栈为：stack = [] stack.append(<...
python练习之栈的封装、队列的封装
weixin_46268244的博客
07-31 174
栈的封装 栈是限制在一端进行插入操作和删除操作的线性表（俗称堆栈），允许进行操作的一端称为“栈顶”， 另一固定端称为“栈底”，当栈中没有元素时称为“空栈”。向一个栈内插入元素称为是进栈，push； 从一个栈删除元素称为是出栈，pop。特点 ：后进先出（LIFO）。 # 栈：先进后出 【”栈底”……”栈顶”】 # pop（出栈），push（入栈），len（获取栈的长度），is_empty（判断栈是否为空），top（>栈顶） class Stack(object): def __init__(
三十九、python-出栈入栈和列表的封装
weoopp的博客
10-30 799
文章目录三十九、python-出栈和列表39.1 出栈入栈--stack39.2 列表---queue 三十九、python-出栈和列表 39.1 出栈入栈–stack 栈：先进后出 pop（出栈）push（入栈） len（获取栈的长度） is_empty（判断栈是否为空） top（栈顶） 代码 class stack (object): # 定义类 def __init__(self): # 定义栈首先为空 self.stack=[] de
Python——栈的实现（面向对象法）
weixin_44224288的博客
04-09 507
实现如下： class Stack(): def __init__(self): self.stack = [] def push(self,value): self.stack.append(value) return True def pop(self): #先判断栈是否为空 if s...
Python 类与对象
热门推荐
zcx1203的博客
04-10 6万+
类与对象的理解与封装特性 面向对象编程语言 - 类: 一个模板, (人类)---是一个抽象的， 没有实体的 - 对象: (eg: 张三， 李四) - 属性: (表示这类东西的特征, 眼睛， 嘴巴， 鼻子) - 方法： (表示这类物体可以做的事情， eg: 吃饭， 睡觉，学习) 1). 定义类:class: 类 from collections import Count...
python栈的实现与应用
自成背后的博客
02-22 7026
文章目录什么是栈？用Python实现栈栈的应用：简单括号匹配栈的应用：十进制转换为二进制栈的应用：表达式转换 什么是栈？ 栈有时也被称作“下推栈”。它是一种有次序的数据项集合，添加操作和移除操作总发生在同一端，即“顶端”，另一端则被称为“底端”。 栈中的元素离底端越近，代表其在栈中的时间越长，因此栈的底端具有非常重要的意义。最新添加的元素将被最先移除。这种排序原则被称作LIFO ( last-in first-out )，即后进先出。这是一种基于数据项保存时间的次序，时间越短的离栈顶越近，而时间越长的离栈底
Python数据结构——栈
weixin_33716154的博客
11-01 153
栈是一种特殊的列表，栈内的元素只能通过列表的一端访问，这一端称为栈顶。咖啡厅内的一摞盘子是现实世界中常见的栈的例子。只能从最上面取盘子，盘子洗净后，也只能摞在这一摞盘子的最上面。栈被称为一种后入先出（LIFO，last-in-first-out）的数据结构。 由于栈具有后入先出的特点，所以任何不在栈顶的元素都无法访问。为了得到栈底的元素，...
Python对象以及堆栈
偷得浮生半日闲
04-19 319
对象： python中，一切皆对象，每一个对象由：标识（identity）、类型（type）、值（value）组成。 1.标识用于唯一标识对象，通常对于对象在计算机内存中的地址，使用内置函数id（obj）可返回对象obj的标识。 2.类型用于表示对象存储的“数据”的类型，类型可以限制对象取值范围以及可执行的操作。可以使用type（obj）获取对象的所属类...
python中栈与队列的封装
凡哥的博客
11-29 572
栈的封装 栈是限制在一端进行插入操作和删除操作的线性表（俗称堆栈）， 允许进行操作的一端称为“栈顶”，另一固定端称为“栈底”，当栈中没有元素时称为“空栈”。向一个栈内插入元素称为是进栈，push；从一个栈删除元素称为是出栈，pop。 #后进先出！ 先定义出入栈的函数： class Stack(object): def __init__(self): self.stack = [] def push(self,value): #入栈 self.stack.ap
Python面向对象编程实训
最新发布
12-25
面向对象编程是一种编程范式，它将数据和操作封装在对象中，通过定义类和创建对象来实现。在Python中，我们可以使用类来创建自定义的数据类型，并在类中定义方法来操作这些数据。 下面是一个示例，展示了如何使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小莫细说linux

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值