Python数据容器

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

列表（list）

基本语法：

变量名称=[元素1,元素2,元素3,元素4,……]
变量名称=[]
变量名称=list()

列表内每个数据，成为元素，用逗号隔开。

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

name_list = ['张三','李四','王五']
print(name_list)
print(type(name_list))
my_list = ['Python',555,True]
print(my_list)
print(type(my_list))
lists = [[1,2,3],[4,5,6]]
print(lists)
print(type(lists))

输出结果：
D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py 
['张三', '李四', '王五']
<class 'list'>
['Python', 555, True]
<class 'list'>
[[1, 2, 3], [4, 5, 6]]
<class 'list'>

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

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

如图，列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次递增。
我们只需要按照下标索引，即可取得对应位置的元素。
或者，可以反向索引，也就是从后向前：从-1开始，依次递减（-1、-2、-3…）
如图，从后向前，下标索引为：-1、-2、-3，依次递减。
如果列表是嵌套的列表，同样支持下标索引，在通过索引获取值时，可直接标出 2 层索引即可

name_list = ['张三','李四','王五']
lists = [[1,2,3],[4,5,6]]
print(name_list[0],name_list[1],name_list[2])
print(name_list[-1],name_list[-2],name_list[-3])
print(lists[0][2])

输出结果：
D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py 
张三 李四 王五
王五 李四 张三
3

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

列表的常用操作

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

name_list = ['张三','李四','王五']
lists = [1,2,3]
#查找某元素的下标  index()
print(name_list.index('李四'))
#修改元素数值  直接对指定小标的值进行赋值即可
name_list[0] = '孙六'
print(name_list)
"""
插入元素
insert()方法：在指定下标位置，插入指定元素
append()方法：将指定元素追加到列表最后位置
extend(其他数据容器)方法：将其他数据容器的内容取出，依次追加到列表最后位置
"""
name_list.insert(1,'张三')
print(name_list)
name_list.append('赵二')
print(name_list)
name_list.extend(lists)
print(name_list)

"""
删除元素:del 列表[下标]、列表.pop(下标)，删除某位置的列表数据
"""
del name_list[0]
print(name_list)
name_list.pop(-1)
print(name_list)
#列表.remove(元素） 删除元素在列表中的第一个匹配项
lists.append(2)
print(lists)
lists.remove(2)
print(lists)
#清空列表内容
lists.clear()
print(lists)
#统计某个元素在列表中个数
print(name_list.count('张三'))
#统计列表内内容个数 len()
print(len(name_list))index = 0 
while index < len(列表):
    元素 = 列表[index]
    对元素进行处理
    index+=1

for 临时变量 in 数据容器（列表）:
    对临时变量进行处理

输出结果：
D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py 
1
['孙六', '李四', '王五']
['孙六', '张三', '李四', '王五']
['孙六', '张三', '李四', '王五', '赵二']
['孙六', '张三', '李四', '王五', '赵二', 1, 2, 3]
['张三', '李四', '王五', '赵二', 1, 2, 3]
['张三', '李四', '王五', '赵二', 1, 2]
[1, 2, 3, 2]
[1, 3, 2]
[]
1

遍历列表

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

index = 0 
while index < len(列表):
    元素 = 列表[index]
    对元素进行处理
    index+=1

for 临时变量 in 数据容器（列表）:
    对临时变量进行处理

列表的特点：

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

元组（tupe)

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

name = ('张三')
print(type(name))
name = ('张三',)
print(type(name))

输出结果：
D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py 
<class 'str'>
<class 'tuple'>

元组的基本操作

name = ('张三','李四','王五','李四')
#根据所以获取元组特定位置数据
print(name[2])
print(name[-3])
#index() 获取元素的第一个匹配的位置
print(name.index('李四'))
#count() 统计某个数据在元组中出现的次数
print(name.count('李四'))
#len() 统计整个元组的数据个数
print(len(name))

输出结果：
D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py 
王五
李四
1
2
4

元组的遍历

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

元组的特点

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

字符串（str)

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

字符串的操作

my_str = 'Python is language'
#index() 查找特定字符串的索引值
print(my_str.index('is'))
"""
字符串的替换：字符串.replace(str1,str2)
将字符串内全部的str1，替换为str2
注意：这个操作是得到新的字符串，不是对字符串本身修改
"""
newmy_str = my_str.replace('Python', 'Java')
print(newmy_str)
print(my_str)
"""
字符串的分割：字符串.split(分隔符)
按照指定的分隔符，将字符串换分为多个字符串，并存入列表对象中
注意：字符串本身不变，而是得到了一个列表对象
"""
newstr = my_str.split(" ")
print(newstr)
print(my_str)
#字符串.strip() 去除字符串前后的空格 strip还可分为lstrip()和rstrip()
my_str = '  Python is language  '
print(my_str.strip())
print(my_str)
#字符串.strip(前后指定字符串) 去除字符串前后指定的字符串，光去左或右跟strip()一样
my_str = '12Python is language12'
print(my_str.strip('12'))
print(my_str)
#统计某个字符从出现的次数 字符串.count(字符串)
print(my_str.count('a'))
#字符串的长度  len(字符串)
print(len(my_str))

输出结果：
D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py 
7
Java is language
Python is language
['Python', 'is', 'language']
Python is language
Python is language
  Python is language  
Python is language
12Python is language12
2
22

字符串的特点

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

序列的切片

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

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

序列的常用操作-切片

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

my_list = [1, 2, 3,4,5]
new_list = my_list[1:4]   # 下标1开始，下标4（不含）结束，步长1
print(new_list)

my_tuple = (1,2,3,4,5)
new_tuple = my_tuple[:]   #从头开始，到最后结束，步长1
print(new_tuple)

new_list = my_list[::2]   # 从头开始，到最后结束，步长2
print(new_list)

my_str = "12345"
new_str = my_str[:4:2]    # 从头开始，到下标4（不含）结束，步长2
print(new_str)
new_str = my_str[::-1]   # 从头（最后）开始，到尾结束，步长-1（倒序）
print(new_str)
new_list = my_list[3:1:-1]  # 从下标3开始，到下标1（不含）结束，步长-1（倒序）
print(new_list)
new_tuple = my_tuple[:1:-2]  # 从头（最后）开始，到下标1(不含)结束，步长-2（倒序）
print(new_tuple)

输出结果：
D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py 
[2, 3, 4]
(1, 2, 3, 4, 5)
[1, 3, 5]
13
54321
[4, 3]
(5, 3)

集合（set)

基本语法

变量名称 = {元素,元素1,元素1,……元素1}
变量名称 = set()

name = {'张三','李四','王五','李四'}
print(name)
输出结果：
D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py 
{'李四', '王五', '张三'}

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

集合的基本操作

my_set = {"hello","world"}
print(my_set)
print("--------------------------------")
#集合.add(元素)  新增集合元素，将指定元素加入集合内  同时集合本身被修改
my_set.add("python")
print(my_set)
print("--------------------------------")
#集合.remove()  将指定元素从集合中移除  同时集合本身被修改
my_set.remove("world")
print(my_set)
print("--------------------------------")
#集合.pop() 从集合中随机取出一个元素  会得到一个元素的结果。同时集合本身被修改，元素被移除
my_set.pop()
print(my_set)
print("--------------------------------")
#集合.clear() 清空集合
my_set.clear()
print(my_set)
print("--------------------------------")
"""
取出2个集合的差集
集合1.difference(集合2)，功能：取出集合1和集合2的差集（集合1有而集合2没有的）
得到一个新集合，集合1和集合2不变
"""
set1 = {1,2,3,5}
set2 = {4,5,6,7}
set3 = set1.difference(set2)
print(set1)
print(set2)
print(set3)
print("--------------------------------")
"""
消除2个集合的差集
集合1.difference_update(集合2)
对比集合1和集合2，在集合1内，删除和集合2相同的元素。
集合1被修改，集合2不变
"""
set1.difference_update(set2)
print(set1)
print(set2)
print("--------------------------------")
"""
2个集合合并
集合1.union(集合2)
将集合1和集合2组合成新集合
得到新集合，集合1和集合2不变
"""
set1 = {1,2,3,5}
set2 = {4,5,6,7}
set3 = set1.union(set2)
print(set1)
print(set2)
print(set3)
print("--------------------------------")
#查看集合的元素数量 len()
print(len(set3))

输出结果：
D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py 
{'world', 'hello'}
--------------------------------
{'world', 'python', 'hello'}
--------------------------------
{'python', 'hello'}
--------------------------------
{'hello'}
--------------------------------
set()
--------------------------------
{1, 2, 3, 5}
{4, 5, 6, 7}
{1, 2, 3}
--------------------------------
{1, 2, 3}
{4, 5, 6, 7}
--------------------------------
{1, 2, 3, 5}
{4, 5, 6, 7}
{1, 2, 3, 4, 5, 6, 7}
--------------------------------
7

集合的特点

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

字典（dict)

定义和语法

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

my_dict = {key:value,key:value,key:value……}
my_dict = {}
my_dict = dict()

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

字典的常用操作

my_scors = {"张三":"77","李四":"88","王五":"99"}
print(my_scors)
print("--------------------------------------------")
# 新增元素 	字典[Key] = Value，结果：字典被修改，新增了元素
my_scors["赵六"] = 100
print(my_scors)
print("--------------------------------------------")
#更新元素   语法：字典[Key] = Value，结果：字典被修改，元素被更新
#字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值
my_scors["张三"] = 85
print(my_scors)
print("--------------------------------------------")
#删除元素 字典.pop(Key)，结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除
my_scors.pop("赵六")
print(my_scors)
print("--------------------------------------------")
#清空字典 字典.clear()，结果：字典被修改，元素被清空
my_scors.clear()
print(my_scors)
print("--------------------------------------------")
#获取全部的Key  字典.keys()，结果：得到字典中的全部Key
my_scors = {"张三":"77","李四":"88","王五":"99"}
keys = my_scors.keys()
print(keys)
print("--------------------------------------------")
#遍历字典 for key in 字典.keys()
for key in keys:
    print(key)
print("--------------------------------------------")
#计算字典内的全部元素（键值对）数量 len(字典） 得到一个整数，表示字典内元素（键值对）的数量
print(len(my_scors))

输出结果：
D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py 
{'张三': '77', '李四': '88', '王五': '99'}
--------------------------------------------
{'张三': '77', '李四': '88', '王五': '99', '赵六': 100}
--------------------------------------------
{'张三': 85, '李四': '88', '王五': '99', '赵六': 100}
--------------------------------------------
{'张三': 85, '李四': '88', '王五': '99'}
--------------------------------------------
{}
--------------------------------------------
dict_keys(['张三', '李四', '王五'])
--------------------------------------------
张三
李四
王五
--------------------------------------------
3

字典的特点

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

数据容器对比总结

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

容器通用排序功能

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

my_list = [1,3,4,5]
my_tuple = (1,3,4,5)
my_set = {1,3,4,5}
my_str = '1345'
my_dict = {'a':1,'b':3,'c':2}
print("-------------------list-----------------")
print(type(my_list))
my_list = sorted(my_list,reverse=True)
print(my_list)
print(type(my_list))
print("-------------------tuple-----------------")
print(type(my_tuple))
my_tuple = sorted(my_tuple,reverse=True)
print(my_tuple)
print(type(my_tuple))
print("-------------------set-----------------")
print(type(my_set))
my_set = sorted(my_set,reverse=True)
print(my_set)
print(type(my_set))
print("-------------------dict-----------------")
print(type(my_dict))
my_dict = sorted(my_dict,reverse=True)
print(my_dict)
print(type(my_dict))
print("-------------------str-----------------")
print(type(my_str))
my_str = sorted(my_str,reverse=True)
print(my_str)
print(type(my_str))

输出结果:
D:\Study\PythonManage\.venv\Scripts\python.exe D:\Study\PythonManage\Demo\Demo1.py 
-------------------list-----------------
<class 'list'>
[5, 4, 3, 1]
<class 'list'>
-------------------tuple-----------------
<class 'tuple'>
[5, 4, 3, 1]
<class 'list'>
-------------------set-----------------
<class 'set'>
[5, 4, 3, 1]
<class 'list'>
-------------------dict-----------------
<class 'dict'>
['c', 'b', 'a']
<class 'list'>
-------------------str-----------------
<class 'str'>
['5', '4', '3', '1']
<class 'list'>

通用功能