Python中的父类子类用法

父类子类用法

继承

（1）语法格式
class 子类类名(父类1,父类2…):
pass

print('---------------------继承------------------------')
class Animal:
    def __init__(self, name, year):
        self.name = name
        self.year = year
    def tiger(self):
        print(self.name, self.year)
class Animal1(Animal):
    pass
zoo = Animal1('tiger', 10)
zoo.tiger()

print('---------------------多继承------------------------')
class A:
    pass
class B:
    pass
class C(A, B):
    pass

(2）如果一个类没有继承任何类，则默认继承object
(3）在继承中，如果子类定义了构造方法，则父类的构造方法__init__不会自动被调用，需要用到super函数调用父类。

print('---------------------super------------------------')
'''
在内部直接传入数据
'''
class Animal2(Animal):
    def __init__(self):
        super(Animal2, self).__init__('tiger', 10)
zoo = Animal2()
zoo.tiger()
print('---------------------super------------------------')
'''
在外部传入数据
'''
class Animal3(Animal):
    def __init__(self, name, year, ss):
        super().__init__(name, year)
        self.ss = ss
zoo = Animal3('tiger', 10, 20)
zoo.tiger()
print(zoo.ss)

多态

多态就是“具有多种形态”，它指的是：即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量的调用方法，在运行过程中根据变量所引用对象的类型，动态决定调用哪个对象中的方法。
当子类和父类存在相同的方法的时候，子类的方法会覆盖父类的方法，这样代码在运行时总会调用子类的方法，这就是多态。
判断一个实例是不是某个对象，可以使用isinstance()函数，是则输出True，反之输出False

print('---------------------多态------------------------')
class Animal:
    def say(self):
        print('Animal')
class Dog(Animal):
    def say(self):
        print('Dog')
class Cat(Animal):
    def say(self):
        print('Cat')
animal = Animal()
animal.say()
dog = Dog()
dog.say()
cat = Cat()
cat.say()
print('-------------------------isinstance()----------------------')
print(isinstance(dog, Dog))
print(isinstance(dog, Cat))
print(isinstance(dog, Animal))

封装

（1）封装：提高程序的安全性
将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。
在Python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用两个“-”。
（2）继承：提高代码的复用性
（3）多态：提高程序的可扩展性和可维护性

object类

（1）object类是所有类的父类，因此所有类都有objec类的属性和方法。
（2）内置函数dir()可以查看指定对象所有属性
（3）objec有一个_str_()方法，用于返回一个对于“对象的描述”，对于内置函数str()经常用于print()方法，帮我们查看对象的信息，所以我们经常会对_str_()进行重写

特殊方法和特殊属性

print('-----------------------------------------------------')
class A:
    pass
class B:
    pass
class D(A):
    pass
class C(A, B):
    def __init__(self, name, age):
        self.name = name
        self.age = age
print('----------------------特殊属性-----------------------')
x = C('ss', 10)
print('----------------__dict__----------------')
print(x.__dict__) # 实例对象的属性字典
print(C.__dict__) # 类对象的属性字典
print('----------------------------------------')
print(x.__class__) # 输出了对象所属的类
print(C.__bases__) # C类的父类类型的元组
print(C.__base__) # C类的父类的第一个类
print(C.__mro__) #查看类的层次结构
print(A.__subclasses__()) # 子类的列表
print('----------------------特殊方法-----------------------')
print('--------------__add__整数相加操作----------------')
a = 20
b = 10
c = a+b
d = a.__add__(b)
print(c)
print(d)
print('--------------__add__----------------')
class Student:
    def __init__(self, name):
        self.name = name
    def __add__(self, other): # 可以使stu1+stu2进行相加
        return self.name + other.name
stu1 = Student('aa')
stu2 = Student('bb')
s = stu1+stu2
print(s)
s1 = stu1.__add__(stu2)
print(s1)
print('--------------__len__----------------')
class Student:
    def __init__(self, name):
        self.name = name
    def __len__(self): #可以使name的长度成功输出
        return len(self.name)
stu1 = Student('aa')
stu2 = Student('bb')
print('-----------------------')
lst = [11,22,33,44]
print(len(lst))
print(lst.__len__())
print(len(stu1))

类的浅拷贝与深拷贝

浅拷贝

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

print('----------------------类的浅拷贝与深拷贝------------
class Cpu:                                        
    pass                                          
class Disk:                                       
    pass                                          
class Computer:                                   
    def __init__(self, cpu, disk):                
        self.cpu = cpu                            
        self.disk = disk                          
# 变量的赋值                                           
cpu1 = Cpu() # 创建Cpu类对象                           
cpu2 = cpu1                                       
disk = Disk() # 创建Disk类对象                         
computer = Computer(cpu1, disk) # 创建Computer类对象   
import copy                                       
print('--------------------浅拷贝-----------------') 
computer2 = copy.copy(computer)                   
print(computer, computer.cpu, computer.disk)      
print(computer2, computer2.cpu, computer2.disk)   

深拷贝

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

print('--------------------深拷贝-----------------') 
computer3 = copy.deepcopy(computer)               
print(computer, computer.cpu, computer.disk)      
print(computer3, computer3.cpu, computer3.disk)