part5-1 Python 函数(递归函数、参数传递方式、变量作用域、局
发布时间:2020-12-20 10:20:23 所属栏目:Python 来源:网络整理
导读:函数的特点: (1)、使用 def 关键字定义,有函数名。使用 lambda 定义的函数除外。 (2)、一个函数通常执行一个特定任务,可多次调用,因此函数是代码利用的重要手段。 (3)、函数调用时可以传递0个或多个参数。 (4)、函数有返回值。 一、 函数基础 函
函数的特点: 1 def function_name(arg1,arg2,...): 2 # 函数体(由0条或多条代码组成)
3 [return [返回值]]
1 def max_num(x,y): 2 """ 3 获取两个数值中较大数的函数 4 max_num(x,y) 5 返回x、y两个参数之间较大的那个数 6 """ 7 return x if x > y else y 8 # 使用 help() 函数和 __doc__ 属性查看 max_num 的帮助文档 9 help(max_num) 10 print(max_num.__doc__)
1 # 定义函数
2 def foo(x,y) 3 return x + y,x - y 4 # 调用函数
5 a1 = foo(10,5) # 函数返回的是一个元组,变量a1 也就是一个元组
1 def f(n): 2 if n == 0: 3 return 1
4 elif n == 1: 5 return 4
6 else: 7 # 在函数体内调用其自身,就是递归函数
8 return 2 * f(n - 1) + f(n - 2) 9
10 print(f(10)) # 输出:10497
1 def f(n): 2 if n == 20: 3 return 1
4 elif n == 21: 5 return 4
6 else: 7 return f(n + 2) - 2 * f(n + 1) 8 print(f(10)) # 输出:-3771
1 # 定义一个计算周长的函数 girth,接收两个形参
2 def girth(length,width): 3 print("length:",length) 4 print("width:",width) 5 return 2 * (length + width) 6 # 传统调用函数方式,根据位置传入参数值
7 print(girth(3,5.5)) 8 # 根据关键字参数传入参数值,使用关键字时,参数位置可以交换
9 print(girth(width=5.5,length=3)) 10 # 部分用关键字,部分用位置参数,位置参数必须在关键字参数前面
11 print(girth(3,width=5.5))
1 # 为参数指定默认值
2 def say_hi(name=‘michael‘,message="欢迎学习使用Python!"): 3 print("hello,",name) 4 print("消息是:",message,sep="") 5 # 第一次调用:使用默认参数调用函数
6 say_hi() 7 # 第二次调用:传入1个位置参数时,默认传给第一个参数
8 say_hi(‘jack‘) 9 # 第三次调用:传入2个位置参数
10 say_hi(‘stark‘,‘欢迎使用 C 语言!‘) 11 # 使用关键字参数指明要传给哪个参数
12 say_hi(message="欢迎使用 Linux 系统!") 13
14 输出如下所示: 15 hello,michael 16 消息是:欢迎学习使用Python! 17 hello,jack 18 消息是:欢迎学习使用Python! 19 hello,stark 20 消息是:欢迎使用 C 语言! 21 hello,michael 22 消息是:欢迎使用 Linux 系统!
1 def foo(a,b=10): pass # 有默认值的参数在没有默认值的参数后面
2 下面这些调用函数的方法都是正确的: 3 foo(5) 4 foo(a=5,b=4) 5 foo(5,4) 6 foo(a=‘python‘)
1 def my_test(a,*args): 2 """测试支持参数收集的函数"""
3 print(args) 4 # args 参数被当成元组处理
5 for s in args: 6 print(s) 7 print(a) 8 my_test(123,‘python‘,‘linux‘,‘C‘) 9
10 输出如下所示: 11 (‘python‘,‘C‘) 12 python 13 linux 14 C 15 123
1 def bar(a,b,c=5,*args,**kwargs): pass 2 bar(1,2,3,"python","linux",name=stark,age=30)
1 def bar(s1,s2): 2 print(s1) 3 print(s2) 4 s = ‘ab‘
5 bar(*s) 6 ss = ("python","linux") 7 bar(*ss) 8 ss_dict = {"s1": "michael","s2": 25} 9 bar(**ss_dict)
1 def bar(s1,*s2): 2 print(s1) 3 print(s2) 4 s = ‘abcd‘
5 bar("py",*s) 6 ss = ("python","linux") 7 bar("java",*ss)
1 def swap(a,b): 2 a,b = b,a 3 print("在swap函数里,a的值是%s; b 的值是%s" % (a,b)) 4 a = 10
5 b = 20
6 swap(a,b) 7 print("变换结束后,变量 a 的值是%s;变量 b 的值是%s。" % (a,b)) 8
9 运行代码,输出如下: 10 在swap函数里,a的值是20; b 的值是10 11 变换结束后,变量 a 的值是10;变量 b 的值是20。
1 def test(): 2 name = ‘michael‘
3 print(name) # 输出:michael
4 # 访问函数局部范围内的”变量字典“
5 print(locals()) # 输出:{‘name‘: ‘michael‘}
6 # 通过函数局部范围内的”变量数组“访问 name 变量
7 print(locals()[‘name‘]) # 输出:michael
8 # 通过 locals() 函数修改局部变量的值,即使修改了也不会对局部变量有什么影响
9 locals()[‘name‘] = ‘stark‘
10 # 再次访问 name 变量的值
11 print("modify: ",locals()[‘name‘]) # 输出:modify: michael
12 # 通过 globlas() 函数修改全局变量 x 的值
13 globals()[‘x‘] = 10
14 x = 1
15 y = 2
16 # 在全局范围内调用 globals() 函数和 locals() 函数,访问的是全局变量的”变量字典",两个函数输出的结果一样
17 print(globals()) # 输出:{...,‘x‘: 1,‘y‘: 2}
18 print(locals()) # 输出:{...,‘y‘: 2}
19 # 在全局范围内直接使用 globlas 和 locals 函数访问全局变量
20 print(globals()[‘x‘]) # 输出:1
21 print(locals()[‘x‘]) # 输出:1
22 # 在全局范围地内使用 globlas 和 locals 函数修改全局变量的值
23 globals()[‘x‘] = 30
24 locals()[‘y‘] = 20
25 # 从输出可知,在全局范围内,使用 globlas 和 locals 函数修改全局变量的值都会修改成功
26 print("modify: ",globals()[‘x‘]) # modify: 30
27 print("modify: ",locals()[‘y‘]) # modify: 20
28
29 test() # 在函数内部使用 globals 函数修改全局变量的值也会修改成功
30 print("modify two: ",globals()[‘x‘]) # modify two: 10
1 name = ‘michael‘ 2 def test(): 3 # 直接访问 name 的全局变量 4 print(name) 5 name = ‘stark‘ 6 test()
1 name = ‘michael‘ 2 def test(): 3 # 直接访问 name 的全局变量 4 print(globals()[‘name‘]) # 输出:michael 5 name = ‘stark‘ # 定义局部变量 6 test() 7 print(name) # 输出:michael
1 name = ‘michael‘ 2 def test(): 3 # 先声明 name 是全局变量,后面的赋值语句不会重新定义局部变量,而是直接修改全局变量 4 global name 5 # 直接访问 name 全局变量 6 print(name) # 输出:michael 7 name = ‘stark‘ # 修改全局变量 8 test() 9 print(name) # 输出:stark
1 def foo(type,nn): 2 """定义一个函数,该函数包含局部函数"""
3 def square(n): 4 """定义一个计算平方的局部函数"""
5 return n * n 6 def cube(n): 7 """定义一个计算立方的局部函数"""
8 return n * n * n 9 def factorial(n): 10 """定义一个计算阶乘的局部函数"""
11 result = 1
12 for i in range(2,n + 1): 13 result *= i 14 return result 15 # 调用局部函数
16 if type == ‘square‘: 17 return square(nn) 18 elif type == ‘cube‘: 19 return cube(nn) 20 else: 21 return factorial(nn) 22 print(foo(‘square‘,5)) # 输出:25
23 print(foo(‘cube‘,3)) # 输出:27
24 print(foo(‘‘,3)) # 输出:6
1 def foo(): 2 # 局部变量 name
3 name = ‘michael‘
4 def bar(): 5 # 访问 bar 函数所在 foo 函数内的 name 局部变量
6 print(name) # michael
7 name = ‘stark‘
8 bar() 9 foo()
运行这段代码,出现错误提示“UnboundLocalError: local variable ‘name‘ referenced before assignment”。这错误是由于局部变量遮蔽局部变量导致的,在 bar() 函数中定义的 name 局部变量遮蔽了它所在 foo() 函数内的 name 局部变量,因此导致程序中 print 语句代码报错。 1 def foo(): 2 # 局部变量 name
3 name = ‘michael‘
4 def bar(): 5 # 访问 bar 函数所在 foo 函数内的 name 局部变量
6 nonlocal name 7 print(name) # michael
8 name = ‘stark‘
9 bar() 10 foo()
在 foo() 函数内增加 “nonlocal name” 语句后,在 bar() 函数中的 “name = ‘stark‘” 就不再是定义新的局部变量,而是访问它所在函数(foo())内的 name 局部变量。 (编辑:李大同) 【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容! |