文章目录
python数据容器
认识数据容器
-
数据容器：一种可以存储多个元素的python数据类型
-
python数据容器
-
list：列表
-
tuple：元组
-
str：字符串
-
set：集合
-
dict：字典
-
列表
列表定义
-
列表内的每一个数据，称为元素
-
列表内每一个元素之间用逗号隔开
-
注意：列表中一次可以存储多个数据，且可以为不同数据类型，支持嵌套
-
语法
python
# 字面量
[元素1, 元素2, 元素3, ...]
# 定义变量
变量名称 = [元素1, 元素2, 元素3, ...]
# 定义空列表
变量名称 = []
变量名称 = list()- 代码示例
python
# 定义列表
l1 = ["元素1", "元素2", "元素3"]
print(l1)
print(type(l1))
# 定义嵌套
l2 = [[1, 2, 3], [4, 5]]
print(l2)
print(type(l2))
l3 = [1, 2, True, 2.34, [1234]]
print(l3)
print(type(l3))list下标索引
-
从前向后：从0开始每次加1；从后往前：从-1开始，每次减1
-
注意：通过下标取数据，一定不能超出范围
-
代码示例
python
print(l2[0])
print(l2[0][1])
print(l2[-1][1])列表的常用操作
方法
- 方法：在python中，如果将函数定义为class类的成员，那么函数会称为方法
python
def add(x, y):
return x+y
class Student:
def add(x, y):
return x+y-
方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同
-
函数的使用：
add(1,2) -
方法的使用：
pythonstu=Student() stu.add(1,2) -
列表的查询功能
-
查找某个元素的下标
-
功能：查找指定元素在列表的下摆哦，如果找不到，报错ErrorValue
-
语法：列表.index(元素)
-
代码示例
python
mylist = [1, 2, 3]
# 查找元素在列表内的下标索引
print(f'2在列表中的下标索引是{mylist.index(2)}')
# ValueError: 4 is not in list
# print(f'2在列表中的下标索引是{mylist.index(4)}')列表的修改功能
-
修改特定位置的元素值
-
语法：
列表[下标]=值 -
代码示例
python
# 修改列表中的值
print(f'当前列表元素{mylist}')
print(f'修改0位置的元素为9')
mylist[0] = 9
print(f'当前列表元素{mylist}')
print(f'修改-2位置的元素为7')
mylist[-2] = 7
print(f'当前列表元素{mylist}')插入元素
-
语法：
列表.insert(下标,元素) -
代码示例：
python
print(f'当前列表元素{mylist}')
mylist.insert(1, 12)
print(f'当前列表元素{mylist}')追加元素
-
语法：列表.append(元素...)， 将指定元素追加到列表尾部
-
代码示例
python
mylist.append(mylist, 'hello')
mylist.append(mylist, 'h', 4, 18)删除元素
- 语法
python
# 语法1
del 列表[下标]
# 语法2
列表.pop(下标)- 代码示例
python
del mylist[1]
mylist.pop(1)删除某元素在列表中的第一个匹配项
-
语法：
列表.remove(元素) -
代码示例
python
mylist.remove('h')清空列表
- 语法：
列表.clear()
统计某元素在列表中的数量
- 语法：
列表.count(元素)
统计列表中元素个数
- 语法：
列表.len()
总结
列表遍历
- 代码示例
python
# while遍历
def list_while_func(l):
index = 0
while index < len(l):
print(l[index], end=' ')
index += 1
# for遍历
def list_for_func(l):
for i in l:
print(l[i], end=' ')
mylist = [1, 2, 3, 'a', True, "dsadas"]
list_while_func(mylist)
list_for_func(mylist)元组
为什么需要元组
-
列表是可以修改的，如果想要传递的信息不被修改，列表就不合适了
-
元组和列表最大的区别：元组一旦完成定义就不可修改
定义元组
-
元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同数据类型
-
语法
python
# 字面量
(元素1, 元素2, 元素3, ...)
# 定义变量
变量名称 = (元素1, 元素2, 元素3, ...)
# 定义空元组
变量名称 = ()
变量名称 = tuple()-
注意：元组只有一个数据时，这个数据后面要添加逗号，否则不是元组类型
-
代码示例
python
# 基本定义
t1 = (1, 2, 3, 'a', True)
# 单数据定义：元组只有一个数据时，这个数据后面要添加逗号
t2 = (1,)
# 嵌套定义
t3 = ((1, 2, 3), (4, 5))
print(t3)下标索引取出内容
-
同列表操作
-
代码示例
python
# 下标取元组内容
print(t3[1])
print(t3[1][1])元组相关操作
-
index：查找某个数据，如果数据存在返回对应的下标，否则报错
-
count：统计某个数据在当前元组出现的次数
-
len(元组)：统计元组内的元素个数
python
print(t1.index(3))
print(t1.count(3))
print(len(t1))元组的遍历
- 代码示例
python
for i in t3:
print(i, end=' ')
print()
index = 0
while (index < len(t1)):
print(t1[index], end=' ')
index += 1
print()字符串
特点
-
字符串是字符的容器，一个字符串可以存放任意数量的字符
-
字符串是一个无法修改的容器
-
只可以存储字符串
-
支持下标索引
-
允许重复字符串存在
-
for和while循环都支持
字符串的下标
-
从前向后：下标从0开始
-
从后向前：下标从-1开始
-
代码示例
python
name = "zhangsan"
print(name[1])
print(name[-4])字符串的常用操作
查找子串
-
语法：
字符串.index(字符串) -
代码示例
python
my_str = "we are happy"
print(my_str.index("are"))
# ValueError: substring not found
# print(my_str.index("are1"))字符串替换
-
语法：
字符串.replace(字符串1,字符串2) -
功能：将字符串内全部字符串1替换为字符串2
-
注意：替换
-
代码示例
python
# replace字符串替换
new_str = my_str.replac字符串分割
-
语法：
字符串.split(分割字符串) -
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
-
注意：字符串本身不变，而是得到一个列表对象
-
代码示例
python
# 字符串分割
split_str = my_str.split(' ')
print(f'分割后原字符串{my_str}')
print(f'分割后新字符串{split_str}')字符串规整
- 语法：
python
字符串.strip()
字符串.strip(字符串)- 代码示例
python
# 去掉字符串首尾空格
blank_str = " we ert dsf rew "
print(f'原始字符串:{blank_str}')
new_blank_str = blank_str.strip()
print(f'规整后字符串:{new_blank_str}')
blank_str1 = "@@@we ert dsf rew@@@"
print(f'原始字符串:{blank_str1}')
new_blank_str1 = blank_str1.strip('@')
print(f'规整后字符串:{new_blank_str1}')统计字符串出现次数
-
语法：
字符串.count(指定字符串) -
代码示例
python
# 统计字符串中某字符串出现次数
print(f'@字符串出现次数:{blank_str1.count("@")}')统计字符串长度
-
语法：
len(字符串) -
代码示例
python
# 统计字符串长度
print(f'字符串长度：{len(my_str)}')总结
数据容器(序列)的切片
序列
-
内容连续、有序，可使用下标索引的一类数据容器
-
列表、元组、字符串均可视为序列
切片
-
定义：从一个序列中取出另一个切片
-
语法：
序列[起始下标:结束下标:步长]-
起始下标表示从何处开始，可以为空，表示从头开始
-
结束下标表示从何处结束，可以为空，表示到尾结束
-
步长：表示依次取元素的间隔，可正可负
-
-
代码示例
python
# 对序列进行切片操作
# 正向操作
# 取列表中2到5位置，步长为1
l = [1, 2, 3, 4, 5, 6, 7]
s1 = l[2:5:1]
print(s1)
# 取元组中所有元素
t = (1, 2, 3, 4, 5, 6, 7)
s1 = t[:]
print(s1)
# 字符串反转
str = "dhjskkkk"
s1 = str[::-1]
print(s1)
# 反向操作：从3开始到1结束，步长为-1
s1 = l[3:1:-1]
print(s1)
# 从头开始到尾结束步长为-2
s1 = t[::-2]
print(s1)集合
特点
-
可以容纳多个元素，且类型可以不同
-
数据是无序存储，不支持下标操作
-
不允许重复数据存在
-
可以修改
-
支持for循环
基本语法
python
# 定义字面量集合
{元素1,元素2,元素3,元素4,...}
# 定义集合变量
变量名称={元素1,元素2,元素3,元素4,...}
# 定义空集合
变量名称=set()集合常用功能
- 代码示例
python
# *_*coding:utf-8 *_*
# 定义集合
my_set = {1, 2, 1, 1, True, 4.321, "dsadas"}
# 元素不能重复,会自动去重
# 内容是乱序的
print(f'包含重复元素的set结果{my_set}')
print(type(my_set))
my_set1 = set()
my_set2 = {}
print(f'空集合内容{my_set1}')
print(f'空集合内容{my_set2}')
# 常用操作
# 添加新元素
my_set1.add(1)
my_set1.add(2)
my_set1.add(5)
my_set1.add(6)
my_set1.add(7)
my_set1.add(1)
my_set1.add(3)
print(f'add添加元素后结果是{my_set1}')
# 移除元素
# remove移除置顶元素
my_set1.remove(2)
print(f'remove移除元素后结果是{my_set1}')
# pop随机移除
my_set1.pop()
print(f'pop移除元素后结果是{my_set1}')
# clear清空集合
my_set1.clear()
print(f'clear清空集合元素后结果是{my_set1}')
set1 = {1, 2, 3, 5, 6}
set2 = {4, 5, 6, 7, 8, 9}
# 差集
diff_set = set1.difference(set2)
print(f'difference求两个集合的差集{diff_set}')
union_set = set1.union(set2)
print(f'difference求两个集合的并集{union_set}')
inter_set = set1.intersection(set2)
print(f'difference求两个集合的交集{inter_set}')
# 集合遍历
for i in set2:
print(i, end=' ')
print()字典
特点
-
可以容纳多个数据
-
可以容纳不同类型数据
-
每一个元素是key:val格式
-
可以通过key获取value值，key不能重复否则会被覆盖
-
不支持下标索引
-
支持for循环，不支持while循环
-
可以修改
字典定义
-
字典的定义同样使用{}，不过存储的元素是一个个的键值对
-
语法：
python
# 字典定义
dict1 = {"name": "zsx", "age": 18, "score": 80.5}
dict2 = {}
dict3 = dict()
print(f'内容：{dict1}, 类型：{type(dict1)}')
print(f'内容：{dict2}, 类型：{type(dict2)}')
print(f'内容：{dict3}, 类型：{type(dict3)}')
# key值不允许重复，重复的key值会被覆盖
dict2 = {"age": 14, "age": 13}
print(f'内容：{dict2}, 类型：{type(dict2)}')获取字典数据
-
字典同集合一样，不可以使用下标索引
-
字典需要通过key值来获取相应的value值
python
print(f'获取key值为age的value值:{dict2["age"]}')
# KeyError: 'age1',key值不存在时会报错
# print(f'获取key值为age的value值:{dict2["age1"]}')字典的嵌套
- 字典的key和value可以是任意数据类型，key不可为字典
python
# 字典的嵌套
nested_dict = {"zs": {"age": 18, "sex": "male"}, "xh": {"age": 20, "sex": "female"}}
print(f'内容：{nested_dict}, 类型：{type(nested_dict)}')
print(f'获取嵌套的内层元素value值{nested_dict["zs"]["age"]}')字典的常用操作
- 代码示例
python
# *_*coding:utf-8 *_*
# 新增/更新元素
# 语法：字典[key]=value，key不存在为新增元素,key存在为更新元素
# 新增
my_dict = dict()
print(f'原始字典内容{my_dict}')
my_dict["key"] = "val"
my_dict["key1"] = "val1"
my_dict["key2"] = "val2"
print(f'新增元素后字典内容：{my_dict}')
# 更新元素
my_dict["key"] = "new_val"
print(f'更新key元素后字典内容：{my_dict}')
# 删除元素
my_dict.pop("key2")
print(f'删除key2元素后字典内容：{my_dict}')
# 获取全部key
all_keys = my_dict.keys()
print(f'获取全部key内容：{all_keys}')
all_vals = my_dict.values()
print(f'获取全部val内容：{all_vals}')
# 遍历字典
# 方式一：通过遍历所有key来取值
for key in all_keys:
print(f'key：{key}, val：{my_dict[key]}')
# 方式二直接使用for循环取值
for key in my_dict:
print(f'key---{key}, val----{my_dict[key]}')
# 统计字典内元素数量
print(f'字典内的元素数量为:{len(my_dict)}')
# 清空元素
my_dict.clear()
print(f'清空元素后字典内容：{my_dict}')数据容器总结
分类
-
是否支持下标索引
-
支持：列表、元组、字符串--序列类型
-
不支持：集合、字典--非序列类型
-
-
是否支持重复元素
-
支持：列表、元组、字符串
-
不支持：集合、字典
-
-
是否可以修改
-
支持：列表、集合、字典
-
不支持：元组、字符串
-
特点对比
通用操作
-
都支持for循环遍历；列表、元组、字符串支持while，集合、字典不支持
-
len：统计元素个数
-
max：统计容器最大元素
-
min：统计容器最小元素
容器的通用转换类型
-
list(容器)：将给定容器转化为列表
-
str(容器)：将给定容器转化为字符串
-
tuple(容器)：将给定容器转化为元组
-
set(容器)：将给定容器转化为集合
-
代码示例
python
# *_*coding:utf-8 *_*
src_list = [1, 2, 3, 4, 5]
src_tuple = (1, 2, 3, 4, 5)
src_set = {1, 2, 3, 4, 5}
src_str = "12345"
# 转列表
print(f'列表转列表{list(src_list)}, 类型：{type(list(src_list))}')
print(f'元组转列表{list(src_tuple)}, 类型：{type(list(src_tuple))}')
print(f'集合转列表{list(src_set)}, 类型：{type(list(src_set))}')
print(f'字符串转列表{list(src_str)}, 类型：{type(list(src_str))}')
# 转元组
print(f'列表转元组{tuple(src_list)}, 类型：{type(tuple(src_list))}')
print(f'元组转元组{tuple(src_tuple)}, 类型：{type(tuple(src_tuple))}')
print(f'集合转元组{tuple(src_set)}, 类型：{type(tuple(src_set))}')
print(f'字符串转元组{tuple(src_str)}, 类型：{type(tuple(src_str))}')
# 转字符串
print(f'列表转字符串{str(src_list)}, 类型：{type(str(src_list))}')
print(f'元组转字符串{str(src_tuple)}, 类型：{type(str(src_tuple))}')
print(f'集合转字符串{str(src_set)}, 类型：{type(str(src_set))}')
print(f'字符串转字符串{str(src_str)}, 类型：{type(str(src_str))}')
# 转集合
print(f'列表转集合{set(src_list)}, 类型：{type(set(src_list))}')
print(f'元组转集合{set(src_tuple)}, 类型：{type(set(src_tuple))}')
print(f'集合转集合{set(src_set)}, 类型：{type(set(src_set))}')
print(f'字符串转集合{set(src_str)}, 类型：{type(set(src_str))}')通用排序功能
- 代码示例
python
src_list = [1, 4, 5, 2, 3]
src_tuple = (1, 3, 4, 2, 5)
src_set = {1, 4, 2, 3, 5}
src_str = "13425"
print(f'正序排序：{sorted(src_list)},逆序排序：{sorted(src_list, reverse=True)}')
print(f'正序排序：{sorted(src_tuple)},逆序排序：{sorted(src_tuple, reverse=True)}')
print(f'正序排序：{sorted(src_set)},逆序排序：{sorted(src_set, reverse=True)}')
print(f'正序排序：{sorted(src_str)},逆序排序：{sorted(src_str, reverse=True)}')字符串比较
-
从头到尾，一位一位比较，其中一位大，后续就无须比较了
-
通过ASCII码确定对应的字符值大小