BUG: df.iloc not working with NamedTuple

[yuanx749]

• closes BUG: Using NamedTuples with .iloc fails #48188(Replace xxxx with the GitHub issue number)
• Tests added and passed if fixing a bug or adding a new feature
• All code checks passed.
• Added type annotations to new arguments/methods/functions.
• Added an entry in the latest doc/source/whatsnew/vX.X.X.rst file if fixing a bug or adding a new feature.

@rhshadrach I kept the type(key) is tuple since index can contain namedtuple, used as key in df.loc[key], as shown in the test case below:

pandas/pandas/tests/indexing/test_loc.py

Lines 1615 to 1624 in 488f6bd

	def test_loc_getitem_index_namedtuple(self):
	IndexType = namedtuple("IndexType", ["a", "b"])
	idx1 = IndexType("foo", "bar")
	idx2 = IndexType("baz", "bof")
	index = Index([idx1, idx2], name="composite_index", tupleize_cols=False)
	df = DataFrame([(1, 2), (3, 4)], index=index, columns=["A", "B"])
	result = df.loc[IndexType("foo", "bar")]["A"]
	assert result == 1

[rhshadrach]

I kept the type(key) is tuple since index can contain namedtuple, used as key in df.loc[key], as shown in the test case below:

Sorry, I don't understand. In particular, the test you highlighted passes with this patch applied and from your comment above I expected it not to.

[yuanx749]

I mean if we only change type(key) is tuple to isinstance(key, tuple), this particular test will fail.

Because in this test, namedtuples are elements of the index, and are used as labels in df.loc. It was handled by the else branch in the original code below.

pandas/pandas/core/indexing.py

Lines 1180 to 1192 in 7281475

	if type(key) is tuple:
	key = tuple(list(x) if is_iterator(x) else x for x in key)
	key = tuple(com.apply_if_callable(x, self.obj) for x in key)
	if self._is_scalar_access(key):
	return self.obj._get_value(*key, takeable=self._takeable)
	return self._getitem_tuple(key)
	else:
	# we by definition only have the 0th axis
	axis = self.axis or 0
	maybe_callable = com.apply_if_callable(key, self.obj)
	maybe_callable = self._check_deprecated_callable_usage(key, maybe_callable)
	return self._getitem_axis(maybe_callable, axis=axis)

[rhshadrach]

Thanks - makes sense. I think this might need further discussion in that case. I do not see a way to support tuple (and subclasses of tuple) in a flat Index (i.e. not a MultiIndex) and using tuples for accessing (row, column) pairs. Indeed, the following variant of that test using tuples fails on main:

idx1 = ("foo", "bar")
idx2 = ("baz", "bof")
index = Index([idx1, idx2], name="composite_index", tupleize_cols=False)
df = DataFrame([(1, 2), (3, 4)], index=index, columns=["A", "B"])
result = df.loc[("foo", "bar")]["A"]
assert result == 1

The only way I can see making it all work is to try one and if it fails try the other - which I think we want to avoid.

While we don't run into this problem with iloc, I wonder if we want to avoid supporting subclasses with iloc but not loc.

cc @jbrockmendel @phofl

[github-actions]

This pull request is stale because it has been open for thirty days with no activity. Please update and respond to this comment if you're still interested in working on this.