本章内容：
装饰器
迭代器 & 生成器
re 正则表达式
字符串格式化
装饰器
装饰器是一个很著名的设计模式，经常被用于有切面需求的场景，较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。
先定义一个基本的装饰器：
########## 基本装饰器 ##########
def orter(func): #定义装饰器
def inner():
print(“this is inner before.”)
s = func() #调用原传入参数函数执行
print(“this is inner after.”)
return s #return原函数返回值
return inner #将inner函数return给name函数
@orter #调用装饰器（将函数name当参数传入orter装饰器）
def name():
print(“this is name.”)
return true #name原函数return true
ret = name()
print(ret)
输出结果：
this is inner before.
this is name.
this is inner after.
true
给装饰器传参数：
############ 装饰器传参数 ###########
def orter(func):
def inner(a,b): #接收传入的2个参数
print(“this is inner before.”)
s = func(a,b) #接收传入的原函数2个参数
print(“this is inner after.”)
return s
return inner
@orter
def name(a,b): #接收传入的2个参数，并name整体函数当参数传入orter装饰器
print(“this is name.%s,%s”%(a,b))
return true
ret = name(‘nick’,’jenny’) #传入2个参数
print(ret)
输出结果：
this is inner before.
this is name.nick,jenny
this is inner after.
true
给装饰器传万能参数：
########## 万能参数装饰器 ##########
def orter(func):
def inner(*args,**kwargs): #万能参数接收多个参数
print(“this is inner before.”)
s = func(*args,**kwargs) #万能参数接收多个参数
print(“this is inner after.”)
return s
return inner
@orter
def name(a,b,c,k1=’nick’): #接受传入的多个参数
print(“this is name.%s,%s”%(a,b))
return true
ret = name(‘nick’,’jenny’,’car’)
print(ret)
输出结果：
this is inner before.
this is name.nick,jenny
this is inner after.
true
一个函数应用多个装饰器方法：
########### 一个函数应用多个装饰器 #########
def orter(func):
def inner(*args,**kwargs):
print(“this is inner one before.”)
print(“this is inner one before angin.”)
s = func(*args,**kwargs)
print(“this is inner one after.”)
print(“this is inner one after angin.”)
return s
return inner
def orter_2(func):
def inner(*args,**kwargs):
print(“this is inner two before.”)
print(“this is inner two before angin.”)
s = func(*args,**kwargs)
print(“this is inner two after.”)
print(“this is inner two after angin.”)
return s
return inner
@orter #将以下函数整体当参数传入orter装饰器
@orter_2 #将以下函数当参数传入orter_2装饰器
def name(a,b,c,k1=’nick’):
print(“this is name.%s and %s.”%(a,b))
return true
ret = name(‘nick’,’jenny’,’car’)
print(ret)
输出结果：
this is inner one before.
this is inner one before angin.
this is inner two before.
this is inner two before angin.
this is name.nick and jenny.
this is inner two after.
this is inner two after angin.
this is inner one after.
this is inner one after angin.
true
迭代器 & 生成器
1、迭代器
迭代器只不过是一个实现迭代器协议的容器对象。
特点：
访问者不需要关心迭代器内部的结构，仅需通过next()方法不断去取下一个内容
不能随机访问集合中的某个值 ，只能从头到尾依次访问
访问到一半时不能往回退
便于循环比较大的数据集合，节省内存
a = iter([1,2,3,4])
print a
print a.next()
print a.next()
print a.next()
print a.next()
print a.next()
1
2
3
4
traceback (most recent call last):
file “d:/python/untitled4/test.py”, line 23, in
print a.next()
stopiteration
2、生成器
一个函数调用时返回一个迭代器，那这个函数就叫做生成器（generator）；如果函数中包含yield语法，那这个函数就会变成生成器。
def xran():
print (“one”)
yield 1
print “two”
yield 2
print “sr”
yield 3
ret = xran()
#print ret #
result = ret.next()
print result
result = ret.next()
print result
result = ret.next()
print result
# ret.next() #循环完毕抛出异常
# ret.close() #关闭生成器
one
1
two
2
sr
3
生成器的表达式：
a = [1,2,3]
b = [i+3 for i in a]
print b
print type(b)
ib = (i+3 for i in a)
print ib
print ib.next()
print ib.next()
print ib.next()
[4, 5, 6]
4
5
6
正则表达式：
正则表达式是用来匹配字符串非常强大的工具，在其他编程语言中同样有正则表达式的概念。就其本质而言，正则表达式（或 re）是一种小型的、高度专业化的编程语言，（在python中）它内嵌在python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 c 编写的匹配引擎执行。
#导入 re 模块
import re
s = ‘nick jenny nice’
# 匹配方式（一）
b = re.match(r’nick’,s)
q = b.group()
print(q)
# 匹配方式（二）
# 生成pattern对象实例,r表示匹配源字符串
a = re.compile(r’nick’)
print(type(a)) #
b = a.match(s)
print(b) #
q = b.group()
print(q)
#被匹配的字符串放在string中
print(b.string) #nick jenny nice
#要匹配的字符串放在re中
两种匹配方式区别在于：第一种简写是每次匹配的时候都要进行一次匹配公式的编译，第二种方式是提前对要匹配的格式进行了编译（对匹配公式进行解析），这样再去匹配的时候就不用在编译匹配的格式。
匹配规则：
# “.” 匹配任意字符（除了\n）
a = re.match(r”.”,”95nick”)
b = a.group()
print(b)
# […] 匹配字符集
a = re.match(r”[a-za-z0-9]”,”123nick”)
b = a.group()
print(b)
# \d \d 匹配数字/非数字
a = re.match(r”\d”,”nick”)
b = a.group()
print(b)
# \s \s 匹配空白/非空白字符
a = re.match(r”\s”,” “)
b = a.group()
print(b)
# \w \w 匹配单词字符[a-za-z0-9]/非单词字符
a = re.match(r”\w”,”123nick”)
b = a.group()
print(b)
a = re.match(r”\w”,”+-*/”)
b = a.group()
print(b)
# “*” 匹配前一个字符0次或者无限次
a = re.match(r”[a-z][a-z]*”,”aaaaaa123″) #可以只匹配a，123不会匹配上
b = a.group()
print(b)
# “+” 匹配前一个字符1次或者无限次
a = re.match(r”[_a-za-z]+”,”nick”)
b = a.group()
print(b)
# “？” 匹配一个字符0次或者1次
a = re.match(r”[0-8]?[0-9]”,”95″) #(0-8)没有匹配上9
b = a.group()
print(b)
# {m} {m,n} 匹配前一个字符m次或者m到n次
a = re.match(r”[\w]{6,10}@qq.com”,”630571017@qq.com”)
b = a.group()
print(b)
# *? +? ?? 匹配模式变为非贪婪（尽可能少匹配字符串）
a = re.match(r”[0-9][a-z]*?”,”9nick”)
b = a.group()
print(b)
a = re.match(r”[0-9][a-z]+?”,”9nick”)
b = a.group()
print(b)
# “^” 匹配字符串开头,多行模式中匹配每一行的开头。
li = “nick\nnjenny\nsuo”
a = re.search(“^s.*”,li,re.m)
b = a.group()
print(b)
# “$” 匹配字符串结尾,多行模式中匹配每一行的末尾。
li = “nick\njenny\nnick”
a = re.search(“.*y$”,li,re.m)
b = a.group()
print(b)
# \a 仅匹配字符串开头
li = “nickjennyk”
a = re.findall(r”\anick”,li)
print(a)
# \z 仅匹配字符串结尾
li = “nickjennyk”
a = re.findall(r”nick\z”,li)
print(a)
# \b 匹配一个单词边界，也就是指单词和空格间的位置
a = re.search(r”\bnick\b”,”jenny nick car”)
b = a.group()
print(b)
# “|” 匹配左右任意一个表达式
a = re.match(r”nick|jenny”,”jenny”)
b = a.group()
print(b)
# (ab) 括号中表达式作为一个分组
a = re.match(r”[\w]{6,10}@(qq|163).com”,”630571017@qq.com”)
b = a.group()
print(b)
# \ 引用编号为num的分组匹配到的字符串
a = re.match(r”)[\w]+