Update readme.md

AugustOxy · web-flow · commit acd4042bb50a · 2023-05-17T09:52:55.000+03:00
diff --git a/readme.md b/readme.md
@@ -1,34 +1,36 @@
-# **Python Cache: How to Speed Up Your Code with Effective Caching**
+# Python Cache: How to Speed Up Your Code with Effective Caching
 
 This article will show you how to use caching in Python with your web
 scraping tasks. You can read the [<u>full
 article</u>](https://oxylabs.io/blog/python-cache-how-to-use-effectively)
 on our blog, where we delve deeper into the different caching
 strategies.
 
-## **How to implement a cache in Python**
+## How to implement a cache in Python
 
 There are different ways to implement caching in Python for different
 caching strategies. Here we’ll see two methods of Python caching for a
 simple web scraping example. If you’re new to web scraping, take a look
 at our [<u>step-by-step Python web scraping
 guide</u>](https://oxylabs.io/blog/python-web-scraping).
 
-### **Install the required libraries**
+### Install the required libraries
 
 We’ll use the [<u>requests
 library</u>](https://pypi.org/project/requests/) to make HTTP requests
 to a website. Install it with
 [<u>pip</u>](https://pypi.org/project/pip/) by entering the following
 command in your terminal:
 
+```bash
 python -m pip install requests
+```
 
-Other libraries we’ll use in this project, specifically time and
-functools, come natively with Python 3.11.2, so you don’t have to
+Other libraries we’ll use in this project, specifically `time` and
+`functools`, come natively with Python 3.11.2, so you don’t have to
 install them.
 
-### **Method 1: Python caching using a manual decorator**
+### Method 1: Python caching using a manual decorator
 
 A [<u>decorator</u>](https://peps.python.org/pep-0318/) in Python is a
 function that accepts another function as an argument and outputs a new
@@ -42,143 +44,116 @@ saving them in the cache for future use.
 Let’s start by creating a simple function that takes a URL as a function
 argument, requests that URL, and returns the response text:
 
+```python
 def get_html_data(url):
-
-response = requests.get(url)
-
-return response.text
+    response = requests.get(url)
+    return response.text
+```
 
 Now, let's move toward creating a memoized version of this function:
 
+```python
 def memoize(func):
+    cache = {}
 
-cache = {}
-
-def wrapper(\*args):
-
-if args in cache:
-
-return cache\[args\]
-
-else:
-
-result = func(\*args)
+    def wrapper(*args):
+        if args in cache:
+            return cache[args]
+        else:
+            result = func(*args)
+            cache[args] = result
+            return result
 
-cache\[args\] = result
+    return wrapper
 
-return result
-
-return wrapper
 
 @memoize
-
 def get_html_data_cached(url):
+    response = requests.get(url)
+    return response.text
+```
 
-response = requests.get(url)
-
-return response.text
-
-The wrapper function determines whether the current input arguments have
+The `wrapper` function determines whether the current input arguments have
 been previously cached and, if so, returns the previously cached result.
 If not, the code calls the original function and caches the result
-before being returned. In this case, we define a memoize decorator that
-generates a cache dictionary to hold the results of previous function
+before being returned. In this case, we define a `memoize` decorator that
+generates a `cache` dictionary to hold the results of previous function
 calls.
 
-By adding @memoize above the function definition, we can use the memoize
-decorator to enhance the get_html_data function. This generates a new
-memoized function that we’ve called get_html_data_cached. It only makes
+By adding `@memoize` above the function definition, we can use the memoize
+decorator to enhance the `get_html_data` function. This generates a new
+memoized function that we’ve called `get_html_data_cached`. It only makes
 a single network request for a URL and then stores the response in the
 cache for further requests.
 
-Let’s use the time module to compare the execution speeds of the
-get_html_data function and the memoized get_html_data_cached function:
+Let’s use the `time` module to compare the execution speeds of the
+`get_html_data` function and the memoized `get_html_data_cached` function:
 
+```python
 import time
 
-start_time = time.time()
 
+start_time = time.time()
 get_html_data('https://books.toscrape.com/')
-
 print('Time taken (normal function):', time.time() - start_time)
 
-start_time = time.time()
 
+start_time = time.time()
 get_html_data_cached('https://books.toscrape.com/')
-
-print('Time taken (memoized function using manual decorator):',
-time.time() - start_time)
+print('Time taken (memoized function using manual decorator):', time.time() - start_time)
+```
 
 Here’s what the complete code looks like:
 
-\# Import the required modules
-
+```python
+# Import the required modules
 from functools import lru_cache
-
 import time
-
 import requests
 
-\# Function to get the HTML Content
 
+# Function to get the HTML Content
 def get_html_data(url):
+    response = requests.get(url)
+    return response.text
 
-response = requests.get(url)
-
-return response.text
-
-\# Memoize function to cache the data
 
+# Memoize function to cache the data
 def memoize(func):
+    cache = {}
 
-cache = {}
-
-\# Inner wrapper function to store the data in the cache
-
-def wrapper(\*args):
-
-if args in cache:
-
-return cache\[args\]
-
-else:
-
-result = func(\*args)
+    # Inner wrapper function to store the data in the cache
+    def wrapper(*args):
+        if args in cache:
+            return cache[args]
+        else:
+            result = func(*args)
+            cache[args] = result
+            return result
 
-cache\[args\] = result
+    return wrapper
 
-return result
-
-return wrapper
-
-\# Memoized function to get the HTML Content
 
+# Memoized function to get the HTML Content
 @memoize
-
 def get_html_data_cached(url):
+    response = requests.get(url)
+    return response.text
 
-response = requests.get(url)
-
-return response.text
-
-\# Get the time it took for a normal function
 
+# Get the time it took for a normal function
 start_time = time.time()
-
 get_html_data('https://books.toscrape.com/')
-
 print('Time taken (normal function):', time.time() - start_time)
 
-\# Get the time it took for a memoized function (manual decorator)
-
+# Get the time it took for a memoized function (manual decorator)
 start_time = time.time()
-
 get_html_data_cached('https://books.toscrape.com/')
+print('Time taken (memoized function using manual decorator):', time.time() - start_time)
+```
 
-print('Time taken (memoized function using manual decorator):',
-time.time() - start_time)
-
-Here’s the output:
+And here’s the output:
+![](images/output_normal_memoized.png)
 
 Notice the time difference between the two functions. Both take almost
 the same time, but the supremacy of caching lies behind the re-access.
@@ -190,82 +165,70 @@ increase the number of calls to these functions, the time difference
 will significantly increase (see [<u>Performance
 Comparison</u>](#performance-comparison)). 
 
-### **Method 2: Python caching using LRU cache decorator**
+### Method 2: Python caching using LRU cache decorator
 
 Another method to implement caching in Python is to use the built-in
-@lru_cache decorator from functools. This decorator implements cache
+`@lru_cache` decorator from `functools`. This decorator implements cache
 using the least recently used (LRU) caching strategy. This LRU cache is
 a fixed-size cache, which means it’ll discard the data from the cache
 that hasn’t been used recently.
 
-To use the @lru_cache decorator, we can create a new function for
+To use the `@lru_cache` decorator, we can create a new function for
 extracting HTML content and place the decorator name at the top. Make
-sure to import the functools module before using the decorator: 
+sure to import the `functools` module before using the decorator: 
 
+```python
 from functools import lru_cache
 
-@lru_cache(maxsize=None)
 
+@lru_cache(maxsize=None)
 def get_html_data_lru(url):
+    response = requests.get(url)
+    return response.text
+```
 
-response = requests.get(url)
-
-return response.text
-
-In the above example, the get_html_data_lru method is memoized using the
-@lru_cache decorator. The cache can grow indefinitely when the maxsize
-option is set to None.
+In the above example, the `get_html_data_lru` method is memoized using the
+`@lru_cache` decorator. The cache can grow indefinitely when the `maxsize`
+option is set to `None`.
 
-To use the @lru_cache decorator, just add it above the get_html_data_lru
+To use the `@lru_cache` decorator, just add it above the `get_html_data_lru`
 function. Here’s the complete code sample:
 
-\# Import the required modules
-
+```python
+# Import the required modules
 from functools import lru_cache
-
 import time
-
 import requests
 
-\# Function for getting HTML Content
 
+# Function to get the HTML Content
 def get_html_data(url):
+    response = requests.get(url)
+    return response.text
 
-response = requests.get(url)
-
-return response.text
-
-\# Memoized using LRU Cache
 
+# Memoized using LRU Cache
 @lru_cache(maxsize=None)
-
 def get_html_data_lru(url):
+    response = requests.get(url)
+    return response.text
 
-response = requests.get(url)
-
-return response.text
-
-\# Getting time for Normal function to extract HTML content
 
+# Get the time it took for a normal function
 start_time = time.time()
-
 get_html_data('https://books.toscrape.com/')
-
 print('Time taken (normal function):', time.time() - start_time)
 
-\# Getting time for Memoized function (LRU cache) to extract HTML
-content
-
+# Get the time it took for a memoized function (LRU cache)
 start_time = time.time()
-
 get_html_data_lru('https://books.toscrape.com/')
-
-print('Time taken (memoized function with LRU cache):', time.time() -
-start_time)
+print('Time taken (memoized function with LRU cache):', time.time() - start_time)
+```
 
 This produced the following output:
+![](images/output_normal_lru.png)
 
-### **Performance comparison**
+### Performance comparison
 
 In the following table, we’ve determined the execution times of all
 three functions for different numbers of requests to these functions:
@@ -280,6 +243,7 @@ three functions for different numbers of requests to these functions:
 As the number of requests to the functions increases, you can see a
 significant reduction in execution times using the caching strategy. The
 following comparison chart depicts these results:
+![](images/comparison-chart.png)
 
 The comparison results clearly show that using a caching strategy in
 your code can significantly improve overall performance and speed.
