Python requestsライブラリは何に使用されますか？

Python requestsライブラリはWebサーバーやAPIへのHTTPリクエストを行うために使用されます。Webページの取得、REST APIの利用、フォームデータの送信、ファイルのアップロード、認証の処理などのタスクを簡素化します。直感的なAPIと包括的な機能セットのおかげで、Pythonで最も人気のあるHTTPライブラリです。

Python requestsライブラリをインストールするにはどうすればよいですか？

pipを使用してrequestsライブラリをインストールしてください: pip install requests。conda環境では conda install requests を使用します。インストール後は、Pythonコードで import requests としてインポートします。このライブラリはPythonの標準ライブラリに含まれていないため、インストールが必要です。

Python requestsライブラリでエラーを処理するにはどうすればよいですか？

try-exceptブロックを使用して例外をキャッチしてください: ネットワーク問題にはConnectionError、遅いレスポンスにはTimeout、4xx/5xxステータスコードにはHTTPError、汎用例外にはRequestExceptionを使用します。リクエストが失敗した場合に自動的にHTTPErrorを発生させるために、各リクエストの後にresponse.raise_for_status()を呼び出してください。リクエストが無期限にハングしないよう、常にタイムアウトを設定してください。

Python requestsでJSONデータを送信するにはどうすればよいですか？

requestsでjsonパラメータを使用してください: requests.post(url, json=data)。ライブラリはPythonディクショナリを自動的にJSONにシリアライズし、Content-Type: application/jsonヘッダーを設定します。JSONレスポンスを解析するには、response.json()を使用します。

Pythonではrequestsとurllibのどちらを使用すべきですか？

ほとんどのHTTP操作にはrequestsライブラリを使用してください。urllibと比べて、よりクリーンなAPI、自動JSONハンドリング、組み込みセッション管理、より良いエラー処理を提供します。外部パッケージをインストールできない場合のみurllibを使用してください。HTTP/2や非同期サポートが必要な現代のアプリケーションには、httpxを代替として検討してください。

Python requestsのセッションとは何ですか？いつ使用すべきですか？

セッションは同じサーバーへの複数のリクエストにわたって設定（ヘッダー、Cookie、認証）を維持します。APIへの複数のリクエスト、Cookieでのログイン状態の維持、またはパフォーマンス向上のためにTCP接続を再利用したい場合にセッションを使用してください。session = requests.Session()でセッションを作成し、requests.get()の代わりにsession.get()を使用してください。

Python Requestsライブラリ：PythonでHTTPリクエストを行うための完全ガイド

Q: requests.get()とrequests.post()の違いは何ですか？

requests.get()はサーバーからデータを取得し、何も変更しません。主にWebページやAPIデータを取得するために使用されます。requests.post()はリソースを作成または更新するためにデータをサーバーに送信し、フォーム送信、ファイルアップロード、またはサーバーの状態を変更するAPI操作に使用されます。GETリクエストはURLでパラメータを渡し、POSTリクエストはリクエストボディでデータを送信します。

Q: Python requestsに認証を追加するにはどうすればよいですか？

Basic認証の場合はrequests.get(url, auth=('username', 'password'))を使用してください。BearerトークンはAuthorizationヘッダーで追加します: headers = {'Authorization': f'Bearer {token}'}。APIキーの場合はparamsディクショナリのクエリパラメータか'X-API-Key'などのカスタムヘッダーとして追加できます。セッションは複数のリクエストにわたって認証を維持できます。

Name: Soren Atelier

Updated on 2026/2/11

PythonでHTTPリクエストを作る際、標準ライブラリのurllibモジュールを使う方法は、非常に複雑で冗長になりがちです。パラメータのエンコードを手作業で行い、レスポンスオブジェクトを複数のメソッド呼び出しで扱い、単純なAPIリクエストを送るだけでも何十行ものボイラープレートコードを書く必要があります。この複雑さは開発速度を落とし、コードの保守性も下げてしまいます。

Pythonのrequestsライブラリは、HTTP通信のための洗練された人間に優しいAPIを提供することで、こうしたストレスを解消します。REST APIの利用、Webスクレイピング、ファイルアップロード、自動化スクリプトの構築など、どの用途でもrequestsを使えば、わずか数行のコードで直感的かつ分かりやすくHTTP操作を実装できます。

この包括的なガイドでは、基本的なGET/POSTリクエストから、認証、セッション、エラーハンドリング、実際のAPI統合パターンといった高度な機能まで、すべてを学べます。

📚

Python Requestsライブラリのインストール

requestsライブラリはPythonの標準ライブラリには含まれていないため、pipで別途インストールする必要があります。

pip install requests

condaユーザーの場合：

conda install requests

インストールしたら、Pythonスクリプトでインポートできます。

import requests

インストール確認とバージョンチェック：

import requests
print(requests.__version__)

Python RequestsでGETリクエストを送る

GETリクエストは最も一般的なHTTPメソッドで、サーバーからデータを取得するために使われます。requestsライブラリを使うと、GETリクエストは驚くほど簡単です。

基本のGETリクエスト

基本的なGETリクエストは次のとおりです。

import requests
 
response = requests.get('https://api.github.com')
print(response.status_code)  # 200
print(response.text)  # Response body as string

クエリパラメータ付きGETリクエスト

クエリ文字列を手動でURLに組み立てる代わりに、paramsパラメータを使います。

import requests
 
# Method 1: Using params dictionary
params = {
    'q': 'python requests',
    'sort': 'stars',
    'order': 'desc'
}
response = requests.get('https://api.github.com/search/repositories', params=params)
 
# The URL is automatically constructed:
# https://api.github.com/search/repositories?q=python+requests&sort=stars&order=desc
 
print(response.url)  # View the constructed URL
data = response.json()  # Parse JSON response

カスタムヘッダー付きGETリクエスト

多くのAPIでは、認証やコンテンツネゴシエーションのためにカスタムヘッダーが必要です。

import requests
 
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
    'Accept': 'application/json',
    'Accept-Language': 'en-US,en;q=0.9'
}
 
response = requests.get('https://api.example.com/data', headers=headers)
print(response.json())

PythonでPOSTリクエストを送る

POSTリクエストはサーバーにデータを送信します。フォーム送信やAPI操作でよく使われます。

フォームデータを使ったPOSTリクエスト

フォームエンコードされたデータ（HTMLフォーム送信のような形式）を送る場合：

import requests
 
# Send form data
data = {
    'username': 'john_doe',
    'password': 'secret123',
    'remember_me': True
}
 
response = requests.post('https://example.com/login', data=data)
print(response.status_code)

JSONペイロードを使ったPOSTリクエスト

現代のREST APIは通常、JSONペイロードを期待します。requestsライブラリはJSONのシリアライズを自動で処理します。

import requests
 
# Method 1: Using json parameter (recommended)
payload = {
    'name': 'New Project',
    'description': 'A test project',
    'tags': ['python', 'api']
}
 
response = requests.post('https://api.example.com/projects', json=payload)
 
# Method 2: Manual JSON encoding
import json
headers = {'Content-Type': 'application/json'}
response = requests.post(
    'https://api.example.com/projects',
    data=json.dumps(payload),
    headers=headers
)

ファイル付きPOSTリクエスト

filesパラメータでファイルをアップロードできます。

import requests
 
# Upload a single file
files = {'file': open('report.pdf', 'rb')}
response = requests.post('https://example.com/upload', files=files)
 
# Upload multiple files
files = {
    'file1': open('document.pdf', 'rb'),
    'file2': open('image.jpg', 'rb')
}
response = requests.post('https://example.com/upload', files=files)
 
# Upload file with additional form data
files = {'file': open('data.csv', 'rb')}
data = {'description': 'Monthly report', 'category': 'finance'}
response = requests.post('https://example.com/upload', files=files, data=data)

その他のHTTPメソッド：PUT、PATCH、DELETE

requestsライブラリは標準的なHTTPメソッドをすべてサポートしています。

import requests
 
# PUT - Replace entire resource
data = {'name': 'Updated Name', 'status': 'active'}
response = requests.put('https://api.example.com/users/123', json=data)
 
# PATCH - Partially update resource
data = {'status': 'inactive'}
response = requests.patch('https://api.example.com/users/123', json=data)
 
# DELETE - Remove resource
response = requests.delete('https://api.example.com/users/123')
print(response.status_code)  # 204 No Content
 
# HEAD - Get headers only (no response body)
response = requests.head('https://example.com')
print(response.headers)
 
# OPTIONS - Get supported methods
response = requests.options('https://api.example.com/users')
print(response.headers.get('Allow'))

Responseオブジェクトを理解する

Responseオブジェクトには、サーバーからの返信に関するあらゆる情報が含まれます。

import requests
 
response = requests.get('https://api.github.com/users/github')
 
# Status code
print(response.status_code)  # 200, 404, 500, etc.
 
# Response body as string
print(response.text)
 
# Response body as JSON (for JSON APIs)
data = response.json()
print(data['login'])
 
# Raw binary content (for images, files)
image_data = response.content
with open('profile.jpg', 'wb') as f:
    f.write(image_data)
 
# Response headers
print(response.headers)
print(response.headers['Content-Type'])
 
# Encoding
print(response.encoding)  # 'utf-8'
 
# Request information
print(response.request.headers)
print(response.request.url)
 
# Check if request was successful
if response.ok:  # True if status_code < 400
    print("Success!")

リクエストヘッダーの扱い

ヘッダーはリクエストに関する重要なメタデータを運びます。

カスタムヘッダーを設定する

import requests
 
headers = {
    'User-Agent': 'MyApp/1.0',
    'Accept': 'application/json',
    'Accept-Encoding': 'gzip, deflate',
    'Connection': 'keep-alive',
    'Custom-Header': 'custom-value'
}
 
response = requests.get('https://api.example.com', headers=headers)

レスポンスヘッダーにアクセスする

import requests
 
response = requests.get('https://api.github.com')
 
# Dictionary-like access
print(response.headers['Content-Type'])
print(response.headers.get('X-RateLimit-Remaining'))
 
# Case-insensitive access
print(response.headers['content-type'])  # Works!
 
# Iterate all headers
for key, value in response.headers.items():
    print(f"{key}: {value}")

Python Requestsで認証を行う

requestsライブラリは複数の認証方式をサポートしています。

Basic認証

import requests
from requests.auth import HTTPBasicAuth
 
# Method 1: Using auth parameter (recommended)
response = requests.get(
    'https://api.example.com/protected',
    auth=('username', 'password')
)
 
# Method 2: Explicit HTTPBasicAuth
response = requests.get(
    'https://api.example.com/protected',
    auth=HTTPBasicAuth('username', 'password')
)
 
# Method 3: Manual header (not recommended)
import base64
credentials = base64.b64encode(b'username:password').decode('utf-8')
headers = {'Authorization': f'Basic {credentials}'}
response = requests.get('https://api.example.com/protected', headers=headers)

Bearerトークン認証

JWTトークンやOAuth 2.0で一般的です。

import requests
 
token = 'your_access_token_here'
headers = {'Authorization': f'Bearer {token}'}
 
response = requests.get('https://api.example.com/user', headers=headers)

API Key認証

import requests
 
# Method 1: Query parameter
params = {'api_key': 'your_api_key_here'}
response = requests.get('https://api.example.com/data', params=params)
 
# Method 2: Custom header
headers = {'X-API-Key': 'your_api_key_here'}
response = requests.get('https://api.example.com/data', headers=headers)

OAuth 2.0認証

OAuth 2.0にはrequests-oauthlibライブラリを使います。

from requests_oauthlib import OAuth2Session
 
client_id = 'your_client_id'
client_secret = 'your_client_secret'
token_url = 'https://oauth.example.com/token'
 
oauth = OAuth2Session(client_id)
token = oauth.fetch_token(token_url, client_secret=client_secret)
 
# Make authenticated requests
response = oauth.get('https://api.example.com/protected')

永続的な接続のためのSession

Sessionは、複数リクエスト間でCookie、接続プール、設定を維持します。

import requests
 
# Create a session
session = requests.Session()
 
# Set headers for all requests in this session
session.headers.update({
    'User-Agent': 'MyApp/1.0',
    'Accept': 'application/json'
})
 
# Login and session maintains cookies
login_data = {'username': 'john', 'password': 'secret'}
session.post('https://example.com/login', data=login_data)
 
# Subsequent requests use the session cookies
response1 = session.get('https://example.com/dashboard')
response2 = session.get('https://example.com/profile')
 
# Close the session
session.close()

認証付きSession

import requests
 
session = requests.Session()
session.auth = ('username', 'password')
 
# All requests in this session use the authentication
response1 = session.get('https://api.example.com/users')
response2 = session.get('https://api.example.com/posts')

Sessionのコンテキストマネージャ

import requests
 
with requests.Session() as session:
    session.headers.update({'Authorization': 'Bearer token123'})
 
    response1 = session.get('https://api.example.com/data')
    response2 = session.post('https://api.example.com/data', json={'key': 'value'})
 
# Session automatically closed after with block

タイムアウトとリトライ戦略

リクエストが無期限にハングしないよう、常にタイムアウトを設定しましょう。

タイムアウトの設定

import requests
 
# Single timeout value (applies to both connect and read)
response = requests.get('https://api.example.com', timeout=5)
 
# Separate connect and read timeouts
response = requests.get('https://api.example.com', timeout=(3, 10))
# 3 seconds to establish connection, 10 seconds to read response
 
# No timeout (dangerous - may hang forever)
response = requests.get('https://api.example.com', timeout=None)

リトライロジックの実装

import requests
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry
 
# Configure retry strategy
retry_strategy = Retry(
    total=3,  # Total number of retries
    backoff_factor=1,  # Wait 1, 2, 4 seconds between retries
    status_forcelist=[429, 500, 502, 503, 504],  # Retry on these status codes
    allowed_methods=["HEAD", "GET", "OPTIONS", "POST"]
)
 
adapter = HTTPAdapter(max_retries=retry_strategy)
session = requests.Session()
session.mount("http://", adapter)
session.mount("https://", adapter)
 
# Requests will automatically retry on failure
response = session.get('https://api.example.com/data')

Python Requestsのエラーハンドリング

本番運用のアプリケーションでは、堅牢なエラーハンドリングが不可欠です。

よくある例外を扱う

import requests
from requests.exceptions import (
    ConnectionError,
    Timeout,
    HTTPError,
    RequestException
)
 
try:
    response = requests.get('https://api.example.com/data', timeout=5)
    response.raise_for_status()  # Raises HTTPError for 4xx/5xx status codes
    data = response.json()
 
except ConnectionError:
    print("Failed to connect to the server")
 
except Timeout:
    print("Request timed out")
 
except HTTPError as e:
    print(f"HTTP error occurred: {e}")
    print(f"Status code: {e.response.status_code}")
 
except RequestException as e:
    # Catches all requests exceptions
    print(f"An error occurred: {e}")
 
except ValueError:
    # JSON decoding error
    print("Invalid JSON response")

ステータスコードをチェックする

import requests
 
response = requests.get('https://api.example.com/data')
 
# Method 1: Manual check
if response.status_code == 200:
    data = response.json()
elif response.status_code == 404:
    print("Resource not found")
elif response.status_code >= 500:
    print("Server error")
 
# Method 2: Using raise_for_status()
try:
    response.raise_for_status()
    data = response.json()
except requests.exceptions.HTTPError as e:
    if response.status_code == 404:
        print("Resource not found")
    elif response.status_code == 401:
        print("Authentication required")
    else:
        print(f"HTTP error: {e}")
 
# Method 3: Using response.ok
if response.ok:  # True if status_code < 400
    data = response.json()
else:
    print(f"Request failed with status {response.status_code}")

SSL検証と証明書

デフォルトでは、requestsはSSL証明書を検証します。

import requests
 
# Default behavior - verify SSL certificate
response = requests.get('https://api.example.com')
 
# Disable SSL verification (not recommended for production)
response = requests.get('https://example.com', verify=False)
 
# Suppress the InsecureRequestWarning
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
response = requests.get('https://example.com', verify=False)
 
# Use custom CA bundle
response = requests.get('https://example.com', verify='/path/to/ca_bundle.crt')
 
# Client-side certificates
response = requests.get(
    'https://example.com',
    cert=('/path/to/client.crt', '/path/to/client.key')
)

Python Requestsでプロキシを使う

リクエストにプロキシサーバーを設定できます。

import requests
 
# HTTP and HTTPS proxies
proxies = {
    'http': 'http://10.10.1.10:3128',
    'https': 'http://10.10.1.10:1080',
}
 
response = requests.get('https://api.example.com', proxies=proxies)
 
# SOCKS proxy (requires requests[socks])
proxies = {
    'http': 'socks5://user:pass@host:port',
    'https': 'socks5://user:pass@host:port'
}
 
# Use environment variables
# Set HTTP_PROXY and HTTPS_PROXY environment variables
response = requests.get('https://api.example.com')  # Automatically uses env proxies
 
# Disable proxies
response = requests.get('https://api.example.com', proxies={'http': None, 'https': None})

PythonのHTTPライブラリ比較

requestsライブラリを代替案と比較すると次のようになります。

Feature	requests	urllib	httpx	aiohttp
Ease of Use	Excellent (Pythonic API)	Poor (verbose)	Excellent	Good
Async Support	No	No	Yes	Yes
HTTP/2 Support	No	No	Yes	No
Session Management	Built-in	Manual	Built-in	Built-in
JSON Handling	Automatic	Manual	Automatic	Automatic
Connection Pooling	Yes	No	Yes	Yes
Standard Library	No (pip install)	Yes	No (pip install)	No (pip install)
Documentation	Excellent	Good	Excellent	Good
Performance	Good	Fair	Excellent	Excellent (async)
SSL/TLS	Full support	Full support	Full support	Full support
Best For	Synchronous HTTP, general use	Simple scripts, no dependencies	Modern sync/async HTTP	High-performance async

それぞれを使うべき場面：

requests：同期HTTP操作のデフォルト選択肢。Webスクレイピング、API利用、一般的なHTTPタスクに最適。
urllib：外部パッケージをインストールできず、標準ライブラリのみが要件のとき。
httpx：HTTP/2が必要、またはasync機能を備えたrequests互換のモダンAPIが欲しいとき。
aiohttp：多数の同時リクエストを扱う高性能な非同期アプリケーション向け。

レート制限と礼儀正しいスクレイピング

WebサイトのスクレイピングやAPI呼び出しでは、レート制限を実装しましょう。

import requests
import time
from datetime import datetime
 
class RateLimitedSession:
    def __init__(self, requests_per_second=1):
        self.session = requests.Session()
        self.min_interval = 1.0 / requests_per_second
        self.last_request_time = 0
 
    def get(self, url, **kwargs):
        # Wait if necessary
        elapsed = time.time() - self.last_request_time
        if elapsed < self.min_interval:
            time.sleep(self.min_interval - elapsed)
 
        # Make request
        response = self.session.get(url, **kwargs)
        self.last_request_time = time.time()
        return response
 
# Use rate-limited session
session = RateLimitedSession(requests_per_second=2)  # 2 requests per second
 
urls = ['https://api.example.com/item/1', 'https://api.example.com/item/2']
for url in urls:
    response = session.get(url)
    print(f"{datetime.now()}: {response.status_code}")

robots.txtを尊重する

import requests
from urllib.robotparser import RobotFileParser
 
def can_fetch(url, user_agent='MyBot'):
    """Check if URL can be scraped according to robots.txt"""
    rp = RobotFileParser()
    robots_url = f"{url.split('/')[0]}//{url.split('/')[2]}/robots.txt"
    rp.set_url(robots_url)
    rp.read()
    return rp.can_fetch(user_agent, url)
 
url = 'https://example.com/page'
if can_fetch(url):
    response = requests.get(url)
else:
    print("Scraping not allowed by robots.txt")

実例とユースケース

例1：REST APIを利用する

import requests
 
class GitHubAPI:
    def __init__(self, token=None):
        self.base_url = 'https://api.github.com'
        self.session = requests.Session()
        if token:
            self.session.headers.update({'Authorization': f'token {token}'})
 
    def get_user(self, username):
        """Get user information"""
        response = self.session.get(f'{self.base_url}/users/{username}')
        response.raise_for_status()
        return response.json()
 
    def search_repositories(self, query, sort='stars', limit=10):
        """Search repositories"""
        params = {'q': query, 'sort': sort, 'per_page': limit}
        response = self.session.get(f'{self.base_url}/search/repositories', params=params)
        response.raise_for_status()
        return response.json()['items']
 
    def create_issue(self, owner, repo, title, body):
        """Create an issue in a repository"""
        url = f'{self.base_url}/repos/{owner}/{repo}/issues'
        data = {'title': title, 'body': body}
        response = self.session.post(url, json=data)
        response.raise_for_status()
        return response.json()
 
# Usage
api = GitHubAPI(token='your_github_token')
user = api.get_user('torvalds')
print(f"Name: {user['name']}, Followers: {user['followers']}")
 
repos = api.search_repositories('python requests', limit=5)
for repo in repos:
    print(f"{repo['full_name']}: {repo['stargazers_count']} stars")

例2：進捗表示付きでファイルをダウンロードする

import requests
from tqdm import tqdm
 
def download_file(url, filename):
    """Download file with progress bar"""
    response = requests.get(url, stream=True)
    response.raise_for_status()
 
    total_size = int(response.headers.get('content-length', 0))
 
    with open(filename, 'wb') as f, tqdm(
        desc=filename,
        total=total_size,
        unit='B',
        unit_scale=True,
        unit_divisor=1024,
    ) as progress_bar:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)
            progress_bar.update(len(chunk))
 
# Download a file
download_file('https://example.com/large-file.zip', 'downloaded.zip')

例3：エラーハンドリング付きのWebスクレイピング

import requests
from bs4 import BeautifulSoup
import time
 
def scrape_articles(base_url, max_pages=5):
    """Scrape article titles from a news website"""
    session = requests.Session()
    session.headers.update({
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    })
 
    articles = []
 
    for page in range(1, max_pages + 1):
        try:
            url = f"{base_url}?page={page}"
            response = session.get(url, timeout=10)
            response.raise_for_status()
 
            soup = BeautifulSoup(response.content, 'html.parser')
            titles = soup.find_all('h2', class_='article-title')
 
            for title in titles:
                articles.append({
                    'title': title.text.strip(),
                    'url': title.find('a')['href'] if title.find('a') else None
                })
 
            print(f"Scraped page {page}: {len(titles)} articles")
            time.sleep(1)  # Rate limiting
 
        except requests.exceptions.RequestException as e:
            print(f"Error scraping page {page}: {e}")
            continue
 
    return articles
 
# Usage
articles = scrape_articles('https://news.example.com/articles', max_pages=3)
print(f"Total articles collected: {len(articles)}")

例4：ページネーション付きAPI統合

import requests
 
def fetch_all_items(api_url, headers=None):
    """Fetch all items from a paginated API"""
    items = []
    page = 1
 
    while True:
        try:
            params = {'page': page, 'per_page': 100}
            response = requests.get(api_url, params=params, headers=headers, timeout=10)
            response.raise_for_status()
 
            data = response.json()
 
            if not data:  # No more items
                break
 
            items.extend(data)
            print(f"Fetched page {page}: {len(data)} items")
 
            page += 1
 
            # Check for pagination in headers
            if 'Link' in response.headers:
                links = response.headers['Link']
                if 'rel="next"' not in links:
                    break
 
        except requests.exceptions.RequestException as e:
            print(f"Error fetching page {page}: {e}")
            break
 
    return items
 
# Usage
all_items = fetch_all_items('https://api.example.com/items')
print(f"Total items: {len(all_items)}")

JupyterでRunCellを使ってAPIをテストする

API連携の開発・テストを行う際、RunCell (opens in a new tab)はJupyter notebook上で直接使えるAI搭載のエージェント環境を提供します。HTTPリクエストとレスポンスを手作業でデバッグする代わりに、RunCellのインテリジェントなエージェントが次のことを支援します。

適切な認証を含むAPIリクエストの自動構築とテスト
レスポンス解析やエラーハンドリングのリアルタイムデバッグ
よくあるHTTPパターンのコードスニペット生成
期待するスキーマに対するAPIレスポンスの検証
APIレスポンスからのデータ変換を素早く反復

これは、複数段階の認証、ページネーション処理、複雑なデータパースロジックが必要なAPIを扱うときに特に有用です。RunCellは、HTTPリクエストを手動でテストする際の往復作業を減らし、開発ワークフローを加速させます。

FAQ

Python requestsライブラリは何に使われますか？

Python requestsライブラリは、WebサーバーやAPIにHTTPリクエストを送るために使われます。Webページの取得、REST APIの利用、フォームデータ送信、ファイルアップロード、認証処理などを簡単にします。直感的なAPIと包括的な機能セットにより、Pythonで最も人気のあるHTTPライブラリです。

Python requestsライブラリはどうやってインストールしますか？

pipでpip install requestsを実行してインストールします。conda環境ではconda install requestsを使います。インストール後はPythonコード内でimport requestsとして読み込みます。requestsは標準ライブラリではないため、インストールが必要です。

requests.get()とrequests.post()の違いは何ですか？

requests.get()はサーバーのデータを取得し、通常は何も変更しません（WebページやAPIデータの取得に使用）。requests.post()はデータをサーバーに送信してリソースを作成・更新します（フォーム送信、ファイルアップロード、サーバー状態を変更するAPI操作などで使用）。GETはURLにパラメータを渡し、POSTはリクエストボディにデータを送ります。

Python requestsライブラリでエラーを処理するには？

try-exceptで例外を捕捉します。ネットワーク問題はConnectionError、遅い応答はTimeout、4xx/5xxステータスはHTTPError、その他はRequestExceptionで包括的に扱えます。各リクエスト後にresponse.raise_for_status()を呼ぶと、失敗時に自動でHTTPErrorが発生します。また、リクエストが無期限に停止しないよう常にタイムアウトを設定してください。

Python requestsでJSONデータを送るには？

requests.post(url, json=data)のようにjsonパラメータを使います。Pythonのdictを自動でJSONにシリアライズし、Content-Type: application/jsonヘッダーも設定します。JSONレスポンスのパースにはresponse.json()を使い、レスポンスボディをPythonのdictにデシリアライズします。

Pythonではrequestsとurllibのどちらを使うべきですか？

ほとんどのHTTP操作ではrequestsを使うべきです。urllibと比べてAPIが分かりやすく、JSONの自動処理、セッション管理の内蔵、エラーハンドリングの改善などの利点があります。外部パッケージをインストールできず、標準ライブラリのみが必須の場合に限ってurllibを使います。HTTP/2やasync対応が必要なモダンなアプリケーションでは、代替としてhttpxも検討できます。

Python requestsに認証を追加するには？

Basic認証はrequests.get(url, auth=('username', 'password'))を使います。Bearerトークン（JWT、OAuthなど）はAuthorizationヘッダーを追加します：headers = {'Authorization': f'Bearer {token}'}。APIキーはparamsに入れてクエリパラメータとして渡すか、'X-API-Key'のようなカスタムヘッダーで渡します。Sessionを使うと複数リクエストに認証を保持できます。

Python requestsのセッション（sessions）とは何で、いつ使うべきですか？

Sessionは、同じサーバーへの複数リクエストに対して設定（ヘッダー、Cookie、認証）を維持します。APIに対して複数回リクエストする場合、Cookieでログイン状態を維持したい場合、TCP接続を再利用してパフォーマンスを上げたい場合に使います。session = requests.Session()で作成し、requests.get()の代わりにsession.get()を使います。

まとめ

Python requestsライブラリは、PythonでHTTP通信を行うための不可欠なツールです。洗練されたAPIにより、複雑なHTTP操作をシンプルで読みやすいコードに変換できます。基本的なGETリクエストから、認証、セッション、ファイルアップロード、エラーハンドリングといった高度な機能まで、堅牢なHTTPインタラクションに必要なものが揃っています。

このガイドで紹介したパターンとベストプラクティス（タイムアウト設定、リトライロジックの実装、丁寧なエラー処理、レート制限の尊重）を身につけることで、WebサービスやAPIと効果的に通信できる信頼性の高いアプリケーションを構築できます。REST APIの利用、Webスクレイピング、自動化ツールの構築など、どの用途でもrequestsはHTTP操作を分かりやすく、保守しやすい形にしてくれます。

📚