day14-异常和面向对象

2023-11-25 14:16:22

异常捕捉

1. 异常 - 错误

代码在执行过程中如果遇到异常，程序会中断执行(会提前结束)

2. 捕获异常

捕获异常的目的：在程序遇到异常的时候可以继续执行
什么时候需要捕获异常：明明知道可能会出现异常，但是又没有办法通过修改代码来避免异常，程序在异常出现的时候要继续执行。
结构1 - 捕获所有类型的异常

try:
    代码段1（需要捕获异常的代码）
except:
    代码段2（捕获到异常后会执行的代码）
finally:
    代码段

执行过程：先执行代码段1，如果没有出现异常就不会执行代码段2，直接执行后面的其他代码；
如果出现异常，程序不会报错，直接执行代码段2，然后再执行后面的其他代码。
结构2 - 捕获指定类型的异常

try:
    代码段1（需要捕获异常的代码）
except 异常类型:
    代码段2（捕获到异常后会执行的代码）
finally:
    代码段

结构3 - 同时捕获多种异常，不同的异常做相同的处理

try:
    代码段1（需要捕获异常的代码）
except (异常类型1, 异常类型2, ...):
    代码段2（捕获到异常后会执行的代码）
finally:
    代码段

结构4 - 同时捕获多种异常，不同的异常做不同的处理

try:
    代码段1（需要捕获异常的代码）
except 异常类型1:
    代码段11
except 异常类型2:
    代码段22
except 异常类型3:
    代码段33
...
finally:
    代码段

# try:
#     age = int(input('请输入年龄:'))
#     age += 1
# except:
#     print('年龄输入有误，必须是整数!')
# print('后续其他的功能')


# print('abc'[4])         # IndexError
# print(10 + '1')           # TypeError
# print(int('12a'))         # ValueError

# try:
#     print(10 + '1')
# except IndexError:
#     print('捕获到异常!')

3. finally

异常捕获的完整结构：try-except-finally
finally的存在不影响try-except的功能，finally后面的代码段不管前面发生什么都会执行

try:
    print('aaa' + 100)
except IndexError:
    print('不获取到异常')
finally:
    print('finally')

编程思想

1. 面向过程(穷人思想) - 语法+逻辑

2. 函数式(小资思想) - 函数

3. 面向对象(富豪思想) - 类和对象

# 求1+2+3+...+100
# sum1 = 0
# for x in range(1, 101):
#     sum1 += x
# print(sum1)


# sum(range(101))
def sum_yt(num):
    sum1 = 0
    for x in range(1, num+1):
        sum1 += x
    return sum1

class Math:
    @classmethod
    def sum_yt(cls, num):
        sum1 = 0
        for x in range(1, num+1):
            sum1 += x
        return sum1

    @classmethod
    def factorial(cls, num):
        pass

类和对象

1. 概念

类 - 类就是拥有相同属性和相同功能的对象的集合（一个抽象的概念）
对象 - 对象就是类的实例 (具体的一个事物)

2. 定义类 - 创建类(用代码来描述类)

用代码说清楚，这个类共同的属性-属性(类属性和对象属性)和功能-方法(函数-方法)有哪些？

语法：
class 类名: 
    类说明文档
    类的内容(属性和方法)
    
说明：
class       -       关键字，固定写法
类名         -       程序员自己命名；
                    要求：标识符，不是关键字
                    规范：见名知义；采用驼峰式命名，首字母大写；不使用系统的函数名、类名或者模块名
:           -       固定写法
类说明文档   -        本质就是多行注释
类的内容     -        由属性和方法两个部分组成
                     属性：类属性、对象属性
                     方法：对象方法、类方法、静态方法

class Person:
    """人类"""
    pass

3. 创建对象

语法：类名()
p1 = Person()
p2 = Person()
print(p1, p2) # <main.Person object at 0x10324e8e0> <main.Person object at 0x10324e8b0>

对象方法

类的内容：属性(对象属性、类属性) + 方法(对象方法、类方法、静态方法)

1. 方法

方法就是定义在类中的函数 - 本质是函数

2. 对象方法

怎么定义：直接定义在类的函数就是对象方法
怎么调用：通过 ‘对象.’ 的方式去调用
特点：有个默认参数self，通过对象调用对象方法的时候默认参数self不用传参，系统会自动将当前对象传给self（谁调用self就指向谁）

class Student:
    def study(self):
        print(f'self1:{self}')
        print('学习')

    def eat(self, food='米饭'):
        print(f'self2:{self}')
        print(f'干饭:{food}')
stu = Student()    # stu是Student类的对象
print(f'stu:{stu}')

# 对象方法的参数self在调用的时候不用传参
stu.study()
stu.eat('包子')


# class Rect:
#     def __init__(self, length, width):
#         self.length = length
#         self.width = width
#
#     def area(self):
#         return self.length * self.width
#
#
# r1 = Rect(10, 5)
# r2 = Rect(3, 2)
# print(r1.area())
# print(r2.area())

初始化方法

1.初始化方法

类中函数名是__init__的对象方法就是初始化方法
初始化方法是Python魔法方法中的一个，所有的魔法方法方法名前后都有两个下滑线，并且都不需要程序员来调用
1)__init__在创建类的对象的时候会被自动调用（每次创建都会调用）
2)创建对象的时候需不需要实参，需要几个实参由类中__init__方法决定

class Student:
    def __init__(self, x, y=20):
        print('初始化！')


stu1 = Student(10)
stu2 = Student(100, 200)
stu3 = Student(y=33, x=22)

print(int(10).bit_length())

码农公寓