python study day5 基础篇
字符串格式化
Python的字符串格式化有两种方式: 百分号方式、format方式
在两种字符串格式化中%为先前的字符串格式方式，后来python为了针对字符串格式化有更多的操作，python引入了format字符串格式化的方式。现在两种字符串格式化方式并存，目前使用format 字符串格式化方式较多，以后有可能format会代替%。
百分号方式
语法：
%[(name)][flags][width].[precision]typecode
- u [(name)] 可选，可用于选择指定的key
- u [flags] 可选，可供用于选择的值有：
- l + 右对齐；正数前加正好，负数前加负号；
- l - 左对齐；正数前无符号，负数前加负号
- l 空格 右对齐；正数前加空格，负数前加负号
- l 0 右对齐； 正数前无符号，负数前加负号；用0填充空白处
- u [width] 可选，占有宽度
- u .precision 可选，小数点后保留的位数
- u Typecode 必选
- l S.获取传入对象的_str_方法的返回值，并将其格式化到指定位置
- l r.获取传入对象的_repr_方法的返回值，并将其格式化到指定位置
- l c.整数： 将数字转换成器unicode对应的值，10进制范围为0<=i<=1114111(py27则支持0-255)；字符：将字符添加到指定位置
- l o，将整数转换成 八 进制表示，并将其格式化到指定位置
- l x，将整数转换成十六进制表示，并将其格式化到指定位置
- l d，将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置
- l e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
- l E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
- l f， 将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
- l F，同上
- l g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
- l G，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
- l %，当字符串中存在格式化标志时，需要用 %%表示一个百分号
常用字符串格式化范例：
demo = "i am %s" % "jack"
demo = "i am %s age %d" % ("jack", 18)
demo = "i am %(name)s age %(age)d" % {"name": "jack", "age": 18}
demo = "percent %.2f" % 99.97623
demo = "i am %(pp).2f" % {"pp": 123.425556, }
demo = "i am %.2f %%" % {"pp": 123.425556, }
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位）
字符串格式化范例：
demo = "i am {}, age {}, {}".format("seven", 18, 'eric')
demo = "i am {}, age {}, {}".format(*["seven", 18, 'eric'])
demo = "i am {0}, age {1}, really {0}".format("seven", 18)
demo = "i am {0}, age {1}, really {0}".format(*["seven", 18])
demo = "i am {name}, age {age}, really {name}".format(name="seven", age=18)
demo = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})
demo = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
demo = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)
demo = "i am {:s}, age {:d}".format(*["seven", 18])
demo = "i am {name:s}, age {age:d}".format(name="seven", age=18)
demo = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})
demo = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
demo = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
demo = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
demo = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)
递归
递归不断的执行函数本身，直到到达某种条件后，函数执行完成，有返回值。
递归范例：
def func(n):
n += 1
if n > 4:
return "end"
return func(n)
r = func(1)
print(r)
迭代器和生成器
迭代器
迭代器就是针对某一个数据集合访问，从数据集合中的第一个元素开始访问，依次向下访问，直到集合中的最后一个元素访问结束，迭代器指定向前不能后退。
迭代器的特点：
- 访问者不需要关心迭代器内部的结构，仅需要通过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
生成器
一个函数调用时返回一个迭代器，那这个函数就叫做生成器（generator）；如果函数中包含yield语法，那这个函数就会变成生成器；
生成器范例：
def myrange(arg):
start = 0
while True:
if start >3:
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)
#实际使用当中直接使用for循环取值，不使用_next_。
for i in ret:
print i
json和pickle序列化和反序列化
import json dic={"k1":"v1"} ret=json.dumps(dic) #将python的基本数据类型转换成字符串 print(ret,type(ret)) s1='{"k2":123}' result=json.loads(s1) #将字符串转换成python的基本数据类型 一定要使用双引号 print(result,type(result)) li=[11,22,33] json.dump(li,open('db','w')) #写入文件 li=json.load(open('db','r')) #从文件读 print(type(li),li)
import pickle li=[11,22,33] r=pickle.dumps(li) #将python的数据类型转换成字符串。 print(r) m=pickle.loads(r) #将字符串样式的python数据类型转换成python的基本数据类型。 print(m) dic={"k1":123} r=pickle.dump(dic,open('db','wb')) #将python基本数据类型以字符串样式写入文件。 r=pickle.load(open("db","rb")) #在文件中读取字符串样式的python基本数据类型转换成python 基本数据类型。 print(r,type(r))
json和pickle对比： #json更加适合跨语言，字符串，只适用于基本数据类型。 #pickle适用于python所有类型的序列化，仅适用于python。 json用的比较多
time模块主要方法：
import time #生成时间戳 print(time.time()) print(time.mktime(time.localtime())) #1575270580.4648929 #1575270580.0 #生成gtime_struct_time print(time.gmtime()) print(time.gmtime(time.time())) #time.struct_time(tm_year=2019, tm_mon=12, tm_mday=2, tm_hour=7, tm_min=13, tm_sec=47, tm_wday=0, tm_yday=336, tm_isdst=0) #生成localtime_struct_time print(time.localtime()) print(time.localtime(time.time())) #time.struct_time(tm_year=2019, tm_mon=12, tm_mday=2, tm_hour=15, tm_min=13, tm_sec=47, tm_wday=0, tm_yday=336, tm_isdst=0) #将字符串时间格式转换成struct_time时间格式 time_object=time.strptime("2017-10-1 10:23:22",'%Y-%m-%d %H:%M:%S') print(time_object,type(time_object)) #time.struct_time(tm_year=2017, tm_mon=10, tm_mday=1, tm_hour=10, tm_min=23, tm_sec=22, tm_wday=6, tm_yday=274, tm_isdst=-1) <class 'time.struct_time'> #将struct_time时间格式转换成字符串时间格式 print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()),type(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))) print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()),type(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()))) #2019-12-02 15:25:28 <class 'str'> #2019-12-02 07:25:28 <class 'str'> #生成固定格式时间 a=time.asctime(time.gmtime())#可以转换struct_time格式的时间到固定格式时间 print(a,type(a)) b=time.ctime() #只能转换时间戳格式的时间到固定格式时间 print(b,type(b)) #Mon Dec 2 07:28:29 2019 <class 'str'> #Mon Dec 2 15:28:29 2019 <class 'str'>
struct_time元组元素结构
属性 值 tm_year（年） 比如2011 tm_mon（月） 1 - 12 tm_mday（日） 1 - 31 tm_hour（时） 0 - 23 tm_min（分） 0 - 59 tm_sec（秒） 0 - 61 tm_wday（weekday） 0 - 6（0表示周一） tm_yday（一年中的第几天） 1 - 366 tm_isdst（是否是夏令时） 默认为-1
format time结构化时间表示：
格式 含义 %a 本地（locale）简化星期名称 %A 本地完整星期名称 %b 本地简化月份名称 %B 本地完整月份名称 %c 本地相应的日期和时间表示 %d 一个月中的第几天（01 - 31） %H 一天中的第几个小时（24小时制，00 - 23） %I 第几个小时（12小时制，01 - 12） %j 一年中的第几天（001 - 366） %m 月份（01 - 12） %M 分钟数（00 - 59） %p 本地am或者pm的相应符 %S 秒（01 - 61） %U 一年中的星期数。（00 - 53星期天是一个星期的开始。）第一个星期天之前的所有天数都放在第0周。 %w 一个星期中的第几天（0 - 6，0是星期天） %W 和%U基本相同，不同的是%W以星期一为一个星期的开始。 %x 本地相应日期 %X 本地相应时间 %y 去掉世纪的年份（00 - 99） %Y 完整的年份 %Z 时区的名字（如果不存在为空字符） %% ‘%’字符
时间加减
print(time.time()-100000) #以时间戳(S)格式加减 #1575172804.8181186
mt=time.localtime(time.time()-100000) #先通过时间戳加减时间，然后转换成struct_time, bb=time.strftime("%Y-%m-%d %H:%M:%S",mt)#把sturct_time转换成自定义的字符串时间格式 print(bb,type(bb)) #2019-12-01 12:29:31 <class 'str'>
datetime模块
datetime提供用于处理日期和时间的类，datetime模块封装了time模块的功能，在支持日期时间运算的同时，实现的关注点更着重于如何能够有效地解析其属性，用于格式化输出和数据操作。
from datetime import * #导入模块 ta=datetime.now() #获取当前的日期和时间 print(ta) 2019-12-03 14:56:17.895183 ta=datetime.today() #获取今天的日期和时间 print(ta) 2019-12-03 15:01:20.822510 ta=date.today() #获取今天的日期 print(ta) 2019-12-03 ta=date.today()+timedelta(days=1) #获取明天的日期 print(ta) 2019-12-04 ta=date.today()-timedelta(days=3) #获取前三天日期 print(ta) 2019-11-30 ta=datetime.combine(date.today(),time.min)#获取当天的起始时间 print(ta) 2019-12-03 00:00:00 ta=datetime.combine(date.today(),time.max)#获取当天的最大时间 print(ta) 2019-12-03 23:59:59.999999 ta=(datetime(2019,12,3,10,0,0)-datetime.now()).total_seconds() #获取两个datetime时间差 print(ta) -18597.315051 ta=date.today()+timedelta(6-date.today().weekday())#获取本周的最后一天 print(ta) 2019-12-08 ta=datetime.now().strftime("%Y-%m-%d %H:%M:%S") # 把现在日期时间转换成字符串日期时间格式，eg:2019-12-03 11:13:47 print(ta,type(ta)) 2019-12-03 15:23:01 <class 'str'> ta=datetime.strptime("2014-10-11 18:20:10","%Y-%m-%d %H:%M:%S") #把字符串日期时间格式转换成日期时间格式 print(ta,type(ta)) 2014-10-11 18:20:10 <class 'datetime.datetime'> ta=datetime.now().timetuple() #当前时间转换成struct_time print(ta) time.struct_time(tm_year=2019, tm_mon=12, tm_mday=3, tm_hour=15, tm_min=26, tm_sec=9, tm_wday=1, tm_yday=337, tm_isdst=-1) ta=datetime.now().date() #获取当前和今天的日期 ta=date.today() print(ta) 2019-12-03 ta=datetime.fromtimestamp(1838728379.0) #timestamp时间戳转换成日期时间 print(ta) 2028-04-07 21:52:59 ta=datetime(2016,10,20,10,30,11) #日期时间格式转换成timestamp时间戳 ta=ta.timestamp() print(ta) 1476930611.0
logging
日志记录
import logging
logging.basicConfig(filename='log.log',
format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',
level=10)
logging.debug('debug')
logging.info('info')
logging.warning('warning')
logging.error('error')
logging.critical('critical')
logging.log(10,'log')
日志等级
CRITICAL = 50 FATAL = CRITICAL ERROR = 40 WARNING = 30 WARN = WARNING INFO = 20 DEBUG = 10 NOTSET = 0
注意：只有大于当前日志等级的操作才会被记录。
logging可配置属性
日志同时打印到屏幕和文件日志高级进阶案例
#create logger
logger = logging.getLogger('TEST-LOG') #首先获取对象
logger.setLevel(logging.DEBUG) #设置一个全局的log级别
# create console handler and set level to debug
ch = logging.StreamHandler() #print the log monitor
ch.setLevel(logging.CRITICAL) #在屏幕上输出
# create file handler and set level to warning
fh = logging.FileHandler("access.log") #文件输出
fh.setLevel(logging.DEBUG)
# 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) #把Handler注册给logger
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')
