python3入门笔记二之 函数 & 参数

函数

定义 def ：

def my_abs(x): 
    if x >=0:
        return x
    else:
        return -x
print(my_abs(-55))
复制代码

返回结果 return:

如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。return None可以简写为return 返回多个值其实就是返回一个tuple，只有一个tuple时可以省略括号 如 return 1,2,3

导入方法： from 文件名 import 方法名

# 从 abstest.py  文件中导入 my_abs() 函数
from abstest import my_abs
my_abs(-9)
复制代码

空函数: pass占位符的使用

这里主要是pass语句的使用，pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。 如：

def nop():
    pass
print(nop())  # None
复制代码

递归函数: 注意栈溢出

def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)
复制代码

递归函数要注意防止栈溢出，可以通过尾递归优化，es6中已经有了，可以参考博主的这篇文章 《es6入门提升总结一》  中的这个尾递归优化。

尾递归是指，在函数返回的时候，调用自身本身，并且，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解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出。

使用递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出。 针对尾递归优化的语言可以通过尾递归防止栈溢出。尾递归事实上和循环是等价的，没有循环语句的编程语言只能通过尾递归实现循环。Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。

参数

参数检查: isinstance ,raise TypeError

if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
复制代码

调用函数时，如果参数个数不对，Python解释器会自动检查出来，并抛出TypeError,但是如果参数类型不对，Python解释器就无法帮我们检查

参数个数不对:

参数类型不对:

abs:

my_abs:(这里直接报了if的错误)

修改一下my_abs的定义，对参数类型做检查，只允许整数和浮点数类型的参数。数据类型检查可以用内置函数 isinstance() 实现：

默认参数：(name,age=18)

一是必选参数在前，默认参数在后，否则Python的解释器会报错(SyntaxError: non-default argument follows default argument)

非默认参数在默认参数之后，很明显 这样做会产生歧义，当你传参时,函数都不知道给哪个赋值好。。

二是如何设置默认参数。 当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。 使用默认参数有什么好处？最大的好处是能降低调用函数的难度。

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

定义默认参数要牢记一点：默认参数必须指向不变对象！ 如： str、None , 因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。

可变参数： *

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple

*变量名 用这样的形式即可接受多个参数，或者tuple，list

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
total=calc(*[1,2]) # *nums表示把nums这个list的所有元素作为可变参数传进去。
total2=calc(1,2,3)
print(total,total2) # 5 14
复制代码

关键字参数: **

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

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)
extra={'city':'Beijing'}
person('Bob', 35, **extra) # 把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数
# name: Bob age: 35 other: {'city': 'Beijing'}
复制代码

注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。

命名关键字参数：必填参数

限制关键字参数的名字，例如，只接收city和job作为关键字参数, 可以理解为必填参数，传参的时候必须用key=value的形式： city='Beijing'

def person(name, age, *,city, job):
    print(name, age, city, job)
person('Jack', 24,city='Beijing',job='Engineer')
person('Jack', 24,'Beijing','Engineer') # TypeError: person() takes 2 positional arguments but 4 were given python 
# Python解释器把这4个参数均视为位置参数，但person()函数仅接受2个位置参数
复制代码

函数参数中有可变参数*args,后面的命名关键字参数就不再需要特殊分隔符*了

def person(name, age, *args, city, job):
    print(name, age, args, city, job)
复制代码

命名关键字参数也可以有默认值，这时就可以不传入对应的key参数

def person(name, age, *, city='Beijing', job):
    print(name, age, city, job)
person('Jack', 24, job='Engineer')
Jack 24 Beijing Engineer
复制代码

小结

函数

定义函数时，需要确定函数名和参数个数； 如果有必要，可以先对参数的数据类型做检查； 函数体内部可以用return随时返回函数结果； 函数执行完毕也没有return语句时，自动return None。 函数可以同时返回多个值，但其实就是一个tuple。

参数

参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

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)