【Python学习笔记】三、序列（Sequence）
3.1序列简介
• 数据结构是通过某种方式组织在一起的元素的集合。
• 容器（Container）是一种Python的数据结构，基本上是包含其他对象的任意对象。序列和映射（如字典）是两类主要的容器。集合（Set）也是容器类型。
• 序列是最基本的数据结构，是通过对数据元素进行编号将它们组织在一起的数据元素的集合。
• Python有6中种内建的序列：列表、元组、字符串、Unicode字符串、buffer对象、xrange对象。
3.2 通用序列操作
（1）索引（Indexing）
• 序列中的每个元素被分配一个序号，即元素的位置，称为索引。以正数第一个元素的索引为0，正数第二个元素的索引为1，倒数第一个元素的索引为-1，以此类推。
（2）分片（Slicing）
• 分片使用2个冒号分隔的3个数字来完成：[srart:end:step]
• 第一个数字表示切片开始位置（默认为0），第二个数字表示切片截止（但不包含）位置（默认为列表长度），第三个数字表示切片的步长（默认为1）
• 可以使用切片来截取列表中的任何部分，得到一个新列表，也可以通过切片来修改和删除列表中部分元素，甚至可以通过切片操作为列表对象增加元素。
• 与使用下标访问列表元素的方法不同，切片操作不会因为下标越界而抛出异常，而是简单地在列表尾部截断或者返回一个空列表，代码具有更强的健壮性。
• step为正时，Python会从序列头部开始向右提取元素，直到最后一个元素， start索引的元素应在end索引的元素左边，否则将返回一个空序列；step为负时， Python会从序列尾部开始向左提取元素，直到第一个元素，这时start索引的元素应在end索引的元素右边，否则将返回一个空序列。step不能为0。
• 当step省略时可以省略最后一个冒号或置空最后一个索引
[start:end]或[start:end:]
• 当start或end省略时要置空对应索引
[start:]或[:end]或[:]
•切片可以返回列表的浅拷贝a[:]==a
• a[:]将得到包含a所有元素的分片，是一种很有效率的复制整个列表的方法
•
（3）加（Adding）
• 序列连接操作，只有相同类型的序列才能进行连接操作
• 实质上是创建了一个新序列并将原序列中的元素和新元素依次复制到新序列的内存空间
（4）乘（Multiplying）
• 序列重复操作，用数字x乘以一个序列会产生新的序列，新的序列是原序列的重复
（5）成员资格
• 使用in运算符（布尔运算符）检查一个元素是否在序列中，返回布尔值True或False
>>> 2 in [2,3,4]
True
>>> [2] in [2,3,4]
False
>>>‘P’in ‘PYTHON’
True
（6）内建函数
• len()：返回序列中的元素个数
• max()、 min()：返回序列中的最大或最小元素
（7）迭代（iteration）
（8）赋值、浅拷贝与深拷贝
①直接赋值：其实就是对象的引用（别名）。
b = a: 赋值引用，a 和 b 都指向同一个对象。
②浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。
b =a.copy(): 浅拷贝, a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象（是引用）。
如果原地修改子对象，父对象也会改变。
③深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。
b = copy.deepcopy(a): 深度拷贝, a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。
3.2列表（List）
• 列表是Python中内置可变序列，是若干元素的有序集合。类似C语言中的链表。列表中的每一个数据称为元素，列表的所有元素放在一对中括号[ 和 ] 中，并使用逗号分隔开。
• 当列表元素增加或删除时，列表对象自动进行扩展或收缩内存，保证元素之间没有缝隙。尽量从列表尾部进行列表元素的增加与删除操作。
• 在Python中，一个列表中的数据类型可以各不相同，可以同时分别为整数、实数、字符串等基本类型，甚至是列表、元组、字典、集合以及其他自定义类型的对象。
（1）列表的创建
①赋值创建
>>> my_list = ['a', 'b', 'mpilgrim', 'z', 'example']
②内置函数创建
• list()函数：将一个序列转化成列表
>>> my_list = list((1,2,3))
[1,2,3]
>>> my_list = list(‘hello’)
[‘h’, ‘e’, ‘l’, ‘l, ‘o]
• range()函数
>>>list(range([start,]stop[,step]))
• range()函数在3.x中返回一个range可迭代对象
（2）列表的操作
① “+”运算符
• 严格意义上来讲，这并不是真的为列表添加元素，而是创建一个新列表，并将原列表中的元素和新元素依次复制到新列表的内存空间。由于涉及大量元素的复制，该操作速度较慢，在涉及大量元素添加时不建议使用该方法。
>>>a=[1]
>>>b=a
>>>a=a+[1]
>>>a
[1, 1]
>>>b
[1]
② *运算符
• 使用乘法来扩展列表对象，将列表与整数相乘，生成一个新列表，新列表是原列表中元素的重复。
>>>a=[1]
>>>b=a
>>>a=a*2
>>>a
[1, 1]
>>>b
[1]
• 需要注意的是，当使用* 运算符将包含列表的列表重复并创建新列表时，并不创建元素的复制，而是创建已有对象的引用。因此，当修改其中一个值时，相应的引用也会被修改
>>> x = [[None] * 2] * 3
>>> x
[[None, None], [None, None], [None, None]]
>>> x[0][0] = 5
>>> x
[[5, None], [5, None], [5, None]]
③ 基本赋值与分片赋值
• 基本赋值不能为一个不存在的元素进行赋值
• 分片赋值可以将一个分片（包括空的分片中的列表元素）替换成一个新的分片（序列）中的元素
• 可以通过分片赋值一次为多个元素赋值和插入新元素
>>>a=[1,2,3,4]
>>>a[2:]=[]
>>>a
[1,2]
>>>a[1:]=[1,2,3]或a[1:]=‘123’或a[1:]=(1,2,3)
>>>a
[1,1,2,3]
>>>a[1:1]=‘p’或a[1:1]=[‘p’]
>>>a
[1,‘p’,1,2,3]
>>>a[1:]=[‘python’]
[1,‘python’]
④ 删除元素
可以删除整个列表
• >>>del list
也可删除指定位置上的元素
• >>>del list[0]
（3）列表的方法
方法是一个与某些对象有紧密联系的函数
方法 |
说明 |
list.append(x) |
原位置，将元素x添加至列表尾部，“入栈” |
list.extend(L) |
将列表L中所有元素添加至列表尾部 |
list.insert(index, x) |
在列表指定位置index处添加元素x |
list.remove(x) |
移除列表中某个值的首个匹配项 |
list.pop([index]) |
删除并返回列表对象指定位置的元素，“出栈” |
list.clear() |
删除列表中所有元素，但保留列表对象，该方法在Python2中没有 |
list.index(x) |
使用列表对象的index()方法获取指定元素首次出现的下标。若列表对象中不存在指定元素，则抛出异常。 |
list.count(x) |
统计指定元素在列表对象中出现的次数 |
list.reverse() |
对列表元素进行原地逆序 |
list.sort() |
对列表元素进行原地排序 a.sort(reverse = True)相当于reverse |
list.copy() |
返回列表对象的浅拷贝，该方法在Python2中没有 |
① append()方法
使用列表对象的append()方法，
原地修改列表，是真正意义上的在列表尾部添加元素，速度较快
>>>a=[1]
>>>b=a
>>>a.append(1)
>>>a
[1, 1]
>>>b
[1, 1]
② extend()方法
使用列表对象的extend()方法可以将另一个迭代对象的所有元素添加至该列表对象的尾部。通过extend()方法来增加列表元素不改变其内存首地址，属于原地操作。
a.extend(b)相当于a[len(a):]=b
>>>a=[1]
>>>b=a
>>>a.extend([1])
>>>a
[1, 1]
>>>b
[1, 1]
注意：extend与append的区别
>>>x = [1, 2, 3]
>>>x.append([4, 5])
>>>x
[1, 2, 3, [4, 5]]
>>>x = [1, 2, 3]
>>>x.extend([4, 5])
>>>x
[1, 2, 3, 4, 5]
③ insert方法
• 应尽量从列表尾部进行元素的增加与删除操作
• 列表的insert()可以在列表的任意位置插入元素，但由于列表的自动内存管理功能，insert()方法会涉及到插入位置之后所有元素的移动，这会影响处理速度
• 类似的还有后面介绍的remove()方法以及使用pop()函数弹出列表非尾部元素和使用del命令删除列表非尾部元素的情况
• 可以用分片赋值实现同样效果
• >>>a.insert(position,data)
④ remove()方法
• 使用列表对象的remove()方法删除首次出现的指定元素，如果列表中不存在要删除的元素，则抛出异常。
•
• 注意：删除列表中指定元素的所有重复时不应该使用“循环+remove()”的方法
• 因为每当插入或删除一个元素之后，该元素位置后面所有元素的索引就都改变了，这时可能会发生索引出错的情况
⑤ pop()方法
• 实现一种常用数据结构——栈
• 用append作为入栈（pop）方法，pop作为出栈（push）方法
• 使用列表的pop()方法删除并返回指定（默认为最后一个）位置上的元素，如果给定的索引超出了列表的范围则抛出异常
⑥ sort()方法
在保留原列表的情况下得到一个已排序的列表副本
y=x[:]
y.sort()
或y=sorted(x)
⑦ copy()方法：深拷贝
•
3.3元组（Tuple）
• 元组是Python中内置不可变序列
（1）元组的创建
• 元组可以表示为一组用逗号分隔的值，可以通过圆括号括起来。相当于不可变的列表。
• 空元组:()
• 单值元组必须加一个逗号
(1,)或1，
• 使用tuple()将一个序列转换为元组
（2）元组的操作
• 元组支持切片操作，但只能通过切片来访问元组中的元素，而不能使用切片来修改元组中元素的值。
• 元组的速度比列表更快。如果定义了一系列常量值，而所需做的仅是对它进行遍历，那么一般使用元组而不用列表。
• 元组对不需要改变的数据进行“写保护”将使得代码更加安全。
• 一些元组可用作字典的键（特别是包含字符串、数值和其它元组这样的不可变数据的元组）。列表永远不能当做字典键使用，因为列表不是不可变的。
• 元组的不可变性只适用于元组本身顶层而并非其内容
•
• zip(列表1,列表2,…)将多个列表对应位置元素组合为元组列表（以最短列表的长度为准），并返回元组列表（Python2.x）/可迭代对象（Python3.x）
• zip(*元组列表)将实现逆操作
Python 3.x：
>>> zipList = zip([1, 2, 3], [4, 5, 6])
>>> zipList
>>> list(zipList)
[(1, 4), (2, 5), (3, 6)]
>>> unzipList=zip(*zipList)
>>> list(unzipList)
[[1, 2, 3], [4, 5, 6]]
（3）元组的方法
• 元组没有append()、extend()和insert()等方法，无法向元组中添加元素。
• 元组没有remove()或pop()方法，也无法对元组元素进行del操作，不能从元组中删除元素。
• 元组有index()和count()方法
•
3.4字符串（String）
• String属于Python不可变序列
• Python字符串驻留机制：对于短字符串，将其赋值给多个不同的对象时，内存中只有一个副本，多个对象共享该副本。长字符串不遵守驻留机制。
• Python不支持单字符类型，单字符也在Python也是作为一个字符串使用
（1）字符串的创建
• Python中单引号、双引号、三单引号、三双引号使用完全相同，可以互相嵌套
• 三引号可以将复杂的字符串进行复制，允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
cursor.execute('''
CREATE TABLE users (
login VARCHAR(8),
uid INTEGER,
prid INTEGER)
''')
• 三引号还可以在程序中表示较长的注释
• 若字符串包含某种引号，则不能用该引号来界定字符串，否则需要使用反斜杠“\”对字符串中的引号进行转义
‘Let\’s say “Hello,world!”’
‘‘‘Let’s say“Hello,world!”’’’
• 字符串的级联：书写含有单引号和双引号的字符串时，可以采用一个紧接另一个的方式写两个字符串
“Let’s say”‘“Helloworld!”’
（2）转义字符
转义字符 |
描述 |
\(在行尾时) |
续行符 |
\\ |
反斜杠符号 |
\' |
单引号 |
\" |
双引号 |
\a |
响铃 |
\b |
退格(Backspace) |
\e |
转义 |
\000 |
空 |
\n |
换行 |
\v |
纵向制表符 |
\t |
横向制表符 |
\r |
回车 |
\f |
换页 |
\oyy |
八进制数，yy代表的字符，例如：\o12代表换行 |
\xyy |
十六进制数，yy代表的字符，例如：\x0a代表换行 |
\other |
其它的字符以普通格式输出 |
（3）字符串的操作
操作符 |
描述 |
实例 |
+ |
字符串连接 |
>>>a + b'HelloPython' |
* |
重复输出字符串 |
>>>a * 2'HelloHello' |
[] |
通过索引获取字符串中字符 |
>>>a[1]'e' |
[ : ] |
截取字符串中的一部分 |
>>>a[1:4]'ell' |
in |
成员运算符 - 如果字符串中包含给定的字符返回 True |
>>>"H"inaTrue |
not in |
成员运算符 - 如果字符串中不包含给定的字符返回 True |
>>>"M"notinaTrue |
r/R |
原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 |
>>>printr'\n' \n >>> printR'\n' \n |
% |
格式字符串 |
|
len(str) |
返回字符串长度 |
|
max(str) |
返回字符串 str 中最大的字母。 |
|
min(str) |
返回字符串 str 中最小的字母。 |
|
（4）字符串的格式化
格式转换说明符包含以下部分：%+辅助命令+格式化符号
①辅助指令（可选）
符号 |
功能 |
- |
用做左对齐 |
+ |
在正数前面显示加号( + ) |
在正数前面显示空格 |
|
# |
在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X') |
0 |
显示的数字前面填充'0'而不是默认的空格 |
% |
'%%'输出一个单一的'%' |
(var) |
映射变量(字典参数) |
m.n |
（1）m:最小字符宽度（可选）: 如果达到字符宽度，数字和字符串将正常显示；若未达到字符宽度，字段宽度不足处将默认有空白字符填充 （2）.n:点精度值（可选）:如果转换的是实数，精度值就表示出现在小数点后的位数；如果转换的是字符串，那么该数字表示最大字段宽度。
|
* |
如果m或n的值是*，将会从元组中读出m或n的值 （定义宽度或者小数点精度） |
②格式化符号
格式字符 |
说明 |
%s |
字符串 (采用str()的显示) |
%c |
单个字符 |
%o |
八进制整数 |
%d |
十进制整数 |
%i |
十进制整数 |
%x |
十六进制整数 |
%X |
十六进制整数（大写） |
%e |
指数 (基底写为e) |
%E |
指数 (基底写为E) |
%f、%F |
浮点数 |
%g |
指数(e)或浮点数 (根据显示长度) |
%G |
指数(E)或浮点数 (根据显示长度) |
%% |
字符"%""%" |
注：十进制没有对应的格式字符，用format格式化函数格式输出。
（5）format格式化函数
• Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。基本语法是通过 {} 和 : 来代替以前的 % 。
• format 函数可以接受不限个参数，位置可以不按顺序。
• ^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
• + 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格
• b、d、o、x 分别是二进制、十进制、八进制、十六进制。
• 此外我们可以使用大括号 {} 来转义大括号
数字 |
格式 |
输出 |
描述 |
3.1415926 |
{:.2f} |
3.14 |
保留小数点后两位 |
3.1415926 |
{:+.2f} |
+3.14 |
带符号保留小数点后两位 |
-1 |
{:+.2f} |
-1.00 |
带符号保留小数点后两位 |
2.71828 |
{:.0f} |
3 |
不带小数 |
5 |
{:0>2d} |
05 |
数字补零 (填充左边, 宽度为2) |
5 |
{:x<4d} |
5xxx |
数字补x (填充右边, 宽度为4) |
10 |
{:x<4d} |
10xx |
数字补x (填充右边, 宽度为4) |
1000000 |
{:,} |
1,000,000 |
以逗号分隔的数字格式 |
0.25 |
{:.2%} |
25.00% |
百分比格式 |
1000000000 |
{:.2e} |
1.00e+09 |
指数记法 |
13 |
{:10d} |
13 |
右对齐 (默认, 宽度为10) |
13 |
{:<10d} |
13 |
左对齐 (宽度为10) |
13 |
{:^10d} |
13 |
中间对齐 (宽度为10) |
11 |
'{:b}'.format(11) '{:d}'.format(11) '{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11) |
1011 11 13 b 0xb 0XB |
进制 |
（6）Unicode与UTF
• 从通信的角度理解，Unicode是信源编码，是对字符集数字化;UTF-8是信道编码，为更好的存储和传输。
• UTF-8以字节为单位对Unicode进行编码，特点是对不同范围的字符使用不同长度的编码。
Python 2.x与Python 3.x在支持Unicode方面的异同
• Python 2.7中，字符串分为str和Unicode两种，str表示8位文本（8-bit string）和二进制数据；Unicode表示Unicode文本。加前缀u或U，如 u"this is an unicode string"即为Unicode字符串。默认编码为ASCII。basestring是str和unicode的超类，也是抽象类，因此不能被调用和实例化，但可以被用来判断一个对象是否为str或者unicode的实例（Python3.5中没有basestring）。
•Python3.5中不再有Unicode类型，str类型支持Unicode，或者说Python3.5中的str类型就相当于Python2.7中的unicode类型，而多出一种bytes类型，在Python 3.5中， “bytes” 类型存储的是 byte 串。可以通过一个 b 前缀来声明 bytes。默认编码为UTF-8。
• 简单理解：
在 Python 2.7 中的 str（无前缀）在 Python 3.5 中叫做bytes（前缀b）
在 Python 2.7 中的 unicode（前缀u）在 Python 3.5 中叫做 str（无前缀）
•str编码成bytes，bytes解码成str
•
（7）字符串的方法
方法 |
描述 |
编解码方法 |
|
bytes.decode ([encoding ="utf-8", errors="strict"]) |
以指定的编码格式解码 bytes 对象, 返回解码后的字符串 Python3 中str没有 decode 方法，我们使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象 默认编码为 'utf-8' 参数 encoding -- 要使用的编码，如"UTF-8"。 errors -- 设置不同错误的处理方案。 默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。 >>>str = "菜鸟教程"; >>>str_utf8 = str.encode("UTF-8") >>>print("UTF-8 编码：", str_utf8) UTF-8编码： b'\xe8\x8f\x9c\xe9\xb8\x9f\xe6\x95\x99\xe7\xa8\x8b' >>>print("UTF-8 解码：", str_utf8.decode('UTF-8','strict')) UTF-8解码：菜鸟教程 |
encode ([encoding ='UTF8', errors='strict']) |
以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' 参数 encoding -- 要使用的编码，如: UTF-8。 errors -- 设置不同错误的处理方案。 |
查询方法 |
|
count (str, [beg=0, end=len(string)]) |
用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置 参数 sub -- 搜索的子字符串 start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。 end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。 |
find (str, beg=0 end=len(string)) |
检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内 如果包含返回开始的索引值，否则返回-1 参数 str -- 指定检索的字符串 beg -- 开始索引，默认为0。 end -- 结束索引，默认为字符串的长度。 |
rfind (str, beg=0,end=len(string)) |
从右边开始的find() |
index(str, beg=0, end=len(string)) |
index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg和 end范围，则检查是否包含在指定范围内 如果包含子字符串返回开始的索引值，否则抛出异常。 参数 str -- 指定检索的字符串 beg -- 开始索引，默认为0。 end -- 结束索引，默认为字符串的长度。 |
rindex( str, beg=0, end=len(string)) |
从右边开始的index() |
startswith (str, beg=0, end=len(string)) |
检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。 参数 str -- 检测的字符串。 strbeg -- 可选参数用于设置字符串检测的起始位置。strend -- 可选参数用于设置字符串检测的结束位置。 |
endswith (suffix, [beg=0, end=len(string)]) |
检查字符串是否以suffix结束，如果是，返回 True,否则返回 False.可选参数"start"与"end"为检索字符串的开始与结束位置。 参数 suffix -- 该参数可以是一个字符串或者是一个元素。 start -- 字符串中的开始位置。 end -- 字符中结束位置。 |
isalnum() |
如果字符串至少有一个字符并且所有字符都是字母或数字则返回True,否则返回 False |
isalpha() |
如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False |
isdigit() |
如果字符串至少有一个字符并且所有字符都是数字则返回 True, 否则返回 False |
isnumeric() |
如果Unicode字符串（str）中只包含数字字符，则返回 True，否则返回 False 数字字符包含的内容很广，包括罗马数字、汉字数字等 Bytes字符串会抛出AttributeError异常 |
isdecimal() |
如果Unicode字符串（str）中只包含十进制字符，则返回 True，否则返回 False |
islower() |
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
isupper() |
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
isspace() |
如果字符串中只包含空白，则返回 True，否则返回 False |
istitle() |
如果字符串中包含至少一个区分大小写的字符的单词，并且所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False. |
转换方法 |
|
lstrip([chars]) |
截掉字符串左边的空格或指定字符。 参数 chars --指定截取的字符。 |
rstrip() |
截掉字符串右边的空格或指定字符。 |
strip([chars]) |
在字符串上执行 lstrip()和 rstrip() |
capitalize() |
将字符串的第一个字符转换为大写 |
lower() |
转换字符串中所有大写字符为小写. |
upper() |
转换字符串中的小写字母为大写 |
swapcase() |
将字符串中大写转换为小写，小写转换为大写 |
title() |
返转换字符串中所有单词的首字母为大写，其余字母均为小写 |
expandtabs (tabsize=8) |
把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。 参数 tabsize -- 指定转换字符串中的 tab 符号('\t')转为空格的字符数。 |
replace (old , new [, max]) |
把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。 参数 old -- 将被替换的子字符串。 new -- 新字符串，用于替换old子字符串。 max -- 可选字符串, 替换不超过 max 次 |
maketrans(intab, outtab) |
• 创建字符映射的转换表 • 两个参数字符串的长度必须相同，为一一对应的关系 • 参数 • intab -- 字符串中要替代的字符组成的字符串。 outtab -- 相应的映射字符的字符串。 |
translate (table, [deletechars=""])
|
• 根据参数table给出的表(包含 256 个字符)转换字符串的字符,要过滤掉的字符放到 deletechars 参数中。 • 参数 • table -- 翻译表，翻译表是通过maketrans()方法转换而来。deletechars -- 字符串中要过滤的字符列表。 >>>intab ="aeiou" >>>outtab = "12345" >>>trantab = str.maketrans(intab, outtab) >>>str ="this is string example....wow!!!" >>>print (str.translate(trantab)) th3s 3s str3ng 2x1mpl2....w4w!!! |
构造方法 |
|
center (width[, fillchar]) |
返回一个指定的宽度 width 居中的字符串，如果 width 小于字符串宽度直接返回字符串，否则使用 fillchar 去填充。 参数 width -- 字符串的总宽度。 fillchar -- 填充字符。（默认为空格） >>>str = "python" >>>print ( str.center(10, '*')) **python** |
ljust (width[, fillchar]) |
返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。 |
rjust (width,[, fillchar]) |
返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串 |
zfill (width) |
返回长度为 width 的字符串，原字符串右对齐，前面填充0 参数 width -- 指定字符串的长度。原字符串右对齐，前面填充0。 |
分隔连接方法 |
|
str.join(seq) |
以指定字符串(str)作为分隔符，将seq中所有的元素(的字符串表示)合并为一个新的字符串 参数 sequence -- 要连接的元素序列。 应优先使用join方法而不是使用+来连接字符串 >>>s1 = "-" >>>s2 = "" >>>seq =("r","u","n","o","o","b")# 字符串序列 >>>print (s1.join( seq )) r-u-n-o-o-b >>>print (s2.join( seq )) runoob |
split (str="", num=string.count(str)) |
通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串 参数 str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。 num -- 分割次数。 join的逆方法 |
splitlines([keepends]) |
按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 参数 keepends -- 在输出结果里是否去掉换行符('\r', '\r\n', \n')，默认为 False，不包含换行符，如果为 True，则保留换行符。 |
•
（8）正则表达式
Python 2.x与Python 3.x在支持Unicode方面的异同
• python允许处理unicode字符串，加前缀u或U， 如 u"thisis an unicode string"。
• unicode是信源编码，对字符集数字化;utf8是信道编码，为更好的存储和传输。
• 不再有unicode类型
• str类型支持Unicode，或者说Python3.5中的str类型就相当于Python 2.7中的unicode类型
• Python 3.5的默认编码是UTF-8