{"id":8851,"date":"2018-02-21T10:59:19","date_gmt":"2018-02-21T05:29:19","guid":{"rendered":"https:\/\/data-flair.training\/blogs\/?p=8851"},"modified":"2026-04-23T15:50:36","modified_gmt":"2026-04-23T10:20:36","slug":"python-lambda-expression","status":"publish","type":"post","link":"https:\/\/data-flair.training\/blogs\/python-lambda-expression\/","title":{"rendered":"Python Lambda Expression – Declaring Lambda Expression & Its Defaults"},"content":{"rendered":"

In this Python Tutorial, we will study What is Python Lambda Expression with its syntax and examples.<\/p>\n

Moreover, we will study how to and when to declare a Lambda Expression in Python, Python Lambda with inbuilt Python lambda functions, and some Python functions are: reduce(), map(), and filter().<\/p>\n

When creating\u00a0functions in Python, we use the def keyword. We bind them to a name while doing so.<\/p>\n

But sometimes, we may want to declare a function anonymously. Or we may want to use a function only once. In such a case, defining a function seems a bit extra.<\/p>\n

So, let’s start learning Lambda Expression in Python.<\/p>\n

\"Python<\/a>

Python Lambda Expression<\/p><\/div>\n

What is a Python Lambda Expression?<\/span><\/h3>\n

Python lambda expression\u00a0allows us to define a function anonymously. It is worthwhile to note that it is an expression, not a statement.<\/p>\n

That is, it returns a value; it has an implicit return statement. The following is the\u00a0Python syntax\u00a0of a lambda expression in Python.<\/p>\n

lambda [arg1,arg2,..]:[expression]<\/p>\n

Where you place a lambda expression in Python, it returns the value of the expression.<\/p>\n

Advantages of lambda expression in Python:<\/strong><\/p>\n

    \n
  • Short code:<\/strong> It lets you write the function in one line, avoiding unnecessary code.<\/li>\n
  • No proper definition:<\/strong> you don\u2019t have to use the define function for simple operations.<\/li>\n
  • Useful for quick operations:<\/strong> It can be useful when you need a function temporarily.<\/li>\n
  • Readable:<\/strong> It helps in making the code simple and easy to understand.<\/li>\n<\/ul>\n

    How to Declare a Python Lambda Expression?<\/span><\/h3>\n

    To declare a lambda expression in Python, you use the lambda keyword.<\/p>\n

    >>> lambda e:e-2<\/pre>\n
    Output<\/strong><\/p>\n
    \n
    <function <lambda> at 0x03DBA978><\/p>\n<\/div>\n
    You can assign it to a variable if you want to be able to call it again later.<\/p>\n
    >>> downbytwo=lambda e:e-2<\/pre>\n
    Here, e is the argument, and e-2 is the expression. Then you would call it like you would call any other Python Lambda function.<\/p>\n
    Here, we passed the integer 1 as an argument.<\/p>\n
    >>> downbytwo(1)<\/pre>\n
    Output<\/strong><\/p>\n
    -1<\/div>\n
    You can also pass an argument along with the declaration. Use parentheses for this.<\/p>\n
    >>> (lambda e:e-2)(1)<\/pre>\n
    Output<\/strong><\/p>\n
    \n
    -1<\/p>\n<\/div>\n
    What Exactly is an Expression in Python?<\/span><\/h3>\n
    As we\u2019ve seen, the expression is what the Python3 lambda returns, so we must be curious about what qualifies as an expression.<\/p>\n
    An expression here is what you would put in the return statement of a Python Lambda function. The following items qualify as expressions.<\/p>\n
    1. Arithmetic operations <\/strong>like a+b and a**b<\/p>\n
    2. Function calls <\/strong>like sum(a,b)<\/p>\n
    3. A print statement<\/strong>\u00a0like print(\u201cHello\u201d)<\/p>\n
    Other things, like an assignment statement, cannot be provided as an expression to a Python lambda because it does not return anything, not even None.<\/p>\n
    When to Use Which Lambda Expression in Python?
    \n<\/span><\/h3>\n
    Like we\u2019ve seen so far, Python lambda expressions may take arguments and take one expression. The value of this expression is what it returns after evaluating.<\/p>\n
    Python Lambda expression isn\u2019t necessary, but it\u2019s handy in certain situations. These are:<\/p>\n
    1. When you have only a single statement to execute in your Python Lambda function<\/strong><\/h4>\n
    Suppose we want to print a Hello in the body of a function printhello(). In this function\u2019s body, we have only one line of code.<\/p>\n
    >>> def printhello():\r\n       print(\"Hello\")\r\n>>> printhello()<\/pre>\n
    Output<\/strong><\/p>\n
    Hello<\/div>\n
    Now, let\u2019s do this with a Python lambda expression.<\/p>\n
    >>> (lambda :print(\"Hello\"))()<\/pre>\n
    Output<\/strong><\/p>\n
    Hello<\/div>\n
    Notice that we did not provide any arguments here. We\u2019ll discuss this in a later section in this article. Let\u2019s take another example yet.<\/p>\n
    >>> z=lambda a=2:print(\"Hello\")\r\n>>> z()<\/pre>\n
    Output<\/strong><\/p>\n
    \n
    Hello<\/p>\n<\/div>\n
    2. When you need to call that code only once<\/strong><\/h4>\n
    One of the main reasons why we use functions, apart from modularity, is the reusability of code.<\/p>\n
    But when you want to need some code only once, or less often, you may use a Python lambda expression in place of defining a function for it.<\/p>\n
    Defaults in Python Lambda Expression<\/span><\/h3>\n
    In Python, and in other languages like C++, we can specify default arguments.<\/p>\n
    But what is that? Suppose a function func1() has an arity of 2 with parameters a and b.<\/p>\n
    What happens if the user provides only one argument or none? This is why you may want to provide default values for your parameters.<\/p>\n
    Let\u2019s take an example.<\/p>\n
    >>> def func1(a=2,b=3):\r\n        print(a,' ',b)\r\n>>> func1()<\/pre>\n
    Output<\/strong><\/p>\n
    \n
    2 \u00a0\u00a03<\/p>\n<\/div>\n
    >>> func1(3)<\/pre>\n
    Output<\/strong><\/p>\n
    3\u00a0\u00a0 3<\/div>\n
    Here, the default values for a and b are 2 and 3, respectively.
    \nTo call as y(), need default arguments:<\/p>\n
    >>> o=lambda x=1,y=2,z=3:x+y+z\r\n>>> o(2,3)<\/pre>\n
    Output<\/strong><\/p>\n
    \n
    8<\/p>\n<\/div>\n
    >>> o(2)<\/pre>\n
    Output<\/strong><\/p>\n
    \n
    7<\/p>\n<\/div>\n
    >>> o<\/pre>\n
    Output<\/strong><\/p>\n
    \n
    <function <lambda> at 0x00A46150><\/p>\n<\/div>\n
    >>> o()<\/pre>\n
    Output<\/strong><\/p>\n
    \n
    6<\/p>\n<\/div>\n
    Python Lambda Expression Syntax<\/span><\/h3>\n
    We\u2019ve seen how we declare a lambda expression in Python, but where there are building blocks, there are possibilities. So, let\u2019s see what we can or can\u2019t do with a lambda.<\/p>\n
    1. Python Arguments<\/span><\/h4>\n
    One or more variables appearing in the expression may be declared previously. But if it\u2019s there in the arguments, either it should have a default value or must be passed as an argument to the call.<\/p>\n
    >>> a,b=1,2\r\n>>> y=lambda a,b:a+b\r\n>>> y()<\/pre>\n
    Output<\/strong><\/p>\n
    \n
    Traceback (most recent call last):File “<pyshell#167>”, line 1, in <module><\/p>\n
    y()<\/p>\n
    TypeError: <lambda>() missing 2 required positional arguments: \u2018a\u2019 and \u2018b\u2019<\/p>\n<\/div>\n
    Here, both a and b are missing values.<\/p>\n
    >>> y=lambda a:a+b\r\n>>> y()<\/pre>\n
    Output<\/strong><\/p>\n
    \n
    Traceback (most recent call last):File “<pyshell#169>”, line 1, in <module><\/p>\n
    y()<\/p>\n
    TypeError: <lambda>() missing 1 required positional argument: \u2018a\u2019<\/p>\n<\/div>\n
    The variable a is still missing a value.<\/p>\n
    >>> y=lambda :a+b\r\n>>> y()<\/pre>\n
    Output<\/strong><\/p>\n
    3<\/div>\n
    Finally, since no argument here is missing a value, it works just fine.<\/p>\n
    2. Omitting Arguments<\/span><\/h4>\n
    It isn\u2019t mandatory to provide arguments to a lambda expression in Python, it works fine without them.<\/p>\n
    >>> y=lambda :2+3\r\n>>> y()<\/pre>\n
    Output<\/strong><\/p>\n
    5<\/div>\n
    Another example would be where the expression is a print statement.<\/p>\n
    >>> (lambda :print(\"Hi\"))()<\/pre>\n
    Output<\/strong><\/p>\n
    Hi<\/div>\n
    Hence, we conclude that omitting arguments is acceptable.<\/p>\n
    3. Omitting the Expression<\/span><\/h4>\n
    Now let\u2019s try if it works without an expression.<\/p>\n
    >>> y=lambda a,b:<\/pre>\n
    Output<\/strong><\/p>\n
    SyntaxError: invalid syntax<\/div>\n
    Clearly, it didn\u2019t work. And why would it? The expression\u2019s value is what it returns, so without an expression, it would be a waste of time.<\/p>\n
    Python Lambdas with In-Built Functions<\/span><\/h3>\n
    There are some built-in functions, like filter() and map(), on which we can apply a Python lambda expression to filter out elements from a list.<\/p>\n
    Let\u2019s see how. First, we take a list called numbers.<\/p>\n
    >>> numbers=[0,1,2,3,4,5,6,7,8,9,10]<\/pre>\n
    Next, we take a lambda function as follows.
    \nlambda x:x%3==0<\/p>\n
    1. filter() in python<\/span><\/h4>\n
    The filter() function takes two parameters- a function, and a list to operate on. Finally, we apply the list() function on this to return a list.<\/p>\n
    >>> list(filter(lambda x:x%3==0,numbers))<\/pre>\n
    Output<\/strong><\/p>\n
    [0, 3, 6, 9]<\/div>\n
    This is the final code for our purpose, and guess what it does.<\/p>\n
    Well, this code takes the list \u2018numbers\u2019, and filters out all elements from it except those which do not successfully divide by 3.<\/p>\n
    Note that this does not alter the original list.<\/p>\n
    2. map() in python<\/span><\/h4>\n
    The map() function, unlike the filter() function, returns values of the expression for each element in the list. Let\u2019s take the same list \u2018numbers\u2019.<\/p>\n
    >>> list(map(lambda x:x%3==0,numbers))<\/pre>\n
    Output<\/strong><\/p>\n
    [True, False, False, True, False, False, True, False, False, True, False]<\/div>\n
    3. reduce() in python<\/span><\/h4>\n
    Lastly, the reduce() function takes two parameters- a function, and a list.<\/p>\n
    It performs computation on sequential pairs in the list and returns one output. But to use it, you must import it from the functools module.<\/p>\n
    >>> from functools import reduce\r\n>>> reduce(lambda x,y:y-x,numbers)<\/pre>\n
    Output<\/strong><\/p>\n
    5<\/div>\n
    Let\u2019s perform a dry run.
    \n1-0=1
    \n2-1=1
    \n3-1=2
    \n4-2=2
    \n5-2=3
    \n6-3=3
    \n7-3=4
    \n8-4=4
    \n9-4=5
    \n10-5=5
    \nHence, it outputs 5.<\/p>\n
    Let\u2019s take another example.<\/p>\n
    >>> reduce(lambda x,y:y+x,numbers)<\/pre>\n
    Output<\/strong><\/p>\n
    55<\/div>\n
    Try doing the same thing here for y+x instead; you should get 55.<\/p>\n
    So, this was all about Python lambda expression. Hope you like our expression.<\/p>\n
    Python Interview Questions on Lambda Expression<\/h3>\n
      \n
    1. What is a Lambda Expression in Python?<\/li>\n
    2. How to write a Lambda Expression in Python?<\/li>\n
    3. What is the advantage of a Lambda Expression in Python?<\/li>\n
    4. Explain the Lambda keyword in Python?<\/li>\n
    5. What is the syntax of a Lambda function in Python?<\/li>\n<\/ol>\n
      Conclusion<\/span><\/h3>\n
      That\u2019s all for today. We learned quite a bit about Python3 lambda expression with syntax, how to create Lambda expressions in Python.<\/p>\n
      Then we saw what qualifies as an expression, and also learned how to provide default arguments in Python Lambda expressions.<\/p>\n
      Finally, we tried out three functions, filter(), map(), and reduce(), to make use of lambdas. A lambda, as compared to a normal function, offers its own benefits.<\/p>\n","protected":false},"excerpt":{"rendered":"
      In this Python Tutorial, we will study What is Python Lambda Expression with its syntax and examples. Moreover, we will study how to and when to declare a Lambda Expression in Python, Python Lambda...<\/p>\n","protected":false},"author":5,"featured_media":8858,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[46],"tags":[3718,8066,8068,10632,16507,14089],"class_list":["post-8851","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-python","tag-defaults-in-python-lambda","tag-lambda-expression","tag-lambda-expressions-in-python","tag-python-lambda-expression","tag-python-lambda-in-built-functions","tag-syntax-of-python-lambda-expression"],"yoast_head":"\nPython Lambda Expression - Declaring Lambda Expression & Its Defaults - DataFlair<\/title>\n<meta name=\"description\" content=\"Python Lambda Expression-Declaring Lambda Expressions in Python,In-built function & Syntax of Lambda Expression Python, Defaults in Python Lambda expression\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/data-flair.training\/blogs\/python-lambda-expression\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Python Lambda Expression - Declaring Lambda Expression & Its Defaults - DataFlair\" \/>\n<meta property=\"og:description\" content=\"Python Lambda Expression-Declaring Lambda Expressions in Python,In-built function & Syntax of Lambda Expression Python, Defaults in Python Lambda expression\" \/>\n<meta property=\"og:url\" content=\"https:\/\/data-flair.training\/blogs\/python-lambda-expression\/\" \/>\n<meta property=\"og:site_name\" content=\"DataFlair\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/DataFlairWS\/\" \/>\n<meta property=\"article:published_time\" content=\"2018-02-21T05:29:19+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2026-04-23T10:20:36+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/02\/Lambda-Expressions-in-Python-1.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1200\" \/>\n\t<meta property=\"og:image:height\" content=\"628\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"DataFlair Team\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@DataFlairWS\" \/>\n<meta name=\"twitter:site\" content=\"@DataFlairWS\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"DataFlair Team\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"7 minutes\" \/>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Python Lambda Expression - Declaring Lambda Expression & Its Defaults - DataFlair","description":"Python Lambda Expression-Declaring Lambda Expressions in Python,In-built function & Syntax of Lambda Expression Python, Defaults in Python Lambda expression","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:\/\/data-flair.training\/blogs\/python-lambda-expression\/","og_locale":"en_US","og_type":"article","og_title":"Python Lambda Expression - Declaring Lambda Expression & Its Defaults - DataFlair","og_description":"Python Lambda Expression-Declaring Lambda Expressions in Python,In-built function & Syntax of Lambda Expression Python, Defaults in Python Lambda expression","og_url":"https:\/\/data-flair.training\/blogs\/python-lambda-expression\/","og_site_name":"DataFlair","article_publisher":"https:\/\/www.facebook.com\/DataFlairWS\/","article_published_time":"2018-02-21T05:29:19+00:00","article_modified_time":"2026-04-23T10:20:36+00:00","og_image":[{"width":1200,"height":628,"url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/02\/Lambda-Expressions-in-Python-1.jpg","type":"image\/jpeg"}],"author":"DataFlair Team","twitter_card":"summary_large_image","twitter_creator":"@DataFlairWS","twitter_site":"@DataFlairWS","twitter_misc":{"Written by":"DataFlair Team","Est. reading time":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/data-flair.training\/blogs\/python-lambda-expression\/#article","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/python-lambda-expression\/"},"author":{"name":"DataFlair Team","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/7f83c342f5d1632d6f7b4b0b0f447823"},"headline":"Python Lambda Expression – Declaring Lambda Expression & Its Defaults","datePublished":"2018-02-21T05:29:19+00:00","dateModified":"2026-04-23T10:20:36+00:00","mainEntityOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/python-lambda-expression\/"},"wordCount":1360,"commentCount":8,"publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/python-lambda-expression\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/02\/Lambda-Expressions-in-Python-1.jpg","keywords":["Defaults in Python Lambda","Lambda expression","Lambda Expressions in Python","python lambda expression","Python Lambda in-built Functions","Syntax of Python Lambda expression"],"articleSection":["Python Tutorials"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/data-flair.training\/blogs\/python-lambda-expression\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/data-flair.training\/blogs\/python-lambda-expression\/","url":"https:\/\/data-flair.training\/blogs\/python-lambda-expression\/","name":"Python Lambda Expression - Declaring Lambda Expression & Its Defaults - DataFlair","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/#website"},"primaryImageOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/python-lambda-expression\/#primaryimage"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/python-lambda-expression\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/02\/Lambda-Expressions-in-Python-1.jpg","datePublished":"2018-02-21T05:29:19+00:00","dateModified":"2026-04-23T10:20:36+00:00","description":"Python Lambda Expression-Declaring Lambda Expressions in Python,In-built function & Syntax of Lambda Expression Python, Defaults in Python Lambda expression","breadcrumb":{"@id":"https:\/\/data-flair.training\/blogs\/python-lambda-expression\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/data-flair.training\/blogs\/python-lambda-expression\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/python-lambda-expression\/#primaryimage","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/02\/Lambda-Expressions-in-Python-1.jpg","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/02\/Lambda-Expressions-in-Python-1.jpg","width":1200,"height":628,"caption":"Python Lambda Expression"},{"@type":"BreadcrumbList","@id":"https:\/\/data-flair.training\/blogs\/python-lambda-expression\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Blog Home","item":"https:\/\/data-flair.training\/blogs\/"},{"@type":"ListItem","position":2,"name":"Python Tutorials","item":"https:\/\/data-flair.training\/blogs\/category\/python\/"},{"@type":"ListItem","position":3,"name":"Python Lambda Expression – Declaring Lambda Expression & Its Defaults"}]},{"@type":"WebSite","@id":"https:\/\/data-flair.training\/blogs\/#website","url":"https:\/\/data-flair.training\/blogs\/","name":"DataFlair","description":"Learn Today. Lead Tomorrow.","publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/data-flair.training\/blogs\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/data-flair.training\/blogs\/#organization","name":"DataFlair","url":"https:\/\/data-flair.training\/blogs\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/logo\/image\/","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2016\/07\/Data-Flair.png","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2016\/07\/Data-Flair.png","width":106,"height":48,"caption":"DataFlair"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/DataFlairWS\/","https:\/\/x.com\/DataFlairWS","https:\/\/www.linkedin.com\/company\/dataflair-web-services-pvt-ltd\/","https:\/\/www.youtube.com\/user\/DataFlairWS"]},{"@type":"Person","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/7f83c342f5d1632d6f7b4b0b0f447823","name":"DataFlair Team","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/4cf3a74600d131330b8c481d519afd1574093ed89f6d3396a95393ad223eb7cd?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/4cf3a74600d131330b8c481d519afd1574093ed89f6d3396a95393ad223eb7cd?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/4cf3a74600d131330b8c481d519afd1574093ed89f6d3396a95393ad223eb7cd?s=96&d=mm&r=g","caption":"DataFlair Team"},"description":"DataFlair Team creates expert-level guides on programming, Java, Python, C++, DSA, AI, ML, data Science, Android, Flutter, MERN, Web Development, and technology. Our goal is to empower learners with easy-to-understand content. Explore our resources for career growth and practical learning.","url":"https:\/\/data-flair.training\/blogs\/author\/dfteam1\/"}]}},"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/8851","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/users\/5"}],"replies":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/comments?post=8851"}],"version-history":[{"count":15,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/8851\/revisions"}],"predecessor-version":[{"id":147817,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/8851\/revisions\/147817"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media\/8858"}],"wp:attachment":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media?parent=8851"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/categories?post=8851"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/tags?post=8851"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}