Python os Module: Operating System Interface (Complete Guide)

OVERVIEWWhat is the os module?

The os module provides a portable way of using operating system-dependent functionality. It is one of Python’s oldest and most fundamental standard library modules, offering access to file systems, process management, environment variables, and low-level system calls.

Unlike higher-level modules that abstract the operating system away, os exposes the raw interface. This means you get fine-grained control, but you also take responsibility for platform differences. Functions like os.fork() exist only on Unix. os.startfile() exists only on Windows. The module is designed so that code written for one platform fails gracefully on another, typically by raising AttributeError for missing functions.

The module is organized into several conceptual areas: process parameters, file descriptor operations, filesystem operations, process management, and system information. Understanding these boundaries helps you navigate the module without memorizing every function name.

Core functional areas

Why use it?

Modern Python offers higher-level alternatives for many os tasks. pathlib handles paths more elegantly. subprocess replaces os.system. shutil covers file copying and archiving. So why does os still matter?

Because some operations have no higher-level equivalent. Setting file permissions with os.chmod(), creating named pipes with os.mkfifo(), duplicating file descriptors with os.dup2(), and managing process groups with os.setpgid() are all os-only territory. When you write deployment scripts, container entrypoints, or system monitoring tools, you need this level of access.

Even when higher-level alternatives exist, os sometimes wins on performance. A tight loop calling os.path.exists() on a million files is faster than creating a million pathlib.Path objects. The difference is small, but in data pipelines and log processors, it adds up.

When os is the right choice

• You need low-level file descriptors or raw I/O.
• You are writing system administration or DevOps tooling.
• You are working with process IDs, signals, or Unix-specific features.
• You need to minimize object allocation in performance-critical loops.
• You are maintaining legacy code that already uses os extensively.

Do you need to install it?

No. The os module is part of Python’s standard library and has been since the earliest versions. It is implemented in C and compiled into the Python interpreter. There is nothing to install, no requirements file to update, and no version pinning to worry about.

However, the availability of specific functions depends on your operating system and Python build. A function like os.fork() is present on Linux and macOS but absent on Windows. Functions in os.path are universally available, but some system information functions require specific POSIX support.

What isSystem requirements

GuideInstallation

Since os is built into Python, installation means ensuring Python is properly set up on your system. Platform-specific notes follow.

Windows

Install Python from python.org. The Windows build includes all portable os functions plus Windows-specific additions like os.startfile() and os.getlogin(). Some Unix-only functions like os.fork() and os.getuid() are not available.

# Verify os module on Windows
python -c "import os; print(os.name); print(os.getcwd())"
# nt
# C:\Users\YourName

macOS

macOS is a certified Unix system, so most POSIX functions are available. Install Python via Homebrew or the official installer. Note that some functions like os.getgroups() behave differently on macOS due to its group implementation.

brew install python
python3 -c "import os; print(os.uname())"

Linux

Linux provides the fullest os feature set. All POSIX functions are available, and many Linux-specific extensions work through the module. Install via your distribution’s package manager.

# Debian/Ubuntu
sudo apt install python3

# Verify full POSIX support
python3 -c "import os; print(hasattr(os, 'fork'))"
# True

Docker

The official Python Docker images include the full os module. Containerized applications can use all functions supported by the host kernel.

FROM python:3.13-slim
WORKDIR /app
COPY . /app
CMD ["python", "-c", "import os; print(os.name, os.uname().sysname)"]

Process OfVerification

Run this diagnostic script to verify which os features are available on your system:

#!/usr/bin/env python3
# verify_os.py - Diagnostic script for os module capabilities

import os
import sys

def main():
    print(f"Python: {sys.version}")
    print(f"Platform: {sys.platform}")
    print(f"os.name: {os.name}")

    # Core features
    checks = {
        "fork": "Process forking",
        "getuid": "User ID access",
        "getpid": "Process ID access",
        "getcwd": "Current directory",
        "uname": "System information",
        "cpu_count": "CPU core count",
        "symlink": "Symbolic links",
        "mkfifo": "Named pipes",
    }

    print("
os module capabilities:")
    for func, desc in checks.items():
        available = "✓" if hasattr(os, func) else "✗"
        print(f"  {available} {desc:<20} ({func})")

    print(f"
Current working directory: {os.getcwd()}")
    print(f"Process ID: {os.getpid()}")

    if hasattr(os, "getuid"):
        print(f"User ID: {os.getuid()}")

if __name__ == "__main__":
    main()

First working example

Let’s build a script that cleans up old log files. This demonstrates directory traversal, file metadata, path joining, and safe deletion using os functions.

#!/usr/bin/env python3
# cleanup_logs.py - Remove log files older than N days

import os
import time
from datetime import timedelta

def cleanup_old_logs(log_dir: str, days: int = 7) -> tuple[int, int]:
    """Remove log files older than `days`. Returns (removed_count, bytes_freed)."""
    if not os.path.isdir(log_dir):
        raise ValueError(f"Not a directory: {log_dir}")

    cutoff = time.time() - (days * 86400)
    removed = 0
    freed = 0

    for filename in os.listdir(log_dir):
        if not filename.endswith(".log"):
            continue

        filepath = os.path.join(log_dir, filename)

        # Skip directories and symlinks for safety
        if not os.path.isfile(filepath):
            continue

        try:
            mtime = os.path.getmtime(filepath)
            if mtime < cutoff:
                size = os.path.getsize(filepath)
                os.remove(filepath)
                removed += 1
                freed += size
        except (OSError, PermissionError) as e:
            print(f"Skipping {filename}: {e}")

    return removed, freed

if __name__ == "__main__":
    log_dir = os.path.join(os.path.expanduser("~"), "logs")
    removed, freed = cleanup_old_logs(log_dir, days=30)
    print(f"Removed {removed} files, freed {freed:,} bytes")

Expected output:

Removed 12 files, freed 45,230,112 bytes

This example uses os.listdir() for directory scanning, os.path.join() for safe path construction, os.path.getmtime() and os.path.getsize() for metadata, and os.remove() for deletion. The explicit checks for isfile() prevent accidental directory removal.

>Real production example

Below is a production-ready process supervisor that monitors worker processes, restarts crashed ones, and handles graceful shutdown on Unix systems. This pattern appears in WSGI servers, task queues, and containerized applications.

#!/usr/bin/env python3
# process_supervisor.py - Manage and monitor worker processes

import os
import signal
import sys
import time
from typing import Callable, Dict, List

class ProcessSupervisor:
    """Supervise a pool of worker processes with auto-restart."""

    def __init__(self, worker_count: int, worker_func: Callable[[], None]):
        self.worker_count = worker_count
        self.worker_func = worker_func
        self.workers: Dict[int, int] = {}  # slot -> pid
        self.shutdown = False

        # Set up signal handlers for graceful shutdown
        signal.signal(signal.SIGTERM, self._handle_signal)
        signal.signal(signal.SIGINT, self._handle_signal)

    def _handle_signal(self, signum: int, frame) -> None:
        print(f"
Received signal {signum}, shutting down...")
        self.shutdown = True

    def _spawn_worker(self, slot: int) -> int:
        """Fork a new worker process. Returns the child PID."""
        pid = os.fork()
        if pid == 0:
            # Child process
            try:
                self.worker_func()
            except Exception as e:
                print(f"Worker error: {e}", file=sys.stderr)
            os._exit(0)  # Avoid running cleanup in child
        return pid

    def run(self) -> None:
        """Main supervision loop."""
        # Initial spawn
        for slot in range(self.worker_count):
            self.workers[slot] = self._spawn_worker(slot)

        print(f"Supervisor started with {self.worker_count} workers")

        while not self.shutdown:
            try:
                # Wait for any child to exit
                pid, status = os.waitpid(-1, os.WNOHANG)
                if pid == 0:
                    time.sleep(0.5)
                    continue

                # Find which slot exited and restart
                for slot, worker_pid in self.workers.items():
                    if worker_pid == pid:
                        print(f"Worker {slot} (PID {pid}) exited with {status}, restarting...")
                        if not self.shutdown:
                            self.workers[slot] = self._spawn_worker(slot)
                        break
            except ChildProcessError:
                time.sleep(0.5)

        # Graceful shutdown: terminate all workers
        print("Terminating workers...")
        for slot, pid in self.workers.items():
            try:
                os.kill(pid, signal.SIGTERM)
            except ProcessLookupError:
                pass

        # Wait for all to finish
        for _ in range(self.worker_count):
            try:
                os.waitpid(-1, 0)
            except ChildProcessError:
                break

        print("All workers stopped.")

def sample_worker() -> None:
    """A sample worker that runs indefinitely."""
    print(f"Worker {os.getpid()} started")
    while True:
        time.sleep(1)

if __name__ == "__main__":
    if not hasattr(os, "fork"):
        print("This supervisor requires a Unix-like system with fork support.")
        sys.exit(1)

    supervisor = ProcessSupervisor(worker_count=3, worker_func=sample_worker)
    supervisor.run()

This supervisor demonstrates os.fork() for process creation, os.waitpid() for non-blocking child monitoring, os.kill() for signal delivery, and proper cleanup on shutdown. The os._exit() call in the child prevents Python’s cleanup handlers from running twice. Note the platform guard at the bottom: the script checks for os.fork before attempting to use it.

Guide toTroubleshooting

Operating system interfaces fail for predictable reasons: permissions, missing files, platform incompatibilities, and race conditions.

TheCommon mistakes

Mistake 1: Using string concatenation for paths

# Wrong - breaks on Windows
path = "/tmp/" + filename

# Wrong - also fragile
path = "/tmp/%s" % filename

# Correct
path = os.path.join("/tmp", filename)

Mistake 2: Checking existence before opening

# Race condition - file may disappear between check and open
if os.path.exists(path):
    with open(path) as f:  # May still raise FileNotFoundError
        data = f.read()

# Correct - handle the exception
try:
    with open(path) as f:
        data = f.read()
except FileNotFoundError:
    data = None

Mistake 3: Modifying os.environ during iteration

# Wrong - RuntimeError: dictionary changed size during iteration
for key in os.environ:
    if key.startswith("OLD_"):
        del os.environ[key]

# Correct - iterate over a snapshot
for key in list(os.environ):
    if key.startswith("OLD_"):
        del os.environ[key]

Mistake 4: Assuming os.name == 'posix' means Unix

# Misleading - macOS and Linux both report 'posix'
if os.name == "posix":
    # This runs on macOS too, which may behave differently
    os.setuid(0)

# Better - check the specific function
if hasattr(os, "setuid"):
    os.setuid(0)

GuideBest practices

Security considerations

Low-level OS interfaces are powerful and dangerous. A mistake with os.chmod() or os.exec* can compromise a system. Below are the most common security risks and mitigations.

# secure_temp.py - Safe temporary file creation

import os
import tempfile

def write_sensitive_data(data: str) -> str:
    """Write data to a secure temporary file. Returns the path."""
    # mkstemp creates the file atomically with restrictive permissions
    fd, path = tempfile.mkstemp(prefix="secure_", suffix=".tmp")
    try:
        with os.fdopen(fd, "w") as f:
            f.write(data)
        # Restrict to owner only
        os.chmod(path, 0o600)
    except Exception:
        os.close(fd)
        raise
    return path

if __name__ == "__main__":
    path = write_sensitive_data("secret_api_key=abc123")
    print(f"Secure temp file: {path}")
    print(f"Permissions: {oct(os.stat(path).st_mode)[-3:]}")

TopPerformance tips

The os module is already thin wrapper around system calls, but some patterns are faster than others.

# fast_directory_scan.py - Efficient directory scanning

import os
from typing import Iterator, Tuple

def find_large_files_fast(root: str, min_size: int = 10_000_000) -> Iterator[Tuple[str, int]]:
    """Yield (path, size) for files larger than min_size."""
    for entry in os.scandir(root):
        try:
            if entry.is_dir(follow_symlinks=False):
                yield from find_large_files_fast(entry.path, min_size)
            elif entry.is_file() and entry.stat().st_size > min_size:
                yield (entry.path, entry.stat().st_size)
        except (OSError, PermissionError):
            continue

if __name__ == "__main__":
    for path, size in find_large_files_fast("/var/log"):
        print(f"{size:>12,}  {path}")

Advanced usage

File descriptor operations

For applications that need precise control over file I/O, os provides low-level file descriptor operations. These map directly to Unix system calls and are useful for implementing custom buffering, atomic writes, or pipe-based IPC.

# fd_operations.py - Low-level file descriptor patterns

import os

def atomic_write(path: str, data: bytes) -> None:
    """Write data atomically using a temporary file and rename."""
    temp_path = path + ".tmp"
    fd = os.open(temp_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o644)
    try:
        os.write(fd, data)
        os.fsync(fd)  # Ensure data hits disk
    finally:
        os.close(fd)
    os.replace(temp_path, path)  # Atomic on POSIX

def create_pipe() -> tuple[int, int]:
    """Create an anonymous pipe for IPC. Returns (read_fd, write_fd)."""
    return os.pipe()

if __name__ == "__main__":
    atomic_write("data.bin", b"hello world")
    r, w = create_pipe()
    os.write(w, b"ping")
    print(os.read(r, 1024))  # b'ping'
    os.close(r)
    os.close(w)

Working with file permissions and ownership

# permissions.py - Manage file permissions portably

import os
import stat

def set_secure_permissions(path: str) -> None:
    """Set owner-read/write only, remove all group/other access."""
    os.chmod(path, stat.S_IRUSR | stat.S_IWUSR)

def make_executable(path: str) -> None:
    """Add execute permission for the owner."""
    current = os.stat(path).st_mode
    os.chmod(path, current | stat.S_IXUSR)

def copy_permissions(source: str, target: str) -> None:
    """Copy permission bits from source to target."""
    mode = stat.S_IMODE(os.stat(source).st_mode)
    os.chmod(target, mode)

Process groups and sessions

# process_groups.py - Unix process group management

import os
import signal

def daemonize() -> None:
    """Basic Unix daemonization (simplified)."""
    if not hasattr(os, "fork"):
        raise OSError("Daemonization requires Unix")

    # First fork
    if os.fork() > 0:
        os._exit(0)

    os.setsid()  # Create new session

    # Second fork
    if os.fork() > 0:
        os._exit(0)

    os.chdir("/")
    os.umask(0)

Alternatives and comparisons

The os module overlaps with several other standard library modules. Choosing the right tool depends on your abstraction level.

Conclusion

The os module is Python’s direct line to the operating system. It is not always the most convenient tool, but it is the most capable. When you need to manage processes, manipulate file descriptors, query system information, or perform operations that higher-level modules do not expose, os is where you turn.

For new projects, prefer pathlib for path manipulation and subprocess for command execution. Reserve os for the edges: signal handling, process forking, permission management, and low-level I/O. This division of labor keeps your code modern and readable while preserving access to the full power of the underlying system.

The key to using os well is knowing its boundaries. Check for platform-specific functions with hasattr(). Handle OSError and PermissionError gracefully. Avoid os.system() and os.popen() in favor of subprocess. And never change the working directory in library code. Follow these rules, and os becomes a reliable foundation for system-level Python programs.

FAQ

Related articles

Official references

1. os – Miscellaneous operating system interfaces (Python 3.13 Documentation)
2. os.path – Common pathname manipulations
3. pathlib – Object-oriented filesystem paths
4. subprocess – Subprocess management
5. shutil – High-level file operations

# Verify os module on Windows
python -c "import os; print(os.name); print(os.getcwd())"
# nt
# C:\Users\YourName

brew install python
python3 -c "import os; print(os.uname())"

# Debian/Ubuntu
sudo apt install python3

# Verify full POSIX support
python3 -c "import os; print(hasattr(os, 'fork'))"
# True

FROM python:3.13-slim
WORKDIR /app
COPY . /app
CMD ["python", "-c", "import os; print(os.name, os.uname().sysname)"]

#!/usr/bin/env python3
# verify_os.py - Diagnostic script for os module capabilities

import os
import sys

def main():
    print(f"Python: {sys.version}")
    print(f"Platform: {sys.platform}")
    print(f"os.name: {os.name}")

    # Core features
    checks = {
        "fork": "Process forking",
        "getuid": "User ID access",
        "getpid": "Process ID access",
        "getcwd": "Current directory",
        "uname": "System information",
        "cpu_count": "CPU core count",
        "symlink": "Symbolic links",
        "mkfifo": "Named pipes",
    }

    print("
os module capabilities:")
    for func, desc in checks.items():
        available = "✓" if hasattr(os, func) else "✗"
        print(f"  {available} {desc:<20} ({func})")

    print(f"
Current working directory: {os.getcwd()}")
    print(f"Process ID: {os.getpid()}")

    if hasattr(os, "getuid"):
        print(f"User ID: {os.getuid()}")

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
# cleanup_logs.py - Remove log files older than N days

import os
import time
from datetime import timedelta

def cleanup_old_logs(log_dir: str, days: int = 7) -> tuple[int, int]:
    """Remove log files older than `days`. Returns (removed_count, bytes_freed)."""
    if not os.path.isdir(log_dir):
        raise ValueError(f"Not a directory: {log_dir}")

    cutoff = time.time() - (days * 86400)
    removed = 0
    freed = 0

    for filename in os.listdir(log_dir):
        if not filename.endswith(".log"):
            continue

        filepath = os.path.join(log_dir, filename)

        # Skip directories and symlinks for safety
        if not os.path.isfile(filepath):
            continue

        try:
            mtime = os.path.getmtime(filepath)
            if mtime < cutoff:
                size = os.path.getsize(filepath)
                os.remove(filepath)
                removed += 1
                freed += size
        except (OSError, PermissionError) as e:
            print(f"Skipping {filename}: {e}")

    return removed, freed

if __name__ == "__main__":
    log_dir = os.path.join(os.path.expanduser("~"), "logs")
    removed, freed = cleanup_old_logs(log_dir, days=30)
    print(f"Removed {removed} files, freed {freed:,} bytes")

Removed 12 files, freed 45,230,112 bytes

#!/usr/bin/env python3
# process_supervisor.py - Manage and monitor worker processes

import os
import signal
import sys
import time
from typing import Callable, Dict, List

class ProcessSupervisor:
    """Supervise a pool of worker processes with auto-restart."""

    def __init__(self, worker_count: int, worker_func: Callable[[], None]):
        self.worker_count = worker_count
        self.worker_func = worker_func
        self.workers: Dict[int, int] = {}  # slot -> pid
        self.shutdown = False

        # Set up signal handlers for graceful shutdown
        signal.signal(signal.SIGTERM, self._handle_signal)
        signal.signal(signal.SIGINT, self._handle_signal)

    def _handle_signal(self, signum: int, frame) -> None:
        print(f"
Received signal {signum}, shutting down...")
        self.shutdown = True

    def _spawn_worker(self, slot: int) -> int:
        """Fork a new worker process. Returns the child PID."""
        pid = os.fork()
        if pid == 0:
            # Child process
            try:
                self.worker_func()
            except Exception as e:
                print(f"Worker error: {e}", file=sys.stderr)
            os._exit(0)  # Avoid running cleanup in child
        return pid

    def run(self) -> None:
        """Main supervision loop."""
        # Initial spawn
        for slot in range(self.worker_count):
            self.workers[slot] = self._spawn_worker(slot)

        print(f"Supervisor started with {self.worker_count} workers")

        while not self.shutdown:
            try:
                # Wait for any child to exit
                pid, status = os.waitpid(-1, os.WNOHANG)
                if pid == 0:
                    time.sleep(0.5)
                    continue

                # Find which slot exited and restart
                for slot, worker_pid in self.workers.items():
                    if worker_pid == pid:
                        print(f"Worker {slot} (PID {pid}) exited with {status}, restarting...")
                        if not self.shutdown:
                            self.workers[slot] = self._spawn_worker(slot)
                        break
            except ChildProcessError:
                time.sleep(0.5)

        # Graceful shutdown: terminate all workers
        print("Terminating workers...")
        for slot, pid in self.workers.items():
            try:
                os.kill(pid, signal.SIGTERM)
            except ProcessLookupError:
                pass

        # Wait for all to finish
        for _ in range(self.worker_count):
            try:
                os.waitpid(-1, 0)
            except ChildProcessError:
                break

        print("All workers stopped.")

def sample_worker() -> None:
    """A sample worker that runs indefinitely."""
    print(f"Worker {os.getpid()} started")
    while True:
        time.sleep(1)

if __name__ == "__main__":
    if not hasattr(os, "fork"):
        print("This supervisor requires a Unix-like system with fork support.")
        sys.exit(1)

    supervisor = ProcessSupervisor(worker_count=3, worker_func=sample_worker)
    supervisor.run()

# Wrong - breaks on Windows
path = "/tmp/" + filename

# Wrong - also fragile
path = "/tmp/%s" % filename

# Correct
path = os.path.join("/tmp", filename)

# Race condition - file may disappear between check and open
if os.path.exists(path):
    with open(path) as f:  # May still raise FileNotFoundError
        data = f.read()

# Correct - handle the exception
try:
    with open(path) as f:
        data = f.read()
except FileNotFoundError:
    data = None

# Wrong - RuntimeError: dictionary changed size during iteration
for key in os.environ:
    if key.startswith("OLD_"):
        del os.environ[key]

# Correct - iterate over a snapshot
for key in list(os.environ):
    if key.startswith("OLD_"):
        del os.environ[key]

# Misleading - macOS and Linux both report 'posix'
if os.name == "posix":
    # This runs on macOS too, which may behave differently
    os.setuid(0)

# Better - check the specific function
if hasattr(os, "setuid"):
    os.setuid(0)

# secure_temp.py - Safe temporary file creation

import os
import tempfile

def write_sensitive_data(data: str) -> str:
    """Write data to a secure temporary file. Returns the path."""
    # mkstemp creates the file atomically with restrictive permissions
    fd, path = tempfile.mkstemp(prefix="secure_", suffix=".tmp")
    try:
        with os.fdopen(fd, "w") as f:
            f.write(data)
        # Restrict to owner only
        os.chmod(path, 0o600)
    except Exception:
        os.close(fd)
        raise
    return path

if __name__ == "__main__":
    path = write_sensitive_data("secret_api_key=abc123")
    print(f"Secure temp file: {path}")
    print(f"Permissions: {oct(os.stat(path).st_mode)[-3:]}")

# fast_directory_scan.py - Efficient directory scanning

import os
from typing import Iterator, Tuple

def find_large_files_fast(root: str, min_size: int = 10_000_000) -> Iterator[Tuple[str, int]]:
    """Yield (path, size) for files larger than min_size."""
    for entry in os.scandir(root):
        try:
            if entry.is_dir(follow_symlinks=False):
                yield from find_large_files_fast(entry.path, min_size)
            elif entry.is_file() and entry.stat().st_size > min_size:
                yield (entry.path, entry.stat().st_size)
        except (OSError, PermissionError):
            continue

if __name__ == "__main__":
    for path, size in find_large_files_fast("/var/log"):
        print(f"{size:>12,}  {path}")

# fd_operations.py - Low-level file descriptor patterns

import os

def atomic_write(path: str, data: bytes) -> None:
    """Write data atomically using a temporary file and rename."""
    temp_path = path + ".tmp"
    fd = os.open(temp_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o644)
    try:
        os.write(fd, data)
        os.fsync(fd)  # Ensure data hits disk
    finally:
        os.close(fd)
    os.replace(temp_path, path)  # Atomic on POSIX

def create_pipe() -> tuple[int, int]:
    """Create an anonymous pipe for IPC. Returns (read_fd, write_fd)."""
    return os.pipe()

if __name__ == "__main__":
    atomic_write("data.bin", b"hello world")
    r, w = create_pipe()
    os.write(w, b"ping")
    print(os.read(r, 1024))  # b'ping'
    os.close(r)
    os.close(w)

# permissions.py - Manage file permissions portably

import os
import stat

def set_secure_permissions(path: str) -> None:
    """Set owner-read/write only, remove all group/other access."""
    os.chmod(path, stat.S_IRUSR | stat.S_IWUSR)

def make_executable(path: str) -> None:
    """Add execute permission for the owner."""
    current = os.stat(path).st_mode
    os.chmod(path, current | stat.S_IXUSR)

def copy_permissions(source: str, target: str) -> None:
    """Copy permission bits from source to target."""
    mode = stat.S_IMODE(os.stat(source).st_mode)
    os.chmod(target, mode)

# process_groups.py - Unix process group management

import os
import signal

def daemonize() -> None:
    """Basic Unix daemonization (simplified)."""
    if not hasattr(os, "fork"):
        raise OSError("Daemonization requires Unix")

    # First fork
    if os.fork() > 0:
        os._exit(0)

    os.setsid()  # Create new session

    # Second fork
    if os.fork() > 0:
        os._exit(0)

    os.chdir("/")
    os.umask(0)