Python学习（是我的课堂上学到的东西）不包含课外

2023-10-11课堂

本次上课主要是教的是数据容器，通过这节课，我们可以学到python数据容器有四种类型

  1. 列表（List）
    列表有以下的特点
    • 可以存储不同数据类型的数据
    • 有序存储（记录存储的数据）、索引
    • 数据可以重复
    • 可以进行增删查改
  2. 元组（Tuple）
    元组有以下的特点
    • 可以存储不同数据类型的数据
    • 有序存储(记录存储的顺序)、索引[0,len-1]
    • 数据可以重复
    • 只能进行查询
  3. 字典（Dictionary）
    字典有以下的特点
    • 存储键值，key和value可以是任意类型，key不可以为字典
    • key可以访问value，不支持索引
    • key不能重复，不可以存储重复的数据
    • 支持crud
  4. 集合（Set）
    集合有以下的特点
    • 可以存储不同数据类型
    • 无序存储，不支持索引
    • 删除只能用pop
    • 不可以存储重复数据
    • 支持crud

下面是对上面的数据容器特点进行演示，以及介绍

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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
"""
    这个主要进行list序列容器的学习
    list容器的特点：
    1.可以存储不同数据类型的数据
    2.有序存储（记录存储的数据）、索引
    3.数据可以重复
    4.可以进行增删查改
"""
# 定义空列表
list = []

# 增加
list.append(1)
list.append(2)
list.append(3)
list.append(4)
list.append(5)
print(list,type(list))

# 列表的扩展
list.extend([6,7,8,9,10])
print(list,type(list))

# 指定位置插入
list.insert(0,11)
print(list,type(list))

# 使用+
list += ["hello","world"]
print(list)

# 使用*
list *= 3
print(list)

# 删除
list = ['odin', 'jack', 'lucy', 'andi', 'jame', 'peter']
del list[0]
print(list)
del list[-1]
print(list)
ele = list.pop(-3)
print(ele)
print(list)
list.remove("andi")
print(list)

# 改
list = ['odin', 'jack', 'lucy', 'andi', 'jame', 'peter']
list[2] = "merry"
print(list)

# 查
print(len(list))
list.append("odin")
list.append("odin")
print(list.count("odin"))
print(list[4], list[-4])
print(list)
print(list.index("odin"))

# 遍历
for ele in list:
    print(f"{ele} ", end='')
print()

# 清空
list.clear()
print(list)

"""
主要进行tuple序列(容器)的学习
作者：jack
日期：23.10.10

tuple容器的特点：
1、可以存储不同数据类型的数据
2、有序存储(记录存储的顺序)、索引[0,len-1]
3、数据可以重复
4、只能进行查询
"""

t = ("关羽", "张飞", "刘备", "赵云", "刘备")
print(t[0], t[-1])
print(len(t))
print(t.count("刘备"))
print(t.index("刘备"))

# 尝试修改元组的值
# t[-2] = "赵子龙"

# 当元组中只有一个数据的时候需要给该元素后面添加,
t = ('a',)
print(t, type(t))

"""
    这里是dictionary字典容器
    特点：
    1.存储键值，key和value可以是任意类型，key不可以为字典
    2.key可以访问value，不支持索引
    3.key不能重复，不可以存储重复的数据
    4.支持crud
"""
# 增
dic = {}
dic["name"] = "jack"
dic["age"] = 23
print(dic)

# 改
dic["age"] = 24
print(dic)

# 删
del dic["age"]
print(dic)

# 查
print(dic["name"])

# 重建
dic.clear()

# 老师的
# 增加
dict = {}
print(dict)

dict["python"] = 100
dict["java"] = 60
dict["js"] = 80
print(dict)

# 删除
del dict["python"]
print(dict)
ele = dict.pop("js")
print(ele,type(ele))
print(dict)

# 修改
dict["python"] = 90
print(dict)

# 查询
for key in dict:
    print(key, dict[key])
print()

for name in dict.keys():
    print(f"{name}" ,end='')
print()

for key,value in dict.items():
    print(f"{key} = {value}" ,end=' ')
print()

sum = 0
for value in dict.values():
    sum += value
print(f"{sum}")

dict.clear()

"""
    set的用法
    特点：
    1.可以存储不同数据类型
    2.无序存储，不支持索引
    3.删除只能用pop
    4.不可以存储重复数据
    5.支持crud
"""
# 新建
s = set()
print(s,type(set))

# 增加
s.add(1)
s.add(2)
s.add(3)
s.add(4)
s.add(5)
print(s,type(s))
set1 = {"hello","world"}
print(set.union(set1))
print(s.difference(set1))

# 删除
s.remove(2)
print(s,type(s))
ele = s.pop()
print(ele,type(ele))

# 遍历
for ele in s:
    print(f"{ele} ", end='')
print()

# 改
s = {-1,-2,-3}
print(s)

# 查询长度
print(len(s))

# 再次遍历
for ele in s:
    print(f"{ele} ", end='')
print()

print(sorted(s))
1
2
3
4
5
6
7
8
9
10
11
12
# 同数据类型列表
list = ["java","python","cpp","goland"]
print(list)
print(type(list))
# 不同数据类型列表
list = ["java",False,30,400.9]
print(list)
print(type(list))
# 支持嵌套
list = [["java","python","cpp","goland"],[1000,8000,500]]
print(list)
print(type(list))
1
2
3
4
5
6
7
8
9
10
11
"""
    列表 索引
"""
list = ["java","python","cpp","goland"]
# 正向索引
print(f"{list[0]} {list[1]} {list[2]} {list[3]}")
# 反向索引
print(f"{list[-1]} {list[-2]} {list[-3]} {list[-4]}")
# 嵌套访问
list = [["java","python","cpp"],[1000,800,500]]
print(f"{list[0][2]} {list[-1][-1]}")
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
# 定义while循环来遍历列表里的元素
def list_element_print_while(list):
    index = 0
    while index < len(list):
        element = list[index]
        print(f"{list[index]}", end='')
        index += 1
    print()

# 定义for循环遍历列表元素的函数（元素）
def list_element_print_for(list):
    for ele in list:
        print(f"{ele}" , end='')
    print()

# 定义for循环遍历列表元素的函数（索引）
def list_element_print_for_index(list):
    for index in range(len(list)):
        ele = list[index]
        print(f"{ele}" , end='')
    print()

# 列表
list = ["java","python","cpp","goland"]
# 调用while循环函数
list_element_print_while(list)
# 调用for循环函数（元素）
list_element_print_for(list)
# 调用for循环遍历列表函数（索引）
list_element_print_for_index(list)
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
list = []
print(list)
# 增加元素
list.append("java")
list.append("python")
print(list)
# 扩展列表
list.extend(["markdown","php"])
print(list)
# 插入元素
list.insert(1 , "js")
print(list)
# 修改元素
list[1] = "c"
list[-1] = "vc"
print(list)
# 元素数量
list.append("java")
list.append("git")
print(list)
count = list.count("java")
print(f"有{count}个")
# 元素索引
index = list.index("git")
print(f"git在列表中的索引：{index}")
# delete元素
del list[-1]
del_ele = list.pop(-1)
print(del_ele)
# delete元素（元素）
list.remove("c")
print(list)
# 清空列表
list.clear()
print(list)
1
2
3
4
5
6
7
8
9
10
11
12
13
# 空列表
result = list()
# 数据列表
list = [1,2,3,4,5,6,7,8,9,10]
# def自定义函数
def get_evev_list(list,result):
    for ele in list:
        if ele % 2 == 0:
            result.append(ele)
# 调用函数
get_evev_list(list,result)
# 输出
print(result)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 变量元组
tuple = ("java","python","cpp","goland")
print(tuple)
print(type(tuple))
# 嵌套元组
tuple = (("java","python"),("cpp","goland"))
print(tuple)
print(type(tuple))
# 元组嵌套列表
tuple = ("java",["python","cpp","goland"])
print(tuple)
print(type(tuple))
# 注意：定义只有一个元素的元组时该元素的后面必须加英文逗号，不然是字符串
tuple = ("java",)
print(tuple)
print(type(tuple))
tuple = ("java")
print(tuple)
print(type(tuple))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
tuple = ("java","python","cpp","goland")
# 索引访问
print(tuple[0])
print(tuple[-1])
# 获取索引
print(f"cpp在元组中的索引：{tuple.index('cpp')}")
# 元素数量
tuple = ("java","python","cpp","goland")
print(f"python在元组的数量：{tuple.count('python')}")
# 元组长度
print(f"元组长度:{len(tuple)}")
tuple = ("java","python","cpp","goland")
# while循环遍历
index = 0
while index < len(tuple):
    print(f"{tuple[index]}" , end = ' ')
    index += 1
print()
# for循环遍历
for ele in tuple:
    print(f"{ele}" , end = ' ')
print()
1
2
3
4
5
6
7
8
9
tuple = ("hello" , "12156000" , ["python","data","ai"])
# 修改元组中嵌套的列表元素 “ai”换成“world“
tuple [2][-1] = "world"
# 格式化输出
print(f"{tuple[0]},{tuple[1]},{tuple[2]}")
# 循环遍历
for ele in tuple[-1]:
    print(f"{ele}", end= ' ')
print()
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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
"""
    这里是dictionary字典容器
    特点：
    1.存储键值，key和value可以是任意类型，key不可以为字典
    2.key可以访问value，不支持索引
    3.key不能重复，不可以存储重复的数据
    4.支持crud
"""
# 增
dic = {}
dic["name"] = "jack"
dic["age"] = 23
print(dic)

# 改
dic["age"] = 24
print(dic)

# 删
del dic["age"]
print(dic)

# 查
print(dic["name"])

# 重建
dic.clear()

# 老师的
# 增加
dict = {}
print(dict)

dict["python"] = 100
dict["java"] = 60
dict["js"] = 80
print(dict)

# 删除
del dict["python"]
print(dict)
ele = dict.pop("js")
print(ele,type(ele))
print(dict)

# 修改
dict["python"] = 90
print(dict)

# 查询
for key in dict:
    print(key, dict[key])
print()

for name in dict.keys():
    print(f"{name}" ,end='')
print()

for key,value in dict.items():
    print(f"{key} = {value}" ,end=' ')
print()

sum = 0
for value in dict.values():
    sum += value
print(f"{sum}")

dict.clear()
1
2
3
4
5
6
# 下面错误原因：改变了集合大小
# for ele in s:
#     print(f"{ele}",end='')
#     s.remove(ele)
# print("-"*40)
# print(s)