字符串和常用数据结构

使用字符串

第二次世界大战促使了现代电子计算机的诞生，当初的想法很简单，就是用计算机来计算导弹的弹道，因此在计算机刚刚诞生的那个年代，计算机处理的信息主要是数值，而世界上的第一台电子计算机ENIAC每秒钟能够完成约5000次浮点运算。随着时间的推移，虽然对数值运算仍然是计算机日常工作中最为重要的事情之一，但是今天的计算机处理得更多的数据都是以文本信息的方式存在的，而Python表示文本信息的方式我们在很早以前就说过了，那就是字符串类型。所谓字符串，就是由零个或多个字符组成的有限序列，一般记为<span class={\displaystyle s=a_{1}a_{2}\dots a_{n}(0\leq n \leq \infty)}">。

我们可以通过下面的代码来了解字符串的使用。

  1. def main():
  2.     str1 = 'hello, world!'
  3.     # 通过len函数计算字符串的长度
  4.     print(len(str1))  # 13
  5.     # 获得字符串首字母大写的拷贝
  6.     print(str1.capitalize())  # Hello, world!
  7.     # 获得字符串变大写后的拷贝
  8.     print(str1.upper())  # HELLO, WORLD!
  9.     # 从字符串中查找子串所在位置
  10.     print(str1.find('or'))  # 8
  11.     print(str1.find('shit'))  # -1
  12.     # 与find类似但找不到子串时会引发异常
  13.     # print(str1.index('or'))
  14.     # print(str1.index('shit'))
  15.     # 检查字符串是否以指定的字符串开头
  16.     print(str1.startswith('He'))  # False
  17.     print(str1.startswith('hel'))  # True
  18.     # 检查字符串是否以指定的字符串结尾
  19.     print(str1.endswith('!'))  # True
  20.     # 将字符串以指定的宽度居中并在两侧填充指定的字符
  21.     print(str1.center(50, '*'))
  22.     # 将字符串以指定的宽度靠右放置左侧填充指定的字符
  23.     print(str1.rjust(50, ' '))
  24.     str2 = 'abc123456'
  25.     # 从字符串中取出指定位置的字符(下标运算)
  26.     print(str2[2])  # c
  27.     # 字符串切片(从指定的开始索引到指定的结束索引)
  28.     print(str2[2:5])  # c12
  29.     print(str2[2:])  # c123456
  30.     print(str2[2::2])  # c246
  31.     print(str2[::2])  # ac246
  32.     print(str2[::-1])  # 654321cba
  33.     print(str2[-3:-1])  # 45
  34.     # 检查字符串是否由数字构成
  35.     print(str2.isdigit())  # False
  36.     # 检查字符串是否以字母构成
  37.     print(str2.isalpha())  # False
  38.     # 检查字符串是否以数字和字母构成
  39.     print(str2.isalnum())  # True
  40.     str3 = '  jackfrued@126.com '
  41.     print(str3)
  42.     # 获得字符串修剪左右两侧空格的拷贝
  43.     print(str3.strip())
  46. if __name__ == '__main__':
  47.     main()

除了字符串，Python还内置了多种类型的数据结构，如果要在程序中保存和操作数据，绝大多数时候可以利用现有的数据结构来实现，最常用的包括列表、元组、集合和字典。

使用列表

下面的代码演示了如何定义列表、使用下标访问列表元素以及添加和删除元素的操作。

  1. def main():
  2.     list1 = [1, 3, 5, 7, 100]
  3.     print(list1)
  4.     list2 = ['hello'] * 5
  5.     print(list2)
  6.     # 计算列表长度(元素个数)
  7.     print(len(list1))
  8.     # 下标(索引)运算
  9.     print(list1[0])
  10.     print(list1[4])
  11.     # print(list1[5])  # IndexError: list index out of range
  12.     print(list1[-1])
  13.     print(list1[-3])
  14.     list1[2] = 300
  15.     print(list1)
  16.     # 添加元素
  17.     list1.append(200)
  18.     list1.insert(1, 400)
  19.     list1 += [1000, 2000]
  20.     print(list1)
  21.     print(len(list1))
  22.     # 删除元素
  23.     list1.remove(3)
  24.     if 1234 in list1:
  25.         list1.remove(1234)
  26.     del list1[0]
  27.     print(list1)
  28.     # 清空列表元素
  29.     list1.clear()
  30.     print(list1)
  33. if __name__ == '__main__':
  34.     main()

和字符串一样，列表也可以做切片操作，通过切片操作我们可以实现对列表的复制或者将列表中的一部分取出来创建出新的列表，代码如下所示。

  1. def main():
  2.     fruits = ['grape', 'apple', 'strawberry', 'waxberry']
  3.     fruits += ['pitaya', 'pear', 'mango']
  4.     # 循环遍历列表元素
  5.     for fruit in fruits:
  6.         print(fruit.title(), end=' ')
  7.     print()
  8.     # 列表切片
  9.     fruits2 = fruits[1:4]
  10.     print(fruits2)
  11.     # fruit3 = fruits  # 没有复制列表只创建了新的引用
  12.     # 可以通过完整切片操作来复制列表
  13.     fruits3 = fruits[:]
  14.     print(fruits3)
  15.     fruits4 = fruits[-3:-1]
  16.     print(fruits4)
  17.     # 可以通过反向切片操作来获得倒转后的列表的拷贝
  18.     fruits5 = fruits[::-1]
  19.     print(fruits5)
  22. if __name__ == '__main__':
  23.     main()

下面的代码实现了对列表的排序操作。

  1. def main():
  2.     list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
  3.     list2 = sorted(list1)
  4.     # sorted函数返回列表排序后的拷贝不会修改传入的列表
  5.     # 函数的设计就应该像sorted函数一样尽可能不产生副作用
  6.     list3 = sorted(list1, reverse=True)
  7.     # 通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序
  8.     list4 = sorted(list1, key=len)
  9.     print(list1)
  10.     print(list2)
  11.     print(list3)
  12.     print(list4)
  13.     # 给列表对象发出排序消息直接在列表对象上进行排序
  14.     list1.sort(reverse=True)
  15.     print(list1)
  18. if __name__ == '__main__':
  19.     main()

我们还可以使用列表的生成式语法来创建列表，代码如下所示。

  1. import sys
  4. def main():
  5.     f = [x for x in range(1, 10)]
  6.     print(f)
  7.     f = [x + y for x in 'ABCDE' for y in '1234567']
  8.     print(f)
  9.     # 用列表的生成表达式语法创建列表容器
  10.     # 用这种语法创建列表之后元素已经准备就绪所以需要耗费较多的内存空间
  11.     f = [x ** 2 for x in range(1, 1000)]
  12.     print(sys.getsizeof(f))  # 查看对象占用内存的字节数
  13.     print(f)
  14.     # 请注意下面的代码创建的不是一个列表而是一个生成器对象
  15.     # 通过生成器可以获取到数据但它不占用额外的空间存储数据
  16.     # 每次需要数据的时候就通过内部的运算得到数据(需要花费额外的时间)
  17.     f = (x ** 2 for x in range(1, 1000))
  18.     print(sys.getsizeof(f))  # 相比生成式生成器不占用存储数据的空间
  19.     print(f)
  20.     for val in f:
  21.         print(val)
  24. if __name__ == '__main__':
  25.     main()

除了上面提到的生成器语法，Python中还有另外一种定义生成器的方式，就是通过yield关键字将一个普通函数改造成生成器函数。下面的代码演示了如何实现一个生成斐波拉切数列的生成器。所谓斐波拉切数列可以通过下面递归的方法来进行定义：

<span class={\displaystyle F_{0}=0}">

<span class={\displaystyle F_{1}=1}">

<span class={\displaystyle F_{n}=F_{n-1}+F_{n-2}}({n}\geq{2})">

字符串和常用数据结构 - 图5

  1. def fib(n):
  2.     a, b = 0, 1
  3.     for _ in range(n):
  4.         a, b = b, a + b
  5.         yield a
  8. def main():
  9.     for val in fib(20):
  10.         print(val)
  13. if __name__ == '__main__':
  14.     main()

使用元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改，在前面的代码中我们已经不止一次使用过元组了。顾名思义，我们把多个元素组合到一起就形成了一个元组，所以它和列表一样可以保存多条数据。下面的代码演示了如何定义和使用元组。

  1. def main():
  2.     # 定义元组
  3.     t = ('骆昊', 38, True, '四川成都')
  4.     print(t)
  5.     # 获取元组中的元素
  6.     print(t[0])
  7.     print(t[3])
  8.     # 遍历元组中的值
  9.     for member in t:
  10.         print(member)
  11.     # 重新给元组赋值
  12.     # t[0] = '王大锤'  # TypeError
  13.     # 变量t重新引用了新的元组原来的元组将被垃圾回收
  14.     t = ('王大锤', 20, True, '云南昆明')
  15.     print(t)
  16.     # 将元组转换成列表
  17.     person = list(t)
  18.     print(person)
  19.     # 列表是可以修改它的元素的
  20.     person[0] = '李小龙'
  21.     person[1] = 25
  22.     print(person)
  23.     # 将列表转换成元组
  24.     fruits_list = ['apple', 'banana', 'orange']
  25.     fruits_tuple = tuple(fruits_list)
  26.     print(fruits_tuple)
  29. if __name__ == '__main__':
  30.     main()

这里有一个非常值得探讨的问题，我们已经有了列表这种数据结构，为什么还需要元组这样的类型呢？

  1. 元组中的元素是无法修改的，事实上我们在项目中尤其是多线程环境（后面会讲到）中可能更喜欢使用的是那些不变对象（一方面因为对象状态不能修改，所以可以避免由此引起的不必要的程序错误，简单的说就是一个不变的对象要比可变的对象更加容易维护；另一方面因为没有任何一个线程能够修改不变对象的内部状态，一个不变对象自动就是线程安全的，这样就可以省掉处理同步化的开销。一个不变对象可以方便的被共享访问）。所以结论就是：如果不需要对元素进行添加、删除、修改的时候，可以考虑使用元组，当然如果一个方法要返回多个值，使用元组也是不错的选择。
  2. 元组在创建时间和占用的空间上面都优于列表。我们可以使用sys模块的getsizeof函数来检查存储同样的元素的元组和列表各自占用了多少内存空间，这个很容易做到。我们也可以在ipython中使用魔法指令%timeit来分析创建同样内容的元组和列表所花费的时间，下图是我的macOS系统上测试的结果。

字符串和常用数据结构 - 图6

使用集合

Python中的集合跟数学上的集合是一致的，不允许有重复元素，而且可以进行交集、并集、差集等运算。

字符串和常用数据结构 - 图7

  1. def main():
  2.     set1 = {1, 2, 3, 3, 3, 2}
  3.     print(set1)
  4.     print('Length =', len(set1))
  5.     set2 = set(range(1, 10))
  6.     print(set2)
  7.     set1.add(4)
  8.     set1.add(5)
  9.     set2.update([11, 12])
  10.     print(set1)
  11.     print(set2)
  12.     set2.discard(5)
  13.     # remove的元素如果不存在会引发KeyError
  14.     if 4 in set2:
  15.         set2.remove(4)
  16.     print(set2)
  17.     # 遍历集合容器
  18.     for elem in set2:
  19.         print(elem ** 2, end=' ')
  20.     print()
  21.     # 将元组转换成集合
  22.     set3 = set((1, 2, 3, 3, 2, 1))
  23.     print(set3.pop())
  24.     print(set3)
  25.     # 集合的交集、并集、差集、对称差运算
  26.     print(set1 & set2)
  27.     # print(set1.intersection(set2))
  28.     print(set1 | set2)
  29.     # print(set1.union(set2))
  30.     print(set1 - set2)
  31.     # print(set1.difference(set2))
  32.     print(set1 ^ set2)
  33.     # print(set1.symmetric_difference(set2))
  34.     # 判断子集和超集
  35.     print(set2 <= set1)
  36.     # print(set2.issubset(set1))
  37.     print(set3 <= set1)
  38.     # print(set3.issubset(set1))
  39.     print(set1 >= set2)
  40.     # print(set1.issuperset(set2))
  41.     print(set1 >= set3)
  42.     # print(set1.issuperset(set3))
  45. if __name__ == '__main__':
  46.     main()

说明： Python中允许通过一些特殊的方法来为某种类型或数据结构自定义运算符（后面的章节中会讲到），上面的代码中我们对集合进行运算的时候可以调用集合对象的方法，也可以直接使用对应的运算符，例如&运算符跟intersection方法的作用就是一样的，但是使用运算符让代码更加直观。

使用字典

字典是另一种可变容器模型，类似于我们生活中使用的字典，它可以存储任意类型对象，与列表、集合不同的是，字典的每个元素都是由一个键和一个值组成的“键值对”，键和值通过冒号分开。下面的代码演示了如何定义和使用字典。

  1. def main():
  2.     scores = {'骆昊': 95, '白元芳': 78, '狄仁杰': 82}
  3.     # 通过键可以获取字典中对应的值
  4.     print(scores['骆昊'])
  5.     print(scores['狄仁杰'])
  6.     # 对字典进行遍历(遍历的其实是键再通过键取对应的值)
  7.     for elem in scores:
  8.         print('%s\t--->\t%d' % (elem, scores[elem]))
  9.     # 更新字典中的元素
  10.     scores['白元芳'] = 65
  11.     scores['诸葛王朗'] = 71
  12.     scores.update(冷面=67, 方启鹤=85)
  13.     print(scores)
  14.     if '武则天' in scores:
  15.         print(scores['武则天'])
  16.     print(scores.get('武则天'))
  17.     # get方法也是通过键获取对应的值但是可以设置默认值
  18.     print(scores.get('武则天', 60))
  19.     # 删除字典中的元素
  20.     print(scores.popitem())
  21.     print(scores.popitem())
  22.     print(scores.pop('骆昊', 100))
  23.     # 清空字典
  24.     scores.clear()
  25.     print(scores)
  28. if __name__ == '__main__':
  29.     main()

练习

练习1：在屏幕上显示跑马灯文字

  1. import os
  2. import time
  5. def main():
  6.     content = '北京欢迎你为你开天辟地…………'
  7.     while True:
  8.         # 清理屏幕上的输出
  9.         os.system('cls')  # os.system('clear')
  10.         print(content)
  11.         # 休眠200毫秒
  12.         time.sleep(0.2)
  13.         content = content[1:] + content[0]
  16. if __name__ == '__main__':
  17.     main()

练习2：设计一个函数产生指定长度的验证码，验证码由大小写字母和数字构成。

  1. import random
  4. def generate_code(code_len=4):
  5.     """
  6.     生成指定长度的验证码
  8.     :param code_len: 验证码的长度(默认4个字符)
  10.     :return: 由大小写英文字母和数字构成的随机验证码
  11.     """
  12.     all_chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
  13.     last_pos = len(all_chars) - 1
  14.     code = ''
  15.     for _ in range(code_len):
  16.         index = random.randint(0, last_pos)
  17.         code += all_chars[index]
  18.     return code

练习3：设计一个函数返回给定文件名的后缀名。

  1. def get_suffix(filename, has_dot=False):
  2.     """
  3.     获取文件名的后缀名
  5.     :param filename: 文件名
  6.     :param has_dot: 返回的后缀名是否需要带点
  7.     :return: 文件的后缀名
  8.     """
  9.     pos = filename.rfind('.')
  10.     if 0 < pos < len(filename) - 1:
  11.         index = pos if has_dot else pos + 1
  12.         return filename[index:]
  13.     else:
  14.         return ''

练习4：设计一个函数返回传入的列表中最大和第二大的元素的值。

  1. def max2(x):
  2.     m1, m2 = (x[0], x[1]) if x[0] > x[1] else (x[1], x[0])
  3.     for index in range(2, len(x)):
  4.         if x[index] > m1:
  5.             m2 = m1
  6.             m1 = x[index]
  7.         elif x[index] > m2:
  8.             m2 = x[index]
  9.     return m1, m2

练习5：计算指定的年月日是这一年的第几天

  1. def is_leap_year(year):
  2.     """
  3.     判断指定的年份是不是闰年
  5.     :param year: 年份
  6.     :return: 闰年返回True平年返回False
  7.     """
  8.     return year % 4 == 0 and year % 100 != 0 or year % 400 == 0
  11. def which_day(year, month, date):
  12.     """
  13.     计算传入的日期是这一年的第几天
  15.     :param year: 年
  16.     :param month: 月
  17.     :param date: 日
  18.     :return: 第几天
  19.     """
  20.     days_of_month = [
  21.         [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
  22.         [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
  23.     ][is_leap_year(year)]
  24.     total = 0
  25.     for index in range(month - 1):
  26.         total += days_of_month[index]
  27.     return total + date
  30. def main():
  31.     print(which_day(1980, 11, 28))
  32.     print(which_day(1981, 12, 31))
  33.     print(which_day(2018, 1, 1))
  34.     print(which_day(2016, 3, 1))
  37. if __name__ == '__main__':
  38.     main()

练习6：打印杨辉三角。

  1. def main():
  2.     num = int(input('Number of rows: '))
  3.     yh = [[]] * num
  4.     for row in range(len(yh)):
  5.         yh[row] = [None] * (row + 1)
  6.         for col in range(len(yh[row])):
  7.             if col == 0 or col == row:
  8.                 yh[row][col] = 1
  9.             else:
  10.                 yh[row][col] = yh[row - 1][col] + yh[row - 1][col - 1]
  11.             print(yh[row][col], end='\t')
  12.         print()
  15. if __name__ == '__main__':
  16.     main()

综合案例

案例1：双色球选号

  1. from random import randrange, randint, sample
  4. def display(balls):
  5.     """
  6.     输出列表中的双色球号码
  7.     """
  8.     for index, ball in enumerate(balls):
  9.         if index == len(balls) - 1:
  10.             print('|', end=' ')
  11.         print('%02d' % ball, end=' ')
  12.     print()
  15. def random_select():
  16.     """
  17.     随机选择一组号码
  18.     """
  19.     red_balls = [x for x in range(1, 34)]
  20.     selected_balls = []
  21.     selected_balls = sample(red_balls, 6)
  22.     selected_balls.sort()
  23.     selected_balls.append(randint(1, 16))
  24.     return selected_balls
  27. def main():
  28.     n = int(input('机选几注: '))
  29.     for _ in range(n):
  30.         display(random_select())
  33. if __name__ == '__main__':
  34.     main()

说明： 上面使用random模块的sample函数来实现从列表中选择不重复的n个元素。

综合案例2：约瑟夫环问题

  1. """
  2. 《幸运的基督徒》
  3. 有15个基督徒和15个非基督徒在海上遇险，为了能让一部分人活下来不得不将其中15个人扔到海里面去，有个人想了个办法就是大家围成一个圈，由某个人开始从1报数，报到9的人就扔到海里面，他后面的人接着从1开始报数，报到9的人继续扔到海里面，直到扔掉15个人。由于上帝的保佑，15个基督徒都幸免于难，问这些人最开始是怎么站的，哪些位置是基督徒哪些位置是非基督徒。
  4. """
  7. def main():
  8.     persons = [True] * 30
  9.     counter, index, number = 0, 0, 0
  10.     while counter < 15:
  11.         if persons[index]:
  12.             number += 1
  13.             if number == 9:
  14.                 persons[index] = False
  15.                 counter += 1
  16.                 number = 0
  17.         index += 1
  18.         index %= 30
  19.     for person in persons:
  20.         print('基' if person else '非', end='')
  23. if __name__ == '__main__':
  24.     main()

综合案例3：井字棋游戏

  1. import os
  4. def print_board(board):
  5.     print(board['TL'] + '|' + board['TM'] + '|' + board['TR'])
  6.     print('-+-+-')
  7.     print(board['ML'] + '|' + board['MM'] + '|' + board['MR'])
  8.     print('-+-+-')
  9.     print(board['BL'] + '|' + board['BM'] + '|' + board['BR'])
  12. def main():
  13.     init_board = {
  14.         'TL': ' ', 'TM': ' ', 'TR': ' ',
  15.         'ML': ' ', 'MM': ' ', 'MR': ' ',
  16.         'BL': ' ', 'BM': ' ', 'BR': ' '
  17.     }
  18.     begin = True
  19.     while begin:
  20.         curr_board = init_board.copy()
  21.         begin = False
  22.         turn = 'x'
  23.         counter = 0
  24.         os.system('clear')
  25.         print_board(curr_board)
  26.         while counter < 9:
  27.             move = input('轮到%s走棋, 请输入位置: ' % turn)
  28.             if curr_board[move] == ' ':
  29.                 counter += 1
  30.                 curr_board[move] = turn
  31.                 if turn == 'x':
  32.                     turn = 'o'
  33.                 else:
  34.                     turn = 'x'
  35.             os.system('clear')
  36.             print_board(curr_board)
  37.         choice = input('再玩一局?(yes|no)')
  38.         begin = choice == 'yes'
  41. if __name__ == '__main__':
  42.     main()

说明： 最后这个案例来自《Python编程快速上手:让繁琐工作自动化》一书（这本书对有编程基础想迅速使用Python将日常工作自动化的人来说还是不错的选择），对代码做了一点点的调整。