1.
Write a program to intersect with the operating
system using os module: 1)Display current working
directory 2)List all files and directory 3)Create a new
directory 4)Remove an empty directory 5)Run a shell
command. in python
import os
def display_current_directory():
current_directory = os.getcwd() # Get the current working directory
print(f"Current Working Directory: {current_directory}")
def list_files_and_directories():
files_and_dirs = os.listdir() # List files and directories in the current working directory
print("Files and Directories in the Current Directory:")
for item in files_and_dirs:
print(item)
def create_new_directory(directory_name):
try:
os.mkdir(directory_name) # Create a new directory
print(f"Directory '{directory_name}' created successfully.")
except FileExistsError:
print(f"Directory '{directory_name}' already exists.")
except Exception as e:
print(f"An error occurred: {e}")
def remove_empty_directory(directory_name):
try:
os.rmdir(directory_name) # Remove an empty directory
print(f"Directory '{directory_name}' removed successfully.")
except FileNotFoundError:
print(f"Directory '{directory_name}' does not exist.")
except OSError:
print(f"Directory '{directory_name}' is not empty or cannot be removed.")
except Exception as e:
print(f"An error occurred: {e}")
def run_shell_command(command):
try:
os.system(command) # Run a shell command
print(f"Shell command '{command}' executed.")
except Exception as e:
print(f"An error occurred while running the shell command: {e}")
if __name__ == "__main__":
display_current_directory()
list_files_and_directories()
create_new_directory('test_directory')
remove_empty_directory('test_directory')
run_shell_command('echo Hello World')
2. Write a program for file operations using ‘shutil’
module and collect information about os architecture
and processor: 1)Copy a file 2)Move a file 3)Remove a
directory 4)OS name 5)OS version 6)Processor details in
python
import shutil
import os
import platform
import psutil
def copy_file(src, dst):
try:
shutil.copy(src, dst) # Copy file from src to dst
print(f"File copied from {src} to {dst}")
except FileNotFoundError:
print(f"Source file {src} not found.")
except Exception as e:
print(f"Error while copying file: {e}")
def move_file(src, dst):
try:
shutil.move(src, dst) # Move file from src to dst
print(f"File moved from {src} to {dst}")
except FileNotFoundError:
print(f"Source file {src} not found.")
except Exception as e:
print(f"Error while moving file: {e}")
def remove_directory(directory_name):
try:
shutil.rmtree(directory_name) # Remove a directory and all its contents
print(f"Directory {directory_name} and its contents removed successfully.")
except FileNotFoundError:
print(f"Directory {directory_name} does not exist.")
except Exception as e:
print(f"Error while removing directory: {e}")
def get_os_name():
os_name = platform.system() # Get the name of the operating system
print(f"Operating System: {os_name}")
def get_os_version():
os_version = platform.version() # Get the version of the OS
print(f"OS Version: {os_version}")
def get_processor_details():
processor = platform.processor() # Get the processor name
print(f"Processor: {processor}")
cpu_count = psutil.cpu_count(logical=True) # Logical cores
cpu_physical = psutil.cpu_count(logical=False) # Physical cores
print(f"Logical CPUs: {cpu_count}")
print(f"Physical CPUs: {cpu_physical}")
if __name__ == "__main__":
copy_file('source_file.txt', 'destination_file.txt')
move_file('destination_file.txt', 'moved_file.txt')
remove_directory('test_directory')
get_os_name()
get_os_version()
get_processor_details()
3. Write a program for directory tree traversal using
os.walk() method. in python
import os
def traverse_directory_tree(root_dir):
for dirpath, dirnames, filenames in os.walk(root_dir):
print(f"Current Directory: {dirpath}")
if dirnames:
print("Subdirectories:")
for dirname in dirnames:
print(f" - {dirname}")
else:
print("No subdirectories.")
if filenames:
print("Files:")
for filename in filenames:
print(f" - {filename}")
else:
print("No files.")
print("="*40)
root_directory = "."
traverse_directory_tree(root_directory)
4. Write a program in python for parallel computing by
using any one parallel system tool. in python without
comment lines
import concurrent.futures
import time
def compute_square(n):
time.sleep(1)
return n * n
def compute_cube(n):
time.sleep(1)
return n * n * n
def main():
numbers = [1, 2, 3, 4, 5]
with concurrent.futures.ThreadPoolExecutor() as executor:
square_results = executor.map(compute_square, numbers)
cube_results = executor.map(compute_cube, numbers)
print("Squares:", list(square_results))
print("Cubes:", list(cube_results))
if __name__ == "__main__":
main()
5. Write a program to terminate the execution of a
python program or exit the python interpreter: 1)quit()
2) exit() 3)sys.exit() 4)os._exit() in python without
coments line
import sys
import os
def terminate_program(method):
if method == 1:
print("Using quit() to terminate the program.")
quit()
elif method == 2:
print("Using exit() to terminate the program.")
exit()
elif method == 3:
print("Using sys.exit() to terminate the program.")
sys.exit()
elif method == 4:
print("Using os._exit() to terminate the program.")
os._exit(0)
terminate_program(3)
6. Write a program for handling command line
arguments using below mentioned module: 1)sys.argv
2)getopt module 3)argparse module
import sys
import getopt
import argparse
def sys_argv_example():
print("Using sys.argv:")
for arg in sys.argv:
print(arg)
def getopt_example():
print("Using getopt:")
args = sys.argv[1:] # Skip the script name
opts, _ = getopt.getopt(args, "a:b:")
for opt, value in opts:
print(f"{opt} {value}")
def argparse_example():
print("Using argparse:")
parser = argparse.ArgumentParser()
parser.add_argument("-a", type=int, help="First argument")
parser.add_argument("-b", type=int, help="Second argument")
args = parser.parse_args() # Parse the arguments
print(f"a = {args.a}, b = {args.b}")
if __name__ == "__main__":
# Manually set sys.argv to simulate command-line arguments
sys.argv = ['command_line_args.py', '-a', '10', '-b', '20']
sys_argv_example()
getopt_example()
argparse_example()
UNIT-4
7. Write a program to communicate between two
nodes connected in network.(socket
programming)
import socket
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(('0.0.0.0', 12345))
server_socket.listen(5)
print("Server listening on 0.0.0.0:12345...")
while True:
client_socket, addr = server_socket.accept()
print(f"Connected to {addr}")
data = client_socket.recv(1024).decode()
print(f"Client says: {data}")
client_socket.send("Message received successfully!".encode())
client_socket.close()
Save the above code as “Server.py”
import socket
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect(('127.0.0.1', 12345))
client_socket.send("Hello, Server!".encode())
response = client_socket.recv(1024).decode()
print(f"Server response: {response}")
client_socket.close()
Save the above code as “ Client.py”
8. Write a program to establish a dynamic
interaction between a web application and the
browser.(cell script with user interaction)
import tkinter as tk
from tkinter import ttk
def button_click():
output_label.config(text="Button clicked!")
def submit_click():
user_input = input_entry.get()
if user_input:
output_label.config(text=f"You entered: {user_input}")
input_entry.delete(0, tk.END) # Clear the input field
else:
output_label.config(text="Please enter something!")
def enter_pressed(event):
submit_click()
root = tk.Tk()
root.title("Dynamic Interaction")
output_label = ttk.Label(root, text="Waiting for user interaction...")
output_label.pack(pady=10)
button = ttk.Button(root, text="Click Me!", command=button_click)
button.pack(pady=5)
input_entry = ttk.Entry(root)
input_entry.pack(pady=5)
input_entry.bind("<Return>", enter_pressed) #Bind enter key to submit
submit_button = ttk.Button(root, text="Submit", command=submit_click)
submit_button.pack(pady=5)
root.mainloop()
9. Write a program in python to process xml data
using SAX parser(simple API for XML).
import xml.sax
class MyHandler(xml.sax.ContentHandler):
def __init__(self):
self.current_data = ""
self.title = ""
self.author = ""
self.year = ""
self.price = ""
def startElement(self, tag, attributes):
self.current_data = tag
def endElement(self, tag):
if self.current_data == "title":
print("Title:", self.title)
elif self.current_data == "author":
print("Author:", self.author)
elif self.current_data == "year":
print("Year:", self.year)
elif self.current_data == "price":
print("Price:", self.price)
self.current_data = ""
def characters(self, content):
if self.current_data == "title":
self.title = content
elif self.current_data == "author":
self.author = content
elif self.current_data == "year":
self.year = content
elif self.current_data == "price":
self.price = content
if __name__ == "__main__":
xml_data = """
<bookstore>
<book>
<title>Everyday Italian</title>
<author>Giada De Laurentiis</author>
<year>2005</year>
<price>30.00</price>
</book>
<book>
<title>Harry Potter</title>
<author>J K. Rowling</author>
<year>2005</year>
<price>29.99</price>
</book>
</bookstore>
"""
parser = xml.sax.make_parser()
parser.setFeature(xml.sax.handler.feature_namespaces, 0)
handler = MyHandler()
parser.setContentHandler(handler)
xml.sax.parseString(xml_data, handler)
10. Write a python program to process XML data
using Dom parser(Document object Model API).
from xml.dom.minidom import parse
# Parse the XML file
xml_file = "sample.xml" # Make sure this file exists
dom_tree = parse(xml_file)
# Get the root element
root = dom_tree.documentElement
print(f"Root Element: {root.tagName}")
# Get all "employee" elements
employees = root.getElementsByTagName("employee")
# Loop through employees and print details
for emp in employees:
emp_id = emp.getAttribute("id") # Get attribute
name = emp.getElementsByTagName("name")[0].childNodes[0].nodeValue
age = emp.getElementsByTagName("age")[0].childNodes[0].nodeValue
department = emp.getElementsByTagName("department")[0].childNodes[0].nodeValue
print(f"\nEmployee ID: {emp_id}")
print(f"Name: {name}")
print(f"Age: {age}")
print(f"Department: {department}")
Save the above code as “parser_xml.py”
<?xml version="1.0"?>
<company>
<employee id="101">
<name>Alice</name>
<age>30</age>
<department>HR</department>
</employee>
<employee id="102">
<name>Bob</name>
<age>35</age>
<department>IT</department>
</employee>
</company>
Save the above code as “sample.xml”
Now run the “ parser_xml.py “ code
