Considering that pyFFmpeg is just a wrapper over the libraries, I'd say you shouldn't have any negligible performance difference between the 2, since they use the same libraries at the core.

From a brief look at FFMPY, you could do this using ffmpy.FFmpeg, as that allows any and all FFMPEG command line options, including -f. -- Click the link for documentation.

You could do the FFMPEG command with os.system. You'll need to import OS anyway to iterate through the files.

You would need to iterate through all the files in a directory though. This would be the more challenging bit, it's quite easy with a for loop though.

for filename in os.listdir(path):
    if (filename.endswith(".mp4")): #or .avi, .mpeg, whatever.
        os.system("ffmpeg -i {0} -f image2 -vf fps=fps=1 output%d.png".format(filename))
    else:
        continue

The above code iterates through the directory at path, and uses command prompt to execute your given FFMPEG command, using the filename (if it's a video file) in place of mymovie.avi

The conversion is quite straightforward:

ffmpeg.input('input.mov')\
    .video.filter('zscale', t='linear', npl=100)\
    .filter('format', pix_fmts='gbrpf32le')\
    .filter('zscale', p='bt709')\
    .filter('tonemap', tonemap='hable', desat=0)\
    .filter('zscale', t='bt709', m='bt709', r='tv')\
    .filter('format', pix_fmts='yuv420p')\
    .output('output.mp4', vcodec='libx264', crf=0, preset='ultrafast', tune='fastdecode')\
    .run()

• Arguments of ffmpeg.input(...) begins with input file name followed by input arguments.
• .video followed by .filter(...).filter(...).filter(...) applies chain of video filters.
• filter(...) begins with filter name followed by filter parameters as arguments.
  The syntax is <param_name0>=param_value0, <param_name1>=param_value1...
• output(...) begins with output file name followed by output arguments.

The only caveat is the format filter.
The parameter name of format filter is pix_fmts (we usually skip it).
One way for getting the parameter name is using FFmpeg help (in command line):

ffmpeg -h filter=format

Output:

Filter format
  Convert the input video to one of the specified pixel formats.
    Inputs:
       #0: default (video)
    Outputs:
       #0: default (video)
(no)format AVOptions:
   pix_fmts          <string>     ..FV....... A '|'-separated list of pixel formats

Here we can see that the parameter name is pix_fmts.

When using ffmpeg-python, it is recommended to add .overwrite_output() (equivalent to -y argument).

For testing it is recommended to add .global_args('-report') for creating a log file (remove .global_args('-report') after finish testing).

ffmpeg.input('input.mov')\
    .video.filter('zscale', t='linear', npl=100)\
    .filter('format', pix_fmts='gbrpf32le')\
    .filter('zscale', p='bt709')\
    .filter('tonemap', tonemap='hable', desat=0)\
    .filter('zscale', t='bt709', m='bt709', r='tv')\
    .filter('format', pix_fmts='yuv420p')\
    .output('output.mp4', vcodec='libx264', crf=0, preset='ultrafast', tune='fastdecode')\
    .global_args('-report').overwrite_output().run()

The log shows us the actual FFmpeg command:

ffmpeg -i input.mov -filter_complex "[0:v]zscale=npl=100:t=linear[s0];[s0]format=pix_fmts=gbrpf32le[s1];[s1]zscale=p=bt709[s2];[s2]tonemap=desat=0:tonemap=hable[s3];[s3]zscale=m=bt709:r=tv:t=bt709[s4];[s4]format=pix_fmts=yuv420p[s5]" -map "[s5]" -crf 0 -preset ultrafast -tune fastdecode -vcodec libx264 output.mp4 -report -y

As you can see, ffmpeg-python uses -filter_complex instead of -vf, and uses temporary naming as [s0], [s1], [s2]...
The result is equivalent to your original command.

I would recommend PyAV. it's a proper wrapper around ffmpeg's libraries.

the other mentioned packages use the "subprocess" approach, which is limited and inefficient. these libraries may be more convenient than plain ffmpeg APIs.

In Windows one line with spaces should work, but in Linux we have to pass the arguments as list.

• We can build the command as a list:

   command = ['ffmpeg', '-i', 'head1.png', '-i', 'hdmiSpitting.mov', '-filter_complex', '[0:v][1:v]overlay=0:0', '-pix_fmt', 'yuv420p', '-c:a', 'copy', 'output3.mov']
  

• We may also use shlex.split:

   import shlex
   command = shlex.split('ffmpeg -i head1.png -i hdmiSpitting.mov -filter_complex "[0:v][1:v] overlay=0:0" -pix_fmt yuv420p -c:a copy output3.mov')
  

Adding -y argument:
If the output file output3.mov already exists, FFmpeg prints a message:
File 'output3.mov' already exists. Overwrite? [y/N]
And waits for the user to press y.
In some development environments we can't see the message.
Add -y for overwriting the output if already exists (without asking):

command = shlex.split('ffmpeg -y -i head1.png -i hdmiSpitting.mov -filter_complex "[0:v][1:v] overlay=0:0" -pix_fmt yuv420p -c:a copy output3.mov')

Path issues:
There are cases when ffmpeg executable is not in the execution path.
Using full path may be necessary.
Example for Windows (assuming ffmpeg.exe is in c:\FFmpeg\bin):

command = shlex.split('c:\\FFmpeg\\bin\\ffmpeg.exe -y -i head1.png -i hdmiSpitting.mov -filter_complex "[0:v][1:v] overlay=0:0" -pix_fmt yuv420p -c:a copy output3.mov')

In Linux, the default path is /usr/bin/ffmpeg.

Using shell=True is not recommended and considered "unsafe".
For details see Security Considerations.
The default is False, so we may use subprocess.call(command).

Note: subprocess.run supposes to replace subprocess.call.
See this post for details.

Creating log file by adding -report argument:
In some development environments we can't see FFmpeg messages, which are printed to the console (written to stderr).
Adding -report argument creates a log file with name like ffmpeg-20220624-114156.log.
The log file may tell us what went wrong when we can't see the console.

Example:

import subprocess
import shlex
subprocess.run(shlex.split('ffmpeg -y -i head1.png -i hdmiSpitting.mov -filter_complex "[0:v][1:v] overlay=0:0" -pix_fmt yuv420p -c:a copy output3.mov -report'))