Python Requests 라이브러리 스니펫

1 Python Requests 라이브러리 소개

requests 라이브러리는 Python의 우아한 HTTP 클라이언트로, API 호출을 마치 당연한 것처럼 느끼게 해줍니다. HTTP의 복잡한 세부 사항을 추상화하면서도 강력한 기능을 그대로 유지합니다. 간단한 페이지 가져오기부터 복잡한 인증 흐름까지, 인터넷을 위한 신뢰할 수 있는 택배 기사라고 생각하세요.

개발자들이 이 라이브러리를 사랑하는 이유:

인간 친화적: API가 암호 같은 HTTP 전문 용어가 아닌 일반 영어처럼 읽힙니다.
내장 JSON: 자동 파싱으로 반복적인 파싱 작업을 줄여줍니다.
세션 지원: 쿠키와 연결 풀링을 자동으로 유지해 줍니다.
강력한 오류 처리: 암호 같은 상태 코드 대신 명확한 예외를 제공합니다.
SSL 검증: 기본적으로 안전하며, 필요에 따라 유연하게 설정할 수 있습니다.

데이터를 가져올 준비가 되셨나요? 기본부터 시작해 봅시다.

2 사전 요구 사항: Python & Pip

requests 라이브러리를 설치하려면 Python 3.6+와 pip가 필요합니다. 설정을 확인해 봅시다:

python --version && pip --version

해당 명령이 작동하면 준비된 것입니다. 그렇지 않다면 python.org에서 Python을 다운로드하세요. pip는 자동으로 함께 설치됩니다.

3 Requests 라이브러리 설치

먼저, 새로운 가상 환경을 생성해 봅시다. 이렇게 하면 프로젝트 종속성을 깔끔하게 유지하고 버전 충돌을 방지할 수 있습니다:

python -m venv .venv && source .venv/bin/activate  # macOS/Linux
# or
python -m venv .venv && .venv\Scripts\activate  # Windows

이제 pip를 사용하여 requests를 설치합니다:

pip install requests

4 첫 GET 요청

가장 일반적인 작업인 데이터 가져오기부터 시작해 봅시다. 이 간단한 스니펫은 공개 API에서 JSON 응답을 가져옵니다:

import requests

response = requests.get('https://httpbin.org/json')
print(f"Status: {response.status_code}")
print(f"Content-Type: {response.headers['content-type']}")

# Automatic JSON parsing
data = response.json()
print(f"Keys: {list(data.keys())}")

자동 JSON 파싱에 주목하세요. requests는 콘텐츠 유형을 감지하고 자동으로 파싱합니다. 수동 json.loads() 작업이 필요 없습니다.

5 데이터를 포함한 POST 요청

서버로 데이터를 보내시겠습니까? POST 요청은 폼 데이터, JSON, 파일을 원활하게 처리합니다. 일반적인 패턴은 다음과 같습니다:

import requests

# Send form data
form_data = {'username': 'alice', 'password': 'secret123'}
response = requests.post('https://httpbin.org/post', data=form_data)

# Send JSON data (automatically sets Content-Type header)
json_data = {'name': 'Alice', 'email': '[email protected]'}
response = requests.post('https://httpbin.org/post', json=json_data)

print(f"Status: {response.status_code}")
print(f"Response: {response.json()}")

json 매개변수는 올바른 헤더를 자동으로 설정하고 데이터를 직렬화합니다. 수동 헤더 설정보다 훨씬 깔끔합니다.

6 맞춤 헤더 및 인증

API는 종종 맞춤 헤더와 인증이 필요합니다. Requests는 내장 인증 클래스를 사용하여 이를 간단하게 만듭니다:

import requests
from requests.auth import HTTPBasicAuth, HTTPDigestAuth

# Custom headers
headers = {
    'User-Agent': 'MyApp/1.0',
    'Accept': 'application/json',
    'X-API-Key': 'your-api-key-here'
}

response = requests.get('https://httpbin.org/headers', headers=headers)
print(response.json())

# Basic Authentication
auth = HTTPBasicAuth('username', 'password')
response = requests.get('https://httpbin.org/basic-auth/user/pass', auth=auth)

# API Key in header
api_key = 'sk-1234567890abcdef'
headers = {'Authorization': f'Bearer {api_key}'}
response = requests.get('https://httpbin.org/bearer', headers=headers)

HTTPBasicAuth와 HTTPDigestAuth는 자동으로 인코딩을 처리합니다. 최신 API의 경우 Bearer 토큰을 Authorization 헤더에 사용하는 것이 표준입니다.

7 오류 처리 및 상태 코드

견고한 애플리케이션은 오류를 우아하게 처리합니다. Requests는 네트워크 문제에 대해 예외를 발생시키고 상세한 응답 객체를 제공합니다:

import requests
from requests.exceptions import RequestException, Timeout, ConnectionError

try:
    response = requests.get('https://httpbin.org/status/404', timeout=5)
    
    # Raise an exception for bad status codes
    response.raise_for_status()
    
except Timeout:
    print("Request timed out after 5 seconds")
except ConnectionError:
    print("Failed to connect to server")
except RequestException as e:
    print(f"Request failed: {e}")
    
else:
    print(f"Success! Status: {response.status_code}")
    print(f"Headers: {response.headers}")
    print(f"Body: {response.text[:100]}...")  # First 100 chars
    
# Manual status code checking
if response.status_code == 200:
    data = response.json()
    print("Data received:", data)
elif response.status_code == 404:
    print("Resource not found")
else:
    print(f"Unexpected status: {response.status_code}")

raise_for_status()는 4xx/5xx 응답에 대해 HTTPError를 발생시킵니다. 타임아웃은 애플리케이션이 무기한 중단되는 것을 방지합니다.

8 JSON 처리 및 데이터 핸들링

JSON 데이터를 효율적으로 작업하는 것은 requests 라이브러리의 강점입니다. 인코딩, 디코딩 및 유효성 검사를 자동으로 처리합니다:

import requests

# Complex JSON handling
response = requests.get('https://httpbin.org/json')

# Safe JSON parsing with error handling
try:
    data = response.json()
    print(f"Type: {type(data)}")
    print(f"Keys: {data.keys() if isinstance(data, dict) else 'Not a dict'}")
except ValueError as e:
    print(f"Invalid JSON: {e}")
    print(f"Raw content: {response.text}")

# Working with nested data
user_data = {
    'name': 'Alice Johnson',
    'email': '[email protected]',
    'preferences': {
        'theme': 'dark',
        'notifications': True,
        'language': 'en'
    }
}

# Send complex nested JSON
response = requests.post('https://httpbin.org/post', json=user_data)
result = response.json()

# Access nested values
nested = result.get('json', {}).get('preferences', {})
theme = nested.get('theme', 'light')
print(f"User theme: {theme}")

KeyError 예외를 피하려면 항상 get()과 같은 안전한 메서드를 사용하여 중첩된 JSON에 액세스하세요.

9 파일 다운로드 및 스트리밍

효율적인 파일 다운로드는 메모리 문제를 방지합니다. 대용량 파일의 경우 스트리밍을 사용하고 콘텐츠 유형을 확인하세요:

import requests
import os
from pathlib import Path

# Download a file
url = 'https://httpbin.org/image/jpeg'
response = requests.get(url, stream=True)

if response.status_code == 200:
    # Create downloads directory
    downloads_dir = Path('downloads')
    downloads_dir.mkdir(exist_ok=True)
    
    # Save file
    file_path = downloads_dir / 'image.jpg'
    with open(file_path, 'wb') as f:
        for chunk in response.iter_content(chunk_size=8192):
            if chunk:  # Filter out keep-alive chunks
                f.write(chunk)
    
    print(f"Downloaded {file_path} ({file_path.stat().st_size} bytes)")
else:
    print(f"Download failed: {response.status_code}")

# Get file info before downloading
head_response = requests.head(url)
content_length = head_response.headers.get('content-length')
content_type = head_response.headers.get('content-type')

print(f"File size: {content_length} bytes")
print(f"Content type: {content_type}")

# Download with progress
def download_with_progress(url, filename):
    response = requests.get(url, stream=True)
    total_size = int(response.headers.get('content-length', 0))
    
    with open(filename, 'wb') as f:
        downloaded = 0
        for chunk in response.iter_content(chunk_size=1024):
            if chunk:
                f.write(chunk)
                downloaded += len(chunk)
                
                # Print progress
                if total_size > 0:
                    progress = (downloaded / total_size) * 100
                    print(f"Progress: {progress:.1f}%")

스트림 다운로드는 전체 파일을 메모리에 로드하는 것을 방지합니다. 대용량 이미지, 문서 또는 미디어 파일에 적합합니다.

10 세션 관리 및 쿠키

로그인 세션과 같이 요청 간에 상태를 유지해야 하는 애플리케이션의 경우 requests Session 객체를 사용하십시오:

import requests

# Create a session for persistent connections and cookies
session = requests.Session()

# Set default headers for all requests
session.headers.update({
    'User-Agent': 'MyApp/1.0',
    'Accept': 'application/json'
})

# Automatically handles cookies, connection pooling, and redirects
response1 = session.get('https://httpbin.org/cookies/set/session_id/abc123')
print("Cookies set:", response1.cookies.get_dict())

# Subsequent requests include the cookies
response2 = session.get('https://httpbin.org/cookies')
print("Cookies received:", response2.json())

# Session-level configuration
session.auth = ('username', 'password')
session.timeout = 10

# Use context manager for automatic cleanup
with requests.Session() as s:
    response = s.get('https://httpbin.org/json')
    data = response.json()
    print("Using context manager")
    
# Manual cookie handling
cookies = {'sessionid': 'abc123', 'csrftoken': 'xyz789'}
response = requests.get('https://httpbin.org/cookies', cookies=cookies)
print("Manual cookies:", response.json())

세션은 연결 풀링을 자동으로 처리하므로 후속 요청 속도가 빨라지고 서버 부하가 줄어듭니다.

11 모범 사례 및 일반적인 패턴

전문적인 HTTP 클라이언트는 특정 패턴을 따릅니다. 프로덕션 코드에 대한 검증된 모범 사례는 다음과 같습니다:

import requests
import logging
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

# Configure logging for debugging
logging.basicConfig(level=logging.WARNING)  # Reduce noise
logger = logging.getLogger(__name__)

class APIClient:
    def __init__(self, base_url, timeout=10, max_retries=3):
        self.session = requests.Session()
        
        # Retry strategy for transient failures
        retry_strategy = Retry(
            total=max_retries,
            status_forcelist=[429, 500, 502, 503, 504],
            method_whitelist=["HEAD", "GET", "OPTIONS"],
            backoff_factor=1
        )
        
        adapter = HTTPAdapter(max_retries=retry_strategy)
        self.session.mount("http://", adapter)
        self.session.mount("https://", adapter)
        
        self.base_url = base_url
        self.timeout = timeout
    
    def get(self, endpoint, **kwargs):
        """Perform GET request with error handling"""
        url = f"{self.base_url.rstrip('/')}/{endpoint.lstrip('/')}"
        
        try:
            response = self.session.get(url, timeout=self.timeout, **kwargs)
            response.raise_for_status()
            return response
        except requests.RequestException as e:
            logger.error(f"Request failed: {e}")
            raise
    
    def post(self, endpoint, **kwargs):
        """Perform POST request"""
        url = f"{self.base_url.rstrip('/')}/{endpoint.lstrip('/')}"
        return self.session.post(url, timeout=self.timeout, **kwargs)

# Usage example
api = APIClient('https://httpbin.org')
try:
    response = api.get('json')
    data = response.json()
    print(f"Got data: {list(data.keys())}")
except Exception as e:
    print(f"API call failed: {e}")

# Environment-based configuration
import os

API_BASE_URL = os.getenv('API_BASE_URL', 'https://httpbin.org')
API_KEY = os.getenv('API_KEY', 'dev-key')

headers = {
    'Authorization': f'Bearer {API_KEY}',
    'User-Agent': f'MyApp/{__version__}'
}

이러한 패턴은 재시도, 올바른 오류 로깅, 환경 구성을 처리하고 API 상호 작용을 위한 깔끔한 추상화 계층을 생성합니다.

핵심 요약

• 연결 풀링 및 쿠키 관리를 위해 세션 사용
• 항상 타임아웃 및 오류 처리 구현
• 자동 직렬화를 위해 json= 매개변수 활용
• 메모리 관리를 위해 대용량 파일 다운로드 스트리밍
• 환경 변수 사용하여 구성