【Python】函数基础知识

函数简介

用于存储一些可执行的代码，方便代码的调用。

定义函数

• 函数名的命名规范：由数字、字母、下划线组成，不以数字开头。
• 语法：def 函数名 ( 形参 ) : 代码块

def function(形参1, 形参2...形参n):
	code block

调用函数

• 语法：函数名 ( 实参 )

function(实参1, 实参2...实参n)

函数的参数

• 参数可以是任意类型。
• 形参可以设置默认值，并且只能从右往左设置。

def fun(a, b, c=3):
    print(a + b + c)

fun(1, 2)
# ----------输出----------
# 6

参数传递

参数传递就是实参给形参赋值。

• 位置传参：将对应位置的实参赋值给对应位置的形参
• 关键字传参 : 根据参数名进行传递，关键字参数之间的位置可任意，从右往左写起。

def fun(a, b, c):
    print(a + b + c, end='  ')

fun(1, 2, 3)
fun(a=1, c=5, b=6)
fun(1, 4, c=5)
# ----------输出----------
# 6  12  10  

不定长参数

• 不定长参数，就是前面带星号的形参，eg : *parameter & **parameter，分别只能有一个
• *parameter 可以接受所有剩余的、位置传参的实参，并将其存储在元组 parameter 中
  • 若无剩余的、位置传参的实参，则返回空元组
• **parameter 可以接受所有剩余的、关键字传参的实参，并将其存储在字典 parameter 中
  • 字典的 key 是实参名，value 是实参值
  • 若无剩余的、关键字传参的实参，则返回空字典
• 参数顺序：位置传参 - (*parameter) - 关键字传参 - (**parameter)

def fun(a, *b, c, **d):
    print(a, b, c, d)

fun(1, 2, 3, c=4, d=5, e=7)
# ----------输出----------
# 1 (2, 3) 4 {'d': 5, 'e': 7}

参数 ( 序列 ) 的拆包

就是将序列里面的元素拆分开，并分别进行赋值

string = 'Hello World'
firstWord, secondWord = string.split()
print(f'{firstWord} - {secondWord}')
# ----------输出----------
# Hello - World

• 在序列类型的对象前面添加星号 * ，就可以将其元素拆散为一个个单独的值（当然你也可以通过索引获取元素的值）

def fun(a, b, c, *d):
    print(a, b, c, d)
    print(a, b, c, *d)

tuple1 = (1, 2, 3, 4, 5, 6)
fun(*tuple1)
# ----------输出----------
# 1 2 3 (4, 5, 6)
# 1 2 3 4 5 6

• 对于字典，加一个星号时返回拆散后的 key，加两个星号返回拆散后的 value（当然你也可以配合字典的遍历使用）
  • 加两个星号的情况下，形参名必须与字典的 key 一样，就相当于关键字传参嘛

def fun(name, sex, age):
    print(name, sex, age, end=', ')

dict1 = {
    'name': 'superman',
    'sex': 'male',
    'age': 3
}
fun(*dict1)
fun(*dict1.values())
fun(**dict1)
# ----------输出----------
# name sex age, superman male 3, superman male 3, 

注意：单个星号不止可以用于参数的拆包，还可以直接使用于序列的拆包

tuple1 = (1, 2, 3, 4, 5, 6)
dict1 = {
    'name': 'superman',
    'sex': 'male',
    'age': 3
}
print(*tuple1)
print(*dict1)  # 双星号修饰的字典无法直接输出
# ----------输出----------
# 1 2 3 4 5 6
# name sex age

• 双星号 ** 还可以用于字典的合并

dict1 = {'name1': 'superman', 'sex1': 'male'}
dict2 = {'name2': 'superwoman', 'sex2': 'female'}
dict3 = {**dict1, **dict2}
print(dict3)
# ----------输出----------
# {'name1': 'superman', 'sex1': 'male', 'name2': 'superwoman', 'sex2': 'female'}

函数的返回值

• 返回值就是函数执行完后返回的结果，可以是任意类型，当然也可以返回函数了咯
• 用 return 表达式 来返回，执行完 return 语句后，函数结束
• 不需要返回值的话，可以不写 return 语句，或者只写 return，不写返回值

def fun1():
    def fun2():
        return 1
    return fun2

a = fun1()
print(a)
print(a())
# ----------输出----------
# <function fun1.<locals>.fun2 at 0x0000021C41D29950>
# 1

文档字符串

• help ( ) 是 python 的内置函数，用于查询其他函数的用法
• 定义函数时，可以在函数内编写文档字符串，以介绍这个自定义函数

def fun1():
    """
    这里面可以进行函数的介绍
    """
    return 0

help(fun1)
# ----------输出----------
# Help on function fun1 in module __main__:
# fun1()
#     这里面可以进行函数的介绍

作用域

就是变量生效的区域

全局作用域

• 函数外定义的变量，即全局变量，都有全局作用域。从定义时生效，到程序结束时失效。

函数作用域

• 函数内定义的变量，即局部变量，都有函数作用域。从定义时生效，到函数结束时失效。
• 若局部变量与全局变量同名，局部变量会覆盖全局变量
• 如果想在函数内定义全局变量，可在定义时用 globals 声明变量

a = 1

def fun1():
    a = 2
    global b  # 在函数内定义全局变量
    b = 2
    print(f'fun1内的 a = {a}')
    print(f'fun1内的 b = {b}')

print(f'函数外的 a = {a}')
print(f'函数外的 b = {b}')
# ----------输出----------
# fun1内的 a = 2
# fun1内的 b = 2
# 函数外的 a = 1
# 函数外的 b = 2

命名空间

• 其实就是一个字典，用于存储变量及其 value
• locals ( ) 可获取、并返回当前作用域的命名空间

a = 1
dict1 = locals()
print(dict1)
print(a, dict1['a'])
# ----------输出----------
# { ...此处省略一大堆全局作用域自带的变量...'a': 1, 'dict1': {...}}
# 1 1

• 在函数作用域中，globals ( ) 可获取、并返回全局作用域的命名空间

def fun1():
    a = 1
    print(locals())
    dict1 = globals()
    print(dict1.get('a'))  # a 不是全局变量，所以不在全局作用域的命名空间里面
    print(dict1.get('fun1'))

fun1()
# ----------输出----------
# {'a': 1}
# None
# <function fun1 at 0x000001DC46681E18>

函数进阶知识

【Python】函数进阶知识