函数
函数定义：使用一个名字定义一段实现特定功能的代码组织的工作机制。
使用该函数的名字，即可让计算机执行函数内预定义好的程序。
封装：封装一个功能
容器对数据的封装
函数对语句的封装
类是对方法和属性的封装
函数的使用：函数使用前应先定义，使用函数即调用。
定义一个函数：
用def 后跟一个空格创建一个函数
用return关键字指定函数返回值的值（给调用者，返回值可以有也可以没有）
- 格式：def 函数名（）：
-
《函数体》 - 注意函数名为和类的定义区分一般首字母小写，括号和冒号一定不可省略，函数体内有代码缩进。
def hanshu():
<函数体>
调用函数时：
#函数名（参数）
一个函数只实现功能不做数据处理，没有返回值，直接像一个赋值语句一样无返回值。
无返回值时的调用：直接调用函数名
有返回值时的调用：结合赋值语句进行调用
def na(n):
if n>=3:
print("年后开会")
else:
print("不开了")
na(5)
函数小技巧：
1、map()函数。
有时候需要对列表中每个元素做相同的处理，得到新的列表。
例：对一个列表所有数据乘以3，所有字符串转换为整数，两列表值对应相加等等！我们学过for循环后可以利用for循环进行处理。但方便还是用map()函数。
格式：map(func,list2,list1,…listn)——内置函数
list(map())表示要转换为列表形式，要像转为元组即tuole(map())
func为一个函数，这个函数中有几个参数后面跟几个列表（参数对应列表中的元素）
2、匿名函数：lambda()
有时候函数只用一次，其名称也就不重要，不用专门去起了
用lambda()表达式返回一个匿名函数。
格式：lambda 参数表 ：表达式
ml=[2,4,6,8,10]
nl=[10,20,40,80,160]
def F(a):
return a*3
print(list(map(F,ml)))#list表示使用内置map函数要得到的数据为列表，要想得到元组改为tuple
def H(a,b):
sum=a+b/2
return sum
print(list(map(H,ml,nl)))#map()根据提供的函数对指定的序列做映射
#简化函数的另一种方法{匿名函数lambda()}
print(list(map(lambda a:a*4,ml)))
'''使用lambda函数，当函数只用一次时无需想名字
直接使用lambda 表达式,所以无需费神使用def定义一个函数，lambda格式如下
lambda 参数列表：函数体 见上程序即可'''
递归函数
定义：函数间或者直接调用自己（直接或间接调用自己）
递归分两个过程：往下调用，分解的过程。往上回溯，综合的过程。（一定要有结束的条件，否则会死掉，学会利用数学公式）
1、案列FIB（斐波那契额数列）
**斐波那契额数列：*又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……在数学上，斐波那契数列以如下被以递推的方法定义：F(1)=1，F(2)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 3，n ∈ N）在现代物理、准晶体结构、化学等领域，斐波纳契数列都有直接的应用，为此，美国数学会从 1963 年起出版了以《斐波纳契数列季刊》为名的一份数学杂志，用于专门刊载这方面的研究成果。
这个数列从第3项开始，每一项都等于前两项之和。
f(n)=f(n-1)+f(n-2) n>=3 n={1,2}f(n)=1
def fib(n):
if n==1 or n==2:
return 1
return fib(n-1)+fib(n-2)
f=fib(5)
print(f)
2、案列：阶乘
定义：
10！=10X9X8…X1
f(n)=n*f(n-1) n>=2
def fun_c(n):
print(n)#dayin
if n==1:#判断
return 1
return n*fun_c(n-1)
#调用，当为fun_c(1)时，return 1,即fun_c(1)=1.于是开始回溯，综合
print(fun_c(3))
3、案例汉诺塔
规则：每次只能移动一个、任何一次移动塔的状态必须大的在下，小的在上。
方法：n=1直接把A上的盘子移动到C上即可
n=2：先把小的移到C上把大的移到B上最好在把C上的移到B上即可 A>C,A>B C>B
n=3：把A上的两个盘子，通过C移动到B上去，调用递归实现
把A上剩下的一个最大盘子移动到C上。
把上两个盘子借助A，挪到C上去，调用递归
n=n时，递归
a='A'
b='B'
c='C'
def han(a,b,c,n):
if n==1:
print("{}—》{}".format(a,c))
return None
if n==2:
print("{}—》{}".format(a,b))
print("{}—》{}".format(a,c))
print("{}—》{}".format(b,c))
return None
han(a,c,b,n-1)#借助c塔移动，此时a上还剩一个
#此时括号里的参数为形参
print("{}—》{}".format(a,c))#把a移到c上几个
han(b,a,c,n-1)#b借助a移到c上即可。注意：到这传入的参数仍为3
#调用这个目的是对b上的那俩进行移走
#可能有的同学对参数的变换可能不太明白，可见下方参数的描述
return None
han(a,b,c,3)#借助c塔移动
#（传入的为ABC而abc只是占位而已，对与下两个调用足以说明这些，注意，ABC调用时位置就已经固定了）
（前三个案列是递归函数的经典案列）
4、案列乘法表
def jiujiu():
for o in range(1,10):
for i in range(1,o+1):
print(o*i,end=" ")
print('\n')
jiujiu()
#以下为另一种形式
'''def printline():
print(" ")
def jiujiu():
for o in range(1,10):
printline()
for i in range(1,o+1):
print(o*i,end=" ")
#print('\n')
jiujiu()
'''
help()随时为您效劳
重点在于理解：变量、参数的形式（见下）
变量的作用域
分类：局部变量、全局变量
局部变量：在函数内部定义的参数以及变量，且只在函数定义内有效，函数外边无法访问到。
**全局变量：**在函数外部定义的，作用与整个代码段
在函数内部使用与全局变量同名的变量时，若未在函数内定义则使用全局变量的值。一旦在函数内部定义，python会在函数内部创建一个局部变量，那么就与全局变量无关了。
**global关键字：**使用此关键字可以在函数中改变全局变量的值。
此关键字还可明确指明某一个名称就是全局变量，格式如下：
global 参数表
局部变量赋值不会影响全局变量，而使用global，局部变量赋值会影响全局变量。
def sum(num0,num2):
sum1=num0+num2
return sum1
num0,num2=1,3
print(sum(num0,num2))
#print(sum1) 明明赋值，程序还报错因为sum1为局部变量，函数外无法访问
num0,num2=6,7
def sum():
num0=2
num2=6
sum1=num0+num2
return sum1
print(sum())
#在函数内部使用与全局变量一样的变量时，若在函数内未定义则使用全局变量的值
#一旦含无数内部定义python会创建一个局部变量，与全局变量无关
参数
**定义：**负责给函数传递一些必要的数据或者信息
分类：从大方面讲分为：形参和实参
形参：函数创建和定义过程中，函数后面括号里的参数，在函数定义时候用到的参数，没有具体值，只是代表一个占位符号、一个变量名。
实参：函数调用过程中传入的参数，是一个具体内容，赋值到变量的值
（当调用含参数的函数时，这些参数的值会被复制给函数中对应的参数传入）
形参的分类：定义函数时形参又分为两种。
一种是在参数表中写明参数名key的参数，固定了顺序和数量的固定参数
一种是不知道还会有多参数传入的可变参数
def fun_c(*args):
<函数体>
#带名字的可变参数
def fun_c1(**kwargs):
<函数体>
从可变参数引入一个小函数：——zip()函数
用于将可迭代的对象作为参数，将对象对应的元素打包成一个元组，然后返回这些元组组成的列表
（若迭代器元素不一样，则以最短的为准）
在python3.X中zip（）函数要想实现转换成列表的功能需要使用list()
利用“*”（即星号）可以将元组解压为列表
a=[1,2,45,6,4]
b=[1,5,9,88,7]
st=list(zip(a,b))
print(st)
#结果：[(1, 1), (2, 5), (45, 9), (6, 88), (4, 7)]——一一对应
#print(zip(a,b)) 在python3中zip（）函数要想实现转换成列表的功能需要使用list()
a1,b1=list(zip(*st))
print(a1)
print(b1)
li=(1,2,3,4)
print(*li)
实参的理解：
在调用函数的时候，可传入两种参数
1、没有名字的位置参数
会按照前后顺序对应到函数传入
通过固定参数和位置参数，可更好的对汉诺塔进行理解
2、带key的关键字参数（key1=value1,key2=value2…形式）
由于指定了key，可以不按照顺序传入，如果和位置参数混用，位置参数要在前。
'''
def keys_para(k1=v1,k2=v2,k3=v3,k4=v4......):
<函数体>
#调用函数
keys_para(k1=value1,k2=value2.....)
'''
def keys_para(one,two,three):
print(one+two)
print(three)
return None
keys_para(one=1,two=2,three=3)
keys_para(one=1,three=3,two=2)
不容易混淆，一般形参和实参只是按照位置一一对应即可容易出错
使用关键字参数，可以不考虑参数位置
收集参数
**定义：**把没有位置，不能和定义时的参数位置相对应的参数，放入一个特定的数据结构——也就是上面所讲的可变参数
可以和其它参数共存
格式： def fun_c(*args):
<函数体>
调用：fun_c(p1,p2,p3,p4…)
args可以看作一个列表
也可以不带任何参数使用
def fun(*args):
print("加油您真棒")
print(type(args))
for i in args:
print(i)
fun("您好","lala",18)
收集参数之关键字参数：把关键字参数按字典格式存入收集参数
语法： def fun_y(**kwargs):
<函数体>
调用：fun_y(p1=v1,p2=v2,p3=v3,…)
调用的时候把关键字参数放入kwargs
访问kwargs需要按字典格式访问（字典格式的访问可见我博客里的数据类型总汇，（对字典的访问python 2和3有区别））
items()方法——以列表返回可遍历的（键值）元组数组
格式：dict.items()——（内置，有返回值）
items方法把字典键值组成一个元组，并把这写元组放在列表中返回
dict={'a':2,'c':1,'d':6}
print(dict.items())
#返回值：dict_items([('a', 2), ('c', 1), ('d', 6)])
#循环遍历字典列表格式
for i,j in dict.items():
print(i,j)
#以上是对字典items()方法的介绍具体见我博客里的“数据类型总汇——python”
def fun(**kwargs):
print("加油您真棒")
for i,j in kwargs.items():
print(i,"-->",j)
fun(name="您好",age="lala",a=18)
收集参数混合调用的顺序问题
收集参数、关键字参数、普通参数可以混合调用
使用规则：普通参数和关键字参数优先
定义的时候一般找普通参数、关键字参数、收集参数tuple(args)、收集参数list（kwargs）
收集参数的解包问题
把参数放入列表中或者字典中，直接把list/dict中的值放入收集参数中
（其实也就是一个语法问题）
格式：见下方参数案列
def stu(*args):
print("hahaha")
for i in args:
print(i)
p=[]
p.append("r")
p.append("ro")
p.append("rom")
stu(p)
#结果为：['r', 'ro', 'rom']
#很遗憾不是按照所想的那样输出
#此时，args的表示形式是字典内一个list类型的元素，即args=(['r', 'ro', 'rom']),即把转入的列表当作一个值
#此时，就需要解包符号，即调用的时候前加一个星号
stu(*p)
'''
结果：hahaha
r
ro
rom
函数文档
作用：对当前函数提供使用相关的参考信息
文档的写法：在函数内部开始的第一行使用三引号字符串定义符。一般具有特定格式，见下方案列
文档查看：使用help()函数，形如：help(函数名)或者 函数名.doc
def stu(name,age,*args):
'''这是文档
:name:表示学生的姓名
：age:表示学生的年龄
'''
print("this is hanshu stu")
print(help(stu))
print(stu.__doc__)
pass语句
pass表示一个什么都不做的空语句，例如：如果像定义一个什么事也不做的空函数，可以用pass语句，代码如下：
def fun_ycx():
pass
为防止程序出错，无法写出正确代码，以及其它功能尚不明确，也可以用pass语句
Pass一般用于占位置，当想好程序之后可以用pass来填充，使程序正常运行
412
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
