[19/10/16-星期三] Python中的模块和包、异常、操作文件

一、模块

# 模块（module）
# 模块化，模块化指将一个完整的程序分解为一个一个小的模块
#   通过将模块组合，来搭建出一个完整的程序
# 不采用模块化，统一将所有的代码编写到一个文件中
# 采用模块化，将程序分别编写到多个文件中
#   模块化的有点：
#       ① 方便开发
#       ② 方便维护
#       ③ 模块可以复用！
 
# 在Python中一个py文件就是一个模块，要想创建模块，实际上就是创建一个python文件
# 注意：模块名要符号标识符的规范
 
# 在一个模块中引入外部模块
# ① import 模块名 （模块名，就是python文件的名字，注意不要后边的.py）
# ② import 模块名 as 模块别名
#   - 可以引入同一个模块多次，但是模块的实例只会创建一个
#   - import可以在程序的任意位置调用，但是一般情况下，import语句都会统一写在程序的开头
#   - 在每一个模块内部都有一个__name__属性，通过这个属性可以获取到模块的名字
#   - __name__属性值为 __main__的模块是主模块，一个程序中只会有一个主模块
#       主模块就是我们直接通过 python 执行的模块
import test_module as test
 
# print(test.__name__)
print(__name__)

测试

# 可以在模块中定义变量，在模块中定义的变量，在引入模块后，就可以直接使用了
#m.py文件
a = 10
b = 20
 
# 添加了_的变量，只能在模块内部访问，在通过import * 引入时，不会引入_开头的变量
_c = 30
 
# 可以在模块中定义函数，同样可以通过模块访问到
def test():
    print('test')
 
def test2():
    print('test2')
 
# 也可以定义类
class Person:
    def __init__(self):
        self.name = '孙悟空'
 
# 编写测试代码，这部分代码，只要当当前文件作为主模块的时候才需要执行
#   而当模块被其他模块引入时，不需要执行的，此时我们就必须要检查当前模块是否是主模块
if __name__ == '__main__':
    test()
    test2()
    p = Person()
    print(p.name)

# import m
 
# # 访问模块中的变量：模块名.变量名
# # print(m.a , m.b)
 
# # m.test2()
 
# p = m.Person()
 
# print(p.name)
 
def test2():
    print('这是主模块中的test2')
 
# 也可以只引入模块中的部分内容
# 语法 from 模块名 import 变量,变量....
# from m import Person
# from m import test
# from m import Person,test #引入2个
# from m import * # 引入到模块中所有内容，一般不会使用
# p1 = Person()
# print(p1)
# test()
# test2()
 
# 也可以为引入的变量使用别名
# 语法：from 模块名 import 变量 as 别名
# from m import test2 as new_test2
 
# test2()
# new_test2()
 
from m import *
# print(_c)
 
# import xxx
# import xxx as yyy
# from xxx import yyy , zzz , fff
# from xxx import *
# from xxx import yyy as zz

包

# 包 Package
# 包也是一个模块
# 当我们模块中代码过多时，或者一个模块需要被分解为多个模块时，这时就需要使用到包
# 普通的模块就是一个py文件，而包是一个文件夹
#   包中必须要一个一个 __init__.py 这个文件，这个文件中可以包含有包中的主要内容
from hello import a , b
 
print(a.c)
print(b.d)
 
# __pycache__ 是模块的缓存文件
# py代码在执行前，需要被解析器先转换为机器码，然后再执行
#   所以我们在使用模块（包）时，也需要将模块的代码先转换为机器码然后再交由计算机执行
#   而为了提高程序运行的性能，python会在编译过一次以后，将代码保存到一个缓存文件中
#   这样在下次加载这个模块（包）时，就可以不再重新编译而是直接加载缓存中编译好的代码即可

二、标准库

# 开箱即用
# 为了实现开箱即用的思想，Python中为我们提供了一个模块的标准库
# 在这个标准库中，有很多很强大的模块我们可以直接使用，
#   并且标准库会随Python的安装一同安装
# sys模块，它里面提供了一些变量和函数，使我们可以获取到Python解析器的信息
#   或者通过函数来操作Python解析器
# 引入sys模块
import sys
 
# pprint 模块它给我们提供了一个方法 pprint() 该方法可以用来对打印的数据做简单的格式化
import pprint
 
# sys.argv
# 获取执行代码时，命令行中所包含的参数
# 该属性是一个列表，列表中保存了当前命令的所有参数
# print(sys.argv)
 
# sys.modules
# 获取当前程序中引入的所有模块
# modules是一个字典，字典的key是模块的名字，字典的value是模块对象
# pprint.pprint(sys.modules)
 
# sys.path
# 他是一个列表，列表中保存的是模块的搜索路径
# ['C:\\Users\\lilichao\\Desktop\\resource\\course\\lesson_06\\code',
# 'C:\\dev\\python\\python36\\python36.zip',
# 'C:\\dev\\python\\python36\\DLLs',
# 'C:\\dev\\python\\python36\\lib',
# 'C:\\dev\\python\\python36',
# 'C:\\dev\\python\\python36\\lib\\site-packages']
# pprint.pprint(sys.path)
 
# sys.platform
# 表示当前Python运行的平台
# print(sys.platform)
 
# sys.exit()
# 函数用来退出程序
# sys.exit('程序出现异常，结束！')
# print('hello')
 
# os 模块让我们可以对操作系统进行访问
import os
 
# os.environ
# 通过这个属性可以获取到系统的环境变量
# pprint.pprint(os.environ['path'])
 
# os.system()
# 可以用来执行操作系统的名字
# os.system('dir')
os.system('notepad')

三、异常

# 第七章 异常和文件
 
## 异常
    程序在运行过程当中，不可避免的会出现一些错误，比如：
        使用了没有赋值过的变量
        使用了不存在的索引
        除0
        ...
    这些错误在程序中，我们称其为异常。
    程序运行过程中，一旦出现异常将会导致程序立即终止，异常以后的代码全部都不会执行！    
 
## 处理异常
    程序运行时出现异常，目的并不是让我们的程序直接终止！
    Python是希望在出现异常时，我们可以编写代码来对异常进行处理！    
 
    try语句
        try:
            代码块（可能出现错误的语句）
        except 异常类型 as 异常名:
            代码块（出现错误以后的处理方式）
        except 异常类型 as 异常名:
            代码块（出现错误以后的处理方式）
        except 异常类型 as 异常名:
            代码块（出现错误以后的处理方式）
        else：
            代码块（没出错时要执行的语句）
        finally:
            代码块（该代码块总会执行）    
 
        try是必须的 else语句有没有都行
        except和finally至少有一个    
 
    可以将可能出错的代码放入到try语句，这样如果代码没有错误，则会正常执行，
        如果出现错误，则会执行expect子句中的代码，这样我们就可以通过代码来处理异常
        避免因为一个异常导致整个程序的终止            
 
## 异常的传播（抛出异常）
    当在函数中出现异常时，如果在函数中对异常进行了处理，则异常不会再继续传播,
        如果函数中没有对异常进行处理，则异常会继续向函数调用处传播,
        如果函数调用处处理了异常，则不再传播，如果没有处理则继续向调用处传播
        直到传递到全局作用域（主模块）如果依然没有处理，则程序终止，并且显示异常信息
 
    当程序运行过程中出现异常以后，所有的异常信息会被保存一个专门的异常对象中，
        而异常传播时，实际上就是异常对象抛给了调用处
        比如 ： ZeroDivisionError类的对象专门用来表示除0的异常
                NameError类的对象专门用来处理变量错误的异常
                ....
 
    在Python为我们提供了多个异常对象            
 
## 抛出异常
    - 可以使用 raise 语句来抛出异常，
        raise语句后需要跟一个异常类 或 异常的实例
 
## 文件（File）
    - 通过Python程序来对计算机中的各种文件进行增删改查的操作
    - I/O(Input / Output)
    - 操作文件的步骤：
        ① 打开文件
        ② 对文件进行各种操作（读、写），然后保存
        ③ 关闭文件

# print('hello')
# try:
#     # try中放置的是有可能出现错误的代码
#     print(10/0)
# except:
#     # except中放置的是出错以后的处理方式
#     print('哈哈哈，出错了~~~')
# else:
#     print('程序正常执行没有错误')
# print('你好')
 
# print(10/0)
 
def fn():
    print('Hello fn')
    print(a)
    print(10/0)
 
def fn2():
    print('Hello fn2')
    fn()
 
def fn3():
    print('Hello fn3')
    fn2()
 
fn3()    

print('异常出现前')
l = []
try:
    # print(c)
    # l[10]
    # 1 + 'hello'
    print(10/0)
except NameError:
    # 如果except后不跟任何的内容，则此时它会捕获到所有的异常
    # 如果在except后跟着一个异常的类型，那么此时它只会捕获该类型的异常
    print('出现 NameError 异常')
except ZeroDivisionError:
    print('出现 ZeroDivisionError 异常')
except IndexError:
    print('出现 IndexError 异常')
# Exception 是所有异常类的父类，所以如果except后跟的是Exception，他也会捕获到所有的异常
# 可以在异常类后边跟着一个 as xx 此时xx就是异常对象
except Exception as e :
    print('未知异常',e,type(e))
finally :
    print('无论是否出现异常，该子句都会执行')
 
print('异常出现后')

自定义异常

# 也可以自定义异常类，只需要创建一个类继承Exception即可
class MyError(Exception):
    pass
 
def add(a,b):
    # 如果a和b中有负数，就向调用处抛出异常
    if a < 0 or b < 0:
        # raise用于向外部抛出异常，后边可以跟一个异常类，或异常类的实例
        # raise Exception
        # 抛出异常的目的，告诉调用者这里调用时出现问题，希望你自己处理一下
        # raise Exception('两个参数中不能有负数！')
        raise MyError('自定义的异常')
 
        # 也可以通过if else来代替异常的处理
        # return None
    r = a + b
    return r
 
print(add(-123,456))