异常，模块，文件，数据存储

########################1.异常###########################
在程序开发中，如果对某些代码的执行不确定(程序的语法完全正确)
可以增加try来捕获异常
示例：
try:
    尝试执行的代码
except:
    出现错误的处理
实例演示：
try:
    num = int(raw_input('请输入一个整数：'))
except:
    print '请输入正确的整数'
注意：无论是否输入错误额，下面的语句都会正常执行
print '*' * 50

实例演示：当python解释器抛出异常时，最后一行错误信息的第一个单词，就是错误类型。
需求：
# 1.提示用户输入一个整数
# 2.使用8除以用户输入的整数并且输出
num = int(raw_input('请输入一个整数:'))
result = 8 / num
print result
#（1）输入的不是数字

#（2）0不能做除数

可以异常处理的代码：
try:
    num = int(raw_input('请输入一个整数:'))
    result = 8 / num
    print result
except ZeroDivisionError:
    print '除0错误 0不能做除数'
except ValueError:
    print '请输入正确的整数'
捕获未知错误：
在开发的时候，要判断所有可能出现的错误，是有一定难度的
如果希望程序无论出现任何错误，都不会因python解释器抛出异常而终止。
可以再增加一个except
实例演练：
try:
    num = int(raw_input('请输入一个整数:'))
    result = 8 / num
    print result
#except ZeroDivisionError:
#    print '除0错误 0不能做除数'
except ValueError:
    print '请输入正确的整数'
# 捕获未知异常
# result:一个变量名，可以随便起名
except Exception as result:
    print '未知错误额 %s' % result

标准的异常捕获与异常处理代码模型：
try:
    #尝试执行的代码
   pass
except 错误类型1：
    pass
except 错误类型2：
    pass
except Exception as result:
    pass
else:
    #没有异常才会执行的代码
    pass
finally:
    #无论是否有异常，都会执行的代码
    pass
实例演练：
try:
    num = int(raw_input('请输入一个整数:'))
    result = 8 / num
    print result
#except ZeroDivisionError:
#    print '除0错误 0不能做除数'
except ValueError:
    print '请输入正确的整数'
# 捕获未知异常
# result:一个变量名，可以随便起名
except Exception as result:
    print '未知错误 %s' % result
# 只有在没有异常的时候，才会执行的代码
else:
    print '尝试成功！'
# 无论是否有异常，都会执行的代码
finally:
    print '*************'

异常的传递
异常的传递--当函数/方法执行出现异常，会将异常传递给函数/方法调用的一方
如果传递到主程序，依旧没有异常处理，程序才会终止，可以在主程序中增加
异常捕获，而在主函数中调用其他函数，只要出现异常，都会传递到主函数的异常
捕获中，这就不需要在代码中，增加大量的异常捕获，能够保证代码的整洁
def demo1():
    return int(raw_input('请输入整数：'))

def demo2():
    return demo1()

# 利用异常的传递性，在主程序中捕获异常
try:
    print demo2()
except Exception as result:
    print '未知错误 %s' % result

实例演练：
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
# 先创建异常对象，再抛出异常，再在主函数中捕获异常

断言:可以理解为提前预言，让人更好的知道错误原因

如上图所表示，如果我们的代码出现了错误，可我们对报错看不懂，但知道错误原因，我们可以加上断言，写上我们能懂的报错信息。
def func(num,div):
    assert (div != 0),'div不能为0'
    return num / div
print func(10,0)

#######################2.模块######################################
（1）使用import导入模块。
先新建两个python文件：test1,test2
test1:

test2:

在导入模块时，每个导入应独占一行
import test1
import test2
test1.say_hello()
test2.say_hello()
dog = test2.Dog()
print dog
cat = test1.Cat()
print cat
（2）使用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
（3）从模块中导入方法并指定别名
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()
python的解释器在导入模块的时候，会：
   1.搜索当前目录指定的模块文件，如果有就直接导入
   2.如果没有，再搜索系统目录
注意：在开发时，给文件起名，不要和系统模块文件重名
实例演练（没有指定random模块文件，这时搜索系统目录）：
import random
rand = random.randint(0,10)
print rand
在很多python文件中会看到以下格式的代码

    # 导入模块
    # 定义全部变量
    # 定义类
    # 定义函数

    #在代码的下方

    def main():
        pass
    if __name__ == '__main__'
        main()
在导入的.py文件中,输出是文件名
如：import test
__name__属性
__name__属性可以做到，测试模块的代码只在测试情况下被运行，而在被导入时不会执行
    __name__是python的一个内置属性，记录着一个字符串
    如果是被其他文件导入时，__name__就是模块名
    如果是当前执行的程序,__name__就是__main__
# 全局变量，函数，类 直接执行的代码不是向外界提供的工具
def say_hello():
    print 'hello hello'
#print 'have a nice day!'
# 如果直接在模块中输入，得到的是__main__
if __name__ == '__main__':
    print __name__
# 文件被导入的时候，能够直接被执行的代码不需要被执行
    print 'lily 开发的程序'
    say_hello()

#######################3.文件############################################
操作文件的函数/方法
在python中要操作文件需要记住的1个函数和3个方法
    #python中一切皆对象
    open  :打开文件，并且返回文件操作对象
    read  :将文件内容读取到内存
    write :将指定内容写入文件
    close :关闭文件
open函数负责打开文件，并且返回文件对象
read/write/close三个方法都需要通过文件对象来调用
read方法--读取文件
open函数的第一个参数是要打开的文件名(文件名区分大小写)
    如果文件存在，返回文件操作对象
    如果文件不存在，会抛出异常
read方法可以一次性读入并返回文件的所有内容
close方法负责关闭文件
# 如果忘记关闭文件，会造成系统消耗，而且会影响到后续对文件的访问
示例：
# 1.打开文件
file = open('REDME')
# 2.操作文件 读/写
# read方法：读取文件内容(一次性返回文件的所有内容)
text = file.read()
print text
# 3.关闭文件
# close方法：负责关闭文件
file.close()
# 在开发中，通常会先编写打开和关闭的代码
文件指针：
    文件指针标记从哪个位置开始读取数据
    第一次打开文件时，通常文件指针会指向文件的开始位置
    当执行了read方法后，文件指针会移动到读取内容的末尾
实例演练：
# 1.打开文件
file = open('REDME')
# 2.操作文件 读/写
# read方法：读取文件内容(一次性返回文件的所有内容)
text = file.read()
print text
print '*' * 50
# 第一次读取的时候，文件指针移动到了文件的末尾
# 再次调用不会读取到任何内容
text = file.read()
print text
# 3.关闭文件
# close方法：负责关闭文件
file.close()
注意文件的位置也可以不是当前位置，其他位置皆可。
实例演练：
# 1.打开文件
file = open('/home/kiosk/Desktop/file')
# 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()
打开文件的方式：
    name = open('文件名','访问方式')
以写的方式打开文件，如果文件存在会被覆盖，如果文件不存在，创建新文件
#1.打开文件
file = open('REDME','w')
# 2.写入文件
file.write('@#@!$@!$!')
# 3.关闭文件
file.close()
以追加方式打开文件
# 如果该文件存在，文件指针会放在文件的末尾
# 如果文件不存在，创建文件并写入
# 1.打开文件
file = open('REDME','a')   a------append
# 2.写入文件
file.write('linux')
# 3.关闭文件
file.close()
按行读取文件
        read方法默认会把文件的所有内容一次性读到内存
        如果文件太大，对内存的占用会非常严重
readline方法：
    readline方法可以一次性读取一行内容
    方法执行后，会把文件指针移动到下一行，准备再次读取
# 读取大文件的正确姿势
file = open('REDME')
# 为什么要写成死循环:因为我们不知道要读取的文件有多少行
while True:
    text = file.readline()
    # 如果文件指针到文件的最后一行，那么就读不到内容了
    if not text:
        break
    # 每读取一个行，末尾都已经有一个\n
    print text
file.close()
实例演练:
# 1.打开文件
# 源文件以只读的方式打开
file_read = open('REDME')
# 目标文件以写的方式打开
file_write = open('README_COPY','w')
# 从源文件中读取内容
text = file_read.read()
# 将读取到的内容写到目标文件中
file_write.write(text)
# 关闭文件
file_read.close()
file_write.close()
实例演练（逐行读取文件并写入另一个文件）：
# 1.打开文件
file_read = open('REDME')
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()
关键字with在不需要访问文件后将其关闭，在这个程序中，
我们调用了open(),但没有调用close();你也可以调用open()和close来打开
和关闭文件，但这样做时，如果程序存在bug，导致close()语句没有执行，
文件将不会关闭，未妥善地关闭文件可能会导致数据丢失或受损，
如果在程序中过早地调用close(),
你会发现需要使用文件时它已经关闭(无法访问)，
这会导致更多地错误，你并非在任何情况下都能轻松地确定关闭文件地恰当时机
通过使用with结构，可让python去确定，
你只管打开文件，并在需要时使用它，
python会在合适的时候自动将其关闭
实例演练1：
with open('pi_digits') as file_object:
    contents = file_object.read()
    print contents
实例演练2：
filename = 'pi_digits'
with open(filename) as file_object:
    for line in file_object:
        print line
实例演练3：
filename = 'pi_digits'
with open(filename) as file_object:
    lines = file_object.readline()
for line in lines:
    print line
实例演练4:
filename = 'linux'
with open(filename,'w') as file_object:
    file_object.write('I love python.\n')
    file_object.write('I love linux.')
##############################4.数据存储--json##################################
很多程序都要求用户输入某种信息,程序都把用户提供的信息存储在列表和字典等数据结构中，
用户关闭程序时，你几乎总是要保存他们的信息：
一种简单的方式是使用模块json来存储数据
(在python中使用json的时候，主要也就是使用json模块，json是以一种良好的格式来进行数据的交互)
模块json让你能够将简单的Python数据结构转存到文件中，并在程序再次运行时加载该文件中的数据，
你还可以使用json在Python程序之间分享数据，更重要的是，json数据格式并非Python专用的，
这让你能够将以json格式存储的数据与使用其他编程语言的人分享。
注意：json(javascriptObject notation)格式最初是为javascript开发的，但随后成了一种常见格式，
被包括python在内的众多语言采用。
实例演练1(json.dump())：
import json
number = [1,2,3,4]
with open('numbers.json','w') as f_obj:
    # 我们使用函数json.dump()将数字列表存储到文件中
    json.dump(number,f_obj)
实例演练2(json.load()):
import json
filename = 'numbers.json'
with open(filename) as f_obj:
    # 我们使用函数json.load加载存储在numbers.json中的信息
    # 并将其存储到变量numbers中
    numbers = json.load(f_obj)
print numbers
实例演练3：
import json
username = raw_input('what is your name ?')
filename = 'username.json'
with open(filename,'a') as f_obj:
    json.dump(username,f_obj)
    print 'We will rember you when you come back, %s' % username
实例演示4：
import json
filename = "username.json"
with open(filename) as f_obj:
    username = json.load(f_obj)
    print "Welcome back, %s" % username
实例演示5（异常与数据存储的合用）：
如果以前存储了用户，就显示
否则，就提示用户输入用户名并存储它
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