Using thesorted() Function

The critical function that you’ll use to sort dictionaries is the built-insorted() function. This function takes aniterable as the main argument, with two optionalkeyword-only arguments—akey function and areverse Boolean value.

To illustrate thesorted() function’s behavior in isolation, examine its use on alist of numbers:

>>>numbers=[5,3,4,3,6,7,3,2,3,4,1]>>>sorted(numbers)[1, 2, 3, 3, 3, 3, 4, 4, 5, 6, 7]

As you can see, thesorted() function takes an iterable, sortscomparable elements like numbers inascending order, and returns a new list. With strings, it sorts them inalphabetical order:

>>>words=["aa","ab","ac","ba","cb","ca"]>>>sorted(words)['aa', 'ab', 'ac', 'ba', 'ca', 'cb']

Sorting by numerical or alphabetical precedence is the most common way to sort elements, but maybe you need more control.

Say you want to sort on thesecond character of each word in the last example. To customize what thesorted() function uses to sort the elements, you can pass in acallback function to thekey parameter.

A callback function is a function that’s passed as an argument to another function. Forsorted(), you pass it a function that acts as a sort key. Thesorted() function will thencall back the sort key for every element.

In the following example, the function passed as the key accepts a string and will return the second character of that string:

>>>defselect_second_character(word):...returnword[1]...>>>sorted(words,key=select_second_character)['aa', 'ba', 'ca', 'ab', 'cb', 'ac']

Thesorted() function passes every element of thewords iterable to thekey function and uses the return value for comparison. Using the key means that thesorted() function will compare the second letter instead of comparing the whole string directly.

More examples and explanations of thekey parameter will comelater in the tutorial when you use it to sort dictionaries by values or nested elements.

If you take another look at the results of this last sorting, you may notice thestability of thesorted() function. The three elements,aa,ba andca, are equivalent when sorted by their second character. Because they’re equal, thesorted() function conserves theiroriginal order. Python guarantees this stability.

>>>list(reversed([1,2,3]))[3, 2, 1]

So, how about dictionaries? You can actually take the dictionary and feed it straight into thesorted() function:

>>>people={3:"Jim",2:"Jack",4:"Jane",1:"Jill"}>>>sorted(people)[1, 2, 3, 4]

But the default behavior of passing in a dictionary directly to thesorted() function is to take thekeys of the dictionary, sort them, and return alist of the keysonly. That’s probably not the behavior you had in mind! To preserve all the information in a dictionary, you’ll need to be acquainted withdictionary views.

Getting Keys, Values, or Both From a Dictionary

If you want to conserve all the information from a dictionary when sorting it, the typical first step is to call the.items() method on the dictionary. Calling.items() on the dictionary will provide an iterable oftuples representing the key-value pairs:

>>>people={3:"Jim",2:"Jack",4:"Jane",1:"Jill"}>>>people.items()dict_items([(3, 'Jim'), (2, 'Jack'), (4, 'Jane'), (1, 'Jill')])

The.items() method returns a read-onlydictionary view object, which serves as a window into the dictionary. This view isnot a copy or a list—it’s a read-onlyiterable that’s actuallylinked to the dictionary it was generated from:

>>>people={3:"Jim",2:"Jack",4:"Jane",1:"Jill"}>>>view=people.items()>>>people[2]="Elvis">>>viewdict_items([(3, 'Jim'), (2, 'Elvis'), (4, 'Jane'), (1, 'Jill')])

You’ll notice that any updates to the dictionary also get reflected in the view because they’re linked. A view represents a lightweight way to iterate over a dictionary without generating a list first.

Crucially, you can use thesorted() function with dictionary views. You call the.items() method and use the result as an argument to thesorted() function. Using.items() keeps all the information from the dictionary:

>>>people={3:"Jim",2:"Jack",4:"Jane",1:"Jill"}>>>sorted(people.items())[(1, 'Jill'), (2, 'Jack'), (3, 'Jim'), (4, 'Jane')]

This example results in a sorted list of tuples, with each tuple representing a key-value pair of the dictionary.

If you want to end up with a dictionary sorted by values, then you’ve still got two issues. The default behavior still seems to sort bykey and not value. The other issue is that you end up with alist of tuples, not a dictionary. First, you’ll figure out how to sort by value.

Understanding How Python Sorts Tuples

When using the.items() method on a dictionary and feeding it into thesorted() function, you’re passing in an iterable of tuples, and thesorted() function compares the entire tuple directly.

When comparing tuples, Python behaves a lot like it’s sorting strings alphabetically. That is, it sorts themlexicographically.

Lexicographical sorting means that if you have two tuples,(1, 2, 4) and(1, 2, 3), then you start by comparing the first item of each tuple. The first item is1 in both cases, which is equal. The second element,2, is also identical in both cases. The third elements are4 and3, respectively. Since3 is less than4, you’ve found which item isless than the other.

So, to order the tuples(1, 2, 4) and(1, 2, 3) lexicographically, you would switch their order to(1, 2, 3) and(1, 2, 4).

Because of Python’s lexicographic sorting behavior for tuples, using the.items() method with thesorted() function will always sort by keys unless you use something extra.

Using thekey Parameter and Lambda Functions

For example, if you want to sort by value, then you have to specify asort key. A sort key is a way to extract a comparable value. For instance, if you have a pile of books, then you might use the author surname as the sort key. With thesorted() function, you can specify a sort key by passing a callback function as akey argument.

To see a sort key in action, take a look at this example, which is similar to the one you saw in thesection introducing thesorted() function:

>>>people={3:"Jim",2:"Jack",4:"Jane",1:"Jill"}>>># Sort key>>>defvalue_getter(item):...returnitem[1]...>>>sorted(people.items(),key=value_getter)[(2, 'Jack'), (4, 'Jane'), (1, 'Jill'), (3, 'Jim')]>>># Or with a lambda function>>>sorted(people.items(),key=lambdaitem:item[1])[(2, 'Jack'), (4, 'Jane'), (1, 'Jill'), (3, 'Jim')]

In this example, you try out two ways of passing akey parameter. Thekey parameter accepts a callback function. The function can be a normal function identifier or alambda function. The lambda function in the example is the exact equivalent of thevalue_getter() function.

# With a normal functiondefvalue_getter(item):returnitem[1]sorted(people.items(),key=value_getter)# With a lambda functionsorted(people.items(),key=lambdaitem:item[1])

Thekey callback function will receive each element of the iterable that it’s sorting. The callback function’s job is toreturn something that can be compared, such as a number or a string. In this example, you named the functionvalue_getter() because all it does is get the value from a key-value tuple.

Since the default behavior ofsorted() with tuples is to sort lexicographically, thekey parameter allows you to select a value from the element that it’s comparing.

In the next section, you’ll take sort keys a bit further and use them to sort by a nested value.

Selecting a Nested Value With a Sort Key

You can also go further and use a sort key to select nested values that may or may not be present and return a default value if they’re not present:

data={193:{"name":"John","age":30,"skills":{"python":8,"js":7}},209:{"name":"Bill","age":15,"skills":{"python":6}},746:{"name":"Jane","age":58,"skills":{"js":2,"python":5}},109:{"name":"Jill","age":83,"skills":{"java":10}},984:{"name":"Jack","age":28,"skills":{"c":8,"assembly":7}},765:{"name":"Penelope","age":76,"skills":{"python":8,"go":5}},598:{"name":"Sylvia","age":62,"skills":{"bash":8,"java":7}},483:{"name":"Anna","age":24,"skills":{"js":10}},277:{"name":"Beatriz","age":26,"skills":{"python":2,"js":4}},}defget_relevant_skills(item):"""Get the sum of Python and JavaScript skill"""skills=item[1]["skills"]# Return default value that is equivalent to no skillreturnskills.get("python",0)+skills.get("js",0)print(sorted(data.items(),key=get_relevant_skills,reverse=True))

In this example, you have a dictionary with numeric keys and a nested dictionary as a value. You want to sort by the combined Python and JavaScript skills, attributes found in theskills subdictionary.

Part of what makes sorting by the combined skill tricky is that thepython andjs keys aren’t present in theskills dictionary for all people. Theskills dictionary is also nested. You use.get() to read the keys and provide0 as a default value that’s used for missing skills.

You’ve also used thereverse argument because you want the top Python skills to appear first.

sorted(data.items(),key=lambdaitem:(item[1]["skills"].get("python",0)+item[1]["skills"].get("js",0)),reverse=True,)

You’ve successfully used a higher-order function as a sort key to sort a dictionary view by value. That was the hard part. Now there’s only one issue left to solve—converting the list thatsorted() yields back into a dictionary.

Converting Back to a Dictionary

The only issue left to address with the default behavior ofsorted() is that it returns a list, not a dictionary. There are a few ways to convert a list of tuples back into a dictionary.

You can iterate over the result with afor loop and populate a dictionary on each iteration:

>>>people={3:"Jim",2:"Jack",4:"Jane",1:"Jill"}>>>sorted_people=sorted(people.items(),key=lambdaitem:item[1])>>>sorted_people_dict={}>>>forkey,valueinsorted_people:...sorted_people_dict[key]=value...>>>sorted_people_dict{2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}

This method gives you absolute control and flexibility in deciding how you want to construct your dictionary. This method can be quite lengthy to type out, though. If you don’t have any special requirements for constructing your dictionary, then you may want to go for adictionary constructor instead:

>>>people={3:"Jim",2:"Jack",4:"Jane",1:"Jill"}>>>sorted_people=sorted(people.items(),key=lambdaitem:item[1])>>>dict(sorted_people){2: 'Jack', 4: 'Jane', 1: 'Jill', 3: 'Jim'}

That’s nice and compact! You could also use adictionary comprehension, but that only makes sense if you want to change the shape of the dictionary or swap the keys and values, for example. In the following comprehension, you swap the keys and values:

>>>{...value:key...forkey,valueinsorted(people.items(),key=lambdaitem:item[1])...}...{'Jack': 2, 'Jane': 4, 'Jill': 1, 'Jim': 3}

Depending on how familiar you or your team are with comprehensions, this may be less readable than just using a normalfor loop.

Congratulations, you’ve got your sorted dictionary! You can now sort it by any criteria that you’d like.

Now that you can sort your dictionary, you might be interested in knowing if there are any performance implications to using a sorted dictionary, or whether there are alternative data structures for key-value data.

Using Special Getter Functions to Increase Performance and Readability

You may have noticed that most of the sort key functions that you’ve used so far aren’t doing very much. All the function does is get a value from a tuple. Making a getter function is such a common pattern that Python has a special way to create special functions that get values more quickly than regular functions.

Theitemgetter() function can produce highly efficient versions of getter functions.

You passitemgetter() an argument, which is typically the key or index position that you want to select. Theitemgetter() function will then return a getter object that you call like a function.

That’s right, it’s a function that returns a function. Using theitemgetter() function is another example of working with higher-order functions.

The getter object fromitemgetter() will call the.__getitem__() method on the item that’s passed to it. When something makes a call to.__getitem__(), it needs to pass in the key or index of what to get. The argument that’s used for.__getitem__() is the same argument that you passed toitemgetter():

>>>item=("name","Guido")>>>fromoperatorimportitemgetter>>>getter=itemgetter(0)>>>getter(item)'name'>>>getter=itemgetter(1)>>>getter(item)'Guido'

In the example, you start off with a tuple, similar to one that you might get as part of a dictionary view.

You make the first getter by passing0 as an argument toitemgetter(). When the resultant getter receives the tuple, it returns the first item in the tuple—the value at index0. If you callitemgetter() with an argument of1, then it gets the value at index position1.

You can use this itemgetter as a key for thesorted() function:

>>>fromoperatorimportitemgetter>>>fruit_inventory=[...("banana",5),("orange",15),("apple",3),("kiwi",0)...]>>># Sort by key>>>sorted(fruit_inventory,key=itemgetter(0))[('apple', 3), ('banana', 5), ('kiwi', 0), ('orange', 15)]>>># Sort by value>>>sorted(fruit_inventory,key=itemgetter(1))[('kiwi', 0), ('apple', 3), ('banana', 5), ('orange', 15)]>>>sorted(fruit_inventory,key=itemgetter(2))Traceback (most recent call last):  File"<input>", line1, in<module>sorted(fruit_inventory,key=itemgetter(2))IndexError:tuple index out of range

In this example, you start by usingitemgetter() with0 as an argument. Since it’s operating on each tuple from thefruit_inventory variable, it gets the first element from each tuple. Then the example demonstrates initializing anitemgetter with1 as an argument, which selects the second item in the tuple.

Finally, the example shows what would happen if you useditemgetter() with2 as an argument. Since these tuples only have two index positions, trying to get the third element, with index2, results in aIndexError.

You can use the function produced byitemgetter() in place of the getter functions that you’ve been using up until now:

>>>people={3:"Jim",2:"Jack",4:"Jane",1:"Jill"}>>>fromoperatorimportitemgetter>>>sorted(people.items(),key=itemgetter(1))[(2, 'Jack'), (4, 'Jane'), (1, 'Jill'), (3, 'Jim')]

Theitemgetter() function produces a function that has exactly the same effect as thevalue_getter() function from previous sections. The main reason you’d want to use the function fromitemgetter() is because it’s more efficient. In the next section, you’ll start to put some numbers on just how much more efficient it is.

Measuring Performance When Usingitemgetter()

So, you end up with a function that behaves like the originalvalue_getter() from the previous sections, except that the version returned fromitemgetter() is more efficient. You can use thetimeit module to compare their performance:

fromtimeitimporttimeitdict_to_order={1:"requests",2:"pip",3:"jinja",4:"setuptools",5:"pandas",6:"numpy",7:"black",8:"pillow",9:"pyparsing",10:"boto3",11:"botocore",12:"urllib3",13:"s3transfer",14:"six",15:"python-dateutil",16:"pyyaml",17:"idna",18:"certifi",19:"typing-extensions",20:"charset-normalizer",21:"awscli",22:"wheel",23:"rsa",}sorted_with_lambda="sorted(dict_to_order.items(), key=lambda item: item[1])"sorted_with_itemgetter="sorted(dict_to_order.items(), key=itemgetter(1))"sorted_with_lambda_time=timeit(stmt=sorted_with_lambda,globals=globals())sorted_with_itemgetter_time=timeit(stmt=sorted_with_itemgetter,setup="from operator import itemgetter",globals=globals(),)print(f"""\{sorted_with_lambda_time=:.2f} seconds{sorted_with_itemgetter_time=:.2f} secondsitemgetter is{(sorted_with_lambda_time/sorted_with_itemgetter_time):.2f} times faster""")

This code uses thetimeit module to compare the sorting processes of the function fromitemgetter() and a lambda function.

Running this script from the shell should give you similar results to what’s below:

$pythoncompare_lambda_vs_getter.pysorted_with_lambda_time=1.81 secondssorted_with_itemgetter_time=1.29 secondsitemgetter is 1.41 times faster

A savings of around 40 percent is significant!

Bear in mind that when timing code execution, times can vary significantly between systems. That said, in this case, the ratio should be relatively stable across systems.

From the results of this test, you can see that usingitemgetter() is preferable from a performance standpoint. Plus, it’s part of the Python standard library, so there’s no cost to using it.

Now you can squeeze a bit more performance out of your dictionary sorting, but it’s worth taking a step back and considering whether using a sorted dictionary as your preferred data structure is the best choice. A sorted dictionary isn’t a very common pattern, after all.

Coming up, you’ll be asking yourself some questions about what you what you want to do with your sorted dictionary and whether it’s the best data structure for your use case.

Judging Whether You Want to Use a Sorted Dictionary

If you’re considering making a sorted key-value data structure, then there are a few things you might want to take into consideration.

If you’re going to be adding data to a dictionary, and you want it to stay sorted, then you might be better off using a structure like a list of tuples or a list of dictionaries:

# Dictionarypeople={3:"Jim",2:"Jack",4:"Jane",1:"Jill"}# List of tuplespeople=[(3,"Jim"),(2,"Jack"),(4,"Jane"),(1,"Jill"),]# List of dictionariespeople=[{"id":3,"name":"Jim"},{"id":2,"name":"Jack"},{"id":4,"name":"Jane"},{"id":1,"name":"Jill"},]

A list of dictionaries is the most widespread pattern because of its cross-language compatibility, known aslanguage interoperability.

Language interoperability is especially relevant if you create anHTTP REST API, for instance. Making your data available over the Internet will likely mean serializing it inJSON.

If someone usingJavaScript were to consume JSON data from a REST API, then the equivalent data structure would be anobject. The kicker is that JavaScript objects arenot ordered, so the order would end up scrambled!

This scrambling behavior would be true for many languages, and objects are even defined in theJSON specification as an unordered data structure. So, if you took care to order your dictionary before serializing to JSON, it wouldn’t matter by the time it got into most other environments.

Another option is to simply not worry about ordering the data if you don’t need to. Includingid,priority, or other equivalent attributes for each object can be enough to express order. If the ordering gets mixed up for any reason, then there’ll always be an unambiguous way to sort it:

people={3:{"priority":2,"name":"Jim"},2:{"priority":4,"name":"Jack"},4:{"priority":1,"name":"Jane"},1:{"priority":2,"name":"Jill"},}

With apriority attribute, for instance, it’s clear thatJane should be first in line. Being clear about your intended ordering is nicely in agreement with the old Python adage ofexplicit is better than implicit, from theZen of Python.

What are the performance trade-offs with using a list of dictionaries versus a dictionary of dictionaries, though? In the next section, you’ll start to get some data on just that very question.

Comparing the Performance of Different Data Structures

If performance is a consideration—maybe you’ll be working with large datasets, for example—then you should carefully consider what you’ll be doing with the dictionary.

The two main questions you’ll seek to answer in the next few sections are:

1. Will you be sorting once and then making lots of lookups?
2. Will you be sorting many times and making very few lookups?

Once you’ve decided what usage patterns you’ll be subjecting your data structure to, then you can use thetimeit module to test the performance. These measurements can vary a lot with the exact shape and size of the data being tested.

In this example, you’ll be pitting a dictionary of dictionaries against a list of dictionaries to see how they differ in terms of performance. You’ll be timing sorting operations and lookup operations with the following sample data:

dictionary_of_dictionaries={1:{"first_name":"Dorthea","last_name":"Emmanuele","age":29},2:{"first_name":"Evelina","last_name":"Ferras","age":91},3:{"first_name":"Frederica","last_name":"Livesay","age":99},4:{"first_name":"Murray","last_name":"Linning","age":36},5:{"first_name":"Annette","last_name":"Garioch","age":93},6:{"first_name":"Rozamond","last_name":"Todd","age":36},7:{"first_name":"Tiffi","last_name":"Varian","age":28},8:{"first_name":"Noland","last_name":"Cowterd","age":51},9:{"first_name":"Dyana","last_name":"Fallows","age":100},10:{"first_name":"Diahann","last_name":"Cutchey","age":44},11:{"first_name":"Georgianne","last_name":"Steinor","age":32},12:{"first_name":"Sabina","last_name":"Lourens","age":31},13:{"first_name":"Lynde","last_name":"Colbeck","age":35},14:{"first_name":"Abdul","last_name":"Crisall","age":84},15:{"first_name":"Quintus","last_name":"Brando","age":95},16:{"first_name":"Rowena","last_name":"Geraud","age":21},17:{"first_name":"Maurice","last_name":"MacAindreis","age":83},18:{"first_name":"Pall","last_name":"O'Cullinane","age":79},19:{"first_name":"Kermie","last_name":"Willshere","age":20},20:{"first_name":"Holli","last_name":"Tattoo","age":88},}list_of_dictionaries=[{"id":1,"first_name":"Dorthea","last_name":"Emmanuele","age":29},{"id":2,"first_name":"Evelina","last_name":"Ferras","age":91},{"id":3,"first_name":"Frederica","last_name":"Livesay","age":99},{"id":4,"first_name":"Murray","last_name":"Linning","age":36},{"id":5,"first_name":"Annette","last_name":"Garioch","age":93},{"id":6,"first_name":"Rozamond","last_name":"Todd","age":36},{"id":7,"first_name":"Tiffi","last_name":"Varian","age":28},{"id":8,"first_name":"Noland","last_name":"Cowterd","age":51},{"id":9,"first_name":"Dyana","last_name":"Fallows","age":100},{"id":10,"first_name":"Diahann","last_name":"Cutchey","age":44},{"id":11,"first_name":"Georgianne","last_name":"Steinor","age":32},{"id":12,"first_name":"Sabina","last_name":"Lourens","age":31},{"id":13,"first_name":"Lynde","last_name":"Colbeck","age":35},{"id":14,"first_name":"Abdul","last_name":"Crisall","age":84},{"id":15,"first_name":"Quintus","last_name":"Brando","age":95},{"id":16,"first_name":"Rowena","last_name":"Geraud","age":21},{"id":17,"first_name":"Maurice","last_name":"MacAindreis","age":83},{"id":18,"first_name":"Pall","last_name":"O'Cullinane","age":79},{"id":19,"first_name":"Kermie","last_name":"Willshere","age":20},{"id":20,"first_name":"Holli","last_name":"Tattoo","age":88},]

Each data structure has the same information, except one is structured as a dictionary of dictionaries, and the other is a list of dictionaries. First up, you’ll be getting some metrics on the performance of sorting these two data structures.

Comparing the Performance of Sorting

In the following code, you’ll be usingtimeit to compare the time it takes to sort the two data structures by theage attribute:

fromtimeitimporttimeitfromsamplesimportdictionary_of_dictionaries,list_of_dictionariessorting_list="sorted(list_of_dictionaries, key=lambda item:item['age'])"sorting_dict="""dict(    sorted(        dictionary_of_dictionaries.items(), key=lambda item: item[1]['age']    ))"""sorting_list_time=timeit(stmt=sorting_list,globals=globals())sorting_dict_time=timeit(stmt=sorting_dict,globals=globals())print(f"""\{sorting_list_time=:.2f} seconds{sorting_dict_time=:.2f} secondslist is{(sorting_dict_time/sorting_list_time):.2f} times faster""")

This code imports the sample data structures for sorting on theage attribute. It may seem like you aren’t using the imports fromsamples, but it’s necessary for these samples to be in the globalnamespace so that thetimeit context has access to them.

Running the code for this test on the command line should provide you with some interesting results:

$pythoncompare_sorting_dict_vs_list.pysorting_list_time=1.15 secondssorting_dict_time=2.26 secondslist is 1.95 times faster

Sorting a list can be almost twice as fast as the process required to sort a dictionary view and then create a new sorted dictionary. So, if you plan on sorting your data very regularly, then a list of tuples might be better than a dictionary for you.

One of the main overheads when sorting a dictionary, as opposed to a list, is reconstructing the dictionary after sorting it. If you were to take out the outerdict() constructor, then you’d significantly cut the execution time.

In the next section, you’ll be looking at the time it takes to look up values in a dictionary of dictionaries versus in a list of dictionaries.

Comparing the Performance of Lookups

However, if you plan to use the dictionary to sort your data once and use that dictionary mainly for lookups, then a dictionary will definitely make more sense than a list:

fromtimeitimporttimeitfromsamplesimportdictionary_of_dictionaries,list_of_dictionarieslookups=[15,18,19,16,6,12,5,3,9,20,2,10,13,17,4,14,11,7,8]list_setup="""def get_key_from_list(key):    for item in list_of_dictionaries:        if item["id"] == key:            return item"""lookup_list="""for key in lookups:    get_key_from_list(key)"""lookup_dict="""for key in lookups:    dictionary_of_dictionaries[key]"""lookup_list_time=timeit(stmt=lookup_list,setup=list_setup,globals=globals())lookup_dict_time=timeit(stmt=lookup_dict,globals=globals())print(f"""\{lookup_list_time=:.2f} seconds{lookup_dict_time=:.2f} secondsdict is{(lookup_list_time/lookup_dict_time):.2f} times faster""")

This code makes a series of lookups to both the list and the dictionary. You’ll note that with the list, you have to write a special function to make a lookup. The function to make the list lookup involves going through all the list elements one by one until you find the target element, which isn’t ideal.

Running this comparison script from the command line should yield a result showing that dictionary lookups are significantly faster:

$pythoncompare_lookup_dict_vs_list.pylookup_list_time=6.73 secondslookup_dict_time=0.38 secondsdict is 17.83 times faster

Nearly eighteen times faster! That’s a whole bunch. So, you certainly want to weigh the blazing speed of dictionary lookups against the data structure’s slower sorting. Bear in mind that this ratio can vary significantly from system to system, not to mention the variation that might come from differently sized dictionaries or lists.

Dictionary lookups are certainly faster, though, no matter how you slice it. That said, if you’re just doing lookups, then you could just as easily do that with a regular unsorted dictionary. Why would you need a sorted dictionary in that case? Leave your use case in the comments!

Now you should have a relatively good idea of some trade-offs between two ways to store your key-value data. The conclusion that you can reach is that, most of the time, if you want a sorted data structure, then you should probably steer clear of the dictionary, mainly for language interoperability reasons.

That said, giveGrant Jenks’ aforementionedsorted dictionary a try. It uses some ingenious strategies to get around typical performance drawbacks.

Do you have any interesting or performant implementations of a sorted key-value data structure? Share them in the comments, along with your use cases for a sorted dictionary!