Python快速入门学习笔记：第五天

这个是为准备考研复试，希望做一个textCNN文本情感分析打语言基础的自学笔记，博主本身本科非计算机专业，如果网友们有幸看见本文，博客中内容如有疏漏，不吝赐教。

第7节 面向对象

7.1 继承

  继承作为实现代码复用的重要手段，一个新的类能够继承父类已经具有的特征就可以大大降低工作量。在Python中，提供了继承的语法格式：

class sub_name(super_name01[, super_name02,...,]):

如果在类中并没有明确指出一个类的父类，那么这个类的默认父类是object类。另外，在定义子类的时候，逻辑上必须在其构造函数中调用父类的构造函数。（虽然语法没有问题）

class Car:

    model = 0

    def __init__(self, make, year):
        self.make = make
        self.year = year

    def get_name(self):
        name = self.make + " " + str(self.year) + " " + str(self.model)
        return name.title()

    def print_odometer(self):
        print("This car has {0}".format(self.model))

    def update_odometer(self, mile):
        if mile >= self.model:
            self.model = mile
            print("This car has {0}".format(self.model))
        else:
            print("This car has " + self.model + " " + "now")


class ElectricCar(Car):
    def __init__(self, make, year):
        super().__init__(make, year)        # 或写成Car().__init__(make, year)


my_car = ElectricCar("BMW", 2020)
print(my_car.get_name())
my_car.print_odometer()
my_car.update_odometer(22000)

"""
输出结果：
Bmw 2020 0
This car has 0
This car has 22000
"""

在子类继承父类之后，子类可以继承父类除了构造方法之外的所有成员。但是，有时候会需要将父类中的某个方法的功能进行略微调整并在某个子类中体现出来，就需要用到方法的重写。

class ElectricCar(Car):
    def __init__(self, make, year):
        super().__init__(make, year)        # 或写成Car().__init__(make, year)

    def print_odometer(self):# 在子类中重写了父类的同名方法
        print("Override!")
"""
输出结果：
Bmw 2020 0
Override!
This car has 22000
"""

Python除了可以继承一个父类，还可以继承多个父类，如：

class A:
    def printA(self):
        print("A")
    def same(self):
        print("Same_A")
class B:
    def printB(self):
        print("B")

class C(A, B):
    def printC(self):
        print("C")


c = C()
c.printA()
c.printB()
c.printC()
c.same()
print(C.mro())

输出结果：
A
B
C
Same_A
[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]

多重继承可能遇到的问题就是，在多个父类中有同名的方法，那么此时子类需要按照继承的先后顺序来调用方法，另外我们也可以通过mro()方法来查看这个继承关系。

除了方法的重写，运算符也可以进行重载，这里有个表：

7.2 多态

  多态是当然同一个方法调用不同对象可能产生不同的行为，需要注意的是多态是方法的多态，属性没有多态；多态存在的两个必要条件就是：继承和重写

class Man:
    def eat(self):
        print("Eating...")

class Chinese(Man):
    def eat(self):
        print("Eating with chopsticks")

class English(Man):
    def eat(self):
        print("Eating with folk")

class Indian(Man):
    def eat(self):
        print("No tool")

def manEat(m):
    if isinstance(m, Man):
        m.eat() # 一个方法调用，根据对象不同显示不同结果
    else:
        print("Error")

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

"""
输出结果：
Eating with chopsticks
Eating with folk
No tool
"""

7.3 对象的浅拷贝和深拷贝

  变量的赋值操作只是形成了两个变量，但是还是指向同一个对象。Python当中的拷贝，一般是浅拷贝。拷贝时对象包含的子对象内容不拷贝，源对象和拷贝对象都会引用同一个子对象。而深拷贝使用了copy模块中的deepcopy函数，递归地去拷贝对象汇总包含的子对象。

# 变量赋值
class PersonalComputer:
    def __init__(self, cpu, screen):
        self.cpu = cpu
        self.screen = screen

class CPU:
    def calculate(self):
        print("CPU对象", self)

class Screen:
    def show(self):
        print("Screen对象", self)
# 变量赋值
m1 = PersonalComputer("R7 2700","AOC")
m2 = m1
print(m1)
print(m2)
"""
<__main__.PersonalComputer object at 0x000001EAAA4CD4F0>
<__main__.PersonalComputer object at 0x000001EAAA4CD4F0>
"""

# 浅复制与深复制
import copy
class MobilePhone:
    def __init__(self, cpu, screen):
        self.cpu = cpu
        self.screen = screen
class CPU:
    def calculate(self):
        print("CPU对象", self)
class Screen:
    def show(self):
        print("Screen对象", self)

# 变量赋值
c1 = CPU()
c2 = c1
print(c1)
print(c2)

#浅复制
s1 = Screen()
m1 = MobilePhone(c1, s1)
m2 = copy.copy(m1)
print(m1)
print(m2)

#深复制
m3 = copy.deepcopy(m1)
print(m1,m1.cpu,m1.screen)
print(m3,m3.cpu,m3.screen)

"""
<__main__.CPU object at 0x000001A8D8509760>
<__main__.CPU object at 0x000001A8D8509760>
<__main__.MobilePhone object at 0x000001A8D8509700>
<__main__.MobilePhone object at 0x000001A8D8562070>
<__main__.MobilePhone object at 0x000001A8D8509700> <__main__.CPU object at 0x000001A8D8509760> <__main__.Screen object at 0x000001A8D8509220>
<__main__.MobilePhone object at 0x000001A8D85D6640> <__main__.CPU object at 0x000001A8D860D520> <__main__.Screen object at 0x000001A8D860D5B0>
"""

7.3 组合

  组合可以体现类的整体与局部的关系，如：手机（手机屏，手机按键，接线口），人（手，脚，头）这样的关系。相比于继承，组合也是一个类似于继承的面向对象方法的体现。总之：继承是共性与个性的问题，组合是整体与局部的问题。

class Person:
    def __init__(self,head,foot):
        self.head = head
        self.foot = foot

class headcls:
    def think(self):
        print("Thinking")
class footcls:
    def run(self):
        print("Running")


h = headcls()
f = footcls()
p = Person(h, f)

p.head.think()
p.foot.run()

"""
Thinking
Running
"""