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))
微信关注我们
转载内容版权归作者及来源网站所有！
低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。
为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。
Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。
Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。
Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。
扫码在手机上查看文章
扫描二维码，手机阅读更方便
有任何问题或合作意向欢迎联系我们
Email: 99873273@qq.com
QQ: 99873273
开局一张图