Tutorial

Um programa de computador pode ser entendido como uma série de instruções que são executadas em sequência para completar uma determinada tarefa. As tarefas podem ir do extremamente simples, como mostrar mensagens na tela, até o extremamente complicado como fazer um cálculo científico ou dirigir um carro. No caso do Pytuguês você provavelmente iniciará o contato com a programação desenhando figuras na tela. No início, iremos programar o computador para realizar tarefas como quadrados, triângulos, estrelas ou outras figuras geométricas.

Podemos iniciar o ambiente de programação em modo texto invocando o comando pytuga no terminal. Uma alternativa gráfica mais amigável é o Tugalinhas que também é instalado junto com este pacote.

Uma vez aberto o Tugalinhas ou o pytuga, nos deparamos com o shell de Pytuguês (que inicia com >>>) onde podemos digitar comandos diretamente. Para mostrar uma mensagem na tela, por exemplo, digite:

>>> mostre("olá, mundo!")
olá, mundo

Experimente também com operações básicas, para ter um sabor dos recursos disponíveis no terminal de Pytuguês:

>>> 5 * 4 * 3 * 2 * 1
120
>>> 40 + 2
42

A sintaxe do Pytuguês foi criada para produzir códigos que se assemelhem o máximo possível com um pseudo-código em português. Queremos que o significado dos programas mais simples seja óbvio para um usuário que não conhece a linguagem ou que nunca programou na vida, e que a linguagem seja fácil de aprender e pareça natural para programadores iniciantes. O Python oferece isto para falantes do inglês, o Pytuguês oferece o mesmo para brasileiros, portugueses, angolanos, etc.

Esta seção vai percorrer os principais recursos do Pytuguês para que você possa começar a programar em poucos minutos. Normalmente a primeira interação com o Pytuguês se dá por meio da programação gráfica, onde controlamos a trajetória de um pequeno “robô” que desenha figuras geométricas na tela. Inicie o Tugalinhas ou o pytuga. Os comandos básicos para interagir com o cursor na tela são:

>>> frente(100)   # avança 100 pixels
>>> trás(100)     # recua 100 pixels
>>> direita(90)   # gira 90 graus no sentido horário
>>> esquerda(90)  # gira 90 graus no sentido anti-horário

Digite os comandos no terminal interativo para ver o Tuga se mexer. Aos poucos podemos construir interações complexas e interessantes utilizando estes blocos básicos e os recursos comuns de programação como repetições, execução condicional, interação com o usuário, etc.

Desafio!

Utilize estes comandos para desenhar uma figura regular como quadrado, triângulo, ou pentágono.

Comandos básicos

Esta seção apresenta os recursos mais básicos do Pytuguês que serão utilizados posteriormente para construir programas mais complexos e interessantes.

Operações matemáticas

Talvez o uso mais simples do interpretador de Pytuguês seja como uma calculadora. Além das operações aritméticas comuns, o Pytuguês permite salvar variáveis, utilizar funções científicas, definir as nossas próprias funções matemáticas, além de vários outros recursos.

A notação para as operações matemáticas é usual, onde apenas lembramos que as casas decimais são separadas por pontos e não por vírgulas:

1 + 1     # soma
2 - 1     # subtração
3.14 * 2  # multiplicação
1 / 2     # divisão
3**2      # potência

É possível criar variáveis e reaproveitá-las em outras partes do código. As funções matemáticas mais comuns também estão imediatamente disponíveis. Experimente estes comandos no terminal interativo:

>>> x = raiz(4)
>>> x + 1
3.0
>>> x * x
4.0
>>> módulo(1 - x)
1.0

O operador de igual =, possui o sentido usual da maioria das linguagens de programação, mas que é diferente do da matemática. Ele não estabelece ou testa uma relação de igualdade. Ele é utilizado na atribuição de variáveis. Portanto um código do tipo:

x = x + 1

não é uma falsidade matemática. Na realidade, estamos atribuindo um novo valor para a variável x que é igual ao valor anterior adicionado de 1.

Desafio!

Calcule x = 42**42. Muito provavelmente este resultado é maior que o que cabe na sua calculadora! Confira.

Interação com o usuário

Em um programa de computador muitas vezes queremos perguntar algum tipo de informação ao usuário. O Pytuguês oferece algumas funções para salvar valores digitados pelo usuário em variáveis. Os principais métodos de entrada são as funções leia_texto(msg), leia_número(msg) e leia_arquivo(arquivo). O código a seguir, por exemplo, pergunta o nome e a idade do usuário:

nome = leia_texto("Qual é o seu nome? ")
idade = leia_número("Qual é a sua idade? ")

A variável nome contêm o texto que o usuário digitou como sendo o seu nome e a variável idade guarda a idade em um formato numérico. A diferença entre leia_número(msg) e leia_texto(msg) está em que a primeira salva o resultado em formato numérico e obriga o usuário a digitar um número válido. A segunda conterá sempre um texto, mesmo quando o usuário digitar um número. Observe a diferença que existe entre um número e um texto que contêm um número: enquanto o primeiro admite as operações matemáticas, o segundo corresponde a um valor textual que por um acaso pode ser interpretado (por nós humanos, não pelo computador!) como um número.

As funções mencionadas acima são conhecidas como “funções de entrada”, já que permitem que o usuário do programa dê a entrada em valores que serão utilizados posteriormente. As funções de saída são aquelas que fornecem informação de volta para o usuário. A mais importante delas é a função mostre(valor), que mostra o conteúdo do argumento na tela. Podemos fazer a saída na forma de um arquivo, utilizando a função salve_arquivo(nome_do_arquivo, valor). Teste também a função alerte(valor): ela é semelhante à função “mostre”, mas em modo gráfico ela mostra a mensagem em uma caixa de diálogo.

Teste

Crie uma função que pergunte o ano de nascimento do usuário e calcule a sua idade.

Controle de fluxo de código

Alguns comandos do Pytuguês executam ações imediatas, como por exemplo, o comando frente(passo). Podemos construir programas interessantes encadeando vários destes comandos. O programa abaixo, por exemplo, desenha um triângulo:

frente(100)
esquerda(120)
frente(100)
esquerda(120)
frente(100)

(você consegue fazer o triângulo apontar para baixo?)

Em alguns casos é necessário controlar o “fluxo de código”; ou seja, temos que decidir quais comandos serão executados e quantas vezes será realizada cada execução. Esta seção mostra as principais estruturas de controle de fluxo de código do Pytuguês: repetir, para cada, enquanto e se/senão.

Repetições: repetir

Muitas tarefas que um programa realiza envovem um grande número de repetições de tarefas mais simples. Na realidade computadores são muito bons nisso: podem repetir exatamente a mesma sequência de passos uma quantidade gigantesca de vezes sem ficarem cansados, errarem ou reclamarem. O comando mais básico de repetição do Pytuguês é o comando repetir. Ele simplesmente repete um bloco de instruções pelo número dado de vezes:

repetir 3 vezes:
    frente(100)
    esquerda(120)

Em programação, chamamos cada uma destas repetições de uma “iteração”. No exemplo acima, repetimos o os comandos frente(100) e esquerda(120) três vezes, nesta ordem. De modo mais abstrato, podemos descrever o comando repetir como:

repetir <número> vezes:
    <bloco de instruções>

Onde o campo <número> representa qualquer número inteiro ou variável numérica e <bloco de instruções> é uma sequência de instruções como a frente(100)/esquerda(90) dada anteriormente. Devemos nos atentar para os espaços em branco durante a definição do bloco de instruções. São eles que delimitam o bloco de instruções e dizem para o Pytuguês quais instruções devem ser repetidas e quais não fazem mais parte do bloco de repetição e serão executadas após o término de todas iterações.

O código abaixo, por exemplo, é muito semelhate ao anterior, mas o comando esquerda(120) está alinhado ao início da linha. Isto faz com que apenas a parte frente(100) seja executada as três vezes. O comando esquerda está fora do bloco repetir e portanto é executado apenas uma única vez após o bloco terminar:

repetir 3 vezes:
    frente(100)
esquerda(120)

Importante

Indentação O número de espaços em branco antes de cada linha dentro do código define o nível de indentação da linha. A indentação é importantíssima em Pytuguês pois é o que delimita onde começa e onde termina cada bloco de instruções. Normalmente utilizamos quatro espaços para cada nível de indentação (mas você pode utilizar uma indentação diferente, se preferir).

É importante prestar atenção ao nível de indentação de cada linha. Em Pytuguês, todos os comandos que terminam com um símbolo de : definem um início de bloco e portanto exigem que se aumente um nível de indentação. Para sair do bloco devemos voltar à indentação anterior.

Desafio!

Faça uma estrela de 5 pontas utilizando o comando repetir. Depois tente fazer a estrela de Davi (neste caso pode ser necessário usar 2 repetições).

Repetições: para cada

Muitas vezes queremos repetir um bloco de comandos onde em cada iteração uma variável deve mudar de valor de forma previsível. Por exemplo, se quisermos cumprimentar várias pessoas numa lista, é possível escrever algo como:

lista = ["Maria", "João", "José"]

para cada nome em lista faça:
    mostre("Olá " + nome)

Neste caso, a variável nome assume um valor diferente em cada iteração percorrendo a lista de nomes fornecida.

É muito comum também realizar iterações sobre sequências numéricas. O comando muda ligeiramente, onde especificamos o intervalo de valores inteiros que queremos percorrer. O exemplo abaixo soma todos os números de 1 até 10:

soma = 0

para cada x de 1 até 10 faça:
    soma = soma + x

mostre(soma)

Se quisermos pular de dois em dois, a sintaxe muda um pouquinho:

soma = 0

para cada x de 1 até 10 a cada 2 faça:
    soma = soma + x

mostre(soma)

Neste caso, somente os ímpares seriam contabilizados na soma.

A sintaxe geral do comando para cada é dada abaixo. Na forma de sequência, ela funciona como:

para cada <nome> em <sequência> faça:
    <bloco de comandos>

Caso seja uma sequência numérica, podemos usar:

para cada <nome> de <início> até <fim> a cada <passo> faça:
    <bloco de comandos>

Assim como no bloco repetir, o comando faça é opcional. Podemos também trocar o comando para cada por simplesmente para, na forma compacta. Finalmente, podemos omitir o passo na segunda versão do comando caso ele seja igual à 1.

Desafio!

Desenhe uma espiral quadrada de 10 braços em que o tamanho de cada avanço varie segundo o padrão 10px, 20px, 30px, ..., 100px. A forma ingênua criar este programa seria algo do tipo:

frente(10)
esquerda(90)

frente(20)
esquerda(90)

frente(30)
esquerda(90)

frente(40)
esquerda(90)
...

É lógico que podemos fazer algo bem melhor com o comando para cada (ou até mesmo com o comando repetir).

Repetições: enquanto

O comando para cada é útil quando sabemos de antemão o número de iterações que devem ser executadas. Muitas vezes, no entanto, queremos repetir um bloco de código por um número indefinido de vezes até que um determinado critério de parada seja satisfeito. O código abaixo, por exemplo, repete uma pergunta até que o usuário acerte a resposta correta:

enquanto ler_texto("Baterista dos Beatles: ") != "Ringo" faça:
    mostre("Resposta errada! Tente novamente...")

De um modo geral, o comando enquanto possui a estrutura:

enquanto <condição> faça:
    <bloco de comandos>

No exemplo acima, a condição testada no início do laço é se o resultado da função ler_texto() é diferente (!=) do valor "Ringo". O laço enquanto executa o bloco de comandos indefinidamente enquanto a condição fornecida for verdadeira. Caso a condição se torne falsa, ele interrompe antes de executar o bloco de comandos.

O comando enquanto é talvez a forma mais geral das estruturas de repetição. Podemos reescrever todos os laços do tipo para cada ou repetir utilizando o comando enquanto. Existe um custo nisto: o código pode ficar mais longo, confuso e, em alguns casos, até mesmo um pouco mais lento. O código abaixo, por exemplo, desenha um triângulo utilizando o comando enquanto. Este código funciona sem maiores problemas. No entanto, o fato de termos que lidar com variáveis adicionais tira a elegância e concisão da versão que utilizava o comando repetir:

n_iterações = 0

enquanto n_iterações < 3:
    frente(100)
    esquerda(120)
    n_iterações = n_iterações + 1

Desafio!

A função aleatório() produz um número aleatório entre 0 e 1. O programa abaixo, por exemplo, produz 100 “passos do bêbado” e imprime a coordenada x após o passo:

repetir 100 vezes:
    # Dá um passo
    frente(50)
    esquerda(aleatório() * 360)

    # Imprime a coordenada x
    x, y = posição()
    mostre(x)

Modifique o comando acima para que o “passo do bêbado” termine quando o cursor atingir uma distância de 300 px da origem.

Condicionais

Se quisermos executar um comando apenas se determinada condição for satisfeita, então usamos o bloco se:

x = leia_número("Diga um número: ")

se x > 10 então faça:
    mostre("x é muito grande")

Neste caso, o comando mostre(...) será executado somente se o usuário digitar um valor maior que 10. Se quisermos adicionar uma condição que deva ser executada caso o teste x > 10 falhe, basta adicionar um bloco do tipo senão:

x = leia_número("Diga um número: ")

se x > 10 então faça:
    mostre("x é muito grande")
senão faça:
    mostre("x é pequeno")

Este código imprime na tela que x é muito grande caso o usuário diga um número maior que 10, ou imprime que x é pequeno caso contrário. É possível adicionar condições intermediárias usando o bloco ou então se. Neste caso, somente a primeira condição a ser satisfeita é executada. A sintaxe completa é portanto:

x = leia_número("Diga um número: ")

se x > 10 então faça:
    mostre("x é muito grande")
ou então se x == 7 faça:
    mostre("x é meu número da sorte")
senão faça:
    mostre("x é pequeno")

De um modo geral, a estrutura condicional pode ser escrita como:

se <condição 1> então faça:
    <bloco de código 1>
ou então se <condição 2> faça:
    <bloco de código 2>
ou então se <condição 3> faça:
    <bloco de código 3>
...
senão faça:
    <bloco de código senão>

No máximo um dos blocos de código será executado, sendo este o que corresponde à primeira condição satisfeita. Analogamente aos laços repetição, os termos então faça e faça são opcionais.

O condicional funciona assim.

• Primeiramente testamos a condição 1. Se ela for satisfeita, o bloco de código correspondente é executado e o Pytuguês ignora todos os outros blocos restantes e continua a execução a partir daí.
• Caso a condição seja falsa, partimos para a condição 2. Se ela for satisfeita, executamos o segundo bloco de código e pulamos sobre todos os outros.
• Somente se nenhuma das condições for satisfeita, executa-se o bloco senão. Caso o bloco senão não exista, nenhum comando é executado.

Talvez fique mais claro em um exemplo:

se x == 1:
    mostre("uma unidade")
ou então se x > 10:
    mostre("x é grande")
ou então se x < 0:
    mostre("x é pequeno")
ou então se x % 2 == 0:
    mostre("x é par")
ou então se x == 20:
    mostre("esta linha nunca será executada pois 20 > 10")
senão:
    mostre(x)

Se x for igual a 4, o programa imprimirá “x é par”, pois a condição x % 2 == 0 (resto da divisão de x por 2 é igual a zero) é a primeira condição satisfeita no bloco condicional. Caso x seja igual a 12, a mensagem mostrada será “x é grande”, pois apesar de tanto x > 10 quanto x % 2 == 0 serem satisfeitos para este valor, a primeira condição é selecionada pois aparece primeiro no bloco condicional. Para executarmos o bloco senão, é necessário utilizar um valor de x que viole todas as condições apresentadas. Neste caso, qualquer um dos valores 3, 5, 7 e 9 funcionam. Você consegue dizer o que acontece se x for igual a 20?

Desafio!

Pergunte a idade do usuário e imprima uma das mensagens abaixo dependendo da faixa em que ele se situa.

• negativo: “você ainda não nasceu!”
• 0-3: “você é um bebê”
• 4-9: “você é uma criança”
• 10-12: “você é um pré-adolescente”
• 13-19: “você é um adolescente”
• 20-59: “você é um adulto”
• 60 ou mais: “você é um idoso”

O Pytuguês aceita condições compostas, assim podemos usar o teste 0 <= idade <= 3 para verificar se a idade está no intervalo entre 0 e 3.

Funções e módulos

Uma função, em computação é entendida como um comando que recebe zero ou mais argumentos, realiza uma ação e opcionalmente pode retornar um valor. Isto é um pouco diferente e mais abrangente que as funções da matemática, que devem possuir pelo menos uma entrada e uma única saída. Pense numa função como uma sequência fixa de operações que você pode querer executar em um programa.

Pense na função cubo(x), que eleva o argumento de entrada x ao cubo e retorna o resultado (ela não existe em Pytuguês, mas logo aprenderemos como definí-la). Esta é uma função tanto no sentido matemático, como no computacional. Neste caso, para calcular o cubo do argumento, simplesmente obtemos o resultado da multiplicação x * x * x. Já a função aleatório() que mencionamos anteriormente é uma função no sentido computacional mas não no sentido matemático: ela não possui qualquer argumento de entrada e a cada vez que for chamada, retorna um valor diferente:

x = aleatório()
y = aleatório()
mostre(x, y)

Ao executarmos o programa acima, vemos que x e y (muito provavelmente) possuem valores diferentes e que a cada execução estes valores mudam. aleatório() não é uma função no sentido matemático. Ela apenas representa a ação de obter um número aleatório.

O conceito de funções é muito importante em computação. Podemos compor funções simples para criar funções um pouco mais complexas e seguir compondo estas funções em camadas até criar um programa altamente sofisticado. É claro que estamos apenas começando e não vamos já de cara desenvolver um editor de textos ou um jogo de tiros em primeira pessoa. Estes programas podem involver literalmente milhões de linhas de códigos que são desenvolvidas por grandes times de programadores durante longos intervalos de tempo. Vamos, no entanto, aprender a definir funções para dar o primeiro passo para virarmos bons programadores.

Definindo uma função

Pense numa função como um pedaço de código reutilizável. Vamos voltar ao exemplo de como construir um quadrado:

repetir 4 vezes:
    frente(100)
    esquerda(90)

Se quisermos fazer algum tipo de arte (ou um programa) que envolva a criação de vários quadrados, copiar e colar este código pode se tornar repetitivo. Para evitar muitas repetições, podemos colocar este código dentro de uma função:

definir função quadrado():
    repetir 4 vezes:
        frente(100)
        esquerda(90)

Simplesmente colocamos o código que queremos reutilizar dentro do corpo da função quadrado(). Note que isto não executa a sequência de comandos fornecido. Para isto, é necessário chamar quadrado() explicitamente:

quadrado()  # desenha um quadrado
esquerda(45)
quadrado()  # desenha outro quadrado inclinado, pois iniciamos de uma posição inclinada

Compondo funções, é possível criar programas relativamente complexos de forma simples:

repetir 8 vezes:
    quadrado()
    esquereda(45)

O código acima desenha uma mandala a partir de oito quadrados.

Desafio

Crie duas funções: quadrado_grande() e quadrado_pequeno() e desenhe uma mandala compondo os dois tipos de quadrados, chamando suas respectivas funções. Obs.: este exerício pode ser resolvido sem utilizar funções, mas muito provavelmente o código ficará mais longo e confuso.

Entrada de parâmetros

Vimos como criar uma função que repete uma sequência fixa de comandos. Muitas vezes é necessário alterar o comportamento da função a cada chamada passando parâmetros adicionas. No exemplo dos quadrados acima, poderíamos, por exemplo, controlar o tamanho do quadrado desenhado em cada chamada passando o mesmo como argumento para a função. O Pytuguês suporta este recurso simplesmente escrevendo os parâmetros adicionais na definição da função:

definir função quadrado(lado):
    repetir 4 vezes:
        frente(lado)
        esquerda(90)

Esta função pode ser chamada como quadrado(100) para desenhar um quadrado de 100 px de lado. O parâmetro passado é atribuído à variável lado que posteriormente pode ser utilizado no corpo da função como uma variável qualquer. Neste caso, ela aparece na linha frente(lado) que comanda o cursor a andar para frente pelo valor especificado.

Uma função pode possuir qualquer número de parâmetros de entrada, que são passados na mesma ordem de chamada. Considere a função que desenha um polígono regular:

definir função polígono_regular(N, lado):
    ângulo = 360 / N
    repetir N vezes:
        frente(lado)
        esquerda(ângulo)

Esta função é chamada com dois parâmetros (por exemplo, polígono_regular(3, 100) desenha um triângulo de lados de 100px). É importante passar os parâmetros na mesma ordem em que eles aparecem na definição da função. Por exemplo, polígono_regular(100, 3) provavelmente é um erro, mas talvez seja um usuário que realmente queira desenhar um polígono de 100 lados de tamanho 3px. Não tem como o computador adivinhar a intenção real de quem chamou a função e mesmo que isso fosse possível em alguns casos, não é senstato depender da inteligência do computador para acertar nossas intenções. Devemos treinar um certo rigor nos comandos que são passados para o computador.

Lembrar a ordem de cada parâmetro pode ser bastante confuso e sujeito a erros, principalmente em funções com um grande número de parâmetros. Pensando nisto, o Pytuguês permite passar os parâmetros por nome (e permite até definir parâmetros opcionais, mas isto é um tópico mais avançado que não trataremos aqui). Podemos chamar polígono_regular(lado=100, N=3) passando os argumentos de entrada explicitamente a partir dos seus nomes. Neste caso, a ordem dos parâmetros é irrelevante.

Desafio

Crie uma função que desenha uma mandala a partir de uma figura regular de N lados utilizando a mesma técnica que fizemos anteriormente com o quadrado.

Valores de saída

Todas as funções em Pytuguês possuem um certo número de parâmetros de entrada e um valor de saída. Isto permite que a função retorne um resultado potencialmente útil para o usuário. Podemos, por exemplo, definir uma função cubo(x) que retorna o valor terceira potência do argumento x. Para retornar um valor explícito, é necessário inserir a cláusula retornar <valor> no corpo da função:

definir função cubo(x):
    resultado = x * x * x
    retornar resultado

A partir daí podemos utilizar esta função para calcular o cubo de qualquer valor fornecido:

valor = cubo(2)
mostre(valor)

Neste caso, o programa mostrará o número 8.

Observe que as funções que não possuem uma cláusula do tipo retornar implicitamente retornam o valor nulo, como em:

valor = polígono_regular(4, 100)
mostre(valor)

Isto irá mostrar nulo na tela. É possível retornar o valor nulo explicitamente utilizando retornar nulo, mas isto não é necessário.

Desafio

Crie uma função que calcula e retorna o alcance de um projétil a partir do ângulo de arremesso e da velocidade de saída. Lembre-se das aulas de física: o alcance é dado por :latex:`$\frac{v_0^2 sin(2\theta)}{g}$`.

Estruturas de dados

Vimos até agora apenas alguns tipos de variáveis bem simples: números e, de forma superficial, textos (strings) e variáveis lógicas. As variávies em Pytuguês podem assumir vários outros tipos de valores (e inclusive você poderá criar os seus próprios tipos quando estiver mais experiente em programação). Nesta seção discutiremos principalmente os tipos de sequêcias e agrupamentos e as relações entre eles. O tipo mais básico e intuitivo talvez seja a lista. Definimos uma lista simplesmente enumerando seus elementos dentro de colchetes:

L = [1, 2, 9, 16]

Podemos acessar os elementos da lista utilizando a notação de índices. Em Pytuguês, os índices começam em zero. Desta forma, o primeiro elemento da lista pode ser acessado como L[0], o segundo como L[1] e assim por diante. Cada elemento da lista anterior pode ser acessado como:

L[0] --> 1
L[1] --> 2
L[2] --> 9
L[3] --> 16

Índices negativos podem ser utilizados para acessar a lista de trás para frente. Desta forma L[-1] corresponde ao último elemento, L[-2] ao penúltimo e assim por diante.

Podemos encontrar o número de elementos da lista utilizando a função tamanho(L). Muitas vezes utilizamos a função tamanho para determinar os índices sobre o qual queremos iterar:

N = tamanho(L)
para cada i de 0 até N - 1 faça:
    mostre(i, L[i])

Se quisermos percorrer os elementos sem nos importarmos com os índices podemos realizar um laço do tipo para cada diretamente sobre a lista:

para cada x em L faça:
    mostre(x)

Modificando uma lista

Podemos alterar os elementos de uma lista, apagá-los, ou inserir novos elementos.

Modificamos o valor contido em um determinado local da lista como:

>>> L[2] = 0  # altera o terceiro elemento da lista para zero

Para apagar um elemento específico da lista utilizamos o comando remover:

>>> remover L[2]
>>> mostre(L)
[1, 2, 16]

Observe que o terceiro elemento foi removido e o quarto passou a ocupar o seu lugar.

Podemos inserir elementos na lista utilizando duas funções diferentes. A função acrescentar(lista, elemento) adiciona um novo elemento no final da lista. É muito comum utilizar a função acrescentar para construir uma lista aos poucos a partir de uma lista vazia. No exemplo abaixo, criamos uma lista com os 100 primeiros quadrados perfeitos:

quadrados = []
para cada x de 1 até 100:
    acrescentar(quadrados, x * x)

Já a função inserir(lista, índice, elemento) insere um novo elemento no índice dado deslocando todos os elementos subsequentes para frente. Podemos ver como isto funciona no exemplo:

>>> beatles = ['Paul', 'George', 'Ringo']
>>> inserir(beatles, 1, 'John')
>>> mostre(beatles)
['Paul', 'John', 'George', 'Ringo']

Desafio

Crie uma lista que começa com L = [1, 1]. Cada novo elemento é criado somando os dois anteriores. Esta regra cria os números de Fibonacci, que foram propostos inicialmente para descrever o crescimento de uma população de coelhos. Complete esta lista até que ela tenha 10 elementos.

Texto (strings)

Representamos uma variável do tipo texto (string, em inglês) colocando o conteúdo entre aspas, como em msg = "Olá, todo mundo!". A variável msg é do tipo texto, e aceita operações como concatenamento, conversão entre maiúsculas e minúsculas, etc. Sob vários aspectos, uma variável de texto se assemelha a uma lista de caracteres. Podemos, por exemplo, extrair uma letra específica do texto utilizando a notação de indexamento:

>>> [msg[0], msg[1], msg[2], msg[-1]]
['O', 'l', 'á', '!']

Diferentemente das listas, as variáveis de texto não podem ser modificadas. Para realizar uma alteração em uma string é sempre necessário criar uma nova string com o valor alterado. Em alguns casos, pode ser necessário converter a string para uma lista de caracteres, modificar a lista e finalmente juntá-la numa string final:

>>> L = lista("hello")
>>> L[0] = "H"
>>> acrescentar(L, "!")
>>> mostre(juntar(L))
Hello!

Strings de texto aceitam algumas operações matemáticas úteis. A soma de duas stings corresponde à concatenação:

>>> "olá" + "mundo"
'olámundo'

Já a multiplicação de uma string por um número inteiro corresponde a uma repetição:

>>> "abc" * 3
'abcabcabc'

Existem várias funções auxiliares aplicadas sobre strings que podem ser acessadas pela notação <variável>.<método>, como por exemplo em:

>>> nome = "ringo"
>>> nome.maiúsculas()
'RINGO'

A função nome.maiúsculas() é um método associado apenas às variáveis do tipo string. Como se trata de uma função com aplicação bem restrita — não faz sentido, por exemplo, converter um número para letras maiúsculas — esta função não possui escopo global.

Podemos obter a lista completa de funções associadas a cada tipo usando o comando ajuda(<nome do tipo>), onde substituímos o nome do tipo por Texto para acessar as funções específicas de strings. A maior parte das funções é auto-explicativa: explore-as para se familiarizar com os recursos de processamento de texto disponíveis no Pytuguês.

Desafio

Crie uma função que remova todos os acentos de uma palavra. Para este exercício considere apenas os acentos que normalmente aparecem em português.

Dicionário

Um dicionário em Pytuguês (algumas vezes chamado de hash table) define um mapeamento entre um conjunto de índices (as chaves) para um conjunto de valores. Podemos, por exemplo, relacionar um grupo de pessoas às suas respectivas idades:

D = {'João': 31, 'Maria': 29, 'José': 3}

Note que as chaves podem ser do tipo texto ou qualquer outro valor imutável: você pode utilizar números inteiros ou decimais, mesclar textos com números, etc. No entanto, não é possível utilizar valores mutáveis como chaves. Podemos acessar o valor associado a uma chave no dicionário usando a notação de índices:

>>> D['José'] + 1
4

Para acrescentar valores ao dicionário, basta fazer uma atribuição e o elemento será inserido automaticamente (caso a chave já exista, substitui-se seu valor):

>>> D['Joana'] = 1
>>> tamanho(D)
4

Desafio

Crie um programa encriptador de mensagens. Para isto, defina um dicionário que troque algumas letras do alfabeto de lugar até criar uma mensagem incompreensível. Depois crie um outro programa que decodifique a mensagem secreta.