INGENIERIA EN SISTEMAS

DOCENTE: ROGERIO ORLANDO BELTRAN CASTRO

INTELIGENCIA ARTIFICIAL.

MANEJO DE GRAFOS CON PHYTON

INGENIERIA EN SISTEMAS

INTELIGENCIA ARTIFICIAL. GRAFOS EN PHYTON 1

 INGENIERIA EN SISTEMAS

DOCENTE: ROGERIO ORLANDO BELTRAN CASTRO

INDICE

INDICE ............................................................................................................................................................................... 2

LOS GRAFOS EN PYTHON 3 ......................................................................................................................................... 3

UN POCO DE TEORÍA DE GRAFOS ..................................................................................................................................... 3
SCRIPT DE GRAFO EN PYTHON 3, NO DIRIGIDO, PONDERADO .......................................................................................... 3
RECORRIDO DE UN GRAFO EN PROFUNDIDAD [PROGRAMA] EN PYTHON 3 ................................................ 6
PSEUDOCÓDIGO RECORRIDO DE UN GRAFO EN PROFUNDIDAD ....................................................................................... 6
ALGORITMO RECORRIDO GRAFO EN PROFUNDIDAD ...................................................................................................... 7
RECORRIDO DE UN GRAFO EN ANCHURA [PROGRAMA] EN PYTHON 3 ......................................................... 9
ALGORITMO RECORRIDO GRAFO EN ANCHURA ........................................................................................................... 10

INTELIGENCIA ARTIFICIAL. GRAFOS EN PHYTON 2

 INGENIERIA EN SISTEMAS

DOCENTE: ROGERIO ORLANDO BELTRAN CASTRO

Los grafos en python 3

En esta ocasión les dejo el algortimo para implementar Grafos en Python, verán como se define y codifica
un grafo no dirigido y ponderado en Python 3 utilizando una de las estructuras de datos en Python
conocida como Diccionario

Un poco de teoría de Grafos

Los grafos tienen aplicaciones en campos tan diversos como sociología, química, geografía, ingeniería
eléctrica e industrial, etc. Los grafos se estudian como estructuras de datos o tipos abstractos de datos.
Tomado del libro: Joyanes Aguilar Luis, Estructuras de Datos en C++

En computación y matemáticas, un grafo es una representación gráfica de diferentes puntos conocidos

como nodos o vértices, los cuales se encuentran unidos a través de líneas que reciben el nombre de aristas.
Los Grafos no dirigidos se representan mediante Nodos o Vértices unidos por medio de Aristas que no
tienen una dirección específica de ida o vuelta. Un Grafo ponderado es un grafo que tiene un peso o
ponderación especificado en la arista que une a cualesquiera de los vértices o nodos.

Grafo no dirigido, ponderado

Script de Grafo en python 3, no dirigido,

ponderado
En el siguiente script, algoritmo o programa veremos de una manera práctica y lo más sencilla posible, la
creación de un grafo no dirigido y ponderado en python 3 en el cual se pueden agregar nodos (origen y
destino) con su respectivo peso o ponderación

#Autor: UTS
#Carrera: Ingeniería en Sistemas

import os

grafo = {}

opc = 0
while opc != 3:

INTELIGENCIA ARTIFICIAL. GRAFOS EN PHYTON 3

 INGENIERIA EN SISTEMAS

DOCENTE: ROGERIO ORLANDO BELTRAN CASTRO

os.system("cls")
print("\n\tGrafo Ponderado no Dirigido")
opc = input ("\n1.-Ingresar nodos \n2.-Mostrar grafo \n3.-Salir \nElige una opcion-> ")
opc = int(opc)

if opc == 1:
print("\nINGRESE LOS NODOS Y SU PESO \n")
origen = input("Ingresa el origen: ")
destino = input("Ingresa el destino: ")
peso = input("Ingresa el peso: ")
peso = int(peso)

###VERIFICA QUE NO ESTE REPETIDO EL VERTICE ORIGEN Y DESTINO INGRESADO

repetido = False
for orig, lista in grafo.items():
for destin, pesos in grafo[orig]:
if orig == origen and destin == destino and pesos == peso:
print("\nEL VERTICE YA EXISTE\n")
repetido = True
#SI NO ESTÁ REPETIDO INGRESA A VALIDAR SI LOS NODOS ORIGEN Y DESTINO EXISTEN
if repetido == False:
if origen in grafo:
if destino in grafo:
lista = grafo[origen]
grafo[origen] = lista + [(destino, peso)]
lista = grafo [destino]
lista.append((origen, peso))
grafo[destino] = lista
else:
grafo[destino] = [(origen, peso)]
lista = grafo [origen]
lista.append((destino, peso))
grafo[origen] = lista
elif destino in grafo:
grafo[origen] = [(destino, peso)]
lista = grafo [destino]
lista.append((origen, peso))
grafo[destino] = lista
else:
grafo[destino] = [(origen, peso)]
grafo[origen] = [(destino, peso)]
if opc == 2:
print()
INTELIGENCIA ARTIFICIAL. GRAFOS EN PHYTON 4
 INGENIERIA EN SISTEMAS

DOCENTE: ROGERIO ORLANDO BELTRAN CASTRO

#SI EL GRAFO TIENE NODOS LO MUESTRA

if len(grafo) > 0:
for key, lista in grafo.items():
print(key)
print(lista)
else:
print("El grafo esta vacio...")
print()
os.system("pause")

INTELIGENCIA ARTIFICIAL. GRAFOS EN PHYTON 5

 INGENIERIA EN SISTEMAS

DOCENTE: ROGERIO ORLANDO BELTRAN CASTRO

Recorrido de un Grafo en Profundidad [Programa] en

Python 3
En esta ocasión les dejo el pseudocódigo recorrido de un grafo en profundidad, este algoritmo de
recorrido en profundidad puede ser implementado en otros lenguajes como C++ o Java por nombrar
algunos, pero en esta oportunidad lo utilizaremos para recorrer un grafo en profundidad en Python 3

Grafo sobre el cual se aplicara el recorrido en Resultado del recorrido de un grafo en

profundidad profundidad del grafo ejemplo

Pseudocódigo Recorrido de un Grafo en

Profundidad
Creando o traduciendo los siguientes pasos a código, es posible recorrer un grafo en profundidad o lo que es
lo mismo, hacer una búsqueda en profundidad sobre un grafo

1. Se coloca el vértice origen en una pila

2. Crear un ciclo: Mientras la pila no esté vacía
3. Desapilar un vértice, este será ahora el vértice actual
4. Si el vértice actual no ha sido visitado
5. Procesar (imprimir) el vértice actual
6. Colocar vértice actual en la lista de visitados
7. Para cada vértice que el vértice actual tiene como destino, y que no ha sido visitado: apilar el vértice

INTELIGENCIA ARTIFICIAL. GRAFOS EN PHYTON 6

 INGENIERIA EN SISTEMAS

DOCENTE: ROGERIO ORLANDO BELTRAN CASTRO

Algoritmo Recorrido Grafo en

Profundidad
#AUTOR: UTS
#CARRERA: Ingeniería en Sistemas

import os

#DEFINIENDO EL GRAFO MEDIANTE UN DICCIONARIO DE PYTHON:

#PARA MEJOR COMPRENSION EL VALOR 'a': [('p',4), ('j',15), ('b',1)],
#INDICA QUE EL VERTICE 'a' ES ADYACENTE CON 'P', CON 'J' Y CON 'b'
#CADA UNO CON SU RESPECTIVO PESO, AUNQUE EL PESO PARA HACER RECCORRIDOS EN PROFUNDIDAD
#NO ES NECESARIO, SE LO AGREGUE PARA MOSTRAR TAMBIÉN LA IMPLEMENTACIÓN DE UN GRAFO PONDERADO

grafo = {'a': [('p',4), ('j',15), ('b',1)],

'b': [('a',1), ('d',2), ('e',2), ('c',3)],
'j': [('a',15)],
'p': [('a', 4)],
'd': [('b',2), ('g',3)],
'e': [('b',2), ('g',4), ('f',5), ('c',2)],
'c': [('b',3), ('e',2), ('f',5), ('i',20)],
'g': [('d',3), ('e',4), ('f',10), ('h',1)],
'f': [('g',10), ('e',5), ('c',5)],
'i': [('c',20)],
'h': [('g',1)]
}

#MUESTRA EL GRAFO ANTES DEL RECORRIDO

print("Muestra el grafo antes del recorrido: \n")
for key, lista in grafo.items():
print(key)
print(lista)

print()
os.system("pause")

visitados = []
pila = []

origen = input("Ingresa un nodo: ")

INTELIGENCIA ARTIFICIAL. GRAFOS EN PHYTON 7

 INGENIERIA EN SISTEMAS

DOCENTE: ROGERIO ORLANDO BELTRAN CASTRO

print("\nLista de recorrido en profundidad\n")

#Paso 1: SE COLOCA EL VÉRTICE ORIGEN EN UNA PILA
pila.append(origen)
#Paso 2: MIENTRAS LA PILA NO ESTE VACÍA
while pila:
#paso 3: DESAPILAR UN VÉRTICE, ESTE SERÁ AHORA EL VÉRTICE ACTUAL
actual = pila.pop()
#FORMA ALTERNATIVA PARA DESAPILAR:
#actual = pila[-1]
#pila.remove(pila[-1])

#paso 4: SI EL VÉRTICE ACTUAL NO HA SIDO VISITADO

if actual not in visitados:
#paso 5: PROCESAR (IMPRIMIR) EL VÉRTICE ACTUAL
print("Vertice actual -> ", actual)
#paso 6: COLOCAR VÉRTICE ACTUAL EN LA LISTA DE VISITADOS
visitados.append(actual)
#paso 7: PARA CADA VÉRTICE QUE EL VÉRTICE ACTUAL TIENE COMO DESTINO,
# Y QUE NO HA SIDO VISITADO:
# APILAR EL VERTICE
for key, lista in grafo[actual]:
if key not in visitados:
pila.append(key)

print()
os.system("pause")

INTELIGENCIA ARTIFICIAL. GRAFOS EN PHYTON 8

 INGENIERIA EN SISTEMAS

DOCENTE: ROGERIO ORLANDO BELTRAN CASTRO

Recorrido de un Grafo en Anchura [Programa] en

Python 3
En esta ocasión les dejo el pseudocódigo recorrido de un grafo en anchura, este algoritmo de recorrido
en anchura al igual que en el artículo en donde tratamos el recorrido de un grafo en profundidad, puede ser
implementado de la misma manera en lenguajes como C++ o Java, pero en esta oportunidad lo utilizaremos
para recorrer un grafo en anchura en Python 3
En otras palabras, lo único que cambia para recorrer un grafo en anchura es la utilización de una cola en
lugar de utilizar una pila que se utiliza para recorrerlo en profundidad.

Pseudocódigo Recorrido de un Grafo en

Anchura
Creando o traduciendo los siguientes pasos a código, es posible recorrer un grafo en anchura o lo que es
lo mismo, hacer una búsqueda en anchura sobre un grafo
1. Se coloca el vértice origen en una cola
2. Crear un ciclo: Mientras la cola no esté vacía
3. Desencolar un vértice, este será ahora el vértice actual
4. Si el vértice actual no ha sido visitado
5. Procesar (imprimir) el vértice actual
6. Colocar vértice actual en la lista de visitados
7. Para cada vértice que el vértice actual tiene como destino, y que no ha sido visitado: encolar el vértice

INTELIGENCIA ARTIFICIAL. GRAFOS EN PHYTON 9

 INGENIERIA EN SISTEMAS

DOCENTE: ROGERIO ORLANDO BELTRAN CASTRO

Algoritmo Recorrido Grafo en Anchura

#AUTOR: UTS
#CARRERA: Ingeniería en Sistemas

import os

#DEFINIENDO EL GRAFO MEDIANTE UN DICCIONARIO DE PYTHON:

#PARA MEJOR COMPRENSION EL VALOR 'a': [('p',4), ('j',15), ('b',1)],
#INDICA QUE EL VERTICE 'a' ES ADYACENTE CON 'P', CON 'J' Y CON 'b'
#CADA UNO CON SU RESPECTIVO PESO, AUNQUE EL PESO PARA HACER RECCORRIDOS EN PROFUNDIDAD
#NO ES NECESARIO, SE LO AGREGUE PARA MOSTRAR TAMBIÉN LA IMPLEMENTACIÓN DE UN GRAFO PONDERADO

grafo = {'a': [('p',4), ('j',15), ('b',1)],

'b': [('a',1), ('d',2), ('e',2), ('c',3)],
'j': [('a',15)],
'p': [('a', 4)],
'd': [('b',2), ('g',3)],
'e': [('b',2), ('g',4), ('f',5), ('c',2)],
'c': [('b',3), ('e',2), ('f',5), ('i',20)],
'g': [('d',3), ('e',4), ('f',10), ('h',1)],
'f': [('g',10), ('e',5), ('c',5)],
'i': [('c',20)],
'h': [('g',1)]
}

#MUESTRA EL GRAFO ANTES DEL RECORRIDO

print("Muestra el grafo antes del recorrido: \n")
for key, lista in grafo.items():
print(key)
print(lista)

print()
os.system("pause")

visitados = []
cola = []

origen = input("Ingresa el nodo origen: ")

print("\nLista de recorrido en anchura\n")
#Paso 1: SE COLOCA EL VÉRTICE ORIGEN EN UNA COLA
cola.append(origen)

INTELIGENCIA ARTIFICIAL. GRAFOS EN PHYTON 10

 INGENIERIA EN SISTEMAS

DOCENTE: ROGERIO ORLANDO BELTRAN CASTRO

#Paso 2: MIENTRAS LA COLA NO ESTE VACÍA

while cola:
#paso 3: DESENCOLAR UN VÉRTICE, ESTE SERÁ AHORA EL VÉRTICE ACTUAL
actual = cola.pop(0)

#paso 4: SI EL VÉRTICE ACTUAL NO HA SIDO VISITADO

if actual not in visitados:
#paso 5: PROCESAR (IMPRIMIR) EL VÉRTICE ACTUAL
print("Vertice actual -> ", actual)
#paso 6: COLOCAR VÉRTICE ACTUAL EN LA LISTA DE VISITADOS
visitados.append(actual)
#paso 7: PARA CADA VÉRTICE QUE EL VÉRTICE ACTUAL TIENE COMO DESTINO,
# Y QUE NO HA SIDO VISITADO:
# ENCOLAR EL VERTICE
for key, lista in grafo[actual]:
if key not in visitados:
cola.append(key)

print()
os.system("pause")

INTELIGENCIA ARTIFICIAL. GRAFOS EN PHYTON 11