User:Xyy23330121/Python/字符串的操作

Python 学习资料 目录

一、开始

1. 安装Python
2. 安装文本编辑器
3. 第一个程序：Hello World

二、变量

1. 命名规则
2. 特殊赋值方法

三、数字 (int float complex)

1. 数学运算
2. 将对象转化为数字
3. 编写加法程序
4. 数字精度（选学）
5. 位运算（选学）

四、布尔值 (bool) 与 if 语句

1. if语句
2. 比较运算
3. 布尔运算

五、字符串 (str)

1. 字符串的操作

六、列表 (list) 和 元组 (tuple)

1. 用推导式创建列表/元组
2. 通用序列操作
3. 可变序列操作

七、循环

1. while 语句
2. for 语句

八、字典 (dict)

1. 字典的简单操作

九、选学：集合 (set)

1. 集合的操作
2. 可变集合的操作

十、更多字符串操作

1. 字符串和编码 (bytes)
2. 格式化字符串
3. 正则表达式

十一、函数

1. 选学：函数注释

十二、类

1. 类的私有量与类的继承

十三、异常与try语句

1. try 语句
2. 异常类型的属性和方法

十四、类的方法与Python的计算

1. 类的方法与类实例
2. 类的方法与数学运算
3. 类的方法与其它内置函数

十五、import语句与模块

1. 简单模块
2. __main__

十六、查漏补缺

1. with 语句
2. match 语句
3. 随机数

十七、日期与时间

1. 日期与时间内容列表

十八、更多数字模式：numpy

1. 十进制浮点数 decimal
2. 分数 fractions

十九、文件系统

1. 文件处理 (file object)
2. json 格式

二十、 HTTP 请求

1. HTTP 请求示例

Python 为字符串添加了许多有意思的操作。迫于篇幅原因，这里另起一个页面。

在初次阅读时，只要掌握本页面的in / not in以及 str.find 即可。与其熟记以下全部内容，等需要操作的时候再来查阅是更有效的方法。

简单操作

这些操作比较简单，因为读者不需要学习 Unicode 对各个字符的定义或属性即可正常使用。

判断子字符串

in / not in

以下语句被用于判断字符串是否为另一字符串的子字符串：

print("Py" in "Python")      #输出：True
print("Py" not in "Python")  #输出：False

如果读者在之前章节学习比较运算符时看了文档。不难发现 Python 将 in 和 not in 视为是比较运算符的一种。因此，比较运算符的并联，比如 "Py" in "Python" not in "ABCDE" 也是可以的。

查找子字符串在父字符串中的位置

提示

在 Python 文档中，用方括号括起来的部分，代表“可选的部分”。在使用时，可以不输入这部分内容。比如左边的str.find(sub[, start[, end]])。它的意思是，可以用以下方式输入：

1. str.find(sub, start, end)
   可选的部分全部输入。
2. str.find(sub, start)
   不输入 [, end] 的部分。
3. str.find(sub)
   不输入[, start[, end]] 。

这种表示方法下，str代表读者创建的一个字符串，在使用时需要替换为字符串的内容，比如：

a = "Python"
index = a.find("y")

或者：

index = "Python".find("y")

而非直接使用str。

如果是直接使用str的情况，它会写作：

classmethod int.from_bytes(bytes, byteorder='big', *, signed=False)

或者，对于类型名称已经很明显时，写作：

classmethod fromhex(string)

本教程之后的内容都将采用 Python 文档的方法。

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

str.find(sub)会寻找 str 中，从左往右第一个子字符串 sub 的首字符索引。如果没有找到，返回-1。

关于 start 和 end 这两个参数，用以下方式可能更好理解。这两个方式输出的结果是相同的：

str.find(sub, start, end)
str[start:end].find(sub)

考虑到程序运行耗时，如果只是要确定子字符串是否在字符串之中，Python 更建议使用sub in str的方式。

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

类似 str.find ，但它会寻找 str 中，从右往左第一个子字符串 sub 的首字符索引。

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

类似 str.find ，但是在找不到的时候，会触发ValueError。

str.rindex(sub[, start[, end]])

类似 str.rfind ，但是在找不到的时候，会触发ValueError。

计数子字符串出现的次数

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

str.count(sub) 会寻找字符串 str 中，子字符串 sub 出现的次数。比如：

print("Python".count("y"))   #输出：1
print("aaaaaa".count("aa"))  #输出：3 被计数的sub之间，两两不会重合。
print("Python".count(""))    #输出：7 输入空字符串时，会返回len(str) + 1。

类似 str.find，以下两个方式输出的结果是相同的：

str.count(sub, start, end)
str[start:end].count(sub)

替换

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

返回 str 中，所有子字符串 old 都被转换成 new 的副本。如果指定了 count ，则最多替换从左往右的 count 个子字符串。有以下示例：

print("aaaa".replace("a","12"))   #输出：12121212
print("aaaa".replace("aa","1"))   #输出：11
print("aaaa".replace("a","1",3))  #输出：111a

拼接与拆分

str.join(iterable)

iterable 需要是一个由字符串组成的可迭代序列。str.join(iterable) 会返回把 iterable 中的所有拼接在一起的字符串；拼接时，会把 str 作为分隔符。有以下示例：

print("-ddd-".join(["a","b","c"])) #输出：a-ddd-b-ddd-c

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

提示

在 Python 文档中，符号 = 是另一种表示可选参数的方式，与方括号的方式不同，该方式同时给出了不使用该参数时，参数的默认值。以左边的str.split(sep = None, maxsplit = -1)为例：

• 读者可以不使用参数 sep，此时，sep 会取默认值None。
• 读者可以不使用参数 maxsplit，此时，maxsplit 会取默认值-1。

从而，使用str.split()等同于使用str.split(None, -1)

None 是 Python 中表示“空”的类型（对应其它一些语言中的 Null ）。读者无需特别掌握该类型。

返回字符串被按分割符 split 分割后的列表。比如：

print("a-ddd-b-ddd-c".split("-ddd-")) #输出：['a', 'b', 'c']

如果指定了 maxsplit，使 maxsplit 的值不为 -1。则最多从左往右分割 maxsplit 次。比如：

print("a-ddd-b-ddd-c".split("-ddd-",1)) #输出：['a', 'b-ddd-c']

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

类似str.split，但在指定 maxsplit 且 maxsplit 的值不为 -1 时，会从右往左分割 maxsplit 次。比如：

print("a-ddd-b-ddd-c".split("-ddd-")) #输出：['a-ddd-b', 'c']

str.splitlines(keepends = False)

返回由原字符串中各行组成的列表。每一项为一行的内容，不包含换行符。

如果 keepends 为 True，则每一行为一行的内容，包含换行符。

以下字符会被视为是换行符：

换行符	描述
\n	换行
\r	回车
\r\n	回车 + 换行
\v 或 \x0b	行制表符
\f 或 \x0c	换表单
\x1c	文件分隔符
\x1d	组分隔符
\x1e	记录分隔符
\x85	下一行 (C1 控制码)
\u2028	行分隔符
\u2029	段分隔符

str.partition(sep)

返回有三个元素的元组。看以下示例：

print("a-ddd-b-ddd-c".partition("-ddd-")) #输出：('a','-ddd-','b-ddd-c')
print("a-ddd-b-ddd-c".partition("-ded-")) #输出：('a-ddd-b-ddd-c','','')

若上面示例不够清楚，下面的代码可能有所帮助。它返回的内容等同于：

(s[:end if (end:=s.find(sep)) != -1 else (end:=len(s))],
 s[end:end+len(sep)],
 s[end+len(sep):])

str.rpartition(sep)

类似str.partition。返回有三个元素的元组，但是是从右往左进行的。看以下示例：

print("a-ddd-b-ddd-c".rpartition("-ddd-")) #输出：('a-ddd-b','-ddd-','c')
print("a-ddd-b-ddd-c".rpartition("-ded-")) #输出：('','','a-ddd-b-ddd-c')

与字符串开头/结尾内容有关的操作

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

若字符串 str 以 prefix 为开头，str.startswith(prefix) 会返回 True，否则返回False。比如：

print("Python".startswith("Py"))      #输出：True
print("Python".startswith("th"))      #输出：False

类似 str.find，以下两个方式输出的结果是相同的：

str.startswith(prefix, start, end)
str[start:end].startswith(prefix)

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

类似 str.startswith ，若字符串 str 以 suffix 为结尾，str.endswith(suffix) 会返回 True，否则返回False。

str.removeprefix(prefix)

若字符串 str 以 prefix 为开头，则返回 str 移除开头的 prefix 后的副本。比如：

print("Python".removeprefix("Py"))      #输出：thon
print("Python".removeprefix("th"))      #输出：Python

str.removesuffix(suffix)

类似 str.removeprefix。不过返回的是移除结尾的副本。

str.lstrip([chars])

提示

若左侧说明不够详细，以下代码可能对理解str.lstrip的作用有帮助。返回的结果等同于运行下面函数返回的结果：

def lstrip(str, char = " "):
    for index in range(len(str)):
        if str[index] not in chars:
            return str[index:]
    return ""

关于函数，参见之后的章节。

返回移除 str 开头，所有在 chars 中列出字符的副本，直到出现未列出的字符为止。如果不输入 chars ，默认移除空格。

print("abcaabbccdabc".lstrip("abc"))      #输出：dabc

str.rstrip([chars])

类似 str.lstrip 不过移除的是结尾的字符。

str.strip([chars])

类似 str.lstrip 但开头和结尾的字符都会被移除。

居中与左右对齐

str.center(width[, fillchar])

str.center(width)会返回原字符串居中的副本。它会在字符串两端填充空格，直到字符串长度达到或超过 width 为止。如果字符串长度本就大于 width ，它会直接返回字符串的副本。比如：

print("-","a".center(5),"-")  #输出：-   a   -
print("-","a".center(6),"-")  #输出：-   a    -
print("a12345678".center(5))  #输出：a12345678

fillchar 可以输入一个长度为 1 的字符串（单个字符）。如果指定了 fillchar 两端填充的将不是空格，而是 fillchar。

str.ljust(width[, fillchar])

类似str.center，但返回的是原字符串居左的副本。

str.rjust(width[, fillchar])

类似str.center，但返回的是原字符串居右的副本。

复杂操作

Python 在设计这些操作的时候广泛参考了 Unicode 标准，尤其是对各种语言的大小写、各种语言的数字之类的标准。因此，比如在理解大小写时，可以用英文字母的大小写来理解，但不要狭义的以为只有英文字母有大小写、或所有字符不是大写、就是小写。具体情况请参阅 Unicode 标准。

除此之外，也可以通过 unicodedata 模块 来进行操作。

判断大小写

str.islower()

如果字符串中字符都是小写，则返回 True。

str.isupper()

如果字符串中字符都是大写，则返回 True。

str.istitle()

如果字符串的每个单词的首字母都是大写、而其余字母都是小写，则返回 True。

大小写转换

str.lower()

将所有字符转换为小写（如果有小写形式）。

str.upper()

将所有字符转换为大写（如果有大写形式）。

str.swapcase()

将小写字符转换为大写，将大写字符转换为小写。

要注意，由于 Unicode 标准的原因，多个小写字符可能对应同一个大写字符。这使得 str.swapcase().swapcase() 不一定与 str 相等。

str.capitalize()

将字符串的第一个字母转换为大写，其余转换为小写。

str.title()

返回字符串中各个单词首字母大写的副本。

该方法将连续的字母组合视为单词，因此 they're 由于引号分隔，会被转换为 They'Re

str.casefold()

将所有字符转换为小写，且更为严格（如果有小写形式）。在 Python 文档中有以下示例：

德语小写字母 'ß' 相当于 "ss"。 由于它已经是小写了，lower() 不会对 'ß' 做任何改变；而 casefold() 则会将其转换为 "ss"。

判断字符类型

str.isalnum()

如果字符串中每个字符都是字母或数字，则返回 True。

严格来讲，如果 c.isalpha() ， c.isdecimal() ， c.isdigit() ，或 c.isnumeric() 之中有一个返回 True ，则字符 c 是字母或数字。

str.isalpha()

如果字符串中每个字符都是字母，则返回 True。

字母指的是 Unicode 字符数据库中被定义为 "Letter" 的字符，即具有通用类型属性 "Lm", "Lt", "Lu", "Ll" 或 "Lo" 之一的字符。

str.isascii()

如果字符串中每个字符都是 ascii 字符，则返回 True。

str.isdecimal()

如果字符串中每个字符都是十进制数字字符，则返回 True。

十进制字符是 Unicode 通用类别 "Nd" 中的字符。

str.isidentifier()

如果字符串可以作为变量名，或是关键词的名称，则返回 True。

str.isnumeric()

如果字符串中所有字符都是数值字符，则返回 True。

数值字符就是 Unicode 数据库中，具有特征属性值 Numeric_Type=Digit, Numeric_Type=Decimal 或 Numeric_Type=Numeric 的字符。

str.isprintable()

如果字符串中所有字符均为可打印字符或字符串为空则返回 True ，否则返回 False 。

不可打印字符指的是空格（\x20）以外的、在 Unicode 字符数据库中被定义为 "Other" 或 "Separator" 的字符。