python的学习之路day5

USER_INFO = {}def check_login(func):
def inner(*args, **kwargs):
if USER_INFO.get("is_login", None):
# 用get方法拿字典里面的内容，如果字典里面没有我们要拿的参数，不会报错，给他默认返回的为None
ret = func(*args, **kwargs)
return ret
else:
print("请登录") return innerdef check_admin(func): # 判断是否为管理员用户
def inner(*args, **kwargs):
if USER_INFO.get("is_login", None):
if USER_INFO.get("user_type", None) == 2: # 如果用户类型等于2，表示为管理员用户
ret = func(*args, **kwargs)
return ret
else:
print("无权限查看") # 否者无权限查看
else:
print("请登录") return inner@check_admin
def index(): # 超级管理员可以查看
print("index")@check_login
def home(): # 登录可以查看
"""
普通用户的功能
:return:
"""
print("home")def login(): # 登录
user = input("请输入用户名：")
if user == "admin":
USER_INFO["is_login"] = True
USER_INFO["user_type"] = 2
else: # 否者如果不为admin，表示登录的用户为普通用户
USER_INFO["is_login"] = True
USER_INFO["is_login"] = 1def main():
while True:
inp = input("1、登录；2、查看信息；3超级管理员\n>>>")
if inp == "":
login()
elif inp == "":
home()
elif inp == "":
index()main()

1、登录；2、查看信息；3超级管理员
>>>2
请登录
1、登录；2、查看信息；3超级管理员
>>>3
请登录
1、登录；2、查看信息；3超级管理员
>>>1
请输入用户名：user
1、登录；2、查看信息；3超级管理员
>>>2
home
1、登录；2、查看信息；3超级管理员
>>>3
无权限查看
1、登录；2、查看信息；3超级管理员
>>>1
请输入用户名：admin
1、登录；2、查看信息；3超级管理员
>>>2
home
1、登录；2、查看信息；3超级管理员
>>>3
index
1、登录；2、查看信息；3超级管理员
>>>

# 从版本以一中我们可以看到很多我们的check_admin里面重复了check_login的代码（check_admin又判断登录，又判断权限），
# 如果我们又加上了超级管理员，那我们就会又写一个重复的装饰器，
# 所以我们需要用到双层装饰器，先用check_login，判断是否登录，然后用check_admin判断是否为管理员
USER_INFO = {}def check_login(func):
def inner(*args, **kwargs):
if USER_INFO.get("is_login", None):
# 用get方法拿字典里面的内容，如果字典里面没有我们要拿的参数，不会报错，给他默认返回的为None
ret = func(*args, **kwargs)
return ret
else:
print("请登录") return innerdef check_admin(func): # 判断是否为管理员用户
def inner(*args, **kwargs):
if USER_INFO.get("user_type", None) == 2: # 如果用户类型等于2，表示为管理员用户
ret = func(*args, **kwargs)
return ret
else:
print("无权限查看") # 否者无权限查看 return inner# 为什么check_login写上面，我们从下向上看，从index()开始，
# 可以看到先用admin装饰后，比如变成了nindex这个函数，然后再用login装饰进行装饰，比如又变成了nnindex，然后python是从上向下执行，
# 所以python会执行nnindex，判断是否登录，然后在执行nindex，判断是否为管理员，如果没有登录，
# 提示登录，如果已经登录（不为管理员），提示无权限
@check_login
@check_admin
def index(): # 管理员可以查看
"""
管理员的功能
:return:
"""
print("index")@check_login
def home(): # 登录可以查看
"""
普通用户的功能
:return:
"""
print("home")def login(): # 登录
user = input("请输入用户名：")
if user == "admin":
USER_INFO["is_login"] = True
USER_INFO["user_type"] = 2
else: # 否者如果不为admin，表示登录的用户为普通用户
USER_INFO["is_login"] = True
USER_INFO["is_login"] = 1def main():
while True:
inp = input("1、登录；2、查看信息；3超级管理员\n>>>")
if inp == "":
login()
elif inp == "":
home()
elif inp == "":
index()main()

1、登录；2、查看信息；3超级管理员
>>>2
请登录
1、登录；2、查看信息；3超级管理员
>>>3
请登录
1、登录；2、查看信息；3超级管理员
>>>1
请输入用户名：user
1、登录；2、查看信息；3超级管理员
>>>2
home
1、登录；2、查看信息；3超级管理员
>>>3
无权限查看
1、登录；2、查看信息；3超级管理员
>>>1
请输入用户名：admin
1、登录；2、查看信息；3超级管理员
>>>2
home
1、登录；2、查看信息；3超级管理员
>>>3
index
1、登录；2、查看信息；3超级管理员
>>>

# 字符串格式化
# %[(name)] [flags] [width].[precision] typecode# 常规的格式化
string = "博客网址：www.cnblogs.com/%s，园龄：%d个月" % ("smelond", 1)
print(string)# %[(name)]可选，用于指定的key：
string = "博客网址：www.cnblogs.com/%(name)s，园龄：%(age)d个月" % {"name": "smelond", "age": 1} # 用字典方式
print(string)# flags 可选，可供选择的值有（听说没卵用）
# + 右对齐：正数前加正号，负数前加负号
# - 左对齐：正数前无符号，负数前加负号
# 空格 右对齐：正数前加空格，负数前加负号
# 0 右对齐：正数前无符号，负数前加负号；用0填充空白处
string = "博客网址：www.cnblogs.com/%(name)+20s,园龄：%(age)-10d个月" % {"name": "smelond", "age": 1} # 占有20个空格，smelond在其中，向右对齐
print(string)# width 可选，占有宽度# .precision 可选，小数点后保留的位数
string = "数值：%(p).2f" % {"p": 1.23656} # 在后面加上.然后数字，代表保留几位，有四舍五入功能
print(string)# typecode 必选
# s，获取传入对象的__str__方法的返回值，并将其格式化到指定位置
# r，获取传入对象的__repr__方法的返回值，并将其格式化到指定位置（面向对象内容）
# c，整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置
# o，将整数转换成 八 进制表示，并将其格式化到指定位置
# x，将整数转换成十六进制表示，并将其格式化到指定位置
string = "%c___%o___%x" % (65, 15, 15) # 将十进制转换为其他进制（A,17,f）
print(string)# d，将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置
# e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
# E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
# f， 将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
# F，同上
string = "%d--------%f--------%e--------%E-------%.2ef" % (100000000, 1.23456, 10000000, 10000000, 10000000)
print(string)# g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
# G，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
string = "%g-------%g-------%G-------%G" % (10000000, 100, 10000000, 100)
print(string)# %，当字符串中存在格式化标志时，需要用 %%表示一个百分号
string = "name:%s %% %%%%" % "smelond" # 如果需要输出一个%，但是前面已经有了一个占位符，那就需要输出%%才能代表一个%，否者会报错，需要输出%%，就需要%%%%
print(string)
#
# 注：Python中百分号格式化是不存在自动将整数转换成二进制表示的方式

博客网址：www.cnblogs.com/smelond，园龄：1个月
博客网址：www.cnblogs.com/smelond，园龄：1个月
博客网址：www.cnblogs.com/ smelond,园龄：1 个月
数值：1.24
A___17___f
100000000--------1.234560--------1.000000e+07--------1.000000E+07-------1.00e+07f
1e+07-------100-------1E+07-------100
name:smelond % %%

# 两个最基本的格式化
string = "asdfasgsdf__{0}__asdf__{0}__adhkg__{1}__".format(123, "smelond")
print(string) # asdfasgsdf__123__asdf__123__adhkg__smelond__
string = "___{name:s}___{age:d}___{name:s}".format(name="smelond", age=16)
print(string) # ___smelond___16___smelond# 一些常用的用法
# 空白处填充*，^字符居中,20个空格，s：字符串形式{:*^20s}
# +有符号数值,d:十进制{:+d}
# x 直接转换为16进制
# #如果后面输入的为x，那就转换为16进制后再前面加上0x{:#x}
string = "_____{:*^20s}_____{:+d}_____{:x}_____{:#x}".format("smelond", 123, 15, 15)
print(string) # _____******smelond*******_____+123_____f_____0xfstring = "百分比：{:%}".format(1.2345)
print(string) # 百分比：123.450000%

# 一些常用的用法
tpl = "i am {},age {},{}".format("seven", 16, "smelond")
print(tpl) # i am seven,age 16,smelondtpl = "i am {},age {},{}".format(*["seven", 16, "smelond"])
print(tpl) # i am seven,age 16,smelond,注意，如果是列表要在前面加上*tpl = "i am {0},age {1}, really {0}".format("seven", 16)
print(tpl) # i am seven,age 16, really seventpl = "i am {0},age {1}, really {0}".format(*["seven", 16])
print(tpl) # i am seven,age 16, really seven,列表需要加上*tpl = "i am {name}, age {age}, really {name}".format(name="smelond", age=16)
print(tpl) # i am smelond, age 16, really smelondtpl = "i am {name}, age {age}, really {name}".format(**{"name": "smelond", "age": 16})
print(tpl) # i am smelond, age 16, really smelond,注意，如果是字典需要加上两个*tpl = "i am {0[0]}, age {0[1]}, really {1[2]}".format([1, 2, 3], [11, 22, 33])
print(tpl) # i am 1, age 2, really 33,列表里面的列表tpl = "i am {:s}, age {:d}".format("smelond", 16)
print(tpl) # i am smelond, age 16tpl = "i am {name:s}, age {age:d}".format(name="smelond", age=16)
print(tpl) # i am smelond, age 16tpl = "i am {name:s}, age {age:d}".format(**{"name": "smelond", "age": 16})
print(tpl) # i am smelond, age 16,字典需要加上**tpl = "numbers:{:b},{:o},{:d},{:x},{:X},{:%}".format(15, 15, 15, 15, 15, 15.87612)
print(tpl) # s:1111,17,15,f,F,1500.000000%tpl = "numbers:{0:b},{0:o},{0:d},{0:x},{0:X},{0:%}".format(15)
print(tpl) # s:1111,17,15,f,F,1500.000000%tpl = "numbers:{num:b},{num:o},{num:d},{num:x},{num:X},{num:%}".format(num=15)
print(tpl) # s:1111,17,15,f,F,1500.000000%

# 普通函数
# def func():
# return 123
#
#
# ret = func() # 执行函数拿结果# 生成器
def func():
# print("start")
print(111)
yield 1
print(222)
yield 2
print(333)
yield 3 # 如果在函数里面出现了yield，这个函数就称之为生成器ret = func()
print(ret)
# for i in ret:
# print(i) # 输出
# 循环第一次的时候就进入func函数里面去，进入后拿走yield后面的值，所以输出1，然后循环第二次，
# 第二次进入func函数时，找到上一次结尾的位置，从结尾的位置又开始循环（往下走），所以就是输出2
# 然后第三次
r1 = ret.__next__() # 进入函数找到yield，获取yield后面的数据，然后我们就拿到了1
print(r1)
r2 = ret.__next__() # 进入函数找到yield，获取yield后面的数据，然后我们就拿到了2
print(r2)
r3 = ret.__next__() # 进入函数找到yield，获取yield后面的数据，然后我们就拿到了3
print(r3)# r4 = ret.__next__()
# print(r4) # 从函数里面可以看到没有第4个yield，所以这句要报错#输出：
111
1
222
2
333
3

# 基于生成器实现range功能
def myrange(arg): # 相当于这是一个生成器
start = 0
while True:
if start > arg:
return
yield start
start += 1ret = myrange(3)
# for i in ret:
# print(i)
r = ret.__next__()
print(r)
r = ret.__next__()
print(r)
r = ret.__next__()
print(r)
r = ret.__next__()
print(r)
# r = ret.__next__()
# print(r)#第四次肯定报错，因为只循环3次，从0开始输出：
0
1
2
3

# 一个递给另外一个，一个简单的原理
def d():
r = "end" # 将字符串end赋给r
return r # 返回一个变量rdef c():
r = d() # 拿到函数d的返回值
return rdef b():
r = c() # 拿到函数c的返回值
return rdef a():
r = b() # 拿到函数b的返回值
print(r) # 拿到结果后输出a() # 输出end# 递归
# 执行第一次时的效果
def func(n): # 现在n=1
n += 1 # n等于2
if n >= 4: # 当如果n>=4的时候
return "end" # 遇到return直接退出，然后返回一个字符串end
return func(n) # 上面if如果没执行，肯定会执行这句，返回func函数，现在的n=2r = func(1) # 传入实参1到func函数里去慢慢执行，然后接收返回值
print(r) #输出end

def func(n, x): # n=1,x=1.......n=2,x=2.......n=3,x=6
n += 1 # n=2.......n=3.......n=4
x *= n # x=x*n,x=2.......x=x*n,x=6.......x=x*n,x=24
if n >= 7: # 直到n等于7的时候，将x返回
return x
return func(n, x) # n=2,x=2.......n=3,x=6.......r = func(1, 1)
print(r)输出：5040

def func(num):
if num == 1:
return 1
return num * func(num - 1)x = func(7)
print(x)输出：5040

# 导入模块
# 单模块
import call_m # 直接调用当前目录下的call_m.py文件
import lib.commons # 调用lib目录下的commons.py文件
# 嵌套在文件夹下的模块
from lib import commons
from src import commons as xxx # 如果重名，我们可以用as给他做一个别名# call_m.login() # 输出里面的方法，就相当于调用了里面的函数
# lib.commons.logout()