python基础之函数总结

函数在任何程序语言中都是一个不可缺少的部分。
无论是面向过程还是面向对象，都离不开函数。函数从文本上看，就是一个代码块，有着一个输入口，有着一个或几个输出。
在python中函数的定义方式:
def function()：
    函数体

在python中任何函数要使用，都必须有一个定义过程，即使是匿名函数也是如此。

在python中函数的调用：
function()，此语句即可调用函数，得到返回值。

但是如果没有return语句，并不代表函数没有返回值，而是说函数的返回值是’none’。

  >>> def test():
    print('任何函数都是有返回值的')


>>> result = test()
任何函数都是有返回值的
>>> type(result)
<class 'NoneType'>
>>> print(result)
None
>>>

函数定义的时候，可以不带参数，也可以带一个或几个参数。
就比如说function(x)，其中x称作形参，而在调用过程中，function(2)，这个2称作实参。
因为2是一个实际的值，不像形参，只是在函数定义过程中占位置用的。
为了便于对函数有一些文字描述，python在函数的定义的过程中加入了函数文档这个东西。
函数文档的写法：
在函数体的前面，用’‘包含对函数进行描述的文字。我们可以用fucntion.__doc__或者help(fucntion)来查看一个函数的函数文档。

>>> def function1(x):
    '这个函数实现的是：求一个数的平方'
    return x*x

>>> function1.__doc__
'这个函数实现的是：求一个数的平方'
>>> help(function1)
Help on function function1 in module __main__:

function1(x)
    这个函数实现的是：求一个数的平方

在很多情况下，函数不止一个参数。
我们可以用这种方式定义函数：function(param1,param2,param3.....paramn)。 
但是这种多函数参数定义函数很容易导致在调用的时候，我们忘记了参数依次所代表的真实含义，因此很容易出现不可预料的错误。

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


>>> fucntion2('毛主席',"黑猫白猫，抓的到老鼠的都是好猫")
毛主席->黑猫白猫，抓的到老鼠的都是好猫
>>> fucntion2("黑猫白猫，抓的到老鼠的都是好猫",'毛主席')
黑猫白猫，抓的到老鼠的都是好猫->毛主席
>>>

为了避免发生以上，那种错误。我们可以利用关键字参数解决。

 >>> fucntion2(name = '毛主席',words = "黑猫白猫，抓的到老鼠的都是好猫")
毛主席->黑猫白猫，抓的到老鼠的都是好猫
>>>

有的时候函数定义是有参数的，但如果你少写一个参数，就会报错。 
为解决这个问题，就需要默认参数。就是在函数定义的时候就加上默认值

def fucntion2(name = '毛主席',words = "黑猫白猫，抓的到老鼠的都是好猫")

有的情况下，我们自己也不确定，函数到底有几个参数。 
这种情况，就得使用收集参数，其实python的BIL中很多函数都利用了收集参数。

>>> def function3(*params,name = '毛主席'):
    x=params[0]
    y=params[1]
    result =x*y
    print(result)
    print(name)
>>> function3(3.4,2,3)
6.8
毛主席
>>>

在python中，函数和过程是有本质区别的，区别就在于函数有返回值，而过程没有。
关于变量。python中有全局变量和局部变量两种。 
其中局部变量是在函数体中定义的，作用域就是函数体，出了函数体就不能调用了。
而全局变量定义在函数体外，无论函数体内还是函数体外都能调用，简单来说就是.py文件中都可以调用。 
但是一定要注意，函数体内可以调用全局变量，可千万不要修改全局变量的值。 
因为，在函数体内修改全局变量的值，只会迫使python在函数体中创建一个同名的局部变量， 
再修改此局部变量的值，与函数体外的全局变量无关，两者的值互不影响。

>>> size = 100
>>> def change():
    print('此处，尝试在函数体内修改全局变量size....')
    size = 50


>>> change()
此处，尝试在函数体内修改全局变量size....
>>> size
100
>>> 
    但是，如果真的想要在函数体内修改全局变量，也是有办法的，使用关键字global即可。

def change2():
global size
print(‘此处，尝试在函数体内修改全局变量size….’)
size = 50

change2()
此处，尝试在函数体内修改全局变量size….
size
50


    内嵌函数，也叫内部函数，也即一个函数内部包含另一个函数。如：

def function4(x):
def function5(n):
return n*n
result = function5(x)
return result

print(function4(5))
25


    闭包是一种编程范式。python中闭包的表现形式为： 
    如果在一个内部函数里，对外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就会被认为是闭包。

def FunX(x):
def FunY(y):
return x*y
return FunY

i = FunX(8)
i

   lambda 表达式创建匿名函数的作用有：
   1，python写执行脚本时名，lambda可以省下函数定义过程
   2，适用于一些比较抽象并且整个程序执行下来只需要调用一两次的函数，不需要考虑命名
   3，简化代码

lambda x: x+1

    两个python中比较特殊的BIL，filter()，map()
    filter(function,iterable)，又叫做过滤器，有两个参数，第一个参数是一个函数，可用匿名函数表示， 
    第二个参数是一个可迭代对象，如序列。作用就是将序列中的数依次从头到尾的输入到函数中，然后只保留返回值为真的数字。
    map(function,iterable)，又叫作映射，有两个参数，和filter()一样， 
    只是这里是将序列中的每一个数依次输入函数中，将所有返回值以序列的方式返回。

list(filter(lambda x:x % 2,[-3 , 2 , -4 ,3]))
[-3, 3]
list(map(lambda x:x +2,[-3 , 2 , -4 ,3]))
[-1, 4, -2, 5]

    函数的递归。递归和迭代有点类似，但递归是解决一些困难问题的很棒的思路，比如斐波那契数列和汉诺塔。

#阶乘的迭代实现
def jiecheng(x):
    sum = 1
    for i in list(range(1,x+1)):
            sum = sum * i
    return sum
print(jiecheng(5))
#阶乘的递归实现
def jiecheng2(x):
    if x =1:
        return 1
    else:
        return x *jiecheng2(x-1)
#斐波那契数列的迭代实现            
def feibonaqi(n):
    data = [1,1]
    for i in range(1,n+1):
        temp = data[i] + data[i-1]
        data.append(temp)
    return data[n-1]
print(feibonaqi(35))


#斐波那契数列的递归实现
def feibonaqi2(n):
        if n ==1 or n ==2:
            return 1
        else:
            return (feibonaqi2(n-1)+feibonaqi2(n-2))
print(feibonaqi2(35))

#汉诺塔的递归实现
def hanoi(n , x , y , z):
    if n == 1:
        print(x+ '->' + z)
    else:
        hanoi(n-1,x , z , y)#第一步将n-1个塔从x放到y
        print(x + '->' + z)#第二步将第n层的塔从x放到z
        print(y + '->' + z)#第三步将n-1层塔从y放到z
hanoi(3 , 'X' , 'Y' , 'Z')

python基础之函数总结

猜你喜欢