EstudoDirigidoPython

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 ................................................................................................


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 ................................................................


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.


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.


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!).


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.


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


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.


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,

� ��


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.


André Koscianski

Adapte para Python o código FORTRAN que calcula os zeros de um polinômio de segundo grau,


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.


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 é


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


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


sem recursão, 9 linhas de código


(repetir quantas vezes desejar)

14 linhas de código


horizontalmente 4 ou 5 vezes)


***** ****


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:


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


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.


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.


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.


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.


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().


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


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.


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).


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.


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”).



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”).


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


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.


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


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.


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]


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


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


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.


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


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.


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:


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


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.


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


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

Documents

EstudoDirigidoPython