Add files via upload

Author: krishnaik06

16-Multithreading and Multiprocessing/advance_multi_processing.py

@@ -0,0 +1,17 @@
+###  Multiprocessing with ProcessPoolExecutor
+
+from concurrent.futures import ProcessPoolExecutor
+import time
+
+def square_number(number):
+    time.sleep(2)
+    return f"Square: {number * number}"
+
+numbers=[1,2,3,4,5,6,7,8,9,11,2,3,12,14]
+if __name__=="__main__":
+
+    with ProcessPoolExecutor(max_workers=3) as executor:
+        results=executor.map(square_number,numbers)
+
+    for result in results:
+        print(result)

16-Multithreading and Multiprocessing/advance_multi_threading.py

@@ -0,0 +1,16 @@
+### Multithreading With Thread Pool Executor
+
+from concurrent.futures import ThreadPoolExecutor
+import time
+
+def print_number(number):
+    time.sleep(1)
+    return f"Number :{number}"
+
+numbers=[1,2,3,4,5,6,7,8,9,0,1,2,3]
+
+with ThreadPoolExecutor(max_workers=3) as executor:
+    results=executor.map(print_number,numbers)
+
+for result in results:
+    print(result)

16-Multithreading and Multiprocessing/factorial_multi_processing.py

@@ -0,0 +1,40 @@
+'''
+Real-World Example: Multiprocessing for CPU-bound Tasks
+Scenario: Factorial Calculation
+Factorial calculations, especially for large numbers, 
+involve significant computational work. Multiprocessing 
+can be used to distribute the workload across multiple 
+CPU cores, improving performance.
+
+'''
+
+import multiprocessing
+import math
+import sys
+import time
+
+# Increase the maximum number of digits for integer conversion
+sys.set_int_max_str_digits(100000)
+
+## function to compute factorials of a given number 
+
+def computer_factorial(number):
+    print(f"Computing factorial of {number}")
+    result=math.factorial(number)
+    print(f"Factorial of {number} is {result}")
+    return result
+
+if __name__=="__main__":
+    numbers=[5000,6000,700,8000]
+
+    start_time=time.time()
+
+    ##create a pool of worker processes
+    with multiprocessing.Pool() as pool:
+        results=pool.map(computer_factorial,numbers)
+
+    end_time=time.time()
+
+    print(f"Results: {results}")
+    print(f"Time taken: {end_time - start_time} seconds")
+

16-Multithreading and Multiprocessing/multi_processing.py

@@ -0,0 +1,35 @@
+## PRocesses that run in parallel
+### CPU-Bound Tasks-Tasks that are heavy on CPU usage (e.g., mathematical computations, data processing).
+## PArallel execution- Multiple cores of the CPU
+
+import multiprocessing
+
+import time
+
+def square_numbers():
+    for i in range(5):
+        time.sleep(1)
+        print(f"Square: {i*i}")
+
+def cube_numbers():
+    for i in range(5):
+        time.sleep(1.5)
+        print(f"Cube: {i * i * i}")
+
+if __name__=="__main__":
+
+    ## create 2 processes
+    p1=multiprocessing.Process(target=square_numbers)
+    p2=multiprocessing.Process(target=cube_numbers)
+    t=time.time()
+
+    ## start the process
+    p1.start()
+    p2.start()
+
+    ## Wait for the process to complete
+    p1.join()
+    p2.join()
+
+    finished_time=time.time()-t
+    print(finished_time)

16-Multithreading and Multiprocessing/multi_threading.py

@@ -0,0 +1,33 @@
+### Multithreading
+## When to use Multi Threading
+###I/O-bound tasks: Tasks that spend more time waiting for I/O operations (e.g., file operations, network requests).
+###  Concurrent execution: When you want to improve the throughput of your application by performing multiple operations concurrently.
+
+import threading
+import time
+
+def print_numbers():
+    for i in range(5):
+        time.sleep(2)
+        print(f"Number:{i}")
+
+def print_letter():
+    for letter in "abcde":
+        time.sleep(2)
+        print(f"Letter: {letter}")
+
+##create 2 threads
+t1=threading.Thread(target=print_numbers)
+t2=threading.Thread(target=print_letter)
+
+t=time.time()
+## start the thread
+t1.start()
+t2.start()
+
+### Wait for the threads to complete
+t1.join()
+t2.join()
+
+finished_time=time.time()-t
+print(finished_time)

16-Multithreading and Multiprocessing/webscrapping_multi_threading.py

@@ -0,0 +1,48 @@
+'''
+Real-World Example: Multithreading for I/O-bound Tasks
+Scenario: Web Scraping
+Web scraping often involves making numerous network requests to 
+fetch web pages. These tasks are I/O-bound because they spend a lot of
+time waiting for responses from servers. Multithreading can significantly
+improve the performance by allowing multiple web pages to be fetched concurrently.
+
+'''
+
+'''
+
+https://python.langchain.com/v0.2/docs/introduction/
+
+https://python.langchain.com/v0.2/docs/concepts/
+
+https://python.langchain.com/v0.2/docs/tutorials/
+'''
+
+import threading
+import requests
+from bs4 import BeautifulSoup
+
+urls=[
+'https://python.langchain.com/v0.2/docs/introduction/',
+
+'https://python.langchain.com/v0.2/docs/concepts/',
+
+'https://python.langchain.com/v0.2/docs/tutorials/'
+
+]
+
+def fetch_content(url):
+    response=requests.get(url)
+    soup=BeautifulSoup(response.content,'html.parser')
+    print(f'Fetched {len(soup.text)} characters from {url}')
+
+threads=[]
+
+for url in urls:
+    thread=threading.Thread(target=fetch_content,args=(url,))
+    threads.append(thread)
+    thread.start()
+
+for thread in threads:
+    thread.join()
+
+print("All web pages fetched")