pandas经常使用总结

pandas 数据结构简单理解为一维,二维,三维

#Series (collection of values 亦称系列)  相似一维ndarray,能够用numpy部分操做处理(np.sin(),np.max())
#DataFrame (collection of Series objects 亦称数据帧)，结构如有行名和列名的二维矩阵，相似一个表格
#Panel (collection of DataFrame objects 亦称面板)，多个DataFrame的集合，即多张表格数据
pandas Series数据类型
#object - For string values
#int - For integer values
#float - For float values
#datetime - For time values
#bool - For Boolean values

pandas.Series( data, index, dtype, copy)。

1 	data 	数据采起各类形式，如：ndarray，list，constants
2 	index 	索引值必须是惟一的和散列的，与数据的长度相同。 默认np.arange(n)若是没有索引被传递。
3 	dtype 	dtype用于数据类型。若是没有，将推断数据类型
4 	copy 	复制数据，默认为false。
data = np.array(['a','b','c','d'])
s = pd.Series(data)
data = np.array(['a','b','c','d'])
data = {'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data)
data = {'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data,index=['b','c','d','a']) -> d NaN
s = pd.Series(data,index=[100,101,102,103])
s = pd.Series(5, index=[0, 1, 2, 3])
索引:s[2],s[1:3],s["a"]
系列基本功能
编号 	属性或方法 	描述
1 	axes 	返回行轴标签列表。
2 	dtype 	返回对象的数据类型(dtype)。
3 	empty 	若是系列为空，则返回True。
4 	ndim 	返回底层数据的维数，默认定义：1。
5 	size 	返回基础数据中的元素数。
6 	values 	将系列做为ndarray返回。
7 	head() 	返回前n行。
8 	tail() 	返回最后n行。
from pandas import Series
pd.Series([1, 2, 3]).values  -> array([1, 2, 3])
original_index = series_custom.index.tolist()
sorted_index = sorted(original_index)
sorted_by_index = series_custom.reindex(sorted_index)

sc2 = series_custom.sort_index()
sc3 = series_custom.sort_values()
np.add(series_custom, series_custom)  #series 对应相加

#data alignment same index,赋予相同的index,而后对应操做
rt_critics = Series(fandango['RottenTomatoes'].values, index=fandango['FILM'])
rt_users = Series(fandango['RottenTomatoes_User'].values, index=fandango['FILM'])
rt_mean = (rt_critics + rt_users)/2
print(rt_mean)

pandas.DataFrame( data, index, columns, dtype, copy)

1 	data 	数据采起各类形式，如:ndarray，series，map，lists，dict，constant和另外一个DataFrame。
2 	index 	对于行标签，要用于结果帧的索引是可选缺省值np.arrange(n)，若是没有传递索引值。
3 	columns 	对于列标签，可选的默认语法是 - np.arange(n)。 这只有在没有索引传递的状况下才是这样。
4 	dtype 	每列的数据类型。
5 	copy 	若是默认值为False，则此命令(或任何它)用于复制数据。

选择列:print df ['one']
添加列:df['four']=df['one']+df['three'] ,将两列的和作新的列
df['new name'] = pd.Series()
删除列:df.pop('two')
按标签选择行:df.loc['b']
按整数位置选择行:df.iloc[2]
行切片:df[2:4]
增长新行:df.append(df2)
删除行:df.drop(0)#标签重复则删除多行
DataFrame基本功能
编号 	属性或方法 	描述
1 	T 	转置行和列。
2 	axes 	返回一个列，行轴标签和列轴标签做为惟一的成员。
3 	dtypes 	返回此对象中的数据类型(dtypes)。
4 	empty 	若是NDFrame彻底为空[无项目]，则返回为True; 若是任何轴的长度为0。
5 	ndim 	轴/数组维度大小。
6 	shape 	返回表示DataFrame的维度的元组。
7 	size 	NDFrame中的元素数。
8 	values 	NDFrame的Numpy表示。
9 	head() 	返回开头前n行。
10 	tail() 	返回最后n行。

面板:pandas.Panel(data, items, major_axis, minor_axis, dtype, copy)

data 	数据采起各类形式，如：ndarray，series，map，lists，dict，constant和另外一个数据帧(DataFrame)
items 	axis=0
major_axis 	axis=1
minor_axis 	axis=2
dtype 	每列的数据类型
copy 	复制数据，默认 - false

初始化:3Dndarray:
data = np.random.rand(2,4,5)
p = pd.Panel(data)
DataFrame:
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)), 
		'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
索引:
p['Item1']
p.major_xs(1)
 p.minor_xs(1)

下面重点是Dataframe的介绍：

导入

import pandas
food_info = pandas.read_csv("food_info.csv")
print(type(food_info)) -> <class 'pandas.core.frame.DataFrame'>
pandas.read_csv(filepath_or_buffer, sep=',', delimiter=None, header='infer',
names=None, index_col=None, usecols=None) #index_col 指定某列做为索引,names指定列名,skiprows跳过指定行数
pd.read_excel

初始化

#初始化
data = [1,2,3,4,5]
df = pd.DataFrame(data)

data = [['Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'],dtype=float)

data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data)

data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data, index=['rank1','rank2','rank3','rank4'])

data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data) #没有的为NaN

data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data, index=['first', 'second'])

data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df1 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b'])

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
	  'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)

索引以及行列操做

.loc() 	基于标签、单个标量标签、标签列表、切片对象、一个布尔数组
df.loc[:,'A']
df.loc[:,['A','C']]
df.loc['a':'h']
.iloc() 	基于整数、整数列表、系列值
df.iloc[:4]
df.iloc[1:5, 2:4]
df.iloc[[1, 3, 5], [1, 3]]
.ix() 	基于标签和整数
df.ix[:4]
df.ix[:,'A']

属性.
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
print (df.A)

#pandas从0开始索引
print food_info.loc[0] #第一行
food_info.loc[6] #第七行,超出范围会报错

# DataFrame 的3,4,5,6行,注意:左闭右闭
print food_info.loc[3:6]

two_five_ten = [2,5,10] 
print food_info.loc[two_five_ten] #2,5,10行
print food_info.loc[[2,5,10]] #同上

ndb_col = food_info["NDB_No"] #指定列
col_name = "NDB_No"		
ndb_col = food_info[col_name]

columns = ["Zinc_(mg)", "Copper_(mg)"]
zinc_copper = food_info[columns]
zinc_copper = food_info[["Zinc_(mg)", "Copper_(mg)"]]

food_info.columns #显示列名,可是不是list -> Index([u'NDB_No', u'Shrt_Desc'],dtype='object')
col_names = food_info.columns.tolist() #将列名转为list -> ['NDB_No', 'Shrt_Desc',]
div_1000 = food_info["Iron_(mg)"] / 1000 #对该列每行数据除以1000(能够实现+-*/,返回是series)
water_energy = food_info["Water_(g)"] * food_info["Energ_Kcal"] #列与列之间运算
max_calories = food_info["Energ_Kcal"].max() #某列中的最大值
gram_columns = []
print type(col_names)
for c in col_names:
	if c.endswith("(g)"):
		gram_columns.append(c)
gram_df = food_info[gram_columns]
print(gram_df.head(3))

DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last') 
axis:{0 or ‘index’, 1 or ‘columns’}, default 0，默认按照索引排序，即纵向排序，若是为1，则是横向排序 
by:str or list of str；若是axis=0，那么by="列名"；若是axis=1，那么by="行名"； 
ascending:布尔型，True则升序，能够是[True,False]，即第一字段升序，第二个降序 
inplace:布尔型，是否用排序后的数据框替换现有的数据框
kind:排序方法，{‘quicksort’, ‘mergesort’, ‘heapsort’}, default ‘quicksort’。
na_position : {‘first’, ‘last’}, default ‘last’，默认缺失值排在最后面 
example:
沿着轴方向按指定值排序  
x.sort_values(by="x1",ascending= False)

是否为NaN

age = titanic_survival["Age"] #某列
age_is_null = pd.isnull(age)  #返回该列是不是NaN的bool值
age_null_true = age[age_is_null] #返回是True所在行,可是值是NaN
age_null_count = len(age_null_true) #统计非空数量
mean_age = sum(titanic_survival["Age"]) / len(titanic_survival["Age"]) #为NaN,则该列含有NaN,含NaN的运算可能致使结果为NaN
good_ages = titanic_survival["Age"][age_is_null == False]  #与前面结合,将NaN值踢掉
titanic_survival["Age"].mean() #则是自动剔除NaN计算

计算每一个班的平均分

passenger_classes = [1, 2, 3]
fares_by_class = {}
for this_class in passenger_classes:
	pclass_rows = titanic_survival[titanic_survival["Pclass"] == this_class]
	pclass_fares = pclass_rows["score"]
	fare_for_class = pclass_fares.mean()
	fares_by_class[this_class] = fare_for_class

数据透视表(刚接触的比较难理解)

pandas.pivot_table()
data：DataFrame对象
values：源数据中的一列，数据透视表中用于观察分析的数据值，相似Excel中的值字段
index：源数据中的一列，数据透视表用于行索引的数据值，相似Excel中的行字段
columns：源数据中的一列，数据透视表用于列索引的数据值，相似Excel中列字段
aggfunc：根据当前的行、列索引生成的数据透视表中有多个数据须要进行聚合时，对这多个数据须要进行的操做，默认为np.mean()

pandas.DataFrame.dropna

DataFrame.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)
功能：根据各标签的值中是否存在缺失数据对轴标签进行过滤，可经过阈值调节对缺失值的容忍度
参数：axis : {0 or ‘index’, 1 or ‘columns’},或 tuple/list 
   how : {‘any’, ‘all’}
	  any : 若是存在任何NA值，则放弃该标签
	  all :    若是因此的值NA值，则放弃该标签
   thresh : int, 默认值 None
   int value ：要求每排至少N个非NA值　　
   subset : 相似数组,列名 ["Age", "Sex"]
   inplace : boolean, 默认值 False
	  若是为True，则进行操做并返回None。
返回：被删除的DataFrame

titanic_survival.loc[1,"Age"] #索引,第2行,"Age"列的值,选择多行返回dataframe,选择单行返回Series
df1 = df.loc[[0,2,3],:]
df2 = df1.reset_index()  #df1按顺序加上新的索引,原来的索引列名为"index"
reset_index，经过函数 drop=True 删除原行索引
df3 = df1.reset_index(drop=True)

默认状况下会以列为单位，分别对列应用函数,将df按行或列传给函数f处理,函数须要返回值

t1=df.apply(f)
t2=df.apply(f,axis=1)
def which_class(row):
	pclass = row['Pclass']
	if pd.isnull(pclass):
		return "Unknown"
	elif pclass == 1:
		return "First Class"
	elif pclass == 2:
		return "Second Class"
	elif pclass == 3:
		return "Third Class"
classes = titanic_survival.apply(which_class, axis=1)

重置索引

DataFrame能够经过set_index方法，能够设置单索引和复合索引。
DataFrame.set_index(keys, drop=True, append=False, inplace=False, verify_integrity=False)
append添加新索引，drop为False，inplace为True时，索引将会还原为列]
data:
	 a    b  c    d
0  bar  one  z  1.0
1  bar  two  y  2.0
2  foo  one  x  3.0
3  foo  two  w  4.0
indexed1 = data.set_index('c')
	 a    b    d
c               
z  bar  one  1.0
y  bar  two  2.0
x  foo  one  3.0
w  foo  two  4.0

indexed2 = data.set_index(['a', 'b'])
		 c    d
a   b          
bar one  z  1.0
	two  y  2.0
foo one  x  3.0
	two  w  4.0

groupby:

group1 = df.groupby('key1')
group2 = df.groupby(['key1','key2'])
group1.size()/sum()/count() #分组统计
对于分组的某一列或者多个列，应用agg(func)能够对分组后的数据应用func函数
group1['data1'].agg('mean')
group1['data1'].agg(['mean','sum'])
group1['data1','data2'].agg(['mean','sum'])
apply()不一样于agg()的地方在于：前者应用于dataframe的各个列，后者仅做用于指定的列。
交叉表crosstab  能够按照指定的行和列统计分组频数
pd.crosstab(df.key1,df.key2, margins=True)

经常使用函数

print food_info.dtypes (返回各个列的数据类型)
NDB_No               int64
Shrt_Desc           object
Water_(g)          float64
Energ_Kcal           int64
first_rows = food_info.head() #默认5行
print first_rows
print(food_info.head(3))
#print food_info.columns 
print food_info.shape #不包括第一行head行

重要函数 -

编号 	函数 	描述
1 	count() 	非空观测数量
2 	sum() 	全部值之和
3 	mean() 	全部值的平均值
4 	median() 	全部值的中位数
5 	mode() 	值的模值
6 	std() 	值的标准误差
7 	min() 	全部值中的最小值
8 	max() 	全部值中的最大值
9 	abs() 	绝对值
10 	prod() 	数组元素的乘积
11 	cumsum() 	累计总和
12 	cumprod() 	累计乘积

注 - 因为DataFrame是异构数据结构。通用操做不适用于全部函数。

相似于：sum()，cumsum()函数能与数字和字符(或)字符串数据元素一块儿工做，不会产生任何错误。字符聚合历来都比较少被使用，虽然这些函数不会引起任何异常。
因为这样的操做没法执行，所以，当DataFrame包含字符或字符串数据时，像abs()，cumprod()这样的函数会抛出异常。


代表智函数应用：pipe()
行或列函数应用：apply()
元素函数应用：applymap()

遍历DataFrame:

要遍历数据帧(DataFrame)中的行，可使用如下函数 -
	iteritems() - 迭代(key，value)对
	iterrows() - 将行迭代为(索引，系列)对
	itertuples() - 以namedtuples的形式迭代行
for col in df:
   print (col)#列名

for key,value in df.iteritems():
   print (key,value) #列为键
for row_index,row in df.iterrows():
   print (row_index,row)#行为键
for row in df.itertuples():
	print (row) #每行一个元组(index,行值)

排序:

sorted_df=unsorted_df.sort_index(axis=1) 按行or列排序(按index或者列名)
sorted_df = unsorted_df.sort_values(by='col1') #按值排序,某列的值

pandas 对字符串操做函数

1 	lower() 	将Series/Index中的字符串转换为小写。
2 	upper() 	将Series/Index中的字符串转换为大写。
3 	len() 	计算字符串长度。
4 	strip() 	帮助从两侧的系列/索引中的每一个字符串中删除空格(包括换行符)。
5 	split(' ') 	用给定的模式拆分每一个字符串。
6 	cat(sep=' ') 	使用给定的分隔符链接系列/索引元素。
7 	get_dummies() 	返回具备单热编码值的数据帧(DataFrame)。
8 	contains(pattern) 	若是元素中包含子字符串，则返回每一个元素的布尔值True，不然为False。
9 	replace(a,b) 	将值a替换为值b。
10 	repeat(value) 	重复每一个元素指定的次数。
11 	count(pattern) 	返回模式中每一个元素的出现总数。
12 	startswith(pattern) 	若是系列/索引中的元素以模式开始，则返回true。
13 	endswith(pattern) 	若是系列/索引中的元素以模式结束，则返回true。
14 	find(pattern) 	返回模式第一次出现的位置。
15 	findall(pattern) 	返回模式的全部出现的列表。
16 	swapcase 	变换字母大小写。
17 	islower() 	检查系列/索引中每一个字符串中的全部字符是否小写，返回布尔值
18 	isupper() 	检查系列/索引中每一个字符串中的全部字符是否大写，返回布尔值
19 	isnumeric() 	检查系列/索引中每一个字符串中的全部字符是否为数字，返回布尔值。

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber[@t](https://my.oschina.net/u/104868)', np.nan, '1234','SteveMinsu'])
print (s.str.lower())
s = pd.Series(['Tom', 'William Rick', 'John', 'Alber[@t](https://my.oschina.net/u/104868)', np.nan, '1234','SteveMinsu'])
print (s.str.len())

pct_change()函数

系列，DatFrames和Panel都有pct_change()函数。此函数将每一个元素与其前一个元素进行比较，并计算变化百分比。
协方差
协方差适用于系列数据。Series对象有一个方法cov用来计算序列对象之间的协方差。NA将被自动排除。
s1 = pd.Series(np.random.randn(10))
s2 = pd.Series(np.random.randn(10))
print (s1.cov(s2))

print (frame['a'].cov(frame['b']))
print (frame.cov())

相关性

相关性显示了任何两个数值(系列)之间的线性关系。有多种方法来计算pearson(默认)，spearman和kendall之间的相关性。
(frame['a'].corr(frame['b']))
print (frame.corr())

排名s.rank()
Rank可选地使用一个默认为true的升序参数; 当错误时，数据被反向排序，也就是较大的值被分配较小的排序。

Rank支持不一样的tie-breaking方法，用方法参数指定 -

	average - 并列组平均排序等级
	min - 组中最低的排序等级
	max - 组中最高的排序等级
	first - 按照它们出如今数组中的顺序分配队列

清理/填充缺乏数据

Pandas提供了各类方法来清除缺失的值。fillna()函数能够经过几种方法用非空数据“填充”NA值
df.fillna(0)

pad/fill 	填充方法向前
bfill/backfill 	填充方法向后

丢失缺乏的值

若是只想排除缺乏的值，则使用dropna函数和axis参数。 默认状况下，axis = 0，即在行上应用，这意味着若是行内的任何值是NA，那么整个行被排除。

替换丢失(或)通用值
不少时候，必须用一些具体的值取代一个通用的值。能够经过应用替换方法来实现这一点。
用标量值替换NA是fillna()函数的等效行为
df = pd.DataFrame({'one':[10,20,30,40,50,2000],
'two':[1000,0,30,40,50,60]})
print (df.replace({1000:10,2000:60}))

链接,拼接,可视化,时间日期,