Microcurso: Encontrar Duplicados en Python

1. Introducción a los Duplicados

En este curso aprenderás a identificar y manejar elementos duplicados en Python, una habilidad esencial para el procesamiento y limpieza de datos.

¿Por qué es importante?

Los datos duplicados pueden afectar los resultados de análisis
Pueden consumir recursos innecesarios
Pueden indicar problemas en la recolección de datos

Ejemplo práctico:

Imagina una lista de correos electrónicos de usuarios donde algunos están repetidos. Necesitamos identificar estos duplicados para enviar un solo correo a cada usuario.

2. Conceptos Básicos

Para identificar duplicados, necesitamos entender algunas estructuras de datos en Python:

Listas en Python

Las listas son colecciones ordenadas y mutables que permiten elementos duplicados.

                    # Crear una lista

                    frutas = ["manzana", "banana", "naranja", "manzana", "uva"]

                    # Acceder a elementos

                    print(frutas[0]) # Output: manzana

                    # Verificar duplicados

                    print(frutas.count("manzana")) # Output: 2

Conjuntos en Python

Los conjuntos son colecciones no ordenadas y sin elementos duplicados.

                    # Crear un conjunto

                    frutas = {"manzana", "banana", "naranja", "manzana", "uva"}

                    # Los duplicados se eliminan automáticamente

                    print(frutas) # Output: {'manzana', 'banana', 'naranja', 'uva'}

                    # Verificar si un elemento existe

                    print("manzana" in frutas) # Output: True

Diccionarios en Python

Los diccionarios almacenan pares clave-valor y son útiles para contar ocurrencias.

                    # Crear un diccionario para contar frutas

                    conteo_frutas = {}

                    frutas = ["manzana", "banana", "naranja", "manzana", "uva"]

                    for fruta in frutas:

                        if fruta in conteo_frutas:

                            conteo_frutas[fruta] += 1

                        else:

                            conteo_frutas[fruta] = 1

                    print(conteo_frutas) # Output: {'manzana': 2, 'banana': 1, 'naranja': 1, 'uva': 1}

Ejercicio Práctico

Crea una lista con 10 números (algunos duplicados) y escribe código para contar cuántas veces aparece cada número.

3. Métodos para Encontrar Duplicados

Existen varias formas de identificar elementos duplicados en Python. Veamos los más comunes:

Método 1: Usando conjuntos (set)

                def encontrar_duplicados(lista):

                    unicos = set()

                    duplicados = set()

                    for item in lista:

                        if item in unicos:

                            duplicados.add(item)

                        else:

                            unicos.add(item)

                    return list(duplicados)

                # Ejemplo de uso

                lista = [1, 2, 3, 2, 4, 5, 1, 6, 7, 1]

                print(encontrar_duplicados(lista)) # Output: [1, 2]

Método 2: Usando collections.Counter

                from collections import Counter

                def encontrar_duplicados(lista):

                    conteo = Counter(lista)

                    return [item for item, count in conteo.items() if count > 1]

                # Ejemplo de uso

                lista = ['a', 'b', 'c', 'a', 'd', 'e', 'b']

                print(encontrar_duplicados(lista)) # Output: ['a', 'b']

Método 3: Usando list.count()

                def encontrar_duplicados(lista):

                    duplicados = []

                    for item in lista:

                        if lista.count(item) > 1 and item not in duplicados:

                            duplicados.append(item)

                    return duplicados

                # Ejemplo de uso

                lista = [10, 20, 30, 20, 40, 10, 50]

                print(encontrar_duplicados(lista)) # Output: [10, 20]

Cuestionario

1. ¿Cuál método es más eficiente para listas grandes?

list.count()

collections.Counter

Usando conjuntos

4. Aplicación Completa para Encontrar Duplicados

Ahora implementaremos una aplicación completa que permite al usuario ingresar datos y encontrar duplicados.

Encuentra Duplicados en tus Datos

Ingresa tus elementos separados por comas (ej: manzana,banana,naranja,manzana):

                // JavaScript para la aplicación

                function findDuplicates() {

                    const input = document.getElementById('input-data').value;

                    const items = input.split(',').map(item => item.trim());

                    const unique = new Set();

                    const duplicates = new Set();

                    items.forEach(item => {

                        if (unique.has(item)) {

                            duplicates.add(item);

                        } else {

                            unique.add(item);

                        }

                    });

                    const resultsDiv = document.getElementById('results');

                    if (duplicates.size === 0) {

                        resultsDiv.innerHTML = '<p>No se encontraron
                elementos duplicados.</p>';

                    } else {

                        resultsDiv.innerHTML = '<h4>Elementos duplicados
                encontrados:</h4>';

                        duplicates.forEach(item => {

                            const count = items.filter(i =>
                i === item).length;

                            resultsDiv.innerHTML += `

                                <div
                class="duplicate-item">

                                    <strong>${item}</strong>
                aparece ${count} veces

                                </div>`;

                        });

                    }

                }

Ejercicio de Mejora

Modifica la aplicación para que también muestre los índices (posiciones) donde aparece cada elemento duplicado.

5. Casos de Uso Avanzados

Vamos a explorar situaciones más complejas donde necesitamos encontrar duplicados.

1. Duplicados en Listas de Diccionarios

                usuarios = [

                    {"id": 1, "nombre": "Juan", "email": "juan@example.com"},

                    {"id": 2, "nombre": "María", "email": "maria@example.com"},

                    {"id": 3, "nombre": "Juan", "email": "juan.d@example.com"},

                    {"id": 4, "nombre": "Pedro", "email": "juan@example.com"} # Email duplicado

                ]

                # Encontrar usuarios con email duplicado

                emails = {}

                duplicados = []

                for usuario in usuarios:

                    email = usuario["email"]

                    if email in emails:

                        duplicados.append(emails[email])

                        duplicados.append(usuario)

                    else:

                        emails[email] = usuario

                print("Usuarios con email duplicado:", duplicados)

2. Encontrar Duplicados en Archivos

                import hashlib

                def hash_file(filepath):

                    """Calcula el hash MD5 de un archivo"""

                    hash_md5 = hashlib.md5()

                    with open(filepath, "rb") as f:

                        for chunk in iter(lambda: f.read(4096), b""):

                            hash_md5.update(chunk)

                    return hash_md5.hexdigest()

                def encontrar_archivos_duplicados(directorio):

                    import os

                    hashes = {}

                    duplicados = []

                    for root, dirs, files in os.walk(directorio):

                        for filename in files:

                            filepath = os.path.join(root,
                filename)

                            file_hash =
                hash_file(filepath)

                            if file_hash in hashes:

                                duplicados.append((filepath,
                hashes[file_hash]))

                            else:

                                hashes[file_hash]
                = filepath

                    return duplicados

                # Ejemplo de uso

                # duplicados = encontrar_archivos_duplicados('/ruta/al/directorio')

                # for dup in duplicados:

                #     print(f"Archivo duplicado: {dup[0]} es igual a {dup[1]}")

3. Duplicados en Bases de Datos

                import sqlite3

                def encontrar_duplicados_en_db(db_path):

                    conn = sqlite3.connect(db_path)

                    cursor = conn.cursor()

                    # Ejemplo: encontrar usuarios con el mismo email

                    cursor.execute("""

                        SELECT email, COUNT(*) as count

                        FROM usuarios

                        GROUP BY email

                        HAVING count > 1

                    """)

                    duplicados = cursor.fetchall()

                    conn.close()

                    return duplicados

                # Ejemplo de uso

                # duplicados = encontrar_duplicados_en_db('mi_base_de_datos.db')

                # for email, count in duplicados:

                #     print(f"Email {email} aparece {count} veces")

Cuestionario Final

1. ¿Cuál es la forma más eficiente de encontrar duplicados en una lista muy grande?

Usando list.count() en un bucle

Usando un diccionario para contar ocurrencias

Comparando cada elemento con todos los demás

2. Para encontrar archivos duplicados, ¿qué propiedad debemos comparar?

El nombre del archivo

El tamaño del archivo

El hash del contenido del archivo

Microcurso: Encontrar Elementos Duplicados en Python