day14_异常和面向对象基础

前言回顾

1.模块

import 模块 as 新名字 -> 导入全部变量
from 模块 import 变量1,变量2... as 新变量名1,变量2 -> 导入import之后的变量

通过import导入模块的时候会自动避免重复导入(即去重的功能)

阻止导入用下列语句，并放在末尾

if __name__ == '__main__':
    print('=====')

2.生成器、迭代器-iter(特色)

next(), for-in
(表达式 for 变量 in 序列)、(表达式 for 变量 in 序列 if 条件语句)

3.文件操作

打开文件、操作文件、关闭文件

with open() as 文件对象:
    操作文件

read() / readline()
write()

4.json数据

json转python: json.loads(json字符串)
python转json: json.dumps(python数据)

异常

1.异常捕获

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

2.异常捕获的语法

语法一: try-except(可以捕获所有的异常)

try:
代码块1
except:
代码块2
其他与句

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

语法二:

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

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

语法三:

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

语法四:

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

上面的四种结构最后都可以加上一个finally：不管try里面的代码有没有异常，异常有没有被捕获

finally后面的代码都会执行。一般可以在这个地方做一些数据的保存和备份操作！！

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

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

语法：
raise 异常类型

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

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

def main():
    # print('===语法一===')
    # try:
    #     print('+++++')
    #     list1 = [1, 2]
    #     print(list1[3])
    #     print('=====')
    # except:
    #     print('出现异常')
    # print('~~~~~')
    
    # print('===语法二===')
    # try:
    #     value = int(input('数字:'))  # ValueError
    #     # print([1, 2][4])  # IndexError
    # except ValueError:
    #     print('出现值错误异常')

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

    # try:
    #     open('aaa.txt', encoding='utf-8')
    # except FileNotFoundError:
    #     print('没有该文件，创建成功')
    #     open('aaa.txt', 'w', encoding='utf-8')
    
    # print('===语法三===')
    # try:
    #     print(int('abc'))  # ValueError
    #     print([1, 2][3])  # IndexError
    #     print({'a': 10}['b'])  # KeyError
    # except (IndexError, KeyError):
    #     print('出现异常')
    
    # print('===语法四===针对不同的异常有不同的处理')
    # try:
    #     print(int('abc'))  # ValueError
    #     print([1, 2][3])  # IndexError
    #     print({'a': 10}['b'])  # KeyError
    # except IndexError:
    #     print('下标越界')
    # except KeyError:
    #     print('键错误！')
    # except:
    #     print('其他异常')
    
    print('===finally===')
    try:
        # print(int('abc'))  # ValueError
        # print([1, 2][3])  # IndexError
        print({'a': 10}['b'])  # KeyError
    except IndexError:
        print('下标越界')
    finally:
        print('写遗书')

if __name__ == '__main__':
    main()

编程思想

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

求两个数的和

面向过程:

num1 = 1
num2 = 5
sum1 = num1 + num2
print(sum1)

函数式编程

def sum1(n1, n2):
    return n1 + n2

类和对象

1.什么是类，什么是对象

什么是类: 类就是拥有相同功能和相同属性的对象的集合(抽象的)
什么是对象: 对象就是类的示例(具体)

2.类的声明

python所有的数据类型都是类，每种类型对应的数据都是对象
int类是所有整数的集合(每个单独的整数都是int的对象)

声明类就是自定义类型

语法:

class 类名():
类体

说明

class - 声明类的关键字
类名 - 自定义，标识符不能是关键字
规范:见名知义；首字母大写，并且采用驼峰式命名(即多个单词的名字,每个单词的首字母需要大写)
: - 固定内容
类体 - 主要包含：类的说明文档、属性、方法(功能)

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

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

3.创建对象

对象是通过类来创建的

语法

类() - 创建指定类的对象

p1 = Person()
print(p1)

1.类中的方法

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

2.对象方法

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

self
对象方法中的默认参数self，在通过对象调用的时候，这个参数不用传参，系统会自动将当前对象传递给他
哪个对象调用的当前方法，self就指该对象

self本质就是当前类的对象，所以对象能做的事self都可以做

class Person:
    def __init__(self):
        self.name = ''

    def eat(self):
        print('self:', self)
        print('吃东西！')
        self.run()

    def run(self):
        print('跑步')

p1 = Person()
p1.name = '张三'
p2 = Person()
print(p1, p2)
p1.eat()

# 注意：对象方法在语法上来说可以使用'类.'的方式去使用，这样用self会失去它的意义
# Person.eat('abc')

1.init

python所有的类中都有一个特殊的对象方法：init
当通过类去创建对象的时候，系统会自动调用init方法，来对对象进行初始化操作(*)

补充：python中以''开头并且以''结尾的方法叫魔法方法所有的魔法方法都不需要程序员手动调用，系统会在需要的情况下自动调用

2.构造方法

函数名和类名一样的方法就是构造方法
python中，当我们声明类的时候，系统会自动给我们创建这个类的构造方法。
方法中会先在内存中开辟空间创建对象，然后用创建好的对象去调用init方法对对象进行初始化，
初始化完成后才将对象返回

创建对象的时候需不需要参数，需要几个参数，看init方法(*)

class Dog:
    def __init__(self, name, age):
        print('init方法', name, age)

构造方法的伪代码

def Dog(*args, **kwargs):
    对象 = 创建对象(在内存中开辟空间创建对象)
    对象.__init__(*args, **kwargs)
    return 对象

dog1 = Dog('大黄', 3)  # 位置参数
dog2 = Dog(age=2, name='财财')  # 关键字参数

模拟init方法

# def __init__():
#     print('模仿init方法')

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

# Dog1(name='coco', age=10)

类：拥有相同属性和相同功能的对象的集合

1.属性

属性分为：类的字段、对象属性

类的字段

a.声明：直接声明在类中的变量就是类的字段
b.怎么使用：通过'类.'的方式去使用
c.什么时候使用：属性的值不会因为对象不同而不同，就使用类的字段(相当于java中的类变量)

对象属性

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

class Person:
    """类的说明文档：人类"""
    # 1.属性
    num = 60  # 类的字段

    def __init__(self, name, age=0):
        # 这儿的name和age就是Person类的对象属性
        self.name = name
        self.age = age

    # 2.方法
# 使用字段
Person.num = 61
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, name, color, age=0):
        self.name = name
        self.color = color
        self.age = age
        self.type = '柴犬'

    # 方法
    def eat(self, food: str):
        print(self.name+'在吃'+food)
    # def eat(self, food: str):
    #     print('%s在吃%s' % (self.name, food))

dog1 = Dog('警长', '黄色', 3)
dog1.eat('骨头')
print(dog1.name+'是只'+dog1.type)

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

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

1.对象属性的增删改查

查 - 获取对象属性的值

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

print('===查===')
print(stu1.name)
print(getattr(stu1, 'name'))
print(getattr(stu1, 'name1', '无'))

p_name = 'name'
print(getattr(stu1, p_name))

增/改 - 添加/修改属性

a.对象.属性 = 值 - 当属性存在的时候修改属性的值，属性不存的时候添加属性
b.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)

删 - 删除对象属性

a. del 对象.属性

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

delattr(stu1, 'age')
# print(stu1.age)  # AttributeError: 'Student' object has no attribute 'age'

注意：对象属性的增删改查只针对单个对象

print(stu1.gender)
# print(stu2.gender)  # AttributeError: 'Student' object has no attribute 'gender'

2.slots魔法

class Person:
    # 在类中可以通过给__slots__赋值来约束当前类的对象有哪些对象属性
    __slots__ = ('name', 'age', 'gender', 'id')

    def __init__(self, name, age):
        self.name = name
        self.age = age
        # self.height = 180  # slots的元组里限制了类的属性

print('===slots魔法===')
p1 = Person('小敏', 10)
p1.gender = '男'

p1.id = '小明'
# p1.name1 = '花花'  # AttributeError: 'Person' object has no attribute 'name1'

class Car:
    """说明文档：车类"""
    num = 100

    def __init__(self, color='黑色', brand='丰田', price=50000):
        self.color = color
        self.brand = brand
        self.price = price
        self.speed = 100

    def stop(self):
        self.speed = 0

car1 = Car()

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

name

字段，获取类的类名

print(Car)
print(Car.__name__, type(Car.__name__))

doc

字段,获取类的说明文档

print(Car.__doc__)

class

对象属性，获取对象的类型

C1 = car1.__class__
car2 = C1

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

print([1, 2].__class__)

dict(重点)

字段，获取当前类中所有的字段和字段对应的值以字典的形式返回(了解)
对象属性，获取当前对象中所有的对象属性和对应的值

print(Car.__dict__)
print(car1.__dict__)

module

字段，获取当前类所在(声明在哪儿)的模块的名字

print(Car.__module__)

bases

字段，获取当前类的父类

print(Car.__bases__)