python面向对象编程及prettytable的实例（封装与继承）

于 2021-11-29 18:00:35 发布
阅读量547 收藏 1
点赞数 1
分类专栏： python 文章标签： python python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_45655407/article/details/121597964
版权

面向过程编程

“面向过程”(Procedure Oriented)是一种以过程为中心的编程思想。

分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候依次调用就可以了。

面向对象的方法也是含有面向过程的思想。面向过程最重要的是模块化的思想方法。

特性：
模块化 流程化

优点：
性能比面向对象高, 因为类调用时需要实例化，开销比较大，比较消耗资源;
单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。

缺点：
没有面向对象易维护、易复用、易扩展

面向对象编程

面向对象是按人们认识客观世界的系统思维方式，把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

特性： 抽象 封装 继承 多态
优点： 易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，
可以设计出低耦合 的系统，使系统更加灵活、更加易于维护
缺点： 性能比面向过程低

类和对象

类（Class）是现实或思维世界中的实体在计算机中的反映，它将数据以及这些数据上的操作封装在一起。
对象(Object)是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概念。

类（Class）是是创建实例的模板
对象(Object)是一个一个具体的实例

定义类 class 类(): pass

将类转换成对象
实例化是指在面向对象的编程中，把用类创建对象的过程称为实例化。是将一个抽象的概念类，具体到该类实物的过程。实例化过程中一般由类名 对象名 = 类名（参数1，参数2…参数n）构成。

例如：

class Cat:
    name = 'name'
    kind = 'kind'
    def eat(self):
        print('cat like eating fish...')
#对象（Object）:对类得实例化（具体化）
yinduan = Cat()

print(Cat)
print(yinduan)

封装特性

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

(1)封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。所以，在使用面向对象的封装特性时，需要：

1). 将内容封装到某处
2). 从某处调用被封装的内容
3). 通过对象直接调用被封装的内容： 对象.属性名
4).通过self间接调用被封装的内容： self.属性名
5). 通过self间接调用被封装的内容: self.方法名()

构造方法__init__与其他普通方法不同的地方在于，当一个对象被创建后，会立即调用构造方法。自动执行构造方法里面的内容。

对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。

例如：

class Cat:
    def __init__(self, name, kind):  # 形参
        """
        1. 构造方法，实例化对象时自动执行的方法
        2. self是什么? self实质上是实例化的对象
        3. 类方法中, python解释器会自动把对象作为参数传给self
        """
        print('正在执行__init__构造方法')
        print('self:', self)
        # 封装: self.name将对象和name属性封装/绑定
        self.name = name
        self.kind = kind
    def eat(self):
        print('cat %s like eating fish.....' %(self.name))

# 对象(Object):对类的实例化(具体化)
jiong = Cat("囧囧", "美短虎斑")
print(jiong.name)
print(jiong.kind)
jiong.eat()

练习

创建一个类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()

结果如下：

继承特性

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

继承描述的是事物之间的所属关系，当我们定义一个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 Math(Student):
    pass

m = Math('华罗庚',88)
print(m.name)
print(m.age)
m.learning()    #子类没有就会去父类找

结果如下：

华罗庚
88
华罗庚正在学习

重写父类

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

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 Math(Student):
    def choice_course(self):
        #方法：通过super找到父类的方法，再执行（）中的。
        super(Math,self).choice_course()
        info = """
                   课程表
            1. 高数
            2. 线性代数
            3. 概率论
        """
        print(info)
        print(''.center(54,'*'))

m = Math('华罗庚',88)
m.choice_course()

结果为：

**********************正在选课中***********************

                   课程表
            1. 高数
            2. 线性代数
            3. 概率论
        
******************************************************

两数之和

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

解法：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        l3 = ListNode(0)
        head = l3
        step = 0
        while l1 or l2 :
            x = l1.val if l1 else 0
            y = l2.val if l2 else 0
            
            result = x + y + step
            step = result // 10
            
            head.next = ListNode(result % 10)
            head = head.next
            l1 = l1.next if l1 else None
            l2 = l2.next if l2 else None
        
        if step == 1:
            head.next = ListNode(1)
        
        return l3.next

1.定义链表

定义链表的时候，当x的值为0的时候，代表的是链表为空。也就是定义了一个空链表。

// 参数值为0代表的是链表为空
ListNode list = new ListNode(0);

2.链表的赋值

通过X.next = new ListNode(1);来赋值，此时链表中的一个值为1。

3.取值

取第一个值的时候，只需要xx.val即可。取第二个值的时候，先指针后移动，xx = xx.next;然后int x = xx.val;

链表的封装

数组: 需要连续的内存空间
链表: 不需要连续的内存空间

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)

多继承

多继承,即子类有多个父类,并且具有它们的特征
经典类多继承搜索顺序(深度优先算法):先深入继承树左侧查找，然后再返回，开始查找右侧。
新式类多继承搜索顺序(广度优先算法):先在水平方向查找，然后再向上查找，

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

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()

输出为B

注释子类中的某个def hello(self)，print(’’)
最后留下的print（A/B/C/D）
留下的哪个def hello(self)，print(’’)就输出哪个

广度搜索的好处在于：
确保了外部代码不能随意修改对象内部的状态,这样通过访问限制的保护, 代码更加健壮。

如果又要允许外部代码修改属性怎么办?可以给类增加专门设置属性方法。 为什么大费周折?因为在方法中,可以对参数做检查,避免传入无效的参数。

多态特性

字面的意思就是“多种状态”。
通俗来说： 同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
多态的好处就是，当我们需要传入更多的子类，只需要继承父类就可以了，而方法既可以直接不重写（即使用父类的），也可以重写一个特有的。
简单来说就是：不需要特别说明的子类只需要调用父类的，而新增加一种特定的子类时候，只需要重写这个特有的

这就是著名的“开闭”原则：
对扩展开放（Open for extension）：允许子类重写方法函数
对修改封闭（Closed for modification）：不重写，直接继承父类方法函数

prettytable

需求：
列出一个 表格如下

import prettytable as pt

table = pt.PrettyTable(field_names=['主机名','IP','CPU','内存','磁盘类型','磁盘大小','运行状态'])
for i in range(10):

    table.add_row([f'lcf{i}.example.com',f'192.168.1.{i}','4','8g','普通云盘','40g','running'])
print(table)

在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

lll_cf

喜欢

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

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

打赏作者

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

抵扣说明：

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

余额充值