-
Notifications
You must be signed in to change notification settings - Fork 11
/
chapter2.html
331 lines (225 loc) · 24.6 KB
/
chapter2.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
<!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>ISPJCcP, Capítulo 2 - O Console Interativo</title>
<link rel="stylesheet" href="inventbook.css" type="text/css" media="all" />
</head>
<body>
<table border='0' width='100%'><tr><td><a href='chapter1.html'>Ir ao capítulo 1 - Instalando <i>Python</i></a></td><td align='right'><a href='chapter3.html'>Ir ao capítulo 3 - <i>Strings</i></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/chap2.png'></div>
<div class='inthischapter'><h3 id="TopicsCoveredInThisChapter">Tópicos Abordados neste Capítulo</h3>
<ul>
<li>Números Inteiros e de Ponto Flutuante</li>
<li>Expressões</li>
<li>Valores</li>
<li>Operadores</li>
<li>Avaliando Expressões</li>
<li>Armazenando Valores em Variáveis</li>
<li>Sobrescrevendo Variáveis</li>
</ul></div>
<p>Antes de começarmos a escrever jogos de computador, nós devemos, primeiro, aprender alguns conceitos básicos de programação. Estes conceitos são: valores, operadores, expressões e variáveis. Nós não vamos começar a programar nesse capítulo, mas conhecer estes conceitos e nome das coisas fará com que aprender a programar seja muito mais fácil. Isso porque a maior parte da programação se resume a combinar alguns poucos conceitos simples para formar programas mais avançados.</p>
<p>Vamos começar aprendendo como usar o console interativo do <i>Python</i>.</p>
<h2 id="SomeSimpleMathStuff">Algumas coisas simples de matemática</h2>
<p>Para abrir o IDLE no Windows, clique em <span class='menuname'>Iniciar</span>, depois em <span class='menuname'>Programas</span>, depois em <span class='menuname'>Python 3.1</span> e, finalmente, em <span class='menuname'>IDLE (Python GUI)</span>. Com o IDLE aberto, vamos fazer um pouco de matemática básica com Python. O console interativo pode funcionar como se fosse uma calculadora. Digite <span class='m'>2+2</span> no console e aperte a tecla Enter do seu teclado (em alguns teclados, ela pode se chamar Return ou Retorno). Como você pode ver na figura 2-1, o computador deve respoder com o número 4; a soma de 2+2.</p>
<p class='centeredImageP'><img src='images/2-1.png' alt='' class='centeredImage' /><br />
Figura 2-1: Digite <span class='m'>2+2</span> no console.</p>
<p>Como você pode ver, nós podemos usar o console interativo do Python exatamente como se fosse uma calculadora. Isso ainda não é um programa porque nós ainda estamos aprendendo o básico nesse momento. O sinal de <span class='m'>+</span> diz ao computador para somar os números 2 e 2. Para subtrair números use o sinal de <span class='m'>-</span>, e para multiplicar use um asterisco (<span class='m'>*</span>), assim:</p>
<table class='centertable simpletable' style='width: 200px; text-align: center;'>
<caption>Tabela 2-1: Os vários operadores matemáticos do Python.</caption>
<tr><td class='simpletd'><span class='m'>2+2</span></td><td class='simpletd'>adição</td></tr>
<tr><td class='simpletd'><span class='m'>2-2</span></td><td class='simpletd'>subtração</td></tr>
<tr><td class='simpletd'><span class='m'>2*2</span></td><td class='simpletd'>multiplicação</td></tr>
<tr><td class='simpletd'><span class='m'>2/2</span></td><td class='simpletd'>divisão</td></tr>
</table>
<p>Quando usados dessa forma, +, -, *, e / são chamados de <span class='term'>operadores</span> porque eles dizem ao computador realizar a operação escolhida nos números quem estão em volta dele.</p>
<h3 id="IntegersandFloatingPointNumbers">Números Inteiros e de Ponto Flutuante</h3>
<p>Em programação (e também na matemática), números como 4, 0 e 99 são chamados de <span class='term'>inteiros</span>. Números com fração ou casas decimais (como 3,5 e 42,1 e 5,0) não são inteiros. Em Python, o número 5 é um inteiro, mas se nós escrevermos ele como 5.0 ele não será mais um inteiro. Números com casas decimais são chamados <span class='term'>números de ponto flutuante</span>. Na matemática, 5,0 ainda é considerado um inteiro e é igual ao número 5, mas em programação o computador considera qualquer número com casa decimal como um número não inteiro.</p>
<!-- Esse seção não faz sentido em português pois não usamos vírgula como separador de milhar. Mas ela me motivou a adicionar a próxima seção -->
<!-- Decided to remove this since it was important enough.
<h3 id="DontUseCommasinNumbers">Don't Use Commas in Numbers</h3>
<p>The Python shell is handy for solving large math problems very quickly. For example, try entering <span class='m'>2063 * 3581</span>.</p>
<p>When I say "enter" I mean type something into IDLE and then press the Enter or RETURN key on your keyboard. It will look something like this:</p>
<div class='sourceblurb'>
>>> 2063 * 3581<br />
7387603<br />
>>><br />
</div>
<p>That was a lot faster than solving it by hand! Solving calculations quickly is what computers were made for. But in order for Python to understand what calculations we want it to do, we must enter them in a particular way.</p>
<p>In Python, we don't put commas inside numbers. We type <span class='m'>2063</span> instead of <span class='m'>2,063</span>. The computer can do what you tell it to very quickly, but it needs you to tell it in a very specific way. Computer programming is all about writing out precise instructions to get the computer to do exactly what you want because really computers are dumb. We need to tell them exactly what to do.</p>
//-->
<h3 id="DontUseCommasinNumbers">Não use vírgula nos números</h3>
<p>O console interativo do Python é útil para resolver problemas matemáticos rapidamente. Por exemple, tente executar <span class='m'>2.063 * 0.3581</span>.</p>
<p>Quando eu digo "executar" eu quero dizer digite alguma coisa no IDLE e então aperte a tecla Enter ou Retorno (Return) do seu teclado. O resulta será algo do tipo:</p>
<div class='sourceblurb'>
>>> 2.063 * 0.3581<br />
0.7387603<br />
>>><br />
</div>
<p>Isso foi muito mais rápido do que resolvar não mão! Resolver contas rapidamente foi o motivo pelo qual os computadores foram criados. Mas para que o Python entendo que conta nós queremos fazer, nós devemos escreve-lás em um formato específico.</p>
<p>Em Python, nós não usamos vírgula nos números. Nós escrevemos <span class='m'>2.063</span> ao invés de <span class='m'>2,063</span>. O computador pode fazer o que você pedir para ele rapidamente, mas ele precisa que você diga a ele em um formato específico. Programar um computador é escrever instruções precisas para fazer com que o computador faça exatamente o que você quer porque, na realidade, computadore são burros. Nós precisamos dizer a eles exatamente o que queremos fazer.</p>
<h3 id="Expressions">Expressões</h3>
<p>Tente digitar alguns destes probelmas matemáticos no console, apertando a tecla Enter depois de cada um deles.</p>
<div class='sourceblurb'>
2+2+2+2+2<br />
8*6<br />
10-5+6<br />
2 + 2<br />
</div>
<p>Figura 2-2 mostra como o console interativo no IDLE irá ficar depois que você digitar as instruções acima.</p>
<p class='centeredImageP'><img src='images/2-2.png' alt='' class='centeredImage' /><br />
Figura 2-2: Como a janela do IDLE ficará depois de executar as instruções.</p>
<p style='float: right;' class='centeredImageP'><img src='images/2-3.png' alt='' class='centeredImage' /><br />
Figura 2-3: Uma expressão é formada por valores e operadores.</p>
<p>Estes problemas matemáticos são chamados expressões. Computadores podem resolver milhÕes destes problemas em segundos. Expressões são formadas por <span class='term'>valores</span> (os números) conectados por <span class='term'>operadores</span> (os símbolos matemáticos). Vamos aprender exatamente o que valores e operadores são.</p>
<p>Como você pode ver nas últimas expressões do exemplo acima, você pode colocar quantos espaços você quiser entre os inteiros e estes operadores (mas tenha certeza de sempre começar no início da linha, sem espaços em branco na frente).</p>
<p>Números são um tipo de valor. Inteiros são um tipo de número. Mas, embora inteiros sejam números, nem todos os números são inteiros (por exemplo, frações e números com casas decimais como <span class='m'>2.5</span> são números que não são inteiros).</p>
<p>Isso é como um gato é um tipo de animal de estimação, mas nem todos os animais de estimação são gatos. Alguém poderia ter como animal de estimação um cachorro ou um carangueijo ermitão. Uma <span class='term'>expressão</span> é formada por valores (como os inteiros 8 e 6) conectados por um operador (como o símbolo de multiplicação *). Um único valor sozinho também é considerado uma expressão.</p>
<p>No próximo capítulo, nós vamos aprender como trabahar com texto nas expressões. Python não é limitado apenas à números. É muito mais do que uma calculadora rebuscada!</p>
<h2 id="EvaluatingExpressions">Avaliando Expressões</h2>
<p>Quando um computador resolve a expressão <span class='m'>10 + 5</span> e encontra o valor <span class='m'>15</span>, nós dizemos que ele <span class='term'>avaliou</span> a expressão. Avaliar uma expressão reduz a expressão a um único valor, da mesma forma que resolver um problema matemático reduz o problema a um único número: a resposta.</p>
<p>As expressões <span class='m'>10 + 5</span> e <span class='m'>10 + 3 + 2</span> possuem o mesmo valor, pois as duas são avaliadas em <span class='m'>15</span>. Até mesmo valores únicos são considerados expressões: a expressão <span class='m'>15</span> é avaliada para o valor <span class='m'>15</span>.</p>
<p>Entretanto, se nós apenas digitarmos <span class='m'>5 +</span> no console interativo, você receberá uma mensagem de erro.</p>
<div class='sourceblurb'>
>>> 5 +<br />
SyntaxError: invalid syntax<br />
</div>
<p>Esse erro ocorreu pois <span class='m'>5 +</span> não é uma expressão. Expressões possum valores conectados por operadores, mas o operador + sempre espera conectar duas coisas em Python. Nós demos a ele apenas um. Por isso a mensagem de erro apareceu. Um erro de sintaxe significa que o computador não entende a instrução que você deu a ele porque você a digitou incorretamente. Python sempre irá mostrar uma mensagem de erro se você enviar uma instrução que ele não consegue entender.</p>
<p>Isso pode não parecer importante, mas grande parte da programação de computadores não é apenas dizer ao computador o que ele deve fazer, mas também saber exatamente como dizer isso ao computador.</p>
<h3 id="ExpressionsInsideOtherExpressions">Expressões Dentro de Outras Expressões</h3>
<p>Expressões também podem conter outras expressões. Por exemplo, nas expressões <span class='m'>2 + 5 + 8</span>, a parte <span class='m'>2 + 5</span> é uma expressão. Python avalia <span class='m'>2 + 5</span> em <span class='m'>7</span>, então a expressão original se transforma em <span class='m'>7 + 8</span>. Python então avalia essa expressão em <span class='m'>15</span>.</p>
<p>Pense em uma expressão como se fosse uma pilha de panquecas. Se você colocar duas pilhas de panquecas juntas, você ainda terá uma pilha de panquecas. E uma grande pilha de panquecas pode ser formada de pilhas menores de panquecas que foram colocadas juntas. Da mesma forma, expressões podem ser combinadas para formar expressões maiores. Mas não importa o quão grande uma expressão é, ela também será avaliada em uma única resposta, exatamente como <span class='m'>2 + 5 + 8</span> é avaliada em <span class='m'>15</span>.</p>
<h2 id="StoringValuesinVariables">Guardando Valores em Variáveis</h2>
<p>Quando nós programamos, frequentemente nós iremos querer salvar os valores em que as nossas expressões são avaliadas para que nós possamos utilizá-los mais tarde em nosso programa. Nós podemos guardar valores em <span class='term'>variáveis</span>.</p>
<p>Pense nas variáveis como uma caixa que pode guardar valores. Você pode guardar valores dentro de variáveis com o símbolo = (chamado de <span class='term'>operador de atribuição</span>). Por exemplo, para guardar o valor 15 em uma variável chamada "spam", digite <span class='m'>spam = 15</span> no console:</p>
<div class='sourceblurb'>
>>> spam = 15<br />
>>><br />
</div>
<p style='float: right;' class='centeredImageP'><img src='images/2-4.png' alt='' class='centeredImage' /><br />
Figura 2-4: Variáveis são como caixas que podem guardar valores dentro delas.</p>
<p>Você pode pensar em uma variável como uma caixa com o valor 15 dentro dela (como mostrada na Figura 2-4). O nome da variável "spam" é a etiqueta na caixa (para que nós possamos diferenciar uma variável da outra) e o valor armazenado dentro dela é como se fosse um bilhete dentro da caixa.</p>
<p>Quando você apertar Enter, você não verá nada como resposta, exceto uma linha em branco. A menos que você veja uma mensagem de erro, você pode assumir que a execução da instrução foi bem sucedida. O próximo >>> irá aparecer para que você possa digitar a próxima instrução.</p>
<p>Essa instrução (chamada de <span class='term'>declaração de atribuição</span>) cria uma variável <span class='m'>spam</span> e guarda o valor <span class='m'>15</span> nela. Diferentemente das expressões, <span class='term'>declarações</span> são instruções que não são avaliadas a nenhum valor, por isso que nenhum valor é exibido na próxima linha do console.</p>
<p>Pode ser confuso saber quais instruções são expressões e quais são declarações. Apenas lembre-se que se uma instrução for avaliada em único valor, é uma expressão. Caso contrário, é uma declaração.</p>
<p>Uma declaração de atribuição é escrito como uma variável, seguida de um símbolo de igual =, seguida de uma expressão. O valor em que a expressão é avaliada é aramzenada dentro da variável. O valor <span class='m'>15</span> por si só é uma expressão. Expressões formadas por um único valor são fáceis de se avaliar. Estar expressões são avaliadas apenas em seu próprio valor. Por exemplo, a expressão <span class='m'>15</span> é avaliada em <span class='m'>15</span>!</p>
<p>Lembre-se, variáveis guardam valores, não expressões. Por exemple, se nós tivéssemos a declaração, <span class='m'>spam = 10 + 5</span>, então a expressão <span class='m'>10 + 5</span> seria primeiro avaliada em <span class='m'>15</span> e então o valor <span class='m'>15</span> seria armazenado na variável <span class='m'>spam</span>.</p>
<p>A primeira vez que você armazenar um valor em uma variável usando uma declaração de atribuição, Python irá criar essa variável. Todas as vezes depois disso, uma declaração de atribuição irá apenas substituir o valor aramzenado naquela variável.</p>
<p>Agora vamos ver se nós criamos a nossa variável corretamente. Se nós digitarmos apenas <span class='m'>spam</span> no console, deveremos ver que valor está armezenado dentro desta variável <span class='m'>spam</span>.</p>
<div class='sourceblurb'>
>>> spam = 15<br />
>>> spam<br />
15<br />
>>><br />
</div>
<p>Agora, <span class='m'>spam</span> é avaliado para o valor armazenado dentro da variável, 15.</p>
<p>E aqui está uma mudança interessante. Se nós agora digitarmos <span class='m'>spam + 5</span> no console, nós recebemos o inteiro <span class='m'>20</span>, assim.</p>
<div class='sourceblurb'>
>>> spam = 15<br />
>>> spam + 5<br />
20<br />
>>><br />
</div>
<p>Isso pode parecer estranho mas faz todo o sentido quando nós lembramos que nós associamos o valor de spam para <span class='m'>15</span>. Como nós associamos o valor da variável <span class='m'>spam</span> para <span class='m'>15</span>, escrevendo <span class='m'>spam + 5</span> é como escrever a expressão <span class='m'>15 + 5</span>.</p>
<p>Se você tentar usar uma variável antes de criá-la, Python lhe dará um erro porque nenhuma variável com aquele nome foi criada ainda. Isso também acontece se você digitar o nome errado de uma variável</p>
<p>Nós podemos mudar o valor armazenado em uma variável executando uma outra declaração de associação. Por exemplo, tente o seguinte:</p>
<div class='sourceblurb'>
>>> spam = 15<br />
>>> spam + 5<br />
20<br />
>>> spam = 3<br />
>>> spam + 5<br />
8<br />
>>><br />
</div>
<p>Na primeira vez em que executamos <span class='m'>spam + 5</span>, a expressão é avaliada em <span class='m'>20</span>, pois nós armazenamos o valor <span class='m'>15</span> dentro da variável <span class='m'>spam</span>. Mas quando nós executamos <span class='m'>spam = 3</span>, o valor <span class='m'>15</span> é substituído, ou sobrescrito, com o valor <span class='m'>3</span>. Agora, quando nós executamos <span class='m'>spam + 5</span>, a expressão é avaliada em <span class='m'>8</span> porque o valor de <span class='m'>spam</span> agora é 3.</p>
<p>Para descobrir qual o valor atual armazenado em uma variável, apenas digite o nome da variável no console e aperte Enter.
<p>Agora aqui está algo interessanto. Como uma variável é apenas um nome para um valor, nós podemos escrever expressões com variáveis dessa forma:</p>
<div class='sourceblurb'>
>>> spam = 15<br />
>>> spam + spam<br />
30<br />
>>> spam - spam<br />
0<br />
>>><br />
</div>
<p>Quando a variável <span class='m'>spam</span> tem o valor inteiro <span class='m'>15</span> armezenado nela, executando <span class='m'>spam + spam</span> é o mesmo que executar <span class='m'>15 + 15</span>, que é avaliado em <span class='m'>30</span>. E <span class='m'>spam - spam</span> é o mesmo que <span class='m'>15 - 15</span>, que é avaliado em <span class='m'>0</span>. As expressões acima usam a variável <span class='m'>spam</span> duas vezes. Você pode usar variáveis quantas vezes você quiser em expressões. Lembre-se que o Python irá avaliar o nome da variável ao valor que está armazenado dentro da variável, todas as vezes que a variável é utilizada.</p>
<p>Nós podemos até usar o valor amrmazenado na variável <span class='m'>spam</span> para associar à <span class='m'>spam</span> um novo valor:</p>
<div class='sourceblurb'>
>>> spam = 15<br />
>>> spam = spam + 5<br />
20<br />
>>><br />
</div>
<p>A declaração de associação <span class='m'>spam = spam + 5</span> é como dizer, "o novo valor da variável <span class='m'>spam</span> será o valor atual de <span class='m'>spam</span> mais cinco." Lembre-se que a variável do lado esquerdo do símbolo <span class='m'>=</span> será associado ao valor que a expressão do lado direito é avaliada. Nós podemos inclusive continuar aumentando o valor armazenado em <span class='m'>spam</span> em <span class='m'>5</span> várias vezes:</p>
<div class='sourceblurb'>
>>> spam = 15<br />
>>> spam = spam + 5<br />
>>> spam = spam + 5<br />
>>> spam = spam + 5<br />
>>> spam<br />
30<br />
>>><br />
</div>
<h2 id="UsingMoreThanOneVariable">Usando Mais de Uma Variável</h2>
<p>Quando nós programamos, nós nem sempre iremos querer nos limitarmos à apenas uma única variável. Frequentemente nós iremos precisar usar diversas variáveis.</p>
<p>Por exemplo, vamos associar valores diferentes a duas variáveis chamadas <span class='m'>ovos</span> e <span class='m'>assobio</span>
For example, let's assign different values to two variables named <span class='m'>ovos</span> and <span class='m'>assobio</span>, assim:</p>
<div class='sourceblurb'>
>>> assobio = 10<br />
>>> ovos = 15<br />
</div>
<p>Agora a variável <span class='m'>assobio</span> tem <span class='m'>10</span> armazenado nela, e <span class='m'>ovos</span> tem <span class='m'>15</span> dentro dela.</p>
<p class='centeredImageP'><img src='images/2-5.png' alt='' class='centeredImage' /><br />
Figura 2-5: As variáveis "assobio" e "ovos" possuem valores armazenados dentro delas.</p>
<p>Sem mudar o calor em nossa variável <span class='m'>spam</span>, vamos tentar armazenar um novo valor para a variável <span class='m'>spam</span>. Execute <span class='m'>spam = assobio + ovos</span> no console e em seguida execute <span class='m'>spam</span> no console para ver o novo valor de <span class='m'>spam</span>. Você consegue imaginar qual será?</p>
<div class='sourceblurb'>
>>> assobio = 10<br />
>>> ovos = 15<br />
>>> spam = assobio + ovos<br />
>>> spam<br />
25<br />
>>><br />
</div>
<p>O valor em <span class='m'>spam</span> é agora <span class='m'>25</span> pois quando nós somamos <span class='m'>assobio</span> e <span class='m'>ovos</span> nós estamos somando os valores armazenados dentro de <span class='m'>assobio</span> e <span class='m'>ovos</span>.</p>
<h3>Sobrescrevendo Variáveis</h3>
<p>Mudar o valor armazenado dentro de uma variável é simples. Apenas execute outra declaração de associação com a mesma variável. Veja o que acontece quando você executa o seguinte comando no console interativo:</p>
<div class='sourceblurb'>
>>> spam = 42<br />
>>> print(spam)<br />
42<br />
>>> spam = 'Oi'<br />
>>> print(spam)<br />
Oi<br />
</div>
<p>Inicialmente, a variável <span class='m'>spam</span> tinha um inteiro <span class='m'>42</span> guardado dentro dela. Por isso que o primeiro <span class='m'>print(spam)</span> imprime <span class='m'>42</span>. Mas quando nós executamos <span class='m'>spam = 'Oi'</span>, o valor <span class='m'>42</span> é jogado fora da variável e esquecido pois o novo valor da string <span class='m'>'Oi'</span> é armazenada dentro da variável <span class='m'>spam</span>.</p>
<p>Substituindo o valor de uma variável com um novo calor é chamado <span class='term'>sobrescrever</span> o valor. É importante saber que o valor antigo é permanentemente esquecido. Se você quiser lembrar esse valor para poder usá-lo mais tarde no seu programa, guarde-o em uma variável diferente antes de sobrescrever o valor:</p>
<div class='sourceblurb'>
>>> spam = 42<br />
>>> print(spam)<br />
42<br />
>>> oldSpam = spam<br />
>>> spam = 'Oi'<br />
>>> print(spam)<br />
Oi<br />
>>> print(oldSpam)<br />
42<br />
</div>
<p>No exemplo acima, antes de sobrescrever o valor em <span class='m'>spam</span>, nós copiamos esse valor em uma variável chamada <span class='m'>oldSpam</span>. Nesse momento, tanto <span class='m'>spam</span> quanto <span class='m'>oldSpam</span> guardam o valor <span class='m'>42</span>. Na linha seguinte, a string <span class='m'>'Oi'</span> é armazenada em <span class='m'>spam</span> mas <span class='m'>oldSpam</span> permanece igual.</p>
<h2 id="Summary">Sumário</h2>
<p>Neste capítulo você aprendeu o básico sobre escrever instruções em Python. Python precisa que você diga a ele exatamente o que fazer em uma forma expecífica, pois computadores não tem bom senso e entende apenas instruções muito simples. Você aprendeu que Python pode avaliar expressões (ou seja, reduzir a expressão em um único valor), e que expressões são valores (tais como <span class='m'>2</span> ou <span class='m'>5</span>) combinados com operadores (tais como <span class='m'>+</span> or <span class='m'>-</span>). Você também aprendeu que você pode armazenar valores dentro de variáveis para que o seu programa possa se lembrar delas e possa utilizá-las mais tarde.</p>
<p>No próximo capítulo, nós iremos cobrir mais alguns conceitos básicos, e você irá escrever o seu primeiro programa!</p>
<table border='0' width='100%'><tr><td><a href='chapter1.html'>Ir para o capítulo 1 - Instalando <i>Python</i></a></td><td align='right'><a href='chapter3.html'>Ir para o capítulo 3 - <i>Strings</i></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>