python笔记

                       python笔记 - day5                        

参考：

http://www.cnblogs.com/wupeiqi/articles/5484747.html

http://www.cnblogs.com/alex3714/articles/5161349.html

http://www.cnblogs.com/wupeiqi/articles/5501365.html

大纲：

双层装饰器

python字符串格式化

python生成器

python迭代器

python模块介绍

python序列化之json

python序列化之pickle

python时间处理之time模块

python日志处理之logging模块

模块：

logging
time/datetime
json/pickle
requests

 双层装饰器：

方法一，不使用装饰器：

#!/usr/bin/python env
#_*_coding:utf-8 _*_

USER_INFO = {}

def check_login(func):
    def inner(*args,**kwargs):
        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('is_login',None):
            if USER_INFO.get('user_type') == 2:
                ret = func(*args,**kwargs)
                return ret
            else:
                print("无权限查看.")
        else:
            print("请登录")
    return inner

@check_admin
def index():
    print("Index,admin")

@check_login
def home():
    print("home,command")

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.login  2.查看信息  3.用户管理")
        if inp == '1':
            login()
        elif inp == '2':
            home()
        elif inp == '3':
            index()
main()

 方法二，使用双层装饰器：

#!/usr/bin/python env
#_*_coding:utf-8 _*_

USER_INFO = {}

def check_login(func):
    def inner(*args,**kwargs):
        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') == 2:
            ret = func(*args,**kwargs)
            return ret
        else:
            print("无权限查看.")
    return inner

@check_login
@check_admin
def index():
    print("Index,admin")

@check_login
def home():
    print("home,command")

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.login  2.查看信息  3.用户管理")
        if inp == '1':
            login()
        elif inp == '2':
            home()
        elif inp == '3':
            index()
main()

#双层装饰器，解释，从下往上解释，执行，从上往下执行；

 字符串格式化(%，format)

% 号方式，字符串格式化：

tp1 = "i am %s " % 'alex'
print(tp1)
结果：i am alex 

tp1 = "i am %s age %d"%('alex',18)
print(tp1)
结果：i am alex age 18

【传入的是字典格式】
tp1 = "i am %(name)s  age  %(age)d" %{"name":"alex","age":18}
print(tp1)
结果：i am alex  age  18

【取小数点后两位】
tp1 = "percent %.2f"%88.234567
print(tp1)
结果：percent 88.23 

【以字典形式传入，取小数点后两位】
tp1 = "i am %(pp).2f"%{"pp":123.234345,}
print(tp1)
结果：123.23

【以字典形式传入，取小数点后两位，并加上 % 号】
tpl = "i am %(pp).2f %% "%{"pp": 123.425556, }
print(tpl)
结果：i am 123.43 % 

format，字符串格式化：

【顺序传入参数】
t1 = "i am {},age{},{}".format("seven",18,'alex')
print(t1)
结果：i am seven,age18,alex

【*[] , 以列表的形式传入参数】
t1 = "i am {},age {},{}".format(*['seven',18,'alex'])
print(t1)
结果：i am seven,age 18,alex

【根据数字定位，字符串输出】
t2 = "i am {0},age {1},really{0}".format("seven",19)
print(t2)
结果：i am seven,age 19,reallyseven

【*[] ,根据数字定位，字符串输出，传入的是个列表】
t2 = "i am {0}, age{1}, really{0}".format(*["seven",18])
print(t2)
结果：i am seven, age18, reallyseven

【根据指定的字符串来格式化输出】
t3 = "i am {name}, age{age},really{name}".format(name="seven",age=18)
print(t3)
结果：i am seven, age18,reallyseven

【**{}，根据指定的字符串来格式化输出，并且是以字典的形式传入】
t3 = "i am {name}, age{age}, really {name}".format(**{"name":"seven","age":18})
print(t3)

【通过列表取值的方式，格式化输出】
t4 = "i am {0[0]}, age{0[1]}, really {0[2]}".format([1,2,3],[11,22,33])
print(t4)
结果：i am 1, age2, really 3

【根据类型，格式化输出】
t5 = "i am {:s}, age{:d},money {:f} ".format("seveb",18, 888888.1)
print(t5)
结果：i am seveb, age18,money 888888.100000 

【*[]，列表形式】
t6 = "i am {:s}, age{:d}".format(*["seven",18])
print(t6)
结果：i am seven, age18

【指定字符串，格式化输出】
t7 = "i am {name:s},age{age:d}".format(name="seven",age=18)
print(t7)
结果：i am seven,age18

【**{}，传入的字典格式】
t8 = "i am {name:s},age {age:d}".format(**{"name":"seven","age":18})
print(t8)
结果：i am seven,age 18

【2进制，八进制，十进制，16进制，16进制，百分比】
【下面三个例子，结果一样，只不过传入值得形式不一样】
t9 = "numbers:{:b},{:o},{:d},{:x},{:X},{:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
print(t9)
结果：numbers:1111,17,15,f,F,1587.623000%

t9 = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X},{0:%}".format(15)
print(t9)
结果：numbers: 1111,17,15,f,F,1500.000000%

t99 = "numbers:{num:b},{num:o},{num:d},{num:x},{num:X},{num:%}".format(num=15)
print(t9)
结果：numbers:1111,17,15,f,F,1500.000000%

python生成器：

例一：
def func():
    print("start")
    yield 1
    yield 2
    yield 3
ret = func()

for i in ret:
    print(i)
结果：
start
1
2
3

例二：
def func():
    print(11111)
    yield 1
    print(22222)
    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)
结果：
11111
1
22222
2
33333
3

迭代器，生成器，模拟一个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)
结果：
0
1
2
3

函数递归：
def func(n):
    n +=1
    if n >= 4:
        return 'end'
    return func(n)

r = func(1)
print(r)
结果：end

python模块：

t6.py文件内容：

def login():
    print("login")

def loginout():
    print('loginout')

t7文件里导入并执行login()模块：
import t6
t6.login()

导入模块的几种方法：
（1）improt
调用：模块名.函数名

（2）from t6 import login
调用：可以直接调用  函数名调用

（3）from t6 import *
导入t6模块下的所有函数

（4）from t6 import login as t6_commons
应用于，在一个py文件中，导入不同模块，有相同函数名冲突时，可以给其中一个模块设置一个别名；

总结：同一级目录下用import导入
       否则用  from  导入；

打印python执行程序，查找文件路径：
import sys
for item in sys.path:
    print(item)

【把 E 目录，添加到python查找的路径中】
sys.path.append('E:\')

【安装第三方模块】
pip3 install requests

源码方式安装模块：
1.把下载的源码包解压了
2.进入到源码包目录
3.运行 python setup.py install，如果不依赖其他内容，一下就安装成功了；

json，pickle 序列化：

【json.dumps:将python基本数据类型转化成字符串形式】
dic = {"k1":"v1"}
print(dic,type(dic))
结果：{'k1': 'v1'} <class 'dict'>

result=json.dumps(dic)
print(result,type(result))
结果：{"k1": "v1"} <class 'str'>

【json.loads:将字符串，转换成python对应格式的数据类型】
s1 = '{"k1":123}'  #通过loads，反序列话的时候，里面必须要使用双引号；因为需要跨平台
print(s1,type(s1))
结果：{"k1":123} <class 'str'>

dic = json.loads(s1)
print(dic,type(dic))
结果：{'k1': 123} <class 'dict'>

import requests
import json

response = requests.get('http://wthrcdn.etouch.cn/weather_mini?city=北京')
#发了一个http请求，把请求的内容返回给response，封装到response对象里面
response.encoding = 'utf-8'

dic = json.loads(response.text)  #.text，获取http请求的内容；
print(dic,type(dic))

结果：
{'data': {'forecast': [{'fengxiang': '无持续风向', 'type': '多云', 'date': '27日星期三', 'low': '低温 25℃', 'fengli': '微风级', 'high': '高温 34℃'}, {'fengxiang': '无持续风向', 'type': '雷阵雨', 'date': '28日星期四', 'low': '低温 23℃', 'fengli': '微风级', 'high': '高温 33℃'}, {'fengxiang': '无持续风向', 'type': '多云', 'date': '29日星期五', 'low': '低温 24℃', 'fengli': '微风级', 'high': '高温 32℃'}, {'fengxiang': '无持续风向', 'type': '阴', 'date': '30日星期六', 'low': '低温 26℃', 'fengli': '微风级', 'high': '高温 32℃'}, {'fengxiang': '无持续风向', 'type': '晴', 'date': '31日星期天', 'low': '低温 26℃', 'fengli': '微风级', 'high': '高温 34℃'}], 'yesterday': {'type': '晴', 'date': '26日星期二', 'low': '低温 24℃', 'fl': '微风', 'fx': '无持续风向', 'high': '高温 33℃'}, 'aqi': '141', 'wendu': '33', 'ganmao': '各项气象条件适宜，发生感冒机率较低。但请避免长期处于空调房间中，以防感冒。', 'city': '北京'}, 'status': 1000, 'desc': 'OK'} <class 'dict'>



【json.dump，先序列化，然后写到文件内】
import json
li = [11,22,33]
json.dump(li,open('db','w'))

【json.load，先打开这个文件，然后把字符串转换成列表】
import json
li = json.load(open('db','r'))
print(type(li),li)

pickle，序列化，只能在python平台使用：

【pickle.dumps，序列化成字符串】
import pickle
li = [11,22,33]
r = pickle.dumps(li)
print(r,type(r))
结果：b'x80x03]qx00(Kx0bKx16K!e.' <class 'bytes'>

【pickle.loads，反序列化】
import pickle
li = [11,22,33]
r = pickle.dumps(li)
result = pickle.loads(r)
print(result,type(result))

【pickle.dump，序列化至文件内，】
import pickle
lt = [22,33,44]
pickle.dump(lt,open('db','wb'))  #这里要加“b”

【pickle.load，读文件，也要加b】
import pickle
ret = pickle.load(open('db','rb'))
print(ret,type(ret))

总结：
#json：更加适合跨语言序列化，但是只支持基本数据类型序列化
#pickle仅适用于python，pickle支持所有的python数据类型序列化；

 python时间处理之time模块：

import time
【返回时间戳】
print(time.time())

【返回当前时间】
print(time.ctime())

【返回一天前的时间】
print(time.ctime(time.time()-86400))

【函数返回time.struct_time类型的对象】
time_obj = time.gmtime()
print(time_obj)
结果：time.struct_time(tm_year=2016, tm_mon=7, tm_mday=27, tm_hour=8, tm_min=52, tm_sec=26, tm_wday=2, tm_yday=209, tm_isdst=0)
格式化输出：
print(time_obj.tm_year,time_obj.tm_mon,time_obj.tm_mday)

print("{year}-{month}".format(year=time_obj.tm_year,month=time_obj.tm_mon))

【以time.struct_time类型，打印本地时间】
print(time.localtime())

【转换成时间戳】
time_obj = time.gmtime()
print(time.mktime(time_obj))

【延时2秒】
time.sleep(2)

【打印UTC，世界标准时间，北京时区是东八区，领先UTC八个小时】
print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime())) 

【本地时间】
print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())) 

【把time.struct_time类型时间，转换成时间戳】
tm = time.strptime("2016-05-6 15:06:33","%Y-%m-%d %H:%M:%S")
print(tm)
print(time.mktime(tm))

 python时间处理之datetime模块：

import datetime

【打印当前，年，月，日】
print(datetime.date.today())

【打印当前时间，精确到微秒】
current_time = datetime.datetime.now() 
print(current_time)

【转成time.struct_time格式时间】
current_time = datetime.datetime.now()
print(current_time.timetuple())

【加十天】
print(datetime.datetime.now() +datetime.timedelta(days=10))
【减十天】
print(datetime.datetime.now() +datetime.timedelta(days=-10))
【减十个小时】
print(datetime.datetime.now() +datetime.timedelta(hours=-10))
【加120s】
print(datetime.datetime.now() +datetime.timedelta(seconds=120))

【替换成指定的时间】
cr_time = datetime.datetime.now()
print(cr_time.replace(2014,9,12))
结果：2014-09-12 17:28:17.522893

【格式化输出】
print(datetime.datetime.strptime("21/11/06 16:30","%d/%m/%y %H:%M"))

【替换成指定时间后，类型是<class 'datetime.datetime'>】
current_time = datetime.datetime.now()
time_obj = current_time.replace(2015,5)
print(time_obj,type(time_obj))
结果：2015-05-27 17:34:13.350245 <class 'datetime.datetime'>

【对比时间大小，取指定时间范围使用】
current_time = datetime.datetime.now()
time_obj = current_time.replace(2015,5)
print(current_time>time_obj)

 python日志处理之logging模块

【打印日志】
import logging
logging.warning("user [alex] attempted wrong password more than 3 times")
logging.critical("server is down")

【这里定义只有级别是INFO以上的，才把日志写入到文件里面】
import logging
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 the, too')

【给打印日志加上，打印时间】
import logging
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 the, too')

同时输出log到文件和屏幕：

#!/usr/bin/python env
#_*_coding:utf-8 _*_


# loggers:
# handlers：把log发送到不同的地方；
# filter：过滤文件内的特殊字符
# formatters：格式化输出
import logging

logger = logging.getLogger('TEST-LOG') #不指定是root；获取到logger对象
logger.setLevel(logging.DEBUG)  #设置一个全局打印日志级别

ch = logging.StreamHandler() #输出日志到屏幕
ch.setLevel(logging.DEBUG) #设置屏幕输出的日志级别

fh = logging.FileHandler('access.log')  #输出日志到文件
fh.setLevel(logging.WARNING)  #设置文件输出日志的级别

#增加一个error日志，这里需要改动
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')
err_formatter = logging.Formatter('%(asctime)s - %(filename)s - %(funcName)s - %(lineno)s - %(name)s - %(levelname)s - %(message)s')
#设置日志输出格式
#%(asctime)s :时间格式
#%(filename)s：执行程序的名称
#%(funcName)s:定位函数
#%(lineno)s：定义是哪行打印的
#%(name)s ：不指定是root，这里是上面定义的 TEST-LOG
#%(levelname)s：日志级别
#%(message)s：日志的详细信息

#增加一个error日志，这里需要改动
ch.setFormatter(formatter)  #设置屏幕输出日志格式，调用的上面
fh.setFormatter(formatter_for_file)  #设置文件输出日志格式，调用的上面
fh_err.setFormatter(err_formatter)   #设置error日志输入格式，调用的上面

【把这个日志打印到指定的handler里面，也就是文件里面】
#增加打印一个error日志，这里需要改动
logger.addHandler(ch)  #打印到屏幕
logger.addHandler(fh)  #输出日志到access.log文件
logger.addHandler(fh_err)  #输出日志到error.log文件
　　　　　　　　　　
logger.debug('debug message')
logger.info('info message')
logger.warn('warn message')
logger.error('error message')
logger.critical('critical message')

总结：
#局部打印的优先级不能低于全局的，否则只会应用全局的日志打印级别
#为什么要设置全局级别：可以操作输出日志到多个文件

 日志格式化，可以使用的参数：