How can I delete the same columns(same indexed elements) from a python dictionary?

Question

Let's say I have this:

d = {'a': [1, 2, 3, 4], 'b': ['10', '', '30', '40']}

And I'd like this:

d = {'a': [1, 3, 4], 'b': ['10', '30', '40']}

If I see an empty element in b, I'd like to delete it, which is d["b"][1] and the same time delete d["a"][1] at the same index.

EDIT: Forget to mention, that you must not change the order of any elements.

Answer 1

Here's an idea. Looks like you're treating your dictionary as a data frame, since you're "connecting" your lists by index.

So why not just use a library and do your operations in a clean way and efficently?

import pandas as pd
df = pd.DataFrame(d)

Yields

   a   b
0  1  10
1  2    
2  3  30
3  4  40

Then

df[~df.eq('').any(1)]

   a   b
0  1  10
2  3  30
3  4  40

After all manipulation, if you need your dictionary back:

df.to_dict('list')

{'a': [1, 3, 4], 'b': ['10', '30', '40']}

Answer 2

A general solution:

• find which indices are blanks and put them in an unique list, sorted in reversed order
• loop in the values and remove the indices

The decreasing order ensures that if there are several blanks the proper elements are removed.

d = {'a': [1, 2, 3, 4], 'b': ['10', '', '30', '40']}

empty_indexes = sorted({i for v in d.values() for i,x in enumerate(v) if not x},reverse=True)

for v in d.values():
    for i in empty_indexes:
        try:
            v.pop(i)
        except IndexError:
            pass

A oneliner (inspired by pault in comments):

dict(zip(d,[list(y) for y in zip(*(x for x in zip(*d.values()) if all(i!="" for i in x)))]))

decrypting this:

• the inner zip transposes the values.
• a generator comprehension filters the rows where all elements are non-empty (if all(...)
• the middle zip transposes back into the original orientation
• zipping keys & values rebuilds the dictionary. There's no order issue as keys are guaranteed to be ordered the same as values, no matter the version of python.

The oneliner is hard to read, and can be decomposed in loops. It doesn't require sort+unicity of the indices. In fact, it doesn't need indices at all.

One-liner free:

values = []  # init list of values
for y in zip(*d.values()):   # loop on assembled values
    if all(i != "" for i in y):  # filter out rows which contain empty strings
        values.append(y)

# transpose back / convert to list (since zip yields tuples)
values = [list(x) for x in zip(*values)]

# rebuild dictionary. Order of d and values is the same
d = dict(zip(d,values))

Answer 3

As a general solution, assuming each list is of the same size, you can use:

def drop_empty(d, key):
    '''
    Drops values from all lists in the dictionary `d` at the
    indices of the list given by `key` that are blank strings.
    '''
    indices = [i for i, v in enumerate(d.get('b')) if v=='']
    for v in d.values():
        for ix in reversed(indices):
            v.pop(ix)
    return d

# test case, drops indices 1 and 4:
d = {'a': [1, 2, 3, 4, 5], 'b': ['10', '', '30', '40', ''], 'c': [0, 0, 1, 1, 2]}

drop_empty(d, 'b')
# returns:
{'a': [1, 3, 4], 'b': ['10', '30', '40'], 'c': [0, 1, 1]}

Answer 4

d = {'a': [1, 2, 3, 4], 'b': ['10', '', '30', '40']}

bad_inds = [ind for ind in range(len(d['a'])) if not d['a'][ind] or not d['b'][ind]]

for ind in bad_inds:
    for value in d.values():
        del value[ind]

output:

d

>>> {'a': [1, 3, 4], 'b': ['10', '30', '40']}

Answer 5

you can first obtain all good indices and then filter your values base on good indices:

from operator import itemgetter

good_indices = [i for i, v in enumerate(zip(*d.values())) if all(v)]
d = {k : [*itemgetter(*good_indices)(v)] for k, v in d.items()}

print(d)

output:

{'a': [1, 3, 4], 'b': ['10', '30', '40']}