day_5装饰器、字符串格式化、序列化、内置模块、生成器、迭代器之篇】

#装饰器格式：@+函数名
def outer(func):
    def inner(arg):  #原函数传递一个参数
        print(‘before‘)
        # func()   #func：表示原函数
        # return func()  程序遇到return时则不执行下面函数
        ret = func(arg) #func：表示获取原函数返回值
        print(‘after‘)
        return ret #打印原函数返回值
    return func   #当函数名在带（）时表示，此时函数名代表整个函数，如加（）-》表示执行函数
#自动执行outer函数并且将下面的函数名F1当做参数传递
#将ouetr函数的返回值，重新赋值给F1

def outer(func):
    def inner(*arg,**kwargs):
        print(‘before‘)
        # func()   #func：表示原函数
        # return func()  程序遇到return时则不执行下面函数
        ret = func(*arg,**kwargs) #func：表示获取原函数返回值
        print(‘after‘)
        return ret #打印原函数返回值
    return func   #当函数名在带（）时表示，此时函数名代表整个函数，如加（）-》表示执行函数
@outer
def f1(arg):   #f1：原函数   #当f1里面传递几个参数时，那么装饰器中的函数体inner也需要传递给几个参数
    print(arg)

@outer
def f2(arg1,arg2):  #传递多个参数时
    print("F2")

USER_INFO={}   #定义一个空的字典
USER_INFO[‘is_login‘]  #字典取值形式为key, Value形式，如果此时只取key,不取value时，系统则报错
#字典取值形式为key, Value形式，如果此时字典中没有value时，可定义一个None值，这样当取不到字典中的value值，则系统返回None值
USER_INFO.get(‘is_login‘,None)
#定义一个装饰器
def check_login(func):  #03此时func只的是check_admin中inner函数
    def inner(*args,**kwargs):
        if USER_INFO.get(‘is_login‘,None): #默认情况下，用户不存在，则返回值为None
            ret1 = func(*args,**kwargs)   # 04此时func代表指的check_admin-》inner函数下
            return ret1    #注意ret后面不能加（），如添加（）：表示执行函数
        else:
            print("请登入！！！")
#及判断登入和权限
def check_admin(func):
    def inner(*args,**kwargs):
            if USER_INFO.get(‘user_type‘,None)==2:  #2表示超级管理员
                ret2 = func(*args,**kwargs)  #此时func为原来index函数
                return ret2  #此时ret2返回值传输给check_login装饰器中的ret2
            else:
                print("无权限查看")
    return inner
#双层装饰器==》嵌套函数，装饰器是从下往上解释，执行是从上往下执行
@check_login  #02 装饰器接着把check_admin和（check_admin、index）当做一个参数传递给check_login下面inner函数
@check_admin #01 装饰器把将check_admin和index当做一个参数传递给inner函数，
def index():
    """
    管理员功能
    :return:
    """
    print(‘Index‘)

#向右对齐且宽度为10个字节
s = "i am %(name)+10s,%(age)d"%{‘name‘:‘lcj‘,‘age‘:123} #将字典中的元素按照key,value形式传递name,age
print(s)

#向左对齐且宽度为10个字节
s = "i am %(name)-10s,%(age)d"%{‘name‘:‘lcj‘,‘age‘:123} #将字典中的元素按照key,value形式传递name,age
print(s)

•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；）
 •%，当字符串中存在格式化标志时，需要用 %%表示一个百分号

 
注：Python中百分号格式化是不存在自动将整数转换成二进制表示的方式

#将元素传递给占位符
n1 = "i am is %s" %"lcj"
print(n1)
#将元祖中的元祖依次传递给占位符%s %d
n2 = "i am %s age %d"%("lcj",18)
print(n2)
#将字典中的每一个元素指定传递给占位符
n3 = "i am %(name)s age%(age)d"%{"name":"lcj","age":18}
print(n3)
#取小数点前2位并按照四舍五入取值
n4 = "percent %.2f"%99.885
print(n4)
#定点取小数
n5 = "i am %(pp).2f"%{"pp":123.45621,}
print(n5)
#
n6 = "i am %.2f %%"%{"pp":123.4732,}
print(n6)
#c:将数字转换至unicode对应的值，10进制范围为0<=i<=114111(py27则只支持0-255)，字符：将字符添加至指定位置
n7 = "lcj %c----%o----%x---%e"%(65,15,15,1000000000)
print(n7)
n8 = "lcj %"
print(n8)
#在格式化字符串中，出现占位符（%s %d %f），那么需要用了两个%%号输出时表示一个%号（转移效果）
n9 ="name %s %%"%("lcj")
print(n9)

s = "i am name %s,age %d"%(‘lcj‘,123)  #lcj传递给name,123传递给age
print(s)

#指定传值
s = "i am %(name)s,%(age)d"%{‘name‘:‘lcj‘,‘age‘:123} #将字典中的元素按照key,value形式传递name,age
print(s)

•传入” 字符串类型 “的参数 •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位）

#format顺序传值给站位符{}
n1 = "i am {},age{},{}".format("lcj",15,‘yxy‘)
print(n1)
#将列表中的每一个元素顺序添加至占位符中，如果列表前不添加*号，则把列表中所有元素当做一个元素进行传值
n2 = "i am {},age{},{}".format(*["lcj",18,‘yxy‘])
print(n2)
#按照索引方式进行传值
n3 = "i am {0},age{1},really{0}".format("lcj",13)
print(n3)
#将列表中的元素按照索引方式进行传值
n4 = "i am {0},age{1},really{0}".format(*["lcj",13])
print(n4)
#指定参数进行传值
n5 = "i am {name},age{age},really{age}".format(name="lcj",age = 12)
print(n5)
#将字典中元素指定传值
n6 = "i am {name},age{age},really{name}".format(**{"name":"lcj","age":12})
print(n6)
#按照索引中索引进行传值：0-》表示第一个列表，第二个0:》表示取第一个列表中的第一个元素
n7= "i am {0[0]},age{0[1]},really{0[2]}".format([1,2,3,],[4,5,6,])
print(n7)
#依次给站位符传递“字符串”，“数字”，“浮点数”
n8 = "i am {:s},age{:d},really{:.2f}".format("lcj",19,19.823)
print(n8)
#将列表中各元素按照字符串和数字依次进行传递，参数传递给%s %d的位置要一致
n9 = "i am {:s},age{:d}".format(*["lcj",19])
print(n9)
#给占位符s,d指定参数
n10 = "i am {name:s},age{age:d}".format(name=‘lcj‘,age=20)
print(n10)
#给占位符按照字典方式进行传值
n11 = "i am {name:s},age{age:d}".format(**{"name":"xiaoluo","age":19})
print(n11)
#把传递参数按照“b:二进制，o:八进制，d:十进制，x:十六机制”方式进行传给占位符
n12 = "number:{:b},{:o},{:d},{:x},{:X}".format(15,15,15,15,15,15.876,12)
print(n12)
#按照下标对占位符进行传值
n13 = "number:{0:b},{0:o},{0:d},{0:x},{0:X}".format(16)
print(n13)
#给站位符指定参数进行传值
n14 = "number:{num:b},{num:o},{num:d},{num:x},{num:X},{num:%}".format(num=17)
print(14)

#format中单个%表示百分符号即把传递参数向前进2位并保留小数位
n7 = "---{:%}".format(0.33333)
print(n7)
#保留小数点前两位
n8 = "---{:.2%}".format(0.33333)
print(n8)

import json
#将python中字符串形式转化成基本数据类型
s1 = ‘{"name":"lcj"}‘
ret = json.loads(s1)
print(ret,type(ret))

#生成器标志：yield，使用函数创建
def func():
    print(111)
    yield 1
    print(2222)
    yield 2
    print(33333)
    yield 3
ret = func()
r1=ret.__next__()#进入函数找到yield,获取yield后面的数据
print(r1)
r2=ret.__next__()#进入函数找到yield,获取yield后面的数据
print(r2)
r3=ret.__next__()#进入函数找到yield,获取yield后面的数据
print(r3)

def d():
    return ‘lcj‘

def c():
    r=d()
    return r

def b():
    r=c()
    return r
def a():
    r=b()
    print(r)
a()

def func(n):
    n += 1
    if n >=4:  #当递归参数大于等于4，则返回end,否则继续
        return ‘end‘
    return func(n)
ret =func(0)
print(ret)