1.异常
概述：
在程序开发中,如果某些代码的执行不确定（程序的语法完全正确），可以增加try 来捕获异常
（1）基本语法格式：
try:
要执行的代码
except:
出现错误的处理
代码
try:
num = int(raw_input('请输入一个整数：'))
except:
print '请输入正确的整数'
# 无论输入是否正确,程序都会正确的执行
print '*' * 50
执行结果：
例1
需求：
1.提示用户输入一个整数
2.使用8除以用户输入的整数并输出
预知错误类型：
1. 输入的不是整数
2. 0 不能作为除数
注意：当python解释器抛出异常时,最后一行错误信息的第一个单词就是错误类型
代码
try:
num = int(raw_input('请输入一个整数:'))
result = 8 / num
print result
except ZeroDivisionError:
print '除数错误 0不能作为除数'
except ValueError:
print '请输入一个正确的整数'
执行结果：
（2）捕获未知异常：
在开发时,要判断所有可能出现的错误,是有一定难度的,若希望程序无论出现任何错误 都不会因为python解释器
抛出的异常而终止,可以再增加一个except
代码
try:
num = int(raw_input('请输入一个整数:'))
result = 8 / num
print result
except ValueError:
print '请输入一个正确的整数'
# 当某些错误我们预知不到的时候
# 此时可以利用python解释器来捕获未知异常
# result为一个变量名,可以随意取
except Exception as result:
print '未知错误 %s' % result
执行结果：
（3）完整的语法格式
try:
#想要执行的代码
pass
except: 错误类型1
pass
except: 错误类型2
pass
except Exception as 变量名:
#未知异常
pass
else:
#没有异常时才会执行的代码
pass
finally:
#无论是否有异常都会执行的代码
pass
代码
try:
num = int(raw_input('请输入一个整数:'))
result = 8 / num
print result
except ValueError:
print '请输入一个正确的整数'
# 当某些错误我们预知不到的时候
# 此时可以利用python解释器来捕获未知异常
# result为一个变量名,可以随意取
except Exception as result:
print '未知错误 %s' % result
# 只有在没有异常的时候,才会执行
else:
print '尝试成功'
# 无论是否有异常,都会执行
finally:
print '*************'
执行结果：
（4）异常的传递
当函数/方法执行出现异常时,会将异常传递给函数/方法调用的一方，如果传递到主程序,依旧没有异常处理,程序才会终止，可以在主程序中增加，异常捕获,而主函数中调用其他函数,只要出现异常,都会传递到主函数的，异常捕获中,这就避免在代码中增加大量的异常捕获 能够保证代码的整洁
代码
def demo1():
return int(raw_input('请输入一个整数：'))
# 异常具有传递性
#print demo1()
def demo2():
return demo1()
# 利用异常的传递性在主程序中捕获异常
try:
print demo2()
except Exception as result:
print '未知错误 %s' % result
执行结果：
实例：
需求：
判断用户输入的密码
1. < 8 错误
2. >= 8 返回输入的密码
先创建异常对象 再抛出异常 在主函数中捕获异常
len() 判断字符长度的函数
代码
def input_passwd():
# 提示用户输入密码
passwd = raw_input('请输入密码：')
# 判断密码长度如果大于8就后返回输入的密码
if len(passwd) >= 8:
return passwd
# 如果密码长度小于8就主动抛出异常
# print '主动抛出异常'
# 1.创建异常对象（可以添加错误信息）
ex = Exception('密码太短了')
raise ex
# 注意：只抛出异常而不捕获异常,代码会报错
# 2.捕获异常
try:
print input_passwd()
except Exception as result:
print result
执行结果：
2.断言:
提前预言 让人更好的知道错误的原因
代码
def func(num,div):
assert (div != 0),'div不能为0'
return num / div
print func(10,0)
执行结果：
3.模块
（1）建立一个test1 :
代码
title = '模块1'
# 定义函数
def say_hello():
print '我是 %s' % title
# 定义类
class Cat(object):
pass
（2）再建立一个test2 :
代码
title = '模块2'
def say_hello():
print '我是 %s' % title
class Dog(object):
pass
（3）重新建立文件
代码1
import test1
import test2
test1.say_hello()
test2.say_hello()
cat = test1.Cat()
print cat
dog = test2.Dog()
print dog
执行结果：
代码2
# 使用as指定模块的别名（大驼峰命名法）
import test1 as CatModule
import test2 as DogModule
CatModule.say_hello()
DogModule.say_hello()
cat = CatModule.Cat()
print cat
dog = DogModule.Dog()
print dog
执行结果：
（4）python的解释器在导入模块的时候,会：
1.搜索当前目录指定的模块文件,如果有就直接导入
2.如果没有,再搜索系统目录
注意：在开发时 给文件起名 不要和系统模块文件重名
如果出现重名,再导入模块的时候会报错
代码
# 导入random模块
import random
# 生成0-10的随机数
rand = random.randint(0,10)
print rand
执行结果：
（5）__name__ 属性
可以做到 测试模块的代码只是在测试的情况下被运行,而在被导入的时候不会被执行
__name__是python的一个内置属性 __name__记录着一个字符串
注意：如果是被其他文件导入时 __name__就是模块名
如果时被当前文件执行的程序 __name__就是__main__
代码1：
1.在test3中
代码
def say_hello():
print 'hello word!'
#print 'have a nice day'
#say_hello()
# 直接在模块中输入 得到的是__main__
print __name__
执行结果：
2.在003中
# 在导入的文件中 输出的是 文件名
import test3
执行结果：
在test3中
代码2：
# 全局变量 函数 类 直接执行的代码不是向外界提供的工具
def say_hello():
print 'hello word!'
#print 'have a nice day'
#say_hello()
# 直接在模块中输入 得到的是__main__
# print __name__
if __name__ == '__main__':
print __name__
print 'lily 开发的程序'
say_hello()
执行结果：
在003中：
代码
# 在导入的文件中 输出的是 文件名
import test3
执行结果：
4.文件
1.操作文件的函数/方法
在python中要操作文件需要记住1个函数和3个方法
#python中一切皆对象
（1）. open函数
负责打开文件 并返回文件对象
语法格式：
变量名 = open('文件名')
注意： 如果文件存在 返回文件操作对象， 如果文件不存在 会影响后续文件，文件名区分大小写
（2）. 三个方法
都需要通过文件对象来调用
read 将文件内容读取到内
write 将指定内容写入文件
close 关闭文件
（1）. 1 read方法
可以一次性读入并返回文件的所有内容
格式：
变量名=文件名.read（）
先建立一个名为README的文件（点击鼠标右键 ---> New ---> File）
并在README文件中写入：hello python
代码
# 1. 打开文件
file = open('README')
# 2. 操作文件 读/写
# read方法 读取文件内容并打印文件内容（一次性返回文件的所有内容）
text = file.read()
print text
# 3. 关闭文件
# close方法 负责关闭文件
file.close()
# 在开发中 通常会先编写打开文件和关闭文件的代码 再操作文件
执行结果：
文件指针：
文件指针标记从那个位置开始读取数据，第一次打开文件时 通常文件指针会指向文件开始的位置，当执行了read方法后 文件指针会移动到读取内容的末尾
再在README文件中写入：my love
代码1
# 1. 打开文件
file = open('README')
# 2. 操作文件 读/写
# read方法 读取文件内容（一次性返回文件的所有内容）
text = file.read()
print text
print '*' * 50
# 第一次读取的时候 文件指针移动到了文件的末尾
# 再次读取的时候 便读取不到文件内容
text = file.read()
print text
# 3. 关闭文件
# close方法 负责关闭文件
file.close()
执行结果：
代码2
# 1. 打开文件
# 文件名也可以用绝对路径的方式
#file = open('/home/kiosk/python07')
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()
执行结果：
（1) .2 readline方法
read方法默认会把文件的所有内容一次性读到内存,如果文件太大,对内存的占用会非常严重
readline方法：
可以一次性读取一行内容, 方法执行后,会把文件指针移动到下一行,准备再次读取
格式：
变量名 = 文件名.readline()
代码
# 读取大文件的正确姿势
file = open('README')
# 由于未知文件的行数 故写为死循环
while True:
text = file.readline()
# 如果文件指针到文件的最后一行 便跳出循环
if not text:
break
# 每读取一行 末尾便会自动加上\n换行
print text
file.close()
执行结果：
（2）write方法
将指定内容写入文件
格式：
变量名 = open('文件名','w') # w 表示 覆盖
变量名 = open('文件名','a') # a 表示 追加
代码1
# 1. 打开文件
# w 会覆盖原文件内容
file = open('README','w')
# 2. 写入文件
file.write('westos')
# 3. 关闭文件
file.close()
执行结果：
README文件中的内容变为 westos 将原来文件中的内容覆盖
代码2
# 1. 打开文件
# a 表示追加,不会覆盖原文件内容
# 如果该文件存在,文件指针会放在文件的末尾
# 如果文件不存在,会自动创建文件并写入
file = open('README','a')
# 2. 写入文件
file.write('linux')
# 3. 关闭文件
file.close()
执行结果：
在README文件中的westos后边添加linux
实例
需求：复制文件
代码1（read方法）
# 1.打开文件
# 源文件以只读方式打开
file_read = open('README')
# 目标文件以写的方式打开
file_write = open('READ_COPY','w')
# 从源文件中读取内容
text = file_read.read()
# 将读取的内容写到目标文件中
file_write.write(text)
# 3.关闭文件
file_read.close()
file_write.close()
执行结果：
自动创建名为READ_COPY的文件
代码2（readline方法）
再在README文件中添加一行
写入 nice day
# 1.打开文件
# 源文件以只读方式打开
file_read = open('README')
# 目标文件以写的方式打开
file_write = open('READ_COPY1','w')
# 2.读写
while True:
text = file_read.readline()
# 如果文件指针到文件的最后一行 便跳出循环
if not text:
break
# 每读取一行便将读取的内容写到目标文件中
file_write.write(text)
# 3.关闭文件
file_read.close()
file_write.close()
执行结果：
（3）close方法
用于关闭文件
格式：
文件名.close()
2.关键字with
概述：
在不需要访问文件后将其关闭 ,在这个程序中我们调用了open()函数 但没有调用close()，你可以调用open()和close() 来打开和关闭文件,但这样做时,如果程序存在bug，会导致close()语句没执行,文件将不会关闭,未妥善的关闭文件可能会导致数据的丢失或受损，如果在程序中过早的调用close(),你会发现需要使用文件时,它已经关闭（无法访问），这样会导致很多的错误。
你并非在任何情况下都能轻松的确定关闭文件通过使用with结构,可让python去确定，你只需要打开文件,并在需要的时候使用它，python会在和时的时候自动将其关闭
先创建一个名为pi_file的文件
并在pi_file文件中写入 3.1415926
代码1
# 好处：打开文件后无需关闭文件
with open('pi_file') as file_object:
contents = file_object.read()
print contents
执行结果：
代码2
filename = 'pi_file'
with open(filename) as file_object:
# 按行打印 中间会自动出现换行符
for line in file_object:
print line
执行结果：
代码3
filename = 'pi_file'
# 读取文件
with open(filename) as file_object:
lines = file_object.readline()
#for line in lines:
# 只会打印第一行
print lines
执行结果:
代码4
filename = 'pi_file'
# 写入文件
# 如果是a 便会添加到文件内容的末尾
with open(filename,'w') as file_object:
file_object.write('I love me\n')
file_object.write('I love you')
执行结果：
5.数据存储
概述：
很多程序都要求用户输入某种信息,程序都把用户提供的信息存储在列表和字典等数据结构中，用户关闭程序时,你几乎总是要保存他们的信息:，一种简单的方式是使用json模块来存储数据(在python中使用json的时候，主要也就是使用json模块，json是以一种良好的格式来进行数据的交互)，json模块让你能够将简单的python数据转存到文件中,并在程序再次运行时加载该文件中的数据，你还可以使用json在python程序之间分享数据，更重要的是json数据个格式存储的数据与使用其他编程语言的人分享
注意：
json（javascriptObject natation）格式最初是为 javascript开发的,但随后成了一种常见的格式,被包括python在内的众多语言采用
代码1
# 导入 json
import json
number = [1,3,5]
# 以写的方式打开number.json文件
with open('number.json','w') as w_obj:
# 函数json.dump 表示将number写入w_obj
json.dump(number,w_obj)
执行结果：
代码2
# 导入json
import json
filename = 'number.json'
# 以只读的方式打开filename文件
with open(filename) as w_obj:
# 函数json.load 表示加载存储在numbers.json中的信息
# 并将其存储到变量numbers中
numbers = json.load(w_obj)
print numbers
执行结果：
代码3
import json
username = raw_input('what is your name')
filename = 'username.json'
# w会覆盖 a表示追加
with open(filename,'a') as w_obj:
# 将username写入w_obj
json.dump(username,w_obj)
print 'we will remember you forever %s' % username
执行结果：
代码4
# 导入json
import json
filename = 'username.json'
# 以读的方式打开文件
with open(filename) as w_obj:
username = json.load(w_obj)
print 'welcome back %s' % username
执行结果：
