{"id":3311,"date":"2021-09-07T09:30:34","date_gmt":"2021-09-07T13:30:34","guid":{"rendered":"https:\/\/www.alpharithms.com\/?p=3311"},"modified":"2022-12-19T11:20:28","modified_gmt":"2022-12-19T16:20:28","slug":"python-list-vs-dictionary","status":"publish","type":"post","link":"https:\/\/www.alpharithms.com\/python-list-vs-dictionary-343009\/","title":{"rendered":"Python List vs Dictionary: Which Data Type is Better? [Runtime Tests Included]"},"content":{"rendered":"

<\/p>\n

Comparing a Python list vs dictionary is a task as common as coding loops, especially among coders learning the ropes. They are, after all, two different data types with unique implementations and strengths.<\/p>\n

Choosing a side in a list vs dictionary Python discussion ultimately comes down to understanding each data type, how it works, and ultimately what it can do for you and your next project. Once you have those fundamentals down to the letter, making a choice is, for the most part, incredibly easy.<\/p>\n

Python List vs Dictionary<\/h2>\n

When comparing a Python list vs dictionary you’ll want first to consider how they represent data. Lists tend to represent data collections of the same type or function, while dictionaries represent individual data with unique properties. As projects increase in complexity, you’ll often find that you’ll need a combination of these two robust data structures to create valuable apps and scripts for you and your clients. However, you’ll also need to weigh other factors, such as overall lookup speed and resource management.<\/p>\n

Today, we’ll cover the fundamental differences and time complexity nuance that will help you pick the right choice in any Python list vs Dictionary discussion. We’ll also delve a little deeper to truly understand when you should use a list and when you should use a Python Dictionary for your projects.<\/p>\n

Without further ado, let’s begin!<\/p>\n

List vs Dictionary Python<\/h2>\n

Most list vs dictionary python discussions are settled with a strong understanding of each data type fundamentals, so let’s start with that. The list data type<\/a> contains multiple values in an ordered sequence, with all of these items representing a collection of data from a similar type (or function). You can define a list using square brackets and separating each item with a comma, as follows:<\/p>\n

## List example #1\r\n\r\n['burger', 'pizza', 'pasta', 'bacon omelette']\r\nfood = ['burger', 'pizza', 'pasta', 'bacon omelette']\r\nprint(food[0])<\/pre>\n
Each item in your list is delimited by a comma and can be accessed by referencing its respective index, as seen below.<\/p>\n
food = ['burger', 'pizza', 'pasta', 'bacon omelette']\r\nfor i in range(len(food)):\r\n    print('Index ' + str(i) + ' in the food list is: ' + food[I])\r\n\r\n## Output\r\n\r\nIndex 0 in the food list is: burger        \r\nIndex 1 in the food list is: pizza\r\nIndex 2 in the food list is: pasta\r\nIndex 3 in the food list is: bacon omelette<\/pre>\n
This organized catalog of each list item is a big reason why most list vs dictionary Python discussions can be so heated. It seems ideal for iterative processes and is intuitive in nature, making it a strong choice for a wide range of projects that require sequentially-ordered data.<\/p>\n
On the other corner of this list vs dictionary python argument, we got the Python Dictionary. A Python dictionary consists of an unordered collection of data values, which allows you to pair one item to another in any order of your choosing. They’re typically known as associative arrays since you can link a key with a specific value.<\/p>\n
To create a Python dictionary, assign a name to it and open a pair of curly braces to store as many key-value pairs as you’d like. You can separate a key from its value with a colon and delimit each pair with a comma.<\/p>\n
## Dictionary Example\r\n\r\ndictionary_one = {\r\n    \"A\": 1,\r\n    \"B\": \"2\",\r\n    }<\/pre>\n
Beginner coders will often think that dictionaries are not proper organizational tools because they don’t follow a strictly sequential order, but that couldn’t be farther from the truth<\/a>. Dictionaries store individual pieces of data with multiple properties, but each key corresponds to a specific value. This specificity and its hash table implementation turn dictionaries into compelling data structure elements for many projects.<\/p>\n
You can even append dictionaries to dataframes in Python<\/a>, which follow a strict data organization scheme you can visualize in well-organized tables. There’s tons of creative freedom around dictionaries, with values taking the forms of individual dictionaries, if need be.<\/p>\n
Now that we understand what each element brings to the table, it’s time to map out their differences to better understand when we should use each Python data type.<\/p>\n
Python List vs Dict<\/h2>\n
Now that we’ve covered the basics, it’s time that we go a level deeper in this Python vs dict breakdown. Let’s list (no pun intended) some of the most notable differences between these two valuable data types. We’ve already established that lists are a collection of ordered values that work like arrays, while dictionaries are unordered key-value pairs, but dictionaries are also considered hashed structures.<\/p>\n
A hash table is an associative array that allows you to store a collection of key-value pairs. As an astute commenter on StackOverflow pointed out, asking what the difference between a hash table and a Python dictionary is, is like asking what’s the difference between a car and a Ford Focus. Dictionaries are implemented as hash tables in Python and work with hash functions, so they’re the same.<\/p>\n
To some, this might be a borderline nit-picky observation. Still, this is a crucial difference once you consider the lookup speed differences between elements and their space-time tradeoff (which we’ll explore later in this article). But, for now, let’s get back to our Python list vs dict breakdown.<\/p>\n
When it comes to Syntax and index types, both elements are wildly different. Lists require you to place their items inside square brackets, while dictionaries use curly brackets and their respective function. Both data structures have comma-delimited items, but dictionaries additionally need a colon that defines key-value pairs. Here’s an example that illustrates these syntactical differences:<\/p>\n
## Dictionary Example\r\n\r\ndictionary_one = {      ## Opening Curly Brackets\r\n    \"A\": 1,             ## Key-Value pairs are separated by a colon (:)\r\n    \"B\": \"2\",           ## Key-Value pairs are comma-delimited\r\n    }                   ## Closing Curly Brackets\r\n\r\n## List example\r\n\r\nfood = ['burger',             ## Opening Brackets\r\n        'pasta',              ## items in a list are comma-delimited\r\n       ]                      ## Closing Brackets]<\/pre>\n
Any Python list vs dict comparison needs to address how items are accessed. You can access items in your lists through their individual index values, which are assigned on creation, starting from 0. On the other hand, dictionaries require you to reference their keys to get specific values that follow no numbered order.<\/p>\n
Last but not least, it’s important to point out that while both data structures are mutable, only lists accept true duplicates. Dictionaries, on the other hand, require all keys to be unique. Dictionary values can be duplicates, but they’re not true duplicates since their corresponding key has to be unique.<\/p>\n
Now, let’s peel another layer in our Python list vs dict breakdown and take a look at lookup speed and resource management differences between these two data structures.<\/p>\n
Dictionary vs List Python: Which One is Faster<\/h2>\n
When making a dictionary vs list Python comparison, you’re guaranteed to run into Big O, time complexity, and memory efficiency. Once you’re processing large amounts of data (the whole point behind automation and coding), you’ll want to use data structures and functions that will, ideally, decrease runtime and resource usage over time.<\/p>\n
You’ll notice that, depending on the size of the input, your overall runtime can increase, and programmers use Big O notation and Time Complexity<\/a> to calculate this relationship. The most common time complexity relationships are linear, constant, and quadratic.<\/p>\n
    \n
  1. A linear time relationship means that your runtime increases as the number of input increases. This is known as O(n) in Big O notation.<\/li>\n
  2. A constant time relationship means that the time to complete a function (runtime) does not increase when the input size varies. This is known as O(1) in Big O notation.<\/li>\n
  3. A quadratic time relationship means that your runtime will behave like a quadratic function when the size input varies, meaning it’ll increase exponentially. This is known as O(n\u00b2) in Big O notation.<\/li>\n<\/ol>\n
    I ran some rudimentary tests to compare runtimes between a dictionary vs list Python to see where they fall under time complexity and Big O measurements. Let’s start with lists.<\/p>\n
    import time\r\n\r\nsmall_list = list(range(100000))\r\nlarge_list = list(range(1000000))\r\n\r\nstart_time = time.time()\r\nfor i in small_list:\r\n    if i == 99999:\r\n        break\r\n    \r\ncompleted_time = time.time() - start_time\r\nprint (f'Searching Small List: {completed_time} seconds')\r\n\r\nstart_time_1 = time.time()\r\nfor i in large_list:\r\n    if i == 999999:\r\n        break\r\n    \r\ncompleted_time_2 = time.time() - start_time_1\r\nprint (f'Searching Large List: {completed_time_2} seconds')\r\n\r\n# Searching Small List: 0.00400090217590332 seconds\r\n# Searching Large List: 0.04300975799560547 seconds<\/pre>\n
    And here are the results for our dictionaries, using the same number of inputs.<\/p>\n
    import time\r\n\r\ndict_1 = {}\r\nfor i in range (100000):\r\n    dict_1 [i]= i\r\n\r\nstart_time = time.time()\r\nvalue = dict_1[99999]\r\ncompleted_time = time.time() - start_time\r\nprint (f'Searching Dictionary 1: {completed_time} seconds')\r\n\r\ndict_2 = {}\r\nfor i in range (1000000):\r\n    dict_2 [i]= i\r\n\r\nstart_time_1 = time.time()\r\nvalue = dict_2[999999]\r\ncompleted_time_1 = time.time() - start_time\r\nprint (f'Searching Dictionary 2: {completed_time} seconds')\r\n\r\n# Searching Dictionary 1: 0.0 seconds\r\n# Searching Dictionary 2: 0.0 seconds<\/pre>\n
    Notice how dictionaries are significantly faster, and how search runtime increases as input increases on our lists. This is because dictionaries in Python are implemented as hash tables, something we listed as a critical difference between these two data types in our previous section.<\/p>\n
    In a nutshell, hash tables are made up of hash functions, which map data of any length to a fixed-length value (hashes). It doesn’t matter what your input is (10, 1000, or 10000); the result will always be a predetermined, fixed-length hash. Since the same string will always produce an exact hash, they’re incredibly fast to compute, especially compared to lists, as seen in our previous example.<\/p>\n
    Python Dictionary vs List: When To Use Each<\/h2>\n
    Generally speaking, you’ll want to use a list data structure when your elements need to follow a strictly sequential order or when dealing with data you’ll most likely need to modify later. Dictionaries and lists are both mutable, but your dictionary keys can’t be duplicates, and when you’re dealing with massive amounts of data, there’s also room for massive bugs. However, remember that their search method is reasonably expensive and has a slower runtime.<\/p>\n
    \u00a0<\/span>On the other hand, dictionaries are better for any type of data that doesn’t need to be stored and accessed through an ordered sequential index. In every other aspect, dictionaries are superior to lists in terms of runtime and overall efficiency. Their most popular methods (search, append and delete) are inexpensive and faster to execute, thanks to how Python implemented them.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Comparing a Python list vs dictionary is a task as common as coding loops, especially among coders learning the ropes. They are, after all, two different data types with unique implementations and strengths. Choosing a side in a list vs dictionary Python discussion ultimately comes down to understanding each data type, how it works, and […]<\/p>\n","protected":false},"author":4,"featured_media":3316,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[186],"tags":[735,734,659],"acf":[],"_links":{"self":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/3311"}],"collection":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/users\/4"}],"replies":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/comments?post=3311"}],"version-history":[{"count":10,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/3311\/revisions"}],"predecessor-version":[{"id":3324,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/posts\/3311\/revisions\/3324"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media\/3316"}],"wp:attachment":[{"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/media?parent=3311"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/categories?post=3311"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.alpharithms.com\/wp-json\/wp\/v2\/tags?post=3311"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}