Bash is my favorite programming language, but lately I write any non-trivial script in Python.

My main annoyance is that all my scripts start with a wrapper for subprocess.run that sets check=True by default and prints out the command to be run with shlex.join. This function grows a few more functionalities depending on the script.

Another annoyance is that I have not found an equivalent I like for Bash's exec.

But pathlib.Path.(read|write)_(text|bytes), f-strings, tempfile.NamedTemporaryFile(delete_on_close=False) (very recent, I was basically using temporary directories for everything normally), textwrap.dedent with multiline strings, built-in json, tarfile, argparse, getpass, concurrent.futures' map, context managers... are very useful batteries without resorting to dependencies.

It's still not entirely mainstream to have tools that allow embedded dependencies, but at some point we'll get there, I guess.

This is a great post, but in practice, the tooling ecosystem around python had made it somewhat untenable in the past. With uv these days, though, I feel confident to write scripts in python that will work on a coworker's machine:

https://akrabat.com/using-uv-as-your-shebang-line

#!/usr/bin/env -S uv run --script
# /// script
# requires-python = ">=3.12"
# dependencies = [
# "click",
# ]
# ///

I tend to use Go for scripting if Bash won't cut it.

Solves distribution issues, runs fast, has types. What more need be said...

Shout out to Plumbum the best library in Python for shell scripting.

Off the top of my head, there are a few reasons I tend to use shell for quick scripts rather than python:

1. Command invocation from python is annoying. I don't want to memorize how to use subprocess.
2. Making HTTP requests with the standard library sucks (uv scripts help with this issue, but then you require all users to have uv, losing the portability benefits).
3. Bash pipes are genuinely amazing. When processing a file line by line in python, the most ergonomic thing to do (for me anyway) is to read the whole thing into memory and then do stuff. By contrast cat file | dostuff is a huge performance improvement.

These downsides, plus shellcheck being so good, mean that I'm pretty happy sticking to bash for most cases (as long as I don't have to do anything with data structures).

Python will work the same on all the machines you run your script on

This is exactly why I prefer starting automation in Python once powershell or bash extends past a few lines. However, paths and executable names are the usual things that break between platforms.

The problem I haven't solved is how to scale up larger sets of scripts. There's a region quite a bit past "basic automation" where things get much more complicated with many smaller scripts or an "uber-script" with subcommands; you have a lot of functionality you're duplicating from or want to use in binaries and ensuring cross-platform functionality becomes less trivial, especially if you're calling your own executables with changing CLIs or output formats or with lesser used workflows. It seems similar to the sort of problems I've encountered with complicated Jenkins or GitHub action flows.

standard library is there and won’t go away

The Python standard library isn't perfect but it's great. There's also shlex for command line parsing and difftool for diffs.

standard library is there and won’t go away

So long as you aren’t talking about the 2-3 transition.

I tend to use sh for shelling out from Python. For example

uv run --with sh - <<EOF
from sh import printf
print(printf("hello"))
EOF

Shout out also to babashka if youre lisp-inclined: https://babashka.org/ fast and portable

I use https://github.com/google/zx for my scripts.

I've been meaning to use Janet more as in this post.