每天坚持手写 一天一篇 决定坚持几年 为了梦想为了信仰
![]()
开局一张图
Python人工智能从入门到精通
day16补充：
异常处理 文件操作综合练习示例
src_filename = input("请输入源文件路径名: ")
dst_filename = input('请输入目标文件路径名: ')
try:
src = open(src_filename, 'rb') # 打开源文件用来读数据
try:
try:
dst = open(dst_filename, 'wb') # 打开目标文件用来写
try:
while True:
b = src.read(4096) # 4096当前Linux系统内核字节大小
if not b: # 已经再也读不到数据了
break
dst.write(b) # 写字节到文件
print("复制成功")
finally:
dst.close() # 必须关闭文件
except OSError:
print("打开写文件失败")
finally:
src.close() # 必须关闭文件
except OSError:
print("复制失败")
面向对象编程：
以函数单位
面向对象编程 Ojbect-Oriented Programing
什么是对象：
对象是指现实中的物体或实物
对象有什么属性：
对象有很多属性（名词，形容词）
姓名， 年龄， 性别
对象有很多行为（动作，动词）
吃饭，睡觉，工作
面向对象：
把一切都看作对象（实例） 用各种对象之间的关系来描述事务
什么是类：
拥有相同属性和行为的对象分为一组， 即为一个类
类是用来描述对象的工具，用类可以创建此类的对象（实例）
面向对象示意：
车（类）----> BYD E6(京A：88888)实例（对象）
\
\----> BMW X5(京A：66666)实例（对象）
狗（类）----> 小京巴(户籍号：0000001)实例（对象）
\
\----> 导盲犬(户籍号：0000002)实例（对象）
int（类）----> 100（对象）
\
\----> 500（实例、对象）
类的创建语句：
class 类名（继承列表）：
‘类的文档字符串’
实例方法的定义
类变量的定义
类方法的定义（@classmethod）
静态方法的定义（@staticmethod）
作用：
创建一个类
类用于描述对象的行为和属性
类用于创建此类的一个或多个对象
说明：
类名必须是标识符
类名实质上就是变量， 它绑定一个类
示例：
# 用class语句 创建一个类
class Dog:
''' 这是文档字符串 描述一些小动物 '''
pass
构造函数
构造函数的调用表达式
语法：
类名（[创建传参列表]）
作用：
创建这个类的实例对象，并返回此实例的引用关系
示例：
dog1 = Dog() # 调用构造函数创建一个实例对象 再用dog1绑定
print(id(dog1))
dog2 = Dog() # 创建另一个实例对象
print(id(dog2))
lst1 = list() # 调用构造函数创建一个列表对象
print(id(lst1))
lst2 = list() # 创建另一个实例对象
print(id(lst2))
实例说明：
1.实例有自己的作用域和空间名， 可以为该类添加实例变量（也叫属性）
2.实例可以调用类的方法和实例方法
3.实例可以访问类变量和实例变量
实例方法：
语法：
class 类名（继承列表）
def 实例方法名（self， 参数1， 参数2...）：
‘文档字符串’
语句
作用：
用于描述一个对象的行为， 让此类型的全部对象都拥有相同的行为
说明：
实例方法实质是函数， 是定义类的函数
实例方法至少有一个形参， 第一个形参代表调用方法的实例， 一般命名为“self”
实例方法语法：
实例.实例方法名（调用传参）
或
实例.实例方法名（实参， 调用传参）
示例：
# 实例方法的创建和调用
class Dog:
''' 这是文档字符串 描述一些小动物 '''
def eat(self, food):
'''此方法用来描述小狗吃的行为'''
print("小狗正在吃", food)
def slep(self, hour):
'''此方法用来描述小狗睡的行为'''
print("小狗睡了%d小时" % hour)
def play(self, obj):
'''此方法用来描述小狗玩的行为'''
print("小狗正在玩", obj)
dog1 = Dog() # 调用构造函数创建一个实例对象 再用dog1绑定
dog1.eat("单身狗粮")
dog1.slep(3)
dog1.play("球")
dog2 = Dog()
dog2.eat("提子") # 创建另一个实例对象
dog1.slep(5)
dog1.play("MM")
======================
>>> import day17
小狗正在吃 单身狗粮
小狗睡了3小时
小狗正在玩 球
小狗正在吃 提子
小狗睡了5小时
小狗正在玩 MM
>>> dir()
['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'day17']
>>> dir(day17)
['Dog', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'dog1', 'dog2']
>>> help(day17)
>>> help(list)
======================
实例属性 atribute（也叫实例变量）
每个实例对象可以有自己的变量， 称为实例变量（也叫属性）
语法：
实例.属性名
赋值规则：
首次为属性赋值则创建此属性
再次为属性赋值则修改属性的绑定关系
作用：
记录每个对象自身数据
示例：
# 属性的方法
class Dog:
''' 这是文档字符串 描述一些小动物 '''
def eat(self, food):
'''此方法用来描述小狗吃的行为'''
print(self.color, "的", self.kinds, "小狗正在吃", food)
# 让调用此方法的对象添加一个last_food属性用来记住吃过的信息（方法内添加属性）
self.last_food = food
# 方法外添加属性
dog1 = Dog() # 调用构造函数创建一个实例对象 再用dog1绑定
dog1.kinds = "京巴" # 为dog1对象添加kinds属性， 绑定为"京巴"
dog1.color = "白色" # 为dog1对象添加 color ＂白色＂属性
dog1.color = "原谅色" # 改变dog1对象 color属性
print(dog1.color, "的", dog1.kinds) # 原谅色 的 京巴
dog2 = Dog()
# print(dog2.color, "的", dog2.kinds) # 出错
dog2.kinds = "二哈" # 为dog2对象添加kinds属性， 绑定为"二哈"
dog2.color = "白色" # 为dog2对象添加 color ＂白色＂属性
dog2.color = "黄色" # 改变dog2对象 color属性
print(dog2.color, "的", dog2.kinds) # 黄色 的 二哈
dog1.eat("单身狗粮") # 原谅色 的 京巴 小狗正在吃 单身狗粮
dog2.eat("爱心蛋糕") # 黄色 的 二哈 小狗正在吃 爱心蛋糕
# 可以在方法（函数）外添加对象属性也可以在方法内添加 通常在方法内（函数）
删除属性：
del
例如：
class Dog:
pass
dog1 = Dog()
dog1.color = "白色"
del dog1.color
del 变量名 删除变量
del 列表[整数表达式] 删除列表元素
del 字典[键] 删除字典中的键
del 对象.属性 删除对象的属性
初始化方法：
作用：
对新创建的对象添加属性
语法：
def __init__（self[, 形参列表]）：
语句块
[ ] 代表可省略
说明：
1.初始化方法名必须为‘__init__’不可改变
2.初始化方法在构造函数创建实例后自动调用，且将实例自身
通过第一个参数 self 传入__init__方法
3.构造函数的实参将通过__init__方法的参数列表传入到‘__init__’方法中
4.初始化方法内如果需要return语句返回 则返回None
示例：
# 初始化方法 __init__
class Car:
'''定义汽车类'''
def __init__(self, c, b, m):
self.color = c # 颜色
self.brand = b # 品牌
self.model = m # 型号
print('__init__方法被调用')
def run(self, speed):
print(self.color, "的", self.brand, self.model,
"正才以", speed, "公里没小时行驶")
a4 = Car("红色", "奥迪", "A4") # 调用构造函数
a4.run(1000) # 红色 的 奥迪 A4 正才以 1000 公里没小时行驶
s3 = Car("蓝色", "TESLA", "Model S") # 调用构造函数
s3.run(6000) # 蓝色 的 TESLA Model S 正才以 6000 公里没小时行驶
析构方法：
语法：
class 类名：
def __del__(self):
...
说明：
析构方法在对象被销毁时会自动调用
Python建议不要在对象销毁时做任何事情， 因为销毁时间难以确定
示例：
# 析构方法
class Car:
def __init__(self, name):
self.name = name
print("汽车", name, "被创建")
def __del__(self):
'''析构方法，对象被销毁时 次方法调用'''
print("汽车", self.name, "被销毁")
c1 = Car("BYD E6")
input("此汽车是伪造！ 按回车继续程序...")
# 汽车 BYD E6 被创建
# 此汽车是伪造！ 按回车继续程序...
# 汽车 BYD E6 被销毁
c2 = c1
del c2
input() # 汽车 BYD E6 被创建
预置实例属性：
__dict__属性
__dict__属性绑定一个储存此实例自身变量的字典
示例：
>>> class Dog:
... pass
>>> dog1 = Dog()
>>> dog1.name = "哈哈"
>>> dog1.__dict__
{'name': '哈哈'}
>>> dog1.age = 3
>>> dog1.__dict__
{'age': 3, 'name': '哈哈'}
>>> del dog1.age
>>> dog1.__dict__
{'name': '哈哈'}
>>>
__class__属性
此属性用于绑定创建一些实例的类
作用：
可以借助于此属性来访问创建此实例的类
示例：
>>> class Dog:
... pass
...
>>> dog1 = Dog()
>>> Dog
<class '__main__.Dog'>
>>> dog1.__class__
<class '__main__.Dog'>
>>> type(dog1)
<class '__main__.Dog'>
>>> type(dog1) is Dog
True
>>> dog2 = dog1.__class__() # 等同于 dog2 = Dog()
>>> dog2.__class__
<class '__main__.Dog'>
![]()
面向对象的综合示例：
有两个人：
1.
姓名：张三
年龄：25
2.
姓名：李四
年龄：5
行为：
1.教别人学学东西 teach
2.赚钱 works
3.借钱 borrow
事情：
张三 教 李四 学 Python
李四 教 张三 学 跳皮筋
张三 上班赚了 1000 元钱
李四 向 张三 借了 200 元钱
打印张三的信息：25岁 的 张三 有钱 800元 他学会了跳皮筋
打印李四的信息：5岁 的 李四 有钱 200元 他学会了python
class Human:
'''描述人的行为和属性
teach(self, other, subject)
学习技能
works(self, money)
赚钱
borrow(self, other, money)
借钱
def print_info(self)
输出信息
'''
def __init__(self, name, age):
'''初始化基本信息和属性'''
self. name, self.age = name, age # 名字， 年龄
self.money = 0 # 钱数
self.skill = [] # 技能列表
def teach(self, other, subject):
'''实例行参对象1 教 实例行参对象2 学 技能的实例方法
self:实例形参1（调用对象自己）
other: 实例形参2 （调用目标对象）
subject: 技能
'''
other.skill.append(subject) # 行参对象2 追加新技能
print(self.name, "教", other.name, "学", subject)
def works(self, money):
'''实例行参对象的 赚钱 实例方法
self:实例行参（调用对象自己）
money:赚的钱数
'''
self.money = money # 实例形的钱数
print(self.name, "上班赚了", money, "元钱")
def borrow(self, other, money):
'''实例行参对象1 向 实例行参对象2 借钱 的实例方法
self:实例形参1（调用对象自己）
other: 实例行参2 （调用目标对象）
monay: 接的钱数
'''
if other.money > money: # 目标对象的钱小于借钱数额 借钱失败
self.money += money # 自己的钱
other.money -= money # 目标对象剩余的钱
print(self.name, "向", other.name, "借了", self.money, "元钱")
else:
print(self.name, "向", other.name, "借钱失败！")
def print_info(self):
'''打印输出self的信息实例方法
self:实例行参（调用对象自己）
'''
print(self.age, "岁的", self.name,
"有钱", self.money, "元 他学会了：", self.skill)
zhang3 = Human("张三", 25)
li4 = Human("李四", 5)
# 张三教李四Python
zhang3.teach(li4, "Python")
# 李四教张三玩游戏
li4.teach(zhang3, "玩游戏")
# 张三上班赚了 1000 元钱
zhang3.works(1000)
# 李四向张三借 200 元钱
li4.borrow(zhang3, 200)
# 打印李四信息
li4.print_info()
# 打印张三信息
zhang3.print_info()
# 第一个实例形参一般为调用者自己
# （自动传参自己 不需要填写 直接从第二个形参开始）
# __init__()初始化信息函数内的属性为公用属性
# 初始化对象后每个对象都会调用__init__内的属性
# 其他方法（单独属性）另需调用
用于类的函数：
isinstance（obj, class_or_tuple）
返回这个对象obj是否是某个类的对象或某些类中的一个类的对象,
如果是则返回True,否则返回False
type(obj) 返回对象的类型
>>> a = 100
>>> isinstance(a, int)
True
>>> isinstance(a, bool)
False
>>> a = 100.0
>>> isinstance(a, int)
False
>>> isinstance(a, float)
True
>>> type(a)
<class 'float'>
>>> a = 100
>>> type(a)
<class 'int'>
>>>
练习:
自己写一个'人'类: Human
class Human:
def set_info(self, name, age, address='未知'):
'''此方法用来给人对象添加'姓名', '年龄', '家庭住址'三个属性'''
... # << 此处自己实现
def show_info(self):
'''显示此人的全部信息'''
... # 此处自己实现
如:
h1 = Human()
h1.set_info('小张', 20, '北京市朝阳区')
h2 = Human()
h2.set_info('小李', 18)
h1.show_info() # 小张今年 20 岁,家庭住址:北京市朝阳区
h2.show_info() # 小李今年 18 岁,家庭住址:末知
答案：
class Human:
def set_info(self, name, age, address='未知'):
'''此方法用来给人对象添加'姓名', '年龄', '家庭住址'三个属性'''
self.name = name
self.age = age
self.address = address
def show_info(self):
'''显示此人的全部信息'''
print(self.name, '今年',
self.age, '岁,家庭住址:',
self.address)
h1 = Human()
h1.set_info('小张', 20, '北京市朝阳区')
h2 = Human()
h2.set_info('小李', 18)
h1.show_info() # 小张今年 20 岁,家庭住址:北京市朝阳区
h2.show_info() # 小李今年 18 岁,家庭住址:末知
class Human:
def set_info(self, name, age, address='未知'):
'''此方法用来给人对象添加'姓名', '年龄', '家庭住址'三个属性'''
self.name = name
self.age = age
self.address = address
def show_info(self):
'''显示此人的全部信息'''
print(self.name, '今年',
self.age, '岁,家庭住址:',
self.address)
h1 = Human()
# h1.set_info('小张', 20, '北京市朝阳区')
Human.set_info(h1, '小张', 20, '北京市朝阳区')
h1.show_info() # 小张今年 20 岁,家庭住址:北京市朝阳区
练习:
写一个Student类
1) 为该类添加初始化方法, 实现在创建对象时自动设置
'姓名','年龄', '成绩' 属性
2) 添加set_score方法能修改成绩信息
3) 添加show_info方法打印学生对象的信息
如:
class Student:
def __init__(...):
...
...
s1 = Student('小王', 15, 59)
s1.show_info() # 小王 今年 17 岁, 成绩是: 59
s1.set_score(80)
s1.show_info() # 小王 今年 17 岁, 成绩是: 80
答案：
class Student:
def __init__(self, n, a, s):
self.name, self.age, self.score = n, a, s
def show_info(self):
print(self.name, '今年',
self.age, '岁, 成绩是:',
self.score)
def set_score(self, s):
assert 0 <= s <= 100, '参数错误'
self.score = s
s1 = Student('小王', 15, 59)
s1.show_info() # 小王 今年 17 岁, 成绩是: 59
s1.set_score(80) # s1.score = 80
s1.show_info() # 小王 今年 17 岁, 成绩是: 80
上面两个练习我写了一份很详细的 明天改 这个先凑合着...
练习:
修改原来的学生信息管理程序,将原来字典来存储学生信息,
现改为用对象来存储学生信息
# file : student.py
class Student:
def __init__(self, n, a, s):
....
L = []
# L.append({...}) 改为对象
L.append(Student('xiaozhang', 20, 100))
(要求类Student 要写在模块 student.py中)
示例：
# 假如文件中有这么多学生信息
L = [{"name": "Tom", "age": 15, "score": 98},
{"name": "AL", "age": 16, "score": 95},
{"name": "Lix", "age": 16, "score": 95},
{"name": "Li", "age": 16, "score": 95},
{"name": "ix", "age": 16, "score": 95},
{"name": "ix", "age": 16, "score": 95},
{"name": "Ax", "age": 16, "score": 95},
{"name": "i", "age": 16, "score": 95},
{"name": "x", "age": 16, "score": 95},
{"name": "Lx", "age": 16, "score": 95},
{"name": "ALi", "age": 16, "score": 95},
{"name": "Ka", "age": 16, "score": 95},
{"name": "Kla", "age": 16, "score": 95},
{"name": "KAl", "age": 16, "score": 95},
{"name": "Ala", "age": 16, "score": 95},
{"name": "Al", "age": 16, "score": 95},
{"name": "KAla", "age": 17, "score": 100}]
class Student:
'''创建学生类用来描述学生基本信息'''
def __init__(self, n, a, s):
'''初始化学生信息'''
self.name, self.age, self.score = n, a, s
def student_info(self):
'''输出此学生信息'''
print("Name:", self.name,
"Age:", self.age,
"score:", self.score)
def student_list(L):
'''将文件内学生信息编号存入列表'''
L1 = []
for x, y in zip(L, range(1, len(L) + 1)):
y = Student(x["name"], x["age"], x["score"])
L1.append(y)
return L1
# 也可以用迭代器函数
# def student_list():
# for x in L:
# y = Student(x["name"], x["age"], x["score"])
# yield y
# 输出所有学生信息
def print_student(L):
'''输出有所有学生信息'''
for stud in L:
stud.student_info()
print_student(student_list(L))
开局一张图
