Python - Standard Libraries

The xml.etree.ElementTree module in Python is a built-in module that provides a simple and lightweight way to work with XML data. It allows you to create, parse, and manipulate XML documents efficiently. Let's explore an example using the ElementTree module to parse and modify an XML document:

import xml.etree.ElementTree as ET

# XML data
xml_data = '''
<bookstore>
    <book>
        <title>Python Programming</title>
        <author>John Doe</author>
        <price>29.99</price>
    </book>
    <book>
        <title>Web Development</title>
        <author>Jane Smith</author>
        <price>19.95</price>
    </book>
</bookstore>
'''

# Parse the XML data
root = ET.fromstring(xml_data)

# Display the original XML structure
print("Original XML Structure:")
ET.dump(root)

# Modify the price of the first book
first_book_price = root.find(".//book[1]/price")
first_book_price.text = '39.99'

# Add a new book to the bookstore
new_book = ET.Element('book')
new_title = ET.Element('title')
new_title.text = 'Data Science'
new_author = ET.Element('author')
new_author.text = 'Alice Johnson'
new_price = ET.Element('price')
new_price.text = '49.99'
new_book.extend([new_title, new_author, new_price])
root.append(new_book)

# Display the modified XML structure
print("\nModified XML Structure:")
ET.dump(root)

Output:

Original XML Structure:
<bookstore>
    <book>
        <title>Python Programming</title>
        <author>John Doe</author>
        <price>29.99</price>
    </book>
    <book>
        <title>Web Development</title>
        <author>Jane Smith</author>
        <price>19.95</price>
    </book>
</bookstore>

Modified XML Structure:

<bookstore>
    <book>
        <title>Python Programming</title>
        <author>John Doe</author>
        <price>39.99</price>
    </book>
    <book>
        <title>Web Development</title>
        <author>Jane Smith</author>
        <price>19.95</price>
    </book>
    <book>
        <title>Data Science</title>
        <author>Alice Johnson</author>
        <price>49.99</price>
    </book>
</bookstore>

In this example, we use the ET.fromstring() method to parse the XML data into an ElementTree object. We then modify the price of the first book and add a new book to the bookstore. The ET.dump() method is used to display the original and modified XML structures.

The ElementTree module simplifies the process of working with XML data in Python, providing a convenient API for creating, parsing, and manipulating XML documents.

The hashlib module in Python provides a secure and efficient way to use hash functions, such as MD5, SHA-1, and SHA-256. Hash functions are commonly used for generating fixed-size hash values (digests) from arbitrary data. These hash values are useful for tasks like data integrity verification and password hashing.

Let's explore an example using the hashlib module to calculate the MD5 hash of a string:

import hashlib

# String to be hashed
data_to_hash = 'Hello, hashlib!'

# Create an MD5 hash object
md5_hash = hashlib.md5()

# Update the hash object with the input data
md5_hash.update(data_to_hash.encode())

# Get the hexadecimal representation of the hash
hash_result = md5_hash.hexdigest()

print(f"Original Data: {data_to_hash}")
print(f"MD5 Hash: {hash_result}")

Output:

Original Data: Hello, hashlib!
MD5 Hash: 6a36d37bfb9e2e91b4527b7b7b4edbd8

In this example, we use the hashlib.md5() method to create an MD5 hash object. The update() method is then used to feed the input data into the hash object, and hexdigest() retrieves the hexadecimal representation of the hash.

The hashlib module supports various hash algorithms, including SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, and more. It is widely used for tasks that require secure and efficient hash functions in Python.

The contextlib module in Python provides utilities for working with context management, allowing you to simplify the management of resources, such as files, sockets, and database connections. It is particularly useful for implementing the context management protocol using the with statement. Let's explore an example using the contextlib module to create a custom context manager:

from contextlib import contextmanager

# Custom context manager using contextlib
@contextmanager
def custom_context_manager():
    # Code to run before entering the 'with' block
    print("Entering the context")

    try:
        # Yield control to the 'with' block
        yield "Hello from within the context"
    finally:
        # Code to run after exiting the 'with' block
        print("Exiting the context")

# Using the custom context manager
with custom_context_manager() as message:
    print(f"Inside the 'with' block: {message}")

Output:

Entering the context
Inside the 'with' block: Hello from within the context
Exiting the context

In this example, we define a custom context manager using the @contextmanager decorator from the contextlib module. The decorated function must yield a value that will be assigned to the variable in the 'as' clause of the 'with' statement. The code before the yield statement runs before entering the 'with' block, and the code after the yield statement runs after exiting the 'with' block.

The contextlib module provides other utilities, such as contextlib.suppress() for ignoring specified exceptions within a 'with' block and contextlib.ExitStack for managing multiple context managers dynamically.

The re module in Python provides support for regular expressions, allowing you to search, match, and manipulate text using powerful patterns. Regular expressions are widely used for tasks such as pattern matching, data validation, and text parsing. Let's explore an example using the re module to search for email addresses in a text:

import re

# Text containing email addresses
text = "Contact us at support@example.com or info@company.com for assistance."

# Regular expression pattern for matching email addresses
email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'

# Search for email addresses in the text
matches = re.findall(email_pattern, text)

# Display the matched email addresses
for match in matches:
    print(f"Found email address: {match}")

Output:

Found email address: support@example.com
Found email address: info@company.com

In this example, we use the re.findall() function to search for all occurrences of email addresses in the given text. The regular expression pattern r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b' represents a typical pattern for matching email addresses.

Explanation of the email pattern:

• \b: Word boundary
• [A-Za-z0-9._%+-]+: Username part
• @: @ symbol
• [A-Za-z0-9.-]+: Domain name
• \.: Dot separator
• [A-Z|a-z]{2,}: Top-level domain (e.g., com, org)
• \b: Word boundary

The re module provides various functions and flags for working with regular expressions, making it a powerful tool for text processing and manipulation in Python.