非常全的博客，防丢链接参考https://www.cnblogs.com/madsnotes/articles/5521551.html
1、文件操作
1.1 操作流程
1）文件打开
2）文件操作
3）文件关闭
1.2 open简介
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
打开 file 并返回相应 file object (文件对象)。若文件不能被打开的话，会引发 OSError (操作系统错误)。
# python中打开文件有两种方式，即：open(...) 和 file(...) ，本质上前者在内部会调用后者来进行文件操作，推荐使用 open。3.0以后file方法讲被用做其他，open方法会自动的去帮你找他调用得方法在那里！
1.2.1 file(重点)
file 要么是可给出打开文件路径名 (绝对或相对当前工作目录) 的字符串或字节对象，要么是包裹文件的整数文件描述符。
1.2.2 mode(重点)
mode 是能指定文件打开方式的可选字符串。默认值为 'r'，意味着以文本模式读取打开。
可用模式包括：
字符 含义
'r' 读取打开 (默认)
'w' 写入打开 (会先截取文件)
'x' 独占创建打开 (若文件名已存在的话，操作会失败------不是内容是文件名)
'a' 写入打开 (若文件存在的话，会追加到文件末尾)
'b' 二进制模式
't' 文本模式 (默认)
'+' 更新打开磁盘文件 (读写)
'U' universal newlines mode (deprecated)
Python 会区分二进制 I/O 和文本 I/O。以二进制模式 (mode 自变量含有 'b') 打开文件时，无需任何解码就能返回 bytes (字节) 对象内容。在文本模式 (默认，或当 mode 自变量含有 't' 时) 下，会以 str (字符串) 形式返回文件内容 (会先用从属平台编码或给定 encoding 解码字节)。
注意：Python 不会依赖底层操作系统文本文件概念；所有处理都由 Python 自身完成，因此，独立于平台。
1.2.3 buffering
buffering是用来设置缓冲策略的可选整数
1.2.4 encoding(重点)
encoding是用于解码或编码文件的编码名称。这只应用于文本模式。默认编码从属平台 (不管 locale.getpreferredencoding() 函数返回什么)；而且，被 Python 支持的任何编码都可以使用。请参阅 codecs (编解码器) 模块，了解支持编码列表。
>>> import locale
>>> locale.getpreferredencoding()
'cp936'
1.2.5 errors
errors是能指定该如何处理编码、解码错误的可选字符串 – 不可用于二进制模式
1.2.6 newline
newline能控制 universal newlines (通用换行符) 模式如何工作 (只适于文本模式)
1.2.7 closefd
1.2.8 opener
1.3 文件操作案例
以文本模式读取文件内容
文件内容：
12344
aaaaaacccccdddd 操作方法：
>>> f = open('db','r', encoding="utf-8")
>>> data = f.read()
>>> print(data, type(data))
12344
aaaaaacccccdddd
<class 'str'>
>>> f.close()
以文本模式写文件
>>> f = open('db','a', encoding="utf-8")
>>> data = f.write("asdfasdf")
>>> f.close()
以二进制模式读取文件内容
>>> f.close()
>>> f = open('db','rb')
>>> data = f.read()
>>> print(data,type(data))
b'12344\r\naaaaaacccccdddd\r\n' <class 'bytes'>
以二进制模式写文件
原文件内容：
123 >>> f = open("db", 'ab')
>>> f.write(bytes("李杰", encoding="utf-8"))
6
>>> f.close() 文件内容：
123李杰
1.4 文件操作方法
class file(object):
def close(self): # real signature unknown; restored from __doc__
关闭文件
"""
close() -> None or (perhaps) an integer. Close the file.
Sets data attribute .closed to True. A closed file cannot be used for
further I/O operations. close() may be called more than once without
error. Some kinds of file objects (for example, opened by popen())
may return an exit status upon closing.
"""
def fileno(self): # real signature unknown; restored from __doc__
文件描述符
"""
fileno() -> integer "file descriptor".
This is needed for lower-level file interfaces, such os.read().
"""
return 0
def flush(self): # real signature unknown; restored from __doc__
刷新文件内部缓冲区
""" flush() -> None. Flush the internal I/O buffer. """
pass
def isatty(self): # real signature unknown; restored from __doc__
判断文件是否是同意tty设备
""" isatty() -> true or false. True if the file is connected to a tty device. """
return False
def next(self): # real signature unknown; restored from __doc__
获取下一行数据，不存在，则报错 Python 3.x已经没有改功能
""" x.next() -> the next value, or raise StopIteration """
pass
def read(self, size=None): # real signature unknown; restored from __doc__
读取指定字节数据
"""
read([size]) -> read at most size bytes, returned as a string.
If the size argument is negative or omitted, read until EOF is reached.
Notice that when in non-blocking mode, less data than what was requested
may be returned, even if no size parameter was given.
"""
pass
def readinto(self): # real signature unknown; restored from __doc__
读取到缓冲区，不要用，将被遗弃 Python 3.x已经没有改功能
""" readinto() -> Undocumented. Don't use this; it may go away. """
pass
def readline(self, size=None): # real signature unknown; restored from __doc__
仅读取一行数据
"""
readline([size]) -> next line from the file, as a string.
Retain newline. A non-negative size argument limits the maximum
number of bytes to return (an incomplete line may be returned then).
Return an empty string at EOF.
"""
pass
def readlines(self, size=None): # real signature unknown; restored from __doc__
读取所有数据，并根据换行保存值列表
"""
readlines([size]) -> list of strings, each a line from the file.
Call readline() repeatedly and return a list of the lines so read.
The optional size argument, if given, is an approximate bound on the
total number of bytes in the lines returned.
"""
return []
def seek(self, offset, whence=None): # real signature unknown; restored from __doc__
指定文件中指针位置
"""
seek(offset[, whence]) -> None. Move to new file position.
Argument offset is a byte count. Optional argument whence defaults to
(offset from start of file, offset should be >= 0); other values are 1
(move relative to current position, positive or negative), and 2 (move
relative to end of file, usually negative, although many platforms allow
seeking beyond the end of a file). If the file is opened in text mode,
only offsets returned by tell() are legal. Use of other offsets causes
undefined behavior.
Note that not all file objects are seekable.
"""
pass
def tell(self): # real signature unknown; restored from __doc__
获取当前指针位置
""" tell() -> current file position, an integer (may be a long integer). """
pass
def truncate(self, size=None): # real signature unknown; restored from __doc__
截断数据，仅保留指定之前数据
"""
truncate([size]) -> None. Truncate the file to at most size bytes.
Size defaults to the current file position, as returned by tell().
"""
pass
def write(self, p_str): # real signature unknown; restored from __doc__
写内容
"""
write(str) -> None. Write string str to file.
Note that due to buffering, flush() or close() may be needed before
the file on disk reflects the data written.
"""
pass
def writelines(self, sequence_of_strings): # real signature unknown; restored from __doc__
将一个字符串列表写入文件
"""
writelines(sequence_of_strings) -> None. Write the strings to the file.
Note that newlines are not added. The sequence can be any iterable object
producing strings. This is equivalent to calling write() for each string.
"""
pass
def xreadlines(self): # real signature unknown; restored from __doc__
可用于逐行读取文件，非全部 Python 3.x已经没有改功能
"""
xreadlines() -> returns self.
For backward compatibility. File objects now include the performance
optimizations previously implemented in the xreadlines module.
"""
pass
练习：
fileno
>>> f = open('python.txt','r')
>>> f.fileno()
3 flush
isatty
>>> f = open('python.txt.new','r')
>>> f.isatty()
False line_buffering
mode
name
newlines
read
>>> f = open('python.txt.new','r')
>>> f.read()
'模块\npickle\n\n认证信息写入列表，写入文件\n'
>>> f.close() >>> f = open('python.txt.new','r')>>> f.read(10)
'模块\npickle\n'
>>> f.close() readable
readline
>>> f = open('python.txt.new','r')
>>> f.readline()
'模块\n'
>>> f.readline()
'pickle\n'
>>> f.readline()
'\n'
>>> f.readline()
'认证信息写入列表，写入文件\n'
>>> f.close() readlines
>>> f = open('python.txt.new','r')
>>> f.readlines()
['模块\n', 'pickle\n', '\n', '认证信息写入列表，写入文件\n']
>>> f.close() seek
>>> f = open('python.txt.new','r')
>>> f.tell()
0
>>> f.read()
'模块\npickle\n\n认证信息写入列表，写入文件\n'
>>> f.tell()
44
>>> f.close()
1.5 with方法
为了避免打开文件后忘记关闭，可以通过管理上下文，即：(建议使用此方法打开文件)
with open('xb') as f:
pass
如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源
在Python 2.7 后，with又支持同时对多个文件的上下文进行管理，即：
with open('db1', 'r', encoding="utf-8") as f1, open("db2", 'w',encoding="utf-8") as f2: # f1文件读 f2文件写
times = 0
for line in f1:
times += 1
if times <=10:
f2.write(line)
else:
break
with open('db1', 'r', encoding="utf-8") as f1, open("db2", 'w',encoding="utf-8") as f2:
for line in f1:
new_str = line.replace("alex", 'st')
f2.write(new_str)
应用案例：文件备份
>>> with open('python.txt','r') as obj1,open('python.txt.new','w') as obj2:
... for i in obj1.readlines():
... i = i.strip()
... print(i)
... obj2.write(i)
... obj2.write('\n')
...
其实因为处理问题，两个文件并非完全一致
aaarticlea/png;base64,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" alt="" width="982" height="109" />
校验md5值
File: C:\Users\Administrator\python.txt.new # Python重写文件
Size: 44 bytes
Modified: 2016年5月23日 星期一, 22:13:47
MD5: FA84E60379990C979DF1D2EE778E6821
SHA1: 82627034A574A59D5266C9BBC1B427625E38104D
CRC32: 368DCCC0 File: C:\Users\Administrator\python.txt # 原文件
Size: 42 bytes
Modified: 2016年5月9日 星期一, 19:49:35
MD5: 8D6BE3607B6F6E0C8696BE90270FC0DD
SHA1: 522B719CB211C55E10E9EC9BADD453BE14C5EAC4
CRC32: 5D3A3BFF File: C:\Users\Administrator\python - 副本.txt # window直接复制一份文件
Size: 42 bytes
Modified: 2016年5月9日 星期一, 19:49:35
MD5: 8D6BE3607B6F6E0C8696BE90270FC0DD
SHA1: 522B719CB211C55E10E9EC9BADD453BE14C5EAC4
CRC32: 5D3A3BFF
1.6 open对象的属性
open.closed # 返回true如果文件已被关闭，否则返回false。
open.mode # 返回被打开文件的访问模式。
open.name # 返回文件的名称。 应用案例：
>>> fo = open("test.txt", "wb")
>>> print("文件名: ", fo.name)
文件名: test.txt
>>> print("是否已关闭 : ", fo.closed)
是否已关闭 : False
>>> print("访问模式 : ", fo.mode)
访问模式 : rb
2、os模块中的文件操作
Python的os模块提供了帮你执行文件处理操作的方法，比如重命名和删除文件。要使用这个模块，你必须先导入它，然后才可以调用相关的各种功能。
os.rename(current_file_name, new_file_name) # 文件重命名
os.remove(file_name) # 文件删除
os.mkdir("newdir") # 目录创建
os.chdir("newdir") # 目录切换
os.getcwd() # 显示当前目录名称
os.rmdir('dirname') # 删除目录，必须为空目录
os.removedirs(path) # 递归删除目录
os.removedirs(path) # 显示文件或者目录信息
3、正则表达式
3.1 Python正则表达简介
正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。re 模块使 Python 语言拥有全部的正则表达式功能。compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。re 模块也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。
3.2 re模块方法
#
# Secret Labs' Regular Expression Engine
#
# re-compatible interface for the sre matching engine
#
# Copyright (c) 1998-2001 by Secret Labs AB. All rights reserved.
#
# This version of the SRE library can be redistributed under CNRI's
# Python 1.6 license. For any other use, please contact Secret Labs
# AB (info@pythonware.com).
#
# Portions of this engine have been developed in cooperation with
# CNRI. Hewlett-Packard provided funding for 1.6 integration and
# other compatibility work.
# r"""Support for regular expressions (RE). This module provides regular expression matching operations similar to
those found in Perl. It supports both 8-bit and Unicode strings; both
the pattern and the strings being processed can contain null bytes and
characters outside the US ASCII range. Regular expressions can contain both special and ordinary characters.
Most ordinary characters, like "A", "a", or "0", are the simplest
regular expressions; they simply match themselves. You can
concatenate ordinary characters, so last matches the string 'last'. The special characters are:
"." Matches any character except a newline.
"^" Matches the start of the string.
"$" Matches the end of the string or just before the newline at
the end of the string.
"*" Matches 0 or more (greedy) repetitions of the preceding RE.
Greedy means that it will match as many repetitions as possible.
"+" Matches 1 or more (greedy) repetitions of the preceding RE.
"?" Matches 0 or 1 (greedy) of the preceding RE.
*?,+?,?? Non-greedy versions of the previous three special characters.
{m,n} Matches from m to n repetitions of the preceding RE.
{m,n}? Non-greedy version of the above.
"\\" Either escapes special characters or signals a special sequence.
[] Indicates a set of characters.
A "^" as the first character indicates a complementing set.
"|" A|B, creates an RE that will match either A or B.
(...) Matches the RE inside the parentheses.
The contents can be retrieved or matched later in the string.
(?aiLmsux) Set the A, I, L, M, S, U, or X flag for the RE (see below).
(?:...) Non-grouping version of regular parentheses.
(?P<name>...) The substring matched by the group is accessible by name.
(?P=name) Matches the text matched earlier by the group named name.
(?#...) A comment; ignored.
(?=...) Matches if ... matches next, but doesn't consume the string.
(?!...) Matches if ... doesn't match next.
(?<=...) Matches if preceded by ... (must be fixed length).
(?<!...) Matches if not preceded by ... (must be fixed length).
(?(id/name)yes|no) Matches yes pattern if the group with id/name matched,
the (optional) no pattern otherwise. The special sequences consist of "\\" and a character from the list
below. If the ordinary character is not on the list, then the
resulting RE will match the second character.
\number Matches the contents of the group of the same number.
\A Matches only at the start of the string.
\Z Matches only at the end of the string.
\b Matches the empty string, but only at the start or end of a word.
\B Matches the empty string, but not at the start or end of a word.
\d Matches any decimal digit; equivalent to the set [0-9] in
bytes patterns or string patterns with the ASCII flag.
In string patterns without the ASCII flag, it will match the whole
range of Unicode digits.
\D Matches any non-digit character; equivalent to [^\d].
\s Matches any whitespace character; equivalent to [ \t\n\r\f\v] in
bytes patterns or string patterns with the ASCII flag.
In string patterns without the ASCII flag, it will match the whole
range of Unicode whitespace characters.
\S Matches any non-whitespace character; equivalent to [^\s].
\w Matches any alphanumeric character; equivalent to [a-zA-Z0-9_]
in bytes patterns or string patterns with the ASCII flag.
In string patterns without the ASCII flag, it will match the
range of Unicode alphanumeric characters (letters plus digits
plus underscore).
With LOCALE, it will match the set [0-9_] plus characters defined
as letters for the current locale.
\W Matches the complement of \w.
\\ Matches a literal backslash. This module exports the following functions:
match Match a regular expression pattern to the beginning of a string.
fullmatch Match a regular expression pattern to all of a string.
search Search a string for the presence of a pattern.
sub Substitute occurrences of a pattern found in a string.
subn Same as sub, but also return the number of substitutions made.
split Split a string by the occurrences of a pattern.
findall Find all occurrences of a pattern in a string.
finditer Return an iterator yielding a match object for each match.
compile Compile a pattern into a RegexObject.
purge Clear the regular expression cache.
escape Backslash all non-alphanumerics in a string. Some of the functions in this module takes flags as optional parameters:
A ASCII For string patterns, make \w, \W, \b, \B, \d, \D
match the corresponding ASCII character categories
(rather than the whole Unicode categories, which is the
default).
For bytes patterns, this flag is the only available
behaviour and needn't be specified.
I IGNORECASE Perform case-insensitive matching.
L LOCALE Make \w, \W, \b, \B, dependent on the current locale.
M MULTILINE "^" matches the beginning of lines (after a newline)
as well as the string.
"$" matches the end of lines (before a newline) as well
as the end of the string.
S DOTALL "." matches any character at all, including the newline.
X VERBOSE Ignore whitespace and comments for nicer looking RE's.
U UNICODE For compatibility only. Ignored for string patterns (it
is the default), and forbidden for bytes patterns. This module also defines an exception 'error'. """ import sys
import sre_compile
import sre_parse
try:
import _locale
except ImportError:
_locale = None # public symbols
__all__ = [
"match", "fullmatch", "search", "sub", "subn", "split",
"findall", "finditer", "compile", "purge", "template", "escape",
"error", "A", "I", "L", "M", "S", "X", "U",
"ASCII", "IGNORECASE", "LOCALE", "MULTILINE", "DOTALL", "VERBOSE",
"UNICODE",
] __version__ = "2.2.1" # flags
A = ASCII = sre_compile.SRE_FLAG_ASCII # assume ascii "locale"
I = IGNORECASE = sre_compile.SRE_FLAG_IGNORECASE # ignore case
L = LOCALE = sre_compile.SRE_FLAG_LOCALE # assume current 8-bit locale
U = UNICODE = sre_compile.SRE_FLAG_UNICODE # assume unicode "locale"
M = MULTILINE = sre_compile.SRE_FLAG_MULTILINE # make anchors look for newline
S = DOTALL = sre_compile.SRE_FLAG_DOTALL # make dot match newline
X = VERBOSE = sre_compile.SRE_FLAG_VERBOSE # ignore whitespace and comments # sre extensions (experimental, don't rely on these)
T = TEMPLATE = sre_compile.SRE_FLAG_TEMPLATE # disable backtracking
DEBUG = sre_compile.SRE_FLAG_DEBUG # dump pattern after compilation # sre exception
error = sre_compile.error # --------------------------------------------------------------------
# public interface def match(pattern, string, flags=0):
"""Try to apply the pattern at the start of the string, returning
a match object, or None if no match was found."""
return _compile(pattern, flags).match(string)
'''
尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none
pattern:匹配的正则表达式
string:要匹配的字符串
flags:标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
'''
def fullmatch(pattern, string, flags=0):
"""Try to apply the pattern to all of the string, returning
a match object, or None if no match was found."""
return _compile(pattern, flags).fullmatch(string) def search(pattern, string, flags=0):
"""Scan through string looking for a match to the pattern, returning
a match object, or None if no match was found."""
return _compile(pattern, flags).search(string)
'''
扫描整个字符串并返回第一个成功的匹配
各个参数含义与match()一致
''' def sub(pattern, repl, string, count=0, flags=0):
"""Return the string obtained by replacing the leftmost
non-overlapping occurrences of the pattern in string by the
replacement repl. repl can be either a string or a callable;
if a string, backslash escapes in it are processed. If it is
a callable, it's passed the match object and must return
a replacement string to be used."""
return _compile(pattern, flags).sub(repl, string, count)
'''
替换字符串中的匹配项
''' def subn(pattern, repl, string, count=0, flags=0):
"""Return a 2-tuple containing (new_string, number).
new_string is the string obtained by replacing the leftmost
non-overlapping occurrences of the pattern in the source
string by the replacement repl. number is the number of
substitutions that were made. repl can be either a string or a
callable; if a string, backslash escapes in it are processed.
If it is a callable, it's passed the match object and must
return a replacement string to be used."""
return _compile(pattern, flags).subn(repl, string, count) def split(pattern, string, maxsplit=0, flags=0):
"""Split the source string by the occurrences of the pattern,
returning a list containing the resulting substrings. If
capturing parentheses are used in pattern, then the text of all
groups in the pattern are also returned as part of the resulting
list. If maxsplit is nonzero, at most maxsplit splits occur,
and the remainder of the string is returned as the final element
of the list."""
return _compile(pattern, flags).split(string, maxsplit) def findall(pattern, string, flags=0):
"""Return a list of all non-overlapping matches in the string. If one or more capturing groups are present in the pattern, return
a list of groups; this will be a list of tuples if the pattern
has more than one group. Empty matches are included in the result."""
return _compile(pattern, flags).findall(string)
'''
match\search只能匹配字符串中的一个，如果想要匹配到字符串中所有符合条件的元素，则需要使用 findall
''' def finditer(pattern, string, flags=0):
"""Return an iterator over all non-overlapping matches in the
string. For each match, the iterator returns a match object. Empty matches are included in the result."""
return _compile(pattern, flags).finditer(string) def compile(pattern, flags=0):
"Compile a regular expression pattern, returning a pattern object."
return _compile(pattern, flags) def purge():
"Clear the regular expression caches"
_cache.clear()
_cache_repl.clear() def template(pattern, flags=0):
"Compile a template pattern, returning a pattern object"
return _compile(pattern, flags|T) _alphanum_str = frozenset(
"_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890")
_alphanum_bytes = frozenset(
b"_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890") def escape(pattern):
"""
Escape all the characters in pattern except ASCII letters, numbers and '_'.
"""
if isinstance(pattern, str):
alphanum = _alphanum_str
s = list(pattern)
for i, c in enumerate(pattern):
if c not in alphanum:
if c == "\000":
s[i] = "\\000"
else:
s[i] = "\\" + c
return "".join(s)
else:
alphanum = _alphanum_bytes
s = []
esc = ord(b"\\")
for c in pattern:
if c in alphanum:
s.append(c)
else:
if c == 0:
s.extend(b"\\000")
else:
s.append(esc)
s.append(c)
return bytes(s) # --------------------------------------------------------------------
# internals _cache = {}
_cache_repl = {} _pattern_type = type(sre_compile.compile("", 0)) _MAXCACHE = 512
def _compile(pattern, flags):
# internal: compile pattern
try:
p, loc = _cache[type(pattern), pattern, flags]
if loc is None or loc == _locale.setlocale(_locale.LC_CTYPE):
return p
except KeyError:
pass
if isinstance(pattern, _pattern_type):
if flags:
raise ValueError(
"cannot process flags argument with a compiled pattern")
return pattern
if not sre_compile.isstring(pattern):
raise TypeError("first argument must be string or compiled pattern")
p = sre_compile.compile(pattern, flags)
if not (flags & DEBUG):
if len(_cache) >= _MAXCACHE:
_cache.clear()
if p.flags & LOCALE:
if not _locale:
return p
loc = _locale.setlocale(_locale.LC_CTYPE)
else:
loc = None
_cache[type(pattern), pattern, flags] = p, loc
return p def _compile_repl(repl, pattern):
# internal: compile replacement pattern
try:
return _cache_repl[repl, pattern]
except KeyError:
pass
p = sre_parse.parse_template(repl, pattern)
if len(_cache_repl) >= _MAXCACHE:
_cache_repl.clear()
_cache_repl[repl, pattern] = p
return p def _expand(pattern, match, template):
# internal: match.expand implementation hook
template = sre_parse.parse_template(template, pattern)
return sre_parse.expand_template(template, match) def _subx(pattern, template):
# internal: pattern.sub/subn implementation helper
template = _compile_repl(template, pattern)
if not template[0] and len(template[1]) == 1:
# literal replacement
return template[1][0]
def filter(match, template=template):
return sre_parse.expand_template(template, match)
return filter # register myself for pickling import copyreg def _pickle(p):
return _compile, (p.pattern, p.flags) copyreg.pickle(_pattern_type, _pickle, _compile) # --------------------------------------------------------------------
# experimental stuff (see python-dev discussions for details) class Scanner:
def __init__(self, lexicon, flags=0):
from sre_constants import BRANCH, SUBPATTERN
self.lexicon = lexicon
# combine phrases into a compound pattern
p = []
s = sre_parse.Pattern()
s.flags = flags
for phrase, action in lexicon:
gid = s.opengroup()
p.append(sre_parse.SubPattern(s, [
(SUBPATTERN, (gid, sre_parse.parse(phrase, flags))),
]))
s.closegroup(gid, p[-1])
p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
self.scanner = sre_compile.compile(p)
def scan(self, string):
result = []
append = result.append
match = self.scanner.scanner(string).match
i = 0
while True:
m = match()
if not m:
break
j = m.end()
if i == j:
break
action = self.lexicon[m.lastindex-1][1]
if callable(action):
self.match = m
action = action(self, m.group())
if action is not None:
append(action)
i = j
return result, string[i:]
3.3 re应用案例
aaarticlea/png;base64,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" alt="" />
# re.match()
>>> import re # 导入re模块
>>> print(re.match('www', 'www.runoob.com').span()) # 在起始位置匹配
(0, 3)
>>> print(re.match('com', 'www.runoob.com')) # 不在起始位置匹配
None # 其他案例
>>> import re
>>>
>>> obj = re.match('\d+', '123uuasf')
>>> if obj:
... print(obj.group())
...
123 # group()
>>> import re
>>>
>>> line = "Cats are smarter than dogs"
>>> matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
>>>
>>> if matchObj:
... print ("matchObj.group() : ", matchObj.group())
... print ("matchObj.group(1) : ", matchObj.group(1))
... print ("matchObj.group(2) : ", matchObj.group(2))
... else:
... print ("No match!!")
...
matchObj.group() : Cats are smarter than dogs
matchObj.group(1) : Cats
matchObj.group(2) : smarter # re.search()
>>> import re
>>> print(re.search('www', 'www.runoob.com').span()) # 在起始位置匹配
(0, 3)
>>> print(re.search('com', 'www.runoob.com').span()) # 不在起始位置匹配
(11, 14) # 其他案例
>>> obj = re.search('\d+', 'u123uu888asf')
>>> if obj:
... print(obj.group())
...
123 # re.findall()
>>> import re
>>>
>>> obj = re.findall('\d+', 'fa123uu888asf')
>>> print(obj)
['123', '888']
re.match与re.search的区别:
re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。
import re line = "Cats are smarter than dogs"; matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
print("match --> matchObj.group() : ", matchObj.group())
else:
print("No match!!") matchObj = re.search( r'dogs', line, re.M|re.I)
if matchObj:
print("search --> matchObj.group() : ", matchObj.group())
else:
print("No match!!") # re.sub()
>>> import re
>>>
>>> phone = "2004-959-559 # This is Phone Number"
>>>
>>> # Delete Python-style comments
... num = re.sub(r'#.*$', "", phone)
>>> print ("Phone Num : ", num)
Phone Num : 2004-959-559
>>>
>>> # Remove anything other than digits
... num = re.sub(r'\D', "", phone)
>>> print ("Phone Num : ", num)
Phone Num : 2004959559
3.4 正则表达式修饰符-可选标志
正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：
aaarticlea/png;base64,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" alt="" />
3.5 正则表达式模式
模式字符串使用特殊的语法来表示一个正则表达式：
字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。
多数字母和数字前加一个反斜杠时会拥有不同的含义。
标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。
反斜杠本身需要使用反斜杠转义。
由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r'/t'，等价于'//t')匹配相应的特殊字符。
下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变。
aaarticlea/png;base64,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" alt="" />
练习：
# 字符匹配（普通字符，元字符）
# 普通字符：大多数字符和字母都会和自身匹配
>>> import re
>>> re.findall('alex','yuanaleSxalexwupeiqi')
['alex']
>>> re.findall('yuan','yuanaleSxalexwupeiqi')
['yuan'] # 元字符(. ^ $ * + ? { } [ ] | ( ) \)
# 注：[]比较特殊会去掉括号内的具有特性的字符，使其变为普通字符
# . ：匹配任意单个字符
>>> re.findall('al.x','yuanaleSxalexwupeiqialax') # 字母
['alex', 'alax']
>>> re.findall('al.x','yuanaleSxalexwupeiqialaxal4x') # 数字
['alex', 'alax', 'al4x']
>>> re.findall('al.x','yuanaleSxalexwupeiqialaxal!x') # ！符号
['alex', 'alax', 'al!x']
>>> re.findall('al.x','yuanaleSxalexwupeiqialaxal@x') # @符号
['alex', 'alax', 'al@x']
# ^ ：匹配以某个字符开头 $匹配以某个字符结尾
>>> re.findall('^yuan','yuanaleSxalexwupeiqialaxalx')
['yuan']
>>> re.findall('alx$','yuanaleSxalexwupeiqialaxalx')
['alx'] # *：匹配前一个字符0次或者多次
>>> re.findall('al*x','yuanaleSxalexwuallllxpeiqialaxalx')
['allllx', 'ax', 'alx'] # + ：匹配前一个字符1次或者多次（对比1个例子）
>>> re.findall('al+x','yuanaleSxalexwuallllxpeiqialaxalx')
['allllx', 'alx'] # ？：匹配前一个字符0次或者1次（对比2个例子）
>>> re.findall('al?x','yuanaleSxalexwuallllxpeiqialaxalx')
['ax', 'alx'] # {m}：匹配前一个字符m次 {m,}: 匹配前面的字符m次或者更多次 {m,n}:匹配前面的内容m到n次
>>> re.findall('al{4}x','yuanaleSxalexwuallllxpeiqialaxalx')
['allllx']
>>> re.findall('al{4,}x','yuanaleSxalexwuallllxpalllllllllxeiqialaxalx')
['allllx', 'alllllllllx']
>>> re.findall('al{3,4}x','yuanaleSxalexwuallllxpeiqialaxalx')
['allllx'] # [] :字符集，可能位置是字符集中的任意字符 a-z A-Z 0-9 在[]中，只有字符^、-、]和\有特殊含义。字符\仍然表示转义，字符-可以定义字符范围，字符^放在前面，表示非
>>> re.findall('al[a-z]x','yuanaleSxalexwuallllxpeiqialaxalx')
['alex', 'alax'] # | ：表示匹配|两边的任意一个表达式 此例：匹配 ale 或者 xx
>>> re.findall('ale|xx','yuanaleSxalexwuallllxpeiqialaxalxx')
['ale', 'ale', 'xx'] #（）：被括起来的表达式将作为分组 # \：转义字符，是一个普通字符改变原有的含义 是原字符则去除特殊功能
>>> re.findall('\alex','yuanaleSxalexwuallllxpeiqialaxalxx') #\a有特殊含义
[]
>>> re.findall('a\lex','yuanaleSxalexwuallllxpeiqialaxalxx') #\l 没有特殊含义
['alex']
>>> re.findall('al\ex','yuanaleSxalexwuallllxpeiqialaxalxx') # \e没有特殊含义
['alex']
# 特殊字符类
# \d 匹配任何十进制数；它相当于类 [0-9]。
>>> re.findall('al.x','yuanaleSxalexwuallllxpeiqialaxal3x') # 正常匹配
['alex', 'alax', 'al3x']
>>> re.findall('al\dx','yuanaleSxalexwuallllxpeiqialaxal3x')
['al3x'] # \D 匹配任何非数字字符；它相当于类 [^0-9]。
>>> re.findall('al\Dx','yuanaleSxalexwuallllxpeiqialaxal3x')
['alex', 'alax'] # \s 匹配任何空白字符；它相当于类 [ \t\n\r\f\v]。
# \S 匹配任何非空白字符；它相当于类 [^ \t\n\r\f\v]。
# \w 匹配任何字母数字字符；它相当于类 [a-zA-Z0-9_]。
# \W 匹配任何非字母数字字符；它相当于类 [^a-zA-Z0-9_]
# \b: 匹配一个单词边界，也就是指单词和空格间的位置。匹配单词边界（包括开始和结束），这里的“单词”，是指连续的字母、数字和
下划线组成的字符串。注意，\b的定义是\w和\W的交界，这是个零宽界定符（zero-width assertions）只用以匹配单词的词首和词尾。
单词被定义为一个字母数字序列，因此词尾就是用空白符或非字母数字符来标示的。
分组
# re.compile()
>>> p = re.compile('(a(b)c)d')
>>> m = p.match('abcd')
>>> m.group(0)
'abcd'
>>> m.group(1)
'abc'
>>> m.group(2)
'b'
贪婪模式，惰性模式
3.7 常见正则应用
# 匹配手机号
>>> import re
>>> phone_num = '13001000000'
>>> a = re.compile(r"^1[\d+]{10}")
>>> b = a.match(phone_num)
>>> print(b.group())
13001000000 # 匹配IP地址
ip = '192.168.1.1'
a = re.compile(r"(((1?[0-9]?[0-9])|(2[0-4][0-9])|(25[0-5]))\.){3}((1?[0-9]?[0-9])|(2[0-4][0-9])|(25[0-5]))$")
b = a.search(ip)
print(b) # 匹配 email
email = '630571017@qq.com'
a = re.compile(r"(.*){0,26}@(\w+){0,20}.(\w+){0,8}")
b = a.search(email)
print(b.group())
3、json&pickle
与文件相关的操作，应用案例详见：http://www.cnblogs.com/madsnotes/articles/5537947.html
出处：http://www.cnblogs.com/madsnotes/
声明：本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接。