Python入门与进阶

基础语法语句

在线python代码运行网址 （推荐使用python3网址）

基础语法&输入输出

python等号赋值

赋值类型	描述	示例
基本赋值	使用等号（=）进行赋值。	x=10
同一个值给多个变量	可以使用一个值来赋值给多个变量。	x=y=z=10
多重赋值	可以同时给多个变量赋多个值。	x,y,z=1,2,3
使用下划线的赋值	当你不关心某个值时，可以使用下划线（_）作为“丢弃”变量。	x,_=1,2

python命名规则

以下名字有特殊意义，不能作为变量名

false	none	true	and	as	assert
async	await	break	class	continue	def
del	elif	else	except	finally	for
form	global	if	import	in	is
lambda	nonlocal	not	or	pass	raise
return	try	while	with	yield

变量名不能数字和特殊字符开头

# 以下内容为非法标识符
4word # 以数字开头
try # Python保留字
$lady # 特殊字符

命名规则建议以下划线或者驼峰命名

# 下划线法
user_name = "Alice"
# 驼峰法
userName = "Alice"

python注释

使用#号进行单行注释
```
a = 1
# b = 2
c = 3
```
使用三引号进行多行注释
```
'''
e = 4
f = 5
'''
g = 6
```

python屏幕输出/键盘输入

python屏幕输出

参数	描述	示例	结果
obj	可以打印一个对象	print(“AI”)	AI
obj	需要打印的对象，可以是多个	print(“Hello Word”)	Hello Word
sep	用于分隔多个对象的字符，默认是空格	print(“Hello”,“Word”,sep=“-”)	Hello-Word
end	打印结束后的字符，默认是换行符\n	print(“Hello”,end=“!”)	Hello!

python键盘输入
- 等待用户输入，用户键盘输入完毕敲回车进行确认，结果保存在result中
```
result = input()
```
- 提示用户输入之前，先在屏幕显示出“请输入结果”
```
result = input("请输入结果")
```

小案例

name = input("你是谁？")
print("欢迎学习python，", name)

顺序结构语句

从上往下依次执行
通常为赋值语句、计算语句等

赋值&计算&数据格式

使用 = 进行赋值

计算语句

运算符	描述	示例
+	加法	5 + 3 = 8
-	减法	5 - 3 = 2
*	乘法	5 * 3 = 15
/	算术除法	5 / 3 = 1.666666666666667
//	整数除法求商	5 // 3 = 1
%	求余数	5 % 3 = 2
**	幂运算	5 ** 3 = 125 （5的3次方)

计算同时赋值

运算符	示例	展开式	运算（假设a = 10）	运算结果
+=	a += 1	a = a + 1	a = 10 + 1	a = 11
-=	a -= 1	a = a - 1	a = 10 - 1	a = 9
*=	a *= 2	a = a * 2	a = 10 * 2	a = 20
/=	a /= 3	a = a / 3	a = 10 / 3	a = 3.3333333333
//=	a //= 3	a = a // 3	a = 10 // 3	a = 3
%=	a %= 3	a = a % 3	a = 10 % 3	a = 1
**=	a **= 2	a = a ** 2	a = 10 ** 2	a = 100

数据格式（类型）

数据类型	描述	示例	特点
int	整型，整数	5 3 -1	可正数、复数或者0
float	浮点数，有小数点	3.14 -0.6 1e-3	有精度限制
str	字符串，文本数据	‘Hello Word’ 、“Hello Word”、‘’‘Hello Word’‘’	用引号创建、可字符串连接和重复、可用索引和切片
complex	复数，有实部虚部	2 + 3j 3 - 4j	j 表示虚部

查看数据类型（使用type()可以查看数据类型）

a = 1
b = 3.14
c = '123'
d = "这也是字符串"
e = '''这也可以是字符串'''

print("a的数据类型是：", type(a))
print("b的数据类型是：", type(b))
print("c的数据类型是：", type(c))
print("d的数据类型是：", type(d))
print("e的数据类型是：", type(e))

打印结果如下：
a的数据类型是： <class 'int'>
b的数据类型是： <class 'float'>
c的数据类型是： <class 'str'>
d的数据类型是： <class 'str'>
e的数据类型是： <class 'str'>

数据格式转换&案例

转为整数

进制	单个取值范围	示例
10进制	0-9	0，2，-1，3
2进制	0-1	0（十进制的0）、1（十进制的1）、10（十进制的2）、11（十进制的3）
8进制	0-7	162 = (1 * 8^2) + (6 * 8^1) + (2 * 8 ^ 0) = 114，即八进制的162=十进制的114
16进制	0-9，A-F	64 = (6 * 16^1) + (4 * 16^0) = 100

转为小数（使用float()转为小数）

num_str = input("请输入小数：")
print("num_str = ", num_str, "格式是：", type(num_str))
num_float = float(num_str)
print("num_float = ",num_str," 格式是：",type(num_float))

运行结果如下：
请输入小数： 12.44553
('num_str = ', '12.44553', '格式是：', <class 'str'>)
('num_float = ', '12.44553', ' 格式是：', <class 'float'>)

转为字符串（使用str()转为字符串）

name = "alice"
age = 30
print("My name is %s and Im %d years old."%(name,age))
print("My name is {} and Im {} years old.".format(name,age))
print(f"My name is {name} and Im {age} years old.")

运行结果如下：
My name is alice and Im 30 years old.
My name is alice and Im 30 years old.
My name is alice and Im 30 years old.

输出时精度控制

number = 12.3456

# 2f-保留两位小数
print("%.2f" % number)
print("{:.2f}".format(number))
print(f"{number:.2f}")

运行结果如下：
12.35
12.35
12.35

选择结构语句

运算符	名称	描述	示例
==	等于	检查两个操作数是否相等	5 == 3
!=	不等于	检查两个操作数是否不相等	5 != 3
大于	检查左操作数是否大于右操作数	5 > 3
<	小于	检查左操作数是否小于右操作数	5 < 3
>=	大于等于	检查左操作数是否大于等于右操作数	5 >= 3
<=	小于等于	检查左操作数是否小于等于右操作数	5 < = 3

IF选择语句

if语句
```
x = 10
if x > 5:
	print("x大于5")
```

if…else语句

x = 10
if x > 5:
	print("x大于5")
else:
	print("x小于等于5")

if…elif…else语句

x = 5
if x > 10:
	print("x大于10")
elif x == 5:
	print("x是5")
else:
	print("x小于10，但不等于5")

IF选择语句综合案例

a = 10
b = 20
result = a + b
answer = int(input(f"请输入{a}+{b}的结果"))
if result == answer:
	print("回答正确")
else:
	print("回答错误")

循环结构语句

for循环语句

可指定遍历对象

可指定循环次数

epoch = 5
for epoch_i in range(epoch):
	print("------------")
	print(f"正在处理第{epoch_i}个epoch的数据")
	print(f"第{epoch_i}个数据处理完毕")
	
运行结果如下：
正在处理第0个epoch的数据
第0个数据处理完毕
------------
正在处理第1个epoch的数据
第1个数据处理完毕
------------
正在处理第2个epoch的数据
第2个数据处理完毕
------------
正在处理第3个epoch的数据
第3个数据处理完毕
------------
正在处理第4个epoch的数据
第4个数据处理完毕

可指定迭代对象

optimizers = ["SGD","Adam","Momentum","Adagrad"]
for optimizer_i in optimizers:
	print("正在使用 ", optimizer_i, " 进行优化")
	
运行结果如下：
正在使用  SGD  进行优化
正在使用  Adam  进行优化
正在使用  Momentum  进行优化
正在使用  Adagrad  进行优化

可对数据进行枚举（enumerate）

img_list = ["img_1.png""img_2.png","img_3.png","img_4.png"]
for index, img_i in enumerate(img_list):
	print(f"索引 {index} 对应的数据是 {img_i}")
	
运行结果如下：
索引 0 对应的数据是 img_1.pngimg_2.png
索引 1 对应的数据是 img_3.png
索引 2 对应的数据是 img_4.png

while循环语句

当不清楚应该循环多少次时，用whie

command = ""
while command != "end":
	command = input("请输入命令: ")
	print("正在执行命令：", command)
	
运行结果如下：
请输入命令:  ws
正在执行命令： ws
请输入命令:  fg
正在执行命令： fg
请输入命令:  end
正在执行命令： end

break打破循环

使用braek可以停止循环，即跳出整个循环

numbers = [1,2,3,4,5,6,7,8,9]

found = False

for number in numbers:
    print(f"正在查看数字{number}")
    if number == 5:
        found = True
        print(f"机器人找到了数字{number}")
        break

if not found:
    print("机器人没有找到数字5.")
    
运行结果如下：
正在查看数字1
正在查看数字2
正在查看数字3
正在查看数字4
正在查看数字5
机器人找到了数字5

continue跳过当前回合

continue跳过当前回合，但仍在循环中

numbers = [1,2,3,4,5,6,7,8,9]

for number in numbers:
    print(f"正在查看数字{number}")
    if number == 5:
        continue
    print(f"机器人找到了数字{number}!")

运行结果如下：
正在查看数字1
机器人找到了数字1!
正在查看数字2
机器人找到了数字2!
正在查看数字3
机器人找到了数字3!
正在查看数字4
机器人找到了数字4!
正在查看数字5
正在查看数字6
机器人找到了数字6!
正在查看数字7
机器人找到了数字7!
正在查看数字8
机器人找到了数字8!
正在查看数字9
机器人找到了数字9!

循环语句综合案例

Python列表/元组/字典和集合

Python序列与应用

python列表

列表是常用的序列

list_empty = []
list_a = [1,2,3]
list_b = list(range(10))

print(list_empty)
print(list_a)
print(list_b)

运行结果：
[]
[1, 2, 3]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

可以用过索引访问

list_a = [1,2,3]
print(list_a[1])

运行结果：
2

遍历列表

for in - 普通遍历

data_list = ['a','b','c','d','e']
for data_i in data_list:
	print(data_i)

运行结果：
a
b
c
d
e

for in enumerate - 枚举遍历

data_list = ['a','b','c','d','e']
for index,data_i in enumerate(data_list):
	print(index,data_i)
	
运行结果：
0 a
1 b
2 c
3 d
4 e

列表的增删改查

list_a = [1,2,3,4,5]

print(list_a)

list_a.append(6)
print(list_a)

list_a[0] = 0
print(list_a)

list_a.remove(4)
print(list_a)

运行结果：
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 6]
[0, 2, 3, 4, 5, 6]
[0, 2, 3, 5, 6]

列表元素统计运算-求和

list_a = [1,2,3,4,5]
result = sum(list_a)

print(result)

运行结果
15

列表排序

score = [12,32,14,56,23,43,26,74,34]
print("原列表：", score)

score.sort()
print("升序后：",score)

score.sort(reverse = True)
print("降序后：",score)

运行结果：
原列表： [12, 32, 14, 56, 23, 43, 26, 74, 34]
升序后： [12, 14, 23, 26, 32, 34, 43, 56, 74]
降序后： [74, 56, 43, 34, 32, 26, 23, 14, 12]

列表推导式-快速创建一个有序列表

x_list = [i for i in range(10)]
print(x_list)

运行结果：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

小案例

# 初始的模型准确率
accuracies = [0.85,0.90,0.88,0.92]

# 添加新的准确率
accuracies.append(0.95)

# 计算平均率
avarage_accuracy = sum(accuracies) / len(accuracies)
print(f"模型平均准确率（保留两位小数）为：{avarage_accuracy:.2f}")

运行结果：
模型平均准确率（保留两位小数）为：0.90

python元组

列表序列是方括号，元组是小括号

tuple_1 = ()
# 创建10-20之前的元组序列，步进为2，不包含20
tuple_2 = tuple(range(10,20,2))

print(tuple_1)
print(tuple_2)

运行结果：
()
(10, 12, 14, 16, 18)

元组数据可以索引和切片

tuple_1 = (1,2,3,4,5)

print(tuple_1[2])
print(tuple_1[-1])

运行结果：
3
5

元组推导式，像创建列表一样创建元组

tuple_a = tuple(i for i in range(10))
print(tuple_a)

运行结果：
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

列表序列与元组序列差别

特性	列表序列	元组序列
定义	使用方括号[]或list()	使用圆括号()或tuple()
可变性	可变，可以修改内容	不可变，一旦创建不能修改
方法	拥有多种方法，如append等	方法较少
性能	相对较慢	相对较快
适用场景	需要经常修改内容	不需要修改内容
占用空间	相对较多	相对较少

元组小案例-解包元组

# 元组模型的配置（层数、每层单元数、激活函数）
model_config = (3, 128, "relu")

# 解包元组
layers, units, activation = model_config
print(f"layers:{layers}, units:{units}, activation:{activation}")

运行结果:
layers:3, units:128, activation:relu

python字典

字典序列存放信息以键值对形式出现，相当于JavaScript中的对象类型

info_xiaoming = {
	'name':'小明',
	'age':14,
	'score':60
}
info_zhangsan = {
	'name':'张三',
	'age':15,
	'score':79
}

print(info_xiaoming)
print(info_xiaoming['age'])
print(info_zhangsan['score'])

运行结果：
{'name': '小明', 'age': 14, 'score': 60}
14
79

可以通过键名访问到键值

neural_network_config = {
	'layr_1':{'units':64,'activation':'relu'},
	'layr_2':{'units':128,'activation':'relu'},
	'output_layer':{'units':10,'activation':'softmax'},
}

layer_1_units = neural_network_config['layr_1']['units']
print(f"Number of units in layer 1: {layer_1_units}")

运行结果：
Number of units in layer 1: 64

字典遍历 for in

info_xiaoming = {
    'name': '小明',
    'age': 14,
    'score': 60
}

print("以下为小明的信息:")
for key, value in info_xiaoming.items():
    print(f"{key} 为 {value}")
    
运行结果：
以下为小明的信息:
name 为 小明
age 为 14
score 为 60

字典元素增删改查

neural_network_config = {
	'layr_1':{'units':64,'activation':'relu'},
	'layr_2':{'units':128,'activation':'relu'},
	'output_layer':{'units':10,'activation':'softmax'},
}

# 新增 layr_3
neural_network_config['layr_3'] = {'units':256,'activation':'relu'}
# 修改 layr_1
neural_network_config['layr_1']['units'] = 126
# 删除键值
del neural_network_config['output_layer']['activation']

# 输出最后字典
print(neural_network_config)

运行结果：
{'layr_1': {'units': 126, 'activation': 'relu'}, 'layr_2': {'units': 128, 'activation': 'relu'}, 'output_layer': {'units': 10}, 'layr_3': {'units': 256, 'activation': 'relu'}}

字典小案例

# 不同模型信息
models_info = {
	'CNN': {'layers':3,'units':128,'activation':'relu'},
	'RNN': {'layers':2,'units':64,'activation':'relu'},
}
# 访问特定模型的信息
cnn_info = models_info['CNN']
print(f"CNN-Layers: {cnn_info['layers']}, units: {cnn_info['units']}, activation: {cnn_info['activation']}")

运行结果：
CNN-Layers: 3, units: 128, activation: relu

python集合

集合的标志是花括号，里面元素会自动去重

# 创建空集-方式1
set_1 = set() 
# 创建空集-方式2
set_2 = {}
# 创建集合，会自动去重
set_3 = {1,2,3,3,4,5}

print(set_1)
print(set_2)
print(set_3)

运行结果：
set()
{}
{1, 2, 3, 4, 5}

集合元素的添加与删除

# 初始化一个空集
my_set = set()

# 添加元素
my_set.add(1)
my_set.add(2)
my_set.add(3)

# 删除元素
my_set.remove(2)

print(my_set)

运行结果：
{1, 3}

集合中的数学运算

# 定义两个集合
set1 = {1,2,3,4}
set2 = {3,4,5,6}

# 交集运算
intersection = set1.intersection(set2)
# 交集运算2
# intersection = set1 & set2
print(f"交集：{intersection}")

# 并集运算
union = set1.union(set2)
# 并集运算2
# union = set1 | set2
print(f"并集：{union}")

# 差集运算
difference1 = set1.difference(set2)
# 差集运算2
# difference1 = set1 - set2
print(f"set1与set2差集：{difference1}")
# 差集运算3
difference2 = set2.difference(set1)
# 差集运算4
# difference2 = set2 - set1
print(f"set2与set1差集：{difference2}")

运行结果：
交集：{3, 4}
并集：{1, 2, 3, 4, 5, 6}
set1与set2差集：{1, 2}
set2与set1差集：{5, 6}

集合小案例

# 两个实验中使用的函数
experiment1 = {'relu','sigmoid','tanh'}
experiment2 = {'relu','softmax'}

# 找出两个实验中都是用过的函数
common_activations = experiment1.intersection(experiment2)

print(f"两个实验中都是用过的函数：{common_activations}")

运行结果：
两个实验中都是用过的函数：{'relu'}

python字符串

字符串索引

# 示例字符串
string = "this_is_a_file.jpg"

# 获取字符串的第2到第5个字符（索引从0开始）
substring = string[1:5]  # 结果: "his_"
print(substring)

# 获取字符串的第2到最后一个字符
substring = string[1:]  # 结果: "his_is_a_file.jpg"
print(substring)

# 获取字符串的开始到第5个字符
substring = string[:5]  # 结果: "this_"
print(substring)

# 获取整个字符串
substring = string[:]  # 结果: "this_is_a_file.jpg"
print(substring)

# 获取字符串的最后3个字符
substring = string[-3:]  # 结果: "jpg"
print(substring)

# 获取字符串的第2到倒数第3个字符，每隔2个字符取一个
substring = string[1:-2:2]  # 结果: "hsi__iej"
print(substring)

# 反转字符串
substring = string[::-1]  # 结果: "gpj.elif_a_si_siht"
print(substring)

运行结果：
his_
his_is_a_file.jpg
this_
this_is_a_file.jpg
jpg
hsi__iej
gpj.elif_a_si_siht

字符串比较

# 定义两个字符串
string1 = "Hello"
string2 = "hello"
string3 = "Hello"

# 使用 == 操作符比较字符串
is_equal = string1 == string2  # 结果: False
print(f"string1 is equal to string2: {is_equal}")

is_equal = string1 == string3  # 结果: True
print(f"string1 is equal to string3: {is_equal}")

# 使用 != 操作符比较字符串
is_not_equal = string1 != string2  # 结果: True
print(f"string1 is not equal to string2: {is_not_equal}")

# 使用 <, > 操作符比较字符串（基于字典顺序）
is_less_than = string1 < string2  # 结果: True (因为大写字母在字典顺序中排在小写字母之前)
print(f"string1 is less than string2: {is_less_than}")

# 不区分大小写的字符串比较
is_equal_ignore_case = string1.lower() == string2.lower()  # 结果: True
print(f"string1 is equal to string2 (ignore case): {is_equal_ignore_case}")

运行结果：
string1 is equal to string2: False
string1 is equal to string3: True
string1 is not equal to string2: True
string1 is less than string2: True
string1 is equal to string2 (ignore case): True

Python函数/模块/文件与文件夹

python函数

函数

参数传递

形参与实参

# 形参是函数定义时的参数，实参是函数调用时的参数
def create_model(layers, units):  # layers和units是形参
    print(f"Creating a model with {layers} layers and {units} units in each layer.")

# 调用函数
create_model(3, 128)  # 3和128是实参

位置参数

# 位置参数的顺序很重要
def create_model(layers, units):
    print(f"Creating a model with {layers} layers and {units} units in each layer.")

# 调用函数
create_model(3, 128)
create_model(128, 3)

关键字参数

# 使用关键字参数调用函数
def create_model(layers, units):
    print(f"Creating a model with {layers} layers and {units} units in each layer.")

# 调用函数
create_model(units=128, layers=3)  # 使用关键字参数，顺序不重要
create_model(layers=3, units=128)

默认参数

# 使用默认参数值
def create_model(layers=3, units=128):
    print(f"Creating a model with {layers} layers and {units} units in each layer.")

# 调用函数
create_model()  # 使用默认值

可变参数

# 使用可变参数接收多个参数值
def add_layers(model, *layers):
    for layer in layers:
        print(f"Adding layer {layer} to model {model}.")

# 调用函数
add_layers("Model1", "conv", "relu", "softmax")

函数返回值-return

# 函数返回模型的信息
def create_model(layers, units):
    info = f"Creating a model with {layers} layers and {units} units in each layer."
    return info

# 调用函数
model_info = create_model(3, 128)
print(model_info)

变量作用域

全局变量

# 全局变量
MODEL_NAME = "CNN"

def print_model_name():
    print(f"The model name is {MODEL_NAME}.")

# 调用函数
print_model_name()

局部变量

# 局部变量
def create_model():
    model_name = "RNN"  # 局部变量
    print(f"Creating a model named {model_name}.")

# 调用函数
create_model()

print(model_name) # 此行代码会报错

匿名函数

冒号前面是输入
冒号后面是输出

定义关键字 lambda

# 使用lambda创建匿名函数
calculate_units = lambda layers: layers * 128

# 调用函数
units = calculate_units(3)
print(f"Total units: {units}")

综合案例：使用函数创建模型

创建一个函数，输入包括：

输入图形尺寸（channels, height, width）
卷积核大小（默认为3）
边缘补零（默认为0）
卷积步长（默认为1）

最终需要返回的卷积后图像尺寸

计算方法为：

new_height = ((height + 2 * padding - kernel) // stride) + 1

new_width = ((width + 2 * padding - kernel) // stride) + 1

最后将 channels，new_height ，new_width 组成新的元组 output_size进行返回

def create_cnn(input_size, kernel=3, padding=0, stride=1):
    """
    创建一个卷积神经网络层

    参数：
    - input_size: 输入图像的尺寸，形式为 (channels, height, width)
    - kernel: 卷积核的大小，默认为 3
    - padding: 填充大小，默认为 0
    - stride: 步长，默认为 1

    返回：
    - output_size: 卷积操作后输出图像的尺寸，形式为 (channels, height, width)
    """

    # 从输入尺寸中获取通道数和图像大小
    channels, height, width = input_size

    # 计算卷积操作后的输出图像尺寸
    new_height = ((height + 2 * padding - kernel) // stride) + 1
    new_width = ((width + 2 * padding - kernel) // stride) + 1

    # 输出图像的尺寸
    output_size = (channels, new_height, new_width)
    return output_size

# 示例用法：
input_size = (3, 64, 64)  # 3通道，64x64的图像
output_size = create_cnn(input_size, kernel=3, padding=1, stride=2)
print(output_size)

python模块

模块的使用

python集合了很多模块，包括人工智能领域的一些深度学习框架，比如：TensorFlow，PyTorch等

模块使用中需要注意的：

使用 pip list 查看已安装的模块
使用 pip install 安装模块
使用 pip uninstall 卸载模块
安装时可以指定想要安装的版本，例如：pip install numpy==1.26.1

使用 import 导入模块

import shutil
import time

tik = time.time()

如果模块名很长，可以使用 import … as … 给模块起个别名

# 导入random模块，并将其别名设置为r
import random as r

# 使用randint函数生成一个介于1到5之间的随机整数，并将其赋值给变量a
a = r.randint(1, 5)
# 使用randint函数生成另一个介于1到5之间的随机整数，并将其赋值给变量b
b = r.randint(1, 5)

导入同级目录的方法

from functions import *
# 推荐： from functions import add, sub

python文件与文件操作

文件操作

复制单个文件

import shutil

# 源目录和目标目录
src = 'resources/fire_yolo_format'
dst = 'resources/fire_yolo_format_new'

# 使用copytree复制目录
shutil.copytree(src, dst)

print(f"Directory copied from {src} to {dst}")

复制多个文件

import shutil

# 源目录和目标目录
src = 'resources/fire_yolo_format'
dst = 'resources/fire_yolo_format_new_2'

# 使用copytree复制目录
shutil.copytree(src, dst, ignore=shutil.ignore_patterns("*.txt"))

print(f"Directory copied from {src} to {dst}")

移动文件，相当于剪切粘贴

import shutil

file_1_loc = './resources/保存目录1/fire_label.txt'
file_1_save_loc = './resources/保存目录2/fire_label.txt'
shutil.move(file_1_loc, file_1_save_loc)

删除文件

import os

file_loc = r'./resources/保存目录1/fire.jpg'

os.remove(file_loc)

文件夹操作

创建文件夹

import os

dir_name = "my_dir"
if os.path.exists(dir_name):
    print("文件夹已经存在！")
else:
    os.mkdir(dir_name)
    print("文件夹已经创建完毕！")

创建多层目录

# 导入os模块，用于操作文件路径和目录
import os

# 创建多层文件夹，如果存在则不会重复创建
os.makedirs("my_dir_1\my_dir_2\my_dir_3")

遍历文件夹（获取目录下所有文件名）

# 导入os模块，用于操作文件路径和目录
import os

# 定义根目录路径
root_dir = "dir_loc"

# 存储所有文件的完整路径列表
file_full_path_list = []

# 使用os.walk遍历指定根目录下的所有文件和文件夹
for root, dirs, files in os.walk(root_dir):
    # 遍历每个文件夹中的文件
    for file_i in files:
        # 获取当前文件的完整路径
        file_i_full_path = os.path.join(root, file_i)
        # 将文件完整路径添加到列表中
        file_full_path_list.append(file_i_full_path)

# 打印所有文件的完整路径列表
print(file_full_path_list)

删除空白文件夹（rmdir）

# 导入os模块，用于操作文件路径和目录
import os

# 定义要删除的文件夹路径
dir_path = 'my_dir'

# 检查文件夹是否存在
if os.path.exists(dir_path):
    # 如果存在，打印提示信息
    print("删除文件夹 " + dir_path)
    # 使用os.rmdir函数删除指定的文件夹
    os.rmdir('my_dir')
    # 打印删除完成的提示信息
    print("删除完成")
else:
    # 如果文件夹不存在，打印提示信息
    print("文件夹 " + dir_path + " 不存在")

删除非空文件夹（rmtree)

# 导入os模块，用于操作文件路径和目录
import os
# 导入shutil模块，用于高级文件操作，例如递归删除文件夹
import shutil

# 定义文件夹名称
dir_name = "my_dir"

# 检查文件夹是否存在
if os.path.exists(dir_name):
    # 如果存在，则使用shutil.rmtree函数递归删除文件夹及其内容
    shutil.rmtree(dir_name)
    # 打印文件夹已删除的提示信息
    print("文件夹已经删除！")
else:
    # 如果文件夹不存在，则创建该文件夹
    os.mkdir(dir_name)
    # 打印文件夹不存在的提示信息
    print("文件夹不存在！")

综合案例：YOLO标注文件清洗

训练一个人工智能算法需要一个庞大的数据集，这个数据集需要进行人为标注。

但由于出现意外，造成部分数据丢失，使得标注文件和图片文件的文件名前缀不能一一对应。

需要写一段代码，将可以文件名前缀一一对应的文件保存到一个新的文件夹中，以完成数据的清洗。

import os
import shutil

# 步骤一：定义函数，获取指定根目录下所有文件的文件名列表
def get_info(root_from):
    file_full_path_list = []
    # 遍历指定根目录及其子目录中的所有文件
    for root, dir, files in os.walk(root_from):
        for file_i in files:
            # 构建文件的完整路径
            file_i_full_path = os.path.join(root, file_i)

            # 使用路径分隔符将文件完整路径拆分为列表
            file_i_full_path_list = file_i_full_path.split(os.sep)

            # 获取文件相对于根目录的相对路径
            file_i_short_path = os.path.join(file_i_full_path_list[-2], file_i_full_path_list[-1])

            # 获取不包含扩展名的文件名
            file_i_name = file_i_short_path.split('.')[0]

            # 将文件名添加到列表中
            file_full_path_list.append(file_i_name)

    return file_full_path_list

# 步骤二：定义源目录和目标目录的路径
root_path_from = r'resources/fire_yolo_format'
root_path_save = r'resources/clean_data'

# 源目录中图片和标签文件的路径
root_images_from = os.path.join(root_path_from, 'images')
root_labels_from = os.path.join(root_path_from, 'labels')

# 目标目录中图片和标签文件的路径
root_images_save = os.path.join(root_path_save, 'images')
root_labels_save = os.path.join(root_path_save, 'labels')

# 输出路径信息
print("源图片目录:", root_images_from)
print("源标签目录:", root_labels_from)
print("目标图片目录:", root_images_save)
print("目标标签目录:", root_labels_save)

# 定义子目录列表
dir_list_1 = ['images', 'labels']
# 目标子目录名称列表
dir_name_list = ['train', 'test', 'val']

# 遍历创建目标目录下的子目录
for dir_1_i in dir_list_1:
    for dir_2_i in dir_name_list:
        dir_i_full_path = os.path.join(root_path_save, dir_1_i, dir_2_i)
        # 如果目录不存在，则创建目录
        if not os.path.exists(dir_i_full_path):
            os.makedirs(dir_i_full_path)

# 步骤三：获取源目录中图片文件的文件名列表
image_full_path_list = get_info(root_images_from)
print("源图片文件名列表:", image_full_path_list)

# 获取源目录中标签文件的文件名列表
label_full_path_list = get_info(root_labels_from)
print("源标签文件名列表:", label_full_path_list)

# 将文件名列表转换为集合，以便进行交集操作
image_set = set(image_full_path_list)
label_set = set(label_full_path_list)

# 计算图片文件名集合、标签文件名集合和它们的交集的大小
intersection_set = image_set & label_set
print("图片文件数目:", len(image_set))
print("标签文件数目:", len(label_set))
print("交集文件数目:", len(intersection_set))

# 输出交集集合
print("交集文件列表:", intersection_set)

# 步骤四：遍历交集集合，复制相应的图片和标签文件到目标目录中
for intersection_i in intersection_set:
    intersection_i_image_full_path_from = os.path.join(root_images_from, intersection_i) + '.jpg'
    # 构建要复制的图片文件的目标路径
    intersection_i_image_full_path_save = os.path.join(root_images_save, intersection_i) + '.jpg'

    intersection_i_label_full_path_from = os.path.join(root_labels_from, intersection_i) + '.txt'
    # 构建要复制的标签文件的目标路径
    intersection_i_label_full_path_save = os.path.join(root_labels_save, intersection_i) + '.txt'

    # 复制图片文件和标签文件到目标路径
    shutil.copy(intersection_i_image_full_path_from, intersection_i_image_full_path_save)
    shutil.copy(intersection_i_label_full_path_from, intersection_i_label_full_path_save)

Python面向对象编程

面向对象概念

类

技术解释：类是定义对象的模板或蓝图。它定义了对象的属性（数据）和行为（方法或功能）。
举例：可以把类想象成一个蓝图或者食谱。比如，一个蛋糕的食谱会告诉你需要哪些原料和制作方法，但食谱本身不是蛋糕。

代码示例：

# 使用class创建一个蛋糕类
class Cake:
    # pass只是占位符
    pass

# 使用类
cake_1 = Cake()
cake_2 = Cake()

print(cake_1)
print(cake_2)

运行结果：
<__main__.Cake object at 0x7f989fe77970>
<__main__.Cake object at 0x7f989fe77940>

属性

技术解释：属性是类或对象的变量，它存储了关于对象的信息或者状态。
举例：车的颜色、品牌、型号等信息就是车的属性。它们描述了车的特征。

代码示例：

class Car:
    def __init__(self):
        self.color = 'red'
        self.brand = 'BYD' 
        self.model = 'A1'
        print("正在定义一辆车")
        
car_1 = Car()  # 实例化，自动运行类的__init__方法

print(car_1.color)
print(car_1.brand)
print(car_1.model)

运行结果：
正在定义一辆车
red
BYD
A1

行为

技术解释：行为通常是类中定义的方法，它描述了对象可以执行的操作。
举例：汽车可以启动、加速和刹车。这些都是汽车的行为，描述了汽车可以做什么

代码示例：

class Car:
   def __init__(self):
       self.color = 'red'
       self.brand = 'BYD'
       self.model = 'A1'
       print("正在定义一辆车")
   
   # 定义汽车的行为方法
   def start(self):
       print(f"{self.brand}正在启动")
   def forward(self, metter):
       print(f"正在向前 {metter}米")
   def stop(self):
       print("正在停止")
       
car_1 = Car()  # 实例化，自动运行类的__init__方法

print(car_1.color)
print(car_1.brand)
print(car_1.model)

car_1.start()
car_1.forward(100)
car_1.stop()

运行结果：
正在定义一辆车
red
BYD
A1
BYD正在启动
正在向前 100米
正在停止

对象

技术解释：对象是类的实例。可以根据一个类创建多个对象，每个对象都有自己的属性（数据）和行为（方法）。
举例：如果类是蛋糕的食谱，那么对象就是根据食谱制作出来的实际的蛋糕。可以根据同一个食谱制作成许多蛋糕，每个蛋糕都是一个对象。

代码示例：

# 使用class创建一个神级网络类
class NeuralNetwork:
    def __init__(self, weights, bias):
        """
        初始化神级网络对象。

        参数：
            weights (float): 网络的权重。
            bias (float): 网络的偏差。
        """
        print("我是神级网络")
        self.w = weights
        self.b = bias
        
    def forward(self, x):
        """
        执行前向传播操作。

        参数：
            x (float): 输入数据。

        返回：
            float: 前向传播计算的结果。
        """
        print(f"已经接收到输入{x}")
        print("正在前向传播")
        y = self.w * x + self.b
        return y
        
    def show_parameters(self):
        """展示网络的参数。"""
        print("我的网络参数如下：")
        print(f"self.w = {self.w}")
        print(f"self.b = {self.b}")

# network_1
network_1 = NeuralNetwork(2, 3)
network_1.show_parameters()
result_1 = network_1.forward(2)
print(result_1)

# network_2
network_2 = NeuralNetwork(4, 5)
network_2.show_parameters()
result_2 = network_2.forward(2)
print(result_2)

运行结果：
我是神级网络
我的网络参数如下：
self.w = 2
self.b = 3
已经接收到输入2
正在前向传播
7
我是神级网络
我的网络参数如下：
self.w = 4
self.b = 5
已经接收到输入2
正在前向传播
13

面向对象特征

封装

技术解释：是指将对象的状态（属性）和行为（方法）包装在一起，并限制外部直接访问对象内部细节（例如，直接修改对象的某个属性）。通过封装，对象的内部实现可以自动修改，而不影响外部代码。
举例：就像去银行通过柜员机拿钱，只需要输入账号密码，还有取款金额，就可以拿钱，里面的细节我们不需要解释。

代码示例：

# 创建一个银行类
class BankAccount:
    def __init__(self,initial_balance=0):
        self.balance = initial_balance
    def deposi(self,amount):
        if amount > 0:
            self.balance += amount
            return True
        return False
    def whithdraw(self,amount):
        if 0 < amount <= self.balance:
            self.balance -= amount
            return True
        return False
    def get_blance(self):
        return self.balance
        
        
# 创建一个银行账户
account = BankAccount(1000)
# 存款
success_deposit = account.deposi(50)
print("存钱是否成功 = ", success_deposit)
# 取款
success_whithdraw = account.whithdraw(5000)
print("取款是否成功 = ", success_whithdraw )
# 获取最终余额
balance = account.get_blance()
print("账户最终余额 = ", balance)

运行结果：
存钱是否成功 =  True
取款是否成功 =  False
账户最终余额 =  1050

继承

技术解释：在面向对象编程（OOP）中，继承是一种机制，允许我们定义一个新的类（子类）基于一个已有的类（父类）。子类继承父类的属性和方法，并可以添加自己的属性和方法，或重写父类的方法以实现不同的行为。
举例：扩展之前的例子，在BankAccount基础上，做出可以计算利息的SavingsAccount

代码示例：

# 创建一个银行类
class BankAccount:
    def __init__(self, initial_balance=0):
        self.balance = initial_balance
        
    def deposit(self, amount):
        if amount > 0:
            self.balance += amount
            return True
        return False
    
    def withdraw(self, amount):
        if 0 < amount <= self.balance:
            self.balance -= amount
            return True
        return False
    
    def get_balance(self):
        return self.balance

class SavingAccount(BankAccount):
    def __init__(self, initial_balance, interest_rate):
        super().__init__(initial_balance)
        self.interest_rate = interest_rate
        
    def add_interest(self):
        interest = self.balance * self.interest_rate / 100
        self.balance += interest
        return interest

# 实例化 SavingAccount 对象
saving_account = SavingAccount(100, 5)
interest = saving_account.add_interest()  # 计算并添加利息
new_balance = saving_account.get_balance()  # 获取更新后的余额

print(f"根据利率5计算后存款产生的利息: {interest}, 新余额{new_balance}")  # 输出计算的利息和新余额

运行结果：
根据利率5计算后存款产生的利息: 5.0, 新余额105.0

多态

技术解释：是指不同类的对象对同一消息（方法调用）可以做出不同的响应。这意味着不同类的对象可以使用相同的接口（方法名），但具体实现（方法的内部代码）可以不同。
举例：同样是计算面积，圆形和矩形的计算方法有所不同

代码示例：

# 创建一个计算面积类
class Shape:
    def area(self):
        return 0

# 创建一个计算圆形面积类
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        geometric_area = 3.14159 * self.radius * self.radius
        return f"圆形几何面积为：{geometric_area}"
        
# 创建一个计算矩形面积类
class Rectangle(Shape):
    def __init__(self, length, width):
        self.length = length
        self.width= width
    def area(self):
        geometric_area = self.length * self.width
        return f"矩形几何面积为：{geometric_area}"
        
def print_area(shape):
    print("计算后", shape.area(), sep='的')
    
# 创建不同形状的实例
circle = Circle(5)
rectangle = Rectangle(10, 5)

# 使用多态性质打印面积
print_area(circle)
print_area(rectangle)

运行结果：
计算后的圆形几何面积为：78.53975
计算后的矩形几何面积为：50

综合案例

神经网络继承

class NeuralNetwork:
    def __init__(self, input_layer, hidden_layer, output_layer):
        """
        初始化神经网络对象。
        参数：
            input_layer (int): 输入层神经元数量。
            hidden_layer (int): 隐藏层神经元数量。
            output_layer (int): 输出层神经元数量。
        """
        print("我是神经网络 ")
        print(f"输入层有{input_layer}个神经元")
        print(f"隐藏层有{hidden_layer}个神经元")
        print(f"输出层有{output_layer}个神经元")

    def forward(self, x):
        """
        执行前向传播操作。
        参数：
            x : 输入数据。
        """
        print(f"已经接收到输入{x}")
        print("我在前向传播")


class CNN(NeuralNetwork):
    def __init__(self, input_layer, hidden_layer, output_layer, filters):
        """
        初始化卷积神经网络对象。
        参数：
            input_layer (int): 输入层神经元数量。
            hidden_layer (int): 隐藏层神经元数量。
            output_layer (int): 输出层神经元数量。
            filters (int): 卷积核数量。
        """
        super().__init__(input_layer, hidden_layer, output_layer)
        self.filters = filters
        print(f"我是卷积神经网络，我有{self.filters}个卷积核")

    def convolution(self, x):
        """
        执行卷积操作。
        参数：
            x : 输入数据。
        """
        print(f"对{x}进行卷积操作")

class RNN(NeuralNetwork):
    def __init__(self, input_layer, hidden_layer, output_layer, time_steps):
        """
        初始化循环神经网络对象。
        参数：
            input_layer (int): 输入层神经元数量。
            hidden_layer (int): 隐藏层神经元数量。
            output_layer (int): 输出层神经元数量。
            time_steps (int): 时间步数量。
        """
        super().__init__(input_layer, hidden_layer, output_layer)
        self.time_steps = time_steps
        print(f"我是循环神经网络，我有{self.time_steps}个时间步")

    def recurrent(self, x):
        """
        执行循环操作。
        参数：
            x : 输入数据。
        """
        print(f"对{x}进行循环操作")


# 使用示例
input_layer = 256
hidden_layer = 128
output_layer = 10

cnn_network = CNN(input_layer, hidden_layer, output_layer, filters=32)  # 创建CNN卷积神经网络对象
cnn_network.convolution("图像数据")
print('-------------------------')
rnn_network = RNN(input_layer, hidden_layer, output_layer, time_steps=5)  # 创建RNN循环神经网络对象
rnn_network.recurrent("序列数据")

运行结果：
我是神经网络 
输入层有256个神经元
隐藏层有128个神经元
输出层有10个神经元
我是卷积神经网络，我有32个卷积核
对图像数据进行卷积操作
-------------------------
我是神经网络 
输入层有256个神经元
隐藏层有128个神经元
输出层有10个神经元
我是循环神经网络，我有5个时间步
对序列数据进行循环操作