Python——类与模块

Posted 2023-02-23

【中文标题】Python——类与模块

【英文标题】：Python -- class vs module

【发布时间】：2013-06-25 17:43:36

【问题描述】：

我正在开发一组功能，这些功能可能更容易单独管理，只是在一个模块中。但是，除了我的薪水等级之外，还有其他原因想考虑把它变成一门课。但是，由于它是从多项式输入转换为字符串，因此正则表达式适用于字符串，但是一旦输入是类实例，它就会决定在此之后退出。

所以我的问题是如何将它变成一个类并仍然保持功能（如何初始化它等）。或者，如果这种情况更适合作为一个模块，那么我可以争辩说，但我需要完全理解。我检查了这些，但我不确定我是否能从它们中得到足够的东西来解决这个问题：

http://docs.python.org/2/tutorial/classes.html

organising classes and modules in python

import re

def id(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(lst):  #converts list to integer for later use
    result = id(lst)
    return int(''.join(map(str,result)))

def parsePolyToListInput(poly):
    c = [int(i.group(0)) for i in re.finditer(r'\d+', poly)] #re.finditer returns an iterator
    return [1 if x in c else 0  for x in xrange(max(c), -1, -1)]

def prepBinary(x,y):  #converts to base 2 and orders min and max for use
    x = parsePolyToListInput(x); y = parsePolyToListInput(y)
    a = listToInt(x); b = listToInt(y)
    bina = int(str(a),2); binb = int(str(b),2)
    #a = min(bina,binb); b = max(bina,binb);
    return bina,binb  #bina,binb are binary values like 110100101100.....

def add(a,b): # a,b are GF(2) polynomials like x**7 + x**3 + x**0 ....
    bina,binb = prepBinary(a,b)
    return outFormat(bina^binb)  #returns binary string

def subtract(x,y):  # same as addition in GF(2)
    return add(x,y)

def multiply(a,b):  # a,b are GF(2) polynomials like x**7 + x**3 + x**0 ....
    a,b = prepBinary(a,b)
    return outFormat(a*b)  #returns product of 2 polynomials in gf2

def divide(a,b): #a,b are GF(2) polynomials like x**7 + x**3 + x**0 ....
    a,b = prepBinary(a,b)
    #bitsa = "0:b".format(a); bitsb = "0:b".format(b)
    return outFormat(a/b),outFormat(a%b)  #returns remainder and quotient formatted as polynomials

def quotient(a,b): #separate quotient function for clarity when calling
    return divide(a,b)[1]

def remainder(a,b): #separate remainder function for clarity when calling
    return divide(a,b)[0]

def outFormat(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]))
    if len(g) == 0: return 0 #return 0 if list empty
    return processed  #returns result in gf(2) polynomial form

def extendedEuclideanGF2(a,b): # extended euclidean. a,b are values 10110011... in integer form
    inita,initb=a,b;  x,prevx=0,1;  y,prevy = 1,0
    while b != 0:
        q = int("0:b".format(a//b),2)
        a,b = b,int("0:b".format(a%b),2);
        x,prevx = (int("0:b".format(prevx-q*x)), int("0:b".format(x,2)));  y,prevy=(prevy-q*y, y)
    #print("%d * %d + %d * %d = %d" % (inita,prevx,initb,prevy,a))
    return a,prevx,prevy  # returns gcd of (a,b), and factors s and t

def modular_inverse(a,mod): # a,mod are GF(2) polynomials like x**7 + x**3 + x**0 ....
    a,mod = prepBinary(a,mod)
    bitsa = int("0:b".format(a),2); bitsb = int("0:b".format(mod),2)
    #return bitsa,bitsb,type(bitsa),type(bitsb),a,mod,type(a),type(mod)
    gcd,s,t = extendedEuclideanGF2(a,mod); s = int("0:b".format(s))
    initmi = s%mod; mi = int("0:b".format(initmi))
    print ("%d * %d mod %d = 1"%(a,initmi,mod))
    if gcd !=1: return outFormat(mi),False
    return outFormat(mi)   # returns modular inverse of a,mod


a = "x**14 + x**1 + x**0"; b = "x**6 + x**2 + x**1"
c = "x**2 + x**1 + x**0"; d = "x**3 + x**1 + x**0"
e = "x**3 + x**2 + x**1 + x**0"; f = "x**2"; g = "x**1 + x**0"
p = "x**13 + x**1 + x**0"; q = "x**12 + x**1"
print "add: [%s] + [%s]  =  %s "%(a,b,add(a,b))
print "add: [%s] + [%s]  =  %s "%(c,d,add(c,d))
print "multiply: [%s] * [%s]  =  %s "%(a,b,multiply(a,b))
print "multiply: [%s] * [%s]  =  %s "%(c,d,multiply(c,d))
print "multiply: [%s] * [%s]  =  %s "%(f,g,multiply(f,g))
print "quotient (max(a,b)/min(a,b): [%s] / [%s]  =  %s "%(a,b,quotient(a,b))
print "quotient (max(a,b)/min(a,b): [%s] / [%s]  =  %s "%(c,d,quotient(c,d))
print "remainder (max(a,b) mod min(a,b)): [%s] mod [%s]  =  %s "%(a,b,remainder(a,b))
print "remainder (max(a,b) mod min(a,b): [%s] mod [%s]  =  %s "%(c,d,remainder(c,d))
valuemi1 = modular_inverse(a,b)
print "modular_inverse: [%s] * [%s] mod [%s] = 1  [%s]"%(a,valuemi1[0],b,valuemi1[1])
valuemi2 = modular_inverse(p,q)
print "modular_inverse: [%s] * [%s] mod [%s] = 1  [%s]"%(p,valuemi2[0],q,valuemi2[1])

每个算术运算只接受一个字符串格式的 GF(2) 多项式，然后将其解析为相应的二进制值，然后将其发送到 outFormat() 以转换回多项式。现在工作正常，所以如果它没有坏，我倾向于不修复它。

【参考方案1】：

我只是一个新手 python 开发人员，但是如果我正确理解了您的问题，那么您需要编写如下代码：

import re
class MathOperations:
      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))]

然后你就可以使用类了：

obj = MathOperations()
obj.id([1, 2])

【讨论】：

感谢我正在寻找的东西。只有两件事：1.我看到的大多数类都使用class Math(object):而不是class Math: ... 2.然后当你创建一个实例并使用它时，我不确定它为什么会遇到正则表达式问题但现在此实例似乎可以处理输入...

@Rami：使用标准的self 变量可能会更好——提高可读性。 @stackuser：似乎您要做的只是将一些函数打包到一个类中。我没有看到您的函数交换数据。那么为什么不使用静态函数。例如：`` 类 MathOperations：@staticmethod def id(lst): return [int(val)%2 for i, val in enumerate(lst)] ``需要注意的几件事：你可以这样调用：MathOperations.id( [1,2])

很抱歉格式混乱，但不想添加新评论

@Rami：不确定您所说的不“交换数据”是什么意思——似乎 13 个人中只有 4 或 5 个不互相打电话。其余的都在那里使用其他功能。比如，outFormat()、id() 等不要调用其他的 1。