深度学习理论基础（一）Python基础篇(1)_python 函数规范

1. 注释
   使用# 号进行单行注释，或者''' '''或""" """进行批量注释。
   快速注释方法：选中注释的内容按下Ctrl+/。

 # 单行注释
''' 批量注释 '''
""" 批量注释 """

1
2
3
4

2. Python 里换行符（回车）可以替代分号（;），所以一般不出现分号；
3. Python 是动态输入类型的语言，像 Matlab 一样，变量类型是动态推断的；静态类型的 C 语言须声明变量类型，如 int a = 1，而 Python 只需要 a = 1；
4. Python中代码包含关系使用缩进来表示，而不是使用括号来进行包含。

一、变量类型与输出语句

1. 变量类型

基本变量类型：字符串、数字、布尔型；
高级变量类型：集合、元组、列表、字典。

#字符串：    str_v = "a real man" 
#数字：      num_v = 415411
#布尔：      bool_v = True
#集合：      set_v = {1, 2, 3, 1}
#元组：      tuple_v = (1, 2, 3)
#列表：      list_v = [1, 2, 3]
#字典：      dict_v = {'a':1, 'b':2 , 'c':3 }

1
2
3
4
5
6
7
8

这里我们不再讲述基本变量类型，因为和c语言的变量类型没任何区别。主要讲述高级变量类型。

（1）集合（使用较少）

定义：
  集合是无序且元素唯一的集合数据类型。
  集合使用大括号 {} 定义，其中的元素通过逗号分隔。
特点：
  唯一性：集合中的元素是唯一的，不会出现重复元素。
  无序性：集合中的元素无序存储，因此不能通过索引访问。
  高效性：集合提供了高效的成员检测操作。
  示例：my_set = {1, 2, 3, 'a', 'b', 'c'}
●常用操作：
  添加元素：使用 add() 方法或者 update() 方法添加新元素。
  删除元素：使用 remove() 或者 discard() 方法删除元素。
  集合运算：包括并集、交集、差集等。

（2）元组

定义：
  元组是有序的不可变序列。
  元组使用圆括号 () 定义，其中的元素通过逗号分隔。
特点：
  不可变性：元组一旦创建，其元素不可更改，删除或添加。
  有序性：元组中的元素按照它们的插入顺序存储，并且可以通过索引访问。
  示例：my_tuple = (1, 2, 'a', 'b')
常用操作：
  访问元组元素：通过索引访问元组中的元素，索引从0开始。
  切片：可以通过切片操作获取元组的子元组。
  元组拆包：将元组的元素解包给多个变量。
  不可变性：元组的元素不能被修改、删除或添加。

●元组的创建： 一种是规范括号法，一种是省略括号法。
规范的括号法：

(1, 2, 3)
输出：(1, 2, 3)

1
2
3

省略括号法（核心）：

1, 2, 3
输出： (1, 2, 3)

1
2
3

●元组的拆分解包：
元组拆分法——极速创建新变量

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

1
2
3
4

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

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

1
2
3
4
5

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

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

1
2
3
4
5

（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']

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

●列表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!

1
2
3
4
5
6
7
8
9
10
11
12
13

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

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]

1
2
3
4
5
6
7
8
9
10
11
12
13

（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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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

# 原字典
object = {
	'冶金工程': 'A+',
	'矿业工程': 'A+',
	'护理学': 'A+'
}

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


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


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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

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

for k in animals.keys():
	print( k )
	
输出结果：
       小鸡
       小狗
       小猪

1
2
3
4
5
6
7
8
9
10

（2）循环值

animals= {'小鸡': '黄色', '小狗': '黑色', '小猪': '绿色'}
for v in animals.values():
	print( '颜色是' , v )
	
输出结果：
	颜色是 黄色
	颜色是 黑色
	颜色是 绿色

1
2
3
4
5
6
7
8
9

（3）循环键值对

animals= {'小鸡': '黄色', '小狗': '黑色', '小猪': '绿色'}
for k, v in animals.items():
	print( k, '的颜色是', v )
	
输出结果：
	小鸡的颜色是黄色
	小狗的颜色是黑色
	小猪的颜色是绿色

1
2
3
4
5
6
7
8
9

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
2
3
4
5
6
7
8
9
10
11
12

二、函数

1. python函数规范

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

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

1
2
3
4

（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


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2. 输入任意数量的参数

def menu(\*args):
'''菜单'''
	return args

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

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

1
2
3
4
5
6
7
8
9
10

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大学，你是一所不错的大学！'


1
2
3
4
5
6
7
8
9
10
11

4. 主函数

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

if __name__ == '\_\_main\_\_':
	执行函数1
	执行函数2
	执行函数3

1
2
3
4
5

三、类

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

1
2
3
4
5
6
7
8
9
10
11

⚫ 函数内部的变量与外部是在两个空间，为了使自定义方法能在类里互通，需要一个 self 作为舰船，将需要互通的变量作为 self 的属性进行传递；因此，特殊方法__init__旨在使用舰船 self 来承载公共变量 a 和 b。
⚫ __init__特殊方法和自定义方法后的括号就只需要写舰船 self 即可操作使用self属性的变量。
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

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

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

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

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

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

图片转存中…(img-CMMzzXkX-1713799589350)]

[外链图片转存中…(img-zkf3D8uJ-1713799589350)]

[外链图片转存中…(img-SqVnDxrB-1713799589351)]

[外链图片转存中…(img-gCFCpW85-1713799589352)]

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

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

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