I'm trying to modify a trivia program found in a book as part of a tutorial; I need to save the name and score of the player using a pickled dictionary. I've already created the dat file using a separate program, to avoid reading from a file that doesn't exist.
This is the code for the trivia program.
#Trivia Challenge
#Trivia game that reads a plain text file
import sys
def open_file(file_name, mode):
"""Open a file"""
try:
the_file = open(file_name, mode)
except IOError as e:
print("Unable to open the file", file_name, "Ending program.\n", e)
input("\n\nPress the enter key to exit.")
sys.exit()
else:
return the_file
def next_line(the_file):
"""Return next line from the trivia file, formatted."""
line = the_file.readline()
line = line.replace("/", "\n")
return line
def next_block(the_file):
"""Return the next block of data from the triva file."""
category = next_line(the_file)
question = next_line(the_file)
answers = []
for i in range(4):
answers.append(next_line(the_file))
correct = next_line(the_file)
if correct:
correct = correct[0]
explanation = next_line(the_file)
value = next_line(the_file)
return category, question, answers, correct, explanation, value
def welcome(title):
"""Welcome the player and get his or her name."""
print("\t\tWelcome to Trivia Challenge!\n")
print("\t\t", title, "\n")
def saving(player_name):
import pickle
f = open("trivia_scores.dat", "rb+")
highscores = pickle.load(f)
if player_name in highscores and score > highscores[player_name]:
highscores[player_name] = score
pickle.dump(highscores, f)
elif player_name not in highscores:
highscores[player_name] = score
pickle.dump(highscores, f)
print("The current high scores are as follows:")
print(highscores)
f.close()
def main():
trivia_file = open_file("trivia.txt", "r")
title = next_line(trivia_file)
welcome(title)
score = 0
#Get the first block
category, question, answers, correct, explanation, value = next_block(trivia_file)
while category:
#Ask a question
print(category)
print(question)
for i in range(4):
print("\t", i + 1, "-", answers[i])
#Get answer
answer = input("What is your answer?: ")
#Check answer
if answer == correct:
print("\nRight!", end=" ")
score += int(value)
else:
print("\nWrong!", end=" ")
print(explanation)
print("Score:", score, "\n\n")
#Get the next block
category, question, answers, correct, explanation, value = next_block(trivia_file)
trivia_file.close()
print("That was the last question!")
print("Your final score is", score)
return score
player_name = input("First, enter your name: ")
main()
saving(player_name)
input("\n\nPress the enter key to exit.")
The eponymous error occurs at this point:
def saving(player_name):
import pickle
f = open("trivia_scores.dat", "rb+")
highscores = pickle.load(f)
When the questions end, the program attempts to run the "saving" module, which (In theory) opens the trivia_scores.dat file, loads the highscores dictionary, checks to see if the player's name is in the dictionary, and if their current score is higher than the one in the file, it overwrites it.
But for some reason, when the program attempts to load the highscores dictionary, instead I get this error message.
EOFError: Ran out of input
I have never seen this error before. From some cursory googling, I got the impression that it has something to do with the program trying to read from an empty file. But that made no sense to me, since I specifically created a dat file using a different program to prevent that from happening: trivia_scores.dat is NOT an empty file. I even read from it with Python Shell to make sure.
What does this error mean, and why won't Python load the dat file?
Context: The book I'm reading from is Python for the Absolute Beginner, by Michael Dawson. This program and the challenge I'm trying to complete come from chapter 7. The program was running fine before I added the saving module.
Probably the original trivia_scores.dat file you wrote got corrupt (maybe you didn't call close() on it?). You should try creating a new file and adding a pre-populated dictionary to this file. Then try reading from this new file.
Related
hi guys i made a script for a game in python (the game is written in python too) that logs all users name that joins in game and saves them in a text file so:
def onPlayerJoin(self, player):
'Called for new players joined'
nick= player.getName(full=True).encode('utf-8')
#append
f = open(r"ALLIDS.txt", "a+")
f.seek(0)
data = f.read(100)
if len(data) > 0 :
f.write("\n")
f.write(str(nick)+": ")
IT DOESN'T MAKE ANY BUGz AND IT WORKS WELL
OUTPUT OF TEXT FILE
Linux31748:
JunkieSam:
Linux31748:
JunkieSam:
StratexFsk:
Linux31748:
StratexFsk:
Linux31748:
DrugrichSam:
SapoBully:
Stop Using /GP:
JunkieSam:
it prints the same player name more times so i want to fix that but i don't know how
thanks in advance for the replies , love this community every day more.
You can check if player already written(also I simplified some of the syntax):
def log_player(player_nick, file=r"ALLIDS.txt"):
with open(file, "a+") as f:
f.seek(0)
# TODO: improve algorithm, this is just showing the concept
if player_nick in f.read():
return
f.write(f'{player_nick}\n')
def onPlayerJoin(self, player):
'Called for new players joined'
nick = player.getName(full=True).encode('utf-8')
log_player(nick)
Can you have a try?
Before you write a player's name, you should check whether the name is existed.
Check code:
def is_name_existed(name):
with open(r"test.txt", "r") as f:
lines = f.readlines()
for line in lines:
if line == "{}: \n".format(name) or line == "{}: ".format(name):
return True
return False
My task is to make a quiz using python, with questions being stored in an external file. However, I can not figure out how to get my questions to randomize and only display 10 at a time out of the 20 possible
I have tried using import random however the syntax random.shuffle(question) does not seem to be valid. I am not sure what to do now.
The question.txt file is laid out as:
Category
Question
Answer
Answer
Answer
Answer
Correct Answer
Explanation
My code:
#allows program to know how file should be read
def open_file(file_name, mode):
"""Open a file."""
try:
the_file = open(file_name, mode)
except IOError as e:
print("Unable to open the file", file_name, "Ending program.\n", e)
input("\n\nPress the enter key to exit.")
sys.exit()
else:
return the_file
def next_line(the_file):
"""Return next line from the trivia file, formatted."""
line = the_file.readline()
line = line.replace("/", "\n")
return line
#defines block of data
def next_block(the_file):
"""Return the next block of data from the trivia file."""
category = next_line(the_file)
question = next_line(the_file)
answers = []
for i in range(4):
answers.append(next_line(the_file))
correct = next_line(the_file)
if correct:
correct = correct[0]
explanation = next_line(the_file)
time.sleep(1.5)
#beginning of quiz questions
def main():
trivia_file = open_file("trivia.txt", "r")
title = next_line(trivia_file)
welcome(title)
score = 0
# get first block
category, question, answers, correct, explanation = next_block(trivia_file)
while category:
# ask a question
print(category)
print(question)
for i in range(4):
print("\t", i + 1, "-", answers[i])
# get answer
answer = input("What's your answer?: ")
# check answer
if answer == correct:
print("\nCorrect!", end=" ")
score += 1
else:
print("\nWrong.", end=" ")
print(explanation)
print("Score:", score, "\n\n")
# get next block
category, question, answers, correct, explanation = next_block(trivia_file)
trivia_file.close()
print("That was the last question!")
print("Your final score is", score)
main()
That is most of the code associated with the program. I will be very grateful for any support available.
You can read the file and group its contents into blocks of eight. To generate unique random questions, you can use random.shuffle and then list slicing to create the groups of questions. Also, it is cleaner to use a collections.namedtuple to form the attributes of the question for use later:
import random, collections
data = [i.strip('\n') for i in open('filename.txt')]
questions = [data[i:i+8] for i in range(0, len(data), 8)]
random.shuffle(questions)
question = collections.namedtuple('question', ['category', 'question', 'answers', 'correct', 'explanation'])
final_questions = [question(*i[:2], i[2:6], *i[6:]) for i in questions]
Now, to create the groups of 10:
group_questions = [final_questions[i:i+10] for i in range(0, len(final_questions), 10)]
The result will be a list of lists containing the namedtuple objects:
[[question(category='Category', question='Question', answers=['Answer', 'Answer', 'Answer', 'Answer'], correct='Correct Answer', explanation='Explanation ')]]
To get the desired values from each namedtuple, you can lookup the attributes:
category, question = question.category, question.question
Etc.
How do I implement a simple code that will only save the student's latest 3 scores? If the test is repeated later, the old score should be replaced.
Thank you.
This is the code that asks the user the questions and saves the results in the txt. files.
import random
import math
import operator as op
correct_answers = 0
def test():
num1 = random.randint(1, 10)
num2 = random.randint(1, 10)
ops = {
'+': op.add,
'-': op.sub,
'*': op.mul,
}
keys = list(ops.keys())
rand_key = random.choice(keys)
operation = ops[rand_key]
correct_result = operation(num1, num2)
print ("What is {} {} {}?".format(num1, rand_key, num2))
user_answer= int(input("Your answer: "))
if user_answer != correct_result:
print ("Incorrect. The right answer is {}".format(correct_result))
return False
else:
print("Correct!")
return True
username = input("What is your name? ")
print("Hi {}! Welcome to the Arithmetic quiz...".format(username))
class_name = input("Are you in class 1, 2 or 3? ")
correct_answers = 0
num_questions = 10
for i in range(num_questions):
if test():
correct_answers +=1
print("{}: You got {}/{} questions correct.".format(
username,
correct_answers,
num_questions,
))
class_name = class_name + ".txt" #creates a txt file called the class that the user entered earlier on in the quiz.
file = open(class_name , 'a') #These few lines open and then write the username and the marks of the student into the txt file.
name = (username)
file.write(str(username + " : " ))
file.write(str(correct_answers))
file.write('\n') #This puts each different entry on a different line.
file.close() #This closes the file once the infrmation has been written.
A much better solution would be to store the data in a different format that made everything easy. For example, if you used a shelve database that mapped each username to a deque of answers, the whole thing would be this simple:
with shelve.open(class_name) as db:
answers = db.get(username, collections.deque(maxlen=3))
answers.append(correct_answers)
db[username] = answers
But if you can't change the data format, and you need to just append new lines to the end of a human-readable text file, then the only want to find out if there are already 3 answers is to read through every line in the file to see how many are already there. For example:
past_answers = []
with open(class_name) as f:
for i, line in enumerate(f):
# rsplit(…,1) instead of split so users who call
# themselves 'I Rock : 99999' can't cheat the system
name, answers = line.rsplit(' : ', 1)
if name == username:
past_answers.append(i)
And if there were 3 past answers, you have to rewrite the file, skipping line #i. This is the really fun part; text files aren't random-access-editable, so the best you can do is either read it all into memory and write it back out, or copy it all to a temporary file and move it over the original. Like this:
excess_answers = set(past_answers[:-2])
if excess_answers:
with open(class_name) as fin, tempfile.NamedTemporaryFile() as fout:
for i, line in enumerate(fin):
if i not in excess_answers:
fout.write(line)
os.replace(fout.name, fin)
That part is untested. And it requires Python 3.3+; if you have an earlier version and are on Mac or Linux you can just use os.rename instead of replace, but if you're on Windows… you need to do some research, because it's ugly and no fun.
And now, you can finally just append the new answer, as you're already doing.
I am very new to Python and what I am trying to achieve is to pickle a dictionary and then use some form of loop (apologies if I have the terminology incorrect!) to print all the scores in the file.
I am using Python 3.3.3 and here is my attempt, the user enters a name and a score which is first saved to a file and then I try to print it. However I am not able to print the scores.
import pickle
# store the scores in a pickled file
def save_scores(player, score):
f = open("high_score.dat", "ab")
d = {player:score}
pickle.dump(d, f)
f.close
# print all the scores from the file
def print_scores():
# this is the part that I can't get to work!
with open("high_score.dat", "r") as f:
try:
for player, score in pickle.load(f):
print("Player: ", player, " scored : ", score)
except EOFError:
pass
f.close
def main():
player_name = input("Enter a name: ")
player_score = input("Enter a score: ")
save_scores(player = player_name, score = player_score)
print_scores()
main()
input("\nPress the Enter key to exit")
I have Google'd and searched Stackoverflow for similar problems but I must be using the wrong terms as I haven't found a solution.
Thanks in advance.
pickle.load(f) will return a dictionary. If you iterate the dictionary, it yields keys, not key-values pairs.
To yield key-value paris, use items() method (use iteritems() method if you use Python 2.x):
for player, score in pickle.load(f).items():
print("Player: ", k, " scored : ", v)
To get multiple dictionaries out, you need to loop:
with open("high_score.dat", "r") as f:
try:
while True:
for player, score in pickle.load(f).items():
# print("Player: ", k, " scored : ", v) # k, v - typo
print("Player: ", player, " scored : ", score)
except EOFError:
pass
BTW, if you use with statement, you don't need to close the file yourself.
# f.close # This line is not necessary. BTW, the function call is missing `()`
pickle.load will return your dictionary ({player:score})
this code:
for player, score in pickle.load(f):
will try to unpack the returned value as a tuple.
Also, since you ignore the exception it will be hard to tell what went wrong.
I've done a few fixes to make your code work under Python 2 (no Python 3 is available, sorry). Several places were changed. Here it is with some notes:
#!/bin/python2
import pickle
# store the scores in a pickled file
def save_scores(player, score):
f = open("high_score.dat", "wb") # "wb" mode instead of "ab" since there is no obvious way to split pickled objects (surely you can make it, but it seems a bit hard subtask for such task)
d = {player:score}
pickle.dump(d, f)
f.close() # f.close is a method; to call it you should write f.close()
# print all the scores from the file
def print_scores():
# this is the part that I can't get to work!
with open("high_score.dat", "rb") as f: # "rb" mode instead of "r" since if you write in binary mode than you should read in binary mode
try:
scores = pickle.load(f)
for player, score in scores.iteritems(): # Iterate through dict like this in Python 2
print("Player: ", player, " scored : ", score) # player instead of k and score instead of v variables
except EOFError:
pass
# f.close -- 1. close is a method so use f.close(); 2. No need to close file as it is already closed after exiting `where` expression.
def main():
player_name = raw_input("Enter a name: ") # raw_input instead of input - Python 2 vs 3 specific
player_score = raw_input("Enter a score: ")
save_scores(player = player_name, score = player_score)
print_scores()
main()
raw_input("\nPress the Enter key to exit")
I am trying to create a quiz. In a text file, I have blocks consisting of subject, question, answer and an empty space (on that order). Each line represents one of those items:
Histology What do megakaryocytes originate? Platelets.
Physiology Which physiological process does not occur in Glanzmann's
thrombasthenia? Platelet aggregation.
Histology When in the erythropoietic process does the cell lose its
nucleus? When in the ortochromatophilic stage.
Physiology Which phase of hemostasis features the action of
coagulation factors? Secondary hemostasis.
Physiology What characterizes hemarthrosis? Blood in joint spaces.
Physiology Beyond being in circulation, a portion of platelets is also
stored. Where? The spleen.
Physiology Which of the platelet zones includes the submembranous
region? Peripheral zone.
I have successfully coded a program that shows the user the question and then reveals the answer when the user says so. However, I wanted to display the questions randomly. What I used to display them sequentially was inspired by Michael Dawson's book "Python programming for the absolute beginner". I followed the structure the author showed closely and it works. The code is:
#File opening function. Receives a file name, a mode and returns the opened file.
def open_file(file_name, mode):
try:
file = open(file_name, mode)
except:
print("An error has ocurred. Please make sure that the file is in the correct location.")
input("Press enter to exit.")
sys.exit()
else:
return file
#Next line function. Receives a file and returns the read line.
def next_line(file):
line = file.readline()
line = line.replace("/", "\n")
return line
#Next block function. Receives a file and returns the next block (set of three lines comprising subject, question and answer.
def next_block(file):
subject = next_line(file)
question = next_line(file)
answer = next_line(file)
empty = next_line(file)
return subject, question, answer, empty
#Welcome function. Introduces the user into the quizz, explaining its mechanics.
def welcome():
print("""
Welcome to PITAA (Pain In The Ass Asker)!
PITAA will ask you random questions. You can then tell it to
reveal the correct answer. It does not evaluate your choice,
so you must see how many you got right by yourself.
""")
def main():
welcome()
file = open_file("quizz.txt", "r")
store = open_file("store.bat", "w")
subject, question, answer, empty = next_block(file)
while subject:
print("\n")
print("Subject: ", subject)
print("Question: ", question)
input("Press enter to reveal answer")
print("Answer: ", answer)
print("\n")
subject, question, answer, empty = next_block(file)
file.close()
print("\nQuizz over! Have a nice day!")
#Running the program
main()
input("Press the enter key to exit.")
How can I group blocks of 4 lines and then randomize them? It would be even better if I could filter them by subject and question.
import random
def open_file(file_name, mode):
try:
file = open(file_name, mode)
except:
print("An error has ocurred. Please make sure that the file is in the correct location.")
input("Press enter to exit.")
sys.exit()
else:
return file
def replace_linebreaks(value):
value.replace("/", "\n")
def main():
welcome()
# store = open_file("store.bat", "w")
file = open_file("quizz.txt", "r")
questions = file.read().split('\n\n') # if UNIX line endings
file.close()
random.shuffle(questions)
for question in questions.splitlines():
subject, question, answer, empty = map(replace_linebreaks, question)
print("\n")
print("Subject: ", subject)
print("Question: ", question)
input("Press enter to reveal answer")
print("Answer: ", answer)
print("\n")
subject, question, answer, empty = next_block(file)
print("\nQuizz over! Have a nice day!")
To organize I would make a simple class or use dicts. For example:
Class implementation
class Quiz():
def __init__(self, question, answer, subject):
self.question = question
self.answer = answer
self.subject = subject
You can make an instance of those questions and create a subject for each of them, accessing them based on their attribute. As such:
q = Quiz("Question 1", "Answer 1", "Chemistry")
print(q.subject)
>>> Chemistry
You can append the new instance to a list and just randomize the list as such
import random #Look up the python docs for this as there are several methods to use
new_list = []
new_list.append(q)
random.choice(new_list) #returns a random object in the list
You can also do this with nested dictionaries and drill down based on the 'subject'
new_dict = {'subject': {'question': 'this is the question',
'answer': 'This is the answer'}}
But I feel its easier to organize by creating your own class.
Hope that helps a little...