Operadores en Python para Ingenieros de Redes: Guia de Estudio (7)

• El tipo de dato Booleano (Bullion) en Python: Fue añadido para simplificar la evaluación de condiciones como verdaderas o falsas.
• Subclase de la clase integer: La clase Booleana es una subclase de la clase integer, lo que permite realizar operaciones matemáticas con valores booleanos.
• La función bool(): Esta función evalúa si un valor dado es verdadero o falso.
  • Funcionamiento: Al pasar un valor a la función bool(), esta determinará si el valor se considera True o False.
  • Valores True y False: La función bool() retornará uno de estos dos valores.
• Todo en Python es un objeto: Todos los objetos en Python pueden ser evaluados como True o False.
• Comparaciones en Python:
  • Se utiliza == para comparar valores, no un solo =.
  • El operador = se usa para la asignación de objetos.
• Ejemplos de la función bool():
  • bool(1 + 1 == 2) retorna True.
  • bool(2 + 2 == 5) retorna False.
• El valor None:
• Es un valor especial en Python que siempre se evalúa como False.
• Es útil para pruebas de condiciones donde se necesita un valor que sea consistentemente falso.
• Importante: La palabra clave None debe escribirse con la primera letra en mayúscula.

• Evaluación de cadenas y listas:
• Una cadena como John se evalúa como True.
• Una lista con elementos, como [15, "VLAN"], también se evalúa como True.
• Una lista vacía, o el valor "nada", se evalúa como False.

• Reglas de evaluación: Python sigue reglas específicas para determinar si los valores son True o False. Estas reglas son específicas para cada tipo de dato.

• Evaluación de Cadenas como Booleanos:

  • En Python, las cadenas pueden ser evaluadas como valores booleanos (verdadero o falso).
  • Generalmente, todas las cadenas se evalúan como True, a menos que sean una cadena vacía.

• Cadenas No Vacías:

  • Cualquier cadena que contenga al menos un carácter, como "John", "access list", "F", "5", "VLAN", o "abracadabra" se evaluará como True.
  • Esto significa que la mayoría de las cadenas que encuentres en tu código se considerarán verdaderas cuando se utilicen en contextos que requieran un valor booleano.

• Cadenas Vacías:

  • Una cadena vacía ( "" ), es la única excepción y se evalúa como False.
  • Esto es fundamental para entender cómo Python interpreta las cadenas en condiciones o evaluaciones booleanas.

• Ejemplos:

• Si defines una variable access_list1 = "access list" y la pasas a una función que evalúa valores booleanos, retornará True.
• Si defines una variable test_string = "" (una cadena vacía), la evaluación de esta variable retornará False.

• Reglas Clave:

• La regla principal es que cualquier cadena con contenido se evalúa como True.
• Solo las cadenas vacías se evalúan como False.
• Listas No Vacías:
• Una lista que contiene al menos un elemento, independientemente del tipo de dato de los elementos (cadenas, enteros, otros tipos), se evaluará como True.
• Ejemplos de listas que se evalúan como True: ['VLAN 5', 'VLAN 10', 'VLAN 15'], ['VLAN 20', 45, 5, 'VLAN 99'], ['', '', ''].
• Es importante notar que incluso una lista que contiene cadenas vacías se evalúa como True porque la lista en sí no está vacía.

• Lo que importa es si la lista tiene elementos, no el contenido de esos elementos.

• Listas Vacías:
• Una lista vacía ( [] ) es la única condición en la que una lista se evalúa como False.
• Este comportamiento es similar al de las cadenas vacías.


• Valores Booleanos de Otros Tipos de Datos:
• Números no cero (enteros y flotantes) se evalúan como True
• El valor 0 (cero) y 0.0 (cero punto cero) se evalúan como False
• Estos valores también pueden ser incluidos en listas, pero no afectan la evaluación de la lista en sí misma; una lista con estos valores se evalúa como verdadera si la lista no está vacía.
• Por ejemplo, una lista como [0, 0.0] se evaluará como True

El método append se utiliza para añadir un elemento al final de una lista. Este método es muy útil para construir listas dinámicamente, añadiendo elementos uno a uno durante la ejecución del código.

Ejemplo de uso de append:

.

Vemos ahora cómo Python evalúa tuplas, diccionarios y conjuntos en contextos booleanos, similar a cómo lo hace con listas. Estos conceptos son importantes en la automatización de redes para escribir código más eficiente y legible [conversación].

Evaluación de Veracidad/Falsedad

En Python, los tipos de datos pueden ser evaluados como True o False basándose en si contienen o no elementos.

• Tuplas
  • Una tupla no vacía es evaluada como True.

    mi_tupla = ("VLAN 1", "VLAN 2")
    print(bool(mi_tupla))  # Output: True
    

  • Una tupla vacía es evaluada como False.

    mi_tupla_vacia = ()
    print(bool(mi_tupla_vacia))  # Output: False
    

• Diccionarios
  • Un diccionario no vacío es evaluado como True.

    mi_diccionario = {"version": "15.6", "obtain": 200, "platform": "Cisco_iOS"}
    print(bool(mi_diccionario))  # Output: True
    

  • Un diccionario vacío es evaluado como False.

    mi_diccionario_vacio = {}
    print(bool(mi_diccionario_vacio))  # Output: False
    

  • Un diccionario con claves y valores vacíos (ej. cadenas vacías) se considera no vacío y se evalúa como True.

    mi_diccionario_con_vacios = {"key": "", "value": ""}
    print(bool(mi_diccionario_con_vacios)) # Output: True
    

• Conjuntos (Sets)
  • Un conjunto no vacío se evalúa como True.

    mi_set = {1, 2, 5, 7}
    print(bool(mi_set))  # Output: True
    

  • Un conjunto vacío se evalúa como False. Para inicializar un conjunto vacío, se debe usar set() en lugar de {}, ya que las llaves se utilizan para crear diccionarios.

    mi_set_vacio = set()
    print(bool(mi_set_vacio))  # Output: False

• Lógica del Operador and
• El operador and evalúa múltiples condiciones y devuelve True solo si todas las condiciones son verdaderas.
• Si alguna de las condiciones es False, el operador and devuelve False.
• Esta lógica se puede entender mejor con una analogía binaria:
• 1 representa True
• 0 representa False

1 and 1 resulta en 1 (True).

1 and 0 resulta en 0 (False).

0 and 0 resulta en 0 (False).

Strings:
Un string no vacío se evalúa como True. 

mi_string1 = "John" 

mi_string2 = "" 

print(bool(mi_string1)) # Output: True 

print(bool(mi_string2)) # Output: False

Cuando se usa el operador and, si una variable es False, la evaluación resulta en False. 

print(mi_string1 and mi_string2) # Output: False

Múltiples Condiciones: 

El operador and no se limita a dos condiciones, puede evaluar múltiples condiciones. 

nombre1 = "John" 

nombre2 = "Dave" 

nombre3 = "Michelle" 

nombre4 = "Ryan"

print(nombre1 and nombre2 and nombre3 and nombre4) # Output: True

Si cambiamos una variable a un valor vacío, la evaluación completa resulta en False: 

nombre1 = "John" 

nombre2 = "" 

nombre3 = "Michelle" 

nombre4 = "Ryan" 

print(nombre1 and nombre2 and nombre3 and nombre4) # Output: False

Listas: Una lista vacía se evalúa como False. 

mi_nombre = "John" 

mi_apellido = "Rambo" 

mi_lista = [] 

print(mi_nombre and mi_apellido and mi_lista) # Output: False

Ejemplos Prácticos con and

Verificación de Versión y Plataforma: 

Se pueden combinar múltiples condiciones para verificar que un dispositivo cumpla con ciertos criterios antes de ejecutar una acción. 

Condición de No-Ejecución: Si cualquiera de las condiciones evaluadas con and es False, el bloque de código condicional no se ejecuta. 

Uso en Automatización: El operador and es fundamental para asegurar que todas las condiciones necesarias se cumplen antes de realizar una acción, como recargar un dispositivo o actualizar una política.

Consideraciones Adicionales

El operador and evalúa las expresiones de izquierda a derecha, deteniéndose tan pronto como encuentra una condición False.
Se pueden combinar diferentes tipos de datos en las evaluaciones con el operador and.
Es crucial entender la evaluación booleana de los distintos tipos de datos para utilizar el operador and de manera efectiva.
El operador and se puede usar para validar que todos los valores requeridos son True, antes de ejecutar una acción especifica.
Conclusión


El operador and es una herramienta poderosa en Python para la toma de decisiones lógicas, especialmente útil en la automatización de redes. Permite verificar que todas las condiciones necesarias se cumplen antes de ejecutar una acción. Al comprender su funcionamiento y aplicarlo correctamente, se pueden escribir scripts más robustos y fiables.

Ejemplos practicos con NOT:

• El operador NOT invierte la veracidad o falsedad de un valor. Si un valor es verdadero, el operador NOT lo cambiará a falso, y viceversa.

• Ejemplo en Python:

• Si name = "John" entonces bool(name) es verdadero.
• not name invertirá ese valor a falso.
• Si my_list = [] (una lista vacía) entonces bool(my_list) es falso.
• not my_list invertirá ese valor a verdadero.

• Uso del operador NOT en código Python:

  • El operador NOT puede hacer que el código sea más corto y conciso.
  • Es útil en pruebas de condiciones en automatización de redes.

• Ejemplo de uso con una lista de protocolos:

• Se crea una lista de protocolos: my_list_of_protocols = ["Rep", "EIGRP", "OSPF", "ISIS"].
• Se verifica si "BGP" está presente en la lista.
• Sin el operador NOT, la declaración ("BGP" in my_list_of_protocols) retorna False porque BGP no está en la lista.
• Al usar el operador NOT, not ("BGP" in my_list_of_protocols) retorna True.

• En este caso, se imprime el mensaje "no path vector protocols are present".

• Si se cambia la lista para incluir "BGP", la declaración ("BGP" in my_list_of_protocols) retorna True.
• Al usar el operador NOT, not ("BGP" in my_list_of_protocols) retorna False.
• En este caso, se imprime el mensaje "path vector detected".

• El operador NOT no es estrictamente necesario, pero puede hacer que el código sea más limpio y fácil de leer.

• Recomendación: Familiarizarse con el uso del operador NOT para escribir código Python más eficiente.