Site is under maintenance mode. Please wait few min!
Saltar al contenido

Una introducción al trabajo con cuerdas en Python 3

marzo 4, 2020

 cuerdas

Introducción

Rubí tienen muchos métodos incorporados que hacen que sea fácil de modificar y manipular texto, una tarea común en muchos programas.

En este tutorial, vamos a usar métodos de string para determinar la longitud de una cadena, índice y cuerdas divididas para extraer subcadenas, añadir y eliminar espacios en blanco y otros caracteres, cambie el caso de caracteres en cadenas, y buscar y reemplazar texto. Cuando haya terminado, podrás incorporar estos métodos en sus propios programas.

La determinación de la longitud de cadena

El método de cadena de longitud devuelve el número de caracteres de una cadena. Este método es útil para cuando se necesita para hacer cumplir las longitudes mínima o máxima de contraseña, o truncar cadenas más grandes para estar dentro de ciertos límites para su uso como abreviaturas.

He aquí un ejemplo que imprime la longitud de una frase:

open_source = "Sammy contributes to open source."
print open_source.length
Output33

Tenga en cuenta que todos los personajes, incluyendo letras, números, espacios en blanco y símbolos, se contará, ya que es parte de la cadena. cheque

Para ver si una cadena está vacía, se puede comprobar para ver si su longitud es 0, o puede utilizar el vacío? Método: La mirada de

name = ""
name.empty? # true

name = "Sammy"
name.empty? # false

name = " "
name.empty? # false

Vamos a ver cómo a que las cadenas de índice y acceder a los contenidos de una cadena.

Acceso a los personajes dentro de una impresión de cadena

Para el trabajo o con algunos de los caracteres de una cadena, utilice el método de división para llegar a la parte desea. matrices

similares, en donde cada elemento corresponde a un número de índice, cada uno de los personajes de una cadena también se corresponden con un número de índice, empezando por el número de índice 0.

Para la cadena Sammy las miradas índice de degradación de este tipo:

La rebanada método le permite tomar un solo carácter o una serie de caracteres. El paso de un solo entero devuelve el carácter de ese índice. Paso de dos números enteros, separados por una coma, dice rebanada para regresar todos los caracteres de la primer índice al último índice, ambos inclusive. El método slice también acepta una amplia gama, tales como 1..4, para especificar los caracteres al extracto:

"Sammy".slice(0) # "s"
"Sammy".slice(1,2) # "am"
"Sammy".slice(1..4) # "ammy"

El [] sintaxis es un alias para el corte, por lo que puede tratar las series como matrices:

"Sammy"[0] # "s"
"Sammy"[1,2] # "am"
"Sammy"[1..4] # "ammy"

También puede acceder un único personaje de la final de la cadena con un índice negativo. -1 le permitirá acceder al último carácter de la cadena, -2 sería tener acceso a la segunda a la última, y ​​así sucesivamente.

Por último, se puede convertir la cadena en una matriz de caracteres con el método de caracteres:

"sammy".chars # ["S", "a", "m", "m", "y"]

Esto puede ser útil para manipular o transformar los caracteres de la cadena.

A continuación, Echemos un vistazo a cómo modificar el caso de los caracteres de una cadena.

la conversión a mayúsculas y minúsculas

El upcase y métodos downcase devuelva una cadena con todas las letras de una cadena original convierte en letras mayúsculas o minúsculas. Cualquier caracteres de la cadena que no son letras no serán cambiados. convertido de

Let la cadena Sammy tiburón para ser todo en mayúsculas:

name = "Sammy Shark"
print name.upcase
OuputSAMMY SHARK

Ahora, vamos a convertir la cadena a ser todo en minúsculas:

print name.downcase Ouputsammy shark

El upcase y funciones downcase hacen que sea más fácil de evaluar y comparar las cuerdas, haciendo caso consistente a lo largo. Por ejemplo, si usted pide un nombre de usuario y el usuario introduce el nombre de usuario con una letra mayúscula, puede minúsculas entrada del usuario y compararla con un valor conocido en minúsculas. cuerdas

Rubí también tienen un método que devuelve una nueva cadena con el primer carácter en mayúscula capitalizar:

"sammy".capitalize # "Sammy"

Este es un método conveniente, pero tenga cuidado de cómo lo usa; sólo en mayúscula la primera letra lo que no siempre podría ajustar en el caso de uso que necesita.

Rubí también proporciona un método swapcase que devuelve una cadena con la carcasa intercambiado:

text = "Sammy"
print text.swapcase
sAMMY

El downcase, upcase, métodos y captalize swapcase toda devuelve una nueva cadena y salir de la cadena existente sin alterar. Esto es importante tener en cuenta si está haciendo algo que no sea inmediatamente imprimir el texto. Echar un vistazo a la siguiente esxample:

text = "sammy"
text.capitalize

print "Hello, #{text}!" OutputHello, sammy!

A pesar de que llamamos a sacar provecho de la variable de texto, nunca capturado el valor devuelto por capitalizar. Habría que volver a escribir el programa como este:

text = "sammy"
text = text.capitalize

print "Hello, #{text}!" OutputHello, Sammy!

Puede utilizar downcase !, upcase !, provecho! y swapcase! para modificar la cadena original en su lugar:

text = "sammy"
text = text.capitalize!

print "Hello, #{text}!"

Tenga cuidado sin embargo. Hay desventajas a la mutación de la cadena original. Rubí ofrece dos métodos para que pueda elegir la que más se adapte a sus necesidades.

Ahora vamos a agregar y quitar los espacios en blanco de las cadenas.

Relleno y pelar Cuerdas

Si estás escribiendo un programa que tiene para dar formato a un texto, a menudo se encontrará que usted querrá añadir un poco de espacio delante de, después de, o alrededor de una cadena con el fin de hacer se alinea con otros datos. Y otras veces, es posible que desee eliminar los caracteres innecesarios desde el principio o el final de sus cuerdas, como espacios en blanco extra o caracteres especiales.

para rodear una cadena con espacios, utilice el método de centro:

"Sammy",center(21) # " Sammy "

Puede especificar una cadena como el segundo argumento si desea utilizar un carácter diferente:

" [Sammy] ".center(21, "<>") # "<><><> [Sammy] <><><>"

El ljust y métodos rjust añadir espacios o caracteres a la izquierda oa la derecha de una cadena y el trabajo exactamente igual que el método de centro:

"Sammy".ljust(20) # "Sammy "
"Sammy".rjust(20) # " Sammy"
"Sammy".rjust(20, "!") # "!!!!!!!!!!!!!!!Sammy"

Para quitar los espacios iniciales de una cadena, utilice el método rstrip. Para eliminar los espacios finales, el uso lstrip. Uso tira para extirpar ambos espacios iniciales y finales:

" Sammy".rstrip # "Sammy"
"Sammy ".lstrip # "Sammy"
" Sammy ".strip # "Sammy"

Puede utilizar el centro !, ljust !, rjust !, lstrip !, rstrip !, y tiras! métodos para modificar la cadena original.

A veces se tendrá que quitar caracteres desde el final de una cadena. Método chuleta de Ruby hace precisamente eso; se elimina el último carácter de una cadena:

"Sammy".chop # "Samm"

Esto es especialmente útil para eliminar el carácter de nueva línea ( n) a partir de cadenas:

"This string has a newlinen".chop

Las hojas método Picar la cadena original intacto, el retorno de una nueva cadena. ¡La chuleta! método modifica la cadena existente en el lugar.

El método Chomp puede eliminar varios caracteres desde el final de una cadena:

"Sammy".chomp("my") # "Sam"

Si no se especifica una cadena para eliminar, chomp eliminará el salto de línea:

"This string has a newlinen".chomp # "This string has a newline

Sin embargo, si la cadena no contiene un salto de línea carácter, chomp sólo devuelve la cadena original:

"Sammy".chomp # "Sammy"

Esto hace que masticar un poco más seguro para el uso al quitar saltos de línea que el método chuleta, que siempre elimina el último carácter.

Ruby tiene un mordisco! método que muta la cadena y devuelve la cadena modfied si se realiza un reemplazo originales. Sin embargo, a diferencia de chomp, chomp el! método devuelve nil si no alteró la cadena:

string = "Hellon"
string.chomp! # "Hello"

string = "Hello"
string.chomp! # nil

A continuación, Echemos un vistazo a cómo buscar texto en cadenas.

Finding Caracteres y texto

A veces es necesario determinar si una cadena contiene otra cadena. El

incluye? método comprueba si una cadena contiene otra cadena. Devuelve verdadero si existe la cuerda y falso si no:

"Sammy".include?("a") # true
"Sammy".include?("b") # false

El método del índice devuelve el índice de un carácter. También puede identificar el índice del primer carácter de una subcadena. Y devuelve nil si no existe el carácter o subcadena:

"Sammy".index("a") # 1
"Sammy".index("mm") # 2
"Sammy".index("Fish") # nil

El método del índice sólo se encuentra la primera ocurrencia sin embargo. He aquí un ejemplo con una cadena más larga:

text = "Sammy has a balloon"
text.index("a") # 1

La cadena Sammy tiene un globo tiene cuatro ocurrencias de la letra “a”. Pero el índice sólo se encuentra la primera ocurrencia. Vas a tener que escribir algo más específico para localizar una de las otras ocurrencias.

Por ejemplo, se podría convertir la cadena en un array de caracteres y métodos de uso de la matriz para recorrer los resultados y seleccionar los índices para el personaje. He aquí un método para hacer eso:

text = "Sammy has a balloon"
indices = text.chars
.each_with_index
.select{|char, index| char == "a" }
.map{|pair| pair.last}

print indices [1, 7, 10, 13]

each_with_index devuelve una matriz bidimensional que contiene la una entrada para cada carácter y su índice. seleccione Whittles se reduce a sólo las entradas donde el personaje es un mapa y convierte la matriz bidimensional en una matriz unidimensional de los índices.

Además de buscar caracteres de una cadena, se puede comprobar para ver si una cadena comienza con un carácter o subcadena utilizando el start_with? Método:

text = "Sammy has a balloon"
text.start_with?("s") # true
text.start_with?("Sammy has" # true

El start_with? método acepta múltiples cadenas y devuelve verdadero si alguno de ellos partido:

text = "Sammy has a balloon"
text.start_with?("Sammy the Shark", "Sammy") # true

En este ejemplo, “Sammy el Tiburón” no se encuentra, pero “Sammy” es, por lo que el valor de retorno es cierto.

Puede utilizar el end_with? Método para ver si termina una cadena con la subcadena dada. Funciona exactamente igual que start_with ?:

text = "Sammy has a balloon"
text.end_with?("balloon") # true
text.end_with?("boomerang") # false
text.end_with?("boomerang", "balloon") # true

Hemos visto maneras de encontrar el texto, por lo que vamos a ver cómo sustituir el texto con texto diferente.

Reemplazar texto en cadenas

La función Buscar y reemplazar en los procesadores de texto le permite buscar una cadena y sustituirla por otra cadena. Puede hacerlo en Ruby con los métodos y sub gsub.

El método sub reemplaza parte de una cadena con otra.

Sammy ya no tiene el globo; se fue volando. Vamos a cambio la subcadena «tiene» que «tenía».

balloon = "Sammy has a balloon"
print balloon.sub("has","had")

Nuestra producción se verá así:

OuputSammy had a balloon.

El método sub sólo reemplaza la primera ocurrencia del partido con el nuevo texto. Let uso de una cadena modificada que tiene dos apariciones de la palabra tiene:

balloon = "Sammy has a balloon. The balloon has a ribbon"
print balloon.sub("has","had")
OutputSammy had a balloon. The balloon has a ribbon

Sólo la primera ocurrencia cambió.

Para cambiar a todos ellos, utilice el método gsub, que realiza la sustitución mundial :

balloon = "Sammy has a balloon. The balloon has a ribbon"
print balloon.gsub("has","had")
OutputSammy had a balloon. The balloon had a ribbon

Los métodos y sub gsub siempre vuelven nuevas cadenas, dejando los originales sin modificar. Vamos a demostrar esto cambiando “globo” a “boomerang” en nuestra cadena:

text = "Sammy has a balloon"
text.gsub("ballooon", "boomerang")
print text
OutputSammy has a balloon

La salida no muestra el resultado que estamos buscando, porque si bien especificó la sustitución, nunca le asigna el resultado de gsub a una nueva variable. Para obtener el resultado que nos gustaría, podríamos reescribir el programa como este:

text = "Sammy has a balloon"
text = text.sub("ballooon", "boomerang")
print text

Alternativamente, se puede utilizar sub! en cambio, que modifica la cadena original. Probemos esto haciendo un par de reemplazo de cadena. Vamos a cambiar “globo rojo” a “boomerang azul”:

text = "Sammy has a red balloon"
text.sub!("red", "blue")
text.sub!("balloon", "boomerang")
print text
OutputSammy has a blue boomerang

Puede utilizar el gsub! método para hacer un cambio global en el lugar también.

Los sub gsub y métodos aceptan expresiones regulares para el patrón de búsqueda. Vamos a sustituir todas las vocales en la cadena con el símbolo @:

"Sammy has a red balloon".gsub /[aeiou]/, "@" "S@mmy h@s @ r@d b@ll@@n"

valor La sustitución no tiene que ser una cadena. Se puede utilizar un hash para especificar cómo se deben reemplazar los caracteres individuales o piezas. Vamos a sustituir todas las ocurrencias de la letra a con @ y todos los personajes o con ceros:

"Sammy has a red balloon".gsub /[aeiou]/, {"a" => "@", "o" => "0"}
# "S@mmy h@s @ rd b@ll00n"

Usted puede usar esto para realizar sustituciones más complejas con menos código.

Conclusión

En este tutorial, se trabajó con cuerdas y manipulados utilizando algunos de los métodos integrados para el tipo de datos de cadena. También ha aprendido que muchos de los métodos para trabajar con cadenas vienen en dos variantes: uno que se retira de la cadena sin cambios, y uno que modifica la cadena original. La que utilice depende de sus necesidades. Rubí le da la flexibilidad de elegir cómo desea trabajar con sus datos. Sin embargo, la escritura de código que no modifica los datos existentes puede ser más fácil de depurar más tarde.

Asegúrese de mirar a estos tutoriales relacionados para continuar explorando la forma de trabajar con datos en Ruby:

  • Cómo trabajar con cadenas en Ruby
  • cómo funcionan Para con matrices en Ruby
  • Conceptos de los tipos de datos en Ruby
  • Cómo para utilizar métodos de arreglos en Ruby