一 、约束

python中约束有两种

第一种,通过抛异常进行约束,这种是子类不按我要求的来,我就给你抛异常(推荐)

操作:提取一个父类. 在父类中给出一个方法。但在方法中不给出任何代码,直接抛异常

# 贴吧
# 项目经理(级别高一点儿)
class Base:
def login(self): # 强制子类做xxxx事
raise NotImplementedError("子类没有实现该方法") # 报错. 抛异常

# 1. 普通账号 --> 翔哥
class Normal(Base):
def login(self):
print("普通账号的登录")

# 2. 吧务 - > 强哥
class Member(Base):
def login(self):
print("吧务的登录")

# 3. 百度员工 -> 明哥
class Admin(Base):
def denglu(self):
print("管理员的登录")

# 项目经理
def wodetian(obj):
obj.login()

n = Normal()
wodetian(n)

m = Member()
wodetian(m)

a = Admin()
wodetian(a) #这就会抛出异常,因为没按要求写,找不到login

异常约束

 1  # 贴吧
2 # 项目经理(级别高一点儿)
3 class Base:
4 def login(self): # 强制子类做xxxx事
5 raise NotImplementedError("子类没有实现该方法") # 报错. 抛异常
6
7 # 1. 普通账号 --> 翔哥
8 class Normal(Base):
9 def login(self):
10 print("普通账号的登录")
11
12 # 2. 吧务 - > 强哥
13 class Member(Base):
14 def login(self):
15 print("吧务的登录")
16
17 # 3. 百度员工 -> 明哥
18 class Admin(Base):
19 def denglu(self):
20 print("管理员的登录")
21
22 # 项目经理
23 def wodetian(obj):
24 obj.login()
25
26 n = Normal()
27 wodetian(n)
28
29 m = Member()
30 wodetian(m)
31
32 a = Admin()
33 wodetian(a) #这就会抛出异常,因为没按要求写,找不到login

第二种,通过抽象类和抽象方法进行约束,这种是子类不按我要求的来,我就不让子类实例化

操作:提取一个父类,将父类中给出的方法定义为抽象方法,不必实现,直接pass

### 这些概念要记住:

抽象类是不能进行实例化的

如果一个类中有抽象方法,那么这个类就是抽象类

一个抽象类可以有非抽象方法

from abc import ABCMeta, abstractmethod

class Base(metaclass=ABCMeta): # 抽象类
# 抽象方法
@abstractmethod
def login(self): # 强制子类做xxxx事,子类必须重写这个方法
pass

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

class Member(Base):
def login(self):
print("会员登录")

class Admin(Base):
def denglu(self):
print('管理员登录')

def denglu(obj):
obj.login()
n = Normal()
denglu(n)
m = Member()
denglu(m)
a = Admin() #Can't instantiate abstract class admin with abstract methods login
denglu(a)

抽象约束

 1 from abc import ABCMeta, abstractmethod
2
3 class Base(metaclass=ABCMeta): # 抽象类
4 # 抽象方法
5 @abstractmethod
6 def login(self): # 强制子类做xxxx事,子类必须重写这个方法
7 pass
8
9 class Normal(Base):
10 def login(self):
11 print("普通登录")
12
13 class Member(Base):
14 def login(self):
15 print("会员登录")
16
17 class Admin(Base):
18 def denglu(self):
19 print('管理员登录')
20
21 def denglu(obj):
22 obj.login()
23 n = Normal()
24 denglu(n)
25 m = Member()
26 denglu(m)
27 a = Admin() #Can't instantiate abstract class admin with abstract methods login
28 denglu(a)

二、异常处理

格式:

try:

  代码块

except  错误名 as 别名:

  出现该错误时做什么

except 错误名 as  别名:

  出现该错误时做什么

...

else:

  不出错时执行这里

finally:

  出不出错都执行这里

解读: 程序先执行操作, 然后如果出错了会走except中的代码. 如果不出错, 执行else中的代码. 不论出不出错. 最后都要执行finally中的语句. 一般我们用try...except就够了. 顶多加上finally. finally一般用来作为收尾工作。

def cul(a,b):
if (type(a)== int or type(a) == float) and (type(b)== int or type(b)== float):
return a+b
else:
raise Exception("我要的是数字,你输入的是啥")

try:
print(cul("一",4))
except Exception as e:
print("错了,你要输入数字")

异常处理

 1 def cul(a,b):
2 if (type(a)== int or type(a) == float) and (type(b)== int or type(b)== float):
3 return a+b
4 else:
5 raise Exception("我要的是数字,你输入的是啥")
6
7 try:
8 print(cul("一",4))
9 except Exception as e:
10 print("错了,你要输入数字")

##抛异常

抛异常要用到关键字raise

def add(a, b):
'''
给我传递两个整数. 我帮你计算两个数的和
:param :param a:
:param :param b:
:return :return:
'''
if not type(a) == int and not type(b) == int:
# 当程序运行到这句话的时候. 整个函数的调用会被中断. 并向外抛出一个异常.
raise Exception("不是整数, 朕不能帮你搞定这么复杂的运算.")
return a + b
# 如果调用方不处理异常. 那产生的错误将会继续向外抛. 最后就抛给了用户
add("你好", "我叫赛利亚")
# 如果调用方处理了异常. 那么错误就不会丢给用户. 程序也能正常进行
try:
add("胡辣汤", "滋滋冒油的大腰子")
except Exception as e:
print("报错了. 我要的是数字")

raise

 1 def add(a, b):
2 '''
3 给我传递两个整数. 我帮你计算两个数的和
4 :param :param a:
5 :param :param b:
6 :return :return:
7 '''
8 if not type(a) == int and not type(b) == int:
9 # 当程序运行到这句话的时候. 整个函数的调用会被中断. 并向外抛出一个异常.
10 raise Exception("不是整数, 朕不能帮你搞定这么复杂的运算.")
11 return a + b
12 # 如果调用方不处理异常. 那产生的错误将会继续向外抛. 最后就抛给了用户
13 add("你好", "我叫赛利亚")
14 # 如果调用方处理了异常. 那么错误就不会丢给用户. 程序也能正常进行
15 try:
16 add("胡辣汤", "滋滋冒油的大腰子")
17 except Exception as e:
18 print("报错了. 我要的是数字")

##自定义异常

非常简单. 只要你的类继承了Exception类. 那你的类就是一个异常类

格式:

def  异常名(Exception):

  pass

#自定义异常
class GenderException(Exception):
pass

class Person:

def __init__(self,name,gender):
self.name = name
self.gender = gender

def goto_nan(self):
if self.gender !="男":
raise GenderException("性别不对")
else:
print("欢迎光临")
try:
p1 = Person('alex', '男')
p1.goto_nan()

p2 = Person('妖姬', '女')
p2.goto_nan()

except GenderException as e:
print("你来错地儿了")
except Exception as e:
print("其他错误")

自定义异常

 1 #自定义异常
2 class GenderException(Exception):
3 pass
4
5 class Person:
6
7 def __init__(self,name,gender):
8 self.name = name
9 self.gender = gender
10
11 def goto_nan(self):
12 if self.gender !="男":
13 raise GenderException("性别不对")
14 else:
15 print("欢迎光临")
16 try:
17 p1 = Person('alex', '男')
18 p1.goto_nan()
19
20 p2 = Person('妖姬', '女')
21 p2.goto_nan()
22
23 except GenderException as e:
24 print("你来错地儿了")
25 except Exception as e:
26 print("其他错误")

##异常处理好是好,但是有一个问题,我们在调试的时候是希望看到程序哪里出现问题的,而异常处理没有具体的错误信息,那这么办呢?这时需要引入另一个模块traceback. 这个模块可以获取到我们每个方法的调用信息. 又被称为堆栈信息. 这个信息对我们排错是很有帮助的.

import traceback

# 继承Exception. 那这个类就是一个异常类 自定义异常
class GenderError(Exception):
pass
class Person:
def __init__(self, name, gender):
self.name = name
self.gender = gender

def nan_zao_tang_xi_zao(person):
if person.gender != "男":
raise GenderError("性别不对. 这里是男澡堂子")

p1 = Person("alex", "男")
p2 = Person("eggon", "蛋")
# nan_zao_tang_xi_zao(p1)
# nan_zao_tang_xi_zao(p2) # 报错. 会抛出一个异常: GenderError

# 处理异常
try:
nan_zao_tang_xi_zao(p1)
nan_zao_tang_xi_zao(p2)
except GenderError as e:
val = traceback.format_exc() # 获取到堆栈信息
print(e) # 性别不对. 这里是男澡堂子
print(val)
except Exception as e:
print("反正报错了")
结果:
性别不对. 这里是男澡堂子
Traceback (most recent call last):
File "/Users/sylar/PycharmProjects/oldboy/面向对象/day05.py", line 155, in
<module>
nan_zao_tang_xi_zao(p2)
File "/Users/sylar/PycharmProjects/oldboy/面向对象/day05.py", line 144, in
nan_zao_tang_xi_zao
raise GenderError("性别不对. 这里是男澡堂子")
GenderError: 性别不对. 这里是男澡堂子

 1 import traceback
2
3 # 继承Exception. 那这个类就是一个异常类 自定义异常
4 class GenderError(Exception):
5 pass
6 class Person:
7 def __init__(self, name, gender):
8 self.name = name
9 self.gender = gender
10
11 def nan_zao_tang_xi_zao(person):
12 if person.gender != "男":
13 raise GenderError("性别不对. 这里是男澡堂子")
14
15 p1 = Person("alex", "男")
16 p2 = Person("eggon", "蛋")
17 # nan_zao_tang_xi_zao(p1)
18 # nan_zao_tang_xi_zao(p2) # 报错. 会抛出一个异常: GenderError
19
20 # 处理异常
21 try:
22 nan_zao_tang_xi_zao(p1)
23 nan_zao_tang_xi_zao(p2)
24 except GenderError as e:
25 val = traceback.format_exc() # 获取到堆栈信息
26 print(e) # 性别不对. 这里是男澡堂子
27 print(val)
28 except Exception as e:
29 print("反正报错了")
30 结果:
31 性别不对. 这里是男澡堂子
32 Traceback (most recent call last):
33 File "/Users/sylar/PycharmProjects/oldboy/面向对象/day05.py", line 155, in
34 <module>
35 nan_zao_tang_xi_zao(p2)
36 File "/Users/sylar/PycharmProjects/oldboy/面向对象/day05.py", line 144, in
37 nan_zao_tang_xi_zao
38 raise GenderError("性别不对. 这里是男澡堂子")
39 GenderError: 性别不对. 这里是男澡堂子

这样我们就能收放放如了. 当测试代码的时候把堆栈信息打印出来. 但是当到了 线上的生产环境的时候把这个堆栈去掉即可

三、日志(不用记,知道怎么用就行)

当出现任何错误的时候. 我们都可以去日志系统里去查. 看哪里出了问题. 这样在解决问题和bug的时候就多了一个帮手。

那如何在python中创建这个日志系统呢?

1. 导入logging模块.

2. 简单配置一下logging

3. 出现异常的时候(except). 向日志里写错误信息.

 1 #参数解释
2 # filename: 文件名
3 # format: 数据的格式化输出. 最终在日志文件中的样子
4 # 时间-名称-级别-模块: 错误信息
5 # datefmt: 时间的格式
6 # level: 错误的级别权重, 当错误的级别权重大于等于leval的时候才会写入文件
7
8 import logging #导入模块
9 #简单配置,一般只需修改level值
10 logging.basicConfig(filename='x1.txt',
11 format='%(asctime)s - %(name)s - %(levelname)s -%
12 (module)s: %(message)s',
13 datefmt='%Y-%m-%d %H:%M:%S',
14 level=0) # 当前配置表示 0以上的分数会被写入文件
15 # CRITICAL = 50
16 # FATAL = CRITICAL
17 # ERROR = 40
18 # WARNING = 30
19 # WARN = WARNING
20 # INFO = 20
21 # DEBUG = 10
22 # NOTSET = 0
23 logging.critical("我是critical") # 写入critical级别信息
24 logging.error("我是error") # 写入error级别信息
25 logging.warning("我是警告") # 警告
26 logging.info("我是基本信息") #
27 logging.debug("我是调试")
28 logging.log(2, "我是自定义") # 自定义. 第一个参数可以自己给值,第二个是往日志文件里写的内容

1 import logging
2
3 logging.basicConfig(filename='x1.log',
4 format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
5 datefmt='%Y-%m-%d %H:%M:%S',
6 level=35) # 当前配置表示 35以上的级别会被写入文件
7
8 import traceback
9 try:
10 print(1/0)
11 except Exception:
12 logging.error(traceback.format_exc()) # 写入error信息
13 logging.log(36, traceback.format_exc()) # 自定义写入
14 print("出错了")
15 结果:
16 x1.txt内容
17
18 2018-11-12 20:43:01 - root - ERROR -日志系统: Traceback (most recent call last):
19 File "D:/PyCharm/workspace/day019 约束/日志系统.py", line 29, in <module>
20 print(1/0)
21 ZeroDivisionError: division by zero
22
23 2018-11-12 20:43:01 - root - Level 36 -日志系统: Traceback (most recent call last):
24 File "D:/PyCharm/workspace/day019 约束/日志系统.py", line 29, in <module>
25 print(1/0)
26 ZeroDivisionError: division by zero

日志应用

 1  1 import logging
2 2
3 3 logging.basicConfig(filename='x1.log',
4 4 format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
5 5 datefmt='%Y-%m-%d %H:%M:%S',
6 6 level=35) # 当前配置表示 35以上的级别会被写入文件
7 7
8 8 import traceback
9 9 try:
10 10 print(1/0)
11 11 except Exception:
12 12 logging.error(traceback.format_exc()) # 写入error信息
13 13 logging.log(36, traceback.format_exc()) # 自定义写入
14 14 print("出错了")
15 15 结果:
16 16 x1.txt内容
17 17
18 18 2018-11-12 20:43:01 - root - ERROR -日志系统: Traceback (most recent call last):
19 19 File "D:/PyCharm/workspace/day019 约束/日志系统.py", line 29, in <module>
20 20 print(1/0)
21 21 ZeroDivisionError: division by zero
22 22
23 23 2018-11-12 20:43:01 - root - Level 36 -日志系统: Traceback (most recent call last):
24 24 File "D:/PyCharm/workspace/day019 约束/日志系统.py", line 29, in <module>
25 25 print(1/0)
26 26 ZeroDivisionError: division by zero

##

最后, 如果你系统中想要把日志文件分开. 比如. 有个大项目, 有两个子系统, 那两个子系 统要分开记录日志. 方便调试. 那怎么办呢? 注意. 用上面的basicConfig是搞不定的. 我们要借助文件助手(FileHandler), 来帮我们完成日志的分开记录

import logging

# 创建一个操作日志的对象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=logging.ERROR) #级别
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=logging.ERROR) #级别
logger2.addHandler(file_handler2)
logger2.error('我是B系统') #写入日志信息

日志分开

 1 import logging
2
3 # 创建一个操作日志的对象logger(依赖FileHandler)
4 file_handler = logging.FileHandler('l1.log', 'a', encoding='utf-8')
5 file_handler.setFormatter(logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s"))
6
7 logger1 = logging.Logger('a系统', level=logging.ERROR) #级别
8 logger1.addHandler(file_handler) #把文件助手和日志对象绑定
9 logger1.error('我是A系统') #写入日志信息
10
11 # 再创建一个操作日志的对象logger(依赖FileHandler)
12 file_handler2 = logging.FileHandler('l2.log', 'a', encoding='utf-8')
13 file_handler2.setFormatter(logging.Formatter(fmt="%(asctime)s - %(name)s -%(levelname)s -%(module)s: %(message)s"))
14
15 logger2 = logging.Logger('b系统', level=logging.ERROR) #级别
16 logger2.addHandler(file_handler2)
17 logger2.error('我是B系统') #写入日志信息
 

python学习13-类的约束 异常处理 日志的更多相关文章

  1. python记录_day019 类的约束 异常处理 日志

    一 .约束 python中约束有两种 第一种,通过抛异常进行约束,这种是子类不按我要求的来,我就给你抛异常(推荐) 操作:提取一个父类. 在父类中给出一个方法.但在方法中不给出任何代码,直接抛异常 # ...

  2. python之路--类的约束, 异常处理, MD5, 日志处理

    一 . 类的约束 1. 写一个父类,父类中的某个方法要抛出一个异常 NotImplementedError class Base: # 对子类进行了约束. 必须重写该方法 # 以后上班了. 拿到公司代 ...

  3. python学习13类2之封装

    '''''''''面向对象三大特性:封装,继承,多态1.封装: 类中以_或者__的属性,都是私有属性,禁止外部调用.'''class Student(object): def __init__(sel ...

  4. Python学习:类和实例

    Python学习:类和实例 本文作者: 玄魂工作室--热热的蚂蚁 类,在学习面向对象我们可以把类当成一种规范,这个思想就我个人的体会,感觉很重要,除了封装的功能外,类作为一种规范,我们自己可以定制的规 ...

  5. Python 入门 之 类的约束以及super()剖析

    Python 入门 之 类的约束以及super()剖析 1.类的约束 第一版: class WechatPay: def pay(self): print("微信支付") clas ...

  6. python基础学习笔记——类的约束

    ⾸先, 你要清楚. 约束是对类的约束. 用一个例子说话: 公司让小明给他们的网站完善一个支付功能,小明写了两个类,如下: class QQpay: def pay(self,money): print ...

  7. python摸爬滚打之day19----类的约束, 异常处理

    1.类的约束 父类对子类某些功能的约束. python 中的两种约束: 1, 提取父类, 然后在父类中定义好方法, 该方法什么都不用干, 就通过主动抛出异常 raise NotImplementedE ...

  8. python学习之正则表达式,StringIO模块,异常处理,搭建测试环境

    python正则表达式 引入一个强大的匹配功能来匹配字符串 import re 正则表达式的表示类型raw string类型(原生字符串类型) r'sa\\/sad/asd'用r转为raw strin ...

  9. Python学习笔记——类和对象

    类和对象 1. 一个例子 # 对象 = 属性 + 方法 # Python 中的类名称约定首字母大写,而 Python 函数名首字母小写 class Turtle: #属性 color = 'green ...

  10. python学习19类5之多态与鸭子模型

    '''''''''一.多态1.Python中多态是指一类事物有多种形态.''' class Animal: def run(self): raise AttributeError('子类必须实现这个方 ...

随机推荐

  1. 3.python 发送邮件之smtplib模块

    SMTP(Simple Mail Transfer Protocol)是简单邮件传输协议,它是一组用于由源地址到目的地址的邮件传输规则. python中对SMTP进行了简单的封装,可以发送纯文本邮件, ...

  2. js 二维数组排序sort()函数

    一.按数值排序 var arr = [[1, 2, 3], [7, 2, 3], [3, 2, 3]]; arr.sort(function(x, y){  return x[0] – y[0];}) ...

  3. Appium移动端自动化测试之应用操作详解(四)

    应用操作篇 1.1).安装应用 desired_caps = { 'platformName': 'Android', 'platformVersion': '5.0.0.0', 'deviceNam ...

  4. 什么是Condition Number(条件数)?

    In the field of numerical analysis, the condition number of a function with respect to an argument m ...

  5. Portal:Machine learning机器学习:门户

    Machine learning Machine learning is a scientific discipline that explores the construction and stud ...

  6. T-SQL查询进阶--SQL Server中的事务与锁

    为什么需要锁 在任何多用户的数据库中,必须有一套用于数据修改的一致的规则,当两个不同的进程试图同时修改同一份数据时,数据库管理系统(DBMS)负责解决它们之间潜在的冲突.任何关系数据库必须支持事务的A ...

  7. ARKit入门

    ARKit介绍 ARKit是iOS11引入的一个全新的框架,使用Visual Inertial Odometry(VIO,视觉惯性里程计)来精确跟踪现实世界中的真实场景.相比其它设备平台,ARKit中 ...

  8. 十六、Node.js-fs模块-流

    10. fs.createReadStream 从文件流中读取数据 /** * 之前我们学习过读取文件内容的方法readFile():该方法适合读取文件内容比较少的文件,如果遇到数据量庞大的文件,我们 ...

  9. WCF进阶(一)——概述

    前言 时间的朋友>里面几句特别有预见性的话来说明当今儿世界互联网发展趋势: 市场上有一种叫做"父爱算法"的需求.将会诞生很多伟大的公司.背后的精神就是六个字:你不用懂,听我的 ...

  10. 网页控件很多时最好用绝对定位absolute

    否则动一个位置可能影响其他的,牵一发而动全身