python基础第二十课(面向对象2)

面向对象的三大特征

• 封装 : 提高程序的安全性

  • 将数据(属性)和行为(方法)包装到类对象中,在方法内部对属性进行操作,在类对象的外部调用方法,这样,无需关心方法内部的具体实现细节, 从而隔离了复杂度
  • 在Python中没有专门的修饰符用于属性的私有, 如果该属性不希望在类对象外部被访问, 前面使用两个"_".

• 继承 : 提高代码的复用性

• 多态 : 提高程序的可扩展性和可维护性

封装

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

    def get_age(self):
        return self.__age

    def set_age(self, age):
        self.__age = age


stu1 = Student('张三', 150)
print(stu1.name, stu1.get_age())  # 张三 150
stu1.set_age(20)
print(stu1.get_age())  # 20
print(stu1._Student__age)  # 20 获取私有变量

继承

• 语法格式

class 子类类名(父类1, 父类2 ...) :
	pass

• 如果一个类没有继承任何类, 则默认继承object
• Python支持多继承
• 定义子类时, 必须在其构造函数中调用父类的构造函数

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

    def info(self):
        print('姓名:{0}, 年龄:{1}'.format(self.name, self.age))


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


s1 = Student('小明', 20, 100)
s1.info()

方法重写

• 如果子类对继承自父类的某个属性或方法不满意, 可以在子类中对其(方法体)进行重新编写
• 子类重写后的方法中可以通过super().xxx调用父类中被重写的方法

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

    def info(self):
        print('姓名:{0}, 年龄:{1}'.format(self.name, self.age))


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

    def info(self):
        print('姓名:{0}, 学号:{1}'.format(self.name, self.score))


s1 = Student('小明', 20, 100)
s1.info()

Object类

• object类是所有类的父类,因此所有类都有object类的属性和方法
• 内置函数dir()可以查看指定对象所有属性
• Object有一个__str__()方法,用于返回一个对于"对象的描述", 对应于内置函数str()经常用于print()方法, 帮我们查看对象的信息, 所以我们经常会对__str__()进行重写

o = object()
print(dir(s1))
print(dir(o))

多态

• 即便不知道一个变量所引用的对象到底是什么类型, 仍然可以通过这个变量调用方法, 在运行过程中根据变量所引用对象的类型, 动态决定调用哪个对象中的方法

class Animal(object):
    def eat(self):
        print('动物要吃东西')


class Dog(Animal):
    def eat(self):
        print('狗吃肉')


class Cat(Animal):
    def eat(self):
        print('猫吃鱼')


class Person(object):
    def eat(self):
        print('人吃五谷杂粮')

def fun(an):
    an.eat()

fun(Dog())  # 狗吃肉
fun(Person())  # 人吃五谷杂粮

特殊方法和特殊属性

• 特殊属性
  • dict : 获得类对象或实例对象所绑定的所有属性和方法的字典

class A:
    pass


class B:
    pass


class C(A, B):
    def __init__(self, name, age):
        self.name = name
        self.age = age


x = C('小明', 20)
print(x.__dict__)  # {'name': '小明', 'age': 20}
# 输出了对象所属的类
print(x.__class__)  # <class '__main__.C'>
# C类的父类类型的元素
print(C.__bases__)  # (<class '__main__.A'>, <class '__main__.B'>)
print(C.__mro__)  # 类的层次结构
# 查看A的子类
print(A.__subclasses__())  # [<class '__main__.C'>]

• 特殊方法
  • len() : 通过重写__len__()方法, 让内置函数len()的参数可以是自定义类型

在这里插入代码片

• add() : 通过重写__add__()方法,可使用自定义对象具有"+"功能

# 实现两个对象的加法运算
class Student:
    def __init__(self, name):
        self.name = name
    def __add__(self, other):
        return self.name + other.name
    def __len__(self):
        return len(self.name)
s1 = Student('张三')
s2 = Student('李四')
# 实现了两个对象的加法运算
s = s1 + s2
print(s)  # 张三李四
print(len(s1))  # 2

• new() : 用于创建对象
• init() : 对创建的对象进行初始化

类的赋值与浅拷贝

• 变量的赋值操作
  • 只是形成两个变量, 实际上还是指向同一个对象

class CPU:
    pass

c1 = CPU()
c2 = c1
print(c1, id(c1))
print(c2, id(c2))

• 浅拷贝
  • Python拷贝一般都是浅拷贝, 拷贝时, 对象包含的子对象的内容不拷贝, 因此, 源对象与拷贝对象会引用同一个子对象

# 浅拷贝
import copy
computer2 = copy.copy(computer)
# <__main__.Computer object at 0x00000277E431C9C8>
# <__main__.CPU object at 0x00000277E431C908>
# <__main__.Disk object at 0x00000277E431C988>
print(computer, computer.cpu, computer.disk)
# <__main__.Computer object at 0x00000277E431CA88>
# <__main__.CPU object at 0x00000277E431C908>
# <__main__.Disk object at 0x00000277E431C988>
# 浅拷贝, 所以cup和disk对象只有一个
print(computer2, computer2.cpu, computer2.disk)

• 深拷贝
  • 使用copy模块的deepcopy函数, 递归拷贝对象中包含的子对象, 子对象和拷贝对象所有的子对象也不相同

computer3 = copy.deepcopy(computer)
# <__main__.Computer object at 0x00000277E431C9C8>
# <__main__.CPU object at 0x00000277E431C908>
# <__main__.Disk object at 0x00000277E431C988>
print(computer, computer.cpu, computer.disk)
# <__main__.Computer object at 0x000002B2FFAB46C8>
# <__main__.CPU object at 0x000002B2FFAB4708>
# <__main__.Disk object at 0x000002B2FFAB4F08>
# deepcopy实现了深拷贝, 子对象和拷贝对象所有的子对象也不相同
print(computer3, computer3.cpu, computer3.disk)