Что происходит в момент объявления функции?

Логично, что во время объявления функции интерпретатор не просто пропускает тело функции...

Куда? Куда пропускает не просто?

Python интерпретатор и обрабатывает код построчно. В момент выполнения print a интерпретатор останавливает выполнени программы, т.к. значение переменной “a” должно быть определено до использования, если это не так, то ошибка и что там дальше интерпретатор не знает.

LaRN, На самом деле, все намного сложнее. Попробуйте вообще убрать строчку "a = 2" (которая стоит в вышеприведенном фрагменте ПОСЛЕ print) и запустить. Все сработает! Потому что интерпретатор будет думать, что a - глобальная переменная!
Более того. Попробуйте запустить

a = 1
def test():
    z=a
    return z
test()

и

a = 1
def test():
    z=a
    a=6
    return z
test()

Обратите внимание, ошибка возникает ДО вновь введенной строчки "a=6".
При этом код

a = 1
def test():
    a=6
    return a
test()

будет вполне рабочим.

Другими словами, интерпретатор сначала просматривает весь код функции до ее конца, определяется с пространством имен, по одному ему понятному алгоритму решает где глобальная переменная, а где локальная (причем - не всегда как мы видим корректно решает) и только потом начинает построчно выполнять функцию.
Вот как-то так.

dmshar, да, это то что я имел ввиду. Только не очень понятно, интерпретатор "просматривает" весь код исключительно для поиска возможных локальных переменных? Зачем? При этом локальное пространство имен заполняется по мере выполнения функции... И исключение поднимается в ходе выполнения, а не во время "анализа" функции.

a = 1
def test():
    print 'ok' # -> 'ok'
    print locals() # -> {}
    print a # ERROR
    a = 2

https://pythonworld.ru/osnovy/faq.html
Судя по тому что там написано, как только мы присваиваем какое-то значение глобальной переменной внутри функции, создается новая локальная переменная с таким же именем. И получается что в момент загрузки модуля
все "ОК", т.к. функция видит глобальную переменную, но в момент выполнения функции все крашится, т.к. уже действует локальная, но без присвоенного ей значения.

LaRN, по ссылке вообще не о том. Что значит "в момент загрузки модуля функция видит глобальную переменную"? И не очень понятно "...уже действует локальная" с какого момента она действует и как понять "действует"?

a = 1
def test():
    print a
    a = 2
test()

Интерпретатор выполняет программу построчно. В таком случае, при вызове функции, он должен был бы вывести сначала глобальную переменную (print a), а потом создать локальную переменную (a = 2). Но "print a" приводит к ошибке, поскольку интерпретатор уже на 1ой строчке знает, что где-то дальше будет определена локальная переменная...

Файл читается построчно и тут же интерпретируется.
До объявления функции у вас a = 1 - тут создается глобальная переменная.
Далее в процессе чтения файла создается функция test и в конце этой функции в пространстве имен этой функии создается локальная переменная "a".

Если из вашего примера убрать вызов функции test() все отработает без ошибок.
Ошибка возникает в тот момент, когда интерпретатор выполняя функцию находит локальную переменную "a", это при вызове функции print(a), и ошибка от того, что значение локальной переменной "a" еще не присвоено.
Оно появиться после выполнения строки a = 2, т.е. схема такая:

загрузка модуля:
a = 1 #глобальная переменная "a" со значением 1
def test():
print(a) #глобальная переменная "a" со значением 1
a = 2 #создается локальная переменная "a", значение она получит только в момент выполнения функции

test()

#выполнение функции
def test():
print(a) #локальная переменная "a"без присвоенного значения - ошибка!
a = 2 #если бы сюда дошли была бы локальная переменная "a" со значением 2

Именно об этом по ссылке и говорится, смотрите первый пункт: "Почему я получаю исключение UnboundLocalError, хотя переменная имеет значение?"

Если бы вы в функции test() закомментировали код a = 2, создающий локальную переменную такой ошибки бы не было.

Т.е. вот так работает правильно:
a = 1
def test():
print a

test()

Все портит попытка присвоить имени "a" какое-либо значения в теле функции.
В этот момент создается локальная переменная с именем "a", которая закрывает для функции значение глобальной переменной "a".

Порядок разрешения имен в общем случае такой:
local - локальные переменные
nonlocal - "нелокальные" переменные, это те, что объявляются в теле функции и д.б. доступны во вложенных
функциях объявленных в теле той же функции. (шаблон декоратор как пример)
global - глобальные переменные
built-in - встроенная область