Python es un lenguaje de programación de alto nivel que se caracteriza por su sintaxis simple y legible. Es ampliamente utilizado en una variedad de campos, desde desarrollo web y aplicaciones de escritorio hasta análisis de datos y aprendizaje automático. Aquí tienes una descripción más detallada de Python:

Python es un lenguaje de programación, lo que significa que es una herramienta que permite a los programadores escribir instrucciones que una computadora puede entender y ejecutar.

Python es un lenguaje de alto nivel que se enfoca en la facilidad de uso y la legibilidad del código. Su sintaxis es clara y se asemeja al lenguaje humano, lo que facilita que los programadores escriban y mantengan código.

Python es un lenguaje interpretado, lo que significa que no requiere un proceso de compilación. Los programas Python se ejecutan directamente a través de un intérprete, lo que agiliza el proceso de desarrollo y prueba de código.

Python es compatible con una variedad de sistemas operativos, incluyendo Windows, macOS y Linux. Esto significa que el mismo código Python puede ejecutarse en diferentes plataformas sin modificaciones.

Python es un lenguaje orientado a objetos. La programación orientada a objetos es una metodología de diseño de software que se basa en la creación y manipulación de objetos, lo que permite una organización y reutilización eficiente del código.

Python incluye una extensa biblioteca estándar que contiene módulos y paquetes que abordan una amplia variedad de tareas, desde manipulación de archivos y procesamiento de texto hasta redes y desarrollo web. Esto hace que Python sea un lenguaje muy versátil.

Python tiene una comunidad de desarrolladores y usuarios activa y dedicada. Esto significa que hay una abundancia de recursos, como bibliotecas de terceros, documentación y foros de ayuda.

Python se utiliza en una amplia variedad de aplicaciones, incluyendo desarrollo web (con marcos de trabajo como Django y Flask), análisis de datos (con bibliotecas como NumPy y pandas), aprendizaje automático (con bibliotecas como scikit-learn y TensorFlow), automatización de tareas y más.

Python es ampliamente utilizado en la educación y se considera un lenguaje de programación accesible para principiantes. Su sintaxis clara y legible lo convierte en una excelente opción para enseñar programación.

Python es un proyecto de código abierto, lo que significa que su código fuente está disponible públicamente. Esto permite a la comunidad de desarrolladores contribuir al desarrollo y mejora del lenguaje.

Python es conocido por su simplicidad, flexibilidad y poder, lo que lo convierte en una de las opciones más populares para programadores de todo el mundo. Es utilizado en una amplia variedad de industrias y aplicaciones, y sigue creciendo en popularidad debido a su versatilidad y a la comunidad activa que lo respalda.

Comentarios en Python

Los comentarios en Python son partes del código fuente que se utilizan para proporcionar información adicional o aclaraciones sobre el código a los programadores. Los comentarios son ignorados por el intérprete de Python y no tienen ningún impacto en la ejecución del programa. Se utilizan principalmente para hacer que el código sea más comprensible y legible. Aquí hay algunas pautas sobre cómo usar comentarios en Python:

Comentarios de una sola línea

Para crear un comentario de una sola línea en Python, simplemente preceda el texto del comentario con el símbolo "#" (almohadilla o numeral). Todo lo que sigue después del "#" en esa línea se considera un comentario y no se ejecutará.

# Este es un comentario de una sola línea

variable = 42 # Esto es otro comentario en la misma línea

Comentarios multilínea

Si deseas agregar comentarios multilínea, puedes usar triple comillas dobles (''') o triple comillas simples (''') para encerrar el texto del comentario. Esto es útil cuando necesitas escribir comentarios más largos o comentarios que abarcan varias líneas de código.

'''

Este es un comentario que abarca varias líneas.

Puedes usar comillas dobles o simples.

''' variable = 42

NOTA: Se suelen utilizar únicamente para documentar código

Usos de los comentarios

Comentarios en el medio del código

Puedes agregar comentarios en medio del código para explicar partes específicas o dar contexto. Esto es especialmente útil cuando escribes código complejo.

# Calcular el promedio total = 0 for num in lista_de_numeros:

total += num

promedio = total / len(lista_de_numeros) # Calcular el promedio

Comentarios de documentación

Python tiene una convención llamada "docstrings" que se utiliza para proporcionar documentación en módulos, clases, funciones y métodos. Los docstrings son cadenas de texto que se encuentran en la parte superior de estas estructuras y se utilizan para describir su funcionalidad.

def suma(a, b):

"""

Esta función toma dos argumentos y devuelve la suma de ellos.

Args:

a (int): El primer número. b (int): El segundo número.

Returns:

int: La suma de a y b.

""" return a + b

Usar comentarios de manera adecuada puede hacer que tu código sea más comprensible para otros programadores y para ti mismo en el futuro. Ayudan a explicar la lógica detrás de tu código y a documentar su funcionamiento.

Tipos de datos en Python

Python es un lenguaje de programación que es conocido por su flexibilidad en el manejo de tipos de datos. A continuación, se presentan algunos de los tipos de datos más comunes en Python:

Booleanos (bool)

Representan valores de verdad. Pueden ser True (verdadero) o False (falso).

es_verdadero = True es_falso = False

Enteros (int)

Representan números enteros sin punto decimal. Pueden ser positivos o negativos.

x = 5 y = -10

Flotantes (float)

Representan números decimales o números de punto flotante.

a = 3.14 b = 0.25

Cadenas de texto (str)

Representan secuencias de caracteres. Pueden estar encerradas en comillas simples (' ') o comillas dobles (" ").

nombre = "Juan"

mensaje = 'Hola, ¿cómo estás?'

Listas (list)

Son colecciones ordenadas de elementos, que pueden ser de diferentes tipos. Se definen mediante corchetes y los elementos se separan por comas.

mi_lista = [1, 2, 3, "cuatro", 5.0]

Tuplas (tuple)

Son similares a las listas, pero son inmutables, lo que significa que no se pueden modificar una vez creadas. Se definen mediante paréntesis.

mi_tupla = (1, 2, 3, "cuatro", 5.0)

Diccionarios (dict)

Representan colecciones de pares clave-valor. Cada clave está asociada a un valor. Se definen mediante llaves y los pares clave-valor se separan por comas.

mi_diccionario = {"nombre": "Juan", "edad": 30, "ciudad": "Ejemplo"}

Conjuntos (set)

Representan colecciones no ordenadas y sin elementos duplicados. Se definen mediante llaves o con la función set().

mi_conjunto = {1, 2, 3, 4, 5}

Ningún valor (None)

Representa la ausencia de un valor. Se utiliza para indicar que una variable no tiene un valor asignado.

valor_nulo = None

Diferencia entre nulo y vacío

Valor Nulo ("None")

En Python, "None" es un valor nulo especial que se utiliza para representar la falta de un valor asignado a una variable o un objeto.

Indica explícitamente que no hay un valor válido presente en la variable, que no existe una reserva de memoria

Se utiliza cuando deseas inicializar una variable sin asignarle un valor real o para indicar que una función no devuelve ningún valor explícito.

"None" es un objeto nulo y tiene su propio tipo, "NoneType".

x = None # x se inicializa con un valor nulo

Valor Vacío

El término "vacio" se refiere generalmente a la falta de contenido o elementos en una estructura de datos como una lista, una cadena o un conjunto.

No hay un valor específico asignado a la variable o estructura, lo que resulta en una longitud, tamaño o contenido igual a cero, pero ya tiene asignada memoria, hay una referencia de memoria

El concepto de "vacío" no está relacionado con el valor "None" y puede variar según el tipo de dato. Ejemplo:

Una lista vacía:

lista_vacia = [] # Una lista sin elementos

Una cadena vacía:

cadena_vacia = "" # Una cadena sin caracteres

En resumen, "None" se refiere a la falta de un valor asignado a una variable o la indicación de que una función no tiene un valor de retorno, mientras que "vacio" se refiere generalmente a estructuras de datos que no contienen elementos o caracteres. Son conceptos diferentes, pero pueden estar relacionados en algunos contextos, ya que una variable puede inicializarse con "None" y luego asignarse un valor vacío, o una estructura de datos puede estar vacía y contener una variable con valor "None".

Operadores en Python

Operadores aritméticos:

a = 10 b = 3 # Suma

resultado = a + b # 13

# Resta

resultado = a - b # 7

# Multiplicación resultado = a * b # 30

# División

resultado = a / b # 3.33333

# División entera (cociente) resultado = a // b # 3

# Módulo (resto) resultado = a % b # 1

# Potencia resultado = a ** b # 1000

Operadores de Comparación

a = 5 b = 10

# Igual a

resultado = a == b # False

# Diferente de

resultado = a != b # True

# Mayor que

resultado = a > b # False

# Menor que

resultado = a < b # True # Mayor o igual que resultado = a >= b # False # Menor o igual que resultado = a <= b # True

Operadores de asignación

a = 5

# Asignación simple b = a # b = 5

# Asignación con operación a += 3 # a = a + 3 --> a = 8

# Asignación con operación de resta a -= 2 # a = a - 2 --> a = 6

# Asignación con operación de multiplicación a *= 4 # a = a * 4 --> a = 24

# Asignación con operación de división a /= 6 # a = a / 6 --> a = 4.0

# Asignación con operación de módulo a %= 3 # a = a % 3 --> a = 1.0

# Asignación con operación de potencia a **= 2 # a = a ** 2 --> a = 1.0

Operadores Lógicos

a = True b = False

# Operador AND

resultado = a and b # False

# Operador OR

resultado = a or b # True

# Operador NOT resultado = not a # False

Operadores de Identidad

a = [1, 2, 3] b = [1, 2, 3] c = a

# Operador is

resultado = a is b # False

# Operador is not

resultado = a is not b # True

# Comparación de identidad con el mismo objeto resultado = a is c # True

Operadores de Pertenencia

lista = [1, 2, 3]

diccionario = {'a': 1, 'b': 2} cadena = "Hola"

# Operador in

resultado = 2 in lista # True

# Operador not in

resultado = 'c' not in diccionario # True

# Operador in con cadena

resultado = 'a' in cadena # True

Cadenas

En Python, las cadenas de texto (strings) son secuencias inmutables de caracteres encerrados entre comillas simples ('') o comillas dobles (""). Aquí tienes un resumen sobre las cadenas en Python con ejemplos:

Creación de una cadena

Puedes crear una cadena asignando un valor entre comillas a una variable.

mensaje = "Hola, mundo!"

Acceso a caracteres

Puedes acceder a caracteres individuales de una cadena utilizando el índice entre corchetes.

mensaje = "Hola, mundo!" primer_caracter = mensaje[0] ultimo_caracter = mensaje[-1]

Longitud de una cadena

Puedes obtener la longitud de una cadena utilizando la función len().

mensaje = "Hola, mundo!" longitud = len(mensaje)

Slicing de cadenas

El slicing de cadenas en Python te permite extraer una porción de una cadena de caracteres. Puedes especificar un rango de índices para seleccionar un subconjunto de caracteres de la cadena original. La sintaxis general para el slicing de cadenas es:

cadena[inicio:final:paso]

inicio: Índice desde el cual comienza la extracción (inclusive). Si se omite, se toma el primer carácter (índice 0).

final: Índice en el que se detiene la extracción (exclusivo). Si se omite, se toma el último carácter.

paso: Cantidad de caracteres que se saltean al realizar el slicing. Si se omite, se toma el valor predeterminado de 1.

Aquí hay algunos ejemplos de cómo realizar slicing en cadenas:

mi_cadena = "Python es genial"

# Extraer los primeros 6 caracteres subcadena = mi_cadena[:6] # subcadena será "Python"

# Extraer los caracteres desde el índice 7 hasta el final subcadena = mi_cadena[7:]

# subcadena será "es genial"

# Extraer los caracteres desde el índice 7 hasta el índice 9 (exclusivo) subcadena = mi_cadena[7:9]

# subcadena será "es"

# Extraer cada segundo carácter subcadena = mi_cadena[::2]

# subcadena será "Pto sgna"

# Invertir la cadena subcadena = mi_cadena[::-1]

# subcadena será "laing seg se nohtyP"

Recuerda que los índices en Python comienzan desde 0, por lo que el primer carácter de una cadena tiene un índice de 0, el segundo tiene un índice de 1, y así sucesivamente.

El slicing de cadenas es una técnica muy útil para manipular y trabajar con texto en Python. Puedes utilizarlo para extraer partes específicas de una cadena, invertirla, o crear subcadenas de acuerdo con tus necesidades.

Concatenación de cadenas

Puedes concatenar dos o más cadenas utilizando el operador +.

saludo = "Hola" nombre = "Juan"

mensaje = saludo + " " + nombre # Obtiene "Hola Juan"

Repetición de cadenas

Puedes repetir una cadena utilizando el operador *.

palabra = "Hola"

repetida = palabra * 3 # Obtiene "HolaHolaHola"

Métodos de cadenas

Las cadenas en Python tienen varios métodos incorporados que puedes utilizar para realizar operaciones y manipulaciones.

mensaje = "Hola, mundo!" mayusculas = mensaje.upper() # Convierte a mayúsculas minusculas = mensaje.lower() # Convierte a minúsculas

reemplazo = mensaje.replace("mundo", "Python") # Reemplaza una subcadena

Formateo de cadenas:

En Python, puedes formatear cadenas de varias maneras. Esto te permite crear cadenas que incluyen valores de variables, texto estático y formatos específicos. Aquí hay algunas formas comunes de formatear cadenas en Python:

Usar f-strings (cadenas f o literales f)

A partir de Python 3.6, puedes usar f-strings para formatear cadenas de manera sencilla. Coloca una "f" antes de la cadena y coloca las variables entre llaves {} dentro de la cadena.

nombre = "Alice" edad = 30 mensaje = f"Hola, soy {nombre} y tengo {edad} años."

Método format()

Puedes utilizar el método format() en una cadena para insertar valores en ella. En la cadena, puedes usar llaves {} como marcadores de posición y luego utilizar el método format() para especificar los valores que se insertarán.

nombre = "Bob" edad = 25

mensaje = "Hola, soy {} y tengo {} años.".format(nombre, edad)

También se podría realizar indicando el orden de los argumentos del format

nombre = "Bob" edad = 25 mensaje = "Hola, soy {1} y tengo {0} años.".format(edad, nombre)

Interpolación de cadenas con %

Puedes usar el operador % para formatear cadenas. En la cadena, utiliza %s para representar cadenas y %d para representar números enteros. Luego, utiliza el operador % para proporcionar los valores.

nombre = "Carlos" edad = 35 mensaje = "Hola, soy %s y tengo %d años." % (nombre, edad)

Cualquiera de estas opciones puede ser utilizada para formatear cadenas en Python. La elección de la técnica de formateo depende de tus preferencias personales y del estilo de codificación que desees seguir. Las f-strings son una forma moderna y recomendada de formatear cadenas en Python si estás utilizando Python 3.6 o una versión posterior.

Ver Anexo Formateo de Numeros y Fechas

Comparación de cadenas:

Puedes comparar cadenas utilizando operadores de comparación como ==, !=, <, >, <= y >=.

palabra1 = "Hola" palabra2 = "Hola"

igual = palabra1 == palabra2 # True

Conversión entre cadenas y otros tipos de datos:

Puedes convertir otros tipos de datos a cadenas utilizando la función str(), y puedes convertir cadenas a otros tipos de datos utilizando funciones como int() y float().

numero = 10 cadena = str(numero)

Métodos de cadenas

Lista completa de los métodos de cadenas en Python junto con ejemplos de su uso:

Método capitalize()

Convierte la primera letra de la cadena en mayúscula y el resto en minúsculas.

texto = "hola mundo" texto_capitalizado = texto.capitalize() print(texto_capitalizado) # Output: "Hola mundo"

Método casefold()

Convierte la cadena a minúsculas y la realiza una conversión adicional para manejar casos especiales de letras.

texto = "Hola Mundo" texto_casefold = texto.casefold() print(texto_casefold) # Output: "hola mundo"

Método center(width, fillchar)

Devuelve una cadena centrada en una longitud determinada con un carácter de relleno opcional.

texto = "Python" texto_centrado = texto.center(10, "*") print(texto_centrado) # Output: "**Python**"

Método count(substring, start, end)

Devuelve el número de apariciones de una subcadena en la cadena.

texto = "Hola, hola, hola" contador = texto.count("hola") print(contador) # Output: 3

Método endswith(suffix, start, end)

Verifica si la cadena termina con una subcadena especificada.

texto = "Hola mundo" termina_con_mundo = texto.endswith("mundo") print(termina_con_mundo) # Output: True

Método startswith(prefix, start, end)

Verifica si la cadena comienza con una subcadena especificada.

texto = "Hola mundo" comienza_con_hola = texto.startswith("Hola") print(comienza_con_hola) # Output: True

Método find(substring, start, end)

Busca la primera aparición de una subcadena en la cadena y devuelve su posición. Si no se encuentra, devuelve -1.

texto = "Hola mundo" posicion = texto.find("mundo") print(posicion) # Output: 5

Método index(substring, start, end)

Busca la primera aparición de una subcadena en la cadena y devuelve su posición. Si no se encuentra, lanza una excepción ValueError.

texto = "Hola mundo" posicion = texto.index("mundo") print(posicion) # Output: 5

Método isalnum()

Verifica si todos los caracteres de la cadena son alfanuméricos (letras o números).

texto = "Hola123" es_alnum = texto.isalnum() print(es_alnum) # Output: True

Método isalpha()

Verifica si todos los caracteres de la cadena son letras.

texto = "Hola" es_alpha = texto.isalpha() print(es_alpha) # Output: True

Método isdigit()

Verifica si todos los caracteres de la cadena son dígitos.

texto = "123" es_digit = texto.isdigit() print(es_digit) # Output: True

Método islower()

Verifica si todos los caracteres de la cadena están en minúsculas.

texto = "hola" es_lower = texto.islower() print(es_lower) # Output: True

Método isupper()

Verifica si todos los caracteres de la cadena están en mayúsculas.

texto = "HOLA"

es_upper = texto.isupper() print(es_upper) # Output: True

Método isspace()

Verifica si todos los caracteres de la cadena son espacios en blanco.

texto = " " es_space = texto.isspace() print(es_space) # Output: True

Método join(iterable)

Une los elementos de un iterable utilizando la cadena como separador.

lista = ["Hola", "Python", "mundo"] texto = "-".join(lista)

print(texto) # Output: "Hola-Python-mundo"

Método len()

Devuelve la longitud de la cadena.

texto = "Hola mundo" longitud = len(texto) print(longitud) # Output: 10

Método strip(chars)

Elimina los caracteres especificados (o espacios en blanco por defecto) al principio y al final de la cadena.

texto = " Hola mundo " texto_sin_espacios = texto.strip()

print(texto_sin_espacios) # Output: "Hola mundo"

Método lstrip(chars)

Elimina los caracteres especificados (o espacios en blanco por defecto) al principio de la cadena.

texto = " Hola mundo " texto_sin_espacios_inicio = texto.lstrip()

print(texto_sin_espacios_inicio) # Output: "Hola mundo "

Método rstrip(chars)

Elimina los caracteres especificados (o espacios en blanco por defecto) al final de la cadena.

texto = " Hola mundo " texto_sin_espacios_final = texto.rstrip()

print(texto_sin_espacios_final) # Output: " Hola mundo"

Método replace(old, new, count)

Reemplaza todas las apariciones de una subcadena por otra subcadena.

texto = "Hola mundo" texto_reemplazado = texto.replace("mundo", "Python") print(texto_reemplazado) # Output: "Hola Python"

Método split(sep, maxsplit)

Divide la cadena en una lista de subcadenas utilizando el separador especificado.

texto = "Hola,Python,mundo" lista_palabras = texto.split(",")

print(lista_palabras) # Output: ["Hola", "Python", "mundo"]

Método splitlines(keepends)

Divide la cadena en una lista de líneas, conservando los caracteres de salto de línea.

texto = "Hola\nPython\nmundo" lista_lineas = texto.splitlines() print(lista_lineas) # Output: ["Hola", "Python", "mundo"]

Función print() e input()

Funcion print()

La función print() en Python se utiliza para mostrar información en la consola o en la salida estándar. Puedes usar print() para mostrar texto, valores de variables, resultados de cálculos y más. La sintaxis básica de print() es la siguiente:

print(valor_o_cadena)

Donde valor_o_cadena es el valor o la cadena de texto que deseas mostrar en la consola. Puedes proporcionar múltiples argumentos separados por comas, y print() los mostrará en la consola uno tras otro.

Ejemplos de uso de print():

Mostrar un mensaje de texto en la consola:

print("Hola, mundo!")

Mostrar el valor de una variable:

nombre = "Alice"

print("El nombre es:", nombre)

Mostrar el resultado de una operación:

a = 5

b = 3

suma = a + b

print("La suma de", a, "y", b, "es", suma)

Mostrar varios elementos en una sola llamada a print():

nombre = "Bob" edad = 30

print("Nombre:", nombre, "Edad:", edad)

Argumentos sep y end

print() también admite una serie de argumentos opcionales para personalizar la salida, como el argumento sep para especificar el separador entre los elementos y el argumento end para especificar lo que se coloca al final de la línea (por defecto, es un salto de línea '\n'). Por ejemplo:

a = 10 b = 20

print("El valor de a es", a, "y el valor de b es", b, sep=", ", end=".\n")

Este código producirá la salida: "El valor de a es 10, y el valor de b es 20."

La función print() es una herramienta útil para depurar código y proporcionar información a los usuarios a través de la consola. Puedes utilizarla para visualizar resultados intermedios, mensajes informativos y más.

Función input()

La función input() en Python se utiliza para recibir la entrada del usuario a través del teclado. Esta función permite al programa interactuar con el usuario, solicitando que ingrese información que puede ser utilizada en el programa. La función input() toma un argumento opcional, que es la cadena de texto que se mostrará al usuario como un mensaje o una solicitud.

La sintaxis básica de input() es la siguiente:

respuesta = input("Mensaje o pregunta al usuario: ")

Donde:

"Mensaje o pregunta al usuario" es una cadena de texto opcional que se muestra al usuario como una indicación de lo que se espera.

respuesta es la variable que almacena la entrada del usuario como una cadena de texto. Ejemplo de uso de input():

nombre = input("Por favor, ingresa tu nombre: ") print("Hola, " + nombre + "! Bienvenido.")

En este ejemplo, el programa muestra el mensaje "Por favor, ingresa tu nombre:" y luego espera a que el usuario ingrese su nombre. La entrada del usuario se almacena en la variable nombre, que se utiliza posteriormente para saludar al usuario.

Es importante tener en cuenta que input() siempre devuelve una cadena de texto (string), por lo que si deseas utilizar la entrada del usuario como un número, deberás convertirla a un tipo numérico, como int o float, utilizando las funciones int() o float(). Por ejemplo:

edad = input("Ingresa tu edad: ")

edad = int(edad) # Convierte la entrada del usuario a un número entero

Ten en cuenta que la función input() detendrá la ejecución del programa hasta que el usuario ingrese algo y presione la tecla "Enter". Por lo tanto, es una forma efectiva de obtener interacción del usuario en la consola.

Estructuras de Datos

Listas (list):

● Almacenamiento: Las listas pueden contener elementos de cualquier tipo y pueden crecer o reducirse dinámicamente en tamaño.

● Orden: Las listas mantienen el orden de los elementos según se agregan. ● Acceso a elementos: Se puede acceder a los elementos de una lista mediante índices.

● Modificación: Las listas son mutables, lo que significa que se pueden modificar agregando, eliminando o cambiando elementos en cualquier posición.

● Uso de memoria: Las listas pueden ocupar más memoria debido a la flexibilidad de almacenar elementos de diferentes tipos y su capacidad de crecimiento dinámico.

Tuplas (tuple):

● Almacenamiento: Las tuplas pueden contener elementos de cualquier tipo y son inmutables, lo que significa que no se pueden modificar una vez creadas. ● Orden: Las tuplas mantienen el orden de los elementos según se agregan. ● Acceso a elementos: Se puede acceder a los elementos de una tupla mediante índices.

● Modificación: Las tuplas son inmutables, por lo que no se pueden modificar directamente. Sin embargo, se pueden crear nuevas tuplas con elementos modificados o concatenando tuplas existentes.

● Uso de memoria: Las tuplas generalmente ocupan menos memoria que las listas debido a su naturaleza inmutable y almacenamiento más compacto.

Conjuntos (set):

● Almacenamiento: Los conjuntos contienen elementos únicos y no se permiten duplicados. Pueden contener elementos de cualquier tipo inmutable.

● Orden: Los conjuntos no mantienen un orden específico de los elementos. No se puede acceder a los elementos mediante índices.

● Acceso a elementos: Los conjuntos se utilizan principalmente para comprobar la existencia de un elemento en la colección, no para acceder a elementos específicos. ● Modificación: Los conjuntos son mutables, se pueden agregar o eliminar elementos. ● Uso de memoria: Los conjuntos pueden ocupar menos memoria que las listas debido a su naturaleza de elementos únicos y almacenamiento eficiente.

Diccionarios (dict):

● Almacenamiento: Los diccionarios almacenan pares clave-valor, donde cada clave debe ser única. Los valores pueden ser de cualquier tipo.

● Orden: A partir de Python 3.7, los diccionarios mantienen el orden de inserción, lo que significa que se recuerda el orden en que se agregaron los elementos.

● Acceso a elementos: Los elementos de un diccionario se acceden mediante sus claves, no mediante índices.

● Modificación: Los diccionarios son mutables, se pueden agregar, eliminar o modificar elementos mediante claves.

● Uso de memoria: Los diccionarios pueden ocupar más memoria debido al almacenamiento adicional de claves y la flexibilidad de almacenar valores de cualquier tipo.

Listas

Las listas son una estructura de datos muy versátil y ampliamente utilizada. Las listas son colecciones ordenadas y mutables de elementos. Cada elemento en una lista se almacena en una ubicación específica y se puede acceder a través de un índice.

Crear una lista:

mi_lista = [1, 2, 3, 4, 5]

#Lista vacía mi_lista = []

Acceder a elementos de la lista:

mi_lista = [1, 2, 3, 4, 5]

# Acceder al primer elemento (índice 0) primer_elemento = mi_lista[0] # 1

# Acceder al último elemento ultimo_elemento = mi_lista[-1] # 5

# Acceder a un rango de elementos sublista = mi_lista[2:4] # [3, 4]

Modificar elementos de la lista:

mi_lista = [1, 2, 3, 4, 5]

# Modificar el valor de un elemento mi_lista[2] = 10 # [1, 2, 10, 4, 5]

# Agregar un elemento al final de la lista mi_lista.append(6) # [1, 2, 10, 4, 5, 6]

# Insertar un elemento en una posición específica mi_lista.insert(2, 7) # [1, 2, 7, 10, 4, 5, 6]

# Eliminar un elemento de la lista mi_lista.remove(4) # [1, 2, 7, 10, 5, 6]

# Eliminar el último elemento de la lista ultimo_elemento = mi_lista.pop() # [1, 2, 7, 10, 5]

Operaciones y funciones útiles con listas:

mi_lista = [1, 2, 3, 4, 5]

# Obtener la longitud de la lista longitud = len(mi_lista) # 5

# Ordenar la lista de forma ascendente mi_lista.sort() # [1, 2, 3, 4, 5]

# Ordenar la lista de forma descendente mi_lista.sort(reverse=True) # [5, 4, 3, 2, 1]

# Obtener el índice de un elemento indice = mi_lista.index(3) # 2

# Verificar si un elemento está en la lista esta_presente = 4 in mi_lista # True

# Concatenar dos listas otra_lista = [6, 7, 8] concatenacion = mi_lista + otra_lista # [5, 4, 3, 2, 1, 6, 7, 8]

Recorrer listas

mi_lista = [1, 2, 3, 4, 5]

#Te imprime todos los elementos de la lista for item in mi_lista:

print(item)

# Te imprime todos los elementos de la lista y el indice que tienen dentro de la misma for id,item in enumerated(mi_lista):

print(id,item)

Tuplas

A diferencia de las listas, las tuplas son inmutables, lo que significa que no se pueden modificar una vez creadas. Sin embargo, puedes realizar operaciones como acceder a elementos, obtener la longitud, buscar elementos y concatenar tuplas. Las tuplas son útiles cuando tienes datos que no deben cambiar o cuando deseas asegurarte de que los datos no sean modificados accidentalmente.

Crear una tupla

mi_tupla = (1, 2, 3, 4, 5)

Acceder a elementos de la tupla:

mi_tupla = (1, 2, 3, 4, 5)

# Acceder al primer elemento (índice 0) primer_elemento = mi_tupla[0] # 1

# Acceder al último elemento ultimo_elemento = mi_tupla[-1] # 5

# Acceder a un rango de elementos subtupla = mi_tupla[2:4] # (3, 4)

No se puede modificar una tupla:

mi_tupla = (1, 2, 3, 4, 5)

# Intentar modificar el valor de un elemento genera un error mi_tupla[2] = 10 # Genera un TypeError

Operaciones y funciones útiles con tuplas:

mi_tupla = (1, 2, 3, 4, 5)

# Obtener la longitud de la tupla

longitud = len(mi_tupla) # 5

# Obtener el índice de un elemento indice = mi_tupla.index(3) # 2

# Verificar si un elemento está en la tupla esta_presente = 4 in mi_tupla # True

# Concatenar dos tuplas otra_tupla = (6, 7, 8) concatenacion = mi_tupla + otra_tupla # (1, 2, 3, 4, 5, 6, 7, 8)

Conjuntos - Set

Los conjuntos en Python son útiles cuando necesitas almacenar elementos sin un orden específico y sin duplicados. Los conjuntos ofrecen operaciones eficientes para realizar uniones, intersecciones, diferencias y más. Además, puedes agregar y eliminar elementos fácilmente.

Crear un conjunto:

mi_set = {1, 2, 3, 4, 5}

Agregar elementos al conjunto

mi_set = {1, 2, 3}

# Agregar un elemento individual mi_set.add(4) # {1, 2, 3, 4}

# Agregar varios elementos a la vez

mi_set.update([5, 6, 7]) # {1, 2, 3, 4, 5, 6, 7}

Eliminar elementos del conjunto:

mi_set = {1, 2, 3, 4, 5}

# Eliminar un elemento

mi_set.remove(3) # {1, 2, 4, 5}

# Eliminar un elemento sin generar error si no está presente mi_set.discard(6) # {1, 2, 4, 5}

# Eliminar y devolver un elemento al azar

elemento = mi_set.pop() # elemento = 1, mi_set = {2, 4, 5}

# Vaciar el conjunto por completo mi_set.clear() # {}

Operaciones con conjuntos:

set1 = {1, 2, 3} set2 = {3, 4, 5}

# Unión de conjuntos union = set1.union(set2) # {1, 2, 3, 4, 5}

# Intersección de conjuntos interseccion = set1.intersection(set2) # {3}

# Diferencia entre conjuntos diferencia = set1.difference(set2) # {1, 2}

# Diferencia simétrica entre conjuntos diferencia_simetrica = set1.symmetric_difference(set2) # {1, 2, 4, 5}

Verificar pertenencia y tamaño:

mi_set = {1, 2, 3, 4, 5}

# Verificar si un elemento está en el conjunto esta_presente = 3 in mi_set # True

# Obtener la cantidad de elementos en el conjunto cantidad_elementos = len(mi_set) # 5

Diccionarios

Los diccionarios en Python son estructuras de datos que almacenan pares clave-valor. Son útiles para representar datos estructurados y acceder a ellos de forma eficiente mediante claves. Puedes agregar, modificar y eliminar elementos, así como recorrer los elementos del diccionario usando bucles.

Crear un diccionario:

mi_diccionario = {"nombre": "Juan", "edad": 30, "ciudad": "Madrid"}

Acceder a valores en el diccionario:

mi_diccionario = {"nombre": "Juan", "edad": 30, "ciudad": "Madrid"}

# Acceder a un valor por su clave

nombre = mi_diccionario["nombre"] # "Juan"

# Otra forma de acceder a un valor por su clave edad = mi_diccionario.get("edad") # 30

Modificar y agregar elementos al diccionario:

mi_diccionario = {"nombre": "Juan", "edad": 30, "ciudad": "Madrid"}

# Modificar un valor existente mi_diccionario["edad"] = 31

# Agregar un nuevo par clave-valor mi_diccionario["profesion"] = "Ingeniero"

Eliminar elementos del diccionario:

mi_diccionario = {"nombre": "Juan", "edad": 30, "ciudad": "Madrid"}

# Eliminar un elemento por su clave

del mi_diccionario["edad"]

# Eliminar un elemento y obtener su valor ciudad = mi_diccionario.pop("ciudad")

Recorrer un diccionario:

mi_diccionario = {"nombre": "Juan", "edad": 30, "ciudad": "Madrid"}

# Recorrer las claves del diccionario for clave in mi_diccionario:

print(clave)

# Recorrer los valores del diccionario for valor in mi_diccionario.values():

print(valor)

# Recorrer las claves y valores del diccionario for clave, valor in mi_diccionario.items():

print(clave, valor)

Verificar si una clave está presente en el diccionario:

mi_diccionario = {"nombre": "Juan", "edad": 30, "ciudad": "Madrid"}

# Verificar si una clave está presente esta_presente = "nombre" in mi_diccionario # True

Condicionales

Los condicionales en Python son estructuras de control que te permiten tomar decisiones en función de ciertas condiciones.

Estructura if..elif..else

Los condicionales más comunes en Python son if, elif y else. Aquí tienes un ejemplo de cómo funcionan:

edad = 18

if edad < 18:

print("Eres menor de edad.") elif edad == 18:

print("Tienes 18 años.") else:

print("Eres mayor de edad.")

En este ejemplo, if se utiliza para evaluar si la variable edad es menor que 18. Si es cierto, se ejecutará el bloque de código dentro de ese if. Si no, se pasa a la siguiente condición, que se comprueba con elif (abreviatura de "else if"). Si edad es igual a 18, se ejecutará el bloque de código dentro del elif. Si ninguna de las condiciones anteriores se cumple, se ejecutará el bloque de código dentro del else.

También puedes utilizar condicionales anidados para tomar decisiones más complejas:

edad = 25 tiene_licencia = True

if edad >= 18:

if tiene_licencia:

print("Puedes conducir un coche.") else: print("Eres mayor de edad, pero no tienes licencia para conducir.") else:

print("Eres menor de edad y no puedes conducir.")

En este ejemplo, se evalúa si la persona es mayor de edad y si tiene una licencia para conducir. Dependiendo de las condiciones, se imprimirá un mensaje diferente.

Ten en cuenta que la indentación es fundamental en Python, ya que define los bloques de código. Los bloques de código deben estar indentados correctamente para que el programa funcione de manera adecuada.

Operador ternario

El operador ternario es una forma compacta de expresar una decisión en una sola línea.

Tiene la forma valor_si_verdadero if condicion else valor_si_falso. Aquí tienes un ejemplo:

edad = 20 estatus = "Mayor de edad" if edad >= 18 else "Menor de edad" print(estatus)

Comprensión de listas

Las comprensiones de listas te permiten crear listas de forma concisa utilizando condicionales. Por ejemplo:

numeros = [1, 2, 3, 4, 5, 6, 7] pares = [x for x in numeros if x % 2 == 0] print(pares)

Comprensión de diccionarios

Similar a las comprensiones de listas, las comprensiones de diccionarios te permiten crear diccionarios de manera concisa utilizando condicionales. Aquí tienes un ejemplo:

personas = {'Alice': 25, 'Bob': 18, 'Charlie': 30} adultos = {nombre: edad for nombre, edad in personas.items() if edad >=

18} print(adultos)

Any y All

Las funciones any() y all() permiten verificar si al menos un elemento o todos los elementos de una secuencia cumplen una condición, respectivamente.

valores = [True, False, True, True] if any(valores):

print("Al menos un valor es True") if all(valores):

print("Todos los valores son True")

Switch-Case

Antes de la versión 3.10 se puede emular utilizando diccionarios. Aquí tienes un ejemplo:

def opcion_a():

return "Elegiste la opción A"

def opcion_b():

return "Elegiste la opción B"

def opcion_predeterminada(): return "Opción no válida"

opciones = { 'A': opcion_a,

'B': opcion_b

} eleccion = 'A'

resultado = opciones.get(eleccion, opcion_predeterminada)() print(resultado)

A partir de la versión 3.10, para escribir instrucciones switch con la función de coincidencia de patrones estructurales, puede utilizar la siguiente sintaxis:

match term:

case pattern-1: action-1 case pattern-2: action-2 case pattern-3:

action-3 case _: action-default

Ten en cuenta que el símbolo de subrayado es lo que se utiliza para definir un caso predeterminado para la instrucción switch en Python.

lang = input("What's the programming language you want to learn? ")

match lang: case "JavaScript":

print("You can become a web developer.")

case "Python":

print("You can become a Data Scientist")

case "PHP":

print("You can become a backend developer")

case "Solidity":

print("You can become a Blockchain developer")

case "Java":

print("You can become a mobile app developer") case _: print("The language doesn't matter, what matters is solving problems.")

Esa es una sintaxis mucho más limpia que varias instrucciones y simular la instrucción switch con una función.

Probablemente hayas notado que no agregué una palabra clave break a cada uno de los casos, como se hace en otros lenguajes de programación. Esa es la ventaja que tiene la

instrucción switch nativa de Python sobre las de otros lenguajes. La funcionalidad de la palabra clave break se realiza por ti en segundo plano.

Bucles

En Python, existen diferentes tipos de bucles que te permiten repetir un bloque de código múltiples veces. Los bucles son fundamentales en la programación y se utilizan para automatizar tareas y procesar datos de manera eficiente. Aquí te presento los tipos de bucles más comunes en Python:

Bucle for: El bucle for se utiliza para iterar sobre una secuencia (como una lista, una tupla, una cadena o un rango) y ejecutar un bloque de código para cada elemento de la secuencia. Su sintaxis es la siguiente:

for elemento in secuencia:

# Código a repetir

frutas = ["manzana", "banana", "cereza"] for fruta in frutas: print(fruta)

Bucle while

El bucle while se utiliza para repetir un bloque de código mientras una condición sea verdadera. Su sintaxis es la siguiente:

while condición: # Código a repetir

contador = 0 while contador < 5: print(contador) contador += 1

**Bucle for con range()

El bucle for en combinación con la función range() es una forma común de realizar iteraciones en Python. La función range() te permite generar una secuencia de números en un rango específico, y el bucle for se utiliza para iterar a través de estos números. Aquí tienes información sobre cómo utilizar for y range() juntos:

La función range() se utiliza generalmente en la siguiente forma:

range(inicio, final, paso)

inicio: El número en el que debe comenzar la secuencia (inclusive). final: El número en el que debe terminar la secuencia (exclusivo). paso: El incremento entre los números en la secuencia (opcional, con un valor predeterminado de 1 si se omite).

Aquí hay algunos ejemplos de cómo utilizar el bucle for con range():

Iterar sobre una secuencia de números del 0 al 4 (inclusive):

for i in range(5):

print(i)

Este código imprimirá los números del 0 al 4.

Iterar sobre una secuencia de números del 2 al 8 con un paso de 2:

for i in range(2, 9, 2):

print(i)

Este código imprimirá los números 2, 4, 6 y 8.

Iterar sobre una secuencia de números en orden inverso, del 5 al 1:

for i in range(5, 0, -1):

print(i)

Este código imprimirá los números del 5 al 1 en orden descendente.

La función range() es útil para generar secuencias de números que se utilizan en bucles for, especialmente cuando se trabaja con un número específico de iteraciones o se necesita un control preciso sobre el rango de valores.

Bucle for con índices

A veces, es útil acceder a los índices de los elementos de una secuencia al iterar. Puedes usar la función enumerate() para obtener tanto el índice como el elemento en cada iteración.

frutas = ["manzana", "banana", "cereza"] for indice, fruta in enumerate(frutas): print(f"Índice {indice}: {fruta}")

Bucle for para diccionarios

Puedes iterar a través de las claves y valores de un diccionario utilizando el método items().

estudiante = {"nombre": "Ana", "edad": 25, "carrera": "Informática"} for clave, valor in estudiante.items():

print(f"{clave}: {valor}")

Control de bucles

Puedes utilizar declaraciones como break para salir de un bucle antes de que se complete, o continue para saltar la iteración actual y pasar a la siguiente.

for i in range(10): if i == 3:

break # Sale del bucle cuando i es igual a 3 if i == 5: continue # Salta la iteración cuando i es igual a 5 print(i)

Nota: su uso no esta recomendado ya que es mejor utilizar la gestión de excepciones que también se utiliza para el control de flujo.

Técnicas avanzadas con bucles

Comprensión de listas (list comprehension)

Las comprensiones de listas son una forma concisa y poderosa de crear listas a partir de una expresión y un bucle for. Esto es especialmente útil para transformar, filtrar o generar listas de forma eficiente.

numeros = [1, 2, 3, 4, 5] cuadrados = [x**2 for x in numeros]

Comprensión de diccionarios (dict comprehension)

De manera similar a las comprensiones de listas, puedes crear diccionarios de manera concisa utilizando un bucle for.

frutas = ["manzana", "banana", "cereza"]

longitud_frutas = {fruta: len(fruta) for fruta in frutas}

Comprensión de conjuntos (set comprehension)

Las comprensiones de conjuntos te permiten crear conjuntos de elementos únicos de una manera similar a las comprensiones de listas.

numeros = [1, 2, 2, 3, 3, 4, 5] conjunto = {x for x in numeros}

Función zip()

La función zip() combina elementos de dos o más secuencias en tuplas. Esto es útil cuando necesitas iterar simultáneamente sobre múltiples iterables.

nombres = ["Alice", "Bob", "Charlie"] edades = [30, 25, 35] for nombre, edad in zip(nombres, edades):

print(f"{nombre}: {edad} años")

Bucle for...else

Puedes utilizar un bloque else después de un bucle for para especificar qué hacer después de que el bucle termine. El bloque else se ejecuta si el bucle se completa sin interrupciones.

for i in range(5): if i == 3: break else:

print("El bucle se completó sin interrupciones")

Bucle while...else

Similar al bucle for...else, puedes usar un bloque else después de un bucle while para especificar acciones que se ejecutarán si el bucle termina sin interrupciones.

i = 0 while i < 5: if i == 3: break i += 1 else:

print("El bucle while se completó sin interrupciones")

Biblioteca itertools

El módulo itertools proporciona herramientas para crear y utilizar iteradores eficientes, como cycle, count, permutations, combinations, etc. Estas herramientas son útiles para operaciones avanzadas en secuencias.

from itertools import permutations

elementos = [1, 2, 3]

permutaciones = permutations(elementos) for p in permutaciones: print(p)

Funciones en Python

Funciones incorporadas

Python proporciona muchas funciones incorporadas que se pueden utilizar directamente en tu código sin necesidad de importar módulos adicionales. Algunas de las funciones incorporadas comunes son print(), len(), type(), input(), range(), sum(), etc. Estas funciones están disponibles para su uso en cualquier momento.

numero = 10 print(numero) # Imprime el valor de la variable numero

Funciones de usuario

Puedes crear tus propias funciones personalizadas para realizar tareas específicas. Las funciones definidas por el usuario se definen utilizando la palabra clave def, seguida del nombre de la función y los parámetros entre paréntesis. Puedes especificar los parámetros de entrada y opcionalmente un valor de retorno.

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

resultado = suma(5, 3) # Llama a la función suma con los argumentos 5 y

print(resultado) # Imprime el resultado de la suma: 8

Funciones de biblioteca (módulos)

Python proporciona una amplia variedad de módulos y bibliotecas que contienen funciones predefinidas para realizar tareas específicas. Puedes importar estos módulos en tu código y utilizar las funciones que ofrecen. Algunos ejemplos comunes son math, random, datetime, os, json, etc.

import math

raiz_cuadrada = math.sqrt(16) # Utiliza la función sqrt() del módulo math para calcular la raíz cuadrada de 16

print(raiz_cuadrada) # Imprime el resultado: 4.0

Funciones lambda (funciones anónimas)

Las funciones lambda son funciones pequeñas y anónimas que se definen sin un nombre utilizando la palabra clave lambda. Estas funciones suelen utilizarse cuando se requiere una función rápida y sencilla sin necesidad de definirla por separado.

doble = lambda x: x * 2 resultado = doble(5) # Llama a la función lambda con el argumento

5 print(resultado) # Imprime el resultado: 10

Funciones de usuario

Las funciones de usuario en Python permiten definir tus propias funciones personalizadas para realizar tareas específicas.

Estos son los conceptos básicos para construir funciones de usuario en Python. Las funciones permiten modularizar y reutilizar código, lo que mejora la organización y mantenibilidad del programa.

Sintaxis básica

Las funciones se definen utilizando la palabra clave def, seguida del nombre de la función y paréntesis que pueden contener los parámetros de entrada.

El bloque de código de la función se define con sangría.

Se puede opcionalmente especificar un valor de retorno utilizando la palabra clave return.

def nombre_funcion(parametro1, parametro2):

# Bloque de código return resultado

Parámetros de entrada

Los parámetros de entrada son valores que se pasan a la función cuando se llama.

Se pueden definir cero o más parámetros separados por comas entre los paréntesis de la función.

Los parámetros pueden tener valores predeterminados, lo que permite que la función se llame sin proporcionar un valor para esos parámetros.

def saludo(nombre):

print("Hola, " + nombre) saludo("Juan") # Llama a la función saludo con el argumento "Juan"

Parámetros con nombre

Son argumentos en los que se especifica explícitamente el nombre del parámetro y su valor correspondiente al llamar a la función. Esto permite pasar los argumentos en cualquier orden. Por ejemplo:

def saludar(nombre, mensaje):

print(f"Hola {nombre}, {mensaje}")

saludar(mensaje="bienvenido", nombre="Juan") # Salida: Hola Juan, bienvenido

Parámetros por defecto

Son argumentos que tienen un valor predeterminado en la declaración de la función. Si no se proporciona un valor para estos argumentos al llamar a la función, se utilizará el valor por defecto. Por ejemplo:

def saludar(nombre, mensaje="bienvenido"): print(f"Hola {nombre}, {mensaje}")

saludar("Juan") # Salida: Hola Juan, bienvenido saludar("Pedro", "hola") # Salida: Hola Pedro, hola

Parámetros variables

Puedes utilizar argumentos variables cuando no sabes cuántos argumentos se pasarán a una función. Hay dos tipos de argumentos variables en Python:

Parámetros variables posicionales

Se denotan con un asterisco (*) antes del nombre del parámetro y permiten pasar un número variable de argumentos posicionales. Los argumentos se agruparán en una tupla dentro de la función. Por ejemplo:

def sumar(*numeros): total = sum(numeros) print(f"La suma es: {total}")

sumar(1, 2, 3) # Salida: La suma es: 6

sumar(4, 5, 6, 7) # Salida: La suma es: 22

Parámetros variables con nombre

Se denotan con dos asteriscos (**) antes del nombre del parámetro y permiten pasar un número variable de argumentos con nombre. Los argumentos se agruparán en un diccionario dentro de la función. Por ejemplo:

def imprimir_datos(**datos): for clave, valor in datos.items():

print(f"{clave}: {valor}")

imprimir_datos(nombre="Juan", edad=30) # Salida: nombre: Juan\nedad: 30 imprimir_datos(nombre="Pedro", ocupacion="ingeniero", ciudad="Madrid")

# Salida: nombre: Pedro\nocupacion: ingeniero\nciudad: Madrid

Valor de retorno

Una función puede devolver un valor utilizando la palabra clave return.

Se puede devolver cualquier tipo de dato o incluso estructuras de datos más complejas, como listas o diccionarios.

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

resultado = suma(5, 3) # Llama a la función suma con los argumentos 5 y

print(resultado) # Imprime el resultado de la suma: 8

Variables locales y globales

Las variables definidas dentro de una función son locales a esa función y no pueden ser accedidas fuera de ella.

Se puede utilizar variables globales (definidas fuera de cualquier función) dentro de una función, pero si quieres modificar su valor, debes usar la palabra clave global.

global_variable = 10

def function():

local_variable = 5 global global_variable

global_variable += local_variable print(global_variable)

function() # Imprime 15

Documentación de la función

Puedes agregar documentación a tus funciones utilizando comentarios entre comillas triples (docstrings).

La documentación describe el propósito de la función, los parámetros de entrada, el valor de retorno y cualquier otra información relevante.

def suma(a, b):

"""

Esta función realiza la suma de dos números.

Parámetros:

a (int): El primer número. b (int): El segundo número.

Retorna:

int: El resultado de la suma.

""" return a + b print(suma.__doc__) # Imprime la documentación de la función suma

Ámbitos de variables

Los ámbitos de variables se refieren a las reglas que determinan dónde se puede acceder a una variable y en qué partes del código es visible. Python tiene varios niveles de ámbitos de variables, y la comprensión de estos es esencial para escribir código limpio y evitar errores.

Ámbito Local

Las variables definidas dentro de una función son locales y solo son accesibles dentro de esa función.

No son visibles desde fuera de la función.

Las variables locales tienen precedencia sobre las variables con el mismo nombre en ámbitos superiores.

def mi_funcion():

variable_local = 10 print(variable_local)

mi_funcion() # variable_local es accesible aquí

# print(variable_local) # Esto generaría un error, variable_local no es accesible aquí

Ámbito Encerrante (Enclosing Scope):

En funciones anidadas, el ámbito local de una función encapsula el ámbito local de la función exterior.

Puedes acceder a variables en el ámbito exterior, pero no puedes modificarlas directamente a menos que las declares como nonlocal.

def exterior():

variable_exterior = 10

def interior():

variable_interna = variable_exterior # variable_exterior es accesible en el ámbito interior

interior()

exterior()

Ámbito Global:

Las variables globales se definen fuera de todas las funciones y son accesibles desde cualquier parte del código, incluyendo dentro de las funciones.

Debes tener cuidado al modificar variables globales desde funciones, ya que pueden tener efectos no deseados en el código.

variable_global = 20

def mi_funcion():

global variable_global variable_global += 1 # Modificamos la variable global

mi_funcion() print(variable_global) # variable_global ahora es 21

Ámbito Incorporado (Built-in Scope):

Python tiene un conjunto de variables y funciones incorporadas que están disponibles en cualquier parte del código sin necesidad de importar módulos adicionales. Estas incluyen funciones como print(), len(), y variables como True, False, None, etc.

print(len([1, 2, 3])) # La función len() es una función incorporada

Es importante comprender estos ámbitos de variables para evitar confusiones y errores en tus programas. La regla general es que Python busca una variable en el ámbito local antes de buscar en ámbitos encerrantes y global. Si no se encuentra en ningún ámbito local, se buscará en el ámbito global. Si aún no se encuentra, se buscará en el ámbito incorporado.

Gestión de Excepciones

La gestión de excepciones en Python es una técnica utilizada para manejar situaciones inesperadas o errores durante la ejecución de un programa. Permite detectar y responder de manera adecuada a los errores, evitando que el programa se bloquee o se comporte de manera incorrecta.

También se utiliza para el control de flujo ya que en el momento que se lanza una excepción el flujo se desvía hasta donde sea recogida y si no se recoge, el programa terminaría su ejecución con dicha excepción.

La sintaxis básica para gestionar excepciones en Python es mediante el uso de los bloques try-except. El código que se encuentra dentro del bloque try es el código que se ejecuta en primer lugar, y dentro del bloque except se define el código a ejecutar en caso de que se produzca una excepción. Veamos un ejemplo sencillo:

try:

resultado = 10 / 0 print("Esta línea no se ejecutará") except ZeroDivisionError: print("Error: División entre cero")

En este ejemplo, se intenta realizar una división entre cero, lo cual genera una excepción del tipo ZeroDivisionError. Al encontrarse esta excepción, el flujo del programa se desvía al bloque except correspondiente y se imprime el mensaje "Error: División entre cero".

Es posible manejar múltiples tipos de excepciones utilizando varios bloques except. Además, también se puede incluir un bloque else que se ejecutará si no se produce ninguna excepción en el bloque try. Veamos un ejemplo:

try:

resultado = 10 / 0 except ZeroDivisionError:

print("Error: División entre cero") except ValueError:

print("Error: Valor inválido") else:

print("El resultado es:", resultado)

En este caso, si se produce una excepción del tipo ZeroDivisionError, se imprimirá "Error: División entre cero". Si se produce una excepción del tipo ValueError, se imprimirá "Error: Valor inválido". Si no se produce ninguna excepción, se ejecutará el bloque else y se imprimirá el mensaje "El resultado es: [resultado]".

Adicionalmente, es posible utilizar un bloque finally que se ejecuta siempre, independientemente de si se produce una excepción o no. Este bloque es útil para realizar acciones de limpieza o liberar recursos. Veamos un ejemplo:

try:

archivo = open("archivo.txt", "r") contenido = archivo.read() print(contenido) except FileNotFoundError:

print("Error: Archivo no encontrado") finally: if archivo:

archivo.close()

En este ejemplo, se intenta abrir un archivo llamado "archivo.txt" para lectura. Si el archivo no se encuentra, se genera una excepción del tipo FileNotFoundError. En el bloque finally, se asegura de que el archivo se cierre correctamente, incluso si se produjo una excepción.

Jerarquía de Excepciones

Aquí hay una representación simplificada de la jerarquía de excepciones en Python:

BaseException

├── SystemExit

├── KeyboardInterrupt

├── Exception

├── StopIteration

├── ArithmeticError

│ ├── ZeroDivisionError

│ ├── FloatingPointError

│ └── ...

├── AssertionError

├── AttributeError

├── ... └── ...

Algunos puntos importantes sobre la jerarquía de excepciones en Python:

BaseException es la clase base de todas las excepciones, pero generalmente no se utiliza directamente en las capturas de excepciones.

Exception es la clase base para excepciones que no son errores de sistema ni interrupciones del usuario. Es común capturar y manejar excepciones de esta clase.

Dentro de la jerarquía de Exception, hay subclases que representan diferentes tipos de excepciones, como StopIteration para señalar el final de una iteración, ArithmeticError para errores aritméticos, AssertionError para fallas en las aserciones, AttributeError para errores de atributo, entre otros.

Las excepciones más específicas están más abajo en la jerarquía. Por ejemplo, ZeroDivisionError es una subclase de ArithmeticError y se utiliza para representar errores de división entre cero.

Puedes capturar excepciones específicas en bloques try-except para manejarlas de manera más precisa y tomar acciones adecuadas en cada caso.

Aquí hay un ejemplo básico que muestra cómo se pueden capturar excepciones en diferentes niveles de la jerarquía:

try:

# Código que puede generar una excepción resultado = 10 / 0 except ZeroDivisionError:

print("¡Error: división entre cero!") except ArithmeticError:

print("¡Error aritmético!") except Exception as e:

print(f"¡Ocurrió una excepción: {type(e).__name__}!")

En este ejemplo, si se produce una excepción de ZeroDivisionError, se captura y se imprime un mensaje específico. Si ocurre una excepción de ArithmeticError (que incluye ZeroDivisionError), se captura y se imprime otro mensaje. Y si ocurre cualquier otra excepción, se captura y se muestra un mensaje genérico.

Lanzar excepciones

Aquí se muestra un ejemplo de cómo lanzar una excepción personalizada en Python:

def dividir(a, b): if b == 0:

raise ValueError("¡División entre cero no está permitida!") return a / b try:

resultado = dividir(10, 0) print("El resultado de la división es:", resultado) except ValueError as ve:

print(ve)

En este ejemplo, la función dividir() verifica si el divisor b es cero. Si es cero, se lanza una excepción ValueError con un mensaje personalizado. Luego, se utiliza un bloque try-except para capturar esa excepción y mostrar el mensaje de error.

La salida del código será:

¡División entre cero no está permitida!

Al lanzar una excepción, se puede utilizar cualquier clase de excepción incorporada en Python, como ValueError, TypeError, IndexError, o se pueden crear tus propias clases de excepción personalizadas heredando de la clase base Exception. Puedes personalizar los mensajes de error y proporcionar información adicional en las excepciones para ayudar en la depuración y el manejo de errores.

Excepciones personalizadas

En Python, puedes crear tus propias excepciones personalizadas para manejar situaciones específicas en tus programas. Esto te permite definir un comportamiento personalizado cuando ocurre un error o una condición excepcional en tu código. Para crear una excepción personalizada, sigue estos pasos:

Define una nueva clase que herede de la clase base Exception o de una de sus subclases, como ValueError, TypeError, etc. Esto te permitirá crear tu propia jerarquía de excepciones.

python

class MiErrorPersonalizado(Exception): def __init__(self, mensaje): super().__init__(mensaje) self.mensaje = mensaje

Puedes personalizar el constructor __init__ de tu excepción para aceptar un mensaje específico que describa el error. Esto es útil para proporcionar información detallada sobre la excepción. También puedes incluir otros atributos personalizados en tu excepción si es necesario.

Lanza tu excepción personalizada cuando ocurra una condición excepcional en tu código. Para lanzar la excepción, simplemente crea una instancia de la clase de excepción y utilice la palabra clave raise. Por ejemplo:

def dividir(a, b):

if b == 0: raise MiErrorPersonalizado("No se puede dividir por cero") return a / b

A continuación, puedes atrapar y manejar tu excepción personalizada en un bloque try...except. Esto te permite tomar acciones específicas cuando ocurre la excepción.

try:

resultado = dividir(10, 0) except MiErrorPersonalizado as error:

print(f"Error personalizado: {error.mensaje}")

Paquetes, Módulos y Namespaces

En Python, los paquetes, módulos y espacios de nombres (namespaces) son conceptos clave que se utilizan para organizar y estructurar el código.

Módulos

Los módulos son archivos que contienen definiciones y declaraciones de variables, funciones y clases que se pueden utilizar en otros programas de Python. Los módulos son una forma de organizar y reutilizar código. Aquí tienes una guía básica sobre cómo trabajar con módulos en Python:

Creación de módulos

Un módulo es simplemente un archivo con extensión .py que contiene código Python. Por ejemplo, podrías tener un archivo llamado mi_modulo.py que contenga funciones y variables:

# mi_modulo.py

def saludar(nombre):

return f"Hola, {nombre}!"

mi_variable = 42

Uso de módulos

Puedes utilizar los contenidos de un módulo en otro programa Python utilizando la palabra clave import. Por ejemplo:

import mi_modulo

saludo = mi_modulo.saludar("Juan") print(saludo) # Imprime "Hola, Juan!"

print(mi_modulo.mi_variable) # Imprime 42

También puedes importar módulos con un nombre diferente utilizando la palabra clave as:

import mi_modulo as mm # Ahora, el módulo se llama mm en lugar de mi_modulo

saludo = mm.saludar("Ana")

print(saludo)

Importación selectiva

Puedes importar solo funciones o variables específicas de un módulo utilizando la sintaxis from ... import ...:

from mi_modulo import saludar

saludo = saludar("Pedro") print(saludo)

Módulos incorporados

Python también incluye una serie de módulos incorporados que proporcionan funcionalidades básicas, como math para operaciones matemáticas, os para manipulación de archivos y directorios, random para generación de números aleatorios, y muchos otros. Estos módulos no requieren instalación adicional y están disponibles en cualquier instalación de Python.

Módulos personalizados

Además de los módulos incorporados, puedes crear tus propios módulos personalizados para organizar y reutilizar tu código. Es una buena práctica dividir tu código en módulos lógicos y reutilizables para facilitar el mantenimiento y la colaboración en proyectos más grandes.

Los módulos son una parte esencial de la organización y estructuración del código en Python y te permiten dividir y reutilizar tu código de manera eficiente. Puedes usar módulos tanto para tu propio código como para aprovechar las bibliotecas y marcos de trabajo proporcionados por la comunidad de Python.

Paquetes

Los paquetes son una forma de organizar módulos relacionados en un directorio y sus subdirectorios. Los paquetes permiten una estructura jerárquica para organizar el código, lo que facilita la gestión de proyectos más grandes y la reutilización de código. Aquí tienes una guía básica sobre cómo trabajar con paquetes en Python:

Estructura de directorios de un paquete:

Un paquete Python es simplemente un directorio que contiene un archivo especial llamado

__init__.py. El __init__.py puede estar vacío o contener código de inicialización del paquete. Además, el directorio del paquete puede contener otros módulos (archivos .py) y subpaquetes (subdirectorios que también contienen __init__.py).

Ejemplo de estructura de directorios:

mi_paquete/ __init__.py modulo1.py modulo2.py subpaquete/ __init__.py modulo3.py

Cómo importar módulos desde un paquete

Puedes importar módulos desde un paquete utilizando la sintaxis de puntos, donde especificas el nombre del paquete y el nombre del módulo, separados por un punto. Por ejemplo:

import mi_paquete.modulo1

mi_paquete.modulo1.funcion_de_modulo1()

También puedes usar la forma abreviada de importar un módulo:

from mi_paquete import modulo2 modulo2.funcion_de_modulo2()

Y si deseas importar solo una función o una variable específica de un módulo:

from mi_paquete.modulo1 import funcion_especifica funcion_especifica()

Uso de subpaquetes:

Los paquetes pueden contener subpaquetes para organizar aún más el código. Puedes acceder a los módulos de un subpaquete utilizando la notación de puntos.

from mi_paquete.subpaquete import modulo3 modulo3.funcion_de_modulo3()

Importación relativa

La importación relativa te permite importar módulos dentro del mismo paquete de manera más concisa utilizando el punto . para referenciar el paquete actual. Esto es útil para evitar conflictos de nombres y simplificar las importaciones dentro del paquete.

from . import modulo1 # Importa modulo1 del paquete actual

from .subpaquete import modulo3 # Importa modulo3 del subpaquete actual

Los paquetes son una parte fundamental de la organización y estructuración de código en proyectos más grandes en Python. Permiten dividir el código en componentes más manejables y reutilizables, lo que facilita el mantenimiento y la colaboración en proyectos de desarrollo de software.

Espacios de nombres (Namespaces)

Un espacio de nombres es un contexto en el que se definen y se acceden a los nombres de las variables, funciones y clases. Proporciona un mecanismo para evitar conflictos de nombres y para organizar y estructurar el código. En Python, existen diferentes espacios de nombres, como el espacio de nombres global (que contiene los nombres definidos en el nivel superior de un módulo o script), los espacios de nombres locales (que contienen los nombres definidos dentro de una función o método) y los espacios de nombres de módulos o paquetes (que contienen los nombres definidos dentro de un módulo o paquete). Los espacios de nombres se utilizan para controlar el alcance y la visibilidad de los nombres en un programa Python.

En resumen, los paquetes y módulos se utilizan para organizar y estructurar el código en Python, mientras que los espacios de nombres proporcionan contextos separados para definir y acceder a los nombres de variables, funciones y clases.

Librerías Estándar

Módulo Random

El módulo random, por otro lado, es una biblioteca o módulo en muchos lenguajes de programación que proporciona funciones para generar números aleatorios. Estos números se utilizan en diversas aplicaciones, como juegos, simulaciones, criptografía, entre otros.

A continuación, se proporciona un resumen de las funcionalidades más comunes del módulo random, junto con ejemplos en Python:

1. Generación de números aleatorios:

● randint(a, b): genera un número entero aleatorio en el rango [a, b]. Ejemplo: random.randint(1, 10) puede devolver 4.

● uniform(a, b): genera un número flotante aleatorio en el rango [a, b]. Ejemplo: random.uniform(0.0, 1.0) puede devolver 0.752.

2. Selección aleatoria de elementos:

● choice(lista): devuelve un elemento aleatorio de una lista.

Ejemplo: random.choice(["manzana", "plátano", "naranja"]) puede devolver "plátano".

● sample(secuencia, k): devuelve una muestra aleatoria de k elementos únicos de una secuencia.

Ejemplo: random.sample(range(1, 50), 6) puede devolver [12, 5, 40, 22, 1, 35].

3. Aleatoriedad de secuencias:

● shuffle(lista): reordena aleatoriamente los elementos de una lista.

Ejemplo: lista = [1, 2, 3, 4, 5]; random.shuffle(lista) puede modificar la lista a [4, 1, 3, 5, 2].

4. Generación de números pseudoaleatorios:

● seed(x): inicializa la semilla para generar números pseudoaleatorios. Ejemplo: random.seed(42) establece la semilla en 42.

● random(): genera un número flotante aleatorio en el rango [0.0, 1.0). Ejemplo: random.random() puede devolver 0.639.

Módulo SYS

El módulo sys es un módulo incorporado en Python que proporciona acceso a variables y funciones relacionadas con el intérprete de Python y el sistema en el que se ejecuta.

Resumen de las funcionalidades más comunes del módulo sys junto con ejemplos:

1. Argumentos de línea de comandos:

sys.argv: es una lista que contiene los argumentos de la línea de comandos pasados al programa.

Ejemplo:

import sys for arg in sys.argv:

print(arg)

Si ejecutas el programa python mi_programa.py argumento1 argumento2, mostrará:

mi_programa.py argumento1

argumento2

2. Rutas de búsqueda de módulos:

sys.path: es una lista que contiene las rutas de búsqueda de módulos de Python. Ejemplo:

import sys for path in sys.path:

print(path)

3. Muestra las rutas de búsqueda de módulos.

Salida estándar:

sys.stdout: proporciona acceso a la salida estándar (stdout).

sys.stderr: proporciona acceso a la salida de error estándar (stderr). Ejemplo:

import sys sys.stdout.write("Este es un mensaje en la salida estándar.\n") sys.stderr.write("Este es un mensaje de error en la salida estándar de error.\n")

4. Finalización del programa:

sys.exit([código]): finaliza el programa y regresa al sistema operativo. Ejemplo:

import sys

respuesta = input("¿Desea salir del programa? (s/n): ") if respuesta.lower() == "s":

sys.exit(0) else:

print("Continuando con la ejecución del programa...")

5. Funcionalidades del intérprete:

sys.version: devuelve la cadena que representa la versión del intérprete de Python.

sys.platform: devuelve el nombre de la plataforma en la que se está ejecutando Python.

sys.stdin: proporciona acceso a la entrada estándar (stdin).

Módulos OS y SHUTIL

El módulo os y el módulo shutil son dos módulos en Python que proporcionan funcionalidades relacionadas con operaciones del sistema operativo y manipulación de archivos y directorios. A continuación, un resumen y ejemplos de funcionalidades clave de cada módulo:

Módulo OS

1. Manipulación de rutas y directorios:

os.path.join(path1, path2, ...): Une componentes de ruta para formar una ruta. os.path.exists(path): Verifica si una ruta existe en el sistema de archivos.

os.makedirs(path): Crea directorios recursivamente.

2. Operaciones de archivos:

os.path.isfile(path): Verifica si una ruta es un archivo. os.path.getsize(path): Obtiene el tamaño de un archivo en bytes.

os.remove(path): Elimina un archivo.

3. Obtención de información del sistema:

os.getcwd(): Obtiene el directorio de trabajo actual. os.listdir(path): Obtiene una lista de nombres de archivos y directorios en una ruta. Ejemplo:

import os

ruta = os.path.join("directorio", "archivo.txt") if os.path.exists(ruta):

print(f"El archivo {ruta} existe y tiene un tamaño de

{os.path.getsize(ruta)} bytes.") else:

print(f"El archivo {ruta} no existe.")

directorio_actual = os.getcwd()

print(f"El directorio de trabajo actual es: {directorio_actual}")

archivos = os.listdir(directorio_actual)

print(f"Archivos en el directorio actual: {archivos}")

Módulo SHUTIL:

1. Copia y movimiento de archivos:

shutil.copy(src, dst): Copia un archivo de origen a un destino.

shutil.move(src, dst): Mueve un archivo de origen a un destino.

2. Eliminación de directorios:

shutil.rmtree(path): Elimina un directorio y su contenido de forma recursiva.

3. Operaciones de compresión:

shutil.make_archive(base_name, format, root_dir): Crea un archivo comprimido (zip, tar, etc.) de un directorio.

Ejemplo:

import shutil

# Copia un archivo shutil.copy("origen/archivo.txt", "destino/archivo_copia.txt")

# Mueve un archivo shutil.move("origen/archivo.txt", "destino/archivo.txt")

# Elimina un directorio y su contenido shutil.rmtree("directorio_a_eliminar")

# Crea un archivo comprimido de un directorio

shutil.make_archive("mi_archivo", "zip", "directorio_a_comprimir")

Módulo Math

El módulo math es un módulo incorporado en Python que proporciona funciones matemáticas para realizar operaciones comunes. A continuación, un resumen de las funcionalidades más comunes del módulo math, junto con ejemplos:

1. Funciones matemáticas básicas:

math.sqrt(x): devuelve la raíz cuadrada de x.

Ejemplo: math.sqrt(16) devuelve 4.

math.pow(x, y): devuelve x elevado a la potencia y.

Ejemplo: math.pow(2, 3) devuelve 8.

math.floor(x): redondea hacia abajo el número x. Ejemplo: math.floor(3.7) devuelve 3.

2. Funciones trigonométricas:

math.sin(x): devuelve el seno de x (en radianes).

Ejemplo: math.sin(math.pi/2) devuelve 1.0.

math.cos(x): devuelve el coseno de x (en radianes).

Ejemplo: math.cos(0) devuelve 1.0.

math.radians(x): convierte el ángulo x de grados a radianes. Ejemplo: math.radians(90) devuelve 1.5707963267948966.

3. Funciones logarítmicas:

math.log(x): devuelve el logaritmo natural (base e) de x.

Ejemplo: math.log(10) devuelve 2.302585092994046.

math.log10(x): devuelve el logaritmo en base 10 de x. Ejemplo: math.log10(100) devuelve 2.0.

4. Funciones especiales:

math.factorial(x): devuelve el factorial de x.

Ejemplo: math.factorial(5) devuelve 120.

math.exp(x): devuelve e elevado a la potencia x.

Ejemplo: math.exp(1) devuelve 2.718281828459045.

math.pi: constante matemática que representa el valor de pi (π). Ejemplo: math.pi devuelve 3.141592653589793.

Módulo Statistics

El módulo statistics es un módulo incorporado en Python que proporciona funciones para realizar cálculos estadísticos en conjuntos de datos. A continuación, t un resumen de las funcionalidades más comunes del módulo statistics, junto con ejemplos:

1. Medidas de tendencia central:

statistics.mean(data): devuelve la media aritmética de los datos. Ejemplo: statistics.mean([1, 2, 3, 4, 5]) devuelve 3.

statistics.median(data): devuelve la mediana de los datos. Ejemplo: statistics.median([1, 2, 3, 4, 5]) devuelve 3.

statistics.mode(data): devuelve la moda de los datos (el valor más frecuente). Ejemplo: statistics.mode([1, 2, 2, 3, 3, 3, 4, 5]) devuelve 3.

2. Medidas de dispersión:

statistics.variance(data): devuelve la varianza de los datos. Ejemplo: statistics.variance([1, 2, 3, 4, 5]) devuelve 2.5.

statistics.stdev(data): devuelve la desviación estándar de los datos.

Ejemplo: statistics.stdev([1, 2, 3, 4, 5]) devuelve aproximadamente 1.58.

3. Otras medidas estadísticas:

statistics.min(data): devuelve el valor mínimo de los datos. Ejemplo: statistics.min([1, 2, 3, 4, 5]) devuelve 1.

statistics.max(data): devuelve el valor máximo de los datos. Ejemplo: statistics.max([1, 2, 3, 4, 5]) devuelve 5.

statistics.quantiles(data, n=4): devuelve una lista de n-1 cuantiles (por defecto, cuartiles) de los datos.

Ejemplo: statistics.quantiles([1, 2, 3, 4, 5]) devuelve [2, 3, 4].

Módulo Datetime

El módulo datetime es un módulo incorporado en Python que proporciona clases y funciones para trabajar con fechas, horas y operaciones relacionadas con el tiempo. A continuación, un resumen de las funcionalidades más comunes del módulo datetime, junto con ejemplos:

1. Clase datetime:

datetime.datetime.now(): devuelve la fecha y hora actual.

Ejemplo: datetime.datetime.now() devuelve algo como 2022-03-15 14:30:00.

datetime.datetime(year, month, day, hour, minute, second): crea un objeto datetime con los valores proporcionados.

Ejemplo: datetime.datetime(2022, 3, 15, 14, 30, 0) crea un objeto datetime para el 15 de marzo de 2022 a las 14:30:00.

Métodos de la clase datetime: incluyen strftime(format), para formatear una fecha y hora en una cadena, y replace(year, month, day, hour, minute, second), para crear una nueva instancia de datetime con valores reemplazados.

Ejemplo: datetime.datetime.now().strftime("%Y-%m-%d") devuelve la fecha actual en formato "YYYY-MM-DD".

2. Clase date:

datetime.date.today(): devuelve la fecha actual (sin hora).

Ejemplo: datetime.date.today() devuelve algo como 2022-03-15.

datetime.date(year, month, day): crea un objeto date con los valores proporcionados.

Ejemplo: datetime.date(2022, 3, 15) crea un objeto date para el 15 de marzo de 2022.

Métodos de la clase date: incluyen strftime(format) para formatear una fecha en una cadena y replace(year, month, day) para crear una nueva instancia de date con valores reemplazados.

Ejemplo: datetime.date.today().strftime("%Y-%m-%d") devuelve la fecha actual en formato "YYYY-MM-DD".

3. Clase time:

datetime.time(hour, minute, second): crea un objeto time con los valores proporcionados.

Ejemplo: datetime.time(14, 30, 0) crea un objeto time para las 14:30:00.

Métodos de la clase time: incluyen strftime(format) para formatear una hora en una cadena y replace(hour, minute, second) para crear una nueva instancia de time con valores reemplazados.

Manejo de Ficheros

Abrir un fichero

Para abrir un fichero en Python, puedes utilizar la función open(). Toma dos argumentos: el nombre del fichero 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 fichero. Por ejemplo:

fichero = open('nombre_fichero.txt', 'r')

Modos de apertura de un fichero

Modo de lectura ('r'): Este modo se utiliza para abrir un fichero en modo de lectura. El fichero debe existir previamente, de lo contrario, se generará un error. Por ejemplo:

Modo de escritura ('w'): Este modo se utiliza para abrir un fichero en modo de escritura. Si el fichero ya existe, su contenido se sobrescribirá. Si el fichero no existe, se creará uno nuevo. Por ejemplo:

Modo de añadir ('a'): Este modo se utiliza para abrir un fichero en modo de añadir contenido al final del mismo. Si el fichero ya existe, el nuevo contenido se agregará al final. Si el fichero no existe, se creará uno nuevo. Por ejemplo:

Modo binario ('b'): Este modo se puede agregar a cualquiera de los modos anteriores para abrir el fichero en modo binario. Se utiliza principalmente cuando se trabaja con ficheros binarios, como imágenes o archivos de audio. Por ejemplo:

fichero = open('nombre_fichero.bin', 'rb') # Modo de lectura binaria fichero = open('nombre_fichero.bin', 'wb') # Modo de escritura binaria fichero = open('nombre_fichero.bin', 'ab') # Modo de añadir binario

Además de estos modos básicos, también existen combinaciones de modos, como 'r+' para lectura y escritura, y 'a+' para añadir y lectura.

Leer el contenido de un fichero

Una vez que has abierto un fichero en modo de lectura, puedes leer su contenido utilizando varios métodos. Algunos ejemplos comunes son: read(): Lee todo el contenido del fichero como una cadena. readline(): Lee una línea del fichero. readlines(): Lee todas las líneas del fichero y las devuelve como una lista.

contenido = fichero.read() # Lee todo el contenido linea = fichero.readline() # Lee una línea lineas = fichero.readlines() # Lee todas las líneas

Escribir en un fichero

Si has abierto un fichero en modo de escritura o añadir, puedes utilizar el método write() para escribir contenido en él. También puedes utilizar el método writelines() para escribir varias líneas a la vez. Por ejemplo:

fichero.write('Hola, mundo!\n') # Escribe una línea

fichero.writelines(['Línea 1\n', 'Línea 2\n', 'Línea 3\n']) # Escribe varias líneas

Cerrar un fichero

Es importante cerrar un fichero después de haber terminado de trabajar con él. Puedes utilizar el método close() para cerrar un fichero abierto. Por ejemplo:

fichero.close()

Sin embargo, una forma más recomendada de trabajar con ficheros en Python es utilizando la declaración with. Esto garantiza que el fichero se cerrará automáticamente al finalizar el bloque de código. Aquí hay un ejemplo:

with open('nombre_fichero.txt', 'r') as fichero:

contenido = fichero.read()

# Realiza operaciones con el fichero

# El fichero se cerrará automáticamente al salir del bloque "with"

Acceso a BBDD

En Python, se puede acceder a una base de datos utilizando varios módulos y bibliotecas. A continuación, se muestra un resumen de las principales bibliotecas utilizadas para acceder a bases de datos en Python:

Python DB-API: Es una especificación de interfaz de programación de aplicaciones (API) estándar para acceder a bases de datos desde Python. Proporciona una forma consistente de interactuar con diferentes bases de datos utilizando módulos específicos de la base de datos que implementan la especificación. Algunos ejemplos de módulos de DB-API comunes son sqlite3, mysql-connector-python, psycopg2 (para PostgreSQL) y pyodbc (para bases de datos ODBC).

SQLAlchemy: Es una biblioteca de mapeo objeto-relacional (ORM) muy popular que proporciona una capa de abstracción sobre las bases de datos. Permite interactuar con la base de datos utilizando objetos Python y proporciona herramientas para trabajar con consultas, relaciones, transacciones y más. SQLAlchemy es compatible con varias bases de datos, incluyendo SQLite, MySQL, PostgreSQL y Oracle.

Pandas: Es una biblioteca de análisis de datos en Python que también proporciona funcionalidades para leer y escribir datos en bases de datos. Puedes utilizar las funciones read_sql() y to_sql() de Pandas para ejecutar consultas SQL y cargar los resultados en DataFrames de Pandas, o para guardar los datos de un DataFrame en una tabla de base de datos.

Django: Es un popular framework web de Python que incluye un ORM incorporado. Con Django, puedes definir modelos Python que representan tablas de la base de datos y utilizar las operaciones ORM para interactuar con los datos. Django es compatible con varios motores de base de datos, incluyendo SQLite, MySQL y PostgreSQL.

En Python, hay varias bibliotecas y métodos disponibles para acceder a bases de datos. Algunas de las bibliotecas más populares son sqlite3, psycopg2, mysql-connector-python, pyodbc, entre otras. Aquí se muestra una descripción de los métodos más comunes utilizados para acceder a bases de datos desde Python:

ODBC con pyodbc

● connect(connection_string, autocommit=True): Establece una conexión con una base de datos a través de ODBC.

● cursor(): Crea un objeto cursor para ejecutar consultas y obtener resultados.

● execute(operation[, parameters]): Ejecuta una consulta o sentencia SQL en la base de datos.

● executemany(operation, seq_of_parameters): Ejecuta una consulta múltiples veces con diferentes conjuntos de parámetros.

● fetchone(): Recupera la siguiente fila de un conjunto de resultados.

● fetchall(): Recupera todas las filas de un conjunto de resultados.

import pyodbc

# Establecer conexión

conexion = pyodbc.connect('DRIVER={ODBC Driver 17 for SQL

Server};SERVER=nombre_servidor;DATABASE=nombre_basedatos;UID=usuario;PWD= contraseña')

# Crear un cursor

cursor = conexion.cursor()

# Ejecutar una consulta SELECT cursor.execute("SELECT * FROM tabla") resultados = cursor.fetchall() for fila in resultados:

print(fila)

# Ejecutar una consulta INSERT cursor.execute("INSERT INTO tabla (columna1, columna2) VALUES (?, ?)",

("valor1", "valor2")) conexion.commit()

# Cerrar la conexión conexion.close()

SQLite con sqlite3

● connect(database[, timeout, isolation_level, ...]): Establece una conexión con una base de datos SQLite.

● execute(sql[, parameters]): Ejecuta una sentencia SQL en la base de datos.

● executemany(sql, seq_of_parameters): Ejecuta una sentencia SQL múltiples veces con diferentes conjuntos de parámetros.

● fetchone(): Recupera la siguiente fila de un conjunto de resultados.

● fetchall(): Recupera todas las filas de un conjunto de resultados.

import sqlite3

# Establecer conexión conexion = sqlite3.connect('basedatos.db')

# Crear un cursor

cursor = conexion.cursor()

# Ejecutar una consulta SELECT cursor.execute("SELECT * FROM tabla") resultados = cursor.fetchall() for fila in resultados:

print(fila)

# Ejecutar una consulta INSERT cursor.execute("INSERT INTO tabla (columna1, columna2) VALUES (?, ?)",

("valor1", "valor2")) conexion.commit()

# Cerrar la conexión conexion.close()

PostgreSQL con psycopg2

● connect(dsn[, connection_factory, cursor_factory, ...]): Establece una conexión con una base de datos PostgreSQL.

● execute(query[, vars]): Ejecuta una consulta o sentencia SQL en la base de datos.

● executemany(query, vars_list): Ejecuta una consulta múltiples veces con diferentes conjuntos de parámetros.

● fetchone(): Recupera la siguiente fila de un conjunto de resultados.

● fetchall(): Recupera todas las filas de un conjunto de resultados.

import psycopg2 # Establecer conexión conexion = psycopg2.connect( host="localhost", database="basedatos", user="usuario", password="contraseña"

)

# Crear un cursor

cursor = conexion.cursor() # Ejecutar una consulta SELECT cursor.execute("SELECT * FROM tabla") resultados = cursor.fetchall() for fila in resultados:

print(fila)

# Ejecutar una consulta INSERT cursor.execute("INSERT INTO tabla (columna1, columna2) VALUES (%s, %s)",

("valor1", "valor2")) conexion.commit() # Cerrar la conexión conexion.close()

MySQL con mysql-connector-python

● connect(**kwargs): Establece una conexión con una base de datos MySQL.

● cursor(buffered=False): Crea un objeto cursor para ejecutar consultas y obtener resultados.

● execute(operation, params=None, multi=False): Ejecuta una consulta o sentencia SQL en la base de datos.

● executemany(operation, seq_of_params): Ejecuta una consulta múltiples veces con diferentes conjuntos de parámetros.

● fetchone(): Recupera la siguiente fila de un conjunto de resultados.

● fetchall(): Recupera todas las filas de un conjunto de resultados.

import mysql.connector

# Establecer conexión conexion = mysql.connector.connect( host="localhost", database="basedatos",

user="usuario", password="contraseña"

)

# Crear un cursor

cursor = conexion.cursor()

# Ejecutar una consulta SELECT cursor.execute("SELECT * FROM tabla") resultados = cursor.fetchall() for fila in resultados:

print(fila)

# Ejecutar una consulta INSERT cursor.execute("INSERT INTO tabla (columna1, columna2) VALUES (%s, %s)",

("valor1", "valor2")) conexion.commit()

# Cerrar la conexión conexion.close()

Ejemplos de Funcionalidades Avanzadas con MySQL Connector Python

Transacciones

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

)

# Habilitar autocommit conexion.autocommit = False try:

# Crear un cursor

cursor = conexion.cursor()

# Iniciar transacción cursor.execute("START TRANSACTION")

# Ejecutar consultas dentro de la transacción cursor.execute("INSERT INTO tabla (columna1, columna2) VALUES (%s,

%s)", ("valor1", "valor2"))

cursor.execute("UPDATE tabla SET columna1 = %s WHERE columna2 = %s",

("nuevo_valor", "valor2"))

# Confirmar la transacción conexion.commit() print("Transacción completada con éxito.")

except mysql.connector.Error as error:

# Revertir la transacción en caso de error conexion.rollback() print("Error en la transacción:", error)

finally:

# Cerrar la conexión conexion.close()

Consultas parametrizadas

import mysql.connector

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

)

# Crear un cursor

cursor = conexion.cursor()

# Ejecutar una consulta parametrizada consulta = "SELECT * FROM tabla WHERE columna1 = %s AND columna2 = %s" parametros = ("valor1", "valor2") cursor.execute(consulta, parametros)

# Obtener los resultados

resultados = cursor.fetchall() for fila in resultados:

print(fila) # Cerrar la conexión conexion.close()

Obtener el último ID insertado

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

)

# Crear un cursor

cursor = conexion.cursor() # Ejecutar una consulta INSERT cursor.execute("INSERT INTO tabla (columna1, columna2) VALUES (%s, %s)",

("valor1", "valor2"))

# Obtener el último ID insertado ultimo_id = cursor.lastrowid print("Último ID insertado:", ultimo_id)

# Cerrar la conexión conexion.close()

Programación Orientada a Objetos en Python

Conceptos básicos

Clases

Las clases son plantillas o moldes que definen la estructura y el comportamiento de un objeto. Se definen mediante la palabra clave "class" seguida del nombre de la clase y se pueden considerar como un plano para crear objetos.

Objetos

Los objetos son instancias de una clase específica. Se crean utilizando el nombre de la clase seguido de paréntesis. Cada objeto tiene sus propios atributos (variables) y métodos (funciones) asociados.

Atributos

Los atributos son variables que almacenan información sobre el estado de un objeto. Pueden ser variables de instancia (pertenece a cada objeto individualmente) o variables de clase (compartidas entre todos los objetos de la clase).

Métodos

Los métodos son funciones que definen el comportamiento de un objeto. Pueden acceder y manipular los atributos del objeto. Al igual que los atributos, pueden ser métodos de instancia o métodos de clase.

Encapsulación

La encapsulación es un concepto que permite ocultar los detalles internos de un objeto y solo exponer una interfaz para interactuar con él. Se logra mediante el uso de modificadores de acceso como público, privado y protegido.

Herencia

La herencia es un mecanismo que permite crear nuevas clases basadas en clases existentes. La clase existente se llama clase padre o clase base, y la nueva clase se llama clase hija o clase derivada. La herencia permite compartir atributos y métodos entre las clases.

Polimorfismo

El polimorfismo es la capacidad de un objeto para tomar muchas formas diferentes. En Python, se puede lograr mediante el uso de herencia y métodos con el mismo nombre pero diferentes implementaciones en diferentes clases.

Clases

La estructura básica de una clase en Python se compone de la siguiente manera:

class NombreClase: def __init__(self, parametro1, parametro2, ...):

# Inicialización de atributos self.atributo1 = parametro1 self.atributo2 = parametro2 ...

def metodo1(self, parametro1, parametro2, ...): # Código del método ...

def metodo2(self, parametro1, parametro2, ...):

# Código del método

Explicación de los elementos de la estructura:

Definición de la clase: Se utiliza la palabra clave class seguida por el nombre de la clase. El nombre de la clase debe seguir las convenciones de nomenclatura de Python (por ejemplo, CamelCase).

Constructor (__init__): Es un método especial que se llama automáticamente al crear un objeto de la clase. Se utiliza para inicializar los atributos de la clase. Los parámetros del constructor representan los valores iniciales de los atributos.

Atributos: Son variables que almacenan información sobre el estado de un objeto. Se definen dentro del constructor o en cualquier otro método de la clase utilizando la sintaxis self.nombre_atributo = valor.

Métodos: Son funciones que definen el comportamiento de la clase. Se definen dentro de la clase y se acceden a través de los objetos de la clase. Los métodos tienen el primer parámetro self, que hace referencia al objeto que llama al método.

Ejemplo de clase:

class Persona:

def __init__(self, nombre, edad):

self.nombre = nombre

self.edad = edad

def saludar(self):

print(f"Hola, mi nombre es {self.nombre} y tengo {self.edad} años.") def cumplir_anios(self):

self.edad += 1 print(f"¡Feliz cumpleaños! Ahora tengo {self.edad} años.")

def cambiar_nombre(self, nuevo_nombre):

self.nombre = nuevo_nombre print(f"Mi nombre ha sido cambiado a {self.nombre}.")

Ejemplo de uso de la clase:

# Crear un objeto de la clase Persona persona = Persona("Juan", 25)

# Acceder a los atributos print(persona.nombre) # Salida: "Juan" print(persona.edad) # Salida: 25

# Llamar a los métodos persona.saludar() # Salida: "Hola, mi nombre es Juan y tengo 25 años." persona.cumplir_anios() # Salida: "¡Feliz cumpleaños! Ahora tengo 26 años."

persona.cambiar_nombre("Pedro")

Encapsulación

La encapsulación es un principio de la programación orientada a objetos (POO) que se refiere a la ocultación de los detalles internos de una clase y la protección de los datos y comportamientos internos de la manipulación directa desde fuera de la clase. En Python, la encapsulación se logra utilizando convenciones y modificadores de acceso.

En Python, no hay modificadores de acceso como "public", "private" o "protected" como en algunos otros lenguajes de programación. Sin embargo, existen convenciones y mecanismos que puedes utilizar para implementar la encapsulación:

● Convención de nombres: Por convención, los atributos y métodos que se consideran privados se nombran con un subrayado al comienzo del nombre, como _nombre_atributo o _nombre_metodo. Esto indica a otros desarrolladores que esos elementos deben tratarse como privados y no acceder a ellos directamente desde fuera de la clase. Sin embargo, esta convención no impide el acceso a los elementos, ya que en Python no hay una implementación estricta del encapsulamiento.

● Name Mangling: Python proporciona una funcionalidad llamada "Name Mangling" para hacer que los atributos sean menos accesibles desde fuera de la clase. Si un atributo se nombra con doble guion bajo al comienzo (__nombre_atributo), internamente, el nombre del atributo se transforma en

_NombreClase__nombre_atributo. Esto dificulta el acceso directo al atributo desde fuera de la clase, pero aún es posible acceder utilizando el nombre transformado. Sin embargo, es importante tener en cuenta que el "Name Mangling" se utiliza principalmente para evitar colisiones de nombres en las subclases y no se debe utilizar como una herramienta de seguridad para ocultar datos.

Aquí tienes un ejemplo que muestra cómo se puede implementar la encapsulación en Python:

class MiClase: def __init__(self):

self.publico = "Este es un atributo público" self._privado = "Este es un atributo privado"

def metodo_publico(self):

print("Este es un método público")

def _metodo_privado(self):

print("Este es un método privado")

objeto = MiClase()

print(objeto.publico) # Acceso al atributo público print(objeto._privado) # Acceso al atributo privado (por convención) objeto.metodo_publico() # Llamada al método público objeto._metodo_privado() # Llamada al método privado (por convención)

En este ejemplo, público es un atributo público y _privado es un atributo privado (según la convención). El método metodo_publico es un método público y _metodo_privado es un método privado (según la convención). Aunque se puede acceder a los atributos y métodos privados desde fuera de la clase, la convención indica que no se deben acceder directamente.

Herencia

La herencia es un concepto fundamental en la programación orientada a objetos (POO) que permite crear clases nuevas basadas en clases existentes. En Python, puedes implementar la herencia utilizando la siguiente sintaxis:

class ClasePadre:

# Atributos y métodos de la clase padre class ClaseHija(ClasePadre):

# Atributos y métodos adicionales de la clase hija

Explicación de la herencia en Python

La clase ClasePadre se llama clase padre o clase base. Contiene atributos y métodos que pueden ser heredados por otras clases.

La clase ClaseHija se llama clase hija o clase derivada. Hereda los atributos y métodos de la clase padre y también puede tener sus propios atributos y métodos adicionales.

La herencia permite a la clase hija heredar los atributos y métodos de la clase padre, lo que fomenta la reutilización del código y facilita la creación de jerarquías de clases. La clase hija puede acceder a los atributos y métodos heredados directamente como si fueran propios.

Aquí tienes un ejemplo para ilustrar el uso de la herencia en Python:

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

print(f"Soy un animal llamado {self.nombre}")

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

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

# Crear objetos de las clases hijas mi_perro = Perro("Fido") mi_gato = Gato("Pelusa")

# Llamar a los métodos de las clases hijas y de la clase padre mi_perro.saludar() # Salida: "Soy un animal llamado Fido" mi_perro.ladrar() # Salida: "¡Guau!" mi_gato.saludar() # Salida: "Soy un animal llamado Pelusa" mi_gato.maullar() # Salida: "¡Miau!"

En este ejemplo, la clase Animal es la clase padre que define el atributo nombre y el método saludar. La clase Perro y la clase Gato son clases hijas que heredan estos atributos y métodos de la clase Animal y también tienen sus propios métodos adicionales (ladrar y maullar, respectivamente). Al crear objetos de las clases hijas, se puede acceder a los atributos y métodos heredados, así como a los atributos y métodos propios de cada clase hija.

Herencia Múltiple

En Python, es posible lograr la herencia múltiple, que es cuando una clase hija hereda de múltiples clases padres. Para lograr esto, simplemente menciona todas las clases padres separadas por comas en la definición de la clase hija. La sintaxis es la siguiente:

class ClasePadre1:

# Atributos y métodos de la clase padre 1

class ClasePadre2:

# Atributos y métodos de la clase padre 2 class ClaseHija(ClasePadre1, ClasePadre2):

# Atributos y métodos adicionales de la clase hija

En este caso, la clase ClaseHija heredará atributos y métodos tanto de ClasePadre1 como de ClasePadre2.

Aquí tienes un ejemplo para ilustrar la herencia múltiple en Python:

class Vehiculo:

def __init__(self, marca):

self.marca = marca

def mostrar_marca(self):

print(f"Marca: {self.marca}")

class Color:

def __init__(self, color):

self.color = color

def mostrar_color(self):

print(f"Color: {self.color}")

class Coche(Vehiculo, Color): def __init__(self, marca, color):

Vehiculo.__init__(self, marca) Color.__init__(self, color) def mostrar_informacion(self):

self.mostrar_marca() self.mostrar_color() # Crear objeto de la clase hija mi_coche = Coche("Ford", "Rojo")

# Llamar a los métodos heredados de las clases padres mi_coche.mostrar_informacion() # Salida: "Marca: Ford" y "Color: Rojo"

En este ejemplo, la clase Vehiculo define el atributo marca y el método mostrar_marca, mientras que la clase Color define el atributo color y el método mostrar_color. La clase Coche hereda de ambas clases (Vehiculo y Color) y utiliza el método de inicialización de cada clase padre en su propio método __init__. La clase Coche también tiene su propio método mostrar_informacion que llama a los métodos heredados de las clases padres.

Al crear un objeto de la clase Coche, se pueden llamar a los métodos heredados de las clases padres, accediendo tanto a la información de la marca como al color del coche.

Es importante tener en cuenta que la herencia múltiple puede volverse compleja si las clases padres tienen métodos o atributos con el mismo nombre. En ese caso, se aplicará el método de resolución de nombres conocido como MRO (Method Resolution Order) para determinar el orden de búsqueda de atributos o métodos en la jerarquía de herencia.

Polimorfismo

El polimorfismo es un concepto clave en la programación orientada a objetos (POO) que permite que objetos de diferentes clases sean tratados de manera uniforme a través de una interfaz común. En Python, el polimorfismo se logra mediante el uso de herencia y la implementación de métodos con el mismo nombre en diferentes clases.

El polimorfismo permite que una misma operación se comporte de diferentes maneras según el tipo de objeto con el que se esté trabajando. Esto mejora la flexibilidad y la modularidad del código, ya que se pueden agregar nuevas clases que implementen la misma interfaz y se puedan utilizar de manera intercambiable.

Aquí tienes un ejemplo que muestra el polimorfismo en Python:

class Animal: def hablar(self):

pass class Perro(Animal): def hablar(self): return "Guau!" class Gato(Animal): def hablar(self): return "Miau!" class Vaca(Animal): def hablar(self): return "Muu!"

# Función que utiliza polimorfismo

def hacer_hablar(animal): print(animal.hablar())

# Crear objetos de diferentes clases perro = Perro() gato = Gato() vaca = Vaca()

# Llamar a la función haciendo uso del polimorfismo hacer_hablar(perro) # Salida: "Guau!" hacer_hablar(gato) # Salida: "Miau!" hacer_hablar(vaca) # Salida: "Muu!"

En este ejemplo, la clase Animal define un método hablar() que se implementa de manera diferente en cada clase derivada (Perro, Gato y Vaca). La función hacer_hablar() toma un objeto de la clase Animal y llama a su método hablar(). Como cada objeto es de un tipo diferente pero implementa el método hablar(), la función se comporta de manera polimórfica y produce resultados diferentes según el tipo de objeto con el que se llama.

El polimorfismo permite tratar diferentes objetos de manera uniforme a través de una interfaz común, lo que facilita la extensibilidad y el intercambio de objetos en el código. Esto es especialmente útil en situaciones donde se necesita escribir código genérico que pueda manejar múltiples tipos de objetos de manera flexible.

Anexos

Formateo de Numeros

Separadores de miles y decimales usando locale:

Esta técnica se utiliza para formatear números con separadores de miles y decimales basados en la configuración regional. Utiliza el módulo locale para establecer la configuración regional adecuada y luego aplica el formato.

Importa el módulo locale.

Configura la configuración regional deseada (en este caso, 'es_ES.utf8' para España). Utiliza locale.format_string() para aplicar el formato, especificando el número de decimales y la opción grouping=True para incluir separadores de miles.

import locale locale.setlocale(locale.LC_ALL, 'es_ES.utf8') numero_formateado = locale.format_string("%0.2f", numero, grouping=True)

Formato con signo, espacio y relleno

Esta técnica se utiliza para formatear números con signo, espacio y caracteres de relleno. Utiliza el método str.format() o f-string para aplicar el formato deseado.

Utiliza las llaves {} en la cadena para marcar la ubicación de formateo.

Agrega un signo + para que los números positivos también muestren el signo.

Usa 0 para indicar que se utilice el relleno con ceros.

Indica la precisión deseada con .2f para mostrar dos decimales.

numero_formateado = "{:+0.2f}".format(numero)

numero = 1234.5678

numero_formateado = f"{numero:.2f}"

Notación científica

Esta técnica se utiliza para formatear números en notación científica. Utiliza el método str.format() o f-string y especifica el formato e o E.

Utiliza {:.2e} para mostrar el número en notación científica con dos decimales. numero_formateado = "{:.2e}".format(numero)

Redondeo personalizado

Esta técnica se utiliza para redondear un número a un número específico de decimales antes de aplicar el formato. Se utiliza la función round() para redondear el número según la precisión deseada y luego se formatea.

Utiliza round() para redondear el número a la precisión deseada (en este caso, 4 decimales). Luego, aplica el formato usando {:.4f} para mostrar cuatro decimales.

numero_redondeado = round(numero, 4)

numero_formateado = "{:.4f}".format(numero_redondeado)

Formateo de porcentaje

Esta técnica se utiliza para formatear un número como un porcentaje. Se multiplica por 100 y se agrega el signo de porcentaje % al final.

Multiplica el número por 100.

Utiliza {:.2%} para mostrar el número con dos decimales y el signo de porcentaje.

ratio = 0.75

porcentaje_formateado = "{:.2%}".format(ratio)

Formateo con ancho fijo

Esta técnica se utiliza para formatear números para ocupar un ancho fijo, lo que es útil para presentar datos tabulares.

Utiliza "{:8}" para especificar un ancho fijo de 8 caracteres en la salida. Los números se alinearán a la derecha dentro de ese espacio.

numeros = [10, 200, 3000, 40000]

numeros_formateados = ["{:8}".format(numero) for numero in numeros]

Formateo de Fechas

El formateo de fechas en Python implica tomar una fecha en un objeto datetime o date y representarla en una cadena de texto en un formato deseado. Python proporciona la librería datetime para trabajar con fechas y horas, y hay varias formas de formatear fechas en Python.

A continuación, te muestro algunas técnicas comunes para formatear fechas en Python:

Usando strftime()

Puedes utilizar el método strftime() de objetos datetime o date para formatear fechas según un formato específico. Este método toma un argumento de formato que especifica cómo se debe representar la fecha.

from datetime import datetime

fecha_actual = datetime.now() fecha_formateada = fecha_actual.strftime("%d/%m/%Y %H:%M:%S")

En este ejemplo, "d/m/Y H:M:S" es el formato de fecha y hora, donde %d representa el día, %m el mes, %Y el año, %H la hora, %M los minutos y %S los segundos.

Usando strptime() para convertir una cadena en una fecha: Si tienes una cadena que representa una fecha y deseas convertirla en un objeto datetime o date, puedes utilizar el método strptime().

from datetime import datetime

fecha_str = "2023-10-20"

fecha = datetime.strptime(fecha_str, "%Y-%m-%d")

En este ejemplo, "Y-m-d" es el formato de la cadena que coincide con el formato de fecha proporcionado.

Usando librerías de formateo avanzado

Python también ofrece librerías de formateo de fechas más avanzadas, como arrow o dateutil, que facilitan el formateo de fechas en varios formatos.

import arrow

fecha_actual = arrow.now() fecha_formateada = fecha_actual.format("DD/MM/YYYY HH:mm:ss") Librerías como arrow proporcionan una sintaxis más legible y opciones avanzadas para el formateo de fechas.

Usando f-strings (Python 3.8+)

A partir de Python 3.8, puedes utilizar f-strings para formatear fechas directamente en la cadena.

from datetime import datetime

fecha_actual = datetime.now()

fecha_formateada = f"{fecha_actual:%d/%m/%Y %H:%M:%S}"

El formato de fecha se especifica dentro de las llaves {} después del símbolo de porcentaje %.

Estos son solo algunos ejemplos de cómo formatear fechas en Python. Puedes adaptar el formato a tus necesidades específicas, dependiendo de si deseas mostrar la fecha y la hora, solo la fecha, o cualquier otro formato personalizado. Las opciones de formateo son flexibles y te permiten representar las fechas de manera legible para los usuarios o para el almacenamiento de datos.

Uso Avanzado de Funciones

Funciones Lambda (Funciones Anónimas)

Las funciones lambda son funciones pequeñas y anónimas que se definen con la palabra clave lambda. Se utilizan principalmente para crear funciones simples en una sola línea. Son útiles en situaciones donde se necesita una función temporal.

cuadrado = lambda x: x**2

resultado = cuadrado(5) # resultado será 25

Funciones de Orden Superior (Higher-Order Functions):

Python admite funciones de orden superior, lo que significa que puedes pasar funciones como argumentos a otras funciones o devolver funciones desde otras funciones. Esto es útil para la programación funcional y la creación de abstracciones más poderosas.

def aplicar(funcion, lista):

return [funcion(elemento) for elemento in lista]

cuadrado = lambda x: x**2 lista = [1, 2, 3, 4, 5]

resultados = aplicar(cuadrado, lista) # resultados será [1, 4, 9, 16, 25]

Decoradores (Decorators):

Los decoradores son funciones que se utilizan para modificar el comportamiento de otras funciones. Son útiles para agregar funcionalidades a una función sin modificar su código fuente. Se aplican usando la sintaxis @decorador.

def mi_decorador(funcion): def wrapper(): print("Antes de llamar a la función") funcion() print("Después de llamar a la función") return wrapper

@mi_decorador def saludo():

print("¡Hola!")

saludo()

Funciones Generadoras (Generator Functions):

Las funciones generadoras son una forma avanzada de crear iteradores en Python. Utilizan la palabra clave yield para pausar la ejecución y permitir la reanudación de la función. Esto es útil para procesar grandes conjuntos de datos o secuencias infinitas de manera eficiente.

def numeros_pares():

n = 0 while True: yield n n += 2

generador = numeros_pares() for i in range(5):

print(next(generador))

Funciones Recursivas (Recursive Functions):

Las funciones recursivas son funciones que se llaman a sí mismas para resolver un problema. Python admite la recursión y es útil para problemas que se pueden descomponer en subproblemas más pequeños.

Ejemplo (cálculo del factorial):

def factorial(n): if n == 0: return 1 else:

return n * factorial(n - 1)

Funciones con Argumentos Arbitrarios:

Puedes definir funciones con argumentos arbitrarios utilizando *args y **kwargs. Esto permite pasar un número variable de argumentos posicionales y de palabras clave.

Ejemplo:

def funcion_arbitraria(a, *args, **kwargs): print(f"Argumento a: {a}") print(f"Argumentos arbitrarios: {args}") print(f"Argumentos de palabras clave arbitrarios: {kwargs}")

funcion_arbitraria(1, 2, 3, x=4, y=5)

Lambdas

En Python, una función lambda es una función anónima que se define sin un nombre utilizando la palabra clave lambda. A diferencia de una función regular definida con la palabra clave def, una función lambda se puede declarar en una sola línea y se utiliza para crear funciones pequeñas y simples.

La sintaxis básica de una función lambda es la siguiente:

lambda argumentos: expresión

● lambda: es la palabra clave utilizada para definir una función lambda.

● argumentos: son los argumentos de la función separados por comas. Pueden ser cero o más argumentos.

● expresión: es la expresión que se evalúa y devuelve como resultado de la función lambda.

A diferencia de una función regular, una función lambda no contiene un bloque de código con instrucciones. En su lugar, la expresión después de los dos puntos (:) se evalúa y se devuelve como resultado de la función.

Aquí tienes un ejemplo sencillo de una función lambda que suma dos números:

suma = lambda a, b: a + b resultado = suma(3, 4) print(resultado) # Salida: 7

En este caso, hemos definido una función lambda suma que toma dos argumentos a y b y devuelve su suma. Luego, llamamos a la función lambda pasando los valores 3 y 4 como argumentos y almacenamos el resultado en la variable resultado. Finalmente, imprimimos el resultado, que es 7.

Las funciones lambda son especialmente útiles cuando se requieren funciones pequeñas y simples, como en el caso de usar funciones de orden superior, como map(), filter() o reduce(). También se utilizan comúnmente en programación funcional y en expresiones lambda en Python.

Ejemplos de uso

Nivel básico

1. Suma de dos números:

suma = lambda a, b: a + b resultado = suma(3, 4) print(resultado) # Salida: 7

2. Verificar si un número es par:

es_par = lambda x: x % 2 == 0 print(es_par(4)) # Salida: True print(es_par(5)) # Salida: False

3. Elevar un número al cuadrado:

cuadrado = lambda x: x ** 2 resultado = cuadrado(3) print(resultado) # Salida: 9

4. Obtener el primer carácter de una cadena:

primer_caracter = lambda cadena: cadena[0] resultado = primer_caracter("Hola") print(resultado) # Salida: 'H'

5. Comprobar si una cadena contiene una subcadena:

contiene_subcadena = lambda cadena, subcadena: subcadena in cadena print(contiene_subcadena("Hola mundo", "mundo")) # Salida: True print(contiene_subcadena("Hola mundo", "Python")) # Salida: False

Nivel intermedio

1. Ordenar una lista de objetos por un atributo específico:

objetos = [...] # Lista de objetos

ordenados = sorted(objetos, key=lambda x: x.atributo)

Este ejemplo utiliza una lambda para especificar el atributo por el cual se desea ordenar los objetos.

2. Filtrar elementos de una lista que cumplan cierta condición:

numeros = [...] # Lista de números

pares = list(filter(lambda x: x % 2 == 0, numeros))

En este caso, la lambda se utiliza como función de filtrado para obtener únicamente los números pares de la lista.

3. Mapear una función a una lista de elementos:

numeros = [...] # Lista de números

duplicados = list(map(lambda x: x * 2, numeros))

Aquí, la lambda se emplea para duplicar cada número de la lista utilizando la función map().

4. Realizar operaciones aritméticas complejas:

operacion = lambda x, y: (x + y) * (x - y) # (x + y) * (x - y) resultado = operacion(3, 2) # Aplicando la lambda a los valores 3 y 2

En este ejemplo, se define una lambda que representa una operación matemática y luego se aplica a dos valores.

5. Definir funciones de orden superior:

def operador_matematico(operacion):

return lambda x, y: operacion(x, y)

suma = operador_matematico(lambda x, y: x + y) resta = operador_matematico(lambda x, y: x - y)

resultado_suma = suma(3, 2) # 5 resultado_resta = resta(3, 2) # 1

Nivel avanzado

1. Ordenar una lista de objetos utilizando múltiples criterios de clasificación:

objetos = [...] # Lista de objetos ordenados = sorted(objetos, key=lambda x: (x.atributo1, x.atributo2))

En este ejemplo, la lambda se utiliza para ordenar los objetos primero por atributo1 y luego por atributo2.

2. Crear una función generadora infinita utilizando una lambda:

generador_infinito = lambda: (x for x in range(1, float('inf')))

Aquí, la lambda se utiliza para crear una función generadora que genera números infinitamente, comenzando desde 1.

3. Implementar una función de memorización utilizando una lambda:

memoize = lambda f: (lambda *args: memoize(f)(*args)) if isinstance(f, type(lambda:0)) else f

En este ejemplo, la lambda se utiliza para crear una función de memorización que almacena en caché los resultados de llamadas anteriores.

4. Crear una función curried utilizando una lambda:

curry = lambda f: (lambda x: curry(lambda *args: f(x, *args))) if f.func_code.co_argcount > 1 else f

En este caso, la lambda se utiliza para implementar una función curried, que permite aplicar parcialmente los argumentos de una función.

5. Implementar un decorador personalizado utilizando una lambda:

def custom_decorator(arg):

return lambda func: lambda *args, **kwargs: arg + func(*args, **kwargs)

@custom_decorator(10) def my_function(x):

return x * 2

resultado = my_function(5) # 20

Hilos - Módulo threading

El módulo threading es un módulo incorporado de Python que proporciona una interfaz de alto nivel para trabajar con hilos. Este módulo facilita la creación, administración y coordinación de hilos en Python.

Clases y Funciones importantes del módulo threading

Clase Thread:

La clase Thread es la base para crear y manipular hilos en Python. Se utiliza para crear objetos de hilo que pueden ejecutar funciones en segundo plano. Algunos métodos clave de la clase Thread son:

● start(): Inicia la ejecución del hilo.

● join(): Espera a que el hilo termine su ejecución.

● run(): Define el punto de entrada para la ejecución del hilo. Puedes subclasificar la clase Thread y sobrescribir este método para personalizar el comportamiento del hilo. Clase Lock:

La clase Lock proporciona un mecanismo básico de bloqueo que se utiliza para controlar el acceso a recursos compartidos en un entorno multihilo. Permite a un hilo adquirir un bloqueo y asegurarse de que ningún otro hilo pueda acceder al recurso hasta que el bloqueo se libere.

Algunos métodos importantes de la clase Lock son:

● acquire(): Adquiere el bloqueo. Si otro hilo ya lo ha adquirido, el hilo se bloquea hasta que el bloqueo esté disponible. ● release(): Libera el bloqueo.

Clase Condition:

La clase Condition proporciona un mecanismo de sincronización más avanzado que combina un bloqueo con una variable de condición. Se utiliza para coordinar la ejecución entre múltiples hilos.

Algunos métodos clave de la clase Condition son:

● acquire(), release(): Adquieren y liberan el bloqueo asociado con la variable de condición.

● wait(): Pone al hilo en espera hasta que otro hilo notifique la condición.

● notify(), notify_all(): Notifican a los hilos en espera que la condición ha ocurrido y deben continuar.

Clase Semaphore:

La clase Semaphore es una implementación de semáforos en Python. Se utiliza para controlar el acceso a un número limitado de recursos simultáneamente.

Algunos métodos importantes de la clase Semaphore son:

● acquire(): Adquiere el semáforo. Si el número de recursos disponibles es cero, el hilo se bloquea hasta que se libere un recurso.

● release(): Libera el semáforo.

Clase Event:

La clase Event proporciona una forma de que los hilos se comuniquen entre sí mediante señales. Se utiliza para notificar que un evento ha ocurrido.

Algunos métodos clave de la clase Event son:

● set(): Establece el estado del evento en "verdadero", desbloqueando los hilos en espera.

● clear(): Restablece el estado del evento en "falso".

● wait(): Pone al hilo en espera hasta que el estado del evento sea "verdadero".

Funcionalidad Básica con ejemplos

Se puede utilizar hilos para ejecutar varias funciones simultáneamente. Cada función se ejecutará en un hilo separado.

Ejemplo básico

import threading def funcion1():

print("Función 1 ejecutándose") def funcion2():

print("Función 2 ejecutándose")

# Crear los objetos Thread para cada función hilo1 = threading.Thread(target=funcion1) hilo2 = threading.Thread(target=funcion2) # Iniciar la ejecución de los hilos hilo1.start() hilo2.start()

# Esperar a que ambos hilos terminen hilo1.join() hilo2.join() print("Programa principal")

En este ejemplo, las funciones funcion1 y funcion2 se ejecutarán simultáneamente en hilos separados.

Control de concurrencia con bloqueo (Lock)

Puedes utilizar un objeto Lock para controlar el acceso concurrente a secciones críticas de código.

import threading contador = 0 lock = threading.Lock() def incrementar(): global contador for _ in range(100000):

lock.acquire() contador += 1 lock.release() def decrementar(): global contador for _ in range(100000):

lock.acquire() contador -= 1 lock.release()

# Crear los objetos Thread para cada función hilo1 = threading.Thread(target=incrementar) hilo2 = threading.Thread(target=decrementar)

# Iniciar la ejecución de los hilos hilo1.start() hilo2.start()

# Esperar a que ambos hilos terminen hilo1.join() hilo2.join() print("Valor final del contador:", contador)

En este ejemplo, utilizamos un objeto Lock para asegurarnos de que solo un hilo pueda acceder y modificar la variable contador a la vez, evitando problemas de concurrencia.

Comunicación entre hilos con colas (Queue)

Puedes utilizar una cola (Queue) para la comunicación y sincronización entre hilos.

import threading import queue cola = queue.Queue() def productor(): for i in range(5):

mensaje = "Mensaje {}".format(i) cola.put(mensaje) print("Productor: mensaje '{}' producido".format(mensaje))

def consumidor(): while True:

mensaje = cola.get()

print("Consumidor: mensaje '{}' consumido".format(mensaje)) cola.task_done()

# Crear los objetos Thread para cada función hilo_productor = threading.Thread(target=productor) hilo_consumidor = threading.Thread(target=consumidor)

# Iniciar la ejecución de los hilos hilo_productor.start() hilo_consumidor.start()

# Esperar a que el productor termine (en este caso, el consumidor se ejecuta en un ciclo infinito) hilo_productor.join() print("Programa principal")

En este ejemplo, el productor agrega mensajes a una cola, y el consumidor los retira y los procesa. La cola garantiza que el consumidor solo pueda consumir mensajes cuando haya mensajes disponibles.

Documentación De Referencia

threading — Thread-based parallelism — Python 3.11.3 documentation https://docs.python.org/3/library/threading.html

Pruebas Python

unittest es el módulo de pruebas estándar de Python y proporciona una serie de características y funcionalidades para escribir y ejecutar pruebas unitarias. A continuación, te mostraré una visión general de las características clave de unittest:

Clase unittest.TestCase

Las pruebas se organizan en clases que heredan de unittest.TestCase. Cada método en estas clases que comienza con "test_" se ejecutará como una prueba individual.

import unittest

class MiPrueba(unittest.TestCase): def test_algo(self): # Tu prueba aquí

Métodos de aserción

unittest proporciona varios métodos de aserción para verificar resultados. Algunos de los más comunes son:

assertEqual(a, b): Verifica que a sea igual a b. assertTrue(x): Verifica que x sea True. assertFalse(x): Verifica que x sea False. assertIs(a, b): Verifica que a sea idéntico a b.

assertRaises(exception, callable, *args, **kwargs): Verifica que callable(*args, **kwargs) genere una excepción del tipo exception.

Configuración y limpieza

unittest proporciona métodos especiales para configurar y limpiar el estado antes y después de cada prueba, como setUp y tearDown. Estos métodos son útiles para establecer condiciones iniciales y limpiar después de la prueba.

import unittest

class MiPrueba(unittest.TestCase): def setUp(self):

# Configuración inicial self.valor = 42

def test_algo(self):

self.assertEqual(self.valor, 42)

def tearDown(self):

# Limpieza después de la prueba

Vistas
1	Número de vistas
1	Vistas de miembros
0	Vistas públicas

Acciones
0	Gustos
0	No me gusta
0	Comentarios