Python code to find greatest common divisor of multiple numbers
It's more common to use Euler's method to find GCD, rather than factorising both numbers.  However, I'll continue reviewing with the existing algorithm, as there's useful insights to be found.

First, let's look at factors().
Our factors variable is being used as a counter or multiset, and Python provides us with a collections.Counter class for that.
With from collections import Counter, we can replace

        if f'{f}' in factors.keys():
            factors.update({f'{f}': factors[f'{f}'] + 1})
        else:
            factors[f'{f}'] = 1


with
        factors[f] += 1

(I've also changed to using the numbers themselves as keys, instead of converting to string).
The division int(n / f) can be rewritten using integer divide operator n // f (and we know the result will be exact, as we tested n % f == 0).  Also, we should use math.isqrt() rather than int(math.sqrt()) when we want an integer.
from collections import Counter

def factors(n):
    factors = Counter({1: 1, n: 1})
    for f in range(2, 1 + math.sqrt(n)):
        while n % f == 0:
            factors[f] += 1
            n = n // f
    return factors


Now let's look at gcd().
We are computing the intersection of the two multisets.  The operator &amp; does exactly that for us:
common_factors = f1 &amp; f2
cd = 1
for f in common_factors.keys():
    cd *= f ** common_factors[f]

When we iterate over a dictionary, we don't need to get the keys and then index again.  We can iterate over its items() instead, like this:
for f,count in common_factors.items():
    cd *= f ** count

Or we could expand the multiset using elements():
for f in common_factors.elements():
    cd *= f

This allows us to then use math.prod() instead of our own loop:
return math.prod(common_factors.elements())

The whole lot then becomes a one-liner:
def gcd(x, y):
    return math.prod((factors(x) &amp; factors(y)).elements())


Next, main().  The heart of this function is what a functional programmer would call reduce, and - you guessed it - Python provides a reduce() function, in functools:
def main(args):
    args = map(int, args)
    print(reduce(gcd, args))


Finally, it's good practice to use a main guard, so the program can become a module:
if __name__ == &quot;__main__&quot;:
    args = sys.argv[1:]
    main(args)


Simplified code
import math
import sys
from collections import Counter
from functools import reduce

def factors(n):
    factors = Counter({1: 1, n: 1})
    for f in range(2, int(math.sqrt(n))):
        while n % f == 0:
            factors[f] += 1
            n = n // f
    return factors

def gcd(x, y):
    return math.prod((factors(x) &amp; factors(y)).elements())

if __name__ == &quot;__main__&quot;:
    print(reduce(gcd, map(int, sys.argv[1:])))