En la intersección de la ciberseguridad y la eficiencia de programación, se encuentra el dominio de las estructuras de datos en Python. ¿Quiere seleccionar elementos de una lista de objetos pero olvidó cómo comprender la lista? O tal vez tenga un archivo de notación de objetos JavaScript (JSON) y necesite encontrar una estructura de datos adecuada para procesar los datos que contiene.
La buena noticia es que hemos preparado esta hoja de referencia. También sirve como repaso de las estructuras de datos y algoritmos aplicados a Python.
Tipos de estructuras de datos en Python
Aquí hay un diagrama para ilustrar la jerarquía de las estructuras de datos de Python:
| DESCRIPCIÓN | EJEMPLOS | |
| String | Colección de caracteres entre comillas simples o dobles. | ‘Alvaro’, «Chirou» |
| Boolean | Valores lógicos | True, False |
| Integer | Número entero de longitud ilimitada. | 0, -273 |
| Float | decimal de coma flotante | 1.618, 3.1415926 |
Estructuras de datos no primitivas integradas en Python
Estas estructuras de datos, que almacenan valores y colecciones de valores, son inherentes a Python.
| DESCRIPCIÓN | ORDENADO | PERMITIR DUPLICADOS | MUDABLE | SINTAXIS | EJEMPLOS |
| List | √ | √ | √ | [ ] | • [1, 2.3, True] • [‘John’, ‘Doe’] |
| Tuple | √ | √ | ✕ | ( ) | • (‘age’, 22) • (7.89, False) |
| Set 0 is the same as False, as are 1 and True. | ✕ | ✕ | ✕ | { } | • {6, 4.5} • {‘nice’, True} |
| Dictionary Map, storing key-value pairs. | √ > 3,7 ✕ ≤ 3,6 | ✕ | √ | {key: value} | • • {«FB»: «Facebook», «WA»: «WhatsApp», «IG»: «Instagram»} {‘name’: ‘Bob’, ‘id’: 255} |
Operaciones de lista y tupla
Tenga en cuenta que las listas y tuplas de Python tienen un índice cero , lo que significa que el primer elemento tiene un índice de 0. Consulte el cuadro de comandos a continuación para ver un ejemplo.
Acceder a elementos en listas
La siguiente tabla se basa en esta lista:
fruit_list = ["manzana", "banana", "cereza", "naranja", "kiwi", "melón", "mango"].
| DOMINIO | DESCRIPCIÓN |
|---|---|
fruit_list[0] | Obtenga el primer elemento de la lista («manzana») |
fruit_list[1] | Obtenga el segundo elemento de la lista («banana») |
fruit_list[-1] | Consigue el último artículo («mango») |
fruit_list[2:5] | Obtenga los elementos de los índices de principio a fin. |
fruit_list[:4] | Obtenga los elementos desde el principio pero excluya «kiwi» y más allá |
fruit_list[2:] | Consigue los elementos desde «cereza» hasta el final. |
fruit_list[-4:-1] | Obtenga los artículos desde «naranja» (-4) en adelante pero excluya «mango» (-1) |
if "apple" in fruit_list: print("Yes, we have 'apple'") | Comprueba si «manzana» está en la lista |
Métodos de lista (y tupla)
Los comandos con un asterisco (*) se aplican a tuplas.
| DOMINIO | DESCRIPCIÓN | USO |
|---|---|---|
append() | Agregar un elemento al final de la lista | list1.append(element) |
clear() | Eliminar todos los elementos de la lista. | list1.clear() |
copy() | Devolver una copia de la lista | list1.copy() |
count() | Devuelve el número de elementos con el valor especificado* | list1.count(element) |
extend() | Agregar los elementos de una lista (o cualquier iterable), al final de la lista actual | list1.extend(list2) |
index() | Devuelve el índice del primer elemento con el valor especificado* | list1.index(element[,start[,end]]) |
insert() | Agregue un elemento en la posición especificada (la posición es un número entero) | list1.insert(position, element) |
pop() | Retire el elemento en la posición especificada. | list1.pop([index]) |
remove() | Eliminar el primer elemento con el valor especificado | list1.remove(element) |
reverse() | Invertir el orden de la lista | list1.reverse() |
sort()sort(reverse = True) | Ordenar la lista en orden ascendente/descendente | list1.sort()list2.sort(reverse = True) |
del() | Eliminar de la lista el elemento especificado con su índice | del list1[index] |
list1 + list2 | Unir dos listas | list1 = ["x", "y"]list2 = [8, 9]list3 = list1 + list2# Returns: ["x","y",8,9] |
Comprensión de listas
La comprensión de listas simplifica la creación de una nueva lista basada en los valores de una lista existente.
| DOMINIO | DESCRIPCIÓN |
|---|---|
[n for n in range(10) if n < 5] | Aceptar sólo números menores de 5 |
[x for x in fruits if "a" in x] | Aceptar artículos que contengan » a«. |
[x for x in fruits if x != "apple"] | Aceptar todos los artículos excepto » apple« |
[x.upper() for x in fruits] | Poner en mayúsculas los valores en la nueva lista. |
[x + '?' for x in fruits] | Agregue un signo de interrogación al final de cada elemento. |
['hello' for x in fruits] | Establezca todos los valores en la nueva lista en ‘ hello‘ |
[x if x != "banana" else "naranja" for x in fruits] | Reemplace » banana» con » naranja» en la nueva lista |
Accediendo a elementos en tuplas
A continuación, la tupla en cuestión es fruits = ("manzana", "banana", "cereza").
| DOMINIO | DESCRIPCIÓN |
|---|---|
"apple" in fruits | Compruebe si » apple» está presente en la tupla. Este comando devuelve el valor True. |
(x, y, z) = fruits# y == "banana"# z == "cereza"# _ == ["banana", "cereza"] | Asigne variables para ocupar cada elemento de la tupla, lo que también se conoce como desempaquetar una tupla. El número de variables debe coincidir con el número de valores de la tupla o utilizar un asterisco como se muestra para guardar los valores no deseados. |
Manipulación de tuplas
Agregar elementos
Puede agregar elementos a una tupla de la siguiente manera:
| Inicial | original = ("manzana", "banana", "cereza") |
| Código | new_item = ("naranja",)original += new_item |
| Resultado | ("manzana", "banana", "cereza", "naranja") |
Consejo: al crear una tupla de un solo elemento, recuerde incluir una coma.
Eliminar elementos y cambiar valores
Dado que las tuplas son inmutables, no puedes eliminar ni modificar su contenido directamente. La clave es convertirlo en una lista y viceversa.
| EJEMPLO | SUMA | ELIMINACIÓN | CAMBIAR |
|---|---|---|---|
| Inicial | original = ("manzana", "banana", "cereza") | original = ("manzana", "banana", "cereza") | original = ("manzana", "banana", "cereza") |
| → Lista | tempList = list(original) | tempList = list(original) | tempList = list(original) |
| Código | tempList.append("naranja") | tempList.remove("manzana") | tempList[1] = "kiwi" |
| → tupla | newList = tuple(tempList) | newList = tuple(tempList) | newList = tuple(tempList) |
Consecuencia de newList | ("manzana", "banana", "cereza", "naranja") | ("banana", "cereza") | ("kiwi", "banana", "cereza") |
Operaciones de diccionario
Agregar elementos
Hay tres métodos:
| EJEMPLO | ADICIÓN #1 (DIRECTA) | ADICIÓN #2 (ACTUALIZACIÓN()) | ADICIÓN #3 (**) |
|---|---|---|---|
| Inicial | meta = { "FB": "Facebook", "WA": "WhatsApp", "IG": "Instagram" }new_co = { "GIF": "Giphy" } | meta = { "FB": "Facebook", "WA": "WhatsApp", "IG": "Instagram" }new_co = { "GIF": "Giphy" } | meta = { "FB": "Facebook", "WA": "WhatsApp", "IG": "Instagram" }new_co = { "GIF": "Giphy" } |
| Código | meta["GIF"] = "Giphy" | meta.update(new_co) | meta = {**meta, **new_co} |
Consecuencia de meta | { "FB": "Facebook", "WA": "WhatsApp", "IG": "Instagram", "GIF": "Giphy" } | { "FB": "Facebook", "WA": "WhatsApp", "IG": "Instagram", "GIF": "Giphy" } | { "FB": "Facebook", "WA": "WhatsApp", "IG": "Instagram", "GIF": "Giphy" } |
Advertencia: las claves duplicadas harán que los valores más recientes sobrescriban los valores anteriores.
Operaciones Generales
| DOMINIO | DESCRIPCIÓN | EJEMPLO |
|---|---|---|
del dict1["key1"] | Eliminar el elemento con el nombre de clave especificado | del meta["WA"]# "WhatsApp" |
del dict1 | eliminar el diccionario | del meta |
dict1[key1] | Acceda al valor de un dict1 elemento del diccionario usando su clavekey1 | meta["FB"]# "Facebook" |
| Método de diccionario | Descripción | Uso |
clear() | Eliminar todos los elementos del diccionario. | dict1.clear() |
copy() | Devolver una copia del diccionario | dict1.copy() |
fromkeys() | Devolver un diccionario con las claves y el valor especificados | dict1.fromkeys(keys, value) |
get() | Devuelve el valor de la clave especificada. | dictionary.get(key_name, value) |
items() | Devuelve una lista que contiene una tupla para cada par clave-valor | dict1.items() |
keys() | Devolver una lista que contiene las claves del diccionario. | dict1.keys() |
pop() | Eliminar el elemento con la clave especificada. | dict1.pop(key_name) |
popitem() | Eliminar el último par clave-valor insertado | dict1.popitem() |
setdefault() | Devuelve el valor de la clave especificada. Si la clave no existe, agregue como nuevo par clave-valor | dict1.setdefault(key_name, value) |
update() | Actualizar el diccionario con los pares clave-valor especificados | dict1.update(iterable) |
values() | Devuelve una lista de todos los valores del diccionario. | dict1.values() |
Establecer operaciones
Accediendo
Aunque no puede acceder directamente a los elementos de un conjunto, puede recorrerlos en bucle:
| EJEMPLO | ACCEDER A ELEMENTOS DE UN CONJUNTO (USANDO LA COMPRENSIÓN DE LISTAS) |
|---|---|
| Código | set1 = {32, 1, 2, 27, 83, 26, 59, 60}set1_odd = [i for i in set1 if i % 2 == 1] |
| Resultado | set1_odd = [1, 27, 83, 59] |
Agregar y quitar elementos
| DOMINIO | DESCRIPCIÓN | USO |
|---|---|---|
add() | Añadir un solo elemento al conjunto. | fruits.add("naranja") |
update() | Agregar elementos de otro conjunto a este conjunto | fruits.add({"ananá", "mango", "sandía"}) |
discard()remove() | Eliminar el elemento especificado | fruits.discard("banana")fruits.remove("banana") |
pop() | Elimina el último elemento del conjunto. El valor de retorno de bye es el elemento eliminado. | bye = fruits.pop() |
clear() | Vaciar el conjunto | fruits.clear() |
copy() | Devolver una copia del set | fruits.copy() |
del | Eliminar el conjunto | del fruits |
Operaciones matemáticas
| COMANDO/OPERADOR(ES) BINARIO(S) | DESCRIPCIÓN |
|---|---|
difference()- | Consigue la diferencia de varios conjuntos. |
difference_update() | Eliminar los elementos de este conjunto que también están incluidos en otro conjunto especificado |
intersection()& | Obtener intersección de conjuntos |
intersection_update() | Eliminar los elementos de este conjunto que no están presentes en otros conjuntos especificados. |
isdisjoint() | Devuelve si dos conjuntos tienen una intersección |
issubset()<, <= | Comprobar si un conjunto es un subconjunto (estricto <) |
issuperset()>, >= | Comprobar si un conjunto es un superconjunto (estricto >) |
symmetric_difference()^ | Obtener diferencia simétrica de dos conjuntos |
symmetric_difference_update() | Insertar las diferencias simétricas de este conjunto y otro |
union()| | Obtener la unión de conjuntos. |
Algoritmos y complejidades
Esta sección trata sobre las clases de complejidad de varias estructuras de datos de Python.
Lista
Las tuplas tienen las mismas operaciones (no mutables) y complejidades.
COMANDO ( L: LISTA) | CLASE DE COMPLEJIDAD |
|---|---|
L.append(item) | O(1) |
L.clear() | O(1) |
item in/not in L | O(N) |
L.copy() | O(N) |
del L[i] | O(N) |
L.extend(…) | O(N) |
L1==L2, L1!=L2 | O(N) |
L[i] | O(1) |
for item in L: | O(N) |
len(L) | O(1) |
k*L | O(k*N) |
min(L), max(L) | O(N) |
L.pop(-1) | O(1) |
L.pop(item) | O(N) |
L.remove(…) | O(N) |
L.reverse() | O(N) |
L[x:y] | O(y-x) |
L.sort() | O(N*log(N)) |
L[i]=item | O(1) |
Diccionario
COMANDO ( D: DICCIONARIO) | CLASE/RANGO DE COMPLEJIDAD (—) |
|---|---|
d.clear() | O(1) |
dict(…) | O(len(d)) |
del d[k] | O(1) — O(N) |
d.get() | O(1) — O(N) |
for item in d: | O(N) |
len(d) | O(1) |
d.pop(item) | O(1) — O(N) |
d.popitem() | O(1) |
d.values() | O(1) |
d.keys() | O(1) |
d.fromkeys(seq) | O(len(seq)) |
Colocar
| OPERACIÓN | COMANDO ( S: ESTABLECER) | CLASE/RANGO DE COMPLEJIDAD (—) |
|---|---|---|
| Agregar | s.add(item) | O(1) — O(N) |
| Vacias | s.clear() | O(1) |
| Copiar | s.copy() | O(N) |
| Contención | item in/not in s | O(1) — O(N) |
| Creación | set(…) | O(len(s)) |
| Desechar | s.discard(item) | O(1) — O(N) |
| Diferencia | s1-s2 | O(len(s1)) |
| Actualización de diferencias | s1.difference_update(s2) | O(len(s2)) — ∞ |
| Igualdad | s1==s2, s1!=s2 | O(min(len(s1), len(s2))) |
| Intersección | s1&s2 | O(min(len(s1), len(s2))) |
| Iteración | for item in s: | O(N) |
| es subconjunto | s1<=s2 | O(len(s1)) |
| es superserie | s1>=s2 | O(len(s2)) — O(len(s1)) |
| Pop | s.pop() | O(1) — O(N) |
| Unión | s1|s2 | O(len(s1)+len(s2)) — ∞ |
| Diferencia simétrica | s1^s2 | O(len(s1)) — O(len(s1)*len(s2)) |
Tabla de símbolos
Python realiza un seguimiento de las variables mediante tablas de símbolos, que puede explorar utilizando los siguientes comandos básicos:
| DOMINIO | DESCRIPCIÓN |
|---|---|
__doc__ | Documentación del programa como comentarios ( #, """, ''') al principio del código. |
__name__ | Cómo se ejecuta el programa Python. Ejecución directa: __name__ == "__main__" |
dir() | Espacio de nombres efectivo |
global() | Diccionario de nombres de variables de alcance global a valores de variables. |
locals() | Diccionario de nombres de variables de alcance local a valores de variables. |
eval() | Devuelve el valor de la variable especificada. Ejemplo de uso: for x in dir(): print(x, eval(x)) |
Bibliotecas de Python
Los siguientes comandos sirven para configurar programas o bibliotecas de Python para usarlos dentro de su programa:
| DOMINIO | DESCRIPCIÓN |
|---|---|
import module1 | Importar programa/biblioteca module1 como módulo Python |
from module1 import obj1, obj2 | Importar los objetos obj1, obj2 from module1 |
from module1 import * | Importar todos los objetos en module1 |
module1.__dict__ | Devuelve el diccionario que contiene module1la tabla de símbolos, como dir() el del programa principal. |
Ejemplos de bibliotecas de Python que contienen otras estructuras de datos no primitivas:
- matriz : matrices eficientes de valores numéricos
- colecciones : estructuras de datos abstractas
- clases de datos : para crear estructuras de datos definidas por el usuario
- datetime : tipos básicos de fecha y hora
- cola : clase de cola sincronizada
Preguntas frecuentes
¿Cuáles son las estructuras de datos en Python?
Primitivo: cadena, entero, flotante, booleano.
No primitivo, integrado: lista, conjunto, tupla, diccionario.
La documentación de Python incluye otros adicionales .
¿Es tupla una estructura de datos?
Sí. Una tupla es una estructura de datos no primitiva en Python.
¿Python es bueno para DSA?
Sí. La sintaxis de Python es similar al pseudocódigo, lo que hace que el aprendizaje de estructuras y algoritmos de datos (DSA) sea intuitivo.
¿Cuántas estructuras de datos hay en Python?
Existen innumerables estructuras de datos en Python. Los usuarios también pueden definir estructuras de datos personalizadas.
Al dominar las estructuras de datos en Python, los profesionales de la ciberseguridad no solo optimizan la eficiencia de programación, sino que también aseguran un terreno más firme contra las crecientes amenazas en el ciberespacio.
Python Practicando. Desde 0 hasta Desarrollador en Python
Python es Hoy uno de los lenguajes más utilizados por Excelencia.
Esto se debe por su simpleza al momento de Desarrollar aplicaciones.
Por su capacidad de procesamiento a altas velocidades con grandes volúmenes de información.
Es un increíble lenguaje con el cual si no sabes programar, podrás aprender.
Y si ya sabes desarrollar, te aconsejo aprenderlo ya que en el mercado cada vez se solicitan más desarrolladores en Python.
Aspirar al trabajo que desean, o mejorar sus ingresos con un aumento de salario.
Python se utiliza para muchisimas cosas como:
- Machine Learning
- Data Science
- Inteligencia Artificial.
- Y mucho más!
En este curso te acompañare en el proceso por el cual aprenderás las bases del lenguaje, para luego determinar qué camino quieres seguir.
Te invito que me acompañes a conocer este Gran Lenguaje!
Yo soy Álvaro Chirou, tengo más de 20 Años de experiencia trabajando en Tecnología, eh dado disertaciones en eventos internacionales como OWASP, tengo más de 500.000 estudiantes en Udemy y 100 formaciones profesionales impartidas en la misma.
Y junto a mi compañero Walter Coto donde con él hemos dado formaciones profesionales en conjunto también en la plataforma de Udemy, hoy les traemos esta oportunidad de seguirse formando en el lenguaje mas demandado por el mercado.
Tendrás acceso de por vida al curso, recibirás actualizaciones y respuestas a tus preguntas a través de la plataforma de Udemy.
Empieza a aprender ya mismo!
Lo que aprenderás
- Ejercitar la lógica de programación
- Comprender cómo la vida cotidiana puede ser fácilitada o simulada con código
- Aprender programación desde cero
- Usar Visual Studio Code como Editor de Código
- Conocer y aprender el lenguaje de programación Python
- Ser un programador desde cero, sin conocimiento en otro lenguaje o con algo previo
- Mejorar las habilidades de programación, mejorar procesos y fácilitar la comprensión de código
- Preparar un entorno dónde programar en Python
- Operaciones aritméticas y jerarquía de Python
- Manejo de cadenas en Python
- Digitar datos por teclado con Python
- Mostrar Datos por Pantalla al usuario en Python
- Operadores Relacionales de Python
- Operadores Lógicos de Python
- Condicionales en Python
- Estructuras de Datos: Listas, Tuplas y Diccionarios
- Iteraciones y bucles repetitivos de Python
- Segmentar Código y hacerlo más eficaz con las Funciones en Python
- Gestionar posibles errores que puedan dar tus programas
- Programación Orientada a Objetos
- HTML y CSS
- Selenium Web Driver con Python
- Ejercitar todo lo Aprendido con Ejercicios
Aprende Python, donde iniciamos desde 0, sin conocimientos previos hasta desarrollar aplicaciones con mucha practica! https://achirou.com/python