← Back to branch summary

~teamproject/sisepeu/main

« back to all changes in this revision

Viewing changes to env/lib/python3.6/site-packages/pandas/tests/frame/methods/test_rename.py

  • Committer: riveramarlon113 at gmail
  • Date: 2023-06-04 02:19:28 UTC
  • Revision ID: riveramarlon113@gmail.com-20230604021928-rbt05g3480tfhxxj
Correcion de cosas pequeñas

Show diffs side-by-side

added added

removed removed

Lines of Context:
env/lib/python3.6/site-packages/pandas/tests/frame/methods/test_rename.py
1
 
from collections import ChainMap
2
 
 
3
 
import numpy as np
4
 
import pytest
5
 
 
6
 
from pandas import DataFrame, Index, MultiIndex
7
 
import pandas._testing as tm
8
 
 
9
 
 
10
 
class TestRename:
11
 
    def test_rename(self, float_frame):
12
 
        mapping = {"A": "a", "B": "b", "C": "c", "D": "d"}
13
 
 
14
 
        renamed = float_frame.rename(columns=mapping)
15
 
        renamed2 = float_frame.rename(columns=str.lower)
16
 
 
17
 
        tm.assert_frame_equal(renamed, renamed2)
18
 
        tm.assert_frame_equal(
19
 
            renamed2.rename(columns=str.upper), float_frame, check_names=False
20
 
        )
21
 
 
22
 
        # index
23
 
        data = {"A": {"foo": 0, "bar": 1}}
24
 
 
25
 
        # gets sorted alphabetical
26
 
        df = DataFrame(data)
27
 
        renamed = df.rename(index={"foo": "bar", "bar": "foo"})
28
 
        tm.assert_index_equal(renamed.index, Index(["foo", "bar"]))
29
 
 
30
 
        renamed = df.rename(index=str.upper)
31
 
        tm.assert_index_equal(renamed.index, Index(["BAR", "FOO"]))
32
 
 
33
 
        # have to pass something
34
 
        with pytest.raises(TypeError, match="must pass an index to rename"):
35
 
            float_frame.rename()
36
 
 
37
 
        # partial columns
38
 
        renamed = float_frame.rename(columns={"C": "foo", "D": "bar"})
39
 
        tm.assert_index_equal(renamed.columns, Index(["A", "B", "foo", "bar"]))
40
 
 
41
 
        # other axis
42
 
        renamed = float_frame.T.rename(index={"C": "foo", "D": "bar"})
43
 
        tm.assert_index_equal(renamed.index, Index(["A", "B", "foo", "bar"]))
44
 
 
45
 
        # index with name
46
 
        index = Index(["foo", "bar"], name="name")
47
 
        renamer = DataFrame(data, index=index)
48
 
        renamed = renamer.rename(index={"foo": "bar", "bar": "foo"})
49
 
        tm.assert_index_equal(renamed.index, Index(["bar", "foo"], name="name"))
50
 
        assert renamed.index.name == renamer.index.name
51
 
 
52
 
    @pytest.mark.parametrize(
53
 
        "args,kwargs",
54
 
        [
55
 
            ((ChainMap({"A": "a"}, {"B": "b"}),), dict(axis="columns")),
56
 
            ((), dict(columns=ChainMap({"A": "a"}, {"B": "b"}))),
57
 
        ],
58
 
    )
59
 
    def test_rename_chainmap(self, args, kwargs):
60
 
        # see gh-23859
61
 
        colAData = range(1, 11)
62
 
        colBdata = np.random.randn(10)
63
 
 
64
 
        df = DataFrame({"A": colAData, "B": colBdata})
65
 
        result = df.rename(*args, **kwargs)
66
 
 
67
 
        expected = DataFrame({"a": colAData, "b": colBdata})
68
 
        tm.assert_frame_equal(result, expected)
69
 
 
70
 
    def test_rename_multiindex(self):
71
 
 
72
 
        tuples_index = [("foo1", "bar1"), ("foo2", "bar2")]
73
 
        tuples_columns = [("fizz1", "buzz1"), ("fizz2", "buzz2")]
74
 
        index = MultiIndex.from_tuples(tuples_index, names=["foo", "bar"])
75
 
        columns = MultiIndex.from_tuples(tuples_columns, names=["fizz", "buzz"])
76
 
        df = DataFrame([(0, 0), (1, 1)], index=index, columns=columns)
77
 
 
78
 
        #
79
 
        # without specifying level -> across all levels
80
 
 
81
 
        renamed = df.rename(
82
 
            index={"foo1": "foo3", "bar2": "bar3"},
83
 
            columns={"fizz1": "fizz3", "buzz2": "buzz3"},
84
 
        )
85
 
        new_index = MultiIndex.from_tuples(
86
 
            [("foo3", "bar1"), ("foo2", "bar3")], names=["foo", "bar"]
87
 
        )
88
 
        new_columns = MultiIndex.from_tuples(
89
 
            [("fizz3", "buzz1"), ("fizz2", "buzz3")], names=["fizz", "buzz"]
90
 
        )
91
 
        tm.assert_index_equal(renamed.index, new_index)
92
 
        tm.assert_index_equal(renamed.columns, new_columns)
93
 
        assert renamed.index.names == df.index.names
94
 
        assert renamed.columns.names == df.columns.names
95
 
 
96
 
        #
97
 
        # with specifying a level (GH13766)
98
 
 
99
 
        # dict
100
 
        new_columns = MultiIndex.from_tuples(
101
 
            [("fizz3", "buzz1"), ("fizz2", "buzz2")], names=["fizz", "buzz"]
102
 
        )
103
 
        renamed = df.rename(columns={"fizz1": "fizz3", "buzz2": "buzz3"}, level=0)
104
 
        tm.assert_index_equal(renamed.columns, new_columns)
105
 
        renamed = df.rename(columns={"fizz1": "fizz3", "buzz2": "buzz3"}, level="fizz")
106
 
        tm.assert_index_equal(renamed.columns, new_columns)
107
 
 
108
 
        new_columns = MultiIndex.from_tuples(
109
 
            [("fizz1", "buzz1"), ("fizz2", "buzz3")], names=["fizz", "buzz"]
110
 
        )
111
 
        renamed = df.rename(columns={"fizz1": "fizz3", "buzz2": "buzz3"}, level=1)
112
 
        tm.assert_index_equal(renamed.columns, new_columns)
113
 
        renamed = df.rename(columns={"fizz1": "fizz3", "buzz2": "buzz3"}, level="buzz")
114
 
        tm.assert_index_equal(renamed.columns, new_columns)
115
 
 
116
 
        # function
117
 
        func = str.upper
118
 
        new_columns = MultiIndex.from_tuples(
119
 
            [("FIZZ1", "buzz1"), ("FIZZ2", "buzz2")], names=["fizz", "buzz"]
120
 
        )
121
 
        renamed = df.rename(columns=func, level=0)
122
 
        tm.assert_index_equal(renamed.columns, new_columns)
123
 
        renamed = df.rename(columns=func, level="fizz")
124
 
        tm.assert_index_equal(renamed.columns, new_columns)
125
 
 
126
 
        new_columns = MultiIndex.from_tuples(
127
 
            [("fizz1", "BUZZ1"), ("fizz2", "BUZZ2")], names=["fizz", "buzz"]
128
 
        )
129
 
        renamed = df.rename(columns=func, level=1)
130
 
        tm.assert_index_equal(renamed.columns, new_columns)
131
 
        renamed = df.rename(columns=func, level="buzz")
132
 
        tm.assert_index_equal(renamed.columns, new_columns)
133
 
 
134
 
        # index
135
 
        new_index = MultiIndex.from_tuples(
136
 
            [("foo3", "bar1"), ("foo2", "bar2")], names=["foo", "bar"]
137
 
        )
138
 
        renamed = df.rename(index={"foo1": "foo3", "bar2": "bar3"}, level=0)
139
 
        tm.assert_index_equal(renamed.index, new_index)
140
 
 
141
 
    def test_rename_nocopy(self, float_frame):
142
 
        renamed = float_frame.rename(columns={"C": "foo"}, copy=False)
143
 
        renamed["foo"] = 1.0
144
 
        assert (float_frame["C"] == 1.0).all()
145
 
 
146
 
    def test_rename_inplace(self, float_frame):
147
 
        float_frame.rename(columns={"C": "foo"})
148
 
        assert "C" in float_frame
149
 
        assert "foo" not in float_frame
150
 
 
151
 
        c_id = id(float_frame["C"])
152
 
        float_frame = float_frame.copy()
153
 
        return_value = float_frame.rename(columns={"C": "foo"}, inplace=True)
154
 
        assert return_value is None
155
 
 
156
 
        assert "C" not in float_frame
157
 
        assert "foo" in float_frame
158
 
        assert id(float_frame["foo"]) != c_id
159
 
 
160
 
    def test_rename_bug(self):
161
 
        # GH 5344
162
 
        # rename set ref_locs, and set_index was not resetting
163
 
        df = DataFrame({0: ["foo", "bar"], 1: ["bah", "bas"], 2: [1, 2]})
164
 
        df = df.rename(columns={0: "a"})
165
 
        df = df.rename(columns={1: "b"})
166
 
        df = df.set_index(["a", "b"])
167
 
        df.columns = ["2001-01-01"]
168
 
        expected = DataFrame(
169
 
            [[1], [2]],
170
 
            index=MultiIndex.from_tuples(
171
 
                [("foo", "bah"), ("bar", "bas")], names=["a", "b"]
172
 
            ),
173
 
            columns=["2001-01-01"],
174
 
        )
175
 
        tm.assert_frame_equal(df, expected)
176
 
 
177
 
    def test_rename_bug2(self):
178
 
        # GH 19497
179
 
        # rename was changing Index to MultiIndex if Index contained tuples
180
 
 
181
 
        df = DataFrame(data=np.arange(3), index=[(0, 0), (1, 1), (2, 2)], columns=["a"])
182
 
        df = df.rename({(1, 1): (5, 4)}, axis="index")
183
 
        expected = DataFrame(
184
 
            data=np.arange(3), index=[(0, 0), (5, 4), (2, 2)], columns=["a"]
185
 
        )
186
 
        tm.assert_frame_equal(df, expected)
187
 
 
188
 
    def test_rename_errors_raises(self):
189
 
        df = DataFrame(columns=["A", "B", "C", "D"])
190
 
        with pytest.raises(KeyError, match="'E'] not found in axis"):
191
 
            df.rename(columns={"A": "a", "E": "e"}, errors="raise")
192
 
 
193
 
    @pytest.mark.parametrize(
194
 
        "mapper, errors, expected_columns",
195
 
        [
196
 
            ({"A": "a", "E": "e"}, "ignore", ["a", "B", "C", "D"]),
197
 
            ({"A": "a"}, "raise", ["a", "B", "C", "D"]),
198
 
            (str.lower, "raise", ["a", "b", "c", "d"]),
199
 
        ],
200
 
    )
201
 
    def test_rename_errors(self, mapper, errors, expected_columns):
202
 
        # GH 13473
203
 
        # rename now works with errors parameter
204
 
        df = DataFrame(columns=["A", "B", "C", "D"])
205
 
        result = df.rename(columns=mapper, errors=errors)
206
 
        expected = DataFrame(columns=expected_columns)
207
 
        tm.assert_frame_equal(result, expected)
208
 
 
209
 
    def test_rename_objects(self, float_string_frame):
210
 
        renamed = float_string_frame.rename(columns=str.upper)
211
 
 
212
 
        assert "FOO" in renamed
213
 
        assert "foo" not in renamed
214
 
 
215
 
    def test_rename_axis_style(self):
216
 
        # https://github.com/pandas-dev/pandas/issues/12392
217
 
        df = DataFrame({"A": [1, 2], "B": [1, 2]}, index=["X", "Y"])
218
 
        expected = DataFrame({"a": [1, 2], "b": [1, 2]}, index=["X", "Y"])
219
 
 
220
 
        result = df.rename(str.lower, axis=1)
221
 
        tm.assert_frame_equal(result, expected)
222
 
 
223
 
        result = df.rename(str.lower, axis="columns")
224
 
        tm.assert_frame_equal(result, expected)
225
 
 
226
 
        result = df.rename({"A": "a", "B": "b"}, axis=1)
227
 
        tm.assert_frame_equal(result, expected)
228
 
 
229
 
        result = df.rename({"A": "a", "B": "b"}, axis="columns")
230
 
        tm.assert_frame_equal(result, expected)
231
 
 
232
 
        # Index
233
 
        expected = DataFrame({"A": [1, 2], "B": [1, 2]}, index=["x", "y"])
234
 
        result = df.rename(str.lower, axis=0)
235
 
        tm.assert_frame_equal(result, expected)
236
 
 
237
 
        result = df.rename(str.lower, axis="index")
238
 
        tm.assert_frame_equal(result, expected)
239
 
 
240
 
        result = df.rename({"X": "x", "Y": "y"}, axis=0)
241
 
        tm.assert_frame_equal(result, expected)
242
 
 
243
 
        result = df.rename({"X": "x", "Y": "y"}, axis="index")
244
 
        tm.assert_frame_equal(result, expected)
245
 
 
246
 
        result = df.rename(mapper=str.lower, axis="index")
247
 
        tm.assert_frame_equal(result, expected)
248
 
 
249
 
    def test_rename_mapper_multi(self):
250
 
        df = DataFrame({"A": ["a", "b"], "B": ["c", "d"], "C": [1, 2]}).set_index(
251
 
            ["A", "B"]
252
 
        )
253
 
        result = df.rename(str.upper)
254
 
        expected = df.rename(index=str.upper)
255
 
        tm.assert_frame_equal(result, expected)
256
 
 
257
 
    def test_rename_positional_named(self):
258
 
        # https://github.com/pandas-dev/pandas/issues/12392
259
 
        df = DataFrame({"a": [1, 2], "b": [1, 2]}, index=["X", "Y"])
260
 
        result = df.rename(index=str.lower, columns=str.upper)
261
 
        expected = DataFrame({"A": [1, 2], "B": [1, 2]}, index=["x", "y"])
262
 
        tm.assert_frame_equal(result, expected)
263
 
 
264
 
    def test_rename_axis_style_raises(self):
265
 
        # see gh-12392
266
 
        df = DataFrame({"A": [1, 2], "B": [1, 2]}, index=["0", "1"])
267
 
 
268
 
        # Named target and axis
269
 
        over_spec_msg = "Cannot specify both 'axis' and any of 'index' or 'columns'"
270
 
        with pytest.raises(TypeError, match=over_spec_msg):
271
 
            df.rename(index=str.lower, axis=1)
272
 
 
273
 
        with pytest.raises(TypeError, match=over_spec_msg):
274
 
            df.rename(index=str.lower, axis="columns")
275
 
 
276
 
        with pytest.raises(TypeError, match=over_spec_msg):
277
 
            df.rename(columns=str.lower, axis="columns")
278
 
 
279
 
        with pytest.raises(TypeError, match=over_spec_msg):
280
 
            df.rename(index=str.lower, axis=0)
281
 
 
282
 
        # Multiple targets and axis
283
 
        with pytest.raises(TypeError, match=over_spec_msg):
284
 
            df.rename(str.lower, index=str.lower, axis="columns")
285
 
 
286
 
        # Too many targets
287
 
        over_spec_msg = "Cannot specify both 'mapper' and any of 'index' or 'columns'"
288
 
        with pytest.raises(TypeError, match=over_spec_msg):
289
 
            df.rename(str.lower, index=str.lower, columns=str.lower)
290
 
 
291
 
        # Duplicates
292
 
        with pytest.raises(TypeError, match="multiple values"):
293
 
            df.rename(id, mapper=id)
294
 
 
295
 
    def test_rename_positional_raises(self):
296
 
        # GH 29136
297
 
        df = DataFrame(columns=["A", "B"])
298
 
        msg = r"rename\(\) takes from 1 to 2 positional arguments"
299
 
 
300
 
        with pytest.raises(TypeError, match=msg):
301
 
            df.rename(None, str.lower)
302
 
 
303
 
    def test_rename_no_mappings_raises(self):
304
 
        # GH 29136
305
 
        df = DataFrame([[1]])
306
 
        msg = "must pass an index to rename"
307
 
        with pytest.raises(TypeError, match=msg):
308
 
            df.rename()
309
 
 
310
 
        with pytest.raises(TypeError, match=msg):
311
 
            df.rename(None, index=None)
312
 
 
313
 
        with pytest.raises(TypeError, match=msg):
314
 
            df.rename(None, columns=None)
315
 
 
316
 
        with pytest.raises(TypeError, match=msg):
317
 
            df.rename(None, columns=None, index=None)
318
 
 
319
 
    def test_rename_mapper_and_positional_arguments_raises(self):
320
 
        # GH 29136
321
 
        df = DataFrame([[1]])
322
 
        msg = "Cannot specify both 'mapper' and any of 'index' or 'columns'"
323
 
        with pytest.raises(TypeError, match=msg):
324
 
            df.rename({}, index={})
325
 
 
326
 
        with pytest.raises(TypeError, match=msg):
327
 
            df.rename({}, columns={})
328
 
 
329
 
        with pytest.raises(TypeError, match=msg):
330
 
            df.rename({}, columns={}, index={})