Python与Pandas关于数据处理的几个重要函数

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