Python3 函数

一、定义函数

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号圆括号 ()，内容以冒号 : 起始
• 任何传入参数和自变量必须放在圆括号 () 中间，圆括号之间可以用于 定义参数
• 函数的第一行语句可以 选择性 地使用文档字符串—用于 存放函数说明
• 结束函数时，选择性 地返回一个值给调用方，不带表达式的相当于返回 None

# 一般形式
def function_name(parameter_list):
	function_body
	return [expression] 

二、调用函数

• 函数的基本结构完成，可以通过另一个函数 调用执行 ，也可以直接从 Python 3.x 命令提示符执行

# 该实例演示计算面积函数
def area(width, height):
    return width * height


def print_hello(name):
    print("Hello", name)


print_hello("World")
w = 4
h = 5
print("width = %d, height = %d, area = %d" % (w, h, area(w, h)))

-> Hello World
-> width = 4, height = 5, area = 20

三、参数传递

• 在 Python 3.x 中一切都是对象，严格意义上 不能说 值传递还是引用传递，应该说 传不可变对象和传可变对象
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）
• 不可变数据（3 个）：Number（数字）、Tuple（元组）、String（字符串）

# 该实例演示传不可变对象
def ChangeInt( a ):
    a = 10
 
 
b = 2
ChangeInt(b)
print( b )

-> 2

# 该实例演示传可变对象
def changeme(mylist):
    """修改传入的列表"""
    mylist.append([1, 2, 3, 4])
    print("函数内取值: ", mylist)
    return


mylist = [10, 20, 30]
changeme(mylist)
print("函数外取值: ", mylist)

-> 函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
-> 函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

四、参数类型

# 必需参数
# 须以正确的顺序传入函数
# 调用时的数量必须和声明时的一样
def printme(str):
    """打印任何传入的字符串"""
    print(str)
    return


printme("Hello")

-> Hello

# 关键字参数
# 允许函数调用时参数的顺序与声明时不一致
# 因为 Python 解释器能够用参数名匹配参数值
def printinfo(name, age):
    """打印任何传入的字符串"""
    print("名字: ", name)
    print("年龄: ", age)
    return


printinfo(age=70, name="中国")

-> 名字:  中国
-> 年龄:  70

# 默认参数
# 调用函数时，如果没有传递参数，则会使用默认参数
# 默认参数必须放在最后面，否则会报错
def printinfo(name, age=18):
    """打印任何传入的字符串"""
    print("名字: ", name)
    print("年龄: ", age)
    return


printinfo(age=50, name="中国")
print("-" * 24)
printinfo(name="中国")

-> 名字:  中国
-> 年龄:  50
-> ------------------------
-> 名字:  中国
-> 年龄:  18

# 不定长参数
# 一个函数能处理比当初声明时更多的参数
def functionname([formal_args,] *var_args_tuple):
    """函数_文档字符串"""
    function_suite
    return [expression]

# 星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数
def printinfo(arg1, *vartuple):
    """打印任何传入的参数"""
    print("输出: ")
    print(arg1)
    print(vartuple)


printinfo(70, 60, 50)

-> 输出: 
-> 70
-> (60, 50)

# 如果在函数调用时没有指定参数，它就是一个空元组，可以不向函数传递未命名的变量
def printinfo(arg1, *vartuple):
    """打印任何传入的参数"""
    print("输出: ")
    print(arg1)
    for var in vartuple:
        print(var)
    return


printinfo(70, 60, 50)
printinfo(70, (60, 50))

-> 输出: 
-> 70
-> 60
-> 50
-> 输出: 
-> 70
-> (60, 50)

# 不定长参数
# 一个函数能处理比当初声明时更多的参数
def functionname([formal_args,] **var_args_dict):
    """函数_文档字符串"""
    function_suite
    return [expression]

# 星号 ** 的参数会以字典(dictionary)的形式导入，存放所有未命名的变量参数
def printinfo(arg1, **vardict):
    """打印任何传入的参数"""
    print("输出: ")
    print(arg1)
    print(vardict)


printinfo(1, a=2, b=3)

-> 输出: 
-> 1
-> {'a': 2, 'b': 3}

# 如果单独出现星号 * 后的参数必须用关键字传入
>>> def f(a, b, *, c):
...     return a + b + c
... 
>>> f(1, 2, 3)   # 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1, 2, c=3) # 正常
6

五、匿名函数

• lambda 只是一个表达式，函数体比 def 简单很多
• lambda 的主体是 一个表达式 ，而不是一个代码块，仅仅能在 lambda 表达式中封装有限的逻辑进去
• lambda 函数拥有自己的命名空间，且 不能访问 自己参数列表之外或全局命名空间里的参数
• lambda 函数看起来只能写一行，却不等同于 C OR C++ 的内联函数，后者的目的是调用小函数时 不占用 栈内存从而增加运行效率

# 一般形式
# 可以使用关键字参数
# 也可以设定默认参数
lambda [arg1 [,arg2,.....argn]]:expression

# 该实例演示两数相加
sum = lambda arg1, arg2: arg1 + arg2

print("相加后的值为 : ", sum(10, 20))
print("相加后的值为 : ", sum(20, 20))

-> 相加后的值为 :  30
-> 相加后的值为 :  40

六、退出函数

• 选择性地向调用方返回一个表达式，不带参数值返回 None

# 一般形式
# 可以返回多个值，以元组的方式返回
return [expression]

# 该实例演示两数相加
def sum(arg1, arg2):
    """返回2个参数的和"""
    total = arg1 + arg2
    print("函数内：", total)
    return total


total = sum(10, 20)
print("函数外：", total)

-> 函数内： 30
-> 函数外： 30

七、变量作用域

• 程序的变量 并不是 在哪个位置都可以访问的，访问权限 取决于 这个变量是在哪里赋值的
• 变量的作用域 决定 在哪一部分程序可以访问哪个特定的变量名称
  • 四种作用域
    • L （Local） 局部作用域
    • E （Enclosing） 闭包函数外的函数中
    • G （Global） 全局作用域
    • B （Built-in） 内置作用域（内置函数所在模块的范围）
  • 以 L –> E –> G –> B 的规则查找，
  • 即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找

g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    
    def inner():
        i_count = 2  # 局部作用域

# 该实例演示访问全局变量和局部变量
total = 0  # 这是一个全局变量


def sum(arg1, arg2):
    """返回2个参数的和"""
    total = arg1 + arg2  # total在这里是局部变量.
    print("函数内是局部变量：", total)
    return total


sum(10, 20)
print("函数外是全局变量：", total)

-> 函数内是局部变量： 30
-> 函数外是全局变量： 0

# 当内部作用域想修改外部作用域的变量时，就要用到 global 和 nonlocal 关键字
# 该实例演示修改全局变量，需要 global 关键字
num = 1


def fun():
    global num  # 使用 global 关键字声明
    print(num)
    num = 123
    print(num)


fun()
print(num)

-> 1
-> 100
-> 100

# 该实例演示修改嵌套作用域 (enclosing 作用域，外层非全局作用域)，需要 nonlocal 关键字
def outer():
    num = 10
    
    def inner():
        nonlocal num  # 使用 nonlocal 关键字声明
        num = 100
        print(num)
         
    inner()
    print(num)
    

outer()

-> 100
-> 100

八、简单装饰器

• 在 不改变 当前函数的情况下, 给其 增加 新的功能，回调函数和返回函数的实例就是装饰器

def log(pr):  # 将被装饰函数传入
    
    def wrapper():
        print("-" * 24)
        return pr()  # 执行被装饰的函数

    return wrapper  # 将装饰完之后的函数返回（返回的是函数名）


@log
def pr():
    print("Hello World")


pr()

-> ------------------------
-> Hello World