函数

简介

• 函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

函数的定义与调用

函数定义

• 函数的使用必须遵循’先定义，后调用’的原则。函数的定义就相当于事先将函数体代码保存起来，然后将内存地址赋值给函数名，函数名就是对这段代码的引用，这和变量的定义是相似的。没有事先定义函数而直接调用，就相当于在引用一个不存在的’变量名’。

def foo():
    print('in the foo')
    bar()

语法结构

def 函数名(参数1,参数2):
    '''函数注释'''
    函数体代码
    return 返回值

• def：是定义函数的关键字。
• 函数名：与变量名的命名一致，尽量做到见面知意。
• 括号 ：在定义函数的时候函数名后面必须跟括号，任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 参数：定义函数括号内可以写参数(个数不固定) 也可以不写参数，用于接收外界传递给函数体代码内部的数据。
• 冒号：括号后要加冒号，然后在下一行开始缩进编写函数体的代码；
• 函数注释：类似于说明书 用于介绍函数的主题功能和具体用法。
• 函数体代码：整个函数最核心的区域(逻辑代码)。
• return：结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。用于查看使用函数之后有没有相应的反馈。

函数调用

• 定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。
• 函数调用方式：
  1. 语句形式
  2. 表达式形式
  3. 函数调用作为参数的形式

# 1、语句形式：
foo()

# 2、表达式形式：
m=my_min(1,2) #将调用函数的返回值赋值给x
n=10*my_min(1,2) #将调用函数的返回值乘以10的结果赋值给n

# 3、函数调用作为参数的形式：
# my_min（2，3）作为函数my_min的第二个参数，实现了取1,2,3中的较小者赋值给m
m=my_min(1，my_min（2，3）)

注意

1. 函数必须先定义后使用（定义的函数的代码必须要在调用函数的代码之前先运行）
2. 定义函数使用def关键字，调用函数使用函数名加括号（可能需要添加额外的参数）
3. 函数在定义阶段只检测函数体代码语法，不执行函数体代码（只有在调用阶段才会真正的执行函数体代码）
4. 函数名绑定的是一块内存地址，里面存放了函数体代码，要想运行代码就需要调用函数（函数名+()）
5. 函数名加括号执行优先级最高

函数分类

内置函数

• 内置函数：解释器提前定义好的函数，用户可以直接调用
• 注意：内置函数可以直接调用，但是数据类型的内置方法（函数）必须使用数据类型点的方式才能调用，相当于是数据类型独有的一些内置方法。

自定义函数

空函数

• 空函数：函数体代码使用pass顶替，暂时没有什么功能
• 运用：前期的项目搭建，提示主要功能

def auth_user():
    """user authentication function"""
    pass

def download_file():
    """download file function"""
    pass

def upload_file():
    """upload file function"""
    pass

def ls():
    """list contents function"""
    pass

def cd():
    """change directory"""
    pass

无参函数

• 无参函数：函数定义阶段括号内没有填写参数
• 注意：无参函数直接函数名加括号即可调用

def func():
    print('from func')

有参函数

• 有参函数：函数定义阶段括号内填写参数
• 注意：有参函数调用需要函数名加括号并给数据值

def func(a, b):
    print('from func')

函数的返回值

• 返回值：调用函数之后产生的结果，可有可无，
• 获取函数返回值的方式是固定的：变量名 = 函数()
• 返回值有则获取，没有默认接收None

实例

1. 函数体代码没有return关键字:默认返回None

def func():
    print('from func')
res = func()
print(res)  # None

# 结果：
from func
None

2. 函数体代码有return关键字:后面不写，也返回None

def func():
	print('from func')
	return
res = func()
print(res) # None

# 结果：
from func
None

3. 函数体代码有return关键字:return后面写什么就返回什么(如果是数据值则直接返回 如果是变量则需要找到对应的数据值返回)

def func():
    print('from func')
    return 666
res = func()
print(res) # 666
# 结果：
from func
666

def func():
    print('from func')
    name = 'jason'
    return name
res = func()
print(res)  # jason
# 结果：
from func
jason

4. 函数体代码有return关键字并且后面写了多个数据值(名字) 逗号隔开:默认情况下回自动组织成元组返回

def func():
    return 1, 2, 3, 4
res = func()
print(res)  # (1, 2, 3, 4)  # 结果：(1, 2, 3, 4)


def func():
    return [1, 2, 3, 4]
res = func()
print(res)  # [1, 2, 3, 4]  # 结果：[1, 2, 3, 4]


def func():
    return [1, 2, 3, 4], {'name': 'jason'}, 123
res = func()
print(res)  # [1, 2, 3, 4]  # 结果：([1, 2, 3, 4], {'name': 'jason'}, 123)

5. 函数体代码遇到return关键字会立刻结束函数体代码的运行

def func():
    print('我在上面')
    return 123
    print('我在下面')
func() # 我在上面

参数

形式参数/实际参数

• 形式参数：简称“形参”，函数在定义阶段括号内填写的参数，形参本质就是一个变量名，用来接收外部传来的值。
• 实际参数：简称“实参”，函数在调用阶段括号内填写的参数，值可以是常量、变量、表达式或三者的组合。

# 1.实参是常量
res=my_min(1,2)

# 2.实参是变量
a=1
b=2
res=my_min(a,b)

# 3.实参是表达式
res=my_min(10*2,10*my_min(3,4))

# 4.实参可以是常量、变量、表达式的任意组合
a=2
my_min(1,a,10*my_min(3,4))

位置参数

• 位置形参：在函数定义阶段括号内从左往右依次填写的变量名称

def register(name,age,sex): # 定义位置形参：name，age，sex，三者都必须被传值
	print('Name:%s Age:%s Sex:%s' %(name,age,sex))

register() # TypeError：缺少3个位置参数

• 位置实参：在函数定义阶段括号内从左往右依次填写的数据值

register('lili',18,'male') # 对应关系为：name=’lili’,age=18,sex=’male’e

• 注意：
  1. 实参可以是数据值也可以是绑定了数据值的变量名
  2. 给位置形参传值时必须个数一致，多一个少一个都不行

关键字参数

• 关键字实参：在函数调用阶段括号内以什么等于什么的形式传值
• 注意：
  1. 指名道姓的给形参传值（打破了位置的限制）
  2. 位置实参必须在关键字实参前面（无论形参还是实参，都遵循短的（简单）的在前面，长的（复杂的）在后面）
  3. 同一个形参在一次调用中只能传一次值

 func(a, b):
    print(a, b)

func(1, 2) # 1 2
func(b=1, a=2) # 2 1
func(b=1, 2) # 报错 无论形参还是实参，都遵循短的（简单）的在前面，长的（复杂的）在后面
func(2, b=1) # 2 1
func(666, a=1) # 报错 无论形参还是实参，都遵循短的（简单）的在前面，长的（复杂的）在后面

默认值参数

• 默认值参数：在函数定义阶段括号内以什么等于什么的形式填写的形参
• 注意：
  1. 默认参数必须在位置参数之后
  2. 在函数定义阶段就给形参绑定值，后续调用阶段就可以不传
  3. 调用阶段不传值就使用默认的，传了就用传了的
  4. 遵循短的（简单）的在前面，长的（复杂的）在后面

def register(name, age, gender='male'):
    print(f"""
    -------------info-----------
    name:{name}
    age:{age}
    gender:{gender}
    ----------------------------
    """)
register('jason', 18)
register('oscar', 28)
register('jerry', 38)
register('lili', 18, 'female')

可变长参数

• 可变长形参：可以打破形参与实参的个数限制，随意传值

def func(*x):
    print(x)
# * 在形参中的作用,接收多余的位置参数并组织成元组的形式赋值给*后面的变量名

def func(**y):
    print(y)
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'}
# **在形参中的作用,接收多余的关键字参数并组织成字典的形式赋值给**后面的变量名