python 列表、元组、字典

偏执的太偏执、 2022-07-26 05:05 263阅读 0赞

Python基本数据结构:列表，元组及字典

一、列表

一组有序项目的集合。可变的数据类型【可进行增删改查】

列表是以方括号“\[\]”包围的数据集合，不同成员以“,”分隔。

列表中可以包含任何数据类型，也可包含另一个列表

列表可通过序号访问其中成员

常用列表操作：

list.append()追加成员，成员数据

list.pop()删除成员,删除第i个成员

list.count(x)计算列表中参数x出现的次数

list.remove()删除列表中的成员，直接删除成员i

list.extend(L)向列表中追加另一个列表L

list.reverse()将列表中成员的顺序颠倒

list.index(x)获得参数x在列表中的位置

list.sort()将列表中的成员排序

list.insert()向列表中插入数据insert(a,b)向列表中插入数据

倒序排序

b.sort(reverse=True)

print(b)

可通过

>>>help(list) 查看方法详情

**\[python\]**  [view plain][]   [copy][view plain]   [print][view plain] [?][view plain]

1.  print("-------list operations------")  
2.  \#列表操作  
3.  l = \[1,2,3,4,5\]  
4.  l2 = \[7,8,9\]  
5.  print(l)  
6.  \#获得列表长度  
7.  length = len(l)  
8.  print(length)  
9.  \#追加一个元素,在列表最后一位  
10. l.append(6)  
11. print(l)  
12. \#向列表中追加另一个列表  
13. l.extend(l2)  
14. print(l)  
15. \#插入一个元素，在位置a  
16. l.insert(0,0)  
17. print(l)  
18. \#将列表顺序颠倒  
19. l.reverse()  
20. print(l)  
21. \#排序,从小到大  
22. l.sort()  
23. print(l)  
24. \#统计某个元素出现的次数  
25. c = l.count(0)  
26. print(c)  
27. \#查找某个参数在列表中的位置,未命中则抛异常  
28. i = l.index(1)  
29. print(i)  
30. \#删除某个位置的成员  
31. l.pop(0)  
32. print(l)  
33. l.append(1)  
34. \#直接删除某个值的成员,若有多个，删除第一个  
35. l.remove(1)  
36. print(l)

结果:

![0_1302367857LV7j.gif][]

列表补充:2011-4-17

**\[c-sharp\]**  [view plain][]   [copy][view plain]   [print][view plain] [?][view plain]

1.  \#列表操作补充--切片操作  
2.  example = \[0,1,2,3,4,5,6,7,8,9\]  
3.  \#打印某一区间 左闭右开  
4.  print(example\[4:8\])  
5.  \#想包含最后一个  
6.  print(example\[4:\])  
7.  \#包含首个  
8.  print(example\[:8\])  
9.  \#所有的  
10. print(example\[:\])  
11.  
12. \#第三个参数为步长  
13. print(example\[1:8:2\])  
14. \#倒序输出  
15. print(example\[::-1\])  
16.  
17. \#列表合并  
18. a = \[1,2,3\]  
19. b = \[4,5,6\]  
20. print(a+b)  
21.  
22.  
23.  
24. \#替换  
25. ex = \[1,2,3,4,5,6\]  
26. ex\[4:\]=\[9,8,7\]  
27. print(ex)\#将56换为987  
28. \#插入  
29. ex\[1:1\] = \[0,0,0\]  
30. print(ex)  
31. \#删除  
32. del ex\[0:2\]  
33. print(ex)  
34. \#或者  
35. ex\[6:\]=\[\]  
36. print(ex)  
37.  
38.  
39. \#比较  
40. one = \[1,2,3\]  
41. two = \[1,2,3\]  
42. print(one == two)\#true  
43. print(one is two)\#false  
44.  
45. \#列表操作补充——字符串也是列表  
46. str = "abcdefg"  
47. print(str\[0\])  
48.  
49. \#将一个字符串转为字符数组  
50. print(list(str))  
51.  
52.  
53. \#字符串  
54. s = "abcdefg"  
55. \#判断是否包含  
56. print('a' in s)  
57.  
58. \#函数和模块  
59. import math  
60. \#将一个变量指向一个函数  
61. se = math.sqrt  
62. print(se(81))

结果：

![0_1303047402n55S.gif][]

二、元组

不可变序列

元组是以圆括号“()”包围的数据集合，不同成员以“,”分隔

与列表不同：元组中数据一旦确立就不能改变

通过下标进行访问

声明：

L=(1,2,3)

含0个元素的元组: L = ()

含1个元素的元组:L=(1,) 注意有逗号

**\[python\]**  [view plain][]   [copy][view plain]   [print][view plain] [?][view plain]

1.  \#元组操作  
2.  \#声明  
3.  o =('a','b','c',('d1','d2'))  
4.  o1 = ()  
5.  o2 = (1,)  
6.  \#访问  
7.  print(o\[0\])  
8.  print(o\[3\]\[0\])  
9.  \#用于打印语句  
10. age = 22  
11. name = 'tom'  
12. print("%s is %d years old"%(name,age))

![0_13023679367dAI.gif][]

三、字典

键值对的集合(map)

字典是以大括号“\{\}”包围的数据集合

与列表区别：字典是无序的，在字典中通过键来访问成员。

字典是可变的，可以包含任何其他类型

声明:

M=\{k1:v1,k2:v2\}

访问 M\[k1\]将得到v1

常用字典操作：

dic.clear()清空字典

dic.keys()获得键的列表

dic.values()获得值的列表

dic.copy()复制字典

dic.pop(k)删除键k

dic.get(k)获得键k的值

dic.update()更新成员，若成员不存在，相当于加入

dic.items()获得由键和值组成的列表

dic.popitem

可以通过

>>>help(dict) 查看详情

**\[python\]**  [view plain][]   [copy][view plain]   [print][view plain] [?][view plain]

1.  \#字典操作  
2.  m = \{ 'a':1,'b':2,'c':3\}  
3.  print(m)  
4.  \#读取某一个\_通过key  
5.  print(m\['a'\])  
6.  \#读取某一个，通过get方法  
7.  print(m.get('b'))  
8.  \#复制字典  
9.  m2 = m.copy()  
10. print(m2)  
11. \#获取所有键的列表  
12. print( m.keys() )  
13. \#获取所有值的列表  
14. print( m.values() )  
15. \#获取所有键值对元组组成的列表  
16. print( m.items() )  
17. \#更新成员，当对应键值不存在时，相当于加入  
18. m.update(\{ 'd':4\})  
19. print(m)  
20. \#删除某个成员  
21. m.pop('a')  
22. print(m)

![0_1302368022G2s1.gif][]

列表、元组、字典 删除时候都可以用del a\[0\] 方式

四、序列的索引和切片

列表、元组和字符串都是序列

序列的两个主要特点是**索引**操作符和**切片**操作符。

索引操作符让我们可以从序列中抓取一个特定项目。即下标操作，用方括号和数字抓取某个位置的项目,L\[0\]抓取第一个元素，L\[-1\]抓取最后一个元素

切片操作符让我们能够获取序列的一个切片，即一部分序列。方括号加一对可选数字，切出某个子片L\[1:3\] 返回1-2的子片，L\[2:\]从2开始到最后，L\[:\]整个

原文地址：[http://blog.csdn.net/wklken/article/details/6312888][http_blog.csdn.net_wklken_article_details_6312888]

[view plain]: http://blog.csdn.net/wklken/article/details/6312888#
[0_1302367857LV7j.gif]: /images/20220724/28397fe8980047c98f9caeab3c0849b2.png
[0_1303047402n55S.gif]: /images/20220724/fc492fba362b473d97051b070c8efb2c.png
[0_13023679367dAI.gif]: /images/20220724/451101540e934545832ec17a77d39d72.png
[0_1302368022G2s1.gif]: /images/20220724/9de101850cbc45d6a2fa403e71be1e40.png
[http_blog.csdn.net_wklken_article_details_6312888]: http://blog.csdn.net/wklken/article/details/6312888