pandas学习笔记

异常值检测和过滤
使用 describe() 函数查看每一列的描述性统计

count 列的元素的个数

mean 平均值

std 标准方差，描述数据的波动，离散程度

min 最小

max 最大

数据小于标准方差的四倍，认为数据是有意义的

DataFrame.info()

这个函数可以输出读入表格的一些具体信息。这对于加快数据预处理非常有帮助。

独热编码实现方法比较

1、pandas自带的get_dummies()【适合含有字符串类型的数据】
当频繁出现的几个独立变量时，可以使用pandas.get_dummies( )将定性变量转换为 Dummy 变量

好处： * 1.本身就是 pandas 的模块，所以对 DataFrame 类型兼容很好.
* 2.无论你的列是字符型还是数字型都可以进行二值编码.
* 3.能根据用户指定，自动生成二值编码后的变量名.
1 传入Series

import pandas as pd
list1 = pd.Series(list('abcaa'))
dummies_list = pd.get_dummies(list1)
dummies_list

结果：

	a	b	c
0	1	0	0
1	0	1	0
2	0	0	1
3	1	0	0
4	1	0	0

传入DataFrame

df = pd.DataFrame({'A': ['a', 'b', 'a'], 'B': ['b', 'a', 'c'], 'C': [1, 2, 3]})
print(df)
dummies_df = pd.get_dummies(df, prefix = ['col1', 'col2'])
dummies_df

结果：

   A  B  C
0  a  b  1
1  b  a  2
2  a  c  3
    C	col1_a	col1_b	col2_a	col2_b	col2_c
0	1	   1	  0	 	  0		 1		  0
1	2	   0	  1		  1  	 0	 	  0
2	3	   1	  0		  0		 0	 	  1

问题：get_dummies 没有sklearn 的 transformer方法，所以一旦测试集中出现了训练集未曾出现过的特征取值，简单地对测试集、训练集都用 get_dummies 方法将导致数据错误。 也无法像 sklearn 的transformer一样可以输入到pipeline中 进行流程化地机器学习过程。

2、sklearn的OneHotEncoder()【适合只含数值型的数据】

通过 OneHotEncoder() 自带的 feature_indices_ 可以知道哪几列对应哪个原来的特征

使用 numpy.hstack() 将多次结果拼接起来得到变换后的结果

问题：不能直接编码字符串类型数据（LabelEncoder() + OneHotEncoder() 可实现，但需数据格式转换）

print(df.isnull().any()) #用来判断某列是否有缺失值

df.isnull().all() #用来判断某列是否全部为空值

df.isnull().sum() #直接告诉我们每列缺失值的数量。

Pandas.factorize( )

当有多个变量出现时，可以使用pandas.factorize( )创建一些数字，来表示类别变量，对每一个类别映射一个ID，这种映射最后只生成一个特征，不像dummy那样生成多个特征。
factorize（）函数可以将Series中的标称型数据映射称为一组数字，相同的标称型映射为相同的数字。factorize函数的返回值是一个tuple（元组），元组中包含两个元素。第一个元素是一个array，其中的元素是标称型元素映射为的数字；第二个元素是Index类型，其中的元素是所有标称型元素，没有重复。

print(pd.factorize(pd.Series(list('abcaadedffg'))))
df = pd.DataFrame({"id":[1,2,3,4,5,6,3,2], "raw_grade":['a', 'b', 'b', 'a', 'a', 'e','c','a']})
df
x = pd.factorize(df.raw_grade)
x

结果：

(array([0, 1, 2, 0, 0, 3, 4, 3, 5, 5, 6]),
 Index(['a', 'b', 'c', 'd', 'e', 'f', 'g'], dtype='object'))
	id	raw_grade
0	1	a
1	2	b
2	3	b
3	4	a
4	5	a
5	6	e
6	3	c
7	2	a

(array([0, 1, 1, 0, 0, 2, 3, 0]), Index(['a', 'b', 'e', 'c'], dtype='object'))

Pandas.Categorical()

categorical 是计算一个列表型数据中的类别数，即不重复项，它返回的是一个CategoricalDtype 类型的对象，相当于在原来数据上附加上类别信息 ，具体的类别和对应的序号可以通过 categories 和 codes来查看
pd.Categorical( list ).codes 可以直接得到原始数据的对应的序号列表，通过这样的处理可以将类别信息转化成数值信息

import pandas as pd

ss = ['a','a','b','c','c']
ss = pd.Categorical(ss)
print(ss, '\n')
print('ss.dtype:', ss.dtype, 'ss.codes:', ss.codes, 'ss.categories:', ss.categories)

结果：

[a, a, b, c, c]
Categories (3, object): [a, b, c] 

ss.dtype: category ss.codes: [0 0 1 2 2] ss.categories: Index(['a', 'b', 'c'], dtype='object')

pd.qcut(x,q[,labels,retbins,precision])

qcut是根据这些值的频率来选择箱子的均匀间隔，即每个箱子中含有的数的数量是相同的。
x：ndarray或Series
q:必须的参数
precision： int，精度，默认为3
传入q参数：指示划分的组数

factors = np.random.randn(9)
print(pd.qcut(factors, 3))  #返回每个数对应的分组
pd.qcut(factors, 3).value_counts() #计算每个分组中含有的数的数量

结果

[(1.061, 2.774], (1.061, 2.774], (-1.464, -0.349], (-0.349, 1.061], (1.061, 2.774], (-0.349, 1.061], (-1.464, -0.349], (-1.464, -0.349], (-0.349, 1.061]]
Categories (3, interval[float64]): [(-1.464, -0.349] < (-0.349, 1.061] < (1.061, 2.774]]

(-1.464, -0.349]    3
(-0.349, 1.061]     3
(1.061, 2.774]      3
dtype: int64

传入label参数：array或bool，默认为None。当传入数组时，分组的名称由label指示；当传入Flase时，仅显示分组下标

print(pd.qcut(factors, 3,labels=["a","b","c"]))#返回每个数对应的分组，但分组名称由label指示
pd.qcut(factors, 3,labels=False) #返回每个数对应的分组，但仅显示分组下标

结果

[c, c, a, b, c, b, a, a, b]
Categories (3, object): [a < b < c]
array([2, 2, 0, 1, 2, 1, 0, 0, 1])

传入retbins参数：bool，是否返回bins，默认为False。当传入True时，额外返回bins，即每个边界值。

pd.qcut(factors, 3,retbins=True)# 返回每个数对应的分组，且额外返回bins，即每个边界值

结果：

([(-0.518, 0.387], (0.387, 1.449], (-0.927, -0.518], (0.387, 1.449], (-0.518, 0.387], (-0.518, 0.387], (-0.927, -0.518], (0.387, 1.449], (-0.927, -0.518]]
 Categories (3, interval[float64]): [(-0.927, -0.518] < (-0.518, 0.387] < (0.387, 1.449]],
 array([-0.92646072, -0.51765899,  0.38652167,  1.44850209]))

pd.cut(x,bins[,labels,retbins,precision])

cut将根据值本身来选择箱子均匀间隔，即每个箱子的间距都是相同的
x: array，仅能使用一维数组, ndarray or Series
bins: integer或sequence of scalars，指示划分的组数或指定组距
labels:array或bool，默认为None。当传入数组时，分组的名称由label指示；当传入Flase时，仅显示分组下标
retbins: bool，是否返回bins，默认为False。当传入True时，额外返回bins，即每个边界值。
precision: int，精度，默认为3

pd.cut(factors, 3) #返回每个数对应的分组

结果：

[(0.732, 2.154], (-0.69, 0.732], (0.732, 2.154], (-0.69, 0.732], (-2.117, -0.69], (0.732, 2.154], (-0.69, 0.732], (-0.69, 0.732], (0.732, 2.154]]
Categories (3, interval[float64]): [(-2.117, -0.69] < (-0.69, 0.732] < (0.732, 2.154]]

pd.cut(factors, bins=[-3,-2,-1,0,1,2,3])

结果：

[(-1, 0], (0, 1], (0, 1], (0, 1], (-1, 0], (1, 2], (0, 1], (0, 1], (-1, 0]]
Categories (6, interval[int64]): [(-3, -2] < (-2, -1] < (-1, 0] < (0, 1] < (1, 2] < (2, 3]]

pd.cut(factors, 3).value_counts() #计算每个分组中含有的数的数量

(-0.969, -0.122]    3
(-0.122, 0.723]     4
(0.723, 1.567]      2
dtype: int64

传入label参数：

 print(pd.cut(factors, 3,labels=["a","b","c"])) #返回每个数对应的分组，但分组名称由label指示
  pd.cut(factors, 3,labels=False) #返回每个数对应的分组，但仅显示分组下标

结果：

[a, b, c, b, a, c, b, b, a]
Categories (3, object): [a < b < c]

array([0, 1, 2, 1, 0, 2, 1, 1, 0])

传入retbins参数：

pd.cut(factors, 3,retbins=True)# 返回每个数对应的分组，且额外返回bins，即每个边界值

结果：

([(-0.969, -0.122], (-0.122, 0.723], (0.723, 1.567], (-0.122, 0.723], (-0.969, -0.122], (0.723, 1.567], (-0.122, 0.723], (-0.122, 0.723], (-0.969, -0.122]]
 Categories (3, interval[float64]): [(-0.969, -0.122] < (-0.122, 0.723] < (0.723, 1.567]],
 array([-0.96897151, -0.12192407,  0.72258982,  1.56710371]))

re.findall() 坑：捕获分组和非捕获分组

在正则表达式前面加上?:可以将捕获分组变成非捕获分组
详细参考 https://blog.csdn.net/qq_39021458/article/details/82429978

数据聚合groupby和分组运算transform，apply

pd.concat(objs, axis=0, join=‘outer’, join_axes=None, ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True)

参数含义

objs：Series，DataFrame或Panel对象的序列或映射。如果传递了dict，则排序的键将用作键参数，除非它被传递，在这种情况下，将选择值（见下文）。任何无对象将被静默删除，除非它们都是无，在这种情况下将引发一个ValueError。
axis：{0,1，...}，默认为0。沿着连接的轴。
join：{'inner'，'outer'}，默认为“outer”。如何处理其他轴上的索引。outer为联合和inner为交集。
ignore_index：boolean，default False。如果为True，请不要使用并置轴上的索引值。结果轴将被标记为0，...，n-1。如果要连接其中并置轴没有有意义的索引信息的对象，这将非常有用。注意，其他轴上的索引值在连接中仍然受到尊重。
join_axes：Index对象列表。用于其他n-1轴的特定索引，而不是执行内部/外部设置逻辑。
keys：序列，默认值无。使用传递的键作为最外层构建层次索引。如果为多索引，应该使用元组。
levels：序列列表，默认值无。用于构建MultiIndex的特定级别（唯一值）。否则，它们将从键推断。
names：list，default无。结果层次索引中的级别的名称。
verify_integrity：boolean，default False。检查新连接的轴是否包含重复项。这相对于实际的数据串联可能是非常昂贵的。
copy：boolean，default True。如果为False，请勿不必要地复制数据。

pandas map(),apply(),applymap()区别

map()方法

通过df.(tab)键,发现df的属性列表中有apply() 和 applymap(),但没有map().

map()是python 自带的方法, 可以对df某列内的元素进行操作,

import pandas as pd
toward_dict = {'1': '东', '2': '南', '3': '西', '4': '北'}
df = pd.DataFrame({'house' : list('AABCEFG'),
                   'price' : [100, 90, '', 50, 120, 150, 200],
                   'toward' : ['1','1','2','3','','3','2']})
print(df)
df['towarddd'] = df.toward.map(toward_dict)
print(df)

结果

	house	price	toward
0		A		100	  1
1		A		90	  1
2		B			  2
3		C		50	  3
4		E		120	
5		F		150   3
6		G		200	  2

	house	price	toward	towarddd
0		A		100		1		东
1		A		90		1		东
2		B				2		南
3		C		50		3		西
4		E		120				NaN
5		F		150		3		西
6		G		200		2		南

DataFrame.apply(func, axis=0, broadcast=None, raw=False, reduce=None, result_type=None, args=(), **kwds)

将传入的func应用到每一列或每一行,进行元素级别的运算

func : function Function to apply to each column or row.

axis : {0 or ‘index’, 1 or ‘columns’}, default 0 Axis along which the function is applied:

0 or ‘index’: apply function to each column. 1 or ‘columns’: apply function to each row.

df = pd.DataFrame([[4, 9],] * 3, columns=['A', 'B'])
print(df)
print(df.apply(np.sqrt))
print(df.apply(np.sum, axis=1))
print(df.apply(np.sum, axis=0))
df.apply(lambda x: pd.Series([1, 2], index=['foo', 'bar']), axis=1)

    A	B
0	4	9
1	4	9
2	4	9

	A	B
0	2.0	3.0
1	2.0	3.0
2	2.0	3.0

0    13
1    13
2    13
dtype: int64

A    12
B    27
dtype: int64

	foo	bar
0	1	2
1	1	2
2	1	2

DataFrame.applymap(func)

Apply a function to a Dataframe elementwise.

This method applies a function that accepts and returns a scalar to every element of a DataFrame.

Parameters: func : callable ,Python function, returns a single value from a single value.

Returns: DataFrame:Transformed DataFrame.

df = pd.DataFrame([[1, 2.12], [3.356, 4.567]])
print(df)
print(df.applymap(lambda x: len(str(x)))
print(df.applymap(lambda x: x**2))  # faster
print(df **2 )  #尽量不使用

	  0		  1
0	1.000	2.120
1	3.356	4.567

	0	1
0	3	4
1	5	5

	0				1
0	1.000000	4.494400
1	11.262736	20.857489

	0				1
0	1.000000	4.494400
1	11.262736	20.857489

区别与联系
map() python 自带, 对DF中的元素级别的操作, 可以对df的某列或某多列
apply(func) 是DF的属性, 对DF中的行数据或列数据应用func操作.
applymap(func) 是DF的属性, 对整个DF所有元素应用func操作

参考文献
http://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.apply.html
https://blog.csdn.net/zzpdbk/article/details/79232661