Fundamentos de Programación y Python

1

¿Por qué aprender Python?

2

Introducción a Python

3

Conceptos Básicos de Programación

4

Práctica: Te doy la bienvenida a los ejercicios interactivos

5

Manipulación de Cadenas de Texto en Python

6

Enteros, Flotantes y Booleanos

7

Todo lo que Debes Saber sobre print en Python

8

Operaciones Matemáticas en Python

9

Operaciones de Entrada/Salida en Consola

Colección y Procesamiento de Datos en Python

10

Listas

11

Método slice

12

Listas de más dimensiones y Tuplas

13

Aplicación de Matrices

14

Diccionarios

15

Comprehension Lists en Python (CLASE NUEVA)

Control de Flujo en Python

16

Estructuras condicionales

17

Bucles y Control de Iteraciones

18

Generadores e Iteradores

Funciones y Manejo de Excepciones en Python

19

Uso de Funciones en Python

20

Funciones Lambda y Programación Funcional en Python

21

¿Cómo realizar una función recursiva en Python?

22

Manejo de Excepciones y Uso de Pass (CLASE NUEVA)

Programación Orientada a Objetos en Python

23

Fundamentos de Programación Orientada a Objetos en Python

24

Ejercicio Biblioteca con POO

25

Herencia en POO con Python

26

Objetos heredados

27

Los 4 pilares de la programacion orientada a objetos

28

Uso de super() en Python (CLASE NUEVA)

29

Superando los Fundamentos de Programación Orientada a Objetos en Python

Lectura y escritura de archivos

30

Manejo de Archivos .TXT (CLASE NUEVA)

31

Manejo de Archivos CSV (CLASE NUEVA)

32

Manejo de Archivos JSON (CLASE NUEVA)

Biblioteca estándar de Python

33

Librería Statistics y Análisis Estadístico (CLASE NUEVA)

34

Biblioteca estándar en Python (CLASE NUEVA)

35

Librería Os, Math y Random (CLASE NUEVA)

36

Proyecto final: Guerra naval

Conceptos avanzados de Python

37

Recapitulación de lo aprendido hasta ahora

38

Escribir código Pythonico y profesional

39

Comentarios y Docstrings en Python

40

Scope y closures: variables locales y globales

41

Anotaciones de tipo

42

Validación de tipos en métodos

43

Librería Collections y Enumeraciones

Decoradores

44

Decoradores en Python

45

Decoradores anidados y con parámetros

46

Uso de Decoradores en clases y métodos

Métodos y estructura de clases en Python

47

Métodos mágicos

48

Sobrecarga de operadores

49

Implementación de `if __name__ == "__main__":`

50

Metaprogramación en Python

51

Uso de *args y **kwargs

52

Métodos privados y protegidos

53

Gestión avanzada de propiedades

54

Métodos estáticos y de clase avanzados

Programación concurrente y asíncrona

55

Introducción a la concurrencia y paralelismo

56

Threading y multiprocessing en Python

57

Asincronismo con asyncio

58

Asincronismo y concurrencia

Creación de módulos y paquetes

59

Creación de módulos en Python

60

Gestión de paquetes

61

Publicación de paquetes en PyPI

Proyecto final

62

Implementación de un sistema completo

63

Implementación de un Sistema Completo

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de Python

Curso de Python

Carli Code

Carli Code

Manipulación de Cadenas de Texto en Python

5/63
Recursos

Entender cómo trabajar con las cadenas en Python es fundamental para la manipulación de textos y datos en muchos proyectos. Desde definir variables hasta aplicar métodos específicos, el uso de strings es una habilidad básica, pero poderosa, que se utiliza en áreas avanzadas como el procesamiento del lenguaje natural (NLP).

¿Cómo se definen las cadenas en Python?

Para crear una cadena en Python, puedes utilizar comillas simples, dobles o triples. Por ejemplo:

  • Comillas simples: name = 'Carli'
  • Comillas dobles: name = "Carli"
  • Comillas triples: name = '''Carli'''

Las comillas triples permiten incluir saltos de línea y espacios en blanco.

¿Cómo se imprime y verifica el tipo de dato de una variable?

Para imprimir el valor de una variable y verificar su tipo, puedes utilizar la función print junto con la función type:

name = 'Carli'
print(name)  # Imprime 'Carli'
print(type(name))  # Imprime 

¿Cómo se indexan las cadenas en Python?

Las cadenas son colecciones ordenadas y accesibles por índices. Puedes acceder a un carácter específico utilizando corchetes:

name = 'Carli'
print(name[0])  # Imprime 'C'
print(name[-1])  # Imprime 'i'

¿Qué pasa si intentas acceder a un índice que no existe en Python?

Si intentas acceder a un índice fuera del rango de la cadena, Python arrojará un IndexError:

print(name[20])  # Genera IndexError

¿Cómo se concatenan cadenas?

Puedes concatenar cadenas utilizando el operador + y repetirlas con el operador *:

first_name = 'Carli'
last_name = 'Florida'
full_name = first_name + ' ' + last_name
print(full_name)  # Imprime 'Carli Florida'

print(name * 5)  # Imprime 'CarliCarliCarliCarliCarli'

¿Cómo se consultan la longitud y otras operaciones en cadenas?

Para obtener la longitud de una cadena, se usa la función len:

print(len(name))  # Imprime 5

Además, las cadenas tienen métodos específicos como lower(), upper(), y strip():

print(name.lower())  # Imprime 'carli'
print(name.upper())  # Imprime 'CARLI'
print(last_name.strip())  # Elimina espacios en blanco al principio y al final

¿Qué importancia tienen las cadenas en áreas avanzadas como el NLP?

El manejo de cadenas es esencial en NLP, donde grandes cantidades de texto deben ser limpiadas y procesadas. Métodos como strip(), lower(), y replace() ayudan a preparar los datos para análisis más complejos.

Aportes 65

Preguntas 6

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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!" ```
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 !
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
Felicito al equipo de PLATZI, porque siento que este CURSO DE PYTHON está muy bien producido.
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 ![](https://static.platzi.com/media/user_upload/image-750f2436-7355-461b-9639-fbd652b41421.jpg) ```python text = "Python" print(text[0]) # Salida 'P' print(text[-1]) # Salida 'n' ```
**<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 😁
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) ```
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.`
**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.
Todo es nuevo para mi pero por fín estoy en estas
Un poco de lo que aprendi en la clase ![](https://static.platzi.com/media/user_upload/image-89454ced-76aa-4b30-b58f-677625176262.jpg)
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
✨✨✨TIP para windows ✨✨✨ Atajo de Teclado para Uso de emojis Tecla Win + tecla punto (.) Activa el SELECTOR DE EMOJIS de windows.
Aquí dejo cap de script con lo visto en la clase. ![](https://static.platzi.com/media/user_upload/string_calse_3-aff29590-b516-41be-be1f-a31a73910a85.jpg)
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. ![](https://static.platzi.com/media/user_upload/image-d3d2f954-48e7-4db6-8158-8493a063e441.jpg) 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 ![](https://static.platzi.com/media/user_upload/image-22761366-f74f-4a14-aeb9-930372a527f0.jpg)
```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!
![](https://static.platzi.com/media/user_upload/image-0de0dbe6-c1fa-45c9-a8e9-76d214f6959e.jpg) `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!
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
.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.
`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"})`