面向对象的编程蟒蛇

我需要实现一类叫做运动员这需要一个__init__(self,names,fastest_time) 并呼吁fastest_time另一种方法，这将显示速度最快的运动员的名字和时间：面向对象的编程蟒蛇

到目前为止，我有这样的：

class Athlete: 
    def __init__(self,names,ftime): 
     self.name=names 
     self.fastest=ftime 
    def fastest_athlete(self): 


names=(['sara','jam','mary']) 
times=([90,50,75]) 
a=Athlete(name,ftime) 
a.fastest_athlete()

问题：不知道是否需要遍历数组名'times'？不知道如何实现方法faster_time..HELP请

来源

2013-03-16 Java dev

是的，你的倾向是正确的。你应该循环“名字”和“时间”，为每个运动员创建一个对象。提示：'zip（）'将帮助你同时循环两次。 – bernie 2013-03-16 20:16:42

你的oo设计是错误的。一名运动员应该代表一名运动员，并且不应该将名单和时间列表传递给它。 – jurgenreza 2013-03-16 20:18:32

谢谢！什么是zip（）？以前从来没有听说过它..有没有更简单的方法或拉链的唯一途径？ – 2013-03-16 20:18:38

你应该循环数组创建Athlete s。

>>>Athletes = [Athlete(name, time) for name, time in zip(names, times)]  
>>>Athletes[0].name 
sara 
>>>Athletes[1].name 
jam

很好，找到最快的运动员，你可以使用max和min功能。

>>>min(Athletes, key = lambda a : a.fastest)

但你应该注意到，min()是一个包含Athlete S，不是在Athlete本身的阵列上进行。如果你想找到最快的Athlete，你可能需要类似AthleteContainer类。

来源

2013-03-16 20:21:21 thkang

有一个轻微修改上面的代码： – 2013-03-16 20:25:32

类运动员： DEF __init __（个体，名称，FTIME）： self.name =名 self.fastest = FTIME DEF fastest_athlete（个体）：名称=（ ['萨拉'，'果酱'，'玛丽']） times =（[90,50,75]） a =运动员（姓名，次数） a.fastest_athlete（） – 2013-03-16 20:25:49

我不知道如果方法最快时间应该采取名称和时间..迷惑怎么办 – 2013-03-16 20:26:33

由于速度最快的运动员的东西，不依赖于一个具体的实例，它更appropiate作为一个静态方法：

class Athlete: 
    # ... 
    @staticmethod 
    def fastest_athlete(athletes): 
     return reduce(lambda x, y: x if x.fastest < y.fastest else y, athletes) 

# ... 
athletes = [Athlete(name, time) for name, time in zip(names, times)] 
fastest = Athlete.fastest_athlete(athletes)

来源

2013-03-16 20:30:41

如果你想fastest_athlete成为运动员类的一部分，那么你Athlete上课应该能够到达所有运动员。

fastest_athlete会返回一个列表，因为可能会有更多运动员跑最佳时间。

athletes=[] # stores all athletes 

class Athlete: 
    def __init__(self,names,ftime): 
     self.name=names 
     self.fastest=ftime 
     athletes.append(self) 
    def fastest_athlete(self): 
     besttime= min([athlete.fastest for athlete in athletes]) 
     return [athlete.name for athlete in athletes if athlete.fastest==besttime] 



names=(['sara','jam','mary']) 
times=([90,50,75]) 

for a, t in zip(names, times): 
    last_athlete=Athlete(a, t) 

print last_athlete.fastest_athlete()

来源

2013-03-16 20:36:52 drjors

heyy谢谢！它的工作原理，但我不明白这个位besttime = min（[athlete.fastest运动员在运动员]）请问你能解释给我更多的细节？谢谢 – 2013-03-16 20:40:22

运动员是包含每个运动员的列表。
[]部分返回包含每个运动员每次的列表。 min（[]）返回所有的最小（最佳）时间。 “返回”为最快时间等于最佳时间的所有运动员过滤相同的运动员列表，然后将其名称作为列表返回。 – drjors 2013-03-18 15:56:46

如果你只是想循环数组self.name然后在：

for name in self.names: 
    # Do something

但对于实际的问题：

def fastest_athlete(self): 
    combined = zip(self.names, self.fastest) 

    #Note that this will return the athlete with the first fastest time if there are dupes 
    index = self.fastest.index(min(self.fastest)) 

    #If you want multiples: 
    indices = [i for i,n in enumerate(self.fastest) if n == min(self.fastest)] 

    #Either return the list (combined[0] is the athlete's name, combined[1] is the associated time) or print it here. 
    return combined[index]

不过，我同意另一个评论 - 运动员应单独的对象，而不是一个集合。

来源

2013-03-16 20:36:54 Josh

你可以覆盖__gt__方法并使用python的max函数。每个班级也应代表一名运动员，而不是运动员名单。

>>> class Athlete: 
    name = None 
    time = None 

    def __init__(self, name, time): 
     self.name = name 
     self.time = time 

    def __gt__(self, other): 
     return self.time > other.time 

>>> names = ['sara', 'jam', 'mary'] 
>>> times = [90 ,50 , 75] 
>>> 
>>> athletes = [Athlete(name, time) for name, time in zip(names, times)] 
>>> 
>>> fastest = max(athletes) 
>>> fastest.name 
'sara' 
>>> fastest.time 
90

来源

2013-03-16 20:40:53 jurgenreza

面向对象的编程蟒蛇

回答

相关问题