Excluir linhas de um DataFrame do pandas com base em uma expressão condicional envolvendo len (string) fornecendo KeyError

Eu tenho um DataFrame do pandas e quero excluir linhas dele onde o comprimento da string em uma coluna específica é maior que 2.

Espero poder fazer isso (por esta resposta ):

df[(len(df['column name']) < 2)]

mas acabei de receber o erro:

KeyError: u'no item named False'

O que estou fazendo de errado?

(Nota: eu sei que posso usar df.dropna()para me livrar de linhas que contenham alguma NaN, mas não vi como remover linhas com base em uma expressão condicional.)

Quando você len(df['column name'])obtém apenas um número, ou seja, o número de linhas no DataFrame (ou seja, o comprimento da própria coluna). Se você deseja aplicar lena cada elemento da coluna, use df['column name'].map(len). Então tente

df[df['column name'].map(len) < 2]

Para responder diretamente ao título original desta pergunta "Como excluir linhas de um DataFrame do pandas com base em uma expressão condicional" (que eu entendo não é necessariamente o problema do OP, mas pode ajudar outros usuários a encontrar essa pergunta), uma maneira de fazer isso é usar o método drop :

df = df.drop(some labels)

df = df.drop(df[<some boolean condition>].index)

Exemplo

Para remover todas as linhas em que a coluna 'score' é <50:

df = df.drop(df[df.score < 50].index)

Versão no local (conforme indicado nos comentários)

df.drop(df[df.score < 50].index, inplace=True)

Várias condições

(consulte Indexação booleana )

Os operadores são: |para or, &para ande ~para not. Estes devem ser agrupados usando parênteses.

Para remover todas as linhas em que a coluna 'score' é <50 e> 20

df = df.drop(df[(df.score < 50) & (df.score > 20)].index)

Você pode atribuir a DataFrameuma versão filtrada de si mesma:

df = df[df.score > 50]

Isso é mais rápido que drop:

%%timeit
test = pd.DataFrame({'x': np.random.randn(int(1e6))})
test = test[test.x < 0]
# 54.5 ms ± 2.02 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

%%timeit
test = pd.DataFrame({'x': np.random.randn(int(1e6))})
test.drop(test[test.x > 0].index, inplace=True)
# 201 ms ± 17.9 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

%%timeit
test = pd.DataFrame({'x': np.random.randn(int(1e6))})
test = test.drop(test[test.x > 0].index)
# 194 ms ± 7.03 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

Expandirei a solução genérica do @ User para fornecer uma dropalternativa gratuita. Isto é para pessoas direcionadas aqui com base no título da pergunta (não no problema do OP)

Digamos que você queira excluir todas as linhas com valores negativos. Uma solução de revestimento é: -

df = df[(df > 0).all(axis=1)]

Explicação passo a passo: -

Vamos gerar um quadro de dados de distribuição normal aleatória 5x5

np.random.seed(0)
df = pd.DataFrame(np.random.randn(5,5), columns=list('ABCDE'))
      A         B         C         D         E
0  1.764052  0.400157  0.978738  2.240893  1.867558
1 -0.977278  0.950088 -0.151357 -0.103219  0.410599
2  0.144044  1.454274  0.761038  0.121675  0.443863
3  0.333674  1.494079 -0.205158  0.313068 -0.854096
4 -2.552990  0.653619  0.864436 -0.742165  2.269755

Deixe a condição excluir negativos. Um DF booleano que satisfaça a condição: -

df > 0
      A     B      C      D      E
0   True  True   True   True   True
1  False  True  False  False   True
2   True  True   True   True   True
3   True  True  False   True  False
4  False  True   True  False   True

Uma série booleana para todas as linhas que satisfazem a condição Observe que, se algum elemento da linha falhar, a condição é marcada como falsa

(df > 0).all(axis=1)
0     True
1    False
2     True
3    False
4    False
dtype: bool

Por fim, filtre as linhas do quadro de dados com base na condição

df[(df > 0).all(axis=1)]
      A         B         C         D         E
0  1.764052  0.400157  0.978738  2.240893  1.867558
2  0.144044  1.454274  0.761038  0.121675  0.443863

Você pode atribuí-lo novamente ao df para realmente excluir vs filtragem feita acima
df = df[(df > 0).all(axis=1)]

Isso pode ser facilmente estendido para filtrar linhas contendo NaN s (entradas não numéricas): -
df = df[(~df.isnull()).all(axis=1)]

Isso também pode ser simplificado para casos como: Exclua todas as linhas em que a coluna E é negativa

df = df[(df.E>0)]

Gostaria de terminar com algumas estatísticas de criação de perfil sobre por que a dropsolução do @ User é mais lenta que a filtragem baseada em coluna bruta: -

%timeit df_new = df[(df.E>0)]
345 µs ± 10.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%timeit dft.drop(dft[dft.E < 0].index, inplace=True)
890 µs ± 94.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Uma coluna é basicamente uma matriz, Seriesou seja NumPy, pode ser indexada sem nenhum custo. Para as pessoas interessadas em como a organização da memória subjacente atua na velocidade de execução, aqui está um ótimo link para acelerar o Pandas :

Nos pandas, você pode fazer o str.lenseu limite e usar o resultado booleano para filtrá-lo.

df[df['column name'].str.len().lt(2)]

Se você deseja descartar linhas do quadro de dados com base em alguma condição complicada no valor da coluna, escrever isso da maneira mostrada acima pode ser complicado. Eu tenho a seguinte solução mais simples que sempre funciona. Vamos supor que você queira soltar a coluna com 'cabeçalho', para que essa coluna seja listada primeiro.

text_data = df['name'].tolist()

Agora aplique alguma função em todos os elementos da lista e coloque-a em uma série de panda:

text_length = pd.Series([func(t) for t in text_data])

no meu caso, eu estava apenas tentando obter o número de tokens:

text_length = pd.Series([len(t.split()) for t in text_data])

agora adicione uma coluna extra com a série acima no quadro de dados:

df = df.assign(text_length = text_length .values)

agora podemos aplicar a condição na nova coluna, como:

df = df[df.text_length  >  10]

def pass_filter(df, label, length, pass_type):

    text_data = df[label].tolist()

    text_length = pd.Series([len(t.split()) for t in text_data])

    df = df.assign(text_length = text_length .values)

    if pass_type == 'high':
        df = df[df.text_length  >  length]

    if pass_type == 'low':
        df = df[df.text_length  <  length]

    df = df.drop(columns=['text_length'])

    return df