• python进阶练习

    一、数据结构

    第一章  序列构成的数组

    1.1 内置序列类型概述

    容器序列：list、tuple和collections.deque这些序列能存放不同类型的数据。

    扁平序列：str、bytes、bytearray、memoryview和array.array，这些序列只能容纳一种类型。

    可变序列：list、bytearray、array.array、collections.deque和memoryview。

    不可变序列：tuple、str和bytes。

    1.2 列表推导和生成器表达式
    1.2.1 列表推导和可读性

    2-1 把字符串变成Unicode码位的列表

    1. # 方法一
    2. sysmbols = '$￥&*#@!'
    3. codes = []
    4. for symbol in sysmbols:
    5.     codes.append(ord(symbol))
    6. print(codes)
    7.  
    8. # 方法二
    9. sysmbols = '$￥&*#@!'
    10. codes = [ord(symbol) for symbol in sysmbols]
    11. print(codes)
    12.  
    13. # 结果
    14. [36, 65509, 38, 42, 35, 64, 33]
    15. [36, 65509, 38, 42, 35, 64, 33]

    句法提示：python会忽略代码里[]、{}、()中的换行，因此如果你的代码里有多行的列表、列表推导、生成器表达式、字典这一类的，可以省略不太好看的续行符\。

    2-2 列表推导不会再有变量泄露的问题

    1. # 列表推导、生成器表达式、集合推导、字典推导，在python3中有自己局部作用域，不会影响同名变量。
    2. x = 'ABC'
    3. dummy = [ord(x) for x in x]
    4. print(x)
    5. print(dummy)
    6.  
    7. # 结果
    8. ABC
    9. [65, 66, 67]
    1.2.2 列表推导同filter和map的比较

    2-3 列表推导和map/filter组合结果相同，明显列表推导更简单

    1. sysmbols = '$￥&*#@!'
    2. beyond_ascii = [ord(s) for s in sysmbols if ord(s) > 127]
    3. print(beyond_ascii)
    4.  
    5. beyond_ascii2 = list(filter(lambda c: c > 127, map(ord, sysmbols)))
    6. print(beyond_ascii2)
    7.  
    8. # 结果
    9. [65509]
    10. [65509]
    1.2.3 笛卡儿积

    2-4 使用列表推导计算笛卡儿积

    1. colors = ['black', 'white']
    2. sizes = ['S', 'M', 'L']
    3. tshirts = [(color, size) for size in sizes
    4.                         for color in colors]
    5. print(tshirts)
    6.  
    7. # 结果
    8. [('black', 'S'), ('white', 'S'), ('black', 'M'), ('white', 'M'), ('black', 'L'), ('white', 'L')]

    列表推导的作用只有一个：生成列表 

    1.2.4 生成器表达式

    2-5 用生成器表达式初始化元组和数组

    1. sysmbols = '$￥&*#@!'
    2. tup = tuple(ord(symbol) for symbol in sysmbols)
    3. print(tup)
    4.  
    5. import array
    6. arr = array.array('I', (ord(symbol) for symbol in sysmbols))
    7. print(arr)
    8.  
    9. # 结果
    10. (36, 65509, 38, 42, 35, 64, 33)
    11. array('I', [36, 65509, 38, 42, 35, 64, 33])

    2-6 使用生成器表达式计算笛卡儿积

    生成器表达式逐个产出元素，不会一次性产出所有列表，避免额外的内存占用。

    1. colors = ['black', 'white']
    2. sizes = ['S', 'M', 'L']
    3. for tshirt in ('%s, %s,' %(c, s) for c in colors for s in sizes):
    4.     print(tshirt)
    5.  
    6. # 结果
    7. black, S,
    8. black, M,
    9. black, L,
    10. white, S,
    11. white, M,
    12. white, L,
    1.3 元组不仅仅是不可变的列表
    1.3.1 元组和记录

    2-7 把元组用作记录

    1. lax_coordinates = (33.9425, -118.408056)
    2. city, year, pop, chg, area = ('Tokyo', 2003, 32450, 0.66, 8041)
    3. traveler_ids = [('USA', '31195855'), ('BRA', 'CE342567'), ('ESP', 'XDA205856')]
    4. for passport in sorted(traveler_ids):    #迭代过程中，passport变量被绑定到每个元组上
    5.     print('%s/%s' %passport)
    6. for country, _ in traveler_ids:    #拆包（unpacking），元组中第二个元组没用，用占位符“_”
    7.     print(country)
    8.  
    9. # 结果
    10. BRA/CE342567
    11. ESP/XDA205856
    12. USA/31195855
    13. USA
    14. BRA
    15. ESP
    1.3.2 元组拆包
    1. lax_coordinates = (33.9425, -118.408056)
    2. latitude, longitude = lax_coordinates   # 元组拆包
    3. print(latitude, longitude)
    4.  
    5. dm = divmod(20, 8)
    6. print(dm)
    7.  
    8. t = (20, 8)
    9. dm2 = divmod(*t)    # 用*运算符把一个可迭代对象拆开作为函数的参数
    10. print(dm2)
    11.  
    12. quotient, remainder = divmod(*t)
    13. print(quotient, remainder)
    14.  
    15. # 结果
    16. 33.9425 -118.408056
    17. (2, 4)
    18. (2, 4)
    19. 2 4

    os.path.split()函数会返回以路径和最后一个文件名组成的元组（path, last_part） 

    1. import os
    2. path, filename = os.path.split('D:\pythonProject\Fluent_Python\Data_Structure\\array\\tuple.py')
    3. print(path)
    4. print(filename)
    5.  
    6. # 结果
    7. D:\pythonProject\Fluent_Python\Data_Structure\array
    8. tuple.py

    用 * 来处理剩下的元素

    1. a, b, *rest = range(5)  
    2. print(a, b, rest)
    3. a, b, *rest = range(3)
    4. print(a, b, rest)
    5. a, b, *rest = range(2)
    6. print(a, b, rest)
    7.  
    8. a, *body, c, d = range(5)   # 在平行赋值中，*前缀只能用在一个变量名前，但是这个变量可以出现在复制表达式的任意位置
    9. print(a, body, c, d)
    10. *head, b, c, d = range(5)
    11. print(head, b, c, d)
    12.  
    13. # 结果
    14. 0 1 [2, 3, 4]
    15. 0 1 [2]
    16. 0 1 []
    17. 0 [1, 2] 3 4
    18. [0, 1] 2 3 4
    1.3.3 嵌套元组拆包

    2-8 用嵌套元组来获取经度

    1. metro_areas = [
    2.     ('Tokyo', 'JP', 36.933, (350689722, 139.691667)),   # 每个元组有4个元素，其中最后一个元素时一对坐标
    3.     ('Delhi NCR', 'IN', 21.935, (28.613889, 77.208889)),
    4.     ('Mexico City', 'MX', 20.142, (19.433333, -99.133333)),
    5.     ('New York-Newark', 'US', 20.104, (40.808611, -74.020386)),
    6.     ('Sao Paulo', 'BR', 19.649, (-23.547778, -46.635833)),
    7. ]
    8. print('{:15} | {:^9} | {:^9}'.format('city', 'lat.', 'long.'))
    9. fmt = '{:15} | {:9.4f} | {:9.4f}'
    10. for name, cc, pop, (latitude, longitude) in metro_areas:    # 把最后一个元素拆包到由变量构成的元组里，获取坐标
    11.     if longitude <= 0:  # 输出限制在西半球
    12.         print(fmt.format(name, latitude, longitude))
    13.  
    14. # 结果
    15. city            |   lat.    |   long.  
    16. Mexico City     |   19.4333 |  -99.1333
    17. New York-Newark |   40.8086 |  -74.0204
    18. Sao Paulo       |  -23.5478 |  -46.6358
    1.3.4 具名元组

    2-9 定义和使用具名元组

    1. from collections import namedtuple
    2.  
    3. City = namedtuple('City', 'name country population coordinates')    # 创建一个具名元组需要两个参数，一个类名，一个类的各个字段的名字
    4. tokyo = City('Tokyo', 'JP', 36.933, coordinates=(35.689722, 139.691667))
    5. print(tokyo.population)
    6. print(tokyo.coordinates)
    7. print(tokyo[1])
    8.  
    9. #结果
    10. 36.933
    11. (35.689722, 139.691667)
    12. JP

    2-10 具名元组的属性和方法（接续2-9）

    1. print(City._fields)  # _fields属性时一个包含这个类所有字段名称的元组
    2. Latlong = namedtuple('Latlong', 'lat long')
    3. delhi_data = ('Delhi NCR', 'IN', 21.935, Latlong(28.613889, 77.208889))
    4. delhi = City._make(delhi_data)  # 用_make()通过接受一个可迭代对象来生成这个类的一个实例，它的作用跟City(*delhi_data)一样
    5. print(delhi._asdict())  # _asdict()把具名元组以collections.OrderedDict的形式返回，可以用它把元组里的信息友好的呈现
    6. for key, value in delhi._asdict().items():
    7.     print(key + ':', value)
    8.  
    9. #结果
    10. ('name', 'country', 'population', 'coordinates')
    11. {'name': 'Delhi NCR', 'country': 'IN', 'population': 21.935, 'coordinates': Latlong(lat=28.613889, long=77.208889)}
    12. name: Delhi NCR
    13. country: IN
    14. population: 21.935
    15. coordinates: Latlong(lat=28.613889, long=77.208889)
    1.3.5 作为不可变列表的元组
    列表元组
    s._add_(s2)**s + s2，拼接
    s._iadd_(s2)*s += s2，就地拼接
    s.append(e)*在尾部添加一个新元素
    s.clear()*删除所有元素
    s._contains_(e)**s是否包含e
    s.copy()*列表的浅复制
    s.count(e)**e在s中出现的次数
    s._delitem(p)*把位于p的元素删除
    s.extend(it)*把可迭代对象it追加给s
    s._getitem_(p)**s[p]，获取位置p的元素
    s._getnewargs_()*在pickle中支持更加优化的序列化
    s.index(e)**在s中找到元素e第一次出现的位置
    s.insert(p,e)*在位置p之前插入元素e
    s._iter_()**获取s的迭代器
    s._len_()**len(s)，元素的数量
    s._mul_(n)**s * n，n个s的重复拼接
    s._imul_(n)*s *= n，就地重复拼接
    s._rmul_(n)**n * s，反向拼接
    s.pop([p])*删除最后或者是位于p的元素，并返回它的值
    s.remove(e)*删除s中的第一次出现的e
    s.reverse()*就地把s的元素倒序排列
    s._reversed_()*返回s的倒序迭代器
    s._setitem_(p, e)*s[p] = e，把元素e放在位置p，替代已经在那个位置的元素
    s.sort([key], [reverse])*就地对s中的元素进行排序，可选的参数有键（key）和是否倒序

    1.4 切片
    1.5 对序列使用 + 和 *
    建立由列表组成的列表

    2-12 一个包含3个列表的列表，嵌套的3个列表各自有3个元素来代表井字游戏的一行方块。

    1. board = [['_'] * 3 for i in range(3)]   #建立一个包含3个列表的列表，被包含的3个列表各自有3个元素
    2. print(board)
    3. board[1][2] = 'X'   # 把第1行第2列的元素标记为X
    4. print(board)
    5.  
    6. # 结果
    7. [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
    8. [['_', '_', '_'], ['_', '_', 'X'], ['_', '_', '_']]

    2-13 含有3个指向同一对象的引用的列表是毫无用处的

    1. weird_board = [['_'] * 3] * 3   # 外面的列表其实包含3个指向同一个列表的引用，当不做修改的时候，看起来都还好
    2. print(weird_board)
    3. weird_board[1][2] = '0'     # 试图标记第1行第2列的元素，就立马暴露列表内的3个引用指向同一个对象
    4. print(weird_board)
    5.  
    6. # 结果
    7. [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
    8. [['_', '_', '0'], ['_', '_', '0'], ['_', '_', '0']]
    1.6 序列的增量赋值

    例 *= 在可变和不可变序列上的作用

    1. l = [1, 2, 3]  
    2. print(id(l))    # 列表最开始的id
    3. l *= 2
    4. print(id(l))    # 运用增量乘法后，列表的id没变，新元素追加到列表上
    5. t = (1, 2, 3)
    6. print(id(t))    # 元组最开始的id
    7. t *= 2
    8. print(id(t))    # 运用增量乘法后，新的元组被创建
    9.  
    10. # 结果
    11. 2744821281408
    12. 2744821281408
    13. 2744824891520
    14. 2744821338496
    一个关于+=的谜题 

    注意：不要把可变对象放在元组里面。

    2-14 一个谜题

    1. >>> t = (1,2,[30,40])
    2. >>> t[2]+=[50,60]    # 因为tuple不支持对它的元素赋值，所以会抛出TypeError异常
    3. Traceback (most recent call last):
    4.   File "", line 1, in 
    5. TypeError: 'tuple' object does not support item assignment
    6. >>> t
    7. (1, 2, [30, 40, 50, 60])    # t[2]被改动了
    1.7 list.sort方法和内置函数sorted

    例 list.sort和sorted和它们的关键字参数

    1. fruits = ['grape', 'raspberry', 'apple', 'banana']
    2. print(sorted(fruits))   # 新建一个按照字母排序的字符串列表
    3. print(fruits)   # 原列表没有变化
    4. print(sorted(fruits, reverse=True))     # 按照字母降序排列
    5. print(sorted(fruits, key=len))      # 新建一个按照长度排序的字符串列表
    6. print(sorted(fruits, key=len, reverse=True))    # 按照长度降序排列的结果
    7. print(fruits)   # 原列表没有变化   
    8. fruits.sort()   # 对原列表就地排序，返回值None被控制台忽略
    9. print(fruits)   # fruits本身被排序
    10.  
    11. # 结果
    12. ['apple', 'banana', 'grape', 'raspberry']
    13. ['grape', 'raspberry', 'apple', 'banana']
    14. ['raspberry', 'grape', 'banana', 'apple']
    15. ['grape', 'apple', 'banana', 'raspberry']
    16. ['raspberry', 'banana', 'grape', 'apple']
    17. ['grape', 'raspberry', 'apple', 'banana']
    18. ['apple', 'banana', 'grape', 'raspberry']
    1.8 用bisect来管理已排序的序列
    1.8.1 用bisect来搜索

    bisect（haystack，needle）在haystack（干草堆）里搜索needle（针）的位置，需要满足的条件是，把needle插入这个位置后，haystack还能保持升序。也就是说这个函数返回的位置前面的值，都小于或等于needle的值。其中haystack必须是一个有序的序列。

    2.17 在有序序列中用bisect查找某个元素的插入位置

    1. import bisect
    2. import sys
    3. HAYSTACK = [1, 4, 5, 6, 8, 12, 15, 20, 21, 23, 23, 26, 29, 30]
    4. NEEDLES = [0, 1, 2, 5, 8, 10, 22, 23, 29, 30, 31]
    5. ROW_FMT = '{0:2d} @ {1:2d}  {2}{0:<2d}'
    6. def demo(bisect_fn):
    7.     for needle in reversed(NEEDLES):
    8.         position = bisect_fn(HAYSTACK, needle)  # 用特定的bisect函数来计算元素应该出现的位置
    9.         offset = position * '    |'   # 利用该位置来计算出需要几个分隔符号
    10.         print(ROW_FMT.format(needle, position, offset))     # 把元素和其应该出现的位置打印出来
    11.  
    12. if __name__ == '__main__':
    13.     if sys.argv[-1] == 'left':      #根据执行命令最后一个参数来选用bisect函数，例：python bisect_demo.python left
    14.         bisect_fn = bisect.bisect_left
    15.     else:
    16.         bisect_fn = bisect.bisect
    17.     print('DEMO:', bisect_fn.__name__)      # 把选定的函数打印出来
    18.     print('haystack ->', '   '.join('%2d' % n for n in HAYSTACK))
    19.     demo(bisect_fn)
    20.  
    21. # 结果
    22. DEMO: bisect_right
    23. haystack ->  1    4    5    6    8   12   15   20   21   23   23   26   29   30
    24. 31 @ 14      |    |    |    |    |    |    |    |    |    |    |    |    |    |31
    25. 30 @ 14      |    |    |    |    |    |    |    |    |    |    |    |    |    |30
    26. 29 @ 13      |    |    |    |    |    |    |    |    |    |    |    |    |29
    27. 23 @ 11      |    |    |    |    |    |    |    |    |    |    |23
    28. 22 @  9      |    |    |    |    |    |    |    |    |22
    29. 10 @  5      |    |    |    |    |10
    30.  8 @  5      |    |    |    |    |8 
    31.  5 @  3      |    |    |5 
    32.  2 @  1      |2 
    33.  1 @  1      |1 
    34.  0 @  0  0 
    35.  
    36. # 执行python bisect_demo.python left结果
    37. DEMO: bisect_left
    38. haystack ->  1    4    5    6    8   12   15   20   21   23   23   26   29   30
    39. 31 @ 14      |    |    |    |    |    |    |    |    |    |    |    |    |    |31
    40. 30 @ 13      |    |    |    |    |    |    |    |    |    |    |    |    |30
    41. 29 @ 12      |    |    |    |    |    |    |    |    |    |    |    |29
    42. 23 @  9      |    |    |    |    |    |    |    |    |23
    43. 22 @  9      |    |    |    |    |    |    |    |    |22
    44. 10 @  5      |    |    |    |    |10
    45.  8 @  4      |    |    |    |8
    46.  5 @  2      |    |5
    47.  2 @  1      |2
    48.  1 @  0  1
    49.  0 @  0  0

    2-18 根据一个分数，找到它所对应的成绩

    1. import bisect
    2.  
    3. def grade(score, breakpoints=[60, 70, 80, 90], grades='FDCBA'):
    4.     i = bisect.bisect(breakpoints, score)
    5.     print(grades[i])
    6. if __name__ == '__main__':
    7.     [grade(score) for score in [33, 99, 77, 70, 89, 90, 100]]
    8.  
    9. # 结果
    10. F
    11. A
    12. C
    13. C
    14. B
    15. A
    16. A
    2.8.2 用bisect.insort插入新元素

    insort(seq, item)把变量item插入到序列seq中，并能保持seq的升序顺序。

    2-19 insort可以保持有序序列的顺序

    1. import bisect
    2. import random
    3.  
    4. SIZE = 7
    5. random.seed(1729)
    6. my_list = []
    7. for i in range(SIZE):
    8.     new_item = random.randrange(SIZE * 2)
    9.     bisect.insort(my_list, new_item)
    10.     print('%2d ->' % new_item, my_list)
    11.  
    12. # 结果
    13. 10 -> [10]
    14.  0 -> [0, 10]
    15.  6 -> [0, 6, 10]
    16.  8 -> [0, 6, 8, 10]
    17.  7 -> [0, 6, 7, 8, 10]
    18.  2 -> [0, 2, 6, 7, 8, 10]
    19. 10 -> [0, 2, 6, 7, 8, 10, 10]
    1.9 当列表不是首选时
    1.9.1 数组

    2-20 一个浮点型数组的创建、存入文件和从文件读取的过程

    1. from array import array
    2. from random import random
    3.  
    4. floats = array('d', (random() for i in range(10 ** 7)))     # 利用一个可迭代对象生成器表达式来建立一个双精度浮点数组（类型码是’d'）
    5. print(floats[-1])       # 查看数组的最后一个元素
    6. fp = open('floats.bin', 'wb')   
    7. floats.tofile(fp)       # 把数组存入一个二进制文件里
    8. fp.close()
    9. floats2 = array('d')    # 新建一个双精度浮点空数组
    10. fp = open('floats.bin', 'rb')   
    11. floats2.fromfile(fp, 10 ** 7)   # 把1000万个浮点数从二进制文件里读取出来
    12. fp.close()
    13. print(floats2[-1])      # 查看新数组的最后一个元素
    14. print(floats2 == floats)        # 检查两个数组的内容是不是完全一样
    15.  
    16. # 结果
    17. 0.5099803693183845
    18. 0.5099803693183845
    19. True
    列表数组
    s.__add__(s2)**s + s2，拼接
    s.__iadd__(s2)**s += s2，就地拼接
    s.append(e)**在尾部添加一个元素
    s.byteswap*翻转数组内每个元素的字节序列，转换字节序
    s.clear()*删除所有元素
    s.__contains__(e)**s是否含有e
    s.copy()*对列表浅复制
    s.__copy()*对copy.copy的支持
    s.count(e)**s中e出现的次数
    s.__deepcopy__()*对copy.deepcopy的支持
    s.__delitem__(p)**删除位置p的元素
    s.extend(it)**将可迭代对象it里的元素添加到尾部
    s.frombytes(b)*将压缩成机器值得字节序列读出来添加到尾部
    s.fromfile(f,n)*将二进制文件f内含有机器值读出来添加到尾部，最多添加n项
    s.fromlist(l)*将列表里的元素添加到尾部，如果其中任何一个元素导致了TypeError异常，那么所有的添加都会取消
    s.__getitem__(p)**s[p]，读取位置p得元素
    s.index(e)**找到e在序列中第一次出现的位置
    s.insert(p,e)**在位于p得元素之前插入元素e
    s.itemsize*数组中每个元素得长度是几个字节
    s.__iter__()**返回迭代器
    s.__len__()**len(s)，序列的长度
    s.__mul__(n)**s * n，重复拼接
    s.__imul__(n)**s *= n，就地重复拼接
    s.__rmul__(n)**n * s，反向重复拼接*
    s.pop([p])**删除位于p得值并返回这个值，p得默认值是一个元素的位置
    s.remove(e)**删除序列里第一次出现的e元素
    s.reverse(e)**就地调转序列中元素的位置
    s.__reverse__()*返回一个从尾部开始扫描元素的迭代器
    s.__setitem__(p,e)**s[p] = e，把位于p位置的元素替换成e
    s.sort([key], [reverse])*就地排序序列，可选参数有key和reverse
    s.tobytes()*把所有元素的机器值用bytes对象的形式返回
    s.tofile(f)*把所有元素以机器值得形式写入一个文件
    s.tolist()*把数组转换成列表，列表里的元素类型是数字对象
    s.typecode*返回只有一个字符的字符串，代表数组元素在C语言中得类型
    1.9.2 内存视图

    2-21 通过改变数组中的一个字节来更新数组里某个元素的值。

    1. import array
    2.  
    3. numbers = array.array('h', [-2, -1, 0, 1, 2])   # 利用含有5个短整型有符号整数的数组创建一个memoryview
    4. memv = memoryview(numbers)
    5. print(len(memv))
    6. print(memv[0])      # memv里的5个元素跟数组里的没有区别
    7. memv_oct = memv.cast('B')   # 创建一个memv_oct，把memv里的内容转换成‘B’类型，无符号字符
    8. print(memv_oct.tolist())    # 以列表得形式查看memv_oct的内容，出现10个元素，可以研究存储知识，源码，补码
    9. memv_oct[5] = 4     # 把位于位置5的字节赋值成4
    10. print(numbers)      # 因为把占2个字节的整数的高位字节改成4，所以这个有符号整数的值就变成了1024
    11.  
    12. # 结果
    13. 5
    14. -2
    15. [254, 255, 255, 255, 0, 0, 1, 0, 2, 0]
    16. array('h', [-2, -1, 1024, 1, 2])
    1.9.3 NumPy和SciPy

    2-22 对numpy.ndarray的行和列进行基本操作

    1. import numpy
    2.  
    3. a = numpy.arange(12)    # 新建一个0~11的整数numpy.ndarray
    4. print(a)
    5. print(type(a))
    6. print(a.shape)      # 数组的维度，一个一维的，有12个元素
    7. a.shape = 3, 4      # 把数组变成2维的
    8. print(a)
    9. print("------------")
    10. print(a[2])         # 打印出第2行
    11. print("----------")
    12. print(a[2, 1])      # 打印第2行第1列的元素
    13. print("----------")
    14. print(a[:, 1])      # 打印第1列
    15. print("----------")
    16. print(a.transpose())    # 把行和列交换，得到一个新数组
    17.  
    18. # 结果
    19. [ 0  1  2  3  4  5  6  7  8  9 10 11]
    20. <class 'numpy.ndarray'>
    21. (12,)
    22. [[ 0  1  2  3]
    23.  [ 4  5  6  7]
    24.  [ 8  9 10 11]]
    25. ------------
    26. [ 8  9 10 11]
    27. ----------
    28. 9
    29. ----------
    30. [1 5 9]
    31. ----------
    32. [[ 0  4  8]
    33.  [ 1  5  9]
    34.  [ 2  6 10]
    35.  [ 3  7 11]]
    1.9.4 双向队列和其他形式的队列
    1. from collections import deque
    2.  
    3. dq = deque(range(10), maxlen=10)    # maxlen是一个可选参数，代表这个队列可以容纳的元素的数量，一旦设定，这个属性就不能修改了
    4. print(dq)
    5. dq.rotate(3)            # 队列的旋转操作接受一个n，当n>0时，队列的最右边的n个元素会被移动到队列的左边。当n<0时，最左边的n个元素会被移动到右边
    6. print(dq)
    7. dq.rotate(-4)           
    8. print(dq)
    9. dq.appendleft(-1)       # 当试图会一个已满的队列做头部添加操作的时候，它尾部的元素会被删除掉。注意在下一行里，元素0被删除了
    10. print(dq)
    11. dq.extend([11, 22, 33]) # 在尾部添加3个元素的操作会挤掉-1、1、2
    12. print(dq)
    13. dq.extendleft([10, 20, 30, 40])     # extendleft(iter)方法会把迭代器里的元素逐个添加到双向队列的左边，因此迭代器里的所有元素会逆序出现在队列里
    14. print(dq)
    15.  
    16. # 结果
    17. deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
    18. deque([7, 8, 9, 0, 1, 2, 3, 4, 5, 6], maxlen=10)
    19. deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 0], maxlen=10)
    20. deque([-1, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
    21. deque([3, 4, 5, 6, 7, 8, 9, 11, 22, 33], maxlen=10)
    22. deque([40, 30, 20, 10, 3, 4, 5, 6, 7, 8], maxlen=10)

    第二章  字典和集合

    第三章  文本和字节序列

    二、把函数视作对象

    三、面向对象惯用法

    四、控制流程

    五、元编程

  • 相关阅读:
    SQLite数据库损坏及其修复探究
    想看，但电脑没网怎么办，python教你保存整本成TXT~
    【C++面向对象侯捷】10.扩展补充：类模板，函数模板，及其他
    在opencv OpenCV中打开相机摄像头，用分水岭算法实时实现图像的分割与提取
    计算机毕业设计Java景区购票管理系统(源码+mysql数据库+系统+lw文档）
    信号(软中断)
    Arthas（阿尔萨斯）：阿里巴巴开源的线上问题诊断工具
    MMDetection 简单教程之配置文件（MMDetection3D也可从此开始学习）
    测试基础知识
    PostgreSQL更改用户登录密码认证协议
  • 原文地址：https://blog.csdn.net/sugong2021/article/details/133175012