小白学习之路，基础三（函数）

 一，函数的基本介绍

首先谈到函数，相信大家都不陌生，不管是其他语言都会用到，可能就是叫法不一样。就我知道的跟python中函数类似的，在C中只有function，在Java里面叫做method，在js中也是叫function。函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

函数有下面三点好处：

1.能够减少重复代码的使用

2.让你的程序有更好的扩展性

3.可以让你的程序变得更加容易维护

下面我们就来讲一下怎么定义一个函数

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

补充知识：return不返回值的时候有三种方法：不写return，只写一个return，或者return None。return当有多个返回值的时候用逗号分隔。接收的时候可以用一个变量接收（元组），也可以用多个变量接收。

二，函数的参数

函数可以传参，也可以不传参，都是可以的哦。

#定义一个需要传参的函数
def say(name):
    print('hello',name)
say('zzq')   #调用say这个函数，并且传入参数

#不需要传参的函数
def take():
    print('I Love You')
take()   #调用函数，不传任何参数

#有返回值的函数
def add(x,y):
    return x+y
a=add(4,5) #传入的参数必须是相同数据类型
print(a)   #执行结果为9

值得注意的是在传入的参数还有三种：普通参数，不定长参数，自典型

#普通参数
def say1(name):
    print(name)
say1('gmx')

#不定长参数
def say2(*args):
    print(args)
say2(1,5,'sd')

#自典型
def say3(**kwargs):
    print(kwargs)
say3(name='zzq',say='I Love You',to_name='gmx')#传入的参数必须是字典

#执行结果为
#gmx
#(1, 5, 'sd')
#{'name': 'zzq', 'say': 'I Love You', 'to_name': 'gmx'}

听到参数大家还经常听到形参跟实参这两个词，下面我跟大家大概讲一下两者的区别。

• 形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量
• 实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

三，全局变量跟局部变量

什么是全局变量跟局部变量呢，根据他们的名字可以知道，全局变量可以在全局使用，局部变量呢只能在一些地方使用的变量。

在函数里面定义的变量为局部变量，只能试用于函数。

在外面定义的叫全局变量，也可以在函数内部访问。

切记！如果全局变量有一个变量名字跟函数里面的相同，函数内部在调用时，用的是函数内部的变量

name='zzq'
def say():
    name='gmx'
    print(name)#调用的是函数内部的name
say()
print(name)#调用的全局变量的name

#执行结果
#gmx
#zzq

在函数中的局部变量也能转化为全局变量，但是这种方法是不推荐使用的，也是不能使用的。

name='zzq'
def say():
    global name #把name设置为全局变量
    name='gmx'
    print(name)
say()
print(name)
#执行结果
#gmx
#gmx

四，匿名函数

python 使用 lambda 来创建匿名函数，一般一个函数用的次数比较少，为了方便就出现了匿名函数。

• lambda只是一个表达式，函数体比def简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

匿名函数基本语法：

#计算数字的平方
calc=lambda n:n*n  #定义一个匿名函数
print(calc(5))

#当然还能这样用
l=map(lambda n:n*n,[1,2,3,4,5]) #map把后面可迭代对象去执行前面的函数
for i in l:
    print(i)

在这里用到了map，那就简单的提一下把。因为要涉及到后面的迭代对象，所以就简单讲一下用法。

map函数的原型是map(function, iterable, …)，它的返回结果是一个列表。

参数function传的是一个函数名，可以是python内置的，也可以是自定义的。
参数iterable传的是一个可以迭代的对象，例如列表，元组，字符串这样的。

解释起来有点不好理解，下面一些简单的代码例子，供大家参考吧。

a=(1,2,3,4,5)
b=[1,2,3,4,5]
c="zhangkang"

la=map(str,a)
lb=map(str,b)
lc=map(str,c)

print(la)
print(lb)
print(lc)

输出：
['1', '2', '3', '4', '5']
['1', '2', '3', '4', '5']
['z', 'h', 'a', 'n', 'g', 'k', 'a', 'n', 'g']

五，嵌套函数

嵌套函数，听到名字难道是一个函数里面还可以放函数，卧槽，居然特么还有这种操作？当然，嵌套函数就是一个函数里面还嵌套另外一个函数，下面一个简单的例子，给大家参考理解吧。

name='zzq'
def say1():
    name='gmx'
    def say2():
        name='other'
        print('最里面函数',name)
    say2()
    print('外面一层函数',name)
say1()
print('最外面函数',name)

#执行结果
#最里面函数 other
#外面一层函数 gmx
#最外面函数 zzq

六，递归

我们刚刚了解了嵌套函数，知道在函数的内部可以继续调用函数，如果在函数的内部调用自己，那么这个函数就是递归。当然递归不能随便乱用，他也有自己的调用特性。

递归特性:

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

#输入一个数，输出所有平方小于500的数
def calc(n):
    if n>500:
        return n
    print(n)
    return calc(n*n)  #继续调用自己，形成递归
calc(2)

#执行结果
2
4
16
256

4.阶乘

在递归的运用中，有一个很经典的例子，那就是计算阶乘的结果。用其他方法也可以实现，但是估计比较麻烦，下面是用简单的递归实现阶乘计算。

def test(x):
    if x==1:
        return x
    else:
        return x*test(x-1)

5.汉诺塔问题

当然在递归里面很经典的还有一个问题就是汉诺塔问题，而且更能体现递归的好处。

如下图所示，从左到右有A、B、C三根柱子，其中A柱子上面有从小叠到大的n个圆盘，现要求将A柱子上的圆盘移到C柱子上去，期间只有一个原则：一次只能移到一个盘子且大盘子不能在小盘子上面，求移动的步骤和移动的次数

解决的思路其实就三步：1.先把n-1个盘子移动到B（借助C），2.最大的那个放在C，3.把n-1个盘子放到C（借助A）

x = 0  # 记录移动次数
def hannota(n, A, B, C):
    '''
    :param n: 总共移动盘子个数
    :param A: A柱子
    :param B: B柱子
    :param C: C柱子
    :return:
    '''
    if n > 0:
        hannota(n - 1, A, C, B)  # 把n-1从A进过C移动到B
        global x
        x += 1
        print '%s-->%s' % (A, C)  # 把最大的n从A移动到C
        hannota(n - 1, B, A, C)  # 把剩下的n-1从B通过A移动到C
hannota(2, "A", "B", "C")
print x

七，高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。通俗的讲就是函数的参数可以是函数，然后里面的参数可以给作为参数的函数当成传入的参数。emmm，好吧，讲得是有点乱。。那就分析分析代码吧

输入ascii的编码号，输出对应的值
def say(letter,f):
    return f(letter)
ascii_name=say(65,chr)#f为一个函数
print(ascii_name)
#执行结果
#A

卧槽，不知不觉学了这么多函数了啊，你就会想这个学了有啥子用嘛，放心，这个为后面厉害的装逼的打基础呢，这章的嵌套函数跟高阶函数为后面的装饰器打基础。万丈高楼平地起，所以还是要把基础掌握好，怎么才能更好的掌握呢，当然方法只有一个，那就是多敲，多记，多思考。