{"id":19360,"date":"2018-06-20T04:00:49","date_gmt":"2018-06-19T22:30:49","guid":{"rendered":"https:\/\/data-flair.training\/blogs\/?p=19360"},"modified":"2026-04-20T16:07:16","modified_gmt":"2026-04-20T10:37:16","slug":"how-python-copy-a-file","status":"publish","type":"post","link":"https:\/\/data-flair.training\/blogs\/how-python-copy-a-file\/","title":{"rendered":"How Python Copy a File – 9 Simple & Quick Ways"},"content":{"rendered":"

In our last tutorial, we studied Python Zipfile. Today, in this Python Tutorial, we will discuss how Python copies a file.<\/p>\n

Moreover, we will look at the 9 simple ways to copy a file in Python Programming: Using Python OS Module, Python Threading Library, Python Subprocess Module, Python Shutil Module.<\/p>\n

So, let’s start with How to Copy a File in Python.<\/p>\n

How Python Copy a File?<\/h3>\n

Here are the main 4 categories of ways through which Python copies a file.<\/p>\n

1. Using Python OS Module<\/h3>\n

There are two ways to copy a file in Python- the popen() method and the system() method. Let\u2019s discuss them.<\/p>\n

\"How<\/a>

How Python Copy a File – 9 Simple & Quick Ways<\/p><\/div>\n

a. popen() in Python<\/h4>\n

The popen() method returns a file object that connects to a pipe. In mode \u2018w\u2019, we can write to it, and in mode \u2018r\u2019, we can read from it (\u2018r\u2019 is the default).<\/p>\n

You can say that it creates a pipe to a command or from it.<\/p>\n

This is the syntax we use:<\/p>\n

os.popen(command[, mode[, bufsize]])<\/pre>\n
Here, command<\/i> is the command we use, and mode<\/i> is \u2018r\u2019 or \u2018w\u2019, as discussed previously.<\/p>\n
When bufsize<\/i> is 0, there is no buffering. When it is 1, there is line buffering when accessing a file.<\/p>\n
When it is an integer greater than 1, there is buffering with the indicated buffer size. For a negative value, a default buffer size is used.<\/p>\n
We have a file labeled \u20181.txt\u2019 on the Desktop. We use the following code:<\/p>\n
>>> import os\r\n>>> os.chdir('C:\\\\Users\\\\lifei\\\\Desktop')\r\n>>> os.popen('copy 1.txt 2.txt')<\/pre>\n
As you can see, this creates a new file labeled \u20182.txt\u2019 on the Desktop. This has the same contents as 1.txt.<\/p>\n
For Linux, you\u2019d have to write \u2018cp\u2019 instead of \u2018copy\u2019. This method has been deprecated in Python 2.6.<\/p>\n
b. system() in Python<\/h4>\n
The system() method lets us execute a command as a string in a subshell. Any output the command<\/i> generates goes to the interpreter’s standard output stream.<\/p>\n
The syntax is:<\/p>\n
os.system(command)<\/pre>\n
Let\u2019s try doing the same thing using system() here.<\/p>\n
>>> import os\r\n>>> os.chdir('C:\\\\Users\\\\lifei\\\\Desktop')\r\n>>> os.system('copy 1.txt 2.txt')\r\n0<\/pre>\n
We can see the same action with this method. It copies the contents of a file 1.txt into a new file 2.txt.<\/p>\n
Note that if we already had a file called 2.txt, this operation replaces its contents. This applies to the previous method as well.<\/p>\n
While this method is similar to popen(), it executes in a subshell. It executes in a separate thread parallel to our executing code.<\/p>\n
By calling .wait() on the object it returns, we can wait for its completion.<\/p>\n
2.\u00a0 Using Python Threading Library<\/h3>\n
We can borrow the Thread module from the threading library to copy a file in Python. This does the copying in an async manner.<\/p>\n
>>> import os\r\n>>> os.chdir('C:\\\\Users\\\\lifei\\\\Desktop')\r\n>>> import shutil\r\n>>> from threading import Thread\r\n>>> Thread(target=shutil.copy, args=['1.txt','2.txt']).start()<\/pre>\n
This code copies the contents of file 1.txt to a new file 2.txt.<\/p>\n
If your application uses multiple threads for reading or writing a file, you should employ locking to avoid deadlocks.<\/p>\n
3. Using Python Subprocess Module<\/h3>\n
The subprocess module lets us work with child processes- launch them, attach to their pipes for input, output, and error, and retrieve return values.<\/p>\n
From this module, we can use the methods call() and check_output(), to copy a file in Python.<\/p>\n
Let\u2019s see how this module helps Python copy a file.<\/p>\n
\"Python<\/a>
Python Copy a File – Python Subprocess Module<\/p><\/div>\n
a. call() in Python<\/h4>\n
The syntax for this command is the following:<\/p>\n
subprocess.call(args, *, stdin=None, stdout=None, stderr=None, shell=False, timeout=None)<\/pre>\n
The Python call() method runs the command that the args<\/i> describe. It waits for the command to complete and then returns the attribute return code<\/i>.<\/p>\n
We use the following code to copy a file:<\/p>\n
>>> import os, subprocess\r\n>>> os.chdir('C:\\\\Users\\\\lifei\\\\Desktop')\r\n>>> status=subprocess.call('copy 1.txt 2.txt', shell=True)\r\n>>> if status!=0:\r\n       if status<0:\r\n            print(f\"Killed by signal {status}\")\r\n       else:\r\n            print(f\"Command failed with return code {status}\")\r\n       else:\r\n            print(\"Successfully executed command\")\r\n<\/pre>\n
Output<\/strong><\/p>\n
Successfully executed command<\/div>\n
Since here we get the output we do, we figure that the code returns a 0.<\/p>\n
b. check_output() in Python<\/h4>\n
Now, let\u2019s try the same with check_output(). This method runs commands with arguments and returns the output.<\/p>\n
For a non-zero return code, it raises a CalledProcessError. It also supports pipes. This is the syntax to follow:<\/p>\n
subprocess.check_output(args, *, stdin=None, stderr=None, shell=False, universal_newlines=False)<\/strong><\/p>\n
This method is a lot like subprocess.run, but it pipes data from stdout as encoded bytes by default. Let\u2019s see how we can copy a file with it.<\/p>\n
>>> import os, subprocess\r\n>>> os.chdir('C:\\\\Users\\\\lifei\\\\Desktop')\r\n>>> status=subprocess.check_output('copy 1.txt 2.txt',shell=True)<\/pre>\n
4. Using Python Shutil Module<\/h3>\n
Copying files by hand is slow. Python\u2019s shutil module offers a one-line fix: shutil.copy(“data.csv”, “backup\/data.csv”). It keeps the file name while moving its bytes, giving an instant backup. This \u201ccopy files in Python\u201d trick saves both time and typing.<\/p>\n
Benefits of using the Shutil method in Python:<\/strong><\/p>\n