Slicing a dictionary by keys that start with a certain string

Question

This is pretty simple but I'd love a pretty, pythonic way of doing it. Basically, given a dictionary, return the subdictionary that contains only those keys that start with a certain string.

» d = {'Apple': 1, 'Banana': 9, 'Carrot': 6, 'Baboon': 3, 'Duck': 8, 'Baby': 2}
» print slice(d, 'Ba')
{'Banana': 9, 'Baby': 2, 'Baboon': 3}

This is fairly simple to do with a function:

def slice(sourcedict, string):
    newdict = {}
    for key in sourcedict.keys():
        if key.startswith(string):
            newdict[key] = sourcedict[key]
    return newdict

But surely there is a nicer, cleverer, more readable solution? Could a generator help here? (I never have enough opportunities to use those).

Solution 1

How about this:

in python 2.x :

def slicedict(d, s):
    return {k:v for k,v in d.iteritems() if k.startswith(s)}

In python 3.x :

def slicedict(d, s):
    return {k:v for k,v in d.items() if k.startswith(s)}

Solution 2

In functional style:

dict(filter(lambda item: item[0].startswith(string),sourcedict.iteritems()))

Solution 3

In Python 3 use items() instead:

def slicedict(d, s):
    return {k:v for k,v in d.items() if k.startswith(s)}

Comments

[user3181121]

Don't obscure python code just because it is possible. The whole idea of python is readability. If you just need obscure power, use Perl.

[bjd2385]

Also see pythoncentral.io/how-to-slice-custom-objects-classes-in-pyth‌​on, you can customize __getitem__ in your own type/subclass of dict.

[Ignacio Vazquez-Abrams]

Don't shadow the slice built-in (even though almost no one uses it).

[Aphex]

That dict comprehension is delicious. And I had no idea slice was a builtin, wtf?

[Glenn Maynard]

@Ignacio: When you're in a tiny, local function, it really isn't always worth worrying about stepping on builtins--there are too many of them, with far too common names. Better just to worry about it for nontrivial functions (if that) and globals. Builtins aren't keywords, after all.

[Glenn Maynard]

In Python, functional style is usually just what you don't want.

[razpeitia]

No dictionary comprehension way dict((k, v) for k,v in d.iteritems() if k.startswith(s))

[Karl Knechtel]

Eh? The dict-comprehension approach certainly falls under my definition of "functional style".

[cowbert]

in 2017: python can comprehension a dict purely using in: {k:d[k] for k in d if k.startswith(s)}, no more need to invoke a function call.