TLDR

Instead of

my_dict[word] = count

You may want to use

my_dict[word] = my_dict[word] + [count]

This is assuming:

• count is the line(s) that the word was found in
• you want each key to have a list of count denoting which lines the word was found on

Explanation

To assign values to a dict you assign to a specific key in the same way that you might assign a value to an index of a list. You did that in this line here:

# assign value "count" to dict "my_dict" at key "word"
my_dict[word] = count

So you're already partway there! What we want now is to add to a preexisting value. Remembering that in Python assignment replaces the value of a variable, then we want to be careful to assign with our updated value. With int variables we do this by taking the previous value and adding to it (ex a = a + 2), likewise to add to a list in a dict key we take the previous value and assign that plus what was added to it.

Example

my_dict = {}                       # {}
my_dict["a"] = [1]                 # {"a": [1]}
my_dict["a"] = my_dict["a"] + [2]  # {"a": [1, 2]}

This works because my_dict["a"] evaluates to it's current value (a list), and you can then append another list to that list to create a list with the values of both lists. Like

list_a = [1, 2]
list_b = [3, 4]
list_a = list_a + list_b  # == [1, 2, 3, 4]

Cool Tip

Since the operation of adding to an existing value is common in Python, it actually has a shorthand for this pattern.

Instead of

a = a + 2

You also have the option to write the shorthand of that which is

a += 2

Simply use item assignment like this

d['feline']['cat'] = 55

For your case, you might want to do,

d['feline'][fp] = int(apa)

When you say,

d['feline'] = {fp : int(apa)}

You are replacing whatever is already there in d['feline'] with a new dictionary ({fp : int(apa)}), instead you can add new key and corresponding value like I have shown above.

Just switch the order:

z = dict(d2.items() + d1.items())

By the way, you may also be interested in the potentially faster update method.

In Python 3, you have to cast the view objects to lists first:

z = dict(list(d2.items()) + list(d1.items())) 

If you want to special-case empty strings, you can do the following:

def mergeDictsOverwriteEmpty(d1, d2):
    res = d2.copy()
    for k,v in d2.items():
        if k not in d1 or d1[k] == '':
            res[k] = v
    return res

You can subclass dict and in particular, override the __setitem__ method.

This sounds like what you want:

class SpecialDict(dict):
    def __setitem__(self, key, value):
        if not key in self:
            super(SpecialDict, self).__setitem__(key, value)
        else:
            raise Exception("Cannot overwrite key!") # You can make your own type here if needed


x = SpecialDict()


x['a'] = 1
x['b'] = 2
x['a'] = 3  #raises Exception

You need to append these names to a list. The following is a naive example and might break.

for name in file:              
    if name in list:
        if dict.has_key(param):
            dict[param].append(name)
        else:
            dict[param] = [name]

Or if you want to be a little cleaner, you can use collections.defaultdict. This is the pythonic way if you ask me.

d = collections.defaultdict(list)
for name in file:
    if name in lst: # previously overwrote list()
        d[param].append(name)

Please do not overwrite the builtin dict() or list() function with your own variable.

You need make sure each value of the new dictionary is a list. Instead of

new_dict[item] = k  # the value is a string

you need

new_dict[item] = [k]  # the value is a list with the item

Then you can append onto that list. Full code:

latin_dic ={'apple': ['malum', 'pomum', 'popula'], 'fruit': ['baca', 'bacca', 'popum'], 'punishment': ['malum', 'multa']}
new_dict={}
for k,v in latin_dic.items():
    for item in v:
        if item in new_dict:
            new_dict[item].append(k)
        else:
            new_dict[item] = [k]
for k,v in sorted(new_dict.items()):
    print(k, '-', v)

You'll have to decide how many levels of nested dict you want to merge, but it's very doable:

dict_a = {"2": {"2": 0, "12": "94960", "25": "61026"}, 
          "229": {"101": "29043", "106": "25298", "110": "48283", "112": "16219", "126": "35669", "147": "37675"}}

dict_b = {"1": {"1": 0, "2": "84543", "3": "34854", "5": "123439"}, 
          "229": {"2": "71355", "12": "24751", "25": "33600", "229": 0}}

for k, v in dict_b.items():
    if k in dict_a:
        for sub_k, sub_v in v.items():
            if sub_k in dict_a[k]: #decide what to do when there's a conflict at this level
                print("conflict: keeping value from dict_a")
            else:
                dict_a[k][sub_k] = sub_v #add missing item to dict_a[k]
    else:
        dict_a[k] = v #add missing item to dict_a

print(dict_a)

extending the problem to merge an arbitrary number of levels is a simple problem of recursion (though you have to make sure your data structure is consistent, and make decisions on how to resolve conflicts in data):

def recursive_merge(dict_a, dict_b, levels):
    for k, v in dict_b.items():
        if k in dict_a:
            if levels > 1 and isinstance(v, dict) and isinstance(dict_a[k], dict):
                recursive_merge(dict_a[k], dict_b[k], levels - 1)
            else:
                pass #keep the value from dict_a
        else:
            dict_a[k] = v
    return dict_a

print(recursive_merge(dict_a, dict_b, 2))