Python - используя __init__ с унаследованным методом для класса полиномов

Question

Это класс, который будет принимать в качестве входных данных, а затем выводит многочлен в виде строки (в обоих направлениях в том же формате). Некоторая арифметика выполняется различными способами. Я пытался наследовать этот класс в другой класс, который затем будет использовать специальный метод __mod __() первого класса (или, если это необходимо, сделать его собственным специальным методом, но я не вижу, как вы не можете просто использовать оригинал метод) для выполнения мода на входе. Похоже, что это входит в __init __(), но я пробовал 5 разных версий этого, даже если допустить изменение родительского класса, и я никуда не буду. Я преподаю сам Python, поэтому я уверен, что даже младший разработчик Python может увидеть, где я буду совершенно ошибаться.

import re 

class GF2Polynomial(object): #classes should generally inherit from object 

    def __init__(self, string): 
     '''__init__ is a standard special method used to initialize objects. 
     Here __init__ will initialize a gf2infix object based on a string.''' 
     self.string = string #basically the initial string (polynomial) 
     self.key,self.lst = self.parsePolyVariable(string) # key determines polynomial compatibility 
     self.bin = self.prepBinary(string) #main value used in operations 

    def id(self,lst): 
     """returns modulus 2 (1,0,0,1,1,....) for input lists""" 
     return [int(lst[i])%2 for i in range(len(lst))] 

    def listToInt(self,lst): 
     """converts list to integer for later use""" 
     result = self.id(lst) 
     return int(''.join(map(str,result))) 

    def parsePolyToListInput(self,poly): 
     """ 
     replaced by parsePolyVariable. still functional but not needed. 
     performs regex on raw string and converts to list 
     """ 
     c = [int(i.group(0)) for i in re.finditer(r'\d+', poly)] 
     return [1 if x in c else 0 for x in xrange(max(c), -1, -1)] 

    def parsePolyVariable(self,poly): 
     """ 
     performs regex on raw string, converts to list. 
     also determines key (main variable used) in each polynomial on intake 
     """ 
     c = [int(m.group(0)) for m in re.finditer(r'\d+', poly)] #re.finditer returns an iterator 
     letter = [str(m.group(0)) for m in re.finditer(r'[a-z]', poly)] 
     m = max(c); varmatch = True; key = letter[0] 
     for i in range(len(letter)): 
      if letter[i] != key: varmatch = False 
      else: varmatch = True 
     if varmatch == False: return "error: not all variables in %s are the same"%a 
     d = [1 if x in c else (1 if x==0 else (1 if x=='x' else 0)) for x in xrange(m, -1, -1)] 
     return key,d 

    def polyVariableCheck(self,other): 
     return self.key == other.key 

    def prepBinary(self,poly): 
     """converts to base 2; bina,binb are binary values like 110100101100.....""" 
     x = self.lst; a = self.listToInt(x) 
     return int(str(a),2) 

    def __mod__(self,other): 
     """ 
     __mod__ is the special method for overriding the % operator 
     returns remainder formatted as polynomial 
     """ 
     if self.polyVariableCheck(other) == False: 
      return "error: variables of %s and %s do not match"%(self.string,other.string) 
     if self.bin == other.bin: return 0 
     return GF2Polynomial(self.outFormat(self.bin%other.bin)) 

    def __str__(self): 
     return self.string 

    def outFormat(self,raw): 
     """process resulting values into polynomial format""" 
     raw = "{0:b}".format(raw); raw = str(raw[::-1]); g = [] #reverse binary string for enumeration 
     g = [i for i,c in enumerate(raw) if c == '1'] 
     processed = "x**"+" + x**".join(map(str, g[::-1])) 
     proc1 = processed.replace("x**1","x"); proc2 = proc1.replace("x**0","1") 
     if len(g) == 0: return 0 #return 0 if list empty 
     return proc2 #returns result in gf(2) polynomial form 

Желаемый результат должен быть в состоянии назвать его на новый (ребенок) класса с родительским типом и при изменении родительского класса как можно меньше (если даже вообще). Обратите внимание, что класс «BinaryField» является предполагаемый дочерний класс:

p=GF2Polynomial("x**2+x**1+x**0") 
a=BinaryField("x**1+x**0", p) 
b=BinaryField("x**1", p) 

На приеме, данный полином должен быть модуль разделен на 2 элемента (здесь это «р»). Это необходимо для математики конечного поля.

EDIT: при запуске его -

## "x**1 + x**0" polynomial string style input 
poly1 = "x**14 + x**1 + x**0"; poly2 = "x**6 + x**2 + x**1"; poly3 = "y**6 + y**2 + y**1" 
a = GF2Polynomial(poly1); b = GF2Polynomial(poly2); c = GF2Polynomial(poly3) 
## "x+1" polynomial string style input 
poly4 = "x**14 + x + 1"; poly5 = "x**6 + x**2 + x"; poly6 = "y**6 + y**2 + 1" 
d = GF2Polynomial(poly4); e = GF2Polynomial(poly5); f = GF2Polynomial(poly6) 
bf1 = BinaryField(poly1,b); print bf1 
bf2 = BinaryField(poly4,e); print bf2 

Оба этих стилей возможен из-за того, как я закодированным, но они оба должны возвращать тот же самый ответ. Однако результат по этому коду:

>>> 
x**5 + x**4 + x**3 + 1 
x**5 + x 

Кроме того, при использовании BinaryField (poly4, d), которая как раз та же строка с его GF2Polynomial() инициализации, это ошибки, как: AttributeError: 'int' object has no attribute 'string'

Answer 1

Does это решает вашу проблему?

class BinaryField(GF2Polynomial): 
    def __init__(self, string, mod): 
     modded = GF2Polynomial(string) % mod 
     super(BinaryField, self).__init__(modded.string) 


>>> p = GF2Polynomial("x**2+x**1+x**0") 
>>> a = BinaryField("x**1+x**0", p) 
>>> print a 
x + 1 

Вы можете также сделать BinaryField класс быть только фабричный метод:

def BinaryField(string, mod): 
    return GF2Polynomial(string) % mod