刀刀的知识积累

数据容器

更新时间: 2024-03-14 22:16:08

# 数据容器

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素，每一个元素，可以是任意类型的数据，如字符串、数字、布尔等

数据容器根据特点的不同，如：

  • 是否支持重复元素
  • 是否可以修改
  • 是否有序，等

分为5类：
列表（list）、元祖（tuple）、字符串（str）、集合（set）、字典（dict）

# list列表

# 定义

# 字面量
[元素1, 元素2, 元素3, 元素4,...]

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

# 定义空列表
变量名称 = []
变量名称 = list()
1
2
3
4
5
6
7
8
9

list可以嵌套，可以存储任何类型的元素

name_list = ['itheima',666,'python',[1,2,3],[4,5,6]]
print(name_list)
print(type(name_list))
1
2
3

# 下标索引

索引从0开始

name_list = ['itheima',666,'python',[1,2,3],[4,5,6]]
print(name_list[0]) # itheim
print(name_list[1]) # 666
print(name_list[2]) # python
print(name_list[3]) # [1,2,3]
print(name_list[4]) # [4,5,6]
print(name_list[3][0]) # 1
1
2
3
4
5
6
7

或者，可以反向所以，也就是从后向前：从-1开始，依次递减(-1, -2, -3....)

name_list = ['itheima',666,'python',[1,2,3],[4,5,6]]
print(name_list[-1]) # [4,5,6]
print(name_list[-2]) # [1,2,3]
print(name_list[-3]) # python
print(name_list[-4]) # 666
print(name_list[-5]) # itheima
print(name_list[-1][-1]) # 6
1
2
3
4
5
6
7

警告

通过下标索引取数据，一定不要超出范围

# 列表的常用操作（方法）

Python中，如果将函数定义为class(类)的成员，那么函数会称之为方法

# 查找某元素的下标

功能：查找指定元素在列表的下标，如果找不到，报错ValueError 语法：列表.index(元素)

name_list = ['itheima',666,'python',[1,2,3],[4,5,6]]
index = name_list.index(666)
print(index) # 1
1
2
3

# 列表的修改方法

  • 修改特定位置（索引）的元素值 语法：列表[下标] = 值
name_list = ['itheima',666,'python',[1,2,3],[4,5,6]]
name_list[1] = 123
print(name_list) # ['itheima',123,'python',[1,2,3],[4,5,6]]
1
2
3
  • 插入元素 语法： 列表.insert(下标，元素),在指定的下标位置，插入指定的元素
my_list = [1,2,3]
my_list.insert(1,'heima')
print(my_list) # [1, 'heima', 2, 3]
1
2
3
  • 追加元素 列表.append(元素)， 将指定元素，追加到列表的尾部
my_list = [1,2,3]
my_list.append('heima')
print(my_list) # [1, 2, 3, 'heima']
1
2
3

列表.extend(其他数据容器)，将其他数据容器的内容取出，依次追加到列表尾部

my_list = [1,2,3]
my_list.extend(['heima','chengxu','yuan'])
print(my_list) # [1, 2, 3, 'heima', 'chengxu', 'yuan']
1
2
3
  • 删除元素
  1. del 列表[下标]
  2. 列表.pop(下标) 这个方法有返回值，返回被删除元素
my_list = [1,2,3]
del my_list[1]
print(my_list) # [1,3]
1
2
3
my_list = [1,2,3]
element = my_list.pop(1)
print(my_list) # [1,3]
print(f"被删除的元素是{element}")
1
2
3
4
  1. 删除某元素在列表中的第一个匹配项
    列表.remove(元素)
my_list = [1,2,3,2,3]
my_list.remove(2)
print(my_list) # [1, 3, 2, 3]
1
2
3
  • 清空列表
    列表.clear()
my_list = [1,2,3,2,3]
my_list.clear()
print(my_list) # []
1
2
3

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

列表.count(元素)

my_list = [1,2,3,2,3]
num = my_list.count(2)
print(num) # 2
1
2
3

# 统计列表内，有多少元素

len(列表)
可以得到一个int数字，表示列表中的元素数量

my_list = [1,2,3,2,3]
num = len(my_list)
print(num) # 5
1
2
3

# list的遍历

# while循环遍历

my_list = ['a', 'b', 'c']
index = 0
while index < len(my_list):
    print(my_list[index])
    index += 1
1
2
3
4
5

# for循环

my_list = ['a', 'b', 'c']
for x in my_list:
    print(x)
1
2
3

# 元祖

# 格式

元组同列表一样，都是可以封装多个、不同类型的元素在内。

但最大的不同点在于：

元组一旦定义完成，就不可以修改

元祖定义：
定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型

# 定义元组的字面量
(元素，元素，...，元素)
# 定义元组变量
变量名称 = (元素，元素，...，元素)
# 定义空元组
变量名称 = () 
变量名称 = tuple()
1
2
3
4
5
6
7
t1 = ('a', 1, True)
print(t1) # ('a', 1, True)
print(type(t1)) # <class 'tuple'>
1
2
3

注意

如果元组只有一个数据，这个数据后面要添加逗号

t1 = ('a',)

# 元组的相关操作

编号 方法 作用
1 index() 查找某个数据，如果数据存在返回对应的下标，否则报警
2 count() 统计某个数据在当前元组出现的次数
3 len(元组) 统计元组内的元素个数

# while循环

t1 = (1,2,3,4,5,6)

index = 0
while index < len(t1):
    print(f"元组的元素有：{t1[index]}")
    index += 1
1
2
3
4
5
6

# for循环

t1 = (1,2,3,4,5,6)

for element in t1:
    print(f"元组的元素有：{element}")
1
2
3
4

# 数据容器 str(字符串)

字符串是字符的容器，一个字符串可以存放任意数量的字符

# 字符串的下标(索引)

  • 从前向后，下标从[0]开始
  • 从后向前，下标从[-1]开始

警告

同元组一样，字符串是一个: 无法修改的数据容器。 所以：

  • 修改指定下标的字符
  • 移除特定下标的字符
  • 追加字符等

均无法完成。如果必须要做，只能得到一个新字符串，老的字符串无法修改

# 字符串的常用操作

  • 查找特定字符串的下标索引值 字符串.index(字符串)

      my_str = "itheima and itcast"

  print(my_str.index("and")) # 8
    1
    2
    3

  • 字符串的替换
    语法： 字符串.replace(字符串1, 字符串2)
    功能: 将字符串内的全部：字符串1，替换为字符串2
    注意： 不是修改字符串本身，而是得到了一个新字符串哦

    my_str = "itheima and itcast"

print(my_str.replace("and","not")) 
#  "itheima not itcast"
print(my_str)
#  "itheima and itcast"
    1
    2
    3
    4
    5
    6

  • 字符串的分割 语法： 字符串.split(分隔符字符串)
    功能： 按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
    注意： 字符串本身不变，而是得到了一个列表对象

    my_str = "itheima and itcast"
print(my_str.split(" "))
# ['itheima', 'and', 'itcast']
    1
    2
    3

  • 字符串的规整操作（去前后空格）
    语法： 字符串.strip()

      my_str = "     itheima and itcast   "
  print(my_str.strip())
  # itheima and itcast
    1
    2
    3

  • 字符串的规整操作（去前后指定字符串）
    语法： 字符串.strip(字符串)

    my_str = "12itheima and itcast21"
print(my_str.strip("12"))
# itheima and itcast
    1
    2
    3

    注意

    注意，传入的是"12"，其实就是“1”和“2”都会移除，是按照单个字符串

  • 统计字符串中某字符出现次数

my_str = "12itheima and itcast21"
print(my_str.count("a"))
# a
1
2
3
  • 统计字符串的长度
my_str = "12itheima and itcast21"
print(len(my_str)) # 22
1
2

# 数据容器(序列)的切片

# 序列

序列是指：内容连续、有序，可以使用下标索引的一类数据容器

列表，元组，字符串，均可以视为序列

# 序列常用操作 - 切片

序列支持切片，即：列表、元组、字符串均支持进行切片操作

切片：从一个序列中，取出一个子序列

语法：序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

  • 起始下标表示从何处开始，可以留空，留空视作从头开始
  • 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
  • 步长表示，依次取元素的间隔
    • 步长1表示，一个个取元素
    • 步长2表示，每次跳过1个元素取
    • 步长N表示，每次跳过N-1个元素取
    • 步长为负数表示，反向取（注意，起始下班和结束下标也要反向标记）

此操作不会影响序列本身，而是会得到一个新的序列

# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4]
print(f"结果1：{result1}") # 结果1：[1, 2, 3]

# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[::]
print(f"结果2：{result2}")
# 结果2：(0, 1, 2, 3, 4, 5, 6)

# 对str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{result3}") # 结果3：0246

# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1]
print(f"结果4：{result4}")  # 结果4：76543210

# 对列表进行切片，从3开始，到1结束，步长-1
my_list1 = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list1[3:1:-1]
print(f"结果5{result5}") # 结果5[3, 2]

# 对元组进行切片，从头开始，到尾结束，步长-2
my_tuple1 = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"结果6：{result6}")
# 结果6：(6, 4, 2, 0)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# 数据容器：set(集合)

如果场景需要对内容做去重处理，列表、元组、字符串就不方便了。

而集合，最主要的特点就是不支持重复的元素，并且它的内部是无序的

# 集合的定义

基本语法：

# 定义集合字面量
{元素, 元素,...,元素}

# 定义集合变量
变量名称 = {元素, 元素,...,元素}

# 定义空集合
变量名称 = set()
1
2
3
4
5
6
7
8
# 定义集合
my_set = {"传智教育", "黑马程序员", "itheima","传智教育", "黑马程序员", "itheima","传智教育", "黑马程序员", "itheima"}
my_set_empty = set()
# 集合不允许重复，顺序也无法保证
print(f"my_set的内容是：{my_set},类型是:{type(my_set)}")
# my_set的内容是：{'黑马程序员', 'itheima', '传智教育'},类型是:<class 'set'>

print(f"my_set_empty的内容是：{my_set_empty},类型是：{type(my_set_empty)}")
# my_set_empty的内容是：set(),类型是：<class 'set'>
1
2
3
4
5
6
7
8
9

# 集合的常用操作 - 修改

首先，因为集合是无序的，所以集合不支持：下标索引访问

但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法。

# 添加新元素

语法： 集合.add(元素)

my_set = {"hello", "world"}
my_set.add("Python")
my_set.add("hello")
print(my_set) # {'Python', 'world', 'hello'}
1
2
3
4

# 移除元素

语法：集合.remove(元素)

my_set = {"hello", "world","itheima"}
my_set.remove("hello")
print(my_set) # {'itheima', 'world'}
1
2
3

# 从集合中随机取出元素

语法：集合.pop(),从集合中随机取出一个元素
结果：会得到一个元素的结果，同时集合本身被修改，元素被移除

my_set = {"hello", "world","itheima"}
item = my_set.pop()
print(item) # itheima
print(my_set) # {'hello', 'world'}
1
2
3
4

# 清空集合

集合.clear()

# 取出2个集合的差集

语法：集合1.difference(集合2),功能：取出集合1和集合2的差集(集合1有而集合2没有的)
结果：得到一个新集合，集合1和集合2不变

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(set1) # {1, 2, 3}
print(set2) # {1, 5, 6}
print(set3) # {2, 3}
1
2
3
4
5
6

# 消除2个集合的差集

语法：集合1.difference_update(集合2)
功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素
结果：集合1被修改，集合2不变

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference_update(set2)
print(set1) # {2, 3}
print(set2) # {1, 5, 6}
print(set3) # None
1
2
3
4
5
6

# 2个集合合并

语法：集合1.union(集合2)
功能：将集合1和集合2组合成新集合
结果：得到新集合，集合1和集合2不变

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(set1) # {1, 2, 3}
print(set2) # {1, 5, 6}
print(set3) # {1, 2, 3, 5, 6}
1
2
3
4
5
6

# 统计集合元素数量

len(集合)

# 集合的遍历

集合不支持下标索引，不能用while循环

# 可以用for循环
set1 = {1, 2, 3, 4, 5}
for element in set1:
  print(element)
1
2
3
4

# 数据容器：dict(字典、映射)

# 字典的定义

字典的定义，同样使用{}，不过存储的元素是一个个的键值对，如下语法：

# 定义字典字面量
{key:value, key:value,...key:value}
# 定义字典变量
my_dict = {key:value, key:value, ...,key:value}
# 定义空字典
my_dict = {}
my_dict = dict()
1
2
3
4
5
6
7
my_dict = {"王力宏":99, "周杰伦": 88, "林俊杰": 77}
my_dict2 = {}
my_dict3 = dict()
1
2
3

字典的key不可以重复！

# 字典的数据获取

字典同集合一样，不可以使用下标索引
但是字典可以通过key值来取得对应的value

my_dict = {"王力宏":99, "周杰伦": 88, "林俊杰": 77}
print(my_dict['王力宏']) # 99
1
2

# 字典的常用操作

# 新增元素,更新元素

语法：字典[key] = value

my_dict = {"王力宏":99, "周杰伦": 88, "林俊杰": 77}
my_dict['张学友'] = 100
print(my_dict) 
# {'王力宏': 99, '周杰伦': 88, '林俊杰': 77, '张学友': 100}

my_dict['王力宏'] = 60
print(my_dict)
# {'王力宏': 60, '周杰伦': 88, '林俊杰': 77, '张学友': 100}
1
2
3
4
5
6
7
8

# 删除元素

语法：字典.pop(key)
结果：获得指定key的value,同时字典被修改，指定key的数据被删除

my_dict = {"王力宏":99, "周杰伦": 88, "林俊杰": 77}
value = my_dict.pop("王力宏")
print(my_dict) # {'周杰伦': 88, '林俊杰': 77}
print(value) # 99
1
2
3
4

# 清空字典

字典.clear()

# 获取全部的key

语法： 字典.keys()
结果：得到字典中的全部key

my_dict = {"王力宏":99, "周杰伦": 88, "林俊杰": 77}
keys = my_dict.keys()
print(keys)
# dict_keys(['王力宏', '周杰伦', '林俊杰'])
1
2
3
4

# 遍历字典

my_dict = {"王力宏":99, "周杰伦": 88, "林俊杰": 77}

# 方式1 通过获取到全部的key来完成遍历
for key in my_dict.keys():
    print(key)
    print(my_dict[key])

# 方式2 直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict:
    print(key)
    print(my_dict[key])
1
2
3
4
5
6
7
8
9
10
11

上面两种方式都是一样的

# 统计字典的元素数量，len()函数

my_dict = {"王力宏":99, "周杰伦": 88, "林俊杰": 77}
num = len(my_dict)
print(num) # 3
1
2
3

# 数据容器的通用功能

  • 遍历
  • len(容器) 统计容器的元素个数
  • max(容器) 统计容器的最大元素
  • min(容器) 统计容器的最小元素
  • list(容器) 将给定容器转换为列表
  • str(容器) 将给定容器转换为字符串
  • tuple(容器) 将给定容器转换为元组
  • set(容器) 将给定容器转换为集合
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

# len元素个数
print(len(my_list)) # 5
print(len(my_tuple)) # 5
print(len(my_str)) # 7
print(len(my_set)) # 5
print(len(my_dict)) # 5

# min最大元素
print(max(my_list)) # 5
print(max(my_tuple)) # 5
print(max(my_str)) # g
print(max(my_set)) # 5
print(max(my_dict)) # key5

# max最小元素
print(min(my_list)) # 1
print(min(my_tuple)) # 1
print(min(my_str)) # a
print(min(my_set)) # 1
print(min(my_dict)) # key1

# 容器转列表
print(list(my_list)) # [1, 2, 3, 4, 5]
print(list(my_tuple)) # [1, 2, 3, 4, 5]
print(list(my_str)) # ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(list(my_set)) # [1, 2, 3, 4, 5]
print(list(my_dict)) # ['key1', 'key2', 'key3', 'key4', 'key5']

# 容器转元组
print(tuple(my_list)) # (1, 2, 3, 4, 5)
print(tuple(my_tuple)) # (1, 2, 3, 4, 5)
print(tuple(my_str)) # ('a', 'b', 'c', 'd', 'e', 'f', 'g')
print(tuple(my_set)) # (1, 2, 3, 4, 5)
print(tuple(my_dict)) # ('key1', 'key2', 'key3', 'key4', 'key5')

# 容器转字符串
print(str(my_list)) # [1, 2, 3, 4, 5]
print(str(my_tuple)) # (1, 2, 3, 4, 5)
print(str(my_str)) # abcdefg
print(str(my_set)) # {1, 2, 3, 4, 5}
print(str(my_dict)) # {'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}

# 容器转集合
print(set(my_list)) # {1, 2, 3, 4, 5}
print(set(my_tuple)) # {1, 2, 3, 4, 5}
print(set(my_str)) # {'d', 'f', 'a', 'b', 'e', 'g', 'c'}
print(set(my_set)) # {1, 2, 3, 4, 5}
print(set(my_dict)) # {'key4', 'key5', 'key3', 'key2', 'key1'}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

# 容器通用排序功能

sorted(容器,[reverse = True])
将给定容器进行排序

my_list = [3, 2, 1, 5, 4]
my_tuple = (1, 3, 2, 4, 5)
my_str = "abcedgf"
my_set = {1, 5, 3, 4, 2}
my_dict = {"key3": 1, "key4": 2, "key1": 3, "key2": 4, "key5": 5}

# 进行容器的排序
print(sorted(my_list)) # [1, 2, 3, 4, 5]
print(sorted(my_tuple)) # [1, 2, 3, 4, 5]
print(sorted(my_str)) # ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(sorted(my_set)) # [1, 2, 3, 4, 5]
print(sorted(my_dict)) # ['key1', 'key2', 'key3', 'key4', 'key5']

print(sorted(my_list, reverse=True)) # [5, 4, 3, 2, 1]
print(sorted(my_tuple, reverse=True)) # [5, 4, 3, 2, 1]
print(sorted(my_str, reverse=True)) # ['g', 'f', 'e', 'd', 'c', 'b', 'a']
print(sorted(my_set, reverse=True)) # [5, 4, 3, 2, 1]
print(sorted(my_dict, reverse=True)) # ['key5', 'key4', 'key3', 'key2', 'key1']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 列表的sort方法

在前面我们学习过sorted函数，可以对数据容器进行排序。
在后面的数据处理中，我们需要对列表进行排序，并指定排序规则，sorted函数就无法完成了。

我们补充学习列表的sort方法。
使用方式：
列表.sort(key=选择排序依据的函数, reverse=True|False)

  • 参数key,是要求传入一个函数，表示将列表的每一个元素都传入函数中，返回排序的依据
  • 参数reverse，是否反转排序结果，True表示降序，False表示升序

# 带名函数形式

# 如下嵌套列表，要求对外层列表进行排序，排序的依据是内层列表的第二个元素数字
my_list = [["a",33],["b",55],["c",11]]

# 定义排序方法
def choose_sort_key(element):
    return element[1]

my_list.sort(key=choose_sort_key, reverse=True)
print(my_list)
# [['b', 55], ['a', 33], ['c', 11]]
1
2
3
4
5
6
7
8
9
10

# 匿名lambda形式

# 如下嵌套列表，要求对外层列表进行排序，排序的依据是内层列表的第二个元素数字
my_list = [["a",33],["b",55],["c",11]]

my_list.sort(key=lambda element: element[1], reverse=True)
print(my_list)
# [['b', 55], ['a', 33], ['c', 11]]
1
2
3
4
5
6

# 字符串大小比较

# ASCII码表

在程序中，字符串所用的字符都有其对应的ASCII码表值。

没一个字符都能对应上一个：数字的码值，字符串进行比较就是基于数字的码值大小进行比较的。

# 字符串比较

字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大。

← 函数进阶 →

MIT Licensed | Copyright © 2021-present 刀刀