深度学习理论基础（一）Python基础篇

youpccc

于 2024-04-16 10:48:39 发布

阅读量230

点赞数 4

分类专栏：程序员文章标签：深度学习 python 人工智能

本文链接：https://blog.csdn.net/youpccc/article/details/137816527

版权

程序员专栏收录该内容

240 篇文章 0 订阅

订阅专栏

print( list_v[ : : 3 ] ) # 从开头到结尾，每 3 个元素采样一次
print( list_v[ 1 : -1 : 2 ] ) # 切除一头一尾后，每 2 个元素采样一次

输出结果：
[‘a’, ‘c’, ‘e’, ‘g’]
[‘a’, ‘d’, ‘g’]
[‘b’, ‘d’, ‘f’]


**●列表for循环**

schools = [‘中南大学’, ‘湖南大学’, ‘三峡大学’, ‘长江大学’]
for school in schools:
message = f"{school}, you are a great school! "
print(message)
print(“I can’t wait to visit you!”)

输出结果：
中南大学, you are a great school!
湖南大学, you are a great school!
三峡大学, you are a great school!
长江大学, you are a great school!
I can’t wait to visit you!


**●列表推导式**  
 只需要看懂即可！

value = [ i**2 for i in [1,2,3,4,5] ]
print(value)

输出结果：
[1, 4, 9, 16, 25]

//--------------------------------
value = [ i**2 for i in [1,2,3,4,5] if i < 4 ]
print(value)

输出结果：
[1, 4, 9]


#### （4）字典


定义：  
   字典是键值对的集合，通过键来访问值。  
   字典使用花括号 {} 定义，每个键值对之间用冒号 : 分隔，键和值之间用逗号 , 分隔。  
 特点：  
   键值对：字典中的数据以键值对形式存储，每个键唯一，值可以是任意类型。  
   可变性：字典是可变的，可以动态地添加、删除或修改键值对。  
   无序性：字典中的键值对没有固定的顺序。  
   示例：`my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}`  
 ●常用操作：  
   访问元素：通过键访问字典中的值。  
   添加新键值对：直接赋值新的键值对。  
   删除键值对：使用 del 语句或者 pop() 方法删除指定的键值对。  
   修改值：通过键直接赋值新的值。


**●创建字典与索引元素**  
   字典可以理解为升级版的列表，每个元素的索引都可以自己定。使用字典索引时，一定要用自定义的索引去索引！索引一般只能是数字或者字符串！

（1）
dict_v = { ‘a’:90, ‘b’:95, ‘c’:100 }
print( dict_v[‘b’] )
输出结果：95

（2）#字典的值可以是任意类型
dict_v = {
0: ‘Chicken’,
1: 123,
2: True,
3: set([1,2,3]),
4: (1,2,3),
5: [1,2,3],
6: {‘a’:1}
}
print ( dict_v[0], dict_v[1], dict_v[2], dict_v[3],dict_v[4], dict_v[5], dict_v[6])
输出结果： Chicken 123 True {1, 2, 3} (1, 2, 3) [1, 2, 3] {‘a’: 1}

（3）#索引只能是数字或者字符串
dict_v = {
‘zero’ : 123,
1: True,
}
print( dict_v[‘zero’], dict_v[1])
输出结果：123 True


**●字典添加元素与删除元素**

原字典

object = {
‘冶金工程’: ‘A+’,
‘矿业工程’: ‘A+’,
‘护理学’: ‘A+’
}

#添加元素
object [‘计算机科学与技术’] = ‘A-’
object [‘控制科学与工程’] = ‘A-’
object [‘临床医学’] = ‘A-’

#删除元素
del object [‘冶金工程’]
del object [‘矿业工程’]


**●for 循环遍历字典**  
   for 循环遍历字典时，既可以遍历索引，也可以遍历值，更可以都遍历。  
 （1）循环键

animals= {‘小鸡’: ‘黄色’, ‘小狗’: ‘黑色’, ‘小猪’: ‘绿色’}

for k in animals.keys():
print( k )

输出结果：
小鸡
小狗
小猪


（2）循环值

animals= {‘小鸡’: ‘黄色’, ‘小狗’: ‘黑色’, ‘小猪’: ‘绿色’}
for v in animals.values():
print( ‘颜色是’ , v )

输出结果：
颜色是黄色
颜色是黑色
颜色是绿色


（3）循环键值对

animals= {‘小鸡’: ‘黄色’, ‘小狗’: ‘黑色’, ‘小猪’: ‘绿色’}
for k, v in animals.items():
print( k, ‘的颜色是’, v )

输出结果：
小鸡的颜色是黄色
小狗的颜色是黑色
小猪的颜色是绿色


#### 2. 输出语句


想在字符串中插入其它变量，可使用“f 字符串”的方法，代码示例如下：

（1）
str1 = “money path”
str2 = “doctor”
str3 = f"You ruined his {str1}. You ruined his {str2}."
print(str3)
输出结果：‘You ruined his Money Path. You ruined his doctor.’

（2）
answer = 0.98
print(f"测试集的准确率为: {answer}")
输出结果：测试集的准确率为: 0.98


  


### 二、函数


#### 1. python函数规范


（1）python使用`def`关键字定义函数。输入/返回参数可以是任意类型的参数。

def 函数名(输入形参)
函数体
return 返回参数


（2）c语言使用花括号 {} 来包裹函数体内的代码块，而python中使用缩进来表示代码块包含关系。  
 （3）python函数可以有多个返回值，而c语言中函数最多只能有一个返回值。  
   实际上，它们返回的是一个元组（tuple）。当函数执行 return 语句时，可以返回多个值，这些值会被自动打包成一个元组。调用者可以使用元组解包来获取函数返回的多个值。

def calculate(x, y):
addition = x + y
subtraction = x - y
multiplication = x * y
division = x / y
return addition, subtraction, multiplication, division

result = calculate(10, 5)
print(result) # Output: (15, 5, 50, 2.0)

元组解包

add_result, sub_result, mul_result, div_result = calculate(10, 5)

print(“Addition:”, add_result) # Output: Addition: 15
print(“Subtraction:”, sub_result) # Output: Subtraction: 5
print(“Multiplication:”, mul_result) # Output: Multiplication: 50
print(“Division:”, div_result) # Output: Division: 2.0


#### 2. 输入任意数量的参数

def menu(*args):
‘’‘菜单’‘’
return args

info = menu(‘荔枝’, ‘油饼’, ‘香精煎鱼’, ‘香翅捞饭’)
print(info)

#输出结果：
‘荔枝’, ‘油饼’, ‘香精煎鱼’, ‘香翅捞饭’


#### 3. 输入参数的默认值

def my_evaluate2(college, level=‘带专’):
message = f"{college}, 你是一所不错的{level}!"
return message

info=my_evaluate2(‘某1大学’)
info2=my_evaluate2(‘某2大学’,‘大学’)

print(info) #输出：‘某1大学，你是一所不错的带专！’
print(info2) #输出：‘某2大学，你是一所不错的大学！’


#### 4. 主函数


  c语言中，一个完整的工程代码只能有一个主函数。而在python工程中，每个.py文件都可以有一个主函数。  
   当然我们也可以不通过main函数来执行函数，将函数放在行首即可执行。但是为了代码的阅读性好，我们通常使用main函数来进行执行函数如下：

if name == ‘__main__’:
执行函数1
执行函数2
执行函数3


  


### 三、类


python中类和c++中的类大致相同，但是也有一些地方有所区别。


#### 1. 类的特殊方法


  一个类中有很多特殊方法，特殊方法前后均有两个下划线，如\_\_函数名\_\_，特殊方法的函数名是固定的。  
   一个类包含一个\_\_init\_\_方法 + 很多自定义方法，每一个类中都必须包含\_\_init\_\_方法。

class Counter:
def __init__(self,num1,num2): #特殊方法
‘’’ a 和 b 公共变量，也是 self 的属性’‘’
self.a = num1 # 公共变量 a 是 self 的属性
self.b = num2 # 公共变量 b 是 self 的属性

def add(self):   # 自定义的加法方法（普通方法）
	return self.a + self.b
def sub(self):   
	return self.a - self.b


⚫ 函数内部的变量与外部是在两个空间，为了使自定义方法能在类里互通，需要一个 self 作为舰船，将需要互通的变量作为 self 的属性进行传递；因此，特殊方法\_\_init\_\_旨在使用舰船 self 来承载公共变量 a 和 b。  
 ⚫ \_\_init\_\_特殊方法和自定义方法后的括号就只需要写舰船 self 即可操作使用self属性的变量。


#### 2. 类的创建与访问

class Counter:
def __init__(self, num1, num2): # 特殊方法
‘’’ a 和 b 公共变量，也是 self 的属性’‘’
self.a = num1 # 公共变量 a 是 self 的属性
self.b = num2 # 公共变量 b 是 self 的属性

def add(self):  # 自定义的加法方法
    return self.a + self.b

def sub(self):
    return self.a - self.b

if name == ‘__main__’:
object= Counter(3, 8) #类的实例化创建
number= object.add() #访问类的方法
print(number)


#### 3. 类的继承


继承：在原有类（父类）的基础上，新增一些方法，形成一个新的类（子类）。  
 （1）创建子类：如 class 类名(父类名) :  
   子类在继承父类时，如果父类有\_\_init\_\_()构造函数，通常建议在子类中使用`super().__init__()`来确保父类的构造函数被正确地调用，使得父类中的变量被正确的初始化。

class Counter: ‘’‘父类’‘’
def __init__(self, a, b):
self.a = a
self.b = b
def add(self):
return self.a + self.b
def sub(self):
return self.a - self.b

class Counter2(Counter): “”“子类”“”
def __init__(self, num1, num2):
super().__init__(num1, num2)
def mul(self):
return self.a * self.b
def div(self):
return self.a / self.b

test = Counter2(3,4)
print( test.sub() ) # 调用父类的方法
print( test.mul() ) # 调用自己的方法


（2）多重继承  
   尽管多重继承提供了灵活性，但过度使用多重继承可能会导致代码难以理解和维护。因此，在设计类时，应该考虑使用单一继承或者组合（Composition）来替代多重继承，以尽量简化类的结构和关系。

class Base1:
def method1(self):
print(“Method 1 from Base1”)

class Base2:
def method2(self):
print(“Method 2 from Base2”)

class Child(Base1, Base2):
pass

创建子类对象

obj = Child()

调用继承的方法

obj.method1() # Output: Method 1 from Base1
obj.method2() # Output: Method 2 from Base2


## Ⅱ：工程基础


### 一、tqdm进度条类


  可以在任何for…in语句前加入tqdm()，进行进度条显示。tqdm()可以传入参数，这里我们只介绍常传入的三个参数：iterable, desc, total。  
 terable:是一个可迭代对象。  
 desc：进度条前的描述性信息（进度条名称）。  
 total：可迭代对象的长度。


1. 简单使用举例如下：

from tqdm import tqdm
import time

items = range(10)
for item in tqdm(items, desc=“Test”, total=len(items)):
time.sleep(1) #延时1s


![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/90435501367b447ca0b12dd0a9866d46.png)


2. 训练时使用tqdm

import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision import datasets
import matplotlib.pyplot as plt
import argparse
from tqdm import tqdm
import time

def train2_net():
epochs = 50 # 训练次数
“”“损失函数的选择”“”
loss_fn = nn.CrossEntropyLoss() # 自带softmax 激活函数
“”“优化算法的选择”“”
learning_rate = 0.01 # 设置学习率
optimizer = torch.optim.SGD(
model.parameters(),
lr=learning_rate,
momentum=0.5
)
losses = [] # 记录损失函数变化的列表

for epoch in tqdm(range(epochs)):
    loop = tqdm(train_loader, desc=f"Epoch: [{epoch}/{epochs}]", total=len(train_loader))
    for i, (x, y) in enumerate(loop):
        x, y = x.to('cuda:0'), y.to('cuda:0')
        output = model(x)
        optimizer.zero\_grad()
        loss = loss\_fn(output, y)
        losses.append(loss.item())  # 记录损失函数的变化
        loss.backward()
        optimizer.step()
Fig = plt.figure()
plt.plot(range(len(losses)), losses)
plt.show()

if name == ‘__main__’:
“”“批次加载器”“”
“”“这里默认准备好了train_Data和test_Data”“”
train_loader = DataLoader(train_Data, shuffle=True, batch_size=64)
test_loader = DataLoader(test_Data, shuffle=False, batch_size=64)

model = DNN().to('cuda:0')
train\_net()


### 二、调用其他文件函数


   在一个文件中要使用另一个文件里的函数。  
   在user2.py文件中使用user1.py的函数或者变量，只需要在user2.py文件中使用`from user1 import *`即可。这句代码意思是导入user1中的所有东西。


user1.py


 **自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。**

**深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**

**因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。**

![img](https://img-blog.csdnimg.cn/img_convert/411de381fcb2d8d9236c24d86fd37660.png)

![img](https://img-blog.csdnimg.cn/img_convert/654fee19bcbe1095d69fdb8474331f18.png)

![img](https://img-blog.csdnimg.cn/img_convert/4c46368b7ba7a9b457c966518062e486.png)

![img](https://img-blog.csdnimg.cn/img_convert/be5a14952361001b84f79d98e6245998.png)

![img](https://img-blog.csdnimg.cn/img_convert/6c361282296f86381401c05e862fe4e9.png)

![img](https://img-blog.csdnimg.cn/img_convert/9f49b566129f47b8a67243c1008edf79.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！**

**由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**

**如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注Python）**

链图片转存中...(img-rrBwTnkW-1713235707834)]

[外链图片转存中...(img-SbHMyNqI-1713235707835)]

[外链图片转存中...(img-Eh5AZH3t-1713235707835)]

[外链图片转存中...(img-dQs3k3Tj-1713235707836)]

![img](https://img-blog.csdnimg.cn/img_convert/6c361282296f86381401c05e862fe4e9.png)

![img](https://img-blog.csdnimg.cn/img_convert/9f49b566129f47b8a67243c1008edf79.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！**

**由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新**

**如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注Python）**

<img src="https://img-community.csdnimg.cn/images/fd6ebf0d450a4dbea7428752dc7ffd34.jpg" alt="img" style="zoom:50%;" />

youpccc

关注

4
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
深度学习理论基础（一）Python基础篇

print( list_v[ : : 3 ] ) # 从开头到结尾，每 3 个元素采样一次print( list_v[ 1 : -1 : 2 ] ) # 切除一头一尾后，每 2 个元素采样一次输出结果：schools = [‘中南大学’, ‘湖南大学’, ‘三峡大学’, ‘长江大学’]”)输出结果：中南大学, you are a great school!湖南大学, you are a great school!三峡大学, you are a great school。
复制链接

扫一扫