Arquivo de fevereiro, 2014

Já sabemos que é legal um método invocar o outro método, e vimos vários exemplos destes. Mas também é legal um método invocar ele mesmo. Pode não ser óbvio  o por que é isto é necessário, mas acaba por ser uma das coisas mais interessantes  que um programa pode fazer e este tipo de técnica é chamada de recursão.

Recursão é o processo de repetir itens de uma forma auto similar. Por exemplo, quando as superfícies dos dois espelhos são exatamente paralela uma com a outra as imagens que ocorrem aninhadas são uma forma de recursividade infinita. O termo tem uma variedade de significados específicos para uma variedade de disciplinas que vão desde a lógica linguística. A aplicação mais comum da recursividade é em matemática e ciência da computação, no que se refere a um método de definição de funções em que a função a ser definida é aplicada dentro de sua própria definição.

Mas é preciso planejar bem as recursões pois se houver erros em sua lógica, assim como os laços as recursões também podem ser infinitas.

Exemplo:

Neste exemplo vamos programar uma contagem regressiva  utilizando um método recursivo.

Java

public class Recursiva
 {
  static void contagemRegressiva (int n )
  {
    if ( n == 0 )
    {
      System.out.println("Explosão!!!");
    }
    else
    {
      System.out.println(n);
      contagemRegressiva (n-1);
    }
  }
  public static void main(String[] args)
  {
   int contagem = 10;
   System.out.println("Iniciando contage regressiva");
   contagemRegressiva(contagem);
  }
}

C++

#include "stdafx.h"
#include <iostream>
using namespace std;

static void contagemRegressiva(int n)
 {
  if (n == 0)
  {
    cout << "Explosão!!!" << endl;
  }
  else
  {
    cout << n << endl;   contagemRegressiva(n - 1);
  }
 }

int _tmain(int argc, _TCHAR* argv[])
 {
  int contagem = 10;
  cout << "Iniciando contagem regressiva." << endl;
  contagemRegressiva(contagem);
  system("pause");
  return 0;
 }

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DesenvolvimentoAberto
 {
     class Program
     {
         static void contagemRegressiva (int n )
      {
        if ( n == 0 )
        {
               Console.WriteLine("Explosão!!!");
        }
        else
        {
               Console.WriteLine(n);
               contagemRegressiva (n-1);
        }
      }

         static void Main(string[] args)
         {
             int contagem = 10;
             Console.WriteLine("Iniciando contagem regressiva");
             contagemRegressiva(contagem);
             Console.ReadKey();
         }
     }
 }

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# recursivo.py
# Importa OS
import os

# Limpa a tela
os.system("clear")

def ContagemRegressiva (n):
     if (n==0):
         print"Explosão!!!"
     else:
         print n
         ContagemRegressiva(n-1)

contagem = 10
print "Inciando contagem regressiva"
ContagemRegressiva (contagem)

raw_input()

Abap

*&---------------------------------------------------------------------*
*& Report  ZRECURSIVO
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Metodos Recursivos
*&---------------------------------------------------------------------*

REPORT  ZRECURSIVO.
PARAMETERS :CONTAGEM TYPE i.

WRITE : / 'Iniciando contage regressiva.'.

PERFORM CONTAGEM_REGRESSIVA USING CONTAGEM.

FORM CONTAGEM_REGRESSIVA USING N TYPE i.
  IF ( N EQ 0 ).
    WRITE : / 'Explosão!!!'.
  ELSE.
    WRITE : / N.
    N = N - 1.
    PERFORM CONTAGEM_REGRESSIVA USING  N.
  ENDIF.
ENDFORM.
Anúncios

SAP – Database e o Dicionário ABAP

Publicado: 28 de fevereiro de 2014 em Abap

O Dicionário ABAP (SE11) permite centralizar a definição e a gestão de tipos:

  • Criação de elementos de dados definidos pelo usuário, estruturas e tipos de tabela.
  • Definição de tabelas, índices e visualizações.
  • Definição dos serviços que suportam o desenvolvimento do programa.
  • O bloqueio de tabela e liberação de bloqueio.

Definindo a ajuda de entrada (F4)  e a ajuda de campo (F1)  .

Mudanças no Dicionário ABAP entram imediatamente em vigor para os programas que usam o que os elementos do dicionário.

sap-data-objects

Definição

Três tipos de dados podem ser definidos:

  • Elemento de dados (Data Element)
  • Estrutura (Structure)
  • Tipos de Tabela (internal tables)

Type Group

A opção tipo de grupo (Type Group) é fornecida pelo dicionário e está principalmente lá para apoiar o desenvolvimento antigo. (tipo de grupos estavam disponíveis antes de tipos de dados serem suportados.) Tipo de Grupos agora são usados ​​principalmente para definir constantes não-orientadas a objetos.

Domain

Dados de domínio (Domain) estão disponíveis para apoiar a definição de tipos de dados, mas os dados de domínio não são acessível em um programa ABAP.

Tables

Tabelas consistem em colunas (campos) e linhas (entradas). No ABAP tabelas do Dicionário têm nomes e atributos gerais, como classe de entrega e manutenção de autorização. A tabela tem um ou mais campos-chave, designados como a chave primária. campos da tabela são geralmente baseados em elementos de dados que se baseiam em dados do domínio. Campos de tabela podem ser digitados sem referência a um elemento de dados (Foreing Key). Neste caso, o campo é dito ser digitado direto. Tabelas têm configurações técnicas que regem a forma como o sistema deve otimizar o armazenamento de dados e acessar a tabela.

sap-data-field

Tabelas Transparentes

Quando uma tabela é definida no dicionário ABAP, ela é uma tabela transparente. Quando a tabela transparente é ativada, ela é criada no DBMS subjacente. A tabela específica do DBMS tem o mesmo nome que o nome da tabela transparente no ABAP Dictionary. Os tipos de campo na tabela DBMS específicas são convertidos para qualquer que seja a definição do tipo de dados apropriado no DBMS. Os elementos do quadro (por exemplo, campo, etc) subjacente podem ser alterados conforme necessário. A tabela transparente no Dicionário ABAP é a representação independente de banco de dados da tabela subjacente, e é usada em programação ABAP.

sap-data-table

Open SQL

Instruções SQL abertas(Open SQL) em programa ABAP são convertidas em instruções específicas do banco de dados SQL pela interface de banco de dados.

É possível ter acesso ao banco de dados com SQL nativo, mas o código é então do banco de dados específico e menos transportável.

Muitas declarações Open SQL se espelham nas instruções de SQL “tradicionais”, mas com diferenças sutis e refinamentos.

Open SQL contém apenas manipulação de Dados por comandos de linguagem (DML). As operações são feitas utilizando o Dicionário ABAP.

Quatro comandos Open SQL básico:

  • SELECT – seleciona dados em uma tabela.
  • UPDATE – altera dados em uma tabela.
  • INSERT –  insere dados em uma tabela.
  • DELETE – apaga dados em uma tabela.

Sap Luw

SAP LUW (unidade lógica de trabalho) é um conjunto de alterações lógicas para um banco de dados onde todas pertencem uma a outra. O LUW é feito de acordo com o princípio de “tudo ou nada”,  se sequência inteira não pode ser terminada, a operação será revertida (Rollback).

Operação Commit é cometida implicitamente ou via instrução ABAP COMMIT WORK. Rollback é feito via instrução ROLLBACK WORK.

sap-luw

Necessidade do LUW

SAP ERP possui arquitetura cliente-servidor de três camadas. No servidor de aplicação, as aplicações do usuário final são executadas através de processos de trabalho. Trabalho de vários processos em vigor simultaneamente. Ao particionar operações de banco de dados em LUWs, a integridade do banco de dados pode ser mantida e um processo de trabalho pode acessar e liberar recursos de banco de dados rapidamente.

Database Locking

Para evitar alterações simultâneas em tabelas de banco de dados a partir de vários programas, os bloqueios são usados.

Exemplo: o comando select campo (single) da tabela DBTABLE FOR UPDATE irá bloquear o registro selecionado na expectativa de uma mudança pendente. No final do LUW, o bloqueio é libertada.

Para bloquear um recurso para uma sequência mais prolongada, o sistema mantém uma tabela de bloqueio global que gerencia as travas definidas programaticamente para vários recursos.

Para definir o bloqueio: lockobject ENQUEUE.

Para liberar o bloqueio: lockobject DEQUEUE.

SY-SUBRC é definida após todas as operações de banco de dados. 0 = conclusão bem sucedida. Outros valores indicam diferentes tipos de erro, sy-dbcnt está definido para o número de registros afetados pela última operação.

A maioria das tabelas de sistema contêm um campo MANDT para designar um cliente. Comandos OPEN SQL  por padrão são feitos apenas para o cliente atual. Para substituir esse comportamento adicione a cláusula CLIENT SPECIFIED ao comando.

JOINS

É possível unir tabelas em uma consulta.

Sintaxe:

SELECT * FROM table1 INNER JOIN table2 ON table1~field = table2~field WHERE <condition>.

Chamado link em ABAP. Se um JOIN é feito em um programa, é um vínculo dinâmico. Links pré-existentes, links estáticos, são definidos no Dicionário ABAP. Estes são chamados de Views.

Revisão e Exemplos:

Comandos Open SQL tabelas transparentes: https://desenvolvimentoaberto.wordpress.com/2014/02/20/select-e-insert-abap/

Comandos Open SQL tabelas Internas: https://desenvolvimentoaberto.wordpress.com/2014/02/20/internal-tables-abap/

Modelo de Dados do Dicionário ABAP: https://desenvolvimentoaberto.wordpress.com/2014/02/20/netweaver-flight-model-introducao-ao-database-mini-sap/

I/O – Stream – Arquivos – Java, C++ e C#

Publicado: 27 de fevereiro de 2014 em C#, C/C++, Java

Um Stream pode ser definido como um fluxo de dados em um sistema computacional. Quando um arquivo é aberto para edição, todo ele ou parte dele fica na memória, permitindo assim alterações, por isto somente quando ele é fechado, tem-se a garantia de que nenhum dado se perderá ou será danificado.

Quando um arquivo é carregado na memória para ser editado, esta carga ocorre num fluxo “stream“, ou seja, byte a byte até o carregamento total do arquivo.

Stream

  • Lê um byte após o outro, um byte é apenas um número.
  • Os dados sobre o seu disco rígido é armazenado em bytes.
  • Bytes podem ser interpretados como caracteres, números e etc.

Byte

Um byte (Binary Term), baite ou octeto, é um dos tipos de dados integrais em computação. É usado com frequência para especificar o tamanho ou quantidade da memória ou da capacidade de armazenamento de um certo dispositivo, independentemente do tipo de dados.

A codificação padronizada de byte foi definida como sendo de 8 bits. O byte de 8 bits é mais comumente chamado de octeto no contexto de redes de computadores e telecomunicações.

Instruções

FileReader (java) é para a leitura de streams dos caracteres.

ifstream (C++) define um fluxo a ser utilizado para ler dados de caracteres de byte único em série a partir de um arquivo.

StreamReader (C#) é usado para ler linhas de informações de um arquivo de texto padrão.

Exemplos:

Neste exemplo  vamos criar um stream para ler o arquivo chamado Leiame.txt.

Texto –  Leiame.txt

Desenvolvimento Aberto.

Input/Output (Entrada/saída)

é um termo utilizado quase que exclusivamente no ramo da computação (ou informática),
indicando entrada (inserção) de dados por meio de algum código ou programa,
para algum outro programa ou hardware, bem como a sua saída (obtenção de dados) ou retorno de dados,
como resultado de alguma operação de algum programa, consequentemente resultado de alguma entrada.

Java

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class Bytes
 {

public static void main(String[] args) throws IOException
  {
   FileReader fr = new FileReader("./src/Leiame.txt");
   BufferedReader br = new BufferedReader(fr);
   String line = null;
   try
   {
    while ((line = br.readLine()) != null)
    {
       System.out.println(line);
    }
   }
   catch (IOException e)
   {
      e.printStackTrace();
   }
   br.close();
  }
 }

C++

#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
 {
  string linha;
  ifstream arquivo("C:/Desenvolvimento Aberto/Leiame.txt");
  if (arquivo.is_open())
  {
   while (getline(arquivo, linha))
   {
    cout << linha << endl;
   }
   arquivo.close();
  }

  else cout << "Erro ao abrir o arquivo.";

  system("pause");
  return 0;
 }

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
namespace DesenvolvimentoAberto
 {
     class Program
     {
         static void Main(string[] args)
         {

             try
             {
                 StreamReader sr = new StreamReader("C:/Desenvolvimento Aberto/Leiame.txt");
                 String line = sr.ReadToEnd();
                 Console.WriteLine(line);
                 sr.Close();
             }
             catch (Exception e)
             {
                Console.WriteLine( e.StackTrace);
             }

             Console.ReadKey();
         }
     }
 }

Exception – Try … Catch – Raise – Abap

Publicado: 26 de fevereiro de 2014 em Abap

A Classe Exception, representa os erros que ocorrem durante a execução de aplicativos. Todas as classes de exceção devem herdar da superclasse CX_ROOT  e uma de suas classes subclasses:

  • CX_STATIC_CHECK
  • CX_DYNAMIC_CHECK
  • CX_NO_CHECK

Todas as classes de exceção devem começar com o prefixo CX_. Elas são geralmente definidas globalmente no Class Builder do ABAP Workbench. Classes de exceção locais podem, no entanto, também ser definidas.

Execptions

Um erro de aplicativo é um erro de tempo de execução que não pode necessariamente ser evitado escrevendo um código livre de erros.

Erros de tempo de execução podem ocorrer por uma variedade de razões. No entanto, nem todos os erros devem ser tratados como exceções em seu código.

Em alguns casos, um erro de programa pode refletir uma condição de erro esperada ou de rotina. Neste caso, você pode querer evitar o uso de tratamento de exceção para lidar com o erro do programa.

Em outros casos, um erro de programa reflete uma condição de erro inesperado que pode ser manipulado em seu código. Por exemplo, mesmo que você tenha verificado para garantir que existe um arquivo, ele pode ser excluído antes que você possa abri-lo, ou ele pode estar corrompido.

A falha do sistema é um erro de tempo de execução que não podem ser tratada por meio de programação de uma maneira significativa. Por exemplo, qualquer método pode lançar uma exceção OutOfMemory se o Runtime é incapaz de alocar memória adicional

TRY … CATCH

Um modelo de tratamento de exceção que se baseia na representação de exceções como objetos, e a separação de código de programa e o código de tratamento de exceções em blocos TRY e blocos CATCH. Pode haver um ou mais blocos catch, cada um projetado para lidar com um determinado tipo de exceção, ou um bloco projetado para capturar uma exceção mais específica que outro bloco.

Exemplo:

Neste exemplo criamos uma classe para nosso erro herdada da classe CX_DYNAMIC_CHECK e usamos o comando TryCatch para manipular o erro e exibir uma mensagem mais amigável para o usuário.

Abap

*&---------------------------------------------------------------------*
*& Report  ZEXCECAO
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Exceções
*&---------------------------------------------------------------------*

REPORT  ZEXCECAO.

CLASS CX_MinhaExcecao DEFINITION INHERITING FROM CX_DYNAMIC_CHECK.

PUBLIC SECTION.

METHODS : CONSTRUCTOR IMPORTING pvalor TYPE p.

DATA VALOR TYPE p DECIMALS 2.

ENDCLASS.

CLASS CX_MinhaExcecao IMPLEMENTATION.

METHOD CONSTRUCTOR.
CALL METHOD SUPER->CONSTRUCTOR( ) .
VALOR = pvalor.
ENDMETHOD.

ENDCLASS.

start-of-selection.

DATA ERRO         TYPE REF TO CX_MinhaExcecao.
DATA saldo        TYPE p DECIMALS 2.
DATA saque        TYPE p DECIMALS 2.
DATA insuficiente TYPE p DECIMALS 2.

* Efetua Um deposito na conta
WRITE : / 'Deposito de: R$ 500,00'.
saldo = 500.

* Tenta efetuar um saque
PERFORM SAQUE.

FORM SAQUE.
  try.
    " Efetua um saque na conta
    WRITE : /   'saque de: R$ 1000,00'.
    saque =  1000.

    if ( saque LT saldo ).
      saldo = saldo - saque.
    else.
      insuficiente = saque - saldo.
      RAISE EXCEPTION TYPE CX_MinhaExcecao
            EXPORTING
                 PVALOR = Insuficiente.
    ENDIF.

  catch CX_MinhaExcecao into ERRO.
    " Tenta efetuar um saque
    WRITE: / 'Desculpe mas seu pedido de saque ultrapassa o seu saldo em: ', ERRO->VALOR.
  ENDTRY.
ENDFORM.

Exception – Try … Catch – Java, C++ e C#

Publicado: 26 de fevereiro de 2014 em C#, C/C++, Java

A Classe Exception, representa os erros que ocorrem durante a execução de aplicativos.

Um erro de aplicativo é um erro de tempo de execução que não pode necessariamente ser evitado escrevendo um código livre de erros.

Erros de tempo de execução podem ocorrer por uma variedade de razões. No entanto, nem todos os erros devem ser tratados como exceções em seu código.

Em alguns casos, um erro de programa pode refletir uma condição de erro esperada ou de rotina. Neste caso, você pode querer evitar o uso de tratamento de exceção para lidar com o erro do programa.

Em outros casos, um erro de programa reflete uma condição de erro inesperado que pode ser manipulado em seu código. Por exemplo, mesmo que você tenha verificado para garantir que existe um arquivo, ele pode ser excluído antes que você possa abri-lo, ou ele pode estar corrompido.

A falha do sistema é um erro de tempo de execução que não podem ser tratada por meio de programação de uma maneira significativa. Por exemplo, qualquer método pode lançar uma exceção OutOfMemory se o Runtime é incapaz de alocar memória adicional

Um modelo de tratamento de exceção que se baseia a representação de exceções como objetos, e a separação de código de programa e o código de tratamento de exceções em blocos TRY e blocos CATCH. Pode haver um ou mais blocos catch, cada um projetado para lidar com um determinado tipo de exceção, ou um bloco projetado para capturar uma exceção mais específica que outro bloco.

Exemplo:

Neste exemplo criamos uma classe para nosso erro herdada da classe Exception(Java, C++ e C#) e usamos o comando TryCatch para manipular o erro e exibir uma mensagem mais amigável para o usuário.

Java

Classe #1 – Principal

public class Principal
 {
  static double saldo = 0.0;
  static void saque (double valor) throws MinhaExcecao
  {
   if ( valor <= saldo )
   {
    saldo -= valor;
   }
   else
   {
    double insuficiente = valor - saldo;
    throw new MinhaExcecao(insuficiente);
   }
  }
  public static void main(String[] args)
  {
   // Efetua Um deposito na conta
   System.out.println("Deposito de: R$ 500,00");
   saldo = 500.00;

   // Tenta efetuar um saque
   try
   {
    System.out.println("Saque de: R$ 1000,00");
    saque(1000.00);
   }
   catch (MinhaExcecao erro)
   {
    System.out.println("Desculpe mas seu pedido ultrapassa o saldo em: "
                       + erro.pegaValor() );

    // Imprime conteudo do erro
    erro.printStackTrace();
   }
}
}

Erro

public class MinhaExcecao extends Exception

{
  private  double valor;
  public  MinhaExcecao ( double valor )
  {
   this.valor = valor;
  }

  public double pegaValor ( )
  {
   return valor;
  }
}

C++

Programa – Principal

#include "stdafx.h"
#include <iostream>
#include <exception>
#include "minhaexcecao.h"

using namespace std;

static double saldo = 0.0;

static void saque(double valor)
 {
  if (valor <= saldo)
  {
   saldo -= valor;
  }
  else
  {
   double insuficiente = valor - saldo;
   throw  MinhaExcecao(insuficiente);
  }
 }

int _tmain(int argc, _TCHAR* argv[])
 {

  // Efetua Um deposito na conta
  cout << "Deposito de: R$ 500,00" << endl;
  saldo = 500.00;

  // Tenta efetuar um saque
  try
  {
   cout << "Saque de: R$ 1000,00" << endl;   saque(1000.00);
  }
  catch (MinhaExcecao erro)
  {
   cout << "Desculpe mas seu pedido ultrapassa o saldo em: "    <<  erro.pegaValor() << endl;
  }
  system("pause");
  return 0;
 }

Erro – (.h)

#include "stdafx.h"
#include <iostream>
#include <exception>

using namespace std;

class MinhaExcecao : public exception
 {
private:

        double valor;

public:
    MinhaExcecao(double valor)
  {
   this->valor = valor;
  }

  double pegaValor()
  {
   return valor;
  }
 };

C#

Classe #1 – Principal

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DesenvolvimentoAberto
 {
     class Program
     {
         static double saldo = 0.0;
         static void saque (double valor)
         {
            if ( valor <= saldo )
            {
               saldo -= valor;
            }
            else
            {
               double insuficiente = valor - saldo;
               throw new MinhaExcecao(insuficiente);
             }
          }

         static void Main(string[] args)
         {
             // Efetua Um deposito na conta
             Console.WriteLine("Deposito de: R$ 500,00");
             saldo = 500.00;

             // Tenta efetuar um saque
             try
             {
               Console.WriteLine("Saque de: R$ 1000,00");
               saque(1000.00);
             }
             catch (MinhaExcecao erro)
             {
               Console.WriteLine("Desculpe mas seu pedido ultrapassa o saldo em: "
                                  + erro.pegaValor() );

               // Imprime conteudo do erro
               Console.WriteLine(erro.StackTrace);
             }

             Console.ReadKey();
            }
     }
 }

Classe #2 – Erro

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DesenvolvimentoAberto
 {
     class MinhaExcecao : Exception
     {
         private double valor;

         public MinhaExcecao(double valor)
         {
             this.valor = valor;
         }

         public double pegaValor()
         {
             return valor;

         }
     }
 }

Classes – Interfaces – Abap

Publicado: 25 de fevereiro de 2014 em Abap

Os objetos definem sua interação com o mundo exterior através dos métodos que eles expõem. Métodos formam a interface do objeto com o mundo exterior; os botões na parte frontal do seu aparelho de televisão, por exemplo, são a interface entre você e a fiação elétrica do outro lado do seu invólucro de plástico. Você aperta o botão “Power” para ligar e desligar a televisão.

Na sua forma mais comum, uma interface é um conjunto de métodos relacionados com corpos vazios

A implementação de uma interface permite que uma classe se torne mais formal sobre o comportamento que promete proporcionar. Interfaces formam um contrato entre a classe e o mundo exterior, e este contrato é imposto em tempo de compilação.

Se sua classe reivindica implementar uma interface, todos os métodos definidos por essa interface deve aparecer em seu código-fonte antes da classe ser compilada com sucesso.

Em ABAP  a palavra chave interface é realmente levada ao pé da letra, obrigando o programador a referenciar a interface na instrução entre o objeto e o método.

Sintaxe:

CALL METHOD Objeto->Interface~Método.

Lembrando que a interface obriga a classe na qual foi implementada a cumprir o que nela foi declarado. Caso não cumpra o determinado pela interface obterá o seguinte erro de compilação:

Erro: Implementention missing for method “Interface~Method”.

Conceito de interfaces

  • Não pode ser instanciada.
  • Só pode possuir assinaturas de métodos de instância, públicos e abstratos (sem corpo).
  • Não pode possuir métodos concretos (com corpo), nem métodos estáticos.

Uso Comum de Interface

Já que sabemos que os objetos Abap são baseados em C++ e Java, vamos fazer uma curta analogia para que você entenda perfeitamente o uso de interfaces. As classes Abap separam a implementação da definição, assim como C++, mas também assim como Java não permitem heranças múltiplas.

Na linguagem de programação C++ pode se utilizar uma interface abstrata, mas este uso não é muito comum, pois a convenção de classes C++ já contempla que a interface seja separada da implementação na criação da própria classe, utilizando arquivos diferentes (.h e .cpp). Além da linguagem C++ permitir múltiplas heranças tornando raro a necessidade do uso de interfaces abstratas.

Java e Abap utilizam a interface pois não permitem múltiplas heranças, então a interface se torna necessária para criar um efeito deste tipo, por exemplo, imagine que temos a classe Casa e queremos que esta classe herde as classes Portas e Janelas, isto não será possível em Java e Abap, mas é possível em C++.

Para garantir que teremos os métodos paras portas e janelas na classe Casa, precisamos utilizar a interface Portas e a Interface Janelas, ainda não garantindo como em C++ os tipos de portas e janelas já que as interfaces são abstratas e não métodos concretos, Mas este recurso permite que a classe Casa tenha obrigatoriamente, portas e janelas de qualquer tipo.

Este também é o motivo de uso de uma interface abstrata em C++, quando queremos métodos abstratos para uma classe dizendo que você permite portas e janelas de qualquer tipo. Nota-se assim que C++ é uma linguagem mais flexível em termos de recursos na criação de objetos

Exemplo:

Neste exemplo simulamos um programa de I/O de arquivos, criamos uma interface contendo os métodos obrigatórios para qualquer classe, que reivindicar a interface:

Abap

*&---------------------------------------------------------------------*
*& Report  ZINTERFACE
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Interfaces
*&---------------------------------------------------------------------*

REPORT  ZINTERFACE.

* Declara Interface

INTERFACE Acao.

   METHODS :
          ABRE   IMPORTING ARQUIVO TYPE STRING,
          GRAVA  IMPORTING ARQUIVO TYPE STRING,
          DELETA IMPORTING ARQUIVO TYPE STRING.

ENDINTERFACE.

* Declara Classe

CLASS ARQUIVO DEFINITION.

   PUBLIC SECTION.

      INTERFACES ACAO.

ENDCLASS.

* Declara Implementação da Classe

CLASS ARQUIVO IMPLEMENTATION.

   METHOD ACAO~ABRE.

      " ... Implementa método para abrir o arquivo.

      WRITE: / 'Arquivo:', ARQUIVO, 'em uso'.

   ENDMETHOD.

   METHOD ACAO~GRAVA.

      " ... Implementa método para gravar o arquivo.

      WRITE: / 'Arquivo:', ARQUIVO, 'Gravado com sucesso'.

   ENDMETHOD.

   METHOD ACAO~DELETA.

      " ... Implementa método para deletar o arquivo.

      WRITE: / 'Arquivo:', ARQUIVO, 'Deletado com sucesso'.

   ENDMETHOD.

ENDCLASS.

* Cria Objetos

START-OF-SELECTION.
DATA ARQ1 TYPE REF TO ARQUIVO.
CREATE OBJECT ARQ1.

ARQ1->ACAO~ABRE( EXPORTING ARQUIVO = 'Texto.txt' ).
ARQ1->ACAO~GRAVA( EXPORTING ARQUIVO = 'Texto.txt' ).
ARQ1->ACAO~DELETA( EXPORTING ARQUIVO = 'Texto.txt' ).

* ou

CALL METHOD ARQ1->ACAO~ABRE( EXPORTING ARQUIVO = 'Texto.txt' ).
* ...

Classes – Inheritance e Override – Abap

Publicado: 25 de fevereiro de 2014 em Abap

Inheritance (herança)

Programação orientada a objetos permite que classes possam herdar estados e comportamentos comuns usados de outras classes. Neste exemplo, bicicleta torna-se agora a superclasse de MountainBike. Na linguagem de programação, cada classe é permitido ter uma superclasse direta, e cada superclasse tem o potencial para um número ilimitado de subclasses.

Override

Métodos Override (substituição), em programação orientada a objeto, é um recurso de linguagem que permite que uma subclasse ou classe filha possa fornecer uma implementação específica de um método que já é fornecido por uma de suas superclasses ou classes pai.

A implementação Override das subclasses substitui a implementação na superclasse, fornecendo um método que tem o mesmo nome, mesmos parâmetros ou assinatura, e mesmo tipo de retorno como o método na classe pai.

Final e Abstract

Abap possui o conceito de classes e métodos finais, uma classe final não pode ter uma subclasse. Um método final não pode ser redefinido em uma subclasse. Eles concluem uma árvore de herança.

Um método abstrato é definido em uma classe abstrata e não pode ser implementado na classe. Em vez disso, ele é implementado em uma subclasse da classe. Classes abstratas não podem ser instanciadas.

Redefinition

É a instrução na qual cria um método override. A implementação da redefinição na subclasse obscurece a implementação original na superclasse.

Exemplo:

Utilizando o exemplo de classes anterior onde definimos e implementamos a classe ZBICICLETA no Class Builder vamos criar uma subclasse desta superclasse, para isto precisamos modificar o parâmetro da classe que por default no R/3 é marcado como uma classe final, siga os passos abaixo:

  1. Entre no Class Builder,  trasação SE24.
  2. Escolha a classe que criamos anteriormente ZBICICLETA e clique no botão Change.
  3. Na aba Properties, desmarque a opção Final, use como referencia a imagem abaixo:

FinalClass

Neste exemplo damos a classe BICICLETAMONTANHA todos os mesmos campos e métodos da classe bicicleta, e ainda permite que seu código se concentre exclusivamente sobre as características que a tornam única. Isso faz do código de suas subclasses fáceis de ler. Usamos métodos Override neste exemplo, para substituir o método BICICLETA da superclasse na subclasse.

No entanto, você deve tomar cuidado para documentar corretamente o estado e o comportamento que cada superclasse define, uma vez que o código não irá aparecer no arquivo de origem de cada subclasse.

Abap

*&---------------------------------------------------------------------*
*& Report  ZHERANCA
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Herança e Override
*&---------------------------------------------------------------------*

REPORT  ZHERANCA.

* Cria uma herança da classe ZBICICLETA

CLASS BICICLETAMONTANHA DEFINITION INHERITING FROM ZBICICLETA.

PUBLIC SECTION.

DATA:   marchas       TYPE STRING,
        amortecedores TYPE STRING,
        garrafa       TYPE STRING,
        gps           TYPE STRING.

METHODS BICICLETA REDEFINITION.

ENDCLASS.

CLASS BICICLETAMONTANHA IMPLEMENTATION.

METHOD BICICLETA.

CALL METHOD super->BICICLETA.

WRITE : / ' Marchas:', marchas.
WRITE : / ' Amortecedores:', amortecedores.
WRITE : / ' Garrafa:', garrafa.
WRITE : / ' Gps:', gps.

ENDMETHOD.

ENDCLASS.

* Cria Instancia da Classe Herdada
START-OF-SELECTION.
DATA BIKE1 TYPE REF TO BICICLETAMONTANHA.
CREATE OBJECT BIKE1.

* Propriedades (Atributos) da classe ZBICICLETA.

MOVE 'TRACK X100'       TO BIKE1->MODELO.
MOVE 'Fibra de Carbono' TO BIKE1->QUADRO.
MOVE 'Disco'            TO BIKE1->FREIOS.
MOVE 'Aluminio'         TO BIKE1->RODAS.

* Propriedades (Atributos) da classe BICICLETAMONTANHA

MOVE '18'              TO BIKE1->MARCHAS.
MOVE 'PRO III S'       TO BIKE1->AMORTECEDORES.
MOVE 'Aluminio 500 ml' TO BIKE1->GARRAFA.
MOVE 'Discovery PRO'   TO BIKE1->GPS.

* chama método OVERRIDE.

WRITE : / 'Bicicleta Montanha é uma herança da classe Bicicleta', / .

CALL METHOD BIKE1->BICICLETA.

SAP – Classes – Abap

Publicado: 24 de fevereiro de 2014 em Abap

Orientação a Objeto é geralmente considerada superior à programação procedural devido ao encapsulamento de dados com  funcionalidades relacionadas. ABAP Objects é conceitualmente semelhante as linguagens como C++ e Java, no entanto as duas linguagens estão entre as mais utilizadas atualmente e evoluem em alta velocidade, o mesmo não acontece com ABAP OO, podemos dizer que na pratica a diferença  na construção de classes é uma sintaxe um pouco mais pesada e a não permissão de criar métodos Overload dentro de uma classe, exemplo, não podemos ter um construtor vazio e um construtor utilizando parâmetros ao mesmo tempo.

Mas o ponto mais impactante entre o desenvolvimento ABAP OO e outras línguas orientadas a objeto segundo a própria SAP, “As instruções ABAP utilizadas para processamento de listas ainda não estão totalmente disponíveis em ABAP Objects“. Linguagens orientadas a objeto utilizam de forma intensa objetos de listas que são conhecidos como coleções ou Containers para manipular objetos, o ABAP possui algumas destas classes entretanto suas funcionalidades são precárias e não podem ser comparadas com os frameworks de coleções como STL para C++ e JCF para Java que praticamente definem conceitos para a manipulação de objetos.

Deste modo é comum mesmo em programas disponibilizados pela própria SAP, encontrarmos instruções consideradas procedurais como FORM e PERFORM entre outras sendo utilizada em conjunto com objetos, caso queira uma completa programação orientada a objeto como acontece em outras linguagens de programação, enquanto a SAP não disponibiliza a implementação total das coleções, você deve herdar as classes de coleções e estender as funcionalidades disponibilizadas pela SAP. Algumas construções da linguagem ABAP são consideradas obsoletas e ainda são suportadas em ABAP processual, não são permitidas em objetos ABAP.

ABAP Objects suporta:

  • Herança – uma classe compartilha a estrutura e comportamento com outra.
  • Polimorfismo – objetos diferentes (mas relacionados) têm a mesma interface de comunicação.
  • Eventos – respondem quando provocados. Os objetos podem disparar um evento.

Classe

A definição da estrutura e funcionalidade de um objeto. Define se o objeto de dados irá conter (atributos) e funcionalidades relacionadas (métodos).

Sintaxe da classe ABAP divide a definição de classe (contendo declarações de atributos e definições de interface do método) e a implementação da classe (definições de funcionalidade do método).

Sintaxe:

CLASS classe DEFINITION.

ENDCLASS.

CLASS classe IMPLEMENTATION.

ENDCLASS.

Uma classe pode ser definida localmente ou globalmente, usando a transação Class Builder SE24.

Objeto

A instanciação de uma classe, o armazenamento de dados reais e ou permitir a execução do método.

A definição de classe pode definir o seguinte: tipos, constantes, objetos de dados (atributos) e interfaces de método.

Os itens podem ser designados como:

  • PUBLIC (público) disponível a partir de fora do objeto.
  • PRIVATE (privada), disponível somente dentro do próprio objeto.
  • PROTECTED (protegida) disponível dentro do próprio objeto e suas sub classes.
  • STATIC (estático) é um atributo cujo valor é compartilhado entre todos os objetos em uma classe e não é dependente de instanciação, em ABAP a palavra chave Static não é utilizada e é referida como sendo “da classe” ou seja dados da classe, métodos da classes.

Um atributo público pode ser designado como somente leitura. Dentro da definição de classe, o setor público deve vir antes do setor privado.

Um atributo estático muitas vezes usado para coisas como contadores ocorrência de objeto e como os dados pertencem à classe e é compartilhado entre os objetos, ele é declarado como CLASS-DATA.

Método

  • Na definição de classe, a definição do método indica um método de interface.
  • Métodos podem ser designados como públicos ou privados.
  • Um método privado só pode ser chamado de dentro de outro método da classe.
  • Métodos de classe podem ser definidos e estes métodos só podem acessar atributos estáticos.
  • Métodos de classe podem ser invocados usando o nome da classe ou um objeto da classe.
  • Um objeto não precisa ser instanciado para chamar uma método de classe.
  • Código para a funcionalidade de um método é colocado na implementação da classe.
  • Os nomes de parâmetros e tipos não estão listados, pois eles já foram declarados na definição da classe.

Parâmetros do método:

IMPORTING – Parâmetros importador de entrada, usado para transferir dados de um método. Pode ser designado como opcional. Pode ter um valor padrão especificado.

EXPORTING – Parâmetros exportadores de saída. Parâmetros de exportação são sempre opcionais (por padrão).

CHANGING – Mudança de combinação acima. Passado para o método a ser utilizado. Pode ser alterado. Pode ser designado como opcional. Pode ter um valor padrão especificado.

Construtor

Uma classe pode definir um método construtor chamado constructor. O método deve ter parâmetros públicos e só importadores. O construtor não é chamado explicitamente, mas é chamado implicitamente quando um novo objeto é criado. Em ABAP Objects um método construtor não pode ser sobrecarregado (Overload) utilizando um outro método construtor, entretanto é possível criar este efeito através de parâmetros opcionais.

Construtores são úteis para:

  • Inicializar os atributos de um objeto.
  • Alocação de recursos para o objeto.
  • Modificando atributos estáticos (programação).
  • Disparando outras atividades que precisam acontecer quando um novo objeto é criado.

Auto Referencia

Dentro de um método, a referência aos atributos do objeto ou outros métodos geralmente não pode ser ambígua. Em caso de ambigüidade (um parâmetro tem o mesmo nome de um atributo), você pode se referir ao objeto, seus atributos e seus métodos usando: me.

Sintaxe:

me-> nomedotributo.

DIAGRAMA DE UMA CLASSE

Classe - Diagrama

Classe – Diagrama

CLASS BUILDER – SE24

O Class Builder permite criar e manter as classes ABAP globais e interfaces. Ambos os tipos de objetos, como os tipos de dados globais, são definidos no Repositório ABAP, compondo, assim, uma biblioteca de classes central. Juntos, eles formam uma biblioteca de classe central e são visíveis em todo o sistema. Você pode exibir as classes e interfaces existentes na biblioteca de classes usando o navegador de classe.

Criando Uma Classe no Class Builder

1 –  Entre com a transação SE24.

bicicleta1

2 – Crie a Classe ZBICICLETA como na imagem acima, utilizando os mesmos parâmetros mostrados em cada janela da imagem, na ultima janela acima escolha Local Object.

bicicleta2

3 – Na aba Attributes crie os atributos MODELO, QUADRO, RODAS, FREIOS como String, utilize a imagem acima para referencia.

bicicleta3

4 – Na aba Methods, crie o método BICICLETA utilizando a imagem acima como referencia.

bicicleta4

5 – Na barra de tarefas clique em Source Code Based para ver o código fonte da classe, também é permitido altera-lo caso seja necessário.

6 – Digite o código como mostra na imagem acima para o método BICICLETA e clique em salvar, volte uma tela e clique em ACTIVATE para ativar a classe.

7 – Pronto já temos nossa classe ZBicicleta com quatro atributos e um método BICICLETA, agora entre na transação SE38 e crie um programa para nosso exemplo abaixo onde utilizaremos nossa classe.

Exemplo:

Neste exemplo instanciaremos a classe ZBICICLETA criada no Class Builder utilizando os parâmetros acima, criaremos uma nova classe chamada MOUNTAINBIKE utilizando parâmetros em seu construtor.

Obs: Para que uma classe forme um objeto completo é necessário métodos de entrada e saída. A classe abaixo ainda não contempla o conceito de métodos Getter e Setter (C++, Java e Abap) também equivalentes a propriedades em outras linguagens de programação (Delphi, C#, Python). Estes métodos são essências na manipulação dos atributos, veremos estes métodos no tópico exclusivo com o assunto métodos.

Abap

*&---------------------------------------------------------------------*
*& Report  ZLOJA
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Classes ABAP
*&---------------------------------------------------------------------*

REPORT  ZLOJA.

* Define Classe dinamicamente.

class MOUNTAINBIKE definition.

PUBLIC SECTION.

data MODELO type STRING .
data QUADRO type STRING .
data FREIOS type STRING .
data RODAS  type STRING .

methods CONSTRUCTOR IMPORTING
                        PMODELO TYPE STRING
                        PQUADRO TYPE STRING
                        PFREIOS TYPE STRING
                        PRODAS  TYPE STRING.

methods BICICLETA .

ENDCLASS.

CLASS MOUNTAINBIKE IMPLEMENTATION.

method BICICLETA.

" Minha implementação.

WRITE: / ' Bicicleta:', modelo.
WRITE: / ' Quadro:', quadro.
WRITE: / ' Rodas:', rodas.
WRITE: / ' Freios:',  freios.

endmethod.

method CONSTRUCTOR.

me->MODELO = pmodelo.
me->QUADRO = pquadro.
me->RODAS  = prodas.
me->FREIOS = pfreios.

endmethod.

ENDCLASS.

* Cria objetos Bicicleta - definidos na CLASS BUILDER.

START-OF-SELECTION.
DATA BIKE1 TYPE REF TO ZBICICLETA.
CREATE OBJECT BIKE1.

DATA BIKE2 TYPE REF TO ZBICICLETA.
CREATE OBJECT BIKE2.

* Alimenta Variáveis
* Tem uma pegadinha aqui! você já descobriu?

* Objeto Bicicleta #1
MOVE 'BMX'       TO BIKE1->MODELO.
MOVE 'Ferro'     TO BIKE1->QUADRO.
MOVE 'Ferro'     TO BIKE1->RODAS.
MOVE 'Pastilhas' TO BIKE1->FREIOS.

* Objeto Bicicleta #2
MOVE 'Caloi'        TO BIKE1->MODELO.
MOVE 'Aluminio'     TO BIKE1->QUADRO.
MOVE 'Aluminio'     TO BIKE1->RODAS.
MOVE 'Pastilhas'    TO BIKE1->FREIOS.

* Chama o metodo bicicleta

CALL METHOD BIKE1->BICICLETA.

WRITE: / .

CALL METHOD BIKE2->BICICLETA.

* Objeto criado usando o  metodo Construtor

WRITE: / .

DATA BIKE3 TYPE REF TO MOUNTAINBIKE.

CREATE OBJECT BIKE3 EXPORTING

pMODELO = 'ZX-Track'
pQUADRO = 'Fibra de Carbono'
pFREIOS = 'Disco'
pRODAS  = 'Aluminio'.

CALL METHOD BIKE3->BICICLETA.

Web Spider – Captura Links de Website

Publicado: 23 de fevereiro de 2014 em Hacking

Um Spider simples coleta o conteúdo da Internet

Spider é um programa que visita sites e lê suas páginas e outras informações, a fim de criar entradas para um índice de motor de busca. Os principais motores de busca na Web, todos têm um programa desse tipo, o que também é conhecido como um “crawler” ou um “bot”. Os spiders são normalmente programados para visitar sites que tenham sido apresentados por seus proprietários como novos ou atualizados. Sites inteiros ou páginas específicas podem ser visitados e indexados de forma seletiva. Spiders são chamados de aranhas, porque eles costumam visitar muitos locais, em paralelo, ao mesmo tempo, as suas “pernas” que abrangem uma grande área do “web”. As aranhas podem rastejar através de páginas de um site de várias maneiras. Uma maneira é seguir todos os links de hipertexto em cada página até que todas as páginas foram lidas.

Pernas do Spider

O Web spider usa principalmente o HTTP para olhar e mover-se pela Internet. HTTP é um protocolo orientado à mensagem no qual um cliente se conecta a um servidor e emite pedidos. O servidor fornece uma resposta. Cada pedido e resposta é composto de cabeçalho e corpo, com o cabeçalho fornecendo informações de status e uma descrição do conteúdo do corpo.

Coleta de e-mail

Agora o lado ruim dos crawlers. Infelizmente, pessoas mal intencionadas podem efetuar estragos na Internet. Os crawlers de coleta de e-mail procuram por endereços de e-mail em Web sites que são então utilizados para gerar o spam em massa que vemos diariamente.

A coleta de e-mail pode ser uma das atividades de crawl mais fáceis.

Exemplo:

Requisitos: Package Termcolor – https://pypi.python.org/pypi/termcolor

Neste exemplo em Python executamos o script do nosso Spyder via terminal do linux, passando o nome do web site como parametro e logo nosso Spyder analisa todas as paginas do site e captura todos os links do site.

Este exemplo pode ser modificado para capturar varias outras informações do website.

Executar: python spyder.py http://nomedosite.com

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-

# Estes modulos fazem a maioria do trabalho.
import sys
import urllib2
import urlparse
import htmllib, formatter
from cStringIO import StringIO
from termcolor import colored

def log_stdout(msg):
     """imprime menssagem na tela"""
     print colored(msg,"cyan")

def get_page(url, log):
     """Retorna URL e seus conteudos, log erros."""
     try:
         page = urllib2.urlopen(url)
     except urllib2.URLError:
         log("Retornando Erros : " + url)
         return ''
     body = page.read()
     page.close()
     return body

def find_links(html):
     """Retorna uma lista de links html."""
     # Usa para validar  as urls e retornar as HREFs
     writer = formatter.DumbWriter(StringIO())
     f = formatter.AbstractFormatter(writer)
     parser = htmllib.HTMLParser(f)
     parser.feed(html)
     parser.close()
     return parser.anchorlist

class Spider:

    """
    O coração do programa, encontra todos os links em web site.
    run() contem o loop principal.
    process_page() retorna cada pagina e encontra os links.
    """

    def __init__(self, startURL, log=None):
         # Este metodo seta valores iniciais
         self.URLs = set()
         self.URLs.add(startURL)
         self.include = startURL
         self._links_to_process = [startURL]
         if log is None:
             # Use log_stdout se não providenciar log
             self.log = log_stdout
         else:
             self.log = log

    def run(self):
         # Processa lista de URLs de uma vez
         while self._links_to_process:
             url = self._links_to_process.pop()
             self.log("Retornando: " + url)
             self.process_page(url)

    def url_in_site(self, link):
         # Checa quando o link começa com uma base URL
         return link.startswith(self.include)

    def process_page(self, url):
         # Retorna a pagina e checa o link nela
         html = get_page(url, self.log)
         for link in find_links(html):
             # Manipula oslinks relativos
             link = urlparse.urljoin(url, link)
             self.log("Checking: " + link)
             # Obtendo certeza que este é um novo link
             if link not in self.URLs and self.url_in_site(link):
                 self.URLs.add(link)
                 self._links_to_process.append(link)

if __name__ == '__main__':
     # Este codigo roda quando o script é rodado na linha de comando
     startURL = sys.argv[1]
     spider = Spider(startURL)
     spider.run()
     for URL in sorted(spider.URLs):
         print colored(URL, "blue")

Packages – Python – Linux

Publicado: 23 de fevereiro de 2014 em Python

Uma Package (pacote) é uma coleção de módulos relacionados armazenados em um diretório e subdiretórios.

Um __name__ é um __name__, exceto quando é __ main__

Dentro de um módulo, o nome do módulo (como uma string) é armazenado no nome global __ name__.

Mas há uma exceção: Se o arquivo de módulo é executado como um programa a partir da  linha de comando, Python define __ name__ do módulo para ‘__main__‘.

Este recurso é útil para incluir código (geralmente o código de teste) em um arquivo de módulo que é executado somente quando você iniciar o módulo a partir da linha de comando (digitando: python nomedomodulo.py).

O código fica assim:


if __name__ == '__main__':

do something

Quando você inclui o código que é executado somente sob essas circunstâncias, você não tem que remover o código quando você importa o módulo. Isso porque quando um módulo é importado, __ name__ é o nome do módulo, não ‘__main__‘.

Este código vai fora de quaisquer definição de função ou declarações de importação no módulo, geralmente no final do módulo.

Os efeitos de pacotes

Os pacotes são uma outra maneira de tirar vantagem da capacidade do Python para ocultar a complexidade.

Pacotes tem alguns recursos úteis:

  • Um pacote tem seu próprio namespace.
  • Nomes definidos dentro de um módulo,  incluindo nomes de módulos não conflitam com os nomes definidos em outro lugar.
  • Os pacotes podem conter módulos.
  • Os pacotes podem conter sub pacotes.
  • Pacotes são ideais para armazenar e organizar uma série de características relacionadas.

Requisitos e Orientações Para os Pacotes:

  • Um pacote vive dentro de um diretório e seus sub pacotes vivem dentro de sub diretórios desse diretório (em geral).
  • Assim como um módulo de arquivos nomeia o módulo, um pacote de diretório nomeia o pacote.
  • Isso permite importar itens do pacote, usando a importação no formato packagename.modulename.
  • Um diretório do pacote deve conter um arquivo chamado __ init__.py.

No caso mais simples, __ init__.py é apenas um arquivo vazio. Mas, muitas vezes, contém código que inicializa o pacote. Por exemplo, a melhor maneira de importar um específico sub módulo com um pacote ou sub pacotes particular é carregá-los no arquivo __init__.py.

O arquivo __init__.py às vezes contém a lista: __ all__

Esta lista ajuda código Python executado em diferentes sistemas operacionais. Quando você inclui nomes de módulos em __all__, o comando de importação: from packagename import * – importa apenas estes módulos.

Sobre diretórios e pacotes especiais

Quando Python é instalado, ele cria diretórios específicos para pacotes. Se você armazenar pacotes em um desses diretórios especiais de pacote, é menos provável ter problemas se os seus nomes de pacotes são os mesmos que os nomes dos módulos em outros lugares no caminho Python.

  • Diretório: lib/local-python/  – Este diretório é para pacotes que funcionam da mesma maneira com todas as versões do Python.
  • Diretório: Lib/pythonXX/site-packages/ – Este diretório é para os pacotes que dependem da versão do Python. Alterações XX representam o número da versão do Python.

Estrutura de Packages

Você pode ver melhor como é uma estrutura de packages Python na imagem abaixo:

pacotes

 Exemplo:

Neste exemplo criamos um projeto chamado Prj_Dev01 e na raiz do projeto temos o modulo principal.py, logo temos um pacote chamado devaberto(em Python uma package é apenas um diretório que contém o arquivo __init__.py) e dentro dele temos um modulo chamado msg.py e o arquivo de controle do pacote chamado __init__.py.

Python

Principal.py

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# Principal.py

# Importa pacote
import devaberto.msg

# Importa OS
import os

# Limpa a tela
os.system("clear")

print "Modulo Principal"

print "\n"

devaberto.msg.menssagem("Minha menssagem")
devaberto.msg.msg2('menssagem2')

# Cria uma espera no terminal
raw_input()

__init__.py

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto

__all__ = ['msg']
# Importa pacote
import msg

msg.py

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# msg.py

def menssagem (x):
     print x

def msg2(x):
     print x
     print x