|
28 | 28 | from pandas.tseries.offsets import BDay
|
29 | 29 |
|
30 | 30 |
|
| 31 | +class TestGet: |
| 32 | + def test_get(self, float_frame): |
| 33 | + b = float_frame.get("B") |
| 34 | + tm.assert_series_equal(b, float_frame["B"]) |
| 35 | + |
| 36 | + assert float_frame.get("foo") is None |
| 37 | + tm.assert_series_equal( |
| 38 | + float_frame.get("foo", float_frame["B"]), float_frame["B"] |
| 39 | + ) |
| 40 | + |
| 41 | + @pytest.mark.parametrize( |
| 42 | + "df", |
| 43 | + [ |
| 44 | + DataFrame(), |
| 45 | + DataFrame(columns=list("AB")), |
| 46 | + DataFrame(columns=list("AB"), index=range(3)), |
| 47 | + ], |
| 48 | + ) |
| 49 | + def test_get_none(self, df): |
| 50 | + # see gh-5652 |
| 51 | + assert df.get(None) is None |
| 52 | + |
| 53 | + |
31 | 54 | class TestDataFrameIndexing:
|
32 | 55 | def test_getitem(self, float_frame):
|
33 | 56 | # Slicing
|
@@ -64,27 +87,6 @@ def test_getitem_dupe_cols(self):
|
64 | 87 | with pytest.raises(KeyError, match=re.escape(msg)):
|
65 | 88 | df[["baf"]]
|
66 | 89 |
|
67 |
| - def test_get(self, float_frame): |
68 |
| - b = float_frame.get("B") |
69 |
| - tm.assert_series_equal(b, float_frame["B"]) |
70 |
| - |
71 |
| - assert float_frame.get("foo") is None |
72 |
| - tm.assert_series_equal( |
73 |
| - float_frame.get("foo", float_frame["B"]), float_frame["B"] |
74 |
| - ) |
75 |
| - |
76 |
| - @pytest.mark.parametrize( |
77 |
| - "df", |
78 |
| - [ |
79 |
| - DataFrame(), |
80 |
| - DataFrame(columns=list("AB")), |
81 |
| - DataFrame(columns=list("AB"), index=range(3)), |
82 |
| - ], |
83 |
| - ) |
84 |
| - def test_get_none(self, df): |
85 |
| - # see gh-5652 |
86 |
| - assert df.get(None) is None |
87 |
| - |
88 | 90 | @pytest.mark.parametrize("key_type", [iter, np.array, Series, Index])
|
89 | 91 | def test_loc_iterable(self, float_frame, key_type):
|
90 | 92 | idx = key_type(["A", "B", "C"])
|
@@ -1547,14 +1549,6 @@ def test_loc_duplicates(self):
|
1547 | 1549 | df.loc[trange[bool_idx], "A"] += 6
|
1548 | 1550 | tm.assert_frame_equal(df, expected)
|
1549 | 1551 |
|
1550 |
| - def test_iat(self, float_frame): |
1551 |
| - |
1552 |
| - for i, row in enumerate(float_frame.index): |
1553 |
| - for j, col in enumerate(float_frame.columns): |
1554 |
| - result = float_frame.iat[i, j] |
1555 |
| - expected = float_frame.at[row, col] |
1556 |
| - assert result == expected |
1557 |
| - |
1558 | 1552 | @pytest.mark.parametrize(
|
1559 | 1553 | "method,expected_values",
|
1560 | 1554 | [
|
@@ -1916,89 +1910,6 @@ def test_at_time_between_time_datetimeindex(self):
|
1916 | 1910 | result.loc[bkey] = df.iloc[binds]
|
1917 | 1911 | tm.assert_frame_equal(result, df)
|
1918 | 1912 |
|
1919 |
| - def test_xs(self, float_frame, datetime_frame): |
1920 |
| - idx = float_frame.index[5] |
1921 |
| - xs = float_frame.xs(idx) |
1922 |
| - for item, value in xs.items(): |
1923 |
| - if np.isnan(value): |
1924 |
| - assert np.isnan(float_frame[item][idx]) |
1925 |
| - else: |
1926 |
| - assert value == float_frame[item][idx] |
1927 |
| - |
1928 |
| - # mixed-type xs |
1929 |
| - test_data = {"A": {"1": 1, "2": 2}, "B": {"1": "1", "2": "2", "3": "3"}} |
1930 |
| - frame = DataFrame(test_data) |
1931 |
| - xs = frame.xs("1") |
1932 |
| - assert xs.dtype == np.object_ |
1933 |
| - assert xs["A"] == 1 |
1934 |
| - assert xs["B"] == "1" |
1935 |
| - |
1936 |
| - with pytest.raises( |
1937 |
| - KeyError, match=re.escape("Timestamp('1999-12-31 00:00:00', freq='B')") |
1938 |
| - ): |
1939 |
| - datetime_frame.xs(datetime_frame.index[0] - BDay()) |
1940 |
| - |
1941 |
| - # xs get column |
1942 |
| - series = float_frame.xs("A", axis=1) |
1943 |
| - expected = float_frame["A"] |
1944 |
| - tm.assert_series_equal(series, expected) |
1945 |
| - |
1946 |
| - # view is returned if possible |
1947 |
| - series = float_frame.xs("A", axis=1) |
1948 |
| - series[:] = 5 |
1949 |
| - assert (expected == 5).all() |
1950 |
| - |
1951 |
| - def test_xs_corner(self): |
1952 |
| - # pathological mixed-type reordering case |
1953 |
| - df = DataFrame(index=[0]) |
1954 |
| - df["A"] = 1.0 |
1955 |
| - df["B"] = "foo" |
1956 |
| - df["C"] = 2.0 |
1957 |
| - df["D"] = "bar" |
1958 |
| - df["E"] = 3.0 |
1959 |
| - |
1960 |
| - xs = df.xs(0) |
1961 |
| - exp = pd.Series([1.0, "foo", 2.0, "bar", 3.0], index=list("ABCDE"), name=0) |
1962 |
| - tm.assert_series_equal(xs, exp) |
1963 |
| - |
1964 |
| - # no columns but Index(dtype=object) |
1965 |
| - df = DataFrame(index=["a", "b", "c"]) |
1966 |
| - result = df.xs("a") |
1967 |
| - expected = Series([], name="a", index=pd.Index([]), dtype=np.float64) |
1968 |
| - tm.assert_series_equal(result, expected) |
1969 |
| - |
1970 |
| - def test_xs_duplicates(self): |
1971 |
| - df = DataFrame(np.random.randn(5, 2), index=["b", "b", "c", "b", "a"]) |
1972 |
| - |
1973 |
| - cross = df.xs("c") |
1974 |
| - exp = df.iloc[2] |
1975 |
| - tm.assert_series_equal(cross, exp) |
1976 |
| - |
1977 |
| - def test_xs_keep_level(self): |
1978 |
| - df = DataFrame( |
1979 |
| - { |
1980 |
| - "day": {0: "sat", 1: "sun"}, |
1981 |
| - "flavour": {0: "strawberry", 1: "strawberry"}, |
1982 |
| - "sales": {0: 10, 1: 12}, |
1983 |
| - "year": {0: 2008, 1: 2008}, |
1984 |
| - } |
1985 |
| - ).set_index(["year", "flavour", "day"]) |
1986 |
| - result = df.xs("sat", level="day", drop_level=False) |
1987 |
| - expected = df[:1] |
1988 |
| - tm.assert_frame_equal(result, expected) |
1989 |
| - |
1990 |
| - result = df.xs([2008, "sat"], level=["year", "day"], drop_level=False) |
1991 |
| - tm.assert_frame_equal(result, expected) |
1992 |
| - |
1993 |
| - def test_xs_view(self): |
1994 |
| - # in 0.14 this will return a view if possible a copy otherwise, but |
1995 |
| - # this is numpy dependent |
1996 |
| - |
1997 |
| - dm = DataFrame(np.arange(20.0).reshape(4, 5), index=range(4), columns=range(5)) |
1998 |
| - |
1999 |
| - dm.xs(2)[:] = 10 |
2000 |
| - assert (dm.xs(2) == 10).all() |
2001 |
| - |
2002 | 1913 | def test_index_namedtuple(self):
|
2003 | 1914 | from collections import namedtuple
|
2004 | 1915 |
|
@@ -2154,31 +2065,6 @@ def test_mask_callable(self):
|
2154 | 2065 | tm.assert_frame_equal(result, exp)
|
2155 | 2066 | tm.assert_frame_equal(result, (df + 2).mask((df + 2) > 8, (df + 2) + 10))
|
2156 | 2067 |
|
2157 |
| - def test_head_tail(self, float_frame): |
2158 |
| - tm.assert_frame_equal(float_frame.head(), float_frame[:5]) |
2159 |
| - tm.assert_frame_equal(float_frame.tail(), float_frame[-5:]) |
2160 |
| - |
2161 |
| - tm.assert_frame_equal(float_frame.head(0), float_frame[0:0]) |
2162 |
| - tm.assert_frame_equal(float_frame.tail(0), float_frame[0:0]) |
2163 |
| - |
2164 |
| - tm.assert_frame_equal(float_frame.head(-1), float_frame[:-1]) |
2165 |
| - tm.assert_frame_equal(float_frame.tail(-1), float_frame[1:]) |
2166 |
| - tm.assert_frame_equal(float_frame.head(1), float_frame[:1]) |
2167 |
| - tm.assert_frame_equal(float_frame.tail(1), float_frame[-1:]) |
2168 |
| - # with a float index |
2169 |
| - df = float_frame.copy() |
2170 |
| - df.index = np.arange(len(float_frame)) + 0.1 |
2171 |
| - tm.assert_frame_equal(df.head(), df.iloc[:5]) |
2172 |
| - tm.assert_frame_equal(df.tail(), df.iloc[-5:]) |
2173 |
| - tm.assert_frame_equal(df.head(0), df[0:0]) |
2174 |
| - tm.assert_frame_equal(df.tail(0), df[0:0]) |
2175 |
| - tm.assert_frame_equal(df.head(-1), df.iloc[:-1]) |
2176 |
| - tm.assert_frame_equal(df.tail(-1), df.iloc[1:]) |
2177 |
| - # test empty dataframe |
2178 |
| - empty_df = DataFrame() |
2179 |
| - tm.assert_frame_equal(empty_df.tail(), empty_df) |
2180 |
| - tm.assert_frame_equal(empty_df.head(), empty_df) |
2181 |
| - |
2182 | 2068 | def test_type_error_multiindex(self):
|
2183 | 2069 | # See gh-12218
|
2184 | 2070 | df = DataFrame(
|
@@ -2269,10 +2155,3 @@ def test_set_reset(self):
|
2269 | 2155 |
|
2270 | 2156 | df = result.set_index("foo")
|
2271 | 2157 | tm.assert_index_equal(df.index, idx)
|
2272 |
| - |
2273 |
| - def test_transpose(self, uint64_frame): |
2274 |
| - |
2275 |
| - result = uint64_frame.T |
2276 |
| - expected = DataFrame(uint64_frame.values.T) |
2277 |
| - expected.index = ["A", "B"] |
2278 |
| - tm.assert_frame_equal(result, expected) |
0 commit comments