python面向对象

面向对象介绍

一、面向对象和面向过程
面向过程：核心过程二字，过程即解决问题的步骤，就是先干什么后干什么基于该思想写程序就好比在这是一条流水线，是一种机械式的思维方式
优点：复杂的过程流程化
缺点：扩展性差

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

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

驼峰式命名法
class Students:
    school = '薪享宏福'
    def __init__(self,name, age):#初始化函数（区分不同对象的函数）
        self.name = name
        self.age = age
        #代表谁调用self，self就是谁
        #stu1.name = name
        #stu1.age = age
    def run(self):
        print('%s is running......' % self.name)
    def __str__(self):
        # 当打印实例化出来的对象的时候，会打印出__str__返回的值
        return '实例化  %s' % self.name

stu1 = Students('蒋介石',88)
print(stu1)

stu2 = Students('江青',77)
print(stu2)

封装

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

一、小明爱跑步
需求

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):
         return '%s 的体重是 %s' % (self.name, self.weight)

 xiaoming = Person('小明', 75)
 print(xiaoming)

二、房屋放置家具
需求：
1、房子有户型、总面积、家具名称列表
房子没有任何家具
2、家具有名字和占地面积，其中
席梦思(bed):4平米
衣柜(chest): 2平米
餐桌(table): 1.5平米
3、将以上3个家具添加到房子中
4、打印房子中，要求输出:户型、总面积、剩余面积、家具名称列表

定义几个类：2个类，1个房子类，1个家具类
定义类的顺序：先定义范围小的
家具有哪些特征：名字和占地面积
家具有哪些技能：没有技能
房子有哪些特征：户型，总面积，剩余面积，家具列表
房子有哪些技能：添加家具

class Item(object):
    def __init__(self,name,area):
        self.name = name
        self.area = area


class House(object):
    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):
        if item.area < self.free_area:
            self.items.append(item.name)
            self.free_area -= item.area
        else:
            print('%s太大了，放不进来' % item.name)

    def __str__(self):
        return '户型:%s   总面积:%s   剩余面积:%s   家具列表:%s' % 
(self.name,self.total_area,self.free_area,self.items)

bed = Item('席梦思', 4)
table = Item('餐桌', 1.5)
chest = Item('衣柜', 2)
house = House('地下室', 30)
TV = Item('电视', 35)
house.add_item(bed)
house.add_item(table)
house.add_item(chest)
house.add_item(TV)
print(house)

继承

目标：
单继承
多继承
继承：
继承实现代码的重用，相同的代码不需要重复的编写

image

class Animal:
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')
class Dog(Animal):
    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()

方法的重写

image

#重写哮天犬叫唤的方法
class Animal(object):
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')
class Dog(Animal):
    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 Animal(object):
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')
class Dog(Animal):
    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()

多态

面向对象的三大特性：
　　1.封装根据职责将属性和方法封装到一个抽象的类中
定义类的准则
　　2.继承实现代码的重用，相同的代码不需要重复的编写

• 设计类的技巧
• 子类针对自己特有的需求，编写特定的代码
  3.多态不同的子类对象调用相同的父类方法，产生不同的执行结果
  　1.多态可以增加代码的灵活度
  　2.以继承和重写父类方法为前提
  　3.是调用方法的技巧，不会影响到类的内部设计

image

#多态的特性：让不同的子类对象调用相同的代码产生不同的结果
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)

异常处理

什么是异常？
异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。
一般情况下，在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()

try-finally 语句：

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

 try:
     f = open('a.txt', 'r', encoding='utf-8')
     a = 100
     print(a)
 except:
     print('出错')
 finally:#不管正常与否都会执行finally下面的代码块
     f.close()

用户自定义异常：

通过创建一个新的异常类，程序可以命名它们自己的异常。异常应该是典型的继承自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)


class SB_ERROR(Exception):
    def __init__(self, info):
        self.info = info

def ad(age):
    if age == 100:
        raise SB_ERROR('年纪不能等于100')
try:
    ad(100)
except SB_ERROR as e:
    print(e)