2.1 Python列表与元组

1、列表与元组

（1）序列与列表与元组的关系和创建

1. 序列

   列表可变，元组不可变、字符串不可变（程序无法修改元组内包含的元素，无法修改字符串包含的字符）

2. 创建列表和元组

   • 列表用 list() 创建；元组用 tuple() 创建

     my_list = list(range(2, 10))
     print(my_list)
     
     my_tuple = tuple(range(4, 8))
     print(my_tuple)
     

     [2, 3, 4, 5, 6, 7, 8, 9]
     (4, 5, 6, 7)

     list_1 = list(my_tuple)       # 将 list 转成 tuple
     print(list_1)
      
     tuple_1 = tuple(my_list)      # 将 tuple 转成 list 
     print(tuple_1)
     

     [4, 5, 6, 7]
     (2, 3, 4, 5, 6, 7, 8, 9)

   • 创建列表：[ele1, ele2, ele3, …]；创建元组：(ele1, ele2, ele3, …)

     my_list = [2, 3, 'python', 3.4]
     my_tuple = (3.4, 100, 'python')
     
     print(my_list, type(my_list))
     print(my_tuple, type(my_tuple))
     

     [2, 3, ‘python’, 3.4]
     (3.4, 100, ‘python’)

     single_tuple_1 = (3.4)
     print(single_tuple_1, type(single_tuple_1))
     
     single_tuple_2 = (3.4,)     # 创建的元组只有一个元素，需要在元素后添加逗号
     print(single_tuple_2, type(single_tuple_2))
     

     3.4
     (3.4,)

（2）列表和元组的简单使用

1. 通过索引访问元素

   索引位置：
   
   索引在 -len~len-1 之间，len为序列长度。

2. 子序列

   slice（分片、切片）：[start: end: step]

3. 序列运算

   • 加法：元素拼接

     list1 = [20, 'python']
     list2 = list(range(4))
     print(list1+list2)           # 列表相加，将元素拼接
     
     tuple1 = (20, 'python')
     tuple2 = tuple(range(4))
     print(tuple1+tuple2)         # 列表相加，将元素拼接
     

     [20, ‘python’, 0, 1, 2, 3]
     (20, ‘python’, 0, 1, 2, 3)

   • 乘法：元素重复N次，N为被乘的倍数

     list1 = ['a', 1, 2]
     print(list1*3)
     

     [‘a’, 1, 2, ‘a’, 1, 2, ‘a’, 1, 2]

   • in 运算：是否包含元素

     list1 = ['a', 1, 2]
     print('a' in list1)
     print(3 in list1)
     

     True
     False

（3）序列相关函数与封包解包

1. 最大值、最小值、长度

   max()、min()、len()函数获取列表、元组的最大值、最小值、长度。

2. 序列解包与封包

   • 封包：将多个值赋值给一个变量时，python会自动将多个值封装成元组。

     mydata = 10, 20, 'python'
     print(mydata, type(mydata))
     

     (10, 20, ‘python’)

   • 解包：序列（元组或列表等）可被直接赋值给多个变量，此时序列的各个元素会依次赋值给每个变量（要求序列的元素个数和变量个数相等）。

     data1, data2, data3 = mydata
     print(data1, data2, data3)
     
     a, b, c, d = range(10, 14)
     print(a, b, c, d)
     

     10 20 python
     10 11 12 13

     mytuple = (10, 20, 'python', 'java')
     first, *rest = mytuple           # 只解包第一个值，其余值可用带 * 的变量来接受
     print(first)
     print(rest)
     

     10
     [20, ‘python’, ‘java’]

     first, second, *rest = mytuple   # 只解包第一个值和第二个值，其余值可用带 * 的变量来接受
     print(first)
     print(second)
     print(rest)
     

     10
     20
     [‘python’, ‘java’]

     first, *rest, last = mytuple    # 只解包第一个值和最后一个值，其余值可用带 * 的变量来接受
     print(first)
     print(rest)
     print(last)
     

     10
     [20, ‘python’]
     java

     a, b, *c = 'python'
     print(a)
     print(b)
     print(c)
     

     p
     y
     [‘t’, ‘h’, ‘o’, ‘n’]

   • python多变量赋值机制

     1. 将右边的多个值封包成元组
     2. 元组被解包依次对左边变量赋值

     a, b, c =10, 20, 'python'
     print(a)
     print(b)
     print(c)
     

     10
     20
     python

（4）列表的用法及操作列表元素

1. 添加、删除、替换元素

   • 添加

     • append() 方法将传入的参数追加到列表的后面，当传入的参数为列表（序列）时，该列表（序列）被当成一个元素。

       my_list = ['python', 'java']
       
       my_list.append('c')
       print(my_list)
       
       my_list.append(tuple(range(2, 4)))
       
       print(my_list)
       

       [‘python’, ‘java’, ‘c’]

       [‘python’, ‘java’, ‘c’, (2, 3)]

     • extend() 方法用户追加另一个列表（序列），将列表（序列）中的元素追加进来。

       my_list.extend(range(10, 12))
       print(my_list)
       

       [‘python’, ‘java’, ‘c’, (2, 3), 10, 11]

       my_list.extend('abc')
       print(my_list)
       

       [‘python’, ‘java’, ‘c’, (2, 3), 10, 11, ‘a’, ‘b’, ‘c’]

     • insert() 方法将元素插入列表指定位置。

       my_list.insert(3, 'c++')
       print(my_list)
       

       [‘python’, ‘java’, ‘c’, ‘c++’, (2, 3), 10, 11, ‘a’, ‘b’, ‘c’]

   • 删除

     • del 语句可删除列表元素（可删除列表中单个元素，也可删除中间一段），也可删除变量等。

       my_list = ['python', 'java', 'c','c++']
       
       del my_list[2]       # 删除第 3 个元素
       print(my_list)
       
       del my_list[1:3]    # 删除第 2 个到第 3 个
       print(my_list)
       

       [‘python’, ‘java’, ‘c++’]

       [‘python’]

       my_list = list(range(10))
       
       del my_list[1: 8: 2] 
       print(my_list)
       

       [0, 2, 4, 6, 8, 9]

     • remove() 删除找到的第一个元素。

   • 替换

     my_list = ['python', 'java', 'c','c++']
     my_list[1] = 10
     print(my_list)
     

     [‘python’, 10, 20, 30, 40]

     # 被替换部分只有 2 个元素，替换成 3 个元素，实际上增加了元素
     my_list[2: 4] = [20, 30, 40]
     print(my_list)
     

     [‘python’, 10, 20, 30, 40]

     # 被替换部分有 3 个元素，替换成 2 个元素，实际上删除了元素
     my_list[2: 5] = ['a', 'b']
     print(my_list)
     

     [‘python’, 10, ‘a’, ‘b’]

     # 当对列表中一段进行赋值字符串时，会把字符串当成列表处理
     my_list[2: 4] = 'xyz'
     print(my_list)
     

     [‘python’, 10, ‘x’, ‘y’, ‘z’]

2. 列表常用方法

   使用 dir(list) 查看支持列表的方法：

   方法名	说明
   count()	统计某个元素的出现次数
   index()	判断某个元素的出现位置
   pop()	将列表当成“栈”使用，实现元素出栈功能
   reverse()	将列表中元素反向存放
   sort()	对列表元素进行排序

   my_list = ['python', 'java', 'c','c++']
   
   print(my_list.index('java'))        # 判断元素位置
   
   my_list.reverse()        # 反转
   print(my_list)
   
   my_list.sort()           # 排序
   print(my_list)
   

   1
   [‘c++’, ‘c’, ‘java’, ‘python’]

   [‘c’, ‘c++’, ‘java’, ‘python’]