Fundamentos de Programación y Python
Fundamentos de Programación con Python para Principiantes
Instalación y Uso Básico de Python en Windows y Mac
Semántica y Sintaxis en Programación Python
Práctica: Te doy la bienvenida a los ejercicios interactivos
Manejo de Cadenas y Operaciones Básicas en Python
Tipos de Datos en Python: Enteros, Flotantes y Booleanos
Dominio de la función `print` en Python: usos y formatos avanzados
Operaciones matemáticas avanzadas en Python: módulo, potencia y más
Entrada de información y manejo de tipos de datos en Python
Colección y Procesamiento de Datos en Python
Manipulación de Listas en Python: Creación, Indexación y Métodos Básicos
Copiar listas en Python sin compartir memoria con slicing
Manejo de Matrices y Tuplas en Python
Matrices en Juegos y Imágenes con Python
Diccionarios en Python: Uso y Manipulación de Datos
Control de Flujo en Python
Estructuras Condicionales en Programación: Uso de If, Else y Elif
Iteración y control de flujo con bucles en Python
Iteradores y Generadores en Python: Uso Eficiente de Memoria
Listas por comprensión en Python: creación y optimización de listas
Funciones y Manejo de Excepciones en Python
Funciones y Parámetros en Python: Crea una Calculadora Básica
Funciones Lambda en Python: Uso y Aplicaciones Prácticas
Recursividad en Python: Factoriales y Serie de Fibonacci
Manejo de Excepciones y Errores en Python
Programación Orientada a Objetos en Python
Programación Orientada a Objetos en Python: Clases y Métodos Básicos
Gestión de Biblioteca con Programación Orientada a Objetos
Herencia y Polimorfismo en Programación Orientada a Objetos
Programación Orientada a Objetos: Implementación de Clases y Herencia
Polimorfismo en Programación Orientada a Objetos
Herencia y Uso de la Función super() en Python
Programación Orientada a Objetos: Atributos, Métodos y `super()` en Python
Lectura y escritura de archivos
Manipulación de Archivos TXT y CSV en Python
Manipulación de archivos CSV con Python: lectura y escritura
Manejo de Archivos JSON en Python para Aplicaciones Web y APIs
Biblioteca estándar de Python
Uso Eficiente de la Biblioteca Estándar de Python
Uso de las librerías OS, Math y Random en Python
Análisis de Datos de Ventas con Python y Statistics
Desarrollo del juego Batalla Naval en Python
Conceptos avanzados de Python
Programación Avanzada en Python: POO, Excepciones y Proyectos
Escritura de Código Pytónico y Buenas Prácticas en Python
Comentarios y Docstrings: Buenas Prácticas en Programación
Tiempo de vida y alcance de variables en Python
Anotaciones de Tipo en Python para Código Más Legible
Validación de Tipos y Manejo de Excepciones en Python
Estructuras de Datos Avanzadas en Python: Collection y Enumeraciones
Decoradores
Decoradores en Python: Extiende Funcionalidades de Funciones
Uso de Decoradores Anidados y con Parámetros en Python
Decoradores en Programación Orientada a Objetos en Python
Métodos y estructura de clases en Python
Uso de Métodos Mágicos en Python
Sobrecarga de Operadores en Python: Personaliza Comportamiento de Clases
Ejecutar scripts Python con `if __name__ == '__main__'`
Metaprogramación en Python: Métodos `__new__` y `__init__`
Uso de *args y **kwargs en funciones de Python
Métodos y Atributos Privados y Protegidos en Python
Uso de Property en Python: Getter, Setter y Eliminación de Atributos
Métodos estáticos y de clase en Python
Programación concurrente y asíncrona
Concurrencia y Paralelismo en Python: Técnicas y Librerías Básicas
Concurrencia y Paralelismo en Python: `threading` y `multiprocessing`
Asincronismo en Python con AsyncIO y Corrutinas
Sincronía y Concurrencia en Python: Teoría y Práctica
Creación de módulos y paquetes
Módulos y Paquetes en Python: Reutilización y Organización de Código
Uso de Paquetes y Subpaquetes en Python con Visual Studio Code
Publicación de Paquetes Python en PyPI
Proyecto final
Sistema de Gestión de Reservas en Python Avanzado
Sistema de Gestión de Reservas en Python Avanzado
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Uso de las librerías OS, Math y Random en Python
34/63Recursos
¿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 31
Preguntas 0
Ordenar por:
**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`.
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 🔑
Carli explica muy bien, nada en contra de ella.
Pero la verdad, la ruta no nos explica el verdadero concepto o mas bien, entramos a tratar de entender el concepto sin entender muy bien el objetivo.
Entonces es como que a mi me den un Martillo, un Serrucho, unos clavos, una madera, un destornillador, unos tornillos, pero sino se como usarlos ni para que, seguramente no lo hago.
Entonces aqui nos explica como usarlo, pero no para que sirve o que podria resolver con tanta herramienta.
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.
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 :)
Con ayuda de ChatGPT pude extraer los que se utilizan con mas frecuencia:
1\. Manejo de archivos:
\- open(file, mode): Abre un archivo en el modo especificado (lectura, escritura, etc.).
\- read(), readline(), readlines(): Lee el contenido de un archivo completo o línea por línea.
\- write(string): Escribe texto en un archivo.
2\. Manejo de cadenas:
\- str.split(separator): Divide una cadena en una lista según un separador.
\- str.join(iterable): Une elementos de un iterable en una sola cadena.
\- str.strip(), str.lstrip(), str.rstrip(): Elimina espacios o caracteres de los extremos de una cadena.
\- str.replace(old, new): Reemplaza partes de una cadena.
\- str.upper(), str.lower(), str.capitalize(): Cambia el formato de las cadenas (mayúsculas, minúsculas, etc.).
3\. Listas:
\- list.append(element): Agrega un elemento al final de la lista.
\- list.extend(iterable): Agrega múltiples elementos a la lista desde un iterable.
\- list.sort(key=None, reverse=False): Ordena los elementos de la lista en su lugar.
\- list.pop(index): Elimina y devuelve el elemento en el índice especificado.
4\. Diccionarios:
\- dict.keys(), dict.values(), dict.items(): Obtiene las claves, valores o pares clave-valor.
\- dict.get(key, default): Obtiene el valor de una clave, o un valor predeterminado si no existe.
\- dict.update(other\_dict): Actualiza el diccionario con pares clave-valor de otro diccionario.
5\. Funciones matemáticas:
\- abs(x): Devuelve el valor absoluto de un número.
\- round(number, ndigits): Redondea un número a la cantidad especificada de decimales.
\- min(iterable), max(iterable): Devuelve el valor mínimo o máximo de un iterable.
\- sum(iterable): Suma todos los elementos de un iterable.
6\. Colecciones:
\- len(iterable): Devuelve el número de elementos en un iterable.
\- enumerate(iterable, start=0): Devuelve un iterable con índices y valores.
\- zip(\*iterables): Combina múltiples iterables en tuplas.
7\. Fechas y horas:
\- datetime.now(): Obtiene la fecha y hora actuales.
\- date.today(): Devuelve la fecha actual.
\- strftime(format): Formatea objetos de fecha y hora en cadenas.
8\. Módulos útiles:
\- os: os.getcwd(): Devuelve el directorio actual. os.listdir(): Lista archivos en un directorio.
\- sys: sys.argv: Obtiene los argumentos de línea de comandos.
\- json: json.loads(): Convierte una cadena JSON en un diccionario. json.dumps(): Convierte un diccionario en una cadena JSON.
\- re: re.search(pattern, string): Busca patrones en una cadena usando expresiones regulares.
\- random: random.randint(a, b): Genera un número entero aleatorio entre `a` y `b`.
Esa funcion de shuffle es una chulada!!!
Justo como el Spotify!
* 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
Hay un tema que deberían aclarar, en la clase pasada tocaron los conceptos de **Librería Estándar de Python** e indicaron que es un conjunto de herramientas para facilitar el desarrollo.
* Una librería es un conjunto de módulos., que te da las herramientas necesarias para agregar funcionalidades reutilizando código.
* Un módulo resuelve problemas específicos, tiene clases, atributos y funciónes.
* Un módulo es un elemento de una libreria y pueden interactuar entre si, pero cada módulo resuelve temas específicos.
Indicaron que Math, random, socket, css, json son módulos y no librerías, pues están contenidos dentro de la Librería Estándar de Python.
Ahora indican librería OS, match y Random.
```python
import random
opcions = ['Ganaste una moneda', 'Ganaste un cupon', 'Ganaste un chocolote', 'No ganaste nada ', 'Ganaste una mosca']
oselect = random.choice(opcions)
probability = round(random.random() * 100, 2) #random.random = Me da un numero 0 a 1 pero en este caso sin el 1 ntonces
#me daria un 0 con decimales , lo multiplico x 100 y random lo redondea y el 2 genera dos decimales al final
print(f"Resultado: {oselect} (Probabilidad: {probability}%)")
```**JUEGUITO 💚🚀**
En Python, además de los métodos de cadena, hay varios métodos disponibles en la biblioteca estándar que puedes utilizar sin importar módulos adicionales. Algunos de ellos incluyen:
1. **Métodos de listas**: como `append()`, `remove()`, `sort()`, entre otros.
2. **Métodos de conjuntos**: como `add()`, `discard()`, `union()`.
3. **Métodos de diccionarios**: como `keys()`, `values()`, `items()`.
Estos métodos te permiten manipular y operar en estructuras de datos básicas que son parte de la biblioteca estándar de Python, facilitando tareas comunes.
* `os.getcwd()`: Obtiene el directorio de trabajo actual.
* `os.chdir(path)`: Cambia el directorio de trabajo actual a `path`.
* `os.listdir(path)`: Lista todos los archivos y directorios en el directorio especificado.
* `os.mkdir(path)`: Crea un nuevo directorio en la ruta especificada.
* `os.remove(path)`: Elimina el archivo especificado.
* `os.rmdir(path)`: Elimina un directorio vacío.
* `os.path.join(path, *paths)`: Une uno o más componentes de ruta de forma correcta.
* `os.path.exists(path)`: Verifica si una ruta existe.
* `os.environ`: Permite acceder a las variables de entorno del sistema.
* `os.system(command)`: Ejecuta un comando del sistema operativo.
aqui algunos ejemplos de metodos de las librerias
\#convertir a mayusculatexto = "hola mundo"mayusculas = texto.upper()
print(mayusculas) # Salida: HOLA MUNDO
\#Ordenar listanumeros = \[5, 2, 8, 1, 3]numeros.sort()
print(numeros) # Salida: \[1, 2, 3, 5, 8]
\#obtener claves de un diccionariopersona = {"nombre": "Juan", "edad": 30, "ciudad": "Madrid"}claves = persona.keys()
print(claves) # Salida: dict\_keys(\['nombre', 'edad', 'ciudad'])
\#agrega un elemento a un conjuntonumeros = {1, 2, 3}numeros.add(4)
print(numeros) # Salida: {1, 2, 3, 4}#¿Por qué usar set? Los conjuntos no permiten elementos duplicados,# lo que los hace útiles para eliminar repetidos.
\#calcular raiz cuadradaimport math
numero = 16raiz = math.sqrt(numero)
print(raiz) # Salida: 4.0
\#obtener fecha y hora actualfrom datetime import datetime
ahora = datetime.now()
print(ahora) # Salida: 2025-03-10 19:43:21.755253 (ejemplo)
\#formatea la fecha en un string personalizadofecha\_actual = datetime.now()formato\_personalizado = fecha\_actual.strftime("%d/%m/%Y %H:%M:%S")
print(formato\_personalizado) # Salida: 10/03/2025 14:30:15
\# Crear un diccionario con información del usuario y la fecha actualimport jsonusuario = { "nombre": "Laura", "edad": 27, "registro": datetime.now().strftime("%Y-%m-%d %H:%M:%S") # Formateamos la fecha}
\# Convertir el diccionario a JSONjson\_usuario = json.dumps(usuario, indent=4)
print(json\_usuario) # Salida en formato JSON legible
Retomé el curso despues de un mes, estuve motivando mi cerebro, creo que empezando uno debe tener más motivación, es muy complejo para iniciar, bueno esta clase no. Pero si muchas.
`ramdon` no produce números aleatorios si no pseudoaleatorios, esto se hace por un algoritmo que empieza desde una numero semilla que funciona como una llave , esto no hace débil par crear contraseñas ya que si alguien averigua el método de creación del contraseñas puede vulnerar un sistema
Librería Os, Math y Random (CLASE NUEVA)
Estás ya vienen instaladas por defecto
os ayuda a interactuar con archivos
math sirve para trabajar con constantes matemáticas como por ejemplo pi
random sirve para obtener valores aleatorios, por ejemplo dentro de un conjunto de datos que declaremos
De esta manera podemos hacer un filtro para obtener solamente los archivos de texto de una manera más rápida y con menos lineas
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
```js
import os, fnmatch
print(fnmatch.filter(os.listdir("c:/Users/miusuario/Downloads"), '*.txt'))
```
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} ")
\## 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
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
```python
import random
# Establecer una semilla para resultados reproducibles
random.seed(42)
# Generar un número flotante entre 0 y 1
num_float = random.random()
print(f"Número aleatorio entre 0 y 1: {num_float}")
# Generar un entero aleatorio entre 1 y 10
num_int = random.randint(1, 10)
print(f"Entero aleatorio entre 1 y 10: {num_int}")
# Elegir un elemento aleatorio de una lista
frutas = ["manzana", "banana", "naranja", "uva", "pera"]
fruta_elegida = random.choice(frutas)
print(f"Fruta elegida aleatoriamente: {fruta_elegida}")
# Barajar una lista
numeros = [1, 2, 3, 4, 5]
random.shuffle(numeros)
print(f"Lista barajada: {numeros}")
# Seleccionar múltiples elementos únicos
seleccion = random.sample(frutas, 3)
print(f"Tres frutas seleccionadas al azar (sin repetición): {seleccion}")
# Generar un número flotante en un rango específico
temp = random.uniform(15.0, 25.0)
print(f"Temperatura aleatoria entre 15°C y 25°C: {temp:.2f}°C")
```
1. `random.random()`: Devuelve un número flotante aleatorio en el rango \[0.0, 1.0).
2. `random.randint(a, b)`: Devuelve un entero aleatorio entre `a` y `b` (incluyendo ambos extremos).
3. `random.choice(sequence)`: Devuelve un elemento aleatorio de una secuencia (como una lista o una tupla).
4. `random.shuffle(sequence)`: Mezcla (baraja) los elementos de una secuencia en su lugar.
5. `random.sample(population, k)`: Devuelve una lista de `k` elementos únicos elegidos de la población especificada.
6. `random.uniform(a, b)`: Devuelve un número flotante aleatorio en el rango \[a, b].
7. `random.seed(a=None)`: Inicializa el generador de números aleatorios con una semilla opcional para obtener resultados reproducibles.
8. `random.gauss(mu, sigma)`: Devuelve un número aleatorio siguiendo una distribución normal con media `mu` y desviación estándar `sigma`.
Estas funciones son útiles en diversas aplicaciones, como si
1. `os.getcwd()`: Obtiene el directorio de trabajo actual.
2. `os.chdir(path)`: Cambia el directorio de trabajo actual a `path`.
3. `os.listdir(path)`: Lista todos los archivos y directorios en el directorio especificado.
4. `os.mkdir(path)`: Crea un nuevo directorio en la ruta especificada.
5. `os.remove(path)`: Elimina el archivo especificado.
6. `os.rmdir(path)`: Elimina un directorio vacío.
7. `os.path.join(path, *paths)`: Une uno o más componentes de ruta de forma correcta.
8. `os.path.exists(path)`: Verifica si una ruta existe.
9. `os.environ`: Permite acceder a las variables de entorno del sistema.
10. `os.system(command)`: Ejecuta un comando del sistema operativo.
Estas funciones son útiles para la manipulación de archivos y directorios, así como para interactuar con el entorno del sistema. ¿Te gustaría saber más sobre alguna en particular?
##### Dijiste:
Que es lo más importante o lo mas usado en la libreria MATHde Python?
###### ChatGPT dijo:
La librería `math` de Python proporciona funciones matemáticas básicas y avanzadas. Aquí tienes algunas de las funciones más importantes y comúnmente usadas:
1. `math.sqrt(x)`: Calcula la raíz cuadrada de `x`.
2. `math.pow(x, y)`: Eleva `x` a la potencia `y`.
3. `math.factorial(x)`: Calcula el factorial de `x`.
4. `math.sin(x)`, `math.cos(x)`, `math.tan(x)`: Calcula el seno, coseno y tangente de `x` (en radianes).
5. `math.log(x, base)`: Calcula el logaritmo de `x` en la base especificada (base natural si no se especifica).
6. `math.exp(x)`: Calcula el número de Euler elevado a la potencia `x`.
7. `math.pi`: Constante que representa el valor de π.
8. `math.e`: Constante que representa el número de Euler (aproximadamente 2.718).
9. `math.ceil(x)`: Redondea `x` hacia arriba al entero más cercano.
10. `math.floor(x)`: Redondea `x` hacia abajo al entero más cercano
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?