Python全栈开发-Python基础教程-08 面向对象高级

面向对象高级

一. 常用内置函数

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） 是最简单的设计模式之一，属于创建型模式。它提供了一种创建对象的最佳方式。

单例模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

1. 单例类只能有一个实例。
2. 单例类必须自己创建自己的唯一实例。
3. 单例类必须给所有其他对象提供这一实例。
4. 每一次执行 类名() 返回的对象，内存地址是相同

优点：

1. 在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
2. 避免对资源的多重占用（比如写文件操作）。

缺点： 没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

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__() 方法的对象就是上下文管理器。

1. __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