Read JSON files with Python

 

Getting All Keys and Values From a JSON Object in Python: 

A Practical Guide

JSON is everywhere in modern development, and Python’s dictionaries map cleanly to JSON objects. If you’ve fetched JSON data and want to pull out all keys, all values, or both, this guide walks you through simple patterns you can reuse in real projects. We’ll start with basics and then cover nested structures and a handy flattening utility for deeper JSON.

Prerequisites:

• Python 3.x
• Basic familiarity with dictionaries, lists, and JSON structure
• The json module (built into Python)

---

1) Load JSON into Python

To work with JSON in Python, you typically convert it into Python objects using the json module.

import json

# From a JSON string
json_str = '{"name": "Alice", "age": 30, "city": "New York"}'
data = json.loads(json_str)

# From a JSON file
# with open('data.json', 'r', encoding='utf-8') as f:
#     data = json.load(f)

print(type(data))  # <class 'dict'> if the top-level JSON is an object

Tip: json.loads returns Python objects (usually dicts or lists). json.load reads JSON directly from a file object.

---

2) Get all top-level keys

If you only need the keys from a JSON object (top-level keys in the dict), use dict.keys().

keys = list(data.keys())
print(keys)  # ['name', 'age', 'city']

# Iterate directly (no need to convert to a list)
for key in data:
    print(key)

Notes:

• dict.keys() returns a view object; wrap with list() if you need indexing or a concrete list.
• Iterating over a dict yields its keys by default.

---

3) Get all top-level values

Similarly, you can access all values with dict.values().

values = list(data.values())
print(values)  # ['Alice', 30, 'New York']

# Iterate directly
for value in data.values():
    print(value)

If you need both keys and values together, dict.items() is the most convenient path.

---

4) Get key-value pairs together

The standard way is to use dict.items(), which yields (key, value) pairs.

items = list(data.items())
print(items)  # [('name', 'Alice'), ('age', 30), ('city', 'New York')]

# Unpack in a loop
for key, value in data.items():
    print(f"{key}: {value}")

---

5) Working with nested JSON

Real-world JSON often contains nested objects (dictionaries) or arrays (lists). Access top-level keys easily, and for deeper levels, drill down or flatten.

Example: nested JSON

nested_json = '''
{
  "user": {
    "name": "John",
    "age": 28,
    "address": {
      "city": "Paris",
      "zip": "75001"
    }
  }
}
'''

data = json.loads(nested_json)

name = data["user"]["name"]
city = data["user"]["address"]["city"]

print(name)  # John
print(city)  # Paris

If your goal is to flatten a nested JSON into a simple key-value map (e.g., for CSV export), you can use a small helper.

---

6) Flattening nested dictionaries (simple version)

This utility flattens nested dictionaries into dot-separated keys. It’s a straightforward approach that works well for dictionaries without deep-list structures.

def flatten(d, parent_key='', sep='.'):
    items = {}
    for k, v in d.items():
        new_key = f"{parent_key}{sep}{k}" if parent_key else k
        if isinstance(v, dict):
            items.update(flatten(v, new_key, sep=sep))
        else:
            items[new_key] = v
    return items

flat = flatten(data)
print(flat)
# Example output with the nested JSON: {'user.name': 'John', 'user.age': 28, 'user.address.city': 'Paris', 'user.address.zip': '75001'}

Note:

• This version handles dictionaries recursively.
• If your JSON contains lists and you want to flatten those too, you can extend the function to annotate indices (e.g., foo.0.bar).

---

7) Error handling and best practices

• Validate JSON before processing. If the JSON is invalid, json.JSONDecodeError will be raised.

import json

s = '{"valid": true, "count": 5}'

try:
    obj = json.loads(s)
except json.JSONDecodeError as e:
    print(f"Invalid JSON: {e}")

• For very large JSON files, consider streaming or incremental parsers (e.g., ijson) to avoid loading everything into memory.
• Use descriptive variable names and comments to clarify whether you’re grabbing keys, values, or both.
• For concise extraction, dictionary comprehensions can help, e.g.,

# Keys as a list
keys = [k for k in data.keys()]

# A dictionary of only string values
string_pairs = {k: v for k, v in data.items() if isinstance(v, str)}

---

8) Quick reference cheat sheet

• Top-level keys: data.keys()
• All values: data.values()
• Key-value pairs: data.items()
• Convert to lists (if needed): list(data.keys()), list(data.values()), list(data.items())
• Access nested values: data['outer']['inner'] (use get() for safe access)

---

9) Real-world use cases

• Quick exploration of API responses
• Preparing JSON data for CSV export or tabular analysis
• Generating summaries of JSON payloads for logs or reports
• Validating the shape of received JSON by extracting keys and ensuring expected ones exist

---

10) Conclusion

JSON objects map naturally to Python dictionaries, so pulling out keys, values, or both is straightforward with the dict API (keys(), values(), items()). For nested structures, a small flattening utility makes it easy to work with a flat key-value map. If you’d like, I can tailor this post to your blog’s voice, adjust the length, or add more real-world examples (e.g., parsing a specific API response you cover). Tell me your preferred tone (friendly, technical, beginner-friendly), target word count, and any topics you want emphasized.

Efficient JSON serialization with Jackson and Java

 

📌 Introduction

JSON serialization is a fundamental part of modern Java applications — converting Java objects into JSON and back. Jackson is the most widely used library for this purpose in the Java ecosystem, offering powerful, flexible, and performant serialization mechanisms.

In this article, we'll explore:

• Basic Jackson setup
• Custom serialization & deserialization
• A real-world one-to-many example: CarDTO → CarAttributeDTO

📚 References:

• Baeldung — Jackson Custom Serialization
• Oracle Java Magazine — Java JSON Serialization with Jackson

---

⚙️ 1. Maven Dependency

Add Jackson to your pom.xml:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.17.0</version>
</dependency>

---

🏗️ 2. Define the DTOs

CarAttributeDTO — The "Many" Side

public class CarAttributeDTO {

    private String attributeName;   // e.g. "color", "engine", "transmission"
    private String attributeValue;  // e.g. "red", "V8", "automatic"

    // Constructors
    public CarAttributeDTO() {}

    public CarAttributeDTO(String attributeName, String attributeValue) {
        this.attributeName = attributeName;
        this.attributeValue = attributeValue;
    }

    // Getters & Setters
    public String getAttributeName() { return attributeName; }
    public void setAttributeName(String attributeName) { 
        this.attributeName = attributeName; 
    }

    public String getAttributeValue() { return attributeValue; }
    public void setAttributeValue(String attributeValue) { 
        this.attributeValue = attributeValue; 
    }
}

---

CarDTO — The "One" Side (with One-to-Many relationship)

import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonInclude;
import java.util.List;

@JsonInclude(JsonInclude.Include.NON_NULL) // Excludes null fields from JSON
public class CarDTO {

    @JsonProperty("car_id")
    private Long id;

    @JsonProperty("brand")
    private String brand;           // e.g. "BMW"

    @JsonProperty("model")
    private String model;           // e.g. "M3"

    @JsonProperty("year")
    private int year;               // e.g. 2024

    @JsonProperty("attributes")
    private List<CarAttributeDTO> attributes; // One-to-Many

    // Constructors
    public CarDTO() {}

    public CarDTO(Long id, String brand, String model, 
                  int year, List<CarAttributeDTO> attributes) {
        this.id = id;
        this.brand = brand;
        this.model = model;
        this.year = year;
        this.attributes = attributes;
    }

    // Getters & Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }

    public String getBrand() { return brand; }
    public void setBrand(String brand) { this.brand = brand; }

    public String getModel() { return model; }
    public void setModel(String model) { this.model = model; }

    public int getYear() { return year; }
    public void setYear(int year) { this.year = year; }

    public List<CarAttributeDTO> getAttributes() { return attributes; }
    public void setAttributes(List<CarAttributeDTO> attributes) { 
        this.attributes = attributes; 
    }
}

---

🔄 3. Basic Serialization (Object → JSON)

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import java.util.List;

public class JacksonSerializationExample {

    public static void main(String[] args) throws Exception {

        // Build the CarDTO with attributes (One-to-Many)
        List<CarAttributeDTO> attributes = List.of(
            new CarAttributeDTO("color",        "Frozen Black"),
            new CarAttributeDTO("engine",       "3.0L TwinPower Turbo"),
            new CarAttributeDTO("transmission", "8-Speed Automatic"),
            new CarAttributeDTO("horsepower",   "503 HP")
        );

        CarDTO car = new CarDTO(1L, "BMW", "M3 Competition", 2024, attributes);

        // Configure ObjectMapper
        ObjectMapper mapper = new ObjectMapper();
        mapper.enable(SerializationFeature.INDENT_OUTPUT); // Pretty print

        // Serialize to JSON String
        String json = mapper.writeValueAsString(car);
        System.out.println(json);
    }
}

📤 Output JSON:

{
  "car_id": 1,
  "brand": "BMW",
  "model": "M3 Competition",
  "year": 2024,
  "attributes": [
    {
      "attributeName": "color",
      "attributeValue": "Frozen Black"
    },
    {
      "attributeName": "engine",
      "attributeValue": "3.0L TwinPower Turbo"
    },
    {
      "attributeName": "transmission",
      "attributeValue": "8-Speed Automatic"
    },
    {
      "attributeName": "horsepower",
      "attributeValue": "503 HP"
    }
  ]
}

---

🔁 4. Deserialization (JSON → Object)

String jsonInput = """
    {
        "car_id": 2,
        "brand": "BMW",
        "model": "X5",
        "year": 2023,
        "attributes": [
            { "attributeName": "color",    "attributeValue": "Alpine White" },
            { "attributeName": "engine",   "attributeValue": "4.4L V8"      }
        ]
    }
    """;

ObjectMapper mapper = new ObjectMapper();
CarDTO car = mapper.readValue(jsonInput, CarDTO.class);

System.out.println("Brand : " + car.getBrand());
System.out.println("Model : " + car.getModel());
System.out.println("Attrs : " + car.getAttributes().size());

---

🎨 5. Custom Serializer

Sometimes you need full control over the JSON output. Use a custom serializer to reshape the attributes list into a flat key-value map:

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;
import java.io.IOException;

public class CarDTOSerializer extends StdSerializer<CarDTO> {

    public CarDTOSerializer() {
        super(CarDTO.class);
    }

    @Override
    public void serialize(CarDTO car, 
                          JsonGenerator gen, 
                          SerializerProvider provider) throws IOException {

        gen.writeStartObject();

        gen.writeNumberField("car_id", car.getId());
        gen.writeStringField("brand",  car.getBrand());
        gen.writeStringField("model",  car.getModel());
        gen.writeNumberField("year",   car.getYear());

        // 🔑 Flatten attributes into a key-value object
        gen.writeObjectFieldStart("attributes");
        if (car.getAttributes() != null) {
            for (CarAttributeDTO attr : car.getAttributes()) {
                gen.writeStringField(
                    attr.getAttributeName(), 
                    attr.getAttributeValue()
                );
            }
        }
        gen.writeEndObject();

        gen.writeEndObject();
    }
}

Register the Custom Serializer:

ObjectMapper mapper = new ObjectMapper();
mapper.enable(SerializationFeature.INDENT_OUTPUT);

SimpleModule module = new SimpleModule();
module.addSerializer(CarDTO.class, new CarDTOSerializer());
mapper.registerModule(module);

String json = mapper.writeValueAsString(car);
System.out.println(json);

📤 Output with Custom Serializer (flattened attributes):

{
  "car_id": 1,
  "brand": "BMW",
  "model": "M3 Competition",
  "year": 2024,
  "attributes": {
    "color": "Frozen Black",
    "engine": "3.0L TwinPower Turbo",
    "transmission": "8-Speed Automatic",
    "horsepower": "503 HP"
  }
}

---

🛡️ 6. Useful Jackson Annotations Summary

Annotation	Purpose
@JsonProperty("name")	Rename a field in JSON
@JsonInclude(NON_NULL)	Exclude null fields from output
@JsonIgnore	Completely exclude a field from serialization
@JsonAlias	Accept multiple names during deserialization
@JsonSerialize	Attach a custom serializer to a field/class
@JsonDeserialize	Attach a custom deserializer to a field/class
@JsonFormat	Format dates, numbers, etc.

---

✅ 7. Best Practices

🔹 Reuse ObjectMapper — it is thread-safe and expensive to create
🔹 Use @JsonInclude(NON_NULL) to keep JSON payloads clean
🔹 Prefer DTOs over Entities — never serialize JPA entities directly
🔹 Use custom serializers when you need full control over output format
🔹 Validate deserialized objects using Bean Validation (@Valid)

---

🎯 Conclusion

Jackson provides a rich, flexible API to handle JSON serialization in Java. By combining annotations, custom serializers, and the ObjectMapper, you can cleanly model complex relationships like Car → Attributes (one-to-many) and produce well-structured, efficient JSON payloads.

---

📚 Further Reading:

• Baeldung — Jackson Custom Serialization
• Oracle Java Magazine — Jackson JSON
• Definitive Guide to Jackson ObjectMapper - Serialize and Deserialize Java Objects

Linux for DevOps (Beginners)

---

1. Linux Fundamentals

1.1 What is Open Source?

Open-source software has source code freely available for anyone to view, modify, and distribute. Linux is built on open-source principles.

Key Points	Description
Source code	Publicly accessible
Development	Community-driven
License	Free to use, modify, and redistribute
Examples	Linux, Python, Firefox, Android

---

1.2 What is Linux?

Linux is a free, open-source operating system kernel created by Linus Torvalds in 1991. It powers many devices from smartphones to supercomputers.

Aspect	Details
Kernel vs OS	Linux is a kernel, not a full OS
Full OS Components	Linux Kernel + GNU tools + package manager + desktop environment
Popular Distributions (Distros)	Ubuntu, Fedora, Debian, CentOS, Arch Linux
Usage	Servers, cloud, Android, IoT, supercomputers

---

1.3 Linux vs UNIX

System	Description	Notes
Linux	Free, open-source kernel by Linus Torvalds (1991)	Community-developed
UNIX	Proprietary OS from Bell Labs (1969)	Not free
macOS	UNIX-based (BSD), proprietary by Apple	UNIX-based, proprietary
Similarities	Both follow POSIX standards	Linux inspired by UNIX

---

1.4 Why Use Linux?

• Free and open source — no licensing costs.
• Highly secure — fewer viruses, strong permission model.
• Stable and reliable — servers can run for years without reboot.
• Lightweight — runs on old hardware.
• Industry standard — most servers, cloud, and DevOps tools run on Linux.
• Customizable — choose your own components and desktop environment.

---

1.5 Linux vs Windows

Feature	Linux	Windows
Cost	Free	Requires license
Security	Strong permissions, fewer viruses	More vulnerable, requires antivirus
Usage	Dominates servers	Dominates desktops
CLI vs GUI	CLI-first	GUI-first
File Systems	ext4, XFS	NTFS, FAT32
Software Install	Package managers (apt, yum)	Installers (.exe)

---

1.6 What is a Kernel?

The kernel is the core of the operating system. It manages hardware resources and allows software to communicate with hardware.

Functions	Description
Manages	CPU, memory, I/O devices
Provides	System calls for programs to request services
Acts as	Bridge between applications and hardware
Linux Kernel Type	Monolithic (all services run in kernel space)

---

2. Installing Ubuntu via WSL (Windows Subsystem for Linux)

WSL allows running a Linux terminal on Windows without a VM.

Steps	Commands/Actions
Open PowerShell as Administrator	Run: wsl --install
Restart PC	Restart your computer
Open Ubuntu	From Start Menu
Initial Setup	Set username and password on first launch

Useful WSL Commands

Command	Description
wsl --list --verbose	List installed distros with details
wsl --set-default-version 2	Set WSL version 2 as default
explorer.exe .	Open Linux files in Windows Explorer

---

3. Basic Terminal Commands

3.1 Navigation

Command	Description
pwd	Print working directory
ls	List files and directories
ls -la	List all files including hidden with details
cd <dir>	Change directory
cd ..	Go up one directory level
cd ~	Go to home directory
cd /	Go to root directory

---

3.2 File and Directory Operations

Command	Description
mkdir <name>	Create a new directory
mkdir -p a/b/c	Create nested directories
touch <file>	Create empty file or update timestamp
rm <file>	Remove a file
rm -r <dir>	Remove directory and contents recursively
rm -zf <dir>	Force remove without prompts (use carefully!)
cp <src> <dst>	Copy a file
mv <src> <dst>	Move or rename a file
cat <file>	Display file contents
less <file>	Scroll through file contents
nano <file>	Open file in nano editor
vim <file>	Open file in vim editor

---

3.3 File Permissions — chmod

Symbol	Value	Permission
r	4	Read
w	2	Write
x	1	Execute

Command	Effect
chmod 755 file	Owner: rwx, Group: r-x, Others: r-x
chmod 644 file	Owner: rw-, Group: r--, Others: r--
chmod +x file	Add execute permission for all
chmod -w file	Remove write permission

---

3.4 Links

Command	Description
ln <src> <link>	Create hard link (same inode)
ln -s <src> <link>	Create symbolic (soft) link
alias ll='ls -la'	Create command alias (session only)

Note: Deleting original breaks soft link but not hard link.

---

4. File Handling & Text Processing

4.1 head & tail

Command	Description
head <file>	Show first 10 lines
head -n 20 <file>	Show first 20 lines
tail <file>	Show last 10 lines
tail -f <file>	Follow file output live (logs)

---

4.2 wc — Word Count

Command	Description
wc <file>	Show lines, words, bytes
wc -l <file>	Count lines only
wc -w <file>	Count words only
wc -c <file>	Count bytes/characters only

---

4.3 sort

Command	Description
sort <file>	Sort lines alphabetically
sort -r <file>	Sort in reverse order
sort -n <file>	Sort numerically
sort -u <file>	Sort and remove duplicates
sort -k2 <file>	Sort by 2nd column

---

4.4 grep — Search Text

Command	Description
grep 'pattern' file	Search for pattern in file
grep -i 'pattern' file	Case-insensitive search
grep -r 'pattern' dir/	Recursive search in directory
grep -n 'pattern' file	Show line numbers with results
grep -v 'pattern' file	Show lines NOT matching pattern
grep -c 'pattern' file	Count matching lines
`grep -E 'p1	p2' file`

---

4.5 find — File Search

Command	Description
find . -name '*.txt'	Find all .txt files in current directory
find / -name 'file.log'	Find file across entire system
find . -type d	Find only directories
find . -type f	Find only regular files
find . -mtime -7	Find files modified in last 7 days
find . -size +10M	Find files larger than 10MB

---

4.6 awk — Text Processing

Command	Description
awk '{print $1}' file	Print first column
awk '{print $1, $3}' file	Print columns 1 and 3
awk -F',' '{print $2}' file	Use comma as delimiter (CSV)
awk 'NR == 5' file	Print line number 5
awk '{sum+=$1} END {print sum}' file	Sum all values in column 1

---

5. Disk Management & Archives

Command	Description
df -h	Show disk space usage (human-readable)
du -sh <dir>	Show size of directory
du -h --max-depth=1	Show sizes of subdirectories
lsblk	List block devices (disks, partitions)

---

5.1 Zip / Unzip

Command	Description
zip archive.zip file1 file2	Create a zip archive
zip -r archive.zip dir/	Zip an entire directory
unzip archive.zip	Extract zip archive
unzip -l archive.zip	List contents without extracting

---

5.2 tar — Tape Archive

Command	Description
tar -cvf archive.tar dir/	Create tar archive
tar -xvf archive.tar	Extract tar archive
tar -czvf archive.tar.gz dir/	Create compressed tar.gz archive
tar -xzvf archive.tar.gz	Extract tar.gz archive
tar -tf archive.tar	List contents of tar file

---

6. Process Management

6.1 View Processes

Command	Description
ps	List processes for current user
ps aux	List all processes with details
`ps aux	grep nginx`
top	Interactive real-time viewer
htop	Improved interactive process viewer
pgrep <name>	Find process ID by name

---

6.2 Killing Processes

Command	Description
kill <PID>	Send SIGTERM (graceful stop)
kill -9 <PID>	Send SIGKILL (force stop)
killall <name>	Kill all processes by name
pkill <name>	Kill process by pattern match

---

6.3 Background Jobs & nohup

Command	Description
command &	Run command in background
jobs	List background jobs
fg %1	Bring job 1 to foreground
bg %1	Resume job 1 in background
Ctrl + Z	Suspend current foreground job
nohup command &	Run command immune to hangups (survives logout)
nohup command > out.log 2>&1 &	Run nohup and save output to file
disown %1	Remove job from shell job table

---

7. Remote Access

7.1 SSH — Secure Shell

Command	Description
ssh user@host	Connect to remote server
ssh user@192.168.1.10	Connect via IP address
ssh -p 2222 user@host	Connect on custom port
ssh-keygen	Generate SSH key pair
ssh-copy-id user@host	Copy public key to remote server
exit	Disconnect SSH session

---

7.2 SCP — Secure Copy

Command	Description
scp file.txt user@host:/path/	Copy file TO remote server
scp user@host:/path/file.txt .	Copy file FROM remote server
scp -r dir/ user@host:/path/	Copy directory recursively
scp -P 2222 file user@host:/path/	Use custom SSH port

---

7.3 GUI Tools

• PuTTY — SSH/Telnet client for Windows
• WinSCP — GUI file transfer for Windows (SFTP/SCP)
• FileZilla — Cross-platform FTP/SFTP client

---

8. Package Management

8.1 apt-get (Debian/Ubuntu)

Command	Description
sudo apt-get update	Update package list from repos
sudo apt-get upgrade	Upgrade all installed packages
sudo apt-get install <pkg>	Install a package
sudo apt-get remove <pkg>	Remove a package
sudo apt-get autoremove	Remove unused dependencies
apt-cache search <keyword>	Search for a package
dpkg -l	List all installed packages

---

8.2 wget — Download Files

Command	Description
wget <URL>	Download file from URL
wget -O output.zip <URL>	Download with custom filename
wget -c <URL>	Resume interrupted download
wget -r <URL>	Recursively download website

---

9. Scheduling & Automation

9.1 Cron Jobs

Cron is a time-based scheduler to run tasks automatically.

Command	Description
crontab -e	Edit cron jobs
crontab -l	List current cron jobs
crontab -r	Remove all cron jobs

Cron Syntax

* * * * * command
- - - - -
| | | | |
| | | | +---- Day of week (0-7, 0=Sun)
| | | +------ Month (1-12)
| | +-------- Day of month (1-31)
| +---------- Hour (0-23)
+------------ Minute (0-59)

Examples

Schedule	Command	Description
0 2 * * * /backup.sh	Run backup daily at 2 AM
*/5 * * * * /check.sh	Run every 5 minutes
0 9 * * 1 /report.sh	Run every Monday at 9 AM
@reboot /startup.sh	Run at system startup

---

9.2 Apache Airflow (Overview)

• Platform for authoring, scheduling, monitoring workflows.
• Uses Python DAGs (Directed Acyclic Graphs).
• Better suited than cron for complex, dependent tasks.
• Provides web UI for monitoring.
• Supports retries, alerts, and dependency management.

---

10. Shell Scripting

10.1 Getting Started

#!/bin/bash
echo 'Hello World'
chmod +x script.sh
./script.sh

• #!/bin/bash — Shebang line specifying interpreter.
• echo — Print to terminal.
• chmod +x — Make script executable.
• ./script.sh — Run script.

---

10.2 Variables

name='Alice'
echo $name
echo ${name}
read -p "Enter name: " name

• Assign variable (no spaces around =).
• Access variable with $.
• Safer with ${}.
• Read input from user.

---

10.3 Conditionals

if [ $age -gt 18 ]; then
  echo 'Adult'
elif [ $age -eq 18 ]; then
  echo 'Just 18'
else
  echo 'Minor'
fi

Operator	Description
-eq	Equal
-ne	Not equal
-gt	Greater than
-lt	Less than
-ge	Greater than or equal
-le	Less than or equal
-z	String is empty
-f file	File exists and is regular
-d dir	Directory exists

---

10.4 Loops

for i in 1 2 3 4 5; do
  echo "Number $i"
done

---

10.5 Advanced Scripting Tips

• Use set -e to exit on any error.
• Use set -x for debug mode (prints commands).
• Always quote variables "${var}" to handle spaces.
• Use [[ ]] for advanced test features.
• Trap signals for cleanup: trap 'cleanup' EXIT.

---

11. Quick Reference Cheat Sheet

Command Group	Commands / Description
Navigation Basics	pwd, ls, cd
File Operations	mkdir, touch, rm, cp, mv
View File Contents	cat, less, head, tail
Search & Text Processing	grep, find, awk, sort, wc
Permissions Management	chmod, chown
Links and Aliases	ln -s, alias
Process Management	ps, top, kill, nohup
Disk and Archives	df, du, tar, zip
Remote Access	ssh, scp
Package Management	apt-get, wget
Scheduling Tasks	crontab -e
Shell Scripting	#!/bin/bash, chmod +x

---