首页 / PYTHON / python学习之路——基础篇（3）模块（续）

python学习之路——基础篇（3）模块（续）

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了python学习之路——基础篇（3）模块（续），小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含5668字，纯文字阅读大概需要9分钟。

内容图文

re正则表达式、shutil、ConfigParser、xml

一、re

  • 正则元字符和语法：
语法 说明　　 表达式 完全匹配字符
　　　　　　　　　　字符
一般字符　　 匹配自身 abc　　 abc
. 匹配除换行符“\n”外,任意一个字符 a.c abc
\　　　　　　 转义字符,将特殊字符转义为本身

a\.c

a\\c

a.c

a\c

[...]

匹配字符集任意一个字符，或者“-”表示一个集合范围

如：[a-zA-Z0-9]匹配范围中任意一个字符；或者[^]

匹配否定，对括号中的内容取反。

[abc]efg

aefg

befg

cefg

　　　　　　　　　预定义字符集
\d 数字：[0-9] a\dc 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  非单词字符：[^\w] a\Wc a c
                           数量词
*　　 匹配前一个字符0次或无数次 a*b

aab

ab

b

+　　 匹配前一个字符1次或无数次 a+b

aab

aaaab

? 匹配前一个字符0次或1次 a?b

b

ab

{m} 匹配前一个字符m次 a{2}c aac
{m,n}

匹配前一个字符m次到n次。m与n可以省略

如果省略m，表示0次到n次；省略n表示从m次到

无数次

a{1,2}c

ac

aac

*? +? ??

{m,n}?

使*、+、？、{m,n}变为非贪婪模式 见后文
                    边界匹配
^ 匹配字符串开头 ^abc abc
$ 匹配字符串结尾 abc$ abc
\A 仅匹配字符串开头 \Aabc abc
\Z 仅匹配字符串结尾 abc\Z abc
\b 
                        匹配一个单词边界，也就是指单词和空格间的位置。例如，“er\b”可以匹配“never”中的“er”，但不能匹配“verb”中的“er”
ab\b ab
\B 
                        匹配非单词边界。“er\B”能匹配“verb”中的“er”，但不能匹配“never”中的“er”
ab\Bc abc
                    逻辑与分组
|

代表左右表达式任意匹配一个。

它总是先匹配左边的，一旦匹配成功，则跳过右边表达式。

如果|没有被包含在()中，他的范围将是整个表达式。

abc|def

abc

def

()

被括号括起来的表达式将视为分组。

从表达式左边开始，每遇到一个分组的左括号“（“，编号+1

分组表达式作为一个整体，可以后接数量词。表达式中|仅在分组中生效。

(abc){2}

(abc|bcd)

abcabc

abc

(?P<name>...) 分组，除了原有编号外，再指定一个别名。group(1)=group(name) (?P<id>abc) abc
(?P=name)引用别名为name的分组匹配到的字符串(?P<id>123)abc(?P=id)123abc123

  • 数量词的贪婪模式与非贪婪模式

　　正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；非贪婪的则相反，总是尝试匹配尽可能少的字符。例如：正则表达式"ab*"如果用于查找"abbbc"，将找到"abbb"。而如果使用非贪婪的数量词"ab*?"，将找到"a"。

  • 反斜杠的困扰

　　与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r"\\"表示。同样，匹配一个数字的"\\d"可以写成r"\d"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。

  • re相关匹配方法
  1. match

　　　　match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None

             1
            import
             re

             2
             3 text="the Attila the Hun show" 4 m = re.match(".",text)
 5print(m.group()) #"t" 或者group(0)取得匹配所有结果 6 7 m = re.match("(.)(.)(.)",text)
 8print(m.group(0)) #"the" 910#分组11print(m.group(1,2,3)) #(‘t‘,‘h‘,‘e‘) 匹配后得分组1213#将正则编译成Pattern对象14 pattern = re.compile(".") 
15 m = pattern.match(text)
16print(m.group()) #‘t‘

 

　　2. search

　　　　search, 浏览整个字符串去匹配第一个，未匹配成功返回None

            1
            import
             re

            2 text = "Example 3:there is 1 date 11/5/2016 in here"3 m = re.search("(\d{1,2})/(\d{1,2})/(\d{2,4})",text)
4print(m.group(1),m.group(2),m.group(3))# 11 5 2016

     3. sub

　　　　替换匹配成功的指定位置字符串

             1
            import
             re

             2
            #
             sub(pattern, repl, string, count=0, flags=0)
             3
            #
             pattern： 正则模型
             4
            #
             repl   ： 要替换的字符串或可执行对象
             5
            #
             string ： 要匹配的字符串
             6
            #
             count  ： 指定匹配个数
             7
            #
             flags  ： 匹配模式
             8 text = "you‘re no fun anymore fun" 9 m = re.sub("fun","entertaining",text,2)
10print(m)
11# "you‘re no entertaining anymore entertaining"

    4. spilt

          根据正则匹配分隔字符串

            import
             re

            #
             split(pattern, string, maxsplit=0, flags=0)
            
#
             pattern： 正则模型
            
#
             string ： 要匹配的字符串
            
#
             maxsplit：指定分割个数
            
#
             flags  ： 匹配模式
            #
             无分组
origin = "hello alex bcd alex lge alex acd 19"
r = re.split("alex", origin, 1)
print(r) #["hello","bcd alex lge alex acd 19"]# 有分组
origin = "hello alex bcd alex lge alex acd 19"
r1 = re.split("(alex)", origin, 1)
print(r1) # ["hello","alex","bcd alex lge alex acd 19"]
 r2 = re.split("(al(ex))", origin, 1)
print(r2) # ["hello","alex","ex","bcd alex lge alex acd 19"]

    5. findall

获取非重复的匹配列表；如果有一个组则以列表形式返回，且每一个匹配均是字符串；如果模型中有多个组，则以列表形式返回，且每一个匹配均是元祖；

　　　　空的匹配也会包含在结果中 
                1
                #
                 无分组
                2 origin = "hello alex bcd abcd lge acd 19"3 r = re.findall("a\w+",origin)
4print(r) # ["alex","abcd","acd"]56# 有分组7 origin = "hello alex bcd abcd lge acd 19"8 r = re.findall("a((\w*)c)(d)", origin)
9print(r) # 匹配两个字符串"abcd"&"acd"先将匹配最外层分组的元素放入元祖#中，再将内层分组匹配的元素放入元祖中结果[("bc","b","d"),("c","","d")] 
                IP：
^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$
手机号：
^1[3|4|5|8][0-9]\d{8}$
邮箱：
[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+

二、shutil

高级文件、文件夹、压缩包处理模块

  1. 将文件内容拷贝到另一个文件

　　　　shutil.copyfileobj(fsrc, fdst[, length])

                1
                import
                 shutil

                2 shutil.copyfileobj(open(‘old.xml‘,‘r‘), open(‘new.xml‘, ‘w‘))

　　2. 拷贝文件

　　　　shutil.copyfile(src, dst)

                1 shutil.copyfile(‘f1.log‘, ‘f2.log‘)

　　3. 仅拷贝权限。内容、组、用户均不变

　　　　shutil.copymode(src, dst)

                1 shutil.copymode(‘f1.log‘, ‘f2.log‘)

　　4. 仅拷贝状态的信息，包括：mode bits, atime, mtime, flags

　　　　shutil.copystat(src, dst)

                1 shutil.copystat(‘f1.log‘, ‘f2.log‘)

　　5. 拷贝文件和权限

　　　　shutil.copy(src, dst)

                1 shutil.copy(‘f1.log‘, ‘f2.log‘)

　　6. 拷贝文件和状态信息

　　　　shutil.copy2(src, dst)

                1 shutil.copy2(‘f1.log‘, ‘f2.log‘)

　　7. 递归的去拷贝文件夹

　　　　shutil.ignore_patterns(*patterns) 忽略某些格式文件
　　　　shutil.copytree(src, dst, symlinks=False, ignore=None)

                1
                import
                 shutil

                2 shutil.copytree(‘folder1‘, ‘folder2‘, ignore=shutil.ignore_patterns(‘*.pyc‘, ‘tmp*‘))
                1
                import
                 shutil

                2 shutil.copytree(‘f1‘, ‘f2‘, symlinks=True, ignore=shutil.ignore_patterns(‘*.pyc‘, ‘tmp*‘))

　8. 递归的去删除文件

　　　　shutil.rmtree(path[, ignore_errors[, onerror]])

                1
                import
                 shutil

                2 shutil.rmtree(‘folder1‘)

　　9. 递归的去移动文件，它类似mv命令，其实就是重命名。

　　　　shutil.move(src, dst)

                1
                import
                 shutil

                2 shutil.move(‘folder1‘, ‘folder3‘)

　　10. 创建压缩包并返回文件路径，例如：zip、tar

　　　　shutil.make_archive(base_name, format,...) 这个功能只能压缩一个文件夹

  • base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，如：www =>保存至当前路径如：/Users/lcy/www =>保存至/Users/lcy/
  • format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
  • root_dir： 要压缩的文件夹路径（默认当前目录）
  • owner： 用户，默认当前用户
  • group： 组，默认当前组
  • logger： 用于记录日志，通常是logging.Logger对象  
                #
                将 /Users/lcy/Downloads/test 下的文件打包放置当前程序目录
                import
                 shutil
ret = shutil.make_archive("www", ‘gztar‘, root_dir=‘/Users/lcy/Downloads/test‘)
#将 /Users/lcy/Downloads/test 下的文件打包放置 /Users/lcy/目录import shutil
ret = shutil.make_archive("/Users/lcy/www", ‘gztar‘, root_dir=‘/Users/lcy/Downloads/test‘)

附加：ZipFile 和 TarFile一般用这个较多

                 1
                import
                 zipfile

                 2
                 3
                #
                 压缩
                 4 z = zipfile.ZipFile(‘laxi.zip‘, ‘w‘) #创建一个压缩包
 5 z.write(‘a.log‘)
 6 z.write(‘data.data‘)
 7z.close()
 8# 解压 9 z = zipfile.ZipFile(‘laxi.zip‘, ‘r‘)
10z.extractall()
11 z.close()

 

 

原文：http://www.cnblogs.com/lcysen/p/6032932.html

内容总结

以上是互联网集市为您收集整理的python学习之路——基础篇（3）模块（续）全部内容，希望文章能够帮你解决python学习之路——基础篇（3）模块（续）所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1201619.html

来源：【匿名】