This Small Python Script Improved Understanding of Low-Level Programming

Originally published in Level Up Coding on Medium.

---

Python's ease of use often masks the underlying complexities. Many developers become comfortable with common libraries and patterns, leading to a plateau in learning. However, advanced topics like concurrency and low-level programming offer significant opportunities for growth.

The Talk Python To Me podcast is a valuable resource for advanced Python learning. Their course, "Parallel Programming in Python with async/await and threads," provides crucial insights into concurrency and code optimization.

Traditional computer science curriculums often cover computer architecture, C programming, and concepts like mutexes, semaphores, and pointers. Yet, the practical application of these concepts can remain elusive for many programmers. Understanding CPU core utilization, for example, often stays theoretical.

This course highlights the unsync library, a powerful tool simplifying concurrent and parallel programming. unsync unifies async, threading, and multiprocessing into a single API, automatically optimizing tasks based on whether they're CPU-bound, I/O-bound, or asynchronous. It streamlines concurrent programming by handling thread management complexities.

The following script illustrates these concepts:

# source: https://github.com/talkpython/async-techniques-python-course/blob/master/src/09-built-on-asyncio/the_unsync/thesync.py

import datetime
import math
import asyncio
import aiohttp
import requests
from unsync import unsync

def main():
    start_time = datetime.datetime.now()

    tasks = [
        compute_some(),
        compute_some(),
        compute_some(),
        download_some(),
        download_some(),
        download_some_more(),
        download_some_more(),
        wait_some(),
        wait_some(),
        wait_some(),
        wait_some(),
    ]

    [t.result() for t in tasks]

    end_time = datetime.datetime.now()
    elapsed_time = end_time - start_time
    print(f"Synchronous version completed in {elapsed_time.total_seconds():,.2f} seconds.")

@unsync(cpu_bound=True)
def compute_some():
    print("Performing computation...")
    for _ in range(1, 10_000_000):
        math.sqrt(25 ** 25 + .01)

@unsync()
async def download_some():
    print("Downloading...")
    url = 'https://talkpython.fm/episodes/show/174/coming-into-python-from-another-industry-part-2'
    async with aiohttp.ClientSession(connector=aiohttp.TCPConnector(ssl=False)) as session:
        async with session.get(url) as resp:
            resp.raise_for_status()
            text = await resp.text()
    print(f"Downloaded (more) {len(text):,} characters.")

@unsync()
def download_some_more():
    print("Downloading more...")
    url = 'https://pythonbytes.fm/episodes/show/92/will-your-python-be-compiled'
    resp = requests.get(url)
    resp.raise_for_status()
    text = resp.text
    print(f"Downloaded {len(text):,} characters.")

@unsync()
async def wait_some():
    print("Waiting...")
    for _ in range(1, 1000):
        await asyncio.sleep(.001)

if __name__ == "__main__":
    main()

Script Breakdown

This script showcases concurrent task execution for improved performance:

1. compute_some Function: Performs intensive calculations, demonstrating multi-threaded CPU core utilization. Real-world applications include scientific computing and data processing.
2. download_some Function: Asynchronously downloads data, utilizing aiohttp for non-blocking I/O. Ideal for web scraping and concurrent API calls.
3. download_some_more Function: Uses synchronous requests in a separate thread, suitable for simpler scenarios requiring concurrency without non-blocking I/O.
4. wait_some Function: Simulates asynchronous delays, allowing other tasks to proceed concurrently. Useful for tasks involving waiting for external events.

Key Learning Points

The script highlights the benefits of concurrent programming: simultaneous task execution leads to faster processing and more efficient resource utilization.

---

Efficient application development requires understanding the interplay between memory (RAM) and processing power (CPU). RAM provides fast access to data, enabling smooth multitasking, while the CPU executes instructions. Adequate memory is crucial for handling large datasets and multiple operations, while a powerful CPU ensures fast computations and responsive applications. Understanding this relationship is vital for optimization and efficient task management, leading to high-performance applications capable of handling complex tasks.

---

Photo by Alexander Kovalev

The above is the detailed content of This Small Python Script Improved Understanding of Low-Level Programming. For more information, please follow other related articles on the PHP Chinese website!