python基础(九) 面向对象(三)

1173-杨同学

发表文章数:29

首页 » Python » 正文

面向对象三大特征

1.封装(隐藏)
隐藏对象的属性和实现细节,只对外提供必要的方法。相当于将“细节封装起来”,只 对外暴露“相关调用方法”。 通过前面学习的“私有属性、私有方法”的方式,实现“封装”。Python 追求简洁的 语法,没有严格的语法级别的“访问控制符”,更多的是依靠程序员自觉实现。
2.继承
继承可以让子类具有父类的特性,提高了代码的重用性。 从设计上是一种增量进化,原有父类设计不变的情况下,可以增加新的功能,或者改进 已有的算法。
3.多态
多态是指同一个方法调用由于对象不同会产生不同的行为。生活中这样的例子比比皆 是:同样是休息方法,人不同休息方法不同。张三休息是睡觉,李四休息是玩游戏。

继承

继承是面向对象程序设计的重要特征,也是实现“代码复用”的重要手段。 如果一个新类继承自一个设计好的类,就直接具备了已有类的特征,就大大降低了工作 难度。已有的类,我们称为“父类或者基类”,新的类,我们称为“子类或者派生类”。
Python 支持多重继承,一个子类可以继承多个父类。继承的语法格式如下:
class 子类类名(父类 1[,父类 2,…]): 类体
如果在类定义中没有指定父类,则默认父类是 object 类。也就是说,object 是所有类的父 类,里面定义了一些所有类共有的默认实现,比如:new()。 定义子类时,必须在其构造函数中调用父类的构造函数。调用格式如下: 父类名.init(self, 参数列表)
子类拥有父类的私有属性,但是不能直接调用。

#测试继承的基本使用

class Person:

    def __init__(self,name,age):
        self.name = name
        self.__age = age    #私有属性

    def say_age(self):
        print("年龄,年龄,我也不知道")


class Student(Person):

    def __init__(self,name,age,score):
        Person.__init__(self,name,age)  #必须显式的调用父类初始化方法,不然解释器不会去调用
        self.score = score


#Student-->Person-->object类
print(Student.mro())

s = Student("高淇",18,60)
s.say_age()
print(s.name)
#print(s.age)
print(dir(s))
print(s._Person__age)

类成员的继承和重写

  1. 成员继承:子类继承了父类除构造方法之外的所有成员。
  2. 方法重写:子类可以重新定义父类中的方法,这样就会覆盖父类的方法,也称为“重写”
#测试方法的重写

class Person:

    def __init__(self,name,age):
        self.name = name
        self.__age = age    #私有属性

    def say_age(self):
        print("我的年龄:",self.__age)

    def say_introduce(self):
        print("我的名字是{0}".format(self.name))


class Student(Person):

    def __init__(self,name,age,score):
        Person.__init__(self,name,age)  #必须显式的调用父类初始化方法,不然解释器不会去调用
        self.score = score

    def say_introduce(self):
        '''重写了父类的方法'''
        print("报告老师,我的名字是:{0}".format(self.name))


s = Student("高淇",18,80)
s.say_age()
s.say_introduce()

查看类的继承层次结构

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

object根类

object 类是所有类的父类,因此所有的类都有 object 类的属性和方法。

dir()查看对象属性

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

重写__str__()方法

object 有一个__str__()方法,用于返回一个对于“对象的描述”,对应于内置函数 str() 经常用于 print()方法,帮助我们查看对象的信息。str()可以重写。

#测试重写object的__str__()

class Person:       #默认继承object类

    def __init__(self,name):
        self.name = name

    def __str__(self):
        return "名字是:{0}".format(self.name)

p = Person("高淇")
print(p)

多重继承

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

MRO()

Python 支持多继承,如果父类中有相同名字的方法,在子类没有指定父类名时,解释器将 “从左向右”按顺序搜索。 MRO(Method Resolution Order):方法解析顺序。 我们可以通过 mro()方法获得 “类的层次结构”,方法解析顺序也是按照这个“类的层次结构”寻找的。

#测试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()

super()获得父类定义

在子类中,如果想要获得父类的方法时,我们可以通过 super()来做。
super()代表父类的定义,不是父类对象。(并不是new 一个对象)

#测试super(),代表父类的定义,而不是父类的对象

class A:

    def say(self):
        print("A:",self)


class B(A):

    def say(self):
        #A.say(self)
        super().say()
        print("B:",self)


B().say()

多态

指同一个方法调用由于对象不同可能会产生不同的行为
关于多态要注意以下 2 点:

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

class Man:
    def eat(self):
        print("饿了,吃饭啦!")

class Chinese(Man):
    def eat(self):
        print("中国人用筷子吃饭")

class English(Man):
    def eat(self):
        print("英国人用叉子吃饭")

class Indian(Man):
    def eat(self):
        print("印度人用右手吃饭")


def manEat(m):
    if isinstance(m,Man):
        m.eat()                 #多态。一个方法调用,根据对象不同调用不同的方法!
    else:
        print("不能吃饭")


manEat(Chinese())
manEat(English())

特殊方法和运算符重载

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

#测试运算符的重载


class Person:
    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基础(九) 面向对象(三)

对象的浅拷贝和深拷贝

·变量的赋值操作
只是形成两个变量,实际还是指向同一个对象。
·浅拷贝
Python 拷贝一般都是浅拷贝。拷贝时,对象包含的子对象内容不拷贝。因此,源对象 和拷贝对象会引用同一个子对象。
·深拷贝
使用 copy 模块的 deepcopy 函数,递归拷贝对象中包含的子对象。源对象和拷贝对象 所有的子对象也不同。

#测试对象的浅拷贝、深拷贝
import copy


class MobilePhone:
    def __init__(self,cpu,screen):
        self.cpu = cpu
        self.screen = screen


class CPU:
    def calculate(self):
        print("算你个12345")
        print("cpu对象:",self)

class Screen:
    def show(self):
        print("显示一个好看的画面,亮瞎你的钛合金大眼")
        print("screen对象:",self)

#测试变量赋值
c1 = CPU()
c2 = c1
print(c1)
print(c2)
print("测试浅复制....")
#测试浅复制
s1 = Screen()
m1 = MobilePhone(c1,s1)
m2 = copy.copy(m1)
print(m1,m1.cpu,m1.screen)
print(m2,m2.cpu,m2.screen)

#测试深复制
print("测试深复制....")
m3 = copy.deepcopy(m1)
print(m1,m1.cpu,m1.screen)
print(m3,m3.cpu,m3.screen)#均变化

组合

“is-a”关系,我们可以使用“继承”。从而实现子类拥有的父类的方法和属性。“is-a” 关系指的是类似这样的关系:狗是动物,dog is animal。狗类就应该继承动物类。
“has-a”关系,我们可以使用“组合”,也能实现一个类拥有另一个类的方法和属性。” has-a”关系指的是这样的关系:手机拥有 CPU。 MobilePhone has a CPU。

#测试组合

#使用继承实现代码的复用
class A1:

    def say_a1(self):
        print("a1,a1,a1")

class B1(A1):
    pass

b1 = B1()
b1.say_a1()


#同样的效果,使用组合实现代码的复用
class A2:
    def say_a2(self):
        print("a2,a2,a2")

class B2:
    def __init__(self,a):
        self.a = a

a2 = A2()
b2 = B2(a2)
b2.a.say_a2()

设计模式_工厂模式实现

工厂模式实现了创建者和调用者的分离,使用专门的工厂类将选择实现类、创建对象进 行统一的管理和控制。

#测试工厂模式

class CarFactory:
    def create_car(self,brand):
        if brand =="奔驰":
            return Benz()
        elif brand =="宝马":
            return BMW()
        elif brand == "比亚迪":
            return BYD()
        else:
            return "未知品牌,无法创建"

class Benz:
    pass

class BMW:
    pass

class BYD:
    pass

factory = CarFactory()
c1 = factory.create_car("奔驰")
c2 = factory.create_car("比亚迪")
print(c1)
print(c2)

设计模式_单例模式实现

单例模式(Singleton Pattern)的核心作用是确保一个类只有一个实例,并且提供一 个访问该实例的全局访问点。

#测试单例模式

class MySingleton:

    __obj = None           #类属性
    __init_flag = True

    def __new__(cls, *args, **kwargs):
        if cls.__obj ==None:
            cls.__obj = object.__new__(cls)

        return cls.__obj

    def __init__(self,name):
        if MySingleton.__init_flag:
            print("init.....")
            self.name = name
            MySingleton.__init_flag = False

a = MySingleton("aa")
b = MySingleton("bb")
print(a)
print(b)
c = MySingleton("cc")
print(c)

未经允许不得转载:作者:1173-杨同学, 转载或复制请以 超链接形式 并注明出处 拜师资源博客
原文地址:《python基础(九) 面向对象(三)》 发布于2020-07-10

分享到:
赞(0) 打赏

评论 抢沙发

评论前必须登录!

  注册



长按图片转发给朋友

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

Vieu3.3主题
专业打造轻量级个人企业风格博客主题!专注于前端开发,全站响应式布局自适应模板。

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录