Python 学习中碰到的函数

​

1、map（作用于后面的序列）

格式

map（func,sep1,sep2,…）

map函数第一个参数接受的是一个函数，后面接收的是一个或多个可迭代的序列（列表、元组和字符串），他返回的是一个集合。

也可以理解为：map（）函数是将 func函数作用于后面序列中的每一个数，并将所有的调用结果作为一个list返回，如果 func为None，作用同zip()函数。

1、当sep只有一个时，将函数func作用于这个sep序列的每一个元素上，并得到一个新的sep

map（）函数工作流程：↓

​​

从上图可以看出，函数func函数会作用于seq中的每个元素，得到func(seq[n])组成的列表。下面举得例子来帮助我们更好的理解这个工作过程。

1、

print(list( map(lambda x:x%2 range(5)) ))
[1,0,1,0]
一个sep时候，可以用filter（）函数代替

2、当seq多于一个时，map可以并行（注意是并行）地对每个seq执行如下图所示的过程：

有图可以看出，我们seq1，seq2的对应位置元素同时 传入我们的函数，且得到一个返回值，我们将这个返回值存放在一个列表里面，

print( list(map(lambda x , y : (x,y), [2,4,6],[3,2,1])))
[(2, 3), (4, 2), (6, 1)]

我们还可以定义返回值的形式
比如元组:
print( list( map(lambda x,y:(x,y),[1,2,3],[4,5,6]) ))
比如字典
print( list( map(lambda x,y:{x:y},[1,2,3],[4,5,6])))
其实说实话 你如果看的不是很懂 你就这么理解 我们前面不是有参数么,
我们后面也有对应个数的序列,你可以理解为 我们第一个参数对应第一个序列.
#第n个参数对应第n个序列 并把他们传入我们对应的函数进行运算,每一次运算的结果都会存放在 列表中

借鉴于：
map

2、filter（过滤）

格式

filter:过滤函数
概念:filter函数 也会接收一个序列或者函数,他也会作用于 每次元素上 如果返回值为True 就会保留并返回 如果为Flase 就会舍去
格式:
舍去 奇数
def idd(x):
return x%2==0
x=[1,2,3,4]
print(list(filter(idd,x)))

3、 lambda(匿名函数)

在python中，我们可以使用lambda关键字来声明一个匿名函数这就是我们为什么 称它为“lambda匿名函数”。匿名函数是指没有声明函数名称的函数。 尽管他们形式上不相同，但是它的行为方式和def定义的函数完全一致。
那为什么要使用它呢?
一般是需要短时间使用函数才使用lambda函数

语法

lambda函数只包含一个语句，表现形式如下：
lambda [arg1,[,arg2,arg3,…]]:expression
其中lambda是预留的关键字，arg和expression由用户自定义
arg：是参数列表，他和python中函数的（function）的定义是一样的
略微我提一下他的参数列表形式：
a,b a=1,b=1 *args **args a,b=1,*args 空 .....
*和**的区别
expression是一个参数表达式，表达式中出现的参数需要在arg里面有定义，并且表达式是单行的，只能有一个表达式，比如：
1, None, a + b, sum(a), 1 if a >10 else 0, ......

特点

接下来请看lambda函数的一些特点：

1、当然既然叫匿名函数。它肯定是匿名的：
。。。。所谓匿名函数，通俗的讲它就是没有名字的函数，lambda函数没有名字
2、lambda 函数可以接受任意数量的参数，但函数只能包含一个表达式。
3、表达式lambda函数执行的一段代码，它可以返回任何的值，也可以不返回值
。。。。它有输入、输出的值，当然 上面说了，输出（返回）值不是必要的。
4、lambda可以返回函数对象，我们可以把返回的函数赋值给其他变量
5、拥有自己的命名空间
。。。。不能访问自己参数列表之外或全局命名空间里面的参数，只能完成非常简单的功能（我自己理解为，lambda函数是独立的 就好比 全局变量a 我们给lamba函数一个参数a 他们毫不相关）

用法

我们可以使用一下语法来声明一个lambda函数：
lambda s1,s2，.......：expression
如上面所述，我们的参数可以写多个，但是只能有一个表达式
举例：
qumo=lambda num:num%2
print(qumo(5))
输出:
1
在这段代码中，num就是我们的参数，num%2 就是我们的表达式，表达式用来计算结果，然后返回。该表达式获取输入的参数，然后%2，得到余数1，当然这是只有一个参数的情况下，多个参数也是一样，数组之类的序列都是像遍历数组一样，一个一个传入，一个一个计算，一个一个返回。
为了方便理解（因为我也是小白）上面的lambda函数也相当于下面这种：
def qumo(num): return num % 2
上面是一个参数的时候，接下来我们看看大于一个的时候
pro =lambda x,y:x*y print( pro(2,3) )
输出 6

函数中调用lambda函数：

开始我看的时候，我还有点蒙，我理解为：我们将testfunc函数 赋给了 result1，testfunc（10）传入的参数是他自己本身的，也就是num，当执行到result的时候，result（9）传入的参数就是 lambda的参数 x

def testfunc(num):
    return lambda x : x * num
result1 = testfunc(10)
print(result1(9))   ##输出  90


def testfunc(num):
    return lambda x : x * num
 
result1 = testfunc(10)
result2 = testfunc(1000)
 
print(result1(9))  ##输出 90
print(result2(9))	##输出 9000

高阶使用

所谓高阶使用就是和其他内置函数一起使用，比如我上面的map和fileter。

4、保留指定位数的几种方法

1、"%.nf"（四舍五入）

f=1.23456

print("%.2f"%f) >> 1.23
print("%.3f"%f)  >>1.235

2、format函数（四舍五入）

f=1.23456

print("{:.2f}".format(f))  >>1.23
print("{:.3f}".format(f))  >>1.235

5、join函数

Python里面的join函数功能和强大，可以把字符串、元组、列表中的元素一指定的字符（分隔符）连接生成一个新的字符串，而且分割的字符也可以是一个字符串，接下来我们详细的介绍这个函数：

1、语法

string.join()

’sep‘.join(data)

代码解析：
sep:代表分隔符，可以是单个字符串，如： ， 。 - ：等。也可以是字符串：’abc‘
data:代表要连接的元素，可以是字符串、数组、列表、字典等
注意：他们两个都必须是string型，不能是int型和float型

os.path.join()

os.path.join(path1,path2,)
代码解析：
把path1，path2等用`\连接起来，组成文件路径

2、具体实例

6、zip函数

定义

1 、从参数中的多个迭代器取元素组合成一个新的迭代器
2、返回：一个zip对象，其内部元素为元组；可以转化成列表或元组
3、传入参数：元组、列表、字典等迭代器

返回值

zip（）函数返回一个真正的python列表，就像map（）一样

使用

当zip()函数中只有一个参数时，zip(iterable)从迭代器中依次取一个元组，组成一个元组。

# python 3
# zip()函数单个参数
In [1]: list1 = [1, 2, 3, 4]
In [2]: tuple1 = zip(list1)
In [3]: type(tuple1)
Out[3]: zip
In [4]: list(tuple1)
Out[4]: [(1,), (2,), (3,), (4,)]

当zip()函数有两个参数时，
zip(a,b)函数分别从a和b中取一个元素组成元组，
再次将组成的元组组合成一个新的迭代器。
a与b的维数相同时，正常组合对应位置的元素。
当a与b行或列数不同时，取两者中的最小的行列数

# zip()函数有两个参数
In [5]: m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
In [6]: n = [[1, 1, 1], [2, 2, 3], [3, 3, 3]]
In [7]: p = [[1, 1, 1], [2, 2, 2]]
In [8]: list(zip(m,n))
Out[8]: [([1, 2, 3], [1, 1, 1]), ([4, 5, 6], [2, 2, 3]), ([7, 8, 9], [3, 3, 3])]
In [9]: list(zip(m,p))
Out[9]: [([1, 2, 3], [1, 1, 1]), ([4, 5, 6], [2, 2, 2])]

反向操作

只要您使用特殊*操作符,zip就是它自己的反面！

import numpy as np
a=[1,2,3]
b=[4,5,6,7]
c=[8,9,10,11,12]
zz=zip(a,b,c)
print(zz)

x,y,z=zip(*zz)
print(x)
print(y)
print(z)

输出：
[(1, 4, 8), (2, 5, 9), (3, 6, 10)]
(1, 2, 3)
(4, 5, 6)
(8, 9, 10)