Ufdjrw

Is there a way to simplify this pile of if-statements? This parsing function sure works (with the right dictionaries), but it has to test 6 if-statements for each word in the input. For a 5-word sentence that would be 30 if-statements. It is also kind of hard to read.

def parse(text):
 predicate=False
 directObjectAdjective=False
 directObject=False
 preposition=False
 indirectObjectAdjective=False
 indirectObject=False
 text=text.casefold()
 text=text.split()
 for word in text:
 if not predicate:
 if word in predicateDict:
 predicate=predicateDict[word]
 continue
 if not directObjectAdjective:
 if word in adjectiveDict:
 directObjectAdjective=adjectiveDict[word]
 continue
 if not directObject:
 if word in objectDict:
 directObject=objectDict[word]
 continue
 if not preposition:
 if word in prepositionDict:
 preposition=prepositionDict[word]
 continue
 if not indirectObjectAdjective:
 if word in adjectiveDict:
 indirectObjectAdjective=adjectiveDict[word]
 continue
 if not indirectObject:
 if word in objectDict:
 indirectObject=objectDict[word]
 continue
 if not directObject and directObjectAdjective:
 directObject=directObjectAdjective
 directObjectAdjective=False
 if not indirectObject and indirectObjectAdjective:
 indirectObject=indirectObjectAdjective
 indirectObjectAdjective=False
 return [predicate,directObjectAdjective,directObject,preposition,indirectObjectAdjective,indirectObject]

Here's also a sample of a dictionary, if that's needed.

predicateDict=
"grab":"take",
"pick":"take",
"collect":"take",
"acquire":"take",
"snag":"take",
"gather":"take",
"attain":"take",
"capture":"take",
"take":"take"

This is more of a Code Review question than a Stack Overflow one. A major issue is that you have similar data that you're keeping in separate variables. If you combine your variables, then you can iterate over them.

missing_parts_of_speech = ["predicate", [...]]
dict_look_up = "predicate":predicateDict,
 [...] 
 
found_parts_of_speech = 
for word in text:
 for part in missing_parts_of_speech:
 if word in dict_look_up[part]:
 found_parts_of_speech[part] = dict_look_up[part][word]
 missing_parts_of_speech.remove(part)
 continue

I would suggest to simply use the method dict.get. This method has the optional argument default. By passing this argument you can avoid a KeyError. If the key is not present in a dictionary, the default value will be returned.

If you use the previously assigned variable as default, it will not be replaced by an arbitrary value, but the correct value. E.g., if the current word is a "predicate" the "direct object" will be replaced by the value that was already stored in the variable.

CODE

def parse(text):
 predicate = False
 directObjectAdjective = False
 directObject = False
 preposition = False
 indirectObjectAdjective = False
 indirectObject = False

 text=text.casefold()
 text=text.split()
 for word in text:
 predicate = predicateDict.get(word, predicate)
 directObjectAdjective = adjectiveDict.get(word, directObjectAdjective)
 directObject = objectDict.get(word, directObject)
 preposition = prepositionDict.get(word, preposition)
 indirectObjectAdjective = adjectiveDict.get(word, indirectObjectAdjective)
 indirectObject = objectDict.get(word, indirectObject)

 if not directObject and directObjectAdjective:
 directObject = directObjectAdjective
 directObjectAdjective = False

 if not indirectObject and indirectObjectAdjective:
 indirectObject = indirectObjectAdjective
 indirectObjectAdjective = False

 return [predicate, directObjectAdjective, directObject, preposition, indirectObjectAdjective, indirectObject]

PS: Use a little more spaces. Readers will thank you...

PPS: I have not tested this, for I do not have such dictionaries at hand.

PPPS: This will always return the last occurances of the types within the text, while your implementation will always return the first occurances.

You could map the different kinds of words (as strings) to dictionaries where to find those words, and then just check which of those have not been found yet and look them up if they are in those dicts.

needed = "predicate": predicateDict,
 "directObjectAdjective": adjectiveDict,
 "directObject": objectDict,
 "preposition": prepositionDict,
 "indirectObjectAdjective": adjectiveDict,
 "indirectObject": objectDict

for word in text:
 for kind in needed:
 if isinstance(needed[kind], dict) and word in needed[kind]:
 needed[kind] = needed[kind][word]
 continue

In the end (and in each step on the way) all the items in needed that do not have a dict as a value have been found and replaced by the value from their respective dict.

(In retrospect, it might make more sense to ue two dictionaries, or one dict and a set: One for the final value for that kind of word, and one for whether they have already been found. Would probably be a bit easier to grasp.)

I suggest that you use a new pattern to write this code instead the old one. The new pattern has 9 lines and stay 9 lines - just add more dictionaries to D. The old has already 11 lines and will grow 4 lines with every additional dictionaries to test.

aDict = "a1" : "aa1", "a2" : "aa1" 
bDict = "b1" : "bb1", "b2" : "bb2" 
text = ["a1", "b2", "a2", "b1"]
# old pattern
a = False
b = False
for word in text:
 if not a:
 if word in aDict:
 a = aDict[word]
 continue
 if not b:
 if word in bDict:
 b = bDict[word]
 continue
print(a, b)
# new pattern
D = [ aDict, bDict]
A = [ False for _ in D]
for word in text:
 for i, a in enumerate(A):
 if not a:
 if word in D[i]:
 A[i] = D[i][word]
 continue
print(A)