{"id":2980748,"date":"2023-11-20T10:00:30","date_gmt":"2023-11-20T15:00:30","guid":{"rendered":"https:\/\/wordpress-1016567-4521551.cloudwaysapps.com\/plato-data\/why-you-should-not-overuse-list-comprehensions-in-python-kdnuggets\/"},"modified":"2023-11-20T10:00:30","modified_gmt":"2023-11-20T15:00:30","slug":"why-you-should-not-overuse-list-comprehensions-in-python-kdnuggets","status":"publish","type":"station","link":"https:\/\/platodata.io\/plato-data\/why-you-should-not-overuse-list-comprehensions-in-python-kdnuggets\/","title":{"rendered":"Why You Should Not Overuse List Comprehensions in Python &#8211; KDnuggets"},"content":{"rendered":"<p><img decoding=\"async\" src=\"https:\/\/wordpress-1016567-4521551.cloudwaysapps.com\/wp-content\/uploads\/2023\/11\/why-you-should-not-overuse-list-comprehensions-in-python-kdnuggets.png\" alt=\"Your KDnuggets Post - Why You Should Not Overuse List Comprehensions in Python\" width=\"100%\"><br \/><span>Image by Author<\/span><br \/>\u00a0 <\/p>\n<p>In Python, list comprehensions provide a concise syntax to create new lists from existing lists and other iterables. However, once you get used to list comprehensions you may be tempted to use them even when you shouldn&#8217;t.\u00a0<\/p>\n<p>Remember, your goal is to write simple and maintainable code; not complex code. It\u2019s often helpful to revisit the <a href=\"https:\/\/peps.python.org\/pep-0020\/\" rel=\"noopener\" target=\"_blank\">Zen of Python<\/a>, a set of aphorisms for writing clean and elegant Python, especially the following:<\/p>\n<ul>\n<li>Beautiful is better than ugly.\n<\/li>\n<li>Simple is better than complex.\n<\/li>\n<li>Readability counts.\n<\/li>\n<\/ul>\n<p>In this tutorial, we\u2019ll code three examples\u2014each more complex than the previous one\u2014where list comprehensions make the code super difficult to maintain. We\u2019ll then try to write a more maintainable version of the same.\u00a0<\/p>\n<p>So let\u2019s start coding!<\/p>\n<p>Let&#8217;s start by reviewing list comprehensions in Python. Suppose you have an existing iterable such as a list or a string. And you\u2019d like to create a new list from it. You can loop through the iterable, process each item, and append the output to a new list like so:<\/p>\n<div>\n<pre><code>new_list = []\nfor item in iterable:\n    new_list.append(output)<\/code><\/pre>\n<\/div>\n<p>\u00a0 <\/p>\n<p>But less comprehensions provide a concise one-line alternative to do the same:<\/p>\n<div>\n<pre><code>new_list = [output for item in iterable]<\/code><\/pre>\n<\/div>\n<p>\u00a0 <\/p>\n<p>In addition, you can also add filtering conditions.<\/p>\n<p>The following snippet:<\/p>\n<div>\n<pre><code>new_list = []\nfor item in iterable:\n    if condition:\n        new_list.append(output)<\/code><\/pre>\n<\/div>\n<p>\u00a0 <\/p>\n<p>Can be replaced by this list comprehension:<\/p>\n<div>\n<pre><code>new_list = [output for item in iterable if condition]<\/code><\/pre>\n<\/div>\n<p>\u00a0 <\/p>\n<p>So list comprehensions help you write Pythonic code\u2014often make your code cleaner by reducing visual noise.\u00a0<\/p>\n<p>Now let&#8217;s take three examples to understand why you shouldn&#8217;t be using list comprehensions for tasks that require super complex expressions. Because in such cases, list comprehensions\u2014instead of making your code elegant\u2014make your code difficult to read and maintain.<\/p>\n<p><strong>Problem<\/strong>: Given a number <code>upper_limit<\/code>, generate a list of all the prime numbers up to that number.<\/p>\n<p>You can break down this problem into two key ideas:<\/p>\n<ul>\n<li>Checking if a number is prime\n<\/li>\n<li>Populating a list with all the prime numbers\u00a0\n<\/li>\n<\/ul>\n<p>The list comprehension expression to do this is as shown:<\/p>\n<div>\n<pre><code>import math\n\nupper_limit = 50  \n\nprimes = [x for x in range(2, upper_limit + 1) if  x &gt; 1 and all(x % i != 0 for i in range(2, int(math.sqrt(x)) + 1))]\n\nprint(primes)<\/code><\/pre>\n<\/div>\n<p>\u00a0 <\/p>\n<p>And here\u2019s the output:<\/p>\n<div>\n<pre><code>Output &gt;&gt;&gt;\n[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]<\/code><\/pre>\n<\/div>\n<p>\u00a0 <\/p>\n<p>At first glance, it is difficult to see what is going on\u2026Let\u2019s make it better.<\/p>\n<p>Perhaps, better?<\/p>\n<div>\n<pre><code>import math\n\nupper_limit = 50  \n\nprimes = [\n\tx\n\tfor x in range(2, upper_limit + 1)\n\tif x &gt; 1 and all(x % i != 0 for i in range(2, int(math.sqrt(x)) + 1))\n]\n\nprint(primes)<\/code><\/pre>\n<\/div>\n<p>\u00a0 <\/p>\n<p>Easier to read, certainly. Now let\u2019s write a <i>truly <\/i>better version.<\/p>\n<h2>A Better Version<\/h2>\n<p>Though a list comprehension is actually a good idea to solve this problem, the logic to check for primes in the list comprehension is making it noisy.<\/p>\n<p>So let&#8217;s write a more maintainable version that moves the logic for checking if a number is prime to a separate function <code>is_prime()<\/code>. And call the function <code>is_prime()<\/code> in the comprehension expression:<\/p>\n<div>\n<pre><code>import math\n\ndef is_prime(num):\n    return num &gt; 1 and all(num % i != 0 for i in range(2, int(math.sqrt(num)) + 1))\n\nupper_limit = 50  \n\nprimes = [\n\tx\n\tfor x in range(2, upper_limit + 1)\n\tif is_prime(x)\n]\n\nprint(primes)<\/code><\/pre>\n<\/div>\n<p>\u00a0 <\/p>\n<div>\n<pre><code>Output &gt;&gt;&gt;\n[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]<\/code><\/pre>\n<\/div>\n<p>\u00a0 <\/p>\n<p><strong>Is the better version good enough? <\/strong>This makes the comprehension expression much easier to understand. It&#8217;s now clear that the expression collects all numbers up to <code>upper_limit<\/code> that are prime (where <code>is_prime()<\/code> returns True).<\/p>\n<p><strong>Problem<\/strong>: Given a matrix, find the following:<\/p>\n<ul>\n<li>All the prime numbers\u00a0\n<\/li>\n<li>The indices of the prime numbers\u00a0\n<\/li>\n<li>Sum of the primes\u00a0\n<\/li>\n<li>Prime numbers sorted in descending order\u00a0\n<\/li>\n<\/ul>\n<p>\u00a0<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/wordpress-1016567-4521551.cloudwaysapps.com\/wp-content\/uploads\/2023\/11\/why-you-should-not-overuse-list-comprehensions-in-python-kdnuggets-1.png\" alt=\"Your KDnuggets Post - Why You Should Not Overuse List Comprehensions in Python\" width=\"100%\"><br \/><span>Image by Author<\/span><br \/>\u00a0 <\/p>\n<p>To flatten the matrix and collect the list of all prime numbers, we can\u00a0 use a logic similar to the previous example.\u00a0<\/p>\n<p>However, to find the indices, we have another complex list comprehension expression (I\u2019ve formatted the code such that it is easy to read).\u00a0<\/p>\n<p>You can combine checking for primes and getting their indices in a single comprehension. But that will not make things any simpler.\u00a0<\/p>\n<p>Here\u2019s the code:<\/p>\n<div>\n<pre><code>import math\nfrom pprint import pprint\n\nmy_matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n\ndef is_prime(num):\n    return num &gt; 1 and all(num % i != 0 for i in range(2, int(math.sqrt(num)) + 1))\n\n\n# Flatten the matrix and filter to contain only prime numbers\nprimes = [\n\tx\n\tfor row in my_matrix\n\tfor x in row\n\tif is_prime(x)\n]\n\n# Find indices of prime numbers in the original matrix\nprime_indices = [\n\t(i, j)\n\tfor i, row in enumerate(my_matrix)\n\tfor j, x in enumerate(row)\n\tif x in primes\n]\n\n# Calculate the sum of prime numbers\nsum_of_primes = sum(primes)\n\n# Sort the prime numbers in descending order\nsorted_primes = sorted(primes, reverse=True)\n\n# Create a dictionary with the results\nresult = {\n\t\"primes\": primes,\n\t\"prime_indices\": prime_indices,\n\t\"sum_of_primes\": sum_of_primes,\n\t\"sorted_primes\": sorted_primes\n}\n\npprint(result)<\/code><\/pre>\n<\/div>\n<p>\u00a0 <\/p>\n<p>And the corresponding output:<\/p>\n<div>\n<pre><code>Output &gt;&gt;&gt;\n\n{'primes': [2, 3, 5, 7],\n 'prime_indices': [(0, 1), (0, 2), (1, 1), (2, 0)],\n 'sum_of_primes': 17,\n 'sorted_primes': [7, 5, 3, 2]}<\/code><\/pre>\n<\/div>\n<p>\u00a0 <\/p>\n<p>So what is a better version?\u00a0<\/p>\n<h2>A Better Version<\/h2>\n<p>Now for the better version, we can define a series of functions to separate out concerns. So that if there\u2019s a problem, you know which function to go back to and fix the logic.<\/p>\n<div>\n<pre><code>import math\nfrom pprint import pprint\n\ndef is_prime(num):\n    return num &gt; 1 and all(n % i != 0 for i in range(2, int(math.sqrt(num)) + 1))\n\ndef flatten_matrix(matrix):\n    flattened_matrix = []\n    for row in matrix:\n        for x in row:\n            if is_prime(x):\n                flattened_matrix.append(x)\n    return flattened_matrix\n\ndef find_prime_indices(matrix, flattened_matrix):\n    prime_indices = []\n    for i, row in enumerate(matrix):\n        for j, x in enumerate(row):\n            if x in flattened_matrix:\n                prime_indices.append((i, j))\n    return prime_indices\n\ndef calculate_sum_of_primes(flattened_matrix):\n    return sum(flattened_matrix)\n\ndef sort_primes(flattened_matrix):\n    return sorted(flattened_matrix, reverse=True)\n\nmy_matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n\nprimes = flatten_matrix(my_matrix)\nprime_indices = find_prime_indices(my_matrix, primes)\nsum_of_primes = calculate_sum_of_primes(primes)\nsorted_primes = sort_primes(primes)\n\nresult = {\n\t\"primes\": primes,\n\t\"prime_indices\": prime_indices,\n\t\"sum_of_primes\": sum_of_primes,\n\t\"sorted_primes\": sorted_primes\n}\n\npprint(result)<\/code><\/pre>\n<\/div>\n<p>\u00a0 <\/p>\n<p>This code also gives the same output as before.<\/p>\n<div>\n<pre><code>Output &gt;&gt;&gt;\n\n{'primes': [2, 3, 5, 7],\n 'prime_indices': [(0, 1), (0, 2), (1, 1), (2, 0)],\n 'sum_of_primes': 17,\n 'sorted_primes': [7, 5, 3, 2]}<\/code><\/pre>\n<\/div>\n<p>\u00a0 <\/p>\n<p><strong>Is the better version good enough?<\/strong> While this works for a small matrix such as the one in this example, returning a static list is generally not recommended. And for generalizing to larger dimensions, you can use <a href=\"https:\/\/www.kdnuggets.com\/2023\/02\/getting-started-python-generators.html\" rel=\"noopener\" target=\"_blank\">generators<\/a> instead.<\/p>\n<p><strong>Problem<\/strong>: Parse a given nested JSON string based on conditions and get a list of required values.<\/p>\n<p>Parsing nested JSON strings is challenging because you have to account for the different levels of nesting, the dynamic nature of the JSON response, and diverse data types in your parsing logic.<\/p>\n<p>Let&#8217;s take an example of parsing a given JSON string based on conditions to get a list of all values that are:<\/p>\n<ul>\n<li>Integers or list of integers\u00a0\n<\/li>\n<li>Strings or list of strings\u00a0\n<\/li>\n<\/ul>\n<p>You can load a JSON string into a Python dictionary using the <code>loads<\/code> function from the built-in <a href=\"https:\/\/docs.python.org\/3\/library\/json.html\" rel=\"noopener\" target=\"_blank\">json module<\/a>. So we\u2019ll have a nested dictionary over which we have a list comprehension.<\/p>\n<p>The list comprehension uses nested loops to iterate over the nested dictionary. For each value, it constructs a list based on the following conditions:<\/p>\n<ul>\n<li>If the value is not a dictionary and the key starts with &#8216;inner_key&#8217;, it uses <code>[inner_item]<\/code>.\n<\/li>\n<li>If the value is a dictionary with &#8216;sub_key&#8217;, it uses <code>[inner_item['sub_key']]<\/code>.\n<\/li>\n<li>If the value is a string or integer, it uses <code>[inner_item]<\/code>.\n<\/li>\n<li>If the value is a dictionary, it uses <code>list(inner_item.values())<\/code>.\n<\/li>\n<\/ul>\n<p>Have a look at the code snippet below:<\/p>\n<div>\n<pre><code>import json\n\njson_string = '{\"key1\": {\"inner_key1\": [1, 2, 3], \"inner_key2\": {\"sub_key\": \"value\"}}, \"key2\": {\"inner_key3\": \"text\"}}'\n\n# Parse the JSON string into a Python dictionary\ndata = json.loads(json_string)\n\n\nflattened_data = [\n\tvalue\n\tif isinstance(value, (int, str))\n\telse value\n\tif isinstance(value, list)\n\telse list(value)\n\tfor inner_dict in data.values()\n\tfor key, inner_item in inner_dict.items()\n\tfor value in (\n    \t[inner_item]\n    \tif not isinstance(inner_item, dict) and key.startswith(\"inner_key\")\n    \telse [inner_item[\"sub_key\"]]\n    \tif isinstance(inner_item, dict) and \"sub_key\" in inner_item\n    \telse [inner_item]\n    \tif isinstance(inner_item, (int, str))\n    \telse list(inner_item.values())\n\t)\n]\n\nprint(f\"Values: {flattened_data}\")<\/code><\/pre>\n<\/div>\n<p>\u00a0 <\/p>\n<p>Here\u2019s the output:<\/p>\n<div>\n<pre><code>Output &gt;&gt;&gt;\nValues: [[1, 2, 3], 'value', 'text']<\/code><\/pre>\n<\/div>\n<p>\u00a0 <\/p>\n<p>As seen, the list comprehension is very difficult to wrap your head around.\u00a0<\/p>\n<p><i>Please do yourself and others on the team a favor by never writing such code.<\/i><\/p>\n<h2>A Better Version<\/h2>\n<p>I think the following snippet using nested for loops and if-elif ladder is better. Because it\u2019s easier to understand what\u2019s going on.\u00a0<\/p>\n<div>\n<pre><code>flattened_data = []\n\nfor inner_dict in data.values():\n    for key, inner_item in inner_dict.items():\n        if not isinstance(inner_item, dict) and key.startswith(\"inner_key\"):\n            flattened_data.append(inner_item)\n        elif isinstance(inner_item, dict) and \"sub_key\" in inner_item:\n            flattened_data.append(inner_item[\"sub_key\"])\n        elif isinstance(inner_item, (int, str)):\n            flattened_data.append(inner_item)\n        elif isinstance(inner_item, list):\n            flattened_data.extend(inner_item)\n        elif isinstance(inner_item, dict):\n            flattened_data.extend(inner_item.values())\n\nprint(f\"Values: {flattened_data}\")<\/code><\/pre>\n<\/div>\n<p>\u00a0 <\/p>\n<p>This gives the expected output, too:<\/p>\n<div>\n<pre><code>Output &gt;&gt;&gt;\nValues: [[1, 2, 3], 'value', 'text']<\/code><\/pre>\n<\/div>\n<p>\u00a0 <\/p>\n<p><strong>Is the better version good enough?<\/strong> Well, not really.\u00a0<\/p>\n<p>Because if-elif ladders are often considered a code smell. You may repeat logic across branches and adding more conditions will only make the code more difficult to maintain.\u00a0<\/p>\n<p>But for this example, the if-elif ladders and nested loops the version is easier to understand than the comprehension expression, though.<\/p>\n<p>The examples we\u2019ve coded thus far should give you an idea of how overusing a Pythonic feature such as list comprehension can often become too much of a good thing. This is true not just for list comprehensions (they\u2019re the most frequently used, though) but also for dictionary and set comprehensions.<\/p>\n<p>You should always write code that\u2019s easy to understand and maintain. So try to keep things simple even if it means <strong>not<\/strong> using some Pythonic features. Keep coding!<br \/>\u00a0<br \/>\u00a0<\/p>\n<p><b><a href=\"https:\/\/twitter.com\/balawc27\" rel=\"noopener\"><strong><a href=\"https:\/\/twitter.com\/balawc27\" target=\"_blank\" rel=\"noopener noreferrer\">Bala Priya C<\/a><\/strong><\/a><\/b> is a developer and technical writer from India. She likes working at the intersection of math, programming, data science, and content creation. Her areas of interest and expertise include DevOps, data science, and natural language processing. She enjoys reading, writing, coding, and coffee! Currently, she&#8217;s working on learning and sharing her knowledge with the developer community by authoring tutorials, how-to guides, opinion pieces, and more.<\/p>\n<div class=\"crp_related     crp-text-only\"><\/p>\n<h3>More On This Topic<\/h3>\n<\/div>\n<ul class=\"plato-post-bottom-links\">\n<li class=\"plato-post-bottom-link-amplifi\">SEO Powered Content &amp; PR Distribution. <a href=\"https:\/\/www.amplifipr.com\" target=\"_blank\" rel=\"noopener\">Get Amplified Today.<\/a><\/li>\n<li class=\"plato-post-bottom-link-platodata-network\">PlatoData.Network Vertical Generative Ai. Empower Yourself. <a href=\"https:\/\/platodata.network\" target=\"_blank\" rel=\"noopener\">Access Here.<\/a><\/li>\n<li class=\"plato-post-bottom-link-platoaistream\">PlatoAiStream. Web3 Intelligence. Knowledge Amplified. <a href=\"https:\/\/wordpress-1016567-4521551.cloudwaysapps.com\" target=\"_blank\" rel=\"noopener\">Access Here.<\/a><\/li>\n<li class=\"plato-post-bottom-link-platoesg\">PlatoESG. <a href=\"https:\/\/platoesg.com\/aiwire\/carbon\/\" target=\"_blank\" rel=\"noopener\">Carbon,<\/a> <a href=\"https:\/\/platoesg.com\/aiwire\/cleantech\/\" target=\"_blank\" rel=\"noopener\">CleanTech,<\/a> <a href=\"https:\/\/platoesg.com\/aiwire\/energy\/\" target=\"_blank\" rel=\"noopener\">Energy,<\/a> <a href=\"https:\/\/platoesg.com\/aiwire\/environment\/\" target=\"_blank\" rel=\"noopener\">Environment,<\/a> <a href=\"https:\/\/platoesg.com\/aiwire\/solar\/\" target=\"_blank\" rel=\"noopener\">Solar,<\/a> <a href=\"https:\/\/platoesg.com\/aiwire\/waste-management\/\" target=\"_blank\" rel=\"noopener\">Waste Management.<\/a> <a href=\"https:\/\/platoesg.com\" target=\"_blank\" rel=\"noopener\">Access Here.<\/a><\/li>\n<li class=\"plato-post-bottom-link-platohealth\">PlatoHealth. Biotech and Clinical Trials Intelligence. <a href=\"https:\/\/platohealth.ai\" target=\"_blank\" rel=\"noopener\">Access Here.<\/a><\/li>\n<li class=\"plato-post-bottom-link-source\"><span>Source:<\/span> <a href=\"https:\/\/www.kdnuggets.com\/why-you-should-not-overuse-list-comprehensions-in-python?utm_source=rss&amp;utm_medium=rss&amp;utm_campaign=your-kdnuggets-post-why-you-should-not-overuse-list-comprehensions-in-python\" target=\"_blank\" rel=\"noopener\">https:\/\/www.kdnuggets.com\/why-you-should-not-overuse-list-comprehensions-in-python?utm_source=rss&amp;utm_medium=rss&amp;utm_campaign=your-kdnuggets-post-why-you-should-not-overuse-list-comprehensions-in-python<\/a><\/li>\n<\/ul>\n","protected":false},"author":1,"featured_media":2980750,"template":"Default","meta":{"_eb_attr":"","type":"","auto_type":false,"post":"","stream":"","stream_url":"","waveform_data":[],"duration":0,"start":0,"end":0,"bpm":0,"downloadable":false,"download_url":"","purchase_title":"","purchase_url":"","post-count-all":0,"like_count":0,"download_count":0,"editor_note":"","copyright":"","captions":[],"sources":[]},"genre":[42022],"station_tag":[38012,33649,38013,34957,21579,10944,3759,69363,70785,71983,69102,69597,69377,69598,10520,75032,71137,75435,69015,3629,48576,4262,13775,4263,9087,40086,69352,69382,10996,3761,68956,12470,12467,68950,18340,9773,68867,48551,34374,3718,48552,48553,42276,39877,30993,48554,13212,10620,12619,12341,14383,39297,29071,10228,69017,48555,47685,3886,48563,4145,40290,11483,39832,4962,77290,74726,40050,3720,69367,4963,10623,46457,40139,3690,9226,36222,72407,9416,13337,40181,74917,6978,16593,12195,11928,11002,11927,3642,8865,74674,5167,43888,26408,9163,11470,13827,40110,69099,9423,9366,14017,40011,69378,70616,40054,9165,39858,9166,12390,11931,9712,9417,70538,10519,69742,40056,3729,4382,34902,12637,30994,3772,3730,9874,48556,40316,13776,4691,12621,11489,9007,40035,9229,34012,40168,40059,10469,19651,9607,9167,4491,5428,48557,3952,9238,10060,69342,3694,12342,18595,3650,48567,3906,12478,69344,22734,19265,10371,4693,16425,40062,3652,11694,68944,3653,33104,69019,43209,13752,3805,13648,4597,12657,4572,9704,4010,69921,75152,13568,48580,72400,3911,4087,4965,69875,13214,10849,42525,13777,11042,3737,5763,8465,26118,12349,10997,9483,26946,69523,10517,43581,16265,9486,69925,20482,7017,68945,10785,4748,48559,69346,48560,69347,17454,68953,4731,68946,3662,14287,3663,19503,69348,48879,68865,13672,7457,8453,9642,30372,12190,35038,9231,9221,11810,5195,9054,15313,15551,4502,68947,41194,10148,14294,10030,10097,9836,3776,39868,4433,12142,40651,3810,40338,19892,48565,13653,4118,69188,69193,47328,3778,3976,12254,69362,39869,12345,9232,4461,13654,4548,43850,72547,3779,4392,11458,3714,10375,67549,39843,76096,28207,15627,72939,39844,10316,10092,4126,75195,68954,48561,13215,39845,48569,69447,13778,13284,69351,68948,28884,13569,9055,72630,19267,22249,40077,70380,36021,6313,69591,12348,9872,10367,68866,71140,69023,3782,24736,12835,69191,77607,68959,48571,9178,4368,69189,36520,11454,69024,27168,48562,9608,4240,40680,40104,41870,5152,467,4927,68949,13217,40472,14555],"artist":[42028],"mood":[],"activity":[],"_links":{"self":[{"href":"https:\/\/platodata.io\/wp-json\/wp\/v2\/station\/2980748"}],"collection":[{"href":"https:\/\/platodata.io\/wp-json\/wp\/v2\/station"}],"about":[{"href":"https:\/\/platodata.io\/wp-json\/wp\/v2\/types\/station"}],"author":[{"embeddable":true,"href":"https:\/\/platodata.io\/wp-json\/wp\/v2\/users\/1"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/platodata.io\/wp-json\/wp\/v2\/media\/2980750"}],"wp:attachment":[{"href":"https:\/\/platodata.io\/wp-json\/wp\/v2\/media?parent=2980748"}],"wp:term":[{"taxonomy":"genre","embeddable":true,"href":"https:\/\/platodata.io\/wp-json\/wp\/v2\/genre?post=2980748"},{"taxonomy":"station_tag","embeddable":true,"href":"https:\/\/platodata.io\/wp-json\/wp\/v2\/station_tag?post=2980748"},{"taxonomy":"artist","embeddable":true,"href":"https:\/\/platodata.io\/wp-json\/wp\/v2\/artist?post=2980748"},{"taxonomy":"mood","embeddable":true,"href":"https:\/\/platodata.io\/wp-json\/wp\/v2\/mood?post=2980748"},{"taxonomy":"activity","embeddable":true,"href":"https:\/\/platodata.io\/wp-json\/wp\/v2\/activity?post=2980748"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}