异常
在Python中，程序在执行的过程中产生的错误称为异常。 如列表所以越界、打开不存在的文件等。
异常类
NameError | 尝试访问一个未声明的变量，会引发NameError。 |
ZeroDivisionError | 当除数为零的时候，会引发ZeroDividionError异常。 |
SyntaxError | 当解释器发现语法错误时，会引发SyntaxError异常。 |
IndexError | 当使用序列中不存在的索引时，会引发IndexError异常 |
KeyError | 当使用字典中不存在的键访问值时，会引发KeyError异常。 |
异常处理
Python处理异常的能力非常强大，它可以准确地反馈错误信息，帮助开发人员准确定位到问题发生的位置和原因。Python中使用try-except语句处理异常。其中，try语句用于检测异常，except语句用于捕获异常。
体验异常
'''
try:
可能发生错误的代码
except：
发生错误的时候执行的代码
'''
try:
f = open('1.txt','r')
except:
f = open('test.txt','w')捕获指定异常
# 需求：尝试执行打印num，捕获异常类型NameError. 如果捕获到这个异常类型，执行打印，'有错误'
try:
print(num) # 可能发生的错误
except NameError : # 异常类型
print('有错误') # 如果捕获到该异常类型执行的代码
'''
注意：
1. 如果尝试执行的代码的异常类型和要捕获的异常类型不一致，则无法捕获异常。
2. 一般try下方只放一行尝试执行的代码
'''捕获异常描述信息
try:
print(1/0)
except(NameError,ZeroDivisionError) as result:
print(result) # division by zero捕获所有异常
try:
print(num)
except Exception as result:
print(result)
# Exception是所有程序异常类的父类
# 不需要程序员指定具体的异常类型
# 捕获所有异常就是去except捕获这个Exception，从而做到捕获了父类，即捕获到了具体的某个异常类else和finally
- else
'''
else表示的是如果没有异常要执行的代码
'''
try:
print(1)
except Exception as result:
print(result)
else:
print('我是else，当没有异常的时候执行的代码')- finally
'''
finally表示的是无论是否异常都要执行的代码，例如关闭文件
'''
try:
f = open('test300.txt','r')
except Exception as e:
print(e)
f = open('test300.txt','w')
finally:
f.close()异常的传递
'''
# 异常的传递指代的就是我们的异常是可以嵌套书写的，要去了解嵌套书写异常语句的时候，
我们的程序执行流程是什么.
# 这些要学习的知识点简称为异常的传递
# 如果书写打开访问模式，不写访问模式，那么默认即为只读r模式
# 先执行外层的try、except，然后在执行内层的try、except
'''
'''
需求1：尝试只读打开test.txt 文件存在读取内容，不存在提示用户
需求2：读取内容：循环读取，当无内容的时候退出循环，如果用户意外终止，提示用户已经意外终止
'''
import time
try:
f = open('test.txt')
try:
while True:
con = f.readline()
# 如果读取完成退出循环
if len(con) == 0:
break
time.sleep(3)
print(con)
except:
# 在命令提示符中如果按下ctrl+c结束符终止的键
print('程序被意外终止')
except:
print('该文件不存在')自定义异常
'''
自定义异常的作用：用来我们将不满足程序逻辑的情况，进行一个反馈，报错给用户。
用来报错，报的错误不是语法错误，而是不符合我们程序逻辑要求的错误。
'''
class ShortInputError(Exception):
def __init__(self,length,min_len):
# 用户输入的密码长度
self.length = length
# 系统要求的最少长度
self.min_len = min_len
# 设置异常描述信息
def __str__(self):
return f'您输入的密码长度是{self.length},密码不能少于{self.min_len}'
def main():
try:
password = input('输入密码')
# 抛出异常类创建的对象
# ShortInputError(len(password),3)抛出了一个对象而已。可以理解raise相当于原来的打印。打印对象的时候，打印到的就是str魔法对象的返回值。
# raise抛出这个对象的时候，我们捕获的时候，捕获到的也是str魔法方法的返回值
if len(password) < 3:
raise ShortInputError(len(password),3)
except Exception as result:
print(result)
else:
print('没有异常，密码输入完成')
main()小总结
'''
1. 异常语法
try：
可能发生的异常
except:
如果出现异常执行的代码
else：
没有异常执行的代码
finally：
无论是否异常都要执行的代码
2. 捕获异常
except 异常类型：
代码
except 异常类型 as xx：
代码
3. 自定义异常
# 1.自定义异常类
class 异常类类名(Except):
代码
# 设置抛出异常的描述信息
def __str__(str):
return ...
# 2. 抛出异常
raise 异常类名()
# 捕获异常
except Exception...
'''Python模块
模块的基本使用
# 模块就是一个python文件，直接调用这个模块里的功能，省去了自己定义功能再使用的步骤。
# 不推荐一次性导入多个模块，推荐的是跟一个模块名
# 需求：math模块下sqrt（）开平方计算
# 方法一：import 模块名 模块名.功能
import math
print(math.sqrt(9)) # 3.0
# 再python当中，涉及到类似于除法计算不管参与计算的数字是否有浮点数，将来反馈回来的结果一定是浮点数。
# 方法二：from 模块名 import 功能1，功能2... 直接功能调用
from math import sqrt
print(sqrt(9))
# 方法三：from math import * 直接功能调用
from math import *
print(sqrt(9))- 定义别名
# 需求：运行后暂停2秒打印hello
'''
1. 导入time模块或导入time模块的sleep功能
2. 调用功能
3. 打印hello
'''
# 模块别名
import time as tt
tt.sleep(2)
print('hello')
# 定义别名
from time import sleep as sl
sl(2)
print('hello')模块的制作
在当前文件夹中创建my_module1.py，然后在调用自己制作的模块。
my_module1.py
# 需求：一个函数，完成任意两个数字加法运算
def testA(a,b):
print(a+b)
# 测试信息
# testA(1, 1)
# print(__name__)
# 为了不频繁的删除测试信息或添加测试信息，这时可以加一个判断
# __name__是系统变量，是模块的标识符，值是：如果是自身模块值是__main__,否则是当前的模块的名字
if __name__ == '__main__':
testA(1,1)在下面的程序里调用my_module1.py模块
'''
再python程序当中，每个模块就是一个python文件，这个python文件都有自己的名字。
name是一个系统变量，是模块的标识符，是每个python文件的标识符，如果name的使用位置再在自身模块里
那么它的值就是__main__,否则不在自身模块里面，那么这个name的值就是我们模块的名字，即是我们的python文件名。
'''
# 导入模块
import my_module1
# 调用功能
my_module1.testA(2,2)模块的定位顺序
'''
当导入一个模块，Python解析器对模块的搜索顺序是：
1. 当前目录
2. 如果不在当前目录，Python则搜索shell变量PYTHONPATH下的每个目录（安装解释器目录下的）
3. 如果都找不到，Python会查看默认路径。UNIX下，默认路径一般为/usr/local/lib/python（一般不涉及到默认路径）
模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录
注意：
自己的文件名不要和已有的模块名重复，否则导致模块功能无法使用
使用from 模块名 import 功能的时候，如果功能名字重复，调用到的是最后定义或导入的功能
'''
# 自己的模块名不能和已有的模块名重复
import random
num = random.randint(1,5) # 因为在当前目录中有一个random模块，则报错
print(num)all列表
下面就是my_module2.py中的代码
'''
如果一个模块文件中有__all__变量，当使用from xxx import * 导入时，只能导入这个列表中的元素
'''
# 定义多个功能，把某个功能添加到__all__
__all__=['testA']
def testA():
print('testA')
def testB():
print('testB')导入包
创建了一个名为mypackage的包，里面有三个文件
init.py
__all__ = ['my_module1']mymodule1.py
print(1)
def info_print():
print('my_module1')mymodule2.py
print(2)
def info_print():
print('my_module2')这个就是导入包.py（尽量不要起中文名称），开始导包
'''
# 包将有联系的模块组织在一起，即放到同一个文件夹下，并且在这个文件夹创建一个名字为__init__.py文件，那么这个文件就称为包
# 当右键去创建包的时候，这个文件夹里面会自动创建一个名字为__init__.py的文件，这个文件可以控制包的导入行为
'''
# 方法一
'''
1. 导入
import 包名.模块名
2. 调用功能
包名.模块名.功能（）
'''
# 导入mypackage包下的模块1，使用这个模块内的info_print1函数
import mypackage.my_module1
mypackage.my_module1.info_print()
# 方法二：注意 设置__init__.py文件里面的all列表( __all__ = [] )，添加的是允许导入的模块
'''
from 包名 import *
模块名.目标
'''
from mypackage import *
my_module1.info_print()拓展小知识
# 在工作岗位下，避免功能名字重复这个事情发生
# 1. 当使用from xx import 功能
# 导入模块功能的时候，如果功能名字重复，导入的时候后定义或后导入的这个同名功能
def sleep():
print('我是自定义的sleep')
from time import sleep
# 后导入的同名功能（这时就会报错）
# def sleep():
# print('我是自定义的sleep')
sleep(2)
# 2. 拓展：名字重复
# 问题：import 模块名 时候担心名字重复的问题-不需要（因为功能名一样但是模块名不一样）
import time
print(time)
time = 1 # 这个变量会覆盖模块的功能
print(time)
# 问题：为什么变量也能覆盖模块？-- 在Python语言中，数据是通过 引用 传递的小总结
'''
什么是模块？ 模块就是一个python文件，这个文件里面有大量的变量，或者是函数、类，这是一个普通的python文件
可以书写大量的python程序，这个python程序书写完成之后，可以用以下的三种方法进行导入。其他文件能灵活的调用
这个模块当中的功能。
导入模块方法
import 模块名
from 模块名 import 目标
from 模块名 import *
导入包
import 包名.模块名
from 包名 import * ( __all__ = [] : 允许导入的模块或功能列表)
'''学生管理系统
思路：
1.首先先创建一个项目目录StudentManagerSystem。这个是面向对象的学生管理系统，一共有两个角色（两个类），一个是学生，一个是管理系统。为了方便维护代码，一般一个角色一个程序文件。项目由主程序入口，习惯为main.py。
2. 学生类里面有学生的基本信息，当创建一个学生对象的时候，会显示学生的信息（str）
3. 管理系统类里面有程序入口，提供功能界面，每个功能由每个函数实现，然后再去调用。功能主要增、删、改、查学生，显示所有学员信息，保存学员信息，加载学员信息。
main.py
# 程序入口文件功能的学习，程序入口文件:运行这个文件就可以启动这个管理系统。
# 1. 导入关系系统模块
from managerSystem import *
# 2. 启动管理系统
# 保证是当前文件运行才启动管理系统：if -- 创建对象并调用run方法
if __name__ == '__main__': # 这个__name__意思：在本程序中执行就等于__main__,其他文件调用就不等于__main__.
student_manager = StudentManager()
student_manager.run()managerSystem.py
from student import *
class StudentManager(object):
def __init__(self):
# 储存学员数据 -- 列表
self.student_list = []
# 程序的入口一般定义为run函数名，这是程序员的习惯。从键盘输入的内容都是字符串，需要用int进行转换
# 一、程序入口函数
def run(self):
# 1. 加载文件里面的学员数据
self.load_student()
while True:
# 2. 显示功能菜单
self.show_menu()
# 3. 用户输入目标功能序号
menu_num = int(input('请输入您需要的功能序号：'))
# 4. 根据用户输入的序号执行不同的功能 -- 如果用户输入1，执行添加
if menu_num == 1:
# 添加学员
self.add_student()
elif menu_num == 2:
# 删除学员
self.del_student()
elif menu_num == 3:
# 修改学员信息
self.modify_student()
elif menu_num == 4:
# 查询学员信息
self.search_student()
elif menu_num == 5:
# 显示所有学员信息
self.show_student()
elif menu_num == 6:
# 保存学员信息
self.save_student()
elif menu_num == 7:
# 退出系统 -- 退出循环
break
# 这里面不涉及对象或对象数据的使用，在面向对象编程的时候，这样的函数需要定义成静态方法。
# 在类里面书写代码，在类里面调用实例方法的写法是self.函数名
# 二、系统功能函数
# 2.1 显示功能函数 -- 打印序号的功能对应关系 -- 静态
@staticmethod
def show_menu():
print('请选择如下功能：')
print('1:添加学员')
print('2:删除学员')
print('3:修改学员信息')
print('4:查询学员信息')
print('5:显示所有学员信息')
print('6:保存学员信息')
print('7:退出系统')
# 2.2 添加学员
def add_student(self):
pass
# 1. 用户输入姓名、性别、手机号
name = input('请输入您的姓名：')
gender = input('请输入您的性别: ')
tel = input('请输入您的手机号：')
# 2. 创建学员列表 -- 类？类在student文件里面 先导入student模块，在创建对象
student = Student(name, gender, tel)
# 3. 将该对象添加到学员列表
self.student_list.append(student)
print(self.student_list)
print(student)
# 2.3 删除学员
def del_student(self):
# 1. 用户输入目标学员姓名
del_name = input('请输入要删除的学员姓名：')
# 2. 遍历学员列表，如果用户输入的学员存在则删除学员对象，否则提示学员不存在
for i in self.student_list:
if del_name == i.name:
# 删除学员对象
self.student_list.remove(i)
break
else:
# 循环正常结束执行的代码：循环结束都没有删除一个对象，所以说明用户输入的目标学员不存在
print('查无此人')
print(self.student_list)
# 2.4 修改学员信息
def modify_student(self):
# 1. 用户输入目标学员姓名
modify_name = input('请输入要修改的学员姓名')
# 2. 遍历列表数据，如果学员存在修改姓名性别手机号，否则提示学员不存在
for i in self.student_list:
if modify_name == i.name:
i.name = input('姓名：')
i.gender = input('性别：')
i.tel = input('手机号：')
print(f'修改学员信息成功，姓名{i.name}, 性别{i.gender}, 手机号{i.tel}')
break
else:
print('查无此人')
# 2.5 查询学员信息
def search_student(self):
# 1. 用户输入目标学员姓名
search_name = input('请输入您要搜索的学员姓名：')
# 2. 遍历列表。如果学员存在打印学员信息，否则提示学员不存在
for i in self.student_list:
if search_name == i.name:
print(f'姓名是{i.name},性别是{i.gender}, 手机号是{i.tel}')
break
else:
print('查无此人！')
# 2.6 显示所有学员信息
def show_student(self):
# 1. 打印表头
print('姓名\t性别\t手机号')
# 2. 打印学员数据
for i in self.student_list:
print(f'{i.name}\t\t{i.gender}\t\t{i.tel}')
# 2.7 保存学员信息
def save_student(self):
# 1. 打开文件
f = open('student.data', 'w')
# 2. 文件写入数据
# 2.1 [学员对象] 转换成 [字典]
new_list = [i.__dict__ for i in self.student_list]
# 2.2 文件写入 字符串数据 (转化成字符串才能写入文件)
f.write(str(new_list))
# 3. 关闭文件
f.close()
# 2.8 加载学员信息
def load_student(self):
# 1. 打开文件：尝试r打开，如果有异常w
try:
f = open('student.data', 'r')
except:
f = open('student.data', 'w')
else:
# 2. 读取数据：文件读取出的数据是字符串 还原列表类型：[{}] 转换 [学员对象]
data = f.read() # 字符串
new_list = eval（data) # 还原列表类型，eval把字符串里面的列表这样的数据类型转换成列表原本类型
self.student_list = [Student(i['name'], i['gender'], i['tel']) for i in new_list] # 获取到每个key的值
finally:
# 3. 关闭文件
f.close()student.py
'''
需求：
学员信息包含：姓名、性别、手机号
添加__str__魔法方法，方便查看学员对象信息
'''
class Student(object):
def __init__(self, name, gender, tel):
# 姓名、性别、手机号
self.name = name
self.gender = gender
self.tel = tel
def __str__(self):
return f'{self.name}, {self.gender}, {self.tel}'
# aa = Student('aa', 'nv' , 111)
# print(aa)小拓展__dict__
这个知识点在managerSystem.py文件中用到了，所以学习一下。
'''
拓展:
__dict__是面向对象编程当中类对象或者是实例都拥有的属性，这个属性的作用是收集类对象或者实例对象的属性和方法
以及对应的值，从而返回一个字典。
'''
# 1. 定义类
class A(object):
a = 0
def __init__(self):
self.b = 1
# 2. 创建对象
aa = A()
# 3. 调用__dict__
# 返回类内部所有属性和方法对应的字典
print(A.__dict__)
# 返回实例属性和值组成的字典
print(aa.__dict__) # {'b': 1}小总结
这是学生管理系统所用的知识点，基本上覆盖了所学的基础知识。查漏补缺，复习巩固。
'''
函数：
定义和调用
参数的使用
面向对象：
定义类
创建对象
定义和调用实例属性
定义和调用实例方法
数据类型:
列表
增加删除数据
列表推导式
字典
字符串
文件操作：
打开文件
读取或写入（读取出来的数据和写入的数据数据类型必须是字符串类型）
关闭文件
'''
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
