python3函数

一.函数

1.样例一

>>> def Mysecondfun(name):
	print('Hello，')
	print(name)
	print('你好')

>>> Mysecondfun('xiaojiayu')
Hello，
xiaojiayu
你好

2.有返回值的函数

>>> def addfun(num1,num2):
	result=num1+num2;
	print('Hello')
	return result

>>> p=addfun(3,4)
Hello
>>> p
7

3.含参函数，参数文档

>>> def Mythirdfun(name):
	'函数定义过程中的name是叫形参'
	#因为Ta只是一个形式，表示占据一个参数位置
	print('传递进来的 '+name+'叫做实参，因为Ta是具体的参数值')

>>> Mythirdfun('xioajiayu')
传递进来的 xioajiayu叫做实参，因为Ta是具体的参数值
>>> Mythirdfun.__doc__
'函数定义过程中的name是叫形参'
>>> 

函数文档：对函数的参数，意义等进行描述，方便别人的查看和调试

4.函数参数的顺序

>>> def Helloworld(name,word):
	print(name+' , '+word)
	
>>> Helloworld('Hello','world')
Hello , world
>>> Helloworld('world','Hello')
world , Hello
>>> Helloworld(word='world',name='Hello')
Hello , world
>>> 

5.收集参数也叫可变参数：事先不知道参数的个数，类似于c++中的指针

>>> def Myfouthfun(*params):
	  print('参数的长度是： ',len(params))
	  print('第二个参数是：',params[1])
	
>>> Myfouthfun(1,'xiaojiayu',3.14,5,7)
参数的长度是：  5
第二个参数是： xiaojiayu
>>>

>>> def Myfifthfun(*params,exp=9):
	print('参数的长度是： ',len(params))
	print('第二个参数是：',params[1])
	print(exp)

	
>>> Myfifthfun('小甲鱼',2,5,3,6,exp=8)
参数的长度是：  5
第二个参数是： 2
8
>>>  

6.函数和过程

有返回值的叫函数

没有返回值的叫过程

>>> def temp1():
	print('Hello,world')
>>> def temp2():
	return [1,'xiaojiayu',3.14]
>>> temp1()
Hello,world
>>> temp2()
[1, 'xiaojiayu', 3.14]

二.局部变量和全局变量

1.样例1

#discount.py文件
    def discount(price,rate):
    final_price=price*rate  #局部变量
    return final_price

old_price = float(input('请输入原价：'))# 全局变量
rate = float(input('请输入折扣率：' ))
new_price = discount(old_price,rate)
print('打折后的价格是：',new_price)

运行结果：

请输入原价：10

请输入折扣率：0.12

打折后的价格是： 1.2

2.注：python对全局变量有保护作用：

例如：

>>> count=5
>>> def f1():
	count=10
	
>>> count
5

但是如果想让局部变量变成全局变量，可以用global关键字：

>>> count
5
>>> def f1(): 
	global count
	count=10
>>> f1()
>>> count
10
>>> 

三.内嵌函数和闭包

1.内嵌函数

>>> def fun1():
	print('fun1()正在被调用')
	def fun2():
		print('fun2()正在被调用')
	fun2()

	
>>> fun1()
fun1()正在被调用
fun2()正在被调用
>>> fun2()#报错，不能在外部调用

2.闭包

存在以下问题：

>>> def fun1():
	x=5
	def fun2():
		x*=x #x显示未定义
		return x
	return fun2()

>>> fun1()#报错

但是

>>> def fun3():
	x=[5]
	def fun4():
		x[0]*=x[0]
		return x[0]
	return fun4()

>>> fun3()#正确
25
>>> 

>>> def fun1():
	x=5
	def fun2():
		nonlocal x
		x*=x
		return x
	return fun2()

>>> fun1( )#正确
25

为了避免上述问题的产生：提出了nonlocal

>>> def fun1():
	x=5
	def fun2():
		nonlocal x
		x*=x
		return x
	return fun2()

>>> fun1( )#正确
25

三.lambda创建匿名函数

样例1：

>>> def ds(x):
	return 2*x+1
>>> ds(5)
11

等价于：

>>> g=lambda x:2*x+1
>>> g(5)
11

样例2：

>>> def add(x,y):
	return x+y

>>> add(3,4)
7

>>> def add(x,y):
	return x+y

>>> add(3,4)
7

等价于：

>>> t=lambda x,y:x+y
>>> t(3,4)
7
>>> 

lambda函数：使得代码更加精简，而且不需要考虑命名的问题，简化代码的可读性

四.filter过滤

>>> list(filter(None,[1,0,False,True]))
[1, True]
>>> 

>>> def odd(x):
	return x%2

>>> temp=range(10)
>>> show=filter(odd,temp)
>>> list(show)
[1, 3, 5, 7, 9]

等价于：

>>> list(filter(lambda x:x%2,range(10)))
[1, 3, 5, 7, 9]

map函数

>>> list(map(lambda x:x*2,range(10)))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

五.递归：有风险

1.递归求阶乘

>>> def funx(n):
	if n==1:
		return 1
	else:
		return n*funx(n-1)
	
>>> funx(3)
6

2.求斐波那契数列

非递归：

>>> a,b=0,1
>>> while b<1000:
	print(b,end=',')
	a,b=b,a+b

1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

递归：

>>> def fab(n):
	if n<1:
		print('输入错误')
		return -1
	if n==1 or n==2:
		return 1
	else:
		return fab(n-1)+fab(n-2)
	
>>> fab(4)
3
>>> fab(2)
1
>>> fab(3)
2
>>> 

3.汉诺塔

  思路：有64个盘子：

   可以分解为三个大步骤：

      ---将前63个盘子从x移动到y上

      ---将最底下的第64个盘子从x移动到z上

      ---将y上的63个盘子移动到z上

 问题一：将x上的63个盘子借助z移动到y上

 问题二：将y上的63个盘子借助x移到z上

问题一：(将x上63个盘子借助z移到y上 )拆解为：

  ----将前62个盘子从x移动到z上

----将最底下的第63个盘子移动到y上

----将z上的62个盘子移动到y上

      问题二：（将y上的63个盘子借助x移动到z上）拆解为：

        ---将前62个盘子从y移动到x上

        ---将最底下的第63个盘子移动到z上

        ---将x上的62个盘子移动到y上

代码:

def hanoi(n,x,y,z):
    if n==1:
        print(x,' --> ',z)
    else:
        hanoi(n-1,x,z,y)#将前n-1个盘子从x移动到y上
        print(x,' --> ',z)#将最底下一个盘子从x移动到z上
        hanoi(n-1,y,x,z)#将y上的n-1个盘子移动到z上
n=int(input('请输入汉诺塔的层数：'))
hanoi(n,'x','y','z')

运行结果：

请输入汉诺塔的层数：3

x  -->  z

x  -->  y

z  -->  y

x  -->  z

y  -->  x

y  -->  z

x  -->  z