上下文管理器

上下文Context:程序执行中某个状态

  • 程序执行所需的一些内外部参数，构成了程序运行时的状态。
  • 上下文是用来表达程序运行状态的概念，对应内存状态。
  • 上下文是程序中断保留或恢复运行的重要状态信息。

上下文管理器：一个可以在程序中加载独立上下文的对象

  • 万物皆对象：上下文管理器也是一个对象，管理者一个独立上下文区域。
  • 上下文管理器使用with显示创建。
  • 进入和退出分别对应__enter__()和__exit__()。
#cm.__enter__()执行开始，返回结果绑定给对象引用
with <表达式> as <对象引用>:
	<语句块>
#cm.__exit__()执行结果，退出上下文区域
with open('from_f.txt','r') as fi, \
		open('to_f.txt','r') as fo:
	for line in fi:
		fo.write(line)

如何使用上下文管理器

  • with要配合特定对象使用。
  • Python默认支持的对象：
  • file
  • decimal.Context
  • thread.LockType
  • threading.Lock
  • threading.RLock
  • threading.Condition
  • threading.Semaphore
  • threading.BoundedSemaphore
  • 用户可自定义对象
class DemoClass:
	def __init__(self,name):
		self.name=name
	def __enter__(self): #重载__enter__()方法
		print('进入上下文管理器')
		return self #as 引用是__enter__()返回值
	def __exit__(self,exc_type,exc_val,exc_tb): #__exit__()方法
		print('退出上下文管理器')
	def run(self):
		print('DemoClass的某个实例对象在运行')
with DemoClass('Python123') as d:
	d.run()
'''
进入上下文管理器
DemoClass的某个实例对象在运行
退出上下文管理器
'''

迭代器类型

迭代器类型 iterator types:实现容器中元素的迭代

  • 容器container: 包含一组元素的数据类型，如 全部组合数据类型。
  • 迭代器：容器之上的一种迭代，迭代方式以对象形式表达。
  • 迭代器定义了逐一获取容器中元素的方法。

迭代器类型 iterator types:实现容器中元素的迭代

  • 迭代器是一个对象，常与for…in…配合使用，需要重载两个方法。
  • _ _ iter _ _ ()返回迭代器对象自身，配合for…in…使用时需要。
  • _ _ next _ _()返回容器的下一个元素，如果遍历结束，产生Stoplteration异常。

迭代器类型：原理实例

class DemoIterator:
	def __init__(self,container):
		self.container=container
		self.salt=len(self.container)
	def __iter__(self):
		return self
	def __next__(self):
		self.salt-=1
		if self.salt>=0:
			return self.container[self.salt]
		else:
			raise StopIteration

di=DemoIterator([1,2,3,4,5,6,7,8])
for i in di:
	print(i,end=' ')
#输出：
#8,7,6,5,4,3,2,1

迭代器类型 iterator types:实现容器中元素的迭代

  • 迭代器非常常用，尤其是涉及管理一组数据的应用场景。
  • 自定义类+for…in…管理一组数据，作为数据管理的核心自定义数据类型。
  • 迭代器返回下一个元素的方式为优化程序内存使用提供了重要支持。

生成器设计

生成器Generator: 快速实现迭代器类型的方式

  • 生成器是迭代器的另一个角度诠释，生成器都是迭代器。
  • 生成器以逐一产生数据为角度，重点在于迭代逻辑的方便实现。
  • 生成器只需要yield保留字即可定义并表达，不用重载对象方法。

生成器Generator: 快速实现迭代器类型的方式

  • 生成器函数是生成器的核心，用来实现迭代逻辑。
  • 任何包含yield语句的函数，都是生成器函数。
  • 对于函数来说，yield和return功能接近，但不完全相同。

普通函数

  • 每次调用完整执行后退出。
  • 如果函数表达了容器概念也是如此。

计算资源被浪费

生成器：设计实例

def getValue(max):
	import random
	ls=list(range(10))
	print(ls,end=",")
	for i in range(max):
		yield ls[random.randint(0,9)]

for i in getValue(10):
	print(i)
#输出为：
'''
[0,1,2,3,4,5,6,7,8,9],0
9
9
0
3
0
4
2
9
5
'''

生成器函数的设计原则

  • 若想不断生成数据，生成器函数需要存在迭代/循环过程。
  • 每次迭代/循环产生的结果以yield方式表达。
  • 生成器函数要与for…in…配合使用，注意：生成器是一种特殊迭代器。

装饰器与语法糖

装饰器Decorator: 以函数为参数实现其额外功能更新

  • 需求：对于一个已有函数，如何更新其功能？（同名使用）
  • 解决方式1：重新编写该函数，把功能补充进去。
  • 解决方式2：不改变原来函数，增补一个装饰器给它。

装饰器Decorator: 以函数为参数实现其额外功能更新

  • classmethod()和staticmethod()内置函数。
  • @classmethod
  • @staticmethod
def f(...):
	...
f=staticmethod(f)

上面实例等价下面实例

@staticmethod
def f(...):
	...

语法糖 Syntactic Sugar: 方便使用但无实质功能的语法

  • 语法糖：一种功能的简化使用方式，非功能性改变。
  • Python中采用@作为语法糖，辅助装饰器使用。
  • 任何语法糖表达的装饰器都对应一个函数。
@f1(arg)
@f2
def func():
	pass
#等价于
f1(arg)(f2(func))

装饰器

  • 语法糖不重要，重要的是装饰器函数，该函数以函数为参数。
  • 由于可能存在装饰器迭代，每个装饰器函数需要返回一个函数引用。
  • 装饰器函数内部，进行功能扩展。

装饰器设计：实例

def bar(foo):
'''
装饰器函数必须返回一个函数对象引用
否则，无法利用语法糖
因此，需要内部定义一个函数
建议：都用wrapper这个名字

函数就是一段代码
如果没有语法糖，不必要非定义函数
'''
	def wrapper(a): #wrapper函数要包含printA()所用参数
		print("{:*^20}".format('BEGIN')) #wrapper函数内部要完成功能扩展
		foo(a)
		print("{:*^20}".format('END'))
	return wrapper
@bar #装饰器的语法糖，此时原函数不再是原函数
def printA(a): #原函数：有一个参数
	print("这是变量{}".format(a))

printA("Python123")
'''
这是变量Python123

******BEGIN*********
这是变量Python123
*******END**********
'''

装饰器使用场景

  • 对原函数功能的补充：测量时间、增加打印等。
  • 对原函数功能的调用：利用原函数运行结果，再次运算产生新结果。
  • 对原函数功能的重写：只是借助原来的名字，谨慎修改旧函数。

异步协程函数

协程Coroutine：在程序层面的多段代码异步执行

  • Python3.5新增内置功能：async和await保留字。
  • async：用于定义异步执行的协程代码片段。
  • await：异步代码段之间的手工同步方式。

async的用法

async def foo(): #协程函数
	pass

async with lock: #协程上下文管理器
	pass

async for data in pipeline: #协程迭代器
	pass

await的用法

async def foo(db):
	data=await db.fetch('SELECT ...') #在异步函数中，等待其他函数返回结果的保留字
	pass
'''
获取异步协程的结果
结果为awaitable对象
'''

协程初步

  • 协程就是一个函数，只是它满足一下几个特种：
    1.有I/O(输入/输出：如存储txt)依赖的操作。
    2.可以在进行I/O操作时暂停。
    3.无法直接执行。
  • 它的作用就是对有大量I/O操作的程序进行加速。
    python协程属于 可等待对象，因此可以在其他协程中被等待
import asyncio
async def net():
	return 11
async def main():
	net() #error异步函数无法直接调用
	d=await net() #right
	print(d)
asyncio.run(main())
#输出为：11
'''
也可以使用
async def main():
	task=asyncio.create_task(net)
	await task
'''
import asyncio
async def hello(i):
	print('hello',i)
	await asyncio.sleep(3)
	print('world',i)
if __name__=='__main__':
	tasks=[]
	for i in range(4):
		tasks.append(hello(i))
	loop=asyncio.get_event_loop()
	loop.run_until_complete(asyncio.wait(tasks))
	loop.close()

保留字

保留字：被编程语言内部定义并保留使用的标识符，共33+2个
and/as/assert/break/class/continue/def/elif/else/except/finally/for/from/if/import/in/is/lambda/not/or/pass/raise/return/try/while/with/yied/del/global/nonlocal/True/False/None/async/await/

and/or/not逻辑运算保留字
and: 与操作 True and False
or: 或操作 True or False
not: 非操作 not True

as 对象引用增加保留字，相当于绑定别名

  • import 模块 as 别名（对象引用）
  • （try …）except 异常 as 对象引用
  • with … as 对象引用

assert 断言语句保留字，通过异常进行程序辅助调试

  • assert 判断条件
  • 如果条件为False，产生AssertionError异常

break、continue循环控制保留字

  • break 退出当前层循环。
  • continue 退出当次循环。

class 类定义保留字

  • class 类名：
  • class 派生类名(基类名):

def 函数定义保留字

  • def 函数名（参数列表）：
  • async def 函数名（参数列表）：

if、elif、else条件判断保留字

  • 条件判断：if-else、if-elif-else
  • else:可以与循环和异常结合使用

try、except、finally异常处理保留字

  • try-except
  • try-except-else-finally

for、while循环处理保留字

  • 遍历循环：for…in
  • 无限循环：while

from、import模块导入保留字

  • import 模块名
  • from 模块名 import *

in 成员关系操作保留字

  • 成员关系提取：for … in …
  • 成员关系判断：… in …

is 对象判断保留字

  • 对象一致性判断，即比较id()函数结果。
  • 以内存对象为判断依据：x is y。

lambda 匿名函数保留字

  • 定义匿名函数，产生函数对象。
  • lambda 参数列表：表达式。

pass 空操作保留字

  • 代表空操作，执行后不产生任何功能。
  • 在程序中用作占位符。

raise 异常产生保留字

  • 产生一个异常，辅助try-except程序功能。
  • raise 异常名称

return 函数返回保留字

  • 结束当前函数，返回0个或多个结果。
  • return 返回值。

with 上下文管理器保留字

  • 构建并管理一个上下文区域。
  • with 表达式 as 对象：

yield 生成器定义保留字

  • 定义一个同步或异步（协程）生成器。
  • yield 表达式。

del 删除保留字

  • 解除引用与对象的绑定关系，“删除”引用。
  • del 引用。

global 全局声明保留字

  • 全局变量声明，声明后可以赋值。
  • global 变量名。

nonlocal 非本地声明保留字

  • 声明变量为当前与全局命名空间之间。
  • nonlocal 变量名。

True、False布尔保留字

  • True:表示真。
  • False:表示假，含0、0.0、[]、{}、""等。

None 空无保留字

  • 表示空无，与False不同。
  • Python最基础的一个对象。

async 协程声明保留字

  • 声明一段协程程序。
  • async def 协程函数名（函数参数）：
  • async with …:

await 协程等待保留字

  • 等待一段协程程序执行并返回结果。
  • await 协程函数调用（）。

Python特殊符号

特殊符号：表达Python语法的三种逻辑

  • 操作符：表达操作运算。
+ - * ** / // % @(矩阵乘法操作符，尚未有功能支持 预留)
<< >> & | ^ ~
< > <= >= == !=
  • 分界符：表达式之间的分界。
( ) [ ] { } , : . ; @ = -> += -= *= /= //= %= 
@= &= |= ^= >>= <<= **=
# ;当多行语句在一行表示时，可以用分号分隔，但不建议
# ->函数注解，辅助对函数参数及返回值类型进行注解
'''
def foo(a: int,b: str)->str:
	return "{} and {}".format(a,b)
'''
  • 特殊含义：具有特殊含义的符号。
' " # \

Python内置函数

函数

描述

abs(x)

返回x的绝对值（int，float），如x为复数（complex），返回摸值

bin(x)

将一个整数x转换为二进制字符串形式，以0b开头

bytearray()

返回一个新的字节数组

bytes(src)

将src转换成一个新的字节串对象

chr(int)

返回int在Unicode编码下代表的字符

complex([r[,i]])

将输入的数值/元组/字符串转换为复数（complex）对象并返回

dict()

返回一个新的字典对象

divmod(inta,intb)

返回(a//b,a%b)的结果

eval（exp)

将字符串表达式exp作为合法的语句传入Python进行解释执行

float(x)

将数字或字符串x转换为浮点数

hash(obj)

返回对象obj的哈希值

hex(int)

将int转换为十六进制，返回以0x为前缀全部小写的字符串结果

id(obj)

返回obj在Python中的id值，一般指CPython中改对象的内存地址

input([prompt])在屏幕显示字符串prompt并等待输入

int(x)

将数字/字符串x转换为整数

len(s)

返回对象s的长度

list([iterable])

返回一个新的列表对象，可用iterable参数对其初始化

max(iterable)

返回iterable中最大值

min(iterable)返回iterable中最小值

oct(int)

将int转换为八进制，返回以0o为前缀的字符串结果

open(file,mode)

以mode方式打开文件file并返回文件对象

ord©

与chr©相反，返回字符串C的Unicode编码值

pow(x,y[,z])

返回x的y次方，可选参数z用于取模

print(x)

将x打印到屏幕上

range（start,stop[,step]）

返回start(包含)开始，stop（不包含）结束的可迭代对象，可选参数step控制步长间隔

round(x)

对x近似取整（受浮点数精度影响，不是严格的四舍五入）

set([iterable])

返回一个新的集合对象，可用iterable参数初始化

str(x)

将x转换为字符串

sum(iterable)

返回iterable的求和结果

super(x)

用于在子类中调用父类中被重载的方法

tuple([iterable])

返回一个新的元组对象，可用iterable参数初始化

type(obj)

返回obj的类型

all(iterable)

如果iterable中元素都是True或iterable为空，则返回True

any(iterable)

如果iterable中任一元素是True,返回True,iterable为空返回False

ascii(obj)

返回obj的repr()输出，对于非可打印字符采用\x \u \U表示

bool(x)

计算x，返回True或False

breakpoint(*args,**kws)

使用该函数进入Debug环境

callable(obj)

如果obj是可调用的则返回True，否则返回False

classmethod()

装饰器函数，将方法转换为类方法，对应语法糖@classmethod

compile(src,filename,mode)

将src编译为代码或AST对象

delattr(obj,name)

删除obj对象的name属性

dir(obj)

返回obj的所有合法属性

enumerate(iterable)

返回由iterable初始化的枚举对象（序号与值组成的二元组序列）

exec(obj)

执行传入的string或code对象

filter(func,iterable)

将iterable对象传入函数func，将True对象构造为一个迭代器

format(value[,format_spec])

将value按照format_spec的格式进行格式化

frozenset([iterable])

返回一个不可修改的集合对象，只可用iterable参数初始化

getattr(obj,name)

返回obj对象的name属性

globals()

返回由当前全局变量组成的字典

hasattr(obj,name)

如果obj对象有name属性则返回True,否则返回False

help(obj)

输出obj对象的帮助文档

isinstance(obj,classinfo)

如果对象obj是类classinfo的实例则返回True,否则返回False

issubclass(class,classinfo)

如果类class是类classinfo的子类则返回True,否则返回False

iter(obj)

返回由obj对象构造的迭代器，obj必须是可迭代对象

local（）

返回由当前局部变量组成的字典

map(func,iterable)

返回将iterable中每个对象传入函数func而构造的迭代器

memoryview(obj)

返回obj对象的memory view信息

next(iterator)

返回迭代器中下一个元素，会改变迭代器状态

object

Python最基础对象，它的类是所有对象的基类

property()

装饰器函数，用于将方法转换为属性，对应语法糖@property

repr(obj)

调用obj对象 _ _ repr _ _ ()方法，返回目标对象的可打印字符串

reversed(seq)

返回将序列seq反向后构造的迭代器

setattr(obj,name,value)

为obj对象增加name属性，属性值为value

slice(start,stop[,step])

返回start(包含)开始，stop(不包含)结束的可切片对象，可选参数step控制步间隔

sorted(iterable)

返回一个由iterable对象元素排序后构成的新列表对象

staticmethod()

装饰器函数，将方法转换为静态方法，对应语法糖@staticmethod

vars(obj)

返回obj模块/类/对象 _ _ dict _ _属性

zip(*iterables)

从各iterable对象中提取元素拼成元组，形成并返回新的迭代器

_ _ import _ _ (name)

使用关键字import导入模块时调用的查找函数