面向对象 异常处理

面向对象和面向过程

    面向过程：核心过程二字，过程即解决问题的步骤，就是先干什么后干什么

    基于该思想写程序就好比在这是一条流水线，是一种机械式的思维方式

    优点：复杂的过程流程化

    缺点：扩展性差

    面向对象：核心是对象二字，对象指特征与技能的结合体

    基于该思想编写程序就好比在创造一个世界，世界是由一个个对象组成，是一种‘上帝式’的思维方式

    优点：可扩展性强

    缺点：编程复杂度高，极容易出现过度设计的问题

类

    对象是特征与技能的结合体，类就是一系列对象相似的特征与技能的结合体

    在现实生活中：一定是先有一个个具体的对象，后总结出类

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

# class Students:
#     school = '薪享宏福'
#     #初始化
#     def __init__(self,name,phone):
#         self.name = name
#         self.phone = phone
#
#     def run(self):
#         print('running......')
#
# stu1 = Students('吉喆', 110)
# print(stu1.name)
# print(stu1.phone)
# stu1.run()
# stu2 = Students('李凯', 120)
# print(stu2.name)
# print(stu2.phone)
# stu2.run()

面向对象有三大特性:

  1.封装

        1.封装是面相对性一大特点

　　　2.面向对象编程的第一步--将属性和方法封装到一个抽象的类当中

　　　　3.外界使用类创建对象，然后让对象调用方法

　　　　4.对象方法的细节都被封装在类的内部

# 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)
# xiaoming.eat()
# xiaoming.eat()
# xiaoming.run()
# print(xiaoming)

    2.继承

 　　目标：

　　　　单继承

　　　　多继承

　　　　继承：

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

class Anamal:
    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()

方法重写：

#重写哮天犬叫唤的方法
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()

 # 3.多态

　　面向对象的三大特性：

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

 定义类的准则

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

 设计类的技巧

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

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

　　　　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)

异常处理；

'''

什么是异常？

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

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

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

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

异常处理：

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

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

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

'''

try:

代码体

except：  #当try下面的部分遇到错误时，执行except下面的代码

代码体

finally： #不论上面执行成功，都会执行finally下面的代码

代码体

ps:

1.except 错误类型

只要遇到指定的类型的错误时，才会执行except下面的代码

2.except 错误类型 as e:

print(e)

将原生错误打印出来

自定义错误：

class MyError(Exception): #先自定义一个错误类，该类继承exception

    def __init__(self,age):

        self.age=age

 

 

def ag():

    age=int(input('输入年龄：'))

    if age<=0 or age>100:

        raise MyError('年龄只能在0到100岁之间')#raise 返回错误的内容

 

try:

     ag()

except MyError as e:

    print(e)