Day14 Exception & Object-oriented

1 异常捕获

1.1什么是异常捕获

正常情况下程序出现异常，程序会直接崩溃，不能接着往后执行。异常捕获就是为了让程序出现异常的时候不崩溃，自己处理异常

1.2 异常捕获语法

1.2.1语法1 try-except（可以捕获所有异常）

try:
    代码块1
except:
    代码块2

其他语句

• 练习: 检查当前目录下是否有aaa.txt文件，如果没有就提示没有该文件，并且创建这个文件

try:
    open("aaa.txt", encoding="utf-8")
except:
    print("该文件不存在")
    open("aaa.txt", "w", encoding="utf-8")

• 执行过程: 先执行代码块1，在执行代码块1的过程中如果出现异常，程序不崩溃直接执行代码块2。 如果没有出现异常，不执行代码块2直接执行其他语句

1.2.2 语法二:(可以捕获某一种异常)

try:
    代码段1
except 异常类型:
    代码段2

• 执行过程: 先执行代码段1，如果在执行代码块1的过程中出现异常，检查出现的异常类型是否和except后面的异常类型是否一致，如果一致程序不崩溃，直接执行代码段2；如果不一致，程序直接崩溃。如果没有异常，直接执行后面其他语句

print("语句2")
try:
    value = int("23a45") # ValueError
    print("****")
except ValueError :
    print("ValueError")
print("其他语句")

1.2.3 语法三:

try:
    代码段1
except (异常类型1,异常类型2,...):
    代码段2

• 执行过程： 先执行代码段1，如果在执行代码块1的过程中出现异常，检查出现的异常类型是否和except后面的异常类型中一个是否一致，如果一致程序不崩溃，直接执行代码段2；如果不一致，程序直接崩溃。如果没有异常，直接执行后面其他语句

print("语句3")
try:
    print({"a": 1}["b"])
    value = int("df") # ValueError
    print([1, 2][4])  # IndexError

    print("****")
except (KeyError, IndexError, ValueError) :
    print("出现异常")
print("其他语句3")

1.2.4 语法四:

try:
    代码块1
except 异常类型1:
    代码块2
except 异常类型2:
    代码块3

try:
    print([1, 2][10])  # IndexError
    print(int('abc'))  # ValueError
    print({'a': 10}['b'])  # KeyError
except IndexError:
    print('下标越界')
except KeyError:
    print('键错误！')
except:
    print('其他异常')

• 执行过程： 先执行代码段1，如果在执行代码块1的过程中出现异常，检查出现的异常类型是否和except后面的异常类型1是否一致，如果一致程序不崩溃，直接执行代码段2；如果不一致，检查出现的异常类型是否和常类型2是否一致，如果一致程序不崩溃，直接执行代码段3；直到所有的异常类型检查完毕，若都不一致，则程序崩溃。如果没有异常，直接执行后面其他语句

• 上面的四种结构的最后都可以加上一个finally；不管try里面的代码有没有异常，异常有没有被捕获，finally后面的代码都会执行。 一般可以在这个地方做一些数据的保存和备份操作!

try:
    代码块1
except:
    代码块2
finally:
    代码块3

try:
    print([1, 2][10])  # IndexError
    print(int('abc'))  # ValueError
    # print({'a': 10}['b'])  # KeyError
except ValueError:
    print('出现下标越界')
finally:
    print('语句结束')

1.3 抛出异常: 主动让程序崩溃

• 语法:
  raise 异常类型
• 注意：异常类型可以是系统自带的，也可以是程序员自定义 (要求异常类型必须是Exception的子类)

让程序主动崩溃
raise IndexError
print('abc')

2 程序设计思想

• 编程思想分类
  • 面向过程编程: 遇到问题就考虑通过代码一步一步的去解决问题(不能停留，必须转换)
  • 函数式编程: 遇到问题就考虑是否能够有这样功能的一个函数
  • 面向对象编程: 遇到问题就考虑是否有这样一个类，拥有相应的功能和属性

# 求两个数的和

# 面向过程：
num1 = 1
num2 = 23
sum1 = num1 + num2
print(sum1)


# 函数式编程
def sum1(n1, n2):
    return n1 +n2


# 面向对象编程
class Math:
    @staticmethod
    def sum(n1, n2):
        return n1+n2

3 面向对象基础

3.1 类与对象

3.1.1 什么是类，什么是对象

• 类: 类是拥有相同功能和相同属性的对象的集合（抽象的）

• 对象: 对象就是类的实例 (具体)

  • 如果人是一个类，Python1902班的每个学员都是是人的对象;
  • 如果车是一个类，楼下那辆红色的车是车的对象;
  • 如果电脑是一个类, 我桌上的这台电脑就是电脑的对象

3.1.2 类的声明

python所有的数据类型都是类，每种类型对应的数据都是对象;比如int类是所有整数的集合（每个单独的整数都是int的对象）声明类就是自定义类型。

• 语法:
  class 类名:
  类的内容

• 说明

  • class - 声明类的关键字
  • 类名 - 自己命名，标识符不能是关键字; 见名知义;首字母大写，并且采用驼峰式命名(如果名字由多个单词组成，单词之间采用单词首字母大写的方式进行区分)
  • : - 固定写法
  • 类的内容 - 主要包含:类的说明文档、属性、方法(功能)

• 补充： 什么是方法 - 声明在类中的函数 (方法就是函数)

class Person:
    """类的说明文档: 人类"""
    def eat(self):
        print('吃东西!')

3.1.3 创建对象

对象是通过类来创建的

• 语法 类() - 创建指定类对应的对象

p1 = Person()
print(p1)

p2 = Person()
print(p2)

3.1.4 类中的方法

类中的方法其实就是声明在类中函数；类中的方法分为三种：

• 对象方
• 类方法
• 静态方法

3.1.5 对象方法

直接声明在类中的函数就是对象方法, 有个默认参数self, 需要使用'对象.'的方式去调用

• 对象方法中默认参数self，在通过对象调用的时候，这个参数不用传参，系统会自动将当前对象传递给它。哪个对象调用的当前方法，self就是谁！
• self本质就是当前类的对象，所以对象能做的事情self都可以做

class Person:
    def eat(self, food='米饭'):
        print('self:', self)
        print('吃东西!')
        self.run()
    
    def run(self):
        print('跑步')

p1 = Person()
p2 = Person()

print(p1, p2)

p1.eat()
p2.eat()

注意：对象方法从语法上来说可以使用'类.'的方式去使用，这样用self会失去它存在的意义，所以不要这样用！

list1 = [1, 2, 3] # 是list类的对象
list1.append(10) # 对象方法

3.1.6 init方法

• python所有的类中都有一个特殊的对象方法: init;
• 当通过类去创建对象的时候，系统会自动调用init方法，来对对象进行初始化操作。(*)
• 创建对象的时候需不需要参数，需要几个参数，看init方法 (*)
• 补充: python中以''开头并且以''结尾的方法叫魔法方法。所有的魔法都不需要程序员手动调用，系统会在需要的情况下自动调用
• 构造方法
  • 函数名和类名一样的方法就是构造方法。
  • python中，当我们声明类的时候，系统会自动给我们创建这个类的构造方法。
  • 方法中会先在内存中开辟空间创建对象，然后用创建好的对象去调用init方法对对象进行初始化,初始化完成后才将对象返回

"""
构造方法的伪代码
def Dog(*args, **kwargs):
    对象 = 创建对象 (在内存中开辟空间创建对象)
    对象.__init__(*args, **kwarges)
    return 对象
"""
print('===============模拟init和构造方法============')
def __init__(name, age):
    print('模仿init方法', name, age)

def Dog1(*args, **kwargs):
    # 创建对象
    __init__(*args, **kwargs)
    # 返回对象


Dog1(name='huahua', age = 10)

3.1.7 类的属性

• 属性分类
  属性分为: 类的字段、对象属性

• 类的字段

  • 声明: 直接声明在类中的变量就是类的字段
  • 怎么使用: 通过'类.'的方式去使用
  • 什么时候用: 属性的值不会因为对象不同而不同，就使用类的字段

• 对象属性

  • 声明：对象属性需要声明在init方法中, 以'self.属性=值'的方式来声明
  • 怎么使用：通过'对象.'的方式去使用
  • 什么时候用：属性的值会因为对象不同而不同，就使用对象属性

class Person:
    """类的说明文档: 人类"""
    # 1.属性
    num = 61
    
    def __init__(self, name1, age1=0):
        # 这儿的name和age就是Person类的对象属性
        self.name = name1
        self.age = age1
    
# 2.方法
# 使用字段
Person.num = 60
print(Person.num)

# 使用对象属性
p1 = Person('小明')
print(p1.name, p1.age)


p2 = Person('小花', 3)
print(p2.name, p2.age)

• 练习: 声明一个Dog类，有属性: 名字、年龄、颜色、品种。
  • 要求创建Dog对象的时候名字和颜色必须赋值，年龄可以赋值也可以不赋值，品种不能赋值！
  • 有一个吃的方法，要求不同的Dog对象，调用这个方法的时候打印'XXX(名字)在吃XXX(吃的东西)

class Dog:
    """狗类"""
    # 属性
    def __init__(self, name1, color1, age1=0):
        self.name = name1
        self.age = age1
        self.color = color1
        self.type = '无'
    
    # 方法
    def eat(self, food: str):
        print('%s在吃%s' % (self.name, food))


dog1 = Dog('花花', '白色', 3)
dog1.type = '泰迪'

dog2 = Dog('财财', '黄色', 1)
dog2.type = '中华田园犬'
print(dog1.name, dog2.name)
dog1.eat('骨头')

3.1.8 对象属性的增删改查

class Student:
    def __init__(self, name1, age1=18):
        self.name = name1
        self.age = age1
        self.stu_id = '001'


stu1 = Student('小明', 20)
stu2 = Student('小红')

• 查 - 获取对象属性的值
• 对象.属性 - 获取对象属性的值,属性不存在会报错
• getattr(对象,属性名) - 获取对象属性的值,属性不存在会报错
• getattr(对象,属性名, 默认值) - 获取对象属性的值,属性不存在不会报错，并且返回默认值

print(stu1.name)
print(getattr(stu1, 'name'))

p_name = 'name'
print(getattr(stu1, p_name))
# print(stu1.p_name)     # AttributeError: 'Student' object has no attribute 'p_name'

print(getattr(stu1, 'name1', '无'))

• 增/改 - 添加/修改属性
  • 对象.属性 = 值 - 当属性存在的时候修改属性的值，当属性不存在的时候添加属性
  • setattr(对象, 属性名, 值) - 当属性存在的时候修改属性的值，当属性不存在的时候添加属性

print('==============增/改==============')
stu1.name = '张三'
print(stu1.name)
setattr(stu1, 'age', 22)
print(stu1.age)

stu1.gender = '男'
print(stu1.gender)
setattr(stu1, 'score', 100)
print(stu1.score)

• 删 - 删除对象属性
  • del 对象.属性
  • delattr(对象, 属性名)

del stu1.stu_id
# print(stu1.stu_id)    #  AttributeError: 'Student' object has no attribute 'stu_id'

delattr(stu1, 'age')
# print(stu1.age)


# 注意： 对象属性的增删改查只针对单个对象
print(stu1.gender)
# print(stu2.gender)   # AttributeError: 'Student' object has no attribute 'gender'

stu1.names = 'xiaoming'
print(stu1.names)

3.1.9 slots魔法

class Person:

    # 在类中可以通过给__slots__赋值来约束当前类的对象有哪些对象属性
    __slots__ = ('name', 'age', 'gender', 'id')
    
    def __init__(self, name1, age1):
        self.name = name1
        self.age = age1
        # self.height = 180


p1 = Person('小敏', 10)
p1.gender = '男'

# p1.id = '小明'
# p1.name1 = '花花'

• 内置类属性：声明类的时候系统自动给类添加的属性

class Car:
    """说明文档: 车类"""
    num = 100
    
    def __init__(self, price1=50000, color1='黑色', brand1='丰田'):
        self.color = color1
        self.brand = brand1
        self.price = price1
        self.speed = 100
    
    def stop(self):
        self.speed = 0


car1 = Car()

# 1.内置类属性：声明类的时候系统自动给类添加的属性
# 1) __name__
"""
字段, 获取类的类名
"""
print(Car)
print(Car.__name__, type(Car.__name__))

# 2) __doc__
"""
字段, 获取类的说明文档
"""
print(Car.__doc__)


# 3) __class__
"""
对象属性, 获取对象的类
"""
C1 = car1.__class__
print(C1)

car2 = C1()
print('car2:', car2)

print([1, 2].__class__)

# 4)__dict__(重点)
"""
字段, 获取当前类所有的字段和字段对应的值以字典的形式返回(了解)
对象属性, 获取当前对象中所有的对象属性和对应的值
"""
print(Car.__dict__)
print(car1.__dict__)

# 5) __module__
"""
字段, 获取当前类所在(声明在哪儿)的模块的名字
"""
print(Car.__module__)


# 6) __bases__
"""
字段, 获取当前类的父类
"""
print(Car.__bases__)