1.多层装饰器

多层装饰器的原理是，装饰器装饰函数后，其实也是一个函数，这样又可以被装饰器装饰。 编译是从下至上进行的，执行时是从上至下进行。

#!/usr/bin/env python
# _*_coding:utf-8_*_
‘‘‘
 * Created on 2016/11/29 20:38.
 * @author: Chinge_Yang.
‘‘‘

USER_INFO = {}


# USER_INFO[‘is_login‘] = True
# USER_INFO[‘user_type‘] = 2


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‘, 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.超级管理员管理\n >>>")
        if inp == "1":
            login()
        elif inp == "2":
            home()
        elif inp == "3":
            index()
        elif inp == "q":
            exit()


main()

2.字符串格式化

Python的字符串格式化有两种方式: 百分号方式、format方式

百分号的方式相对来说比较老，而format方式则是比较先进的方式，企图替换古老的方式，目前两者并存。[PEP-3101]
This PEP proposes a new system for built-in string formatting operations, intended as a replacement for the existing ‘%‘ string formatting operator.

1.百分号方式

%[(name)][flags][width].[precision]typecode

• (name) 可选，用于选择指定的key
• flags 可选，可供选择的值有:
  + 右对齐；正数前加正好，负数前加负号；
  - 左对齐；正数前无符号，负数前加负号；
  空格 右对齐；正数前加空格，负数前加负号；
  0 右对齐；正数前无符号，负数前加负号；用0填充空白处
• width 可选，占有宽度
• .precision 可选，小数点后保留的位数
• typecode 必选
  s，获取传入对象的__str__方法的返回值，并将其格式化到指定位置
  r，获取传入对象的__repr__方法的返回值，并将其格式化到指定位置
  c，整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置
  o，将整数转换成 八 进制表示，并将其格式化到指定位置
  x，将整数转换成十六进制表示，并将其格式化到指定位置
  d，将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置
  E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
  f， 将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
  F，同上
  g，自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
  G，自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
  %，当字符串中存在格式化标志时，需要用 %%表示一个百分号

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

常用格式化：

tpl = "i am %s" % "ygqygq2"
 
tpl = "i am %s age %d" % ("ygqygq2", 27)
 
tpl = "i am %(name)s age %(age)d" % {"name": "ygqgyq2", "age": 27}
 
tpl = "percent %.2f" % 99.97623
 
tpl = "i am %(pp).2f" % {"pp": 123.425556, }
 
tpl = "i am %.2f %%" % {"pp": 123.425556, }

2.Format方式

[[fill]align][sign][#][0][width][,][.precision][type]

• fill 【可选】空白处填充的字符
• align 【可选】对齐方式（需配合width使用）
  <，内容左对齐
  >，内容右对齐(默认)
  ＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。即使：符号+填充物+数字
  ^，内容居中
  sign 【可选】有无符号数字
  +，正号加正，负号加负；
  -，正号不变，负号加负；
  空格 ，正号空格，负号加负；
  # 【可选】对于二进制、八进制、十六进制，如果加上#，会显示0b/0o/0x，否则不显示
  ， 【可选】为数字添加分隔符，如：1,000,000
  width 【可选】格式化位所占宽度
  .precision 【可选】小数位保留精度
  type 【可选】格式化类型
  传入” 字符串类型 “的参数
  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位）

常用格式化：

tpl = "i am {}, age {}, {}".format("seven", 18, ‘alex‘)
  
tpl = "i am {}, age {}, {}".format(*["seven", 18, ‘alex‘])
  
tpl = "i am {0}, age {1}, really {0}".format("seven", 18)
  
tpl = "i am {0}, age {1}, really {0}".format(*["seven", 18])
  
tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18)
  
tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})
  
tpl = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
  
tpl = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)
  
tpl = "i am {:s}, age {:d}".format(*["seven", 18])
  
tpl = "i am {name:s}, age {age:d}".format(name="seven", age=18)
  
tpl = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})
 
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
 
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
 
tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
 
tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)

更多格式化操作：https://docs.python.org/3/library/string.html

3.迭代器和生成器

1.迭代器

迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退，不过这也没什么，因为人们很少在迭代途中往后退。另外，迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件

特点：

访问者不需要关心迭代器内部的结构，仅需通过next()方法不断去取下一个内容
不能随机访问集合中的某个值 ，只能从头到尾依次访问
访问到一半时不能往回退
便于循环比较大的数据集合，节省内存

>>> a = iter([1,2,3,4,5])
>>> a
<list_iterator object at 0x101402630>
>>> a.__next__()
1
>>> a.__next__()
2
>>> a.__next__()
3
>>> a.__next__()
4
>>> a.__next__()
5
>>> a.__next__()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

2.生成器

一个函数调用时返回一个迭代器，那这个函数就叫做生成器（generator）；如果函数中包含yield语法，那这个函数就会变成生成器；

def func():
    print(11)
    yield 1
    print(22)
    yield 2
    print(33)
    yield 3
    print(44)
    yield 4

上述代码中：func是函数称为生成器，当执行此函数func()时会得到一个迭代器。

>>> temp = func()
>>> temp.__next__()
11
1
>>> temp.__next__()
22
2
>>> temp.__next__()
33
3
>>> temp.__next__()
44
4
>>> temp.__next__()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

4.函数递归

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

def func(n):
    n += 1
    if n >= 4:
        return "end"
    return func(n)

res = func(1)
print(res)

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

使用递归函数需要注意防止栈溢出。

详细请看廖雪峰的官方网站中递归函数

5.模块

为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里，这样，每个文件包含的代码就相对较少，很多编程语言都采用这种组织代码的方式。在Python中，一个.py文件就称之为一个模块（Module）。
模块分为三种：
* 自定义模块
* 第三方模块
* 内置模块

1.使用模块有什么好处？

1. 最大的好处是大大提高了代码的可维护性。
2. 使用模块还可以避免函数名和变量名冲突。

2.导入模块

单模块：import
嵌套在文件夹下：
from xxx import xxx
from xxx import as ooo

3.第三方模块

pip3安装（pip安装）

pip3 install requests

源码安装

curl -OL https://github.com/kennethreitz/requests/tarball/master

解压后，进入目录

python setup.py install

6.序列化

Python中用于序列化的两个模块

• json 用于【字符串】和【python基本数据类型】间进行转换
• pickle 用于【python特有的类型】和【python基本数据类型】间进行转换

Json模块提供了四个功能：dumps、dump、loads、load
pickle模块提供了四个功能：dumps、dump、loads、load

json相关用法：

import json

dict = {‘k1‘: ‘v1‘}
print(dict, type(dict))
# 将python基本数据类型转换成字符串形式
res = json.dumps(dict)
print(res, type(res))

{‘k1‘: ‘v1‘} <class ‘dict‘>
{"k1": "v1"} <class ‘str‘>

import json

# 将python字符串形式转换成基本数据类型
s1 = ‘{"k1": 123}‘
dict = json.loads(s1)   # 反序列化时，一定要使用 ""
print(dict, type(dict))

{‘k1‘: 123} <class ‘dict‘>

import json

li = [11,22,33]
json.dump(li,open(‘test.txt‘,‘w‘))

li = json.load(open(‘test.txt‘,‘r‘))
print(type(li),li)

pickle相关用法：

import pickle

li = [11,22,33]
r = pickle.dumps(li)
print(r)

res = pickle.loads(r)
print(res)

b‘\x80\x03]q\x00(K\x0bK\x16K!e.‘
[11, 22, 33]

li = [11,22,33]
pickle.dump(li, open(‘test4.txt‘, ‘wb‘))

res = pickle.load(open(‘test4.txt‘, ‘rb‘))
print(res)

[11, 22, 33]

json和pickle对比：
1. json更适合跨语言，字符串，基本数据类型
2. pickle更适合python所有类型的序列化操作

7.time & datetime模块

#_*_coding:utf-8_*_
__author__ = ‘Alex Li‘

import time


# print(time.clock()) #返回处理器时间,3.3开始已废弃 , 改成了time.process_time()测量处理器运算时间,不包括sleep时间,不稳定,mac上测不出来
# print(time.altzone)  #返回与utc时间的时间差,以秒计算# print(time.asctime()) #返回时间格式"Fri Aug 19 11:14:16 2016",
# print(time.localtime()) #返回本地时间 的struct time对象格式
# print(time.gmtime(time.time()-800000)) #返回utc时间的struc时间对象格式

# print(time.asctime(time.localtime())) #返回时间格式"Fri Aug 19 11:14:16 2016",
#print(time.ctime()) #返回Fri Aug 19 12:38:29 2016 格式, 同上



# 日期字符串 转成  时间戳
# string_2_struct = time.strptime("2016/05/22","%Y/%m/%d") #将 日期字符串 转成 struct时间对象格式
# print(string_2_struct)
# #
# struct_2_stamp = time.mktime(string_2_struct) #将struct时间对象转成时间戳
# print(struct_2_stamp)



#将时间戳转为字符串格式
# print(time.gmtime(time.time()-86640)) #将utc时间戳转换成struct_time格式
# print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) ) #将utc struct_time格式转成指定的字符串格式





#时间加减
import datetime

# print(datetime.datetime.now()) #返回 2016-08-19 12:47:03.941925
#print(datetime.date.fromtimestamp(time.time()) )  # 时间戳直接转成日期格式 2016-08-19
# print(datetime.datetime.now() )
# print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天
# print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天
# print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时
# print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分


#
# c_time  = datetime.datetime.now()
# print(c_time.replace(minute=3,hour=2)) #时间替换

8.logging模块　　

很多程序都有记录日志的需求，并且日志中包含的信息即有正常的程序访问日志，还可能有错误、警告等信息输出，python的logging模块提供了标准的日志接口，你可以通过它存储各种格式的日志，logging的日志可以分为 debug(), info(), warning(), error() and critical() 5个级别，下面我们看一下怎么用。
最简单用法

import logging
 
logging.warning("user [alex] attempted wrong password more than 3 times")
logging.critical("server is down")

WARNING:root:user [alex] attempted wrong password more than 3 times
CRITICAL:root:server is down

看一下这几个日志级别分别代表什么意思

如果想把日志写到文件里，也很简单

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 this, too‘)

其中下面这句中的level=loggin.INFO意思是，把日志纪录级别设置为INFO，也就是说，只有比日志是INFO或比INFO级别更高的日志才会被纪录到文件里，在这个例子， 第一条日志是不会被纪录的，如果希望纪录debug的日志，那把日志级别改成DEBUG就行了。

logging.basicConfig(filename=‘example.log‘,level=logging.INFO)

感觉上面的日志格式忘记加上时间啦，日志不知道时间怎么行呢，下面就来加上!

import logging
logging.basicConfig(format=‘%(asctime)s %(message)s‘, datefmt=‘%m/%d/%Y %I:%M:%S %p‘)
logging.warning(‘is when this event was logged.‘)

12/12/2010 11:46:36 AM is when this event was logged.

日志格式

如果想同时把log打印在屏幕和文件日志里，就需要了解一点复杂的知识 了

Python 使用logging模块记录日志涉及四个主要类，使用官方文档中的概括最为合适：
1. logger提供了应用程序可以直接使用的接口；
2. handler将(logger创建的)日志记录发送到合适的目的输出；
3. filter提供了细度设备来决定输出哪条日志记录；
4. formatter决定日志记录的最终输出格式。

logger
每个程序在输出信息之前都要获得一个Logger。Logger通常对应了程序的模块名，比如聊天工具的图形界面模块可以这样获得它的Logger：
LOG=logging.getLogger(”chat.gui”)
而核心模块可以这样：
LOG=logging.getLogger(”chat.kernel”)

Logger.setLevel(lel):指定最低的日志级别，低于lel的级别将被忽略。debug是最低的内置级别，critical为最高
Logger.addFilter(filt)、Logger.removeFilter(filt):添加或删除指定的filter
Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)：增加或删除指定的handler
Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()：可以设置的日志级别

handler
handler对象负责发送相关的信息到指定目的地。Python的日志系统有多种Handler可以使用。有些Handler可以把信息输出到控制台，有些Logger可以把信息输出到文件，还有些 Handler可以把信息发送到网络上。如果觉得不够用，还可以编写自己的Handler。可以通过addHandler()方法添加多个多handler
Handler.setLevel(lel):指定被处理的信息级别，低于lel级别的信息将被忽略
Handler.setFormatter()：给这个handler选择一个格式
Handler.addFilter(filt)、Handler.removeFilter(filt)：新增或删除一个filter对象

每个Logger可以附加多个Handler。接下来我们就来介绍一些常用的Handler：
1) logging.StreamHandler
使用这个Handler可以向类似与sys.stdout或者sys.stderr的任何文件对象(file object)输出信息。它的构造函数是：
StreamHandler([strm])
其中strm参数是一个文件对象。默认是sys.stderr
2) logging.FileHandler
和StreamHandler类似，用于向一个文件输出日志信息。不过FileHandler会帮你打开这个文件。它的构造函数是：
FileHandler(filename[,mode])
filename是文件名，必须指定一个文件名。
mode是文件的打开方式。参见Python内置函数open()的用法。默认是’a‘，即添加到文件末尾。
3) logging.handlers.RotatingFileHandler
这个Handler类似于上面的FileHandler，但是它可以管理文件大小。当文件达到一定大小之后，它会自动将当前日志文件改名，然后创建 一个新的同名日志文件继续输出。比如日志文件是chat.log。当chat.log达到指定的大小之后，RotatingFileHandler自动把 文件改名为chat.log.1。不过，如果chat.log.1已经存在，会先把chat.log.1重命名为chat.log.2。。。最后重新创建 chat.log，继续输出日志信息。它的构造函数是：
RotatingFileHandler( filename[, mode[, maxBytes[, backupCount]]])
其中filename和mode两个参数和FileHandler一样。
maxBytes用于指定日志文件的最大文件大小。如果maxBytes为0，意味着日志文件可以无限大，这时上面描述的重命名过程就不会发生。
backupCount用于指定保留的备份文件的个数。比如，如果指定为2，当上面描述的重命名过程发生时，原有的chat.log.2并不会被更名，而是被删除。
4) logging.handlers.TimedRotatingFileHandler
这个Handler和RotatingFileHandler类似，不过，它没有通过判断文件大小来决定何时重新创建日志文件，而是间隔一定时间就 自动创建新的日志文件。重命名的过程与RotatingFileHandler类似，不过新的文件不是附加数字，而是当前时间。它的构造函数是：
TimedRotatingFileHandler( filename [,when [,interval [,backupCount]]])
其中filename参数和backupCount参数和RotatingFileHandler具有相同的意义。
interval是时间间隔。
when参数是一个字符串。表示时间间隔的单位，不区分大小写。它有以下取值：
S 秒
M 分
H 小时
D 天
W 每星期（interval==0时代表星期一）
midnight 每天凌晨

import logging
 
#create logger
logger = logging.getLogger(‘TEST-LOG‘)
logger.setLevel(logging.DEBUG)
 
 
# create console handler and set level to debug
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
 
# create file handler and set level to warning
fh = logging.FileHandler("access.log")
fh.setLevel(logging.WARNING)
# create formatter
formatter = logging.Formatter(‘%(asctime)s - %(name)s - %(levelname)s - %(message)s‘)
 
# add formatter to ch and fh
ch.setFormatter(formatter)
fh.setFormatter(formatter)
 
# add ch and fh to logger
logger.addHandler(ch)
logger.addHandler(fh)
 
# ‘application‘ code
logger.debug(‘debug message‘)
logger.info(‘info message‘)
logger.warn(‘warn message‘)
logger.error(‘error message‘)
logger.critical(‘critical message‘)

import logging

from logging import handlers

logger = logging.getLogger(__name__)

log_file = "timelog.log"
#fh = handlers.RotatingFileHandler(filename=log_file,maxBytes=10,backupCount=3)
fh = handlers.TimedRotatingFileHandler(filename=log_file,when="S",interval=5,backupCount=3)


formatter = logging.Formatter(‘%(asctime)s %(module)s:%(lineno)d %(message)s‘)

fh.setFormatter(formatter)

logger.addHandler(fh)


logger.warning("test1")
logger.warning("test12")
logger.warning("test13")
logger.warning("test14")

Python学习记录day5