From e15eec5dc0f7b0db3321c274d12519364f702b28 Mon Sep 17 00:00:00 2001 From: GustavoSuto Date: Fri, 15 Nov 2019 16:00:13 -0300 Subject: [PATCH 01/18] created Pessoa class --- oo/__init__.py | 0 oo/pessoa.py | 2 ++ 2 files changed, 2 insertions(+) create mode 100644 oo/__init__.py create mode 100644 oo/pessoa.py diff --git a/oo/__init__.py b/oo/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/oo/pessoa.py b/oo/pessoa.py new file mode 100644 index 000000000..e1da50e22 --- /dev/null +++ b/oo/pessoa.py @@ -0,0 +1,2 @@ +class Pessoa: + pass \ No newline at end of file From 838ba7a987f98914dc93cf0959a08fdeb470a087 Mon Sep 17 00:00:00 2001 From: GustavoSuto Date: Fri, 15 Nov 2019 16:20:35 -0300 Subject: [PATCH 02/18] created cumprimentar method --- oo/pessoa.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/oo/pessoa.py b/oo/pessoa.py index e1da50e22..02fde550e 100644 --- a/oo/pessoa.py +++ b/oo/pessoa.py @@ -1,2 +1,8 @@ class Pessoa: - pass \ No newline at end of file + def cumprimentar(self): + return f"Olá, {id(self)}" + +if __name__ == '__main__': + p = Pessoa() + print(id(p)) + print(p.cumprimentar()) \ No newline at end of file From e88b3723bcf9d305c6c847300df99cf708f48675 Mon Sep 17 00:00:00 2001 From: GustavoSuto Date: Fri, 15 Nov 2019 19:01:17 -0300 Subject: [PATCH 03/18] created instance attributes --- oo/pessoa.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/oo/pessoa.py b/oo/pessoa.py index 02fde550e..2b016e386 100644 --- a/oo/pessoa.py +++ b/oo/pessoa.py @@ -1,8 +1,15 @@ class Pessoa: + def __init__(self, nome="Gustavo", idade=35): + self.idade = idade + self.nome = nome + def cumprimentar(self): return f"Olá, {id(self)}" if __name__ == '__main__': p = Pessoa() print(id(p)) - print(p.cumprimentar()) \ No newline at end of file + print(p.cumprimentar()) + print(p.nome) + p = Pessoa("Suto") + print(p.nome) From 85b14ba1be5eba6e22f5b226f84aab33d6cf06c3 Mon Sep 17 00:00:00 2001 From: GustavoSuto Date: Fri, 15 Nov 2019 19:22:31 -0300 Subject: [PATCH 04/18] created complex instance attributes --- oo/pessoa.py | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/oo/pessoa.py b/oo/pessoa.py index 2b016e386..3ff478a5e 100644 --- a/oo/pessoa.py +++ b/oo/pessoa.py @@ -1,15 +1,16 @@ class Pessoa: - def __init__(self, nome="Gustavo", idade=35): + def __init__(self, *filhos, nome="Gustavo", idade=35): self.idade = idade self.nome = nome + self.filhos = list(filhos) def cumprimentar(self): - return f"Olá, {id(self)}" + return f"Olá, {self.nome}!" if __name__ == '__main__': - p = Pessoa() - print(id(p)) - print(p.cumprimentar()) - print(p.nome) - p = Pessoa("Suto") - print(p.nome) + filho01 = Pessoa(nome="Gu", idade=34) + filho02 = Pessoa(nome="Gui", idade=32) + pai = Pessoa(filho01, filho02, nome="José", idade=64) + print(pai.cumprimentar()) + print(f"{pai.nome} tem {pai.idade} anos e {len(pai.filhos)} filhos.") + From 11f1fb89dd93d07663a3e8bfe6b4b74b02179000 Mon Sep 17 00:00:00 2001 From: GustavoSuto Date: Fri, 15 Nov 2019 19:25:59 -0300 Subject: [PATCH 05/18] created complex instance attributes --- oo/pessoa.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/oo/pessoa.py b/oo/pessoa.py index 3ff478a5e..925a08e5f 100644 --- a/oo/pessoa.py +++ b/oo/pessoa.py @@ -13,4 +13,6 @@ def cumprimentar(self): pai = Pessoa(filho01, filho02, nome="José", idade=64) print(pai.cumprimentar()) print(f"{pai.nome} tem {pai.idade} anos e {len(pai.filhos)} filhos.") + for i, filho in enumerate(pai.filhos): + print(f"O {i+1}º chama {filho.nome}.") From 7c340120a752e464056a7756accc42432a451fcf Mon Sep 17 00:00:00 2001 From: GustavoSuto Date: Fri, 15 Nov 2019 19:39:50 -0300 Subject: [PATCH 06/18] created dynamic instance attribute --- oo/pessoa.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/oo/pessoa.py b/oo/pessoa.py index 925a08e5f..e06245fc6 100644 --- a/oo/pessoa.py +++ b/oo/pessoa.py @@ -13,6 +13,11 @@ def cumprimentar(self): pai = Pessoa(filho01, filho02, nome="José", idade=64) print(pai.cumprimentar()) print(f"{pai.nome} tem {pai.idade} anos e {len(pai.filhos)} filhos.") + for i, filho in enumerate(pai.filhos): print(f"O {i+1}º chama {filho.nome}.") + pai.sobrenome = "Souza" + print(pai.nome, pai.__dict__) + print(filho01.nome, filho01.__dict__) + From 6d972195fc660a591d6e4b37548e594df54e3792 Mon Sep 17 00:00:00 2001 From: GustavoSuto Date: Fri, 15 Nov 2019 19:50:00 -0300 Subject: [PATCH 07/18] created class attribute --- oo/pessoa.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/oo/pessoa.py b/oo/pessoa.py index e06245fc6..2d859f88e 100644 --- a/oo/pessoa.py +++ b/oo/pessoa.py @@ -1,9 +1,14 @@ class Pessoa: + # Atributos de classe ou atributo default + olhos = 2 + + # Atributos de instância def __init__(self, *filhos, nome="Gustavo", idade=35): self.idade = idade self.nome = nome self.filhos = list(filhos) + # Método def cumprimentar(self): return f"Olá, {self.nome}!" @@ -17,7 +22,7 @@ def cumprimentar(self): for i, filho in enumerate(pai.filhos): print(f"O {i+1}º chama {filho.nome}.") - pai.sobrenome = "Souza" + pai.sobrenome = "Souza" # Atributo criado dinamicamente print(pai.nome, pai.__dict__) print(filho01.nome, filho01.__dict__) From 6962b2067ec348662d207ad47fb731aedd0001c3 Mon Sep 17 00:00:00 2001 From: GustavoSuto Date: Fri, 15 Nov 2019 20:00:50 -0300 Subject: [PATCH 08/18] created class methods as static methods and class methods --- oo/pessoa.py | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/oo/pessoa.py b/oo/pessoa.py index 2d859f88e..ad571b822 100644 --- a/oo/pessoa.py +++ b/oo/pessoa.py @@ -2,16 +2,29 @@ class Pessoa: # Atributos de classe ou atributo default olhos = 2 + # Atributos de instância def __init__(self, *filhos, nome="Gustavo", idade=35): self.idade = idade self.nome = nome self.filhos = list(filhos) - # Método + + # Método de instância def cumprimentar(self): return f"Olá, {self.nome}!" + + @staticmethod + def metodo_estatico(): + return 42 + + + @classmethod + def nome_e_atributos_de_classe(cls): + return f"{cls} - quantidade de olhos: {cls.olhos}" + + if __name__ == '__main__': filho01 = Pessoa(nome="Gu", idade=34) filho02 = Pessoa(nome="Gui", idade=32) @@ -26,3 +39,5 @@ def cumprimentar(self): print(pai.nome, pai.__dict__) print(filho01.nome, filho01.__dict__) + print(Pessoa.metodo_estatico(), pai.metodo_estatico()) + print(Pessoa.nome_e_atributos_de_classe(), pai.nome_e_atributos_de_classe()) From 8f7865ed188a2d96d8cac29e783ae1c9100f96ac Mon Sep 17 00:00:00 2001 From: GustavoSuto Date: Sat, 16 Nov 2019 00:33:55 -0300 Subject: [PATCH 09/18] created an python modulo for OO studies --- oo/carro.py | 136 +++++++++++++++++++++++++++++++++++++++++++++++++++ oo/pessoa.py | 8 +-- 2 files changed, 138 insertions(+), 6 deletions(-) create mode 100644 oo/carro.py diff --git a/oo/carro.py b/oo/carro.py new file mode 100644 index 000000000..aa512b23a --- /dev/null +++ b/oo/carro.py @@ -0,0 +1,136 @@ +""" + >>> 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 + >>> # Testando Direcao + >>> 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' +""" + +class Carro: + def __init__(self, direcao, motor): + self.motor = motor + self.direcao = direcao + + def calcular_velocidade(self): + return self.motor.velocidade + + def acelerar(self): + return self.motor.acelerar() + + def frear(self): + return self.motor.frear() + + def calcular_direcao(self): + return self.direcao.valor + + def girar_a_direita(self): + return self.direcao.girar_a_direita() + + def girar_a_esquerda(self): + return self.direcao.girar_a_esquerda() + + + +class Motor: + def __init__(self, velocidade=0): + self.velocidade = velocidade + + def acelerar(self): + self.velocidade += 1 + + def frear(self): + if self.velocidade - 2 <= 0: + self.velocidade = 0 + else: + self.velocidade -= 2 + + + +class Direcao(): + + def __init__(self, valor="Norte"): + self.valor = valor + + def girar_a_direita(self): + if self.valor == "Norte": + self.valor = "Leste" + elif self.valor == "Leste": + self.valor = "Sul" + elif self.valor == "Sul": + self.valor = "Oeste" + else: + self.valor = "Norte" + + def girar_a_esquerda(self): + if self.valor == "Norte": + self.valor = "Oeste" + elif self.valor == "Oeste": + self.valor = "Sul" + elif self.valor == "Sul": + self.valor = "Leste" + else: + self.valor = "Norte" diff --git a/oo/pessoa.py b/oo/pessoa.py index ad571b822..73449b249 100644 --- a/oo/pessoa.py +++ b/oo/pessoa.py @@ -2,24 +2,20 @@ class Pessoa: # Atributos de classe ou atributo default olhos = 2 - # Atributos de instância def __init__(self, *filhos, nome="Gustavo", idade=35): self.idade = idade self.nome = nome self.filhos = list(filhos) - # Método de instância def cumprimentar(self): return f"Olá, {self.nome}!" - @staticmethod def metodo_estatico(): return 42 - @classmethod def nome_e_atributos_de_classe(cls): return f"{cls} - quantidade de olhos: {cls.olhos}" @@ -33,9 +29,9 @@ def nome_e_atributos_de_classe(cls): print(f"{pai.nome} tem {pai.idade} anos e {len(pai.filhos)} filhos.") for i, filho in enumerate(pai.filhos): - print(f"O {i+1}º chama {filho.nome}.") + print(f"O {i + 1}º chama {filho.nome}.") - pai.sobrenome = "Souza" # Atributo criado dinamicamente + pai.sobrenome = "Souza" # Atributo criado dinamicamente print(pai.nome, pai.__dict__) print(filho01.nome, filho01.__dict__) From ed3053e7e89fc61c9866541661f5cd2dc9c8257f Mon Sep 17 00:00:00 2001 From: GustavoSuto Date: Sun, 17 Nov 2019 11:08:40 -0300 Subject: [PATCH 10/18] applied concepts of unity tests and OOP --- atores.py | 8 ++++---- fase.py | 6 +++--- oo/carro.py | 8 ++++---- oo/pessoa.py | 24 +++++++++++++++++++++--- oo/teste_carro.py | 14 ++++++++++++++ 5 files changed, 46 insertions(+), 14 deletions(-) create mode 100644 oo/teste_carro.py diff --git a/atores.py b/atores.py index cfc2ef5ea..4e7abdbcb 100644 --- a/atores.py +++ b/atores.py @@ -57,11 +57,11 @@ def colidir(self, outro_ator, intervalo=1): class Obstaculo(Ator): - pass + _caracter_ativo = "O" class Porco(Ator): - pass + _caracter_ativo = "@" class DuploLancamentoExcecao(Exception): @@ -133,8 +133,8 @@ def lancar(self, angulo, tempo_de_lancamento): class PassaroAmarelo(Passaro): - pass + _caracter_ativo = "A" class PassaroVermelho(Passaro): - pass \ No newline at end of file + _caracter_ativo = "V" \ No newline at end of file diff --git a/fase.py b/fase.py index 3385175c6..1c8fd161f 100644 --- a/fase.py +++ b/fase.py @@ -43,7 +43,7 @@ def adicionar_obstaculo(self, *obstaculos): :param obstaculos: """ - pass + self._obstaculos.extend(obstaculos) def adicionar_porco(self, *porcos): """ @@ -51,7 +51,7 @@ def adicionar_porco(self, *porcos): :param porcos: """ - pass + self._porcos.extend(porcos) def adicionar_passaro(self, *passaros): """ @@ -59,7 +59,7 @@ def adicionar_passaro(self, *passaros): :param passaros: """ - pass + self._passaros.extend(passaros) def status(self): """ diff --git a/oo/carro.py b/oo/carro.py index aa512b23a..0293a3061 100644 --- a/oo/carro.py +++ b/oo/carro.py @@ -46,16 +46,16 @@ >>> direcao.valor 'Norte' >>> carro = Carro(direcao, motor) - >>> carro.calcular_velocidade() + >>> carro.calcular_velocidade 0 >>> carro.acelerar() - >>> carro.calcular_velocidade() + >>> carro.calcular_velocidade 1 >>> carro.acelerar() - >>> carro.calcular_velocidade() + >>> carro.calcular_velocidade 2 >>> carro.frear() - >>> carro.calcular_velocidade() + >>> carro.calcular_velocidade 0 >>> carro.calcular_direcao() 'Norte' diff --git a/oo/pessoa.py b/oo/pessoa.py index 73449b249..e503d8c10 100644 --- a/oo/pessoa.py +++ b/oo/pessoa.py @@ -10,7 +10,7 @@ def __init__(self, *filhos, nome="Gustavo", idade=35): # Método de instância def cumprimentar(self): - return f"Olá, {self.nome}!" + return f"Olá, meu nome é {self.nome}!" @staticmethod def metodo_estatico(): @@ -21,9 +21,19 @@ def nome_e_atributos_de_classe(cls): return f"{cls} - quantidade de olhos: {cls.olhos}" +class Homem(Pessoa): + def cumprimentar(self): + cumprimentar_da_classe_pai = super().cumprimentar() + return f"{cumprimentar_da_classe_pai}. Aperto de Mão." + + +class Mutante(Pessoa): + olhos = 3 + + if __name__ == '__main__': - filho01 = Pessoa(nome="Gu", idade=34) - filho02 = Pessoa(nome="Gui", idade=32) + filho01 = Mutante(nome="Gu", idade=34) + filho02 = Homem(nome="Gui", idade=32) pai = Pessoa(filho01, filho02, nome="José", idade=64) print(pai.cumprimentar()) print(f"{pai.nome} tem {pai.idade} anos e {len(pai.filhos)} filhos.") @@ -37,3 +47,11 @@ def nome_e_atributos_de_classe(cls): print(Pessoa.metodo_estatico(), pai.metodo_estatico()) print(Pessoa.nome_e_atributos_de_classe(), pai.nome_e_atributos_de_classe()) + + pessoa = Homem("Anônimo") + print(isinstance(pessoa, Pessoa)) + + print(filho01.olhos) + + print(pai.cumprimentar()) + print(filho02.cumprimentar()) diff --git a/oo/teste_carro.py b/oo/teste_carro.py new file mode 100644 index 000000000..49837c5c8 --- /dev/null +++ b/oo/teste_carro.py @@ -0,0 +1,14 @@ +from unittest import TestCase + +from oo.carro import Motor + + +class CarroTestCase(TestCase): + def teste_velocidade_inicial(self): + motor = Motor() + self.assertEqual(0, motor.velocidade) + + def teste_acelerar(self): + motor = Motor() + motor.acelerar() + self.assertEqual(1, motor.velocidade) From c4c46ff45e8111f451e36b03d3ee67934f79753d Mon Sep 17 00:00:00 2001 From: GustavoSuto Date: Sat, 23 Nov 2019 10:03:08 -0300 Subject: [PATCH 11/18] applied concepts of unity tests and OOP (fases) --- fase.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/fase.py b/fase.py index 1c8fd161f..e2d17101e 100644 --- a/fase.py +++ b/fase.py @@ -73,7 +73,7 @@ def status(self): :return: """ - return EM_ANDAMENTO + return VITORIA def lancar(self, angulo, tempo): """ From e4853a84004ae86cee9b2d18888c5acf13e8364d Mon Sep 17 00:00:00 2001 From: Gustavo Suto Date: Mon, 7 Sep 2020 12:01:52 -0300 Subject: [PATCH 12/18] [chore] Retomando curso. Adicionada a classe Pessoa. --- .gitignore | 1 + oo/pessoa.py | 57 +---------------------------------- oo_old/__init__.py | 0 {oo => oo_old}/carro.py | 0 oo_old/pessoa.py | 57 +++++++++++++++++++++++++++++++++++ {oo => oo_old}/teste_carro.py | 0 6 files changed, 59 insertions(+), 56 deletions(-) create mode 100644 oo_old/__init__.py rename {oo => oo_old}/carro.py (100%) create mode 100644 oo_old/pessoa.py rename {oo => oo_old}/teste_carro.py (100%) diff --git a/.gitignore b/.gitignore index 6220a9500..999174f74 100644 --- a/.gitignore +++ b/.gitignore @@ -18,6 +18,7 @@ lib64/ parts/ sdist/ var/ +.vscode *.egg-info/ .installed.cfg *.egg diff --git a/oo/pessoa.py b/oo/pessoa.py index e503d8c10..e1da50e22 100644 --- a/oo/pessoa.py +++ b/oo/pessoa.py @@ -1,57 +1,2 @@ class Pessoa: - # Atributos de classe ou atributo default - olhos = 2 - - # Atributos de instância - def __init__(self, *filhos, nome="Gustavo", idade=35): - self.idade = idade - self.nome = nome - self.filhos = list(filhos) - - # Método de instância - def cumprimentar(self): - return f"Olá, meu nome é {self.nome}!" - - @staticmethod - def metodo_estatico(): - return 42 - - @classmethod - def nome_e_atributos_de_classe(cls): - return f"{cls} - quantidade de olhos: {cls.olhos}" - - -class Homem(Pessoa): - def cumprimentar(self): - cumprimentar_da_classe_pai = super().cumprimentar() - return f"{cumprimentar_da_classe_pai}. Aperto de Mão." - - -class Mutante(Pessoa): - olhos = 3 - - -if __name__ == '__main__': - filho01 = Mutante(nome="Gu", idade=34) - filho02 = Homem(nome="Gui", idade=32) - pai = Pessoa(filho01, filho02, nome="José", idade=64) - print(pai.cumprimentar()) - print(f"{pai.nome} tem {pai.idade} anos e {len(pai.filhos)} filhos.") - - for i, filho in enumerate(pai.filhos): - print(f"O {i + 1}º chama {filho.nome}.") - - pai.sobrenome = "Souza" # Atributo criado dinamicamente - print(pai.nome, pai.__dict__) - print(filho01.nome, filho01.__dict__) - - print(Pessoa.metodo_estatico(), pai.metodo_estatico()) - print(Pessoa.nome_e_atributos_de_classe(), pai.nome_e_atributos_de_classe()) - - pessoa = Homem("Anônimo") - print(isinstance(pessoa, Pessoa)) - - print(filho01.olhos) - - print(pai.cumprimentar()) - print(filho02.cumprimentar()) + pass \ No newline at end of file diff --git a/oo_old/__init__.py b/oo_old/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/oo/carro.py b/oo_old/carro.py similarity index 100% rename from oo/carro.py rename to oo_old/carro.py diff --git a/oo_old/pessoa.py b/oo_old/pessoa.py new file mode 100644 index 000000000..e503d8c10 --- /dev/null +++ b/oo_old/pessoa.py @@ -0,0 +1,57 @@ +class Pessoa: + # Atributos de classe ou atributo default + olhos = 2 + + # Atributos de instância + def __init__(self, *filhos, nome="Gustavo", idade=35): + self.idade = idade + self.nome = nome + self.filhos = list(filhos) + + # Método de instância + def cumprimentar(self): + return f"Olá, meu nome é {self.nome}!" + + @staticmethod + def metodo_estatico(): + return 42 + + @classmethod + def nome_e_atributos_de_classe(cls): + return f"{cls} - quantidade de olhos: {cls.olhos}" + + +class Homem(Pessoa): + def cumprimentar(self): + cumprimentar_da_classe_pai = super().cumprimentar() + return f"{cumprimentar_da_classe_pai}. Aperto de Mão." + + +class Mutante(Pessoa): + olhos = 3 + + +if __name__ == '__main__': + filho01 = Mutante(nome="Gu", idade=34) + filho02 = Homem(nome="Gui", idade=32) + pai = Pessoa(filho01, filho02, nome="José", idade=64) + print(pai.cumprimentar()) + print(f"{pai.nome} tem {pai.idade} anos e {len(pai.filhos)} filhos.") + + for i, filho in enumerate(pai.filhos): + print(f"O {i + 1}º chama {filho.nome}.") + + pai.sobrenome = "Souza" # Atributo criado dinamicamente + print(pai.nome, pai.__dict__) + print(filho01.nome, filho01.__dict__) + + print(Pessoa.metodo_estatico(), pai.metodo_estatico()) + print(Pessoa.nome_e_atributos_de_classe(), pai.nome_e_atributos_de_classe()) + + pessoa = Homem("Anônimo") + print(isinstance(pessoa, Pessoa)) + + print(filho01.olhos) + + print(pai.cumprimentar()) + print(filho02.cumprimentar()) diff --git a/oo/teste_carro.py b/oo_old/teste_carro.py similarity index 100% rename from oo/teste_carro.py rename to oo_old/teste_carro.py From 2a65ca4f084976d6bee4935ebfb7f8caf3b19ceb Mon Sep 17 00:00:00 2001 From: Gustavo Suto Date: Mon, 7 Sep 2020 12:13:04 -0300 Subject: [PATCH 13/18] =?UTF-8?q?[feat]=20Criado=20m=C3=A9todo=20cumprimen?= =?UTF-8?q?tar=20(classe=20Pessoa).?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- oo/pessoa.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/oo/pessoa.py b/oo/pessoa.py index e1da50e22..313c9fc7e 100644 --- a/oo/pessoa.py +++ b/oo/pessoa.py @@ -1,2 +1,8 @@ class Pessoa: - pass \ No newline at end of file + def cumprimentar(self): + return f"Olá {id(self)}" + +if __name__ == "__main__": + p = Pessoa() + print(id(p)) + print(p.cumprimentar()) \ No newline at end of file From f6d93f505343aea48e9adc0c5314f3ec5e06342a Mon Sep 17 00:00:00 2001 From: Gustavo Suto Date: Mon, 7 Sep 2020 12:35:31 -0300 Subject: [PATCH 14/18] [feat] Criado atributo nome da classe Pessoa. --- oo/pessoa.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/oo/pessoa.py b/oo/pessoa.py index 313c9fc7e..b1b530fab 100644 --- a/oo/pessoa.py +++ b/oo/pessoa.py @@ -1,8 +1,14 @@ class Pessoa: + def __init__(self, nome=None): + self.nome = nome + def cumprimentar(self): return f"Olá {id(self)}" if __name__ == "__main__": - p = Pessoa() + p = Pessoa("Gustavo") + print(p.nome) print(id(p)) - print(p.cumprimentar()) \ No newline at end of file + print(p.cumprimentar()) + p.nome = "Suto" + print(p.nome) \ No newline at end of file From 97b6157d49fd0419f9dba59a223672f8f66c852b Mon Sep 17 00:00:00 2001 From: Gustavo Suto Date: Mon, 7 Sep 2020 14:56:07 -0300 Subject: [PATCH 15/18] [feat] Criado atributo complexo. --- oo/pessoa.py | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/oo/pessoa.py b/oo/pessoa.py index b1b530fab..0e135258b 100644 --- a/oo/pessoa.py +++ b/oo/pessoa.py @@ -1,14 +1,17 @@ class Pessoa: - def __init__(self, nome=None): + def __init__(self, *filhos,nome=None, idade=35): self.nome = nome + self.idade = idade + self.filhos = list(filhos) def cumprimentar(self): return f"Olá {id(self)}" if __name__ == "__main__": - p = Pessoa("Gustavo") - print(p.nome) - print(id(p)) - print(p.cumprimentar()) - p.nome = "Suto" - print(p.nome) \ No newline at end of file + gustavo = Pessoa(nome="Gustavo") + jose = Pessoa(gustavo, nome="José") + print(jose.nome) + print(id(jose)) + print(jose.cumprimentar()) + for filho in jose.filhos: + print(f"Um dos filhos de {jose.nome} chama {filho.nome}.") From ea88ad96dbd96bc9090c2bc5052fcf2bc3550d4a Mon Sep 17 00:00:00 2001 From: Gustavo Suto Date: Mon, 7 Sep 2020 15:05:08 -0300 Subject: [PATCH 16/18] =?UTF-8?q?[feat]=20Criado=20atributo=20din=C3=A2mic?= =?UTF-8?q?o=20Pessoa.sobrenome.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- oo/pessoa.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/oo/pessoa.py b/oo/pessoa.py index 0e135258b..f1d8fdbce 100644 --- a/oo/pessoa.py +++ b/oo/pessoa.py @@ -9,9 +9,13 @@ def cumprimentar(self): if __name__ == "__main__": gustavo = Pessoa(nome="Gustavo") - jose = Pessoa(gustavo, nome="José") + jose = Pessoa(gustavo, nome="José", idade=66) print(jose.nome) print(id(jose)) print(jose.cumprimentar()) for filho in jose.filhos: print(f"Um dos filhos de {jose.nome} chama {filho.nome}.") + + gustavo.sobrenome = "Suto" # Criando um atributo dinâmico + print(gustavo.__dict__) # Acessando todos os atributos de um objeto, mesmo os atributos dinâmicos. + print(jose.__dict__) From 19e65d599799ae50cfb2f6aacbf269fe75715e72 Mon Sep 17 00:00:00 2001 From: Gustavo Suto Date: Thu, 10 Sep 2020 00:00:46 -0300 Subject: [PATCH 17/18] [feat] Added features according to the 78% of the course. --- fase.py | 25 ++- oo/carro.py | 197 ++++++++++++++++++ oo/direcao.py | 57 +++++ oo/motor.py | 41 ++++ oo/pessoa.py | 47 ++++- oo/teste_carro.py | 78 +++++++ oo_old/carro.py | 11 + testes/{atores_testes.py => testes_atores.py} | 0 testes/{fase_testes.py => testes_fase.py} | 0 .../{integracao.py => testes_integracao.py} | 0 10 files changed, 450 insertions(+), 6 deletions(-) create mode 100644 oo/carro.py create mode 100644 oo/direcao.py create mode 100644 oo/motor.py create mode 100644 oo/teste_carro.py rename testes/{atores_testes.py => testes_atores.py} (100%) rename testes/{fase_testes.py => testes_fase.py} (100%) rename testes/{integracao.py => testes_integracao.py} (100%) diff --git a/fase.py b/fase.py index e2d17101e..8b7ef0d2e 100644 --- a/fase.py +++ b/fase.py @@ -73,7 +73,12 @@ def status(self): :return: """ - return VITORIA + if not self._possui_porco_ativo(): + return VITORIA + elif self._possui_passaro_ativo(): + return EM_ANDAMENTO + else: + return DERROTA def lancar(self, angulo, tempo): """ @@ -86,7 +91,10 @@ def lancar(self, angulo, tempo): :param angulo: ângulo de lançamento :param tempo: Tempo de lançamento """ - pass + for passaro in self._passaros: + if not passaro.foi_lancado(): + passaro.lancar(angulo, tempo) + break def calcular_pontos(self, tempo): @@ -105,3 +113,16 @@ def calcular_pontos(self, tempo): def _transformar_em_ponto(self, ator): return Ponto(ator.x, ator.y, ator.caracter()) + def _possui_porco_ativo(self): + for porco in self._porcos: + if porco.status==ATIVO: + return True + return False + + def _possui_passaro_ativo(self): + for passaro in self._passaros: + if passaro.status==ATIVO: + return True + return False + + diff --git a/oo/carro.py b/oo/carro.py new file mode 100644 index 000000000..b53963c80 --- /dev/null +++ b/oo/carro.py @@ -0,0 +1,197 @@ +""" +Você deve criar uma classe carro que vai possuir +butos compostos por outras duas classes: + +Motor +Direção +O Motor terá a responsabilidade de controlar a velocidade. +Ele oferece os seguintes atributos: + +Atributo de dado velocidade +Método acelerar, que deverá incremetar a velocidade de uma unidade +Método frear que deverá decrementar a velocidade em duas unidades +A Direção terá a responsabilidade de controlar a direção. Ela oferece +os seguintes atributos: + +Valor de diração com valores possíveis: Norte, Sul, Leste, Oeste. +Método girar_a_direita +Método girar_a_esquerda + + N + O L + S + +IMPORTANTE: +Para rodar o doctest, no terminal: +python -m doctest .py # rodar todos os testes de uma só vez. +python -m doctest -f .py # rodar testes e para na primeira falha. + +>>> # 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 +>>> # Testando Direcao +>>> 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' + +""" + +class Direcao: + + def __init__(self, valor="Norte"): + self.valor = valor + + def girar_a_direita(self): + if self.valor == "Norte": + self.valor = "Leste" + elif self.valor == "Leste": + self.valor = "Sul" + elif self.valor == "Sul": + self.valor = "Oeste" + else: + self.valor = "Norte" + + def girar_a_esquerda(self): + if self.valor == "Norte": + self.valor = "Oeste" + elif self.valor == "Oeste": + self.valor = "Sul" + elif self.valor == "Sul": + self.valor = "Leste" + else: + self.valor = "Norte" + + +class Motor: + + def __init__(self, velocidade=0): + self.velocidade = velocidade + + def acelerar(self): + self.velocidade += 1 + + def frear(self): + if self.velocidade-2 < 0: + self.velocidade = 0 + else: + self.velocidade -= 2 + + +class Carro: + ## Se eu tivesse deixado as classes Motor e Direcao em arquivos separados do + ## carro.py, as chamadas de impoortação deveriam ser colocadas. + # from direcao import Direcao + # from motor import Motor + + def __init__(self, direcao=Direcao(), motor=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() + + +# if __name__ == "__main__": +# from direcao import Direcao +# from motor import Motor +# carro = Carro(Direcao("Sul"), Motor(10)) +# print(carro.calcular_velocidade()) +# print(0) +# carro.acelerar() +# print(carro.calcular_velocidade()) +# print(1) +# carro.acelerar() +# print(carro.calcular_velocidade()) +# print(2) +# carro.frear() +# print(carro.calcular_velocidade()) +# print(0) +# print(carro.calcular_direcao()) +# print('Norte') +# carro.girar_a_direita() +# print(carro.calcular_direcao()) +# print('Leste') +# carro.girar_a_esquerda() +# print(carro.calcular_direcao()) +# print('Norte') +# carro.girar_a_esquerda() +# print(carro.calcular_direcao()) +# print('Oeste') diff --git a/oo/direcao.py b/oo/direcao.py new file mode 100644 index 000000000..d7bc5be65 --- /dev/null +++ b/oo/direcao.py @@ -0,0 +1,57 @@ +class Direcao: + + def __init__(self, valor="Norte"): + self.valor = valor + + def girar_a_direita(self): + if self.valor == "Norte": + self.valor = "Leste" + elif self.valor == "Leste": + self.valor = "Sul" + elif self.valor == "Sul": + self.valor = "Oeste" + else: + self.valor = "Norte" + + + def girar_a_esquerda(self): + if self.valor == "Norte": + self.valor = "Oeste" + elif self.valor == "Oeste": + self.valor = "Sul" + elif self.valor == "Sul": + self.valor = "Leste" + else: + self.valor = "Norte" + + +if __name__ == "__main__": + # Testando Direcao + direcao = Direcao() + print(direcao.valor) + print('Norte') + direcao.girar_a_direita() + print(direcao.valor) + print('Leste') + direcao.girar_a_direita() + print(direcao.valor) + print('Sul') + direcao.girar_a_direita() + print(direcao.valor) + print('Oeste') + direcao.girar_a_direita() + print(direcao.valor) + print('Norte') + direcao.girar_a_esquerda() + print(direcao.valor) + print('Oeste') + direcao.girar_a_esquerda() + print(direcao.valor) + print('Sul') + direcao.girar_a_esquerda() + print(direcao.valor) + print('Leste') + direcao.girar_a_esquerda() + print(direcao.valor) + print('Norte') + diff --git a/oo/motor.py b/oo/motor.py new file mode 100644 index 000000000..2d0ba05cc --- /dev/null +++ b/oo/motor.py @@ -0,0 +1,41 @@ +class Motor: + + def __init__(self, velocidade=0): + self.velocidade = velocidade + + def acelerar(self): + self.velocidade += 1 + + def frear(self): + if self.velocidade-2 < 0: + self.velocidade = 0 + else: + self.velocidade -= 2 + + + +if __name__ == "__main__": + motor = Motor() + motor.velocidade + print(motor.velocidade) + print(0) + motor.acelerar() + motor.velocidade + print(motor.velocidade) + print(1) + motor.acelerar() + motor.velocidade + print(motor.velocidade) + print(2) + motor.acelerar() + motor.velocidade + print(motor.velocidade) + print(3) + motor.frear() + motor.velocidade + print(motor.velocidade) + print(1) + motor.frear() + motor.velocidade + print(motor.velocidade) + print(0) diff --git a/oo/pessoa.py b/oo/pessoa.py index f1d8fdbce..16a3db7eb 100644 --- a/oo/pessoa.py +++ b/oo/pessoa.py @@ -1,21 +1,60 @@ class Pessoa: - def __init__(self, *filhos,nome=None, idade=35): + # Atributo de classe. Deve ser usado quando todas as instâncias tiverem o mesmo valor. + olhos = 2 + ser = "Pessoa" + + # Atributos de dado ou apenas atributos + def __init__(self, *filhos, nome=None, idade=35): self.nome = nome self.idade = idade self.filhos = list(filhos) + # Método def cumprimentar(self): return f"Olá {id(self)}" + # Método de classe: Método que independe do objeto que está sendo executado + # Pode-se fazer isso usando decorators + @staticmethod + def metodo_estatico(): + return "método estático" + + # Método de classe com decorator @classmethod. + # Com esse é possível acessar a classe que está executando esse método. + # No caso, o parâmetro cls representa a palavra class; porém, como class é uma palavra reservada, usamos o cls. + @classmethod + def nome_e_atributos_de_classe(cls): + return f"{cls} - olhos {cls.olhos}" + +class Homem(Pessoa): + pass + +class Mutante(Pessoa): + olhos = 3 + if __name__ == "__main__": - gustavo = Pessoa(nome="Gustavo") + gustavo = Mutante(nome="Gustavo") jose = Pessoa(gustavo, nome="José", idade=66) print(jose.nome) print(id(jose)) print(jose.cumprimentar()) for filho in jose.filhos: print(f"Um dos filhos de {jose.nome} chama {filho.nome}.") + gustavo.olhos = 1 - gustavo.sobrenome = "Suto" # Criando um atributo dinâmico - print(gustavo.__dict__) # Acessando todos os atributos de um objeto, mesmo os atributos dinâmicos. + # Criando um atributo dinâmico + gustavo.sobrenome = "Suto" + + # Acessando todos os atributos de um objeto, mesmo os atributos dinâmicos. + print(gustavo.__dict__) print(jose.__dict__) + + print(f"{gustavo.nome} tem {gustavo.olhos} olhos.") + print(f"Pessoa tem {Pessoa.olhos} olhos.") + + # Usando o método de classe sob o decorator @staticmethod: + print(f"{Pessoa.ser}: {Pessoa.metodo_estatico()}, {gustavo.nome}: {gustavo.metodo_estatico()}") + + # Usando o método de classe sob o decorator @classmethod: + print(f"""{Pessoa.ser}: {Pessoa.nome_e_atributos_de_classe()} +{gustavo.nome}: {gustavo.nome_e_atributos_de_classe()}""") \ No newline at end of file diff --git a/oo/teste_carro.py b/oo/teste_carro.py new file mode 100644 index 000000000..456ebcaba --- /dev/null +++ b/oo/teste_carro.py @@ -0,0 +1,78 @@ +from unittest import TestCase + +from oo.carro import Motor +from oo.carro import Direcao +from oo.carro import Carro + +class CarroTestCase(TestCase): + def teste_velocidade(self): + motor = Motor() + self.assertEqual(0, motor.velocidade) + + def teste_aceleracao(self): + motor = Motor() + motor.acelerar() + self.assertEqual(1, motor.velocidade) + motor.acelerar() + self.assertEqual(2, motor.velocidade) + motor.acelerar() + self.assertEqual(3, motor.velocidade) + + def teste_frenagem(self): + motor = Motor(3) + motor.frear() + self.assertEqual(1, motor.velocidade) + motor.frear() + self.assertEqual(0, motor.velocidade) + + def teste_direcao(self): + direcao = Direcao() + self.assertEqual("Norte", direcao.valor) + + def teste_girar_a_direita(self): + direcao = Direcao() + direcao.girar_a_direita() + self.assertEqual("Leste", direcao.valor) + direcao.girar_a_direita() + self.assertEqual("Sul", direcao.valor) + direcao.girar_a_direita() + self.assertEqual("Oeste", direcao.valor) + + def teste_girar_a_esquerda(self): + direcao = Direcao() + direcao.girar_a_esquerda() + self.assertEqual("Oeste", direcao.valor) + direcao.girar_a_esquerda() + self.assertEqual("Sul", direcao.valor) + direcao.girar_a_esquerda() + self.assertEqual("Leste", direcao.valor) + + def teste_carro(self): + carro = Carro() + self.assertEqual(0, carro.calcular_velocidade()) + + + +# >>> 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' \ No newline at end of file diff --git a/oo_old/carro.py b/oo_old/carro.py index 0293a3061..cca647eea 100644 --- a/oo_old/carro.py +++ b/oo_old/carro.py @@ -134,3 +134,14 @@ def girar_a_esquerda(self): self.valor = "Leste" else: self.valor = "Norte" + +if __name__ == "__main__": + carro = Carro(direcao, motor) + print(carro.calcular_velocidade()) + print(0) + carro.acelerar() + print(carro.calcular_velocidade()) + print(1) + carro.acelerar() + print(carro.calcular_velocidade()) + print(2) \ No newline at end of file diff --git a/testes/atores_testes.py b/testes/testes_atores.py similarity index 100% rename from testes/atores_testes.py rename to testes/testes_atores.py diff --git a/testes/fase_testes.py b/testes/testes_fase.py similarity index 100% rename from testes/fase_testes.py rename to testes/testes_fase.py diff --git a/testes/integracao.py b/testes/testes_integracao.py similarity index 100% rename from testes/integracao.py rename to testes/testes_integracao.py From dabb16b4f0dc848ee92f04d6feb5ab65245f169a Mon Sep 17 00:00:00 2001 From: Gustavo Suto Date: Sun, 20 Sep 2020 15:29:11 -0300 Subject: [PATCH 18/18] [feat] Python birds finalizado. --- atores.py | 47 +++++++++++++++++++++++++++++++++++------ fase.py | 6 ++++++ testes/testes_atores.py | 2 +- 3 files changed, 47 insertions(+), 8 deletions(-) diff --git a/atores.py b/atores.py index 4e7abdbcb..5866f61ab 100644 --- a/atores.py +++ b/atores.py @@ -38,7 +38,7 @@ def calcular_posicao(self, tempo): :param tempo: o tempo do jogo :return: posição x, y do ator """ - return 1, 1 + return self.x, self.y def colidir(self, outro_ator, intervalo=1): """ @@ -52,16 +52,22 @@ def colidir(self, outro_ator, intervalo=1): :param intervalo: Intervalo a ser considerado :return: """ - pass + if self.status == ATIVO and outro_ator.status == ATIVO: + delta_x=abs(self.x - outro_ator.x) + delta_y=abs(self.y - outro_ator.y) + if delta_x <= intervalo and delta_y <= intervalo: + self.status = outro_ator.status = DESTRUIDO class Obstaculo(Ator): _caracter_ativo = "O" + _caracter_destruido = " " class Porco(Ator): _caracter_ativo = "@" + _caracter_destruido = "+" class DuploLancamentoExcecao(Exception): @@ -93,7 +99,7 @@ def foi_lancado(self): :return: booleano """ - return True + return not self._tempo_de_lancamento is None def colidir_com_chao(self): """ @@ -101,7 +107,9 @@ def colidir_com_chao(self): o status dos Passaro deve ser alterado para destruido, bem como o seu caracter """ - pass + if self.y <= 0: + self.status = DESTRUIDO + def calcular_posicao(self, tempo): """ @@ -117,7 +125,11 @@ def calcular_posicao(self, tempo): :param tempo: tempo de jogo a ser calculada a posição :return: posição x, y """ - return 1, 1 + if self.foi_lancado() and self.status == ATIVO: + delta_t = tempo - self._tempo_de_lancamento + self._calcular_posicao_vertical(delta_t) + self._calcular_posicao_horizontal(delta_t) + return super().calcular_posicao(tempo) def lancar(self, angulo, tempo_de_lancamento): @@ -129,12 +141,33 @@ def lancar(self, angulo, tempo_de_lancamento): :param tempo_de_lancamento: :return: """ - pass + self._angulo_de_lancamento = math.radians(angulo) + self._tempo_de_lancamento = tempo_de_lancamento + + + def _calcular_posicao_vertical(self, delta_t): + y_atual = self._y_inicial + angulo_radianos = self._angulo_de_lancamento + y_atual += self.velocidade_escalar*delta_t*math.sin(angulo_radianos) + y_atual -= (GRAVIDADE*(delta_t**2))/2 + self.y = y_atual + + + def _calcular_posicao_horizontal(self, delta_t): + x_atual = self._x_inicial + angulo_radianos = self._angulo_de_lancamento + x_atual += self.velocidade_escalar*delta_t*math.cos(angulo_radianos) + self.x = x_atual + class PassaroAmarelo(Passaro): _caracter_ativo = "A" + _caracter_destruido = "a" + velocidade_escalar = 30 class PassaroVermelho(Passaro): - _caracter_ativo = "V" \ No newline at end of file + _caracter_ativo = "V" + _caracter_destruido = "v" + velocidade_escalar = 20 diff --git a/fase.py b/fase.py index 8b7ef0d2e..564676866 100644 --- a/fase.py +++ b/fase.py @@ -106,6 +106,12 @@ def calcular_pontos(self, tempo): :param tempo: tempo para o qual devem ser calculados os pontos :return: objeto do tipo Ponto """ + for passaro in self._passaros: + passaro.calcular_posicao(tempo) + for alvo in self._obstaculos+self._porcos: + passaro.colidir(alvo, self.intervalo_de_colisao) + passaro.colidir_com_chao() + pontos=[self._transformar_em_ponto(a) for a in self._passaros+self._obstaculos+self._porcos] return pontos diff --git a/testes/testes_atores.py b/testes/testes_atores.py index f4254f29e..e833eb43a 100644 --- a/testes/testes_atores.py +++ b/testes/testes_atores.py @@ -113,7 +113,7 @@ def test_caracter(self): def assert_colisao_atores_ativos(self, ator, ator2, intervalo=1): """ Se certifica que há colisão entre atores ativos - Atenção: Esse não é método de teste porque nao se inicia com prefixo "text". + Atenção: Esse não é método de teste porque nao se inicia com prefixo "test". Ele serve apenas para encapsular toda lógica de teste de colisão entre dois atores ativos """ # Conferindo status dos dois atores antes da colisão