[Python] 学习笔记-数据容器

数据容器

---

---

数据容器的类型

列表（list）：可修改，支持重复元素、有序不支持下标索引  [ ]
元组（tuple）：不可修改，支持重复元素、有序不支持下标索引  ( )
字符串（str）：不可修改，支持重复元素、有序不支持下标索引 " "
集合（set）：可修改，不支持重复元素、无序不支持下标索引 { }
字典（dict）：可修改，不支持重复元素、无序不支持下标索引、存放键值对 { }

一、列表

创建一个列表，列表可以存放多种类型的元素，允许重复元素的存在

my_list = ["one", 666, true]

列表的常见操作

1.下标索引

从左向右索引：0、1、2
从右向左索引：-1、-2、-3
超出范围将会报错

2.增删改查

查
注：若查询元素不存在则会报错

my_list = ["one", "Python", "666"]

# index方法，确定列表中指定元素的第一次出现的索引值
index = my_list.index("one")
print(f"one在列表中的下表索引值是：{index}")

# ccount方法，计算列表中某元素的个数
count = my_list.count("Python")

# len函数，计算列表中所有元素的个数
count = len(my_list)

改

# 修改某个索引位的值
my_list = ["one", "Python", "666"]
my_list[1] = "C++"

#在指定位置插入元素（在字符串Python前插入字符串C++）
my_list.insert(1,"C++")

#在列表尾部追加一个元素
my_list.append("C++")

#取出其他数据容器中的元素，追加这一批元素到列表尾部
my_list2 = ["111", "222", "333"]
my_list.extend(my_list2)

删

# del关键字
del my_list[2]

# pop方法，取出元素并赋值给另一个元素
element = my_list.pop(2)

# remove方法，删除某元素在列表中的第一个匹配项
my_list.remove("one")

# clear方法，清空列表
my_list.clear()

3.列表的循环索引

while循环

index = 0
my_list = ["111", "222", "333"]
list1 = []
while index < len(my_list):
    element = my_list[index]
    list1.append(element)
    print(element)
    index += 1
print(list1)

for循环(简单且适用场景单一)

my_list = ["111", "222", "333"]
list1 = []
for element in my_list:
    list1.append(element)
print(list1)

【练习】取出偶数，并传入新的列表中

mylist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# for循环
list1 = []
for element in mylist:
    if element % 2 == 0:
        list1.append(element)
print(list1)

# while循环
list2 = []
index = 0
while index < len(mylist):
    if mylist[index] % 2 == 0:
        list2.append(mylist[index])
    index += 1
print(list2)

二、元组

就是不能修改的列表，使用小括号定义

t1 = (1, "Python", "666")
t2 = ()
t3 = tuple()

若元组中只有一个元素，需要在最后加逗号

t1 = (1, )
type(t1)

取出元素

a = ((1, 2), (3, 4))
b = a[1][0]

元组中的操作，只包含如下：

t1 = (111, "Python", "666")
index = t1.index("Python")
num = t1.count("Python")
lenth = len(t1)

【注】元组中若嵌套列表，可以修改列表中的元素

t1 = ('W', 30, ['C++', 'Python'])
print(f"姓名：{t1[0]}，年龄{t1[1]}")
del t1[2][1]
t1[2].append("Java")
print(t1)

三、字符串

字符串也可以作为一个数据容器，同时其不可修改

str1 = "I Love Coding"
print(str1[0], str1[-1])

常见操作如下：

# index方法
str1 = "I Love Coding"
index1 = str1.index("L")
index2 = str1.index("Love")
print(index1, index2)

# replace方法
#【注意】replace方法是生成一个新的字符串，不会修改原字符串，且会替换所有指定值而不是只替换第一次出现的
str1 = "I Love Coding"
str2 = str1.replace("Coding", "C++")
print(str1, str2)

# split方法
# 【注意】得到的是列表对象
str1 = "I Love Coding"
str2 = str1.split()

# strip方法，对字符串规正
# 去除首尾空格
str1 = " I Love Coding "
str2 = str1.strip()
# 去除首尾指定字符串
str1 = "121I Love Coding112"
str2 = str1.strip("112")

# count方法，统计字符串中某字符串出现的次数
str1 = "I Love Coding"
count = str1.count("o")

# len函数，统计字符串的长度
lenth = len(str1)

序列的切片

序列：内容连续、有序，可用下标索引的一类数据容器
列表、元组、字符串都可称为序列

序列名称[ 起始下标 : 结束下标 : 步长 ]
起始下标：表示从谁开始，留空表示从头开始
结束下标：表示到谁但不取那一位，留空表示到最后一位
步长：表示间隔长度，不写默认是1
【注】不影响序列本身，而是会得到一个新的序列

# 注意切片能够取到的位数
list1 = ["111", 222, "P", "Q"]
list2 = list1[0:3:1]     # ['111', 222, 'P']
list3 = list1[0:4:1]     # ['111', 222, 'P', 'Q']
list4 = list1[::1]       # ['111', 222, 'P', 'Q']
list5 = list1[::-1]      # ['Q', 'P', 222, '111'] 倒序
list5 = list1[2:-2]      # 去除开头和结尾两个
list5 = list1[2:]        # 去除开头两个

四、集合

无序、不支持下标索引、允许修改

my_set = {"111", "222", "Q", "W", "E", 666}
# 空集合为set()，不能用s = {}
empty_set = set()  

# add方法，添加元素
my_set.add("Python")

# remove方法，移除元素
my_set.remove("222")

# pop方法，从集合中随机取出一个元素，作为字符串对象
element = my_set.pop()

# clear方法
my_set.clear()

# difference方法，求出两集合的差集，且不改变原集合
set1 = {1 ,2, 3}
set2 = {1, 5, 6}
set1.difference(set2)  #求出集合1中有的，集合2中没有的{2,3}

# difference_update方法，消除两集合的差集，改变集合1，不改变集合2
set1 = {1 ,2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2) # {2,3}

# union方法，将集合1、2组合成新的集合，不改变集合1、2
set1 = {1 ,2, 3}
set2 = {1, 5, 6}
set1.union(set2) # {1,2,3,5,6}

# len函数，统计集合中的元素个数
set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5} 
lenth = len(set1)  # 5

【注意】集合遍历，只能用for，不能用while索引
【练习】将列表中的重复元素去除，并传入集合中

my_set = ["111", "222", "Q", "W", "E", 666, 666, 666]
set1 = set()
for element in my_set:
    set1.add(element)
print(f"结果：{set1}")

五、字典

包括key和value，可以通过key取出value
key和value可以为任意数据类型，但是key不能为字典

# 定义字典
dict1 = {"a": 6, "b": 7}
# 定义空字典
empty_dict = {}
empty_dict = dict()

# 查找键的值
dict1 = {"a": 6, "b": 7}
value = dict1["a"]

# 字典嵌套
dict1 = {
    "stu1": {
       "语文": 100,
       "数学": 100,
       "英语": 100
    },
    "stu2": {
        "语文": 100,
        "数学": 100,
        "英语": 100
    },
    "stu3": {
        "语文": 100,
        "数学": 100,
        "英语": 100
    }
}
score = dict1["stu1"]["语文"]
print(score)

字典的常见操作

# 增，改
# 若索引存在则为改，若索引不存在则为增
dict1["stu1"]["数学"] = 150
dict1["stu1"]["物理"] = 100

# 删 pop方法，可以将删除的生成一个新字典
score = dict1.pop("stu1")

# clear方法
dict1.clear

# keys方法
keys = dict1,keys()

# len函数
num = len(dict1)

字典遍历
【注】由于字典不支持下标索引，所以不能通过while循环遍历

# 方法1
keys = dict1.keys()
for key in keys:
    print(dict1[key])
    
# 方法2
for key in dict1:
    print(dict1[key])

数据容器的通用操作

# 最值、长度
max(a)
min(a)
len(a)

# 数据容器类型的相互转换
list(a)   # 字典只保留key
tuple(a)  # 字典只保留key
str(a)    # 字典全保留
set(a)    # 字典只保留key

# 排序，得到列表对象，字典排序丢失value
sorted(my_list)
sorted(my_list, reverse=True)