Python基础-函数[1]

Posted on

简单函数的定义

def 关键字定义函数

1
2
3
4
5
6
7
8
9
10
11
#!/usr/bin/env python

def func_name():             # def关键字定义函数
    print "hello world"

func_name()    #调用所定义的函数


========结果=====
root@tonglele /mnt # python fun.py 
hello world

局部变量和全局变量

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
（局部变量与全局变量）
#!/usr/bin/env python

a = 5               #这里的a为全局变量
def func_name():
    a = 'hello'    #这个a为局部变量，它的作用域为此函数
    print a

func_name()   #调用函数
print a   #这里打印的为全局变量a

========结果========
root@tonglele /mnt # python fun.py
hello
5


（global关键字）
#!/usr/bin/env python

a = 5
def func_name():
    global a            #这里使用global关键字定义a是全局变量a，在这个函数体内所有对a的赋值操作都是对全局变量a的改变
    a = 'hello'
    print a

func_name()
print a

==========结果=======
root@tonglele /mnt # python fun.py
hello
hello


(在函数体内可以直接调用全局变量)
#!/usr/bin/env python

a = 5
def func_name():
    print a

func_name()
print a

=======结果=======
root@tonglele /mnt # python fun.py
5
5

带不可变参数的函数

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

1
2
3
4
5
6
7
8
9
10
11
(传入一个参数)
#!/usr/bin/env python

def func_name(arg):  #arg 形参
    print arg      #arg作为参数传进来，相当于一个局部变量

func_name('hello tonglele')   #'hello tonglele'就是实参，是在调用函数时传给函数的参数

=======结果=======
root@tonglele /mnt # python fun.py
hello tonglele

传入多个参数

位置参数

1
2
3
4
5
6
7
8
9
#!/usr/bin/env python

def func_name(arg1,arg2):      #arg1,arg2为两个形参，中间用‘，’隔开
    print arg1+arg2      #打印arg1+arg2的结果

func_name(1,2)   #在调用函数时传入两个时参，中间用逗号隔开,需要注意的是顺序要按照所调用的函数定义的顺序
========结果======
root@tonglele /mnt # python fun.py
3

关键字参数

1
2
3
4
5
6
7
8
9
10
11
#!/usr/bin/env python

def func_name(arg1,arg2):
    print arg1
    print arg2

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

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

1
2
3
4
5
6
7
8
#!/usr/bin/env python

def func_name(arg1,arg2,arg3):
    print arg1
    print arg2
    print arg3

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

默认参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#!/usr/bin/env python

def func_name(arg1,arg2,arg3=3):   #给arg3一个默认值，如果在调用此函数时未给arg3传值，则取默认值3
    print arg1
    print arg2
    print arg3

func_name(1,2)     #此时未给arg3传参
==========结果========
root@tonglele /mnt # python fun.py
1
2
3

#!/usr/bin/env python

def func_name(arg1,arg2,arg3=3):    #在函数定义的时候,带默认值的参数必须放在不带默认值参数的后边。
    print arg1
    print arg2
    print arg3

func_name(1,2,5)    #此时给arg3传参，默认值将被覆盖
=======结果======
root@tonglele /mnt # python fun.py
1
2
5

带可变参数的函数

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

可变位置参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#!/usr/bin/env python

def func_name(*args):
    print type(args)
    for x in args:
        print x

func_name(1,2,5,'hello','tonglele')
=======结果=======
root@tonglele /mnt # python fun.py
<type 'tuple'>     #我们可以看出函数将传进来的参数打包成了一个元组
1
2
5
hello
tonglele

可变关键字参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/usr/bin/env python

def 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  ==>  19
name  ==>  tonglele
school  ==>  XAUT

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#!/usr/bin/env python

def func_name(arg1,arg2,*args):
    print arg1
    print arg2
    print args

func_name(1,2,3,4,5,5)
=======结果=======
root@tonglele /mnt # python fun.py
1
2
(3, 4, 5, 5)

参数解包

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/usr/bin/env python

def func_name(arg1,arg2,arg3):
    print arg1
    print arg2
    print arg3

li = [1,2,3]
func_name(*li)    #将一个列表解包传递进去
=======结果======
root@tonglele /mnt # python fun.py 
1
2
3

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/usr/bin/env python

def func_name(arg1,arg2,arg3):
    print arg1
    print arg2
    print arg3

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

函数返回值

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/usr/bin/env python

def func_name(arg1,arg2):
    arg3 = arg1 + arg2
    arg4 = arg1 * arg2
    return arg3,arg4

i,j = func_name(2,3)
print i
print j
===========结果===========
root@tonglele /mnt # python fun.py
5
6

python中的递归函数

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#!/usr/bin/env python

def 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，所以要尽量避免使用递归，可是使用迭代代替:

1
2
3
4
5
6
7
8
9
10
#!/usr/bin/env python

def func_name(n):
    answer = 1
    for x in range(1,n,1):
        answer *= x
    return answer

answer = func_name(1001)
print answer

函数作为参数

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/usr/bin/env python

def fun1():
    print "calling fun1"

def fun2(f):
    print "calling fun2"
    f()

fun2(fun1)
=========结果======
root@tonglele /mnt # python fun.py 
calling fun2
calling fun1

高阶函数

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

filter函数

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

1
2
3
4
5
6
7
8
9
10
11
#!/usr/bin/env python

li = [0,1,2,3,4,5,6,7,8,9,10]

def fun(x):
    return x % 2 == 0

print filter(fun,li)
===========结果=======
root@tonglele /mnt # python fun.py 
[0, 2, 4, 6, 8, 10]  #类似于列表解析

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#!/usr/bin/env python

li = [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 li1

def fun(x):
    return x % 2 == 0

print 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函数：

1
2
3
4
5
6
7
8
9
10
11
#!/usr/bin/env python

li = [0,1,2,3,4,5,6,7,8,9,10]

def fun(x):
    return x ** 2

print map(fun,li)
==========结果==========
root@tonglele /mnt # python fun.py
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

自己用代码实现map函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#!/usr/bin/env python

li = [1,2,3,4,5,6,7,8,9,10]

def mymap(f,li):
    li1 = []
    for i in li:
        li1.append(f(i))
    return li1

def fun(x):
    return x ** 2

print 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函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/usr/bin/env python

li = [0,1,2,3,4,5,6,7,8,9,10]

def comp(x,y):
    if x >= y:
        return x
    else:
        return y

print reduce(comp,li)
=======结果======
root@tonglele /mnt # python fun.py
10

自己用代码实现reduce：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#!/usr/bin/env python

li = [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 answer

def comp(x,y):
    if x <= y:
        return y
    else:
        return x

print myreduce(comp,li)
=========结果=======
root@tonglele /home/tyj/Desktop/Python1[基础]/code/6-5 # python reduce.py
13

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#!/usr/bin/env python

li = [[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 answer

def 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 li

print myreduce(find_b,li)
===========结果========
root@tonglele /home/tyj/Desktop/Python1[基础]/code/6-5 # python reduce++.py
[10, 13]

感谢阅读，欢迎指正。

-------------本文结束感谢您的阅读-------------