Python基础数据容器

1、列表

以[]作为标识，可为不同类型

list = [1,2,3] 或 嵌套 list = [[1,2,3],[4,5,6]]

下标索引 0,1,2,3,4 反向下标索引 -4，-3，-2，-1

常用操作：

编号	使用方法	作用	操作（全部基于list=[1,1,1,2,3,4,5]）
1	列表.append(元素)	向列表中追加一个元素	list.append(6) #list=[1, 1, 1, 2, 3, 4, 5, 6]
2	列表.extend(容器)	将数据容器的内容依次取出，追加到列表尾部	list.extend([1,2,3]) #list=[1, 1, 1, 2, 3, 4, 5, 1, 2, 3]
3	列表.insert(下标, 元素)	在指定下标处，插入指定的元素	list.insert(1,8) #list=[1, 8, 1, 1, 2, 3, 4, 5]
4	del 列表[下标]	删除列表指定下标元素	del list[3] #list=[1, 1, 1, 3, 4, 5]
5	列表.pop(下标)	删除列表指定下标元素	list.pop(3) #list=[1, 1, 1, 3, 4, 5]
6	列表.remove(元素)	从前向后，删除此元素第一个匹配项	list.remove(4) #list=[1,1,1,2,3,5]
7	列表.clear()	清空列表	list.clear() #list=[]
8	列表.count(元素)	统计此元素在列表中出现的次数	list.count(1) # 3
9	列表.index(元素)	查找指定元素在列表的下标 找不到报错ValueError	list.index(8) #ValueError: 8 is not in list
10	len(列表)	统计容器内有多少元素	print(len(list) #7

二、元组

(需要在程序内封装数据，又不希望封装的数据被篡改) 定义元组使用小括号，可以是不同的类型

tuple = (1,2,3) 或 嵌套 tuple = ((1,2,3),(4,5,6))

常用操作：

编号	方法	作用	操作
1	index()	查找某个数据，如果数据存在返回对应的下标，否则报错(查找特定元素的第一个匹配项)	t1=(1,2,‘hello’,3,4,‘gello’) print(t1.index(‘hello’)) #2
2	count()	统计某个数据在当前元组出现的次数	t1=(1,2,‘hello’,3,4,‘gello’) print(t1.index(‘hello’)) #2
3	len(元组)	统计元组内的元素个数	t1=(1,2,3) print(len(t1)) #3

元组遍历：

三、字符串

从前往后，下标从0开始；从后往前，下标从-1开始

name = "juxiaoran"

print(name(0)) # 结果 j

print(name(-1)) #结果 n

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

编号	操作	说明
1	字符串[下标]	根据下标索引取出特定位置字符
2	字符串.index(字符串）	查找给定字符的第一个匹配项的下标
3	字符串.replace(字符串1, 字符串2)	将字符串内的全部字符串1，替换为字符串2 不会修改原字符串，而是得到一个新的
4	字符串.split(字符串)	按照给定字符串，对字符串进行分隔 不会修改原字符串，而是得到一个新的列表
5	字符串.strip() 字符串.strip(字符串)	移除首尾的空格和换行符或指定字符串
6	字符串.count(字符串)	统计字符串内某字符串的出现次数
7	len(字符串)	统计字符串的字符个数

• 查找特定字符串的下标索引值

str="ju xiao ran"

print(str.index("xi")) #结果为3

• 字符串的替换

  语法：字符串.replace(字符串1，字符串2）
  功能：将字符串内的全部：字符串1，替换为字符串2
  注意：不是修改字符串本身，而是得到了一个新字符串哦

str="ju xiao ran"
newstr=str.replace("ju","居")
print(str)      #结果为 ju xiao ran
print(newstr)      #结果为 居 xiao ran

• 字符串的分割

  语法：字符串.split(分隔符字符串）
  功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
  注意：字符串本身不变，而是得到了一个列表对象

str="ju xiao ran"
newstr=str.split("a")
print(str)      #结果: ju xiao ran
print(newstr)      #结果: ['ju xi', 'o r', 'n']
print(type(newstr))    #结果是：<class 'list'>

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

  语法：字符串.strip()

str=" 12ju xiao ran21 "
print(str.strip())    #12ju xiao ran21

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

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

str="12ju xiao ran21"
print(str.strip("12"))     #ju xiao ran   传入的是“12” 其实就是：”1”和”2”都会移除，是按照单个字符

• 统计字符串中某字符串的出现次数

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

str="ju xiao ran"
print(str.count("a"))     #2

• 统计字符串的长度

  语法：len(字符串)

str="12 juxiaoran !@#"
print(len(str))     #16

数字（1、2、3…）、字母（abcd、ABCD等）、符号（空格、!、@、#、$等）、中文均算作1个字符

四、序列（切片）

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

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

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

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

my_str = "12345"
new_str = my_str[:4:2] # 从头开始，到下标4（不含）结束，步长2
print(new_str) # 结果："13"

my_str = "12345"
new_str = my_str[::-1] # 从头（最后）开始，到尾结束，步长-1（倒序）
print(new_str) # 结果："54321"

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

my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[:1:-2] # 从头（最后）开始，到下标1(不含)结束，步长-2（倒序）
print(new_tuple) # 结果：(5, 3)

五、集合{}

列表可修改、支持重复元素且有序

元组、字符串不可修改、支持重复元素且有序

set = {"周杰伦", "薛之谦", "棱镜", "林俊杰", "周杰伦", "薛之谦", "棱镜", "林俊杰", "夏企"}
print(set的内容是：{my_set}, 类型是：{type(my_set)})   
#set的内容是：{'周杰伦', '棱镜', '林俊杰', '夏企', '薛之谦'}, 类型是：<class 'set'>

因为要对元素做去重处理，所以无法保证顺序和创建的时候一致

因为集合是无序的，所以集合不支持：下标索引访问

编号	操作	说明
1	集合.add(元素)	集合内添加一个元素
2	集合.remove(元素)	移除集合内指定的元素
3	集合.pop()	从集合中随机取出一个元素
4	集合.clear()	将集合清空
5	集合1.difference(集合2)	得到一个新集合，内含2个集合的差集 原有的2个集合内容不变
6	集合1.difference_update(集合2)	在集合1中，删除集合2中存在的元素 集合1被修改，集合2不变
7	集合1.union(集合2)	得到1个新集合，内含2个集合的全部元素 原有的2个集合内容不变
8	len(集合)	得到一个整数，记录了集合的元素数量

• 添加新元素

  语法：集合.add(元素)。将指定元素，添加到集合内
  结果：集合本身被修改，添加了新元素

set = {"周杰伦", "薛之谦", "棱镜", "夏企"}
set.add("周深")
set.add("陈粒")
print(set)    #{'周杰伦', '夏企', '棱镜', '周深', '陈粒', '薛之谦'}

• 移除元素

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

set = {"周杰伦", "薛之谦", "棱镜", "夏企"}
set.remove("薛之谦")
print(set)    #{'夏企', '棱镜', '周杰伦'}

• 从集合中随机取出元素

  语法：集合.pop()，功能，从集合中随机取出一个元素
  结果：会得到一个元素的结果。同时集合本身被修改，元素被移除

set = {"周杰伦", "薛之谦", "棱镜", "夏企"}
element = set.pop()
print(f"集合被取出元素是：{element}, 取出元素后：{set}")
#集合被取出元素是：夏企, 取出元素后：{'薛之谦', '棱镜', '周杰伦'}

• 清空集合

  语法：集合.clear()，功能，清空集合
  结果：集合本身被清空

set = {"周杰伦", "薛之谦", "棱镜", "夏企"}
set.clear()
print(f"集合被清空啦，结果是：{set}")  #集合被清空啦，结果是：set()

• 取出两个集合的差集

  语法：集合1.difference(集合2)，功能：取出集合1和集合2的差集（集合1有而集合2没有的）
  结果：得到一个新集合，集合1和集合2不变

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"取出差集后的结果是：{set3}")    #取出差集后的结果是：{2, 3}
print(f"取差集后，原有set1的内容：{set1}")    #取差集后，原有set1的内容：{1, 2, 3}
print(f"取差集后，原有set2的内容：{set2}")    #取差集后，原有set2的内容：{1, 5, 6}

• 消除两个集合的差集

  语法：集合1.difference_update(集合2)
  功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。
  结果：集合1被修改，集合2不变

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后，集合1结果：{set1}")    #消除差集后，集合1结果：{2, 3}
print(f"消除差集后，集合2结果：{set2}")    #消除差集后，集合2结果：{1, 5, 6}

• 两个集合合并

  语法：集合1.union(集合2)
  功能：将集合1和集合2组合成新集合
  结果：得到新集合，集合1和集合2不变

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"2集合合并结果：{set3}")    #2集合合并结果：{1, 2, 3, 5, 6}
print(f"合并后集合1：{set1}")    #合并后集合1：{1, 2, 3}
print(f"合并后集合2：{set2}")    #合并后集合2：{1, 5, 6}

• 查看集合的元素数量

  语法：len(集合)
  功能：统计集合内有多少元素
  结果：得到一个整数结果

set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
num = len(set1)
print(f"集合内的元素数量有：{num}个")   #集合内的元素数量有：5个

• 集合同样支持使用for循环遍历

# 集合的遍历
# 集合不支持下标索引，不能用while循环
# 可以用for循环
set1 = {1, "a", "b", 4, 5}
for element in set1:
    print(f"集合的元素有：{element}")
#

六、字典{}

使用{}存储原始，每一个元素是一个键值对
Key和Value可以是任意类型的数据（key不可为字典）
Key不可重复，重复会对原有数据覆盖

my_dict1 = {"王力鸿": 99, "王力鸿": 88, "林俊节": 77}
print(f"重复key的字典的内容是：{my_dict1}")
#重复key的字典的内容是：{'王力鸿': 88, '林俊节': 77}

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

my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
# 定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f"字典1的内容是：{my_dict1}, 类型：{type(my_dict1)}")
print(f"字典2的内容是：{my_dict2}, 类型：{type(my_dict2)}")
print(f"字典3的内容是：{my_dict3}, 类型：{type(my_dict3)}")
#字典1的内容是：{'王力鸿': 99, '周杰轮': 88, '林俊节': 77}, 类型：<class 'dict'>
#字典2的内容是：{}, 类型：<class 'dict'>
#字典3的内容是：{}, 类型：<class 'dict'>

编号	操作	说明
1	字典[Key]	获取指定Key对应的Value值
2	字典[Key] = Value	添加或更新键值对
3	字典.pop(Key)	取出Key对应的Value并在字典内删除此Key的键值对
4	字典.clear()	清空字典
5	字典.keys()	获取字典的全部Key，可用于for循环遍历字典
6	len(字典)	计算字典内的元素数量

• 新增元素

  语法：字典[Key] = Value，结果：字典被修改，新增了元素

• 更新元素

  语法：字典[Key] = Value，结果：字典被修改，元素被更新
  注意：字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值

• 删除元素

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

• 清空字典

  语法：字典.clear()，结果：字典被修改，元素被清空

• 获取全部的key

  语法：字典.keys()，结果：得到字典中的全部Key

• 遍历字典

  语法：for key in 字典.keys()

结果：

​ 字典不支持下标索引，所以同样不可以用while循环遍历

计算字典内的全部元素（键值对）数量
语法：len(字典)
结果：得到一个整数，表示字典内元素（键值对）的数量

从字典中用key获取value

my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
score = my_dict1["王力鸿"]
print(f"王力鸿的考试分数是：{score}")
score = my_dict1["周杰轮"]
print(f"周杰轮的考试分数是：{score}")

嵌套字典

stu_score_dict = {
    "王力鸿": {
        "语文": 77,
        "数学": 66,
        "英语": 33
    }, "周杰轮": {
        "语文": 88,
        "数学": 86,
        "英语": 55
    }, "林俊节": {
        "语文": 99,
        "数学": 96,
        "英语": 66
    }
}
print(f"学生的考试信息是：{stu_score_dict}")
#学生的考试信息是：{'王力鸿': {'语文': 77, '数学': 66, '英语': 33}, '周杰轮': {'语文': 88, '数学': 86, '英语': 55}, '林俊节': {'语文': 99, '数学': 96, '英语': 66}}

看周杰伦的语文信息：

score = stu_score_dict["周杰轮"]["语文"]
print(f"周杰轮的语文分数是：{score}")       #周杰轮的语文分数是：88
score = stu_score_dict["林俊节"]["英语"]
print(f"林俊节的英语分数是：{score}")       #林俊节的英语分数是：66

字典特点：

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

总结

数据容器可以从以下视角进行简单的分类：
是否支持下标索引

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

是否支持重复元素：

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

是否可以修改

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

** **	列表	元组	字符串	集合	字典
元素数量	支持多个	支持多个	支持多个	支持多个	支持多个
元素类型	任意	任意	仅字符	任意	Key：Value Key：除字典外任意类型 Value：任意类型
下标索引	支持	支持	支持	不支持	不支持
重复元素	支持	支持	支持	不支持	不支持
可修改性	支持	不支持	不支持	支持	支持
数据有序	是	是	是	否	否
使用场景	可修改、可重复的一批数据记录场景	不可修改、可重复的一批数据记录场景	一串字符的记录场景	不可重复的数据记录场景	以Key检索Value的数据记录场景