Python数据容器

定义：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
数据容器根据特点的不同，如：是否支持重复元素是否可以修改是否有序，平分为5类，分别是：列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）
列表（list）

根本语法：

1. 变量名称=[元素1,元素2,元素3,元素4,……]
2. 变量名称=[]
3. 变量名称=list()
5. 列表内每个数据，成为元素，用逗号隔开。

复制代码

注意：列表可以一次存储多个数据，也可以为不同的数据类型，支持嵌套。

1. name_list = ['张三','李四','王五']
2. print(name_list)
3. print(type(name_list))
4. my_list = ['Python',555,True]
5. print(my_list)
6. print(type(my_list))
7. lists = [[1,2,3],[4,5,6]]
8. print(lists)
9. print(type(lists))
11. 输出结果：
12. D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py
13. ['张三', '李四', '王五']
14. <class 'list'>
15. ['Python', 555, True]
16. <class 'list'>
17. [[1, 2, 3], [4, 5, 6]]
18. <class 'list'>

复制代码

列表获取特定位置的数据：

列表的索引，列表索引共有两种方式，如下所示：

如图，列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增。
我们只需要按照下标索引，即可取得对应位置的元素。

或者，可以反向索引，也就是从后向前：从-1开始，依次递减（-1、-2、-3…）
如图，从后向前，下标索引为：-1、-2、-3，依次递减。
如果列表是嵌套的列表，同样支持下标索引，在通过索引获取值时，可直接标出 2 层索引即可

1. name_list = ['张三','李四','王五']
2. lists = [[1,2,3],[4,5,6]]
3. print(name_list[0],name_list[1],name_list[2])
4. print(name_list[-1],name_list[-2],name_list[-3])
5. print(lists[0][2])
7. 输出结果：
8. D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py
9. 张三 李四 王五
10. 王五 李四 张三
11. 3

复制代码

如果使用的索引不在列表中，python 会提示错误：IndexError: list index out of range
列表的常用操纵

列表的常用操纵包括：插入元素、删除元素、清空列表、修改元素、统计元素个数 、查询元素下标

1. name_list = ['张三','李四','王五']
2. lists = [1,2,3]
3. #查找某元素的下标  index()
4. print(name_list.index('李四'))
5. #修改元素数值  直接对指定小标的值进行赋值即可
6. name_list[0] = '孙六'
7. print(name_list)
8. """
9. 插入元素
10. insert()方法：在指定下标位置，插入指定元素
11. append()方法：将指定元素追加到列表最后位置
12. extend(其他数据容器)方法：将其他数据容器的内容取出，依次追加到列表最后位置
13. """
14. name_list.insert(1,'张三')
15. print(name_list)
16. name_list.append('赵二')
17. print(name_list)
18. name_list.extend(lists)
19. print(name_list)
21. """
22. 删除元素:del 列表[下标]、列表.pop(下标)，删除某位置的列表数据
23. """
24. del name_list[0]
25. print(name_list)
26. name_list.pop(-1)
27. print(name_list)
28. #列表.remove(元素） 删除元素在列表中的第一个匹配项
29. lists.append(2)
30. print(lists)
31. lists.remove(2)
32. print(lists)
33. #清空列表内容
34. lists.clear()
35. print(lists)
36. #统计某个元素在列表中个数
37. print(name_list.count('张三'))
38. #统计列表内内容个数 len()
39. print(len(name_list))index = 0
40. while index < len(列表):
41.     元素 = 列表[index]
42.     对元素进行处理
43.     index+=1
45. for 临时变量 in 数据容器（列表）:
46.     对临时变量进行处理
48. 输出结果：
49. D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py
50. 1
51. ['孙六', '李四', '王五']
52. ['孙六', '张三', '李四', '王五']
53. ['孙六', '张三', '李四', '王五', '赵二']
54. ['孙六', '张三', '李四', '王五', '赵二', 1, 2, 3]
55. ['张三', '李四', '王五', '赵二', 1, 2, 3]
56. ['张三', '李四', '王五', '赵二', 1, 2]
57. [1, 2, 3, 2]
58. [1, 3, 2]
59. []
60. 1

复制代码

遍历列表

我们可以通过 while 循环或 for 循环对列表举行遍历

1. index = 0
2. while index < len(列表):
3.     元素 = 列表[index]
4.     对元素进行处理
5.     index+=1
7. for 临时变量 in 数据容器（列表）:
8.     对临时变量进行处理

复制代码

列表的特点：

可以容纳多个元素
可以容纳不同类型的元素（混装）
数据是有序存储的（有下标序号）
答应重复数据存在
可以修改（增加或删除元素等）
支持 for、while 循环
元组（tupe)

定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。也支持嵌套
注意：元组一旦定义完成，就不能举行修改了，元组只有一个数据时，这个数据背面要加逗号

1. name = ('张三')
2. print(type(name))
3. name = ('张三',)
4. print(type(name))
6. 输出结果：
7. D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py
8. <class 'str'>
9. <class 'tuple'>

复制代码

元组的根本操纵

1. name = ('张三','李四','王五','李四')
2. #根据所以获取元组特定位置数据
3. print(name[2])
4. print(name[-3])
5. #index() 获取元素的第一个匹配的位置
6. print(name.index('李四'))
7. #count() 统计某个数据在元组中出现的次数
8. print(name.count('李四'))
9. #len() 统计整个元组的数据个数
10. print(len(name))
12. 输出结果：
13. D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py
14. 王五
15. 李四
16. 1
17. 2
18. 4

复制代码

元组的遍历

同列表一样，元组也可以被遍历。可以使用while循环和for循环遍历它
元组的特点

可以容纳多个数据
可以容纳不同类型的数据（混装）
数据是有序存储的（下标索引）
答应重复数据存在
不可以修改（增加或删除元素等）
支持for、while 循环
字符串（str)

从容器方面来看，字符串是字符的容器，一个字符串可以放任意数目的字符
字符串的索引
和别的容器如：列表、元组一样，字符串也可以通过下标举行访问
从前向后，下标从0开始
从后向前，下标从-1开始
执字符串和元组一样，也是无法修改数据的容器，以是通过字符串 [0]=‘a’,remove(),pop(),append()等是不能举行修改的。
字符串的操纵

1. my_str = 'Python is language'
2. #index() 查找特定字符串的索引值
3. print(my_str.index('is'))
4. """
5. 字符串的替换：字符串.replace(str1,str2)
6. 将字符串内全部的str1，替换为str2
7. 注意：这个操作是得到新的字符串，不是对字符串本身修改
8. """
9. newmy_str = my_str.replace('Python', 'Java')
10. print(newmy_str)
11. print(my_str)
12. """
13. 字符串的分割：字符串.split(分隔符)
14. 按照指定的分隔符，将字符串换分为多个字符串，并存入列表对象中
15. 注意：字符串本身不变，而是得到了一个列表对象
16. """
17. newstr = my_str.split(" ")
18. print(newstr)
19. print(my_str)
20. #字符串.strip() 去除字符串前后的空格 strip还可分为lstrip()和rstrip()
21. my_str = '  Python is language  '
22. print(my_str.strip())
23. print(my_str)
24. #字符串.strip(前后指定字符串) 去除字符串前后指定的字符串，光去左或右跟strip()一样
25. my_str = '12Python is language12'
26. print(my_str.strip('12'))
27. print(my_str)
28. #统计某个字符从出现的次数 字符串.count(字符串)
29. print(my_str.count('a'))
30. #字符串的长度  len(字符串)
31. print(len(my_str))
33. 输出结果：
34. D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py
35. 7
36. Java is language
37. Python is language
38. ['Python', 'is', 'language']
39. Python is language
40. Python is language
41.   Python is language  
42. Python is language
43. 12Python is language12
44. 2
45. 22

复制代码

字符串的特点

只可以存储字符串
长度任意（取决于内存大小）
支持下标索引
答应重复字符串存在
不可以修改（增加或删除元素等）
支持for、while 循环
序列的切片

序列是指：内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以可以视为序列。

如图，序列的典型特征就是：有序并可用下标索引，字符串、元组、列表均满意这个要求。
序列的常用操纵-切片

序列支持切片，即：列表、元组、字符串，均支持举行切片操纵
切片：从一个序列中，取出一个子序列
语法：序列[起始下标:竣事下标:步长]
表现从序列中，从指定位置开始，依次取出元素，到指定位置竣事，得到一个新序列：
        起始下标表现从何处开始，可以留空，留空视作从头开始
        竣事下标（不含）表现何处竣事，可以留空，留空视作截取到结尾
            步长表现，依次取元素的隔断
            步长1表现，一个个取元素
            步长2表现，每次跳过1个元素取
            步长N表现，每次跳过N-1个元素取
            步长为负数表现，反向取（注意，起始下标和竣事下标也要反向标记）
注意：此操纵不会影响序列自己，而是会得到一个新的序列（列表、元组、字符串）

1. my_list = [1, 2, 3,4,5]
2. new_list = my_list[1:4]   # 下标1开始，下标4（不含）结束，步长1
3. print(new_list)
5. my_tuple = (1,2,3,4,5)
6. new_tuple = my_tuple[:]   #从头开始，到最后结束，步长1
7. print(new_tuple)
9. new_list = my_list[::2]   # 从头开始，到最后结束，步长2
10. print(new_list)
12. my_str = "12345"
13. new_str = my_str[:4:2]    # 从头开始，到下标4（不含）结束，步长2
14. print(new_str)
15. new_str = my_str[::-1]   # 从头（最后）开始，到尾结束，步长-1（倒序）
16. print(new_str)
17. new_list = my_list[3:1:-1]  # 从下标3开始，到下标1（不含）结束，步长-1（倒序）
18. print(new_list)
19. new_tuple = my_tuple[:1:-2]  # 从头（最后）开始，到下标1(不含)结束，步长-2（倒序）
20. print(new_tuple)
22. 输出结果：
23. D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py
24. [2, 3, 4]
25. (1, 2, 3, 4, 5)
26. [1, 3, 5]
27. 13
28. 54321
29. [4, 3]
30. (5, 3)

复制代码

集合（set)

根本语法

1. 变量名称 = {元素,元素1,元素1,……元素1}
2. 变量名称 = set()
4. name = {'张三','李四','王五','李四'}
5. print(name)
6. 输出结果：
7. D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py
8. {'李四', '王五', '张三'}

复制代码

由上述结果可知，集合内部是去重且无序的
集合的根本操纵

1. my_set = {"hello","world"}
2. print(my_set)
3. print("--------------------------------")
4. #集合.add(元素)  新增集合元素，将指定元素加入集合内  同时集合本身被修改
5. my_set.add("python")
6. print(my_set)
7. print("--------------------------------")
8. #集合.remove()  将指定元素从集合中移除  同时集合本身被修改
9. my_set.remove("world")
10. print(my_set)
11. print("--------------------------------")
12. #集合.pop() 从集合中随机取出一个元素  会得到一个元素的结果。同时集合本身被修改，元素被移除
13. my_set.pop()
14. print(my_set)
15. print("--------------------------------")
16. #集合.clear() 清空集合
17. my_set.clear()
18. print(my_set)
19. print("--------------------------------")
20. """
21. 取出2个集合的差集
22. 集合1.difference(集合2)，功能：取出集合1和集合2的差集（集合1有而集合2没有的）
23. 得到一个新集合，集合1和集合2不变
24. """
25. set1 = {1,2,3,5}
26. set2 = {4,5,6,7}
27. set3 = set1.difference(set2)
28. print(set1)
29. print(set2)
30. print(set3)
31. print("--------------------------------")
32. """
33. 消除2个集合的差集
34. 集合1.difference_update(集合2)
35. 对比集合1和集合2，在集合1内，删除和集合2相同的元素。
36. 集合1被修改，集合2不变
37. """
38. set1.difference_update(set2)
39. print(set1)
40. print(set2)
41. print("--------------------------------")
42. """
43. 2个集合合并
44. 集合1.union(集合2)
45. 将集合1和集合2组合成新集合
46. 得到新集合，集合1和集合2不变
47. """
48. set1 = {1,2,3,5}
49. set2 = {4,5,6,7}
50. set3 = set1.union(set2)
51. print(set1)
52. print(set2)
53. print(set3)
54. print("--------------------------------")
55. #查看集合的元素数量 len()
56. print(len(set3))
58. 输出结果：
59. D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py
60. {'world', 'hello'}
61. --------------------------------
62. {'world', 'python', 'hello'}
63. --------------------------------
64. {'python', 'hello'}
65. --------------------------------
66. {'hello'}
67. --------------------------------
68. set()
69. --------------------------------
70. {1, 2, 3, 5}
71. {4, 5, 6, 7}
72. {1, 2, 3}
73. --------------------------------
74. {1, 2, 3}
75. {4, 5, 6, 7}
76. --------------------------------
77. {1, 2, 3, 5}
78. {4, 5, 6, 7}
79. {1, 2, 3, 4, 5, 6, 7}
80. --------------------------------
81. 7

复制代码

集合的特点

可以容纳多个数据
可以容纳不同类型的数据（混装）
数据是无序存储的（不支持索引）
不答应重复数据存在
可以修改（增加或删除元素等）
支持for循环，不支持 while 循环
字典（dict)

定义和语法

字典同样使用{}，不外存储的元素是一个个的：键值对

1. my_dict = {key:value,key:value,key:value……}
2. my_dict = {}
3. my_dict = dict()

复制代码

语法：
使用{}存储原始，每一个元素是一个键值对
每一个键值对包含Key和Value（用冒号分隔）
键值对之间使用逗号分隔
Key和Value可以是任意类型的数据（key不可为字典）
Key不可重复，重复会对原有数据覆盖
字典同集合一样，不可以使用索引，但是字典可以通过Key值来取得对应的Value
字典的Key和Value可以是任意数据类型（Key不可为字典）
字典的常用操纵

1. my_scors = {"张三":"77","李四":"88","王五":"99"}
2. print(my_scors)
3. print("--------------------------------------------")
4. # 新增元素         字典[Key] = Value，结果：字典被修改，新增了元素
5. my_scors["赵六"] = 100
6. print(my_scors)
7. print("--------------------------------------------")
8. #更新元素   语法：字典[Key] = Value，结果：字典被修改，元素被更新
9. #字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值
10. my_scors["张三"] = 85
11. print(my_scors)
12. print("--------------------------------------------")
13. #删除元素 字典.pop(Key)，结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除
14. my_scors.pop("赵六")
15. print(my_scors)
16. print("--------------------------------------------")
17. #清空字典 字典.clear()，结果：字典被修改，元素被清空
18. my_scors.clear()
19. print(my_scors)
20. print("--------------------------------------------")
21. #获取全部的Key  字典.keys()，结果：得到字典中的全部Key
22. my_scors = {"张三":"77","李四":"88","王五":"99"}
23. keys = my_scors.keys()
24. print(keys)
25. print("--------------------------------------------")
26. #遍历字典 for key in 字典.keys()
27. for key in keys:
28.     print(key)
29. print("--------------------------------------------")
30. #计算字典内的全部元素（键值对）数量 len(字典） 得到一个整数，表示字典内元素（键值对）的数量
31. print(len(my_scors))
33. 输出结果：
34. D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py
35. {'张三': '77', '李四': '88', '王五': '99'}
36. --------------------------------------------
37. {'张三': '77', '李四': '88', '王五': '99', '赵六': 100}
38. --------------------------------------------
39. {'张三': 85, '李四': '88', '王五': '99', '赵六': 100}
40. --------------------------------------------
41. {'张三': 85, '李四': '88', '王五': '99'}
42. --------------------------------------------
43. {}
44. --------------------------------------------
45. dict_keys(['张三', '李四', '王五'])
46. --------------------------------------------
47. 张三
48. 李四
49. 王五
50. --------------------------------------------
51. 3

复制代码

字典的特点

可以容纳多个数据
可以容纳不同类型的数据
每一份数据是KeyValue键值对
可以通过Key获取到Value，Key不可重复（重复会覆盖）
不支持索引
可以修改（增加或删除更新元素等）
支持for循环，不支持while循环
数据容器对比总结

数据容器可以从以下视角举行简朴的分类：
是否支持索引：
支持：列表、元组、字符串 - 序列类型
不支持：集合、字典 - 非序列类型
是否支持重复元素：
支持：列表、元组、字符串 - 序列类型
不支持：集合、字典 - 非序列类型
是否可以修改
支持：列表、集合、字典
不支持：元组、字符串

容器通用排序功能

sorted(容器, [reverse=True]) 将给定容器举行排序，排序后都会得到 list 对象

1. my_list = [1,3,4,5]
2. my_tuple = (1,3,4,5)
3. my_set = {1,3,4,5}
4. my_str = '1345'
5. my_dict = {'a':1,'b':3,'c':2}
6. print("-------------------list-----------------")
7. print(type(my_list))
8. my_list = sorted(my_list,reverse=True)
9. print(my_list)
10. print(type(my_list))
11. print("-------------------tuple-----------------")
12. print(type(my_tuple))
13. my_tuple = sorted(my_tuple,reverse=True)
14. print(my_tuple)
15. print(type(my_tuple))
16. print("-------------------set-----------------")
17. print(type(my_set))
18. my_set = sorted(my_set,reverse=True)
19. print(my_set)
20. print(type(my_set))
21. print("-------------------dict-----------------")
22. print(type(my_dict))
23. my_dict = sorted(my_dict,reverse=True)
24. print(my_dict)
25. print(type(my_dict))
26. print("-------------------str-----------------")
27. print(type(my_str))
28. my_str = sorted(my_str,reverse=True)
29. print(my_str)
30. print(type(my_str))
32. 输出结果:
33. D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py
34. -------------------list-----------------
35. <class 'list'>
36. [5, 4, 3, 1]
37. <class 'list'>
38. -------------------tuple-----------------
39. <class 'tuple'>
40. [5, 4, 3, 1]
41. <class 'list'>
42. -------------------set-----------------
43. <class 'set'>
44. [5, 4, 3, 1]
45. <class 'list'>
46. -------------------dict-----------------
47. <class 'dict'>
48. ['c', 'b', 'a']
49. <class 'list'>
50. -------------------str-----------------
51. <class 'str'>
52. ['5', '4', '3', '1']
53. <class 'list'>

复制代码

通用功能

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。