零基础入门学Python系列内容的学习目录 → \rightarrow →零基础入门学Python系列内容汇总。
列表、元组和字符串（下）
需要学习的基础知识有：列表、元组、字符串、序列等。因本部分内容较多，故分为上下两个篇章。
1、2部分内容见零基础入门学Python（五）—— 列表、元组和字符串（上）
3、4部分内容见零基础入门学Python（五）—— 列表、元组和字符串（下）
前半部分内容见零基础入门学Python（五）—— 列表、元组和字符串（上）。
3. 字符串字符串跟元组一样，都是一旦定下来就不能直接对它们进行修改了。对于之前应用到列表和元组中的分片概念，也可以应用于字符串之上，对字符串进行间接修改。
example1:>>>str = “I am learning Python.”
>>>str[ : 4 ]
‘I am’
example2:>>>str = “I am learning Python.”
>>>str[ : 4 ] + “插入的字符串” + str[ 4 : ]
‘I am插入的字符串 learning Python.’
在C语言中，字符串和字符是两个不同的概念，字符用单引号' '表示，字符串用双引号" "表示。但在Python中并没有字符这个类型，对Python来说字符就是长度为1的字符串。当要访问字符串中的一个字符时，只需要用索引列表和元组的方法来索引字符串即可。
example3:>>>str = “I am learning Python.”
>>>str[ 6 ]
e
3.1 各种内置方法
Python有很多的字符串方法，表1总结了字符串所有方法及对应的含义。
| 方法 | 含义 |
|---|---|
| capitalize() | 把字符串的第一个字符改为大写 |
| casefold() | 把整个字符串的所有字符改为小写 |
| center(width) | 将字符串居中，并使用空格填充至长度width的新字符串 |
| count(sub[, start[, end]]) | 返回sub在字符串里边出现的次数，start和end参数表示范围，可选 |
| encode(encoding=‘utf-8’, errors=‘strict’) | 以encoding指定的编码格式对字符串进行编码 |
| endswith(sub[, start[, end]]) | 检查字符串是否以sub子字符串结束，如果是返回True，否则返回False，start和end参数表示范围，可选 |
| expandtabs([tabsize=8]) | 把字符串中的tab符号（\t）转换为空格，如不指定参数，默认的空格数是tabsize=8 |
| find(sub[, start[, end]]) | 检测sub是否包含在字符串中，如果有则返回索引值，否则返回-1，start和end参数表示范围，可选 |
| index(sub[, start[, end]]) | 跟find方法一样，不过如果sub不在string中会产生一个异常 |
| isalnum() | 如果字符串至少有一个字符并且所有字符都是字母或数字则返回True,否则返回False |
| isalpha() | 如果字符串至少有一个字符并且所有字符都是字母则返回True,否则返回False |
| isdecimal() | 如果字符串只包含十进制数字则返回True，否则返回False |
| isdigit() | 如果字符串只包含数字则返回True，否则返回False |
| islower() | 如果字符串中至少包含一个区分大小写的字符，并且这些字符都是小写，则返回True，否则返回False |
| isnumeric() | 如果字符串中只包含数字字符，则返回True，否则返回False |
| isspace() | 如果字符串中只包含空格，则返回True，否则返回False |
| istitle() | 如果字符串是标题化（所有的单词都是以大写开始，其余字母均小与），则返回True，否则返回False |
| isupper() | 如果字符串中至少包含一个区分大小写的字符，并且这些字符都是大写，则返回True，否则返回False |
| join(sub) | 以字符串作为分隔符，插入到sub中所有的字符之间 |
| ljust(width) | 返回一个左对齐的字符串，并使用空格填充至长度为width的新字符串 |
| lower() | 转换字符串中所有大写字符为小写 |
| lstrip() | 去掉字符串左边的所有空格 |
| partition(sub) | 找到子字符串sub，把字符串分成一个3元组(pre_sub,sub,fol_sub)，如果字符串中不包含sub则返回(’原字符串’，’ ‘，’ '） |
| replace(old, new[, count]) | 把字符串中的old子字符串替换成new子字符串，如果count指定，则替换不超过count次 |
| rfind(sub[, start[, end]]) | 类似于find()方法，不过是从右边开始查找 |
| rindex(sub[, start[, end]]) | 类似于index()方法，不过是从右边开始查找 |
| rjust(width) | 返回一个右对齐的字符串，并使用空格填充至长度为width的新字符串 |
| rpartition(sub) | 类似于partition()方法，不过是从右边开始查找 |
| rstrip() | 删除字符串末尾的空格 |
| split(sep=None,maxsplit=-1) | 不带参数默认是以空格为分隔符切片字符串，如果maxsplit参数有设置，则仅分隔maxsplit个子字符串，返回切片后的子字符串拼接的列表 |
| splitlines(([keepends])) | 按照’\n’分隔，返回一个包含各行作为元素的列表，如果keepends参数指定，则返回前keepends行 |
| startswith(prefix[, start[, end]]) | 检查字符串是否以prefix开头，是则返回True，否则返回False,start和end参数可以指定范围检查，可选 |
| strip([chars]) | 删除字符串前边和后边所有的空格，chars参数可以定制删除的字符，可选 |
| swapcase() | 翻转字符串中的大小写 |
| title() | 返回标题化（所有的单词都是以大写开始，其余字母均小写)的字符串 |
| translate(table) | 根据table的规则（可以由str.maketrans(‘a’，‘b’）定制）转换字符串中的字符 |
| upper() | 转换字符串中的所有小写字符为大写 |
| zfill（ width) | 返回长度为width的字符串，原字符串右对齐，前边用0填充 |
3.2 格式化
格式化字符串，就是按照统一的规格去输出一个字符串。关于格式化字符串这部分内容的学习，推荐两篇文章：1、Python格式化字符串，这个方法你值得拥有！；2、安利三个关于Python字符串格式化的进阶知识。
3.2.1 format()
format()方法接受位置参数和关键字参数，二者均传递到一个叫做replacement的字段，这个replacement字段在字符串内由大括号{ }表示。
example1:>>>"{0} am {1} {2}".format(" I " , " learning " , " Python ")
‘I am learning Python’
example1中的{0}、{1}和{2}均跟位置有关，依次被format()的三个参数替换，那么format()的三个参数就叫作位置参数。
example2:>>>"{a} am {b} {c}".format(a = " I ",b = " learning ",c = " Python ")
‘I am learning Python’
example2中的{a}、{b}和{c}相当于三个标签，format()将参数中等值的字符串替换进去，这就是关键字参数。
我们可以将位置参数和关键字参数综合起来一起使用，但是位置参数必须在关键字参数之前，否则会报错。
example3:>>>"{0} am {b} {c}".format(" I ",b = " learning “,c = " Python “)
‘I am learning Python’
>>>”{a} am {b} {0}”.format(a = " I ",b = " learning ", " Python ")
SyntaxError: positional argument follows keyword argument
如果想要把大括号打印出来，跟字符串转义字符有点像，只是需要用多一层大括号括起来即可。
example4:>>>"{{0}}".format(" 不打印 ")
‘{0}’
example4中的位置参数“不打印”并没有被打印出来，这是因为{0}的特殊功能被外层的大括号{ }剥夺了，因此没有字段可以输出。
example5:>>>"{0}:{1:.2f}".format(" 圆周率",3.14159)
’ 圆周率:3.14’
example5中可以看到位置参数{1}跟之前不同，后边多了一个冒号。在替换域中，冒号表示格式化符号的开始，".2"的意思是四舍五入保留到两位小数点，而f的意思是浮点数。
3.2.2 格式化操作符：%
%：当%的左右均为数字的时候，那么它表示求余数的操作；但当它出现在字符中的时候，它表示的是格式化操作符。表2列举了Python的格式化符号及含义。
| 符号 | 含义 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数(大写) |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同 %e，用科学计数法格式化浮点数 |
| %g | 根据值的大小决定使用 %f 或 %e |
| %G | 作用同%g，根据值的大小决定使用 %f 或 %E |
example1:>>>’ % c ’ % 97
’ a ’
>>>’ % d 转换为八进制是 % o ’ % (123, 123)
’ 123 转换为八进制是 173 ’
>>>’% f 用科学计数法表示为：% e’ %(149500000, 149500000)
’ 149500000.000000 用科学计数法表示为： 1.495000e+08’
Python还提供了格式化操作符的辅助指令，如表3所示。
| 符号 | 含义 |
|---|---|
| m.n | m是显示的最小总宽度，n是小数点后的位数 |
| - | 结果左对齐 |
| + | 在正数前面显示加号 |
| # | 在八进制数前面显示’0o’，在十六进制数前面显示’0x’或’0X’ |
| 0 | 显示的数字前面填充’0’代替空格 |
example2:>>>’ % 5.2f ’ % 27.658
’ 27.66 ’
>>>’ % .2e ’ % 27.658
’ 2.77e+01 ’
>>>’ % 10d ’ % 5
’ 5 ’
>>>’% -10d ’ % 5
’ 5 ’
>>>’ % 010d ’ % 5
’ 000000005 ’
>>>’ % #X ’ % 100
’ 0X64 ’
3.2.3 Pyhton的转义字符及含义
Pyhton的转义字符及含义如表4所示。
| 符号 | 说明 |
|---|---|
| \ ’ | 单引号 |
| \ ‘’ | 双引号 |
| \ a | 发出系统响铃声 |
| \ b | 退格符 |
| \ n | 换行符 |
| \ t | 横向制表符（TAB） |
| \ v | 纵向制表符 |
| \ r | 回车符 |
| \ f | 换页符 |
| \ o | 八进制数代表的字符 |
| \ x | 十六进制数代表的字符 |
| \ 0 | 表示一个空字符 |
| \ \ | 反斜杠 |
通过之前的学习，我们可以发现列表、元组和字符串之间有很多共同点：
- 都可以通过索引得到每一个元素‘
- 默认索引值总是从0开始；
- 可以通过分片的方法得到一个范围内的元素的集合；
- 有很多共同的操作符（重复操作符、拼接操作符、成员关系操作符）
我们把它们统称为序列。
学习一下关于序列常用的BIF。
-
1. list([iterable])
list()方法用于把一个可迭代对象转换为列表。
example1:>>># 创建一个空列表
>>>a = list()
>>>a
[ ]
example2:>>># 将字符串的每个字符迭代存放到列表中
>>>b = list(“Python”)
>>>b
[‘P’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’]
example3:>>># 将元组中的每个元素迭代存放到列表中
>>>c = list((1, 1, 2, 3, 5, 8, 13))
>>>c
[1, 1, 2, 3, 5, 8, 13] -
2. tuple([iterable])
tuple()方法用于把一个可迭代对象转换为元组，具体用法和list一样。
example1:>>>a = tuple()
>>>a
()
example2:>>>b = tuple(“Python”)
>>>b
(‘P’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’)
example3:>>>c = tuple((1, 1, 2, 3, 5, 8, 13))
>>>c
(1, 1, 2, 3, 5, 8, 13) -
3. str(obj)
str()方法用于把obj对象转换为字符串。
example1:>>>a = 5.99
>>>b=str(a)
>>>b
‘5.99’ -
4. len(sub)
len()方法用于返回sub参数的长度。
example1:>>>str1 = “I am learning Python.”
>>>len(str1)
21
example2:>>>list1 = [1, 1, 2, 3, 5, 8, 13]
>>>len(list1)
7
example3:>>>tuple1 = “这”, “是”, “一”, “个”, “元组”
>>>len(tuple1)
5 -
5. max(…)
max()方法用于返回序列或者参数集合中的最大值。max()参数可以是一个序列，返回值是该序列中的最大值；也可以是多个参数，返回值是这些参数中最大的一个。
example1:>>>str1 = “I am learning Python.”
>>>max(str1)
‘y’
example2:>>>list1 = [1, 1, 2, 3, 5, 8, 13]
>>>max(list1)
13
example3:>>>tuple1 = (1, 1, 2, 3, 5, 8, 13)
>>>max(tuple1)
13 -
6. min(…)
min()方法用于返回序列或者参数集合中的最小值，跟max()效果相反。要注意的是，使用min()和max()方法都要保证序列或者参数的数据类型统一，否则会出错。
example1:>>>list1 = [1, 1, 2, 3, 5, 8, 13]
>>>list1.append(“x”)
>>>max(list1)
Traceback (most recent call last):
File “<pyshell#20>”, line 1, in < module>
max(list1)
TypeError: ‘>’ not supported between instances of ‘str’ and ‘int’ -
7. sum(iterable[, start])
sum()方法用于返回序列iterable的总和，用法跟max()和min()一样。但是sum()方法有一个可选参数(start)，如果设置该参数，表示从该值开始加起，默认值是0。
example1:>>>tuple1 = 1, 2, 3, 4, 5
>>>sum(tuple1)
15
>>>sum(tuple1, 10)
25 -
8. sorted(iterable, key = None, reverse = False)
sorted()方法用于返回一个排序的列表。它跟列表的内建方法sort()效果一样，但是列表的内建方法sort()是实现列表原地排序；而sorted()是返回一个排序后的新列表。
example1:>>>list1 = [1, 8, 13, 0, -98, 34, 54, 76, 32]
>>>list2 = list1[ : ]
>>>list1.sort()
>>>list1
[-98, 0, 1, 8, 13, 32, 34, 54, 76]
>>>sorted(list2)
[-98, 0, 1, 8, 13, 32, 34, 54, 76]
>>>list2
[1, 8, 13, 0, -98, 34, 54, 76, 32]
通过example1中的结果可以看出，list1用sort()排序后自身发生了变化，而list2用sorted()排序后自身没有发生变化，得到了一个新列表。 -
9. reversed(sequence)
reversed()方法用于返回逆向迭代序列的值。它跟列表的内建方法reverse()效果一样，但是列表的内建方法reverse()是原地翻转；而reversed()是返回一个翻转后的迭代器对象。
example1:>>>list1 = [1, 8, 13, 0, -98, 34, 54, 76, 32]
>>>reversed(list1)
<list_reverseiterator object at 0x0000021B4AE51A90>
>>>for each in reversed(list1):
print(each, end=’,’)
32,76,54,34,-98,0,13,8,1, -
10. enumerate(iterable)
enumerate()方法生成由二元组（二元组就是元素数量为二的元组）构成的一个迭代对象，每个二元组是由可迭代参数的索引号及其对应的元素组成的。
example1:>>>str1 =“Python”
>>>for each in enumerate(str1):
print(each)
(0, ‘P’)
(1, ‘y’)
(2, ‘t’)
(3, ‘h’)
(4, ‘o’)
(5, ‘n’) -
11. zip(iter1[, iter2[…]])
zip()方法用于返回由各个可迭代参数共同组成的元组。
example1:>>>list1 =[1, 3, 5, 7, 9, 11]
>>>str1 =“Python”
>>>for each in zip(list1,str1):
print(each)
(1, ‘P’)
(3, ‘y’)
(5, ‘t’)
(7, ‘h’)
(9, ‘o’)
(11, ‘n’)
example2:>>>list1 =[1, 3, 5, 7, 9, 11]
>>>tuple1 =(2, 4, 6, 8, 10, 12)
>>>str1 =“Python”
>>>for each in zip(list1,str1,tuple1):
print(each)
(1, ‘P’, 2)
(3, ‘y’, 4)
(5, ‘t’, 6)
(7, ‘h’, 8)
(9, ‘o’, 10)
(11, ‘n’, 12)