第二次世界大战促使了现代电子计算机的诞生，世界上的第一台通用电子计算机叫ENIAC（电子数值积分计算机），诞生于美国的宾夕法尼亚大学，占地167平米，重量27吨，每秒钟大约能够完成约5000次浮点运算，如下图所示。ENIAC诞生之后被应用于导弹弹道的计算，而数值计算也是现代电子计算机最为重要的一项功能。
image.png
随着时间的推移，虽然数值运算仍然是计算机日常工作中最为重要的组成部分，但是今天的计算机还要处理大量的以文本形式存在的信息。如果我们希望通过Python程序来操作本这些文本信息，就必须要先了解字符串这种数据类型以及与它相关的知识。

字符串的定义

所谓字符串，就是由零个或多个字符组成的有限序列，一般记为：
01 字符串 - 图2
在Python程序中，如果我们把单个或多个字符用单引号或者双引号包围起来，就可以表示一个字符串。字符串中的字符可以是特殊符号、英文字母、中文字符、日文的平假名或片假名、希腊字母、Emoji字符等。

  1. s1 = 'hello, world!'
  2. s2 = "你好，世界！"
  3. print(s1, s2)
  4. # 以三个双引号或单引号开头的字符串可以折行
  5. s3 = '''
  6. hello, 
  7. world!
  8. '''
  9. print(s3, end='')

提示：print函数中的end=''表示输出后不换行，即将默认的结束符\n（换行符）更换为''（空字符）。

转义字符和原始字符串

可以在字符串中使用\（反斜杠）来表示转义，也就是说\后面的字符不再是它原来的意义，例如：\n不是代表反斜杠和字符n，而是表示换行；\t也不是代表反斜杠和字符t，而是表示制表符。所以如果字符串本身又包含了'、"、\这些特殊的字符，必须要通过\进行转义处理。例如需要一个带单引号或反斜杠的字符串，可以用如下所示的方法进行处理。

  1. # 头尾带单引号的hello, world!
  2. s1 = '\'hello, world!\''
  3. print(s1)
  4. # 头尾带反斜杠的hello, world!
  5. s2 = '\\hello, world!\\'
  6. print(s2)

Python中的字符串可以r或R开头，这种字符串被称为原始字符串，意思是字符串中的每个字符都是它本来的含义，没有所谓的转义字符。例如，在字符串'hello\n'中，\n表示换行；而在r'hello\n'中，\n不再表示换行，就是反斜杠和字符n。大家可以运行下面的代码，看看会输出什么。

  1. # 字符串s1中\t是制表符，\n是换行符
  2. s1 = '\time up \now'
  3. print(s1)
  4. # 字符串s2中没有转义字符，每个字符都是原始含义
  5. s2 = r'\time up \now'
  6. print(s2)

Python中还允许在\后面还可以跟一个八进制或者十六进制数来表示字符，例如\141和\x61都代表小写字母a，前者是八进制的表示法，后者是十六进制的表示法。另外一种表示字符的方式是在\u后面跟Unicode字符编码，例如\u4f60\u597d\u4e16\u754c代表的是中文“你好世界”。运行下面的代码，看看输出了什么。

  1. s1 = '\141\142\143\x61\x62\x63'
  2. s2 = '\u4f60\u597d\u4e16\u754c'
  3. print(s1, s2)

字符串的运算

Python为字符串类型提供了非常丰富的运算符，我们可以使用+运算符来实现字符串的拼接，可以使用*运算符来重复一个字符串的内容，可以使用in和not in来判断一个字符串是否包含另外一个字符串，我们也可以用[]和[:]运算符从字符串取出某个字符或某些字符。

拼接和重复

下面的例子演示了使用+和*运算符来实现字符串的拼接和重复操作。

  1. s1 = 'hello' + ' ' + 'world'
  2. print(s1)    # hello world
  3. s2 = '!' * 3
  4. print(s2)    # !!!
  5. s1 += s2     # s1 = s1 + s2
  6. print(s1)    # hello world!!!
  7. s1 *= 2      # s1 = s1 * 2
  8. print(s1)    # hello world!!!hello world!!!

用*实现字符串的重复是非常有意思的一个运算符，在很多编程语言中，要表示一个有10个a的字符串，你只能写成"aaaaaaaaaa"，但是在Python中，你可以写成'a' * 10。你可能觉得"aaaaaaaaaa"这种写法也没有什么不方便的，那么想一想，如果字符a要重复100次或者1000次又会如何呢？

比较运算

对于两个字符串类型的变量，可以直接使用比较运算符比较两个字符串的相等性或大小。需要说明的是，因为字符串在计算机内存中也是以二进制形式存在的，那么字符串的大小比较比的是每个字符对应的编码的大小。例如A的编码是65， 而a的编码是97，所以'A' < 'a'的结果相当于就是65 < 97的结果，很显然是True；而'boy' < 'bad'，因为第一个字符都是'b'比不出大小，所以实际比较的是第二个字符的大小，显然'o' < 'a'的结果是False，所以'boy' < 'bad'的结果也是False。如果不清楚两个字符对应的编码到底是多少，可以使用ord函数来获得，例如ord('A')的值是65，而ord('昊')的值是26122。下面的代码展示了字符串的比较运算。

  1. s1 = 'a whole new world'
  2. s2 = 'hello world'
  3. print(s1 == s2, s1 < s2)      # False True
  4. print(s2 == 'hello world')    # True
  5. print(s2 == 'Hello world')    # False
  6. print(s2 != 'Hello world')    # True
  7. s3 = '程不懂'
  8. print(ord('程'), ord('不'), ord('懂'))    # 31243 19981 25026
  9. s4 = '橙不懂'
  10. print(ord('橙'), ord('不'), ord('懂'))    # 27225 19981 25026
  11. s5 = '程懂'
  12. print(ord('程'), ord('懂'))               # 31243 25026
  13. print(s3 > s4, s3 <= s4)      # True False
  14. print(s3 > s5, s3 < s5)       # False True

需要强调一下的是，字符串的比较运算比较的是字符串的内容，Python中还有一个is运算符（身份运算符），如果用is来比较两个字符串，它比较的是两个变量对应的字符串是否在内存中相同的位置（内存地址），简单的说就是两个变量是否对应内存中的同一个字符串。看看下面的代码就比较清楚is运算符的作用了。

  1. s1 = 'hello world'
  2. s2 = 'hello world'
  3. s3 = s2
  4. # 比较字符串的内容
  5. print(s1 == s2, s2 == s3)    # True True
  6. # 比较字符串的内存地址
  7. print(s1 is s2, s2 is s3)    # False True

成员运算

Python中可以用in和not in判断一个字符串中是否存在另外一个字符或字符串，in和not in运算通常称为成员运算，会产生布尔值True或False，代码如下所示。

  1. s1 = 'hello, world'
  2. print('wo' in s1)    # True
  3. s2 = 'goodbye'
  4. print(s2 in s1)      # False

获取字符串长度

获取字符串长度没有直接的运算符，而是使用内置函数len，我们在上节课的提到过这个内置函数，代码如下所示。

  1. s1 = 'hello, world'
  2. print(len(s1))           # 12
  3. print(len('你好世界'))    # 4

索引和切片

如果希望从字符串中取出某个字符，我们可以对字符串进行索引运算，运算符是[n]，其中n是一个整数，假设字符串的长度为N，那么n可以是从0到N-1的整数，其中0是字符串中第一个字符的索引，而N-1是字符串中最后一个字符的索引，通常称之为正向索引；在Python中，字符串的索引也可以是从-1到-N的整数，其中-1是最后一个字符的索引，而-N则是第一个字符的索引，通常称之为负向索引。注意，因为字符串是不可变类型，所以不能通过索引运算修改字符串中的字符。

  1. s1 = 'abc123456'
  2. N = len(s1)
  4. # 获取第一个字符
  5. print(s1[0], s1[-N])    # a a
  7. # 获取最后一个字符
  8. print(s1[N-1], s1[-1])  # 6 6
  10. # 获取索引为2或-7的字符
  11. print(s1[2], s1[-7])    # c c
  13. # 获取索引为5和-4的字符
  14. print(s1[5], s1[-4])    # 3 3

注意，在进行索引操作时，如果索引越界（正向索引不在0到N-1范围，负向索引不在-1到-N范围），会引发IndexError异常，错误提示信息为：string index out of range（字符串索引超出范围）。

如果要从字符串中取出多个字符，我们可以对字符串进行切片，运算符是[i:j:k]，其中i是开始索引，索引对应的字符可以取到；j是结束索引，索引对应的字符不能取到；k是步长，默认值为1，表示从前向后获取相邻字符的连续切片，所以:k部分可以省略。

假设字符串的长度为N，当k > 0时表示正向切片（从前向后获取字符），如果没有给出i和j的值，则i的默认值是0，j的默认值是N；

当k < 0时表示负向切片（从后向前获取字符），如果没有给出i和j的值，则i的默认值是-1，j的默认值是-N - 1。如果不理解，直接看下面的例子，记住第一个字符的索引是0或-N，最后一个字符的索引是N-1或-1就行了。

  1. s1 = 'abc123456'
  3. # i=2, j=5, k=1的正向切片操作
  4. print(s1[2:5])       # c12
  6. # i=-7, j=-4, k=1的正向切片操作
  7. print(s1[-7:-4])     # c12
  9. # i=2, j=9, k=1的正向切片操作
  10. print(s1[2:])        # c123456
  12. # i=-7, j=9, k=1的正向切片操作
  13. print(s1[-7:])       # c123456
  15. # i=2, j=9, k=2的正向切片操作
  16. print(s1[2::2])      # c246
  18. # i=-7, j=9, k=2的正向切片操作
  19. print(s1[-7::2])     # c246
  21. # i=0, j=9, k=2的正向切片操作
  22. print(s1[::2])       # ac246
  24. # i=1, j=-1, k=2的正向切片操作
  25. print(s1[1:-1:2])    # b135
  27. # i=7, j=1, k=-1的负向切片操作
  28. print(s1[7:1:-1])    # 54321c
  30. # i=-2, j=-8, k=-1的负向切片操作
  31. print(s1[-2:-8:-1])  # 54321c
  33. # i=7, j=-10, k=-1的负向切片操作
  34. print(s1[7::-1])     # 54321cba
  36. # i=-1, j=1, k=-1的负向切片操作
  37. print(s1[:1:-1])     # 654321c
  39. # i=0, j=9, k=1的正向切片
  40. print(s1[:])         # abc123456
  42. # i=0, j=9, k=2的正向切片
  43. print(s1[::2])       # ac246
  45. # i=-1, j=-10, k=-1的负向切片
  46. print(s1[::-1])      # 654321cba
  48. # i=-1, j=-10, k=-2的负向切片
  49. print(s1[::-2])      # 642ca

循环遍历

如果希望从字符串中取出每个字符，可以使用for循环对字符串进行遍历，有两种方式。
方式一：

  1. s1 = 'hello'
  2. for index in range(len(s1)):
  3.     print(s1[index])

方式二：

  1. s1 = 'hello'
  2. for ch in s1:
  3.     print(ch)

字符串的方法

在Python中，我们可以通过字符串类型自带的方法对字符串进行操作和处理，对于一个字符串类型的变量，我们可以用变量名.方法名()的方式来调用它的方法。所谓方法其实就是跟某个类型的变量绑定的函数，后面我们讲面向对象编程的时候还会对这一概念详加说明。

大小写相关操作

下面的代码演示了和字符串大小写变换相关的方法。

  1. s1 = 'hello, world!'
  3. # 使用capitalize方法获得字符串首字母大写后的字符串
  4. print(s1.capitalize())   # Hello, world!
  5. # 使用title方法获得字符串每个单词首字母大写后的字符串
  6. print(s1.title())        # Hello, World!
  7. # 使用upper方法获得字符串大写后的字符串
  8. print(s1.upper())        # HELLO, WORLD!
  10. s2 = 'GOODBYE'
  11. # 使用lower方法获得字符串小写后的字符串
  12. print(s2.lower())        # goodbye

查找操作

如果想在一个字符串中查找有没有另外一个字符串，可以使用字符串的find或index方法。

  1. s1 = 'hello, world!'
  3. # find方法从字符串中查找另一个字符串所在的位置
  4. # 找到了返回字符串中另一个字符串首字符的索引
  5. print(s1.find('or'))        # 8
  6. # 找不到返回-1
  7. print(s1.find('shit'))      # -1
  8. # index方法与find方法类似
  9. # 找到了返回字符串中另一个字符串首字符的索引
  10. print(s1.index('or'))       # 8
  11. # 找不到引发异常
  12. print(s1.index('shit'))     # ValueError: substring not found

在使用find和index方法时还可以通过方法的参数来指定查找的范围，也就是查找不必从索引为0的位置开始。find和index方法还有逆向查找（从后向前查找）的版本，分别是rfind和rindex，代码如下所示。

  1. s = 'hello good world!'
  3. # 从前向后查找字符o出现的位置(相当于第一次出现)
  4. print(s.find('o'))       # 4
  5. # 从索引为5的位置开始查找字符o出现的位置
  6. print(s.find('o', 5))    # 7
  7. # 从后向前查找字符o出现的位置(相当于最后一次出现)
  8. print(s.rfind('o'))      # 12

性质判断

可以通过字符串的startswith、endswith来判断字符串是否以某个字符串开头和结尾；还可以用is开头的方法判断字符串的特征，这些方法都返回布尔值，代码如下所示。

  1. s1 = 'hello, world!'
  3. # startwith方法检查字符串是否以指定的字符串开头返回布尔值
  4. print(s1.startswith('He'))    # False
  5. print(s1.startswith('hel'))   # True
  6. # endswith方法检查字符串是否以指定的字符串结尾返回布尔值
  7. print(s1.endswith('!'))       # True
  9. s2 = 'abc123456'
  11. # isdigit方法检查字符串是否由数字构成返回布尔值
  12. print(s2.isdigit())    # False
  13. # isalpha方法检查字符串是否以字母构成返回布尔值
  14. print(s2.isalpha())    # False
  15. # isalnum方法检查字符串是否以数字和字母构成返回布尔值
  16. print(s2.isalnum())    # True

格式化字符串

在Python中，字符串类型可以通过center、ljust、rjust方法做居中、左对齐和右对齐的处理。

  1. s1 = 'hello, world'
  3. # center方法以宽度20将字符串居中并在两侧填充*
  4. print(s1.center(20, '*'))  # ****hello, world****
  5. # rjust方法以宽度20将字符串右对齐并在左侧填充空格
  6. print(s1.rjust(20))        #         hello, world
  7. # ljust方法以宽度20将字符串左对齐并在右侧填充~
  8. print(s1.ljust(20, '~'))   # hello, world~~~~~~~~

我们之前讲过，在用print函数输出字符串时，可以用下面的方式对字符串进行格式化。

  1. a = 321
  2. b = 123
  3. print('%d * %d = %d' % (a, b, a * b))

当然，我们也可以用字符串的方法来完成字符串的格式，代码如下所示。

  1. a = 321
  2. b = 123
  3. print('{0} * {1} = {2}'.format(a, b, a * b))

从Python 3.6开始，格式化字符串还有更为简洁的书写方式，就是在字符串前加上f来格式化字符串，在这种以f打头的字符串中，{变量名}是一个占位符，会被变量对应的值将其替换掉，代码如下所示。

  1. a = 321
  2. b = 123
  3. print(f'{a} * {b} = {a * b}')

如果需要进一步控制格式化语法中变量值的形式，可以参照下面的表格来进行字符串格式化操作。
01 字符串 - 图3

修剪操作

字符串的strip方法可以帮我们获得将原字符串修剪掉左右两端空格之后的字符串。这个方法非常有实用价值，通常用来将用户输入中因为不小心键入的头尾空格去掉，strip方法还有lstrip和rstrip两个版本，相信从名字大家已经猜出来这两个方法是做什么用的。

  1. s1 = ' hello world '
  2. s2 = '*hello world*'
  3. # strip方法获得字符串修剪左右两侧空格之后的字符串
  4. print(len(s1))      # 13
  5. print(s1.strip())
  6. print(len(s1.strip()))  # 11
  7. print(s1.lstrip())      # 修剪左侧的空格
  8. print(s1.rstrip())      # 修剪右侧的空格
  9. print(s2.strip('*'))    # 修剪指定的字符

对于字符串类型来说，还有一个常用的操作是对字符串进行匹配检查，即检查字符串是否满足某种特定的模式。例如，一个网站对用户注册信息中用户名和邮箱的检查，就属于模式匹配检查。实现模式匹配检查的工具叫做正则表达式，Python语言通过标准库中的re模块提供了对正则表达式的支持，

函数和字符串的应用

先来回答一个可能会让大家感到费解的问题：为什么字符串类型（str）可以通过调用方法的方式进行操作，而之前我们用到的数值类型（如int、float）却没有可以调用的方法。在Python中，数值类型是标量类型，也就是说这种类型的变量没有可以访问的内部结构；而字符串类型是一种结构化的、非标量类型，所以才会有一系列的方法可供调用。

例子1：设计一个生成指定长度验证码的函数。

说明：验证码由数字和英文大小写字母构成。

  1. """
  2. 设计一个生成指定长度验证码的函数。
  3. 说明：验证码由数字和英文大小写字母构成。
  4. """
  5. import random
  7. ALL_CHARS = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
  10. def generate_code(code_len=4):
  11.     """
  12.     生成指定长度的验证码
  13.     :param code_len: 验证码的长度(默认4个字符)
  14.     :return: 由大小写英文字母和数字构成的随机验证码字符串
  15.     """
  16.     code = ''
  17.     for _ in range(code_len):
  18.         # 产生0到字符串长度减1范围的随机数作为索引
  19.         index = random.randrange(0, len(ALL_CHARS))
  20.         # 利用索引运算从字符串中取出字符并进行拼接
  21.         code += ALL_CHARS[index]
  22.     return code
  25. # 生成10组随机验证码来测试上面的函数
  26. for _ in range(10):
  27.     print(generate_code())

上面的函数其实还有一种更为简单的写法，直接利用random模块的随机抽样函数从字符串中取出指定数量的字符，然后利用字符串的join方法将选中的那些字符拼接起来。此外，可以利用Python标准库中的string 模块来获得数字和英文字母的字面常量。

  1. import random
  2. import string
  4. ALL_CHARS = string.digits + string.ascii_letters
  7. def generate_code(code_len=4):
  8.     """
  9.     生成指定长度的验证码
  10.     :param code_len: 验证码的长度(默认4个字符)
  11.     :return: 由大小写英文字母和数字构成的随机验证码字符串
  12.     """
  13.     return ''.join(random.choices(ALL_CHARS, k=code_len))

说明：random模块的sample和choices函数都可以实现随机抽样，sample实现无放回抽样，这意味着抽样取出的字符是不重复的；choices实现有放回抽样，这意味着可能会重复选中某些字符。这两个函数的第一个参数代表抽样的总体，而参数k代表抽样的数量。

例子2：设计一个函数返回给定文件名的后缀名。

说明：文件名通常是一个字符串，而文件的后缀名指的是文件名中最后一个.后面的部分，也称为文件的扩展名，它是某些操作系统用来标记文件类型的一种机制，例如在Windows系统上，后缀名exe表示这是一个可执行程序，而后缀名txt表示这是一个纯文本文件。需要注意的是，在Linux和macOS系统上，文件名可以以.开头，表示这是一个隐藏文件，像.gitignore这样的文件名，.后面并不是后缀名，这个文件没有后缀名或者说后缀名为’’。

  1. """
  2. 例子2：设计一个函数返回给定文件名的后缀名
  3. """
  6. def get_suffix(filename):
  7.     """
  8.     获取文件的后缀名
  9.     :param filename: 文件名
  10.     :return: 文件的后缀名
  11.     """
  12.     pos = filename.rfind('.')  # 逆向查找到.出现的位置
  13.     return filename[pos+1:] if pos > 0 else ''
  16. print(get_suffix('test.py'))  # py
  17. print(get_suffix('test.py.md'))  # md
  18. print(get_suffix('.test'))  # ''
  19. print(get_suffix('test'))  # ''

上面的get_suffix函数还有一个更为便捷的实现方式，就是直接使用os.path模块的splitext函数，这个函数会将文件名拆分成带路径的文件名和扩展名两个部分，然后返回一个二元组（下节课会讲到元组），二元组中的第二个元素就是文件的后缀名（包含.），如果要去掉后缀名中的.，可以做一个字符串的切片操作，代码如下所示。

  1. from os.path import splitext
  4. def get_suffix(filename):
  5.     return splitext(filename)[1][1:]

例子3：在终端中显示跑马灯（滚动）文字。

说明：实现跑马灯文字的原理非常简单，把当前字符串的第一个字符放到要输出的内容的最后面，把从第二个字符开始后面的内容放到要输出的内容的最前面，通过循环重复这个操作，就可以看到滚动起来的文字。两次循环之间的间隔可以通过time模块的sleep函数来实现，而清除屏幕上之前的输出可以使用os模块的system函数调用系统清屏命令来实现。

  1. import os
  2. import time
  3. content = '人生苦短，我用Python！'
  4. while True:
  5.     os.system('cls')  # windows清屏操作
  6.     print(content)
  7.     time.sleep(0.3)  # 休眠0.2秒
  8.     content = content[1:] + content[0]

提示：PyCharm的运行窗口无法用上面的方式做清屏处理。建议在“命令行提示符”或“终端”（PyCharm中的“Terminal”相当于就是Windows系统的“命令行提示符”或macOS系统的“终端”）中运行该程序。