python学习记录day-13封装继承多态AND拷贝

目录

封装

私有属性

继承

object类

多继承

方法重写

多态

特殊的属性和方法

特殊属性

特殊方法

add方法 

len方法 

__new__方法和__init__方法

浅拷贝与深拷贝

---

封装

# 面向对象的三大特征：封装继承和多态
'''
封装：提高程序安全性
继承：提高代码复用性
多态：
'''
class Car: # 封装
def __init__(self,brand):
self.brand=brand
def start(self):
print('汽车已启动....')
car=Car('宝马车')
car.start()
print(car.brand)

私有属性

# 类：__修饰私有属性
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) # 外部不可使用
# print(dir(stu))
print(stu._Student__age) # 强制访问，考验程序员道德素养

继承

object类

# 如果一个类没有继承任何类，则默认继承object类
class Person(object): # 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_no):
super().__init__(name,age) # 继承父类
self.stu_no=stu_no
class Teacher(Person):
def __init__(self,name,age,teachofyear):
super().__init__(name,age) # 继承父类
self.teachofyear=teachofyear

stu=Student('张三',20,'1010')
teacher=Teacher('李四',34,10)

stu.info() # info（）是继承父类的
teacher.info()

多继承

# 多继承
class A(object):
pass

class B(object):
pass

class C(A,B): # C有两个父类
pass

方法重写

父类提供的方法不能满足子类的需求时可以重写

class Person(object): # 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_no):
super().__init__(name,age) # 继承父类
self.stu_no=stu_no
def info(self): # 重写方法
super().info() # 还想使用父类方法，继承父类的方法
print(self.stu_no)
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,'1010')
teacher=Teacher('李四',34,10)

stu.info() # info（）是继承父类的
print('---------------')
teacher.info()

# object类是所有类的父类
class Student:
def __init__(self,name,age):
self.name=name
self.age=age
def __str__(self):
return '我的名字是{0}，今年{1}岁'.format(self.name,self.age)
stu=Student('张三',20)
print(dir(stu)) # 继承object类的方法
print(stu) # 默认调用__str__()这样的方法，但是我们把方法重写了
print(type(stu))

多态

python属于动态语言

# 多态
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(animal):
animal.eat()

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

特殊的属性和方法

# 特殊的属性和方法
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('------------------------')
print(x.__class__) # 输出对象所属类型
print(C.__bases__) # C类的父类类型的元素
print(C.__base__) # 输出多继承第一位的（基类）
print(C.__mro__) # 继承关系
print(A.__subclasses__()) # 查看子类

特殊方法

# 特殊方法

add方法 

a=20
b=100
c=a+b # 整数类型相加
d=a.__add__(b) # 实际底层实现原理
print(c)
print(d)

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)
stu1=Student('Jick')
stu2=Student('李四')
s=stu1+stu2 # 实现了两个对象的加法运算（因为在Student类当中，编写了ADD方法）
print(s)
s=stu1.__add__(stu2)
print(s)

len方法 

print('-------------------')
lst=[11,22,33,44]
print(len(lst)) # 内置函数len
print(lst.__len__())
print(len(stu1)) # 直接用报错，，需要编写len函数

__new__方法和__init__方法

# __new__方法和__init__方法
# new创建对象（前)
# init为实例对象赋值(后）
class Person(object): # 对照图更好理解
def __new__(cls, *args, **kwargs):
print('__new__被调用执行了，cls的id值为{0}'.format(id(cls)))
obj=super().__new__(cls)
print('创建的对象的id为：{0}'.format(id(obj)))
def __init__(self,name,age):
print('__init__被调用了，self的id值为：{0}'.format(id(self))) # format会把括号内容扔给前面字典
self.name=name
self.age=age

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

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)
# 总结：浅拷贝时对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象
print('--------------------------')
# 深拷贝
computer3=copy.deepcopy(computer)
print(computer,computer.cpu,computer.disk)
print(computer3,computer3.cpu,computer3.disk)
# 总结：递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不同

 

学习地址：

【花了2万多买的Python教程全套，现在分享给大家，入门到精通(Python全栈开发教程)】 https://www.bilibili.com/video/BV1wD4y1o7AS/?p=120&share_source=copy_web&vd_source=5f93c948050b4284ccf31ae9244fad4c