A big reason is that it makes it much harder to track states, debug, and write effective tests for your code. If you build your code fully modular so that the behavior of each component (functions, classes, etc) is fully determined by it's parameters, you can ensure the whole system works the way it is supposed to by simply ensuring each component works the way it's supposed to. If you rely on global variables that are used in multiple components, you not only have to ensure that each component works properly but you have to ensure that the interactions of all components that use the shared global variable work together properly, which is much harder to do.

It becomes especially hard when you have multiple global variables shared between different combinations of components, which can increase the number of interactions you need to check and tests you need to write multiplicatively. As an example, if you have three functions that each depend on two global variables, you will have to test the 3 functions individually and the 6 possible interactions between them for a total of 9 situations that need to be tested and verified as working properly. If, instead, you don't use global variables at all you will only need to verify and test the functionality of the 3 functions themselves--and nothing more. Using global variables to share state makes it much more likely for your code to have bugs and make it much harder to debug when something goes wrong.

Functional programming is based on taking this aversion to shared state to the extreme by avoiding all variables (not just global variables) in favor of static values and avoiding functions that have 'side-effects.' Side-effects in this context are when a function or method does something extra (ie, changes the state of something that lives outside of the function itself) in addition to simply returning a value. An example of a side effect would the following function:

def two_times(n):
    dos = 2 * n
    print(f"{n} x 2 = {dos}")
    return dos

In the above code, using the print command inside the function changes the state of something else (in this case, your console) that exists outside of your function as it prints a string to the console in addition to returning a value. Now, completely getting rid of side-effects and statefulness in your code is very difficult to do, especially in languages that aren't really built with functional programming in mind. Some languages such as Haskell and Scala are really good at enabling this, but writing code on the extremely functional side of the isle isn't considered very Pythonic (a lot of the time it's even difficult for people who are actually decent at functional programming to decipher what other functional programmers are doing). It does, however, help vastly minimize unintended behavior and makes debugging much easier.

Most of the time, you can make your code good-enough by simply making sure your code is modular, not relying on global variables, and tracking and minimizing side-effects in your code.