当前位置:   article > 正文

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

python 函数规范
  1. 注释
    使用# 号进行单行注释,或者''' '''""" """进行批量注释。
    快速注释方法:选中注释的内容按下Ctrl+/
 # 单行注释
''' 批量注释 '''
""" 批量注释 """

  • 1
  • 2
  • 3
  • 4
  1. Python 里换行符(回车)可以替代分号(;),所以一般不出现分号;
  2. Python 是动态输入类型的语言,像 Matlab 一样,变量类型是动态推断的;静态类型的 C 语言须声明变量类型,如 int a = 1,而 Python 只需要 a = 1;
  3. 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开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。

img

img

img

img

img

img

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

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

如果你觉得这些内容对你有帮助,可以扫码获取!!!(备注:Python)

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

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

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

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

img

img

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

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

如果你觉得这些内容对你有帮助,可以扫码获取!!!(备注:Python)

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/897128
推荐阅读
相关标签
  

闽ICP备14008679号