双层装饰器示例

__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'] = 2
else:
USER_INFO['is_login'] = True
USER_INFO['user_type'] = 1
def main():
while True:
inp = input("1：登录；2：查看信息；3：超级管理员管理")
":
login()
elif inp == "":
home()
elif inp == "":
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():
"
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。

time

import 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)

datetime

import 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))

logging

import 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

巴特西

跟着老男孩教育学Python开发【第四篇】：模块