Python Como impedir que métodos sejam acessados a partir de algum valor de atributo

[Cachorro_louco]

Talvez não tenha ficado muito claro o titulo, mas eu queria que só fosse possível usar um método em um objeto, caso um ou mais de seus atributos estejam de uma certa forma. Por exemplo: Uma classe Tv que tem diversos métodos, para aumentar, diminuir, mudar canal, ligar, desligar. Como mostra o codigo abaixo:

class Tv():
    def __init__(self, canal, volume=0):
        self.canal = canal
        self.volume = volume
    def ver_canal(self):
        return self.canal
    def ver_volume(self):
        return self.volume
    def mudar_canal(self, new_canal):
        if new_canal in '2 4 5 7 9 11 15 18 30 33 36 41 47 51 54 100' and new_canal != ' ':
            self.canal = new_canal
    def aumentar_volume(self, quantidade):
        if self.volume + quantidade > 100:
            print('É impossível aumentar nessa quantidade, o limite de som é 100')
        else:
            self.volume += quantidade
    def diminuir_volume(self, quantidade):
        if self.volume - quantidade < 0:
            print('É impossível diminuir nessa quantidade, o limite minimo de som é 0')
    def volume_mudo(self):
        self.volume = 0

Neste codigo ainda não tem a os metodos ligar e desligar, porém mesmo se eles existissem seria possível fazer muitas coisas com a tv estivesse desligada por exemplo. Seria possível aumentar o volume com a tv desligada, diminuir o volume, mudar o canal... eu queria saber se tem como impossibilitar todos os metodos até que a tv esteja ligada (como eu disse nesse codigo ainda não tem nada que faça isso) se precisaram que eu explique melhor, explicarei.  agradeço desde já

 

Edit: Creio que o pessoal não entendeu minha duvida, então vou mostra basicamente o que esta acontecendo e que não deveria acontecer

#Removi tudo do codigo que não ajudava em nada no entendimento da duvida
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?

 

[Visitante]

O que você quer é que nas propriedades da instância televisao, não apareça a opção alterar_volume , até que o método botao_on esteja ligado ligado?

 

voce tem ai duas opções ou faz encapsulamento @property e em seguida um @setter, onde voce vai passar o valor que quer para ligar isso e faz essa verificação de está True ou False.

 

Ou cria uma segunda classe que herda do objeto Tv(), onde o atributo volume deve ser tornar privado usando um undescore _volume, então pelo acesso a superclasse Tv(), voce pode alterar esse valor.

 

mas o correto mesmo o dito mais Pythônico seria fazer isso aqui que expliquei primeiro:

 

class P(object):

    def __init__(self, x):
        self._x = x # Atributo implementado é público que deve ser tornar privado

    @property
    def elemento(self):
        return self._x

    @elemento.setter
    def algo(self, x):
        if x > 0:
            self._x = x

p = P(10)
print(f'Maior que zero= {p.algo}')

p.algo = -1
print(f'Menor que zero= {p.algo}')

p.algo = 1
print(f'Maior que zero= {p.algo}')

# Esta é considerada a forma PYTHÔNICA de se fazer o encapsulamento, usando @property e @setter

Veja que a minha condicional verifica se o numero é maior que ZERO, se for imprime o valor, caso contrário, repete o valor atual, ou seja, não aceita o parâmetro passado, seria o equivalente do DESLIGADO para sua TV

 

Dê uma lida em encapsulamento que você vai ter vários exemplos.

[Visitante]

Poderia fazer assim também que dá certo, mas não sei se é o que você precisa

class TV(object):

    def __init__(self, som=0, canal=2, ligado=False):

        self._som = som
        self._canal = canal
        self._ligado = ligado

    def estado_da_tv(self):

        if self._ligado == False:
            return 'Desligada'
        else:
            return 'Ligada'

    def canal_sintonizado(self):
        canais = {2:'TV Cultura',4:'Rede Globo',6:'Rede TV',7:'Band',9:'CNT',11:'SBT',13:'Record'}

        if self._ligado == False:
            return ''
        else:
            if self._canal in canais:
                return str(self._canal)+' - '+(canais[self._canal])
            else:
                return '2 - TV Cultura' # Se não tiver o canal na lista o padrão será o canal 2

    def volume(self):
        if self._som <= 0:
            return 'Mudo'
        elif self._som >= 100:
            return 'máximo de 100'
        else:
            return self._som

    def __str__(self):
        if self._ligado == True:
            return f'A TV está {self.estado_da_tv()} e sintonizada no canal:' \
               f' {self.canal_sintonizado()}, com volume em: {self.volume()}'
        else:
            return 'A TV está Desligada!'


"""
Crie uma instância ou mais e chame a classe passando os parâmetros
TV(som, canal, ligado)

Ex:
"""
tv1 = TV(32, 13, True) # Volume 32, canal 13, Ligada
print(tv1.__str__())

tv2 = TV(50, 4, False) # Volume 50, canal 4, Desligada
print(tv2.__str__())

O resultado na tela seria esse aqui:

Cada uma das 2 instâncias retornou um estado da TV, e mesmo que eu passe valores como: volume e canal, eles efetivamente só funcionam se a TV estiver ligada(True).