Resumo : neste tutorial, você aprenderá como usar o método de substituição do Python para permitir que uma classe filha forneça uma implementação específica de um método fornecido por uma de suas classes pai.
Introdução ao método de substituição do Python
O método de substituição permite que uma classe filha forneça uma implementação específica de um método que já é fornecido por uma de suas classes pai.
Vamos dar um exemplo para entender melhor o método de substituição.
Primeiro, defina a Employee
classe:
class Employee:
def __init__(self, name, base_pay):
self.name = name
self.base_pay = base_pay
def get_pay(self):
return self.base_pay
Linguagem de código: Python ( python )
A Employee
classe tem duas variáveis de instância name
e base_pay
. Também possui o get_pay()
método que retorna o base_pay
.
Segundo, defina o SalesEmployee
que herda da Employee
classe:
class SalesEmployee(Employee):
def __init__(self, name, base_pay, sales_incentive):
self.name = name
self.base_pay = base_pay
self.sales_incentive = sales_incentive
Linguagem de código: Python ( python )
A SalesEmployee
classe possui três atributos de instância: name
, base_pay
e sales_incentive
.
Terceiro, crie uma nova instância da SalesEmployee
classe e exiba o pagamento:
john = SalesEmployee('John', 5000, 1500)
print(john.get_pay())
Linguagem de código: Python ( python )
Saída:
5000
Linguagem de código: Python ( python )
O get_pay()
método retorna apenas o base_pay
, não a soma do base_pay
e sales_incentive
.
Quando você chama a get_pay()
partir da instância da SalesEmployee
classe, o Python executa o get_pay()
método da Employee
classe, que retorna o arquivo base_pay
.
Para incluir o incentivo de vendas no pagamento, é necessário redefinir o get_pay()
método na SalesEmployee
classe da seguinte forma:
class SalesEmployee(Employee):
def __init__(self, name, base_pay, sales_incentive):
self.name = name
self.base_pay = base_pay
self.sales_incentive = sales_incentive
def get_pay(self):
return self.base_pay + self.sales_incentive
Linguagem de código: Python ( python )
Nesse caso, dizemos que o get_pay()
método da SalesEmployee
classe substitui o get_pay()
método da Employee
classe.
Quando você chama o get_pay()
método do SalesEmployee
objeto ‘, o Python chamará o get_pay()
método na SalesEmployee
classe:
john = SalesEmployee('John', 5000, 1500)
print(john.get_pay())
Linguagem de código: Python ( python )
Saída:
6500
Linguagem de código: Python ( python )
Se você criar uma instância da Employee
classe, o Python chamará o get_pay()
método da Employee
classe, não o get_pay()
método da SalesEmployee
classe. Por exemplo:
jane = Employee('Jane', 5000)
print(jane.get_pay())
Linguagem de código: Python ( python )
Junte tudo.
class Employee:
def __init__(self, name, base_pay):
self.name = name
self.base_pay = base_pay
def get_pay(self):
return self.base_pay
class SalesEmployee(Employee):
def __init__(self, name, base_pay, sales_incentive):
self.name = name
self.base_pay = base_pay
self.sales_incentive = sales_incentive
def get_pay(self):
return self.base_pay + self.sales_incentive
if __name__ == '__main__':
john = SalesEmployee('John', 5000, 1500)
print(john.get_pay())
jane = Employee('Jane', 5000)
print(jane.get_pay())
Linguagem de código: Python ( python )
Exemplo de substituição de método avançado
O seguinte define a Parser
classe:
class Parser:
def __init__(self, text):
self.text = text
def email(self):
match = re.search(r'[a-z0-9\.\-+_]+@[a-z0-9\.\-+_]+\.[a-z]+', self.text)
if match:
return match.group(0)
return None
def phone(self):
match = re.search(r'\d{3}-\d{3}-\d{4}', self.text)
if match:
return match.group(0)
return None
def parse(self):
return {
'email': self.email(),
'phone': self.phone()
}
Linguagem de código: Python ( python )
A Parser
classe possui um atributo text
que especifica um trecho de texto a ser analisado. Além disso, a Parser
classe possui três métodos:
- O
email()
método analisa um texto e retorna o email. - O
phone()
método analisa um texto e retorna um número de telefone no formatonnn-nnnn-nnnn
onden
é um número de 0 a 9, por exemplo,408-205-5663
. - O
parse()
método retorna um dicionário que contém dois elementosemail
ephone
. Ele chama o métodoemail()
andphone()
para extrair o email e o telefone dotext
atributo.
O seguinte usa a Parser
classe para extrair email e telefone:
s = 'Contact us via 408-205-5663 or [email protected]'
parser = Parser(s)
print(parser.parse())
Linguagem de código: Python ( python )
Saída:
{'email': '[email protected]', 'phone': '408-205-5663'}
Linguagem de código: Python ( python )
Suponha que você precise extrair números de telefone no formato n-nnn-nnn-nnnn
, que é o formato de número de telefone do Reino Unido. Além disso, você deseja usar extrair email como a Parser
classe
Para fazer isso, você pode definir uma nova classe chamada UkParser
que herda da Parser
classe. Na UkParser
classe, você substitui o phone()
método da seguinte maneira:
class UkParser(Parser):
def phone(self):
match = re.search(r'(\+\d{1}-\d{3}-\d{3}-\d{4})', self.text)
if match:
return match.group(0)
return None
Linguagem de código: Python ( python )
A seguir, use a UkParser
classe para extrair um número de telefone (no formato do Reino Unido) e e-mail de um texto:
s2 = 'Contact me via +1-650-453-3456 or [email protected]'
parser = UkParser(s2)
print(parser.parse())
Linguagem de código: Python ( python )
Saída:
{'email': '[email protected]', 'phone': '+1-650-453-3456'}
Linguagem de código: Python ( python )
Neste exemplo, parser
chama o parse()
método da classe pai que é a classe Parser. Por sua vez, o parse()
método chama os métodos email()
e phone()
.
No entanto, parser()
não chama o phone()
método da Parser
classe, mas o phone()
método da UkParser
classe:
parser.parse()
Linguagem de código: Python ( python )
A razão é que dentro do parse()
método, the self
é parser
uma instância da UkParser
classe.
Portanto, quando você chama self.phone()
um método dentro do parse()
método, o Python procurará o phone()
método que está vinculado à instância do arquivo UkParser
.
Junte tudo.
import re
class Parser:
def __init__(self, text):
self.text = text
def email(self):
match = re.search(r'[a-z0-9\.\-+_]+@[a-z0-9\.\-+_]+\.[a-z]+', self.text)
if match:
return match.group(0)
return None
def phone(self):
match = re.search(r'\d{3}-\d{3}-\d{4}', self.text)
if match:
return match.group(0)
return None
def parse(self):
return {
'email': self.email(),
'phone': self.phone()
}
class UkParser(Parser):
def phone(self):
match = re.search(r'(\+\d{1}-\d{3}-\d{3}-\d{4})', self.text)
if match:
return match.group(0)
return None
if __name__ == '__main__':
s = 'Contact us via 408-205-5663 or [email protected]'
parser = Parser(s)
print(parser.parse())
s2 = 'Contact me via +1-650-453-3456 or [email protected]'
parser = UkParser(s2)
print(parser.parse())
Linguagem de código: Python ( python )
Substituindo atributos
Veja a seguir como implementar as classes Parser e UkParser substituindo atributos:
import re
class Parser:
phone_pattern = r'\d{3}-\d{3}-\d{4}'
def __init__(self, text):
self.text = text
def email(self):
match = re.search(r'[a-z0-9\.\-+_]+@[a-z0-9\.\-+_]+\.[a-z]+', self.text)
if match:
return match.group(0)
return None
def phone(self):
match = re.search(self.phone_pattern, self.text)
if match:
return match.group(0)
return None
def parse(self):
return {
'email': self.email(),
'phone': self.phone()
}
class UkParser(Parser):
phone_pattern = r'(\+\d{1}-\d{3}-\d{3}-\d{4})'
if __name__ == '__main__':
s = 'Contact us via 408-205-5663 or [email protected]'
parser = Parser(s)
print(parser.parse())
s2 = 'Contact me via +1-650-453-3456 or [email protected]'
parser = UkParser(s2)
print(parser.parse())
Linguagem de código: Python ( python )
Neste exemplo, the Parser
possui uma variável de classe phone_pattern
. O phone()
método na Parser
classe usa phone_pattern
para extrair um número de telefone.
A UkParser
classe filha redefine (ou substitui) o phone_pattern
atributo de classe.
Se você chamar o parse()
método da UkParser
instância de ‘, o parse()
método chamará o phone()
método que usa o phone_pattern
definido na UkParser
classe.
Resumo
- A substituição de método permite que uma classe filha forneça uma implementação específica de um método que já é fornecido por uma de suas classes pai.