day 14 异常捕获和面向对象基础
Date: 2019.5.5
内容纲要:
一、异常捕获
1.异常捕获
正常情况下程序出现异常,程序会直接崩溃,不能接着往后执行。异常捕获就是为了让程序出现异常的时候不崩溃,自己处理异常
2.异常捕获异常
1)语法一:try - except(可以捕获任何异常)
try:
代码块1
except:
代码块2
执行过程:先执行代码块1,在执行代码块1的过程中,如果出现异常,程序不崩溃直接执行代码块2,如果没有出现异常,不会执行代码块2,直接执行其他语句
try:
print('==============语法1==============')
list1 = [1, 2]
print(list1[3])
print('============================')
except:
print('出现异常')
print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
2)语法二:
try:
代码块1
except 错误类型:
代码块2
执行过程:先执行代码块1,如果在执行代码块1的过程中出现异常,检查出现的异常类型是否和except后面的异常类型是否一致,如果一致程序不崩溃,直接执行代码块2;如果不一致,程序直接崩溃,如果没有异常,直接执行后面其他语句
print('==============语法2==============')
try:
print(int('abc'))
except ValueError:
print('出现值错误异常')
练习:检查当前目录下是否有aaa.txt文件,如果没有就提示没有该文件,并且创建这个文件
try:
f1 = open('aaa.txt', 'r', encoding='utf-8')
except FileNotFoundError:
print('没有aaa.txt文件不存在!')
f1 = open('aaa.txt', 'w', encoding='utf-8')
3)语法三:
try:
代码块1
except (异常类型1,异常类型2,.....)
代码块2
print('==============语法3==============')
try:
print(int('abc'))
print([1, 2][10])
print({'a': 10}['b'])
except (IndexError, KeyError, ValueError):
print('出现异常!!')
4)语法四:
try:
代码块1
except 异常类型1
代码块2
except 异常类型2
代码块3
print('==============语法4==============')
try:
print(int('abc'))
print([1, 2][10])
print({'a': 10}['b'])
except IndexError:
print('下标越界异常!!')
except KeyError:
print('键异常!!')
except ValueError:
print('值异常!!')
5)上面的四种结构的最后都可以加上一个finally;不管try里面的代码有没有异常,异常有没有被捕获,finally后面的代码都会执行。一般可以在这个地方做一些数据的保存和备份操作!
try:
代码块1
except:
代码块2
finally:
代码块3
print('============5)finally============')
try:
print(int('abc'))
print([1, 2][10])
print({'a': 10}['b'])
except:
print('出现下标越界')
finally:
print('写遗书')
3.抛出异常:主动让程序崩溃
1)语法:
raise 异常类型
注意:异常类型可以是系统自带的,也可以是程序员自定义(要求异常类型必须是Exception的子类)
让程序主动崩溃:
raise IndexError
print(int('abc'))
二、面向对象基础
1.编程思想
1)面向过程编程:一遇到问题就考虑通过代码一步一步的取解决问题
num1 = 1
num2 = 23
sum1 = num1 +num2
print(sum1)
2)函数式编程: 一遇到问题就考虑是否能够有这样功能的一个函数
def sum1(n1, n2)
return n1 + n2
3)面向对象编程:一遇到问题就考虑是否有这样一个类,拥有相应的功能和属性
class Math:
@statemethod
def sum1:
2.什么是类,什么是对象
1)什么是类:类是拥有相同功能和相同属性对象的集合(抽象的)
2)什么是对象:对象就是类的实例(具体)
3.类的声明
python所有的数据类型都是泪,每种类型对应的数据都是对象,int类是所有整数的集合(每个单独的整数都是int的对象)
声明类就是自定义类型。
1)语法:
class 类名:
类的内容
2)说明
class - 声明类的关键字
类名 - 自己命名,标识符不能是关键字
见名知义,首字母大写,并且采用驼峰式命名(如果名字由多个单词组成,单词之间采用单词首字母大写的方式进行区分)
: - 固定写法
类的内容 - 主要包含:类的说明文档、属性、方法
补充:什么是方法 - 声明在类中的函数(方法就是函数)
class Person:
"""
类的说明文档:人类
"""
def eat(self):
print('吃东西!')
3.创建对象
对象是通过类来创建的
1)语法
类() - 创建指定类对应的对象
p1 = Person()
print(p1)
p2 = Person()
print(p2)
三、类的方法
1.类中的方法
类中的方法其实就是声明在类中的函数;勒种的方法分为三种:对象方法、类方法、静态方法
2.对象方法
直接声明在类中的函数就是对象方法,有个默认参数self,需要使用'对象.'的方式调用
1)self
对象方法中的默认参数self,在通过对象调用的时候,这个参数不用传参,系统会自动将当前对象传递给它。哪个对象调用的当前方法,self就是谁!self本质就是当前类的对象,所以对象能做的事情self都可以做
class Person:
def eat(self):
print('吃东西!')
def run(self):
print('跑步')
p1 = Person()
p1.eat()
p1.run()
注意:对象方法从语法上来说可以使用‘类.’的方式去使用,这样用self会失去它存在的意义,所以不能这样用:Person.eat(self)
list1 = [1, 2, 3] # 是list类的对象
list1.append(10)
3.init方法
1)init方法
python所有的类中都有一个特殊的对象方法: __ init__当通过类去创建对象的时候,系统会自动调用__ init__方法,用来对对象进行初始化操作
补充:python中以 '__'开头并且以' __'结尾的方法叫魔法方法。所有的魔法方法不需要程序员手动调用,系统会在需要的情况下自动调用
2).构造方法
函数名和类名一样的方法就是构造方法
python中,当我们声明类的时候,系统会自动给我们创建这个类的构造方法。方法中会先在内存中开辟空间,创建对象,然后用创建好的对象去调用init方法对对象进行初始化,初始化完成后才将对象返回。
创建对象的时候需不需要参数,需要几个参数,看init方法(*)
class Dog:
def __init__(self, name, age):
print('init方法', name)
#构造方法的伪代码:
def Dog():
对象 = 创建对象(在内存中开辟空间创建对象)
对象.__init__()
return 对象
"""
dog1 = Dog('大黄', 18)
dog2 = Dog(age = 18, name = '财财')
print('====================模拟init和构造方法==========')
def __init__(name, age):
print('模拟init方法', name, age)
四、Property
类:拥有相同属性和相同功能的对象的集合
1.属性
属性分为:类的字段、对象属性
1)类的字段
a. 声明:直接声明在类中的变量就是类的字段
b. 怎么使用:通过'类.'的方式去使用
c. 什么时候用:属性的值不会因为对象不同而不同,就是用类的字段
2)对象属性
a. 声明:对象属性需要声明在init方法中,以'self.属性 = 值'的方式来声明
b. 怎么使用:通过'对象'去使用
c. 什么时候用:属性的值会因为对象不同而不同,就是用对象属性
class Person:
"""类的说明文档:人类"""
# 1.属性
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.color = color1
self.age = age1
self.variety = '无'
# 方法
def eat(self, food):
print('%s在吃%s'%(self.name, food) )
d1 = Dog('旺财', '黄色', 4)
d1.variety = '柯基'
d1.eat('骨头')
print(d1.name, d1.color, d1.age, d1.variety)
2.对象属性的增删改查
1)查 - 获取对象属性的值
a. 点语法:对象、属性 - 属性不存在会报错
b. getattr(对象,属性名) - 获取对象属性的值,属性不存在会报错
getattr(对象,属性名,默认值) - 获取对象属性的值,属性不存在不会报错,并且返回默认值
class Student:
"""学生"""
def __init__(self, name1, age1 = 18):
self.name = name1
self.age = age1
self.stu_id = '001'
stu1 = Student('小明', 20)
stu2 = Student('小红', )
print('===========查============')
print(stu1.name)
print(getattr(stu2, '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','None'))
2)增/改 - 添加/修改属性
a.对象.属性 = 值 - 当属性存在的时候修改属性的值,当属性不存在的时候添加属性
b.setattr(对象,属性名,值) - 当属性存在的时候修改属性值,当属性不存在的时候添加属性
print('==========增/改===========')
stu1.name = '张三'
setattr(stu2, 'name', '菜菜')
print(stu1.name)
print(stu2.name)
stu1.gender = '男'
print(stu1.gender)
setattr(stu1, 'score', 100)
print(stu1.score)
3)删 - 删除对象属性
a.del 对象.属性
b.delattr(对象,属性名)
del stu1.stu_id
# print(stu1.stu_id) AttributeError: 'Student' object has no attribute 'stu_id'
注意:对象属性的增删改查只针对单个对象
3.slots魔法
class Person:
# 类可以通过给__slots__赋值来约束当前类的对象有哪些对象属性
__slots__ = ('name', 'age', 'gender', 'id')
def __init__(self, name1,age1):
self.name = name1
self.age = age1
print('============slots魔法============')
p1 = Person('小敏',10)
p1.gender = '男'
# p1.namea = '小明' AttributeError: 'Person' object has no attribute 'namea
4.内置类属性:声明类的时候系统自动给类添加的属性
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)name
字段,获取类的类名
print(Car)
print(Car.__name__, type(Car.__name__))
2)doc
字段:获取类的说明文档
print(Car.__doc__)
3)class
对象属性:获取对象的类
print(car1.__class__)
print([1, 2].__class__)
4)dict(重点)
字段,
print(Car.__dict__)
print(car1.__dict__)
5)module
字段,获取当前类所在的(声明在哪儿)的模块的名字
print(Car.__module__)
6)bases
字段,获取当前类所有的父类
print(Car.__bases__)