01. 字符串的基本概念

1.1 字符串的定义

  • 字符串（也称字符序列）是由零个或多个任意字符组成的不可变的有序序列。
  • 字符串主要是用来描述文本数据的，声明字符串的方式有：
    • 用一对单引号包裹文本数据：'Hello World'
    • 用一对双引号包裹文本数据："Hello World"
    • 用一对三引号包裹文本数据："""Hello World"""
  • 用三引号包裹的字符串可以是多行文本，单引号和双引号只能用来声明单行文本。
    • 三引号字符串的文本在写的时候是什么格式的，print()打印出来也是什么格式的。
    • 因此三引号包裹的字符串也被称为预编译文本。 ```python s = “””Hello World Hello BigData Hello Python “”” print(s)

“”” 运行结果： Hello World Hello BigData Hello Python “””

  1. <a name="bZgbN"></a>
  2. ### 1.2 字符串的分类
  3. <a name="BAjnx"></a>
  4. #### 1.2.1 转义字符串
  6. - 转义字符串与普通字符串不同，转移字符有它自己的含义，且被程序解析。
  7. - 转移字符串由转义符`\`和表示字符组成，如`\n`就是一个转义字符，代表着换行。
  8. - 常见的转义字符：
  9.    - \n：换行。
  10. ```python
  11. print("ABC\nDEF")
  12. """
  13. 运行结果：
  14. ABC
  15. DEF
  16. """

  • \a：响铃。（IDE决定把这个字符显示成一个方块“”，建议在CMD >> python中执行以下代码）

    1. >>> print('\a')

  • \t：水平制表符，相当于建表上的Tab键。

    1. print("Hello\tWorld\tPython")  # Hello    World    Python

  • \：输出一个反斜杠，单个字符\会联合其他字符被识别成转移字符，当字符串中就是想要输出一个反斜杠时，可以使用\。

  • \’(\”)：输出一个单（双）引号。普通字符串（除预编译文本）是由一对单引号或一对双引号组成，其引号不允许嵌套（即一对单引号中不允许嵌套单引号；一对双引号中不允许嵌套双引号），当字符串中就是想要输出一个单（双）引号时，可以使用\’(\”)。 ```python print(“反斜杠：\“) print(‘单引号内输出一个单引号：\’’) print(“双引号内输出一个单引号：\””)

“”” 运行结果： 反斜杠：\ 单引号内输出一个单引号：’ 双引号内输出一个单引号：” “””

  2.    - \uXXXX：XXXX代表的是Unicode码，\u的作用就是将XXXX转移为其对应的字符。
  3.       - 若\u之后的字符不是十六进制的字符，则运行时会报错：` (unicode error) 'unicodeescape' codec can't decode bytes in position 0-1: truncated \uXXXX escape`。
  4. ```python
  5. print("\u4e2a")  # 个

1.2.2 原生字符串

  • 原生字符串就是字符串在字面上拥有转义字符，但取消掉转移字符的含义，保留其字面的意思。即不让转义字符生效。
  • 在转义字符下\n代表的是一个换行符，但在原生字符下\n代表着的是由字符\和字符n组成的字符串。

  • Python输出原生字符串的方式：

    • 使用\的方式，如在字符串中包含一个字符串\n：

      1. print("换行符为：\\n")  # 换行符为：\n

    • 在字符串前使用r/R修饰，如在字符串中包含一个字符串\n：

      1. print(r"换行符为：\n")  # 换行符为：\n

      02. 字符串的相关操作

      2.1 索引

      2.1.1 索引概述

  • 字符串是一个有序的字符序列。所谓有序，最大的特点就是书写顺序与显示顺序是一致的，即字符串”ABC”无论怎么显示都是“ABC”，不可能变成“CBA”或者”BAC”。其次，每个位置的元素都有自己固定的编号。

    • 这个固定的编号被称之为索引，也可以称为下标或脚标。
    • 正方向上索引是从0开始，到len(str) - 1结束。
    • 负方向上索引是从-1开始，到-len(str)结束。
    • len()函数在2.1.5 len()函数中有介绍。
  • 字符串中指定索引位上的元素可以通过字符串[索引值]的方式获取。
    • 所有的有序序列（数组、元组、字符串）都可以通过索引来获取元素。

  • 索引可以分为正向索引和负向索引两种。

    2.1.2 正向索引

  • 正向索引代表着从左往右索引，从0开始，到len(str) - 1结束。

  • 示例：用正向索引显示索引值以及对应的元素。 ```python s = “HelloWorld” print(“索引位\t元素”) for i in range(0, len(s)): print(f”{i}\t\t{s[i]}”)

“”” 运行结果： 索引位 元素 0 H 1 e 2 l 3 l 4 o 5 W 6 o 7 r 8 l 9 d “””

  2. - 定位字符串左边的元素，推荐使用正向索引。
  3. <a name="xfQZZ"></a>
  4. #### 2.1.3 负向索引
  6. - 负向引代表着从右往左索引，从-1开始，到-len(str)结束。
  7. - 示例：用负向索引显示索引值以及对应的元素。
  8. ```python
  9. s = "HelloWorld"
  10. print("索引位\t元素")
  11. for i in range(-1, (-len(s) - 1), -1):
  12.     print(f"{i}\t\t{s[i]}")
  14. """
  15. 运行结果：
  16. 索引位    元素
  17. -1        d
  18. -2        l
  19. -3        r
  20. -4        o
  21. -5        W
  22. -6        o
  23. -7        l
  24. -8        l
  25. -9        e
  26. -10        H
  27. """

  • 定位字符串右边的元素，推荐使用负向索引。

    2.1.4 字符串的不可变性

  • 在1.1 字符串的定义中有说到字符串是一个不可变的有序序列。

  • 所谓不可变就是指字符串的内容一旦确定，则不能发生改变；即在字符串中索引只能用来定位元素，不能用来修改元素。 ```python s = “HelloWorld”

print(s[3]) # l，证明可以定位到元素

s[3] = “Z” # 尝试修改元素，发生报错：TypeError: ‘str’ object does not support item assignment

  1. <a name="CmeBJ"></a>
  2. #### 2.1.5 len()函数
  4. - 对于有序序列，我们都可以用len()函数获取该序列的长度（即序列中元素的个数）。
  5. ```python
  6. s = "HelloWorld"
  7. print(len(s))  # 10

  • 注意：转义字符整体算一个字符串。 

    1. print(len(r"\u4e2a"))  # 6
    2. print(len("\u4e2a"))  # 1

    2.2 切片

    2.2.1 切片概述

  • 切片是指对操作的对象截取其中一部分的操作，有序序列（包括字符串、列表、元组）都支持切片操作。

  • 使用索引能获取单个字符，而使用切片则可以从父字符串中获取一个子字符串。

    2.2.2 切片和步长

  • 切片的语法格式：str_obj[start_index:end_index:step]

    • 切片选取的区间属于左闭右开型，即从start_index位开始，到end_index的前一位结束（不包含结束位本身）。
    • step为步长，步长值可以省略，且缺省值为1。
  • 切片操作不会对原字符串产生影响，而是会为截取的子字符串开辟一个新的空间，在这个空间内存储切片得到的各个字符，因此切片操作会有返回值。

  • 步长缺省（缺省值为1）：

    1. s = "abcdefghijklmnopqrstuvwxyz"
    2. print(s[7:15])  # hijklmno，步长为缺省值1。

  • 步长大于0：正向索引切片

    • 按照从左到右的顺序，按照步长间隔进行截取（即从左往右每n个元素截取一次）。
    • 这种情况下，start_index指向的元素应该位于end_index的左边，否则切片返回值为空。 ```python s = “abcdefghijklmnopqrstuvwxyz”

print(s[3:21:4]) # dhlpt，获取元素索引位：3、7、11、15、19

print(s[3:-2:4]) # dhlptx

s[3:-2] = defghijklmnopqrstuvwx

以步长1的4倍进行截取：dhlptx

print(s[12:9:4]) # 空值，因为start_index指向的元素应该位于end_index的右边

  2. - 步长小于0：负向索引切片
  3.    - 按照从右到左的顺序，按照步长间隔进行截取（即从右往左每n个元素截取一次）。
  4.    - 这种情况下，start_index指向的元素应该位于end_index的右边，否则切片返回值为空。
  5. ```python
  6. s = "abcdefghijklmnopqrstuvwxyz"
  8. print(s[-3:-21:-1])  # xwvutsrqponmlkjihg
  10. print(s[-3:-21:-4])  # xtplh，获取元素索引位：-3、-7、-11、-15、-19
  12. s = "abcdefghijklmnopqrstuvwxyz"
  13. print(s[-3:2:-5])  # xsnid
  14. # s[-3:2:-1] = xwvutsrqponmlkjihgfed
  15. # 以步长-1的5倍进行截取：xsnid
  17. print(s[2:-2:-5])  # 空值，因为start_index指向的元素应该位于end_index的左边

2.2.3 切片的缺省值与边界

  • 切片的索引有着非常有用的缺省值。

  • 如果省略了切片的起始位置，则默认切片的起始位置为0。

    1. s = "abcdefg"
    2. print(s[0:5])  # abcde
    3. print(s[:5])  # abcde

  • 如果省略了切片的结束位置，则默认切片的结束位置为字符串的长度。

    1. s = "abcdefg"
    2. print(s[2:len(s)])  # cdefg
    3. print(s[2:])  # cdefg

  • 若起始位置和结束位置都省略了，结合上述两种情况，那么切出来的就是完整的原字符串。

    1. s = "abcdefg"
    2. print(s[0:len(s)])  # abcdefg
    3. print(s[:])  # abcdefg
    4. print(s[::-1])  # gfedcba，逆序字符串

  • 同时，字符串的索引也是有边界的（即下标越界）。但Python处理了无意义的切片，将越出边界的切片按照实际边界进行处理。

    1. s = "abcdefg"
    2. print(s[-200:5])  # abcde，起始下标越界，按0处理。
    3. print(s[3:100])  # defg，结束下标越界，按len(s)处理。
    4. print(s[-200:100])  # abcdefg，起始下标和结束下标都越界，按[0:len(s)]处理，切取得原字符串

    2.2.4 切片的正反向索引混用

  • 其实这在2.2.2中已经使用过了，正向索引可以结合负向索引混用达到截取字符串得结果。

    1. s = "abcdefg"
    2. print(s[1:-2])  # bcde
    3. print(s[-7:3])  # abc

    2.2.5 切片的应用场景

  • 判断一个数据是否是回文数（正着读反着读都一样，如12321、43534等）。

    1. num = int(input("输入一个数，判断是否是回文数："))
    2. if str(num) == str(num)[::-1]:
    3.   print(True)
    4. else:
    5.   print(False)

  • 判断一个数据是否以指定内容开头，如是否以start开头。

    1. data = input("输入数据：")
    2. if data[:len("start")] == "start":
    3.   print(True)
    4. else:
    5.   print(False)

  • 判断一个数据是否以指定内容结尾，如是否以end开头。

    1. data = input("输入数据：")
    2. if data[-len("end"):] == "end":
    3.   print(True)
    4. else:
    5.   print(False)

    2.3 字符串的运算

    2.3.1 +字符串拼接

  • str1 + str2可以将两个字符串str1和str2拼接成一个字符串。

    1. print("abc" + "def" + "ghi")  # abcdefghi

  • +加号两边的数据都必须是字符串类型的，否则比如一个整型一个字符串类型就会报错：TypeError: unsupported operand type(s) for +: 'int' and 'str'

    2.3.2 *字符串重复

  • str * n会将字符串str重复输出n次。

    1. print("abc" * 3)  # abcabcabc

    2.3.3 in/not in成员运算

  • str1 in str2可以判断str2中是否包含子字符串str1。

  • str1 not in str2可以判断str2中是否不包含子字符串str1。

    1. print("def" in "abcdefghi")  # True
    2. print("xyz" in "abcdefghi")  # False
    3. print("def" not in "abcdefghi")  # False
    4. print("xyz" not in "abcdefghi")  # True

    2.3.4 >/>=/</<=/==/!=比较运算符

  • str1 比较运算符 str2可以比较两个字符串的大小。

    • 字符串比较的本质：从左边第一个字符开始，依次比较两个字符对应的十进制数据，直到比出结果为止。
    • 比较运算符有：>大于、>=大于等于、<小于、<=小于等于、==相等、!=不相等。
      1. print("abc" == "def")  # False
      2. print("abc" != "def")  # True
      3. print("abc" >= "acd")  # False

      2.3.5 +=/*=复合赋值

  • str1 += str2实际上就是str1 = str1 + str2

  • str *= n实际上就是str = str * n ```python str1 = “abc” str1 += “def” print(str1) # abcdef

str2 = “ghi” str2 *= 3 print(str2) # ghighighi

  1. <a name="Qbxvn"></a>
  2. ### 2.4 字符串的遍历
  3. <a name="wOAkQ"></a>
  4. #### 2.4.1 直接遍历字符串
  6. - 可以通过for-in循环直接从左到右依次获取字符串中的所有元素。
  7. ```python
  8. for i in "HelloWorld":
  9.     print(i)

2.4.2 通过下标遍历字符串

  • range(0, len(str))可以生成由字符串str中的每一个索引组成的序列，由此可以通过索引获取字符串中的每一个元素。

    1. str = "HelloWorld"
    2. for i in range(0, len(str)):
    3.   print(i, str[i])

    03. 字符串的常用函数

    3.1 查找类函数

    3.1.1 find()查找子字符串首次出现的位置

  • str1.find(str2)：用于在str1父字符串中查找str2子字符串第一次出现的位置。

    • 查找方式：从左往右查找，若找到则返回子字符串第一次出现时第一个字符的索引值。
    • 若父字符串中没有指定的子字符串，则返回-1。
      1. s = "abc123abc123abc"
      2. pos = s.find("123")
      3. print(pos)  # 3
      4. pos = s.find("def")
      5. print(pos)  # -1

  • str1.find(str2, index)：在str1.find(str2)的基础上，指定从index索引位开始向右查找，而非从头开始查找。

    1. s = "abc123abc123abc"
    2. pos = s.find("123", 6)
    3. print(pos)  # 9

  • str1.find(str2, start_i, end_i)：在str1.find(str2)的基础上，在str1[start_i:end_i]中查找子字符串str2。

    1. s = "abc123abc123"
    2. pos = s.find("abc", 6, 8)
    3. print(pos)  # -1，虽然s中包含子字符串abc，但s[6:8] = ab，其中不包含abc

    3.1.2 index()查找子字符串首次出现的位置

  • str1.index(str2)：用于在str1父字符串中查找str2子字符串第一次出现的位置。

  • index()函数与find()函数最大的区别在于find()函数未找到元素则返回-1，而index()函数未找到元素会报错。

    1. s = "abc123abc123abc"
    2. pos = s.index("123")
    3. print(pos)  # 3
    4. pos = s.index("def")  # 报错：ValueError: substring not found
    5. print(pos)  # 不会执行

  • 除了找不到元素会报错外，find()函数有的功能index()也几乎都有；为了保证程序可顺利运行，还是建议使用find()函数。

    3.1.3 rfind()查找子字符串最后一次出现的位置

  • str1.rfind(str2)：用于在str1父字符串中查找str2子字符串最后一次出现的位置。

    • 查找方式：从右往左查找，若找到则返回子字符串最后一次出现时第一个字符的索引值。
    • 若父字符串中没有指定的子字符串，则返回-1。
      1. s = "abc123abc123abc"
      2. pos = s.rfind("123")
      3. print(pos)  # 9
      4. pos = s.find("def")
      5. print(pos)  # -1

  • 与find()函数类似，rfind()有一个类似函数rindex()；二者的关系和find()与index()的关系类似，即rindex()找不到元素报错。

    3.1.4 count()统计子串出现的次数

  • str1.count(str2)：用于在str1父字符串中查找str2子字符串出现的次数，即统计str1中有几个str2。

    1. s = "abc123abc123abc"
    2. print(s.count("abc"))  # 3

  • str1.count(str2, index)：从索引位index开始向右统计字符串str1中有几个子字符串str2。

    1. s = "abc123abc123abc"
    2. print(s.count("abc", 4))  # 2

  • str1.count(str2, start_i, end_i)：从start_i开始到end_i结束的范围内，统计str1中有几个str2。

    1. s = "abc123abc123abc"
    2. print(s.count("abc", 4, 10))  # 1

    3.2 转换类函数

  • 字符串拥有不可变性，因此这类函数都会生成新的字符串并返回。

    3.2.1 upper()/lower()/swapcase()大小写转换

  • str.upper()：用于将字符串str中所有的字母（不管其他数字或符号）转换为大写。

  • str.lower()：用于将字符串str中所有的字母（不管其他数字或符号）转换为小写。

  • str.swapcase()：用于将字符串中原有的大写字母转为小写字母，原有的小写字母转为大写字母（不管其他数字或符号）。

    1. print("AbCdeFG".upper())  # ABCDEFG
    2. print("AbCdeFG".lower())  # abcdefg
    3. print("AbCdeFG".swapcase()  # aBcDEfg

    3.2.2 capitalize()首字母大写

  • str.capitalize()：用于将字符串str中的首字母转为大写，其他字母转为小写。

    1. print("AbCdeFG".capitalize())  # Abcdefg

    3.2.3 title()每个单词首字母大写

  • str.title()：用于将字符串str中的每个单词的首字母大写，其他字母小写。

    • 这里的单词并不是指正规的英文单词，只要不是连接在一起的英文字符，都被视为单词。
      1. print("abc def ghi jkl".title())  # Abc Def Ghi Jkl，用空格分割
      2. print("abc,def,ghi,jkl".title())  # Abc,Def,Ghi,Jkl，用逗号分割
      3. print("abc-def-ghi-jkl".title())  # Abc-Def-Ghi-Jkl，用"-"分割

      3.2.4 encode()编码/decode()解码

  • str. encode(character)：用于将字符串str根据指定的字符集character转换成其对应的字节内容。

    • 单字节（如英文字母）的内容在字节中的体现与字符串中的体现是一致的。
    • 多字节（如汉字）的内容在字节中展示其每个字节【1个字节是8个二进制位】对应的十六进制形式。
      1. s = "Hello你好"
      2. byte_s = s.encode("utf-8")
      3. print(byte_s)  # b'Hello\xe4\xbd\xa0\xe5\xa5\xbd'
      4. # Hello都是单字节内容，因此转换为字节后还是Hello。
      5. # 在UTF-8中一个中文占3个字节，因此你是\xe4\xbd\xa0，好是\xe5\xa5\xbd。

  • str. decode(character)：用于将字节字符串str用指定的字符集character转换成对应的字符。

    1. byte_s = b'Hello\xe4\xbd\xa0\xe5\xa5\xbd'
    2. print(byte_s.decode("utf-8"))  # Hello你好
    3. print(byte_s.decode("gbk"))  # Hello浣犲ソ，UTF-8中文占3个字节，GBK占2个字节，因此解析不一样。

  • 注意：编码和解码使用的字符集必须保持一致，否则容易出现乱码或报错。

    3.3 判断类函数

    3.3.1 isdigit()判断数字字符串

  • str.isdigit()：判断字符串str是否为数字字符串（即所有字符都为数字字符，若全为数字字符则返回True，否则返回Flase）

    • 注意：这个方法只能识别整数，无法识别小数。
      1. print("12345".isdigit())  # True
      2. print("a12b34c5".isdigit())  # False
      3. print("123.45".isdigit())  # False

      3.3.2 isaplha()判断字母字符串

  • str.isaplha()：与isdigit()类似，isaplha()用于判断字符串str中是否全是字母。

    • 注意：Python使用的是UTF-8编码，是Unicode万国码的一种。
    • 因此isaplha()可以识别的字母是指所有国家的文字（并非单指英文字母），但无法识别特殊符号、数字等符号。
      1. print("你好。Hello.".isalpha())  # False
      2. print("你好Hello".isalpha())  # True

  • 补充：如何判断一个字符串是由纯英文字母组成的字符串：

    • 英文字母和其他语言文字的区别：
      • 英文字母是在ASCII码表中列出的，是单个字节的数据。
      • 其他语言是在ASCII码的基础上收录进来的，在Unicode编码表中，是最少占三字节的数据。
    • 实现思路：
      • 将字符串转换成字节数据时，单字节的英文字母保持不变，多字节的数据将转换为对应的十六进制数据。
      • 因此，转换得到的字节数据中如果和原来一样是纯英文的，那就表示是纯英文字母的字符串；否则带有\x十六进制的内容时，就表示这个字符串并非一个纯英文字母的字符串。
    • 代码实现： ```python s = “abcdef” is_eng = s.encode(“utf-8”).isalpha() # 转换成字节数组后若还是纯英文的字符串，那原来就是纯英文的 print(is_eng) # True

s = “你好Hello” is_eng = s.encode(“utf-8”).isalpha() # 否则原来就不是纯英文的字符串。 print(is_eng) # False

  1. <a name="NHudf"></a>
  2. #### 3.3.3 isalnum()判断字母或数字字符串
  4. - str.isalnum()：用于判断字符串str中的内容是否是字母或数字。（可以看作isdigit()与isaplha()功能之和）
  5.    - 注意：isalnum()依旧无法识别特殊符号。
  6. ```python
  7. print("HelloWorld".isalnum())  # True
  8. print("123456".isalnum())  # True
  9. print("Hello123World456".isalnum())  # True
  10. print("Hello,123,World".isalnum())  # False
  • 补充：如何判断一个字符串是由纯英文字母或数字组成的字符串：
    • 英文字母和数字都在ASCII码表中，都是单字节的数据。
    • 因此判断方式和3.3.2中判断一个字符串是由纯英文字母组成的字符串相似。 ```python s = “Hello123你好” print(s.isalnum()) # True

only_num_and_eng = s.encode(“utf-8”).isalnum() print(only_num_and_eng) # False

print(“Hello123”.encode(“utf-8”).isalnum()) # True

  1. <a name="r0Asy"></a>
  2. #### 3.3.4 isupper()/islower()判断字母的大小
  4. - str.isupper()：用于判断字符串str中所有的字母（不管其他数字或符号）是否是大写。
  5. ```python
  6. print("123Abc".isupper())  # False
  7. print("123ABC".isupper())  # True

  • str.islower()：用于判断字符串str中所有的字母（不管其他数字或符号）是否是小写。

    1. print("123Abc".islower())  # False
    2. print("123abc".islower())  # True

    3.3.5 startswith()/endswith()判断字符串是否以指定内容开头/结尾

  • str1.startswith(str2)：判断字符串str1是否以字符串str2开头。

  • str1.endswith(str2)：判断字符串str1是否以字符串str2结尾。

  • 示例1：判断字符串Hello是否以Hel开头，是否以lo结尾。

    1. s = "Hello"
    2. print(s.startswith("Hel"))  # True
    3. print(s.endswith("lo"))  # True

  • 这两个函数的参数也可以是一个元组，里面会给出多个匹配选项，只要匹配上其中一个就为True，全不匹配才为False。

  • 示例2：判断HelloWorld是否是以Hel、hel、leH中的其中一个开头的。

    1. s = "HelloWorld"
    2. print(s.startswith(("Hel", "hel", "leH")))  # True

  • 示例3：判断HelloWorld是否是以LLa、alc、dld中的其中一个结尾的。

    1. s = "HelloWorld"
    2. print(s.endswith(("LLa", "alc", "dld")))  # False

    3.4 字符串的替换与移除

    3.4.1 replace()内容替换

  • str1.replace(old_str, new_str)：用于在字符串str1中，将所有的子字符串old_str替换成new_str。

  • 示例1：将字符串”Hello World Hello Python”中的所有空格替换成”-“。

    1. s = "Hello World Hello Python"
    2. new_s = s.replace(" ", "-")
    3. print(new_s)  # Hello-World-Hello-Python

  • 还可以用str1.replace(old_str, new_str, num)的方式指定替换的个数，即将num个old_str替换成new_str。

  • 示例2：将字符串”Hello-World-Hello-Python”中的前两个”-“替换成”||”

    1. s = "Hello-World-Hello-Python"
    2. new_s = s.replace("-", "||", 2)
    3. print(new_s)  # Hello||World||Hello-Python

    3.4.2 strip()移除首尾内容

  • 空参的str.strip()函数用于移除字符串str中开头和结尾处的空白符号。

    • 空白符号：string.whitespace属性值中所有的字符都是空白符号，whitespace = ' \t\n\r\v\f'。
    • 注意：只会移除字符串开头和结尾处的空白符号，不会移除字符串中间的空白符号。
      1. s = "         abc  def         "
      2. new_s = s.strip()
      3. print(new_s)  # abc  def
      4. print(len(new_s))  # 8

  • 可以给strip()传递一个字符串参数，Python会将字符串参数拆分成一个个字符，然后从字符串头部和字符串尾部开始匹配。只要匹配上其中一个就移除，直到匹配失败为止。（注意：不会移除中间匹配成功的字符）

  • 示例：移除字符串s = "%^&abc^|def&^|%^"首尾的”&”、”|”、”%”、”^”符号。

    1. s = "%^&abc^|def&^|%^"
    2. new_s = s.strip("&|%^")
    3. print(new_s)  # abc^|def

    3.4.3 lstrip()移除首内容/rstrip()移除尾内容

  • str1.lstrip(str2)：用于移除str1开头处的str2，str2缺省为string.whitespace。

  • str1.rstrip(str2)：用于移除str1结尾头处的str2，str2缺省为string.whitespace。

    1. print("HelloWorld".lstrip("He"))  # lloWorld
    2. print("HelloWorld".rstrip("rld"))  # HelloWo

    3.5 字符串的切割与拼接

    3.5.1 split()从左往右切割字符串

  • str1.split(str2)：用于在str1中寻找所有str2，并在所有str2处做分割操作（将字符串一分为二），因此可以将str2看作一个分隔符。分割得到所有字符串将被存储在一个列表中。

  • 示例1：现有字符串s = "Hello Good Good study\nnice to meet you"，将空格作为分隔符，分割字符串s。

    1. s = "Hello Good Good  study\nnice to meet you"
    2. str_lst = s.split(" ")
    3. print(str_lst)  # ['Hello', 'Good', 'Good', '', 'study\nnice', 'to', 'meet', 'you']
    • 分割解读：
      1. 第一次分割："Hello"和"Good Good  study\nnice to meet you"
      2. 第二次分割："Good"和"Good  study\nnice to meet you"
      3. 第三次分割："Good"和" study\nnice to meet you"
      4. 第四次分割：""和"study\nnice to meet you"
      5. 第五次分割："study\nnice"和"to meet you"
      6. 第六次分割："to"和"meet you"
      7. 第七次分割："meet"和"you"

  • split()的默认参数：当split()函数内没有指定切割字符串时，会将” “、”\t”、”\n”、”\r”、”\v”、”\f”（总的来说就是ASCII中包含的所有空白符号）作为默认的切割符号，并且将结果中的空白字符串给移除掉。

  • 示例2：用默认切割符切割字符串s = "Hello Good Good study\nnice to meet you"。

    1. s = "Hello Good Good  study\nnice to meet you"
    2. new_s = s.split()
    3. print(new_s)  # ['Hello', 'Good', 'Good', 'study', 'nice', 'to', 'meet', 'you']

  • 最后还可以通过给参数maxsplit赋值指定切割的次数。

  • 示例：用默认切割符切割字符串s = "Hello Good Good study\nnice to meet you"，且只切割前两处。

    1. s = "Hello Good Good  study\nnice to meet you"
    2. new_s = s.split(maxsplit=2)
    3. print(new_s)  # ['Hello', 'Good', 'Good  study\nnice to meet you']

    3.5.2 rstrip()从右往左切割字符串

  • 全切的时候rstrip()其实和strip()没有什么区别。

    1. print("He ll oW or ld".split())  # ['He', 'll', 'oW', 'or', 'ld']
    2. print("He ll oW or ld".rsplit())  # ['He', 'll', 'oW', 'or', 'ld']

  • 但若指定分割的次数，那么strip()是从左往右一个一个切，而rstrip()则是从右往左一个一个切。

    1. print("He ll oW or ld".split(maxsplit=1))  # ['He', 'll oW or ld']
    2. print("He ll oW or ld".rsplit(maxsplit=1))  # ['He ll oW or', 'ld']

    3.5.3 join()拼接字符串

  • str1.join(lst_str)：一般用于将一个字符串列表lst_str中所有的字符串元素用连接字符str1连接起来（可以将str1看作拼接符）。

    • lst_str中所有的元素必须是字符串类型的，否则会报错。
    • 因为join()是使用+进行拼接的，而在2.3.1中提到，字符串拼接只能是：str + str。

  • 示例：用”—“连接列表[“Hello”, “World”, “Hello”, “Python”]中的所有元素。

    1. lst_str = ["Hello", "World", "Hello", "Python"]
    2. new_s = "--".join(lst_str)
    3. print(new_s)  # Hello--World--Hello--Python

  • 其实join()的参数不一定要上字符串列表，只要是个有序序列即可。

    1. print("+".join("123456"))  # 1+2+3+4+5+6
    2. print("//".join(("abc", "def", "ghi")))  # abc//def//ghi

    04. 格式化字符串

    4.1 文本对齐函数

    4.1.1 ljust()/center()/rjust()左中右对齐

  • str.ljust(width, fillchar)将字符串str按照width个宽度左对齐，若str无法占满width个位置，则右边用fillchar填充。

    • width：格式化后字符串的宽度。
    • fillchar：填充字符，缺省值为空格。
      1. print("Hello".ljust(10))
      2. print("Hello".ljust(10, "-"))
      3. """
      4. 运行结果：
      5. Hello     | 字符到这里为止
      6. Hello-----
      7. """

  • str.center(width, fillchar)将字符串str按照width个宽度居中对齐，若str无法占满width个位置，则两侧用fillchar填充。

    1. print("Hello".center(10))
    2. print("Hello".center(10, "-"))
    3. """
    4. 运行结果：
    5. Hello   | 字符到这里为止
    6. --Hello---
    7. """

  • str.rjust(width, fillchar)将字符串str按照width个宽度右对齐，若str无法占满width个位置，则左边用fillchar填充。

    1. print("Hello".rjust(10))
    2. print("Hello".rjust(10, "-"))
    3. """
    4. 运行结果：
    5.    Hello
    6. -----Hello
    7. """

  • 若width <= len(str)，则会按照str的长度显示整个字符串，此时就算设置了fillchar也不会显示。

    1. print("Hello".rjust(3, "-"))  # Hello

    4.1.2 zfill()右对齐

  • str.zfill(width)将字符串str按照width个宽度右对齐，与rjust()不同，zfill()空缺处固定用0填充。

    1. print("Hello".zfill(3))  # Hello
    2. print("Hello".zfill(10))  # 00000Hello

    4.2 格式化字符串

    4.2.1 用%格式化

  • 用%格式化字符串的基本格式："xxx%格式化类型xxx" % (datas)

    • 占位符（%格式化类型）：占位符由%符合与一个类型标识字符串组成。
      • %s：可以填充任意数据。
      • %d：可以填充整型数据，也可以按照指定位数格式化：%0nd按照n位数格式化。
      • %f：可以填充浮点型数据，也可以保留指定位数的小数：%.nf保留n为小数。
    • %：格式化的标志，用于连接字符串与待格式化的数据。
    • (datas)：由待格式化的数据组成的数据序列。有几个占位符就有几个数据，并且其位置也是一一对应的。多个数据之间用逗号分隔。

  • 示例：

    1. name = "乐乐"
    2. age = 18
    3. sid = 10
    4. score = 356
    5. message = "我叫%s，今年%d岁，在学校的学号是%05d，期末成绩是%.2f" % (name, age, sid, score)
    6. print(message)  # 我叫乐乐，今年18岁，在学校的学号是00010，期末成绩是356.00

    4.2.2 format()函数格式化

  • format()函数格式化字符串的基本格式：带占位符的字符串.format(datas)

    • 占位符：{index:格式化操作}
      • index：索引datas数据序列中的数据；索引值可以不写，缺省按照0、1、2、……的顺序自动填充。
      • 常用的格式化操作：
        • 保留n为小数：.nf
        • 按照指定宽度格式化数据：[填充符][对齐模式][宽度]
          • 填充符：可以用任意字符填充空缺位置上的数据，且缺省值为空格。
          • 对齐模式：<居左对齐、^居中对齐、>居右对齐
          • 宽度：格式化后字符串的长度。
        • 将数据格式化成百分比的形式：.n%，保留n位小数。
        • 千位计数法：,当数据较大时，会按照三位一分的形式格式化数据。
        • 科学计数法：.ne，保留n位小数。
    • datas：待格式化的数据序列，作为参数传入format()函数，多个数据间用逗号分隔。

  • 示例：

    1. name = "乐乐"
    2. age = 18
    3. sid = 10
    4. score = 556
    5. student_count = 4123421
    6. promote = 0.123
    7. print("我叫{0:^4}，今年{1:_>3d}岁，在学校的学号是{2:0>5}".format(name, age, sid))
    8. print("期末成绩是{0:.2f}，全省共{1:,}名高二学生，我提升了{2:.2%}".format(score, student_count, promote))
    9. print("全省共{0:,}名高二学生，用科学计数法可表示为：{0:2e}（保留两位小数）".format(student_count))
    10. """
    11. 运行结果：
    12. 我叫 乐乐 ，今年_18岁，在学校的学号是00010
    13. 期末成绩是556.00，全省共4,123,421名高二学生，我提升了12.30%
    14. 全省共4,123,421名高二学生，用科学计数法可表示为：4.123421e+06（保留两位小数）
    15. """

    4.2.3 用f/F修饰字符串

  • 在Python 3.6及以后，支持在字符串前使用f/F修饰字符串，然后在需要填充数据的位置，使用{数据/变量[:数据格式]}的格式将数据插入到字符串中。

    • 这种方式可以看作是对format()函数的一种优化，format()中的格式化操作这里基本通用。
  • 格式：f"内容1{数据1[:数据格式]}内容2{数据2[:[宽度格式][数据格式]]}……"

  • 示例：改写4.2.2中的程序。

    1. name = "乐乐"
    2. age = 18
    3. sid = 10
    4. score = 556
    5. student_count = 4123421
    6. promote = 0.123
    7. print(f"我叫{name:^4}，今年{age:_>3d}岁，在学校的学号是{sid:0>5}")
    8. print(f"期末成绩是{score:.2f}，全省共{student_count:,}名高二学生，我提升了{promote:.2%}")
    9. print(f"全省共{student_count:,}名高二学生，用科学计数法可表示为：{student_count:2e}（保留两位小数）")

    4.2.4 用\连接多行字符串

  • 有时候一个字符串过长，在编码时会影响代码的美观以及代码的阅读。

    1. context = "2006年，参演电视剧《与青春有关的日子》，开始在影视圈崭露头角。2005年，拍摄古装剧《锦衣卫》。2007年，主演赵宝刚导演的青春剧《奋斗》；同年，主演首部电影《走着瞧》。"
    2. print(context)  # 2006年，参演电视剧《与青春有关的日子》，开始在影视圈崭露头角。2005年，拍摄古装剧《锦衣卫》。2007年，主演赵宝刚导演的青春剧《奋斗》；同年，主演首部电影《走着瞧》。

  • 此时可以将这段文本数据用\分成多行，但是这段文本数据在计算时依旧是连在一起的。

    1. context = "2006年，参演电视剧《与青春有关的日子》，开始在影视圈崭露头角。" \
    2.         "2005年，拍摄古装剧《锦衣卫》。" \
    3.         "2007年，主演赵宝刚导演的青春剧《奋斗》；同年，主演首部电影《走着瞧》。"
    4. print(context)  # 2006年，参演电视剧《与青春有关的日子》，开始在影视圈崭露头角。2005年，拍摄古装剧《锦衣卫》。2007年，主演赵宝刚导演的青春剧《奋斗》；同年，主演首部电影《走着瞧》。