python 三大属性

封装

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() #类外访问不到age
print(dir(stu))
print(stu._Student__age) #可以通过此格式访问

继承

class Person():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,self.age)
class Stu(Person):
    def __init__(self,name,age,sno):
        super().__init__(name,age)
        self.sno=sno
class Teacher(Person):
    def __init__(self,name,age,ty):
        super().__init__(name,age)
        self.ty=ty
stu1=Stu('张三',20,'1001')
t1=Teacher('李四',50,'20')
stu1.info()
t1.info()

方法重写

class Stu(Person):
    def __init__(self,name,age,sno): #学号
        super().__init__(name,age)   # 继承格式 super()__init__
        self.sno=sno
    def info(self):         #子类重新定义方法
        super().info()
        print(self.sno)
        
class Teacher(Person):
    def __init__(self,name,age,ty): #教龄
        super().__init__(name,age)
        self.ty=ty
        def info(self):     #子类重新定义方法
        super().info()
        print(self.ty)

#object类

class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age
#写完这个类，重写__str__方法，用于对这个对象的描述
#分则返回的是地址
    def __str__(self): 
        return f"名字：{self.name}\t 年龄：{self.age}"
stu=Student('zsy', 19)
print(stu)

多态

#多态
class Animal:
    def __init__(self,species,age):
        self.species=species
        self.age=age
    def eat(self):
        print(f"动物在吃饭")
class Dog(Animal):
    def __init__(self,species,age):
        super().__init__(species,age)
    def eat(self):
        print(f"{self.species}在吃饭，已经{self.age}岁了。")

class Tiger(Animal):
    def __init__(self,species,age):
        super().__init__(species,age)
    def eat(self):
        print(f"{self.species}在吃饭，已经{self.age}岁了。")  
def fun(a1):
    a1.eat()
    
an=Animal('动物',0)
an.eat()
dog1=Dog('哈士奇', 5)
fun(dog1)
t1=Tiger('老虎',7)
fun(t1)

特殊方法和特殊属性

class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age
x=C('zsy',20)    
print(x.__dict__)   #实例对象的属性字典

print(x.__class__)  #输出对象所属的类
print(C.__bases__)   #C类的父类
print(C.__mro__)     #类的层次对象

重定义类内方法

a=20
b=100
d=a.__add__(b)

class S:
    def __init__(self,name):
        self.name=name
    def __add__(self,other):
        return self.name+other.name
    def __len__(self):
        return len(self.name)
s1=S('张三')
s2=S('李四')
s_=s1+s2
s=s1.__add__(s2)
print(s_,s)  #实现了两个对象的加法运算（再类内编写__add()__特殊的方法）
 
print('**************************************')
lst=[1,23,4,5,6]
print(len(lst))
print(lst.__len__())
print(len(s1))

浅拷贝和深拷贝

class Cpu:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu=cpu
        self.disk=disk
        
# 简单类的等号赋值
# 就是把一个变量放到两个对象当中

#浅拷贝,对象包含的组对象内容不拷贝
#因此，源对象和拷贝对象会引用同一个子对象
cpu1=Cpu()
disk=Disk()
comp1=Computer(cpu1, disk)

import copy
comp2=copy.copy(comp1)
print(comp1,comp1.cpu,comp1.disk)
print(comp2,comp2.cpu,comp2.disk)
#不同对象，子对象却是相同的

#深拷贝，使用deepcopy函数，递归拷贝对象中包含的子对象
#源对象和拷贝对象所有的子对象也不相同
print('----------------------------------------')
comp3=copy.deepcopy(comp1)
print(comp1,comp1.cpu,comp1.disk)
print(comp3,comp3.cpu,comp3.disk)