FM / methods

/usr/local/lib64/python3.6/site-packages/pandas/tests/frame/methods/

/usr/local/lib64/python3.6/site-packages/pandas/tests/frame/methods

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
test_align.py	10339	0644	edit dl rm
test_append.py	7399	0644	edit dl rm
test_asfreq.py	1970	0644	edit dl rm
test_asof.py	5767	0644	edit dl rm
test_assign.py	2982	0644	edit dl rm
test_astype.py	21027	0644	edit dl rm
test_at_time.py	3205	0644	edit dl rm
test_between_time.py	3675	0644	edit dl rm
test_clip.py	6028	0644	edit dl rm
test_combine.py	1359	0644	edit dl rm
test_combine_first.py	12748	0644	edit dl rm
test_compare.py	6158	0644	edit dl rm
test_count.py	1068	0644	edit dl rm
test_cov_corr.py	11888	0644	edit dl rm
test_describe.py	12492	0644	edit dl rm
test_diff.py	7374	0644	edit dl rm
test_drop.py	15662	0644	edit dl rm
test_droplevel.py	855	0644	edit dl rm
test_drop_duplicates.py	13387	0644	edit dl rm
test_duplicated.py	3191	0644	edit dl rm
test_explode.py	5294	0644	edit dl rm
test_filter.py	4933	0644	edit dl rm
test_first_and_last.py	1803	0644	edit dl rm
test_head_tail.py	1194	0644	edit dl rm
test_interpolate.py	11816	0644	edit dl rm
test_isin.py	7324	0644	edit dl rm
test_nlargest.py	6731	0644	edit dl rm
test_pct_change.py	3436	0644	edit dl rm
test_pop.py	1226	0644	edit dl rm
test_quantile.py	18028	0644	edit dl rm
test_rank.py	11377	0644	edit dl rm
test_reindex_like.py	1187	0644	edit dl rm
test_rename.py	12543	0644	edit dl rm
test_rename_axis.py	4074	0644	edit dl rm
test_replace.py	59230	0644	edit dl rm
test_reset_index.py	12506	0644	edit dl rm
test_round.py	7916	0644	edit dl rm
test_select_dtypes.py	12104	0644	edit dl rm
test_set_index.py	19571	0644	edit dl rm
test_shift.py	10324	0644	edit dl rm
test_sort_index.py	25678	0644	edit dl rm
test_sort_values.py	25358	0644	edit dl rm
test_to_dict.py	9989	0644	edit dl rm
test_to_period.py	984	0644	edit dl rm
test_to_records.py	13981	0644	edit dl rm
test_to_timestamp.py	4020	0644	edit dl rm
test_transpose.py	2426	0644	edit dl rm
test_truncate.py	4180	0644	edit dl rm
test_tz_convert.py	3415	0644	edit dl rm
test_tz_localize.py	666	0644	edit dl rm
test_update.py	4259	0644	edit dl rm
test_value_counts.py	2631	0644	edit dl rm
__init__.py	229	0644	edit dl rm

Edit: /usr/local/lib64/python3.6/site-packages/pandas/tests/frame/methods/test_isin.py (7324B)

import numpy as np
import pytest

import pandas as pd
from pandas import DataFrame, MultiIndex, Series
import pandas._testing as tm

class TestDataFrameIsIn:
    def test_isin(self):
        # GH#4211
        df = DataFrame(
            {
                "vals": [1, 2, 3, 4],
                "ids": ["a", "b", "f", "n"],
                "ids2": ["a", "n", "c", "n"],
            },
            index=["foo", "bar", "baz", "qux"],
        )
        other = ["a", "b", "c"]

result = df.isin(other)
        expected = DataFrame([df.loc[s].isin(other) for s in df.index])
        tm.assert_frame_equal(result, expected)

@pytest.mark.parametrize("empty", [[], Series(dtype=object), np.array([])])
    def test_isin_empty(self, empty):
        # GH#16991
        df = DataFrame({"A": ["a", "b", "c"], "B": ["a", "e", "f"]})
        expected = DataFrame(False, df.index, df.columns)

result = df.isin(empty)
        tm.assert_frame_equal(result, expected)

def test_isin_dict(self):
        df = DataFrame({"A": ["a", "b", "c"], "B": ["a", "e", "f"]})
        d = {"A": ["a"]}

expected = DataFrame(False, df.index, df.columns)
        expected.loc[0, "A"] = True

result = df.isin(d)
        tm.assert_frame_equal(result, expected)

# non unique columns
        df = DataFrame({"A": ["a", "b", "c"], "B": ["a", "e", "f"]})
        df.columns = ["A", "A"]
        expected = DataFrame(False, df.index, df.columns)
        expected.loc[0, "A"] = True
        result = df.isin(d)
        tm.assert_frame_equal(result, expected)

def test_isin_with_string_scalar(self):
        # GH#4763
        df = DataFrame(
            {
                "vals": [1, 2, 3, 4],
                "ids": ["a", "b", "f", "n"],
                "ids2": ["a", "n", "c", "n"],
            },
            index=["foo", "bar", "baz", "qux"],
        )
        msg = (
            r"only list-like or dict-like objects are allowed "
            r"to be passed to DataFrame.isin\(\), you passed a 'str'"
        )
        with pytest.raises(TypeError, match=msg):
            df.isin("a")

with pytest.raises(TypeError, match=msg):
            df.isin("aaa")

def test_isin_df(self):
        df1 = DataFrame({"A": [1, 2, 3, 4], "B": [2, np.nan, 4, 4]})
        df2 = DataFrame({"A": [0, 2, 12, 4], "B": [2, np.nan, 4, 5]})
        expected = DataFrame(False, df1.index, df1.columns)
        result = df1.isin(df2)
        expected["A"].loc[[1, 3]] = True
        expected["B"].loc[[0, 2]] = True
        tm.assert_frame_equal(result, expected)

# partial overlapping columns
        df2.columns = ["A", "C"]
        result = df1.isin(df2)
        expected["B"] = False
        tm.assert_frame_equal(result, expected)

def test_isin_tuples(self):
        # GH#16394
        df = pd.DataFrame({"A": [1, 2, 3], "B": ["a", "b", "f"]})
        df["C"] = list(zip(df["A"], df["B"]))
        result = df["C"].isin([(1, "a")])
        tm.assert_series_equal(result, Series([True, False, False], name="C"))

def test_isin_df_dupe_values(self):
        df1 = DataFrame({"A": [1, 2, 3, 4], "B": [2, np.nan, 4, 4]})
        # just cols duped
        df2 = DataFrame([[0, 2], [12, 4], [2, np.nan], [4, 5]], columns=["B", "B"])
        msg = r"cannot compute isin with a duplicate axis\."
        with pytest.raises(ValueError, match=msg):
            df1.isin(df2)

# just index duped
        df2 = DataFrame(
            [[0, 2], [12, 4], [2, np.nan], [4, 5]],
            columns=["A", "B"],
            index=[0, 0, 1, 1],
        )
        with pytest.raises(ValueError, match=msg):
            df1.isin(df2)

# cols and index:
        df2.columns = ["B", "B"]
        with pytest.raises(ValueError, match=msg):
            df1.isin(df2)

def test_isin_dupe_self(self):
        other = DataFrame({"A": [1, 0, 1, 0], "B": [1, 1, 0, 0]})
        df = DataFrame([[1, 1], [1, 0], [0, 0]], columns=["A", "A"])
        result = df.isin(other)
        expected = DataFrame(False, index=df.index, columns=df.columns)
        expected.loc[0] = True
        expected.iloc[1, 1] = True
        tm.assert_frame_equal(result, expected)

def test_isin_against_series(self):
        df = pd.DataFrame(
            {"A": [1, 2, 3, 4], "B": [2, np.nan, 4, 4]}, index=["a", "b", "c", "d"]
        )
        s = pd.Series([1, 3, 11, 4], index=["a", "b", "c", "d"])
        expected = DataFrame(False, index=df.index, columns=df.columns)
        expected["A"].loc["a"] = True
        expected.loc["d"] = True
        result = df.isin(s)
        tm.assert_frame_equal(result, expected)

def test_isin_multiIndex(self):
        idx = MultiIndex.from_tuples(
            [
                (0, "a", "foo"),
                (0, "a", "bar"),
                (0, "b", "bar"),
                (0, "b", "baz"),
                (2, "a", "foo"),
                (2, "a", "bar"),
                (2, "c", "bar"),
                (2, "c", "baz"),
                (1, "b", "foo"),
                (1, "b", "bar"),
                (1, "c", "bar"),
                (1, "c", "baz"),
            ]
        )
        df1 = DataFrame({"A": np.ones(12), "B": np.zeros(12)}, index=idx)
        df2 = DataFrame(
            {
                "A": [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1],
                "B": [1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1],
            }
        )
        # against regular index
        expected = DataFrame(False, index=df1.index, columns=df1.columns)
        result = df1.isin(df2)
        tm.assert_frame_equal(result, expected)

df2.index = idx
        expected = df2.values.astype(bool)
        expected[:, 1] = ~expected[:, 1]
        expected = DataFrame(expected, columns=["A", "B"], index=idx)

result = df1.isin(df2)
        tm.assert_frame_equal(result, expected)

def test_isin_empty_datetimelike(self):
        # GH#15473
        df1_ts = DataFrame({"date": pd.to_datetime(["2014-01-01", "2014-01-02"])})
        df1_td = DataFrame({"date": [pd.Timedelta(1, "s"), pd.Timedelta(2, "s")]})
        df2 = DataFrame({"date": []})
        df3 = DataFrame()

expected = DataFrame({"date": [False, False]})

result = df1_ts.isin(df2)
        tm.assert_frame_equal(result, expected)
        result = df1_ts.isin(df3)
        tm.assert_frame_equal(result, expected)

result = df1_td.isin(df2)
        tm.assert_frame_equal(result, expected)
        result = df1_td.isin(df3)
        tm.assert_frame_equal(result, expected)

@pytest.mark.parametrize(
        "values",
        [
            pd.DataFrame({"a": [1, 2, 3]}, dtype="category"),
            pd.Series([1, 2, 3], dtype="category"),
        ],
    )
    def test_isin_category_frame(self, values):
        # GH#34256
        df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
        expected = DataFrame({"a": [True, True, True], "b": [False, False, False]})

result = df.isin(values)
        tm.assert_frame_equal(result, expected)

def test_isin_read_only(self):
        # https://github.com/pandas-dev/pandas/issues/37174
        arr = np.array([1, 2, 3])
        arr.setflags(write=False)
        df = DataFrame([1, 2, 3])
        result = df.isin(arr)
        expected = DataFrame([True, True, True])
        tm.assert_frame_equal(result, expected)

cmd: