数据容器是一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。Python 提供了四种主要的内置容器，列表、元组、集合、字典。
1.列表(list)
（1）列表的定义：列表中存储元素的数据类型不受限制，甚至元素也可以是列表，这样就定义了嵌套列表。
# 定义空列表
list = []
list = list()
# 列表中的每一个数据，称为元素
list = [1, 2, 3]
# 列表的嵌套
list = [[1, 2, 3], [4, 5, 6]]
# 数据容器
# 列表(list)
# 定义一个列表
name_list = ["张三", "李四", "王五"]
print(name_list)
print(type(name_list))
# 列表中存储元素的数据类型不受限制
user_list = ["张三", 18, 178.2, True]
print(user_list)
print(type(user_list))
# 定义一个嵌套列表
num_list = [[1, 2, 3], [4, 5, 6]]
print(num_list)
print(type(num_list))
（2）列表的下标(索引):列表中的每一个元素，都有其对应的位置值，称为索引。
从左向右，从0开始，依次递增。
从右向左，从-1开始，依次递减。
使用下标索引即可取得相应的元素
语法：列表[下标索引]
# 嵌套列表下标(索引)
列表[下标索引][下标索引]
注意：下标索引的取值范围，超出范围无法取出元素并且会报错
列表的下标(索引)
# 通过下标(索引)取出对应位置的元素
name_list = ["张三", "李四", "王五"]
# 从左到右，从0开始，依次递增
print(name_list[0])
print(name_list[1])
print(name_list[2])
# 错误用法 列表中没有第四个元素，下标超出范围 print(name_list[3])
# 反向索引：从右到左，从-1开始，依次递减
print(name_list[-3])
print(name_list[-2])
print(name_list[-1])
# 取出嵌套列表的元素
num_list = [[1, 2, 3], [4, 5, 6]]
# 从左到右依次取出
print(num_list[0][0])
print(num_list[0][1])
print(num_list[0][2])
print(num_list[1][0])
print(num_list[1][1])
print(num_list[1][2])
# 1
print(num_list[-2][0])
# 1
print(num_list[-2][-3])
（3）列表的常用操作(方法)
1）查询
a.查询某元素的下标：查找指定元素在列表中的下标,如果找不到，报错ValueError
语法：列表.index(元素)
# 列表的常用操作
# 查询
# 查询某元素的下标
name_list = ["张三", "李四", "王五"]
# 查询元素"张三"在列表中的索引值,查询结果是正向索引值
index = name_list.index("张三")
print(f"\"张三\"在列表中的下标索引值是：{index}")
# 错误用法 "曹仁"不在列表中，会报错
# index = name_list.index("曹仁")
# print(f"\"曹仁\"在列表中的下标索引值是：{index}")
b.统计某元素在列表中的数量
语法：列表.count(元素)
# 查询
# 统计某元素在列表中的数量
name_list = ["张三", "李四", "王五", "张三", "张三"]
count = name_list.count("张三")
print(f"列表中\"张三\"元素的个数是：{count}")
c.统计列表中有多少个元素
语法：len(列表)
# 查询
# 统计列表中有多少个元素
name_list = ["张三", "李四", "王五", "张三", "张三"]
count = len(name_list)
print(f"列表中的元素的个数是：{count}")
2）插入
a.插入元素:在指定的下标位置，插入指定的元素
语法：列表.insert(下标, 元素)
# 插入元素
name_list = ["张三", "李四", "王五"]
# 在"张三"和"李四"中间插入"曹仁"这个元素
name_list.insert(1, "曹仁")
print(f"插入元素后的列表为：{name_list}")
name_list = ["张三", "李四", "王五"]
# 在"王五"后面插入"曹仁"这个元素,相当于在列表追加元素"曹仁"
name_list.insert(3, "曹仁")
print(f"插入元素后的列表为：{name_list}")
b.追加元素：将指定元素，追加到列表的尾部
语法：列表.append(元素)
# 追加元素
name_list = ["张三", "李四", "王五"]
# 在列表尾部追加元素"曹仁"
name_list.append("曹仁")
print(f"追加元素后的列表为：{name_list}")
c.追加一批元素，将其他数据容器的内容取出，依次追加到列表尾部
语法：列表.extend(其他数据容器)
# 追加一批元素
name_list = ["张三", "李四", "王五"]
name_list2 = ["曹仁", "李彪"]
name_list.extend(name_list2)
print(f"追加元素后的列表为：{name_list}")
3）修改
修改特定位置(索引)的元素值
语法：列表[下标] = 值
# 修改特定位置(索引)的元素值
name_list = ["张三", "李四", "王五"]
# 修改第二个元素的值为"曹仁"
name_list[1] = "曹仁"
print(f"列表中的第二个元素值是：{name_list[1]}")
# 错误用法：不能修改超出下标范围元素的值,即不能通过这种方法插入元素
# name_list[3] = "曹仁"
# print(f"列表中的第四个元素值是：{name_list[3]}")
4）删除
a.删除元素
语法：del 列表[下标]
语法：列表.pop(下标) 删除元素的同时的到元素值
# 删除元素
name_list = ["张三", "李四", "王五"]
# 删除"张三"方式一：
del name_list[0]
print(f"删除元素后的列表为：{name_list}")
name_list = ["张三", "李四", "王五"]
# 删除"张三"方式二：删除元素的同时的到元素值
element = name_list.pop(0)
print(f"删除元素后的列表为：{name_list}, 通过pop方法取出的元素是{element}")
b.删除某元素在列表中的第一个匹配项
语法：列表.remove(元素)
# 删除某元素在列表中的第一个匹配项
name_list = ["张三", "李四", "王五", "张三", "张三"]
name_list.remove("张三")
print(f"删除元素后的列表为：{name_list}")
c.清空列表
语法：列表.clear()
# 清空列表
name_list = ["张三", "李四", "王五"]
name_list.clear()
print(f"清空列表后的列表为：{name_list}")
（4）列表的遍历
遍历(迭代)：将容器内的元素依次取出进行处理
1）while循环
# 列表的遍历
# while循环
name_list = ["张三","李四","王五"]
# 定义一个变量，标记列表的下标
index = 0
# 循环条件：下标索引变量 < 列表的元素数量len(name_list)
while index < len(name_list):
element = name_list[index]
print(f"列表的元素：{element}")
# 每次循环下标索引变量 + 1
index += 1
2）for循环
# 列表的遍历
# for循环
name_list = ["张三","李四","王五"]
for element in name_list:
print(f"列表的元素：{element}")
（5）列表的特点
-
可以容纳多个元素
-
可以容纳不同类型的元素
-
数据是有序存储的(下标索引)
-
允许重复数据存在
-
可以修改(增加或删除元素)
2.元组(tuple)
（1）元组的定义：元组同列表一样，都是可以封装多个、不同类型的元素在内。但最大的不同点在于：元组一旦定义完成，就不可修改。
# 定义空元组
tuple = ()
tuple = tuple()
# 元组中的每一个数据，称为元素
tuple = (1, 2, 3)
# 定义单个元素的元组
tuple = ("hello", )
# 元组的嵌套
tuple = ((1, 2, 3), (4, 5, 6))
# 元组(tuple)
# 元组的定义
name_tuple = ("张三", "李四", "王五")
print(name_tuple)
print(type(name_tuple))
user_tuple = ("张三", 18, 178.5, False)
print(user_tuple)
print(type(user_tuple))
# 定义单个元素的元组,一定要在后面写上一个单独的逗号
single_tuple = ("hello", )
# 错误写法
# single_tuple = ("hello")
print(single_tuple)
print(type(single_tuple))
# 元组的嵌套
num_tuple = ((1, 2, 3), (4, 5, 6))
print(num_tuple)
print(type(num_tuple))
（2）元组的下标(索引)：同列表的下标索引
# 通过下标(索引)取出对应位置的元素
name_tuple = ("张三", "李四", "王五")
print(name_tuple[0])
print(name_tuple[1])
print(name_tuple[2])
# 错误用法 列表中没有第四个元素，下标超出范围 print(name_tuple[3])
# 反向索引：从右到左，从-1开始，依次递减
print(name_tuple[-3])
print(name_tuple[-2])
print(name_tuple[-1])
# 取出嵌套元组的元素
num_tuple = ((1, 2, 3), (4, 5, 6))
# 从左到右依次取出
print(num_tuple[0][0])
print(num_tuple[0][1])
print(num_tuple[0][2])
print(num_tuple[1][0])
print(num_tuple[1][1])
print(num_tuple[1][2])
# 6
print(num_tuple[-1][2])
# 1
print(num_tuple[-2][-3])
（3）元组的常用操作(方法)
1）查询
a.查询某元素的下标：查找指定元素在列表中的下标,如果找不到，报错ValueError
语法：列表.index(元素)
# 元组的常见操作
# 查询某元素的下标
name_tuple = ("张三", "李四", "王五")
index = name_tuple.index("李四")
print(f"\"李四\"元素在元组中的下标索引是：{index}")
b.统计某元素在列表中的数量
语法：列表.count(元素)
#统计某元素在元组中的数量
name_tuple = ("张三", "李四", "王五", "李四")
count = name_tuple.count("李四")
print(f"\"李四\"元素在元组中的数量是：{count}")
c.统计列表中有多少个元素
语法：len(列表)
# 统计元组中有多少个元素
name_tuple = ("张三", "李四", "王五", "李四")
count = len(name_tuple)
print(f"元组中的元素数量是：{count}")
2）修改：在元组内定义一个列表，可以修改列表的内容
name_tuple = ("张三","李四","王五")
# 修改元组内容，报错
# name_tuple[1] = "曹仁"
# 在元组内定义一个列表，尝试修改列表的内容
t1 = ("张三", ["李四", "王五"])
t1[1][0] = "曹仁"
print(f"修改后元组的内容：{t1}")
（4）元组的遍历
1）while循环
# 元组的遍历
# while循环
name_tuple = ("张三", "李四", "王五")
# 定义一个变量，标记列表的下标
index = 0
# 循环条件：下标索引变量 < 元组的元素数量len(name_tuple)
while index < len(name_tuple):
element = name_tuple[index]
print(f"元组的元素：{element}")
# 每次循环下标索引变量 + 1
index += 1
2）for循环
# 元组的遍历
# for循环
name_tuple = ("张三","李四","王五")
for element in name_tuple:
print(f"元组的元素：{element}")
（5）元组的特点
-
可以容纳多个元素
-
可以容纳不同类型的元素
-
数据是有序存储的(下标索引)
-
允许重复数据存在
-
不可以修改
3.字符串(string)
（1）从容器角度看字符串
字符串是字符的容器，一个字符串可以存放任意数量的字符。
同元组一样，字符串是一个无法修改的数据容器。
（2）字符串的下标索引：同列表、元组的下标索引
# 字符串
# 通过下标(索引)取出对应位置的元素
name = "Alice"
print(name[0])
print(name[-5])
# 字符串无法修改
# name = "Alice"
# name[0] = a
# print(name)
（3）字符串的常见操作
1）查询
a.查询某字符串的下标
语法：字符串.index(元素)
# 查询某字符串的下标
name = "Alice"
index = name.index("c")
print(f"字符串c在字符串中的列表索引值是：{index}")
word = "hello world"
index = word.index("o")
print(f"字符串o在字符串中的列表索引值是：{index}")
# 查找字符串的下标：返回字符串的第一个元素在字符串中的下标索引值
index1 = word.index("hello")
print(f"字符串\"hello\"在字符串中的列表索引值是：{index1}")
index2 = word.index("world")
print(f"字符串\"world\"在字符串中的列表索引值是：{index2}")
b.统计某字符串在字符串中的出现次数
语法：字符串.count(元素)
# 统计某字符串在字符串中的出现次数
word = "hello world, hello python"
count = word.count("o")
print(f"字符串\"o\"在字符串中的出现次数是：{count}")
word = "hello world, hello python"
count = word.count("hello")
print(f"字符串\"hello\"在字符串中的出现次数是：{count}")
c.统计字符串的长度
语法：len(字符串)
# 统计字符串的长度
word = "hello world, hello python"
count = len(word)
print(f"字符串的长度是：{count}")
2）字符串的替换
语法：字符串.replace(字符串1,字符串2) 将字符串的全部字符串1替换为字符串2
注意：不是修改字符串本身，而是得到了一个新的字符串
# 字符串的替换
name = "Alice"
name_replace = name.replace(name, "Tom")
print(f"替换后的字符串为：{name_replace}")
word = "hello world, hello python"
word_replace = word.replace("hello" ,"hi")
print(f"替换后的字符串为：{word_replace}")
word = "hello world, hello python"
word_replace = word.replace("e" ,"o")
print(f"替换后的字符串为：{word_replace}")
3）字符串的分割
语法：字符串.split(分隔符字符串) 按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中。
注意：字符串本身不变，而是得到了一个列表对象
# 字符串的分割
word = "hello world, hello python"
# 列表对象word_split
word_split = word.split(",")
print(f"将字符串分割后的得到的列表为：{word_split}, 其类型是{type(word_split)}")
4）字符串的规整操作
a.去前后空格
语法：字符串.strip()
# 字符串的规整操作
# 不传入参数，去前后空格
word = " hello world, hello python "
word_strip = word.strip()
print(f"规整后的字符串为：{word_strip}")
b.去前后指定字符串
语法：字符串.strip(指定字符串)
# 字符串的规整操作
# 传入参数
word = "9hello world, hello python9"
word_strip = word.strip("9")
print(f"规整后的字符串为：{word_strip}")
word = "12hello world, hello python21"
word_strip = word.strip("12")
print(f"规整后的字符串为：{word_strip}")
（4）字符串的遍历
1）while循环
# 字符串的遍历
# while循环
name = "Alice"
index = 0
while index < len(name):
element = name[index]
print(element)
index += 1
2）for循环
# 字符串的遍历
# for循环
name = "Alice"
for i in name:
print(i)
（5）字符串的特点
-
长度任意(取决于内存大小)
-
只可以存储字符串
-
支持下标索引
-
允许重复字符串存在
-
不可以修改
4.序列
（1）序列的定义
内容连续、有序，可使用下标索引的一类数据容器。
列表、元组、字符串，均可以视为序列。
（2）序列的切片操作：
a.切片操作：从一个序列中，取出一个子序列
b.语法：序列[起始下标:结束下标:步长] 从序列中指定位置开始，依次取出元素，到指定位置结束，得到一个新序列。
起始下标：可以为空(表示从头开始)
结束下标(不含)：可以为空(表示截取到结尾)
步长：表示依次取元素的间隔。步长为 n表示，每次跳过 n-1个元素取。步长为负数，反向取
c.注意：此操作不会影响序列本身，而是会得到一个新的序列(列表、元组、字符串)
列表的切片
# 数据容器(序列)的切片
# 列表的切片
my_list = [0, 1, 2, 3, 4, 5]
new_list = my_list[0:3:1]
print(f"切片后的列表为：{new_list}")
# 起始下标默认是0，步长默认是1
new_list = my_list[:3]
print(f"切片后的列表为：{new_list}")
# 起始下标默认是0，步长默认是1
new_list = my_list[:3:]
print(f"切片后的列表为：{new_list}")
# 结束下标默认截取到结尾，步长默认是1
new_list = my_list[3:]
print(f"切片后的列表为：{new_list}")
# 起始下标默认是0，结束下标默认截取到结尾，步长默认是1
new_list = my_list[:]
print(f"切片后的列表为：{new_list}")
# 步长为负数，反向取
# 结束下标默认截取到结尾
new_list = my_list[-4::-1]
print(f"切片后的列表为：{new_list}")
# 步长默认是1
new_list = my_list[-4:-1]
print(f"切片后的列表为：{new_list}")
# 起始下标默认是-1
new_list = my_list[:-4:-1]
print(f"切片后的列表为：{new_list}")
# 从3开始，到1结束，步长是-1
new_list = my_list[3:1:-1]
print(f"切片后的列表为：{new_list}")
元组的切片
# 数据容器(序列)的切片
# 元组的切片
my_tuple = (0, 1, 2, 3, 4, 5)
# 从1开始，到3结束，步长是2
new_tuple = my_tuple[1:3:2]
print(f"切片后的元组为：{new_tuple}")
# 从头开始，到尾结束，步长是-2
new_tuple = my_tuple[::-2]
print(f"切片后的元组为：{new_tuple}")
字符串的切片
# 数据容器(序列)的切片
# 字符串的切片
my_str = "012345"
# 从头开始，到3结束，步长是1
new_str = my_str[:3:]
print(f"切片后的字符串为：{new_str}")
# 从头开始，到尾结束，步长是1
new_str = my_str[::-1]
print(f"切片后的字符串为：{new_str}")
扫一扫
17万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
