(Python) How to prevent methods from being accessed from the value of some attribute

Question

It may not have been very clear about the title, but I wanted it only to be possible to use a method on an object if one or more of its attributes are in a certain way. For example: A TV class that has several methods, to increase, decrease, change channel, turn on, turn off. As the code below shows (in this case I removed all methods and attributes that do not help in understanding doubt):

I removed everything from the code that helped in the understanding of doubt

'''python
class Tv:
  def __self__(self, ligado=False, volume=0):#apenas define os atributos
    self.ligado = ligado
    self.volume = volume

  def altera_volume(self, novo_volume):#ele so faz mudar o valor do atributo "volume"
    self.volume = novo_volume

  def botao_on(self):#ou seja, esta meio que precionando aquele botaozinho de ligar a tv
    if self.ligado == False:#ou seja se a tv estiver desligada, ele vai ligar ela. ou seja "ligado" sera verdadeiro
      self.ligado == True
    else:#ou seja, se a tv estiver ligada o atributo ligado será falso
      self.ligado == False

#Nada do que esta escrito dentro dos metodos "altera_volume" e "botao_on" importa, a unica coisa que importa é que "altera_volume" só
#pode ser usado se o atributo "ligado" for verdadeiro, ou seja olha o que aconteceria abaixo

televisao = Tv()#ou seja televisao é uma Tv desligada com volume 0
televisao.alterar_volume(100)#Aqui esta o problema, como é possivel alterar o volume com a tv desligada?

#Tem alguma forma de proibir o uso do metodo "alterar_volume" até que o atributo "ligado" tenha o valor que eu quero?
'''

Answer 1

Good afternoon. Crazy Dog, unfortunately I think there is no way to do a single magical thing that will prevent you from replicating the "condition" in those 50 or 100 methods. Use Property and do if in the methods you think you need.

class Tv(object):

    def __init__(self, ligado = False, volume = 0):
        self._ligado = ligado
        self._volume = volume

    def altera_volume(self, novo_volume):
        if self.ligado:
            self._volume = novo_volume

    @property
    def ligado(self):
        return self._ligado

    @ligado.setter
    def ligado(self, novo_estado):
        self._ligado = novo_estado

this is the famous python "get and set". If you use Property, you can change the volume without the "altera_volume" method, but instead simply use a self.volume = volume_desired. Check out the property.

Abç.

Answer 2

I don’t quite understand, but I think you want to prevent direct access to class attributes. If this is the case you will have to name the attributes with dunderscore or underline twice before the variable name, example:self.volume = volume para self.__volume = volume. I hope I’ve helped.

Answer 3

This is a good case where we use exceptions. Exceptions are when something unforeseen happens, they come from logic errors or access to unavailable resources.

Whenever an exception occurs, the program’s execution stack is stopped until some processing is done, otherwise the program itself is stopped by casting the exception on the console.

You can read more about exceptions in python here.

By analyzing your TV class, we could make an exception if any action is taken and the TV is off. This exception would be similar to the following code:

class TvDesligadaException(Exception):
  def __init__(self, message):
     self.message = message

  def __str__(self):
   return repr(self.message)

Soon, in the tv class, if the method to increase volume is called with the tv off, you can launch the exception warning that such an operation is not possible.

class Tv:
  def __init__(self, ligado=False, volume=0):
    self.ligado = ligado
    self.volume = volume

  def altera_volume(self, novo_volume):
    if(self.ligado == False):
      raise TvDesligadaException('Não é possível aumentar o volume com a tv desligada!')

    self.volume = novo_volume

  def botao_on(self):
    if(self.ligado == False):
      self.ligado = True
    else:
      self.ligado == False

So when we try to turn up the volume without turning on the TV first:

televisao = Tv()
televisao.altera_volume(100)

Our exception is cast on the console:

Traceback (most recent call last):
  File "main.py", line 26, in <module>
    televisao.altera_volume(100)
  File "main.py", line 15, in altera_volume
    raise TvDesligadaException('Não é possível aumentar o volume com a tv desligada!')
__main__.TvDesligadaException: 'Não é possível aumentar o volume com a tv desligada!'

If the TV is turned on before, the runstack normally follows:

televisao = Tv()
televisao.botao_on()
televisao.altera_volume(100)

To avoid interrupting code execution, you can perform a treatment of the possible exception to be launched.

televisao = Tv()

try:
  televisao.altera_volume(100)
except TvDesligadaException:
  print('A TV estava desligada')
  print('Ligando a TV')
  televisao.botao_on()

  print('Aumentando o volume')
  televisao.altera_volume(100)

Note that now, if your TV is turned off when you turn up the volume, you can capture the exception and finally turn on the TV before you turn up the volume.