Python面向对象

1. 面向对象

1.1 面向对象的三大特征

　　1) 封装

　　2) 继承

　　3) 多态

 

1.2 面向对象和面向过程

　　面向过程：核心过程二字，过程即解决问题的步骤，就是先干什么后干什么。基于该思想写程序就好比在这是一条流水线，是一种机械式的思维方式。

　　优点：复杂的过程流程化。

　　缺点：扩展性差。

　    面向对象：核心是对象二字，对象指特征与技能的结合体。基于该思想编写程序就好比在创造一个世界，世界是由一个个对象组成，是一种“上帝式”的思维方式。
       优点：可扩展性强。
       缺点：变成复杂度高，极容易出现过度设计的问题。

2. 类

　　 对象是特征与技能的结合体，类就是一系列对象相似的特征与技能的结合体。
　　 在现实生活中：一定是先有一个个具体的对象，后总结出类；

　　 在程序中：一定是先定义类，后产生对象。

　　 定义类用命令class，定义类名字最好用驼峰式命名法。

类的定义和类的实例化：

#定义类
class StudentsInfo:                    #定义类
    class_a = '1902'                   #类的属性
    def __init__(self,name,age):       #定义初始化函数，用以区分对象
                                       #self：谁调用谁就是self
        self.name = name               #对象属性
        self.age = age                 #对象属性
    def run(self):                     #用函数定义特征，self自加
        print('%s is running' % self.name)

#实例化，产生对象
stu1 = StudentsInfo('zxj',23)
print(stu1.class_a)                    #调用属性
stu1.run()                             #1调用self为1
print('-------------华丽的分割线----------------')
stu2 = StudentsInfo('wrl',24)
print(stu2.class_a)                    #调用属性
stu2.run()                             #2调用self为2

result：
1902
zxj is running
-------------华丽的分割线----------------
1902
wrl is running

3. 封装

　　封装是面相对性一大特点，面向对象编程的第一步就是将属性和方法封装到一个抽象的类当中；外界使用类创建对象，然后让对象调用方法；对象方法的细节都被封装在类的内部。

　　封装案例1：

　    需求：

　　　1> 小明体重75公斤；

　　　2> 小明每次跑步都会减肥0.5公斤；

　　　3> 小明每次吃东西体重会增加1公斤。

#定义类
class Person:
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight
    def run(self):
        self.weight -= 0.5
    def eat(self):
        self.weight += 1
    def __str__(self):          #定义str函数，打印return的返回值
        return '%s的体重为%s' % (self.name,self.weight)
#产生对象
zxj = Person('小周',75)
print(zxj)

result：
小周的体重为75

调用对象时自动执行str函数将其打印，这就是__str__函数的意义。
zxj = Person('小周',75)
zxj.run()                      #调用技能
zxj.run()
zxj.run()
print(zxj)
result：
小周的体重为73.5

zxj = Person('小周',75)
zxj.run()
zxj.run()
zxj.run()
zxj.eat()
print(zxj)

result：
小周的体重为74.5

　　封装案例2：

　　需求：

　　　　1> 房子有户型、总面积、家具名称列表；

　　　　　 房子没有任何家具；

　　　　2> 家具有名字和占地面积，其中；

　　　　　 席梦思(bed):4平米；

　　　　　 衣柜(chest): 2平米；

　　　　　 餐桌(table): 1.5平米；

　　　　3> 将以上3个家具添加到房子中；

　　　　4> 打印房子中，要求输出:户型、总面积、剩余面积、家具名称列表。

class Item:                                         #定义家具
    def __init__(self,name,area):
        self.name = name
        self.area =area
class House:                                        #定义房子
    def __init__(self,name,total_area):
        self.name = name
        self.total_area = total_area
        self.free_area = total_area
        self.items = []
    def add_item(self,item):
        self.free_area = self.total_area - item.area
        self.items.append(item.name)
    def __str__(self):
        return '户型：%s|总面积：%s|剩余面积“%s|家具列表：%s' % (self.name,self.total_area,self.free_area,self.items)
house =  House('别墅',200)
print(house)

result:
户型：别墅|总面积：200|剩余面积“200|家具列表：[]

 
添加家具：
house =  House('别墅', 200)
bed =  Item('席梦思', 4)
chest = Item('衣柜', 2)
table =  Item('餐桌', 1.5)
house.add_item(bed)
house.add_item(chest)
house.add_item(table)
print(house)

result：
户型：别墅|总面积：200|剩余面积“192.5|家具列表：['席梦思', '衣柜', '餐桌']


封装案例三：

class Gun:                                         #创建枪类
    def __init__(self,gun_type):
        self.gun_type = gun_type                   #初始化枪的型号
        self.bullet = 0                            #初始化子弹的数量
    def add_count(self, count):                    #添加子弹
        self.bullet += count
    def shoot(self):                               #射击
        if self.bullet > 0:                        #假如子弹数量大于0
            self.bullet -= 1                       # 那就射击，并且减少子弹数量
            print('开火.......%s' % self.bullet)
        else:
            print('没有子弹啊，兄弟，别这么坑我啊？？？')#否则没有就显示没有子弹
class Soldier:                                     #创建一个士兵的类
    def __init__(self, name,gun=None):
        self.name = name                           #初始化士兵的姓名
        self.gun = gun                             #初始化枪
    def fire(self):                                #开火方法
        if self.gun:                               #假如有枪
            self.gun.shoot()                       #那就射击
        else:                                      #不然就显示没有枪
            print('没有枪啊，兄弟，你让我去送死吗？？')
ak47 = Gun('AK47')                                 #创建一个枪的对象叫ak47
ak47.add_count(10)                                 #添加10颗子弹
xsd = Soldier('许三多')                             #实例化一个许三多的士兵对象
xsd.gun = ak47                                     #把枪交到许三多手中
xsd.fire()                                         #开火
result:
开火.......9

4. 继承

　　继承实现代码的重用，相同的代码不需要重复的编写，继承包括单继承和多继承。

　　不继承地定义类代码有很多重复，使用继承可以降低代码的重复，减少代码量，然后再加上自己的技能属性。

　　继承只需要在定义类的括号里写上父类的名字。继承的鼻祖为object（新式类），定义类括号不加object则为旧式类；一般的定义习惯是：如果没有父类则将object写上。

　　多继承即在定义类时的括号里写入多个父类，对于多个父类，谁写前面谁优先级大。

class Anamal(object):
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')
class Dog(Anamal):
    def bark(self):
        print('汪汪叫')

class XiaoTianQuan(Dog):
    def fly(self):
        print('我会飞啦！！！！')
dog = XiaoTianQuan()
dog.eat()
dog.run()
dog.sleep()
dog.drink()
dog.bark()
dog.fly()
 
result：
吃
跑
睡
喝
汪汪叫
我会飞啦！！！！

　　方法的重写：

      　　 重新写一个方法覆盖掉原来的方法即可。

#重写哮天犬叫唤的方法
class Anamal(object):
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')
class Dog(Anamal):
    def bark(self):
        print('汪汪叫')

class XiaoTianQuan(Dog):
    def fly(self):
        print('我会飞啦！！！！')
    def bark(self):
        print('牛逼的叫.......')

dog = XiaoTianQuan()
dog.eat()
dog.run()
dog.sleep()
dog.drink()
dog.bark()
dog.fly()

　　对父类的方法进行扩展

　　　　1> 在子类中重写父类的方法

　　　　2> 在需要的位置使用super().父类方法来调用父类方法的执行

　　　　3> 代码其他的位置针对子类的需求，编写子类特有的代码实现

　　关于super

　　　　在python中super是一个特殊的类

　　　　super()就是使用super类创建出来的对象

　　最常使用的场景就是在重写父类方法时，调用在父类中封装的方法实现。

#用super继承父类的方法并扩展新内容
class Anamal(object):
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')
class Dog(Anamal):
    def bark(self):
        print('汪汪叫')

class XiaoTianQuan(Dog):
    def fly(self):
        print('我会飞啦！！！！')

    def bark(self):
        print('牛逼的叫.......')
        super().bark()
        print('%*#*@^$*(@')

dog = XiaoTianQuan()
dog.eat()
dog.run()
dog.sleep()
dog.drink()
dog.bark()
dog.fly()


result：
吃
跑
睡
喝
牛逼的叫.......
汪汪叫
%*#*@^$*(@
我会飞啦！！！！

5. 多态

　　面向对象的三大特性：

　　　　1> 封装根据职责将属性和方法封装到一个抽象的类中

　　　　　　定义类的准则

　　　　2> 继承实现代码的重用，相同的代码不需要重复的编写

　　　　　　设计类的技巧

　　　　　　子类针对自己特有的需求，编写特定的代码

　　　　3> 多态不同的子类对象调用相同的父类方法，产生不同的执行结果

　　　　　　多态可以增加代码的灵活度

　　　　　　以继承和重写父类方法为前提

　　　　　　是调用方法的技巧，不会影响到类的内部设计

#多态的特性：让不同的子类对象调用相同的代码产生不同的结果
class Dog(object):
    def __init__(self, name):
        self.name = name
    def game(self):
        print('%s 开开心心去玩耍.....' % self.name)

class XiaoTianQuan(Dog):
    def game(self):
        print('%s 开开心心去玩耍.....' % self.name)

class Person(object):
    def __init__(self, name):
        self.name = name
    def game_with_dog(self, dog):
        print('%s 和 %s 正在开开心心的玩耍......' % (self.name, dog.name))
        dog.game()

#创建人对象
xiaoming = Person('小明')
#创建狗对象
dog = Dog('旺财')
#让小明跟狗玩耍
xiaoming.game_with_dog(dog)

resut:
小明 和 旺财 正在开开心心的玩耍......
旺财 开开心心去玩耍.....

6. 异常处理

　　什么是异常？

　　异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。

　　一般情况下，在Python无法正常处理程序时就会发生一个异常。

　　异常是Python对象，表示一个错误。

　　当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。

　　异常处理：

　　捕捉异常可以使用try/except语句。

　　try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。

　　如果你不想在异常发生时结束你的程序，只需在try里捕获它。

　　语法：

　　以下为简单的try....except...else的语法：

try:
    正常的操作
   ......................
except:
    发生异常，执行这块代码
   ......................
else:
    如果没有异常执行这块代码

try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
    print("Error: 没有找到文件或读取文件失败")
else:
    print("内容写入文件成功")
fh.close()

result:
内容写入文件成功

　

　　try-finally 语句：

try:
<语句>
finally:
<语句>    #退出try时总会执行
raise

try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
finally:
    print("Error: 没有找到文件或读取文件失败")

result:
Error: 没有找到文件或读取文件失败

　　用户自定义异常：

　　通过创建一个新的异常类，程序可以命名它们自己的异常。异常应该是典型的继承自Exception类，通过直接或间接的方式。

　　以下为与RuntimeError相关的实例,实例中创建了一个类，基类为RuntimeError，用于在异常触发时输出更多的信息。

　　在try语句块中，用户自定义的异常后执行except块语句，变量 e 是用于创建Networkerror类的实例。

class MyError(Exception):
    def __init__(self,age):
        self.age=age
    # def __str__(self):
    #     return self.age

def ag():
    age=int(input('输入年龄：'))
    if age<=0 or age>100:
        raise MyError('年龄只能在0到100岁之间')
try:
     ag()
except MyError as e:
print(e)

result:
输入年龄：150
年龄只能在0到100岁之间

自定义异常