装饰器、迭代器、生成器、字符串格式化

装饰器　

装饰器是一个很著名的设计模式，经常被用于有切面需求的场景，较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。

先定义一个基本的装饰器：

def orter(func):    #定义装饰器
    def inner():
        print("之前")
        s = func()    #调用原传入参数函数执行
        print("之后")
        return s        #return原函数返回值
    return inner      #将inner函数return给name函数

@orter    #调用装饰器（将函数name当参数传入orter装饰器）
def name():
    print("原本")
    return True       #name原函数return True

#当定义一个接受值时，有返回值
ret = name()
print(ret)

#输出结果
之前
原本
之后
True

#当直接执行时函数name函数，没有return值
def orter(func):    #定义装饰器
    def inner():
        print("之前")
        s = func()    #调用原传入参数函数执行
        print("之后")

    return inner      #将inner函数return给name函数

@orter    #调用装饰器（将函数name当参数传入orter装饰器）
def name():
    print("原本")


name()
#输出结果
之前
原本
之后

给装饰器传参数：

def orter(func):
    def inner(a,b):      #接收传入的2个参数
        print("之前")
        s = func(a,b)    #接收传入的原函数2个参数
        print("之后")
        return s
    return inner

@orter
def name(a,b):    #接收传入的2个参数，并name整体函数当参数传入orter装饰器
    print("This is name.%s,%s"%(a,b))
    return True

ret = name('yu','mei')    #传入2个参数
print(ret)

输出结果：
之前
This is name.yu,mei
之后
True

给装饰器传万能参数：

def orter(func):
    def inner(*args,**kwargs):        #万能参数接收多个参数
        print("之前")
        s = func(*args,**kwargs)       #万能参数接收多个参数
        print("之后")
        return s
    return inner

@orter
def name(a,b,c):        #接受传入的多个参数
    print("This is name.%s,%s%s"%(a,b,c))
    return True

ret = name('yu','mie','car')
print(ret)

输出结果：
之前
This is name.yu,mei,car
之后
True

一个函数应用多个装饰器方法：

def orter(func):
    def inner(*args,**kwargs):        #万能参数接收多个参数
        print("第一之前")
        s = func(*args,**kwargs)       #万能参数接收多个参数
        print("第一之后")
        return s
    return inner
def orter_2(func):
    def inner(*args,**kwargs):        #万能参数接收多个参数
        print("第二之前")
        s = func(*args,**kwargs)       #万能参数接收多个参数
        print("第二之后")
        return s
    return inner

@orter
@orter_2
def name(a,b,c,k1=''):        #接受传入的多个参数
    print("This is name.%s,%s,%s,%s"%(a,b,c,k1))
    return True

ret = name('yu','mie','car')
print(ret)

#输出结果
第一之前
第二之前
This is name.yu,mie,car,
第二之后
第一之后
True

带参数的装饰器   直接改变False或者True就可以实现用或不用装饰器

假如你有成千上万个函数使用了一个装饰器，现在你想把这些装饰器都取消掉，你要怎么做？

一个一个的取消掉？ 没日没夜忙活3天。。。

过两天你领导想通了，再让你加上。。

def outer(flag):
    def timer(func):
        def inner(*args,**kwargs):
            if flag:
                print('''执行函数之前要做的''')
            re = func(*args,**kwargs)
            if flag:
                print('''执行函数之后要做的''')
            return re
        return inner
    return timer

@outer(False)
def func():
    print(111)

func()

迭代器　

1、迭代器   __next__

　　迭代器只不过是一个实现迭代器协议的容器对象。

特点：

1. 访问者不需要关心迭代器内部的结构，仅需通过next()方法不断去取下一个内容
2. 不能随机访问集合中的某个值 ，只能从头到尾依次访问
3. 访问到一半时不能往回退
4. 便于循环比较大的数据集合，节省内存

a = iter([1,2,3,4,5,6,7])
for i in  range(7):
    print(a.__next__())

#输入结果
1
2
3
4
5
6
7
StopIteration         #末尾生成StopIteration异常

2、生成器

　　一个函数调用时返回一个迭代器，那这个函数就叫做生成器（generator）；如果函数中包含yield语法，那这个函数就会变成生成器。

def test():
    print("1111")
    yield 1
    print("222")
    yield 2
    print("333")
    yield 3


ret = test()
# print(ret)      #<generator object xran at 0x00000000006ED308>

result = ret.__next__()
print(result)

result = ret.__next__()
print(result)

result = ret.__next__()
print(result)

#返回结果
1111
1
222
2
333
3

字符串格式化　

1.百分号方式

%[(name)][flags][width].[precision]typecode

• (name)   可选，用于选择指定的key
• flags    可选，可供选择的值有:width         可选，占有宽度
  • • +     右对齐；正数前加正好，负数前加负号；
    • -     左对齐；正数前无符号，负数前加负号；
    • 空格  右对齐；正数前加空格，负数前加负号；
    • 0     右对齐；正数前无符号，负数前加负号；用0填充空白处
• .precision  可选，小数点后保留的位数
• typecode    必选
  • • s，获取传入对象的__str__方法的返回值，并将其格式化到指定位置
    • r，获取传入对象的__repr__方法的返回值，并将其格式化到指定位置
    • c，整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置
    • o，将整数转换成 八  进制表示，并将其格式化到指定位置
    • x，将整数转换成十六进制表示，并将其格式化到指定位置
    • d，将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置
    • e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
    • E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
    • f， 将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
    • F，同上
    • g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
    • G，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
    • %，当字符串中存在格式化标志时，需要用 %%表示一个百分号

常用格式化：
 
tpl = "i am %s" % "nick"
  
tpl = "i am %s age %d" % ("nick", 18)
  
tpl = "i am %(name)s age %(age)d" % {"name": "nick", "age": 18}
  
tpl = "percent %.2f" % 99.97623
  
tpl = "i am %(pp).2f" % {"pp": 123.425556, }
  
tpl = "i am %.2f %%" % {"pp": 123.425556, }

2.Format方式　

• fill    【可选】空白处填充的字符
• align   【可选】对齐方式（需配合width使用）
  • <，内容左对齐
  • >，内容右对齐(默认)
  • ＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。 即使：符号+填充物+数字
  • ^，内容居中
• sign    【可选】有无符号数字
  • • +，正号加正，负号加负；
    •  -，正号不变，负号加负；
    • 空格 ，正号空格，负号加负；
• #       【可选】对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示
• ，      【可选】为数字添加分隔符，如：1,000,000
• width   【可选】格式化位所占宽度
• .precision 【可选】小数位保留精度
• type    【可选】格式化类型
  • • 传入” 字符串类型 “的参数
      • s，格式化字符串类型数据
      • 空白，未指定类型，则默认是None，同s
    • 传入“ 整数类型 ”的参数
      
      • b，将10进制整数自动转换成2进制表示然后格式化
      • c，将10进制整数自动转换为其对应的unicode字符
      • d，十进制整数
      • o，将10进制整数自动转换成8进制表示然后格式化；
      • x，将10进制整数自动转换成16进制表示然后格式化（小写x）
      • X，将10进制整数自动转换成16进制表示然后格式化（大写X）
    • 传入“ 浮点型或小数类型 ”的参数
      • e， 转换为科学计数法（小写e）表示，然后格式化；
      • E， 转换为科学计数法（大写E）表示，然后格式化;
      • f ， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
      • F， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
      • g， 自动在e和f中切换
      • G， 自动在E和F中切换
      • %，显示百分比（默认显示小数点后6位）

常用格式化：
 
tpl = "i am {}, age {}, {}".format("nick", 18, 'jenny')
   
tpl = "i am {}, age {}, {}".format(*["nick", 18, 'jenny'])
   
tpl = "i am {0}, age {1}, really {0}".format("nick", 18)
   
tpl = "i am {0}, age {1}, really {0}".format(*["nick", 18])
   
tpl = "i am {name}, age {age}, really {name}".format(name="nick", age=18)
   
tpl = "i am {name}, age {age}, really {name}".format(**{"name": "nick", "age": 18})
   
tpl = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
   
tpl = "i am {:s}, age {:d}, money {:f}".format("nick", 18, 88888.1)
 
tpl = "i am {:s}, age {:d}, money {:0.2f}".format("nick", 18, 88888.111111111111)
   
tpl = "i am {:s}, age {:d}".format(*["nick", 18])
   
tpl = "i am {name:s}, age {age:d}".format(name="nick", age=18)
   
tpl = "i am {name:s}, age {age:d}".format(**{"name": "nick", "age": 18})
  
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
  
tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
  
tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)