Publicado el 30/05/2023 12:05:00 en Programación General.
Author: MuldeR | Total de votos: 6   Vote

¿Qué es Python?

Python es un lenguaje de programación de alto nivel, interpretado y de propósito general. Fue creado a fines de la década de 1980 por Guido van Rossum y se ha convertido en uno de los lenguajes más populares en la comunidad de desarrollo. Su diseño se centra en la legibilidad del código, lo que hace que sea fácil de leer y comprender, incluso para aquellos que son nuevos en la programación.



Python se destaca por su sintaxis clara y concisa, lo que lo convierte en un lenguaje muy amigable para principiantes. Además, ofrece una amplia gama de funcionalidades y tiene una gran cantidad de bibliotecas y módulos que facilitan el desarrollo de una variedad de aplicaciones, desde programas simples hasta proyectos más complejos en campos como la inteligencia artificial, el análisis de datos y el desarrollo web.

Ventajas y características del lenguaje

Python ofrece una serie de ventajas y características que lo hacen una excelente elección para aprender a programar:

Sintaxis legible: La sintaxis clara y concisa de Python facilita la comprensión del código, lo que agiliza el proceso de aprendizaje y desarrollo.

Facilidad de aprendizaje: Python ha sido diseñado pensando en la legibilidad y la simplicidad, lo que lo convierte en un lenguaje ideal para principiantes. Incluso aquellos sin experiencia previa en programación pueden comenzar a escribir código en poco tiempo.

Versatilidad: Python es un lenguaje versátil que puede utilizarse en una amplia gama de aplicaciones, desde desarrollo web y científico hasta automatización de tareas y desarrollo de juegos.

Gran comunidad: Python cuenta con una gran comunidad de desarrolladores en constante crecimiento. Esto significa que hay una gran cantidad de recursos, bibliotecas y soporte disponibles en línea, lo que facilita el aprendizaje y el desarrollo de proyectos.

Instalación de Python

Antes de comenzar a programar en Python, necesitarás tener el lenguaje instalado en tu computadora. Afortunadamente, Python es multiplataforma y está disponible para Windows, macOS y Linux.

Windows

Visita el sitio web oficial de Python en https://www.python.org/downloads/ y desplázate hacia abajo hasta encontrar las versiones disponibles.
Descarga el instalador ejecutable de Python para Windows.
Ejecuta el instalador y asegúrate de marcar la opción "Agregar Python al PATH" durante el proceso de instalación.
Sigue las instrucciones del instalador y completa la instalación de Python.

macOS

Abre un navegador web y visita el sitio web oficial de Python en https://www.python.org/downloads/.
Desplázate hacia abajo hasta encontrar las versiones disponibles y descarga el instalador de Python para macOS.
Ejecuta el instalador descargado y sigue las instrucciones para completar la instalación de Python.

Linux

Python generalmente viene preinstalado en la mayoría de las distribuciones de Linux. Sin embargo, es posible que desees asegurarte de tener la última versión o instalarla en caso de que no esté presente. Puedes utilizar el gestor de paquetes predeterminado de tu distribución para instalar Python. Aquí tienes algunos ejemplos de comandos para diferentes distribuciones:

Ubuntu y Debian: Abre una terminal y ejecuta el siguiente comando: sudo apt-get install python3
Fedora: Abre una terminal y ejecuta el siguiente comando: sudo dnf install python3
Arch Linux: Abre una terminal y ejecuta el siguiente comando: sudo pacman -S python

Una vez que hayas completado la instalación de Python, puedes verificar si se instaló correctamente abriendo una terminal y ejecutando el siguiente comando:

python --version

Si todo está configurado correctamente, verás la versión de Python instalada en tu sistema.

Un primer script

Para el primer el primer script abriremos nuestro editor de texto favorito, en mi caso vim (en linux apt install vim).

vim script.py

Pulsamos la tecla [ i ] para insertar en vim y escribimos lo siguiente:

print("Hola DDLR")

Pulsamos las teclas [esc]+[wq] para salir y guardar.

Lo ejecutamos sencillamente con el siguiente comando:

$ python3 script.py
Hola DDLR

Variables y tipos de datos

En la programación, las variables son contenedores que nos permiten almacenar y manipular datos. En Python, no necesitamos declarar explícitamente el tipo de una variable, ya que el lenguaje es de tipado dinámico. Aquí hay algunos tipos de datos comunes en Python:

Números: Puedes utilizar variables para almacenar números enteros (int) y números de punto flotante (float). Por ejemplo:

edad = 25
altura = 1.75

Cadenas de texto: Las cadenas de texto (str) se utilizan para almacenar texto. Puedes definir una cadena utilizando comillas simples ('') o comillas dobles (""). Por ejemplo:

nombre = "Juan"
mensaje = '¡Hola, mundo!'

Booleanos: Los valores booleanos (bool) representan la verdad o la falsedad. Pueden ser True (verdadero) o False (falso). Por ejemplo:

es_mayor_de_edad = True
es_estudiante = False

Operadores y expresiones

Los operadores nos permiten realizar operaciones en los datos. Aquí hay algunos ejemplos de operadores comunes en Python:

Operadores aritméticos: Estos operadores se utilizan para realizar operaciones matemáticas. Por ejemplo:

a = 5
b = 2

suma = a + b  # 7
resta = a - b  # 3
multiplicacion = a * b  # 10
division = a / b  # 2.5

Operadores de comparación: Estos operadores se utilizan para comparar valores y devuelven un valor booleano. Por ejemplo:

x = 10
y = 5

igual = x == y  # False
distinto = x != y  # True
mayor = x > y  # True
menor_o_igual = x <= y  # False

Operadores lógicos: Estos operadores se utilizan para combinar expresiones lógicas y devuelven un valor booleano. Por ejemplo:

p = True
q = False

and_logico = p and q  # False
or_logico = p or q  # True
not_logico = not p  # False

Estructuras de control

Las estructuras de control nos permiten controlar el flujo de ejecución de un programa. Aquí hay algunos ejemplos de estructuras de control en Python:

Condicionales (if-else): Estas estructuras nos permiten ejecutar diferentes bloques de código según una condición. Por ejemplo:

edad = 18

if edad >= 18:
    print("Eres mayor de edad.")
else:
    print("Eres menor de edad.")

Bucles (for y while): Estas estructuras nos permiten repetir una serie de instrucciones varias veces. Por ejemplo:

for i in range(5):
    print(i)  # Imprime los números del 0 al 4

numero = 1
while numero <= 10:
    print(numero)  # Imprime
    numero += 1

Funciones y modularidad

Las funciones nos permiten encapsular un conjunto de instrucciones y reutilizarlas en diferentes partes de nuestro programa. Aquí hay un ejemplo de cómo definir y llamar una función en Python:

def saludar(nombre):
    print("¡Hola, " + nombre + "!")

saludar("Juan")  # Llama a la función y muestra "¡Hola, Juan!"

Las funciones pueden aceptar parámetros y devolver valores utilizando la palabra clave return. Por ejemplo:

def suma(a, b):
    resultado = a + b
    return resultado

resultado_suma = suma(3, 5)  # Llama a la función y guarda el resultado en una variable
print(resultado_suma)  # Muestra 8

Manejo de errores y excepciones

El manejo de errores nos permite controlar situaciones inesperadas que pueden ocurrir durante la ejecución de un programa. Podemos utilizar bloques try-except para capturar y manejar las excepciones. Por ejemplo:

try:
    x = 10 / 0  # Genera una excepción de división por cero
except ZeroDivisionError:
    print("Error: División por cero no permitida")

Podemos capturar excepciones específicas y realizar acciones diferentes según el tipo de excepción.

Estructuras de datos

Las estructuras de datos son formas de organizar y almacenar datos de manera eficiente en un programa. Python proporciona varias estructuras de datos incorporadas que nos permiten manejar diferentes tipos de información de manera conveniente.

Listas:

Una lista es una colección ordenada y mutable de elementos en Python. Puedes almacenar diferentes tipos de datos en una lista, y puedes modificar, agregar y eliminar elementos según sea necesario. Para crear una lista, utiliza corchetes [ ] y separa los elementos por comas. Aquí tienes un ejemplo:

numeros = [1, 2, 3, 4, 5]
nombres = ["Juan", "María", "Carlos"]
mezclado = [1, "dos", True, 3.14]

Puedes acceder a los elementos de una lista utilizando índices numéricos. Por ejemplo, numeros[0] devolvería el primer elemento de la lista 'numeros'.

Tuplas:

Una tupla es similar a una lista, pero a diferencia de las listas, las tuplas son inmutables, lo que significa que no se pueden modificar una vez creadas. Las tuplas se crean utilizando paréntesis ( ) en lugar de corchetes. Aquí tienes un ejemplo:

coordenadas = (10, 20)
punto = ("x", "y", "z")

Puedes acceder a los elementos de una tupla utilizando índices numéricos de la misma manera que en las listas.

Diccionarios:

Un diccionario es una estructura de datos que almacena pares clave-valor. Cada elemento en un diccionario tiene una clave única asociada a un valor. Los diccionarios son útiles para almacenar y acceder rápidamente a datos utilizando una clave en lugar de un índice numérico. Para crear un diccionario, utiliza llaves { } y separa las claves y los valores con dos puntos :. Aquí tienes un ejemplo:

estudiante = {
    "nombre": "Juan",
    "edad": 20,
    "curso": "Python",
}

Puedes acceder a los valores de un diccionario utilizando las claves. Por ejemplo, estudiante["nombre"] devolvería el valor asociado a la clave "nombre".

Conjuntos:

Un conjunto es una colección desordenada de elementos únicos. Los conjuntos son útiles para realizar operaciones matemáticas como uniones, intersecciones y diferencias entre conjuntos. Para crear un conjunto, utiliza llaves { } o la función set(). Aquí tienes un ejemplo:

numeros = {1, 2, 3, 4, 5}
vocales = set(["a", "e", "i", "o", "u"])

Puedes realizar operaciones como agregar elementos a un conjunto, eliminar elementos y realizar operaciones entre conjuntos.

Funciones avanzadas

En Python, las funciones pueden tener características adicionales que las hacen más flexibles y poderosas. A continuación hay algunas funciones avanzadas que puedes utilizar.

Argumentos opcionales:
Los argumentos opcionales permiten proporcionar valores predeterminados a los parámetros de una función. Esto significa que puedes llamar a una función sin proporcionar valores para esos parámetros y utilizar los valores predeterminados en su lugar. Aquí hay un ejemplo:

def saludar(nombre, saludo="Hola"):
    print(saludo + ", " + nombre + "!")

saludar("Juan")  # Muestra "Hola, Juan!"
saludar("María", "Hola, buenos días")  # Muestra "Hola, buenos días, María!"

En el ejemplo anterior, el parámetro saludo tiene un valor predeterminado de "Hola". Si no se proporciona un valor para saludo, se utilizará el valor predeterminado.

Argumentos de palabra clave:

Los argumentos de palabra clave permiten pasar argumentos a una función utilizando su nombre correspondiente. Esto proporciona una forma más explícita de pasar los argumentos y evita confusiones en el orden de los mismos. Aquí hay un ejemplo:

def calcular_precio(total, descuento, impuestos):
    precio_final = total - descuento + impuestos
    return precio_final

precio = calcular_precio(total=100, descuento=10, impuestos=5)
print(precio)  # Muestra 95

En el ejemplo anterior, los argumentos se pasan utilizando sus nombres correspondientes en lugar de su posición.

Generación de números y cadenas aleatorias:

Python proporciona un módulo llamado random que nos permite generar números y cadenas aleatorias. Aquí hay un ejemplo de cómo utilizarlo:

import random

numero_aleatorio = random.randint(1, 100)  # Genera un número entero aleatorio entre 1 y 100
print(numero_aleatorio)

cadena_aleatoria = random.choice(["manzana", "banana", "naranja"])  # Elige una cadena aleatoria de la lista
print(cadena_aleatoria)

El módulo random proporciona muchas más funciones para generar números y cadenas aleatorias. Puedes explorar la documentación oficial para obtener más información.

Programación Orientada a Objetos (POO)

La Programación Orientada a Objetos es un paradigma de programación que se basa en la creación de objetos, los cuales son instancias de clases. Los objetos tienen propiedades (atributos) y comportamientos (métodos) asociados. Veamos con algunos conceptos fundamentales de la POO.

Clases y objetos:

Una clase es una plantilla que define la estructura y el comportamiento de un tipo de objeto. Los objetos son instancias de una clase particular. En Python, se define una clase utilizando la palabra clave class. Aquí tienes un ejemplo de cómo definir una clase Perro:

class Perro:
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad

    def ladrar(self):
        print("¡Guau!")

# Crear un objeto de la clase Perro
mi_perro = Perro("Max", 3)
print(mi_perro.nombre)  # Muestra "Max"
print(mi_perro.edad)  # Muestra 3
mi_perro.ladrar()  # Muestra "¡Guau!"

En el ejemplo anterior, la clase Perro tiene un método especial llamado __init__, que es un constructor utilizado para inicializar los atributos del objeto. El atributo self se refiere al objeto en sí mismo.

Herencia:

La herencia es un concepto clave en la POO que permite crear nuevas clases basadas en clases existentes. La clase nueva hereda las propiedades y los comportamientos de la clase existente, y puede agregar o modificar su propio comportamiento. Aquí te pongo un ejemplo de herencia en Python.

class Animal:
    def __init__(self, nombre):
        self.nombre = nombre

    def hacer_sonido(self):
        print("El animal hace un sonido.")

class Perro(Animal):
    def hacer_sonido(self):
        print("¡Guau!")

class Gato(Animal):
    def hacer_sonido(self):
        print("¡Miau!")

mi_perro = Perro("Max")
mi_gato = Gato("Molly")

mi_perro.hacer_sonido()  # Muestra "¡Guau!"
mi_gato.hacer_sonido()  # Muestra "¡Miau!"

En este ejemplo, la clase Perro y la clase Gato heredan de la clase base Animal. Cada clase hija tiene su propia implementación del método hacer_sonido.

Encapsulación, abstracción y polimorfismo:

La POO también se basa en otros conceptos como la encapsulación, la abstracción y el polimorfismo. La encapsulación se refiere a la ocultación de los detalles internos de una clase y proporciona interfaces para interactuar con los objetos. La abstracción permite crear clases abstractas que definen una estructura general para subclases más específicas. El polimorfismo permite que diferentes clases implementen métodos con el mismo nombre pero con comportamientos diferentes.

# Encapsulación y Abstracción

class Vehiculo:
    def __init__(self, marca, modelo):
        self.marca = marca
        self.modelo = modelo
        self._kilometraje = 0

    def conducir(self, distancia):
        self._kilometraje += distancia

    def obtener_kilometraje(self):
        return self._kilometraje

# Polimorfismo

class Automovil(Vehiculo):
    def __init__(self, marca, modelo, color):
        super().__init__(marca, modelo)
        self.color = color

    def conducir(self, distancia):
        super().conducir(distancia)
        print(f"El automóvil {self.marca} {self.modelo} ha recorrido {distancia} km.")

class Camion(Vehiculo):
    def __init__(self, marca, modelo, carga_maxima):
        super().__init__(marca, modelo)
        self.carga_maxima = carga_maxima

    def conducir(self, distancia):
        super().conducir(distancia)
        print(f"El camión {self.marca} {self.modelo} ha recorrido {distancia} km.")

# Crear objetos y utilizar polimorfismo

auto = Automovil("Toyota", "Corolla", "Rojo")
auto.conducir(100)
print(f"Kilometraje del automóvil: {auto.obtener_kilometraje()}")

camion = Camion("Volvo", "FH16", 5000)
camion.conducir(200)
print(f"Kilometraje del camión: {camion.obtener_kilometraje()}")

Manejo de archivos

Python proporciona funciones y métodos integrados para el manejo de archivos. Puedes abrir archivos, leer su contenido, escribir en ellos y cerrarlos de manera controlada.

Abrir y cerrar archivos:

Para abrir un archivo, puedes utilizar la función open() especificando el nombre del archivo y el modo de apertura. El modo de apertura puede ser "r" para lectura, "w" para escritura o "a" para añadir contenido al final del archivo. Después de trabajar con el archivo, es importante cerrarlo utilizando el método close() para liberar los recursos del sistema. Aquí tienes un ejemplo:

archivo = open("miarchivo.txt", "w")
archivo.write("Hola, este es un archivo de ejemplo.")
archivo.close()

Leer contenido de un archivo:

Para leer el contenido de un archivo, puedes utilizar los métodos read() o readlines(). El método read() devuelve todo el contenido del archivo como una cadena, mientras que el método readlines() devuelve una lista donde cada elemento es una línea del archivo. Aquí tienes un ejemplo:

archivo = open("miarchivo.txt", "r")
contenido = archivo.read()
print(contenido)

archivo = open("miarchivo.txt", "r")
lineas = archivo.readlines()
for linea in lineas:
    print(linea)

Manejo de excepciones:

En Python, puedes utilizar bloques try-except para manejar las excepciones que pueden ocurrir durante la ejecución de un programa. Esto te permite controlar los errores de manera controlada y tomar acciones específicas en caso de que ocurran. Aquí tienes un ejemplo:

try:
    archivo = open("archivo_inexistente.txt", "r")
    contenido = archivo.read()
    print(contenido)
    archivo.close()
except FileNotFoundError:
    print("El archivo no existe.")

En el ejemplo anterior, intentamos abrir un archivo que no existe, lo cual genera una excepción FileNotFoundError. El bloque except captura esa excepción y muestra un mensaje adecuado.

Recuerda que es importante manejar las excepciones de manera adecuada para evitar que tu programa se detenga abruptamente en caso de errores inesperados.

Escribir en archivos:

Para escribir en un archivo, puedes utilizar el modo de apertura "w" al abrir el archivo. Esto borrará el contenido existente del archivo (si lo hubiera) y te permitirá escribir nuevos datos.

archivo = open("miarchivo.txt", "w")
archivo.write("Este es un ejemplo de escritura en un archivo.
")
archivo.write("Aquí agregamos otra línea al archivo.")
archivo.close()

En este ejemplo, utilizamos el método write() para escribir en el archivo. Cada llamada a write() agrega el texto proporcionado al final del archivo.

Operaciones adicionales con archivos

Además de las operaciones básicas de lectura y escritura, Python ofrece algunas operaciones adicionales con archivos.

Renombrar archivos: Puedes utilizar la función os.rename() para cambiar el nombre de un archivo. Aquí tienes un ejemplo:

import os

os.rename("miarchivo.txt", "nuevo_nombre.txt")

Eliminar archivos: Puedes utilizar la función os.remove() para eliminar un archivo. Aquí tienes un ejemplo:

import os

os.remove("archivo_para_eliminar.txt")

Verificar la existencia de un archivo: Puedes utilizar la función os.path.exists() para verificar si un archivo existe.

    import os

    if os.path.exists("miarchivo.txt"):
        print("El archivo existe.")
    else:
        print("El archivo no existe.")

Recuerda que es importante asegurarte de cerrar los archivos después de utilizarlos, ya sea utilizando el método close() o utilizando el bloque with, que se encarga automáticamente de cerrar el archivo una vez que se ha terminado de utilizar. Aquí tienes un ejemplo de uso del bloque with:

with open("miarchivo.txt", "r") as archivo:
    contenido = archivo.read()
    print(contenido)

En este caso, no necesitas cerrar el archivo explícitamente, ya que el bloque with se encargará de hacerlo por ti.

Módulos y Paquetes

En Python, un módulo es un archivo que contiene código Python que puede ser utilizado en otros programas. Un paquete, por otro lado, es una forma de organizar y estructurar módulos relacionados en directorios. Los módulos y paquetes nos permiten organizar y reutilizar nuestro código de manera efectiva. Veamos cómo trabajar con ellos:
Importar módulos

Para utilizar un módulo en Python, primero debemos importarlo en nuestro programa. Esto se puede hacer utilizando la declaración import.

import math

# Utilizar la función sqrt() del módulo math
resultado = math.sqrt(25)
print(resultado)  # Muestra 5.0

En este ejemplo, importamos el módulo math y utilizamos su función sqrt() para calcular la raíz cuadrada de 25.

También es posible importar solo partes específicas de un módulo utilizando la declaración from ... import. Por ejemplo:

from math import sqrt

# Utilizar la función sqrt() directamente sin el prefijo "math."
resultado = sqrt(25)
print(resultado)  # Muestra 5.0

En este caso, solo importamos la función sqrt() del módulo math, por lo que podemos utilizarla directamente sin mencionar el prefijo "math.".

Crear módulos propios:

Además de utilizar los módulos integrados de Python, también puedes crear tus propios módulos para organizar y reutilizar tu código. Para hacerlo, simplemente crea un archivo con extensión .py que contenga el código que deseas utilizar como módulo.

Supongamos que creamos un archivo llamado operaciones.py con el siguiente contenido:

def suma(a, b):
    return a + b

def resta(a, b):
    return a - b

Luego, en otro archivo Python, podemos importar y utilizar este módulo personalizado de la siguiente manera:

import operaciones

resultado = operaciones.suma(5, 3)
print(resultado)  # Muestra 8

resultado = operaciones.resta(10, 4)
print(resultado)  # Muestra 6

Paquetes:

Los paquetes son directorios que contienen módulos relacionados. Para crear un paquete, simplemente crea un directorio y coloca los módulos relacionados dentro de él. También puedes agregar un archivo __init__.py vacío dentro del directorio para indicar que es un paquete válido. Aquí tienes un ejemplo de cómo trabajar con paquetes:

Supongamos que tenemos la siguiente estructura de directorios y archivos:

markdown

mi_paquete/
    __init__.py
    operaciones.py
    utilidades.py

En el archivo operaciones.py, podríamos tener funciones para realizar operaciones matemáticas, mientras que en el archivo utilidades.py, podríamos tener funciones de utilidad general. Luego, en otro archivo Python, podemos importar y utilizar estos módulos del paquete de la siguiente manera:

from mi_paquete import operaciones, utilidades

resultado = operaciones.suma(5, 3)
print(resultado)  # Muestra 
resultado = operaciones.suma(5, 3)
print(resultado)  # Muestra 8

resultado = operaciones.resta(10, 4)
print(resultado)  # Muestra 6

nombre = utilidades.obtener_nombre_completo("John", "Doe")
print(nombre)  # Muestra "John Doe"

En este ejemplo, importamos los módulos operaciones y utilidades desde el paquete mi_paquete. Luego, utilizamos las funciones suma() y resta() del módulo operaciones, así como la función obtener_nombre_completo() del módulo utilidades.
Uso de alias en importaciones

En Python, también puedes utilizar alias para los nombres de los módulos y paquetes importados. Esto puede ser útil si deseas utilizar un nombre más corto o si hay conflictos de nombres.

import math as m

resultado = m.sqrt(25)
print(resultado)  # Muestra 5.0

En este ejemplo, importamos el módulo math con el alias m, por lo que podemos utilizar m.sqrt() en lugar de math.sqrt().
Importar todos los miembros de un módulo

En algunos casos, es posible que desees importar todos los miembros de un módulo en lugar de especificarlos individualmente. Puedes hacerlo utilizando la declaración from ... import *. Sin embargo, esta práctica no se recomienda ampliamente, ya que puede generar conflictos de nombres y dificultar la comprensión del código. Aquí tienes un ejemplo:

from math import *

resultado = sqrt(25)
print(resultado)  # Muestra 5.0

En este caso, importamos todos los miembros del módulo math y podemos utilizar sqrt() directamente sin mencionar el prefijo "math.".

Bases de datos SQL

Para conectar con MySQL desde Python, puedes utilizar el módulo mysql-connector-python, que proporciona una interfaz para interactuar con bases de datos MySQL. Asegúrate de tener instalado el módulo ejecutando el siguiente comando:

pip install mysql-connector-python

Una vez instalado, puedes utilizar el siguiente código como ejemplo para establecer una conexión con MySQL y realizar consultas:

import mysql.connector

# Establecer la conexión
conexion = mysql.connector.connect(
    host="localhost",
    user="usuario",
    password="contraseña",
    database="basedatos"
)

# Crear un objeto cursor
cursor = conexion.cursor()

# Ejecutar una consulta
cursor.execute("SELECT * FROM tabla")

# Obtener los resultados de la consulta
resultados = cursor.fetchall()

# Iterar sobre los resultados
for fila in resultados:
    print(fila)

# Cerrar el cursor y la conexión
cursor.close()
conexion.close()

En este ejemplo, debes reemplazar "localhost" con la dirección del servidor de MySQL, "usuario" y "contraseña" con las credenciales de acceso a la base de datos y "basedatos" con el nombre de la base de datos a la que deseas conectarte. Además, reemplaza "tabla" con el nombre de la tabla de la que deseas obtener los datos.

El código establece una conexión, crea un objeto cursor para ejecutar consultas, ejecuta una consulta SELECT, obtiene los resultados y los muestra en la consola. Por último, se cierran el cursor y la conexión.

Recuerda manejar adecuadamente las excepciones al conectar con la base de datos y realizar operaciones para garantizar un código robusto. Además, puedes utilizar métodos adicionales del módulo mysql-connector-python para realizar inserciones, actualizaciones y otras operaciones con la base de datos.

CREATE TABLE

Para crear una tabla en MySQL, puedes utilizar la consulta CREATE TABLE. Aquí tienes un ejemplo:

import mysql.connector

# Establecer la conexión
conexion = mysql.connector.connect(
    host="localhost",
    user="usuario",
    password="contraseña",
    database="basedatos"
)

# Crear un objeto cursor
cursor = conexion.cursor()

# Ejecutar una consulta CREATE TABLE
cursor.execute("CREATE TABLE empleados (id INT AUTO_INCREMENT PRIMARY KEY, nombre VARCHAR(50), edad INT)")

# Cerrar el cursor y la conexión
cursor.close()
conexion.close()

En este ejemplo, se crea una tabla llamada "empleados" con tres columnas: "id" (entero con autoincremento), "nombre" (cadena de caracteres) y "edad" (entero).

DROP TABLE

Para eliminar una tabla en MySQL, puedes utilizar la consulta DROP TABLE. Aquí tienes un ejemplo:

import mysql.connector

# Establecer la conexión
conexion = mysql.connector.connect(
    host="localhost",
    user="usuario",
    password="contraseña",
    database="basedatos"
)

# Crear un objeto cursor
cursor = conexion.cursor()

# Ejecutar una consulta DROP TABLE
cursor.execute("DROP TABLE empleados")

# Cerrar el cursor y la conexión
cursor.close()
conexion.close()

En este ejemplo, se elimina la tabla "empleados".

INSERT

Para insertar datos en una tabla en MySQL, puedes utilizar la consulta INSERT INTO. Aquí tienes un ejemplo:

import mysql.connector

# Establecer la conexión
conexion = mysql.connector.connect(
    host="localhost",
    user="usuario",
    password="contraseña",
    database="basedatos"
)

# Crear un objeto cursor
cursor = conexion.cursor()

# Ejecutar una consulta INSERT INTO
consulta = "INSERT INTO empleados (nombre, edad) VALUES (%s, %s)"
valores = ("John Doe", 30)
cursor.execute(consulta, valores)

# Confirmar los cambios
conexion.commit()

# Cerrar el cursor y la conexión
cursor.close()
conexion.close()

En este ejemplo, se inserta un nuevo empleado en la tabla "empleados" con nombre "John Doe" y edad 30.

UPDATE

Para actualizar datos en una tabla en MySQL, puedes utilizar la consulta UPDATE. Aquí tienes un ejemplo:

import mysql.connector

# Establecer la conexión
conexion = mysql.connector.connect(
    host="localhost",
    user="usuario",
    password="contraseña",
    database="basedatos"
)

# Crear un objeto cursor
cursor = conexion.cursor()

# Ejecutar una consulta UPDATE
consulta = "UPDATE empleados SET edad = %s WHERE id = %s"
valores = (35, 1)
cursor.execute(consulta, valores)

# Confirmar los cambios
conexion.commit()

# Cerrar el cursor y la conexión
cursor.close()
conexion.close()

En este ejemplo, se actualiza la edad del empleado con ID 1 a 35 en la tabla "empleados".

DELETE

Para eliminar registros de una tabla en MySQL, puedes utilizar la consulta DELETE FROM. Aquí tienes un ejemplo:

import mysql.connector

# Establecer la conexión
conexion = mysql.connector.connect(
    host="localhost",
    user="usuario",
    password="contraseña",
    database="basedatos"
)

# Crear un objeto cursor
cursor = conexion.cursor()

# Ejecutar una consulta DELETE
consulta = "DELETE FROM empleados WHERE id = %s"
valores = (1,)
cursor.execute(consulta, valores)

# Confirmar los cambios
conexion.commit()

# Cerrar el cursor y la conexión
cursor.close()
conexion.close()

En este ejemplo, se elimina el empleado con ID 1 de la tabla "empleados".

Para aprender más sobre SQL pudes consultar el siguiente enlace: Tutorial de SQL general.

Despedida y aclaraciones

Con esta introducción general a Python ya estarás listo para empezar a hacer tus propios programas, recuerda consultar la documentación oficial y los buscadores para ir ampliando tu conocimiento a medida que encuentres situaciones que no sepas como resolver. Para cualquier duda o sugerencia puedes emplear los comentarios a continuación o contactarnos por el discord de Diosdelared.

Saludos!!