== I wish I could split up code more easily in Python

This really starts with [[some tweets
https://twitter.com/thatcks/status/702303275698122752]]:

> This Python program has grown to almost 1500 lines. I think I need an
> intervention, or better data structures, or something. \\
> I also wish it was easier and more convenient to split up a Python
> program across multiple source files (it's one way Go wins).

The best way to split up a big program is to genuinely modularize
it. In other words, find separate pieces of functionality that can
be cleanly extracted and turn them into Python modules, in separate
files. There are still issues with your main program actually finding
the modules, but [[this can be worked around SearchPathWorkaround]]
(even though it is and remains annoying).

However, this assumes that you have a modular structure to start
with, with things sensibly separated. If your program started off
as a little 200 line thing and then grew step by step into a 1500
line monster ([[especially iteratively
../programming/IterativeProgrammer]]), you may not necessarily have
this. That's where Python makes things a little bit awkward. Splitting
things up into separate files fundamentally puts them in separate
modules and thus separate namespaces; in order to do it, you need to
be able to pull your code apart in this way. If your code isn't in
this state already you have some degree of rewriting ahead of you,
and in the mean time you have a 1500 line Python file.

(In theory you can do '_from modname import *_'. In practice this
is only faking a single namespace and the fakery can break down in
various ways.)

Go may be less elegant here (and Go certainly makes it harder to
have separate namespaces), but you can slice a big source file up
into several separate ones while keeping them all co-mingled as
one module, all using bits and pieces from each other. Sometimes
this is more convenient and expedient, even if it may be uglier.

With that said, Python has excellent reasons to require every
separate file to be a separate module. To summarize very quickly,
it's tied to how you don't just load a file of Python source code,
you run it (with things like [[function and class definitions
actually being executable statements FunctionDefinitionOrder]], and
possibly [[other interesting things happening ImportOddities]]).
This is a straightforward model that's quite appropriate for an
interpreted language, but it imposes certain constraints.