5 函数

函数、对象、模块,这里介绍函数

1. 函数的定义

def add(x,y):
    return (x + y)

举例:请问下面这个函数有多少个参数?

def MyFun((x, y), (a, b)):
return x * y - a * b

如果你回答两个, 那么恭喜你错啦, 答案是 0, 因为类似于这样的写法是错误的!
我们分析下, 函数的参数需要的是变量, 而这里你试图用“元祖”的形式来传递是不可行的。
我想你如果这么写, 你应该是要表达这么个意思:

>>> def MyFun(x, y):
return x[0] * x[1] - y[0] * y[1]
>>> MyFun((3, 4), (1, 2))

2. 函数文档

def add(x,y):
    '这是函数文档'
   return (x + y)

执行add.dochelp(add)可打印出函数文档内容。

3.关键字参数

在参数列表中,不按顺序去索引参数,而是按关键字去索引参数。为了防止搞不清参数顺序而出现bug。

def fun(name, words):
    print(name + '->' + words)

fun(words = '让编程改变世界!', name = '小甲鱼')    #小甲鱼->让编程改变世界!

4. 默认参数

即定义了默认值的参数

def add(x = 1,y = 2):
    return (x + y)

add()    #3
add(5)    #7

5. 收集参数

*arg:一个可以代替多个

def test(*arg):
    print('参数长度为:', len(arg))
    print('第二个参数为:', arg[1])

test(1, 'abc', 4, 5)
#参数长度为: 4
#第二个参数为: abc

注意:如果收集参数后面还有其他参数,要用默认参数,否则所有参数都默认给了收集参数。

def test(*arg, exp = 'exp'):
    print('参数长度为:', len(arg), exp)
    print('第二个参数为:', arg[1])

test(1, 'abc', 4, 5)
#参数长度为: 4 exp
#第二个参数为: abc

print()函数就是用的这种形式:

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

要改变exp的值应使用关键字参数:

test(1, 'abc', 4, 5, exp = 'hello')

6. 函数与过程

一般来说,函数有返回值,过程没有返回值。而python中,没有过程这个概念。
即使不写返回值,也会默认返回一个NoneType类型。例:

def fun():
    print('hello')

tmp = fun
type(tmp)    #

7. python可返回多个类型返回值

def back():
    return [1, 2, 'abc']

back()    #[1, 2, 'abc']

8. 变量的作用域

在函数里面定义的变量是局部变量,在函数外不可访问。
注意:对于全局变量,只能在函数内部读取它,但不能在函数内部修改它。一旦修改,函数会在函数内部创建一个与该全局变量同名的局部变量,从而使得该全局变量没有被修改,修改的只是新创建的同名局部变量。例如:

def fun():
    x = 10
    print(x)

x = 20
fun()
print(x)    #会依次输出10和20

9. global关键字

上面说了,对于全局变量,只能在函数内部读取它,但不能在函数内部修改它。如果非要在函数内部修改它,用到global关键字。

c = 5
def fun():
    global c    #声明c为global
    c = 10
    print(c)

fun()    #10
print(c)    #10

10. 内部函数

函数内部还能定义一个函数,但是注意,内部函数的作用域只限于外部函数。

def fun1():
    print('this is fun1.')
    def fun2():
        print('this is fun2.')
    fun2()

11. 闭包

如果一个内部函数,引用了外部作用域的变量,这个内部函数就形成一个闭包。

def funX(x):
    def funY(y):
        return x+y
    return funY

funX(1)(3)    #4

注意:同样,对于闭包,它只能引用外部变量而不能修改它。如果非要修改它,用到nonlocal关键字。类似上面提到的global。

def funX():
    x = 5
    def funY():
        nonlocal x    #声明x为nonlocal
        x = x + 1
        return x
    return funY()

funX()    #6

比较下列两个程序:

def funOut():
    def funIn():
        print('hello')
    return funIn()

funOut()#调用内部函数
def funOut():
    def funIn():
        print('hello')
    return funIn

funOut()()#调用内部函数

12. lambda表达式

function = lambda 参数1,参数2,...,参数n : 返回值

f = lambda x,y : x + y    #定义函数f(x,y) = x + y

f(3,4)    #7

记忆方法:
对照f(x) = ax+b
lambda方法:lambda x : ax+b

13. 两个牛逼的BIF(Built-in Functions)

1. filter():过滤器

filter(function or None, iterable) --> filter object
|
| Return an iterator yielding those items of iterable for which function(item)
| is true. If function is None, return the items that are true.

tmp = filter(None, [1, 0, False, True])    
list(tmp)    #[1, True]

def odd(x):
    return x % 2

tmp = filter(odd, range(10))    #注意这里只写函数名即可,不加括号
list(tmp)    #[1, 3, 5, 7, 9],输出中0被过滤,注意返回的是输入值中符合条件的

或用更简单的lambda表达式:

tmp = filter(lambda x : x % 2, range(10))
list(tmp)    #[1, 3, 5, 7, 9],输出中0被过滤

2. map():映射

把后面的序列里依次送入前面的函数里。

>>> def double(x):
    return x*2

>>> print(list(map(double,[1,2,3,4])))
[2, 4, 6, 8]
list(map(lambda x : x * 2, range(10)))    #[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
list(map(lambda x : x % 2, range(10)))    #[0, 1, 0, 1, 0, 1, 0, 1, 0, 1],可知与filter()的异同。
5 函数_第1张图片
Paste_Image.png

你可能感兴趣的:(5 函数)