Hey there! You ever think about how amazing it would be to just automate your life a lot more every time by setting up systems, and all this stuff? Be it file management, task scheduling, or dealing with intricate processes — automation is the answer. For automation, use Python and Bash.
This article covers just how much Python and Bash can do to automate anything. But not the theory — we are going to be doing examples. And, you will get the knowledge of how to write scripts that can do boring tasks for you while saving yourself some time, but also automate all the repetitive things or system operations.
We’ll start with the basics: setting up your environment and writing simple scripts in Python and Bash. Next we will cover some more advanced using these two combinators so we can push our automation further. At the same time you will get a sneak peak to some of real world applications and how learning these skills can be a game-changer for you.
Oh, and one you are hungry for more — well, don’t forget our ebook The Art of Offensive Scripting. We need some real-life examples and in-depth tricks to go to the next level of automation from here onwards.
So, roll up your sleeves, and let’s get started on automating everything with Python and Bash!
Getting Started with Automation
Well then, let us delve into a bit of realistic automation. We will go back from the beginning (always good for understanding) and increase the difficulty each time. They will be using Linux and Gedit as their main tools, so enough words let’s get to it!
What is Automation?
Automation is the practice of writing scripts or using tools to take over redundant tasks for you. Sounds nice, imagine a virtual assistant doing the boring work for you.
Why Automate with Python and Bash?
Python or Bash are the two most powerful tools for automating your work. Python I s great for more complex tasks and data manipulation, yet Bash is amazing when you want a few lines to an operation on the system. The solution is powerful in combination: it can meet a spectrum of automation requirements.
Setting Up Your Environment
First things first, let’s set up your environment:
- Install Python: Most Linux distributions come with Python pre-installed. If you need to install or update it, use the command
sudo apt install python3. - Set Up Bash: Bash is included with most Linux systems, so you’re all set!
- Use Gedit: Gedit is a simple text editor perfect for writing scripts. Open it by typing
geditin your terminal.
Writing Your First Python Script
Let’s start with something simple—a “Hello, World!” script in Python. Open Gedit and create a file named hello_world.py:
print("Hello, World!")Save the file and run it from your terminal using:
python3 hello_world.pyYou should see the message “Hello, World!” printed to your terminal. Congratulations, you’ve just written and run your first Python script!
Writing Your First Bash Script
Now, let’s create a basic Bash script. Open Gedit and create a file named hello_world.sh:
#!/bin/bash
echo "Hello, World!"Save the file, make it executable with chmod +x hello_world.sh, and run it with:
./hello_world.shYou should see “Hello, World!” printed to your terminal. Awesome job!
Automating Tasks with Python
Now that you’ve got the basics down, let’s move on to more practical automation. Here’s a script that renames files in a directory. Open Gedit and create a file named rename_files.py:
import os
# Path to the directory containing files
path = '/path/to/your/directory'
# Loop through all files in the directory
for filename in os.listdir(path):
new_name = 'prefix_' + filename
os.rename(os.path.join(path, filename), os.path.join(path, new_name))
print("Files renamed successfully!")Replace '/path/to/your/directory' with the actual path to your folder. Save the file and run it from your terminal using:
python3 rename_files.pyYour files should now have a new prefix.
Automating Tasks with Bash
Let’s automate cleaning up old log files with Bash. Create a file named cleanup_logs.sh in Gedit:
#!/bin/bash
# Path to the directory containing logs
LOG_DIR="/path/to/your/logs"
# Find and delete log files older than 7 days
find $LOG_DIR -type f -name "*.log" -mtime +7 -exec rm {} \;
echo "Old log files cleaned up!"Replace "/path/to/your/logs" with your log directory path. Save the file, make it executable with chmod +x cleanup_logs.sh, and run it with:
./cleanup_logs.shYour old log files will be cleaned up!
Running Scripts Automatically
To automate running your scripts:
- For Bash Scripts: Use cron jobs. Open your crontab
crontab -eand add a line like0 2 * * * /path/to/cleanup_logs.shto run your script daily at 2 AM. - For Python Scripts: You can use cron jobs similarly or set up schedules as needed.
And there you have it—getting started with automation using Python and Bash on Linux with Gedit. From basic “Hello, World!” scripts to practical file handling and system cleanup, you’re now equipped to automate a variety of tasks. For more basics to advanced techniques, don’t forget to check out The Art of Offensive Scripting. We have mentioned step by step on the ebook so don’t miss it ..
Automating Tasks with Python
Alright, let’s dive into automating tasks with Python! We’re not just talking theory here—we’ll get right into some hands-on examples to make things crystal clear. And if you’re hungry for more, our book The Art of Offensive Scripting goes into even greater depth.
Python is super versatile for automation. Whether it’s handling files, processing data, or managing system operations, Python has you covered. Let’s start with some practical examples.
Example 1: Renaming Files
Imagine you have a bunch of files that need renaming—say, you want to add a prefix to each file. Here’s how you can automate that:
- Create Your Script: Open Gedit and create a file named
rename_files.py:
import os
# Path to the directory containing files
path = '/path/to/your/directory'
# Loop through all files in the directory
for filename in os.listdir(path):
new_name = 'prefix_' + filename
os.rename(os.path.join(path, filename), os.path.join(path, new_name))
print("Files renamed successfully!")- Customize and Run: Replace
'/path/to/your/directory'with the path to your actual directory. Save the file and run it with:
python3 rename_files.pyYour files should now have a prefix!
Example 2: Monitoring Disk Usage
Let’s say you want to keep an eye on disk usage and get an alert if it’s getting too high. Here’s a script for that:
- Create Your Script: Open Gedit and create a file named
disk_usage.py:
import shutil
# Set your threshold (e.g., 80% usage)
threshold = 80
# Get disk usage
total, used, free = shutil.disk_usage("/")
# Calculate usage percentage
usage_percentage = (used / total) * 100
# Check if usage exceeds the threshold
if usage_percentage > threshold:
print(f"Warning! Disk usage is at {usage_percentage:.2f}%")
else:
print(f"Disk usage is under control at {usage_percentage:.2f}%")- Run Your Script: Save the file and run it with:
python3 disk_usage.pyYou’ll get a warning if disk usage is too high!
Example 3: Automating Email Notifications
Here’s a script to send automated email notifications. Make sure you have the smtplib and email libraries:
- Create Your Script: Open Gedit and create a file named
send_email.py:
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
# Email settings
sender_email = 'your_email@example.com'
receiver_email = 'receiver@example.com'
password = 'your_password'
subject = 'Automated Email Notification'
body = 'This is an automated email sent from Python!'
# Create the email
msg = MIMEMultipart()
msg['From'] = sender_email
msg['To'] = receiver_email
msg['Subject'] = subject
msg.attach(MIMEText(body, 'plain'))
# Send the email
with smtplib.SMTP('smtp.example.com', 587) as server:
server.starttls()
server.login(sender_email, password)
server.sendmail(sender_email, receiver_email, msg.as_string())
print("Email sent successfully!")- Customize and Run: Replace placeholders with your email details. Save the file and run it with:
python3 send_email.pyYour email will be sent automatically!
Note: Make sure that you provide the permission before running the scripts. You can set permission simply using this command: chmod +x filename.py
And there you have it—some cool ways to automate tasks with Python. We’ve just scratched the surface here, and if you’re excited to learn more, check out our book The Art of Offensive Scripting. It’s packed with advanced examples and in-depth techniques to take your scripting skills to the next level.
Discover: Python Mastery: The Ultimate Comprehensive Cheat Sheet for Beginners and Experts Alike
Automating Tasks with Bash
First, we will cover how to carry out automation of tasks using Bash. For our case, Bash is really handy when you need to process system operations and even execute scripts right from your command line. In the next few sections, we need to walk through a couple of practical examples so you can get an idea of how much automation you can achieve with Bash. If you are hungry for more, our book The Art of Offensive Scripting gives a deep dive into these sub-products.
Getting Started
Bash scripts are perfect for tasks like file management, system monitoring, and batch processing. Let’s start with a few hands-on examples to get you comfortable.
Example 1: Creating a Backup Script
Imagine you need to back up files from one directory to another. Here’s how you can automate that with Bash:
- Create Your Script: Open Gedit and create a file named
backup_files.sh:
#!/bin/bash
# Source and destination directories
SOURCE_DIR="/path/to/source"
BACKUP_DIR="/path/to/backup"
# Create backup directory if it doesn't exist
mkdir -p $BACKUP_DIR
# Copy files to the backup directory
cp -r $SOURCE_DIR/* $BACKUP_DIR/
echo "Backup completed successfully!"- Customize and Run: Replace
/path/to/sourceand/path/to/backupwith your actual paths. Save the file, make it executable withchmod +x backup_files.sh, and run it with:
./backup_files.shYour files will be backed up!
Example 2: Cleaning Up Old Files
Here’s a script to delete old files from a directory. This is useful for cleaning up temporary files:
- Create Your Script: Open Gedit and create a file named
cleanup_old_files.sh:
#!/bin/bash
# Directory to clean up
TARGET_DIR="/path/to/your/directory"
# Find and delete files older than 30 days
find $TARGET_DIR -type f -mtime +30 -exec rm {} \;
echo "Old files cleaned up!"- Customize and Run: Replace
/path/to/your/directorywith your directory path. Save the file, make it executable withchmod +x cleanup_old_files.sh, and run it with:
./cleanup_old_files.shOld files will be removed!
Example 3: Monitoring System Resources
Let’s create a script to check your system’s memory usage and alert you if it’s getting too high:
- Create Your Script: Open Gedit and create a file named
monitor_memory.sh:
#!/bin/bash
# Set your memory usage threshold (e.g., 80%)
THRESHOLD=80
# Get memory usage percentage
MEMORY_USAGE=$(free | grep Mem | awk '{print $3/$2 * 100.0}')
# Check if memory usage exceeds the threshold
if (( $(echo "$MEMORY_USAGE > $THRESHOLD" | bc -l) )); then
echo "Warning! Memory usage is at ${MEMORY_USAGE}%"
else
echo "Memory usage is under control at ${MEMORY_USAGE}%"
fi- Run Your Script: Save the file, make it executable with
chmod +x monitor_memory.sh, and run it with:
./monitor_memory.shYou’ll get an alert if memory usage is too high!
Running Scripts Automatically
To automate running your Bash scripts:
- Use Cron Jobs: Open your crontab with
crontab -eand add a line like0 2 * * * /path/to/backup_files.shto run your script daily at 2 AM.
That’s it for automating tasks with Bash! From backing up files to cleaning up old data and monitoring system resources, Bash scripts can handle a lot of your routine tasks. For even more advanced scripting techniques and examples, don’t forget to check out our book The Art of Offensive Scripting. It’s loaded with in-depth content to take your Bash scripting to the next level.
Integrating Python and Bash
Ok, so here’s how you can further super power your automation by mixing Python with Bash. Combine them both and these individual scripts turn into a powerhouse that will speed up your workflow. This post cover some use cases through practical examples to demonstrate how they can work together. And for a deep dive take a look at our book: The Art of Offensive Scripting
Python is superb for processing data, branching logic, and everything else that is not related to quick system tasks or file management unique to Bash. You can use them together to get the best of both in one workflow.
Example 1: Running a Python Script from Bash
Let’s say you have a Python script that processes data, and you want to run it from a Bash script. Here’s how you can do it:
- Create Your Python Script: Open Gedit and create a file named
process_data.py:
# process_data.py
import sys
def main(input_file):
with open(input_file, 'r') as file:
data = file.read()
print(f"Data from {input_file}:")
print(data)
if __name__ == "__main__":
if len(sys.argv) != 2:
print("Usage: python process_data.py <file>")
else:
main(sys.argv[1])- Create Your Bash Script: Open Gedit and create a file named
run_process.sh:
#!/bin/bash
# Path to your input file
INPUT_FILE="/path/to/your/file.txt"
# Run the Python script
python3 process_data.py $INPUT_FILE- Run Your Scripts: Save both files, make the Bash script executable with
chmod +x run_process.sh, and run it with:
./run_process.shThis will execute the Python script from within the Bash script.
Example 2: Using Bash to Prepare Data for Python
Suppose you need to prepare a file before processing it with a Python script. Here’s how you can do it:
- Create Your Bash Script: Open Gedit and create a file named
prepare_data.sh:
#!/bin/bash
# Create a sample file
echo "Sample data for processing" > sample_data.txt
# Run the Python script
python3 process_data.py sample_data.txt- Run Your Bash Script: Make it executable with
chmod +x prepare_data.sh, and then run:
./prepare_data.shThis will create a file and then pass it to the Python script for processing.
Example 3: Using Python to Generate a Bash Command
Sometimes, you might want to use Python to generate a Bash command dynamically. Here’s an example:
- Create Your Python Script: Open Gedit and create a file named
generate_command.py:
# generate_command.py
import sys
def generate_command(file_path):
command = f"cat {file_path} | grep 'example'"
print(command)
if __name__ == "__main__":
if len(sys.argv) != 2:
print("Usage: python generate_command.py <file>")
else:
generate_command(sys.argv[1])- Create Your Bash Script: Open Gedit and create a file named
run_generated_command.sh:
#!/bin/bash
# Generate the command using Python
COMMAND=$(python3 generate_command.py /path/to/your/file.txt)
# Run the generated command
eval $COMMAND- Run Your Scripts: Save both files, make the Bash script executable with
chmod +x run_generated_command.sh, and run:
./run_generated_command.shThis will generate and execute a Bash command based on the Python script’s output.
Here’s a practical and casual conclusion for the article:
Conclusion
These are just the basics for getting new scripts working when calling Python from bash and vice versa, but this introduction should at least get you started in uncharted territory! We discussed everything from basic “Hello, World!” variations to more complex patterns like filters and conversational assistance. scripts to even complex file management and system monitoring. You have also learned how Python and Bash can together improve your workflow to be productive across a wider range of tasks.
If you’re eager to dive deeper and explore advanced techniques, don’t forget to check out our book The Art of Offensive Scripting. It’s packed with detailed examples and in-depth content to help you master automation and scripting.
Thanks for following along! Happy automating, and see you next time!
