Home Page > > Details

Ghostwriter data Programming,Help With Python Programming,Python Course ProgrammingGhostwriter Ghostwriter Python Programming|Debug Matlab Programming

Assignment: Nested list and file
Writing a translation program that includes a
learning dictionary
You're going to write a program that lets the user enter a sentence and translates it to another
language. The program will learn. When it first comes across a word it doesn't have in its
dictionary, it will ask you, then it will remember your reply, so it doesn't have to ask you about
that word again.
Here's a sample run of the program
Initially the dictionary is empty, so it has to ask about every word, but once it's seen a word, it
doesn't ask for that one again. It quite quickly to translate simple sentences.
The ? command displays the list of words and their translations.
Eng: > hello
How do I translate "hello":
ciao
>>> Ciao.
Eng: > Is that your house
How do I translate "is": e'
How do I translate "that": quello
How do I translate "your": tua
How do I translate "house": casa
>>> E' quello tua casa.
Eng: > is that your car
How do I translate "car": macchina
>>> E' quello tua macchina.
Eng: > the cat is red
How do I translate "the": il
How do I translate "cat": gatto
How do I translate "red": rosso
>>> Il gatto e' rosso.
Eng: > that house is blue
How do I translate "blue": blu
>>> Quello casa e' blu.
Eng: > ?
***** Known words *****
hello ciao
is e'
that quello
your tua
house casa
Don't worry about the Italian words, there's a very simple dictionary (four words and their
translations) to get you started, but you can put anything you like in your dictionary. The wordby-word
translation is inherently limited, but it's fun to play with. We'll build the program in nice
easy stages.
Step 1 - display the dictionary
Whenever we create a data structure is very useful be be able to display, to make sure that it
contains what we expect.
The format of the dictionary
The dictionary is a list of lists, where the first item in a sublist is the English word in lowercase,
and the second word is the other language. I'll use Italian, you can use whichever language you
like. Try Chinese, as Python 3 can handle Unicode which means it can store any Chinese
characters you enter.
Define a function displayDictionary() that outputs the list of known
words
Calling this function:
car macchina
the il
cat gatto
red rosso
blue blu
Eng: > my brother is tall
How do I translate "my": mio
How do I translate "brother": fratello
How do I translate "tall": alto
>>> Mio fratello e' alto.
Eng: > my father is tall
How do I translate "father": padre
>>> Mio padre e' alto.
Eng: > The cat is blue and is at your house.
How do I translate "and": e
How do I translate "at": a
>>> Il gatto e' blu e e' a tua casa.
Eng: > what colour is the cat
How do I translate "what": che
How do I translate "colour": colore
>>> Che colore e' il gatto.
Eng: > What colour is your house and your father
Che colore e' tua casa e tua padre.
dictionary = [ ['the', 'la'], ['big', 'grande'], ['house', 'casa'] ]
gives something like this:
IMPORTANT: you must extract the element of the sublist and display them separately. Simply
displaying sublists like this IS NOT SUFFICIENT
Step 2 - a function to look up a word
Now that you can display the dictionary, create a function that can look up an English word, and
return its translation, or None if the translation isn't in the dictionary.
It's called like this (You can define the function name as you like.)
Step 3 - allow the user to enter sentences and
translate them.
It's nice to be able to see what words are in the dictionary, so if the sentence is just ? display the
dictionary
dictionary = []
displayDictionary()
dictionary = [ ['the', 'la'], ['big', 'grande'], ['house', 'casa'] ]
displayDictionary()
*** The dictionary is empty ***
*** Known words ****
the la
big grande
house casa
*** Known words ****
['the', 'la']
['big', 'grande']
['house', 'casa']
def lookup(word):
#returns either the translation of word, or None if the translation isn't
known
w = translateFromEnglish('house')
print('Translation of', 'house', 'is', w)
w = translateFromEnglish('dog')
print('Translation of', 'dog', 'is', w)
Translation of house is casa
Translation of dog is None
def main():
If the dictionary contains
A run of your program might look like that below.
Note the None in the last line as blue isn't in the dictionary.
Step 4 - ask the user and add unknown words to the
dictionary.
while True:
reply = input("Eng: > ")
if reply == '?':
# DISPLAY THE DICTIONARY AND GET THE NEXT WORD
# GET RID OF PUNCTUATION ( . , ? )
# GET RID OF BLANKS AT THE START AND END OF THE LINE
# CONVERT THE REPLY INTO A LIST called /WORDS/
# TRANSLATE EACH WORD AND CREATE A NEW LIST
# you could do it like this:
translatedReply = []
for word in words:
translation = lookup(word)
translatedReply.append(translation)
# TURN THE LIST /translatedReply/ BACK INTO A STRING, with spaces between
the words
# Capitalise the first word (or first character of the string)
# DISPLAY THE TRANSLATED SENTENCE
# OPTIONAL NICE TOUCH:
# IF THE FIRST WORD WAS ONE OF what, where, why, how, is
# ADD A *?* TO MAKE THE TRANSLATION A QUESTION
main()
dictionary = [ ['the', 'la'], ['red', 'rosso'], ['is', "e'"], ['table',
'tavola'] ]
Eng: > The table is red
>>> La tavola e' rosso.
Eng: > ?
**** Known words *****
the la
cat tavola
is e'
red rosso
Eng: > The table is blue La tavola e' None
Currently, lookup(word) returns either a translation, or None is the word isn't known.
Modify lookup(), so that if a word isn't in the dictionary, it asks the user for the translation, and
then adds a new entry to the dictionary.
Then the output on coming across an unknown word will be like this:
Step 5 - load a file as the initial dictionary
You'll rapidly get annoyed retyping words into the dictionary each time you start your program.
Write a function that tries to load the file dictionary.txt as the initial dictionary list.
The format of the dictionary file is:
all words are lower case
the English and translation are separated by a slash (/)
An example dictionary.txt file
Note:
1. If the dictionary exists, the function should ADD (not replace) the current contents of the
dictionary list
2. If the dictionary file doesn't exist, no error occurs and the current original dictionary list is
unchanged.
3. If any other run-time error occurs (e.g. a missing '/' in a line), abort the program.
Call this function before asking the user for words to translate.
Step 6 - add commands to *save the dictionary and
*quit
Add some extra commands to the input loop, so the following are recognised:
Eng: > The table is red
>>> La tavola e' rosso.
Eng: > The table is blue
How do i translate 'blue': blu
>>> La tavola e' blu.
Eng: > ?
**** Known words *****
the la
cat tavola
is e'
red rosso
blue blu
the/la
cat/tavola
is/e'
red/rosso
blue/blu
Command Effect
? Display the dictionary
*save Save the current dictionary to a file called dictionary.txt" overwriting any
current version
*quit Quit the program. If the dictionary has been modified since it was last saved
(use a global saved), offer to save
The *quit command doesn't just exit the program, it checks to see if the dictionary needs saving.
In other words, has the dictionary been added to since the last save?
If there are new words in the dictionary, you could:
automatically save the dictionary to the dictionary file and quit, OR
Tell the user Unsaved entries in the dictionary.Save (y/n): and if they answer affirmatively (y),
save and then quit.
What and how to submit How:
What: Submit your Python program, each named with.py extension.
Do not submit Word documents (.doc or .docx) or .zip files.
Check that:
all programs should display your name,ID number and your classname when starting.
that your files have a .py extension

Contact Us - Email:99515681@qq.com    WeChat:codinghelp
© 2014 www.asgnhelp.com
Programming Assignment Help!