{"id":1978,"date":"2024-06-26T16:17:48","date_gmt":"2024-06-26T16:17:48","guid":{"rendered":"https:\/\/www.w3computing.com\/articles\/?p=1978"},"modified":"2024-06-26T16:18:44","modified_gmt":"2024-06-26T16:18:44","slug":"mastering-python-generators-for-efficient-data-processing","status":"publish","type":"post","link":"https:\/\/www.w3computing.com\/articles\/mastering-python-generators-for-efficient-data-processing\/","title":{"rendered":"Mastering Python Generators for Efficient Data Processing"},"content":{"rendered":"\n

Python is a powerful programming language with many features that enable efficient data processing. Among these features, generators stand out due to their ability to produce items one at a time and only as needed, which can significantly reduce memory consumption and improve performance. This tutorial will explore how to master Python generators for efficient data processing, covering their creation, use cases, and advanced techniques.<\/p>\n\n\n\n

1. Introduction to Generators<\/h2>\n\n\n\n

Generators are a special class of iterators in Python that allow you to iterate through a sequence of values, but unlike lists, they do not store their contents in memory. Instead, they generate each value on-the-fly, which makes them memory efficient. Generators are particularly useful when dealing with large datasets or streams of data where loading the entire dataset into memory is impractical.<\/p>\n\n\n\n

2. Creating Generators<\/h2>\n\n\n\n

Generators can be created in two primary ways: generator functions and generator expressions.<\/p>\n\n\n\n

Generator Functions<\/h3>\n\n\n\n

Generator functions are defined using the def<\/code> keyword and the yield<\/code> statement. The yield<\/code> statement is used to produce a value and suspend the function’s execution, preserving its state for resumption later.<\/p>\n\n\n\n

Here\u2019s a simple example:<\/p>\n\n\n

def<\/span> simple_generator<\/span>()<\/span>:<\/span>\n    yield<\/span> 1<\/span>\n    yield<\/span> 2<\/span>\n    yield<\/span> 3<\/span>\n\ngen = simple_generator()\nfor<\/span> value in<\/span> gen:\n    print(value)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
This code will output:<\/p>\n\n\n
1\n2\n3<\/code><\/span>Code language:<\/span> plaintext<\/span> (<\/span>plaintext<\/span>)<\/span><\/small><\/pre>\n\n\n
Generator Expressions<\/h3>\n\n\n\n
Generator expressions are a concise way to create generators. They are similar to list comprehensions but use parentheses instead of square brackets.<\/p>\n\n\n\n
Example:<\/p>\n\n\n
gen_expr = (x * x for<\/span> x in<\/span> range(10<\/span>))\nfor<\/span> value in<\/span> gen_expr:\n    print(value)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
This will output the squares of numbers from 0 to 9.<\/p>\n\n\n\n
3. Using Generators<\/h2>\n\n\n\n
Iterating Over Generators<\/h3>\n\n\n\n
You can iterate over generators using a for<\/code> loop or manually using the next<\/code> function.<\/p>\n\n\n
def<\/span> countdown<\/span>(n)<\/span>:<\/span>\n    while<\/span> n > 0<\/span>:\n        yield<\/span> n\n        n -= 1<\/span>\n\ngen = countdown(5<\/span>)\nprint(next(gen))  # Outputs: 5<\/span>\nprint(next(gen))  # Outputs: 4<\/span>\nprint(next(gen))  # Outputs: 3<\/span>\n\n# Continue iteration using a loop<\/span>\nfor<\/span> value in<\/span> gen:\n    print(value)  # Outputs: 2, 1<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
Generator Methods (send<\/code>, throw<\/code>, close<\/code>)<\/h3>\n\n\n\n
Generators have additional methods that provide more control over their execution.<\/p>\n\n\n\n
    \n
  • send(value)<\/code>: Resumes the generator and “sends” a value to it, which becomes the result of the current yield<\/code> expression.<\/li>\n\n\n\n
  • throw(type, value=None, traceback=None)<\/code>: Raises an exception at the point where the generator was paused.<\/li>\n\n\n\n
  • close()<\/code>: Stops the generator by raising a GeneratorExit<\/code> exception.<\/li>\n<\/ul>\n\n\n\n
    Example:<\/p>\n\n\n
    def<\/span> interactive_generator<\/span>()<\/span>:<\/span>\n    while<\/span> True<\/span>:\n        value = yield<\/span>\n        if<\/span> value is<\/span> None<\/span>:\n            break<\/span>\n        print(f'Received: {value}<\/span>'<\/span>)\n\ngen = interactive_generator()\nnext(gen)  # Prime the generator<\/span>\ngen.send(10<\/span>)  # Outputs: Received: 10<\/span>\ngen.send(20<\/span>)  # Outputs: Received: 20<\/span>\ngen.close()<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    4. Advantages of Generators<\/h2>\n\n\n\n
    Memory Efficiency<\/h3>\n\n\n\n
    Generators are memory efficient because they yield items one at a time. This is especially beneficial when working with large datasets.<\/p>\n\n\n\n
    Lazy Evaluation<\/h3>\n\n\n\n
    Generators evaluate items lazily, meaning they only produce values when required. This can lead to performance improvements by avoiding unnecessary computations.<\/p>\n\n\n\n
    5. Common Use Cases<\/h2>\n\n\n\n
    Reading Large Files<\/h3>\n\n\n\n
    When dealing with large files, reading the entire file into memory is impractical. Generators provide an efficient way to process files line by line.<\/p>\n\n\n
    def<\/span> read_large_file<\/span>(file_path)<\/span>:<\/span>\n    with<\/span> open(file_path, 'r'<\/span>) as<\/span> file:\n        for<\/span> line in<\/span> file:\n            yield<\/span> line\n\nfor<\/span> line in<\/span> read_large_file('large_file.txt'<\/span>):\n    process(line)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    Infinite Sequences<\/h3>\n\n\n\n
    Generators can produce infinite sequences, which are useful for tasks like generating an unbounded series of numbers.<\/p>\n\n\n
    def<\/span> infinite_sequence<\/span>()<\/span>:<\/span>\n    num = 0<\/span>\n    while<\/span> True<\/span>:\n        yield<\/span> num\n        num += 1<\/span>\n\ngen = infinite_sequence()\nfor<\/span> _ in<\/span> range(10<\/span>):\n    print(next(gen))<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    Pipelines<\/h3>\n\n\n\n
    Generators can be composed into pipelines to process data in stages, enhancing readability and modularity.<\/p>\n\n\n
    def<\/span> generate_numbers<\/span>(n)<\/span>:<\/span>\n    for<\/span> i in<\/span> range(n):\n        yield<\/span> i\n\ndef<\/span> square_numbers<\/span>(numbers)<\/span>:<\/span>\n    for<\/span> number in<\/span> numbers:\n        yield<\/span> number ** 2<\/span>\n\ndef<\/span> sum_squares<\/span>(squares)<\/span>:<\/span>\n    total = 0<\/span>\n    for<\/span> square in<\/span> squares:\n        total += square\n    return<\/span> total\n\nnumbers = generate_numbers(10<\/span>)\nsquares = square_numbers(numbers)\ntotal = sum_squares(squares)\nprint(total)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    6. Advanced Techniques<\/h2>\n\n\n\n
    Composing Generators<\/h3>\n\n\n\n
    Generators can be composed to create more complex pipelines.<\/p>\n\n\n
    def<\/span> filter_even<\/span>(numbers)<\/span>:<\/span>\n    for<\/span> number in<\/span> numbers:\n        if<\/span> number % 2<\/span> == 0<\/span>:\n            yield<\/span> number\n\nnumbers = generate_numbers(10<\/span>)\nevens = filter_even(numbers)\nsquares = square_numbers(evens)\nfor<\/span> square in<\/span> squares:\n    print(square)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    Combining Generators with Coroutines<\/h3>\n\n\n\n
    Generators can be combined with coroutines to build advanced data processing workflows.<\/p>\n\n\n
    def<\/span> coroutine<\/span>(func)<\/span>:<\/span>\n    def<\/span> start<\/span>(*args, **kwargs)<\/span>:<\/span>\n        cr = func(*args, **kwargs)\n        next(cr)\n        return<\/span> cr\n    return<\/span> start\n\n@coroutine<\/span>\ndef<\/span> printer<\/span>()<\/span>:<\/span>\n    while<\/span> True<\/span>:\n        item = yield<\/span>\n        print(item)\n\ngen = generate_numbers(5<\/span>)\np = printer()\nfor<\/span> num in<\/span> gen:\n    p.send(num)<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    7. Debugging and Testing Generators<\/h2>\n\n\n\n
    Testing generators can be tricky due to their stateful nature. It’s useful to convert them to lists for testing purposes.<\/p>\n\n\n
    def<\/span> test_generator<\/span>()<\/span>:<\/span>\n    gen = simple_generator()\n    assert<\/span> list(gen) == [1<\/span>, 2<\/span>, 3<\/span>]\n\ndef<\/span> test_pipeline<\/span>()<\/span>:<\/span>\n    numbers = generate_numbers(10<\/span>)\n    evens = filter_even(numbers)\n    squares = square_numbers(evens)\n    assert<\/span> list(squares) == [0<\/span>, 4<\/span>, 16<\/span>, 36<\/span>, 64<\/span>]<\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    For debugging, you can use the inspect<\/code> module to examine the state of a generator.<\/p>\n\n\n
    import<\/span> inspect\n\ngen = simple_generator()\nprint(inspect.getgeneratorstate(gen))  # Outputs: GEN_CREATED<\/span>\nnext(gen)\nprint(inspect.getgeneratorstate(gen))  # Outputs: GEN_SUSPENDED<\/span><\/code><\/span>Code language:<\/span> Python<\/span> (<\/span>python<\/span>)<\/span><\/small><\/pre>\n\n\n
    8. Conclusion<\/h2>\n\n\n\n
    Generators are a powerful feature in Python that enable efficient data processing by producing values on-the-fly and consuming minimal memory. By mastering generators, you can handle large datasets and complex data processing tasks more effectively. Whether you’re reading large files, creating infinite sequences, or building data processing pipelines, generators provide a robust toolset for writing efficient and readable code.<\/p>\n\n\n\n
    Through the concepts and techniques covered in this tutorial, you should now have a strong foundation for leveraging generators in your Python projects. Continue experimenting and exploring advanced patterns to fully harness the power of generators for efficient data processing.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Python is a powerful programming language with many features that enable efficient data processing. Among these features, generators stand out due to their ability to produce items one at a time and only as needed, which can significantly reduce memory consumption and improve performance. This tutorial will explore how to master Python generators for efficient […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[4,6],"tags":[],"class_list":["post-1978","post","type-post","status-publish","format-standard","category-programming-languages","category-python","entry"],"yoast_head":"\nMastering Python Generators for Efficient Data Processing<\/title>\n<meta name=\"description\" content=\"Among many features of Python, generators stand out due to their ability to produce items one at a time and only as needed, which can significantly\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.w3computing.com\/articles\/mastering-python-generators-for-efficient-data-processing\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Mastering Python Generators for Efficient Data Processing\" \/>\n<meta property=\"og:description\" content=\"Among many features of Python, generators stand out due to their ability to produce items one at a time and only as needed, which can significantly\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.w3computing.com\/articles\/mastering-python-generators-for-efficient-data-processing\/\" \/>\n<meta property=\"article:published_time\" content=\"2024-06-26T16:17:48+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-06-26T16:18:44+00:00\" \/>\n<meta name=\"author\" content=\"w3compadmin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"w3compadmin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"3 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/mastering-python-generators-for-efficient-data-processing\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/mastering-python-generators-for-efficient-data-processing\\\/\"},\"author\":{\"name\":\"w3compadmin\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"headline\":\"Mastering Python Generators for Efficient Data Processing\",\"datePublished\":\"2024-06-26T16:17:48+00:00\",\"dateModified\":\"2024-06-26T16:18:44+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/mastering-python-generators-for-efficient-data-processing\\\/\"},\"wordCount\":578,\"articleSection\":[\"Programming Languages\",\"Python\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/mastering-python-generators-for-efficient-data-processing\\\/\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/mastering-python-generators-for-efficient-data-processing\\\/\",\"name\":\"Mastering Python Generators for Efficient Data Processing\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\"},\"datePublished\":\"2024-06-26T16:17:48+00:00\",\"dateModified\":\"2024-06-26T16:18:44+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"description\":\"Among many features of Python, generators stand out due to their ability to produce items one at a time and only as needed, which can significantly\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/mastering-python-generators-for-efficient-data-processing\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/mastering-python-generators-for-efficient-data-processing\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/mastering-python-generators-for-efficient-data-processing\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Articles Home\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Programming Languages\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Python\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/python\\\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Mastering Python Generators for Efficient Data Processing\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\",\"name\":\"Developer Articles Hub\",\"description\":\"\",\"alternateName\":\"Developer Articles\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\",\"name\":\"w3compadmin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"contentUrl\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"caption\":\"w3compadmin\"},\"sameAs\":[\"http:\\\/\\\/w3computing.com\\\/articles\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Mastering Python Generators for Efficient Data Processing","description":"Among many features of Python, generators stand out due to their ability to produce items one at a time and only as needed, which can significantly","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:\/\/www.w3computing.com\/articles\/mastering-python-generators-for-efficient-data-processing\/","og_locale":"en_US","og_type":"article","og_title":"Mastering Python Generators for Efficient Data Processing","og_description":"Among many features of Python, generators stand out due to their ability to produce items one at a time and only as needed, which can significantly","og_url":"https:\/\/www.w3computing.com\/articles\/mastering-python-generators-for-efficient-data-processing\/","article_published_time":"2024-06-26T16:17:48+00:00","article_modified_time":"2024-06-26T16:18:44+00:00","author":"w3compadmin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"w3compadmin","Est. reading time":"3 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.w3computing.com\/articles\/mastering-python-generators-for-efficient-data-processing\/#article","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/mastering-python-generators-for-efficient-data-processing\/"},"author":{"name":"w3compadmin","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"headline":"Mastering Python Generators for Efficient Data Processing","datePublished":"2024-06-26T16:17:48+00:00","dateModified":"2024-06-26T16:18:44+00:00","mainEntityOfPage":{"@id":"https:\/\/www.w3computing.com\/articles\/mastering-python-generators-for-efficient-data-processing\/"},"wordCount":578,"articleSection":["Programming Languages","Python"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/www.w3computing.com\/articles\/mastering-python-generators-for-efficient-data-processing\/","url":"https:\/\/www.w3computing.com\/articles\/mastering-python-generators-for-efficient-data-processing\/","name":"Mastering Python Generators for Efficient Data Processing","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/#website"},"datePublished":"2024-06-26T16:17:48+00:00","dateModified":"2024-06-26T16:18:44+00:00","author":{"@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"description":"Among many features of Python, generators stand out due to their ability to produce items one at a time and only as needed, which can significantly","breadcrumb":{"@id":"https:\/\/www.w3computing.com\/articles\/mastering-python-generators-for-efficient-data-processing\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.w3computing.com\/articles\/mastering-python-generators-for-efficient-data-processing\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.w3computing.com\/articles\/mastering-python-generators-for-efficient-data-processing\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Articles Home","item":"https:\/\/www.w3computing.com\/articles\/"},{"@type":"ListItem","position":2,"name":"Programming Languages","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/"},{"@type":"ListItem","position":3,"name":"Python","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/python\/"},{"@type":"ListItem","position":4,"name":"Mastering Python Generators for Efficient Data Processing"}]},{"@type":"WebSite","@id":"https:\/\/www.w3computing.com\/articles\/#website","url":"https:\/\/www.w3computing.com\/articles\/","name":"Developer Articles Hub","description":"","alternateName":"Developer Articles","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.w3computing.com\/articles\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561","name":"w3compadmin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","url":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","contentUrl":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","caption":"w3compadmin"},"sameAs":["http:\/\/w3computing.com\/articles"]}]}},"featured_image_src":null,"featured_image_src_square":null,"author_info":{"display_name":"w3compadmin","author_link":"https:\/\/www.w3computing.com\/articles\/author\/w3compadmin\/"},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1978","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/comments?post=1978"}],"version-history":[{"count":1,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1978\/revisions"}],"predecessor-version":[{"id":1979,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1978\/revisions\/1979"}],"wp:attachment":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/media?parent=1978"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/categories?post=1978"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/tags?post=1978"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}