Limitaciones y soluciones de las estructuras de datos de Python

Las variables de Python son buenas para almacenar información volátil. Este valor puede cambiar con el tiempo. Pero, cuando desea almacenar una lista larga de información, que no cambia con el tiempo (no volátil) o cambia con menos frecuencia, las variables no son una buena opción. Por ejemplo, desea almacenar los nombres de los meses del año, la guía telefónica, la lista de artículos esenciales para el hogar. ¿Cuál es la otra opción disponible en Python?

¡Sí!
Las estructuras de datos están disponibles en Python para superar este escenario. A continuación se muestran las diferentes estructuras de datos disponibles:

  • Instrumentos de cuerda
  • Liza
  • Tuplas
  • Conjuntos
  • Diccionarios
  • La estructura de datos adicional en el módulo de recopilación
  • La estructura de datos adicional en el módulo heapq

Instrumentos de cuerda:

La estructura de datos de la cadena es una secuencia inmutable de caracteres. Las cadenas se pueden declarar utilizando comillas simples y dobles.

Str1 = ‘La superficie del círculo se puede calcular usando la fórmula predefinida’

Str2
= “Mi nombre es Python”

Hay una forma más de definir cadenas mediante comillas triples. El propósito de la cadena de comillas triples es especificar cadenas de varias líneas.

Str3 = “” “Las comillas triples se utilizan para escribir comentarios

que se extienden por más de una línea” “”


Str4
= ” ‘Mi prueba de Docstring’ ”

Se dan otros ejemplos de la declaración de cadenas.

hola_1 = 30
imprimir ( hola_1 )
Salida: 30

No se permiten caracteres especiales mientras sea identificador de cadena.

myname @ = ‘abc’
print ( myname @ )
Salida: Archivo “” , línea 17 print ( myname @ ) SyntaxError : sintaxis no válida

Hay muchas funciones integradas disponibles para manipular cadenas:

zfill (), isdigit (), isalpha (), isupper (), islower (), istitle (), isspace (), len (), count (), strip ( ), reemplazar (), traducir (), partición ()

Limitación de cadena:

La cadena es una estructura de datos primitiva. Funciona bien si se debe asignar un solo elemento en una variable. Pero, cuando es necesario manejar varios elementos en una sola variable, como meses de años o la lista de estudiantes de una clase, las cadenas no son útiles. La solución es List and Tuple Data Structure, que maneja estos requisitos de manera efectiva.

Lista:

Las listas son colecciones ordenadas de elementos como cadenas, números enteros o incluso otras listas. Cada elemento tiene un índice que comienza desde cero. La lista es una estructura de datos mutable, es decir, se puede ampliar o reducir cuando sea necesario. La lista puede contener tipos de datos heterogéneos como elementos. La lista se incluye entre corchetes. Para declarar una lista:

lista = [ 1 , 2 , 3.4 , ‘Cinco’ ]
imprimir ( lista )
imprimir ( lista [ 0 ] )                                                                                                                                                             imprimir ( lista [ 3 ] )
Resultado:
[ 1 , 2 , 3.4 , ‘Cinco’ ]
1

Cinco

Hay muchas funciones de manipulación de listas disponibles en Python:

append (), extend (), index (), insert (), remove (), pop (), count (), sort (), reverse ()


list [primer índice : último índice: paso]


Python proporciona una característica interesante que divide la lista.
El corte se usa para construir una nueva lista a partir de la lista existente. Ahora veamos la operación de corte en la lista. Primero, vea la representación gráfica de los elementos de la lista con valores de índice.

Imagen de lista

Ahora vea el código a continuación cómo se divide la lista existente basada en valores de índice. El primer parámetro entre corchetes es el índice de inicio y el segundo parámetro es el valor de parada. La lista se dividirá hasta (valor de parada-1).

lista = [ 0 , 1 , 2 , 3 , 4 , 5 ]
print ( lista )
print ( lista [ 2 : ] )    #El punto de inicio del corte será el índice 2 que es el elemento “2”
imprimir ( lista [ : 2 ]     #Slicing será del índice 0 por defecto al índice 1
imprimir ( lista [ 2 : – 1 ] )  # El corte será del índice 2 al índice -2 (valor de parada-1)
Salida:
[ 0 , 1 , 2 , 3 , 4 , 5 ]
[ 2 , 3 , 4 , 5 ]
[ 0 , 1 ]
[ 2 , 3 , 4 ]

Limitación de la lista:

La lista tiene la limitación de que solo se puede agregar al final. Pero, en la vida real, hay situaciones en las que un desarrollador tiene que agregar elementos al comienzo de la lista existente, lo que se vuelve difícil en la lista. A veces, también se requiere la rotación de elementos dentro de la lista , lo que también es una limitación en la lista. La solución es Deque Data Structure, que proporciona flexibilidad para agregar elementos desde ambos extremos y rotar elementos dentro de deque.

Tuplas:

Las tuplas son colecciones ordenadas de elementos similares a la estructura de datos de la lista. La principal diferencia entre una tupla y una estructura de datos de lista es que las tuplas son inmutables, es decir, no se pueden cambiar una vez declaradas. Por lo tanto, la manipulación de tuplas es más rápida que la lista. La tupla está entre paréntesis.

tuplea = ( 1 , ‘encuentro’ , 28 , ‘abc’ )
print ( tuplea )
print ( tuplea [ 3 ] )

tuplea
[ 3 ] = ‘def’  #Esto es inmutable Por lo tanto TypeError
Salida:
( 1 , ‘conocer’ , 28 , ‘abc’ )

abc

TypeError : ‘tupla’ objeto no no admite la asignación elemento

También hay varios métodos disponibles para la manipulación de tuplas. Count (), index (), len (), max () son algunos ejemplos.

La característica interesante de la tupla es que también se puede utilizar como función de intercambio.

Suponga que desea intercambiar (intercambiar) el valor de 2 variables ayb, puede usar directamente la variable tupla para esta operación.
En lugar de utilizar una lógica de variable temporal que implica más comandos, se puede utilizar el intercambio de tuplas, que es un comando de una línea.

a = 2

b
= 3
( b , a ) = ( a , b )
imprimir ( “a =” , a )
imprimir ( “b =” , b )
Salida:

a
= 3

b
= 2

Observe lo fácil que es intercambiar con una estructura de datos de tupla.

Limitación de tuplas:

Las tuplas no se pueden cambiar una vez declaradas . Pero, en la vida real, hay situaciones en las que es necesario agregar y actualizar elementos. Por lo tanto, tuple no encaja en estos escenarios. La solución es la estructura de datos de lista, que proporciona flexibilidad para agregar y actualizar en cualquier momento.

Conjuntos:

Los conjuntos son colecciones desordenadas de elementos mutables. Los conjuntos se utilizan para crear una secuencia de elementos únicos, ya que no permite duplicados. Esta estructura de datos proporciona operaciones matemáticas como unión, intersección y más.

A continuación se muestra el código para declarar conjunto:

a = set ( [ 1 , 2 , 3 , 3 , 3 , 4 , 4 , 5 ] )   #Verificar en la salida, ha eliminado los valores duplicados.
print ( a )                        # Solo se muestran valores únicos.
Salida: { 1 , 2 , 3 , 4 , 5 }

El conjunto no está ordenado, por lo tanto, no se puede acceder a él mediante el método de índice como lista y tuplas. Ahora, vea si intenta proporcionar un índice en el conjunto, obtendrá un error.

a = establecer ( [ 1 , 2 , 3 , 3 , 3 , 4 , 4 , 5 ] )
imprimir ( a [ 1 ] )
Salida: TypeError : el objeto ‘set’ no es subscriptable

Las operaciones para establecer la estructura de datos son las siguientes.

a = set ( [ 1 , 2 , 3 , 3 , 3 , 4 , 4 , 5 ] )

b
= set ( [ 3 , 4 , 5 , 6 ] )
print ( a | b ) # Union
print ( a & b ) #
Impresión de intersección ( a < ; b ) #
Impresión de subconjunto ( a – b) #
Impresión de diferencia ( a ^ b ) # Diferencia simétrica. Mostrar elementos que no son comunes
Resultado:
{ 1 , 2 , 3 , 4 , 5 , 6 }
{ 3 , 4 , 5 }
falso
{ 1 , 2 }
{ 1 , 2 , 6 }

Limitación de conjuntos:

Los conjuntos tienen la limitación de que no se pueden utilizar como clave en el diccionario . Pero, en la vida real, hay situaciones que un desarrollador debe considerar establecer como variable Clave en el diccionario. Hay una limitación más con el conjunto es que el conjunto de conjuntos no es posible . La solución es Frozenset Data Structure, que supera ambas limitaciones de la estructura de datos del conjunto.

Diccionarios:

Un diccionario es una secuencia desordenada de elementos. Cada artículo tiene una clave y un valor. Se puede acceder a los elementos mediante una clave. Las claves deben ser únicas en el diccionario. Una guía telefónica es un ejemplo de estructura de datos de diccionario. Tiene el nombre como clave y los detalles de contacto como valor.

DiccionarioSintaxis

A continuación se muestra un ejemplo de algunos métodos de diccionario:

dict = { ‘first’ : ‘TestDict’ , ‘second’ : [ 1 , 2 ] }
print ( dict . keys ( ) )   # muestra todas las claves
print ( dict . values ( ) ) # muestra todos los valores
print ( dict [ ‘primero’ ] ) # muestra el valor de la clave dada ‘Primero’. El valor de esta clave es TestDict
print ( dict . Items () )    # muestra todas las claves y valores
print ( dict . get ( ‘first’ ) ) # muestra el valor de la clave ‘First’ dada. El valor de esta clave es TestDict
print ( dict . Pop ( ‘first’ ) ) # muestra el valor de la Key ‘First’ dada y borra este elemento también
print ( dict . Items ( ) )      # Ahora solo hay un elemento en dict después de pop ()
Salida:

dict_keys
( [ ‘first’ , ‘second’ ] )

dict_values
( [ ‘TestDict’ , [ 1 , 2 ] ] )

TestDict


dict_items
( [ ( ‘first’ , ‘TestDict’ ) , ( ‘second’ , [ 1 , 2 ] ) ] )

TestDict


TestDict


dict_items
( [ ( ‘segundo’ , [ 1, 2 ] ) ] )

Limitación de diccionarios:

La única limitación es que se trata de datos estructurados desordenados . A veces, es necesario mantener el orden de los artículos, en los que se han insertado los artículos. La Solución es la estructura de datos OrderedDict que está disponible en el módulo Colecciones .

Congelados:

Ahora hay algunas limitaciones con la estructura de datos establecida.

    1. 1.Los conjuntos son mutables, por lo tanto, no se pueden usar como claves en diccionarios.
    1. Otro problema es que los conjuntos en sí mismos solo pueden contener valores inmutables y, por lo tanto, es posible que no contengan otros conjuntos.

Pero los conjuntos de conjuntos (conjuntos anidados) a menudo se requieren, por lo tanto, Python proporciona una estructura de datos congelada . El siguiente fragmento de código muestra cómo frozenset resolvió los problemas con los conjuntos:

a = establecer ( [ 1 , 2 , 3 ] )

b
= establecer ( [ 2 , 3 , 4 ] )
imprimir ( a. agregar ( b ) )
Salida:   TypeError : unhashable type : ‘set’ . Conjuntos no se pueden añadir

Ahora reemplace add () con frozenset como se muestra a continuación. Vea cómo se ha resuelto el problema del televisor.

a = set ( [ 1 , 2 , 3 ] )

b
= set ( [ 2 , 3 , 4 ] )
#print (a.add (b))

a.
añadir ( frozenset ( b ) )
imprimir ( a )
Resultado:   { 1 , 2 , 3 , frozenset ( { 2 , 3 , 4 } ) }

Una estructura de datos establecida no se puede usar como clave en el diccionario, por lo que Frozenset es la solución. Probemos con la estructura de datos establecida y veamos qué sucede en el código:

dictsetkey = { set ( [ 1 , 2 ] ) : 1 }
Salida: TypeError : unhashable type : ‘set’

Ahora reemplace set con frozenset y vea la magia. El error ha desaparecido:

dictsetkey = { frozenset ( [ 1 , 2 ] ) : ‘Frozenset como clave en el diccionario’ }
print ( dictsetkey [ frozenset ( [ 1 , 2 ] ) ] )
Salida: Frozenset como clave en el diccionario

Los módulos de recopilación y heapq proporcionan una estructura de datos adicional con características sólidas. Veremos un ejemplo del módulo de colección.

Deque:

Deque significa colas de dos extremos. Puede agregar y eliminar elementos de ambos lados a diferencia de las listas. También puede ser útil si los elementos deben eliminarse en el mismo orden en que se agregaron. Esto está disponible en el módulo de colección. A continuación se muestra el código para crear una estructura de datos deque y agregar un elemento en ambos extremos.

de colecciones import deque

doubleque
= deque ( rango ( 5 ) )
print ( doubleque )

doubleque.
append ( 5 )
print ( doubleque )

doubleque.
appendleft ( 6 )
print ( doubleque )

doubleque.
pop ( ) # elemento eliminado de

doubleque
derecho .
popleft ( ) # elemento eliminado de la izquierda
Salida:

deque
( [ 0 , 1 , 2 , 3 , 4 ] )

deque
( [ 0 , 1 , 2 , 3 , 4 , 5 ] )

deque
( [ 6 , 0 , 1 , 2 , 3 , 4 , 5 ] )
5
6

Una característica interesante del deque es la rotación. Puede rotar el último elemento como primer elemento.

imprimir ( doubleque )

q.
rotar ( 1 )
imprimir ( doubleque )
Salida:

deque
( [ 0 , 1 , 2 , 3 , 4 ] )

deque
( [ 4 , 0 , 1 , 2 , 3 ] )

El módulo Heapq le permite agregar objetos en orden arbitrario y en cualquier momento (posiblemente entre la adición) encontrar (y posiblemente eliminar) el elemento más pequeño. Estas estructuras de datos están relacionadas con la manipulación del montón.

Puede ver que estas estructuras de datos adicionales son sólidas.
Hay muchas otras estructuras de datos avanzadas disponibles en Python. Para obtener un conocimiento profundo, debe ensuciarse las manos en la codificación. Cubriremos estas poderosas estructuras de datos adicionales en artículos separados.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *