Python基础（6）_函数

一 为何要有函数？

不加区分地将所有功能的代码垒到一起，问题是：

　　代码可读性差
　　代码冗余
　　代码可扩展差

如何解决？
　　函数即工具，事先准备工具的过程是定义函数，拿来就用指的就是函数调用

　　结论：函数使用必须是：先定义，后调用

python中函数定义方法：

　　　　def test(x):
　　　　"The function definitions"
　　　　x+=1
　　　　return x

　　def:定义函数的关键字
　　test：函数名
　　（）：内可定义形参
　　"":文档描述（非必要，但是强烈建议为你的函数添加描述信息）
　　x+=1：泛指代码块或程序处理逻辑
　　return：定义返回值

调用运行：可以带参数也可以不带
函数名()

二：函数的分类

　　1.内置函数:built-in
　　2.自定义函数:
　　　　def 函数名(参数1,参数2，...):
　　　　　　'''注释'''
　　　　　　函数体

函数的使用：先定义，后调用
如何定义函数之定义函数的三种形式
1 定义无参函数：函数的执行不依赖于调用者传入的参数就能执行时，需要定义为无参函数

def print_tag():
print('*************************')

def main():
print_tag('*',20,3)
print_msg('hello world')
print_tag('*',20,3)

main()

2 定义有参数：函数的执行需要依赖于调用者传入的参数才能执行时，需要定义为有参函数

def print_tag(tag,count,line_num):
for i in range(line_num):
print(tag*count)

3 定义空函数:函数体为pass

def func(x,y,z):
pass

三：函数的使用原则
　　函数的使用必须遵循：先定义后使用的原则
　　函数的定义，与变量的定义是相似的,如果没有事先定义函数而直接引用就相当于在引用一个不存在变量名　　

#定义阶段:只检测语法，不执行代码

def func():
if 1>2
print('hahahahahahah')
def func(): 　　　　　　#语法没问题，逻辑有问题，引用一个不存在的变量名
asdfasdfasdfasdfasdf

#调用阶段

foo()

返回值：可以返回任意类型

没有return：None
return value: value
return val1,val2,val3 :(val1,val2,val3)

return的效果：只能返回一次值，终止函数的执行

返回值：

返回值数=0:返回None

返回值数=1:返回object

返回值数>1:返回tuple

四：函数参数



1.形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

2.实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

3.位置参数和关键字（标准调用：实参与形参位置一一对应；关键字调用：位置无需固定）

4.默认参数

5.参数组

函数参数分类：

1、位置参数（形参、实参）

位置参数：按照从左到右的顺序依次定义的参数
　　def foo(x,y):
　　print(x)
　　print(y)
按位置定义的形参,必须被传值，多一个不行，少一个也不行
　　foo(1,2,3)===>报错
按位置定义的实参,与形参一一对应
　　foo(2,10)

2、关键字参数 （实参）

关键字参数：实参在定义时，按照key=value形式定义
　　def foo(x,y):
　　print(x)
　　print(y)
　　# foo(y=10,x=1)
　　foo(y=10,x=1) #关键字参数可以不用像位置实参一样与形参一一对应，指名道姓地传值

　　# foo(1,z=20,10) ===>报错

　　# foo(1,y=2,z=10) [b]===>报错[/b]

注意的问题一：位置实参必须在关键字实参的前面
注意的问题二：实参的形式既可以用位置实参又可以是关键字实参，但是一个形参不能重复传值

3、默认参数（形参）

默认参数：在定义函数阶段，就已经为形参赋值,定义阶段有值，调用阶段可以不用传值

定义：

# def func(x,y=10):
# print(x)
# print(y)

调用：

# func(1,20)
# func(1)

# def func(y=10,x):
# print(x)
# print(y)

形参的应用：值经常变化的需要定义成位置形参，值大多数情况下都一样，需要定义成默认参数

默认参数需要注意的问题一：必须放在位置形参后面
默认参数需要注意的问题二：默认参数通常要定义成不可变类型
默认参数需要注意的问题三：默认参数只在定义阶段被赋值一次

4、可变长参数

可变长参数：可变长指的是实参的个数不固定

按位置定义的非关键字可变长度的实参：*　　　　 *args

按关键字定义的可变长度的实参：** **kwargs

非关键字可变长度的实参：*

定义一个函数的时候，必须要预先定义这个函数需要多少个参数（或者说可以接受多少个参数）。一般情况下这是没问题的，但是也有在定义函数的时候，不能知道参数个数的情况（想一想C语言里的printf函数），在Python里，带*的参数就是用来接受可变数量参数的。看一个例子

def funcD(a, b, *c):
print a
print b
print "length of c is: %d " % len(c)
print c
调用funcD(1, 2, 3, 4, 5, 6)结果是
1
2
length of c is: 4
(3, 4, 5, 6)

　　前面两个参数被a、b接受了，剩下的4个参数，全部被c接受了，c在这里是一个tuple。我们在调用funcD的时候，至少要传递2个参数，2个以上的参数，都放到c里了，如果只有两个参数，那么c就是一个empty tuple。

关键字定义的可变长度的实参：**

　　如果一个函数定义中的最后一个形参有 ** （双星号）前缀,所有正常形参之外的其他的关键字参数都将被放置在一个字典中传递给函数，比如：

def funcF(a, **b):
print a
for x in b:
print x + ": " + str(b[x])
调用funcF(100, c='你好', b=200)，执行结果
100
c: 你好
b: 200

　　大家可以看到，b是一个dict对象实例，它接受了关键字参数b和c。

结合一起使用：

# def wrapper(*args,**kwargs): #可以接受任意形式，任意长度的参数
# print(args)
# print(kwargs)
#
#
# wrapper(1,2,3,3,3,3,3,x=1,y=2,z=3) ===>(1,2,3,3,3,3,3,) {'x':1,'y'=2,'z'=3}

命名关键字参数：定义在*后的形参，必须被传值，而且要求实参必须是以关键字的形式来传值

即：

　　形参： *args，z=10

或：

　　实参：z=10

# def func(x,y=1,*args,z,**kwargs):
# print(x)
# print(y)
# print(args)
# print(z)
# print(kwargs)
#
# func(1,2,3,4,5,z=10,a=1,b=2)

结果：



# def func(x,*args,z=1,**kwargs):
# print(x)
# print(args)
# print(z)
# print(kwargs)
#
# func(1,2,3,4,5,a=1,b=2,c=3)

结果：



总结：形参：位置形参，默认参数，*args，命名关键字参数，**kwargs

五、函数嵌套

#函数的嵌套调用
#
# def max2(x,y):
# if x > y:
# return x
# else:
# return y
#
# def max4(a,b,c,d):
# res1=max2(a,b) #23
# res2=max2(res1,c) #23
# res3=max2(res2,d) #31
# return res3
#
#
# print(max4(11,23,-7,31))

#函数的嵌套定义
def f1():
def f2():
def f3():
print('from f3')
print('from f2')
f3()
print('from f1')
f2()
# print(f1)
f1()

'''
from f1
from f2
from f3

'''

函数对象：



六、命名空间

名字空间：存放名字与值的绑定关系

名称空间分为三种

　　内置名称空间：python解释器自带的名字，python解释器启动就会生成

　　全局名称空间：文件级别定义的名字都会存放与全局名称空间，执行python文件时会产生

　　局部名称空间：定义在函数内部的名字，局部名称空间只有在调用函数时才会生效，函数调用结束则失效

三者的加载顺序：内置名称空间->全局名称空间->局部名称空间

三者的取值顺序：局部名称空间->全局名称空间->内置名称空间

七、作用域

作用域：

作用范围：

全局作用域：内置名称空间与全局名称空间的名字属于全局范围，
　　　　　　　　#在整个文件的任意位置都能被引用，全局有效
局部作用域：局部名称空间的名字属于局部范围，
　　　　　　　　#只在函数内部可以被引用，局部有效

作用域在定义函数时就已经固定住了，不会随着调用位置的改变而改变

1 name='alex'
2 def foo():
3     name='lhf'
4     def bar():
5         name='wupeiqi'
6         print(name)
7         def tt():
8             name='hedeyong'
9             print(name)
10         return tt
11     return bar
12
13 func=foo()
14 func()()       #==> bar()() ==>tt()
　　'''
　　hedeyong
　　'''