常用模块（三）

最新推荐文章于 2022-09-13 21:25:39 发布

yangsen99

最新推荐文章于 2022-09-13 21:25:39 发布

阅读量228

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/yangsen99/article/details/82505644

本文介绍Python中shelve模块的使用方法，用于简单的持久化存储；探讨了xml模块的功能及其在Python中的应用，包括解析和操作XML文件；同时深入讲解re模块的正则表达式语法及常见匹配模式。

shelve模块

shelve模块相对于其他模块会简单一点，它只有一个“open”函数,与pickle模块相比会比较简单，它在返回对象的时候返回的是字典，可以读可以写，其中key必须是由字符串组成的，值是python所支持的数据类型

import shelve

f=shelve.open(r'sheve.txt')
# f['stu1_info']={'name':'egon','age':18,'hobby':['piao','smoking','drinking']}
# f['stu2_info']={'name':'gangdan','age':53}
# f['school_info']={'website':'http://www.pypy.org','city':'beijing'}

print(f['stu1_info']['hobby'])
f.close()

xml模块

xml模块所实现的功能与json模块所实现的功能相似，可以进行多语言交互，但是相对来说json的使用方法会比较简单，所以大部分人现在的数据交互功能使用的都是json模块，xml模块是通过<>来区分数据结构

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

xml格式

在python当中可以使用以下模块操作xml

# print(root.iter('year')) #全文搜索
# print(root.find('country')) #在root的子节点找，只找一个
# print(root.findall('country')) #在root的子节点找，找所有

#==========================================>查
import xml.etree.ElementTree as ET
#
# tree=ET.parse('a.xml')
# root=tree.getroot()
#三种查找节点的方式
# res=root.iter('rank') # 会在整个树中进行查找，而且是查找到所有
# for item in res:
#     # print(item)
#     print('='*50)
#     print(item.tag) # 标签名
#     print(item.attrib) #属性
#     print(item.text) #文本内容


# res=root.find('country') # 只能在当前元素的下一级开始查找。并且只找到一个就结束
# print(res.tag)
# print(res.attrib)
# print(res.text)
# nh=res.find('neighbor')
# print(nh.attrib)


# cy=root.findall('country') # 只能在当前元素的下一级开始查找,
# print([item.attrib for item in cy])




#==========================================>改
# import xml.etree.ElementTree as ET
# tree=ET.parse('a.xml')
# root=tree.getroot()
#
# for year in root.iter('year'):
#     year.text=str(int(year.text) + 10)
#     year.attrib={'updated':'yes'}
#
#
# # tree.write('b.xml')
# tree.write('a.xml')



#==========================================>增
import xml.etree.ElementTree as ET
tree=ET.parse('a.xml')
root=tree.getroot()

for country in root.iter('country'):
    # print(country)
    year=country.find('year')
    # print(year)
    if int(year.text) > 2020:
        # print(country.attrib)
        # ele=ET.Element('egon')
        # ele.attrib={'nb':'yes'}
        # ele.text='非常帅'
        # country.append(ele)
        country.remove(year)
tree.write('b.xml')

View Code

re模块

正则就是用一些具有特殊含义的符号组合到一起（称为正则表达式）来描述字符或者字符串的方法。或者说：正则就是用来描述一类事物的规则。（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行

常用的一些匹配模式：

import re
# print(re.findall('\w','ab 12\+- *&_'))
#                                  \w
# print(re.findall('\W','ab 12\+- *&_'))
# print(re.findall('\s','ab \r1\n2\t\+- *&_'))
# print(re.findall('\S','ab \r1\n2\t\+- *&_'))
# print(re.findall('\d','ab \r1\n2\t\+- *&_'))
                    #                    \d
# print(re.findall('\D','ab \r1\n2\t\+- *&_'))

# print(re.findall('\w_sb','egon alex_sb123123wxx_sb,lxx_sb'))
#                                                       \w_sb

# print(re.findall('\Aalex','abcalex is salexb'))
# print(re.findall('\Aalex','alex is salexb'))
# print(re.findall('^alex','alex is salexb'))
# print(re.findall('sb\Z','alexsb is sbalexbsb'))
# print(re.findall('sb$','alexsb is sbalexbsb'))
#                                           sb

# print(re.findall('^ebn$','ebn1'))
#                           ebn


# print(re.findall('a\nc','a\nc a\tc a1c'))

基础类型

# 重复匹配：
#.   ?   *   +  {m,n}  .*  .*?
#1、.:代表除了换行符外的任意一个字符
# print(re.findall('a.c','abc a1c aAc aaaaaca\nc'))
#                                           a.c
# print(re.findall('a.c','abc a1c aAc aaaaaca\nc',re.DOTALL))

#2、？：代表左边那一个字符重复0次或1次
# print(re.findall('ab?','a ab abb abbb abbbb abbbb'))
#                                      ab?

#3、*：代表左边那一个字符出现0次或无穷次
# print(re.findall('ab*','a ab abb abbb abbbb abbbb a1bbbbbbb'))
#                                                   ab*

#4、+ ：代表左边那一个字符出现1次或无穷次
# print(re.findall('ab+','a ab abb abbb abbbb abbbb a1bbbbbbb'))
#                                                    ab+

#5、{m,n}:代表左边那一个字符出现m次到n次
# print(re.findall('ab?','a ab abb abbb abbbb abbbb'))
# print(re.findall('ab{0,1}','a ab abb abbb abbbb abbbb'))

# print(re.findall('ab*','a ab abb abbb abbbb abbbb a1bbbbbbb'))
# print(re.findall('ab{0,}','a ab abb abbb abbbb abbbb a1bbbbbbb')) # 出现0次或无穷次

# print(re.findall('ab+','a ab abb abbb abbbb abbbb a1bbbbbbb'))
# print(re.findall('ab{1,}','a ab abb abbb abbbb abbbb a1bbbbbbb'))


# print(re.findall('ab{1,3}','a ab abb abbb abbbb abbbb a1bbbbbbb'))


#6、.*：匹配任意长度，任意的字符=====》贪婪匹配
# print(re.findall('a.*c','ac a123c aaaac a *123)()c asdfasfdsadf'))
#                        a.*c
# 以找到的最后一个c为准

#7、.*？：非贪婪匹配
# print(re.findall('a.*?c','a123c456c'))
# 以找的第一个c为准

# ():分组
# print(re.findall('(alex)_sb','alex_sb asdfsafdafdaalex_sb'))

#                            (alex)_sb
# 以 ‘alex_sb’为标准匹配，最终输出的是括号里面的内容
# print(re.findall(
#     'href="(.*?)"',
#     '<li><a id="blog_nav_sitehome" class="menu" href="http://www.cnblogs.com/">博客园</a></li>')
# )
# <li><a id="blog_nav_sitehome" class="menu" href="http://www.cnblogs.com/">博客园</a></li>
#                                           href=".*?"


# []:匹配一个指定范围内的字符（这一个字符来自于括号内定义的）
# print(re.findall('a[0-9][0-9]c','a1c a+c a2c a9c a11c a-c acc aAc'))

#当-需要被当中普通符号匹配时，只能放到[]的最左边或最 右边,放到中间有特殊意义
# print(re.findall('a[-+*]c','a1c a+c a2c a9c a*c a11c a-c acc aAc'))

# print(re.findall('a[a-zA-Z]c','a1c a+c a2c a9c a*c a11c a-c acc aAc'))


# []内的^代表取反的意思
# print(re.findall('a[^a-zA-Z]c','a c a1c a+c a2c a9c a*c a11c a-c acc aAc'))
# print(re.findall('a[^0-9]c','a c a1c a+c a2c a9c a*c a11c a-c acc aAc'))


# print(re.findall('([a-z]+)_sb','egon alex_sb123123wxxxxxxxxxxxxx_sb,lxx_sb'))
#                                                [a-z]+_sb



# | :或者
# print(re.findall('compan(ies|y)','Too many companies have gone bankrupt, and the next one is my company'))

# (?:):代表取匹配成功的所有内容，而不仅仅只是括号内的内容
# print(re.findall('compan(?:ies|y)','Too many companies have gone bankrupt, and the next one is my company'))

# print(re.findall('alex|sb','alex sb sadfsadfasdfegon alex sb egon'))

# re模块的其他方法：
# print(re.findall('alex|sb','123123 alex sb sadfsadfasdfegon alex sb egon'))  # 二选一
# print(re.search('alex|sb','123213 alex sb sadfsadfasdfegon alex sb egon').group())   # search：找到一个就停下来
# print(re.search('^alex','123213 alex sb sadfsadfasdfegon alex sb egon'))   #  以alex开头的

# print(re.search('^alex','alex sb sadfsadfasdfegon alex sb egon').group())
# print(re.match('alex','alex sb sadfsadfasdfegon alex sb egon').group())
# match和search中加^的意义相同

# print(re.match('alex','123213 alex sb sadfsadfasdfegon alex sb egon'))


# info='a:b:c:d'
# print(info.split(':'))
# print(re.split(':',info))

# info=r'get :a.txt\3333/rwx'
# print(re.split('[ :\\\/]',info))
# split在re模块中切分可以使用正则表达式

# print('egon is beutifull egon'.replace('egon','EGON',1))

# print(re.sub('(.*?)(egon)(.*?)(egon)(.*?)',r'\1\2\3EGON\5','123 egon is beutifull egon 123'))

#              (123 )(egon)( is beutifull )(egon)( 123)

#\1\2\3EGON\5

# print(re.sub('(lqz)(.*?)(SB)',r'\3\2\1',r'lqz is SB'))
# print(re.sub('([a-zA-Z]+)([^a-zA-Z]+)([a-zA-Z]+)([^a-zA-Z]+)([a-zA-Z]+)',r'\5\2\3\4\1',r'lqzzzz123+ is SB'))

#(lqzzzz)(123+ )(is)( )(SB)


# pattern=re.compile('alex')
# print(pattern.findall('alex is alex alex'))
# print(pattern.findall('alexasdfsadfsadfasdfasdfasfd is alex alex'))