所有常用模块的用法： http://www.cnblogs.com/Eva-J/articles/7228075.html
前情回顾：
# 常用模块 # 常用模块 —— 东西多 # 异常处理 # 什么是模块 # 面向对象 #面向对象编程 ： #面向函数编程 ：多用面向函数的思路写代码
正则复习：
import re
# ret = re.findall(r'www\.baidu\.com|www\.oldboy\.com',r'www.baidu.com')
# ret = re.findall(r'www\.(baidu|oldboy)\.com',r'www.baidu.com') #findall取组内
# ret = re.findall(r'www\.(?:baidu|oldboy)\.com',r'www.baidu.com') #findall取组所有匹配的
# print(ret)
#分组优先：优先显示括号内部的内容
#取消分组优先
# ret = re.search(r'www\.(?P<web_name>baidu|oldboy)\.com',r'www.baidu.com').group('web_name') #search取组内
# ret = re.search(r'www\.(?P<web_name>baidu|oldboy)\.com',r'www.baidu.com').group() #search取全组
# print(ret)
# ret=re.split("\d+","eva3egon4yuan")
# print(ret) #结果 ： ['eva', 'egon', 'yuan']
#
# ret=re.split("(\d+)","eva3egon4yuan")
# print(ret) #结果 ： ['eva', '3', 'egon', '4', 'yuan']
# ret = re.search("<\w+>\w+</\w+>","<h1>hello</h1>")
# ret = re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")
# print(ret.group('tag_name')) #结果 ：h1
# print(ret.group()) #结果 ：<h1>hello</h1>
#分组的命名和组的引用
# ret = re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>")
# print(ret.group(1))
#如果不给组起名字，也可以用\序号来找到对应的组，表示要找的内容和前面的组内容一致
#获取的匹配结果可以直接用group(序号)拿到对应的值
# print(ret.group()) #结果 ：<h1>hello</h1>
# ret = re.findall(r"<(\w+)>\w+</\1>","<h1>hello</h1>")
# print(ret)
# ret=re.findall(r"\d+","1-2*(60+(-40.35/5)-(-4*3))")
# print(ret)
# 40.35
#\d+\.\d+|\d+ [^]
ret=re.findall(r"\d+\.\d+|(\d+)","1-2*(60+(-40.35/5)-(-4*3))")
print(ret)
ret.remove('')
print(ret)
爬虫练习：
import re
from urllib.request import urlopen
def getPage(url):
response = urlopen(url) #bytes
return response.read().decode('utf-8')
def parsePage(s):
com = re.compile(
'<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>\d+).*?<span class="title">(?P<title>.*?)</span>'
'.*?<span class="rating_num" .*?>(?P<rating_num>.*?)</span>.*?<span>(?P<comment_num>.*?)评价</span>', re.S)
ret = com.finditer(s)
for i in ret:
yield {
"id": i.group("id"),
"title": i.group("title"),
"rating_num": i.group("rating_num"),
"comment_num": i.group("comment_num"),
}
def main(num):
url = 'https://movie.douban.com/top250?start=%s&filter=' % num
response_html = getPage(url)
ret = parsePage(response_html)
print(ret)
f = open("move_info7", "a", encoding="utf8")
for obj in ret:
print(obj)
data = str(obj)
f.write(data + "\n")
count = 0
for i in range(10):
main(count)
count += 25
collection模块：
# print(r'\n') #表示取消字符串内所有转译符的转译作用 real
# print('\n') #'\'转译符，n，加上转译符 \n --> 换行了
# print('\\n') #'\'转译符，n，加上转译符 \n --> 换行了
#
#结论就是：在工具里什么样，挪到python里加个r
# from collections import Iterator #迭代器
# from collections import Iterable #可迭代对象
# from collections import namedtuple
# point1 = (1,1)
# x = point1[0]
# y = point1[1]
# P = namedtuple('Point',['x','y'])
# p1 = P(1,2)
# p2 = P(3,4)
# print(p1.x)
# print(p1.y)
# print(p2.x)
# print(p2.y)
# 描述一类东西的时候，这一类东西都有相同的特征。
# 想直接用特征的名字就描述这个值的时候，就可以用可命名元祖
# 面向对象的时候还会再讲
# 生日：年月日 （2011，11，11） #练习
#队列
# import queue #队列_多线程多进程
# q = queue.Queue()
# q.put([1])
# q.put(2) #处理任务
# q.put(300)
# q.put('aaa')
# q.put('wahaha')
# # print(q.qsize())
# print(q.get())
# print(q.get())
# print(q.get())
# print(q.get())
# print(q.get()) #hold住的功能
# print(q.qsize())
# print(q.get_nowait()) #如果没有不会hold住，且会报错
# from collections import deque
# dq = deque()
# dq.append('a')
# dq.append('b')
# dq.appendleft('c')
# print(dq.popleft())
# from collections import OrderedDict
# od = OrderedDict([('a', [1,2,3,4]), ('b', 2), ('c', 3)])
# for k in od:
# print(k,od[k])
# l = [11,22,33,44,55,66,77,88,99,90]
# dic = {}
# for i in l:
# if i > 66:
# if 'k1' in dic:
# dic['k1'].append(i)
# else:
# dic['k1'] = []
# dic['k1'].append(i)
# from collections import defaultdict
# def func():
# return 0
# my_dict = defaultdict(func)
# # my_dict = {}
# print(my_dict['k'])
time模块：
import time
# print(time.time()) #时间戳：记录了从1970.1.1到现在的所有秒
# time.sleep(1)
# ret = time.strftime('%Y-%m-%d %a %H:%M:%S') #string format time
# print(ret)
# print(time.localtime())
# print(time.gmtime())
# print(time.time())
#1000000000
# ret = time.localtime(3000000000)
# print(ret)
# print(time.mktime(ret))
# ret2 = time.strftime('%c',ret)
# print(ret2)
# print(time.strptime('1990-3-31','%Y-%m-%d'))
# print(time.mktime(time.strptime('1990-3-31','%Y-%m-%d')))
# print(time.asctime())
# print(time.asctime(time.localtime(1000000)))
# print(time.ctime(1000000))
# start_time = 1500000000
# now = time.time()
# print(now - start_time)
# struct_time = time.gmtime(now - start_time)
# print(struct_time.tm_year - 1970)
# print(struct_time.tm_mon - 1)
# print(struct_time.tm_mday - 1)
# import time
# true_time=time.mktime(time.strptime('2017-09-11 11:30:00','%Y-%m-%d %H:%M:%S'))
# time_now=time.mktime(time.strptime('2017-09-12 10:00:06','%Y-%m-%d %H:%M:%S'))
# dif_time=time_now-true_time
# struct_time=time.gmtime(dif_time)
# print('过去了%d年%d月%d天%d小时%d分钟%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,
# struct_time.tm_mday-1,struct_time.tm_hour,
# struct_time.tm_min,struct_time.tm_sec))
常用方法:
#常用方法 1.time.sleep(secs) (线程)推迟指定的时间运行。单位为秒。 2.time.time() 获取当前时间戳
表示时间的三种方式
在Python中，通常有这三种方式来表示时间：时间戳、元组(struct_time)、格式化的时间字符串：
(1)时间戳(timestamp) ：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。
(2)格式化的时间字符串(Format String)： ‘1999-12-06’
%y 两位数的年份表示（00-99） %Y 四位数的年份表示（000-9999） %m 月份（01-12） %d 月内中的一天（0-31） %H 24小时制小时数（0-23） %I 12小时制小时数（01-12） %M 分钟数（00=59） %S 秒（00-59） %a 本地简化星期名称 %A 本地完整星期名称 %b 本地简化的月份名称 %B 本地完整的月份名称 %c 本地相应的日期表示和时间表示 %j 年内的一天（001-366） %p 本地A.M.或P.M.的等价符 %U 一年中的星期数（00-53）星期天为星期的开始 %w 星期（0-6），星期天为星期的开始 %W 一年中的星期数（00-53）星期一为星期的开始 %x 本地相应的日期表示 %X 本地相应的时间表示 %Z 当前时区的名称 %% %号本身 python中时间日期格式化符号：
(3)元组(struct_time) ：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）
| 索引（Index） | 属性（Attribute） | 值（Values） |
|---|---|---|
| 0 | tm_year（年） | 比如2011 |
| 1 | tm_mon（月） | 1 - 12 |
| 2 | tm_mday（日） | 1 - 31 |
| 3 | tm_hour（时） | 0 - 23 |
| 4 | tm_min（分） | 0 - 59 |
| 5 | tm_sec（秒） | 0 - 60 |
| 6 | tm_wday（weekday） | 0 - 6（0表示周一） |
| 7 | tm_yday（一年中的第几天） | 1 - 366 |
| 8 | tm_isdst（是否是夏令时） | 默认为0 |
时间戳-结构化时间-格式化时间
三者的互相转换:
从时间字符串到时间戳之间的互逆转换（一般我们用到的两种格式，要么是时间字符串，要么就是时间戳，一般用时间戳比较方便，便于在数据库查询中做条件筛选，前后端交互时前端传过来的有可能是格式化的时间字符串，还有可能是时间戳）这是从“时间字符串--结构化时间--时间戳”的过程time_str = "2019-2-20 12:23:43" format_time_str = time.strptime(time_str, "%Y-%m-%d %H:%M:%S") print(time.mktime(format_time_str)) # 1550636623.0这是从“时间戳--结构化时间--时间字符串”
timeStamp = 1550636623.0structTime = time.gmtime(timeStamp)/time.localtime(timeStamp) {gmtime是英国伦敦的时间，相较于localtime本地时间，晚8个小时的时差，在结构上和格式转换上两个都可以用}print(time.strftime("%Y-%m-%d %H:%M:%S", structTime)) # 2019-02-20 04:23:43
#导入时间模块
>>>import time
#时间戳
>>>time.time()
1500875844.800804
#时间字符串
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 13:54:37'
>>>time.strftime("%Y-%m-%d %H-%M-%S")
'2017-07-24 13-55-04'
#时间元组:localtime将一个时间戳转换为当前时区的struct_time
time.localtime()
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24,
tm_hour=13, tm_min=59, tm_sec=37,
tm_wday=0, tm_yday=205, tm_isdst=0)
#时间戳-->结构化时间 #time.gmtime(时间戳) #UTC时间，与英国伦敦当地时间一致 #time.localtime(时间戳) #当地时间。例如我们现在在北京执行这个方法：与UTC时间相差8小时，UTC时间+8小时 = 北京时间 >>>time.gmtime(1500000000) time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0) >>>time.localtime(1500000000) time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0) #结构化时间-->时间戳 #time.mktime(结构化时间) >>>time_tuple = time.localtime(1500000000) >>>time.mktime(time_tuple) 1500000000.0
#结构化时间-->字符串时间
#time.strftime("格式定义","结构化时间") 结构化时间参数若不传，则现实当前时间
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 14:55:36'
>>>time.strftime("%Y-%m-%d",time.localtime(1500000000))
'2017-07-14'
#字符串时间-->结构化时间
#time.strptime(时间字符串,字符串对应格式)
>>>time.strptime("2017-03-16","%Y-%m-%d")
time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1)
>>>time.strptime("07/24/2017","%m/%d/%Y")
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)
#结构化时间 --> %a %b %d %H:%M:%S %Y串 #time.asctime(结构化时间) 如果不传参数，直接返回当前时间的格式化串 >>>time.asctime(time.localtime(1500000000)) 'Fri Jul 14 10:40:00 2017' >>>time.asctime() 'Mon Jul 24 15:18:33 2017' #时间戳 --> %a %d %d %H:%M:%S %Y串 #time.ctime(时间戳) 如果不传参数，直接返回当前时间的格式化串 >>>time.ctime() 'Mon Jul 24 15:19:07 2017' >>>time.ctime(1500000000) 'Fri Jul 14 10:40:00 2017'
import time
true_time=time.mktime(time.strptime('2017-09-11 08:30:00','%Y-%m-%d %H:%M:%S'))
time_now=time.mktime(time.strptime('2017-09-12 11:00:00','%Y-%m-%d %H:%M:%S'))
dif_time=time_now-true_time
struct_time=time.gmtime(dif_time)
print('过去了%d年%d月%d天%d小时%d分钟%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,
struct_time.tm_mday-1,struct_time.tm_hour,
struct_time.tm_min,struct_time.tm_sec))
计算时间差
datetime模块:
import datetime print(datetime.datetime.now()) # 获取当前时间,直接得到年月日时分秒的格式结果 print(datetime.datetime.now()+datetime.timedelta(days=2)) # 得到当前时间两天后的时间,用-2得到当前时间两天前的时间 print(datetime.datetime.now()+datetime.timedelta(hours=-2)) # 得到当前时间两个小时前的时间,用2得到当前时间两个小时后的时间 print(datetime.datetime.now()+datetime.timedelta(minutes=5)) # 得到当前时间5分钟后的时间,用-5得到当前时间5分钟前的时间 print(datetime.datetime.now()+datetime.timedelta(seconds=30)) # 得到当前时间30秒后的时间,换成-30就是当前时间30秒前的时间 # 写项目时会有需要得出当前时间前/后日/时/分/秒的结果,这个模块最大的时间单位是天,day,没有月年
sys模块：
import sys
# print(sys.platform)
# print(sys.version)
# sys.exit(0)
# sys.exit(1)
# print(sys.path)
# 就是模块导入的时候从这个列表中的路径依次去寻找模块
# 找到了就停止
# sys.path的第一位元素是当前被执行的python文件所在的地址
# 之后的地址依次是python内部的库
print(sys.argv)
#python 6sys.py
#python 6sys.py alex 3714
args_lst = sys.argv #['6sys.py', 'alex', '3714']
if len(args_lst) ==3 and args_lst[1] == 'alex' and args_lst[2] == '3714':
print('执行程序了')
else:
sys.exit()
#sys.argv的第一个值是固定的的，就是这个文件的名字
#之后的参数 是在控制台执行py文件的时候传入的参数 python 6sys.py alex 3714
#我们可以用这些参数来直接完成一些校验类的工作
来源：https://www.cnblogs.com/2012-dream/p/7832568.html