Python数据容器

1 数据容器入门

2 数据容器：list（列表）

2.1 列表的定义格式

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

# 定义一个列表 list
my_list = ["itheima","itcast","python"]
print(my_list)
print(type(my_list))

my_list = ["itheima",555,True]
print(my_list)
print(type(my_list))

# 定义一个嵌套列表
my_list = [[1,2,3],[4,5,6]]
print(my_list)
print(type(my_list))

2.2 使用列表的下标索引

# 通过下标索引出对应位置的数据
my_list = ["Tom","John","Smith"]
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误示范：通过下标索引取数据，一定不要超出范围
# print(my_list[3])

# 通过下标索引出对应位置的数据（倒序）
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])

# 取出嵌套列表中的元素
my_list = [[1,2,3],[4,5,6]]
print(my_list[1][1])

2.3 列表的常用操作

2.3.1 查找某元素的下标

mylist = ["itcast","itheima","python"]
# 1.1 查找某元素在列表内下的索引
index = mylist.index("itheima")
print(f"itheima在列表中的下标索引的值是：{index}")

# 1.2 如果查找元素不村庄会报错
# index = mylist.index("hello")
# print(f"hello在列表中的下标索引的值是:{index}")

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

# 2 修改特定下标索引的值
mylist[0] = "传智教育"
print(f"列表被修改元素值后，结果是：{mylist}")

2.3.3 插入元素

# 3 在指定下标位置插入新元素
mylist.insert(1,"best")
print(f"列表插入元素后，结果是：{mylist}")

2.3.4 追加元素

# 4 在列表的尾部追加'''单个'''新元素
mylist.append("黑马程序员")
print(f"列表在追加元素后，结果是：{mylist}")

# 5 在列表微博追加'''一批'''新元素
mylist2 = [1,2,3]
mylist.extend(mylist2)
print(f"列表在追加了一个新的列表后，结果是：{mylist}")

2.3.5 删除元素

# 6 删除指定下标索引的元素（2种方式）
mylist = ["itcast","itheima","python"]

# 6.1 方式1：del.列表[下标]
del mylist[2]
print(f"列表删除元素后，结果是：{mylist}")

# 6.2 方式2：列表.pop(下标)
mylist = ["itcast","itheima","python"]
element = mylist.pop(2)
print(f"通过pop方法取出元素后列表内容:{mylist},取出元素是：{element}")

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

# 7 删除某元素在列表中的第一个匹配项
mylist = ["itcast","itheima","itcast","itheima","python"]
mylist.remove("itheima")
print(f"通过remove方法移除元素后，列表的结果是：{mylist}")

2.3.7 清空列表内容

# 8 清空列表内容
mylist.clear()
print(f"列表被清空了，结果是：{mylist}")

2.3.8 统计某元素在列表内的数量

# 9 统计某元素在列表内的数量
mylist = ["itcast","itheima","itcast","itheima","python"]
count = mylist.count("itcast")
print(f"列表中itcast的数量是:{count}")

2.3.9 清空列表内容

# 10 清空列表内容
mylist = ["itcast","itheima","itcast","itheima","python"]
count = len(mylist)
print(count)

2.4 总结

案例

mylist = [21,25,21,23,22,20]

mylist.append(31)

mylist.extend([29,33,30])

num2 = mylist[0]
print(num2)

num2 = mylist[-1]
print(num2)

index = mylist.index(31)
print(index)

3 list（列表）的遍历

while循环

def list_while_func():
    my_list = ["itheima","python","itcast"]
    index = 0
    while index < len(my_list):
        element = my_list[index]
        print(f"列表的元素{element}")
        index += 1
list_while_func()

for循环

def list_for_func():
    my_list = ["itheima","python","itcast"]
    for element in my_list:
        print(f"列表的元素{element}")
list_for_func()

while循环和for循环的区别

4 数据容器：tuple（元组）

元组的定义

t1 = (1, "hello", True)
t2 =()
t3 = tuple()
print(f"t1的类型是：{type(t1)},内容是：{t1}")
print(f"t2的类型是：{type(t2)},内容是：{t2}")
print(f"t3的类型是：{type(t3)},内容是：{t3}")

元组的操作

t = ("hello", "itheima", "itcast")
index = t.index("itcast")
print(f"在元组t中查找itcast的下标是：{index}")

t = ("hello", "itheima", "itcast", "itcast", "itcast", "itcast", "itcast")
num = t.count("itcast")
print(num)

t = ("hello", "itheima", "itcast", "itcast", "itcast", "itcast", "itcast")
num1 = len(t)
print(t)

5 数据容器：str（字符串）

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

my_str = "itheima and python"
value1 = my_str[2]
value2 = my_str[-16]
print(f"从字符串中{my_str}取下标为2的元素值是：{value1}，取下标为-16的元素的值是：{value2}")

字符串常用操作

5.1 查找特点字符串的下标索引

value = my_str.index("and")
print(f"在字符串{my_str}中查找and，其起始下标是：{value}")

5.2 字符串的替换

new_str = my_str.replace("it", "程序")
print(f"老字符串{my_str},替换后新字符串{new_str}")

5.3 字符串的分割

my_str = "hello itheima itcast"
my_list = my_str.split(" ")
print(f"将字符串{my_str}进行split切分后的得到：{my_list}")

5.4 字符串的规整操作

不传入参数strip去除空格

my_tuple = " hello itheima itcast "
new_tuple = my_tuple.strip()
print(f"将字符串{my_str}进行strip规整后得到:{new_tuple}")

总结

6 数据容器（序列）的切片

my_list = [1,2,3,4,5,6,7,8,9]
result1 = my_list[1:4]
print(result1)

my_tuple = (1,2,3,4,5,6,7,8,9)
result2 = my_tuple[:]
print(result2)

my_str = "0123456789"
result3 = my_str[::2]
print(result3)

my_str = "0123456789"
result4 = my_str[::-1]
print(result4)

my_list = [1,2,3,4,5,6,7,8,9]
result5 = my_list[3:1:-1]
print(result5)

my_list = [1,2,3,4,5,6,7,8,9]
result6 = my_list[::-2]
print(result6)

7 数据容器：set（集合）

my_set = {"itheima","itheima","itheima","传智教育","itheima","itheima"}
my_set_empty = ()
print(my_set,type(my_set))
print(my_set_empty,type(my_set_empty))

7.1 修改

my_set.add("python")
my_set.add("传智教育")
print(my_set)

7.2 移除元素

语法：集合.remove（元素），将指定元素，从集合内移除
结果：集合本身被修改，移除了元素

my_set.remove("itheima")
print(my_set)

7.3 从集合中随机取参数

my_set = {"itheima","python","itcast"}
element = my_set.pop()
print(element,my_set)

7.4 清空集合

my_set.clear()
print(my_set)

7.5 取出2个元素的差集

set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.difference(set2)
print(set3)
print(set1)
print(set2)

7.6 消除2个集合的差集

set1 = {1,2,3}
set2 = {1,5,6}
set1.difference_update(set2)
print(set1)
print(set2)

7.7 两个集合合并

set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
print(set3)
print(set1)
print(set2)

总结

案例

my_list = ["黑马程序员","传智博客","itheima","itcast","黑马程序员","黑马程序员","黑马程序员"]
# 定义空集合
my_set = set()
for i in my_list:
    my_set.add(i)
print(my_set)

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

8.1 字典的定义

my_dict1 = {"小明":99,"小白":96,"小黄":86}
my_dict2 = {}
my_dict3 = dict()
print(my_dict1)
print(my_dict2)
print(my_dict3)

my_dict1 = {"小明":99,"小明":96,"小黄":86}
print(my_dict1)

my_dict1 = {"小明":99,"小白":96,"小黄":86}
print(my_dict1["小白"])

stu_score_dict = {
    "小白": {"语文":88,"数学":78,"英语":98},
    "小明": {"语文":98,"数学":100,"英语":98},
    "小红": {"语文":88,"数学":96,"英语":88}
}
print(stu_score_dict)
a = stu_score_dict["小白"]["语文"]
print(a)

8.2 字典的操作

8.2.1 新增元素

my_dick = {"小明":99,"小白":88,"小红":77}

my_dick["小黄"] = 66
print(my_dick)

8.2.2 更新元素

my_dick["小明"] = 88
print(my_dick)

8.2.3 删除元素

score = my_dick.pop("小明")
print(my_dick,score)

8.2.4 清空字典

my_dick.clear()
print(my_dick)

8.2.5 获取全部的key

my_dick = {"小明":99,"小白":88,"小红":77}
key = my_dick.keys()
print(key)

8.2.6 遍历字典

通过获得到全部的key来完成遍历

for key in key:
    print(f"字典的key是：{key}")
    print(f"字典的value是：{my_dick[key]}")

直接对字典进行for循环，每一次循环都是直接获得key

for key in my_dick:
    print(f"字典的key是：{key}")
    print(f"字典的value是：{my_dick[key]}")

8.3 字典的案例

info_dict = {
    "小明":{
        "部门":"市场部",
        "工资":3000,
        "级别":1
    },
    "小白":{
        "部门":"市场部",
        "工资":5000,
        "级别":2
    },
    "小红":{
        "部门":"市场部",
        "工资":7000,
        "级别":3
    },
    "小黄":{
        "部门":"科技部",
        "工资":4000,
        "级别":1
    },
    "李华":{
        "部门":"市场部",
        "工资":6000,
        "级别":2
    },
}
for name in info_dict:
    if info_dict[name]["级别"] == 1:
        employee_info_dict = info_dict[name]
        employee_info_dict["级别"] = 2
        employee_info_dict["工资"] += 1000
        info_dict[name] = employee_info_dict
print(info_dict)

8.4 总结

9 数据容器的通用操作

my_list = [1,2,3,4,5,6,7,8,9]
my_tuple = (1,2,3,4,5,6,7,8,9)
my_str = "asdfghjklmnopqrstuvwxyz"
my_set = {1,2,3,4,5,6,7,8,9}
my_dict = {"a":1,"b":2,"c":3}

# len
print(len(my_list))
print(len(my_tuple))
print(len(my_set))
print(len(my_dict))
print(len(my_str))

# max
print(max(my_dict))
print(max(my_list))
print(max(my_set))
print(max(my_tuple))
print(max(my_str))

# min
print(min(my_dict))
print(min(my_tuple))
print(min(my_set))
print(min(my_str))
print(max(my_dict))