Afirmaciones

Para un mejor manejo 😃

def primera_letra(lista_palabras):
    primeras_letras = []
    
    for palabra in lista_palabras:
        try:
            assert type(palabra) == str, f'{palabra} no es String'
            assert len(palabra) > 0 , 'No se permiten vacios'
            primeras_letras.append(palabra[0])
        except AssertionError as e:
            print(e)

    return primeras_letras


lista = ['Angelo',5.5, '', 2 , '43952353', 0.35]
print('Primeras letras validas son : ' , primera_letra(lista))

Afirmaciones
Las afirmaciones son un mecanismo en la que podemos determinar si una afirmación se cumple o no se cumple y poder seguir adelante con la ejecución de nuestro programa o darle término.

Las afirmaciones es un método de programación defensiva, esto significa que nos estamos preparando para verificar que los tipos de inputs de nuestro programa es del tipo que nosotros esperamos. Estos también nos sirven para debuggear.

Para realizar una afirmación en nuestro programa lo hacemos con la expresión assert <expresion booleana>, <mensaje de error>.

def primera_letra(lista_de_palabras):
    primeras_letras = []

    for palabra in lista_de_palabras:
        assert type(palabra) == str, f'{palabra} no es str'
        assert len(palabra) > 0, 'No se permiten str vacios'

        primeras_letras.append(palabra[0])

    return primeras_letras

https://www.programiz.com/python-programming/assert-statement

Este curso lo tomé a manera de reforzar conceptos de Python. Este concepto nunca lo he escichado y espro pronto poder aplicarlo. 😄

Afirmaciones

Es un mecanismo por el cuál podemos determinar si una función se cumple o no se cumple. Y poder seguir adelante con la ejecución de nuestro programa o terminar dicha ejecución.

• Programación defensiva
• Pueden utilizarse para verificar que los tipos sean correctos en una función.
• También sirven para debuguear.

Para generarlas tenemos que utlizar el keyword assert y dar una expresión boleana y un mensaje de error

def primera_letra(lista_palabras):
    primeras_letras = []
    
    for palabra in lista_palabras:
        try:
            assert type(palabra) == str, f'{palabra} no es String'
            assert len(palabra) > 0 , 'No se permiten vacios'
            primeras_letras.append(palabra[0])
        except AssertionError as e:
            print(e)

    return primeras_letras

No tenia conocimiento de la existencia de los assert, sin embargo hacia algo muy parecido cuando programaba PLC ya que tenia que hacer condiciones de seguridad que previnieran un error en la ejecución de la tarea.

Sobre programación defensiva encontré esta entrada que me pareció bien estructurada:

https://aslisach.in/2019/what-is-defensive-programming/

Que increíble clase, jamas sabia escuchado de los (assert) , pero creo que de ahora en adelante voy a utilizarlos muchos.
Por eso es que repito, que aun siendo un veterano en algo, es bueno ver como lo miran los principiantes para aprender cosas nueva.

Si la condicion del assert es falsa nos arroja un error y el programa se detiene si no lo capturamos con

try:
     <code conflictivo> 
except Exception:
     <codigo manejador> 

Si no lo detecta sigue con su vida. : )

WOW python es realmente increíble, bueno con los assert nunca lo he utilizado porque es mi primera vez que escribo en este lenguaje pero me parece fascinante todo lo que estoy aprendiendo de python.

Yo ya hacía esto pero desconocía assert, me ahorraste muchas lineas de código en el futuro 😄

Nunca escuche del keyword ‘assert’ ya que soy nuevo en la programación. pero es una forma muy interesante de ‘controlar’ nuestro código o programa

Ya casi te tengo Data Tree Gardener 😄

Me explicaron esto en el 2006, no lo llamaron programación defensiva era solamente estar atento a que el usuario no nos engañara mandando inputs extraños y buggeando el programa.

Hemos usado el sistema de afirmaciones pero por el lado de PHP a través del framework Laravel usando las validaciones en peticiones (requests) Http que llegan al backend.

https://laravel.com/docs/7.x/validation

Ejercicio resuelto aplicando afirmaciones

¿Podría decir que assert es equivalente a una validación?

La declaración de afirmación de Python es una ayuda de depuración, no un mecanismo para manejar errores de tiempo de ejecución. El objetivo de usar aserciones es permitir que los desarrolladores encuentren la causa raíz probable de un error más rápidamente.

No use antes los assert pero me parece una herramienta muy buena inclusive, como decía David, para enfrontar bugs!

Afirmaciones:

• Verificamos una condicion a partir de la cual decidimos si terminamos el programa o continuamos con la ejecucion
• Metodo de programacion defensiva
• Sirven para debuguear

Colocando en práctica en varios escenarios lo entendí mejor.

documentación de assert en Python https://docs.python.org/3/reference/simple_stmts.html#assert

En esta pagina puedes encontrar ejemplos con los que puedes interactuar sobre este tema.
https://www.w3schools.com/python/ref_keyword_assert.asp?msclkid=92071a35ac7611ec9bfb3a726660c3d0

Otras funcionalidades del assert son:

• Su uso en testing.
• Su uso en funciones (como el ejemplo que vimos).
• Su uso en clases.

Assert es equivalente a

if __debug__:
    if not condition:
        raise AssertionError(message)

Cuando se prepara el código para producción ya no existe. Ésa es la diferencia con raise
Lo leí aquí

Código que utilicé en Visual.

def primera_letra(lista_de_palabras):
    primeras_letras = []

    for palabra in lista_de_palabras:
        assert type(palabra) == str, f'{palabra} no es de tipo str'
        assert len(palabra) > 0, 'No se permiten str vacios'

        primeras_letras.append(palabra[0])

    return primeras_letras


lista = ['hola', 'que', 'hace']
palabras = list(primera_letra(lista))
print(palabras)```

Para convertir cada primera letra en mayuscula:

def primera_letra(lista_de_palabras):
    primeras_letras = []
    
    for palabra in lista_de_palabras:
        assert type(palabra) == str, f'{palabra} no es str'
        assert len(palabra) > 0, 'no se permiten srt vacios'
        
        primeras_letras.append(palabra[0].capitalize())
            
    return primeras_letras

Afirmaciones:
*Programación defensiva.
*Pueden utilizarse para verificar que los tipos sean correctos en una función.
*También sirven para debuguear.

ejemplo:
assert <expresión booleana>, <mensaje de error>

assert numero>0, “el número no es mayor que cero”
.
Si cumple la condición NO muestra nada.
Si NO cumple la condición muestra el mensaje.

Primera vez que escucha assert.

def primera_letra_enlista(lista_de_palabras):
    primeras_letras=[]

    for palabra in lista_de_palabras:
        assert type(palabra)==str, f'{palabra} no es str'
        assert len(palabra)>0, 'No se permiten str vacios'

        primeras_letras.append(palabra[0])

    return primeras_letras```

Nunca dejes de Aprender

Nunca había escuchado hablar de assert…pero excelente saber técnicamente para que se utiliza.

afirmaciones es programación defensiva poner trabas en los imputs

primera vez que escucho de ellos pero me parecen muy útiles para complementar lo que hemos aprendido!

# -*_ coding:utf-8 -*-

lista_palabras = []
lista_primeras_letras = []

for i in range(5):
    word=input('Escribi una palabra: ')
    lista_palabras.append(word)
    

for palabra in lista_palabras:
    assert type(palabra) == str, f'{palabra} no es str'
    assert len(palabra) > 0, 'No se permiten str vacios'

    lista_primeras_letras.append(palabra[0])

print(lista_palabras,lista_primeras_letras)

Una forma más sencilla que utilizar los “if”

Acá mi código de esta clases!

def primera_letra(lista_de_palabras):
    primeras_letras = []
    
    for palabra in lista_de_palabras:
        assert type(palabra) == str, f'{palabra} no es str'
        assert len(palabra) > 0, 'no se permiten srt vacios'
        
        primeras_letras.append(palabra[0])
            
    return primeras_letras

if __name__ == '__main__':
    hola = 'hola'
    lista_de_palabras = [hola]
    
    print(primera_letra(lista_de_palabras))

Tercera prueba: ingresando una lista con palabras adecuadas a las condiciones.

Para que funcionara correctamente se adiciono un try: except.

def es_String(lista_palabras):
    primeras_letras = []
    
    for palabra in lista_palabras:
        try:
            assert type(palabra) == str, f'{palabra} no es un string.'
            assert len(palabra) > 0, 'No se permiten string vacios.'
            
            primeras_letras.append(palabra[0])
        
        except AssertionError as e:
            print(e)
    
    return primeras_letras

lista = [1, 'Colombia', '', '986549', 986549, 'Pais']

print(es_String(lista))

para no interrumpir el flujo de ejecución y un mejor manejo.

Los asserts en Python son declaraciones que se utilizan para verificar suposiciones en el código. Sirven para verificar que una determinada condición sea verdadera y, de lo contrario, lanzarán una excepción AssertionError si la condición es falsa. Los asserts se utilizan principalmente para realizar pruebas y depuración en el código.

La sintaxis básica de un assert en Python es la siguiente:

assert condición, mensaje_de_error

La condición es una expresión que se evalúa como verdadera o falsa. Si la condición es falsa, se lanza una excepción AssertionError y se muestra el mensaje de error opcional que se proporciona. Si la condición es verdadera, el programa continúa su ejecución normalmente.

Los asserts son útiles durante el desarrollo de software para detectar errores y verificar suposiciones en el código. Pueden ayudar a identificar rápidamente problemas y asegurarse de que el programa se está ejecutando como se espera. Los asserts también pueden servir como documentación dentro del código, al indicar suposiciones importantes sobre el estado o el comportamiento de un programa en puntos clave.

30. Afirmaciones

• Programación defensiva
• Pueden utilizarse para verificar que los tipos sean correctos en una función
• También sirven para debuguear

# assert <expresion booleana>, <mensaje de error>

def primera_letra(lista_de_palabras):
    primeras_letras = []

    for palabra in lista_de_palabras:
        assert type(palabra) == str, f'{palabra} no es str'
        assert len(palabra) > 0, 'No se permiten str vacios'

        primeras_letras.append(palabra[0])

    return primeras_letras

Afirmaciones (assert)

Una palabra clave para confirmar la veracidad de una declaración dada que se utiliza a menudo para facilitar el desarrollo, documentar código y depurar.

Sintaxis

 assert alguna_condicion, assert_mensaje

La palabra clave assert va seguida de alguna_condicion a comprobar, como la validación de un tipo de datos o la pertenencia a un contenedor determinado. Se puede añadir un mensaje assert_mensaje opcional que se imprimirá cuando se produzca el error de aserción (AssertionError).

color_favorito = 'azul'

assert color_favorito == 'rojo'
#Salida: AssertionError

Ejemplo Codebyte

El siguiente ejemplo utiliza assert para evaluar si ‘barro’ está dentro de la siguiente lista cosas_que_flotan:

cosas_que_flotan = ['pan', 'manzanas', 'rocas']

assert 'barro' in cosas_que_flotan, "Esta cadena no está presente en la lista"	


#Mensaje de consola
Traceback (most recent call last):
File "main.py", line 3, in <module>
assert 'barro' in cosas_que_flotan, "La cadena no está presente en la lista"
AssertionError: La cadena no está presente en la lista

Importante

Esto lo tome de la pagina de codecademy, traduje lo que está en inglés. Si hay algun erro en el código pido disculpas. Estoy aprendiendo a programar, este es un pequeño aporte. Si hay alguna corrección, háganmelo saber así modifico el comentario.

Fuente: [](url https://www.codecademy.com/resources/docs/python/assert)

Saludos y Nunca pares de aprender! 🤓

Afirmaciones en Python

Las afirmaciones o asserts en Python son una forma de asegurarse de que ciertas condiciones sean verdaderas en el código en tiempo de ejecución. Básicamente, es una manera de verificar que algo es cierto y si no lo es, se lanza una excepción AssertionError.
.
En Python, una afirmación se escribe utilizando la palabra clave assert, seguida de una expresión booleana. Si la expresión es verdadera, no sucede nada y el programa continúa normalmente. Si la expresión es falsa, se lanza una excepción AssertionError con un mensaje opcional.

#Afirmaciones en Python

def primera_letra(lista_palabras):
    '''
    Retorna la primera letra de cada string en una lista.

    Args:
    lista_palabras (list): Lista de palabras.

    Returns:
    primeras_letras (list): Lista de las primeras letras en cada string de la lista_palabras.
    '''
    primeras_letras = []

    for palabra in lista_palabras:
        try:
            # Verifica que palabra sea un string
            assert type(palabra) == str, f'{palabra} no es String'
            # Verifica que el string no esté vacío
            assert len(palabra) > 0, 'No se permiten String vacios'
            # Agrega la primera letra a primeras_letras
            primeras_letras.append(palabra[0])
        except AssertionError as e:
            # Si falla la afirmación, imprimir mensaje de error
            print(e)
    
    return primeras_letras

lista = ['Angelo', 5.5, '', 2, '45648721', 0.35, False]
print(f'Primeras letras validas son: {primera_letra(lista)}'

assert <expresión booleana>, <mensaje de error>

afirmaciones- mecanismo para verificar si una condición se cumple o no se cumple, y seguir adelante con la ejecución, o no.

Método de programación defensiva- ver si los inputs de las funciones, lo hace de manera correcta. Los resultados dependen de que los inputs sean correctos.

Afrimaciones sirven para debuggear.

Afirmaciones

• Programación defensiva
• Pueden utilizarse para verificar que los tipos
  sean correctos en una función
• También sirven para debuguear

def primera_letra(lista_de_palabras):
    primeras_letras=[]

    for palabra in lista_de_palabras:

        assert type(palabra) == str, f'{palabra} no es str'
        assert len(palabra) > 0, 'No se permiten str vacios'

        primeras_letras.append(palabra[0])
    return primeras_letras

lista_de_palabras=['Santiago', 'Victor']
print(primera_letra(lista_de_palabras))

Manejo de excepciones para nuestra funcion de calculo de numeros factoriales:

def factorial(numbers):
    '''
    Descripcion funcion:
    Esta funcion es para calcular numeros factoriales con python.
    
    numbers es la variable que va a indicar el usuario con su imput
    
    si numbers > 0 esta funcion aplica recursividad para calcular su factorial
    
    se puede cambiar el limite de recursividad de 1000 a otro con:
    import sys
    sys.setrecursionlimit(2000)
    '''
    print(numbers)
    if numbers == 0:
        print('Factorial de 0 es un producto vacío y por convención es: ')
        return 0
    elif numbers == 1:
        return 1
    elif numbers > 999:
        return print('La recursividad en python es valida hasta 1000, esto nos limita.')
    elif numbers > 1:
        return numbers * factorial(numbers-1)
    else:
        return print('Indique solo numeros positivos, vuelva a correr el programa.')
    
if __name__ == '__main__':
    # unittest.main(argv=['ignored', '-v'], exit=False) 
    # res = unittest.main(argv=[''], verbosity=3, exit=False)
    try:
        print(factorial(int(input('Indica un numero para calcular su factorial: '))))
    except ValueError as e:
        print(f'''Tienes un error del tipo:
"{e}"
Ingresa un valor numerico del tipo entero para poder calcular su factorial
''')  

En la siguiente pagina pueden encontrar ejemplos, ejercicios y más información sobre este tema:
https://www.w3schools.com/python/ref_keyword_assert.asp

Aquí les muestro el código para manejo de asserts con el ejemplo del profesor:

def primera_letra(lista_de_palabras):
    primeras_letras = []

    for palabra in lista_de_palabras:
        try:
            assert type(palabra) == str, f'{palabra} no es str' 
            assert len(palabra) > 0, 'No se permiten str vacios'

            primeras_letras.append(palabra[0])
            
        except AssertionError as e:
            print(e)

    return primeras_letras


def run():

    lista = []
    for i in range(5):
        lista.append(input('Escribe las palabras: '))

    otra_lista = primera_letra(lista)
    print(otra_lista)


if __name__ == '__main__':
    run()

assert

se explica un poco sobre esta keyword

Creo que este es como el throw de otros lenguajes de programación porque genera una excepción tipo AssertionError

Hice que el algoritmo devolviera una letra

Un concepto nuevo:Afirmaciones
Recien estoy adentrandole a python y me parece un concepto nuevo, lo seguire estudiando y ver que ventajas tiene.

No conocía nada acerca de los asserts, muy interesante.

Les comparto mis apuntes de esta clase
Notas

Para realizar una afirmación en nuestro programa lo hacemos con la expresión assert <expresion booleana>, <mensaje de error>.

Las afirmaciones es un método de programación defensiva, esto significa que nos estamos preparando para verificar que los tipos de inputs de nuestro programa es del tipo que nosotros esperamos.

Las afirmaciones son un mecanismo en la que podemos determinar si una afirmación se cumple o no se cumple y poder seguir adelante con la ejecución de nuestro programa o darle término.

En mi caso no los conocía yo para esto usaba if statements y me parece muy bueno conocerlos y saber sobre el tema, serán muy útiles para usarlos dentro de nuestros programas en Python

La verdad nunca escuche sobre los asserts, me parece una forma mucho más eficiente de programar que tratar de evitar los errores con if y elif’s.

Practicamente es un operador ternario, en conjuncion con un raise de python https://es.wikipedia.org/wiki/Operador_ternario#:~:text=En informática un operador ternario,%2C C%2C C%23 o Java.

Me costó trabajo entender cómo funciona pero creo que ya

def primera_letra(lista_de_palabras):
    primeras_letras = []

    for palabra in lista_de_palabras:
        try:
            assert type(palabra) == str, f'{palabra}: no es un string'
            assert len(palabra) > 0, 'No se permiten strings vacios'
            primeras_letras.append(palabra[0])
        except AssertionError as e:
            print(e)

    return primeras_letras

mi_lista = ['oso', 2, 'Carlos', 'arena', True, 5332, 'Youtube', '', 'cinco', 5,'pelusa', False]

print(f'Los caracteres correspondientes de la posición solicitada son: ', primera_letra(mi_lista))


2: no es un string
True: no es un string
5332: no es un string
No se permiten strings vacios
5: no es un string
False: no es un string
Los caracteres correspondientes de la posición solicitada son:  ['o', 'C', 'a', 'Y', 'c', 'p']

Me ha costado un poco entender las afirmaciónes. Aquí un enlace que me permite entenderlas: https://ellibrodepython.com/assert-python

Concepto

‎ ‏‏‎
Las afirmaciones son un mecanismo en la que podemos determinar si una afirmación se cumple o no se cumple y poder seguir adelante con la ejecución de nuestro programa o terminar dicha ejecución. Es además un método que nos asegura una programación defensiva, es decir, mediante este estilo nos podemos preparar por inesperados objetos que puedan ser una fuente de bugs para nuestro programa. Como por ejemplo, sí realizamos un programa que su lógica funcione en base a enteros, y un usuario ingresara un objeto != a enteros, nuestro programa tendría errores o aún peor, bugs. Sin embargo, un punto principal a tener en cuenta es que este método también sirve para debuggear, cosa similar con lo que haríamos manualmente con el print() statement.
‎ ‏‏‎

Afirmaciones en el código

‎ ‏‏‎
La forma de generar afirmaciones es mediante el uso de keyword assert, con esta palabra reservada podemos formar estructuras similares al if. Veamos como utilizarlos en el siguiente código:

Si el assert funciona, se ejecutará la expresión; de lo contrario el flujo de nuestro programa seguirá corriendo normalmente.

Dejo un ejemplo de asserts que se vio en el curso intermedio de python 😄

La forma mas común de usar try except que he visto hasta ahora es par Validación de datos

Les dejo un ejemplo en combinación con el ciclo while true:
👌🏻

def lee_entero():
   while True: # MIENTRAS NO HAYA RETURN SE REPETIRA EL CICLO
       entrada = input("Escribe un numero entero: ")
       try:
           entrada = int(entrada)
           return entrada
       except ValueError:
           print ("La entrada es incorrecta: escribe un numero entero")

lee_entero()

Me pueden decir si la especificación de la función está bien hecha? Graciaaas

def primera_letra(lista_palabras):
    """ Te devuelve una lista con la primera letra de lista_palabras

    param list lista_palabras una lista de Strings
    returns lista de las primera letra de cada elemento de lista_palabras
    """

Yo no había escuchado nunca de los asserts. En mi experiencia en sitios web dónde necesitas registrar tus datos, no son muy utilizados, a veces es posible poder colocar datos incorrectos como <espacios> o <puntos> .

No había escuchado antes los assert, si los hubiese conocido antes, tal vez no me hubiese sentido tan frustrado pero de igual forma son un poco difíciles de digerir.

# assert <expresion boolean>, <mensaje error>

def primera_letra(lista_de_palabras):
    primeras_letras = []


    for palabra in lista_de_palabras:
        try:
                
            assert type(palabra) == str, f'{palabra} no es str'
            assert type(palabra) != bool, f'{palabra} es un boleano y los bueleanos no son permitidos' 
            assert len(palabra) > 0, 'No se permiten str vacíos'

            primeras_letras.append(palabra[0])
        
        except AssertionError as e:
            print(e)

    return primeras_letras    


lista = ['prueba', 2365, '"$ghs', '26762', True]    
print('Primeras letras válidas son: ', primera_letra(lista))

Assert FlowChart

Articulo completo aquí

Normalmente trato de evitar las excepciones en todo nivel. Siempre uso un return (o pass) cuando no se cumple una condicion.

Lanzar una excepcion tiene bastantes implicaciones en bajo nivel (normalmente trabajo Java o C++, asumo que es extensible a Python)

Notas

#Afirmaciones

#Si una condicion es falsa, un error sera disparado al usuario.

#Ejemplo:

#assert <expresion booleana>, <mensaje de error>

def primera_letra(lista_de_palabras):
    primeras_letras = []
    
    for palabra in lista_de_palabras:
        assert type(palabra) == str, f'{palabra} nno es str'
        assert len(palabra) > 0, 'No se permiten str vacios'
        
        primeras_letras.append(palabra[0])
        
    return primeras_letras

lista = ['hello', '', 'pedro']
primera_letra(lista)

Reto

def divide(n, d):
    assert d != 0, 'Al dividir por cero nuestro resultado es indeterminado'
    
    return n / d


numerador = 5
denominador = 0

resultado = divide(numerador, denominador)
print(resultado)

Nunca escuche sobre el “Assert”, muy informativo profe.

Muy interesante, nunca vi algo relacionado con ‘assert´, en cada tema me siento más atraído hacia Python.

Si tenemos dos assert statements estamos tratando el objeto dos veces?
Si tenemos 1000 assert estamos tratando el mismo objeto 1000 veces?
Como afecta esto al tiempo de ejecucion del codigo?

Hice uno con numeros, pero la idea es la misma

def numeros(lista_numeros):
    primeros_numeros = []

    for numeros in lista_numeros:
        try:
            assert type(numeros) == int, f'"{numeros}" no es un entero'
            primeros_numeros.append(numeros)
        except AssertionError as e:
            print(e)

    return primeros_numeros


lista_numeros = ["hola", 54458, 874512148, 87821, 5.4, "Mexico", 8.78, 95248, "Palabras"]
print('Numeros validos: ', numeros(lista_numeros))```

Buenas, programando con unittest me ha pasado algo muy curioso. Me gustaria saber si es posible el guardar en una variable la ejecucion de un assert de la siguiente manera.

• Las afirmaciones es un método de programación de programación defensiva.
• Pueden usarse para verificar que los tipos de datos sean correctos.
• También pueden usarse para realizar debug.

assert condicion, mensaje

Con estos métodos, manejas mejor el comportamiento del programa, para evitar posibles errores y bugs.

Muy interesantes pues nunca había escuchado de los asserts pero me parece que estas sentencias pueden ser muy útiles.

No conocía el concepto de afirmaciones, pero me ha gustado mucho su utilidad.

Es muy parecido o igual al operador condicional ternario en JavaScript.

expresion ? true_value : false_value;

nunca habia escuchado de los assert… donde se encuentra la documentación??

Solo habia esuchado de los try
esta cool

Es muy buen tema, en trabajos que he realizado en Python eh tenido que lidiar con lecturas del puerto Serial sin saber como manejar la entrada de datos que no esperaba, pero con esto ya puedo hacerlo sin probelmas.

Ni idea de los assert tenía

Las afirmaciones son declaraciones que afirman o declaran un hecho con confianza en su programa. Por ejemplo, mientras escribe una función de división, está seguro de que el divisor no debería ser cero, afirma que el divisor no es igual a cero.

Las afirmaciones son simplemente expresiones booleanas que verifican si las condiciones devuelven verdadero o no. Si es cierto, el programa no hace nada y pasa a la siguiente línea de código. Sin embargo, si es falso, el programa se detiene y arroja un error.

Existe algo similar en JS?

Interesante forma de adelantarte de los errores

Este tema es nuevo para mi; pero se ve muy útil para cubrirnos.Muy Buen Curso David.

[1:43] Para implementarlas debemos usar el keyword assert, dar una condición boobleana (que evalue verdadeo o falso) y un mensaje de error a devolver si la asersion no funciona, si la asercion funciona el programa seguira funcionando.

Afirmaciones: es un mecanismo mediante el cual podemos determinar si una condición se cumple o no se cumple y poder seguir adelante o terminar dicha instrucción. Es un método de programación defensiva.