python—【小甲鱼】入门的一些散知识（2）

1、函数

函数定义/参数：def 函数名(参数): 函数体

函数的返回值：return  返回值。

def add(num1, num2):
    result = num1 + num2
    #print(restult)
    return result

result = add(1, 2)
print(restult)

2、函数的参数

以上述函数为例，def add(num1.num2):函数定义过程中的name是形参，因为它只是一个形式，表示占据一个参数位置。

print('传递进来的'+ name + '叫做实参，因为是具体的参数值！')。add(1,2):传递进来的参数时实参，因为是具体的参数值。

关键字参数：传入参数的顺序如果发生改变，会影响函数的结果，所以可以加关键字消除顺序的影响：add(num2=2，num1=1)，也可以在定义函数的时候设置默认参数：def add(num1=1，num2=2)

收集参数（可变参数）：不确定会传进多少个参数，定义的时候加*   def test(*params)

3、函数与过程

python所有的函数都有返回值，有值的时候返回值，没值的时候返回none

4、全局变量与函数中的局部变量

想要在函数中实现对全局变量的修改，可以在函数中将变量声明为global类型

count = 10  
print('the old count = ',count)  
def Myfun():
    global count
    count = 5
    print('the new count = ', count)
Myfun()

5、内嵌函数：在函数内部创建函数，也只能在函数内调用，不能在外部调用

def fun1()：
    print('fun1正在被调用。。。。')
    def fun2()：
        print('fun2正在被调用。。。。')
    fun2()

6、闭包：

python中任何变量或函数都是对象，可以直接返回。nonlocal使子函数可以使用母函数中的变量

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

def Fun1()：
    x = 5
    def Fun2():
        x *= x
        return x
    return Fun2   #return Fun2()会报错


def Fun1()：
    x = 5
    def Fun2():
        nonlocal x   #使x不是局部变量，即Fun2()可以使用x的值
        x *= x
        return x
    return Fun2()

7、lambda公式： x : 2 * x + 1

g = lambda x : 2 * x + 1
print(g(5))
numSum = lambda x,y:x+y
print(numSum(3,5))

1. python写一些执行脚本时，使用lambda就可以省下定义函数的过程，如果只是需要写个简单的脚本来管理服务器的时间，就不需要专门定义一个函数然后写调用，使用lambda就可以使代码更精简。
2. 对一些比较抽象且整个程序执行下来只需要调用一两次的函数，使用lambda就不需要考虑命名的问题了。
3. 简化代码的可读性

8、两个BIF

filter(function or None, iterable)  过滤器：把任何非true的内容过滤掉

def odd(x):
    return x%2
numbers = range(10)
show = filter(odd, numbers)
print(list(show))

map() 映射：将序列的每一个元素作为函数的参数进行运算加工，直到可迭代序列所有的元素加工完毕，返回加工后的序列

mapShow = list(map(lambda x : x * 2, range(10)))
print(mapShow)

9、递归：函数调用自身行为+正确的返回条件       递归具有危险性

def factorial(n):
    if n == 1:
        return 1
    else:
        return n*factorial(n-1)
print(factorial(5))

       递归和迭代的区别：迭代:利用变量的原值推算出变量的一个新值.如果递归是自己调用自己的话,迭代就是A不停的调用B。递归中一定有迭代,但是迭代中不一定有递归,大部分可以相互转换.能用迭代的不用递归,递归调用函数,浪费空间,并且递归太深容易造成堆栈的溢出.