An Autonomous Institute
NEAR ITPB, CHANNASANDRA, BENGALURU – 560 067
Affiliated to VTU,Belagavi
Approved by AICTE, New Delhi
Recognized by UGC under 2(f) & 12(B)
Accredited by NBA & NAAC
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING
INTRODUCTION TO PYTHON PROGRAMMING – MVJ22PCLK25B
~PREPARED BY DEEPTHI S S , ASSISTANT PROFESSOR - CSE
Module 4:
Organizing Files: The shutil Module, Walking a Directory Tree, Compressing Files with the
zipfile Module, Project: Renaming Files with American-Style Dates to European-Style
Dates, Project: Backing Up a Folder into a ZIP File,
Debugging: Raising Exceptions, Getting the Traceback as a String, Assertions, Logging, IDLE‟s
Debugger
Organising Files:
1. Organizing Files: The shutil Module
The shutil (shell utilities) module lets you copy, move, rename, and delete files or entire
directories.
Important shutil functions:
• shutil.copy(source, destination)
Copies the file at source to destination.
If destination is a folder, the file is copied into it.
• shutil.copytree(source_folder, destination_folder)
Recursively copies an entire directory tree.
• shutil.move(source, destination)
Moves a file or folder. Renames if the destination is just a filename.
• shutil.rmtree(path)
Deletes a folder and all its contents.
2. Walking a Directory Tree
Python’s os.walk() function generates the file names in a directory tree by walking the tree
either top-down or bottom-up.
Syntax:
import os
for foldername, subfolders, filenames in os.walk('your_path'):
print(f'Folder: {foldername}')
print(f'Subfolders: {subfolders}')
print(f'Files: {filenames}')
Explanation:
• foldername: Current folder being walked through.
• subfolders: List of subfolders in that folder.
• filenames: List of filenames in that folder.
3. Compressing Files with the zipfile Module
Python’s zipfile module allows you to create, read, write, extract, and list ZIP files.
Creating and Writing ZIP Files:
Reading and Extracting:
4. Project: Renaming Files with American-Style Dates to European-Style Dates
Goal:
Rename files with dates in MM-DD-YYYY format to DD-MM-YYYY format.
Steps:
1. Use os.listdir() and re module to find files with date format.
2. Identify and extract parts: month, day, year, and the rest of the filename.
3. Construct the new filename with European-style date.
4. Rename using os.rename().
Explanation:
There are two files with names :
report_03-25-2024.txt and want to rename as report_25-03-2024.txt
Line by line Exaplanation:
import shutil, os, re
• shutil: for moving (renaming) files.
• os: to list files in the current directory.
• re: for using regular expressions to detect American-style dates.
This regular expression finds files with American-style dates: MM-DD-YYYY.
• ^(.*?): Matches and captures any characters at the start of the filename.
• ((0|1)?\d)-: Matches the month part, allowing one or two digits.
• ((0|1|2|3)?\d)-: Matches the day part.
• ((19|20)\d\d): Matches the year part, starting with 19 or 20.
• (.*?)$: Matches anything after the date.
• The use of re.VERBOSE allows comments and spacing in the regex for readability.
for filename in os.listdir('.'): // Lists every file and folder in the current directory (.).
mo = date_pattern.search(filename)
• mo stands for "match object".
• search() looks for a match of the date pattern in the filename.
• If the pattern is found, mo will contain the matched text and groups.
if mo is None:
continue // If no date is found in the filename, skip to the next file.
before = mo.group(1) // Text before the date.
month = mo.group(2) // The American-style month.
day = mo.group(4) // the day part
year = mo.group(6) // the year part
after = mo.group(8) // text after the date
euro_filename = f'{before}{day}-{month}-{year}{after}' //Constructs the new filename in
European-style date format: DD-MM-YYYY.
shutil.move(filename, euro_filename) // Renames (moves) the file from the original name to the new
name.
example
Project: Backing Up a Folder into a ZIP File
Goal:
Create a ZIP file that contains the entire contents of a folder and ensures previous backups
aren’t overwritten.
Features:
• Automatically names ZIPs like foldername_1.zip, foldername_2.zip, etc.
• Avoids re-zipping ZIP files already in the folder.
• Uses os.walk() to gather all files.
import zipfile, os # Import the modules needed for zipping files and navigating the file system
def backup_to_zip(folder):
# Convert the folder name to an absolute path (for consistency and avoiding confusion)
folder = os.path.abspath(folder)
# Start with a number to create unique backup file names
number = 1
# Keep incrementing the number until we find a filename that doesn't exist yet
while True:
zip_filename = os.path.basename(folder) + f'_{number}.zip' # e.g., 'myfolder_1.zip'
if not os.path.exists(zip_filename): # Check if this ZIP file already exists
break # If not, we can use this name
number += 1 # Otherwise, try the next number
print(f'Creating {zip_filename}...')
# Create the new ZIP file in write mode
backup_zip = zipfile.ZipFile(zip_filename, 'w')
# Walk through every folder, subfolder, and file in the given folder
for foldername, subfolders, filenames in os.walk(folder):
print(f'Adding files in {foldername}...')
# Add the current folder to the ZIP file
backup_zip.write(foldername)
# Loop through each file in the folder
for filename in filenames:
new_base = os.path.basename(folder) + '_' # This helps us detect previous backup files
# Skip any files that are already backup ZIPs made by this script
if filename.startswith(new_base) and filename.endswith('.zip'):
continue # Don’t back up backup ZIP files
# Create the full path of the file and add it to the ZIP
file_path = os.path.join(foldername, filename)
backup_zip.write(file_path)
# Close the ZIP file after writing all files
backup_zip.close()
print('Done.')
Debugging
1. Raising Exceptions
Purpose:
To intentionally cause an error in your code when something goes wrong.
Example & Explanation:
def box_print(symbol, width, height):
if len(symbol) != 1:
raise Exception('Symbol must be a single character string.')
# Custom error if symbol isn't 1 character
if width <= 2:
raise Exception('Width must be greater than 2.') # Width
must allow drawing a box
if height <= 2:
raise Exception('Height must be greater than 2.') #
Height too small to make a box
print(symbol * width) # Top of the box
for i in range(height - 2):
print(symbol + ' ' * (width - 2) + symbol) # Middle rows
print(symbol * width) # Bottom of the box
box_print('*', 4, 4)
Output:
markdown
Copy code
****
* *
* *
****
If input is invalid:
box_print('**', 4, 4)
Raises:
Exception: Symbol must be a single character string.
2. Getting the Traceback as a String
Purpose:
To log or display the full traceback message without crashing the program.
Example:
import traceback
try:
raise Exception('This is the error message.')
except:
error_file = open('error_log.txt', 'w')
error_file.write(traceback.format_exc()) # Get the traceback
as a string and write it to a file
error_file.close()
print('The traceback info was written to error_log.txt')
What It Does:
• traceback.format_exc() captures the error message and stack trace.
• It’s useful in production code to log errors instead of showing them to users.
3. Assertions
Purpose:
To check if a condition is true while the program runs.
If not, an AssertionError is raised.
Example:
pod_bay_door_status = 'open'
assert pod_bay_door_status == 'closed', 'The pod bay doors need to
be "closed".'
Output:
AssertionError: The pod bay doors need to be "closed".
Tip:
Use assertions for sanity checks during development, not for handling runtime user input.
4. Logging
Purpose:
To track and record what the program is doing, especially useful in debugging large programs.
Example:
import logging
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s -
%(levelname)s - %(message)s')
logging.debug('Start of program')
def factorial(n):
logging.debug(f'Start of factorial({n})')
total = 1
for i in range(1, n + 1):
total *= i
logging.debug(f'i = {i}, total = {total}')
logging.debug(f'End of factorial({n})')
return total
print(factorial(5))
logging.debug('End of program')
Output:
(Logged in console)
2025-05-20 18:30:01,123 - DEBUG - Start of program
2025-05-20 18:30:01,123 - DEBUG - Start of factorial(5)
...
2025-05-20 18:30:01,123 - DEBUG - End of program
Logging Levels:
• DEBUG: Details for diagnosing problems.
• INFO: Confirmation that things work.
• WARNING: Something unexpected.
• ERROR: A more serious problem.
• CRITICAL: Program may not continue.
5. IDLE’s Debugger
Purpose:
To step through your code line by line and watch variables change.
How to Use:
1. Open your script in IDLE.
2. From the menu: Debug → Debugger.
3. Run your script.
4. You can now:
o Step through the code (Step button)
o View the call stack and local variables
o Watch execution line-by-line
Example:
If you run this:
def add(x, y):
total = x + y
return total
result = add(5, 7)
print(result)
Using the Debugger:
• You can see x = 5, y = 7, total = 12, and result = 12 as it runs.
Summary Table
Feature Purpose Output Example / Use Case
raise Exception() Stop execution when "Symbol must be a
something’s wrong single character"
traceback.format_exc() Get error details as a Log error to file
string
assert condition Ensure something is true Raises AssertionError if not
during execution
logging.debug() Track what's happening See values, logic, steps during
program execution
IDLE Debugger Step-by-step run and Visual debugging tool
variable view
