When you make HTTP requests sequentially, each one blocks the script until the server responds. If you need to fetch 13 categories, you wait for response 1, then response 2, and so on — the total time is the sum of all individual response times.
Async requests let you send all 13 requests at once and wait for all of them in parallel. If each request takes 200ms, sequential takes 2.6s. Parallel takes ~200ms.
httpx is a modern HTTP client that mirrors the requests API but adds async support via Python's asyncio:
```python
import httpx
# Synchronous — same as requests
response = httpx.get('https://apilearn.tukas.dev/api/products/')
print(response.json()['count'])
```
For async, use AsyncClient with async/await:
```python
import httpx
import asyncio
async def main():
async with httpx.AsyncClient() as client:
response = await client.get('https://apilearn.tukas.dev/api/products/')
print(response.json()['count'])
asyncio.run(main())
```
async with ensures the client is properly closed even if an error occurs. await pauses the coroutine until the response arrives, allowing other coroutines to run in the meantime.
asyncio.gather() is the key to running multiple requests in parallel — it takes a list of coroutines and runs them all concurrently:
```python
results = await asyncio.gather(
client.get(url1),
client.get(url2),
client.get(url3),
)
# results is a list of Response objects, in the same order as the calls
```
When to use async:
- You have many independent requests (fetching all categories, all pages, all product details).
- The requests do not depend on each other's results.
- Each request has non-trivial latency (network calls almost always do).
Async does not help when requests are sequential by nature (e.g. you need the result of request 1 to know what to ask in request 2).
Fetch all category product counts in parallel:
```python
import httpx
import asyncio
BASE_URL = 'https://apilearn.tukas.dev'
async def fetch_category_count(client, slug):
response = await client.get(
f'{BASE_URL}/api/products/',
params={'category': slug, 'page_size': 1},
)
return slug, response.json()['count']
async def main():
# Get all category slugs first
async with httpx.AsyncClient() as client:
r = await client.get(f'{BASE_URL}/api/categories/')
categories = r.json()['results']
slugs = [cat['slug'] for cat in categories]
# Fetch all counts concurrently
tasks = [fetch_category_count(client, slug) for slug in slugs]
results = await asyncio.gather(*tasks)
for slug, count in results:
print(f'{slug}: {count}')
asyncio.run(main())
```
Fetch 5 specific products by id in parallel:
```python
import httpx
import asyncio
BASE_URL = 'https://apilearn.tukas.dev'
async def fetch_product(client, product_id):
response = await client.get(f'{BASE_URL}/api/products/{product_id}/')
return response.json()
async def main():
product_ids = [1, 2, 3, 4, 5]
async with httpx.AsyncClient() as client:
products = await asyncio.gather(
*[fetch_product(client, pid) for pid in product_ids]
)
for p in products:
print(p['name'], p['price'])
asyncio.run(main())
```
The *[...] unpacks the list into positional arguments for asyncio.gather. gather(*tasks) is equivalent to gather(task1, task2, task3, ...).
Note on httpx vs requests: httpx supports both sync and async, has a nearly identical API to requests, and handles HTTP/2. For sync-only scripts requests is fine. Use httpx when you need async.
Write an async function fetch_products() that uses httpx.AsyncClient to fetch /api/products/ and returns the count. Call it with asyncio.run() and print the result.
import httpx
import asyncio
BASE_URL = 'https://apilearn.tukas.dev'
async def fetch_products():
# Use AsyncClient to fetch products and return count
pass
print(asyncio.run(fetch_products()))
Write a coroutine fetch_product(client, product_id) that fetches /api/products/{id}/. Use asyncio.gather() to fetch products with ids 1 to 5 simultaneously. Print the name and price of each.
import httpx
import asyncio
BASE_URL = 'https://apilearn.tukas.dev'
async def fetch_product(client, product_id):
# GET /api/products/{product_id}/
pass
async def main():
async with httpx.AsyncClient() as client:
# Gather and run 5 requests in parallel
pass
asyncio.run(main())
Solution
import httpx
import asyncio
BASE_URL = 'https://apilearn.tukas.dev'
async def fetch_product(client, product_id):
response = await client.get(f'{BASE_URL}/api/products/{product_id}/')
return response.json()
async def main():
async with httpx.AsyncClient() as client:
products = await asyncio.gather(*[
fetch_product(client, i) for i in range(1, 6)
])
for p in products:
print(p['name'], p['price'])
asyncio.run(main())
Fetch 10 pages of products (/api/products/?page=N) both ways: first sequentially in a for loop (measuring time), then concurrently with asyncio.gather (measuring time). Print both elapsed times.
import httpx
import asyncio
import time
BASE_URL = 'https://apilearn.tukas.dev'
# Sequential: fetch pages 1-10 one by one
# Parallel: fetch pages 1-10 concurrently
# Print elapsed time for each approach
Solution
import httpx
import asyncio
import time
BASE_URL = 'https://apilearn.tukas.dev'
pages = list(range(1, 11))
# Sequential
start = time.time()
for page in pages:
httpx.get(f'{BASE_URL}/api/products/', params={'page': page})
print(f'Sequential: {time.time() - start:.2f}s')
# Parallel
async def fetch_page(client, page):
return await client.get(
f'{BASE_URL}/api/products/', params={'page': page},
)
async def run_parallel():
async with httpx.AsyncClient() as client:
await asyncio.gather(*[fetch_page(client, p) for p in pages])
start = time.time()
asyncio.run(run_parallel())
print(f'Parallel: {time.time() - start:.2f}s')
No split tab
Cookie preferences
We use necessary cookies to run the site. With your permission, we can also save your site preferences and use analytics and advertising cookies to understand usage and support the project.
Open tools in tabs.Exercises, IDE tools, and trainers stay available as site tabs.
Switch without losing context.Move between explanations, code, and utilities while keeping your place.
Use the sidebar as your map.The left panels hold navigation, settings, files, libraries, and tool controls.
PythonJavaScriptSQLite
One IDE, three practical modes
Python in the browser.Run small scripts, try libraries, and practice API requests without installing anything.
JavaScript for quick experiments.Test browser-friendly code and compare ideas next to your learning materials.
SQLite for data practice.Open the database explorer to inspect tables, write queries, and learn SQL workflows locally.
TopicIDE
Work side by side with split tabs
Keep instructions visible.Open an exercise or reference page beside the IDE instead of jumping back and forth.
Compare tools while you learn.Place regex checks, explanations, and code experiments next to each other when the task needs it.
Close the split when you are done.The workspace returns to a single focused tab, and your open site tabs remain available.
Code Typing Trainer
Or plain text
This trainer is designed for a physical keyboard.Open this section on a laptop or desktop with a wide screen. Touch typing practice will not work correctly on a phone.
Speed: 0 chars/min
0 words/min
Best speed (60s): 0 chars/min
0 words/min
Errors: 0
Total time: 0.0 s
To practice touch typing, avoid looking at your physical keyboard.