1. 概述

数据容器的目的是运用少量的彬良存储大量数据，如一个name变量存储多个名字。使变量的运用更加高效。

数据容器的的概念是：一种额可以容纳多份数据的数据的数据类型，容纳的每份数据称之为一个元素，每一个元素可以说任意 类型的数据类型，如字符串，数字，布尔等。

容器有五类：

  1. 列表（list）
  2. 元组（tuple）
  3. 字符串（str）
  4. 集合（set）
  5. 字典（dirt）

根据如下特点划分：

  • 是否支持相同元素
  • 是否可以修改
  • 是否有序

2. 列表（list）

2.1 列表基本定义

基本语法如下

1
2
3
4
5
6
#定义变量
变量名称=[元素1，元素2，...]

#定义空列表
变量名=[]
变量名=list()
  • 列表的标志为[]
  • 列表的每一个元素用逗号隔开
  • 空列表的定义中list定义时用小括号而非中括号

示例

1
2
3
my_list=["吃喝不愁"，987，False]
print(my_list)
print(type(my_list))

运行结果如下：

image-20231207160851648

类型为list（列表）类型

列表的元素不仅可以用来存储常规数据，也可以存储另一个列表，即列表的嵌套。

格式如下：

1
列表名称=[列表1,列表2,列表3]

示例：

1
2
3
4
5
6
7
8
9
10
#1
my_list1=[[112,3423,54],["akfjh","sdkaj","aksjd"]]
#2
list1=[123,543,12]
list2=["aksud","iasjudh","skajd"]
my_list2=[list1,list2]

    print(my_list1)
    print(my_list2)
    print(type(my_list1),type(my_list2))

输出结果为

image-20231207161656361

2.2 常用操作

列表的取出可以使用下标索引

基本语法为：

1
列表名称[元素下标]
  • 在这里元素下标第一个从0开始，依次往后推，如果从后往前从-1开始
  • 如果是嵌套列表则用两个[]

示例

1
2
3
4
5
6
7
8
9
#1
my_list1=["吃喝不愁"，987，False]
print(f"第一个元素为{my_list1[0]}")
print(f"第一个元素倒序为{my_list1[-3]}")
#2
list1=[123,543,12]
list2=["aksud","iasjudh","skajd"]
my_list2=[list1,list2]
print(f"第一个子列表的第二个元素为{my_list2[0][1]}")

基本操作如下表

使用方式 作用
名称.append(元素) 向列表中添加一个元素
名称.extend(容器) 将目标容器的元素取出追加到列表的末尾
名称.insert(下标,元素) 在指定下标处插入指定元素，原指定下标元素及其以后的元素编号+1
del 名称[下标] 删除列表指定下标元素
名称.pop(下标) 删除下标指定元素并且返回
名称.remove(元素) 从前向后删除第一个与之匹配的元素
名称.clear() 清空此列表
名称.count(元素) 统计这个元素在列表中出现次数
名称.index() 查找指定元素下标位置，如果没有就报错ValueError
len（名称） 统计列表内有多少元素

3. 元组（tuple）

3.1 元组基本定义

元组与列表区别在于不可修改。定义后只读。

当我们封装的数据不想让其被修改则用元组

基本语法如下：

1
2
3
4
5
6
7
#1
(元素1,元素2,元素3,....)
#2
变量名称=(元素1,元素2,元素3,....)
#定义空元组
变量名称=()
变量名称=tuple()

  • 元组在定义上与列表是括号的不同，元组也支持不同数据类型混搭

  • 空元组两种方式均用小括号

元组不可以修改，但是如果元组中包含列表，则列表对应内容可以修改

示例：

1
2
3
4
5
6
7
8
9
#1
my_tuple=(123,453,[123,432])
del my_tuple[2][1]
print(my_tuple)
#2
list=[1,43,12]
my_tuple2=(list,32,65,"tu")
my_tuple2[0].append("hello")
print(my_tuple2)

运行结果如下：

image-20231208153918364

3.2 元组常规操作

元组由于其不可修改特性，所以具有操作的方式如下

使用方式 作用
名称.index(元素) 查找某个元素下标
名称.count(元素) 统计某个元素出现次数
len(元组) 统计元组有多少元素

4. 字符串及其操作（str）

字符串的本质为一个容器，并且不可修改。

但是字符串拥有替换功能（replace）

基本语法如下：

1
字符串.replace(字符串1，字符串2)

其功能为将字符串1内容换为字符串2内容。从而==得到一个新的字符串==

示例

1
2
3
4
my_st="you and me"
new_st=my_st.replace("me","him")
print(my_st)
print(new_st)

结果如下：

image-20231208155759283

原字符串并未改变

字符串还可以进行分割（split）

基本语法如下：

1
字符串.split(分割字符串)

功能：将字符串分割成多个字符串

==将会得到一个列表，而字符串本体不变==

示例：

1
2
3
str="hello you and me"
list=str.split(" ")#这里我们将有空格的地方分开
print(list)

结果如下

image-20231208172800281

字符串的整规功能(strip)

基本语法如下：

1
字符串.strip(字符串)#若不填则默认为空格

示例：

1
2
3
4
my_str1=" hello "
print(my_str1.strip())
my_str2="1221hello221"
print(my_str2.strip("122"))

输出结果如下：

image-20231208173504300

字符串也可以进行count和len的功能

字符串的另一个特性：切片（列表和元组均支持）：

基本语法：

1
序列[开始元素下标：结束元素下标：步长]

在这个语法中需要注意的是：

  • 起始和结束都可以省略，表示从头开始直到结尾，步长空着默认为1
  • 步长为1为一个一个取，为2则取一个跳过一个，如果为负数则倒着取
  • 结束时不包含结束元素下标
  • 开始元素和结束元素可以取负

示例：

1
2
3
4
5
6
7
8
9
10
11
str="爱党爱国爱人民"

print(str)
print(str[:])
print(str[0:3:2])
print(str[4:6:-1])
print(str[2:])
print(str[:4])
print(str[-3:-1])
print(str[-3:])
print(str[:-3])

结果如下

image-20231208174433051

5. 集合（set）

集合特点：

  • 没有重复元素（即使录入了输出时也只会留下一个）
  • 无序（不支持下标索引）

基本语法：

1
2
3
4
5
6
#1
{元素1,元素2,元素3}
#2
集合名称={元素1,元素2,元素3}
#3
集合名称=()

示例集合的基础使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
my_set1={12,345,4532,123}
print(my_list)

#集合添加元素
my_set1={12,345,4532,123}
my_set1.add("hello")

#随机取出(移除一个元素)
my_set1={12,345,4532,123}
ele=my_set1.pop()
print(ele)

#移除元素
my_set1={12,345,4532,123}
ele2=my_set1.remove(123)
print(my_set1)

#清空集合
my_set1={12,345,4532,123}
my_set1.clear()
print(my_set1)

集合的差集：重新得到一个集合，集合1有而集合2没有的元素组成的集合

基本语法如下

1
集合1.difference(集合2)

示例：

1
2
3
4
my_set1={12,345,4532,123}
my_set2={12,345,123}
dif=my_set1.difference(my_set2)
print(dif)

消除差集：在集合1内删除集合2的内容

基本语句如下：

1
集合1.difference_update(集合2)

示例：

1
2
3
4
my_set1={12,345,4532,123}
my_set2={12,345,123}
my_set1.difference_update(my_set2)
print(my_set1)

集合合并：将两个集合合并为一个

基本语法：

1
集合1.union(集合2)

示例：

1
2
3
4
my_set1={12,345,4532,123}
my_set2={12,345,123,"hello"}
my_set3=my_set1.union(my_set2)
print(my_set3)

注意：

  1. 集合的添加元素使用add
  2. 集合的差集时得到一个新集合并非改变原集合
  3. 消除差集则是修改了集合1内容，没有改变集合2内容
  4. 集合合并后相同元素会只存在一个被保留

6. 字典（dirt）

字典的功能是存储键值对，通过key找值

1
2
3
4
5
6
7
#1
{key1:value1,key2:value,key3:value}
#2
字典名={key1:value1,key2:value,key3:value}
#3
字典名称={}
字典名称=dict()

==注意：字典的key值不能重复，value可以重复==

示例：

1
2
my_dirt={"张三":13,"李四":14,"王五":15}
print(my_dirt["张三"])

字点新增元素和改变value

基本语法：

1
2
my_dirt={key1:value1,key2:value,key3:value}
my_dirt[key]=value0

==当key已经存在于字典时则是修改value==

==如果 不存在key则相当于添加键值对==

字典删除和清空：

删除基本语法：

1
字典.pop(key)

==将key对应的value取出，同时字典被修改，对应键值对被删除==

清空基本语法：

1
字典.clear()

字典获取全部key

基本语法：

1
字典.keys()

示例：

1
2
3
my_dirt={"张三":13,"李四":14,"王五":15}
keys=my_dirt.keys()
print(keys)

输出结果为：

image-20231208182456728

字典的遍历

字典低遍历结果是显示key值，如果需要显示value值需要使用dirt[key]

示例：

1
2
3
4
my_dirt={"张三":13,"李四":14,"王五":15}
for key in my_dirt:
    print(f"字典key为{key}")
    print(f"字典value为{my_dirt[key]}")

结果为：

image-20231208182958321

字典也支持使用len函数统计数量

7. 容器通用操作

max（容器）：找到容器中最大的值

min（容器）：找到到容器中最小值

list（容器）：将容器转化为列表

tuple（容器）：将容器转化为元组

str（容器）：将容器转化为字符串

sorted（容器,[reverse=Ture]）(中括号为是否开起倒序排序,中括号使用时去掉)：排序

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
example="123 aksdfkdj 12987"
my_dirt={"张三":13,"李四":14,"王五":15}
list2=list(my_dirt)
list1=list(example)
tuple1=tuple(example)
print(list1)
print(tuple1)
print(list2)

#排序
print(sorted(my_dirt))
print(sorted(example))
print(sorted(example,reverse=Ture)

结果如下：

image-20231208185035639

==注意：字典转化后只剩key，字符串转化后每个字符都被单独分出来了，在排序中字典也会丢失value==

资料参考

b站的黑马程序员