Pandas入门学习总结

import pandas as pd

import numpy as np
# Pandas中的数据结构
# Series：一维数组，与Numpy中的一维array类似。二者与Python基本的数据结构List也很相近，
# 其区别是：List中的元素可以是不同的数据类型，而Array和Series中则只允许存储相同的数据类型，
# 这样可以更有效的使用内存，提高运算效率。
# Time- Series：以时间为索引的Series
# DataFrame：二维的表格型数据结构,可以将DataFrame理解为Series的容器
s = pd.Series([1,3,5,np.nan,6,8])#NAN表明不是个数

print(s)

# DataFrame
#  DataFrame是二维的数据结构，其本质是Series的容器，
#  因此，DataFrame可以包含一个索引以及与这些索引联合在一起的Series，
#  由于一个Series中的数据类型是相同的，而不同Series的数据结构可以不同。
#  因此对于DataFrame来说，每一列的数据结构都是相同的，而不同的列之间则可以是不同的数据结构。
#  或者以数据库进行类比，DataFrame中的每一行是一个记录，名称为Index的一个元素，
#  而每一列则为一个字段，是这个记录的一个属性
# 模式1:
# dict = {'col1': ts1, 'col2': ts2} # tsx可以是列表、字典、元组、或者pd.series()
# df = pd.DataFrame(data=data, index=index) # index也可以是pd.date_range等其他类型
# 模式2:
# df = pd.DataFrame(data=data,index = index,columns = columns)
# 模式3:
# dict = {'column1_name':pd.Series(),'column2_name':pd.Series(),...,'columnn_name':pd.Series()}
# df = pd.DataFrame(dict,index = index ) #没有index则默认从np.arange(n)从0到(n-1)
# 这时候的最外面字典对应的是DataFrame的列，
# 内嵌的字典及Series则是其中每个值
# 可以看到d是一个字典，其中one的值为Series有3个值，而two为Series有4个值。
# 由d构建的为一个4行2列的DataFrame。其中one只有3个值，因此d行one列为NaN（Not a Number）
# --Pandas默认的缺失值标记
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)

改变两个列的名字，其他不变

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

结果不发生改变，说明是按照列的名字排序的
d = {'one' : pd.Series([1., 2., 3.], index=['a', 'b', 'c']),

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

print('---------- ',df)

# 字典中每个值对应的是这条记录的相关属性
d = [{'one' : 1,'two':1},{'one' : 2,'two' : 2},{'one' : 3,'two' : 3},{'two' : 4}]
df = pd.DataFrame(d,index=['a','b','c','d']

print('---------- ',df)

# 以上的语句与以Series的字典形式创建的DataFrame相同，只是思路略有不同，一个是以列为单位构建，
# 将所有记录的不同属性转化为多个Series，行标签冗余，另一个是以行为单位构建，
# 将每条记录转化为一个字典，列标签冗余。使用这种方式，如果不通过columns指定列的顺序，
# 那么列的顺序会是随机即3.1的。
dates = pd.date_range('20130101',periods=6)#共6天

df = pd.DataFrame(np.random.randn(6,4),index=dates,columns=list('ABCD'))

#list(str)可以将字符串 打散 输出出来

print(df)

pd.date_range(start,end,periods,freq,normalize)

start：开始日期

end：结束日期

periods：日期范围内日期的个数，periods*freq 等于日期范围的长度

freq：每多少天或其他明确时间频率的方式，默认为D，即1天

normalize：把日期规范化到午夜时间戳，即把时间规范化为 00:00:00

df2 = pd.DataFrame({ 'A' : 1.,
                    'B' : pd.Timestamp('20130102'),#pd.Timestamp(日期)  数字生成日期格式
                    'C' : pd.Series(1,index=list(range(4)),dtype='float32'),#list(range(4) 即[0, 1, 2, 3]

                    'D' : np.array([3] * 4,dtype='int32'),#np.array([3] * 4,dtype='int32') 即 [3 3 3 3]

                    #np.array([元素] * k) 即 [元素 元素 元素 元素.....元素 元素] 一共k个

                    'E' : pd.Categorical(["test","train","test","train"]),
                    'F' : 'foo' })

print('df2 ',df2)

# head和tail方法可以显示DataFrame前N条和后N条记录，N为对应的参数，默认值为5。

print('head')
print(df2.head(2))
print('tail')

print(df2.tail(2))

# 显示索引,列,和底层numpy数据
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)
print('df.index ',df.index)
print('df.columns ',df.columns)
print('df.values ',df.values)

print(df.describe())

# 转置

print(df.T)

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

print('原始df ',df)

x = df.sort_index(axis=1, ascending=False) #ascending=False降序排列,ascending=True升序排列

axis = 0 按行名称 axis = 1 按列名称 

print('按轴标签排序 ',x)

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

print(df)

x =df.sort_values(['a','b'],axis=1,ascending=False)

或者

#x = df.sort_values(axis=1,by =['a','b'] ,ascending=False)

先按照第'a'行的值排序 如果有重复 按照'b'行排序

这里的axis可以省略，因为 名字可以唯一确定 某一列或某一行

#sort(columns = 'two', ascending=False) #注意ascending仅是参数名字,True对应降序排列，False对应升序排列

print('排序 ',x)

dates = pd.date_range('1/1/2000', periods=5)
df = pd.DataFrame(np.random.randn(5, 4), index=dates, 
                  columns=['A', 'B', 'C', 'D'])
print('df ',df)

print("列'A': ",df['A'])

s = df['A']
print('s[0:3] ',s[0:3])

print(' 原来df: ',df)

df[['B', 'A']] = df[['A', 'B']]
print(" 'A'列与'B'列互换后的df: ",df)
print('df的前三行 ',df[:3])
print(' df: ',df)

print(' 反向输出df ',df[::-1])

df = pd.DataFrame(np.random.randn(5,4), columns=list('ABCD'), 
                   index=pd.date_range('20130101',periods=5))
# 这是错误的，无法进行slices
# dfl.loc[2:3]
#这是可以的

print(df.loc['20130102':'20130104'])

s = df['A']

print('单列切片是可以的但是要用loc函数 ',s.loc['20130102':'20130104'])

df1 = pd.DataFrame(np.random.randn(6,4),index=list('abcdef'), 
                   columns=list('ABCD'))
print(df1)

print("df1.loc[['a', 'b', 'd'], :] ",df1.loc[['a', 'b', 'd'], :])

print("终于找到了一种dataframe切片的方式了:df1.loc['d':, 'A':'C'] ",df1.loc['d':, 'A':'C'])

df1.loc(['a'] > 0)

# 跟排序关系密切，且它会增设一个排名值（从1开始，一直到数组中有 效数据的数量）。
# 它跟numpy.argsort产生的间接排序索引差不多，只不过它可以根据某种规则破坏平级关系。
# Series和DataFrame的rank方法:默认情况下，rank是通过“为各组分配一个平均排名”的方式破坏平级关系的
# 排名时用于破坏平级关系的method选项
# Method                           说明
# ‘average’         默认：在相等分组中，为各个值分配平均排名
# ‘min’             使用整个分组的最小排名
# ‘max’             使用整个分组的最大排名
# ‘first’           按值在原始数据中的出现顺序分配排名 
obj = pd.Series([7,-5,7,4,2,0,4])
print(" Original obj: ",obj)

print(" Default mode of ranking (average ranking): ",obj.rank()) #默认是平均排名

print(" First mode of ranking (group by the ordering of presentation): ",obj.rank(method='first'))  #根据值在原数据中出现的顺序给出排名

print(" 按降序使用分组的最大排名: ",obj.rank(ascending=False, method='max'))

print(" 按降序使用分组的最小排名: ",obj.rank(ascending=False, method='min'))#符合人们习惯的排名

类似于 numpy.argsort(ascending = True)
# DataFrame的排序接近与人们的直观印象
dict = {'a':pd.Series([0,1,0,1],index = [1,2,3,4]),
        'b':[4.3, 7, -3, 2],
        'c':[-2, 5, 8, -2.5]}
df3 = pd.DataFrame(dict)
print(" original df3: ",df3)
print(" df3按行升序排序: ",df3.rank(axis=1)) # df.rank()返回的都是类似于argsort()返回的索引值
print(" df3按列升序排序: ",df3.rank(axis=0))

data = np.random.randn(6,4)
dates_index = pd.date_range('20170802',periods = 6)
labeled_columns = list('ABCD')
df = pd.DataFrame(data,index = dates_index,columns = labeled_columns)
#可以使用一些方法通过位置num或名字label来检索，例如 ix索引成员(field)

.ix既可以输入行名、列名，也可以输入整数索引和slice切片
print(" original df: ",df)
print(" df.ix['20170802'] ",df.ix['20170802'])
print(" df.ix[:,'A'] ",df.ix[:,'A'])
print(" df.ix[:,'A'] ",df.ix[:,['A','B']])
print(" df.ix[:,'A':'C'] ",df.ix[:,'A':'C'])
print(" df.ix[0:3,0:3] ",df.ix[0:3,0:3])

print(" original df: ",df)
print(" df.iloc[0,:] ",df.iloc[0,:])
print(" df.iloc[:,0] ",df.iloc[:,0])
print(" df.iloc[0:3,0:3] ",df.iloc[0:3,0:3])

print(" original df: ",df)
print(" 第一行df.loc[dates_index[0],:] ",df.loc[dates_index[0],:])
print(" 0-1行A到C列df.loc[dates_index[0:2],'A':'C'] ",df.loc[dates_index[0:2],'A':'C'])
print("从第二行到下面所有行ndf.loc[dates_index[2:],:] ",df.loc[dates_index[2:],:])

print(" original df: ",df)
print(" df.A>0.5: ", df.A>0.5 )#注意这里可以用df.A来引用df的'A'列,等价与df['A']>0.5
print(" df[df.A>0.5] ", df[df.A>0.5] )
print(" df[df['A']>0.5] ", df[df['A']>0.5] )

data = np.random.randn(6,4)
dates_index = pd.date_range('20170802',periods = 6)
labeled_columns = list('ABCD')
df = pd.DataFrame(data,index = dates_index,columns = labeled_columns)

print('df.index: ', df.index) #虽然自动弹出项没有该项，但是可以正常输出
print("df.columns ", df.columns)
print(" values: ", df.values)

对DataFrame的每一行进行迭代，返回一个Tuple (index, Series)
print(" 循环遍历df,原始df如下: ",df)
print(" &&&&&&&&&&&&&&&&&&&& ")
for idx,row in df.iterrows():
    print(' idx ',idx)
    print(row)

也是一行一行地迭代，返回的是一个namedtuple，通常比iterrow快，
# 因为不需要做转换
print(" @@@@@@@@@@@@@@@@@@@@ ")
for row in df.itertuples():
    print (row)

对DataFrame相当于对列迭代
print(" ^^^^^^^^^^^^^^^^ ")
for c, col in df.iteritems():
    print (c)
    print(col)

print(" df的行数:",df.shape[0])
print(" df的数据类型: ",df.dtypes)