双层装饰器示例

1. __author__ = ‘Golden’
2. #!/usr/bin/env python
3. # -*- coding:utf-8 -*-
4.  
5. USER_INFO = {}
6.  
7. def check_login(func):
8.     def inner(*args,**kwargs):
9.         #如果不存在给定默认值None
10.         if USER_INFO.get(“is_login”,None):
11.             ret = func(*args,**kwargs)
12.             return ret
13.         else:
14.             print(“请登录！”)
15.     return inner
16.  
17. def check_admin(func):
18.     def inner(*args,**kwargs):
19.         if USER_INFO.get(‘user_type’,None) == 2:
20.             ret = func(*args,**kwargs)
21.             return ret
22.         else:
23.             print(“无权限查看”)
24.     return inner
25.  
26. @check_login
27. @check_admin
28. def index():
29.     “””
30.     管理员功能
31.     :return:
32.     “””
33.     print(“index”)
34.  
35. @check_login
36. def home():
37.     “””
38.     普通用户功能
39.     :return:
40.     “””
41.     print(“home”)
42.  
43. def login():
44.     user = input(“请输入用户名：”)
45.     if user == “admin”:
46.         USER_INFO[‘is_login’] = True
47.         USER_INFO[‘user_type’] = 2
48.     else:
49.         USER_INFO[‘is_login’] = True
50.         USER_INFO[‘user_type’] = 1
51.  
52. def main():
53.     while True:
54.         inp = input(“1：登录；2：查看信息；3：超级管理员管理”)
55.         “:
56.             login()
57.         elif inp == “”:
58.             home()
59.         elif inp == “”:
60.             index()
61.  
62. main()

字符串格式化

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

百分号方式

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

• (name)可选，用于选择指定的key。

1. s = “%s %d”%(‘alex’,23)
2. print(s)
3.  
4. s = “%(name)s %(age)d”%{‘name’:’alex’,’age’:123}
5. print(s)

• flags可选，可供选择的值有：

+：右对齐，正数前加”+”，负数前加”-“。

1. s = “test%(name)+10stest %(age)d”%{‘name’:’alex’,’age’:123}
2. print(s)

-：左对齐，正数前无符号，负数前加”-“。

1. s = “test%(name)-10stest %(age)d”%{‘name’:’alex’,’age’:123}
2. print(s)

空格：右对齐，正数前加空格，负数前加 “-“。

0：右对齐，正数前无符号，负数前加”-“，用0填充空白处。

• width可选，占用宽度。
• .precision可选，小数点后保留的位数。

1. s = “test%(name)-10stest test%(age).2ftest”%{‘name’:’alex’,’age’:123.1234567}
2. print(s)

• typecode必选

s：获取传入对象的_str_方法的返回值，并将其格式化到指定位置。

r：获取传入对象的_repr_方法的返回值，并将其格式化到指定位置。

c：整数，将数字装换成其unicode对应的值，10进制范围为0<=i<=1114111（py27则只支持0–255），将字符添加到指定位置。

o：将整数转换成八进制表示，并将其格式化到指定位置。

x：将整数转换成十六进制表示，并将其格式化到指定位置。

1. s = “test %c—%o—%x”%(65,15,15)
2. print(s)

d：将整数、浮点数转换成十进制表示，并将其格式化到指定位置。

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

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

1. s = “test %e %E”%(1000000000000000,1000000000000000)
2. print(s)

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

F：同上。

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

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

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

格式化时，字符串中出现占位符%，需要用%%输出%。

1. s = “alex %”
2. print(s)
3. s = “alex %s %% ” %(‘SB’)
4. print(s)

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

Format方式

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

• fill【可选】空白处填充的字符。
• align【可选】对齐方式（需配个width使用）

<：内容左对齐

>：内容右对齐（默认）

=：内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。即使：符号+填充物+数字。

^：内容居中。

1. s = “—{:a^20s}—-“.format(‘alex’)
2. print(s)

• sign【可选】有无符号数字。

+：正号加正，负号加负。

-：正号不变，负号加负。

空格：正号空格，负号加负。

1. s = “—{:a^20s}—-{:+d}”.format(‘alex’,123)
2. print(s)

• #【可选】对于二进制、八进制、十六进制，如果加上#，会显示0b/0o/0x，否则不显示。
• ,【可选】为数字添加分隔符，如1,000,000
• width【可选】格式化位所占宽度。
• .precision【可选】小数位保留精度。
• type【可选】格式化类型

b：将10进制整数自动转换成2进制显示然后格式化。

1. s = “—{:a^20s}—-{:+d}—-{:#b}”.format(‘alex’,123,15)
2. print(s)

%：显示百分比（默认显示小数点后6位）。

1. s = “test {:%}”.format(0.234567)
2. print(s)
3.  
4. s = “test {:.2%}”.format(0.234567)
5. print(s)

总结：

1. s = “i am {},age {},{}”.format(“seven”,18,”alex”)
2. s = “i am {},age {},{}”.format(*[“seven”,18,”alex”])
3. s = “i am {0},age {1},{0}”.format(“seven”,18)
4. s = “i am {0},age {1},{0}”.format(*[“seven”,18])
5. s = “i am {name},age {age},{name}”.format(name=”seven”,age=18)
6. s = “i am {name},age {age},{name}”.format(**{“name”:”seven”,”age”:18})
7. s = “i am {0[0]},age {0[1]},{0[2]}”.format([1,2,3],[11,22,33])
8. s = “i am {:s},age {:d},{:f}”.format(“seven”,18,88888.1)
9. s = “i am {:s},age {:d}”.format(“seven”,18)
10. s = “i am {name:s},age {age:d}”.format(name=”seven”,age=18)
11. s = “i am {name:s},age {age:d}”.format(**{“name”:”seven”,”age”:18})
12. s = “numbers:{:b},{:o},{:d},{:x},{:X},{:%}”.format(15,15,15,15,15,0.78912)
13. s = “numbers:{0:b},{0:o},{0:d},{0:x},{0:X},{0:%}”.format(15)

生成器

1. #普通函数
2. def func():
3.     return 123
4.  
5. ret = func()
6.  
7. #生成器
8. def func():
9.     print(“start”)
10.     yield 1
11.     print(222)
12.     yield 2
13.     print(333)
14.     yield 3
15.  
16. ret01 = func()
17. print(ret01)
18. ”’
19. for i in ret01:
20.     print(i)
21. ”’
22. #进入函数找到yield，获取yield后面的数据
23. r = ret01.__next__()
24. print(r)
25. r = ret01.__next__()
26. print(r)
27. r = ret01.__next__()
28. print(r)

基于生成器实现range功能

1. def myrange(arg):
2.     start = 0
3.     while True:
4.         if start > arg:
5.             return
6.         yield start
7.         start += 1
8.  
9. ret = myrange(3)
10. r = ret.__next__()
11. print(r)
12. r = ret.__next__()
13. print(r)
14. r = ret.__next__()
15. print(r)
16. r = ret.__next__()
17. print(r)

迭代器

1. def myrange(arg):
2.     start = 0
3.     while True:
4.         if start > arg:
5.             return
6.         yield start
7.         start += 1
8.  
9. ret = myrange(3)
10. for item in ret:
11.     print(item)

递归

函数的调用

1. def d():
2.     “
3.  
4. def c():
5.     r = d()
6.     return r
7.  
8. def b():
9.     r = c()
10.     return r
11.  
12. def a():
13.     r = b()
14.     print(r)
15.  
16. a()

递归调用

1. def func(n):
2.     n += 1
3.     if n >= 10:
4.         return ‘end’,n
5.     return func(n)
6.  
7. r = func(1)
8. print(r)

模块

添加一个模块路径

1. import sys
2. sys.path.append(‘E:\\’)

导入模块

1. #导入模块s3
2. import s3
3. #引用s3中login()函数
4. 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任何类型）

1. import json
2.  
3. dic = {‘k1′:’v1’}
4. #将python基本数据类型转换成字符串形式
5. result = json.dumps(dic)
6. print(result,type(result))
7.  
8. s1 = ‘{“k1”:123}’
9. #将python字符串形式转化成基本数据类型
10. dic = json.loads(s1)
11. print(dic,type(dic))

获取天气相关json数据

1. import requests
2. import json
3.  
4. response = requests.get(‘http://wthrcdn.etouch.cn/weather_mini?city=武汉’)
5. response.encoding = ‘utf-8’
6. print(response.text,type(response.text))
7. dic = json.loads(response.text)
8. print(type(dic))

loads反序列化是，一定注意引号的使用格式

1. import json
2.  
3. r = json.dumps([11,22,33])
4. #注意外面用单引号，里面用双引号
5. li = ‘[“alex”,”eric”]’
6. ret = json.loads(li)
7. print(ret,type(ret))

dump与load

1. import json
2.  
3. li = [11,22,44]
4. json.dump(li,open(‘db’,’w’))
5.  
6. li = json.load(open(‘db’,’r’))
7. print(type(li))

pickle仅仅python可用

1. #pickle仅仅python之间调用
2. import pickle
3.  
4. li = [11,22,33]
5. r = pickle.dumps(li)
6. print(r)
7.  
8. ret = pickle.loads(r)
9. print(ret)
10.  
11. #二进制方式
12. pickle.dump(li,open(‘db’,’wb’))
13.  
14. ret = pickle.load(open(‘db’,’rb’))
15. print(ret)

json更适合跨语言，基本数据类型的序列化。

pickle针对python所有类型的序列化，仅仅适用于python。

time

1. import time
2.  
3. #时间戳1970年1月1号0点开始的秒数（unix版本正式上线）
4. print(time.time())
5.  
6. #当前系统时间
7. print(time.ctime())
8. print(time.ctime(time.time()-86400))
9.  
10. #将时间戳转换成struct_time格式
11. print(time.gmtime())
12.  
13. time_obj = time.gmtime()
14. print(time_obj.tm_year,time_obj.tm_mday)
15.  
16. #本地时间（struct_time格式）
17. print(time.localtime())
18.  
19. #struct_time转成时间戳
20. print(time.mktime(time_obj))
21.  
22. #延迟4秒后继续执行
23. #time.sleep(4)
24. print(“—-“)
25.  
26. #将struct_time格式转换成指定的字符串格式
27. tm = time.strftime(“%Y-%m-%d %H:%M:%S”,time.localtime())
28. print(tm)
29.  
30. #将字符串格式转换成struct_time格式
31. tm = time.strptime(“2016-12-14″,”%Y-%m-%d”)
32. tm_1 = time.strptime(“2016-12-12 8:58″,”%Y-%m-%d %H:%M”)
33. print(tm)
34. print(tm_1)
35.  
36. #字符串格式转换成时间戳
37. tm = time.mktime(time.strptime(“2016-12-14”,’%Y-%m-%d’))
38. print(tm)

datetime

1. import datetime
2. import time
3.  
4. #输出格式2016-01-01
5. print(datetime.date.today())
6.  
7. #将时间戳转换成日期格式
8. print(datetime.date.fromtimestamp(time.time()-864400))
9.  
10. #详细时间
11. current_time = datetime.datetime.now()
12. print(current_time)
13.  
14. #返回struct_time格式
15. print(current_time.timetuple())
16.  
17.  
18. #days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0
19. #加10天
20. print(datetime.datetime.now()+datetime.timedelta(days=10))
21.  
22. #减10天
23. print(datetime.datetime.now()+datetime.timedelta(days=-10))
24.  
25. #减10小时
26. print(datetime.datetime.now()+datetime.timedelta(hours=-10))
27.  
28. #加130秒
29. print(datetime.datetime.now()+datetime.timedelta(seconds=-130))
30.  
31. #时间替换
32. current_time = datetime.datetime.now()
33. print(current_time.replace(2014,9,12))
34.  
35. #将字符串转换成日期格式
36. print(datetime.datetime.strptime(“23/12/14 09:13″,”%d/%m/%y %H:%M”))
37.  
38. #时间比较
39. time_obj = current_time.replace(2015,5)
40. print(current_time > time_obj)
41. print(type(time_obj))

logging

1. import logging
2.  
3. logging.warning(“user [alex] attempted wrong password more then 3 times”)
4. logging.critical(“server is down”)

记录日志到文件

1. logging.basicConfig(filename=’example.log’,level=logging.INFO)
2. logging.debug(‘This message should go to the log file’)
3. logging.info(‘So should this’)
4. logging.warning(‘And this,too’)

注意：只有级别比INFO高或相等才会被记录到文件中。

记录时间、日志到文件

1. logging.basicConfig(filename=’example.log’,level=logging.INFO,format=’%(asctime)s %(message)s’,datefmt=’%m/%d/%Y %I:%M:%S %p’)
2. logging.debug(‘This message should go to the log file’)
3. logging.info(‘So should this’)
4. logging.warning(‘And this,too’)

同时打印在屏幕和文件里

1. import logging
2.  
3. #获取日志的对象
4. logger = logging.getLogger(‘TEST-LOG’)
5. #设定一个全局的日志级别
6. logger.setLevel(logging.INFO)
7.  
8. #输出到屏幕
9. ch = logging.StreamHandler()
10. #设定输出级别
11. ch.setLevel(logging.DEBUG)
12.  
13. #写入日志文件
14. fh = logging.FileHandler(“access.log”)
15. #设定写入的级别
16. fh.setLevel(logging.WARNING)
17.  
18. fh_err = logging.FileHandler(“error.log”)
19. fh_err.setLevel(logging.ERROR)
20.  
21. #格式：时间 名字 信息
22. formatter = logging.Formatter(‘%(asctime)s – %(name)s – %(levelname)s – %(message)s’)
23. formatter_for_file = logging.Formatter(‘%(asctime)s – %(levelname)s – %(message)s’)
24. formatter_for_file_err= logging.Formatter(‘%(asctime)s %(filename)s – %(levelname)s – %(message)s’)
25. #屏幕输出格式
26. ch.setFormatter(formatter)
27. #文件记录格式
28. fh.setFormatter(formatter_for_file)
29. fh_err.setFormatter(formatter_for_file_err)
30.  
31. #添加到logger
32. logger.addHandler(ch)
33. logger.addHandler(fh)
34. logger.addHandler(fh_err)
35.  
36. #打印日志
37. logger.debug(‘debug message’)
38. logger.info(‘info message’)
39. logger.warn(‘warn message’)
40. logger.error(‘error message’)
41. logger.critical(‘critical message’)

日志记录格式

%(filename)s：程序文件路径

%(funcName)s：函数名

%(lineno)d：行数

%(module)：模块名

%(processName)s：进程名

%(process)d：进程id

%(thread)d：线程id