【黑马程序员】python数据容器

文章目录

python数据容器

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)
- 方法的使用：
python 复制代码
```
stu=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码确定对应的字符值大小

【黑马程序员】python数据容器

文章目录

python数据容器

认识数据容器

列表

列表定义

list下标索引

列表的常用操作

方法

列表的查询功能

列表的修改功能

插入元素

追加元素

删除元素

删除某元素在列表中的第一个匹配项

清空列表

统计某元素在列表中的数量

统计列表中元素个数

总结

列表遍历

元组

为什么需要元组

定义元组

下标索引取出内容

元组相关操作

元组的遍历

字符串

特点

字符串的下标

字符串的常用操作

查找子串

字符串替换

字符串分割

字符串规整

统计字符串出现次数

统计字符串长度

总结

数据容器(序列)的切片

序列

切片

集合

特点

基本语法

集合常用功能

字典

特点

字典定义

获取字典数据

字典的嵌套

字典的常用操作

数据容器总结

分类

特点对比

通用操作

容器的通用转换类型

通用排序功能

字符串比较