python 基础 day5

本节内容：1、双层装饰器　　

　　　      2、字符串格式化

　　　      3、递归

　　　      4、生成器、迭代器

　　      　5、模块

双层装饰器

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‘,None):
            ret = func(*args,**kwargs)
            return ret
        else:
            print("无权限")
    return

@check_login
@check_admin
def index():
    print("index")

index()

#从下晚上渲染（编译解释），@chec_admin装饰index函数，它们作为一个整体，假设这个整体的名字为nindex,那么@chec_login装饰的就是nindex。
#从上往下之行，先之行@chec_login，执行里面的func也就是执行index，index就是@check_admin和index函数，接下来执行check_admin里的func，也就是执行index 函数，那它执行的就是check_admin里的inner 函数.

字符串格式化

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

百分号的方式相对来说比较老，而format方式则是比较先进的方式，企图替换古老的方式，目前两者并存。

百分号方式

%[(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中百分号格式化是不存在自动将整数转换成二进制表示的方式

常用格式化：

tp1 = "i am %s" % "QL"
print(tp1)
tp2 = "i am %s age %d" % ("QL",18)     #顺序添加
print(tp2)
tp3 = "i am %(name)s age %(age)d" %{"name":"QL","age":18,}  #命名添加
print(tp3)
tp4 = "percent %.2f" % 99.98765
print(tp4)
tp5 = "i am %(pp).2f %%" %{"pp":123.2312444,} #可以命名也可以不命名
print(tp5)
tp6 = "i am %.2f %%" % 123.123123   #显示百分号，需要写两个% 相当于转译
print(tp6)

s = "我是%(name)s age %(age)d" % {‘name‘:‘QL‘,‘age‘:21}
print(s)
#我是QL age 21

s1 = "我是%(name)-10saa %(age) +10daa" %{‘name‘:‘QL‘,‘age‘:12}
print(s1)
#我是QL        aa        +12aa

s2 = "hello %c------%o=====%x" % (65,15,15)  ＃％c是asc码，％o是8进制，％x16进制
print(s2)
#hello A------17=====f

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

常用格式化

s1 = "----{:9^20s}====={:d}====={:x}".format(‘QL‘,16,15) #x是16进制
print(s1)
#----999999999QL999999999=====16=====f

s2 = "sddddsssss {:.2%}".format(0.1334234)  #把数字自动转换成百分比形式，并且保留2位小数
print(s2)
#sddddsssss 13.34%

tp1 = "i am {},age {}, {}".format("seven",18,‘QL‘)
print(tp1)
#i am seven,age 18, QL

tp2 = "i am {},age {}, {}".format(*["seven",18,"QL"]) #列表传递前面要加*
print(tp2)
tp3 = "i am {0},age {1}，really {0}".format("seven",18)
print(tp3)
#i am seven,age 18，really seven

tp4 = "i am {name},age{age},really {name}".format(name="seven",age=18)
print(tp4)

tp5 = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])  #元素传递
print(tp5)

tp6 = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)

tp7 = "i am {:s}, age {:d}".format(*["seven", 18])

tp8 = "i am {name:s}, age {age:d}".format(name="seven", age=18)

tp9 = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})

tp10 = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)

tpl1 = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)

tpl2 = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)

tpl3 = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)

递归

#无返回值，None

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 >=4:
        return "end"
    return func(n)

r = func(1)
print(r)

#思考题：1*2*3*4*5*6

迭代器

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

特点：

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

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

生成器

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

def func():
    print("aaaa")
    yield 1
    yield 2
    print("ccc")
    yield 3

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

ret = func()

r1 = ret.__next__()
print(r1)
r2 = ret.__next__()
print(r2)
r3 = ret.__next__()
print(r3)

＃结果
aaaa
1
2
ccc
3

实例：

用生成器自定义range

def myrange(arg):
    start = 0
    while True:
        if start > arg:
            return
        yield start
        start += 1

ret = myrange(5)
r = ret.__next__()
print(r)

r1 = ret.__next__()
print(r1)

r2 = ret.__next__()
print(r2)

＃结果
0
1
2

模块

模块  （在其他语言里叫类库）

分为三类：
　　　　1、开发者写的模块
　　　　2、第三方模块
　　　　3、自定义模块

为什么要有模块？

将代码归类

先导入，后使用（.py，或者是一个文件夹包含很多.py）

import s1  #一个.py
import lib.commons    #一个文件夹包含多个.py

#调用 f2是s1.py里的函数，f1是lib下的commons.py里的函数
s1.f2()
lib.commons.f1()

from s1 import *
from s1 import f2  #s1模块名，f2是s1里的函数

f2()

from lib import commons
from src import commons as src_commons  #如果两个文件夹里有相同模块名自可以定义别名

commons.f1()

#模块名字非常重要*********
#创建模块名不要和内置模块名一样，先寻找当前目录，找到就不再往下找了，就不会调用内置模块了

查找python 路径

import sys
for item in sys.path:
    print(item)

#查找结果，我所使用的是pycharm,并建立了一个s13的项目文件，下面建立了一个day5文件夹，程序就放在这里面

C:\Users\qinling\PycharmProjects\s13\day5
C:\Users\qinling\PycharmProjects\s13        #先在当前目录找模块  在pycharm下会导入项目目录，但在Linux下是不会导入的，所以忽略此目录
C:\Users\qinling\AppData\Local\Programs\Python\Python35\python35.zip
C:\Users\qinling\AppData\Local\Programs\Python\Python35\DLLs
C:\Users\qinling\AppData\Local\Programs\Python\Python35\lib
C:\Users\qinling\AppData\Local\Programs\Python\Python35
C:\Users\qinling\AppData\Local\Programs\Python\Python35\lib\site-packages #第三方模块存放位置 

sys.path.append(‘E:\\‘) #导入E盘位置，sys.path是列表，添加python路径

推荐使用导入方法：

单模块：
     import

嵌套在文件夹下：
     from xxx import xxx
     from xxx import xxx as xxxxx

安装第三方模块

1、pip 安装（pip3，python3有，python2，没有）

2、源码安装:

　　　　　　解压进入目录

　　　　　　执行 python3  setup.py  install

例如安装requests模块:

pip3 install requests  #找到requests模块文件位置 用这个命令安装
python -m pip install requests #不用找到模块文件位置用这个命令就可以安装了

两个序列化相关的模块（把python的字典、列表等转换成字符串）

json

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

import json

dic = {‘k1‘:‘v1‘}
print(dic,type(dic))
#{‘k1‘: ‘v1‘} <class ‘dict‘>

r = json.dumps(dic)  #python基本数据类型转换成字符串形式
print(r,type(r))
#{"k1": "v1"} <class ‘str‘>

s1 = ‘{"k1":"123"}‘   #里面必须是双引号，外面必须是单引号 （其他语言单引号叫字符，双引号叫字符串）
r1 = json.loads(s1)   #将python字符串类型转换成基本数据类型
print(r1,type(r1))
#{‘k1‘: ‘123‘} <class ‘dict‘>

li = [11,22,33,]
json.dump(li,open(‘db‘,‘w‘))    #先序列化再写入db文件

li = json.load(open(‘db‘,‘r‘))   #先读文件再序列化出来
print(type(li),li)                     #<class ‘list‘> [11, 22, 33]
 

使用json做请求获得字符串转化成字典

import json
import requests

response = requests.get(‘http://wthrcdn.etouch.cn/weather_mini?city=北京‘)
response.encoding = ‘utf-8‘
dic1 = json.loads(response.text)
print(dic1)

pickle

只能python使用

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

li = [11,222,33,]
r = pickle.dumps(li)
print(type(r),r)
#<class ‘bytes‘> b‘\x80\x03]q\x00(K\x0bK\xdeK!e.‘

result = pickle.loads(r) #转化成列表
print(result)
#[11, 222, 33]

pickle.dump(li,open(‘123‘,‘wb‘))      #先序列化再写入文件
re = pickle.load(open(‘123‘,‘rb‘))     ＃读文件，序列化后输出

print(re)
#[11, 222, 33]

两者区别与优缺点：

json 只能处理基本的数据类型，更加适合跨语言，字符串，如果是一个自己的写的类就不能转换

pickel 支持任何类型，适合对python的所有类型操作，仅适用于python，python版本不同可能会出现问题

time 模块 （http://www.cnblogs.com/alex3714/articles/5161349.html）

常用

import time

print(time.time()) #1970年开始计时到现在的系统时间戳
#1465123123.342

print(time.ctime()) #当前时间
#Sun Jun  5 18:38:43 2016

print(time.ctime(time.time()-86400))
#Sat Jun  4 18:38:43 2016

print(time.gmtime())
#time.struct_time(tm_year=2016, tm_mon=6, tm_mday=5, tm_hour=10, tm_min=38, tm_sec=43, tm_wday=6, tm_yday=157, tm_isdst=0)

t_obj = time.gmtime()
print(t_obj.tm_year,t_obj.tm_mon,t_obj.tm_mday)
#2016 6 5

print(time.localtime())  #获取本地时间，本地用哪个时区就获取哪个时区的
#time.struct_time(tm_year=2016, tm_mon=6, tm_mday=5, tm_hour=18, tm_min=40, tm_sec=41, tm_wday=6, tm_yday=157, tm_isdst=0)

print(time.mktime(t_obj)) #把时间对象转成时间戳
#1465094462.0

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

tm = time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()) #常用 将字符串格式转成格式化形式
print(tm)
#2016-06-05 18:41:27

tm1 = time.strptime("2016-05-6 15:06","%Y-%m-%d %H:%M")
print(tm1)
#time.struct_time(tm_year=2016, tm_mon=5, tm_mday=6, tm_hour=15, tm_min=6, tm_sec=0, tm_wday=4, tm_yday=127, tm_isdst=-1)

datetime

常用

import datetime
print(datetime.date.today())
#2016-06-05

tm2 = datetime.datetime.now() # 现在的时间
print(tm2)
#2016-06-05 18:42:58.458000

print(datetime.datetime.now() + datetime.timedelta(days=10)) #比现在加10天
#2016-06-15 18:42:58.458000

current_time = datetime.datetime.now()
print(current_time.replace(2015,5))   #直接回到某个时间
#2015-05-05 18:42:58.458000

time_obj = current_time.replace(2015,5)
print(current_time==time_obj)

time &datetime

import time
import datetime

print(time.clock()) #返回处理器时间,3.3开始已废弃
print(time.process_time()) #返回处理器时间,3.3开始已废弃
print(time.time()) #返回当前系统时间戳
print(time.ctime()) #输出Tue Jan 26 18:23:48 2016 ,当前系统时间
print(time.ctime(time.time()-86640)) #将时间戳转为字符串格式
print(time.gmtime(time.time()-86640)) #将时间戳转换成struct_time格式
print(time.localtime(time.time()-86640)) #将时间戳转换成struct_time格式,但返回 的本地时间
print(time.mktime(time.localtime())) #与time.localtime()功能相反,将struct_time格式转回成时间戳格式
#time.sleep(4) #sleep
print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) ) #将struct_time格式转成指定的字符串格式
print(time.strptime("2016-01-28","%Y-%m-%d") ) #将字符串格式转换成struct_time格式

#datetime module

print(datetime.date.today()) #输出格式 2016-01-26
print(datetime.date.fromtimestamp(time.time()-864400) ) #2016-01-16 将时间戳转成日期格式
current_time = datetime.datetime.now() #
print(current_time) #输出2016-01-26 19:04:30.335935
print(current_time.timetuple()) #返回struct_time格式

#datetime.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]])
print(current_time.replace(2014,9,12)) #输出2014-09-12 19:06:24.074900,返回当前时间,但指定的值将被替换

str_to_date = datetime.datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M") #将字符串转换成日期格式
new_date = datetime.datetime.now() + datetime.timedelta(days=10) #比现在加10天
new_date = datetime.datetime.now() + datetime.timedelta(days=-10) #比现在减10天
new_date = datetime.datetime.now() + datetime.timedelta(hours=-10) #比现在减10小时
new_date = datetime.datetime.now() + datetime.timedelta(seconds=120) #比现在+120s
print(new_date)

 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就行了。

给日志加上时间

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打印在屏幕和文件日志里