面向对象高级
一. 常用内置函数
1.1 hasattr()函数
hasattr() 函数用来判断某个类实例对象是否包含指定名称的属性或方法。该函数的语法格式如下:
hasattr(obj, name)
其中 obj 指的是某个类的实例对象,name 表示指定的属性名或方法名。同时,该函数会将判断的结果(True 或者 False)作为返回值反馈回来。
程序示例:
class CLanguage:
def __init__ (self):
self.name = "百度"
self.add = "http://www.baidu.com"
def say(self):
print("我正在学Python")
clangs = CLanguage()
print(hasattr(clangs,"name"))
print(hasattr(clangs,"add"))
print(hasattr(clangs,"say"))
运行结果:
True
True
True
显然,无论是属性名还是方法名,都在 hasattr() 函数的匹配范围内。因此,我们只能通过该函数判断实例对象是否包含该名称的属性或方法,但不能精确判断,该名称代表的是属性还是方法。
1.2 getattr() 函数
getattr() 函数获取某个类实例对象中指定属性的值。没错,和 hasattr() 函数不同,该函数只会从类对象包含的所有属性中进行查找。getattr() 函数的语法格式如下:
getattr(obj, name[, default])
其中,obj 表示指定的类实例对象,name 表示指定的属性名,而 default 是可选参数,用于设定该函数的默认返回值,即当函数查找失败时,如果不指定 default 参数,则程序将直接报 AttributeError 错误,反之该函数将返回 default 指定的值。
程序示例:
class CLanguage:
def __init__ (self):
self.name = "百度"
self.add = "http://www.baidu.com"
def say(self):
print("我正在学Python")
clangs = CLanguage()
print(getattr(clangs,"name"))
print(getattr(clangs,"add"))
print(getattr(clangs,"say"))
print(getattr(clangs,"display",'nodisplay'))
运行结果:
百度
http://www.baidu.com
<bound method CLanguage.say of <__main__.CLanguage object at 0x000001B664F70400>>
nodisplay
可以看到,对于类中已有的属性,getattr() 会返回它们的值,而如果该名称为方法名,则返回该方法的状态信息;反之,如果该明白不为类对象所有,要么返回默认的参数,要么程序报 AttributeError 错误。
1.3 setattr()函数
setattr() 函数的功能相对比较复杂,它最基础的功能是修改类实例对象中的属性值。其次,它还可以实现为实例对象动态添加属性或者方法。
setattr() 函数的语法格式如下:
setattr(obj, name, value)
首先,下面例子演示如何通过该函数修改某个类实例对象的属性值:
class CLanguage:
def __init__ (self):
self.name = "百度"
self.add = "http://www.baidu.com"
def say(self):
print("我正在学Python")
clangs = CLanguage()
print(clangs.name)
print(clangs.add)
setattr(clangs,"name","Python教程")
setattr(clangs,"add","http://c.biancheng.net/python")
print(clangs.name)
print(clangs.add)
运行结果:
百度
http://www.baidu.com
Python教程
http://c.biancheng.net/python
甚至利用 setattr() 函数,还可以将类属性修改为一个类方法,同样也可以将类方法修改成一个类属性。例如:
def say(self):
print("我正在学Python")
class CLanguage:
def __init__ (self):
self.name = "百度"
self.add = "http://www.baidu.com"
clangs = CLanguage()
print(clangs.name)
print(clangs.add)
setattr(clangs,"name",say)
clangs.name(clangs)
运行结果为:
百度
http://www.baidu.com
我正在学Python
显然,通过修改 name 属性的值为 say(这是一个外部定义的函数),原来的 name 属性就变成了一个 name() 方法。
使用 setattr() 函数对实例对象中执行名称的属性或方法进行修改时,如果该名称查找失败,Python 解释器不会报错,而是会给该实例对象动态添加一个指定名称的属性或方法。例如:
def say(self):
print("我正在学Python")
class CLanguage:
pass
clangs = CLanguage()
setattr(clangs,"name","百度")
setattr(clangs,"say",say)
print(clangs.name)
clangs.say(clangs)
运行结果为:
百度
我正在学Python
可以看到,虽然 CLanguage 为空类,但通过 setattr() 函数,我们为 clangs 对象动态添加了一个 name 属性和一个 say() 方法。
1.4 属性访问的优化
例如,在下面这段代码中:
class Person:
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def run(self):
print(f'{self.name}今年{self.age}岁')
通过简单if判断就能避免属性不存在时,报错的问题,同时也可以设置属性值
if hasattr(xiaoyu,'name'):
a = getattr(xiaoyu,'name')
else:
setattr(xiaoyu,'name','xiangwang')
这个三目运算也可以保证a得到属性值
a = getattr(xiaoyu,'name') if hasattr(xiaoyu,'name') else setattr(xiaoyu,'name','xiaowang')
1.5 issubclass和isinstance函数:检查类型
Python 提供了如下两个函数来检查类型:
- issubclass(cls, class_or_tuple):检查 cls 是否为后一个类或元组包含的多个类中任意类的子类。
- isinstance(obj, class_or_tuple):检查 obj 是否为后一个类或元组包含的多个类中任意类的对象。
通过使用上面两个函数,程序可以方便地先执行检查,然后才调用方法,这样可以保证程序不会出现意外情况。
程序示例:
# 定义一个字符串
hello = "Hello";
# "Hello"是str类的实例,输出True
print('"Hello"是否是str类的实例: ', isinstance(hello, str))
# "Hello"是object类的子类的实例,输出True
print('"Hello"是否是object类的实例: ', isinstance(hello, object))
# str是object类的子类,输出True
print('str是否是object类的子类: ', issubclass(str, object))
# "Hello"不是tuple类及其子类的实例,输出False
print('"Hello"是否是tuple类的实例: ', isinstance(hello, tuple))
# str不是tuple类的子类,输出False
print('str是否是tuple类的子类: ', issubclass(str, tuple))
# 定义一个列表
my_list = [2, 4]
# [2, 4]是list类的实例,输出True
print('[2, 4]是否是list类的实例: ', isinstance(my_list, list))
# [2, 4]是object类的子类的实例,输出True
print('[2, 4]是否是object类及其子类的实例: ', isinstance(my_list, object))
# list是object类的子类,输出True
print('list是否是object类的子类: ', issubclass(list, object))
# [2, 4]不是tuple类及其子类的实例,输出False
print('[2, 4]是否是tuple类及其子类的实例: ', isinstance([2, 4], tuple))
# list不是tuple类的子类,输出False
print('list是否是tuple类的子类: ', issubclass(list, tuple))
运行结果:
"Hello"是否是str类的实例: True
"Hello"是否是object类的实例: True
str是否是object类的子类: True
"Hello"是否是tuple类的实例: False
str是否是tuple类的子类: False
[2, 4]是否是list类的实例: True
[2, 4]是否是object类及其子类的实例: True
list是否是object类的子类: True
[2, 4]是否是tuple类及其子类的实例: False
list是否是tuple类的子类: False
通过上面程序可以看出,issubclass() 和 isinstance() 两个函数的用法差不多,区别只是 issubclass() 的第一个参数是类名,而 isinstance() 的第一个参数是变量,这也与两个函数的意义对应:issubclass 用于判断是否为子类,而 isinstance() 用于判断是否为该类或子类的实例。
issubclass() 和 isinstance() 两个函数的第二个参数都可使用元组。例如如下代码:
data = (20, 'fkit')
print('data是否为列表或元组: ', isinstance(data, (list, tuple))) # True
# str不是list或者tuple的子类,输出False
print('str是否为list或tuple的子类: ', issubclass(str, (list, tuple)))
# str是list或tuple或object的子类,输出True
print('str是否为list或tuple或object的子类 ', issubclass(str, (list, tuple, object)))
运行结果:
data是否为列表或元组: True
str是否为list或tuple的子类: False
str是否为list或tuple或object的子类 True
此外,Python 为所有类都提供了一个 bases 属性,通过该属性可以查看该类的所有直接父类,该属性返回所有直接父类组成的元组。例如如下代码:
class A:
pass
class B:
pass
class C(A, B):
pass
print('类A的所有父类:', A.__bases__)
print('类B的所有父类:', B.__bases__)
print('类C的所有父类:', C.__bases__)
运行结果为:
类A的所有父类: (<class 'object'>,)
类B的所有父类: (<class 'object'>,)
类C的所有父类: (<class '__main__.A'>, <class '__main__.B'>)
从上面的运行结果可以看出,如果在定义类时没有显式指定它的父类,则这些类默认的父类是 object 类。
Python 还为所有类都提供了一个 subclasses() 方法,通过该方法可以查看该类的所有直接子类,该方法返回该类的所有子类组成的列表。例如在上面程序中增加如下两行:
print('类A的所有子类:', A.__subclasses__())
print('类B的所有子类:', B.__subclasses__())
运行结果为:
类A的所有子类: [<class '__main__.C'>]
类B的所有子类: [<class '__main__.C'>]
二. 属性调用过程
学到现在已经接触了很多的内置方法,那么这么多方法,Python底层是如何去实现的呢?
程序示例:
class Person:
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def run(self):
print(f'{self.name}今年{self.age}岁')
kk = Person('空空',21,'男')
print(kk.__getattribute__('name'))
kk.__setattr__('name','落落')
print(kk.__getattribute__('name'))
kk.__delattr__('name')
print(kk.__getattribute__('name'))
运行结果:
空空
落落
Traceback (most recent call last):
File "C:\Users\admin\Desktop\new.py", line 14, in <module>
print(kk.__getattribute__('name'))
AttributeError: 'Person' object has no attribute 'name'
这里调用了一些内置的方法,也会同样的效果
这是因为那些函数本身就是调用的这些方法
上述的例子我们看下如下这个
print(kk.size)
运行结果:
Traceback (most recent call last):
File "<pyshell#7>", line 1, in <module>
print(kk.size)
AttributeError: 'Person' object has no attribute 'size'
当我们在代码中修改为如下代码
class Person:
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def run(self):
print(f'{self.name}今年{self.age}岁')
def __getattr__(self,item):
print('no attribute')
kk = Person('空空',21,'男')
交互模式下运行如下:
>>> kk.size
no attribute
当实例调用一个不存在的属性的时候,会发生报错,
但是如果增加__getattr__方法,则不会报错,而是执行此方法内的内容
意思就是,当没有定义getattr的时候,系统他会自动调用__getattribute__这个隐藏的内置函数如判断有没有,有的话就返回,没得话就报错(这个是你没有自定义这个内置函数时候的功能),当你自定义以后,你要他输出什么他就输出什么切记自定义的函数名为__getattr__,如果你自定义的是__getattribute__这个函数那么你无论输入什么都是自己定义的输出
三. 魔术方法
3.1 魔术方法简介
在Python中,所有以“__”双下划线包起来的方法,都统称为“Magic Method”,中文称『魔术方法』,例如类的初始化方法 init ,Python中所有的魔术方法均在官方文档中有相应描述,但是对于官方的描述比较混乱而且组织比较松散。很难找到有一个例子。
3.2 常用魔术方法
3.2.1 __new__方法
实例化魔术方法
触发时机: 在实例化对时触发
参数:至少一个cls接收当前类
返回值:必须返回一个对象实例
作用:实例化对象
注意:实例化对象是Object类底层实现,其他类继承了Object的__new__才能够实现实例化对象。
没事别碰这个魔术方法,先触发__new__才会触发__init__
程序示例:
class Person(object):
# 初始化
def __init__(self):
print('init...')
# 实例化方法(构造方法)---》创建对象
def __new__(cls, *args, **kwargs):
print('new...')
ret = super().__new__(cls) # 调用父类的__new__()方法创建对象,并用接收返回值
return ret # 将对象返回给person
person = Person()
print(person)
运行结果为:
new...
init...
<__main__.Person object at 0x0000023B9C1B8580>
如上代码所示,要先创建一个对象,才能初始化,所以输出是先输出new…,才输出init…
3.2.2 __call__方法
call():可以让类的实例具有类似于函数的行为,
进一步模糊了函数和对象之间的概念。
使用方式:对象后面加括号,触发执行。即:对象() 或者 类()()
程序示例:
class Person(object):
def __call__(self, *args, **kwargs):
print('call...')
person = Person() # 将Person()的内存地址赋值给person
person() # 内存地址()
#或者是Person()()
运行结果为:
call...
如上代码所示,调用__call__时,并不需要person.call。因为在person=Person()时,就已经将Person()的内存地址赋值给了person,所以后面调用时person本身就代表了那个内存地址,当成函数使用person()
3.2.3 __del__方法
del 方法,功能正好和 init() 相反,其用来销毁实例化对象。
事实上在编写程序时,如果之前创建的类实例化对象后续不再使用,最好在适当位置手动将其销毁,释放其占用的内存空间(整个过程称为垃圾回收(简称GC))。
大多数情况下,Python 开发者不需要手动进行垃圾回收,因为 Python 有自动的垃圾回收机制,能自动将不需要使用的实例对象进行销毁。
程序示例:
class CLanguage:
def __init__(self):
print("调用 __init__() 方法构造对象")
def __del__(self):
print("调用__del__() 销毁对象,释放其空间")
clangs = CLanguage()
del clangs
运行结果为:
调用 __init__() 方法构造对象
调用__del__() 销毁对象,释放其空间
但是,千万不要误认为,只要为该实例对象调用 del() 方法,该对象所占用的内存空间就会被释放。举个例子:
class CLanguage:
def __init__(self):
print("调用 __init__() 方法构造对象")
def __del__(self):
print("调用__del__() 销毁对象,释放其空间")
clangs = CLanguage()
#添加一个引用clangs对象的实例对象
cl = clangs
del clangs
print("***********")
运行结果为:
调用 __init__() 方法构造对象
***********
调用__del__() 销毁对象,释放其空间
注意,最后一行输出信息,是程序执行即将结束时调用 del() 方法输出的。
可以看到,当程序中有其它变量(比如这里的 cl)引用该实例对象时,即便手动调用 del() 方法,该方法也不会立即执行。这和 Python 的垃圾回收机制的实现有关。
3.2.4 __str__方法
触发时机:使用print(对象)或者str(对象)的时候触发
参数:一个self接收对象
返回值:必须是字符串类型
作用:print(对象时)进行操作,得到字符串,通常用于快捷操作
程序示例:
class Cat(object):
def __str__(self):
return '这是一只猫'
cat=Cat()
print(cat)
运行结果:
这是一只猫
在python中 使用print()函数输出对象名称的时候默认情况下,会打印
对象名引用的内存地址,如果希望打印对象的属性值,可以使用__str__(self)
这个方法
3.2.5 __repr__方法
repr():改变对象的字符串显示
此方法是str()的备胎,如果找不到__str__()就会找__repr__()方法。
%r 默认调用的是 repr()方法,如果是字符串会默认加上 ‘’
repr()方法默认调用__repr__()方法
程序示例:
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
# def __str__(self):
# msg = 'name:%s,age:%s' % (self.name, self.age)
# return msg
# 如果没有__str__的时候,就会执行__repr__方法
# 如果有就不执行__repr__方法。
def __repr__(self):
msg = 'name: %s,age: %s' % (self.name, self.age)
return msg
person = Person('kk', 21)
print(person)
运行结果:
name: kk,age: 21
如果是使用%r作为输出,那么调用的就是__repr__方法
程序示例:
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
msg = 'name:%s,age:%s' % (self.name, self.age)
return msg
# 如果没有__str__的时候,就会执行__repr__方法
# 如果有就不执行__repr__方法。
def __repr__(self):
msg = 'name->%s,age->%s' % (self.name, self.age)
return msg
person = Person('kk',21)
print('%s' % person)
print('%r' % person)
运行结果:
name:kk,age:21
name->kk,age->21
或者使用print(repr(person))
print(repr(person))
运行结果为:
name->kk,age->21
更多魔术方法介绍请参考:python魔术方法详解
四. 单例模式
4.1 单例模式的概念
单例模式(Singleton Pattern) 是最简单的设计模式之一,属于创建型模式。它提供了一种创建对象的最佳方式。
单例模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。
注意:
- 单例类只能有一个实例。
- 单例类必须自己创建自己的唯一实例。
- 单例类必须给所有其他对象提供这一实例。
- 每一次执行 类名() 返回的对象,内存地址是相同
优点:
- 在内存里只有一个实例,减少了内存的开销,尤其是频繁的创建和销毁实例(比如管理学院首页页面缓存)。
- 避免对资源的多重占用(比如写文件操作)。
缺点: 没有接口,不能继承,与单一职责原则冲突,一个类应该只关心内部逻辑,而不关心外面怎么样来实例化。
4.2 实现的核心原理
重写类方法中的__new__方法
使用 类名() 创建对象时,Python 的解释器 首先 会 调用 new 方法为对象 分配空间
new 是一个 由 object 基类提供的 内置的静态方法,主要作用有两个:
- 1.在内存中为对象 分配空间
- 2.返回 对象的引用
Python 的解释器获得对象的 引用 后,将引用作为 第一个参数,传递给 init 方法
重写 new 方法 的代码非常固定!
- 重写 new 方法 一定要 return super().new(cls)
- 否则 Python 的解释器 得不到 分配了空间的 对象引用,就不会调用对象的初始化方法
- 注意:new 是一个静态方法,在调用时需要 主动传递 cls 参数
4.2 单例模式的实现方式
4.2.1 __new__方法实现(推荐使用,方便)
我们知道,当我们实例化一个对象时,是先执行了类的__new__方法(我们没写时,默认调用object new ),实例化对象;然后再执行类的__init__方法,对这个对象进行初始化,所有我们可以基于这个,实现单例模式
class Singleton(object):
def __new__(cls, *args, **kwargs):
if not hasattr(cls, '_instance'):
orig = super(Singleton, cls)
cls._instance = orig.__new__(cls, *args, **kwargs)
return cls._instance
class MyClass(Singleton):
a = 1
one = MyClass()
two = MyClass()
#one和two完全相同,可以用id(), ==, is检测
print(id(one))
print(id(two))
print(one == two)
print(one is two)
运行结果为:
2173598467936
2173598467936
True
True
4.2.2 使用模块
Python 的模块就是天然的单例模式,因为模块在第一次导入时,会生成 .pyc 文件,当第二次导入时,就会直接加载.pyc 文件,而不会再次执行模块代码。因此,我们只需把相关的函数和数据定义在一个模块中,就可以获得一个单例对象了。如果我们真的想要一个单例类,可以考虑这样做:
# mysingleton.py
class Singleton(object):
def foo(self):
pass
singleton = Singleton()
将上面的代码保存在文件 mysingleton.py 中,要使用时,直接在其他文件中导入此文件中的对象,这个对象即是单例模式的对象
from a import singleton
4.2.3 使用装饰器
def Singleton(cls):
_instance = {}
def _singleton(*args, **kargs):
if cls not in _instance:
_instance[cls] = cls(*args, **kargs)
return _instance[cls]
return _singleton
@Singleton
class Test(object):
t = 1
def __init__(self, x=0):
self.x = x
t1 = Test(2)
t2 = Test(3)
五. 协议
5.1 序列协议
序列协议即定义:len、getitem、setitem、__delitem__等协议,如果不需要改变,那后两个就不要定义
Python中很多的协议,比如序列协议等很多协议,只要遵守这些协议,既可以说是对应的类型,比如定义了序列类型协议,则定义的类就是序列类型
class IndexTuple:
def __init__(self,*args):
self.values = tuple([x for x in args])
self.index = tuple(enumerate(self.values))
def __len__(self):
return len(self.values)
def __getitem__(self,key):
return self.index[key]
def __repr_(self):
return str(self.values)
a = IndexTuple(1,'a',52,'py',9)
print(a.values)
print(a.index)
print(a[1])
运行结果:
(1, 'a', 52, 'py', 9)
((0, 1), (1, 'a'), (2, 52), (3, 'py'), (4, 9))
(1, 'a')
5.2 迭代器协议
迭代器协议指的是容器类需要包含一个特殊方法,这个特殊方法就是 __iter__()
方法。
如果一个容器类提供了 __iter__()
方法,并且该方法能返回一个能够逐个访问容器内所有元素的迭代器,则我们说该容器类实现了迭代器协议。
迭代器与for循环
Python 处理 for 循环时,首先会调用 something.__iter__()
,返回 something 对应的迭代器(假设叫 it);而后,for 循环会调用 it.__next__()
,获取迭代器的下一个元素,并赋值给 x,然后执行循环体;执行完后,for 循环会继续调用it.__next__()
,获取迭代器的下一个元素,并赋值给 x,执行循环体 …… 当 for 循环调用 it.__next__()
产生 StopIteration 异常时,循环结束。
程序示例:
a_list = [1,2,3,4]
it = a_list.__iter__() # 获取迭代器
print(it.__next__()) # 让迭代器返回下一个值
print(it.__next__())
print(it.__next__())
print(it.__next__())
print(it.__next__()) # 迭代器没有可供返回的值,引发 StopIteration 异常
运行结果:
1
2
3
4
Traceback (most recent call last):
File "C:\Users\admin\Desktop\new.py", line 7, in <module>
print(it.__next__()) # 迭代器没有可供返回的值,引发 StopIteration 异常
StopIteration
下面在看一个迭代器例子:
class Number:
def __init__(self,end=10):
self.start = 0
self.end = end
def __iter__(self):
return self
def __next__(self):
self.start += 1
if self.start >= self.end:
raise StopIteration
return self.start
nu = Number()
print(next(nu))
print(next(nu))
print(next(nu))
print(iter(nu))
运行结果:
1
2
3
<__main__.Number object at 0x000001DAD88FF400>
只要类实现了__iter__和__next__方法,则这个类就是迭代器,因此只要实现这两个方法,则是可以迭代对象
5.2 上下文协议
简单的理解,同时包含__enter__()
和__exit__()
方法的对象就是上下文管理器。
__enter__(self)
:进入上下文管理器自动调用的方法,该方法会在 with as 代码块执行之前执行。如果 with 语句有 as子句,那么该方法的返回值会被赋值给 as 子句后的变量;该方法可以返回多个值,因此在 as 子句后面也可以指定多个变量(多个变量必须由“()”括起来组成元组)。
2.__exit__(self, exc_type, exc_value, exc_traceback)
:退出上下文管理器自动调用的方法。该方法会在 with as 代码块执行之后执行。如果 with as 代码块成功执行结束,程序自动调用该方法,调用该方法的三个参数都为 None:如果 with as 代码块因为异常而中止,程序也自动调用该方法,使用 sys.exc_info 得到的异常信息将作为调用该方法的参数。
当 with as 操作上下文管理器时,就会在执行语句体之前,先执行上下文管理器的 __enter__()
方法,然后再执行语句体,最后执行 __exit__()
方法。
下面我们自定义一个实现上下文管理协议的类,并尝试用 with as 语句来管理它:
class FkResource:
def __init__(self, tag):
self.tag = tag
print('构造器,初始化资源: %s' % tag)
# 定义__enter__方法,with体之前的执行的方法
def __enter__(self):
print('[__enter__ %s]: ' % self.tag)
# 该返回值将作为as子句中变量的值
return 'fkit' # 可以返回任意类型的值
# 定义__exit__方法,with体之后的执行的方法
def __exit__(self, exc_type, exc_value, exc_traceback):
print('[__exit__ %s]: ' % self.tag)
# exc_traceback为None,代表没有异常
if exc_traceback is None:
print('没有异常时关闭资源')
else:
print('遇到异常时关闭资源')
return False # 可以省略,默认返回None也被看做是False
with FkResource('孙悟空') as dr:
print(dr)
print('[with代码块] 没有异常')
print('------------------------------')
with FkResource('白骨精'):
print('[with代码块] 异常之前的代码')
raise Exception
print('[with代码块] ~~~~~~~~异常之后的代码')
运行结果为:
构造器,初始化资源: 孙悟空
[__enter__ 孙悟空]:
fkit
[with代码块] 没有异常
[__exit__ 孙悟空]:
没有异常时关闭资源
------------------------------
构造器,初始化资源: 白骨精
[__enter__ 白骨精]:
[with代码块] 异常之前的代码
[__exit__ 白骨精]:
遇到异常时关闭资源
Traceback (most recent call last):
File "C:\Users\admin\Desktop\new.py", line 25, in <module>
raise Exception
Exception
上面程序定义了一个 FkResource 类,并包含了__enter__()
和__exit__()
两个方法,因此该类的对象可以被 with as 语句管理。
此外,程序中两次使用 with as 语句管理 FkResource 对象。第一次代码块没有出现异常,第二次代码块出现了异常。从上面的输出结果来看,使用 with as 语句管理资源,无论代码块是否有异常,程序总可以自动执行 __exit__()
方法。
注意,当出现异常时,如果
__exit__
返回 False(默认不写返回值时,即为 False),则会重新抛出异常,让 with as 之外的语句逻辑来处理异常;反之,如果返回 True,则忽略异常,不再对异常进行处理。
六. 作业
本节作业
1、测试列表推导和不用列表推导哪一种速度更快
2、range不可以使用小数做步长,实现一个可迭代对象,可以实现小数步长
上节答案
1、定义一个账户类,可以创建账户、存款、取款 、查询余额、以及销户等操作
2、现在三个人分别去开户,存款 和 销户,请利用上面的类实现出来
提示:账户必备要素:1、账户名 2、密码 3、余额
class Bank():
#一个属于银行的类
_Users = {}
#每个对象拥有卡号,密码,用户名,余额
def __init__(self,CardId,pwd,name,balance):
if CardId not in Bank._Users:
Bank._Users[CardId] = {'pwd':pwd,'Username':name,'Balance':balance}
self._CardId = CardId
self._pwd = pwd
self._name = name
self.balance = balance
#查看本银行的开户总数
def nums(cls):
print('当前用户数:%d'%(len(cls._Users)))
#查看所有用户个人信息(卡号,密码,用户名,余额)
def get_Users(cls):
for key,val in cls._Users.items():
print('卡号: %s \n用户名: %s \n密码: %d \n余额: %d'%(key,val['Username'],val['pwd'],val['Balance']))
print()
#验证方法
def check_User(CardId,pwd):
if (CardId in Bank._Users) and (pwd == Bank._Users[CardId]['pwd']):
return True
else:
return False
#验证金额
def check_money(money):
if isinstance(money,int):
return True
else:
return False
#取钱(需要验证卡号和密码)
def q_money(self,CardId,pwd,money):
if Bank.check_User(CardId,pwd):
#开始取钱
if Bank.check_money(money):
if Bank._Users[CardId]['Balance'] >= money:
Bank._Users[CardId]['Balance'] -= money
print('当前卡号%s,当前取款金额%d,当前余额%d'%(CardId,money,Bank._Users[CardId]['Balance']))
else:
print('余额不足')
else:
print('您输入的金额有误')
else:
print('卡号或者密码有误')
#存钱(需要验证卡号和密码)
def c_money(self,CardId,pwd,money):
if Bank.check_User(CardId,pwd):
#开始存钱
if Bank.check_money(money):
Bank._Users[CardId]['Balance'] += money
print('当前卡号%s,当前取款金额%d,当前余额%d'%(CardId,money,Bank._Users[CardId]['Balance']))
else:
print('您输入的金额有误')
else:
print('卡号或者密码有误')
#查看个人信息(需要验证卡号和密码)
def getInfo(self,CardId,pwd):
if Bank.check_User(CardId,pwd):
print('当前卡号%s,当前用户名%s,当前余额%d'%(CardId,Bank._Users[CardId]['Username'],Bank._Users[CardId]['Balance']))
else:
print('卡号或者密码有误')
Tom = Bank('1001',111111,'Tom',100)
Tom2 = Bank('1001',111111,'Tom',100)
Bank.nums(Tom)
print('_'*50)
Bank.get_Users(Tom)
print('_'*50)
Tom.c_money('1001',111111,500)
print('_'*50)
Tom.q_money('1001',111111,300)
print('_'*50)
Tom.getInfo('1001',111111)
运行结果为:
当前用户数:1
__________________________________________________
卡号: 1001
用户名: Tom
密码: 111111
余额: 100
__________________________________________________
当前卡号1001,当前取款金额500,当前余额600
__________________________________________________
当前卡号1001,当前取款金额300,当前余额300
__________________________________________________
当前卡号1001,当前用户名Tom,当前余额300