View
12
Download
1
Category
Preview:
Citation preview
Versão atual = 14/08/2011
versão inicial : 07/07/2007 - | André Koscianski
GRUPO DE
PESQUISA EM
PEDAGOGIA
LÚDICA
PYTHON : ESTUDO DIRIGIDO
Prefácio
Este pequeno guia vai ajudá
também poderá ajudá-lo a melhorar sua habilidade de Python possui uma vantagem importante em relação a linguagem C e todas as suas derivadas (Java,
C++, C#...): a sintaxe é mais simples e evita problemas e seus respectivos algoritmos
Por isso Python é uma ótima linguagem inicial. Para que o trabalho funcione
oriunda da Internet e, sobretudo, resolva os problemas propostosenergia no trabalho – você tem todas as chances de obter bons resultados.
Boa leitura!
µ
3
Este pequeno guia vai ajudá-lo a estudar a linguagem de programação Python. lo a melhorar sua habilidade de programação.
Python possui uma vantagem importante em relação a linguagem C e todas as suas derivadas (Java, ...): a sintaxe é mais simples e evita símbolos como { } ; . Isso permite
e seus respectivos algoritmos e menos na sintaxe do código sendo escrito
Por isso Python é uma ótima linguagem inicial.
funcione é preciso dedicar-se. Leia o texto, complementeresolva os problemas propostos. Fazendo isso –
você tem todas as chances de obter bons resultados.
µ guia de estudos python
André Koscianski
lo a estudar a linguagem de programação Python. Eventualmente, ele
Python possui uma vantagem importante em relação a linguagem C e todas as suas derivadas (Java, se concentrar mais nos
do código sendo escrito.
se. Leia o texto, complemente-o com informação – ou seja, concentrando
O texto não deve ser usado fora da UTFPR sem o consentimento do autor.
Sumário Parte um: Linguagem básica ................................
1. PRINT e operações aritméticas
2. Variáveis ................................
3. PRINT e números, parte II
4. IMPORT ................................
5. IF ELSE ................................
6. Raízes de Equação ................................
7. Entrada de Dados ................................
8. Laços for................................
9. Números aleatórios ................................
10. Números aleatórios em um intervalo
11. Laço WHILE ................................
12. Asteriscos KGB ................................
13. FROM ... IMPORT ................................
14. Sub-rotinas................................
15. Acentuação ................................
16. Laços FOR com listas
Parte dois: PYGAME básico ................................
17. FROM ... IMPORT parte II
18. Mostrar objeto na tela
19. Mover objeto ................................
20. Figuras com Transparências
21. Problema: iô-iô ................................
22. Problema: dois iô-iôs
µ
4
O texto não deve ser usado fora da UTFPR sem o consentimento do autor.
................................................................................................
PRINT e operações aritméticas ................................................................
................................................................................................................................
parte II ................................................................................................
................................................................................................................................
................................................................................................................................
................................................................................................
................................................................................................
................................................................................................................................
................................................................................................
Números aleatórios em um intervalo ................................................................
................................................................................................
................................................................................................
................................................................................................
................................................................................................
................................................................................................
Laços FOR com listas ................................................................................................
................................................................................................
FROM ... IMPORT parte II................................................................................................
Mostrar objeto na tela................................................................................................
................................................................................................
Transparências ................................................................
................................................................................................
iôs ................................................................................................
µ guia de estudos python
André Koscianski
................................................... 7
.................................................................... 8
...................................... 9
............................................ 9
...................................... 10
........................................ 11
..................................................... 12
...................................................... 12
..................................... 13
................................................... 13
.................................................... 13
............................................................ 14
....................................................... 15
................................................... 17
............................................................. 18
............................................................ 18
.............................................. 19
................................................... 20
...................................... 21
........................................... 22
......................................................... 24
.................................................................. 25
...................................................... 26
............................................. 26
23. MRUV, Movimento retilíneo uniformemente acelerado
24. MRUV com atrito ................................
25. Controle do teclado
26. Problema: teste da fila de eventos.
27. Estado atual do teclado
28. Problema: iô-iô com controle
29. Problema: iô-iô com super
30. Canhão anti-aéreo ................................
31. Escrevendo na tela gráfica
Parte três: Orientação a Objetos básica em Python
32. Rudimentos de OO em Python , parte I
33. Rudimentos de OO em Python , parte II
34. Objetos são variáveis
35. A variável self de Python
36. Atributos de objetos
37. Aviões – objetos ................................
38. Esqueleto de jogo: pouso lunar, parte I
39. Esqueleto de jogo: pouso lunar, parte II
µ
5
MRUV, Movimento retilíneo uniformemente acelerado ................................
................................................................................................
Controle do teclado ................................................................................................
Problema: teste da fila de eventos. ................................................................
Estado atual do teclado ................................................................................................
iô com controle ................................................................
iô com super-controle ................................................................
................................................................................................
Escrevendo na tela gráfica ................................................................................................
rte três: Orientação a Objetos básica em Python ................................................................
Rudimentos de OO em Python , parte I ................................................................
Rudimentos de OO em Python , parte II ................................................................
Objetos são variáveis ................................................................................................
de Python ................................................................................................
Atributos de objetos ................................................................................................
................................................................................................
o de jogo: pouso lunar, parte I ................................................................
Esqueleto de jogo: pouso lunar, parte II ................................................................
µ guia de estudos python
André Koscianski
...................................................... 27
................................................... 28
............................................... 29
....................................................... 31
......................................... 31
................................................................ 32
..................................................... 32
................................................. 33
..................................... 34
............................................. 35
................................................ 36
............................................... 36
............................................. 37
...................................... 38
.............................................. 39
.................................................... 40
................................................ 41
............................................... 42
Como este guia funciona
Este guia de estudos é composto de uma série de problemas em Para que o trabalho corra bem, há algumas dicas. Em primeiro lugar, procure não
pior, assistir novela ou jornal nacional (estes dois últimos terão efeitos negativos sobre seu cérebro). Isso vale para qualquer disciplina: jamais estude pensando em outra coisa. Você só Segundo conselho, não exagere
estude 30 minutos por dia e depois mude de assunto. Use isso para aprender mais sobre Python e jogos/PyGame, mas também para TODAS as disciplinas dEstudando mais atento e descansado, seu trabalho renderá o dobro.
Resolva todos os problemas
1) se um problema for muito fácil, construa a solução mentalmentou se sentir inseguro, pode ser melhor implementar
2) se um problema parecer muito difícil, você pode tentar passar para o problema seguinte. Algumas
vezes a ordem de dificuldade proposta não é exatamente a SUA ordem de di Se isso tudo acima não funcionar apele a um colega ou a um professor. Mãos a obra.
µ
6
Como este guia funciona
Este guia de estudos é composto de uma série de problemas em ordem crescente de dificuldade.
bem, há algumas dicas.
não misturar estudo com rádio, briga com o irmão mais novo ou, muito pior, assistir novela ou jornal nacional (estes dois últimos terão efeitos negativos sobre seu cérebro).
Isso vale para qualquer disciplina: jamais estude pensando em outra coisa. Você só
não exagere. Ao invés de estudar cinco horas duranteminutos por dia e depois mude de assunto. Use isso para aprender mais sobre Python e
, mas também para TODAS as disciplinas do curso. Fazendo isso você nunca enjoa ou cansa. Estudando mais atento e descansado, seu trabalho renderá o dobro.
na ordem em que aparecem, salvo em dois casos:
1) se um problema for muito fácil, construa a solução mentalmente. Mas: smelhor implementar.
2) se um problema parecer muito difícil, você pode tentar passar para o problema seguinte. Algumas vezes a ordem de dificuldade proposta não é exatamente a SUA ordem de dificuldade.
não funcionar apele a um colega ou a um professor.
µ guia de estudos python
André Koscianski
ordem crescente de dificuldade.
estudo com rádio, briga com o irmão mais novo ou, muito pior, assistir novela ou jornal nacional (estes dois últimos terão efeitos negativos sobre seu cérebro).
Isso vale para qualquer disciplina: jamais estude pensando em outra coisa. Você só perderá tempo.
. Ao invés de estudar cinco horas durante o fim de semana todo, minutos por dia e depois mude de assunto. Use isso para aprender mais sobre Python e
o curso. Fazendo isso você nunca enjoa ou cansa.
salvo em dois casos:
: se surgir alguma dúvida
2) se um problema parecer muito difícil, você pode tentar passar para o problema seguinte. Algumas ficuldade.
Parte um: Linguagem básica Você deve instalar o interpretador de Python em sua máquina.
default da instalação. Isso significa pressionar “Ok” e “Yes” a todas as perguntas durante a instalação. A última versão pode ser encontrada na internet (
ironpython ou outras implementações. Nada impede, contudo, de testá Você pode executar comandos Python diretamente. Para saber se o interpretador funciona, faça
como mostra esta figura:
µ
7
Parte um: Linguagem básica
Você deve instalar o interpretador de Python em sua máquina. Ao fazê-lo é bom usarIsso significa pressionar “Ok” e “Yes” a todas as perguntas durante a instalação.
A última versão pode ser encontrada na internet (www.python.org). Usaremos o Cpython (e não ironpython ou outras implementações. Nada impede, contudo, de testá-las).
Você pode executar comandos Python diretamente. Para saber se o interpretador funciona, faça
Caso não funcione
computador/propriedades/avançado/variáveis de ambiente" se a variável PATH contem referência ao diretório onde o interpretador Python foi instalado.
Como último recurso, desinstale e instale
novamente o interpretador.
µ guia de estudos python
André Koscianski
lo é bom usar o diretório-Isso significa pressionar “Ok” e “Yes” a todas as perguntas durante a instalação.
Usaremos o Cpython (e não
Você pode executar comandos Python diretamente. Para saber se o interpretador funciona, faça
funcione, verifique em "meu computador/propriedades/avançado/variáveis de ambiente" se a variável PATH contem referência ao
rpretador Python foi instalado.
Como último recurso, desinstale e instale novamente o interpretador.
1. PRINT e operações aritméticas Vamos ao primeiro problema deste guia.
ativar o interpretador Python (simplesmente dambiente por ele fornecido.
Usando apenas o comando print, teste os operadores aritméticos usando números inteiros e
fracionários. Os operadores são: + - * ** / // e % . Comece observando esta cópia de tela
Faça testes simples com números Descubra para que servem os operadores ** e % (ex.: 3**4 e 40 % 3). Depois, teste parentização. Por exemplo, calcule
Você deverá incluir vários parênteses adicionais e s
Em caso de dúvida parentize Lembre-se da ordem de precedência de operações. O
você já sabia. Mas não custava lembrar!).
µ
8
aritméticas
Vamos ao primeiro problema deste guia. Você pode resolvê-lo sem usar um editor de textos! Bativar o interpretador Python (simplesmente digite: python <ENTER>) e escrever os comandos "dentro" do
Usando apenas o comando print, teste os operadores aritméticos usando números inteiros e * ** / // e % .
esta cópia de tela para entender como funciona:
Faça testes simples com números grandes e pequenos, positivos e negativos.
Descubra para que servem os operadores ** e % (ex.: 3**4 e 40 % 3).
este parentização. Por exemplo, calcule
�11 ∗ 137 � 512 � �1 � 144
4
parênteses adicionais e sua expressão deverá começar assim:(11 * ( ( 137 –
Em caso de dúvida parentize cada operação.
se da ordem de precedência de operações. O resultado de 5-2*2 é igual sabia. Mas não custava lembrar!).
µ guia de estudos python
André Koscianski
um editor de textos! Basta os comandos "dentro" do
Usando apenas o comando print, teste os operadores aritméticos usando números inteiros e
grandes e pequenos, positivos e negativos.
verá começar assim:
2*2 é igual a 1 e não 6. (Ok, ok,
2. Variáveis Assim como a linguagem Basic, Variáveis passam a existir assim que recebem um valor
Python utiliza tipagem dinâmica
Percebeu o que aconteceu com a variável “a” acima?
colateral negativo. Um programador mediano ou ruim pode escrever código extraodinariamente sujo.Código bom se aprende lendo.
Wirth (deveria ser obrigatório no curso de Fundamentos da Programaçãolinguagem C), S. Maguire (Writing Solid Code)da linguagem C++).
3. PRINT e números, parte II Tente este comando:
prompt python
>>>print 1, 2, 3; 4; 5
e em seguida, este:
prompt python
>>>print 1.2151E3 + 6.28E
Explique os resultados que aparecem na tela.
µ
9
Assim como a linguagem Basic, Python dispensa declaração de variáveis. Variáveis passam a existir assim que recebem um valor. Veja:
tipagem dinâmica. Isso permite certas diabruras impossíveis em outras linguagens
Percebeu o que aconteceu com a variável “a” acima? Essa liberdade toda pode ter um programador mediano ou ruim pode escrever código extraodinariamente sujo.
Código bom se aprende lendo. Uma pequena lista de bons autores / bons programadoreso curso de Fundamentos da Programação), Kernighan & Ritchie
(Writing Solid Code), D. Knuth, A. N. Tenembaum (Data Struct
e números, parte II
prompt python
1, 2, 3; 4; 5
prompt python
>>>print 1.2151E3 + 6.28E-1
Explique os resultados que aparecem na tela.
µ guia de estudos python
André Koscianski
is em outras linguagens:
Essa liberdade toda pode ter um efeito m programador mediano ou ruim pode escrever código extraodinariamente sujo.
/ bons programadores é: Niklaus , Kernighan & Ritchie (autores da (Data Structures), Stroustrup (pai
sugestão: aprenda + sobre isto na Wikipedia
4. IMPORT Python possui várias biblioteca As bibliotecas são carregada
memória carregando coisas do disco que não serão utilizadas. Semelhante às declarações #include
avise sobre as bibliotecas a serem utilizadas. Isto é feito com o comando import
Exemplo 1: Escreva o código a seguir no bloco de notas ou use o editor N
extensão .PY
teste.py import math print math.sqrt (9)
(sqrt = squared root) Exemplo 2:
prompt python
>>>import math >>>help (math)
Teste o código acima! Você deverá pressionar <ENTER> para rolar a lista
µ
10
bibliotecas embutidas e mais um milhão de outras na Internet
carregadas conforme você precisa. A lógica disso é clara: não perder tempo e memória carregando coisas do disco que não serão utilizadas.
#include usadas nas linguagens da família C, Python requer que você lhe avise sobre as bibliotecas a serem utilizadas.
import.
Escreva o código a seguir no bloco de notas ou use o editor Notepad++. Salve o arquivo com
print math.sqrt (9)
(sqrt = squared root)
prompt python
>>>import math
>>>help (math)
Você deverá pressionar <ENTER> para rolar a lista e <CTRL>+C para interromper
µ guia de estudos python
André Koscianski
embutidas e mais um milhão de outras na Internet!
conforme você precisa. A lógica disso é clara: não perder tempo e
usadas nas linguagens da família C, Python requer que você lhe
otepad++. Salve o arquivo com
interromper.
5. IF ELSE
Um exemplo explicará tudo rapidamente
teste-if.py if 1 > 2 : print "nunca" print "nunquinha"else : print "ok print "tem razao" print "Era isso por hoje."
No código acima existem blocos de
1) a presença de dois pontos sinalizando o início de um bloco2) o fato de todas as linhas do bloco serem
Dica: Nas opções do Notepad++ ou de seu editor predileto, configurebranco. Isso pode evitar muitas dores de cabeça.
µ
11
Um exemplo explicará tudo rapidamente
print "nunca" print "nunquinha"
ok" print "tem razao"
print "Era isso por hoje."
existem blocos de comandos. Observe: a presença de dois pontos sinalizando o início de um bloco o fato de todas as linhas do bloco serem igualmente identadas
Nas opções do Notepad++ ou de seu editor predileto, configure a troca de tabulações por espaços em
Isso pode evitar muitas dores de cabeça.
µ guia de estudos python
André Koscianski
6. Raízes de Equação Abra o artigo da Wikipedia em português sobre a linguagem FORTRAN. Adapte para Python o código FORTRAN que calcula os zeros de um polinômio de segundo grau,
(caso o artigo da Wikipedia tenha sido modificado, você não deverá ter dificuldade em encontrar a
fórmula em outro site). - E por que você não coloca a fórmula aqui, ora? - Por que se você não puder achar a fórmula via Google, e
7. Entrada de Dados Experimente a função input()
Adapte o programa anterior para que o usuário digite os coeficientes a,b,c.
µ
12
Abra o artigo da Wikipedia em português sobre a linguagem FORTRAN.
Adapte para Python o código FORTRAN que calcula os zeros de um polinômio de segundo grau,
� �� � ��� � �� � �
(caso o artigo da Wikipedia tenha sido modificado, você não deverá ter dificuldade em encontrar a
E por que você não coloca a fórmula aqui, ora?
Por que se você não puder achar a fórmula via Google, então está realmente em mau
input().
Adapte o programa anterior para que o usuário digite os coeficientes a,b,c.
µ guia de estudos python
André Koscianski
Adapte para Python o código FORTRAN que calcula os zeros de um polinômio de segundo grau,
(caso o artigo da Wikipedia tenha sido modificado, você não deverá ter dificuldade em encontrar a
ntão está realmente em maus lençóis...
8. Laços for Extremamente fácil:
teste-for.py for i in range(10) : print i ; print "Era isso por hoje."
Exercício:
9. Números aleatórios
Teste isto (e naturalmente experimente modificações para ver o que acontece)
teste-for.py import random print random.random( print int (100.0 *
Depois, crie um programa para imprimir 10 números aleatórios (usando, é claro, um FOR
você nem precise escrever o programa, se já houver entendido o código acima
10. Números aleatórios em um intervalo Escreva um programa para gerar 10 números aleatórios. Os números gerados devem estar dentro do
intervalo [25 ; 77]. Restrição: em seu programa você só pode invocar a função random 10 vezes. Dica: use o operador de resto de divisão.
µ
13
for i in range(10) : print i ;
print "Era isso por hoje."
cio: descubra as diferenças entre range (n), range(a,b)
(e naturalmente experimente modificações para ver o que acontece)
import random
print random.random()
100.0 * random.random())
programa para imprimir 10 números aleatórios (usando, é claro, um FORvocê nem precise escrever o programa, se já houver entendido o código acima).
Números aleatórios em um intervalo
programa para gerar 10 números aleatórios. Os números gerados devem estar dentro do
m seu programa você só pode invocar a função random 10 vezes.
resto de divisão.
µ guia de estudos python
André Koscianski
range(a,b) e xrange (n).
(e naturalmente experimente modificações para ver o que acontece) :
programa para imprimir 10 números aleatórios (usando, é claro, um FOR – talvez
programa para gerar 10 números aleatórios. Os números gerados devem estar dentro do
m seu programa você só pode invocar a função random 10 vezes.
11. Laço WHILE Aqui está:
teste-while.py i = 1 while i < 10 : print i; i = i + 1
Problema: efetue duas modificações no programa do problema anterior. 1) utilize um laço WHILE em lugar de um FOR 2) os números impressos devem ser todos pares (valem as restrições anteriores: random é chamada 10 vezes, o intervalo válido é [25 ; 77]) E veja também isto:
laco-infinito.py while 1 : print "nunca para!" ,
Ok? Como nas linguagens C e C++, um valor diferente de zero representa
µ
14
while i < 10 : print i; i = i + 1
Problema: efetue duas modificações no programa do problema anterior.
1) utilize um laço WHILE em lugar de um FOR
2) os números impressos devem ser todos pares
anteriores: random é chamada 10 vezes, o intervalo válido é [25 ; 77])
infinito.py
print "nunca para!" ,
Como nas linguagens C e C++, um valor diferente de zero representa true; logo, este laço é
µ guia de estudos python
André Koscianski
anteriores: random é chamada 10 vezes, o intervalo válido é [25 ; 77])
; logo, este laço é infinito.
12. Asteriscos KGB Os problemas a seguir usam laços aninhados e servem para exercitar programação. Deve ser feitos observando a seqüência
pode saltar para o final da lista.
Astericos KGB: regra geral
Em todos os problemas a seguir:
• devem ser usados laços
• a impressão na tela só pode ser feita Por exemplo, para imprimir dois asteriscos:
certo
for i in xrange(2) PRINT “*”
KGB , problema 1
Imprima 10 asteriscos em uma linha, assim:**********
KGB , problema 2
Imprima um bloco 10 X 10 de asteriscos no vídeo********** ********** ... **********
KGB , problema 2
Obtenha este desenho na tela* ** *** **** *****
µ
15
Os problemas a seguir usam laços aninhados e servem para exercitar programação.
Deve ser feitos observando a seqüência de dificuldade proposta. Em todo caso, se quiser se divertir,
Em todos os problemas a seguir:
devem ser usados laços ;
a impressão na tela só pode ser feita um caracter por vez .
Por exemplo, para imprimir dois asteriscos:
certo ERRADO
i in xrange(2) PRINT “*”
PRINT “**”
2 linhas de código
Imprima 10 asteriscos em uma linha, assim:
4 linhas de código
Imprima um bloco 10 X 10 de asteriscos no vídeo
4 linhas de código
Obtenha este desenho na tela
µ guia de estudos python
André Koscianski
Os problemas a seguir usam laços aninhados e servem para exercitar programação.
de dificuldade proposta. Em todo caso, se quiser se divertir,
2 linhas de código
4 linhas de código
4 linhas de código
KGB , problema 3
Obtenha este desenho na tela:* ** *** ... **********
KGB , problema 3
Obtenha este desenho na tela:+ *+ +*+ *+*+ +*+*+
...
KGB , problema 4
Obtenha este desenho na tela:* ** *** ** * ** *** **
... (repetir quantas vezes desejar)
KGB , problema 5
Obtenha este desenho na tela: * * * *** *** *** **************
(repetir horizontalmente 4 ou 5 vezes)
KGB , problema 4
Obtenha este desenho na tela: ***** ***** * * * * ***** ***** ****
µ
16
4 linhas de código
Obtenha este desenho na tela:
7 linhas de código
Obtenha este desenho na tela:
sem recursão, 9 linhas de código
Obtenha este desenho na tela:
(repetir quantas vezes desejar)
14 linhas de código
Obtenha este desenho na tela:
horizontalmente 4 ou 5 vezes)
Obtenha este desenho na tela:
***** ****
µ guia de estudos python
André Koscianski
4 linhas de código
linhas de código
linhas de código
14 linhas de código
13. FROM ... IMPORT Você deve lembrar disto
teste.py import math print math.sqrt
Ok. Agora compare cuidadosamente o código acima com este:
teste.py from math import sqrt print sqrt(9)
Percebeu? Usamos uma sintaxe um pouco diferente para
ir ainda mais longe e escrever assim:
teste.py from math import * print sqrt(9)
Problema: explique o que acontece nesta tela:
µ
17
FROM ... IMPORT
print math.sqrt(9) + math.sin(0.1)
compare cuidadosamente o código acima com este:
import sqrt
(9) + math.sin(0.1)
Percebeu? Usamos uma sintaxe um pouco diferente para simplificar as chamadas à sqrt(). Podemos ir ainda mais longe e escrever assim:
import *
(9) + sin(0.1)
: explique o que acontece nesta tela:
µ guia de estudos python
André Koscianski
simplificar as chamadas à sqrt(). Podemos
14. Sub-rotinas Podem ser parametrizadas ou não. A sintaxe é simplíssima.
no_parms.py def bonjour print "ok?" def a_plus (): print "bye.
print "vamos invocar as subbonjour () a_plus ()
E com parâmetros:
with_parms.py def bonjour ( for i in xrange(n): print "ok?" print "vamos bonjour (10)
15. Acentuação Python suporta Unicode. Para isso você deve incluir duas modificações em seu código.
no_parms.py # -*- coding: iso print "bla-bla" print u"áéíóú."
µ
18
Podem ser parametrizadas ou não.
(): print "ok?"
(): bye."
print "vamos invocar as sub-rotinas"
parms.py
def bonjour (n):
for i in xrange(n): print "ok?"
print "vamos invocar a sub-rotina" )
suporta Unicode. Para isso você deve incluir duas modificações em seu código.
coding: iso-8859-1 -*-
bla"
print u"áéíóú."
primeira linha
prefixo u
µ guia de estudos python
André Koscianski
suporta Unicode. Para isso você deve incluir duas modificações em seu código.
primeira linha
16. Laços FOR com Rode este exemplo.
forlista.py for x in [2,4, print x,
Fácil? Listas são estruturas de dados muito úteis. Sua manipulação em Python é bastante simples.
µ
19
listas
for x in [2,4,-3,-1,103]: print x,
Listas são estruturas de dados muito úteis. Sua manipulação em Python é bastante simples.
µ guia de estudos python
André Koscianski
Listas são estruturas de dados muito úteis. Sua manipulação em Python é bastante simples.
Parte dois: PYGAME básico
Do início das atividades de programação até aqui, foram apenas
E agora já vamos iniciar as explicações sobre a biblioteca de jogos! Conforme prometido, o guia é bastante objetivo. Mas, antes de continuar, um conselho dentro de uma pergunta: - Você resolveu os problemas propostos? Para continuar:
Você precisa da biblioteca PYGAME instalada em sua máquina. Para instalá-la:
1. faça a transferência (2. execute o .EXE
A linguagem Python possui todo um mecanismo para gerir bibliotecas e sua instalação.
não seja tratado neste guia.
µ
20
Parte dois: PYGAME básico
Do início das atividades de programação até aqui, foram apenas 10 páginasagora já vamos iniciar as explicações sobre a biblioteca de jogos!
Conforme prometido, o guia é bastante objetivo.
ntes de continuar, um conselho dentro de uma pergunta:
Você resolveu os problemas propostos?
da biblioteca PYGAME instalada em sua máquina.
faça a transferência (download)
A linguagem Python possui todo um mecanismo para gerir bibliotecas e sua instalação.
µ guia de estudos python
André Koscianski
10 páginas!.
A linguagem Python possui todo um mecanismo para gerir bibliotecas e sua instalação. Talvez isto
17. FROM ... IMPORT parte II Digite e salve estes dois programas no mesmo diretório.
minhalib.py def minhasub print "Biblioteca presente"
meuprog.py import minhalib minhalib.minhasubrotina ("teste")
Fácil? Como isto pode ser usado?
µ
21
IMPORT parte II
Digite e salve estes dois programas no mesmo diretório.
minhasubrotina (s): print "Biblioteca presente", s
import minhalib
minhalib.minhasubrotina ("teste")
Exemplo: era uma vez dois amigos, Ana e Carlos. Ana escreveu um módulo Python, paracolorido na tela. Ela o gravou com Carlos copiou o código do placar e o colou jogo que fez. Ana preferiu usar “import placar” Um dia, Ana percebeu um erro no cálculo do placar.corrigiu o erro em 10 minutos, no módulo placar.py. Automaticamente, todos os jogos ficaram corrigidos. Carlos gastou um dia inteiro procurando ecódigo do placar dentro de cada jogo.
µ guia de estudos python
André Koscianski
Exemplo: era uma vez dois amigos, Ana e Carlos.
Python, para mostra um placar . Ela o gravou como “placar.PY”.
e o colou dentro de cada Ana preferiu usar “import placar”
erro no cálculo do placar. Ela 0 minutos, no módulo placar.py.
odos os jogos que utilizavam import
procurando e corrigindo o dentro de cada jogo.
18. Mostrar objeto na tela Desenhe uma bola usando o PaintBrush. No mesmo diretório, salve o programa a seguir e execute
bola0.py
import pygame pygame.init () tela = pygame.display.set_mode ((320,240))bola = pygame.image.load ("bobolaret = bola.get_rect ()tela.blit (bola, bolaret)pygame.display.flip()a = raw_input ("Voila")
Na próxima página vamos analisar cada linha do código.
µ
22
Mostrar objeto na tela
Desenhe uma bola usando o PaintBrush. Grave como BMP.
No mesmo diretório, salve o programa a seguir e execute-o.
import pygame
pygame.init ()
tela = pygame.display.set_mode ((320,240)) bola = pygame.image.load ("bola.bmp") bolaret = bola.get_rect () tela.blit (bola, bolaret) pygame.display.flip() a = raw_input ("Voila")
vamos analisar cada linha do código.
µ guia de estudos python
André Koscianski
#
Linha
0 import pygame
1 pygame.init ()
2 tela = pygame.display. set_mode ((320,240))
3 bola = pygame.image.load ("bola.bmp")
4 bolaret = bola.get_rect ()
5 tela.blit (bola, bolaret)
6 pygame.display.flip ()
7 a = raw_input ("Voila")
µ
23
Significado
Importa toda a biblioteca pygame. Inicializa todos os componentes da biblioteca, deixando“pronta para uso”. Pode-se também inicializar apenas individualmente. É mais rápido quando se sabe que apenas um pedaço dela será usado (ex.: um programa que não tem som, não precisa inicializar essa parte!).
tela = pygame.display. set_mode ((320,240))
Cria uma janela gráfica com as dimensões especificadas. Tais dimensões são passadas à subtupla – um conjunto de valores separados por vírgulas e circundados por parênteses. Entendeu? Esta chamada de sub-rotina usou apenas UM parâmetro, que é a tupla (320, 240).
= pygame.image.load ("bola.bmp")
A variável bola é um pouco mais que uma variável comum, como uma variável inteira que se pode somar A variável bola é um objeto. Um objeto pode conter variáveis e subNeste caso, a variável bola contem a imagem feita no PantBrush.
bolaret = bola.get_rect () A variável bolaret guarda o tamanho (comprimento e altura) da imagem contida no objeto bola.
tela.blit (bola, bolaret) Veja novamente a linha 2: o objeto tela lá obtido é usado aqui. A sub-rotina blit() “carimba” a imagem da bola na tela.
Isto é um truque: na verdade existem DUAS telas, uma que você vê e outra que fica escondida. Todos os desenhos são feitos na tela A sub-rotina flip() troca essas telas. O resultado éusuário terá a impressão de que o desenho foi feito instantâneamente.
a = raw_input ("Voila") Sem esta linha o programa terminaria imediatamente.Você veria apenas a tela piscar e.. fim. a = input() não funciona (experimente testar), então foi usado raw_input().
µ guia de estudos python
André Koscianski
Significado
os os componentes da biblioteca, deixando-a
apenas pedaços da biblioteca,
É mais rápido quando se sabe que apenas um pedaço dela será usado (ex.: um programa que não tem som, não precisa
m as dimensões especificadas.
Tais dimensões são passadas à sub-rotina por meio de uma um conjunto de valores separados por vírgulas e
rotina usou apenas UM .
m pouco mais que uma variável comum, uma variável inteira que se pode somar A=B+C.
sub-rotinas. Neste caso, a variável bola contem a imagem feita no
o tamanho (comprimento e o objeto bola.
: o objeto tela lá obtido é usado
“carimba” a imagem da bola na tela. verdade existem DUAS telas, uma que
Todos os desenhos são feitos na tela escondida.
rotina flip() troca essas telas. O resultado é que o a impressão de que o desenho foi feito
rminaria imediatamente. fim.
a = input() não funciona (experimente testar), então foi
19. Mover objeto Teste este programa. ATENÇÃO: p
bola1.py
import pygame pygame.init () size speed = [2, 2] screen = pygame.display.set_mode (size)ball = pygame.image.load ("ball.bmp")ballrect = ball.get_rect ()screen.blit (ball, ballrect)pygame.display.flip() for i in xrange(100): ballrect = ballrect.move (speed) print ballrect screen.fill ((0, 0, 0)) screen.blit (ball, ballrect) pygame.display.flip
pygame.time.delay
A seta preta (1) mostra atribuições em seqüência:
• “size” recebe a tupla
• width recebe 320 e height recebe A seta branca (2) mostra a criação de uma Na seta verde (3) mostra as coordenadas contidas em ballrect são movidas. Na seta vermelha (4) a tela é toda preenchi Na seta laranja (5), pygame “manda” o programa ficar paralisado durante 10 mili
1)
2)
3)
4)
5)
µ
24
ATENÇÃO: para terminá-lo você precisará fechar a janela DOS.
import pygame
pygame.init ()
= width, height = 320, 240
speed = [2, 2]
screen = pygame.display.set_mode (size) ball = pygame.image.load ("ball.bmp") ballrect = ball.get_rect () screen.blit (ball, ballrect) pygame.display.flip()
for i in xrange(100):
ballrect = ballrect.move (speed)
print ballrect
screen.fill ((0, 0, 0)) screen.blit (ball, ballrect) pygame.display.flip () pygame.time.delay (10)
mostra atribuições em seqüência:
“size” recebe a tupla (320, 240)
e height recebe 240.
mostra a criação de uma lista com 2 elementos.
as coordenadas contidas em ballrect são movidas.
a tela é toda preenchida (to fill, em inglês) com cor preta (RGB = 0,0,0).
, pygame “manda” o programa ficar paralisado durante 10 mili
µ guia de estudos python
André Koscianski
fechar a janela DOS.
da (to fill, em inglês) com cor preta (RGB = 0,0,0).
, pygame “manda” o programa ficar paralisado durante 10 mili-segundos.
20. Figuras com Transparências Você deve ter observado que a figura da bola tem uma estranha borda branca:
Isso acontece pois a figura é na verdade um quadrado
Para conseguir esse efeito, avise a pygame que uma das cores da figura deve ser interpretada como
“buracos”. Ou seja, essa cor representa Modifique o programa anterior assim:
bola2.py
... colorkey = ball.get_at ((0,0))ball.set_colorkey (colorkey, pygame.RLEACCEL) for i in xrange(100): ...
Na seta vermelha, lemos a cor do pixel superior esquerdo da figura (coordenadas 0,0).Na seta laranja, avisamos ao objeto ball que essa cor deve ser tratada como transparente.
µ
25
Figuras com Transparências
Você deve ter observado que a figura da bola tem uma estranha borda branca:
.
Isso acontece pois a figura é na verdade um quadrado. Mas seria bem melhor algo assim:
Para conseguir esse efeito, avise a pygame que uma das cores da figura deve ser interpretada como “buracos”. Ou seja, essa cor representará espaços transparentes.
Modifique o programa anterior assim:
colorkey = ball.get_at ((0,0)) ball.set_colorkey (colorkey, pygame.RLEACCEL)
for i in xrange(100):
cor do pixel superior esquerdo da figura (coordenadas 0,0).seta laranja, avisamos ao objeto ball que essa cor deve ser tratada como transparente.
µ guia de estudos python
André Koscianski
Você deve ter observado que a figura da bola tem uma estranha borda branca:
. Mas seria bem melhor algo assim:
Para conseguir esse efeito, avise a pygame que uma das cores da figura deve ser interpretada como
cor do pixel superior esquerdo da figura (coordenadas 0,0). seta laranja, avisamos ao objeto ball que essa cor deve ser tratada como transparente.
21. Problema: iô-iô Modifique o programa anterior de forma que
descendo na tela. Você precisará usar um comando IF e também
22. Problema: dois Modifique o programa iô-iô
Você deverá criar uma segunda bola com o PaintBrush. Precisará tambola2, que receberá a figura lida do disco
ball2 = pygame.image.load ("ballballrect2 = ball.get_rect ()
Você também precisará modificar
mesmo lugar da tela (uma sobre a outra).
µ
26
iô
anterior de forma que a bola faça um movimento de
um comando IF e também precisará mudar o conteúdo da variável
dois iô-iôs
para que existam duas bolas de cores diferentes pulando na tela.
Você deverá criar uma segunda bola com o PaintBrush. Precisará também de uma segunda variável, bola2, que receberá a figura lida do disco
= pygame.image.load ("ball2.bmp") ballrect2 = ball.get_rect ()
modificar a variável ballrect2, para evitar que as duas bolas apareçam no da tela (uma sobre a outra).
µ guia de estudos python
André Koscianski
faça um movimento de iô-iô, subindo e
mudar o conteúdo da variável speed.
para que existam duas bolas de cores diferentes pulando na tela.
bém de uma segunda variável,
, para evitar que as duas bolas apareçam no
23. MRUV, Movimento retilíneo uniformemente acelerado Vamos modificar o primeiro Quando a bola se move na tela, possui uma certa velocidade, certo? A cada vez que o laço é executado, a imagem da bola
pixels mais longe. Quanto maior o número de pixels, maior a velocidade. Vamos então mudar a velocidade
acontece com uma bola de verdade. Como? A melhor maneira é aplicar Física de verdade. Comece lembrando desta fórmula:
A variável � da fórmula corresponde, no programa, à variável À medida em que o tempo passa (= à cada
deverá ser re-calculada usando essa fórmula. Outra forma de trabalhar – e neste caso mais fácil
Fisicamente é a mesma idéia, mas agora não dependemos mais de Para aplicar (2), observe que
chamada à pygame.time.delay(). Para implementar o programa, você deve criar uma
“velocidadeantiga”. Deve relacionar essas variáveis com a fórmula (2). Finalmente, assim que a bola toca o chão, você Isso é muito fácil; basta mudar o sinal da velocidade:
Dica: a aceleração deve ser fixa e seria bom você começar com um valor baixo programa “rodar” corretamente (sem travar), você aumentará esse número até achar o valor certo.
µ
27
MRUV, Movimento retilíneo uniformemente acelerado
primeiro programa do iô-iô, para dar um toque de realismo físico.
Quando a bola se move na tela, possui uma certa velocidade, certo? A cada vez que o laço é executado, a imagem da bola é apagada e depois surge novamente alguns
ixels mais longe. Quanto maior o número de pixels, maior a velocidade.
Vamos então mudar a velocidade e acelerar a bola, fazendo ela cair cada vez mais rápido acontece com uma bola de verdade.
A melhor maneira é aplicar Física de verdade. Comece lembrando desta fórmula:
� � �� � �� (1)
da fórmula corresponde, no programa, à variável speed.
À medida em que o tempo passa (= à cada iteração do laço principal do programacalculada usando essa fórmula.
e neste caso mais fácil – é assim:
����� � ������� � � � (2)
Fisicamente é a mesma idéia, mas agora não dependemos mais de ��. Percebeu?
Para aplicar (2), observe que Δ� corresponde à uma iteração do laço. É o valor que você usou na
Para implementar o programa, você deve criar uma variável “velocidadenova” e uma “velocidadeantiga”. Deve relacionar essas variáveis com a fórmula (2).
Finalmente, assim que a bola toca o chão, você pode fazê-la pular! mudar o sinal da velocidade:
����� � �������� (3)
aceleração deve ser fixa e seria bom você começar com um valor baixo –programa “rodar” corretamente (sem travar), você aumentará esse número até achar o valor certo.
µ guia de estudos python
André Koscianski
MRUV, Movimento retilíneo uniformemente acelerado
iô, para dar um toque de realismo físico.
é apagada e depois surge novamente alguns
, fazendo ela cair cada vez mais rápido – como
A melhor maneira é aplicar Física de verdade. Comece lembrando desta fórmula:
principal do programa), a velocidade
. Percebeu?
corresponde à uma iteração do laço. É o valor que você usou na
variável “velocidadenova” e uma
– algo como 0.001. Se o programa “rodar” corretamente (sem travar), você aumentará esse número até achar o valor certo.
24. MRUV com atrito Continuando o programa anter Isso acontece porque ela perde energia. Isso acontece de várias formas.
• parte da energia é perdida pela fricção entre a bola e o ar
• outra parte é gasta criando barulho
• também há perdas fazendo o chão vibrar
• e é gasta uma parcela de Incluir todas as equações de Mecânica envolvidas seria um trabalho insano. Mas há uma saída simples, tipicamente usada por engenheiros. Como não é possível medir todos os efeitos acima, arredondamos tudo dentro de um coeficiente. É
um número um pouco mágico, mas que se for bem calibrado vai nos poupar muito trabalho. Faça o seguinte: quando a bo
subtraia um pouco dessa velocidade. Tecnicamente, o que estamos fazendo é dizer que a bola perdeu momento (ou energia cinética).
A fórmula a ser aplicada quando a bola toca o chão é:
Entendeu? Uma parcela da velocidade “evapora” = energia perdida. Modifique o programa usando essa fórmula. Atenção: a fórmula está um pouco complicada em excesso e seria muito bom simplificá
menos cálculos significa obter um programa que roda mais depressa, algo que é muito importante e muito valorizado por todo programador de jogos. Com mais CPU livre é possível enriquecer o jogo.
Para simplificar a fórmula acima, isole a variável
A fórmula mais simples possível contem apenas uma operação de multiplicação.
µ
28
com atrito
Continuando o programa anterior, você sabe que uma bola de verdade pula cada vez mais baixo.
Isso acontece porque ela perde energia. Isso acontece de várias formas.
arte da energia é perdida pela fricção entre a bola e o ar;
utra parte é gasta criando barulho ( foi preciso gastar energia para criar uma onda de som);
fazendo o chão vibrar;
gasta uma parcela de energia fazendo a bola se deformar.
Incluir todas as equações de Mecânica envolvidas seria um trabalho insano.
imples, tipicamente usada por engenheiros.
Como não é possível medir todos os efeitos acima, arredondamos tudo dentro de um coeficiente. É um número um pouco mágico, mas que se for bem calibrado vai nos poupar muito trabalho.
Faça o seguinte: quando a bola toca o chão, mude o sinal da velocidade mas ao mesmo tempo subtraia um pouco dessa velocidade. Tecnicamente, o que estamos fazendo é dizer que a bola perdeu
A fórmula a ser aplicada quando a bola toca o chão é:
����� � � �������� � ��������
Entendeu? Uma parcela da velocidade “evapora” = energia perdida.
Modifique o programa usando essa fórmula.
: a fórmula está um pouco complicada em excesso e seria muito bom simplificásignifica obter um programa que roda mais depressa, algo que é muito importante e muito
valorizado por todo programador de jogos. Com mais CPU livre é possível enriquecer o jogo.
Para simplificar a fórmula acima, isole a variável ������� (isto é, coloque-a “em evidência”).
A fórmula mais simples possível contem apenas uma operação de multiplicação.
µ guia de estudos python
André Koscianski
ior, você sabe que uma bola de verdade pula cada vez mais baixo.
( foi preciso gastar energia para criar uma onda de som);
Como não é possível medir todos os efeitos acima, arredondamos tudo dentro de um coeficiente. É um número um pouco mágico, mas que se for bem calibrado vai nos poupar muito trabalho.
la toca o chão, mude o sinal da velocidade mas ao mesmo tempo subtraia um pouco dessa velocidade. Tecnicamente, o que estamos fazendo é dizer que a bola perdeu
: a fórmula está um pouco complicada em excesso e seria muito bom simplificá-la. Usar significa obter um programa que roda mais depressa, algo que é muito importante e muito
valorizado por todo programador de jogos. Com mais CPU livre é possível enriquecer o jogo.
a “em evidência”).
A fórmula mais simples possível contem apenas uma operação de multiplicação.
25. Controle do teclado Até agora usamos apenas as sub
congelado até que o usuário use a tecla <ENTER>. Evidentemente isto não serve para controlar um jogo: a entrada de dados deve acontecer
funcionamento do mesmo, sem paralizá
As setas laranjas são automaticamente
cliques de mouse e os coloca na fila do aplicativo “dono” da tela que recebeu os dados. As setas vermelhas são gerenciada As setas verdes mostram um caminho alternativo também oferecido pelo S.O.;
e imediatamente o estado pressionado/não pressionado de uma tecla qualquer.vermelhas) mostram o que aconteceu no teclado.
O estado passado da entrada Se quisermos o estado atual
para fazer isso. Essa função deve pedir ao SO (seja ele Windows, Linux, MacOS...) para examinar o teclado. Vamos começar pela lógica das setas vermelhas e ler o estado passado do teclado. Veja o programa
na próxima página.
caminho
µ
29
Controle do teclado
Até agora usamos apenas as sub-rotinas input() e raw_input(). Essas rotinasa tecla <ENTER>.
Evidentemente isto não serve para controlar um jogo: a entrada de dados deve acontecer funcionamento do mesmo, sem paralizá-lo.
automaticamente gerenciadas pelo Sistema Operacional.cliques de mouse e os coloca na fila do aplicativo “dono” da tela que recebeu os dados.
As setas vermelhas são gerenciadas pelos programas aplicativos.
um caminho alternativo também oferecido pelo S.O.; o estado pressionado/não pressionado de uma tecla qualquer. As filas de eventos (setas
e aconteceu no passado recente.As linhas verdes acessam o estado
da entrada é suficiente na maioria das vezes – mesmo em jogos.
atual da entrada, em Python, precisamos de alguma função de bibliotecpara fazer isso. Essa função deve pedir ao SO (seja ele Windows, Linux, MacOS...) para examinar o teclado.
Vamos começar pela lógica das setas vermelhas e ler o estado passado do teclado. Veja o programa
Sistema
Operacional
fila de
eventos
fila de
eventos
fila de
eventos
Leitura direta (sem
espera na fila)
caminho-1
caminho-2
µ guia de estudos python
André Koscianski
Essas rotinas deixam o programa
Evidentemente isto não serve para controlar um jogo: a entrada de dados deve acontecer durante o
gerenciadas pelo Sistema Operacional. Ele recebe teclas e cliques de mouse e os coloca na fila do aplicativo “dono” da tela que recebeu os dados.
um caminho alternativo também oferecido pelo S.O.; ele permite ler direta As filas de eventos (setas
As linhas verdes acessam o estado atual do
mesmo em jogos.
alguma função de biblioteca para fazer isso. Essa função deve pedir ao SO (seja ele Windows, Linux, MacOS...) para examinar o teclado.
Vamos começar pela lógica das setas vermelhas e ler o estado passado do teclado. Veja o programa
Word
Excel
prog.
Python
Leitura direta (sem
espera na fila)al
Digite e teste:
eventos_teclado.py
import pygamefrom pygame.locals import * pygame.init()screen = pygame.display.set_mode((640, 480))pygame.display.set_caption('Pygame Caption')pygame.mouse.set_visible(0) done = Falsewhile not done: for event in pygame.event.get(): if (event.type == KEYUP) or (event.type == KEYDOWN): print event if (event.key == K_ESCAPE):
Aqui está um exemplo de saída.
A seta verde mostra como escrever uma linha de código muito longa em Python
caracter barra invertida \ . A seta vermelha mostra um laço
rotina que lê a fila de eventos do programa
... fila_de_ for event in ...
1 Note como esta frase contem “lista” e “fila”
possíveis. Uma fila não permite inserção/remoção de elementos no meio
µ
30
.py
import pygame from pygame.locals import *
pygame.init() screen = pygame.display.set_mode((640, 480)) pygame.display.set_caption('Pygame Caption') pygame.mouse.set_visible(0)
done = False while not done:
for event in pygame.event.get(): if (event.type == KEYUP) or \
(event.type == KEYDOWN): print event if (event.key == K_ESCAPE):
done = True
Aqui está um exemplo de saída.
escrever uma linha de código muito longa em Python
um laço for ; esse laço itera sobre uma lista. Essa lista éfila de eventos do programa1. Você também poderia programar esse laço assim:
fila_de_eventos = pygame.event.get() for event in fila_de_eventos:
ote como esta frase contem “lista” e “fila”. São estruturas de dados diferentes quanto às operações
permite inserção/remoção de elementos no meio.
µ guia de estudos python
André Koscianski
escrever uma linha de código muito longa em Python: quebrando-a com o
. Essa lista é retornada pela m poderia programar esse laço assim:
. São estruturas de dados diferentes quanto às operações
26. Problema: teste da fila de eventos. A biblioteca pygame possui uma função
instantes. Lembrou? (Ela já foi usada dentro deste guia). Use essa rotina no programa de leitura do teclado e descubra se, enquanto o programa está
paralizado, a fila de eventos ainda é alimentada pelo S.O.
27. Estado atual do teclado Agora vamos usar uma função para ler o estado atual do teclado, sem consultar a fila de eventos.
Essa função será bastante útil em jogos. Veja:
estado_teclado.py
import pygamefrom pygame.locals import * pygame.init() screen = pygame.display.set_mode((100,100)) acc = 0 while (acc < L = pygame.key.get_pressed() pygame.event.get() if L[K_SPACE]: acc += 1 else: acc = 0 print acc ,
pygame.time.delay (5)
Na seta vermelha (1), obtemos de pygame uma lista
representa o estado pressionado/livre de uma tecla.definidas: K_SPACE, K_a , K_b ...
Na seta vermelha(2), chamamos uma função de pygame; sem essa chamada este programa não
funciona. O motivo? Hmm... Na seta laranja(3) verificamos se o elemento da lista L correspondente à barra de espaço contem
True ou False.
1)
2)
3)
µ
31
Problema: teste da fila de eventos.
possui uma função que paraliza a execução do programa durante alguns
Lembrou? (Ela já foi usada dentro deste guia).
Use essa rotina no programa de leitura do teclado e descubra se, enquanto o programa está paralizado, a fila de eventos ainda é alimentada pelo S.O.
Estado atual do teclado
função para ler o estado atual do teclado, sem consultar a fila de eventos. Essa função será bastante útil em jogos.
estado_teclado.py
import pygame from pygame.locals import *
pygame.init()
screen = pygame.display.set_mode((100,100))
while (acc < 50): L = pygame.key.get_pressed()
pygame.event.get()
if L[K_SPACE]: #barra de espaco pressionada?acc += 1
acc = 0
print acc , pygame.time.delay (5)
Na seta vermelha (1), obtemos de pygame uma lista de valores booleanos. Cada elemento drepresenta o estado pressionado/livre de uma tecla. A lista pode ser indexada usando constantes pré
chamamos uma função de pygame; sem essa chamada este programa não
Na seta laranja(3) verificamos se o elemento da lista L correspondente à barra de espaço contem
µ guia de estudos python
André Koscianski
que paraliza a execução do programa durante alguns
Use essa rotina no programa de leitura do teclado e descubra se, enquanto o programa está
função para ler o estado atual do teclado, sem consultar a fila de eventos.
spaco pressionada?
. Cada elemento dessa lista A lista pode ser indexada usando constantes pré-
chamamos uma função de pygame; sem essa chamada este programa não
Na seta laranja(3) verificamos se o elemento da lista L correspondente à barra de espaço contem
28. Problema: iô-iô com controle Volte aos problemas envolvendo uma bola pulando (ou iô Modifique o programa para que a bola seja
<ENTER>.
29. Problema: iô-iô com super Volte ao problema anterior, do “iô Descubra os códigos para as teclas de seta à esquerda, direita, cima e baixo. Modifique o programa para movimentar a bola na direção desejada, enquanto a tecla
correspondente estiver pressionada. Ao soltar a tecla, a bola para de se mover. Dica: todo o controle passa pela variável
µ
32
iô com controle
as envolvendo uma bola pulando (ou iô-iô...).
Modifique o programa para que a bola seja capturada/liberada quando for pressionada a tecla
iô com super-controle
Volte ao problema anterior, do “iô-iô com controle”.
códigos para as teclas de seta à esquerda, direita, cima e baixo.
Modifique o programa para movimentar a bola na direção desejada, enquanto a tecla correspondente estiver pressionada.
Ao soltar a tecla, a bola para de se mover.
sa pela variável speed.
µ guia de estudos python
André Koscianski
liberada quando for pressionada a tecla
Modifique o programa para movimentar a bola na direção desejada, enquanto a tecla
30. Canhão anti-aéreo (1) Desenhe um projétil no PaintBrush. Escreva um programa que dispara projéteis verticalmente, de baixo para cima,
pressiona a barra de espaço. Apenas um projétil deve aparecer na tela. Ele surge ao pressionar a tecla, sobe até o topo da tela e
desaparece. A tecla <ESC> deve encerrar o programa. (2) Inclua no seu programa um objeto (um avião) que cruza a tela da esquerda para a direita. Ao
o lado direito, ele simplesmente reaparece do lado esquerdo. (3) Crie um teste de colisão. Se o projétil ficar muito próximo do avião, você ganha um ponto. Para isso, use esta fórmula:
! � e este código: IF d < dmin: pontos += 1 (4) Crie um desenho de uma explosão e mostre (5) Altere o cálculo de pontuação: quanto mais próximo o tiro passar do avião, mais pontos você ganha. (6) Calibre suas coordenadas para (7) Coloque dois aviões na tela, voando em direções (velocidades) opostas e altitudes diferentes. (8) Coloque vários aviões na tela. Use vetores contendo posição e velocidade dos aviões.Por exemplo, a velocidade e posição do
velocidadeX[2] velocidadeY[2] posX[2] posY[2]
µ
33
aéreo
Desenhe um projétil no PaintBrush.
Escreva um programa que dispara projéteis verticalmente, de baixo para cima,
Apenas um projétil deve aparecer na tela. Ele surge ao pressionar a tecla, sobe até o topo da tela e
A tecla <ESC> deve encerrar o programa.
Inclua no seu programa um objeto (um avião) que cruza a tela da esquerda para a direita. Ao o lado direito, ele simplesmente reaparece do lado esquerdo.
Crie um teste de colisão. Se o projétil ficar muito próximo do avião, você ganha um ponto.
" ������ � �#�$��� � %����� � %#�$���
pontos += 1
Crie um desenho de uma explosão e mostre-a quando o avião for acertado.
Altere o cálculo de pontuação: quanto mais próximo o tiro passar do avião, mais pontos você ganha.
Calibre suas coordenadas para atingir o centro do avião.
aviões na tela, voando em direções (velocidades) opostas e altitudes diferentes.
na tela. Use vetores contendo posição e velocidade dos aviões.Por exemplo, a velocidade e posição do avião 2 estarão guardados em:
velocidadeX[2] velocidadeY[2] posX[2] posY[2]
µ guia de estudos python
André Koscianski
Escreva um programa que dispara projéteis verticalmente, de baixo para cima, quando o jogador
Apenas um projétil deve aparecer na tela. Ele surge ao pressionar a tecla, sobe até o topo da tela e
Inclua no seu programa um objeto (um avião) que cruza a tela da esquerda para a direita. Ao “vazar”
Crie um teste de colisão. Se o projétil ficar muito próximo do avião, você ganha um ponto.
Altere o cálculo de pontuação: quanto mais próximo o tiro passar do avião, mais pontos você ganha.
aviões na tela, voando em direções (velocidades) opostas e altitudes diferentes.
na tela. Use vetores contendo posição e velocidade dos aviões.
31. Escrevendo na tela gráfica
Depois de implementar o último programa, n Agora falta mostrar um placar no vídeo. O programa a seguir mostra como fazer isso.
teste.py import pygame pygame.init () screen = pygame.display.set_mode ((200,100)) #cor de fundoscreen.fill ((0, 0, 255)) #fontes funcionando?if pygame.font: #escolha fonte default font= pygame.font.Font(None, 22) #crie o texto text=font.render("ola mundo!", 1, (255, 250, 0)) #obtenha o retangulo que contem o texto textpos = text.get_rect() #carimbe o texto na tela screen.blit(text, (50,50)) pygame.display.flip() #aguarde o usuario x = raw_input()
Problema: a partir deste exemplo, crie um placar para seu jogo de canhão anti
µ
34
Escrevendo na tela gráfica
Depois de implementar o último programa, nós já temos um jogo completo!
Agora falta mostrar um placar no vídeo.
mostra como fazer isso.
import pygame
pygame.init ()
screen = pygame.display.set_mode ((200,100))
#cor de fundo screen.fill ((0, 0, 255))
#fontes funcionando? if pygame.font:
#escolha fonte default font= pygame.font.Font(None, 22)
#crie o texto text=font.render("ola mundo!", 1, (255, 250, 0))
#obtenha o retangulo que contem o texto textpos = text.get_rect()
#carimbe o texto na tela screen.blit(text, (50,50))
pygame.display.flip()
#aguarde o usuario digitar algo x = raw_input()
: a partir deste exemplo, crie um placar para seu jogo de canhão anti
µ guia de estudos python
André Koscianski
text=font.render("ola mundo!", 1, (255, 250, 0))
: a partir deste exemplo, crie um placar para seu jogo de canhão anti-aéreo.
Parte três: Orientação a Objetos As partes um e dois deste guia apresentaram uma visão geral sobre Python e Se você resolveu todos os problemas propostos, já é capaz de programar desde jogos simples, como
FORCA ou JOGO da VELHA, até alguns com figuras em movimento, como BREAKOUT ou ALIENS INVASION. Vale um lembrete importante. Este guia não tem o objetivo de ensinar todos os detalhes. Excelente. A próxima parte do guia descreve em linhas gerais o uso de Orientação a Objetos em Python. Você
cetamente precisará conhecer esses recursos para poder avançar em Programas grandes devem ser divididos em pedaços. Dividi
organizá-los. No caso de jogos, é natural que cada personagem do jogo (avião, robo, tiro, bichoprogramado dentro de um objeto.
µ
35
ção a Objetos básica em Python
As partes um e dois deste guia apresentaram uma visão geral sobre Python e
Se você resolveu todos os problemas propostos, já é capaz de programar desde jogos simples, como FORCA ou JOGO da VELHA, até alguns com figuras em movimento, como BREAKOUT ou ALIENS INVASION.
Vale um lembrete importante.
objetivo de ensinar todos os detalhes. O guia tem o objetivo de guiar
A próxima parte do guia descreve em linhas gerais o uso de Orientação a Objetos em Python. Você cetamente precisará conhecer esses recursos para poder avançar em direção a programas mais complexos.
Programas grandes devem ser divididos em pedaços. Dividi-los em objetos é uma ótima forma de los. No caso de jogos, é natural que cada personagem do jogo (avião, robo, tiro, bicho
µ guia de estudos python
André Koscianski
As partes um e dois deste guia apresentaram uma visão geral sobre Python e Pygame.
Se você resolveu todos os problemas propostos, já é capaz de programar desde jogos simples, como FORCA ou JOGO da VELHA, até alguns com figuras em movimento, como BREAKOUT ou ALIENS INVASION.
O guia tem o objetivo de guiar. Entende?
A próxima parte do guia descreve em linhas gerais o uso de Orientação a Objetos em Python. Você direção a programas mais complexos.
los em objetos é uma ótima forma de los. No caso de jogos, é natural que cada personagem do jogo (avião, robo, tiro, bicho-papão) seja
32. Rudimentos de OO em Python
Vamos começar analisando este trecho de código:
monstro1.py class Monstro(): def diga_alo(self): print "alo" jorgival = Monstro() jorgival.diga_alo()
Aqui é criada uma classe de monstros, que sabem escrever “alo” no vídeo. Em seguida é criado um monstro chamado jorgival e, finalmente, jorgival diz “alo”. Uma classe é como uma forma de bolo: a partir dela você pode Uma classe contem funções.Objetos fabricados com a classe podem usar (chamar) essas funções.
33. Rudimentos de OO em Python , parte II
Vamos ampliar um pouco o programa anterior.
monstro2.py class Monstro(): peso = 100 def diga_alo(self): print "alo" def diga_peso(self): print "Eu peso ", self.peso, " toneladas." jorgival = Monstro()anaiaia = Monstro() jorgival.peso = 277 jorgival.diga_peso()anaiaia .diga_peso()
Agora um objeto monstro contem duas rotinas e uma Cada objeto possui suas próprias variáveis
como mostra o código, o peso de cada monstro pode ser diferente.
µ
36
Rudimentos de OO em Python , parte I
analisando este trecho de código:
onstro(): # de praxe letra maiuscula
def diga_alo(self): print "alo"
onstro()
jorgival.diga_alo()
Aqui é criada uma classe de monstros, que sabem escrever “alo” no vídeo.
m monstro chamado jorgival e, finalmente, jorgival diz “alo”.
Uma classe é como uma forma de bolo: a partir dela você pode fabricar objetoscontem funções.
Objetos fabricados com a classe podem usar (chamar) essas funções.
Rudimentos de OO em Python , parte II
Vamos ampliar um pouco o programa anterior.
onstro():
peso = 100
def diga_alo(self): print "alo"
def diga_peso(self): print "Eu peso ", self.peso, " toneladas."
onstro() onstro()
jorgival.peso = 277
jorgival.diga_peso() .diga_peso()
Agora um objeto monstro contem duas rotinas e uma variável.
Cada objeto possui suas próprias variáveis: neste exemplo, cada monstro tem seu próprio peso.como mostra o código, o peso de cada monstro pode ser diferente.
µ guia de estudos python
André Koscianski
# de praxe letra maiuscula
m monstro chamado jorgival e, finalmente, jorgival diz “alo”.
fabricar objetos.
print "Eu peso ", self.peso, " toneladas."
este exemplo, cada monstro tem seu próprio peso. E,
34. Objetos são variáveis
Problema: escreva no programa uma rotina que recebe um Essa rotina deve receber um parâmetro que é, logicamente, o monstro. Exemplo de chamada:
monstro2.py jorgival.diga_ engorde (jorgival) jorgival.diga_
µ
37
Objetos são variáveis
: escreva no programa uma rotina que recebe um monstro e aumenta seu peso em 10%.
Essa rotina deve receber um parâmetro que é, logicamente, o monstro.
.diga_peso() #mostra 277 na tela
engorde (jorgival)
.diga_peso() #mostra 304.7 na tela
µ guia de estudos python
André Koscianski
monstro e aumenta seu peso em 10%.
35. A variável self
As sub-rotinas de uma classe são conhecidas como entre métodos de uma classe e sub-rotinas comuns.
Quando invocamos um método, ele deve agir em
jorgival.diga_ anaiaia .diga_
Ou seja: é a mesma sub-rotina, mas trabalhando para um monstro diferente. Pergunta: como o método “sabe” qual é o monstro que está sendo utilizado?Resposta: usando o parâmetro Veja este exemplo:
monstro_self.py class monstro peso = 100 def diga_peso print "Eu peso ", self.peso, " toneladas." jorgival = Monstroanaiaia = Monstro jorgival.diga_pesoanaiaia .diga_peso () Monstro.diga_pesoMonstro.diga_peso (anaiaia)
Na seta vermelha (1) é feita uma chamada “comum”, que você já conhece Na seta amarela (2) é chamda
avisando à função que o monstro a ser us Para a linguagem Python, as duas chamadas são iguais.
Ao ler o código da seta vermelha, o compilador imediatamente identifica o parâmetro self=jorgival.Ao ler o código da seta amarela, novamente self=jorgival. São duas maneiras de escrever a mesma coisa.
comum. Ela corresponde ao que se faz em C++, Java, C# e outras linguagens com orientação a objetos.
1)
2)
µ
38
de Python
rotinas de uma classe são conhecidas como métodos. E existe uma diferença importante rotinas comuns.
Quando invocamos um método, ele deve agir em um determinado objeto:
.diga_peso()
.diga_peso()
rotina, mas trabalhando para um monstro diferente.
: como o método “sabe” qual é o monstro que está sendo utilizado?: usando o parâmetro self .
class monstro ():
peso = 100
def diga_peso (self): print "Eu peso ", self.peso, " toneladas."
onstro () onstro ()
jorgival.diga_peso () anaiaia .diga_peso ()
onstro.diga_peso (jorgival) onstro.diga_peso (anaiaia)
(1) é feita uma chamada “comum”, que você já conhece, ao monstro jorgival.
é chamda a função “diga_peso” da classe “monstro”. Nessaavisando à função que o monstro a ser usado é “jorgival”.
Para a linguagem Python, as duas chamadas são iguais.
Ao ler o código da seta vermelha, o compilador imediatamente identifica o parâmetro self=jorgival.Ao ler o código da seta amarela, novamente self=jorgival.
escrever a mesma coisa. A forma mostrada na seta vermelha é a mais . Ela corresponde ao que se faz em C++, Java, C# e outras linguagens com orientação a objetos.
µ guia de estudos python
André Koscianski
uma diferença importante
rotina, mas trabalhando para um monstro diferente.
: como o método “sabe” qual é o monstro que está sendo utilizado?
print "Eu peso ", self.peso, " toneladas."
, ao monstro jorgival.
. Nessa chamada estamos
Ao ler o código da seta vermelha, o compilador imediatamente identifica o parâmetro self=jorgival.
seta vermelha é a mais . Ela corresponde ao que se faz em C++, Java, C# e outras linguagens com orientação a objetos.
36. Atributos de objetos Vamos aprender mais uma coisa sobre a variável Veja este código:
atributos.py class Monstro (): peso = 100 nome = "" def batizar self.nome = string def diga_peso (self): peso = 123 print "Ola, sou o monstro ", self.nome print "Variavel local vale ", peso print "Eu tenho ", self.peso, " toneladas." x = Monstro () x.batizar ("cleocivaldo")x.diga_peso ()
Na seta vermelha (1) são criadas
• peso
• nome Na setas amarelas (2) os atributos de um determinado monstro são usados. Só é possível saber qual
é o monstro, quando a rotina é chamada (lembrou para que serve o parâmetro
• self.peso
• self.nome Na seta azuL (3), você vê uma variável “solta”
“self.peso” e “peso” são diferentes. E esta é a saída do programa acima:
1)
3)
2)
2)
µ
39
Atributos de objetos
coisa sobre a variável self.
onstro ():
peso = 100 ""
batizar (self, string): self.nome = string
def diga_peso (self): peso = 123
print "Ola, sou o monstro ", self.nome
print "Variavel local vale ", peso
print "Eu tenho ", self.peso, " toneladas."
onstro ()
x.batizar ("cleocivaldo") x.diga_peso ()
Na seta vermelha (1) são criadas variáveis que pertencem a um monstro (ou ATRIBUTOS)
Na setas amarelas (2) os atributos de um determinado monstro são usados. Só é possível saber qual é o monstro, quando a rotina é chamada (lembrou para que serve o parâmetro self ?)
uma variável “solta”. Ela pertence à sub-rotina, não ao objeto
E esta é a saída do programa acima:
µ guia de estudos python
André Koscianski
print "Eu tenho ", self.peso, " toneladas."
(ou ATRIBUTOS):
Na setas amarelas (2) os atributos de um determinado monstro são usados. Só é possível saber qual ?):
não ao objeto. Note que
37. Aviões – objetos
Aperfeiçoamento de um programa
Crie uma classe avião que contem coordenadas x,y e velocidade vx,vy
avioes.py N_AVIOES = 10 ... class Aviao(): rect_aviao=[] vel_x = 0 vel_y = 0 pos_x = 0 pos_y = 0 ... aviao = [] for idx in xrange( aviao[idx] = Aviao() aviao[idx].v aviao[idx].pos_x = random.random() * 10
Para movimentar os aviões, use um laço assim:
for idx in xrange ( aviao[idx].
e crie um método dentro da classe
class Aviao(): ... def mover(self): aux = self.rect.move((self.vel_x, self.vel_y)) self.rect = aux
µ
40
objetos
Aperfeiçoamento de um programa: volte ao jogo do canhão anti-aéreo.
avião que contem coordenadas x,y e velocidade vx,vy e um conjunto de aviões:
= 10
class Aviao():
rect_aviao=[] vel_x = 0 vel_y = 0 pos_x = 0 pos_y = 0
for idx in xrange(N_AVIOES): aviao[idx] = Aviao()
aviao[idx].vel_x = random.random() * 10 aviao[idx].pos_x = random.random() * 10
Para movimentar os aviões, use um laço assim:
xrange (N_AVIOES): aviao[idx].mover ()
e crie um método dentro da classe Avião, assim:
class Aviao():
def mover(self):
aux = self.rect.move((self.vel_x, self.vel_y))
self.rect = aux
µ guia de estudos python
André Koscianski
conjunto de aviões:
aux = self.rect.move((self.vel_x, self.vel_y))
38. Esqueleto de jogo: pouso lunar
Vamos exercitar um pouco mais n
conhecido. Começamos por um dos programas de iôguia.
(1) Primeiro, crie uma classe Nave().
classe deve poder se mover na tela. Programe a rotina de movimento de forma que s
reaparecerá no canto esquerdo – e vice (2) Inclua na classe Nave() uma variável de aceleração,
(self.acc), servirá para calcular a velocidade usando esta fórmula:
O valor constante 0.1 na fórmula acima serve para representar um campo gravitacional que atrai a
nave para o chão. Você deverá calibrar Inicialmente, faça aparecer a nave na tela, atribua o
deve obter uma nave que cai no chão, (3) Agora inclua no programa a capacidade de ler o
exemplo a barra de espaço. Enquanto essa tecla estiver acionada, a variável O valor do incremento deve ser algo em torno de um décimo da força da gravidade.
Assim que o usuário solta essa tecla, imediatamente a variável
resolver esse problema, observe com atenção o programa (4) Coloque um comando IF no código, de forma que se a nave
muito elevada, ela explode. (5) Inclua um placar gráfico na tela, que mostra a velocidade atual da nave.
µ
41
Esqueleto de jogo: pouso lunar, parte I
Vamos exercitar um pouco mais nossos conhecimentos de Mecânica e criar um jogo bastante um dos programas de iô-iô que você fez, como o de MRUV da seção
Primeiro, crie uma classe Nave(). Assim como a bola (ou o avião), a imagem controlada por esta
Programe a rotina de movimento de forma que se a nave “vazar” o canto direito da tela, ela e vice-versa.
Inclua na classe Nave() uma variável de aceleração, acc. Essa variável, que faz parte da Nave(), servirá para calcular a velocidade usando esta fórmula:
����� � ������� � ��� � 0.1� ∗ Δ�.
O valor constante 0.1 na fórmula acima serve para representar um campo gravitacional que atrai a nave para o chão. Você deverá calibrar esse valor por tentativa e erro, assim como no programa do MRUV.
Inicialmente, faça aparecer a nave na tela, atribua o valor self.acc = 0 e simule movimento. Você deve obter uma nave que cai no chão, acelerando, exatamente como o programa da bola fazia.
a capacidade de ler o teclado. Você precisa deEnquanto essa tecla estiver acionada, a variável self.acc
O valor do incremento deve ser algo em torno de um décimo da força da gravidade.
Assim que o usuário solta essa tecla, imediatamente a variável self.acc deve receber zeresolver esse problema, observe com atenção o programa-exemplo da seção 27 deste guia.
Coloque um comando IF no código, de forma que se a nave colidir no chão com uma velocidade
Inclua um placar gráfico na tela, que mostra a velocidade atual da nave.
µ guia de estudos python
André Koscianski
ossos conhecimentos de Mecânica e criar um jogo bastante você fez, como o de MRUV da seção 23 deste
a imagem controlada por esta
“vazar” o canto direito da tela, ela
. Essa variável, que faz parte da Nave()
O valor constante 0.1 na fórmula acima serve para representar um campo gravitacional que atrai a esse valor por tentativa e erro, assim como no programa do MRUV.
= 0 e simule movimento. Você exatamente como o programa da bola fazia.
. Você precisa de uma única tecla – por self.acc deve ser incrementada.
deve receber zero. Para deste guia.
colidir no chão com uma velocidade
39. Esqueleto de jogo: pouso lunar
Agora que a parte I do jogo está funcionando, vamos em frente. (1) Inclua mais uma variável na Nave: (2) Agora programe as teclas de seta à esquerda (K_LEFT) e seta à direita (K_RIGHT) para modificar o
valor da variável self.accX. Quando incrementado, exatamente da mesma forma como você fez com a variável
Siga o mesmo raciocínio e programe a tecla K_LEFT para decrementar a variável (3) Em seguida, inclua no código esta fórmula:
Ela é muito parecida com a fórmula (2) da seção
horizontal da nave. A multiplicação poro usuário acelere a nave, pressionando as teclas de seta e mudando o valor de
A fórmula deve ser calculada
para incluir a fórmula é dentro da classe Nave(). O laço principal do programa pode
while (True): #leia teclado # h = espaco apertado/nao minhanave.controlar_aceleracao_Vertical (v) minhanave.controlar_aceleracao_Horizontal (h) minhanave.atualizar_velocidade_Vertical () minhanave.atualizar_velocidade_Horizontal () minhanave.mover () minhanave.testar_aterrisagem () pygame.time.delay (5)
(4) Último passo: desenhe no PaintBrush
jogador deve conseguir pousar a nave exatamente sobre a plataforma, com uma velocidade vertimuito grande. Se a velocidade estiver muito alta, ou se o pouso for longe demais da plataforma, a nave explode!
µ
42
Esqueleto de jogo: pouso lunar, parte II
Agora que a parte I do jogo está funcionando, vamos em frente.
Inclua mais uma variável na Nave: self.accX. Essa variável contem a aceleração horizontal
Agora programe as teclas de seta à esquerda (K_LEFT) e seta à direita (K_RIGHT) para modificar o Quando a tecla K_RIGHT estiver apertada, o valor de
da mesma forma como você fez com a variável self.acc e a tecla K_ESPACE.programe a tecla K_LEFT para decrementar a variável
inclua no código esta fórmula:
�(���� � 0.9 ∗ �(������ � ���( ∗ Δ�.
Ela é muito parecida com a fórmula (2) da seção 23. Aqui, a variável VA multiplicação por 0.9 faz que a nova velocidade seja menor que a antiga
o usuário acelere a nave, pressionando as teclas de seta e mudando o valor de self.acc
calculada à cada iteração do laço principal do programa. Um local para incluir a fórmula é dentro da classe Nave(). Entende o motivo?
O laço principal do programa poderá ficar mais ou menos assim:
while (True):
leia teclado; v = seta esquerda/direita, # h = espaco apertado/nao
nhanave.controlar_aceleracao_Vertical (v) nhanave.controlar_aceleracao_Horizontal (h)
minhanave.atualizar_velocidade_Vertical () minhanave.atualizar_velocidade_Horizontal ()
minhanave.mover () minhanave.testar_aterrisagem ()
pygame.time.delay (5)
e no PaintBrush uma plataforma de pouso no paint-brush e mostrejogador deve conseguir pousar a nave exatamente sobre a plataforma, com uma velocidade vertimuito grande. Se a velocidade estiver muito alta, ou se o pouso for longe demais da plataforma, a nave
µ guia de estudos python
André Koscianski
aceleração horizontal da Nave.
Agora programe as teclas de seta à esquerda (K_LEFT) e seta à direita (K_RIGHT) para modificar o tiver apertada, o valor de self.accX deve ser
e a tecla K_ESPACE. programe a tecla K_LEFT para decrementar a variável self.hacc.
variável VX contem a velocidade faz que a nova velocidade seja menor que a antiga – a menos que
self.accX.
o laço principal do programa. Um local mais lógico
brush e mostre-a na tela. O jogador deve conseguir pousar a nave exatamente sobre a plataforma, com uma velocidade vertical não muito grande. Se a velocidade estiver muito alta, ou se o pouso for longe demais da plataforma, a nave
Recommended