Operación de texto pandas learning-taskTwo

1. Operaciones de texto habituales

Personalmente, creo que hay tres tipos de operaciones de texto, coincidencia y sustitución, extracción coincidente, separación y empalme. Analicemos a su vez.

1.1 Reemplazo de texto

Esto se refiere al proceso de reemplazar el contenido de un patrón determinado de una cadena con un contenido específico. Por ejemplo, reemplace la letra con el número ※. Al realizar reemplazos, debe tener cierta comprensión de las expresiones regulares de Python.

• Definición: La expresión regular es una secuencia especial de caracteres que puede ayudarlo a verificar fácilmente si una cadena coincide con un patrón determinado. Python ha agregado el módulo re desde la versión 1.5, que proporciona patrones de expresión regular al estilo de Perl. El módulo re hace que el lenguaje Python tenga todas las funciones de expresión regular.

Las expresiones regulares están representadas por una cadena de cadenas y las cadenas coinciden en forma de una combinación de coincidencia exacta y coincidencia aproximada. La coincidencia exacta se expresa mediante las letras que se van a emparejar, como 'py', y las expresiones difusas se expresan mediante el carácter de escape '\' más letras y otros símbolos. Los símbolos de coincidencia difusa habituales son los siguientes:

\ w	Coincidir números y letras subrayado
\ W	Coincidir con el subrayado de letras no numéricas
\ s	Coincide con cualquier carácter en blanco, equivalente a [\ t \ n \ r \ f].
\ S	Coincide con cualquier carácter que no esté en blanco
\re	Coincide con cualquier número, equivalente a [0-9].
\RE	Coincidir con cualquier no dígito
\UN	Inicio de la cadena de coincidencia
\CON	La cadena coincidente finaliza. Si hay una nueva línea, solo la cadena final antes de la nueva línea coincide.
\con	Fin de la cadena de coincidencia
\GRAMO	Coincide con la posición donde se completó el último partido.
\segundo	Haga coincidir el límite de una palabra, es decir, la posición entre la palabra y el espacio. Por ejemplo, 'er \ b' puede coincidir con el 'er' en "nunca" pero no el 'er' en "verbo"
\SEGUNDO	Coincidir con los límites que no son palabras. 'er \ B' puede coincidir con el'er 'en "verbo" pero no el'er' en "nunca".
\ n, \ t, etc.	Coincide con un carácter de nueva línea. Coincide con un carácter de tabulación, etc.

Bueno, aquí hay algunos métodos comunes:

1. Uso común de str.replace

s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca','', np.nan, 
'CABA', 'dog', 'cat'],dtype="string")
0       A
1       B
2       C
3    Aaba
4    Baca
5        
6    <NA>
7    CABA
8     dog
9     cat
dtype: string
#使用***替换A或B,从头开始匹配
s.str.replace(r'^[AB]','***')
0       ***
1       ***
2         C
3    ***aba
4    ***aca
5          
6      <NA>
7      CABA
8       dog
9       cat
dtype: string

Explicación detallada de los parámetros:
s.str.replace (pat, repl, n = -1, case = None, flags = 0, regex = True)

palmadita	Reglas coincidentes, generalmente expresiones regulares (el módulo re aquí no necesita ser importado)
responder	Contenido de reemplazo, puede ser expresión lambda
norte	Tiempos de reemplazo, el valor predeterminado es -1, lo que significa que se reemplaza todo el contenido coincidente
caso	Determine si el reemplazo distingue entre mayúsculas y minúsculas (si es True, distingue entre mayúsculas y minúsculas, en este momento "pat" es una cadena, no una expresión regular, False no distingue entre mayúsculas y minúsculas, pero si pates una expresión regular compilada, no se puede establecer. )
banderas	Indicadores de módulo de expresión regular, como IGNORECASE. Si patestá compilado, no puede establecer una expresión regular. (Generalmente no me importa)
regex	bool, el valor predeterminado es Verdadero para determinar si se asume que el patrón entrante es una expresión regular: -Si es Verdadero, se asume que el patrón entrante es una expresión regular. -Si es False, trate el patrón como una cadena literal

Reemplace f. Con ba, la cadena generalmente representa una coincidencia exacta.

>>> pd.Series(['f.o', 'fuz', np.nan]).str.replace('f.', 'ba', regex=False)
0    bao
1    fuz
2    NaN
dtype: object

str.replace 与 reemplazar

En primer lugar, debe quedar claro que str.replace y replace no son lo mismo:

• str.replace es para el tipo de objeto o el tipo de cadena, y la operación predeterminada son las expresiones regulares. Actualmente, no es compatible con DataFrame.
• Reemplazar es para cualquier tipo de secuencia o marco de datos. Si desea reemplazar con una expresión regular, debe establecer regex = True. Este método admite el reemplazo de varias columnas a través de un diccionario. Pero ahora, debido a la introducción inicial del tipo de cadena, ha habido algunos problemas de uso que se espera que se solucionen en versiones futuras.

Otras consideraciones
(a) El parámetro de asignación str.replace no debe ser pd.NA.
Esto suena muy irrazonable. Por ejemplo, reemplazar una cadena que cumple con ciertas condiciones regulares con un valor faltante y cambiarlo directamente a un valor faltante causará un error en la versión actual

In [28]:
#pd.Series(['A','B'],dtype='string').str.replace(r'[A]',pd.NA) #报错
#pd.Series(['A','B'],dtype='O').str.replace(r'[A]',pd.NA) #报错
此时，可以先转为object类型再转换回来，曲线救国：
In [29]:
pd.Series(['A','B'],dtype='string').astype('O').replace(r'[A]',pd.NA,regex=True).astype('string')
Out[29]:
0    <NA>
1       B
dtype: string

(B) Para el tipo de cadena Series, las expresiones regulares no se pueden usar cuando se usa la función de reemplazo.
Este error aún no se ha corregido.

In [30]:
pd.Series(['A','B'],dtype='string').replace(r'[A]','C',regex=True)
Out[30]:
0    A
1    B
dtype: string
In [31]:
pd.Series(['A','B'],dtype='O').replace(r'[A]','C',regex=True)
Out[31]:
0    C
1    B
dtype: object

(C) Si faltan valores en las secuencias de tipo de cadena, no se puede usar reemplazar

In [32]:
#pd.Series(['A',np.nan],dtype='string').replace('A','B') #报错
In [33]:
pd.Series(['A',np.nan],dtype='string').str.replace('A','B')
Out[33]:
0       B
1    <NA>
dtype: string

En resumen, a menos que el valor de reemplazo sea un valor nulo, use str.replace para reemplazarlo.

1.2 Extracción específica de cuerdas

• （A） str.extract 方法
  pd.Series.str.extract (pat, flags = 0, expand = True)

ejemplo:

pd.Series(['10-87', '10-88', '10-89'],
dtype="string").str.extract(r'([\d]{2})-([\d]{2})')
Out[34]:
	0	1
0	10	87
1	10	88
2	10	89

Esto significa que los dos primeros números se extraen como un grupo y los dos últimos números son otro grupo. Aquí debe prestar atención al concepto de agrupación en expresiones regulares. En términos generales, la parte entre paréntesis es un solo grupo.
Parámetros detallados:

parámetro	efecto
palmadita	Patrón de expresión regular con grupos de captura. (Expresión regular con agrupación)
banderas	int, default 0 (sin banderas) es una declaración de expresiones regulares, generalmente puede ignorarlas, como re.IGNORECASE
expandir	bool, predeterminado True, True indica si se debe devolver un DataFrame. Para un subgrupo de Series, si expand se establece en False, se devuelve la Serie, pero si el resultado es mayor que un subgrupo, el parámetro de expansión no es válido y se devuelven todos.

• (B) El método str.extractall es
  diferente de extract, que solo coincide con la primera expresión calificada. Extractall encontrará todas las cadenas calificadas y construirá un índice multinivel (incluso si solo se encuentra una)

s = pd.Series(["a1a2", "b1", "c1"], index=["A", "B", "C"],dtype="string")
two_groups = '(?P<letter>[a-z])(?P<digit>[0-9])'
s.str.extract(two_groups, expand=True)

	letter	digit
A	a	1
B	b	1
C	c	1

s.str.extractall(two_groups)

		letter	digit
	match		
A	0	a	1
1	a	2
B	0	b	1
C	0	c	1

Si desea verificar la coincidencia de la i-ésima capa, puede usar el método xs

s = pd.Series(["a1a2", "b1b2", "c1c2"], 
index=["A", "B", "C"],dtype="string")
s.str.extractall(two_groups).xs(1,level='match')
Out[48]:
letter	digit
A	a	2
B	b	2
C	c	2

1.3 Segmentación y empalme

1. El método str.split
   (a) el corte del
   divisor y str Split:

In [6]:
s = pd.Series(['a_b_c', 'c_d_e', np.nan, 'f_g_h'], dtype="string")
s
Out[6]:
0    a_b_c
1    c_d_e
2     <NA>
3    f_g_h
dtype: string
根据某一个元素分割，默认为空格

• Tenga en cuenta aquí que el tipo después de la división es objeto, porque ahora los elementos de la serie no son cadenas, sino que incluyen listas, y el tipo de cadena solo puede contener cadenas.
  El método str se puede utilizar para seleccionar elementos. Si el elemento de celda es una lista, Entonces str [i] significa sacar el elemento i-ésimo. Si es un solo elemento, primero convierta el elemento en una lista y sáquelo.

In [8]:
s.str.split('_').str[1]
Out[8]:
0       b
1       d
2    <NA>
3       g
dtype: object
In [9]:
pd.Series(['a_b_c', ['a','b','c']], dtype="object").str[1]
#第一个元素先转为['a','_','b','_','c']
Out[9]:
0    _
1    b
dtype: object

(B) Otros parámetros
expanden el parámetro controla si dividir la columna, el parámetro n representa el número máximo de divisiones

s.str.split('_',expand=True)
0	1	2
0	a	b	c
1	c	d	e
2	<NA>	<NA>	<NA>
3	f	g	h

s.str.split('_',n=1)

0    [a, b_c]
1    [c, d_e]
2        <NA>
3    [f, g_h]
dtype: object

s.str.split('_',expand=True,n=1)
0	1
0	a	b_c
1	c	d_e
2	<NA>	<NA>
3	f	g_h

2. método str.cat
   (a) El modo de empalme de diferentes objetos. El
   método cat tiene diferentes efectos en diferentes objetos. Los objetos incluyen: columna única, columna doble y columnas múltiples.
   ① Para una sola Serie, significa que todos los elementos llevan caracteres. Fusionar en una cadena y una columna en una sola cadena.

s = pd.Series(['ab',None,'d'],dtype='string')
s

0      ab
1    <NA>
2       d
dtype: string

s.str.cat()

'abd'
#其中可选sep分隔符参数，和缺失值替代字符na_rep参数

s.str.cat(sep=',')

'ab,d'

s.str.cat(sep=',',na_rep='*')

'ab,*,d'

② Para la fusión de dos Series, los elementos del índice correspondiente se fusionan

In [17]:
s2 = pd.Series(['24',None,None],dtype='string')
s2
Out[17]:
0      24
1    <NA>
2    <NA>
dtype: string
In [18]:
s.str.cat(s2)
Out[18]:
0    ab24
1    <NA>
2    <NA>
dtype: string
同样也有相应参数，需要注意的是两个缺失值会被同时替换
In [19]:
s.str.cat(s2,sep=',',na_rep='*')
Out[19]:
0    ab,24
1      *,*
2      d,*
dtype: string

③ El empalme de varias columnas se puede dividir en empalme de mesa y empalme de varias series

表的拼接
In [20]:
s.str.cat(pd.DataFrame({
    
    0:['1','3','5'],1:['5','b',None]},dtype='string'),na_rep='*')
Out[20]:
0    ab15
1     *3b
2     d5*
dtype: string

Costura de varias series

s.str.cat([s+'0',s*2])

0    abab0abab
1         <NA>
2        dd0dd
dtype: string

(B) Alineación del índice en cat En la
versión actual, si los dos índices fusionados no son iguales y no se especifica el parámetro de unión, el valor predeterminado es left join, set join = 'left'

In [22]:
s2 = pd.Series(list('abc'),index=[1,2,3],dtype='string')
s2
Out[22]:
1    a
2    b
3    c
dtype: string
In [23]:
s.str.cat(s2,na_rep='*')
Out[23]:
0    ab*
1     *a
2     db
dtype: string

referencia

1.pandas alegres