[TOC]

知识点统计

安装软件：使用PyCharm，Anaconda等软件基本输入输出 基本输入输出：制作用户欢迎标语 程序逻辑结构：顺序语句、循环语句、选择语句 序列数据处理：列表、元组、字典、集合、字符串 函数的定义与使用：参数传递、变量作用域 模块的基本操作：学会如何安装新模块 文件与文件夹操作：文件复制、删除、文件夹遍历 面向对象编程：学会创建一个类

1.基本的输入输出

等号赋值

Python 保留关键字

命名规则

1. 下划线法

   user_name="Alice"
   

2. 驼峰法

   userName="Alice"
   

注释

• 使用 #进行单行注释
• 使用 ''' '''进行多行注释

屏幕输出

键盘输入

• 等待用户键盘输入，用户输入完毕后敲回车进行确认，结果保存在result中

  result = input()
  

• 在提示用户输入之前，先在屏幕显示出“请输入结果"

  result = input("请输入结果")z
  

综合案例

2.程序逻辑结构

顺序结构

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

计算语句

计算同时赋值

数据格式

使用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))

数据格式的转换

• 转为整数

  

• 转为浮点型

  使用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
  num_str = 12 格式是： <class 'str'>
  num_float = 12 格式是： <class 'float'>
  

• 转为字符串

  使用str()转为字符串

  name = "Alice"
  age = 30
  print("My name is %s and I'm %d years old." % (name, age))
  print("My name is {} and I'm {} years old.".format(name, age))
  print(f"My name is {name} and I'm {age} years old.")
  
  My name is Alice and I'm 30 years old.
  My name is Alice and I'm 30 years old.
  My name is Alice and I'm 30 years old.
  

  输出时精度控制

  number = 12.3456
  print("%.2f" % number)
  print("{:.2f}".format(number))
  print(f"{number:.2f}")
  
  12.35
  12.35
  12.35
  

选择结构

运算符的判断

if else if 语句

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

综合案例

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(f"正在处理第{epoch_i}个epoch的数据")
    print(f"第{epoch_i}个数据处理完毕")

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

可对数据进行枚举

img_list = ["img_1.png", "img_2.png", "img_3.png"]
for index, img_i in enumerate(img_list):
    print(f"索引{index}对应的数据是{img_i}")
    
    
索引0对应的数据是img_1.png
索引1对应的数据是img_2.png
索引2对应的数据是img_3.png

• 不确定循环次数的while循环

command = ""
while command != "end":
    command = input("请输入命令：")
    print("正在执行命令：", command)

• break打破循环

# 这是一个数字列表，机器人将在这个列表中搜索数字 "5"
numbers = [1, 3, 4, 2, 5, 6, 8, 7, 9]

# 这是一个标志，用来表示机器人是否找到了数字 "5"
found = False

# 机器人开始搜索数字 "5"
for number in numbers:
    print(f"正在查看数字 {number}")
    if number == 5:
        found = True
        print(f"机器人找到了数字 {number}！")
        break  # 一旦找到数字 "5"，就退出循环

# 检查机器人是否找到了数字 "5"
if not found:
    print("机器人没有找到数字 5.")

正在查看数字 1
正在查看数字 3
正在查看数字 4
正在查看数字 2
正在查看数字 5
机器人找到了数字 5！

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

# 这是一个数字列表，机器人将在这个列表中搜索不是 "5" 的数字
numbers = [1, 3, 4, 2, 5, 6, 8, 7, 9]

# 机器人开始搜索不是 "5" 的数字
for number in numbers:
    print(f"正在查看数字 {number}")
    if number == 5:
        continue  # 如果数字是 "5"，跳过当前迭代，继续下一次循环
    print(f"机器人找到了数字 {number}！")

正在查看数字 1
机器人找到了数字 1！
正在查看数字 3
机器人找到了数字 3！
正在查看数字 4
机器人找到了数字 4！
正在查看数字 2
机器人找到了数字 2！
正在查看数字 5
正在查看数字 6
机器人找到了数字 6！
正在查看数字 8
机器人找到了数字 8！
正在查看数字 7
机器人找到了数字 7！
正在查看数字 9
机器人找到了数字 9！

• 综合案例

a = 10
b = 20
result = a + b

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

假设用户依次输入 25 和 30，程序会输出以下内容：

请输入10+20的结果：25
回答错误
请输入10+20的结果：30
回答正确！

3. 序列

序列通用操作

①索引：通过下标访问内容

numbers = [10, 11, 12, 13, 14]
print(numbers[-1])
print(numbers[0])

14
10

②切片：通过一串下标访问一串内容

numbers = [10, 11, 12, 13, 14]
print(numbers[1:3])
print(numbers[2:])
print(numbers[:2])
print(numbers[:-2])
print(numbers[0:4:2])

[11, 12]
[12, 13, 14]
[10, 11]
[10, 11, 12]
[10, 12]

③序列相加：两个序列前后拼在一起

numbers = [1, 2, 3, 4, 5]
data = ["a", "b", 3, 4.0, 5]
result = numbers + data
print(result)

[1, 2, 3, 4, 5, 'a', 'b', 3, 4.0, 5]

④序列乘法：序列中的内容重复出现多次

numbers = [1, 2, 3]
result = numbers * 3
print(result)

[1, 2, 3, 1, 2, 3, 1, 2, 3]

⑤序列是否包含元素：查看元素是否在序列中

numbers = [1, 2, 3]
if 1 in numbers:
    print("1 在 numbers 里面")
else:
    print("1 不在 numbers 里面")

1 在 numbers 里面

⑥序列长度、最大值、最小值：对序列做简单的统计

numbers = [1, 2, 3, 4, 5]
print(len(numbers))
print(max(numbers))
print(min(numbers))

5 5 1

列表

• 列表是最常用的序列

  # 初始化空列表
  list_empty = []
  # 定义列表 list_a
  list_a = [1, 2, 3]
  # 使用 range() 生成列表 list_b
  list_b = list(range(1, 4))  # 注意：range 的第二个参数应为 4，以包含 1 到 3
  # 打印三个列表
  print(list_empty)
  print(list_a)
  print(list_b)
  
  []
  [1, 2, 3]
  [1, 2, 3]
  

• 访问列表元素：列表属于序列，可以用索引访问

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

• 列表遍历：对列表遍历的两种方式

  # 定义数据列表
  data_list = ['a', 'b', 'c', 'd', 'e']
  
  # 遍历并打印列表中的每个元素
  for data_i in data_list:
      print(data_i)
      
  a
  b
  c
  d
  e
  

  # 定义数据列表
  data_list = ['a', 'b', 'c', 'd', 'e']
  
  # 使用 enumerate 遍历列表，同时获取索引和元素值
  for index, data_i in enumerate(data_list):
      print(index, data_i)
  0 a
  1 b
  2 c
  3 d
  4 e
  
  enumerate(data_list)：返回一个枚举对象，每次迭代时提供一个索引 (index) 和对应的元素值 (data_i)
  

• 添加、修改、删除列表元素：列表可以进行增删改查

  # 定义列表 list_a
  list_a = [1, 2, 3, 4, 5]
  # 打印初始列表
  print(list_a)
  # 在列表末尾添加元素 6
  list_a.append(6)
  print(list_a)
  # 修改列表中索引为 0 的元素值为 0
  list_a[0] = 0
  print(list_a)
  # 从列表中移除元素 4
  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
  list_a = [1, 2, 3, 4, 5]
  # 计算列表中所有元素的总和
  result = sum(list_a)
  # 打印总和
  print(result)
  
  15
  

• 列表元素进行排序

# 定义分数列表
score = [50, 60, 20, 40, 30, 80, 90, 55, 100]
# 打印原列表
print("原列表：", score)
# 对列表进行升序排序
score.sort()
print("升序后：", score)
# 对列表进行降序排序
score.sort(reverse=True)
print("降序后：", score)

原列表： [50, 60, 20, 40, 30, 80, 90, 55, 100]
升序后： [20, 30, 40, 50, 55, 60, 80, 90, 100]
降序后： [100, 90, 80, 60, 55, 50, 40, 30, 20]

• 列表推导式：可以快速创建一个有序列表

  # 使用列表推导式生成从 0 到 9 的整数列表
  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)
  # 计算平均准确率
  average_accuracy = sum(accuracies) / len(accuracies)
  # 打印平均准确率，保留两位小数
  print(f"Average Accuracy: {average_accuracy:.2f}")
  
  Average Accuracy: 0.90
  

元组

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

  # 定义一个空元组
  tuple_1 = ()
  # 使用 range() 函数生成一个包含特定范围值的元组
  tuple_2 = tuple(range(10, 20, 2))
  # range(10, 20, 2) 生成从 10 到 20（不包括 20）的数字序列，步长为 2，即 [10, 12, 14, 16, 18]。
  # 打印两个元组
  print(tuple_1)
  print(tuple_2)
  
  ()
  (10, 12, 14, 16, 18)
  

• 元组的数据可以索引和切片

  # 正确定义元组
  tuple_1 = (1, 2, 3, 4, 5)
  # 打印元组的第三个元素（索引为 2）
  print(tuple_1[2])
  # 打印元组的最后一个元素（使用负索引 -1）
  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)
  

列表和元组的差异

详细说明

1. 定义方式：

   • 列表可以通过 [ ] 或 list() 创建，例如：my_list = [1, 2, 3] 或 my_list = list((1, 2, 3))。
   • 元组可以通过 ( ) 或 tuple() 创建，例如：my_tuple = (1, 2, 3) 或 my_tuple = tuple([1, 2, 3])。

2. 可变性：

   • 列表是可变的，可以对其进行增删改操作。例如：

     python深色版本

     my_list = [1, 2, 3]
     my_list.append(4)  # 添加元素
     my_list[0] = 0     # 修改元素
     

   • 元组是不可变的，创建后无法修改其内容。例如：

     python深色版本

     my_tuple = (1, 2, 3)
     # my_tuple[0] = 0  # 这会引发 TypeError 错误
     

3. 方法：

   • 列表提供了丰富的内置方法，例如 append()、insert()、remove()、pop() 等。

   • 元组的方法较少，主要有

     count()
     

     （统计某个值出现的次数）和

     index()
     

     （查找某个值的索引位置）。例如：

     python深色版本

     my_tuple = (1, 2, 3, 2)
     print(my_tuple.count(2))  # 输出 2
     print(my_tuple.index(3))  # 输出 2
     

4. 性能：

   • 列表由于支持动态修改，内部实现较为复杂，因此性能相对较慢。
   • 元组由于是不可变的，内存分配固定，操作更高效，性能更快。

5. 适用场景：

   • 列表适用于需要频繁修改数据的场景，例如存储动态变化的数据集合。
   • 元组适用于数据固定不变的场景，例如存储配置项、常量集合等。

6. 占用空间：

   • 列表由于支持动态扩展，需要额外的空间来管理数据结构，因此占用空间较大。

   • 元组由于固定长度，占用空间较小。例如：

     python深色版本

     import sys
     my_list = [1, 2, 3]
     my_tuple = (1, 2, 3)
     print(sys.getsizeof(my_list))  # 输出：72
     print(sys.getsizeof(my_tuple)) # 输出：56
     

• 元组案例

  # 模型的配置（层数，每层的单元数，激活函数）
  model_config = (3, 128, "relu")
  
  # 解包元组
  layers, units, activation = model_config
  
  # 打印解包后的值
  print(f"Layers: {layers}, Units: {units}, Activation: {activation}")
  # layers, units, activation = model_config 将元组中的值依次赋给变量 layers、units 和 activation。
  
  Layers: 3, Units: 128, Activation: relu
  

字典

• 字典存放的信息以键值对形式出现

  # 定义小明的信息字典
  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 = {
      "layer_1": {"units": 64, "activation": "relu"},
      "layer_2": {"units": 128, "activation": "relu"},
      "output_layer": {"units": 10, "activation": "softmax"}
  }
  
  # 打印神经网络的配置参数
  print(neural_network_config)
  
  
  {
      "layer_1": {"units": 64, "activation": "relu"},
      "layer_2": {"units": 128, "activation": "relu"},
      "output_layer": {"units": 10, "activation": "softmax"}
  }
  

• 可以通过键访问到值

  # 创建一个字典来存储神经网络的配置参数
  neural_network_config = {
      "layer_1": {"units": 64, "activation": "relu"},
      "layer_2": {"units": 128, "activation": "relu"}, 
      "output_layer": {"units": 10, "activation": "softmax"}
  }
  
  # 访问字典中的特定键值对
  layer_1_units = neural_network_config["layer_1"]["units"]
  
  # 打印第一层的单元数
  print(f"Number of units in layer 1: {layer_1_units}")
  
  Number of units in layer 1: 64
  

• 对字典遍历的方式

  # 定义小明的信息字典
  info_xiaoming = {
      'name': '小明',
      'age': 14,
      'score': 60
  }
  
  # 遍历字典
  print("以下为 xiaoming 的信息：")
  for key, value in info_xiaoming.items():
      print(f"{key} 为 {value}")
  
  
  以下为 xiaoming 的信息：
  name 为 小明
  age 为 14
  score 为 60
  

  # 创建一个字典来存储神经网络的配置参数
  neural_network_config = {
      "layer_1": {"units": 64, "activation": "relu"},
      "layer_2": {"units": 128, "activation": "relu"},
      "output_layer": {"units": 10, "activation": "softmax"}
  }
  
  # 遍历字典，打印每一层的配置信息
  for layer, config in neural_network_config.items():
      print(f"{layer}: {config['units']} units, activation = {config['activation']}")
  
  layer_1: 64 units, activation = relu
  layer_2: 128 units, activation = relu
  output_layer: 10 units, activation = softmax
  

• 可以对字典元素进行增删改查

  # 创建一个字典来存储神经网络的配置参数
  neural_network_config = {
      "layer_1": {"units": 64, "activation": "relu"},
      "layer_2": {"units": 128, "activation": "relu"},
      "output_layer": {"units": 10, "activation": "softmax"}
  }
  
  # 添加一个新的层到字典
  neural_network_config["layer_3"] = {"units": 256, "activation": "relu"}
  
  # 修改第一层的单元数
  neural_network_config["layer_1"]["units"] = 128
  
  # 删除输出层的激活函数键值对
  del neural_network_config["output_layer"]["activation"]
  
  # 输出修改后的字典
  print(neural_network_config)
  
  
  {
      'layer_1': {'units': 128, 'activation': 'relu'},
      'layer_2': {'units': 128, 'activation': 'relu'},
      'output_layer': {'units': 10},
      'layer_3': {'units': 256, 'activation': 'relu'}
  }
  

• 字典案例

  # 不同模型的信息
  models_info = {
      "CNN": {"layers": 3, "units": 128, "activation": "relu"},
      "RNN": {"layers": 2, "units": 64, "activation": "tanh"}
  }
  
  # 访问特定模型的信息
  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
  

集合

• 集合的标值是大括号，具有去重复作用

  # 创建空集合
  set_1 = set()
  set_2 = set()  # 原代码中 set_2 没有被定义，这里补充为一个空集合
  # 创建包含元素的集合（自动去重）
  set_3 = {1, 2, 3, 3, 4, 5}
  # 打印集合
  print(set_1)
  print(set_2)
  print(set_3)
  
  set()
  set()
  {1, 2, 3, 4, 5}
  

• 集合支持增删改查，同时里面的元素会自动去重复

  # 初始化一个空集合
  my_set = set()
  # 添加元素
  my_set.add(1)  # {1}
  my_set.add(2)  # {1, 2}
  my_set.add(3)  # {1, 2, 3}
  # 删除元素
  my_set.remove(2)  # {1, 3}
  # 打印集合
  print(my_set)
  
  {1, 3}
  

• 使用集合完成数学当中的集合运算

  # 定义两个集合
  set1 = {1, 2, 3, 4}
  set2 = {3, 4, 5, 6}
  
  # 交集运算
  intersection = set1.intersection(set2)
  # 或者
  # intersection = set1 & set2
  print(f"交集：{intersection}")
  
  # 并集运算
  union = set1.union(set2)
  # 或者
  # union = set1 | set2
  print(f"并集：{union}")
  
  交集：{3, 4}
  并集：{1, 2, 3, 4, 5, 6}
  
  # 定义两个集合
  set1 = {1, 2, 3, 4}
  set2 = {3, 4, 5, 6}
  
  # 差集运算（set1 - set2）
  difference1 = set1.difference(set2)
  # 或者
  # difference1 = set1 - set2
  print(f"set1 和 set2 的差集：{difference1}")
  
  # 差集运算（set2 - set1）
  difference2 = set2.difference(set1)
  # 或者
  # difference2 = set2 - set1
  print(f"set2 和 set1 的差集：{difference2}")
  
  set1 和 set2 的差集：{1, 2}
  set2 和 set1 的差集：{5, 6}
  

• 使用集合的小案例

  # 两个实验中使用的激活函数
  experiment1 = {"relu", "sigmoid", "tanh"}
  experiment2 = {"relu", "softmax"}
  # 找出两个实验中都使用过的激活函数
  common_activations = experiment1.intersection(experiment2)
  # 或者可以使用 & 运算符：common_activations = experiment1 & experiment2
  # 打印结果
  print(f"Common Activations: {common_activations}")
  
  Common Activations: {'relu'}
  

字符串

• 字符串索引

  # 示例字符串
  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)
  

• 字符串比较

  '''
  基本输入输出代码练习
  '''
  # 定义两个字符串
  string1 = "He1lo"
  string2 = "hello"
  string3 = "Hello"
  
  # 使用 == 操作符比较字符串
  is_equal = string1 == string2  # 结果：False
  print(f"string1 is equal to string2: {is_equal}")
  
  is_equal = string1 == string3  # 结果：False
  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()  # 结果：False（原注释为 True，实际为 False）
  print(f"string1 is equal to string2 (ignore case): {is_equal_ignore_case}")
  

4.函数&模块

函数

• 参数传递：形参与实参

  # 形参是函数定义时的参数，实参是函数调用时的参数
  # 定义函数
  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 是实参
  
  Creating a model with 3 layers and 128 units in each layer.
  

• 位置参数

  # 位置参数的顺序很重要
  # 定义函数
  def create_model(layers, units):  # 注意：这里修正了参数名拼写错误，将 "laxers" 改为 "layers"
      print(f"Creating a model with {layers} layers and {units} units in each layer.")
  
  # 调用函数
  create_model(3, 128)  # 第一次调用，3 对应 layers，128 对应 units
  create_model(128, 3)  # 第二次调用，128 对应 layers，3 对应 units
  
  Creating a model with 3 layers and 128 units in each layer.
  Creating a model with 128 layers and 3 units in each layer.
  

• 关键字参数

  # 使用关键字参数调用函数
  
  # 定义函数
  def create_model(layers, units):  # 定义形参 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)  # 关键字参数，顺序依然不重要
  
  Creating a model with 3 layers and 128 units in each layer.
  Creating a model with 3 layers and 128 units in each layer.
  

• 默认参数

  # 使用默认参数值
  
  # 定义函数，设置默认参数值
  def create_model(layers=3, units=128):  # layers 默认为 3，units 默认为 128
      print(f"Creating a model with {layers} layers and {units} units in each layer.")
  
  # 调用函数，使用默认值
  create_model()  # 不传参时，使用默认值
  
  Creating a model with 3 layers and 128 units in each layer.
  

• 可变参数

  # 使用可变参数接收多个参数值
  
  # 定义函数，使用可变参数 *layers 接收多个参数
  def add_layers(model, *layers):  # *layers 表示接收任意数量的参数
      for layer in layers:  # 遍历传入的每一层
          print(f"Adding layer {layer} to model {model}.")
  
  # 调用函数，传递多个参数
  add_layers("Model1", "conv", "relu", "softmax")
  
  Adding layer conv to model Model1.
  Adding layer relu to model Model1.
  Adding layer softmax to model Model1.
  

• 通过 return 返回

  # 函数返回模型的信息
  
  # 定义函数
  def create_model(layers, units):  # 定义形参 layers 和 units
      info = f"Creating a model with {layers} layers and {units} units in each layer."
      return info  # 返回生成的字符串信息
  
  # 调用函数
  model_info = create_model(3, 128)  # 调用函数，传入参数 3 和 128
  print(model_info)  # 打印返回的结果
  
  Creating a model with 3 layers and 128 units in each layer.
  

• 全局变量

  # 全局变量
  MODEL_NAME = "CNN"
  
  # 定义函数
  def print_model_name():
      print(f"The model name is {MODEL_NAME}.")
  
  # 调用函数
  print_model_name()
  
  The model name is CNN.
  

• 局部变量

  # 局部变量
  def create_model():
      model_name = "RNN"  # 局部变量
      print(f"Creating a model named {model_name}.")
  
  # 调用函数
  create_model()
  
  # 尝试访问局部变量（会报错）
  print(model_name)  # NameError: name 'model_name' is not defined
  
  Creating a model named RNN.
  NameError: name 'model_name' is not defined
  

• 匿名函数:冒号前面是输入，国号后面是输出

  # 使用 lambda 创建匿名函数
  calculate_units = lambda layers: layers * 128
  
  # 调用函数
  units = calculate_units(3)
  
  # 打印结果
  print(f"Total units: {units}")
  
  
  Total units: 384
  

• 综合案例：创建一个函数，其输入包括以下参数：

  • 输入图像尺寸 (channels, height, width)
  • 卷积核大小 kernel_size（默认值为 3）
  • 边缘补零 padding（默认值为 0）
  • 卷积步长 stride（默认值为 1）

  函数需要返回卷积操作后图像的尺寸。

  计算方法如下：

  new_height = ((height + 2 * padding - kernel_size) // stride) + 1
  new_width = ((width + 2 * padding - kernel_size) // stride) + 1
  

  最后将 channels、new_height 和 new_width 组成一个新的元组 output_size 并返回。

      """
      计算卷积操作后图像的尺寸。
  
      参数：
      input_size (tuple): 输入图像尺寸，格式为 (channels, height, width)。
      kernel_size (int): 卷积核大小，默认为 3。
      padding (int): 边缘补零大小，默认为 0。
      stride (int): 卷积步长，默认为 1。
  
      返回：
      tuple: 卷积后的输出图像尺寸，格式为 (channels, new_height, new_width)。
      """
  def calculate_conv_output_size(input_size, kernel_size=3, padding=0, stride=1):
      # 解构输入图像尺寸
      channels, height, width = input_size
      # 计算卷积后的高度和宽度
      new_height = ((height + 2 * padding - kernel_size) // stride) + 1
      new_width = ((width + 2 * padding - kernel_size) // stride) + 1
      # 返回新的输出尺寸
      output_size = (channels, new_height, new_width)
      return output_size
  

模块

查看已安装的模块

pip list

使用以下命令安装所需的模块：

pip install 模块名

如果需要安装特定版本的模块，可以指定版本号：

pip install 模块名==版本号

pip install numpy==1.21.0

如果需要升级模块到最新版本：

pip install --upgrade 模块名

如果需要卸载某个模块：

pip uninstall 模块名

在 Python 脚本或交互式环境中，使用 import 语句导入模块。

import 模块名

如果模块名称较长，可以使用 as 给模块起一个别名：

import 模块名 as 别名

import numpy as np
import pandas as pd

如果只需要模块中的某些功能，可以使用以下语法：

from 模块名 import 功能名

from math import sqrt

可以通过以下方式导入模块中的所有功能，但通常不推荐这样做，因为它可能会导致命名冲突：

from 模块名 import *

简单案例：统计用户输入时长

functions.py对应的代码

def add(x,y):
    return x+y

def sub(x,y):
    return x - y

learn_import.py对应的代码

import time
import numpy
import random as r
from functions import *

a = r.randint(1,5)
b = r.randint(1,5)

tik = time.time()
data = int(input(f"请输入{a} - {b} 的结果"))
result = sub(a,b)
if data == result:
    print("恭喜，回答成功")
else:
    print("回答错误！")

tok = time.time()
print(tok - tik)

文件与文件夹操作

①文件操作

• 复制单个文件

  import shutil
  
  file_1_loc = './resources/保存目录1/fire.jpg'  # 原文件路径
  file_1_save_loc = './resources/保存目录2/fire_copy.jpg'  # 目标文件路径
  
  # 使用 shutil.copyfile 复制文件
  shutil.copyfile(file_1_loc, file_1_save_loc)
  

• 复制多个文件

  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
  
  # 源文件路径和目标文件路径
  file_1_loc = '/resources/保存目录1/fire_label.txt'  
  file_1_save_loc = './resources/保存目录2/fire_label.txt'
  # 使用 shutil.move 移动文件
  shutil.move(file_1_loc, file_1_save_loc)
  # 输出移动完成的信息
  print(f"File moved from {file_1_loc} to {file_1_save_loc}")
  

• 删除文件

  import os
  # 文件路径
  file_loc = r"./resources/保存目录1/fire.jpg"  
  # 删除文件
  os.remove(file_loc)
  # 输出删除成功的信息
  print(f"File removed: {file_loc}")
  

②文件夹操作

• 创建文件夹

  import os
  
  dir_name = "my_dir"
  # 检查文件夹是否存在
  if os.path.exists(dir_name):  # 如果文件夹已存在
      print("文件夹已经存在！")
  else:  # 如果文件夹不存在，则创建
      os.mkdir(dir_name)
      print("文件夹已经创建完毕！")
      
  
  # 创建多级目录
  os.makedirs("my_dir_1\\my_dir_2\\my_dir_3", exist_ok=True)
  print("多级目录创建完成！")
  

• 遍历文件夹

  import os
  
  root_dir = "dis_loc"
  file_full_path_list = []
  
  # 遍历 root_dir 目录及其子目录
  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)
  

• 删除空白文件夹

  import os
  
  dir_path = 'my_dir'
  
  # 检查文件夹是否存在
  if os.path.exists(dir_path):  # 如果文件夹存在
      print("删除文件夹 " + dir_path)
      os.rmdir(dir_path)  # 删除文件夹
      print("删除完成")
  else:  # 如果文件夹不存在
      print("文件夹 " + dir_path + " 不存在")
  

• 综合案例

  在训练人工智能算法时，通常需要一个大规模的数据集，并对数据集进行人为标注。然而，在实际操作中可能会出现意外情况，例如部分数据丢失，导致 标注文件与图片文件的文件名前缀无法一一对应。为了确保数据的完整性和一致性，我们需要编写一段代码，将文件名前缀匹配的图片文件和标注文件保存到一个新的文件夹中，从而完成数据清洗。

  # 训练一个人工智能算法需要一个庞大的数据集，这个数据集需要进行人为标注。
  # 但由于出现意外，造成部分数据丢失，使得标注文件和图片文件的文件名前缀不能一一对应。
  # 需要写一段代码，将可以文件名前缀一一对应的文件保存到一个新的文件夹中，以完成数据的清洗。
  
  
  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('\\')
  
              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'
      # print(intersection_i_image_full_path)
      intersection_i_label_full_path_from = os.path.join(root_labels_from, intersection_i) + '.txt'
      # print(intersection_i_label_full_path)
  
      intersection_i_image_full_path_save = os.path.join(root_images_save, intersection_i) + '.jpg'
  
      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)
  

5.面相对象

①面相对象的概念

• 类

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

  class Cake:
      pass
  
  cake_1 = Cake()
  cake_2 = Cake()
  
  print(cake_1)
  print(cake_2)
  

• 属性

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

  class Car:
      def __init__(self):  # 初始化方法
          self.color = 'red'  # 设置颜色属性
          self.band = 'BYD'  # 设置品牌属性
          self.model = 'A1'  # 设置型号属性
          print("正在定义一辆车")
  
  # 实例化对象
  car_1 = Car()
  
  # 打印对象的属性
  print(car_1.color)  # 输出颜色
  print(car_1.band)  # 输出品牌
  print(car_1.model)  # 输出型号
  

• 行为

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

  class Car:
      def __init__(self):  # 初始化方法
          self.color = 'red'  # 设置颜色属性
          self.band = 'BYD'  # 设置品牌属性
          self.model = 'A1'  # 设置型号属性
          print("正在定义一辆车")
  
      def start(self):
          print(f"{self.band}正在启动汽车！")
  
      def forward(self,meter):
          print(f"正在向前开车！{meter}")
  
      def stop(self):
          print("正在停止汽车！")
  
  
  # 实例化对象
  car_1 = Car()
  
  # 打印对象的属性
  print(car_1.color)  # 输出颜色
  print(car_1.band)  # 输出品牌
  print(car_1.model)  # 输出型号
  
  car_1.start()
  car_1.forward(100)
  car_1.stop()
  
  正在定义一辆车
  red
  BYD
  A1
  BYD正在启动汽车！
  正在向前开车！100
  正在停止汽车！
  

• 对象

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

  # 定义 NeuralNetwork 类
  class NeuralNetwork:
      def __init__(self, weights, bias):  # 初始化方法
          self.w = weights  # 权重参数
          self.b = bias     # 偏置参数
  
      def forward(self, x):  # 前向传播方法
          y = self.w * x + self.b  # 线性计算
          return y
  
      def show_parameters(self):  # 显示参数方法
          print(f"当前网络参数如下：")
          print(f"权重 (w) = {self.w}")
          print(f"偏置 (b) = {self.b}")
  
  
  # network_1
  network_1 = NeuralNetwork(weights=2, bias=3)  # 创建第一个神经网络实例
  network_1.show_parameters()  # 显示 network_1 的参数
  result_1 = network_1.forward(2)  # 计算前向传播结果
  print(f"network_1 的前向传播结果为: {result_1}")
  

②面相对象的特点

• 封装

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

  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
  
  
  # 创建一个银行账户
  account = BankAccount(1000)
  success_deposit = account.deposit(50)
  print("success_deposit=", success_deposit)
  success_withdraw = account.withdraw(500)
  print("success_withdraw=", success_withdraw)
  print("余额=", account.get_balance())
  
  success_deposit= True
  success_withdraw= True
  balance= 550
  

• 继承

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

  # 定义一个基础的银行账户类
  class BankAccount:
      # 初始化方法，设置初始余额，默认值为 0
      def __init__(self, initial_balance=0):
          self.balance = initial_balance  # 账户余额
  
      # 存款方法
      def deposit(self, amount):
          # 如果存款金额大于 0，则增加余额并返回 True
          if amount > 0:
              self.balance += amount
              return True
          # 否则返回 False 表示存款失败
          return False
  
      # 取款方法
      def withdraw(self, amount):
          # 如果取款金额大于 0 且小于等于当前余额，则减少余额并返回 True
          if 0 < amount <= self.balance:
              self.balance -= amount
              return True
          # 否则返回 False 表示取款失败
          return False
  
      # 获取当前余额的方法
      def get_balance(self):
          return self.balance
  
  
  # 定义一个储蓄账户类，继承自 BankAccount 类
  class SavingAccount(BankAccount):
      # 初始化方法，设置初始余额和利率
      def __int__(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
  
  
  # 创建一个储蓄账户实例，初始余额为 100，利率为 5%
  saving_account = SavingAccount(100, 5)
  
  # 调用 add_interest 方法计算并添加利息
  interest = saving_account.add_interest()
  
  # 获取新的余额
  new_balance = saving_account.get_balance()
  
  # 打印利息和新的余额
  print(interest, new_balance)
  

• 多态

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

  # 定义一个基础形状类 Shape
  class Shape:
      def __init__(self):
          # 构造函数不返回任何值，Shape 类是一个抽象基类，用于定义通用接口
          pass
  
      # 定义一个通用的 area() 方法，子类必须实现该方法
      def area(self):
          # 如果子类没有实现 area() 方法，则抛出异常，提示子类需要实现此方法
          raise NotImplementedError("子类必须实现 area() 方法")
  
  
  # 定义 Circle 类，继承自 Shape
  class Circle(Shape):
      def __init__(self, radius):
          # 初始化半径属性
          self.radius = radius  # 圆的半径
  
      # 实现 area() 方法，计算圆的面积
      def area(self):
          # 使用圆的面积公式：πr^2
          return 3.14159 * self.radius * self.radius
  
  
  # 定义 Rectangle 类，继承自 Shape
  class Rectangle(Shape):
      def __init__(self, length, width):
          # 初始化长度和宽度属性
          self.length = length  # 矩形的长度
          self.width = width    # 矩形的宽度
  
      # 实现 area() 方法，计算矩形的面积
      def area(self):
          # 使用矩形的面积公式：长 × 宽
          return self.length * self.width
  
  
  # 定义一个函数，用于打印形状的面积
  def print_area(shape):
      # 调用传入对象的 area() 方法，并打印结果
      print("The Area of the shape is: ", shape.area())
  
  
  # 创建 Circle 类的实例，表示一个半径为 5 的圆
  circle = Circle(5)
  
  # 创建 Rectangle 类的实例，表示一个长为 10、宽为 5 的矩形
  rectangle = Rectangle(10, 5)
  
  # 调用 print_area 函数，分别打印圆和矩形的面积
  print_area(circle)    # 打印圆的面积
  print_area(rectangle) # 打印矩形的面积
  

综合案例

神经网络的继承（看操作演示）

# 定义一个通用的神经网络类 NeuralNetwork
class NeuralNetwork:
    def __init__(self, input_layer, hidden_layer, output_layer):
        # 初始化神经网络的基本结构
        print("我是神经网络")
        print(f"输入层有 {input_layer} 个神经元")  # 打印输入层神经元数量
        print(f"隐藏层有 {hidden_layer} 个神经元")  # 打印隐藏层神经元数量
        print(f"输出层有 {output_layer} 个神经元")  # 打印输出层神经元数量

    def forward(self, x):
        # 定义前向传播方法
        print(f"已经接收到输入 {x}")  # 打印接收到的输入数据
        print("正在前向传播")  # 表示正在进行前向传播


# 定义卷积神经网络类 CNN，继承自 NeuralNetwork
class CNN(NeuralNetwork):
    def __init__(self, input_layer, hidden_layer, output_layer, filters):
        # 调用父类 NeuralNetwork 的初始化方法
        super().__init__(input_layer, hidden_layer, output_layer)
        self.filters = filters  # 定义卷积核的数量
        print(f"我是卷积神经网络，我有 {filters} 个卷积核")  # 打印卷积核的数量

    def convolution(self, x):
        # 定义卷积操作方法
        print(f"对 {x} 进行卷积操作")  # 打印正在对输入数据进行卷积操作


# 定义循环神经网络类 RNN，继承自 NeuralNetwork
class RNN(NeuralNetwork):
    def __init__(self, input_layer, hidden_layer, output_layer, time_steps):
        # 调用父类 NeuralNetwork 的初始化方法
        super().__init__(input_layer, hidden_layer, output_layer)
        self.time_steps = time_steps  # 定义时间步的数量
        print(f"我是循环神经网络，我有 {self.time_steps} 个时间步")  # 打印时间步的数量

    def recurrent(self, 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(100)  # 调用卷积方法，传入输入数据 100

# 创建循环神经网络实例并调用循环方法
rnn_network = RNN(input_layer, hidden_layer, output_layer, time_steps=5)  # 创建 RNN 实例
rnn_network.recurrent(10)  # 调用循环方法，传入输入数据 10


我是神经网络
输入层有 256 个神经元
隐藏层有 128 个神经元
输出层有 10 个神经元
我是卷积神经网络，我有 32 个卷积核
对 100 进行卷积操作
我是神经网络
输入层有 256 个神经元
隐藏层有 128 个神经元
输出层有 10 个神经元
我是循环神经网络，我有 5 个时间步
对 10 进行循环操作