python函数

一、函数的定义：

语法：
def <函数名>(<参数列表>):
<函数体>
return <返回值列表>

二、函数的调用

四个步骤：
1、调用程序在调用出暂停执行
2、在调用时将实参复制给函数的形参
3、执行函数体语句
4、函数调用结束给出返回值，程序回到调用前暂停处继续执行

三、函数的参数传递

位置参数 ---->关键字参数---->可变数量参数

1、普通的参数叫做位置参数，调用时需要按位置传递参数；
2、关键字参数就是在调用函数，传入实参时指定形参的变量名
3、可变数量参数（*c, **d)

• 在函数定义时,通过参数前增加单星号（*）实现。带有星号的可变参数只能出现在参数列表的后面。调用时，这些参数被当作元组类型传递到函数中

def vfunc(a,*b):
    print(type(b))
    for n in b:
        a+=n
     return a
vfunc(3,7,8)

<class 'tuple'>
18

• 在函数定义时，也可以通过在参数前增加带双星号的参数，向函数传递可变数量的参数。带有双星号的可变参数只能出现在参数列表的最后。调用时，后的那些参数被当作字典**类型传递到函数中

def my_sum(a,b,**c):
    total = a+b
    for key in c:
        total+=c[key]
    return total

my_sum(3,1,c = 3,d = 10)
17

my_sum(3,1,a = 3,d = 10)   #报错，c中参数不能与位置参数重复

def test_fun(a,b = 6,*c,**d):       # 一个*是元祖，两个*是字典
    print('a =  ',a,'.b = ',b,'.c =  ',c,' d = ',d)
test_fun(1)
test_fun(1,2)
test_fun(1,2,3)
test_fun(1,2,3,4)
test_fun(1,2,3,4,5,6)
test_fun(1,world = 6)
test_fun(a=1)
test_fun(a = 1,b = 2, c = 3)     # c,d只是占位符，不是名称
test_fun(1,2,3,4,x = 1)
#test_fun(1,2,3,4,b = 8)    # 报错

a =   1 .b =  6 .c =   ()  d =  {}
a =   1 .b =  2 .c =   ()  d =  {}
a =   1 .b =  2 .c =   (3,)  d =  {}
a =   1 .b =  2 .c =   (3, 4)  d =  {}
a =   1 .b =  2 .c =   (3, 4, 5, 6)  d =  {}
a =   1 .b =  6 .c =   ()  d =  {'world': 6}
a =   1 .b =  6 .c =   ()  d =  {}
a =   1 .b =  2 .c =   ()  d =  {'c': 3}
a =   1 .b =  2 .c =   (3, 4)  d =  {'x': 1}

可选参数：
在定义函数时，如果有些参数存在默认值，即部分参数不一定需要调用程序输入，可以在定义函数时直接为这些参数指定默认值。
当函数被调用时，如果没有传入对应的参数值，则使用函数定义时的默认值替代。
由于函数调用时需要按顺序输入参数，可选参数必须定义在非可选参数的后面

def fact(n,m = 1):    # m为可选参数
    s = 1
    for i in range(1,n+1):
        s*=i
    return s//m
fact(10)  # n=10,m=1
[out]:3628800

fact(10,5) # n=10,m=5
[out]:725760

强制命名参数

• 在带星号的参数后面申明参数会导致强制命名参数。调用时必须显式使用命名参数传递值，
• 如果不需要带星的可变参数，只想使用强制命名参数，可以简单地使用一个星号。例如：def my_func( *, a, b, c)

def f(*c,a,b):   # 第一个是*号
    return a+b
    
f(a=3,b=5)    # 调用数必须加参数名字
8

四、 lambda函数

<函数名> = lambda<参数> : <表达书> # 只可以包含一个表达书

等价于

def <函数名> (<参数>):

函数体

return <返回值>

f = lambda x :x+5

f(3)
8

g = lambda x,y = 2,z = 3:x+y+z

g(1)  # 参数默认值
6

g(2,z = 4,y = 5)  # 关键参数
11

sorted(['abc','afe','acb'],key = lambda x:(x[0],x[2])) 

['acb', 'abc', 'afe']

五、range函数

返回的是一个可迭代对象，不是列表类型

>>> list(range(1,10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(range(0,-10,-1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

>>> list(range(1,0))
[]

>>> list(range(5))
[0, 1, 2, 3, 4]

六、map函数

map(function,iterable,…)
function为函数
iterable为一个或多个序列
根据提供的函数对指定序列做映射,第一个参数function以参数序列中每一个元素调用function函数，返回包含每次function函数返回值的新列表

def square(x):
    return x**2
    
map (square, [1,2,3,4,5])   # 生成迭代器
<map at 0x23e1da8e4e0>

list(map (square, [1,2,3,4,5]))    # 转化为列表
[1, 4, 9, 16, 25]

list(map(lambda x,y:x+y,[1,2,3,4,5],[2,3,4,5,6]))  #提供两个列表，对相同位置的列表数据相加
[3, 5, 7, 9, 11]

for i in map(lambda x,y:x+y,[1,2,3,4,5],[2,3,4,5,6]):    
     print(i**2,end = '\t')
9	25	49	81	121	

def add(x,y,z):
    return x+y+z

list1 = [1,2,3]
list2 = [1,2,3,4]
list3 = [1,2,3,4,5]
res = map(add, list1, list2, list3)
print(list(res))      # 对列表1，2,3中位置相同的元素执行函数add

[3, 6, 9]

list(map(str,[1,2,3]))   # 把列表[1,2,3]变成字符串
['1', '2', '3']

>>> list(map(lambda x: x+5, [1, 2, 3, 4, 5]))  #把列表[1, 2, 3, 4, 5]每个元素加5
[6, 7, 8, 9, 10]

list(map(lambda x: len(x), ['a', 'bb', 'ccc']))
[1, 2, 3]

x,y,z = map(str,range(3))

y
'1'

七、filter函数

filter(function,ierrable)
filter()函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件的元素组成的新列表，接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回True或False，最后将返回True的元素放到新列表中

seq = ['foo','x41','?','**']
def func(x):
    return x.isalnum()   #测试是否为字母或数字
    
filter(func,seq)  #返回filter对象
<filter at 0x142178fe208>

list(filter(func,seq))   # 把filter对象转换为列表
['foo', 'x41']

list(filter(None,[0,1,2,3,0,0]))   # 去掉列表中的0再返回列表
[1, 2, 3]

list(filter(lambda x:x>2,[0,1,2,3,0,0]))   # 去掉列表中小于等于2的数然后返回列表
[3]

list(filter(lambda x:x%2 == 0,range(1,10))) # 返回列表中的偶数组成的列表
[2, 4, 6, 8]

八、zip函数

zip(seq[,seq,…])

把两个或多个序列中的相应项合并在一起，并且元祖的格式返回它们，在处理完最短序列中的所有项后就停止

a = [1,2,3]
b = [4,5,6]

zip(a,b)   # 返回迭代器
<zip at 0x23e1da7edc8>

list(zip(a,b))     #转换为列表
[(1, 4), (2, 5), (3, 6)]

a = [1,2,3]
b = [4,5,6]
zipped = zip(a,b)
list(zip(*zipped))  #zip里一个*号就还原  *zipped返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]

a = ['name','age','sex']
b = ['Dong',38,'Male']

dict(zip(a,b))    # 将两个列表的内容转换为字典
{'name': 'Dong', 'age': 38, 'sex': 'Male'}

x = range(1,4)
y = range(4,7)
sum([i*j for i,j in zip(x,y)])
32

x = 'abcd'
y = 'abcde'
[i ==j for i,j in zip(x,y)]
[True, True, True, True]

九、enumerate函数

enumerate(sequence,[start=0])

用于将一个可遍历的数据对象（如列表，元祖，字符串）组合为一个索引序列，同时列出数据和数据下标，一般用于for循环当中

seasons = ['Spring','Summer','Fall','Winter']
list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

list(enumerate(seasons, start = 1))  # 下标从1开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
In [12]:

i = 0
seq = ['Tom','Jerry','Bob']
for element in seq:
    print (i,seq[i])
    i+=1
    
0 Tom
1 Jerry
2 Bob

seq = ['Tom','Jerry','Bob']
for i,element in enumerate(seq):
    print(i,element)

0 Tom
1 Jerry
2 Bob

x = [3,2,3,3,4]
[index for index,value in enumerate(x) if value == 3]   # 返回值为3的序号
[0, 2, 3]

x = [1,2]
list(enumerate(x))
[(0, 1), (1, 2)]

x = [1, 3, 2]
[value for index, value in enumerate(x) if index==2]  #序号为2的值
[2]

十、reduce函数

reduce(function,iterable[,initializer])

函数会对参数序列中的元素进行累积 函数将一个数据集合（链表，元祖等）中的所有数据进行一下操作：用传给reduce中 的函数function（有两个参数）先对集合中的第1,2个元素进行操作，得到的结果再 与第三个数据用function函数运算，最后得到一个结果

from functools import reduce
def add(x,y):
    return x+y

reduce(add,[1,2,3,4,5])
15

reduce(lambda x,y:x-y,[1,2,3])  #先将1-2得-1，然后-1-3=-4
-4

reduce(lambda x,y:x+y,[1,2,3],6)
12