python 全栈开发笔记 3

正则表达式

正则表达式(RE)是一种小型的，高度专业化的，它镶嵌在python中，并通过re模块实现，正则表达式编译成一系列的字节码，然后由用c编写的匹配引擎执行。

#正则表达式
import re
a=re.findall('alex','asdadrenzhanqalexiadaf')#返回的格式是一个列表格式
print(a)#输出 ['alex']

# findall 和finditer的区别是一个返回元组直接一个返回的是一个迭代器
# finditer
p=re.compile(r'\d+')
w=p.finditer('12asfasf12adad12asdads2sfasa3dfsaf')
print(w) # 输出结果是一个迭代器 <callable_iterator object at 0x00000181B8302390> 
#可以把这个迭代器遍历出来
for match in w:
    print(match.group(),match.span()) 
#输出结果为
'''
12 (0, 2) 开始位置和结束位置
12 (8, 10)
12 (14, 16)
2 (22, 23)
3 (28, 29)
'''
# search 只寻找到一个就返回，从前到后，后面再多也不匹配
# match  只有在最前面才能匹配到，中间和后面都不能匹配
# findall 将匹配所有的符合，放到一个列表中,其实就是一个个的search匹配后的叠加

import re
origin='hello alex bcd alex lge alex acd 19'
r=re.findall('(a)((\w+)(e))(x)',origin) # 先找最外层的括号，然后在最外层括号找的结果中再寻找对应的第二层括号中，
#把寻找的结果依次放在元组中，最后把所有的元组放在一个列表中
print(r)# 输出结果 [('a', 'le', 'l', 'e', 'x'), ('a', 'le', 'l', 'e', 'x'), ('a', 'le', 'l', 'e', 'x')]

 

# match:  re.match(pattern,string,flag=0)

# flag标志位
# re.I 使匹配对大小写不敏感
# re.L 使本地化识别(locale-aware)匹配
# re.M 多行匹配，影响^ 和 $
# re.S 使.匹配包括换行在内的所有字符(能匹配换行符\n)

# group() 对象方法，返回被RE匹配的字符串，参数默认是0，group(1),group(2)..取相应的组，第一组，第二组..
# groups() 获取模型中匹配到的分组结果
# groupdict() 获取模型中匹配到的分组中所有执行key的组

# 对比 group() groups()  groupdict() 
import re
origin='hello alex bcd alex lge alex acd 19'
r= re.match('h(?P<n1>\w+)',origin)
print(r.group()) #不管加不加() 它的匹配结果都为 hello，它返回所有的结果
print(r.groups()) # 只有加上() 它才会有匹配结果 ('ello',)，去你已拿到的东西(hello)再做一次筛选
print(r.groupdict())# 不想放在元组中，想放在字典中，但必须要为字典指定key，方法是在每个分组()前面加上?P<n1> ?P<n2>... n1,n2是字典的key

 

# start() 返回匹配开始的位置
# end()   返回匹配结束的位置
# span()  返回一个元组包含匹配（开始，结束）的位置
# sub 替换功能
# re.sub(pattern,repl,string,max=0)  
a=re.sub('g.t','have','I got B,I get A,I got C',2) #所有的g.t都被替换成have,max设置替换的次数
print(a)
# subn   返回替换的总次数
a=re.subn('g.t','have','I got B,I get A,I got C') #所有的g.t都被替换成have
print(a) # 返回元组形式 ('I have B,I have A,I have C', 3) 并返回替换的总次数

text='JGood is a handsome boy,he is cool,clever,and so hearted.'
regex=re.compile(r'\w*oo\w*')  #将查找的方法编译成一个对象，然后在调用findall方法，适合在多次搜寻时适用效率较高
print(regex.findall(text)) #查找所有包含oo的单词

# split 分割
p=re.compile(r'\d+')#所有十进制的数字
q=p.split('asd13fsasf32fdsfdsdfs31sdfsf12sf') #以所有的十进制数字分割字符串
print(q)#输出结果['asd', 'fsasf', 'fdsfdsdfs', 'sdfsf', 'sf']
print(re.split('[bc]','abcd'))  #先用b分 再用c去分，[bc]并列的关系

#计算机其中会用到的正则表达式匹配
import re
origin='1-2*(50+100*(1+2/3)+37*(34+234+48*(45+56)))'
n=re.split('\(([^()]+)\)',origin) #在以什么分割时，在外面加上（）可以把它取出来，不加只能取出分割后的东西，
#\使后面的()失去特殊意义，[]表示或的意思，里面加上^表示去否，后面加上+可以重复一到多次，不加只取一次。
print(n)

 

# 元字符 ： . ^ $ * + ? {} [] | () \
#各种元字符都有自己的功能

# . 通配符

a=re.findall('alex.w','alexaw')# 能匹配除换行符以外的所有字符 
print(a) #输出  ['alexaw']  一个点只能匹配一个字符

# ^ 尖角符  放在规则的前面
a=re.findall('^alex','alexaw')# 加上^ 后 alex必须在最前面才能匹配到
print(a) 

# $ 必须放在最后才能匹配到,放在规则的后面
a=re.findall('alex$','alelexawalex')# 加上$后 alex必须在最后面才能匹配到
print(a) 

# * + ? {}    主要是重复
# *
a=re.findall('alex*','alelexawalexxxxxx')# 加上*后能控制*号前面的一个字符，贪婪匹配，取0到多次
# 如果要搜寻的字符串没有x 也能匹配到，当0次
# 如果想要非贪婪匹配，则可以在后面加个问号，将策略改为非贪婪，只匹配尽量少的
# 如果前后均有限定条件，则贪婪模式不起作用 
a1=re.findall('alex*','alelexawale') # 输出 ['ale', 'ale']
print(a,a1)  #输出   ['ale', 'alexxxxxx']

# + 重复一到多次   至少有一个
a1=re.findall('alex+','alelexawale') 
print(a1)   # 输出为空，因为一个x也没有

#  ?  0到1次  0次或者一次
a1=re.findall('alex?','alelexawalex') 
print(a1)   # 输出为['ale', 'alex']  0 次1 次都能匹配出来

#{固定次数,想几次就几次，也可以是一个区间}  {3,5} 3 到 5 区间 内都能匹配到 
a1=re.findall('alex{2,3}','alalexxxxawalexx') 
print(a1)   # 输出为['alexxx', 'alexx']     两次  三次都能匹配出来    

# () 一个括号就代表一个组
 re.findall('www.(?:baidu|laonanhai).com','sdad www.laonanhai.com')
 # 匹配结果为www.laonanhai.com
#如果组内前面不加?:则匹配结果为 laonanhai 因为如果不加?: 则会优先匹配组内的内容，把组内的内容显示出来
而不显示其他的内容,但如果加上？：则会取消这种优先级，结果都会匹配出来

#

#  \   
#  反斜杠后面跟元字符 将去除元字符的特殊功能
#  反斜杠后面跟普通字符将实现特殊功能
#  引用序号对应的字组所匹配的字符串
a=re.search(r'(alex)(eric)com\2','alexericcomeric').group() #\2相当于第二组(alex)是第一组(eric)是第二组...
print(a)# 输出一个字符串  alexericcomeric   alexericcom是前面匹配的  eric是第二组匹配的
#  \d 匹配任何十进制数 相当于[0-9]
#  \D 匹配任何非数字字符，相当于类[^0-9]
#  \s 匹配任何空白字符，相当于类[\t\n\r\f\v]
#  \S 匹配任何非空白字符，相当于类[^\t\n\r\f\v]
#  \w 匹配任何字母数字字符，相当于类[a-zA-Z0-9]

import re
a='alex'
n=re.findall('(\w){4}',a)#匹配四次，但最后取时只取最后一个，因为就一个括号
n1=re.findall('(\w)(\w)(\w)(\w)',a)
n2=re.findall('(\w)*',a)#贪婪匹配，最后一个空也会被匹配到
n3=re.findall('',a) #默认从头开始匹配，到最后一个时x后面其实还有一个空，也会被匹配到
print(n,n1,n2,n3)#输出结果['x'] [('a', 'l', 'e', 'x')] ['x', ''] ['', '', '', '', '']

 

#  \W 匹配任何非字母数字字符，相当于类[^a-zA-Z0-9]
#  \b 匹配一个单词边界，也就是指单词和空格间的位置
#   \b就是在你匹配整个单词的时候，如果不是整个单词就不匹配

# 字符集   元字符 在 字符集里面是不行的   [.]  . 不再是通配符的含义了
a1=re.findall('a[bc]d','alabdacdlexxxxawalexx')  # [] 相当于 或 的一次  abd acd 都能匹配到 
print(a1)  #输出 ['abd', 'acd']

# [a-z]  a-z 表示a 到 z 都能匹配到  - 就有意义了,表示至的意思
# [^a-z]  ^ 表示非的意思  除了a-z 都能取出来
# [\d]    也还有意义，表示匹配任何十进制数 相当于[0-9]

#原生字符串
#为了解决python 和 re 模块 有关 \ 转义之间麻烦的变换 而引进来
a1=re.findall('\\\\','abc\sad') #在re模块中'\\'两个表示取消\的特殊含义，但因为是在python环境下,'\\'只能
#代表是一个\python也有自己的转义，所以必须给它四个才能匹配成功
print(a1)# 输出结果为['\\'] 表示只有一个\ 
#为了解决这种麻烦，引入原生字符串 
a1=re.findall(r"\\",r"abc\asd")
print(a1)  #现在只需要两个\\即能匹配成功

 模块

 进度条例子

import sys,time
for i in range(31):
    sys.stdout.write('\r') # 每一次清空原行
    sys.stdout.write('%s%% |%s' % (int(i/30*100),int(i/30*100)*'*'))# 两个%可以使它成为一个真正的%
    sys.stdout.flush()#强制刷新屏幕
    time.sleep(0.2)

pickle

python的文件操作，如果对一个文件进行修改，如果不能修改和原来文件中相同的字节，那么新的内容将会覆盖旧的文件内容，唯一的解决办法就是重新创建一个新的文件进行读写把新的内容加进去，为了解决这个麻烦，可以用pickle模块来帮助实现

 

#pickle 模块
import pickle
with open('text.txt','rb') as f:
    account_dic=pickle.loads(f.read())# 等于account_dic=pickle.load(f)
account_dic[1000]['balance'] -= 500
for k,v in account_dic.items():
    print(k,v)

with open('text.txt','wb') as f:
    f.write(pickle.dumps(account_dic))    # 等于pickle.dump(account_dic,f)

# json模块和pickle模块用法基本都一样,pickle比json更强大，但pickle只能在python 中使用
# 但json可以在不同语言中通用,可以在不同语言中通讯

 json.loads将字符串形式的列表或者字典等，转换成真正的字典和列表,但字典或者列表中的字符串必须要双引号括住。

json.dumps将python的字典或者列表等转换成字符串

json为了通用式的数据传输，将元组dumps时，会将其变成列表，将字符串形式的元组loads时会报错，因为元组这个数据类型只有python才有，并不通用。

 

#本身就存在的全局变量
print(vars()) #输出结果
'''
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001B517D4B160>, 
'__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'user.py', '__cached__': None}

'''
#__doc__ .py文件的注释
#__file__.py本身自己的路径
#__package__ 当前.py文件所在的包，当从其他模块导入这个模块时，可以用这个查看这个模块所在的包是什么
#__cached__  从其他模块导入这个模块时，当前文件为None可以用这个查看这个模块的缓存 .pyc文件
#__name__   在当前文件时 name为 __main__,但从其他模块导入这个模块时，name将是模块名,主要是入口文件
#如果是在入口文件中调用其他的功能，加上这个 if __name__ =='__main__': 条件时，只有在入口文件.py中才会执行,
#如果是其他文件导入了这个入口文件,那么入口文件中的name将不会是main 将会是模块名,那么下面的调用将不会执行
#调用主函数前，必须加这个条件判断
if __name__ =='__main__': 
    print(__name__)
    print('123')# 只有在当前文件才会执行，如果是在其他模块中导入这个模块，那么name将不会是main,是模块名，可用模块名.__name__查看

 安装第三方模块

1.安装：软件管理工具  python3中用 pip3，依赖setuptools

2源码安装：下载代码安装  先下载解压进入目录执行python setup.py install 进行安装

   requests模块的作用时发送http请求的，用python来模拟网页

import requests
response=requests.get('http://wthrcdn.etouch.cn/weather_mini?city=北京')
response.encoding='utf-8'
result=response.text #result得到的是一个字符串 
print(result)

 XML

python 中一切皆是对象

服务器返回的请求的其中一个格式，XML格式，但这种格式前提也是字符串，python中有一个模块专门处理这种格式的数据。

#创建一个xml文件
from xml.etree import ElementTree as ET
root=ET.Element('famliy') #创建一个根节点
son=ET.Element('pp',{'kk':'vv'})#创建一个son节点，ET.Element是一个类
ele2=ET.Element('pp',{'kk':'123123'})#创建一个ele2节点
son.append(ele2) #将ele2添加到son节点下面
root.append(son)#将son节点添加到根节点下面
tree=ET.ElementTree(root)
tree.write('first.xml',encoding='utf-8',short_empty_elements=False)#保存到first.xml文件中

 

#python 中一切皆对象 
from xml.etree import ElementTree as ET
tree=ET.parse('first.xml')
#一切皆对象，tree就是一个对象，既然是对象那它肯定有一个归属类
print(type(tree))
#输出 <class 'xml.etree.ElementTree.ElementTree'>  属于ElementTree类，那么tree将拥有
#ElementTree类中的所有方法

xml实例

import urllib
import requests
from xml.etree import ElementTree as ET
#查询QQ在线状态 XML实例
r=requests.get('http://www.webxml.com.cn//webservices/qqOnlineWebService.asmx/qqCheckOnline?qqCode=1278628365')
result=r.text #字符串类型

# 解析XML格式内容
#XML接收一个参数：字符串，格式化为特殊的对象
node=ET.XML(result)
if node.text == 'Y':
    print('在线')
else:
    print('离线')

#查询火车站点 XML实例
import urllib
import requests
from xml.etree import ElementTree as ET
r = requests.get('http://www.webxml.com.cn/WebServices/TrainTimeWebService.asmx/getDetailInfoByTrainCode?TrainCode=K52&UserID=')
result = r.text # 返回的是XML格式的字符串
#解析XML格式的内容
root=ET.XML(result)#解析XML对象
for node in root.iter('TrainDetailInfo'):
    print(node.find('TrainStation').text,node.find('StartTime').text)

#每一个节点都是Element类型，Element是一个类
#可以用一个类创建一个对象
#创建节点有两个方式：1，通过类创建一个节点，类比通过字符串类str()创建一个字符串
#2，通过makeelement() 单纯创建一个节点，再把节点选择挂在哪个节点的下面
from xml.etree import ElementTree as ET
#第一种方式
son=ET.Element('pp',{'kk':'vv'})#创建一个son节点，ET.Element是一个类
ele2=ET.Element('pp',{'kk':'123123'})#创建一个ele2节点
son.append(ele2) #将ele2添加到son节点下面
root.append(son)#将son节点添加到根节点下面
#第二种方式
son=root.makeelement('tt',{'kk':'vv'})#在根节点下面创建一个son节点
s=son.makeelement('tt',{'kk':'123123'})#在son节点下面创建一个s节点
#但第二种方式也是通过调用第一种方式来执行的