Seguindo a linha de posts extras anteriores, e inspirado pelo tópico de jogos, vou abordar muitos tópicos não vistos ainda pra fazer esse jogo da velha, mas como a intenção desses tópicos extras é tornar o aprendizado de programação algo mais divertido ou de mostrar a aplicabilidade de programação na vida real, vamos nessa:
Primeiro, vou usar muitas funções pra criar meu jogo. Funções são blocos de código que podem ser reaproveitados em nosso programa, que recebem argumentos, fazem algum processo com esses argumentos e podem retornar um valor ou não.
Se ficou confuso, nada melhor do que mostrar em código:
# A definição de funções em Python é feita por meio da palavra reservada "def"
>>> def soma_dois(x):
return x + 2
>>> soma_dois(2)
4
# soma_dois é uma função que recebe um argumento x e retorna a soma desse argumento com o número 2
Ou seja, explicando em miúdos. Defini a função com nome de "soma_dois" e disse que ela receberia um argumento x, e retornaria esse argumento x somado do número 2.
Em seguida eu chamei a função por meio do comando "soma_dois(2)", passei 2 como argumento.
Então o meu x é igual a 2. Se o retorno da função é x + 2, então 2 + 2 = 4.
Outros exemplos pra ficar mais claro:
>>> def soma_dois(x):
return x + 2
>>> def divide_por_dois(y):
return y / 2
>>> def multiplica_por_10(a):
return a * 10
>>> soma_dois(15)
17
>>> divide_por_dois(10)
5.0
>>> multiplica_por_10(5)
50
Se não está tão claro ainda, vai haver ainda muita explicação sobre funções na parte teórica mais à frente.
O fato de minha função retornar um valor significa que eu posso fazer qualquer coisa com o valor retornado por essa função:
>>> valor = soma_dois(10)
>>> valor
12
>>> valor = valor / 3
>>> valor
4.0
E minhas funções podem inclusive não retornar nada e não receber nada como argumento, mas mesmo assim preciso adicionar os parênteses no fim do nome da função:
>>> def da_bom_dia():
print('bom dia!')
>>> da_bom_dia()
bom dia!
Nesse caso eu não posso atribuir nenhuma variável ao retorno da função já que ela não me retorna nada, só manda um simples print na tela.
Pra começar a fazer o jogo, também preciso falar de dicionários. Dicionários são uma estrutura da linguagem parecidas com listas, mas que acessamos os seus valores não pelos seus índices mas sim por suas chaves.
>>> # Se vocês lembrarem das listas, acessamos um valor da lista pelo seu índice
>>> lista = [1, 2, 3, 4]
>>> lista[0]
1
Já os dicionários recebem não só um valor por vez mas sim o valor e sua chave ou sua key. São definidos por meio de chaves ({}):
>>> meu_dicionario = {'numero1': 1, 'numero2': 2, 'numero3': 3}
>>> meu_dicionario['numero1']
1
Eu também posso varrer um dicionário usando um laço "for". Posso tanto escolher varrer somente as chaves, ou somente os valores, ou varrer todos os items:
In [11]: meu_dicionario = {'numero1': 1, 'numero2': 2, 'numero3': 3}
In [12]: for key in meu_dicionario.keys():
...: print(key)
...:
numero1
numero2
numero3
In [13]: for value in meu_dicionario.values():
...: print(value)
...:
1
2
3
In [15]: for key, value in meu_dicionario.items():
...: print(key, value)
...:
numero1 1
numero2 2
numero3 3
Também não se preocupem muito com dicionários agora pois vamos chegar lá.
Inclusive meus dicionários podem ser argumentos passados para uma função. Em Python chamamos isso de kwargs, que é simplesmente dizer que estou passando um dicionário como parâmetro de uma função. Nesse caso, precisamos adicionar dois asteriscos antes do nome do argumento:
>>> meu_dicionario = {'numero1': 1, 'numero2': 2, 'numero3': 3}
>>> def funcao_que_recebe_dicionario(**dicionario):
print(dicionario)
>>> funcao_que_recebe_dicionario(**meu_dicionario)
{'numero1': 1, 'numero2': 2, 'numero3': 3}
Por fim, para começarmos a escrever o código de nosso jogo, preciso falar de laço while. Eu dei uma pincelada sobre o laço "for" nos tópicos extras anteriores, e existe também o while. Em português simples, o que eu quero de um while:
enquanto algo for verdade:
faça alguma coisa
Em Python:
>>> x = 0
>>> while x < 10:
print(x)
x += 1
0
1
2
3
4
5
6
7
8
9
Inclusive eu posso interromper meu laço quando eu quiser por meio do comando "break":
x = 0
while x < 10:
if x == 5:
print('Parei antes da hora, achei o 5')
break
else:
print(x)
x += 1
# Resultado
# 0
# 1
# 2
# 3
# 4
# Parei antes da hora, achei o 5
Eu também posso criar um loop eterno com o while, que não termina nunca até que eu defina uma condição de parada. No nosso caso acima, a condição de parada era x ser maior ou igual a 10. Caso eu queria um loop infinito, posso definir dessa forma:
# Este programa não tem fim
In [20]: while True:
...: print(x)
...: x += 1
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
...
# Este programa tem fim
In [23]: while True:
...: print(x)
...: if x == 10:
...: break
...: else:
...: x += 1
...:
0
1
2
3
4
5
6
7
8
9
10
Sei que também não falei de condicionais ainda (esse bloco de if e else), mas vamos chegar lá também. Basicamente o que o if e o else fazem aí é que se (if) x for igual a 5, o programa faz alguma coisa, e se não for igual a 5 (else), ele faz outra coisa.
Enfim, isso tudo foi pra começar a escrever o nosso jogo da velha. Como este é um tópico extra, não dissequei muito sobre a teoria da coisa, então fiquem tranquilos que a gente vai chegar lá. A ideia do tópico é mostrar um joguinho feito em Python em ação, e faremos ele na parte 2 deste tópico.
EDIT: Pra não ter que abrir um novo tópico pra falar mais detalhes teóricos sobre o nosso jogo, decidi me estender por aqui.
Não detalhei nada sobre o bloco "if - else", e acho legal comentar já que não comentamos nada ainda sobre condicionais:
O "if" quer dizer "se" e o "else" quer dizer "senão".
Então, em português, seria algo como:
se algo for verdade:
faça algo
senão:
faça outra coisa
E em Python:
In [1]: x = 10
In [2]: if x > 5:
...: print('x é maior que 5')
...: else:
...: print('x é menor que 5')
...:
x é maior que 5
Para nosso joguinho, irei também usar o operador lógico de igualdade. O operador lógico de igualdade não é um sinal de igualdade da matemática, e sim dois sinais de igualdade. Abaixo um exemplo de uso de operadores lógicos:
In [3]: x == 10
Out[3]: True
In [4]: x < 5
Out[4]: False
In [5]: x > 5
Out[5]: True
# <= é o sinal matemático de menor ou igual a que
In [6]: x <= 10
Out[6]: True
# >= é o sinal matemático de maior ou igual a que
In [7]: x >= 10
Out[7]: True
Cuidado pra não confundir o operador lógico de igualdade com o operador de atribuição de variável:
# Usando o operador lógico de igualdade
In [8]: 10 == 10
Out[8]: True
# Usando o operador de atribuição de variável
In [9]: x = 10
In [10]: x
Out[10]: 10
Enfim, acho que já temos o necessário para criar nosso jogo da velha.
