Um dos paradigmas de Python é a Orientação a Objetos, que dão um melhor controle e estabilidade de projetos grandes. Nesse artigo você vai conhecer como preparar o ambiente de desenvolvimento utilizando a ferramenta LiEclipse, ideal para Python, além de criar projetos, conhecer sintaxes com relação a programação a objetos e conhecer o framework web Cherrypy, desde sua instalação.

Preparando o ambiente de Desenvolvimento

Para iniciarmos, precisaremos preparar o ambiente de desenvolvimento. Para esse artigo vamos configurar uma máquina com sistema operacional Windows de 32bits.

Acesse o site do Python (vide seção Links) e clique na aba Downloads para achar a versão desejada de acordo com o seu sistema operacional (neste artigo será utilizada a versão 3.4.3). Depois de concluído execute o instalador. Após escolher a pasta de instalação, a próxima tela a aparecer é igual a Figura 1. Para essa etapa iremos alterar uma instrução.

Customização do Python

Figura 1. Customização do Python

Por padrão, o instalador deixa a opção de adicionar a instrução que insere valor na variável de ambiente desabilitada, mas para facilitar nosso trabalho iremos habilitá-la e deixá-la igual a Figura 3. Após esta alteração basta clicar novamente no botão “Next >” e aguardar o processo de instalação. Dependendo das suas configurações de segurança do computador, poderá aparecer uma mensagem de alerta do Windows pedindo acesso ao software, mas é só clicar em permitir e aguardar mais alguns segundos e clique no botão “Finish” para finalizar a instalação.

Com o Python já instalado podemos fazer um teste abrindo o prompt de comando ou terminal. Digite “python” e irá iniciar o console onde já poderemos programar, como mostra a Figura 2.

Usamos o seguinte exemplo para testar:

  a=10
  b=20
  c=a+b
  print(c)

Veja que foi criada uma variável com nome “a” e atribuído um valor de 10, uma variável de nome “b” e atribuído um valor de 20, e uma variável “c” que recebe o valor da soma das duas e o método “print()” para exibir o resultado.

Exemplo básico sendo executado no
prompt de comando

Figura 2. Exemplo básico sendo executado no prompt de comando.

Assim como no PHP, no Python você não precisa definir o tipo da variável: basta atribuir um valor e ela interpreta o tipo. Vejamos mais um exemplo utilizando a concatenação de string usando aspas duplas com a execução sendo exibida na Figura 3:

  a=”Estou aprendendo “
  b=”Python!”
  c=a+b
  print(c)

Figura 3. Exemplo utilizando a concatenação de string

IDE LiClipse

Vamos utilizar agora a interface de desenvolvimento integrado LiClipse, baixando do seu site (vide seção Links) e escolhendo a opção “Get it Download”.

Após a instalação do mesmo, execute-o e aparecerá uma tela como a da Figura 4.

Seleção do workspace

Figura 4. Seleção do workspace

Esta janela se refere à localização do workspace, ou seja, o local no disco onde vão ficar os projetos. Para esse artigo vamos usar o valor padrão dos documentos do usuário logado. Depois de selecionado, basta escolher qual o tema desejado, como na Figura 5. Para esse artigo usaremos o primeiro tema.

Escolha do tema

Figura 5. Escolha do tema

Com isso o LiClipse estará pronto para ser utilizado, como mostra a Figura 6.

Tela que ilustra
como é o menu principal “File” com as opções para se trabalhar

Figura 6. Tela que ilustra como é o menu principal “File” com as opções para se trabalhar.

Criando um Projeto

Para iniciar o desenvolvimento desse exemplo, precisamos ter em mente algumas características importantes do Python:

  1. A linguagem é “Case Sensitive”, ou seja, existe diferenciação do compilador das letras minúsculas e maiúsculas, ou seja, “a” é uma variável e “A” seria outra;
  2. Não é necessário definir um tipo de variável, pois essa tipagem é dinâmica, similar ao PHP, ou seja, basta colocar uma variável e atribuir um valor a ela. Contudo, tipagem dinâmica se refere à linguagem não associar tipos às variáveis e sim aos seus valores. E como tipagem forte, entende-se que não é possível realizar operações com valores que possuem tipos incompatíveis de dados, como, por exemplo, unir um número a uma string;
  3. Não é possível manipular ponteiros e não há suporte a sobrecarga de funções.

Passando a prática, vamos até o menu superior do LiClipse e clicar em File > New > PyDev Project para aparecer uma tela como a da Figura 7.

Novo projeto

Figura 7. Novo projeto.

Em “Project Name” definiremos o nome do projeto como “Testes” e selecionaremos o tipo Python. Com relação ao interpretador de sintaxe da versão, utilizaremos a 3.0, assim, a partir desta versão, todas as versões superiores terão sua sintaxe reconhecida, não sendo necessário reescrever o código caso seja atualizado a versão do Python.

Para configurar o interpretador no IDE clique no link “Please configure na interpreter before proceeding”, assim ele iniciará uma tela de configuração para indicar onde está instalado o Python. Basta clicar em “Quick Auto-Config” que ele irá identificar automaticamente, mas caso o software não reconheça terá que ser configurado manualmente clicando em “Manual Config” e indicando onde o Python foi instalado. Na opção do interpretador deixe selecionado “python” e clique em “Finish”.

Agora com o projeto já criado, vamos criar um novo módulo Python para o projeto: clique com o botão direito do mouse em cima do nome do projeto que aparecerá na guia a esquerda, em seguida New > PyDev Module, como mostra a Figura 8.

Caminho para criação de um novo
PyDev Module

Figura 8. Caminho para criação de um novo PyDev Module.

Em seguida surgirá uma tela onde poderemos colocar o nome do pacote a ser adicionado e o nome do módulo, como mostra a Figura 9.

Novo módulo

Figura 9. Novo módulo

Na tela apresentada o Package está branco mesmo e o “Name” será Sintaxes. Clique em “Finish” e clique em “Ok” na tela seguinte. Aparecerá a opção de escolha do tipo de template que poderá utilizar no módulo: note que já tem a opção de trabalhar com o formato de classe ou mesmo tratar o módulo como o método principal (Main), contudo, clique em <Empty> e de novamente um Ok.

O módulo deverá iniciar com um trecho comentado (repare que comentários de várias linhas em Python são feitos utilizando três apóstrofos).

Python Orientado a Objetos

Programar em Python com orientação a objetos é mais simples que definir o que é a orientação a objetos, pois neste modelo não existe funções, mas sim métodos que se comunicam na programação procedural - o programador manipula os dados através de uma sequência de procedimentos:

  Procedimento1: abasteça com gasolina
  Procedimento2: encha os quatro pneus
  Procedimento3: limpe o para-brisa

Se as suas variáveis são carros, o código irá funcionar perfeitamente, contudo pensemos no caso da variável ser uma moto, ou um carro a álcool: vai dar erro ou teremos que reescrever o código.

Na orientação a objetos a ideia é tornar os códigos reutilizáveis, neste caso, ao invés de uma variável carro, teríamos um objeto carro, pois um objeto tem atributos e métodos.

Atributos são as características, e no caso de carro poderíamos definir um atributo chamado rodas que recebe o total de rodas. Poderíamos também ter um atributo booleano chamado para-brisas, que receberia verdadeiro ou falso, e um atributo combustível que poderia receber uma string como tipo.

Métodos são ações que este objeto tem, por exemplo, um carro anda, buzina, dá seta, Poderíamos declarar um método como Carro.andar().toPosto().checkup(). Mas, e se fosse uma moto?

Na orientação a objetos possuímos um recurso chamado herança, onde podemos criar outro objeto com características, atributos e métodos da classe herdade e selecioná-los.

Vamos entender melhor isso através dos códigos a seguir, mas devemos salientar que em Python não é necessário definir os atributos (como private em Java), e também suporta múltiplas heranças e não suporta sobrecarga de métodos. Veja o exemplo de estrutura na Listagem 1.

Listagem 1. Exemplo de método

  1  class Minhaclasse(): 
  2  """ 
  3  Documentação da Classe 
  4  """ 
  5  atributo1 = "VALOR_ATRIBUTO1" 
  6  atributo2 = "VALOR_ATRIBUTO2" 
  7  __privado1 = "VALOR_PRIVADO1" 
  8  __privado2 = "VALOR_PRIVADO2" 
  9 """ DEFINIÇÕES """
  10 def __init__ (self, params ): 
  11 """ DOCUMENTACAO DO CONSTRUTOR """ 
  12 #BLOCO DE CÓDIGO DO CONSTRUTOR 
  13 def __del__ (self): 
  14 """ DOCUMENTACAO DO DESTRUTOR """ 
  15 #BLOCO DE CÓDIGO DO DESTRUTOR 
  16 def Metodo1 (self, param1, params): 
  17 #BLOCO DE CÓDIGO 
  18 def __MetodoPrivado1 (self, params): 
  19 #BLOCO DE CÓDIGO

Os atributos normais estão localizados nas linhas 5 e 6 e o construtores está indicado por __init__() na linha 10. Já o destrutor está indicado por __del__() na linha 13.

Outro ponto a ser notado é que atributos e métodos são iniciados por dois sublinhados “__”, e os terminados com, no máximo, um sublinhado são privados (encontrados nas linhas 7 e 8). Todos os métodos devem receber como primeiro parâmetro um objeto que representa a própria classe: por convenção chamamos este parâmetro de self (localizados nas linhas 13, 16 e 18).

Clique com o botão direito em cima do projeto criado e vá em New > PyDev Module e coloque o nome “humanos”. Copie o código da Listagem 2 e compile.

Listagem 2. Classe humanos

  1  import datetime 
  2  import math 
  3  class humanos(object): 
  4          def __init__(self,nome,dtnasc,peso,altura): 
  5                      self.nome=nome 
  6                      self.dtnasc=dtnasc 
  7                      self.peso=peso 
  8                      self.altura=altura 
  9          def getidade(self): 
  10                    calc= datetime.date.today()-self.dtnasc 
  11                    return int (calc.days/365.25) 
  12        def getimc(self): 
  13                    return self.peso/math.pow(self.altura/100., 2) 
  14 pessoa = humanos("Pessoa",datetime.date(1985,4,1), 98,178) 
  15 print (pessoa.nome) 
  16 print (pessoa.getidade(),"Anos de idade") 
  17 print ("IMC é de:",round(pessoa.getimc(),2))

Nas linhas 1 e 2 foram importadas duas classes: a datetime e a math, para utilizarmos alguns de seus métodos. Na linha 3 definimos a classe humanos e na linha 4 definimos seu construtor, bem como os parâmetros que deverão existir. Colocamos as variáveis diretamente no construtor para serem carregadas assim que a classe for invocada, com acesso público.

Na linha 5 até a 8 carregamos os valores das variáveis no construtor com os parâmetros e na linha 9 criamos um método que retorna a idade de acordo com a data de nascimento passada. Veja que utilizamos um dos métodos da classe datetime importada no topo.

Na linha 12 temos um método que retorna o índice de massa corpórea (IMC) e utilizamos o método pow da classe math para fazer potenciação. Por fim, é impresso na tela as informações nome, idade e IMC.

Métodos e Atributos Privados e Estáticos

Note que no exemplo anterior não foi instanciado o objeto humanos, apenas atribuímos os valores que deveriam constar quando a classe for chamada. Na linha 17 utilizamos o método round para deixar o número com apenas duas casas decimais. Contudo ainda podemos deixar os atributos da classe privados, ou seja, só poderemos acessá-los por métodos da própria classe. Veja na Listagem 3 alguns exemplos.

Listagem 3. Exemplos de atributos

1  import datetime 
  2  import math 
  3  class humanos(object): 
  4          __nome="" 
  5          __dtnasc=object 
  6          __peso=0.0 
  7          __altura=0
  8          cabeca =0 
  9          def __init__(self,nome,dtnasc,peso,altura): 
  10                    self.nome=nome 
  11                    self.dtnasc=dtnasc 
  12                    self.peso=peso 
  13                    self.altura=altura 

Na linha 4 foi criado o atributo privado da classe e na linha 8 foi criado o atributo estático da classe. Na linha 9 definimos o construtor e da linha 10 até a 13 carregamos os valores das variáveis no construtor com os parâmetros.

Herança

Em se tratando de herança é necessário ter o cuidado com o uso de atributos encapsulados, pois eles não terão visibilidade na subclasse. Na Listagem 4 temos um exemplo onde será preciso criar dois PyDev Modules: um com nome Funcionario (sem acento) e o outro com o nome de Gerente no módulo Funcionario.

Listagem 4. Exemplo de herança

  1  class Funcionario(object): 
  2          nome="" 
  3          cart_trab="" 
  4          valor_hora=0 
  5          horas_trab=0 
  6          def __init__(self,nome,cart,val,hor): 
  7                      self.nome=nome 
  8                      self.cart_trab=cart 
  9                      self.valor_hora=val 
  10                    self.horas_trab=hor 
  11        def get_salario(self): 
  12                    return self.valor_hora*self.horas_trab 
  13        def get_nome(self): 
  14                    return self.nome

Veja que temos a classe Funcionário “pai” com seus atributos, construtor, valores carregados. Na linha 11 um método retorna o salário e na linha 13 foi criado um método que retorna o nome.

Agora, no módulo criado com nome Gerente adicione o código da Listagem 5.

Listagem 5. Classe gerente que herda de funcionario

  1 from Funcionario import Funcionario 
  2  class Gerente(Funcionario): 
  3          adic=0.0 
  4          def __init__(self,nome,cart,val,hor,adic): 
  5                      Funcionario.__init__(self, nome, cart, val, hor) 
  6                      self.adic=adic 
  7          def get_salario(self): 
  8                      return Funcionario.get_salario(self)*(1+self.adic/100.) 
  9          def get_adicional(self): 
  10        return self.adic

A classe Gerente herda os atributos da primeira classe. Na linha 1 importa-se a classe Funcionario e na linha 2 faz-se uma referência à classe herdada. Na linha 4 temos um construtor com seus atributos e na linha 5 chamamos os atributos da classe Funcionario. Já na linha 7 é criado um método para retornar o salário com seu adicional (referentes as linhas 3 e 6) e na linha 9 é criado um método para retornar este adicional.

Após criado os módulos Funcionario e Gerente, vamos até o módulo Sintaxes.py e inserimos o código da Listagem 6. Compile para ver o resultado.

Listagem 6. Módulo Sintaxes

  1  from Funcionario import Funcionario 
  2  from Gerente import Gerente 
  3  f1=Funcionario("Jose","1259-8",12.5,44) 
  4  print (f1.get_nome()," : ",f1.get_salario()) 
  5  g1=Gerente("Andre","6759-7",12.5,44,10) 
  6  print (g1.get_nome()," : ",g1.get_salario()) 
  7  equipe=[] 
  8  equipe.append(f1); 
  9  equipe.append(g1); 
  10 for f in equipe: 
  11        print ("Nome:",f.get_nome(),"Salario R$ ",f.get_salario()) 
  12        if isinstance(f,Gerente): 
  13                    print (" Adicional de",f.get_adicional())

Veja que temos um exemplo de polimorfismo por herança que ocorre quando os ponteiros de uma classe base podem referenciar objetos de classes derivadas, como localizamos nas linhas 3 a 6. Na linha 7 é criada uma lista vazia e nas linhas 8 e 9 são adicionados o Funcionário e Gerente a esta lista. Na linha 10 é criado um laço onde imprime os nomes das pessoas e seus salários.

Na linha 12 é onde vemos o polimorfismo dinâmico, que verifica se a pessoa pertence a instância Gerente e, se isso for verdade, é impresso o adicional dele.

Para conhecer mais sobre os princípios OO no Python acesse o curso completo no nosso portal.

Frameworks para Python

Os frameworks são, na prática, ferramentas que ajudam no desenvolvimento em determinada plataforma. Em Python existem alguns frameworks conhecidos que ajudam muito no desenvolvimento das aplicações, principalmente para web, como os exemplos a seguir:

  • Mod_python: é um módulo do Apache que inclui o interpretador Python dentro do servidor. Com ele você pode escrever aplicações baseadas na web que serão executadas muitas vezes mais rapidamente do que no CGI tradicional, e terão acesso a recursos avançados, como a capacidade de manter conexões de banco de dados e acesso a partes internas do Apache;
  • Django: também é um framework voltado para a web e incentiva o rápido desenvolvimento e design limpo pragmático. Criada por desenvolvedores experientes, ele cuida de grande parte do trabalho de desenvolvimento da web, para nos concentrarmos em escrever o aplicativo sem a necessidade de reinventar a roda. É livre e open source;
  • TurboGears: É construído em cima da experiência de vários frameworks web de última geração, incluindo Django e Rails. É outro framework que foca em agilidade no desenvolvimento de aplicações, utilizando-se de templates e facilidades na implementação e integração com base de dados relacionais;
  • Zope: É uma das opções mais robustas, pois é um servidor de aplicações e pode ser comparado ao JBoss ou TomCat;
  • Cherrypy: framework simples que implementa um servidor em cada aplicação, mas pode rodar em servidores web. É orientado a objetos e roda no Android. Esse será o nosso objeto de estudo nesse artigo.

Cherrypy

Para começarmos precisamos fazer o download do mesmo (vide seção Links): para esse artigo usamos a versão 3.8.0, e selecione o instalador de acordo com o sistema operacional. Como neste artigo estamos usando como base o Windows 7 32 bits, usamos a opção CherryPy-3.8.0-py3-none-any.whl(md5) do tipo Python Whell. Quando terminar o download extraia o arquivo para uma pasta separada, e dentro dela veremos outra pasta com nome cherrypy: copie e cole-a dentro do diretório C:\Python34\Lib\site-packages.

Para testar se tudo ocorreu bem abra o prompt de comando e acesse C:\Python34\Lib\site-packages\cherrypy\tutorial>\Python34\. Em seguida dê o comando a seguir e veja como fica a execução na Figura 10:

python tut01_helloworld.py

Prompt que
mostra como são os processos da instalação do Cherrypy

Figura 10. Prompt que mostra como são os processos da instalação do Cherrypy.

Abra um navegador e acesse http://localhost:8080 para ver sua primeira página Cherrypy conhecida como CherryPy-served page. Use Ctrl+C para parar o servidor no prompt caso deseje.

Para que LiClipse reconheça o framework, vá em File >New > PyDev Project, Grammar Version 3.0 e coloque o nome do projeto de WEB e clique em Finish.

Feito isso vamos criar um novo Módulo clicando com o botão direito no projeto Web > New > PyDev Module. Coloque o nome de AloMundo e insira o código da Listagem 7.

Listagem 7. AloMundo

  1 import cherrypy 
  2 class AloMundo: 
  3          @cherrypy.expose 
  4          def index(self): 
  5                      return “Começando na WEB com Python!" 
  6 cherrypy.quickstart(AloMundo())

Na linha 1 é feita a importação da biblioteca cherrypy e na linha 3 é criado uma marcação obrigatória, que é responsável para expor o método. Na linha 4 é criado o método principal que retorna uma mensagem na tela e a linha 6 é responsável em iniciar o projeto WEB de acordo com o nome da classe passada por parâmetro “AloMundo()”.

Após isso, execute o arquivo, abra o navegador e acesse http://localhost:8080 para aparecer a mesma tela da Figura 11.

Tela do
navegador que exibe a mensagem inicial

Figura 11. Tela do navegador que exibe a mensagem inicial.

Também é possível adicionar e ou alterar configurações do servidor pelo código Python, como mostra o exemplo da Listagem 8.

Listagem 8. Configuração do Host

  1   import cherrypy 
  2   class AloMundo: 
  3          @cherrypy.expose 
  4          def index(self): 
  5                      return "Começando na WEB com Python!" 
  6   server_config={ 
  7   'server.socket_host': '127.0.0.1', 
  8   'server.socket_port': 80 
  9   } 
  10  cherrypy.config.update(server_config) 
  11  cherrypy.quickstart(AloMundo())

O código é responsável por configurar o host (linha 7) e a porta de acesso (linha 8). Note que é necessário colocar a linha 10, já que ela é responsável por atualizar a configuração do servidor antes da linha 11, que é de inicialização do projeto. Execute o arquivo e acesse: http://127.0.0.1:80.

Espero que tenham gostado da apresentação desse framework e vejam que ele é tão fácil de usar quanto a sua linguagem.

Até a próxima.

LINKS

Python
https://www.python.org/

Ambiente LiClipse
http://www.liclipse.com/

Framework CherryPy
https://pypi.python.org/pypi/CherryPy

Mod_python
http://modpython.org/

Django
https://www.djangoproject.com/

TurboGears
http://turbogears.org/

Zope
http://www.zope.org/