Exemplo de Aplicação da Biblioteca Numpy

 

- Vetor não ordenado, orientado a objetos

import numpy as np

class Vetor :

def __init__ ( self , tamanho ) :

self .tamanho = tamanho

self .ultimo = -1

self .elementos = np.empty ( self .tamanho , dtype = int )

def exibe_em_tela ( self ) :

if self .ultimo == -1 :

print ( 'Vetor vazio!!!' )

else :

for i in range ( self .ultimo + 1 ):

print ( i , self .elementos [ i ])

def insere_elemento ( self , elemento ) :

if self .ultimo == self .tamanho -1 :

print ( 'Capacidade máxima atingida' )

else :

self .ultimo += 1

self .elementos [ self .ultimo ] = elemento

def pesquisa_elemento ( self , elemento ) :

for i in range ( self .ultimo + 1 ):

if elemento == self .elementos [ i ]:

return i

return -1

def exclui_elemento ( self , elemento ) : posicao = self .pesquisa_elemento ( elemento )

if posicao == -1 :

return -1

else :

for i in range ( posicao , self .ultimo ):

self .elementos [ i ] = self .elementos [ i + 1 ]

self .ultimo -= 1

 

Partindo para prática, vamos simular uma simples aplicação, toda implementada fazendo o uso de recursos da biblioteca Numpy, onde é criada uma estrutura de vetor não ordenado.

Inicialmente, é necessário sempre realizar as devidas importações das bibliotecas, módulos e pacotes que iremos utilizar ao longo de nosso código. Nesse caso, bastando importar a biblioteca numpy, por convenção a referenciando como np.

Em seguida é criada uma classe de nome Vetor, dentro de seu corpo/escopo, é criado um método construtor/inicializador __init__( ) que define o escopo dessa classe para seus objetos, e que por sua vez receberá obrigatoriamente um dado/valor a ser utilizado como referência para o tamanho fixo deste vetor.

Sendo assim, são criados alguns objetos de classe, onde o primeiro deles é self.tamanho, que recebe o valor atribuído a tamanho. Também é criado um outro objeto de classe de nome self.ultimo, que recebe como atributo o valor inicial -1, que por sua vez define um gatilho a ser acionado quando o vetor atingir sua capacidade máxima de elementos.

Por fim, é criado um último objeto de classe chamado self.elementos, que recebe como atributo inicial uma array do tipo numpy vazia, porém já com tamanho definido baseado no valor do objeto tamanho, assim como já é aproveitada a deixa para estabelecer o tipo de dado que irá obrigatoriamente compor este vetor.

Na sequência é criado um novo método de classe, dessa vez de nome exibe_em_tela( ), que como o próprio nome já sugere, quando instanciado e inicializado, retornará a própria estrutura array desse vetor.

Para isso, inicialmente é criada uma estrutura condicional que verifica se o valor de self.ultimo for igual a -1, então exibe em tela via função print( ) a mensagem ‘Vetor vazio!!!’.

Caso essa condição não seja válida, por meio de um laço for é percorrido cada elemento de nosso vetor, a cada ciclo de repetição exibindo o mesmo assim como seu número de índice.

Dando sequência em nosso código, é criado um novo método de classe, dessa vez chamado insere_elemento( ), que recebe como parâmetro um elemento.

Dentro do corpo desta função inicialmente é criada uma estrutura condicional onde se o valor atribuído a self.ultimo for igual ao valor de self.tamanho – 1, é exibido em tela a mensagem ‘Capacidade máxima atingida’.

Caso contrário, self.ultimo tem seu valor incrementado em 1 unidade, assim como para self.elementos na posição [self.ultimo] é inserido o novo elemento anteriormente repassado como parâmetro para nossa função insere_elemento( ).

Na sequência é criado um novo método de classe, agora chamado pesquisa_elemento( ) que por sua vez receberá como parâmetro um elemento.

No bloco indentado a esta função temos um laço de repetição for que percorre cada um dos elementos de nosso vetor, validando se o valor atual de elemento é igual a self.elementos na posição [i], caso seja igual, é retornado o último valor atribuído a i, caso não seja igual, é retornado -1.

Por fim, é criado um último método de classe, dessa vez de nome exclui_elemento( ) que receberá por justaposição um elemento como parâmetro.

Dentro do corpo dessa função é criada uma variável local de nome posição, que por sua vez recebe como atributo os dados/valores oriundos da função aninhada self.pesquisa_elemento(elemento).

Em seguida é criada uma estrutura condicional onde se o valor de posição for igual a -1, é retornado -1, caso contrário, é feito o uso de um laço de repetição que percorrerá todos os elementos de posição equiparados com self.ultimo.

A partir deste ponto, self.elementos na posição [i] tem seu valor atualizado com o último valor atribuído a self.elementos em sua posição [i + 1], finalizando com o decremento de sela.ultimo em 1 unidade.

base = Vetor ( 10 )

base.exibe_em_tela ()

 

Devolta ao escopo global do código, é criada uma variável de nome base que por sua vez instancia e inicializa a classe Vetor( ), repassando como argumento para a mesma o valor 10. Em outras palavras, aqui a variável base importa toda a estrutura interna da classe Vetor, assim como define um tamanho fixo de vetor em 10 elementos.

Usando do método base.exibe_em_tela( ) o retorno gerado neste momento é ‘Vetor vazio!!!”, uma vez que ainda não inserimos elementos no mesmo.

base.insere_elemento ( 9 )

base.insere_elemento ( 3 )

base.exibe_em_tela ()

 

Usando do método insere_elemento( ) atrelado a nossa variável base, podemos inserir alguns elementos em nosso vetor. Novamente, usando do método exibe_em_tela( ), nos é retornado o vetor representado por seus elementos.

0 9

1 3

print ( base.pesquisa_elemento ( 9 ))

Realizando outro tipo de interação com nosso vetor, podemos usar de nosso método pesquisa_elemento( ) parametrizado com o elemento em si para descobrir sua posição de índice no vetor.

print ( base.ultimo )

 

Também é possível pesquisar diretamente o último valor atribuído para o objeto ultimo, usando desse retorno, que será um número de índice, para descobrirmos quantos elementos compõe nosso vetor.

base.insere_elemento ( 1 )

base.insere_elemento ( 4 )

base.insere_elemento ( 5 )

base.insere_elemento ( 12 )

base.insere_elemento ( 20 )

base.exibe_em_tela ()

 

Uma vez que nosso vetor esteja definido, assim como para o mesmo não exista nenhum conflito de interação ou até mesmo de sintaxe, podemos manipular este vetor à vontade.

Inserindo alguns elementos via método insere_elemento( ), podemos visualizar nosso vetor instanciando e executando o método exibe_em_tela( ) sempre que necessário.

0 9

1 3

2 1

3 4

4 5

5 12

6 20

base.exclui_elemento ( 12 )