Downloading files with Python is super easy and can even be syntactically simple with robust libraries like requests. However, there is no standard library implementation to show a progress bar in python during a download. In this quick tutorial, we’ll show how to quickly implement such a feature to help avoid guesswork during long downloads.<\/p>\n
Before we dive in we need to understand all the moving pieces of this problem. This will provide the framework by which we can concoct our approach of showing a progress bar while downloading a file via Python. An outline is as follows:<\/p>\n
The good news is that we don’t have to implement any of this from scratch\u2014or even on a low-enough level that we would need to touch Python’s To integrate a progress bar into Python while downloading a file, we need to modify the approach that we might take otherwise. Let’s start by considering how one might download a file in Python without using a progress bar. The following code will download a file and save it to the local file system:<\/p>\n This code uses the requests library to construct an HTTP GET request to the Note<\/strong>: Check out this article on other simple ways to download a file with Python<\/a>.<\/em><\/p>\n In the example above, we download the entirety of a remote file and save its contents to a newly-created local file. This doesn’t allow for any incremental measuring\u2014the file is downloaded entirely and then saved entirely. Let’s first look at how we might implement this manually, then we’ll look at a more streamlined approach.<\/p>\n To incrementalize the download process, such that we can register the progress, we need to set the stream parameter<\/a> of our When this code executes, the same data as before is downloaded, but now we are iterating over the byte stream<\/a> from the response. While doing this, we are calculating the total percentage of bytes downloaded\u2014relative to the total number conveyed by the The only real magic here is using the urllib<\/code>. Step 1 will be handled via the Python requests<\/code> library and both steps 2 and 3 will be handled via the tqdm<\/code> library. Let’s get started by considering downloading our file.<\/p>\nStep 1: Preparing an HTTP Request<\/h2>\n
import requests\r\n\r\nwith requests.get('https:\/\/www.example.com\/file.txt')as r:\r\n with open('download.txt', 'wb')as file:\r\n file.write(r.raw)<\/pre>\nhttps:\/\/www.example.com\/file.txt<\/code> URL. This will download the content of example.com and save it as a file named download.txt<\/code> on the local disk\u201446 lines of HTML code.<\/p>\nSteps 2 & 3: Metering & Displaying the Transfer of Data<\/h2>\n
Manual Implementation<\/h3>\n
requests<\/code> object to True<\/code>. This sends an initial HEAD request to get file information which will then allow iteration of transferred bytes. This is implemented as such:<\/p>\nimport time\r\nimport requests\r\n\r\n# use a context manager to make an HTTP request and file\r\nwith requests.get(\"https:\/\/www.example.com\/file.txt\", stream=True) as r:\r\n with open('download.txt', 'wb') as file:\r\n\r\n # Get the total size, in bytes, from the response header\r\n total_size = int(r.headers.get('Content-Length'))\r\n\r\n # Define the size of the chunk to iterate over (Mb)\r\n chunk_size = 1\r\n\r\n # iterate over every chunk and calculate % of total\r\n for i, chunk in enumerate(r.iter_content(chunk_size=chunk_size)):\r\n\r\n # calculate current percentage\r\n c = i * chunk_size \/ total_size * 100\r\n\r\n # write current % to console, pause for .1ms, then flush console\r\n sys.stdout.write(f\"\\r{round(c, 4)}%\")\r\n time.sleep(.1)\r\n sys.stdout.flush()<\/pre>\nContent-Length<\/code> header from our initial HTTP request. This will continue to display a value similar to 5.234234%<\/code> in the console every .1ms.<\/p>\nsys.stdout.write<\/code> method to stream to the console, the time.sleep<\/code> method to pause for .1 millisecond, and then the sys.stdout.flush<\/code> method to move the cursor back to the first character. This is sloppy, could be much-improved even in its current approach, and adds a .1ms delay for each chunk size\u2014which is a single byte in the above example<\/strong>. Let’s look at a more streamlined approach.<\/p>\ntqdm Implementation<\/h3>\n