python--模块一

经常使用模块

collections模块

在内置数据类型（dict、list、set、tuple）的基础上，collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。

1.namedtuple: 生成可使用名字来访问元素内容的tuple
2.deque: 双端队列，能够快速的从另一侧追加和推出对象
3.Counter: 计数器，主要用来计数
4.OrderedDict: 有序字典
5.defaultdict: 带有默认值的字典

1.namedtuple

- tuple能够表示不变集合，例如，一个点的二维坐标就能够表示成：

p = (1,2)

- 看不出来1,2用来表示坐标，用namedtuple实现方法

from collections import namedtuple
Point = namedtuple('Point',["x","y"])
p = Point(1,2)
print(p.x)
print(p.y)

- 定义方式：namedtuple('名称', [属性list])

2.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()，这样就能够很是高效地往头部添加或删除元素。

3.defaultdict

有以下值集合 [11,22,33,44,55,66,77,88,99,90...]，将全部大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。即： {'k1': 大于66 , 'k2': 小于66}

dic = {"k1":[],"k2":[]}
l1 = [11,22,33,44,55,66,77,88,99,90]
for number in l1:
    if number > 66:
        dic["k1"].append(number)
    elif number < 66:
        dic["k2"].append(number)
print(dic)
#普通字典须要先定义好一个字典，字典必须有k1,k2的key值

使用dict时，若是引用的Key不存在，就会抛出KeyError。若是但愿key不存在时，返回一个默认值，就能够用defaultdict：

from collections import defaultdict
l1 = [11,22,33,44,55,66,77,88,99,90]
dic = defaultdict(list)
for number in l1:
    if number > 66:
        dic["k1"].append(number)
    elif number < 66:
        dic["k2"].append(number)
    elif number == 66:
        dic["k3"].append(number)
print(dic)

time模块

1.经常使用方法：

1.time.sleep(secs)
(线程)推迟指定的时间运行。单位为秒
2.time.time()
获取当前时间戳

2.表示时间的三种方式:

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

3.struct_time) ：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）

import time
#时间戳
print(time.time())
#字符串时间
print(time.strftime("%Y-%m-%d %H:%M:%S"))
#时间元组：localtime将一个时间戳转换为当前时区的struct_time
print(time.localtime())
#打印结果：
1530693574.325
2018-07-04 16:39:34
time.struct_time(tm_year=2018, tm_mon=7, tm_mday=4, tm_hour=16, tm_min=39, tm_sec=34, tm_wday=2, tm_yday=185, tm_isdst=0)

总结：时间戳是计算机可以识别的时间；时间字符串是人可以看懂的时间；元组则是用来操做时间的
时间格式的转化：

#1.时间戳转结构化时间
import time
print(time.gmtime()) #UTC时间，与英国伦敦当地时间一致
print(time.localtime()) #当地时间。例如咱们如今在北京执行这个方法：与UTC时间相差8小时，UTC时间+8小时 = 北京时间

#2.结构化时间转时间戳
#获取本地时间的结构化时间
time_tuple = time.localtime()
print(time_tuple)
#将结构化时间转化为时间戳
print(time.mktime(time_tuple))

#3.结构化时间转字符串时间
#time.strftime("格式定义","结构化时间")  结构化时间参数若不传，则现实当前时间
print(time.strftime("%y-%m-%d %H:%M:%S"))
print(time.strftime("%Y-%m-%d",time.localtime()))

#4.字符串时间转结构化时间
#time.strptime(时间字符串,字符串对应格式)
print(time.strptime("2018-07-04","%Y-%m-%d"))
#time.struct_time(tm_year=2018, tm_mon=7, tm_mday=4, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=185, tm_isdst=-1)

计算时间差：

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

random模块

1.随机小数

import random
print(random.random()) #大于0且小于一的小数
print(random.uniform(1,3))  #大于1且小于3的小数

2.随机整数

import random
print(random.randint(1,3)) #>=1且<=3的随机整数
print(random.randrange(1,10,2)) #大于等于1且小于10之间的奇数

3.随机返回

import random
print(random.choice([1,2,3,4,5,[6,7]])) #在列表中随机选择一个元素返回
print(random.sample([1,2,3,4,5,6],3)) #列表内任意3个组合

4.打乱列表顺序

import random
l1 = [1,2,3,4,5]
print(random.shuffle(l1))
print(l1)

生成随机验证码：

def random_number(numer,alpath=True):
    """
    :param numer: 生成几位
    :param alpath: 默认包括数字
    :return:
    """
    code = ""
    for i in range(numer):
        choice = random.randint(0,9)
        if alpath:
            number2 = chr(random.randint(65,90)) #大写
            number3 = chr(random.randint(97,122)) #小写
            choice = random.choice([choice,number2,number3])
            print(choice)
        code += str(choice)
    return code

os模块

os模块是一个于操做系统交互的一个接口

import os
os.getcwd()           #获取当前的工做目录当前的工做目录
os.chdir("E:\python\day08") #改变脚本工做目录，至关于shell下的cd
os.curdir             #返回当前目录  .
os.pardir             #返回到父集目录 ..
os.makedirs("linux\go") #递归建立目录，至关于shell的mkdir -p
os.removedirs("linux\go") #若目录为空则删除，并递归到上一层目录，若是上一次目录也为空，也删除。依次类推
os.mkdir("python")  #生成单级目录，至关于shell中的mkdir path
os.rmdir("python")   #删除单级空目录，不为空则没法删除
print(os.listdir("E:\python\day08")) #列出指定目录下的全部文件和目录，包括隐藏文件，以列表的方式打印
os.remove("1.py") #删除某个文件
os.rename("day08.zip","day8.zip")  #重命名目录/文件
os.stat("README") #获取文件/目录信息，以一个元组的方式返回，能够按照索引取值
os.sep #在pycharm中打印的结果是：/,在windows解释器是：//,linux下为：/
print(os.name) #输出当前使用平台，win=“nt”，linux=“posix”
os.system("bash commond") #运行shell命令
os.popen("bash commond").read() #运行shell命令，获取执行结果
print(os.environ) #获取系统变量
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)的第二个元素
print(os.path.exists("E:\python")) #判断目录/文件是否存在，存在返回True，反之false
print(os.path.isabs("E:\python")) #若是path是绝对路径返回true，反之false
print(os.path.isfile("Calculator.py")) #判断文件是否存在，存在true，反之false
print(os.path.isdir("python"))  #判断目录是否存在，存在true，反之false
os.path.getatime("E:\python\day08")  #返回path所指向的文件或者目录的最后访问时间戳
os.path.getmtime("E:\python\day08")  #返回path所指向的文件或者目录的最后修改时间戳
os.path.getsize("E:\python\day08") #返回path的大小

sys模块

sys模块是一个与python解释器交互的模块

import sys
print(sys.argv) #命令行参数list，返回的是程序自己的路径
sys.exit(n)   #退出程序，正常退出是exit(0),错误退出是exit(1)
print(sys.version) #返回python解释器的版本信息
print(sys.path) #返回模块的搜索路径
print(sys.platform) #返回操做平台名称

re模块

正则：
1.字符组 ： [字符组]

- 在同一个位置可能出现的各类字符组成了一个字符组，在正则表达式中用[]表示
- 字符分为不少类，好比数字、字母、标点等等。
- 假如你如今要求一个位置"只能出现一个数字",那么这个位置上的字符只能是0、一、2...9这10个数之一。

2.字符：

3.量词：

注意：前面的*,+,?等都是贪婪匹配，也就是尽量匹配，后面加?号使其变成惰性匹配

4.字符集：

5.分组 ()与 或 ｜［^］
身份证号码是一个长度为15或18个字符的字符串，若是是15位则所有🈶️数字组成，首位不能为0；若是是18位，则前17位所有是数字，末位多是数字或x，下面咱们尝试用正则来表示：

6.转义符 \
python中，不管是正则表达式，仍是待匹配的内容，都是以字符串的形式出现的，在字符串中也有特殊的含义，自己还须要转义。因此若是匹配一次"d",字符串中要写成'\d'，那么正则里就要写成"\\d",这样就太麻烦了。这个时候咱们就用到了r'd'这个概念，此时的正则是r'\d'就能够了。

7.贪婪匹配
贪婪匹配：在知足匹配时，匹配尽量长的字符串，默认状况下，采用贪婪匹配

经常使用的：

*? 重复任意次，但尽量少重复
+? 重复1次或更屡次，但尽量少重复
?? 重复0次或1次，但尽量少重复
{n,m}? 重复n到m次，但尽量少重复
{n,}? 重复n次以上，但尽量少重复

re模块经常使用用法:

import re

ret = re.findall('a', 'eva egon yuan')  # 返回全部知足匹配条件的结果,放在列表里
print(ret) #结果 : ['a', 'a']

ret = re.search('a', 'eva egon yuan').group()
print(ret) #结果 : 'a'
# 函数会在字符串内查找模式匹配,只到找到第一个匹配而后返回一个包含匹配信息的对象,该对象能够
# 经过调用group()方法获得匹配的字符串,若是字符串没有匹配，则返回None。

ret = re.match('a', 'abc').group()  # 同search,不过尽在字符串开始处进行匹配
print(ret)
#结果 : 'a'

ret = re.split('[ab]', 'abcd')  # 先按'a'分割获得''和'bcd',在对''和'bcd'分别按'b'分割
print(ret)  # ['', '', 'cd']

ret = re.sub('\d', 'H', 'eva3egon4yuan4', 1)#将数字替换成'H'，参数1表示只替换1个
print(ret) #evaHegon4yuan4

ret = re.subn('\d', 'H', 'eva3egon4yuan4')#将数字替换成'H'，返回元组(替换的结果,替换了多少次)
print(ret)

obj = re.compile('\d{3}')  #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字
ret = obj.search('abc123eeee') #正则表达式对象调用search，参数为待匹配的字符串
print(ret.group())  #结果 ： 123

import re
ret = re.finditer('\d', 'ds3sy4784a')   #finditer返回一个存放匹配结果的迭代器
print(ret)  # <callable_iterator object at 0x10195f940>
print(next(ret).group())  #查看第一个结果
print(next(ret).group())  #查看第二个结果
print([i.group() for i in ret])  #查看剩余的左右结果

findall优先级查询

import re

ret = re.findall('www.(baidu|wangyi).com', 'www.wangyi.com')
print(ret)  # ['wangyi']     这是由于findall会优先把匹配结果组里内容返回,若是想要匹配结果,取消权限可
ret = re.findall('www.(?:baidu|wangyi).com', 'www.oldboy.com')
print(ret)  # ['www.wangyi.com']

split的优先级查询

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

ret=re.split("(\d+)","eva3egon4yuan")
print(ret) #结果 ： ['eva', '3', 'egon', '4', 'yuan']

#在匹配部分加上（）以后所切出的结果是不一样的，
#没有（）的没有保留所匹配的项，可是有（）的却可以保留了匹配的项，
#这个在某些须要保留匹配部分的使用过程是很是重要的。