Objectos com Classe!!

Temos estado a discutir como a definição de uma estrutura de dados adequada pode ser benéfica para a qualidade da programação. A estrutura de dados tem duas componentes: o objecto propriamente dito, devidamente representado, e um conjunto de operações sobre o objecto, operações que dependem da representação escolhida. Dizemos que as operações escondem o objecto do exterior, ou, dito de outro modo, o objecto fica encapsulado pelas operações. Normalmente o programador deve-se preocupar em definir estrutura de dados que sejam eficientes computacionalmente, passando, se for esse o caso, a só ter que se preocupar com as funcionalidades oferecidas pela estrutura. O leitor mais atento já ligou este aspecto ao que se passa com os tipos de dados das linguagens de programação: nós operamos com números inteiros, por exemplo, sem cuidar de saber como é que estes inteiros estão organizados. Apenas nos interessam as funcionalidades. Alguém teve o trabalho de definir esses tipos para nós. Mas será que nós podemos definir novos tipos de dados com as mesmas características de abstracção? Já vimos que sim! Mas podemos fazer, diferente, para melhor? Uma vez mais a resposta é sim, e liga-se ao conceito de objecto tal como é usado em programação orientada aos objectos: o objecto é um todo englobando as duas componentes acima referidas.


Neste paradigma de programação o conceito de classe é central. De um modo simples, uma classe é um modelo abstracto de objectos. Traduz as características comuns a todos os objectos da classe.Na vida comum nós falamos da classe dos mamíferos, sendo o meu cão ‘Bobi’ e eu objectos dessa classe. Dizemos que os objectos são instâncias da classe. Repetindo: os objectos formam um todo com as suas características (estado) definidas por meio de atributos (por exemplo, palavra, letras usadas, tentativas) e as operações (por exemplo, add_letra_pal) determinando o seu comportamento.


Em Python todos os tipos de dados são implementados como classes. Vamos tentar fazer o mesmo com o conceito de estado apresentado no problema 8.9.

view sourceprint?

01.# classe Estado

02.class Estado(object):

03.     

04.    # Construtor

05.    def __init__(self,palavra =[],usadas=[],tentativas=0):

06.        """ Cria estado 'vazio'."""

07.        self.palavra = list(palavra)

08.        self.usadas = list(usadas)

09.        self.tentativas = tentativas

10.     

11.    # Acessores

12.    def get_estado(self):

13.        # Devolve estado

14.        return (self.palavra, self.usadas, self.tentativas)

15. 

16.    def get_pal(self):

17.        return  self.palavra

18. 

19.    def get_letras(self):

20.        return self.usadas

21. 

22.    def get_tentativas(self):

23.        return  self.tentativas

24. 

25.    # Modificadores

26.    def set_estado(self, palavra,letras,tentativas):

27.        # Altera estado

28.        self.palavra = list(palavra)

29.        self.usadas = list(letras)

30.        self.tentativas = tentativas

31. 

32. 

33.    def set_palavra(self,pal):

34.        self.palavra = list(pal)

35. 

36. 

37.    def set_usadas(self,letras):

38.        self.usadas = list(letras)

39. 

40. 

41.    def set_tentativas(self,tenta):

42.        if tenta >= 0:

43.            self.tentativas = tenta

44.        else:

45.            print 'O valor não pode ser negativo. Foi indicado %d.' % tenta  

46. 

47. 

48.    def add_letra_palavra(self, letra,l_pos):

49.        """ Junta a letra em todas as posições não ocupadas indicadas em l_pos."""

50.        for ind in l_pos:

51.            if self.palavra[ind] == '_':

52.                self.palavra[ind] = letra

53.            else:

54.                print 'Posição %d já ocupada. Estado inalterado!' % ind

55. 

56. 

57.    def add_letra_usadas(self, letra):

58.        """ Junta a letra às letras usadas."""

59.        if not letra in self.usadas:

60.            self.usadas.append(letra)

61.        else:

62.            print '%s já existente. Estado inalterado!' % letra

63. 

64.    def add_tentativas(self,tenta):

65.        """ Modifica o valor das tentivas em tenta."""

66.        novo_valor = self.tentativas + tenta

67.        if novo_valor >= 0:

68.            self.tentativas = novo_valor

69.        else:

70.            print 'O valor não pode ser negativo. o Resultado foi %d.' % novo_valor   

71. 

72. 

73.    # Auxiliares

74.    def __str__(self):

75.        palavra = ' '.join(self.palavra)

76.        usadas =  ', '.join(self.usadas)

77.        tentativas = self.tentativas

78.        return 'Palavra: %s\nUsadas: %s\nTentativas: %d' % (palavra,usadas,tentativas)

79. 

80.if __name__ == '__main__':

81.    estado = Estado()

82.    estado.set_palavra('__n_n_')

83.    estado.add_letra_usadas('b')

84.    estado.set_tentativas(7)

85.    print estado

86.    estado.add_letra_usadas('b')

87.    estado.set_tentativas(-4)

88.    estado.add_letra_palavra('a',[1,2,3,5])

89.    estado.add_letra_usadas('a')

90.    print estado

Carregue o código e execute-o. Sem entrar em muitos detalhes, o que podemos dizer por comparação ao que fizemos anteriormente?

(1) Aparece uma nova construção denominada classe;

(2) As definições anteriormente apresetnadas estão agora no interior da classe;

(3) O construtor tem agora o nome __init__ (trata-se de um método especial que permite ao utilizador fugir ao construtor por defeito);

(4) Já não temos um dicionários mas sim atributos do objecto definidos no interior do método __init__;

(5) O nome da estrutura (estado) é substituído pelo nome genérico self;

(6) Os modificadores alteram os atributos e não devolvem por return;

(7) A chamada dos métodos da classe usa a notação por ponto (dot notation);

(8) Na chamada dos métodos não se usa o parâmetro self


Muito mais poderia ser dito, mas ficamos por aqui. O leitor interessado pode alterar o código do enforcado para usar a nova classe.