Python Series.reindex方法代码示例

# 需要导入模块: from pandas.core.api import Series [as 别名]
# 或者: from pandas.core.api.Series import reindex [as 别名]
    def test_reindex_int(self):
        ts = self.ts[::2]
        int_ts = Series(np.zeros(len(ts), dtype=int), index=ts.index)

        # this should work fine
        reindexed_int = int_ts.reindex(self.ts.index)

        # if NaNs introduced
        self.assert_(reindexed_int.dtype == np.float_)

        # NO NaNs introduced
        reindexed_int = int_ts.reindex(int_ts.index[::2])
        self.assert_(reindexed_int.dtype == np.int_)

# 需要导入模块: from pandas.core.api import Series [as 别名]
# 或者: from pandas.core.api.Series import reindex [as 别名]
    def test_reindex_bool(self):

        # A series other than float, int, string, or object
        ts = self.ts[::2]
        bool_ts = Series(np.zeros(len(ts), dtype=bool), index=ts.index)

        # this should work fine
        reindexed_bool = bool_ts.reindex(self.ts.index)

        # if NaNs introduced
        self.assert_(reindexed_bool.dtype == np.object_)

        # NO NaNs introduced
        reindexed_bool = bool_ts.reindex(bool_ts.index[::2])
        self.assert_(reindexed_bool.dtype == np.bool_)

# 需要导入模块: from pandas.core.api import Series [as 别名]
# 或者: from pandas.core.api.Series import reindex [as 别名]
def _filter_data(lhs, rhs):
    """
    Cleans the input for single OLS.

    Parameters
    ----------
    lhs: Series
        Dependent variable in the regression.
    rhs: dict, whose values are Series, DataFrame, or dict
        Explanatory variables of the regression.

    Returns
    -------
    Series, DataFrame
        Cleaned lhs and rhs
    """
    if not isinstance(lhs, Series):
        assert(len(lhs) == len(rhs))
        lhs = Series(lhs, index=rhs.index)

    rhs = _combine_rhs(rhs)

    rhs_valid = np.isfinite(rhs.values).sum(1) == len(rhs.columns)

    if not rhs_valid.all():
        pre_filtered_rhs = rhs[rhs_valid]
    else:
        pre_filtered_rhs = rhs

    index = lhs.index + rhs.index
    if not index.equals(rhs.index) or not index.equals(lhs.index):
        rhs = rhs.reindex(index)
        lhs = lhs.reindex(index)

        rhs_valid = np.isfinite(rhs.values).sum(1) == len(rhs.columns)

    lhs_valid = np.isfinite(lhs.values)
    valid = rhs_valid & lhs_valid

    if not valid.all():
        filt_index = rhs.index[valid]
        filtered_rhs = rhs.reindex(filt_index)
        filtered_lhs = lhs.reindex(filt_index)
    else:
        filtered_rhs, filtered_lhs = rhs, lhs

    return filtered_lhs, filtered_rhs, pre_filtered_rhs, index, valid

# 需要导入模块: from pandas.core.api import Series [as 别名]
# 或者: from pandas.core.api.Series import reindex [as 别名]
    def y_fitted(self):
        """Returns the fitted y values.  This equals BX."""
        if self._weights is None:
            index = self._x_filtered.index
            orig_index = index
        else:
            index = self._y.index
            orig_index = self._y_orig.index

        result = Series(self._y_fitted_raw, index=index)
        return result.reindex(orig_index)

# 需要导入模块: from pandas.core.api import Series [as 别名]
# 或者: from pandas.core.api.Series import reindex [as 别名]
    def test_groupby_transform(self):
        data = Series(np.arange(9) / 3, index=np.arange(9))

        index = np.arange(9)
        np.random.shuffle(index)
        data = data.reindex(index)

        grouped = data.groupby(lambda x: x // 3)

        transformed = grouped.transform(lambda x: x * x.sum())
        self.assertEqual(transformed[7], 12)

        # corner cases
        self.assertRaises(Exception, grouped.transform,
                          lambda x: x.mean())

# 需要导入模块: from pandas.core.api import Series [as 别名]
# 或者: from pandas.core.api.Series import reindex [as 别名]
    def test_groupby_transform(self):
        data = Series(np.arange(9) / 3, index=np.arange(9))

        index = np.arange(9)
        np.random.shuffle(index)
        data = data.reindex(index)

        grouped = data.groupby(lambda x: x // 3)

        transformed = grouped.transform(lambda x: x * x.sum())
        self.assertEqual(transformed[7], 12)

        transformed = grouped.transform(np.mean)
        for name, group in grouped:
            mean = group.mean()
            for idx in group.index:
                self.assertEqual(transformed[idx], mean)

# 需要导入模块: from pandas.core.api import Series [as 别名]
# 或者: from pandas.core.api.Series import reindex [as 别名]
    def test_groupby(self):
        data = Series(np.arange(9) / 3, index=np.arange(9))

        index = np.arange(9)
        np.random.shuffle(index)
        data = data.reindex(index)

        grouped = data.groupby(lambda x: x // 3)

        repr(grouped.groups) # nothing else here

        for k, v in grouped:
            self.assertEqual(len(v), 3)

        agged = grouped.aggregate(np.mean)
        self.assertEqual(agged[1], 1)

        assert_series_equal(agged, grouped.agg(np.mean)) # shorthand
        assert_series_equal(agged, grouped.mean())

        assert_series_equal(grouped.agg(np.sum), grouped.sum())


        transformed = grouped.transform(lambda x: x * x.sum())
        self.assertEqual(transformed[7], 12)

        value_grouped = data.groupby(data)
        assert_series_equal(value_grouped.aggregate(np.mean), agged)

        # complex agg
        agged = grouped.aggregate([np.mean, np.std])
        agged = grouped.aggregate({'one' : np.mean,
                                   'two' : np.std})

        group_constants = {
            0 : 10,
            1 : 20,
            2 : 30
        }
        agged = grouped.agg(lambda x: group_constants[x.groupName] + x.mean())
        self.assertEqual(agged[1], 21)

        # corner cases
        self.assertRaises(Exception, grouped._aggregate_named,
                          lambda x: x * 2)

# 需要导入模块: from pandas.core.api import Series [as 别名]
# 或者: from pandas.core.api.Series import reindex [as 别名]
 def y_fitted(self):
     """Returns the fitted y values.  This equals BX."""
     result = Series(self._y_fitted_raw, index=self._y.index)
     return result.reindex(self._y_orig.index)

# 需要导入模块: from pandas.core.api import Series [as 别名]
# 或者: from pandas.core.api.Series import reindex [as 别名]
 def test_reindex_bool_pad(self):
     # fail
     ts = self.ts[5:]
     bool_ts = Series(np.zeros(len(ts), dtype=bool), index=ts.index)
     filled_bool = bool_ts.reindex(self.ts.index, fillMethod='pad')
     self.assert_(isnull(filled_bool[:5]).all())

# 需要导入模块: from pandas.core.api import Series [as 别名]
# 或者: from pandas.core.api.Series import reindex [as 别名]

#.........这里部分代码省略.........
        val2 = self.ts.asOf(self.ts.index[19])

        self.assertEqual(val1, self.ts[4])
        self.assertEqual(val2, self.ts[14])

        # accepts strings
        val1 = self.ts.asOf(str(self.ts.index[7]))
        self.assertEqual(val1, self.ts[4])

        # in there
        self.assertEqual(self.ts.asOf(self.ts.index[3]), self.ts[3])

        # no as of value
        d = self.ts.index[0] - datetools.bday
        self.assert_(np.isnan(self.ts.asOf(d)))

    def test_merge(self):
        index, data = common.getMixedTypeDict()

        source = Series(data['B'], index=data['C'])
        target = Series(data['C'][:4], index=data['D'][:4])

        merged = target.merge(source)

        for k, v in merged.iteritems():
            self.assertEqual(v, source[target[k]])

        # input could be a dict
        merged = target.merge(source.toDict())

        for k, v in merged.iteritems():
            self.assertEqual(v, source[target[k]])

    def test_reindex(self):
        identity = self.series.reindex(self.series.index)
        self.assertEqual(id(self.series.index), id(identity.index))

        subIndex = self.series.index[10:20]
        subSeries = self.series.reindex(subIndex)

        for idx, val in subSeries.iteritems():
            self.assertEqual(val, self.series[idx])

        subIndex2 = self.ts.index[10:20]
        subTS = self.ts.reindex(subIndex2)

        for idx, val in subTS.iteritems():
            self.assertEqual(val, self.ts[idx])
        crapSeries = self.ts.reindex(subIndex)

        self.assert_(np.isnan(crapSeries).all())

        # This is extremely important for the Cython code to not screw up
        nonContigIndex = self.ts.index[::2]
        subNonContig = self.ts.reindex(nonContigIndex)
        for idx, val in subNonContig.iteritems():
            self.assertEqual(val, self.ts[idx])

        # bad fill method
        ts = self.ts[::2]
        self.assertRaises(Exception, ts.reindex, self.ts.index, fillMethod='foo')

        # corner case: pad empty series
        reindexed = self.empty.reindex(self.ts.index, fillMethod='pad')

        # pass non-Index