python - Cortar la columna Dataframe en función de la longitud de las cadenas

pandas

Question

Me gustaría eliminar los primeros 3 caracteres de las cadenas en una columna de Dataframe donde la longitud de la cadena es> 4

Si no, deberían seguir siendo los mismos.

P.ej

bloomberg_ticker_y

AIM9
DJEM9 # (should be M9)
FAM9
IXPM9 # (should be M9)

Puedo filtrar las cuerdas por longitud:

merged[''bloomberg_ticker_y''].str.len() > 4

y cortar las cuerdas:

merged[''bloomberg_ticker_y''].str[-2:]

Pero no estoy seguro de cómo poner esto junto y aplicarlo a mi marco de datos

Cualquier ayuda sería apreciada.

Answer 1

Otro enfoque es usar expresiones regulares:

df["bloomberg_ticker_y"].str.replace(r".{3,}(?=.{2}$)", "")
#0    AIM9
#1      M9
#2    FAM9
#3      M9

El patrón significa:

• .{3,} : combina 3 o más caracteres
• (?=.{2}$) : anticipación positiva de exactamente 2 caracteres seguidos del final de la cadena.

Answer 2

Puede usar numpy.where para aplicar una condición para seleccionar segmentos en función de la longitud de la cadena.

np.where(df[''bloomberg_ticker_y''].str.len() > 4, 
         df[''bloomberg_ticker_y''].str[3:], 
         df[''bloomberg_ticker_y''])
# array([''AIM9'', ''M9'', ''FAM9'', ''M9''], dtype=object)

df[''bloomberg_ticker_sliced''] = (
   np.where(df[''bloomberg_ticker_y''].str.len() > 4, 
            df[''bloomberg_ticker_y''].str[3:], 
            df[''bloomberg_ticker_y'']))
df
  bloomberg_ticker_y bloomberg_ticker_sliced
0               AIM9                    AIM9
1              DJEM9                      M9
2               FAM9                    FAM9
3              IXPM9                      M9

Si te apetece una solución basada en un map vectorizado, es

df[''bloomberg_ticker_y''].map(lambda x: x[3:] if len(x) > 4 else x)

0    AIM9
1      M9
2    FAM9
3      M9
Name: bloomberg_ticker_y, dtype: object

Answer 3

Puede utilizar una lista de comprensión:

df = pd.DataFrame({''bloomberg_ticker_y'' : [''AIM9'', ''DJEM9'', ''FAM9'', ''IXPM9'']})

df[''new''] = [x[-2:] if len(x)>4 else x for x in df[''bloomberg_ticker_y'']]

Salida:

  bloomberg_ticker_y   new
0               AIM9  AIM9
1              DJEM9    M9
2               FAM9  FAM9
3              IXPM9    M9

Answer 4

Puedes usar DataFrame.mask :

df[''bloomberg_ticker_y''] = (df.bloomberg_ticker_y.mask(
                                      df.bloomberg_ticker_y.str.len().gt(4), 
                                      other=df.bloomberg_ticker_y.str[-2:]))

       bloomberg_ticker_y
0               AIM9
1                 M9
2               FAM9
3                 M9

Answer 5

También puede utilizar DataFrame.apply :

import pandas as pd

df = pd.DataFrame({''bloomberg_ticker_y'' : [''AIM9'', ''DJEM9'', ''FAM9'', ''IXPM9'']})

df[''bloomberg_ticker_y''] = df.apply(lambda x: (x[''bloomberg_ticker_y''][3:] if len(x[''bloomberg_ticker_y'']) > 4 else x[''bloomberg_ticker_y'']) , axis=1)

Salida:

  bloomberg_ticker_y
0               AIM9
1                 M9
2               FAM9
3                 M9

Answer 6

Vio una gran variedad de respuestas, así que decidí compararlas en términos de velocidad:

# Create big size test dataframe
df = pd.DataFrame({''bloomberg_ticker_y'' : [''AIM9'', ''DJEM9'', ''FAM9'', ''IXPM9'']})
df = pd.concat([df]*100000)
df.shape

#Out
(400000, 1)

CS95 # 1 np.where

%%timeit 
np.where(df[''bloomberg_ticker_y''].str.len() > 4, 
         df[''bloomberg_ticker_y''].str[3:], 
         df[''bloomberg_ticker_y''])

Resultado:

163 ms ± 12.8 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

CS95 # 2 solución basada en map vectorizados

%%timeit 
df[''bloomberg_ticker_y''].map(lambda x: x[3:] if len(x) > 4 else x)

Resultado:

86 ms ± 7.31 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

Yatu DataFrame.mask

%%timeit
df.bloomberg_ticker_y.mask(df.bloomberg_ticker_y.str.len().gt(4), 
                           other=df.bloomberg_ticker_y.str[-2:])

Resultado:

187 ms ± 18.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Vlemaistre list comprehension

%%timeit
[x[-2:] if len(x)>4 else x for x in df[''bloomberg_ticker_y'']]

Resultado:

84.8 ms ± 4.85 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

pault str.replace con regex

%%timeit
df["bloomberg_ticker_y"].str.replace(r".{3,}(?=.{2}$)", "")

Resultado:

324 ms ± 17.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Cobra DataFrame.apply

%%timeit
df.apply(lambda x: (x[''bloomberg_ticker_y''][3:] if len(x[''bloomberg_ticker_y'']) > 4 else x[''bloomberg_ticker_y'']) , axis=1)

Resultado:

6.83 s ± 387 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Conclusión

• El método más rápido es la list comprehension seguida de cerca por una solución basada en map vectorizados.

• El método más lento es DataFrame.apply con diferencia (como se esperaba) seguido de str.replace con regex