Introducción a la Programación en Julia

Julia fue lanzado originalmente en 2012 por Alan Edelman, Stefan Karpinski, Jeff Bezanson y Viral Shah. Es un lenguaje de programación gratuito y de código abierto.

La elección de un lenguaje de programación es siempre subjetiva. Para mí, las siguientes características de Julia son decisivas:

Julia es un lenguaje de programación único, ya que resuelve el problema de los dos idiomas. No se necesita de ningún otro lenguaje de programación para escribir código de alto rendimiento. Esto no significa que ocurra automáticamente. Es responsabilidad del programador optimizar el código que genere cuellos de botella, aunque esto puede hacerse directamente en Julia.

Este libro es para cualquier persona que quiera aprender a programar. No se requieren conocimientos formales previos.

Los nuevos conceptos se introducen gradualmente, y los temas más avanzados se describen en capítulos posteriores.

Introducción a Julia puede ser usado como un curso de un semestre de nivel secundario o universitario.

En este libro se siguen las siguientes convenciones tipográficas:

Todo el código utilizado en este libro está disponible en un repositorio de Git en GitHub: https://github.com/JuliaIntro/IntroAJulia.jl. Si no está familiarizado con Git, es un sistema de control de versiones que le permite realizar seguimiento a los archivos que componen un proyecto. Una colección de archivos controlados por Git se denomina “repositorio”. GitHub es un servicio de hosting que proporciona almacenamiento para repositorios de Git, y una interfaz web conveniente.

El siguiente paquete puede ser de utilidad, y se puede agregar directamente a Julia. Simplemente escriba add https://github.com/JuliaIntro/IntroAJulia.jl en el REPL, en modo Pkg.

La forma más fácil de ejecutar un código de Julia es yendo a https://juliabox.com, e iniciar una sesión de prueba gratuita. Es posible utilizar tanto las interfaces REPL como de notebooks. Si desea tner Julia instalada localmente en su computadora, puede descargar JuliaPro de Julia Computing gratuitamente. Consiste en una versión reciente de Julia, el IDE de Juno basado en Atom y varios paquetes de Julia preinstalados. Si es más aventurero, puede descargar Julia desde https://julialang.org, instale el editor que prefiera, por ejemplo Atom o Visual Studio Code, activando los complementos para su integración de Julia. En el caso de una instalación local, también puede agregar el paquete IJulia que le permite ejecutar un notebook de Jupyter en su computadora.

Realmente quiero agradecer a Allen por escribir Think Python, y permitirme trasladar este libro a Julia. ¡Tu entusiasmo es contagioso!

También me gustaría agradecer a los revisores técnicos de este libro, que hicieron muchas sugerencias útiles: Tim Besard, Bart Janssens y David P. Sanders.

Gracias a Melissa Potter de O’Reilly Media por hacer de este un mejor libro. Me obligaste a hacer las cosas bien, y hacer que este libro sea lo más original posible.

Gracias a Matt Hacker de O’Reilly Media que me ayudó con la cadena de herramientas Atlas, y algunos problemas al destacar la sintaxis.

Gracias a todos los estudiantes que trabajaron con una versión temprana de este libro, y a todos los colaboradores (enumerados a continuación) que enviaron correcciones y sugerencias.

Si tiene una sugerencia o corrección, abra un issue en GitHub. Si se realiza un cambio basado en sus comentarios, será agregado a la lista de contribuyentes (a menos que solicite ser omitido).

Avísenos con qué versión del libro está trabajando, y en qué formato. Si incluye al menos parte de la oración en la que aparece el error, eso facilita la búsqueda. Los números de página y sección también son útiles, pero no es tan fácil trabajar con ellos. ¡Gracias!

Una sentencia de asignación crea una nueva variable y le asigna un valor:

Este ejemplo realiza tres asignaciones. La primera asigna una cadena a una nueva variable llamada mensaje; la segunda le asigna el entero 17 a la variable n; la tercera asigna el valor (aproximado) de π a la variable π_val (\pi TAB).

Una forma común de representar variables en papel es escribir el nombre de la variable con una flecha apuntando a su valor. Este tipo de figura se llama “diagrama de estado” porque muestra en qué estado se encuentra cada una de las variables. La Figura 1, Diagrama de estado, muestra el resultado del ejemplo anterior.

Los programadores generalmente eligen nombres representativos para sus variables, es decir, nombres que explican para qué se usa o qué contiene la variable.

Los nombres de las variables pueden ser tan largos como se desee. Pueden contener casi todos los caracteres Unicode (consulte Caracteres), pero no pueden comenzar con un número. Es válido usar letras mayúsculas, pero lo común es usar solo minúsculas para nombres de variables.

Los caracteres Unicode se pueden ingresar mediante autocompletado por tabulación de las abreviaturas tipo LaTeX en el REPL de Julia.

El carácter guión bajo, _, puede formar parte del nombre de una variable. Generalmente se usa como separador en nombres con varias palabras, como por ejemplo en tu_nombre o velocidad_aerodinamica_de_una_golondrina_sin_cargamento.

Si se le da un nombre inválido a una variable, aparece un error de sintaxis:

76trombones es un nombre de variable inválido porque comienza con un número. También es inválido mas@ porque contiene el carácter inválido: @. Pero, ¿cuál es el error en struct?

Resulta que struct es una de las palabras reservadas de Julia. Julia usa las palabras reservadas para reconocer la estructura del programa, por ello no pueden usarse como nombres de variables.

Julia tiene las siguientes palabras reservadas:

No es necesario memorizar esta lista. En la mayoría de los entornos de desarrollo, las palabras reservadas se muestran en un color diferente; por lo tanto, si intenta usar una como nombre de variable, lo sabrá.

Una expresión es una combinación de valores, variables y operadores. Un valor o una variable por sí solos se consideran una expresión, por lo que las siguientes expresiones son válidas:

Cuando escribe una expresión en el prompt, el REPL la evalúa, lo que significa que encuentra el valor de la expresión. En este ejemplo, n tiene el valor 17 previamente asignado y n+25 retorna el valor 42.

Una sentencia es una unidad de código que tiene un efecto, tal como crear una variable o mostrar un valor.

La primera línea es una sentencia de asignación, ya que asigna un valor a n. La segunda línea es una sentencia de impresión que muestra el valor de n.

Cuando escribe una sentencia, REPL la ejecuta, es decir, hace lo que dice la sentencia.

Hasta ahora se ha ejecutado Julia en modo interactivo, lo que significa que se ha interactuado directamente con el REPL. Este modo es una buena manera de comenzar, pero si está trabajando con varias líneas de código, puede resultar incómodo.

Una alternativa es guardar el código en un archivo de órdenes o script y luego utilizar Julia en modo script para ejecutarlo. Por convención, los scripts de Julia tienen nombres que terminan con la extensión .jl.

Si sabe cómo crear y ejecutar un script en su computadora, está listo para comenzar. De lo contrario, es recomendable usar JuliaBox nuevamente. Abra un archivo de texto, escriba el script y guárdelo con la extensión .jl. El script se puede ejecutar en una terminal con el comando julia nombre_del_script.jl.

Debido a que Julia proporciona ambos modos, puede probar líneas de código en modo interactivo antes de colocarlos en un script. Aún así, tenga en consideración que existen diferencias entre el modo interactivo y el modo script que pueden generar confusión.

Por ejemplo, si está utilizando Julia como una calculadora, puede escribir

La primera línea asigna un valor a millas y muestra el valor. La segunda línea es una expresión, por lo que el REPL la evalúa y muestra el resultado. Gracias al código anterior sabemos que una maratón tiene unos 42 kilómetros.

Pero, si escribe el mismo código en un script y lo ejecuta, no obtendrá ningún resultado. En el modo script, una expresión, por sí sola, no tiene ningún efecto visible. Julia evalúa la expresión, pero no muestra el valor a menos que se lo indique:

Al principio este comportamiento puede ser confuso.

Un script generalmente contiene una secuencia de sentencias. Si hay más de una sentencia, los resultados aparecen de uno a la vez a medida que se ejecutan las sentencias.

Por ejemplo, el script

produce la salida

Notar que la sentencia de asignación x = 2 no tiene salida.

Cuando una expresión contiene más de un operador, el orden de evaluación depende de las reglas de precedencia. Julia sigue la convención matemática para el orden de evaluación de los operadores matemáticos. El acrónimo PAPOMUDAS es una forma útil de recordar estas reglas:

En general, no se pueden realizar operaciones matemáticas con cadenas, aunque las cadenas puedan parecer números, por lo que lo siguiente es inválido:

No obstante, hay dos excepciones, * y ^.

El operador * realiza concatenación de cadenas, lo que significa que une las cadenas de extremo a extremo. Por ejemplo:

El operador ^ también funciona con cadenas generando repeticiones. Por ejemplo, "Spam"^3 es "SpamSpamSpam". Si uno de los valores es una cadena, el otro tiene que ser un número entero.

De manera análoga, este uso de * y ^ también tiene sentido en la multiplicación y potencia. Así como 4^3 es equivalente a 4*4*4, esperamos que el "Spam"^3 sea lo mismo que el "Spam"*"Spam"*"Spam", y lo es.

A medida que los programas se hacen más largos y complejos, se vuelven más difíciles de leer. Los lenguajes formales son densos, y a menudo es difícil leer el código y entender qué está haciendo o por qué.

Por esta razón, es una buena idea agregar notas a sus programas para explicar en lenguaje natural lo que está haciendo el programa. Estas notas se llaman comentarios, y comienzan con el símbolo #:

En este caso, el comentario aparece sólo en una línea. También puede poner comentarios al final de una línea:

Todo, desde el # hasta el final de la línea se ignora y no tiene ningún efecto en la ejecución del programa.

Los comentarios son más útiles cuando documentan características no obvias del código. Es razonable suponer que el lector puede averiguar qué hace el código, por lo tanto es más útil explicar por qué.

Este comentario es inútil porque es redundante con el código:

Este comentario contiene información útil que no está presente en el código:

Se pueden producir tres tipos de errores en un programa: errores de sintaxis, errores en tiempo de ejecución, y errores semánticos. Es útil distinguirlos para rastrearlos más rápidamente.

Identificar errores semánticos puede ser complicado porque requiere que se trabaje a la inversa, analizando la salida del programa para intentar descubrir qué está haciendo.

Ya se ha visto un ejemplo de una llamada a función:

El nombre de esta función es println. La expresión entre paréntesis se llama argumento de la función.

Es común decir que una función "toma" un argumento y "devuelve" un resultado. El resultado también se llama valor de retorno.

Julia tiene funciones integradas que convierten valores de un tipo a otro. La función parse toma una cadena y, si es posible, la convierte en cualquier tipo de número, en caso contrario arroja error:

(ERROR: ArgumentError: base inválida de 10 dígitos H en "Hola")

trunc puede convertir valores de punto flotante a enteros, pero no redondea; sino que trunca:

float convierte números enteros en números de punto flotante:

Finalmente, string convierte el argumento en una cadena:

En Julia, la mayoría de las funciones matemáticas conocidas están disponibles directamente:

Este primer ejemplo utiliza la función log10 para calcular la proporción entre señal y ruido en decibelios (suponiendo que potencia_de_señal y potencia_de_ruido están definidos). También existe la función log, que calcula el logaritmo natural.

Este segundo ejemplo encuentra la razón seno (en inglés sine) de la variable radianes. El nombre de esta variable es una pista de que la función sin y las otras funciones trigonométricas (cos, tan, etc.) toman argumentos en radianes. Para convertir grados a radianes, se debe dividir por 180 y multiplicar por \(\pi\):

El valor de la variable π es una aproximación de punto flotante de \(\pi \), con una precisión de aproximadamente 16 dígitos.

Si sabe de trigonometría, puede verificar el resultado anterior comparándolo con la raíz cuadrada de dos dividido por dos:

Hasta ahora, hemos analizado los elementos de un programa (variables, expresiones y sentencias) de forma aislada, sin mencionar cómo se combinan.

Una de las características más útiles de los lenguajes de programación es su capacidad para combinar pequeños bloques de código. Por ejemplo, el argumento de una función puede ser cualquier tipo de expresión, incluidos operadores aritméticos:

E incluso llamadas a función:

Casi en cualquier lugar donde se pueda colocar un valor, se puede colocar una expresión arbitraria, con una excepción: el lado izquierdo de una sentencia de asignación debe ser un nombre de variable. Cualquier otra expresión en el lado izquierdo genera un error de sintaxis (se verán excepciones a esta regla más adelante).

(ERROR: sintaxis: "60" no es un nombre de argumento de función válido)

Hasta ahora, solo hemos usado las funciones integradas en Julia, pero también es posible agregar nuevas funciones. Una definición de función especifica el nombre de una nueva función y la secuencia de sentencias que se ejecutan cuando se llama a la función. A continuación se muestra un ejemplo:

function es una palabra reservada que indica que esta es una definición de función. El nombre de la función es imprimirletras. Las reglas para los nombres de funciones son las mismas que para los nombres de variables: pueden contener casi todos los caracteres Unicode (consulte Caracteres), pero el primer carácter no puede ser un número. No puede usar una palabra reservada como nombre de una función, y debe evitar tener una variable y una función con el mismo nombre.

Los paréntesis vacíos después del nombre indican que esta función no tiene argumentos.

La primera línea de una definición de función se llama encabezado; el resto se llama cuerpo. El cuerpo termina con la palabra reservada end y puede contener todas las sentencias que desee. Para facilitar la lectura, el cuerpo de la función debería tener sangría.

Las comillas deben ser "comillas rectas" (""), generalmente ubicadas junto a la tecla Enter en el teclado. Las "comillas inglesas" (“”)no son válidas en Julia.

Si escribe una definición de función en modo interactivo, Julia REPL inserta una sangría para informarle que la definición no está completa:

Para finalizar la función, debe escribir end.

La sintaxis para llamar a la nueva función es la misma que para las funciones integradas en Julia:

Una vez definida una función, puede usarla dentro de otra función. Por ejemplo, para repetir el estribillo anterior, se podría escribir una función llamada repetirletras:

Y luego llamar a repetirletras:

Al unir los fragmentos de código de la sección anterior, todo el programa se ve así:

Este programa contiene dos definiciones de función: imprimirletras y repetirletras. Las definiciones de función se ejecutan al igual que otras sentencias, pero su ejecución crea nuevas funciones. Las sentencias dentro de la función no se ejecutan hasta que se llama a la función, y la definición de la función no genera salida.

Como es de esperar, debe crear una función antes de poder ejecutarla. En otras palabras, la definición de la función tiene que ejecutarse antes de que se llame a la función.

Para asegurarse de que una función sea definida antes de su primer uso, debe conocer el orden en que se ejecutan las instrucciones, lo que se denomina flujo de ejecución.

La ejecución siempre comienza con la primera sentencia del programa. Las sentencias se ejecutan una a la vez, en orden descendente.

Las definiciones de función no alteran el flujo de ejecución del programa, pero se debe recordar que las sentencias dentro de la función no se ejecutan hasta que se llama a la función.

Una llamada a función es como un desvío en el flujo de ejecución. En lugar de pasar a la siguiente sentencia, el flujo salta al cuerpo de la función, ejecuta las sentencias que están allí y luego regresa para continuar el código donde lo dejó.

Esto suena bastante simple, hasta que se tiene en cuenta que una función puede llamar a otra. Mientras se está ejecutando una función, el programa podría tener que ejecutar las sentencias de otra función. Luego, mientras ejecuta esa nueva función, ¡el programa podría tener que ejecutar otra función más!

Afortunadamente, Julia es capaz de hacer el seguimiento de sus movimientos, así que cada vez que una función termina, el programa retoma la función que la llamó justo donde la dejó. Cuando llega al final del programa, la ejecución termina.

En resumen, cuando lee un programa, no siempre debe leer de arriba hacia abajo. A veces tiene más sentido seguir el flujo de ejecución.

Algunas de las funciones que se han visto requieren argumentos. Por ejemplo, la función cos necesita un número como argumento. Algunas funciones toman más de un argumento; por ejemplo parse toma dos: un número y una cadena.

Dentro de la función, los argumentos se asignan a variables llamadas parámetros. A continuación se muestra un ejemplo de definición de función que toma un argumento:

Esta función asigna el argumento a un parámetro llamado juan. Cuando se llama a la función, esta imprime el valor del parámetro (cualquiera que sea) dos veces.

Esta función funciona con cualquier valor que se pueda imprimir.

Las mismas reglas de composición que se aplican a las funciones integradas también se aplican a las funciones definidas por el programador, por lo que podemos usar cualquier tipo de expresión como argumento para imprimirdosveces:

El argumento se evalúa antes de llamar a la función, por lo que en los ejemplos las expresiones "Correo no deseado "^4 y cos(π) solo se evalúan una vez.

También puede usar una variable como argumento:

El nombre de la variable que pasamos como argumento (michael) no tiene nada que ver con el nombre del parámetro (juan). Para la función imprimirdosveces todos los parámetros se llaman juan, sin importar el nombre de la variable que pasemos como argumento (en este caso michael).

Cuando se crea una variable dentro de una función, esta es local, es decir, solo existe dentro de la función. Por ejemplo:

Esta función toma dos argumentos, los concatena e imprime el resultado dos veces. Aquí hay un ejemplo:

Cuando concatenar_dos termina, la variable concat es destruida. Si intentamos imprimirla, obtendremos un error:

Los parámetros también son locales. Por ejemplo, fuera de la función imprimirdosveces, no existe juan.

Para seguir la pista de qué variables se usan en qué lugares es útil dibujar un diagrama de pila. Al igual que los diagramas de estado, los diagramas de pila muestran el valor de cada variable, pero también muestran la función a la que pertenece cada una.

Cada función se representa por un marco. Un marco es un recuadro con el nombre de una función a un costado, y los parámetros y variables de la función dentro. El diagrama de pila para el ejemplo anterior se muestra en Diagrama de pila.

Los marcos se ordenan de tal manera que cada función llama a la función inmediatamente inferior. En este ejemplo, imprimirdosveces fue llamado por concatenar_dos, y concatenar_dos fue llamado por Main, que es un nombre especial para la función de más alto nivel. Cuando se crea una variable afuera de cualquier función, pertenece a Main.

Cada parámetro se refiere al mismo valor que su argumento correspondiente. Entonces, parte1 tiene el mismo valor que linea1, parte2 tiene el mismo valor que linea2, y juan tiene el mismo valor que concat.

Si se produce un error durante una llamada a función, Julia imprime el nombre de la función, el nombre de la función que la llamó, el nombre de la función que a su vez llamó a esta otra, y así sucesivamente hasta llegar a la función de más alto nivel Main.

Por ejemplo, si intenta acceder a concat desde imprimirdosveces, obtendrá un UndefVarError:

Esta lista de funciones se llama trazado inverso. Indica en qué archivo de programa se produjo el error, en qué línea y qué funciones se estaban ejecutando en ese momento. También muestra la línea de código que causó el error.

El orden de las funciones en el trazado inverso es el opuesto del orden de los recuadros en el diagrama de pila. La función que se está ejecutando actualmente está en la parte superior.

Algunas de las funciones que hemos utilizado, como las funciones matemáticas, devuelven resultados. A este tipo de funciones se les llamará funciones productivas, a falta de un nombre mejor. Otras funciones como imprimirdosveces, realizan una acción pero no devuelven un valor. Estas se llaman funciones nulas.

Cuando se llama a una función productiva, casi siempre se quiere hacer algo con el resultado; por ejemplo, asignarlo a una variable o usarlo como parte de una expresión:

Cuando se llama a una función en modo interactivo, Julia muestra el resultado:

Pero en un script, si se llama a una función productiva, ¡el valor de retorno se pierde para siempre!

Output:

Este script calcula la raíz cuadrada de 5, pero como no almacena ni muestra el resultado, no es muy útil.

Las funciones nulas pueden mostrar algo en la pantalla o tener algún otro efecto, pero no tienen un valor de retorno. Si asigna el resultado a una variable, obtendrá un valor especial llamado nothing (nada en inglés).

Para imprimir el valor nothing, debe usar la función show que es como la función print pero permite el valor nothing.

El valor nothing no es lo mismo que la cadena "nothing". Es un valor especial que tiene su propio tipo:

Las funciones que hemos escrito hasta ahora son nulas. Comenzaremos a escribir funciones productivas en unos pocos capítulos.

Puede que no esté claro por qué vale la pena dividir un programa en funciones. Hay varias razones:

Una de las habilidades más importantes que adquirirá es la depuración. Aunque puede ser frustrante, la depuración es una de las partes más intelectualmente gratificantes, desafiantes e interesantes de la programación.

La depuración puede ser vista como un trabajo de detective. El programador se enfrenta a pistas y tiene que inferir los procesos y eventos que generaron los resultados que ve.

La depuración también es como una ciencia experimental. Una vez que se tiene una idea de lo que está mal, se modifica el programa y se intenta nuevamente. Si la hipótesis era correcta, se puede predecir el resultado de la modificación y así estar un paso más cerca de un programa totalmente funcional. Si la hipótesis era incorrecta, se tiene que encontrar una nueva. Como Sherlock Holmes señaló:

Para algunas personas, la programación y la depuración son lo mismo. Es decir, la programación es el proceso de depurar gradualmente un programa hasta que haga lo que desea. Lo ideal es comenzar con un programa que funcione y hacer pequeñas modificaciones, depurándolas a medida que avanza.

Por ejemplo, Linux es un sistema operativo que contiene millones de líneas de código, pero comenzó como un programa simple que Linus Torvalds usó para explorar el chip Intel 80386. Según Larry Greenfield, "Uno de los proyectos anteriores de Linus fue un programa que cambiaría entre imprimir" AAAA "y" BBBB ". Esto luego evolucionó a Linux ". (The Linux Users'’ Guide Beta Version 1).

Un modulo es un archivo que contiene una colección de funciones relacionadas. Julia proporciona algunos módulos en su Biblioteca Estándar. Además, es posible agregar más funciones a una gran cantidad de paquetes (https://juliaobserver.com).

Los paquetes se pueden instalar en REPL ingresando al modo Pkg REPL con la tecla ].

Esto puede demorar un poco.

Antes de que podamos usar las funciones de un módulo, tenemos que importarlo con una sentencia using:

El módulo IntroAJulia proporciona una función llamada Turtle (tortuga en español) que crea un objeto Luxor.Turtle, el cual es asignado a una variable llamada 🐢 (\:turtle: TAB).

Una vez que crea una tortuga, puede llamar a una función para "moverla", y así hacer un dibujo con ella. Por ejemplo, para mover la tortuga hacia adelante (forward en inglés):

La palabra reservada @svg ejecuta una macro que dibuja una imagen SVG. Las macros son una característica importante pero avanzada de Julia.

Los argumentos de forward son la tortuga y una distancia en píxeles, por lo que el tamaño real depende de su pantalla.

También es posible hacer girar a la tortuga con la función turn. Los argumentos de esta función son la tortuga y un ángulo en grados.

Además, cada tortuga está sosteniendo un lápiz, que puede estar hacia arriba o hacia abajo; si el lápiz está hacia abajo, la tortuga deja un rastro cuando se mueve. Haciendo avanzar a la tortuga muestra el rastro dejado por la tortuga. Las funciones penup y pendown significan "lápiz hacia arriba" y "lápiz hacia abajo".

Para dibujar un ángulo recto, modifique la llamada a la macro:

Es probable que haya escrito algo como esto:

Se puede hacer lo mismo de manera más concisa con una sentencia for:

Este es el uso más simple de la sentencia for, aunque se verán más usos después. Ésto debería ser suficiente para reescribir su programa que dibuja un cuadrado. No continúe hasta que lo haga.

Aquí hay una sentencia for que dibuja un cuadrado:

La sintaxis de una sentencia for es similar a la definición de una función. Tiene un encabezado y un cuerpo que termina con la palabra reservada end. El cuerpo puede contener el número de sentencias que desee.

Una sentencia for también es llamada bucle porque el flujo de ejecución recorre el cuerpo y luego vuelve a la parte superior. En este caso, ejecuta el cuerpo cuatro veces.

Esta versión es en realidad un poco diferente del código anterior que dibujaba un cuadrado porque hace otro giro después de dibujar el último lado del cuadrado. El giro adicional lleva más tiempo, pero simplifica el código si se hace lo mismo en cada iteración del ciclo. Esta versión también tiene el efecto de dejar a la tortuga nuevamente en la posición inicial, mirando hacia la dirección inicial.

Los siguientes ejercicios usan tortugas. Son divertidos, pero también tienen un trasfondo. Mientras trabaja en ellos, piense cuál es ese trasfondo.

El primer ejercicio le pide que coloque el código que permite dibujar un cuadrado en una definición de función, y que luego llame a la función, pasando a turtle como parámetro. Aquí hay una solución:

Las sentencias más internas, forward y turn tienen doble sangría para mostrar que están dentro del bucle for, que a su vez está dentro de la definición de función.

Dentro de la función, t se refiere a la misma tortuga 🐢, entonces turn(t, -90) tiene el mismo efecto que turn(🐢, -90). En ese caso, ¿por qué no llamar al parámetro 🐢? La razón es que t puede ser cualquier tortuga, no solo 🐢, por lo que podríamos crear una segunda tortuga y pasarla como argumento a cuadrado:

Colocar una porción de código en una función se denomina encapsulación. Uno de los beneficios de la encapsulación es que al ponerle un nombre al código, esto sirve como una especie de documentación. Otra ventaja es que si reutiliza el código, ¡es más conciso llamar a una función dos veces que copiar y pegar el cuerpo!

El siguiente paso es agregar un parámetro lon a cuadrado. Aquí hay una solución:

Agregar un parámetro a una función se llama generalización porque hace que la función sea más general: en la versión anterior, el cuadrado siempre tenía el mismo tamaño; en esta versión puede ser de cualquier tamaño.

El siguiente paso también es una generalización. En vez de dibujar cuadrados, poligono dibuja polígonos regulares con cualquier número de lados. Aquí hay una solución:

Este ejemplo dibuja un polígono de 7 lados, con una longitud de 70 por lado.

El siguiente paso es escribir circulo, que toma un radio r como parámetro. Aquí hay una solución simple que usa poligono para dibujar un polígono de 50 lados:

La primera línea calcula la circunferencia de un círculo con radio \(r\) usando la fórmula \(2 \pi r\). n es el número de segmentos de línea de nuestra aproximación a un círculo, y lon es la longitud de cada segmento. Por lo tanto, polígono dibuja un polígono de 50 lados que se aproxima a un círculo de radio r.

Una limitante de esta solución es que n es constante, lo que significa que para círculos muy grandes, los segmentos de línea son demasiado largos, y para círculos pequeños, perdemos tiempo dibujando segmentos muy pequeños. Una solución sería generalizar la función tomando n como parámetro. Esto le daría al usuario (quien llama a círculo) más control pero la interfaz sería menos pulcra.

La interfaz de una función es un resumen de cómo se usa: ¿cuáles son los parámetros? ¿Qué hace la función? ¿Y cuál es el valor de retorno? Una interfaz es "pulcra" si le permite al usuario que la llama hacer lo que quiera sin tener que lidiar con detalles innecesarios.

En este ejemplo, r pertenece a la interfaz porque especifica el círculo a dibujar. n es menos apropiado porque se refiere a los detalles de cómo se debe representar el círculo.

En lugar de saturar la interfaz, es mejor elegir un valor apropiado de n dependiendo de la circunferencia:

Ahora, el número de segmentos es un número entero cercano a circunferencia/3, por lo que la longitud de cada segmento es aproximadamente 3, que es lo suficientemente pequeño como para que los círculos se vean bien, pero lo suficientemente grandes como para ser eficientes y aceptables para cualquier círculo.

Agregar 3 a n garantiza que el polígono tenga al menos 3 lados.

Cuando se escribió circulo, se pudo reutilizar poligono ya que un polígono de muchos lados es una buena aproximación de un círculo. Pero arco no es tan versátil; no se puede usar poligono o circulo para dibujar un arco.

Una alternativa es comenzar con una copia de poligono y transformarla en arco. El resultado podría verse así:

La segunda mitad de esta función se parece a poligono, pero no se puede reutilizar poligono sin cambiar la interfaz. Se podría generalizar poligono para tomar un angulo como tercer argumento, ¡pero entonces poligono ya no sería un nombre apropiado! En su lugar, se puede llamar a esta función más general polilinea:

Ahora se puede reescribir poligono y arco usando polilinea:

Finalmente, se puede reescribir circulo usando arco:

Este proceso, que reorganiza un programa para mejorar las interfaces y facilitar la reutilización del código, se denomina refactorización. En este caso, se observa que había un código similar en arco y poligono, por lo que lo "factorizamos" en polilinea. (refactorización

Si se hubiese planeado con anticipación, se podría haber escrito polilinea primero y haber evitado la refactorización, pero a menudo no se sabe lo suficiente al comienzo de un proyecto para diseñar todas las interfaces. Una vez que se comienza a programar, se comprende mejor el problema. A veces, refactorizar es una señal de que se ha aprendido algo.

Un plan de desarrollo de programa es un proceso para escribir programas. El proceso que se utiliza en este estudio de caso es "encapsulación y generalización". Los pasos de este proceso son:

Este proceso tiene algunos inconvenientes, se explorarán alternativas más adelante, pero puede ser útil si no sabe de antemano cómo dividir el programa en funciones. Este enfoque permite diseñar conforme se avanza.

Un docstring es una cadena que va antes de una función y que explica la interfaz ("doc" es la abreviatura de "documentación"). Aquí hay un ejemplo:

Se puede acceder a la documentación en REPL o en un notebook escribiendo ? seguido del nombre de una función o macro, y presionando ENTER:

Los docstring generalmente son cadenas de comillas triples, también conocidas como cadenas de líneas múltiples ya que las comillas triples permiten que la cadena abarque más de una línea.

Un docstring contiene la información esencial que alguien necesitaría para usar esta función. Explica de manera concisa lo que hace la función (sin entrar en detalles sobre cómo lo hace). Explica qué efecto tiene cada parámetro en el comportamiento de la función y de qué tipo debe ser cada parámetro (si no es obvio).

Una interfaz es como un contrato entre una función y el usuario. El usuario acepta proporcionar ciertos parámetros y la función acepta hacer cierto trabajo.

Por ejemplo, polilinea requiere cuatro argumentos: t tiene que ser una tortuga; n tiene que ser un número entero; lon debería ser un número positivo; y angulo tiene que ser un número, en grados.

Estos requisitos se llaman precondiciones porque se supone que son verdaderos antes de que la función comience a ejecutarse. Por el contrario, las condiciones al final de la función son postcondiciones. Las postcondiciones incluyen el efecto deseado de la función (como dibujar segmentos de línea) y cualquier efecto secundario (como mover la tortuga o hacer otros cambios).

Las condiciones previas son responsabilidad del usuario. Si el usuario viola una precondición (¡debidamente documentada!) y la función no funciona correctamente, el error está en el usuario, no en la función.

Si se cumplen las precondiciones pero no las postcondiciones, el error está en la función. Si sus pre y postcondiciones son claras, pueden ayudar con la depuración.

El operador división entera, ÷ (\div TAB), divide dos números y redondea hacia abajo el resultado. Por ejemplo, suponga que la duración de una película es de 105 minutos. Es posible que desee saber la duración en horas. La división convencional devuelve un número de punto flotante:

No obstante, las horas no se suelen escribir con decimales. La división entera devuelve el número entero de horas, redondeado hacia abajo:

Para obtener el resto de la división, se puede restar una hora (en minutos) a la duración total de la película:

Otra alternativa es usar el operador módulo, %, que divide dos números y devuelve el resto.

Una expresión booleana es una expresión que es verdadera o falsa. Los siguientes ejemplos usan el operador ==, que compara dos operandos, y devuelve el valor true (verdadero en español) si son iguales, y el valor false (falso) de lo contrario.

true y false son valores especiales que pertenecen al tipo Bool, no son cadenas:

El operador == es un operador relacional. El resto de operadores relacionales son:

Hay tres operadores lógicos: && (y), || (o) y ! (no). La semántica (significado) de estos operadores es similar a su significado en español. Por ejemplo, x>0 && x<10 es verdadero solo si x es mayor que 0 y menor que 10.

n%2==0 || n%3 == 0 es verdadero si una o ambas condiciones son verdaderas, es decir, si el número es divisible por 2 o por 3.

Tanto && como || se asocian en primer lugar con el objeto a su derecha, pero && tiene preferencia por sobre ||.

Finalmente, el operador ! niega una expresión booleana, entonces !(x>y) es verdadero si x>y es falso, es decir, si x es menor o igual que y.

Para escribir programas útiles, generalmente se necesita verificar condiciones y cambiar el comportamiento del programa acorde a ellas. Las sentencias condicionales permiten llevar esto a cabo. La forma más simple es la sentencia if ("si" en inglés):

La expresión booleana después de if se llama condición. Si es verdadera, se ejecuta la instrucción con sangría. Si no, nada ocurre.

Las sentencias if tienen la misma estructura que las definiciones de función: un encabezado seguido del cuerpo, terminado con la palabra reservada end (en español "fin"). Las sentencias como esta se denominan sentencias compuestas.

No hay límite en el número de sentencias que pueden aparecer en el cuerpo. A veces es útil tener un cuerpo sin sentencias (por lo general, como un marcador de posición para el código que aún no se ha escrito).

Una segunda forma de la sentencia if es la "ejecución alternativa", en la que hay dos posibilidades y la condición determina cuál se ejecuta. La sintaxis se ve así:

Si el resto de x dividido por 2 es 0, entonces x es par y el programa muestra un mensaje acorde. Si la condición es falsa, se ejecuta el segundo conjunto de sentencias. Como la condición debe ser verdadera o falsa, se ejecutará exactamente una de las alternativas. Las alternativas se llaman ramas, porque son ramas en el flujo de ejecución.

A veces hay más de dos posibilidades y se necesitan más de dos ramas. Una manera de expresar este cómputo es a través de una condicional encadenada:

De nuevo, sólo se ejecutará una rama. No hay límite al número de sentencias elseif. Si hay una sentencia else, debe estar al final (aunque no es necesario que esté).

Cada condición se comprueba en orden. Si la primera es falsa, se comprueba la siguiente, y así se sigue con las demás. Si una de ellas es verdadera, se ejecuta la rama correspondiente y la sentencia se termina. Si es verdadera más de una condición, sólo se ejecuta la primera rama verdadera.

Una condicional puede estar anidada ("nested" en inglés) dentro de otra. Podríamos haber escrito el ejemplo de la sección anterior de la siguiente manera:

La condicional externa contiene dos ramas. La primera rama contiene una sentencia simple. La segunda rama contiene otra sentencia if, que tiene dos ramas propias. Estas dos ramas son ambas sentencias simples, aunque podrían ser sentencias condicionales.

Aunque la sangría no obligatoria de las sentencias hace evidente su estructura, las condicionales anidadas muy pronto se vuelven difíciles de leer. Se recomienda evitarlas cuando pueda.

Los operadores lógicos a menudo proporcionan una forma de simplificar las sentencias condicionales anidadas. Por ejemplo, es posible reescribir el siguiente código usando un solo condicional:

La sentencia print sólo se ejecuta si conseguimos superar ambas condicionales, de modo que se puede obtener el mismo efecto con el operador &&:

Para este tipo de condición, Julia proporciona una sintaxis más concisa:

Está permitido que una función llame a otra y también que una función se llame a sí misma. Puede no parecer útil, pero sí lo es, como puede verse en la siguiente función:

Si n es 0 o negativo, muestra la palabra "Despegue!". En otro caso, muestra el valor n y luego llama a la función cuentaregresiva, pasándole n-1 como argumento.

¿Qué sucede si llamamos a una función como esta?

La ejecución de cuentaregresiva empieza con n = 3, y como n es mayor que 0, muestra el valor 3, y luego se llama a sí misma…​

 La ejecución de cuentaregresiva empieza con n = 2, y como n es mayor que 0,
  muestra el valor 2, y luego se llama a sí misma…​

  La ejecución de cuentaregresiva empieza con n = 1, y como n es mayor que 0,
   muestra el valor 1, y luego se llama a sí misma…​

   La ejecución de cuentaregresiva empieza con n = 0, y como n no es mayor que 0,
    muestra la palabra "Despegue!" y luego termina.

  La cuentaregresiva cuyo argumento es n = 1 termina.

 La cuentaregresiva cuyo argumento es n = 2 termina.

La cuentaregresiva cuyo argumento es n = 3 termina.

Y volvemos a Main.

Una función que se llama a sí misma es una función recursiva y el proceso de ejecución se llama recursividad.

Como otro ejemplo, se puede escribir una función que imprima una cadena \(n\) veces.

Si n <= 0, se usa la sentencia return para salir de la función. El flujo de la ejecución vuelve inmediatamente a la sentencia de llamada a función y no se ejecutan las líneas restantes de la función.

El resto de la función es similar a cuenta regresiva: muestra s y luego se llama a sí misma para mostrar s \(n-1\) veces más de modo que el número de lineas mostradas es \(1 + (n - 1)\), es decir \(n\).

Para ejemplos simples como este, es más fácil usar un ciclo for. Se mostrarán ejemplos que son difíciles de escribir con un ciclo for y fáciles de escribir con recursividad.

En Diagramas de pila se usó un diagrama de pila para representar el estado de un programa durante una llamada de función. El mismo tipo de diagrama puede ser de utilidad para interpretar una función recursiva.

Cada vez que se llama a una función, Julia crea un marco que contiene las variables locales de la función y los parámetros. En una función recursiva, puede haber más de un marco en el diagrama de pila al mismo tiempo.

Diagrama de pila muestra un diagrama de pila para cuentaregresiva utilizando n=3.

Como siempre, la parte superior de la pila es el marco para Main. Está vacío pues no se crearon variables en Main ni tampoco se pasaron argumentos.

Los cuatro marcos de cuentaregresiva tienen diferentes valores del parámetro n. La parte inferior del diagrama de pila, donde n = 0, es llamado caso base. No hace una llamada recursiva, así que no hay más marcos.

Si una recursión nunca alcanza un caso base, continúa haciendo llamadas recursivas para siempre y el programa nunca termina. Esto se conoce como recursión infinita y generalmente no es una buena idea. Aquí hay un código con una recursión infinita:

En la mayoría de los entornos de programación, un programa con recursión infinita realmente no se ejecuta para siempre. Julia entrega un mensaje de error cuando se alcanza la profundidad de recursión máxima:

Este stacktrace es un poco más grande que el que vimos en el capítulo anterior. Cuando se produce el error, ¡hay 80000 marcos de recursion en el diagrama de pila!

Si por accidente encuentra una recursión infinita en su código, revise su función para confirmar que hay un caso base que no realiza una llamada recursiva. Si hay un caso base, verifique si realmente puede ocurrir.

Los programas que se han escrito hasta ahora no aceptan entradas del usuario. Simplemente hacen lo mismo cada vez.

Julia tiene una función incorporada llamada readline que detiene el programa y espera a que el usuario escriba algo. Cuando el usuario presiona RETURN o ENTER, el programa se reanuda y readline devuelve lo que el usuario escribió como una cadena.

Antes de recibir una entrada por teclado del usuario, es una buena idea imprimir un mensaje que le diga al usuario qué escribir:

Un punto y coma ; permite colocar varias sentencias en la misma línea. En el REPL solo la última sentencia devuelve su valor.

Si espera que el usuario escriba un número entero, puede intentar convertir el valor de retorno a Int64:

Pero si el usuario no escribe una cadena de dígitos, obtendrá un error:

Veremos qué hacer con este tipo de error más adelante.

Cuando se produce un error de sintaxis o de tiempo de ejecución, el mensaje de error contiene mucha información, lo cual puede ser abrumador. Las partes más útiles suelen ser:

Los errores de sintaxis suelen ser fáciles de encontrar y hay algunos trucos. En general, los mensajes de error indican dónde se descubrió el problema pero el error real podría estar antes en el código, a veces en una línea anterior.

Lo mismo aplica para los errores de tiempo de ejecución. Suponga que está tratando de calcular una relación señal/ruido en decibelios. La fórmula es

En Julia, se podría escribir algo como esto:

Obteniendo:

Este no es el resultado que esperábamos.

Para encontrar el error, puede ser útil imprimir el valor de la variable "relacion", que resulta ser 0. El problema está en la línea 3, que usa la división entera en lugar de la división de punto flotante.

Llamar a una función genera un valor de retorno, que generalmente se asigna a una variable o se usa como parte de una expresión.

Las funciones que se han escrito hasta ahora son nulas. Coloquialmente hablando, no tienen valor de retorno; de manera formal, su valor de retorno es nothing. En este capítulo, (finalmente) se van a escribir funciones productivas. El primer ejemplo es area, que devuelve el área de un círculo dado un radio:

Se ha visto la sentencia return antes pero en una función productiva la sentencia return incluye una expresión. Esta sentencia significa: "Retorne inmediatamente de esta función y use la siguiente expresión como valor de retorno". La expresión dada puede ser arbitrariamente complicada. Así pues, se podría haber escrito esta función más concisamente:

El valor devuelto por una función es el valor de la última expresión evaluada, que, por defecto, es la última expresión en el cuerpo de la definición de la función.

Por otro lado, las variables temporales como a, y las sentencias return explícitas pueden facilitar la depuración.

A veces es útil tener múltiples sentencias return, una en cada rama de una sentencia condicional:

Dado que estas sentencias return están en una condicional alternativa, solo se ejecuta una.

En cuanto se ejecuta una sentencia return, la función termina sin ejecutar ninguna de las sentencias siguientes. El código que aparece después de la sentencia return, o en cualquier otro lugar al que el flujo de ejecución nunca llegará, se llama código muerto.

En una función productiva, es una buena idea asegurarse que cualquier posible recorrido del programa llegue a una sentencia return. Por ejemplo:

Esta versión no es correcta porque si x es igual a 0, ninguna de las condiciones es verdadera y la función termina sin alcanzar una sentencia return. Si el flujo de ejecución llega al final de la función, el valor de retorno es nothing, que claramente no es el valor absoluto de 0.

Conforme vaya escribiendo funciones más extensas puede empezar a dedicar más tiempo a la depuración.

Para lidiar con programas de complejidad creciente, se sugiere una técnica llamada desarrollo incremental. El objetivo del desarrollo incremental es evitar largas sesiones de depuración, añadiendo y probando solamente pequeñas porciones de código cada vez.

Por ejemplo, suponga que desea encontrar la distancia entre dos puntos dados por las coordenadas \(\left(x_1, y_1\right)\) y \(\left(x_2, y_2\right)\). Por el teorema de Pitágoras, la distancia es:

El primer paso es considerar qué aspecto tendría la función distancia en Julia. En otras palabras, ¿cuáles son las entradas (parámetros) y cuál es la salida (valor de retorno)?

En este caso las entradas son los dos puntos, que se pueden representar usando cuatro números. El valor devuelto es la distancia, que es un número de punto flotante.

He aquí una primera versión de la función:

Obviamente esta versión de la función no calcula distancias sino que siempre devuelve cero. Aun así, es correcta sintácticamente hablando y se ejecutará, lo que implica que se puede probar antes de hacerla más compleja. Los números de subíndice están disponibles en la codificación de caracteres Unicode (\_1 TAB, \_2 TAB, etc.).

Para probar la nueva función, se llama con una muestra de valores:

Se eligen estos valores de tal forma que la distancia horizontal sea igual a 3 y la distancia vertical sea igual a 4 y de esa manera el resultado es 5 (la hipotenusa del triángulo 3-4-5). Cuando se comprueba una función, es útil conocer la respuesta correcta.

Hasta el momento se ha podido confirmar que la función es sintácticamente correcta, por lo que se puede empezar a agregar líneas de código. El paso lógico siguiente es encontrar las diferencias \(x_2 - x_1\) y \(y_2 - y_1\). En la siguiente versión de la función se almacenarán estos valores en variables temporales y se mostrarán con el macro @show.

Si la función trabaja bien, las salidas deben ser dx = 3 y dy = 4. Si es así, se sabe que la función está obteniendo los parámetros correctos y realizando el primer cálculo correctamente. Si no, entonces sólo hay unas pocas líneas que revisar.

A continuación se calcula la suma de los cuadrados de dx y dy:

De nuevo se quiere ejecutar el programa en esta etapa y comprobar la salida (que debería ser 25). Los números en superíndice también están disponibles (\^2 TAB). Finalmente, se puede usar sqrt para calcular y devolver el resultado:

Si esto funciona correctamente, ya se habría terminado. Si no, se podría mostrar el valor de la variable resultado antes de la sentencia de retorno.

La versión final de la función no muestra nada cuando se ejecuta, sólo retorna un valor. Las sentencias print son útiles para la depuración, pero una vez que el programa esté funcionando correctamente, se deben eliminar. El código eliminado se llama andamiaje porque es útil para construir el programa pero no es parte del producto final.

Al principio, debería añadir solamente una o dos líneas de código cada vez. Conforme vaya ganando experiencia, puede que se encuentre escribiendo y depurando fragmentos mayores de código. Sin embargo, el proceso de desarrollo incremental puede ahorrarle mucho tiempo de depuración.

Los aspectos clave del proceso son:

Ahora, como usted esperaría, se puede llamar a una función desde otra. Como ejemplo, se escribe una función que tome dos puntos, el centro del círculo y un punto del perímetro, y calcule el área del círculo.

Suponga que el punto central está almacenado en las variables xc y yc, y que el punto del perímetro lo está en xp y yp. El primer paso es hallar el radio del círculo, que es la distancia entre los dos puntos. La función distancia que realiza esta tarea sería:

El siguiente paso es encontrar el área del círculo usando este radio. De nuevo se usa una de las funciones definidas previamente:

Envolviendo todo en una función, se obtiene:

Las variables temporales radio y resultado son útiles para el desarrollo y la depuración, pero una vez que el programa está funcionando, se puede hacer más conciso componiendo las llamadas a función:

Las funciones pueden devolver valores booleanos, lo que a menudo es conveniente para ocultar complicadas comprobaciones dentro de funciones. Por ejemplo:

Es común dar a las funciones booleanas nombres que suenan como preguntas que tienen como respuesta un si ó un no, esdivisible devuelve true o false para indicar si x es o no divisible por y.

Por ejemplo:

El resultado del operador == es booleano, por lo tanto se puede escribir la función de una manera más concisa devolviendo el resultado directamente:

Las funciones booleanas se usan a menudo en las sentencias condicionales:

Puede parecer tentador escribir algo como:

pero la comparación extra con true es innecesaria.

Solo se ha cubierto una pequeña parte de Julia pero le puede interesar saber que esta parte ya es un lenguaje de programación completo, lo que significa que cualquier cómputo puede expresarse en este lenguaje. Cualquier programa que se haya escrito podría reescribirse usando solo lo que ha aprendido hasta ahora (en realidad, necesitaría algunos comandos para controlar dispositivos como el mouse, discos, etc., pero eso es todo).

Probar esta afirmación es un ejercicio no trivial realizado por primera vez por Alan Turing, uno de los primeros científicos de la computación (algunos argumentarían que era matemático, pero muchos de los primeros científicos informáticos comenzaron como matemáticos). En consecuencia, esto se conoce como la Tesis de Turing. Para una discusión más completa (y precisa) de la Tesis de Turing, se recomienda el libro de Michael Sipser Introducción a la Teoría de la Computación.

Para darle una idea de lo que puede hacer con las herramientas que ha aprendido hasta ahora, se evalúan algunas funciones matemáticas definidas recursivamente. Una definición recursiva es similar a una definición circular, en el sentido de que la definición contiene una referencia a lo que está siendo definido. Una definición verdaderamente circular no es muy útil:

Si esta definición apareciese en el diccionario, la persona que la leyera podría molestarse. Por otro lado, si se busca la definición de la función factorial, denotada con el símbolo \(!\), se encuentra encontrar algo como esto:

Esta definición dice que el factorial de 0 es 1, y el factorial de cualquier otro valor \(n\), es \(n\) multiplicado por el factorial de \(n-1\).

Entonces \(3!\) es 3 veces \(2!\), que es 2 veces \(1!\), que es 1 vez \(0!\). Es decir, \(3!\) es igual a 3 por 2 por 1 por 1, que es 6.

Si se puede escribir una definición recursiva, se puede escribir un programa de Julia para evaluarlo. El primer paso es decidir cuáles deberían ser los parámetros. En este caso, debe quedar claro que factorial toma valores enteros:

Si el argumento es 0, la función debe devolver 1:

De lo contrario, y esto es lo interesante, se tiene que hacer una llamada recursiva para encontrar el factorial de n-1 y luego multiplicarlo por n:

El flujo de ejecución de este programa es similar al flujo de cuentaregresiva en Recursividad. Si llamamos a fact con el valor 3:

Diagrama de pila muestra cómo se ve el diagrama de pila para esta secuencia de llamadas a funciones.

Los valores de retorno se pasan de nuevo a la pila. En cada marco, el valor de retorno es el valor de resultado, que es el producto de n y recursion.

En el último marco, las variables locales recursion y resultado no existen, porque la rama que las crea no se ejecuta.

Seguir el flujo de ejecución es una forma de leer programas, pero puede llegar a ser abrumador. Una alternativa es lo que se conoce como el "voto de confianza"(en inglés, "leap of faith"). Cuando llega a una llamada de función, en lugar de seguir el flujo de ejecución, asume que la función funciona correctamente y devuelve el resultado correcto.

De hecho, ya se está dando este voto de confianza cuando se usan funciones integradas de Julia. Cuando se llaman a cos o exp, no se examinan los cuerpos de esas funciones. Simplemente se asume que funcionan porque las personas que las escribieron eran buenos programadores.

Lo mismo ocurre cuando el usuario llama a una de sus propias funciones. Por ejemplo, en Funciones Booleanas, se escribe una función llamada esdivisible que determina si un número es divisible por otro. Una vez que se confirme que esta función es correcta —al examinar y probar el código—, se puede usar la función sin mirar nuevamente el cuerpo.

Lo mismo aplica a los programas recursivos. Cuando llegue a la llamada recursiva, en lugar de seguir el flujo de ejecución, debe suponer que la llamada recursiva funciona (devuelve el resultado correcto) y luego preguntarse: "Suponiendo que pueda encontrar el factorial de \(n-1\), ¿se puede calcular el factorial de \(n\)?" Está claro que es posible, multiplicando por \(n\).

Por supuesto, es un poco extraño suponer que la función funciona correctamente cuando no ha terminado de escribirla, ¡pero por eso se llama voto de confianza!

Después de los factoriales, el ejemplo más común de una función matemática definida de manera recursiva es fibonacci, que tiene la siguiente definición (ver https://en.wikipedia.org/wiki/Fibonacci_number):

Traducido a Julia, se ve así:

Si intenta seguir el flujo de ejecución en esta función, incluso para valores bastante pequeños de n, su cabeza podría estallar. Dando un voto de confianza, es decir, asumiendo que las dos llamadas recursivas funcionan correctamente, entonces está claro que se obtiene el resultado correcto al sumarlas.

¿Qué pasa si se llama a fact con 1.5 como argumento?

Parece una recursión infinita. ¿Como es esto posible? La función tiene un caso base (cuando n == 0). Pero si n no es un número entero, es posible perderse el caso base y hacer recursión para siempre.

En la primera llamada recursiva, el valor de n es 0.5. En la siguiente, es -0.5. A partir de ahí, se vuelve más pequeño (más negativo), pero nunca será 0.

Existen dos opciones. Se puede intentar generalizar la función factorial para trabajar con números de punto flotante, o se puede hacer que fact verifique el tipo del argumento. La primera opción se llama función gamma y está un poco más allá del alcance de este libro. En este libro se proseguirá con la segunda.

Se puede usar el operador integrado isa para verificar el tipo de argumento. También podemos asegurarnos de que el argumento sea positivo:

El primer caso base se hace cargo de números no enteros y el segundo de enteros negativos. En ambos casos, el programa imprime un mensaje de error y devuelve nothing para indicar que algo salió mal:

Si se superan ambas verificaciones, se sabe que n es positivo o cero, por lo que es posible probar que la recursión termina.

Este programa muestra un patrón a veces llamado guardian. Los dos primeros condicionales actúan como guardianes, protegiendo el código que sigue de los valores que pueden causar un error. Los guardianes hacen posible demostrar que el código es correcto.

En Captura de Excepciones se explorará una alternativa más flexible para imprimir un mensaje de error: generar una excepción.

Dividir un código extenso en pequeñas funciones crea naturalmente puntos de control para la depuración. Si un programa no está funcionando, existen tres posibilidades a considerar:

Para descartar la primera posibilidad, puede agregar una sentencia de impresión al comienzo de la función para mostrar los valores de los parámetros (y tal vez sus tipos) o bien escribir líneas de código que verifiquen las condiciones previas de manera explícita.

Si los parámetros están bien, agregue una sentencia de impresión antes de cada sentencia return y muestre el valor de retorno. Si es posible, verifique el resultado a mano. Considere también llamar a la función con valores que faciliten la verificación del resultado (como en Desarrollo incremental).

Si la función parece estar funcionando, revise la llamada a la función para asegurarse de que el valor de retorno se está utilizando correctamente (¡o incluso si se está utilizando!).

Agregar sentencias de impresión al principio y al final de una función puede ayudar a que el flujo de ejecución sea más transparente. Por ejemplo, aquí hay una versión de fact con sentencias de impresión:

espacio es una cadena de caracteres de espacios que permite generar sangría en la salida:

Si está confundido con el flujo de ejecución, este tipo de salida puede ser útil. Desarrollar un buen andamiaje toma tiempo, pero un poco de andamiaje puede ahorrar al usuario mucha depuración.

Puede que ya haya descubierto que está permitido realizar más de una asignación a la misma variable. Una nueva asignación hace que la variable existente se refiera a un nuevo valor (y deje de referirse al viejo valor).

La primera vez que se muestra x su valor es 5, y la segunda vez su valor es 7

Diagrama de estado muestra el aspecto de una asignación múltiple en un diagrama de estado.

Es necesario aclarar algo que puede causar confusión. Puesto que Julia usa el signo igual (=) para la asignación, es tentador interpretar una sentencia a = b como una sentencia de igualdad. Pero esta interpretación es incorrecta.

Para empezar, la igualdad es simétrica y la asignación no lo es. Por ejemplo, en matemáticas, si \(a=7\) entonces \(7=a\). Pero en Julia la sentencia a = 7 es válida, y 7 = a no lo es.

Además, en matemáticas, una sentencia de igualdad es verdadera o falsa siempre. Si \(a=b\) ahora, entonces \(a\) siempre será igual a \(b\). En Julia, una sentencia de asignación puede hacer que dos variables sean iguales, pero no tienen por qué quedarse así:

La tercera línea cambia el valor de a pero no cambia el valor de b, por lo tanto ya dejan de ser iguales.

Una de las formas más comunes de asignación múltiple es la actualización, dónde el nuevo valor de la variable depende del anterior.

Esto significa “tome el valor actual de x, súmele uno, y después actualice x con el nuevo valor.”

Si intenta actualizar una variable que no existe obtendrá un error, puesto que Julia evalúa la expresión del lado derecho antes de asignar un valor a x:

Antes de actualizar una variable tiene que inicializarla, usualmente con una asignación simple:

Actualizar una variable sumándole 1 se denomina un incremento y restándole 1 se llama un decremento.

Las computadoras se usan a menudo para automatizar tareas repetitivas. Realizar repetidamente tareas idénticas o similares sin cometer errores es algo que las computadoras hacen bien y que los seres humanos hacen limitadamente. La ejecución repetida de un conjunto de sentencias se llama iteración.

Ya se han visto dos funciones, cuentaregresiva y printn, que iteran usando recursividad. Por ser la iteración tan común, Julia proporciona varias características que la hacen más fácil. Una es la sentencia for que se vio en Repetición Simple, a la cual se volverá más adelante.

Otra característica es la sentencia while. Aquí hay una versión de cuentaregresiva que muestra el uso de la sentencia while:

Casi podría leer la sentencia while como si fuera Español. La función anterior significa: “Mientras n sea mayor que 0, continúe mostrando el valor de n y luego reduciendo el valor de n en 1. Cuando llegue a 0, muestre la palabra ¡Despegue!“

Más formalmente, el flujo de ejecución de una sentencia while es el siguiente:

Este tipo de flujo se llama bucle porque el tercer paso vuelve a la parte superior.

El cuerpo del bucle debería cambiar el valor de una o más variables de manera que, en algún momento, la condición sea falsa y el bucle termine. En caso contrario, el bucle se repetirá indefinidamente, lo cual se llama bucle infinito. Una interminable fuente de diversión para los informáticos es la observación de que las instrucciones del champú “Enjabone, enjuague, repita”, son un bucle infinito.

En el caso de cuentaregresiva, podemos probar que el bucle termina: si n es cero o negativo, el ciclo termina. En otro caso, el valor de n se hace más pequeño cada vez que pasa por el bucle, así en cierto momento se llega a 0.

En otros casos no es tan fácil decirlo. Por ejemplo:

La condición de este bucle es n != 1, de manera que el bucle continuará hasta que n sea 1, que hará que la condición sea falsa.

Cada vez que pasa por el bucle, el programa muestra como salida el valor de n y luego comprueba si es par o impar. Si es par, el valor de n se divide por dos. Si es impar, el valor de n se sustituye por n*3 + 1. Por ejemplo, si el argumento pasado a la función seq es 3, los valores resultantes n son 3, 10, 5, 16, 8, 4, 2, 1.

Puesto que n a veces aumenta y a veces disminuye, no hay una prueba obvia de que n alcance alguna vez el valor 1, o de que el programa vaya a terminar. Para algunos valores particulares de n, se puede probar que sí termina. Por ejemplo, si el valor de inicio es una potencia de dos, entonces el valor de n será par cada vez que se pasa por el bucle, hasta que llegue a 1. El ejemplo anterior produce dicha secuencia si se inicia con 16.

Lo díficil es preguntarse si se puede probar que este programa termina para todos los valores positivos de n. Hasta ahora, nadie ha sido capaz de probar que lo hace o ¡que no lo hace! (Vea https://es.wikipedia.org/wiki/Conjetura_de_Collatz.)

A veces no se sabe que un ciclo debe terminar hasta que se llega al cuerpo. En ese caso, se puede usar la sentencia break para salir del bucle.

Por ejemplo, suponga que se desea recibir entradas del usuario hasta que este escriba "listo". Podríamos escribir:

La condición del bucle es true, que siempre es verdadero, por lo que el bucle se ejecuta hasta que llega a la sentencia break.

En cada iteración, se le pide al usuario (con el símbolo "> ") una entrada. Si el usuario escribe listo, la sentencia break sale del bucle. De lo contrario, el programa repite lo que escriba el usuario y vuelve a la parte superior del bucle. A continuación se muestra cómo funciona este programa:

Esta forma de escribir bucles while es común porque permite verificar la condición en cualquier parte del bucle (no solo en la parte superior) y puede expresar la condición de término de manera afirmativa ("detenerse cuando esto suceda"), en vez de negativamente ("continuar hasta que esto suceda").

La sentencia break permite terminar el bucle. Cuando aparece una sentencia continue dentro de un bucle, se regresa al comienzo del bucle, ignorando todos las sentencias que quedan en la iteración actual del bucle e inicia la siguiente iteración. Por ejemplo:

Output:

Si i es divisible por 3, la sentencia continue detiene la iteración actual y comienza la siguiente iteración. Solo se imprimen los números en el rango de 1 a 10 no divisibles por 3.

Los bucles son comúnmente utilizados en programas que calculan resultados numéricos y que comienzan con una respuesta aproximada que es iterativamente mejorada.

Por ejemplo, una forma de calcular raíces cuadradas es el método de Newton. Suponga que desea conocer la raíz cuadrada de \(a\). Si comienza con casi cualquier estimación \(x\), puede calcular una mejor aproximación con la siguiente fórmula:

Por ejemplo, si \(a\) es 4 y \(x\) es 3:

El resultado está más cerca de la respuesta correcta (\(\sqrt 4 = 2\)). Si se repite el proceso con la nueva estimación, se acerca aún más:

Después de algunas actualizaciones, la estimación es casi exacta:

En general, no se sabe de antemano cuántos pasos se necesitan para llegar a la respuesta correcta, pero se sabe que se ha llegado a ella cuando la estimación deja de cambiar:

Cuando y == x, ya se pueden detener los cómputos. A continuación se muestra un ciclo que comienza con una estimación inicial, x, la cual mejora hasta que deja de cambiar:

Para la mayoría de los valores de a esto funciona bien, aunque en general no se recomienda probar igualdad entre números de punto flotante. Los números de punto flotante son aproximadamente correctos: la mayoría de los números racionales, como \(\frac{1}{3}\), e irracionales, como \(\sqrt 2\), no pueden ser representados exactamente con un Float64.

En lugar de verificar si x e y son exactamente iguales, es más seguro usar la función integrada abs para calcular el valor absoluto o la magnitud de la diferencia entre ellos:

Donde ε (\varepsilon TAB) toma un valor como 0.0000001 que determina cómo de cerca es suficientemente cerca.

El método de Newton es un ejemplo de un algoritmo, un proceso mecánico que permite resolver una categoría de problemas (en este caso, el cálculo de raíces cuadradas).

Para comprender qué es un algoritmo, podría ayudar empezar con algo que no es un algoritmo. Cuando aprendió a multiplicar números de un solo dígito, probablemente memorizó la tabla de multiplicar. En efecto, memorizó 100 soluciones específicas. Ese tipo de conocimiento no es un algoritmo.

Pero si fuera "perezoso", podría haber aprendido algunos trucos. Por ejemplo, para encontrar el producto de \(n\) y 9, puede escribir \(n-1\) como el primer dígito y \(10-n\) como el segundo dígito. Este truco es una solución general para multiplicar cualquier número de un solo dígito por 9. ¡Esto sí es un algoritmo!

Del mismo modo, las técnicas que aprendió para la suma con “llevamos tanto”, la resta con “pedimos prestado tanto”, y la división “larga o con galera o de casita” son todas ellas algoritmos. Una de las características de los algoritmos es que no requieren inteligencia para realizarlos. Son procesos mecánicos donde cada paso se sigue de acuerdo con un conjunto simple de reglas.

Ejecutar algoritmos es aburrido, pero diseñarlos es interesante, intelectualmente desafiante y constituyen una parte central de la informática.

Algunas de las cosas que las personas hacen naturalmente, sin dificultad o conscientemente, son las más difíciles de expresar en algoritmos. Comprender el lenguaje natural es un buen ejemplo. Todo el mundo lo hace, pero hasta ahora nadie ha podido explicar cómo se hace, al menos no en forma de algoritmo.

A medida que comience a escribir programas más extensos, es posible que pase más tiempo depurando. Más código significa más posibilidades de cometer un error y más lugares dónde se pueden esconder los errores.

Una forma de reducir el tiempo de depuración es "depurar por bisección". Por ejemplo, si hay 100 líneas en su programa y las revisa una a la vez, serían 100 revisiones.

Es mejor tratar de dividir el problema en dos. Busque en la mitad del programa o un valor intermedio que pueda verificar. Agregue una sentencia de impresión (o algo que permita verificar) y ejecute el programa.

Si esta verificación es incorrecta, debe haber un problema en la primera mitad del programa. Si es correcta, el problema está en la segunda mitad.

Cada vez que realiza una verificación como esta, reduce a la mitad el número de líneas que debe revisar. Después de seis pasos (que es mucho menos que 100), se reduciría a una o dos líneas de código, al menos en teoría.

En la práctica, no siempre se conoce dónde está la "mitad del programa", y no siempre es posible verificarlo. No tiene sentido contar líneas y encontrar el punto medio exacto. En su lugar, piense en los lugares del programa donde puede haber errores y en los lugares donde es fácil verificar. Luego, elija un lugar en donde usted crea que las posibilidades de encontrar un error antes o después de esta verificación son más o menos las mismas.

Los hispanohablantes están familiarizados con algunos caracteres, tales como las letras del alfabeto (A, B, C, …​), los números y los signos de puntuación comunes. Estos caracteres están estandarizados en el código ASCII (Código Estándar Estadounidense para el Intercambio de Información).

Por supuesto hay muchos otros caracteres utilizados en idiomas distintos del español que no están en el código ASCII, tales como aquellos usados en los idiomas griego, árabe, chino, hebreo, hindi, japonés y coreano.

Definir qué es un carácter es altamente complejo. La norma Unicode permite abordar este problema, y se considera como el estándar definitivo para ello. Esta norma funciona asignando un número único para cada carácter a nivel global.

Un valor Char representa un único carácter y está entre comillas simples:

Incluso los emojis son parte del estándar Unicode. (\:banana: TAB)

Una cadena es una secuencia de caracteres. Se puede acceder a un carácter con el operador corchete:

La segunda sentencia selecciona el carácter número 1 de fruta y la asigna a la variable letra.

La expresión entre corchetes se llama indice. El índice indica el carácter de la secuencia a obtener (de ahí el nombre).

La indexación en Julia es base 1, es decir, el primer elemento de cualquier objeto indexado con enteros está en el índice 1, y el último en el índice end:

Como índice se pueden usar expresiones que contengan variables y operadores:

No obstante, el valor del índice tiene que ser un número entero. De lo contrario se obtiene:

length es una función integrada que devuelve el número de caracteres de una cadena:

Para obtener la última letra de una cadena, puede sentirse tentado a probar algo como esto:

Pero con esto no se obtiene el resultado esperado.

Las cadenas se codifican usando codificación UTF-8. UTF-8 es una codificación de longitud variable, lo que significa que no todos los caracteres están codificados con el mismo número de bytes.

La función sizeof devuelve el número de bytes de una cadena:

Dado que un emoji está codificado en 4 bytes y la indexación de cadenas está basada en bytes, el quinto elemento de frutas es un ESPACIO.

Esto significa que no todos los índices de byte de una cadena UTF-8 son necesariamente índices válidos para un carácter. Si en una cadena se indexa con un índice de bytes no válido, se genera un error:

En el caso de frutas, el carácter 🍌 es un carácter de cuatro bytes, por lo que los índices 2, 3 y 4 no son válidos y el índice del siguiente carácter es 5, el siguiente índice válido se puede calcular con nextind(frutas, 1), el subsiguiente con nextind(frutas,5) y así sucesivamente.

Muchos cálculos implican procesar una cadena carácter por carácter. A menudo empiezan por el principio, seleccionan cada carácter por turno, hacen algo con él y continúan hasta el final. Este patrón de proceso se llama recorrido. Una forma de escribir un recorrido es con una sentencia while:

Este bucle recorre la cadena y muestra cada letra en una línea distinta. La condición del bucle es index <= sizeof(fruta), de modo que cuando el índice es mayor al número de bytes en la cadena, la condición es falsa y no se ejecuta el cuerpo del bucle.

La función firstindex devuelve el primer índice de bytes válido. La palabra reservada global antes de indice indica que queremos reasignar la variable indice definida en Main (ver [variables_globales]).

A la subcadena de una cadena se le llama porción. La selección de una porción es similar a la selección de un carácter:

El operador [n:m] devuelve la parte de la cadena desde el n-ésimo byte hasta el m-ésimo. Por lo tanto, se siguen las mismas reglas que para la indexación simple.

La palabra reservada end se puede usar para indicar al último byte de la cadena:

Si el primer índice es mayor que el segundo, el resultado es una cadena vacía, representada por dos comillas:

Una cadena vacía no contiene caracteres y tiene una longitud de 0, pero aparte de eso es igual a cualquier otra cadena.

Es tentador usar el operador [] en el lado izquierdo de una asignación con la intención de cambiar un carácter en una cadena. Por ejemplo:

Nota del traductor: De acuerdo con la codificación de caracteres en utf-8 o latin-1, el carácter de exclamación ‘¡’, en la variable saludo ocupa dos posiciones, de ahí que la letra ‘H’ esté localizada en el índice 3.

La razón del error es que las cadenas son inmutables, lo que significa que no se puede cambiar una cadena existente. Lo máximo que se puede hacer es crear una nueva cadena que sea una variación de la original:

Este ejemplo concatena la apertura del signo de exclamación y una nueva primera letra a una porción de saludo. Esta operación no tiene efecto sobre la cadena original.

Construir cadenas usando concatenación puede ser un poco engorroso. Para disminuir la necesidad de las llamadas a string o multiplicaciones repetidas, Julia permite la interpolación de cadenas usando $:

Esto es más entendible y conveniente que la concatenación de cadenas: saludo * ", " * paraquien * "!"

La expresión inmediatamente siguiente a $ se toma como la expresión cuyo valor se va a interpolar en la cadena. Por lo tanto, puede interpolar cualquier expresión en una cadena usando paréntesis:

¿Qué hace la siguiente función?

En cierto sentido, la función búsqueda es lo contrario del operador []. En lugar de tomar un índice y extraer el carácter correspondiente, toma un carácter y encuentra el índice donde aparece el carácter. Si el carácter no se encuentra, la función devuelve -1.

Este es el primer ejemplo de una sentencia return dentro de un bucle. Si palabra[indice] == letra, la función devuelve inmediatamente el índice, escapando del bucle prematuramente.

Si el carácter no aparece en la cadena, entonces el programa sale del bucle normalmente y devuelve -1.

Este patrón de computación se llama a veces un recorrido eureka porque tan pronto como encontramos lo que buscamos, podemos gritar “¡Eureka! ” y dejar de buscar.

El siguiente programa cuenta el número de veces que aparece la letra a en una cadena:

Este programa es otro ejemplo del patrón de computación llamado conteo. La variable contador se inicializa en 0 y se incrementa cada vez que encuentra la letra a. Cuando termina el bucle, contador contiene el resultado (el número total de letras a).

Julia tiene funciones integradas que realizan una variedad de operaciones útiles en cadenas. Por ejemplo, la función uppercase toma una cadena y devuelve una nueva cadena con todas las letras mayúsculas.

Existe una función llamada findfirst que es notablemente similar a la función busqueda que escribimos:

La función findfirst es más general que la función creada: puede encontrar subcadenas, no solo caracteres:

Por defecto, findfirst empieza la búsqueda al comienzo de la cadena pero la función findnext toma un tercer argumento: el indice donde debería comenzar:

El operador ∈ (\in TAB) es un operador booleano que toma un carácter y una cadena, y devuelve true si el primero aparece en el segundo:

Por ejemplo, la siguiente función imprime todas las letras de palabra1 que también aparecen en palabra2:

Una buena elección de nombres de variables permite que Julia se pueda leer como el español. Este bucle puede leerse como: "para (cada) letra en (la primera) palabra, si (la) letra es un elemento de (la segunda) palabra, imprima (la) letra".

Esto es lo que se obtiene si se compara "manzanas" y "naranjas":

Los operadores de comparación trabajan sobre cadenas. Para ver si dos cadenas son iguales:

Otras operaciones de comparación son útiles para ordenar alfabéticamente palabras:

Julia no maneja las letras mayúsculas y minúsculas del mismo modo que son manejadas en cualquier lengua hablada. Todas las letras mayúsculas van antes de las letras minúsculas, según el estándar de codificación. Por lo tanto:

Cuando se usan índices para recorrer los valores en una secuencia, es difícil acceder al principio y al final del recorrido. Aquí hay una función que compara dos palabras y devuelve true si una de las palabras es el reverso de la otra, pero contiene dos errores:

La primera sentencia if verifica si las palabras tienen la misma longitud. Si no, se devuelve false inmediatamente. De lo contrario, para el resto de la función, se puede suponer que las palabras tienen la misma longitud. Este es un ejemplo del patrón guardián.

i y j son índices: i recorre palabra1 de derecha a izquierda mientras que j recorre palabra2 de izquierda a derecha. Si dos letras no coinciden, se devuelve false inmediatamente. Si el ciclo termina y todas las letras coinciden, se devuelve true.

La función lastindex devuelve el último índice de bytes válido de una cadena y prevind el índice válido anterior a un carácter.

Si se prueba esta función con las palabras "amor" y "roma", se espera el valor de retorno true, pero se obtiene false:

Para depurar este tipo de error, primeramente se imprimen los valores de los índices:

Ahora, al ejecutar el programa, se obtiene más información:

En la primera iteración del bucle, el valor de j es 3, pero tendría que ser 4. Esto se puede solucionar trasladando la línea j = prevind (palabra2, j) al final del ciclo while.

Si se soluciona ese error y se ejecuta el programa nuevamente, se obtiene:

Esta vez se ha producido un BoundsError. El valor de i es 5, que está fuera del rango de la cadena "amor".

Para los ejercicios de este capítulo se necesita una lista de palabras en español. Hay muchas listas de palabras disponibles en la Web, pero la más adecuada para nuestro propósito es una de las listas de palabras recopiladas y contribuidas al dominio público por Ismael Olea (see http://olea.org/proyectos/lemarios/). Esta lista de 87900 palabras se encuentra en la página de Olea con el nombre de archivo lemario-general-del-espanol.txt. También es posible descargar una copia desde https://github.com/JuliaIntro/IntroAJulia.jl/blob/master/data/palabras.txt.

Este archivo es un archivo de texto simple, por lo que puede ser abierto con un editor de texto o leído con Julia. La función integrada open toma el nombre del archivo como parámetro y devuelve un objeto archivo que puede ser usado para la lectura del archivo.

fin es un objeto archivo que puede ser utilizado como entrada y cuando se deja de utilizar, debe cerrarse con close(fin).

Julia tiene integradas varias funciones de lectura, entre ellas readline, que lee los caracteres del archivo hasta que llega a un salto de línea, devolviendo el resultado como una cadena:

La primera palabra en esta lista particular es "a", que indica dirección, intervalo de tiempo, finalidad, entre otros.

El objeto archivo lleva registro de dónde quedó por última vez, por lo que si llama a readline nuevamente, se obtendrá la siguiente palabra:

La siguiente palabra es "a-", que es un prefijo que indica privación.

También se puede usar un archivo como parte de un bucle for. El siguiente programa lee palabras.txt e imprime cada palabra, una por línea:

Todos los ejercicios en la sección anterior tienen algo en común: se pueden resolver con el patrón de búsqueda. El ejemplo más simple es:

El bucle for recorre los caracteres de palabra. Si encontramos la letra e, puede devolver inmediatamente false, de lo contrario hay que pasar a la siguiente letra. Si se sale del bucle normalmente, eso significa que no se encontró una e, por lo que la función devuelve true.

Esta función podría ser escrita de manera más concisa usando el operador ∉ (\notin TAB), pero se comienza con esta versión porque muestra la lógica del patrón de búsqueda.

evita es una versión más general de notiene_e pero tiene la misma estructura:

Se devuelve false tan pronto como se encuentre una letra prohibida, si llegamos al final del ciclo, se devuelve true.

usasolo es similar, excepto que el sentido de la condición se invierte:

En vez de un conjunto de letras prohibidas, se tiene un conjunto de letras disponibles. Si se encuentra una letra en palabra que no está en disponible, se devuelve false.

usatodo es similar, excepto que se invierte el papel de la palabra y la cadena de letras:

En lugar de recorrer las letras de la palabra, el bucle recorre las letras requeridas. Si alguna de las letras requeridas no aparece en la palabra, se devuelve false.

Si se pensara como un informático se reconocería que usatodo es una instancia de un problema previamente resuelto y se podría haber escrito:

Este es un ejemplo de una forma de desarrollar programas llamada reducción a un problema resuelto previamente, lo que significa que se reconoce el problema en el que se está trabajando como una instancia de un problema ya resuelto y se aplica la solución existente.

Las funciones de la sección anterior fueron escritas con ciclos for porque solo se necesitaban los caracteres en las cadenas y no hubo necesidad de trabajar con los índices.

Para esabecedaria tenemos que comparar letras adyacentes, lo cual es un poco complicado con un ciclo for:

Otra alternativa es usar recursividad:

Una tercera opción es usar un ciclo while:

El ciclo comienza en i=1 y j=nextind(palabra, 1) y termina cuando j>sizeof(palabra). En cada iteración, se compara el carácter iésimo (que se puede considerar como el carácter actual) con el carácter jésimo (que se puede considerar como el siguiente).

Si el siguiente carácter es menor (va antes en el alfabeto) que el actual, entonces la palabra no tiene sus letras en orden alfabético, y se devuelve false.

Si se llega al final del ciclo sin encontrar letras que imposibiliten el orden alfabético, entonces la palabra pasa la prueba. Para convencerse de que el ciclo termina correctamente, considere como ejemplo la palabra "Abel".

A continuación se muestra una versión de espalindromo que usa dos índices: uno comienza al principio de la palabra y aumenta su valor, y el otro comienza al final y disminuye su valor.

O podríamos reducir este problema a uno previamente resuelto y escribir:

Usando esreverso de Depuración.

Comprobar el correcto funcionamiento de los programas es difícil. Las funciones de este capítulo son relativamente fáciles de probar porque se pueden verificar los resultados a mano. Aun así, es casi imposible elegir un conjunto de palabras que permitan evaluar todos los posibles errores.

Tomando notiene_e como ejemplo, hay dos casos obvios que verificar: las palabras que tienen una e deberían devolver false y las palabras que no, deberían devolver true. No deberían haber problemas para encontrar un ejemplo de cada uno.

Dentro de cada caso, hay algunos subcasos menos obvios. Entre las palabras que tienen una "e", se deben probar las palabras con una "e" al principio, al final y al medio. Además, se deben probar palabras largas, cortas y muy cortas, como una cadena vacía. La cadena vacía es un ejemplo de un "caso especial" no obvio donde pueden originarse errores.

Además de las instancias de prueba generadas, también puede probar su programa con una lista de palabras como palabras.txt. Al escanear el resultado, es posible que pueda detectar errores, pero tenga cuidado: puede detectar un tipo de error (palabras que no deberían incluirse, pero lo están) y no otro (palabras que deberían incluirse, pero no lo están).

Por lo general, las pruebas pueden ayudarlo a encontrar errores, pero no es fácil generar un buen conjunto de instancias de prueba e incluso si lo hace, no puede estar seguro de que su programa sea correcto. Según un informático muy famoso:

Al igual que una cadena de texto, un arreglo es una secuencia de valores. En una cadena los valores son caracteres, en un arreglo pueden ser de cualquier tipo. Los valores en un arreglo se denominan elementos o, a veces, items.

Hay varias formas de crear un nuevo arreglo, la más sencilla es encerrar los elementos entre corchetes ([ ]):

El primer ejemplo es un arreglo de cuatro enteros. El segundo es un arreglo de tres cadenas de texto. Los elementos de un arreglo no tienen por qué ser del mismo tipo. El siguiente arreglo contiene una cadena, un número de punto flotante, un entero y otro arreglo:

Se dice que un arreglo dentro de otro arreglo está anidado.

Un arreglo que no contiene elementos se llama arreglo vacío y se puede crear uno con corchetes vacíos, [].

Como es de esperar, se pueden asignar valores de arreglos a variables:

La función typeof se puede usar para conocer el tipo del arreglo:

El tipo del arreglo se especifica entre llaves, y se compone de un tipo y un número. El número indica las dimensiones. El conjunto vacío contiene valores de tipo Any, es decir, puede contener valores de todos los tipos.

La sintaxis para acceder a los elementos de un arreglo es el mismo que para acceder a los caracteres de una cadena: el operador corchete. La expresión dentro de los corchetes especifica el índice. Recuerde que los índices comienzan en 1:

A diferencia de las cadenas, los arreglos son mutables, lo que significa que podemos cambiar sus elementos. Se puede modificar uno de sus elementos usando el operador corchetes en el lado izquierdo de una asignación:

El segundo elemento de numeros, que era 123, ahora es 5.

Diagrama de estado muestra los diagramas de estado para quesos, numeros y vacio.

Los arreglos son representados mediante cuadros con elementos del arreglo en su interior. El arreglo quesos hace referencia a un arreglo con tres elementos indexados 1, 2 y 3. El arreglo numeros contiene dos elementos. El diagrama muestra que el valor del segundo elemento de numeros se ha reasignado de 123 a 5. Finalmente, vacio hace referencia a un arreglo sin elementos.

Los índices de un arreglo funcionan de la misma manera que los índices de una cadena (pero sin los problemas generados por la codificación UTF-8):

El operador ∈ también funciona en arreglos:

La forma más común de recorrer los elementos de un arreglo es con un ciclo for. La sintaxis es la misma que para las cadenas:

Esto funciona bien si solo se necesita leer los elementos del arreglo, pero si se desea escribir o actualizar los elementos es necesario utilizar índices. Una forma común de hacerlo es usando la función integrada eachindex:

Este bucle recorre el arreglo y actualiza cada elemento. En cada iteración del ciclo, i representa el índice del elemento actual. La sentencia de asignación usa numeros[i] para leer el valor original del elemento y asignar el nuevo valor.

Por otra parte, length devuelve el número de elementos en el arreglo.

Un ciclo for sobre un arreglo vacío nunca ejecuta el cuerpo del bucle:

Aunque un arreglo puede contener otro arreglo, este arreglo anidado cuenta como un elemento único. Por ejemplo, la longitud de este arreglo es cuatro:

El operador porción también funciona en arreglos:

El operador porción [:] hace una copia de todo el arreglo:

Como los arreglos son mutables, es útil hacer una copia antes de realizar operaciones que las modifiquen.

Un operador porción en el lado izquierdo de una asignación puede actualizar varios elementos:

Julia tiene funciones integradas que operan en arreglos. Por ejemplo, push! agrega un nuevo elemento al final de un arreglo:

append! agrega elementos de un arreglo al final de otro:

En este ejemplo t2 no es modificado.

sort! ordena los elementos de un arreglo de menor a mayor:

sort devuelve una copia ordenada de los elementos de un arreglo:

Para sumar todos los números en un arreglo se puede usar un ciclo como este:

total se inicializa en 0. En cada iteración, con += se añade un elemento del arreglo a la suma total. El operador += es una forma simple de actualizar esta variable. Esta sentencia de asignación aumentada,

es equivalente a

A medida que se ejecuta el ciclo, total acumula la suma de los elementos. A veces se denomina acumulador a una variable utilizada de esta manera.

Sumar los elementos de un arreglo es una operación tan común que Julia tiene una función integrada para ello, sum:

Una operación como esta, que combina una secuencia de elementos en un solo valor, a veces se denomina operación de reducción.

Es común querer recorrer un arreglo mientras se construye otro. Por ejemplo, la siguiente función toma un arreglo de cadenas y devuelve un nuevo arreglo que contiene las mismas cadenas pero en mayúsculas:

res se inicializa con un arreglo vacío, y en cada iteración se le agrega un nuevo elemento. De esta manera, res es otro tipo de acumulador.

Una operación como todoenmayusculas a veces se denomina mapeo porque "asigna" una función (en este caso uppercase) a cada uno de los elementos de una secuencia.

Otra operación común es seleccionar solo algunos de los elementos de un arreglo y devolver una sub-arreglo. Por ejemplo, la siguiente función toma un arreglo de cadenas y devuelve un arreglo que contiene solamente las cadenas en mayúsculas:

Operaciones como solomayusculas se llaman filtro porque seleccionan solo algunos elementos, filtrando otros.

Las operaciones de arreglos más comunes son una combinación de mapeo, filtro y reducción.

Para cada operador binario, como por ejemplo ^, existe un operador punto correspondiente .^ que automáticamente define la operación ^ para cada elemento de un arreglo. Por ejemplo, [1, 2, 3] ^ 3 no está definido, pero [1, 2, 3] .^ 3 se define como el resultado de realizar la operación ^ en cada elemento [1^3, 2^3, 3^3]:

Cualquier función f de Julia puede ser aplicada a cada elemento de cualquier arreglo con la sintaxis de punto. Por ejemplo, para poner en mayúsculas un arreglo de cadenas, no es necesario un bucle explícito:

Esta es una forma elegante de crear un mapeo. Siguiendo esta lógica, la función todoenmayusculas puede implementarse con una línea:

Hay varias formas de eliminar elementos de un arreglo. Si se conoce el índice del elemento que se desea eliminar, se puede usar splice!:

splice! modifica el arreglo y devuelve el elemento que se eliminó.

pop! elimina y devuelve el último elemento:

popfirst! elimina y devuelve el primer elemento:

Las funciones pushfirst! y push! insertan un elemento al principio y al final del arreglo, respectivamente.

Si no se necesita el valor eliminado, se puede usar la función deleteat!:

La función insert! inserta un elemento en un índice dado:

Una cadena es una secuencia de caracteres y un arreglo es una secuencia de valores, pero un arreglo de caracteres no es lo mismo que una cadena. Para convertir una cadena a un arreglo de caracteres, se puede usar la función collect:

La función collect divide una cadena u otra secuencia en elementos individuales.

Si desea dividir una cadena en palabras, puede usar la función split:

Un argumento opcional llamado delimitador especifica qué caracteres usar como límites de palabra. El siguiente ejemplo usa un guión como delimitador:

join es el inverso de split. Toma un arreglo de cadenas y concatena los elementos:

En este caso, el delimitador es un carácter de espacio en blanco. Para concatenar cadenas sin espacios, no especifique un delimitador.

Un objeto es algo a lo que una variable puede referirse. Hasta ahora, podría usar "objeto" y "valor" indistintamente.

Si ejecutamos estas sentencias de asignación:

Se sabe que a y b apuntan a una cadena, pero no se sabe si están apuntando a la misma cadena. Hay dos estados posibles, los cuales se muestran en la Figura 10-2.

En un caso, a y b se refieren a dos objetos diferentes que tienen el mismo valor. En el segundo caso, se refieren al mismo objeto.

Para verificar si dos variables se refieren al mismo objeto, se puede usar el operador ≡ (\equiv TAB)) o ===.

En este ejemplo, Julia solo creó un objeto de cadena, y ambas variables a y b apuntan a ella. Pero cuando se crean dos arreglos, se obtienen dos objetos:

Entonces el diagrama de estado se ve así Diagrama de estado.

En este caso, se podría decir que los dos arreglos son equivalentes, porque tienen los mismos elementos, pero no idénticos, ya que no son el mismo objeto. Si dos objetos son idénticos, también son equivalentes, pero si son equivalentes, no son necesariamente idénticos.

Para ser precisos, un objeto tiene un valor. Si se evalúa [1, 2, 3], se obtendrá un objeto arreglo cuyo valor es una secuencia de enteros. Si otro arreglo tiene los mismos elementos, se dice que tiene el mismo valor, pero no es el mismo objeto.

Si a apunta a un objeto, y se asigna b = a, entonces ambas variables se refieren al mismo objeto:

El diagrama de estado sería como este Diagrama de estado.

La asociación de una variable con un objeto se llama referencia. En este ejemplo, hay dos referencias al mismo objeto.

Un objeto con más de una referencia tiene más de un nombre, por lo que decimos que el objeto tiene un alias.

Si el objeto con alias es mutable, los cambios hechos a un alias afectan al otro:

No hay problema con los alias al trabajar con objetos inmutables, tales como cadenas de texto. En este ejemplo:

Casi nunca es relevante que a y b se refieran a la misma cadena o no.

Cuando se pasa un arreglo como argumento de una función, en realidad se pasa una referencia a ella. Si la función modifica el arreglo, el que hizo la llamada verá el cambio. Por ejemplo, la función borrarprimero elimina el primer elemento de un arreglo:

Aquí se aprecia el uso de borrarprimero!:

El parámetro t y la variable letras son alias de un mismo objeto. El diagrama de estado es así Diagrama de estado.

Como el arreglo está compartido por dos marcos, se dibuja entre ambos.

Es importante distinguir entre operaciones que modifiquen arreglos y operaciones que creen nuevas arreglos. Por ejemplo, push! modifica un arreglo, pero vcat crea un nuevo arreglo.

Aquí hay un ejemplo de push!:

t2 es un alias de t1.

Aquí hay un ejemplo de vcat:

El resultado de vcat es un nuevo arreglo. El arreglo original no ha sufrido cambios.

Esta diferencia es importante al momento de escribir funciones que modifican arreglos.

Por ejemplo, esta función no elimina el primer elemento de un arrreglo:

El operador porción crea un nuevo arreglo y la asignación hace que t se refiera a ella, pero eso no afecta al arreglo t fuera de la función.

Al comienzo de noborrarprimero, t y t3 se refieren al mismo arreglo. Al final, t se refiere a un nuevo arreglo, pero t3 todavía se refiere al arreglo original no modificado.

Una alternativa es escribir una función que cree y devuelva un nuevo arreglo. Por ejemplo, la función cola devuelve todos menos el primer elemento de un arreglo:

Esta función no modifica el arreglo original, y se usa de la siguiente manera:

Un uso inadecuado de los arreglos (y otros objetos mutables) puede llevar a largas horas de depuración. A continuación se muestran algunos errores comunes y cómo evitarlos:

Un diccionario es como una matriz pero más general. En una matriz, los índices tienen que ser enteros; en un diccionario pueden ser (casi) de cualquier tipo.

Un diccionario contiene una colección de índices, llamados claves, y una colección de valores. Cada clave está asociada a un solo valor. La asociación entre una clave y un valor se denomina par clave-valor o, a veces, item.

En lenguaje matemático, un diccionario representa un mapeo de las claves a los valores, es decir, cada clave apunta a un valor. A modo de ejemplo, se crea un diccionario que asocia palabras en español con palabras en inglés. En este diccionario, las claves y los valores son cadenas.

La función Dict crea un nuevo diccionario sin elementos. Como Dict es el nombre de una función integrada de Julia, debe evitar usarla como nombre de variable.

El tipo de este diccionario está compuesto por el tipo de las claves y de los valores, entre llaves. En este caso, las claves y los valores son de tipo Any.

El diccionario está vacío. Para agregar elementos a él, se pueden usar corchetes:

Esta línea de código crea un elemento con la clave "one" que apunta al valor "uno". Si se imprime el diccionario nuevamente, se ve un par clave-valor con una flecha => entre la clave y el valor:

Este formato de salida también es un formato de entrada. Por ejemplo, se puede crear un nuevo diccionario con tres ítems de la siguiente manera:

Todas las claves y valores iniciales son cadenas, por lo que se crea un Dict{String,String}.

Esto no significa un problema ya que los elementos de un diccionario nunca se indexan con índices enteros. En lugar de ello, se utilizan las claves para buscar los valores correspondientes:

La clave "two" da el valor "dos", así que el orden de los ítems no importa.

Si la clave no está en el diccionario, se da un mensaje de error:

La función length también funciona con diccionarios y devuelve el número de pares clave-valor:

La función keys devuelve una colección con las claves del diccionario:

También se puede usar el operador ∈ para ver si algo es una clave en un diccionario:

Para ver si algo es un valor en un diccionario, se puede usar la función values, que devuelve una colección de valores, y luego usar el operador ∈:

El operador ∈ utiliza diferentes algoritmos para matrices y diccionarios. Para las matrices, busca los elementos de la matriz en orden, como en Búsqueda. El tiempo de búsqueda es directamente proporcional al largo de la matriz.

Para los diccionarios, Julia usa un algoritmo llamado tabla hash que tiene una propiedad importante: el operador ∈ toma aproximadamente la misma cantidad de tiempo sin importar cuántos elementos haya en el diccionario.

Suponga que tiene una cadena y desea contar cuántas veces aparece cada letra. Hay varias formas de hacerlo:

Cada una de estas opciones realiza el mismo cálculo, pero la implementación es diferente.

Una implementación es una forma de realizar un cálculo. Algunas implementaciones son mejores que otras, por ejemplo, una ventaja de la implementación del diccionario es que no hace falta saber de antemano qué letras aparecen en la cadena y solo hay que agregar las letras que aparecen.

Así es como se vería el código:

La función se llama histograma, que es un término en estadística para una colección de frecuencias (o conteos).

La primera línea de la función crea un diccionario vacío. El ciclo for recorre la cadena s. En cada iteración de este ciclo, si el carácter c no está en el diccionario, se crea un nuevo elemento con la clave c y el valor inicial 1 (ya que hemos visto esta letra una vez). Si c ya está en el diccionario, se incrementa d[c].

Así es como funciona:

El histograma indica que las letras a y b aparecen una vez, o aparece dos veces, y así sucesivamente.

Los diccionarios tienen una función llamada get que toma como argumentos un diccionario, una clave y un valor predeterminado. Si la clave aparece en el diccionario, get devuelve el valor correspondiente; de lo contrario, devuelve el valor predeterminado. Por ejemplo:

Es posible recorrer las claves del diccionario con un ciclo for. Por ejemplo, imprimirhist imprime cada clave y su valor correspondiente:

Así es como se ve la salida:

Nuevamente, las claves no están en un orden particular. Para recorrer las claves en orden, puede usar sort y collect:

Dado un diccionario d y una clave k, es fácil encontrar el valor correspondiente v = d[k]. Esta operación se llama búsqueda.

Pero, ¿qué pasa si se tiene v y se quiere encontrar k? Existen dos problemas: primeramente, puede haber más de una clave que apunta al valor v. Dependiendo de lo que se quiera, es posible que se pueda elegir una de estas claves, o que se tenga que hacer una matriz que las contenga a todas. En segundo lugar, no hay una sintaxis simple para hacer una búsqueda inversa; solo se debe buscar.

A continuación se muestra una función que toma un valor y que devuelve la primera clave que apunta a ese valor:

Esta función es otro ejemplo del patrón de búsqueda, pero utiliza una función que no hemos visto antes: error. La función error se usa para producir un ErrorException que interrumpe el flujo normal. En este caso tiene el mensaje "Error de Busqueda", que indica que no existe una clave.

Si llega al final del ciclo, eso significa que v no aparece en el diccionario como un valor, por lo que se produce una excepción.

A continuación se muestra un ejemplo de una búsqueda inversa exitosa:

y una no exitosa:

El efecto cuando generamos una excepción es el mismo que cuando Julia genera una: se imprime un trazado inverso y un mensaje de error.

Julia proporciona una forma optimizada de hacer una búsqueda inversa: findall(isequal(3),h).

Las matrices pueden aparecer como valores en un diccionario. Por ejemplo, si se tiene un diccionario que asigna frecuencias a letras, y se quiere invertir, es decir, tener un diccionario que asigne letras a frecuencias. Dado que pueden haber varias letras con la misma frecuencia, cada valor en el diccionario invertido debería ser una matriz de letras.

Aquí hay una función que invierte un diccionario:

Cada vez que se recorre el bucle, se asigna a la variable clave una clave de d, y a val el valor correspondiente. Si val no está en el diccionario inverso, significa que no se ha visto este valor antes, por lo que se crea un nuevo item y se inicializa con un singleton (una matriz que contiene un solo elemento). De lo contrario, se ha visto este valor antes, por lo que se agrega la clave correspondiente a la matriz.

Aquí hay un ejemplo:

Diagrama de estado es un diagrama de estado que muestra hist e inverso. Un diccionario se representa como un cuadro con los pares clave-valor dentro. En este libro, si los valores son enteros, números de punto flotante o cadenas de texto, se dibujan dentro del cuadro, y las matrices (generalmente) se dibujan fuera del cuadro, solo para mantener el diagrama simple.

Si estuvo jugando con la función fibonacci de Un Ejemplo Más, es posible que haya notado que cuanto más grande el argumento que le da, más tiempo tarda la función en ejecutarse. Más aún, el tiempo de ejecución aumenta muy rápidamente.

Para entender por qué, considere Gráfico de llamadas, que muestra el gráfico de llamadas para la función fibonacci con n = 4:

Un gráfico de llamadas muestra un conjunto de cuadros de funciones, con líneas que conectan cada cuadro con los cuadros de las funciones a las que llama. En la parte superior del gráfico, fibonacci con n = 4 llama a fibonacci con n = 3 y n = 2. A su vez, fibonacci con n = 3 llama a fibonacci con n = 2 y n = 1. Y así sucesivamente.

Cuente cuántas veces se llama a fibonacci(0) y fibonacci(1). Esta es una solución ineficiente al problema y empeora a medida que el argumento aumenta en tamaño.

Una solución es llevar un registro de los valores que ya se han calculado almacenándolos en un diccionario. Un valor que ya ha sido calculado y almacenado para un uso posterior se le denomina pista. Aquí hay una implementación de fibonacci con pistas:

El diccionario llamado anteriores mantiene un registro de los valores de Fibonacci que ya conocemos. El programa comienza con dos pares: 0 corresponde a 1 y 1 corresponde a 1.

Siempre que se llama a fibonacci, se comprueba si el diccionario contiene el resultado ya calculado. Si está ahí, la función puede devolver el valor inmediatamente. Si no, tiene que calcular el nuevo valor, añadirlo al diccionario y devolverlo.

Si ejecuta esta versión de fibonacci y la compara con la original, se dará cuenta que es mucho más rápida.

En el ejemplo anterior, el diccionario anteriores se crea fuera de la función, por lo que pertenece al marco especial llamado Main. Las variables en Main a veces son llamadas globales porque se puede acceder a ellas desde cualquier función. A diferencia de las variables locales, que desaparecen cuando finaliza su función, las variables globales existen de una llamada de función a la siguiente.

Es común usar variables globales como flags o banderas; es decir, variables booleanas que indican si una condición es verdadera. Por ejemplo, algunos programas usan una bandera llamada verbosa para controlar el nivel de detalle en la salida:

Si intenta reasignar una variable global, se sorprenderá. El siguiente ejemplo trata de llevar registro sobre si se ha llamado o no a una función:

Pero si lo ejecuta, verá que el valor de ha_sido_llamada no cambia. El problema es que ejemplo2 + crea una nueva variable local llamada +ha_sido_llamada. La variable local desaparece cuando finaliza la función y no tiene efecto en la variable global.

Para reasignar una variable global dentro de una función, debe declarar la variable global antes de usarla: (reasignación

La sentencia global le dice al intérprete algo como esto: “En esta función, cuando digo ha_sido_llamada, me refiero a la variable global; así que no crees una variable local".

A continuación se muestra un ejemplo que intenta actualizar una variable global:

Si lo ejecuta obtiene:

Julia asume que conteo es local, y bajo esa suposición lo está leyendo antes de escribirlo. La solución, nuevamente, es declarar conteo como global.

Si una variable global se refiere a un valor mutable, puede modificar el valor sin declarar la variable global:

Por lo tanto, puede agregar, eliminar y reemplazar elementos de una matriz global o diccionario, pero si desea reasignar la variable, debe declararla global:

Para mejorar el rendimiento, puede declarar la variable global como constante. Con esto, ya no se puede reasignar la variable, pero si se refiere a un valor mutable, sí se puede modificar el valor.

A medida que trabaja con conjuntos de datos más grandes, la depuración mediante la impresión y verificación de la salida de manera manual puede tornarse difícil. Aquí hay algunas sugerencias para depurar grandes conjuntos de datos:

Una tupla es una secuencia de valores. Estos valores pueden ser de cualquier tipo y están indexados por enteros, por lo que las tuplas son muy parecidas a los arreglos. La diferencia más importante es que las tuplas son inmutables y que cada elemento puede tener su propio tipo.

Una tupla es una lista de valores separados por comas:

Aunque no es necesario, es común encerrar las tuplas entre paréntesis:

Para crear una tupla con un solo elemento, se debe incluir una coma final:

Otra forma de crear una tupla es la función de tupla integrada en Julia. Sin argumento, esta función crea una tupla vacía:

Si se tienen múltiples argumentos, el resultado es una tupla con los argumentos dados:

Ya que tuple es el nombre de una función integrada, debe evitar usarla como nombre de variable.

La mayoría de los operadores de arreglos también sirven en las tuplas. El operador corchete indexa un elemento:

Y el operador porción selecciona un rango de elementos:

Pero si se intenta modificar uno de los elementos de la tupla, se obtendrá un error:

Como las tuplas son inmutables, sus elementos no se pueden modificar.

Los operadores relacionales funcionan con las tuplas y otras secuencias, Julia comienza comparando el primer elemento de cada secuencia. Si son iguales, pasa a los siguientes elementos, y así sucesivamente, hasta que encuentra elementos que difieren. Los elementos posteriores no se consideran (incluso si son realmente grandes).

De vez en cuando, es útil intercambiar los valores de dos variables. Para hacerlo con sentencias de asignación convencionales se debe usar una variable temporal. Por ejemplo, para intercambiar a y b:

Esta solución resulta aparatosa. La asignación de tuplas soluciona este problema elegantemente:

El lado izquierdo es una tupla de variables y el lado derecho es una tupla de expresiones. Cada valor se asigna a su respectiva variable. Todas las expresiones del lado derecho se evalúan antes de las asignaciones.

El número de variables de la izquierda tiene que ser menor o igual que el número de valores a la derecha:

El lado derecho puede ser cualquier tipo de secuencia (cadena, arreglo o tupla). Por ejemplo, para dividir una dirección de correo electrónico en nombre de usuario y dominio, se puede escribir:

El valor de retorno de split es un arreglo con dos elementos: el primer elemento se asigna a unombre, y el segundo a dominio.

Estrictamente hablando, una función solo puede devolver un valor pero si el valor es una tupla, el efecto es el mismo que devolver múltiples valores. Por ejemplo, si desea dividir dos enteros y calcular el cociente y el resto, es ineficiente calcular x ÷ y y luego x % y. Es mejor calcular ambos al mismo tiempo.

La función integrada divrem toma dos argumentos y devuelve una tupla de dos valores: el cociente y el resto. El resultado puede ser almacenado como una tupla:

También se puede utilizar asignación de tuplas para almacenar los elementos por separado:

Aquí hay un ejemplo de una función que devuelve una tupla:

maximum y minimum son funciones integradas que encuentran los elementos más grandes y más pequeños de una secuencia, respectivamente. La función minmax calcula ambos y devuelve una tupla de dos valores. Otra alternativa es utilizar la función integrada extrema, lo cual es más eficiente.

Las funciones pueden tomar un número variable de argumentos. Un nombre de parámetro que termina con ... recopila argumentos en una tupla. Por ejemplo, imprimirtodo toma cualquier número de argumentos y los imprime:

El parámetro de recopilación puede tener cualquier nombre, pero la convención es llamarlo args. A continuación se muestra cómo funciona la función:

El opuesto de la recopilación es la dispersión. Si tiene una secuencia de valores y desea pasarla a una función como argumento múltiple, puede usar el operador ... . Por ejemplo, divrem toma exactamente dos argumentos y no funciona con tuplas:

No obstante, si "dispersamos" la tupla, funciona:

Muchas de las funciones integradas usan tuplas con argumentos de longitud variable. Por ejemplo, max y min pueden tomar cualquier número de argumentos:

Pero sum no:

zip es una función integrada que toma dos o más secuencias y devuelve una colección de tuplas donde cada tupla contiene un elemento de cada secuencia. El nombre de la función se refiere a una cremallera, que une e intercala dos filas de dientes.

Este ejemplo une e intercala una cadena y un arreglo:

El resultado es un objeto zip que permite iterar a través de los pares. El uso más común de zip es en un bucle for:

Un objeto zip es un tipo de iterador, que es cualquier objeto que itera a través de una secuencia. Los iteradores son, en cierto modo, similares a los arreglos, pero a diferencia de estos últimos, no se puede usar un índice para seleccionar un elemento de un iterador.

Si desea usar operadores y funciones de arreglos, puede usar un objeto zip para hacer un arreglo:

El resultado es una serie de tuplas. En este ejemplo, cada tupla contiene un carácter de la cadena y el elemento correspondiente del arreglo.

Si las secuencias no tienen la misma longitud, el resultado tiene la longitud de la más corta.

Se puede usar asignación de tuplas en un bucle for para recorrer un arreglo de tuplas:

En cada iteración del ciclo, Julia selecciona la siguiente tupla en el arreglo y asigna estos elementos a letra y número. Los paréntesis de (letra, número) son obligatorios.

Combinando zip, for y asignación de tuplas, se obtiene una forma para recorrer dos (o más) secuencias al mismo tiempo. Por ejemplo, la función coinciden toma dos secuencias, t1 y t2, y devuelve true si hay un índice i tal que t1[i] == t2[i]:

Si se necesita recorrer los elementos de una secuencia y sus índices, se puede usar la función integrada enumerate:

El resultado de enumerate es un objeto enumerate, el cual hace una iteración sobre una secuencia de pares, dónde cada par contiene un índice (a partir de 1) y un elemento de la secuencia dada.

Los diccionarios se pueden usar como iteradores que iteran sobre los pares clave-valor. Puede usarlos en un bucle for como este:

Como es de esperar, en un diccionario los elementos no están en un orden particular.

Ahora, si se quiere hacer lo contrario, se puede usar una serie de tuplas para inicializar un nuevo diccionario:

Al combinar Dict con zip, podemos crear un diccionario de una manera muy simple:

Es común usar tuplas como claves en los diccionarios. Por ejemplo, un directorio telefónico puede asignar números de teléfono a una tupla con apellido y nombre. Suponiendo que se ha definido apellido, nombre y numero, podríamos escribir:

La expresión entre paréntesis es una tupla. Se podría usar asignación de tuplas para recorrer este diccionario.

Este bucle recorre los pares clave-valor en directorio, los cuales son tuplas. Asigna los elementos de la clave de cada tupla a apellido y nombre y el valor a numero, luego imprime el nombre y el número de teléfono correspondiente.

Hay dos formas de representar tuplas en un diagrama de estado. La versión más detallada muestra los índices y elementos tal como aparecen en un arreglo. Por ejemplo, la tupla ("Cortázar", "Julio") se vería como en Diagrama de estado.

Pero en un diagrama más grande, es posible que desee omitir algunos detalles. Por ejemplo, un diagrama del directorio telefónico puede verse como en Diagrama de estado.

Aquí las tuplas se muestran usando la sintaxis de Julia para tener un esquema más simple. El número de teléfono del diagrama es el número de reclamos de la BBC, así que no intentes llamar.

Hasta ahora, el capítulo se ha centrado en los arreglos de tuplas, pero casi todos los ejemplos que se han visto también funcionan con arreglos de arreglos, tuplas de tuplas y tuplas de arreglos. Para evitar enumerar todas las posibles combinaciones, a veces es más fácil hablar sobre secuencias de secuencias.

En muchos contextos, los diferentes tipos de secuencias (cadenas, arreglos y tuplas) se pueden usar indistintamente. Entonces, ¿cómo elegir uno u otro?

Para comenzar con lo mas obvio, las cadenas son más limitadas que las demás secuencias, porque los elementos deben ser caracteres. Además son inmutables. Si se necesita poder cambiar los caracteres en una cadena (en vez de crear una nueva), puede que lo mas adecuado sea elegir un arreglo de caracteres.

Los arreglos se usan con mas frecuencia que las tuplas, principalmente porque son mutables. No obstante, hay algunos casos donde es posible que sea preferible usar tuplas:

Dado que las tuplas son inmutables, no tienen funciones como sort! y reverse! que modifiquen arreglos ya existentes. Sin embargo, Julia proporciona las funciones integradas sort, que toma un arreglo y devuelve una secuencia nueva con los mismos elementos ordenados, y reverse, que toma cualquier secuencia y devuelve una secuencia nueva del mismo tipo con los mismos elementos en el orden contrario.

Los arreglos, diccionarios y tuplas son ejemplos de estructuras de datos. En este capítulo se empiezan a ver estructuras de datos compuestas, como arreglos o tuplas, y diccionarios que contienen tuplas como claves y arreglos como valores. Las estructuras de datos compuestas son útiles, aunque también resultan propensas a lo que se llaman errores de forma, es decir, errores causados cuando una estructura de datos tiene el tipo, tamaño o estructura incorrecta. Por ejemplo, si está esperando una lista con un entero y se le pasa simplemente un entero (no en una lista), no funcionará.

Julia permite añadir el tipo a elementos de una secuencia. Esto se detalla en Dispatch Múltiple. Especificar el tipo elimina muchos errores de forma.

Como de costumbre, se recomienda intentar resolver los ejercicios antes de leer las soluciones.

Dadas las mismas entradas, la mayor parte de los programas generan la misma salida cada vez que los ejecutamos, por lo que se dice que son deterministas. Normalmente el determinismo es algo bueno, ya que esperamos que un cálculo nos entregue siempre el mismo resultado. Para algunas aplicaciones, sin embargo, queremos que el computador sea impredecible. Por ejemplo en los juegos, entre otros casos.

Hacer que un programa sea realmente no determinista resulta difícil, pero hay formas de que hacer que al menos parezca no determinista. Una de ellas es usar algoritmos para generar números pseudoaleatorios. Los números pseudoaleatorios no son verdaderamente aleatorios porque se generan mediante un cálculo determinista pero al mirar estos números es casi imposible distinguirlos de lo aleatorio.

La función rand devuelve un numero de punto flotante entre 0.0 y 1.0 (incluyendo 0.0 pero no 1.0). Cada vez que usted llama a rand obtiene el siguiente numero de una larga serie. Para ver un ejemplo, ejecute este bucle:

La función rand puede tomar un iterador o arreglo como argumento y devuelve un elemento aleatorio de ellos:

Debe hacer los ejercicios anteriores antes de continuar. También necesitará https://github.com/JuliaIntro/IntroAJulia.jl/blob/master/data/DonQuijote.txt.

Aquí hay un programa que lee un archivo y construye un histograma de las palabras en el archivo:

Este programa lee DonQuijote.txt, que contiene el texto de Don Quijote de Miguel de Cervantes.

procesararchivo recorre las líneas del archivo, pasando una línea a la vez a procesarlinea. El histograma hist se está utilizando como acumulador.

procesarlinea usa la función replace para reemplazar los guiones por espacios antes de usar split para dividir la línea en un arreglo de cadenas. Recorre el conjunto de palabras y usa filter, isletter y lowercase para eliminar los signos de puntuación y convertir las palabras a minúsculas. (Decir que las cadenas se "convierten" es incorrecto, recuerde que las cadenas son inmutables, por lo que una función como lowercase devuelve cadenas nuevas).

Finalmente, procesarlinea actualiza el histograma creando un nuevo elemento o incrementando uno existente.

Para contar el número total de palabras en el archivo, podemos sumar las frecuencias en el histograma:

El número de palabras diferentes es el número de elementos en el diccionario:

Para imprimir los resultados se puede usar el siguiente código:

Observación: No se considera el encabezado del archivo de texto, sólo el libro.

Para encontrar las palabras más comunes, podemos hacer un arreglo de tuplas, donde cada tupla contiene una palabra y su frecuencia, y ordenarlas. La siguiente función toma un histograma y devuelve un arreglo de tuplas de frecuencia de palabras:

En cada tupla, la frecuencia aparece primero, por lo que el arreglo resultante se ordena por frecuencia. A continuación se muestra un bucle que imprime las 10 palabras más comunes:

En este ejemplo utilizamos un carácter de tabulación ('\t') como "separador", en vez de un espacio, por lo que la segunda columna está alineada. A continuación se muestran los resultados de Don Quijote:

Se han tratado funciones integradas de Julia que toman argumentos opcionales. También es posible escribir funciones definidas por el programador con argumentos opcionales. Por ejemplo, aquí hay una función que imprime las palabras más comunes en un histograma:

El primer parámetro es obligatorio y el segundo es opcional. El valor predeterminado de num es 10.

Si solo pasas un argumento:

num toma el valor predeterminado. Si pasas dos argumentos:

num toma el valor del argumento. En otras palabras, el argumento opcional anula el valor predeterminado.

Si una función tiene parámetros obligatorios y opcionales, los parámetros obligatorios deben ir primero, seguidos de los opcionales.

Encontrar las palabras de un libro que no están en la lista de palabras de palabras.txt es un problema similar a una resta de conjuntos, es decir, se quiere encontrar todas las palabras de un conjunto (las palabras en el libro) que no están en el otro (las palabras en la lista).

resta toma los diccionarios d1 y d2 y devuelve un nuevo diccionario que contiene todas las claves de d1 que no están en d2. Como realmente no importan los valores, se fijan como nothing.

Para encontrar las palabras en el libro que no están en palabras.txt, se ouede usar procesararchivo para construir un histograma para palabras.txt, y luego la función resta:

Estos son algunos de los resultados de Don Quijote:

Algunas de estas palabras son conjugaciones de verbos. Otros, como "solene", ya no son de uso común. ¡Pero algunas son palabras comunes que deberían estar en la lista!

Para elegir una palabra aleatoria del histograma, el algoritmo más simple es construir un arreglo con múltiples copias de cada palabra, de acuerdo con la frecuencia observada, y luego elegir una palabra del arreglo:

Este algoritmo funciona pero no es muy eficiente ya que cada vez que elige una palabra aleatoria, reconstruye el arreglo, que es tan grande como el libro original. Una mejora es construir el arreglo una vez y luego hacer múltiples selecciones, pero el arreglo sigue siendo grande.

Una alternativa es:

Si elige palabras del libro al azar, puede tener una idea del vocabulario usado, pero probablemente no se va a obtener una oración:

Una serie de palabras aleatorias rara vez tiene sentido porque no hay relación entre palabras sucesivas. Por ejemplo, en una oración real, se esperaría que un artículo como "el" fuese seguido por un sustantivo y probablemente no un verbo o un adverbio.

Una forma de medir este tipo de relaciones es con el análisis de Markov, que define para una secuencia dada de palabras la probabilidad de las palabras que podrían venir después. Por ejemplo, en la canción La vida es un carnaval (de Celiz Cruz):

En este texto, la frase "que piense" siempre va seguida de la palabra "que", pero la frase "piense que" puede ir seguida de "la" o "esto".

El resultado del análisis de Markov es un mapeo de cada prefijo (como "que piense" y "piense que") a todos los sufijos posibles (como "la" y "esto").

Dada esta asignación, se puede generar un texto aleatorio comenzando con cualquier prefijo y eligiendo aleatoriamente entre los posibles sufijos. A continuación, puede combinar el final del prefijo y el nuevo sufijo para formar el siguiente prefijo y repetir.

Por ejemplo, si comienza con el prefijo "Que la", la siguiente palabra será "vida", porque el prefijo solo aparece dos veces en el texto y siempre está seguido de este sufijo. El siguiente prefijo es "la vida", por lo que el siguiente sufijo podría ser "siempre" o "es".

En este ejemplo, la longitud del prefijo siempre es dos, pero puede hacer análisis de Markov con un prefijo de cualquier longitud.

Usar análisis de Markov para generar texto aleatorio es divertido, pero además, este ejercicio tiene un trasfondo: la selección de la estructura de datos. En los los ejercicios anteriores, tenía que elegir:

El último es fácil: un diccionario es la opción obvia para una asociación entre claves y valores correspondientes.

Para los prefijos, las opciones más obvias son cadena, arreglo de cadenas o tupla de cadenas.

Para los sufijos, puede ser un arreglo o un histograma (diccionario).

¿Cómo se elige? El primer paso es pensar en las operaciones que deberá implementar para cada estructura de datos. Para los prefijos, se debe ser capaz de eliminar palabras del principio y agregarlas al final. Por ejemplo, si el prefijo actual es "que piense" y la siguiente palabra es "que", debe poder formar el siguiente prefijo, "piense que".

Para los prefijos, podría elegir un arreglo, ya que en él es fácil agregar y eliminar elementos.

Para la colección de sufijos, las operaciones que se deben realizar incluyen agregar un nuevo sufijo (o aumentar la frecuencia de uno existente) y elegir un sufijo aleatorio.

Agregar un nuevo sufijo es igualmente fácil para la implementación del arreglo o del histograma. Elegir un elemento aleatorio de un arreglo es fácil pero elegir eficientemente de un histograma es más difícil (ver Ejercicio 13-7).

Hasta ahora se ha hablado principalmente sobre la facilidad de implementación, pero hay otros factores a considerar al elegir las estructuras de datos. Uno es el tiempo de ejecución. A veces hay una razón teórica para esperar que una estructura de datos sea más rápida que otra. Por ejemplo, anteriormente se mencionó que el operador in es más rápido para los diccionarios que para los arreglos, al menos cuando el número de elementos es grande.

Aunque generalmente no se sabe de antemano qué implementación será más rápida, una opción es implementar ambos y ver cuál es mejor. Este enfoque se llama benchmarking. Una alternativa práctica es elegir la estructura de datos que sea más fácil de implementar y luego ver si es lo suficientemente rápida para la aplicación prevista. Si es así, no hay necesidad de continuar. Si no, hay herramientas, como el módulo Profile, que pueden identificar los lugares en un programa que toman más tiempo.

El otro factor a considerar es el espacio de almacenamiento. Por ejemplo, usar un histograma para la colección de sufijos puede tomar menos espacio porque solo tiene que almacenar cada palabra una vez, sin importar cuántas veces aparezca en el texto. En algunos casos, ahorrar espacio también puede hacer que su programa se ejecute más rápido. En el peor de los casos, su programa podría no ejecutarse si se queda sin memoria pero para muchas aplicaciones el espacio es una consideración secundaria después del tiempo de ejecución.

Una última reflexión: en esta discusión, se ha dado a entender que se debería usar una estructura de datos para el análisis y la generación. Pero dado que estas son fases separadas, también sería posible usar una estructura para el análisis y luego convertirla en otra estructura para la generación. Esto sería conveniente si el tiempo ahorrado durante la generación excede el tiempo dedicado a la conversión.

Cuando está depurando un programa, y especialmente si está tratando de resolver un error difícil, hay cinco cosas que puede probar:

Los programadores principiantes a veces se atascan en una de estas actividades y olvidan las otras. Cada actividad viene con su propia forma de fallar.

Por ejemplo, leer su código podría ayudar si el problema es un error tipográfico, pero no si el problema es un malentendido conceptual. Si no comprende lo que hace su programa, puede leerlo 100 veces y nunca ver el error, porque el error está en su cabeza.

Ejecutar experimentos puede ayudar, especialmente si ejecuta pruebas pequeñas y simples, pero si ejecuta experimentos sin pensar o leer su código, puede caer en un patrón llamado "programación de caminata aleatoria", que es el proceso de hacer cambios aleatorios hasta que el programa haga lo correcto. No hace falta decir que la programación de caminata aleatoria puede llevar mucho tiempo.

La persona que programa tiene que tomarse su tiempo para pensar. La depuración es como una ciencia experimental. Debe tener al menos una hipótesis sobre la causa del problema. Si hay dos o más opciones, trate de pensar en una prueba que elimine una de ellas.

Incluso las mejores técnicas de depuración fallarán si hay demasiados errores, o si el código que está tratando de corregir es demasiado grande y complicado. A veces, la mejor opción es volver atrás, simplificando el programa hasta que llegue a algo que funcione y que comprenda.

Los programadores principiantes a menudo son reacios a volver atrás porque no pueden soportar eliminar una línea de código (incluso si es incorrecto). Si le hace sentir mejor, copie su programa en otro archivo antes de comenzar a eliminarlo. Luego puede copiar las piezas una por una.

Encontrar un error difícil requiere leer, ejecutar, reflexionar y, a veces, volver atrás. Si se queda atascado en una de estas actividades, pruebe las otras.

La mayoría de los programas que hemos visto hasta ahora han sido transitorios, es decir, se ejecutan por un tiempo corto y generan una salida pero cuando finalizan, sus datos desaparecen. Si ejecuta el programa nuevamente, este comienza de cero.

Otros programas, en cambio, son persistentes, se ejecutan durante un largo período de tiempo (o todo el tiempo), mantienen al menos parte de sus datos en almacenamiento permanente (en un disco duro, por ejemplo) y si se apagan y vuelven a comenzar, retoman donde lo dejaron.

Ejemplos de programas persistentes son los sistemas operativos, que se ejecutan siempre que una computadora esté encendida, y los servidores web, que se ejecutan todo el tiempo esperando a que lleguen solicitudes a la red.

Una de las formas más simples para que los programas mantengan sus datos es leyendo y escribiendo archivos de texto. Ya se han visto programas que leen archivos de texto y en este capítulo se van a ver programas que los escriben.

Otra alternativa es almacenar el estado del programa en una base de datos. En este capítulo también se presentará cómo usar una base de datos simple.

Un archivo de texto es una secuencia de caracteres almacenados en un medio permanente, como un disco duro o una memoria flash. Ya se vio cómo abrir y leer un archivo en Leer listas de palabras.

Para escribir un archivo, debe abrirlo usando el modo "w" (de write) como segundo parámetro:

Si el archivo ya existe, abrirlo en modo de escritura borra los datos antiguos y comienza de nuevo, ¡así que tenga cuidado!. Si el archivo no existe, se crea uno nuevo. open devuelve un objeto de archivo y la función write escribe datos en el archivo.

El valor de retorno es el número de caracteres que se escribieron. El objeto de archivo fout lleva el registro de dónde se quedó por última vez, por lo que si llama a write nuevamente, esta agrega nuevos datos al final del archivo.

Cuando el usuario haya terminado de escribir, debe cerrar el archivo.

Si no cierra el archivo, este se cierra cuando finaliza el programa.

El argumento de write tiene que ser una cadena, por lo que si queremos poner otros valores en un archivo, tenemos que convertirlos a cadenas. La forma más fácil de hacerlo es con la función string o con interpolación de cadenas:

Otra alternativa es utilizar la familia de funciones de print(ln).

Los archivos están organizados en directorios (también llamados "carpetas"). Cada programa en ejecución tiene su propio "directorio actual", que es el directorio que usará por defecto para para la mayoría de las operaciones. Por ejemplo, cuando abre un archivo para leer, Julia lo busca en el directorio actual.

La función pwd (en inglés "print working directory") devuelve el nombre del directorio actual:

cwd significa "directorio del trabajo actual" (en inglés “current working directory”). El resultado en este ejemplo es /home/ben, que es el directorio de inicio de un usuario llamado ben.

Una cadena como "/home/ben" que identifica un archivo o directorio se llama ruta o path.

Un nombre de archivo simple, como memo.txt también se considera una ruta aunque es una ruta relativa porque comienza en el directorio actual. Si el directorio actual es /home/ben, el nombre de archivo memo.txt se refiere a /home/ben/memo.txt.

Una ruta que comienza con / no depende del directorio actual. Este tipo de ruta se llama ruta absoluta. Para encontrar la ruta absoluta de un archivo, puede usar abspath:

Julia también tiene otras funciones para trabajar con nombres de archivo y rutas. Por ejemplo, ispath comprueba si existe un archivo o directorio:

Si existe, isdir comprueba si es un directorio:

Del mismo modo, isfile comprueba que se trate de un archivo.

readdir devuelve un arreglo de los archivos (y otros directorios) en el directorio dado:

Para mostrar el comportamiento de estas funciones, el siguiente ejemplo "recorre" un directorio, imprime los nombres de todos los archivos y se llama a sí misma, de manera recursiva, en todos los directorios.

joinpath toma un directorio y un nombre de archivo y los une en una ruta completa.

Muchas cosas pueden salir mal al intentar leer y escribir archivos. Al intentar abrir un archivo que no existe, se obtiene un SystemError:

Si el usuario intenta abrir un archivo pero no tiene permiso para acceder a él, obtiene el error de sistema "Permission denied" (Permiso denegado).

Para evitar estos errores se podrían usar funciones como ispath e isfile pero tomaría mucho tiempo y líneas de código verificar todas las posibilidades.

Es más fácil intentar lidiar con los problemas a medida que ocurren, que es exactamente lo que hace la sentencia try. La sintaxis es similar a una sentencia if:

Julia comienza ejecutando el bloque try. Si nada falla, se saltará el bloque catch y finalizará. Si ocurre una excepción, Julia saltará fuera del bloque try y ejecutará el bloque catch.

Gestionar una excepción con try recibe el nombre de capturar una excepción. En este ejemplo, el bloque catch muestra un mensaje de error que no es muy útil. En general, capturar una excepción da la oportunidad de corregir el problema, volverlo a intentar o, al menos, terminar el programa con elegancia.

Cuando el código realiza cambios de estado o usa recursos, como archivos, generalmente se deben hacer ciertas cosas al finalizar la programación del código, como por ejemplo cerrar los archivos. Las excepciones pueden complicar esta tarea, ya que se podría salir antes de lo esperado de un bloque de código. La palabra reservada finally permite ejecutar un código al salir de un bloque de código determinado, independientemente de cómo salga:

En este ejemplo, la función close siempre se ejecutará.

Una base de datos es un archivo que está organizado para almacenar datos. La mayoría de las bases de datos están organizadas como diccionarios, en el sentido de que realizan asociaciones entre claves y valores. La diferencia más importante entre un diccionario y una base de datos, es que la base de datos se encuentra en el disco (u otro almacenamiento permanente), de modo que su contenido se conserva después de que el programa haya finalizado.

IntroAJulia proporciona una interfaz para GDBM (GNU dbm), que permite crear y actualizar archivos de base de datos. A modo de ejemplo, se crea una base de datos que contiene pies de foto para archivos de imagen.

Abrir una base de datos es similar a abrir otros archivos:

El modo "c" significa que la base de datos debe crearse si no existe. El resultado es un objeto de base de datos que se puede usar (para la mayoría de las operaciones) como un diccionario.

Cuando se crea un nuevo elemento, GDBM actualiza el archivo de base de datos:

Cuando accede a uno de los elementos, GDBM lee el archivo:

Si realiza otra asignación a una clave existente, GDBM reemplaza el valor anterior:

Algunas funciones que tienen un diccionario como argumento, con claves y valores, no funcionan con objetos de base de datos. No obstante, la iteración con un bucle for sí:

Al igual que con otros archivos, debe cerrar la base de datos cuando haya terminado:

Una limitación de GDBM es que las claves y los valores deben ser cadenas o conjuntos de bytes. Si intenta utilizar cualquier otro tipo, se producirá un error.

Las funciones serialize y deserialize pueden ser útiles. Traducen casi cualquier tipo de objeto en un arreglo de bytes (un iobuffer) adecuado para el almacenamiento en una base de datos y luego traducen los arreglos de bytes nuevamente en objetos:

El formato no es intuitivo para nosotros pero es fácil de interpretar para Julia. deserialize reconstituye el objeto:

serialize y deserialize escriben y leen desde un objeto iobuffer que representa un I/O stream en memoria. La función take! recupera el contenido del iobuffer como un arreglo de bytes y reestablece el iobuffer a su estado inicial.

Aunque el nuevo objeto tiene el mismo valor que el anterior, no es (en general) el mismo objeto:

En otras palabras, la serialización y luego la deserialización tienen el mismo efecto que copiar el objeto.

Esto se puede usar para almacenar valores que no sean cadenas en una base de datos.

La mayoría de los sistemas operativos proporcionan una interfaz de línea de comandos, también conocida como shell. Las shells generalmente proporcionan comandos para navegar por el sistema de archivos y ejecutar aplicaciones. Por ejemplo, en Unix puede cambiar los directorios con cd, mostrar el contenido de un directorio con ls e iniciar un navegador web escribiendo (por ejemplo) firefox.

Cualquier programa que se pueda iniciar desde la shell también puede iniciarse desde Julia usando un objeto de comando:

Las comillas invertidas se usan para delimitar el comando.

La función run ejecuta el comando:

hola es la salida del comando echo, enviado a STDOUT. La función run devuelve un objeto de proceso y genera un ErrorException si el comando externo no se ejecuta correctamente.

Si se desea leer la salida del comando externo, se puede usar read en su lugar:

Por ejemplo, la mayoría de los sistemas Unix tienen un comando llamado md5sum o md5 que lee el contenido de un archivo y calcula una "suma de verificación". Puede leer sobre Md5 en https://en.wikipedia.org/wiki/Md5. Este comando proporciona una manera eficiente de verificar si dos archivos tienen el mismo contenido. La probabilidad de que diferentes contenidos produzcan la misma suma de comprobación es muy pequeña.

Puede usar un objeto de comando para ejecutar md5 desde Julia y obtener el resultado:

Supongamos que tenemos un archivo llamado "wc.jl" con el siguiente código:

Si ejecuta este programa, se leen las líneas de código y se imprime el número de líneas en el archivo, que es 9. También puede incluirlo en REPL de esta manera:

Los módulos permiten crear espacios de trabajo separados, es decir, nuevos global scopes (ámbitos de tipo global). Una sentencia tiene global scope si tiene efecto en todo el programa.

Un módulo comienza con la palabra reservada module y termina con end. Al usar módulos, se evitan los conflictos de nombres entre sus propias definiciones de nivel superior y las que se encuentran en el código de otra persona. import permite controlar qué nombres de otros módulos están visibles y export especifica cuáles de sus nombres son públicos, es decir, aquellos que se pueden usar fuera del módulo sin tener el prefijo del nombre del módulo.

El módulo ContarLineas proporciona la función contarlineas:

Al leer y escribir archivos, el usuario puede tener problemas con los espacios en blanco. Estos errores pueden ser difíciles de depurar porque los espacios, las tabulaciones y las nuevas líneas son generalmente invisibles:

Las funciones integradas repr o dump pueden ser de ayuda. Toman cualquier objeto como argumento y devuelven una representación de tipo cadena del objeto.

Esto puede ser útil para la depuración.

Otro problema con el que es fácil encontrarse es que en diferentes sistemas operativos se usan diferentes caracteres para indicar el final de una línea. Algunos sistemas usan una nueva línea, representada por \n. Otros usan un carácter de retorno \r. Algunos usan ambos. Si un archivo es usado en diferentes sistemas, estas inconsistencias podrían causar problemas.

Para la mayoría de los sistemas, hay aplicaciones para convertir de un formato a otro. Puede encontrarlas (y leer más sobre este tema) en https://en.wikipedia.org/wiki/Newline. O, por supuesto, podría escribir una usted mismo.