| Ir ao Capítulo 3 - Strings | Ir ao Capítulo 5 - Piadas |
Vamos fazer o jogo "Adivinhe o Número". Neste jogo, o computador pensará um número aleatóreo de 1 a 20 e pedirá que você adivinhe o número. Você tem apenas seis chances, mas o computador dirá se o seu palpite é muito alto ou muito baixo. Se acertar o número em seis tentativas, você ganha.
Este é um bom jogo para começar a programar, pois usa números aleatóreos, loops e entrada de dados do usuário em um programa mais ou menos curto. Enquanto você escreve este jogo, aprenderá como converter valores para diferentes tipos de dados (e porque você precisaria fazer isso).
Como este programa é um jogo, nós chamaremos o usuário de jogador, mas o termo "usuário" é correto também.
É dessa forma que nosso jogo será apresentado ao jogador quando o programa for executado. O texto que o jogador escreve está em negrito.
Entre esse código exatamente como ele está aqui, então salve-o clicando no menu e então . Dê ao arquivo um nome como adivinhe.py e então execute apertando a tecla F5. Não se preocupe se você não entender o código agora, eu explicarei passo a passo.
Aqui está o código fonte do nosso jogo Adivinhe o Número. Quando você entrar esse código no editor, preste atenção ao espaçamento no início de algumas das linhas. Algumas linhas têm quatro ou oito espaçõs no início. Depois de digitar o código, salve o arquivo como adivinhe.py. Você pode rodar o programa do editor de texto apertando F5. Se aparecer uma menssagem de erro, verifique se você digitou o programa exatamente como está escrito.
Se você não quer digitar todo esse código, pode baixá-lo do websitedo livro na URL http://inventwithpython.com/chapter4.
Nota Importante! Certifique-se de rodar este programa com o Python 3 e não Python 2. Os programas deste livro usam Python 3, e você verá erros se tentar rodá-los com Python 2. Você pode clicar em e então em para descobrir que vresão do Python você tem.
Mesmo que estejamos entrando nosso código fonte em uma nova janela do editor, podemos retornar ao console para entrar instruções individuais para ver o que elas fazem. O console interativo é muito bom para experimentar com diferentes instruções quando não estamos rodando um programa. Você pode retornar ao console interativo clicando na sua janela ou no botão da barra de tarefas. No Windows ou Mac OS X, a barra de tarefas está no rodapé da tela. No Linux pode estar no topo da tela.
If the program doesn't seem to work after you've typed it, check to see if you have typed the code exactly as it appears in this book. You can also copy and paste your code to the online "diff" tool at http://inventwithpython.com/diff. The diff tool will show you how your code is different from the source code in this book. In the file editor, press Ctrl-A to "Select All" the text you've typed, then press Ctrl-C to copy the text to the clipboard. Then, paste this text by clicking in the diff tool's text field on the website and click the "Compare" button. The website will show you any differences between your code and the code in this book.
There is a diff tool for each program in this book on the http://inventwithpython.com website. A video tutorial of how to use the diff tool is available from this book's website at http://inventwithpython.com/videos/.
Vamos olhar cada linha de código para ver como este programa funciona.
Estas linhas são comentários. Comentários foram introduzidos no nosso programa Alô Mundo no capítulo três. Lembre-se que o Python ignora tudo depois do sinal #. Isto apenas nos lembra o que este programa faz.
Esta é uma declaração de importação. Declarações não são funções (note que nem o import nem o random têm parênteses depois do seu nome). Lembre-se, declarações são instruções que fazem alguma ação mas não avaliam para um valor. Você já viu declarações: declarações de associação armazenam o valor em uma variável (mas a declaração não avalia para nada).
Enquanto Python inclue muitas funções nativas, algumas funções existem em programas separados chamados de módulos. Módulos são programas em Python que contêm funções adicionais. Nós usamos as funções desses módulos chamando-as para dentro do nosso programa com a declaração import. Neste caso, estamos importando o módulo random (random, em inglês, significa "aleatóreo").A declaração de importação é feita da palavra import seguida do nome do módulo. Juntas o import e o nome do módulo compõe a declaração. Então a linha 2 é uma declaraçao de importação que importa o módulo chamado random que contém diversas funções relacionadas a números aleatóreos. (Vamos usar uma dessas funções mais tarde para que o computador tenha um número aleatóreo para adivinharmos.)
Esta linha cria uma nova variável chamada 0.
As linhas 6 e 7 são as mesmas linhas do programa Alô Mundo que vimos no capítulo 3. Programadores costumam reutilizar código de seus outros programas quando eles precisam programar alguma coisa que já programaram antes.
A linha 6 é a chamada da função print(). Lembre-se que a função é como um mini-programa que nosso programa executa, e quando nosso programa chama a função ele roda esse mini-programa. O código dentro da função print() mostra na tela o string que você passou a ela dentro dos parênteses.
Quando essas duas linhas terminarem de executar, o string que é o nome do jogador será armazenado na variável meuNome. (Lembre-se, o string pode não ser realmente o nome do jogador. Ele é apenas qualquer string que o jogador digitou. Computadores são estúpidos e apenas seguem o seu programa, não importa o quê.)
Na linha 9 nós chamamos uma nova função chamada randint(), e então armazenamos o valor retornado na variável chamada numero. Lembre-se que chamadas de funções são expressões porque elas avaliam para um valor. Nós chamamos esse valor de valor de retorno.
Como a função randint() é fornecida pelo módulo random, nós a precedemos com random. (não esqueça o ponto!) para avisar nosso programa que a função randint() está no módulo random.
A função randint() retornará um número inteiro entre (e incluindo) os dois inteiros passados pra ela. Aqui, nós passamos a ela os inteiros 1 e 20 entre os parênteses que seguem o nome da função (separados por vírgula). O número inteiro que randint() retorna é armazenado em uma variável chamada numero; este é o número secreto que o jogador está tentando adivinhar.
Apenas por um momento, volte ao console interativo e digite import random para importar o módulo "random". Então digite random.randint(1, 20) para ver o que será avaliado dessa função. Ela deve retornar um número inteiro entre 1 e 20. Agora, repita o mesmo código novamente e a função provavelmente retornará um número inteiro diferente. Isso porque cada vez que a função randint() é chamada, ela retorna um número aleatóreo, como quando você joga um dado você tem um número aleatóreo cada vez.
Sempre que quisermos adicionar aleatoredade aos nossos jogos, podemos usar a função randint(). E nós usamos aleatoredade na maioria dos jogos. (Pense em quantos jogos de tabuleiro usamos dados.)
Você também pode tentar diferentes intervalos de números mudando os argumentos. Por exemplo, digite random.randint(1, 4) para obter apenas inteiros entre 1 e 4(incluindo o 1 e o 4). Ou tente random.randint(1000, 2000) para obter inteiros entre 1000 e 2000. Abaixo está um exemplo de chamada da função random.randint() com os valores retornados. Os resultados que você obtém ao chamar a função random.randint() provavelmente serão diferentes (é aleatóreo, afinal).
Nós podemos mudar levemente o código do jogo para fazê-lo se comportar diferente. Tente mudar as linhas 9 e 10 de:
para essas linhas:
E agora o computador pensará em um inteiro entre 1 e 100.Mudando a linha 9 o intervalo do número aleatóreo mudará, mas lembre-se de mudar a linha 10 para que o jogo também avise o jogador do novo intervalo em vez do antigo.
A propósito, certifique-se de digitar random.randint(1, 20) e não apenas randint(1, 20), ou o computador não saberá que deve procurar no módulo random pela função randint() e você terá um erro como esse:
Lembre-se, o seu programa precisa executar import random antes de poder chamar a função random.randint(). É por isso que declarações de import costumam estar no começo do programa.
Os valores inteiros entre os parênteses na chamada da função random.randint(1, 20) chamam-se argumentos. Argumentos são os valores que são passados para uma função quando ela é chamada. Argumentos dizem à função como se comportar. Assim como a entrada de dados pelo jogador modifica como nosso programa se comporta, argumentos são entrada de dados das funções.
Algumas funções requerem que você passe valores a elas ao chamá-las. Por exemplo, veja estas chamadas de função:
A função input() não tem argumentos, mas a função print()randint() tem dois. Quando chamamos mais de um argumento, separamos cada um com vírgulas, como você pode ver neste exmeplo. Programadores dizem que os argumentos são delimitados (isto é, separados) por vírgulas. É assim que o computador sabe onde um valor termina e o outro começa.
Se você passar argumentos demais ou muito poucos uma chamada de função, o Python mostrará uma mensagem de erro, como você pode ver abaixo. Neste exemplo, nós primeiro chamamos randint()
com apenas um argumento (muito poucos), e depois chamamos randint() com três argumentos (demais).Note que a mensagem de erro (em inglês) diz que passamos 2 e 4 argumentos em vez de 1 e 3. Isso porque o Python sempre passa um argumento extra, invisível. Este argumento está além do escopo deste livro e você não precisa se preocupar com ele.
Ns linhas 10 e 12 o programa saúda o jogador e conta a ele sobre o jogo, e então começa deixando o jogador adivinhar o número secreto. A linha 10 é bem simples, mas a linha 12 introduz um conceito útil chamado loop.
Na linha 10 e a função print() saúda o jogador pelo seu nome, e então diz a ele que o computador está pensando em um número aleatóreo.
Mas espere - eu não disse que a função print() aceita apenas um string? Pode parecer que tem mais de um string lá. Mas preste atenção na linha. Os sinais de mais juntam os três strings para avaliar para apenas um string, e esse é o único string que a função print() mostra. Pode parecer que as vírgulas estão separando os strings, mas se você prestar atenção verá que as vírgulas estão dentro das aspas, e são parte dos próprios strings.
A linha 12 tem algo que chamamos de um comando while, que indica o começo de um loop "while" ("while", em inglês, significa "enquanto", e pronuncia-se mais ou menos "uaiou"). Loops são partes do código que ficam sendo executadas e executadas de novo. Mas antes de aprendermos sobre os loops while, precisamos aprender alguns conceitos primeiro. Esses conceitos são blocos, Booleanos, operadores de comparação, condições e, finalmente, o comando while.
Um bloco é uma ou mais linhas de código agrupadas com a mesma identação mínima. Você pode dizer quando um bloco começa e termina olhando para a identação das linhas (isto é, o número de espaços na frente de cada linha).
Um bloco começa quando a linha está identada por quatro espaços. Qualquer linha que também esteja identada por quatro espaços é parte do bloco. Um block dentro de um bloco começa quando a linha está identada por outros quatro espaços (num total de oito espaços na frente da linha). O bloco termina quando há uma linha de código com a mesma identação de antes do bloco começar.
Abaixo está um diagrama do código com os blocos destacados e numerados. Os espaços têm quadrados preenchidos de preto para ficar mais fácil contá-los.
Figura 4-1: Blocos e sua identação. Os pontos pretos representam espaços.
Por exemplo, veja o código na Figura 4-1. Os espaços foram substituídos por quadrados escuros para facilitar a sua contagem. A linha 12 tem uma identação de zero espaços e não está dentro de nenhum bloco. A linha 13 tem uma identação de 4 espaços. Como essa identação é maior que a identação da linha anterior, podemos dizer um novo bloco começou. As linhas 14, 15, 17 e 19 também têm quatro espaços de identação. Todas essas linhas têm a mesma quantidade de identação que a linha anterior, então sabemos que elas estão no mesmo bloco. (Nós não contamos linhas em branco quando procuramos pela identação.)
A linha 20 tem uma identação de oito espaços. Oito espaços é mais que quatro espaços, então sabemos que um novo bloco começou. Esse é um bloco que está dentro de outro bloco.
A linha 22 tem apenas quatro espaços. A linha antes da 22 tinha um número maior de espaços. Como a identação diminuiu, sabemos que aquele bloco terminou. A linha 22 está no mesmo bloco das outras linhas com quatro espaços.
A linha 23 aumenta a identação para oito espaços, então novamente começou um novo bloco.
Para relembrar, a linha 12 não está em nenhum bloco. As linhas 13 a 23 estão todas em um bloco (marcado com o 1 circulado). A linha 20 está mum bloco dentro de outro bloco (marcada com o 2 circulado). E a linha 23 é a única linha de outro bloco dentro de bloco (marcada com um 3 circulado).
Quando você digita código no IDLE, cada letra tem a mesma largura. Você pode contar o número de letras acima ou abaixo da linha para ver quantos espaços você colocou na frente daquela linha de código.
Nesta figura, as linhas de código dentro da caixa 1 estão todas na mesma figura, e os blocos 2 e 3 estão dentro do bloco 1. O bloco 1 está identado com pelo menos quatro espaços a partir da margem esquerda, e os blocos 2 e 3 estão identados oito espaços a partir da margem esquerda. Um bloco pode conter apenas uma linha. Note que os blocos 2 e 3 têm apenas uma linha cada.
O tipo de dado Booleano tem apenas dois valores: True ou False (que em inglês significam "Verdadeiro" e "Falso", respectivamente). Esses valores são sensíveis a letras maiúsculas ou minúsculas (você não pode escrever true ou TRUE) e eles não são strings; em outras palavras, você não coloca o caracter ' de aspas simples em volta deles. Usaremos valores Booleanos (também chamados de bools) com operadores de comparação para formar condições. (Explicado em seguida.)
Na linha 12 do nosso programa, a linha de código contendo o comando while:
A expressão que segue a palavra while (tentativas < 6) contém dois valores (o valor da variável tentativas e o valor inteiro 6) conectador por um operador (o sinal <, o sinal "menor que"). O sinal < é chamado de um operador de comparação.
O operador de comparação é usado para comparar dois valores e avaliar para um valor Booleano True (verdadeiro) ou False (falso). A tabela 4-1 mostra uma lista com todos os operadores de comparação.
| Sinal do Operador | Nome do Operador |
|---|---|
| < | Menor que |
| > | Maior que |
| <= | Menor que ou igual a |
| >= | Maior que ou igual a |
| == | Igual a |
| != | Diferente de |
Uma condição é uma expressão que combina dois valores com um operador de comparação (como < ou >) e avalia para um valor Booleano. A condição é apenas um outro nome para uma expressão que avalia para True ou False. Você pode ver uma lista de outros operadores de comparação na tabela 4-1.
Condições sempre avaliam para um valor Booleano: True ou False. Por exemplo, a condição no nosso código tentativas < 6 pergunta "o valor armazenado em tentativas é menor que o número 6?". Se sim, então a condição avalia para True (verdadeiro). Senão, a condição avalia para False.
No caso do nosso jogo Adivinhe o Número, na linha 4 armazenamos o valor 0 em tentativas. Como 0 é menor que 6, essa condição avalia para o valor Booleano True (verdadeiro). Lembre-se, uma condição é apenas um nome para uma expressão que usa operadores de comparação como < or !=.
Entre as seguintes expressões no console interativo para ver os seus resultados Booleanos:
A condição 0 < 6 retorna o valor Booleano True (verdadeiro) porque o número 0 é menor que o número 6. Mas como 6 não é menor que 0, a condição 6 < 0 avalia para False. 50 não é menor que 10, portanto 50 < 10 é False. 10 é menor que 11, então 10 < 11 é True (verdadeiro).
Mas e 10 < 10? Porque avalia para False? É False porque o número 10 não é menor que o número 10. Eles são exatamente do mesmo tamanho. Se uma menina chamada Alice fosse da mesma altura que um menino chamado Bob, você não diria que a Alice é mais alta que o Bob ou que a Alice é mais baixa que o Bob. Ambas as afirmações seriam falsas.
Experimente digitar algumas condições no console para ver como esses operadores de comparação funcionam:
Repare a diferença entre o operador de associação (=) e o operador de comparação "igual a" (==). O sinal de igual (=) é usado para associar um valor a uma variável, e o sinal de igual a (==) é usado em expressões para saber se dois valores são iguais. É fácil usar acidentalmente um quando você queria usar o outro, então tenha cuidado com o que você digita.
Dois valores que são de tipos diferentes sempre serão diferentes um do outro. Por exemplo, experimente entrar o seguinte código no console interativo:
O comando while ("enquanto", em inglês) marca o começo de um loop. Algumas vezes nos nossos programas, queremos que o programa faça alguma coisa repetidas vezes. Quando a execução chega em um comando while, ela avalia a condição próxima à palavra while. Se a condição avaliar para True (verdadeiro), a execução vai para dentro do bloco-while. (No nosso programa, o bloco-while começa na linha 13). Se a condição avalia para False, a execução vai para depois do bloco-while. (No nosso programa, a primeira linha depois do bloco-while é a linha 28).
Um comando while sempre tem um sinal de dois pontos (o sinal :) depois da condição.
Figura 4-2: A condição de loop do while.
A Figura 4-2 mostra como a execução flui dependendo da condição. Se a condição avalia para True (o que acontece na primeira vez, porque o valor de tentativas é 0), a execução entrará no bloco-while na linha 13 e continuará dali. Quando o programa chegar ao final do bloco-while, em vez de continuar para a próxima linha, ele pulará de volta para a linha do comando while (linha 12). Então ele reavalia a condição, e se ela ainda avaliar para True entramos no bloco-while de novo.
É assim que o loop funciona. Enquanto a condição é True, o programa continua executando o código dentro do bloco-while repetidamente, até que chegue ao final do bloco-while e a condição seja False. E, até que tentativas seja igual ou maior que 6, vamos continuar em loop.
While, em inglês, significa "enquanto". Pense no comando while como se dissesse "enquanto essa condição é verdadeira, continue executando o código desse bloco em loop".
Você pode fazer esse jogo mais difícil ou mais fácil mudando o número de tentativas que o jogador tem. Tudo o que vc tem que fazer é mudar essa linha:
para essa outra:
...e agora o jogador tem apenas quatro tentativas em vez de seis. Ao mudar a condição para tentativas < 4, nós asseguramos que o código dentro do loop vai rodar quatro vezes em vez de seis. Isso torna o jogo muito mais difícil. Para tornar o jogo mais fácil, mude a condição para tentativas < 8 ou tentativas < 10, o que fará com que o loop rode algumas vezes a mais e aceite mais tentativas do jogador.
Claro que, se removermos a linha 17 (tentativas = tentativas + 1) então tentativas nunca aumentaria e a condição sempre seria True. Isso daria ao jogador um número ilimitado de tentativas.
As linhas 13 a 17 pedem ao jogador para adivinhar qual é o número secreto e permite a ele entrar seu palpite. Nós armazenamos esse palpite em uma variável, e então convertemos aquele valor de string em um valor inteiro.
O programa agora nos pede um palpite. Nós digitamos nosso palpite e esse número é armazenado em uma variável chamada palpite.
Na linha 15, chamamos uma nova função chamada int(). A função int() recebe um argumento. A função input() retornou um string com texto que o jogador digitou. Mas no nosso programa queremos um inteiro, não um string. Se o jogador entra o número 5 no seu palpite, a função input() retornará o valor string '5' e não o valor inteiro 5. Lembre-se que o Python considera que string '5' e o inteiro 5 são valores diferentes. Então a função int() pegará o valor string que passamos a ela e retornará a forma de inteiro desse valor.
Vamos experimentar com função int() no console interativo. Tente digitar o seguinte:
Podemos ver que a chamada de int('42') retornará o valor inteiro 42, e que int(42) fará o mesmo (apesar de não fazer sentido converter um inteiro em um inteiro). Porém, mesmo que você possa passar um string para a função int(), você não pode passar qualquer string. Por exemplo, ao passar 'oi' para int() (como fizemos na chamada int('oi')) resultará em erro. O string que passamos para int() deve ser feito de números.
O inteiro que passamos para int() também deve ser numérico, em vez de texto, por isso int('quarenta-e-dois') também produz um error. Dito isso, a função é um pouquinho flexível; se nosso string tem espaços em algum lado, ela ainda vai retornar sem erro. É por isso que a chamada int(' 42 ') funciona.
A linha 3 + int('2') mostra uma expressão que soma um inteiro 3 ao valor retornado por int('2') (que é o inteiro 2). A expressão avalia para 3 + 2, que então avalia para 5. Então mesmo que não possamos somar um inteiro e um string (3 + '2' daria um erro), nós podemos somar um inteiro e um string que foi convertido para um inteiro.
Remember, back in our program on line 15 the guess variable originally held the string value of what the player typed. We will overwrite the string value stored in guess with the integer value returned by the int() function. This is because we will later compare the player's guess with the random number the computer came up with. We can only compare two integer values to see if one is greater (that is, higher) or less (that is, lower) than the other. We cannot compare a string value with an integer value to see if one is greater or less than the other, even if that string value is numeric such as '5'.
In our Guess the Number game, if the player types in something that is not a number, then the function call int() will result in an error and the program will crash. In the other games in this book, we will add some more code to check for error conditions like this and give the player another chance to enter a correct response.
Notice that calling int(guess) does not change the value in the guess variable. The code int(guess) is an expression that evaluates to the integer value form of the string stored in the guess variable. We must assign this return value to guess in order to change the value in guess to an integer with this full line: guess = int(guess)
Once the player has taken a guess, we want to increase the number of guesses that we remember the player taking.
The first time that we enter the loop block, guessesTaken has the value of 0. Python will take this value and add 1 to it. 0 + 1 is 1. Then Python will store the new value of 1 to guessesTaken.
Think of line 17 as meaning, "the guessesTaken variable should be one more than what it already is".
When we add one to an integer value, programmers say they are incrementing the value (because it is increasing by one). When we subtract one from a value, we are decrementing the value (because it is decreasing by one). The next time the loop block loops around, guessesTaken will have the value of 1 and will be incremented to the value 2.
Lines 19 and 20 check if the number that the player guessed is less than the secret random number that the computer came up with. If so, then we want to tell the player that their guess was too low by printing this message to the screen.
Line 19 begins an if statement with the keyword, if. Next to the if keyword is the condition. Line 20 starts a new block (you can tell because the indentation has increased from line 19 to line 20.) The block that follows the if keyword is called an if-block. An if statement is used if you only want a bit of code to execute if some condition is true. Line 19 has an if statement with the condition guess < number. If the condition evaluates to True, then the code in the if-block is executed. If the condition is False, then the code in the if-block is skipped.
Figure 4-3: if and while statements.
Like the while statement, the if statement also has a keyword, followed by a condition, a colon, and then a block of code. See Figure 4-3 for a comparison of the two statements.
The if statement works almost the same way as a while statement, too. But unlike the while-block, execution does not jump back to the if statement at the end of the if-block. It just continues on down to the next line. In other words, if statements won't loop.
If the condition is True, then all the lines inside the if-block are executed. The only line inside this if-block on line 19 is a print() function call.
If the integer the player enters is less than the random integer the computer thought up, the program displays Your guess is too low. If the integer the player enters is equal to or larger than the random integer (in which case, the condition next to the if keyword would have been False), then this block would have been skipped over.
Lines 22 to 26 in our program check if the player's guess is either too big or exactly equal to the secret number.
If the player's guess is larger than the random integer, we enter the if-block that follows the if statement. The print() line tells the player that their guess is too big.
This if statement's condition checks to see if the guess is equal to the random integer. If it is, we enter line 26, the if-block that follows it.
The line inside the if-block is a break statement that tells the program to immediately jump out of the while-block to the first line after the end of the while-block. (The break statement does not bother re-checking the while loop's condition, it just breaks out immediately.)
The break statement is just the break keyword by itself, with no condition or colon.
If the player's guess is not equal to the random integer, we do not break out of the while-block, we will reach the bottom of the while-block anyway. Once we reach the bottom of the while-block, the program will loop back to the top and recheck the condition (guessesTaken < 6). Remember after the guessesTaken = guessesTaken + 1 line of code executed, the new value of guessesTaken is 1. Because 1 is less than 6, we enter the loop again.
If the player keeps guessing too low or too high, the value of guessesTaken will change to 2, then 3, then 4, then 5, then 6. If the player guessed the number correctly, the condition in the if guess == number statement would be True, and we would have executed the break statement. Otherwise, we keep looping. But when guessesTaken has the number 6 stored, the while statement's condition is False, since 6 is not less than 6. Because the while statement's condition is False, we will not enter the loop and instead jump to the end of the while-block.
The remaining lines of code run when the player has finished guessing (either because the player guessed the correct number, or because the player ran out of guesses). The reason the player exited the previous loop will determine if they win or lose the game, and the program will display the appropriate message on the screen for either case.
Unlike the code in line 25, this line has no indentation, which means the while-block has ended and this is the first line outside the while-block. When we left the while block, we did so either because the while statement's condition was False (when the player runs out of guesses) or if we executed the break statement (when the player guesses the number correctly). With line 28, check again to see if the player guessed correctly. If so, we enter the if-block that follows.
Lines 29 and 30 are inside the if-block. They only execute if the condition in the if statement on line 28 was True (that is, if the player correctly guessed the computer's number).
In line 29 we call the new function str(), which returns the string form of an argument. We use this function because we want to change the integer value in guessesTaken into its string version because we can only use strings in calls to print().
Line 29 tells the player that they have won, and how many guesses it took them. Notice in this line that we change the guessesTaken value into a string because we can only add (that is, concatenate) strings to other strings. If we were to try to add a string to an integer, the Python interpreter would display an error.
In Line 32, we use the comparison operator != with the if statement's condition to mean "is not equal to." If the value of the player's guess is lower or higher than (and therefore, not equal to) the number chosen by the computer, then this condition evaluates to True, and we enter the block that follows this if statement on line 33.
Lines 33 and 34 are inside the if-block, and only execute if the condition is True.
In this block, we tell the player what the number is because they failed to guess correctly. But first we have to store the string version of number as the new value of number.
This line is also inside the if-block, and only executes if the condition was True. At this point, we have reached the end of the code, and the program terminates.
Congratulations! We've just programmed our first real game!
If someone asked you, "What exactly is programming anyway?" what could you say to them? Programming is just the action of writing code for programs, that is, creating programs that can be executed by a computer.
"But what exactly is a program?" When you see someone using a computer program (for example, playing our Guess The Number game), all you see is some text appearing on the screen. The program decides what exact text to show on the screen (which is called the output), based on its instructions (that is, the program) and on the text that the player typed on the keyboard (which is called the input). The program has very specific instructions on what text to show the user. A program is just a collection of instructions.
"What kind of instructions?" There are only a few different kinds of instructions, really.
And that's it, just those four things. Of course, there are many details about those four types of instructions. In this book you will learn about new data types and operators, new flow control statements besides if, while and break, and several new functions. There are also different types of I/O (input from the mouse, and outputting sound and graphics and pictures instead of just text.)
For the person using your programs, they really only care about that last type, I/O. The user types on the keyboard and then sees things on the screen or hears things from the speakers. But for the computer to figure out what sights to show and what sounds to play, it needs a program, and programs are just a bunch of instructions that you, the programmer, have written.
If you have access to the Internet and a web browser, you can go to this book's website at http://inventwithpython.com/traces you will find a page that traces through each of the programs in this book. By following along with the trace line by line, it might become more clear what the Guess the Number program does. This website just shows a simulation of what happens when the program is run. No actual code is really being executed.
Figure 4-4: The tracing web page.
Figure 4-4: The tracing web page.
The left side of the web page shows the source code, and the highlighted line is the line of code that is about to be executed. You execute this line and move to the next line by clicking the "Next" button. You can also go back a step by clicking the "Previous" button, or jump directly to a step by typing it in the white box and clicking the "Jump" button.
On the right side of the web page, there are three sections. The "Current variable values" section shows you each variable that has been assigned a value, along with the value itself. The "Notes" section will give you a hint about what is happening on the highlighted line. The "Program output" section shows the output from the program, and the input that is sent to the program. (This web page automatically enters text to the program when the program asks.)
So go to each of these web pages and click the "Next" and "Previous" buttons to trace through the program like we did above.
A video tutorial of how to use the online tracing tool is available from this book's website at http://inventwithpython.com/videos/.
| Go to Chapter 3 - Strings | Go to Chapter 5 - Jokes |