Python核心编程--学习笔记--6--序列（上）字符串
本章研究Python中的序列：字符串、列表和元组。因为这些类型其实都是由一些成员共同组成的一个序列整体，所以我们把它们统称为序列。序列的存储结构可以表示为：
1 序列
序列类型有着相同的访问模式：按下标访问某一元素[0, N-1]，也可以通过切片操作一次得到多个元素。
1.1 标准类型操作符
比较运算、逻辑运算（见4.5节），一般都能适用于所有序列类型。
1.2 序列类型操作符
1 in, not in #成员关系操作符
2 + #连接操作符
3 * #重复操作符
4 [] #切片操作符
成员关系操作符——obj [not] int sequence，判断对象obj是否属于序列sequence：
>>> 'py' in 'python'
True
>>> 4 not in range(6)
False
连接操作符——sequence1+sequence2，将两个序列合并在一起，返回一个新序列：
>>> 'Py' + 'thon'
'Python'
>>> range(4) + range(4,8)
[0, 1, 2, 3, 4, 5, 6, 7]
重复操作符——sequence * copies_int，返回一个新序列，包含copies_int个重复的sequence：
>>> '-' * 20
'--------------------'
切片操作符——seq[index]，seq[start:stop]，seq[start:stop:step]，访问 元素/子序列/按步长访问：
>>> aList = range(10)
>>> aList
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> aList[4] #按下标访问单个元素
4
>>> aList[10] #下标范围：0～len(seq)，超出范围则产生异常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> aList[:] #切片操作，不指定起点和终点，则复制全部元素
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> aList[None:8] #起始为None，则默认从第一个元素开始
[0, 1, 2, 3, 4, 5, 6, 7]
>>> aList[3:] #终点为空，则默认直到最后一个元素
[3, 4, 5, 6, 7, 8, 9]
>>> aList[1::3] #步长为3
[1, 4, 7]
>>> aList[-1:-len(aList)] #负索引。不管正负索引，起始元素一定要在终点元素的左边，否则返回空
[]
>>> aList[-len(aList):-1] #负索引
[0, 1, 2, 3, 4, 5, 6, 7, 8]
>>> aList[-100:100:2] #切片操作可以超出范围
[0, 2, 4, 6, 8]
逆序访问序列，以及循环输出每次都去掉最后一个字符的序列：
>>> aList = range(5)
>>> aList
[0, 1, 2, 3, 4]
>>> aList[::-1] #逆序输出
[4, 3, 2, 1, 0]
>>> for i in [None] + range(-1, -len(aList), -1): #加[None]，否则第一个输出不包含最后一个元素
... print aList[ :i]
...
[0, 1, 2, 3, 4]
[0, 1, 2, 3]
[0, 1, 2]
[0, 1]
[0]
1.3 内建函数
类型转换工厂函数：
1 str(obj) #把obj对象转换成字符串(对象的字符串表示法)
2 list(iter) #把可迭代对象转换成一个列表对象
3 tuple(iter) #把可迭代对象转换成一个元组对象
4 unicode(obj) #把对象转换成Unicode字符串(使用默认编码)
5 basestring() #抽象工厂函数，其作用仅仅是为str和unicode函数提供父类，所以不能被实例化，也不能被调用(详见第2节)
>>> str([1,2,3])
'[1, 2, 3]'
>>> list('abcd')
['a', 'b', 'c', 'd']
>>> tuple('abcd')
('a', 'b', 'c', 'd')
一些可操作的内建函数：
1 len(seq) #返回seq的长度 2 sum(seq, init=0) #返回seq和可选参数init的总和 3 reversed(seq) #接受一个序列作为参数，返回一个以逆序访问的迭代器
#接受一个可迭代对象作为参数，返回一个enumerate对象(也是一个迭代器)，该对象生成由iter每个元素的index值和item值组成的元组
4 enumerate(iter)
#返回iter或(arg0,arg1,...)中的最大值；如果指定了key，则key必须是一个可以传给sort()方法的用于比较的回调函数
5 max(iter,key=None) or 6 max(arg0, arg1, ..., key=None) 7 min(iter, key=None) or 8 min(arg0, arg1, ..., key=None)#返回iter或(arg0,arg1,...)中的最小值；如果指定了key，key同上
#接受一个可迭代对象作为参数，返回一个有序的列表;可选参数func,key 和 reverse 的含义跟 list.sort()内建函数的参数含义一样.
9 sorted(iter, func=None, key=None, reverse=False)
10 zip([it0, it1,... itN])#返回一个列表，其第一个元素是it0,it1,...这些迭代对象各自第一个元素组成的一个元组，以此类推。返回列表长度等于it..中的最小值。
2 字符串
字符串即单/双/三引号括起来的内容；通常的字符串（str）和Unicode字符串（unicode）都是抽象类basestring的子类，这个basestring不能被实例化。
>>> basestring('abc')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: The basestring type cannot be instantiated
访问：字符串可以通过下标和切片访问字符和子串，不允许通过下标更改其内容，因为字符串是不可变类型。
>>> aStr = 'Hello Python'
>>> aStr[4]
'o'
>>> aStr[4] = 'O' #下标操作，实际上返回一个长为1的子串，字符串对象不可更改
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
更新：同整数一样，更新字符串的值，实际上是创建了一个新对象，并将其引用赋值给原来的变量。
>>> bStr is aStr
True
>>> bStr += 'er'
>>> bStr
'Hello Pythoner'
>>> aStr #原对象未变
'Hello Python'
删除：要么赋一个空字符串值（其实是减少原对象的引用计数），要么显示的del掉这个变量引用。不能直接删除其中字符或子串。
3 字符串和操作符
3.1 标准类型操作符
比较运算、逻辑运算都适合于字符串，实际按照字符ASCII值来比较。
3.2 序列操作符
切片操作符[]、成员操作符[not] in、连接操作符+、重复操作符* 都适用于字符串。
一些string模块预定义的字符串：
>>> import string
>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'
>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.digits
'0123456789'
>>> a = 'hello' + ' ' + 'world' #运行时连接字符串
>>> a
'hello world'
>>> b = 'hello' ' ' "word" #编译时连接字符串，同其他语言，Python默认将相邻的字符串连接为一个
>>> b
'hello word'
如果一个普通字符串和一个Unicode字符串连接，则普通字符串会被先转换成Unicode字符串，再连接：
>>> 'hello' + u' ' + 'world'
u'hello world'
4 只适用于字符串的操作符
4.1 格式化操作符
类似于C语言里printf()函数的格式。字符串格式化符号：
1 %c #转换成字符(ASCII码值，或者长度为一的字符串)
2 %r #优先用repr()函数进行字符串转换
3 %s #优先用 str()函数进行字符串转换
4 %d/%i #转成十进制数
5 %u #转成十进制数
6 %o #转成八进制数
7 %x/%X #转成十六进制数(x/X代表转换后的十六进制字符的大小写)
8 %e/%E #转成科学计数法(e/E控制输出e/E)
9 %f/%F #转成浮点数(小数部分自然截断)
10 %g/%G #%e和%f / %E和%F的简写
11 %% #输出%
格式化操作符辅助命令：
1 * #定义宽度或者小数点精度
2 - #左对齐
3 + #在正数前面显示加号( + )
4 <sp> #在正数前面显示空格
5 # #在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
6 0 #显示的数字前面填充‘0’而不是默认的空格
7 % #'%%'输出一个单一的'%'
8 (var) #映射变量(字典参数)
9 m.n #m是显示的最小总宽度,n是小数点后的位数(如果可用的话)
例子：
>>> '%x' % 108 #返回其十六进制的字符串表示 '6c' >>> '%#X' % 108 #打印十六进制的前缀，大写X '0X6C' >>> '%.2f' % 1234.567890 #保留两位小数位，默认为六位 '1234.57' >>> '%e' % 1234.567890 #科学计数法，默认小数点后六位 '1.234568e+03' >>> '%G' % 1234.567890 #默认整数位和小数位一共保留6位，从左到右第一个非0数字开始计算 '1234.57'
>>> '%g' % 0.001234567890 #前面的0不计入这六位数
'0.00123457' >>> "%+d" % 4 #整数加符号 '+4' >>> "% d" % 4 #整数前加空格 ' 4' >>> "we are at %d%%" % 100 #输出% 'we are at 100%' >>> num = 123 >>> 'dec: %d/ oct: %#o/ hex: %#X' % (num, num, num) #分别输出十进制、带前缀的八进制和十六进制 'dec: 123/ oct: 0173/ hex: 0X7B' >>> "MM/DD/YY = %02d/%02d/%02d" % (5, 15, 2014) #输出宽度至少为2，不够的前面补0 'MM/DD/YY = 05/15/2014' >>> 'There are %(howmany)d %(lang)s Quotation Symbols' % \ ... {'lang': 'Python', 'howmany': 3} #字典的键作为格式符，输出对应值的相应格式 'There are 3 Python Quotation Symbols'
字符串格式化操作符是一个很有用的调试工具，print语句自动为每个对象调用str()函数，获得一个适当的描述信息。
4.2 字符串模板：更简单的替代品
对于上一节最后一个例子，如果忘记了%(lang)s等这种转换类型参数，就会产生错误。
而新的字符串模板Template对象使用类似shell中变量一样的$符号，还有两个方法substitute()和safe_substitute()，来显示字符串：
>>> from string import Template
>>> s = Template('There are ${howmany} ${lang} Quotation Symbols') #两个变量
>>> print s.substitute(howmany=3, lang='Python') #使用模板
There are 3 Python Quotation Symbols
>>> print s.substitute(lang='Python') #只提供了一个变量实参，引发异常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/usr/lib/python2.7/string.py", line 172, in substitute
return self.pattern.sub(convert, self.template)
File "/usr/lib/python2.7/string.py", line 162, in convert
val = mapping[named]
KeyError: 'howmany'
>>> print s.safe_substitute(lang='Python') #安全函数，虽然只提供一个参数，仍然输出
There are ${howmany} Python Quotation Symbols
4.3 原始字符串操作符（r/R）
字符串前面加r，取消串内的转义：
>>> f = open('C:\windows\temp\readme.txt', 'r') #\t \r被转义
Traceback (most recent call last):
Edit By Vheavens Edit By Vheavens
File "<stdin>", line 1, in ?
f = open('C:\windows\temp\readme.txt', 'r')
IOError: [Errno 2] No such file or directory: 'C:\\windows\\temp\readme.txt'
>>> f = open(r'C:\windows\temp\readme.txt', 'r') #取消转移
>>> f.readline()
'Table of Contents (please check timestamps for last update!)\n'
>>> f.close()
4.4 Unicode字符串操作符（u/U）
>>> u'abc'
u'abc'
>>> ur'Hello\nWorld' #u必须在r之前
u'Hello\\nWorld'
5 内建函数
5.1 标准类型函数
cmp(obj1, obj2)——对于字符串，则是按照ASCII值来比较大小的。左边大，返回1；左边小，返回-1；相等则返回0。
5.2 序列类型函数
len()返回字符个数、max()和min()分别返回ASCII值最大和最小的字符、enumerate()返回包含下标和字符的元组组成的迭代对象、zip()返回一个列表：
>>> enumerate('abc')
<enumerate object at 0xb72b0cac>
>>> for i in enumerate('abc'): #返回一个可迭代对象
... print i
...
(0, 'a')
(1, 'b')
(2, 'c')
>>> for i,c in enumerate('abc'):
... print i,c
...
0 a
1 b
2 c
>>> zip('123', 'ABC', 'abc') #各自第n个元素组成的元组，成为返回值列表的第n个元素
[('1', 'A', 'a'), ('2', 'B', 'b'), ('3', 'C', 'c')]
5.3 字符串类型函数
1 raw_input() #可以用一个字符串作参数，作为提示，将用户输入转为字符串返回
2 str() #工厂函数，将对象转换成可打印的字符串表示
3 unicode() #工厂函数，将对象转换成Unicode的字符串表示
4 chr() #接收[0,255]内的数，返回对应的字符
5 unichr() #接收一定范围内的数，返回Unicode字符（具体范围视系统配置而定）
6 ord() #接收一个字符
>>> unichr(12345)
u'\u3039'
>>> ord('a')
97
>>> ord(u'\u2345') #\u表明后面是一个Unicode字符，如果不加，就是一个字符串'2345'
9029
6 字符串内建函数
字符串是不可变类型，下面这些方法都是生成一个新对象并返回，原字符串并未变化：
1 string.capitalize() #把字符串的第一个字符大写
2 string.center(width) #返回一个原字符串居中，并使用空格填充两边至长度width的新字符串
3 string.count(str, beg=0, end=len(string)) #返回str在一定范围里面出现的次数
#以encoding指定的编码格式解码string，出错默认报ValueError的异常，除非errors指定'ignore'或'replace'
4 string.decode(encoding='UTF-8', errors='strict')
5 string.encode(encoding='UTF-8', errors='strict') #以encoding指定的编码格式编码string，errors同上
6 string.endswith(obj, beg=0, end=len(string)) #检查一定范围内的子字符串是否以obj结束
7 string.expandtabs(tabsize=8) #把字符串string中的tab符号转为tabsize个空格
8 string.find(str, beg=0,end=len(string)) #检测str是否在一定范围子串内，在则返回其第一次出现下标，否则返回-1
9 string.index(str, beg=0,end=len(string)) #跟find()方法一样，不过如果str不在string中会报一个异常
10 string.format(*args, **kwargs) #格式化输出字符串，用参数代替字符串内的{}占位符
11 string.isalnum() #如果string非空，且所有字符都是字母或数字，则返回True
12 string.isalpha() #如果string非空，且所有字符都是字母，则返回True
13 string.isdigit() #如果string非空，且所有字符都是数字，则返回True
14 string.islower() #如果string非空，且所包含的字母都是小写，则返回True
15 string.isspace() #如果string中只包含空格，则返回True
16 string.istitle() #如果string是标题化的(见title())则返回True
17 string.isupper() #如果string非空，且所包含的字母都是大写，则返回True
18 string.join(seqs) #以string作为分隔符，将seqs中所有的元素(的字符串表示)合并为一个新的字符串
19 string.ljust(width) #返回一个原字符串左对齐，并使用空格填充至长度width的新字符串
20 string.lower() #将string中存在的所有大写字符转为小写
21 string.lstrip() #截掉string左边的空格
22 string.partition(str) #把string分成一个以str为中间元素的3元素元组，如果string中不包含str，则string为第一个元素
23 string.replace(str1, str2, num=string.count(str1)) #把string中的前num个str1替换成str2
24 string.rfind(str, beg=0, end=len(string)) #类似于find()函数，不过是从右边开始查找
25 string.rindex(str, beg=0, end=len(string)) #类似于index()，不过是从右边开始
26 string.rjust(width) #返回一个原字符串右对齐，并使用空格填充至长度width的新字符串
27 string.rpartition(str) #类似于partition()函数，不过是从右边开始查找
28 string.rsplit() #见split()函数，不过从右边开始计算
29 string.rstrip() #删除string字符串末尾的空格
30 string.split(str=" ", num=string.count(str)) #以str为分隔符，将string从前num个分隔符上切开
31 string.splitlines(num=string.count('\n')) #同上，不过分隔符改成换行符
32 string.startswith(obj, beg=0, end=len(string)) #检查一定范围内的子字符串是否是以obj开头
33 string.strip([obj]) #在string上执行lstrip()和rstrip()
34 string.swapcase() #翻转string中的大小写
35 string.title() #返回"标题化"的string，即所有单词都是以大写开始，其余字母均为小写
36 string.translate(str, del="") #根据str给出的表(包含256个字符)转换string的字符，要过滤掉的字符放到del参数中
37 string.upper() #将string中的所有的小写字母转换为大写
38 string.zfill(width) #返回长度为width的字符串，原字符串string右对齐，前面填充0
第十个format()函数在原书中没有，但是本人机器上的python版本有（dir(str)可看到），所以举几个例子：
>>> '{1},{0}'.format('world', 'hello') #{}占位符，可以调整顺序
'hello,world'
>>> '{1},{0},{py}'.format('world', 'hello', py = 'pythoner') #{变量}占位符
'hello,world,pythoner'
7 字符串的独特特性
7.1 特殊字符串和控制字符
即转义字符，控制字符的一个用处就是用作定界符，它们不可打印：
1 八进制 十进制 十六进制 字符 说明
2 \0 000 0 0x00 NUL 空字符 Nul #Python中不是字符串的结束符
3 \a 007 7 0x07 BEL 响铃字符
4 \b 010 8 0x08 BS 退格
5 \t 011 9 0x09 HT 横向制表符
6 \n 012 10 0x0A LF 换行
7 \v 013 11 0x0B VT 纵向制表符
8 \f 014 12 0x0C FF 换页
9 \r 015 13 0x0D CR 回车
10 \e 033 27 0x1B ESC 转义
11 \" 042 34 0x22 " 双引号
12 \' 047 39 0x27 ' 单引号
13 \\ 134 92 0x5C \ 反斜杠
14 \000 ~ \177 八进制值
15 \x00 ~ \xff x开头的十六进制值
16 \ 连字符，将本行和下一行的内容连接起来
7.2 三引号
允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。对于HTML或SQL很有用：
>>> s='''hello
... world
... \tI'm
... here'''
>>> s
"hello\nworld\n\tI'm\nhere"
>>> print s
hello
world
I'm
here
7.3 字符串不变性
字符串是不可变类型：
>>> s = 'abc'
>>> id(s)
139902686038944
>>> s += 'def'
>>> id(s) #新分配内存，生成一个新对象，原对象被回收
139902685293376
8 Unicode
8.1 术语
1 名词 意思
2 ASCII #美国标准信息交换码
3 BMP #基本多文种平面(第零平面)
4 BOM #字节顺序标记(标识字节顺序的字符)
5 CJK/CJKV #中文-日文-韩文(和越南语)的缩写
6 Code point #类似于ASCII值，代表Unicode字符的值，范围在range(1114112)或者说0x000000到0x10FFFF
7 Octet #八位二进制数的位组
8 UCS #通用字符集
9 UCS2 #UCS的双字节编码方式(见 UTF-16)
10 UCS4 #UCS的四字节编码方式
11 UTF #Unicode或者UCS的转换格式
12 UTF-8 #八位UTF转换格式(无符号字节序列，长度为1~4个字节)
13 UTF-16 #16位UTF转换格式(无符号字节序列，通常是16位长[两个字节]，见 UCS2)
8.2 什么是Unicode
ASCII字符只有1个字节，无法支持像汉语这种字符，因此使用Unicode字符，它使用1个或多个字节，可表示90,000+字符。
8.3 怎么用Unicode
Python中字符串已经不再是个类型，而是对象。ASCII字符串是StringType，Unicode字符串是UnicodeType。
以上两种的行为是非常相近的。string模块里面都有相应的处理函数，string模块已经停止了更新，只保留了ASCII 码的支持，string模块已经不推荐使用。在任何需要跟Unicode兼容的代码里都不要再用该模块，保留该模块仅仅是为了向后兼容。
str()和chr()处理Unicode字符串时会先转换成ASCII字符串，超出范围则报错；unicode()和unichr()则是Unicode版本的str()和chr()。
8.4 Codecs是什么
codec是COder/DECoder的首字母组合，它定义了文本跟二进制值的转换方式。Unicode用的是多字节，所以它支持多种不同的编码方式，比如说codec支持的四种耳熟能详的编码方式是：ASCII，ISO8859-1/Latin-1，UTF-8和UTF-16。
其中最著名的是UTF-8编码，它也用一个字节来编码ASCII 字符，跟ASCII编码完全相同。UTF-8编码用1~4个字节来表示其他语言的字符，汉语一般都是用3个字节来表示。Python替我们完成了相关细节，我们无须为处理多字节字符的复杂问题而担心。
UTF-16以后可能会常用。它容易读写，因为所有字符都是用2B来存储，而这两个字节的顺序需要定义一下（大小端的问题），一般的UTF-16编码文件都需要一个BOM(Byte Order Mark)，或者显式地定义UTF-16-LE（小端）或者 UTF-16-BE（大端）字节序。
8.5 编码解码
Unicode支持多种编码格式，写文件时必须定义一个编码(encoding参数)用于把对应的Unicode内容转换成定义的格式。
Unicode字符串的encode()用于编码，该函数接受字符串中的字符为参数，输出指定的编码格式的内容。
#!/usr/bin/env python
'''
An example of reading and writing Unicode strings:
Writes a Unicode string to a file in utf-8 and reads it back in.
'''
CODEC = 'utf-8'
FILE = 'unicode.txt'
hello_out = u"Hello world\n"
bytes_out = hello_out.encode(CODEC) #编码
f = open(FILE, "w")
f.write(bytes_out) #将编码的内容写入文件
f.close()
f = open(FILE, "r")
bytes_in = f.read() #读文件
f.close()
hello_in = bytes_in.decode(CODEC) #解码
print hello_in, #输出，去掉print的换行符（即逗号的作用）
$ python pytest.py #执行
Hello world
$ cat unicode.txt #显示生成的文件内容
Hello world
8.6 Unicode应用到实际应用中
以下经验可以避免很多错误：
- 程序中出现字符串时一定要加个前缀u。
- 不要用str()函数，用unicode()代替。
- 不要用过时的string模块——如果传给它的是非ASCII字符，它会把一切搞砸。
- 尽量不在程序里面编解码Unicod字符，只在写入文件/数据库/网络时才调用encode()函数；只在读数据时才调用decode()函数。
8.7 Python的Unicode支持
内建的unicode()、encode()、decode()函数，接受一个字符串为参数，分别返回一个unicode对象、编码/解码后的字符串。
类型：Unicode类型是basestring的子类，用unicode()工厂函数/字符串前加u来创建实例。
序数：ord()接受一个unicode字符，返回其码值；unichr()接受一个码值，返回一个Unicode字符。
转换：普通字符串和Unicode字符串运算，会将普通串强制转换为Unicode串。
异常：所有关于Unicode编解码的异常都继承自UnicodeError，这是exceptions模块中ValueError的子类。
RE：正则表达式引擎需要Unicode支持。
格式化操作：如果格式化字符串是Unicode对象（比如u"%s"），或输出中包含Unicode串，则执行转换 数字->普通字符串->Unicode字符串。
>>> '%s' % 'abc'
'abc'
>>> u'%s' % 'abc' #格式化字符串是Unicode对象
u'abc'
>>> '%s' % u'abc' #输出是Unicode对象
u'abc'
>>> '%s-%s' % (u'abc', 12) #数字->字符串->Unicode串
u'abc-12'
常用Unicode编码：
1 utf-8 #变量长度为8的编码(默认编码)
2 utf-16 #变量长度为16的编码(大/小端)
3 utf-16-le #小端UTF-16编码
4 utf-16-be #大端UTF-16编码
5 ascii #7位ASCII码表
6 iso-8859-1 #ISO8859-1(Latin-1)码表
7 unicode-escape #(定义见Python Unicode构造函数)
8 raw-unicode-escape #(定义见Python Unicode构造函数)
9 native #Python用的内部格式
9 相关模块
1 string #字符串操作相关函数和工具，比如Template类
2 re #正则表达式：强大的字符串模式匹配模块
3 struct #字符串和二进制之间的转换
4 c/StringIO #字符串缓冲对象，操作方法类似于file对象
5 base64 #Base 16,32,64数据编解码
6 codecs #解码器注册和基类
7 crypt #进行单方面加密
8 difflib #找出序列间的不同
9 hashlib #多种不同安全哈希算法和信息摘要算法的API
10 hma #HMAC信息鉴权算法的Python实现
11 md5 #RSA的MD5信息摘要鉴权
12 rotor #提供多平台的加解密服务
13 sha #NIAT的安全哈希算法SHA
14 stringprep #提供用于IP协议的Unicode字符串
15 textwrap #文本打包和填充
16 unicodedata #Unicode数据库
正则表达式的用处自不必说，第15会做详细介绍。re模块中重要的函数有：
- compile() - 将一个RE表达式编译成一个可重用的RE对象
- match() - 试图从字符串的开始匹配一个模式
- search() - 找出字符串中所有匹配的项
- sub() - 进行查找替换操作。其中的一些函数返回匹配到的对象，可以通过组匹配来访问（如果找到的话）。
10 字符串关键点总结
- 单/双引号包围
- 不可变类型
- 格式化操作符%
- 三引号
- 取消转义
- NUL或'\0'不是结束符
