python函数编程——函数简介
引用
一说到函数可能你想到的就是初中学得y=f(x)，那么恭喜你还是那个纯真的少年。我曾今也是少年，如今我已经长大了，那么我让我给你叨叨我这个大人学的函数是什么。现在的大人每天都要在不同地方重复使用一样工具，我们只要需要它就可以反复的使用(有电啊，有网啊)，便捷我们的生活。那么python中的函数也起到了这样的作用，那它到底是什么样子的呢？
一、基本定义
1、函数是什么
函数这一说法来源于数学，但是python中的函数和数学中的函数还是有很大区别的。
定义：python中的函数是指组织好的、可重复使用的、用来实现单一或相关联功能的代码段。通过一个函数名封装起来，若想执行这个函数，只需要调用函数名。
优点：减少代码的重复量，使代码看起来更简洁，易修改等。
2、语法定义
def 函数名(参数1, 参数2):
"""函数的注释(说明书)"""
函数体代码(函数的功能实现)
return 返回值
1.def：定义函数的关键字
2.函数名：函数名类似于变量名，指代函数体的代码，做到知名其意
3.括号：定义函数函数名后面一定要写括号
4.参数：用于接受外界传递给函数体代码内部的数据(给函数传递数据)，参数个数可以是一个或者多个或不写
5.函数注释：介绍函数的功能和具体用法，类似我们的说明书
6.函数体代码：整个函数的主心骨，存放逻辑代码实现函数的功能
7.return：执行函数后返回的值
3、函数调用
- 函数在调用时一定要注意必须要先定义函数才可以调用函数方法。
- 函数在定义阶段只检测函数体代码的语法，不执行函数体整体得到吗，只有在函数被调用时才会真正的执行函数体代码
- 函数名绑定的是一块内存地址，里面存放了函数体代码。调用函数才能运行函数体代码。
def func():
print('from func, hello')
name = 'jason'
func = name
print(func) # jason
def func1():
print('from func, hello')
name1 = 'jason'
name1 = func1
print(name1) # <function func at 0x0000023AAF192EA0>
func1() # from func, hello
name1() # from func, hello
- 函数名加括号执行优先级最高(定义阶段除外)
二、函数的分类
1、内置函数
解释器已经含有的含义，用户可以直接调用，查看可点击关键字按住Ctrl+鼠标左键点击了解内置函数的方法。
内置函数和数据类型的内置方法有所不同，内置函数可直接调用，但是数据类型的内置方法必须要使用 “数据类型所定义的变量名或数据值 + . + 内置方法” 才可以调用。理解为数据类型所拥有的特殊方法。
2、自定义函数
2.1空函数
函数体代码使用pass或…顶替，函数体没有任何功能，主要用于前期项目的搭建框架，提示主要功能，用空函数快速罗列程序中大致的功能，让整体框架清晰。后期想要补功能时可随时添加。
def func():
pass
# 类似于前期基础搭建框架
cmd = input('please your cmd: ')
if cmd == '1':
print('功能1')
elif cmd == '2':
print('功能2')
elif cmd == '3':
print('功能3')
2.2无参函数
函数定义阶段括号内没有参数
def func(): # 括号内没有参数
print('from func, hello')
2.3有参函数
函数定义阶段括号内有参数，类似于变量名。调用有参函数括号内也必须要传入参数。
def func(a, b):
print('from func, hello')
func() # 报错，必须要有两个数据值
func(1, 2) # 任意类型的数据值都可以
func([1, 2], 'jason')
name = 'orange'
func({'jason': 18}, name) # # 可以是变量名，只要变量名绑定数据值就可以
'''有参函数调用需要函数名加括号必须要给数据值'''
三、函数的返回值
函数的外部的代码想要获取函数执行的结果，就可以在函数里用return语句把结果返回。返回值就是调用函数之后产生的结果，可有可无。
函数返回值的方式是固定的，获取返回值：变量名 = 函数()。有返回值则获取没有返回None。
1.函数体代码没有return关键字，默认返回None
def func():
print('from func, hello')
# 先执行函数体代码，然后将函数执行之后的返回值赋值给变量名res
res = func() # from func, hello
print(res) # None
2.函数体代码有return关键字但是后面没有任何代码，返回None
def func():
print('from func, hello')
return
res = func() # from func, hello
print(res) # None
3.函数体代码有return关键字，return后面若有数据值则返回数据值；若有变量名找到变量名绑定的数据值返回
def func():
print('from func, hello')
return 222
res = func() # from func, hello
print(res) # 222
def func():
print('from func, hello')
name = 'jason'
return name
res = func() # from func, hello
print(res) # jason
4.函数体代码有return关键字，return后面若有多个数据值无论是什么形式以逗号隔开默认返回元组形式；若想返回其它类型的形式，需要自定义return后面数据值的类型
def func():
print('from func, hello')
name = 'jason'
return 1, 2, 3, 4
res = func() # from func, hello
print(res) # (1, 2, 3, 4)
def func():
print('from func, hello')
return [1, 2, 3, 4]
res = func() # from func, hello
print(res) # [1, 2, 3, 4]
def func():
print('from func, hello')
return [1, 2, 3, 4], {'name': 'jason'}, 18
res = func() # from func, hello
print(res) # ([1, 2, 3, 4], {'name': 'jason'}, 18)
5.函数体代码有关键字，遇到return关键字会返回结果后结束函数体代码的运行。相当于循环语句中的break关键字。
def func():
print('upper')
return 222
print('lower') # 不会执行，相当于循环语句里面的break
func() # upper
四、函数的参数
1、参数
1.2形式参数(形参)
形参只在函数内部有效，相当于是变量名会临时参与实参进行绑定，函数调用结束则不再使用形参(函数结束运行解除动态绑定)。
1.2实际参数(实参)
函数在调用阶段括号内填写的参数，可以是变量、常量、表达式、函数等，无论实参是什么类型，进行函数调用时，必须有确定的值把值传给形参。
def func(a): # a形参
print(a)
# 函数运行时与a绑定，当运行结束立即解除绑定，等待下一次绑定
func(111) # 111 111实参
func(222) # 222
func(333) # 333
func('jason') # jason
2、位置参数
2.1位置形参
在函数定义阶段括号内从左向右依次填写的变量名称。
2.2位置实参
在函数调用阶段括号内从左向右依次填写的数据值或绑定数据值的变量名。
def func(a, b, c):
print(a)
print(b)
print(c)
func(1, 2, 3) # 1 2 3
name = 'jason'
func(name, 1, 2) # jason 1 2
'''位置形参传值的实参是必须要与形参的个数要一一对应(个数一致)，不能多也不能少'''
def func(a, b, c):
print(a)
print(b)
print(c)
func(111) # 报错，提示少了两个实参
func(111, 222) # 报错，提示少了一个实参
func(111, 222, 333) # 111 222 333
func(111, 222, 333, 444) # 报错，提示多了一个实参
3、关键字参数
关键字实参，给函数传值时指定参数名。指调用阶段括号内什么等于等于什么的形式传值。注意位置实参必须在关键字参数前面；无论是形参还是实参，遵循简单的在前，复杂的在后；同一个形参在同次调用中只能传一次值。
'''位置实参必须在关键字实参前面'''
def func(a, b):
print(a, b)
func(a=1, b=2) # 1 2
func(b=1, a=2) # 2 1
# 2是位置参数会给2，两个值都给了2报错
func(b=1, 2) # （b接受1，理论上a给2）报错
# 2会按照位置实参形式传给a,b按照关键字参数传给b
func(2, b=1) # 2 1，不报错
'''无论是形参还是实参，遵循简单的在前，复杂的在后'''
def func(a, b):
print(a, b)
# 报错，222会按照位置形参给a,a又再次按照关键字参数传值111给a
func(222, a=111)
# 报错，遵循简单在前，复杂在后
def get_info(name, age=18, gender):
pass
# 不报错，遵循简单在前，复杂在后
def get_info(name, age=18, gender='male'):
pass
'''同一个形参在同一次调用时不能接收多个实参，一个形参在调用时只能赋值一次'''
def func(a, b):
print(a, b)
# 报错，222会按照位置形参给a,a又再次按照关键字参数传值111给a
func(222, a=111)
4、默认值参数
默认值形参，在函数定义阶段括号内以什么等于等吗的形式填写的形参
出现在形参中
在函数定义阶段就已经给一下形参赋值
后续如果不传值则使用默认
后续传值则使用直接传入的
默认参数的出现也打破了形参与实参之间个数一致的情况
默认参数必须定义在位置参数的后面
def register(name, age, gender='male'):
print(f'''
--------------info----------------
name:{name}
age:{age}
gender:{gender}
''')
# 默认值，自定义阶段绑定值后，后续调用不用传值
register('jason', 28)
register('oscar', 16)
# 如果自己传值则传入写入的值，不然就用自己的值。
register('jenny', 18, 'female')
# 报错，遵循简单在前，复杂在后
def get_info(name, age=18, gender):
pass
# 不报错，遵循简单在前，复杂在后
def get_info(name, age=18, gender='male'):
pass
''''''
5、可变长参数
在函数定义时不确定想传入多少个参数时，可使用可变长长数
def func(*args): # *args不是变量名，不是形参
print(args)
'''*在形参中的作用：接收多余的位置参数并以元组的形式赋值给*后面的变量名'''
# 若有实参先将实参给形参，形参不够了(多余的实参)会被*接收组织成元组给后面的变量名args，必须是位置参数
def func(*args):
print(args)
func() # ()
func(1) # (1,)
func(1, 2) # (1, 2)
func(1, 2, 3, 4, 5, 6, 7, 8) # (1, 2, 3, 4, 5, 6, 7, 8)
def func(a, *args):
print(args)
# func() # 报错，因为a需要一个实参
func(1) # ()
func(1, 2) # (2,)
func(1, 2, 3, 4, 5, 6, 7, 8) # (2, 3, 4, 5, 6, 7, 8)
def func(**kwargs):
print(kwargs)
'''**在形参中的作用，接收多余的关键字参数并以字典的形式赋值给**后面的变量名'''
# 接收多余的关键字参数
def func(**kwargs):
print(kwargs)
func() # {}
func(name='jason') # {'name': 'jason'}
func(name='jason', age=18) # {'name': 'jason', 'age': 18}
func(name='jason', age=18, hobby='read') # {'name': 'jason', 'age': 18, 'hobby': 'read'}
# a只能接收位置参数，kwargs只能接收关键字参数
def func(a, **kwargs):
print(kwargs)
# func() # 报错
func(a=1) # {}
func(a=1, b=2) # {'b': 2}
func(a=1, name='jason') # {'name': 'jason'}
func(1, name='jason') # {'name': 'jason'}
func(1, 2, 3, name='jason') # 报错，只有一个位置形参，不能传多个位置实参，kwargs只能接收关键字参数
# func(name='jason', age='18') # 报错,a只能传位置参数
原创文章，作者：wure，如若转载，请注明出处：https://blog.ytso.com/272579.html