Python 的几个重要函数：
1、Lambda表达式：
语法： lambda argument1, argument2,...,argumentN:expression using arguments
lambda实质上是一个表达式，冒号后面的部分是表达式的返回值，使用它就可以很方便的用于不允许def出现的地方，如列表中或函数的参数中。
例1：参数无默认值，位置参数：
f=lambda x,y,z:x+y+z
print f(1,2,3) # 6
例2：参数有默认值，位置参数，关键字参数：
f=lambda a="I", b="Love", c ="Python": a+b+c
f("We") # 'WeLovePython'
f=lambda a="I", b="Love", c ="Python": a+b+c
f(b="Hate") # 'IHatePython'
f=lambda a,b="Love", c="Python": a+b+c # 需要同时有位置参数和关键字参数的时候，位置参数靠前。
f("We",b="Hate",c="US") # 'WeHateUS'
例3：求阶乘：结合reduce函数（稍后讲）：
from functools import reduce
n = 6
print(reduce(lambda x,y:x*y,range(1,n+1))) # 720
例4：lambda的嵌套使用：
b = lambda x:lambda y:x+y
a = b(3) # 返回一个lambda表达式： a=lambda y:3+y
print (a(2)) # 实际执行： a=lambda y:3+y a(2) 结果：5
print ((b(2))(2)) # 实际执行： f=lambda y:2+y f(2) 结果：4
相当于：
def f(x):
return lambda y:x+y
a=f(3) # 返回一个lambda表达式： a=lambda y:3+y
print(a(2)) # 实际执行： a=lambda y:3+y a(2) 结果：5
print((b(2))(2)) # 实际执行： f_=lambda y:2+y f_(2) 结果：4
例5：在列表中使用：用于生成跳转表：
L = [lambda x:x2, lambda x:x3, lambda x:x**4]
for f in L:
print(f(2)) # 4 8 16
例6：lambda 和 if...else 结合使用：
f=lambda x:x2 if (x % 2)==0 else x3
print(f(2)) # 4
print(f(3)) # 27
2、map函数：
语法：map(function, iterable)
第一个参数是函数名或lambda表达式，第二个元素传入可迭代对象。
作用：使用函数对可迭代对象中的每个元素进行处理，得到map object，可以使用list/set函数转化为列表/集合：
例1：
l1 = [1,2,3,4,5]
result = map(lambda x:x+1,l1)
print(result) # <map object at 0x000002370FF3BB48>
print(list(result)) # [2, 3, 4, 5, 6]
例2：
result = map(lambda x:"D" if x=="d" else x,s)
print(result) # <map object at 0x000002370FF47B88>
sl=list(result)
print(sl) # ['a', 'b', 'c', 'D', 'e', 'f', 'g']
new_s="".join(sl)
print(new_s) # abcDefg
ss=set(result)
print(ss) # {'f', 'b', 'a', 'e', 'c', 'D', 'g'}
print(str(result)) # <map object at 0x000002370FF47B88>
3、reduce函数：
语法：reduce(function, sequence[,initial=None]) function可以是lambda表达式：
第一个参数是函数，第二个参数为序列(需要能对该序列进行for循环即可)，第三个参数为initial=None。
作用：利用function函数对sequence进行聚缩，获得一个数字。
例1：列表求积：
from functools import reduce
ls = [1,2,3,4,5,6,7,8,9]
a = reduce(lambda x,y: x*y, ls,1)
print(a) # 362880
例2：求阶乘
from functools import reduce
n = 6
print(reduce(lambda x,y:x*y,range(1,n+1))) # 720
4、filter函数
语法：filter(function, iterable)
第一个参数是function，第二个iteralbel。
作用：过滤，留下使function返回值为True的iteralbel的元素：
例1：# 将列表中的偶数保留：
li=[2,3,4,5,6,7,8,9]
li_new=filter(lambda x:x%2==0,li)
print(list(li_new)) # [2, 4, 6, 8]
例2：# 将年龄大于18岁的剔除
people=[
{'name':'aaa','age':11},
{'name':'bbb','age':18},
{'name':'ccc','age':20}
]
print(list(filter(lambda x:x['age'] <= 18 ,people)))
Pandas中的几个重要的函数：
Series的几个函数：
1、map函数：只用于 Series:
语法：Series.map(dict) 或 Series.map(function)
作用：对序列中满足字典或函数规定的元素进行处理，其中function只接受一个参数，即Series里对应的每个元素。
例1：把数据集中gender列的男替换为1，女替换为0：
1）使用字典进行映射：
data["gender"] = data["gender"].map({"男":1, "女":0})
2）使用 def函数：
def gender_map(x):
return 1 if x == "男" else 0
data["gender"] = data["gender"].map(gender_map) #注意这里传入的是函数名，不带括号
3) 使用 lambda表达式：
data["gender"] = data["gender"].map(lambda x:1 if x=="男" else 0)
2、apply函数：
语法：Series.apply(function)
作用：apply方法的作用原理和map方法类似，区别在于参数function可以接收多个参数，因此实现的功能可以更复杂。
例1：假设在数据统计的过程中，年龄age列有较大误差，需要对其进行调整（加上或减去一个值），
由于这个加上或减去的值未知，故在定义函数时，需要加多一个参数bias，此时用map方法是操作不了的（传入map的函数只能接收一个参数），
apply方法则可以解决这个问题：
def apply_age(x,bias):
return x+bias
# 以args=元组的方式传入额外的参数
data["age"] = data["age"].apply(apply_age,args=(-3,)) # 缺省的参数就是Series里的元素
data["age"] = data["age"].apply((lambda x,bias:x+bias),args=(-3,))
data["age"] = data["age"].apply(lambda x:x-3) # 如果 bias=-3是固定的，可以直接这样。
例2：map和apply在function只接受一个参数时，效果一样：
import pandas as pd
import numpy as np
df_hz["净重是否一致？"]=df_hz["净重是否一致？"].apply(lambda x:"一致"if x==True else "不一致")
df_hz["净重是否一致？"]=df_hz["净重是否一致？"].map(lambda x:"一致" if x==True else "不一致")
df = pd.DataFrame(np.random.rand(2, 2), columns=list('AB')) # 形状为2x2的0-1之间的数构成的dataframe
print(df)
df["A"]=df["A"].apply((lambda x,y:x+y),args=(1,))
print(df)
df_score = pd.DataFrame(np.random.rand(2, 2)*100, columns=list('AB')) # 形状为2x2的0-1之间的数构成的dataframe
print(df_score)
df_score["A"]=df_score["A"].apply(lambda x:"优秀"if x>=80 else "一般")
print(df_score)
df_score2 = pd.DataFrame(np.random.rand(2, 2)*100, columns=list('AB')) # 形状为2x2的0-1之间的数构成的dataframe
print(df_score2)
df_score2["A"]=df_score2["A"].map(lambda x:"优秀"if x>=80 else "一般")
print(df_score2)
DataFrame的几个函数：
1、apply函数：
语法：dataframe.apply(function,axis=0)
作用：对dataframe的多行或多列或整个dataframe的每行或每列（Series）进行操作,根据function的类型(普通函数或聚合函数),返回dataframe或聚合Series。
function接收的参数是序列，而不是元素。
例1：
df = pd.DataFrame(np.random.rand(6, 3), columns=list('ABC'))
print(df)
df1=df.apply(lambda x:x*100,axis=1) # x为行Series,按行操作元素,返回一个结构和原dataframe一样的新的dataframe
print(df1)
A B C
0 33.538653 71.249145 5.037846
1 33.046605 19.985572 82.762447
2 14.170736 96.949203 19.425454
3 57.596054 8.871985 84.138249
4 60.109552 46.197523 36.904565
5 41.205720 64.347780 74.839440
df2=df[["A","C"]].apply(lambda x:x*-100,axis=0) # x为列Series,按列操作元素,返回一个只含"A"和"C"列的dataframe
print(df2)
A C
0 -42.431966 -15.729176
1 -1.908547 -26.970564
2 -54.378145 -1.202459
3 -64.568167 -9.193546
4 -91.014507 -13.606579
5 -93.857594 -34.910796
例2：
df_new=df[["B","C"]].apply(np.sum, axis=0) # x为列Series,按列求和,返回一个序列 Series
print(df_new)
2、applymap函数：
语法：dataframe.applymap(function)
作用：对DataFrame中的每个元素执行指定函数的操作：
例1：对dataframe中所有元素保留两位小数：
df = pd.DataFrame(
{
"A":np.random.randn(5),
"B":np.random.randn(5),
"C":np.random.randn(5),
"D":np.random.randn(5),
"E":np.random.randn(5),
}
)
print(df)
df_new=df.applymap(lambda x:"%.2f" % x) # x为元素
df_new=df.apply(lambda x:"%.2f" % x) # 使用apply会报错，因为 x为series不能作为float使用
print(df_new)
A B C D E
0 -1.053736 0.272299 -0.999303 1.022918 0.401127
1 0.129401 0.387668 -1.225724 -0.015265 0.210593
2 0.397829 0.707525 -0.628846 -1.723541 -0.227998
3 0.977949 -0.874221 1.570470 0.818799 0.371058
4 -1.238976 1.072337 -0.076957 -0.204579 -0.708090
A B C D E
0 -1.05 0.27 -1.00 1.02 0.40
1 0.13 0.39 -1.23 -0.02 0.21
2 0.40 0.71 -0.63 -1.72 -0.23
3 0.98 -0.87 1.57 0.82 0.37
4 -1.24 1.07 -0.08 -0.20 -0.71
3、apply与applymap的区别：
1）参数有区别，dataframe.apply需要指定axis，dataframe.applymap不需要；
2）参数里function接收的参数类型不一样，dataframe.apply的function接收的是Series，dataframe.applymap接收的是单个元素。
例1：验证类型：
df = pd.DataFrame(
{
"A":np.random.randn(5),
"B":np.random.randn(5),
"C":np.random.randn(5),
"D":np.random.randn(5),
"E":np.random.randn(5),
}
)
df2=df[["A","C"]].apply(lambda x:type(x),axis=0) # 验证apply里function接收到的x的类型
df3=df[["A","C"]].applymap(lambda x:type(x)) # 验证 x的类型
print(df2)
A <class 'pandas.core.series.Series'>
C <class 'pandas.core.series.Series'>
dtype: object
print(df3)
A C
0 <class 'float'> <class 'float'>
1 <class 'float'> <class 'float'>
2 <class 'float'> <class 'float'>
3 <class 'float'> <class 'float'>
4 <class 'float'> <class 'float'>
作者：Collin wx:pxy123abc tel:17763230890