Introduction

os.walk is designed for local filesystems, so it cannot traverse an FTP server directly. To get similar behavior for remote directories, you need a generator that logs into the server, lists each directory, separates child folders from files, and yields the same three-part structure that os.walk returns.

Why os.walk Does Not Work on FTP

os.walk depends on local operating-system calls such as scandir and directory metadata access. An FTP server exposes files through network commands instead, so Python has no native way to treat it as a normal local path tree.

That means the useful goal is not to “extend” os.walk itself, but to create a compatible generator with a similar interface:

• current directory path
• list of subdirectories
• list of files

Once you have that shape, the rest of your code can often stay close to the local os.walk pattern.

Use ftplib as the Traversal Backend

Python's standard ftplib module is enough for many servers. The cleanest implementation uses mlsd when available, because it returns structured metadata that includes the entry type.

1from ftplib import FTP
2
3ftp = FTP("ftp.example.com")
4ftp.login("user", "password")
5
6for name, facts in ftp.mlsd("/"):
7    print(name, facts.get("type"))

If mlsd is supported, you can distinguish directories from files without guessing from names. If it is not supported, you may need fallbacks such as trying cwd into an entry or parsing LIST output, both of which are less reliable.

Build a Generator That Mimics os.walk

A practical approach is recursive traversal. For each directory, list entries, split them into folders and files, yield the tuple, and then recurse into each child directory.

1from ftplib import FTP
2from posixpath import join
3
4
5def ftp_walk(ftp, top):
6    dirnames = []
7    filenames = []
8
9    for name, facts in ftp.mlsd(top):
10        entry_type = facts.get("type")
11        if entry_type == "dir":
12            dirnames.append(name)
13        elif entry_type == "file":
14            filenames.append(name)
15
16    yield top, dirnames, filenames
17
18    for dirname in dirnames:
19        child = join(top, dirname)
20        yield from ftp_walk(ftp, child)
21
22
23with FTP("ftp.example.com") as ftp:
24    ftp.login("user", "password")
25    for dirpath, dirnames, filenames in ftp_walk(ftp, "/"):
26        print(dirpath, dirnames, filenames)

This is close to os.walk conceptually, which makes it easy to reuse directory-processing logic from local scripts.

Top-Down Control and Filtering

One useful feature of os.walk is top-down processing, where callers can filter dirnames before recursion happens. You can keep the same pattern with FTP traversal.

1def ftp_walk(ftp, top):
2    dirnames = []
3    filenames = []
4
5    for name, facts in ftp.mlsd(top):
6        if facts.get("type") == "dir":
7            dirnames.append(name)
8        elif facts.get("type") == "file":
9            filenames.append(name)
10
11    yield top, dirnames, filenames
12
13    for dirname in list(dirnames):
14        if dirname.startswith("."):
15            continue
16        yield from ftp_walk(ftp, join(top, dirname))

With this structure, a caller can decide to skip archive folders, hidden directories, or known slow branches before deeper traversal begins.

Handle Servers That Do Not Support MLSD

Older FTP servers sometimes lack MLSD. In that case, you can probe entries by attempting to change directory into them. That works, but it is slower because every entry becomes a round trip to the server.

1def is_dir(ftp, path):
2    current = ftp.pwd()
3    try:
4        ftp.cwd(path)
5        ftp.cwd(current)
6        return True
7    except Exception:
8        return False

Use this only as a fallback. Structured listings are more efficient and less fragile.

Design for Network Failures

FTP traversal is not the same as local disk traversal because the network can fail mid-walk. Timeouts, dropped connections, and permission errors should be expected. It is often worth wrapping directory listing calls so one unreadable folder does not abort the entire scan.

1try:
2    entries = list(ftp.mlsd(top))
3except Exception as exc:
4    print(f"Skipping {top}: {exc}")
5    return

That pattern is especially useful for inventory scripts, mirroring tools, and reporting jobs where partial results are still valuable.

Common Pitfalls

• Assuming os.walk can operate on FTP paths just because the directory structure looks similar.
• Parsing raw LIST output when MLSD is available and more reliable.
• Recursing blindly without filtering directories that should be skipped.
• Ignoring connection failures, permission errors, or server timeouts during traversal.
• Forgetting that repeated cwd probes can make large walks very slow on older servers.

Summary

• 'os.walk only works on local filesystems, so FTP requires a separate generator.'
• 'ftplib plus MLSD is the cleanest way to build an os.walk-like traversal.'
• Yield (dirpath, dirnames, filenames) so the API stays familiar.
• Add filtering and exception handling because remote traversal is slower and less reliable than local disk access.
• Use cwd probing only as a fallback when the server cannot provide structured listings.