将一个列表中的字符串与另一个列表中的整数“配对”的最简单方法是什么（在python中）？

Question

I'm working on a school project which has to store the names of people and their respective score on a test in a list so that I can manipulate it to find averages as well as printing out each persons score with their name. Relatively new to Python so any help is appreciated :)

Answer 1

I would recommend using a dictionary. This pairs keys (the name of students) to values (the score on a test). Here is an example below that gets you the output that you would want.

import math

student_scores = {}

student_scores['Rick'] = 89
student_scores['Pat'] = 79
student_scores['Larry'] = 82
score_list = []

for name, score in student_scores.items():
         score_list.append(score)
         print(name.title() + "'s score was: " + str(score) + '%')

sum_scores = sum(score_list)
division_scores = len(score_list)
average_score = sum_scores / division_scores
print('The average score was {0:.2f}%'.format(average_score))

1. I created an empty dictionary that you will use to add student names and scores to a list. So in the dictionary (student_scores) The student name 'Rick' will be a key, and the score 89 will the value. I do this for 2 additional students, pairing their name up with the score that they received.

2. I create an empty list called score_list. You'll use this list later to add he sum of all scores, and divide by the number of total scores to get an average score for your test.

3. We start a for loop that iterates over each key and value in your dictionary. For each score, we append it to the empty score list. For each name and score, we print a message showing what the student got on the test.

4. Now that we have appended the scores to the dictionary we can use the sum method to get the sum of all scores in your score list. We put it in a variable called sum_scores. We also get the number of scores in your list by finding the length of the list (which will be 3 in this case since I put 3 scores in it). We will store that in a variable called division_scores (since I am dividing the sum of all scores by the number of scores recorded). We create a variable called average_score which is the result of the sum of scores divided by the total number of observations.

5. We then print what the average score was using the .format() method. We just format the average score so that you get it to extend two decimal places {0:.2f}%.

Your output is as follows:

Rick's score was: 89%
Pat's score was: 79%
Larry's score was: 82%
The average score was 83.33%

Answer 2

The above answer is a great data structure for pairing strings. It'll set you on the right track for enumerating scores, averages, etc in simple cases.

Another way to store relationships is with classes (or tuples, at the bottom!) There's a rough sketch of an OOP approach below.

The most important parts are

1. The properties of the ExamAttempt class store the information (names, scores)

2. In the Exam.record_attempt method, a new ExamAttempt object is created from the ExamAttempt class and added to the list of attempts on the Exam object.

From here, you could easily add other features. You'd probably want to model a Question and Answer , and maybe a Student object too, if you're going all out. If you store questions and answers, as well as which answer each student selected, you can start doing things like throwing out questions, grading on a curve, discovering questions to throw out, etc. The OOP approach makes it easier to extend functionality like plotting all kinds of fancy graphs, export to CSV or Excel, and so on.

Not all of the code below is necessary.. it can definitely be simplified a little, or reimagined entirely, but hopefully this should give you enough to start looking down that path. Even if it seems complicated now, it's not that bad, and it's what you'll want to be doing eventually (with Python, anyway!)

class ExamAttempt:
    def __init__(self, id, name, correct, total):
        self.id = id
        self.name = name
        self.correct = correct
        self.total = total
        self.score = (self.correct / float(self.total))

    def __repr__(self):
        return "<ExamAttempt: Id={}, Student={}, Score={}>".format(self.id, self.name, self.score)

class Exam:
    def __init__(self, name, questions):
        self.name = name
        self.attempts = []
        self.questions = questions
        self.num_questions = len(questions)

    def __str__(self):
        return "<Exam ({})>".format(self.name)

    def load(self, filename):
        pass

    def saveAttemptsToFile(self, filename):
        pass

    def record_attempt(self, student_name, num_correct):
        id = len(self.attempts) + 1
        self.attempts.append(
            ExamAttempt(id, student_name, num_correct, self.num_questions))

    def get_student_attempt(self, student_name):
        for att in self.attempts:
            if student_name == att.name:
                return att

    def get_average_score(self):
        return "homework" 

    def get_results_by_score(self):
        return sorted(self.attempts, key=lambda x: x.score, reverse=True)

    def get_attempts_by_name(self):
        return sorted(self.attempts, key=lambda x: x.name)

if __name__ == '__main__':
    questions = ['Question?' for i in range(100)] # Generate 100 "questions" = 100%
    exam = Exam('Programming 101', questions)
    data = [('Rick', 89), ('Pat', 79), ('Larry', 82)]

    for name, correct in data:
        exam.record_attempt(name, correct)

    for attempt in exam.get_results_by_score():
        print("{} scored {}".format(attempt.name, attempt.score))