Javascript: Comprobar si un objeto está vacio.

¿Cómo saber si un objeto en Javascript está vacio o no?

En Python, por ejemplo, la evaluación de un diccionario o lista  que estén vacios (sin contenido), retornará un valor falso.

bool({}) # Retornará False.

bool([]) # Retornará False.

Pero en Javascript es diferente. La evaluación siguiente retornará un valor verdadero, aunque el objeto esté vacio:

// Creamos un objeto y su contenido.

var obj1 = {nombre: "limón", color: "verde"}

// Creamos un objeto vacio.

var obj2 = {}

// Confirmamos la existencia del objeto 1, y es verdadera.

if (obj1) {

  console.log("El objeto 1 existe, y tiene contenido.");

}

// Confirmamos la existencia del objeto 2, y también es verdadera.

if (obj2) {

  console.log("El objeto 2 también existe, pero está vacio.")

}

La ejecución del código anterior producirá la siguiente salida:

[LOG]: "El objeto 1 existe, y tiene contenido." 

[LOG]: "El objeto 2 también existe, pero está vacio." 

Pero lo que necesitamos es comprobar si un objeto está o no vacio. La siguiente función te podrá ayudar, incluso sin saber si el "objeto" a evaluar es realmente un objeto, porque lo que necesitas saber es:

1. Si es un objeto.
2. Si tiene valor.

/**

 * Confirma si un objeto existe y tiene valor.

 * @param obj Objeto a evaluar. Puede ser cualquier tipo.

 * @returns Retorna true si el objeto existe y no está vacio, false todo lo contrario.

 */

function isObject(obj) {

    if (obj == undefined || !obj) {

        return false;

    }

    try {

        if (Object.keys(obj).length) {

            return true;

        }

        else {

            return false;

        }

    }

    catch (error) {

        return false;

    }

}

Python: Hola Mundo con Kivy

Kivy es una biblioteca de Python de código abierto para el desarrollo rápido de aplicaciones que utilizan interfaces de usuario innovadoras, como aplicaciones multitáctiles.

Hola Mundo con Kivy

Instalación de Kivy

pip install kivy

Código fuente

Creamos un archivo con la extención .py con el siguiente contenido:

import kivy 

# Para crear una interfaz de usuario necesitamos 

# importar el módulo de la aplicación Kivy:

from kivy.app import App

# Importamos una etiqueta con la que 

# mostraremos el texto "Hola Mundo".

from kivy.uix.label import Label

# Cambie esto a su versión de Kivy instalada.

kivy.require("2.0.0")

# Esta es la clase principal de nuestra aplicación. 

# Aquí se construirá la ventanda con una etiqueta 

# con el texto "Hola Mundo".

class HelloWorldKivyApp(App):

    # Método que retorna el widget raiz.

    def build(self):

        # La etiqueta con el texto "Hola Mundo" es 

        # retornada como widget raiz.

        return Label(text="Hello World")

# Aquí es inicializada nuestra clase y el método 

# run es llamado, iniciando así nuestra aplicación.

HelloWorldKivyApp().run()

Ejecutamos nuestro código:

python [nombredetuarchivo].py

¡Y listo!

Código para mostrar las diferencias entre tus modelos Django y la base de datos

¿Cómo saber si existen diferencias entre tus modelos Django y la base de datos? 

Es posible que, por lo menos una vez en la vida, hayas tenido problemas aplicando las migraciones de tu proyecto Django.

Las migraciones son la forma en que Django propaga los cambios que realiza en sus modelos (agregar un campo, eliminar un modelo, etc.) en el esquema de su base de datos. Están diseñados para ser en su mayoría automáticos, pero necesitará saber cuándo realizar migraciones, cuándo ejecutarlas y los problemas comunes que puede encontrar. https://docs.djangoproject.com/en/3.1/topics/migrations/

¿Cuáles son los problemas más comunes? 

 El sistema de migraciones de Django es un sistema bastante potente. Te permite realizar varias operaciones importantes en tu base de datos, sin tan siquiera tener que escribir SQL. El sistema puede crear, a partir de los modelos que hayas creado en tus aplicaciones, toda la estructura de la base de datos, las modificaciones que realices a tus modelos se verán reflejadas en tu base de datos con tan solo escribir python manage.py makemigrations y python manage.py migrate. También te permite realizar la operación de manera contraria, creando tus modelos a partir de una base de datos ya existente. Pero, como bien lo dice el equipo de Django en su guía:

"no es perfecto y, para cambios complejos, es posible que no detecte lo que esperaba".

De modo que puedas verte en la necesidad de realizar ajustes en tus modelos o en la base de datos de forma manual. El siguiente código te puede ayudar a encontrar las diferencias existentes entre tus modelos y la base de datos:

from django.db import connections
from django.db.models import ForeignKey, ManyToOneRel, ManyToManyRel, ManyToManyField
from django.db.utils import OperationalError
from django.core.exceptions import ObjectDoesNotExist
from django.conf import settings


def get_cursor(db_alias="default"):
    """
    Obtiene el cursor de la conección a la base de datos.
    """
    return connections[db_alias].cursor()

def check_database():
    """
    Compruba que la información de los modelos está acorde con la información
    en la base de datos. Los campos que estén acordes con la información de la 
    base de datos, serán marcados con una [X]; una casilla vacia en caso contrario [ ].
    """
    from django.contrib.contenttypes.models import ContentType
    qs = ContentType.objects.all()
    cursor = get_cursor()
    models_evals = []
    dbname = str(settings.DATABASES["default"]["NAME"])
    text = f"=======================\nTest: {dbname}\n=======================\n"
    print(text)
    for ct in qs:
        model = ct.model_class()
        if (model is None):
            continue
        models_evals, text = check_model(model, cursor, models_evals, text)
    
    filename = dbname.replace("$", "_").replace(".", "_").replace(" ", "_")
    filename = "test/" + filename.split("/")[-1] + ".txt"
    f = open(filename, "w")
    f.write(text)
    f.close()
    print(f"Guardado en: '{filename}'")

def check_model(model, cursor, models_evals=[], text=""):
    """
    Compara la información de los campos del modelo indicado, con la base de datos.
    """
    if (str(model) in models_evals):
        return models_evals, text
    print("\n----------------------------------")
    print(model, model._meta.verbose_name)
    text += f"\n{model} | {model._meta.verbose_name}\n"
    
    models_evals.append(str(model))
    try:
        fields = model._meta.get_fields()
    except (AttributeError) as e:
        return models_evals, text
    manytomanyfieldsmodels = []
    for field in fields:
        name = field.name
        if isinstance(field, ForeignKey):
            name = name + "_id"
        elif isinstance(field, ManyToManyField):
            manytomanyfieldsmodels.append(field.related_model)
            print(f"Relación: {field}")
            text += f"Relación: {field}\n"
            continue
        elif (isinstance(field, (ManyToOneRel, ManyToManyRel))):
            print(f"Dependiente: {field}")
            text += f"Dependiente: {field}\n"
            continue
        pri = f" - Field: {field.__class__.__name__}( '{name}' )"
        
        try:
            cursor.execute(f"SELECT {name} FROM {model._meta.db_table};")
        except (OperationalError) as e:
            pri = "[ ] "+ pri + f" | Error: {e}"
        else:
            pri = "[X] " + pri
        print(pri)
        text += f"{pri}\n"
    for many_model in manytomanyfieldsmodels:
        models_evals, text = check_model(many_model, cursor, models_evals, text)
    return models_evals, text

Cálculo de la cuota de un préstamo con Python

Función en Python para calcular las cuotas de un préstamo según el sistema francés, en el que las cuotas son fijas.

¿Qué es el sistema de amortización francés?

El sistema de amortización francés, es uno de los principales sistemas que se emplean a la hora de amortizar hipotecas. El sistema de amortización francés es aquel que se caracteriza por ser un sistema de amortización de cuotas constantes.

Debido a que las cuotas son constantes, cada mes el banco recibe los intereses en función del capital pendiente de amortizar. Por ello, durante los primeros años de la hipoteca, se paga una cantidad mayor de intereses que de capital y en cambio, durante el período final del préstamo, por pagar más capital e intereses menores.

from decimal import Decimal

def GetValorDeCuotaFija(self, monto, tasa, cuotas, periodo=MENSUAL, limit_dec=None):

    """

    Retorna el valor actual de la cuota, según el método francés,

    en donde las cuotas son fijas. -> float(x)

 

    Formula = R = P [(i (1 + i)**n) / ((1 + i)**n – 1)].

    Donde:

    R = renta (cuota)

    P = principal (préstamo adquirido)

    i = tasa de interés

    n = número de periodos

    -> (Moneda valor, Moneda interes, Moneda monto)

    """

    tasa = tasa / Decimal(100)

    if periodo == DIARIO:

        tasa /= Decimal(30.4167)

    elif periodo == SEMANAL:

        tasa /= Decimal(4.34524)

    if periodo == QUINCENAL:

        tasa /= Decimal(2.0)

    elif periodo == ANUAL:

        tasa *= 12

    # Si no se especifica una tasa, se pone un número casi imperceptible para

    # evitar que la formula lanze una excepción de división por cero.

    if not tasa:

        tasa = Decimal(0.00000000001)

    # Furmula para el cálculo según el sistema francés.

    valor = monto * ( (tasa * ((1 + tasa)**cuotas)) / (((1 + tasa)**cuotas) - 1) )

    interes = valor - monto

    if limit_dec:

        return (round(valor, limit_dec), round(interes, limit_dec), round(monto, limit_dec))

    return (valor, interes, monto)

¿Te diste cuenta que hemos utilizado la clase Decimal del módulo decimal, en vez de un objeto float? La razón principal es la precisión. En este artículo te cuento acerca de las diferencias entre Decimal y float.

Enlaces externos:
Sistema de amortización francés