#Python函数
一、函数介绍
在我们以往的学习编程的过程当中,碰到的最多的两张编程方式或者说编程方法:面向过程和面向对象。其实不管是哪一种,其实都是编程的方法论而已。但是现在有一种更古老的编程方式:函数式编程,以它的不保存的状态,不修改变量等特性,重新进入我们的视野。
- 面向对象 --->类 ---->class
- 面向过程 --->过程--->def
- 函数式编程-->函数--->def
二、函数定义
我们上初中那会也学过函数,即:y=2x,说白了,这里面总共就两个变量x和y,x是自变量,y是因变量(因为x变而变),y是x的函数。自变量的取值范围,叫做这个函数的定义域。
说了这么多,我们还是来讲讲,编程中的函数定义吧!!!
1、函数定义:
def test(): "the funcation details" print("in the test funcation") return 0 def #定义函数的关键字 test #函数名 () #定义形参,我这边没有定义。如果定义的话,可以写成:def test(x): 其中x就是形式参数 "the funcation details" # 文档描述(非必要,但是强烈建议你为你的函数添加详细信息,方便别人阅读) print #泛指代码块或者程序逻辑处理 return #定义返回值
2、过程定义:
#定义过程 def test_2(): "the funcation details" print("in the test funcation")
注:从上面两个例子看出来,函数和过程,无非就是函数比过程多了一个return的返回值,其他的也没什么不一样。
3、两者比较:
#定义函数 def test_1(): "the funcation details" print("in the test funcation") return 0 #定义过程 def test_2(): "the funcation details" print("in the test funcation") a = test_1() b = test_2() print(a) print(b) #输出 in the test funcation in the test funcation #输出返回值 0 #没有return ,返回为空 None
小结:不难看出,函数和过程其实在python中没有过多的界限,当有return时,则输出返回值,当没有return,则返回None
三、使用函数原因
至此、我们已经了解了函数,但是我们为啥要用函数啊,我觉的我们以前的那种写法挺好的呀!其实不然,我给使用函数总结 了两点好处:
- 代码重复利用
- 可扩展性
- 保持一致性
1、代码重复利用
我们平时写代码的时候,最讨厌的就是写重复代码,这个无疑是增加我们的工作量,所以代码重用性是非常有必要的。下面我们就举个简单的例子吧,使用函数和不使用函数的区别。
①优化前
#假设我们编写好了一个逻辑(功能),用来打印一个字符串 print("高高最帅") #现在下面有2个函数,每个函数处理完了,都需要使用上面的逻辑,那么唯一的方法就是拷贝2次这样的逻辑 def test_1(): "the funcation details" print("in the test1") print("高高最帅") def test_2(): "the funcation details" print("in the test2") print("高高最帅")
那么假设有n个函数,我们是不是也要拷贝n次呐?于是,我们就诞生了下面的方法
②优化后
def test(): print("高高最帅") def test_1(): "the funcation details" print("in the test1") test() def test_2(): "the funcation details" print("in the test2") test()
2、可扩展,代码保持一致性
#代码逻辑变了 def test(): print("高高一直都很帅") def test_1(): "the funcation details" print("in the test1") test() def test_2(): "the funcation details" print("in the test2") test()
注:如果遇到代码逻辑变了,用以前拷贝n次的方法,那什么时候拷贝完啊,而且中间有遗漏怎么办,如果用了函数,我们只需要改这个函数的逻辑即可,不用改其他任何地方。
四、返回值
之前在day3-函数介绍中提到了return关键字,但是那个只是提到,并没有详细的介绍的return关键字的用法,下面我们就来详细的阐述一下。
1、return作用
return其实有两个作用:
- 需要用一个变量来接受程序结束后返回的结果
- 它是作为一个结束符,终止程序运行
def test(): print("in the test_1") return 0 print("the end") #结果中没有打印 x = test() print(x) #输出 in the test_1 #第一次打印 0 #结果返回值
注:从上面的代码可以看出,return 0后面的代码就不执行了,只执行return前面的代码;变量x接受了test()函数结束后的返回结果
2、返回多个值
上面我们试了返回一个常量值,或者说一个对象值,下面我们来试试,不返回值,或者说返回多个值得情况
# __auther__ == zhangqigao def test_1(): print("in the test_1") def test_2(): print("in the test_2") return 0 def test_3(): print("in the test_3") return 1,"hello",["qigao","shuaigao"],{"name":"qigao"} x = test_1() y = test_2() z =test_3() print(x) print(y) print(z) #输出 in the test_1 in the test_2 in the test_3 None #x的值 0 #y的值 (1, 'hello', ['qigao', 'shuaigao'], {'name': 'qigao'}) #z的值
从上面的例子可以看出:
- 没有定义,返回值数=0,返回:None
- 只定义了1个返回值,返回值=1 ,返回:定义的那个值,或者说定义的那个object
- 定义了2个以上,返回值 > 1,返回:1个元组(tuple)
提问:这边我们不经意的要问,为什么要有返回值?
因为我们想要想要这个函数的执行结果,这个执行结果会在后面的程序运行过程中需要用到。
五、有参数函数调用
在此之前,我们演示的函数都是没有带参数的,下面我们就来说说带参数的函数。在讲之前,我们先来说一下,什么是形参,什么是实参吧!
- 形参:指的是形式参数,是虚拟的,不占用内存空间,形参单元只有被调用的时才分配内存单元
- 实参:指的是实际参数,是一个变量,占用内存空间,数据传递单向,实参传给形参,形参不能传给实参
代码如下:
def test(x,y): #x,y是形参 print(x) print(y) test(1,2) #1和2是实参 #输出 1 2
1、位置参数
从上面的例子可以看出,实际参数和形式参数是一一对应的,如果调换位置,x和y被调用的时,位置也会互换,代码如下:
def test(x,y): print(x) print(y) print("--------互换前-----") test(1,2) print("--------互换后-----") test(2,1) #输出 --------互换前----- 1 2 --------互换后----- 2 1
那有些同学会说,那我多一个或者少一个参数,总归没事了吧!那我看看行不行呢?
①多一个参数
def test(x,y): print(x) print(y) print("--------多一个参数----") test(1,2,3) #输出 --------多一个参数---- Traceback (most recent call last): File "D:/PycharmProjects/pyhomework/day3/函数_带参数.py", line 8, in <module> test(1,2,3) TypeError: test() takes 2 positional arguments but 3 were given #test()函数需要传两个实参,你传了三个实参
②少一个参数
def test(x,y): print(x) print(y) print("--------少一个参数----") test(1) #输出 --------少一个参数---- Traceback (most recent call last): File "D:/PycharmProjects/pyhomework/day3/函数_带参数.py", line 8, in <module> test(1) TypeError: test() missing 1 required positional argument: 'y' #没有给y参数传实参
事实证明:多传一个参数或者少传一个参数都是不行的。
2、关键字参数
到这边有些小伙伴不经意的要说,像这种位置参数,有点死,我不想这么干,万一我传错了咋办,对吧!OK,没有问题,下面我们就来讲讲关键字传参。
关键字传参不需要一一对应,只需要你指定你的哪个形参调用哪一个实参即可,代码如下:
def test(x,y): print(x) print(y) print("--------互换前------") test(x=1,y=2) print("--------互换后------") test(y=2,x=1) #输出 --------互换前------ 1 2 --------互换后------ 1 2
但是,这是又有小伙伴要问了,那我可不可以位置参数和关键字参数结合起来用呐?接下来,我们就来探讨一下。
①位置参数在前,关键字参数在后
def test(x,y): print(x) print(y) test(1,y=2) #输出 1 2
我擦这样是可以的,那我试试这种情况,我把后面关键字不传给y,我传给x,代码如下:
def test(x,y): print(x) print(y) test(1,x=2) #输出 Traceback (most recent call last): File "D:/PycharmProjects/pyhomework/day3/函数_带参数.py", line 8, in <module> test(1,x=2) TypeError: test() got multiple values for argument 'x' #给x形参传的值过多
报错的意思是:给形参x传的值过多。这种报错的原因是:实参1已经传给了形参x,后面的x=2又传了一次,所以报错。
②关键字在前,位置参数在后
def test(x,y): print(x) print(y) test(y=2,1) #输出 File "D:/PycharmProjects/pyhomework/day3/函数_带参数.py", line 8 test(y=2,1) ^ SyntaxError: positional argument follows keyword argument # 关键字参数在位置参数的前面
我去,看来这样不行。那我位置参数放前面,中间放关键字参数总行了吧!代码如下:
def test(x,y,z): print(x) print(y) test(1,y=2,3) #输出 File "D:/PycharmProjects/pyhomework/day3/函数_带参数.py", line 8 test(1,y=2,3) ^ SyntaxError: positional argument follows keyword argument
还是一样的错误,我去,那我只能把关键字参数放最后试试!
def test(x,y,z): print(x) print(y) print(z) test(1,2,z=3) #输出 1 2 3
那我最后两个用关键字参数呐?
def test(x,y,z): print(x) print(y) print(z) test(1,z=2,y=3) #输出 1 3 2
这样也是可以的,所以,得出一个结论:关键字参数是不能写在位置参数前面的。
总结:
- 既有关键字,又有位置参数时,是按位置参数的顺序来
- 关键字参数是不能写在位置参数的前面的
六、默认参数
默认参数指的是,我们在传参之前,先给参数制定一个默认的值。当我们调用函数时,默认参数是非必须传递的。
def test(x,y=2): print(x) print(y) print("-----data1----") test(1) #没有给默认参数传值 print("-----data2----") test(1,3) #给默认参数传位置参数 print("-----data3----") test(1,y=3) #给默认参数传关键字参数 #输出 -----data1---- 1 2 -----data2---- 1 3 -----data3---- 1 3
默认参数用途:
- 安装默认软件(def test(x,soft=True))
- 传递一下默认的值(定义mysql的默认端口号:def count(host,port=3306))
七、参数组(非固定参数)
之前我们传参数,都是传一个固定参数,不能多也不能少,但是如果说我们需要非固定参数怎么办呢?好吧,于是就衍生出了,以下两种传参方式:
- 非固定位置参数传参(*args)
- 非固定关键字传参(**kwargs)
下面我们就来说说这两种方式传参:
1、非固定位置参数传参
①功能:接收N个位置参数,转换成元组的形式。
②定义,代码如下:
def test(*args): #形参必须以*开头,args参数名随便定义,但是最好按规范来,定义成args print(args) test(1,2,3,4,5) #输入多个位置参数 #输出 (1, 2, 3, 4, 5) #多个参数转换成元组
这边不禁的有个疑问,你这是传入的都是N个位置参数,那我要传入一整个列表咋办,我要完全的获取这个列表的值。
③传入列表
def test(*args): print(args) print("-------data1-----") test() #如果什么都不传入的话,则输出空元组 print("-------data2-----") test(*[1,2,3,4,5]) #如果在传入的列表的前面加*,输出的args = tuple([1,2,3,4,5]) print("-------data3-----") test([1,2,3,4,5]) #如果再传入的列表前不加*,则列表被当做单个位置参数,所以输出的结果是元组中的一个元素 #输出 -------data1----- () -------data2----- (1, 2, 3, 4, 5) -------data3----- ([1, 2, 3, 4, 5],)
④位置参数和非固定位置参数
def test(x,*args): print(x) #位置参数 print(args) #非固定参数 test(1,2,3,4,5,6) #输出 1 (2, 3, 4, 5, 6)
从上面看出,第1个参数,被当做位置参数,剩下的被当做非固定位置参数。
⑤关键字和非固定位置参数
def test(x,*args): print(x) print(args) test(x=1,2,3,4,5,6) #输出 File "D:/PycharmProjects/pyhomework/day3/非固定参数/非关键字参数.py", line 21 test(x=1,2,3,4,5,6) ^ SyntaxError: positional argument follows keyword argument #位置参数在关键字参数后面
很显然报错了,因为x=1是关键字参数,*args是位置参数,而关键字参数不能再位置参数前面的,所以报错。
2、非固定关键字传参
①功能:把N个关键字参数,转换成字典形式
②定义,代码如下:
def test(**kwargs): #形参必须以**开头,kwargs参数名随便定义,但是最好按规范来,定义成kwargs print(kwargs) test(name="qigao",age=18) #传入多个关键字参数 #输出 {'name': 'qigao', 'age': 18} #多个关键字参数转换成字典
③传入字典
def test(**kwargs): print(kwargs) test(**{"name":"qigao","age":18}) #传入字典时,一定要在字典前面加**,否则就会报错 #输出 {'name': 'qigao', 'age': 18}
然而,有些小伙伴说,我就不信,难道不加**,就会报错,那为啥非固定位置参数不加*,为啥就不报错呐?下面我们就用事实说话,代码如下:
def test(**kwargs): print(kwargs) test({"name":"qigao","age":18}) #输出 Traceback (most recent call last): File "D:/PycharmProjects/pyhomework/day3/非固定参数/非固定关键字参数.py", line 9, in <module> test({"name":"qigao","age":18}) TypeError: test() takes 0 positional arguments but 1 was given #报类型错误,传入的是位置参数
因为传入的字典被当做位置参数,所以被报类型错误,所以小伙伴们千万要记住:传字典,加**
④配合位置参数使用
def test(name,**kwargs): print(name) print(kwargs) print("------data1-----") test("qigao") #1个位置参数 print("------data2------") test("qigao",age=18,sex="M") #1个位置参数,两个关键字参数 print("------data3------") test(name="qigao",age=18,sex="M") #3个关键字参数 #输出 ------data1----- qigao #输出1个位置参数 {} #没有输入关键字参数,所以输出空字典 ------data2------ qigao #第1个位置参数 {'age': 18, 'sex': 'M'} #剩下关键字参数,转换成1个字典 ------data3------ qigao #第1个关键字参数 {'age': 18, 'sex': 'M'} #剩下的关键字参数,转换成1个字典
⑤位置参数、关键字和非固定关键字参数
提示:参数组一定要往最后放
def test(name,age=18,**kwargs): print(name) print(age) print(kwargs) print("----------data1--------") test("qigao",sex='M',hobby='tesl') print("----------data2--------") test("qigao",34,sex='M',hobby='tesl') print("----------data3--------") test("qigao",sex='M',hobby='tesl',age=34) #age关键字参数放到最后,也可以的 #输出 ----------data1-------- qigao 18 #不传,显示默认参数 {'sex': 'M', 'hobby': 'tesl'} ----------data2-------- qigao 34 #传位置参数 {'sex': 'M', 'hobby': 'tesl'} ----------data3-------- qigao 34 #关键字参数,放在前后并没有影响 {'sex': 'M', 'hobby': 'tesl'}
注:就是说,如果遇到一个关键字传参和非固定关键字传参,前后放的位置是不影响传参的,但是我们一般还是按顺序来。
⑥位置参数、关键字参数、非固定位置参数和非固定关键字参数
def test(name,age=18,*args,**kwargs): print(name) print(age) print(args) print(kwargs) print("-------第1种传参--------") test("qigao",19,1,2,3,4,sex="m",hobby="tesla") print("-------第2种传参--------") test("qigao",19,*[1,2,3,4],**{'sex':"m",'hobby':"tesla"}) #输出 -------第1种传参-------- qigao #传name位置参数 19 #给age传位置参数 (1, 2, 3, 4) #非固定位置参数,以转换成元组 {'sex': 'm', 'hobby': 'tesla'} # 非固定关键字参数,转换成字典 -------第2种传参--------- qigao 19 (1, 2, 3, 4) #以列表的形式传入,在列表前加* {'sex': 'm', 'hobby': 'tesla'} #以字典的形式传入,在字典前加**
那么问题来了,上面的age传参传的是位置参数,那我能不能传关键字参数呐?现在我们就来看看,代码如下:
def test(name,age=18,*args,**kwargs): print(name) print(age) print(args) print(kwargs) test("qigao",age=19,1,2,3,4,sex="m",hobby="tesla") #输出 File "D:/PycharmProjects/pyhomework/day3/非固定参数/非固定关键字参数.py", line 55 test("qigao",age=19,1,2,3,4,sex="m",hobby="tesla") ^ SyntaxError: positional argument follows keyword argument #语法错误,位置参数在关键字参数前面
看来是不可以的,为什么?因为age=19是关键字参数,而后面的*args是非固定位置参数,说白了不管*args传入几个字,它的本质都是位置参数,上面我们提到关键字参数是不能再位置参数的前面,所以报错了。
看来上面的情况是不可以的,那能不能非固定关键字参数在非固定位置参数前面呢?来,我们带着疑问一起来试一下。代码如下:
def test(name,age=18,*args,**kwargs): print(name) print(age) print(args) print(kwargs) test("qigao",19,sex="m",hobby="tesla",1,2,3,4,5) #输出 File "D:/PycharmProjects/pyhomework/day3/非固定参数/非固定关键字参数.py", line 57 test("qigao",19,sex="m",hobby="tesla",1,2,3,4,5) ^ SyntaxError: positional argument follows keyword argument #语法错误,关键字参数在位置参数前面
我擦咧,也是不可以的,经我仔细研究发现,非固定关键字参数,本质也是关键字参数,是不能放在非固定位置参数的前面的。
总结
- 参数分为位置参数、关键字参数、默认参数、非固定位置参数和非固定关键字参数
- 位置参数之前传参,位置是不能调换的,多一个或者少一个参数都是不可以的。
- 关键字参数是不能放在位置参数前面的。
- 函数传参的位置一次是,位置参数,默认参数、非固定位置参数、非固定关键字参数(def test(name,age=18,*args,**kwargs))
- 关键字传参,可以不用考虑位置的前后问题
八、作用域、局部变量、全局变量
我们之前写代码,都需要声明变量,但是我们思考过变量的作用范围吗?今天我们就来讲讲变量的作用范围,这个作用范围又叫作用域。首先我们根据变量的作用范围把变量分为:局部变量和全局变量,即:
- 局部变量
- 全局变量
我们先做一个小实验:一个函数体内部调用另外一个函数,代码如下:
def test(name,age=18,**kwargs): print(name) print(age) print(kwargs) logger("test") #调用logger函数 def logger(sounce): print("from %s"%sounce)
①logger函数之后执行
def test(name,age=18,**kwargs): print(name) print(age) print(kwargs) logger("test") def logger(sounce): print("from %s"%sounce) test("qigao",age=23,sex="m",hobby="tesla") #在logger函数之后调用 #输出 qigao 23 {'hobby': 'tesla', 'sex': 'm'} from test
ok,很完美,一点问题都没有,那么还有一种情况,就是在logger函数之前调用呐?
②logger函数之前执行
def test(name,age=18,**kwargs): print(name) print(age) print(kwargs) logger("test") test("qigao",age=23,sex="m",hobby="tesla") #在logger函数之前调用 def logger(sounce): print("from %s"%sounce) #输出 qigao 23 {'hobby': 'tesla', 'sex': 'm'} Traceback (most recent call last): File "D:/PycharmProjects/pyhomework/day3/局部变量和全局变量/test.py", line 12, in <module> test("qigao",age=23,sex="m",hobby="tesla") File "D:/PycharmProjects/pyhomework/day3/局部变量和全局变量/test.py", line 10, in test logger("test") NameError: name 'logger' is not defined #命名错误:logger没有被定义
很显然是出错的,为什么呢?我不是定义了logger函数了吗?喔。。。。。。原来在logger函数之前执行,logger函数还没有被读到内存中,所以报错。
1、局部变量
局部变量:顾名思义,指在局部生效,定义在函数体内的变量只能在函数里面生效,出个这个函数体,就不能找到它,这个函数就是这个变量的作用域。
下面我们就用事实说话吧,请看如下代码:
def test(name): print("before change:",name) name = "qigao" #局部变量name,只能在这个函数内生效,这个函数就是这个变量的作用域 print("after change:",name) name = "alex" print("-----调用test-----") test(name) print("------打印name----") print(name) #输出 -----调用test----- before change: alex after change: qigao #局部变量生效 ------打印name---- alex
2、全局变量
有了局部变量,那就肯定有全局变量,那什么是全局变量呐?全局变量又改怎么定义呢?
全局变量:指的是在整个程序中都生效的变量,在整个代码的顶层声明。
代码如下:
school = "leidu edu" #定义全局变量 def test_1(): print("school:",school) def test_2(): school = "qigao linux " print("school:",school) print("------test_1----") test_1() print("------test_2----") test_2() print("----打印school--") print("school:",school) #输出 ------test_1---- school: leidu edu #打印的是全局变量 ------test_2---- school: qigao linux #打印局部变量 ----打印school-- school: leidu edu #打印全局变量
从上面的例子可看出全局变量的优先级是低于局部变量的,当函数体内没有局部变量,才会去找全局变量。但是有的同学会问了,那我需要在函数体内修改全局变量咋办呢?
①函数里面修改全局变量
- 改前用global先声明一下全局变量
- 将全局变量重新赋值
school = "leidu edu" #定义全局变量 def test(): global school #用global关键字声明全局变量 school = "qigao linux " #将全局变量重新赋值 print("school:",school) print("------test_2----") test() print("----打印school--") print("school:",school) #输出 ------test_2---- school: qigao linux ----打印school-- school: qigao linux #全局变量被改掉
②只在函数里面声明全局变量
def test(): global school #只在里面定义全局变量 school = "qigao linux" print("school:",school) print("--------test-------") test() print("-----打印school----") print("school:",school) #输出 --------test------- school: qigao linux -----打印school---- school: qigao linux
也是可以的,但是我们最好不要用以上2种情况,也就是说最好不要用global这个关键字,因为你用了,其他人调你的函数时,就乱套了,而且还不好调试,说不定还冒着被开除的危险,所以请大家忘记它吧,只是知道有这么一个东西就行了。
③修改列表
names = ['alex',"qigao"] #定义一个列表 def test(): names[0] = "金角大王" print(names) print("--------test-----") test() print("------打印names--") print(names) #输出 --------test----- ['金角大王', 'qigao'] #函数内的names输出 ------打印names-- ['金角大王', 'qigao'] #函数外的names输出
从上面的例子可以看出,列表names被当做在函数中全局变量,重新赋值了,是可以被修改的。
小结:1、只有字符串和整数是不可以被修改的,如果修改,需要在函数里面声明global。2、但是复杂的数据类型,像列表(list)、字典(dict)、集合(set),包括我们后面即将要学的类(class)都是可以修改的。
总结
- 在子程序(函数)中定义的变量称为局部变量,在程序一开始定义的变量称为全局变量。
- 全局变量的作用域是整个程序,局部变量的作用域是定义该变量的子程序(函数)。
- 当全局变量和局部变量同名时:在定义局部变量的子程序内,局部变量起作用;在其他地方,全局变量起作用。
九、匿名函数、eval()函数
1.匿名函数
也叫 lambda 表达式
a.匿名函数的核心:一些简单的需要用函数去解决的问题,匿名函数的函数体只有一行
b.参数可以有多个,用逗号隔开
c.返回值和正常的函数一样可以是任意的数据类型
d.匿名函数不支持复杂的逻辑判断
e.一般跟其他函数搭配使用,如map()、filter()
#这段代码 def calc(x,y): return x**y print(calc(2,5)) #换成匿名函数 calc = lambda x,y:x**y print(calc(2,5)) #输出 32
你也许会说,用上这个东西没感觉有毛方便呀, 。。。。呵呵,如果是这么用,确实没毛线改进,不过匿名函数主要是和其它函数搭配使用的呢,如下
res = map(lambda x:x**2,[1,5,7,4,8]) for i in res: print(i) #输出 1 25 49 16 64
2.eval()函数
在我们使用一些类似于字典的字符串时,虽然它看起来很像字典,但是在它的最外层多了引号,说明它是字符串,但是我们如何把它转换成字典呐,这就用到了eval()函数,看看eval()函数是如何把字符串转换成字典的,下面就来看看见证奇迹的时刻:
#定义一个类似于字典的字符串,把值赋给arg >>> arg = '''{ 'backend': 'www.oldboy.org', 'record':{ 'server': '100.1.7.9', 'weight': 20, 'maxconn': 30 } }''' #这边根据键取值报错,说明它是一个字符串,不是字典 >>> arg["backend"] Traceback (most recent call last): File "<input>", line 1, in <module> TypeError: string indices must be integers #通过eval()函数把字符串转成字典 >>> arg = eval(arg) #显示的类型是字典 >>> type(arg) <class 'dict'> >>> arg {'record': {'server': '100.1.7.9', 'weight': 20, 'maxconn': 30}, 'backend': 'www.oldboy.org'} #通过键能获取对应的值,说明字符串成功转成字典 >>> arg["backend"] 'www.oldboy.org'
十、递归
定义:递归调用是函数嵌套调用的一种特殊形式,如果一个函数在内部直接或间接调用自身,这个函数就是递归函数。
场景:用10不断除以2,直到除不尽为止,打印每次结果。
思路:
# 10/2=5 # 5/2=2.5 # 2.5/2=1.25 # ...
用while循环实现:
n = 10 while True: n = int(n/2) print(n) if n == 0: break #输出 5 2 1 0
非递归方式实现:
def calc(n): n = int(n/2) return n r1 = calc(10) r2 = calc(r1) r3 = calc(r2) r4 = calc(r3) print(r1) print(r2) print(r3) print(r4) #输出 5 2 1 0
用递归实现:
def calc(n): print(n) if int(n/2) == 0: #结束符 return n return calc(int(n/2)) #调用函数自身 m = calc(10) print('----->',m) #输出 10 5 2 1 -----> 1 #最后返回的值
来看实现过程,我改了下代码
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
为什么输出结果是这样?
递归层数:
import sys print(sys.getrecursionlimit()) # 默认递归限制层数 sys.setrecursionlimit(1500) # 修改递归层数
尾递归优化:
调用下一层时候退出。(解决栈溢出的问题,每次只保留当前递归的数据),在C语音里有用,Python中没用。
def recursion(n): print(n) return recursion(n+1) recursion(1)
递归特性:
(1)递归就是在过程或者函数里调用自身
(2)在使用递归策略时,必须有一个明确的结束条件,称为递归出口
(3)每次进入更深一层递归时,问题规模相比上次递归都应有所减少(问题规模:比如你第1次传进的是10,第2次递归应该是9...依次越来越少,不能越来越多)。
(4)递归算法解题通常显得很简洁,但递归效率不高,递归层次过多会导致栈溢出(在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出),所以一般不倡导使用递归算法设计程序。
堆栈扫盲http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html
递归有什么用呢?下面讲几个实例
1.用递归实现1+2+3...+100
def calc(n): if n > 0: return n + calc(n-1) if n == 0: return 0 print(calc(100))
2.用递归实现阶乘(就是大于等于1的自然数相乘,1*2*3*4*5*...)
我们知道n! = n *(n-1)! 那么我们可以用递归来实现阶乘,下面计算一下5的阶乘
def factorial(n): if n == 1: return 1 return n * factorial(n-1) print(factorial(5)) #输出 120
3.二分查找
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#!/usr/bin/env python # -*- coding:utf-8 -*- """ @Version: v1.0 @Author: wushuaishuai @Contact: 434631143@qq.com @File: 2018-06-20.py @Time: 2018/06/20 15:06 """ """ 1.二分查找练习,所用知识点,函数、递归、高亮显示文字 (1).首先判断列表长度是否>1,>1的情况下再去设置一个变量mid为列表总长度的1/2长度,mid=int(len(dataset)/2) (2).设置完mid后,比较列表的中间的数字(dataset[mid])和要查找的数字(find_num)的关系 (3).data[mid] == find_num时,返回查找的数字 data[mid] > find_num时,返回列表在data[mid]的左边,并return binary_search(dataset[0:mid],find_num) data[mid] < find_num时,返回列表在data[mid]的右边,并return binary_search(dataset[mid+1:],find_num) (4).dataset列表经过上面的不断递归,列表越来越短,最终列表长度变成1,设置会变成空列表,此时先判断dataset是否为空 为空时返回查找的数字不在列表中,再判断dataset[0] == find_num, 当相等时,返回查找的数字,否则返回查找的数字不在列表中。 """ data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35] def binary_search(dataset, find_num): """ :param dataset: 检索的数据集合,eg.列表 :param find_num: 查找的数字 eg.32 :return: 数字查找过程以及最终数字 """ if len(dataset) > 1: mid = int(len(dataset) / 2) # 注意浮点数要转为int # print("mid",mid) # print("len(dataset)",len(dataset)) # print("dataset",dataset) if dataset[mid] == find_num: print("你要查找的数字是%s" % (find_num)) elif dataset[mid] > find_num: print("\033[31;1m你要查找的数字在%s左边\033[0m" % (dataset[mid])) # 31是红色 return binary_search(dataset[0:mid], find_num) # 递归查找,顾头不顾尾,此处mid不用加1 else: print("\033[32;1m你要查找的数字在%s右边\033[0m" % (dataset[mid])) # 32是绿色 return binary_search(dataset[mid + 1:], find_num) # 顾头不顾尾,mid要加1,不包含mid本身 else: # dataset列表通过上面的不断递归,列表越来越短,最终列表长度会变成1,甚至变为空列表 if not dataset: # dataset为空 print("没的分了,你要的数字%s不在这个列表中" % (find_num)) elif dataset[0] == find_num: print("你要查找的数字是%s" % (find_num)) else: print("没的分了,你要的数字%s不在这个列表中" % (find_num)) num = int(input("请输入你要查找的数字>>>")) # input接收的都是字符串,要int一下 binary_search(data, num)
递归算法一般用于解决三类问题:
(1)数据的定义是按递归定义的。(比如Fibonacci函数)
(2)问题解法按递归算法实现。(回溯)
(3)数据的结构形式是按递归定义的。(比如树的遍历,图的搜索,二分法查找等)
十一、内置函数
Python的len为什么你可以直接用?肯定是解释器启动时就定义好了
内置参数详解 https://docs.python.org/3/library/functions.html?highlight=built#ascii
几个***钻古怪的内置方法用法提醒
#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') #<memory at 0x104069648> #在进行切片并赋值数据时,不需要重新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)