Python深度学习入门：从基础语法到PyTorch实战

1. Python语言简介

Python是一门简洁、易读、功能强大的高级编程语言，以其接近人类自然语言的语法特点而广受欢迎。在深度学习领域，Python凭借其丰富的科学计算库（如NumPy、PyTorch、TensorFlow）和简洁的语法，成为了研究和开发的首选语言。

Python的核心优势：

  • 语法简洁：代码可读性高，学习曲线平缓
  • 生态丰富：拥有庞大的第三方库支持
  • 跨平台：可在Windows、Linux、macOS等多个操作系统上运行
  • 社区活跃：遇到问题可以快速找到解决方案

对于深度学习初学者来说，掌握Python基础是进入AI领域的必经之路。本文将从Python基础语法讲起，逐步深入到深度学习所需的NumPy和PyTorch库的使用。

2. Python基础数据结构

在Python中，数据结构是组织和存储数据的方式。掌握以下五种基本数据类型是编写Python程序的基础：

2.1 数值类型：整型与浮点型

整型（int） 用于表示整数，浮点型（float） 用于表示小数。Python的变量使用非常灵活，无需显式声明类型。

# 整型示例
a = 3  # Python的变量使用之前不需要声明，而是根据内容自动分配类型
# a = 3.0  按Ctrl+/可以快速注释选中代码
print(a)
b = 4
print(b)
print(a, b)
a, b = b, a  # Python支持多变量赋值，这是Python特有的简洁语法
print(a, b)

运行结果：
整型变量操作结果

浮点型示例：

name = "ligekaoyan"  # 字符串可以用单引号或双引号
print(name)
print(name[2])  # 字符串支持索引访问，索引从0开始

运行结果：
浮点型示例结果

2.2 列表（List）

列表是Python中最常用的数据结构之一，用于存储有序的元素集合。

2.2.1 基础用法
# 列表 list []
list1 = [1, 2, 3, 4, 5]
print(list1)
print(list1[2])  # 访问第三个元素（索引从0开始）
print(list1[-1])  # 负索引是Python中非常强大的功能，-1表示最后一个元素

dict1 = {"name": "ligekaoyan", "age": 28, 20: 80}  # 字典
list2 = [1, "art", dict1]  # 列表可以嵌套其他数据类型，包括字典
print(list2)

运行结果：
列表基础用法结果

2.2.2 列表的切片、插入与删除

切片操作是Python列表的强大功能，可以方便地获取子列表：

list1 = [1, 2, 3, 4, 5]
for each in list1:
    print(each)

print(list1[1:4])  # [2, 3, 4]，左闭右开区间
print(list1[0:4])  # [1, 2, 3, 4]
print(list1[1:-1])  # [2, 3, 4]，-1表示最后一个元素
print(list1[1:])   # [2, 3, 4, 5]，冒号后不写默认到末尾
print(list1[:])    # [1, 2, 3, 4, 5]，复制整个列表

for each in list1[1:4]:
    print(each)

运行结果：
列表切片操作结果

删除操作：

list2 = [1, 2, 3, 10, 5]
print(list2)
list2.remove(10)  # 删除指定值的元素
print(list2)

list2 = [1, 2, 3, 10, 5]
del list2[3]  # 删除指定索引的元素
print(list2)

运行结果：
列表删除操作结果

增加操作：

list2 = [1, 2, 3, 4, 5]
list2.append(7)  # 在末尾添加一个元素
print(list2)
list2.extend([8, 9])  # 在末尾添加另一个列表的所有元素
print(list2)

# 列表推导式：快速构建列表的简洁语法
list2 = [i for i in range(1, 10, 2)]  # 生成1到9的奇数列表
print(list2)

# 等价写法
list3 = []
for i in range(10):
    list3.append(i)
print(list3)

运行结果：
列表增加操作结果

2.3 字典（Dictionary）

字典是Python中的键值对集合，类似于其他语言中的Map或哈希表。

# 字典 dict {}
# 格式：key : value
dict1 = {"name": "ligekaoyan", "age": 28, 20: 80}  # 键可以是字符串、数字等不可变类型
print(dict1["name"])   # 用key作为索引来访问value
print(dict1["age"])
print(dict1[20])

运行结果：
字典操作结果

字典的特点：

  • 键必须是不可变类型（字符串、数字、元组）
  • 值可以是任意类型
  • 通过键快速访问值，时间复杂度为O(1)

3. Python基本语句与流程控制

要掌握一门编程语言，首先需要理解其四种基础语句类型：赋值语句、条件判断、循环语句和函数定义。这些构成了程序逻辑的骨架。

3.1 赋值语句（陈述）

赋值语句用于给变量分配值，这是最基本的操作。Python支持多种赋值方式：

  • 简单赋值：a = 3
    ÿ09- 多重赋值：a, b = 1, 2
    ÿ09- 链式赋值：a = b = c = 0

3.2 条件判断（if语句）

条件判断让程序能够根据不同的情况执行不同的代码块，这是实现逻辑控制的基础。

a = 3

if a == 3:  # 条件后面必须有冒号
    print("正确的")  # Python中使用缩进来表示代码块，通常使用4个空格
    print("今天天气不错")

if a == 4:
    print("错误的1")
    
print("错误的2")  # 这行不属于任何if语句，总是会执行

运行结果：
条件判断基础结果

嵌套条件判断：

a = 3
b = 4
if a == 3:
    if b > 3:
        print("b大于3")
    else:
        print("b不大于3")  # Shift+Tab可以取消缩进

运行结果：
嵌套条件判断结果

None值的判断：

A = None  # None表示空值，类似于其他语言中的null
if A == None:
    print("A为空")

运行结果：
None值判断结果

3.3 循环语句

循环用于重复执行某段代码，Python提供了for和while两种循环。

for循环：

# for i in 可迭代对象
list1 = [1, 2, 3, 4, 5]
for i in list1:
    print(i)

运行结果：
for循环结果

range()函数：生成一个整数序列，常用于控制循环次数

for i in range(10):  # [0, 10)，不包含10
    print(i)
print("----------")
for i in range(1, 10, 2):  # 从1开始，到10结束（不包含），步长为2
    print(i)

运行结果：
range函数结果

遍历字典：

dict1 = {"name": "ligekaoyan", "age": 28, 20: 80}
print(dict1)

for each in dict1:  # each是常用的遍历变量名
    print(each)      # 打印key
    print(dict1[each])  # 打印value

运行结果：
遍历字典结果

while循环：

i = 0
while i < 10:  # 相比C语言，Python的while语句少括号多冒号
    i = i + 1   # Python没有i++语法
    print(i)

运行结果：
while循环结果

3.4 函数

函数是组织代码的基本单元，可以提高代码的复用性和可读性。

基本算术运算：

a = 3
b = 2
print(a + b)   # 加法
print(a - b)   # 减法
print(a * b)   # 乘法
print(a / b)   # 除法，返回浮点数
print(a // b)  # 整除（向下取整除法），和C语言除法类似
print(a ** b)  # 幂运算，a的b次方

运行结果：
基本算术运算结果

自定义函数：

# 计算a的平方
def myfunc1(a):
    c = a ** 2
    return c
    
a = 3
print(myfunc1(a))

# 计算a的b次方
def myfunc2(a, b):
    return a ** b
    
a = 3
b = 3
print(myfunc2(a, b))

# 默认参数：如果传入b就返回a的b次方，否则返回a的平方
def myfunc3(a, b=2):
    return a ** b

a = 3
print(myfunc3(a))  # 使用默认参数b=2
print(myfunc3(a, 3))  # 传入b=3

运行结果：
自定义函数结果

函数设计原则：

  1. 单一职责：一个函数只做一件事
  2. 参数明确：参数名要有意义，必要时添加类型提示
  3. 返回值清晰：明确函数返回什么
  4. 文档注释：使用docstring说明函数功能

4. Python的类与继承

4.1 类

在深度学习中，我们要想搭建一个模型，可能要集成很多东西
那么我们需要用到类，它可以集成很多的属性和自己的函数
是这个类的实例，就可以用这个类的东西
我们来定义一个人的类

#__init__中来声明属性
class person():  #修正拼写错误：persion -> person
    def __init__(self,name,age):  #self表示类自己，用于在各个函数中传递属性
        self.name=name
        self.age=age
    def print_name(self):
        print(self.name)
    def print_age(self):
        print(self.age)

切记声明了一个类，但不代表有这个实例，如果在下面直接打印那就会报错
在这里插入图片描述
结果
在这里插入图片描述
ps：这种情况就如同定义了一个链表节点，不等于有了一个链表
下面是实例化

laoli=person('ligekaoyan',28)  #实例化，统一用户名为ligekaoyan
print(laoli.name)
laoli.print_name()  #类中函数可以直接使用

结果
在这里插入图片描述

4.2 继承

继承的意义在于减少重复性工作
我们再来定义一个超人的类，超人有人的属性，所以我们直接继承人的类

class superman(person):  #继承person类
    def __init__(self,name,age):
        super().__init__(name, age)
        #super(superman, self).__init__(name,age)与上面等同
        self.fly_=True
    def fly(self):
        if(self.fly_== True):
            print("我会飞")
lige=superman('ligekaoyan',28)  #统一用户名为ligekaoyan
lige.print_name()
print(lige.name)
lige.print_age()
lige.fly()

结果
在这里插入图片描述

5.numpy库的作用

numpy深度学习中非常重要的一个库

import numpy as np  #进行缩写

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

array1=np.array(list1)  #转化为矩阵
print(array1)

array2=np.array(list1)

array3=np.concatenate((array1,array2),axis=1)  #拼接，axis=1横向拼接（向右），axis=0竖向拼接（向下）
print(array3)

结果

在这里插入图片描述
切片

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

array1=np.array(list1)#转化为矩阵
#矩阵的切片功能更强大
print(list1[1:3])
print(array1[1:3,1:3])

#跳着切
idx=[1,3]
print(array1[:,idx])

结果
在这里插入图片描述

6.torch库与tensor

6.1张量

张量是一个升级版矩阵，它能表示的维度更多，它的计算速度更快

import torch
import numpy as np
list1 =[
    [1,2,3,4,5],
    [6,7,8,9,10],
    [11,12,13,14,15]
]
print(list1)
array1=np.array(list1) #转化为矩阵
print(array1)
tensor1=torch.tensor(list1) #转化为张量
print(tensor1)
print(tensor1.shape)

结果
在这里插入图片描述
这里我们可以看见张量的前面有一个tensor，这个标志就说明了它是张量
张量挂在张量网上，如果要画图需要先取出

张量可以用来求梯度

#求梯度
x=torch.tensor(3.0)  
x.requires_grad_(True) #告诉张量，需要求梯度，否则求梯度时会报错
y=x**2
y.backward()  #求梯度
print(y)
print(x.grad)

# x.grad.zero_()  #清空梯度，否则会累加
y2=x**2
y2.backward()
print(y2)
print(x.grad)

这里没有清空梯度，第二次的梯度结果是错误的
在这里插入图片描述
再来看清空之后的情况

#求梯度
x=torch.tensor(3.0)
x.requires_grad_(True) #告诉张量，需要求梯度
y=x**2
y.backward()  #求梯度
print(y)
print(x.grad)

x.grad.zero_()  #清空梯度，否则会累加
y2=x**2
y2.backward()
print(y2)
print(x.grad)

结果
在这里插入图片描述

6.2张量的创建与求和

#创建张量

tensor1=torch.ones(10,4)  #创建全1张量
print(tensor1)
tensor2=torch.zeros(10,4)  #创建全0张量
print(tensor2)
tensor3=torch.rand(10,4)  #创建随机张量
print(tensor3)
tensor4=torch.normal(mean=10,std=1,size=(10,4))  #创建正太分布张量
print(tensor4)

#求和
tensor1=torch.ones(10,4)
sum1=tensor1.sum(dim=1,keepdim=True)  #dim 1求行和，keepdim=True 保留维度
print(sum1)

print(tensor1.shape)

结果
在这里插入图片描述

6.3引用

我们不会在一个文件里面完成所有工作，可以通过引用来传递数据

from mytensor import tensor1 #引用会把mytensor先运行一遍
from myclass import superman

print(tensor1)

lige=superman('ligekaoyao',28)

结果
在这里插入图片描述

7.总结

总的来说，通过本课学习，了解了python基础的数据结构，基本语句，类与继承，numpy，tensor，torch等

我终于对类与继承这些面向对象编程的内容有所了解

# python # 开发语言 # 深度学习 # 人工智能
Logo
AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

AI Agent编排：复杂工作流的自动化实现

在深入探讨Agent编排之前，我们首先需要明确什么是AI Agent。AI Agent是一个能够感知环境、做出决策并采取行动的自主实体。感知模块：接收和处理环境信息推理/决策模块：基于感知信息进行思考和决策行动模块：执行具体的操作（如调用工具、生成文本）记忆模块：存储历史信息和知识通信模块：与其他Agent或系统进行交互Agent编排（Agent Orchestration）是指对多个Agent的

avatar AI Agent技术社区
cover

90%的人认为RAG和Agent分开做都不难，合在一起就废？可写简历:RAG+Agent合体全链路方案

avatar AI Agent技术社区

看病总是记不住医生说的？从“听完就忘”到“医嘱随时查”的完整解决方案

医疗信息的准确性直接关系到健康甚至生命。在问诊时，患者天然处于“弱势”——时间紧、信息多、情绪乱。过去我们只能靠脑子记、靠手写，结果就是“听时明白，出门就忘”。现在，随着AI语音技术和智能整理技术的成熟，我们已经有了一个非常成熟的解决方案。智在记录这套工具，本质上是一个“医疗信息伴侣”——它帮你把医生的每一句话变成可读、可查、可分享的结构化内容，让你从“害怕遗忘”的焦虑中解放出来。进诊室前打开录音

avatar AI Agent技术社区