Manipulación de Cadenas de Texto en Python

Algunos métodos para cadenas son:

.count() 
.capitalize()
.title() 
.swapcase() 
.replace(,) 
.split() 
.strip() 
.lstrip() 
.rstrip() 
.find()
.index() 
eval()	#Este y el siguiente son super métodos
exec()

Investiga y comenta para qué sirven, así ayudas a otros alumnos e interactúas en la comunidad, además investigar es parte fundamental de la programación, un programados pasa muchísimo tiempo investigando y aprendiendo nuevas tecnologías…

```js #Capitaliza la primera letra. texto = "hola mundo" print(texto.capitalize()) # "Hola mundo" #title() #Capitaliza la primera letra de cada palabra. texto = "hola mundo" print(texto.title()) # "Hola Mundo" #strip() #Elimina los espacios en blanco al inicio y al final. texto = " hola " print(texto.strip()) # "hola" #replace(old, new) #Reemplaza partes de la cadena. texto = "hola mundo" print(texto.replace("mundo", "Python")) # "hola Python" #split(sep) #Divide la cadena en una lista según el separador. texto = "hola,mundo,Python" print(texto.split(",")) # ['hola', 'mundo', 'Python'] #join(iterable) #Une elementos de un iterable en una sola cadena. lista = ["hola", "mundo"] print(" ".join(lista)) # "hola mundo" #find(sub) #Busca una subcadena y devuelve el índice de su primera aparición. texto = "hola mundo" print(texto.find("mundo")) # 5 #startswith(prefix) y endswith(suffix) #Verifica si la cadena empieza o termina con una subcadena. texto = "hola mundo" print(texto.startswith("hola")) # True print(texto.endswith("mundo")) # True #Ejemplo Completo: frase = " Bienvenido a Python! " frase = frase.strip().replace("Python", "el mundo de Python").upper() print(frase) # "BIENVENIDO A EL MUNDO DE PYTHON!" ```

Hola amigos, un tip para hacer las cosas mas rapido (VSCode, windows): Comentar / descomentar segmentos de codigo seleccionado: Ctrl+KC / Ctrl+KU Mantener apretado control y presionar secuencialmente K y C en un caso y K y luego U para descomentar. SALUDOS

Mientras vas realizando los ejercicios si desea agregar comentarios en el codigo para pueden usar el simbolo de numeral # ejemplo: print(name.strip()) # para eliminar espacio al principio y final. pd: coloque el comentario al lado pero puede ser en cualquier posicion !

**<u>Aquí les explico un poco qué es un método en Python.</u>** Un **método** en Python es una función que está asociada a un objeto específico y que puede realizar operaciones o manipulaciones sobre ese objeto. Los métodos se invocan usando la sintaxis `objeto.metodo()`, donde `objeto` es la instancia de una clase (por ejemplo, una cadena de texto) y `metodo()` es la función que se ejecuta sobre ese objeto. Por ejemplo, en `cadena.upper()`, `upper()` es un método que pertenece al objeto `cadena`, y su función es convertir el contenido de `cadena` a mayúsculas. Los métodos permiten manipular y trabajar con los datos contenidos en el objeto de manera más directa y conveniente. Estos son algunos métodos que se pueden usar para Strings o Cadenas de texto: `upper()`: Convierte todos los caracteres de la cadena en mayúsculas.* Ejemplo: `"hola".upper()` → `"HOLA"` * `lower()`: Convierte todos los caracteres de la cadena en minúsculas.* Ejemplo: `"HoLa".lower()` → `"hola"` * `capitalize()`: Convierte el primer carácter de la cadena en mayúscula y el resto en minúsculas.* Ejemplo: `"hOLA mUNDO".capitalize()` → `"Hola mundo"` * `title()`: Convierte el primer carácter de cada palabra en mayúscula.* Ejemplo: `"hola mundo".title()` → `"Hola Mundo"` * `strip()`: Elimina los espacios en blanco al principio y al final de la cadena.* Ejemplo: `" hola ".strip()` → `"hola"` * `lstrip()`: Elimina los espacios en blanco al principio de la cadena.* Ejemplo: `" hola".lstrip()` → `"hola"` * `rstrip()`: Elimina los espacios en blanco al final de la cadena.* Ejemplo: `"hola ".rstrip()` → `"hola"` * `replace(old, new)`: Reemplaza todas las ocurrencias de `old` por `new` en la cadena.* Ejemplo: `"hola mundo".replace("mundo", "Python")` → `"hola Python"` * `find(sub)`: Devuelve el índice de la primera aparición de `sub` en la cadena, o `-1` si no se encuentra.* Ejemplo: `"hola".find("o")` → `1` * `count(sub)`: Devuelve el número de veces que `sub` aparece en la cadena.* Ejemplo: `"hola mundo".count("o")` → `2` * `split(sep)`: Divide la cadena en una lista de subcadenas utilizando `sep` como delimitador.* Ejemplo: `"hola mundo".split(" ")` → `["hola", "mundo"]` * `join(iterable)`: Une los elementos de un iterable (como una lista) en una sola cadena, utilizando la cadena como separador.* Ejemplo: `" ".join(["hola", "mundo"])` → `"hola mundo"` * `startswith(prefix)`: Devuelve `True` si la cadena comienza con `prefix`.* Ejemplo: `"hola mundo".startswith("hola")` → `True` * `endswith(suffix)`: Devuelve `True` si la cadena termina con `suffix`.* Ejemplo: `"hola mundo".endswith("mundo")` → `True` * `isalpha()`: Devuelve `True` si todos los caracteres de la cadena son alfabéticos y la cadena no está vacía.* Ejemplo: `"hola".isalpha()` → `True` * `isdigit()`: Devuelve `True` si todos los caracteres de la cadena son dígitos y la cadena no está vacía.* Ejemplo: `"123".isdigit()` → `True` * `isalnum()`: Devuelve `True` si todos los caracteres de la cadena son alfanuméricos (letras o números) y la cadena no está vacía.* Ejemplo: `"hola123".isalnum()` → `True` * `isspace()`: Devuelve `True` si todos los caracteres de la cadena son espacios en blanco y la cadena no está vacía.* Ejemplo: `" ".isspace()` → `True` * `swapcase()`: Convierte las mayúsculas en minúsculas y viceversa.* Ejemplo: `"HoLa".swapcase()` → `"hOlA"` * `zfill(width)`: Rellena la cadena con ceros a la izquierda hasta alcanzar el ancho especificado.* Ejemplo: `"42".zfill(5)` → `"00042"` Espero que les ayude 😁

Indexación En Python, Se puede acceder a una cadena o una secuencia de caracteres mediante un índice, el primer índice inicia con el número 0 incrementándose hasta llegar al final de la cadena de texto y nos daría acceso a los caracteres de izquierda a derecha. De la misma forma se puede acceder a los caracteres de derecha a izquierda (de adelante hacia atrás) con índices en negativo comenzando con el -1  ```python text = "Python" print(text[0]) # Salida 'P' print(text[-1]) # Salida 'n' ```

Felicito al equipo de PLATZI, porque siento que este CURSO DE PYTHON está muy bien producido.

Una lista de los métodos más utilizados para cadenas (strings) en Python: `lower(): Convierte la cadena a minúsculas.` `upper(): Convierte la cadena a mayúsculas.` `strip(): Elimina espacios en blanco al inicio y al final.` `split(): Divide la cadena en una lista de subcadenas.` `join(): Une una lista de cadenas en una sola cadena.` `replace(): Reemplaza una subcadena por otra.` `startswith(): Verifica si la cadena comienza con una subcadena específica.` `endswith(): Verifica si la cadena termina con una subcadena específica.` `find(): Busca una subcadena y devuelve su posición.` `count(): Cuenta las ocurrencias de una subcadena.` `isalpha(): Verifica si todos los caracteres son alfabéticos.` `isdigit(): Verifica si todos los caracteres son dígitos.` `capitalize(): Convierte el primer carácter a mayúscula.` `title(): Convierte la primera letra de cada palabra a mayúscula.` `format(): Formatea la cadena con valores especificados.`

Para concatenar con espacios, en vez de utilizar `+ ' ' +`, podemos usar `,`, p. ej: ```python name = 'Carla Marcela' last_name = 'Florida Roman' #print(name + ' ' + last_name) print(name, last_name) ```

✨✨✨TIP para windows ✨✨✨ Atajo de Teclado para Uso de emojis Tecla Win + tecla punto (.) Activa el SELECTOR DE EMOJIS de windows.

Conocer los métodos disponibles de un objeto, por ejemplo, el siguiente String: "hola" Si quieres ver los métodos que se le pueden aplicar escribe en la consola interactiva: **dir("hola")** Si tienes un archivo con extensión py puedes usar la instrucción: **print(dir("hola"))**

**Los docstrings en python.** Una aclaración, cuando se usa las triples comillas simples o triples comillas dobles: `''' Hola mundo'''` `""" Soy un docstring"""` A esto se le conoce como **Docstrings**, normalmente se usa al momento de documentar código (funciones, clases, módulos,...), para que este sea más limpio. Se puede llamar a un docstring a través de su método `__doc__` o de la función `help()` Aunque igualmente es valido si se quiere guardar más de una linea de texto.

**Analogía de la Indexación.** Imaginemos un estante lleno de libros. Cada libro tiene un número asignado que indica su posición en el estante: * **Índice positivo**: Contamos los libros desde izquierda a derecha, comenzando en 0. * **Índice negativo**: Contamos los libros pero esta vez desde la derecha a la izquierda, comenzando en -1. Si queremos el **segundo libro** del estante, usamos entonces `estante[1]`. Si necesitamos el **último libro**, entonces `estante[-1]`. Ahora si deseamos un grupo de libros, podemos decir: "Dame los libros del 2 al 4" con `estante[1:4]`.

En la parte de len, dice Python que son 13 espacios en la cadena "Carla Marcela" yo contaba 12 considerando que los index se empiezan en 0 pero al parecer cuando se cuentan no, si empiezan en 1

Si un string contiene comillas del mismo tipo, utiliza el otro tipo de comillas. Por ejemplo: `mensaje = "Ella dijo: 'Hola'"` Esto se recomienda y aclara incluso en el PEP8(Guía oficial de código en Python)


Debido a unos requerimientos me ha tocado trabajar con python estos últimos meses, me di a la tarea de comenzar con este curso para tener bases más solidas y estoy descubriendo cosas que desconocía, excelente curso y la profesora explica muy bien

por que me da errror? name = "Emerson" last\_name = "godoy" print(name) print(name + " " + last\_name) ![]()

Todo es nuevo para mi pero por fín estoy en estas

Un poco de lo que aprendi en la clase 

El método `strip()` es muy útil cuando trabajas con entradas de usuario, archivos de texto, o cualquier tipo de dato donde puedas tener caracteres indeseados en los bordes.

```python print(fullname.lower()) #Cambia todas las letras del texto a minuscula print(fullname.upper()) #Cambia todas las letras del texto a mayuscula print(fullname.strip()) #Elimina el espacio en blanco antes y despues del texto print(fullname.capitalize()) #Convierte el primer carácter de una cadena a mayúscula y el resto de los caracteres a minúscula. print(fullname.find("Rodriguez")) #Busca una subcadena dentro de otra cadena y te muestra el indice donde comienza la palabra (El índice se refiere a la posición de un carácter) print(fullname.index("Rodriguez")) #Lo mismo que .find con la diferencia que cuando encuentre un error no te regresa el valor -1 sino substring not found print(fullname.replace("Rodriguez", "Esparza")) #Remplaza todas las ocurrencias de una subcadena con otra print(fullname.count("a")) #Devuelve el numero de veces que aparece una subcadena en la cadena o dejando el entreparentesis vacio simplente te arroaj la cantidad de indices ```Comparto mis apuntes si a alguien le es útil.

Para las iteraciones en un string podemos hacer uso del ciclo for ```python name = "Sara Mejia" # Imprimir cada uno de los caracteres for letter in name: print(letter) # Imprimir de cada uno de los caracteres de atrás hacia adelante for letter in name[::-1]: print(letter) ```

Me encanta com aborda los pequeños erros que se van presentando ❤️

Que gran curso voy en la clase 5 y me emociona ver la simplicidad con lo que explican todo

Aquí dejo cap de script con lo visto en la clase. 

Existen varios métodos para trabajar con cadenas de texto en Python. Algunos de los más utilizados son: 1. `lower()`: Convierte todos los caracteres de la cadena a minúsculas. 2. `upper()`: Convierte todos los caracteres de la cadena a mayúsculas. 3. `strip()`: Elimina los espacios en blanco al inicio y al final de la cadena. 4. `replace(old, new)`: Reemplaza todas las ocurrencias de una subcadena por otra. 5. `split(sep)`: Divide la cadena en una lista usando el separador especificado. 6. `join(iterable)`: Une elementos de un iterable en una cadena, usando la cadena en la que se llama como separador. Estos métodos permiten manipular y procesar cadenas de manera eficiente.

Mientras exploraba la manipulación de cadenas en Python, quise imprimir emojis y caracteres especiales como `🌎` directamente en la consola. Aunque Python admite estos caracteres gracias a su soporte nativo de Unicode, me encontré con el siguiente error al ejecutarlo en VS Code sobre Windows: `UnicodeEncodeError: 'charmap' codec can't encode character '\U0001f30e' in position 0: character maps to <undefined>` 🔍 Este error se debe a que en algunos sistemas Windows, la consola por defecto (CMD o la terminal integrada de VS Code) usa una codificación limitada llamada `charmap` (o `cp1252`), que **no puede representar muchos caracteres Unicode como emojis o letras de alfabetos no latinos**. 💡 **Solución aplicada:** Para forzar la salida de texto en formato `UTF-8` (que sí los soporta), agregué al inicio del script esta línea de código, y funcionó perfectamente: ```js import sys import io sys.stdout = io.TextIOWrapper(sys.stdout.detach(), encoding='utf-8') ``` 📝 **Nota aclaratoria:** Esta solución **reemplaza la salida estándar de texto (stdout)** con una versión que usa UTF-8 como codificación. De este modo, se puede imprimir cualquier carácter Unicode directamente en consola, sin errores. ```js # Emoji como parte de una cadena mensaje = "¡Hola mundo 🌎!" # Recorriendo la cadena por caracteres for caracter in mensaje: print(caracter) # Codificando en bytes UTF-8 (útil para almacenamiento o APIs) bytes_emoji = "🌎".encode("utf-8") print("Representación en bytes:", bytes_emoji) print("Tamaño en bytes:", len(bytes_emoji)) # Decodificando de vuelta a string original = bytes_emoji.decode("utf-8") print("Emoji recuperado:", original) ``` ✅ Esta práctica resulta especialmente útil en proyectos donde se usan emojis, nombres internacionales o análisis de texto avanzado, como en chatbots, procesamiento de lenguaje natural o visualización de resultados enriquecidos.

Como aportación extra, también se pueden usar las triples comillas dobles `"""string"""`, de igual manera que las triples comillas simples `'''string'''` vistas en la clase. Ambas nos permiten hacer saltos de línea.

El método `rstrip()` es un método de cadena (string) en Python que elimina los espacios en blanco al final (derecha) de la cadena. En tu código específico, si ejecutas: print(direccion) # Imprime: " calle 123 " print(direccion.rstrip()) # Imprime: " calle 123" Puedes ver que: 1. La cadena original `direccion` tiene espacios tanto al inicio como al final 2. `rstrip()` solo elimina los espacios del lado derecho (final) de la cadena 3. Los espacios del lado izquierdo se mantienen intactos Es similar a los otros métodos de limpieza de espacios que estás usando en tu código: * `strip()`: elimina espacios tanto al inicio como al final * `lstrip()`: elimina espacios solo al inicio (lado izquierdo) * `rstrip()`: elimina espacios solo al final (lado derecho) Este método es muy útil cuando necesitas limpiar datos de entrada donde los espacios al final no son significativos pero quieres mantener los espacios al inicio.

El método `strip()` es un método de cadena (string) en Python que elimina los espacios en blanco tanto al inicio como al final de la cadena. En tu código específico, si ejecutas: ```python print(direccion) # Imprime: " calle 123 " print(direccion.strip()) # Imprime: "calle 123" ``` Puedes ver que: 1\. La cadena original `direccion` tiene espacios tanto al inicio como al final 2\. `strip()` elimina todos los espacios en blanco de ambos extremos 3\. El resultado es una cadena limpia sin espacios al inicio ni al final Este método es muy útil cuando necesitas limpiar datos de entrada donde los espacios al inicio y al final no son significativos. Es uno de los métodos más comunes para limpiar cadenas de texto en Python. Es importante notar que `strip()` solo elimina los espacios en blanco, no afecta a los espacios que están entre palabras.

Muy interesante conocer los tipos de cadenas y como manipularlas. ademas de usar las funciones `lower()`, `upper()` y `strip()`, así como la función `len()` para obtener la longitud de las cadenas. Practico para los inicios en el uso de Python!

Los métodos de string que permiten manipular, analizar y modificar texto. Agrupados por categoría serían: 1\) Métodos para manipular strings: * upper(): convierte todo a mayúsculas```python texto = "hola mundo" print(texto.upper()) # "HOLA MUNDO" ``` * lower(): convierte todo a minúsculas```python texto = "Hola Mundo" print(texto.lower()) # "hola mundo" ``` * capitalize(): convierte el primer caracter del string en mayúscula```python texto = "python es genial" print(texto.capitalize()) # "Python es genial" ``` * title(): convierte la primera letra de cada palabra en mayúscula```python texto = "python es genial" print(texto.title()) # "Python Es Genial" ``` * swapcase(): convierte de mayúsculas a minúscula y viceversa```python texto = "Hola Mundo" print(texto.swapcase()) # "hOLA mUNDO" ``` 2\) Métodos para buscar y reemplazar * find(): retorna la posicion de una subcadena, o -1 si no la encuentra```python texto = "Hola mundo" print(texto.find("mundo")) # 5 print(texto.find("Python")) # -1 (no encontrado) ``` * index() retorna la posición de una subcadena, y produce error sin no la encuentra```python texto = "Hola mundo" print(texto.index("mundo")) # 5 print(texto.index("Python")) # ❌ ValueError si no se encuentra ``` * replace(): reemplaza una subcadena por otra```python texto = "Hola mundo" print(texto.replace("mundo", "Python")) # "Hola Python" ``` 3\) Métodos para verificación: Verifica si cumple con una condición, retorna **true** si cumple con la condición y **false** si no cumple * startswith(): empieza con una subcadena en específico```python texto = "Hola mundo" print(texto.startswith("Hola")) # True print(texto.startswith("Mundo")) # False ``` * endswith(): termina con una subcadena es específico```python texto = "Hola mundo" print(texto.endswith("mundo")) # True print(texto.endswith("Hola")) # False ``` * isalpha(): verifica si son solo letras```python texto1 = "Python" texto2 = "Python3" print(texto1.isalpha()) # True print(texto2.isalpha()) # False (porque tiene un número) ``` * isdidgt(): verifica si son solo números```python numero = "12345" print(numero.isdigit()) # True texto = "123abc" print(texto.isdigit()) # False ``` * isalnum(): verifica si es alfanumérico ```python print("Python123".isalnum()) # True print("Python 123".isalnum()) # False (espacio no es alfanumérico) ``` * isspace(): verifica si es solo espacios```python print(" ".isspace()) # True print("Hola Mundo".isspace()) # False ``` 4\) Métodos para manipular espacios * strip(): elimina espacios al inicio y al final```python texto = " Hola mundo " print(texto.strip()) # "Hola mundo" ``` * lstrip(): elimina espacios al inicio```python texto = " Hola mundo " print(texto.lstrip()) # "Hola mundo " ``` * rstrip(): elimina espacios al final```python texto = " Hola mundo " print(texto.rstrip()) # " Hola mundo" ``` 5\) Métodos para unir y separar strings * split(): divide los caracteres por un caracter en especifico , y por defecto usa el caracter espacio```python texto = "Hola mundo Python" print(texto.split()) # ['Hola', 'mundo', 'Python'] frutas = "manzana,naranja,platano" print(frutas.split(",")) # ['manzana', 'naranja', 'platano'] ``` * join(): Une elementos de una lista en un string```python lista = ["Hola", "mundo", "Python"] print(" ".join(lista)) # "Hola mundo Python" ``` 6\) Métodos para alinear texto: * center(): centra el texto en un ancho definido```python print("Python".center(20, "-")) # "-------Python--------" ``` * ljust(): alinea a la izquierda con un ancho definido```python print("Python".ljust(10, "*")) # "Python****" ``` * rjust(): alinea a la derecha con un ancho definido```python print("Python".rjust(10, "*")) # "****Python" ``` 7\) Métodos para formatear strings * zfill(): rellena con ceros a la izquierda hasta alcanzar un ancho determinado```python numero = "42" print(numero.zfill(5)) # "00042" ``` * format(): formatea cadenas de acuerdo a una estructura determinada```python nombre = "Aarón" edad = 29 print("Mi nombre es {} y tengo {} años.".format(nombre, edad)) ``` * Se peude usar z-format desde python 3.6 que es similar al mátodo format()```python nombre = "Aarón" edad = 29 print(f"Mi nombre es {nombre} y tengo {edad} años.") ```

En Python, la indexación de cadenas comienza en 0 por motivos históricos y de diseño. Este enfoque, conocido como "indexación cero", permite que las computadoras accedan a la memoria de manera más eficiente, ya que las posiciones de los elementos en un arreglo coinciden directamente con sus direcciones de memoria. Por ejemplo, si tienes la cadena `"hola"`, los índices son: - `h` es 0 - `o` es 1 - `l` es 2 - `a` es 3 Esto se ajusta a la forma en que se manejan los datos a nivel de hardware, donde la posición 0 representa el primer elemento. Este patrón es común en muchos lenguajes de programación, como C y Java.

Interesante, con estás cuantas funciones pude ver varias cosas de python que hacen más simple que otros lenguajes.

No aparece donde estan los recursos

En Python, existen numerosos métodos para trabajar con cadenas de texto. 🤖Algunos de estos métodos son variaciones de otros, añaden funcionalidades específicas o permiten personalizar su comportamiento mediante parámetros. Dominar estos métodos no solo te ayudará a escribir código más eficiente, sino que también te permitirá resolver problemas de manera más rápida y elegante. Te recomiendo explorar la documentación oficial de Python para familiarizarte con todos los métodos disponibles en la clase `str`. En el futuro, este conocimiento te será de gran utilidad para simplificar y optimizar la creación de tus programas. <https://docs.python.org/es/3/library/stdtypes.html#string-methods> 

En Python, puedes usar comillas simples (`'`) o dobles (`"`) para escribir cadenas, y normalmente da igual cuál elijas. Pero aquí van algunos consejos prácticos: 1. **Si tu cadena tiene comillas simples dentro**, usa comillas dobles para que sea más fácil:

La clase se centra en la manipulación de cadenas de texto en Python. Se explican los tipos de datos string (cadenas) y cómo se pueden representar utilizando comillas simples, dobles y triples. Se menciona la indexación para acceder a caracteres específicos y se abordan operaciones como la concatenación y la repetición de cadenas. También se presentan métodos para manipular cadenas, como `lower()`, `upper()` y `strip()`, así como la función `len()` para obtener la longitud de las cadenas. Es esencial comprender estas operaciones para manejar texto eficazmente en Python.

La clase se centró en la manipulación de cadenas de texto en Python. Se abordaron las variables y sus tipos, específicamente el tipo string (STR). Se explicaron tres formas de representar cadenas: comillas dobles, simples y triples, destacando que las triples permiten saltos de línea. Se introdujo la indexación, permitiendo acceder a caracteres específicos usando posiciones. Se discutieron las operaciones de concatenación y repetición de cadenas, así como el uso de métodos para manipular cadenas, como `lower()`, `upper()` y `strip()`. Se enfatizó la importancia de las buenas prácticas en la escritura del código.

funciones: ``` len(str) ``` métodos: ``` str.lower() ```

``` name = 'Daniel' print(name\[0]) #D print(name\[-1]) #l ```

```js name = 'Daniel' print(name[0]) #D print(name[-1]) #l ```name = 'Daniel' print(name\[0])

\# Métodos comunes de cadenas en Python \# Contar ocurrencias de un substring en una cadena "hello world".count("o") # Devuelve 2 \# Capitaliza el primer carácter de la cadena y pone el resto en minúsculas "hello world".capitalize() # Devuelve 'Hello world' \# Pone en mayúsculas la primera letra de cada palabra "hello world".title() # Devuelve 'Hello World' \# Invierte mayúsculas y minúsculas "Hello World".swapcase() # Devuelve 'hELLO wORLD' \# Reemplaza un substring por otro "hello world".replace("o", "a") # Devuelve 'hella warld' \# Divide la cadena en una lista según un separador (por defecto, espacios) "hello world".split() # Devuelve \['hello', 'world'] \# Elimina espacios en blanco al inicio y al final de la cadena " hello world ".strip() # Devuelve 'hello world' \# Elimina espacios en blanco solo al inicio " hello world ".lstrip() # Devuelve 'hello world ' \# Elimina espacios en blanco solo al final " hello world ".rstrip() # Devuelve ' hello world' \# Busca un substring en la cadena y devuelve la primera posición (o -1 si no lo encuentra) "hello world".find("o") # Devuelve 4 \# Similar a find, pero lanza un error si no encuentra el substring "hello world".index("o") # Devuelve 4 \# Evalúa una expresión de Python desde una cadena (¡cuidado al usarlo!) eval("3 + 4") # Devuelve 7 \# Ejecuta código Python dinámicamente (¡cuidado al usarlo!) exec("x = 5\ny = 10\nprint(x + y)") # Imprime 15

### **Manipulación básica** 1. `upper()` Convierte todos los caracteres de la cadena a mayúsculas. Ejemplo: `"hola".upper()` → `'HOLA'` 2. `lower()` Convierte todos los caracteres de la cadena a minúsculas. Ejemplo: `"HOLA".lower()` → `'hola'` 3. `capitalize()` Convierte el primer carácter a mayúscula y el resto a minúsculas. Ejemplo: `"hola mundo".capitalize()` → `'Hola mundo'` 4. `title()` Convierte la primera letra de cada palabra a mayúscula. Ejemplo: `"hola mundo".title()` → `'Hola Mundo'` 5. `strip()` Elimina los espacios en blanco al principio y al final. Ejemplo: `" hola ".strip()` → `'hola'` 6. `replace(old, new)` Sustituye una subcadena por otra. Ejemplo: `"hola mundo".replace("mundo", "Python")` → `'hola Python'` **Búsqueda y comparación** 7. `find(sub)` Busca una subcadena y devuelve su índice inicial (o -1 si no se encuentra). Ejemplo: `"hola mundo".find("mundo")` → `5` **División y unión** 8. `split(sep)` Divide la cadena en una lista, usando el separador especificado. Ejemplo: `"hola mundo".split(" ")` → `['hola', 'mundo']` **Formato** 9. `format()` Inserta valores dentro de la cadena utilizando marcadores `{}`. Ejemplo: `"Hola, {}!".format("mundo")` → `'Hola, mundo!'` ¡Por supuesto! Aquí tienes una lista de los métodos comunes de cadenas en Python con una breve explicación de cada uno: ### **Manipulación básica** 1. `upper()` Convierte todos los caracteres de la cadena a mayúsculas. Ejemplo: `"hola".upper()` → `'HOLA'` 2. `lower()` Convierte todos los caracteres de la cadena a minúsculas. Ejemplo: `"HOLA".lower()` → `'hola'` 3. `capitalize()` Convierte el primer carácter a mayúscula y el resto a minúsculas. Ejemplo: `"hola mundo".capitalize()` → `'Hola mundo'` 4. `title()` Convierte la primera letra de cada palabra a mayúscula. Ejemplo: `"hola mundo".title()` → `'Hola Mundo'` 5. `strip()` Elimina los espacios en blanco al principio y al final. Ejemplo: `" hola ".strip()` → `'hola'` 6. `replace(old, new)` Sustituye una subcadena por otra. Ejemplo: `"hola mundo".replace("mundo", "Python")` → `'hola Python'` ### **Búsqueda y comparación** 1. `find(sub)` Busca una subcadena y devuelve su índice inicial (o -1 si no se encuentra). Ejemplo: `"hola mundo".find("mundo")` → `5` 2. `rfind(sub)` Busca una subcadena desde el final y devuelve su índice inicial. Ejemplo: `"hola mundo mundo".rfind("mundo")` → `11` 3. `startswith(prefix)` Verifica si la cadena empieza con una subcadena específica. Ejemplo: `"hola mundo".startswith("hola")` → `True` 4. `endswith(suffix)` Verifica si la cadena termina con una subcadena específica. Ejemplo: `"hola mundo".endswith("mundo")` → `True` ### **División y unión** 1. `split(sep)` Divide la cadena en una lista, usando el separador especificado. Ejemplo: `"hola mundo".split(" ")` → `['hola', 'mundo']` 2. `join(iterable)` Une elementos de un iterable en una cadena, usando la cadena actual como separador. Ejemplo: `"-".join(['hola', 'mundo'])` → `'hola-mundo'` ### **Formato** 1. `format()` Inserta valores dentro de la cadena utilizando marcadores `{}`. Ejemplo: `"Hola, {}!".format("mundo")` → `'Hola, mundo!'` 2. **F-strings** Inserta variables directamente en la cadena con un prefijo `f`. Ejemplo: `nombre = "mundo"; f"Hola, {nombre}!"` → `'Hola, mundo!'` ### **Validación** 1. `isalnum()` Verifica si la cadena contiene solo caracteres alfanuméricos (sin espacios). Ejemplo: `"Hola123".isalnum()` → `True` 2. `isalpha()` Verifica si la cadena contiene solo letras. Ejemplo: `"Hola".isalpha()` → `True` 3. `isdigit()` Verifica si la cadena contiene solo dígitos. Ejemplo: `"12345".isdigit()` → `True` 4. `isspace()` Verifica si la cadena contiene solo espacios en blanco. Ejemplo: `" ".isspace()` → `True` **Alineación** 5. `center(width)` Centra la cadena dentro de un ancho especificado, rellenando con espacios. Ejemplo: `"hola".center(10)` → `' hola '` **Alineación** 6. `center(width)` Centra la cadena dentro de un ancho especificado, rellenando con espacios. Ejemplo: `"hola".center(10)` → `' hola '` 7. `ljust(width)` Alinea la cadena a la izquierda dentro de un ancho especificado. Ejemplo: `"hola".ljust(10)` → `'hola '` 8. `rjust(width)` Alinea la cadena a la derecha dentro de un ancho especificado. Ejemplo: `"hola".rjust(10)` → `' hola'` 9. `ljust(width)` Alinea la cadena a la izquierda dentro de un ancho especificado. Ejemplo: `"hola".ljust(10)` → `'hola '` 10. `rjust(width)` Alinea la cadena a la derecha dentro de un ancho especificado. Ejemplo: `"hola".rjust(10)` → `' hola'` 1. **F-strings** Inserta variables directamente en la cadena con un prefijo `f`. Ejemplo: `nombre = "mundo"; f"Hola, {nombre}!"` → `'Hola, mundo!'` 2. `join(iterable)` Une elementos de un iterable en una cadena, usando la cadena actual como separador. Ejemplo: `"-".join(['hola', 'mundo'])` → `'hola-mundo'` 3. `endswith(suffix)` Verifica si la cadena termina con una subcadena específica. Ejemplo: `"hola mundo".endswith("mundo")` → `True` 4. `startswith(prefix)` Verifica si la cadena empieza con una subcadena específica. Ejemplo: `"hola mundo".startswith("hola")` → `True` 5. `rfind(sub)` Busca una subcadena desde el final y devuelve su índice inicial. Ejemplo: `"hola mundo mundo".rfind("mundo")` → `11`

En Python, al usar comillas dobles (`"`) o simples (`'`) para definir cadenas de texto, estas no permiten incluir saltos de línea directamente. Por ejemplo, si defines una cadena así: ```python cadena = 'Hola\nMundo' ``` El `\n` es un carácter de escape que indica un salto de línea. Sin embargo, si usas comillas triples (`"""` o `'''`), puedes escribir cadenas que incluyan saltos de línea sin necesidad de usar el carácter de escape. Así, ambas comillas simples y dobles son útiles para cadenas de texto simples, mientras que las triples son ideales para texto multilínea.

`igual se pude usar f` en `print()` te permite formatear cadenas fácilmente y de manera eficiente, integrando variables o expresiones directamente en la salida del texto. ejemplo: `name="DIEGO"` `last_name="Hernandez"` `print(f "Mi nombre es{name} {last_name"})`

* [`capitalize()`](https://docs.python.org/es/3/library/stdtypes.html#str.capitalize) * [`casefold()`](https://docs.python.org/es/3/library/stdtypes.html#str.casefold) * [`center()`](https://docs.python.org/es/3/library/stdtypes.html#str.center) * [`count()`](https://docs.python.org/es/3/library/stdtypes.html#str.count) * [`encode()`](https://docs.python.org/es/3/library/stdtypes.html#str.encode) * [`endswith()`](https://docs.python.org/es/3/library/stdtypes.html#str.endswith) * [`expandtabs()`](https://docs.python.org/es/3/library/stdtypes.html#str.expandtabs) * [`find()`](https://docs.python.org/es/3/library/stdtypes.html#str.find) * [`format()`](https://docs.python.org/es/3/library/stdtypes.html#str.format) * [`format_map()`](https://docs.python.org/es/3/library/stdtypes.html#str.format_map) * [`index()`](https://docs.python.org/es/3/library/stdtypes.html#str.index) * [`isalnum()`](https://docs.python.org/es/3/library/stdtypes.html#str.isalnum) * [`isalpha()`](https://docs.python.org/es/3/library/stdtypes.html#str.isalpha) * [`isascii()`](https://docs.python.org/es/3/library/stdtypes.html#str.isascii) * [`isdecimal()`](https://docs.python.org/es/3/library/stdtypes.html#str.isdecimal) * [`isdigit()`](https://docs.python.org/es/3/library/stdtypes.html#str.isdigit) * [`isidentifier()`](https://docs.python.org/es/3/library/stdtypes.html#str.isidentifier) * [`islower()`](https://docs.python.org/es/3/library/stdtypes.html#str.islower) * [`isnumeric()`](https://docs.python.org/es/3/library/stdtypes.html#str.isnumeric) * [`isprintable()`](https://docs.python.org/es/3/library/stdtypes.html#str.isprintable) * [`isspace()`](https://docs.python.org/es/3/library/stdtypes.html#str.isspace) * [`istitle()`](https://docs.python.org/es/3/library/stdtypes.html#str.istitle) * [`isupper()`](https://docs.python.org/es/3/library/stdtypes.html#str.isupper) * [`join()`](https://docs.python.org/es/3/library/stdtypes.html#str.join) * [`ljust()`](https://docs.python.org/es/3/library/stdtypes.html#str.ljust) * [`lower()`](https://docs.python.org/es/3/library/stdtypes.html#str.lower) * [`lstrip()`](https://docs.python.org/es/3/library/stdtypes.html#str.lstrip) * [`maketrans()`](https://docs.python.org/es/3/library/stdtypes.html#str.maketrans) * [`partition()`](https://docs.python.org/es/3/library/stdtypes.html#str.partition) * [`removeprefix()`](https://docs.python.org/es/3/library/stdtypes.html#str.removeprefix) * [`removesuffix()`](https://docs.python.org/es/3/library/stdtypes.html#str.removesuffix) * [`replace()`](https://docs.python.org/es/3/library/stdtypes.html#str.replace) * [`rfind()`](https://docs.python.org/es/3/library/stdtypes.html#str.rfind) * [`rindex()`](https://docs.python.org/es/3/library/stdtypes.html#str.rindex) * [`rjust()`](https://docs.python.org/es/3/library/stdtypes.html#str.rjust) * [`rpartition()`](https://docs.python.org/es/3/library/stdtypes.html#str.rpartition) * [`rsplit()`](https://docs.python.org/es/3/library/stdtypes.html#str.rsplit) * [`rstrip()`](https://docs.python.org/es/3/library/stdtypes.html#str.rstrip) * [`split()`](https://docs.python.org/es/3/library/stdtypes.html#str.split) * [`splitlines()`](https://docs.python.org/es/3/library/stdtypes.html#str.splitlines) * [`startswith()`](https://docs.python.org/es/3/library/stdtypes.html#str.startswith) * [`strip()`](https://docs.python.org/es/3/library/stdtypes.html#str.strip) * [`swapcase()`](https://docs.python.org/es/3/library/stdtypes.html#str.swapcase) * [`title()`](https://docs.python.org/es/3/library/stdtypes.html#str.title) * [`translate()`](https://docs.python.org/es/3/library/stdtypes.html#str.translate) * [`upper()`](https://docs.python.org/es/3/library/stdtypes.html#str.upper) * [`zfill()`](https://docs.python.org/es/3/library/stdtypes.html#str.zfill)

En Python, una función es un bloque de código que se puede reutilizar y que puede recibir parámetros y devolver valores. Por otro lado, un método es una función que está asociada a un objeto (como una cadena de texto). Por ejemplo, al usar `nombre.lower()`, `lower` es un método que actúa sobre el objeto `nombre` (una cadena). La diferencia radica en que los métodos son específicos para los tipos de datos, mientras que las funciones son más generales y pueden aplicarse a diferentes contextos.

`lower`, `upper` y `len` son funciones, pero tienen diferencias importantes. `len` es una función global que devuelve la longitud de un objeto, como una cadena, y se usa como `len(cadena)`. Por otro lado, `lower` y `upper` son métodos de las cadenas (strings) que convierten todas las letras de una cadena a minúsculas o mayúsculas, respectivamente, y se utilizan en la forma `cadena.lower()` o `cadena.upper()`. Estos métodos son parte de la clase `str` en Python.

Los metodos mas comunes son: * `strip()` - Elimina espacios o caracteres específicos al inicio y final de la cadena. * `lstrip()` - Elimina espacios o caracteres al inicio (izquierda) de la cadena. * `rstrip()` - Elimina espacios o caracteres al final (derecha) de la cadena. * `lower()` - Convierte todos los caracteres a minúsculas. * `upper()` - Convierte todos los caracteres a mayúsculas. * `title()` - Convierte la primera letra de cada palabra a mayúscula. * `capitalize()` - Convierte la primera letra de la cadena a mayúscula. * `replace()` - Reemplaza una subcadena por otra. * `find()` - Devuelve la posición de la primera ocurrencia de una subcadena. * `split()` - Divide la cadena en una lista usando un separador. * `join()` - Une los elementos de una lista en una cadena con un separador. * `startswith()` - Comprueba si la cadena empieza con una subcadena específica. * `endswith()` - Comprueba si la cadena termina con una subcadena específica. * `isnumeric()` - Comprueba si todos los caracteres son números. * `isdigit()` - Comprueba si todos los caracteres son dígitos. * `isalpha()` - Comprueba si todos los caracteres son alfabéticos. * `isalnum()` - Comprueba si los caracteres son alfanuméricos (letras o números). * `len()` - Devuelve la longitud de la cadena (**función**, no método). * `count()` - Cuenta cuántas veces aparece una subcadena. * `index()` - Devuelve el índice de la primera ocurrencia de una subcadena. * `rfind()` - Devuelve la posición de la última ocurrencia de una subcadena. * `zfill()` - Rellena la cadena con ceros al inicio para alcanzar una longitud específica. * `format()` - Da formato a la cadena reemplazando marcadores con valores. * `center()` - Centra la cadena en una longitud específica. * `rjust()` - Alinea la cadena a la derecha con una longitud específica. * `ljust()` - Alinea la cadena a la izquierda con una longitud específica.

```js name = "Mara" #str nameCapital = " MARA " caracter ='c' #str lastname = ''' Guerrero''' #str nameComplete = " edmara guerrero " print(type(name)) #devuelve tipo del dato print(lastname) print(type(caracter)) print(name[0]) #devuelve el primer caracter del str print(name[1]) print(name[2]) print(name[3]) print(name + lastname) #concatenar variables str print(name*5) # devuelve el name 5 veces print(len(lastname)) #longitud del str print("Lower: " + nameCapital.lower()) #convertir todo en minuscula print("Upper: " + nameCapital.upper()) #convertir todo en mayuscula print("Strip: " + nameCapital.strip()) #remueve espacios inicio y fin del str print("LStrip: " + nameCapital.lstrip()) #remueve espacios inicio del str print("RStrip: " + nameCapital.rstrip()) #remueve espacios fin del str print("Count: " + str(nameComplete.count("r"))) #cuenta cuantas veces existe el str dentro del parentesis / str() convierte a str lo que esta dentro del parentesis print("Capitalize: " + nameComplete.capitalize()) #pone el primer caracter en mayuscula print("Title: " + nameComplete.title()) #pone el primer caracter de cada palabra en mayuscula print("Swapcase: " + nameComplete.swapcase()) #cambia de upper a lower o lower upper segun el str original print("Replace: " + nameComplete.replace("a","@")) #reemplaza el primer str por el segundo dentro del parentesis print("Split: ") print(nameComplete.split(" ")) #separa los str cuando consigue el str dentro del parentesis print("Find: ") print(nameComplete.find("r")) #devuelve el indice donde consigue el str por primera vez print("Index: ") print(nameComplete.index("r")) #devuelve el indice donde consigue el str por primera vez ```name = "Mara" *#str*nameCapital = "   MARA   "caracter ='c' *#str*lastname = ''' Guerrero''' *#str*nameComplete = "  edmara guerrero  "print(type(name)) *#devuelve tipo del dato*print(lastname)print(type(caracter)) print(name\[0]) *#devuelve el primer caracter del str*print(name\[1])print(name\[2])print(name\[3])print(name + lastname) *#concatenar variables str*print(name\*5) *# devuelve el name 5 veces*print(len(lastname)) *#longitud del str*print("Lower: " + nameCapital.lower()) *#convertir todo en minuscula*print("Upper: " + nameCapital.upper()) *#convertir todo en mayuscula*print("Strip: " + nameCapital.strip()) *#remueve espacios inicio y fin del str*print("LStrip: " + nameCapital.lstrip()) *#remueve espacios inicio del str*print("RStrip: " + nameCapital.rstrip()) *#remueve espacios  fin del str*print("Count: " + str(nameComplete.count("r"))) *#cuenta cuantas veces existe el str dentro del parentesis / str() convierte a str lo que esta dentro del parentesis*print("Capitalize: " + nameComplete.capitalize()) *#pone el primer caracter en mayuscula*print("Title: " + nameComplete.title()) *#pone el primer caracter de cada palabra en mayuscula*print("Swapcase: " + nameComplete.swapcase()) *#cambia de upper a lower o lower upper segun el str original*print("Replace: " + nameComplete.replace("a","@")) *#reemplaza el primer str por el segundo dentro del parentesis*print("Split: ")print(nameComplete.split(" ")) *#separa los str cuando consigue el str dentro del parentesis*print("Find: ")print(nameComplete.find("r")) *#devuelve el indice donde consigue el str por primera vez*print("Index: ")print(nameComplete.index("r")) *#devuelve el indice donde consigue el str por primera vez*

`name = "Mara" ``#str``nameCapital = "   MARA   "caracter ='c' ``#str``lastname = ''' Guerrero''' ``#str``nameComplete = "  edmara guerrero  "print(type(name)) ``#devuelve tipo del dato``print(lastname)print(type(caracter)) print(name[0]) ``#devuelve el primer caracter del str``print(name[1])print(name[2])print(name[3])print(name + lastname) ``#concatenar variables str``print(name*5) ``# devuelve el name 5 veces``print(len(lastname)) ``#longitud del str``print("Lower: " + nameCapital.lower()) ``#convertir todo en minuscula``print("Upper: " + nameCapital.upper()) ``#convertir todo en mayuscula``print("Strip: " + nameCapital.strip()) ``#remueve espacios inicio y fin del str``print("LStrip: " + nameCapital.lstrip()) ``#remueve espacios inicio del str``print("RStrip: " + nameCapital.rstrip()) ``#remueve espacios  fin del str``print("Count: " + str(nameComplete.count("r"))) ``#cuenta cuantas veces existe el str dentro del parentesis / str() convierte a str lo que esta dentro del parentesis``print("Capitalize: " + nameComplete.capitalize()) ``#pone el primer caracter en mayuscula``print("Title: " + nameComplete.title()) ``#pone el primer caracter de cada palabra en mayuscula``print("Swapcase: " + nameComplete.swapcase()) ``#cambia de upper a lower o lower upper segun el str original``print("Replace: " + nameComplete.replace("a","@")) ``#reemplaza el primer str por el segundo dentro del parentesis``print("Split: ")print(nameComplete.split(" ")) ``#separa los str cuando consigue el str dentro del parentesis``print("Find: ")print(nameComplete.find("r")) ``#devuelve el indice donde consigue el str por primera vez``print("Index: ")print(nameComplete.index("r")) ``#devuelve el indice donde consigue el str por primera vez`

name = "Mara" *#str*nameCapital = "   MARA   "caracter ='c' *#str*lastname = ''' Guerrero''' *#str*nameComplete = "  edmara guerrero  "print(type(name)) *#devuelve tipo del dato*print(lastname)print(type(caracter)) print(name\[0]) *#devuelve el primer caracter del str*print(name\[1])print(name\[2])print(name\[3])print(name + lastname) *#concatenar variables str*print(name\*5) *# devuelve el name 5 veces*print(len(lastname)) *#longitud del str*print("Lower: " + nameCapital.lower()) *#convertir todo en minuscula*print("Upper: " + nameCapital.upper()) *#convertir todo en mayuscula*print("Strip: " + nameCapital.strip()) *#remueve espacios inicio y fin del str*print("LStrip: " + nameCapital.lstrip()) *#remueve espacios inicio del str*print("RStrip: " + nameCapital.rstrip()) *#remueve espacios  fin del str*print("Count: " + str(nameComplete.count("r"))) *#cuenta cuantas veces existe el str dentro del parentesis / str() convierte a str lo que esta dentro del parentesis*print("Capitalize: " + nameComplete.capitalize()) *#pone el primer caracter en mayuscula*print("Title: " + nameComplete.title()) *#pone el primer caracter de cada palabra en mayuscula*print("Swapcase: " + nameComplete.swapcase()) *#cambia de upper a lower o lower upper segun el str original*print("Replace: " + nameComplete.replace("a","@")) *#reemplaza el primer str por el segundo dentro del parentesis*print("Split: ")print(nameComplete.split(" ")) *#separa los str cuando consigue el str dentro del parentesis*print("Find: ")print(nameComplete.find("r")) *#devuelve el indice donde consigue el str por primera vez*print("Index: ")print(nameComplete.index("r")) *#devuelve el indice donde consigue el str por primera vez*

Para practicar un poco, pídanle a ChatGPT que les genere retos donde puedan resolver problemas reales con los conocimientos aprendidos en esta y otras clases. Yo le pedí uno para practicar los métodos de las cadenas de texto, y este fue el que me pidió. Compartan sus soluciones en los comentarios. **Reto: Analizador de Sentimientos básico** #### **Contexto:** Eres un desarrollador que trabaja en un sistema básico de análisis de sentimientos. Recibes reseñas de clientes sobre un producto, y tu tarea es identificar si una reseña es positiva, negativa o neutra, basado en palabras clave. #### **Tarea:** 1. **Clasificar las reseñas** según las palabras clave: * Si contiene palabras positivas como `"excelente", "bueno", "genial"`, clasificar como **Positiva**. * Si contiene palabras negativas como `"malo", "terrible", "horrible"`, clasificar como **Negativa**. * Si no contiene ninguna de estas palabras clave, clasificar como **Neutral**. 2. **Contar la cantidad de palabras positivas y negativas** en cada reseña. 3. **Limpiar el texto** eliminando puntuación y convirtiendo todo a minúsculas para análisis más preciso. #### **Ejemplo de reseñas:** ```js resenas = [ "El producto es excelente, lo recomiendo a todos.", "La calidad es terrible, no volveré a comprar.", "Es un producto bueno, pero el envío fue malo.", "No tengo opinión al respecto, fue normal.", "¡Genial! Sin duda lo volveré a comprar." ] ```

Comparto mi ejercicio 

Otra forma de concatenar `print(f"{name} {last_name}")` Esta es una f-string, una forma de formatear cadenas en Python que permite incrustar expresiones/variables dentro de llaves `{}`

Entiendo cómo se utiliza la indexación de los strings, pero mi duda es, hablando de la práctica ¿En qué casos se utiliza o para que es útil? ¿Me podrían decir algunos ejemplos? 🙃?

En cuanto al espacio en las concatenaciones yo añadí un espacio a mi variable, la profesora concatenó un espacio. Pero a mi me funcionó igual... En realidad no si se se usa, o si es buena o mala práctica

Creo que No quedó muy claro el ejemplo que Carla hizo sobre el método "strip" para suprimir los espacios de la cadena. Porque en el resultado de la consola siguen apareciendo los espacios...

Python permite trabajar con cadenas de texto (strings) de manera muy flexible. Puedes definir cadenas con comillas simples, dobles o triples, siendo estas últimas útiles para incluir saltos de línea. Además, puedes acceder a cada carácter mediante indexación, donde las posiciones comienzan en cero y los índices negativos permiten acceder desde el final. Las cadenas son iterables y soportan operaciones como concatenación y repetición. Para concatenar, usas el operador `+`, mientras que para repetir, utilizas el `*`. También puedes obtener la longitud de una cadena con la función `len()` y manipularlas con métodos específicos como `lower()`, `upper()` y `strip()`.

En esta clase se tratan las cadenas haciendo enfasis en las cadenas de caracteres se ven 4 conceptos principales: 1 tipos de cadenas segun las comillas usadas (simples, Dobles o triples). 2 la indexacion:la posibilidad de tratar estas cadenas como arreglos y acceder a posiciones exactas de ese arreglo, 3 concatenacion y repeticion de cadenas con el uso de los ooperadoers matematicos + \*. build in methods para la manipulacion de cadenas.

### **1.** `.count(substring, start, end)` Cuenta cuántas veces aparece un **substring** (subcadena) en una cadena. **Ejemplo:** pythonCopiar código`texto = "hola hola hola"` `print(texto.count("hola")) # Resultado: 3` **Parámetros opcionales:** * `start`: índice inicial para buscar. * `end`: índice final para buscar. ### **2.** `.capitalize()` Convierte la primera letra de la cadena en mayúscula y el resto en minúscula. **Ejemplo:** pythonCopiar código`texto = "hola mundo"` `print(texto.capitalize()) # Resultado: "Hola mundo"` ### **3.** `.title()` Convierte la primera letra de cada palabra en mayúscula. **Ejemplo:** pythonCopiar código`texto = "hola mundo"` `print(texto.title()) # Resultado: "Hola Mundo"` ### **4.** `.swapcase()` Invierte el caso de cada letra: las mayúsculas se convierten en minúsculas y viceversa. **Ejemplo:** pythonCopiar código`texto = "Hola Mundo"` `print(texto.swapcase()) # Resultado: "hOLA mUNDO"` ### **5**. `.replace(old, new, count)` Reemplaza todas las apariciones de una subcadena `old` por `new`. Puedes limitar el número de reemplazos con `count`. **Ejemplo:** pythonCopiar código`texto = "Hola mundo mundo"` `print(texto.replace("mundo", "planeta")) # Resultado: "Hola planeta planeta"` `print(texto.replace("mundo", "planeta", 1)) # Resultado: "Hola planeta mundo"` ### 6. `.split(separator, maxsplit)` Divide una cadena en una lista, usando un separador (por defecto, los espacios). Puedes limitar el número de divisiones con `maxsplit`. **Ejemplo:** pythonCopiar código`texto = "Hola, mundo, bonito"` `print(texto.split(", ")) # Resultado: ["Hola", "mundo", "bonito"]` ### **7.** `.strip(chars)` Elimina caracteres específicos (o espacios en blanco por defecto) al inicio y al final de una cadena. **Ejemplo:** pythonCopiar código`texto = " Hola mundo "` `print(texto.strip()) # Resultado: "Hola mundo"` `texto = "--Hola mundo--"` `print(texto.strip("-")) # Resultado: "Hola mundo"` ### **8.** `.lstrip(chars)` Elimina caracteres específicos (o espacios) al inicio de una cadena. **Ejemplo:** pythonCopiar código`texto = " Hola mundo"` `print(texto.lstrip()) # Resultado: "Hola mundo"` ### **9.** `.rstrip(chars)` Elimina caracteres específicos (o espacios) al final de una cadena. **Ejemplo:** pythonCopiar código`texto = "Hola mundo "` `print(texto.rstrip()) # Resultado: "Hola mundo"` ### **10**. `.find(substring, start, end)` Devuelve el índice de la primera aparición de una subcadena en la cadena. Si no se encuentra, devuelve `-1`. **Ejemplo:** pythonCopiar código`texto = "Hola mundo"` `print(texto.find("mundo")) # Resultado: 5` `print(texto.find("planeta")) # Resultado: -1` ### **11**. `.index(substring, start, end)` Similar a `.find()`, pero si la subcadena no se encuentra, genera un **ValueError**. **Ejemplo:** pythonCopiar código`texto = "Hola mundo"` `print(texto.index("mundo")) # Resultado: 5` pythonCopiar código`print(texto.index("planeta")) # Error: ValueError` ### **12.** `eval(expression)` Evalúa una expresión Python contenida en una cadena y ejecuta su resultado. **Ejemplo:** pythonCopiar código`expr = "2 + 2"` `print(eval(expr)) # Resultado: 4` **Nota:** ¡Usa `eval` con cuidado! Ejecutar código no controlado puede ser peligroso. ### **13.** `exec(statement)` Ejecuta código Python dentro de una cadena. A diferencia de `eval`, `exec` puede ejecutar declaraciones completas, no solo expresiones. **Ejemplo:** pythonCopiar código`codigo = `""" for i in range(3): print("Hola", i) `"""` `exec`(codigo) **Nota:** Al igual que con `eval`, ten cuidado con su uso para evitar problemas de seguridad.

Para los que quieran agilizar el tema de copiar y pegar toda una línea, solo tiene que ubicarse al final de la línea y presionar "shift + alt + flecha arriba" y les copiará y pegará esa línea en la siguiente

Como saber cuantos métodos existen cada tipo de variable con la función dir() `text = "Estes es un texto"` `print(dir(text))` `print(dir(10))`

```js name = 'ULISES' #Asigna el valor 'ULISES' a la variable name last_name = 'Gomez Zenteno' #Asigna el valor 'Gomez Zenteno' a la variable last_name print(5 * name) #Imprime el valor de name 5 veces print(name + ' ' +last_name) #Imprime el valor de name concatenado con un espacio y el valor de last_name print(len(name)) #Imprime la longitud (número de caracteres) del valor de name print(len(last_name)) #Imprime la longitud (número de caracteres) del valor de last_name print(name.lower()) #name.lower = Imprime el valor de name en minúsculas print(name.upper()) #name.upper = Imprime el valor de name en mayúsculas print(last_name.strip()) #name.strip = Imprime el valor de last_name eliminando los espacios en blanco al inicio y al final ```

Cuando escribes `print("hola \n mundo")`, Python interpreta `\n` como un carácter de nueva línea. Esto significa que al ejecutar el código, se imprimirá "hola" en una línea y "mundo" en la siguiente. El resultado será: ``` hola mundo ``` Esto demuestra cómo las cadenas pueden incluir caracteres especiales para dar formato a la salida.

Hola. Estaba probando los métodos descritos en la clase, y lo hice en varios entornos (colab, jupyter, code, playgrounds, etc) y todos obtengo el mismo error: name = 'Prueba de STRINGS y CaMBIos de formato' print(name) print(name.lower) \<built-in method lower of str object at 0x00000224DA0276F0> **¿Hay algo que está faltando?**

\- Manipulacion de Cadenas de Texto en Python \- para crear un string en python puedes utilizar 3 tipos de comillas comillas→simples, dobles y triples \- Las comillas triples permiten incluir saltos de línea y espacios en blanco. \- name = 'Carly' \- imprime 'C' print(name\[0]) \- imprime 'y' contanto por atras print(name\[-1]) \- Puedes concatenar cadenas utilizando el operador + \- Puedes repetir cadenas utilizando el operador \* \- obten la longitud de la cadena print(len(name)) \- obten la cadena en minuscula print(name.lower()) \- obten la cadena en mayuscula print(name.upper()) \- elimina espacios en blanco al principio y al final print(name.strip())

Escribo mucho y nunca he podido saber donde estan las comillas simples...

min 6:00, Concatenacion No es Sumar, es Juntar, agrupar, esto es una gran diferencia: son dos conceptos diferentes en el contexto de manipulación de datos. Permíteme explicarte: * **Concatenar**: Cuando concatenamos, estamos uniendo o agrupando elementos de texto o cadenas de caracteres. Por ejemplo, si tenemos dos palabras, “Hola” y “mundo”, al concatenarlas obtendríamos “Hola mundo”. [En Excel, puedes usar funciones como **CONCATENAR**, **CONCAT** o incluso el símbolo “&” para combinar el contenido de varias celdas en una sola](https://excel-exercice.com/es/agrupar-celdas-concatenadas/)[1](https://excel-exercice.com/es/agrupar-celdas-concatenadas/)[2](https://support.microsoft.com/es-es/office/concatenate-function-5b0392b2-94ef-49ea-8532-4fdd3a69d362). Por ejemplo, si quisieras unir el contenido de las celdas A1 y B1, podrías escribir `=A1&B1`. * **Sumar**: Por otro lado, la suma es una operación matemática que implica agregar valores numéricos. Si tenemos los números 3 y 5, al sumarlos obtendríamos 8. En Excel, utilizamos la función **SUMA** para sumar valores numéricos. Por ejemplo, si tienes los valores en las celdas A1 y B1, podrías escribir `=SUMA(A1:B1)` para obtener la suma de ambos valores. En resumen, **concatenar** es como unir palabras o textos, mientras que **sumar** se refiere a la operación matemática de agregar números.

Notas: -Para variables de tipo string se puede usar "comillas dobles", 'comilla simple' y '''comilla triple''' -Con las comillas triples se pueden hacer saltos de linea -El conteo de caracteres de una cadena empieza desde 0 -print(nombre\[0]) #consulta posicion de caracter, te imprime el caracter en esa posición -Si se intenta imprimir un carácter fuera de rango dará error -print(nombre\[-1]) #Impresion de caracter pero empieza desde el ultimo y va en reversa -Se pueden multiplicar variables de tipo str -print(len(name)) #longitud de cadena

*# Métodos para strings* texto = "Hola Mundo" texto\_con\_espacios = " hola mundo " *# 1. upper() y lower() - Convertir a mayúsculas y minúsculas* print(texto.upper()) *# Resultado: HOLA MUNDO* print(texto.lower()) *# Resultado: hola mundo* *# 2. strip() - Eliminar espacios en blanco al inicio y final* print(texto\_con\_espacios.strip()) *# Resultado: "hola mundo"* *# 3. replace() - Reemplazar texto* print(texto.replace("Mundo", "Python")) *# Resultado: Hola Python* *# 4. split() - Convertir string a lista* texto\_largo = "Python es genial" print(texto\_largo.split()) *# Resultado: \['Python', 'es', 'genial']* *# 5. join() - Unir elementos de una lista en un string* lista = \['Python', 'es', 'genial'] print(" ".join(lista)) *# Resultado: Python es genial* *# Métodos para listas* numeros = \[1, 2, 3, 4, 5] frutas = \['manzana', 'banana'] *# 1. append() - Añadir un elemento al final* frutas.append('naranja') print(frutas) *# Resultado: \['manzana', 'banana', 'naranja']* *# 2. extend() - Añadir varios elementos de una vez* mas\_frutas = \['uva', 'pera'] frutas.extend(mas\_frutas) print(frutas) *# Resultado: \['manzana', 'banana', 'naranja', 'uva', 'pera']* *# 3. insert() - Insertar un elemento en una posición específica* frutas.insert(1, 'kiwi') print(frutas) *# Resultado: \['manzana', 'kiwi', 'banana', 'naranja', 'uva', 'pera']* *# 4. remove() - Eliminar un elemento específico* frutas.remove('banana') print(frutas) *# Resultado: \['manzana', 'kiwi', 'naranja', 'uva', 'pera']* *# 5. pop() - Eliminar y devolver un elemento* ultimo = frutas.pop() print(f"Eliminado: {ultimo}") *# Resultado: Eliminado: pera* print(frutas) *# Resultado: \['manzana', 'kiwi', 'naranja', 'uva']* *# Métodos para diccionarios* persona = {'nombre': 'Ana', 'edad': 25} *# 1. keys() - Obtener todas las claves* print(list(persona.keys())) *# Resultado: \['nombre', 'edad']* *# 2. values() - Obtener todos los valores* print(list(persona.values())) *# Resultado: \['Ana', 25]* *# 3. items() - Obtener pares clave-valor* print(list(persona.items())) *# Resultado: \[('nombre', 'Ana'), ('edad', 25)]* *# 4. get() - Obtener valor de forma segura* print(persona.get('ciudad', 'No especificada')) *# Resultado: No especificada*

La manipulación de cadenas de texto en Python es fundamental para trabajar con texto y procesar datos. Aquí tienes una breve introducción a algunas técnicas comunes de manipulación de cadenas: 1. **Creación de Cadenas:** * En Python, puedes crear una cadena de caracteres simplemente encerrando contenido entre comillas. Por ejemplo:mensaje = "Hola, mundo" ```js mensaje = "Hola, mundo" ``` 2. **Operadores de Cadenas:** * Los operadores de cadenas te permiten realizar acciones como concatenar y multiplicar. * La **concatenación** se realiza con el operador `+`. Puedes unir dos cadenas así:```js nombre = "Juan" saludo = "¡Hola, " + nombre + "!" ``` * La asteriscos = "\*" \* 10 # Resultado: "\*\*\*\*\*\*\*\*\*\*"**multiplicación** repite una cadena varias veces. Por ejemplo: ```js asteriscos = "*" * 10 # Resultado: "**********" ``` 3. **Métodos para Cadenas:** * Python proporciona varios métodos para manipular cadenas. Algunos ejemplos son: * `upper()`: Convierte la cadena a mayúsculas. * `lower()`: Convierte la cadena a minúsculas. * `replace(subcadena, nueva_subcadena)`: Reemplaza una subcadena por otra. * `find(subcadena)`: Busca la posición de una subcadena. * `split(separador)`: Divide la cadena en partes usando un separador. 4. **Secuencias de Escape:** * Las secuencias de escape se utilizan para representar caracteres especiales, como `\\n` (salto de línea) o `\\t` (tabulación). * Por ejemplo:direccion = "Calle 123\nCiudad" ```js direccion = "Calle 123\nCiudad" ```

Excelente esta profe, muy bien explicado todo. Gracias!

La comilla triple función como lo que se conoce como: “literal String” es útil para agregar identacion y saltos de línea como por ejemplo consultas de typo SQL

Util, ¿la comilla simple? -- singo de pregunta--

Revision para esta clase del trato de una cadena de texto.  saludos

En ésta clase visualizamos 3 tipos de métodos upper para cambiar el texto a mayúsculas , lower para cambiar el texto a minúsculas y strip para eliminar los espacios de los bordes.

¿Porqué no me eliminará los espacios el strip? hasta puse 2 ejemplos diferentes el de name y ciudad 

✅

```js #Strings ("""Un string es una secuencia de caracteres, como letras, números, símbolos, o espacios. En Python, los strings se escriben entre comillas simples ('...') o comillas dobles ("...").""") nombre = "Hola" saludo = 'Mundo' #Para imprimir el valor de una variable, utilizas la función print(): variable = "Hola, Mundo" print(variable) # Imprime: Hola, Mundo #Para verificar el tipo de dato de una variable, utilizas la función type(): tipo = type(variable) print(tipo) # Imprime: <class 'str'> ### 1. **¿Qué es un string?** ###Un **string** es una secuencia de caracteres, como letras, números, símbolos, o espacios. En Python, los strings se escriben entre comillas simples (`'...'`) o comillas dobles (`"..."`). Por ejemplo: nombre = "Hola" saludo = 'Mundo' ### 2. **Acceso a los caracteres** #Puedes acceder a los caracteres individuales de un string usando índices. Los índices comienzan desde 0: #saludo = "Mundo" #print(saludo[0]) # Imprime 'M' # ### 3. **Longitud del string** #Para saber cuántos caracteres tiene un string, puedes usar la función `len()`: #len(saludo) # Devuelve 5 # ### 4. **Concatenación** #Puedes unir dos o más strings usando el operador `+`: #nombre_completo = "Hola" + " " + "Mundo" # Resultado: "Hola Mundo" # ### 5. **Repetición** #Puedes repetir un string varias veces usando el operador `*`: #repetido = "Hola" * 3 # Resultado: "HolaHolaHola" # ### 6. **Slicing (Rebanado)** #Puedes obtener una parte de un string usando slicing. Por ejemplo: #parte = saludo[1:4] # Resultado: "und" # #Esto toma los caracteres desde el índice 1 hasta el 3 (el 4 no se incluye). ### 7. **Métodos útiles** #Los strings en Python tienen muchos métodos incorporados que te permiten manipularlos. Algunos ejemplos son: #- `lower()` y `upper()`: para convertir el string a minúsculas o mayúsculas. # # saludo.lower() # "mundo" # #- `strip()`: para eliminar espacios en blanco al principio y al final. # # espacio = " Hola ".strip() # "Hola" # #- `replace()`: para reemplazar partes del string. # # nuevo_saludo = saludo.replace("o", "a") # "Munda" # ### 8. **Inmutabilidad** #Los strings en Python son **inmutables**, lo que significa que no puedes cambiar un carácter específico directamente. Si intentas hacer esto: #saludo[0] = "m" # Error # ```#Strings("""Un string es una secuencia de caracteres, como letras, números,símbolos, o espacios. En Python, los strings se escriben entre comillas simples ('...') o comillas dobles ("...").""") nombre = "Hola"saludo = 'Mundo' \#Para imprimir el valor de una variable, utilizas la función print():variable = "Hola, Mundo"print(variable)  # Imprime: Hola, Mundo \#Para verificar el tipo de dato de una variable, utilizas la función type():tipo = <u>type</u>(variable)print(tipo)  # Imprime: \<class 'str'> \### 1. \*\*¿Qué es un string?\*\*###Un \*\*string\*\* es una secuencia de caracteres, como letras, números, símbolos, o espacios. En Python, los strings se escriben entre comillas simples (`'...'`) o comillas dobles (`"..."`). Por ejemplo: nombre = "Hola"saludo = 'Mundo' \### 2. \*\*Acceso a los caracteres\*\*#Puedes acceder a los caracteres individuales de un string usando índices. Los índices comienzan desde 0: \#saludo = "Mundo"#print(saludo\[0])  # Imprime 'M'# \### 3. \*\*Longitud del string\*\*#Para saber cuántos caracteres tiene un string, puedes usar la función `len()`: \#len(saludo)  # Devuelve 5# \### 4. \*\*Concatenación\*\*#Puedes unir dos o más strings usando el operador `+`: \#nombre\_completo = "Hola" + " " + "Mundo"  # Resultado: "Hola Mundo"# \### 5. \*\*Repetición\*\*#Puedes repetir un string varias veces usando el operador `\*`: \#repetido = "Hola" \* 3  # Resultado: "HolaHolaHola"# \### 6. \*\*Slicing (Rebanado)\*\*#Puedes obtener una parte de un string usando slicing. Por ejemplo: \#parte = saludo\[1:4]  # Resultado: "und"##Esto toma los caracteres desde el índice 1 hasta el 3 (el 4 no se incluye). \### 7. \*\*Métodos útiles\*\*#Los strings en Python tienen muchos métodos incorporados que te permiten manipularlos. Algunos ejemplos son:#- `lower()` y `upper()`: para convertir el string a minúsculas o mayúsculas.## saludo.lower()  # "mundo"#  #- `strip()`: para eliminar espacios en blanco al principio y al final.## espacio = " Hola ".strip()  # "Hola"#  #- `replace()`: para reemplazar partes del string.## nuevo\_saludo = saludo.replace("o", "a")  # "Munda"#   \### 8. \*\*Inmutabilidad\*\*#Los strings en Python son \*\*inmutables\*\*, lo que significa que no puedes cambiar un carácter específico directamente. Si intentas hacer esto: \#saludo\[0] = "m"  # Error#

Muy interesante el uso de las triples comillas.

```js name = 'David Averto' last_name = 'Lopez Ruiz' # character = "C" # print(type(character)) # print(name[0]) # print(name[1]) # print(name[-2]) print(name) print(name + ' ' + last_name) print(len(name)) print(len(last_name)) ```name = 'David Averto'last\_name = 'Lopez Ruiz'# character = "C"# print(type(character))# print(name\[0])# print(name\[1])# print(name\[-2])print(name)print(name + ' ' + last\_name)print(len(name))print(len(last\_name))

```python string_var = ' The car, is red ' print(string_var.count('car')) # Cuenta la cantidad de veces que aparece una palabra en un cadena de Texto print(string_var.capitalize()) # Convierte la primera Letra de la cadena de texto en Máyuscula print(string_var.title()) # Conviernte la primera letra de cada palabra en Mayúscula print(string_var.swapcase()) # Convierte toca la cadena de Texto en MAYÚSCULA print(string_var.replace('car', 'helicopter')) # Reemplazar algún elemento de la cadena de texto / string.replace(oldvalue, newvalue) print(string_var.split(',')) # Divide una cadena en una lista, se puede establecer cual será el separador print(string_var.split()) # En este caso la lista se dividirá por medio de los espacios. print(string_var.strip()) # Elimina los espacios en blanco iniciales y Finales, print(string_var.strip(' Thered')) # Pero también se puede especificar que elementos eliminar print(string_var.lstrip()) # Elimina los caracteres Iniciales de la Cadena print(string_var.rstrip('d ')) # Elimina los caracteres Finales de la Cadena print(string_var.find('a')) # Devuelve el número de la pisición en la que se encuentra la palabra print(string_var.index('i',11, 14 )) # Podemos declarar un rango para encontrar la posición de la letra, en este caso por medio de la indexación. ```

una corrección al minuto 3:50: realmente las posiciones 0 y 1 corresponden a "h" y "o", ya que Python es sensible a mayúsculas y minúsculas

Carli quería saber como puedo cambiar el color de texto de la terminal, me gustaría que saliera solo en blanco ya que el amarillo y azul me distorsiona un poco la vista.

¡Increible! Esta super cool todo lo que se puede hacer solo con un texto `print("Hola Mundo")` `saludo = "Hola "nombre = "Ana"apellidos = "Gutierrez Villanueva"` `# Concatenacion (no se agregan espacios)``print(saludo + nombre)` `print(type(nombre)) ``# Tipo de dato - str` `nombre_2 = '''Soy sensible a saltos de linea'''` `print(nombre_2)` `mascota = "Milaneso"print(mascota[0]) ``#M``print(mascota[1]) ``#i``print(mascota[2]) ``#l` `print(mascota[-3]) ``#e``print(mascota[-2]) ``#s``print(mascota[-1]) ``#o` `print(3 * nombre)print(len(mascota)) ``#Longitud de la cadena (incluye espacios)` `#Metodo ``print(nombre.upper())print(apellidos.lower())`

Muy buena clase!

 `Saludo = "Hola"` `Saludo2 = 'HOLA por dos'` `Nombre = "Evaristo "` `Nombre2 = '''Gomez` `Davalos''' # escribir comillas simples pero de forma triple me permite que se vean e incluyan cambios de linea` `Caracter = "C" # en lo personal prefiero comillas dobles por que son las que mas ampliamente se usan` `Presentacion = "Hola, Yo soy"` `Fullname = "Evaristo Gomez Davalos"` `print (type(Caracter))` `print ((Saludo + " " + Nombre))` `print(Fullname[0]) # Ponemos 0 por ue se empeiza a contar de 0 ` `print(Fullname[-1]) # Puedo poner numeros dnegativos para empzar del final al principio -1 seria ` `print (Presentacion + " " +Fullname) # en python se utiliza + para concatenar` `print (Nombre *5)` `print (len(Fullname))` `print (Saludo2.lower()) #LOWER es un METODO que me sirve para convertir en minuscula` `print (Saludo.upper()) #UPPER es un METODO para convertir a MAYUSULAS` `print (Fullname.strip())#STRIP es un METODO para cortar por decirlo de una forma en ese caso espacios` `texto = "###Hola, mundo!###"` `print (texto.strip("#")) #STRIP en este caso cortara el simbolo de #`

Saludo = "Hola"Saludo2 = 'HOLA por dos'Nombre = "Evaristo "Nombre2 = '''GomezDavalos''' # escribir comillas simples pero de forma triple me permite que se vean e incluyan cambios de lineaCaracter = "C" # en lo personal prefiero comillas dobles por que son las que mas ampliamente se usanPresentacion = "Hola, Yo soy"Fullname = "Evaristo Gomez Davalos"print (type(Caracter))print ((Saludo + " " +  Nombre))print(Fullname\[0]) # Ponemos 0 por ue se empeiza a contar de 0 print(Fullname\[-1]) # Puedo poner numeros dnegativos para empzar del final al principio -1 seria print (Presentacion + " " +Fullname) # en python se utiliza + para concatenarprint (Nombre \*5)print (len(Fullname))print (Saludo2.lower()) #LOWER es un METODO que me sirve para convertir en minusculaprint (Saludo.upper())  #UPPER es un METODO para convertir a MAYUSULASprint (Fullname.strip())#STRIP es un METODO para cortar por decirlo de una forma en ese caso espaciostexto = "###Hola, mundo!###"print (texto.strip("#")) #STRIP  en este caso cortara el simbolo de #

porque cuando escribo last name no me lo reonoce como una funcion si estoy siguiendo al pie de la letra la sintaxis

```python # Buenas practicas de programacion # cuando de claremos una variable no debera llevar espacios, debemos de sus tituirlas por un "__" guion bajo name = "Abdiel jozimar" * 3 last_name = "Navarrete alba" print(name + " " + last_name) #Concatenacion - ponemos sumar dos cadenas al mismo con un (+) print(name) # Repeticion - podemos repetir una cadena las veces que queramos utlizando un (*) print( name[8]) # Indexacion - podemos ubicar un a un pedazo de la cadena, utilizando un (name [#]) # Medotos comunes de la cadena name = len("Abdiel jozimar") #LEN - Nos indica la longitud de la cadena print (name ) last_name = "NAVARRETE ALBA" #LOWER - Convierte a la cadena en minisculas print( last_name.lower()) last_name = "navarrete alba" # UPPER - Convierte la cadena a mayusculas print( last_name.upper()) name = " Abdiel jozimar " #STRIP - Elimina los espacios en blanco del inicio y final print(name.strip()) ```Mi aportación :)

```js nombre = 'Juan' nombre = nombre + ' Pérez' nombre = nombre + ' Gómez' print(nombre) ```nombre = 'Juan'nombre = nombre + ' Pérez'nombre = nombre + ' Gómez' print(nombre)

Se imprime lo que esta en paréntesis multiplicado por el int name = 'Carli'l print((name + ', ') \* 5) Output: Carli, Carli, Carli, Carli, Carli,

Otros métodos interesantes para usar son los `rjust, ljust y center` que nos ayudan a alinear el texto dentro de una anchura y un pattern.

En Python, puedes manipular cadenas usando slicing (subíndices). Aquí hay algunos ejemplos con la cadena `name = 'Carlos'`: 1. Para obtener los caracteres desde la posición 3 hasta la 6, usas `name[3:6]`. El resultado es `'los'`. 2. Para obtener los caracteres desde la posición 3 hasta el final, usas `name[3:]`. El resultado es `'los'`. 3. Para obtener los caracteres desde el principio hasta la posición 6, usas `name[:6]`. El resultado es `'Carlos'`. 4. Para obtener todos los caracteres, usas `name[:]`. El resultado es `'Carlos'`. 5. Para obtener todos los caracteres de dos en dos, usas `name[::2]`. El resultado es `'Crls'`. 6. Para obtener todos los caracteres en orden inverso, usas `name[::-1]`. El resultado es `'solraC'`.

## Manipulación de Cadenas en Python: Slicing La manipulación de cadenas en Python es una habilidad esencial para cualquier programador. Una de las técnicas más útiles para trabajar con cadenas es el slicing. Slicing nos permite extraer porciones de una cadena utilizando la notación de subíndice `[inicio:fin:paso]`. ### Ejemplos Prácticos Consideremos la cadena `name`: pythonCopiar código`name = 'Carlos'` Vamos a aplicar diferentes formas de slicing sobre esta cadena: 1. **Extracción de una Subcadena desde la Posición 3 hasta la 6:**pythonCopiar código`print(name[3:6]) # Salida: 'los'` * `name[3:6]` extrae los caracteres desde el índice 3 hasta el índice 6 (sin incluir el carácter en la posición 6). 2. **Extracción de una Subcadena desde la Posición 3 hasta el Final:**pythonCopiar código`print(name[3:]) # Salida: 'los'` * `name[3:]` extrae los caracteres desde el índice 3 hasta el final de la cadena. 3. **Extracción de una Subcadena desde el Inicio hasta la Posición 6:**pythonCopiar código`print(name[:6]) # Salida: 'Carlos'` * `name[:6]` extrae los caracteres desde el inicio de la cadena hasta el índice 6 (sin incluir el carácter en la posición 6). 4. **Extracción de Todos los Caracteres:**pythonCopiar código`print(name[:]) # Salida: 'Carlos'` * `name[:]` extrae todos los caracteres de la cadena. 5. **Extracción de Caracteres con un Paso de 2:**pythonCopiar código`print(name[::2]) # Salida: 'Crls'` * `name[::2]` extrae todos los caracteres desde el inicio hasta el final, pero con un paso de 2 (saltando un carácter). 6. **Extracción de Todos los Caracteres en Orden Inverso:**pythonCopiar código`print(name[::-1]) # Salida: 'solraC'` * `name[::-1]` extrae todos los caracteres desde el final hasta el inicio, invirtiendo la cadena. ### Visualización Para visualizar mejor cómo funciona el slicing, aquí tienes una representación de los índices para la cadena `Carlos`: plaintextCopiar código C a r l o s 0 1 2 3 4 5 -6 -5 -4 -3 -2 -1 Los índices positivos comienzan desde 0 en el extremo izquierdo y aumentan hacia la derecha. Los índices negativos comienzan desde -1 en el extremo derecho y disminuyen hacia la izquierda. ### Conclusión El slicing es una herramienta poderosa para la manipulación de cadenas en Python. Permite extraer subcadenas de manera eficiente y flexible, lo cual es útil en diversas aplicaciones de programación. ¡Experimenta con diferentes combinaciones de índices y pasos para familiarizarte con esta técnica!

.count() **cuenta elementos en la lista,** ocupa un argumento lista='hola mundo' print(lista.count('o')) 2 .capitalize() **reescribe el texto en minúsculas, excepto la primer letra, que se escribe en mayúscula,** no ocupa argumento lista='hola MUNDO' print(lista.capitalize()) Hola mundo .title() **Capitaliza la primera letra después de un espacio**, no ocupa argumento lista='hOLA mUndo' print(lista.title()) Hola Mundo .sawpcase() **invierte las mayúsculas y minúsculas**, no ocupa argumento lista='hOLA mUndo' print(lista.swapcase()) Hola MuNDO .replace() **remplaza un elemento por otro**, ocupa dos argumentos lista='Hola mundo' print(lista.replace("o", "e")) Hela munde

Hola... no estaría el rescurso que comenta la prof.