Python基础（四）数据容器

一、数据容器是什么

一个可以容纳多份数据的数据类型，容纳的每一分数据称之为一个元素，每个元素可以是任意类型的数据，如字符串、数字、布尔值等。
数据容器根据特点的不同，如：是否支持重复元素，是否可以修改，是否有序等，分为5类，分别是：String（字符串）、Tuple（元组）、List（列表）、Dictionary（字典）、Set（集合）

二、List（列表）

1. 列表的特点和定义

列表的特点：可以容纳多个元素（2**63 - 1），可以存储不同类型的元素，数据是有序存储的，允许重复数据，可以增删改查。

# 列表的定义
# 字面量
[1, 2, 3, 4, "hello", True]
# 定义变量：变量名 = [元素1, 元素2, 元素3...],元素类型不受限制
my_list = [1, 2, 3, 4, "hello", True]

# 定义空列表
my_list = []
my_list = list()

# 嵌套列表的定义，列表里面可以定义列表
my_list = [[1, 2, 3], [4, 5, 6]]

2. 列表的下标索引

利用下标索引取出列表数据

name_list = ["Jack", "Amy", "Rose", "Apple"]

# 下标索引 正向索引是从0开始，0,1,2...
name = name_list[0]
print(name)  # Jack
# 反向索引 从末尾开始 -1,-2,-3...
name = name_list[-1]
print(name)  # Apple
# 嵌套列表使用索引取值
num_list = [[1, 2, 3], [5, 6, 7]]
num = num_list[0][0]
print(num)  # 1

3. 列表的常用方法

fruit_list = ["apple", "banana", "pear"]
# 在列表末尾追加数据
fruit_list.append("orange")
print(fruit_list)  # ['apple', 'banana', 'pear', 'orange']
# 将another_list中的数据追加到列表fruit_list中
another_list = ["grape", "watermelon"]
fruit_list.extend(another_list)
print(fruit_list)  # ['apple', 'banana', 'pear', 'orange', 'grape', 'watermelon']
# 将数据插入指定索引处
fruit_list.insert(2, "lemon")
print(fruit_list)  # ['apple', 'banana', 'lemon', 'pear', 'orange', 'grape', 'watermelon']
# 数据在列表中出现的次数
count = fruit_list.count("banana")
print(count)  # 1
# 将列表数据逆序、反转
fruit_list.reverse()
print(fruit_list)  # ['watermelon', 'grape', 'orange', 'pear', 'lemon', 'banana', 'apple']
# 对列表升序排序
fruit_list.sort()
print(fruit_list)  # ['apple', 'banana', 'grape', 'lemon', 'orange', 'pear', 'watermelon']
# 对列表进行降序
fruit_list.sort(reverse=True)
print(fruit_list)  # ['watermelon', 'pear', 'orange', 'lemon', 'grape', 'banana', 'apple']
# 返回列表的长度
length = len(fruit_list)
print(length)  # 7
# 返回指定数据在列表中第一次出现的索引值,如果查找的元素不存在，则会报错 ValueError
index = fruit_list.index("pear")
print(index)  # 1
# 拷贝一份原来的列表
new_fruit_list = fruit_list.copy()
print(new_fruit_list)  # ['watermelon', 'pear', 'orange', 'lemon', 'grape', 'banana', 'apple']
# 修改指定索引处的数据
fruit_list[3] = "cherry"
print(fruit_list)  # ['watermelon', 'pear', 'orange', 'cherry', 'grape', 'banana', 'apple']
# 删除第一个出现的指定数据
fruit_list.append("pear")
print(fruit_list)  # ['watermelon', 'pear', 'orange', 'cherry', 'grape', 'banana', 'apple', 'pear']
fruit_list.remove("pear")
print(fruit_list)  # ['watermelon', 'orange', 'cherry', 'grape', 'banana', 'apple', 'pear']
# 删除列表末尾数据
fruit_list.pop()
print(fruit_list)  # ['watermelon', 'orange', 'cherry', 'grape', 'banana', 'apple']
# 删除指定索引处数据,删除的元素可以作为返回值被变量接收
element = fruit_list.pop(2)
print(fruit_list)  # ['watermelon', 'orange', 'grape', 'banana', 'apple']
# 删除索引处的数据
del fruit_list[0]
print(fruit_list)  # ['orange', 'grape', 'banana', 'apple']
# 清空列表
fruit_list.clear()
print(fruit_list)  # []

4. 列表的遍历

fruit_list = ["apple", "banana", "pear"]

# while 循环遍历
i = 0
while i < len(fruit_list):
    print(fruit_list[i])
    i += 1

print("------------------------")

# for 循环遍历
for x in fruit_list:
    print(x)

三、Tuple（元组）

1. 元组的特点

元组与列表类型，可以容纳多个元素，可以存储不同类型的元素，数据是有序存储的，允许重复数据。区别就是元组不支持元素的修改（不能增加或删除元素等）

2. 元组的定义

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

# 元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。
# 定义元组字面量
(1, "apple", True, 3.14)
# 定义元组变量
my_tuple = (1, "apple", True, 3.14)
# 元组中只有一个数据的时候，这个数据后面要添加逗号
my_tuple = (1,)

# 定义空元组
my_tuple = ()
my_tuple = tuple()

# 元组的嵌套
multi_tuple = ((1, 2, 3), (4, 5, 6))

# 通过索引获取嵌套元组中数据
i = multi_tuple[0][0]
print(i)  # 1

3. 元组的常用方法和遍历

new_tuple = (1, "apple", True, 3.14)
# 获取元组中元素个数
print(len(new_tuple))  # 4
# 通过索引获取元组中数据
print(new_tuple[1])  # apple
# 查找指定元素的第一个匹配项的索引值
print(new_tuple.index("apple"))  # 1
# 统计某个元素在元组中出现的次数
print(new_tuple.count("apple"))  # 1

print("-------------------------")
# 元组的遍历
idx = 0
while idx < len(new_tuple):
    print(new_tuple[idx])
    idx += 1
print("-------------------------")
for x in new_tuple:
    print(x)


# 元组的元素不能修改，但是如果这个元素是列表，则可以修改这个列表里的元素
t = (1, "kk", [1, 2])
# TypeError: 'tuple' object does not support item assignment
# t[0] = 2
t[2][0] = 5
t[2][1] = 6
print(t)  # (1, 'kk', [5, 6])

四、String（字符串）

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

1. 定义与常用方法

string = "jskfjasj sjdkfj djfkeufgk"
# 通过下标获取指定字符
print(string[2])  # k
print(string[-2])  # g

# 跟元组一样，字符串是一个无法修改的容器
# string[2] = "s"  报错：TypeError: 'str' object does not support item assignment

# 查找特点字符串的下标
idx = string.index("asj")
print(idx)  # 5

# 替换字符串,本质是生成新的字符串，不是去修改原字符串
new_str = string.replace("sj", "你")
print(new_str)  # jskfja你 你dkfj djfkeufgk

# 字符串的分割,原字符串同样不会修改，只是新增一个list对象
my_list = string.split(" ")
print(my_list)  # ['jskfjasj', 'sjdkfj', 'djfkeufgk']

# 去除字符串前后的空格
my_str = " sjdfkfjkj jfjf "
st = my_str.strip()
print(st)  # "sjdfkfjkj jfjf"
# 去除字符串前后指定的字符
my_str = "12hello23"
# 这里会拿括号中的字符串中的字符一一去匹配
st = my_str.strip("123")
print(st)  # hello

# 统计字符串中指定字符出现的次数
print(my_str.count("l"))  # 2

# 统计字符串的长度
print(len(my_str))  # 9

2. 特点和字符串遍历

特点：只可以存储字符串，长度任意，支持索引，允许重复，不可以修改，支持遍历

i = 0
while i < len(my_str):
    print(my_str[i])
    i += 1

print("--------")

for x in my_str:
    print(x)

五、序列的切片

1. 序列切片是什么

序列是指内容连续、有序，可以使用下标索引的一类数据容器，比如列表、元组、字符串，均可以视为序列。
序列支持切片，切片是指从一个序列中，取出一个子序列。

2. 序列切片语法

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

• 起始下标可以留空不写，不写就代表从头开始
• 结束下标也可以留空不写，不写就代表截取到结尾
• 步长表示依次取元素的间隔， 步长为1表示一个一个取，步长为2表示每次跳一个元素取，步长为N表示每次跳过N-1个元素取，步长为负数表示反向取
• 下标截取数据的时候遵循前开后闭原则

3. 序列切片操作列表、元组、字符串

# 对list进行切片，从下标1开始，下标4结束 ，步长为1
my_list = [1, 2, 3, 4, 5, 6]
print(my_list[1:4])  # [2, 3, 4]

# 对tuple进行切片  从头到尾，步长为1
my_tuple = (1, 2, 3, 4, 5, 6)
print(my_tuple[:])  # (1, 2, 3, 4, 5, 6)

# 对str进行切片 从头到尾，步长为2
my_str = "finished with exit code"
print(my_str[::2])  # fnse ihei oe

# 对str进行切片 从头到尾，步长为-1
print(my_str[::-1])  # edoc tixe htiw dehsinif

# 对列表进行切片，从3开始， 到1结束 ，步长-1
print(my_list[3:1:-1])  # [4, 3]

# 对元组进行切片 从头开始，到尾结束，步长-2
print(my_tuple[::-2])  # (6, 4, 2)

六、Set（集合）

集合可以存储多个元素，元素不可用重复，元素无序存储，不支持下标索引，元素允许修改，支持for循环

1. 集合的定义

# 定义集合字面量
{1, "jack", False, 9.9}
# 定义集合变量
col = {1, "jack", False, 9.9}
# 定义空集合
empty_col = set()

2. 常用操作

# 添加新元素
col.add("jack")
print(col)  # {False, 1, 'jack', 9.9}
# 移除元素
col.remove("jack")
print(col)  # {False, 1, 9.9}
# 随机取出一个元素
ele = col.pop()
print(ele)  # 1
# 清空集合
col.clear()
print(col)  # set()

# 取两个集合的差集，得到一个新集合(set1有但set2没有的元素)，原来的set1和set2集合不变
set1 = {1, 2, 3}
set2 = {1, 5, 6}
new_set = set1.difference(set2)
print(new_set)  # {2, 3}
print(set1)  # {1, 2, 3}
print(set2)  # {1, 5, 6}

# 消除两个集合的差集(在集合1内删除和集合2相同的元素，集合2不变)
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(set1)  # {2, 3}
print(set2)  # {1, 5, 6}

# 2个集合合并,得到新集合，原集合不变
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(set3)  # {1, 2, 3, 5, 6}
print(set1)  # {1, 2, 3}
print(set2)  # {1, 5, 6}

# 统计集合的元素个数
print(len(set1))  # 3

# 遍历集合
for x in set1:
    print(x)

七、Dictionary（字典）

字典的元素以k-v的形式存储,通过key可以检索value，key不允许重复，key和value可以是任意类型但是key不可用为字典,不支持下标索引，可以修改元素，支持for循环遍历。

1. 字典的定义

# 字典字面量
{"name": "jack", "age": 18, "sex": "M"}
# 字典的变量定义
dic = {"name": "jack", "age": 18, "sex": "M"}
# 空字典
empty_dic = {}
empty_dic = dict()

# 定义重复key的字典(字典的key不允许重复，定义了重复的key后它默认会取后面那个，覆盖前面的)
repeat_dic = {"name": "jack", "age": 18, "name": "amy"}
print(repeat_dic)  # {'name': 'amy', 'age': 18}

# 通过字典的key获取value
print(repeat_dic["name"])  # amy
print(repeat_dic["age"])  # 18

# key和value可以是任意类型，意味着字典可以嵌套定义，但是key不可用为字典
dc = {"name": "jack", "dic": {"age": 1, "color": "red"}}
print(dc["dic"]["age"])  # 1

2. 常用操作

score = {"java": 80, "python": 90, "c": 88}
# 新增字段元素
score["c++"] = 91
print(score)  # {'java': 80, 'python': 90, 'c': 88, 'c++': 91}
# 更新元素
score["c++"] = 99
print(score)  # {'java': 80, 'python': 90, 'c': 88, 'c++': 99}
# 删除指定元素
v = score.pop("c")
print(v)  # 88
print(score)  # {'java': 80, 'python': 90, 'c++': 99}
# 获取全部的key
keys = score.keys()
print(keys)  # dict_keys(['java', 'python', 'c++'])
# 遍历字典方式一
for k in keys:
    print(f"key是{k}")
    print(f"value是{score[k]}")

# 遍历方式二:直接遍历字典
for key in score:
    print(f"key是{key}")
    print(f"value是{score[key]}")
# 获取字段元素个数
print(len(score))  # 3
# 清空元素
score.clear()
print(score)  # {}

八、数据容器总结

是否支持下标索引

• 支持：列表、元组、字符串 — 序列类型
• 不支持：集合、字典 — 非序列类型

是否支持重复元素

• 支持：列表、元组、字符串 — 序列类型
• 不支持：集合、字典 — 非序列类型

是否支持修改

• 支持：列表、集合、字典
• 不支持：元组、字符串

应用场景
列表：一批数据，可以修改，可重复的存储场景
元组：一批数据，不可以修改，可重复的存储场景
字符串：一串字符串的存储场景
集合：一批数据，去重存储场景
字典：一批数据，key检索value的存储场景

九、数据容器的通用操作

my_list = [1, 2, 3, 4]
my_tuple = (1, 2, 3, 4)
my_str = "package"
my_set = {1, 2, 3, 4}
my_dic = {"key1": 1, "key2": 2, "key3": 3}

# 获取元素个数
len(my_list)
len(my_tuple)
len(my_str)
len(my_set)
len(my_dic)
# 获取最大元素
print(max(my_list))  # 4
print(max(my_tuple))  # 4
print(max(my_str))  # p
print(max(my_set))  # 4
print(max(my_dic))  # key3
# 获取最小元素
print(min(my_list))  # 1
print(min(my_tuple))  # 1
print(min(my_str))  # a
print(min(my_set))  # 1
print(min(my_dic))  # key1
# 容器转列表
print(list(my_list)) # [1, 2, 3, 4]
print(list(my_tuple)) # [1, 2, 3, 4]
print(list(my_str)) # ['p', 'a', 'c', 'k', 'a', 'g', 'e']
print(list(my_set)) # [1, 2, 3, 4]
print(list(my_dic)) # ['key1', 'key2', 'key3']
# 容器转元组
print(tuple(my_list)) # (1, 2, 3, 4)
print(tuple(my_tuple)) # (1, 2, 3, 4)
print(tuple(my_str)) # ('p', 'a', 'c', 'k', 'a', 'g', 'e')
print(tuple(my_set)) # (1, 2, 3, 4)
print(tuple(my_dic)) # ('key1', 'key2', 'key3')
# 容器转str
print(str(my_list)) # [1, 2, 3, 4]
print(str(my_tuple)) # (1, 2, 3, 4)
print(str(my_str)) # package
print(str(my_set)) # {1, 2, 3, 4}
print(str(my_dic)) # {'key1': 1, 'key2': 2, 'key3': 3}
# 容器转集合
print(set(my_list)) # {1, 2, 3, 4}
print(set(my_tuple)) # {1, 2, 3, 4}
print(set(my_str)) # {'g', 'p', 'c', 'k', 'e', 'a'}
print(set(my_set)) # {1, 2, 3, 4}
print(set(my_dic)) # {'key2', 'key3', 'key1'}
# 容器正序排序
print(sorted(my_list)) # [1, 2, 3, 4]
print(sorted(my_tuple)) # [1, 2, 3, 4]
print(sorted(my_str)) # ['a', 'a', 'c', 'e', 'g', 'k', 'p']
print(sorted(my_set)) # [1, 2, 3, 4]
print(sorted(my_dic)) # ['key1', 'key2', 'key3']
# 容器反序排序
print(sorted(my_list, reverse=True)) # [4, 3, 2, 1]
print(sorted(my_tuple, reverse=True)) # [4, 3, 2, 1]
print(sorted(my_str, reverse=True)) # ['p', 'k', 'g', 'e', 'c', 'a', 'a']
print(sorted(my_set, reverse=True)) # [4, 3, 2, 1]
print(sorted(my_dic, reverse=True)) # ['key3', 'key2', 'key1']