所谓字符串，就是由零个或多个字符组成的有限序列，一般记为{\displaystyle s=a_{1}a_{2}\dots a_{n}(0\leq n \leq \infty)}">。在Python程序中，如果我们把单个或多个字符用单引号或者双引号包围起来，就可以表示一个字符串。

    可以在字符串中使用（反斜杠）来表示转义，也就是说\后面的字符不再是它原来的意义，例如：\n不是代表反斜杠和字符n，而是表示换行；而\t也不是代表反斜杠和字符t，而是表示制表符。所以如果想在字符串中表示'要写成\'，同理想表示\要写成\\。可以运行下面的代码看看会输出什么。

    1. s1 = '\'hello, world!\''
    2. s2 = '\n\\hello, world!\\\n'
    3. print(s1, s2, end='')

    在\后面还可以跟一个八进制或者十六进制数来表示字符，例如\141和\x61都代表小写字母a，前者是八进制的表示法，后者是十六进制的表示法。也可以在\后面跟Unicode字符编码来表示字符，例如\u9a86\u660a代表的是中文“骆昊”。运行下面的代码，看看输出了什么。

    1. s1 = '\141\142\143\x61\x62\x63'
    2. s2 = '\u9a86\u660a'
    3. print(s1, s2)

    如果不希望字符串中的\表示转义，我们可以通过在字符串的最前面加上字母r来加以说明，再看看下面的代码又会输出什么。

    1. s1 = r'\'hello, world!\''
    2. s2 = r'\n\\hello, world!\\\n'
    3. print(s1, s2, end='')

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

    1. s1 = 'hello ' * 3
    2. print(s1) # hello hello hello 
    3. s2 = 'world'
    4. s1 += s2
    5. print(s1) # hello hello hello world
    6. print('ll' in s1) # True
    7. print('good' in s1) # False
    8. str2 = 'abc123456'
    9. # 从字符串中取出指定位置的字符(下标运算)
    10. print(str2[2]) # c
    11. # 字符串切片(从指定的开始索引到指定的结束索引)
    12. print(str2[2:5]) # c12
    13. print(str2[2:]) # c123456
    14. print(str2[2::2]) # c246
    15. print(str2[::2]) # ac246
    16. print(str2[::-1]) # 654321cba
    17. print(str2[-3:-1]) # 45

    在Python中，我们还可以通过一系列的方法来完成对字符串的处理，代码如下所示。

    1. str1 = 'hello, world!'
    2. # 通过内置函数len计算字符串的长度
    3. print(len(str1)) # 13
    4. # 获得字符串首字母大写的拷贝
    5. print(str1.capitalize()) # Hello, world!
    6. # 获得字符串每个单词首字母大写的拷贝
    7. print(str1.title()) # Hello, World!
    8. # 获得字符串变大写后的拷贝
    9. print(str1.upper()) # HELLO, WORLD!
    10. # 从字符串中查找子串所在位置
    11. print(str1.find('or')) # 8
    12. print(str1.find('shit')) # -1
    13. # 与find类似但找不到子串时会引发异常
    14. # print(str1.index('or'))
    15. # print(str1.index('shit'))
    16. # 检查字符串是否以指定的字符串开头
    17. print(str1.startswith('He')) # False
    18. print(str1.startswith('hel')) # True
    19. # 检查字符串是否以指定的字符串结尾
    20. print(str1.endswith('!')) # True
    21. # 将字符串以指定的宽度居中并在两侧填充指定的字符
    22. print(str1.center(50, '*'))
    23. # 将字符串以指定的宽度靠右放置左侧填充指定的字符
    24. print(str1.rjust(50, ' '))
    25. str2 = 'abc123456'
    26. # 检查字符串是否由数字构成
    27. print(str2.isdigit())  # False
    28. # 检查字符串是否以字母构成
    29. print(str2.isalpha())  # False
    30. # 检查字符串是否以数字和字母构成
    31. print(str2.isalnum())  # True
    32. str3 = '  jackfrued@126.com '
    33. print(str3)
    34. # 获得字符串修剪左右两侧空格之后的拷贝
    35. print(str3.strip())

    我们之前讲过，可以用下面的方式来格式化输出字符串。

    1. a, b = 5, 10
    2. print('%d * %d = %d' % (a, b, a * b))

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

    1. a, b = 5, 10
    2. print('{0} * {1} = {2}'.format(a, b, a * b))

    Python 3.6以后，格式化字符串还有更为简洁的书写方式，就是在字符串前加上字母f，我们可以使用下面的语法糖来简化上面的代码。

    1. a, b = 5, 10
    2. print(f'{a} * {b} = {a * b}')

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

    使用列表

    不知道大家是否注意到，刚才我们讲到的字符串类型（str）和之前我们讲到的数值类型（int和float）有一些区别。数值类型是标量类型，也就是说这种类型的对象没有可以访问的内部结构；而字符串类型是一种结构化的、非标量类型，所以才会有一系列的属性和方法。接下来我们要介绍的列表（list），也是一种结构化的、非标量类型，它是值的有序序列，每个值都可以通过索引进行标识，定义列表可以将列表的元素放在[]中，多个元素用,进行分隔，可以使用for循环对列表元素进行遍历，也可以使用[]或[:]运算符取出列表中的一个或多个元素。

    下面的代码演示了如何定义列表、如何遍历列表以及列表的下标运算。

    1. list1 = [1, 3, 5, 7, 100]
    2. # 添加元素
    3. list1.append(200)
    4. list1.insert(1, 400)
    5. # 合并两个列表
    6. # list1.extend([1000, 2000])
    7. list1 += [1000, 2000]
    8. print(list1) # [1, 400, 3, 5, 7, 100, 200, 1000, 2000]
    9. print(len(list1)) # 9
    10. # 先通过成员运算判断元素是否在列表中，如果存在就删除该元素
    11. if 3 in list1:
    12.     list1.remove(3)
    13. if 1234 in list1:
    14.     list1.remove(1234)
    15. print(list1) # [1, 400, 5, 7, 100, 200, 1000, 2000]
    16. # 从指定的位置删除元素
    17. list1.pop(0)
    18. list1.pop(len(list1) - 1)
    19. print(list1) # [400, 5, 7, 100, 200, 1000]
    20. # 清空列表元素
    21. list1.clear()
    22. print(list1) # []

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

    1. fruits = ['grape', 'apple', 'strawberry', 'waxberry']
    2. fruits += ['pitaya', 'pear', 'mango']
    3. # 列表切片
    4. fruits2 = fruits[1:4]
    5. print(fruits2) # apple strawberry waxberry
    6. # 可以通过完整切片操作来复制列表
    7. fruits3 = fruits[:]
    8. print(fruits3) # ['grape', 'apple', 'strawberry', 'waxberry', 'pitaya', 'pear', 'mango']
    9. fruits4 = fruits[-3:-1]
    10. print(fruits4) # ['pitaya', 'pear']
    11. # 可以通过反向切片操作来获得倒转后的列表的拷贝
    12. fruits5 = fruits[::-1]
    13. print(fruits5) # ['mango', 'pear', 'pitaya', 'waxberry', 'strawberry', 'apple', 'grape']

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

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

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

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

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

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

    {\displaystyle F_{1}=1}">

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

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

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

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

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

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

    可以按照下面代码所示的方式来创建和使用集合。

    1. # 创建集合的字面量语法
    2. set1 = {1, 2, 3, 3, 3, 2}
    3. print(set1)
    4. print('Length =', len(set1))
    5. # 创建集合的构造器语法(面向对象部分会进行详细讲解)
    6. set2 = set(range(1, 10))
    7. set3 = set((1, 2, 3, 3, 2, 1))
    8. print(set2, set3)
    9. # 创建集合的推导式语法(推导式也可以用于推导集合)
    10. set4 = {num for num in range(1, 100) if num % 3 == 0 or num % 5 == 0}
    11. print(set4)

    向集合添加元素和从集合删除元素。

    1. set1.add(4)
    2. set1.add(5)
    3. set2.update([11, 12])
    4. set2.discard(5)
    5. if 4 in set2:
    6.     set2.remove(4)
    7. print(set1, set2)
    8. print(set3.pop())
    9. print(set3)

    集合的成员、交集、并集、差集等运算。

    使用字典

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

    1. # 创建字典的字面量语法
    2. scores = {'骆昊': 95, '白元芳': 78, '狄仁杰': 82}
    3. print(scores)
    4. # 创建字典的构造器语法
    5. items1 = dict(one=1, two=2, three=3, four=4)
    6. # 通过zip函数将两个序列压成字典
    7. items2 = dict(zip(['a', 'b', 'c'], '123'))
    8. # 创建字典的推导式语法
    9. items3 = {num: num ** 2 for num in range(1, 10)}
    10. print(items1, items2, items3)
    11. # 通过键可以获取字典中对应的值
    12. print(scores['骆昊'])
    13. print(scores['狄仁杰'])
    14. # 对字典中所有键值对进行遍历
    15. for key in scores:
    16.     print(f'{key}: {scores[key]}')
    17. # 更新字典中的元素
    18. scores['白元芳'] = 65
    19. scores['诸葛王朗'] = 71
    20. scores.update(冷面=67, 方启鹤=85)
    21. print(scores)
    22. if '武则天' in scores:
    23.     print(scores['武则天'])
    24. print(scores.get('武则天'))
    25. # get方法也是通过键获取对应的值但是可以设置默认值
    26. print(scores.get('武则天', 60))
    27. # 删除字典中的元素
    28. print(scores.popitem())
    29. print(scores.popitem())
    30. print(scores.pop('骆昊', 100))
    31. # 清空字典
    32. scores.clear()
    33. print(scores)

    练习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.     获取文件名的后缀名
    6.     :param has_dot: 返回的后缀名是否需要带点
    7.     :return: 文件的后缀名
    8.     """
    9.     if 0 < pos < len(filename) - 1:
    10.         index = pos if has_dot else pos + 1
    11.         return filename[index:]
    12.     else:
    13.         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()

    综合案例2：。

    综合案例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__':