python学习之2函数（廖雪峰）

一、函数

1、调用函数

函数名就是 指向一个函数对象的 引用，完全可以把函数名赋给一个变量，相当于给这个函数起了个“别名”。

>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数

2、定义函数

定义函数用def语句，依次写出函数名、括号、括号中的参数和冒号：，然后在缩进块中编写函数体。

例如，定义一个求绝对值的my_abs函数:

def my_abs(x):
    if x>=0:
        return x
    else:
        return -x

如果已经把my_abs()函数的代码存为funct1.py的文件，那么打开cmd后先用 cd C:\work 切换到funct1.py的存储目录，然后输入 python 来启动python解释器，而后输入 from funct1 import my_abs 来导入my_abs()函数，就可以在cmd中输入诸如 my_abs(-97) 来调用函数并显示结果

 注意：

（1）定义函数时，需要确定函数名和参数个数

（2）函数执行完毕也没有return语句时，自动return None

（3）函数可以同时返回多个值，但其实就是一个tuple。

3、函数的参数

（1）位置参数

例如计算x的n次方

def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

 power(x,n)函数有两个参数：x和n，这两个参数就是位置参数，调用函数时，传入的两个值按照位置顺序依次赋给参数x和n.

（2）默认参数

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

当我们调用power(5)时，相当于调用power(5, 2)

而对于n > 2的其他情况，就必须明确地传入n，比如power(5, 3)

注意：

（a）必选参数在前，默认参数在后。

（b）当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。

（c）默认参数一定要用不可变对象。

（3）可变参数

可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。

请计算a2 + b2 + c2 + ……。

由于参数个数不确定，我们首先想到可以把a，b，c……作为一个list或tuple传进来，这样，函数可以定义如下：

def calc(numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

调用的时候，需要先组装出一个list或tuple：

calc([1, 2, 3])
calc((1, 3, 5, 7))

但是，如果想要调用可变参数，例如 calc(1, 2, 3) 就需要将函数的参数改成可变参数，可变参数在函数调用时自动组装为一个tuple

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

如果已经有一个list或者tuple，要调用一个可变参数怎么办？可以这样做：

nums = [1, 2, 3]
calc(*nums)

 *nums 把 nums 这个list的所有元素作为可变参数传进去。这个写法很常用。

（4）关键字参数

关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。例如：

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', 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

extra = {'city': 'Beijing', 'job': 'Engineer'}

作为关键字参数传进去，可以如下写：

>>> 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 。

（5）命名关键字参数

如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数：

def person(name, age, *, city, job):
    print(name, age, city, job)

需要一个特殊分隔符‘*’，‘*’后面的参数被视为命名关键字，调用方式如下：

>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

注意：

（a）命名关键字参数必须传入参数名，按如上写法。

（b）如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符‘*’了：

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

（c）命名关键字参数可以有缺省值，从而简化调用：

def person(name, age, *, city='Beijing', job):
    print(name, age, city, job)

>>> person('Jack', 24, job='Engineer')
Jack 24 Beijing Engineer

（6）参数组合

在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)

 *args 是可变参数，args接收的是一个tuple； **kw 是关键字参数，kw接收的是一个dict。

4、递归函数

递归函数：一个函数在内部调用自身本身

例如：计算阶乘n! = 1 * 2 * 3 * ... * n：

def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)

但是，使用递归函数需要注意防止栈溢出！

解决递归调用栈溢出的方法是通过尾递归优化，尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。

将上述代码改为尾递归方式，主要是把每一步的成绩传入到递归函数中：

def fact(n):
    return fact_iter(n, 1)

def fact_iter(num, product):
    if num == 1:
        return product
    return fact_iter(num - 1, num * product)

需要注意的是：Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。

 

转载于:https://www.cnblogs.com/zj83839/p/7625380.html