主要的参考资料来源 《深度学习入门：基于Python的理论与实现 (斋藤康毅) 》（鱼书） B站Up主爆肝杰哥的相关视频 主要考虑到是入门以及快速能上手工程，没有基础，不能在数学等其余问题上过多的纠结，本身掌握程度不够，所以不会以李沐老师的课成为第一课程，后续才会去看 此外，因为是为了深度学习才接触的Python，并非专攻Python方向，所以对于Python的很多其他的特性也不会涉及，一切以深度学习的需要进行学习

前言

在深度学习领域，我们主要是利用Python以及几个库进行，分别是

• NumPy-为Python加上了关键的数组变量类型

• Pandas-在NumPy的基础上添加了类似Excel的行列标签

• Matplotlib-借鉴Matlab，为Python提供了绘图能力

• Scikit-learn-机器学习库，包含了分类，回归，聚类，将为等多种算法

• Tensorflow-Goole研发的深度学习框架

• PyTorch-FaceBook研发的深度学习框架

深度学习的相关概念

大家可能听说过人工智能；机器学习；神经网络；深度学习等多个专有名词，实际上这几个都是有联系的

• 人工智能是最大的一个概念，最顶层的，其中一个重要的分支就是机器学习

• 机器学习的算法多种多样，其中核心就是神经网络

• 神经网络的隐藏层如果够深，就可以被称之为深层神经网络，这也属于我们所说的深度学习

• 深度学习包括了深度神经网络；卷积神经网络；循环神经网络

变量类型与输出语句

总览

学习Python首先需要注意如下几点

1. Python的注释是采用#而不是 //，多行注释要采用三个双引号"""..."""

2. Python是动态语言类型不是静态，在声明变量的时候不需要指定变量类型，如果需要指定数据类型，可以使用类型注解（但是即使使用，也只是作为提示作用，不会受到编译器强制校验）

3. Python没有末尾分号，但是有比较烦人的缩进，所以不要在Python中随便使用空格

首先我们来看看如何定义一个变量

# 直接声明和初始化即可
a = 2  
# 如果需要指定类型 可以使用类型注解，即name:type的形式
b:int = 2  
# 但是类型注解只是起到提示的作用，编译器并不会校验，所以如下代码也不会报错
c:int = "abc"

Python原生的数据类型分为两大类：基本变量类型和高级变量类型，一共七种数据类型 基本数据类型包括：字符串，数字，布尔类型 ； 高级变量类型包括：集合，元组，列表，字典 七种类型展示如下，需要注意一下几点

• Python不能够声明但是不赋值，这是因为在Python中变量只有被赋值的时候才是真正被创建，在其他语言中，例如Java中允许int a;这是因为在Java中声明即创建了对应的内存空间，a已经存在只是没有数值

• Python中的布尔类型严格遵循大小写，只能是True和False，而不能是true或false

• Python四大高级变量类型，set集合是使用大括号{} ； list列表使用中括号[] ； tuple元组使用的小括号() ； dict字典是大括号但为Key-Value的形式

• list集合：有序，支持下标访问，地址不可变但是内容可变，支持增删改，允许重复，空列表使用[]或者list()

• tuple元组：有序，同列表可下标访问；不可变，一旦确认不能修改，不能增删改；允许重复；空元组使用()或者tuple()；如果是只有一个元素的元组创建，必须加一个逗号(1,)

• set集合：无序,不能下标查找；可变，支持增删，但不能修改已有元素；不可重复，自动去重；空集合使用set()；支持集合运算符交集(&),并集( | ),差集(-)等

• dict字典：3.7版本及其以上默认按照插入顺序排序；3.7之前无序 ； 可变 Key唯一，重复会覆盖原本的 ； Value可重复 ；Key必须是不可变类型(例如int,str,tuple；列表/集合/字典就不能作为Key) ； 空字典使用dict()或者{}，只能通过键值对访问而不能通过索引访问

# 声明但不赋值 这个在python中是不允许的
s:int
​
# 基本变量类型  
s = "zeal" # 字符串  
# 数字类型  
age = 22  
height = 1.75  
weight = 120.0  
# 布尔类型  
bool_t = True  
bool_f = False  
  
# 高级变量类型  
#集合set 利用大括号包裹{}  
set_v = {1,2,3}  
print(set_v)  
  
  
# 元组tuple 利用 小括号包裹()  
tuple_v = (1,2,3)  
print(tuple_v)  
  
# 列表  
list_v = [1,2,3,4,5]  
print(list_v)  
  
# 字典dict  
dict_v = {"name":"zeal","age":22}  
print(dict_v)

特性	list（列表）	tuple（元组）	set（集合）	dict（字典）
有序性	是	是	否	3.7+是，3.6及以下否
可变性	是（支持增/删/改元素）	否（创建后不可修改）	是（支持增/删元素，无修改）	是（支持增/删/改键值对）
元素重复性	允许重复元素	允许重复元素	不允许重复元素（自动去重）	键唯一（重复覆盖），值允许重复
访问方式	通过索引（下标）访问	通过索引（下标）访问	无索引（仅in判断存在）	通过键（key）访问值
定义符号	[]（空列表：[]/list()）	()（空元组：()/tuple()）	{}（空集合：set()）	{key: value}（空字典：{}/dict()）
键/元素要求	无特殊要求	无特殊要求	元素需为不可变类型	键需为不可变类型，值无限制
核心用途	动态有序的序列数据	固定不变的有序数据	数据去重/集合运算	键值对映射（如用户信息、配置）
查找效率	O(n)（按索引O(1)）	O(n)（按索引O(1)）	O(1)（in判断）	O(1)（按键查找）

基本变量类型

字符串类型

Python中字符串类型，也就是我们别的编程语言中说的String类型，可以使用双引号，也可以使用单引号,支持两种方式的原因是为了保证当字符串本身有单引号或者双引号的时候可以灵活处理，如果字符串本身同时具备单引号和双引号，那么和别的编程语言一样，就需要使用转义了。

# 当变量中本身具备单引号  
s1 = "I'm a student."  # 使用双引号包裹字符串 防止字符串本身的单引号截断  
# 当变量中本身具备双引号  
s2 = 'He said, "I am a student."'  # 使用单引号包裹字符串 防止字符串本身的双引号截断  
# 当变量中同时具备单引号和双引号  
s3 = "He said, \"I'm a student.\""  # 使用转义字符 \ 来表示字符串中的双引号,当然，也可以转义单引号

当我们要想组合字符串类型的变量的时候，可以利用 f字符串，将需要引入的字符串变量在f后的字符串中通过大括号{...}包裹起来从而实现引用，在输出中我们常这么使用

name = "zeal"  
love = "play game"  
# 组合字符串为一个新字符串
result = f"My name is {name} and I love {love}"  
print(result)
# 直接在打印语句中组合字符串  
print(f"My name is {name} and I love {love}")

当然，print还有另外一个用法，直接利用逗号,进行拼接，但是因为默认,会用一个空格隔开，我们可以在最后用sep=设置间隔符从而实现无间隔拼接

print("my name is",name,"and age is",age,sep=" ")

数字类型

数字类型分为整型和浮点型，具体的区别我们在NumPy中再去介绍。 Python中常见运算规则如下

# 1. 算术运算符
print("-" * 40)  
a = 10  
b = 3  
print(f"a = {a}, b = {b}")  
  
print(f"加法: a + b = {a} + {b} = {a + b}")  
print(f"减法: a - b = {a} - {b} = {a - b}")  
print(f"乘法: a * b = {a} * {b} = {a * b}")  
#需要注意python中的单个/是完整的除法 也就是会计算完
#别的语言中 / 是整除，python中 // 才是整除
print(f"除法: a / b = {a} / {b} = {a / b}")  
print(f"整除: a // b = {a} // {b} = {a // b}")  
print(f"取余: a % b = {a} % {b} = {a % b}")  
print(f"幂运算: a ** b = {a} ** {b} = {a ** b}")  # a的b次方,即a^b
  
# 2. 比较运算符
# 等于为== 不等于为!= 可以直接使用>= 和 <=
print("-" * 40)  
x = 15  
y = 20  
print(f"x = {x}, y = {y}")  
  
print(f"等于: x == y -> {x} == {y} = {x == y}")  
print(f"不等于: x != y -> {x} != {y} = {x != y}")  
print(f"大于: x > y -> {x} > {y} = {x > y}")  
print(f"小于: x < y -> {x} < {y} = {x < y}")  
print(f"大于等于: x >= y -> {x} >= {y} = {x >= y}")  
print(f"小于等于: x <= y -> {x} <= {y} = {x <= y}")  
  
# 3. 赋值运算符 (Assignment Operators)print("\n【3】赋值运算符 (Assignment Operators)")  
print("-" * 40)  
c = 5  
print(f"初始值: c = {c}")  
  
c += 3      # c = c + 3  
print(f"加法赋值: c += 3 -> c = {c}")  
  
c -= 2      # c = c - 2  
print(f"减法赋值: c -= 2 -> c = {c}")  
  
c *= 4      # c = c * 4  
print(f"乘法赋值: c *= 4 -> c = {c}")  
  
c /= 2      # c = c / 2  
print(f"除法赋值: c /= 2 -> c = {c}")  
  
c //= 3     # c = c // 3  
print(f"整除赋值: c //= 3 -> c = {c}")  
  
c %= 4      # c = c % 4  
print(f"取余赋值: c %= 4 -> c = {c}")  
  
c **= 3     # c = c ** 3  
print(f"幂运算赋值: c **= 3 -> c = {c}")  
  
# 4. 位运算符 
print("-" * 40)  
m = 12      # 二进制: 1100  
n = 10      # 二进制: 1010  
# 利用bin(number) 可以得到number的二进制
print(f"m = {m} (二进制: {bin(m)}), n = {n} (二进制: {bin(n)})")  
  
print(f"按位与: m & n = {m} & {n} = {m & n} (二进制: {bin(m & n)})")  
print(f"按位或: m | n = {m} | {n} = {m | n} (二进制: {bin(m | n)})")  
print(f"按位异或: m ^ n = {m} ^ {n} = {m ^ n} (二进制: {bin(m ^ n)})")  
print(f"按位取反: ~m = ~{m} = {~m} (二进制: {bin(~m & 0b1111)})")  
print(f"左移: m << 2 = {m} << 2 = {m << 2} (二进制: {bin(m << 2)})")  
print(f"右移: m >> 2 = {m} >> 2 = {m >> 2} (二进制: {bin(m >> 2)})")  
  
# 5. 逻辑运算符 这里需要注意和别的语言的区别,python的与或非使用的为 and or not 而不是& | !
print("-" * 40)  
p = True  
q = False  
print(f"p = {p}, q = {q}")  
  
print(f"逻辑与: p and q = {p} and {q} = {p and q}")  
print(f"逻辑或: p or q = {p} or {q} = {p or q}")  
print(f"逻辑非: not p = not {p} = {not p}")  
  
# 6. 成员运算符和身份运算符 
# 主要用于高级变量类型，检查是否在集合内，in 和 not in
# 元组，列表，集合，字典都可以使用，对于字典而言，检查的是key不是value
print("-" * 40)  
num_list = [1, 2, 3, 4, 5]  
num1 = 10  
num2 = 10  
print(f"列表: {num_list}, num1 = {num1}, num2 = {num2}")  
  
print(f"成员运算符 in: 3 in num_list = {3 in num_list}")  
print(f"成员运算符 not in: 6 not in num_list = {6 not in num_list}")  
print(f"身份运算符 is: num1 is num2 = {num1 is num2}")  
print(f"身份运算符 is not: num1 is not num_list = {num1 is not num_list}")  
  
# 7. 运算符优先级示例  
print("\n【7】运算符优先级示例")  
print("-" * 40)  
result1 = 10 + 5 * 3  
result2 = (10 + 5) * 3  
result3 = 2 ** 3 * 4  
result4 = 2 ** (3 * 4)  
  
print(f"乘法优先于加法: 10 + 5 * 3 = {result1}")  
print(f"括号改变优先级: (10 + 5) * 3 = {result2}")  
print(f"幂运算优先于乘法: 2 ** 3 * 4 = {result3}")  
print(f"括号改变优先级: 2 ** (3 * 4) = {result4}")  
  
# 8. 不同数字类型之间的运算  
print("\n【8】不同数字类型之间的运算")  
print("-" * 40)  
int_num = 10  
float_num = 3.5  
complex_num = 2 + 3j  
  
print(f"整数: {int_num}, 浮点数: {float_num}, 复数: {complex_num}")  
print(f"整数 + 浮点数: {int_num} + {float_num} = {int_num + float_num} (类型: {type(int_num + float_num)})")  
print(f"整数 + 复数: {int_num} + {complex_num} = {int_num + complex_num} (类型: {type(int_num + complex_num)})")  
print(f"浮点数 * 复数: {float_num} * {complex_num} = {float_num * complex_num} (类型: {type(float_num * complex_num)})")

类型转换

Python中，字符串，浮点数，整数，布尔类型之间都可以转换

• 需要转化为字符串，使用str()

• 需要转化为整数，使用int()

• 需要转化为浮点数，使用float()

• 需要转化为布尔类型，使用bool() 需要注意，上述的这些属于内置工具函数，而不是别的语言中的强转，但也要注意 浮点数字符串不能int(); 非0数字和非空字符串(包括空格组成的字符串) 使用bool()返回True; 0和串("")使用bool()返回False

str_v = "123.123"  
print(float(str_v))  
print(bool(str_v))  
  
number1 = 99  
number2 = 0  
print(str(number1))  
print(str(number2))  
print(bool(number2))  
  
bool_v1 = True  
bool_v2 = False  
print(str(bool_v1))  
print(str(bool_v2))  
print(int(bool_v1))  
print(int(bool_v2))
​

高级变量类型

Set集合

Set集合的特点：无序 ； 不可重复 ；可以使用-；|；&进行集合的运算；不能修改，只能删除和新增

set_1 = {"湖","南","科","专",1,2,3}  
print(set_1) # 输出 {1, 2, 3, '南', '专', '湖', '科'}  体现无序
set_2 = set(["湖","南","科","科",4,5,6])  # 类似上面的类型转换，可有元组得到
print(set_2) # 输出 {4, 5, 6, '南', '湖', '科'} 体现自动去重
​
print(set_1-set_2) # set1中有但是set2中没有的  
print(set_1|set_2) # set1或set2中的所有元素  
print(set_1&set_2) # set1和set2中的交集元素

我们可以使用 in 和 not in判断元素是否存在于集合中

可以通过list(set)或者tuple(set)的方式将集合转换为列表或者元组，从而实现遍历和查找元素 如果要修改元素，因为不支持修改，我们只能先删除再添加，删除我们常用的语法是remove()和discard()（前者删除不存在的元素的时候会报错，后者不会更加安全），新增则用add()

集合在深度学习的过程中遇到的概率比较低，会被Pands替代，所以不过多讲述

List列表

Python中的列表就可以比作Java中的ArrayList，边长的数组，可重复，有序，下标访问，只是基于Python动态语言的特性，一个List中可以包含任何数据类型，不存在类型限制，也可以List套List

list_v = [1,2,3,"ZhangSan",True,[4,5,6]]  
print(list_v)
print(list_v[0])

虽然List没有限制，但是实际上底层List还是会需要存储每个类型的数据类型，导致数组其实占用空间增大了。在NumPy中我们会用NumPy数组（仅仅接纳一种数据类型的列表）代替List，提升运行速度，降低内存压力

List支持负数下标索引，我们知道0索引位置对应的List的第一个元素，那么-1其实就是倒数第一个元素，以此类推，-2就是倒数第二个元素

list_v = [1,2,3,"ZhangSan",True,[4,5,6]]  
print(list_v[-1],list_v[-2],list_v[-3])  
list_v[-2]=100  
print(list_v[-1],list_v[-2],list_v[-3])

Python的List有着和Golang的数组一样的切片的特性，切片就是列表一部分，可以利用[start:end]的形式截取列表中的 start~end 之间的部分，注意左闭右开

list_v = [1,2,3,"ZhangSan",True,[4,5,6]]  
print(list_v[1:]) # 第二个元素到最后  
print(list_v[:]) # 全部元素  
print(list_v[1:2]) # 只有第二个元素  
print(list_v[:5]) # 前四个元素 等同于 print(list_v[:-1])

除此之外，Python的切片还能支持间隔切片。当我们明确隔n个元素采样一次的时候，可以使用[star:end:n]

list_v = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]  
print(list_v[1:-1:2]) # [2, 4, 6, 8, 10, 12, 14]

特别注意，Python的切片和原列表对象是完全独立的，也就是两个列表了实际上，所以对于几百万数据的大列表进行切片操作，对于主机而言是一个很大的考验，这点要和Go的切片区分开来，Go中的切片和原来的是共享的

list_v = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]  
list_v2 = list_v[1:-1:2]  
print(list_v2)   # [2, 4, 6, 8, 10, 12, 14]
list_v2[0] = 99  
print(list_v2)  # [99, 4, 6, 8, 10, 12, 14]
print(list_v) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

在NumPy的数组中这个就被舍弃了，NumPy中的切片和原数组是共享的，修改切片也会修改原数组，如果真的需要完全拷贝一份新的，就是借助copy()函数

List可以通过append()函数添加元素，也可以通过加法和乘法扩充和复制

list_v = [1,2,3,4]  
list_v.append(5)  
print(list_v)  #12345
print(list_v+[6])   #123456
print(list_v+[6,7,8])  #12345678
print(list_v*2) #1234512345

列表还有一个列表推导式，可以了解和学习一下 正常的我们创建由已知列表开平方得到新列表，我们需要借助for循环，代码如下

result = []
for i in [1,2,3,4]:
    result = result+[i**2]
print(result)

使用列表推导式之后可以这么写

result = [i**2 for i in [1,2,3,4]]

也还是加一点的if判断

result = []
for i in [1,2,3,4]:
    if i<3:
        result = result+[i**2]
print(result)
​
# 列表推导式写法
result = [i**2 for i in [1,2,3,4] if i<3]

tuple元组

元组的特点：有序；可重复；单个元素不可修改但是可重新赋值替换；下标访问

tuple_age = (1,2,3)  
# 这种创建方式极其简单方便
# 同时也可以看到，python中对于类型的要求没那么强
tuple_name = "张三","李四",99  tuple_null = ()  # 创建空元组
print(tuple_age)  
# tuple_age[0]=10 在运行的时候会报错
tuple_age = 3,3,3  
print(tuple_age[0]) # 下标访问单个元素
print(tuple_name)  
print(tuple_null)

除此之外，可以利用元组进行批量赋值，或者说就是Python的批量赋值的特性

a,b,c = 1,2,3  
e,f,g = (11,12.2,13.33)  
print(a,b,c)  
print(e,f,g)

当有多个数值的列表，然后你只需要部分数值的时候，你可以利用元组的快捷构造的特性进行截取

result1,result2,*other,result3 =1,2,3,4,5  
print(result1)  #1
print(result2)  #2
print(other)  #[3,4]
print(result3) #5

dict字典

一个Key-Value结构，不可重复，重复会覆盖；无序 ；Key唯一 ； Value可以为任何数据类型，Key只能是不可变的元素（数字，字符串，布尔，元组，不可变集合）

dict_v = {  
    "name":"zhangsan",  
    "age":18,  
    1:(1,2,3),  
    2:[1,2,3],  
    3:{1,2,3},  
    "4":True  
}  
# {'name': 'zhangsan', 'age': 18, 1: (1, 2, 3), 2: [1, 2, 3], 3: {1, 2, 3}, '4': True}
print(dict_v)

字典添加元素，可以直接通过dict[newKey]=newValue的方式进行新增

dict_v = {  
    "name":"zhangsan",  
    "age":18,  
}  
dict_v["newKey"] = "newValue"  
print(dict_v)

类型转换

集合，列表，元组，字典之间也可以进行转换，用到如下四个函数

• 转化为集合使用set()

• 转化为元组使用tuple()

• 转化为列表使用list()

• 转化为字典使用dist() 这里就展示图片，不附带代码了，可自行尝试，需要注意的是，其余的转化为字典的时候，因为字典是双列的，所以肯定还会需要一个单列集合，这个时候就需要借助zip(A,B)函数，该函数会将入参A和B进行一一对应，然后让A[0]作为Key，B[0]作为Value从而组成dict[0]，这里需要注意，传入的A和B如果是集合这种无序的，那么会造成匹配不一样按照预期一样

流程控制

if语句

在Python中，if语句的使用格式为如下，需要注意：

• Python中的函数，循环，if条件判断等都不会使用end来表示代码块的结束

• Python中使用缩进来表示代码块的范围

• 每一个判断条件的最后都有一个冒号，不要遗漏

if 判断条件:
    逻辑处理一
elif 判断条件:
    逻辑处理二
else:
    逻辑处理三

简单的分数区间判断案例

source = 85  
if source == 100:  
    print("满昏")  
elif source >= 90:  
    print("优秀")  
elif source >= 60:  
    print("及格")  
else:  
    print("不及格")

循环语句

Python中for循环的基本使用如下

for 变量名 in 可迭代对象:
    循环体逻辑
    
    
# 遍历列表，依次取出每个元素 
fruits = ["苹果", "香蕉", "橙子"] 
for fruit in fruits: 
    print(f"我喜欢吃：{fruit}") 
# 输出结果： # 我喜欢吃：苹果 # 我喜欢吃：香蕉 # 我喜欢吃：橙子

如果需要计数式循环，即例如Java中for(int i=0;i<10;i++),可以借助range(n)，该函数会创建一个0~n-1的整数序列供for循环使用,需要注意，range()函数也是左闭右开的区间范围

# 用法1：range(n) → 生成 0 ~ n-1 的整数序列  
for i in range(5):  
    print(i)  # 输出：0 1 2 3 4  
  
# 用法2：range(start, end) → 生成 start ~ end-1 的整数序列（左闭右开）  
for i in range(2, 7):  
    print(i)  # 输出：2 3 4 5 6  
  
# 用法3：range(start, end, step) → 步长为step，生成等差序列  
for i in range(0, 10, 2):  
    print(i)  # 输出：0 2 4 6 8（偶数）  
  
# 示例：通过索引遍历列表  
fruits = ["苹果", "香蕉", "橙子"]  
for i in range(len(fruits)):  
    print(f"索引{i}：{fruits[i]}")

for循环也常用于高级变量类型的遍历

# 1. 遍历列表 (List)print("\n【1】遍历列表 (List)")  
print("-" * 40)  
fruits = ["苹果", "香蕉", "橙子", "葡萄", "草莓"]  
print(f"列表内容: {fruits}")  
  
print("方法1: 直接遍历元素")  
for fruit in fruits:  
    print(f"  - {fruit}")  
  
print("\n方法2: 使用enumerate()获取索引和值")  
for index, fruit in enumerate(fruits):  
    print(f"  索引: {index}, 值: {fruit}")  
  
print("\n方法3: 使用range(len())遍历索引")  
for i in range(len(fruits)):  
    print(f"  索引: {i}, 值: {fruits[i]}")  
  
# 2. 遍历元组 (Tuple)print("\n【2】遍历元组 (Tuple)")  
print("-" * 40)  
colors = ("红色", "绿色", "蓝色", "黄色")  
print(f"元组内容: {colors}")  
  
print("方法1: 直接遍历元素")  
for color in colors:  
    print(f"  - {color}")  
  
print("\n方法2: 使用enumerate()获取索引和值")  
for index, color in enumerate(colors):  
    print(f"  索引: {index}, 值: {color}")  
  
# 3. 遍历集合 (Set)print("\n【3】遍历集合 (Set)")  
print("-" * 40)  
numbers = {1, 2, 3, 4, 5, 3, 2}  # 注意：集合会自动去除重复元素  
print(f"集合内容: {numbers}")  
  
print("方法1: 直接遍历元素")  
for num in numbers:  
    print(f"  - {num}")  
  
print("\n方法2: 对集合排序后遍历")  
for num in sorted(numbers):  
    print(f"  - {num} (排序后)")  
  
# 4. 遍历字典 (Dictionary)print("\n【4】遍历字典 (Dictionary)")  
print("-" * 40)  
student_scores = {  
    "张三": 95,  
    "李四": 87,  
    "王五": 92,  
    "赵六": 78  
}  
print(f"字典内容: {student_scores}")  
  
print("方法1: 遍历键(keys)")  
for name in student_scores:  
    print(f"  学生: {name}, 分数: {student_scores[name]}")  
  
print("\n方法2: 明确遍历键(keys)")  
for name in student_scores.keys():  
    print(f"  学生: {name}, 分数: {student_scores[name]}")  
  
print("\n方法3: 遍历值(values)")  
for score in student_scores.values():  
    print(f"  分数: {score}")  
  
print("\n方法4: 同时遍历键和值(items)")  
for name, score in student_scores.items():  
    print(f"  学生: {name}, 分数: {score}")  
  
# 5. 嵌套数据结构的遍历  
print("\n【5】嵌套数据结构的遍历")  
print("-" * 40)  
nested_data = {  
    "班级A": [85, 90, 78],  
    "班级B": [92, 88, 84],  
    "班级C": [79, 85, 91]  
}  
  
print("遍历嵌套字典和列表")  
for class_name, scores in nested_data.items():  
    print(f"  {class_name}:")  
    for i, score in enumerate(scores):  
        print(f"    学生{i+1}: {score}分")  
  
# 6. 使用条件语句的遍历  
print("\n【6】带条件判断的遍历")  
print("-" * 40)  
mixed_list = [1, "hello", 3.14, "world", 42, True, "python"]  
print(f"混合列表: {mixed_list}")  
  
print("只打印字符串类型的元素:")  
for item in mixed_list:  
    if isinstance(item, str):  
        print(f"  字符串: {item}")  
  
print("\n只打印数字类型的元素:")  
for item in mixed_list:  
    if isinstance(item, (int, float)):  
        print(f"  数字: {item}")  
  
print("\n" + "="*60)  
print("Python for循环遍历演示完成！")  
print("="*60)

while循环的基本格式如下

while 条件:
    循环体

break和continue的使用和其他语言一致，这里不过多讲述

函数

Python中的函数关键字为def，其格式如下

def 函数名(入参列表):
    """ 文档说明字符串 """
    函数体
    return 反参

首先我们来解释一下这个一开始文档说明字符串，这个需要搭配方法名.__doc__进行使用，当你在这个方法写了文档说明字符串的时候，你使用方法名.__doc__就能打印出这些内容，相当于做了方法说明文档，当然，这个不是必须的，如果不写，调用.__doc__会返回None

def add(x, y):  
    """计算x+y"""  
    return x + y  
  
print(add.__doc__) # 输出 计算x+y

函数的入参和反参可以是七种数据类型中的任意一种，并且Python的入参是值传递，也就是说函数入参是形参，不会对外部数据造成影响

def change(v):  
    v=v+1  
  
x = 10  
change(x)  
print(x) # 依旧是10

Python的函数可以多个入参和多个反参,多个反参可以利用多个变量接收，可以当作一个整体进行接收

def my_counter(a,b):  
    return a+b,a-b,a*b  
  
a,b,c= my_counter(1,2)  
print("和为",a,"差为",b,"积为",c)  
tuple_v = my_counter(1,2)  
print("和为",tuple_v[0],"差为",tuple_v[1],"积为",tuple_v[2])

需要传入可变数量的参数的时候，可以利用元组拆分法，利用*name作为入参

def my_counter(*args):  
    result = 0  
    for arg in args:  
        result += arg  
    return result  
  
print(my_counter(1, 2, 3, 4, 5))  #15
print(my_counter(1, 2, 3)) # 6

自然，也可以同时指定一个入参和剩下的不确定入参，需要注意的是，可变参数只能作为最后一个参数且一个函数只能有一个可变参数，虽然编译器不会报错，但是运行时会出错，因为无法确定边界

def my_counter(off,*args):  
    result = 0  
    for arg in args:  
        result += arg  
    return result+off  
  
print(my_counter(-10,1, 2, 3, 4, 5))  
print(my_counter(10,1, 2, 3))

上面通过*name实现不确定入参，可以理解为创建了一个name的列表然后允许我们一直往里面加东西，除此之外，还可以利用**name的方式，作为可变参数的键值对/字典

def plusDict(a,b,**dict_v):  
    """ 加入对Java和Golang的描述，也可以自定义加新的描述键值对 """    dict_v["Java"] = a  
    dict_v["Golang"] = b  
    return dict_v  
  
print(plusDict( "CRUD工程师","云原生的宠儿",Python="AI时代大哥大",Rust="高大上") )

在入参的时候，可以指定入参名从而不一定需要按照顺序传入参数

def my_counter(a, b, c):  
    return a + b * c  
print(my_counter(1,c=2,b=3))

在定义函数的时候，可以指定入参默认值，从而当不传入的时候，可以使用默认值

def yourSchool(name,level="本科"):  
    print("your school " + name + "is a " + level )  
  
yourSchool("HNUST")  # 不会报错
yourSchool("HNUST","985")

类

定义和普通使用

类的定义我们就不多说了，Python中的类一样具备封装，继承，多态的特性(据说在深度学习领域类一般是用来封装参数传递，其余特性用的少)，并且在Python中其实也是一切皆对象，就连基本数据类型int也是

a = 1
print(type(a)) # 输出：<class 'int'>

Python中类中的函数称之为方法，且约定俗成类的名称一般大写，Python的每个类必须包含一个__init__的初始化方法（简单理解为有参构造方法） init方法内的入参通过赋值就可以让类对象拥有成员a,b，也可以直接不通过入参来定义成员，这些成员具备默认值

class Counter:  
    """ 一个可以进行加减法的计算器 """    
    def __init__(self, a, b):  # 用于完成初始化的特殊方法  
        self.a = a  
        self.b = b
        self.name = "超级计算机"
  
  
    def plus(self):  # 类中的普通方法  
        return self.a + self.b  
    def minus(self):  # 类中的普通方法  
        return self.a - self.b
    def zwjs(self):  
        print("欢迎使用", self.name)

可以看到，无论是自定义普通方法还是init初始化方法，都有一个self参数，这个参数用于链接类内部和外部的信息，大家可以简单的理解为this指针，而且从上面也可也看到，Python的类的成员属性貌似可以不要定义，会根据__init__方法自动定义在self中，需要的话直接去self中拿就行了

类定义完成后，就可以创建类的对象以及调用其成员方法和成员属性

counter1 = Counter(1,2)  
print(counter1.a, counter1.b)  
print(counter1.plus())  
print(counter1.minus())  
counter1.zwjs()

继承

利用继承，可以让子类继承父类的属性和方法 Python的继承的表现形式为

class 类名(父类名):

在Python中还能多继承

class 类名(fu1,fu2)

子类需要在__init__方法中调用super()函数从而实现继承属性和方法，对于父类中已有属性和方法子类中再次定义的话就会覆盖重写

class Counter2(Counter):  
    """ 可以进行加减乘除的计算器 """  
    def __init__(self, a, b):  
        super().__init__(a, b)  # 这个不写其实也没事，不写的话就不能使用父类的东西，只要不使用父类的东西就不会报错
        self.name = "超级计算机二代"  
  
    def multiply(self):  
        return self.a * self.b  
    def divide(self):  
        return self.a / self.b  
  
    def zwjs(self):  
        print("您好,欢迎使用", self.name)
        
        
counter = Counter2(1, 2)  
print(counter.plus())  
print(counter.minus())  
print(counter.multiply())  
print(counter.divide())  
counter.zwjs()