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

Biblioteca estándar en Python (CLASE NUEVA)

34

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

35

Librería Statistics y Análisis Estadístico (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

No se trata de lo que quieres comprar, sino de quién quieres ser. Aprovecha el precio especial.

Antes: $249

Currency
$209

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Suscríbete

Termina en:

14 Días
4 Hrs
4 Min
4 Seg
Curso de Python

Curso de Python

Carli Code

Carli Code

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

34/63
Recursos

¿Cómo utilizar la librería OS en Python para trabajar con archivos y directorios?

Interactuar con el sistema operativo desde Python es una tarea que se hace mucho más sencilla gracias a la librería OS. Sin necesidad de instalaciones adicionales, esta herramienta permite automatizar y manejar archivos y directorios, lo que simplifica enormemente el flujo de trabajo. Veamos algunos ejemplos prácticos de su uso.

¿Cómo obtener el directorio de trabajo actual?

La librería OS nos facilita la tarea de conocer en qué carpeta estamos trabajando. Esto es especialmente útil cuando deseamos manipular archivos en nuestro directorio actual sin tener que especificar rutas absolutas.

import os

# Obtener el directorio de trabajo actual
cwd = os.getcwd()
print("Directorio de trabajo actual:", cwd)

Cuando ejecutas este código, Python te indicará el directorio corriente en el que te encuentras, ayudándote a tener un mejor control sobre tu ubicación en el sistema de archivos.

¿Cómo listar archivos de cierto tipo?

Muchas veces, necesitamos desplegar una lista de archivos de un tipo específico, como los archivos de texto.

# Lista los archivos que terminan en .txt en el directorio actual
txt_files = [f for f in os.listdir('.') if f.endswith('.txt')]
print("Archivos txt:", txt_files)

En este snippet, usamos list comprehension para filtrar y obtener solo los archivos que terminan con .txt, facilitando así su manipulación posterior.

¿Cómo renombrar un archivo?

Renombrar archivos es otra funcionalidad que podemos implementar fácilmente con OS. Supongamos que queremos cambiar el nombre del archivo caperucita.txt a cuento.txt.

# Renombrar un archivo de caperucita.txt a cuento.txt
os.rename('caperucita.txt', 'cuento.txt')
print("Archivo renombrado")

Así podrás modificar nombres de archivos de manera simple y rápida, ayudando a mantener tus directorios organizados.

¿Cómo realizar cálculos matemáticos precisos con Math?

Cuando trabajamos con cálculos matemáticos en Python, la librería Math es una aliada invaluable. Ofrece una serie de funciones y constantes matemáticas, ideal para conseguir resultados precisos, como en el caso del número pi.

¿Cuál es la importancia de la constante pi?

Pi es una constante con decimales infinitos, y usarla con precisión es esencial para cálculos científicos o de ingeniería. La librería Math nos provee de pi con todos sus decimales disponibles.

import math

# Calcular el área y perímetro de un círculo
radio = 5
area = math.pi * (radio ** 2)
perimetro = 2 * math.pi * radio

print("Área:", area)
print("Perímetro:", perimetro)

Gracias a Math, obtenemos resultados matemáticamente precisos, que pueden ser fundamentales en diferentes aplicaciones científicas.

¿Cómo se pueden generar números y selecciones aleatorias con Random?

La generación de números y elecciones aleatorias es una tarea comúnmente requerida, y la librería Random en Python nos ofrece varias herramientas útiles para este propósito.

¿Cómo generar un número entero aleatorio?

Para generar números al azar dentro de un rango específico, randint es extremadamente práctica.

import random

# Generar un número entero aleatorio entre 1 y 10
random_number = random.randint(1, 10)
print("Número aleatorio:", random_number)

Esta función es solo la primera entre muchas posibles aproximaciones para incluir aleatoriedad en nuestros programas.

¿Cómo elegir un elemento aleatorio de una lista?

Podemos usar Random para hacer selecciones aleatorias de listas predefinidas. Supongamos que queremos elegir un color al azar.

# Elegir un color aleatorio de la lista
colores = ["rojo", "azul", "verde"]
color_random = random.choice(colores)
print("Color elegido aleatoriamente:", color_random)

Aquí, usamos choice para realizar selecciones impredecibles, lo cual es ideal para situaciones que requieren diversidad o variación en los resultados.

¿Cómo desordenar una lista?

Si deseamos barajar o mezclar elementos de una lista, shuffle es el método indicado.

# Barajar una lista de cartas
cartas = ["as", "rey", "reina", "jota", "10"]
random.shuffle(cartas)
print("Cartas barajadas:", cartas)

Esta función reordena los elementos de la lista, dejando abierta un sinfín de aplicaciones posibles, desde juegos de cartas hasta simulaciones.

Cada librería de la biblioteca estándar de Python ofrece una amplia gama de posibilidades para el aprendizaje y la automatización de tareas cotidianas. Continúa explorando la documentación y descubre más funcionalidades que enriquecerán tus aplicaciones.

Aportes 17

Preguntas 0

Ordenar por:

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

**C**hicos para facilitarles si quieren buscar aquí dejo una lista interesante que con ayudar de ChatGpt me pareció interesante: ### 1. **Métodos de cadenas (strings)**: * `str.upper()`: Convierte una cadena a mayúsculas. * `str.lower()`: Convierte una cadena a minúsculas. * `str.capitalize()`: Convierte el primer carácter a mayúscula y el resto a minúsculas. * `str.split(sep=None)`: Divide una cadena en una lista, usando el separador `sep`. * `str.join(iterable)`: Une una lista o iterable en una sola cadena, usando el string como separador. * `str.strip()`: Elimina espacios en blanco (u otros caracteres) al inicio y final de la cadena. * `str.replace(old, new)`: Reemplaza todas las ocurrencias de una subcadena `old` por `new`. * `str.find(sub)`: Busca la subcadena `sub` y devuelve la posición de su primera aparición, o `-1` si no la encuentra. ### 2. **Métodos de listas**: * `list.append(item)`: Agrega un elemento al final de la lista. * `list.extend(iterable)`: Agrega todos los elementos de un iterable al final de la lista. * `list.insert(index, item)`: Inserta un elemento en una posición específica. * `list.remove(item)`: Elimina la primera aparición de un elemento en la lista. * `list.pop(index=-1)`: Elimina y devuelve el elemento en la posición `index` (el último por defecto). * `list.index(item)`: Devuelve el índice de la primera aparición de un elemento. * `list.sort()`: Ordena la lista en orden ascendente. * `list.reverse()`: Invierte el orden de los elementos en la lista. ### 3. **Métodos de diccionarios**: * `dict.get(key, default=None)`: Devuelve el valor asociado a la clave `key`, o `default` si la clave no existe. * `dict.keys()`: Devuelve una vista de todas las claves del diccionario. * `dict.values()`: Devuelve una vista de todos los valores del diccionario. * `dict.items()`: Devuelve una vista de todos los pares clave-valor del diccionario. * `dict.update(other_dict)`: Actualiza el diccionario con los pares clave-valor de otro diccionario. * `dict.pop(key, default=None)`: Elimina y devuelve el valor asociado a la clave `key`. ### 4. **Métodos de conjuntos (sets)**: * `set.add(item)`: Agrega un elemento al conjunto. * `set.remove(item)`: Elimina un elemento del conjunto. Lanza un error si el elemento no está presente. * `set.discard(item)`: Elimina un elemento sin lanzar un error si no está presente. * `set.union(other_set)`: Devuelve un nuevo conjunto con los elementos de ambos conjuntos. * `set.intersection(other_set)`: Devuelve un conjunto con los elementos comunes entre ambos conjuntos. * `set.difference(other_set)`: Devuelve un conjunto con los elementos presentes en el conjunto original pero no en `other_set`. ### 5. **Métodos de archivos**: * `open(filename, mode)`: Abre un archivo y lo devuelve como un objeto de archivo. * `file.read()`: Lee todo el contenido del archivo. * `file.readline()`: Lee una línea del archivo. * `file.readlines()`: Lee todas las líneas del archivo y las devuelve como una lista. * `file.write(string)`: Escribe una cadena en el archivo. * `file.writelines(lines)`: Escribe una lista de cadenas en el archivo. * `file.close()`: Cierra el archivo. ### 6. **Métodos para manejo de errores**: * `try`: Comienza un bloque de código que podría generar una excepción. * `except`: Se ejecuta si ocurre una excepción dentro del bloque `try`. * `finally`: Se ejecuta independientemente de si se produce una excepción o no. * `raise`: Lanza una excepción manualmente. ### 7. **Funciones generales**: * `len(obj)`: Devuelve la longitud de un objeto (lista, cadena, etc.). * `type(obj)`: Devuelve el tipo de un objeto. * `isinstance(obj, class)`: Verifica si un objeto es una instancia de una clase. * `sum(iterable)`: Devuelve la suma de los elementos de un iterable. * `max(iterable)`: Devuelve el valor máximo de un iterable. * `min(iterable)`: Devuelve el valor mínimo de un iterable. * `range(start, stop, step)`: Genera una secuencia de números desde `start` hasta `stop`, con un incremento de `step`.
### 1. OS (Sistema Operativo): * `os.getcwd()` Retorna el directorio de trabajo actual. * `os.chdir(path)`: Cambia el directorio de trabajo actual al especificado. * `os.listdir(path)`: Lista los archivos y carpetas en el directorio especificado. * `os.makedirs(path)`: Crea directorios de manera recursiva. * `os.remove(path)`: Elimina el archivo especificado. * `os.path.join(*paths)`: Une componentes de una ruta de manera segura según el sistema operativo. * `os.path.exists(path)`: Verifica si una ruta existe. * `os.rename(src, dst)`: Renombra un archivo o directorio. * `os.environ`: Proporciona acceso a las variables de entorno del sistema. ### 2. **Módulo** (Operaciones Matemáticas): * `math.sqrt(x)`: Retorna la raíz cuadrada de `x`. * `math.pow(x, y)`: Eleva `x` a la potencia `y` (equivalente a `x ** y`). * `math.ceil(x)`: Redondea un número hacia arriba (al entero más cercano). * `math.floor(x)`: Redondea un número hacia abajo (al entero más cercano). * `math.factorial(x)`: Retorna el factorial de `x`. * `math.fabs(x)`: Retorna el valor absoluto de `x` (como número flotante). * `math.log(x[, base])`: Retorna el logaritmo de `x` con base `base` (por defecto, base `e`). * `math.sin(x)`, `math.cos(x)`, `math.tan(x)`: Retorna el seno, coseno y tangente de `x` (en radianes). * `math.pi`: Retorna el valor de `π` (pi). ### 3. **Módulo** (Generación Aleatoria): * `random.random()`: Retorna un número flotante aleatorio entre 0.0 y 1.0. * `random.randint(a, b)`: Retorna un entero aleatorio entre `a` y `b` (ambos inclusive). * `random.choice(seq)`: Retorna un elemento aleatorio de una secuencia (como una lista). * `random.shuffle(seq)`: Baraja una secuencia (lista) en su lugar. * `random.sample(population, k)`: Retorna una lista de tamaño `k` con elementos aleatorios sin repetición de la `population`. * `random.uniform(a, b)`: Retorna un número flotante aleatorio entre `a` y `b`. * `random.gauss(mu, sigma)`: Retorna un número siguiendo una distribución normal (gaussiana) con media `mu` y desviación estándar `sigma`.
el archivo no puede llamarse math.py porque crea un conflicto y python intenta importar ese mismo archivo, hay que ponerle otro nombre, incluso ella lo dice en el video :)
Explore algunas de las librerias, les dejo el codigo que cree para probar cada una: -Shutil: Lo usé para realizar una copia del archivo "cuento.txt" import shutil origen = "cuento.txt" destino = "copia_de_cuento.txt" shutil.copy(origen, destino) print("Archivo copiado.") -Pathlib: Lo usé para saber si un archivo existe: from pathlib import Path ruta = Path("cuento.txt") if ruta.exists(): contenido = ruta.read_text() print(f"Contenido del archivo:\n{contenido}") else: print(f"El archivo {ruta} no existe.") -Datetime: Lo usé para calcular la cantidad de dias entre dos fechas: from datetime import datetime, timedelta fecha_inicio = datetime(2020, 3, 10) fecha_fin = datetime(2024, 4, 18) diferencia = fecha_fin - fecha_inicio print(f"Días entre {fecha_inicio} y {fecha_fin}: {diferencia.days}")
Muy buena clase, ya voy entendiendo mejor cada una de las herramientas.
* algunos métodos útiles pueden ser: * datetime, time, para manejo de fechas y horas, * String, para manejo de textos, * re, para expresiones regulares para búsqueda y manipulación de texto
Ahora que explicaste que saldría un error si pones el mismo nombre de la librearía al archivo, me paso son json. Todo el ejercicio me salió un error y no sabía que era.
por si estaban leyendo la documentacion de os y tambienles costo entenderla, no esn solos, me canse y abandone, pero¡¡¡ me quede con la duda de que es una configuracion regional, al parecer es el formato que se usa por defecto para el manejo de fechas, numeros y otras variables y que varia segun regiones del mundo. EN CUANTO A RANDOM los numeros que genera no son realmente random estos se los demostare en un a entrega proxima, ya tengo en mi cabeza el codigo que escribire, si se necesitan contraseñas usen el modulo secret, si lo que necesitan es randomizar una muestra cuando manejen un dataset enorme (entrenando una red neuronal) usen numpy. RECUERDEN si necesitan que sus experimentos con random sean reproducibles leanse el metodo.seed()
La verdad que clase tan chevere en combinación con las anteriores de manipulación de documentos y la randomización.
Hola a todos encontré estas funciones interesantes: \# POWER EXPONENCIATION base = 10 exp = 3 power\_result = pow(10, 3) print(power\_result) \# Funciones trigronométricas \# 1 Convertir grados a radianes sacando el seno, coseno y tangente angle = math.radians(45) sin\_value = math.sin(angle) cos\_value = math.cos(angle) tan\_value = math.tan(angle) print(angle, sin\_value, cos\_value, tan\_value) \# 2 Logaritmos log\_result = math.log(10, 2) log10\_result = math.log10(10) print(f"Logaritmo base 2 de 10 es {log\_result}, logaritmo base 10 de 10{log10\_result}") \# Calculo Hipotenusa del triangulo lado1 = 5 lado2 = 12 \# Calculamos la hypotenusa usando el diagrama de pitagoras hypo = math.sqrt(lado1\*\*2 +lado2\*\*2) print(f"Hypotenusa del triángulo de {lado1} y {lado2} es: {hypo} ") ![](https://static.platzi.com/media/user_upload/image-44b87732-4040-404c-a1cc-172d89a8c304.jpg)![](https://static.platzi.com/media/user_upload/image-75adee23-6f71-4c15-86b1-79fa94769b46.jpg)
![](https://static.platzi.com/media/user_upload/image-27449faa-6cca-43bb-a6fc-9705f7cbb4d8.jpg)![](https://static.platzi.com/media/user_upload/image-f00da2b5-8068-4401-acf3-81944190b75d.jpg)
\## Pip (Copilot) pip (Pip Installs Packages) es una herramienta que permite instalar y gestionar bibliotecas y paquetes adicionales que no están incluidos en la biblioteca estándar de Python. Es el gestor de paquetes oficial y más utilizado en la comunidad de Python. Ademas pip facilita la instalación, actualización y gestión de paquetes, y es esencial para mantener proyectos organizados y reproducibles. Su uso junto con entornos virtuales asegura que las dependencias de diferentes proyectos no entren en conflicto. \*Ciencia de Datos y Análisis\* 1\. `numpy`: Operaciones numéricas eficientes. 2\. `pandas`: Manipulación y análisis de datos. 3\. `scipy`: Funciones científicas y de ingeniería. 4\. `matplotlib`: Gráficos y visualización de datos. 5\. `seaborn`: Visualización de datos estadísticos. 6\. `scikit-learn`: Aprendizaje automático. \*Desarrollo Web\* 1\. `Flask`: Framework para aplicaciones web. 2\. `Django`: Framework para aplicaciones web. 3\. `requests`: Biblioteca para hacer solicitudes HTTP. 4\. `beautifulsoup4`: Parsing de HTML y XML. \*IA y Machine Learning\* 1\. `TensorFlow`: Biblioteca para aprendizaje automático. 2\. `Keras`: Biblioteca para aprendizaje automático. 3\. `PyTorch`: Biblioteca para aprendizaje automático. 4\. `OpenCV`: Procesamiento de imágenes y visión artificial. \*Seguridad y Criptografía\* 1\. `cryptography`: Biblioteca para criptografía. 2\. `pycryptodome`: Biblioteca para criptografía. \*Interfaz Gráfica\* 1\. `PyQt`: Biblioteca para interfaces gráficas. 2\. `wxPython`: Biblioteca para interfaces gráficas. \*Automatización y Scripting\* 1\. `paramiko`: Biblioteca para SSH y automatización. 2\. `schedule`: Biblioteca para programación de tareas. \*Otros\* 1\. `geopy`: Biblioteca para geolocalización. 2\. `folium`: Biblioteca para mapas interactivos. 3\. `pygame`: Biblioteca para juegos.
\## Biblioteca estándar de Python (Copilot) La biblioteca estándar de Python incluye una amplia variedad de módulos y paquetes para realizar distintas tareas: *\*Módulos de sistema y archivo\** 1\. `os`: Interacción con el sistema operativo. 2\. `sys`: Acceso a variables y funciones del intérprete. 3\. `pathlib`: Manipulación de rutas y archivos. 4\. `glob`: Búsqueda de archivos según patrones. 5\. `shutil`: Operaciones de archivo y directorio. *\*Módulos de red y comunicación\** 1\. `socket`: Comunicación mediante sockets. 2\. `select`: Gestión de conexiones y eventos. 3\. `http`: Implementación del protocolo HTTP. 4\. `urllib`: Acceso a recursos web .5. `smtp`: Envío de correo electrónico. *\*Módulos de seguridad y criptografía\** 1\. `hashlib`: Funciones de hash. 2\. `hmac`: Código de autenticación de mensajes. 3\. `ssl`: Conexiones seguras mediante SSL/TLS. 4\. `crypt`: Funciones de cifrado. *\*Módulos de bases de datos\** 1\. `sqlite3`: Base de datos SQLite. 2\. `dbm`: Acceso a bases de datos DBM. *\*Módulos de interfaz gráfica\** 1\. `tkinter`: Biblioteca de interfaz gráfica. 2\. `turtle`: Gráficos vectoriales. *\*Módulos de procesamiento de datos\** 1\. `csv`: Lectura y escritura de archivos CSV. 2\. `json`: Trabajo con datos JSON. 3\. `xml`: Trabajo con datos XML. 4\. `re`: Expresiones regulares. 5\. `math`: Funciones matemáticas. *\*Otros módulos\** 1\. `argparse`: Análisis de argumentos de línea de comandos. 2\. `configparser`: Lectura de archivos de configuración. 3\. `logging`: Registro de eventos. 4\. `random`: Generación de números aleatorios. Estos son solo algunos de los paquetes disponibles en la biblioteca estándar de Python. La documentación oficial de Python proporciona una lista completa y detallada de todos los módulos y paquetes disponibles.
hex(*x*) - comvierte de int a hexadecimal Sorted - regresa una lista ordenada abs(*x*) - regresa el valor absoluto de un número
random.getstate() Retorna un objeto capturando el estado interno del generador. Este objeto puede pasarse a [`setstate()`](https://docs.python.org/es/3/library/random.html#random.setstate "random.setstate") para restaurar su estado. random.setstate(*state*) El *state* debería haberse obtenido de una llamada previa a [`getstate()`](https://docs.python.org/es/3/library/random.html#random.getstate "random.getstate"), y [`setstate()`](https://docs.python.org/es/3/library/random.html#random.setstate "random.setstate") reestablece el estado interno del generador al que tenia cuando se llamó a la función [`getstate()`](https://docs.python.org/es/3/library/random.html#random.getstate "random.getstate").
las librerías os, math y random de Python permiten realizar tareas relacionadas con el sistema operativo, cálculos matemáticos y la generación de números aleatorios. La librería os es útil para interactuar con el sistema operativo en el que se está ejecutando el programa. La librería math proporciona funciones matemáticas avanzadas, como funciones trigonométricas, logaritmos, y operaciones aritméticas más complejas La librería random permite generar números aleatorios. Esto es útil para tareas como simular sorteos, juegos, o pruebas aleatorias. Algunas de las funciones más comunes son os: Te permite interactuar con el sistema operativo (archivos, carpetas, etc.). math: Ofrece herramientas para realizar operaciones matemáticas avanzadas. random: Genera números aleatorios y permite realizar selecciones aleatorias. Estas librerías te proporcionan un conjunto básico de herramientas para trabajar con archivos, realizar cálculos y agregar aleatoriedad a tus programas
La librería `random` de Python no genera números completamente aleatorios, sino **pseudoaleatorios** 🎲. Esto significa que los números que produce provienen de un algoritmo que utiliza un valor inicial llamado **semilla** 🌱 . A partir de esta semilla, el algoritmo genera una secuencia de números que, aunque parecen aleatorios, en realidad siguen un patrón que es predecible si conoces la semilla 🔑