Python基础-函数[1]

简单函数的定义

def 关键字定义函数

1234567891011

#!/usr/bin/env pythondef func_name():             # def关键字定义函数    print "hello world"func_name()    #调用所定义的函数========结果=====root@tonglele /mnt # python fun.py hello world

局部变量和全局变量

作用域： 变量生效的范围
局部变量： 在某一函数内定义的变量，作用域为此函数体
全局变量： 定义在函数之外，作用域为整个模块，如果要在函数体内使用则使用global关键字标记
全局变量尽量少用。但有些配置性的信息可以设置为全局变量方便使用。

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849

（局部变量与全局变量）#!/usr/bin/env pythona = 5               #这里的a为全局变量def func_name():    a = 'hello'    #这个a为局部变量，它的作用域为此函数    print afunc_name()   #调用函数print a   #这里打印的为全局变量a========结果========root@tonglele /mnt # python fun.pyhello5（global关键字）#!/usr/bin/env pythona = 5def func_name():    global a            #这里使用global关键字定义a是全局变量a，在这个函数体内所有对a的赋值操作都是对全局变量a的改变    a = 'hello'    print afunc_name()print a==========结果=======root@tonglele /mnt # python fun.pyhellohello(在函数体内可以直接调用全局变量)#!/usr/bin/env pythona = 5def func_name():    print afunc_name()print a=======结果=======root@tonglele /mnt # python fun.py55

带不可变参数的函数

在调用函数时传入一个或多个参数，函数体接收之后作出相应工作。

1234567891011

(传入一个参数)#!/usr/bin/env pythondef func_name(arg):  #arg 形参    print arg      #arg作为参数传进来，相当于一个局部变量func_name('hello tonglele')   #'hello tonglele'就是实参，是在调用函数时传给函数的参数=======结果=======root@tonglele /mnt # python fun.pyhello tonglele

传入多个参数

位置参数

123456789

#!/usr/bin/env pythondef func_name(arg1,arg2):      #arg1,arg2为两个形参，中间用‘，’隔开    print arg1+arg2      #打印arg1+arg2的结果func_name(1,2)   #在调用函数时传入两个时参，中间用逗号隔开,需要注意的是顺序要按照所调用的函数定义的顺序========结果======root@tonglele /mnt # python fun.py3

关键字参数

123456789101112

 #!/usr/bin/env pythondef func_name(arg1,arg2):    print arg1    print arg2func_name(arg2=1,arg1=2)    #在关键字传参时顺序就不那么重要了，但需要把参数名与值一一对应好=======结果======root@tonglele /mnt # python fun.py21

关键字参数和位置参数混合使用

123456789

 #!/usr/bin/env pythondef func_name(arg1,arg2,arg3):    print arg1    print arg2    print arg3func_name(1,arg3=2,arg2=5)   #位置参数必须在关键字参数之前，否则会出现语法错误。eg:SyntaxError: non-keyword arg after keyword arg

默认参数

123456789101112131415161718192021222324252627

#!/usr/bin/env pythondef func_name(arg1,arg2,arg3=3):   #给arg3一个默认值，如果在调用此函数时未给arg3传值，则取默认值3    print arg1    print arg2    print arg3func_name(1,2)     #此时未给arg3传参==========结果========root@tonglele /mnt # python fun.py123#!/usr/bin/env pythondef func_name(arg1,arg2,arg3=3):    #在函数定义的时候,带默认值的参数必须放在不带默认值参数的后边。    print arg1    print arg2    print arg3func_name(1,2,5)    #此时给arg3传参，默认值将被覆盖=======结果======root@tonglele /mnt # python fun.py125

带可变参数的函数

在Python中支持可变参数，即你可以传入0或多个参数，对参数的个数没用固定的要求

可变位置参数

1234567891011121314151617

#!/usr/bin/env pythondef func_name(*args):    print type(args)    for x in args:        print xfunc_name(1,2,5,'hello','tonglele')=======结果=======root@tonglele /mnt # python fun.py<type 'tuple'>     #我们可以看出函数将传进来的参数打包成了一个元组125hellotonglele

可变关键字参数

123456789101112131415

 #!/usr/bin/env pythondef func_name(**kwargs):    print type(kwargs)    for k,v in kwargs.items():        print "%s  ==>  %s" % (k,v)func_name(name='tonglele',age='19',school='XAUT')===========结果===========root@tonglele /mnt # python fun.py<type 'dict'>   #函数将传进去的变量打包成一个字典age  ==>  19name  ==>  tongleleschool  ==>  XAUT

非可变参数与可变参数的结合

非可变参数必须要在可变参数之前
可变位置参数要在关键字参数之前

1234567891011121314

#!/usr/bin/env pythondef func_name(arg1,arg2,*args):    print arg1    print arg2    print argsfunc_name(1,2,3,4,5,5)=======结果=======root@tonglele /mnt # python fun.py12(3, 4, 5, 5)

参数解包

* 用于解包序列为位置参数

123456789101112131415

#!/usr/bin/env pythondef func_name(arg1,arg2,arg3):    print arg1    print arg2    print arg3li = [1,2,3]func_name(*li)    #将一个列表解包传递进去=======结果======root@tonglele /mnt # python fun.py 123

** 用于解包字典为关键字参数

123456789101112131415

 #!/usr/bin/env pythondef func_name(arg1,arg2,arg3):    print arg1    print arg2    print arg3dic = {'arg1':1,'arg2':2,'arg3':3}func_name(**dic)    #将一个字典解包传递进去======结果======root@tonglele /mnt # python fun.py123

函数返回值

主要使用return关键字
可以返回任何对象
python中以元组的形式可以返回多个值

123456789101112131415

#!/usr/bin/env pythondef func_name(arg1,arg2):    arg3 = arg1 + arg2    arg4 = arg1 * arg2    return arg3,arg4i,j = func_name(2,3)print iprint j===========结果===========root@tonglele /mnt # python fun.py56

python中的递归函数

递归：函数直接或间接调用自身的函数

1234567891011121314

 #!/usr/bin/env pythondef func_name(n):    if n<= 1:        return 1    else:        return n * func_name(n - 1)answer = func_name(10)print answer=========结果=======root@tonglele /mnt # python fun.py      3628800      #即计算10的阶乘    #shell中一条命令计算阶乘：seq -s \* 1 10 | bc

python 中函数递归的最大深度为1000，所以要尽量避免使用递归，可是使用迭代代替:

1234567891011

 #!/usr/bin/env pythondef func_name(n):    answer = 1    for x in range(1,n,1):        answer *= x    return answeranswer = func_name(1001)print answer

函数作为参数

在python中函数也可以当作参数，可以作为函数的返回值函数

123456789101112131415

#!/usr/bin/env pythondef fun1():    print "calling fun1"def fun2(f):    print "calling fun2"    f()fun2(fun1)=========结果======root@tonglele /mnt # python fun.py calling fun2calling fun1

高阶函数

在python中以函数作为参数的函数叫做高阶函数
下面介绍三个内置的高阶函数

filter函数

filter:filter(function or none,seq)
可以看作是一个过滤函数 当函数返回值为true时，会将当前值加进序列
简单的使用：

123456789101112

#!/usr/bin/env pythonli = [0,1,2,3,4,5,6,7,8,9,10]def fun(x):    return x % 2 == 0print filter(fun,li)===========结果=======root@tonglele /mnt # python fun.py [0, 2, 4, 6, 8, 10]  #类似于列表解析

自己用代码实现filter函数的功能：

12345678910111213141516171819

#!/usr/bin/env pythonli = [1,2,3,4,5,6,7,8,9,10]def afilter(f,li):    li1 = []    for i in li:        if f(i):            li1.append(i)    return li1def fun(x):    return x % 2 == 0print afilter(fun,li)=======结果======root@tonglele /home/tyj/Desktop/Python1[基础]/code/6-5 # python filter.py[2, 4, 6, 8, 10]

map函数

map:map(function or none,seq)
对列表中的所有元素执行一个函数
简单使用map函数：

123456789101112

 #!/usr/bin/env pythonli = [0,1,2,3,4,5,6,7,8,9,10]def fun(x):    return x ** 2print map(fun,li)==========结果==========root@tonglele /mnt # python fun.py[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

自己用代码实现map函数：

123456789101112131415161718

 #!/usr/bin/env pythonli = [1,2,3,4,5,6,7,8,9,10]def mymap(f,li):    li1 = []    for i in li:        li1.append(f(i))    return li1def fun(x):    return x ** 2print mymap(fun,li)=========结果=======root@tonglele /home/tyj/Desktop/Python1[基础]/code/6-5 # python map.py   [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

reduce函数

reduce:reduce(function,seq)
先对进来的列表中的前两个元素进行function操作，得到的结果再与第三个元素一起进行function操作，所以function一定要是一个二元操作函数
简单使用reduce函数：

123456789101112131415

 #!/usr/bin/env pythonli = [0,1,2,3,4,5,6,7,8,9,10]def comp(x,y):    if x >= y:        return x    else:        return yprint reduce(comp,li)=======结果======root@tonglele /mnt # python fun.py10

自己用代码实现reduce：

12345678910111213141516171819202122

 #!/usr/bin/env pythonli = [1,4,5,7,13,7,8,9,10]def myreduce(f,li):    answer = li[0]    li_len = len(li)    for index in  range(1,li_len):        answer = f(answer,li[index])    return answerdef comp(x,y):    if x <= y:        return y    else:        return xprint myreduce(comp,li)=========结果=======root@tonglele /home/tyj/Desktop/Python1[基础]/code/6-5 # python reduce.py13

用自己实现的reduce 选取出一大组数中最大的两个:
先将一大组数划分为几个小块
选取出每个小块中最大的两个
再选取出原来的那个一大组数中的最大的两个

12345678910111213141516171819202122232425262728

#!/usr/bin/env pythonli = [[1,4,5],[7,13,7],[8,9,10]]def myreduce(f,li):    answer = li[0]    li_len = len(li)    for index in  range(1,li_len):        answer = f(answer,li[index])    return answerdef find_b(li1,li2):    li1.sort()    li2.sort()    li = []    for i in range(2):        li.append(li1.pop())        li.append(li2.pop())    li.sort()    li = li[len(li) - 2:len(li)]    return liprint myreduce(find_b,li)===========结果========root@tonglele /home/tyj/Desktop/Python1[基础]/code/6-5 # python reduce++.py[10, 13]