laywerrobot/lib/python3.6/site-packages/pandas/tests/series/indexing/test_numeric.py

# coding=utf-8
# pylint: disable-msg=E1101,W0612

import pytest

import numpy as np
import pandas as pd

from pandas import (Index, Series, DataFrame)

from pandas.compat import lrange, range
from pandas.util.testing import (assert_series_equal)

import pandas.util.testing as tm


def test_get():
    # GH 6383
    s = Series(np.array([43, 48, 60, 48, 50, 51, 50, 45, 57, 48, 56, 45,
                         51, 39, 55, 43, 54, 52, 51, 54]))

    result = s.get(25, 0)
    expected = 0
    assert result == expected

    s = Series(np.array([43, 48, 60, 48, 50, 51, 50, 45, 57, 48, 56,
                         45, 51, 39, 55, 43, 54, 52, 51, 54]),
               index=pd.Float64Index(
                   [25.0, 36.0, 49.0, 64.0, 81.0, 100.0,
                    121.0, 144.0, 169.0, 196.0, 1225.0,
                    1296.0, 1369.0, 1444.0, 1521.0, 1600.0,
                    1681.0, 1764.0, 1849.0, 1936.0],
                   dtype='object'))

    result = s.get(25, 0)
    expected = 43
    assert result == expected

    # GH 7407
    # with a boolean accessor
    df = pd.DataFrame({'i': [0] * 3, 'b': [False] * 3})
    vc = df.i.value_counts()
    result = vc.get(99, default='Missing')
    assert result == 'Missing'

    vc = df.b.value_counts()
    result = vc.get(False, default='Missing')
    assert result == 3

    result = vc.get(True, default='Missing')
    assert result == 'Missing'


def test_get_nan():
    # GH 8569
    s = pd.Float64Index(range(10)).to_series()
    assert s.get(np.nan) is None
    assert s.get(np.nan, default='Missing') == 'Missing'


def test_get_nan_multiple():
    # GH 8569
    # ensure that fixing "test_get_nan" above hasn't broken get
    # with multiple elements
    s = pd.Float64Index(range(10)).to_series()

    idx = [2, 30]
    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
        assert_series_equal(s.get(idx),
                            Series([2, np.nan], index=idx))

    idx = [2, np.nan]
    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
        assert_series_equal(s.get(idx),
                            Series([2, np.nan], index=idx))

    # GH 17295 - all missing keys
    idx = [20, 30]
    assert(s.get(idx) is None)

    idx = [np.nan, np.nan]
    assert(s.get(idx) is None)


def test_delitem():
    # GH 5542
    # should delete the item inplace
    s = Series(lrange(5))
    del s[0]

    expected = Series(lrange(1, 5), index=lrange(1, 5))
    assert_series_equal(s, expected)

    del s[1]
    expected = Series(lrange(2, 5), index=lrange(2, 5))
    assert_series_equal(s, expected)

    # empty
    s = Series()

    def f():
        del s[0]

    pytest.raises(KeyError, f)

    # only 1 left, del, add, del
    s = Series(1)
    del s[0]
    assert_series_equal(s, Series(dtype='int64', index=Index(
        [], dtype='int64')))
    s[0] = 1
    assert_series_equal(s, Series(1))
    del s[0]
    assert_series_equal(s, Series(dtype='int64', index=Index(
        [], dtype='int64')))

    # Index(dtype=object)
    s = Series(1, index=['a'])
    del s['a']
    assert_series_equal(s, Series(dtype='int64', index=Index(
        [], dtype='object')))
    s['a'] = 1
    assert_series_equal(s, Series(1, index=['a']))
    del s['a']
    assert_series_equal(s, Series(dtype='int64', index=Index(
        [], dtype='object')))


def test_slice_float64():
    values = np.arange(10., 50., 2)
    index = Index(values)

    start, end = values[[5, 15]]

    s = Series(np.random.randn(20), index=index)

    result = s[start:end]
    expected = s.iloc[5:16]
    assert_series_equal(result, expected)

    result = s.loc[start:end]
    assert_series_equal(result, expected)

    df = DataFrame(np.random.randn(20, 3), index=index)

    result = df[start:end]
    expected = df.iloc[5:16]
    tm.assert_frame_equal(result, expected)

    result = df.loc[start:end]
    tm.assert_frame_equal(result, expected)


def test_getitem_negative_out_of_bounds():
    s = Series(tm.rands_array(5, 10), index=tm.rands_array(10, 10))

    pytest.raises(IndexError, s.__getitem__, -11)
    pytest.raises(IndexError, s.__setitem__, -11, 'foo')


def test_getitem_regression():
    s = Series(lrange(5), index=lrange(5))
    result = s[lrange(5)]
    assert_series_equal(result, s)


def test_getitem_setitem_slice_bug():
    s = Series(lrange(10), lrange(10))
    result = s[-12:]
    assert_series_equal(result, s)

    result = s[-7:]
    assert_series_equal(result, s[3:])

    result = s[:-12]
    assert_series_equal(result, s[:0])

    s = Series(lrange(10), lrange(10))
    s[-12:] = 0
    assert (s == 0).all()

    s[:-12] = 5
    assert (s == 0).all()


def test_getitem_setitem_slice_integers():
    s = Series(np.random.randn(8), index=[2, 4, 6, 8, 10, 12, 14, 16])

    result = s[:4]
    expected = s.reindex([2, 4, 6, 8])
    assert_series_equal(result, expected)

    s[:4] = 0
    assert (s[:4] == 0).all()
    assert not (s[4:] == 0).any()


def test_setitem_float_labels():
    # note labels are floats
    s = Series(['a', 'b', 'c'], index=[0, 0.5, 1])
    tmp = s.copy()

    s.loc[1] = 'zoo'
    tmp.iloc[2] = 'zoo'

    assert_series_equal(s, tmp)


def test_slice_float_get_set(test_data):
    pytest.raises(TypeError, lambda: test_data.ts[4.0:10.0])

    def f():
        test_data.ts[4.0:10.0] = 0

    pytest.raises(TypeError, f)

    pytest.raises(TypeError, test_data.ts.__getitem__, slice(4.5, 10.0))
    pytest.raises(TypeError, test_data.ts.__setitem__, slice(4.5, 10.0), 0)


def test_slice_floats2():
    s = Series(np.random.rand(10), index=np.arange(10, 20, dtype=float))

    assert len(s.loc[12.0:]) == 8
    assert len(s.loc[12.5:]) == 7

    i = np.arange(10, 20, dtype=float)
    i[2] = 12.2
    s.index = i
    assert len(s.loc[12.0:]) == 8
    assert len(s.loc[12.5:]) == 7


def test_int_indexing():
    s = Series(np.random.randn(6), index=[0, 0, 1, 1, 2, 2])

    pytest.raises(KeyError, s.__getitem__, 5)

    pytest.raises(KeyError, s.__getitem__, 'c')

    # not monotonic
    s = Series(np.random.randn(6), index=[2, 2, 0, 0, 1, 1])

    pytest.raises(KeyError, s.__getitem__, 5)

    pytest.raises(KeyError, s.__getitem__, 'c')


def test_getitem_int64(test_data):
    idx = np.int64(5)
    assert test_data.ts[idx] == test_data.ts[5]