week 7

Week 7: Working with OS & Threads - 40 Python Snippets

This week covers system modules, threading, multiprocessing, logging, and static code analysis. Below are 40 Python snippets categorized into 4 topics (10 per topic).

---

1️⃣ sys, os, shutil, and subprocess (10 Snippets)

1. Getting Python Version using sys

import sys
print(sys.version)

2. Getting Command-Line Arguments using sys

import sys
print("Arguments passed:", sys.argv)

3. Listing Files in a Directory using os

import os
print(os.listdir("."))

4. Getting the Current Working Directory using os

import os
print(os.getcwd())

5. Creating a New Directory using os

import os
os.mkdir("new_folder")
print("Directory created!")

6. Removing a File using os

import os
os.remove("test.txt")
print("File deleted!")

7. Copying a File using shutil

import shutil
shutil.copy("source.txt", "destination.txt")
print("File copied!")

8. Moving a File using shutil

import shutil
shutil.move("file.txt", "new_directory/")
print("File moved!")

9. Running a Shell Command using subprocess

import subprocess
subprocess.run(["ls", "-l"])

10. Capturing Output from a Shell Command using subprocess

import subprocess
result = subprocess.run(["echo", "Hello, World!"], capture_output=True, text=True)
print(result.stdout)

---

2️⃣ Multithreading and Multiprocessing (10 Snippets)

11. Creating a Simple Thread

import threading

def print_message():
    print("Hello from a thread!")

thread = threading.Thread(target=print_message)
thread.start()
thread.join()

12. Running Multiple Threads

import threading

def task(n):
    print(f"Thread {n} running")

threads = []
for i in range(5):
    thread = threading.Thread(target=task, args=(i,))
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

13. Using a Lock in Threads

import threading

lock = threading.Lock()

def critical_section(n):
    with lock:
        print(f"Thread {n} entering critical section")
        print(f"Thread {n} exiting critical section")

threads = [threading.Thread(target=critical_section, args=(i,)) for i in range(3)]
for t in threads:
    t.start()
for t in threads:
    t.join()

14. Creating a Process using multiprocessing

import multiprocessing

def print_message():
    print("Hello from a process!")

process = multiprocessing.Process(target=print_message)
process.start()
process.join()

15. Running Multiple Processes

import multiprocessing

def worker(n):
    print(f"Process {n} running")

processes = [multiprocessing.Process(target=worker, args=(i,)) for i in range(3)]
for p in processes:
    p.start()
for p in processes:
    p.join()

16. Using a Queue in Multiprocessing

import multiprocessing

def worker(q):
    q.put("Data from process")

queue = multiprocessing.Queue()
process = multiprocessing.Process(target=worker, args=(queue,))
process.start()
process.join()
print(queue.get())

17. Using a Pool of Processes

import multiprocessing

def square(n):
    return n * n

with multiprocessing.Pool(4) as pool:
    results = pool.map(square, [1, 2, 3, 4, 5])
print(results)

18. Using a Shared Variable in Multiprocessing

import multiprocessing

def increment(shared_value):
    shared_value.value += 1

value = multiprocessing.Value("i", 0)
process = multiprocessing.Process(target=increment, args=(value,))
process.start()
process.join()
print(value.value)

19. Using Manager for Shared Data

import multiprocessing

def worker(shared_list):
    shared_list.append("Hello")

with multiprocessing.Manager() as manager:
    shared_list = manager.list()
    process = multiprocessing.Process(target=worker, args=(shared_list,))
    process.start()
    process.join()
    print(shared_list)

20. Killing a Process

import multiprocessing
import time

def long_task():
    while True:
        print("Running...")
        time.sleep(1)

process = multiprocessing.Process(target=long_task)
process.start()
time.sleep(3)
process.terminate()
print("Process killed!")

---

3️⃣ Logging & Debugging with logging (10 Snippets)

21. Basic Logging Configuration

import logging

logging.basicConfig(level=logging.INFO)
logging.info("This is an info message")

22. Writing Logs to a File

import logging

logging.basicConfig(filename="app.log", level=logging.DEBUG)
logging.debug("This is a debug message")

23. Logging Different Levels

import logging

logging.warning("Warning message")
logging.error("Error message")
logging.critical("Critical error!")

24. Using Custom Log Format

import logging

logging.basicConfig(format="%(asctime)s - %(levelname)s - %(message)s", level=logging.INFO)
logging.info("Formatted log message")

25. Logging Exceptions

import logging

try:
    1 / 0
except ZeroDivisionError:
    logging.exception("An error occurred")

26. Creating a Custom Logger

import logging

logger = logging.getLogger("custom_logger")
logger.setLevel(logging.INFO)

handler = logging.FileHandler("custom.log")
formatter = logging.Formatter("%(levelname)s: %(message)s")
handler.setFormatter(formatter)
logger.addHandler(handler)

logger.info("Custom logger message")

27. Adding Multiple Handlers

import logging

logger = logging.getLogger("multi_logger")
logger.setLevel(logging.DEBUG)

console_handler = logging.StreamHandler()
file_handler = logging.FileHandler("logfile.log")

logger.addHandler(console_handler)
logger.addHandler(file_handler)

logger.info("This message goes to both console and file")

28. Using Rotating File Handler

import logging
from logging.handlers import RotatingFileHandler

handler = RotatingFileHandler("app.log", maxBytes=1000, backupCount=3)
logger = logging.getLogger("rotating_logger")
logger.addHandler(handler)

logger.warning("Rotating log example")

29. Disabling Logging for a Module

import logging
logging.getLogger("urllib3").setLevel(logging.WARNING)

30. Using Logging in a Class

import logging

class MyClass:
    def __init__(self):
        self.logger = logging.getLogger(self.__class__.__name__)
        self.logger.setLevel(logging.INFO)

    def do_something(self):
        self.logger.info("Doing something!")

obj = MyClass()
obj.do_something()

---

4️⃣ Pylint for Static Code Analysis (10 Snippets)

31. Installing Pylint

pip install pylint

32. Running Pylint on a File

pylint script.py

33. Checking a Python File for Issues

pylint my_script.py --errors-only

34. Ignoring Warnings in Pylint

# pylint: disable=missing-function-docstring
def my_function():
    pass

35. Generating a Pylint Report

pylint --output-format=json my_script.py

---