Sich im Durchschnitt in einer Funktion in Python

Ich versuche zu lernen Python, und ich bin stecken. Alles ging gut, bis die Letzte Funktion, die die:

def get_class_average(students):

bis zu diesem Punkt hat alles Prima funktioniert, aber es in der letzten Funktion, ich kann nicht herausfinden, wie es funktioniert. Ich werde versuchen, die Durchschnittswerte für jeden Schüler, dann die Berechnung der Durchschnitt dieser Mittelwerte, in anderen Worten, die "Klasse-Durchschnitt" So, ich würde nur gerne wissen, die Antwort auf die Letzte Funktion ohne änderung der Funktionen, bevor der Letzte:

lloyd = {
    "name": "Lloyd",
    "homework": [90.0, 97.0, 75.0, 92.0],
    "quizzes": [88.0, 40.0, 94.0],
    "tests": [75.0, 90.0]
}
alice = {
    "name": "Alice",
    "homework": [100.0, 92.0, 98.0, 100.0],
    "quizzes": [82.0, 83.0, 91.0],
    "tests": [89.0, 97.0]
}
tyler = {
    "name": "Tyler",
    "homework": [0.0, 87.0, 75.0, 22.0],
    "quizzes": [0.0, 75.0, 78.0],
    "tests": [100.0, 100.0]
}



def average(numbers):
       total = sum(numbers)
       return float(total) / len(numbers)


def get_average(student):
       homework = average(student["homework"]) 
       quizzes = average(student["quizzes"]) 
       tests = average(student["tests"]) 
       return 0.1 * average(student["homework"]) + 0.3 * average(student["quizzes"])    +     0.6 * average(student["tests"])

def get_letter_grade(score):
       if score >= 90:
              return "A"
       elif score >= 80:
              return "B"         
       elif score >= 70:
              return "C"
       elif score >= 60:
              return "D"
       else:
              return "F"

def get_class_average(students):
       results = []
       for student in results:
              get_average(student)
              results.append(student)
              average(student)
              return results

students = [lloyd,alice,tyler]

print get_class_average(students)

Endlich fand ich die Lösung für diese ein. So, ich will einfach nur nach den korrigierten code hier unten für die Letzte Funktion, get_class_average(Studenten). Jetzt funktioniert es:

def get_class_average(students):
       results = []
       for each in students:
              studentavg = float(get_average(each))
              results.append(studentavg)
       return average(results)

students = [lloyd,alice,tyler]

print get_class_average(students)

Sie sollten gehen Sie durch die vorherigen Funktionen und versuchen Sie zu verstehen, wie Sie funktionieren ersten.
in get_class_average du bist der Iteration über die Ergebnisse (leere Liste), wenn Sie sollten die Iteration über die Schüler. for student in students: Auch die Rückgabe außerhalb der for-Schleife - sonst wird es erst wieder die ersten Schüler. Dies sollte fix it für Sie.
Ignacio Vazquez-Abrams ich verstehen, wie Sie funktionieren, schrieb ich den vorherigen Funktionen nacheinander und Schritt für Schritt. In der letzten Funktion, ich bin offensichtlich etwas fehlt
Ich habe versucht, dass Sie wohl Recht haben, dass es behoben werden sollte, aber auch wenn ich die Einstellung ändern, funktioniert es nicht
Okay auf der Suche tiefer in Ihren code innerhalb get_class_average, die Sie anrufen, Durchschnitt(Studenten). Die Durchschnitt () - Funktion kann nur unterstützen, eine Liste von zahlen, weil es aus der Summe der argument. Ich denke, was Sie wollen, ist get_average(student), zusammen mit den änderungen, die ich oben erwähnt, wie gut. Sie müssen auch herausfinden, wie hängen die Mittelwerte zusammen mit Ihnen, wie Sie Ihren code nur fügt der Liste der Studenten in eine neue Liste und druckt Sie aus.
Jordan ja, diese sind das, was ich bin versucht, herauszufinden, aber ich habe nicht die Antwort gefunden, doch
Okay, anstelle von Anhängen Schüler auf die Ergebnisse, fügen Sie die get_average(student). Dies könnte das sein, was du bist suchen für. results.append(get_average(student)) und dann wieder den Durchschnitt gesetzt. return average(results)

InformationsquelleAutor Joe T. Boka | 2014-07-05

Du bist nicht wirklich nehmen soll durchschnittlich durchschnittlich, nur damit Sie es wissen. Ich habe korrigiert Sie Ihren code, um es zu bekommen, um korrekt zu arbeiten. Hier ist es:

lloyd = {
    "name": "Lloyd",
    "homework": [90.0, 97.0, 75.0, 92.0],
    "quizzes": [88.0, 40.0, 94.0],
    "tests": [75.0, 90.0]
}
alice = {
    "name": "Alice",
    "homework": [100.0, 92.0, 98.0, 100.0],
    "quizzes": [82.0, 83.0, 91.0],
    "tests": [89.0, 97.0]
}
tyler = {
    "name": "Tyler",
    "homework": [0.0, 87.0, 75.0, 22.0],
    "quizzes": [0.0, 75.0, 78.0],
    "tests": [100.0, 100.0]
}



def average(numbers):
    total = sum(numbers)
    return float(total) / len(numbers)


def get_average(student):
       homework = average(student["homework"]) 
       quizzes = average(student["quizzes"]) 
       tests = average(student["tests"]) 
       return 0.1 * average(student["homework"]) \
            + 0.3 * average(student["quizzes"]) \
        + 0.6 * average(student["tests"])

def get_letter_grade(score):
       if score >= 90:
              return "A"
       elif score >= 80:
              return "B"         
       elif score >= 70:
              return "C"
       elif score >= 60:
              return "D"
       else:
              return "F"

def get_class_average(students):
    results = []
    for student in students:
        a = get_average(student)
        results.append(a)
    return average(results)

students = [lloyd,alice,tyler]

print get_class_average(students)

Da du bist neu in python habe ich den besseren Teil von einer Stunde oder zwei und umgeschrieben Ihrem code verwenden Sie die verschiedenen Funktionen von python, darunter docstrings, Generatoren, Liste Verstehens, Klassen, sowie eine map-reduce Muster, und auch einige neue Importe wie auch unit-test Modul. Ich weiß, Sie sagte minimale änderungen an Ihrem code, aber ich fühlte, wie es wäre eine Unhöflichkeit, um Sie einfach Ihr problem lösen und bewegen auf. Ich wollte für Euch einige Ausschnitte, mit Ihrem Beispiel, dass ich aufgebaut und gelernt werden, während das lernen von python selbst.

Mein Beispiel ist DEUTLICH länger und größer als deiner, und ich bin in keinster Weise darauf hindeutet, Sie nehmen Weg über die kürzeste und einfachste route, ich bin lediglich ein Beispiel. Seien Sie nicht beunruhigt, wenn Sie dieses Lesen, gehen Sie einfach durch Sie und mit Ihr spielen und Sie nutzen, um den besten Ihrer Fähigkeit. Sie müssen möglicherweise halten Sie sinniert in Ihrem Kopf & Dateisystem für eine Weile, bevor es beginnt Sinn zu machen.

Wenn Sie wissen wollen, was alle, die if __name__ == "__main__": Müll ist, schlage ich vor, Sie speichern Sie meinen code in eine Datei namens Student.py - und call - import Student aus einem python-interpreter-Sitzung. Beachten Sie, was passiert anders :). Auch, in der gleichen Sitzung, nach dem Aufruf import Student (aus dem gleichen Verzeichnis Student.py gespeichert ist, natürlich) geben help(Student) -- ich garantieren, es wird Ihre Zeit Wert sein.

from __future__ import division # to get rid of having to use float()
from math       import floor, log10 # for a helper function

class Student:
    """
    A class encapsulating elements of a student object. 
    Notable properties:
    homework_weight(0.1) --> a float multiplying student's homework average
    quiz_weight(0.3)     --> a float multiplying the student's quiz average
    test_weight(0.6)     --> a float multiplying the student's test average
    delimiter            --> a character used to separate fields in __str__
    """
    sig_figs        = 2
    homework_weight = 0.1
    quiz_weight     = 0.3
    test_weight     = 0.6
    delimiter       = '|'

    def __init__(self, name, homework, quizzes, tests):
        """
        Constructor for the Student object. Parameters are as follows:
        name      --> a string containing the student's name
        homework  --> a list of floats containing homework grades
        quizzes   --> a list of floats containing quiz grades
        tests     --> a list of floats containing test grades
        """
        self.__name     = name
        self.__homework = homework
        self.__quizzes  = quizzes
        self.__tests    = tests

    def get_name(self):
        """ Returns the current object's name """
        return self.__name

    def get_homeworks(self):
        """ yields a generator object for student's homework grades"""
        for i in self.__homework: yield i

    def get_quizzes(self):
        """ yields a generator object for student's quiz grades"""
        for i in self.__quizzes:  yield i

    def get_tests(self):
        """ yields a generator object for student's test grades"""
        for i in self.__tests:    yield i


    @classmethod
    def from_dict(cls, student_dict):
        """
        Creates a Student object from a dictionary. The dictionary must
        contain the following key-value pairs:
        'name'     : student_name
        'homework' : list of floats for homework grades
        'quizzes'  : list of floats for quiz grades
        'tests'    : list of floats for test grades
        """
        d = student_dict
        return cls(d['name'], d['homework'], d['quizzes'], d['tests'])

    def __str__(self):
        """
        Returns a string representation of the current
        object. The representation will be in the form
        of the fields separated by the default separator
        character (currently '|').
        """
        conv = lambda x, d: d.join(map(str, x))
        sep  = self.delimiter

        buff = ''
        buff +=      self.__name           + sep
        buff += conv(self.__homework, sep) + sep
        buff += conv(self.__quizzes,  sep) + sep
        buff += conv(self.__tests,    sep) 

        return buff

    def __repr__(self):
        """
        Returns a representation of the current object. In this
        case, we will return the same thing as __str__
        """
        return str(self)


    def to_dict(self):
        """
        Returns a dict representation of this object containing
        the keys ['name', 'homework', 'quizzes', 'tests'] where
        homework, quizzes, and tests are lists of floats.
        """
        obj = {}
        obj['name']     = self.__name
        obj['homework'] = self.__homework
        obj['quizzes']  = self.__quizzes
        obj['tests']    = self.__tests
        return obj



    def get_student_average(self, tuplify=False):
        """
        This method retrieves the student's class average according
        to predefined weighting rules. In this method, we average the
        list of scores together for the student's homework, quizzes,
        and tests, multiply them by their respective weights, and
        sum them together to obtain the final score. See implementation
        for more details.
        """
        hw = self.__homework
        qu = self.__quizzes
        ts = self.__tests

        if(0 not in map(len, [hw, qu, ts])): #division by zero, bla bla
            avg  = lambda l: sum(l)/len(l)
            avgs = map(avg,  [hw, qu, ts])
            hwa  = avgs[0] * Student.homework_weight
            qua  = avgs[1] * Student.quiz_weight
            tsa  = avgs[2] * Student.test_weight
            if tuplify is False:
                return sum([hwa, qua, tsa])
            else: 
                return (hwa, qua, tsa)

    def get_student_averages(self):
        """
        This method retrieves the student's class averages according
        to predefined weighting rules. In this method, we average the
        list of scores together for the student's homework, quizzes,
        and tests, multiply them by their respective weights, and return
        a set of them as a tuple where (homeworka, quiza, testa)
        See implementation for more details. 
        """
        return self.get_student_averages(tuplify=True)

    def get_student_letter_grade(self):
        """
        This method takes a student's letter score according to their
        average (computed by self.get_student_average()) and fetches
        the appropriate letter grade (A through F)
        """
        score = self.get_student_average()
        if   score >= 90:   return 'A'
        elif score >= 80:   return 'B'
        elif score >= 70:   return 'C'
        elif score >= 60:   return 'D'
        else:           return 'F'

    @staticmethod
    def __get_significant_average(grade_list):
        """ 
        Takes a list of grades and returns an average, does the average
        using proper significant figures according to a global variable
        grade_list -- a list of floats to average
        """
        sigfig = lambda x, n: round(x, -int(floor(log10(x))) + (n - 1))
        avg    = sigfig(sum(grade_list)/len(grade_list), num_figs)
        print '\t\t' + str(avg)
        return avg

    @staticmethod
    def get_class_set(student_list):
        """
        Generates a student object from a list of students
        and by assembling all the student's grades for each
        assignment and then using methods in the Student class
        to compute what we need to compute. 
        """
        # this is REALLY slick. What we're going to do is create a 
        # generator  generators of the student's homework and test
        # grades, but for the quizzes we will make regular list of
        # lists. 
        hwg = (x.get_homeworks()            for x in student_list)
        qwg = [[q for q in y.get_quizzes()] for y in student_list]
        twg = (z.get_tests()                for z in student_list)

        tl = lambda l: [x for x in l]
        # ^This is a lambda expression that converts a generator l
        # to a list (hence tl)



        # since each get_blabla() function returns a generator
        # and since each *wg variable is a generator of a generator
        # we will eventually get sublists of sublists of sublists
        # on and on and on and need to flatten them. Here are three
        # ways to do that. 
    # http://stackoverflow.com/questions/952914/making-a-flat-list-out-of-list-of-lists-in-python 
        hwl = [item for sublist in hwg for item in sublist]
        qwl = sum(qwg, []) 
        twl = reduce(lambda x,y: tl(x)+tl(y), twg)

        class_set = Student('class_whole_set', hwl, qwl, twl)
        return class_set




if __name__ == "__main__":

    lloyd = {
        "name": "Lloyd",
        "homework": [90.0, 97.0, 75.0, 92.0],
        "quizzes": [88.0, 40.0, 94.0],
        "tests": [75.0, 90.0]
    }

    alice = {
        "name": "Alice",
        "homework": [100.0, 92.0, 98.0, 100.0],
        "quizzes": [82.0, 83.0, 91.0],
        "tests": [89.0, 97.0]
    }

    tyler = {
        "name": "Tyler",
        "homework": [0.0, 87.0, 75.0, 22.0],
        "quizzes": [0.0, 75.0, 78.0],
        "tests": [100.0, 100.0]
    }

    slloyd  = Student.from_dict(lloyd)
    salice  = Student(alice['name'], alice['homework'], alice['quizzes'], alice['tests'])
    styler  = Student.from_dict(tyler)

#  YOU COULD DO THIS!
#   print 'lloyd dict'
#   print '\t' + str(sdlloyd)
#
#   print 'alice ctor'
#   print '\t' + str(slloyd)
#
#   print 'slloyd name: ' + slloyd.to_dict()['name']
#   print 'slloyd home: ' + str(map(str, slloyd.to_dict()['homework']))
#   print 'slloyd quiz: ' + str(map(str, slloyd.to_dict()['quizzes']))
#   print 'slloyd test: ' + str(map(str, slloyd.to_dict()['tests']))
#   print 'slloyd avg:  ' + str(slloyd.get_student_average())
#
#   conv = lambda x: str(map(str, x))
#   print 'salice name: ' + salice.get_name()
#   print 'salice home: ' + conv(salice.get_homeworks())
#   print 'salice quiz: ' + conv(salice.get_quizzes())
#   print 'salice test: ' + conv(salice.get_tests())
#   print 'salice avg:  ' + str(salice.get_student_average())
#


    """Unit test some object obj"""
    def unit_test(objname, obj):
        conv = lambda x: str(map(str, x))
        print str(objname) + ' name: ' + obj.get_name()
        print str(objname) + ' home: ' + conv(obj.get_homeworks())
        print str(objname) + ' quiz: ' + conv(obj.get_quizzes())
        print str(objname) + ' test: ' + conv(obj.get_tests())
        print str(objname) + ' avg : ' + str(obj.get_student_average())
        print str(objname) + ' let : ' + obj.get_student_letter_grade()

    sclss  = Student.get_class_set( [slloyd, salice, styler] )
    unit_test('sclss', sclss)
    unit_test('slloyd', slloyd)
    unit_test('salice', salice)
    unit_test('styler', styler)

Bitte lassen Sie mich wissen, wenn dies Ihnen hilft, und wenn Sie verwirrt sind von jedem Aspekt dieses Kodex. Herzlich willkommen auf stack overflow 🙂

Vielen Dank für deine Antwort. Ich bin noch am studieren Ihr mehr Beispiel-code Ihrer zweiten Antwort, die ist in der Tat sehr Komplex. Ich Schätze es sehr.Jedoch, die erste, einfache version immer noch nicht das zurück, was ich Suche. Was ich versuche zu bekommen, mit der letzten Funktion, get_class_average, wird zuerst der Durchschnitt für jeden Schüler mit der Funktion get_average(), irgendwie anfügen, dass die Ergebnisse und endlich wieder die Klasse im Durchschnitt, was ist der Durchschnitt von jedem Schüler durchschnittlich mit der Funktion average(). Bitte lassen Sie mich wissen Sie Ihre Gedanken.
Du bist so willkommen. Wenn meine Antwort Ihnen geholfen, die in einer signifikanten Art und Weise, vergessen Sie nicht, markieren Sie es als Antwort. Meine zweite Teil von code ist nicht Komplex, sobald Sie Spurenelemente, die er alle aus -- meine Empfehlung ist, drucken Sie es aus und hand-trace mit einem Stift und Papier. Auch die einfache version des get_class_average macht genau das, was Sie sagte; auch wenn es technisch eine falsche Praxis zum Durchschnitt, durchschnittlich. Welche Ergebnisse konnten Sie immer, dass Sie nicht wie?
alvonellos ich bearbeitet meine ursprüngliche Frage gepostet und die Lösung des Problems. Bitte siehe mein edit oben.
Ich bin froh, dass meine Antwort geholfen hat.

InformationsquelleAutor alvonellos

0

lloyd = { "name": "Lloyd", "homework": [90.0, 97.0, 75.0, 92.0], "quizzes": [88.0, 40.0, 94.0], "tests": [75.0, 90.0] } alice = { "name": "Alice", "homework": [100.0, 92.0, 98.0, 100.0], "quizzes": [82.0, 83.0, 91.0], "tests": [89.0, 97.0] } tyler = { "name": "Tyler", "homework": [0.0, 87.0, 75.0, 22.0], "quizzes": [0.0, 75.0, 78.0], "tests": [100.0, 100.0] }

Add your function below! def average(numbers): total = float(sum(numbers)) return total/len(numbers) def get_average(student): homework = average(student['homework']) * 0.1 quizzes = average(student['quizzes']) * 0.3 tests = average(student['tests']) * 0.6 return (homework + quizzes + tests) def get_letter_grade(score): if score > 90 or score == 90: return "A" elif score > 80 or score == 80 and score < 90: return "B" elif score > 70 or score == 70 and score < 80: return "C" elif score > 60 or score == 60 and score < 70: return "D" else: return "F" students = [lloyd,alice,tyler] def get_class_average(students): results = [] for student in students: print "student: %s, srednia %s" % (student['name'],get_average(student)) results.append(get_average(student)) print results print get_average(student) return average(results)

print get_class_average(students)

InformationsquelleAutor Pas_

Dieser arbeitete für mich:

lloyd = {
  "name": "Lloyd",
  "homework": [90.0, 97.0, 75.0, 92.0],
  "quizzes":  [88.0, 40.0, 94.0],
  "tests":    [75.0, 90.0]
}
alice = {
  "name": "Alice",
  "homework": [100.0, 92.0, 98.0, 100.0],
  "quizzes":  [82.0, 83.0, 91.0],
  "tests":    [89.0, 97.0]
}
tyler = {
  "name": "Tyler",
  "homework": [0.0, 87.0, 75.0, 22.0],
  "quizzes":  [0.0, 75.0, 78.0],
  "tests":    [100.0, 100.0]
}

# Add your function below!
def average(numbers):
  total = 0.0
  total = sum(numbers)
  total = float(total) / len(numbers)
  return total

def get_average(student):
  hweight = 0.1
  qweight = 0.3
  tweight = 0.6
  homework = average(student["homework"])
  quizzes  = average(student["quizzes"])
  tests    = average(student["tests"])
  total = (homework * hweight) + (quizzes * qweight) + (tests * tweight)
  return total

def get_letter_grade(score):
  if score >= 90:
    return 'A'
  elif score < 90 and score >= 80:
    return 'B'
  elif score < 80 and score >= 70:
    return 'C'
  elif score < 70 and score >= 60:
    return 'D'
  else:
    return 'F'

def get_class_average(class_list):
  results = []
  for student in class_list:
    running = get_average(student)
    results.append(running)
  return average(results)

students = [lloyd, alice, tyler]
print "The Average for the class is:\n"
print get_class_average(students)
print
print "Which corresponds to a letter grade of:\n"
print get_letter_grade(get_class_average(students))

InformationsquelleAutor MaxBacon

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.