What is meant by Unpacking columns ?

Unpacking columns typically refers to the process of expanding or splitting a column that
contains structured or nested data into separate columns. This is common when dealing
with data that is stored in a denormalized or nested format, and you want to extract
specific elements for easier analysis.
Example:-
if you have a column with tuples (x, y), you might unpack it into two columns
one for x and another for y.
Similarly, if a column contains lists [a, b, c],
you could create separate columns for a, b, and c.
Original Column: [(10, 20), (15, 25), (12, 18)]
Unpacked Columns: Column1 Column2
10 20
15 25
12 18
In this case, the original column with tuples is unpacked into two separate columns,
Column1 and Column2, to represent the individual elements of each tuple.
Unpacking FileName
 Unpacking filenames refers to the process of extracting or breaking down a
filename into its individual components or parts.
 This is often done when filenames follow a specific pattern and you want to retrieve
meaningful information from them.
For example
consider the filename "document_20220101.txt".
If you know that your filenames follow the pattern "prefix_yearmonthday.extension,"
unpacking the filename involves extracting the individual components: like
 "document" as the prefix
 "2022" as the year,
 "01" as the month,
 "01" as the day, and
 "txt" as the extension.
Unpacking filenames is commonly performed using regular expressions in Python
, It allowing you to define a pattern that matches the structure of your filenames and
extract relevant information.
This process is useful when dealing with large datasets or when you need to organize and
analyze files based on their content or metadata.
Example 1:-
import re
# Sample list of filenames
filenames = ["document_20220101.txt", "image_20211215.jpg",
"data_20210320.csv"]
# Define a regular expression pattern to extract information
pattern = re.compile(r'([a-zA-Z]+)_(\d{4})(\d{2})(\d{2})\.(\w+)')
# Unpack information from each filename
for filename in filenames:
match = pattern.match(filename)
if match:
file_type, year, month, day, extension = match.groups()
print(f"File Type: {file_type}, Date: {year}-{month}-{day}, Extension:
{extension}")
else:
print(f"Filename '{filename}' does not match the expected pattern.")
Output:-

Example 2:-
import re
# Sample list of filenames
filenames = ["employee_001_JohnDoe.txt", "employee_002_JaneSmith.txt",
"employee_003_BobJohnson.txt"]
# Define a regular expression pattern to extract information
pattern = re.compile(r'employee_(\d+)_(\w+\.?\w*)\.txt')
# Unpack information from each filename
for filename in filenames:
match = pattern.match(filename)
if match:
employee_id, employee_name = match.groups()
 print(f"Employee ID: {employee_id}, Employee Name: {employee_name}")
else:
print(f"Filename '{filename}' does not match the expected
Output:-

Note:-
The line pattern = re.compile(r'employee_(\d+)_(\w+\.?\w*)\.txt') defines a regular
expression pattern using the re module in Python.
Explanation:
 employee_: It specifies that the filename should start with "employee_".
 (\d+): This is a capturing group that matches one or more digits (\d+). It captures
and extracts the employee ID from the filename.
 _: This part of the pattern is a literal match for the underscore character.
 (\w+\.?\w*): This is another capturing group that matches the employee name. It
allows for alphanumeric characters (\w+), an optional dot (\.?), and additional
alphanumeric characters (\w*). This captures and extracts the employee name.
 \.txt: This part of the pattern is a literal match for the file extension ".txt".
groups (\d+) and (\w+\.?\w*) extract the employee ID and name, respectively.
Sample Example:-
Given the filename "employee_001_JohnDoe.txt":
• Employee ID ((\d+)): Captures "001".
• Employee Name ((\w+\.?\w*)): Captures "JohnDoe".
This pattern is useful for extracting structured information from filenames that remain to
the specified format.
Unpacking content:-
 Unpacking content typically refers to the process of extracting or retrieving individual
pieces of information from a larger dataset or structure.
 This can be applied in various contexts, such as
 unpacking data from a container
 extracting values from a data structure or
 breaking down a complex dataset into its constituent elements.
Examples:-
 1. Unpacking Tuple or List
data = (1, 'John', 25)
employee_id, employee_name, employee_age = data
print("Employee ID:", employee_id)
print("Employee Name:", employee_name)
print("Employee Age:", employee_age)
Output:-

It making it easy to access and use the individual elements of the data.
2. Unpacking a Dictionary: involves extracting its key-value pairs and assigning
them to variables.
Example:-
# Sample dictionary
student_info = {
'name': 'John Doe',
'age': 20,
'grade': 'A',
'courses': ['Math', 'Physics', 'English']
}
# Extracting key-value pairs
for key, value in student_info.items():
print(f"{key}: {value}")
Output:-

Alternatively, you can use the get method to access values with default values for keys
that may not exist.

Example:-
# Unpacking with get method
name = student_info.get('name', 'N/A')
age = student_info.get('age', 'N/A')
grade = student_info.get('grade', 'N/A')
courses = student_info.get('courses', [])
# Displaying the unpacked values
print("Name:", name)
print("Age:", age)
print("Grade:", grade)
print("Courses:", courses)
Output:-

In this above example, if a key is not present in the dictionary, the get method returns the
specified default value ('N/A' for strings or an empty list [] for the 'courses' key).
Reformulating a new table for visualization
creating a new table for visualization. In this example, I'll use a hypothetical
scenario of tracking sales data for a small business. The table will include columns
such as "Product," "Units Sold," "Price per Unit," and "Total Revenue."

In this table:
 Product: Represents the name of the product.
 Units Sold: Represents the quantity of units sold for each product.
 Price per Unit ($): Represents the price of one unit of the product in dollars.
 Total Revenue ($) (calculated): Represents the total revenue generated for each
product (calculated by multiplying Units Sold by Price per Unit).
 Total: Represents the sum of Units Sold and Total Revenue for all products.
you can customize the table structure and content based on the specific data and context
you're working with. Visualization tools like Excel, Google Sheets, or Python libraries like
Matplotlib or Pandas can help in creating visualizations from such tabular data.
Example:-
import pandas as pd
# Creating a DataFrame (table) with sales data
data = {
'Product': ['Laptop', 'Smartphone', 'Headphones', 'Smartwatch'],
'Units Sold': [50, 120, 80, 30],
'Price per Unit ($)': [800, 300, 50, 150]
}
df = pd.DataFrame(data)
# Adding a calculated column for Total Revenue
df['Total Revenue ($)'] = df['Units Sold'] * df['Price per Unit ($)']
# Adding a row for the total
total_row = pd.DataFrame({
'Product': ['Total'],
'Units Sold': [df['Units Sold'].sum()],
'Price per Unit ($)': [''],
'Total Revenue ($)': [df['Total Revenue ($)'].sum()]
}, index=[len(df)])
df = pd.concat([df, total_row])
# Displaying the Data Frame
print(df)
Output:-

For drawing visualizations, we can use the Matplotlib library in conjunction with the
Pandas DataFrame. If you don't have Matplotlib installed, you can install it using:
Example:-
import pandas as pd
import matplotlib.pyplot as plt
# Creating a DataFrame (table) with sales data
data = {
'Product': ['Laptop', 'Smartphone', 'Headphones', 'Smartwatch'],
'Units Sold': [50, 120, 80, 30],
'Price per Unit ($)': [800, 300, 50, 150]
}
df = pd.DataFrame(data)
# Adding a calculated column for Total Revenue
df['Total Revenue ($)'] = df['Units Sold'] * df['Price per Unit ($)']
# Adding a row for the total
total_row = pd.DataFrame({
'Product': ['Total'],
'Units Sold': [df['Units Sold'].sum()],
'Price per Unit ($)': [''],
'Total Revenue ($)': [df['Total Revenue ($)'].sum()]
}, index=[len(df)])
df = pd.concat([df, total_row])
# Displaying the DataFrame
print("Data Table:")
print(df)
# Drawing a bar chart
plt.bar(df['Product'], df['Total Revenue ($)'], color='blue')
plt.xlabel('Product')
plt.ylabel('Total Revenue ($)')
plt.title('Total Revenue by Product')
plt.show()

Output:-