Python数据结构：字符串（string）_python的instr

数据类型：字符串（string）

​ 在 Python 中处理文本数据使用 str 对象，也称为字符串。 字符串是由 Unicode 码位构成的不可变序列。

1.字符串的定义

​ 字符串是主要用于表示文本数据的不可变的序列，不可变的意思是说字符串一旦被创建完成以后就不能对其中的元素进行添加、删除、修改，序列的意思谁说字符串中的字符都拥有自己的数字位置顺序，可以通过这个数字位置编号来获取各元素，即索引、切片操作。

2.字符串的创建

​ 字符串创建主要可以分为使用符号创建和使用函数创建两种方法。

1.使用符号创建字符串有多种不同的写法：

• 单引号: ‘abc’、‘123’、‘ab12’
• 双引号: “abc”、“123”、“ab12”
• 三重引号: ‘’‘三重单引号’’’, “”“三重双引号”""

其中单引号和双引号可以相互区别，以满足日常英语和中文输入的需求，示例如下：

>>> str01 = '我说:"今天的菜真好吃"。' # 满足中文中带双引号的语法
>>> print(str01)
我说:"今天的菜真好吃"。
    
>>> str02 = "I'm very happy today" # 满足英文中带引号的语法
>>> print(str02)
I'm very happy today

>>> str03 = 'I'm very happy today' # 会报错，语法错误，无效的语法
>>> print(str03)
File "test.py", line 2 # 错误所在的文件和行数
    str02 = 'I'm very happy today' # 错误的具体位置
               ^
SyntaxError: invalid syntax # 错误类型，和对错误的说明
1
2
3
4
5
6
7
8
9
10
11
12
13
14

​ 上例中，str01的内容中使用了双引号，str02的内容中使用了一个单引号，这些是语言中语法要求必须有的。为了区别字符串内容中的双引号，在定义字符串str01时使用了单引号来区别其中的内容，这样Python程序不会报语法错误。同理，定义str02时，为了满足英语语法要求"I’m"使用了一个单引号，定义整个字符串时使用了一个双引号，这样可以和str02内容中的单引号区别，也不会报错。但是在str03中，都是用了单引号，Python程序只能识别出’I’前后的单引号，后面的单引号成为了一个单独的，程序无法识别，因此语法错误。"SyntaxError："是错误类型–语法错误，"invalid syntax"是错误的具体说明，无效的语法。在程序设计中会有很多时候遇到代码报错，因为需要对报错类型和报错说明有明确的认识，只有对报错了解，才能更好的解决出现的错误。

​ 三重单引号和三重双引号的用法和单引号、双引号的稍有差别，接下来通过示例来说明这两种符号创建字符串的使用，示例如下：

>>> str04 = '''
	Python语言
	是目前最流行的一门编程语言
	深受程序员的喜爱
	它语法简单易学	
	'''
>>> print(str04) # 注意观察打印输出的格式
	Python语言
	是目前最流行的一门编程语言
	深受程序员的喜爱
	它语法简单易学	
1
2
3
4
5
6
7
8
9
10
11

​ 三重单引号和三重双引号在没有为变量赋值的时候属于多行注释，在此例中通过赋值号"="为变量str04赋值，打印出的str04格式和创建时的格式相同，输出了一个占用多个物理行的字符串，使用三重双引号创建的字符串同上。

2.使用str()函数，该函数可以把其他类型的数据转换为字符串类型，示例如下：

>>> num01 = 100.0
>>> str05 = str(num01) # 使用str()函数将浮点型转为字符串类型
>>> print(str05)
100.0
>>> print(type(str05)) # 使用type()函数测试变量str05的类型
<class 'str'>
1
2
3
4
5
6

​ str()函数一般用来将其他类型转为字符串类型，使用print()函数打印出的字符串没有显示引号，但是需要注意类型，不能只通过输出的格式判断变量类型。

3.字符串的索引

​ 在字符串的定义中解释了序列的含义，字符串中的每个元素都拥有自己的数字位置，这个数字位置就是索引，也可以叫作下标。可以通过索引从字符串中获取元素，索引的语法如下：

变量名[索引值]
1

索引具有方向性：

• 从左往右，以0为开始值，字符串的长度-1为结束值；
• 从右往左，以-1为开始值，-字符串的长度为结束值；

如图所示：

图展示了分别从两个方向：正向（从左到右），反向（从右到左）每个位置元素的索引值。使用索引从字符串中获取元素的代码示例如下：

>>> str01 = 'PYTHON'
>>> print(str01[0]) # 取第0个位置的元素，索引一次只能取一个元素
P
>>> print(str01[3]) # 取第3个位置的元素
H
>>> print(str01[-1]) # 取第-1个位置的元素
N
>>> print(str01[-4]) # 取第-4个位置的元素
T
>>> print(str01[6]) # 索引超出范围是会报错
Traceback (most recent call last):
  File "test.py", line 2, in <module>
    print(str01[6])
IndexError: string index out of range
1
2
3
4
5
6
7
8
9
10
11
12
13
14

使用索引获取元素时需要注意索引超限的问题，如果输入的索引值超出字符串本身的长度，就会触发索引超限的错误，这是一个比较常见的错误。

注意：可以使用内建函数len()输出字符串的长度。

4. 字符串的切片

​ 字符串切片也叫分片，由于使用索引获取元素的值一次只能获取一个，如果需要有规律的获取多个元素就需要用到切片。切片的语法如下：

变量名[开始值:结束值:步长]
1

​ 切片是一个左闭右开的区间，即开始值位置的元素是可以被获取到的，结束值位置的元素不能被获取，只能获取到结束值-1位置的元素。开始值默认为0，步长默认为1。示例代码如下：

>>> str01 = 'PYTHON现在是最受欢迎的编程语言'
>>> print(str01[0:6]) # 结束值获取不到，只能取到结束值的前一位，步长默认为1
PYTHON
>>> print(str01[:6]) # 开始值默认是0，切片生成一个新的字符串
PYTHON
>>> print(str01[:]) # 开始值、结束值和步长都为空时，默认全部获取
PYTHON现在是最受欢迎的编程语言
>>> print(str01[::2]) # 步长为2
PTO现是受迎编语
>>> print(str01[-1:-3:-1]) # 反方向切片时需要注意步长的值
言语
>>> print(str01[-1:-3]) # 返回空行，开始值、结束值与步长发生矛盾

1
2
3
4
5
6
7
8
9
10
11
12
13

5. 字符串的循环遍历

​ 字符串是有序的字符集合，是可迭代对象，可以使用for循环对字符串进行循环遍历。可迭代是指可以依次把元素从头到尾取出来使用，字符串是可迭代的，数值型是不可迭代的。可迭代对象可以使用for循环遍历其中的元素，列表、元组、字典、集合都属于可迭代对象。

​ for循环语句可以实现循环遍历，示例如下：

>>> str01 = 'PYTHON'
>>> for item in str01: # 变量item依次接收str01中的元素打印
>>> 	print(item)
P
Y
T
H
O
N
1
2
3
4
5
6
7
8
9

6. 字符串的格式化

​ 字符串具有一种特殊的内置操作：使用 % (取模) 运算符。 也被称为字符串的格式化或插值运算符。对于 format % values (其中 format为一个格式字符串)，在 format中的 %转换标记符将被替换为零个或多个values值。 其效果类似于在 C 语言中使用 sprintf()。如果 format要求一个单独参数，则 values可以为一个非元组对象。 否则的话，values必须是一个元组，或者是一个单独映射对象（如字典）。基本语法如下：

格式字符串 % (参数1, 参数2...)
格式字符串 % {键1: 值1, 键2: 值2}
1
2

示例如下:

>>> print('%s说:"我今年%d岁，读%s年级了。"' % ('小明', 10, '三'))
小明说:"我今年10岁，读三年级了。"
    
>>> print('%(language)s has %(number)03d quote types' % {'language': "Python", "number": 2})
Python has 002 quote types
1
2
3
4
5

转换标记符包含两个或更多字符并具有以下组成，且必须遵循此处规定的顺序：

1. '%'字符，用于标记转换符的起始。
2. 映射键（可选），由加圆括号的字符序列组成 (如: (language)，(number))。
3. 转换旗标（可选），用于影响某些转换类型的结果（如：s，d）。
4. 最小字段宽度（可选），（如:03）。
5. 精度（可选），以在 ‘.’ (点号) 之后加精度值的形式给出。
6. 长度修饰符（可选）。
7. 转换类型。

当右边的参数为一个字典（或其他映射类型）时，字符串中的格式必须包含加圆括号的映射键，对应 '%'字符之后字典中的每一项。 映射键将从映射中选取要格式化的值。

Python的转换标记符如表所示：

​ Python的字符串还提供了.format()函数可以实现字符串格式化的效果，语法如下：

str.format(*args, **kwargs)
1

​ 调用此方法的字符串可以包含字符串字面值或者以大括号 {} 括起来的替换域。 每个替换域可以包含一个位置参数的数字索引，或者一个关键字参数的名称。 返回的字符串副本中每个替换域都会被替换为对应参数的字符串值。示例如下：

>>> print('{}说：“我今年{}岁了，读{}年级。”'.format('小明', 10, '三'))
小明说：“我今年10岁了，读三年级。”
1
2

7. 字符串的运算符

算术运算中的’+’、’*'运算符也可以运用到字符串类型中，但是代表的含义和在数值运算中的完全不同。除此以外，还有其他字符串运算符，如表所示：

示例如下：

# '+'运算符，实现字符串拼接
>>> str01 = 'Python'
>>> str02 = '最受欢迎的编程语言'
>>> print(str01 + str02)
Python最受欢迎的编程语言
1
2
3
4
5

# '*'运算符，实现字符串重复
>>> str01 = '学好Python'
>>> print(str01 * 3)
学好Python学好Python学好Python
1
2
3
4

# 成员运算符
>>> str01 = 'Python'
>>> print('y' in str01) # 判断字符串str01中是否包含'y',返回True表示包含
True
>>> str01 = 'Python'
>>> print('a' not in str01) # 判断字符串str01中是否包含'a',返回False表示不包含
False
1
2
3
4
5
6
7

# 身份运算符
>>> str01 = '好好学习'
>>> str02 = str01 # 将str01的引用对象赋值给str02
>>> print(str01 is str02) # is判断两个字符串是否引用同一个对象，返回True
True
>>> print(id(str01)) # 使用id()函数返回str01和str02引用对象的内存地址
>>> print(id(str02)) # 两者引用对象的内存地址相同，表名两个变量引用了同一个对象
2626944341456
2626944341456
1
2
3
4
5
6
7
8
9

8. 字符串的函数

常用的字符串处理函数包括repr()、ord()和chr()等。

1.repr()

​ 除了使用str()函数转换字符串外，还可以使用repr()函数转换字符串。转换数值型时这两个函数的效果相同。但在处理字符串时，repr()会为转换后的字符串添加单引号，示例代码如下：

# 转换数值型
>>> print(str(100))
100
>>> print(repr(100))
100
1
2
3
4
5

# 转换字符串
>>> print(str('100'))
100
>>> print(repr("100"))
'100'
1
2
3
4
5

2.ord()

​ ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值。示例如下：

>>> print(ord('A'))
65
>>> print(ord('程'))
31243
1
2
3
4

3.chr()

chr()函数返回Unicode码对应的字符，示例如下：

>>> print(chr(65))
A
>>> print(chr(31243))
程
1
2
3
4

9.字符串类方法

字符串实现了所有一般序列的操作，除此以外，字符串类还提供了一系列处理字符串的方法，如下所示：

1.capitalize()

返回原字符串的副本，其首个字符大写，其余为小写。

>>> str01 = 'python is the most popular programming language'
>>> print(str01.capitalize())
Python is the most popular programming language
1
2
3

2.casefold()

返回原字符串消除大小写的副本。 消除大小写的字符串可用于忽略大小写的匹配。

>>> str01 = 'Python Is The mOst popUlar proGramming lAnguage'
>>> print(str01.casefold())
python is the most popular programming language
1
2
3

3.center(width[, fillchar])

返回长度为 width 的字符串，原字符串在其正中。 使用指定的 fillchar 填充两边的空位（默认使用 ASCII 空格符）。 如果 width 小于等于 len(s) 则返回原字符串的副本。

>>> str01 = 'Python'
>>> print(str01.center(10, '*'))
**Python**
1
2
3

4.count(sub[, start[, end]])

返回子字符串 sub 在 [start, end] 范围内非重叠出现的次数。

>>> str01 = 'python is the most popular programming language'
>>> print(str01.count('o'))
4
>>> str01 = 'python is the most popular programming language'
>>> print(str01.count('o', 0, 6)) # 限定范围(0, 6)
1
1
2
3
4
5
6

5.encode(encoding=“utf-8”, errors=“strict”)

以指定的编码格式编码字符串。errors参数可以指定不同的错误处理方案，errors 的默认值为 'strict'，表示编码错误会引发 UnicodeError。 其他可用的值为 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及任何其他通过codecs.register_error() 注册的值。

>>> str01 = '好好学习python'
>>> print(str01.encode())
b'\xe5\xa5\xbd\xe5\xa5\xbd\xe5\xad\xa6\xe4\xb9\xa0python'
1
2
3

6.endswith(suffix[, start[, end]])

如果字符串以指定的 suffix 结束返回 True，否则返回 False。 suffix 也可以为由多个供查找的后缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。

>>> str01 = 'This is Python'
>>> print(str01.endswith('on'))
True
1
2
3

7.expandtabs(tabsize=8)

返回字符串的副本，其中所有的制表符会由一个或多个空格替换，具体取决于当前列位置和给定的制表符宽度。每 tabsize 个字符设为一个制表位（默认值 8 时设定的制表位在列 0, 8, 16 依次类推）

>>> str01 = '01\t012\t0123\t01234'
>>> print(str01.expandtabs())
01      012     0123    01234
>>> print(str01.expandtabs(4))
01  012 0123    01234
1
2
3
4
5

8.find(sub[, start[, end]])

返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引。 可选参数 start 与 end 会被解读为切片表示法。 如果 sub 未被找到则返回 -1。

>>> str01 = 'python is the most popular programming language'
>>> print(str01.find('is'))
7
1
2
3

9.format(*args, **kwargs)

执行字符串格式化操作。 调用此方法的字符串可以包含字符串字面值或者以花括号 {} 括起来的替换域。 每个替换域可以包含一个位置参数的数字索引，或者一个关键字参数的名称。 返回的字符串副本中每个替换域都会被替换为对应参数的字符串值。

>>> str01 = '{}语言可以进行web后端开发。'
>>> print(str01.format('Python'))
Python语言可以进行web后端开发。

1
2
3
4

10.format_map(mapping)

类似于 str.format(**mapping)

>>> str01 = '{name} was born in {country}'
>>> print(str01.format_map({'name': 'lilei', 'country': 'China'})
lilei was born in China
1
2
3

11.index(sub[, start[, end]])

类似于 find()，但在找不到子类时会引发 ValueError。

>>> str01 = 'python is the most popular programming language'
>>> print(str01.index('is'))
7
>>> str01 = 'python is the most popular programming language'
>>> print(str01.index('are')) # str01中不包含'are'，会导致报错
Traceback (most recent call last):
  File "D:\test.py", line 2, in <module>
    print(str01.index('are'))
ValueError: substring not found
1
2
3
4
5
6
7
8
9

12.isalnum()

如果字符串中至少有一个字符并且所有字符都是字母或数字则返回 True，否则返回 False。

>>> str01 = 'abc123'
>>> print(str01.isalnum())
True

>>> str02 = 'abcdefg'
>>> print(str02.isalnum())
True

>>> str03 = '1234567'
>>> print(str03.isalnum())
True

>>> str04 = 'abc 123'
>>> print(str04.isalnum())
False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

13.isalpha()

字符串至少有一个字符并且所有字符都是字母或文字则返回 True，否则返回 False。

>>> str01 = 'abc'
>>> print(str01.isalpha())
True

>>> str02 = 'abc一二三'
>>> print(str02.isalpha())
True

>>> str03 = 'abc123'
>>> print(str03.isalpha())
False
1
2
3
4
5
6
7
8
9
10
11

14.isascii()

如果字符串为空或字符串中的所有字符都是 ASCII ，返回 True ，否则返回 False 。ASCII 字符的码点范围是 U+0000-U+007F。

>>> str01 = '123456'
>>> print(str01.isascii())
True

>>> str02 = 'abcdef'
>>> print(str02.isascii())
True

>>> str03 = '好好学习'
>>> print(str03.isascii()) # 汉字返回False
False
1
2
3
4
5
6
7
8
9
10
11

15.isdecimal()

如果字符串中的所有字符都是十进制字符且该字符串至少有一个字符，则返回 True ， 否则返回 False 。

>>> str01 = '123456'
>>> print(str01.isdecimal())
True

>>> str02 = '123456a'
>>> print(str02.isdecimal())
False
1
2
3
4
5
6
7

16.isdigit()

如果字符串中的所有字符都是数字，并且至少有一个字符，返回 True ，否则返回 False 。 数字包括十进制字符和需要特殊处理的数字，如兼容性上标数字。

>>> str01 = '123456'
>>> print(str01.isdigit())
True

>>> str02 = '123456a'
>>> print(str02.isdigit())
False
1
2
3
4
5
6
7

17.islower()

如果字符串中至少有一个区分大小写的字符且此类字符均为小写则返回 True ，否则返回 False 。

>>> str01 = 'abcdefg'
>>> print(str01.islower())
True

>>> str02 = 'AbcDeF'
>>> print(str02.islower())
False
1
2
3
4
5
6
7

18.isnumeric()

如果字符串中至少有一个字符且所有字符均为数值字符则返回 True ，否则返回 False 。 数值字符包括数字字符，以及所有在 Unicode 中设置了数值特性属性的字符，例如 U+2155。

>>> str01 = '\u00B23455' 
>>> print(str01)
²3455
>>> print(str01.isnumeric())
True

>>> str02 = '\u00BD'
>>> print(str02)
½
>>> print(str02.isnumeric())
True

>>> str03 = "10km2"
>>> print(str03.isnumeric())
False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

19.isspace()

如果字符串中只有空白字符且至少有一个字符则返回 True ，否则返回 False 。

>>> str01 = '   '
>>> print(str01.isspace())
True

>>> str02 = 'python is the most popular programming language'
>>> print(str02.isspace())
False
1
2
3
4
5
6
7

20.istitle()

如果字符串中至少有一个字符且为标题字符串则返回 True ，例如大写字符之后只能带非大写字符而小写字符必须有大写字符打头。 否则返回 False 。

>>> str01 = 'python is the most popular programming language'
>>> print(str01.istitle())
False

>>> str01 = 'Python Is The Most Popular Programming Language'
>>> print(str01.istitle())
True
1
2
3
4
5
6
7

21.isupper()

如果字符串中至少有一个区分大小写的字符且此类字符均为大写则返回 True ，否则返回 False 。

>>> str01 = 'Python'
>>> print(str01.isupper())
False

>>> str02 = 'PYTHON'
print(str02.isupper())
True
1
2
3
4
5
6
7

22.join(iterable)

返回一个由 iterable 中的字符串拼接而成的字符串。调用该方法的字符串将作为元素之间的分隔。

# 语法：str.join(sequence) str为间隔符
>>> list01 = ['python', 'is', 'the', 'most', 'popular', 'programming', 'language']
>>> str01 = ' '.join(list01) 
>>> print(str01)
python is the most popular programming language
1
2
3
4
5

23.ljust(width[, fillchar])

返回长度为 width 的字符串，原字符串在其中靠左对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。

>>> str01 = 'python'
>>> print(str01.ljust(10, '*'))
python****
1
2
3

24.lower()

返回原字符串的副本，其所有区分大小写的字符 4 均转换为小写。

>>> str01 = 'PYTHON'
>>> print(str01.lower())
python
1
2
3

25.lstrip([chars])

返回原字符串的副本，移除其中的前导字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空白符。 实际上 chars 参数并非指定单个前缀；而是会移除参数值的所有组合:

>>> str01 = "     python python python    "
>>> print( str01.lstrip() )
python python python

>>> str02 = "88888888python python python8888888"
>>> print(str02.lstrip('8'))
python python python8888888
1
2
3
4
5
6
7

26.partition(sep)

在 sep 首次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 如果分隔符未找到，则返回的 3 元组中包含字符本身以及两个空字符串。

>>> str01 = 'www.python.org'
>>> print(str01.partition('.'))
('www', '.', 'python.org')
1
2
3

27.replace(old, new[, count])

返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new。 如果给出了可选参数 count，则只替换前 count 次出现。

>>> str01 = 'this is python'
>>> print(str01.replace('is', 'are'))
thare are python

>>> str01 = 'this is python'
>>> print(str01.replace('is', 'are', 1))
thare is python
1
2
3
4
5
6
7

28.rfind(sub[, start[, end]])

返回子字符串 sub 在字符串内被找到的最大（最右）索引，这样 sub 将包含在 s[start:end] 当中。 可选参数 start 与 end 会被解读为切片表示法。 如果未找到则返回 -1。

>>> str01 = 'this is python' 
>>> print(str01.rfind('is')) 
5

>>> str02 = 'this is python'
>>> print(str02.rfind('are'))
-1
1
2
3
4
5
6
7

29.rjust(width[, fillchar])

返回长度为 width 的字符串，原字符串在其中靠右对齐。 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。 如果 width 小于等于 len(s) 则返回原字符串的副本。

>>> str01 = 'python'
>>> print(str01.rjust(10, '*'))
****python
1
2
3

30.rsplit(sep=None, maxsplit=-1)

返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分，从 最右边 开始。 如果 sep 未指定或为 None，任何空白字符串都会被作为分隔符。 除了从右边开始拆分，rsplit()的其他行为都类似于下文所述的 split()。

>>> str01 = 'python is the most popular programming language'
>>> print(str01.rsplit(' ')) # 功能同split()
['python is the most popular programming', 'language']

>>> str02 = 'python is the most'
>>> print(str02.rsplit(' ', 2))
['python is the most popular', 'programming', 'language']
1
2
3
4
5
6
7

31.rstrip([chars])

返回原字符串的副本，移除其中的末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空白符。 实际上 chars 参数并非指定单个后缀；而是会移除参数值的所有组合:

>>> str01 = "     python python python    "
>>> print( str01.rstrip() )
     python python python

>>> str02 = "88888888python python python8888888"
>>> print(str02.rstrip('8'))
88888888python python python
1
2
3
4
5
6
7

32.split(sep=None, maxsplit=-1)

返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分（因此，列表最多会有 maxsplit+1 个元素）。 如果 maxsplit 未指定或为 -1，则不限制拆分次数（进行所有可能的拆分）。

>>> str01 = 'python#python#python'
>>> print(str01.split('#'))
['python', 'python', 'python']

>>> str01 = 'python#python#python'
>>> print(str01.split('#', 1))
['python', 'python#python']
1
2
3
4
5
6
7

33.splitlines(keepends=False)

返回由原字符串中各行组成的列表，在行边界的位置拆分。 结果列表中不包含行边界，除非给出了 keepends 且为真值。

>>> str01 = 'ab c\n\nde fg\rkl\r\n'
>>> print(str01.splitlines())
['ab c', '', 'de fg', 'kl']

>>> str02 = 'ab c\n\nde fg\rkl\r\n'
>>> print(str02..splitlines(keepends=True))
['ab c\n', '\n', 'de fg\r', 'kl\r\n']
1
2
3
4
5
6
7

34.startswith(prefix[, start[, end]])

如果字符串以指定的 prefix 开始则返回 True，否则返回 False。 prefix 也可以为由多个供查找的前缀构成的元组。 如果有可选项 start，将从所指定位置开始检查。 如果有可选项 end，将在所指定位置停止比较。

>>> str01 = 'Python is the best'
>>> print(str01.startswith('Py'))
True
1
2
3

35.strip([chars])

返回原字符串的副本，移除其中的前导和末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空白符。 实际上 chars 参数并非指定单个前缀或后缀；而是会移除参数值的所有组合:

>>> str01 = "     python python python    "
>>> print(str01.strip())
python python python

>>> str02 = "88888888python python python8888888"
>>> print(str02.strip('8'))
python python python
1
2
3
4
5
6
7

36.swapcase()

返回原字符串的副本，其中大写字符转换为小写，反之亦然。 请注意 s.swapcase().swapcase() == s 并不一定为真值。

>>> str01 = 'PYthon is THE bEST'
>>> print(str01.swapcase())
pyTHON IS the Best
1
2
3

37.title()

返回原字符串的标题版本，其中每个单词第一个字母为大写，其余字母为小写。

>>> str01 = 'python is the best'
>>> print(str01.title())
Python Is The Best
1
2
3

38.upper()

返回原字符串的副本，其中所有区分大小写的字符均转换为大写。

>>> str01 = 'python is the best'
>>> print(str01.upper())
PYTHON IS THE BEST
1
2
3

39.zfill(width)

返回原字符串的副本，在左边填充 ASCII '0' 数码使其长度变为 width。 正负值前缀 ('+'/'-') 的处理方式是在正负符号 之后 填充而非在之前。 如果 width 小于等于 len(s) 则返回原字符串的副本。

>>> str01 = 'python'
>>> print(str01.zfill(10))
0000python
1
2
3