Python基础（三）

本次介绍一点 python中的标准库和一些最爱，同时介绍一下他们主要要意思的方法

一、sys模块介绍

import  sys
#1.输出一个一个列表，其中列表中只有一个元素 那就是当前运行文件的路径
print(sys.argv[0])
#2.退出程序 可以选参数 给定的返回值和错误提示信息
print(sys.exit(["程序错误了"]))
#3.映射模块名字载入到模块的字典
for key  in  sys.modules.keys():
    print(key)
#4.path 查询模块所在目录的目录名列表
print(sys.path)
#5.platform类似sunos5或者win32的平台标识符
print(sys.platform)
#6.stdin标准输入流 一个类文件(file-like)对象
print(sys.stdin)
#7.stdout标准输出流 一个类文件对象、
print(sys.stdin)
#8.stderr标准错误流 一个类文件对象
print(sys.stderr)

 

二、OS模块

import  os
#1.environ 对环境变量进行映射
print(os.environ)
#2.system 在子shell中执行系统的操作命令
print(os.system("dir"))
#3.sep 路径的分隔符（打印出”\"）
print(os.sep)
#4.pathsep分隔路径中的分隔符
print(os.path)
#5.linesep行分隔符('\n','\r','or' ,'\r\n')
print(os.linesep)
#6.urandom(n)返回n个字节的加密强随机数据
print(os.urandom(5))

其中system这个命令很有意思，他可以驱动本机的文件启动 看下图（当然你用来驱动浏览器也是可以的，但是我们启动浏览器有更好的模块，叫做webbrowser模块，喜欢的可以去学习一下，具体方式是导入模块之后，webbrowser.open('http://www.python.org')这样就可以打开指定的url了）

三、fileinput模块

fileinput.filename函数返回当前正在处理的文件名(也就是包含了当前正在处理的文本行的文件)。
fileinput.lineno返回当前行的行数。这个数值是累计的，所以在完成一个文件的处理并且开始处理下一个文件的时候，行数并不会重置，而是将上一个文件的最后行数加1作为计数的起始。
fileinput.filelineno函数返回当前处理文件的当前行数。每次处理完一个文件并且开始处理下一个文件时，行数都会重置为1，然后重新开始计数。
fileinput . isfirstline函数在当前行是当前文件的第一行时返回真值，反之返回假值。
fileinput isstdin函数在 当前文件为sys.stdin时返回真值， 否则返回假值。
fileinput. nextfile函数会关闭当前文件，跳到下一个文件，跳过的行并不计。在你知道当前文件已经处理完的情况下，这个函数就比较有用了一-比如每个 文件都包含经过排序的单词，而你需要查找某个词。如果已经在排序中找到了这个词的位置，那么你就能放心地跳到下一个文件了。
fieinput. close函数关闭整个文件链，结束迭代。

随机练习代码：

import fileinput

for line in fileinput.input(inplace=True):
    line=line.rstrip()
    num=fileinput.lineno()
    print('%-40s # %2i' % (line,num))

放到命令行运行之后，每行右边就增加了一个标记了

 

 

四、堆：他是优先队列的一种，使用优先队列能够以任意顺序增加对象，并且能在任意时间（可能增加对象的同时）找到（也可能是移除）最小元素，也就是说它比用于列表的min方法要有效率的多

下面是heapq（堆）中的一些重要的函数

heappush(heap,x)                       将x入堆

heappop(heap)                           将堆中最小的元素弹出

heapify(heap)                              将heap属性强制应用到任意一个列表

heapreplace(heap,x)                  将堆中最小的元素弹出，同时将x入堆

nlargest(n,iter)                             返回iter中第n大的元素

nsmallest(n,iter)                          返回iter中第n小的元素

下面是根据heappush新建一个堆的例子：

#coding=utf-8
"""使用heappush的方式建立堆 python2.7"""
from heapq import *

data=range(10)
heap=[]
for n in data:
    heappush(heap,n)
"""
这里他貌似没有啥顺序 但是我们在下面打印一下这个堆的顺序 我们发现
1 2 3 4 5 6 7 8 9 10
0 1 4 2 5 6 7 9 3 8
假设第二位  i=2  2*i=2*2=4 对应的值为2
                2*i+1=5  对应的值为5
                第二位的值是1 总是比2 和5 小
假设第三位  i=3  3*i=3*3=9 对应的值是3
                3*i+1=3*3+1=10 对应的值是8
                第三位的值是4 总是比3和8要小
....得到一个规律 就是 
i位置的元素 总是比2i和2i+1处的元素要小 这个属性 叫做堆属性，这就是底层堆算法的基础
"""
print(heap)
heappush(heap,0.5)#在堆中追加一个元素0.5
print(heap)
print(heappop(heap))#打印出堆中最小的一个数 一般都是第一个
print(heappop(heap)) #打印出0.5
print(heappop(heap)) #打印出1
print(heap)
"""
打印出堆中最小的数，一般来说是索引为0的元素，并且会确保剩余元素的那个占据这个位置（堆属性) 
一般来说尽管弹出的列表第一个元素并不是很有效率，但是在这里不是问题，因为heappop在“幕后会做一些
移位的操作，也就是我们最后打印heap之后 0，0.5,1都不见了
"""

 

现在来介绍一下 heapify

"""heapify函数会通过尽可能少的移位操作，让这个列表转换成堆"""
from  heapq import *
listheap=[1,2,3,4,5,0,7]
heapify(listheap)
print(listheap)#这个时候Listheap已经从列表转变成堆
print(heapreplace(listheap,0))#弹出最小的那个堆元素 之后增加一个元素0
print(listheap)#所以这里输出跟前二行打印的是一致的

print(nlargest(2,listheap))#打印listheap中 第n大的数
print(nsmallest(2,listheap))#打印listheap中 第小的数

五、re

1.通配符

"." 代表匹配任意单个字符串（除了换行符）

比如  ".ython" 可以匹配字符串python  和 jython,以及qython 或者" ython"(第一个是空格)  但是他不能匹配ppython  因为"."只能匹配一个字符。因此点号就称为通配符

2.对特殊字符进行转义

假设：需要匹配的字符串"python.org"  不能直接用"python.org"的模式，因为"."是一个通配符，所以程序会将"pythonnorg"这类也会匹配出来。

解决办法。只需要对特殊符号进行转义"python\\.org" 这样就只会匹配python.org了

这里使用双反斜线，（1）通过解释器转义  （2）通过re模块转义

事实上 这里有些情况下是可以使用单个反斜线，让解释器自动进行转义，但是最好别依赖这种行为，当然我们如果不喜欢\\的话，我们可以使用原始字符串u"python\.org"

3.字符集

比如"[py]thon"   可以匹配pthon   和  ython

比如"[a-z]"  能够按照字母匹配a到z的任意一个字符

比如"[a-zA-Z0-9]"能够匹配任何大小写的字母和数字

但是注意这些 都只是匹配一个这样的字符  

字符集的反转  我们只需要在前面加上^

比如"[^tbc]" 就可以排除除了t；b；c三个字符之外的字符

当然如果我们遇到字符集中有特殊字符的话

需要使用//进行转义  这里包括的字符 ，点号，星号，问号   这个地方   假设你是想当文本字符不是当做正则表达式运算符的话，需要转义。。。但是如果你只是想用正则表达式运算符的话就不需要转义了

转义规则

如果（^）脱字符出现在字符集的开头，但是你只是当做文本字符，这个时候需要转义

右中的括号（]）和横线 应该放在字符集的开头或者用反斜线进行转义（事实上反斜线你也可以放最后）

预定义字符集

\d	数字:[0-9]	a\bc	a1c
\D	非数字:[^\d]	a\Dc	abc
\s	匹配任何空白字符:[<空格>\t\r\n\f\v]	a\sc	a c
\S	非空白字符:[^\s]	a\Sc	abc
\w	匹配包括下划线在内的任何字字符:[A-Za-z0-9_]	a\wc	abc
\W	匹配非字母字符，即匹配特殊字符	a\Wc	a c
\A	仅匹配字符串开头,同^	\Aabc	abc
\Z	仅匹配字符串结尾，同$	abc\Z	abc
\b	匹配\w和\W之间，即匹配单词边界匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。	\babc\b a\b!bc	空格abc空格 a!bc
\B	[^\b]	a\Bbc	abc

3.选择符和子模式

比如我想匹配 python  perl这二个字符（只有这二个）  然后我又不好写字符集或者通配符来进行这个指定的模式

这个时候我们可以使用管道|这个选择特殊的符号

python | perl  或者我们也可以写成 'p(ython|erl)'-----这里需要注意，术语中的子模式也使用单个字符，这里()里面的就是字模式了

4.可选项和重复子模式

子模式的后面加上？就变成可选项了

比如r"(http://)?(www.)?python\.org"

这里的?是标识 http://可以有也可以没有  www.可以有也可以没有 所以他只能匹配下面的

"http://www.python.org"

"www.python.org"

"python.org"

对于这个例子是，我们有这些是需要注意的

对点号进行了转义，防止他当做通配符处理

使用原始字符串，减少了反斜线的数量

每个可选子模式都用圆括号括起来

可选的子模式出现与否均可，而且相互独立

问号标识子模式可以出现一次或者不出现，下面这些运算符是 允许子模式重复多次

（pattern）*：允许出现0次或者多次

（pattren）+：允许出现1次或者多次

(pattern){m,n}:允许出现m~n次数

举个例子，r'w*.python.org'可以匹配 www.python.org也可以匹配.python.org也可以匹配w.python.org

在举个例子，r'w{3,4}.python.org'只能匹配 www.python.org和wwww.python.org

5.字符串的开始和结尾

比如你只想在某个字符串的开头匹配某个字符 

举个例子，http://python.org 和python://http.org 这个时候 我只需要从开头匹配http

这个时候我们需要使用脱字符（^ht+p)

相反我们如果需要从末尾开始就用字符$

re模块的一般方法 （当然还有很多）

import  re



#1.compiley根据包含的正则表达式字符串进行创建模式对象
str = "Tina is a good girl, she is cool, clever, and so on..."
rr = re.compile(r'\w*oo\w*') #其中\w代表是匹配包括下划线在内的任何字字符:[A-Za-z0-9_] 如果改成/W则是匹配非法字符 里面实际是pattern编译时用的表达式字符串。
print(rr.findall(str))   #查找所有包含'oo'的单词 这里打印出来['good', 'cool']



# 2.search在字符串中寻找模式，寻找到第一个就返回 如果没有返回None
a = "123abc456"
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0))   #123abc456,返回整体
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1))   #123
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(2))   #abc
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(3))   #456
"""
*注：match和search一旦匹配成功，就是一个match object对象，而match object对象有以下方法：
group() 返回被 RE 匹配的字符串
start() 返回匹配开始的位置
end() 返回匹配结束的位置
span() 返回一个元组包含匹配 (开始,结束) 的位置
group() 返回re整体匹配的字符串，可以一次输入多个组号，对应组号匹配的字符串。
"""


#3.findall查找出所有满足要求的模式字符
a = "123abc456ffffff8"
print(re.findall("[\D]",a))#查询所有的字符


#4. split() 按照能够匹配的字符串将string分割 在返回列表
a="dsfn2nlndsf2ojidfnv"
print(re.split("[\d]",a))#按照数字进行分割
#将字符串中按照a分割 ，并且返回列表
aa="1A1a2A3"
print(re.split('a',aa,flags=re.I))#如果忽略大小写 就需要加flags=re.I 否则不加即可