Función Open de Python

Open abre un archivo. Bastante simple, ¿eh? La mayoría de las veces, vemos que se usa así:

f = open('photo.jpg', 'r+')

jpgdata = f.read()

f.close()

El valor de retorno de open es un identificador de archivo, dado desde el sistema operativo. 

Llamar explícitamente a close cierra el archivo, pero solo si la lectura fue exitosa. Si hay algún error justo después de f = open (...), no se llamará a f.close (). Para asegurarse de que el archivo se cierre ya sea que ocurra una excepción o no, podemos usar with:

with open('photo.jpg', 'r+') as f:

    jpgdata = f.read()

El primer argumento de abrir es el nombre del archivo. El segundo (el modo) determina cómo se abre el archivo.

Si desea leer el archivo, pase r

Si desea leer y escribir el archivo, pase r +

Si desea sobrescribir el archivo, pase w

Si desea agregar al archivo, pase a

El modo es importante no solo porque cambia el comportamiento, sino también porque puede resultar en errores de permisos. Por ejemplo, si abriéramos un archivo jpg en un directorio protegido contra escritura, abrir (.., 'r +') fallaría. El modo puede contener un carácter más; podemos abrir el archivo en binario (obtendrás una cadena de bytes) o en modo texto (una cadena de caracteres).

En general, si el formato está escrito por humanos, suele ser en modo texto. Los archivos de imagen jpg generalmente no están escritos por humanos (y de hecho no son legibles por humanos) y, por lo tanto, debe abrirlos en modo binario agregando ab a la cadena de modo (si está siguiendo el ejemplo de apertura, el modo correcto sería rb). Si abre algo en modo texto (es decir, agrega una t, o nada aparte de r / r + / w / a), también debe saber qué codificación usar. Para una computadora, todos los archivos son solo bytes, no caracteres.

Desafortunadamente, open no permite la especificación de codificación explícita en Python 2.x. Sin embargo, la función io.open está disponible tanto en Python 2.x y 3.x (donde es un alias de open) y hace lo correcto. Puede pasar la codificación con la palabra clave de codificación. Si no pasa ninguna codificación, se elegirá un sistema (y Python) predeterminado específico. Puede tener la tentación de confiar en estos valores predeterminados, pero los valores predeterminados a menudo son incorrectos o la codificación predeterminada no puede expresar todos los caracteres en el archivo (esto sucederá a menudo en Python 2.x y/o Windows). Así que adelante, elija una codificación. La codificación es la forma de instruir a las computadoras sobre cómo se deben almacenar los números como bytes en la memoria. utf-8 es excelente y es compatible con los principales navegadores y lenguajes de programación. Cuando escribe un archivo, puede elegir la codificación a su gusto (o al gusto del programa que eventualmente leerá su archivo).

¿Cómo averigua en qué codificación se escribió un archivo que está leyendo? Bueno, desafortunadamente, no existe una forma infalible de detectar la codificación: los mismos bytes pueden representar caracteres diferentes pero igualmente válidos en diferentes codificaciones. Por lo tanto, debe confiar en los metadatos (por ejemplo, en los encabezados HTTP) para conocer la codificación. Cada vez más, los formatos solo definen la codificación como UTF-8.

Armados con este conocimiento, escribamos un programa que lea un archivo, determine si es JPG (pista: estos archivos comienzan con los bytes FF D8) y escriba un archivo de texto que describa el archivo de entrada.

import io

with open('photo.jpg', 'rb') as inf:

    jpgdata = inf.read()

if jpgdata.startswith(b'\xff\xd8'):

    text = u'This is a JPEG file (%d bytes long)\n'

else:

    text = u'This is a random file (%d bytes long)\n'

with io.open('summary.txt', 'w', encoding='utf-8') as outf:

    outf.write(text % len(jpgdata))

Y listo!

Manejo de errores en Go vs Rust parte 3

Seguimos viendo el manejo de errores en Go y Rust.

En Go, Panic es una función incorporada que detiene el flujo ordinario de control y comienza a entrar en pánico. Cuando la función F llama a Panic, la ejecución de F se detiene, cualquier función diferida en F se ejecuta normalmente y luego F vuelve a su llamador. El proceso continúa en la pila hasta que todas las funciones de la goroutine actual han regresado, momento en el que el programa se bloquea. Los pánicos se pueden iniciar invocando el Panic directamente. También pueden deberse a errores en tiempo de ejecución.

Rust tambien tiene panic! pero en este caso en una macro, cuando panic! se ejecuta, el programa imprimirá un mensaje de error y limpiará la pila y luego se cerrará. Esto ocurre más comúnmente cuando se detecta un error de algún tipo y el programa no tiene claro cómo manejar el error.

Veamos un ejemplo para ver cómo es cuando se ejecuta panic!: 

fn main() {

    let v = vec![1, 2, 3];

    v[99];

}

Aquí, estamos intentando acceder al elemento en la posición 100 de nuestro vector (que está en el índice 99 porque la indexación comienza en cero), pero solo tiene 3 elementos. En esta situación, Rust entrará en pánico. Se supone que el uso de [] devuelve un elemento, pero si pasa un índice no válido, no hay ningún elemento que Rust pueda devolver aquí que sea correcto.

En C, intentar leer más allá del final de una estructura de datos es un comportamiento indefinido. Puede obtener lo que esté en la ubicación de la memoria que corresponda a ese elemento en la estructura de datos, aunque la memoria no pertenezca a esa estructura. Esto se denomina sobrelectura del búfer y puede generar vulnerabilidades de seguridad si un atacante es capaz de manipular el índice de tal manera que lea datos que no deberían tener permitido y que se almacenan después de la estructura de datos.

Para proteger el programa de este tipo de vulnerabilidad, si intenta leer un elemento en un índice que no existe, Rust detendrá la ejecución y se negará a continuar. Probémoslo y veamos:

$ cargo run

   Compiling panic v0.1.0 (file:///projects/panic)

    Finished dev [unoptimized + debuginfo] target(s) in 0.27s

     Running `target/debug/panic`

thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', /rustc/5e1a799842ba6ed4a57e91f7ab9435947482f7d8/src/libcore/slice/mod.rs:2806:10

note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.

Este error apunta a un archivo que no escribimos, libcore / slice / mod.rs. Esa es la implementación de slice en el código fuente de Rust. El código que se ejecuta cuando usamos [] en nuestro vector v está en libcore / slice / mod.rs, ¡y ahí es donde entra el pánico! 

La siguiente línea de nota nos dice que podemos configurar la variable de entorno RUST_BACKTRACE para obtener un seguimiento de lo que sucedió exactamente. Un backtrace es una lista de todas las funciones que se han llamado para llegar a este punto. Los backtraces en Rust funcionan como lo hacen en otros lenguajes: la clave para leer el backtrace es comenzar desde arriba y leer hasta que veas los archivos que escribiste. Ese es el lugar donde se originó el problema. Veamos un ejemplo : 

$ RUST_BACKTRACE=1 cargo run

thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', /rustc/5e1a799842ba6ed4a57e91f7ab9435947482f7d8/src/libcore/slice/mod.rs:2806:10

stack backtrace:

   0: backtrace::backtrace::libunwind::trace

             at /Users/runner/.cargo/registry/src/github.com-1ecc6299db9ec823/backtrace-0.3.40/src/backtrace/libunwind.rs:88

   1: backtrace::backtrace::trace_unsynchronized

             at /Users/runner/.cargo/registry/src/github.com-1ecc6299db9ec823/backtrace-0.3.40/src/backtrace/mod.rs:66

   2: std::sys_common::backtrace::_print_fmt

             at src/libstd/sys_common/backtrace.rs:84

   3: <std::sys_common::backtrace::_print::DisplayBacktrace as core::fmt::Display>::fmt

             at src/libstd/sys_common/backtrace.rs:61

   4: core::fmt::ArgumentV1::show_usize

   5: std::io::Write::write_fmt

             at src/libstd/io/mod.rs:1426

   6: std::sys_common::backtrace::_print

             at src/libstd/sys_common/backtrace.rs:65

   7: std::sys_common::backtrace::print

             at src/libstd/sys_common/backtrace.rs:50

   8: std::panicking::default_hook::{{closure}}

             at src/libstd/panicking.rs:193

   9: std::panicking::default_hook

             at src/libstd/panicking.rs:210

  10: std::panicking::rust_panic_with_hook

             at src/libstd/panicking.rs:471

  11: rust_begin_unwind

             at src/libstd/panicking.rs:375

  12: core::panicking::panic_fmt

             at src/libcore/panicking.rs:84

  13: core::panicking::panic_bounds_check

             at src/libcore/panicking.rs:62

  14: <usize as core::slice::SliceIndex<[T]>>::index

             at /rustc/5e1a799842ba6ed4a57e91f7ab9435947482f7d8/src/libcore/slice/mod.rs:2806

  15: core::slice::<impl core::ops::index::Index<I> for [T]>::index

             at /rustc/5e1a799842ba6ed4a57e91f7ab9435947482f7d8/src/libcore/slice/mod.rs:2657

  16: <alloc::vec::Vec<T> as core::ops::index::Index<I>>::index

             at /rustc/5e1a799842ba6ed4a57e91f7ab9435947482f7d8/src/liballoc/vec.rs:1871

  17: panic::main

             at src/main.rs:4

  18: std::rt::lang_start::{{closure}}

             at /rustc/5e1a799842ba6ed4a57e91f7ab9435947482f7d8/src/libstd/rt.rs:67

  19: std::rt::lang_start_internal::{{closure}}

             at src/libstd/rt.rs:52

  20: std::panicking::try::do_call

             at src/libstd/panicking.rs:292

  21: __rust_maybe_catch_panic

             at src/libpanic_unwind/lib.rs:78

  22: std::panicking::try

             at src/libstd/panicking.rs:270

  23: std::panic::catch_unwind

             at src/libstd/panic.rs:394

  24: std::rt::lang_start_internal

             at src/libstd/rt.rs:51

  25: std::rt::lang_start

             at /rustc/5e1a799842ba6ed4a57e91f7ab9435947482f7d8/src/libstd/rt.rs:67

  26: panic::main

En Go, Recover es una función incorporada que recupera el control de una goroutine en pánico. Recuperar solo es útil dentro de funciones diferidas. Durante la ejecución normal, una llamada para recuperar devolverá cero y no tendrá ningún otro efecto. Si la goroutine actual entra en pánico, una llamada para recuperar capturará el valor dado al pánico y reanudará la ejecución normal.

Aquí hay un programa de ejemplo que demuestra la mecánica del panic y el defer:

package main

import "fmt"

func main() {

    f()

    fmt.Println("Returned normally from f.")

}

func f() {

    defer func() {

        if r := recover(); r != nil {

            fmt.Println("Recovered in f", r)

        }

    }()

    fmt.Println("Calling g.")

    g(0)

    fmt.Println("Returned normally from g.")

}

func g(i int) {

    if i > 3 {

        fmt.Println("Panicking!")

        panic(fmt.Sprintf("%v", i))

    }

    defer fmt.Println("Defer in g", i)

    fmt.Println("Printing in g", i)

    g(i + 1)

}

La función g toma el int i, y entra en pánico si i es mayor que 3, o se llama a sí misma con el argumento i + 1. La función f difiere una función que llama a recuperar e imprime el valor recuperado (si no es nulo). Esto da como resultado: 

Calling g.

Printing in g 0

Printing in g 1

Printing in g 2

Printing in g 3

Panicking!

Defer in g 3

Defer in g 2

Defer in g 1

Defer in g 0

Recovered in f 4

Returned normally from f.

Si eliminamos la función diferida de f, el pánico no se recupera y alcanza la parte superior de la pila de llamadas de goroutine, terminando el programa. Este programa modificado generará:

Calling g.

Printing in g 0

Printing in g 1

Printing in g 2

Printing in g 3

Panicking!

Defer in g 3

Defer in g 2

Defer in g 1

Defer in g 0

panic: 4

panic PC=0x2a9cd8

[stack trace omitted]

La convención en las bibliotecas de Go es que incluso cuando un paquete usa panic internamente, su API externa aún presenta valores de retorno de error explícitos.

Deno 1.5 fue liberado

 

No puede ser que no haya hablado de deno en el blog. Como se me paso...

Bueno un pequeño resumen, el creador de nodejs se canso de c++ y otras cosas que tenia node y dijo yo empiezo otro proyecto de 0 y probo Go pero no le termino de convencer, así que se paso a Rust y se enamoro, hizo un node que bautizo deno, porque lo de él era ser original. En fin deno es muy superior a node en performance (gracias a Rust) y trae otras características. por ejemplo deno permite ejecutar typescipt nativo. 

El equipo detrás del tiempo de ejecución de Deno para JavaScript y TypeScript lanzó recientemente Deno 1.5. Deno 1.5 mejoró el tiempo de empaquetado mediante el uso del compilador swc de JavaScript / TypeScript basado en Rust. Deno reduce aún más el tamaño del paquete con la agitación de árboles e implementa las API de plataforma web de alerta, confirmación y solicitud. Esto último puede permitir a los desarrolladores escribir aplicaciones interactivas simples en la terminal.

El equipo de Deno refactorizó la infraestructura del compilador TypeScript de Deno para usar swc. Este último es un compilador y paquete de JavaScript / TypeScript escrito en Rust. Swc afirma ser 20 veces más rápido que el compilador de Babel en un solo hilo, y 70 veces más rápido en un punto de referencia de cuatro núcleos. Las notas de la versión de Deno 1.5 comentaron sobre el impacto de swc en el rendimiento de la compilación de Deno.

Las nuevas habilidades de los árboles se traducen en paquetes reducidos. La nota de lanzamiento dio un ejemplo de código fuente que vio una reducción de tamaño del 35% cuando se compiló con v1.5 en lugar de v1.4.

La nueva versión de Deno implementa las API de la plataforma web para alertar, confirmar y solicitar con una semántica similar a la del navegador. Por ejemplo, en el navegador, Window.prompt muestra un cuadro de diálogo con un mensaje opcional que solicita al usuario que ingrese algún texto. En una terminal Deno, la función de solicitud solicitará de manera similar al usuario y bloqueará sincrónicamente hasta que se reciba esa entrada.

Las API mencionadas pueden permitir a los desarrolladores implementar interacciones interactivas simples en la terminal. La nota de la versión proporciona un ejemplo trivial.

Solicitar al usuario una entrada en Node.js puede requerir que los desarrolladores manipulen los flujos de E / S directamente (por ejemplo, process.stdin) o mediante una biblioteca.

La nueva versión de Deno también mejora el REPL con la adición de varias características nuevas. Las propiedades y métodos de los objetos se pueden completar dentro del REPL presionando la tecla TAB. El código puede estar resaltado en sintaxis si el terminal admite colores. El REPL ahora también admite instrucciones de espera de nivel superior.

La nota de la versión detalla características menores adicionales que son parte de la versión. Los desarrolladores interesados ​​pueden revisar la nota de la versión en línea.

Deno es un software de código abierto disponible bajo la licencia MIT. Se fomentan las contribuciones a través del Proyecto Deno y deben seguir las pautas de contribución de Deno.

Dejo link : https://deno.land/posts/v1.5

https://deno.land

Manejo de errores en Go vs Rust Parte 2

Las segundas partes a veces son buenas como terminator 2. Por lo tanto seguimos con el manejo de errores de Go y Rust. 

En Go, una declaración defer empuja una llamada de función a una lista. La lista de llamadas guardadas se ejecuta después de que regrese la función circundante. Defer se usa comúnmente para simplificar funciones que realizan varias acciones de limpieza.

Por ejemplo, veamos una función que abre dos archivos y copia el contenido de un archivo al otro:

func CopyFile(dstName, srcName string) (written int64, err error) {

    src, err := os.Open(srcName)

    if err != nil {

        return

    }

    dst, err := os.Create(dstName)

    if err != nil {

        return

    }

    written, err = io.Copy(dst, src)

    dst.Close()

    src.Close()

    return

}

Esto funciona, pero hay un error. Si la llamada a os.Create falla, la función regresará sin cerrar el archivo fuente. Esto puede remediarse fácilmente llamando a src.Close antes de la segunda declaración de retorno, pero si la función fuera más compleja, el problema podría no ser detectado y resuelto tan fácilmente. Al introducir declaraciones diferidas, podemos asegurarnos de que los archivos siempre estén cerrados:

func CopyFile(dstName, srcName string) (written int64, err error) {

    src, err := os.Open(srcName)

    if err != nil {

        return

    }

    defer src.Close()

    dst, err := os.Create(dstName)

    if err != nil {

        return

    }

    defer dst.Close()

    return io.Copy(dst, src)

}

Las declaraciones diferidas nos permiten pensar en cerrar cada archivo justo después de abrirlo, garantizando que, independientemente del número de declaraciones devueltas en la función, los archivos se cerrarán.

El comportamiento de las declaraciones diferidas es sencillo y predecible. Hay tres reglas simples:

Los argumentos de una función diferida se evalúan cuando se evalúa la sentencia defer.

En este ejemplo, la expresión "i" se evalúa cuando se aplaza la llamada Println. La llamada diferida imprimirá "0" después de que la función regrese.

func a() {

    i := 0

    defer fmt.Println(i)

    i++

    return

}

Las llamadas a funciones diferidas se ejecutan en el orden Último en entrar, primero en salir después de que regrese la función circundante.

Esta función imprime "3210":

func b() {

    for i := 0; i < 4; i++ {

        defer fmt.Print(i)

    }

}

Las funciones diferidas pueden leer y asignar a los valores de retorno nombrados de la función de retorno.

En este ejemplo, una función diferida incrementa el valor de retorno i después de que regresa la función circundante. Por lo tanto, esta función devuelve 2:

func c() (i int) {

    defer func() { i++ }()

    return 1

}

Esto es conveniente para modificar el valor de retorno de error de una función. A mi me suena como que defer es el finaly de una expesión try-catch de Java o C++. 

Pero Rust no tiene tampoco la estructura try-catch de Java o C++ entonces ¿como podríamos simular el finally? o cerrar un archivo luego de utilidad. En realidad Rust carece de estas estructuras porque no son necesarias. Por ejemplo podemos hacer algo así : 

fn main() {

    let do_steps = || -> Result<(), MyError> {

        do_step_1()?;

        do_step_2()?;

        do_step_3()?;

        Ok(())

    };

    if let Err(_err) = do_steps() {

        println!("Failed to perform necessary steps");

    }

     runFinallyMethod(); 

}

Y listo! Bueno, vamos a seguir en proximos posts... 

Excepciones en Python

En código que puede causar que ocurra una excepción se coloca en el bloque try y el manejo de la excepción se implementa en el bloque except. El código en el bloque except solo se ejecutará si el bloque try se encuentra con una excepción. He aquí un ejemplo sencillo:

try:

    file = open('test.txt', 'rb')

except IOError as e:

    print('An IOError occurred. {}'.format(e.args[-1]))

En el ejemplo anterior, estamos manejando solo la excepción IOError.

Podemos usar tres métodos para manejar múltiples excepciones. El primero implica poner todas las excepciones que probablemente ocurran en una tupla. Al igual que:

try:

    file = open('test.txt', 'rb')

except (IOError, EOFError) as e:

    print("An error occurred. {}".format(e.args[-1]))

Otro método consiste en manejar excepciones individuales en bloques de excepción separados. Podemos tener tantos excepto bloques como queramos. Aquí hay un ejemplo:

try:

    file = open('test.txt', 'rb')

except EOFError as e:

    print("An EOF error occurred.")

    raise e

except IOError as e:

    print("An error occurred.")

    raise e

De esta manera, si la excepción no es manejada por el primer bloque except, entonces puede ser manejada por un bloque siguiente, o ninguno en absoluto. Ahora, el último método implica atrapar TODAS las excepciones:

try:

    file = open('test.txt', 'rb')

except Exception as e:

    # Some logging if you want

    raise e

Esto puede ser útil cuando no tiene idea de las excepciones que puede generar su programa. Si solo está buscando capturar todas las ejecuciones, pero en realidad no le importa lo que son, puede incluso excluir la excepción como parte.

Nota: la captura de todas las excepciones puede tener consecuencias no deseadas porque la captura de todas las excepciones también puede detectar las que desea que ocurran; por ejemplo, en muchos programas basados ​​en la línea de comandos, presionar control + c terminará el programa, pero si detecta todas las excepciones, KeyboardInterrupt se detectará como una excepción, por lo que presionar control + c NO terminará el programa.

Envolvemos nuestro código principal en la cláusula try. Después de eso, envolvemos algún código en una cláusula except que se ejecuta si ocurre una excepción en el código envuelto en la cláusula try. En este ejemplo también usaremos una tercera cláusula que es la cláusula finally. El código que está envuelto en la cláusula finally se ejecutará tanto si se produjo una excepción como si no. Podría usarse para realizar una limpieza después de un script. He aquí un ejemplo sencillo:

try:

    file = open('test.txt', 'rb')

except IOError as e:

    print('An IOError occurred. {}'.format(e.args[-1]))

finally:

    print("This would be printed whether or not an exception occurred!")

# Output: An IOError occurred. No such file or directory

# This would be printed whether or not an exception occurred!

A menudo, es posible que deseemos que se ejecute algún código si no se produce ninguna excepción. Esto se puede lograr fácilmente utilizando una cláusula else. Uno podría preguntarse: ¿por qué, si solo desea que se ejecute algún código si no ocurre ninguna excepción, no simplemente pondría ese código dentro del intento? La respuesta es que entonces cualquier excepción en ese código será detectada por el intento, y es posible que no desee eso. La mayoría de la gente no lo usa. Aquí hay un ejemplo:

try:

    print('I am sure no exception is going to occur!')

except Exception:

    print('exception')

else:

    # any code that should only run if no exception occurs in the try,

    # but for which exceptions should NOT be caught

    print('This would only run if no exception occurs. And an error here '

          'would NOT be caught.')

finally:

    print('This would be printed in every case.')

# Output: I am sure no exception is going to occur!

# This would only run if no exception occurs. And an error here would NOT be caught

# This would be printed in every case.

La cláusula else solo se ejecutará si no se produce ninguna excepción y se ejecutará antes de la cláusula finalmente.

Listas, conjuntos definidos por comprensión en Python

Las comprensiones son construcciones que permiten construir secuencias a partir de otras secuencias. Se admiten varios tipos de comprensión tanto en Python 2 como en Python 3:

• listas por comprensión
• diccionarios por comprensión
• conjuntos  por comprensión
• Generadores por comprensión

Las listas por comprensión proporcionan una forma breve y concisa de crear listas. Consiste en corchetes que contienen una expresión seguida de una cláusula for, luego cero o más cláusulas for o if. Las expresiones pueden ser cualquier cosa, lo que significa que puede incluir todo tipo de objetos en listas. El resultado sería una nueva lista realizada después de la evaluación de la expresión en el contexto de las cláusulas if y for.

variable = [out_exp for out_exp in input_list if out_exp == 2]

Aquí hay un pequeño ejemplo:

multiples = [i for i in range(30) if i % 3 == 0]

print(multiples)

# Output: [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

Esto puede resultar muy útil para hacer listas rápidamente. Algunos incluso lo prefieren en lugar de la función de filtro. Las comprensiones de listas realmente brillan cuando desea proporcionar una lista a un método o función para hacer una nueva lista agregándola en cada iteración del ciclo for. Por ejemplo, normalmente haría algo como esto:

squared = []

for x in range(10):

    squared.append(x**2)

Puede simplificarlo usando listas por comprensión. Por ejemplo:

squared = [x**2 for x in range(10)]

Los diccionarios por comprensión se utilizan de forma similar. Aquí hay un ejemplo que encontré recientemente:

mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}

mcase_frequency = {

    k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0)

    for k in mcase.keys()

}

# mcase_frequency == {'a': 17, 'z': 3, 'b': 34}

En el ejemplo anterior, estamos combinando los valores de las claves que son iguales pero en diferentes tipos de letra. También puede cambiar rápidamente las claves y los valores de un diccionario:

{v: k for k, v in some_dict.items()}

Los conjuntos  por comprensión también son similares a las listas por comprensión. La única diferencia es que usan llaves {}. Aquí hay un ejemplo:

squared = {x**2 for x in [1, 1, 2]}

print(squared)

# Output: {1, 4}

Los Generadores por comprensión también son similares a las listas por comprensión. La única diferencia es que no asignan memoria para toda la lista, sino que generan un elemento a la vez, por lo que la memoria es más eficiente.

multiples_gen = (i for i in range(30) if i % 3 == 0)

print(multiples_gen)

# Output: <generator object <genexpr> at 0x7fdaa8e407d8>

for x in multiples_gen:

  print(x)

  # Outputs numbers

Maybe

Veamos la mónada Maybe, que facilita mucho el uso del tipo Maybe.

Ya conoces la definición del tipo Maybe:

    data Maybe a = Just a | Nothing

Las funciones de Head y Tail de Prelude no son seguras en el sentido de que fallan cuando se llaman en una lista vacía. Podemos definir versiones seguras usando Maybe:

    myHead :: [a] -> Maybe a

    myHead [] = Nothing

    myHead (x:xs) = Just x

    myTail :: [a] -> Maybe []

    myTail [] = Nothing

    myTail (x:xs) = Just xs

Ahora podemos hacer de Maybe una instancia de la clase de tipo Monad, simplemente proporcionando las definiciones apropiadas para return, bind, then y fail:

    import Control.Monad

    instance Monad Maybe where

        return           =   Just

        Nothing  >>= f = Nothing

        (Just x) >>= f = f x

        fail _           =   Nothing

Hay algunas funciones adicionales definidas en la clase de tipo MonadPlus:

    instance MonadPlus Maybe where

        mzero               = Nothing

        Nothing `mplus` x = x

        x `mplus` _         = x

Eso es todo, ¡ahora tenemos una mónada Maybe!

Veamos qué nos da esta mónada:

Un cálculo usando Maybe explícito

    foo :: [a] -> Maybe a

    foo xs =

      case myTail xs of

        Nothing -> Nothing

        Just a -> case myTail a of

                    Nothing -> Nothing

                    Just b -> myHead b

Para combinar cálculos que usan el tipo Maybe, necesitamos expresiones de caso explícitas para hacer coincidir el patrón con el tipo.

Escribamos este cálculo usando la mónada Maybe, primero usando el operador >> =:

    bar :: [a] -> Maybe a

    bar xs =

      myTail xs >>=

        (\a -> myTail a >>=

          (\b -> myHead b))

Ahora cambiemos un poco los saltos de línea y la sangría para que se vea mejor:

    bar2 :: [a] -> Maybe a

    bar2 xs =

      myTail xs >>= (\a ->

      myTail a >>=  (\b ->

      myHead b))

Gracias a la ley de asociatividad, también podemos eliminar los paréntesis innecesarios:

    bar3 :: [a] -> Maybe a

    bar3 xs =

      myTail xs >>= \a ->

      myTail a >>=  \b ->

      myHead b

Esto ya es mucho más limpio, pero finalmente podemos usar la notación do:

    bar3 :: [a] -> Maybe a

    bar3 xs = do

      a <- myTail xs

      b <- myTail a

      myHead b

Claramente, el código monádico final es mucho más legible que el código no monádico original.

Ejemplo: Reducción de barra [5,6]

        bar [5,6]

    -- > substitute [5,6] for xs in definition of bar

        myTail [5,6] >>=

         (\a -> myTail a >>=

          (\b -> myHead b))

    -- > def. myTail

        Just [6]  >>=

         (\a -> myTail a >>=

          (\b -> myHead b))

    -- >  def.2 of (>>=)

         (\a -> myTail a >>=

          (\b -> myHead b))

            [6]

    -- > beta reduction, substitute [6] for a

         myTail [6] >>= (\b -> myHead b)

    -- > reduce myTail

         Just [] >>=  (\b -> myHead b)

    -- >  def.2 of (>>=)   

        (\b -> myHead b) []

    -- > beta reduction, substitute [] for b

       myHead []

    -- > def.1 myHead

      Nothing

Ejemplo: Reducción de barra [5,6,7]

        bar [5,6,7]

    -> sustituir [5,6,7] por xs en la definición de bar

        bar [5,6,7]

    -- > substitute [5,6,7] for xs in definition of bar

        myTail [5,6,7] >>=

         (\a -> myTail a >>=

          (\b -> myHead b))

    -- > def. myTail

        Just [6,7]  >>=

         (\a -> myTail a >>=

          (\b -> myHead b))

    -- >  def.2 of (>>=)

         (\a -> myTail a >>=

          (\b -> myHead b))

            [6,7]

    -- > beta reduction, substitute [6,7] for a

         myTail [6,7] >>= (\b -> myHead b)

    -- > reduce myTail

         Just [7] >>=  (\b -> myHead b)

    -- >  def.2 of (>>=)   

        (\b -> myHead b) [7]

    -- > beta reduction, substitute [7] for b

        myHead [7]

    -- > def myHead

        Just 7

Y un día llego .net 5

Charan!

No hablamos mucho de .net por nuestra clara preferencia al software libre pero pero .net 5, viene a taparnos la boca y a afirmar que microsoft, si ama a linux y al open source.

.net 5 es la confluencia de .net con .net core y tiene todas las ventajas de los 2 mundos. .net 5 es independiente de la plataforma, puede correr en Window, Linux y Mac. 

.NET 5 mejora diversos frentes, como en el rendimiento de muchos componentes del framework, los lenguajes C# 9 y F# 5, el rendimiento de algunas bibliotecas para la serialización de JSON y en las opciones de implementación o despliegue, además de haberse expandido el enfoque a Windows para ARM64 y WebAssembly.

 .NET 5 no solo abarca cosas a nivel de servidor, sino también componentes exclusivos de Windows como Windows Forms. En lo que respecta a Linux, se ha incorporado el soporte multiplataforma para ‘System.DirectoryServices.Protocols’, que ya estaba presente en Windows, pero no en Linux y macOS. “‘System.DirectoryServices.Protocols’ es una API de más bajo nivel que ‘System.DirectoryServices’ y habilita (o puede usarse para habilitar) más escenarios. ‘System.DirectoryServices’ incluye conceptos/implementaciones solo para Windows, por lo que no era una elección obvia hacerla multiplataforma. Ambos conjuntos de API permiten controlar e interactuar con un servidor de servicios de directorio, como LDAP o Active Directory.”

Y trae como muchas cosas, seguro que vamos a tener que visitar esta plataforma desde blog. 

Sin más dejo link: 

https://devblogs.microsoft.com/dotnet/announcing-net-5-0/

https://dotnet.microsoft.com/download/dotnet/5.0

https://docs.microsoft.com/es-es/dotnet/core/install/linux

¿Qué es una mónada?

Rápidamente nos podemos percatar de la importancia de los acentos! 

Una mónada es una estructura algebraica en la teoría de categorías, y en Haskell se usa para describir cálculos como secuencias de pasos y para manejar efectos secundarios como estado de entrada o salida.

Las mónadas son abstractas y tienen muchos ejemplos concretos útiles.

Las mónadas proporcionan una forma de estructurar un programa.

Se pueden usar (junto con tipos de datos abstractos) para permitir que las acciones (por ejemplo, variables mutables) se implementen de forma segura.

Una mónada tiene tres bloques de construcción:

• Un constructor de tipos que produce el tipo de cálculo, dado el tipo de resultado de ese cálculo.
• Una función que toma un valor y devuelve un cálculo que, cuando se ejecuta, producirá ese valor.
• Una función que toma dos cálculos y los realiza uno tras otro, haciendo que el resultado del primer cálculo esté disponible para el segundo.

Una mónada consta de tres objetos, que deben satisfacer las leyes de la mónada. Veamos primero los objetos:

Un constructor de tipo M, tal que para cualquier tipo a, el tipo M a es el tipo de cálculo en la mónada M que produce un resultado de tipo a.

Una función return :: a → M a. Por lo tanto, si x :: a, return x es un cálculo en M que, cuando se ejecuta, producirá un valor de tipo a.

Una función (>> =) :: M a → (a → M b) → M b.

El primer argumento es un cálculo que produce un valor de tipo a.

El segundo argumento es una función que requiere un argumento de tipo a y devuelve un cálculo que produce un valor de tipo b.

Las leyes de las mónadas es un cálculo que producirá un valor de tipo b. Funciona ejecutando el primer cálculo y pasando su resultado a la función que devuelve el segundo cálculo, que luego se ejecuta.

Las mónadas son abstractas, generales y útiles.

En consecuencia, hay muchos casos de ellos.

Esto se captura mediante la definición de una clase de tipo para las mónadas, junto con muchas instancias estándar.

    class Monad m where

        return :: a -> m a

        (>>=) :: m a -> (a -> m b) -> m b

        (>>)   :: m a -> m b -> m b

        fail   :: String -> m a

La función de retorno toma un valor y devuelve un valor monádico, es decir, un valor envuelto en el constructor de tipo monada.

El operador >> = (pronunciado "bind") es una parte crucial de una mónada. Vincula un valor devuelto de un cálculo a otro cálculo.

El operador >> (pronunciado "then") es como >> =, pero simplemente ignora el valor devuelto por el cálculo:

    m >> n = m >> = \ _ -> n

El sistema utiliza la función de error para ayudar a producir mensajes de error cuando hay un patrón que no coincide; normalmente no lo usa directamente.

Cada mónada debe satisfacer las siguientes tres leyes. Entonces, si algo parece una mónada pero no satisface estas leyes, ¡no es una mónada! Las leyes expresan propiedades que deben satisfacerse para hacer componibles los cálculos monádicos.

La ley de unidad correcta:

    m >> = retorno = m

La ley de la unidad izquierda:

    devuelve x >> = f = f x

La ley de asociatividad:

    (m >> = f) >> = g = m >> = (\ x -> f x >> = g)

Hay muchas metáforas o intuiciones sobre lo que es una mónada.

Ejemplo: un "cálculo" o una "acción". Pero estos términos son vagos: pueden ayudarlo a comprender, pero a veces también pueden ser engañosos.

Una mónada es exactamente lo que dice la definición, ni más ni menos.

Escribir cálculos monádicos usando los operadores bind y then sigue siendo algo torpe. Haskell proporciona un azúcar sintáctico muy conveniente para cálculos monádicos llamado "notación do":

    baz :: [a] -> Maybe a

    baz xs =

      do  a <- myTail xs

          b <- myTail a

          c <- myHead b

          return c

Reglas de sintaxis para hacer

    do { x }  -- >  x

    do {x ; <xs> }  -- >  x >> do { <xs> }

    do { a <- x ; <xs> }  -- >  x >>= \a -> do { <xs> }

    do { let <declarations> ; xs }    -- >   let <declarations> in do { xs }

En un lenguaje funcional, solo hay funciones

Aunque parezca que un lenguaje como Haskell tiene muchos objetos y construcciones diferentes, podemos expresarlos todos en términos de funciones. 

  let

      n = 10

      f x = x+1

    in

      f n

-- Una variable por let =>

    let

      n = 10

    in

      let  

        f x = x+1

      in

        f n

-- Reescribe f como lambda  =>

        

    let

      n = 10

    in

      let  

        f = \x -> x+1

      in

        f n

-- Reescribe el let interno como lambda =>

    let

      n = 10

    in

      (\f -> f n) (\x -> x+1)  

-- Reescribe el let externo como lambda =>

    ( \n -> ((\f -> f n) ( \x -> x+1 )) ) 10    

Entonces, las variables y las expresiones let son solo azúcar sintáctico para las expresiones lambda.

    tp = (1,"2",[3])

La notación de tupla es azúcar sintáctica para una aplicación de función:

    tp = mkTup 1 "2" [3]

La función de construcción de tuplas se puede definir de nuevo simplemente usando lambdas:

   mkTup = \x y z -> \t -> t x y z

Lo mismo ocurre con las funciones de acceso a la tupla:

    fst tp = tp (\x y z -> x)

    snd tp = tp (\x y z -> y)

Las listas se pueden definir en términos de listas vacías [] y la operación de contras (:).

    ls = [1,2,3]

Se puede escribir con : y [] =>

    ls = 1 : 2 : 3 : []

O usando cons =>

 ls = cons 1 (cons 2 (cons 3 []))

Podemos definir cons usando solo funciones lambda como

  cons = \x xs ->

   \c -> c x xs

Así

    ls = cons 1 (...)

       = \c -> c 1 (...)

También podemos definir head y tail usando solo lambdas:

    head ls = ls (\x y -> x)

    tail ls = ls (\x y -> y)

 

Podemos definir la lista vacía de la siguiente manera:

 [] = \f -> true

Las definiciones de verdadero y falso se dan a continuación bajo Booleanos.

Luego podemos verificar si una lista está vacía o no:

    isEmpty lst = lst (\x xs -> false)

Una lista no vacía siempre se define como: 

lst = x: xs

que con nuestra definición de (:) es

    lst = (\x xs -> \c -> c x xs) x xs

    = \c -> c x xs

Así que :

isEmpty lst

    = isEmpty (\c -> c x xs)

    =  (\c -> c x xs) (\x xs -> false)

    = false

    isEmpty []

    = isEmpty (\f -> true)

    = (\f->true) (\x xs -> false)

    = true

Ahora que podemos probar la lista vacía, podemos definir recursiones en listas como foldl, map, etc.

    foldl f acc lst =

      if isEmpty lst

        then acc

        else foldl f (f (head lst) acc) (tail lst)

y

    map f lst  =

      let

        map' f lst lst' = if isEmpty lst then (reverse lst') else map' f (tail lst) (head lst: lst')

      in

        map' f lst []

con

   reverse lst = (foldl (\acc elt -> (elt:acc)) [] lst

Las definiciones de foldl y map usan una expresión if-then-else que se define a posteriormente en condicionales.

 Concatenación de lista :   (++) lst1 lst2 = foldl (\acc elt -> (elt:acc)) lst2 (reverse lst1)

Para calcular la longitud de una lista necesitamos números enteros, se definen a continuación.

    length lst = foldl calc_length 0 lst

      where

        calc_length _ len = inc len

Hemos utilizado condicionales en las expresiones anteriores:

    if cond then if_true_exp else if_false_exp

Aquí cond es una expresión que devuelve verdadero o falso, que se definen a continuación.

Podemos escribir la cláusula if-then-else como una función pura:

    ifthenelse cond if_true_exp if_false_exp

Para evaluar la condición necesitamos definir booleanos:

    true = \x y -> x

    false = \x y -> y

Con esta definición, el if-then-else se convierte simplemente

    ifthenelse cond if_true_exp if_false_exp = cond if_true_exp if_false_exp

Usando ifthenelse podemos definir y, o y no:

    and x y = ifthenelse x (ifthenelse y true) false

    or x y = ifthenelse x true (ifthenelse y true false)

    not x = ifthenelse x false true

Observamos que para probar la igualdad de los booleanos podemos usar xnor y, por supuesto, podemos definir xor en términos de y, o y no:

    xor x y = (x or y) and (not x or not y)

    xnor x y = not (xor x y)

Enteros firmados

Definimos un entero como una lista de valores booleanos, en codificación de termómetro, y con las siguientes definiciones:

Definimos usigned 0 como una lista de 1 elemento que contiene false. Para obtener enteros con signo, simplemente definimos el primer bit de la lista como el bit de signo. Definimos versiones firmadas y sin firmar de 0:

    u0 = false:[]

    0 = +0 = true:u0

    -0 = false:u0

Por conveniencia definimos también:

    isPos n = head n

    isNeg n = not (head n)

    isZero n = not (head (tail n))

    sign n = head n

La definición de 0 facilita la igualdad de enteros (==):

    (==) n1 n2 = let

      s1 = head n1

      s2 = head n2

      b1 = head (tail n1)

      b2 = head (tail n2)

      if (xnor s1 s2) then

        if (and (not b1) (not b2))

          then true

          else

            if (and b1 b2)

              then  (==) (s1:(tail n1)) (s2:(tail n2))

              else false

        else false

También podemos definir fácilmente la negación:

    neg n = (not (head n)):(tail n)

Por conveniencia definimos también definimos operaciones de incremento y decremento:

    inc n = if isPos n then true:true:(tail n) else if isZero n then 1 else false:(tail (tail n))

    dec n = if isZero n then -1 else if isNeg n then false:true:(tail n) n else true:(tail (tail n))

La adición general es bastante fácil:

    add n1 n2 = foldl add_if_true n1 n2

      where

        add_if_true elt n1 = if elt then true:n1 else n1

Del mismo modo, la resta también es sencilla:

    sub n1 n2 = foldl sub_if_true n1 n2

      where

        sub_if_true elt n1 = of elt then (tail n1) else n1

Una forma sencilla de definir la multiplicación es definiendo las operaciones de replicación y suma:

    replicate n m =

      let

        repl n m lst = if n==0 then lst else repl (dec n) m (m:lst)

      in

        repl n m []

    sum lst = foldl add 0 lst

Entonces la multiplicación simplemente se convierte en

    mult n m = sum (replicate n m)

De manera similar, se pueden definir la división y el módulo de enteros.

Observamos que los flotantes y los caracteres utilizan una representación de números enteros, y las cadenas son simplemente listas de caracteres. Entonces ahora tenemos un lenguaje que puede manipular listas y tuplas de enteros, flotantes, caracteres y cadenas.

Introspección de objetos en Python

En programación, la introspección es la capacidad de determinar las características de un objeto en tiempo de ejecución. Es uno de los puntos fuertes de Python. Todo en Python es un objeto y podemos examinar esos objetos. Python viene con algunas funciones y módulos incorporados para ayudarnos.

dir es una de las funciones más importantes para la introspección. Devuelve una lista de atributos y métodos que pertenecen a un objeto. Aquí hay un ejemplo:

my_list = [1, 2, 3]

dir(my_list)

# Output: ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__',

# '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',

# '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__',

# '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__',

# '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__',

# '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__',

# '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop',

# 'remove', 'reverse', 'sort']

Esta llamada nos dio los nombres de todos los métodos de una lista. Esto puede ser útil cuando no puede recordar el nombre de un método. Si ejecutamos dir () sin ningún argumento, devuelve todos los nombres en el ámbito actual.

La función de type devuelve el tipo de un objeto. Por ejemplo:

print(type(''))

# Output: <type 'str'>

print(type([]))

# Output: <type 'list'>

print(type({}))

# Output: <type 'dict'>

print(type(dict))

# Output: <type 'type'>

print(type(3))

# Output: <type 'int'>

id devuelve los identificadores únicos de varios objetos. Por ejemplo:

name = "Yasoob"

print(id(name))

# Output: 139972439030304

El módulo de inspección también proporciona varias funciones útiles para obtener información sobre objetos activos. Por ejemplo, puede verificar los miembros de un objeto ejecutando:

import inspect

print(inspect.getmembers(str))

# Output: [('__add__', <slot wrapper '__add__' of ... ...

También hay un par de otros métodos que ayudan en la introspección. Pero los veremos en otro post...

Libros Gratuitos de Java Code Geeks

 

Download IT Guides!   Java 8 Features With no doubts, Java 8 release is the greatest thing in the Java world since Java 5 (released quite a while ago, back in 2004). It brings tons of new features to the Java as a language,...     Amazon DynamoDB Tutorial Amazon DynamoDB is a fully managed proprietary NoSQL database service that is offered by Amazon.com as part of the Amazon Web Services portfolio...     Mockito Programming Cookbook Mockito is an open source testing framework for Java released under the MIT License. The framework allows the creation of test double objects (mock objects) in automated unit tests for...     Vaadin Programming Cookbook Vaadin is an open source web framework for rich Internet applications. In contrast to JavaScript libraries and browser-plugin based solutions, it features a server-side architecture,...

Elixir School

Elixir School es el primer destino para personas que buscan aprender y dominar el lenguaje de programación Elixir

Ya seas un veterano experimentado o esta es tu primera vez, vas a encontrar lo que necesitas en las lecciones y en los recursos auxiliares

Mediante el trabajo duro de voluntarios Elixir School ha sido traducido a muchos idiomas. Algunas de estas traducciones incluyen: Việt ngữ, 简体中文, 繁體中文, English, Slovenčina, 日本語, Polski, Português, Русском, Bahasa Indonesia, Bahasa Melayu, Українською, 한국어, Italiano, Deutsch, বাংলা, Türkçe, y ภาษาไทย.

Te damos la bienvenida y te motivamos a continuar haciendo Elixir School grandioso involucrándote en elixirschool/elixirschool!

De esta manera se presenta Elixir school que es un excelente sitio para comenzar con Elixir. 

Y sin más dejo link: https://elixirschool.com/es/

Tipos con Clase parte 5

Seguimos con type class. 

Veamos algunas de type class definidas en las bibliotecas estándar.

Num: números, con muchas subclases para tipos específicos de números.

Read: tipos que se pueden "leer desde" una cadena.

Show: tipos que se pueden "mostrar a" una cadena.

Eq: tipos para los que se define el operador de igualdad ==.

Ord: tipos para los que puede hacer comparaciones como <,>, etc.

Enum: tipos donde los valores se pueden enumerar en secuencia; esto se usa, por ejemplo, en la notación [1..n] y ′ a ′ .. ′ z ′.

    *Main> [1..10]

    [1,2,3,4,5,6,7,8,9,10]

    *Main> ['a'..'z']

    "abcdefghijklmnopqrstuvwxyz"

Tipos con Clase parte 4

Seguimos con Type class. 

Hemos estado usando show para convertir un valor de datos en una cadena, que luego se puede escribir en la salida.

Algunos valores se pueden "mostrar", pero no todos.

Por ejemplo, en general es imposible mostrar una función.

Por lo tanto, debemos usar type class

    show::Show a → a→String

Definición de su propia instancia de Show

    data Foo = Bar | Baz

Podríamos querer nuestra propia representación de cadena :

    instance Show Foo where

      show Bar = "it is a bar"

      show Baz = "this is a baz"

Recordemos que cuando ingresa una expresión exp en ghci, imprime showexp. Entonces podemos probar nuestra extraña declaración de instancia:

    *Main> Bar

    it is a bar

    *Main> Baz

    this is a baz

deriving nos permite indicar que "implementa" Show o otro data type : 

    data Foo2 = Bar2 | Baz2

      deriving (Read, Show)

Haskell definirá automáticamente una instancia de show para Foo2, usando la definición obvia:

    *Main> Bar2

    Bar2

    *Main> Baz2

    Baz2