序列（sequence）

基本概念

  • 序列是Python中最基本的一种数据结构。序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引）并且序列中的数据会按照添加的顺序来分配索引

  • 数据结构指计算机中数据存储的方式

    序列的分类

  • 可变序列（序列中的元素可以改变）：例如 列表（list）

  • 不可变序列（序列中的元素不能改变）：例如 字符串（str）元组（tuple）

    列表(list)

  • 列表是Python中的一个对象

  • 列表的作用

    • 列表中可以保存多个有序的数据
    • 列表是用来存储对象的对象

      列表的使用

  • 列表的创建：通过[]来创建一个空列表 ```python

    增删改查

    列表使用[]来表示的 用list来表示

    list1 = [1, ‘python’, True, None] print(list1, type(list1))

[1, ‘python’, True, None]

列表就是用来存储对象的对象

取数据 通过索引来取数据

print(list1[0]) print(list1[-1]) print(list1[-2]) print(list1[-3]) print(len(list1))

1 None True python 4

  1. <a name="NkUbD"></a>
  2. ###  切片
  4. - 切片是指从现有列表中获得一个子列表
  5. - 通过切片来获取指定的元素
  6. - 语法: 列表[起始 : 结束 : 步长]
  7. - 通过切片获取元素时,会包括起始位置的元素,不会包括结束位置的元素
  8. - 起始位置和结束位置的索引可以不写
  9.    - 如果省略结束位置, 则会从当前的开始位置一直截取到最后
  10.    - 如果省略开始位置, 则会从第一个元素截取到结束的元素，但是不包括结束的元素
  11.    - 如果开始位置和结束位置都省略, 则则会从第一个元素开始截取到最后一个元素
  12. - 步长表示每次获取元素的间隔，默认是1(可以省略不写)
  13. - 步长不能是0,但可以是是负数
  14. ```python
  15. # 创建空列表
  16. list1 = []
  17. print(list1)
  19. []
  21. # 切片
  22. # 语法： str[]    list[起始索引：结束索引：步长]
  23. list1 = ['第一', '第二', '第三', '第四', '第五', '第六']
  24. print(list1[3:5])
  25. print(list1[-2:-4:-1])
  27. ['第四', '第五']
  28. ['第五', '第四']

通用操作

    • 和 *
        • 可以将两个列表拼接成一个列表
        • 可以将列表重复指定的次数 (注意2个列表不能够做乘法，要和整数做乘法运算)
  • in 和 not in
  • in用来检查指定元素是否在列表当中
  • not in 用来检查指定元素是否不在列表当中
  • len() 获取列表中元素的个数
  • max() 获取列表中最大值
  • min() 获取列表中最小值
  • list.index(x[, start[, end]])
    • 第一个参数 获取指定元素在列表中的位置
    • 第二个参数 表示查找的起始位置
    • 第三个参数 表示查找的结束位置
  • list.count(x) 统计指定元素在列表中出现的个数 ```python a = [1, 2, 3] + [4, 5, 6] b = [1, 2, 3] * 3 print(‘a=’, a) print(‘b=’, b)

a= [1, 2, 3, 4, 5, 6]

b= [1, 2, 3, 1, 2, 3, 1, 2, 3]

a = ‘abcd’ print(‘a’ in a) print(‘e’ in a)

True

False

b = [1, 2, 3, 1] print(max(b)) print(1 in b) # 返回的值是一个布尔值 print(b.index(1)) # index返回的结果就是当前这个数据的索引

print(b.find(1)) # 列表是没有find的这个方法

print(b.count(1)) # 计算指定元素个数

3 True 0 2

  1. <a name="9SPFG"></a>
  2. ## 修改列表
  4. - 通过切片来修改(起始就是给切片的内容重新赋值，但是赋值的内容必须是一个序列)
  5. - 当设置了步长时,序列中元素的个数必须和切片中元素的个数保持一致
  6. - 通过切片来删除元素
  7.    - del list[起始 : 结束]
  8.    - list = []
  9. <a name="kVwTP"></a>
  10. ## 列表的方法
  12. - append() 像列表的最后添加一个元素
  13. - insert(arg1,arg2) 像列表指定位置插入一个元素  参数1:要插入的位置 参数2:要插入的元素
  14. - extend(_iterable_) 使用一个新的序列来扩展当前序列(它会将该序列的中元素添加到列表中) 参数需要传递一个序列
  15. - pop() 根据索引删除并返回指定元素
  16. - remove() 删除指定元素 (如果相同值的元素有多个，只会删除第一个)
  17. - reverse() 翻转列表
  18. - sort(key=None,reverse=False) 用来对列表中的元素进行排序 reverse：True反序；False 正序
  19. ```python
  20. # 方法  方法是和面向对象相关的  使用方式是  ： 对象.方法名（'参数'）
  21. # 添加方法
  23. list1 = ['第一', '第二', '第三', '第四', '第五', '第六']
  24. # list.append()  向类表中最后的位置插入一个元素
  25. list1.append('第七')
  26. print(list1)
  28. ['第一', '第二', '第三', '第四', '第五', '第六', '第七']
  29. ----------------------------------------------------------
  30. list1 = ['第一', '第二', '第三', '第四', '第五', '第六']
  31. # list.insert() 向列表中的指定位置插入一个元素，第一个参数是要插入的位置，第二个参数是要插入的内容
  32. list1.insert(4, '第八')
  33. print(list1)
  35. ['第一', '第二', '第三', '第四', '第八', '第五', '第六']
  36. -------------------------------------------------------
  37. list1 = ['第一', '第二', '第三', '第四', '第五', '第六']
  38. # list.extend() 使用新的序列来扩展当前序列
  39. list1.extend(['第九', '第十'])
  40. print(list1)
  42. ['第一', '第二', '第三', '第四', '第五', '第六', '第九', '第十']
  43. -----------------------------------------------------------
  44. # 删除方法
  45. list1 = ['第一', '第二', '第三', '第四', '第五', '第六']
  46. # list.pop() 根据索引删除并返回元素， 如果不传递索引，默认删除最后一个
  47. a = list1.pop(2)
  48. b = list1.pop()
  49. print(a)
  50. print(b)
  51. print('list1=', list1)
  53. 第三
  54. 第六
  55. list1= ['第一', '第二', '第四', '第五']
  56. --------------------------------------
  57. list2 = ['第一', '第二', '第三', '第四', '第五', '第六']
  58. print('list2=', list2)
  59. # list.remove() 删除指定的元素
  60. list2.remove('第三')
  61. # d = list2.remove() # 报错，remove() takes exactly one argument (0 given)
  62. print('list2=', list2)
  64. list2= ['第一', '第二', '第三', '第四', '第五', '第六']
  65. list2= ['第一', '第二', '第四', '第五', '第六']
  66. ----------------------------------------
  67. # 反转列表
  68. list2 = ['第一', '第二', '第三', '第四', '第五', '第六']
  69. # reverse()
  70. list2.reverse()
  71. print(list2)
  73. ['第六', '第五', '第四', '第三', '第二', '第一']
  74. -----------------------------------------------
  75. # 排序
  76. # list.sort()  默认是正序排序 他有一个参数reverse
  77. list3 = ['第一', '第二', '第三', '第四', '第五', '第六']
  78. print(list3)
  79. list3.sort(reverse=True) # 汉字排序可能不准
  80. print(list3)
  82. ['第一', '第二', '第三', '第四', '第五', '第六']
  83. ['第四', '第六', '第五', '第二', '第三', '第一']
  84. ------------------------
  85. list4 = ['a', 'c', 'b', 'd', 'e', 'f']
  86. print(list4)
  87. list4.sort(reverse=True)
  88. print(list4)
  90. ['a', 'c', 'b', 'd', 'e', 'f']
  91. ['f', 'e', 'd', 'c', 'b', 'a']
  92. -------------------------
  93. list5 = [1, 5, 6, 4, 2, 3]
  94. print(list5)
  95. list5.sort() # 没有参数，默认正序
  96. print(list5)
  98. [1, 5, 6, 4, 2, 3]
  99. [1, 2, 3, 4, 5, 6]

作业

  1. 现在有 a = [1,2,3,4,5,6] 用多种方式实现列表的反转([6,5,4,3,2,1]) 并写出推导过程 ```python

    1

    a = [1,2,3,4,5,6] a.reverse() print(a)

[6, 5, 4, 3, 2, 1]

2

a = [1,2,3,4,5,6] a.sort(reverse=True) print(a)

[6, 5, 4, 3, 2, 1]

3

a = [1,2,3,4,5,6] b = [] for i in range(len(a)): b.insert(0,a[i]) print(b)

[6, 5, 4, 3, 2, 1]

4

a = [1,2,3,4,5,6] b = [] j=len(a) for i in range(len(a)): j -=1 b.append(a[j]) print(b)

[6, 5, 4, 3, 2, 1]

5

a = [1,2,3,4,5,6] print(a[::-1]) [6, 5, 4, 3, 2, 1]

  2. 2.  给 用户9次机会 猜1 - 10 个数字随机来猜数字。如果随机的数字和用户输入的数字一致则表示正确，如果不一致则表示错误。最终结果要求用户怎么也猜不对
  3. ```python
  4. # 创建一个1-10的列表
  5. # 用户输入一个数字，你就删除一个数字，同时告诉他你猜错了，请重新输入，如果有输入的同样的数字，做判断
  6. # 将删除9次的列表直接取值第一个，就是正确的数字
  7. list1 = list(range(1, 11))
  8. i = 1
  9. while i < 10:
  10.     num = int(input('请输入1-10的数字：'))
  11.     if 10 < num or num < 1:
  12.         print('输入错误，必须是0-10的数。')
  13.         continue
  14.     print('对不起，您猜错了，请继续')
  15.     list1.remove(num)
  16.     i += 1
  17. print('正确答案是%s' % list1[0])
  19. 请输入1-10的数字：1
  20. 对不起，您猜错了，请继续
  21. 请输入1-10的数字：2
  22. 对不起，您猜错了，请继续
  23. 请输入1-10的数字：3
  24. 对不起，您猜错了，请继续
  25. 请输入1-10的数字：4
  26. 对不起，您猜错了，请继续
  27. 请输入1-10的数字：5
  28. 对不起，您猜错了，请继续
  29. 请输入1-10的数字：6
  30. 对不起，您猜错了，请继续
  31. 请输入1-10的数字：7
  32. 对不起，您猜错了，请继续
  33. 请输入1-10的数字：13
  34. 输入错误，必须是0-10的数。
  35. 请输入1-10的数字：8
  36. 对不起，您猜错了，请继续
  37. 请输入1-10的数字：9
  38. 对不起，您猜错了，请继续
  39. 正确答案是10
  41. #其它方法: 创建一个空的列表，进行添加，最后在和1-10的列表进行比较，没有的那个就是正确答案
  1. 有两个列表 lst1 = [11, 22, 33] lst2 = [22, 33, 44]获取内容相同的元素 ```python lst1 = [11, 22, 33] lst2 = [22, 33, 44] for i in range(len(lst1)): for j in range(len(lst2)):
    1.  if lst1[i] == lst2[j]:
    2.      print(lst1[i])

22 33 

  2. 4. 现在有8位老师，3个办公室，要求将8位老师随机的分配到三个办公室中
  3. ```python
  4. #1 
  5. import random
  6. teacher = ['老师1', '老师2', '老师3', '老师4', '老师5', '老师6', '老师7', '老师8']
  7. room_1 = []
  8. room_2 = []
  9. room_3 = []
  11. for i in teacher:
  12.    j = random.randint(1,3)
  13.    if j == 1:
  14.        room_1.append(i)
  15.    elif j == 2:
  16.        room_2.append(i)
  17.    elif j==3:
  18.        room_3.append(i)
  19. print('Room 1: ', room_1)
  20. print('Room 2: ', room_2)
  21. print('Room 3: ', room_3)
  23. Room 1:  ['老师4', '老师6']
  24. Room 2:  ['老师1', '老师2', '老师7', '老师8']
  25. Room 3:  ['老师3', '老师5']
  27. #其它方法
  28. # 2. 先随机三个老师，添加到三个办公室中， 然后随意随机其他5位老师
  29. # 3. 直接做随机，然后判断办公室有没有为空的情况，如果为空，那么重新生成， 不为空，打印出结果