Introdução à programação em Julia

O Julia foi originalmente lançada em 2012 por Alan Edelman, Stefan Karpinski, Jeff Bezanson, e Viral Shah. Ela é uma linguagem de programação gratuita e open source.

Escolher uma linguagem de programação é sempre subjetivo. Para mim, as seguintes características do Julia são decisivas:

O Julia é uma linguagem de programação única pois resolve o chamado "problema de duas linguagens". Nenhuma outra linguagem de programação é necessária para escrever código de alta performance. Isso não significa que isso acontece automaticamente. É de responsabilidade do programador otimizar o código que forma um gargalo, mas isso pode ser feito no próprio Julia.

Este livro é para qualquer um que quer aprender a programar. Nenhum conhecimento prévio é requerido.

Novos conceitos são introduzidos gradualmente e tópicos mais avançados são descritos em capítulos posteriores.

Introdução à programação em Julia (Think Julia) pode ser usado para um curso de um semestre em nível de ensino médio ou de universidade.

As seguintes conveções foram adotadas neste livro:

Todo código usado neste livro está disponível em um repositório Git no Github: https://github.com/JuliaIntro/JuliaIntroBR.jl. Se você não esta familiarizado com o Git, ele é um sistema de controle de versão que permite ao usuário acompanhar os arquivos que fazem parte de um projeto. Um conjunto de arquivos sob controle do Git é chamado de “repositório”. O Github é um serviço de hospedamento que fornece armazenamento para repositórios Git e uma interface web conveniente.

Um pacote de conveniência é fornecido que pode ser diretamente adicionado ao Julia. Apenas digite add https://github.com/JuliaIntro/JuliaIntroBR.jl No REPL em modo Pkg, veja [turtles].

A maneira mais fácil de executar código em Julia é indo para https://repl.it e iniciar uma sessão gratuita. Tanto o REPL quanto um editor estão disponíveis. Se você quiser ter o Julia instalado localmente no seu computador, você pode fazer o download do JuliaPro gratuitamente de Julia Computing. Ele consiste de uma versão recente do Julia, um ambiente interativo de desenvolvimento baseado no Atom e um número de pacotes Julia pré-instalados. Se você quiser se aventurar ainda mais, você pode fazer o download do Julia em https://julialang.org, instalar o editor que você quiser (ex. Atom ou Visual Studio Code), e ativar plug-ins para integração do Julia. Para uma instalação local, você também pode adicionar o pacote IJulia e executar um notebook Jupyter no seu computador.

Eu realmente gostaria de agradecer ao Allen por escrever Think Python e permitir que eu pudesse adaptar o seu livro para o Julia. Seu entusiasmo é contagiante!

Eu também gostaria de agradecer aos revisores técnicos para este livro, que fizeram muitas sugestões utéis: Tim Besard, Bart Janssens, e David P. Sanders.

Obrigado à Melissa Potter da O’Reilly Media, que fez deste livro melhor. Você me forçou a fazer as coisas certo e fazer este livro o mais original possível.

Obrigado a Matt Hacker da O’Reilly Media, que me ajudou com o conjunto de ferramentas Atlas e alguns problemas de destacação de sintaxe.

Obrigado a todos os estudantes que trabalharam com uma versão inicial deste livro e todos os contribuidores (listados abaixo) que mandaram correções e sugestões.

Se você tem uma sugestão ou correção, porfavor mande um email à ben.lauwens@gmail.com ou abra um issue em GitHub. Se eu fizer uma mudança baseada no seu feedback, irei adicioná-lo na lista de contribuidores (a menos que você peça para ser omitido).

Me diga com qual versão do livro você esta trabalhando, e qual formato. Se você incluir ao menos parte da frase aonde o erro aparece, isso facilitará a minha busca. Páginas e número de seção também ajudam, mas não são tão facéis de trabalhar. Obrigado!

Uma declaração de atribuição cria uma nova variável e da à ela um valor:

Este exemplo faz três atribuições. A primeira atribui uma string à uma nova variável chamada mensagem; a segunda dá o inteiro 17 a n; a terceira atribui (aproximadamente) o valor de \(\pi\) a π_val (\pi TAB).

Um jeito comum de representar variáveis no papel é escrevendo o nome com uma flecha apontando para o seu valor. Este tipo de figura é denominado de diagrama de estado pois mostra em que estado cada variável encontra-se (imagine isso como sendo o estado de espirito da variável) Diagrama de estado mostra o resultado do exemplo anterior.

Programadores geralmente escolhem nomes para suas variáveis que são significativos—eles documentam para o que a variável é usada.

Nomes de variáveis podem ser o quão longas você desejar. Eles podem conter quase todos os caracteres Unicode (veja [caracteres]), mas não podem começar com um número. É permitido usar letras maiúsculas, mas é convencional utilizar somente letras minúsculas para nomes de variáveis.

caracteres Unicode podem ser inseridos através do autocompletar do tab de abreviações similares à LaTeX no REPL do Julia.

O caractere sublinhado, _, pode aparecer em um nome. É comumente utilizado em nomes com multiplas palavras, como seu_nome ou velocidade_de_uma_andorinha_sem_carga.

Se um nome inválido for dado a uma variável, recebemos um erro de sintaxe:

76trombones é inválido pois começa com um número. mais@ é inválido pois contem um caractere inválido, @. Mas o que há de errado com struct?

Acontece que struct é uma das palavras chave do Julia. O REPL usa palavras chaves para reconhecer a estrutura do programa, e elas não podem ser usadas como nomes de variáveis.

O Julia possui as seguintes palavras chave:

Nós não precisamos memorizar esta lista. Na maior parte dos ambientes desenvolvidos, palavras chave são exibidas em diferentes cores; se nós tentarmos utilizar uma como um nome de variável, saberemos.

Uma expressão é uma combinação de valores, variáveis e operadores. Um valor por si só é considerado uma expressão, assim como uma variável, então as expressões a seguir são todas válidas:

Quando nós digitamos uma expressão no prompt, o REPL a avalia, o que significa que ele acha o valor da expressão. Neste exemplo, n tem valor 17 e n + 25 valor 42.

Uma declaração é uma unidade de código que possui um efeito, como criar uma variável ou exibir um valor.

A primeira linha é uma declaração de atribuição que da valor a n. A segunda linha é uma declaração de impressão que exibe o valor de n.

Quando nós digitamos uma declaração, o REPL a executa, o que significa que ele faz o que a declaração diz.

Até agora nós rodamos o Julia em modo interativo, o que significa que nós interagimos diretamente com o REPL. O modo interativo é uma boa maneira de começar, mas se nós estamos trabalhando com mais do que poucas linhas de código, ele pode ser inadequado.

A alternativa é salvar o código em um arquivo chamado script e em seguida rodar o Julia em modo script para executar o script. Por convenção, scripts Julia possuem nomes que terminam com .jl.

Se você sabe como criar e rodar um script no seu computador, você está pronto pra utilizar. No entanto eu recomendaria utilizar o Repl.it novamente. Abrir um arquivo de texto, escrever um script e salvá-lo com a extensão .jl. O script pode ser executado em um terminal com o comando julia nome_do_script.jl.

Como o Julia nos fornece ambos os modos, podemos testar pequenos trechos de código no modo interativo antes de colocá-los num script. Mas há diferenças entre o modo interativo e o modo script que podem ser um pouco confusas.

Por exemplo, se nós estamos usando o Julia como uma calculadora, podemos digitar

A primeira linha atribui um valor à milhas e exibe o seu valor. A segunda linha é uma expressão, então o REPL avalia-a e exibe o resultado. Acontece que uma maratona é aproximadamente 42 quilômetros.

Mas se digitarmos o mesmo código num script e rodá-lo, não temos resultado algum. No modo script uma expressão, por si só, não possui nenhum efeito visível. Na verdade o Julia avalia a expressão, mas não exibe o valor a não ser que nós mandemos-o:

Esse comportamente pode ser um pouco confuso no início.

Um script geralmente contém uma sequência de declarações. Se existe mais de uma declaração, os resultados aparecem um de cada vez conforme as declarações são executadas.

Por exemplo, o script

produz o resultado

A declaração de atribuição não produz nenhum resultado.

Quando uma expressão contém mais de um operador, a ordem de avaliação depende da precedência de operador. Para operadores matemáticos, Julia segue convenções matemáticas. O acrônimo PEMDAS é uma maneira útil de lembrar as regras:

Em geral, não podemos executar operações matemáticas em strings, mesmo se as strings pareçam-se com números, então o que se segue abaixo é inválido.

Mas existem duas exceções, * e ^.

O operador * executa a concatenação de strings, o que signifca que ele junta as strings ligando-as de ponta-a-ponta. Por exemplo:

O operador ^ também funciona em strings; ele executa a repetição. Por exemplo, "Spam"^3 é "SpamSpamSpam". Se um dos valores é uma string, o outro deve ser um inteiro.

Este uso de * e ^ faz sentido com analogia à multiplicação e exponenciação. Assim como 4^3 é equivalente a 4*4*4, nós esperamos que "Spam"^3 seja igual a "Spam"*"Spam"*"Spam", e é.

À medida que os programas ficam maiores e mais complicados, eles ficam mais dificéis de ler. Linguagens formais são densas, e é comum ser difícil olhar para um pedaço de código e descobrir o que está acontecendo, ou por quê.

Por esta razão, é uma boa ideia adicionar anotações em nossos programas para explicar em uma linguagem natural o que o programa esta fazendo. Estas anotações são chamadas de comentários, e eles começam com o símbolo #:

Neste caso, o comentário aparece numa linha por si só. Nós também podemos colocar comentários no final da linha:

Tudo a partir do # até o final da linha é ignorado e não causa efeito algum na execução do programa.

Comentários são bastante utéis quando eles documentam caractereísticas não óbvias do código. É razoável assumir que o leitor consegue descobrir o que o código faz; é mais útil explicar o por quê.

Esse comentário é redundante com o código e inútil:

Esse comentário contém informação útil que não está no código:

Três tipos de erros podem ocorrer em um programa: erros de sintaxe, erros de execução e erros de semântica. É útil distinguir entre eles a fim de localizá-los mais rapidamente.

Nós já vimos um exemplo de chamada de função:

O nome da função é println. A expressão entre parênteses é o argumento da função.

É comum dizer que uma função "pega" um argumento e "retorna" um resultado que também é chamado de valor de retorno.

Julia fornece funções que convertem valores de um tipo para outro. A função parse recebe uma string e a converte em qualquer tipo de número se puder, ou dá erro caso contrário:

trunc pode converter valores de ponto flutuante em valores inteiros, mas não os arredonda; o comando trunca a parte fracionária:

float converte números inteiros em números de ponto flutuante:

Por último, string converte o seu argumento em uma string:

Em Julia, a maioria das funções matemáticas tradicionais estão diretamente disponíveis:

Este primeiro exemplo usa log10 para calcular uma relação sinal-ruído em decibéis (assumindo que potência_sinal e potência_ruído estão definidos). log, que calcula logaritmos naturais, também é dado.

Este segundo exemplo calcula o seno de radianos. O nome da variável é uma dica de que sin e de que as outras funções trigonométricas (cos, tan, etc.) recebem argumentos em radianos. Para converter de graus em radianos, divida por 180 e multiplique pelo \(\pi\):

O valor da variável π é uma aproximação do ponto flutuante de \(\pi\), com precisão de aproximadamente de 16 dígitos.

Se você conhece trigonometria, pode verificar o resultado anterior comparando-o com a raiz quadrada de dois dividido por dois:

Até este momento, vimos os elementos de um programa—variáveis, expressões e comandos—isoladamente, sem detalhar em como combiná-las.

Um dos recursos mais úteis das linguagens de programação é a sua capacidade de manipular pequenos blocos de montar e compô-los. Por exemplo, o argumento de uma função pode ser qualquer tipo de expressão, incluindo operadores aritméticos:

E até mesmo as chamadas de função:

Em quase todos os lugares onde você pode colocar um valor, pode-se colocar uma expressão arbitrária, com uma exceção: o lado esquerdo de uma atribuição tem que ser um nome de variável. Qualquer outra expressão do lado esquerdo resulta em um erro de sintaxe (veremos exceções a esta regra mais tarde).

Embora tenhamos usado só as funções que vêm com Julia até agora, também é possível adicionar novas funções. A definição da função especifica o nome de uma nova função e a sequência de comandos que são executados quando a função é chamada. Aqui está um exemplo:

function é uma palavra-chave que indica a definição de função. O nome da função é imprimir_letras. As regras para nomes de funções são as mesmas dos nomes de variáveis: eles podem conter quase todos os caracteres Unicode (veja [caracteres]), mas o primeiro caracter não pode ser um número. Você não pode usar uma palavra-chave como nome de uma função, e evite ter uma variável e uma função com o mesmo nome.

Os parênteses vazios após o nome da função indicam que esta função não recebe nenhum argumento.

A primeira linha da definição da função é o cabeçalho; o restante é chamado de corpo. Finaliza-se o corpo com a palavra-chave end e pode conter qualquer número de comandos. Para facilitar a leitura, o corpo da função deve estar indentado.

As aspas devem ser "aspas retas" (""), geralmente localizadas abaixo do Esc no teclado. As "aspas encaracoladas" ou "aspas inglesas" (“”), como as que estão nesta frase, não são legais em Julia.

Se você definir uma função no modo interativo, o REPL indentará para informar que a definição não está finalizada:

Para terminar a função, deve-se inserir end.

A sintaxe para chamar a nova função é a mesma das funções internas:

Uma vez definida uma função, você pode usá-la dentro de outra função. Por exemplo, para repetir o refrão anterior, poderíamos escrever uma função chamada repetir_letras:

E depois é só chamar repetir_letras:

Mas não é bem assim que a música é.

Reunindo os pedaços de código da seção anterior, o programa completo fica assim:

Este programa contém duas definições de funções: imprimir_letras e repetir_letras. As definições de funções são executadas exatamente como outros comandos, e o resultado é a criação de objetos do tipo função. Os comandos dentro da função não são executados até que a função seja chamada, e a definição da função não gera saída.

Como você pode esperar, deve-se criar uma função antes de poder executá-la. Em outras palavras, a definição da função tem que ser executada antes de chamá-la.

Para garantir a definição de uma função antes de sua primeira chamada, é necessário conhecer a ordem dos comandos executados, conhecido como fluxo de execução.

A execução é feita sempre a partir do primeiro comando do programa. Os comandos são executados uma de cada vez, de cima para baixo.

As definições das funções não mudam o fluxo de execução do programa, mas lembre-se que os comandos dentro da função são executados somente quando a função é chamada.

Quando a função é chamada, é como um desvio no fluxo de execução. Em vez de ir para o comando seguinte, o fluxo salta para o corpo da função, executa os comandos lá e depois volta para continuar de onde parou.

Isso parece bastante simples, até você lembrar que uma função pode chamar outra. Enquanto estiver no meio de uma função, o programa pode ter a necessidade de executar os comandos em uma outra função. Logo, ao executar essa nova função, o programa pode precisar executar outra função!

Felizmente, Julia é bom em monitorar seus passos, portanto, toda vez que uma função é concluída, o programa retoma de onde parou na função que a chamou. Chegando ao final do programa, ele é encerrado.

Em resumo, quando você lê um programa, nem sempre deseja ler de cima para baixo. Às vezes, é mais lógico seguir o fluxo de execução.

Algumas das funções que vimos exigem argumentos. Por exemplo, quando você chama sin, um número é passado como argumento. Algumas funções usam mais de um argumento: parse necessita de dois, um tipo de número e uma string.

Dentro da função, os argumentos são atribuídos a variáveis denominadas parâmetros. Aqui está uma definição para uma função que exige um argumento:

Esta função atribui o argumento a um parâmetro denominado bruno. Quando a função é chamada, imprime-se o valor do parâmetro (qualquer que seja) duas vezes.

Esta função funciona com qualquer valor que possa ser impresso.

As mesmas regras de composição que se aplicam às funções embutidas também se aplicam às funções definidas pelo programador, portanto podemos usar qualquer tipo de expressão como argumento para imprimir2vezes:

O argumento é avaliado antes da chamada da função, de modo que nos exemplos as expressões "Spam "^4 e cos(π) são avaliadas apenas uma vez.

Também pode-se usar uma variável como argumento:

O nome da variável que passamos como argumento (ana) não tem nada a ver com o nome do parâmetro (bruno). Para a função imprimir2vezes, todos os parâmetros são chamados bruno, independentemente do nome da variável que passamos como argumento (neste caso, ana)

Ao criar uma variável dentro de uma função, ela é local, isto é, ela existe apenas dentro da função. Por exemplo:

Esta função exige dois argumentos, concatena-os e imprime o resultado duas vezes. A seguir um exemplo que a usa:

Após o término de concat_imprimir2vezes, a variável concat é destruída. Se tentarmos imprimi-la, aparece uma exceção:

Os parâmetros também são locais. Por exemplo, fora do imprimir2vezes, não existe o bruno.

Para verificar quais variáveis podem ser usadas e onde, às vezes é prático desenhar um diagrama de pilha. Da mesma maneira dos diagramas de estado, os diagramas de pilha mostram o valor de cada variável, e mostram também a função à qual cada variável pertence.

Cada função é indicada por um quadro, que é representado por uma caixa com o nome de uma função ao lado e os parâmetros e as variáveis da respectiva função dentro dele. O diagrama de pilha do exemplo anterior é ilustrado em Stack diagram.

Os quadros são dispostos em uma pilha que mostra qual função é chamada por outra, e assim por diante. Neste exemplo, imprimir2vezes foi chamada por concat_imprimir2vezes, e concat_imprimir2vezes foi chamada por Main, que é um nome especial para o quadro superior. Criando uma variável fora de qualquer função, ela pertence a Main.

Cada parâmetro recebe o mesmo valor que o seu argumento correspondente. Logo, parte1 tem o mesmo valor que linha1, da mesma forma que parte2 tem o mesmo valor que linha2, e bruno tem o mesmo valor que concat.

Em um caso de erro durante uma chamada de função, Julia imprime o nome da função, o nome da função que a chamou, e o nome da função que chamou por ela, e assim por diante até chegar no Main.

Por exemplo, se você tentar acessar concat de dentro de imprimir2vezes, você recebe um UndefVarError:

Esta lista de funções é chamada de rastreamento de pilha, que informa em qual arquivo de programa ocorreu o erro, em qual linha e quais funções estavam sendo executadas no momento. Também indica a linha de código que causou o erro.

A ordem das funções no rastreamento de pilha é a ordem inversa dos quadros no diagrama de pilha. A função atualmente em execução fica no topo.

Algumas das funções que usamos, como as funções matemáticas que retornam resultados; por falta de um nome melhor, chamaremos de funções produtivas. As outras funções, como imprimir2vezes, que executam uma ação sem retornar um valor chamaremos de funções nulas.

Quando você chama uma função produtiva, quase sempre deseja-se fazer algo com o resultado; por exemplo, atribuí-lo a uma variável ou usá-lo como parte de uma expressão:

Ao chamar uma função no modo interativo, Julia exibe o seguinte resultado:

Porém em um script, se chamar uma função produtiva por si só, o valor de retorno será perdido para sempre!

Output:

Este script calcula a raiz quadrada de 5, que não é armazenado e nem exibido o resultado, e assim, não é muito útil.

As funções nulas podem exibir algo na tela ou ter algum outro efeito, mas não retorna um valor. Se atribuir o resultado a uma variável, obterá um valor especial chamado nothing.

Para imprimir o valor nothing, usa-se a função show que é similar a print mas que pode lidar com o valor nothing.

O valor nothing não é o mesmo que a string "nothing". Pois é um valor especial que tem seu próprio tipo:

As funções que temos escrito até o momento são todas nulas. Começaremos a escrever funções produtivas em alguns capítulos.

Pode não estar claro o motivo de fragmentar um programa em funções, mas existem várias razões:

Uma das habilidades mais significativas que você vai adquirir é a depuração. Ainda que possa ser frustrante, a depuração é uma das partes da programação mais intelectualmente rica, desafiadora e interessante.

De certa forma, a depuração é como um trabalho de detetive. Você é confrontado com pistas e precisa inferir os processos e eventos que levaram aos resultados encontrados.

A depuração também é como uma ciência experimental. Uma vez que você tem uma ideia do que está dando errado, modifique seu programa e tente novamente. Se a sua hipótese estiver correta, pode-se prever o resultado da modificação e aproximar-se de um programa funcional. Se a sua hipótese estava errada, inventa-se uma nova. Como Sherlock Holmes apontou,

Algumas pessoas consideram que a programação e a depuração são a mesma coisa, já que a programação é o processo de depurar gradualmente um programa até que ele faça o que o programador deseja. A ideia é começar com um programa funcional e fazer pequenas mudanças, depurando-as à medida que avança.

Por exemplo, o Linux é um sistema operacional com milhões de linhas de código, mas começou como um programa simples que Linus Torvalds usava para examinar o chip Intel 80386. De acordo com Larry Greenfield, "um dos primeiros projetos de Linus era um programa que alternava entre imprimir "AAAA" e "BBBB". Este mais tarde evoluiu para Linux. ” (The Linux Users' Guide Versão Beta 1).

Um módulo é um arquivo que contém uma coleção de funções relacionadas. O Julia fornece alguns módulos na sua biblioteca padrão. Mais funcionalidades podem ser adicionadas a partir de uma crescente coleção de pacotes (https://juliaobserver.com).

Pacotes podem ser instalados no REPL através do modo Pkg usando a tecla ].

Isso pode demorar um pouco.

Antes de podermos usar as funções de um módulo, temos que importá-lo usando a declaração using:

O módulo JuliaIntroBR possui uma função chamada Turtle que cria um objeto Luxor.Turtle, que atribuímos a uma variável chamada 🐢 (\:turtle: TAB).

Logo após criarmos a tartaruga, podemos chamar uma função que a move ao redor de um desenho. Por exemplo, para mover a tartaruga para a frente:

A palavra-chave @svg executa uma macro que desenha uma imagem SVG. Macros são uma parte importante, mas avançada, do Julia.

Os argumentos de forward são a tartaruga e a distância em pixels, portanto o tamanho real do movimento depende do seu monitor.

Outra função que nós podemos chamar com tartaruga como argumento é turn, para virar. O segundo argumento para turn é o ângulo em graus.

Além disso, cada tartaruga está segurando uma caneta, que pode estar tanto para baixo ou para cima; se a caneta está para baixo, a tartaruga deixa uma trilha quando ela se move. Movendo a tartaruga para a frente mostra a trilha deixada pela tartaruga. As funções penup e pendown significam respectivamente “caneta para cima” e “caneta para baixo”.

Para desenhar um ângulo reto, modifique a chamada de macro:

Existe uma chance de que você escreveu algo como:

Nós podemos fazer a mesma coisa de forma mais concisa com uma declaração for:

Esse é o uso mais simples da declaração for; nós veremos mais usos mais tarde. Mas isso deve ser o suficiente para que você possa reescrever o seu programa que desenha um quadrado. Não avançe até que você o faça.

Aqui está uma declaração for que desenha um quadrado:

A sintaxe de uma declaração for é similar a uma definição de função. Ela possui um cabeçalho e um corpo que termina com a palavra-chave end. O corpo pode conter qualquer número de declarações.

Uma declaração for também é chamada de laço, pois o fluxo de execução percorre o corpo e em seguida retorna até o topo em um ciclo. Nesse caso, ela percorre o corpo quatro vezes.

Essa versão é na verdade um pouco diferente do código que desenha um quadrado visto anteriormente, pois faz mais uma curva depois de desenhar o último lado do quadrado. A curva adicional leva mais tempo, mas simplifica o código se fizermos a mesma coisa toda vez que percorre o laço. Essa versão também faz a tartaruga retornar para sua posição inicial, de frente à direção inicial.

A seguir estão uma série de exercícios utilizando turtles. Elas tem o propósito de serem divertidas, mas tem um objetivo também. Enquanto você trabalha com elas, pense sobre qual é o objetivo.

O primeiro exercício pede para que você coloque o seu código de desenhar quadrado em uma definição de função, e que em seguida você chame essa função utilizando tartaruga como parâmetro. Aqui está a solução:

As declarações forward e turn são indentadas duas vezes para mostrar que elas estão dentro do laço for, que está dentro da definição da função.

Dentro da função, t refere-se à mesma tartaruga 🐢, então turn(t, -90) tem o mesmo efeito que turn(🐢, -90). Neste caso, por que não chamar o parâmetro +🐢 ? A ideia é que t pode ser qualquer tartaruga, não somente 🐢, então você pode criar uma segunda tartaruga e passá-la como argumento para quadrado.

Envolver um pedaço de código em uma função é chamado de encapsulamento. Um dos benefícios do encapsulamento é que ele anexa um nome ao código, que serve como uma forma de documentação. Outra vantagem é que se você está re-utilizando o código, é mais conciso chamar a função duas vezes do que copiar e colar o corpo!

O próximo passo é adicionar com aos parâmetros de quadrado. Aqui está a solução:

Adicionar um parâmetro a uma função é chamado de generalização pois faz com que a função seja mais abrangente: na versão anterior, o quadrado sempre tem o mesmo tamanho; nesta versão ele pode ter qualquer tamanho.

O próximo passo também é uma generalização. Ao invés de desenhar quadrados, polígono desenha polígonos regulares com qualquer número de lados. Aqui está a solução:

Este exemplo desenha um heptágono de lado medindo 70.

O próximo passo é escrever círculo, que recebe um raio r como parâmetro. Aqui está uma solução simples que usa polígono para desenhar um polígono de 50 lados:

A primeira linha computa a circunferência de um círculo com raio \(r\) usando a fórmula \(2 \pi r\). n é o número de segmentos de linha usados na nossa aproximação de um círculo, e com é o comprimento de cada segmento. Portanto, polígono desenha um polígono de 50 lados que se aproxima um círculo de raio r.

Uma limitação dessa solução é que n é uma constante, o que significa que para círculos bem grandes, os segmentos de linha são muito longos, e para círculos pequenos, nós gastamos tempo desenhando segmentos bem pequenos. Uma solução seria generalizar a função para que ela receba n como parâmetro. Isso daria ao usuário (qualquer um que chame círculo) mais controle, mas a interface seria menos limpa.

A interface de uma função é um resumo de como ela deve ser usada: quais são os parâmetros? O que a função faz? E qual o seu valor de retorno? Uma interface é “limpa” se permite àquele que chamou a função fazer tudo o que ele quer sem precisar lidar com detalhes desnecessários.

Neste exemplo, r pertence à interface pois especifica o círculo a ser desenhado. n é menos apropriada pois diz respeito aos detalhes de como o círculo deve ser renderizado.

Em vez de bagunçar a interface, é melhor escolher um valor apropriado de n dependendo de circunferência:

Agora o número de segmentos é um inteiro ao redor de circunferência/3, então o comprimento de cada segmento é aproximadamente 3, que é pequeno o suficiente para que os círculos fiquem bons, mas grande o suficiente para ser eficaz, e aceitável para qualquer tamanho de círculo.

Adicionar 3 a n garante que o polígono tenha no mínimo 3 lados.

Quando escrevemos círculo, pudemos reutilizar polígono pois um polígono com vários lados é uma boa aproximação de um círculo. Mas arco não é igualmente cooperativo; não podemos usar polígono ou círculo para desenhar um arco.

Uma alternativa é começar com uma cópia de polígono e transformá-la em arco. O resultado pode parecer algo como:

A segunda metade dessa função parece-se com polígono, mas nós não podemos reusar polígono sem mudar a interface. Nós poderíamos generalizar polígono para receber ângulo como terceiro argumento, mas então polígono não seria mais um nome apropriado! Ao invés disso, chamaremos a função mais geral polilinha:

Agora nós podemos reescrever polígono e arco para usar polilinha:

Finalmente, nós podemos reescrever círculo para usar arco:

Este processo de reorganização de um programa para melhorar interface e facilitar o reuso de código é chamado de refatoração. Neste caso, nós percebemos que havia código similar em arco e polígono, então nós o “fatoramos” para dentro de polilinha.

Se nós tivéssemos planejado com antecedência, nós poderíamos ter escrito polilinha primeiro e evitado a refatoração, mas você frequentemente não sabe o suficiente no começo de um projeto para planejar todas as interfaces. A partir do momento em que você começa a programar, você passa a entender o problema melhor. Às vezes refatoração é um sinal de que você aprendeu alguma coisa.

Um plano de desenvolvimento é um processo para escrever programas. O processo que usamos nesse estudo de caso é “encapsulamento e generalização”. Os passos desse processo são:

Esse processo tem algumas desvantagens-nós veremos as alternativas mais tarde-mas pode ser útil se você não sabe previamente como dividir o programa em funções. Essa abordagem permite que você planeje conforme você vai projetando.

Uma docstring é uma string que vem antes de uma função e descreve sua interface (“doc” refere-se a “documentação”). Aqui está um exemplo:

A documentação pode ser acessada no REPL ou em um notebook digitando ? seguido pelo nome de uma função ou macro, e apertando ENTER;

Docstrings são comumente strings envolvidas por três aspas, também conhecidas por strings multi-linha, pois as três aspas permitem que a string abranja mais de uma linha.

Uma docstring contém a informação essencial que alguém precisaria para usar essa função. Ela explica concisamente o que a função faz (sem entrar em detalhes de como ela faz). Ela explica que efeito cada parâmetro tem na execução da função e qual tipo cada parâmetro deve ser (se não é óbvio).

Uma interface é como um contrato entre a função e quem a chama. Quem chama concorda em fornecer certos parâmetros e a função concorda em fazer um certo trabalho.

Por exemplo, polilinha requer quatro argumentos: t tem que ser uma tartaruga; n tem que ser um inteiro; com deve ser um número positivo; e ângulo tem que ser um número, que assume-se ser uma medida em graus.

Esses requerimentos são chamados de precondições pois eles deveriam ser verdadeiros antes que a função execute. Inversamente, condições no final da função são chamadas de pós-condições. Pós-condições incluem o efeito desejado da função (como desenhar segmentos de linha) e qualquer efeito colateral (como mover a tartaruga ou fazer outra mudança).

precondições são de responsabilidade de quem chama a função. Se quem chama viola uma precondição (propriamente documentada!) e a função não funciona adequadamente, o bug está em quem chamou, e não na função.

Se as precondições são satisfeitas e as pós-condições não, então o bug está na função. Se as suas pré- e pós-condições forem claras, elas podem ajudar na hora de depurar.

O operador de divisão inteira, ÷ (\div TAB), divide dois números e arredonda pra baixo para um inteiro. Por exemplo, suponha que o tempo de duração de um filme seja de 105 minutos. Talvez você queira saber o quanto isso equivale em horas. A divisão convencional retorna um número em ponto-flutuante:

Porém, normalmente não escrevemos horas com pontos decimais. A divisão inteira retorna um número inteiro de horas, arredondando para baixo:

Para obter o resto, você pode subtrair uma hora em minutos:

Uma alternativa é usar o operador módulo, %, que divide dois números e retorna o resto.

Uma expressão booleana é uma expressão que é ou verdadeira ou falsa. Os seguintes exemplos usam o operador ==, que compara dois operandos e gera true se forem iguais e false--do inglês, verdadeiro e falso, respectivamente.

true e false são valores especiais que pertencem ao tipo Bool; esses valores não são strings:

O operador == é um dos operadores de relação; os outros são:

Existem três operadores lógicos: && (e), || (ou) e ! (não). A semântica (significado) destes operadores são similiares aos seus significados em Português. Por exemplo, x > 0 && x < 10 é verdadeiro se e somente se x é maior que 0 e menor que 10.

n % 2 == 0 || n % 3 == 0 é verdadeiro se uma ou ambas condições são verdadeiras, isto é, se o número é divisível por 2 ou por 3.

Tanto && quanto || associam à direita, mas && tem maior precedência que ||.

Por fim, o operador ! nega uma expressão booleana, então !(x > y) é verdadeira se x > y é falsa, isto é, se x é menor ou igual a y.

Para escrever programas úteis, quase sempre precisamos verificar as condições e alterar o comportamento de acordo com o programa. Comandos condicionais nos fornecem essa habilidade. A forma mais simples é o comando if (da conjunção se em Inglês).

A expressão booleana depois de if é chamada de condição. Se é verdadeira, então o comando indentado é executado. Se não, nada acontece.

O comando if possui a mesma estrutura das definições de funções: Um cabeçalho seguido de um corpo terminado com a palavra-chave end. Comandos como esse são chamadas de comandos compostos.

Não há limites para o número de comandos que podem aparecer no corpo. Ocasionalmente, é útil ter um corpo sem comandos (geralmente como detentor de um lugar para o código que você ainda não escreveu).

Uma segunda maneira de usar o comando if é através da "execução alternativa", que oferece duas possibilidades e a condição determina qual delas deverá ser executada. A sintaxe é a seguinte:

Se o resto da divisão de x por 2 é 0, então sabemos que x é par, e o programa irá exibir a mensagem apropriada. Se a condição for falsa, o segundo conjunto de comandos será executado. Desde que a condição seja verdadeira ou falsa, exatamente uma das alternativas irá ser executada. Essas alternativas são chamadas de ramos (branches em inglês), porque são ramos de um fluxo de execução.

Algumas vezes há mais do que duas possibilidades e precisamos de mais que dois ramos. Uma maneira de expressar um comando como esse é através de condicionais encadeadas:

Novamente, exatamente um dos ramos será executado. Não há limites para o número de comandos elseif. Se existir uma cláusula else, essa deve estar no final, mas não precisa haver uma.

Cada condição é checada em ordem. Se a primeira for falsa, a próxima é checada e assim por diante. Se uma delas é verdadeira, o ramo correspondente é executado e o comando é encerrado. Se mais de uma condição é verdadeira, apenas o primeiro ramo verdadeiro é executado.

Uma condicional também pode ser aninhada com outra. O exemplo da seção anterior poderia ter sido escrito da seguinte maneira:

O condicional externo contém dois ramos. O primeiro ramo contém um comando simples. O segundo ramo contém outro condicional if, que possui dois ramos inseridos nele. Esses dois ramos são comandos simples, embora também possam ter sido declarações condicionais.

Embora a indentação não obrigatória das declarações torne a estrutura aparente, as condicionais aninhadas tornam-se difíceis de ler muito rapidamente. Uma boa ideia é evitá-las quando puder.

Operadores lógicos geralmente produzem uma maneira de simplificar instruções condicionais aninhadas. Por exemplo, podemos reescrever o seguinte código usando uma única condicional:

O comando print executa somente se for verdadeira nas duas condições, para que possamos obter o mesmo efeito com operador &&:

Para esse tipo de condição, o Julia fornece uma sintaxe mais concisa:

É possível fazer com que uma função chame outra; também é possível uma função chamar a si mesma. Pode não parecer óbvio por que isso é uma coisa boa, mas acaba sendo uma das coisas mais mágicas que um programa pode fazer. Por exemplo, observe a seguinte função:

Se n é 0 ou negativo, será exibido a frase "Feliz Ano Novo!". Caso contrário, a função exibe n e chama uma função chamada contagem_regressiva—ela mesma— passando n-1 como argumento.

O que acontece se chamarmos uma função como essa?

A execução de contagem_regressiva começa com n = 3, e como n é maior que 0, terá como saída o valor 3, e depois executa a si mesma…​

 A execução de contagem_regressiva começa com n = 2, e como n é maior que 0,
  terá como saída o valor 2, e depois executa a si mesma …​

  A execução de contagem_regressiva começa com n = 1, e como n é maior que 0,
   terá como saída o valor 1, e depois executa a si mesma …​

   A execução de contagem_regressiva começa com n = 0, e como n não é maior que
    0, terá como saída uma frase, "Feliz Ano Novo!" e depois retorna.

  A contagem regressiva que obteve n = 1 retorna.

 A contagem regressiva que obteve n = 2 retorna.

A contagem regressiva que obteve n = 3 retorna.

E então você retornará para Main.

Uma função que chama a si mesma é dita recursiva; o processo de execução desta função é chamada de recursão.

Um outro exemplo é que podemos escrever uma função que imprime uma string \(n\) vezes.

Se n <= 0 o comando return sai da função. O fluxo de execução retorna imediatamente para quem a chamou e as linhas restantes da função não são executadas.

O restante da função é similar a contagem_regressiva: Ela exibirá s e chamará a si mesma para exibir s \(n-1\) várias vezes. Portanto, o número de linhas de saída é \(1 + (n - 1)\), o que soma \(n\).

Para exemplos simples como esse, provavelmente é mais fácil usar um laço for. Veremos exemplos em que são difíceis de escrever com um laço for e fáceis de escrever com recursão; portanto, é uma boa ideia começar cedo.

Em Diagramas de Pilha, usamos um diagrama de pilha para representar o estado de um programa durante uma chamada de função. O mesmo tipo de diagrama pode ajudar a interpretar uma função recursiva.

Sempre que uma função é chamada, o Julia cria um quadro para conter os parâmetros e as variáveis locais da função. Para uma função recursiva, pode haver mais de um quadro na pilha ao mesmo tempo.

Diagrama de Pilha mostra um diagrama de pilha para contagem_regressiva chamada com n = 3.

Como sempre, o topo da pilha é o quadro para Main. Ele está vazio porque não criamos nenhuma variável em Main ou nem passamos algum argumento para ela.

Os quatro quadros de contagem_regressiva contém valores diferentes para o parâmetro n. A parte inferior da pilha, onde n = 0, é chamada de caso base. Ele não faz uma chamada recursiva, portanto não há mais quadros.

Se uma recursão nunca atinge o caso base, ela continua fazendo chamadas recursivas para sempre e o programa nunca termina. Isso é conhecido como recursão infinita, e geralmente isso não é uma boa ideia. À seguir, um pequeno programa com uma recursão infinita:

Na maioria dos ambientes de programação, um programa com recursão infinita realmente não é executado para sempre. O Julia exibe uma mensagem de erro quando a profundidade máxima de recursão é atingida:

Esse rastreamento de pilha é um pouco maior do que vimos no capítulo anterior. Quando o erro ocorre, existem 80000 quadros de recursão na pilha!

Se você encontrar uma recursão infinita por acidente, revise a sua função para confirmar se há um caso base que não faz uma chamada recursiva. E se houver, verifique que você está garantindo o alcance do caso base.

Os programas que escrevemos até agora não aceitam nenhuma entrada do usuário. Eles apenas fazem a mesma coisa toda hora.

O Julia fornece uma função interna chamada readline que interrompe o programa e aguarda o usuário digitar algo. Quando o usuário pressiona RETURN ou ENTER, o programa é retomado e readline retorna o que o usuário digitou como uma sequência de caracteres.

Antes de receber informações do usuário, é uma boa ideia imprimir um prompt informando ao usuário o que digitar:

Um ponto e vírgula ; permite colocar múltiplos comandos na mesma linha. No REPL apenas o último comando retornará seu valor.

Se você espera que o usuário digite um número inteiro, tente converter o valor de retorno para Int64:

Mas se o usuário digitar algo diferente de uma sequência de dígitos, você receberá um erro:

Veremos como lidar com esse tipo de erro posteriormente.

Quando um erro de sintaxe ou de tempo de execução ocorrer, a mensagem de erro contém muitas informações, mas ela pode ser avassaladora. As partes mais úteis são geralmente:

Os erros de sintaxe geralmente são fáceis de encontrar, mas existem algumas ressalvas. Em geral, as mensagens de erro indicam onde o problema foi descoberto, mas o verdadeiro erro pode estar antes no código, às vezes em uma linha anterior.

O mesmo vale para erros de tempo de execução. Suponha que você esteja tentando calcular uma taxa de sinal/ruído em decibéis. A fórmula é

No Julia você pode escrever desta forma:

E você obtém:

Com certeza não era um resultado que você estava esperando.

Para encontrar o erro, pode ser útil imprimir o valor da razão, que acaba sendo 0. O problema está na linha 3, que usa a divisão de piso em vez da divisão do ponto flutuante.

A chamada de uma função gera um valor de retorno, que geralmente atribuímos a uma variável ou utilizamos como parte de uma expressão.

As funções escritas até o momento são nulas, o que significa que elas não têm valor de retorno; mais precisamente, seu valor de retorno é nothing. Neste capítulo, (finalmente) vamos escrever funções produtivas. O primeiro exemplo é a função área, que retorna a área de um círculo dado um raio:

Já vimos o comando return anteriormente, mas em uma função produtiva o comando return inclui uma expressão. Este comando significa: "Retorne imediatamente a partir desta função e leve a expressão seguinte como um valor de retorno". Como essa expressão pode ser arbitrariamente complicada, então poderíamos ter escrito uma função mais sucinta:

O valor retornado por uma função é o valor do último comando executado, que, por padrão, é a última expressão no corpo da definição da função.

Além disso, variáveis temporárias como a e as instruções explícitas return podem contribuir para a depuração.

Às vezes, é prático ter diversos comandos return, uma em cada ramo de uma condicional:

E já que estas instruções de retorno estão em alternativas exclusivas, somente uma é executada.

Assim que um comando return é executado, a função termina sem executar qualquer comando posterior. O código que aparece após um comando return, ou qualquer outro lugar que o fluxo de execução jamais possa alcançar, é chamado de código morto.

Em uma função produtiva, recomendamos garantir que todos os caminhos possíveis através do programa chegue em um comando de retorno. Por exemplo:

Essa função está incorreta porque se x for 0, nenhuma das condições é verdadeira, e a função termina sem chegar a um comando return. Quando o fluxo de execução chega ao final de uma função, o valor de retorno é nothing, que não é o valor absoluto de 0.

À medida que se escreve funções maiores, talvez aconteça de você passar mais tempo depurando.

Ao lidar com programas cada vez mais complexos, tente um processo chamado desenvolvimento incremental, que adiciona e testa apenas uma pequena quantidade de código por vez, evitando assim longas sessões de depuração.

Para exemplificar esse processo, suponha que você queira determinar a distância entre dois pontos, dada pelas coordenadas \(\left(x_1, y_1\right)\) e \(\left(x_2, y_2\right)\). Pelo teorema de Pitágoras, a distância é:

O primeiro passo é avaliar como deve ser uma função de distância em Julia. Em outras palavras, quais são as entradas (os parâmetros) e qual é a saída (o valor de retorno)?

Neste exemplo, as entradas são dois pontos, que pode ser representado por quatro números. Já o valor de retorno é a distância representada por um valor de ponto flutuante.

Com isso, pode-se esboçar a função:

Obviamente que essa versão não determina as distâncias pois ela sempre retorna zero. Mas é sintaticamente correta, e roda, o que significa que você pode testá-la antes de complicá-la. Os números dos subscritos estão disponíveis na codificação de caracteres Unicode (\_1 TAB, \_2 TAB, etc.).

Para testar a nova função, chame-a com argumentos exemplificados a seguir:

Escolhemos estes valores para que a distância horizontal seja 3 e a vertical seja 4; logo, o resultado é 5 porque é a hipotenusa de um triângulo retângulo 3-4-5. Quando testar uma função, o aconselhável é já saber a resposta correta.

Nesse ponto, como já confirmamos que a função está sintaticamente correta, então podemos começar a adicionar código ao corpo. Um passo subsequente razoável é encontrar as diferenças \(x_2 - x_1\) e \(y_2 - y_1\). A próxima versão da função armazena esses valores em variáveis temporárias que são mostradas com a macro @show.

Se a função estiver funcionando, ela deve exibir dx = 3 e dy = 4. Nesse caso, sabemos que a função está obtendo os argumentos certos e executando os primeiros cálculos corretamente. Caso contrário, há apenas poucas linhas para analisar.

Em seguida, somamos os quadrados de dx e de dy:

Você executaria o programa mais uma vez nesse estágio e verificaria a saída (que deveria ser 25). Números sobrescritos também estão disponíveis (\^2 TAB). Por fim, usa-se sqrt para calcular e retornar o resultado final:

Se a função rodar corretamente, pronto. Caso contrário, convém mostrar o valor de sqrt(d²) antes do comando return.

A versão final da função não exibe nada quando é executada, retornando apenas um valor. As instruções de impressão que escrevemos são úteis para a depuração, mas depois que a função estiver funcionando, devemos removê-las. Um código como esse é chamado andaime porque é útil para criar o programa, embora não faça parte do produto final.

Ao iniciar, você deve adicionar apenas uma ou duas linhas de código por vez. À medida que você adquire mais experiência, pode se escrever e depurar pedaços maiores. De qualquer forma, o desenvolvimento incremental pode economizar muito tempo de depuração.

Os principais aspectos do processo são:

Como já esperado, você pode chamar uma função de dentro da outra. Para exemplificar isso, escreveremos uma função que calcula a área do círculo a partir de dois pontos, o centro do círculo e um ponto no perímetro.

Suponha que o ponto central é indicado pelas variáveis xc e yc, e o ponto de perímetro é indicado por xp e yp. O primeiro passo é encontrar o raio do círculo, dado pela distância entre estes dois pontos. Note que acabamos de escrever a função distância:

O próximo passo é calcular a área de um círculo a partir desse raio, e por isso também escrevemos essa função:

Encapsulando esses passos em uma função, temos:

As variáveis temporárias raio e resultado são úteis para o desenvolvimento e a depuração, mas depois que o programa estiver funcionando, podemos torná-lo mais conciso fazendo:

As funções podem retornar valores booleanos, o que muitas vezes é conveniente para ocultar testes complicados dentro de funções. Por exemplo:

Frequentemente se atribui nomes de funções booleanas que soam como perguntas de sim/não; neste caso, é_divisível retorna true ou false para saber se x é divisível por y.

Eis um exemplo:

O resultado do operador == é um valor booleano, logo podemos escrever a função de forma mais sucinta por meio de um comando direto:

Funções booleanas são constantemente utilizadas em estruturas condicionais:

Talvez seja tentador escrever algo como:

No entanto, a comparação adicional com true é desnecessária.

Mostramos apenas uma pequena fração de Julia, mas você pode estar interessado em saber que essa fração é uma linguagem de programação completa, significando que qualquer coisa que possa ser calculada pode ser expressa nessa linguagem. Qualquer programa já escrito pode ser reescrito usando apenas os recursos da linguagem que você aprendeu até o momento (na verdade, você precisaria de alguns comandos para controlar dispositivos como mouse, discos, etc., mas isso é tudo).

Essa afirmação é um exercício não trivial provado pela primeira vez por Alan Turing, um dos primeiros cientistas da computação (alguns argumentariam que ele era matemático, mas muitos dos primeiros cientistas da computação começaram como matemáticos). Por isso, esta prova é conhecida como a Tese de Turing. Para uma discussão mais completa (e precisa) da Tese de Turing, recomendo o livro Introdução à teoria da computação de Michael Sipser.

Para ter uma noção do que você pode fazer com as ferramentas que sabe até agora, avaliaremos algumas funções matemáticas definidas recursivamente. Uma definição recursiva é semelhante a uma definição circular, no sentido de que a definição contém uma chamada de si própria. Uma definição totalmente circular não é muito vantajosa:

Ver essa definição no dicionário pode ser irritante. Por outro lado, se consultar a definição da função fatorial, denotada com o símbolo \(!\), poderá obter algo assim:

Essa definição diz que o fatorial de 0 é 1, e o fatorial de qualquer outro valor \(n\) é \(n\) multiplicado pelo fatorial de \(n-1\).

Então \(3!\) é 3 vezes \(2!\), que é 2 vezes \(1!\), que é 1 vezes \(0!\). Colocando tudo junto, \(3!\) é igual a 3 vezes 2 vezes 1 vezes 1, que dá 6.

Se puder escrever uma definição recursiva de algo, pode-se escrever um programa em Julia para testá-la. A primeira etapa é decidir quais devem ser os parâmetros. E nesse caso, é evidente que o fatorial recebe um número inteiro:

Se o argumento for 0, basta retornar 1:

Caso contrário, e esta é a parte interessante, temos que fazer uma chamada recursiva para encontrar o fatorial de n-1 para depois multiplicá-lo por n:

O fluxo de execução deste programa é similar ao fluxo de contagem regressiva em Recursão. Chamando fatorial do valor 3:

Diagrama de Pilha mostra como fica o diagrama de pilha para esta sequência de chamadas de função.

Os valores de retorno são exibidos quando devolvidos de volta para cima da pilha. Em cada quadro, o valor de retorno é o valor de resultado, dado pelo produto de n com recursão.

No último quadro, as variáveis locais recursão e resultado não existem porque o ramo que as cria não é executado.

Ler programas seguindo o fluxo de execução pode se tornar rapidamente exaustivo. Uma alternativa que eu chamo de "salto de fé" faz a leitura conforme o fluxo de execução e quando se chega a uma chamada de função, assume-se que a função funciona corretamente e devolve o resultado correto.

Na verdade, você já está praticando este salto de fé no uso de funções embutidas. Quando você chama cos ou exp, você não investiga os corpos dessas funções. Você apenas assume que funcionam já que as pessoas que escreveram as funções embutidas eram bons programadores.

A mesma prática ocorre quando você chama uma de suas próprias funções. Por exemplo, em Funções Booleanas, escrevemos a função é_divisível que determina se um número é divisível por outro. Depois de nos convencermos de que essa função está correta ao examinar seu código e testar, podemos usá-la sem olhar para o corpo novamente.

O mesmo se aplica aos programas recursivos. Ao chegar na chamada recursiva, em vez de acompanhar o fluxo de execução, deve-se assumir que a chamada recursiva funciona (retorna o resultado correto) e depois se perguntar: “Supondo que possa encontrar o fatorial do \(n-1\), posso calcular o fatorial do \(n\)?” Sim, multiplicando por \(n\).

É claro que é um pouco estranho assumir que a função funciona corretamente quando ainda não se terminou de escrevê-la, mas é por isso que se chama salto de fé!

Após fatorial, o exemplo mais familiar de uma função matemática definida recursivamente é a sequência de Fibonacci, cuja definição é (consulte https://pt.wikipedia.org/wiki/Sequência_de_Fibonacci):

Traduzindo para Julia, tem-se:

Se você tentar acompanhar o fluxo de execução aqui, mesmo para valores razoavelmente pequenos de n, sua cabeça vai enlouquecer. No entanto, de acordo com o salto de fé, se presumir que as duas chamadas recursivas funcionam sem erros, fica nítido que o resultado certo é obtido a partir da soma delas.

O que ocorre se chamarmos fatorial e atribuirmos 1.5 como argumento?

Parece uma recursão infinita. Como pode ser? A função tem um caso base—quando n == 0. Mas se n não for um número inteiro, podemos perder o caso base e ficar recursivo para sempre.

Na primeira chamada recursiva, o valor de n é 0.5. No próximo, é -0.5. A partir daí, vai diminuindo e ficando cada vez mais negativo, mas nunca será 0.

Temos duas escolhas. Podemos tentar generalizar a função fatorial para trabalhar com números de ponto flutuante, ou podemos fazer fatorial verificar o tipo de argumento. Na primeira opção, tem-se a função gama que está um pouco além do escopo deste livro. Logo, vamos adotar a segunda opção.

Podemos usar o operador embutido isa para verificar o tipo do argumento. Ainda falando no assunto, também podemos certificar que o argumento seja positivo:

Enquanto o primeiro caso-base aborda os não-inteiros; o segundo aborda os inteiros negativos. Para esses dois casos, o programa exibe uma mensagem de erro e devolve nothing para indicar que algo deu errado:

Se passarmos pelas duas verificações, concluímos que n é positivo ou zero, logo, conseguimos provar que a recursão termina.

Esse programa demonstra um padrão às vezes de guardião. Os dois primeiros condicionais atuam como guardiões, protegendo o código de valores que podem causar um erro. Além disso, os guardiões tornam possível provar a execução sem erro do código.

Em Capturando Exceções, veremos uma alternativa mais flexível para mostrar uma mensagem de erro: levantando uma exceção.

Dividir um programa grande em funções menores cria pontos de verificação naturais para a depuração. Caso uma função não esteja funcionando, há três possibilidades para analisar:

Para descartar a primeira possibilidade de erro, você pode imprimir no início da função os valores dos parâmetros (e possivelmente seus tipos). Ou pode escrever um código que verifique claramente as precondições.

Se os parâmetros parecerem bons, imprima o valor de retorno adicionando um comando de impressão antes de cada comando de retorno. Se possível, verifique o resultado à mão. Considere chamar a função com valores que facilitem a conferência do resultado (como em Desenvolvimento Incremental).

Caso a função pareça estar funcionando, observe a chamada de função para garantir que o valor de retorno esteja sendo usado corretamente (ou se está mesmo sendo usado!).

Adicionar comandos de impressão no início e no final de uma função pode facilitar o acompanhamento do fluxo de execução. Por exemplo, aqui está uma versão de fatorial com comandos print:

espaço é uma string de espaços que atua na indentação da saída:

Caso o fluxo de execução não esteja claro, esse tipo de saída de impressões pode ser útil. Leva algum tempo para usar andaimes eficientemente, mas um pouco de andaime pode economizar muita depuração.

Como você deve ter descoberto, é permitido fazer mais de uma atribuição para as mesmas variáveis. Uma nova atribuição faz com que uma variável existente se refira a um novo valor (e pare de se referir ao valor antigo).

A primeira vez que exibimos x, o seu valor é 5; na segunda vez, o seu valor é 7.

Diagrama de estado mostra como uma reatribuição funciona por meio de um diagrama de estado.

Neste ponto, queremos abordar um assunto comum de confusão. Como o Julia usa o sinal de igual (=) para a atribuição, é tentador interpretar uma afirmação como a = b como uma proposição matemática de igualdade; isto é, a afirmação de que a e b são iguais. Mas essa interpretação está errada.

Primeiro que a igualdade é uma relação simétrica e a atribuição não é. Por exemplo, em matemática, se \(a=7\) então \(7=a\). Mas em Julia, a atribuição a=7 é permitida e 7=a não.

Também na matemática, uma proposição de igualdade ou é verdadeira ou é falsa para sempre. Se \(a=b\) agora, então \(a\) será sempre igual a \(b\). Em Julia, uma atribuição pode fazer duas variáveis iguais, mas elas não precisam ficar assim:

A terceira linha altera o valor de a mas não altera o valor de b, portanto eles não são mais iguais.

Um tipo comum de reatribuição é uma atualização, onde o novo valor da variável depende do antigo.

Isso significa “pegue o valor atual de x, adicione um, e então atualize x ao novo valor.”

Se você tenta atualizar uma variável que não existe, uma mensagem de erro aparecerá, porque o Julia avalia o lado direito antes de atribuir um valor a x:

Antes que você possa atualizar uma variável, deve-se inicializá-la geralmente com uma atribuição simples:

Atualizar uma variável adicionando 1 é chamado de incremento; e subtraindo 1 é chamado de decremento.

Os computadores são frequentemente usados para automatizar tarefas repetitivas. Repetir tarefas idênticas ou semelhantes sem cometer erros é algo que os computadores fazem bem, ao contrário das pessoas. Em um programa de computador, a repetição também é chamada de iteração.

Já vimos duas funções, contador_regressivo e imprima_n, que iteram usando recursão. Como a iteração é muito comum, Julia dispõe de recursos para simplificá-la. Um deles é a declaração for que vimos em Repetição Simples. Voltaremos a este assunto mais tarde.

A outra é a declaração while. Aqui está a versão de contagem_regressiva que utiliza a declaração while:

Você pode ler a declaração while quase como se estivesse em Português, traduzindo while por enquanto. Ela significa “Enquanto n for maior que 0, exiba o valor de n e depois diminua n. Quando chegar a 0, imprima a palavra Decolar!”

Formalmente, segue abaixo o fluxo de execução de uma declaração while:

Esse tipo de fluxo é chamado de laço porque o terceiro passo retorna ao topo.

O corpo do laço deve mudar o valor de uma ou mais variáveis até que eventualmente a condição se torna falsa e o laço é finalizado. Caso contrário, o laço irá se repetir para sempre, ou seja, um laço infinito. Uma fonte inesgotável de diversão para os cientistas da computação são as instruções nos frascos de shampoo, “ensaboe, enxague, repita”, pois é um laço infinito.

No caso da função contagem_regressiva, podemos provar que o laço é finalizado: se n é zero ou negativo, o laço nunca termina. Caso contrário, n vai diminuindo durante o laço e então eventualmente chegará a 0.

Para alguns laços, não é tão fácil de provar. Por exemplo:

A condição para esse laço é n != 1, então esse laço irá continuar até que n seja 1, o que faz a condição ser falsa.

A cada passada do laço, o programa tem como saída o valor n que é verificado se é par ou ímpar. Se é par, n é dividido por 2. Se é ímpar, o valor de n é substituído por n*3 + 1. Por exemplo, se o argumento da sequência é 3, os valores de n recebidos são 3, 10, 5, 16, 8, 4, 2, 1.

Já que n às vezes cresce e às vezes decresce, não existe uma demonstração óbvia de que n resultará em 1 ou que o programa termine. Para alguns valores particulares de n, podemos demonstrar que termina. Por exemplo, se o valor inicial é uma potência de dois, n será sempre par durante o laço até que chega em 1. O exemplo anterior finaliza essa sequência, a partir de 16.

A parte difícil é provar que esse programa finaliza para todos os valores positivos de n. Até agora ninguém foi capaz de provar ou desprovar isso! (Consulte https://pt.wikipedia.org/wiki/Conjectura_de_Collatz.)

Às vezes, você não sabe que é hora de terminar um laço até chegar na metade do corpo. Neste caso você pode utilizar a declaração break para sair do laço.

Por exemplo, suponha que você queira receber entradas do usuário até que ele digite concluído. Poderia-se escrever:

A condição deste laço é true, que é sempre verdade, então o laço será executado até chegar na declaração break.

A cada iteração, a solicitação ao usuário ocorre por meio de um sinal de maior (">"). Se o usuário digitar concluído, então a declaração break finaliza o laço. Caso contrário, o programa mostrará o que o usuário digitar e voltará ao topo do laço. Aqui está um exemplo de execução:

Essa maneira de escrever laços é comum porque você pode verificar a condição em qualquer lugar do laço (não apenas no topo) e você pode expressar a condição de parada afirmativamente ("pare quando isso acontecer") ao invés de negativamente ("continue enquanto isso acontece").

A declaração break sai do laço. Quando uma declaração continue é encontrado dentro de um laço, salta-se para o início do laço da próxima iteração, pulando a execução de comandos dentro do corpo do laço da iteração atual. Por exemplo:

Output:

Se i é divisível por 3, a declaração continue para na iteração atual e a próxima iteração é iniciada. Apenas os números no intervalo entre 1 a 10 não divisíveis por 3 são exibidos.

Laços são frequentemente usados em programas que calculam resultados numéricos começando com um valor aproximado e aprimorando-o iterativamente.

Por exemplo, uma maneira de calcular raízes quadradas é através do método de Newton. Suponha que você queira saber a raiz quadrada de \(a\). Se você começar com uma estimativa qualquer, \(x\), pode-se calcular uma estimativa melhor com a seguinte fórmula:

Por exemplo, se \(a\) é 4 e \(x\) é 3:

O resultado está mais próximo da resposta correta (\(\sqrt 4 = 2\)). Se repetirmos o processo com a nova estimativa, ficará mais próximo ainda:

Depois de mais algumas atualizações, a estimativa é quase exata:

Em geral, não sabemos antecipadamente quantos passos são necessários para obter a resposta certa, mas sabemos quando chegamos lá porque a estimativa para de mudar:

Quando y == x, podemos parar. Aqui está um laço que começa com uma estimativa inicial x, e melhora até parar de mudar:

Essa função funciona bem para a maior parte dos valores de a, mas em geral é perigoso testar igualdade com pontos flutuantes. Pontos flutuantes não são totalmente exatos: a maioria dos números racionais, como \(\frac{1}{3}\), e números irracionais, como \(\sqrt 2\), não podem ser representados exatamente com um tipo Float64.

Em vez de verificar se x e y são exatamente iguais, é mais seguro usar a função interna abs para calcular o valor absoluto, ou magnitude, da diferença entre eles:

Onde ε (\varepsilon TAB) possui um valor como 0.0000001 que determina o quão suficientemente próximo está.

O método de Newton é um exemplo de um algoritmo: um processo mecânico para resolver uma categoria de problemas (nesse caso, o cálculo de raízes quadradas).

Para entender o que é um algoritmo, talvez seja interessante começar com algo que não é um algoritmo. Quando você aprendeu a multiplicar unidades, você provavelmente memorizou a tabuada. De fato, você memorizou 100 soluções específicas. Esse tipo de conhecimento não é um algoritmo.

Mas se você fosse “preguiçoso”, talvez tivesse aprendido alguns truques. Por exemplo, para encontrar o produto de \(n\) e 9, você pode escrever \(n-1\) no primeiro dígito e \(10-n\) no segundo dígito. Esse truque é uma solução geral para multiplicar qualquer unidade por 9. Isso é um algoritmo!

Similarmente, as técnicas que você aprendeu para a adição com transporte de unidades, a subtração com empréstimos e a divisão longa são todos algoritmos. Uma das características dos algoritmos é que eles não exigem nenhuma inteligência para serem executados. São processos mecânicos em que cada passo segue a partir do último, de acordo com um conjunto simples de regras.

Apesar da execução de algoritmos ser chata, a construção é interessante, intelectualmente desafiadora e uma parte central da ciência da computação.

Algumas das coisas que as pessoas fazem naturalmente, sem dificuldade ou conscientemente pensado, são as mais difíceis de expressar por algoritmos. Compreender a linguagem natural é um bom exemplo. Todos nós fazemos isso, mas até agora ninguém foi capaz de explicar como fazemos, pelo menos não na forma de um algoritmo.

Ao começar a escrever programas maiores, você pode passar mais tempo com a depuração. Mais código significa mais chances de cometer um erro e mais lugares para os erros se esconderem.

Uma maneira de reduzir o tempo da depuração é a “depuração por bissecção”. Por exemplo, se houver 100 linhas no seu programa e você verificá-las uma de cada vez, serão necessárias 100 etapas.

Em vez disso, tente quebrar o problema ao meio. Olhe no meio do programa, ou por perto, para um valor intermediário que você pode verificar. Adicione uma declaração print (ou qualquer outra coisa que tenha um propósito de verificação) e execute o programa.

Se a verificação da região do meio estiver incorreta, deve haver um problema na primeira metade do programa. Se estiver correta, o problema está na segunda metade.

Toda vez que você executa uma verificação como essa, reduz-se pela metade o número de linhas que se precisa averiguar. Após seis etapas (que é menor que 100), você reduziria para uma ou duas linhas de código, pelo menos em teoria.

Na prática, nem sempre é claro onde é o "meio do programa" e nem sempre é possível verificá-lo. Não faz sentido contar linhas e encontrar o ponto médio exato. Em vez disso, pense nos locais do programa em que pode haver erros e nos locais onde é fácil fazer uma verificação. Em seguida, escolha um local onde você acha que as chances são as mesmas de que o erro seja antes ou depois da verificação.

Falantes da língua portuguesa estão familiarizados com caracteres como as letras do alfabeto (A, B, C, …​), numerais e a pontuação comum. Esses caracteres são padronizados e mapeados para valores inteiros entre 0 e 127 pelo padrão ASCII (American Standard Code for Information ou "Código Padrão Americano de Intercâmbio de Informações")

Existem, é claro, muitos outros caracteres usados em línguas diferentes do Português, incluindo variantes dos caracteres ASCII com acentos e outras modificações, scripts relacionados como o Cirílico e o Grego e scripts completamente não relacionados ao ASCII e ao Português, incluindo Árabe, Chinês, Hebreu, Hindi, Japonês e Koreano.

O padrão Unicode lida com as complexidades do que exatamente é um caractere e é geralmente aceitado como o padrão definitivo que resolve esse problema. Ele fornece um número único para todo caractere em uma escala mundial.

Um valor Char representa um único caractere e está cercado por aspas simples:

Até mesmo emojis fazem parte do padrão Unicode. (\:banana: TAB)

Uma string é uma sequência de caracteres. Você pode acessar os caracteres um de cada vez com o operador colchetes:

O segundo comando seleciona o primeiro caractere de fruta e o atribui para letra.

A expressão em colchetes é chamada de índice. O índice indica qual caractere da sequência você deseja (por isso o nome).

Toda indexação no Julia começa em 1, o primeiro elemento de qualquer objeto inteiramente indexado é encontrado no índice 1 e o último no índice end:

Você pode usar como índice uma expressão que contém variáveis e operadores:

Mas o valor do índice precisa ser um inteiro. Caso contrário você recebe:

length é uma função interna que retorna o número de caracteres em uma string:

Para obter a última letra da string, você pode ficar tentado a fazer algo como:

Mas você pode não conseguir o que espera.

Strings são codificadas usando a codificação UTF-8. UTF-8 é uma codificação de largura variável, o que significa que nem todos os caracteres estão codificados com o mesmo número de bytes.

A função sizeof retorna o número de bytes em uma string:

Como um emoji é codificado em 4 bytes e a indexação de strings é baseado em bytes, o quinto elemento de frutas é um ESPAÇO.

Isso significa também que nem todo índice de bytes em uma string UTF-8 é necessariamente um índice válido para um caractere. Se você indexar em uma string com um índice de bytes inválido, será gerado um erro:

No caso de frutas, o caractere 🍌 é um caractere de quatro bytes, então os índices 2, 3 e 4 são inválidos e o índice do próximo caractere é 5; esse próximo índice válido pode ser calculado por nextind(frutas, 1) e o índice depois dele por nextind(frutas, 5) e assim por diante.

Muitos problemas computacionais envolvem o processamento de uma string, um caractere de cada vez. Geralmente eles começam no início, selecionando cada caractere por vez, fazendo algo com ele, e continuando até o final. Esse padrão de processamento é denominado de travessia. Um jeito de escrever uma travessia é com um laço while:

Esse laço faz a travessia da string e exibe cada letra em uma linha por si só. A condição do laço é index <= sizeof(fruta), então quando o índice é maior que o número de bytes em uma string, a condição é false, e o corpo do laço não executa.

A função firstindex retorna o primeiro índice de bytes válido. A palavra-chave global antes de índice indica que nós queremos reatribuir a variável índice definida em Main (ver Variáveis Globais).

Um segmento de uma string é chamado de fatia. Selecionar uma fatia é similar a selecionar um caractere:

O operador [n:m] retorna a parte da string do n-ésimo byte até o m-ésimo byte. Então o mesmo cuidado é necessário como para a indexação simples.

A palavra-chave end pode ser usada para indicar o último byte da string:

Se o primeiro índice é maior que o segundo, o resultado é uma string vazia, representada por aspas duplas:

Uma string vazia não contém nenhum caractere e possui tamanho 0, mas fora isso, é igual a qualquer outra string.

É tentador usar o operador [] no lado esquerdo da atribuição, com a intenção de mudar um caractere de uma string. Por exemplo:

O motivo deste erro é de que strings são imutáveis, o que significa que você não pode mudar uma string existente. O melhor que você pode fazer é criar uma nova string que é uma variação da original:

Esse exemplo concatena uma nova primeira letra em uma fatia de cumprimento. Ele não tem efeito algum na string original.

Construir strings usando concatenação pode vir a ser um incômodo. Para reduzir a necessidade dessas chamadas verbosas para string ou multiplicações repetidas, o Julia permite interpolação de strings usando $:

Isso é mais legível e conveniente do que concatenação de strings: cumprimento * ", " * quem * "!"

O valor da menor expressão inteira após o $ é tomado como o valor que deve ser interpolado na sequência. Assim, você pode interpolar qualquer expressão em uma string usando parênteses:

O que a função a seguir faz?

De certo modo, buscar é o inverso do operador []. Ao invés de pegar um índice e extrair o caractere correspondente, ela recebe o caractere e busca o índice aonde este caractere aparece. Se o caractere não é encontrado, a função retorna -1.

Esse é o primeiro exemplo que nós vimos de uma declaração return dentro de um laço. Se palavra[índice] == letra, a função sai do laço e retorna imediatamente.

Se o caractere não aparece na string, o programa sai do laço normalmente e retorna -1.

Percorrer uma sequência e retornar o objeto que estamos procurando quando achamos-o é um padrão de computação chamado de busca.

O seguinte programa conta o número de vezes que a letra a aparece em uma string:

Esse programa demonstra outro padrão de programação chamado contador. A variável contador é inicializada com 0 e incrementada toda vez que um a é encontrado. Quando a função sai do laço, contador contém o resultado-o número total de a’s.

O Julia fornece funções que executam uma variedade de operações utéis com strings. Por exemplo, a função uppercase recebe uma string e retorna uma nova string com todas suas letras maiúsculas.

Acontece que, existe uma função chamada findfirst que é bastante similar a função busca que nós escrevemos:

Na verdade, a função findfirst é mais geral que a nossa função; ela pode achar substrings, não apenas caracteres:

Por padrão, findfirst começa no início da string, mas a função findnext recebe um terceiro argumento, o índice onde ela deve começar:

O operador ∈ (\in TAB) é um operador booleano que recebe um caractere e uma string e retorna true se o caractere aparece na string:

Por exemplo, a seguinte função imprime todas as letras da palavra1 que também aparecem na palavra2:

Com variáveis de nomes bem escolhidos, o Julia às vezes lê como Inglês. Você poderia ler este laço da seguinte forma: “para (cada) letra na (primeira) palavra, se (a) letra é um elemento da (segunda) palavra, imprima (a) letra”

Isso é o que você recebe se você compara "maçãs" e "laranjas":

O operador relacional funciona em strings. Para ver se duas strings são iguais:

Outras operações relacionais são utéis para colocar palavras em ordem alfabética:

O Julia não trata letras maiúsculas e minúsculas do mesmo jeito que as pessoas lidam. Todas as letras maiúsculas vem antes de todas as letras minúsculas, então:

Quando você usa índices para percorrer os valores em uma sequência, é difícil de obter o começo e o fim da travessia direito. Aqui está uma função que deveria comparar duas palavras e retornar true se uma das palavras é o inverso da outra, mas ela contém dois erros:

A primeira declaração if verifica se as palavras são do mesmo tamanho. Se não, nós podemos retornar false imediatamente. Caso contrário, para o resto da função, nós podemos assumir que as palavras são do mesmo tamanho. Isso é um exemplo do padrão guardião.

i e j são índices: i percorre a palavra1 de frente para trás, enquanto j percorre a palavra2 de trás para frente. Se nós acharmos duas letras que não são iguais, nós podemos retornar false imediatamente. Se nós passarmos pelo laço inteiro e todas as letras forem iguais, nós retornamos true.

A função lastindex retorna o último índice de bytes válido de uma string e prevind o último índice válido de um caractere.

Se nós testarmos essa função com as palavras "pare" e "erap", nós esperamos que o valor de retorno seja true, mas nós obtemos false:

Para depurar esse tipo de erro, o primeiro passo é imprimir os valores dos índices:

Agora quando executamos novamente o programa, obtemos mais informações:

Na primeira iteração do laço, o valor de j é 3, que tem que ser 4. Isso pode ser consertado movendo j = prevind(palavra2, j) para o final do laço while.

Se consertamos este erro e executarmos novamente o programa, obtemos:

Desta vez um BoundsError foi gerado. O valor de i é 5, que está fora do alcance para a string "erap".

Para os exercícios deste capítulo, será necessária uma lista de palavras em inglês. Existem muitas listas de palavras disponíveis na internet, e a mais adequada para o nosso propósito é uma das listas de palavras coletadas e disponibilizadas em domínio público por Grady Ward como parte do projeto léxico da Moby (consulte https://wikipedia.org/wiki/Moby_Project). É uma lista com 113.809 palavras cruzadas oficiais; isto é, termos considerados válidos em palavras cruzadas e outros jogos com palavras. Na coleção de Moby, o nome do arquivo é 113809of.fic e você pode fazer o download de uma cópia, com o nome mais simples palavras.txt, em https://github.com/JuliaIntro/JuliaIntroBR.jl/blob/master/data/palavras.txt.

Este arquivo está em texto não formatado e portanto, pode ser aberto com um editor de texto, inclusive também pode ser lido em Julia. A função interna open precisa receber o nome do arquivo como parâmetro e retorna um fluxo (stream) de arquivo usado para a leitura do arquivo.

arquivo_entrada é um fluxo de arquivo usado para a entrada de dados e quando não for mais necessário, deve ser fechado com close(arquivo_entrada).

O Julia fornece várias funções para leitura, como a readline, que lê os caracteres do arquivo até chegar a um comando de nova linha e retorna o resultado como uma string:

A primeira palavra em Inglês nesta lista especial é "aa", que é uma espécie de lava.

O fluxo de arquivo monitora sua localização no arquivo; portanto, se chamarmos novamente o comando readline, recebemos a próxima palavra:

O termo subsequente em inglês é "aah", que é uma palavra perfeitamente legítima, então pare de me olhar desse jeito.

Você também pode usar um objeto de arquivo em um laço for. Este programa lê palavras.txt e imprime cada palavra, uma por linha:

Todos os exercícios da seção anterior têm algo em comum; eles podem ser resolvidos por meio de um padrão de busca. O exemplo mais simples é:

O laço for percorre os caracteres das palavras. Se encontrarmos a letra e, podemos retornar imediatamente false; caso contrário, temos que avançar para a próxima letra. Se sairmos do laço do modo convencional, isso significa que não encontramos um e, por isso retornamos true.

Você poderia escrever esta função de forma mais sucinta usando o operador ∉ (\notin TAB), mas comecei com essa versão porque ela mostra a lógica do padrão de busca.

evita é uma versão mais geral do sem_e, apesar de ter a mesma estrutura:

Devolvemos false assim que encontrarmos uma letra proibida e se chegarmos ao final do laço, retornamos true.

usa_somente é parecido, exceto que o sentido da condição se inverte:

Ao invés de uma lista de letras proibidas, temos uma série de letras válidas. Se encontrarmos uma letra em palavra que não seja válida, então podemos retornar false.

usa_todas é similar, exceto que invertemos a posição da palavra e a sequência de letras:

Em vez de percorrer as letras nas palavras, o laço percorre as letras obrigatórias. Se alguma das letras obrigatórias não aparecer na palavra, então retornamos false.

Se você estivesse realmente pensando como um cientista da computação, você teria identificado que usa_todas era um caso de um problema previamente solucionado e teria escrito:

Este é um exemplo de um plano de desenvolvimento para um programa chamado redução para um problema previamente resolvido, no qual você reconhece o problema em que está trabalhando como uma instância de um problema resolvido e aplica uma solução existente.

Escrevi as funções da seção anterior com laços for porque só precisava dos caracteres nas strings, sem precisar operar com os índices.

Em é_abecedário, temos que comparar letras adjacentes, o que é um pouco trabalhoso com um laço for:

Uma alternativa é usar a recursão:

Uma outra opção é usar um laço while:

O laço começa em i=1 e j=nextind(palavra, 1) e termina quando j>sizeof(palavra). A cada iteração no laço, ele compara o i-ésimo caractere (que você pode pensar como sendo o caractere atual) com o j-ésimo caractere (que você pode pensar como o próximo).

Se a posição do próximo caractere é alfabeticamente antecedente à posição do caractere atual, descobrimos uma quebra na tendência alfabética e retornamos false.

Ao chegarmos ao final do laço sem uma falha, então a palavra passa no teste. Para se convencer de que o laço termina corretamente, considere a palavra "acenos" como um exemplo.

Aqui está uma versão de é_palíndromo que usa dois índices; um está no início e sobe, e o outro está no final e desce.

Ou podemos fazer a redução para um problema resolvido anteriormente e escrever:

usando é_inversa de Depuração.

Testar programas é difícil. As funções neste capítulo são relativamente fáceis de testar já que você pode verificar os resultados manualmente. Mesmo assim, é difícil ou impossível escolher um conjunto de palavras para testar todos os erros possíveis.

Selecionando sem_e como exemplo, há dois casos óbvios a serem avaliados: palavras com e devem retornar false e palavras sem e devem retornar true. Não vai ser difícil encontrar um exemplo de cada.

Dentro de cada caso, existem subcasos menos óbvios. Entre as palavras que possuem um "e", você deve testar as palavras com "e" no início, no final e em algum lugar no meio. Devem-se testar palavras longas, curtas e muito curtas, como a string vazia. A string vazia é um exemplo de um caso especial, que é um dos casos não óbvios onde geralmente os erros se ocultam.

Além dos casos de teste gerados, você também pode testar seu programa com uma lista de palavras como palavras.txt. Ao avaliar a saída, podem-se detectar erros, mas tenha cuidado: você pode encontrar um tipo de erro (palavras que não devem ser incluídas, mas são) e não o outro tipo (palavras que devem ser incluídas, mas não são).

Em geral, o teste pode te ajudar a encontrar bugs, embora não seja fácil gerar um bom conjunto de casos de teste e, mesmo que você consiga, não é possível ter certeza de que seu programa está correto. De acordo com um lendário cientista da computação:

Assim como uma string, uma lista é uma sequência de valores. Em uma string, os valores são caracteres; em uma lista, eles podem ser de qualquer tipo. Os valores de uma lista são chamados de elementos ou por vezes itens.

Existem diversas maneiras de criar uma nova lista; a mais simples é inserir os elementos entre colchetes ([ ]), da seguinte forma:

O primeiro exemplo é uma lista de quatro inteiros. O segundo é uma lista de três strings. Os elementos de uma lista não precisam ser do mesmo tipo. A seguinte lista contém uma string, um float, um inteiro e uma outra lista:

Uma lista dentro de outra lista é dita aninhada.

Uma lista que não contém elementos é chamada de lista vazia; você pode criar uma lista vazia com colchetes vazios, [].

Como esperado, podemos atribuir valores de listas a variáveis:

A função typeof pode ser usada para encontrar o tipo de lista:

O tipo de lista é especificado entre as chaves e é composto por um tipo e um número. O número indica as dimensões. A lista vazia contém valores do tipo Any., isto é, ela pode conter valores de todos os tipos.

A sintaxe para acessar elementos de uma lista é a mesma para acessar caracteres de uma string com o operador colchetes. A expressão dentro dos colchetes especifica o índice. Lembre-se que o índice começa em 1:

Ao contrário de strings, listas são mutáveis. Quando os colchetes aparecem no lado esquerdo de uma atribuição, eles identificam o elemento da lista que será atribuido:

O segundo elemento de números, que costumava ser 123, agora é 5.

Diagrama de estado mostra o diagrama de estado para vegetais, números e vazia.

Uma lista é representada por uma caixa e pelos elementos da lista dentro dela. vegetais refere-se a uma lista com três elementos indexados 1, 2 e 3. números contém dois elementos; o diagrama mostra que o valor do segundo elemento foi reatribuído de 123 para 7. vazia refere-se a uma lista sem elementos.

Os índices das listas funcionam do mesmo jeito que os índices de strings (mas sem as ressalvas do UTF-8):

O operador ∈ também funciona em listas:

A maneira mais comum de percorrer os elementos de uma lista é através de um laço for. A sintaxe é a mesma para strings:

Isso funciona bem se você precisa apenas ler os elementos de uma lista. Mas se você deseja escrever ou atualizar os elementos, você precisa dos índices. Um jeito comum de fazer isto é utilizando a função interna eachindex:

Esse laço percorre a lista e atualiza cada elemento. length retorna o número de elementos de uma lista. Toda vez que o laço é percorrido, i obtém o índice do próximo elemento. O comando de atribuição no corpo usa i para ler o valor antigo do elemento e atribuir ao novo valor:

Utilizar o laço for sobre uma lista vazia nunca executa o corpo:

Embora uma lista possa conter outra lista, a lista aninhada ainda conta como um único elemento. O comprimento dessa lista é quatro:

O operador de fatias também funciona para listas.

O operador de fatia [:], faz uma cópia de toda a lista:

Como as listas são mutáveis, geralmente é útil fazer uma cópia antes de executar operações que modificam listas.

O operador de fatias no lado esquerdo de uma atribuição pode atualizar múltiplos elementos:

O Julia fornece funções que operam com listas. Por exemplo, push! adiciona um novo elemento ao final de uma lista:

append! adiciona os elementos da segunda lista ao final da primeira:

Esse exemplo deixa t2 sem modificações.

sort! organiza os elementos da lista do menor para o maior:

sort retorna uma cópia dos elementos da lista em ordem:

Para somar todos os números de uma lista, podemos utilizar um laço da seguinte forma:

total é iniciado em 0. Toda vez que o laço é percorrido, += captura um elemento da lista. O operador += fornece um jeito fácil de atualizar uma variável. Esse comando de atribuição aumentada,

é equivalente a

Quando o laço é iniciado, total acumula a soma dos elementos; uma variável usada dessa maneira é chamada de acumuladora.

Adicionar elementos de uma lista é uma operação tão comum que o Julia fornece uma função interna, sum:

Uma operação como essa que combina uma sequência de elementos a um único valor por vezes é chamada de operação de redução.

Muitas vezes, você deseja percorrer uma lista enquanto cria outra. Por exemplo, a função à seguir recebe uma lista de strings e retorna uma nova lista que contém as strings com todos os seus caracteres maiúsculos:

res é inicializada com uma lista vazia; toda vez que laço é percorrido, anexamos o próximo elemento. Então, res é outro tipo de acumulador.

Uma operação como todas_maiúsculas é por vezes chamado de mapa pois “mapeia” uma função (neste caso uppercase) a cada um dos elementos em uma sequência.

Outro tipo comum de operação é selecionar alguns dos elementos de uma lista e retornar uma sublista. Por exemplo, a seguinte função recebe uma lista de strings e retorna uma lista que contém apenas as strings com letras maiúsculas:

Uma operação como apenas_maiúsculas é chamada de filtro pois seleciona alguns dos elementos e filtra outros.

Operações mais comuns de listas podem ser expressas como uma combinação de mapeamento, filtro e redução.

Para cada operador binário como ^, existe um operador ponto .^ correspondente que é automaticamente definido para efetuar ^ elemento-a-elemento em listas. Por exemplo, [1, 2, 3] ^ 3 não é definido, mas [1, 2, 3] .^ 3 é definido como calcular elemento a elemento o resultado [1^3, 2^3, 3^3]:

Qualquer função f do Julia pode ser aplicada elemento a elemento à qualquer lista com a sintaxe do ponto. Por exemplo, para deixar uma lista de strings com todas as strings em letra maiúscula, não precisamos explicitar o laço:

Esse é um jeito elegante de criar mapeamentos. A função todas_maiúsculas pode ser implementada em uma única linha:

Existem várias maneiras de deletar elementos de uma lista. Se você sabe o índice do elemento que você precisa, você pode usar splice!:

splice! modifica a lista e retorna o elemento que foi removido.

pop! deleta e retorna o último elemento:

popfirst! deleta e retorna o primeiro elemento:

As funções pushfirst! e push! inserem, respectivamente, um elemento no início e no fim de uma lista.

Se você não precisa do valor removido, você pode usar a função deleteat!:

A função insert! insere um elemento em um índice dado:

Uma string é uma sequência de caracteres e uma lista é uma sequência de valores, mas uma lista de caracteres não é o mesmo que uma string. Para converter uma string em uma lista de caracteres, você pode usar a função collect:

A função collect divide uma sequência ou outra sequêcia em elementos individuais.

Se você quer dividir uma string em palavras, você pode usar a função split:

Um argumento opcional chamado delimitador especifica quais caracteres devem ser usados como limites de palavras. Os seguintes exemplos usam um hífen como um delimitador:

join é o inverso de split. Ela recebe uma lista de strings e concatena os elementos:

Neste caso o delimitador é um caractere de espaço. Para concatenar strings sem espaços, você não precisa especificar um delimitador.

Um objeto é algo que uma variável pode se referir a. Até agora, você poderia usar “objeto” e “valor” sem distinção.

Se você executar estes comandos de atribuições:

Sabemos que ambas a e b referem-se a uma string, mas não sabemos se eles referem à mesma string. Existem dois estados possíveis, mostrados na Figura 10-2.

Em um caso, a e b referem-se a dois objetos diferentes que possuem o mesmo valor. No segundo caso, elas referem-se ao mesmo objeto.

Para verificar se duas variáveis referem-se ao mesmo objeto, você pode usar o operador ≡ (\equiv TAB) ou ===.

Nesse exemplo, o Julia apenas criou um objeto string, e ambos a e b referem-se a ele. Mas quando você cria duas listas, você obtém dois objetos:

Portanto, o diagrama de estado se parece com Diagrama de estado.

Nesse caso poderíamos dizer que as duas listas são equivalentes, porque possuem os mesmos elementos, mas não idênticos, porque elas não são o mesmo objeto. Se dois objetos são idênticos, eles também são equivalentes, mas se eles são equivalentes, eles não necessariamente são idênticos.

Para sermos mais precisos, um objeto possui um valor. Se você avaliar [1, 2, 3], você obterá um objeto lista cujo o valor é uma sequência de inteiros. Se uma outra lista possuir os mesmos elementos, dizemos que eles tem os mesmos valores, mas que não são o mesmo objeto.

Se a refere-se a um objeto e você atribuir b = a, então ambas variáveis irão se referir ao mesmo objeto:

O diagrama de estado se parece com Diagrama de estado.

A associação de uma variável com um objeto é chamado de referência. Nesse exemplo, existem duas referências ao mesmo objeto.

Um objeto com mais de uma referência contém mais de um nome, dizemos então que esse objeto é um alias.

Se um objeto alias for mutável, as alterações feitas com um alias afetam o outro:

Para objetos imutáveis, como strings, o alias não é um problema. Neste exemplo:

Quase nunca faz diferença se a e b referem-se a mesma string ou não.

Quando você passa uma lista para uma função, a função recebe uma referência para a lista. Se a função modifica a lista, quem chama nota a diferença. Por exemplo, deleta_cabeça! remove o primeiro elemento de uma lista:

Segue abaixo como isto é utilizado:

O parâmetro t e a variável letras são alias para o mesmo objeto. O diagrama de estado se parece com a Diagrama de estado.

Já que a lista é compartilhada por dois quadros, eu a desenhei entre eles.

É importante distinguir operações que modificam listas de operações que criam novas listas. Por exemplo, push! modifica uma lista, mas vcat cria uma nova lista.

Aqui vai um exemplo usando push!:

t2 é um alias de t1.

E aqui, um exemplo de vcat:

O resultado de vcat é uma nova lista e a lista original permanece inalterada.

Essa diferença é importante quando você escreve funções que devem modificar listas.

Por exemplo, essa função não deleta a cabeça de uma lista:

O operador de fatia cria uma nova lista e a atribuição faz com que t se refira a ela, mas isso não afeta quem a chama.

No início de não_deleta_cabeça, t e t3 referem-se à mesma lista. No final, t refere-se a uma nova lista, mas t3 continua a referir-se à lista original, que não foi modificada.

Uma alternativa é escrever uma função que cria e retorna uma nova lista. Por exemplo, calda retorna todos, exceto o primeiro elemento de uma lista:

Essa função deixa a lista original sem modificações. Veja como ela é usada:

O uso descuidado de listas (e outros objetos mutáveis) pode levar longas horas para depurar. Veja algumas armadilhas comuns e maneiras de como evitá-las:

Um dicionário é como uma lista, mas mais geral. Em uma lista, os índices devem ser inteiros e em um dicionário, eles podem ser de (quase) qualquer tipo.

Um dicionário contém uma coleção de índices, que são chamados de chaves, e uma coleção de valores. Cada chave é associada a um único valor. A associação de uma chave e um valor é chamada de par chave-valor ou, às vezes, de item.

Na linguagem matemática, um dicionário representa um mapeamento das chaves para os valores, então você também pode dizer que cada chave “é mapeada” para um valor. Como um exemplo, iremos construir um dicionário que mapeia palavras em Português para palavras em Espanhol, com as chaves e os valores todos strings.

A função Dict cria um novo dicionário sem items. Como Dict é um nome de uma função embutida, devemos evitar usar ele como um nome de variável.

O tipo do dicionário é cercado por chaves: as chaves são do tipo Any e os valores também são do tipo Any.

O dicionário está vazio. Para adicionar items no dicionário, podemos usar os colchetes:

Essa linha cria um item que mapeia a chave "um" para o valor "uno". Se imprimirmos o dicionário novamente, nós vemos o par chave-valor com a flecha => entre a chave e o valor:

Essa formatação de saída também é uma formatação de entrada. Por exemplo, você pode criar um novo dicionário com três itens:

Todas as chaves e os valores iniciais são strings, então um Dict{String,String} é criado.

Mas isso não é um problema pois os elementos de um dicionário nunca são indexados com índices inteiros. Ao invés disso, nós usamos as chaves para consultar os valores correspondentes:

A chave "dois" sempre é mapeada para o valor "dos", então a ordem dos itens não importa.

Se a chave não está no dicionário, nós recebemos uma exceção:

A função length funciona nos dicionários e retorna o número de pares chave-valor:

A função keys retorna uma lista com as chaves do dicionário:

Agora você pode usar o operador ∈ para verificar se algo aparece como uma chave no dicionário:

Para verificar se algo aparece como um valor em um dicionário, você pode usar a função values que retorna uma coleção de valores, e em seguida usar o operador ∈:

O operador ∈ utiliza algoritmos diferentes para as listas e dicionários. Para as listas, ele busca os elementos da lista em ordem, como em Buscando. À medida que a lista fica maior, o tempo de busca cresce diretamente proporcional.

Para os dicionários, o Julia usa um algoritmo chamado tabela hash (ou tabela de dispersão ou tabela de espalhamento) que possui uma propriedade excepcional: o operador ∈ leva aproximadamente o mesmo tempo independente da quantidade de itens do dicionário.

Suponha que é dado a você uma string e você gostaria de contar quantas vezes cada letra aparece. Existem muitas maneiras de fazer isso:

Cada uma dessas opções efetua o mesmo cálculo, mas cada uma delas implementa este cálculo de formas diferentes.

Uma implementação é uma maneira de efetuar um cálculo e algumas implementações são melhores que outras. Por exemplo, uma vantagem da implementação do dicionário é que nós não temos que saber antecipadamente quais letras aparecem na string, e sim criar espaço só para as letras que aparecem.

O código pode parecer com algo como:

O nome da função é histograma, que é um termo estátistico para uma coleção de contadores (ou frequências).

A primeira linha da função cria um dicionário vazio. O laço for percorre a string. Toda vez que o laço é percorrido, se o caractere c não está no dicionário, nós criamos um novo item com a chave c e o valor inicial 1 (já que nós vimos esta letra uma vez). Se c já está no dicionário, nós incrementamos d[c].

Funciona da seguinte forma:

O histograma indica que as letras a e b aparecem uma vez; o aparece três, e assim em diante.

Dicionários possuem uma função chamada get que recebe uma chave e um valor padrão. Se a chave aparece no dicionário, get retorna o valor correspondente; caso contrário ela retorna o valor padrão. Por exemplo:

Você pode percorrer as chaves de um dicionário em uma declaração for. Por exemplo, imprime_hist exibe cada chave e o seu valor correspondente:

Aqui está o resultado:

Novamente as chaves não estão em nenhuma ordem específica. Para percorrer as chaves em ordem, você pode combinar sort e collect:

Dado um dicionário d e uma chave k, é fácil achar o valor correspondente v = d[k]. Esta operação é chamada de consulta.

Mas e se você tem v e quer achar k? Você tem dois problemas: primeiro, pode haver mais de uma chave que mapeia para o valor v. Dependendo do que é pedido, você poderia escolher um, ou teria que criar uma lista que contém todos eles. Segundo, não há uma sintaxe simples que faz uma consulta inversa; você tem que procurar.

Aqui está uma função que recebe um valor e retorna a primeira chave que mapeia a este valor:

Esta função é mais um exemplo do padrão de busca, mas usa uma função que ainda não vimos, error. A função error é usada para gerar um ErrorException que interrompe o fluxo normal de controle. Neste caso ela tem a mensagem "Erro de Consulta", indicando que a chave não existe.

Se nós chegarmos no final do laço, isso significa que v não aparece no dicionário como um valor, então geramos uma exceção.

Aqui está um exemplo de uma consulta inversa bem-sucedida:

E uma malsucedida:

O resultado de uma exceção gerada é o mesmo quando o Julia gera um: ele exibe o stacktrace e uma mensagem de erro.

Julia fornece uma maneira otimizada de fazer uma consulta inversa: findall(isequal(3), h).

Listas podem aparecer como valores em um dicionário. Por exemplo, se você receber um dicionário que mapeia letras às frequências, você pode querer invertê-lo; isto é, criar um dicionário que mapeia frequências até as letras. Já que várias letras podem ter a mesma frequência, cada valor em um dicionário invertido deve ser uma lista de letras.

Aqui está uma função que inverte um dicionário:

Cada vez que o laço é percorrido, chave recebe uma chave de d e valor recebe o valor correspondente. Se valor não está em inverso, isto significa que não a vimos ainda, então criamos um novo item e inicializamos com um singleton (uma lista que contém um único elemento). Caso contrário esse valor já foi visto, e então acrescentamos a chave correspondente à lista.

Aqui está um exemplo:

Diagrama de Estado é um diagrama de estado mostrando hist e inverso. Um dicionário é representado como uma caixa com os pares chave-valor dentro. Para os valores que são inteiros, pontos flutuantes ou strings, eu os desenho dentro da caixa, já para as listas normalmente desenho fora da caixa, só para simplificar o diagrama.

Se você já brincou com a função fibonacci de [one_more_exemple], pode ter percebido que quanto maior o argumento que você fornece, mais tempo a função leva para executar. Além disso, o tempo de execução cresce rapidamente.

Para entender o porquê, considere Grafo de chamada, que mostra um grafo de chamada para fibonacci com n = 4:

Um grafo de chamada mostra um conjunto de quadros da função, com linhas conectando cada quadro aos quadros que a função chama. No topo do grafo, fibonacci com n = 4 chama fibonacci com n = 3 e n = 2. Por sua vez, fibonacci com n = 3 chama fibonacci com n = 2 e n = 1. E assim em diante.

Conte quantas vezes fibonacci(0) e fibonacci(1) são chamadas. Está é uma solução ineficiente do problema, e fica pior à medida que o argumento aumenta.

Uma solução é acompanhar os valores já calculados armazenando-os em um dicionário. Um valor previamente calculado que é armazenado para uso posterior é chamado de memo. Aqui está uma versão “memoizada” de fibonacci:

conhecidos é um dicionáro que guarda os números de Fibonacci que já sabemos. Ele começa com dois itens: 0 mapeia para 0 e 1 mapeia para 1.

Toda vez que fibonacci é chamada, ela checa conhecidos. Se o resultado já está lá, ela retorna imediatamente. Por outro lado ela tem que computar um novo valor, adicionar ele ao dicionário, e retorná-lo.

Se você executar esta versão de fibonacci e comparar com a original, você verá que a atual é muito mais rápida.

No exemplo anterior, conhecidos é criado fora da função, então ela pertence ao quadro especial chamado Main. Variáveis em Main são às vezes chamadas de globais pois podem ser acessadas de qualquer função. Diferente de variáveis locais, que desaparecem quando a função acaba, variáveis globais persistem de uma chamada de função para a próxima.

É comum usar variáveis globais para flags; isto é, variáveis booleanas que indicam (“sinalizam”) se uma condição é verdadeira. Por exemplo, alguns programas usam uma flag chamada verbose para controlar o nível de detalhamento na saída:

Se você tentar reatribuir uma variável global, poderá se surpreender. O exemplo a seguir deve acompanhar se a função foi chamada:

Mas se você executar a função, você verá que o valor de foi_chamada não muda. O problema é que exemplo2 cria uma nova variável local denominada foi_chamada. A variável local é removida quando a função termina, e não tem nenhum efeito sobre a variável global.

Para reatribuir uma variável global dentro de uma função, você deve declarar a variável global antes de usá-la:

A declaração global indica ao interpretador algo como “Nesta função, quando eu digo foi_chamada, eu quero dizer a variável global; não crie uma local.”

Aqui está um exemplo que tenta atualizar uma variável global:

Ao executar a função, você recebe:

O Julia assume que conta é local, partindo da suposição de que você está lendo a função antes de escrevê-la. A solução, novamente, é declarar conta como global.

Se uma variável global se refere a um valor mutável, você pode modificar o valor sem declarar a variável global:

Então você pode adicionar, remover e substituir os elementos de uma lista global ou dicionário, mas se você quiser reatribuir a variável, você deve declará-la como global:

Por razões de performance, deve-se declarar uma variável global como constante. Você já não pode reatribuir a variável mas caso ela faça referência a um valor mutável, pode-se modificar o valor.

Na medida em que você trabalha com conjuntos de dados maiores, pode ser que seja difícil depurar imprimindo e checando a saída na mão. Aqui estão algumas sugestões para depurar conjuntos de dados maiores:

Uma tupla é uma sequência de valores. Estes valores podem ser de qualquer tipo e são indexados por números inteiros; logo, neste aspecto, as tuplas são muito similares às listas. A diferença importante é que as tuplas são imutáveis e que cada elemento pode ter seu próprio tipo.

Sintaticamente, uma tupla é uma lista de valores separados por vírgula:

Apesar de não ser necessário, é comum colocar tuplas entre parênteses:

Para criar uma tupla com um único elemento, tem que inserir uma vírgula no final:

Outra maneira de criar uma tupla é por meio da função interna tuple. Sem nenhum argumento, uma tupla vazia é criada:

Se vários argumentos são fornecidos, o resultado é uma tupla com os argumentos dados:

Já que tuple é o nome de uma função interna, deve-se evitar usá-lo como o nome de variável.

A maioria dos operadores da lista também funciona com as tuplas. O operador colchete indexa um elemento:

E o operador de fatia seleciona uma faixa de elementos:

E caso você tente modificar um dos elementos da tupla, uma mensagem de erro aparecerá:

Já que as tuplas são imutáveis, você não pode modificar os elementos.

Os operadores relacionais trabalham com tuplas e outras sequências; em Julia, começa-se comparando o primeiro elemento de cada sequência. Se forem iguais, passa-se para os elementos seguintes, e assim por diante, até encontrar elementos que diferem. Após isso, os elementos seguintes são desconsiderados (ainda que sejam realmente grandes).

Muitas vezes, deseja-se permutar os valores de duas variáveis. Nas atribuições convencionais, você tem que usar uma variável temporária. Por exemplo, para permutar as variáveis a e b:

Essa solução é trabalhosa; já a atribuição da tupla é mais elegante:

O lado esquerdo é uma tupla de variáveis; o lado direito é uma tupla de expressões. Cada valor é atribuído à sua correspondente variável. Todas as expressões no lado direito são avaliadas antes de qualquer uma das atribuições.

O número de variáveis do lado esquerdo não deve ser maior do que o número de valores do lado direito:

Geralmente, o lado direito pode ser qualquer tipo de sequência (string, lista ou tupla). Por exemplo, ao dividir um endereço de e-mail em um nome de usuário e um domínio, poderia-se escrever:

O valor de retorno de split é uma lista com dois elementos; o primeiro elemento é atribuído a nome_usuário e o segundo a domínio.

A princípio, uma função pode retornar apenas um valor, mas se o valor for uma tupla, é como se devolvesse vários valores. Por exemplo, se você deseja dividir dois números inteiros e calcular o quociente e o restante, é ineficiente calcular x ÷ y e depois x % y. É melhor fazer os dois cálculos ao mesmo tempo.

A função embutida divrem recebe dois argumentos e retorna uma tupla de dois valores: o quociente e o restante, respectivamente. O resultado pode ser armazenado como uma tupla:

Ou use a atribuição de tupla para armazenar os elementos separadamente:

Eis um exemplo de uma função que retorna uma tupla:

As funções internas maximum e minimum encontram o maior e o menor elemento de uma sequência. minmax calcula os dois e retorna-os por meio de uma tupla. Já a função interna extrema é mais eficiente.

As funções podem receber um número variável de argumentos. Um nome de parâmetro que termina com ... agrupa argumentos em uma tupla. Por exemplo, printall pega qualquer número de argumentos e os imprime:

O parâmetro de agrupamento pode ter qualquer nome que você goste, mas args é padronizado. Veja como funciona a função:

O complemento do agrupamento é a separação. Se você tem uma seqüência de valores e quiser passá-la para uma função com diversos argumentos, pode-se usar o operador .... No exemplo seguinte, divrem recebe exatamente dois argumentos e não funciona com uma tupla:

Mas se você separar a tupla, o comando funcionará:

Muitas das funções embutidas usam tuplas com argumentos de comprimento variável. Por exemplo, max e min podem receber qualquer número de argumentos:

Mas sum, não:

zip é uma função interna que recebe duas ou mais sequências e retorna uma coleção de tuplas em que cada tupla contém um elemento de cada sequência. O nome da função refere-se a um zíper, que une e intercala duas faixas de dentes.

Este exemplo intercala uma string com uma lista:

O resultado é um objeto zip que sabe como iterar através dos pares. O uso mais comum de zip ocorre em um laço for:

O objeto zip é um tipo de iterador, um objeto usado para percorrer uma sequência. De uma certa forma, os iteradores são similares às listas, e o que difere das listas é que não se pode usar um índice para selecionar um elemento a partir de um iterador.

Se você quiser usar operadores e funções de listas, pode-se usar um objeto zip para gerar uma lista:

O resultado é uma lista de tuplas; e neste exemplo, cada tupla contém um caractere da string e o elemento correspondente da lista.

Se as sequências não tiverem o mesmo comprimento, o resultado terá o comprimento da menor sequência.

Você pode usar a atribuição de tupla em um laço for para percorrer uma lista de tupla:

A cada iteração do laço, o Julia seleciona a próxima tupla na lista e atribui os elementos à letra e ao número. Os parênteses em torno de (letra, número) são necessários.

Se você combinar zip, for e a atribuição de tuplas, obtém-se uma função prática para analisar duas (ou mais) seqüências ao mesmo tempo. Por exemplo, tem_combinação considera duas seqüências, t1 e t2, e devolve true se existir um índice i tal que t1[i] == t2[i]:

Se você precisa percorrer os elementos de uma sequência e os seus índices, pode-se usar a função interna enumerate:

O resultado de enumerate é um objeto enumerado, que itera sobre uma seqüência de pares onde cada par contém um índice (a partir de 1) e um elemento da seqüência dada.

Os dicionários podem ser usados como iteradores dos pares chave-valor. Você pode usá-lo em um laço for como este:

Como é de se esperar de um dicionário, os itens não estão em nenhuma específica ordem.

Indo na outra direção, você pode usar uma lista de tuplas para inicializar um novo dicionário:

A combinação de Dict com zip resulta numa maneira concisa de criar um dicionário:

É comum utilizar tuplas como chaves nos dicionários. Por exemplo, uma lista telefônica pode mapear os pares de sobrenome e nome até os números de telefone. Supondo que definimos sobrenome, nome e número, poderíamos escrever:

A expressão entre parênteses é uma tupla. Poderíamos usar a atribuição de tuplas para percorrer este dicionário.

Este laço percorre os pares chave-valor em diretório, que são tuplas. Ele atribui os elementos da chave em cada tupla sobrenome e nome ao valor em número, e então imprime o nome completo e o número de telefone correspondente.

Existem duas maneiras de representar tuplas em um diagrama de estados. A versão mais detalhada mostra os índices e os elementos exatamente como eles aparecem em uma lista. Por exemplo, a tupla ("Carlos", "João") apareceria como no Diagrama de estado.

Mas em um diagrama maior, você pode ocultar os detalhes. Por exemplo, um diagrama da lista telefônica pode ser impresso como em Diagrama de estado.

Aqui, as tuplas são mostradas com a sintaxe do Julia para simplificar o diagrama. O número de telefone no diagrama é a linha de reclamações da BBC; sendo assim, não ligue para lá.

Temos focado nas listas de tuplas, mas quase todos os exemplos neste capítulo também funcionam com as listas de listas, tuplas de tuplas, e tuplas de listas. Para evitar enumerar as possíveis combinações, às vezes é mais fácil falar sobre seqüências de seqüências.

Em muitos contextos, os diferentes tipos de sequências (strings, listas e tuplas) podem ser usados de forma intercambiável. Então, como você deve escolher um ao invés dos outros?

Para começar com o óbvio, as strings são mais limitadas que as outras sequências porque os elementos precisam ser caracteres, além de serem imutáveis. Se você possivelmente precisar mudar os caracteres de uma string (ao invés de criar uma nova string), pode ser melhor usar uma lista de caracteres em seu lugar.

As listas são mais comuns que tuplas, principalmente porque são mutáveis. Mas existem algumas situações em que você pode preferir as tuplas:

Como as tuplas são imutáveis, elas não dispõem de funções como sort! e reverse!, que modificam os arrays existentes. Mas o Julia possui a função interna sort, que recebe uma lista e devolve uma nova lista com os mesmos elementos na ordem classificada, e reverse, que recebe qualquer sequência e devolve uma sequência do mesmo tipo na ordem contrária.

As listas, os dicionários e as tuplas são exemplos de estruturas de dados; neste capítulo, começamos a ver estruturas de dados compostas, como arrays de tuplas ou dicionários que contêm tuplas como chaves e arrays como valores. As estruturas de dados compostas são práticas, embora sejam propensas ao que chamamos de erros de forma; isto é, erros causados ​​quando uma estrutura de dados tem o tipo, tamanho ou estrutura incorreta. Por exemplo, se você está esperando uma lista com um número inteiro e for fornecido um número inteiro (que não é um lista), não funcionará.

Julia permite anexar um tipo aos elementos de uma sequência. As informações de como isso é feito está em Despacho Múltiplo. A especificação do tipo elimina muitos erros de forma.

Como sempre, você deve pelo menos tentar fazer os exercícios antes de ver as soluções.

Dadas as mesmas entradas, a maioria dos programas de computadores sempre geram a mesma saída e por isso eles são ditos determinísticos. O determinismo é geralmente uma coisa boa pois esperamos que o mesmo cálculo produza o mesmo resultado. Mas para algumas aplicações, queremos que o computador seja imprevisível. Os jogos são um exemplo óbvio, porém há mais exemplos.

Desenvolver um programa puramente não determinístico acaba sendo difícil, mas há maneiras de fazer pelo menos com que ele pareça não determinístico. Uma delas é usar algoritmos que geram números pseudoaleatórios. Os números pseudoaleatórios não são aleatórios de verdade porque eles são gerados por um cálculo determinístico, mas só olhando, é praticamente impossível distingui-los da aleatoriedade.

A função rand retorna um ponto flutuante aleatório entre 0.0 e 1.0 (incluindo 0.0 mas não 1.0). Toda vez que se usa o comando rand, você obtém o próximo número de uma longa série. Para ver uma amostra disso, execute este laço:

A função rand pode receber um iterador ou uma lista como argumentos e retorna um elemento aleatório:

Você deve tentar fazer os exercícios anteriores antes de continuar. Você também precisará de https://github.com/JuliaIntro/JuliaIntroBR.jl/blob/master/data/emma.txt.

Logo abaixo, temos um programa que lê um arquivo e cria um histograma das palavras no arquivo:

Esse programa lê emma.txt, que contém o texto de Emma escrito por Jane Austen.

A função processa_arquivo percorre as linhas do arquivo passando-as uma vez de cada para processa_linha. O histograma hist é utilizado como um acumulador.

A função processa_linha usa a função replace para substituir os hífens e espaços antes de usar split para separar a linha em uma lista de strings. Ela percorre a lista de palavras e usa filter, isletter e lowercase para remover as pontuações e converter em letras minúsculas. (Apesar de dizer que as strings são “convertidas”, lembre-se de que as strings são imutáveis e portanto, uma função como lowercase retorna novas strings.)

Finalmente, processa_linha atualiza o histograma criando um novo item ou incrementando um já existente.

Para contar o número total de palavras no arquivo, podemos adicionar as frequências no histograma:

O número de palavras diferentes é apenas o número de itens no dicionário:

A seguir, um código que imprime os resultados:

Para encontrar as palavras mais frequentes, podemos fazer uma lista de tuplas, onde cada tupla contém uma palavra e a sua respectiva frequência e fazemos a ordenação. A função seguinte recebe um histograma e retorna uma lista de tuplas que contém a frequência de palavras.

Em cada tupla, a frequência aparece primeiro, então o resultado da lista é ordenada pela frequência. Aqui está um laço que imprime as 10 palavras mais frequentes:

Usamos o caractere tab ('\t') como um “separador”, ao invés de um espaço, fazendo com que a segunda coluna fique alinhada. Abaixo, os resultados de Emma:

Temos visto funções embutidas que recebem argumentos opcionais. É possível escrever as funções com argumentos opcionais também. Por exemplo, eis uma função que imprime as palavras mais frequentes em um histograma:

O primeiro parâmetro é obrigatório, enquanto que o segundo é opcional. O valor padrão de num é 10.

Se você fornecer apenas um argumento:

o argumento num recebe o valor padrão. Se você fornecer dois argumentos:

o argumento num fica com o valor passado no argumento. Em outras palavras, o valor opcional sobrepõe o valor padrão.

Se uma função possui tanto os argumentos obrigatórios e os opcionais, todos os parâmetros obrigatórios deverão ficar entre os primeiros, seguido dos opcionais.

Encontrar as palavras do livro que não estão na lista de palavras em palavras.txt é um problema que você pode reconhecer como subtração de conjuntos, isto é, queremos encontrar todas as palavras de um conjunto (as palavras do livro) que não estão no outro (as palavras da lista).

A função subtrair recebe os dicionários d1 e d2 e retorna um novo dicionário que contém todas as chaves de d1 que não estão em d2. Como realmente não nos importamos com os valores, definimos todos como nothing.

Para encontrar as palavras do livro que não estão em palavras.txt, podemos usar processa_arquivo para construir um histograma para palavras.txt, e depois subtrair:

Eis alguns resultados de Emma:

Algumas dessas palavras são nomes e preposições. Outros, como “rencontre” não são mais usados. Mas algumas são as palavras comuns que realmente devem estar na lista!

Para escolher uma palavra aleatória do histograma, o algoritmo mais simples é construir uma lista com múltiplas cópias de cada palavra, de acordo com a frequêcia observada e depois escolher da lista:

Esse algoritmo funciona, mas não é muito eficiente; toda vez que você escolhe uma palavra aleatória, ele reconstrói a lista, o que é tão grande quanto o livro original. Uma melhoria óbvia é construir uma lista uma vez e então realizar múltiplas seleções, mas a lista continua grande.

Uma alternativa é:

Se você escolher as palavras do livro aleatoriamente, pode-se obter um senso de vocabulário, mas você provavelmente não obterá uma sentença:

Uma série de palavras aleatórias raramente faz sentido pois não há relação com as palavras sucessivas. Por exemplo, numa sentença real você esperaria um artigo como “the” ser seguido por um adjetivo ou um substantivo, e provávelmente não um verbo ou advérbio.

Um jeito de medir essa relação é através da análise de Markov, que caracteriza, para uma sequência de palavras dadas, a probabilidade das palavras que possam vir a seguir. Por exemplo, a música Amor Pra Recomeçar (do Frejat) tem o seguinte trecho:

No texto, o trecho “eu te” é sempre seguido da palavra “desejo”, mas o trecho “te desejo” pode ser seguido de “não” ou “muitos”.

O resultado da análise de Markov é um mapeamento de cada prefixo (como “eu te” e “te desejo”) a todos os possíveis sufixos (como “não” ou “muitos”).

Dado esse mapeamento, você pode gerar um texto aleatório começando com qualquer prefixo e escolhendo aleatoriamente dentre os possíveis sufixos. Em seguida, você pode combinar o final do prefixo e o novo sufixo para formar o próximo prefixo, e repetir.

Por exemplo, se você começar com o prefixo “eu te”, então a próxima palavra deverá ser “desejo”, pois é o prefixo que aparece apenas uma vez no texto. O próximo prefixo é “te desejo”, então o próximo sufixo poderá ser “não” ou “muitos”.

Nesse exemplo o tamanho do prefixo é sempre dois, mas você pode fazer uma análise de Markov com qualquer tamanho de prefixo.

Usar a análise de Markov para gerar textos aleatórios é divertido, mas há também um propósito para este exercício: a seleção da estrutura de dados. Na sua solução para os exercícios anteriores, você teve que escolher:

A última é fácil: Um dicionário é a escolha óbvia para um mapeamento de chaves aos valores correspondentes.

Para os prefixos, as opções mais óbvias são as strings, listas de strings ou tuplas de strings.

Para os sufixos, uma opção é uma lista; outra é um histograma (dicionário).

Como você deve escolher? O primeiro passo é pensar nas operações que você precisará implementar para cada estrutura de dados. Para os prefixos, precisamos remover palavras do começo e adicionar ao final. Por exemplo, se o prefixo atual é “eu te” e a próxima palavra é “desejo”, você precisa formar o próximo prefixo, “te desejo”.

Sua primeira escolha pode ser uma lista, pois é fácil adicionar e remover os elementos.

Para a coleta dos sufixos, as operações que precisamos executar incluem a adição de um novo sufixo (ou aumento da frequência de um existente) e a seleção de um sufixo aleatório.

Adicionar um novo sufixo é igualmente fácil para a implementação da lista ou do histograma. Escolher um elemento aleatório de uma lista é fácil enquanto que escolher de um histograma é mais difícil de ser feito eficientemente (veja Exercício 13-7).

Até agora, conversamos principalmente sobre a facilidade de implementação, mas há outros fatores a serem considerados na escolha das estruturas de dados. Um deles é o tempo de execução. Às vezes, existe uma razão teórica para esperar que uma estrutura de dados seja mais rápida que outra; por exemplo, mencionamos que o operador in é mais rápido para os dicionários do que para as listas, pelo menos quando o número de elementos é grande.

Mas muitas vezes você não sabe antecipadamente qual implementação será mais rápida. Uma opção é implementar os dois e ver qual é o melhor. Essa abordagem é chamado de benchmarking. Uma alternativa prática é escolher a estrutura de dados mais fácil de implementar e verificar se é rápida o suficiente para a aplicação pretendida. Se sim, não há necessidade de continuar. Caso contrário, existem ferramentas, como o módulo Profile, que podem identificar os locais em um programa que mais demoram.

O outro fator a considerar é o espaço de armazenamento. Por exemplo, o uso de um histograma para a coleção de sufixos pode exigir menos espaço, pois você só precisa armazenar cada palavra uma vez, não importa quantas vezes apareça no texto. Em alguns casos, economizar espaço também pode fazer com que seu programa seja executado mais rapidamente e, em um caso extremo, seu programa poderá não executar se você ficar sem memória. Porém, para muitos aplicativos, o espaço é uma consideração secundária após o tempo de execução.

Uma indagação final: nesta discussão, sugerimos que devemos usar uma estrutura de dados para a análise e geração. Mas como essas fases são separadas, também seria possível usar uma estrutura para a análise e depois converter em outra estrutura para a geração. Isso seria uma vitória se o tempo economizado durante a geração excedesse o tempo gasto na conversão.

Quando você está depurando um programa, e especialmente se você está trabalhando em um erro difícil, existem cinco atividades para se tentar:

Programadores iniciantes às vezes ficam presos em uma dessas atividades e esquecem das outras. Cada atividade tem a sua própria maneira de falhar.

Por exemplo, a leitura do seu código pode ajudar se o problema é um erro tipográfico, mas não se o problema for conceitual. Se você não entende o que o seu programa faz, pode lê-lo cem vezes e nunca verá o erro, porque o erro está na sua cabeça.

Realizar experimentos pode ajudar, especialmente se você executar testes pequenos e simples. No entanto, se você executar experimentos sem pensar ou ler seu código, pode cair em um padrão que eu chamo de “programação aleatória”, que é o processo de fazer alterações aleatórias até que o programa faça a coisa certa. Obviamente, a programação aleatória pode levar muito tempo.

Você precisa ter um tempo para pensar. Depuração é como um experimento científico. Deve haver pelo menos uma hipótese sobre qual é o problema. Se houver duas ou mais possibilidades, tente pensar em um teste que eliminaria uma delas.

Mas até mesmo as melhores técnicas de depuração falham se houver erros demais, ou se o código que você está tentando corrigir for muito grande e complicado. Às vezes, a melhor opção é voltar atrás, simplificando o programa até chegar a algo que funcione e que você entenda.

Programadores iniciantes muitas vezes relutam em voltar atrás porque não conseguem eliminar uma linha de código (mesmo se estiver errada). Se isso faz você se sentir melhor, copie seu programa para um outro arquivo antes de começar a desmontá-lo. Então você pode copiar as partes de volta, uma a uma.

Encontrar um erro difícil exige a leitura, execução, ruminação, e, às vezes, o recuo. Se você empacar em alguma dessas atividades, tente as outras.

A maioria dos programas que nós vimos até agora são transitórios no sentido de que eles executam por um tempo e produzem alguma saída, mas ao finalizarem, seus dados desaparecem. Se você executar o programa novamente, ele inicia com um estado limpo.

Outros programas são persistentes: eles executam por um longo tempo (ou toda hora); eles mantém pelo menos um pouco dos dados em um armazenamento permanente (um disco rígido, por exemplo); e se eles forem encerrados e reiniciados, eles retornam aonde pararam.

Exemplos de programas persistentes são sistemas operacionais, que são executados toda vez que um computador é ligado e servidores web, que são executados toda hora, aguardando solicitações vindas da rede.

Uma das maneiras mais simples que os programas usam para manter seus dados é lendo e escrevendo arquivos de texto. Nós já vimos programas que leem arquivos de texto; neste capítulo nós veremos programas que os escrevem.

Uma alternativa é armazenar o estado do programa em um banco de dados. Neste capítulo, iremos apresentar como usar um banco de dados simples.

Um arquivo de texto é uma sequência de caracteres armazenado em um meio permanente como um disco rígido ou memória flash. Nós vimos como abrir e ler um arquivo em Lendo Listas de Palavras.

Para escrever em um arquivo, você tem que abri-lo com modo "w" como segundo parâmetro:

Se o arquivo já existe, abri-lo em modo escrita limpa os dados antigos e começa de novo, então tome cuidado! Se o arquivo não existe, um novo é criado. open retorna um objeto arquivo e a função write coloca dados dentro do arquivo.

O valor de retorno é o número de caracteres que foram escritos. O arquivo objeto acompanha aonde ele está, então se você chamar write novamente, ela adiciona novos dados ao final do arquivo.

Quando você terminar de escrever no arquivo, ele deve ser fechado.

Se você não fechar o arquivo, ele é fechado quando o programa encerra.

O argumento da função write precisa ser uma string, então se quisermos colocar outros valores no arquivo, temos que convertê-los para string. A maneira mais fácil de fazer isso é usando string ou interpolação de strings:

Uma alternativa é usar a familia de funções print(ln).

Arquivos são organizados em diretórios (também chamados de “pastas”). Todo programa em execução possui um “diretório atual”, que é o diretório padrão para a maioria das operações. Por exemplo, quando você abre um arquivo para leitura, o Julia a procura no diretório atual.

A função pwd retorna o nome do diretório atual:

cwd significa “current working directory” (diretório de trabalho atual). O resultado nesse exemplo é home/ben, que é o diretório home do usuário chamado ben.

Uma string como "/home/ben" que identifica um arquivo ou diretório é chamada de caminho.

Um nome de arquivo simples, como memo.txt também é considerado um caminho, mas é um caminho relativo porque se refere ao diretório atual. Se o diretório atual é /home/ben, o nome do arquivo memo.txt se referiria à /home/ben/memo.txt.

Um caminho que começa com / não depende do diretório atual; ele é chamado de caminho absoluto. Para encontrar um caminho absoluto para um arquivo, você pode usar abspath:

O Julia fornece outras funções para trabalhar com nomes de arquivos e caminhos. Por exemplo, ispath verifica se um arquivo ou diretório existe:

Se ele existe, isdir verifica se é um diretório:

De forma similar, isfile verifica se é um arquivo.

readdir retorna uma lista de arquivos (e outros diretórios) no diretório dado:

Para demonstrar estas funções, o exemplo a seguir “caminha” por um diretório, exibe os nomes de todos os arquivos e chama a si mesmo recursivamente em todos os diretórios.

joinpath recebe um diretório e um nome de arquivo e junta-os em um caminho completo.

Muitas coisas podem dar errado quando você tenta ler e escrever arquivos. Se você tentar abrir um arquivo que não existe, você recebe um SystemError:

Se você não tem permissão para acessar o arquivo:

Para evitar estes erros, você pode usar funções como ispath e isfile, porém, tomaria muito tempo e código para verificar todas as possibilidades.

É mais fácil tentar de uma vez—e lidar com os problemas se eles ocorrerem—que é exatamente o que a declaração try faz. A sintaxe é similar a uma declaração if:

O Julia inicia executando a cláusula try. Se tudo der certo, ele pula a cláusula catch e segue adiante. Se ocorrer alguma exceção, ele pula fora da cláusula try e executa a cláusula catch.

Lidar com uma exceção com uma declaração try é chamado de capturar uma exceção. Neste exemplo, a cláusula de exceção imprime uma mensagem de erro que não é muito útil. Em geral, capturar uma exceção nos da uma chance de consertar o problema, ou tentar novamente ou pelo menos encerrar o programa graciosamente.

Em código que realiza mudanças de estado ou usa recursos como arquivos, geralmente há um trabalho de limpeza (como fechar arquivos) que precisa ser feito quando o código é encerrado. Exceções potencialmente complicam esta tarefa, já que elas podem causar a saída de um bloco de código antes dele atingir seu fim normal. A palavra-chave finally fornece uma maneira de executar código quando um dado bloco de código sai, independente de como ele saiu:

A função close sempre será executada.

[[banco de dados]] === Banco de Dados

Um banco de dados é um arquivo que é organizado para guardar dados. Muitos bancos de dados são organizados como um dicionário no sentido de que eles mapeiam chave para valores. A maior diferença entre um banco de dados e um dicionário é de que o banco de dados está em disco (ou em armazenamento permanente), então ele persiste após o programa encerrar.

O JuliaIntroBR fornece uma interface para GDBM (GNU dbm) para criar e atualizar arquivos de bancos de dados. Como um exemplo, irei criar um banco de dados que contém legendas para arquivos de imagens.

Abrir um banco de dados é similar a abrir outros arquivos:

O modo "c" significa que o banco de dados deve ser criado se ele ainda não existe. O resultado é um objeto banco de dados que pode ser usado (para a maioria das operações) como um dicionário.

Quando você cria um novo item, GDBM atualiza o arquivo banco de dados:

Quando você acessa um de seus itens, GDBM lê o arquivo:

Se você faz outra atribuição para uma chave já existente, GDBM substitui o valor antigo:

Algumas funções que tem um dicionário como argumento, como keys e values, não funcionam com objetos banco de dados. Mas iteração com o laço for funciona:

Como outros arquivos, você deve fechar o banco de dados quando acabar:

A limitação do GDBM é de que as chaves e valores precisam ser strings ou listas de bytes. Se você tentar usar qualquer outro tipo, você recebe um erro.

As funções serialize e deserialize podem ajudar. Elas traduzem quase todo tipo de objeto em uma lista de bytes (um iobuffer) adequado para armazenamento em um banco de dados e em seguida traduz a lista de bytes em objetos:

O formato não é óbvio para humanos; ele tem o propósito de ser fácil para o Julia interpretá-lo. deserialize reconstitui o objeto:

serialize e deserialize escrevem para e leem de um objeto iobuffer que representa um fluxo I/O em memória. A função take! busca os conteúdos do iobuffer como uma lista de bytes e reinicia o iobuffer para seu estado inicial.

Apesar do novo objeto ter o mesmo valor do antigo, ele não é (em geral) o mesmo objeto:

Em outras palavras, serialização e em seguida desserialização tem o mesmo efeito de copiar o objeto.

Você pode usar isso para guardar coisas diferentes de strings em um banco de dados.

A maioria dos sistemas operacionais fornecem uma interface de linha de comando, também conhecida como uma shell. Shells geralmente fornecem comandos para navegar o sistema de arquivos e iniciar aplicações. Por exemplo, no Unix você pode mudar de diretório com o comando cd, exibir o conteúdo do diretório com ls e iniciar o web browser digitando (por exemplo) firefox.

Qualquer programa que você inicia do shell também pode ser iniciado do Julia usando um objeto de comando:

Acentos graves são usados para delimitar o comando.

A função run executa o comando:

O olá é o resultado do comando echo, mandado para STDOUT. A função run retorna um objeto de processo, e gera um ErrorException se o comando externo falha ao executar com sucesso.

Se você quer ler a saída do comando externo, read pode ser usado como alternativa:

Por exemplo, a maioria dos sistemas Unix fornecem um comando chamado md5sum ou md5 que lê o conteúdo de um arquivo e calcula uma “soma de verificação” para checar a integridade dos dados. Você pode ler mais sobre MD5 em https://pt.wikipedia.org/wiki/MD5. Este comando fornece uma maneira eficiente de verificar se dois arquivos possuem o mesmo conteúdo. A probabilidade de que conteúdos diferentes produzem a mesma soma de verificação é muito pequena (isto é, improvável de acontecer antes que o universo entre em colapso).

Você pode usar um objeto comando para executar md5 do Julia e gerar o resultado:

Suponha que você tenha um arquivo chamado "wc.jl" com o seguinte código:

Se você executar esse programa, ele lê a si mesmo e imprime o número de linhas de um arquivo, que é 9. Você também pode incluir ele no REPL assim:

O Julia introduz módulos para criar uma área de trabalho de variáveis separada, isto é, novos escopos globais.

Um módulo inicia com a palavra-chave module e termina com end. Conflitos de nomes são evitados entre suas próprias definições de alto nível e aquelas encontradas em código de outra pessoa. import permite o controle de quais nomes de outros módulos são visíveis e export específica quais nomes são públicos, isto é, podem ser usados fora do módulo sem a necessidade de serem prefixados com o nome do módulo.

O objeto de tipo módulo ContaLinha fornece contalinha:

Quando você está lendo ou escrevendo arquivos, você pode encontrar problemas com o espaço em branco. Estes erros podem ser dificéis de depurar por causa de espaços, tabs e novas linhas que são normalmente invisivéis.

As funções internas repr ou dump podem ajudar. Elas recebem qualquer objeto como argumento e retornam uma string representando o objeto.

Isso pode ser útil para depurar.

Um outro problema que você pode encontrar é que sistemas diferentes usam caracteres diferentes para indicar o final da linha. Alguns sistemas usam uma nova linha, representada por \n. Outros usam um caractere de retorno, representado por \r. Alguns usam ambos. Se você mover arquivos entre sistemas diferentes, essas inconsistências podem causar problemas.

Para a maioria dos sistemas, existem aplicações que convertem de um formato para o outro. Você pode achá-los (e ler mais a respeito deste problema) em https://pt.wikipedia.org/wiki/Nova_linha. Ou, é claro, você pode escrever um por conta própria.