Diccionarios vs Matrices en Python - Inmersión Profunda

En esta guía, profundizaremos en matrices y diccionarios, las dos estructuras de datos más utilizadas en Python, y compararemos sus usos e implementaciones con ejemplos.

Introducción

En esta guía, veremos dos de las estructuras de datos más populares de Python: Diccionarios y Matrices. Cada uno de estos proporciona una forma específica de organizar sus datos, con ventajas y desventajas para ciertas tareas, y saber cuándo usar lo que le permitirá aprovechar las funcionalidades integradas.

Nota: Esta guía asume Python 3.x, y la mayor parte está orientada a versiones posteriores. Sin embargo, también notaremos algunas diferencias clave para Python 2.x.

Guía de arreglos de Python

Un Array es una de las estructuras de datos fundamentales en informática: una secuencia de 0..n elementos, donde cada elemento tiene un índice.

La mayoría de las matrices tienen un tamaño fijo, por lo que ocupan una parte de la memoria cada vez que se crea una nueva:

indexación de matrices

Aquí, tenemos una matriz simple que consta de 7 elementos. La indexación generalmente comienza en 0, y cada elemento tiene un índice posicional que podemos usar para acceder a él. Esto hace que la complejidad del tiempo de acceso de la matriz sea O(1).

La mayoría de las matrices de Python tienen tipos dinámicos, lo que significa que los objetos de una matriz tienen un tipo, pero la matriz en sí no está restringida a solo un tipo: puede tener una matriz que consiste en un número entero , una cadena y un objeto, o incluso de otra matriz que también esté heterogéneamente mezclada.

Hay 6 tipos importantes de arreglos en Python: list, tuple, str, bytes, bytearray y array.array.

Al hablar de cada uno de ellos, hay algunas propiedades clave que tendremos en cuenta:

  • Si son dinámicos o no dinámicos
  • Si están escritos estáticamente o dinámicamente
  • Si son mutables o inmutables

Listas de Python

Una lista en Python es dinámica (tamaño no fijo), escrita dinámicamente (elementos no restringidos a un solo tipo) y mutable (los elementos se pueden cambiar en -lugar).

En Python, una lista se define declarando sus elementos entre corchetes []. Avancemos y definamos una lista:

1
2
myList = [1, 2, 3, "Mark", "John", "Emma"]
print(myList)

Contiene algunos números enteros y algunas cadenas, que denotan nombres. Dado que las listas se escriben dinámicamente, esto está permitido:

1
[1, 2, 3, 'Mark', 'John', 'Emma']    

Dado que las listas son dinámicas, podemos cambiar la cantidad de elementos agregando uno nuevo, por ejemplo:

1
2
3
myList.append(4)
myList.append("Peter")
print(myList)

Esto da como resultado que nuestra lista tenga 8 elementos, en lugar de los 6 que hemos definido al principio:

1
[1, 2, 3, 'Mark', 'John', 'Emma', 4, 'Peter']

Ahora, intentemos reemplazar un elemento y agregar uno nuevo. Verificaremos la ID de la lista (referencia en la memoria) para confirmar que no está cambiada bajo el capó con una nueva copia que contiene elementos agregados o reemplazados:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
myList = [1, 2, 3, "Mark", "John", "Emma", 4, "Peter"]
# Print original list and its ID
print('Original list: ', myList)
print('ID of object in memory: ', id(myList))

# Modify existing element and add a new one
myList[4] = "Anna"
myList.append("Dan")

# Print changed list and its ID
print('Changed list: ', myList)
print('ID of object in memory: ', id(myList))

Ejecutar este código da como resultado:

1
2
3
4
Original list:  [1, 2, 3, 'Mark', 'John', 'Emma', 4, 'Peter']
ID of object in memory:  140024176315840
Changed list:  [1, 2, 3, 'Mark', 'Anna', 'Emma', 4, 'Peter', 'Dan']
ID of object in memory:  140024176315840

El hecho de que myList apunte al mismo objeto en memoria (140024176315840) demuestra aún más cómo las listas son mutables.

Nota: Las listas de Python pueden incluso almacenar funciones en una secuencia:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
def f1():
    return "Function one"

def f2():
    return "Function two"

def f3():
    return "Function three"

listOfFunctions = [f1, f2, f3]
print(listOfFunctions)

Lo que resultará en:

1
[<function f1 at 0x0000016531807488>, <function f2 at 0x00000165318072F0>, <function f3 at 0x0000016531807400>]

Nuestra salida consiste en funciones en las direcciones dadas. Ahora intentemos acceder a una función y ejecutarla:

1
print(listOfFunctions[0]())

Dado que el primer elemento de esta lista es f1(), esperaríamos que se ejecutara la instrucción print() adecuada:

1
Function one

Las listas son el tipo de matrices más utilizado en Python. Son fáciles de usar e intuitivos. Además, su complejidad de tiempo para acceder a los elementos es O(1).

Tuplas de Python

Una tupla en Python es no dinámica (tamaño fijo), de tipo dinámico (elementos no restringidos a un solo tipo) e inmutable (los elementos no se pueden cambiar en -lugar).

Además de eso, usamos corchetes regulares () al definirlos:

1
2
myTuple = (1, 2, 3, "Mark", "John", "Emma")
print(myTuple)

Dado que las tuplas son tipadas dinámicamente, podemos tener elementos de diferentes tipos presentes dentro de ellas:

1
(1, 2, 3, 'Mark', 'John', 'Emma')

Dado que las tuplas son no dinámicas, tienen un tamaño fijo, y no podemos agregarles elementos en el lugar, ya que esto cambia su tamaño. Por lo tanto, las tuplas no tienen un método append().

Sin embargo, podemos crear una nueva tupla que consta de tuplas más pequeñas, que nuevamente es de tamaño fijo:

1
2
3
4
5
6
7
8
myTuple = (1, 2, 3)
anotherTuple = ("Mark", "John", "Emma")
print('Original tuple: ', myTuple)
print('ID of object in memory: ', id(myTuple))

myTuple = myTuple + anotherTuple
print('New tuple: ', myTuple)
print('ID of object in memory: ', id(myTuple))

Hemos asignado la misma referencia de variable a un nuevo objeto creado para contener ambas tuplas juntas; aunque la variable de referencia es la misma, apunta a un objeto totalmente diferente en la memoria:

1
2
3
4
5
Original tuple:  (1, 2, 3)
ID of object in memory:  139960147395136

New tuple:  (1, 2, 3, 'Mark', 'John', 'Emma')
ID of object in memory:  139960147855776

La complejidad del tiempo para acceder a los elementos de una tupla también es O(1).

Cadenas de Python {#cadenas de Python}

En Python 3, el tipo str (abreviatura de String) se revisó de Python 2. En Python 2, solía representar tanto texto como bytes, pero desde Python 3, estos dos son tipos de datos totalmente diferentes.

Una cadena en Python es no dinámica (tamaño fijo), estáticamente tipada (elementos restringidos a un solo tipo) e inmutable (los elementos no se pueden cambiar en- lugar).

Una secuencia de bytes (en caracteres legibles por humanos), entre paréntesis "" se usa para definir una cadena:

1
2
myStr = "qwerty"
print(myStr)

Esto dará como resultado:

1
qwerty

Podemos acceder a los elementos a través de la indexación de matrices estándar, pero no podemos cambiarlos:

1
2
print(myStr[0])
myStr[0] = "p"

Esto dará como resultado:

1
2
q
TypeError: 'str' object does not support item assignment

De hecho, las cadenas son recursivas. Cuando declaramos una cadena usando caracteres, se forma una cadena para cada carácter, que luego se agrega a una lista de cadenas que constituyen otra cadena.

myStr tiene una longitud de 5 y se compone de cinco cadenas individuales, de longitud 1:

1
2
3
4
5
6
7
myStr = "abcde"
print(len(myStr)) # Check the length of our str
print(type(myStr)) # Check the type of our str

print(myStr[0]) # Letter 'a'
print(len(myStr[0])) # Check the length of our letter
print(type(myStr[0])) # Check the type of our letter 'a'

Esto resulta en:

1
2
3
4
5
5
<class 'str'>
a
1
<class 'str'>

Tanto nuestro 'carácter' como la cadena son de la misma clase: str.

De manera similar a las tuplas, podemos concatenar cadenas, lo que da como resultado una nueva cadena que consta de las dos más pequeñas:

1
2
3
4
5
myStr = "qwerty"
myStr2 = "123"

result = myStr + myStr2
print(result)

Y el resultado es:

1
qwerty123

Nuevamente, las cadenas solo admiten caracteres y no podemos mezclar otros tipos:

1
2
3
4
5
myStr = "qwerty"
myStr2 = 123

result = myStr + myStr2
print(result)

Lo que resultará en:

1
TypeError: can only concatenate str (not "int") to str

Sin embargo, int, así como cualquier otro tipo, se puede castear (convertir) en una representación de cadena:

1
2
3
4
5
myStr = "qwerty"
myStr2 = str(123) # int 123 is now casted to str

result = myStr + myStr2
print(result)

Esto dará como resultado:

1
qwerty123

Con este método puede imprimir, por ejemplo, ints y strings en la misma línea:

1
2
3
4
myStr = "qwerty"
print("myStr's length is: " + len(myStr)) # TypeError

print("myStr's length is: " + str(len(myStr))) # String concatenation resulting in 'myStr's length is: 6'

Bytes de Python

Los bytes en Python son no dinámicos (tamaño fijo), escritos estáticamente (elementos restringidos a un solo tipo) e inmutables (los elementos no se pueden cambiar en el lugar ).

Un objeto bytes consta de múltiples bytes individuales o enteros, que van desde 0 hasta 255 (8 bits).

Definir un objeto bytes es ligeramente diferente de otras matrices, ya que explícitamente tenemos que convertir una tupla en bytes:

1
2
myBytes = bytes((0, 1, 2))
print(myBytes)

Esto dará como resultado:

1
b'\x00\x01\x02'

Si la tupla contiene elementos de diferentes tipos, se lanza un TypeError:

1
myBytes = bytes((0, 1, 2, 'string'))
1
TypeError: 'str' object cannot be interpreted as an integer

Cuando se trabaja con str's, una matriz de bytes debe codificarse con un conjunto de caracteres, de lo contrario, será ambiguo en cuanto a lo que representan:

1
2
3
4
5
6
myStr = "This is a string"

myBytes = bytes(myStr) # this will result in an error TypeError: string argument without an encoding

myBytes = bytes(myStr, 'utf-8')
print(myBytes) # this will print out myStr normally

Si no está familiarizado con el funcionamiento de la codificación de bytes, lea nuestra guía sobre Cómo convertir bytes a cadena en Python.

Además, una matriz bytes de enteros puede ser mutable cuando se convierte en otro tipo de matriz llamado bytearray.

Bytearray de Python

Un Bytearray en Python es dinámico (tamaño no fijo), escrito estáticamente (elementos restringidos a un solo tipo) y mutable (los elementos se pueden cambiar en el lugar) .

1
myByteArray = bytearray((0, 1, 2))

Ahora, podemos intentar agregar elementos a esta matriz, así como cambiar un elemento:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
myByteArray = bytearray((0, 1, 2))
print(myByteArray)
print("ByteArray ID: ", id(myByteArray))

myByteArray.append(3)
print(myByteArray)
print("ByteArray ID: ", id(myByteArray))

myByteArray[3] = 50
print(myByteArray)
print("ByteArray ID: ", id(myByteArray))

Esto resulta en:

1
2
3
4
5
6
7
8
bytearray(b'\x00\x01\x02')
ByteArray ID:  140235112668272

bytearray(b'\x00\x01\x02\x03')
ByteArray ID:  140235112668272

bytearray(b'\x00\x01\x022')
ByteArray ID:  140235112668272

Todos estos tienen el mismo ID de objeto, que apunta al mismo objeto en memoria que se está cambiando.

Un bytearray se puede convertir de nuevo en una matriz de bytes; sin embargo, tenga en cuenta que es una operación costosa que requiere O(n) tiempo.

Python array.array

Hasta ahora, hemos estado trabajando con tipos integrados. Sin embargo, existe otro tipo de matriz, en el módulo array.

Esta matriz es dinámica (tamaño no fijo), estáticamente tipada (elementos restringidos a un solo tipo) y mutable (se puede cambiar en el lugar). Necesitamos anotar explícitamente el tipo que usaremos en una matriz y estos tipos son tipos de estilo C: enteros de 32 bits, números de coma flotante, dobles, etc.

Cada uno de estos tiene un marcador: i para números enteros, f para flotantes y d para dobles. Hagamos una matriz de enteros a través del módulo array:

1
2
3
import array

myArray =  array.array("i", (1, 2, 3, 4))

Algunos de los tipos tipo C más utilizados:

c tipos

Guía de diccionarios de Python

El Diccionario es una estructura de datos central en Python. Almacena datos en pares clave-valor.

Debido a esto, también se le puede llamar mapa, mapa hash o tabla de búsqueda.

Hay algunas variantes diferentes de un diccionario:

  • dict
  • colecciones.defaultdict
  • colecciones.OrderedDict
  • colecciones.ChainMap

Los diccionarios se basan en valores hash, que identifican claves para la operación de búsqueda. Una tabla hash contiene muchos valores hash que nunca cambian durante el tiempo de vida de una tabla hash.

Tipo hashable y valores hash

Cada objeto tiene un valor hash, y se puede usar el método hash() para recuperarlo. Este valor no es constante y se calcula en tiempo de ejecución, aunque si a == b, hash(a) siempre será igual a hash(b):

1
2
3
4
5
6
randomString = "This is a random string"
a = 23
b = 23.5
print(hash(randomString))
print(hash(a))
print(hash(b))

Este código dará como resultado algo similar a:

1
2
3
4400833007061176223
23
1152921504606846999

Nota: Los valores numéricos que son iguales tienen el mismo valor hash, independientemente de su tipo:

1
2
3
4
a = 23
b = 23.0
print(hash(a))
print(hash(b))

Resultados en:

1
2
23
23

Este mecanismo es lo que hace que los diccionarios sean increíblemente rápidos en Python: identificadores únicos para cada elemento, lo que les otorga un tiempo de búsqueda de O(1).

Diccionario de Python

El contenido de un diccionario (tipo dict) se define entre llaves {}. La sintaxis se parece a JSON, dados los pares clave-valor:

1
2
3
4
5
myDict = {
    "name": "Mike James",
    "age": 32,
    "country": "United Kingdom"
}

Un diccionario puede tener un número arbitrario de pares y las claves deben ser hash sin claves duplicadas (las claves duplicadas darán como resultado el mismo hash). En tales casos, la primera clave será rechazada y el diccionario solo contendrá la segunda clave.

Dado que los diccionarios son mutables, podemos agregar un nuevo par clave-valor simplemente 'accediendo' a una clave inexistente y configurando su valor:

1
2
myDict["countries_visited"] = ["Spain", "Portugal", "Russia"]
print(myDict)

Esto dará como resultado:

1
{'name': 'Mike James', 'age': 34, 'country': 'United Kingdom', 'countries_visited': ['Spain', 'Portugal', 'Russia']}

El núcleo dict de Python probablemente resolverá la mayoría de sus problemas, pero si no, hay algunos tipos de diccionarios que se pueden importar desde una biblioteca llamada colecciones.

Python DefaultDict

Un problema que puedes encontrar cuando usas un dict es intentar acceder al valor de una clave que no existe.

Por ejemplo, en nuestra demostración anterior, si accedíamos a print(myDict["zip_code"]), obtendríamos un KeyError: zip_code ya que zip_code no existe.

Aquí es cuando entra en juego defaultdict, ya que solicita default_factory, una función que devuelve el valor predeterminado si no hay una clave presente. De esta forma, un defaultdict nunca puede generar un KeyError:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
from collections import defaultdict 

def safe_function(): # default_factory
    return "Value not defined"

myDict = defaultdict(safe_function)
myDict["name"] = "Mark James"
myDict["age"] = 32

print(myDict["country"]) # This will output Value not defined and not raise a KeyError

Esto, como era de esperar, resulta en:

1
Value not defined

Definir valores defaultdict es diferente de la clase dict principal porque cada par clave-valor debe definirse 'manualmente', lo cual es más tedioso que la sintaxis similar a JSON.

Mapa de cadena de Python {#mapa de cadena de Python}

Este tipo de diccionario nos permite conectar varios diccionarios en uno, para encadenarlos. Al acceder a los datos, buscará una clave una por una hasta encontrar la primera correcta:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
from collections import ChainMap

myDict1 = {
    "name": "Mike James",
    "age": 32
}

myDict2 = {
    "name": "James Mike",
    "country": "United Kingdom",
    "countries_visited": ["Spain", "Portugal", "Russia"]    
}

myDictResult = ChainMap(myDict1, myDict2)
print(myDictResult)

Esto da como resultado un ChainMap:

1
ChainMap({'name': 'Mike James', 'age': 32}, {'name': 'James Mike', 'country': 'United Kingdom', 'countries_visited': ['Spain', 'Portugal', 'Russia']})

Nota: Podemos definir claves duplicadas. 'nombre' está presente en ambos diccionarios. Sin embargo, cuando intentamos acceder a la tecla 'nombre':

1
print(myDictResult['name'])

Encuentra la primera clave coincidente:

1
Mike James

También tenga en cuenta que estos aún pueden generar un KeyError, ya que ahora estamos trabajando con un dict central.

Python OrderedDict

Nota: A partir de Python 3.6, los diccionarios están ordenados por inserción de forma predeterminada.

El OrderedDict se utiliza cuando desea mantener el orden de inserción de pares clave-valor en un diccionario. dict no garantiza esto, y puede terminar con un orden de inserción diferente al cronológico.

Si esto no es algo importante, puedes usar cómodamente un diccionario. Sin embargo, si esto es importante, como cuando se trata de fechas, querrá usar un OrderedDict en su lugar:

1
2
3
4
5
6
7
8
9
from collections import OrderedDict

orderedDict = OrderedDict()
orderedDict['a'] = 1
orderedDict['b'] = 2
orderedDict['c'] = 3
orderedDict['d'] = 4
  
print(orderedDict)

Esto resulta en:

1
OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 4)])

Nota: Aunque los objetos dict conservan el orden de inserción a partir de Python 3.6, use OrderedDict si se requiere un orden de inserción. Su código no garantiza el orden de inserción en otras versiones de Python (anteriores) si usa un dict regular.

Métodos de diccionario frente a métodos de matriz

Ahora que nos hemos puesto al día, deberíamos cubrir todos los métodos que estos dos tipos han implementado en ellos. Hay cuatro operaciones básicas que se pueden hacer con los datos: acceder (obtener), actualizar, agregar, eliminar.

Definamos una matriz y un diccionario con los que experimentaremos:

1
2
3
4
5
6
7
8
9
exampleDict = {
    "id": 101,
    "name": "Marc Evans",
    "date_of_birth": "13.02.1993.",
    "city": "Chicago",
    "height": 185,
}

exampleArray = [1, 2, 3, "red", "green", "yellow", "blue", 4]

Obtención de datos {#obtención de datos}

Diccionario: Hay varias formas de acceder a los datos en un diccionario:

  • Refiriéndose a un nombre clave - myDict["key_name"]:

    • 1
      2
      
      print(exampleDict["name"]) 
      # Output: Marc Evans
      
  • Llamar al método get() - myDict.get("key_name"):

    • 1
      2
      
      print(exampleDict.get("city")) 
      # Output: Chicago
      
  • Acceder a todas las claves en un diccionario - myDict.keys() - devuelve una lista de claves:

    • 1
      2
      
      print(exampleDict.keys()) 
      # Output: dict_keys(['id', 'name', 'date_of_birth', 'city', 'height'])
      
  • Acceder a todos los valores en un diccionario - myDict.values() - devuelve una lista de valores:

    • 1
      2
      
      print(exampleDict.values()) 
      # Output: dict_values([101, 'Marc Evans', '13.02.1993.', 'Chicago', 185])
      
  • Acceso a todos los pares clave-valor: myDict.items() - devuelve una tupla de pares clave-valor:

    • 1
      2
      
      print(exampleDict.items()) 
      # Output: dict_items([('id', 101), ('name', 'Marc Evans'), ('date_of_birth', '13.02.1993.'), ('city', 'Chicago'), ('height', 185)]
      

Matriz: Solo hay una forma de obtener datos de una matriz:

  • Al referirse al índice de un elemento - myArray[index_number]:

    • 1
      2
      
      print(exampleArray[3]) 
      # Output: red
      

Actualización de datos

Diccionario: Hay 2 formas de actualizar datos en un diccionario:

  • Establecer directamente un nuevo valor para una determinada clave - myDict["key"] = new_value:

    • 1
      2
      3
      
      exampleDict["height"] = 190
      print(exampleDict["height"]) 
      # Output: 190
      
  • Llamar al método update() - myDict.update({"key": new_value}) - Los argumentos del método deben ser un diccionario:

    • 1
      2
      3
      
      exampleDict.update({"height": 190})
      print(exampleDict["height"]) 
      # Output: 190
      

Matriz: Si una matriz es mutable, se puede cambiar de forma similar a la obtención de datos:

  • Haciendo referencia al índice de un elemento y estableciendo un valor diferente: myArray[index_number] = new_value

    • 1
      2
      3
      
      exampleArray[3] = "purple" 
      print(exampleArray) 
      # Output: [1, 2, 3, 'purple', 'green', 'yellow', 4, 'blue']
      

Añadir datos

Diccionario: Hay 2 formas de agregar datos a un diccionario:

  • Establecer un valor para una nueva clave, que creará automáticamente un par clave-valor y lo agregará: myDict["new_key"] = value:

    • 1
      2
      3
      
      exampleDict["age"] = 45
      print(exampleDict) 
      # Output: {'id': 101, 'name': 'Marc Evans', 'date_of_birth': '13.02.1993.', 'city': 'Chicago', 'height': 185, 'age': 45}
      
  • Llamar al método update() - myDict.update({"new_key": value}):

    • 1
      
      exampleDict.update({"age": 45}) 
      

Matriz: Hay un par de formas de agregar datos a una matriz (aunque una matriz debe ser mutable):

  • Llamar al método append() - myArray.append(new_element) - agrega new_element al final de myArray:

    • 1
      2
      3
      
      exampleArray.append("grey")
      print(exampleArray) 
      # Output: [1, 2, 3, "purple", "green", "yellow", "blue", 4, "grey"]
      
  • Llamar a un método insert() - myArray.insert(index_number, new_element) - inserta un new_element en la posición index_number:

    • 1
      2
      3
      
      exampleArray.insert(0, 0) 
      print(exampleArray)
      # Output: [0, 1, 2, 3, "purple", "green", "yellow", "blue", 4, "grey"]
      
  • Llamar al método extend() - myArray.extend(myArray2) - inserta elementos de myArray2 al final de myArray:

    • 1
      2
      3
      4
      
      exampleArray2 = [5, 6]
      exampleArray.extend(exampleArray2)
      print(exampleArray)
      # Output: [0, 1, 2, 3, "purple", "green", "yellow", "blue", 4, "grey", 5, 6]
      

Eliminación de datos

Diccionario: Hay varias formas de eliminar datos de un diccionario:

  • Llamar a un método pop() - myDict.pop("key_name") - toma el nombre de la clave a eliminar

    • 1
      2
      3
      4
      
      exampleDict.pop("name")
      print(exampleDict)
      
      # {'id': 101, 'date_of_birth': '13.02.1993.', 'city': 'Chicago', 'height': 185}
      
  • Llamar al método popitem() - myDict.popitem() - en Python 3.7+, elimina el último par clave-valor agregado y en las versiones de Python inferiores a 3.7 elimina un par clave-valor aleatorio:

    • 1
      2
      3
      4
      
      exampleDict.popitem()
      print(exampleDict)
      
      #{'id': 101, 'name': 'Marc Evans', 'date_of_birth': '13.02.1993.', 'city': 'Chicago'}
      
  • Usando la palabra clave del - del myDict["key_name"]

    •  1
       2
       3
       4
       5
       6
       7
       8
       9
      10
      
      del exampleDict['name']
      print(exampleDict)
      
      # {'id': 101, 'date_of_birth': '13.02.1993.', 'city': 'Chicago', 'height': 185}
      
      # del dict deletes the entire dictionary
      del exampleDict
      print(exampleDict)
      
      # NameError: name 'exampleDict' is not defined
      
  • Llamar al método clear() - myDict.clear() - vacía el diccionario, pero seguirá existiendo como uno vacío {}

    • 1
      2
      3
      4
      
      exampleDict.clear()
      print(exampleDict)
      
      # {}
      

Matriz: Hay algunas formas de eliminar datos de una matriz:

  • Llamar a un método pop() - myArray.pop(index_number) - elimina un elemento en el index_number especificado:

    • 1
      2
      3
      4
      
      exampleArray.pop(2)
      print(exampleArray)
      
      # [1, 2, 'red', 'green', 'yellow', 'blue', 4]
      
  • Llamar al método remove() - myArray.remove(value) - elimina el primer elemento con el value especificado:

    • 1
      2
      3
      4
      
      exampleArray.remove(2)
      print(exampleArray)
      
      # [1, 3, 'red', 'green', 'yellow', 'blue', 4]
      
  • Llamar a un método clear() - myArray.clear() - al igual que en el diccionario, elimina todos los elementos de una matriz, dejando uno vacío []:

    • 1
      2
      3
      4
      
      exampleArray.clear()
      print(exampleArray)
      
      # []
      

`

Licensed under CC BY-NC-SA 4.0