{"id":74599,"date":"2019-12-26T10:12:53","date_gmt":"2019-12-26T04:42:53","guid":{"rendered":"https:\/\/techvidvan.com\/tutorials\/?p=74599"},"modified":"2024-08-22T20:24:19","modified_gmt":"2024-08-22T14:54:19","slug":"python-operator-precedence","status":"publish","type":"post","link":"https:\/\/techvidvan.com\/tutorials\/python-operator-precedence\/","title":{"rendered":"Python Operator Precedence – Learn how to perform operations in Python"},"content":{"rendered":"

There are many different types of operators. When evaluating complex expressions like 5+2*4%6-1 and 13 or 3<\/strong> one might easily get confused about in which order the operations will be performed. This Python operator precedence article will help you in understanding how these expressions are evaluated<\/strong> and the order of precedence<\/strong> Python follows.<\/p>\n

Python Operators Precedence Table<\/h3>\n

Here we have a table that is arranged in the ascending order of precedence of operators.<\/p>\n

The new Assignment expression (:=) operator<\/strong> from Python 3.8<\/strong> onwards has the lowest precedence<\/strong> while parentheses()<\/strong> have the highest precedence<\/strong>.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Operator<\/b><\/td>\nDescription<\/b><\/td>\n<\/tr>\n
:=<\/span><\/td>\nAssignment expression (Lowest precedence)\u00a0<\/span><\/td>\n<\/tr>\n
lambda<\/span><\/td>\nLambda expression<\/span><\/td>\n<\/tr>\n
if-else<\/span><\/td>\nConditional expression<\/span><\/td>\n<\/tr>\n
or<\/span><\/td>\nBoolean OR<\/span><\/td>\n<\/tr>\n
and<\/span><\/td>\nBoolean AND<\/span><\/td>\n<\/tr>\n
not<\/span> x<\/span><\/td>\nBoolean NOT<\/span><\/td>\n<\/tr>\n
<<\/span>, <\/span><=<\/span>, <\/span>><\/span>, <\/span>>=<\/span>,\u00a0<\/span><\/td>\nComparison operators<\/span><\/td>\n<\/tr>\n
!=<\/span>, <\/span>==<\/span><\/td>\nEquality operators<\/span><\/td>\n<\/tr>\n
in<\/span>, <\/span>not in<\/span>, <\/span>is<\/span>, <\/span>is not<\/span>,<\/span><\/td>\nIdentity operators, membership operators<\/span><\/td>\n<\/tr>\n
|<\/span><\/td>\nBitwise OR<\/span><\/td>\n<\/tr>\n
^<\/span><\/td>\nBitwise XOR<\/span><\/td>\n<\/tr>\n
&<\/span><\/td>\nBitwise AND<\/span><\/td>\n<\/tr>\n
<<<\/span>, <\/span>>><\/span><\/td>\nLeft and right Shifts<\/span><\/td>\n<\/tr>\n
+<\/span>, <\/span>–<\/span><\/td>\nAddition and subtraction<\/span><\/td>\n<\/tr>\n
*<\/span>, <\/span>@<\/span>, <\/span>\/<\/span>, <\/span>\/\/<\/span>, <\/span>%<\/span><\/td>\nMultiplication, matrix multiplication, division, floor division, remainder<\/span><\/td>\n<\/tr>\n
+x<\/span>, <\/span>-x<\/span>, <\/span>~x<\/span><\/td>\nUnary plus, Unary minus, bitwise NOT<\/span><\/td>\n<\/tr>\n
**<\/span><\/td>\nExponentiation<\/span><\/td>\n<\/tr>\n
await<\/span> x<\/span><\/td>\nAwait expression<\/span><\/td>\n<\/tr>\n
x[index]<\/span>, <\/span>x[index:index]<\/span>, <\/span>x(arguments…)<\/span>, <\/span>x.attribute<\/span><\/td>\nSubscription, slicing, call, attribute reference<\/span><\/td>\n<\/tr>\n
(expressions…)<\/span>, <\/span>[expressions…]<\/span>, <\/span><\/p>\n

{key: value…}<\/span>, <\/span>{expressions…}<\/span><\/td>\n

Binding or parenthesized expression, list display, dictionary display, set display<\/span><\/td>\n<\/tr>\n
()<\/span><\/td>\nParentheses (Highest precedence)\u00a0<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

What are Expressions in Python?<\/h3>\n

Before we move further, let\u2019s first understand what are expressions.<\/p>\n

An expression is made with combinations of variables<\/strong>, values<\/strong>, operators<\/strong> and function calls. <\/strong>The Python interpreter evaluates<\/strong> the valid expression.<\/p>\n

Have a look at a very simple expression.<\/p>\n

5 - 2<\/pre>\n
Output: <\/strong><\/p>\n
3<\/div>\n
5-2 is an expression that contains a single operator<\/strong>.<\/p>\n
However, an expression can also contain multiple operators<\/strong> and operands<\/strong>.<\/p>\n
10-5\/5<\/pre>\n
Output: <\/strong><\/p>\n
9.0<\/div>\n
In this expression, it first divided<\/strong> the 5\/5 and then subtracted<\/strong> the result from 10 because, in Python, the division operator has higher precedence<\/strong> than subtraction.<\/p>\n
Let\u2019s look at this example:<\/p>\n
(10-5)\/5<\/pre>\n
Output: <\/strong><\/p>\n
1.0<\/div>\n
Here, with the use of parentheses<\/strong>, we force the interpreter to first evaluate the expression inside<\/strong> the parentheses and then continue the overall evaluation.<\/p>\n
Python Operators Precedence Rule – PEMDAS<\/h3>\n
You might have heard about the BODMAS rule<\/strong> in your school’s mathematics class. Python also uses a similar type of rule known as PEMDAS<\/strong>.<\/p>\n
P –<\/strong> Parentheses
\nE –<\/strong> Exponentiation
\nM –<\/strong> Multiplication
\nD –<\/strong> Division
\nA –<\/strong> Addition
\nS –<\/strong> Subtraction<\/p>\n
The precedence of operators is listed from High to low<\/strong>. To remember the abbreviations, we have a funny mnemonic \u201cPlease Excuse My Dear Aunt Sally\u201d<\/strong>.\"python<\/a><\/p>\n
Now we apply the PEMDAS rule and evaluate the following expression –<\/p>\n
((((6+4)*2)-10)\/\/2)-4*2<\/pre>\n
Output: <\/strong><\/p>\n
-3.0<\/div>\n
How did we get -3?<\/p>\n
Let\u2019s break down the evaluation:<\/p>\n
(6+4) = 10
\n(10*2) = 20
\n(20-10) = 10
\n(10\/\/2) = 5
\n4*2 = 8
\n5-8 = -3<\/p>\n
Associativity of Operators in Python<\/h3>\n
If you observed the precedence table, you may have noticed that many cells had more than one operator<\/strong> which means that they have the same precedence<\/strong>.<\/p>\n
So then, which will be evaluated first is managed by the associativity of operators<\/strong>.<\/p>\n
1. Associative Operators<\/h4>\n
The associative operators are division<\/strong>, multiplication<\/strong>, remainder<\/strong>, etc. and the expressions will be evaluated from left to right<\/strong>. Almost all operators except the exponentiation(**) operator<\/strong> support left-to-right associativity.<\/p>\n
This means that in an expression with multiple associative operators of the same precedence, the operations are performed sequentially from left to right, ensuring consistent and predictable results.<\/p>\n
Example 1:<\/strong><\/p>\n
Suppose modulus(%)<\/strong> and division(\/)<\/strong> operators<\/strong> have the same precedence<\/strong>. So, if both operators are present in an expression, then the left one<\/strong> is evaluated first<\/strong>.<\/p>\n
45 % 10 \/ 2<\/pre>\n
Output: <\/strong><\/p>\n
2.5<\/div>\n
First, 45%10 gives 5 and then 5\/2 gives us 2.5 as output. If this was evaluated from right to left, we would get a different<\/strong> output.<\/p>\n
45% (10\/2)<\/pre>\n
Output:<\/strong><\/p>\n
0.0<\/div>\n
Here, we forced<\/strong> the expression to evaluate from right to left.<\/p>\n
Example 2:<\/strong><\/p>\n
The exponentiation operator<\/strong> evaluates from right to left.<\/p>\n
2**2**3<\/pre>\n
Output:<\/strong><\/p>\n
256<\/div>\n
If we want to see the output of left to right, we can use parentheses<\/strong>.<\/p>\n
(2**2)**3<\/pre>\n
Output:<\/strong><\/p>\n
64<\/div>\n
2. Non-Associative Operators<\/h4>\n
The comparison operator and the assignment operators do not support associativity<\/strong> which means that an expression like 10<20<30<\/strong> doesn\u2019t mean (10<20)<30<\/strong> or 10<(20<30 )<\/strong>. They both mean the same thing as they are evaluated from left to right<\/strong>. This ensures logical evaluation without ambiguity.<\/p>\n
The statement 10<20<30<\/strong> means 10<20<\/strong> and 20<30<\/strong>. You can also chain the assignment operators in any order and they will behave the same way.<\/p>\n
a = b = c = d<\/strong> will be same as b = a = d = c<\/strong> or d = c = b = a<\/strong>.<\/p>\n
Short-Circuiting in Python Operators Precedence<\/h3>\n
As we saw how Python mostly evaluates the expression from left-to-right<\/strong>.<\/p>\n
In expression with \u2018and\u2019<\/strong>, \u2018or\u2019<\/strong> operators<\/strong>, Python uses Short-Circuiting<\/strong> which means that it will evaluate the right side only when it is needed<\/strong>.<\/p>\n
You\u2019ll understand this better with examples.<\/p>\n
1. Short-circuiting with and\/or<\/h4>\n
The boolean operation<\/strong> will stop executing when we arrive at the truth value of the expression.<\/p>\n
    \n
  • x or y: Evaluates y only when x is false.<\/li>\n
  • x and y: Evaluates y only when x is true.<\/li>\n<\/ul>\n
    0 or \u201cHey\u201d and 1<\/pre>\n
    Output:\u00a0<\/strong><\/p>\n
    1<\/div>\n
    0 or \u201cHey\u201d returns \u201cHey\u201d
    \n\u201cHey\u201d and 1 returns 1<\/p>\n
    2. Short-circuiting with all()\/ any()<\/h4>\n
    The inbuilt functions all()<\/strong> and any()<\/strong> also supports short-circuiting<\/strong>.<\/p>\n
      \n
    • all()<\/strong> function checks that all statements should be \u2018True\u2019.<\/li>\n
    • So when the first \u2018False\u2019 statement occurs, it stops<\/strong> further executing and returns False<\/strong>.<\/li>\n<\/ul>\n
      def short_ciruit(i):\r\n  print(\u201cExecuting\u201d)\r\n  return i\r\n\r\nprint(all(short_circuit(i) for i in [1,2,3,0,5,6] ) )<\/pre>\n
      Output:<\/strong><\/p>\n
      Executing
      \nExecuting
      \nExecuting
      \nExecuting
      \nFalse<\/div>\n
        \n
      • any()<\/strong> function returns \u201cTrue\u201d if one of the statements is true.<\/li>\n
      • So, when the first \u2018True\u2019 statement occurs, we don\u2019t need to execute<\/strong> any further and simply return \u201cTrue\u201d<\/strong>.<\/li>\n<\/ul>\n
        def short_ciruit(i):\r\n  print(\u201cExecuting\u201d)\r\n  return i\r\n\r\nprint(any(short_circuit(i) for i in [0,0,3,0,5,6] ) )<\/pre>\n
        Output:<\/strong><\/p>\n
        Executing
        \nExecuting
        \nExecuting
        \nTrue<\/div>\n
        3. Short-circuiting with conditional operators<\/h4>\n
        Conditional operators<\/strong> also follow short-circuiting. Let\u2019s see it with an example.<\/p>\n
        def check(i)\r\n    \"Watch how this unfurls with conditional operators like > and <.\r\n     Have a look at Python Bitwise Operator\"\r\n     return i\r\n\r\nprint(5>20>check(50))<\/pre>\n
        Output:<\/strong><\/p>\n
        False<\/div>\n
        The statement stopped executing when the statement becomes false and it was no longer needed to execute it further so the check(50) method<\/strong> didn\u2019t run.<\/p>\n
        Summary<\/h3>\n
        In this article, we studied the important topic of Python operators precedence table<\/strong>. We understood the rules of operator precedence and how Python evaluates complex expressions. Some operators are associative<\/strong> while some are non-associative<\/strong>.<\/p>\n
        Later on, we saw more on short-circuiting<\/strong> that Python stops executing when it is sure of the result and thus it doesn\u2019t need to execute code any further.<\/p>\n","protected":false},"excerpt":{"rendered":"
        There are many different types of operators. When evaluating complex expressions like 5+2*4%6-1 and 13 or 3 one might easily get confused about in which order the operations will be performed. This Python operator...<\/p>\n","protected":false},"author":1,"featured_media":74720,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1053],"tags":[1142,1144,1115,1146,1148,1150],"class_list":["post-74599","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-python","tag-associativity-of-operators-in-python","tag-operator-precedence-in-python","tag-python-operator-precedence","tag-python-operator-precedence-table","tag-python-rules","tag-what-are-expressions-in-python"],"yoast_head":"\nPython Operator Precedence - Learn how to perform operations in Python - TechVidvan<\/title>\n<meta name=\"description\" content=\"Python Operator Precedence - Explore precedence table in Python, expressions in Python, PEMDAS\u00a0rule, Short-Circuiting in Python.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/techvidvan.com\/tutorials\/python-operator-precedence\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Python Operator Precedence - Learn how to perform operations in Python - TechVidvan\" \/>\n<meta property=\"og:description\" content=\"Python Operator Precedence - Explore precedence table in Python, expressions in Python, PEMDAS\u00a0rule, Short-Circuiting in Python.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/techvidvan.com\/tutorials\/python-operator-precedence\/\" \/>\n<meta property=\"og:site_name\" content=\"TechVidvan\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/TechVidvan\/\" \/>\n<meta property=\"article:published_time\" content=\"2019-12-26T04:42:53+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-08-22T14:54:19+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2019\/12\/Python-operator-precedence-1.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"802\" \/>\n\t<meta property=\"og:image:height\" content=\"420\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"TechVidvan Team\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@vidvantech\" \/>\n<meta name=\"twitter:site\" content=\"@vidvantech\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"TechVidvan Team\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"5 minutes\" \/>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Python Operator Precedence - Learn how to perform operations in Python - TechVidvan","description":"Python Operator Precedence - Explore precedence table in Python, expressions in Python, PEMDAS\u00a0rule, Short-Circuiting in Python.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/techvidvan.com\/tutorials\/python-operator-precedence\/","og_locale":"en_US","og_type":"article","og_title":"Python Operator Precedence - Learn how to perform operations in Python - TechVidvan","og_description":"Python Operator Precedence - Explore precedence table in Python, expressions in Python, PEMDAS\u00a0rule, Short-Circuiting in Python.","og_url":"https:\/\/techvidvan.com\/tutorials\/python-operator-precedence\/","og_site_name":"TechVidvan","article_publisher":"https:\/\/www.facebook.com\/TechVidvan\/","article_published_time":"2019-12-26T04:42:53+00:00","article_modified_time":"2024-08-22T14:54:19+00:00","og_image":[{"width":802,"height":420,"url":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2019\/12\/Python-operator-precedence-1.jpg","type":"image\/jpeg"}],"author":"TechVidvan Team","twitter_card":"summary_large_image","twitter_creator":"@vidvantech","twitter_site":"@vidvantech","twitter_misc":{"Written by":"TechVidvan Team","Est. reading time":"5 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/techvidvan.com\/tutorials\/python-operator-precedence\/#article","isPartOf":{"@id":"https:\/\/techvidvan.com\/tutorials\/python-operator-precedence\/"},"author":{"name":"TechVidvan Team","@id":"https:\/\/techvidvan.com\/tutorials\/#\/schema\/person\/e9c26e74dd3d87421f7ada9433b8cd22"},"headline":"Python Operator Precedence – Learn how to perform operations in Python","datePublished":"2019-12-26T04:42:53+00:00","dateModified":"2024-08-22T14:54:19+00:00","mainEntityOfPage":{"@id":"https:\/\/techvidvan.com\/tutorials\/python-operator-precedence\/"},"wordCount":994,"commentCount":0,"publisher":{"@id":"https:\/\/techvidvan.com\/tutorials\/#organization"},"image":{"@id":"https:\/\/techvidvan.com\/tutorials\/python-operator-precedence\/#primaryimage"},"thumbnailUrl":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2019\/12\/Python-operator-precedence-1.jpg","keywords":["associativity of operators in python","operator precedence in python","python operator precedence","python operator precedence table","python rules","What are expressions in python"],"articleSection":["Python Tutorials"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/techvidvan.com\/tutorials\/python-operator-precedence\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/techvidvan.com\/tutorials\/python-operator-precedence\/","url":"https:\/\/techvidvan.com\/tutorials\/python-operator-precedence\/","name":"Python Operator Precedence - Learn how to perform operations in Python - TechVidvan","isPartOf":{"@id":"https:\/\/techvidvan.com\/tutorials\/#website"},"primaryImageOfPage":{"@id":"https:\/\/techvidvan.com\/tutorials\/python-operator-precedence\/#primaryimage"},"image":{"@id":"https:\/\/techvidvan.com\/tutorials\/python-operator-precedence\/#primaryimage"},"thumbnailUrl":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2019\/12\/Python-operator-precedence-1.jpg","datePublished":"2019-12-26T04:42:53+00:00","dateModified":"2024-08-22T14:54:19+00:00","description":"Python Operator Precedence - Explore precedence table in Python, expressions in Python, PEMDAS\u00a0rule, Short-Circuiting in Python.","breadcrumb":{"@id":"https:\/\/techvidvan.com\/tutorials\/python-operator-precedence\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/techvidvan.com\/tutorials\/python-operator-precedence\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/techvidvan.com\/tutorials\/python-operator-precedence\/#primaryimage","url":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2019\/12\/Python-operator-precedence-1.jpg","contentUrl":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2019\/12\/Python-operator-precedence-1.jpg","width":802,"height":420,"caption":"Operator precedence in python"},{"@type":"BreadcrumbList","@id":"https:\/\/techvidvan.com\/tutorials\/python-operator-precedence\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/techvidvan.com\/tutorials\/"},{"@type":"ListItem","position":2,"name":"Python Operator Precedence – Learn how to perform operations in Python"}]},{"@type":"WebSite","@id":"https:\/\/techvidvan.com\/tutorials\/#website","url":"https:\/\/techvidvan.com\/tutorials\/","name":"TechVidvan Blogs","description":"","publisher":{"@id":"https:\/\/techvidvan.com\/tutorials\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/techvidvan.com\/tutorials\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/techvidvan.com\/tutorials\/#organization","name":"TechVidvan","url":"https:\/\/techvidvan.com\/tutorials\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/techvidvan.com\/tutorials\/#\/schema\/logo\/image\/","url":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2024\/03\/techvidvan-logo-200x50-1.webp","contentUrl":"https:\/\/techvidvan.com\/tutorials\/wp-content\/uploads\/2024\/03\/techvidvan-logo-200x50-1.webp","width":200,"height":50,"caption":"TechVidvan"},"image":{"@id":"https:\/\/techvidvan.com\/tutorials\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/TechVidvan\/","https:\/\/x.com\/vidvantech"]},{"@type":"Person","@id":"https:\/\/techvidvan.com\/tutorials\/#\/schema\/person\/e9c26e74dd3d87421f7ada9433b8cd22","name":"TechVidvan Team","description":"The TechVidvan Team delivers practical, beginner-friendly tutorials on programming, Java, Python, C++, DSA, AI, ML, data Science, Android, Flutter, MERN, Web Development, and technology. Our experts are here to help you upskill and excel in today\u2019s tech industry."}]}},"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/posts\/74599","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/comments?post=74599"}],"version-history":[{"count":2,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/posts\/74599\/revisions"}],"predecessor-version":[{"id":447701,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/posts\/74599\/revisions\/447701"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/media\/74720"}],"wp:attachment":[{"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/media?parent=74599"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/categories?post=74599"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/techvidvan.com\/tutorials\/wp-json\/wp\/v2\/tags?post=74599"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}