python笔记三之面向对象（继承，封装，多态）

类和对象：

类是一组具有相同特征或者行为的事物的统称，是抽象的，不能直接使用
特征被称为属性
行为被称为方法
类的名命名，满足大驼峰的命名方法
对象是由类创建创建出来的具体存在的事物，可以直接使用
在自己定义的类中，能够定义属性和方法
类是模板，对象是根据类这个模板创建出来的，先有类，后有对象
类只有一个，而对象只有一个
不同的对象属性可能不同，类中有的属性和方法，对象就能调用这些属性和方法

python面向对象的基础语法

使用内置函数的dir可以查看到对象的所有属性和方法

定义类的方法：

class 类名:def 方法名1(self,参数列表):passdef 方法名2(self,参数列表):pass

创建对象：

对象名=Cat()
对象名.方法名
在计算机中，通常使用十六进制表示内存地址
%d可以以10进制输出数值
%x可以以16进制输出数字

哪个对象调用的方法，self就是哪个对象的引用

class Cat:def eat(self):print("%s爱吃鱼"%self.name)def drik(self):print("小猫爱喝水")
tom=Cat()
tom.name="Tom"
tom.drik()
tom.eat()
print(tom)
lazy_Cat=Cat()
lazy_Cat.name="dalanmao"
lazy_Cat.eat()
lazy_Cat.drik()
print(lazy_Cat)

初始化方法：
在python中专门用来定义一个类具有哪些属性的方法是__init__，这是对象的内置方法

class Cat:def __init__(self):print("初始化")
tom=Cat()
python中在使用类名()创建对象的时候，会自动调用初始化方法__init__

在初始化方法内部定义属性：

在__init__方法内部使用self.属性名=属性的初始值，就能定义属性
在定义属性之后，在使用Cat类创建对象，就能够调用该属性
__del__如果希望在对象销毁之前在做一些事情，就是用__del__方法
如果在开发中，希望使用print输出对象时，能够打印自定义的内容，就要用__str__这个内置方法返回的是一个字符串，不能直接打印，只能使用return返回
封装是面向对象的一大特征，将属性和方法都封装到一个类中，同一个类创建的对象，属性之间互不影响
在python中定义一个类之后需要再定义一个类，则需要空出两行重新写
在Python中如果不知道设置什么初始值，可以设置为None,None 表示一个空的对象，没有方法和属性值，是一个特殊的常量，可以赋值给任何的一个变量，在python中针对None进行比较时，使用is进行判断

面向对象实例一（摆家具）

#首先定义家居类，属性name，area，使用__str__内置函数返回家具的名称和家具的占地面积
class HouseItem:def __init__(self,name,area):self.name=nameself.area=areadef __str__(self):return"家具的名称是%s，家具的占地面积是%.2f"%(self.name,self.area)#创建一个房子类，房子的属性有house_type,总的占地面积area,空余的面积：free_area,家居类的列表，__str__内置函数输出房子的户型，房子的总面积，和房子的剩余面积，输出家具列表
#行为有add()方法,用于添加家具，
class House:def __init__(self,house_type,area):self.house_type=house_typeself.area=areaself.free_area=areaself.item_list=[]def __str__(self):return ("户型：%s\n总面积：%.2f\n[剩余面积：%.2f]\n家具：%s"%(self.house_type,self.area,self.free_area,self.item_list))def add(self,item):print("要添加的家具%s"%item)#判断家具面积if item.area>self.free_area:print("%s面积太大了，无法添加"%item)returnself.item_list.append(item.name)self.free_area-=item.area#将家具添加到列表中#计算剩余面积
# 创建三个家具类
bed=HouseItem("席梦思",40.0)
chest=HouseItem("衣柜",2.0)
table=HouseItem("餐桌",1.5)
print(bed)
print(chest)
print(table)
# 创建一个房子类，调用添加家具的方法
my_home=House("别墅",60)
my_home.add(bed)
my_home.add(chest)
my_home.add(table)
print(my_home)

面向对象实例二（士兵突击）

#创建一个枪的类，属性为枪的类型，行为是添加子弹，和射击
class Gun:def __init__(self,model):self.model=modelself.bullet_count=0def add_bullet_count(self,count):self.bullet_count+=countdef shoot(self):# 1.判断子弹数量if self.bullet_count<=0:print("%s没有子弹了，需要重新装填"%self.model)return# 2.发射子弹self.bullet_count-=1# 提示发射print("[%s]开始发射！【%d】"%(self.model,self.bullet_count))# 创建一个士兵的类，属性是名字，行为是开火
class Soldier:def __init__(self,name):self.name=nameself.gun=Nonedef fire(self):#判断是否有枪if self.gun is None:print("【%s】还没有得到枪"%self.name)return#士兵高喊口号print("冲啊！...【%s】"%self.name)#士兵装填子弹self.gun.add_bullet_count(50)#枪发射子弹self.gun.shoot()
ak=Gun("ak47")
sanduo=Soldier("许三多")
sanduo.gun=ak
print("%s的枪是"%sanduo.name,sanduo.gun)
sanduo.fire()

身份运算符：

身份运算符用于比较两个对象的内存地址是否一致，是否是一个对象的引用
运算符描述实例
is is是判断两个标识符是不是引用同一个对象 x is y，类似id(x)id(y)
is not is not是判断两个标识 x is not y, 类似于id(x)!=id(b)
is 和的区别：
is 用于判断两个变量的引用对象是否为同一个，比较的是内存的地址
== 用于判断引用变量的值是否想等

私有属性和私有方法：

在实际开发中，对象的某些属性和方法只希望在对象的内部使用，而不希望在外部被访问到
私有属性：对象不希望被公开的属性，不能够被直接访问
私有方法：对象不希望被公开的方法，不能被直接访问
定义的方式：
在定义属性和方法的时候，在属性名称或者和方法名称前面增加两个下划线，定义的就是私有的的属性和方法

Person
name__age
__init__(self,name):_secret(self):

私有方法的实例：
class Women:def __init__(self,name):self.name=nameself.__age=15def secret(self):print("%s的年龄是%d"%(self.name,self.age))
xiaohong=Women("小红")
print(xiaohong.age)
print(xiaohong.name)
xiaohong.secret()
无法进行访问，age的属性是私有保护的，不能进行直接访问

伪私有属性和方法：
python没有真正意义的私有
在给属性和方法命名时，_类名__age

继承：

面向对象的三大特性：
封装：根据职责将属性和方法封装到一个抽象的类中
继承：实现代码的重用，相同的代码不需要重新编写
单继承：
子类拥有父类的所有的属性和方法，继承具有传递性

继承的语法:
class 类名(父类名):
pass
dog类是animal类的派生类，animal是dog类的基类，dog类从animal类中派生

方法的重写：

子类拥有父类的所有的方法和属性
子类继承父类，可以使用父类中已经封装好的方法，当父类中的方法不能实现满足子类时，可以重写该方法
1.覆盖父类中的方法
在子类中定义一个和父类同名的方法并且实现。重写后会调用子类重写的方法，而不会再调用父类封装的方法

class Animal:def eat(self):print("吃东西")def run(self):print("跑步吧！")def sleep(self):print("睡觉觉")
class Dog(Animal):def bark(self):print("汪汪汪！")
class Xiaoming(Dog):def fly(self):print("我会飞!")def bark(self):print("我是二郎神下的一只神狗")
xiaotian=Xiaoming()
xiaotian.bark()
xiaotian.fly()
xiaotian.eat()

2.对父类进行扩展
重写父类中的方法
在需要的位置使用super().父类方法来调用父类方法的执行
代码其他的位置针对子类的需求，编写子类的特有方法实现
关于super
在python中supe()是一个特殊的类，super()就是使用super类创建出来的对象
常用在重写父类的方法时，调用父类中的封装方法实现

02多继承：

python支持多继承，子类可以拥有多个父类，并具有所有父类的属性和方法，在开发中，如果父类中存在同名的属性或者方法，应该尽量避免使用多继承
列如：孩子会继承父亲和母亲的特性
语法格式：

class 子类名(父类名1，父类名2....)
pass

class A:def test(self):print("小朋友！嘻嘻嘻")
class B:def demo(self):print("你好，请多多指教！")
class C(A,B):def tube(self):print("啦啦啦啦!")
c=C()
c.test()
c.tube()
c.demo()

object是python中为所有对象提供的基类，提供的有内置的方法和属性，可以使用dir查看
在定义类的时候，如果没有父类，建议继承来自object

class 类名(object):
pass

多态：不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度
多态可以增加代码的灵活度
以继承和重写父类的方法为前提
是调用的技巧，不会影响到内部的设计

面向对象之继承案列一：

class Dog:def __init__(self,name):self.name=namedef game(self):print("%s玩毛线"%self.name)
class Xiaotianquan(Dog):def game(self):print("%s喜欢在天上玩毛线"%self.name)
class Person:def __init__(self,name):self.name=namedef game_withdog(self,dog):print("%s喜欢和%s玩"%(self.name,dog.name))
dog=Xiaotianquan("哮天犬")
dog.game()
xiaoming=Person("小明")
xiaoming.game_withdog(dog)

创建出来的对象叫做类的实例
创建对象的动作叫做实例化
对象的属性叫做实例的属性
对象的调用方法叫做实例方法
每个对象都有自己的独立的空间，保存着各自独立的属性
多个对象的方法，在内存中只有一份，在调用方法是，需要把对象引用传递到方法内部
类是一个特殊的对象：
python中万物皆对象
class Person：定义类属于类对象
obj=Person() 实例化对象
在程序运行的时候，类会被加载到内存
在python中，类是一个特殊的对象—类对象
在程序运行的时候，类对象在内存中，只有一份，使用一个类就能创建出很多个对象实例
除了封装实例的属性和方法，可以有自己的属性和方法
类属性
类方法
类属性就是给类对象定义的属性，通常用来记录与这个类相关的特征(列如：能够记录创建工具对象的个数)，类属性不会用来记录具体对象的特征

class Person:#使用赋值语句定义类的属性，记录所有工具对象的数量count=0 def __init__(self,name):self.name=name#类属性的值+1Person.count+=1
xiaohong=Person("袁亚茹")
yangguanbing=Person("杨冠宾")
print(Person.count)

类方法：
类方法就是针对类对象定义的方法，在类方法内部可以直接访问类的属性或者调用其他的类方法

@classmethod
def 类方法名(cls):pass

类方法需要修饰器@classmethod来标识，告诉解释器这是一个类方法
类方法的第一个参数是cls
由哪一个类调用的方法，方法内的cls就是哪一个类的引用
与实例方法中的第一个参数是self类似
通过类名调用类方法，调用时不需要传递参数cls
在方法内部
可以使用cls.访问类的属性
也可以通过cls.调用其他的类方法
面向对象案列之类方法的调用

class Person:count=0def __init__(self,name):self.name=namePerson.count+=1@classmethoddef test(cls):print("工具类的数量是%d"%cls.count)yuanyaru=Person("袁亚茹")
yangguanbing=Person("杨冠宾")
Person.test()静态方法：
在开发的时候，如果需要在类中封装一既不需要访问实例属性，也不需要访问类属性大的方法，可以将这个方法定义为静态方法
语法如下：
@staticmethod
def 静态方法名():pass静态方法需要使用@staticmethod来标识，告诉解释器这是一个静态的方法，通过类名. 来调用静态的方法
综合案列一：
class Game:#定义类属性，记录历史最高分：top_score=0#定义类方法显示最高分@classmethoddef show_top_score(cls):print("历史最高分%d"%cls.top_score)#定义游戏的帮助信息@staticmethoddef show_help():print("帮助信息，让植物充满世界！")#实例化属性def __init__(self,name):self.player_name=name#实例方法def start_game(self):print("%s开始游戏了"%self.player_name)
Game.show_help()
Game.show_top_score()
test=Game("杨冠宾")
test.start_game()

异常的概念：
程序在运行的时候，如果遇到一个错误，就会停止程序的执行，并且显示一些错误信息，这就是异常
在程序停止执行结束后提示这个错误信息，就叫做抛出异常
捕获异常：
在程序开发中，如果对某些代码的执行不能确定是否正确，可以增加try(尝试)来捕获异常：

try:不确定是否执行的代码
except:出现的错误的时候，对错误的处理代码！

当python的解释器抛出异常的时候，最后一行错误信息的第一个单词就是错误类型

try:num=int(input("请输入一个整数！"))
except:print("请输入正确的整数！")print("--"*50)

捕获未知的错误：

如果希望程序无论出现任何错误，都不会因为python解释器抛出异常而被终止，可以增加一个except

except Exception as result:print("未知错误 %s"%result)

案例

try:num=int(input("请输入一个整数！"))
except Exception as result:print("未知错误%"%result)

异常捕获的完整语法：

else只有在没有异常的时候才会执行的代码
finally无论是否有异常，都会执行的代码
异常的传递：
当函数或者方法执行出现异常，会将异常传递给函数方法的调用的一方
如果传递到主程序，仍没有异常处理，程序会终止
在开发中，在主程序中增加异常的捕获，主函数中调用的其他的函数，只要出现异常，就会传递到主函数的异常的捕获中，保证代码的整洁

def dom1():return int(input("输入整数"))def dom2():return dom1()#利用异常的传递性，在主程序中捕获异常
try:print(dom2())
except Exception as result:print("%s"%result)

抛出raise异常

在开发中除了python的解释器会抛出异常外，还可以根据应用程序特有的需求，主动抛出异常
创建一个Exception的对象
使用rise关键字抛出异常对象

input_password():#提醒用户输入密码pwd=input("请输入密码：")
#判断密码的长度>=8返回用户输入的密码if len(pwd)>=8:return pwd
#如果<=8主动抛出异常else:print("主动抛出异常！")# 创建异常的对象,可以使用错误信息作为参数es=Exception("密码长度不是太够")#主动抛出异常raise es
#当对象没有任何返回的时候，就会输出一个空对象None
try:print(input_password())
except Exception as result:print(result)