黑马python五、六章

黑马python五、六章

函数

  • 定义：def函数名(参数1, 参数2)：
    函数体
    return返回值（可省）
  • 使用：先定义，后调用
  • 注意：参数、返回值皆可省
    函数体在遇到return后就结束了，所以写在return后的代码不会执行。

None

  • 定义：’NoneType’字面量，表空、无意义
  • 函数返回：无return或return None
  • 场景：函数返回、if判断、变量定义

函数说明文档

  • 作用：对函数进行说明解释，帮助更好理解函数的功能。
  • 定义语法： - 使用def定义函数，如def func(x, y):。
    • 在函数名下方用三对双引号"""包裹函数说明。
    • 使用:param解释参数，如:param x: 参数x的说明，:param y: 参数y的说明。
    • 使用:return解释返回值，如:return: 返回值的说明。
    • 最后是函数体和return返回值。

局部变量与全局变量

  • 局部变量：作用范围在函数内部，函数外部无法使用。
  • 全局变量：在函数内部和外部均可使用。
  • 函数内变量声明为全局变量：使用global关键字，如global 变量。

列表

1
2
3
4
5
6
7
# 字面量定义列表 
my_list1 = [1, 'hello', 3.14, [4, 5, 6]] 
# 定义变量并赋值为列表 
my_list2 = ['apple', 'banana', 'orange'] 
# 定义空列表 
empty_list1 = [] 
empty_list2 = list() 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
my_list = ['apple', 'banana', 'cherry', 'date', 'elderberry'] 
nested_list = [['apple', 'banana'], ['cherry', 'date'], ['elderberry', 'fig']] 
# 从前向后通过下标索引取出元素 
print(my_list[0]) 
print(my_list[2]) 
# 从后向前通过下标索引取出元素 
print(my_list[-1]) 
print(my_list[-3]) 

# 注意下标索引的取值范围，超出范围会报错 
# 例如以下代码会报错，因为列表长度为5，最大下标为4 
# print(my_list[5]) 

# 通过list[-1][0]访问嵌套列表中最后一个子列表的第一个元素 
print(nested_list[-1][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
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
outer_list = [[1, 2], [3, 4]]

print("初始外层列表：", outer_list)

  

# append方法

outer_list.append([5, 6])

print("外层append后：", outer_list)

  

outer_list[0].append(7)

print("内层append后：", outer_list)

  

outer_list.extend([8, 9])

print("外层extend后：", outer_list)

  

outer_list[1].extend([10, 11])

print("内层extend后：", outer_list)

  

outer_list.insert(-1, [12, 13])

print("外层insert后：", outer_list)

  

outer_list[2].insert(0, 14)

print("内层insert后：", outer_list)

  

del outer_list[3]

print("外层del后：", outer_list)

  

del outer_list[1][0]

print("内层del后：", outer_list)

  

popped_outer = outer_list.pop(2)

print("外层pop弹出的元素：", popped_outer)

print("外层pop后：", outer_list)

  

popped_inner = outer_list[0].pop(1)

print("内层pop弹出的元素：", popped_inner)

print("内层pop后：", outer_list)

  

# 确保 [5, 6] 存在

outer_list.append([5, 6])

outer_list.append([5, 6])

print("外层列表中添加2个 [5, 6]：", outer_list)

  

outer_list.remove([5, 6])

print("外层remove后：", outer_list)

  

# 确保 7 存在于内层列表

outer_list[0].append(7)

print("内层列表中添加 7：", outer_list)

  

outer_list[0].remove(7)

print("内层remove后：", outer_list)

  

outer_list.clear()

print("外层clear后：", outer_list)

  

outer_list = [[1, 2], [3, 4]]

outer_list[0].clear()

print("内层clear后：", outer_list)

  

outer_list = [[1, 2], [3, 4], [1, 2]]

print("外层count 2的次数：", outer_list.count(2))

print("外层count [1, 2]的次数：", outer_list.count([1, 2]))

print("内层count 1在[1, 2]中的次数：", outer_list[0].count(1))

  

print("外层index [3, 4]的索引：", outer_list.index([3, 4]))

print("内层index 2在[1, 2]中的索引：", outer_list[0].index(2))

  

print("外层len：", len(outer_list))

print("内层len [1, 2]：", len(outer_list[0]))

insert是在选中的元素前插入（替代输入索引的元素位置），不管是向前还是向后下标索引。
remove只删除第一个匹配的元素。

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
初始外层列表： [[1, 2], [3, 4]]
外层append后： [[1, 2], [3, 4], [5, 6]]
内层append后： [[1, 2, 7], [3, 4], [5, 6]]
外层extend后： [[1, 2, 7], [3, 4], [5, 6], 8, 9]
内层extend后： [[1, 2, 7], [3, 4, 10, 11], [5, 6], 8, 9]
外层insert后： [[1, 2, 7], [3, 4, 10, 11], [5, 6], 8, [12, 13], 9]
内层insert后： [[1, 2, 7], [3, 4, 10, 11], [14, 5, 6], 8, [12, 13], 9]
外层del后： [[1, 2, 7], [3, 4, 10, 11], [14, 5, 6], [12, 13], 9]
内层del后： [[1, 2, 7], [4, 10, 11], [14, 5, 6], [12, 13], 9]
外层pop弹出的元素： [14, 5, 6]
外层pop后： [[1, 2, 7], [4, 10, 11], [12, 13], 9]
内层pop弹出的元素： 2
内层pop后： [[1, 7], [4, 10, 11], [12, 13], 9]
外层列表中添加2个 [5, 6]： [[1, 7], [4, 10, 11], [12, 13], 9, [5, 6], [5, 6]]
外层remove后： [[1, 7], [4, 10, 11], [12, 13], 9, [5, 6]]
内层列表中添加 7： [[1, 7, 7], [4, 10, 11], [12, 13], 9, [5, 6]]
内层remove后： [[1, 7], [4, 10, 11], [12, 13], 9, [5, 6]]
外层clear后： []
内层clear后： [[], [3, 4]]
外层count 2的次数： 0
外层count [1, 2]的次数： 2
内层count 1在[1, 2]中的次数： 1
外层index [3, 4]的索引： 1
内层index 2在[1, 2]中的索引： 1
外层len： 3
内层len [1, 2]： 2

列表具有以下特点：

  • 容量大：可以容纳多个元素，上限为2^63 - 1。
  • 元素类型多样：能够容纳不同类型的元素，可实现混装。
  • 有序存储：数据是有序存储的，每个元素都有下标序号。
  • 允许重复：允许重复数据存在。

元组

1
2
3
4
5
6
7
8
9
# 字面量定义元组
my_list1 = (1, 'hello', 3.14, [4, 5, 6])
# 定义变量并赋值为元组 
my_list2 = ()'apple', 'banana', 'orange') 
# 定义空元组
empty_list1 = ()
empty_list2 = tuple() 
# 定义1个元素的元组必须带有逗号，否则不是元组类型
t2 = ("hello", )

也支持使用中括号下标索引。
相关操作仅支持index count len，元组中的列表可以修改。

字符串

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
text = "  1222hello   world1111  "

print(text[0])

print(text.index("w"))

print(text.index("world"))

text2 = text.replace("world", "python")

print(text, text2)

print(text.split(" "))

print(text.split())

text3 = text.strip()

print(text3)

print(text.strip('12d'))

print(text3.strip('12d'))

print(text.count("l"))

print(len(text))

字符串在Python中是不可变的。所有字符串操作方法(如strip()、replace()、upper()等)都会返回一个新字符串,而不是修改原字符串。如果要更新原变量,需要重新赋值。

1
text = text.strip('12')  # 重新赋值给text
1
2
3
4
5
6
7
8
9
10
14
14
  1222hello   world1111     1222hello   python1111
['', '', '1222hello', '', '', 'world1111', '', '']
['1222hello', 'world1111']
1222hello   world1111
  1222hello   world1111
hello   worl
3
25
  • split(" ")：严格按照空格分割，有几个空格就分几次，所以会产生多个空字符串
  • split()：默认把连续空白字符当作一个分隔符处理
  • strip同理，它的工作原理是：
    • 它把 ‘1’、’2’和’d’ 作为一个字符集
    • 从两端开始，删除任何属于这个字符集的字符
    • 只要遇到不在字符集中的字符就停止

序列切片

切片省略规则 ：

  • 列表、元组和字符串遵循起始位置、结束位置省略以及两者都省略的规则。
  • 例如，对于my_str = "01234567"，my_str[ :4]的结果是"0123"，my_str[1: ]的结果是"1234567"，my_str[ : ]的结果是"01234567"。 步长省略代表步长为1。
  • 此外，切片还可以指定步长。例如，my_str[ : :2]表示从字符串开头到结尾，步长为2进行切片，结果是"0246"。如果步长为负数，如my_str[ : :-1]，则表示从字符串结尾到开头进行切片，结果是"76543210"，注意此时起始下标和结束下标也要反向标。
  • 反向标的意思是例如print(my_str[3:1:-1])和print(my_str[-7:-5:-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
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
# 创建集合

my_set1 = {1, 2, 3}

my_set2 = {3, 4, 5}

# 创建空集合
set()


# add() 添加元素

my_set1.add(6)

print("添加元素后的my_set1:", my_set1)  

  

# remove() 移除元素

my_set1.remove(2)

print("移除元素后的my_set1:", my_set1)  

  

# pop() 随机取出一个元素

popped_element = my_set1.pop()

print("随机取出的元素:", popped_element)  

print("取出元素后的my_set1:", my_set1)  

  

# clear() 清空集合

my_set1.clear()

print("清空后的my_set1:", my_set1)  

  

# difference() 求差集

my_set1 = {1, 2, 3}

my_set2 = {3, 4, 5}

diff_set = my_set1.difference(my_set2)

print("my_set1与my_set2的差集:", diff_set)  

print("my_set1:", my_set1)  

print("my_set2:", my_set2)  

  

# difference_update() 在集合1中删除集合2中存在的元素

my_set1 = {1, 2, 3}

my_set2 = {3, 4, 5}

my_set1.difference_update(my_set2)

print("difference_update后的my_set1:", my_set1)  

print("my_set2:", my_set2)  

  

# union() 求并集

my_set1 = {1, 2, 3}

my_set2 = {3, 4, 5}

union_set = my_set1.union(my_set2)

print("my_set1与my_set2的并集:", union_set)  

print("my_set1:", my_set1)  

print("my_set2:", my_set2)  

  

# len() 获取集合元素数量

print("my_set1的元素数量:", len(my_set1))  

print("my_set2的元素数量:", len(my_set2))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
添加元素后的my_set1: {1, 2, 3, 6}
移除元素后的my_set1: {1, 3, 6}
随机取出的元素: 1
取出元素后的my_set1: {3, 6}
清空后的my_set1: set()
my_set1与my_set2的差集: {1, 2}
my_set1: {1, 2, 3}
my_set2: {3, 4, 5}
difference_update后的my_set1: {1, 2}
my_set2: {3, 4, 5}
my_set1与my_set2的并集: {1, 2, 3, 4, 5}
my_set1: {1, 2, 3}
my_set2: {3, 4, 5}
my_set1的元素数量: 3
my_set2的元素数量: 3
  • 可以容纳不同类型的数据。
  • 数据是无序存储的。
  • 不允许重复数据存在。
  • 支持for循环，不支持while循环。

字典

字典或列表等数据容器中换行不影响。

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
{key: value, key: value, ......, key: value}

#定义空字典
{}
dict()

# 创建字典

my_dict = {"name": "Alice", "age": 25, "city": "New York"}

# 获取指定Key对应的Value值

print("name对应的Value:", my_dict["name"])  

# 添加或更新键值对（如果已经存在即修改）

my_dict["gender"] = "female"

print("添加gender后的字典:", my_dict)  

# 取出Key对应的Value并在字典内删除此Key的键值对

removed_value = my_dict.pop("age")

print("取出的age对应的值:", removed_value)  

print("删除age后的字典:", my_dict)  

# 清空字典

my_dict.clear()

print("清空后的字典:", my_dict)  

# 获取字典的全部Key，可用于for循环遍历字典

my_dict = {"name": "Alice", "age": 25, "city": "New York"}

all_keys = my_dict.keys()

print("字典的全部Key:", list(all_keys))  

# 计算字典内的元素数量

print("字典的元素数量:", len(my_dict))

除了key不能为字典外，其余可以为一切内容；key不允许重复，重复添加覆盖原有数据。

1
2
3
4
5
6
7
name对应的Value: Alice
添加gender后的字典: {'name': 'Alice', 'age': 25, 'city': 'New York', 'gender': 'female'}
取出的age对应的值: 25
删除age后的字典: {'name': 'Alice', 'city': 'New York', 'gender': 'female'}
清空后的字典: {}
字典的全部Key: ['name', 'age', 'city']
字典的元素数量: 3

支持for循环，不支持while循环。

字符串的通用操作


max()最大元素，min()最小元素。
还可以通用类型转换：list()、str()、tuple()、set()。

  • 字符串转前两者会把每个字符提取出来，字典转前三两会抛弃value只保留key。
  • 所有类型转字符串都不会丢失元素，只是在原来的形式下变成了字符串，读取时最外层会有引号。
  • 字典转集合也是只保留key。
    sorted(容器)正向排序（从小到大），sorted(容器, reverse=True)反向排序（从大到小）。
python
黑马python五、六章
https://blakehansen130.github.io/2025/01/19/黑马python五、六章/
发布于
2025年1月19日
许可协议