python学习总结之异常总结

@TOC

<hr style=" border:solid; width:100px; height:1px;" color=#000000 size=1">

1.异常处理(1)

• 语法格式

# import Exception
# except 在捕获错误异常的时候  只要根据具体的错误类型来捕获的
# 用一个块 可以捕获多个不同类型的异常
# Exception 可以捕获所有的异常  当对出现的问题或者错误不确定的情况下  可以使用Exception
# print(dir(Exception))
try:
    # print(b) #捕获逻辑的代码
    li=[1,2,34]
    print(li[10])  #通过下标去访问列表
    # a=10/0
    pass
except  NameError as msg:
#     # 捕获到的错误 才会在这里执行
#     print(msg)
     pass
except IndexError as msg:
#     print(msg)
     pass
except ZeroDivisionError as msg:
#     print(msg)
    pass
except Exception as result:
    # print(result)
    # 在此尽量的去处理捕获到的错误
    pass
# print('初次接触异常处理')
# print('HAHAHAHHAHA')

# try-except-else

# try:
#     print('我是没有错误产生的')
#     pass
# except SyntaxError as msg:
#     print(msg)
# except Exception as msg:
#     print('error',msg)
# else:
#     print('当Try里面的代码 没有出现异常的情况下 我才会执行')
#     pass

# try-except-finally
try:
    int('34')
    open('aaaa.txt')
except Exception as msg:
    print(msg)
    pass
finally:
    print('释放文件的资源、数据库连接是资源等等')
    print('不管有没有出错都执行的代码块')

2.异常处理(2)

• 常见的异常类型

异常	        导致的错误
AssertionError	当assert语句失败时引发。
AttributeError	当属性分配或引用失败时引发。
EOFError	当input()函数达到文件结束条件时引发。
FloatingPointError	当浮点运算失败时引发。
GeneratorExit	调用生成器的close()方法时引发。
ImportError	找不到导入的模块时引发。
IndexError	当序列的索引超出范围时引发。
KeyError	在字典中找不到键时引发。
KeyboardInterrupt	当用户按下中断键(Ctrl+c或delete)时引发。
MemoryError	当操作耗尽内存时引发。
NameError	在局部或全局范围内找不到变量时引发。
NotImplementedError	由抽象方法提出。
OSError	当系统操作导致系统相关错误时引发。
OverflowError	当算术运算的结果太大而无法表示时引发。
ReferenceError	使用弱引用代理访问垃圾收集的引用时引发。
RuntimeError	当错误不属于任何其他类别时引发。
StopIteration	函数引发，以指示迭代器不再返回任何项。
SyntaxError	遇到语法错误时由解析器引发。
IndentationError	当缩进不正确时引发。
TabError	当缩进由不一致的制表符和空格组成时引发。
SystemError	当解释器检测到内部错误时引发。
SystemExit	由sys.exit()函数引发。
TypeError	将函数或操作应用于类型不正确的对象时引发。
UnboundLocalError	当在函数或方法中引用局部变量，但没有将值绑定到该变量时引发。
UnicodeError	当发生与unicode相关的编码或解码错误时引发。
UnicodeEncodeError	当编码过程中发生与unicode相关的错误时引发。
UnicodeDecodeError	当解码过程中出现与unicode相关的错误时引发。
UnicodeTranslateError	翻译过程中发生与unicode相关的错误时引发。
ValueError	当函数得到类型正确但值不正确的参数时引发。
ZeroDivisionError	当除法或模运算的第二个操作数为零时引发。

• 异常处理机制

def A(s):
    return 10/int(s)
    pass
def B(s):
    return A(s)*2
def main():
    # B(0)
    try:
        B('0')
        pass
    except Exception as msg:
        print(msg)
        pass
    pass

# main()
# 不需要在每个可能出错的地方去捕获，只要在合适的层次去捕获错误就可以了 这样的话 就大大减少我们写try---except的麻烦
# 异常的抛出机制
#如果在运行时发生异常  解释器会查找相应的异常捕获类型
#如果在当前函数里面没有找到的话  它会将异常传递给上层的调用函数，看能否处理
# 如果在最外层 没有找到的话，解释器就会退出 程序down哦

3.异常处理（3)

• 自定义异常：都要直接或者间接继承Error或者Exception类

class ToolongMyException(Exception):
    def __init__(self,leng):
        '''

        :param leng: 长度
        '''
        self.len=leng
        pass
    def __str__(self):
        return '您输入姓名数据长度是'+str(self.len)+'超过长度了..'
    pass

def name_Test():
    name=input('请输入姓名.....')
    try:
        if  len(name)>5:
            raise ToolongMyException(len(name))
        else:
            print(name)
            pass
        pass
    except ToolongMyException as result:
        print(result)
        pass
    finally:
        print('执行完毕了....')

name_Test()

4.动态添加属性和方法（了解）

• 代码

import types  #添加方法的库

def dymicMethod(self):
    print('{}的体重是:{}kg 在 {} 读大学'.format(self.name,self.weight,Student.shcool))
    pass
@classmethod
def classTest(cls):
    print('这是一个类方法')
    pass

@staticmethod
def staticMethodTest():
    print('这是一个静态方法')
    pass

class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    pass
    def __str__(self):
        return '{}今天{}岁了'.format(self.name,self.age)
    pass

print('绑定类方法')
Student.TestMethod=classTest
# Student.TestMethod()

Student.staticMethodTest=staticMethodTest
Student.staticMethodTest()


print('---------------绑定类方法执行结束----------------------')

zyh=Student('张艳华',20)
zyh.weight=50 #动态添加
zyh.printInfo=types.MethodType(dymicMethod,zyh) #动态的绑定方法

zyh.TestMethod()
print('-------------实例对象调用 动态绑定类方法-----------------------')
# print(zyh)
# print(zyh.weight)
print('-------------另外一个实例对象  张明--------------------------')
zm=Student('张名',20)
zm.weight=80 #动态添加
print(zm)

zm.printInfo=types.MethodType(dymicMethod,zm) #动态的绑定方法
# print(zm.weight)
print('-------------给类对象添加属性--------------------------')
Student.shcool='北京邮电大学' #动态添加类属性
print(zm.shcool)
print('-------------执行动态调用实例方法--------------------------')
zyh.printInfo() #调用动态绑定的方法
zm.printInfo()

5. __slots __属性

• 作用： 限制要添加的实例属性；节约内存空间

class Student(object):
    __slots__ = ('name','age')
    def __str__(self):
        return '{}....{}'.format(self.name,self.age)
    pass
xw=Student()
xw.name='小王'
xw.age=20
xw.score=96 # 没有在范围内 所以报错
# print(xw.__dict__) #所有可以用的属性都在这里存储  不足的地方就是占用的内存空间大
# 可以看到 在定义了 slots变量之后 student类的实例已经不能随意创建不在 __slots__定义的属性了
# 同时还可以看到实例当中也不在有__dict__
# print(xw)

# 在继承关系当中的使用  __slots__
# 子类未声明  __slots__时，那么是不会继承父类的__slots__，此时子类是可以随意的属性赋值的
# 子类声明 了__slots__时，继承父类的__slots__，也就是子类__slots__的范围是为：
# 其自身+父类的__slots__
class subStudent(Student):
    __slots__ = ('gender','pro')
    pass
ln=subStudent()
ln.gender='男'
ln.pro='计算机信息管理'
print(ln.gender,ln.pro)

6.文件操作

6.1文件读写

• 写

# 文件的操作
# 打开文件 open
# 默认的编码是gbk 这个是中文编码，最好的习惯呢就是我们再打开一个文件的时候
# 给它指定一个编码类型
fobj = open('./Test.txt','w',encoding='utf-8')
# # 开始操作 读/写操作
fobj.write('在苍茫的大海上')
fobj.write('狂风卷积着乌云')
fobj.write('在乌云和大海之间\r\n')
fobj.write('海燕像黑色的闪电\r\n')
fobj.close()
# 以二进制的形式去写数据
fobj=open('Test_1.txt','wb') #str-->bytes
fobj.write('在乌云和大海之间'.encode('utf-8'))
fobj.close()
#用于追加数据
fobj=open('Test.txt','a') 
fobj.write('在乌云和大海之间\r\n')
fobj.write('海燕像黑色的闪电\r\n')
fobj.close()
fobj=open('Test.txt','a') #  a  用于追加数据
fobj.write('在苍茫的大海上')
fobj.write('狂风卷积着乌云')
fobj.write('在乌云和大海之间\n')
fobj.write('海燕像黑色的闪电\n')
fobj.write('今天我诗兴大发\n')
fobj.write('发感觉咋样呢\n')
fobj.close()

• 读

# 读数据操作
f=open('Test.txt','rb')
data=f.read() #读取所有的数据
print(data)
print(data.decode('gbk'))
# print(f.read(12))
# # print(f.read())
# print(f.readline()) #读一行数据
# print(f.readlines(1))
# f.close()  #文件对象关闭掉

# with上下文管理对象
# 优点 自动释放打开关联的对象
with open('Test.txt','a') as f:
    # print(f.read())
    f.write('我觉得python非常的好学\n')


# 小结
# 文件读写的几种操作方式
# read  r r+  rb  rb+
# r r+ 只读  使用普通读取场景
# rb  rb+  适用于 文件 图片 视频 音频 这样文件读取
# write w  w+ wb+  wb a  ab
# w wb+ w+  每次都会去创建文件
# 二进制读写的时候 要注意编码问题  默认情况下 我们写入文件的编码是gbk
# a  ab a+  在原有的文件的基础之后去【文件指针的末尾】去追加，
# 并不会每次的都去创建一个新的文件

def ctime(sec):
    pass

注：模式

6.2备份文件

# import fileOpt

# 文件的备份
def copyFile():
    # 接收用户输入的文件名
    old_file=input('请输入要备份的文件名:')
    file_list=old_file.split('.')
    # 构造新的文件名.加上备份的后缀
    new_file=file_list[0]+'_备份.'+file_list[1]
    old_f=open(old_file,'r') #打开需要备份的文件
    new_f=open(new_file,'w') #以写的模式去打开新文件,不存在则创建
    content=old_f.read() #将文件内容读取出来
    new_f.write(content) #将读取的内容写入到备份文件
    old_f.close()
    new_f.close()
    pass

copyFile()


def copyBigFile():
    # 接收用户输入的文件名
    old_file=input('请输入要备份的文件名:')
    file_list=old_file.split('.')
    # 构造新的文件名.加上备份的后缀
    new_file=file_list[0]+'_备份.'+file_list[1]
    try:
        #监视啊哟处理的逻辑
        with open(old_file,'r') as old_f,open(new_file,'w')as new_f:
            while True:
                content=old_f.read(1024) #一次读取1024字符
                new_f.write(content)
                if len(content)<1024:
                    break
    except  Exception as msg:
        print(msg)
    pass

6.3文件定位（了解）

# tell  返回指针当前所在的位置
# 对于中文讲 每次读取到的一个汉字 实际上占用了 2个字符
with open('Test.txt','r+') as f:
    print(f.read(3))
    print(f.tell())
    print(f.read(2))
    print(f.tell())
   pass

truncate 可以对源文件进行截取操作
fobjB=open('Test.txt','r')
print(fobjB.read())
fobjB.close()
print('截取之后的数据........')

fobjA=open('Test.txt','r+')
fobjA.truncate(15) #保留前15个字符
print(fobjA.read())
fobjA.close()

# seek 可以控制光标所在位置
with open('Test_备份.txt','rb') as f:
    f.seek(4,0) #光标是从0的位置开始 像前【右】移动 4个字符
    data=f.read(2)
    print(data.decode('gbk'))
    f.seek(-2,1) #相当于光标有设置到了0的位置
    print(f.read(4).decode('gbk'))
    f.seek(-6,2) #2 表示光标在末尾处  往回移动了6个字符
    print(f.read(4).decode('gbk'))
    pass

# 对于这种情况 用'r'这种模式打开文件，在文本文件中，没有使用二进制的选项打开文件，
# 只允许从文件的开头计算相对位置，从文件尾部计算或者当前计算的话 就会引发异常

6.4模块导入

• 1：import 模块注： import 到首次导入模块的时候 会发生如下3步操作： 1 打开模块文件 2 执行模块对应的文件，将执行过程中产生的名字都丢到模块的名称空间 3 在程序中会有一个模块【可以取别名的】的名称指向模块的名称空间去

import time as myTime  #加了一个别名
print(myTime.ctime())
# print(time.ctime()) #调用模块中的函数了
import fileOpt

• 2：路径搜索过程



• 3：from 模块 import 方法注：from ...import 首次导入发生了3个步骤 1 以模块为准创造一个模块的名称空间 2 执行模块对应的文件了，将执行过程中产生的名字都丢到模块的名称空间 3 在当前执行文件的名称空间中拿到一个名字，该名字直接指向模块中的某一个名字,意味着可以不用加任何的前缀而直接使用

from time import ctime,time #部分导入
# from time import *
print(ctime())

# 优点：不用加前缀 代码更加简洁了
# 缺点: 容易与当前执行文件中名称空间中的名字冲突

• 4.比较

# 相同点和不同点
	# 相同
	# 都会执行模块对应的文件 并且呢 都会产生模块课的名称空间
	# 两者在调用功能时呢，都需要转到定义时寻找作用域关系
	# 不同点
	# import 需要加前缀  from...import 不需要加前缀

7.常见模块

• os模块





• time、datatime模块

8.模块的制作、发布、安装

8.1模块的制作

• 模块的制作
• 一个随便的py文件就是一个模块
• 有了__name__,这样别的模块调用的时候，不会运行 注：__all__的作用

8.2模块的发布

• 1.写好包放在一个目录下
• 2.创建setup.py文件
• 3.创建模块
• 4.生成压缩包
• 5.tree看结构

8.3模块的安装

• 1.压缩包解压
• 2.安装
• 3.模块引入