# 字符串格式化之%占位符# a. 位置
s = 'i am %s age %d' % ('eason', 18)
print(s)==> i am eason age 18  # 传入可迭代的对象，%占位符会根据迭代传入顺序给字符串赋值# b. 字典
s = 'i am %(name)s age %(age)d' % {'name':'eason','age':18}
print(s)==> i am eason age 18  # 每一个%占位符会起一个名字，传入一个字典，将字典中%占位符名字的key对应的值传入# c. 浮点型
s = 'percent %.2f' % 99.97623    #  精确到两位小数点，并四舍五入后一位
print(s)==> percent 99.98# d.%显示
# 当格式化字符串时，出现了%s等占位符，需要使用%%才可以输出%（类似于转译）
--无占位符时%显示
s = '99%'
print(s)
--有占位符时%显示
s = 'jack %s 99%%' % 'xx'  # 如果使用%需要使用%转译
print(s)==> 99%
jack xx 99%# e. 左右对齐
s = 'xxx|%(name)+10s|xxx' % {'name':'eason'}
print(s)
s = 'xxx|%(name)-10s|xxx' % {'name':'eason'}
print(s)==> xxx|     eason|xxx   # 占位10字符，右对齐（+号）
xxx|eason     |xxx   # 占位10字符，左对齐（-号）# f. unicode、8进制、16进制
s = 'unicode:%c   oct:%o,   hex:%x '  % (65, 15, 15)
print(s)==> unicode:A   oct:17,   hex:f   # 分别将值转为unicode，8进制，16进制

# 字符串格式化之format（字符串方法）# a. format的基本使用
s = 'num1:{0}  num2:{0}  num{1}'.format(123,456)  # 位置可以复用
print(s)==> num1:123  num2:123  num456 # 注意字符串有三个需要格式化地方，而我们只传入两个，传入索引是可以被复用的 # b. 指定名字修改
s = 'name:{name:s}  age:{age}'.format(name='eason', age=12)
print(s)
# 使用**迭代字典
s = 'name:{name:s}  age:{age}'.format(**{'name':'eason', 'age':12})
print(s)==> name:eason  age:12
name:eason  age:12  # format不仅支持迭代字典方式，而且支持指定名字修改# c. 会根据传入类型不同自动去转换
s = 'i am {}, age {}, {}'.format('stenven', 18, 2.3)
print(s)==> i am stenven, age 18, 2.3 # 不需要特定指定字符串类型或者Int或者浮点，传入时自动转换# d. 传入迭代列表
s = 'i am {}, age {}, {}'.format(*['stenven', 18, 2.3])   # 使用星号遍历字典每一项
print(s)==> i am stenven, age 18, 2.3  # 迭代列表# e. 取列表中的元素
s = 'i am {0[0]}, age {1[0]}, {0[2]}'.format(['stenven', 18, 2.3], [18,22])   # 使用星号遍历字典每一项
print(s)==> i am stenven, age 18, 2.3 # 当我们没有使用"*[列表]"时，列表会当成一个元素传入，而在format格式化中，也可以读取列表某个索引的位置

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

特点：1. 访问者不需要关心迭代器内部的结构，仅需通过next()方法不断去取下一个内容
2. 不能随机访问集合中的某个值 ，只能从头到尾依次访问
3. 访问到一半时不能往回退
4. 便于循环比较大的数据集合，节省内存# 用我自己简要理解就是：
# 1. 迭代器是一个对象
# 2. 该对象不使用__next__方法不返回值

# 生成器基本概念：用普通的函数语法定义的迭代器# 取出2层嵌套列表生成器
li = [[1,2],[3,4],[5]]
def fla(lis):for sublist in lis:for element in sublist:yield element# 既然生成器本身就是一个迭代器
f = fla(li)
r1 = f.__next__()
print(r1)
r2 = f.__next__()
print(r2)
r3 = f.__next__()
print(r3)
r4 = f.__next__()
print(r4)
r5 = f.__next__()
print(r5)==>
1
2
3
4
5# 进入函数迭代后，遇到了yield，返回了yield返回值，并在此冻结，在下一次被__next__调用的时候，继续从此开始

# 递归，见递归。这是对“递归”最精简的定义
# 其实按照我的理解就是，在函数中调用自己，就是递归# 例1：斐波那契递归
def fib(n):if n <= 2:return 1else:return fib(n-1) + fib(n-2)r = fib(6)    # 查看第六位斐波那契序列数字
print(r)# 例2：递归乘法
def f1(n):if n == 1:return 1return f1(n-1)*nr = f1(5)   # 计算从1到5的阶乘
print(r)

# json序列化
# json序列化4种方法：dumps、dump、loads、load# a. dumps序列化（将Python数据类型转为json格式）
import json
dic = {'k1':'v1'}
print(dic,type(dic))
result = json.dumps(dic)
print(result,type(result))==> {'k1': 'v1'} <class 'dict'>
{"k1": "v1"} <class 'str'>  # dumps 将字典序列化为字符串# b. loads反序列化
dic = json.loads(result)
print(dic, type(dic))==> {'k1': 'v1'} <class 'dict'> # loads 将字符串反序列化为python字典格式# 通过json获得天气接口
import requestsresponse = requests.get('http://wthrcdn.etouch.cn/weather_mini?city=北京')
response.encoding = 'utf-8'dic = json.loads(response.text) # loads 将字符串反序列化为python字典格式
print(dic)  ==>  {'data': {'wendu': '30', 'yesterday': {'low': '低温 19....
print(type(dic))  ==> <class 'dict'>  # 为字典格式# dump与load方法同dumps与loads一样，
li = [11,22,33]
json.dump(li, open('db', 'w'))   # 将列表序列化，并写入文件
li =json.load(open('db', 'r'))  # 读取文件，并反序列化
print(li)==> [11, 22, 33]# 注意：
#    json.loads 或load 反序列化时，由于json对字符串解析原因，请一定要使用单引号括住双引号格式（例： ‘{“k1”:"v1"}’ ），否则json将会反序列化失败报错

# pickle序列化# a. 序列化
import pickle
li = [11,22,33]
r = pickle.dumps(li)  # 序列化
print(r)==> b'\x80\x03]q\x00(K\x0bK\x16K!e.' # 序列后会是一个字节码# b. 反序列化
result = pickle.loads(r)
print(result)==> [11, 22, 33]# c. 对文件操作的序列化与反序列化
li = [11,22,33]
pickle.dump(li, open('db','wb'))   # pickle 需使用字节写入

ret = pickle.load(open('db','rb')) # 以字节方式读取
print(ret)  ==>  [11, 22, 33]  # 注意：
#     1. pickle序列化为字节码，同样反序列化也是将一个字节码转为本身类型
#     2. pickle与json序列化对比：pickle支持所有Python数据类型，而json仅支持部分Python数据类型，json可夸语言，而pickle仅支持Python，所以各有各的好处与坏处

# time模块
import time,datetime
# a. 时间戳
print(time.time())   # 显示为从1970年1月1日0点开始到现在的秒数（1970年为Unix元年）==> 1465484260.5525756 # b. ctime方法（获取时间字符串格式）
print(time.ctime())  # 系统现在时间的字符串格式
print(time.ctime(time.time()-86640)) # ctime可以传入时间戳参数，例如当前时间戳减去一天秒数==> Thu Jun  9 22:57:40 2016  # 现在时间字符串格式
Wed Jun  8 22:53:40 2016  # 减去一天时间字符串格式# c. gmtime方法（struct_time）
print(time.gmtime())==> time.struct_time(tm_year=2016, tm_mon=6, tm_mday=9, tm_hour=15, tm_min=0, tm_sec=15, tm_wday=3, tm_yday=161, tm_isdst=0)
### gmtime会返回一个对象，找个对象叫做struct_time

time_obj = time.gmtime()
print(time_obj.tm_year, time_obj.tm_mon)
print("{year}-{mon}".format(year=time_obj.tm_year, mon=time_obj.tm_mon))==> 2016 6 # gmtime可以通过以上方式调用使用
2016-6  # 同样我们可以配合使用format，输出自己想要的格式print(time.gmtime(time.time()-86640))  # 同样gmtime可以传入时间戳参数# 注意： gmtime默认返回的struct_time是格林威治时间# d. localtime
print(time.localtime(time.time()-86640)) # 将时间戳转换成struct_time，但返回的本地时间==> time.struct_time(tm_year=2016, tm_mon=6, tm_mday=8, tm_hour=23, tm_min=21, tm_sec=24, tm_wday=2, tm_yday=160, tm_isdst=0)
# 与gmtime一样返回struct_time格式，但是返回本地时间而不是格林威治时间# e. mktime（将struct_time格式转换为时间戳格式）
print(time.mktime(time.localtime()))   # 与time.localtime()功能相反，将struct_time格式转回城时间戳格式==> 1465485924.0# f. time.sleep() 程序睡眠
time.sleep(4)  # 程序睡眠4s# g. strftime（将struct_time格式转换为指定的字符串格式）
print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) ) ==> 2016-06-09 15:30:32   # 注意gmtime和localtime区别使用# h. strptime(将字符串格式转换成struct_time格式)
print(time.strptime("2016-01-28","%Y-%m-%d") )==> time.struct_time(tm_year=2016, tm_mon=1, tm_mday=28, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=28, tm_isdst=-1)

# datetime模块# a. 输出当天字符串
print(datetime.date.today())==> 2016-06-09# b. 将时间戳转成日期格式
print(datetime.date.fromtimestamp(time.time()))==> 2016-06-09# c. 将现在时间转为struct_time格式
current_time = datetime.datetime.now() #
print(current_time) #输出2016-01-26 19:04:30.335935
print(current_time.timetuple()) #返回struct_time格式==>2016-06-09 23:38:58.100283
time.struct_time(tm_year=2016, tm_mon=6, tm_mday=9, tm_hour=23, tm_min=38, tm_sec=58, tm_wday=3, tm_yday=161, tm_isdst=-1)# d. 使用datetime进行时间的加减
new_date = datetime.datetime.now() + datetime.timedelta(days=10) #比现在加10天
print(new_date)==> 2016-06-19 23:44:48.365317new_date = datetime.datetime.now() + datetime.timedelta(days=-10) #比现在减10天
print(new_date)==> 2016-05-30 23:44:48.365317new_date = datetime.datetime.now() + datetime.timedelta(hours=-10) #比现在减10小时
print(new_date)==> 2016-06-09 13:44:48.365317new_date = datetime.datetime.now() + datetime.timedelta(seconds=120) #比现在+120s
print(new_date)==> 2016-06-09 23:46:48.365317# e. 修改时间
current_time = datetime.datetime.now()
print(current_time.replace(2014,9,12)) # 输出2014-09-12 23:48:52.619287,返回当前时间,但指定的值将被替换==> 2014-09-12 23:48:52.619287# f. 时间前后的比较
current_time = datetime.datetime.now()  # 当前时间
current2_time = current_time.replace(2014,9,12) # 替换14年9月份时间# 首先我们要知道，我们这两个变量并不是字符串格式，而是datetime格式
print(type(current_time))==> <class 'datetime.datetime'>  print(current_time>current2_time)  # ==> True
print(current_time<current2_time)  # ==> False# 时间格式是可以直接对比比较的

# 日志模块
import logging# a. 初识
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
# 直接使用，默认打印到屏幕，并且默认还帮你补充了root用户# b. 日志级别
DEBUG、INFO、WARNING、ERROR、CRITICAL
# 分别对应方法：
logging.debug('debug')
logging.info('info')
logging.warning('warning')
logging.error('error')
logging.critical('critical')# c. 将日志不输出到屏幕，而是存入log文件
logging.basicConfig(filename='example.log',level=logging.INFO) # 指定log文件名,log级别
logging.debug('This message should go to the log file')
logging.info('So should this')
logging.warning('And this, too')# example.log == >
INFO:root:So should this
WARNING:root:And this, too  # 因为我们日志级别为INFO，所以并没有将debug日志写入到日志文件# d. 日志中增加时间
logging.basicConfig(filename='example.log',level=logging.INFO，
format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')  # 这里format参数中%(asctime)s 表示时间占位符
logging.warning('is when this event was logged.')# example.log ==>
06/10/2016 01:16:49 AM So should this
06/10/2016 01:16:49 AM And this, too

# logging进阶import logging#create logger
# 刚刚我们默认输出日志中增加一个root, getLogger参数指定root那个位置索要显示的用户名也好或者你自定义标记
logger = logging.getLogger('TEST-LOG')
# setLevel方法设定一个全局的日志级别
logger.setLevel(logging.DEBUG)# create console handler and set level to debug
# 我要输出到哪里，决定权在handler
# StreamHandler屏幕输出日志
ch = logging.StreamHandler()
# setLevel 设置屏幕输出日志的级别（相对于全局，这就是一个局部日志级别）
ch.setLevel(logging.DEBUG)# create file handler and set level to warning
# FileHandler文件输出日志
fh = logging.FileHandler("access.log")
# 同样，setLevel给我们文件输出日志也定义一个级别
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
# 我们刚刚定义屏幕输出对象（ch）和文件输出对象（fh），相当于注册到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')