文章目录
- 1. 函数定义
- 2. 函数参数
- 2.1 参数传递
- 2.2 位置参数（必须参数）
- 2.3 关键字参数
- 2.4 默认参数
- 2.5 可变参数
- 2.5 可变关键字参数
- 3. 参数组合
- 4. 匿名函数
- 5. 作用域
- 6. 递归函数
- 7. 练习
【Python 基础教程（第3版）[挪] Magnus Lie Hetland 著】
1. 函数定义
- 函数代码块以
def关键词开头，后接函数标识符名称和圆括号()。 - 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号起始，并且缩进。
-
return [表达式]结束函数，选择性地返回一个值或者多个值（一个 tuple）给调用方。不带表达式的return相当于返回None。
def square(x):
'Calculates the square of the number x.'
return x * x
# 可以像下面这样访问文档字符串：
>>> square.__doc__
'Calculates the square of the number x.'2. 函数参数
函数参数分为以下几类：
- 位置参数（必选参数）
- 关键字参数
- 默认参数（必须指向不变对象）
- 可变参数（收集所有剩余的位置参数组装成 tuple）
- 可变关键字参数（收集所有剩余的关键字参数组装成 dict）
2.1 参数传递
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。python 函数的参数传递：
- 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如 fun(a)，传递的只是a的值，没有影响 a 对象本身。比如在 fun(a) 内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
- 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响
2.2 位置参数（必须参数）
位置参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
def power(x, n):
s = 1
while n > 0:
n = n - 1
s = s * x
return s执行结果：
>>> power(5, 2)
25
>>> power(5, 3)
1252.3 关键字参数
关键字参数允许函数调用时参数的顺序与声明时不一致。
#!/usr/bin/python3
#可写函数说明
def printinfo( name, age ):
"打印任何传入的字符串"
print ("名字: ", name)
print ("年龄: ", age)
return
#调用printinfo函数
printinfo( age=50, name="runoob" )以上实例输出结果：
名字: runoob
年龄: 502.4 默认参数
调用函数时，如果没有传递参数，则会使用默认参数。默认参数必须指向不可变对象。以下实例中如果没有传入 age 参数，则使用默认值：
#!/usr/bin/python3
#可写函数说明
def printinfo( name, age = 35 ):
"打印任何传入的字符串"
print ("名字: ", name)
print ("年龄: ", age)
return
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )以上实例输出结果：
名字: runoob
年龄: 50
------------------------
名字: runoob
年龄: 352.5 可变参数
参数前面加了一个*号，即为可变参数。* 意味着收集余下所有的位置参数，并在函数调用时自动组装为一个 tuple。如果没有可供收集的参数，则将是一个空元组。因此，调用该函数时，可以传入任意个参数，包括 0 个参数。：
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
调用结果如下：
>>> calc(1, 2)
5
>>> calc()
0def print_params_2(title, *params):
print(title)
print(params)
调用结果如下：
>>> print_params_2('Params:', 1, 2, 3)
Params:
(1, 2, 3)
>>> print_params_2('Nothing:')
Nothing:
() # 没有多余参数时则为空 tuple如果已经有一个 list 或者 tuple，在 list 或 tuple 前面加一个*号，把 list 或 tuple 的元素变成可变参数传进去：
>>> nums = [1, 2, 3]
>>> calc(*nums)
14*nums表示把nums这个 list 的所有元素作为可变参数传进去。这种写法相当有用，而且很常见。
与赋值时一样，带 * 的参数也可放在其他位置（而不是最后），但不同的是，在这种情况下，* 后面必须接关键字参数或者默认参数（被视为命名关键字参数）。
>>> def in_the_middle(x, *y, z):
... print(x, y, z)
...
>>> in_the_middle(1, 2, 3, 4, 5, z=7)
1 (2, 3, 4, 5) 7
>>> in_the_middle(1, 2, 3, 4, 5, 7)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: in_the_middle() missing 1 required keyword-only argument: 'z'如果没有可变参数，就必须加一个*作为特殊分隔符。如果缺少*，Python解释器将无法识别位置参数和命名关键字参数。
例如：只接收city和job作为关键字参数，这种方式定义的函数如下：
def person(name, age, *, city, job):
print(name, age, city, job)
def person(name, age, city, job):
# 缺少 *，city和job被视为位置参数
pass2.5 可变关键字参数
** 可以收集剩余的所有关键字参数，这些关键字参数在函数内部自动组装为一个dict。可以传入 0 个或任意个关键字参数：
def person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)函数 person 除了必选参数 name 和 age 外，还接受关键字参数 kw。在调用该函数时，可以只传入必选参数：
>>> person('Michael', 30)
name: Michael age: 30 other: {}也可以传入任意个数的关键字参数：
>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}和可变参数类似，也可以先组装出一个dict，然后，把该 dict 转换为关键字参数传进去：
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}**extra表示把extra这个 dict 的所有 key-value 用关键字参数传入到函数的**kw参数，kw将获得一个 dict，注意kw获得的 dict 是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
3. 参数组合
参数可以组合使用：
def foo(x, y, z, m=0, n=0):
print(x, y, z, m, n)
def call_foo(*args, **kwds):
print("Calling foo!")
foo(*args, **kwds)这在调用超类的构造函数时特别有用。
在 Python 中定义函数，可以用位置参数、默认参数、可变参数、可变关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：位置参数、默认参数、可变参数、命名关键字参数和可变关键字参数。
def f1(a, b, c=0, *args, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
def f2(a, b, c=0, *, d, **kw):
print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)在函数调用的时候，Python 解释器自动按照参数位置和参数名把对应的参数传进去。最神奇的是通过一个 tuple 和 dict，你也可以调用上述函数：
>>> args = (1, 2, 3, 4)
>>> kw = {'d': 99, 'x': '#'}
>>> f1(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
>>> args = (1, 2, 3)
>>> kw = {'d': 88, 'x': '#'}
>>> f2(*args, **kw)
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}4. 匿名函数
python 使用 lambda 来创建匿名函数。所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
-
lambda只是一个表达式，函数体比 def 简单很多。 -
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。 -
lambda函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。 - 虽然
lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法：lambda 函数的语法只包含一个语句，如下：
lambda [arg1 [,arg2,.....argn]]:expression等价于：
def func(arg1 [,arg2,.....argn]):
return expression示例如下：
#!/usr/bin/python3
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))以上实例输出结果：
相加后的值为 : 30
相加后的值为 : 405. 作用域
变量的作用范围称为命名空间（namespace）或作用域。除全局命名空间外，每个函数调用都将创建一个局部命令空间。
在函数内使用的变量称为局部变量（与之相对的是全局变量）。参数类似于局部变量，因此参数与全局变量同名不会有任何问题。
在函数内部给变量赋值时，该变量默认为局部变量，可以使用 global 关键字声明为全局变量：
>>> x = 1
>>> def change_global():
... global x
... x = x + 1
...
>>> change_global()
>>> x
2通常，在嵌套函数中，不能给外部作用域内的变量赋值，但如果一定要这样做，可使用关键字 nonlocal。这个关键字的用法与 global 很像，让你能够给外部作用域（非全局作用域）内的变量赋值。
6. 递归函数
如果一个函数在内部调用自身本身，这个函数就是递归函数。
递归函数通常包含下面两部分:
- 基线条件（针对最小的问题）：满足这种条件时函数将直接返回一个值。
- 递归条件：包含一个或多个调用，这些调用旨在解决问题的一部分。
这里的关键是，通过将问题分解为较小的部分，可避免递归没完没了，因为问题终将被分解成基线条件可以解决的最小问题。
阶乘函数示例如下：
# 阶乘函数的递归写法：
def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n - 1)理论上，所有的递归函数都可以写成循环的方式。上面的阶乘函数的循环写法示例如下：
# 阶乘函数的循环写法：
def factorial(n):
result = n
for i in range(1, n):
result *= i
return result而且在大多数情况下，使用循环的效率可能更高。然而，在很多情况下，使用递归的可读性更高，且有时要高得多。
7. 练习
- 请利用Python内置的hex()函数把一个整数转换成十六进制表示的字符串：
#!/usr/bin/python3
# -*- coding: utf-8 -*-
n1 = 255
n2 = 1000
print(hex(n1))
print(hex(n2))运行结果：
0xff
0x3e8- 请定义一个函数
quadratic(a, b, c)，接收3个参数，返回一元二次方程
提示：
一元二次方程的求根公式为：
计算平方根可以调用math.sqrt()函数：
>>> import math
>>> math.sqrt(2)
1.4142135623730951代码如下：
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import math
def quadratic(a, b, c):
sqrt = math.sqrt(b**2-4*a*c)
return (-b+sqrt)/(2*a),(-b-sqrt)/(2*a)
print('quadratic(2, 3, 1) =', quadratic(2, 3, 1))
print('quadratic(1, 3, -4) =', quadratic(1, 3, -4))
if quadratic(2, 3, 1) != (-0.5, -1.0):
print('测试失败')
elif quadratic(1, 3, -4) != (1.0, -4.0):
print('测试失败')
else:
print('测试成功')运行结果：
quadratic(2, 3, 1) = (-0.5, -1.0)
quadratic(1, 3, -4) = (1.0, -4.0)
测试成功- 以下函数允许计算两个数的乘积，请稍加改造，变成可接收一个或多个数并计算乘积：
# -*- coding: utf-8 -*-
def product(x, y):
return x * y
# 测试
print('product(5) =', product(5))
print('product(5, 6) =', product(5, 6))
print('product(5, 6, 7) =', product(5, 6, 7))
print('product(5, 6, 7, 9) =', product(5, 6, 7, 9))
if product(5) != 5:
print('测试失败!')
elif product(5, 6) != 30:
print('测试失败!')
elif product(5, 6, 7) != 210:
print('测试失败!')
elif product(5, 6, 7, 9) != 1890:
print('测试失败!')
else:
try:
product()
print('测试失败!')
except TypeError:
print('测试成功!')解答如下，至少有六种写法：
# 1. 常规写法一：
def product(*args):
j = 1
i = 0
if len(args) == 0:
raise TypeError
while i < len(args):
j = j * args[i]
i += 1
return j
# 2. 常规写法二：
def product(*args):
if len(args) == 0:
raise TypeError
j = 1
for i in args:
j = j * i
return j
# 3. 使用 reduce：
from functools import reduce
def product(*args):
return reduce(lambda x,y:x*y,args)
# 4. 使用 eval 一：
def product(*args):
if not len(args):
raise TypeError
result="1"
for i in args:
result=result+"*"+str(i)
return eval（result)
# 5. 使得 eval 二：
def product(*args):
if not args:
raise TypeError
lst=[str(i) for i in list(args)]
result="*".join(lst)
return eval（result)
# 6. 使用嵌套函数：
def product(*args):
def cal(lst):
if len(lst) == 0:
raise TypeError
if len(lst) == 1:
return lst[0]
else:
return lst.pop() * cal(lst)
return cal(list(args))- 汉诺塔的移动可以用递归函数非常简单地实现。
请编写move(n, a, b, c)函数，它接收参数 n，表示 3 个柱子 A、B、C 中第 1 个柱子 A 的盘子数量，然后打印出把所有盘子从 A 借助 B 移动到 C 的方法，例如：
def move(n, a, b, c):
if n == 1:
print(a, '-->', c)
......# 期待输出:
# A --> C
# A --> B
# C --> B
# A --> C
# B --> A
# B --> C
# A --> C
move(3, 'A', 'B', 'C')解答如下：
# -*- coding: utf-8 -*-
def move(n, a, b, c):
if n == 1:
print(a, '-->', c)
else:
move(n-1, a, c, b) # 第一步：将 A 柱除最下面的圆盘外的其他圆盘移动到 B 柱
print(a, '-->', c) # 第二步：将 A 柱最下面的圆盘移动到 C 柱
move(n-1, b, a, c) # 第三步：将 B 柱上的所有圆盘移动到 C 柱
move(3, 'A', 'B', 'C')
