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

时间 2019-11-16

原文原文链接

1、模块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

包less

# 包 Package
# 包也是一个模块
# 当咱们模块中代码过多时，或者一个模块须要被分解为多个模块时，这时就须要使用到包
# 普通的模块就是一个py文件，而包是一个文件夹
#   包中必需要一个一个 __init__.py 这个文件，这个文件中能够包含有包中的主要内容
from hello import a , b

print(a.c)
print(b.d)

# __pycache__ 是模块的缓存文件
# py代码在执行前，须要被解析器先转换为机器码，而后再执行
#   因此咱们在使用模块（包）时，也须要将模块的代码先转换为机器码而后再交由计算机执行
#   而为了提升程序运行的性能，python会在编译过一次之后，将代码保存到一个缓存文件中
#   这样在下次加载这个模块（包）时，就能够再也不从新编译而是直接加载缓存中编译好的代码便可

2、标准库模块化

# 开箱即用
# 为了实现开箱即用的思想，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')

3、异常函数

# 第七章 异常和文件

## 异常
    程序在运行过程中，不可避免的会出现一些错误，好比：
        使用了没有赋值过的变量
        使用了不存在的索引
        除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))