-
Notifications
You must be signed in to change notification settings - Fork 11
/
chapter4.html
731 lines (509 loc) · 62.2 KB
/
chapter4.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en">
<head>
<script type="text/javascript">
var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
</script>
<script type="text/javascript">
try {
var pageTracker = _gat._getTracker("UA-5459430-3");
pageTracker._trackPageview();
} catch(err) {}</script>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<title>IYOCGwP, Capítulo 4 - Adivinhe o Número</title>
<link rel="stylesheet" href="inventbook.css" type="text/css" media="all" />
</head>
<body class='chapter4body'>
<table border='0' width='100%'><tr><td><a href='chapter3.html'>Ir ao Capítulo 3 - Strings</a></td><td align='right'><a href='chapter5.html'>Ir ao Capítulo 5 - Piadas</a></td></tr></table>
<div style='height: 310px;'><a href='http://www.amazon.com/Invent-Your-Computer-Games-Python/dp/0982106017/'><img src='images/buyad.png' align='right'></a></div>
<div style='height: 350px;'><img src='images/chap4.png' /></div>
<div class='inthischapter'><h3 id="TopicsCoveredInThisChapter">Tópicos Abordados neste Capítulo</h3>
<ul>
<li>A declaração <span class='m'>import</span></li>
<li>Módulos</li>
<li>Argumentos</li>
<li>O comando <span class='m'>while</span></li>
<li>Condições</li>
<li>Blocos</li>
<li>Booleanos</li>
<li>Operadores de comparação</li>
<li>A diferença entre <span class='m'>=</span> e <span class='m'>==</span>.</li>
<li>O comando <span class='m'>if</span></li>
<li>O <span class='m'>break</span>.</li>
<li>As funções <span class='m'>str()</span> e <span class='m'>int()</span>.</li>
<li>A função <span class='m'>random.randint()</span>.</li>
</ul></div>
<h2 id="TheGuesstheNumberGame">O Jogo "Adivinhe o Número"</h2>
<p>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.</p>
<p>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).</p>
<p>Como este programa é um jogo, nós chamaremos o usuário de <span class='term'>jogador</span>, mas o termo "usuário" é correto também.</p>
<h2 id="SampleRunofGuesstheNumber">Exemplo de execução do "Adivinhe o Número"</h2>
<p>É dessa forma que nosso jogo será apresentado ao jogador quando o programa for executado. O texto que o jogador escreve está em <b>negrito</b>.</p>
<div class='sourceblurb'>
Olá! Qual é o seu nome?<br />
<b>Alberto</b><br />
Bem, Alberto, eu estou pensando em um número entre 1 e 20.<br />
Tente adivinhar.<br />
<b>10</b><br />
Seu palpite é muito alto.<br />
Tente adivinhar<br />
<b>2</b><br />
Seu palpite é muito baixo.<br />
Tente adivinhar.<br />
<b>4</b><br />
Bom trabalho, Alberto! Você acertou o meu número em 3 tentativas!<br />
</div>
<p>Entre esse código exatamente como ele está aqui, então salve-o clicando no menu <span class='menuname'>Arquivo</span> e então <span class='menuname'>Salvar Como</span>. Dê ao arquivo um nome como <span class='filename'>adivinhe.py</span> 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.</p>
<h2 id="GuesstheNumbersSourceCode">Código fonte do Adivinhe o Número</h2>
<p>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 <span class='filename'>adivinhe.py</span>. 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.</p>
<p>Se você não quer digitar todo esse código, pode baixá-lo do <i>website</i>do livro na URL <a href='http://inventwithpython.com/chapter4'>http://inventwithpython.com/chapter4</a>.</p><!-- TODO URL do codigo fonte em portugues -->
<p><b>Nota Importante!</b> 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 <span class='menuname'>Ajuda</span> e então em <span class='menuname'>Sobre o IDLE</span> para descobrir que vresão do Python você tem.</p>
<!-- TODO traduzir (repetitivo, as crianças vão passar batido por tudo isso e vão direto pro código! :-) -->
<div class='sourcecode pagebreaker'><span class='sourcecodeHeader'>adivinhe.py</span><br /><span class='sourcecodeSubHeader'>This code can be downloaded from <a href='http://inventwithpython.com/guess.py'>http://inventwithpython.com/guess.py</a><br />If you get errors after typing this code in, compare it to the book's code with the online diff tool at <a href='http://inventwithpython.com/diff'>http://inventwithpython.com/diff</a> or email the author at <a href="mailto:[email protected]">[email protected]</a></span><br /><ol start='1'>
<li><span class='comment'># Este é o jogo adivinhe o número.</span></li>
<li>import random</li>
<li></li>
<li>tentativas = 0</li>
<li></li>
<li>print('Olá! Qual é o seu nome?')</li>
<li>meuNome = input()</li>
<li></li>
<li>numero = random.randint(1, 20)</li>
<li>print('Bem, ' + meuNome + ', eu estou pensando em um número entre 1 e 20.')</li>
<li></li>
<li>while tentativas < 6:</li>
<li> print('Tente adivinhar.') <span class='comment'># Há quatro espaços na frente do print.</span></li>
<li> palpite = input()</li>
<li> palpite = int(palpite)</li>
<li></li>
<li> tentativas = tentativas + 1</li>
<li></li>
<li> if palpite < numero:</li>
<li> print('Seu palpite é muito baixo.') <span class='comment'># Há oito espaços na frente do print.</span></li>
<li></li>
<li> if palpite > numero:</li>
<li> print('Seu palpite é muito alto.')</li>
<li></li>
<li> if palpite == numero:</li>
<li> break</li>
<li></li>
<li>if palpite == numero:</li>
<li> tentativas = str(tentativas)</li>
<li> print('Bom trabalho, ' + meuNome + '! Você acertou o meu número em ' + tentativas + ' tentativas!')</li>
<li></li>
<li>if palpite != numero:</li>
<li> numero = str(numero)</li>
<li> print('Não. O número que eu estava pensando era ' + numero)</li>
</ol></div>
<p>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 <!-- TODO or dock --> está no rodapé da tela. No Linux pode estar no topo da tela.</p>
<!-- TODO traduzir, as crianças vão passar batido aqui -->
<p>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 <a href='http://inventwithpython.com/diff'>http://inventwithpython.com/diff</a>. 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.</p>
<!-- TODO traduzir, as crianças vão passar batido aqui -->
<p>There is a diff tool for each program in this book on the <a href='http://inventwithpython.com'>http://inventwithpython.com</a> website. A video tutorial of how to use the diff tool is available from this book's website at <a href='http://inventwithpython.com/videos/'>http://inventwithpython.com/videos/</a>.</p>
<h2 id="TheimportStatement">A declaração <span class='m'>import</span></h2>
<p>Vamos olhar cada linha de código para ver como este programa funciona.</p>
<div class='sourcecode'><ol start='1'>
<li><span class='comment'># Este é o jogo adivinhe o número.</span></li>
</ol></div>
<p>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 <span class='m'>#</span>. Isto apenas nos lembra o que este programa faz. </p>
<div class='sourcecode'><ol start='2'>
<li>import random</li>
</ol></div>
<p>Esta é uma <span class='term'>declaração de importação</span>. Declarações não são funções (note que nem o <span class='m'>import</span> nem o <span class='m'>random</span> 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).</p>
<p>Enquanto Python inclue muitas funções nativas, algumas funções existem em programas separados chamados de módulos. <span class='term'>Módulos</span> 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 <span class='m'>import</span>. Neste caso, estamos importando o módulo <span class='m'>random</span> (random, em inglês, significa "aleatóreo").</p.
<p>A declaração de importação é feita da palavra <span class='m'>import</span> seguida do nome do módulo. Juntas o <span class='m'>import</span> 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 <span class='m'>random</span> 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.)</p>
<div class='sourcecode'><ol start='4'>
<li># tentativas = 0</li.
</ol></div>
<p>Esta linha cria uma nova variável chamada <span clas='m>tentativas</span>. Nós vamos armazenar o número de tentativas que o jogador faz nessa variável. Como o jogador ainda não fez nenhuma tentativa ainda, vamos armazenar o inteiro <span class='m'>0</span>.</p>
<div class='sourcecode'><ol start='6'>
<li>print('Olá! Qual é o seu nome?')</li>
<li>meuNome = <span class='m'>input()</span></li>
</ol></div>
<p>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.</p>
<p>A linha 6 é a chamada da função <span class='m'>print()</span>. 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 <span class='m'>print()</span> mostra na tela o string que você passou a ela dentro dos parênteses.</p>
<p>Quando essas duas linhas terminarem de executar, o string que é o nome do jogador será armazenado na variável <span class='m'>meuNome</span>. (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ê.)</p>
<h2 id="TherandomrandintFunction">A função <span class='m'>random.randint()</span></h2>
<div class='sourcecode'><ol start='9'>
<li>numero = random.randint(1, 20)</li>
</ol></div>
<p>Na linha 9 nós chamamos uma nova função chamada <span class='m'>randint()</span>, e então armazenamos o valor retornado na variável chamada <span class='m'>numero</span>. 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.</p>
<p>Como a função <span class='m'>randint()</span> é fornecida pelo módulo <span class='m'>random</span>, nós a precedemos com <span class='m'>random.</span> (não esqueça o ponto!) para avisar nosso programa que a função <span class='m'>randint()</span> está no módulo <span class='m'>random</span>.</p>
<p>A função <span class='m'>randint()</span> retornará um número inteiro entre (e incluindo) os dois inteiros passados pra ela. Aqui, nós passamos a ela os inteiros <span class='m'>1</span> e <span class='m'>20</span> entre os parênteses que seguem o nome da função (separados por vírgula). O número inteiro que <span class='m'>randint()</span> retorna é armazenado em uma variável chamada <span class='m'>numero</span>; este é o número secreto que o jogador está tentando adivinhar.</p>
<p>Apenas por um momento, volte ao console interativo e digite <span class='m'>import random</span> para importar o módulo "random". Então digite <span class='m'>random.randint(1, 20)</span> para ver o que será avaliado dessa função. Ela deve retornar um número inteiro entre <span class='m'>1</span> e <span class='m'>20</span>. 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 <span class='m'>randint()</span> é chamada, ela retorna um número aleatóreo, como quando você joga um dado você tem um número aleatóreo cada vez.</p>
<div class='sourceblurb'>
>>> import random<br />
>>> random.randint(1, 20)<br />
12<br />
>>> random.randint(1, 20)<br />
18<br />
>>> random.randint(1, 20)<br />
3<br />
>>> random.randint(1, 20)<br />
18<br />
>>> random.randint(1, 20)<br />
7<br />
>>><br />
</div>
<p>Sempre que quisermos adicionar aleatoredade aos nossos jogos, podemos usar a função <span class='m'>randint()</span>. E nós usamos aleatoredade na maioria dos jogos. (Pense em quantos jogos de tabuleiro usamos dados.)</p>
<p>Você também pode tentar diferentes intervalos de números mudando os argumentos. Por exemplo, digite <span class='m'>random.randint(1, 4)</span> para obter apenas inteiros entre <span class='m'>1</span> e <span class='m'>4</span>(incluindo o <span class='m'>1</span> e o <span class='m'>4</span>). Ou tente <span class='m'>random.randint(1000, 2000)</span> para obter inteiros entre <span class='m'>1000</span> e <span class='m'>2000</span>. Abaixo está um exemplo de chamada da função <span class='m'>random.randint()</span> com os valores retornados. Os resultados que você obtém ao chamar a função <span class='m'>random.randint()</span> provavelmente serão diferentes (é aleatóreo, afinal).</p>
<div class='sourceblurb'>
>>> random.randint(1, 4)<br />
3<br />
>>> random.randint(1, 4)<br />
4<br />
>>> random.randint(1000, 2000)<br />
1294<br />
>>> random.randint(1000, 2000)<br />
1585<br />
>>><br />
</div>
<p>Nós podemos mudar levemente o código do jogo para fazê-lo se comportar diferente. Tente mudar as linhas 9 e 10 de:</p>
<div class='sourcecode'><ol start='9'>
<li>numero = random.randint(1, <b>20</b>)</li>
<li>print('Bem, ' + meuNome + ', eu estou pensando em um número entre 1 e 20.')</li>
</ol></div>
<p>para essas linhas:</p>
<div class='sourcecode'><ol start='9'>
<li>numero = random.randint(1, <b>100</b>)</li>
<li>print('Bem, ' + meuNome + ', eu estou pensando em um número entre 1 e 100.')</li>
</ol></div>
<p>E agora o computador pensará em um inteiro entre <span class='m'>1</span> e <span class='m'>100</span>.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.</p>
<h3 id="CallingFunctionsthatareInsideModules">Chamando Funções que estão dentro de Módulos</h3>
<p>A propósito, certifique-se de digitar <span class='m'>random.randint(1, 20)</span> e não apenas <span class='m'>randint(1, 20)</span>, ou o computador não saberá que deve procurar no módulo <span class='m'>random</span> pela função <span class='m'>randint()</span> e você terá um erro como esse:</p>
<div class='sourceblurb'>
>>> randint(1, 20)<br />
Traceback (most recent call last):<br />
File "<stdin>", line 1, in <module><br />
NameError: name 'randint' is not defined<br />
>>><br />
</div>
<p>Lembre-se, o seu programa precisa executar <span class='m'>import random</span> antes de poder chamar a função <span class='m'>random.randint()</span>. É por isso que declarações de <span class='m'>import</span> costumam estar no começo do programa.</p>
<h2 id="PassingArgumentstoFunctions">Passando Argumentos para Funções</h2>
<p>Os valores inteiros entre os parênteses na chamada da função <span class='m'>random.randint(1, 20)</span> chamam-se argumentos. <span class='term'>Argumentos</span> 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.</p>
<p>Algumas funções requerem que você passe valores a elas ao chamá-las. Por exemplo, veja estas chamadas de função:</p>
<div class='sourceblurb'>
input()<br />
print('Olá')<br />
random.randint(1, 20)<br />
</div>
<p>A função <span class='m'>input()</span> não tem argumentos, mas a função <span class='m'>print()</span tem um e a função <span class='m'>randint()</span> 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 <span class='term'>delimitados</span> (isto é, separados) por vírgulas. É assim que o computador sabe onde um valor termina e o outro começa.</p>
<p>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 <span class='m'>randint()</p> com apenas um argumento (muito poucos), e depois chamamos <span class='m'>randint()</span> com três argumentos (demais).</p>
<div class='sourceblurb'>
>>> random.randint(1)<br />
Traceback (most recent call last):<br />
File "<pyshell#1>", line 1, in <module><br />
random.randint(1)<br />
TypeError: randint() takes exactly 3 positional arguments (2 given)<br />
>>> random.randint(1, 2, 3)<br />
Traceback (most recent call last):<br />
File "<pyshell#2>", line 1, in <module><br />
random.randint(1, 2, 3)<br />
TypeError: randint() takes exactly 3 positional arguments (4 given)<br />
>>><br />
</div>
<p>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.</p>
<h2 id="WelcomingthePlayer">Boas vindas ao Jogador</h2>
<p>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.</p>
<div class='sourcecode'><ol start='9'>
<li>print('Bem, ' + meuNome + ', eu estou pensando em um número entre 1 e 100.')</li>
</ol></div>
<p>Na linha 10 e a função <span class='m'>print()</span> saúda o jogador pelo seu nome, e então diz a ele que o computador está pensando em um número aleatóreo.</p>
<p>Mas espere - eu não disse que a função <span class='m'>print()</span> 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 <span class='m'>print()</span> 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 <i>dentro</i> das aspas, e são parte dos próprios strings.</p>
<h2 id="Loops">Loops</h2>
<p>A linha 12 tem algo que chamamos de um comando <span class='m'>while</span>, que indica o começo de um loop "while" ("while", em inglês, significa "enquanto", e pronuncia-se mais ou menos "uaiou"). <span class='term'>Loops</span> são partes do código que ficam sendo executadas e executadas de novo. Mas antes de aprendermos sobre os loops <span class='m'>while</span>, precisamos aprender alguns conceitos primeiro. Esses conceitos são blocos, Booleanos, operadores de comparação, condições e, finalmente, o comando <span class='m'>while</span>.</p>
<h2 id="Blocks">Blocos</h2>
<p>Um <span class='term'>bloco</span> é 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 <span class='term'>identação</span> das linhas (isto é, o número de espaços na frente de cada linha).</p>
<p>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.</p>
<p>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.</p>
<p class='centeredImageP'><img src='images/4-1.png' alt='' class='centeredImage' /><br />
Figura 4-1: Blocos e sua identação. Os pontos pretos representam espaços.</p>
<p>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.)</p>
<p>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.</p>
<p>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.</p>
<p>A linha 23 aumenta a identação para oito espaços, então novamente começou um novo bloco.</p>
<p>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).</p>
<p>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.</p>
<p>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.</p>
<h2 id="TheBooleanDataType">O Tipo de Dado Booleano</h2>
<p>O tipo de dado Booleano tem apenas dois valores: <span class='m'>True</span> ou <span class='m'>False</span> (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ê <b>não</b> coloca o caracter ' de aspas simples em volta deles. Usaremos valores Booleanos (também chamados de <span class='term'>bools</span>) com operadores de comparação para formar condições. (Explicado em seguida.)</p>
<h2 id="ComparisonOperators">Operadores de Comparação</h2>
<p>Na linha 12 do nosso programa, a linha de código contendo o comando <span class='m'>while</span>:</p>
<div class='sourcecode'><ol start='12'>
<li>while tentativas < 6:</li>
</ol></div>
<p>A expressão que segue a palavra <span class='m'>while</span> (<span class='m'>tentativas < 6</span>) contém dois valores (o valor da variável <span class='m'>tentativas</span> e o valor inteiro <span class='m'>6</span>) conectador por um operador (o sinal <span class='m'><</span>, o sinal "menor que"). O sinal <span class='m'><</span> é chamado de um <span class='term'>operador de comparação</span>.</p>
<p>O operador de comparação é usado para comparar dois valores e avaliar para um valor Booleano <span class='m'>True</span> (verdadeiro) ou <span class='m'>False</span> (falso). A tabela 4-1 mostra uma lista com todos os operadores de comparação.</p>
<div class='createspace'><br /><br /><br /></div>
<table class='simpletable'>
<caption>Table 4-1: Operadores de comparação.</caption>
<tr><th class='simpletd'>Sinal do Operador</th><th class='simpletd'>Nome do Operador</th></tr>
<tr><td class='simpletd m' align='center'><</td><td class='simpletd'>Menor que</td></tr>
<tr><td class='simpletd m' align='center'>></td><td class='simpletd'>Maior que</td></tr>
<tr><td class='simpletd m' align='center'><=</td><td class='simpletd'>Menor que ou igual a</td></tr>
<tr><td class='simpletd m' align='center'>>=</td><td class='simpletd'>Maior que ou igual a</td></tr>
<tr><td class='simpletd m' align='center'>==</td><td class='simpletd'>Igual a</td></tr>
<tr><td class='simpletd m' align='center'>!=</td><td class='simpletd'>Diferente de</td></tr>
</table>
<h2 id="Conditions">Condições</h2>
<p>Uma <span class='term'>condição</span> é uma expressão que combina dois valores com um operador de comparação (como <span class='m'><</span> ou <span class='m'>></span>) e avalia para um valor Booleano. A condição é apenas um outro nome para uma expressão que avalia para <span class='m'>True</span> ou <span class='m'>False</span>. Você pode ver uma lista de outros operadores de comparação na tabela 4-1.</p>
<p>Condições sempre avaliam para um valor Booleano: <span class='m'>True</span> ou <span class='m'>False</span>. Por exemplo, a condição no nosso código <span class='m'>tentativas < 6</span> pergunta "o valor armazenado em <span class='m'>tentativas</span> é menor que o número <span class='m'>6</span>?". Se sim, então a condição avalia para <span class='m'>True</span> (verdadeiro). Senão, a condição avalia para <span class='m'>False</span>.</p>
<p>No caso do nosso jogo Adivinhe o Número, na linha 4 armazenamos o valor <span class='m'>0</span> em <span class='m'>tentativas</span>. Como <span class='m'>0</span> é menor que <span class='m'>6</span>, essa condição avalia para o valor Booleano <span class='m'>True</span> (verdadeiro). Lembre-se, uma condição é apenas um nome para uma expressão que usa operadores de comparação como <span class='m'><</span> or <span class='m'>!=</span>.</p>
<h2 id="ExperimentwithBooleansComparisonOperatorsandConditions">Experimente com Booleanos, Operadores de Comparação e Condições</h2>
<p>Entre as seguintes expressões no console interativo para ver os seus resultados Booleanos:</p>
<div class='sourceblurb'>
>>> 0 < 6<br />
True<br />
>>> 6 < 0<br />
False<br />
>>> 50 < 10<br />
False<br />
>>> 10 < 11<br />
True<br />
>>> 10 < 10<br />
False<br />
</div>
<p>A condição <span class='m'>0 < 6</span> retorna o valor Booleano <span class='m'>True</span> (verdadeiro) porque o número <span class='m'>0</span> é menor que o número <span class='m'>6</span>. Mas como <span class='m'>6</span> não é menor que <span class='m'>0</span>, a condição <span class='m'>6 < 0</span> avalia para <span class='m'>False</span>. <span class='m'>50</span> não é menor que <span class='m'>10</span>, portanto <span class='m'>50 < 10</span> é <span class='m'>False</span>. <span class='m'>10</span> é menor que <span class='m'>11</span>, então <span class='m'>10 < 11</span> é <span class='m'>True</span> (verdadeiro).</p>
<p>Mas e <span class='m'>10 < 10</span>? Porque avalia para <span class='m'>False</span>? É <span class='m'>False</span> porque o número <span class='m'>10</span> não é menor que o número <span class='m'>10</span>. 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.</p>
<p>Experimente digitar algumas condições no console para ver como esses operadores de comparação funcionam:</p>
<div class='sourceblurb'>
>>> 10 == 10<br />
True<br />
>>> 10 == 11<br />
False<br />
>>> 11 == 10<br />
False<br />
>>> 10 != 10<br />
False<br />
>>> 10 != 11<br />
True<br />
>>> 'Oi' == 'Oi'<br />
True<br />
>>> 'Oi' == 'Tchau'<br />
False<br />
>>> 'Oi' == 'OI'<br />
False<br />
>>> 'Tchau' != 'Oi'<br />
True<br />
</div>
<p>Repare a diferença entre o operador de associação (<span class='m'>=</span>) e o operador de comparação "igual a" (<span class='m'>==</span>). O sinal de igual (<span class='m'>=</span>) é usado para associar um valor a uma variável, e o sinal de igual a (<span class='m'>==</span>) é 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.</p>
<p>Dois valores que são de tipos diferentes <b>sempre</b> serão diferentes um do outro. Por exemplo, experimente entrar o seguinte código no console interativo:</p>
<div class='sourceblurb'>
>>> 42 == 'Oi'<br />
False<br />
>>> 42 != '42'<br />
False<br />
</div>
<h2 id="LoopingwithWhileStatements"><i>Looping</i> com o Comando <span class='m'>while</span></h2>
<!--
<p>The <span class='m'>while</span> statement marks the beginning of a loop. Sometimes in our programs, we want the program to do something over and over again. When the execution reaches a <span class='m'>while</span> statement, it evaluates the condition next to the <span class='m'>while</span> keyword. If the condition evaluates to <span class='m'>True</span>, the execution moves inside the while-block. (In our program, the while-block begins on line 13.) If the condition evaluates to <span class='m'>False</span>, the execution moves all the way past the while-block. (In our program, the first line after the while-block is line 28.)</p>
-->
<p>O comando <span class='m'>while</span> ("enquanto", em inglês) marca o começo de um <i>loop</i>. Algumas vezes nos nossos programas, queremos que o programa faça alguma coisa repetidas vezes. Quando a execução chega em um comando <span class='m'>while</span>, ela avalia a condição próxima à palavra <span class='m'>while</span>. Se a condição avaliar para <span class='m'>True</span> (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 <span class='m'>False</span>, a execução vai para depois do bloco-while. (No nosso programa, a primeira linha depois do bloco-while é a linha 28).</p>
<!--
<p>A <span class='m'>while</span> statement always has a colon (the : sign) after the condition.</p>
-->
<p>Um comando <span class='m'>while</span> sempre tem um sinal de dois pontos (o sinal :) depois da condição.</p>
<div class='sourcecode'><ol start='12'>
<li>while tentativas < 6:</li>
</ol></div>
<p class='centeredImageP'><img src='images/4-2.png' alt='' class='centeredImage' /><br />
Figura 4-2: A condição de loop do <span class='m'>while</span>.</p>
<!--
<p>Figure 4-2 shows how the execution flows depending on the condition. If the condition evaluates to <span class='m'>True</span> (which it does the first time, because the value of <span class='m'>guessesTaken</span> is <span class='m'>0</span>), execution will enter the while-block at line 13 and keep going down. Once the program reaches the end of the while-block, instead of going down to the next line, it jumps back up to the <span class='m'>while</span> statement's line (line 12). It then re-evaluates the condition, and if it still evaluates to <span class='m'>True</span> we enter the while-block again.</p>
-->
<p>A Figura 4-2 mostra como a execução flui dependendo da condição. Se a condição avalia para <span class='m'>True</span> (o que acontece na primeira vez, porque o valor de <span class='m'>tentativas</span> é <span class='m'>0</span>), 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 <span class='m'>while</span> (linha 12). Então ele reavalia a condição, e se ela ainda avaliar para <span class='m'>True</span> entramos no bloco-while de novo.</p>
<!--
<p>This is how the loop works. As long as the condition is <span class='m'>True</span>, the program keeps executing the code inside the while-block repeatedly until we reach the end of the while-block and the condition is <span class='m'>False</span>. And, until <span class='m'>guessesTaken</span> is equal to or greater than <span class='m'>6</span>, we will keep looping.</p>
-->
<p>É assim que o loop funciona. Enquanto a condição é <span class='m'>True</span>, 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 <span class='m'>False</span>. E, até que <span class='m'>tentativas</span> seja igual ou maior que <span class='m'>6</span>, vamos continuar em loop.</p>
<!--
<p>Think of the <span class='m'>while</span> statement as saying, "while this condition is true, keep looping through the code in this block".</p>
-->
<p>While, em inglês, significa "enquanto". Pense no comando <span class='m'>while</span> como se dissesse "enquanto essa condição é verdadeira, continue executando o código desse bloco em loop".</p>
<!--
<p>You can make this game harder or easier by changing the number of guesses the player gets. All you have to do is change this line:</p>
-->
<p>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:</p>
<div class='sourcecode'><ol start='12'>
<li>while tentativas < <b>6</b>:</li>
</ol></div>
<!--
<p>into this line:</p>
-->
<p>para essa outra:</p>
<div class='sourcecode'><ol start='12'>
<li>while tentativas < <b>4</b>:</li>
</ol></div>
<!--
<p>...and now the player only gets four guesses instead of six guesses. By setting the condition to <span class='m'>guessesTaken < 4</span>, we ensure that the code inside the loop only runs four times instead of six. This makes the game much more difficult. To make the game easier, set the condition to <span class='m'>guessesTaken < 8</span> or <span class='m'>guessesTaken < 10</span>, which will cause the loop to run a few more times than before and accept more guesses from the player.</p>
-->
<p>...e agora o jogador tem apenas quatro tentativas em vez de seis. Ao mudar a condição para <span class='m'>tentativas < 4</span>, 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 <span class='m'>tentativas < 8</span> ou <span class='m'>tentativas < 10</span>, o que fará com que o loop rode algumas vezes a mais e aceite mais tentativas do jogador.</p>
<!--
<p>Of course, if we removed line 17 (<span class='m'>guessesTaken = guessesTaken + 1</span>) altogether then the <span class='m'>guessesTaken</span> would never increase and the condition would always be <span class='m'>True</span>. This would give the player an unlimited number of guesses.</p>
-->
<p>Claro que, se removermos a linha 17 (<span class='m'>tentativas = tentativas + 1</span>) então <span class='m'>tentativas</span> nunca aumentaria e a condição sempre seria <span class='m'>True</span>. Isso daria ao jogador um número ilimitado de tentativas.</p>
<!--
<h2 id="ThePlayerGuesses">The Player Guesses</h2>
-->
<h2 id="ThePlayerGuesses">As tentativas do jogador</h2>
<!--
<p>Lines 13 to 17 ask the player to guess what the secret number is and lets them enter their guess. We store this guess in a variable, and then convert that string value into an integer value.</p>
-->
<p>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.</p>
<div class='sourcecode'><ol start='13'>
<li> print('Tente adivinhar.') <span class='comment'># Há quatro espaços na frente do print.</span></li>
<li> palpite = input()</li>
</ol></div>
<!--
<p>The program now asks us for a guess. We type in our guess and that number is stored in a variable named <span class='m'>guess</span>.</p>
-->
<p>O programa agora nos pede um palpite. Nós digitamos nosso palpite e esse número é armazenado em uma variável chamada <span class='m'>palpite</span>.</p>
<!--
<h3 id="ConvertingStringstoIntegerswiththeintFunction">Converting Strings to Integers with the <span class='m'>int()</span> Function</h3>
-->
<h3 id="ConvertingStringstoIntegerswiththeintFunction">Convertendo Strings para Inteiros com a Função <span class='m'>int()</span></h3>
<div class='sourcecode'><ol start='15'>
<li> palpite = int(palpite)</li>
</ol></div>
<!--
<p>In line 15, we call a new function called <span class='m'>int()</span>. The <span class='m'>int()</span> function takes one argument. The <span class='m'>input()</span> function returned a string of text that player typed. But in our program, we will want an integer, not a string. If the player enters 5 as their guess, the <span class='m'>input()</span> function will return the string value <span class='m'>'5'</span> and not the integer value <span class='m'>5</span>. Remember that Python considers the string <span class='m'>'5'</span> and the integer <span class='m'>5</span> to be different values. So the <span class='m'>int()</span> function will take the string value we give it and return the integer value form of it.</p>
-->
<p>Na linha 15, chamamos uma nova função chamada <span class='m'>int()</span>. A função <span class='m'>int()</span> recebe um argumento. A função <span class='m'>input()</span> 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 <span class='m'>input()</span> retornará o valor string <span class='m'>'5'</span> e não o valor inteiro <span class='m'>5</span>. Lembre-se que o Python considera que string <span class='m'>'5'</span> e o inteiro <span class='m'>5</span> são valores diferentes. Então a função <span class='m'>int()</span> pegará o valor string que passamos a ela e retornará a forma de inteiro desse valor.</p>
<!--
<p>Let's experiment with the <span class='m'>int()</span> function in the interactive shell. Try typing the following:</p>
-->
<p>Vamos experimentar com função <span class='m'>int()</span> no console interativo. Tente digitar o seguinte:</p>
<div class='sourceblurb'>
>>> int('42')<br />
42<br />
>>> int(42)<br />
42<br />
>>> int('oi')<br />
<br />
Traceback (most recent call last):<br />
File "<pyshell#4>", line 1, in <module><br />
int('oi')<br />
ValueError: invalid literal for int() with base 10: 'oi'<br />
>>> int('quarenta-e-dois')<br />
<br />
Traceback (most recent call last):<br />
File "<pyshell#5>", line 1, in <module><br />
int('quarenta-e-dois')<br />
ValueError: invalid literal for int() with base 10: 'quarenta-e-dois'<br />
>>> int(' 42 ')<br />
42<br />
>>> 3 + int('2')<br />
5<br />
</div>
<!--
<p>We can see that the <span class='m'>int('42')</span> call will return the integer value <span class='m'>42</span>, and that <span class='m'>int(42)</span> will do the same (though it is kind of pointless to convert an integer to an integer). However, even though you can pass a string to the <span class='m'>int()</span> function, you cannot just pass any string. For example, passing <span class='m'>'hello'</span> to <span class='m'>int()</span> (like we do in the <span class='m'>int('hello')</span> call) will result in an error. The string we pass to <span class='m'>int()</span> must be made up of numbers.</p>
-->
<p>Podemos ver que a chamada de <span class='m'>int('42')</span> retornará o valor inteiro <span class='m'>42</span>, e que <span class='m'>int(42)</span> 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 <span class='m'>int()</span>, você não pode passar qualquer string. Por exemplo, ao passar <span class='m'>'oi'</span> para <span class='m'>int()</span> (como fizemos na chamada <span class='m'>int('oi')</span>) resultará em erro. O string que passamos para <span class='m'>int()</span> deve ser feito de números.</p>
<!--
<p>The integer we pass to <span class='m'>int()</span> must also be numerical, rather than text, which is why <span class='m'>int('forty-two')</span> also produces an error. That said, the <span class='m'>int()</span> function is slightly forgiving; if our string has spaces on either side, it will still run without error. This is why the <span class='m'>int(' 42 ')</span> call works.</p>
-->
<p>O inteiro que passamos para <span class='m'>int()</span> também deve ser numérico, em vez de texto, por isso <span class='m'>int('quarenta-e-dois')</span> 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 <span class='m'>int(' 42 ')</span> funciona.</p>
<!--
<p>The <span class='m'>3 + int('2')</span> line shows an expression that adds an integer <span class='m'>3</span> to the return value of <span class='m'>int('2')</span> (which is the integer <span class='m'>2</span>). The expression evaluates to <span class='m'>3 + 2</span>, which then evaluates to 5. So even though we cannot add an integer and a string (<span class='m'>3 + '2'</span> would show us an error), we can add an integer to a string that has been converted to an integer.</p>
-->
<p>A linha <span class='m'>3 + int('2')</span> mostra uma expressão que soma um inteiro <span class='m'>3</span> ao valor retornado por <span class='m'>int('2')</span> (que é o inteiro <span class='m'>2</span>). A expressão avalia para <span class='m'>3 + 2</span>, que então avalia para 5. Então mesmo que não possamos somar um inteiro e um string (<span class='m'>3 + '2'</span> daria um erro), nós podemos somar um inteiro e um string que foi convertido para um inteiro.</p>
<!-- TODO PAREI AQUI -->
<p>Remember, back in our program on line 15 the <span class='m'>guess</span> variable originally held the string value of what the player typed. We will overwrite the string value stored in <span class='m'>guess</span> with the integer value returned by the <span class='m'>int()</span> 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 <span class='m'>'5'</span>.</p>
<p>In our Guess the Number game, if the player types in something that is not a number, then the function call <span class='m'>int()</span> 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.</p>
<p>Notice that calling <span class='m'>int(guess)</span> does not change the value in the <span class='m'>guess</span> variable. The code <span class='m'>int(guess)</span> 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: <span class='m'>guess = int(guess)</span></p>
<h3 id="IncrementingVariables">Incrementing Variables</h3>
<div class='sourcecode'><ol start='17'>
<li> guessesTaken = guessesTaken + 1</li>
</ol></div>
<p>Once the player has taken a guess, we want to increase the number of guesses that we remember the player taking.</p>
<p>The first time that we enter the loop block, <span class='m'>guessesTaken</span> has the value of <span class='m'>0</span>. Python will take this value and add <span class='m'>1</span> to it. <span class='m'>0 + 1</span> is <span class='m'>1</span>. Then Python will store the new value of <span class='m'>1</span> to <span class='m'>guessesTaken</span>.</p>
<p>Think of line 17 as meaning, "the <span class='m'>guessesTaken</span> variable should be one more than what it already is".</p>
<p>When we add one to an integer value, programmers say they are <span class='term'>incrementing</span> the value (because it is increasing by one). When we subtract one from a value, we are <span class='term'>decrementing</span> the value (because it is decreasing by one). The next time the loop block loops around, <span class='m'>guessesTaken</span> will have the value of <span class='m'>1</span> and will be incremented to the value <span class='m'>2</span>.</p>
<h2 id="ifStatements"><span class='m'>if</span> Statements</h2>
<h3 id="IsthePlayersGuessTooLow">Is the Player's Guess Too Low?</h3>
<p>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.</p>
<div class='sourcecode'><ol start='19'>
<li> if guess < number:</li>
<li> print('Your guess is too low.') <span class='comment'># There are eight spaces in front of print.</span></li>
</ol></div>
<p>Line 19 begins an <span class='m'>if</span> statement with the keyword, <span class='m'>if</span>. Next to the <span class='m'>if</span> 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 <span class='m'>if</span> keyword is called an if-block. An <span class='m'>if</span> statement is used if you only want a bit of code to execute if some condition is true. Line 19 has an <span class='m'>if</span> statement with the condition <span class='m'>guess < number</span>. If the condition evaluates to <span class='m'>True</span>, then the code in the if-block is executed. If the condition is <span class='m'>False</span>, then the code in the if-block is skipped.</p>
<p style='float: right;' class='centeredImageP'><img src='images/4-3.png' alt='' class='centeredImage' /><br />
Figure 4-3: if and while statements.</p>
<!-- Made these float left and added <br/><br/> due to a printer issue with IE for CreateSpace. -->
<p style='float: left;'>Like the <span class='m'>while</span> statement, the <span class='m'>if</span> 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.<br /><br /></p>
<!-- Made these float left and added <br/><br/> due to a printer issue with IE for CreateSpace. -->
<p style='float: left;'>The <span class='m'>if</span> statement works almost the same way as a <span class='m'>while</span> statement, too. But unlike the while-block, execution does not jump back to the <span class='m'>if</span> statement at the end of the if-block. It just continues on down to the next line. In other words, <span class='m'>if</span> statements won't loop.<br /><br /></p>
<!-- Made these float left and added <br/><br/> due to a printer issue with IE for CreateSpace. -->
<p style='float: left;'>If the condition is <span class='m'>True</span>, then all the lines inside the if-block are executed. The only line inside this if-block on line 19 is a <span class='m'>print()</span> function call.</p>
<span class='createspace'><br /><br /><br /><br /><br /><br /><br /><br /><br /></span>
<p>If the integer the player enters is less than the random integer the computer thought up, the program displays <span class='m'>Your guess is too low</span>. If the integer the player enters is equal to or larger than the random integer (in which case, the condition next to the <span class='m'>if</span> keyword would have been <span class='m'>False</span>), then this block would have been skipped over.</p>
<h3 id="IsthePlayersGuessTooHigh">Is the Player's Guess Too High?</h3>
<p>Lines 22 to 26 in our program check if the player's guess is either too big or exactly equal to the secret number.</p>
<div class='sourcecode'><ol start='22'>
<li> if guess > number:</li>
<li> print('Your guess is too high.')</li>
</ol></div>
<p>If the player's guess is larger than the random integer, we enter the if-block that follows the <span class='m'>if</span> statement. The <span class='m'>print()</span> line tells the player that their guess is too big.</p>
<h2 id="LeavingLoopsEarlywiththebreakStatement">Leaving Loops Early with the <span class='m'>break</span> Statement</h2>
<div class='sourcecode'><ol start='25'>
<li> if guess == number:</li>
<li> break</li>
</ol></div>
<p>This <span class='m'>if</span> 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.</p>
<p>The line inside the if-block is a <span class='term'>break</span> 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 <span class='m'>break</span> statement does not bother re-checking the <span class='m'>while</span> loop's condition, it just breaks out immediately.)</p>
<p>The <span class='m'>break</span> statement is just the <span class='m'>break</span> keyword by itself, with no condition or colon.</p>
<p>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 (<span class='m'>guessesTaken < 6</span>). Remember after the <span class='m'>guessesTaken = guessesTaken + 1</span> line of code executed, the new value of <span class='m'>guessesTaken</span> is <span class='m'>1</span>. Because <span class='m'>1</span> is less than <span class='m'>6</span>, we enter the loop again.</p>
<p>If the player keeps guessing too low or too high, the value of <span class='m'>guessesTaken</span> will change to <span class='m'>2</span>, then <span class='m'>3</span>, then <span class='m'>4</span>, then <span class='m'>5</span>, then <span class='m'>6</span>. If the player guessed the number correctly, the condition in the <span class='m'>if guess == number</span> statement would be <span class='m'>True</span>, and we would have executed the <span class='m'>break</span> statement. Otherwise, we keep looping. But when <span class='m'>guessesTaken</span> has the number <span class='m'>6</span> stored, the <span class='m'>while</span> statement's condition is <span class='m'>False</span>, since <span class='m'>6</span> is not less than <span class='m'>6</span>. Because the <span class='m'>while</span> statement's condition is <span class='m'>False</span>, we will not enter the loop and instead jump to the end of the while-block.</p>
<p>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.</p>
<h2 id="CheckifthePlayerWon">Check if the Player Won</h2>
<div class='sourcecode'><ol start='28'>
<li>if guess == number:</li>
</ol></div>
<p>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 <span class='m'>while</span> block, we did so either because the <span class='m'>while</span> statement's condition was <span class='m'>False</span> (when the player runs out of guesses) or if we executed the <span class='m'>break</span> 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.</p>
<div class='sourcecode'><ol start='29'>
<li> guessesTaken = str(guessesTaken)</li>
<li> print('Good job, ' + myName + '! You guessed my number in ' + guessesTaken + ' guesses!')</li>
</ol></div>
<p>Lines 29 and 30 are inside the if-block. They only execute if the condition in the <span class='m'>if</span> statement on line 28 was <span class='m'>True</span> (that is, if the player correctly guessed the computer's number).</p>
<p>In line 29 we call the new function <span class='m'>str()</span>, which returns the string form of an argument. We use this function because we want to change the integer value in <span class='m'>guessesTaken</span> into its string version because we can only use strings in calls to <span class='m nw'>print()</span>.</p>
<p>Line 29 tells the player that they have won, and how many guesses it took them. Notice in this line that we change the <span class='m'>guessesTaken</span> 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.</p>
<h3 id="CheckifthePlayerLost">Check if the Player Lost</h3>
<div class='sourcecode'><ol start='32'>
<li>if guess != number:</li>
</ol></div>
<p>In Line 32, we use the comparison operator <span class='m'>!=</span> with the <span class='m'>if</span> 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 <span class='m'>True</span>, and we enter the block that follows this <span class='m'>if</span> statement on line 33.</p>
<p>Lines 33 and 34 are inside the if-block, and only execute if the condition is <span class='m'>True</span>.</p>
<div class='sourcecode'><ol start='33'>
<li> number = str(number)</li>
<li> print('Nope. The number I was thinking of was ' + number)</li>
</ol></div>
<p>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 <span class='m'>number</span> as the new value of <span class='m'>number</span>.</p>
<p>This line is also inside the if-block, and only executes if the condition was <span class='m'>True</span>. At this point, we have reached the end of the code, and the program terminates.</p>
<p>Congratulations! We've just programmed our first real game!</p>
<h2 id="SummaryWhatExactlyisProgramming">Summary: What Exactly is Programming?</h2>
<p>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.</p>
<p>"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 <span class='term'>output</span>), based on its instructions (that is, the program) and on the text that the player typed on the keyboard (which is called the <span class='term'>input</span>). The program has very specific instructions on what text to show the user. A <span class='term'>program</span> is just a collection of instructions.</p>
<p>"What kind of instructions?" There are only a few different kinds of instructions, really.</p>
<ol>
<li>Expressions, which are made up of values connected by operators. Expressions are all evaluated down to a single value, like <span class='m'>2 + 2</span> evaluates to <span class='m'>4</span> or <span class='m'>'Hello' + ' ' + 'World'</span> evaluates to <span class='m'>'Hello World'</span>. Function calls are also part of expressions because they evaluate to a single value themselves, and this value can be connected by operators to other values. When expressions are next to the <span class='m'>if</span> and <span class='m'>while</span> keywords, we also call them conditions.</li>
<li>Assignment statements, which simply store values in variables so we can remember the values later in our program.</li>
<li><span class='m'>if</span>, <span class='m'>while</span> and <span class='m'>break</span> are <span class='term'>flow control statements</span> because they decide which instructions are executed. The normal flow of execution for a program is to start at the top and execute each instruction going down one by one. But these flow control statements can cause the flow to skip instructions, loop over instructions, or break out of loops. Function calls also change the flow of execution by jumping to the start of a function.</li>
<li>The <span class='m'>print()</span> function, which displays text on the screen. Also, the <span class='m'>input()</span> function can get text from the user through the keyboard. This is called <span class='term'>I/O</span> (pronounced like the letters, "eye-oh"), because it deals with the input and output of the program.</li>
</ol>
<p>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 <span class='m'>if</span>, <span class='m'>while</span> and <span class='m'>break</span>, 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.)</p>
<p>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.</p>
<h2 id="AWebPageforProgramTracing">A Web Page for Program Tracing</h2>
<p>If you have access to the Internet and a web browser, you can go to this book's website at <a href='http://inventwithpython.com/traces'>http://inventwithpython.com/traces</a> 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.</p>
<p class='centeredImageP createspace'><img width='570' height='388' src='images/4-4.png' alt='' class='centeredImage' /><br />
Figure 4-4: The tracing web page.</p>
<p class='centeredImageP noncreatespace'><img src='images/4-4.png' alt='' class='centeredImage' /><br />
Figure 4-4: The tracing web page.</p>
<p>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.</p>
<p>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.)</p>
<p>So go to each of these web pages and click the "Next" and "Previous" buttons to trace through the program like we did above.</p>
<p>A video tutorial of how to use the online tracing tool is available from this book's website at <a href='http://inventwithpython.com/videos/'>http://inventwithpython.com/videos/</a>.</p>
<table border='0' width='100%'><tr><td><a href='chapter3.html'>Go to Chapter 3 - Strings</a></td><td align='right'><a href='chapter5.html'>Go to Chapter 5 - Jokes</a></td></tr></table>
<div style='height: 310px;'><a href='http://www.amazon.com/Invent-Your-Computer-Games-Python/dp/0982106017/'><img src='images/buyad.png' align='right'></a></div>
</body>
</html>