想学Python的工程师学习之封装、继承和多态

# 项目名称：
# 程序实现目的：
# 开发时间： 2020/12/9 13:55
# 面向对象的三大特征：封装、继承和多态
# 封装：提高程序的安全性
# 继承：提高代码的复用性
# 多态：提高程序的可扩展性和可维护性

# 封装的实现
class Student:
    def __init__(self,name,age):
        self.name=name
        self.__age=age # 年龄不希望在类的外部被使用，所以加了两个_
    def show(self):
        print(self.name,self.__age)

stu=Student('张三',20)
stu.show()
# 在类的外部使用name和age
print(stu.name)
# print(stu.__age) # AttributeError: 'Student' object has no attribute '__age'
print(dir(stu))
print(stu._Student__age) # 在类的外部可以通过_Student__age进行访问

# 继承
# 语法格式：
# class 子类类名（父类1，父类2...）
#       pass
# 如果没有继承任何类，则默认继承object
# Python支持多继承
# 定义子类时，必须在其构造函数中调用父类的构造函数
# class Person(object):
#     def __init__(self,name,age):
#         self.name=name
#         self.age=age
#     def info(self):
#         print(self.name,self.age)
#
# class Student(Person):
#     def __init__(self,name,age,stu_num):
#         super().__init__(name,age)
#         self.stu_num=stu_num
#
# class Teacher(Person):
#     def __init__(self,name,age,teachofyear):
#         super().__init__(name,age)
#         self.teachofyear=teachofyear
#
# stu=Student('张三',20,'1002')
# tea=Teacher('李四',56,20)
#
# stu.info()
# tea.info()

# 方法重写
# 如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其方法进行重写
# 子类重写后的方法，可以通过super（）调用父类中被重写的方法
class Person(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,self.age)

class Student(Person):
    def __init__(self,name,age,stu_num):
        super().__init__(name,age)
        self.stu_num=stu_num
    def info(self): # 重写
        super().info()
        print(self.stu_num)

class Teacher(Person):
    def __init__(self,name,age,teachofyear):
        super().__init__(name,age)
        self.teachofyear=teachofyear
    def info(self): # 重写
        super().info()
        print(self.teachofyear)

stu=Student('张三',20,'1002')
tea=Teacher('李四',56,20)

stu.info()
tea.info()

# object类
# object类是所有类的父类，因此所有类都有object类的属性和方法
# 内置函数dir（）可以查看指定对象所有属性
# object类有一个__str__（）方法，用于返回一个对象的描述，对应于内置函数__str__()经常
# 用于print（）方法，帮我们查看对象的信息，所以我们经常会对__str__()进行重写
class Stu:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
        return '我的名字是{0}，今年{1}岁了！'.format(self.name,self.age)
stu1=Stu('秀月',25)
print(dir(stu1))
print(stu1) # 默认调用__str__()方法

# 多态
# 简单的说，就是即便不知道所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，
# 在运行过程中根据变量所引用对象的类型，动态决定调用哪个对象中的方法
class Animal(object):
    def eat(self):
        print('动物会吃')
class Dog(Animal):
    def eat(self):
        print('狗吃骨头')
class Cat(Animal):
    def eat(self):
        print('猫吃鱼')

class Person:
    def eat(self):
        print('人吃五谷杂粮')
# 定义一个函数
def fun(obj):
    obj.eat()

# 开始调用函数
fun(Cat())
fun(Dog())
fun(Animal())
print('--------------------')
fun(Person())
# Python是动态语言
# 静态语言和动态语言关于多态的区别
# 静态语言实现多态的三个必要条件：继承、方法重写、父类引用指向子类对象
# 静态语言实现多态必须明确继承关系

# 特殊的属性
print(dir(object))
class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age
class D(A):
    pass
#创建C类的对象
x=C('Jack',20) # x是C类的一个实例对象
print(x.__dict__) # 实例对象的属性字典
print(C.__dict__)
print(x.__class__) # 输出对象所属的类
print(C.__bases__) # 输出C类的父类
print(C.__base__) # 输出位置靠前的父类
print(C.__mro__) # 查看类的层次结构
print(A.__subclasses__()) # 查看子类的列表

# 特殊方法
a=20
b=100
c=a+b # 两个整数类型的对象的相加操作
d=a.__add__(b)
print(c)
print(d)

class Stu2:
    def __init__(self,name):
        self.name=name
    def __add__(self, other):
        return self.name+other.name
    def __len__(self):
        return len(self.name)

stu5=Stu2('张三')
stu6=Stu2('李四')
# s=stu5+stu6 # 实现了两个对象的加法运算（编写__add__()特殊的方法）
s=stu5.__add__(stu6)
print(s)
print('-----------------')
lst=[11,22,33,44]
print(len(lst))
print(lst.__len__())
print(len(stu5)) # 方法重写

class Person(object):
    def __new__(cls, *args, **kwargs):
        print('__new__被调用执行了，cls的id值为：{0}'.format(id(cls))) # 8440
        obj=super().__new__(cls)
        print('创建的对象的id为：{0}'.format(id(obj))) # 0120
        return obj

    def __init__(self,name,age): # 用于初始化对象
        print('__init__被调用了，self的id值为：{0}'.format(id(self))) # 0120
        self.name=name
        self.age=age

print('object这个类对象的id为：{0}'.format(id(object))) # 6752
print('Person这个类对象的Id为：{0}'.format(id(Person))) # 8440

# 创建Person类的实例对象
p1=Person('张三',20)
print('p1这个Person类的实例对象的id为：{0}'.format(id(p1))) # 0120

# 类的浅拷贝与深拷贝
# 变量的赋值操作
class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu=cpu
        self.disk=disk
# 1、变量的赋值
cpu1=CPU()
cpu2=cpu1
print(cpu1)
print(cpu2)
# 变量的赋值操作，只是形成两个变量，实际上还是指向同一个对象
# 2、类的浅拷贝
print('------------------------')
disk=Disk() # 创建一个类对象
computer=Computer(cpu1,disk)
# 浅拷贝
import copy
computer2=copy.copy(computer)
print(computer,computer.cpu,computer.disk)
print(computer2,computer2.cpu,computer2.disk)
# Python拷贝一般都是浅拷贝，对象包含的子对象内容不拷贝，因此源对象与拷贝对象会引用同一个子对象
# 3、深拷贝
print('-------------------')
computer3=copy.deepcopy(computer)
print(computer,computer.cpu,computer.disk)
print(computer3,computer3.cpu,computer3.disk)
# 使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同