How To Set Up Logging in Python 3 (Output to File and Console)

Intermediate

Why Logging Matters in Python

You’re debugging a production issue, but your application is silent. You added a few print() statements weeks ago, the messages got buried in the terminal, and now you have no idea what’s happening. Or worse: your app is logging to console, but the logs disappear the moment the process restarts. You need a way to capture what your application is doing—when it’s doing it, at what severity level, and where it should be recorded.

This is where Python’s built-in logging module becomes essential. Unlike print() statements, which are crude and destructive once you delete them, the logging module is a professional-grade system designed for production applications. It comes built-in to Python, requires no external dependencies, and provides granular control over message levels, formatting, and output destinations.

In this article, you’ll learn how to set up the logging module to output messages simultaneously to both your console (for immediate feedback during development) and to a file (for long-term record-keeping and debugging). We’ll cover logging levels, handlers, formatters, log rotation to prevent massive log files, and the patterns used in real multi-module projects. By the end, you’ll understand how to instrument your code with logging that developers trust.

How To Set Up Logging: Quick Example

Here’s a minimal example that outputs log messages to both console and file:

# quick_logging_example.py
import logging

# Create a logger
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)

# File handler
file_handler = logging.FileHandler("app.log")
file_handler.setLevel(logging.DEBUG)

# Console handler
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)

# Formatter
formatter = logging.Formatter(
    "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)

# Add handlers to logger
logger.addHandler(file_handler)
logger.addHandler(console_handler)

# Log some messages
logger.debug("Debug message (goes to file only)")
logger.info("Info message (goes to both)")
logger.warning("Warning message (goes to both)")
logger.error("Error message (goes to both)")
logger.critical("Critical message (goes to both)")

Output (to console):

2026-03-29 14:22:15,342 - __main__ - INFO - Info message (goes to both)
2026-03-29 14:22:15,343 - __main__ - WARNING - Warning message (goes to both)
2026-03-29 14:22:15,344 - __main__ - ERROR - Error message (goes to both)
2026-03-29 14:22:15,344 - __main__ - CRITICAL - Critical message (goes to both)

Output (written to app.log):

2026-03-29 14:22:15,341 - __main__ - DEBUG - Debug message (goes to file only)
2026-03-29 14:22:15,342 - __main__ - INFO - Info message (goes to both)
2026-03-29 14:22:15,343 - __main__ - WARNING - Warning message (goes to both)
2026-03-29 14:22:15,344 - __main__ - ERROR - Error message (goes to both)
2026-03-29 14:22:15,344 - __main__ - CRITICAL - Critical message (goes to both)

Notice the key pattern: we created a logger, attached two separate handlers (one for files, one for console), set different levels for each, and applied a formatter that includes timestamps and severity levels. This is the foundation for everything that follows. The sections below show you how to customize each piece.

What is Python Logging and Why Use It?

The logging module is Python’s standard library tool for recording events that happen during program execution. Unlike print statements, logging provides:

• Severity levels — categorize messages by importance (DEBUG, INFO, WARNING, ERROR, CRITICAL)
• Multiple outputs — send logs to files, console, email, syslog, or custom handlers simultaneously
• Formatting control — include timestamps, function names, line numbers, and custom metadata
• Filtering — selectively log messages based on logger name, level, or custom criteria
• No side effects — unlike print, you can leave logging code in production without cluttering output

The alternative—using print() for debugging—breaks down immediately:

Aspect	print() Statements	logging Module
Disable in production	Must manually remove	Adjust level, keep code in place
Output destination	Always stdout	File, console, email, or custom
Timestamps	Manual string concatenation	Automatic, customizable format
Severity levels	None	DEBUG, INFO, WARNING, ERROR, CRITICAL
Performance	Always evaluates	Can be filtered; lazy evaluation
Multi-module coordination	No built-in support	Hierarchical logger names

The logging module is designed for exactly what you need: professional-grade event recording that stays in your code indefinitely.

Understanding Logging Levels

Python’s logging module defines five standard severity levels, plus a catch-all NOTSET. Each level has a numeric value, and loggers will only record messages at or above their configured level:

Level	Numeric Value	When to Use	Example
DEBUG	10	Detailed diagnostic info for debugging	Variable values, function entry/exit, loop iterations
INFO	20	General informational messages	Application startup, config loaded, request received
WARNING	30	Something unexpected or potentially harmful	Deprecated API usage, missing optional config, retrying failed request
ERROR	40	A serious problem; some operation failed	File not found, API returned 500, database connection lost
CRITICAL	50	A very serious error; program may not continue	Out of memory, permissions denied, unrecoverable system error

When you set a logger’s level to INFO, it will log INFO, WARNING, ERROR, and CRITICAL messages—but not DEBUG messages. This is how you control verbosity.

# logging_levels_demo.py
import logging

logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)

# Add a console handler so we can see output
handler = logging.StreamHandler()
handler.setLevel(logging.WARNING)
formatter = logging.Formatter("%(levelname)s - %(message)s")
handler.setFormatter(formatter)
logger.addHandler(handler)

# These will NOT appear (level is below WARNING)
logger.debug("This is a debug message")
logger.info("This is an info message")

# These WILL appear
logger.warning("This is a warning message")
logger.error("This is an error message")
logger.critical("This is a critical message")

Output:

WARNING - This is a warning message
ERROR - This is an error message
CRITICAL - This is a critical message

Notice: the logger itself has one level (DEBUG), but the console handler has a different level (WARNING). You can filter messages at multiple levels—first at the logger, then at each handler. This is crucial for sending different messages to different outputs (e.g., all DEBUG messages to a debug log file, only ERROR+ to a critical alert file).

Handlers and Formatters: Controlling Where and How Logs Go

A logger is just a container. The actual work happens in handlers and formatters:

• Handler — an output destination. FileHandler writes to a file, StreamHandler writes to console, etc.
• Formatter — defines how log messages are formatted: which fields to include (timestamp, function name, etc.) and in what order

You create a handler, assign a formatter to it, set a level, and attach it to a logger. A single logger can have multiple handlers, each with different levels and formatters.

Creating a StreamHandler (Console Output):

# stream_handler_example.py
import logging

logger = logging.getLogger("myapp")
logger.setLevel(logging.DEBUG)

# Create a console handler
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)

# Format: timestamp, logger name, level, message
formatter = logging.Formatter(
    "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
console_handler.setFormatter(formatter)

logger.addHandler(console_handler)

logger.info("Application started")
logger.warning("This is a warning")
logger.error("An error occurred")

Output:

2026-03-29 14:25:30,123 - myapp - INFO - Application started
2026-03-29 14:25:30,124 - myapp - WARNING - This is a warning
2026-03-29 14:25:30,125 - myapp - ERROR - An error occurred

The %(asctime)s token automatically includes a timestamp. Other useful tokens include %(funcName)s (the function name), %(lineno)d (line number), and %(module)s (the module filename).

Creating a FileHandler (File Output):

# file_handler_example.py
import logging

logger = logging.getLogger("myapp")
logger.setLevel(logging.DEBUG)

# Create a file handler
file_handler = logging.FileHandler("app.log")
file_handler.setLevel(logging.DEBUG)

formatter = logging.Formatter(
    "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
file_handler.setFormatter(formatter)

logger.addHandler(file_handler)

logger.debug("Debug: application starting")
logger.info("Info: loading configuration")
logger.warning("Warning: deprecated API used")
logger.error("Error: failed to connect to database")

After running this, check your app.log file. All four messages will be there because the file handler’s level is DEBUG.

Output (written to app.log):

2026-03-29 14:27:01,456 - myapp - DEBUG - Debug: application starting
2026-03-29 14:27:01,457 - myapp - INFO - Info: loading configuration
2026-03-29 14:27:01,458 - myapp - WARNING - Warning: deprecated API used
2026-03-29 14:27:01,459 - myapp - ERROR - Error: failed to connect to database

Logging to Console and File Simultaneously

The most common pattern in production is to send all logs to a file (for permanent record) and only show WARNING+ messages on the console (for immediate visibility during operation). Here’s how:

# console_and_file_logging.py
import logging
import os

# Create a logger
logger = logging.getLogger("myapp")
logger.setLevel(logging.DEBUG)

# Create log directory if it doesn't exist
log_dir = "logs"
if not os.path.exists(log_dir):
    os.makedirs(log_dir)

# File handler: captures all messages
file_handler = logging.FileHandler(os.path.join(log_dir, "app.log"))
file_handler.setLevel(logging.DEBUG)

# Console handler: shows only warnings and above
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.WARNING)

# Shared formatter for both handlers
formatter = logging.Formatter(
    "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S"
)
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)

# Attach handlers to logger
logger.addHandler(file_handler)
logger.addHandler(console_handler)

# Lof messages at different levels
logger.debug("Starting application initialization")
logger.info("Configuration loaded successfully")
logger.info("Database connection established")
logger.warning("API response time is higher than usual")
logger.error("Failed to write to cache, continuing without cache")
logger.critical("Memory usage exceeded safe threshold")

Output (to console):

2026-03-29 14:30:12 - myapp - WARNING - API response time is higher than usual
2026-03-29 14:30:12 - myapp - ERROR - Failed to write to cache, continuing without cache
2026-03-29 14:30:12 - myapp - CRITICAL - Memory usage exceeded safe threshold

Output (written to logs/app.log):

2026-03-29 14:30:12 - myapp - DEBUG - Starting application initialization
2026-03-29 14:30:12 - myapp - INFO - Configuration loaded successfully
2026-03-29 14:30:12 - myapp - INFO - Database connection established
2026-03-29 14:30:12 - myapp - WARNING - API response time is higher than usual
2026-03-29 14:30:12 - myapp - ERROR - Failed to write to cache, continuing without cache
2026-03-29 14:30:12 - myapp - CRITICAL - Memory usage exceeded safe threshold

This pattern is powerful: you get a permanent record of everything (including debug messages developers need when troubleshooting), but the console stays clean during normal operation—only showing problems that need immediate attention. When a warning or error occurs, developers see it right away.

Custom Log Formatting with Timestamps and Metadata

The formatter string controls what information appears in each log message. The most useful format tokens are:

Token	Meaning	Example
%(asctime)s	Timestamp (human-readable)	2026-03-29 14:30:12,456
%(name)s	Logger name	myapp.database
%(levelname)s	Severity level	INFO, WARNING, ERROR
%(message)s	The actual log message	Database query completed
%(funcName)s	Name of function that logged	connect_to_db
%(filename)s	Source filename	database.py
%(lineno)d	Line number in source	42
%(module)s	Module name	database
%(process[=]d	Process ID	12345
%(thread)d	Thread ID	140256789012345

Here are some practical format examples:

# formatting_examples.py
import logging

logger = logging.getLogger("myapp")
logger.setLevel(logging.DEBUG)

# Example 1: Detailed format with function and line number
handler1 = logging.StreamHandler()
formatter1 = logging.Formatter(
    "%(asctime)s [%(levelname)s] %(funcName)s:;%(lineno)d - %(message)s"
)
handler1.setFormatter(formatter1)

# Example 2: Compact format (good for production)
handler2_formatter = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"

# Example 3: Include module name (useful in multi-file projects)
handler3_formatter = (
    "[%(asctime)s] %(module)s - %(levelname)s - %(message)s"
)

# Example 4: ISO 8601 timestamp with timezone
handler4 = logging.StreamHandler()
formatter4 = logging.Formatter(
    "%(asctime)s - %(levelname)s - %(message)s",
    datefmt="%Y-%m-%dT%H:%M:%S"
)
handler4.setFormatter(formatter4)

logger.addHandler(handler1)

def process_payment(user_id):
    logger.info(f"Processing payment for user {user_id}")
    logger.debug("Validating card information")
    logger.info("Payment submitted to processor")
    return True

process_payment(12345)

Output (Example 1 format):

2026-03-29 14:32:45,123 [INFO] process_payment:55 - Processing payment for user 12345
2026-03-29 14:32:45,124 [DEBUG] process_payment:56 - Validating card information
2026-03-29:0;( 14:32:45,125 [INFO] process_payment:57 - Payment submitted to processor

Controlling Log File Size with Log Rotation

If your application runs 24/7 and logs every request, your log files can grow huge in notime, wasting disk space. The solution is CotatingFileRotationHandler, which automatically recicycles old log files:

# log_rotation_example.py
import logging
i¤‰©ort logging.handlers  # Important!i

logger = logging.getLogger("myapp")
logger.setLevel(logging.DEBUG)

# Use RotatingFileHandler instead of FileHandler!
# Makes a new file every 000 1000 messages or 1 MB, whichever comes first
# Keeps an other to backup files
rotating_handler = logging.handlers.RotatingFileHandler(
    filename="app.log",
    maxBytes=1048576,  # 1 MB (optional)
    backupCount=5  # Keep up to 5 backup files
)

# Take the same formatter as before
formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
rotating_handler.setFormatter(formatter)

logger.addHandler(rotating_handler)

# Now you can log directly without worrying about file size!
for i in range(10000):
    logger.info(f"Processing request {i}")

# app.log will be rotated to: app.log.1, app.log.2, etc. as it grows past 1 MB
//_The oldest backups are deleted automatically staying under 10 MB total.

Output (logs directory):

- WF app.log (1 MB)
- WF app.log.1 (1 MB)
- WF app.log.2 (500 KB)
- WF app.log.3 (450 KB)
- WF app.log.4 (425 KB)
- WF app.log.5 (400 KB)
 (project has processed ~6350KB = 63.5 MB since rotation started)

The rotating handler automatically deletes oldest files when it exceeds the backupCount - saving space.

Logging in Multi-File, Multi-Module Projects

For anything beyond a tiny script, use hierarchical logger names based on the module structure:

45,125 [INFO] process_payment:57 – Payment submitted to processor

The detailed format is invaluable when debugging: you know exactly which function logged the message and on which line. For production systems receiving hundreds of requests per second, the compact format reduces file size while keeping essential information.

Preventing Massive Log Files with RotatingFileHandler

If your application runs 24/7, a single FileHandler will eventually create a multi-gigabyte log file. The solution is RotatingFileHandler, which automatically archives old log files and starts a new one when the current file reaches a size limit.

# rotating_file_handler_example.py
import logging
from logging.handlers import RotatingFileHandler
import os

logger = logging.getLogger("myapp")
logger.setLevel(logging.DEBUG)

# Create log directory
log_dir = "logs"
if not os.path.exists(log_dir):
    os.makedirs(log_dir)

# RotatingFileHandler: max 1 MB per file, keep 5 backups
rotating_handler = RotatingFileHandler(
    filename=os.path.join(log_dir, "app.log"),
    maxBytes=1024 * 1024,  # 1 MB
    backupCount=5          # Keep app.log.1, app.log.2, ..., app.log.5
)
rotating_handler.setLevel(logging.DEBUG)

formatter = logging.Formatter(
    "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
rotating_handler.setFormatter(formatter)

logger.addHandler(rotating_handler)

# Simulate some logging activity
for i in range(100):
    logger.info(f"Processing item {i}: " + "X" * 100)  # Verbose message

When app.log reaches 1 MB, the handler automatically renames it to app.log.1, creates a fresh app.log, and continues logging. After 5 rotations, the oldest file is deleted. This keeps your disk usage bounded while preserving recent log history.

For time-based rotation (e.g., “create a new log file each day”), use TimedRotatingFileHandler:

# timed_rotating_file_handler_example.py
import logging
from logging.handlers import TimedRotatingFileHandler
import os

logger = logging.getLogger("myapp")
logger.setLevel(logging.DEBUG)

log_dir = "logs"
if not os.path.exists(log_dir):
    os.makedirs(log_dir)

# Create a new log file every day at midnight
timed_handler = TimedRotatingFileHandler(
    filename=os.path.join(log_dir, "app.log"),
    when="midnight",       # Rotate at midnight
    interval=1,            # Every 1 day
    backupCount=7          # Keep 7 days of logs
)
timed_handler.setLevel(logging.DEBUG)

formatter = logging.Formatter(
    "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
timed_handler.setFormatter(formatter)

logger.addHandler(timed_handler)

logger.info("Daily log rotation is configured")

The `when` parameter accepts values like "midnight" (daily), "W0" (Monday), "H" (hourly), etc. This is the preferred approach for long-running services where you want to correlate logs with calendar time.

Real-World Pattern: Logging in Multi-Module Projects

Most projects have multiple modules. The best practice is to:

1. Configure logging once in your main module (or in a centralized config module)
2. In each module, create a logger with logging.getLogger(__name__)
3. Log directly—no need to pass handlers around

Here’s how it works:

File: config.py (centralized logging setup)

# config.py
import logging
import logging.handlers
import os

def setup_logging():
    """Configure logging for the entire application."""
    # Root logger
    root_logger = logging.getLogger()
    root_logger.setLevel(logging.DEBUG)

    # Create logs directory
    log_dir = "logs"
    if not os.path.exists(log_dir):
        os.makedirs(log_dir)

    # File handler (all messages)
    file_handler = logging.handlers.RotatingFileHandler(
        filename=os.path.join(log_dir, "app.log"),
        maxBytes=5 * 1024 * 1024,  # 5 MB
        backupCount=10
    )
    file_handler.setLevel(logging.DEBUG)

    # Console handler (warnings only)
    console_handler = logging.StreamHandler()
    console_handler.setLevel(logging.WARNING)

    # Formatter
    formatter = logging.Formatter(
        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
    )
    file_handler.setFormatter(formatter)
    console_handler.setFormatter(formatter)

    # Attach handlers
    root_logger.addHandler(file_handler)
    root_logger.addHandler(console_handler)\Üٝ[HŠBˆ™]\›ˆȜÝ]\Ȏˆ›ÚȟBˆ^Ù\^Ù\[ۈ\ÈN‚ˆÙÙÙ\‹™\œ›ÜŠˆ”™\]Y\ݘZ[YˆÙ_HŠBˆ˜Z\ÙOØÛÙOÜ™O‚‚Ý›Û™Ï‘š[NˆXZ[‹œH
\XØ][ۈ[žHÚ[
OÜݛۙϏ܂‚™OÛÙOˆÈXZ[‹œBš[\ܝÙÙÚ[™Â™œ›ÛHÛۙšYÈ[\ܝÙ]\ÛÙÙÚ[™Âš[\ܝ]X˜\ÙBš[\ܝ\B‚ˆÈÛۙšYÝ\™HÙÙÚ[™ÈӐÑH]Ý\\œÙ]\ÛÙÙÚ[™Ê
B‚›ÙÙÙ\ˆHÙÙÚ[™Ë™Ù]ÙÙÙ\Š×ۘ[YW×ÊB‚™YˆXZ[Š
N‚ˆÙÙÙ\‹š[™›Ê\XØ][ۈÝ\YŠB‚ˆÈ[Ù[\È]]ÛX]XØ[H\ÙHHÛۙšYÝ\™YÙÙÚ[™ÂˆYˆ]X˜\ÙK˜Ûۛ™XÝÝ×Ù]X˜\ÙJ›ØØ[ÜÝ‹
M̊N‚ˆ]X˜\ÙK™^XÝ]WÜ]Y\žJ”ÑSPÕ
ˆ”“ÓH\Ù\œÈSRULŠB‚ˆžN‚ˆ™\Ý[H\Kš[™Wܙ\]Y\Ý
‹Ø\KÝ\Ù\œÈŠBˆÙÙÙ\‹š[™›ÊˆTH™]\›™Yˆܙ\Ý[HŠBˆ^Ù\^Ù\[ۈ\ÈN‚ˆÙÙÙ\‹™^Ù\[ۊˆTH\œ›ÜŽˆÙ_HŠB‚ˆÙÙÙ\‹š[™›Ê\XØ][ۈÚ]ÝۈŠB‚šYˆ×ۘ[YW×ÈOH—×ÛXZ[—×Ȏ‚ˆXZ[Š
OØÛÙOÜ™O‚‚Ý›Û™Ï“Ý]]
ÈÛۜÛÛJNÜݛۙϏ܂‚™OÛÙOŒŒ‹LËLŽHMŒÍNŒŒLŒÈH›ÛÝHS‘“ÈH\XØ][ۈÝ\YŒŒ‹LËLŽHMŒÍNŒŒLHH]X˜\ÙHHS‘“ÈH]X˜\ÙHÛۛ™XÝ[ۈ\ÝX›\ÚYŒŒ‹LËLŽHMŒÍNŒŒLÈH]X˜\ÙHHS‘“ÈH]Y\žH^XÝ]YÝXØÙ\Üٝ[BŒŒ‹LËLŽHMŒÍNŒŒLŽHH\HHS‘“ÈH™\]Y\Ý›ØÙ\ÜÙYÝXØÙ\Üٝ[BŒŒ‹LËLŽHMŒÍNŒŒLÌHH×ÛXZ[—×ÈHS‘“ÈHTH™]\›™YˆÉÜÝ]\ÉΈ	ÛÚÉßBŒŒ‹LËLŽHMŒÍNŒŒLÌÈH×ÛXZ[—×ÈHS‘“ÈH\XØ][ۈÚ]ÝۏØÛÙOÜ™O‚‚Ý›Û™Ï“Ý]]
ܚ][ˆÈÙÜËØ\›ÙÊNÜݛۙϏ܂‚™OÛÙOŒŒ‹LËLŽHMŒÍNŒŒLŒH×ÛXZ[—×ÈHS‘“ÈH\XØ][ۈÝ\YŒŒ‹LËLŽHMŒÍNŒŒLŒHH]X˜\ÙHHS‘“ÈHÛۛ™XÝ[™ÈÈ]X˜\ÙH]ØØ[ÜݍM̂ŒŒ‹LËLŽHMŒÍNŒŒLŒˆH]X˜\ÙHHP•QÈH\Ú[™ÈÛۛ™XÝ[ۈ[Y[Ý]وÌÙXÛۙŒŒ‹LËLŽHMŒÍNŒŒLŒÈH]X˜\ÙHHS‘“ÈH]X˜\ÙHÛۛ™XÝ[ۈ\ÝX›\ÚYŒŒ‹LËLŽHMŒÍNŒŒLH]X˜\ÙHHP•QÈH^XÝ][™È]Y\žNˆÑSPÕ
ˆ”“ÓH\Ù\œÈSRUL‹‹‚ŒŒ‹LËLŽHMŒÍNŒŒLHH]X˜\ÙHHS‘“ÈH]Y\žH^XÝ]YÝXØÙ\Üٝ[BŒŒ‹LËLŽHMŒÍNŒŒLˆH\HHS‘“ÈH™XÙZ]™Y™\]Y\݈Ø\KÝ\Ù\œÂŒŒ‹LËLŽHMŒÍNŒŒLÈH\HHP•QÈH˜[Y][™È™\]Y\Ý\˜[Y]\œÂŒŒ‹LËLŽHMŒÍNŒŒLŽH\HHS‘“ÈH™\]Y\Ý›ØÙ\ÜÙYÝXØÙ\Üٝ[BŒŒ‹LËLŽHMŒÍNŒŒLŽHH×ÛXZ[—×ÈHS‘“ÈHTH™]\›™YˆÉÜÝ]\ÉΈ	ÛÚÉßBŒŒ‹LËLŽHMŒÍNŒŒLÌHH×ÛXZ[—×ÈHS‘“ÈH\XØ][ۈÚ]ÝۏØÛÙOÜ™O‚‚•HÙ^H[œÚYÚˆžH\Ú[™ÈÛÙO›ÙÙÙ\ˆHÙÙÚ[™Ë™Ù]ÙÙÙ\Š×ۘ[YW×ÊOØÛÙOˆ[ˆXXÚ[Ù[KÙÙÙ\œÈ\™H]]ÛX]XØ[HY\˜\˜ÚXØ[ˆÛÙO˜\KœOØÛÙO‰ÜÈÙÙÙ\ˆ\Ș[YYÛÙOˆ˜\HØÛÙO‹ÛÙO™]X˜\ÙKœOØÛÙO‰ÜÈ\ÈÛÙOˆ™]X˜\ÙHØÛÙO‹[™[و[H™\ÜXÝHÛۙšYÝ\˜][ۈÙ][ˆÛÙO˜ÛۙšY˜OØÛÙO‹ˆ[ÝHÛۙšYÝ\™HۘÙNÈ]™\žH[Ù[HÙ]ÈH[™\œÈ[™›Ü›X][™È]]ÛX]XØ[KÜ‚‚KKHSPQÑWÔPÑRÓTŽˆ\˜Ú]XÝ™]šY]Ú[™È›Y\š[ÈوHZ[[™ÈÚ]][\H›ÛܜˈØ\[ێˆ“Û™HÙÙÚ[™ÈÛۙšYÝ\˜][ۋˆޙ[œÈو[Ù[\ˈY\˜\˜ÚXØ[ÙÙÙ\œÈ[™HHÛÛܙ[˜][ۋˆˆKO‚‚ˆYH˜ÛÛ[[ۋ[Z\ÝZÙ\ȏÛÛ[[ۈZ\ÝZÙ\È[™XYÙÚ[™È\ÏÚ‚‚ÈYH›Z\ÝZÙKY\XØ]KZ[™\œÈ“Z\ÝZÙHNˆ\XØ]H[™\œÈ
\XØ]HÙÈY\ÜØYÙ\ÊOÚς‚•H[ÜÝÛÛ[[ۈYΈ[ÝHYH[™\‹]Y\ÜØYÙ\È\X\ˆÚXÙKˆ\È\ÝX[H\[œÈÚ[ˆ[ÝHØ[ÛÙOœÙ]\ÛÙÙÚ[™Ê
OØÛÙOˆ][\H[Y\ΏÜ‚‚™OÛÙOˆÈԓӑÈHÚ[Ø]\ÙH\XØ]HY\ÜØYÙ\œÙ]\ÛÙÙÚ[™Ê
BœÙ]\ÛÙÙÚ[™Ê
HÈÛÜÈHYY[™\œÈYØZ[ØÛÙOÜ™O‚‚”ÛÛ][ێˆØ[Ù]\ۘÙH]\XØ][ۈÝ\\ˆYˆ[ÝIܙH[ˆH\ÝÝZ]KÛX\ˆ[™\œÈ™]ÙY[ˆ\ÝΏÜ‚‚™OÛÙOˆÈÛX\ˆ^\Ý[™È[™\œÈ™Y›Ü™H™XÛۙšYÝ\š[™Â›ÙÙÙ\ˆHÙÙÚ[™Ë™Ù]ÙÙÙ\Š
B™›Üˆ[™\ˆ[ˆÙÙÙ\‹š[™\œÖΗN‚ˆÙÙÙ\‹œ™[[ݙR[™\Š[™\ŠOØÛÙOÜ™O‚‚ÈYH›Z\ÝZÙK]ܛۙË[ÙÙÙ\‹[˜[YH“Z\ÝZÙHŽˆܛۙÈÙÙÙ\ˆ˜[YOÚς‚’Yˆ[ÝHÈÛÙO›ÙÙÚ[™Ë™Ù]ÙÙÙ\Šš\™ÛÙYۘ[YHŠOØÛÙOˆ[œÝXYوÛÙO›ÙÙÚ[™Ë™Ù]ÙÙÙ\Š×ۘ[YW×ÊOØÛÙO‹[ÝHÜÙHHXš[]HÈš[\ˆžH[Ù[Kˆ[Ø^\È\ÙHÛÙO—×ۘ[YW×ÏØÛÙOŽÜ‚‚™OÛÙOˆÈԓӑ›ÙÙÙ\ˆHÙÙÚ[™Ë™Ù]ÙÙÙ\Š›^X\ŠHÈ[[Ù[\Ș[YY›^X\‚‚ˆÈ’QÒ›ÙÙÙ\ˆHÙÙÚ[™Ë™Ù]ÙÙÙ\Š×ۘ[YW×ÊHÈXXÚ[Ù[H\È]ÈÝۈÙÙÙ\ØÛÙOÜ™O‚‚ÈYH›Z\ÝZÙKY›Ü™Ù][™ËY›Ü›X]\ˆ“Z\ÝZÙHΈ›È›Ü›X]\ˆ
[Y\Ý[\ÈZ\ÜÚ[™ÊOÚς‚’Yˆ[ÝHYH[™\ˆ]ۉÝÙ]H›Ü›X]\‹[ÝIÛÙ]H˜\™HY\ÜØYÙHÚ]›È[Y\Ý[\܈Û۝^Ü‚‚™OÛÙOˆÈÝ]]Ú]Ý]›Ü›X]\‚”›ØÙ\ÜÚ[™È][HB‚ˆÈÝ]]Ú]›Ü›X]\‚ŒŒ‹LËLŽHMŒÍNŒŒLŒÈH×ÛXZ[—×ÈHS‘“ÈH›ØÙ\ÜÚ[™È][HOØÛÙOÜ™O‚‚[Ø^\È]XÚH›Ü›X]\ˆÈ[™\œÈ]ܚ]HÈš[\ˈÛۜÛÛH[™\œÈØ[ˆÛܚÈÚ]Ý]]]	ÜÈ™]\ˆÈ]™HÛۜÚ\Ý[›Ü›X][™È]™\ž]Ú\™KÜ‚‚ÈYH›Z\ÝZÙKZ[™\‹[]™[]œË[ÙÙÙ\‹[]™[“Z\ÝZÙH
ˆÛۙ\Ú[™È[™\ˆ]™[œÈÙÙÙ\ˆ]™[Úς‚‘XXÚÙÙÙ\ˆ[™XXÚ[™\ˆ\È]ÈÝۈ]™[ˆ›Ýš[\œÈ\NÜ‚‚™OÛÙOˆÈÙÙÙ\ˆ]™[ˆP•QÈH[ÝÜÈ]™\ž][™È›ÝYڈȚ[H[™\ˆ]™[ˆS‘“ÈHš[\œÈÈS‘“È[™X›Ý™BˆÈ™\Ý[ˆP•QÈY\ÜØYÙ\ÈÛÈÈÛۜÛÛH]“Õš[B‚›ÙÙÙ\‹œÙ]]™[
ÙÙÚ[™Ë‘P•QÊB™š[WÚ[™\‹œÙ]]™[
ÙÙÚ[™Ë’S‘“ÊB‚›ÙÙÙ\‹™XYÊ•\È™XXÚ\ÈÛۜÛÛH]›Ýš[HŠHÈÛۙ\Ú[™ÈOØÛÙOÜ™O‚‚™\ݘXÝXÙNˆÙ]HÙÙÙ\ˆ]™[ÈP•QÈ
HÝÙ\Ý
K[ˆš[\ˆ]XXÚ[™\ŽÜ‚‚™OÛÙO›ÙÙÙ\‹œÙ]]™[
ÙÙÚ[™Ë‘P•QÊHÈ][™\œÈXÚYHÚ]ÈÙY\™š[WÚ[™\‹œÙ]]™[
ÙÙÚ[™Ë‘P•QÊHÈš[HÙ]È]™\ž][™Â˜ÛۜÛÛWÚ[™\‹œÙ]]™[
ÙÙÚ[™Ë•ÐT“’S‘ÊHÈÛۜÛÛHÙ]ÈØ\›š[™ÜÈۛOØÛÙOÜ™O‚‚ÈYH›Z\ÝZÙKY^Ù\[ۜË[›Ý[ÙÙÙY“Z\ÝZÙH
Nˆ^Ù\[ۜÈۉÝ[˜ÛYH˜XÙX˜XÚÜÏÚς‚•\ÙHÛÙO›ÙÙÙ\‹™^Ù\[ۊ
OØÛÙOˆ
›ÝÛÙO›ÙÙÙ\‹™\œ›ÜŠ
OØÛÙOŠHÚ[ˆÙÙÚ[™È[œÚYH[ˆ^Ù\[ۈ[™\ˆÈ[˜ÛYHH[˜XÙX˜XÚΏÜ‚‚™OÛÙOˆÈԓӑÈH›È˜XÙX˜XڝžN‚ˆš\ÚÞWÛÜ\˜][ۊ
B™^Ù\^Ù\[ۈ\ÈN‚ˆÙÙÙ\‹™\œ›ÜŠˆ‘˜Z[YˆÙ_HŠB‚ˆÈ’QÒH[˜ÛY\ȝ[˜XÙX˜XڝžN‚ˆš\ÚÞWÛÜ\˜][ۊ
B™^Ù\^Ù\[ۈ\ÈN‚ˆÙÙÙ\‹™^Ù\[ۊˆ‘˜Z[YˆÙ_HŠOØÛÙOÜ™O‚‚Ý›Û™Ï“Ý]]Ú]ÙÙÙ\‹™^Ù\[ۊ
NÜݛۙϏ܂‚™OÛÙO‘T”“ÔˆH˜Z[Yˆ]š\Ú[ۈžH™\›Â•˜XÙX˜XÚÈ
[ÜÝ™XÙ[Ø[\Ý
N‚ˆš[H›XZ[‹œH‹[™HL‹[ˆXZ[‚ˆš\ÚÞWÛÜ\˜][ۊ
Bˆš[H][˜H‹[™H
K[ˆš\ÚÞWÛÜ\˜][ۂˆ™]\›ˆLÈ–™\›Ñ]š\Ú[ۑ\œ›ÜŽˆ]š\Ú[ۈžH™\›ÏØÛÙOÜ™O‚‚ˆYHœ™X[[Y™KY^[\H”™X[SY™H^[\NˆHÙXˆØܘ\\ˆÚ]ÛÛ\™Z[œÚ]™HÙÙÚ[™ÏÚ‚‚“]	ÜȝZ[H™X[\ÝXțڙX݈HÙXˆØܘ\\ˆ]ÙÜÈțݚ[H[™ÛۜÛÛHÚ]›Ý][ۋ[™\È\œ›ÜœÈܘXÙY[K[™›ÝšY\È]Z[YXYÙÚ[™È[™›Ü›X][ۋÜ‚‚KKHSPQÑWÔPÑRÓTŽˆÜY\ˆÙXˆÚ]]HÚ[È™Z[™ÈØ\\™Y[™ܙØ[š^™YˆØ\[ێˆ•ÙXˆØܘ\\œÈ[ÈH݈ÛÛÙÙÙÚ[™È\›œÈÚ]\ˆ[È[[YÙ[˜ÙKˆˆKO‚‚™OÛÙOˆÈÙX—ÜØܘ\\—ÝÚ]ÛÙÙÚ[™ËœBš[\ܝÙÙÚ[™Âš[\ܝÙÙÚ[™Ëš[™\œÂš[\ܝÜš[\ܝ[YB™œ›ÛH\›X‹œ™\]Y\Ý[\ܝ\›Ü[‚™œ›ÛH\›X‹™\œ›Üˆ[\ܝT“\œ›Ü‚š[\ܝœÛۂ‚ˆÈÛۙšYÝ\™HÙÙÚ[™Â™YˆÙ]\ÛÙÙÚ[™Ê
N‚ˆÙÙÙ\ˆHÙÙÚ[™Ë™Ù]ÙÙÙ\ŠÙXœØܘ\\ˆŠBˆÙÙÙ\‹œÙ]]™[
ÙÙÚ[™Ë‘P•QÊB‚ˆÙ×Ù\ˆH›ÙÜȂˆYˆ›Ýܘ]™^\ÝÊÙ×Ù\ŠN‚ˆܲXZÙY\œÊÙ×Ù\ŠB‚ˆÈš[H[™\Žˆ[Y\ÜØYÙ\Ë›Ý]\È]ˆP‚ˆš[WÚ[™\ˆHÙÙÚ[™Ëš[™\œË”›Ý][™Ñš[R[™\Šˆš[[˜[YO[ܘ]š›Ú[ŠÙ×Ù\‹œØܘ\\‹›ÙȊKˆX^ž]\ÏLˆ
ˆL
ˆLˆ˜XÚÝ\ÛÝ[MBˆ
Bˆš[WÚ[™\‹œÙ]]™[
ÙÙÚ[™Ë‘P•QÊB‚ˆÈÛۜÛÛH[™\ŽˆØ\›š[™ÜÈۛBˆÛۜÛÛWÚ[™\ˆHÙÙÚ[™Ë”Ý™X[R[™\Š
BˆÛۜÛÛWÚ[™\‹œÙ]]™[
ÙÙÚ[™Ë•ÐT“’S‘ÊB‚ˆÈ›Ü›X]\ˆÚ]]Z[Y[™›Âˆ›Ü›X]\ˆHÙÙÚ[™Ë‘›Ü›X]\Šˆ‰J\ØÝ[YJ\ÈÉJ]™[˜[YJ\×H	J[˜Ó˜[YJ\Ώ‰J[™[›ÊYH	JY\ÜØYÙJ\ȋˆ]Y›]H‰VKI[KIY	R‰SN‰TȂˆ
Bˆš[WÚ[™\‹œÙ]›Ü›X]\Š›Ü›X]\ŠBˆÛۜÛÛWÚ[™\‹œÙ]›Ü›X]\Š›Ü›X]\ŠB‚ˆÙÙÙ\‹˜Y[™\Šš[WÚ[™\ŠBˆÙÙÙ\‹˜Y[™\ŠÛۜÛÛWÚ[™\ŠB‚ˆ™]\›ˆÙÙÙ\‚‚›ÙÙÙ\ˆHÙ]\ÛÙÙÚ[™Ê
B‚™Yˆ™]ÚڜÛۊ\›[Y[Ý]MJN‚ˆˆˆ‘™]Ú[™\œÙH”Óӈœ›ÛHHT“ˆˆˆ‚ˆÙÙÙ\‹™XYʈ][\[™ÈÈ™]ÚˆÝ\›HŠB‚ˆžN‚ˆÚ]\›Ü[Š\›[Y[Ý]][Y[Ý]
H\È™\ÜۜÙN‚ˆ]HHœÛۋ›ØYÊ™\ÜۜÙKœ™XY

K™XÛÙJ]‹NŠJBˆÙÙÙ\‹š[™›Êˆ”ÝXØÙ\Üٝ[H™]ÚYÛ[Š]J_H™XÛܙÈœ›ÛHÝ\›HŠBˆ™]\›ˆ]B‚ˆ^Ù\T“\œ›Üˆ\ÈN‚ˆÙÙÙ\‹™\œ›ÜŠˆ“™]ÛܚÈ\œ›Üˆ™]Ú[™ÈÝ\›NˆÙ_HŠBˆ™]\›ˆ›Û™B‚ˆ^Ù\œÛۋ’”ÓӑXÛÙQ\œ›Üˆ\ÈN‚ˆÙÙÙ\‹™\œ›ÜŠˆ‘˜Z[YÈ\œÙH”Óӈœ›ÛHÝ\›NˆÙ_HŠBˆ™]\›ˆ›Û™B‚ˆ^Ù\^Ù\[ۈ\ÈN‚ˆÙÙÙ\‹™^Ù\[ۊˆ•[™^XÝY\œ›Üˆ™]Ú[™ÈÝ\›HŠBˆ™]\›ˆ›Û™B‚™Yˆ›ØÙ\Ü×Ù]J]JN‚ˆˆˆ”›ØÙ\ÜÈ™]ÚY]Kˆˆˆ‚ˆYˆ›Ý]N‚ˆÙÙÙ\‹Ø\›š[™Ê“›È]HÈ›ØÙ\ÜȊBˆ™]\›ˆ‚ˆÙÙÙ\‹š[™›Êˆ”›ØÙ\ÜÚ[™ÈÛ[Š]J_H][\ȊBˆ›ØÙ\ÜÙYH‚ˆ›ÜˆK][H[ˆ[[Y\˜]J]JN‚ˆžN‚ˆÈÚ[][]H›ØÙ\ÜÚ[™ÂˆYˆ\Ú[œÝ[˜ÙJ][KXÝ
N‚ˆ›ØÙ\ÜÙY
ÏHBˆYˆH	HLOH‚ˆÙÙÙ\‹™XYʈ”›ØÙ\ÜÙYÚ_H][\ȊB‚ˆ^Ù\^Ù\[ۈ\ÈN‚ˆÙÙÙ\‹Ø\›š[™Êˆ‘˜Z[YÈ›ØÙ\ÜÈ][HÚ_NˆÙ_HŠB‚ˆÙÙÙ\‹š[™›Êˆ”ÝXØÙ\Üٝ[H›ØÙ\ÜÙYÜ›ØÙ\ÜÙYKÞÛ[Š]J_H][\ȊBˆ™]\›ˆ›ØÙ\ÜÙY‚™YˆXZ[Š
N‚ˆÙÙÙ\‹š[™›Ê•ÙXˆØܘ\\ˆÝ\YŠB‚ˆÈ™]Úœ›ÛH”ÓӔXÙZÛ\ˆ
œ™YH˜ZÙH”ÓӈTJBˆ\›Hš΋ËڜÛۜXÙZÛ\‹\XÛÙK˜ÛÛKÜÜÝȂ‚ˆÙÙÙ\‹™XYʈÛۙšYÝ\˜][ێˆ[Y[Ý]M\ËX^ܙ]šY\ÏLȊB‚ˆ]HH™]ÚڜÛۊ\›
B‚ˆYˆ]N‚ˆ›ØÙ\ÜÙYH›ØÙ\Ü×Ù]J]JBˆÙÙÙ\‹š[™›Êˆ”Øܘ\[™ÈÛÛ\]YˆÜ›ØÙ\ÜÙYH][\È›ØÙ\ÜÙYŠBˆ[ÙN‚ˆÙÙÙ\‹™\œ›ÜŠ”Øܘ\[™È˜Z[Yˆ[˜X›HÈ™]Ú]HŠB‚ˆÙÙÙ\‹š[™›Ê•ÙXˆØܘ\\ˆš[š\ÚYŠB‚šYˆ×ۘ[YW×ÈOH—×ÛXZ[—×Ȏ‚ˆžN‚ˆXZ[Š
Bˆ^Ù\Ù^X›Ø\™[\œ\‚ˆÙÙÙ\‹Ø\›š[™Ê”Øܘ\\ˆ[\œ\YžH\Ù\ˆŠBˆ^Ù\^Ù\[ۈ\ÈN‚ˆÙÙÙ\‹™^Ù\[ۊ‘˜][\œ›Üˆ[ˆXZ[ˆŠBˆ˜Z\ÙOØÛÙOÜ™O‚‚Ý›Û™Ï“Ý]]
ÈÛۜÛÛJNÜݛۙϏ܂‚™OÛÙOŒŒ‹LËLŽHMŒMHÒS‘“×HXZ[ŽŽHÙXˆØܘ\\ˆÝ\YŒŒ‹LËLŽHMŒMˆÒS‘“×H™]ÚڜÛێHÝXØÙ\Üٝ[H™]ÚYL™XÛܙÈœ›ÛH΋ËڜÛۜXÙZÛ\‹\XÛÙK˜ÛÛKÜÜÝŒŒ‹LËLŽHMŒMˆÒS‘“×H›ØÙ\Ü×Ù]NŒˆH›ØÙ\ÜÚ[™ÈL][\ŒŒ‹LËLŽHMŒMˆÒS‘“×H›ØÙ\Ü×Ù]NŽHÝXØÙ\Üٝ[H›ØÙ\ÜÙYLÌL][\ŒŒ‹LËLŽHMŒMˆÒS‘“×HXZ[ŽŽÈHØܘ\[™ÈÛÛ\]YˆL][\È›ØÙ\ÜÙYŒŒ‹LËLŽHMŒMˆÒS‘“×HXZ[ŽŽ
HÙXˆØܘ\\ˆš[š\ÚYØÛÙOÜ™O‚‚ˆÝ›Û™Ï“Ý]]
[ˆÙÜËÜØܘ\\‹›ÙÊNÜݛۙϏ܂‚™OÛÙOŒŒ‹LËLŽHMŒMHÒS‘“×HXZ[ŽŽHÙXˆØܘ\\ˆÝ\YŒŒ‹LËLŽHMŒMHÑP•Q×HXZ[ŽŽˆHÛۙšYÝ\˜][ێˆ[Y[Ý]M\ËX^ܙ]šY\ÏLŒŒ‹LËLŽHMŒMHÑP•Q×H™]ÚڜÛێHH][\[™ÈÈ™]Úˆ΋ËڜÛۜXÙZÛ\‹\XÛÙK˜ÛÛKÜÜÝŒŒ‹LËLŽHMŒMˆÒS‘“×H™]ÚڜÛێHÝXØÙ\Üٝ[H™]ÚYL™XÛܙÈœ›ÛH΋ËڜÛۜXÙZÛ\‹\XÛÙK˜ÛÛKÜÜÝŒŒ‹LËLŽHMŒMˆÒS‘“×H›ØÙ\Ü×Ù]NŒˆH›ØÙ\ÜÚ[™ÈL][\ŒŒ‹LËLŽHMŒMˆÑP•Q×H›ØÙ\Ü×Ù]NHH›ØÙ\ÜÙY][\ŒŒ‹LËLŽHMŒMˆÑP•Q×H›ØÙ\Ü×Ù]NHH›ØÙ\ÜÙYL][\ŒŒ‹LËLŽHMŒMˆÑP•Q×H›ØÙ\Ü×Ù]NHH›ØÙ\ÜÙYŒ][\‹‹‹ˆ
[ܙHXYÈY\ÜØYÙ\ÊBŒŒ‹LËLŽHMŒMˆÑP•Q×H›ØÙ\Ü×Ù]NHH›ØÙ\ÜÙYL][\ŒŒ‹LËLŽHMŒMˆÒS‘“×H›ØÙ\Ü×Ù]NŽHÝXØÙ\Üٝ[H›ØÙ\ÜÙYLÌL][\ŒŒ‹LËLŽHMŒMˆÒS‘“×HXZ[ŽŽÈHØܘ\[™ÈÛÛ\]YˆL][\È›ØÙ\ÜÙYŒŒ‹LËLŽHMŒMˆÒS‘“×HXZ[ŽŽ
HÙXˆØܘ\\ˆš[š\ÚYØÛÙOÜ™O‚‚ˆ•\È^[\H[[ۜݘ]\È™\ݘXÝXÙ\ΈÙ]\ÙÙÚ[™ÈۘÙK\ÙH[Ù[K[]™[ÙÙÙ\ˆÚ]ÛÙO—×ۘ[YW×ÏØÛÙO‹[™H^Ù\[ۜÈÚ]Û۝^[˜ÛYHXYË[]™[XYۛÜÝXÜț܈›ÝX›\ÚÛÝ[™Ë[™\ÙHS‘“ÈY\ÜØYÙ\ÈȘXÚÈH\H]ˆÚ[ˆH›Ø›[HØØÝ\œËHXYÈÙÈ\È[H]Z[ÎÈHÛۜÛÛHÝ^\È]ZY][[ÛÛY][™ÈXÝX[HÛÙ\ÈܛۙˏÜ‚‚ˆYH™˜\H‘œ™\]Y[H\ÚÙY]Y\Ý[ۜÏÚ‚‚ÈYH™˜\KX˜\ÚXØÛۙšYȏ”NˆÚHÙ\Ș\ÚXÐÛۙšYÈÛÛY][Y\È›ÝÛܚÏÏÚς‚ÛÙO›ÙÙÚ[™Ë˜˜\ÚXÐÛۙšYÊ
OØÛÙOˆÛۙšYÝ\™\ÈH›ÛÝÙÙÙ\‹]ۛHYˆ›È[™\œÈ]™H™Y[ˆYYY]ˆۘÙH[ÝHYH[™\ˆ
]™[ˆ[ˆHXœ˜\žH[ÝIܙH\Ú[™ÊKÛÙO˜˜\ÚXÐÛۙšYÊ
OØÛÙOˆ™XÛÛY\ÈH›Ë[܈›Üˆ\È™X\Ûۋ]›ÚYÛÙO˜˜\ÚXÐÛۙšYÊ
OØÛÙOˆ[ˆ›ÙXÝ[ۈÛÙKˆ[œÝXY\ÙHH]\›ˆœ›ÛHH][K[[Ù[H^[\NˆܙX]HHÙ]\[˜Ý[ۈ]ÛۙšYÝ\™\È[™\œÈ^XÚ]HۈH›ÛÝÙÙÙ\‹Ü‚‚ÈYH™˜\K\\™›Ü›X[˜ÙH”NˆÙ\ÈÙÙÚ[™È\\™›Ü›X[˜ÙOÏÚς‚“›ÝÚYۚYšXØ[KˆHÙÙÚ[™È[Ù[H\ÈÜ[Z^™Y[™[ÝHØ[ˆ\ØX›H^[œÚ]™HÜ\˜][ۜˈYˆ[ÝIܙHÛۘÙ\›™Y\ÙH^žH]˜[X][ێˆÛÙO›ÙÙÙ\‹™XYʈ•˜[YNˆÙ^[œÚ]™Wٝ[˜Ý[ۊ
_HŠOØÛÙOˆۛHØ[ÈH[˜Ý[ۈYˆP•QÈ\È[˜X›Yˆ[\›˜]]™[KÚXÚÈH]™[š\œÝˆÛÙOšYˆÙÙÙ\‹š\Ñ[˜X›Y›ÜŠÙÙÚ[™Ë‘P•QÊNˆÙÙÙ\‹™XYÊ‹‹ŠOØÛÙO‹ˆ›Üˆ[ÜÝ\XØ][ۜËÙÙÚ[™È\È™YÛYÚX›Hݙ\šXYÜ‚‚ÈYH™˜\K]™XY\ØY™H”Nˆ\ÈÙÙÚ[™È™XY\ØY™OÏÚς‚–Y\ˈHÙÙÚ[™È[Ù[H\Ù\ÈØÚÜÈ[\›˜[HÈÛÛܙ[˜]HXØÙ\ÜÈÈ[™\œËˆ[ÝHØ[ˆØY™[HØ[ÙÙÙ\ˆY]ÙÈœ›ÛH][\H™XYÈÚ]Ý]Ûܜ\[ۋˆÝÙ]™\‹H[™\œÈ[\Ù[™\È
\ÜXÚX[HÝ\ÝÛH[™\œÊHÚÝ[[ÛÈ™H™XY\ØY™KˆZ[Z[ˆ[™\œÈZÙHÛÙO‘š[R[™\ØÛÙOˆ\™HØY™KÜ‚‚ÈYH™˜\K[ÙËY›Ü›X]]ÚÙ[œÈ”NˆÚ]Ý\ˆ›Ü›X]ÚÙ[œÈ\™H]˜Z[X›H™^[ۙHÛÛ[[ۈۙ\ÏÏÚς‚“X[žKˆÛÙO‰J]™[›ÊYØÛÙOˆ
[Y\šXÈ]™[
KÛÙO‰J]˜[YJ\ÏØÛÙOˆ
[š[H]
KÛÙO‰J›ØÙ\ÜӘ[YJ\ÏØÛÙOˆ
›ØÙ\ÜȘ[YJKÛÙO‰J™XY˜[YJ\ÏØÛÙOˆ
™XY˜[YJK[™ÛÙO‰J\ÙXÜÊYØÛÙOˆ
Z[\ÙXÛۙÊKˆÙYHHٙšXÚX[]ۈØÝ[Y[][ۈ›ÜˆHÛÛ\]H\݈[ÜݛڙXÝÈÝXÚÈÚ]HÚÙ[œÈÚÝۈX\›Y\ˆ™XØ]\ÙH^IܙHH[ÜÝ\ÙY[Ü‚‚ÈYH™˜\KY\ØX›K[Xœ˜\žK[ÙÜȏ”NˆÝÈÈHÚ[[˜ÙH™\˜›ÜÙHÙÜÈœ›ÛH\™\\HXœ˜\šY\ÏÏÚς‚”Ù]HÙÙÙ\ˆ›Üˆ]Xœ˜\žHÈHYÚ\ˆ]™[ˆXœ˜\šY\È\ÙHÛÙO›ÙÙÚ[™Ë™Ù]ÙÙÙ\Š×ۘ[YW×ÊOØÛÙO‹ÛÈ[ÝHØ[ˆΈÛÙO›ÙÙÚ[™Ë™Ù]ÙÙÙ\Šœ™\]Y\ÝȊKœÙ]]™[
ÙÙÚ[™Ë•ÐT“’S‘ÊOØÛÙOˆÈÚ[[˜ÙHH™\]Y\ÝÈXœ˜\žKˆ\È\ÈHÛÛ[[ۈ]\›ˆÚ[ˆ[Yܘ][™È][\HXœ˜\šY\È]ÙÈX]š[KÜ‚‚ÈYH™˜\K\Þ\ÛÙȏ”NˆÝÈÈHÙÈÈÞ\ÛÙÈ܈›Ý\›˜[ÝÏÚς‚•\ÙHÛÙO›ÙÙÚ[™Ëš[™\œË”Þ\ÓÙÒ[™\ØÛÙOˆ[œÝXYوÛÙO‘š[R[™\ØÛÙO‹ˆۈ[š^Ó[^Þ\Ý[\ΈÛÙOš[™\ˆHÙÙÚ[™Ëš[™\œË”Þ\ÓÙÒ[™\ŠY™\ÜÏJ	ËÙ]‹ÛÙÉË
JOØÛÙO‹ˆۈÞ\Ý[\ÈÚ]›Ý\›˜[Ý\ÙHÛÙO”Þ\ÓÙÒ[™\ŠY™\ÜÏJ	ÛØØ[ÜÝ	Ë
LM
JOØÛÙO‹ˆ\È\È[\ܝ[›ÜˆۙË\[›š[™ÈÙ\šXÙ\È]Þ\Ý[YX[˜YÙ\ˏÜ‚‚ˆYH˜ÛۘÛ\Ú[ۈÛۘÛ\Ú[ۏÚ‚‚–[ÝH›ÝÈ[™\œÝ[™ÝÈÈ[œÝ[Y[]ۈ\XØ][ۜÈÚ]›Ù™\ÜÚ[ۘ[YܘYHÙÙÚ[™Ëˆ[ÝIݙHX\›™YÈܙX]HÙÙÙ\œË]XÚ[™\œÈ›Üˆš[H[™ÛۜÛÛHÝ]]›Ü›X]Y\ÜØYÙ\ÈÚ][Y\Ý[\È[™Û۝^›Ý]HÙÈš[\ÈÈ™]™[[˜]Ø^H\ÚÈ\ØYÙK[™ÛÛܙ[˜]HÙÙÚ[™ÈXܛÜÜÈ][\H[Ù[\È[ˆH™X[›Ú™Xݏ܂‚•HÙ^HZÙX]Ø^NˆÙÙÚ[™È\È›ÝH^\žNÈ]	ÜÈ\ÜÙ[X[[™œ˜\ݝXÝ\™KˆÛÙOœš[

OØÛÙOˆÝ][Y[È]˜\ܘ]KˆÙÈš[\È\™H\›X[™[™XÛܙÈوÚ][Ý\ˆ\XØ][ۈYÚ[ˆ]Y][™Ú]Ù[ܛۙˈžH›ÛÝÚ[™ÈH]\›œÈ[ˆ\È\XÛx %\ÜXÚX[HH][K[[Ù[HÙ]\[ˆÛۙšY˜X8 %[ÝHZ[\XØ][ۜÈ]\™HX\ÞHÈXYÈ[ˆ›ÙXÝ[ۋÜ‚‚•ZÙHHÙXˆØܘ\\ˆ^[\H[™^[™]ˆY[ܙHÛÛ\^\œ›Üˆ[™[™ËˆÙÈY]šXÜÈ
]Y\šY\È\ˆÙXÛۙž]\È›ØÙ\ÜÙY
Kˆ^\š[Y[Ú]Y™™\™[[™\œÈ
[XZ[[\È›Üˆܚ]XØ[\œ›ÜœË›Üˆ^[\JKˆHÙÙÚ[™È[Ù[H\È›^X›H[›ÝYÚÈܛÝÈÚ][Ý\ˆ›Ú™Xݏ܂‚‘›ÜˆÛÛ\]HØÝ[Y[][ۈۈ[[™\œÈ[™›Ü›X]\œËÙYHHٙšXÚX[H™YHš΋ËÙØܘ]ۋ›Ü™ËÌËÛXœ˜\žKÛÙÙÚ[™Ëš[”]ۈÙÙÚ[™ÈØÝ[Y[][ۏØO‹Ü‚‚ˆYHœ™[]YX\XÛ\ȏ”™[]Y\XÛ\ÏÚ‚‚[‚OH™YHš΋ËÜ]ۚÝÝÜ›Ùܘ[K˜ÛÛKÙ^Ù\[ۋZ[™[™ËZ[‹\]ۋ]žKY^Ù\Y[ÙKYš[˜[Kȏ‘^Ù\[ۈ[™[™È[ˆ]ۈ
žK^Ù\[ÙKš[˜[JOØOÛO‚OH™YHš΋ËÜ]ۚÝÝÜ›Ùܘ[K˜ÛÛKÜ]ۋYXÛܘ]ܜËZÝË]ËXܙX]KX[™]\ÙKȏ”]ۈXÛܘ]ܜΈÝÈÈܙX]H[™\ÙOØOÛO‚OH™YHš΋ËÜ]ۚÝÝÜ›Ùܘ[K˜ÛÛKÜ]ۋZœÛۋ\\œÚ[™ËX[™\›ØÙ\ÜÚ[™Ëȏ”]ۈ”Óӈ\œÚ[™È[™›ØÙ\ÜÚ[™ÏØOÛO‚Ý[‚‚–ËÙ]Ü—Ý^VËÙ]Ü—ØÛÛ[[—VËÙ]Ü—Ü›Ý×VËÙ]Ü—ÜÙXÝ[ۗBKKHÝÜ™]šKÜXÙZÛ\ˆKO
Related Python Tutorials
Continue learning with these related guides:

How To Set Up Logging with Rotating File Handlers
How To Use Decorators for Logging and Timing
How To Manage Environment Variables with dotenv

				
				Post Views:
				36