Pandas常用函数及操作集锦
- 1 创建Series和DataFrame的方法
- 1.1 Series的创建方法
- 1.2 DataFrame的创建方法
- 1.2.1 字典类型读取到DataFrame（dict to DataFrame)
- 1.2.2 利用np.arange()与np.random. 模块生成DataFrame
- 1.2.3 使用pandas.DataFrame（）函数构建DataFrame
- 1.2.4 读入csv文件构建DataFrame（csv to DataFrame）
- 2 常用的删除方法
- 2.1 drop函数详解
- 2.1.1 语法格式：
- 2.1.2 参数说明：
- 2.1.3 核心功能：
- 2.1.4 常见范例：
- 删除列名称包含特定字符串的各列
- 2.2 dropna()函数详解
- 3 DataFrame的几列数据合并成为一列
- 3.1 .str.cat函数详解
- 3.1.1 语法格式：
- 3.1.2 参数说明：
- 3.1.3 核心功能：
- 3.1.4 常见范例：
- 4 DataFrame插入某一列/行
- 4.1 DataFrame插入某一列
- 4.1.1 insert()函数详解
- 4.2 DataFrame插入某一行
- 5 行去重操作
- 5.1 drop_duplicates()函数详解
- 6 行值替换
- 6.1 replace()函数详解
- 7 统计DataFrame每一列有多少缺失值
- 7.1 df.isnull().sum()函数统计缺失项数量
- 8 缺失值的相关操作
- 8.1 缺失值的检查、确定
- 8.2 缺失值的删除、补全
- 9 筛选的相关操作
- 9.1 df.str.contains()和df.isin()的区别
- 10 在DataFrame指定位置添加一/多列
- 10.1 df.str.contains()和df.isin()的区别
- 小技巧函数归纳
- 1 用np.nan为DataFrame的部分项赋空值
- 11 pandas计数 value_counts()
1 创建Series和DataFrame的方法
1.1 Series的创建方法
1.2 DataFrame的创建方法
1.2.1 字典类型读取到DataFrame（dict to DataFrame)
方法一： 直接使用 pd.DataFrame(data=test_dict) 即可，括号中的 “data=” 写不写都可以。
典例如下：
test_dict = { 'id':[1,2,3,4,5,6],'name':['Alice','Bob','Cindy','Eric','Helen','Grace '],
'math':[90,89,99,78,97,93],'english':[89,94,80,94,94,90]
}
test_dict_df=pd.DataFrame(test_dict)
>>>
test_dict_df
id name math english
0 1 Alice 90 89
1 2 Bob 89 94
2 3 Cindy 99 80
3 4 Eric 78 94
4 5 Helen 97 94
5 6 Grace 93 90方法二： 如果dict的数据量很小，可以直接将dict写到pd.DataFrame()的括号中，但由于dict提供的仅是一个标量，还必须得提供一个索引index，后面的Index必须跟前面的数据组数目一致，否则会报错。
典例如下：
df1=pd.DataFrame({ 'A':['A0','A1','A2','A3'], 'B':['B0','B1','B2','B3'],
'C':['C0','C1','C2','C3'], 'D':['D0','D1','D2','D3']},
index=[0,1,2,3] ) # 备注： index=[0,1,2,3]可以使用pd.Index(range(4))
>>>
df1
A B C D
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3方法三： 使用from_dict方法，test_dict_df = pd.DataFrame.from_dict(test_dict)。
方法四： 若只需要选择dict中部分的键当做DataFrame的列（即仅选取dict的部分列），那么我们可以使用columns参数。
典例如下：
test_dict = { 'id':[1,2,3,4,5,6],'name':['Alice','Bob','Cindy','Eric','Helen','Grace '],
'math':[90,89,99,78,97,93],'english':[89,94,80,94,94,90]
}
test_dict_df = pd.DataFrame(data=test_dict,columns=['id','name'] )
>>>
test_dict_df
id name
0 1 Alice
1 2 Bob
2 3 Cindy
3 4 Eric
4 5 Helen
5 6 Grace1.2.2 利用np.arange()与np.random. 模块生成DataFrame
用顺序数np.arange(12).reshape(3,4)
用随机数np.random.randint(20,size=(2,3))
用随机数np.random.randn(5,3)
典例如下：
#用顺序数np.arange(12).reshape(3,4)
df1=pd.DataFrame(np.arange(12).reshape(3,4),columns=['a','b','c','d'])
>>>
df1
a b c d
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
#用随机数np.random.randint(20,size=(2,3))
df2=pd.DataFrame(np.random.randint(20,size=(2,3)),columns=['b','d','a'])
>>>
b d a
0 3 13 9
1 8 1 13
#用随机数np.random.randn(5,3)
df=pd.DataFrame(np.random.randn(5,3),index=list('abcde'),columns=['one','two','three'])
>>>
one two three
a 2.238856 0.581198 0.038252
b 1.677510 -0.662304 1.114203
c -1.821701 0.693057 0.285409
d -1.649973 -0.014030 -0.405890
e 1.971861 -1.205210 0.5313661.2.3 使用pandas.DataFrame（）函数构建DataFrame
语法格式：
pandas.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)参数说明：
data ：ndarray (structured or homogeneous), Iterable, dict, or DataFrame
Dict can contain Series, arrays, constants, or list-like objects
index ：Index or array-like
Index to use for resulting frame. Will default to RangeIndex if no indexing information part of input data and no index provided
columns ：Index or array-like
Column labels to use for resulting frame. Will default to RangeIndex (0, 1, 2, …, n) if no column labels are provided
dtype ：dtype, default None
Data type to force. Only a single dtype is allowed. If None, infer
copy ：boolean, default False
Copy data from inputs. Only affects DataFrame / 2d ndarray input
常见范例：
df2=pd.DataFrame(np.random.randint(low=0,high=10,size=(5,5)),columns=list('abcde'))
>>>df2
a b c d e
0 4 3 3 6 9
1 2 8 2 4 0
2 9 6 0 2 4
3 5 9 1 9 0
4 1 7 6 2 1
#创建行数据为4,9，列名为A，B，重复行数据3次的DataFrame
df=pd.DataFrame([[4,9],]*3,columns=['A','B']) #[[4,9],]*3中[4,9]后的逗号可以省略
>>>
df
A B
0 4 9
1 4 9
2 4 9
#创建行数据为：第一行4,9，第二行3,6，第三行2，NaN，列名为A，B，依次重复行数据3次的DataFrame
df1=pd.DataFrame([[4,9],[3,6],[2]]*3,columns=['A','B'])
>>>
df1
A B
0 4 9.0
1 3 6.0
2 2 NaN
3 4 9.0
4 3 6.0
5 2 NaN
6 4 9.0
7 3 6.0
8 2 NaN1.2.4 读入csv文件构建DataFrame（csv to DataFrame）
2 常用的删除方法
pandas中删除DataFrame对象可能存在几种情况：
序号 | 常见情形 | 删除方法 | 实例 | 备注 |
1 | 删除具体列 |
| df.drop([‘B’,‘C’],axis=1) | 详情见drop()函数 |
2 | 删除具体行 |
| df.drop(index=[1,3]) | 详情见drop()函数 |
3 | 删除包含某些数值的行或者列 | 转化为筛选 | df[ df[‘成交金额’] > 10000 ] | |
4 | 删除包含某些字符、文字的行或者列 | 转化为筛选 | df[ ~ df[‘承运商’].str.contains(‘联通’) ] | 如果想取包含某些字符的记录，可以去掉 |
备注：
df[~df[column_name].str.contains(‘str’)]==False，可以提高数据结果的稳定性。
df[notnull(df[col_name])]，可以将某列包含空值的行均删除。
2.1 drop函数详解
2.1.1 语法格式：
DataFrame.drop(labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise')[source]2.1.2 参数说明：
labels ：删除的index（行）或column（列）的名字，同时删除多个行（列），用列表给定
axis ：指删除行（axis=0）还是列（axis=1），默认为0
index, columns ：直接指定要删除的行，列（单个用索引标签，多个用列表给
level : 可选参数，针对存在MultiIndex（复合索引）的情况，设置将删除标签的级别，level可以为 int 或 level name（级别名称）
inplace ：默认为False，该操作不改变原数据，而是返回一个执行删除操作后的新dataframe，若inplace=True，则会直接在原数据上执行删除操作，删除后无法返回。
2.1.3 核心功能：
当需要删除Series 的元素或者DataFrame 的某一行（列）时，一般使用drop函数，它不改变原有df中的数据，而是返回另一个新的series或者dataframe来存放删除后的数据，方法如下：
- 删除 Series 的元素，通过
ser.drop(labels, axis=0)方法 - 删除 DataFrame 的某一行（列），通过
df.drop(labels, axis=0)方法
一般，用df.drop()删除 DataFrame中指定的行（列）有通过行（列）名称删除以及通过行（列）索引删除两种方式：
- 通过行（列）名称删除（ 包括2种方法）：
（1）用labels和axis的组合，指定要删除的行或列：
调用方法：
df.drop([list],axis=1) #删除指定的列
df.drop([list]) #删除指定的行，由于默认axis=0，因此可省略（2）用index或columns直接指定要删除的行或列：
调用方法：
df.drop(columns=[list]) #删除指定的列
df.drop(index=[list]) #删除指定的行- 通过行（列）索引删除：
用df.drop()也可以根据行索引删除指定的行。即：df.drop(df.index[])这个方法支持单个行索引、一个连续范围索引切片，以及用负数表示从末尾删除 （间隔行索引不支持该方法，列索引columns也不支持该方法）** 。
典型范例：
#可以理解为先用 df.index[]方法提取df的行索引，之后再用df.drop()删除。
print(df.drop(df.index[1])) #删除第 2行
print(df.drop(df.index[-1])) #删除最后 1行
print(df.drop(df.index[1:])) #删除第 2行及以后各行
print(df.drop(df.index[:-1])) #删除前 2行
#print(df.drop(df.index[1,3])) #错误
#print(df.drop(df.columns[-1])) #错误通过行号删除：
df.drop(df.index[0], inplace=True) # 删除第1行
df.drop(df.index[0:3], inplace=True) # 删除前3行
df.drop(df.index[[0, 2]], inplace=True) # 删除第1第3行
使用列数删除，传入参数是int，列表，者切片：
df.drop(df.columns[0], axis=1, inplace=True) # 删除第1列
df.drop(df.columns[0:3], axis=1, inplace=True) # 删除前3列
df.drop(df.columns[[0, 2]], axis=1, inplace=True) # 删除第1第3列
详见：
2.1.4 常见范例：
范例1：（删除Series的指定元素）
ser=pd.Series([4.5,7.2,-5.3,3.6],index=['a','b','c','d'])
>>>
ser
a 4.5
b 7.2
c -5.3
d 3.6
ser.drop('c') #删除一个元素
>>>
a 4.5
b 7.2
d 3.6
ser.drop(['a','c']) #删除多个元素
>>>
b 7.2
d 3.6范例2：（删除DataFrame指定的行/列）
#创建df
df=pd.DataFrame(np.arange(12).reshape(3,4),columns=['A','B','C','D'])
>>>
df
A B C D
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
#删除df的指定列（用df.drop([list],axis=1)删除column一定要指定axis=1,否则会报错）
df.drop(['B','C'],axis=1)
#或者
df.drop(columns=['B','C'])
>>>
A D
0 0 3
1 4 7
2 8 11
#删除df的指定行（df.drop()，默认axis=0,可省略）
df.drop([0,1])
#或者
df.drop(index=[0,1])
>>>
A B C D
2 8 9 10 11范例3：
import pandas as pd
import numpy as np
# 直接可以用pandas生成随机数组
df=pd.DataFrame(np.random.randn(5,3),index=list('abcde'),columns=['one','two','three'])
>>>
df
one two three
a -0.099452 0.322944 0.912389
b 0.936111 -2.766780 -2.089579
c -1.069152 1.401461 0.600944
d 0.758991 1.965351 -1.253454
e -0.088727 -0.834445 1.454612
#用np.nan为df的部分项赋空值（即：创建存在空值项的DataFrame）
df.ix[1,:-1]=np.nan #第二行，排除倒数第一个都是Nan
df.ix[1:-1,2]=np.nan #第三列，排除第一个和最后一个都是Nan
>>>
df
one two three
a -0.099452 0.322944 0.912389
b NaN NaN NaN
c -1.069152 1.401461 NaN
d 0.758991 1.965351 NaN
e -0.088727 -0.834445 1.454612
#用df.dropna(),把含Nan的项全部删掉
print(df.dropna())
>>>
one two three
a -0.099452 0.322944 0.912389
e -0.088727 -0.834445 1.454612
#用df.drop()删除某行/列
print(df.drop('one',axis=1)) #删除column='one'的列
print(df.drop(['a','c'],axis=0)) #删除index='a','c'两行
>>>
two three
a 0.322944 0.912389
b NaN NaN
c 1.401461 NaN
d 1.965351 NaN
e -0.834445 1.454612
one two three
b NaN NaN NaN
d 0.758991 1.965351 NaN
e -0.088727 -0.834445 1.454612使用df=df[ ~ df['co_name'].str.contains('未知')] #删除某列包含特殊字符"未知"的所有行
常见错误：
pandas筛选数据时可能会遇到如下报错：
例如：data[data['所在省 / 市 / 县'].str.contains('//')] 输出：ValueError: cannot index with vector containing NA / NaN values
解决措施：错误是nan造成的，所以要先筛选非空数据
data= data[data[‘所在省 / 市 / 县’].notnull()] #筛选出非空数据
data[data['所在省 / 市 / 县'].str.contains('//')] #再筛选某列包含特定字段的行
或者
data['所在省 / 市 / 县'].str.contains('^//$',regex=True) #str.contains()函数详解
语法格式
Series.str.contains(pat, case=True, flags=0, na=nan, regex=True)[source]参数说明
pat : str
Character sequence or regular expression.
case : bool, default True
If True, case sensitive.
flags : int, default 0 (no flags)
Flags to pass through to the re module, e.g. re.IGNORECASE.
na : default NaN
Fill value for missing values.
regex : bool, default True
If True, assumes the pat is a regular expression.
If False, treats the pat as a literal string.
删除列名称包含特定字符串的各列
#删除列名称中包含单词“Test”的所有列。 这些列的数量不是静态的，而是依赖于以前的函数，可使用以下方法：
df.select(lambda x: not re.search('Test\d+',x),axis=1)
df = df[df.columns.drop(list(df.filter(regex='Test')))]import pandas as pd
import numpy as np
import re
df=pd.DataFrame({'Test1':np.random.randn(10),
'Test2':np.random.randn(10),
'awesome':np.random.randn(10)})
print(df)
>>>
Test1 Test2 awesome
0 -0.943433 0.747069 -0.225165
1 0.142815 -1.348540 0.451445
2 1.406193 0.381515 0.878521
3 0.397081 -0.742697 -0.562191
4 0.429882 -0.574419 -0.541179
5 0.366996 1.068587 -0.289690
6 -0.165728 1.642604 -0.198651
7 -1.413391 -0.464395 1.161286
8 -0.562969 -1.638158 -1.300878
9 1.154907 -0.992369 -0.208180
#删除列名称中包含单词“Test”的所有列。 这些列的数量不是静态的，而是依赖于以前的函数。
df.select(lambda x: not re.search('Test\d+',x),axis=1)
>>>
awesome
0 -0.225165
1 0.451445
2 0.878521
3 -0.562191
4 -0.541179
5 -0.289690
6 -0.198651
7 1.161286
8 -1.300878
9 -0.208180
#筛选列名称中包含单词“Test”的所有列。 这些列的数量不是静态的，而是依赖于以前的函数。
df.select(lambda x: re.search('Test\d+',x),axis=1)
>>>
Test1 Test2
0 -0.943433 0.747069
1 0.142815 -1.348540
2 1.406193 0.381515
3 0.397081 -0.742697
4 0.429882 -0.574419
5 0.366996 1.068587
6 -0.165728 1.642604
7 -1.413391 -0.464395
8 -0.562969 -1.638158
9 1.154907 -0.9923692.2 dropna()函数详解
删除‘收货地址’列有缺失值的行
data.dropna(subset=['收货地址'],inplace=True) #subset后跟准备删除的含缺失值的列名list[]3 DataFrame的几列数据合并成为一列
- 使用
+直接将多列合并为一列（合并列较少）； - 使用
pandas.Series.str.cat方法，将多列合并为一列（合并列较多）；
范例如下：
dataframe[“newColumn”] = dataframe[“age”].map(str) + dataframe[“phone”] + dataframe["address”]
或者
dataframe[“newColumn”] = dataframe[“age”].map(str) .str.cat([dataframe[“phone”],dataframe["address”]],sep=’-’,na_rep=’?’)
注意事项： - 参与合并的列的数据类型必须为str类型，int和float等数值类型需先转化为str；
- 参与合并的列的长度必须相同（即：行数），否则报错，但使用
pandas.Series.str.cat方法，可通过指定参数join={‘left’, ‘right’, ‘outer’, ‘inner’}，实现长度不相等的列合并； - 参与合并的列的各行元素均不为NaN，否则，只要有一列的对应行元素为NaN，则合并结果中该行将为NaN，但使用
pandas.Series.str.cat方法，可通过指定参数na_rep='-'，将各列中缺失行元素填充为‘-’，从而保留合并列的所有行元素；
3.1 .str.cat函数详解
3.1.1 语法格式：
# pandas.Series.str.cat语法如下：
Series.str.cat(others=None, sep=None, na_rep=None, join=None)3.1.2 参数说明：
others ： 准备合并的字符串列表，其数据类型可以为：Series, Index, DataFrame, np.ndarrary（N元数组） or list-like（类似列表）
备注： 由于默认join=None，所以欲合并的两个（多个）字符串列表必须具有相同的长度，否则需设置参数join= {‘left’, ‘right’, ‘outer’, ‘inner’}，来控制多个字符串列表的合并方式。
（1）如果others=None（即：字符串列表df[col_1]不与其他字符串列表合并），结果将不传递其他值，而是将df[col_1]的所有值都连接成一个字符串；（详见范例1-1）
（2）如果others≠None（即：指定了与字符串列表df[col_1]合并的其他字符串列表df[col_2]），结果将用分隔符把df[col_1]与df[col_2]对应的行值连接在一起， 返回Series。（详见范例1-2）
sep：合并结果中不同元素/列之间的分隔符。默认情况下，使用空字符串’ ’ 。
na_rep：为所有缺失值插入的内容，其数据类型可以为：str或None，默认na_rep=None备注：
（1）如果na_rep=None，则多个合并列中只要有一列的对应行元素为NaN，合并结果中该行元素将为NaN；
（2）如果na_rep=‘str’(str需自定义)，则合并列中各缺失行元素将被填充为‘str’，合并结果将保留合并列的所有行元素；
join ：确定连接方式，其可能的取值为：{‘left’, ‘right’, ‘outer’, ‘inner’}，默认join=None
3.1.3 核心功能：
- 将Series中的多个字符串[‘a’, ‘b’, ‘c’]拼接为一个字符串’a b c’（字符串拼接）
- 将DataFrame中的两（多）列df[col_1]和df[col_2]合并为一列（多列合并）
备注：pandas.Series.str.cat仅适用于str类型的数据，int和float等数值型需先转化为str型，才可调用此方法。
int型转为str的方法：
1、df[‘Price’]=df[‘Price’].map(lambda x: str(x))
2、df[‘Price’]=df[‘Price’].map(str)
3、df[‘Price’]=df[‘Price’].astype(‘str’)
若要同时将多列合并为一列，需引入列表list来指定准备合并的列，例如：
df[col_1].str.cat([df[col_2],df[col_3],df[col_4]],sep=’-’)
3.1.4 常见范例：
import numpy as np
import pandas as pd
#创建原始数据
s=pd.Series(['a','b',np.nan,'d'])
>>>
s
0 a
1 b
2 NaN
3 d
# other=None时，调用s.str.cat()，可将series转为用分隔符sep分隔的字符串,缺失项将被省略
s1=s.str.cat(sep=' ')
>>>
s1
'a b d'
# other=None时，指定na_rep='?'，结果将保留原series中的缺失项，并用？代替
s2=s.str.cat(sep=' ',na_rep='?')
>>>
s2
'a b ? d'
# other≠None时，调用s.str.cat(),可将两个字符串列表df[col_1]与df[col_2]合并为一列，结果用分隔符sep分隔各项元素,由于默认na_rep=None,故合并时若df[col_1]与df[col_2]的对应行元素有一个为NaN，则合并后该行元素值将为None，结果返回Series
s3=s.str.cat(['A','B','C','D'],sep=',')
>>>
s3
0 a,A
1 b,B
2 NaN
3 d,D
# other≠None时，调用s.str.cat(),可将两个字符串列表df[col_1]与df[col_2]合并为一列，指定na_rep='-',故合并结果将保留df[col_1]与df[col_2]的所有行，且将df[col_1]与df[col_2]的缺失项填充为‘-’
s4=s.str.cat(['A','B','C','D'],sep=',',na_rep='-')
>>>
s4
0 a,A
1 b,B
2 -,C
3 d,D
# 欲合并的字符串列表df[col_1]与df[col_2]的索引不同时，需指定参数join，确定连接方式
t=pd.Series(['d','a','e','c'],index=[3,0,4,2])
s_1=s.str.cat(t,join='left',na_rep='-')
>>>
s_1
0 aa
1 b-
2 -c
3 dd
s_2=s.str.cat(t,join='outer',na_rep='-')
>>>
s_2
0 aa
1 b-
2 -c
3 dd
4 -e
s_3=s.str.cat(t,join='inner',na_rep='-')
>>>
s_3
0 aa
2 -c
3 dd
s_4=s.str.cat(t,join='right',na_rep='-')
>>>
s_4
3 dd
0 aa
4 -e
2 -c4 DataFrame插入某一列/行
4.1 DataFrame插入某一列
4.1.1 insert()函数详解
- 语法格式
DataFrame.insert(loc, column, value, allow_duplicates=False)- 参数说明
loc : int Insertion index. Must verify 0 <= loc <= len(columns)
column : string, number, or hashable object
label of the inserted column
value : int, Series, or array-like
allow_duplicates : bool, optional - 核心功能
- 常见范例
将这一列插入到指定位置，假如插入到第一列
df2.insert(0,‘date’,date)
4.2 DataFrame插入某一行
5 行去重操作
5.1 drop_duplicates()函数详解
语法格式：
DataFrame.drop_duplicates(subset=None, keep='first', inplace=False)参数说明：
subset：对重复的定义，即：指定哪几列的行值重复才视作重复。 default use all of the columns
keep：指明是否保留重复行，若保留是保留首行或末行，取值范围： {‘first’, ‘last’, False}, default ‘first’
inplace：是否用替换原表, default False
常见范例：
import pandas as pd
newdata=pd.DataFrame([[1,1,1,1],[1,1,1,1],[2,1,4,3],[5,6,7,9],[5,4,2,1],[2,1,4,9]],columns=['A','B','C','D'])
newdata
>>>
A B C D
0 1 1 1 1
1 1 1 1 1
2 2 1 4 3
3 5 6 7 9
4 5 4 2 1
5 2 1 4 9
#若A、B、C、D这四列如果都相同的话才重复的去重
newdata.drop_duplicates(subset=['A','B','C','D'],keep='last')
>>>
A B C D
1 1 1 1 1
2 2 1 4 3
3 5 6 7 9
4 5 4 2 1
5 2 1 4 9
#只需要其中的某几列相同就可以当作重复的去重
#把A列和B列中元素相同的行去掉，只保留第一次出现的行
newdata.drop_duplicates(subset=['A','B'],keep='first')
>>>
A B C D
0 1 1 1 1
2 2 1 4 3
3 5 6 7 9
4 5 4 2 16 行值替换
6.1 replace()函数详解
语法格式：
DataFrame.replace(to_replace=None, value=None, inplace=False, limit=None, regex=False, method='pad')参数说明：
常见范例：
7 统计DataFrame每一列有多少缺失值
7.1 df.isnull().sum()函数统计缺失项数量
#统计“产品分类”列中缺失项NaN的个数
data['产品分类'].isnull().sum()
>>>
48 缺失值的相关操作
8.1 缺失值的检查、确定
核心功能：
- 使用
df.isnull()，返回判断是否有缺失值的true／false矩阵； - 使用
df['col_name'].isnull()，检查df的某列是否为缺失值； - 使用
df['name'].notnull()，检查df的某列是否为非缺失值； - 使用
df.isnull().any()，返回各个列是否存在缺失值的true／false说明； - 使用
df['col_name'].isnull().values.any()，判断指定列是否存在缺失值的true/false说明，与data['col_name'].isnull().any()等价； - 使用
df['col_name'].isnull().sum()，返回指定各个列有多少个缺失值； - 使用
df.isnull().sum().sum()，返回整个dataframe有多少缺失值； - 使用
df[df.isnull().values==True]，则可以返回包含缺失值的所有行；
常见范例：
import pandas as pd
import numpy as np
print('导入成功')
df=pd.DataFrame(np.random.randn(10,6))
#为部分元素赋空值
df.iloc[1:3,1]=np.nan
df.iloc[5,3]=np.nan
df.iloc[7:9,5]=np.nan
print(df)
>>>
0 1 2 3 4 5
0 -0.655739 -0.880698 0.387871 -0.351270 0.592156 -1.465724
1 0.556340 NaN -0.751302 -0.578623 -1.560874 -0.178364
2 -1.602751 NaN -1.235032 -0.837896 1.162327 0.703572
3 -1.039976 -0.720074 -2.238859 0.062579 -1.819538 -2.846430
4 1.762286 0.703799 0.743671 -0.305712 0.269067 -0.013844
5 0.509670 1.336506 -0.497428 NaN -0.722259 -1.192875
6 -1.472139 0.641542 -2.841253 -0.705087 0.338353 1.468302
7 0.064880 -0.064633 0.039684 -0.680784 0.493549 NaN
8 0.876330 -0.356368 -0.132232 1.126371 -0.567976 NaN
9 3.801031 0.082908 -0.069363 0.034194 0.176096 -0.206301
#df.isnull()返回判断所有数据是否有缺失值的true／false矩阵
df.isnull()
>>>
0 1 2 3 4 5
0 False False False False False False
1 False True False False False False
2 False True False False False False
3 False False False False False False
4 False False False False False False
5 False False False True False False
6 False False False False False False
7 False False False False False True
8 False False False False False True
9 False False False False False False
#返回df的各个列是否存在缺失项
df.isnull().any()
>>>
0 False
1 True
2 False
3 True
4 False
5 True
dtype: bool
>>>
#返回包含缺失值的所有行
df[df.isnull().values==True]
>>>
0 1 2 3 4 5
1 0.556340 NaN -0.751302 -0.578623 -1.560874 -0.178364
2 -1.602751 NaN -1.235032 -0.837896 1.162327 0.703572
5 0.509670 1.336506 -0.497428 NaN -0.722259 -1.192875
7 0.064880 -0.064633 0.039684 -0.680784 0.493549 NaN
8 0.876330 -0.356368 -0.132232 1.126371 -0.567976 NaN8.2 缺失值的删除、补全
核心功能——删除缺失值の篇：
- 使用
df.dropna()，删除含有任意缺失值的行 - 使用
df.dropna(axis=1)，删除含有任意缺失值的列 - 使用
df.dropna(how = 'all')，删除所有字段都有缺失值的行 - 使用
df.dropna(thresh = 2)，删除超过两栏缺失值的行 - 使用
df.dropna(subset=['列名'],inplace=True)，删除指定列中有缺失值的所有行
核心功能——补全缺失值の篇：
- 使用
df.fillna(0)，用0补全所有缺失值； - 使用
df['age'].fillna(df['age'].mean())，用平均值补全指定列的缺失值； - 使用
df['age'].fillna(df.groupby('gender')['age'].transform('mean'),inplace=True)#根据各性别平均年龄填补缺失值； - 使用
df.fillna(method='pad')，向后填补缺失值（pad或者ffill)； - 使用
df.fillna(method='bfill',limit=2)，向前填补缺失值(bfill或者backfill) - 使用
df.interpolate()，内插法填补缺失值
感谢大神帮忙，附上原文链接：https://www.jianshu.com/p/4a39c23825bc
9 筛选的相关操作
9.1 df.str.contains()和df.isin()的区别
核心功能：
- 使用
df[df['col_name'].str.contains('测试')]，筛选出指定列包含特定字段的所有行，一般用于模糊查询，特定字段用str列出； - 使用
df[df['col_name'].isin(['测试'])]筛选出指定列是特定字段的行，一般用于完全匹配，特定字段用==list列表[]==列出；
10 在DataFrame指定位置添加一/多列
一次性在pandas.DataFrame里添加几列，或者在指定的位置添加一/多列的方法如下：
- df是一个DataFrame，一次性在df的后面添加一列
df['C']=list('ab')- df是一个DataFrame，一次性在df的后面添加多列
第一个方法是利用pd.concat 在DataFrame后面添加两列，这种方法的缺点是不能指定位置，即：
df=pd.concat([df,pd.DataFrame(columns=list('DE'))])第二种方法是利用 reindex来重排和增加列名，即：
df=df.reindex(columns=list('ABCDE'))
这种方法可以改变各列的相对位置，且保留原始列的数值，即：
df=df.reindex(columns=list('BCADE'))
reindex 还有 fill_value 选项，可以填充NaN，即：
df=df.reindex(columns=list('ABCDE'), fill_value=0)第三种方法，是针对列名都比较长，无法每个都敲出来，此时用到list.insert(index, obj)的方法。
（a）参数如下：
index -- 对象obj需要插入的索引位置。
obj -- 要插入列表中的对象。
（b）具体操作步骤：
先获取原列名集合, 赋值给新变量（这个很重要，具体原因我也不知道为啥）， 然后 insert，即：
col_name=df.columns.tolist()
col_name.insert(1,'G')
df.reindex(columns=col_name)第四种方法：不用数字索引，直接在某列前面或后面插入，利用 list.index的方法
# 在 B 列前面插入
col_name = df.columns.tolist()
col_name.insert(col_name.index('B'),'D')
df.reindex(columns=col_name)
# 在 B 列后面插入
col_name = df.columns.tolist()
col_name.insert(col_name.index('B')+1,'D')
df.reindex(columns=col_name)#创建原始数据集
df=pd.DataFrame(columns=['A','B'],data=[[1,2],[3,4]])
>>>df
A B
0 1 2
1 3 4
#df是一个DataFrame，在df的后面添加一列
df['C']=None
>>>df
A B C
0 1 2 None
1 3 4 None
#在df的后面同时添加多列，并重置列的位置
df=df.reindex(columns=list('BDECA'),fill_value=5)
>>>df
A B C D E
0 1 2 NaN NaN NaN
1 3 4 NaN NaN NaN
#df的指定位置，插入一列，用list.insert(index, obj)的方法
col_name=df.columns.tolist()
>>>col_name
['B', 'D', 'E', 'C', 'A']
col_name.insert(1,'G')
df.reindex(columns=col_name)
>>>
B G D E C A
0 2 NaN NaN NaN NaN 1
1 4 NaN NaN NaN NaN 3
#不用数字索引，直接在某列前面或后面插入，利用 list.index的方法
#在 B 列前面插入
col_name=df.columns.tolist()
col_name.insert(col_name.index('B'),'H')
df.reindex(columns=col_name)
>>>
H B D E C A
0 NaN 2 NaN NaN NaN 1
1 NaN 4 NaN NaN NaN 3
# 在 B 列后面插入
col_name=df.columns.tolist()
col_name.insert(col_name.index('B')+1,'K')
df.reindex(columns=col_name)
>>>
B K D E C A
0 2 NaN NaN NaN NaN 1
1 4 NaN NaN NaN NaN 310.1 df.str.contains()和df.isin()的区别
核心功能：
小技巧函数归纳
1 用np.nan为DataFrame的部分项赋空值
用np.nan为df的部分项赋空值（即：创建存在空值项的DataFrame）
df.ix[1,:-1]=np.nan #第二行，排除倒数第一个都是Nan
df.ix[1:-1,2]=np.nan #第三列，排除第一个和最后一个都是Nan
11 pandas计数 value_counts()
- Series 情况下：
（1）pandas 的value_counts()函数可以对Series里面的每个值进行计数并且排序。
（2）如果想升序排列，设置参数 ascending = True，即df['区域'].value_counts(ascending=True)（3）如果想得出计数占比，可以加参数 normalize=True，即：df['区域'].value_counts(normalize=True)备注： 空值默认剔除掉的。value_counts()返回的结果是一个Series数组，可以跟别的数组进行计算。
import pandas as pd
df = pd.DataFrame({'区域' : ['西安', '太原', '西安', '太原', '郑州', '太原'],
'10月份销售' : ['0.477468', '0.195046', '0.015964', '0.259654', '0.856412', '0.259644'],
'9月份销售' : ['0.347705', '0.151220', '0.895599', '0236547', '0.569841', '0.254784']})
print(df)
>>>
区域 10月份销售 9月份销售
0 西安 0.477468 0.347705
1 太原 0.195046 0.151220
2 西安 0.015964 0.895599
3 太原 0.259654 0236547
4 郑州 0.856412 0.569841
5 太原 0.259644 0.254784
# 统计每个区域的出现次数,并且默认从高到低排序。
print(df['区域'].value_counts())
>>>
太原 3
西安 2
郑州 1
Name: 区域, dtype: int64
#如果想升序排列，设置参数 ascending = True：
print(df['区域'].value_counts(ascending=True))
>>>
郑州 1
西安 2
太原 3
Name: 区域, dtype: int64
#如果想得出计数次数的占比，可以加参数 normalize=True：
print(df['区域'].value_counts(normalize=True))
>>>
太原 0.500000
西安 0.333333
郑州 0.166667
Name: 区域, dtype: float64- DataFrame 情况下：
df = pd.DataFrame({'区域1' : ['西安', '太原', '西安', '太原', '郑州', '太原'],
'区域2' : ['太原', '太原', '西安', '西安', '西安', '太原']})
print(df)
>>>
区域1 区域2
0 西安 太原
1 太原 太原
2 西安 西安
3 太原 西安
4 郑州 西安
5 太原 太原
print(df.apply(pd.value_counts))
>>>
区域1 区域2
太原 3 3.0
西安 2 3.0
郑州 1 NaN
