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

print(c,b,a)
输出：3 2 1

元组拆分法——极速交换变量值

a,b = 1,2
b,a = a,b
print(a,b)
输出：2 1

元组拆分法——只要前两个答案

values = 98, 99, 94, 94, 90, 92
a, b, *rest = values
a, b, rest
输出：(98, 99, [94, 94, 90, 92])

#### （3）列表


定义：  
   列表是Python中最常用的数据结构之一，是有序的可变序列。  
   列表使用方括号 [] 定义，其中的元素通过逗号分隔。  
 特点：  
   可变性：列表是可变的，即你可以修改列表中的元素、添加新元素或删除元素。  
   有序性：列表中的元素按照它们的插入顺序存储，并且可以通过索引访问。  
   可包含任意类型的数据：列表中的元素可以是不同类型的数据，包括其他列表。  
   示例：`my_list = [1, 2, 3, 'a', 'b', 'c']`  
 常用操作：  
   访问列表元素：通过索引访问列表中的元素，索引从0开始。  
   切片：可以通过切片操作获取列表的子列表。  
   添加元素：使用 append()、insert() 或者使用加号 + 添加新元素。  
   删除元素：使用 del 语句、remove() 方法或者 pop() 方法删除元素。  
   修改元素：通过索引直接赋值。


**●列表的切片操作**  
 列表的访问操作如同数组的访问一样，如list\_v[0]就是 ’a‘。

list_v = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’]
print( list_v )
print( list_v[ 1 : 4 ] ) # 从索引[1]开始，切到索引[4]之前。包含索引[1]，但不包括索引[4]
print( list_v[ 1 : ] ) # 从索引[1]开始，切到结尾
print( list_v[ : 4 ] ) # 从列表开头开始，切到索引[4]之前，不包括索引[4]

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

print( list_v[ 2 : -2 ] ) # 从索引[2]开始，并切除列表结尾两个元素
print( list_v[ : -2 ] ) # 切除结尾两个元素

输出结果：
[‘c’]
[‘a’, ‘b’, ‘c’]
#--------------------------------------------------

list_v = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’]
print( list_v[ : : 2 ] ) # 从开头到结尾，每 2 个元素采样一次
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
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

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

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

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

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

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

图片转存中…(img-QNkxjwdY-1713799624269)]

[外链图片转存中…(img-kcr2d51E-1713799624270)]

[外链图片转存中…(img-8ilKSaId-1713799624271)]

[外链图片转存中…(img-AlZtrPvp-1713799624271)]

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

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

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