Aprenda Python para Jogos

por Guilherme Teres Nunes

Antes de tudo...
Opa! Aqui é o Guilherme da Uniday Studio e estou muito feliz em escrever
este livro para te ajudar a entender um pouco melhor sobre o funcionamento do
Python. É sempre fantástico saber que estou conseguindo ajudar alguém a
encontrar o caminho e aprender algo novo, muito obrigado pela confiança e por você
estar aqui, de verdade.

Uma dica que eu quero te dar logo no começo e que você precisa saber se é
sua primeira vez programando é que programar é como uma nova forma de ver o
mundo... É algo muito bem regrado e definido que muitas vezes nós, “meros
mortais”, não estamos acostumados a seguir. Quando você já souber programar,
inclusive, ficará maravilhado (assim como eu fiquei) com o leque de possibilidades
que vão aparecer em sua frente.

Mas o que isso significa? Significa que a forma mais eficaz de aprender
Python (ou qualquer linguagem de programação) é com a prática. Não hesite em
praticar, abrir o Python, testar, experimentar e claro, voltar aqui no livro quantas
vezes achar necessário. Você também pode consultar a internet sempre que algo
não estiver funcionando (eu faço isso quase todos os dias até hoje, não pense que é
algo só para iniciantes).

Em dez anos de desenvolvimento eu posso dizer com absoluta certeza que

eu nunca conheci ninguém que conseguiu aprender Python sem praticar, nem
mesmo os programadores que hoje considero gurus e mentores tiveram essa sorte
quando começaram. É exatamente por isso que eu quero começar esse conteúdo te
dando essa dica.

Você certamente terá um desempenho fantástico e eu espero contribuir

grandemente para isso, mas tudo será em vão em a prática, então vamos colocar as
mãos na massa, combinado? Se precisar de absolutamente qualquer coisa, é só
dizer.

Bons estudos!
Guilherme
Aprendendo Python
Python... Python?
Talvez seja muito estranho para você ver alguém começar a contar a partir do
zero, mas essa provavelmente vai ser uma das primeiras coisas legais que vou te
ensinar aqui se você nunca programou. Já comece a se familiarizar com isso.

Meu objetivo nesse capítulo é te introduzir aos conceitos básicos da

linguagem de programação Python, bem como a mentalidade necessária para e
tornar um programador. Já antecipo que esse não é um livro exclusivo de introdução
a Python, você irá encontrar vários livros específicos com centenas de páginas que
te ensinam todos os detalhes (se você quiser) e também irá encontrar, no meu canal
do Youtube, uma série gratuita onde eu mostro todos esses conceitos de uma forma
um pouco mais detalhada. Sinta-se livre para consultar essa série, fazer pesquisas
na internet ou me mandar uma mensagem se tiver alguma dúvida no caminho.

De qualquer forma, com a estrutura básica que irei te passar aqui eu espero
que você seja capaz de seguir todo o material desse livro e criar seus próprios
mecanismos dentro do Blender (UPBGE). Para deixar tudo ainda mais dinâmico,
aqui está uma lista detalhada de tudo que você irá aprender nesse capítulo:

• Baixando a IDLE para programar em Python

• O que é Python?
• Um código básico
• Variáveis
• Print (olá, mundo!)
• Condicionais (if, elif, else)
• Indentação
• Funções
• Endentação de novo!
• Funções com parâmetros
• Funções que retornam coisas (return)
• A Regra de ouro para Funções
• Listas
• Classes
• Bibliotecas
 Gosto de fazer esse resumo no início para você se situar e, se por algum motivo
estiver seguindo algum outro material aleatório ao mesmo tempo em que esse você
não ficar perdido em momento algum. Então vamos lá!

Baixando a IDLE para programar em Python

A primeira coisa que você precisa fazer para programar qualquer linguagem é
ter um “ambiente” configurado em seu computador. Em outras palavras, ter uma
série de programas instalados para transformar o código que você escreveu em algo
que seu computador consiga ler. No caso do Python, só precisa de um programinha
bem leve e fácil e instalar (ufa!). É bem simples: basta entrar em python.org, clicar
em download e em “Python 3.7.4”.

Talvez o site esteja um pouco diferente quando você entrar e talvez a versão
do Python não seja mais a 3.7.4 da imagem. Desde que você baixe alguma versão
que comece com “3”, está tudo bem (é sério). Só não pode baixar as versões abaixo
do três, pois elas possuem diferenças drásticas.

Assim que efetuar o download, basta executar o arquivo e seguir todos os

passos para instalar.

Feito isso algum ícone do Python deve aparecer em sua área de trabalho,
mas para não ter dúvidas, digite “IDLE” no menu iniciar do Windows (ou pesquise
por isso nos aplicativos do seu sistema operacional) que você irá encontrar algo
parecido com esse nome:
IDLE (Python GUI)

Ou esse:

IDLE (Python 3.7)

Ou qualquer coisa parecida. Assim que você abrir o programa, verá uma
janela como essa:

Pronto, tudo certo para começarmos!

Ah, eu sei que talvez você tenha pensado: “Ué, mas não vamos utilizar o
UPBGE para criar os jogos? Por que estou tendo que baixar isso?” E para te
explicar o motivo nós iremos à próxima parte desse capítulo:

O que é Python?
Python é uma linguagem de programação de alto nível, interpretada, de script,
feita para ser simples e parecida com a língua inglesa (quem inventou o Python
queria que um script nessa linguagem fosse tão simples e legível como um texto em
inglês, ou quase). Se você não sabe inglês, não se preocupe, seu computador sabe
menos ainda, então são poucas palavras que terá que decorar.

O que quero que você entenda é:

Python não foi feito pelo Blender, nem pelo UPBGE, é uma linguagem
famosa, com diversas aplicações reais e inclusive fora dos jogos: é popular em
Inteligência artificial, aprendizado de máquina, processamento de dados, criação de
robôs, servidores de internet e, claro, Jogos!

Os desenvolvedores do Blender (e do UPBGE) apenas escolheram essa

linguagem para você programar seus jogos lá dentro e eles não foram os únicos,
Python sempre esteve muito presente na indústria de Jogos: Battlefield 2,
Civilization IV, The Sims 4, Overwatch, Eve Online, World of Tanks e diversos
outros jogos famosos utilizam essa linguagem.

É exatamente por isso que eu disse para você baixar o IDLE: um programa
específico do Python, que não tem nada a ver com o Blender e nem com o UPBGE
(nós nem sequer vamos utilizar esse software nos games em si), mas que é
excelente para você dar os seus primeiros passos com a linguagem, para só depois
começarmos a internalizar os conceitos da game engine.

Um código básico
Certo, agora vamos criar seu primeiro script para começarmos a entender
como ele funciona. Abra a IDLE, vá em File e clique em New File:

Uma nova janela irá se abrir com tudo branco lá dentro (sim, é um editor de
textos). Imediatamente, clique em File, Save (ou aperte Ctrl + S) para salvar seu
novo arquivo vazio. Selecione um diretório (eu recomendo que você crie uma pasta
em algum lugar do seu computador para colocar esses arquivos) e digite o nome lá
em baixo como:
first.py

É importante você colocar o “.py” no final. Essa é a extensão padrão de

arquivos de script do Python. Vai dar tudo errado se você esquecer essa parte,
sério! Agora cole esse trecho de código no seu editor de texto vazio (a nova janela
que apareceu e você acabou de salvar):
# Definindo variáveis...
x = 10
y = 15

# Somando os valores...
z=x+y

# Exibindo o resultado...
print("O Resultado é:", z)

Aperte Ctrl + S para salvar e clique em Run, “Run Module” para executar seu
código.

Quando você fizer isso, o IDLE irá abrir novamente aquela primeira janelinha
e exibir isso por lá:

Ótimo! Agora você sabe como criar um novo script, colar um código por lá e
executa-lo. Está na hora de entender como tudo isso acontece para você criar seus
próprios programas.

O primeiro conceito EXTREMAMENTE importante é que seu computador,

quando for “ler” seu código, fará isso de cima para baixo, esquerda para direita,
exatamente como uma pessoa normal leria qualquer texto. Com a diferença que seu
PC é uma máquina que não tem preguiça e é meio “burrinha”: ele sempre vai ler
TUDO que você escrever e na ordem certa. Isso significa que se você pudesse
escrever isso no seu script:

Para continuar lendo esse texto, diga em voz alta qual a resposta certa.

Dica: a resposta certa é “42”.

O seu computador iria explodir, pular em um buraco, desistir da vida, qualquer

coisa parecida. Não pelo fato de que ele não consegue dizer coisas em voz alta,
mas porque ele ficaria preso para sempre na primeira linha sem saber o que fazer
(já que ele não pode pular a primeira linha e ver a dica antes). Inclusive, assim que
você entender alguns conceitos que explicarei daqui a pouco volte aqui e tente
entender porque esse trecho e código causaria o mesmo efeito que o texto anterior
(no caso, um erro):

print(x)
x = 10

Isso que acabei de falar pode parecer brincadeira, mas é a causa de 50% dos
problemas que as pessoas me enviam todos os dias que leva o código delas a “não
funcionar”. Agora que você sabe dessa ordem, vamos entender o que esse código
faz!

A primeira linha, que provavelmente está com uma cor vermelha na sua IDLE
(sem desespero que não estiver, pois isso é configurável e serve só para ficar fácil
de enxergar), está escrito “#Definindo variáveis...”. Algo estranho baseado no que eu
te falei quando disse o que é Python: Uma linguagem feita para se parecer com o
inglês. De fato, isso não é Python e não foi feito para o seu computador entender:
foi feito para você entender. É um comentário. Toda vez que o python encontra o
símbolo “#” pela frente ele educadamente para de ler aquela linha e vai para a linha
de baixo.

Dessa forma, sempre que você achar necessário escrever alguma coisa no
código para entender melhor, basta colocar um comentário e lembrar que o Python
jamais irá tentar ler o que está depois do “#”. Você pode, inclusive, colocar
comentários na mesma linha depois de um código do python (só não pode colocar
antes do código, ou o código irá fazer parte do comentário):

# O Python não vai ler isso!

#x = 10
# O python continua sem saber o que é x
x = 10 # agora ele sabe.

Perfeito! Agora você já sabe o que são três linhas do nosso primeiro código e,
se for esperto, até tem uma noção melhor do que ele faz. Mas vãos com calma, um
passo de cada vez:

Variáveis
Nas próximas linhas do código (excluindo os comentários) nós fazemos uma
coisa muito importante na programação: definimos e lidamos com variáveis. Você
pode armazenar valores diversos (veremos a frente quais) dentro do seu código,
definindo um nome a eles. Quando você faz:

x = 10

Você está atribuindo o valor 10 a uma nova variável chamada “x”. E não se
engane: essa variável poderia chamar (quase) qualquer coisa:

superVariavelComUmNomeLegal = 15

Você deve ter percebido que eu não coloquei espaços na frase que defini
como “nome” dessa variável. Isso é porque eu computador não é tão inteligente
quanto você pensa e o Python utiliza os espaços entre as coisas para identificar
variáveis, etc diferentes. Na verdade, aqui está uma listinha de regras que você
precisa obedecer ao nomear suas variáveis (e qualquer outra coisa que você puder
nomear no Python):

• Não pode começar com números (mas pode ter números no meio da palavra
ou no final).
• Não pode ter pontuação como essas: ,.!?{}[]()+-*/%$#@&!”’. Basicamente,
de todos os caracteres que não são letras e números, você só pode utilizar o
underline (isso aqui: _) nos nomes.
 • Não pode ter espaços entre as palavras. Se seu nome tiver mais de uma
palavra (ex: banana frita), você pode começar a segunda palavra com letra
maiúscula ou colocar um underline entre elas: bananaFrita ou banana_frita.
• Não pode ser nenhuma dessas palavras (pois essas são reservadas pelo
Python, só ele pode usar): False, await, else, import, pass,, None, break,
except, in, raise, True, class, finally, is, return, and, continue, for,
lambda, try, as, def, from, nonlocal, while, assert, del, global, not, with,
async, elif, if, or, yield.

Ah, eu também não recomendo que você use caracteres especiais da língua
portuguesa, como “ç”, “ã” e outros tipos de acentos. Se você definir uma variável
com o nome “ação”, pode até funcionar em alguns casos, mas vai dar problema
quando você menos esperar. É por isso que eu gosto de nomear as coisas em
inglês.

Eu sei que essa definição de variáveis está se parecendo com a boa e velha
matemática do ensino fundamental, de fato, se parece. Você pode definir x como o
resultado de uma conta:

x = 10 + (15 / 3) * 87

E inclusive usar outras variáveis (que você já definiu) nessa conta:

y = 67
x=2*y–1

O que não vai dar certo é você colocar mais de uma coisa antes do sinal de
igual (=).

Esse sinal de igual serve para atribuir um valor a uma variável, então isso
aqui NÃO irá funcionar, por exemplo:

x + 3 = 27 * 2 # Isso vai dar erro

Falando na língua da matemática, você tem que colocar “o x em evidência”.

Certo, agora você já sabe que dá para atribuir números a variáveis e fazer
operações matemáticas com esses valores (adição: a + b, subtração: a - b,
multiplicação: a * b, divisão: a / b, módulo: a % b e até elevar a outro número: a ** b).
Você também pode somar, subtrair, multiplicar e dividir números diretamente
colocando os sinais antes do igual como no exemplo abaixo. Dessa forma isso aqui:

x=3
x = x + 1 # Somando mais um
x = x * 3 # Multiplicando por três

É a mesma coisa que isso:

x=3
x += 1 # Somando mais um
x *= 3 # Multiplicando por três

Agora, que tipo de informação você pode colocar nas variáveis? A resposta é:
(quase) tudo! Veja uma lista com os tipos mais importantes:

Tipo Descrição Exemplo

int Números inteiros, sem vírgula. x = 23
float Números com vírgula. É importante você perceber pi = 3.14
que “vírgula” aqui é só um modo e falar: você
SEMPRE deve utilizar um ponto no lugar da
vírgula pois é assim que o Python interpreta esse
tipo de dado. Caso contrário, vai dar problema.
bool Booleana, uma variável que pode ser verdadeira useWeapon = True
(True) ou falsa (False).
string Strings servem para armazenar palavras, textos, name = “Guilherme”
letras, etc. O nome do seu jogador, por exemplo, é
uma string. Perceba que o valor dessa variável
OBRIGATÓRIAMENTE precisa estar dentro de
aspas (aspas duplas ou simples, você escolhe. Só
não pode misturar as duas).
list Listas, como o nome já diz, são listas de outras bag = [“Apple”,
variáveis (inclusive de outras listas, se você “Orange”, “Red Axe”]
quiser). Iremos ver mais sobre elas mais a frente.
dict Dicionários (dict) são como listas, mas aqui você test = {“x” : 23, “y” :
pode dar um nome a cada valor que está lá 42}
dentro. Pense como um dicionário mesmo: uma
palavra e um “significado” para ela (não precisa
ser só strings). Veremos isso mais a frente
também.

Agora que você tem uma noção melhor do que são variáveis, vamos entender
a última linha do nosso primeiro código para depois praticarmos coisas mais
interessantes.

Print (olá, mundo!)

Lembra qual era essa linha?

print é uma função. Funções são, basicamente, um monte de código que

serve para executar uma tarefa específica. No caso do print, para exibir na tela
todas as variáveis que você colocar dentro dos parênteses, separados por vírgula.
Percebe que na janela da direita está escrito: “O Resultado é: 25”? Isso foi trabalho
do print.

O que fizemos nessa última linha foi chamar a função print. Chamar funções
se resume em, basicamente, digitar o nome dela e colocar parênteses depois:
print(). Dentro desses parênteses podem ter argumentos (se a função permitir) que
são basicamente variáveis. Veremos daqui a pouco como você pode criar suas
próprias funções e colocar argumentos.
 Com o print em mente você já pode criar o famoso programa do “hello,
world!”: Crie um novo arquivo, salve em seu computador e adicione esse código com
a mensagem que quiser para o “mundo”:

Condicionais (if, elif, else)

Certo, agora vamos à parte legal da programação. Um código serve para
você instruir seu computador sobre o que fazer: você escreve uma “ordem” e ele a
obedece. Escreve print(“sim!”) e ele fala sim! Mas você provavelmente vai querer
que ele só faça alguma coisa em uma situação específica. Se o jogador estiver com
a arma mais potente do jogo, você quer que todos os inimigos fujam. Se não, quer
que eles ataquem o player.

E como fazer isso? Adicionando condições!

No exemplo que dei da melhor arma, considere que nós tempos uma variável
booleana chamada “hasBestWeapon” que é positiva (True) se o jogador tem a
melhor arma e falsa (False) se não. Considerem também que temos duas funções:
“enemiesAttack” e “enemiesRunAway” para fazer os inimigos atacarem ou fugirem,
respectivamente (ainda não vimos funções, mas você já tem uma noção que elas
são um monte de código que fazem uma coisa, é o suficiente para esse exemplo).

Como faríamos isso? Bom, em português seria algo assim:

se “hasBestWeapon” for True, enemiesAttack()

se não, enemiesRunAway()

Em inglês:

if “hasBestWeapon” is True, enemiesAttack()

else, enemiesRunAway()
 E em python?

if hasBestWeapon == True:
enemiesAttack()
else:
enemiesRunAway()

Lembra de que eu disse que o objetivo do Python era ser parecido com o
inglês? Olha aí! E eu também disse que não tem muitas palavras para “decorar”.
Não tem. São basicamente essas que estão em azul.

Agora vamos entender o que aconteceu, pois há algumas novidades nesse

script. A primeira delas é o operador “==” (dois sinais de iguais juntos) que é
diferente do operador “=” (um sinal de igual). Quando você usa um sinal apenas,
está atribuindo um valor (o valor da direita) a uma variável (que fica a esquerda),
como já vimos:

x = 10

Quando você usa dois sinais, está comparando se o valor da esquerda é

igual ao da direita. O python irá comparar e automaticamente retornar True se for
igual, e False se for diferente.

Você pode, inclusive, “pegar” essa booleana que diz se é igual ou diferente e
colocar em uma variável:

x = True
result = x == True # “result” vai ser True porque True é igual a True
result2 = x == False # “result2” vai ser False porque True é diferente de False

E o que o if faz? Ele executa o código que está abaixo dele se o valor que
está na frente é True. Percebeu que eu coloquei um “espaço em branco” nas linhas
de baixo do if e do else? Vamos ver exatamente o que é isso daqui a pouco, mas
saiba que é para o python saber o que ele deve executar.

Esqueça o else por enquanto, preciso que você entenda exatamente o que
está acontecendo no if. Fiz um pequeno esquema para te ajudar a entender:

if valor:
 execute esse trecho

Com a estrutura acima, o Python irá executar o trecho e código

imediatamente abaixo do if (em vermelho) se e somente se o valor (em azul) for
True. Na linha de baixo de todo if deve ter obrigatoriamente no mínimo uma linha
de código a ser executada (essa linha não pode ser um comentário). Claro, você
pode colocar mais de uma linha, desde que ela também esteja com esse “espaço”
no começo (veremos daqui a pouco o que é ele):

if valor:
execute esse trecho
esse trecho também
e esse aqui.
já essa linha será executada mesmo se o valor do if for False.

Agora o Python irá executar as três linhas em vermelho caso o valor do if seja
True. Mas perceba que eu adicionei uma nova linha, em verde, no final. Por quê?
Para você perceber que ela não faz parte do if porque não tem o “espaço em
branco” antes.

Observe que o início dessa linha está “alinhado” com o inicio da linha do if.
Significa que ela será executada independente do valor que estiver no if. Claro,
seguindo sempre a regra que eu disse anteriormente: o python irá ler seu código de
cima para baixo, logo ele irá ler a linha do if primiro, e o valor dele for positivo, irá ler
as linhas em vermelhos e depois a linha verde, se o valor for falso, irá pular para a
linha verde.

Se você quiser criar um script na IDLE do Python para testar, faça um código
com uma variável X igual a um valor inteiro que exibe uma mensagem na tela se
esse valor for igual a 32. Para colocar o “espaço em branco” antes da linha, basta
apertar a tecla TAB do seu computador. Assim:

x = 40
if x == 32:
print(“Sua mensagem!”)

Para terminar, cadê o else?

 O else funciona como um “se não”, em outras palavras, se o Python não
entrar no if (valor do if não for True), ele vai procurar um else na próxima linha
abaixo do trecho que seria executado (a linha “verde” do exemplo anterior). Se tiver,
ele vai executar o trecho referente a ele. Imagine que o Python e uma pessoa
andando em uma floresta. Andar seria ler as linhas de código. Ai essa pessoa
encontra uma situação assim:

O caminho se divide em dois. No final os dois caminhos levarão a mesma

trilha novamente, mas ou você passa por um, ou você passa por outro. Esse é o
Python quando encontra um if seguido de um else no seu código.

Se o valor do if for positivo, ele vai executar o trecho dele. Se for falso, ele vai
pular e executar o trecho do else (se houver um else).

if valor:
trecho do if
else:
trecho do else
já essa linha será executada sempre, faça chuva ou faça sol.

A linha verde é onde os dois caminhos do nosso viajante da imagem (e o

Python) se encontram novamente.

No exemplo do x igual a 32, você pode alterar o código para dizer, por
exemplo, se X é ou não esse valor:

x = 40
if x == 32:
 print(“Parabéns, X é um valor válido (32)”)
else:
print(“X não é um valor válido!”)

É importante lembrar que o else é opcional, mas se você decidir usar, ele
deve ser colocado obrigatoriamente imediatamente depois do trecho do if. Pode ter
uma linha em branco ou uma linha toda comentada no meio, mas jamais outro
trecho de código:

x = 40
if x == 32:
print(“Parabéns, X é um valor válido (32)”)
x = 10 # Isso vai dar um erro monstruoso, sério.
else: # E o erro vai acontecer aqui!
print(“X não é um valor válido!”)

Se você tentar executar o código acima o Python vai chegar no else e

literalmente não vai saber o que fazer já que ele só espera um else se for
imediatamente após o if.

Certo, agora imagine um jogo com a seguinte situação: Se o jogador tiver a

espada nível 10, todos os inimigos vão fugir de medo, caso contrário, vão atacar o
jogador. Nada de novo até aqui, você já sabe fazer essa lógica usando um if e else.
Mas agora você decidiu que se a espada for nível 9 os inimigos não vão nem fugir
nem atacar, ficarão imóveis sem saber o que fazer. Como resolver essa questão?

Usando um elif depois do if e antes do else:

if swordLevel == 10:
enemiesRunAway() # Inimigos fogem
elif swordLevel == 9:
enemiesDoNothing() # Inimigos não fazem nada
else:
enemiesAttack() # Inimigos atacam

Um elif serve para quando você quer dar uma “segunda chance” ao python de
executar algum código em uma condição específica. Se o nível da arma não é 10,
existe a possibilidade de ser nove e talvez você queira testar isso. Se não for nem
dez (checado no if) e nem nove (checado no elif), então o python vai executar o else.
Se for dez, ele irá executar o if e ignorar o elif e o else (sim, ele não vai nem testar
para ver se o elif é verdadeiro). Se não for dez (ele não vai executar o if) mas for
nove, ele vai executar o elif e ignorar o resto.

É o famoso “ou um ou outro, os dois não dá!”.

Talvez você tenha se perguntado: “E se eu quiser os dois?” Bom, nesse caso

você usa dois ifs ao invés de um elif. Só precisa se atentar para o uso do else, nesse
caso: Lembre-se que o else se refere apenas ao último if imediatamente acima dele.

Uma última coisa importante sobre o elif: ele também é opcional e se você
usar um, não precisa colocar um else (só se você quiser). Você também é livre para
utilizar mais de um elif depois do if, mas vale lembrar que aquela mesma regra de ter
um “código solto” entre o if e o else vale para o elif: Não pode ter códigos soltos
entre um if e um elif, nem entre um elif e outro elif e muito menos entre um elif e um
else.

Pode parecer confuso, mas calma, você se acostuma com isso. Se não se
acostumar, sempre terá o Python falando que seu código está errado:

E por falar em código solto, talvez você tenha se perguntado: e como o

Python vai saber se a linha de código está solta ou se pertence a algum if, else, etc?
Você se lembra do “espaço em branco” antes? Agora vamos entender o que ele é e
como você nunca mais vai errar.
Indentação
Esse é um nome estranho que inventaram para explicar esse “alinhamento”
de código, o “espaço em branco” que define se uma linha pertence ou não a
condição (if, elif, else, etc) anterior. Em outras palavras, a endentação é literalmente
esse espaço aqui:

E por que é importante? Bom, antes de te responder, vou te contar um dado

alarmante: praticamente todas as pessoas que eu vejo começarem a estudar
python, sofrem pelo menos uma vez por não entender exatamente o que
endentação é e como utiliza-la corretamente. Pode parecer um conceito simples,
mas se você não prestar atenção nos detalhes, vai te dar dor de cabeça.

Quer um exemplo?

Bom, você já sabe que indentação é um “espaço” antes da linha, que o

python irá utilizar para saber se aquele trecho de código pertence ou não ao “if” (ou
elif, ou else, ou outros que veremos adiante). Então me diga: o que há de errado
com esse código abaixo?

Perceba que o primeiro print está um pouco mais a frente que o segundo. Isso
vai causar um erro. Mais especificamente, algum erro similar a esse:
 Ou se você já estiver avançado e estiver programando dentro do Blender,
verá o mesmo erro só que no console de saída:

E, apesar das letrinhas miúdas, você consegue identificar ali no meio a

mensagem “IndentationError”, que se refere exatamente ao que estamos tratando
agora.

Bom, então você já deve ter imaginado que é preciso que esses espaços
sigam certo “padrão”. Antes de eu te mostrar qual é esse padrão, uma observação
importante: no exemplo anterior foi fácil identificar que os espaços tinham tamanhos
diferentes, mas imagine em um código com centenas de linhas e um espaço na linha
287 está diferente de todos os outros? Por isso é importante seguirmos um único
padrão. E for falar em um único padrão, aí vai:

O python deixa você escolher qual o “tamanho” do espaço de indentação:

você pode cria-lo apertando a tecla “espaço” do seu teclado duas vezes, ou quatro,
ou oito, ou duzentas vezes, o Python irá aceitar. Mas desde que você use o
mesmo padrão durante todo o código! Em outras palavras: se a primeira
indentação que você fizer for utilizando oito espaços, então todas as outras devem
seguir essa regra.

Agora vou te adiantar: usar X espaços em brancos para indentar um código

pode (e provavelmente vai) dar problemas e dores de cabeça. Você vai acabar
colocando um espaço a menos ou a mais em algum momento e isso vai deixar seus
cabelos brancos antes da hora. Então qual a regra?

Não use “X espaços” para indentar código. Use uma vez a tecla TAB.

Procure em seu teclado se você não souber qual tecla é essa. Ela fica a
esquerda, próximo da tecla “Caps Lock” (na maioria dos teclados) e geralmente tem
um desenho de duas setinhas, uma para cada lado. Sempre use essa tecla, ela vai
criar um espaço do mesmo tamanho de quatro espaços (mas não é a mesma coisa,
quatro espaços é diferente de um tab, apesar de parecer igual).

Sempre que estiver em dúvida se indentou corretamente, apague os espaços

em branco antes da linha e indente novamente utilizando TAB. Seu código deve
ficar assim:

x = 10
if x > 0:
[TAB]if x == 10:
[TAB][TAB]print(x)

Coloquei o texto [TAB] no lugar dos espaços em branco no código anterior

para você entender melhor, mas obviamente o código não vai ter essa escrita.

Outra utilidade importante da indentação é definir escopos. Cada “pedaço” de

código definido pela indentação é chamado de “escopo”. “Escopo do if”, “escopo a
função” (que veremos daqui a pouco), etc. E um escopo pode ter outros escopos
dentro dele, como no exemplo anterior, que eu coloquei um if dentro do outro. Você
pode fazer isso quantas vezes quiser desde que você se lembre de colocar a
indentação correta.

E o que precisamos aprender sobre escopos? Bom, um conceito simples,

porém MUITO importante: no geral (existem exceções), você sempre deve
considerar que uma variável ou qualquer coisa que você definir em um escopo, só
estará “acessível” em seu próprio escopo ou em sub escopos (como um if dentro de
outro if). Pode parecer complexo, mas vou te dar um exemplo:
 Qual o problema desse código aqui? Bom, se você executar ele irá funcionar.
Mas e se você alterar o valor de x para dez? Então ele não irá entrar no escopo do
if, logo não irá definir que y é igual a dez e, quando chegar na linha do print(y), terá
um erro te esperando, pois o python não saberá o que é y.

Então, apesar de ser possível acessar a variável de um “sub escopo” (como

no exemplo que originalmente funcionou), não considere isso em seus projetos.
Para nós, vamos criar uma regra de que NÃO, não é possível. Essa regra, mesmo
não sendo uma verdade absoluta, pode salvar sua vida e te poupar horas de
sofrimento lidando com erros de código. Agora, seguindo essa regra, vamos resolver
nosso código anterior. Se eu quero acessar o y fora do escopo do if, então eu devo
defini-lo, também, fora desse escopo, assim:

Agora não vai dar problemas, pois o y está sempre definido, mesmo se o
python não entrar no if.

Funções
Agora que sabemos o que é indentação e que ela cria escopos, vamos evoluir
nossos códigos!
 Imagine que você está criando um programinha, um jogo, e quer que ele faça,
em vários momentos, uma mesma ação relativamente complexa (com várias linhas
de código). Por exemplo, quer que ele exiba no console a data atual do sistema.
Esse aqui é o código que faz isso:

Sinta-se livre para escrever esse programa e testar em seu computador,

inclusive. Ele irá exibir o dia, mês e ano atual em que você está lendo isso.

Mas como eu disse, queremos executar essa operação várias vezes em

vários locais de nosso programinha (ou do nosso jogo). Queremos exibir a data
quando o jogador entrar, depois queremos fazer a mesma coisa toda vez que ele
levar um dano de algum inimigo, e por último queremos exibi-la de novo quando ele
sair do jogo. E como fazer isso? Será que a saída mais inteligente é selecionar esse
trecho de código e copiar e colar em todos esses lugares?

Parece razoável, até você precisar alterar alguma coisa nessa lógica. Imagine
que você fez exatamente isso: duplicou seu código várias vezes. Mas agora quer
exibir esse texto em inglês, ou colocar o ano antes do mês, por algum motivo. Terá
que passar uma tarde inteira procurando e alterando TODOS os lugares que colou o
trecho de código. Não é uma boa ideia.

Para resolver isso, podemos criar uma função, que é como se fosse um
“contrato”. Você diz pro python: “Opa, guarde esse trecho de código (um escopo),
pois vou utiliza-lo várias vezes!”. Ficaria assim:
 Agora sim as coisas ficaram emocionantes! Eu utilizei o comando especial do
Python chamado “def” para definir que toda vez que eu digitar a palavra
“exibeData()” (precisa obrigatoriamente ter os parênteses no final, veremos para
quê no próximo tópico), eu quero executar aquele trecho de código específico. Com
isso fica fácil alterar a forma com que a data é exibida, mesmo se nosso
programinha (ou jogo) for um monstro enorme com milhares de linhas de código.
Esse é o poder das funções: poupar trabalho e permitir que você faça projetos
maiores, melhores e mais organizados.

Agora duas coisas importantes: assim como os condicionais (if, elif, else) você
precisa ter ao menos uma linha indentada no escopo da função (logo após o def).
Ou terá um erro! E você se lembra das regrinhas para nomear variáveis? Pois é, as
mesmas se aplicam para nomear suas funções.

Funções com parâmetros

Funções são incríveis, daqui a pouco você vai ver que tudo, literalmente tudo,
que você fizer dentro da programação, pode ser feito criando e utilizando uma
função. Isso ai facilitar sua vida, vai permitir que você entenda o código muito melhor
e, mais ainda: vai permitir que você reuse o mesmo código em vários projetos
diferentes. A parte mais interessante de funções é que, uma vez que ela já está
escrita, você não precisa saber como ela foi escrita (ou seja, qual o código dentro
dela) para utiliza-la. Exemplo, se eu te contar que existe uma função
desligarComputador() e que você pode utiliza-la agora (Nota: essa função não
existe), você sabe o que ela faz? Certamente sim, só pelo nome. Mas sabe como é
o código por trás dela? Não, e nem precisa saber, nunca!

Aliás, eu tenho um exemplo ainda melhor do que desligarComputador().

Quer saber qual? Esse:

Estamos utilizando a função print faz séculos nesse livro e você não faz a
menor ideia de como ela funciona. Para falar a verdade, nem eu tenho 100% de
certeza do que está acontecendo por trás dela.

Isso não importa! Uma vez que ela existe e está disponível para nós e
sabemos o que ela faz, podemos esquecer (ou nunca descobrir) com segurança
como é o código por trás. E você vai ver que a mesma regra se aplica aos seus
códigos futuros.

Isso é um forte indicador de que vale a pena continuar estudando funções.

Então vamos voltar a por as mãos na massa e aprender o que são funções com
parâmetros.

Voltando ao nosso “programinha” (ou jogo) do tópico anterior, onde criamos a

função para exibir a data, pode ser uma boa ideia ter uma mensagem curta de boas-
vindas ao nosso jogador, para ele se sentir feliz de estar jogando nosso game.

Fácil!

Mas um pouco impessoal. Talvez você queira se aproximar ainda mais do seu
jogador e personalizar essa mensagem com o nome dele. O que acha? Seria ótimo,
então como fazer?

Esses parênteses no final do nome da função, além de servirem para o

Python saber que aquilo é uma chamada de função e não uma variável qualquer,
também serve para você adicionar parâmetros. Basicamente uma forma de passar
uma variável para dentro do escopo da função. Você precisa colocar o nome do
parâmetro (nome de variável) dentro desses parênteses na hora de definir a função
com o def e passar o valor deles ao chama-la. Dessa forma:

Você também pode colocar vários parâmetros na função, é só separa-los por

vírgula. Quando eu chamei a função no exemplo acima, eu definir que nome seria
“Guilherme” (como se eu tivesse escrito, para a função, que nome = “Guilherme”).
Eu poderia chamar essa mesma função outras dez vezes depois disso passando
dez nomes diferentes, ela iria funcionar da mesma forma para cada um deles, faça o
teste em seu computador.

Funções que retornam coisas (return)

Você está quase no ponto certo para destravar e utilizar o poder máximo que
as funções irão trazer a você. Se aprender python fosse um jogo (provavelmente é),
essa aqui é a sala de mini-boss final antes do chefão da dungeon. E se você não
entendeu a referência, não se preocupe, apenas procure jogar mais RPGS. 

Já vimos para quê às funções servem e como passar parâmetros a elas, mas
precisamos entender como receber “respostas” dessas funções. Como assim?

Uma coisa que eu percebi assim que aprendi a escrever, no jardim de

infância, é que meu nome (Guilherme) é consideravelmente maior do que os outros.
São nove letras, enquanto meus amigos (Andre, Carlos, João) ficaram na casa das
cinco. E eu me lembro de ter passado um dia inteiro pensando em como eu poderia
me beneficiar de ter um nome grande. Bom, não obtive sucesso em meus
pensamentos de criança, não até agora.

Quer dizer, não até agora... Posso criar uma sala secreta em meu próximo
jogo que só jogadores com nomes grandes podem entrar. Haverá uma enorme
porta, fechada por padrão, escondendo os tesouros extras desse local.
 Isso significa que eu preciso criar uma função que recebe o nome do jogador
e verifica se ele é ou não grande, retornando True ou False, respectivamente. Assim
o código da porta pode utilizar esse valor para decidir se ela está ou não aberta.
Fazer isso é fácil, basta utilizar o comando return do python (só é permitido utiliza-lo
dentro do escopo de uma função).

Agora a variável “abrirPorta” vai ser True se o jogador tiver um nome grande
ou False, caso contrário. Isso por que ela está pegando o retorno da função.

Observe que no código há dois returns. Eles servem exatamente para isso.

Mas você precisa tomar um pouco de cuidado ao utiliza-los, precisa saber de

algo muito importante: Assim que o python encontrar um return no código, ele irá
retornar imediatamente, saindo da função e ignorando todas as linhas de código
que vem depois dentro daquele escopo. Dê uma olhada nesse exemplo para você
entender melhor:

A função exemplo() irá retornar o número um imediatamente na primeira linha

e ignorar todo o restante. Isso pode ser resolvido simplesmente trocando a ordem
das coisas. Se você quer que o print seja executado, então coloque ele antes do
return e problema resolvido.

Essa regrinha também pode nos ajudar a tornar o código do nome grande
mais simples. Observe que se o python entrar no if daquele exemplo, ele irá
obrigatoriamente retornar e não irá executar o restante da função. Em outras
palavras, eu não preciso desse “else”, posso retornar False diretamente caso ele
não entre no if:
 Essa é uma “dica” (opcional, você pode optar por ignora-la por enquanto, se
achar muito complexa) da programação: Se você tem um else depois do return, ele
é inútil, você pode tira-lo em 97% dos casos.

Antes de terminar essa parte, se você estiver lendo esse livro pela terceira
vez OU já for um ninja em python e programação, pode dizer que essa função
poderia ser simples assim:

Se você está começando agora com programação, pode ignorar esse último
exemplo se tiver achado muito complicado, é só uma melhoria “extra”.

Regra de ouro para Funções

Se o tópico anterior era o mini-boss final antes do chefão da dungeon, então
esse aqui é o chefão! E não é um conceito de programação, e sim uma “regrinha”
para te ajudar a criar boas funções.

Talvez em quando você lia os conceitos de parâmetros ou de retorno de

função, você pensou: “Mas não seria mais simples criar uma variável fora do escopo
da função e apenas altera-la lá dentro?“ Algo assim:

Esse código funciona, então porque não utiliza-lo dessa forma?

Bom lembra que eu disse que você não precisa saber nada sobre a função
para poder utiliza-la? Pois é, isso não é verdade para o exemplo anterior. Nele você
não só precisa saber o que ela faz, quais variáveis ela altera, como também precisa
garantir que você criou tais variáveis para que a função funcione. Isso é mais do que
ruim, é péssimo! Assim você não poderá desfrutar de todo o potencial das funções,
então não faça isso!

As regras de ouro são:

Primeiro: Uma função deve ser independente, ou seja, não deve depender
de outras coisas fora do escopo dela para funcionar. Veremos mais a frente que, no
máximo, ela pode depender de uma biblioteca ou da classe que ela pertence, mas
não se preocupe, pois nós vamos ver isso mais a frente. Sempre que criar sua
função, tente utilizar apenas os parâmetros da função e os valores de retorno,
jamais use variáveis fora do escopo dela.

Isso pode não ser possível em 100% dos casos, mas em 99%, sim.

Segundo: Uma função deve ter uma única responsabilidade. Porque

nossa função temNomeGrande também não abre a porta? Simplesmente por que
isso não é responsabilidade dela. Se quisermos reutilizar nosso código o máximo
possível, precisamos garantir que funções façam apenas uma coisa e façam aquilo
muito bem, independente das circunstâncias. Podemos criar outra função,
abrirPorta(porta), se for necessário. E essa função, inclusive, pode consultar a
função temNomeGrande para conferir se ela pode ou não ser aberta. O que não
pode acontecer é uma função fazendo o trabalho de outra, isso irá tornar sua vida
dez vezes pior.

Agora, vamos supor que você seja uma pessoa teimosa e mesmo com esse
conselho, fez a função temNomeGrande abrir portas. Três meses se passaram,
você nem se lembra mais disso, e decide colocar uma áurea azul em volta de todos
os itens que jogadores com nomes grandes receberem. Aí você se lembra dessa
função e decide utiliza-la para fazer a verificação do nome. Ótimo, exceto que agora
todas as vezes que o jogador receber um item, uma porta vai se abrir. Boa sorte
gastando seus neurônios para descobrir de onde vem esse “bug”.

Terceiro: Tente manter suas funções pequenas! Muitos iniciantes na

programação acham que milhares de linhas de código são muita coisa. O que eles
não sabem é que programadores experientes compartilham a mesma opinião.
Ninguém merece você ter que alterar uma função e ela ter centenas de linhas.
Sempre que possível, tente não passar de cinco ou dez linhas de código dentro de
uma função. Você vai aprender, com a prática, que se está maior do que isso,
provavelmente você está usando código duplicado (e perdendo seu tempo),
complicando mais do que deveria ou, ainda, sua função tem mais de uma
responsabilidade e poderia ser dividida duas ou mais.

Com o tempo você ficará melhor em seguir essas regras, mas é bom você tê-
las em mente desde o princípio.

Listas
Vou resumir esse tópico em uma frase e um exemplo, ou quase isso.

“Listas são variáveis que guardam uma lista de variáveis (seja já o que sejam
essas variáveis, podem ser inclusive, outras listas)”.

Se você entendeu isso (e você provavelmente deve ter entendido) tudo vai
ficar mais fácil. Mesmo assim, vou ser didático e te explicar detalhadamente:

Você utiliza colchetes “[ ]” para definir o que está dentro da lista, cada
elemento é separado por uma vírgula. Não, você não pode utilizar parênteses “( )”
nem chaves “{ }” para criar listas, pois o python vai entender isso como outra coisa.

Para obter ou definir um elemento que já está dentro da lista, utilize a

notação:

nomeDaLista[numeroDoElemento]

Aqui nós temos um fator muito importante: robôs são diferentes de nós,
python é um robô e, claro, também é diferente. Diferente como? Bom, se você pedir
alguém para contar até cinco, a pessoa provavelmente vai falar isso:

“Um, dois, três, quatro, cinco!”

Mas o Python (e a maioria dos robôs), por padrão vai fazer isso:

“Zero, um, dois, três, quatro!”

Isso mesmo, Python considera zero como o primeiro número. Então se você
quiser obter o primeiro elemento de uma lista, seguindo nossa notação, o
numeroDoElemento não é um, é zero! E se você quiser o último valor de uma lista
com cinco elementos, então o número que deve utilizar é quatro! Pode parecer
confuso, mas com a prática você irá se acostumar. Se ainda sim tiver dúvidas, é só
pensar no número do elemento normalmente (como humano) e depois subtrair um.

Vamos ver um exemplo de como podemos alterar e printar um elemento de

uma lista utilizando python:

O resultado no console será esse:

Ah, você pode exibir a lista inteira, se quiser, utilizando print(contas)

diretamente.

Como eu disse você também pode colocar uma lita dentro de outra. Nesse
caso, você primeiro acessa a sub lista e depois o elemento dela que quer obter.

E para finalizar, você também pode adicionar ou remover elementos de uma

lista, bem como verificar se uma variável está ou não dentro dela. Dê uma olhada
nesse exemplo que adiciona um bot na prisão se ele estiver fora ou tira ele de lá se
já estiver preso:

Experimente programar esse código na IDLE e executa-lo. Depois tente

adicionar a string “bot” dentro da lista prision e execute novamente.

Aliás, aproveitando o próximo tópico que iremos tratar aqui, vamos tentar
brincar um pouco mais com esse código da prisão. Vamos criar uma pequena
simulação com alguns personagens de nomes fictícios (bots) que segue a mesma
regra anterior: Sempre que um bot estiver fora da prisão, ele é preso, e sempre que
está preso, é solto. Quer dizer, não sempre, mas todas as vezes que o nome dele
for verificado na prisão.

Para fazer isso, você vai precisar criar uma função de verificação, que tem
exatamente essa lógica anterior do if e do else. Tente pausar sua leitura por um
momento e fazer esse exercício.

Dicas: Lembre-se de que você não deve utilizar as variáveis fora do escopo
da função, adicione parâmetros para a prisão e nome do bot ao invés disso.
Também não é uma boa ideia tentar criar a variável prisão dentro da função, pois ela
deixará de existir toda vez que o python terminar de executar o código da função
(saiu do escopo) e o código não irá funcionar.

Se seu código se pareceu com isso, então você está indo bem. Abaixo há o
código (direita) e o que ele exibiu na tela após ser executado na IDLE do Python
(esquerda).
Classes
Na página anterior, brincamos com o código da prisão para criar uma
pequena simulação com alguns nomes fictícios. Se você tinha parado de ler o livro
depois dessa página e está retomando agora, recomendo que volte a ela para
relembrar as regras da simulação.

Certo, agora outro lembrete: eu disse anteriormente que é uma boa ideia
fazer funções que tenham uma única responsabilidade, se lembra?

Vou te fazer uma pergunta baseado nisso tudo:

A responsabilidade de prender ou soltar um bot faz mais sentido ser de

uma função ou da prisão em si?

Bom, faz mais sentido que a prisão cuide disso, mas infelizmente a prisão, no
aso do nosso exemplo, é só uma lista, só uma variável... Não tem a capacidade de
executar código. Agora, seria realmente perfeito se nossa variável prisão tivesse
uma função dentro dela que cuidasse disso.

E é exatamente aqui que surge o conceito de “Orientação a Objetos”. Ou

“classes”, para os íntimos. Um objeto, dentro da programação, é como se fosse uma
“super variável”, que pode ter outras variáveis e funções (nesse caso, as funções
são chamadas de métodos) dentro dela.
 Para criar um objeto, você primeiro precisa definir um contrato, o eu
chamamos de “classe de objeto”, que é como se fosse uma planta de uma casa:
Define tudo, exatamente tudo que aquele objeto vai ter (você pode criar vários
objetos diferentes usando o mesmo contrato, assim como o governo construí
aquelas casinhas iguais eventualmente) e todos os seus comportamentos. Em
outras palavras, dentro desse contrato (classe) deve ter todas as variáveis e todas
as funções (chamadas de métodos) que você quer para o objeto.

No caso de nossa prisão, por exemplo, tudo que ela precisa ter de variável é
uma lista com o nome dos prisioneiros, para verificarmos se algum bot está ou não
preso nela. Quanto às funções (métodos) da prisão, ela só precisa da nossa função
de verify, que verifica se um bot está preso e se sim, solta e se não, prende.

Vou te mostrar como esse contrato (classe) seria escrito e depois iremos
entender os detalhes.

Certo. Agora vamos com calma, entender exatamente o que fizemos nesse
contrato.

Primeiro nós utilizamos a notação class para dizer ao python que estamos
definindo o contrato de um objeto no escopo a seguir (perceba que tudo foi
indentado para pertencer a essa classe), da mesma forma que fizemos com as
funções. Depois definimos um nome para nossa classe (contrato), no caso, “Prision”
e terminamos a linha com parênteses () e dois pontos. Os parênteses servem para
uma coisa chamada herança, mas não vamos nos preocupar com isso agora,
combinado?
 Depois, dentro do escopo da classe, definimos os contratos para todos os
métodos (funções) que pertencem à classe. A única coisa nova aqui é que todas as
funções da classe devem receber, obrigatoriamente, um parâmetro chamado self.
E ele precisa ser o primeiro parâmetro. Você não precisa se preocupar em passa-lo
ao python quando chamar qualquer função do objeto (veremos em breve como
chamar essas funções). Isso serve única e exclusivamente para o Python saber que
aquela função se refere a um objeto (nossa “super variável”) e a qual. Basta colocar
o self ali e esquece-lo.

Agora um método (função) estranho que criamos é esse __init__ (dois

underlines no começo, dois no final). O que é isso? Bom, como eu disse, o que
estamos fazendo aqui não é criar nossa prisão, mas dizer ao Python como ela seria
e quais os seus comportamentos (funções). Esse é apenas um contrato. Quando
nós criarmos, de fato, um objeto da nossa prisão, o python irá utilizar esse contrato
para criar tudo para nós. E assim que ele fizer isso, imediatamente irá chamar esse
método __init__, automaticamente. Isso é chamado, na programação, de
Construtor de classe. Dentro desse construtor você pode definir exatamente quais
são as variáveis que sua classe deve ter. Assim como nas funções (métodos) da
classe, para que o python saiba que você está se referindo a uma variável da classe,
você deve utilizar sempre o “self.” antes do nome da variável. Caso contrário, o
Python irá considera-la como uma variável qualquer.

Volte no código da classe e perceba que, na função verify, eu utilizei

self.prisoners para acessar a lista de prisioneiros.

Eu disse, anteriormente, que é uma boa prática que uma função não acesse
variáveis fora de seu escopo. Mas também disse que isso é um pouco diferente em
classes. Bom, graças a esse conceito de “Orientação a Objetos” (classes), um
método (função) de uma classe pode e deve, sempre que necessário, utilizar as
variáveis e outras funções que pertencem à mesma classe.

Agora o jogo virou a nosso favor!

Bom, eu disse que isso que fizemos é apenas um contrato, não é uma prisão
de verdade (ou o que chamamos de instância da classe). Como acessamos ou
chamamos a função verify agora? Não chamamos! Pois você não pode acessar
isso diretamente do contrato (salvo exceções que não vem ao caso), você primeiro
precisa construir o objeto! Onde já se viu querer prender alguém tendo apenas a
planta baixa da prisão? 

Por sorte, é fácil assim criar uma instância da nossa prisão (objeto):

Quando o Python ler isso, imediatamente ele vai pegar nosso contrato
(definido com o class) e colocar todas as variáveis e funções (métodos) dentro de
“statePrision”, na forma de uma instância de classe, e vai chamar o construtor da
classe, o estranho e famoso método __init__. Se você quiser testar, implemente
esse código e adicione um print(“Uma prisão foi criada!”) em algum lugar do
construtor da classe. Verá essa mensagem ser exibida toda vez que você “construir”
uma nova prisão. E por falar em nova prisão, sim, agora é simples assim criar novas
prisões:

Cada uma delas vai ser construída pelo Python com todas as funções e
variáveis que definimos em nosso contrato de classe. Ou seja: todas terão uma lista
individual de prisioneiros e uma função de verificação para chamarmos sempre que
quiser. Uma prisão não irá afetar nem alterar a outra.

E como acessar os métodos (funções) e variáveis de uma instância de

classe? É simples:

Você digita o nome da instância da classe, depois um ponto e, finalmente, o

nome da função ou variável que deseja.
 A parte legal de utilizar classes é que você pode melhorar ainda mais aqueles
conceitos de deixar suas funções (ou métodos) pequenas e com uma única
responsabilidade. Por exemplo, em nosso código, o método verify também é
responsável por adicionar ou remover o prisioneiro. Também cuida de ver se ele já
está preso. Várias responsabilidades...

E isso pode terminar gerando código duplicado e te dando mais trabalho. Por
exemplo, e se você quiser, logo após a prisão statePrision for criada, já adicionar
“John” em uma cela? Terá de fazer manualmente um
statePrision.prisoners.append(“John”). Mas e quanto à mensagem (print) que
deveria aparecer quando alguém entrar na prisão? Terá que duplicar seu código.

Código duplicado só dá problema, então podemos dividir isso, de modo que a

prisão também tenha funções prontas para adicionar e/ou remover um prisioneiro.
Fazendo isso, podemos escolher tranquilamente o que acontece ao adicionar ou
remover alguém. Alterando nossa classe assim é o suficiente:

Agora, se você quiser adicionar um prisioneiro em statePrision, basta utilizar

o comando statePrision.addPrisoner(“John”) que ele fará tudo para você.

Perceba, também, que nesse código onde definimos o contrato eu chamo

funções de dentro da própria classe utilizando o self. antes do nome. Você deve
utilizar esse prefixo quando estiver tratando da própria classe e dentro dela mesma.
 Para encerrar nosso assunto sobre classes, há uma última coisa que é
interessante você saber: Um construtor (método __init__) também pode receber
parâmetros. Por exemplo, vamos criar uma classe Human para nossos bots. Esses
humanos não tem nada além de um nome. É simples assim:

Como exercício, tente modificar o código de nossa simulação de prisão para

que ele funcione com instâncias da classe Human ao invés de strings com os
nomes dos prisioneiros. E se quiser ainda mais exercícios, adicione um contador no
construtor da classe humano para contar quantas vezes ele já foi preso (começando
em zero).

Bibliotecas
Agora vamos entender a última peça de nosso quebra cabeça de introdução
ao Python: bibliotecas. E nada melhor para entender algo do que fazendo esse algo,
por isso você vai criar, agora, sua primeira biblioteca.

Eu falei algumas vezes aqui sobre reutilizar código. Mas como fazer isso, de
verdade, em vários projetos diferentes? Você se lembra do código da simulação de
prisão que fizemos anteriormente? Pois é, vamos altera-lo para que a classe Prision
possa ser utilizada em vários locais e projetos diferentes. Em outras palavras, vamos
coloca-las em um arquivo separado, de modo que possamos importa-la sempre que
quisermos utilizando esse arquivo.

Crie uma nova pasta vazia e soeu computador e salve dois arquivos nela:
prision.py e main.py. Se você não se lembra de como criar arquivos python, basta
abrir a IDLE e criar aqui e depois salvar com Ctrl + S:
 Sua pasta vai ficar com os dois arquivos, dessa forma:

Certo, agora no arquivo prision.py, que será nossa biblioteca, você vai
colocar o código do contrato da classe Prision que criamos anteriormente (se
quiser, pode voltar uma ou duas páginas para vê-lo novamente). Não crie nenhuma
instância da classe dentro desse arquivo, deixe apenas o contrato, de forma que,
sempre que quiser usar o código, basta você copiar o prision.py e colar em seu
novo projeto.

No arquivo main.py (main, do inglês, “principal”, primeiro, mais importante,

essencial, esse nome, main, é bem utilizado na programação para dizer que é onde
o código principal se inicia), você vai programar a simulação normalmente, criar a
instância da prisão e simular as verificações dos bots. Mas antes, você precisa
importar sua nova biblioteca. Por padrão, importamos bibliotecas em python nas
primeiras linhas do arquivo (não importe nada no meio do código, é feio e difícil de
entender, deixe sempre no início) e utilizamos o comando import, com algumas
variações em seu uso.

Nosso código do main, utilizando o import, fica assim:

Você pode testar em seu computador para conferir que tudo está funcionando
corretamente. Só tem uma diferença do que já fizemos antes: Perceba que eu tive
que digitar prision.Prision() para construir a instância da classe da prisão.

Por quê?
 Porque o Python vai importar tudo que estiver dentro do prision.py, mas é
como se ele deixasse isso em um escopo diferente, que é uma forma de manter as
coisas seguras e sob controle (imagina se dentro da biblioteca que você está
importando tenha uma variável com o mesmo nome de uma que já está dentro do
seu código? Qual delas o python vai usar? Isso geralmente é inseguro). Em outras
linguagens, algo parecido com isso é chamado de namespace, só por curiosidade.
Então antes de acessar o contrato do Prision, você precisa especificar que é
daquela biblioteca. Inclusive, você pode até mesmo dar um “apelido” a
biblioteca/arquivo com o comando as:

E se você tiver certeza do que tem naquela biblioteca e que não há nada em
conflito dentro do eu código, você pode importar uma ou mais coisas específicas
dela através do from, assim poderá utilizar seus nomes diretamente, sem prefixos:

E você pode importar mais de uma coisa daquele arquivo separando por
vírgula:

from biblioteca import ItemA, ItemB

Ou tudo do arquivo, utilizando *:

from biblioteca import *

Isso que você acabou de aprender a criar costuma ser chamado de

biblioteca, mas há um nome ainda mais específico: módulo. Um arquivo que você
importa para utilizar seja criado por você ou por outra pessoa (ou nativo do python,
pois você vai descobrir que a própria linguagem te dá vários) pode ser chamado de
módulo.

Então o que raios é uma biblioteca?

 É um conjunto de módulos. Mesmo que só um, como o que acabamos de
fazer com o prision.py.

O python de tá vários módulos “de presente” para você criar seus códigos.
Um deles, que é bem usado, é o de matemática, ou math, para os íntimos. Um
exemplo prático e bem simples de como, quando e onde utiliza-lo:

Quer saber qual o valor do seno de um número? Basta utilizar a função sin(x)
do módulo math do python:

(O resultado é aproximadamente -0.9165, caso você tenha curiosidade).

Bom, essa foi à introdução ao python. É claro, eu poderia escrever 16 livros

de 800 páginas cada um te explicando todos os detalhes da linguagem, mas para
você começar a se aventurar no desenvolvimento de jogos, os conceitos que passei
aqui são mais do que o suficiente. Com o tempo e o avanço dos seus estudos, você
irá praticar e pegar mais conceitos (como herança de classe). Não se esqueça:
Python é como um músculo, você precisa praticar.

Então vamos por as mãos na massa!