面向对象基础（中）

相信大家都有这样的经历：我们进入一家商店的时候经常会听到一个喇叭播放说，欢迎光临，当我们出商店的时候也会提醒说欢迎光临，现实中这是通过感应器触发的，但是在程序中我们是如何触发实现呢，这就是我们要介绍的，析构函数

1、析构方法

当一个对象被删除或者被销毁时，python解释器也会默认调用一个方法，这个方法为__del__()方法，也称为析构方法。
程序执行结束自动调用__del__方法，对象被释放后将不会被保存，再次调用的时候会报错

class Animal:def __init__(self,name):self.name=nameprint('这是一个初始化方法')passdef __del__(self):print('这是析构方法，用来释放内存')print('{}对象被释放'.format(self.name))passpass
cat=Animal('小花猫')

class Animal:def __init__(self,name):self.name=nameprint('这是一个初始化方法')passdef __del__(self):print('这是析构方法，用来释放内存')print('{}对象被释放'.format(self.name))passpass
cat=Animal('小花猫')
# 当程序还在运行的时候不会删除对象，因为不知道还会不会再用到，故del没有执行
input('程序在等待。。。')

添加手动释放

class Animal:def __init__(self,name):self.name=nameprint('这是一个初始化方法')passdef __del__(self):print('这是析构方法，用来释放内存')print('{}对象被释放'.format(self.name))passpass
cat=Animal('小花猫')
# 手动释放对象
del cat
# 当程序还在运行的时候不会删除对象，因为不知道还会不会再用到，故del没有执行
input('程序在等待。。。')

从下面的输出结果中，我们可以看出，当我们调用del dog 这条语句时__del__方法被执行了

析构方法小结：

1、当整个程序脚本执行完毕后会自动调用__del__方法
2、当对像被手动销毁时也会自动调用 del 方法
3、析构函数一般用于资源回收，利用__del__方法销毁对象回收内存等资源

2、在python中展现买你洗那个对象的三大特征：

封装、继承和多态

封装：指的是把内容封装到某个地方，便于后面的使用；对于封装，其实就是使用初始化构造方法将内容封装到对象中，然后通过对象直接或者self来获取被封装的内容；
继承：在现实生活中，继承一般指的是子女继承父辈的财产。和现实生活中的继承是一样的，儿子可以继承父亲的内容【属性和行为】（爸爸有的儿子都有，但是儿子有的爸爸不一定都有）
多态：所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态。

2.1 单继承

在面向对象中同样有继承，例如：
猫的方法：喵喵叫、吃、喝
狗的方法：汪汪叫、吃、喝
如果给猫和狗都创建一个类，那么猫和狗的所有方法都要写,如：

class Animal:  # 父类def eat(self):print('吃饭了')passdef drink(self):passpass
# 子类
class dog(Animal):  # 继承父类def wwj(self):print('小狗汪汪叫')passpass
class cat(Animal):def mmj(self):print('小猫喵喵叫')passpass# 单继承，只用关注不一样的就行了，一样的就用父类继承过来
d1=dog()
d1.eat()  # 继承了父类的行为
d1.wwj()
c1=cat()
c1.eat()
c1.mmj()

总结：在定义子类时要继承父类，只需要类名后面的小括号()中写上父类的名字，那么父类的属性、方法，会被继承给子类。

2.2 多继承

class shenxian:def fly(self):print('神仙都会飞')passpass
class Monkey:def chitao(self):print('猴子爱吃桃')passpass
class Sunwukong(shenxian,Monkey): # 孙悟空既是神仙又是猴子pass
swk=Sunwukong()
swk.fly()
swk.chitao()

同名方法：如果在上面的多继承例子中，如果父类A和父类B中，有一个同名的方法，那么通过子类去调用的时候，调用哪个？

class D():def eat(self):print('D.eat')passpass
class C(D):# def eat(self):#     print('c.eat')#     passpass
class B(D):# def eat(self):#     print('B.eat')pass
class A(B,C):passa=A()
# 在执行eat的时候，查找的顺序是：先A中找，没有，去B中，B有输出，然后中断
a.eat()
print(A.__mro__)  # 查询查找的顺序，也是继承的顺序

前面代码查找顺序为 A->B->C->D, 一旦找到，则寻找过程立即中断，便不会再继续找了，如果都没找到就报错

2.3 继承的传递

在现实中遗产继承，爷爷的遗产可以被父亲继承，儿子可以继承父亲的。这样看来是不是儿子也是有继承到爷爷的遗产。在面向对象中的继承呢？子类是否能继承父类的父类的方法？

案例

看看下面的继承关系，Son类继承Father类，Father类并没有提供eat方法，但是父类又继承了Grandfather类。Son的对象调用eat方法可以正常执行，运行结果得出，Son类也继承了Granderfather类的方法。这就是继承的传递性。

class grandfather:def eat(self):print('吃饭')passpass
class father(grandfather):pass
class son(father):pass
s=son()
s.eat()
print(son.__mro__)

总结：类的传递过程中，我们把父类又称为基类，子类又称为派生类，父类的属性和方法可以一级一级的传递到子类

2.4 重写父类方法（方法覆盖）

所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法伪代码示例：

# 重写：父类方法已经不能满足子类的需求，需要重写或完善父类
class Dog:def bark(self):print('汪汪叫。。。')passpass
class keji(Dog):def bark(self):  # 属于重写父类方法print('像小猫一样叫。')passpass
kj=keji()
kj.bark()

2.5 调用父类方法

如果在子类中有一个方法需要父类的功能，并且又要添加新的功能。如果直接重写父类方法，那么就要重复写很多代码。那么这就要调用父类方法

# 重写：父类方法已经不能满足子类的需求，需要重写或完善父类
# 调用：有时候急需要继承有需要完善，就需要我们调用了，因为重写会太繁琐
class Dog:def __init__(self,name,color):self.name=nameself.color=colordef bark(self):print('汪汪叫。。。')passpass
class keji(Dog):def __init__(self,name,color):  # 属于重写父类的方法# 针对调用，需要调用父类的函数# Dog.__init__(self,name,color)  # 1、手动调用父类的方法，执行完毕就可以具备name和color这两个实例属性了super().__init__(name,color)  # 2、自动调用，会自己找到对应的父类self，多个父类的时候会按照顺序查找# 扩展其他属性self.height=90self.weight=20passdef __str__(self):return '{}的颜色是{}，它的身高是{}cm，体重是{}公斤'.format(self.name,self.color,self.height,self.weight)def bark(self):  # 属于重写父类方法print('像小猫一样叫。')passpass
kj=keji('柯基犬','红色')
kj.bark()
print(kj)

2.6 多态：定义时的类型和运行时的类型不一样，此时就成为多态。

两个前提：
继承：必须存在继承关系，必须在父类和子类之间
重写：子类重写父类的方法
多态的优势：
增加程序的灵活性
增加程序的扩展性

class Animal:'''父类（基类）'''# 说话的行为def say_who(self):print('我是一只动物。。。。')passpass
class duck(Animal):'''子类：鸭子类'''def say_who(self):  # 子类重写父类的方法print('我是一只鸭子')passpass
class dog(Animal):'''子类：小狗类'''def say_who(self):print('我是一只小狗')passpass
class cat(Animal):'''子类：小猫类'''def say_who(self):print('我是一只小猫')passpass
print('*****重写调用****')
yz=duck()
yz.say_who()
xg=dog()
xg.say_who()
xm=cat()
xm.say_who()
print('********循环调用(多态的优势）****')
# 新增子类更方便
class bird(Animal):'''子类：小鸟类'''def say_who(self):print('我是一只小鸟')passpass
def commmon(obj):'''统一调用的方法:param obj: 对象的实例:return:'''obj.say_who()
listobj=[duck(),dog(),cat(),bird()]
for i in listobj:'''循环调用函数'''commmon(i)

2.6 属性：类属性和实例属性

类属性：就是类对象所拥有的属性，它被所有类对象的实例对象所共有，类对象和实例对象可以访问
实例属性：实例对象所拥有的属性，只能通过实例对象访问
所有实例对象的类对象指针指向同一类对象。实例属性在每个实例中独有一份，而类属性是所有实例对象共有一份

class student:name='黎明'  # 属于类属性，student所有def __init__(self,age):self.age=age   # 实例属性passpass
lm=student(18)
print(lm.name)  #通过实例对象访问类属性
print(lm.age) # 通过实例对象访问实例属性
print('************通过类对象 student 访问name类属性***')
print(student.name)
print('************通过类对象 student 访问age实例类属性（报错）****')
# print(student.age)

修改类属性

class student:name='黎明'  # 属于类属性，student所有def __init__(self,age):self.age=age   # 实例属性passpass
lm=student(18)
print(lm.name)  #通过实例对象访问类属性
lm.name='刘德华' # 通过实例对象不能修改类属性，只是新生成一个实例属性而已
print(lm.name)
print(lm.age) # 通过实例对象访问实例属性
print('*****xh的信息******')
xh=student(18)
print(xh.name)  #通过实例对象访问类属性
print('************通过类对象修改类属性xh的信息***')
student.name='刘德华'
xh=student(18)
print(xh.name)  #通过实例对象访问类属性

类属性的所有权归类对象所有，所以只能通过类对象来修改，不能通过实例对象修改。

2.7 类方法和静态方法

类方法：
类对象所拥有的方法，需要用装饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数，类方法可以通过类对象，实例对象调用
类方法主要可以对类属性进行访问、修改
类方法的第一个参数是类对象cls，通过cls引用的类对象的属性和方法

class people:country='china'@classmethod  # 标识符标识后，实例方法就变成类方法就归类对象所有，而不是实例所有def get_country(cls):  # 不标识的时候是实例方法，标识一下就变成类方法,cls也可以换其他的表示return  cls.country  # 类方法访问类属性pass@classmethoddef change_country(cls,country):cls.country=country #通过类方法修改类属性passpassprint(people.get_country())  # 通过类对象引用
p=people()  # 创建实例对象
print('实例方法访问类对象{}'.format(p.get_country()))
print('****修改后的信息********')
people.change_country('英国')
print(people.get_country())  # 通过类对象引用

静态方法：

类对象所拥有的方法，需要用@staticmethod来表示静态方法，静态方法不需要任何参数（也可以穿参数，一般不传)
由于静态方法主要来存放逻辑性的代码，本身和类记忆实例对象没有交互。也就是说，在静态方法中，不会涉及类中的方法和属性的操作，数据资源能够得到有效的充分利用。

class people:country='china'@classmethod  # 标识符标识后，实例方法就变成类方法就归类对象所有，而不是实例所有def get_country(cls):  # 不标识的时候是实例方法，标识一下就变成类方法,cls也可以换其他的表示return  cls.country  # 类方法访问类属性pass@classmethoddef change_country(cls,country):cls.country=country #通过类方法修改类属性pass@staticmethoddef getdata():return people.countrypassprint('******类对象调用*****')
print(people.get_country())
print('******实例对象调用*****')
p=people()
print(p.get_country())  # 一般情况下，静态方法不会让实例对象访问，占资源

# demo 返回当前的系统时间
import time
class timetest:def __init__(self,hour,min,second):self.hour=hourself.min=minself.second=secondpasspass@staticmethod  # 这个功能是独立的def showtime():return time.strftime('%H:%M:%S',time.localtime())  pass
passprint(timetest.showtime())  #静态方法中引用类属性的话，必须通过类对象来引用。

求知讲堂python+人工智能day8相关推荐

求知讲堂python+人工智能 99天完整版学完可就业+某某教程Python 100例————作业（持续更新）
个人答案仅供参考,不喜勿喷. 求知讲堂python+人工智能 99天完整版学完可就业 1.day1 1. import random index=1 error=0 age=random.randi ...
求知讲堂python+人工智能day4
python函数基本上所有的高级语言都支持函数,Python也不例外.Python不但能非常灵活地定义函数,而且本身内置了很多有用的函数,可以直接调用.函数就是最基本的一种代码抽象的方式. 1.函数 ...
求知讲堂python+人工智能day11
文件操作与模块文件操作是很常见的功能,我们python当然也支持,python自带文件的基本操作方法,但是借助os等模块更加方便快捷.在学习过程中,我们时不时会用到模块,这里也将详细讲解模块.常用模 ...
求知讲堂python+人工智能day6
Python内置函数任何一门编程语言的核心操作都是操作内存中的数据,但内存中的数据又是通过编程语言的API来实现,所谓的API,就是系统提供给我们的函数,有一种函数是系统预先定义的函数,也就是我们安 ...
求知讲堂python+人工智能day5
Python函数2 1.函数的基本类型 2.全局变量和局部变量局部变量就是在函数内部定义的变量(作用域仅仅在函数内部): 不同的函数可以定义相同的局部变量,互不影响. 作用:为了临时的保存数据,需 ...
求知讲堂python+人工智能day7
python面向对象基础(上) Python从设计之初就已经是一门面向对象的语言,正因为如此,在Python中创建一个类和对象是很容易的.本章节我们将详细介绍Python的面向对象编程. 1.面向对象 ...
如何学习python+人工智能
做个自我介绍,我13年考上一所很烂专科民办的学校,学的是生物专业,具体的学校名称我就不说出来献丑了.13年我就辍学了,我在那样的学校,一年学费要1万多,但是根本没有人学习,我实在看不到希望,我就退学了 ...
哈佛大学(2020)《CS50 Python人工智能入门》课程资料下载
关注上方"深度学习技术前沿",选择"星标公众号", 资源干货,第一时间送达! [导读]本课程探讨现代人工智能基础上的概念和算法,深入探讨游戏引擎.手写识别和机器 ...
干货丨机器学习必备：前20名Python人工智能和机器学习开源项目
如今机器学习和人工智能已经变得家喻户晓,有很多爱好者进入了该领域.但是,什么才是能够进入该领域的正确路径呢?如何保持自己跟上该领域的发展步伐呢? 为了解决以上两个问题,可以通过利用高级专业人员每天使用 ...

求知讲堂python+人工智能day8