len()

La longitud de una lista puede variar durante la ejecución. Se pueden agregar nuevos elementos a la lista, mientras que otros pueden eliminarse de ella. Esto significa que la lista es una entidad muy dinámica.

Se utiliza esta función para obtener la longitud o el número de elementos de cualquier objeto que sea una colección o secuencia, como una lista, cadena, tupla, conjunto o diccionario. Esta función es muy útil para determinar el tamaño de estructuras de datos en Python, lo que permite trabajar con ellas de manera más eficiente y programática.

                  
                    print(len([1, 2, 3, 4, 5]))  # Output: 5
                    print(len("Python"))  # Output: 6 
                    print(len(("apple", "banana", "cherry")))  # Output: 3
                    print(len({1, 2, 3}))  # Output: 3
                    print(len({"name": "John", "age": 30}))  # Output: 2
                  
              

del

La sentencia del es una instrucción en Python que se utiliza para eliminar elementos o variables. A diferencia de los métodos específicos para listas como remove() o pop(), que están diseñados para manipular elementos dentro de listas, la sentencia del es más versátil y se puede usar en una variedad de contextos para eliminar:

• Variables
• Elementos de una lista
• Partes de un diccionario
• Incluso secciones de una lista mediante el uso de la notación de rebanado (slicing)

La principal ventaja de del es su flexibilidad, ya que permite eliminar elementos en diferentes estructuras de datos, no sólo en listas. Además, la sentencia del ofrece más control y opciones de eliminación que los métodos específicos para listas.

                  
                    mi_lista = [0, 1, 2, 3, 4, 5]
                    del mi_lista[2]  # Elimina el elemento en el índice 2 (en este caso, el número 2)
                    print(mi_lista)  # Imprime: [0, 1, 3, 4, 5]
                  
                

append()

El método append() en Python permite agregar un nuevo elemento al final de una lista. Cuando se llama a append() sobre una lista, este método añade el elemento especificado como argumento a la parte final de la lista, incrementando su tamaño en uno.

Algunas características clave del método append():

• Agrega un único elemento al final de la lista.
• Aumenta el tamaño de la lista en 1.
• El elemento agregado pasa a ser el último elemento de la lista.
• Es uno de los métodos de lista más comúnmente utilizados para ir construyendo una lista de forma dinámica.

                  
                    my_list = [0, 1, 2, 3]
                    my_list.append(4)
                    print(my_list) # Output: [0, 1, 2, 3, 4]
                  
                

insert()

El método insert() es más versátil que append(), ya que permite agregar un nuevo elemento en cualquier posición de la lista, no solo al final. Esto brinda mayor control y flexibilidad al trabajar con listas en Python.

                  
                    # Crear una lista
                    fruits = ['apple', 'banana', 'cherry']
                    # Agregar un elemento en la posición 1 (entre 'apple' y 'banana')
                    fruits.insert(1, 'orange')
                    # La lista resultante es:
                    # ['apple', 'orange', 'banana', 'cherry']
                  
                

La redacción revisada transmite de manera más efectiva las capacidades y ventajas del método insert() en comparación con append().

Extend()

Este método permite agregar todos los elementos de un iterable (como otra lista, tupla, cadena, etc.) al final de la lista actual. A diferencia de append(), que agrega un solo elemento a la lista, extend() añade múltiples elementos de una sola vez, expandiendo el tamaño de la lista original.

                  
                    # Lista original
                    frutas = ['manzana', 'pera', 'naranja']
                    # Nueva lista para agregar
                    mas_frutas = ['uva', 'fresa']
                    # Usando extend() para agregar los elementos
                    frutas.extend(mas_frutas)
                    print(frutas)  # Resultado: ['manzana', 'pera', 'naranja', 'uva', 'fresa']
                  
              

remove()

Este método integrado de las listas en Python que elimina la primera aparición de un elemento específico dentro de la lista.

Características importantes:

• Solo elimina la primera ocurrencia del elemento.
• Modifica la lista original.
• Es útil cuando se conoce el valor del elemento a eliminar (no su posición).
• Si el elemento no existe, lanza un error ValueError.

                  
                    # Lista de frutas
                    frutas = ['manzana', 'pera', 'naranja', 'manzana', 'uva']
                    # Eliminar la primera 'manzana'
                    frutas.remove('manzana')
                    print(frutas)  # Resultado: ['pera', 'naranja', 'manzana', 'uva']
                    # Manejo de errores al intentar eliminar un elemento que no existe
                    try:
                        frutas.remove('plátano')
                    except ValueError:
                        print("No se encontró el elemento en la lista")
                    # Si hay elementos duplicados, solo elimina la primera ocurrencia
                    numeros = [1, 2, 3, 2, 4]
                    numeros.remove(2)
                    print(numeros)  # Resultado: [1, 3, 2, 4]
                    
                

pop()

El método pop() es una función incorporada de las listas en Python que elimina y devuelve un elemento de una lista.

Características importantes:

• Si la lista está vacía, lanza un ValueError.
• Si el índice está fuera de rango, lanza un IndexError
• Acepta índices negativos (-1 para el último elemento, -2 para el penúltimo, etc.)
• Es más eficiente que eliminar elementos con el método remove() cuando se conoce el índice

                  
                    # Lista inicial de lenguajes de programación
                    lenguajes = ['Python', 'Java', 'JavaScript', 'PHP', 'Ruby']
                    # 1. Eliminar y obtener el último elemento (sin índice)
                    ultimo_lenguaje = lenguajes.pop()
                    print(f"Lenguaje eliminado: {ultimo_lenguaje}")          # Resultado: Lenguaje eliminado: Ruby
                    print(f"Lista actualizada: {lenguajes}")                 # Resultado: ['Python', 'Java', 'JavaScript', 'PHP']
                    # 2. Eliminar y obtener elemento por índice específico
                    lenguaje_posicion_1 = lenguajes.pop(1)
                    print(f"Lenguaje eliminado: {lenguaje_posicion_1}")     # Resultado: Lenguaje eliminado: Java
                    print(f"Lista actualizada: {lenguajes}")                 # Resultado: ['Python', 'JavaScript', 'PHP']
                    # 3. Eliminar y obtener elemento con índice negativo
                    lenguaje_penultimo = lenguajes.pop(-2)
                    print(f"Lenguaje eliminado: {lenguaje_penultimo}")      # Resultado: Lenguaje eliminado: JavaScript
                    print(f"Lista actualizada: {lenguajes}")                 # Resultado: ['Python', 'PHP']
                    # 4. Uso práctico: Eliminar y usar el elemento eliminado
                    carrito_compras = ['laptop', 'mouse', 'teclado', 'monitor']
                    item_procesado = carrito_compras.pop(0)
                    print(f"Procesando item: {item_procesado}")             # Resultado: Procesando item: laptop
                    print(f"Items pendientes: {carrito_compras}")           # Resultado: ['mouse', 'teclado', 'monitor']                    
                

sort()

"Es un método incorporado de las listas en Python que ordena los elementos de la lista en orden ascendente por defecto. Este método modifica la lista original (ordenamiento in-place) y no crea una nueva lista."

Sintaxis básica:

                
                  lista.sort(reverse=False, key=None)
                  
              

Parámetros:

• reverse: Parámetro opcional (boolean). Si es True, ordena en orden descendente.
• key: Parámetro opcional. Una función que sirve como criterio de ordenamiento.

Ejemplos prácticos:

                  
                    # Ordenar números
                    numeros = [5, 2, 8, 1, 9, 3]
                    numeros.sort()
                    print(numeros)  # Resultado: [1, 2, 3, 5, 8, 9]
                    # Ordenar en orden descendente
                    numeros.sort(reverse=True)
                    print(numeros)  # Resultado: [9, 8, 5, 3, 2, 1]
                    # Ordenar cadenas
                    palabras = ['zebra', 'animal', 'casa', 'barco']
                    palabras.sort()
                    print(palabras)  # Resultado: ['animal', 'barco', 'casa', 'zebra']
                    # Ordenar por longitud de palabra usando key
                    palabras = ['gato', 'elefante', 'oso', 'mariposa']
                    palabras.sort(key=len)
                    print(palabras)  # Resultado: ['oso', 'gato', 'elefante', 'mariposa']
                    
                

Características importantes:

• Modifica la lista original.
• No retorna una nueva lista (retorna None).
• Solo funciona con listas, no con otros iterables.
• Los elementos deben ser comparables entre sí.

reverse()

Es un método incorporado que invierte el orden de los elementos de una lista, modificando la lista original. Los elementos del final se mueven al principio y viceversa, alterando el orden de forma permanente sin crear una nueva lista.

Características importantes:

• Modifica la lista original (in-place).
• No devuelve una nueva lista.
• No requiere argumentos.
• Es más eficiente que crear una nueva lista invertida.

Ejemplo práctico:

                  
                    # Lista original
                    numeros = [1, 2, 3, 4, 5]
                    # Aplicando el método reverse()
                    numeros.reverse()
                    print(numeros)  # Resultado: [5, 4, 3, 2, 1]
                    # También funciona con diferentes tipos de datos
                    frutas = ['manzana', 'pera', 'plátano', 'naranja']
                    frutas.reverse()
                    print(frutas)  # Resultado: ['naranja', 'plátano', 'pera', 'manzana']
                    
                

Alternativas:

                  
                    # Usando el operador de rebanado [::-1] (crea una nueva lista)
                    numeros = [1, 2, 3, 4, 5]
                    numeros_invertidos = numeros[::-1]  # Nueva lista: [5, 4, 3, 2, 1]
                    # La lista original permanece sin cambios
                    print(numeros)  # Resultado: [1, 2, 3, 4, 5]
                    
                

split()

Este método se utiliza para dividir una cadena de texto en una lista de palabras o fragmentos, basándose en un delimitador especificado. Este método es especialmente útil para analizar y manipular texto, ya que permite extraer palabras o partes específicas de una cadena larga.

Sintaxis:

                  
                    cadena.split(separador, maxsplit)
                  
                

• separador: (opcional) Especifica el delimitador que se usará para dividir la cadena. Si no se especifica, .split() utiliza el espacio en blanco como delimitador por defecto.
• maxsplit: (opcional) Es el número máximo de divisiones a realizar. Si se especifica, la cadena se dividirá solo ese número de veces. Si no se indica, se realizarán todas las divisiones posibles.

Ejemplos de uso:

• Dividir una cadena en palabras (con espacio como delimitador por defecto):

                        
                          texto = "Python es un lenguaje poderoso"
                          palabras = texto.split()
                          print(palabras)  # Imprime: ['Python', 'es', 'un', 'lenguaje', 'poderoso']
                        
                      

• Dividir una cadena usando un delimitador específico: Si se quiere dividir una cadena basada en un carácter diferente, como una coma, es posible especificarlo como delimitador.

                        
                          valores = "10,20,30,40"
                          numeros = valores.split(",")
                          print(numeros)  # Imprime: ['10', '20', '30', '40']
                        
                      

• Limitar el número de divisiones usando maxsplit: Es posible limitar el número de partes en las que se divide la cadena utilizando el parámetro maxsplit.

                    
                      texto = "Python es un lenguaje poderoso y versátil"
                      fragmentos = texto.split(" ", 3)
                      print(fragmentos)  # Imprime: ['Python', 'es', 'un', 'lenguaje poderoso y versátil']
                    
                  

• Dividir una cadena basada en saltos de línea: .split() también puede dividir cadenas que contengan saltos de línea u otros caracteres de espacio en blanco.

                    
                      parrafo = "Línea1\nLínea2\nLínea3"
                      lineas = parrafo.split("\n")
                      print(lineas)  # Imprime: ['Línea1', 'Línea2', 'Línea3']
                    
                  

• Uso con varias ocurrencias del delimitador: Cuando el delimitador aparece múltiples veces seguidas, .split() trata cada ocurrencia por separado y crea elementos vacíos en la lista resultante si no hay contenido entre delimitadores.

                    
                      texto = "apple,,banana,,cherry"
                      frutas = texto.split(",")
                      print(frutas)  # Imprime: ['apple', '', 'banana', '', 'cherry']
                    
                  

Creación de Listas Anidadas

Una lista anidada es simplemente una lista que contiene otras listas como elementos. A continuación se muestra un ejemplo básico de una lista anidada:

                  
                    lista_anidada = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
                  
                

En este caso, lista_anidada contiene tres listas: [1, 2, 3], [4, 5, 6] y [7, 8, 9]. Esto puede interpretarse como una matriz de 3 filas y 3 columnas.

Acceso a Elementos en Listas Anidadas

Para acceder a los elementos de una lista anidada, se usan índices múltiples. El primer índice selecciona la sublista deseada, y el segundo índice selecciona el elemento dentro de esa sublista.

                  
                    print(lista_anidada[0])      # Imprime: [1, 2, 3] (primera sublista)
                    print(lista_anidada[0][1])   # Imprime: 2 (segundo elemento de la primera sublista)
                    print(lista_anidada[2][2])   # Imprime: 9 (tercer elemento de la tercera sublista)
                  
                

Modificación de Elementos en Listas Anidadas

Es posible modificar elementos dentro de listas anidadas accediendo directamente al índice del elemento deseado.

                  
                    lista_anidada[1][1] = 99  # Cambia el valor 5 por 99 en la segunda sublista
                    print(lista_anidada)      # Imprime: [[1, 2, 3], [4, 99, 6], [7, 8, 9]]
                  
                

Iteración en Listas Anidadas

Para recorrer una lista anidada, se pueden usar bucles anidados. A continuación se muestra cómo imprimir cada elemento de una lista anidada.

                  
                    for fila in lista_anidada:
                      for elemento in fila:
                        print(elemento, end=" ")
                      print()  # Salto de línea después de cada sublista
                  
                

Ejemplo: Representación de una Matriz

Las listas anidadas son útiles para representar estructuras bidimensionales como matrices. Por ejemplo:

                  
                    matriz = [
                    [1, 0, 0],
                    [0, 1, 0],
                    [0, 0, 1]
                    ]
                    # Accediendo al elemento en la posición (2, 2)
                    print(matriz[1][1])  # Imprime: 1