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))

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

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

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. : )

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

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.

Ya casi te tengo Data Tree Gardener 😄

Ejercicio resuelto aplicando afirmaciones

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

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

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)```

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.

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

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

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”

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

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.

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

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

Otras funcionalidades del assert son:

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

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

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.

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

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 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.

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.

Aún no conocía assert pero creo que es lo que estaba buscando para mejorar unos mini-juegos y asegurarme que el usuario no ingrese valores incorrectos, por lo tanto no se genere error y salga del programa.

• 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.

[0:56] Los resultados que el programa nos puede dar dependera que reciba los tipos correctos.

Key Points to Remember
Assertions are the condition or boolean expression which are always supposed to be true in the code.
assert statement takes an expression and optional message.
assert statement is used to check types, values of argument and the output of the function.
assert statement is used as debugging tool as it halts the program at the point where an error occurs

Usos cuando se está optimizando código.

assert statements are great for helping you to refactor and optimize your code with greater confidence that you have preserved correctness

A refactoring or optimization is when you re-write an already-working block of code (say, a function) to make it more maintainable (for refactoring) or to improve performance (for optimization).
Say that you started with a function f(x) and refactored/optimized it to a new version f2(x). You want f(x) and f2(x) to behave identically on all inputs x (at least for those that satisfy pre-conditions).
You can add assert(f(x) == f2(x)) to your code in the appropriate places where f() was originally called (with the appropriate variables/values substituted for x, of course).
Now whenever your program executes and passes that assertion, you can have increased confidence that the two versions of the function behave identically.
It’s often difficult to convince yourself that two versions of a function work in identical ways just by manually inspecting the source code; this strategy defers the hard work to the runtime system! All you need to do is to run your program in some realistic ways to try to exercise that assertion.
Of course, you won’t actually get the performance benefits with the assertion in place since the original (presumably slow) f() is still being called; however, for testing purposes, you should care much more about correctness than performance.
Once you are confident that f() and f2() behave identically on many values of x during normal program executions, you can comment out the assertion and exclusively use f2(x) everywhere rather than f(x), thus completing your refactoring.

as a recap for refactoring/optimizing with assertions:

    // original code snippet:
      y = f(x);

    // code while refactoring and testing:
      assert(f(x) == f2(x));
      y = f2(x);

    // code after refactoring completed:
      y = f2(x);

Alguna vez tuve un profesor que me decía “debemos crear software anti-bobos” (bobos = estupidos ó similar en Colombia). Porque siempre están aquellos que quieren ver “qué hace el programa si hacen esto o aquello”. Me encanta ese tipo de gente xd

La afirmación de afirmación existe en casi todos los lenguajes de progtwigción. Ayuda a detectar problemas al principio de su progtwig, donde la causa es clara, y no más tarde como un efecto secundario de alguna otra operación.

Cuando tu lo hagas…

assert condition
… le está diciendo al progtwig que pruebe esa condición, e inmediatamente active un error si la condición es falsa.

Antes de esta clase no sabia que existían los assserts 😅

Había oído de normalizar las funciones en otros lenguajes de programación, en este caso, el assert y los valores por default es una gran manera de blindar nuestras funciones.

Hola, tengo una duda, en vez de len(palabra) > 0 ¿no deberíamos poner len(palabra) == 0 ?

no habia escuchado sobre los assert, soy nuevo en python, pero este curso me ha dado la intro para poder sumirgirme mas en él.

No habia escuchado de los asserts

Realmente no habia escuchado de los assert

Programación defensiva: Asegurar que quien consuma el algoritmo, función , servicio cometa un error enviando datos mal.
Validar que las entradas son correctas y validas antes de computar.

un poco de juego con el codigo:

def palabras(lista_palabras):
primeras_letras = []

palabra = ' '

while palabra != 'salir':
    for palabra in lista_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_pa =[]
for i in range(5):
word = input('Escriba una palabra: ')
lista_pa.append(word)

print(lista_pa)

lista_nueva = palabras(lista_pa)
print(lista_nueva)

No entendí qué son los asserts, aiuda

Asegurarse de prevenir el error.

El assert es una instruccion de Python que te permite definir condiciones que deban cumplirse siempre. En caso que la expresion booleana sea True assert no hace nada y en caso de False dispara una excepcion.

assert 5 == 5 assert 6 < 2 Traceback (most recent call last): File "<stdin>", line 1, in ? AssertionError

Ni idea que existían los asserts.