所有常用模块的用法：  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())

#

# 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.0
structTime = 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,没有月年

def func():
　　ss = "12/18/2019"
　　ret = ss.split("/")
　　print(ret, type(ret), type(int(ret[0])))
　　l = []
　　for item in ret:
　　　　l.append(int(item))
　　s = datetime.date(l[-1],l[0],l[1])
　　print(s, type(s))



func()


['12', '18', '2019'] <class 'list'> <class 'int'>
2019-12-18 <class 'datetime.date'>




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] == '':

    print('执行程序了')

else:

    sys.exit()

#sys.argv的第一个值是固定的的，就是这个文件的名字

#之后的参数 是在控制台执行py文件的时候传入的参数 python 6sys.py alex 3714

#我们可以用这些参数来直接完成一些校验类的工作




												


											
day20 模块-sys,time,collection的更多相关文章
	

    
								
  1. day20 模块 collections  time sys  os
		
    1.模块 1. 模块的定义:我们把装有特定功能的代码进行归类的结果.我们目前写的所有py文件都是模块 2. 引入模块的方式: 1.import 模块名 2.from xxx import 模块名 2. ...
    
		
    2. 
						
  2. python模块(sys)
		
    SYS模块 sys.argv # 命令行参数List,第一个元素是程序本身路径 sys.exit(n) # 退出程序,正常退出时exit(0) sys.version # 获取Python解释程序的版 ...
    
		
    3. 
						
  3. Python:time模块/random模块/os模块/sys模块
		
    time 模块 #常用方法 1.time.sleep(secs) (线程)推迟指定的时间运行.单位为秒. 2.time.time() 获取当前时间戳 python中时间日期格式化符号: %y 两位数的 ...
    
		
    4. 
						
  4. 4-24日 collections模块  random模块  time模块   sys模块  os模块
		
    1, collections模块 在内置数据类型(dict.list.set.tuple)的基础上,collections模块还提供了几个额外的数据类型:Counter.deque.defaultdi ...
    
		
    5. 
						
  5. python  解释器交互模块 -- sys
		
    sys模块是与python解释器交互的一个接口 sys.argv 命令行参数List,第一个元素是程序本身路径 sys.getdefaultencoding(): 获取系统当前编码,一般默认为asci ...
    
		
    6. 
						
  6. python 全栈开发，Day27(复习, defaultdict,Counter,时间模块,random模块,sys模块)
		
    一.复习 看下面一段代码,假如运行结果有问题,那么就需要在每一步计算时,打印一下结果 b = 1 c = 2 d = 3 a = b+c print(a) e = a + d print(e) 执行输 ...
    
		
    7. 
						
  7. shelve模块,sys模块,logging模块
		
    1.shelve模块 用于序列化的模块,shelve模块比pickle模块简单,只有open函数,返回类似字典的对象,可读可写;key必须为字符串,而值可以是python所支持的数据类型. impor ...
    
		
    8. 
						
  8. day20 python  sys os time json pickl 正则
		
    字符组 : [字符组] 在同一个位置可能出现的各种字符组成了一个字符组,在正则表达式中用[]表示 字符分为很多类,比如数字.字母.标点等等. 假如你现在要求一个位置....9这10个数之一. 量词 几 ...
    
		
    9. 
						
  9. python3模块: sys
		
    一.简介 sys模块用于提供对python解释器的相关操作. 二.常用函数 sys.argv 命令行参数List,第一个元素是程序本身路径 sys.modules 返回系统导入的模块字段,key是模块 ...
    
		
    10. 
		

	


随机推荐
	

    
									
  1. TCP和UDP的对比
			
    UDP #面向报文 UDP 是一个面向报文(报文可以理解为一段段的数据)的协议.意思就是 UDP 只是报文的搬运工,不会对报文进行任何拆分和拼接操作. 具体来说 在发送端,应用层将数据传递给传输层的  ...
    
			
    2. 
						
  2. RefineDet算法笔记
			
    ---恢复内容开始--- 一.创新点 针对two-stage的速度慢以及one-stage精度不足提出的方法,refinedet 包括三个核心部分:使用TCB来转换ARM的特征,送入ODM中进行检测: ...
    
			
    3. 
						
  3. 再谈树形dp
			
    上次说了说树形dp的入门 那么这次该来一点有难度的题目了: UVA10859 Placing Lampposts 给定一个n个点m条边的无向无环图,在尽量少的节点上放灯,使得所有边都与灯相邻(被灯照亮 ...
    
			
    4. 
						
  4. SpringBoot集成Shiro
			
    Shiro是一个安全框架,控制登陆,角色权限管理(身份认证.授权.回话管理.加密) Shiro不会去维护用户,维护权限:这些需要通过realm让开发人员自己注入 1.在pom.xml中引入shiro的 ...
    
			
    5. 
						
  5. 课外知识----ini
			
    ini    初始化英文单词的缩写,用来初始化参数 ini文件配置 [小节] 键=值 [小节] 键=值
    
			
    6. 
						
  6. hdu1565 用搜索代替枚举找可能状态或者轮廓线解（较优），参考poj2411
			
    这题用直接枚举是超时的,必须要用搜索来搜索出所有可能的状态,然后再进行枚举 这是较慢的做法 /* 方格取数,相邻格子的数不可取,问最多取到的和是什么 有点类似炮兵布阵,先打出所有可能的状态,然后dp[ ...
    
			
    7. 
						
  7. beego获取用户请求参数的方法
			
    我们经常需要获取用户传递的数据,包括 Get.POST 等方式的请求,beego 里面会自动解析这些数据,你可以通过如下方式获取数据: GetString(key string) string Get ...
    
			
    8. 
						
  8. 如何录制Chrome或者Linux下的应用
			
    说明: PortMapping的这种用法其实早就有了,开始我一直没注意到这点,后面才发现了这个功能,特别在<性能测试进阶指南Loadrunner11实战>第二版中更新. 不是所有的对象都能 ...
    
			
    9. 
						
  9. Duplicate 复制数据库 搭建Dataguard
			
    1 操作系统环境 此处隐藏具体信息 System IP-address db_name db_version Comment         Target DB         Auxiliary D ...
    
			
    10. 
						
  10. ActiveSync中的SendMail
			
           SendMail命令是专门用于发送MIME格式邮件的.在这里,子元素ClientId必须不同,否则会被认为是同一封邮件,被服务器拒绝.         疑问:ClientId应该是和账户 ...
    
			
    11.