微专业 Python精进路线展望 第一周

上下文管理器

上下文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导入模块时调用的查找函数