python之面向对象

最新推荐文章于 2023-04-15 09:31:26 发布
最新推荐文章于 2023-04-15 09:31:26 发布
阅读量268 收藏
点赞数
文章标签： python 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/crazynzg/article/details/122319545
版权

目录

self指的是调⽤该函数的对象

魔法方法

继承

super()调⽤⽗类⽅法

私有属性和方法

self指的是调⽤该函数的对象

class Washer():
    def wash(self):
        print(self)
        print('洗衣服')
wash=Washer()
print(wash)
wash.wash()
'''
<__main__.Washer object at 0x0000018876BD7B80>
<__main__.Washer object at 0x0000018876BD7B80>
洗衣服
'''

对象属性

类外⾯添加对象属性： 外面实例引用直接.xx赋值

haier1.width = 500

haier1.height = 800

类外⾯获取对象属性

print(f'haier1洗⾐机的宽度是{haier1.width}')

类⾥⾯获取对象属性 使用self.xx进行获取或者赋值

self.属性名

魔法方法

__init__()

class Washer():
    def __init__(self,width,height):
        self.width=width
        self.height=height

    def print_info(self):
        print(f'h宽度{self.width},h高度{self.height}')
h=Washer(100,200)
h.print_info()

__str__()

当使⽤print输出对象的时候，默认打印对象的内存地址。如果类定义了__str__⽅法，那么就会打印从在这个⽅法中 return 的数据。

说白了 就是给self 和实例对象重命名 可以用来 把输出的数据直接定义再str中方便调用输出

class Washer():
    def __init__(self,width,height):
        self.width=width
        self.height=height
    def __str__(self):
         return '这是此对象的说明'
    def print_info(self):
        print(f'h宽度{self.width},h高度{self.height}')
h=Washer(100,200)
h.print_info()
print(h) #默认 <__main__.Washer object at 0x00000246ECC978B0>
#使用了 str魔法后 打印return的数据

__del__():

当删除对象时，python解释器也会默认调⽤__del__()⽅法。

class Washer():
    def __init__(self,width,height):
        self.width=width
        self.height=height
    def __str__(self):
         return 'washer'
    def __del__(self):
        print(f'{self}对象已经被删除')
    def print_info(self):
        print(f'h宽度{self.width},h高度{self.height}')
h=Washer(100,200)
h.print_info()
print(h)
'''
h宽度100,h高度200
washer
washer对象已经被删除
'''

烤地瓜例子

class SweetPotato:
    def __init__(self):
        self.cook_time = 0
        self.cook_static = '生的'
        # 调料
        self.cook_condiments = []

    def cook(self, time):
        self.cook_time += time
        if 0 <= self.cook_time <= 3:
            self.cook_static = '生的'
        elif 3 < self.cook_time <= 8:
            self.cook_static = '半生不熟'
        elif 8 < self.cook_time <= 10:
            self.cook_static = '熟了'
        else:
            self.cook_static = '糊了'

    def add_condiments(self, condiment):
        self.cook_condiments.append(condiment)

    def __str__(self):
        return f'这个地瓜烤了{self.cook_time}分钟，{self.cook_static},添加的调料{self.cook_condiments if len(self.cook_condiments) > 0 else 0}'


s = SweetPotato()
print(s)
s.cook(2)
s.add_condiments('酱油')
s.cook(10)
s.add_condiments('辣椒')
print(s)
'''
这个地瓜烤了0分钟，生的,添加的调料0
这个地瓜烤了12分钟，糊了,添加的调料['酱油', '辣椒']
'''

继承

⼦类默认继承⽗类的所有属性和⽅法

简单继承

class A:
    def __init__(self):
        self.num=1
    def info_print(self):
        print(self.num)
class B(A):
    pass
B().info_print() #1
print(B().num)#1

多继承

注意 当⼀个类有多个⽗类的时候，默认使⽤第⼀个⽗类的同名属性和⽅法。

class A:
    def __init__(self):
        self.name='zndroid'
    def info_print(self):
        print(f'名字是{self.name}')
    def info_p(self):
        print(f'A类info_p打印的名字是{self.name}')
class B:
    def __init__(self):
        self.name='haha'
    def info_print(self):
        print(f'名字是{self.name}')
class C(A,B):
    pass
C().info_print()
C().info_p()
'''
名字是zndroid
A类info_p打印的名字是zndroid
'''

重写⽗类同名⽅法和属性  默认使⽤⼦类的同名属性和⽅法

说白了 爹有的儿子也有的  儿子用自己的 这样才能进化

调用父类同名属性或者方法

父类名称.xxx

为保证调⽤到的也是⽗类的属性，必须在调⽤⽅法前调⽤⽗类的初始化

另外自身的其他方法若调用到自身与父类同名属性的话 也要调用自身的__init()

因为python中一旦调用过父类同名属性和方法 此时再调用自身的同名属性和方法的话，

若不去自身初始化init 会导致调用的结果为上次调用父类同名属性和方法的结果

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class School(object):
    def __init__(self):
        self.kongfu = '[⿊⻢煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class Person(Master, School):
    def __init__(self):
        self.kongfu = '[独创煎饼果⼦配⽅]'

    def make_cake(self):
        #若这里不初始化 最后一次再调用此方法的时候 结果会是
        #运⽤[⿊⻢煎饼果⼦配⽅]制作煎饼果⼦
        self.__init__()
        print(f'运⽤{self.kongfu}制作煎饼果⼦')

    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)
    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)


p = Person()
p.make_cake()
p.make_master_cake()
p.make_school_cake()
p.make_cake()
'''
运⽤[独创煎饼果⼦配⽅]制作煎饼果⼦
运⽤[古法煎饼果⼦配⽅]制作煎饼果⼦
运⽤[⿊⻢煎饼果⼦配⽅]制作煎饼果⼦
运⽤[独创煎饼果⼦配⽅]制作煎饼果⼦
'''

多层继承

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class School(object):
    def __init__(self):
        self.kongfu = '[⿊⻢煎饼果⼦配⽅]'

    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')


class Person(Master, School):
    def __init__(self):
        self.kongfu = '[独创煎饼果⼦配⽅]'

    def make_cake(self):
        # self.__init__()
        print(f'运⽤{self.kongfu}制作煎饼果⼦')

    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)
    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)

class Tusun(Person):
    pass
p = Person()
p.make_cake()
p.make_master_cake()
p.make_school_cake()

t=Tusun()
t.make_cake()
t.make_master_cake()
t.make_school_cake()
'''
运⽤[独创煎饼果⼦配⽅]制作煎饼果⼦
运⽤[古法煎饼果⼦配⽅]制作煎饼果⼦
运⽤[⿊⻢煎饼果⼦配⽅]制作煎饼果⼦

运⽤[独创煎饼果⼦配⽅]制作煎饼果⼦
运⽤[古法煎饼果⼦配⽅]制作煎饼果⼦
运⽤[⿊⻢煎饼果⼦配⽅]制作煎饼果⼦
'''

还有一种多层继承方式  >继承  a>b  a>c b,c>d

class A:
    def __init__(self):
        print('a')
class B(A):
    def __init__(self):
        print('b')
class C(A):
    def __init__(self):
        print('c')
class D(B,C):
    pass
D() #b
class A:
    def __init__(self):
        print('a')
class B(A):
    def __init__(self):
        print('b')
class C(A):
    def __init__(self):
        print('c')
class D(C,B):
    pass
D() #c
print(D.__mro__) #查看继承关系
#(<class '__main__.D'>, <class '__main__.C'>, 
# <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)

说明一点   若出现多个继承且调用方法也是一致的情况下，此时优先调用继承顺序先后

类名.__mro__ 查看继承关系

super()调⽤⽗类⽅法

调用父类方法 有三种方式

第一种：父类名.xx(),若该方法涉及到定义的属性或者方法定义在另外的父类方法中，此方法也要调用

第二种super(当前类名,self).函数() 此时只会延伸到该类的上一级父类 若还想连续调用上上级，则还需再该类上级的方法中添加super(当前类名,self).函数()

第三种  super().函数()

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class School(Master):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

        # 2.1 super()带参数写法
        # super(School, self).__init__()
        # super(School, self).make_cake()

        # 2.2 无参数的super
        super().__init__()
        super().make_cake()


class Prentice(School):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'

    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    # 子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)

    # 需求：一次性调用父类School Master的方法
    def make_old_cake(self):
        # 方法一：如果定义的类名修改，这里也要修改，麻烦； 代码量庞大，冗余
        # School.__init__(self)
        # School.make_cake(self)
        # Master.__init__(self)
        # Master.make_cake(self)

        # 方法二：super()
        # 2.1 super(当前类名, self).函数()
        # super(Prentice, self).__init__()
        # super(Prentice, self).make_cake()

        # 2.2 无参数super
        super().__init__()
        super().make_cake()


daqiu = Prentice()

daqiu.make_old_cake()
'''
运用[黑马煎饼果子配方]制作煎饼果子
运用[古法煎饼果子配方]制作煎饼果子
'''

切记  再同名属性和方法中 一定要看清调用的方法中是否涉及到同名属性,初始化或定义该属性的方法也要一起去调用 否则就会出现上次调用的结果

错误的例子：

class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class School(Master):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

        # 2.1 super()带参数写法
        # super(School, self).__init__()
        # super(School, self).make_cake()

        # 2.2 无参数的super
        super().__init__()
        super().make_cake()


class Prentice(School):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'

    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    # 子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        # 这里不init
        super().make_cake()

    # 需求：一次性调用父类School Master的方法
    def make_old_cake(self):
        # 方法一：如果定义的类名修改，这里也要修改，麻烦； 代码量庞大，冗余
        # School.__init__(self)
        # School.make_cake(self)
        # Master.__init__(self)
        # Master.make_cake(self)

        # 方法二：super()
        # 2.1 super(当前类名, self).函数()
        # super(Prentice, self).__init__()
        # super(Prentice, self).make_cake()

        # 2.2 无参数super
        super().__init__()
        super().make_cake()


daqiu = Prentice()

daqiu.make_old_cake()
# daqiu.make_cake()
daqiu.make_school_cake()
'''
运用[黑马煎饼果子配方]制作煎饼果子
运用[古法煎饼果子配方]制作煎饼果子
运用[古法煎饼果子配方]制作煎饼果子
运用[古法煎饼果子配方]制作煎饼果子
'''
class Master(object):
    def __init__(self):
        self.kongfu = '[古法煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class School(Master):
    def __init__(self):
        self.kongfu = '[黑马煎饼果子配方]'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')

        # 2.1 super()带参数写法
        # super(School, self).__init__()
        # super(School, self).make_cake()

        # 2.2 无参数的super
        super().__init__()
        super().make_cake()


class Prentice(School):
    def __init__(self):
        self.kongfu = '[独创煎饼果子技术]'

    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    # 子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        # 这里不init
        super().make_cake()

    # 需求：一次性调用父类School Master的方法
    def make_old_cake(self):
        # 方法一：如果定义的类名修改，这里也要修改，麻烦； 代码量庞大，冗余
        # School.__init__(self)
        # School.make_cake(self)
        # Master.__init__(self)
        # Master.make_cake(self)

        # 方法二：super()
        # 2.1 super(当前类名, self).函数()
        # super(Prentice, self).__init__()
        # super(Prentice, self).make_cake()

        # 2.2 无参数super
        super().__init__()
        super().make_cake()


daqiu = Prentice()

daqiu.make_old_cake()
daqiu.make_cake()
daqiu.make_school_cake()
'''
运用[黑马煎饼果子配方]制作煎饼果子
运用[古法煎饼果子配方]制作煎饼果子
运用[独创煎饼果子技术]制作煎饼果子
运用[独创煎饼果子技术]制作煎饼果子
运用[古法煎饼果子配方]制作煎饼果子
'''

私有属性和方法

私有属性和私有⽅法只能在该类⾥⾯访问和修改

不能被继承

若想修改 再该类中定义公共的修改或者获取该私有属性或者方法的方法让其子类去继承使用

皮阿玛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python 3面向对象编程
12-22
Python 是一种面向对象的解释型语言，面向对象是其非常重要的特性。《Python 3面向对象编程》通过Python 的数据结构、语法、设计模式，从简单到复杂，从初级到高级，一步步通过例子来展示了Python 中面向对象的概念...
Python3 面向对象编程
05-12
Python 是一种面向对象的解释型语言，面向对象是其非常重要的特性。《Python 3面向对象编程》通过Python 的数据结构、语法、设计模式，从简单到复杂，从初级到高级，一步步通过例子来展示了Python 中面向对象的概念...
python中类的使用
最新发布
weixin_46159570的博客
04-15 204
python中类的使用方法
Python 之面向对象
weixin_45490820的博客
10-15 208
面向对象编程——Object Oriented Programming简写OOP 面向对象与面向过程对比 面向过程: 注重 步骤与过程，不注重职责分工 如果需求复杂，代码会变得很复杂 开发复杂项目，没有固定的套路，开发难度很大！ 面向对象: 注重 对象和职责，不同的对象承担不同的职责 更加适合应对复杂的需求变化，是专门应对复杂项目开发，提供的固定套路 需要在面向过程基础上，再学习一些面向对象的语法 类和对象的概念 类 ...
__init__的用法
Chenzhinan1219的博客
10-01 674
在Python中定义类经常会用到__init__函数（方法），首先需要理解的是，两个下划线开头的函数是声明该属性为私有，不能在类的外部被使用或访问。而__init__函数（方法）支持带参数类的初始化，也可为声明该类的属性（类中的变量）。__init__函数（方法）的第一个参数必须为self，后续参数为自己定义。 从文字理解比较困难，通过下面的例子能非常容易理解这个概念： 例如我们定义一个Box类，有width, height, depth三个属性，以及计算体积的方法： #!/usr/bin/pytho
Python中__init__的用法和理解
热门推荐
luzhan66的博客
09-23 15万+
在Python中定义类经常会用到__init__函数（方法），首先需要理解的是，两个下划线开头的函数是声明该属性为私有，不能在类的外部被使用或访问。而__init__函数（方法）支持带参数类的初始化，也可为声明该类的属性（类中的变量）。__init__函数（方法）的第一个参数必须为self，后续参数为自己定义。 从文字理解比较困难，通过下面的例子能非常容易理解这个概念： 例如我们定义一个Box...
python__魔法方法
小鱼儿
09-06 2583
魔法方法总是被双下划线包围：例：init 它们总能够在适合当的时侯被自动调用构造和析构 init(self[,……]) ：对象初始化时会自动调用class Rectangel: def __init__(self,x,y): self.x = x self.y = y def getPeri(self): return (self
python之面向对象编程
qq_43428929的博客
08-23 1425
面向对象程序设计面向对象程序设计（英语：Object-oriented programming，缩写：OOP）是种具有对象概念的编程典范，同时也是一种程序开发的抽象方针。它可能包含数据、特性、代码与方法。对象则指的是类（class）的实例。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性，对象里的程序可以访问及经常修改对象相关连的数据。在面向对象程序编程里，计算机程序会被设计成彼此相关的对象。从维基百科的定义可以看出，面向对象编程的对象。
Python之面向对象经典题目
weixin_50765519的博客
06-01 3801
题目 1.定义一个学校人员类SchoolPerson， 其中，属性：姓名name、性别sex、年龄age； 方法：设置人员的各个属性的set_info方法； 获取各属性值的get_info方法。 定义好类以后，再定义2个人员进行测试。 2.在第1个题的基础上添加两个方法： 其中，init()方法，完成属性的初始化（要求从键盘输入各属性的值）； del()方法，完成输出“__del__方法调用”这一句话（作用是用来销毁对象）。 3.创建学生类Student，继承自SchoolPerson类，添加额外两个属性：
python之面向对象程序设计基础
jiankang66的博客
07-07 1367
  Python 是一门易于学习、功能强大的编程语言。它提供了高效的高级数据结构，还能简单有效地面向对象编程。Python 优雅的语法和动态类型以及解释型语言的本质，使它成为多数平台上写脚本和快速开发应用的理想语言。下面我们来介绍一下python的面向对象程序设计基础。  面向对象程序设计（Object Oriented Programming，OOP）的思想主要针对大型软件设计而提出，它使得软件设计更加灵活，能够很好地支持代码复用和设计复用，并且使得代码具有更好的可读性和可扩展性。Python完全采用了面
python面向对象练习题.pdf
09-04
python面向对象练习题，资料，教育资料
python面向对象
09-13
面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它基于“对象”的概念，将数据和...在视频课程“Python面向对象精彩讲解”中，会详细阐述这些概念，并通过实例演示如何在实际开发中应用它们。
Python面向对象进阶学习
09-19
在本文里我们整理了关于Python面向对象的进阶学习知识点以及学习路线等内容，有兴趣的朋友们学习下。
Python学习之面向对象
12-22
面向对象编程（Object-Oriented Programming，简称OOP）是一种重要的编程范式，它基于“对象”的概念，通过封装、继承和多态等机制来组织代码。...在实际项目中，熟练掌握面向对象编程是Python程序员必备的技能之一。
面向对象编程基础_python面向对象_python教程_
09-29
以上就是Python面向对象编程的基本概念和特性。掌握这些基础知识，能帮助你更好地理解和编写Python程序，尤其在处理复杂逻辑和大型项目时，面向对象编程的优势会更加明显。在实际应用中，不断实践和探索，才能真正...
Python基础知识：构造函数中self用法
qq_32506555的博客
03-28 5051
在Python开发（http://www.maiziedu.com/course/python-px/）编程语言中有种函数叫构造函数，在这个函数里面有一个关键词叫self，首先明确的是self只有在类的方法中才会有，独立的函数或方法是不必带有self的。下面就讲讲self关键词在构造函数中的使用方法。 构造 class FooBar:   def _int_(self):     self
python 构造函数 __init__()方法的理解
Peter的博客
12-29 3122
用到__init__函数（方法）， 首先，两个下划线开头的函数是声明该属性为私有，不能在类的外部被使用或访问。 而__init__函数（方法）支持带参数类的初始化，也可为声明该类的属性（类中的变量）。 __init__函数（方法）的第一个参数必须为self，后续参数为自己定义。 普通函数（方法）来实现一个Box类，有width, height, depth三...
Python之面向对象（史上最全~不谈）（一）
12-21
Python作为一门动态类型的语言，非常适合进行面向对象编程。在Python中，一切皆为对象，无论是整数、字符串，还是自定义的数据结构。 首先，我们需要理解对象的基本概念。对象是面向对象编程的基础单元，它包含了...
Python3面向对象编程
07-22
资源名称：Python 3面向对象编程 内容简介：Python 是一种面向对象的解释型语言，面向对象是其非常重要的特性。《Python 3面向对象编程》通过Python 的数据结构、语法、设计模式，从简单到复杂，从初级到高级，一...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值