Una pregunta que se suele dar con mucha frecuencia en las entrevistas a desarrolladores de JavaScript es explicar la diferencia entre los métodos find() y filter().

En este tutorial, veremos qué son estos métodos y cuándo debes usarlos.

¿Qué es el método filter()?

Este método devuelve todos los elementos de un arreglo que satisfacen la condición especificada en la función del callback (retrollamada).

Veamos con un ejemplo cómo funciona:

const x = [1, 2, 3, 4, 5];

const y = x.filter(el => el*2 === 2);

console.log("y es: ", y); // y es: [1]

Examinando la salida del ejemplo anterior, vemos que el valor de y es un arreglo con 1 elemento, el único del arreglo x que cumple la condición: se ha filtrado el arreglo. El método filter() itera sobre todos los elementos de un arreglo y devuelve otro arreglo con los elementos que cumplen la condición especificada en la función de callback.

¿Qué es el método find()?

Este método devuelve el primer elemento de un arreglo que satisface la condición especificada en la función de callback.

Como en el punto anterior, veamos un ejemplo:

const x = [1, 2, 3, 4, 5];

const y = x.find(el => el*2 === 2);

console.log("y es: ", y); // y es: 1

Vemos que el valor de y es 1. El lector poco atento dirá: "lo mismo que antes, con filter()". ¡No! Con filter() se obtenía un arreglo con un elemento, se recorre el arreglo entero en busca de todos los elementos que cumplan la condición; find() comienza a iterar pero se detiene en cuanto encuentra un valor que cumpla la condición y lo devuelve. Por eso no devuelve un arreglo, solo va a devolver ese primer valor que encuentre, haya lo que haya después.

Resumiendo:

1. filter() devuelve un arreglo con todos los elementos que cumplen la condición; find() devuelve el primer elemento que satisface la condición.
2. Con filter() se itera todo el arreglo; find() se detiene al encontrar el primer elemento que cumpla la condición.

Si ningún elemento cumple la condición, filter() devuelve un arreglo vacío, [], mientras que find() devuelve undefined.

Casos de uso para find() y filter()

Cuando se quiere aplicar la condición a todo el arreglo, esperando de manera implícita que sea devuelto más de un elemento, habrá que utilizar filter(); si se espera que sólo sea devuelto un valor, se usará find() y se ahorrará el procesamiento de todo el arreglo.

Veamos un ejemplo de cada caso de uso:

1. Ejemplo de caso de uso para filter()

const x = [1, 2, 3, 4, 5];

const y = x.filter(el => el%2 === 0);

console.log("y es: ", y); // y es: [2, 4]

El objetivo aquí es encontrar todos los elementos pares. Obviamente hay que utilizar filter() ya que es necesario recorrer todo el arreglo, y es muy probable que sea devuelto más de un elemento.

2. Ejemplo de caso de uso para find()

const emp = [
    {
        nombre: "Ram",
        empID: 101
    },
    {
        nombre: "Sham",
        empID: 102
    },
    {
        nombre: "Mohan",
        empID: 103
    }
];

const res = emp.find(el => el.empID === 102);

console.log("res es: ", res); // res es: {nombre: 'Sham', empID: 102}

Aquí sin embargo tiene más sentido usar find(). Se sabe que los posibles valores que puede tomar empID son únicos, por lo que una búsqueda sobre ese parámetro va a devolver exclusivamente un elemento. Además, así se evita la iteración sobre todo el arreglo.

¡Gracias por tu tiempo!

Si te ha resultado útil, comparte este artículo con amigos y compañeros.

Un DataFrame (marco de datos) de pandas es una estructura de datos bidimensional que permite almacenar información en forma de filas y columnas. Es una estructura muy útil para realizar análisis de datos.

Dependiendo del modelo o del objetivo de tu estudio, es posible que necesites eliminar un grupo específico de filas del DataFrame.

En este tutorial veremos como eliminar una lista de filas de un DataFrame de pandas.

Como eliminar una fila o una columna de un DataFrame de pandas

Para eliminar una fila o una columna de un DataFrame, necesitas el método drop() del DataFrame. Puedes leer más acerca del método drop() en la  documentación.

Ejes del DataFrame

• Las filas se denotan mediante axis=0
• Las columnas se denotan mediante axis=1

Etiquetas del DataFrame

• Las filas se etiquetan, por defecto, mediante un índice numérico, comenzando por el 0.
• Las columnas se etiquetan por nombre.

Parámetros del método drop()

• index - la lista de filas a eliminar
• axis=0 - indica que son filas, y no columnas, lo que hay que eliminar
• inplace=True - realiza la operación sobre el mismo DataFrame, en lugar de crear y devolver uno nuevo.

DataFrame de muestra

Nuestro DataFrame de muestra contiene las columnas, nombre_producto, precio_unitario, num_de_unidades, cantidad_disponible y disponible_desde_fecha. El valor NaN se usa para denotar valores nulos.

import pandas as pd

data = {"nombre_producto":["Teclado","Raton", "Monitor", "CPU","CPU", "Altavoces",pd.NaT],
        "precio_unitario":[500, 200, 5000.235, 10000.550, 10000.550, 250.50,None],
        "num_de_unidades":[5, 5, 10, 20, 20, 8, pd.NaT],
        "cantidad disponible":[5, 6, 10, "no disponible", "no disponible", pd.NaT, pd.NaT],
        "disponible_desde_fecha":['5/11/2021', '23/4/2021', '21/08/2021', '18/09/2021', '18/09/2021', '05/01/2021', pd.NaT]
       }

df = pd.DataFrame(data)

df

El DataFrame tendrá el siguiente aspecto:

Después de cada operación de eliminación, imprimiremos el DataFrame médiate df con el formato de tabla de HTML.

A continuación veremos distintas formas de seleccionar las filas a eliminar.

Como eliminar una lista de filas mediante índice

Se puede eliminar una serie de filas pasándole al métododrop() una lista con los índices.

df.drop([5,6], axis=0, inplace=True)

df

En este fragmento,

• [5,6] son los índices de las filas a eliminar.
• axis=0 denota que son filas lo que hay que eliminar
• inplace=True realiza la operación sobre el mismo DataFrame

Tras eliminar las filas con índices 5 y 6, los datos en el DataFrame serán:

Como eliminar filas mediante un intervalo de índices

También se puede eliminar una serie de filas en un intervalo específico.

Esto puede ser útil para crear una muestra de nuestro conjunto de datos excluyendo intervalos específicos de datos.

Se puede crear un intervalo de filas en un DataFrame mediante el método df.index(), pasándolo luego al método drop() para eliminar esas filas, como se muestra a continuación:

df.drop(df.index[2:4], inplace=True)

df

Qué está haciendo este código:

• df.index[2:4] genera un intervalo de filas desde la 2ª hasta la 3ª. El límite inferior es inclusivo, mientras que el superior es exclusivo. Es decir, que serán eliminadas las filas 2 y 3, mientras que la 4ª no será eliminada.
• inplace=True realiza la operación de eliminación sobre el mismo DataFrame.

Después de eliminar filas en el intervalo 2-4, el DataFrame queda de la siguiente manera:

Como eliminar todas las filas después de un índice

Es posible eliminar todas las filas posteriores a un índice determinado mediante iloc[].

Con el método iloc[] se seleccionan las filas mediante índices, especificando las posiciones inicial y final separadas por :. Por ejemplo, ya hemos usado 2:4 para seleccionar las filas 2 y 3. Si las queremos seleccionar todas, simplemente pasamos : a iloc[].

Esto resulta útil en los casos en los que se quiera dividir el conjunto de datos con propósitos de prueba.

El siguiente fragmento selecciona las filas con índices 0 y 1 y lo asigna a la misma variable. El resultado final es la eliminación de todas las filas a partir del índice 2.

df = df.iloc[:2]

df

Con :2 se seleccionan las filas hasta el índice 2 (exclusivo).

Después de esta operación, nuestro DataFrame tendrá el siguiente aspecto:

Com eliminar filas usando múltiples condiciones

En lugar de especificar unas filas concretas mediante índices, es posible seleccionar las filas que cumplan unas determinadas condiciones.

Por ejemplo, podrías eliminar filas cuyo valor en alguna de las columnas fuera mayor que X y menor que Y.

Esto puede ser útil en el caso de que quieras crear un conjunto de datos que ignore unos valores específicos en ciertas columnas.

Para eliminar filas condicionalmente, selecciona los índices de las filas que cumplan la condición, pasándolos luego al método drop().

df.drop(df[(df['precio_unitario'] >400) & (df['precio_unitario'] < 600)].index, inplace=True)

df

En el código anterior,

• (df['Unit_Price'] >400) & (df['Unit_Price'] < 600) es la condición para eliminar las filas.
• df[].index selecciona los índices de las filas que cumplen la condición.
• inplace=True realiza la operación de eliminado sobre el mismo DataFrame, en lugar de crear y devolver uno nuevo.

Después de eliminar las filas que cumplen la condición de tener precio_unitario mayor que 400 y menor que 600, nuestro DataFrame quedará con los siguientes datos:

Conclusión

En resumen, en este artículo nos hemos familiarizado con el método drop() de los DataFrame de pandas. También hemos visto como se etiquetan las filas y columnas de los DataFrame. Y finalmente hemos aprendido a eliminar filas mediante índices, un intervalo de índices y basándose en condiciones.

Si te ha gustado este artículo, no dudes en compartirlo.

Tanto si has programado en Java como si no, seguramente habrás escuchado hablar de la Máquina Virtual de Java (en inglés Java Virtual Machine, JVM) en algún momento.

JVM es el núcleo del ecosistema Java, permitiendo al software basado en esta tecnología seguir el enfoque "escríbelo (tu programa) una sola vez, ejecútalo en cualquier parte (write once, run anywhere)". Puedes escribir código Java en un tipo de máquina concreto, y ejecutarlo en cualquier otro tipo de máquina usando la JVM.

Inicialmente, la JVM fue diseñada para admitir Java solamente. Pero, con el paso de los años, muchos otros lenguajes como Scala, Kotlin y Groovy fueron adoptados por la plataforma Java. El conjunto de estos lenguajes se conoce como lenguajes JVM.

En este artículo aprenderemos las esencias de la JVM, cómo funciona y los componentes en que se divide.

¿Qué es una máquina virtual?

Antes de entrar de lleno en la JVM, revisemos el concepto de máquina virtual (VM).

Una máquina virtual es la representación virtual de un ordenador físico. Normalmente, se llama huésped (guest) a la máquina virtual, mientras que al ordenador físico en que se ejecuta, se le suele llamar anfitrión (host).

Una sola máquina física puede ejecutar varias máquinas virtuales, cada una con su propio sistema operativo y aplicaciones a nivel de usuario; están aisladas unas de otras.

¿Qué es la Máquina Virtual de Java?

En lenguajes de programación como C o C++, el código es compilado al código máquina específico de esa platoforma en concreto: son lenguajes compilados.

Por otro lado, en lenguajes como JavaScript o Python, el ordenador ejecuta las instrucciones directamente sin tener que compilarlas: son lenguajes interpretados.

Java usa una combinación de ambas técnicas. El código es compilado a bytecode (un formato binario independiente del hardware y del sistema operativo, que representa instrucciones de la JVM) generando un fichero con formato class. Este fichero class es interpretado por la JVM en la plataforma anfitriona. Un mismo fichero class puede ser ejecutado por la JVM en cualquier plataforma y sistema operativo.

De manera similar a las máquinas virtuales, la JVM crea un espacio aislado en la máquina anfitriona. Este espacio se usa para ejecutar programas Java sea cual sea la plataforma o el sistema operativo de dicha máquina.

Arquitectura de la Máquina Virtual de Java

La JVM consta de tres componentes:

1. Cargador de clases (Class Loader)
2. Área de datos/memoria en tiempo de ejecución (Runtime Memory/Data Area)
3. Motor de ejecución (Execution Engine)

Echemos un vistazo a cada uno de ellos.

Cargador de clases

Como resultado de la compilación del código fuente almacenado en un fichero.java, se obtiene bytecode almacenado en un fichero .class . Si en un programa se va a hacer uso de esta clase, será cargado en memoria principal por el cargador de clases.

La primera clase en ser cargada en memoria es, normalmente, aquella que contiene el método main() .

El proceso de carga de clases consta de tres fases: carga (loading), enlazado (linking), e inicialización (initialization).

Carga (loading)

La fase de carga consiste en encontrar la representación binaria (bytecode) de una clase o interfaz con un nombre concreto, y crear una clase o interfaz a partir de dicha representación (crear una clase o interfaz c es construir una representación interna, específica de esa implementación de la JVM, de c).

Hay tres cargadores de clases incorporados:

• Cargador de clases de arranque (Bootstrap Class Loader) - raíz de la jerarquía de cargadores de clases, superclase de Extension Class Loader. Carga los paquetes estándar de Java como java.lang, java.net, java.util, java.io, etc. localizados en el fichero rt.jar y otras bibliotecas fundamentales presentes en el directorio $JAVA_HOME/jre/lib .
• Cargador de clases de extensión (Extension Class Loader) - subclase de Bootstrap Class Loader y superclase de Application Class Loader. Carga las extensiones de las bibliotecas estándar de Java presentes en el directorio $JAVA_HOME/jre/lib/ext .
• Cargador de clases de aplicación (Application Class Loader) - es el cargador de clases en el nivel más bajo de la jerarquía, subclase de Extension Class Loader. Carga los ficheros indicados en el classpath (variable de entorno que almacena la ruta a las clases creadas por el usuario). Por defecto, la variable classpath es establecida al directorio actual de la aplicación; puede ser modificada desde la línea de comandos con la opción -classpath o -cp (al ejecutar java o javac , por ejemplo).

La JVM usa el método ClassLoader.loadClass() para cargar una clase en memoria, haciendo uso del nombre binario de la clase.

Si un cargador de clases es incapaz de encontrar una clase, delega el trabajo en el cargador de una subclase suya. Si el último cargador de la jerarquía tampoco es capaz de encontrar la clase en cuestión, se producirá NoClassDefFoundError o ClassNotFoundException.

Enlazado (linking)

Después de que una clase haya sido cargada en memoria, se somete al proceso de enlazado. Enlazar una clase o una interfaz supone resolver las referencias externas y dependencias, integrando la clase en el conjunto del programa que hace uso de ella.

El enlazado incluye los siguientes pasos:

Verificación: esta fase verifica la corrección estructural del archivo.class contrastándolo frente a un conjunto de restricciones o reglas. Si la verificación falla, se produce VerifyException.

Por ejemplo, si el código se ha construído con Java 11, pero se va a ejecutar en un sistema con Java 8, la fase de verificación fallará.

Preparación: en esta fase, la JVM asigna memoria para los campos estáticos de una clase o interfaz, inicializándolos con valores por defecto.

Supón, como ejemplo, que has declarado en una clase la siguiente variable:

private static final boolean activado = true;

Durante la fase de preparación, la JVM asigna memoria para la variable activado y le asigna el valor por defecto para un booleano, que es false.

Resolución: es el proceso de resolver dinámicamente las referencias simbólicas presentes en el almacén de constantes de tiempo de ejecución (runtime constant pool, una estructura de datos del fichero .class).

Las referencias (simbólicas) que dentro de una clase se hacen a otras clases o a constantes presentes en otras clases, son resueltas en esta etapa asignándoles los valores reales.

Inicialización (initialization)

La inicialización consiste en ejecutar <clinit>, el método de inicialización de una clase o interfaz. En esta etapa se ejecutan los bloques de inicialización estáticos y se asignan los valores a las variables estáticas. Es el paso final del proceso de carga de clases.

Por ejemplo, cuando anteriormente hemos declarado el siguiente código:

private static final boolean activado = true;

La variable activado fue establecida con su valor por defecto, false , durante la fase de preparación. Ahora, en la fase de inicialización, se le asigna el valor real que queríamos darle, true.

Nota: la JVM es multihilo. Cabe la posibilidad de que múltiples hilos intenten inicializar la misma clase al mismo tiempo, provocando problemas de concurrencia. Hay que gestionar cada hilo de forma segura para garantizar que el programa funcione adecuadamente en un entorno multihilo.

Área de datos en tiempo de ejecución

El área de datos en tiempo de ejecución está formado por cinco componentes:

Veamos cada componente por separado.

Área de métodos

Todos los datos a nivel de clase, como el runtime constant pool, datos de los campos y los métodos, así como el código de los métodos y constructores, son almacenados en esta área.

Si la memoria disponible en el área de métodos no puede satisfacer una petición de asignación de memoria por parte de un proceso, la JVM emite un OutOfMemoryError.

Supongamos que has definido la siguiente clase:

public class Empleado {
  
  private String nombre;
  private int edad;
  
  public Empleado(String nombre, int edad) {
  
    this.nombre = nombre;
    this.edad = edad;
  }
}

Los datos de los campos nombre y edad y el código del constructor son guardados en el área de métodos.

El área de métodos se crea al arrancar la JVM y es compartida por todos los hilos de ejecución.

Area del montículo (heap)

Todos los objetos y sus correspondientes variables de instancia son almacenados en esta zona. El montículo es el área de datos de tiempo de ejecución en la que se aloja la memoria asignada a los arrelgos e instancias de clases.

Supongamos que se ha declarado la siguiente instancia:

Employee empleado = new Empleado();

En este ejemplo, se crea una instancia de la clase Empleado , que será cargada en memoria en el área del montículo.

Al igual que el área de métodos, el área del montículo es creada al arrancar la JVM, y se comparte por todos los hilos.

Nota: como las áreas del montículo y de métodos comparten la misma memoria para los diferentes hilos, habrá que gestionar cada hilo de forma segura para asegurar la integridad de los datos, como ya comentábamos en el apartado de inicialización de clases.

Area de pilas (stack)

A cada hilo creado en la JVM le corresponde en exclusiva una pila, creada al mismo tiempo que el propio hilo. Las variables locales, resultados parciales y llamadas a métodos se almacenan en esta zona de memoria conocida como pila.

Si el procesamiento que se está llevando a cabo en un hilo requiere un tamaño de pila mayor del permitido, la JVM emite un StackOverflowError.

Para cualquier llamada a método, se genera en la memoria de pila una entrada llamada marco de pila (stack frame). Cuando se completa la llamada al método, el marco de pila es destruido.

El marco de pila se divide en tres partes:

• Variables locales – cada marco contiene un arreglo donde se almacenan las variables locales y sus valores. La longitud de este arreglo se establece en tiempo de compilación.
• Pila de operandos (operand stack) – esta estructura de tipo pila es utilizada para llevar a cabo las operaciones intermedias durante la llamada al método en cuestión. La profundidad máxima de esta pila se determina también en tiempo de compilación.
• Marco de datos (frame data) – aquí se guardan todos los símbolos del método invocado, así como la información del bloque catch en caso de que se produzca alguna excepción.

Supongamos el siguiente código:

double calcularPuntuacionNormalizada(List<Respuesta> respuestas) {
  
  double puntuacion = getPuntuacion(respuestas);
  normalizarPuntuacion(puntuacion);
}

normalizarPuntuacion(double puntuacion) {
  
  return (puntuacion – minPuntuacion) / (maxPuntuacion – minPuntuacion);
}

En este ejemplo, el arreglo de variables locales contendrá las variables respuestas y puntuacion. La pila de operandos contiene las variables y operadores necesarios para realizar las operaciones de sustracción y división.

Nota: como cada pila es exclusiva de un hilo, esta área de memoria es inherentemente segura en ambiente multihilo.

Registros de contador de programa (PC, program counter)

La JVM admite múltiples hilos simultáneamente. Cada hilo tiene su propio registro contador de programa (PC) para guardar la dirección de la instrucción de la JVM ejecutándose en ese momento. Una vez ejecutada dicha instrucción, el registro PC es actualizado con la dirección de la próxima instrucción.

Pilas para métodos nativos

La JVM puede hacer uso de pilas que soporten métodos nativos, métodos escritos en lenguajes diferentes a Java, como C o C++. Cada hilo posee su propia pila de métodos nativos.

Motor de ejecución

Una vez que el bytecode se ha cargado en memoria y la información necesaria está disponible en el área de datos de tiempo de ejecución, el siguiente paso es ejecutar el programa. El motor de ejecución gestiona este proceso ejecutando el código de cada clase.

Sin embargo, antes de ejecutar el programa, hay que traducir el bytecode a instrucciones del lenguaje máquina, usando un intérprete o un compilador JIT.

Intérprete

El intérprete lee y ejecuta las instrucciones del bytecode línea a línea. Debido a esta ejecución línea por línea, el intérprete es comparativamente más lento.

Otra desventaja es la reinterpretación de un método cada vez que es llamado.

Compilador JIT

El compilador JIT salva las desventajas del intérprete. En primera instancia, el motor de ejecución usa el intérprete para ejecutar el bytecode, entrando en acción el compilador JIT cuando se encuentra código repetido.

El compilador JIT compila el bytecode traduciéndolo a código máquina nativo, que es usado directamente en las reiteradas llamadas a métodos, mejorando así el rendimiento del sistema.

El compilador JIT se divide en los siguientes componentes:

1. Generador de código intermedio
2. Optimizador de código - optimiza el código intermedio para un mejor desempeño
3. Generador de código objetivo - traduce el código intermedio en código máquina nativo
4. Perfilador (profiler) - encuentra los HotSpots (código que es ejecutado repetidamente)

Veamos el siguiente código para ilustrar la diferencia entre el intérprete y el compilador JIT:

int sum = 10;
for(int i = 0 ; i <= 10; i++) {
   sum += i;
}
System.out.println(sum);

Un intérprete busca en memoria el valor de sum en cada iteración del bucle, le suma el valor dei, y lo vuelve a almacenar en la memoria. Es una operación costosa, ya que se está accediendo a memoria en cada iteración.

Sin embargo, el compilador JIT reconoce que este código tiene un HotSpot, y realizará optimizaciones sobre él. Creará una copia local de sum en el registro PC del hilo, sumándole el valor de i en cada vuelta del bucle y, una vez concluído, llevará el nuevo valor de sum a la memoria.

Nota: un compilador JIT tarda más en compilar el código que un intérprete en interpretarlo línea por línea. Si se va a ejecutar el programa solo una vez, es mejor usar el intérprete.

Recolector de basura (GC, garbage collector)

El recolector de basura detecta y elimina objetos no referenciados en el área del heap. Es el proceso de recuperar automáticamente, en tiempo de ejecución, la memoria ocupada por objetos que ya no van a ser utilizados, mediante la destrucción de tales objetos.

La recolección de basura hace que Java sea eficiente desde el punto de vista de la gestión de memoria, ya que libera memoria del área heap eliminando objetos no referenciados, creándose así espacio para nuevos objetos. Este proceso implica dos fases:

1. Marcado - identificación de objetos no referenciados
2. Barrido - destrucción de los objetos identificados en el paso anterior

La JVM realiza automáticamente la recolección de basura a intervalos regulares, no siendo necesaria su gestión separadamente. Puede ser disparada invocando System.gc(), aunque la ejecución no está garantizada.

La JVM tiene tres tipos de recolectores de basura:

1. En serie - es la implementación más simple, diseñada para pequeñas aplicaciones ejecutándose en entornos monohilo. Usando un solo hilo, produce un evento de tipo "parar el mundo" en el que todos los hilos de aplicación son detenidos hasta que la operación se complete. El argumento de la JVM para usar recolección de basura en serie es -XX:+UseSerialGC
2. En paralelo - es la implementación por defecto en la JVM, conocido como recolector de rendimiento (throughput collector). Uitiliza múltiples hilos, pero aún necesita parar los hilos de aplicación. El argumento de la JVM es -XX:+UseParallelGC.
3. Garbage First (G1) GC - G1GC fue diseñado para aplicaciones multihilo con gran cantidad disponible de heap (más de 4GB). Particiona el heap en un conjunto de regiones de igual tamaño, utilizando múltiples hilos para explorarlas. G1GC identifica las regiones con el máximo de basura y realiza la limpieza prioritaria de esas regiones. El argumento de la JVM para G1GC es -XX:+UseG1GC

Nota: hay otro tipo de colector de basura llamado Barrido de Marcas Concurrente (Concurrent Mark Sweep (CMS) GC). Sin embargo, fue declarado obsoleto en Java 9 y completamente eliminado en Java 14 en favor de G1GC.

Interfaz nativa de Java (JNI)

En ocasiones, es necesario utilizar código nativo en lugar de Java (por ejemplo, C/C++). Esas ocasiones pueden ser cuando necesitamos interactuar con el hardware, o salvar las restricciones de Java en cuanto a gestión de memoria y rendimiento. Java admite la ejecución de código nativo a través de la Interfaz Nativa de Java (JNI).

JNI hace de puente permitiendo el uso de paquetes de apoyo para otros lenguajes, como C, C++, etc. Esto resulta de mucha ayuda en casos en que se necesita escribir código que no esté enteramente admitido por Java, como ciertas características específicas de la plataforma subyacente que solo pueden ser escritas en C.

La palabra reservada native indica que la implementación del método será proporcionada por una biblioteca nativa. Es necesario invocar System.loadLibrary() para cargar en memoria dicha biblioteca nativa compartida y tener su funcionalidad disponible en Java.

Bibliotecas de métodos nativos

Las bibliotecas de métodos nativos son bibliotecas escritas en otros lenguajes, como C, C++ y ensamblador, normalmente en archivos de extensión .dll o .so. Pueden ser cargadas a través de JNI.

Errores habituales de la JVM

• ClassNotFoundException - ocurre cuando el cargador de clases intenta cargar clases mediante Class.forName(), ClassLoader.loadClass() o ClassLoader.findSystemClass() pero no se encuentra la definición de la clase con el nombre especificado.
• NoClassDefFoundError - se produce cuando la compilación de la clase ha tenido éxito, pero el cargador de clases no es capaz de encontrar el fichero tipo class en tiempo de ejecución.
• OutOfMemoryError - la JVM no puede asignar memoria para un objeto, ya que no hay suficiente y el recolector de basura no es capaz de proporcionar más memoria.
• StackOverflowError - la JVM se queda sin espacio al crear nuevos marcos de pila.

Conclusión

En este artículo hemos discutido la arquitectura de la Máquina Virtual de Java y sus diversos componentes. Lo habitual es no preocuparse demasiado de su mecánica interna ni de su funcionamiento mientras nuestro código se ejecuta con normalidad.

Solo cuando algo va mal, y necesitamos ajustar la JVM o corregir un fallo de memoria, intentamos comprender su funcionamiento interno.

Es una cuestión muy popular en entrevistas de trabajo, tanto a nivel junior como senior para perfiles backend. Tener amplios conocimientos de la JVM te ayudará a producir mejor código y evitar trampas que conduzcan a errores de pila o de memoria.

Gracias por acompañarme hasta tan lejos. Espero que te haya gustado el artículo. Puedes encontrarme en LinkedIn, donde normalmente hablo sobre tecnología y sobre la vida. Echa también un vistazo a mis otros artículos y a mi canal de YouTube. Que disfrutes de la lectura. ?

Tuplas (Tuple) y listas (List) son dos de los cuatro tipos de datos incorporados que puedes usar en Python para almacenar colecciones de datos. Los otros dos serían conjuntos (Set) y diccionarios (Dictionary).

Ambos son muy útiles y pueden parecer similares tras un primer vistazo. Pero tienen diferencias significativas y cada uno de ellos será más útil según el caso.

En este artículo vamos a dar una visión general de cómo funcionan las tuplas y las listas. Hablaremos acerca de sus características y sus casos de uso, y mostraré sus parecidos y diferencias.

Puedes probar los códigos de ejemplo mostrados en el artículo usando la shell interactiva de Python, la cual tienes disponible en tu máquina una vez instalado Python.

¡Comencemos!

¿Qué son tuplas y listas en Python?

Tuplas y Listas son estructuras de datos incorporadas en Python.

Son contenedores para el almacenamiento de una colección ordenada de uno o más elementos, accesibles mediante indexación.

Una tupla pertence a la clase 'tuple',<class 'tuple'>, mientras que una lista pertenece a la clase 'list', <class 'list'> .

Digamos que has creado una tupla llamada mi_tupla. Puedes comprobar su tipo de la siguiente manera:

>>>type(mi_tupla)

#output
<class 'tuple'>

Esto es particularmente útil para depuración.

Veamos ahora algunas otras similitudes entre tuplas y listas.

Similitudes entre tuplas y listas en Python

Como ya he mencionado anteriormente, tuplas y listas son muy similares, y comparten ciertas características que veremos a continuación.

Tuplas y listas pueden almacenar múltiples elementos bajo una única variable

Tanto las tuplas como las listas o bien pueden estar vacías o bien pueden contener uno o incluso múltiples elementos bajo una única variable.

La única diferencia radica en la sintaxis: las tuplas se crean rodeando los elementos que va a contener mediante paréntesis, (), mientras que las listas se crean usando corchetes,[].

Para crear una tupla vacía, puedes usar solo los paréntesis,(), o bien el método constructor tuple().

>>>type(())
<class 'tuple'>

>>>mi_tupla = ()

>>>type(mi_tupla)
<class 'tuple'>

#or..


>>>mi_tupla = tuple()

>>>type(mi_tupla)
<class 'tuple'>

Para crear una lista vacía puedes usar simplemente los corchetes o llamar al método constructor list().

>>>type([])
<class 'list'>


>>>mi_lista = []

#or..

>>>mi_lista = list()

Cuando estemos creando una tupla con solo un elemento, no hay que olvidarse de añadir una coma al final.

>>>edad = (28,)

Si estás usando el método tuple(), serán necesarios dobles paréntesis.

>>>edad = tuple((28,))

>>>type(edad)
<class 'tuple'>

Si no añades la coma al final, Python no lo reconocerá como una tupla.

>>>edad = (28)

>>>type(edad)
<class 'int'>

>>>edad = tuple((28))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

Se pueden crear tuplas de uno o más elementos sin utilizar los paréntesis (ojo, con el método, tuple() sí son necesarios):

>>> mi_tupla = 'python',  # <-- obsérvese la coma final.
>>> type(mi_tupla)
<class 'tuple'>

>>> otra_tupla = 1, 2, 3  # <-- aquí no es necesaria la coma.
>>> type(otra_tupla)
<class 'tuple'>

Al crear una lista con solo un elemento, no es necesario añadir la coma final.

>>> edad = [28]

>>> type(edad)
<class 'list'>

Los elementos almacenados son generalmente de naturaleza similar y están relacionados unos con otros de alguna manera.

Puedes crear una tupla o una lista que contenga sencillamente una secuencia de cadenas, de enteros o de valores Booleanos, estando los elementos de la secuencia separados por comas.

Se puede crear una tupla o una lista que contenga una mezcla de diferentes tipos de datos.

>>>mi_informacion = ["Dionysia",27,True,"Lemonaki",7,"Python",False]

#or..

>>>mi_informacion = list(("Dionysia",27,True,"Lemonaki",7,"Python",False))

print(mi_informacion)
['Dionysia', 27, True, 'Lemonaki', 7, 'Python', False]

Listas y tuplas pueden contener elementos duplicados, apareciendo múltiples veces.

>>>informacion = ("Jimmy",50,True,"Kate",50)

>>>print(informacion)
('Jimmy', 50, True, 'Kate', 50)

or..

>>>mi_informacion = ["Dionysia",27,True,"Lemonaki",7,"Python",False,27,"Python",27]

Si te olvidas de las comas, obtendrás un error:

>>>informacion = ("Jimmy" 50,True,"Kate",50)
File "<stdin>", line 1
    >>>informacion = ("Jimmy" 50,True,"Kate",50)
    ^
SyntaxError: invalid syntax

>>>my_informacion = ["Dionysia" 28,True,"Lemonaki",7,"Python",False]
 File "<stdin>", line 1
    my_informacion = ["Dionysia" 28,True,"Lemonaki",7,"Python",False]
                                 ^
SyntaxError: invalid syntax

Para comprobar la longitud y determinar cuantos elementos hay en la tupla o en la lista, habrá que hacer uso del método len() .

>>>mi_informacion = ["Dionysia",27,True,"Lemonaki",7,"Python",False,27,"Python",27]

>>>len(mi_informacion)
7

Tuplas y Listas en Python soportan desempaquetado

Esencialmente, cuando se crea una tupla o una lista, varios valores son 'empaquetados' en una única variable, como ya he mencionado anteriormente.

>>>front_end = ("html","css","javascript")

Esos valores puede ser 'desempaquetados' y asignados a variables individuales.

>>>front_end = ("html","css","javascript")

>>>contenido,estilismo,interactividad = front_end

>>>contenido
'html'

>>>estilismo
'css'

>>>interactividad
'javascript'

Hay que asegurarse de que el número de variables que creas es exactamente el mismo que la cantidad de valores de la tupla/lista, de otro modo Python lanzará un error:

>>>front_end = ("html","css","javascript")

>>>contenido,estilismo = front_end
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)


#or..


>>>front_end = ("html","css","javascript")

>>>contenido,estilismo,interactividad,datos =  front_end
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 4, got 3)

Se puede acceder a los elementos por su índice tanto en tuplas como en listas

Como he mencionado anteriormente, tuplas y listas son una colección ordenada de elementos.

El orden es establecido e inmutable, siendo preservado durante toda la vida del programa.

El orden en que se especifican los elementos será siempre el mismo desde el momento en que son creados.

Cada valor en una tupla o una lista tiene un identificador único, su índice.

Cada elemento de una tupla/lista puede ser accedido haciendo referencia a su índice.

La indexación en Python (y en muchos otros lenguajes de programación y en Informática en general) comienza en 0.

De modo que el primer elemento tiene índice 0, el segundo tiene índice 1, y así sucesivamente.

Para acceder a un elemento, escribe el nombre de la tupla/lista y a continuación el índice del elemento entre corchetes.

>>>nombres = ("Jimmy","Timmy","John","Kate")

>>>nombres[2]
'John'

O bien:

>>>lenguages_de_programacion = ["Python","JavaScript","Java","C"]

>>>lenguages_de_programacion[0]
'Python'

>>>lenguages_de_programacion[1]
'JavaScript'

Bien, ya hemos visto en qué son similares, veamos ahora en qué difieren tuplas y listas.

Diferencias entre tuplas y listas en Python

Las Tuplas son inmutables, mientras que las Listas son mutables

Las tuplas en Python son inmutables, lo que significa que una vez creada una tupla, sus elementos no pueden cambiar.

Las tuplas no pueden ser alteradas.

Si intentas cambiar el valor de uno de sus elementos, obtendrás un error:

>>>nombres = ("Jimmy","Timmy","John","Kate")

>>>nombres[2] = "Kelly"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

No puedes añadir, reemplazar, reasignar o eliminar ningún elemento ya que las tuplas no pueden cambiar su configuración.

Esto implica que las tuplas tienen longitud fija. Su longitud nunca cambia a lo largo del ciclo de vida del programa.

Cuando usar tuplas

Las tuplas son una excelente opción si lo que quieres es que los datos de tu colección sean de solo lectura, que nunca cambien y se mantengan constantes. Tienen la capacidad de garantizar que los datos que contienen nunnca serán alterados.

Las tuplas pueden utilizarse como claves en un diccionario siempre que contengan tipos inmutables (cadenas, números u otras tuplas). Una lista, al ser mutable, no puede utilizarse para este fin.

Cuando usar listas

Por otro lado, las listas pueden ser fácilmente modificadas, ya que son mutables.

Se puede añadir elementos, eliminarlos, cambiarlos de posición o intercambiar unos por otros.

Las listas son útiles si lo que quieres es que tus datos sean flexibles, que puedan ser modificados cuando sea necesario.

Las listas soportan una variedad de métodos incorporados de Python que llevan a cabo ciertas operaciones sobre ellas, operaciones no soportadas por la tuplas.

Todo ello implica que la longitud, el tamaño de una lista pueda variar durante el ciclo de vida del programa.

Veamos ahora algunas operaciones sencillas que modifican una lista.

Como actualizar listas en Python

Ya que las listas son mutables, necesitarás conocer algunas de las formas básicas de actualizar los datos contenidos en una lista.

Como actualizar un elemento en una lista

Para actualizar un elemento en particular, hacemos referencia a su índice entre corchetes y asignamos el nuevo valor.

# sintaxis general
>>>nombre_lista[indice] = nuevo_valor

>>>lenguajes_de_programacion = ["Python","JavaScript","Java","C"]
>>>print(lenguajes_de_programacion)
['Python', 'JavaScript', 'Java', 'C']

>>>lenguajes_de_programacion[2] = "C++"
>>>print(lenguajes_de_programacion)
['Python', 'JavaScript', 'C++', 'C']

Como añadir elementos a una lista

Hay varios métodos incorporados en Python para añadir elementos a una lista.

El método .append() añade un elemento nuevo al final de la lista.

# sintaxis general
>>>nombre_lista.append(elemento)

>>>lenguajes_de_programacion = ["Python","JavaScript","Java","C"]
>>>print(lenguajes_de_programacion)
['Python', 'JavaScript', 'Java', 'C']

>>>lenguajes_de_programacion.append("C++")

>>>print(lenguajes_de_programacion)
['Python', 'JavaScript', 'Java', 'C', 'C++']

Para añadir el elemento en una posición determinada, usa el método  .insert().

Este método inserta el elemento en la posición dada. El resto de elementos de la lista que van después del elemento que se quiere insertar, son desplazados una posición hacia la derecha.

# sintaxis general
>>>nombre_lista.insert(index,item)

>>>nombres = ["Cody","Dillan","James","Nick"]
>>>print(names)
['Cody', 'Dillan', 'James', 'Nick']


>>>nombres.insert(0,"Stephanie")

>>>print(nombres)
['Stephanie', 'Cody', 'Dillan', 'James', 'Nick']

Si lo que se necesita es añadir más de un elemento, haremos uso del método .extend().

Este método añade un iterable al final de la lista. Por ejemplo, se puede añadir una lista al final de una lista ya existente.

# sintaxis general
>>>nombre_lista.extend(iterable)

>>>lenguajes_de_programacion = ["Python","JavaScript"]
>>>mas_lenguajes_de_programacion = ["Java","C"]

# añadir mas_lenguajes_de_programacion a lenguajes_de_programacion
>>>lenguajes_de_programacion.extend(mas_lenguajes_de_programacion) 

>>>print(programming_languages)
['Python', 'JavaScript', 'Java', 'C']

Como eliminar elementos de una lista

Hay dos métodos incorporados para eliminar elementos de una lista.

Uno de ellos es el método .remove(), que elimina la primera instancia del elemento que se le proporciona como argumento.

# sintaxis general
>>>nombre_lista.remove(elemento)

>>>lenguaje_de_programacion = ["Python", "JavaScript", "Java", "C"]
>>>print(lenguaje_de_programacion)
['Python', 'JavaScript', 'Java', 'C']

>>>lenguaje_de_programacion.remove("Java")
>>>print(lenguaje_de_programacion)
['Python', 'JavaScript', 'C']

# elimina solo la primera ocurrencia
>>>lenguaje_de_programacion = ["Python", "JavaScript", "Java", "C","Python"]
>>>lenguaje_de_programacion.remove("Python")
>>>print(lenguaje_de_programacion)
['JavaScript', 'Java', 'C', 'Python']

El otro es el método .pop().

Si lo invocamos sin argumentos, eliminará el último elemento de la lista.

Se le puede pasar como argumento el índice del elemento específico que se quiera eliminar.

Este método devuelve el elemento eliminado, lo que puede ser útil en caso de que se quiera usar posteriormente, almacenándolo en una variable.

>>>lenguaje_de_programacion = ["Python", "JavaScript", "Java", "C"]

>>>lenguaje_de_programacion.pop()
'C'


>>>print(lenguaje_de_programacion)
['Python', 'JavaScript', 'Java']

# guarda el valor retornado en una variable
>>>lenguaje_de_programacion = ["Python", "JavaScript", "Java", "C"]

>>>language_favorito = programming_languages.pop(0)
>>>print(language_favorito)
Python

Conclusión

Aquí acabamos nuestra introducción sobre fundamentos de tuplas y listas y como son usadas normalmente.

Para recapitular, las similitudes entre tuplas y listas son:

• Son considerados objetos (instancias de una clase).
• Son contenedores de colecciones de datos, pudiendo ser estos de cualquier tipo.
• Son colecciones ordenadas, mantienendo siempre ese orden. Una vez que se ha definido el orden de los elementos, ya no cambiará. Esto puede parecer contradictorio en el caso de las listas. Una tupla mantiene su orden desde el mismo momento en que se crea, no pudiendo alterarlo el programador. En una lista podemos cambiar el orden, pero una vez establecido ese nuevo orden, se garantiza que se mantendrá hasta que decidamos volver a cambiarlo. Esta es una característica que no se garantiza, por ejemplo, en el caso de los diccionarios.
• Tanto en tuplas como en listas puedes acceder a un elemento en particular mediante su índice.

Las diferencias entre tuplas y listas son:

• Una tupla es inmutable. Úsalas cuando sepas con seguridad que tus datos no van a variar durante el ciclo de vida del programa o cuando quieras garantizar que se mantendrán constantes.
• Una lista es mutable. Se puede añadir o eliminar elementos. Las listas crecen y decrecen durante la vida del programa. Úsalas cuando tus datos, por su propia naturaleza, sean susceptibles de variar.

Si quieres aprender Python en profundidad, freeCodeCamp ofrece una certificación de Python gratis.

El curso comienza con las bases más elementales y avanza hasta temas más complejos como estructuras de datos y bases de datos relacionales. Al final, hay cinco proyectos que solidificarán tus conocimientos.

¡Gracias por leer y feliz aprendizaje!

Dejo el enlace al tutorial oficial de Python en español.