{"id":27453,"date":"2018-11-21T09:54:09","date_gmt":"2018-11-21T04:24:09","guid":{"rendered":"https:\/\/data-flair.training\/blogs\/?p=27453"},"modified":"2026-04-29T11:56:08","modified_gmt":"2026-04-29T06:26:08","slug":"python-genetic-algorithms-ai","status":"publish","type":"post","link":"https:\/\/data-flair.training\/blogs\/python-genetic-algorithms-ai\/","title":{"rendered":"Python Genetic Algorithms With Artificial Intelligence"},"content":{"rendered":"

In our last Python AI tutorial<\/strong>, we discussed AI Python Logic Programming<\/strong>. Today, we will see AI Python Genetic Algorithms. In this Python Genetic Algorithms tutorial, we will learn the actual meaning of the Genetic Algorithm.<\/p>\n

Genetic Algorithms are inspired by how nature works. Think of it like in the real world, the strongest ideas survive and get better with time. This method is perfect for finding the best answer when there are millions of possibilities, and you have to choose one. Python\u2019s simple tools make it easy for anyone to build a program that learns and improves on its own.<\/p>\n

Also, we will look at the benefits, limitations, and applications of Genetic Algorithms with Python. At last, we will see a Python Genetic Algorithm example.<\/p>\n

So, let’s start the Python Genetic Algorithms tutorial.<\/p>\n

What are Genetic Algorithms With Python?<\/h3>\n

Genetic Algorithms (GA) are a type of AI that works like evolution. Just like how animals evolve by passing on the best genes, GAs create solutions by keeping the best results and improving them over time. Python helps you write these smart systems easily.<\/p>\n

Using libraries like DEAP and PyGAD, Python can solve hard problems where normal algorithms fail. You can create a group of solutions, test them, and then create better ones using operations like selection, crossover, and mutation. Over many cycles, the best solution is found. This is useful in scheduling, planning, and game design.<\/p>\n

Python Genetic Algorithms are used in industries like transport, manufacturing, and finance. They are perfect for tasks where there are many possible answers, and you want the best one. Python makes the process simple and lets you build AI that evolves and improves on its own.<\/p>\n

For any problem, we have a pool of possible solutions. These undergo processes like recombination and mutation to bear new children over generations. The search space is the set of all possible solutions and values that the inputs may take. <\/span><\/p>\n

In optimisation, we try to find within this search space the point or set of points that gives us the optimal solution. Each individual is like a string of characters\/integers\/floats, and the strings<\/strong> are like chromosomes.<\/span><\/p>\n

\"Python<\/a>

What are Genetic Algorithms With Python<\/p><\/div>\n

The fitness value (from a <\/span>fitness function<\/span>) for a candidate tells us how close it is to the optimal solution. <\/span><\/p>\n

This is on the lines of Darwin\u2019s theory of \u2018Survival of the Fittest\u2019 and is how we keep producing better (evolving) individuals\/ solutions over generations before reaching a criterion where to stop. <\/span><\/p>\n

These algorithms work in four steps:<\/strong><\/p>\n

    \n
  1. Individuals in the population compete for resources to mate<\/span><\/li>\n
  2. Fittest individuals mate to create more offspring than others<\/span><\/li>\n
  3. Fittest parent propagates genes through generations; parents may produce offspring better than either parent<\/span><\/li>\n
  4. Each successive generation evolves to suit its ambience<\/span><\/li>\n<\/ol>\n

    Since the population size is constant, some individuals must die to make room for newer ones. <\/span><\/p>\n

    We arrive at a situation of convergence when the difference between offspring produced by the current and ancestral populations is no longer significant. Then, the algorithm converges to a set of solutions for the problem.<\/span><\/p>\n

    Operators of Python Genetic Algorithms<\/strong><\/h3>\n

    To evolve through the generations, an algorithm may make use of one of many operators. Some of those are:<\/span><\/p>\n

    \"Python<\/a>

    Operators in Python Genetic Algorithms<\/p><\/div>\n

    a. Selection Operator\u00a0<\/strong><\/h4>\n

    It prefers individuals with better fitness scores and lets them pass genes on to successive generations.<\/span><\/p>\n

    b. Crossover Operator<\/strong><\/h4>\n

    This lets individuals mate. We apply the selection operator to select two individuals, and randomly choose crossover sites. We then exchange the genes at these sites- this produces an entirely new individual.<\/span><\/p>\n

    \"Crossover<\/a>

    Crossover Operator in Python Genetic Algorithms<\/p><\/div>\n

    c. Mutation Operator<\/strong><\/h4>\n

    In mutation, we insert random genes in offspring to maintain diversity and avoid premature convergence.<\/span><\/p>\n

    \"<\/a>

    Mutation Operator in Python Genetic Algorithms<\/p><\/div>\n

    Python Genetic Algorithm Example<\/strong><\/h3>\n

    Let\u2019s try to build a Genetic Algorithm in Python that can play something like <\/span>Guess the Number<\/span><\/i> better than us humans. This is a game where I randomly select a number<\/strong> between 1 and 10 (both inclusive) and you guess what number<\/strong> I have picked.<\/span>
    \nIs it 7? No<\/span>
    \nIs it 3? No<\/span>
    \nIs it 6? No<\/span>
    \nIs is 2? Yes<\/span><\/p>\n

    Seems like no big deal, but when we start talking about 100 or 1000 numbers, it quickly becomes a problem. How do we improve our guesses? What can we do but depend on sheer luck? This ultimately turns into a mechanical process. Maybe we could decide if a certain guess is closer to the solution in a certain direction?<\/span><\/p>\n

    Is it 7? Lower<\/span>
    \nIs it 1? Higher<\/span>
    \nIs it 5? Lower<\/span>
    \nIs it 4? Lower<\/span>
    \nIs it 3? Yes<\/span>
    \nPossession of such domain knowledge means we can get to the solution faster. To make informed and improved guesses, the algorithms make use of random exploration of the problem space. <\/span><\/p>\n

    Along with that, they also use evolutionary processes like mutation and crossover (see above). Without experience in the problem domain, they also try out things humans never would dare attempt.<\/span><\/p>\n

    Implementation in Python<\/strong><\/h4>\n

    Okay, now let\u2019s try implementing this in Python. Bear in mind that the fitness value for a candidate is how close it is to the optimal. Here, it means how many letters match what it should be- \u201cHello World!\u201d. Let\u2019s start with building a gene set.<\/span><\/p>\n

    >>> geneSet=\"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!.\"\r\n>>> target=\"Hello World!\"<\/pre>\n
    Now, let\u2019s generate a guess.<\/span><\/p>\n
    >>> import random\r\n>>> def gen_parent(length):\r\n       genes=[]\r\n       while len(genes)<length:\r\n               sampleSize=min(length-len(genes),len(geneSet))\r\n               genes.extend(random.sample(geneSet,sampleSize))\r\n       return ''.join(genes)<\/pre>\n
    Here, random.sample() chooses sampleSize random elements from geneSet. <\/span><\/p>\n
    Calculate the fitness value<\/strong><\/h4>\n
    >>> def get_fitness(guess):\r\n      return sum(1 for expected,actual in zip(target,guess) if expected==actual)<\/pre>\n
    With zip()<\/strong>, we can iterate over two lists <\/strong>at once. Now, let\u2019s perform a mutation.<\/span><\/p>\n
    >>> def mutate(parent):\r\n      index=random.randrange(0,len(parent))\r\n      childGenes=list(parent)\r\n      newGene,alternate=random.sample(geneSet,2)\r\n      childGenes[index]=alternate if newGene==childGenes[index] else newGene\r\n      return ''.join(childGenes)<\/pre>\n
    This is to convert the parent into an array<\/strong> with list(parent). Then, we replace 1 letter with one that we randomly select from geneSet. Finally, we recombine the result into a string with .join(). <\/span><\/p>\n
    To avoid wasted guesses, this uses an alternate replacement if the randomly selected newGene is equal to what we expect it to replace. The next function<\/strong> lets us display what is happening.<\/span><\/p>\n
    >>> def display(guess):\r\n      timeDiff=datetime.datetime.now()-startTime\r\n      fitness=get_fitness(guess)\r\n      print(\"{}\\t{}\\t{}\".format(guess,fitness,timeDiff))<\/pre>\n
    We\u2019re all set. Let\u2019s begin with the main program now.<\/strong><\/p>\n
    >>> random.seed()\r\n>>> startTime=datetime.datetime.now()\r\n>>> bestParent=gen_parent(len(target))\r\n>>> bestFitness=get_fitness(bestParent)\r\n>>> display(bestParent)<\/pre>\n
    umaBL.WdlUYj 1 0:00:51.469944<\/strong>
    \nAnd now, a loop<\/strong> to generate a guess, request its fitness, compare that to that of the previous best guess, and keep the guess with the better fitness.<\/span><\/p>\n
    >>> while True:\r\n      child=mutate(bestParent)\r\n      childFitness=get_fitness(child)\r\n      if bestFitness>=childFitness:\r\n               continue\r\n      display(child)\r\n      if childFitness>=len(bestParent):\r\n               break\r\n      bestFitness=childFitness\r\n      bestParent=child<\/pre>\n
    umaBL.WolUYj 2 0:00:55.974065<\/strong><\/p>\n
    umaBL.WollYj 3 0:00:56.032069<\/strong>
    \numaBL.WollY! 4 0:00:56.044069<\/strong>
    \numlBL.WollY! 5 0:00:56.061070<\/strong>
    \nHmlBL.WollY! 6 0:00:56.078071<\/strong>
    \nHelBL.WollY! 7 0:00:56.086072<\/strong>
    \nHellL.WollY! 8 0:00:56.095072<\/strong>
    \nHellL.WorlY! 9 0:00:56.105073<\/strong>
    \nHello.WorlY! 10 0:00:56.112073<\/strong>
    \nHello.World! 11 0:00:56.127074<\/strong>
    \nDid you see how the fitness gradually developed?<\/span><\/p>\n
    Benefits of Python Genetic Algorithms<\/strong><\/h3>\n
    Genetic Algorithms in Python observe the following advantages<\/strong>:<\/span><\/p>\n
      \n
    • No need for derivative information<\/span><\/li>\n
    • Faster and more efficient than traditional methods<\/strong><\/span><\/li>\n
    • Good parallel capabilities<\/span><\/li>\n
    • Deliver a list of good solutions instead of just one<\/span><\/li>\n
    • Optimize continuous as well as discrete functions and multi-objective problems<\/span><\/li>\n
    • Always deliver a solution and improves that with time<\/span><\/li>\n
    • Useful for very large search spaces with many parameters involved<\/span><\/li>\n<\/ul>\n
      Limitations of Python Genetic Algorithms<\/strong><\/h3>\n
      With all those benefits, we also have certain limitations in Genetic Algorithms with Python-<\/span><\/p>\n
        \n
      • Not suitable for simple problems with available derivative information<\/span><\/li>\n
      • Stochastic; no guarantee of the resulting solution being optimal<\/span><\/li>\n
      • Frequent calculation of fitness value is computationally expensive for some problems<\/span><\/li>\n
      • No guarantee of convergence to the optimal solution if not implemented properly<\/span><\/li>\n<\/ul>\n
        Applications of Python Genetic Algorithms<\/strong><\/h3>\n
        Finally, let\u2019s talk about where we typically use such Genetic Algorithms with Python.<\/span><\/p>\n
          \n
        • Recurrent Neural Network<\/strong><\/span><\/li>\n
        • Mutation testing<\/span><\/li>\n
        • Code breaking<\/span><\/li>\n
        • Filtering and signal processing<\/span><\/li>\n
        • Learning fuzzy rule base<\/span><\/li>\n<\/ul>\n
          So, this was all in Python Genetic Algorithms. Hope you like our explanation.<\/p>\n
          Conclusion\u00a0<\/strong><\/h3>\n
          Today, we learned about Python Genetic Algorithms and their operators- selection, crossover, and mutation. We talked about the fitness function and took an example problem to demonstrate Genetic <\/span>Algorithms in Python. <\/span><\/p>\n
          Finally, we learned about the benefits, limitations, and applications of Python Genetic Algorithms. Still, if you have any doubts, feel free to ask in the comments tab.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"
          In our last Python AI tutorial, we discussed AI Python Logic Programming. Today, we will see AI Python Genetic Algorithms. In this Python Genetic Algorithms tutorial, we will learn the actual meaning of the...<\/p>\n","protected":false},"author":5,"featured_media":27469,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[11,46],"tags":[1040,1757,5057,5059,5061,5062,5063,5065,8246,9293,10557],"class_list":["post-27453","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-artificial-intelligence","category-python","tag-applications-of-genetic-algorithms","tag-benefits-of-genetic-algorithms","tag-genetic-algorithm-applications","tag-genetic-algorithm-python","tag-genetic-algorithm-python-example","tag-genetic-algorithm-python-library","tag-genetic-algorithm-with-python","tag-genetic-programming-python","tag-limitations-of-genetic-algorithms","tag-operators-of-genetic-algorithms","tag-python-genetic-algorithm"],"yoast_head":"\nPython Genetic Algorithms With Artificial Intelligence - DataFlair<\/title>\n<meta name=\"description\" content=\"Python Genetic Algorithms, applications of Genetic Algorithms Python with AI, genetic algorithm example, genetic algorithm applications\" \/>\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-genetic-algorithms-ai\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Python Genetic Algorithms With Artificial Intelligence - DataFlair\" \/>\n<meta property=\"og:description\" content=\"Python Genetic Algorithms, applications of Genetic Algorithms Python with AI, genetic algorithm example, genetic algorithm applications\" \/>\n<meta property=\"og:url\" content=\"https:\/\/data-flair.training\/blogs\/python-genetic-algorithms-ai\/\" \/>\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-11-21T04:24:09+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2026-04-29T06:26:08+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/09\/Genetic-Algorithms-with-Python-AI-01.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 Genetic Algorithms With Artificial Intelligence - DataFlair","description":"Python Genetic Algorithms, applications of Genetic Algorithms Python with AI, genetic algorithm example, genetic algorithm applications","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-genetic-algorithms-ai\/","og_locale":"en_US","og_type":"article","og_title":"Python Genetic Algorithms With Artificial Intelligence - DataFlair","og_description":"Python Genetic Algorithms, applications of Genetic Algorithms Python with AI, genetic algorithm example, genetic algorithm applications","og_url":"https:\/\/data-flair.training\/blogs\/python-genetic-algorithms-ai\/","og_site_name":"DataFlair","article_publisher":"https:\/\/www.facebook.com\/DataFlairWS\/","article_published_time":"2018-11-21T04:24:09+00:00","article_modified_time":"2026-04-29T06:26:08+00:00","og_image":[{"width":1200,"height":628,"url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/09\/Genetic-Algorithms-with-Python-AI-01.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-genetic-algorithms-ai\/#article","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/python-genetic-algorithms-ai\/"},"author":{"name":"DataFlair Team","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/7f83c342f5d1632d6f7b4b0b0f447823"},"headline":"Python Genetic Algorithms With Artificial Intelligence","datePublished":"2018-11-21T04:24:09+00:00","dateModified":"2026-04-29T06:26:08+00:00","mainEntityOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/python-genetic-algorithms-ai\/"},"wordCount":1313,"commentCount":0,"publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/python-genetic-algorithms-ai\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/09\/Genetic-Algorithms-with-Python-AI-01.jpg","keywords":["Applications of Genetic Algorithms","Benefits of Genetic Algorithms","genetic algorithm applications","genetic algorithm python","genetic algorithm python example","Genetic Algorithm Python Library","Genetic Algorithm with Python","genetic programming python","Limitations of Genetic Algorithms","Operators of Genetic Algorithms","Python Genetic algorithm"],"articleSection":["Artificial Intelligence Tutorials","Python Tutorials"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/data-flair.training\/blogs\/python-genetic-algorithms-ai\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/data-flair.training\/blogs\/python-genetic-algorithms-ai\/","url":"https:\/\/data-flair.training\/blogs\/python-genetic-algorithms-ai\/","name":"Python Genetic Algorithms With Artificial Intelligence - DataFlair","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/#website"},"primaryImageOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/python-genetic-algorithms-ai\/#primaryimage"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/python-genetic-algorithms-ai\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/09\/Genetic-Algorithms-with-Python-AI-01.jpg","datePublished":"2018-11-21T04:24:09+00:00","dateModified":"2026-04-29T06:26:08+00:00","description":"Python Genetic Algorithms, applications of Genetic Algorithms Python with AI, genetic algorithm example, genetic algorithm applications","breadcrumb":{"@id":"https:\/\/data-flair.training\/blogs\/python-genetic-algorithms-ai\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/data-flair.training\/blogs\/python-genetic-algorithms-ai\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/python-genetic-algorithms-ai\/#primaryimage","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/09\/Genetic-Algorithms-with-Python-AI-01.jpg","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/09\/Genetic-Algorithms-with-Python-AI-01.jpg","width":1200,"height":628,"caption":"Python Genetic Algorithms With AI"},{"@type":"BreadcrumbList","@id":"https:\/\/data-flair.training\/blogs\/python-genetic-algorithms-ai\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Blog Home","item":"https:\/\/data-flair.training\/blogs\/"},{"@type":"ListItem","position":2,"name":"Artificial Intelligence Tutorials","item":"https:\/\/data-flair.training\/blogs\/category\/artificial-intelligence\/"},{"@type":"ListItem","position":3,"name":"Python Genetic Algorithms With Artificial Intelligence"}]},{"@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\/27453","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=27453"}],"version-history":[{"count":7,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/27453\/revisions"}],"predecessor-version":[{"id":148060,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/27453\/revisions\/148060"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media\/27469"}],"wp:attachment":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media?parent=27453"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/categories?post=27453"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/tags?post=27453"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}