推荐|Python之with as用法详解

Python之with as用法详解

23-11-14 09:42

4068

5945

blog.csdn.net

Python之with as用法详解

文章目录

Python之with as用法详解

0任何一门编程语言中，文件的输入输出、数据库的连接断开等，都是很常见的资源管理操作。但资源都是有限的，在写程序时，必须保证这些资源在使用过后得到释放，不然就容易造成资源泄露，轻者使得系统处理缓慢，严重时会使系统崩溃。

例如，前面在介绍文件操作时，一直强调打开的文件最后一定要关闭，否则会程序的运行造成意想不到的隐患。但是，即便使用 close() 做好了关闭文件的操作，如果在打开文件或文件操作过程中抛出了异常，还是无法及时关闭文件。

为了更好地避免此类问题，不同的编程语言都引入了不同的机制。在 python 中，对应的解决方式是使用 with as 语句操作上下文管理器（context manager），它能够帮助我们自动分配并且释放资源。

简单的理解，同时包含 enter() 和 exit() 方法的对象就是上下文管理器。常见构建上下文管理器的方式有 2 种，分别是基于类实现和基于生成器实现。

with通过__enter__方法初始化，然后在__exit__中做善后以及处理异常。

所以使用with处理的对象必须有__enter__()和__exit__()这两个方法。

其中__enter__()方法在语句体（with语句包裹起来的代码块）执行之前进入运行，exit()方法在语句体执行完毕退出后运行。

with 语句适用于对资源进行访问的场合，确保不管使用过程中是否发生异常都会执行必要的“清理”操作，释放资源，比如文件使用后自动关闭、线程中锁的自动获取和释放等。使用 with as 操作已经打开的文件对象（本身就是上下文管理器），无论期间是否抛出异常，都能保证 with as 语句执行完毕后自动关闭已经打开的文件。

With语句的基本语法格式:

with expression [as target]：
代码块

参数说明：

expression：是一个需要执行的表达式；

target：是一个变量或者元组，存储的是expression表达式执行返回的结果，可选参数。

例如：

import os

def main():
	with open('123.txt') as fp:
		print(fp.read())
	input()

if __name__ == "__main__":
    main()
1
2
3
4
5
6
7
8
9

输出：

123.txt文本内容如下：

with语句的工作原理：

紧跟with后面的语句会被求值，返回对象的__enter__()方法被调用，这个方法的返回值将被赋值给as关键字后面的变量，当with后面的代码块全部被执行完之后，将调用前面返回对象的__exit__()方法。

with语句最关键的地方在于被求值对象必须有__enter__()和__exit__()这两个方法，那我们就可以通过自己实现这两方法来自定义with语句处理异常。

基于类实现上下文管理器：

#encoding=utf-8

import os

def main():
	with openx(r'123.txt') as fp:
		for line in fp.readlines():
			print(line)
	input()


class openx(object):
    def __init__(self,filename):
        self.handle=open(filename)
        print("Resource:%s"%filename)

    def __enter__(self):
        print("[enter%s]: Allocate resource."%self.handle)
        return self.handle   # 可以返回不同的对象

    def __exit__(self,exc_type,exc_value,exc_trackback):
        print("[Exit %s]: Free resource." %self.handle)
        if exc_trackback is None:
            print("[Exit %s]:Exited without exception."%self.handle)
            self.handle.close()
        else:
            print("[Exit %s]: Exited with exception raised."%self.handle)
        return False # 可以省略，缺省的None也是被看做是False


if __name__ == "__main__":
    main()
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

结果：

Resource:123.txt
[enter<_io.TextIOWrapper name='123.txt' mode='r' encoding='cp936'>]: Allocate resource.
111

222

333
[Exit <_io.TextIOWrapper name='123.txt' mode='r' encoding='cp936'>]: Free resource.
[Exit <_io.TextIOWrapper name='123.txt' mode='r' encoding='cp936'>]:Exited without exception.
1
2
3
4
5
6
7
8
9

opened中的__enter__() 返回的是自身的引用，这个引用可以赋值给 as 子句中的fp变量；

返回值的类型可以根据实际需要设置为不同的类型，不必是上下文管理器对象本身。

exit() 方法中对变量exc_trackback进行检测，如果不为 None，表示发生了异常，返回 False 表示需要由外部代码逻辑对异常进行处理；

如果没有发生异常，缺省的返回值为 None，在布尔环境中也是被看做 False，但是由于没有异常发生，exit() 的三个参数都为 None，上下文管理代码可以检测这种情况，做正常处理。exit()方法的3个参数，分别代表异常的类型、值、以及堆栈信息。

基于生成器的上下文管理器

除了基于类的上下文管理器，它还可以基于生成器实现。接下来先看一个例子。比如，我们可以使用装饰器 contextlib.contextmanager，来定义自己所需的基于生成器的上下文管理器，用以支持 with as 语句：

from contextlib import contextmanager

@contextmanager
def file_manager(name, mode):
    try:
        f = open(name, mode)
        yield f
    finally:
        f.close()

with file_manager('a.txt', 'w') as f:
    f.write('hello world')
1
2
3
4
5
6
7
8
9
10
11
12

这段代码中，函数 file_manager() 就是一个生成器，当我们执行 with as 语句时，便会打开文件，并返回文件对象 f；当 with 语句执行完后，finally 中的关闭文件操作便会执行。另外可以看到，使用基于生成器的上下文管理器时，不再用定义 enter() 和 exit() 方法，但需要加上装饰器 @contextmanager，这一点新手很容易疏忽。

需要强调的是，基于类的上下文管理器和基于生成器的上下文管理器，这两者在功能上是一致的。只不过，基于类的上下文管理器更加灵活，适用于大型的系统开发，而基于生成器的上下文管理器更加方便、简洁，适用于中小型程序。但是，无论使用哪一种，不用忘记在方法“exit()”或者是 finally 块中释放资源，这一点尤其重要。

《AUTOSAR谱系分解(ETAS工具链)》之总目录

id="article_content" class="article_content clearfix"> id="content_views" class="markdown_views prism-atom-one-light">

【C++笔记】AVL树的深度剖析

🔥个人主页：大白的编程日记

🔥专栏：C++笔记

class="toc">

文章目录

【C++笔记】AVL树的深度剖析

这里我们为了旋转时需要用到父亲节点，所以我们就是一个三叉链的结构。
同时我们引入了平衡因子，方便我们控制高度差。

template<class k, class v> struct AVLNode { using node = AVLNode<k, v>; k _key; v _value; node* left;//左节点 node* right;//右节点 node* parent;//父亲节点 int bf;//平衡因子 AVLNode(const k& key, const v& value) :_key(key) , _value(value) , left(nullptr) , right(nullptr) ,parent(nullptr) ,bf(0) {} }; template<class k, class v> class AVLTree { using node = AVLNode<k, v>; private: node* _root = nullptr; }; class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

void RoRateL( node* parent)//左单旋 { node* subR = parent->right; node* subRL = subR->left; node* pparnet = parent->parent; parent->right = subRL; if (subRL)//防止subRL为空 { subRL->parent = parent;//修改父节点 } subR->left = parent; parent->parent = subR; if (pparnet==nullptr)//parent就是根节点 { _root = subR; subR->parent = nullptr; } else { if (pparnet->left == parent)//确定parent节点是左还是右 { pparnet->left = subR; } else { pparnet->right = subR; } subR->parent = pparnet;//修改父节点 } subR->bf = parent->bf = 0;//更新平衡因子 } class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

void RoRateLR( node* parent)//左右双旋 { node* subL = parent->left; node* subLR = subL->right; int bf = subLR->bf;//先记录插入后的平衡因子 RoRateL(subL); RoRateR(parent); if (bf == 0)//分情况讨论 { parent->bf = 0; subL->bf = 0; subLR->bf = 0; } else if (bf == 1) { parent->bf = 0; subL->bf = -1; subLR->bf = 0; } else if (bf == -1) { parent->bf = 1; subL->bf = 0; subLR->bf = 0; } else { assert(false); } } class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}"> class="hide-preCode-box">

void RoRateR( node* parent)//右单旋 { node* subL = parent->left; node* subLR = subL->right; node* pparnet = parent->parent; parent->left = subLR; if (subLR) { subLR->parent = parent;//修改父节点 } subL->right = parent; parent->parent = subL; if (pparnet == nullptr)//parent就是根节点 { _root = subL; subL->parent = nullptr; } else { if (pparnet->left == parent)//确定parent节点是左还是右 { pparnet->left = subL; } else { pparnet->right = subL; } subL->parent = pparnet;//修改父节点 } subL->bf = parent->bf = 0;//更新平衡因子 } void RoRateL( node* parent)//左单旋 { node* subR = parent->right; node* subRL = subR->left; node* pparnet = parent->parent; parent->right = subRL; if (subRL)//防止subRL为空 { subRL->parent = parent;//修改父节点 } subR->left = parent; parent->parent = subR; if (pparnet==nullptr)//parent就是根节点 { _root = subR; subR->parent = nullptr; } else { if (pparnet->left == parent)//确定parent节点是左还是右 { pparnet->left = subR; } else { pparnet->right = subR; } subR->parent = pparnet;//修改父节点 } subR->bf = parent->bf = 0;//更新平衡因子 } void RoRateLR( node* parent)//左右双旋 { node* subL = parent->left; node* subLR = subL->right; int bf = subLR->bf;//先记录插入后的平衡因子 RoRateL(subL); RoRateR(parent); if (bf == 0)//分情况讨论 { parent->bf = 0; subL->bf = 0; subLR->bf = 0; } else if (bf == 1) { parent->bf = 0; subL->bf = -1; subLR->bf = 0; } else if (bf == -1) { parent->bf = 1; subL->bf = 0; subLR->bf = 0; } else { assert(false); } } void RoRateRL( node* parent)//右左双旋 { node* subR = parent->right; node* subRL = subR->left; int bf = subRL->bf;//先记录插入后的平衡因子 RoRateR(subR); RoRateL(parent); if (bf == 0)//分情况讨论 { parent->bf = 0; subR->bf = 0; subRL->bf = 0; } else if (bf == 1) { parent->bf = -1; subR->bf = 0; subRL->bf = 0; } else if (bf == -1) { parent->bf = 0; subR->bf = 1; subRL->bf = 0; } else { assert(false); } } bool Insert(const k& x, const v& v) { if (_root == nullptr)//插入根节点 { _root = new node(x, v); return true; } node* cur = _root; node* parent = nullptr;//保留父亲节点 while (cur) { /*介质不冗余*/ if (x < cur->_key) { parent = cur; cur = cur->left; } else if (x > cur->_key) { parent = cur; cur = cur->right; } else { return false; } //介质冗余 //if (x <= cur->_key)//相等插入到左子树 //{ // parent = cur; // cur = cur->left; //} //else if (x > cur->_key) //{ // parent = cur; // cur = cur->right; //} } cur = new node(x, v); if (x > parent->_key) { parent->right = cur; } else//相等插入左子树 { parent->left = cur; } cur->parent = parent; while (parent) { // 更新平衡因⼦ if (cur == parent->left) parent->bf--; else parent->bf++; if (parent->bf == 0) { // 更新结束 break; } else if (parent->bf == 1 || parent->bf == -1) { // 继续往上更新 cur = parent; parent = parent->parent; } else if (parent->bf == 2 || parent->bf == -2)//旋转 { if (parent->bf == -2 && cur->bf == -1) { RoRateR(parent); } else if (parent->bf == 2 && cur->bf == 1) { RoRateL(parent); } else if (parent->bf == -2 && cur->bf == 1) { RoRateLR(parent); } else if (parent->bf == 2 && cur->bf == -1) { RoRateRL(parent); } else { assert(false); } break; } else { assert(false); } } return true; } class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}"> class="hide-preCode-box">

void Inorder() { _Inorder(_root); cout << endl; } bool IsBalanceTree() { return _IsBalanceTree(_root); } bool _IsBalanceTree(const node* root) { // 空树也是AVL树 if (nullptr == root) return true; // 计算pRoot结点的平衡因⼦：即pRoot左右⼦树的⾼度差 int leftHeight = _Height(root->left); int rightHeight = _Height(root->right); int diff = rightHeight - leftHeight; // 如果计算出的平衡因⼦与pRoot的平衡因⼦不相等，或者 // pRoot平衡因子的绝对值超过1，则⼀定不是AVL树 if (abs(diff) >= 2) { cout << root->_value << "高度差异常" << endl; return false; } if (root->bf != diff) { cout << root->_key << "平衡因子异常" << endl; return false; } // pRoot的左和右如果都是AVL树，则该树⼀定是AVL树 return _IsBalanceTree(root->left) && _IsBalanceTree(root->right); } void _Inorder(const node* root) { if (root == nullptr) { return; } _Inorder(root->left); cout << root->_key << ":" << root->_value<<endl; _Inorder(root->right); } size_t Size() { return _Size(_root); } size_t _Size(const node* parent) { if (parent) { return 1 + _Size(parent->left)+ _Size(parent->right); } else { return 0; } } size_t Height() { return _Height(_root); } size_t _Height(const node* parent) { if (parent) { return 1 + max(_Height(parent->left), _Height(parent->right)); } else { return 0; } } class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}"> class="hide-preCode-box">

void TestAVLTree1() { AVL::AVLTree<int, int>t; // 常规的测试⽤例 //int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 }; // 特殊的带有双旋场景的测试⽤例 int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 }; for (auto e : a) { t.Insert(e, e); } t.Inorder(); cout << t.IsBalanceTree() << endl; } class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

void TestAVLTree2() { const int N = 100000; vector<int> v; v.reserve(N); srand(time(0)); for (size_t i = 0; i < N; i++) { v.push_back(rand() + i); } size_t begin2 = clock(); AVL::AVLTree<int, int> t; for (auto e : v) { t.Insert(e, e); } size_t end2 = clock(); cout << "Insert:" << end2 - begin2 << endl; cout << t.IsBalanceTree() << endl; cout << "Height:" << t.Height() << endl; cout << "Size:" << t.Size() << endl; size_t begin1 = clock(); // 确定在的值 /*for (auto e : v) { t.Find(e); }*/ // 随机值 for (size_t i = 0; i < N; i++) { t.Find((rand() + i)); } size_t end1 = clock(); cout << "Find:" << end1 - begin1 << endl; } class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}"> class="hide-preCode-box">

Python之with as用法详解

Python之with as用法详解

文章目录

【C++笔记】AVL树的深度剖析

文章目录

前言

一. AVL树的概念

二.AVL树的实现

2.1 AVL树的结构

2.2 AVL树的插入

2.3 平衡因子更新

三.旋转

3.1旋转的原则

3.2右单旋

3.3左单旋

3.4左右双旋

3.5右左双旋

3.6AVL树的插入

3.7AVL树的查找

四.AVL树的检测

4.1AVL树检测

4.2 AVL树的验证

后言

评论记录：