diff --git a/oo/__init__.py b/oo/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/oo/carro.py b/oo/carro.py new file mode 100644 index 000000000..6d91a7153 --- /dev/null +++ b/oo/carro.py @@ -0,0 +1,154 @@ + + + +""" +Criar uma classe carro que vai possuir dois atributos compostos por outras duas classes: + +1) Motor +2) Direção + +O motor deverá controlar a velocidade. +Ele oferece os seguintes atributos: +1) Atributo de velocidade +2) Método acelerar, que deverá incrementar a velocidade de uma unidade +3) Método frear que deverá decrementar a velocidade em duas unidades + +A direção deverá controlar a direção. +Oferece os seguintes atributos: +1)Valor de direção com valores possíveis: norte, Sul, Leste, Oeste. +2)Método girar a direita +2)Método girar a esquerda + + N + O L + S + + Exemplo: + #Testando motor + >>> motor = Motor() + >>> motor.velocidade + 0 + >>> motor.acelerar() + >>> motor.velocidade + 1 + >>> motor.acelerar() + >>> motor.velocidade + 2 + >>> motor.acelerar() + >>> motor.velocidade + 3 + >>> motor.frear() + >>> motor.velocidade + 1 + >>> motor.frear() + >>> motor.velocidade + 0 + >>> direcao = Direcao() + >>> direcao.valor + 'Norte' + >>> direcao.girar_a_direita() + >>> direcao.valor + 'Leste' + >>> direcao.girar_a_direita() + >>> direcao.valor + 'Sul' + >>> direcao.girar_a_direita() + >>> direcao.valor + 'Oeste' + >>> direcao.girar_a_direita() + >>> direcao.valor + 'Norte' + >>> direcao.girar_a_esquerda() + >>> direcao.valor + 'Oeste' + >>> direcao.girar_a_esquerda() + >>> direcao.valor + 'Sul' + >>> direcao.girar_a_esquerda() + >>> direcao.valor + 'Leste' + >>> direcao.girar_a_esquerda() + >>> direcao.valor + 'Norte' + >>> carro = Carro(direcao, motor) + >>> carro.calcular_velocidade() + 0 + >>> carro.acelerar() + >>> carro.calcular_velocidade() + 1 + >>> carro.acelerar() + >>> carro.calcular_velocidade() + 2 + >>> carro.frear() + >>> carro.calcular_velocidade() + 0 + >>> carro.calcular_direcao() + 'Norte' + >>> carro.girar_a_direita() + >>> carro.calcular_direcao() + 'Leste' + >>> carro.girar_a_esquerda() + >>> carro.calcular_direcao() + 'Norte' + >>> carro.girar_a_esquerda() + >>> carro.calcular_direcao() + 'Oeste' + + +""" +NORTE = 'Norte' +SUL = 'Sul' +LESTE = 'Leste' +OESTE = 'Oeste' + +class Carro: + def __init__(self, direcao, motor): + self.motor = motor + self.direcao = direcao + + def calcular_velocidade(self): + return self.motor.velocidade + + def acelerar(self): + self.motor.acelerar() + + def frear(self): + self.motor.frear() + + def calcular_direcao(self): + return self.direcao.valor + + def girar_a_direita(self): + self.direcao.girar_a_direita() + + def girar_a_esquerda(self): + self.direcao.girar_a_esquerda() + + + + +class Motor: + def __init__(self): + self.velocidade = 0 + + def acelerar(self): + self.velocidade += 1 + + def frear(self): + self.velocidade -=2 + self.velocidade = max(0, self.velocidade) + + + +class Direcao: + rotacao_a_direita_dct = {NORTE : LESTE, LESTE : SUL, SUL : OESTE, OESTE : NORTE} + rotacao_a_esquerda_dct = {NORTE: OESTE, LESTE: NORTE, SUL: LESTE, OESTE: SUL} + def __init__(self): + self.valor = NORTE + + def girar_a_direita(self): + self.valor = self.rotacao_a_direita_dct[self.valor] + + def girar_a_esquerda(self): + self.valor = self.rotacao_a_esquerda_dct[self.valor] + diff --git a/oo/pessoa.py b/oo/pessoa.py new file mode 100644 index 000000000..ddd280024 --- /dev/null +++ b/oo/pessoa.py @@ -0,0 +1,66 @@ + + +class Pessoa: + olhos = 2 #atributo de classe , criado quando é um valor padrão, igual para todos os objetos que serão criados + + def __init__(self,*filhos, nome=None, idade=35, altura=1.70): #atributo de instancia ou do objeto,os valores são diferentes para cada objeto, cria um campo ao objeto que será criado p + self.altura = altura + self.idade = idade + self.nome = nome + self.filhos = list(filhos) #Atributo complexo, lista de filhos + + def cumprimentar(self): #método cumprimentar() - Atributo da classe + print('ola', self.nome) + + @staticmethod # modo 01 - decorator para criação do método de classe + def metodo_estatico(): #o método de classe independe do objeto, pois esta atrelado a classe, assim como o atributo de classe + return 50 + + @classmethod + def nome_atributos_de_classe(cls): #modo 02 - decorator para criação de método de classe, usado quando que acessar os atributo e métodos da prórpia classe + return f'{cls}, {cls.olhos}, {cls.metodo_estatico()}' + + +if __name__ == '__main__': + jacson = Pessoa(nome='jacson') #criado o objeto p do tipo Pessoa e atribuindo valor ao campo nome + + joao = Pessoa(jacson, nome='joao') #criado o objeto p do tipo Pessoa e atribuindo valor ao campo nome + pedro = Pessoa(joao, nome='Pedro') + + print(jacson.cumprimentar()) #executando o método cumprimentar + print(jacson.nome) #acessando o atributo de instancia + jacson.nome = 'Jacson' #Alterando o valor do atributo de instância + print(jacson.nome) #acessando e Imprimindo o novo valor do atributo + print(jacson.idade) + print(jacson.altura) #Mostrando o valor do campo altura do objeto p + jacson.cumprimentar() # executando o método cumprimentar + + for filho in joao.filhos: #acessando o atributo complexo filhos + print(filho.nome) + + for filho in pedro.filhos: #acessando o atributo complexo filhos + print(filho.nome) + + jacson.sobrenome = 'jeremias' #criando atributo dinâmico, ou seja é um atributo criado em tempo de execução do programa, ele não foi executado no __init__ + print(jacson.sobrenome) + + #print(joao.sobrenome) #o atributo dinâmico é criado apenas no objeto que foi criado, no exemplo tentou-se acessar o atributo pelo objeto joão mas da erro + + print(jacson.nome, jacson.__dict__) #__dict__ acessa todos os atributos do objeto, inclusive os atributos dinâmicos + print(joao.nome, joao.__dict__, '\n') #__dict__ acessa todos os atributos do objeto + + del joao.filhos #removendo atributo dinamicamente + print('Após ser deletado o atributo filhos do objeto joão \n') + print(jacson.nome, jacson.__dict__) # __dict__ acessa todos os atributos do objeto, inclusive os atributos dinâmicos, no entanto não acessa os atributos de classe + print(joao.nome, joao.__dict__) # __dict__ acessa todos os atributos do objeto, no entanto não acessa os atributos de classe + + print(Pessoa.olhos) #Acessando o atributo de classe + print(jacson.olhos) #todos os objetos criados terão automaticamente o atributo da classe + print(id(Pessoa.olhos),id(jacson.olhos),id(joao.olhos)) #acessando pela classe ou pelo objeto criado o id do atributo de classe é o mesmo para todos + + print(Pessoa.metodo_estatico()) #o método de classe pode acessado diretamente pela classe, quanto pelo objeto + print(jacson.metodo_estatico()) #acessando o método de classe atraves do objeto + + print(Pessoa.nome_atributos_de_classe()) #o método de classe pode acessado diretamente pela classe, quanto pelo objeto + print(jacson.nome_atributos_de_classe()) #acessando o método de classe atraves do objeto +