【Python学习之五】函数

环境
　　虚拟机：VMware 10
　　Linux版本：CentOS-6.5-x86_64
　　客户端：Xshell4
　　FTP：Xftp4
　　python3.6

Python不但能非常灵活地定义函数，而且本身内置了很多有用的函数，可以直接调用。

一、函数的定义与调用
1、定义函数的格式:
def 函数名(): 代码
示例：

def printinfo():
    print('----------------------')
    print('人生苦短，我用Python')
    print('----------------------')

2、调用函数：函数名()

printinfo()
----------------------
人生苦短，我用Python
----------------------

二、函数参数
定义时小括号中的参数，用来接收参数用的，称为 “形参”;调用时小括号中的参数，用来传递给函数用的，称为 “实参”.
1、定义带有参数的函数
#计算两个数的和

def add2num(a,b):
    c=a+b
    print(c)

2、调用带有参数的函数

add2num(11, 22)#33

3、缺省参数
带有默认值的参数一定要位于参数列表的最后面，否则调用报错：SyntaxError: non-default argument follows default argument

def printinfo1(name,sex,age=35):
    print('Name:%s'%name)
    print('Sex:%s'%sex)
    print('age:%d'%age)
    
printinfo1('小明','男')

4、不定长参数
有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明时不会命名。
语法格式：

def functionname([normal_args,] *args, **kwargs):
    function_suite 
    return [expression]

加了星号（*）的变量args会存放所有未命名的变量参数，args为元组；

而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典。

示例：

def func(a,b,*args,**kwargs):
    print('a=%s,b=%s'%(a,b))
    for arg in args:
        print(arg)
    print('kwargs=%s'%kwargs)

(1)注意传递的参数对应

func(1,2,3,4,5,m=6,p=7,n=9)
# a=1,b=2
# 3
# 4
# 5
# kwargs={'m': 6, 'p': 7, 'n': 9}

(2)注意元组与字典的传参方式

c=(3,4,5)
d={'m':6,'p':7,'n':9}
func(1, 2,*c,**d)
# a=1,b=2
# 3
# 4
# 5
# kwargs={'m': 6, 'p': 7, 'n': 9}

(3)注意不加星号与上面的区别

func(1,2,c,d)
# a=1,b=2
# (3, 4, 5)
# {'m': 6, 'p': 7, 'n': 9}
# kwargs={}

5、引用传参

Python中函数参数是引用传递（注意不是值传递）。
对于不可变类型，因变量不能修改，所以运算不会影响到变量自身；
而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量。

def selfadd(a):
    a+=a;
    
a_int=1
print("不可变类型调用之前：%d"%a_int)#不可变类型调用之前：1
selfadd(a_int)
print("不可变类型调用之后：%d"%a_int)#不可变类型调用之后：1

a_list=[3,4]
print("可变类型调用之前：%s"%a_list)#可变类型调用之前：[3, 4]
selfadd(a_list)
print("可变类型调用之后：%s"%a_list)#可变类型调用之后：[3, 4, 3, 4]

三、函数的返回值
1、想要在函数中把结果返回给调用者，需要在函数中使用return

2、函数利用元组可以有多个返回值

def divid(a,b):
    shang=a//b
    yushu=a%b
    return shang,yushu
result=divid(10,3)
print(result)#(3, 1)

四、局部变量和全局变量
1、局部变量
局部变量（Local variables）指在程序中只在特定过程或函数中可以访问的变量。
(1)局部变量，就是在函数内部定义的变量
(2)不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响
(3)局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储，这就是它的作用

2、全局变量
如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量
(1)在函数外边定义的变量叫做全局变量;
(2)全局变量能够在所有的函数中进行访问;

a=10
def func()
    print(a)
    b=a
    print(b)
func()

运行结果：
10
10

不用加global就可以访问  但是修改就会报错。

(3)如果在函数中修改全局变量，那么就需要使用global进行声明，否则出错;
如果全局变量是可变类型：所以在函数里面任意修改（值，引用）;
如果全局变量是不可变类型：在函数里面不能修改值，也不能修改引用，除非加上global才能修改引用;
(4)如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的，小技巧：强龙不压地头蛇;

小结：
(1)在函数中不使用global声明全局变量时不能修改全局变量的本质是不能修改全局变量的指向，即不能将全局变量指向新的数据。
(2)不可变类型：值不可以修改，可以修改变量的引用（=赋值号）,对于不可变类型的全局变量来说，因其指向的数据不能修改，所以不使用global时无法修改全局变量。
(3)可变类型：值可以修改（内存地址不变但是所保存的值变化了），引用可以修改（变量的内存地址变化了）,对于可变类型的全局变量来说，因其指向的数据可以修改，所以不使用global时也可修改全局变量。

五、递归函数
在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

示例：计算阶乘 n! = 1 * 2 * 3 * ... * n

def func_jiecheng(n):
    if n==1:
        return 1
    else:
        return n*func_jiecheng(n-1)

print(func_jiecheng(5))#120

注意点：一定要定义递归的边界，即什么时候退出循环；

六、匿名函数
用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。
Lambda函数能接收任何数量的参数但只能返回一个表达式的值,匿名函数不能直接调用print，因为lambda需要一个表达式。

lambda函数的语法：只包含一个语句

lambda [arg1 [,arg2,.....argn]]:
    expression

示例：

sum=lambda arg1,arg2:arg1+arg2
print(sum(10,20))#30

应用场合：函数作为参数传递
1、自己定义函数

#opt是匿名函数
def func3(a,b,opt):
    print('a=%d'%a)
    print('b=%d'%b)
    print('result=%d'%opt(a,b))

func3(1, 2, lambda x,y:x+y)
# a=1
# b=2
# result=3

2、作为内置函数的参数

stus = [ {"name":"zhangsan", "age":18}, {"name":"lisi", "age":19}, {"name":"wangwu", "age":17} ] 
#按name排序
stus.sort(key=lambda x:x['name'])
print(stus)#[{'name': 'lisi', 'age': 19}, {'name': 'wangwu', 'age': 17}, {'name': 'zhangsan', 'age': 18}]
#按age排序
stus.sort(key=lambda x:x['age'])#
print(stus)#[{'name': 'wangwu', 'age': 17}, {'name': 'zhangsan', 'age': 18}, {'name': 'lisi', 'age': 19}]

参考：
Python学习笔记