Retomando os Trabalhos!

Olá pessoal! Faz algum tempo que não atualizo o blog, é que estive muiiittoooo ocupado com o trabalho...

Bom, hoje vou começar a entrar nos detalhes do nosso projeto, finalmente! Vou falar um pouco do pygame, a biblioteca Python utilizada no desenvolvimento de jogos. Esta biblioteca irá nos fornecer praticamente tudo o que precisamos para desenvolver um jogo em Python, no que se diz respeito a parte programática da coisa.

Como é sabido, na história do desenvolvimento de jogos quase sempre se utilizam linguagens de baixo nível, tais como C/C++. Isto ocorre devido ao fato da necessidade de desempenho que está implícita na programação de jogos.

No entanto, tal desempenho vem com um custo. O desenvolvedor passa a ter que tratar de detalhes que não têm relação com o desenvolvimento do jogo propriamente dito, tais como o gerenciamento de memória e o tratamento de erros. Outro detalhe é que no desenvolvimento de jogos sempre temos algumas características que estão sempre presentes, tais como os sprites - figuras animadas ou não, e as rotinas que manipulam estes sprites, utilização de sons, recursos de rede, etc. Tendo isto em mente, surgiram várias bibliotecas dedicadas a facilitar a vida dos desenvolvedores de jogos, oferecendo o suporte básico a tais funcionalidades. Este é o caso da biblioteca SDL, a qual é a base da biblioteca pygame.

Ou seja, temos a biblioteca SDL, totalmente otimizada para linguagens de baixo nível, e temos o pygame, que possibilita o acesso a SDL através da linguagem Python. Isto torna o desenvolvimento de jogos utilizando Python uma realidade, já que temos apenas que nos preocupar com a criação do jogo em si, e, uma vez que com Python temos uma forma simples de expressar nossas ideias, deixando os detalhes de baixo nível para o pygame, podemos focar apenas na parte criativa.

Conceitos Básicos

O loop principal de um jogo é bastante simples. Basicamente temos que tratar os eventos, tais como o movimento do mouse ou uma tecla ser pressionada ou a recepção de dados via rede, executar a inteligência artificial e então o desenho do plano de fundo e de personagens visíveis. Vejamos abaixo como isso é feito de um modo geral:

01. Inicializar estruturas internas
02. Carregar dados do jogo
03. Repetir:
04.    Capturar e tratar eventos
05.    Executar a inteligência artificial
06.    Desenhar plano de fundo
07.    Desenhar personagems
08.    Emitir sons se necessário
09. Terminar o loop se o usuário deseja terminar o jogo.

Este pseudo código resume o laço principal de qualquer jogo, por mais avançado que seja, sempre terá um loop parecido com este.

No próximo post pretendo mostrar os passo para a criação de um jogo bem simples, onde o jogador controla uma nave espacial e deve derrotar os inimigos, no estilo "vertical scroller", ou seja, os inimigos irão aparecer no topo da tela e seguirão para baixo tentando acertar a nave do jogador. Espero postar uma primeira parte ainda hoje, ou no máximo amanhã. Então fiquem ligado!

Herança

Esta semana vou falar sobre mais um tópico relativo a orientação a objetos: herança.

Herança consiste em fazer com que uma classe "herde" os atributos e métodos de uma outra classe, podendo reescrevê-los ou adicionar funcionalidade à estes.

Vamos a um exemplo prático, a partir da classe que especificamos anteriormente:

# coding: utf-8
# mamifero.py

class Mamifero:
    
    def som(self):
        print 'emitir um som'

class Homem(Mamifero):
        
    def som(self):
        print 'Oi!'

class Cachorro(Mamifero):
    
    def som(self):
        print 'Wufff! Wufff!'

class Gato(Mamifero):
    
    def som(self):
        print 'Meawwwww!'

mamifero = Mamifero()
mamifero.som()

animais = [Homem(), Cachorro(), Gato()]

for animal in animais:
    animal.som()
    

No código acima, criamos 3 classes onde estas herdam os atributos da classe "Mamifero". Neste caso estou demonstrando como podemos reescrever os métodos de uma classe para alterar o funcionamento deste numa classe mais específica.

Ao executar o código acima, no "for" mais abaixo no código, percorreremos uma lista de animais, chamando o método "som()" para cada um deles. Como cada animal foi criado a partir de uma classe específica, o método desta classe mais específica é chamado, e não o da classe mais genérica, "Mamifero". Sendo assim, o som emitido será o que nós esperamos.

Estou indo devagar nesta introdução à classes por este ser um tópico que causa muita confusão nos programadores iniciantes, mas que após um certo tempo de prática se mostra um paradigma interessante e fácil de lidar no dia a dia, tornando a abstração de problemas reais em algoritmos mais simples.

Solução do problema 3n + 1

Olá pessoal! Hoje trago a solução do problema 3n + 1 proposto no início da semana. Então vamos direto a ela:

# coding: utf8
# seq_3n1.py

resolvidos = {1: 1}

def solucionar(a, b):
    maior = 0
    while a <= b:
        num = calc_seq(a)
        if num > maior:
            maior = num
        a += 1

    return maior

def calc_seq(a):
    if a in resolvidos:
        return resolvidos[a]
    if (a % 2) == 0:
        new_a = a / 2
    else:
        new_a = 3 * a + 1
        
    passos = 1 + calc_seq(new_a)
    resolvidos[a] = passos 
    return passos
    
if __name__ == '__main__':
    maior = solucionar(1, 10)
    print "A maior sequencia gerado por um número entre 1 e 10 tem tamanho:", maior
    
    maior = solucionar(100, 200)
    print "A maior sequencia gerado por um número entre 100 e 200 tem tamanho:", maior
    
    maior = solucionar(201, 210)
    print "A maior sequencia gerado por um número entre 201 e 210 tem tamanho:", maior
    
    maior = solucionar(900, 1000)
    print "A maior sequencia gerado por um número entre 900 e 1000 tem tamanho:", maior   

Note que, para calcular a sequencia, utilizo uma função recursiva. Esta função primeiro verifica se já sabemos o tamanho da cadeia para o número que estamos procurando no dicionário "resolvidos". Caso este valor não esteja presente, calculamos o próximo elemento da sequencia e atribuímos o tamanho da sequencia como sendo o tamanho da sequencia do proximo elemente acrescido de 1, salvando este tamanho no dicionário.

Você pode estar se perguntando qual a razão de utilizarmos este dicionário, mas a razão é de simplesmente evitar cálculos repetidos. Inevitavelmente, quando estivermos calculando todas as sequencias de 100 a 200, por exemplo, iremos nos encontrar recalculando a mesma sequencia inúmeras vezes. Mas, se já tivermos calculado uma sequencia anteriormente, podemos simplesmente consultar o tamanho da sequencia gerada no dicionário, o que nos salvará um tempo precioso.

Bom, é isto. Como vocês podem notar, a solução é bastante simples e, com a ajuda de um dicionário, uma estrutura de dados valiosa que temos presente na linguagem Python, foi possível evitar um problema que frequentemente nos deparamos ao utilizar funções recursivas, que é a repetição de cálculos.

Espero ter sido claro na minha explicação e, como sempre, se tiverem dúvidas fiquem a vontade para enviar comentários. Até o próximo post!

Funções Recursivas

Hoje vou entrar num assunto que costuma espantar algumas pessoas, mas que pode ser bastante útil na criação de algoritmos para a resolução de problemas computacionais: as funções recursivas.

Funções recursivas são funções que chamam a si mesma de forma que, para resolver um problema maior, utiliza a recursão para chegar as unidades básicas do problema em questão e então calcular o resultado final.

Hmm... Ainda parece difícil de entender, certo? Bom, vamos ver como isto se aplica na prática. Voltamos ao nosso primeiro problema: a sequencia de Fibonacci. Nela nós temos dois casos base: O primeiro elemento da sequencia sempre é 1, assim como o segundo elemento da sequencia também é sempre 1.

Temos então o caso base. Para calcular os demais, utilizamos o seguinte parâmetro: o valor "i" da sequencia será o valor "i-1" da sequencia somado ao valor "i-2" da sequencia. Ou seja: fibonacci(i) = fibonacci(i - 1) + fibonacci(i - 2). Perceberam como podemos recorrer à própria funcão para calcular o valor de um elemento da sequencia? Vejamos como isto se traduz em código Python:

# coding: utf-8
# fib_recursivo.py

def fibonacci(indice):
    if indice == 1 or indice == 2:
        return 1
    return fibonacci(indice - 1) + fibonacci(i - 2)

A função agora ficou bem mais simples de entender que as versões anteriores com "for" e "while", certo? Pelo menos para mim esta forma é bem mais legível e podemos perceber diretamente como é o seu funcionamento. No entanto, as funções recursivas embutem alguns problemas. Pois é! Nem tudo é maravilhas no mundo de Alice!

A esta altura, você já sabe de algum problema que acontecerá com esta função?

Bom, o primeiro problema está na repetição do cálculo do mesmo valor. Vejamos um exemplo: calcular o quinto valor da sequencia.

1 =>                      x    =           fibonacci(5)
                                        /                 \
2 =>                      x    = fibonacci(4)    +       fibonacci(3)
                                  /       \                /        \
3 =>             x =   fibonacci(3) + fibonacci(2) + fibonacci(2) + fibonacci(1)
...
...

Perceba que, no passo 2 precisamos calcular o fibonacci(4) e o fibonacci(3). Então, no passo 3, precisamos calcular novamente o fibonacci(3) para encontrar o valor do fibonacci(4) do passo 2.

Mas existem outro problema com as funções recursivas. A pilha de chamadas não pode ser infinita, e alguns compiladores ou interpretadores limita o número máximo de chamadas a funções na pilha. Explico: Quando chamamos fibonacci(5), esta chamada irá chamar primeiramente fibonacci(4), sendo assim, a primeria chamada é colocada numa pilha e o controle passa para a segunda chamada. Então, fibonacci(4) chama fibonacci(3), sendo colocada também na pilha enquanto fibonacci(3) assume o controle. Agora imagine que você chamou fibonacci(1000). Quando a chamada chegar a fibonacci(2) serão 998 chamadas de função na pilha, sem contar que cada chamada ainda irá chamar uma segunda ramificação. Se você tentar desenhar uma árvove com as chamadas, verá que a coisa fica bem complexa.

Então meu conselho é o seguinte: use funções recursivas com cautela. Elas são ótimas para solucionar vários tipos de problemas, mas se você notar que a função está duplicando o trabalho ou que a pilha de chamadas será muito grande de acordo com o grau de recursividade, tente uma nova estratégia, como utilizar um algoritmo linear, sem recursão.

Para o exercício hoje vou fazer um pouco diferente. Vou propor um exercício simples e um desafio, um pouco mais complexo. O exercício é escrever um módulo com duas funções: a primeira calcula o fatorial de um número de forma recursiva e a segunda efetua o mesmo cálculo de forma linear, sem recursão.

O desafio é escrever um módulo que calcula a solução do problema da Torre de Hanoi. Tal solução pode ser encontrada de forma simples mas engenhosa utilizando recursão.

Para quem não conhece, a Torre de Hanoi consiste em ter 3 pinos onde no primeiro pino são postos "n" anéis de tamanhos decrescente. O problema é mover todos os "n" anéis para um pino destino, utilizando o terceiro pino como auxiliar, movendo sempre apenas um anel por vez e com a restrição de que num pino não se pode ter um anel menor abaixo de um anel maior.

É isto! Ainda nesta semana post a solução dos exercícios e do desafio. Até a próxima!

Solução do Problema Proposto: conversor.py

Bom Dia! No post anterior eu propus um problema que consistia em escrever um módulo para converter temperaturas entre graus Celsius e graus Fahrenheit. Hoje vou postar uma solução. Vejamos abaixo:

# coding: utf-8
# conversor.py

def celsius_para_fahr(graus):
    # a fórmula pode ser encontrada em:
    # http://www.albireo.ch/temperatureconverter/formula.htm
    graus_fahr = graus * 9.0 / 5.0 + 32.0
    return graus_fahr

Para testarmos nosso módulo, vamos escrever um outro módulo: "testa_conversor.py"

# !/bin/env python
# coding: utf-8
# testa_conversor.py

import conversor

def testes():
    pares = [(0.0, 32.0), (100.0, 212.0), (32.0, 89.6), 
             (38.0, 100.4), (20.0, 68.0)]
    
    for celsius, fahr in pares:
        calculado = conversor.celsius_para_fahr(celsius)
        if calculado != fahr:
            print "A função retornou um resultado inesperado na conversão do valor:", celsius
            print "O resultado esperado era:", fahr, " e o calculado foi:", calculado
        else:
            print "OK!"

if __name__ == '__main__':
    testes()

No módulo de teste incluí mais alguns detalhes que merecem uma explicação mais detalhada. No final do módulo podemos ver um "if" que testa de a variável "__name__" é igual à string "__main__" e, caso seja, chama a função "testes()". Não, isto não é magia negra... Acontece que em Python, algumas variáveis especiais são definidas pelo interpretador no momento que este importa o módulo. Neste caso, a variável "__name__" será definida como a string "__main__" quando o módulo for o mesmo que foi passado na linha de comando para execução, ou seja, quando executamos: python testa_conversor.py.

Outro detalhe é que definimos uma lista de tuplas com as temperaturas que queremos testar e utilizamos esta lista no "for". Como o "for" retorna cada elemento da lista utilizada e, neste caso, cada elemento é uma tupla que contém dois elementos, podemos tirar vantagem do "desempacotamento automático" que a linguagem nos oferece, atribuindo cada elemento da tupla a uma variável. Ou seja, no primeiro passo da iteração "for", a variável "celsius" receberá o valor do primeiro elemento da tupla e a variável "fahr" receberá o valor do segundo elemento da tupla, que são 0.0 e 32.0, respectivamente. Isto facilita em muito a codificação e dá um poder especial ao "for".

Outra coisa que não expliquei em posts anteriores é o funcionamento do comando "if". Tal comando funciona para a execução condicional de um bloco de operações. Ele testa uma condição e, caso esta retorne um valor que possa ser avaliado como "verdadeiro", o primeiro bloco do "if" é executado. No comando "if", opcionalmente, podemos especificar um segundo bloco de operações que deve ser executado caso a condição seja avaliada como "falsa". Isto pode ser realizado através do "else". Existe ainda uma terceira operação, o "elif", mas vou deixar para explicar o funcionamento deste num post futuro.

Bom pessoal, é isto! Ainda esta semana publico mais um post do nosso tutorial!

Utilizando Módulos

Nesta semana vou explicar um pouco de como Python lida com módulos .

Os "módulos" são os arquivos que nós criamos cujo conteúdo são as linhas de código do nosso programa. Para a linguagem Python, tais arquivos devem terminar com a extensão ".py", por exemplo: "modulo1.py", "alunos.py", "cliente.py", etc.

Para criar tais arquivos, você pode usar um editor de texto, tal como o Notepad no Windows, ou o Vim no Linux e demais sistemas Unix. O meu predileto, no linux, é o Vim. Já no Windows não tenho um predileto, pulava de um para outro de tempos em tempos. Um dos bons editores que encontrei é o Komodo Edit, da ActiveState.

Tais editores são melhores que os editores do tipo Notepad por oferecerem variadas funções para auxiliar na programação, tais como auto-completar palavras chave e colorir o código para melhor leitura e entendimento do mesmo, além de indicar possíveis erros de digitação.

Vou utilizar o exemplo da semana passada e escrever um módulo que imprime os 100 primeiros números da sequência de Fibonacci:

#!/bin/env python
# coding: utf-8

a = 1
b = 1
print "Os 100 primeiros números de Fibonacci são:", a, b,
for k in range(98):
    print a + b,
    a, b = b, a + b

Salve estas linhas num arquivo, "c:\tutorial-python\fibonacci.py" por exemplo, se você está no Windows, ou "~/tutorial-python/fibonacci.py" no caso de você utilizar Linux.

Espero que os usuário Linux estejam familiarizados com o terminal. Para os usuários Windows, este não é tão comum, portanto vou explicar como chegar até ele: Clique no menu "Iniciar", depois "Executar...". Na caixa de diálogo que aparece, digite "cmd", sem as aspas, e clique "Ok". Uma janela preta aparecerá. Este é o terminal! Para navegar nas pastas do seu computador, utilize o comando "cd". Este comando funciona da mesma forma, tanto no Linux quanto no Windows. No caso do Windows, digite:

cd \tutorial-python

No caso do Linux:

cd ~/tutorial-python

Para executar o arquivo, digite:

python fibonacci.py

Se você está no Windows, provavelmente obterá um erro parecido com "comando não encontrado". Isto se deve ao fato de o interpretador Python não estar nos caminhos que o Windows busca os comandos por padrão. Você pode resolver isto de duas formas:

• Adicionar o caminho da pasta "c:\Python25" entre as pastas de busca padrão do Windows, algo para usuários mais experientes
• Utilizar o caminho completo sempre que for executar um arquivo

Para utilizar o caminho completo, você deve executar o arquivo da seguinte forma:

c:\python25\python fibonacci.py

No entanto, no caso do Windows, quando você instala o interpretador Python este registra automaticamente a extensão ".py" como executável. Sendo assim, você também pode executar o arquivo digitando apenas:

fibonacci.py

O leitor atento deve ter notado uma linha estranha no código acima: # coding: utf-8. Esta linha indica que a codificação do texto do arquivo é UTF-8, o que permite o uso de caracteres acentuados no código. Por isso, recomendo sempre adicionar esta linha no cabeçalho de seus módulos. Mesmo que você esteja escrevendo um programa totalmente em Inglês.

Existem algumas vantagens óbvias de se programar escrevendo arquivos e não diretamente no interpretador como nós utilizamos até agora. Uma delas é que, ao se encerrar o interpretador, qualquer código que você tenha escrito estará perdido. Já utilizando arquivos, tudo está salvo, podendo ser reutilizado no futuro.

No entanto, utilizar o interpretador também tem lá suas vantagens, tais como fazer testes rápidos de algum trecho de código sem a necessidade de se criar um arquivo para isto. Porém, se você pretende programar pra valer, você terá que lidar com arquivos para escrever seus códigos.

Bom pessoal, por hoje é isso! Gostaria de agradecer os incentivos que tenho visto nos comentários. Algumas pessoas comentaram também que pulei certas etapas no processo. Realmente isto é verdade, mas pulei estas etapas meio que de propósito, para evitar ter que explicar algumas dezenas de definições, as quais espero explicar gradualmente no decorrer das postagens. Como havia dito no post inaugural, minha intenção é escrever um post por semana, mas se for o caso vou tentar escrever mais de um post em algumas semanas. Caso o ritmo fica muito acelerado, postem comentários que voltarei a limitar os posts a um por semana.

Vejo vocês no próximo post!

O Projeto

Hoje vou descrever o projeto que tenho em mente para este mini-curso online. Este consiste em um jogo de damas, que é um dos jogos de tabuleiros mais tradicionais do mundo. Este jogo é ideal por ter regras simples o suficiente para o propósito deste projeto.

Vou descrever os detalhes do jogo, o que facilitará na hora de entender as estruturas de dados utilizadas posteriormente, quando estivermos trabalhando no projeto em si.

1. O tabuleiro é formado por 8 colunas e 8 linhas. Cada casa do tabuleiro tem uma cor, branca ou preta. As cores das casas são alternadas.
2. São dois jogadores. Cada jogador tem a sua disposição 12 peças, onde as peças de um jogador tem uma cor diferente da do outro, uma cor mais clara e outra mais escura.
3. Na posição inicial, os jogadores irão dispor suas peças sobre as casas negras em regiões opostas do tabuleiro, ocupando assim as casas negras das 3 últimas linhas do seu lado do tabuleiro.
4. O movimento das peças será sempre na diagonal, e sempre ocupando uma casa negra e sempre avançando para frente.
5. O ato de "comer" uma peça do adversário consiste em pular sobre esta pedra, obedecendo o movimento em diagonal e para frente, desde que a casa que será ocupada ao final do movimento esteja livre.
6. É permitido "comer" mais de uma peça em um movimento, desde que se obedeça a regra número 5 entre os pulos.
7. Vence o jogador que eliminar todas as peças do adversário
8. Caso alguma peça do jogador atinja a última linha do lado oposto do tabuleiro, esta peça automaticamente é convertida em uma "Dama"
9. As Damas devem obedecer as mesmas regras do movimento que as demais peças, com exceção que estas podem tanto avançar como retroceder no tabuleiro.

Estas são as regras do jogo. Note que, apesar de o jogo ser bastante simples, existem várias regras.

Com o projeto definido, vamos á parte que nos interessa: programar!

Vou começar explicando os tipos de dados que nós temos acesso na linguagem Python. Entre os tipos básicos temos: inteiros, strings e valores reais.

Os dados inteiros são os números inteiros, positivos e negativos, incluindo o zero. String é o tipo de dados que armazena texto. E os valores reais são os dados que armazenam números com casas decimais, conhecidos como de ponto flutuante. Exemplos de inteiros são: 1, 5, 0, -1, 65535, etc. Exemplos de string: "paulo", "maria", "o rato roeu a roupa do rei de roma". E de ponto flutuante: -1.55, 99.9999, 0.12345.

Note que as strings são delimitadas por aspas duplas. No caso da linguagem Python elas também podem ser delimitadas por aspas simples.

Como forma de praticar, podemos utilizar o prompt interativo do interpretador Python:

>>> print 5
5
>>> print 5 + 2
7
>>> print 'Joao Paulo'
Joao Paulo
>>> print 1.5
1.5
>>> print 2.5 * 2
5.0
>>> print 'Joao' + " Paulo"
Joao Paulo

Outros tipos de dados são as listas e tuplas. Listas são, como o nome diz, listas de objetos. Podem conter inteiros, strings, ponto flutuante e qualquer outro tipo de objeto, incluindo listas e tuplas. As tuplas são um tipo especial de listas. Estas são imutáveis, o que significa que uma vez definidas não podem ter seu conteúdo alterado. As listas são definidas com colchetes e as tuplas com parenteses. Vejamos abaixo:

>>> print [1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
>>> print (1, 2, 3, 4, 5)
(1, 2, 3, 4, 5)
>>> print []
[]
>>> print ()
()
>>> print (1,)
(1,)
>>> print [1]
[1]
>>> print [1, [2, 3], 4]
[1, [2, 3], 4]

Podemos notar alguns detalhes acima. Primeiro que podemos definir listas e tuplas vazias. Segundo, para definir uma tupla com apenas um elemento devemos por uma vírgula após o elemento, caso contrário o interpretador entederia isto apenas como um agrupamento normal utilizando parenteses. E, no último exemplo, mostro como incluir uma lista dentro de outra lista. A lista [2, 3] neste caso é o segundo elemento da lista que o contém.

Para terminar o post desta semana, vou introduzir o conceito de variáveis. As variáveis são uma espécie de nome que nós damos aos objetos a fim de identificá-los de forma mais prática. Damos o nome de "atribuição" o ato de ligar um nome a um valor. Vejamos nos exemplos:

>>> nome = 'Joao Paulo'
>>> print nome
Joao Paulo
>>> x = 10
>>> y = 20
>>> print x * y
200
>>> x = 5
>>> print x * y
100
>>> minha_lista = [1, 2, 3, 'Paulo']
>>> print minha_lista
[1, 2, 3, 'Paulo']
>>> print minha_lista[0]
1
>>> print minha_lista[-1]
'Paulo'
>>> minha_lista[1] = 5
>>> print minha_lista
[1, 5, 3, 'Paulo']
>>> del minha_lista[-1]
>>> print minha_lista
[1, 5, 3]

Nos exemplos acima definimos algumas variáveis:

• nome referenciando a string 'Joao Paulo'
• x, de valor inteiro, inicialmente 10 e mais a frente alterado para 5
• y, de valor inteiro 20
• minha_lista, uma lista com 3 inteiros e uma string

Note que para termos acesso a elementos individuais de uma lista devemos escrever o nome da variável e em seguida o índice do elemento entre colchetes. O índice do primeiro elemento sempre será zero. Como se pode observar, também podemos utilizar índices negativos. Neste caso os índices se referem ao final da lista, sendo que o último item sempre terá índice -1.

Bom, por hoje é isso. Na próxima semana irei descrever como criar scripts e dar uma sequência lógica a um programa.

A Arte de Programar Computadores

O  que é programar?

Apesar de parecer estranho, muitas pessoas não sabem - ou não entendem, o que significa programar um computador. Faço analogia aos antigos vídeo cassetes. Nestes aparelhos uma pessoa poderia "programá-lo" para que o mesmo gravasse um determinado canal por um período de tempo específicado. Ou seja, o usuário, utilizando algumas regras, informa ao aparelho uma ação que este deve tomar. Programar um computador é algo parecido, respeitadas as devidas proporções.

Você que está lendo este blog neste momento também está utilizando alguns programas que foram escritos por alguns milhares de programadores mundo afora. Se você utiliza o Windows, saiba que este é um programa especial escrito pelos programadores da Microsoft. Usando o Internet Explorer? Este também é um programa escrito pelo pessoal da Microsoft. Não usa Windows? Que tal o Linux? O Firefox? 

Todos são programas escritos por programadores. O caso do Linux é bem interessante, pois este é escrito por milhares de programadores espalhados pelo mundo de forma colaborativa, utilizando a Internet para sincronizar seus esforços. Tanto o Linux como o Windows são programas especiais, denominados "Sistemas Operacionais". Os sistemas operacionais nada mais são que um suporte para que os programas que usamos no dia a dia. 

Resumindo, programar um computador é determinar quais ações este deve tomar, seguindo uma sequência lógica.

Eu sou uma pessoa que gosto muito de praticar, e acredito que um aprendizado só é completo se envolver uma boa dose de prática. Sendo assim, vamos à prática!

Caso você não entenda alguns dos termos que utilizarei nos parágrafos a seguir, não se espante, eles farão sentido mais tarde.

A primeira coisa que devemos fazer é instalar o interpretador da linguagem Python. Faça o download clicando aqui. Neste curso, utilizaremos a versão 2.5.2 do interpretador, embora já existam versões mais novas. Não se preocupe, o motivo para não utilizar a versão mais recente é puramente didática.

Uma vez instalado, devemos executar o interpretador. Se você utiliza o Windows, pode encontrar o interpretador no menu Iniciar, dentro da pasta Programas / Python 2.5. Selecione o item "Python (Command Line)". Caso utilize Linux ou Mac OS X, abra um terminal e digite "python", sem as aspas, seguido da tecla "enter", ou "return" no caso do Mac OS X.

Você terá na tela algo parecido com isto:

Python 2.5.2 (r252:60911, Jun  5 2008, 11:31:51)
[GCC 4.0.1 (Apple Inc. build 5465)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

Este é o "prompt" do interpretador. Aqui podemos escrever e testar programas de forma interativa, ou seja, as ações são executadas na medida que nós as escrevemos, linha a linha.

Como é tradição no ensino de linguagems de programação, o primeiro programa que escrevemos é conhecido como "Hello World" ou "Olá Mundo". O objetivo deste primeiro programa apenas é fazer com que o computador imprima na tela este texto. Em Python, isto não poderia ser mais simples, basta digitar, após o ">>> ":

print "Hello World"

Seguido da tecla "enter". Como resposta, o interpretador irá imprimir o texto "Hello World", exatamente como esperado. Incrível, não? Pois é, bem vindo ao mundo da programação! Você é agora o mais novo programador de computadores!

Por enquanto é só. A minha ideia inicial era escrever mais detalhes sobre o projeto que pretendo desenvolver durante este "curso". Mas me alonguei demais na teoria. Fica a promessa para a próxima semana. Mas posso adiantar que o projeto tem como objetivo escrever um jogo multiplayer, um jogo simples - damas, afinal este é um curso introdutório! Mas não se deixem enganar, tal projeto irá envolver muitas técnicas de programação.

Ficamos por aqui! Até a semana que vem.

Post Inaugural

Aprendendo a Programar com Python

Este Blog é fruto de algumas observações que tenho feito conversando com bons amigos. Um dos que me influenciaram foi Astênio Araujo. Numa conversa durante o jantar em comemoração à colação de grau de um amigo em comum, Edmilson Barreto, ele me contou como o seu blog obteve um relativo sucesso, e a dica foi "escreva sobre algo que você tenha interesse". 

Mas este não foi o único motivador para a criação deste blog, foi apenas o motivador para tomar a ação! Eu sempre tive interesse em escrever algo voltado para a programação e, nos últimos anos, tenho convivido com a linguagem Python, a qual acho uma excelente escolha para quem está começando a programar. 

Já ministrei alguns mini-cursos sobre Python enquanto era aluno de graduação na UFRN, onde os participantes se mostrarem empolgados com o resultado que pode ser obtido com a dedicação de apenas algumas horas. 

Por fim, recentemente um outro amigo me procurou para saber a respeito de cursos na área, pois ele tem interesse em dar os primeiros passos em direção à arte da programação de computadores. Após alguma procura, verificamos que na nossa cidade apenas um curso utiliza a linguagem Python, voltada para a progração de aplicações WEB, que é ministrado pela Diginet.

Este blog visa então, satisfazer minha vontade pessoal e dar mais uma opção a quem quer se aventurar neste novo mundo. Outro objetivo deste blog é testar minha disciplina pessoal.

A ideia é publicar posts semanais, sempre introduzindo um novo conceito e propondo um exercício quando possível. Serão estabelecidas algumas metas - sejam elas de curto ou médio prazo - para que possamos ter um caminho bem definido.

Por enquanto é só! Na próxima semana irei escrever um pouco sobre o que é programar e descrever o projeto que tenho em mente para realizar durante essa jornada.