Day5 双层装饰器、字符串格式化、生成器、迭代器、递归

双层装饰器实现用户登录和权限认证

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author: WangHuafeng

USER_INFO = {}

def check_login(func):
    def inner(*args, **kwargs):
        #.get拿数据时，不存在则默认为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():
    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:
        imp = input("1.登录；2.查看信息；3.超级管理员管理 \n >>>")
        if imp == '1':
            login()
        elif imp == '2':
            home()
        elif imp == '3':
            index()

main()

双层装饰器详解

字符串格式化

占位符%方式：

%[(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）

    E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）

    f， 将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）

    F，同上

    g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）

    G，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）

    %，当字符串中存在格式化标志时，需要用 %%表示一个百分号

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

s = "My name is %(name)s ,age is %(age)d" %{'name':'wang', 'age':29}
print(s)

s1 = "My name is %(name)+10s ,age is %(age)+10d" %{'name':'wang', 'age':29}
print(s1)

s2 = "My nameis%(name)-10s ,age is %(age)-10d" %{'name':'wang', 'age':-29}
print(s2)
s3 = "My name is %(name)s ,age is %(age)d" %{'name':'wang', 'age':29}
print(s3)

s4 = "My name is %(name)s ,age is %(age)x %(p).2f" %{'name':'wang', 'age':29, 'p':1.234567}
print(s4)

s5 = "My name is %(name)s ,age is %(age)c %(p).2f" %{'name':'wang', 'age':67, 'p':1.234567}
print(s5)

#当格式化时，字符串中出现占位符%s,%d时，必须使用%%才能显示一个%，即转义

s6 = "wang %s %%" %('haha')

print(s6)

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位）

s7 = "aasasasasa{0}as23456{1}".format(123,'qqq')
print(s7)

s8 = "------{name:s}___________{age:d} ========={name:s}".format(name='wang', age=29)
print(s8)
s9 = "----------{:0^20s}===={:+d}-------{:#b}".format('wang', 12345, 18)
print(s9)

生成器

#普通函数中出现yield则称之为生成器，生成器具有生成指定条件数据能力的一个对象，只有循环时才生成

def func():
    yield 1
    yield 2
    yield 3

ret = func()

for i in ret:
    print(i)

即：

r1 = ret.__next__() #进入函数找到yield，获取yield后面的数据
print(r1)
r2 = ret.__next__() #进入函数找到yield，获取yield后面的数据
print(r2)
r3 = ret.__next__() #进入函数找到yield，获取yield后面的数据
print(r3)

#自定义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 func(n):
    n += 1
    if n >= 4:
        return 'end'
    return func(n)

r = func(1)
print(r)

模块（内置模块、第三方模块和自定义模块），作用：代码归类

# 先导入后使用，既可以是文件也可以是文件夹

import lib.commons
import s3

s3.login()
s3.logout()

lib.commons.f1()

s3.py

def login():
    print("login")

def logout():
    print("logout")

commons.py

def f1():
    print("F1")

创建模块名时，一定不要和内置模块名重名

import sys

for item in sys.path:
    print(item)

from导入

from s3 import login
login()

单模块即在同一目录，直接import s3

嵌套在文件夹下：

from lib import commons as lib_commons
from src import commons as src_commons

万能模块导入

import sys.os

BASEDIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

sys.path.append(BASEDIR)

from module import main

第三方模块安装

pip3 install requests

源码安装：1）下载安装包 2）解压后进入解压目录，执行python setup.py install

json序列化和反序列化

#序列化：json中dumps将python的基本数据类型转换成字符串形式
import json

dic = {'k1' : 'v1'}
print(dic, type(dic))
result = json.dumps(dic)
print(result, type(result))

#反序列化：json中loads将字符串转换成python中的基本数据类型，注意使用""
s1 = '{"k1" : 123}'
dict_s1 = json.loads(s1)
print(dict_s1, type(dict_s1))

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

dumps和laods是在dump和laod中间加写文件和读文件操作

import json

li = [11, 22, 33, 44, 55]
json.dump(li, open('db9', 'w'))

l2 = json.load(open('db9', 'r'))
print(type(l2),l2)

pickle dumps和loads

import pickle

li = [11, 22, 33, 44]
r = pickle.dumps(li)
print(type(r), r)
result = pickle.loads(r)
print(type(result), result)

pickle dump和load

import pickle

li = [11, 22, 33, 44]

pickle.dump(li, open('db8', 'wb'))
result = pickle.load(open('db8', 'rb'))
print(type(result), result)

json更适合跨语言，字符串，基本数据类型

pickle，python复杂类型的序列化，仅适用于python

time模块

1970到现在的秒数，1970Unix系统正式商用
print(time.time())

返回当前系统时间

print(time.ctime())

print(time.ctime(time.time()-86400))

print(time_obj)
print(time_obj.tm_year, time_obj.tm_mon, time_obj.tm_mday)

返回本地时间

print(time.localtime())

time对象转换成时间戳

time_obj = time.gmtime()

print(time.mktime(time_obj))

延迟时间，用于阻塞

time.sleep(4)
print("********")

strftime把时间对象转换成字符串

print(time.strptime("2016-07-09 11:25", "%Y-%m-%d %H:%M"))

把字符串日期格式转换成时间对象

print(time.strptime("2016-07-09", "%Y-%m-%d"))

把字符串形式的日期形式转换成时间戳

tm = time.strptime("2016-07-09 11:25", "%Y-%m-%d %H:%M")
print(time.mktime(tm))

datetime

当前日期

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

加减时间

#比现在加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))
#加1000秒
print(datetime.datetime.now() + datetime.timedelta(seconds=1000))

直接回到指定时间

print(current_time.replace(2015,5))

格式化输出

print(datetime.datetime.strptime("21/11/06 15:20", "%d/%m/%y %H:%M"))

时间比较

time1 = current_time.replace(2015,5)
print(current_time,time1)
if time1 < current_time:
    print("Hello")

日志模块

import logging

#写入日志级别
logging.warning("user [alex] attempt wrong password more than 3 times")
logging.critical("server is shutdown")
#加入写日志时间和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 shoud go to the log file')
logging.info('So should this')
logging.warning('And this, too')

日志等级

CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0

分别在屏幕打印和文件输出

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.ERROR)

# create file handler and set level to warning
#写入文件的日志
fh = logging.FileHandler("access.log")
#设置写入文件的日志级别
fh.setLevel(logging.INFO)
# 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')