python入门：函数(函数定义，函数参数，全局和局部变量，嵌套函数，匿名函数，高阶函数，递归，内置函数)

函数

函数是什么？

         函数一词来源于数学，但编程中的【函数】概念，与数学中的函数是有很大不同的，编程中的函数在英文中也有很多不同的叫法。在basic中交债subroutine（子过程或子程序）,在Pascal中交债procedure（过程）和function，在C中只有function，在Java里面叫着method

定义：

      函数是指将一组语句的集合通过一个名字（函数名）封装起来，要想执行这个函数，只需调用其函数名即可

特性：

• 减少重复代码                                                                                       
• 使程序变的可扩展
• 是程序变的易维护       

    

可以带参数：

1 2 3 4 5 6 7 8 9 10 11 12

# 下面这段代码 a, b = 5, 8 c = a ** b print(c) # 改成函数写 def calc(x, y):     res = x**y     return res    # 返回函数执行结果 c = calc(a, b)     # 结果赋值给c变量 print(c)

　　

函数参数

参数可以让你的函数更灵活，不只能做死的动作，还可以根据调用时传参的不同来决定函数内部的执行流程

形参变量

  只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

实参

可以是常理，变量，表达式，函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等方法使参数获得确定值。

 

                                    

# 默认参数

1 2 3 4 5 6 7 8 9 10

def stu_register(name, age, country, course):     print("注册学生信息".center(20, '-'))     print("姓名", name)     print("age", age)     print("国籍", country)     print("课程", course) stu_register("张三", 22, "CN", "python") stu_register("王五", 23, "CN", "linux") stu_register("李四", 25, "CN", "Java")

　　发现 country 这个参数 基本都 是"CN",这种不填写就默认的值，可以把country变成默认参数非常简单

1	def stu_register(name, age, course, country = "CN" ):

　　这样，这个参数在调用时不指定，那默认就是CN，指定了的话，就用你指定的值。

# 关键参数

1 2 3 4 5 6 7 8

def stu_register(name, age, course='py', country="CN"):     print("注册学生信息".center(20, '-'))     print("姓名", name)     print("age", age)     print("国籍", country)     print("课程", course) stu_register("张三", course='py', age=22, country="CN")

　　正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，指定了参数名的参数就叫关键参数，要求是：关键参数必须放在位置参数（以位置顺序确定对应关系的参数）之后

调用可以这样：

1	stu_register("张三", course='py', age=22, country="CN")

　　但不可以这样：

1	stu_register("张三", course='py', 22, country="CN")

　　

# 非固定参数
不确定用户想传入多少个参数，就可以使用非固定参数

1 2 3 4

def stu_register(name, age, *args):   # *args 会把多传入的参数变成一个元组形式     print(name, age, args)       stu_register("张三", 22)

　　输出：

1	张三 22 ()   # 后面这个（）就是args，只是因为没有传值，所以为空

　　

1	stu_register("张三", 22, "CN", "python")

　　输出：

1	张三 22 ('CN', 'python')

　　还可以有一个**kwargs

1 2	def stu_register(name, age, *args, **kwargs):   #  *kwargs会把多传入的参数变成一个dict形式     print(name, age, args, kwargs)

　　输出：

1	stu_register("张三", 22, "CN", "python", sex="M", province="湖南")

# 返回值
函数外部的代码要想获取函数的执行结果，就可以在函数里用return语句把结果返回

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

def stu_register(name, age, course='py', country="CN"):     print("注册学生信息".center(20, '-'))     print("姓名", name)     print("age", age)     print("国籍", country)     print("课程", course)     if age > 22:         return False     else:         return True registration_status = stu_register("张三", 22, course="python全栈开发", country="CN") if registration_status:     print("注册成功!") else:     print("注册信息有误!")

　　注意：

• 函数在执行过程中只要遇到return语句，就会停止执行并返回结果
• 如果未在函数中指定retrurn，那这个函数的返回值为None

　　

# 全局和局部变量

1 2 3 4 5 6 7 8 9

name = "张三" def change_name(name):     print("修改前的姓名:", name)     name = "张三买了一辆特斯拉"     print("修改后的姓名:", name) change_name(name) print("在外面看看name改了吗？", name)

　　输出：

1 2 3

修改前的姓名: 张三 修改后的姓名: 张三买了一辆特斯拉 在外面看看name改了吗？ 张三

　　不用传name值到函数里，也可以在函数里调用外面的变量

1 2 3 4 5 6 7 8

name = "张三" def change_name():     name = "张三买了一辆特斯拉"     print("修改后的姓名:", name) change_name() print("在外面看看name改了吗？", name)

　　但就是不能改

• 在函数中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量
• 全局变量作用域是整个程序，局部变量作用域是定义该变量的函数
• 当全局变量与局部变量同名时，在定义局部变量的函数内，局部变量起作用；在其它地方全局变量起作用

作用域

作用域：通常来说，一段程序代码中所用到的名字并不总是有效/可用的，而限定这个名字的可用性的代码范围就是这个名字的作用域。

在函数里修改全局变量

1 2 3 4 5 6 7 8 9 10

name = "张三" def change_name():     global name     name = "张三买了一辆特斯拉"     print("修改后的姓名:", name) change_name() print("在外面看看name改了吗？", name)

1	global name的作用就是要在函数里声明全局变量name，意味着最上面的name=“张三”,即使不写，程序最后面的print也可以打印name

# 嵌套函数

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

name = "张三" def change_name():     name = "张三丰"     def change_name2():         name = "张山峰"         print("张山峰打印:", name)     change_name2()    # 调用内层函数     print("第二层打印:", name) change_name() print("最外层打印:", name)

　　输出：

1 2 3

张山峰打印: 张山峰 第二层打印: 张三丰 最外层打印: 张三

　　匿名函数

匿名函数就是不需要显式的指定函数名

1 2 3 4 5

#这段代码 def calc(x,y):     return x**y print(calc(2,5))

　

1 2 3

#换成匿名函数 calc = lambda x,y:x**y   print(calc(2,5))

　　匿名函数主要是和其它函数搭配使用的

1 2 3

res = map(lambda x:x**2, (1, 5, 7, 4, 8)) for i in res:     print(i)

　　

1 2 3 4 5 6 7

输出 1 25 49 16 64

　　

高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

1 2 3 4 5

def add(x, y, f):     return f(x) + f(y) res = add(3, -6, abs) print(res)

　　

只需满足以下任意一个条件，即是高阶函数

• 接受一个或多个函数作为输入
• return返回另外一个函数

递归

在函数内部，可以调用其它函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。　

1 2 3 4 5 6 7

def calc(n):     print(n)     if int(n/2) ==0:         return n     return calc(int(n/2)) calc(10)

　　

输出

10
5
2
1


修改一下代码实现：

1 2 3 4 5 6 7 8

def calc(n):     v = int(n/2)     print(v)     if v > 0:         calc(v)     print(n) calc(10)

　　

输出

5
2
1
0
1
2
5
10

实现过程：

递归特性：

• 必须有一个明确的结束条件
• 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
• 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减少一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

内置函数

Python的len为什么你可以直接用？肯定是解释器启动时就定义好了

1	几个***钻古怪的内置方法用法提醒

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44

#compile f = open("函数递归.py") data =compile(f.read(),'','exec') exec(data) #print msg = "又回到最初的起点" f = open("tofile","w") print(msg,"记忆中你青涩的脸",sep="|",end="",file=f) # #slice # a = range(20) # pattern = slice(3,8,2) # for i in a[pattern]: #等于a[3:8:2] #     print(i) # # #memoryview #usage: #>>> memoryview(b'abcd') # #在进行切片并赋值数据时，不需要重新copy原列表数据，可以直接映射原数据内存， import time for n in (100000, 200000, 300000, 400000):     data = b'x'*n     start = time.time()     b = data     while b:         b = b[1:]     print('bytes', n, time.time()-start) for n in (100000, 200000, 300000, 400000):     data = b'x'*n     start = time.time()     b = memoryview(data)     while b:         b = b[1:]     print('memoryview', n, time.time()-start) 几个内置方法用法提醒