Python约束和异常处理,Md5,日志处理

报错

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
def chufa(a,b):
    try: #尝试执行XX代码
        ret = a/b #如果这里出现了错误.异常.
        #系统内部会产生一个异常对象. 系统会把这个错误抛出,
        #抛出给调用方
        return ret
    # except ZeroDivisionError as e:
    #except ZeroDivisionErro as e: # 内部产生的所有异常都会被捕获 #捕获的异常对象会交给e
    #    print(e)
    #    print("出错,0不能是除数")
    # except FileExistsError as e:
    # except StopIteration as e:
    except Exception as e:
    #except:   #同 except Exception #所有异常
        print(e)
        print("出错了")

    else: #保护不抛出异常的代码,当try 中无异常的时候执行


    finally: #最好总会执行部分

    # return a/b
ret = chufa(5,0)
print(ret)


#计算两个整数的加法
def add(a, b):
    if type(a)!=int or type(b) != int:
        # return
        # return Exception
        raise TypeError("我这里只要int, 不要别的类型")
    return a + b

add(123, "abc"


自定义异常返回

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

class GenderError(Exception):
    pass
class Person:
    def __init__(self,name,gender):
        self.name = name
        self.gender = gender


def xi(per):
    if per.gender != '男':
        raise GenderError("这里是男澡堂")
    else:
        print("进去了")
p1 = Person('tudou',"不详")
p2 = Person('mantou','男')


import traceback # 导入模块
try:
    xi(p2)
except GenderError as g:
    print(g)
    val = traceback.format_exc() #获取堆栈信息
    print(val)


类的约束

约束是对子类进行的约束。

  • 在父类中给出一个方法。 这个方法中什么都不写。 就抛异常。 NotImplementError()
  • 在子类中把上述的方法进行重写。
  • 在子类中把上述的方法进行重写。

  1. python中有两种办法来解决这样的问题.

    提取父类. 然后在父类中定义好方法. 在这个方法中什么都不用干. 就抛一个异常就可以了. 这样所有的子类都必须重写这个方法. 否则. 访问的时候就会报错.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

class Base:
    def login(self):
        #raise Exception("没有实现login方法")
        raise NotImplementedError("没有实现login方法") #专业的写法
    def kantie(self):
        raise Gk("没有看帖功能")

class Normal(Base):
    def login(self):
        print("普通人登录")

 ## 李四写
class Menber(Base):
    def l(self):
        print("吧务登录")

 ## 王八
class Admin(Base):
    def login(self):
        print("管理员登录")

def login(obj):
    print("产生验证码")
    obj.login()
    print("进入主页")
 ## 场景


n = Normal()
m = Menber()
a = Admin()

login(n)
login(m)
login(a)

  1. 使⽤用元类来描述父类. 在元类中给出一个抽象方法. 这样子类就不得不给出抽象方法的具体实现. 也可以起到约束的效果.

    python中编写⼀一个抽象类比较⿇麻烦. 需要引入abc模块中的ABCMeta和
    abstractmethod这两个内容. 来我们看一个例例⼦子.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


from abc import ABCMeta,abstractmethod

class Base(metaclass=ABCMeta):
    @abstractmethod
    def login(self):pass


# 张三
class Normal(Base):
    def login(self):
        print("::普通人登陆")

# 李四
class Member(Base):
    def login(self):
        print("::吧务登陆")

# 王五
class Admin(Base):
    def login(self):
        print("::管理员登陆")

def login(obj):
    print("1.产生验证码")
    obj.login() # 标准在这里.  必须由login
    print("3.进入主页")

# 场景
n = Normal()
m = Member()
a = Admin()
login(n)
login(m)
login(a)

​

总结: 约束. 其实就是⽗类对⼦类进行约束. 子类必须要写xxx方法. 在python中约束的

方式和方法有两种:

  1. 使用抽象类和抽象方法, 由于该方案来源是java和c#. 所以使用频率还是很少的
  2. 使用人为抛出异常的方案. 并且尽量量抛出的是NotImplementError. 这样比较专业, 而且错误比较明确.(推荐)

异常类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
IOError 输入/输出异常；基本上是无法打开文件
ImportError 无法引入模块或包；基本上是路径问题或名称错误
IndentationError 语法错误（的子类） ；代码没有正确对齐
IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
KeyError 试图访问字典里不存在的键
KeyboardInterrupt Ctrl+C被按下
NameError 使用一个还未被赋予对象的变量
SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
TypeError 传入对象类型与要求的不符合
UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，
导致你以为正在访问它
ValueError 传入一个调用者不期望的值，即使值的类型是正确的

常用异常

Exception 万能异常

异常处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

def chu(a, b):
	return a/b
	ret = chu(10, 0)
	print(ret)

###ZeroDivisionError: division by zero


def chu(a, b):
	return a/b
try:
	ret = chu(10, 0)
	print(ret)
except Exception as e:
	print("除数不不能是0")
结果:
除数不不能是0



try:
	print("各种操作....")
except ZeroDivisionError as e:
	print("除数不不能是0")
except FileNotFoundError as e:
	print("⽂文件不不存在")
except Exception as e:
	print("其他错误")





MD5

MD5是一种不可逆的加密算法. 它是可靠的. 并且安全的. 在python中我们不需要手写
这一套算法. 只需要引入一个叫hashlib的模块就能搞定MD5的加密工作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#引入模块
import hashlib


#1.创建一个md5对象
obj = hashlib.md5()
#obj = hashlib.md5(b"3I31") #加..

#2.把要加密的内容给md5
obj.update("root".encode("utf-8")) #必须是字节

# 3.获取密文

val = obj.hexdigest()
print(val)
import  hashlib

def my_md5(yal):
    obj = hashlib.md5()
    obj.update(yal.encode("utf-8"))
    val = obj.hexdigest()
    return val


#注册的时候,用md5 进行加密,

name = input("name")
passwd = input("passwd")

#ps = my_md5(passwd)

if name == "man" and my_md5(passwd) == "63a9f0ea7bb98050796b649e85481845":
    print('go')
else:
    print("n")

使用实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

# python 检测文件MD5值
# python version 2.6

import hashlib
import os
import sys


# 简单的测试一个字符串的MD5值
import hashlib
def md5sum(obj):
    hash = hashlib.md5()
    hash.update(obj.encode('utf-8'))
    return hash.hexdigest()#字符

def GetStrMd5(src):
    m0 = hashlib.md5()
    m0.update(src)
    print(m0.hexdigest())
    pass


# 大文件的MD5值
def GetFileMd5(filename):
    if not os.path.isfile(filename):
        return
    myhash = hashlib.md5()
    f = open(filename, 'rb')
    while True:
        b = f.read(8096)
        if not b:
            break
        myhash.update(b)
    f.close()
    return myhash.hexdigest()


def CalcSha1(filepath):
    with open(filepath, 'rb') as f:
        sha1obj = hashlib.sha1()
        sha1obj.update(f.read())
        hash = sha1obj.hexdigest()
        print(hash)
        return hash


def CalcMD5(filepath):
    with open(filepath, 'rb') as f:
        md5obj = hashlib.md5()
        md5obj.update(f.read())
        hash = md5obj.hexdigest()
        print(hash)
        return hash


if __name__ == "__main__":
    if len(sys.argv) == 2:
        hashfile = sys.argv[1]
        if not os.path.exists(hashfile):
            hashfile = os.path.join(os.path.dirname(__file__), hashfile)
            if not os.path.exists(hashfile):
                print("cannot found file")
            else:
                CalcMD5(hashfile)
        else:
            CalcMD5(hashfile)
            # raw_input("pause")
    else:
        print("no filename")

日志处理

  1. 导入logging模块.
  2. 简单配置⼀一下logging
  3. 出现异常的时候(except). 向⽇日志⾥里里写错误信息.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
import logging

logging.basicConfig(filename='app.log',
                    format='%(asctime)s - %(name)s - %(levelname)s - %(module)s: %(message)s',
                    datefmt='%Y-%m-%d %H:%M:%S',
                    level=40)    # level 设置级别. 当你的信息的级别>=level的时候才会写入日志文件, 默认30

# CRITICAL = 50
# FATAL = CRITICAL
# ERROR = 40
# WARNING = 30
# WARN = WARNING
# INFO = 20
# DEBUG = 10
# NOTSET = 0
# 写日志
# logging.critical("我是critical")
# logging.error("我是error")
# logging.warning("我是警告")
# logging.info("我是基本信息")
# logging.debug("我是调试")
# logging.log(2, "我是自定义")


import traceback
for i in range(20):
    try:
        if i % 3 == 0:
            raise FileNotFoundError("我是FileNotFountException")
        elif i % 3 == 1:
            raise StopIteration()
        elif i % 3 == 2:
            raise KeyError()

    except FileNotFoundError as e:
        val = traceback.format_exc()  # 获取堆栈信息
        logging.error(val)
    except StopIteration as e:
        val = traceback.format_exc()
        logging.error(val)
    except KeyError as e:
        val = traceback.format_exc()
        logging.error(val)
    except Exception as e:
        val = traceback.format_exc()
        logging.error(val)




多文件日志处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 创建⼀个操作⽇志的对象logger（依赖FileHandler）
file_handler = logging.FileHandler('l1.log', 'a', encoding='utf-8')
# 设置日志文件内容的格式
file_handler.setFormatter(logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s"))
logger1 = logging.Logger('A', level=40)
logger1.addHandler(file_handler)
# 记录日志
logger1.error('我是A系统')



# 再创建⼀个操作⽇志的对象logger（依赖FileHandler）
file_handler2 = logging.FileHandler('l2.log', 'a', encoding='utf-8')
file_handler2.setFormatter(logging.Formatter(fmt="%(asctime)s - %(name)s -%(levelname)s -%(module)s: %(message)s"))
logger2 = logging.Logger('B', level=40)
logger2.addHandler(file_handler2)
# 记录日志
logger2.error('我是B系统')


Python

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议 ，转载请注明出处！