函数

定义及调用

定义函数：用关键字def，注意加冒号

1
2
>>> def Function():
	print('我是一个函数')

调用函数：写函数名字，再加上小括号

1
2
>>> Function()
我是一个函数

形参及实参

在函数的参数中分 形式参数(parameter)及实际参数(argument)

1
2
3
4
5
>>> def MyFirstFunction(xingcan):
	print('传递进来的参数' + xingcan)

>>> MyFirstFunction('shican')
传递进来的参数shican

函数文档

用来给函数解释说明用的，定义是在函数里用引号引起来

也可以通过 help 来查看

1
2
3
4
5
6
7
8
>>> def MyFirstFunction(xingcan):
	#定义函数文档
	'这是一个文档'
	print('传递进来的参数' + xingcan)

# 查看函数文档
>>> MyFirstFunction.__doc__
'这是一个文档'

关键字参数

如果你的参数调换了位置，还想匹配形参，那么可以用这个方法

1
2
3
4
5
6
7
>>> def f1(a,b):
	print(a + '是个' + b)

>>> f1("我",'帅哥')
我是个帅哥
>>> f1(b = "帅哥",a = "我")
我是个帅哥

收集参数

如果你也不知道形参到底有多少个的话，可以这么建立函数

1
2
3
4
5
>>> def f1(*params):
	print('形参有' ,len(params) , '个')

>>> f1('1',1,22,3,4,6)
形参有 6 个

常见有形式参数的有 print

函数的返回值

1
2
3
4
5
6
7
8
9
10
>>> def hello():
	print('hello fishC')
>>> hello()
hello fishC
>>> hello
<function hello at 0x000001E6039C4948>
>>> temp = hello()
hello fishC
>>> print(temp)
None

全局变量与函数

如果你想试图用函数来改变全局变量的值，这是不被允许的

1
2
3
4
5
6
7
8
>>> count = 1
>>> def MyFunction():
	count= 2	#这个count是函数内部的count，跟外面的count是两个空间，所以改变不了全局的
	print(count)
>>> MyFunction()
2
>>> print(count)
1

如果你想改变全局的值，用关键字global来声明一下

1
2
3
4
5
6
7
8
9
10
11
>>> count = 1
>>> def MyFunction():
	global count	#这里来声明
	count= 2
	print(count)
>>> print(count)
1
>>> MyFunction()
2
>>> print(count)
2

内嵌函数和闭包

1
2
3
4
5
6
7
8
>>> def fx(x):
	def fy(y):
		return x * y
	return fy

>>> i = fx(5)
>>> i(8)
40
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
>>> def fx():
	x = 5
	def fy():
		x *= x
		return x
	return fy()

>>> fx()
Traceback (most recent call last):
  File "<pyshell#33>", line 1, in <module>
    fx()
  File "<pyshell#32>", line 6, in fx
    return fy()
  File "<pyshell#32>", line 4, in fy
    x *= x
UnboundLocalError: local variable 'x' referenced before assignment

>>> def fx():
	x = 5
	def fy():
		nonlocal x		#如何解决全局变量的问题呢，添加nonlocal
		x *= x
		return x
	return fy()

>>> fx()
25

匿名函数 lambda

我们首先那一条直线方程来说明

1
2
3
4
5
6
7
>>> def ds(x):
	return 2 * x + 1

>>> ds(5)
11
>>> lambda x : 2 * x + 1
<function <lambda> at 0x000001743018B168>

可以看到lambda表达式，冒号前面是变量，后边是执行的函数体

如果想调用的话，就把这个表达式复制，然后调用即可

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

如果是多参数的话就可以用逗号隔开参数

1
2
3
>>> f1 = lambda x,y : x+ y
>>> f1(5,6)
11

lambda 的优点：

  1. 省下函数定义的过程
  2. 不用考虑给孩子起名字
  3. 简化代码

两个牛逼的 BIF 函数

Filter 过滤器

实质：是把非 true 的结果统统过滤掉，只保留 true 的结果

1
2
3
4
5
6
>>> filter(None,[False,0,'',True,1])
<filter object at 0x0000017430203E48>
# 可以看到返回的是个对象，那我们可以用list给迭代出来
>>> list(filter(None,[False,0,'',True,1]))
[True, 1]
# 可以看到他的规则

再来看一个实用的

1
2
3
4
5
6
7
>>> def odd(x):
	return x % 2

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

结合 lambda 实现简洁代码

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

map 映射

我理解为加工车间

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

递归

设置递归的深度

1
2
>>> import sys
>>> sys.setrecursionlimit(10000)
  1. 递归要有结束的条件
  2. 还要调用自己

缺点：

  1. 消耗空间、时间，效率低

斐波那契

1
2
3
4
5
6
7
8
9
10
11
>>> def f1(n):
	if n == 1:
		return 1
	elif (n == 2):
		return 1
	else:
		return f1(n-1) + f1(n-2)


>>> f1(12)
144

汉诺塔问题

1
2
3
4
5
6
7
8
9
def hanoi(n,x,y,z):
    if(n == 1):
        print(x ,'->' ,z)
    else:
        hanoi(n-1,x,z,y)
        print(x,'->',z)
        hanoi(n-1,y,x,z)
n = int(input('输入多少个盘子：'))
hanoi(n,"x",'y','z')