day14- 异常和面向对象

异常和面向对象

1.异常 : 错误

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

print('===========')
# print('abc'[4])
print('-----------')
print('+++++++++++')

1.1捕获异常

捕获异常的目的：在程序遇到异常的时候可以继续执行

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

怎么捕获

结构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('捕获到异常!')

1.2finally

异常捕获的完整结构：try — except — finally

finally的存在不影响try — except的功能，finally后面的代码段不管前面发生什么都会执行

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

2.编程思想

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

3.类和对象

3.1概念

类 — 类就是拥有相同属性和相同功能的对象的集合

对象 — 对象就是类的实例（具体的一个事物）

人是类，某某人是人的对象

杯子是类，桌子上的这个杯子是对象

3.2定义类 — 创建类（用代码来描述类）

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

语法：

class 类名：

​ 类说明文档

​ 类的内容（属性和方法）

说明：

class - 关键字，固定写法

类名 - 程序员自己命名：

          要求：标识符，不是关键字

​ 规范：见名知义；采用驼峰式命名，首字母大写；不使用系统的函

​ 数名、类名或者模块名

： - 固定写法

类说明文档 - 本质就是多行注释

类的内容 - 由属性和方法两个部分组成

​ 属性：类属性、对象属性

​ 方法：对象方法、类方法、静态方法

student_name = 12
studentName = '小明'
StudentName = '类名'


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

3.3 创建对象

语法：类名（）

p1 = Person()
p2 = Person()
print(p1, p2)  # <__main__.Person object at 0x10324e8e0> <__main__.Person object at 0x10324e8b0>

4.对象方法

类的内容：属性（对象属性、类属性） + 方法（对象方法、类方法、静态方法）

4.1 方法

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

4.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()

5.初始化方法

类中函数名是_ _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())