Python21期 day5 之模块

一、模块

模块就是一个包含了Python定义和声明的文件，文件名就是模块名字加上.py的后缀

模块的导入应该在程序开始的地方

导入方法有两种：
import time

from collections import OrderedDict

常用模块

collections模块

在内置数据类型(list , set , tuple , dict)基础上，collections模块还提供了额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict

1、namedtuple：生成可以使用名字来访问元素内容的tuple

2、deque：双端队列，可以快速的从另外一侧追加和推出对象

3、Counter：计数器，用来计数

4、OrderedDict：有序字典

5、defaultdict：带有默认值的字典

namedtuple

tuple是一个不可变集合，例如：一个点的二维坐标就可以表示成：

p = (1,2)

可以使用namedtuple来表示一个坐标
from collections import namedtuple
Point = namedtuple('point',['x','y'])
p = Point(1,2)
print(p.x , p.y)

#结果
1 2

类似的，可以用坐标和半径表示一个圆，也可以用namedtuple定义：

Circle = namedtuple('Circle',['x','y','z'])

deque

使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢，因为list是线性存储，数据量大的时候，插入和删除效率就低

deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈

from collections import deque
q = deque(['a','b','c'])
q.append('x')
q.appendleft('y')
print(q)

#结果
deque(['y', 'a', 'b', 'c', 'x'])

deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效的往头部添加和删除元素

OrderedDict

使用dict时，key是无序的，在对dict做迭代时，无法确定key的顺序。

如果要保持key的顺序，可以用OrderedDict

from _collections import OrderedDict
d = dict([('a',1),('b',2),('c',3),('d',4),('e',5),('f',6)])
print(d)

od = OrderedDict([('a',1),('b',2),('c',3),('d',4),('e',5),('f',6)])
print(od)

OrderedDict的key会按照插入的顺序排列，不是key本身排序

od = OrderedDict()
od['x']=1
od['y']=2
od['z']=3
print(od.keys())

defaultdict

如下集合[11,22,33,44,55,66,77,88,99...]，将所有大于66的值保存至字典的第一个key中，将小于66的值保存至第二个key的值中

即：{‘k1’:大于66 ，'k2'：小于66}

普通代码：

values = [11, 22, 33,44,55,66,77,88,99,90]

dic = {}
for i in values:
    if i > 66:
        if 'k1' in dic:
            dic['k1'].append(i)
        else:
            dic['k1']=[i]
    else:
        if 'k2' in dic:
            dic['k2'].append(i)
        else:
            dic['k2']=[i]
print(dic)

使用defaultdict代码

from _collections import defaultdict

values = [11, 22, 33,44,55,66,77,88,99,90]
my_dict = defaultdict(list)

for i in values:
    if i > 66:
        my_dict['k1'].append(i)
    else:
        my_dict['k2'].append(i)
print(my_dict)

使用dict时，如果引用的key不存在，就会抛出KeyError，如果希望key不存在时，返回一个默认值，可以用defaultdict

dd = defaultdict(lambda: 'N/A')
dd['key1']='abc'
print(dd['key1'])    #key1存在
'abc

print(dd['key2'])    #key2不存在，返回默认值
'N/A'

Counter

用来跟踪值出现的次数，是一个无需的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value

from collections import Counter
c = Counter('abcdeabcdeabc')
print(c)

#结果
Counter({'a': 3, 'b': 3, 'c': 3, 'd': 2, 'e': 2})

时间模块

常用方法：
time.time()
获取当前时间戳

time.sleep(sec)
推迟指定的时间运行，单位为秒

时间的三种表示方式

Python中有三种方式表示时间：时间戳、元祖(struct_time)、格式化的时间字符串

时间戳(timestamp)：通常时间戳表示的是从1970年1月1日00:00:00开始按秒计算，返回的是float类型

格式化时间字符串(Format string)：‘1999-12-12’

%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 当前时区的名称
%% %号本身

元祖(struct_time)：共有9个元素 年、月、日、时、分、秒、一年中第几周、一年中第几天等

导入时间模块
import time

#时间戳
print(time.time())
#结果 1525772214.465437

#时间字符串
print(time.strftime('%Y-%m-%d %H-%M-%S'))
#结果 2018-05-08 17-37-40

#时间元祖：localtime将一个时间戳转换为当前时区的struct_time
print(time.localtime())
#结果
time.struct_time(tm_year=2018, tm_mon=5, tm_mday=8, tm_hour=17, tm_min=38, tm_sec=38, tm_wday=1, tm_yday=128, tm_isdst=0)

小结：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元祖是操作时间的

几种格式之间的转换(Timestamp:时间戳 , struct_time:时间元祖 , Format string:时间字符串)

#时间戳 --> 格式化时间
# print(time.time())
print(time.localtime(1525772677.2285292))
time.struct_time(tm_year=2018, tm_mon=5, tm_mday=8, tm_hour=17, tm_min=44, tm_sec=37, tm_wday=1, tm_yday=128, tm_isdst=0)


#格式化时间 --> 时间戳
time_tuple = time.localtime(1525772677.2285292)
print(time.mktime(time_tuple))

#结构化时间 --> 字符串时间
#time.strftime("格式定义","结构化时间")
print(time.strftime("%Y-%m-%d %X"))
print(time.strftime("%Y-%m-%d %X",time.localtime(1500000000)))
#结果 2017-07-14 10:40:00


#字符串时间 --> 结构化时间
#time.strfptime（时间字符串，字符串对应格式）

print(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)

#结构化时间 --> %a %b %d %H:%M:%S %Y串
#time.asctime(结构化时间) 如果不传参数，直接返回当前时间的格式化串
print(time.asctime(time.localtime(1500000000)))
#Fri Jul 14 10:40:00 2017

print(time.asctime())
#Tue May  8 17:55:15 2018

#时间戳 --> %a %d %d %H:%M:%S %Y串
#time.ctime(时间戳)  如果不传参数，直接返回当前时间的格式化串
print(time.ctime())
#Tue May  8 18:03:46 2018

print(time.ctime(1500000000))
#Fri Jul 14 10:40:00 2017

random

返回随机生成的一个实数，它在[0,1)范围内。

import random

#随机小数
print(random.random())
#0.9196586377243571

print(random.uniform(1,5))   #大于1小于5的小数
#2.341902430898393

#随机整数
print(random.randint(1,5))   #大于1小于5的整数
#4
print(random.randrange(1,10,2))  #大于1小于10的技术活
#7

#随机选择一个返回
print(random.choice([1,'23',[4,5]]))  #返回1或者23或者[4,5]

print(random.choice([1,'23',[4,5]]),2)   #随机返回多个

#打乱列表顺序

item = [1,3,5,7,9]
print(random.shuffle(item))    #打乱次序
#[1, 7, 5, 9, 3]

 

随机验证码

import random

s = ''

for i in range(6):
    num = random.randint(65,90)
    alpha1 = chr(num)
    num = random.randint(97,122)
    alpha2 = chr(num)
    num3 = str(random.randint(0,9))
    s = random.choice([alpha1,alpha2,num3])
    id += s
print(id)

os模块

os模块是与操作系统交互的一个接口

'''
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息
os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令，直接显示
os.popen("bash command).read()  运行shell命令，获取执行结果
os.environ  获取系统环境变量

os.path
os.path.abspath(path) 返回path规范化的绝对路径 os.path.split(path) 将path分割成目录和文件名二元组返回 os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素 os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。
                        即os.path.split(path)的第二个元素
os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)  如果path是绝对路径，返回True
os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小
'''

sys模块

sys模块是与Python解释器交互的一个接口

import sys

sys.argv    命令行参数list，第一个元素是程序本身路径
sys.exit(n)    退出程序，正常退出时exit(0)，错误退出sys.exit(1)
sys.version   获取Python解释程序的版本信息
sys.path        返回模块搜索路径
sys.platform    返回操作系统平台名称

import sys

try:
    sys.exit(1)
except SystemExit as e:
    print(e)

re 模块

正则表达式

在线测试工具 http://tool.chinaz.com/regex/

字符组：

[0-9]    表示数字从0开始到9结束
[a-z]    表示从字母a到字母z    
[A-Z]    表示从大写字母A到大写字母Z

字符

.    匹配除换行符以外的任意字符，就是除了换行，其他都能匹配
\w   匹配字母或数字或下划线，word
\s   匹配任意的空白符
\d   匹配数字
\n   匹配一个换行符
\t   匹配一个制表符tab
\b   匹配一个单词的结尾
^    匹配字符串的开始
$    匹配字符串的结尾
\W   匹配非字母或数字或下划线
\S   匹配非空白符
\D   匹配非数字
a|b  匹配字符a或字符b
()   匹配括号内的表达式，也表示一个组
[..] 匹配字符组中的字符
[^..]匹配除了字符组中字符的所有字符

量词

*    重复零次或更多次
+    重复一次或更多次
?    重复零次或一次
{n}  重复n次
{n,} 重复n次货更多次
{n,m} 重复n到m次

贪婪匹配和非贪婪匹配

贪婪匹配：在满足匹配时，匹配尽可能长的字符串，默认情况下，采用贪婪匹配

加上？将贪婪匹配模式转为非贪婪匹配模式，会匹配尽量短的字符串

常用的非贪婪匹配
*?    重复任意次，但尽可能少重复
+?    重复1次或更多次，但尽可能少重复
??    重复0次或1次，但尽可能少重复
{n,m}? 重复n到m次，但尽可能少重复
{n,}? 重复n次以上，但尽可能少重复

.*? 的用法
.  是任意字符
* 是取0至无限长度
? 是非贪婪模式
合在一起就是 取尽量少的任意字符 ，大多用在：
.*?x
就是取前面任意长度的字符，直到一个x出现

re模块常用方法

import re

#findall 返回string中所有与pattern匹配的字串
#语法： re.findall(pattern , string)
ret = re.findall('a','eva egon yuan')
#结果  ['a','a']

#search 只返回第一个匹配的字串，通过group()方法得到匹配的结果，如果没有匹配返回None
ret = re.search('a','eva egon yuan').group()
print(ret)
#结果  ['a']


#match 只检测是不是在string开始位置匹配，就是说在0位置匹配成功才返回
ret = re.match('a','abc').group()
print(ret)


#split 分割
ret = re.split('[ab]','abcd')  #先按'a'分割得到''和'bcd'，再按b分割得到'','','cd'    
print(ret)
#结果 ['', '', 'cd']

ret = re.split('ab','abcd')   
#结果  ['','cd']


#sub 替换
ret = re.sub('\d','H','eva2egon4yuan',1)  #将数字替换成H，1表示只替换1个
print(ret)
#结果 evaHegon4yuan

1.findall 的优先级查询

ret = re.findall('www.(baidu|oldboy).com','www.oldboy.com')
print(ret)    #['oldboy']
这是因为findall会优先把匹配结果组里内容返回

ret = re.findall('www.(?:baidu|oldboy).com','www.oldboy.com')
print(ret)   #['www.oldboy.com']

2.split 优先级

ret = re.split('\d+','eva3egon4yuan')
print(ret)    #['eva', 'egon', 'yuan']

ret1 = re.split('(\d+)','eva3egon4yuan')
print(ret1)   #['eva', '3', 'egon', '4', 'yuan']

#在匹配部分加上()之后切出来的结果不同
#没有()的没有保留所匹配的项，有()的却能够保留匹配的项
#这个在某些需要保留匹配部分的使用过程是非常重要的