Skrip Python Kecil Ini Meningkatkan Pemahaman tentang Pengaturcaraan Tahap Rendah

Pada asalnya diterbitkan dalam Pengekodan Tahap Naik pada Sederhana.

---

Kemudahan penggunaan Python sering menutupi kerumitan yang mendasari. Ramai pembangun menjadi selesa dengan perpustakaan dan corak biasa, yang membawa kepada dataran tinggi dalam pembelajaran. Walau bagaimanapun, topik lanjutan seperti concurrency dan pengaturcaraan peringkat rendah menawarkan peluang besar untuk pertumbuhan.

Podcast Talk Python To Me ialah sumber yang berharga untuk pembelajaran Python lanjutan. Kursus mereka, "Pengaturcaraan Selari dalam Python dengan tidak segerak/menunggu dan urutan", memberikan cerapan penting tentang konkurensi dan pengoptimuman kod.

Kurikulum sains komputer tradisional selalunya merangkumi seni bina komputer, pengaturcaraan C dan konsep seperti mutex, semaphore dan penunjuk. Namun, aplikasi praktikal konsep ini boleh kekal sukar difahami untuk banyak pengaturcara. Memahami penggunaan teras CPU, sebagai contoh, selalunya kekal sebagai teori.

Kursus ini menyerlahkan unsync perpustakaan, alat berkuasa yang memudahkan pengaturcaraan serentak dan selari. unsync menyatukan async, threading dan berbilang pemprosesan ke dalam API tunggal, mengoptimumkan tugasan secara automatik berdasarkan sama ada tugasan terikat CPU, terikat I/O atau tak segerak. Ia memperkemas pengaturcaraan serentak dengan mengendalikan kerumitan pengurusan benang.

Skrip berikut menggambarkan konsep ini:

# 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()

Pecahan Skrip

Skrip ini mempamerkan pelaksanaan tugas serentak untuk prestasi yang lebih baik:

1. compute_some Fungsi: Melakukan pengiraan intensif, menunjukkan penggunaan teras CPU berbilang benang. Aplikasi dunia nyata termasuk pengkomputeran saintifik dan pemprosesan data.
2. download_some Fungsi: Memuat turun data secara tidak segerak, menggunakan aiohttp untuk I/O tidak menyekat. Sesuai untuk mengikis web dan panggilan API serentak.
3. download_some_more Fungsi: Menggunakan permintaan segerak dalam urutan yang berasingan, sesuai untuk senario yang lebih mudah yang memerlukan konkurensi tanpa I/O tidak menyekat.
4. wait_some Fungsi: Mensimulasikan kelewatan tak segerak, membenarkan tugasan lain diteruskan secara serentak. Berguna untuk tugasan yang melibatkan menunggu acara luaran.

Inti Pembelajaran Utama

Skrip menyerlahkan faedah pengaturcaraan serentak: pelaksanaan tugas serentak membawa kepada pemprosesan yang lebih pantas dan penggunaan sumber yang lebih cekap.

---

Pembangunan aplikasi yang cekap memerlukan pemahaman interaksi antara memori (RAM) dan kuasa pemprosesan (CPU). RAM menyediakan akses pantas kepada data, membolehkan multitasking lancar, manakala CPU melaksanakan arahan. Memori yang mencukupi adalah penting untuk mengendalikan set data yang besar dan berbilang operasi, manakala CPU yang berkuasa memastikan pengiraan pantas dan aplikasi responsif. Memahami hubungan ini adalah penting untuk pengoptimuman dan pengurusan tugas yang cekap, yang membawa kepada aplikasi berprestasi tinggi yang mampu mengendalikan tugas yang rumit.

---

Foto oleh Alexander Kovalev

Atas ialah kandungan terperinci Skrip Python Kecil Ini Meningkatkan Pemahaman tentang Pengaturcaraan Tahap Rendah. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!