dataframe[columns]对于任意列名都有效，但是datarame.columns只在列名是有效的Python变量名时有效,datarame.columns的语法无法创建新的列。
从DataFrame中选取的列是数据的视图，而不是拷贝。因此，对Series的修改会映射到DataFrame中。如果需要复制，应当显示的使用copy方法。

包含Series的字典也可以用于构造DataFrame:

pdata = {'Ohio':frame3['Ohio'][:-1],
        'Nevada':frame3['Nevada'][:2]}
pd.DataFrame(pdata)

与Series相似，DataFrame的values属性 会将包含在DataFrame中的数据以二维数组ndarray的形式返回。如果DataFrame的列是不同的dtypes,则values的dtype会 自动选择 适合所有列的类型。

索引对象是不可变的，用户无法修改索引对象，不变性使得在多种数据结构中分享索引对象更为安全。与Python集合不同，pandas索引对象可以包含重复标签。

重建索引

reindex是pandas的重要方法，用于创建一个符合新索引的新对象

#Series创建reindex方法时，会将数据按照新的索引进行排列，如果某个索引值之前并不存在，则会引入缺失值
obj = pd.Series([4.5,7.2,-5.3,3.6],index = ['d','b','a','c'])
obj2 = obj.reindex(['a','b','c','d','e'])
obj2
a   -5.3
b    7.2
c    3.6
d    4.5
e    NaN
dtype: float64

对于顺序数据，比如时间序列，再重建索引时可能会需要进行插值或填值

#method可选参数 允许我们使用ffill等方法在重建索引时插值，ffill方法会将值前向填充
obj3 = pd.Series(['blue','purple','yellow'],index=[0,2,4])
obj3.reindex(range(6),method = 'ffill')
0      blue
1      blue
2    purple
3    purple
4    yellow
5    yellow
dtype: object

在DataFrame中，reindex可以改变行索引、列索引，也可以同时改变二者。

#当仅传入一个序列时，结果中的行会重建索引
#列可以使用columns关键字重建索引
frame = pd.DataFrame(np.arange(9).reshape(3,3),
                    index = ['a','c','d'],
                    columns = ['Ohio','Texas','California'])
fframe.reindex(['a','b','c','d'])

    Ohio    Texas   California
a   0.0     1.0     2.0
b   NaN     NaN     NaN
c   3.0     4.0     5.0
d   6.0     7.0     8.0
states= ['Texas','Utah','California']
frame.reindex(columns = states)
 Texas  Utah    California
a   1   NaN     2
c   4   NaN     5
d   7   NaN     8
frame.reindex(index = ['a','b','c','d'],columns = states)
   Texas    Utah    California
a   1.0     NaN     2.0
b   NaN     NaN     NaN
c   4.0     NaN     5.0
d   7.0     NaN     8.0
#补充：这里也可以在reindex方法中加入fill_value=0，来填充缺失值

使用.loc[]进行更为简洁的标签索引

frame.loc[['a','b','c','d'],states]

    Texas   Utah    California
a   1.0     NaN     2.0
b   NaN     NaN     NaN
c   4.0     NaN     5.0
d   7.0     NaN     8.0

在轴向上删除一个或更多的条目，drop方法会返回一个含有指示值或轴向上删除值的新对象,axis参数用来指定轴向。注意inplace属性，它会清除被删除的数据。
可以根据一个布尔值数组切片或选择数据 data[data['three']>5]

使用整数标签.iloc[]进行类似的选择 data.iloc[2,[3,0,1]]

标签索引，左闭右闭。整数索引，左闭右开

ser.loc[:1]
0    0.0
1    1.0
dtype: float64
ser.iloc[:1]
0    0.0
dtype: float64

将Series或DataFrame对象相加时，如果存在某个索引对 或列不相同 ，则返回的索引将是索引对的 并集。将两个行或列 完全不同 的DataFrame相加，结果将全部为空。

df1 = DataFrame(np.arange(9.).reshape(3,3),
               index = ['Ohio','Texas','Colorado'],
               columns = list('bcd'))
df2 = DataFrame(np.arange(12.).reshape(4,3),
               index = ['Utah','Ohio','Texas','Oregon'],
               columns = list('bde'))
df1+df2
         b      c       d       e
Colorado NaN    NaN     NaN     NaN
Ohio    3.0     NaN     6.0     NaN
Oregon  NaN     NaN     NaN     NaN
Texas   9.0     NaN     12.0    NaN
Utah    NaN     NaN     NaN     NaN

当一个轴标签在一个对象存在，另一个对象中不存在时，你想将缺失值填充为0。使用add方法，将对对df2和一个fill_value作为参数传入。

df1 = pd.DataFrame(np.arange(12.).reshape(3,4),columns = list('abcd'))
df2 = pd.DataFrame(np.arange(20.).reshape(4,5),columns = list('abcde'))
df1
    a       b       c       d
0   0.0     1.0     2.0     3.0
1   4.0     5.0     6.0     7.0
2   8.0     9.0     10.0    11.0
df2.loc[1,'b'] = np.nan
df2
    a       b       c       d       e
0   0.0     1.0     2.0     3.0     4.0
1   5.0     NaN     7.0     8.0     9.0
2   10.0    11.0    12.0    13.0    14.0
3   15.0    16.0    17.0    18.0    19.0
df1+df2
    a       b       c       d       e
0   0.0     2.0     4.0     6.0     NaN
1   9.0     NaN     13.0    15.0    NaN
2   18.0    20.0    22.0    24.0    NaN
3   NaN     NaN     NaN     NaN     NaN
df1.add(df2,fill_value = 0)
    a       b       c       d       e
0   0.0     2.0     4.0     6.0     4.0
1   9.0     5.0     13.0    15.0    9.0
2   18.0    20.0    22.0    24.0    14.0
3   15.0    16.0    17.0    18.0    19.0

Series和DataFrame的算术方法中每一个都有一个以r开头的副本，这些副本方法的参数是翻转的。

#下面两个语句是等价的
1 / df1
df1.rdiv(1)
    a       b           c           d
0   inf     1.000000    0.500000    0.333333
1   0.250   0.200000    0.166667    0.142857
2   0.125   0.111111    0.100000    0.090909

捕获.PNG

默认情况下，DataFrame和Series的数学操作中会将Series的索引和DataFrame的列进行匹配，并广播到各行。如果你想在列上进行广播，在行上匹配，可以传递axis值用于匹配轴。
另一个常用的操作是将函数应用到一行或一列的一维数组上，DataFrame的apply方法可以实现。传递axis=0 或axis= ‘index’是对列调用，axis = 1 或axis='columns'是对行调用。

f = lambda x: x.max() - x.min()
frame.apply(f)

按行或按列索引进行字典型排序，使用sort_index方法，该方法返回一个新的、排序好的对象。#默认按行索引排序，传递axis=1对列索引进行排序，ascending = False按照降序排序。

根据Series的值排序，使用sort_values方法，对DataFrame排序时，你可以使用一列或多列作为排序键，为此传递一个或多个列明给sort_values的可选参数by，对多列排序时，传递列名的列表。

排名 指对数组从1到有效数据点总数分配名次的操作，Series和DataFrame的rank方法是实现排名的方法，默认情况下，rank通过将平均排名分配到每个组来打破平级关系。

obj = pd.Series([7,-5,7,4,2,0,4])
obj.rank()
0    6.5
1    1.0
2    6.5
3    4.5
4    3.0
5    2.0
6    4.5
dtype: float64
#排名也可以根据它们在数据中的观察顺序进行分配
obj.rank(method = 'first')
0    6.0
1    1.0
2    7.0
3    4.0
4    3.0
5    2.0
6    5.0
dtype: float64
#你也可以按降序排名,将值分配给组中的最大排名
obj.rank(ascending = False,method = 'max')
0    2.0
1    7.0
2    2.0
3    4.0
4    5.0
5    6.0
6    4.0
dtype: float64
obj.rank(ascending = False,method = 'min')
0    1.0
1    7.0
2    1.0
3    3.0
4    5.0
5    6.0
6    3.0
dtype: float64

DataFrame可以对行或列计算排名

frame= pd.DataFrame({'b':[4.3,7,-3,2],'a':[0,1,0,1],'c':[-2,5,8,-2.5]})
frame
    b   a   c
0   4.3     0   -2.0
1   7.0     1   5.0
2   -3.0    0   8.0
3   2.0     1   -2.5
frame.rank(axis = 'columns')
#指定的是列索引，实际按行在排名
    b   a   c
0   3.0     2.0     1.0
1   3.0     1.0     2.0
2   1.0     2.0     3.0
3   3.0     2.0     1.0

is_unique属性告诉你它的标签是否唯一,带有重复索引的情况下，根据一个标签索引多个条目会返回一个序列
DataFrame的sum方法返回一个包含列上加和的Series,传入axis = ‘columns’或axis = 1，则会将一行上各个列的值相加,NA值是被自动排除的。可以通过skipna=False来实现不排除NA值.
idxmin和idxmax，返回的是间接统计信息，即最小值或最大值的索引值。
函数unique，它会给出Series中的唯一值。
函数value_counts计算Series包含的值的个数。

获取一个Series在另一个Series中的索引值：

pd.Index(Series1).get_indexer(Series2)