字符串

转移字符与’\’

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

  1. >>> s1 = '\141\142\143\x61\x62\x63'
  2. >>> s2 = '\u9a86\u660a'
  3. >>> print(s1, s2)
  4. abcabc
  5. 骆昊

如果不希望字符串中的\表示转义，我们可以通过在字符串的最前面加上字母r来加以说明，即使用原生字符

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

字符串处理函数

  • 使用eval()函数执行字符串中的表达式

    1. >>> eval('2')
    2. 2
    3. >>> eval('pow(2,2)')
    4. 4
    5. >>> x = 3
    6. >>> eval('3 * x')
    7. 9

    image.png

    Unicode编码

    image.png
    image.png

    1. >>> "1 + 1 = 2 " + chr(10004)
    2. '1 + 1 = 2 ✔'
    3. >>> "这个字符♉的Unicode值是： " + str(ord('♉'))
    4. '这个字符♉的Unicode值是： 9801'
    5. >>> for i in range(12):
    6.       print(chr(9800 + i), end="")
    7. ♈♉♊♋♌♍♎♏♐♑♒♓

    字符串一众方法

    image.png
    image.png
    image.png

    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. # 从字符串中查找子串所在位置，是下标位置+1
    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. >>> '%d * %d = %d' % (a, b, a * b)
    3. '5, 10, 50'

  • format 方法

    1. >>> a, b = 5, 10
    2. >>> '%d * %d = %d'.format(a, b, a * b)
    3. '5, 10, 50'

  • f-string方法 ```python x = ‘haha’ y = ‘halo’ print(f’{y} {x}’)

输出 halo haha

  2. - 在字符串前加 `f` ,语法糖<br />
  3. ```python
  4. >>> a, b = 5, 10
  5. >>> f'{a} * {b} = {a*b}'
  6. '5, 10, 50'

{}槽内部对格式化的配置方式

image.png
image.png

列表

列表排序

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

生成式和生成器

  • 下面的代码使用生成式语法创建列表
    1. >>> [x for x in range(1, 10)]
    2. [1, 2, 3, 4, 5, 6, 7, 8, 9]
    3. >>> [x + y for x in 'ABCDE' for y in '1234567']
    4. ['A1',
    5. 'A2',
    6. 'A3',
    7. 'A4',
    8. 'A5',
    9. 'A6',
    10. 'A7',
    11. 'B1',
    12. ...]
    13. # 用列表的生成表达式语法创建列表容器
    14. # 用这种语法创建列表之后元素已经准备就绪所以需要耗费较多的内存空间
    15. >>> f = [x ** 2 for x in range(1, 1000)]
    16. >>> print(sys.getsizeof(f))  # 查看对象占用内存的字节数
    17. 9024
    18. # 请注意下面的代码创建的不是一个列表而是一个生成器对象
    19. # 通过生成器可以获取到数据但它不占用额外的空间存储数据
    20. # 每次需要数据的时候就通过内部的运算得到数据(需要花费额外的时间)
    21. f = (x ** 2 for x in range(1, 1000))
    22. >>> print(sys.getsizeof(f))  # 相比生成式生成器不占用存储数据的空间
    23. 120
    24. >>> type(f)
    25. generator
    26. >>> for val in f:
    27.       print(val)
    28. ...
    除了上面的生成器语法，还有一种通过 yield 关键字将一个普通函数改造成生成器函数的方式：比如是生成斐波那契数列的生成器
    【语言基础】字符串和常用数据结构 - 图9 ```python def fib(b): a, b = 0, 1 for _ in range(n):
    1.   a, b = b, a + b
    2.   yield a

def main(): for val in fib(20): print(val)

if name == ‘main‘: main()

  2. - 关于详细的 `yield` ，看链接 [https://www.runoob.com/w3cnote/python-yield-used-analysis.html](https://www.runoob.com/w3cnote/python-yield-used-analysis.html)
  3. <a name="ZEnU8"></a>
  4. # 元组
  6. - 可以保存**类型不同**的多种元素
  7. - 元组中的元素**不能修改**
  8. ```python
  9. # 定义元组
  10. t = ('骆昊', 38, True, '四川成都')
  11. # 获取元组中的元素
  12. print(t[0]) # '骆昊'
  13. # 遍历元组中的值
  14. for member in t:
  15.     print(member)
  16. # 重新给元组赋值
  17. # t[0] = '王大锤'  # TypeError
  18. # 变量t重新引用了新的元组原来的元组将被垃圾回收
  19. t = ('王大锤', 20, True, '云南昆明')
  20. print(t)
  21. # 将元组转换成列表
  22. person = list(t)
  23. print(person)
  24. # 列表是可以修改它的元素的
  25. person[0] = '李小龙'
  26. person[1] = 25
  27. print(person)
  28. # 将列表转换成元组
  29. fruits_list = ['apple', 'banana', 'orange']
  30. fruits_tuple = tuple(fruits_list)
  31. print(fruits_tuple)

我们已经有了列表这种数据结构，为什么还需要元组这样的类型呢?

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

image.png

集合

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

  • 创建和使用集合

    • 使用有重复元素的列表或者元组初始化一个元组，会自动去重
      1. # 创建集合的字面量语法
      2. set1 = {1, 2, 3, 3, 3, 2} # invalid syntax 
      3. print('Length =', len(set1))
      4. # 创建集合的构造器语法(面向对象部分会进行详细讲解)
      5. set2 = set(range(1, 10))
      6. set3 = set((1, 2, 3, 3, 2, 1)) # 自动去重
      7. # 创建集合的推导式语法(推导式也可以用于推导集合)
      8. set4 = {num for num in range(1, 100) if num % 3 == 0 or num % 5 == 0}

  • 向集合添加和删除元素 ```python set1.add(4) #在末尾添加 set2.update([11, 12]) set2.discard(5) # 和remove一样，删除元素5 if 4 in set2: set2.remove(4) set1.clear() # 清空 set1.pop() # 随机返回并删除一个元素

  2. - 集合交、并、补、差等运算
  3. ```python
  4. # 集合的交集、并集、差集、对称差运算
  5. print(set1 & set2)
  6. # print(set1.intersection(set2))
  7. print(set1 | set2)
  8. # print(set1.union(set2))
  9. print(set1 - set2)
  10. # print(set1.difference(set2))
  11. print(set1 ^ set2)
  12. # print(set1.symmetric_difference(set2))
  13. # 判断子集和超集
  14. print(set2 <= set1)
  15. # print(set2.issubset(set1))
  16. print(set3 <= set1)
  17. # print(set3.issubset(set1))
  18. print(set1 >= set2)
  19. # print(set1.issuperset(set2))
  20. print(set1 >= set3)
  21. # print(set1.issuperset(set3))

字典

  1. # 创建字典的字面量语法
  2. scores = {'骆昊': 95, '白元芳': 78, '狄仁杰': 82}
  3. mapping = dict(zip(range(5), reverses(range(5))))
  4. # 创建字典的构造器语法
  5. items1 = dict(one=1, two=2, three=3, four=4)
  6. # 通过zip函数将两个序列压成字典
  7. items2 = dict(zip(['a', 'b', 'c'], '123'))
  8. # 创建字典的推导式语法
  9. dict_com = {val : index for index, val in enumerate([1,2,3,4[)}
  10. items3 = {num: num ** 2 for num in range(1, 10)}
  11. # 通过键可以获取字典中对应的值
  12. print(scores['骆昊'])
  13. # 对字典中所有键值对进行遍历
  14. for key in scores:
  15.     print(f'{key}: {scores[key]}')
  16. # 更新字典中的元素
  17. scores['诸葛王朗'] = 71
  18. scores.update(冷面=67, 方启鹤=85) # 如果update的键在原字典中不存在，则清空后加入该新的键

image.png
image.png

练习

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

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

练习2

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

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

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

  1. def get_suffix(filename, has_dot=False):
  2.     pos = filename.rfind('.')
  3.     if 0 < pos < len(filename) - 1:
  4.         index = pos if has_dot else pos + 1
  5.         return filename[index:]
  6.     else:
  7.         return ""

综合案例：井字棋游戏

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