python中的列表和元组

阳光穿透心脏的1/2处 2023-02-14 13:25 111阅读 0赞

python中的列表和元组

列表和数组

区别：列表可变，而元组不可变。（包含的元素是否可更改）

创建：

  1. # 定义列表
  2. my_list = ['01','demo',3]
  4. # 定义元组
  5. my_tuple = ('01','demo',3)

通用用法：

只要不涉及改变元素的操作，列表和元素的用法是通用的。

（1）通过索引使用元素

索引从0开始，也支持负数索引（从-1开始）

  1. my_list = ['01','demo',3]
  2. print(my_list[0])    # 01
  4. my_tuple = ('01','demo',3)
  5. print(my_tuple[-1]) # 3

（2）序列切片

语法格式为：[start : end : step]从start到end切片，但不包括end； step为步长，默认为1，若为负数则无意义

  1. my_list = [1,2,3,4,5,6,7,8]
  2. print(my_list[2:5]) # [3,4,5]
  4. my_tuple = (1,2,3,4,5,6,7,8)
  5. print(my_tuple[3:9:3]) # (4,7)

（3）加法

两个列表或元组所包含的元素的总和。列表和元组不能相加。

  1. my_list1 = [1,2,3]
  2. my_list2 = [4,5,6]
  3. my_list3 = my_list1 + my_list2
  4. print(my_list3)    # [1, 2, 3, 4, 5, 6]

（4）乘法

列表和元组包含的元素重复N次。

  1. my_list = [1,2,'a']
  2. my_list2 = my_list * 3
  3. print(my_list2)    # [1, 2, 'a', 1, 2, 'a', 1, 2, 'a']

（5）in运算符

判断列表或元组是否包含某元素。

  1. my_tuple = (1,2,'3',4,'5')
  2. print(2 in my_tuple)    #True

（6）长度、最大值和最小值

传给max()、min()函数的元组、列表的元素必须是相同类型且可以比较大小。

  1. my_list = [1,2,3,4,5]
  2. print(max(my_list))    # 5
  4. my_tuple = ('a','b','3')
  5. print(min(my_tuple))    # 3
  6. print(len(my_tuple))    # 3

（7）序列封包和序列解包

序列封包：程序把多个值赋给一个变量时，自动将多个值封装为元组。

序列解包：程序允许将序列直接赋给多个变量，各元素会被依次赋值给每个变量（要求序列的元素个数和变量个数相等）

  1. vals = 1,2,3,4,5
  2. print(type(vals))    # <class 'tuple'>
  4. my_tuple = tuple(range(1,10,2))
  5. print(my_tuple)    # (1, 3, 5, 7, 9)
  6. a,b,c,d,e = my_tuple
  7. print(a,b,c,d,e) # 1 3 5 7 9
  9. x,y,z = 1,2,3
  10. print(x,y,z) # 1 2 3
  12. xyz = 4,5,6
  13. x,y,z = xyz
  14. print(x,y,z)    # 4 5 6
  16. # 交换变量的值
  17. x,y,z = y,z,x
  18. print(x,y,z)    # 5 6 4
  20. first,second,*rest = range(10)
  21. print(first) # 0
  22. print(second)    # 1
  23. print(rest,type(rest)) # [2, 3, 4, 5, 6, 7, 8, 9], <class 'list'>

使用列表

（1）创建列表

  1. my_tuple = (1,2,'3',4,5)
  2. my_list = list(my_tuple)
  3. print(my_list,type(my_list))    # [1, 2, '3', 4, 5] <class 'list'>
  5. my_range = range(1,5)
  6. my_list2 = list(my_list2)
  7. print(my_list2,type(my_list2))    # [1, 2, 3, 4] <class 'list'>

（2）增加列表元素

append()会把传入的参数追加到列表最后面。可以接受单个值、列表、元组等，但只把元组、列表当成单个元素。

  1. my_list = [1,2,3,'4','5']
  2. my_list.append(6)
  3. print(my_list)    # [1, 2, 3, '4', '5', 6]
  5. my_tuple = ('a','b','c')
  6. my_list.append(my_tuple)
  7. print(my_list)    # [1, 2, 3, '4', '5', 6, ('a', 'b', 'c')]

如果不希望追加的列表被当成一个整体而是增加列表中的元素时，可使用extend()方法。

  1. my_list = [1,2,3]
  2. my_list2 = ['a','b','c']
  3. my_list.extend(my_list2)
  4. print(my_list)    # [1, 2, 3, 'a', 'b', 'c']
  6. my_list.extend(range(3,10))
  7. print(my_list)    # [1, 2, 3, 'a', 'b', 'c', 3, 4, 5, 6, 7, 8, 9]

insert()可以在列表中增加元素，并制定插入的位置。

  1. my_list = [1,2,3]
  2. my_list.insert(2,'a')
  3. print(my_list)    # [1, 2, 'a', 3]
  5. my_tuple = ('b','c','d')
  6. my_list.insert(3,my_tuple)
  7. print(my_list)    # [1, 2, 'a', ('b', 'c', 'd'), 3]

（3）删除列表元素

del可用于删除列表中的元素，也可删除列表中的中间一段，也可用于删除变量。

  1. my_list = [1,2,(3,4,5),'a','b','c']
  2. del my_list[2]
  3. print(my_list)    # [1, 2, 'a', 'b', 'c']
  5. del my_list[3:5]
  6. print(my_list)    # [1, 2, 'a']
  8. my_list2 = list(range(1,10))
  9. del my_list2[2:-2:2]
  10. print(my_list2)    # [1, 2, 4, 6, 8, 9]

del删除变量。

  1. num = 10
  2. del num
  3. print(num)    # NameError: name 'num' is not defined

remove()删除匹配到的第一个列表元素。

  1. my_list = [1,2,3,1,1,4,'5']
  2. my_list.remove(1)
  3. print(my_list)    # [2, 3, 1, 1, 4, '5']

clear()清空列表的所有元素。

  1. my_list.clear()
  2. print(my_list)    # []

（4）修改列表元素

通过索引修改列表元素（正数索引、负数索引）

  1. my_list = [1,2,'a','b']
  2. my_list[-2] = 3
  3. print(my_list)    # [1, 2, 3, 'b']

通过slice()对列表其中一部分赋值，不要求新赋值元素个数与原来元素个数相等，这样既可为列表增加元素，亦可为列表删除元素。

  1. my_list = list(range(1,5))
  2. my_list[1:3] = ['a','b']
  3. print(my_list)    # [1, 'a', 'b', 4]

插入元素。

  1. my_list = list(range(1,5))
  2. my_list[1:3] = ['a','b','c','d','e']
  3. print(my_list)    # [1, 'a', 'b', 'c', 'd', 'e', 4]

删除元素。

  1. my_list = list(range(1,5))
  2. my_list[1:3] = []
  3. print(my_list)    # [1, 4]

使用字符串赋值会自动把字符串当成序列处理，其中每个字符都是一个元素。

  1. my_list = list(range(1,5))
  2. my_list[1:3] = 'fltenwall'
  3. print(my_list)    # [1, 'f', 'l', 't', 'e', 'n', 'w', 'a', 'l', 'l', 4]

使用slice赋值时，也可指定step参数，要求所赋值的列表元素个数与所替换的列表元素个数相等。

  1. my_list = list(range(1,10))
  2. my_list[2:9:2] = ['a','b','c','d']
  3. print(my_list)    # [1, 2, 'a', 4, 'b', 6, 'c', 8, 'd']

（5）列表其他常用方法

dir(list)可看到列表包含的所有方法。

count用于统计列表中某个元素出现的次数。

  1. my_list = [1,2,3,2,1,'1','2',3,2,1]
  2. print(my_list.count(2))    # 3

index()用于定位某个元素在列表中出现的位置，可传入start、end参数，用于在列表的指定范围内搜索元素。

  1. print(my_list.index(3,1,8))    # 2

pop()与append()

  1. stack = []
  2. stack.append('a')
  3. stack.append('b')
  4. stack.append('c')
  5. print(stack)    # ['a', 'b', 'c']
  7. stack.pop()    # 'c'
  8. print(stack)    # ['a', 'b']

reverse()将列表中所有元素顺序反转。

  1. my_list = list(range(1,10))
  2. my_list.reverse()
  3. print(my_list)    # [9, 8, 7, 6, 5, 4, 3, 2, 1]

sort()用于列表元素进行排序。

  1. my_list = [1,7,3,5,6,2]
  2. my_list.sort()
  3. print(my_list)    # [1, 2, 3, 5, 6, 7]

sort()可传入key和reverse两个参数，这两个参数必须通过参数名指定。key为每个元素都生成一个比较大小的“键”，reverse用于执行是否需要反转排序，默认从小到大。

  1. my_list = ['python','go','java','ruby','lua']
  2. my_list.sort(key=len,reverse=True)
  3. print(my_list)    # ['python', 'java', 'ruby', 'lua', 'go']

发表评论

表情：
评论列表 （有 0 条评论，111人围观）

还没有评论，来说两句吧...

相关阅读