Ready to take Python coding to a new level? Explore our Python Code Generator. The perfect tool to get your code up and running in no time. Start now!
File transfer is the process of copying or moving a file from one computer to another over a network or Internet connection. In this tutorial, we'll go over how you can write client/server Python scripts that handle that step by step.
The basic idea is to create a server that listens on a particular port; this server will be responsible for receiving files (you can make the server send files as well). On the other hand, the client will try to connect to the server and send a file of any type.
We will use the socket
module, which comes built-in with Python and provides us with socket operations that are widely used on the Internet, as they are behind any connection to any network.
Please note that there are more reliable ways to transfer files with tools like rsync
or scp. However, the goal of this tutorial is to transfer files using Python and without any third-party tool.
Related: How to Organize Files by Extension in Python.
First, we gonna need to install the tqdm
library, which will enable us to print fancy progress bars:
Let's start with the client code, the code that is responsible for sending:
We need to specify the server IP address, the server port we want to connect to, and the file name we want to send:
The host
variable is the IP address of the server. In my case, it's another computer in the same local home network, "192.168.1.101"
.
The filename
needs to exist in the current directory, or you can use an absolute path to that file somewhere on your computer. This is the file you want to send.
os.path.getsize(filename)
gets the size of that file in bytes; that's great, as we need it for showing progress bars in the client and the server.
Let's create the TCP socket:
Connecting to the server:
The connect()
method expects an address of the pair (host, port)
to connect the socket to that remote address. Once the connection is established, we send the name and size of the file:
I've used SEPARATOR
here to separate the data fields; it is just a junk message, we can just use send()
twice, but we may not want to do that anyway. encode()
function encodes the string we passed to 'utf-8' encoding (that's necessary).
Now we need to send the file, and as we are sending the file, we'll print nice progress bars using the tqdm
library:
Basically, what we are doing here is opening the file as read in binary ("rb"
), reading chunks from the file (in this case, 4096 bytes or 4KB) and sending them to the socket using the sendall()
function, and then we update the progress bar each time. Once that's finished, we close that socket.
Related: How to Make a Chat Application in Python.
Alright, so we are done with the client. Let's dive into the server, so open up a new empty Python file and:
I've initialized some parameters we are going to use. Notice that I've used "0.0.0.0" as the server IP address. This means all IPv4 addresses that are on the local machine. You may wonder why we don't just use our local IP address or "localhost" or "127.0.0.1"? Well, if the server has two IP addresses, let's say "192.168.1.101" on one network and "10.0.1.1" on another, and the server listens on "0.0.0.0", it will be reachable at both of those IPs.
Alternatively, you can use your public or private IP address, depending on your clients. If the connected clients are in your local network, you should use your private IP (you can check it using ipconfig
command in Windows or ifconfig
command in Mac OS/Linux), but if you're expecting clients from the Internet, you definitely should use your public address.
Also, make sure you use the same port on the server as on the client.
Let's create our TCP socket:
Now, this is different from the client; we need to bind the socket we just created to our SERVER_HOST
and SERVER_PORT
:
After that, we are going to listen for connections:
Once the client connects to our server, we need to accept that connection:
Remember that when the client is connected, it'll send the name and size of the file. Let's receive them:
As mentioned earlier, the received data is combined with the filename
and the filesize
, and we can easily extract them by splitting them by the SEPARATOR
string.
After that, we need to remove the file's absolute path because the sender sent the file with his own file path, which may differ from ours; the os.path.basename()
function returns the final component of a path name.
Now we need to receive the file:
It is not entirely different from the client code. However, we are opening the file as write in binary ("wb"
) here and using the recv(BUFFER_SIZE)
method to receive BUFFER_SIZE
bytes from the client socket and write it to the file. Once that's finished, we close both the client and server sockets.
Learn also: How to List all Files and Directories in FTP Server using Python
Alright, let me try it on my own private network:
I need to go to my Linux box and send an example file:
Let's see the server now:
Great, we are done! It's working! You can get the complete code here.
If you wish to run the server code on a remote machine and not on the local network, then make sure you allow the port on your firewall. If it's a VM in the cloud, then make sure you allow it via ufw
:
This will tell the firewall to allow that port for remote communication. If the server is in your home, you must enable the port on your router settings, which you can typically access using the web browser via the router's IP address, typically 192.168.1.1. You can check the default gateway IP (router's IP) using the ipconfig
command on Windows, or ip route | grep default
on Linux and macOS.
You can extend this code for your own needs now. Here are some examples you can implement:
Read Also: How to Manipulate IP Addresses in Python.
Happy Coding ♥
Found the article interesting? You'll love our Python Code Generator! Give AI a chance to do the heavy lifting for you. Check it out!
View Full Code Understand My Code
Got a coding query or need some guidance before you comment? Check out this Python Code Assistant for expert advice and handy tips. It's like having a coding tutor right in your fingertips!