Move Files in Python with shutil.move()

Python's shutil.move() function is the usual equivalent of mv. It can move a file into another directory or move and rename it by supplying a new file path. You will learn how to use it safely, how destination paths affect the result, and when os.rename() may be appropriate instead.

The standard-library shutil module provides high-level file operations. Its shutil.move(source, destination) function moves a file or directory.

import shutil

shutil.move("path/to/current/file.foo", "path/to/new/destination/file.foo")

Moving means the item no longer exists at the source location after a successful operation. Depending on the filesystems involved, Python may rename the item directly or copy it to the destination and then remove the original.

The destination argument has two useful forms:

• An existing directory: the source keeps its original name inside that directory.
• A new file path: the source is moved and given the specified new name.

This matters in real programs that organize uploads, archive reports, process incoming files, or rename files after they have been generated.

Think of a file as a labelled folder in a filing cabinet.

• Moving it into a different drawer keeps the label the same.
• Moving it into a different drawer and attaching a new label both relocates and renames it.

shutil.move() is the person who performs that filing task. You tell it where the folder is now and where you want it to end up.

The basic syntax is:

import shutil

shutil.move(source, destination)

Move a file and keep its name

If archive/ already exists, this puts report.csv inside it:

import shutil

shutil.move("reports/report.csv", "archive/")

The resulting path is:

archive/report.csv

Move and rename a file

Give a complete destination file path to change the name while moving:

import shutil

shutil.move(
    "reports/report.csv",
    "archive/report-2025.csv"
)

Use pathlib.Path for readable paths

pathlib is often easier to read than long string paths:

from pathlib import Path
import shutil

source = Path("downloads") / 
destination = Path() / 

destination.parent.mkdir(parents=, exist_ok=)
shutil.move(source, destination)

Consider this code:

from pathlib import Path
import shutil

source = Path("inbox") / "invoice.pdf"
destination = Path("processed") / "invoice.pdf"

destination.parent.mkdir(exist_ok=True)
shutil.move(source, destination)

Step by step:

1. source represents inbox/invoice.pdf.
2. destination represents processed/invoice.pdf.
3. destination.parent is processed.
4. mkdir(exist_ok=True) creates processed if it is absent. If it already exists, no error is raised.
5. shutil.move(source, destination) relocates the file.
6. After success, processed/invoice.pdf exists and inbox/invoice.pdf no longer exists.

If the source file is missing or the program lacks permission, shutil.move() raises an exception.

• Upload processing: Move a newly uploaded file from a temporary directory into permanent storage.
• Report archiving: Move a generated CSV or PDF into a dated archive folder.
• Media organization: Move photos from a download folder into categorized folders.
• Batch processing: Move successfully processed files to processed/ and failed files to failed/.
• Log rotation scripts: Move old log files into an archive before creating fresh logs.
• Data pipelines: Move input files after they have been imported, so they are not processed twice.

In production code, file moves are usually surrounded by validation and error handling.

Validate before moving

from pathlib import Path
import shutil

source = Path("incoming/orders.json")
destination_dir = Path("processed")

if not source.is_file():
    raise FileNotFoundError(f"Expected file was not found: {source}")

destination_dir.mkdir(parents=True, exist_ok=True)
shutil.move(source, destination_dir)

Use a guard clause for duplicate handling

A destination file may already exist. Decide whether your application should reject it, rename the incoming file, or intentionally replace it.

from pathlib import Path
import shutil

source = Path("incoming/data.csv")
destination = Path("archive/data.csv")

if destination.exists():
    raise FileExistsError(f"Refusing to replace existing file: {destination}")

destination.parent.mkdir(parents=True, exist_ok=True)
shutil.move(source, destination)

Handle expected operating-system errors

 shutil

:
    shutil.move(, )
 FileNotFoundError:
    ()
 PermissionError:
    ()
 OSError  error:
    ()

Assuming destination directories are created automatically

This fails if archive/2025/ does not exist:

import shutil

shutil.move("report.csv", "archive/2025/report.csv")

Create the parent directory first:

from pathlib import Path
import shutil

new_path = Path("archive/2025/report.csv")
new_path.parent.mkdir(parents=True, exist_ok=True)
shutil.move("report.csv", new_path)

Confusing a directory destination with a file destination

shutil.move("report.csv", "archive/")

If archive/ exists, the result is archive/report.csv, not a file literally named archive.

Forgetting that a move removes the original

After a successful move, do not continue to read or modify the old path. Store and use the returned destination path if needed:

import shutil

new_location = shutil.move(, )
(new_location)

import shutil
from pathlib import Path

# Move into an existing directory; keeps original file name.
shutil.move("source/report.csv", "archive/")

# Move and rename.
shutil.move("source/report.csv", "archive/final-report.csv")

# Create missing parent directories first.
destination = Path("archive/2025/final-report.csv")
destination.parent.mkdir(parents=True, exist_ok=True)
shutil.move("source/report.csv", destination)

• Use shutil.move(source, destination) for the Python equivalent of mv.
• If destination is an existing directory, the source name is retained.
• If destination is a file path, the item can be renamed.
• Check source.is_file() or source.exists() before moving when appropriate.
• Create destination directories yourself with mkdir().
• Check destination.exists() before a move if overwriting would be dangerous.
• Catch FileNotFoundError, PermissionError, and OSError in scripts that must handle failures.

What is the Python equivalent of mv?

Use shutil.move(source, destination) from Python's standard library.

Does shutil.move() rename files too?

Yes. Supply a destination path with a new filename, such as "archive/old-report.csv".

Does shutil.move() create the destination folder?

No. Create missing parent directories before calling it, for example with Path(...).parent.mkdir(parents=True, exist_ok=True).

What happens if the destination is a directory?

If the directory already exists, Python places the source inside it and keeps the source item's name.

Can Python move directories with shutil.move()?

Yes. shutil.move() works with both files and directories.

Is shutil.move() the same as copying a file?

No. A copy leaves the original in place. A successful move removes the item from its original location.

Should I use os.system("mv ...") in Python?

Usually no. shutil.move() is portable, avoids shell quoting problems, and accepts objects.

• pathlib.Path — Provides object-oriented, readable ways to build, inspect, and create filesystem paths.
• File copying with shutil.copy() — Use copying when the original file must remain available.
• File deletion with Path.unlink() — Removes files and is relevant when managing file lifecycles.
• Directory creation with Path.mkdir() — Required when a move destination's parent folders do not yet exist.
• Exception handling with try/except — Lets programs recover from missing files, permission errors, and operating-system failures.
• File existence checks — Path.exists() and Path.is_file() help validate paths before operating on them.