Início / coding / Perguntas / 78692950
Accepted
Pro Q
Asked: 2024-07-01 23:02:53 +0800 CST

Por que nenhum aviso é emitido para indexar uma série de valores com uma série bool que é muito longa?

  • 772

Eu tenho o seguinte código:

import pandas as pd

series_source = pd.Series([1, 2, 3, 4], dtype=int)
normal_index = pd.Series([True, False, True, True], dtype=bool)
big_index = pd.Series([True, False, True, True, False, True], dtype=bool)

# Both indexes give back: pd.Series([1, 2, 3, 4], dtype=int)
# no warnings are raised!
assert (series_source[normal_index] == series_source[big_index]).all() 

df_source = pd.DataFrame(
    [
        [1, 2, 3, 4],
        [5, 6, 7, 8],
        [9, 10, 11, 12],
        [13, 14, 15, 16]
    ]
)

# no warning - works as expected: grabs rows 0, 2, and 3
df_normal_result = df_source[normal_index]

# UserWarning: Boolean Series key will be reindexed to match DataFrame index.
# (but still runs)
df_big_result = df_source[big_index]

# passes - they are equivalent
assert df_normal_result.equals(df_big_result)
print("Complete")

Por que indexar the series_sourcecom the big_indexnão gera um aviso, mesmo que o índice grande tenha mais valores que a fonte? O que os pandas estão fazendo nos bastidores para fazer a indexação da série?

(Compare isso com a indexação do df_source, onde é gerado um aviso explícito que big_indexprecisa ser reindexado para que a operação funcione.)

Nos documentos de indexação , afirma que:

Usar um vetor booleano para indexar uma série funciona exatamente como em um ndarray NumPy

No entanto, se eu fizer

import numpy as np

a = np.array([1, 2, 3, 4, 5])
b = np.array([True, False, True, True, False])
c = np.array([True, False, True, True, False, True, True])

# returns an ndarray of [1,3, 4] as expected
print(a[b])

# raises IndexError: boolean index did not match indexed array along axis 0;
# size of axis is 5 but size of corresponding boolean axis is 7
print(a[c])

Portanto, não parece que essa funcionalidade corresponda ao Numpy, como afirmam os documentos. O que está acontecendo?

(Minhas versões são pandas==2.2.2e numpy==2.0.0.)

python

2 respostas

  1. Best Answer

    Porque a série de indexação é primeiro alinhada ao índice do DataFrame/Série indexado.

    Resumindo, o pandas está fazendo:

    tmp = big_index.reindex(df.index)
df_big_result = df_source[tmp]

    Exemplo para uma série:

    pd.Series([0,1,2])[pd.Series([True, True, False], index=[1,2,0])]

#  1    1
#  2    2
#  dtype: int64

    Na verdade, você mesmo pode observar isso se alterar os índices da série de indexação:

    big_index2 = pd.Series([False, False, True, True, True, True],
                       index=[4,5,0,1,2,3], dtype=bool)
df_source[big_index2]

    Saída:

        0   1   2   3
0   1   2   3   4
1   5   6   7   8
2   9  10  11  12
3  13  14  15  16

    Temos 4 linhas na saída, apesar dos dois primeiros valores serem False. Após a reindexação, os valores booleanos são [True, True, True, True].

    Você deve receber um aviso neste caso:

    UserWarning: Boolean Series key will be reindexed to match DataFrame index.

    Observe que se o alinhamento não puder ser feito, um erro será gerado, como em numpy:

    pd.Series([0,1,2])[pd.Series([True, True, False], index=[1,2,3])]
# IndexingError: Unalignable boolean Series provided as indexer (index of the boolean Series and of the indexed object do not match).

pd.Series([0,1,2])[[True, False, False, True]]
# IndexError: Boolean index has wrong length: 4 instead of 3

    por que isso acontece com DataFrame[Series] mas não com Series[Series]?

    Porque há uma verificação para DataFrame[Series]

    # internal for DataFrame.__getitem__
     def __getitem__(self, key):
        # ...
        if isinstance(key, Series) and not key.index.equals(self.index):
            warnings.warn(
                "Boolean Series key will be reindexed to match DataFrame index.",
                UserWarning,
                stacklevel=find_stack_level(),
            )

# internal for Series.__getitem__
         if com.is_bool_indexer(key):
             key = check_bool_indexer(self.index, key)
             key = np.asarray(key, dtype=bool)
             return self._get_rows_with_mask(key)
    • 2

  2. Esclarecendo meu aprendizado com a resposta de @mozway :

    Ao indexar a pd.Seriesou pd.DataFramecom a pd.Series[bool], o pandas combinará os rótulos dos valores na série de origem (ou os rótulos das linhas no dataframe de origem) com os rótulos encontrados na série de indexação. Este processo é feito internamente através do reindexmétodo: bool_series.reindex(source.index).

    Observe que se um rótulo estiver na fonte e não estiver no indexador booleano, a reindexação não será possível e, portanto, o programa gerará um erro.

    Se a fonte for um dataframe e os rótulos da série booleana de indexação não corresponderem exatamente aos rótulos do dataframe de origem ( source_df.index != bool_series.index), o programa emitirá um aviso indicando que a reindexação será feita. No entanto, se a fonte for uma série e os rótulos não corresponderem exatamente a ( source_series.index != bool_series.index), nenhum aviso será gerado (apenas reindexará silenciosamente a série booleana). Este é apenas um detalhe de implementação.

    • 0

relate perguntas