Question

对于我来说，这只是一个关于Python面向对象编程的一般性问题。我已经阅读了很多教程，但是我很难将其应用到我自己的需求中。我的问题围绕着如何在Python中使用OOP来完成某些基本任务。 OOP可能不是解决此问题的最佳方法，但这主要是使用我已经熟悉的数据结构的OOP示例。我想带一个包含两个项目（在这种情况下为宠物）的CSV文件及其各自的组合价格，例如：

dog1,cat1,5.00

dog1,cat2,7.00

cat1,dog2,10.00

cat2,dog2,10.00

dog2,dog1,8.00

cat1,cat2,10.00

以下代码是我到目前为止所做的，并不是很好，但希望它足以清楚地解释我的问题。使用非常基本的OOP程序（无论我是否需要），我的目标是：

（1）为实例创建实例并识别所需的变量

（2）使用这些变量，创建一个字典，

（3）将（2）的结果传递给另一个方法并解析该词典

最终，第一种方法会创建一个这样的字典：

{'cat__cat'：[10.0]，'dog__cat'：[7.0,10.0,10.0]，'dog__dog'：[8.0]}

然后第二种方法生成：

['dog__cat'，'dog__dog']

...因为这些是“更便宜”的物品。我想要做的，如最后列出的那样，在一行中调用两种方法，使用一种方法调用另一种方法。这是如何完成的？

import sys
import numpy as np
infile=sys.argv[1]
class PriceParser:
    def __init__(self, linesplit):
        linesplit = line.split(",")
        self.Pet1 = linesplit[0]
        self.Pet2 = linesplit[1]
        self.price = linesplit[2].rstrip("\n")
        self.Pet1short = self.Pet1[0:3]
        self.Pet2short = self.Pet2[0:3]
        self.combo = self.Pet1short+"__"+self.Pet2short
        self.comborev = self.Pet2short+"__"+self.Pet1short
        self.PetSame = self.Pet1short+"__"+self.Pet1short
        #dictPetPrices = {}

    def PriceIdentifier (self):
        if self.Pet1short != self.Pet2short:
            if not self.comborev in dictPetPrices:
                if not self.combo in dictPetPrices:
                    dictPetPrices[self.combo]=[]
                dictPetPrices[self.combo]=[float(self.price)]
            else:
                dictPetPrices[self.comborev].append(float(self.price))
        elif self.Pet1short == self.Pet2short:
            if not self.PetSame in dictPetPrices:
                dictPetPrices[self.PetSame]=[]
            dictPetPrices[self.PetSame].append(float(self.price))
        return dictPetPrices

    def PriceSpectrum (self):

        Cheap = []
        for k,v in dictPetPrices.iteritems():

            for i in v:
                if float(i) <= 8:
                    Cheap.append(k)

        return Cheap


if __name__ == '__main__':
    with open(infile) as f:
        dictPetPrices = {}
        for line in f:

            A = PriceParser(line)
            B=A.PriceIdentifier()

    print B
    print A.PriceSpectrum()
    #What I would prefer to do (below), is pass one method into another, if for instance, I have multiple methods that need to be called
    #print A.PriceSpectrum(PriceIdentifier)

Answer 1

import numpy as np

inputstr = """\
dog1,cat1,5.00
dog1,cat2,7.00
cat1,dog2,10.00
cat2,dog2,10.00
dog2,dog1,8.00
cat1,cat2,10.00"""

class PriceParser:
    def __init__(self, line):
        linesplit = line.strip().split(",")
        self.Pet1 = linesplit[0]
        self.Pet2 = linesplit[1]
        self.price = linesplit[2]
        self.Pet1short = self.Pet1[0:3]
        self.Pet2short = self.Pet2[0:3]
        self.combo = self.Pet1short+"__"+self.Pet2short
        self.comborev = self.Pet2short+"__"+self.Pet1short
        self.PetSame = self.Pet1short+"__"+self.Pet1short
        self.dictPetPrices = {}

    def PriceIdentifier (self):
        if self.Pet1short != self.Pet2short:
            if not self.comborev in self.dictPetPrices:
                if not self.combo in self.dictPetPrices:
                    self.dictPetPrices[self.combo]=[]
                self.dictPetPrices[self.combo]=[float(self.price)]
            else:
                self.dictPetPrices[self.comborev].append(float(self.price))
        elif self.Pet1short == self.Pet2short:
            if not self.PetSame in self.dictPetPrices:
                self.dictPetPrices[self.PetSame]=[]
            self.dictPetPrices[self.PetSame].append(float(self.price))
        return self.dictPetPrices

    def PriceSpectrum (self, call_ident=True):
        if call_ident: self.PriceIdentifier()
        Percentiles = []
        for k in self.dictPetPrices.keys():
            self.dictPetPrices[k].sort()
            a = np.asarray(self.dictPetPrices[k])
            Q1 = np.percentile(a, 1)
            Q25 = np.percentile(a, 25)
            Q50 = np.percentile(a, 50)
            Q75 = np.percentile(a, 75)
            Q90 = np.percentile(a, 90)
            Percentiles.extend([Q1,Q50,Q75,Q90])
        return Percentiles

if __name__ == '__main__':              
    for line in inputstr.split("\n"):
        A = PriceParser(line)
        print A.PriceIdentifier()
        print A.PriceSpectrum()

这产生以下结果：

{'dog__cat': [5.0]}
[5.0, 5.0, 5.0, 5.0]
{'dog__cat': [7.0]}
[7.0, 7.0, 7.0, 7.0]
{'cat__dog': [10.0]}
[10.0, 10.0, 10.0, 10.0]
{'cat__dog': [10.0]}
[10.0, 10.0, 10.0, 10.0]
{'dog__dog': [8.0]}
[8.0, 8.0, 8.0, 8.0]
{'cat__cat': [10.0]}
[10.0, 10.0, 10.0, 10.0]

请解释一下你想要的结果。你的意思是制作一个所有价格的数组，那么，你必须解析一个类中的所有输入或使用其他结构。你在这里只解析一行。或者，您可以使用PriceSpectrum（）获取参数，列表，然后累积所有价格或类似的东西。

如您所见，方法使用属性进行内部通信。 Milion对函数的论证是结构编程的东西。将这个概念从任何OO中删除。方法应该只采用询问某些内容或提供实例尚未提供的内容所需的参数。请根据我的代码解释一切。我错了什么，你希望实现什么。你问题的沟通是否令人满意，或者你的目标是什么特殊的。我真的希望这会有所帮助。至少，现在没有错误。

Answer 2

您有一些正确的想法，但您的代码结构糟糕。当您拨打PriceParser(linesplit)时，您实际上正在呼叫PriceParser.__init__(self,linesplit)。这是初始化成员变量的正确位置。因此，将第一批代码从PriceIdentifier移至##注释，移至__init__。这将解决未定义变量名称的问题。

我不明白你在##评论后在代码中想要做什么。将问题放入文本而不是将其隐藏在代码注释中是个好主意。顺便说一句，行self.Percentiles[:]=[]无法访问（返回后）。

Answer 3

我会根据我对您的代码中发生的事情的解释来回答您的问题。我可以告诉你（乍一看）：

...
def __init__ (self, ...):
    self.Pet1 = Pet1

引发NameError，因为您尝试放入self.Pet1的全局变量Pet1不存在。是的，如果Pet1在类之外初始化，并且在实例化类之前，事情会起作用。

# If you wanted just to initialize self.Pet1 then give it a value like: "Pet1", "" or None; inside __init__() constructor.
    self.Pet1 = ""

您的类是解析器，然后在构造函数中解析您的行，并将值放入属性中。如果这样做，则不需要其他方法来获取参数（超过self），您可以使用这些属性来访问所需的值。然后你会有类似的东西：

for line in f:
    A = PriceParser(line)
    print "Cat1 costs:", A.price("cat1") # Or whatever you want
    print "Avg price of all dogs is:", A.PricesMean("dog")

# Use constructor __init__() to do all the job (splitting, putting into attrs, etc.).
# Do not use tons of arguments in methods. What if zoo-shop adds rabbits the next day?
# If you wish to have all kind of pets covered, use one attr with a dictionary to keep values for each, not a new attribute for each pet.
# If you really wish to have an attribute per pet, use an instance scope variable container self.__dict__
# For instance:
def add_doggy (self, dog_name, dog_colour, dog_price):
    self.__dict__["dog_"+dog_name] = (dog_colour, dog_price)
# Then the following is possible:
A.add_doggy("Rex", "black", 30):
print "Rex costs:", A.dog_Rex[1]

# But this, and all other methods you can use to do same/similar things are more in field of meta programming for which, I think, you are not ready yet.

请按照我的评论编辑您的问题。通过示例教程开始学习OOP，尝试做一些严肃的事情，例如。使用wxPython编写GUI，它将帮助您掌握它。

Answer 4

好多了！ call_ident是一个导致self.PriceIdentifier（）被调用的参数。那是为了确保调用self.PriceIdentifier（），如果你之前没有手动调用它。如果您之前打过它，可以说self.PriceSpectrum（0）以避免再次调用它。如果你希望将一个函数传递给另一个函数，就像我得到的那样，就像在C中一样。通过引用访问Python中的可变对象，即指向对象的指针存储在变量中。至少你可以这样看待它。这就是为什么你将它传递给函数时必须复制一个列表的原因，除非你希望在你在该函数内部更改它时更改原始列表。所以：

def f (another_func): return another_func()
def g (): print "blah"
f(g)

您对方法也这样做，因为方法只是带有附加参数self的函数，它是对您希望它引用的实例的引用。在大多数其他语言中，它被称为。

试试这个：

def callme (func, *args, **kwargs):
    print "I will call", func
    print "With arguments:", args
    print "And keyword arguments:", kwargs
    func(*args, **kwargs)

def dateandtime (date, time, zone=None):
    print "The date:", date
    print "The time:", time
    print "Zone:", zone

callme(dateandtime, "01.01.1881. AC", "00:00:00")

尝试添加区域以查看将会发生的情况。如果这是你想要的，那么看看Stack现在连接你的问题，Q更清楚。

Python OOP：练习将一个方法的结果传递给另一个方法

4 个答案: