Introdução à substituição em Python
Em Substituindo no Python, a programação orientada a objetos, a classe que é declarada inicialmente é chamada de classe pai. o declarado depois disso é chamado de subclasse ou classe filho. Na técnica Substituindo em Python, a subclasse fornece um tipo específico de implementação no qual o elemento da classe pai é substituído pelo elemento na subclasse. De acordo com essa técnica, a entidade declarada na subclasse deve ser semelhante em nome, parâmetro, argumentos com a classe pai. Portanto, nesse caso, diz-se que a subclasse substitui a classe pai.
A função de substituição em Python
O principal tipo de substituição em python é a substituição de método. aqui, um método declarado na classe pai será substituído na subclasse. A representação sintaxe da substituição do método é representada abaixo,
Sintaxe:
class parent_class:
def overriding_method(self):
class Child_class:
def overriden_method(self):
obj1 = parent_class()
obj2 = Child_class()
obj1.overriding_method()
obj2.overriden_method()
Exemplo 1
class parent_class
def __init__(self, Lower_Case, Upper_Case):
self.Lower_Case = Lower_Case
self.Upper_Case = Upper_Case
def attribute_finder_method(self):
print('- - - - - - Overriding method output - - - - -')
print(' - - - - PRINT ON ALPHABETS - - - - - ')
print(' Collection used for variable1 : ', type(Lower_Case))
print(' Collection used for variable2 : ', type(Upper_Case))
print(' Lower case alphabets : ', len(Lower_Case), '--- Values -->', Lower_Case)
print(' Upper case alphabets : ', len(Upper_Case), '--- Values -->', Upper_Case)
print(' ')
print(' ')
print(' ')
class child_class:
def __init__(self, Prime_Numbers):
self.Prime_Numbers = Prime_Numbers
def attribute_finder_method(self):
print('- - - - - - Overriden method output - - - - -')
print(' - - - - PRINT ON PRIME NUMBERS - - - - - ')
print(' Collection used for variable3 : ', type(Prime_Numbers))
print(' Lower case alphabets : ', len(Prime_Numbers), '--- Values -->', Prime_Numbers)
Lower_Case = ( ' a ', ' b ', ' c ', ' d ', ' e ', ' f ', ' g ', ' h ', ' i ', ' j ', ' k ', ' l ', ' m ', ' n ', ' o ', ' p ', ' q ', ' r ', ' s ', ' t ', ' u ', ' v ', ' w ', ' x ', ' y ', ' z ' ) Upper_Case = ( ' A ', ' B ', ' C ', ' D ', ' E ', ' F ', ' G ', ' H ', ' I ', ' J ', ' K ', ' L ', ' M ', ' N ', ' O ', ' P ', ' Q ', ' R ', ' S ', ' T ', ' U ', ' V ', ' W ', ' X ', ' Y ', ' Z ' ) Prime_Numbers = ( ' 1 ', ' 3 ', ' 5 ', ' 7 ', ' 11 ', ' 13 ', ' 17 ', ' 19 ', ' 29 ', ' 31 ', ' 37 ', ' 41 ', ' 43 ', ' 47 ', ' 53 ', ' 59 ', ' 61 ', ' 67 ', ' 71 ', ' 73 ', ' 79 ', ' 83 ', ' 89 ', ' 97 ') object1 = parent_class(Lower_Case, Upper_Case)
object1.attribute_finder_method()
object2 = child_class(Prime_Numbers)
object2.attribute_finder_method()
Resultado:
Explicação:
- O programa acima usa três listas, duas delas com as letras minúscula e maiúscula; a terceira contém os valores dos números primos de 0 a 100.
- a funcionalidade do programa é projetada de tal maneira que se espera que os atributos e o conteúdo dessas listas sejam impressos. Nesse caso, duas classes diferentes são usadas para esse fim. A classe pai lida com todos os alfabetos da coleção, enquanto a classe filho lida com a coleção de números primos.
- Podemos notar que a função 'attribute_finder_method ()' é declarada como parte de ambas as classes. Na classe pai, esse método mantém o processamento de atributos para alfabetos e, na classe filho, mantém o processamento de atributos para números primos. a especificação significativa é o nome da função sendo o mesmo nas duas classes declaradas.
- Portanto, quando um objeto é instanciado para a classe pai, esse objeto será capaz de iniciar a chamada de função para o método na classe pai e, por outro lado, o objeto instanciado para a classe filho será capaz de iniciar a chamada de função para o método na classe filho . Isso significa quando 'objeto2. attribute_finder_method () 'é chamado de chamado de método para a classe filho, mesmo na presença do mesmo método na classe pai. Portanto, isso justifica claramente a substituição do método da classe filho sobre a classe pai declarada, assimilando o fato de que a subclasse é fornecida com um tipo específico de implementação no qual o elemento da classe pai é substituído pelo elemento da subclasse.
Exemplo 2
#!/usr/bin/evn python
# Define a class as 'Individual' #
class Individual:
# Constructor#1 #
def __init__(self):
self.Student_Name = input( " Enter Name of the student : " )
self.Student_age = input( " Enter age of the student : " )
self.Student_gender = input( " Enter gender of the student : " )
# Method
def display(self):
print( " \n \n Enter Name of the student : ", self.Student_Name )
print( " Enter age of the student : ", self.Student_age )
print( " Enter gender of the student : ", self.Student_gender )
# Define a class as 'Evaluated_Marks' #
class Evaluated_Marks:
# Constructor#2 #
def __init__(self):
self.stuClass = input( " Class of the student : " )
print( " Evaluated Marks per subject : " )
self.literature = int(input( " Mark in Literature subject : " ))
self.math = int(input( " Mark in Math subject : " ))
self.biology = int(input( " Mark in Biology subject : " ))
self.physics = int(input( " Mark in Physics subject : " ))
# Method
def display(self):
print( " Study in : ", self.stuClass)
print( " Total Evaluated_Marks : ", self.literature + self.math + self.biology + self.physics)
class student(Individual, Evaluated_Marks):
def __init__(self):
# Call ' Individual ' super class constructor
Individual.__init__(self)
# Call ' Evaluated_Marks ' superclass constructor
Evaluated_Marks.__init__(self)
def result(self):
# Call method of class 'Individual'
Individual.display(self)
# Call method of class 'Evaluated_Marks'
Evaluated_Marks.display(self)
# Objects of class 'student' #
Student1 = student()
Student2 = student()
print(" ")
print( "Note: The instances get initialized with the given values Successfully " )
Resultado:
Explicação:
Aqui, o método display () é herdado e substituído, o que alcança novamente o conceito de substituição de método.
Regras de substituição em Python
- O método substituído deve ter o mesmo nome que o método especificado na classe pai
- métodos estáticos não podem ser substituídos
- Métodos finais não podem ser substituídos
- O modificador sincronizado não tem consequências nos regulamentos de substituição.
Conclusão
O conceito de substituição reflete várias implementações da mesma classe. aqui o modificador sincronizado não tem conseqüências sobre os regulamentos de substituição. Mais anteriormente, define profundamente o comportamento da classe envolvida. esses casos tornam o conceito de substituição muito significativo no mundo python.
Artigos recomendados
Este é um guia para substituir em Python. Aqui discutimos a introdução, Função de substituição e as regras de substituição em Python. Você também pode consultar nossos outros artigos sugeridos para saber mais:
- Recursos do Python
- Substituindo em JavaScript
- Compilador PHP
- Sessões em PHP
- Guia do método estático em PHP
- Exemplos de método estático JavaScript