首页 > 其他分享 >面向对象(四)

面向对象(四)

时间：2024-03-13 18:58:06浏览次数：19  
标签：__ name self 面向对象 print age def

目录

面向对象的三大特征说明(封装、继承、多态)

封装（隐藏）

继承

多态

继承

子类扩展父类

语法格式

成员继承和方法的重写

类成员的继承和重写

查看类的继承层次结构

object根类

dir()查看对象属性

重写str方法

多重继承

MRO方法解析顺序

super()获得父类定义

面向对象的三大特征说明(封装、继承、多态)

封装（隐藏）

隐藏对象的属性和实现细节，只对外提供必要的方法。相当于将“细节封装起来”，只对外暴露“相关调用方法”。

通过前面学习的“私有属性、私有方法”的方式，实现“封装”。Python追求简洁的语法，没有严格的语法级别的“访问控制符”，更多的是依靠程序员自觉实现。

继承

继承可以让子类具有父类的特性，提高了代码的重用性。

从设计上是一种增量进化，原有父类设计不变的情况下，可以增加新的功能，或者改进已有的算法。

多态

多态是指同一个方法调用由于对象不同会产生不同的行为。生活中这样的例子比比皆是：同样是休息方法，人不同休息方法不同。

继承

子类扩展父类

继承是面向对象编程的三大特征之一。继承让我们更加容易实现类的扩展。实现代码的重用。

如果一个新类继承自一个设计好的类，就直接具备了已有类的特征，就大大降低了工作难度。已有的类，我们称为“父类或者基类”，新的类，我们称为“子类或者派生类”。

语法格式

Python支持多重继承，一个子类可以继承多个父类。继承的语法格式如下：

class 子类类名(父类1[，父类2，...])：
    类体

如果在类定义中没有指定父类，则默认父类是object类。也就是说，object是所有类的父类，里面定义了一些所有类共有的默认实现，比如：__new__()

关于构造函数：

  1. 子类不重写 __init__，实例化子类时，会自动调用父类定义的 __init__。
  2. 子类重写了__init__ 时，实例化子类，就不会调用父类已经定义的 __init__
  3. 如果重写了__init__ 时，要使用父类的构造方法，可以使用 super 关键字，也可以使用如下格式调用：

父类名.__init__(self, 参数列表)

class Person:
    def __init__(self, name, age):
        print("Person的构造方法")
        self.name = name
        self.age = age

    def say_age(self):
        print(self.name, "的年龄是：", self.age)


class Student(Person):
    def __init__(self, name, age, score):
        print("Student的构造方法")
        super().__init__(name, age)  # 调用父类的构造方法
        self.score = score

    def say_score(self):
        print(self.name, "的分数是：", self.score)


s1 = Student("张三", 15, 85)
s1.say_age()

运行结果：

Student的构造方法
Person的构造方法
张三 的年龄是： 15

成员继承和方法的重写

类成员的继承和重写

  1. 成员继承：子类继承了父类除构造方法之外的所有成员。

    ⚠️(私有属性、私有方法也被继承)

  2. 方法重写：子类可以重新定义父类中的方法，这样就会覆盖父类的方法，也称为“重写”

【操作】继承和重写的案例

class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def say_age(self):
    print(self.name, "的年龄是：", self.age)

  def say_name(self):
    print("我是", self.name)


class Student(Person):
  def __init__(self, name, age, score):
    super().__init__(name, age)
    self.score = score

  def say_score(self):
    print(self.name, "的分数是：", self.score)

  def say_name(self):  # 重写父类的方法
    super().say_name()


s1 = Student("张三", 15, 85)
s1.say_score()
s1.say_name()
s1.say_age()

执行结果：

张三 的分数是： 85
我是 张三
张三 的年龄是： 15

查看类的继承层次结构

通过类的方法mro()或者类的属性__mro__可以输出这个类的继承层次结构。

【操作】 查看类的继承层次结构

class A:pass
class B(A):pass
class C(B):pass
​
print(C.mro())

执行结果：

[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

object根类

object类是所有类的父类，因此所有的类都有object类的属性和方法。我们显然有必要深入研究一下object类的结构。对于我们继续深入学习Python很有好处。

dir()查看对象属性

为了深入学习对象，先学习内置函数dir()，他可以让我们方便的看到指定对象所有的属性

【测试】查看对象所有属性以及和object进行比对

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_age(self):
        print(self.name, "的年龄是：", self.age)

    def __dir__(self):
        return ['name', 'age', 'say_age']


s2 = Person("浊酒", 18)
print(dir(s2))

运行结果：['age', 'name', 'say_age']

从上面我们可以发现这样几个要点：

  1. Person对象增加了六个属性：

    __dict__ __module__ __weakref__ age name say_age

  2. object的所有属性，Person类作为object的子类，显然包含了所有的属性

  3. 我们打印age、name、say_age，发现say_age虽然是方法，实际上也是属性。只不过，这个属性的类型是method而已。

age <class 'int'>
name <class 'str'>
say_age <class 'method'>

重写str方法

  1. object有一个__str__()方法，用于返回一个对于“对象的描述”。内置函数str(对象),调用的就是__str__()
  2. __str__()经常用于print()方法，帮助我们查看对象的信息。__str__()可以重写
class Person:
  def __init__(self,name,age):
    self.name = name
    self.__age = age

  def __str__(self):
    '''将对象转化成一个字符串，一般用于print方法'''
    print("重写__str__方法")
    return "名字是：{0},年龄是{1}".format(self.name,self.__age)

p = Person("浊酒",18)
print(p)
s = str(p)

多重继承

Python支持多重继承，一个子类可以有多个“直接父类”。这样，就具备了“多个父类”的特点。但是由于，这样会被“类的整体层次”搞的异常复杂，尽量避免使用。

class A:
  def aa(self):
    print("aa")
​
class B:
  def bb(self):
    print("bb")
​
class C(B,A):
  def cc(self):
    print("cc")
​
c = C()
c.cc()
c.bb()
c.aa()

运行结果：

cc
bb
aa

类结构为：

MRO方法解析顺序

Python支持多继承，如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将“从左向右”按顺序搜索。

MRO（Method Resolution Order）：方法解析顺序。 我们可以通过mro()方法获得“类的层次结构”，方法解析顺序也是按照这个“类的层次结构”寻找的。

class A:
  def aa(self):
    print("aa")
​
  def say(self):
    print("say AAA!")
​
class B:
  def bb(self):
    print("bb")
​
  def say(self):
    print("say BBB!")
class C(B,A):
  def cc(self):
    print("cc")
​
c = C()
print(C.mro())     #打印类的层次结构
c.say()         #解释器寻找方法是“从左到右”的方式寻找，此时会执行B类中的say()

执行结果：

[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
say BBB!

super()获得父类定义

在子类中，如果想要获得父类的方法时，我们可以通过super()来做。

super()代表父类的定义，不是父类对象。

❤️想调用父类的构造方法：

super(子类名称,self).__init__(参数列表)

class A:
  def __init__(self):
    print("A的构造方法")
​
  def say(self):
    print("A: ",self)
    print("say AAA")
​
class B(A):
  def __init__(self):
    super(B,self).__init__() #调用父类的构造方法
    print("B的构造方法")
  def say(self):
    #A.say(self)   调用父类的say方法
    super().say()  #通过super()调用父类的方法
    print("say BBB")
​
b = B()
b.say()

运行结果：

A的构造方法
B的构造方法
A:  <__main__.B object at 0x000001BCE921C250>
say AAA
say BBB

多态详解

多态（polymorphism）是指同一个方法调用由于对象不同可能会产生不同的行为。

关于多态要注意以下2点：

  1. 多态是方法的多态，属性没有多态。
  2. 多态的存在有2个必要条件：继承、方法重写
#多态

class Animal:
  def shout(self):
    print("动物叫了一声")

class Dog(Animal):
  def shout(self):
    print("小狗，汪汪汪")

class Cat(Animal):

  def shout(self):
    print("小猫，喵喵喵")

def animalShout(a):
  a.shout()  #传入的对象不同，shout方法对应的实际行为也不同。

animalShout(Dog())
animalShout(Cat())

运行结果：

小狗，汪汪汪
小猫，喵喵喵

特殊方法和运算符重载

Python的运算符实际上是通过调用对象的特殊方法实现的。

a = 20
b = 30
c = a+b
d = a.__add__(b)
print("c=",c)
print("d=",d)

运行结果：

c= 50
d= 50

常见的特殊方法统计如下：

每个运算符实际上都对应了相应的方法，统计如下：

我们可以重写上面的特殊方法，即实现了“运算符的重载”。

  def __init__(self,name):
    self.name = name
  def __add__(self, other):
    if isinstance(other,Person):
      return "{0}--{1}".format(self.name,other.name)
    else:
      return "不是同类对象，不能相加"
  def __mul__(self, other):
    if isinstance(other,int):
      return self.name*other
    else:
      return "不是同类对象，不能相乘"
p1 = Person("浊酒")
p2 = Person("大威天龙")
x = p1 + p2
print(x)
print(p1*3)

浊酒--大威天龙
浊酒浊酒浊酒

特殊属性

Python对象中包含了很多双下划线开始和结束的属性，这些是特殊属性，有特殊用法。这里我们列出常见的特殊属性：

#测试特殊属性
class A:
  pass
class B:
  pass
class C(B,A):
  def __init__(self,nn):
    self.nn = nn
  def cc(self):
    print("cc")
c = C(3)
print(c.__dict__)
print(c.__class__)
print(C.__bases__)
print(C.mro())
print(A.__subclasses__())

运行结果：

{'nn': 3}
<class '__main__.C'>
(<class '__main__.B'>, <class '__main__.A'>)
[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
[<class '__main__.C'>]

浅拷贝和深拷贝_对象内存分析

浅拷贝

Python拷贝一般都是浅拷贝。

浅拷贝：拷贝时，拷贝源对象，但对象包含的子对象内容不拷贝。

深拷贝

使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象。

深拷贝：拷贝时，拷贝源对象，也递归拷贝对象中包含的子对象

#测试对象的引用赋值、浅拷贝、深拷贝
import copy
class MobilePhone:
  def __init__(self,cpu):
    self.cpu = cpu
class CPU:
  pass
c = CPU()
m = MobilePhone(c)
print("----浅拷贝-------")
m2 = copy.copy(m)  #m2是新拷贝的另一个手机对象
print("m：",id(m))
print("m2：",id(m2))
print("m的cpu：",id(m.cpu))
print("m2的cpu：",id(m2.cpu))  #m2和m拥有了一样的cpu对象
print("----深拷贝--------")
m3 = copy.deepcopy(m)
print("m：",id(m))
print("m3：",id(m3))
print("m的cpu：",id(m.cpu))
print("m3的cpu：",id(m3.cpu))  #m3和m拥有不一样的cpu对象

运行结果：

----浅拷贝-------
m： 1994031683408
m2： 1994029520016
m的cpu： 1994031684752
m2的cpu： 1994031684752
----深拷贝--------
m： 1994031683408
m3： 1994031686288
m的cpu： 1994031684752
m3的cpu： 1994031686672

继承和组合

组合

除了继承，“组合”也能实现代码的复用！“组合”核心是“将父类对象作为子类的属性”。

  1. is-a关系，我们可以使用“继承”。从而实现子类拥有的父类的方法和属性。is-a关系指的是类似这样的关系：狗是动物，dog is animal。狗类就应该继承动物类。
  2. has-a关系，我们可以使用“组合”，也能实现一个类拥有另一个类的方法和属性。has-a关系指的是这样的关系：手机拥有CPU。 MobilePhone has a CPU
#组合测试
class MobilePhone:
  def __init__(self,cpu,screen):
    self.cpu = cpu
    self.screen = screen
class CPU:
  def calculate(self):
    print("计算，算个12345")
class Screen:
  def show(self):
    print("显示一个好看的画面，亮瞎你的钛合金大眼")
c = CPU()
s = Screen()
m = MobilePhone(c,s)
m.cpu.calculate()    #通过组合，我们也能调用cpu对象的方法。相当于手机对象间接拥有了“cpu的方法”
m.screen.show()

运算结果：

计算，算个12345
显示一个好看的画面，亮瞎你的钛合金大眼

标签：__,name,self,面向对象,print,age,def
From： https://blog.csdn.net/qq_65463941/article/details/136681857

相关文章

  • 面向对象
    面向对象和面向过程的辨析面向过程编程(ProcedureOrientedProgramming)核心思想：面向过程的核心是以过程或者说函数作为程序设计的基本单元，强调的是解决问题的步骤和顺序。特点程序结构清晰，通常体现为函数的组合和调用，关注的是如何一步步地执行操作。数据和处理数据的函......
  • 面向对象设计的六大原则（SOLID原则）-——开闭原则
    开闭原则（Open-ClosedPrinciple,OCP）是面向对象设计的五大SOLID原则之一。这个原则主张“软件实体（类、模块、函数等）应该对扩展开放，对修改关闭”。也就是说，软件的设计应该允许在不修改原有代码的情况下增加新的功能。这样的设计有助于降低代码的复杂性和维护成本，同时提高系统的可复......
  • [3] C++面向对象编程
    Day1函数指针数组简写函数指针typedeftypedefint(*FunPtr)(int,int);FunPtrFunArr[1]={Add};内联函数#pragmaregion内联函数//避免函数跳转对于程序的额外开销//有两种写法1）.h中写实现文件(在.h中同时写声明和实现)//2）inline关键字......
  • 有两个篮子，分别为A 和 B，篮子A里装有鸡蛋，篮子B里装有苹果，请用面向对象的思想实现两个篮
    packagecom.huang.algorithm;/***面向对象思想实现篮子物品交换*/publicclassDemo04{publicstaticvoidmain(String[]args){Basketbasket1=newBasket("篮子1");Basketbasket2=newBasket("篮子2");basket1.load(&qu......
  • 继承性#java#面向对象
    继承性子类（也称为派生类）继承父类（也称为基类），子类就获取到了父类中声明的所有属性和方法（构造方法不能继承，只能在子类构造方法第一行调用父类的构造方法）。但是由于封装性的影响，可能子类不能直接调用父类中的属性和方法（如父类中声明为private）。继承提高了代码的复用性子类继承父......
  • 多态性#java#面向对象
    多态性静态多态：也称为编译期间的多态，编译器在编译期间完成的，主要通过函数重载实现。编译器根据相同函数名的不同参数列表，可推断出要调用哪个函数。publicclassPerson{publicvoidsay(){System.out.println("我是第一个名为say的方法！");}publicvo......
  • 面向对象
    day07总结笔记01-面向对象介绍面向对象并非是一个技术,而是一种编程的思想这种思想可以指导我们以什么思路解决问题,以什么思路来组织代码问题:为什么要学习这种思想?因为这套思想,来源于生活,生活中解决问题,就是一系列的对象,在一起打交道,从而将问......
  • python面向对象（一）
    面向对象(ObjectOrientedProgram)在Python中，所有的数据（包括数字和字符串）实际都是对象，同一类型的对象都有相同的类型。我们可以使用type()函数来获取关于对象的类型信息。什么是类，什么是对象？在Python中，使用类来定义同一种类型的对象。类（class）是广义的数据类型，能够定义复......
  • java基础 韩顺平老师的 面向对象（基础） 自己记的部分笔记
    194，对象内存布局基本数据类型放在堆里面，字符串类型放在方法区。栈：一般存放基本数据类型（局部变量）堆：存放对象（Catcat，数组等）方法区：常量池（常量，比如字符串），类加载信息 196，属性注意细节1，属性可以是基本数据类型，也可以是引用类型（对象，数组）2，属性的定义语法同变量，示例：访问修饰符属......
  • Java面向对象之封装性
    封装性我要用洗衣机，只需按开关即可，无需了解洗衣机的内部结构。以上这句话可能大家在搜索学习封装性的时候可能都听过，可是这句话严重误导了我。可能是由于面向过程的学习太过深刻，我联想到了函数，函数不就是把洗衣服的过程全部“封装”起来了吗？我只需要调用函数方法就可以了呀，确......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99