python从入门到精通：数据容器

数据容器介绍

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

数据容器根据特点的不同，如：

· 是否支持重复元素

· 是否可以修改

· 是否有序，等

分为五类，分别是：

列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

数据容器：list（列表）

列表（list）的介绍：

列表（list）类型，是数据容器的一类，可以一次存储多个数据。

基本语法：

字面量

[元素1,元素2,元素3,...]

定义变量

变量名称=[元素1,元素2,元素3,...]

定义空列表

变量名称=[ ]

变量名称=list( )

列表内的每一个数据，称之为元素

· 以 [ ] 作为标识

· 列表内的每一个元素，逗号隔开

# 列表（list）
name = ['python','c','c++','java']
print(name)
print(type(name))
# 列表嵌套
name_list = [[1,2,"haha"],[4,5,True]]
print(name_list)
print(type(name_list))

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

列表（list）的下标索引：

我们可以通过下标索引的方式找到列表中特定位置的元素。

比如：

# 列表索引
my_list = ["tom","jack","lihua"]
print(my_list[0]) # 结果为tom
print(my_list[1]) # 结果为jack
print(my_list[2]) #结果为lihua

或者可以反向索引，也就是从后向前：从-1开始，依次递减（-1、-2、-3....）

比如：

my_list = ["tom","jack","lihua"]
print(my_list[-3]) # 结果为tom
print(my_list[-2]) # 结果为jack
print(my_list[-1]) #结果为lihua

嵌套索引的下标索引：

比如：

# 嵌套列表的下标索引
name_list = [[1,2,"haha"],[4,5,True]]
print(name_list[1][2]) # 结果为True
print(name_list[0][2]) # 结果为haha

需要注意的是不要超出下标索引的范围，超出范围无法取出元素，会造成越界。

列表的常用操作：

列表除了可以定义和使用下标索引获取值，此外还有一系列功能：

1、插入元素

2、删除元素

3、清空元素

4、修改元素

5、统计元素个数

等等，这些功能统称为列表的方法

1、列表的查询功能

查询指定元素在列表中的下标，如果找不到，报错ValueError

语法：

列表.index(元素)

index就是列表对象（变量）内置的方法（函数）

# 查询下标索引
name = ['python','c','c++','java']
index = name.index("python")
print(f"python在列表中的下标索引为{index}")
# 如果被查找元素不存在，则会报错
index = name.index("javascript")
print(f"python在列表中的下标索引为{index}")

2、列表的修改功能

修改特定位置（索引）的元素值：

语法：列表[下标]=值

可以使用如上语法，直接对指定下标（正向、或反向均可）的值进行重新赋值

# 修改特定位置元素值
my_list = [1,2,3,4]
my_list[0] = 8
print(my_list)
my_list[-1] = 6
print(my_list)

插入元素：

语法：列表.insert(下标，元素)，在指定的下标位置，插入指定的元素

# 插入元素
my_list = [1,2,3,4]
my_list.insert(2,'haha')
print(my_list)

追加元素：

语法：列表.append(元素)，将指定元素，追加到列表的尾部

# 追加元素
my_list = [1,2,3,4]
my_list.append(4) # 结果：[1,2,3,4,4]
print(my_list)
my_list.append([5,5,6])
print(my_list) #结果：[1, 2, 3, 4, 4, [5, 5, 6]]

追加方式2：

语法2：列表.extend(其他数据容器)，将其他数据容器内容取出，以此追加到列表尾部

# 追加一批元素
my_list = [1,2,3,4]
my_list.extend([4,5,6])
print(my_list) #结果为：[1, 2, 3, 4, 4, 5, 6]

删除元素：

语法1：del列表[下标]

语法2：列表.pop(下标)

# 删除元素
my_list = [1,2,3,4]
# 方式1：
del my_list[0]
print(my_list) #结果为：[2, 3, 4]
# 方式2：
my_list.pop(0)
print(my_list) #结果为：[3, 4]

删除某元素在列表中的第一个匹配项：

语法：列表.remove(元素)

my_list = [1,2,3,2]
my_list.remove(2)
print(my_list) # 结果为：[1, 3, 2]

清空列表内容：

语法： 列表.clear()

# 清空列表内容
my_list = [1,2,3,2]
my_list.clear()
print(my_list)

统计某元素在列表中的数量：

语法：列表.count(元素)

# 统计2在列表中的次数
my_list = [1,2,3,2]
num = my_list.count(2)
print(num)

统计列表内，有多少元素：

语法：len(列表)

# 统计列表内，有多少元素
my_list = [1,2,3,2]
count = len(my_list)
print(count)

列表的特点：

1、可以容纳多个元素（上限为2**63-1个）

2、可以容纳不同类型的元素

3、数据是有序存储的

4、允许重复数据存在

5、可以修改

list（列表）的遍历

既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代。

列表的遍历-while循环

通过定义一个从0开始的下标变量，循环条件为 下标值<列表中元素数量来实现遍历。

index = 0

while index < len(列表):

元素 = 列表[index]

对元素进行处理

index +=

def list_while_func():
    """
    使用while循环遍历列表的演示函数
    :return:
    """
    my_list = ["python","java","c++","javascript","go"]
    index = 0;
    while index < len(my_list):
        element = my_list[index]
        print(f"列表的元素：{element}")
        index += 1
list_while_func()

列表的遍历-for循环

除了while循环，python中还有另一种循环的形式：for循环。对比while，for循环更加适合对列表等数据容器进行遍历

语法：

for 临时变量 in数据容器:

对临时变量进行处理

表示从容器内，依次取出元素并赋值到临时变量上。在每一次的循环中，我们可以对临时变量进行处理。

def list_for_func():
    """
    使用for循环遍历列表的演示函数
    :return:
    """
    my_list = ["python","java","c++","javascript","go"]
    for element in my_list:
        print(f"列表的元素：{element}")
list_for_func()

while循环与for循环的对比：

1、在循环控制上：while循环可以自定循环条件，并自行控制；for循环不可以自定循环条件，只可以一个个从容器内取出数据

2、在无限循环上：while循环可以通过条件控制做到无限循环；for循环理论上不可以，因为被遍历的容器容量不是无限的

3、在使用场景上：while循环适用于任何想要循环的场景；for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

数据容器：tuple（元组）

因为列表是可以被修改的，如果想要传递的信息，不被篡改，列表是不合适的。而元组与列表最大的不同就在于：元组一旦定义完成，就不可修改。

元组定义：定义使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。

定义元组字面量

(元素,元素,......,元素)

定义元组变量

变量名称=(元素,元素,......,元素)

定义空元组

变量名称=( )

变量名称=tuple( )

t1 = (1,"hehe",True)
t2=()
print(f"t1的类型:{type(t1)}")
print(f"t1的类型:{type(t2)}")
t3 = ("haha",) #元组中只有一个数据，这个数据后面添加逗号,否则类型变为str
# 元组嵌套
t = ((1,2,3),(4,5,6))
print(f"t的类型:{type(t)},内容是：{t}")

元组（tuple）的下标索引：

t = ((1,2,3),(4,5,6))
print(f"t的类型:{type(t)},内容是：{t}")
# 元组索引
print(t[1][2])

元组的相关操作：

|----|---------|--------------------------|
| 编号 | 方法 | 作用 |
| 1 | index() | 查找某个数据，如果数据存在返回对应下标，否则报错 |
| 2 | count() | 统计某个数据在当前元组出现的次数 |
| 3 | len() | 统计元组内的元素个数 |

# 根据index()，，查找第一个特定元素的匹配项
t1 = (1,2,"hehe",3,4,"hehe")
index = t1.index("hehe")
print(index) #结果为2
# 统计某个元素在元组中的个数
count = t1.count("hehe")
print(count) #结果为2
# 统计元组中元素个数
print(len(t1)) #结果为6

元组（tuple）的遍历

元组的遍历-while循环：

# 元组的遍历-while循环
t1 = (1,2,"hehe",3,4,"hehe")
index = 0
while index < len(t1):
    print(f"元组的元素有:{t1[index]}")
    index += 1

元组的遍历-for循环：

# 元组的遍历-for循环
t2 = (1,2,"hehe",3,4)
index = 0
for element in t2:
    print(f"元组的元素有：{element}")

注意事项：不可以修改元组内容，否则会直接报错；但是如果在元组中嵌套了一个列表，那么列表中的元素是可以修改的。

数据容器：str（字符串）

字符串是字符的容器，一个字符串可以存放任意数量的字符。

字符串的下标索引：

和其他容器如：列表、元组一样，字符串也可以通过下标进行访问。

· 从前往后，下标从0开始

· 从后向前，下标从-1开始

# 字符串索引
str1 = "hello"
print(str1[0]) #结果为h

同元组一样，字符串是一个无法修改的数据容器。所以：

修改指定下标的字符、移除特定下标的字符、追加字符等均无法完成。如果必须要做，只能得到一个新字符串，旧的字符串无法修改。

字符串的常用操作：

1、查找特定字符串的相关索引值。

语法：字符串.index(字符串)

# 字符串查找特定元素的下标
str1 = "hello word"
index = str1.index("hello")
print(index) # 结果是字符串第一个元素的位置

2、字符串的替换

语法：字符串.replace(字符串1，字符串2)

功能：将字符串的全部：字符串1，替换为字符串2

注意：不是修改字符串本身，而是得到了一个新的字符串

# 字符串的替换
str1 = "hello word"
new_str1 = str1.replace("h","H")
print(new_str1) #结果为：Hello word

3、字符串的分割

语法：字符串.split(分隔符字符串)

功能：将按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中。

注意：字符串本身不变，而是得到了一个列表对象

# 字符串分割
str1 = "hehe haha xixi"
list1 = str1.split(" ")
print(f"将字符串{str1}进行分割后得到{list1}，它的类型为：{type(list1)}")
# 运行结果：将字符串hehe haha xixi进行分割后得到['hehe', 'haha', 'xixi']，它的类型为：<class 'list'>

4、字符串的规整操作（去前后空格）

语法：字符串.strip()

# 字符串规整操作，去前后空格
str1 = " hello word "
print(str1.strip())

5、字符串的规整操作（去前后指定字符串）

语法：字符串.strip(字符串)

# 字符串的规整操作（去前后指定字符串）
str1 = "12@hello word@21"
print(str1.strip("12@"))

6、统计字符串中某个元素的个数

语法：字符串.count(字符)

str1 = "hello word"
count = str1.count("o")
print(count) # 结果为2

7、统计字符串长度

语法：len(字符串)

# 统计字符串长度
str1 = "hello word"
count = len(str1)
print(count) #结果为10

作为数据容器，字符串有如下特点：

1、只可以存储字符串

2、长度任意

3、支持下标索引

4、允许重复字符串存在

5、不可以修改

6、支持while、for循环

数据容器（序列）的切片

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

序列至此切片，即：列表、元组、字符串，均支持进行切片操作。

切片：从一个序列中，取出一个子序列

语法：序列[起始下标：结束下标：步长]

表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

· 起始下标表示从何处开始，可以留空，留空视作从头开始

· 结束下标（不含）表示何处结束，可以留空，留空是做截取到结尾

· 步长表示，依次取元素的间隔

· 步长1表示一个个取元素

· 步长2表示每次跳过一个元素

· 步长n表示每次跳过n-1个元素

· 步长为负数表示，反向取（起始下标与结束下标也要反向标记）

注意：此操作不会影响序列本身，而是会得到一个新序列（元组和字符串不可修改）

# 对list切片，从一到四，步长为1
my_list = [0,1,2,3,4,5,7]
result1 = my_list[1:5]
print(result1)
# 对元组进行切片，从头开始到位结束，步长为-2
my_tuple = [0,1,2,3,4,5,6]
result2 = my_tuple[::-2]
print(result2)

# 案例：万过薪月，员序程马黑来，nohtyp学
# 1、倒序字符串，切片取出或切片取出，然后倒序
str1 = "万过薪月，员序程马黑来，nohtyp学"
str2= str1[::-1][9:14]
print(str2)
str3 = "万过薪月，员序程马黑来，nohtyp学"
str4 = str1[5:10][::-1]
print(str4)
# 2、split分割"，"replace替换来为空，倒序字符串
str5 = "万过薪月，员序程马黑来，nohtyp学"
str6 = str5.split("，")[1].replace("来","")[::-1]
print(str6)

数据容器：set（集合）

集合是不支持重复元素的，会对重复元素进行去重操作、并且内容无序。

基本语法：

定义集合字面量

{元素,元素,......,元素}

定义集合变量

变量名称={元素,元素,......,元素}

定义空集合

变量名称=set( )

set1 = {"haha","hehe","xixi","haha"}
print(f"set1的内容为：{set1},类型：{type(set1)}") #set1的内容为：{'haha', 'hehe', 'xixi'},类型：<class 'set'>
set2 = set() # 空集合

集合的常用操作：

首先，因为集合是无序的，所以不支持下标索引访问。但是集合和列表一样，是允许修改的，因此我们来看集合的修改方法。

1、添加新元素

语法：集合.add(元素)。将指定元素添加到集合内

结果：集合本身被修改，添加了新元素

# 给集合添加元素
my_set = {"haha","hehe","xixi"}
my_set.add("python")
print(my_set)# 结果为：{'hehe', 'haha', 'python', 'xixi'}是无序的

2、移除元素

语法：集合.remove(元素)。将指定元素从集合中删除

结果：集合本身被修改，删除了指定元素

my_set = {"haha","hehe","xixi"}
my_set.remove("haha")
print(my_set) #结果为：{'hehe', 'xixi'}

3、随机取出一个元素

语法：集合.pop( )。将元素从集合中随机删除

结果：会得到一个元素的结果。同时集合本身被修改

# 随机取出一个元素
my_set = {"haha","hehe","xixi"}
pop_set = my_set.pop()
print(f"随机取出的元素为{pop_set},集合中的元素为{my_set}") #随机取出的元素为haha,集合中的元素为{'hehe', 'xixi'}

4、清空集合

语法：集合.clear( )

#清空集合
my_set = {"haha","hehe","xixi"}
my_set.clear()
print(my_set)

5、取出两个集合的差集

语法：集合1.difference(集合2)，功能：取出集合1与集合2的差集（集合1有而集合2没有的）

结果：得到一个新集合，集合1与集合2不变

# 两个集合的差集
my_set1 = {1,3,5}
my_set2 = {1,4,6}
new_set = my_set1.difference(my_set2)
print(new_set) # 结果：{3, 5}
print(my_set1) # 结果：{1, 3, 5}
print(my_set2) # 结果：{1, 4, 6}

6、消除两个集合的差集

语法：集合1.difference_update(集合2)

功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素

结果：集合1被修改，集合2不变

# 消除两个集合的差集
my_set1 = {1,3,5}
my_set2 = {1,4,6}
my_set1.difference_update(my_set2)
print(my_set1) # 结果：{3, 5}
print(my_set2) # 结果：{1, 4, 6}

7、两个集合合并为一个

语法：集合1.union(集合2)

功能：将集合1和集合2组成新集合

结果：得到新集合，集合1和集合2不变

# 两个集合合并为一个
my_set1 = {1,3,5}
my_set2 = {1,4,6}
new_set = my_set1.union(my_set2)
print(new_set) #结果为：{1, 3, 4, 5, 6}
print(my_set1) #结果为：{1, 3, 5}
print(my_set2) #结果为：{1, 4, 6}

8、统计集合数量

语法：len(集合)

my_set = {1,2,3,4,5,6}
num = len(my_set)
print(num)

集合（set）的遍历

因为集合不支持下标索引，所以不能用while循环，但可以使用for循环

# for循环
my_set = {1,2,3,4,5,6}
for element in my_set:
    print(f"集合中的元素有：{element}")

数据容器：dict（字典、映射）

通过字典，我们可以通过用key取value的操作。

字典的定义，同样使用{}，不过存储的元素是一个个的：键值对，如下语法：

定义字典字面量

{key:value,key:value,......,key:value}

定义字典变量

变量名={key:value,key:value,......,key:value}

定义空字典

变量名={}

变量名=dict( )

字典同样不支持key的重复，如果重复，第一个key会被覆盖掉。

字典同集合一样，不可以使用下标索引。但是字典可以通过key值来取得对应的value

语法：字典[key]可以取到对应的value

my_dict = {"张三":99,"李四":88,"王二":77}
print(f"字典的内容为：{my_dict},类型：{type(my_dict)}")
score = my_dict["张三"]
print(score) # 99

字典的嵌套

字典的key和value可以是任意类型（key不可以为字典）

那么，就表明，字典是可以嵌套的

score_dict = {
    "张三":{
        "语文":77,
        "数学":66,
        "英语":33
    },"李四":{
        "语文":88,
        "数学":86,
        "英语":55
    },"王二":{
        "语文":99,
        "数学":96,
        "英语":66
    }
}
print(f"学生的考试信息:{score_dict}")

字典（dict）的常用操作：

1、新增元素

语法：字典[key]=value,字典被修改，新增了元素

my_dict = {"张三":99,"李四":88,"王二":77}
my_dict["麻子"] = 67
print(my_dict) #{'张三': 99, '李四': 88, '王二': 77, '麻子': 67

语法：字典[key]=value,字典被修改，元素被更新

注意：字典key不可以重复，所以对已经存在的key执行上述操作，就是更新value值

# 更新元素
my_dict = {'张三': 99, '李四': 88, '王二': 77, '麻子': 67}
my_dict["麻子"] = 68
print(my_dict) #{'张三': 99, '李四': 88, '王二': 77, '麻子': 68}

3、删除元素

语法：字典.pop(key)，结果：获得指定key的value，同时字典被修改，指定key的数据被删除

# 删除元素
my_dict = {'张三': 99, '李四': 88, '王二': 77, '麻子': 67}
score = my_dict.pop("麻子")
print(f"字典被移除一个元素，结果{my_dict},麻子的分数："{score}")

4、清空元素

语法：字典.clear( )

5、获取全部的key

语法：字典.keys( )

结果：得到字典中的全部key

# 取出全部key
my_dict = {'张三': 99, '李四': 88, '王二': 77, '麻子': 67}
keys = my_dict.keys()
print(keys) #dict_keys(['张三', '李四', '王二', '麻子'])

6、字典内元素数量

语法：len(字典变量名)

# 字典中元素数量
my_dict = {'张三': 99, '李四': 88, '王二': 77, '麻子': 67}
num = len(my_dict)
print(num)

字典（dict）的遍历：

my_dict = {'张三': 99, '李四': 88, '王二': 77, '麻子': 67}
num = len(my_dict)
print(num)
# 取出全部key
my_dict = {'张三': 99, '李四': 88, '王二': 77, '麻子': 67}
keys = my_dict.keys()
for key in keys:
    print(f"字典的key是:{key}")
    print(f"字典的value是:{my_dict[key]}")

emp_dict = {
    "马云":{
        "部门":"科技部",
        "薪资":3000,
        "级别":1
    },"李彦宏":{
        "部门":"市场部",
        "薪资":5000,
        "级别":2
    },"刘强东":{
        "部门":"市场部",
        "薪资":7000,
        "级别":4
    },"张一鸣":{
        "部门":"科技部",
        "薪资":4000,
        "级别":1
    }
}
for name in emp_dict:
    if emp_dict[name]["级别"] == 1:
        info_emp_dict = emp_dict[name]
        info_emp_dict["级别"] = 2
        info_emp_dict["薪资"] += 1000
        emp_dict[name]=info_emp_dict
print(f"升职加薪后的结果为：{emp_dict}")

数据容器的通用操作

首先在遍历上，5类数据容器都支持for循环遍历；列表、元组、字符串支持while循环，集合、字典不支持while循环。

除了下标索引这个共性以外，还可以同哟个类型转换。比如list（容器）-将给定容器转换为列表、set（容器）-将给定容器转换为集合等等。

通用排序功能：

sorted(容器，[reverse=True])

将给定容器进行排序

my_list = [1,4,6,8,2,3]
print(f"列表的排序结果:{sorted(my_list,reverse=True)}") # 反向排序
print(f"列表的排序结果:{sorted(my_list)}")