本文深入探讨Python中的异常处理技巧，包括try-except语句的使用、异常的捕获与传递，以及如何优雅地处理未知错误。同时，文章介绍了Python模块化的实践，涵盖模块的导入、使用和最佳实践，帮助开发者提升代码质量和可维护性。
/home/kiosk一.异常
1.异常-01
|
1
2
3
4
5
6
|
在程序开发中，如果对某些代码的执行不确定（程序的语法完全正确）
可以增加
try
来捕获异常
try
：
尝试执行的代码
expect：
出现错误的处理
|
实验：
|
1
2
3
4
5
6
|
try
:
num=
int
(raw_input(
'请写入一个整数：'
))
except:
print
'请输入一个正确的整数'
#无论是否输入错误额，程序都会正常执行
print
'*'
*
50
|
输入正确结果：
输入错误结果：
2.异常-02
|
1
|
当python解释器抛出异常时，最后一行错误信息的第一个单词，就是错误类型。
|
实验：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
#
1
.提示用户输入一个整数
#
2
.使用
6
除以用户输入的整数并且输出
try
:
num =
int
(raw_input(
'请输入一个整数：'
))
result =
6
/ num
print result
except ZeroDivisionError:
print
'除0错误 0不能做除数'
except ValueError:
print
'请输入正确的整数'
#
1
.输入的不是数字
#
2.0
不能做除数
|
输入错误的结果：
输入正确的结果：
3.异常-03
|
1
2
3
4
|
捕获未知错误：
在开发的时候，要判断所有可能出现的错误，是有一定难度的
如果希望程序无论出现任何错误，都不会因python解释器抛出异常而终止
可以再增加一个except
|
实验：
|
1
2
3
4
5
6
7
8
9
|
try
:
num =
int
(raw_input(
'请输入一个整数：'
))
result =
6
/ num
print result
#捕获未知异常
#result：一个变量名，可以随便起名
except Exception as result:
print
'未知错误额 %s'
% result
|
输入错误的结果：
输入正确的结果：
4.异常-04
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
格式：
try
:
#尝试执行的代码
pass
except 错误类型
1
:
pass
except 错误类型
2
:
pass
expect Exception as result
else
:
#没有异常才会执行的代码
pass
finally
:
#无论是否有异常，都会执行的代码
pass
|
实验：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
try
:
num =
int
(raw_input(
'请输入一个整数：'
))
result =
6
/ num
print result
#捕获未知异常
#result：一个变量名，可以随便起名
except Exception as result:
print
'未知错误额 %s'
% result
#只有在没有异常的时候，才会执行的代码
else
:
print
'尝试成功！'
#无论是否有异常，都会执行的代码
finally
:
print
'================'
|
输入错误的结果：
输入正确的结果：
5.异常-05
|
1
2
3
4
5
|
异常的传递
异常的传递--当函数/方法执行出现异常，会将异常传递给函数/方法调用的一方
如果传递到主程序，依旧没有异常处理，程序才会终止，可以在主程序中增加
异常捕获，而在主函数中调用其他函数，只要出现异常，都会传递到主函数的异常
捕获中，这就不需要在代码中，增加大量的异常捕获，能够保证代码的整洁
|
实验：
|
1
2
3
4
5
6
7
8
9
10
11
|
def demo1():
return
int
(raw_input(
'请输入整数:'
))
def demo2():
return
demo1()
#利用异常的传递性，在主程序中捕获异常
try
:
print demo2()
except Exception as result:
print
'未知错误 %s'
% result
|
输入错误的结果：
输入正确的结果
6.异常-06
实验：
|
1
2
3
4
|
需求：
判断用户输入密码
1
.<
8
错误额
2
.>=
8
返回输入的密码
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
def input_passwd():
#
1
.提示用户输入密码
pwd = raw_input(
'请输入密码'
)
#
2
.判断密码的长度 >-=
8
,就返回用户输入的密码
if
len(pwd) >=
8
:
return
pwd
#
3
.<
8
,主动抛出异常
print
'主动抛出异常'
#
1
.创建异常对象(可以添加错误信息)
ex = Exception(
'密码长度不够'
)
raise ex
#注意：只抛出异常而不捕获异常，代码会出错
try
:
print input_passwd()
except Exception as result:
print result
|
输入正确的结果：
输入错误的结果：
二.模块
建立test1,test2
test1:
|
1
2
3
4
5
6
7
8
9
|
title =
'模块1'
#函数
def say_hello():
print
'我是 %s'
% title
#类
class
Cat(object):
pass
|
test2:
|
1
2
3
4
5
6
7
8
9
|
title =
'模块2'
#函数
def say_hello():
print
'我是 %s'
% title
#类
class
Dog(object):
pass
|
1.模块-01
|
1
2
3
4
5
|
__name__属性
__name__属性可以做到，测试模块内的代码只在测试情况下被运行，而在被导入时不会执行
__name__是python的一个内置属性，记录着一个字符串
如果是被其他文件导入时，__name__就是模块名
如果是当前执行的程序，__name__就是_mian_
|
实验：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
# 全局变量，函数，类 直接执行的代码不是向外界提供的工具
def say_hello():
print
'helll hello'
# print
'have a nice day!'
# 如果直接在模块中输入，得到的时__main__
if
__name__ ==
'__main__'
:
print __name__
#文件被导入的时候，能够直接被执行的代码不需要被执行
print
'gf 开发的程序'
say_hello()
|
实验结果：
2.模块-02
|
1
2
3
4
5
6
7
8
9
10
11
12
|
#在导入模块时，每个导入应独占一行
import
test1
import
test2
test1.say_hello()
test2.say_hello()
dog = test2.Dog()
print dog
cat = test1.Cat()
print cat
|
实验结果：
3.模块-03
|
1
2
3
4
5
6
7
8
9
10
11
|
#使用as指定模块的别名（大驼峰命名法）
import
test1 as CatModule
import
test2 as DogModule
DogModule.say_hello()
CatModule.say_hello()
dog = DogModule.Dog()
print dog
cat = CatModule.Cat()
print cat
|
4.模块-04
|
1
2
3
4
5
6
|
from test1
import
Cat
from test2
import
say_hello
from test1
import
say_hello as test1_say_hello
say_hello()
test1_say_hello()
miaomiao = Cat()
|
5.模块-05
|
1
2
3
4
|
python的解释器在导入模块的时候，会：
1
.搜索当前目录指定的模块文件，如果有就直接导入
2
.如果没有，在搜索系统目录
注意：在开发时，给文件起名，不要和系统模块文件重名
|
实验：
|
1
2
3
|
import
random
rand = random.randint(
0
,
10
)
print rand
|
6.模块-06
|
1
|
断言：可以理解为提前预言，让人更好的知道错误原因
|
实验：
|
1
2
3
4
|
def func(num,p):
assert
(p !=
0
),
'p不能为0'
return
num / p
print func(
10
,
2
)
|
7.模块-07
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
在很多python文件中会看到以下格式的代码
#导入模块
#定义全部变量
#定义类
#定义函数
#在代码下方
def main():
pass
if
__name__==
'__mian__'
mian()
|
实验：
|
1
2
3
4
|
建立一个test：
def say_hello():
print
'helll hello'
print __name__
|
|
1
2
|
#在导入的.py文件中，输出是 文件名
import
test
|
三.文件
建立两个名叫README和README_COPY的文件
建立方法 单击鼠标右键 => New => File
1.文件-01
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
操作文件的函数/方法
在python中要操作文件需要记住的
1
个函数和
3
个方法
#python中一切皆对象
open ：打开文件，并且返回文件操作对象
read ：将文件内容读取到内存
write ：将指定内容写入文件
close ：关闭文件
open函数负责打开文件，并且返回文件对象
read/write/close三个方法都通过文件对象来调用
read方法--读取文件
open函数的第一个参数是要打开的文件名（文件名区分大小写）
如果文件存在，返回文件操作对象
如果文件不存在，会抛出异常
read方法可以一次性读入并返回文件的所有内容
close方法负责关闭文件
|
实验：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
#如果忘记关闭文件，会造成系统损耗，而且会影响到后续对文件的运行
#
1
.打开文件
file = open(
'README'
)
#
2
.操作文件 读/写
#read方法：读取文件内容（一次性返回文件的所有内容）
text = file.read()
print text
#
3
.关闭文件
#close方法：负责关闭文件
file.close()
#在开发中，通常会先编写打开和关闭的代码
|
文件README中：
实验结果：
2.文件-02
|
1
2
3
4
|
文件指针：
文件指针标记从哪个位置开始读取数据
第一次打开文件时，通常文件指针会指向文件的开始位置
当执行了read方法后，文件指针会移动到读取内容的末尾
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
#如果忘记关闭文件，会造成系统损耗，而且会影响到后续对文件的运行
#
1
.打开文件
file = open(
'README'
)
#
2
.操作文件 读/写
#read方法：读取文件内容（一次性返回文件的所有内容）
text = file.read()
print text
#
3
.关闭文件
#close方法：负责关闭文件
file.close()
#在开发中，通常会先编写打开和关闭的代码
|
文件中README：
实验结果：
3.文件-03
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
#
1
.打开文件
file = open(
'README'
)
#
2
.操作文件 读/写
#read方法：读取文件内容（一次性返回文件的所有内容）
text = file.read()
print text
#打印输入内容的长度
print type(text)
print len(text)
print
'*'
*
50
text = file.read()
print text
print len(text)
#
3
.关闭文件
#close方法：负责关闭文件
file.close()
#在开发中，通常会先编写打开和关闭的代码
|
文件中README中：
实验结果：
4.文件-04
|
1
2
|
打开文件的方式：
name = open(
'文件名'
,
'访问方式'
)
|
实验：
|
1
2
3
4
5
6
7
|
#以写的方式打开文件，如果文件存在会被覆盖，如果文件不存在，创建新文件
#
1
.打开文件
file = open(
'README'
,
'w'
)
#
2
.写入文件
file.write(
'～～～～～'
)
#
3
.关闭文件
file.close()
|
原文件README中：
实验结果：
5.文件-05
|
1
2
3
4
5
6
7
8
9
|
# 以追加方式法开文件
# 如果该文件存在，文件指针会放在文件的末尾
# 如果文件不存在，创建文件并写入
#
1
.打开文件
file = open(
'README'
,
'a'
)
#
2
.写入文件
file.write(
'linux'
)
#
3
.关闭文件
file.close()
|
原文件README中：
实验结果：
6.文件-06
|
1
2
3
4
5
6
|
按行读取文件：
read方法默认会把文件的所有内容一次性读到内存
如果文件太大，对内存的占用会非常严重
readline方法：
readline方法可以一次性读取一行内容
方法执行后,会把文件指针移动到下一行，准备再次读取
|
实验：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
# 读取大文件的正确姿势
file = open(
'README'
)
# 为什么要写成死循环：因为我们不知道要读取的文件有多少行
while
True:
text = file.readline()
# 如果文件指定到文件的最后一行，那么就读不到内容
if
not text:
break
# 每读取一行，末尾都已经有一个\n
print text
file.close()
|
文件README中：
运行结果：
7.文件-07
实验：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
#
1
.打开文件
#源文件以只读的方式打开
file_read = open(
'README'
)
#目标文件以写的方式打开
file_write = open(
'README_COPY'
,
'w'
)
#从源文件中读取内容
text = file_read.read()
#将读取到的内容写到目标文件中
file_write.write(text)
#关闭文件
file_read.close()
file_write.close()
|
文件README
文件和README_COPY
实验结果：
README_COPY文件中：
8.文件-08
|
1
|
读取大文件
|
实验：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
#
1
.打开文件
file_read = open(
'README'
)
file_write = open(
'README_COPY'
,
'w'
)
#读写
while
True:
text = file_read.readline()
if
not text:
break
file_write.write(text)
#关闭
file_read.close()
file_write.close()
|
文件README中
文件README_COPY中
实验结果：
文件README_COPY
|
1
2
3
4
5
6
7
8
9
10
|
关键字with在不需要访问文件后将其关闭，在这个程序中，
我们调用了open(),但没有调用close();你也可以调用open()和close来打开
和关闭文件，但这样做时，如果程序存在bug，导致close()语句没有执行，
文件将不会关闭，未妥善地关闭文件可能会导致数据丢失或受损，
如果在程序中过早地调用close(),
你会发现需要使用文件时它已经关闭(无法访问)，
这会导致更多地错误，你并非在任何情况下都能轻松地确定关闭文件地恰当时机
通过使用with结构，可让python去确定，
你只管打开文件，并在需要时使用它，
python会在合适的时候自动将其关闭
|
建立名叫linux和pi_digits的文件
1.文件-11
|
1
2
3
|
with open(
'pi_digits'
) as file_object:
contents = file_object.read()
print contents
|
文件pi_digits中
运行结果：
2.文件-12
|
1
2
3
4
|
filename =
'pi_digits'
with open(filename) as file_object:
for
line in file_object:
print line
|
文件pi_digits中：
运行结果：
3.文件-13
|
1
2
3
4
5
|
filename =
'pi_digits'
with open(filename) as file_object:
lines = file_object.readline()
for
line in lines:
print line
|
文件pi_digits中:
运行结果:
4.文件-14
|
1
2
3
4
|
filename =
'linux'
with open(filename,
'w'
) as file_object:
file_object.write(
'I love python.\n'
)
file_object.write(
'I love linux.'
)
|
文件linux中：
运行结果：
5.文件-15
|
1
2
3
4
|
filename =
'linux'
with open(filename,
'a'
) as file_object:
file_object.write(
'I love python.\n'
)
file_object.write(
'I love linux.'
)
|
文件linux中：
运行结果：
四.数据储存-json
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
很多程序都要求用户输入某种信息
程序都把用户提供的信息储存在列表和字典等数据结构中，
用户关闭程序时，你几乎总要保存他们的信息：
一种简单的方式是使用模块json来储存数据
（在python中使用json的时候，主要也就是json模块，json是以一种良好的格式来进行数据交互）
模块json让你能够将简单的Python数据结构转存到文件中，
并在程序再次运行时加载该文件中的数据，
你还可以使用json在Python程序之间分享数据，
更重要的是，json数据结构格式并非Python专用的，
这让你能够将以json格式储存的数据与使用其他编程语言的人分享
注意：json(javascriptObject notation)格式最初是为了javascript开发的，但随后成了一种常见格式，
被包括python在内的众多语言采用
|
实验一：
|
1
2
3
4
5
6
|
import
json
number = [
1
,
2
,
3
,
4
]
with open(
'number.json'
,
'w'
) as f_obj:
# 我们使用函数json.dump()将数字列表储存到文件中
json.dump(number,f_obj)
|
运行结果：
会生成一个文件：number.json
实验二：
|
1
2
3
4
5
6
7
|
import
json
filename =
'number.json'
with open(filename) as f_obj:
#我们使用函数json.load加载储存在number.json的信息
#并将其储存到变量number中
number = json.load(f_obj)
print number
|
运行结果：
实验三：
|
1
2
3
4
5
6
|
import
json
username = raw_input(
'what is your name?'
)
filename =
'username.json'
with open(filename,
'w'
) as f_obj:
json.dump(username,f_obj)
print
'We will remember you when you come back,%s'
% username
|
运行结果：
会创建一个文件：username.json
实验四：
前提：存在username.json 且存在数据
|
1
2
3
4
5
|
import
json
filename =
"username.json"
with open(filename) as f_obj:
username = json.load(f_obj)
print
'Welcome back, %s'
% username
|
实验五：
前提：存在username.json
|
1
2
3
|
需求：
如果以前储存了用户，就显示
否则，就提示用户输入用户名并储存它
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
import
json
filename =
"username.json"
try
:
with open(filename) as f_obj:
username = json.load(f_obj)
except ValueError:
username = raw_input(
"What is you name? "
)
with open(filename,
"w"
) as f_obj:
json.dump(username,f_obj)
print
"We'll remember you when you come back %s"
% username
#依赖于
try
代码块成功执行的代码都应放到
else
代码块中:
else
:
print
"Welcome back %s "
% username
|
运行结果：
若username.json存在数据
若username.json不存在数据
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
