墨海思微澜
Series
Appearance

五、容器

2018/12/30PythonPython语言

容器是一种可以存储多个元素的数据类型

Python中的容器有： 列表list ， 元组tuple ， 字符串str ， 集合set ， 字典dict

1. 列表list

列表是多个元素的集合

列表的定义

赋值定义

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

空列表定义

列表变量名称 = []
或
列表变量名称 = list()

我们看下示例：

# 定义一个有多元素的列表
list1 = ["java", "python", "c"]
print(f"list1={list1},类型：{type(list1)}")
# 定义空列表
list2 = []
list3 = list()
print(f"list2={list2}")
print(f"list3={list3}")
list2 = list1
list3 = list2
print(f"list2={list2}")
print(f"list3={list3}")
# 列表里元素类型没有限制
list4 = ["python", 222, 3.14, False]
print(f"list4={list4}")
# 列表里可以嵌套列表
list5 = [[1, 2, 3], [4, 5, 6]]
print(f"list5={list5}")

执行结果：

image-20240512170403781

  • 列表里元素类型没有限制
  • 列表里可以嵌套列表

列表的下标索引

我们可以通过列表的下标索引获取列表元素。

下标索引从0开始，第一个元素下标索引是0，第二个元素下标索引是1，...第N个元素下标索引是N-1

示例：

# 定义一个有多元素的列表
list1 = ["java", "python", "c"]
print(f"list1={list1},类型：{type(list1)}")
# 通过正向索引获取列表元素
print(list1[0])
print(list1[1])
print(list1[2])

执行结果：

image-20240512171411369

下标不要越界，否则就会越界错误

image-20240512171629304

或者通过反向索引也可以获取列表元素。索引从-1开始，最后一个元素下标索引是-1，倒数第二个元素下标索引是-2，...倒数第N个元素的下标索引是-N

举例：

# 定义一个有多元素的列表
list1 = ["java", "python", "c"]
print(f"list1={list1},类型：{type(list1)}")

# 通过反向索引获取列表元素
print(list1[-1])
print(list1[-2])
print(list1[-3])

执行结果：

image-20240512171826553

通过下标索引获取嵌套列表的数据

# 列表里可以嵌套列表
list5 = [[1, 2, 3], [4, 5, 6]]
# 获取第一个嵌套列表的里面的第二个元素
print(list5[0][1])

列表的常用方法

列表list对象提供了很多内置方法 供我们操作list。我们要掌握常用的list方法。(具体类和对象，方法我们后面详细讲解)

（1）修改指定位置的元素值

列表[下标索引]=值

示例：

# 1.修改指定位置的元素值
list1 = ["java", "python", "c"]
print(list1)
# 修改指定位置的元素值
list1[1] = "python222"
list1[-1] = "c222"
print(list1)

执行结果：

image-20240512172836405

（2）index(元素)方法，查找列表中指定元素的下标，不存在就报错

示例：

# 2.index(元素)方法，查找列表中指定元素的下标，不存在就报错
list2 = ["java", "python", "c"]
index = list2.index("python")
print(index)

（3）insert(下标,元素)，在指定下标位置元素之前，插入元素

list3 = ["java", "python", "c"]
# insert(下标,元素)，在指定下标位置元素之前，插入元素
list3.insert(1, "php")
print(list3)

执行结果：

image-20240512173407950

（4）append(元素)，将指定元素，追加到列表的尾部

list4 = ["java", "python", "c"]
# append(元素)，将指定元素，追加到列表的尾部
list4.append("php")
print(list4)

执行结果：

image-20240512173536333

（5）extend(容器)，追加容器数据到列表最后

list5 = ["java", "python", "c"]
# extend(容器)，追加容器数据到列表最后
list5.extend(["php", "c#"])
print(list5)

执行结果：

image-20240512173701833

（6）del 列表[下标] 删除指定下标的元素

list6 = ["java", "python", "c"]
# del 列表[下标] 删除指定下标的元素
del list6[1]
print(list6)

执行结果：

image-20240512173844404

（7）pop(元素下标) ，取出元素。从列表中删除这个元素，方法返回该元素。（下标越界就报错）

list7 = ["java", "python", "c"]
# pop(元素下标) ，取出元素。从列表中删除这个元素，方法返回该元素
ele = list7.pop(1)
print(list7, ele)

执行结果：

image-20240512225252105

（8）remove(元素)，删除指定元素在列表中的第一个匹配项

list8 = ["java", "python", "c", "python", "php"]
# remove(元素)，删除指定元素在列表中的第一个匹配项
list8.remove("python")
print(list8)

执行结果：

image-20240512225518099

（9）clear()清空列表

list9 = ["java", "python", "c"]
# clear()清空列表
list9.clear()
print(list9)

执行结果：

image-20240512225833351

（10）count(元素) 统计某元素在列表中的个数

list10 = ["java", "python", "c", "python", "php"]
# count(元素) 统计某元素在列表中的个数
count = list10.count("python")
print(count)

执行结果：

image-20240512233608543

（11）len(列表)，统计列表内一共有多少元素

list11 = ["java", "python", "c", "python", "php"]
# len(列表)，统计列表内一共有多少元素
print(len(list11))

执行结果：

image-20240512233740513

列表的遍历

假如需要获取列表的所有元素，我们可以通过前面学过的while或者for循环遍历来获取；

for循环案例：

list1 = ["java", "python", "c"]
for ele in list1:
    print(ele)

while循环案例：

list1 = ["java", "python", "c"]
i = 0
while i < len(list1):
    ele = list1[i]
    print(ele)
    i += 1

2. 元组tuple

元组是多个元素的集合，但是不能修改，区别于列表。

元组的定义

赋值定义

元组变量名称 =( 元素1, 元素2, 元素3, 元素4, ... )

空元组定义

元组变量名称 =()
或
元组变量名称 = tuple()

假如只有一个元素，后面要加个逗号，否则会当做字符串定义处理

示例代码：

"""
    元组的定义
"""
# 赋值定义
t1 = ("java", "python", "c")
print(f"t1={t1},类型={type(t1)}")

# 注意点，假如只有一个元素，后面要加个逗号，否则会当做字符串定义处理
t2 = ("java")
print(f"t2={t2},类型={type(t2)}")

t3 = ("java",)
print(f"t3={t3},类型={type(t3)}")

# 空元组定义
t4 = ()
t5 = tuple()
print(f"t4={t4},类型={type(t4)}")
print(f"t5={t5},类型={type(t5)}")

# 元组里元素类型没有限制
t6 = ("python", 222, 3.14, False)
print(f"t6={t6},类型={type(t6)}")

# 元组里可以嵌套元组
t7 = ((1, 2, 3), (4, 5, 6))
print(f"t7={t7},类型={type(t7)}")

执行结果：

image-20240717160839842

元组的常用方法

下标索引用法和列表一样，唯一区别就是不能修改元素

示例代码：

"""
    元组的常用方法
"""
# 下标索引用法和列表一样，唯一区别就是不能修改元素
t1 = ("java", "python", "c")
# t1[1] = "python22" 不能修改
print(t1[1])
print(t1[-1])
# 元组里可以嵌套元组
t7 = ((1, 2, 3), (4, 5, 6))
print(t7[1][1])

执行结果：

image-20240717163455590

因为元组不能修改，所以方法比较少；

image-20240717163546028

  1. index(元素)方法，查找元组中指定元素的下标，不存在就报错
t2 = ("java", "python", "c")
print(t2.index("python1"))

image-20240717163917664

  1. count(元素) 统计某元素在元组中的个数
t3 = ("java", "python", "c", "python", "php")
print(t3.count("python"))
  1. len(元组)，统计元组内一共有多少元素
t4 = ("java", "python", "c", "python", "php")
print(len(t4))

元组的遍历

示例代码：

# for遍历
t11 = ("java", "python", "c")
for ele in t11:
    print(ele)

# while遍历
i = 0
while i<len(t11):
    ele = t11[i]
    print(ele)
    i += 1

执行结果：

image-20240717164625885

3. 字符串str

字符串是多个字符的集合，同元组一样，是无法修改字符串内容的。

字符串的定义

字符串变量="内容"

示例代码：

str1 = "******* 是个学习python的好地方"
print(f"str1={str1}，类型是：{type(str1)}")

执行结果：

image-20240717170125735

字符串的常用方法

下标索引操作和前面的列表，元组用法一样。

虽然字符串不能被修改，但是返回一个操作过的新字符串，所以方法还不少。

  1. index(元素)方法，查找字符串中指定元素的下标，不存在就报错
str2 = "thon222 是个学习python的好地方"
print(str2.index('222'))

  1. replace(old字符串1，new字符串2)，把字符串内的所有字符串1,替换成字符串2，然后方法返回一个新字符串。(不是修改字符串操作)

    注： 如果不想全部替换，只替换前几个用 replace(old字符串1，new字符串2，count)方法。

str3 = "python训练营 是个学习python的好地方,我要成为python老司机"
str3_2 = str3.replace("python", "java")
print(str3)
print(str3_2)
str3_3 = str3.replace("python", "java", 2)
print(str3_3)

执行结果：

image-20240717171053964

  1. split(分隔符字符串)，根据指定的分隔符字符串，将字符串分割成多个字符串，并存入列表对象中，方法返回列表对象。(不是修改字符串操作)
str4 = "java php python"
str5 = "java,php,python"
l1 = str4.split(" ")
l2 = str5.split(",")
print(f"l1={l1},type={type(l1)}")
print(f"l2={l2},type={type(l2)}")

执行结果：

image-20240717171336099

  1. strip()，去掉前后空格，返回新的字符串；strip(字符串)，还可以去掉前后指定的字符串，返回新的字符串
str6 = "  java php python  "
print(str6.strip())
str7 = "@%java php python%@"
print(str7.strip("@%"))
print(str6)
print(str7)

执行结果：

image-20240717171735679

  1. count(字符串)，统计字符串中出现指定字符串的个数
str8 = "java php python"
print(str8.count("th"))
  1. len(字符串)，统计字符串的长度
str9 = "java php python"
print(len(str9))

输出： 15

4. 容器序列切片

序列是指内容连续且有序的一类数据容器。

前面学的列表，元组，字符串都是序列，并且支持下标索引。

切片是指从一个序列中，取出一个子序列。

语法： 序列[起始下标:结束下标:步长]，返回一个新的序列

注意点： 步长默认是1 ；结束下标不包括

示例代码：

# 对列表进行切片
list1 = [0, 1, 2, 3, 4, 5, 6, 7]
print(list1[1:4:1])
print(list1)

# 对元组进行切片
tuple1 = (0, 1, 2, 3, 4, 5, 6, 7)
print(tuple1[:])  # 起始下标:结束下标不写默认获取全部
print(tuple1[::2])  # 步长2

# 对字符串进行切片
str1 = "01234567"
print(str1[::-1])  # 反向获取
print(str1[::-2])  # 反向获取
print(str1[6:3:-1])  # 反向获取
print(str1[6:3:-2])  # 反向获取

执行结果：

image-20240717173712479

5. 集合set

集合是多个元素的集合，但是不能有重复元素，区别于列表[]，元组()和字符串""。

集合的定义

赋值定义

集合变量名称 ={ 元素1, 元素2, 元素3, 元素4, ... }

空集合定义

集合变量名称 = set()

示例：

# 定义集合
set1 = {"php", "java", "python"}
print(f"set1={set1},type={type(set1)}")
# 定义空集合
set2 = set()
print(f"set2={set2},type={type(set2)}")

执行结果：

image-20240719154919414

集合的常用方法

因为集合是无序的，所以集合不支持下标索引访问。集合和列表一样，也是可以修改的。

  1. add(元素)，添加元素到集合，假如元素集合里存在，则忽略
set1 = {"php", "java", "python"}
set1.add("c")
set1.add("python")
print(set1)

执行结果： 顺序不定，每次执行都不一样。

image-20240719155418997

  1. pop()，随机从集合中获取一个元素，并且返回。
set2 = {"php", "java", "python"}
ele = set2.pop()
print(set2, ele)

执行结果： 取出的元素不一定，每次执行都不一样。

image-20240719155659942

  1. clear()，清空集合
set3 = {"php", "java", "python"}
set3.clear()
print(set3)

执行结果：

image-20240719155915659

  1. 集合1.difference(集合2) 返回差集（集合1有但是集合2没有的新集合）
set4 = {"a", "b", "c"}
set5 = {"a", "d", "e"}
print(set4.difference(set5))
print(set4)
print(set5)

执行结果：

image-20240719160248071

  1. 集合1.difference_update(集合2) ,删除差集。集合1内，删除和集合2相同的元素
set6 = {"a", "b", "c"}
set7 = {"a", "d", "e"}
set6.difference_update(set7)
print(set6)
print(set7)

执行结果：

image-20240719160541914

  1. 集合1.union(集合2)，返回合并集合1，集合2后的新集合
set8 = {"a", "b", "c"}
set9 = {"a", "d", "e"}
print(set8.union(set9))
print(set8)
print(set9)

执行结果：

image-20240719160832474

  1. len(集合)统计元素个数
set10 = {"z","b","c"}
print(len(set10))

输出：3

集合的遍历

因为集合不支持下标索引，所以不能用while循环。我们用for循环遍历

示例：

set1 = {"php", "java", "python"}
for ele in set1:
    print(ele)

执行结果：

image-20240719161407748

6. 字典dict

字典也是Python提供的一种常用的数据结构，它用于存放具有映射关系的数据。

字典的定义

比如有成绩表数据——语文：68，数学：98，英语: 76，这组数据看上去像两个列表，但这两个列表的元素之间有一定的关联关系。如果单纯使用两个列表来保存这组数据，则无法记录两组数据之间的关联关系。

为了保存具有映射关系的数据，Python提供了字典，字典相当于保存了两组数据，其中一组数据是关键数据，被称为key；另一组数据可通过key来访问，被称为 value。形象地看，字典中key和 value的关联关系如下图所示。

image-20240719162031473

字典的定义：

字典赋值定义

dict1={ key:value , key:value , ... , key:value }

空字典定义

dict2={}
或
dict3=dict()

示例：

# 字典赋值定义
dict1 = {"语文": 68, "数学": 98, "英语": 76}
print(f"dict1={dict1},type={type(dict1)}")
# 空字典定义
dict2 = {}
dict3 = dict()
print(f"dict2={dict2},type={type(dict2)}")
print(f"dict3={dict3},type={type(dict3)}")

执行结果：

image-20240719162503809

key不能重复，否则新的key:value 会覆盖老的key:value

字典的嵌套：

复杂业务逻辑下，我们可以通过字典的嵌套。

字典的value 可以是任意数据类型，但是key不能是字典类型

我们举例，设计学生的成绩单。

dict5 = {
    "张三": {"语文": 58, "数学": 38, "英语": 16},
    "李四": {"语文": 78, "数学": 58, "英语": 96},
    "王五": {"语文": 68, "数学": 98, "英语": 76}}
print(f"dict5={dict5},type={type(dict5)}")

字典的常用方法

  1. 通过key值来获取对应的value 语法：字典["Key"] 也可以单引号，如果访问的key在字典里不存在，则报错；增强方法： get("key")，根据key获取对应的value值。假如不存在，不报错，返回None
# 通过key值来获取对应的value
dict1 = {"语文": 68, "数学": 98, "英语": 76}
print(dict1["语文"])
print(dict1['数学'])
print(dict1["英语"])
print(dict1.get("语文"))
dict2 = {
    "张三": {"语文": 58, "数学": 38, "英语": 16},
    "李四": {"语文": 78, "数学": 58, "英语": 96},
    "王五": {"语文": 68, "数学": 98, "英语": 76}}
print(dict2["张三"]["数学"])
print(dict2["王五"]['英语'])

执行结果：

image-20240719163648398

  1. 新增或者修改元素，语法：字典["Key"]=Value 如果key不存在，就是新增，如果key存在，就是修改。

    update("{key:value}") 功能一样

    update("{key1:value1,key2:value2}") 但是可以一次操作多个键值对

dict3 = {"语文": 68, "数学": 98, "英语": 76}
# key不存在，新增元素
dict3["体育"] = 77
print(dict3)
# key存在，修改元素
dict3["数学"] = 55
print(dict3)
dict3.update({'语文': 10})
dict3.update({'计算机': 50})
print(dict3)
dict3.update({'语文': 20, '计算机2': 50})
print(dict3)

执行结果：

image-20240719164212554

  1. 删除元素。语法：字典.pop("Key") 字典中删除该key:value元素，
dict4 = {"语文": 68, "数学": 98, "英语": 76}
print(dict4.pop("数学"))
print(dict4)

执行结果：

image-20240719164547298

  1. 清空元素。语法：clear()
dict5 = {"语文": 68, "数学": 98, "英语": 76}
dict5.clear()
print(dict5)

执行结果：

image-20240719164727798

  1. 获取所有key。语法字典.keys()。返回值类型的是 dict_keys 类对象
dict6 = {"语文": 68, "数学": 98, "英语": 76}
print(f"keys={dict6.keys()},type={type(dict6.keys())}")

执行结果：

image-20240719165018144

  1. 遍历字典先获取字典的keys，然后遍历keys，通过key获取字典值
dict7 = {"语文": 68, "数学": 98, "英语": 76}
keys = dict7.keys()
for key in keys:
    print(f"{key}:{dict7.get(key)}")

执行结果：

image-20240719165315345

遍历方式2 遍历字典，每次拿到的也是key 以后我们就用这种简单方式，不用获取keys

for key in dict7:
    value = dict7[key]
    print(key, value)
  1. 统计字典元素的总数量，len(字典)
dict8 = {"语文": 68, "数学": 98, "英语": 76}
print(len(dict8))

输出：3

最近一次更新 3/20/2025, 7:54:12 AM
☆本文目录☆