双层装饰器示例
__author__ = 'Golden'
#!/usr/bin/env python
# -*- coding:utf-8 -*-
USER_INFO = {}
def check_login(func):
def inner(*args,**kwargs):
#如果不存在给定默认值None
if USER_INFO. get (" is_login ",None):
ret = func(*args,**kwargs)
return ret
else :
print(" 请登录！ ")
return inner
def check_admin(func):
def inner(*args,**kwargs):
if USER_INFO. get ('user_type',None) == 2:
ret = func(*args,**kwargs)
return ret
else :
print(" 无权限查看 ")
return inner
@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'] = 2else :
USER_INFO['is_login'] = True USER_INFO['user_type'] = 1def main():
while True:
inp = input(" 1：登录；2：查看信息；3：超级管理员管理 ")
if inp == " 1 ":
login()
elif inp == " 2 ":
home()
elif inp == " 3 ":
index()
main()
字符串格式化Python的字符串格式化有两种方式：百分号方式、format方式。
百分号方式 %[(name)][flags][width].[precision]typecode (name)可选，用于选择指定的key。s = " %s %d "%('alex',23)
print(s)
s = " %(name)s %(age)d "%{'name':'alex','age':123}
print(s)
flags可选，可供选择的值有：+：右对齐，正数前加"+"，负数前加"-"。
s = " test%(name)+10stest %(age)d "%{'name':'alex','age':123}
print(s)
-：左对齐，正数前无符号，负数前加"-"。
s = " test%(name)-10stest %(age)d "%{'name':'alex','age':123}
print(s)
空格：右对齐，正数前加空格，负数前加 "-"。
0：右对齐，正数前无符号，负数前加"-"，用0填充空白处。
width可选，占用宽度。 .precision可选，小数点后保留的位数。s = " test%(name)-10stest test%(age).2ftest "%{'name':'alex','age':123.1234567}
print(s)
typecode必选s：获取传入对象的_str_方法的返回值，并将其格式化到指定位置。
r：获取传入对象的_repr_方法的返回值，并将其格式化到指定位置。
c：整数，将数字装换成其unicode对应的值，10进制范围为0<=i<=1114111（py27则只支持0--255），将字符添加到指定位置。
o：将整数转换成八进制表示，并将其格式化到指定位置。
x：将整数转换成十六进制表示，并将其格式化到指定位置。
s = " test %c---%o---%x "%(65,15,15)
print(s)
d：将整数、浮点数转换成十进制表示，并将其格式化到指定位置。
e：将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）。
E：将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）。
s = " test %e %E "%(1000000000000000,1000000000000000)
print(s)
f：将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）。
F：同上。
g：自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学技术则是e）。
G：自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学技术则是E）。
%：定字符串中存在格式化标志时，需要用%%表示一个百分号。
格式化时，字符串中出现占位符%，需要用%%输出%。
s = " alex % "
print(s)
s = " alex %s %% " %('SB')
print(s)
注意：python中百分号格式化是不存在自动将整数转换成二进制表示的方式。
Format方式 [[fill]align][sign][#][width][,][.precision][type] fill【可选】空白处填充的字符。 align【可选】对齐方式（需配个width使用）<：内容左对齐
>：内容右对齐（默认）
=：内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。即使：符号+填充物+数字。
^：内容居中。
s = " ---{:a^20s}---- ".format('alex')
print(s)
sign【可选】有无符号数字。+：正号加正，负号加负。
-：正号不变，负号加负。
空格：正号空格，负号加负。
s = " ---{:a^20s}----{:+d} ".format('alex',123)
print(s)
#【可选】对于二进制、八进制、十六进制，如果加上#，会显示0b/0o/0x，否则不显示。 ,【可选】为数字添加分隔符，如1,000,000 width【可选】格式化位所占宽度。 .precision【可选】小数位保留精度。 type【可选】格式化类型b：将10进制整数自动转换成2进制显示然后格式化。
s = " ---{:a^20s}----{:+d}----{:#b} ".format('alex',123,15)
print(s)
%：显示百分比（默认显示小数点后6位）。
s = " test {:%} ".format(0.234567)
print(s)
s = " test {:.2%} ".format(0.234567)
print(s)
总结：
s = " i am {},age {},{} ".format(" seven ",18," alex ")
s = " i am {},age {},{} ".format(*[" seven ",18," alex "])s = " i am {0},age {1},{0} ".format(" seven ",18)
s = " i am {0},age {1},{0} ".format(*[" seven ",18])s = " i am {name},age {age},{name} ".format(name=" seven ",age=18)
s = " i am {name},age {age},{name} ".format(**{" name ":" seven "," age ":18})
s = " i am {0[0]},age {0[1]},{0[2]} ".format([1,2,3],[11,22,33])s = " i am {:s},age {:d},{:f} ".format(" seven ",18,88888.1)
s = " i am {:s},age {:d} ".format(" seven ",18)
s = " i am {name:s},age {age:d} ".format(name=" seven ",age=18)
s = " i am {name:s},age {age:d} ".format(**{" name ":" seven "," age ":18})
s = " numbers:{:b},{:o},{:d},{:x},{:X},{:%} ".format(15,15,15,15,15,0.78912)
s = " numbers:{0:b},{0:o},{0:d},{0:x},{0:X},{0:%} ".format(15)
生成器#普通函数
def func():
return 123
ret = func()
#生成器
def func():
print(" start ")
yield 1
print(222)
yield 2
print(333)
yield 3
ret01 = func()
print(ret01)
'''
for i in ret01:
print(i)
'''
#进入函数找到yield，获取yield后面的数据
r = ret01.__next__()
print(r)
r = ret01.__next__()
print(r)
r = ret01.__next__()
print(r)
基于生成器实现range功能def myrange(arg):
start = 0
while True:
if start > arg:
return
yield start
start += 1
ret = myrange(3)
r = ret.__next__()
print(r)
r = ret.__next__()
print(r)
r = ret.__next__()
print(r)
r = ret.__next__()
print(r)
迭代器def myrange(arg):
start = 0
while True:
if start > arg:
return
yield start
start += 1
ret = myrange(3)
for item in ret:
print(item)
递归函数的调用
def d():
return " 123 "
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 >= 10:
return 'end',n
return func(n)
r = func(1)
print(r)
模块添加一个模块路径
import sys
sys.path.append('E:\\')
导入模块
#导入模块s3
import s3
#引用s3中login()函数
s3.login()
单模块使用import导入，嵌套在文件夹下使用from xxx import xxx或from xxx import xxx as xx。
第三方模块
安装第三方模块
pip3安装：python3 -m pip3 install xxxx或python2 -m pip install xxxx。
源码安装：下载，解压，进入解压目录python setup.py install。
序列化import json（基本数据类型）和import pickle（python任何类型）
import json
dic = {'k1':'v1'}
#将python基本数据类型转换成字符串形式
result = json.dumps(dic)
print(result,type(result))
s1 = '{" k1 ":123}'
#将python字符串形式转化成基本数据类型
dic = json.loads(s1)
print(dic,type(dic))
获取天气相关json数据
import requests
import json
response = requests. get ('http: //wthrcdn.etouch.cn/weather_mini?city=武汉')
response.encoding = 'utf-8'
print(response.text,type(response.text))
dic = json.loads(response.text)
print(type(dic))
loads反序列化是，一定注意引号的使用格式
import json
r = json.dumps([11,22,33])#注意外面用单引号，里面用双引号
li = '[" alex "," eric "]'ret = json.loads(li)
print(ret,type(ret))
dump与load
import json
li = [11,22,44]json.dump(li,open('db','w'))
li = json.load(open('db','r'))
print(type(li))
pickle仅仅python可用
#pickle仅仅python之间调用
import pickle
li = [11,22,33]r = pickle.dumps(li)
print(r)
ret = pickle.loads(r)
print(ret)
#二进制方式
pickle.dump(li,open('db','wb'))
ret = pickle.load(open('db','rb'))
print(ret)
json更适合跨语言，基本数据类型的序列化。
pickle针对python所有类型的序列化，仅仅适用于python。
timeimport time
#时间戳1970年1月1号0点开始的秒数（unix版本正式上线）
print(time.time())
#当前系统时间
print(time.ctime())
print(time.ctime(time.time()-86400))
#将时间戳转换成struct_time格式
print(time.gmtime())
time_obj = time.gmtime()
print(time_obj.tm_year,time_obj.tm_mday)
#本地时间（struct_time格式）
print(time.localtime())
#struct_time转成时间戳
print(time.mktime(time_obj))
#延迟4秒后继续执行
#time.sleep(4)
print(" ---- ")
#将struct_time格式转换成指定的字符串格式
tm = time.strftime(" %Y-%m-%d %H:%M:%S ",time.localtime())
print(tm)
#将字符串格式转换成struct_time格式
tm = time.strptime(" 2016-12-14 "," %Y-%m-%d ")
tm_1 = time.strptime(" 2016-12-12 8:58 "," %Y-%m-%d %H:%M ")
print(tm)
print(tm_1)
#字符串格式转换成时间戳
tm = time.mktime(time.strptime(" 2016-12-14 ",'%Y-%m-%d'))
print(tm)
datetimeimport datetime
import time
#输出格式2016-01-01
print(datetime.date.today())
#将时间戳转换成日期格式
print(datetime.date.fromtimestamp(time.time()-864400))
#详细时间
current_time = datetime.datetime.now()
print(current_time)
#返回struct_time格式
print(current_time.timetuple())
#days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0
#加10天
print(datetime.datetime.now()+datetime.timedelta(days=10))
#减10天
print(datetime.datetime.now()+datetime.timedelta(days=-10))
#减10小时
print(datetime.datetime.now()+datetime.timedelta(hours=-10))
#加130秒
print(datetime.datetime.now()+datetime.timedelta(seconds=-130))
#时间替换
current_time = datetime.datetime.now()
print(current_time.replace(2014,9,12))
#将字符串转换成日期格式
print(datetime.datetime.strptime(" 23/12/14 09:13 "," %d/%m/%y %H:%M "))
#时间比较
time_obj = current_time.replace(2015,5)
print(current_time > time_obj)
print(type(time_obj))
loggingimport logging
logging.warning(" user [alex] attempted wrong password more then 3 times ")logging.critical(" server is down ")
记录日志到文件
logging.basicConfig(filename='example.log',level=logging.INFO)
logging.debug('This message should go to the log file')
logging.info('So should this ')
logging.warning('And this ,too')
注意：只有级别比INFO高或相等才会被记录到文件中。
记录时间、日志到文件
logging.basicConfig(filename='example.log',level=logging.INFO,format='%(asctime)s %(message)s',datefmt='%m/%d/%Y %I:%M:%S %p')
logging.debug('This message should go to the log file')
logging.info('So should this ')
logging.warning('And this ,too')
同时打印在屏幕和文件里
import logging
#获取日志的对象
logger = logging.getLogger('TEST-LOG')
#设定一个全局的日志级别
logger.setLevel(logging.INFO)
#输出到屏幕
ch = logging.StreamHandler()
#设定输出级别
ch.setLevel(logging.DEBUG)
#写入日志文件
fh = logging.FileHandler(" access.log ")
#设定写入的级别
fh.setLevel(logging.WARNING)
fh_err = logging.FileHandler(" error.log ")
fh_err.setLevel(logging.ERROR)
#格式：时间 名字 信息
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
formatter_for_file = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
formatter_for_file_err= logging.Formatter('%(asctime)s %(filename)s - %(levelname)s - %(message)s')
#屏幕输出格式
ch.setFormatter(formatter)
#文件记录格式
fh.setFormatter(formatter_for_file)
fh_err.setFormatter(formatter_for_file_err)
#添加到logger
logger.addHandler(ch)
logger.addHandler(fh)
logger.addHandler(fh_err)
#打印日志
logger.debug('debug message')
logger.info('info message')
logger.warn('warn message')
logger.error('error message')
logger.critical('critical message')
日志记录格式
%(filename)s：程序文件路径
%(funcName)s：函数名
%(lineno)d：行数
%(module)：模块名
%(processName)s：进程名
%(process)d：进程id
%(thread)d：线程id