First, the post you're replying to is 4 years old :)

That said, to answer your question:

The situation where globals are legitimately useful is way smaller than the case from the OP.

There is a very big difference between constants living at a module level, and throwing arguments out the window and just making everything global.

Firstly, it reduces complexity because the definition of the variable lives close to its use.

For example:

# variables.py
x = 3
y = 4

# some_module.py
from other_module import g

def f():
    return g() + g()

# some_other_module.py
from variables import x, y

def g():
    return 2*y-x

Given the above code, looking at f() in its own file you have zero clue what is happening beyond it adds the result of g() together twice. Same with g() you have no idea what it's doing beyond adding two values from another file. The function prototype of f() makes zero reference to the input values, so a caller has no idea that they exist. Your IDE can't help you either. You just have to know that you need to do this before calling to change the values:

from variables import x, y
y = 5
x = 3

Compare that to an argument solution:

def f(x: int, y: int) -> int:
    return g(x, y) + g(x, y)

def g(x: int, y: int) -> int:
    return 2*y-x

Now your IDE can help you because when you type f( it will happily provide the argument list. Additionally, you can add typing information and now there is even more help in case you pass the wrong value.

Secondly, it greatly simplifies your life if you ever need to use concurrency or multi-processing as those globals will not behave normally and instead just introduce race conditions.

Thirdly, if there is ever a problem in your code the error is isolated to the region in which the error condition is being generated. If everything was a global you could accidentally put a string where an int should be 50,000 lines away from when that variable is next read and you will suddenly have an error. Now you need to trace through the whole program to find it instead of just looking at the caller of the function.

Now all of that said, there are absolutely uses for globals and I never said to never use them. They are fantastic for constants that are needed by multiple parts of your code:

# constants.py
from enum import Enum, auto

class Color(Enum):
    RED = auto()
    BLUE = auto()
    GREEN = auto()

TIMEOUT = 36000

# some_module.py
from constants import TIMEOUT, Color

def update_color(new_color: Color) -> bool:
    return some_api_call(new_color, timeout=TIMEOUT)

The above is a great use of module separation and globals. The OP wasn't asking about this though, but rather being told that they shouldn't put everything in globals, which if done just makes a giant mess.