day14-异常和面向对象

2021-10-28 21:00:32 阅读：110 来源： 互联网

标签：self except 代码段 day14 面向对象 print 异常捕获

异常捕捉

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

标签：self,except,代码段,day14,面向对象,print,异常,捕获
来源： https://blog.csdn.net/m0_62840623/article/details/121022706

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9