1.python 函数 定义 ---def()
def fun()：
print（“我是小甲鱼！！”）
调用函数
a =fun（）
print （a）
即可 ，注：函数调用是由上而下；
2.python 函数的参数 def（a,b）
def fun(name):
print(name+"wo ai ni" )
c =int（input（“输入：”））
fun(c)
即可调用；
3.python 函数返回值 关键字：return
def fun(name1+name2):
return (name1+name2 )
c =int（input（“输入：”））
d =int（input（“输入：”））
fun（c，d)
即可得到返回值
4.python 形参 -- 函数-->内部调用的 参数和实参-->传入函数的参数
def fun(name):
"函数文档"
print(name+"wo ai ni" )
c =int（input（“输入：”））
fun(c)
不能打印出“函数文档”
fun.__doc__ 函数属性即可打印“函数文档”
help（print）介绍函数用法
5. python 关键字参数
def fun（name ，words）：
print（name +“-->”+words）
调用fun（“小甲鱼”，“让加”）
即可打印
调用fun （“让加”，“小甲鱼”）
则输出的结果是反的
解决办法：指定传入的参数
fun（words=“让加”，name=“小甲鱼”）
6.python 默认参数
def fun（name=“小甲鱼” ，words=“让加”）：
print（name +“-->”+words）
fun（）
即可打印
fun（“苍井空”）
打印出 ：苍井空-->让加
7.python 收集参数 别名 ———可变参数
def fun（*params）：
print（“参数的长度：”，len(params)）
pint （“第二个参数：”，params[1]）
fun(1,"小甲鱼"，2，34，5，45，5)
即可打印 参数长度：7 第二个参数：小甲鱼
注：传的参数打包为一个元祖
8.def fun（*params，erp）：
print（“参数的长度：”，len(params)，erp）
pint （“第二个参数：”，params[1]）
fun(1,"小甲鱼"，2，34，5，45，5)
调用默认给收集参数，会出错，给erp定义默认值:“小甲鱼”
则不会出错
9. python 函数与过程
有返回值 --函数 无返回值---过程
def fun()：
print（“我是小甲鱼！！”）
a =fun（）
print（a）
返回值 none
动态确定内存；
可以返回多个值
def back（）：
return（1，“小甲鱼”，3，454）
back（）
打印出一个列表
[1,"小甲鱼"，3，454]包含不同类型的值
def back（）：
return 1，“小甲鱼”，3，454
back（）
打印出元祖
（1，“小甲鱼”，3，454）
10. python 函数变量作用域--变量可见性 局部变量无法影响全局变量 ，在函数内部可以访问全局变量，用关键字global修改全局变量
def fun（a，b）：
xiangcheng =a*b
# print （c)全局变量
golbal c
c= 45
return（ xiangcheng）
c =int（input（“输入：”））
d =int（input（“输入：”））
new =fun(c,d)全局变量
print(new)
11. python 内嵌函数
def fun1（） ：
print（“1”）
def fun2（）：
print（"2")
fun2()
注：内部函数作用域都在外部函数之内的
调用fun1（）
打印：
1
2
12.python 闭包
def funX（x） ：
print（“1”）
def funY（y）：
return x * y
funY()
i= funX(8)
调用函数：funX（5）（8）
输出：40
13. python 函数 产生闭包
def fun1（） ：
x =5
def fun2（y）：
x*=x
return x
调用 函数 fun1（）报错；x在fun2函数中无定义；在fun1函数中定义的x ，无法影响fun2函数
修改后python 2
def fun1（） ：
x =[5]
def fun2（y）：
x[0]*=x[0]
return x[0]
retrun fun2()
即可
修改后 python3利用关键字nonlocal
def fun1（） ：
x =5
def fun2（y）：
nonlocal x
x*=x
return x
return fun2（）
即可调用fun1（）
14.python 匿名函数 --->lambda表达式
def funX（x） ：
reurn 2* x+1
funX（5）
lambda表达式：
g= lambda x：2*x+1
调用 ：g（5）
自动删除申请的内存
例: g= lambda x,y :x+y
g (3,5)即可
15. python 两个BIF 函数 filter（）函数，map（）函数
（1）.filter（）函数
filter（None，[1,0,False,Ture]）
list(filter(None,[1,0,False,Ture]))
即可输出：[1,Ture]
def add(x):
return x %2
temp = range(10)
show = filter (add,temp)
list(show)
输出：[1,3,5,7,9]
list（filter（lambda x：x%2，range（10））)即可输出
（2）.map（）函数：
list（map（lambda x：x*2，range（10））））即可输出
[0,2,4,6,10,12,16,18]---> 利用lambda函数 生成一个数据返回生成一个列表；
16. python ---递归
网络爬虫时设置递归的深度；
import sys
sys.setrecursionlimit(1000000)
===============================================================================
def fun（）：
return fun（）
执行函数fun（）即可，测试
===============================================================================
递归求阶乘：
非递归版:
def fun(n):
result =n
for i in range(1,n):
result * =1
return result
num =int(input(“输入正数：”))
result= fun（num）
priint("%d的阶乘是 %d "，（num ，result）)
递归版:
def fun （n）：
if n== 1:
return 1
else:
return n=fun (n-1)
num =int(input(“输入正数：”))
result= fun（num）
print("%d的阶乘是 %d "，（num ，result）)
17. python ---斐波拉契数列：比例-->0.618：1
def fun(n):
n1=1
n2=1
n3= 1
if n<0:
print("输入有误")
return -1
else：
n3 =n2+n1
n1 = n2
n2 =n3
n =1
return n3
result =fun (20)
if result !=1:
print ("共有多少对小甲鱼："%result)
运行即可输出：
递归版：
def fun （n）:
if n<1:
print("输入有误：")
if n==1 or n ==2：
return 1
else：
return fun（n -1）+fun（n-2）
result =fun （20）
if result ！=1：
print（“共有多少小甲鱼：”% result）
运行即可；
18.python --->汉诺塔
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上
num =int(input("输入正数："))
result= hanoi（num，‘X’，‘Y’，‘Z’）
即可运行