As soon as a script makes more than a few API calls, you start repeating yourself: the base URL, the Authorization header, the same error checks. Wrapping the API in a class solves this.
The benefits:
- BASE_URL is set once — if it changes, you change it in one place.
- Authentication is handled in login() — callers never touch the header.
- Each API resource becomes a method with a clear name.
- requests.Session() is used internally, giving you connection reuse and shared state.
requests.Session() is a persistent HTTP client. Any headers you set on the session are automatically sent with every request:
```python
import requests
session = requests.Session()
session.headers['Authorization'] = 'Token abc123'
# Both calls automatically include the Authorization header
session.get('https://example.com/api/profile/')
session.get('https://example.com/api/cart/')
```
The typical class structure for an API client:
```python
class APIClient:
BASE_URL = 'https://apilearn.tukas.dev'
def __init__(self):
self.session = requests.Session()
def login(self, username, password):
# gets token and stores it in session.headers
...
def get_products(self, **params):
# calls /api/products/ with any filters
...
```
The caller only sees clean method names — no URLs, no headers, no JSON wrangling:
```python
client = APIClient()
client.login('alice', 'pass123')
products = client.get_products(category='kitchen', ordering='-price')
```
requests.Session() key attributes and methods:
```
session.headers Dict-like object; keys are sent with every request
session.get(url, ...) Same signature as requests.get()
session.post(url, ...) Same signature as requests.post()
session.patch(...) Same
session.delete(...) Same
session.close() Release the connection pool (optional for scripts)
```
API client class checklist:
```
□ BASE_URL as a class attribute
□ __init__ creates self.session = requests.Session()
□ login() sets self.session.headers['Authorization']
□ Each resource method calls self.session.get/post/...
□ Use raise_for_status() so errors surface immediately
□ Methods return parsed JSON, not raw Response objects
```
Session vs per-request headers:
```python
# Per-request (repeating yourself)
headers = {'Authorization': f'Token {token}'}
requests.get(url1, headers=headers)
requests.get(url2, headers=headers)
# Session (set once)
session = requests.Session()
session.headers['Authorization'] = f'Token {token}'
session.get(url1)
session.get(url2)
```
Create an APIClient class with __init__() and login() methods. __init__ should create requests.Session(). login() should fetch a token and set the Authorization header. Test it by calling login() and making a direct GET to /api/users/profile/ via session.
import requests
class APIClient:
BASE_URL = 'https://apilearn.tukas.dev'
def __init__(self):
# Create self.session
pass
def login(self, username, password):
# Fetch token and set Authorization header
pass
client = APIClient()
client.login('YOUR_USERNAME', 'YOUR_PASSWORD')
# Verify: session should return profile without extra headers
Extend APIClient with a login(username, password) method that gets a Token and stores it in session.headers. After calling login(), print the Authorization header to confirm it was set.
import requests
class APIClient:
BASE_URL = 'https://apilearn.tukas.dev'
def __init__(self):
self.session = requests.Session()
def login(self, username, password):
# POST to /api/auth/token/ and set Authorization header
pass
client = APIClient()
client.login('YOUR_USERNAME', 'YOUR_PASSWORD')
print(client.session.headers.get('Authorization'))
Add a get_products(**params) method that calls GET /api/products/ with any keyword args as query parameters and returns the parsed JSON. Use it to fetch kitchen products sorted by price.
import requests
class APIClient:
BASE_URL = 'https://apilearn.tukas.dev'
def __init__(self):
self.session = requests.Session()
def login(self, username, password):
token = self.session.post(
f'{self.BASE_URL}/api/auth/token/',
json={'username': username, 'password': password},
).json()['token']
self.session.headers['Authorization'] = f'Token {token}'
def get_products(self, **params):
# GET /api/products/ with params and return JSON
pass
client = APIClient()
client.login('YOUR_USERNAME', 'YOUR_PASSWORD')
data = client.get_products(category='kitchen', ordering='price', page_size=5)
for p in data['results']:
print(p['name'], p['sell_price'])
Build a complete APIClient with methods: login(), get_products(**params), get_profile(), add_to_cart(product_slug, quantity=1), clear_cart(). Then use it to: authenticate, fetch products, add the first to the cart, print the profile, and clear the cart.
Using your complete APIClient: login, get all kitchen products, add the cheapest one to the cart, view the cart total, then clear the cart. Print the product name you added and the cart total before clearing.
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.