python简明教程_06

python编程语言简明教程，翻译自以下仓库：
Python-Lectures
原仓库是一系列的jupyter notebook，可以直接在jupyter环境下运行程序示例。我添加了中文注释，并改为了兼容python3

函数

创建一个函数，可以将会重复使用的代码放入一个函数中

以下是基本的函数编写格式：

def funcname(arg1, arg2,… argN):

''' Document String'''

statements


return <value>

“funcname” 是函数名称, "arg1,arg2,…argN"是传入函数的若干参数. ‘’‘Document String’’’ 中可以写关于此函数的文档. “value” 是函数执行完成后的返回值.

print("Hey Rajath!")
print("Rajath, How do you do?")

Hey Rajath!
Rajath, How do you do?

可以把上面两句print一起写入一个函数，调用这一个函数就能print以上两行

def firstfunc():
    print("Hey Rajath!")
    print("Rajath, How do you do?")   

firstfunc()

Hey Rajath!
Rajath, How do you do?

firstfunc() 现在还没有接受参数，我们也可以将某些信息当做参数传递给一个函数：

def firstfunc(username):
    print("Hey", username + '!')
    print(username + ',' ,"How do you do?")

name1 = input('Please enter your name : ') ###在接下来出现的对话框中输入文字即可

Please enter your name :

现在，输入的内容已经存入了变量name1. 我们把这个变量传递给函数 firstfunc()

firstfunc(name1)

Hey hanmoge!
hanmoge, How do you do?

我们还可以把以上步骤写入另一个函数： secondfunc() 这个函数会获取输入的文字，当做变量name，然后把name传递给 firstfunc()

def firstfunc(username):
    print("Hey", username + '!')
    print(username + ',' ,"How do you do?")
def secondfunc():
    name = input("Please enter your name : ")
    firstfunc(name)

secondfunc()

Please enter your name : hanmoge
Hey hanmoge!
hanmoge, How do you do?

函数的返回值

函数可以用return返回一些信息给函数外，例如：

def times(x,y):
    z = x*y
    return z

以上函数 times( ) 接受两个变量，然后把两个变量的值的乘积返回回去：

c = times(4,5)
print(c)

20

变量c储存了函数 times() 的返回值

以上是return了一个新的变量z，也可以不声明这个变量z，直接返回x乘以y

def times(x,y):
    '''This multiplies the two input arguments'''
    return(x*y)

c = times(4,5)
print(c)

20

times( ) 的文档内容，可以通过help([函数名])的方式显示：

help(times)

Help on function times in module __main__:

times(x, y)
    This multiplies the two input arguments

return也可以返回多个变量，顺序是固定的

eglist = [10,50,30,12,6,8,100]

def egfunc(eglist):
    highest = max(eglist)
    lowest = min(eglist)
    first = eglist[0]
    last = eglist[-1]
    return highest,lowest,first,last

如果调用函数的时候没有将返回值赋值给一个变量，默认把所有返回值放到一个元组里。如果用变量接收函数的返回值，函数返回的值会以特定顺序分配给变量，该特定顺序在函数return语句中声明。

egfunc(eglist)

(100, 6, 10, 100)

a,b,c,d = egfunc(eglist)
print(' a =',a,'\n b =',b,'\n c =',c,'\n d =',d) 
### abcd四个变量按照顺序接收了函数的返回值，即a对应highest、b对应lowest、c对应first、d对应last

a = 100
b = 6
c = 10
d = 100

隐式参数

有时候函数某个参数可能经常会被赋予某个值，这时就可以在声明函数的时候把参数的值写上，例如：

def implicitadd(x,y=3):
    return(x+y)

implicitadd( ) 是两数相加的函数，但可能很多时候我们只希望某个数加3，这样就可以把第二个参数先给赋值为3，第二个参数y就叫做隐式参数。

那么如果只给 implicitadd( ) 函数一个参数，就会把这个值给x，让x和3相加：

implicitadd(4)

7

但如果给足函数两个参数，那么就会用新赋予参数的值覆盖3。也就是说，隐式参数的作用是，如果不给这个参数赋值，就用写好的默认值3，如果给这个参数赋值，就用所给的值。

implicitadd(4,4)

8

任意数量的参数

如果传入函数的参数个数不确定，可以用以下这种加星号的方式，表示任何多个无名参数

def add_n(*args):
    res = 0
    reslist = []
    for i in args:
        reslist.append(i)
    print(reslist)
    return sum(reslist)

以上函数可以接受任意数量的数字作为输入（用逗号隔开），在函数内部，将这些输入的参数赋值给一个列表reslist，再返回这个列表的和.

add_n(1,2,3,4,5)

[1, 2, 3, 4, 5]
15

add_n(1,2,3)

[1, 2, 3]
6

全局变量和局部变量

在函数内部声明的是该函数的局部变量，在函数外部声明的对函数来讲是全局变量。

eg1 = [1,2,3,4,5]

在以下程序中，eg2就是thirdfunc的局部变量，很显然在thirdfunc的函数体范围外是无法访问的：

def egfunc1():
    def thirdfunc(arg1):
        eg2 = arg1[:]
        eg2.append(6)
        print("这句在函数thirdfunc里 :", eg2) 
    print("在函数调用前 : ", eg1)
    thirdfunc(eg1)
    print("这句在函数thirdfunc外 :", eg1)   
    print("很显然在函数外访问函数的局部变量会报错 :" , eg2)

egfunc1()

在函数调用前 :  [1, 2, 3, 4, 5]
这句在函数thirdfunc里 : [1, 2, 3, 4, 5, 6]
这句在函数thirdfunc外 : [1, 2, 3, 4, 5]
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-26-a0aede218e7c> in <module>
----> 1 egfunc1()

<ipython-input-25-116387c82a1b> in egfunc1()
      7     thirdfunc(eg1)
      8     print("这句在函数thirdfunc外 :", eg1)
----> 9     print("很显然在函数外访问函数的局部变量会报错 :" , eg2)

NameError: name 'eg2' is not defined

如果在声明变量的时候，前面加上 global ，那么这个变量就变成了全局变量，可以在函数外被访问：

eg3 = [1,2,3,4,5]

def egfunc1():
    def thirdfunc(arg1):
        global eg2
        eg2 = arg1[:]
        eg2.append(6)
        print("这句在函数thirdfunc里 :", eg2 )
    print("在函数调用前 : ", eg1)
    thirdfunc(eg1)
    print("这句在函数thirdfunc外 :", eg1)
    print("现在在函数范围外也可以访问eg2了 :" , eg2)

egfunc1()

在函数调用前 : [1, 2, 3, 4, 5]
这句在函数thirdfunc里 : [1, 2, 3, 4, 5, 6]
这句在函数thirdfunc外 : [1, 2, 3, 4, 5]
现在在函数范围外也可以访问eg2了 : [1, 2, 3, 4, 5, 6]

Lambda 函数

Lambda函数是一类表达式，执行类似函数的功能，但并不需要声明一个函数名称. 对列表List进行操作时，Lambda函数比较方便. Lambda函数用 lambda 加变量名，再加冒号的方式使用

z = lambda x: x * x
z(8)

64

map

map( ) 依次执行对一个列表中各个元素的操作.

list1 = [1,2,3,4,5,6,7,8,9]
eg = map(lambda x:x+2, list1)
print(eg)
### 注：eg是一个map对象，本质是一个迭代器，所以可以通过for循环或者构造list来使用这个迭代器：
list(eg)

<map object at 0x7f85e4537470>
[3, 4, 5, 6, 7, 8, 9, 10, 11]

也可对两个列表进行操作：

list2 = [9,8,7,6,5,4,3,2,1]
eg2 = map(lambda x,y:x+y, list1,list2)
print(eg2)
list(eg2)

<map object at 0x7f85e4537b38>
[10, 10, 10, 10, 10, 10, 10, 10, 10]

map函数中，不仅可以用lambda函数做操作，也可以用其他python内置函数：

eg3 = map(str,list2)  ### 把list2中的每个元素转化为字符串
print(eg3)
list(eg3)

<map object at 0x7f85e4537518>
[‘9’, ‘8’, ‘7’, ‘6’, ‘5’, ‘4’, ‘3’, ‘2’, ‘1’]

filter

filter( ) 函数用来过滤列表中的元素。 filter() 返回的也是一个迭代器。

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

挑出所有小于5的元素：

list(filter(lambda x:x<5,list1))

[1, 2, 3, 4]

对比一下 map() 函数，同样的内容，map返回一个判断值.

list(map(lambda x:x<5, list1))

[True, True, True, True, False, False, False, False, False]