Python: cómo eliminar un carácter de una cadena

La forma más común de eliminar un carácter de una cadena en Python es con el método replace(). Exploraremos replace(), translate() y un enfoque manual personalizado para eliminar un carácter de una cadena.

Introducción

En esta guía, veremos cómo eliminar un carácter de una cadena en Python.

Las cadenas, y especialmente la entrada generada por el usuario, pueden contener caracteres no deseados, como caracteres especiales en un campo de nombre de usuario que no queremos almacenar. En esos casos, podríamos preferir eliminar caracteres específicos de una cadena determinada.

La forma más común de eliminar un carácter de una cadena es con el método replace(), pero también podemos utilizar el método translate() e incluso reemplazar una o más apariciones de un carácter dado.

Quitar carácter en Python usando replace()

La clase string proporciona un método replace(), que reemplaza un carácter por otro. Vale la pena señalar que su función devuelve una nueva cadena con los caracteres reemplazados, ya que las cadenas son inmutables. La cadena original permanece sin cambios, pero el objeto en la memoria se pierde a menos que mantengamos viva una referencia a él. Por lo general, asignará el valor devuelto al mismo puntero o a uno nuevo.

El método reemplaza todas las apariciones de un carácter, con uno nuevo. Por ejemplo, any_string.replace('a', 'b') reemplazará todas las apariciones de 'a' en any_string con el carácter 'b'. Para eliminar un carácter de una cadena a través de replace(), lo reemplazaremos con un carácter vacío:

1
2
3
4
original_string = "stack abuse"
# Removing character 'a' and replacing with an empty character
new_string = original_string.replace('a', '')
print("String after removing the character 'a':", new_string)

Una vez que ejecutamos este código, somos recibidos con:

1
String after removing the character 'a': stck buse

Quitar carácter en Python usando translate()

Las cadenas de Python tienen un método translate() que reemplaza los caracteres con otros caracteres especificados en una tabla de traducción.

Una tabla de traducción es solo un diccionario de asignaciones de clave-valor donde cada clave se reemplazará con un valor.

Para que este método funcione, tenemos que especificar el valor Unicode para las cadenas, que podemos obtener a través de la función ord().

Por ejemplo, any_string.ranslate({ord('a'):ord('z'), ord('b'):ord('y')}) reemplazará las ocurrencias de 'a' con 'z' y 'b' con 'y'.

Para eliminar un carácter de una cadena usando translate(), deberá mapear el valor Unicode del carácter con Ninguno en la tabla de traducción:

1
2
3
4
original_string = "stack abuse"
# removing character 'a'
new_string = original_string.translate({ord('a'): None})
print("String after removing the character 'a':", new_string)

Este código da como resultado:

1
String after removing the character 'a': stck buse

Quitar un Número de Ocurrencias de un Personaje

Los métodos replace() y translate() reemplazan todas las ocurrencias de un carácter dado con otro. Sin embargo, el método replace() toma un argumento opcional count. Si se da, solo reemplaza contar el número de ocurrencias del carácter dado.

Intentemos eliminar solo la primera 'a' de la cadena, en lugar de todas las ocurrencias:

1
2
3
4
original_string = "stack abuse"
# removing character 's'
new_string = original_string.replace('a',  '', 1)
print("String after removing the character 'a':", new_string)

La salida del código anterior se verá así:

1
String after removing the character 'a': stck abuse

Como el recuento se establece en 1, solo se reemplaza la primera aparición de 'a'; esto es útil cuando desea eliminar uno y solo un carácter.

Crear manualmente una nueva cadena sin carácter {#manualmente crear una nueva cadena sin carácter}

Una técnica algo esotérica, pero sencilla, sería crear una cadena vacía y recorrer la cadena original. En el bucle, escribiremos todos los caracteres en la nueva cadena, excepto el que se eliminará.

Esto es realmente lo que sucede debajo del capó, con alguna validación adicional. Dado que Python está implementado en C, podemos echar un vistazo al código fuente de stringobject.c, que define el replace(), que en última instancia llama a replace_single_character() o replace_single_character_in_place():

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
    start = self_s;
    end = self_s + self_len;
    while (count-- > 0) {
        next = findchar(start, end-start, from_c);
        if (next == NULL)
            break;

        if (next == start) {
            /* replace with the 'to' */
            Py_MEMCPY(result_s, to_s, to_len);
            result_s += to_len;
            start += 1;
        } else {
            /* copy the unchanged old then the 'to' */
            Py_MEMCPY(result_s, start, next-start);
            result_s += (next-start);
            Py_MEMCPY(result_s, to_s, to_len);
            result_s += to_len;
            start = next+1;
        }
    }
    /* Copy the remainder of the remaining string */
    Py_MEMCPY(result_s, start, end-start);

    return result;

Para apreciar cuánta lógica se abstrae detrás de las API simples, intuitivas y de alto nivel, podemos realizar este proceso manualmente:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
def remove_character(original_string, character, occurrence_num):
    new_string = ""
    for char in original_string:
        if char == character and occurrence_num > 0:
            occurrence_num = occurrence_num-1
            continue
        else:
            new_string += char
    return new_string                
                
                
string = 'stack abuse'
print(remove_character(string, 'a', 0))
print(remove_character(string, 'a', 1))
print(remove_character(string, 'a', 2))

El fragmento de código anterior producirá el siguiente resultado:

1
2
3
stack abuse
stck abuse
stck buse

Podemos ver: nuestro propio método funciona de la misma manera que lo hace el método replace(), pero es mucho menos eficiente:

1
2
3
4
5
print("Time taken by manual method: {}"
    .format(timeit.timeit("remove_character('stack abuse', 'a', 1)", "from __main__ import remove_character")))
    
print("Time taken by replace(): {}"
    .format(timeit.timeit("'stack abuse'.replace('a', '', 1)")))

La sincronización de estos métodos da como resultado:

1
2
Time taken by manual method: 1.3785062030074187
Time taken by replace(): 0.13279212499037385

Conclusión

En este tutorial, exploramos cómo podemos eliminar caracteres de una cadena en Python. Hemos visto cómo usar los métodos replace() y translate() para eliminar caracteres reemplazándolos con una cadena vacía o su Unicode con Ninguno.

Más tarde, hemos usado replace() para eliminar un número predefinido de ocurrencias del carácter dado, e incluso el viejo bucle for. El método translate() es útil si tenemos que eliminar un conjunto de caracteres, ya que podemos darle una tabla de traducción. Y el método replace() es útil si queremos eliminar un número de ocurrencias de un carácter dado. dado.

Licensed under CC BY-NC-SA 4.0