7-й час
Функции и модули
В предыдущей главе Вы узнали о таких базовых типах данных Python, как последовательности и словари. Таким образом, Вы уже готовы к написанию функций. Только после того как Вы овладеете искусством написания функций, можно переходить к созданию эффективных и полезных программ. Мы также рассмотрим модули, упоминания о которых уже встречались Вам раньше. Модули — это файлы, в которых собраны определения функций. К концу этой главы Вы не „только научитесь создавать функции, но и узнаете, как помещать функции в модули, чтобы их можно было импортировать и использовать в других программах. Итак, мы рассмотрим следующие вопросы: определение собственной функции; создание собственного модуля; проверка имени модуля; использование аргументов командной строки.
Единственное назначение функции состоит в том, чтобы хоть немного облегчить труд программиста. Без функций код программы превращается в длинное "спагетти", связанное в невообразимые узлы инструкциями goto и long_jmp. Разобраться в таких хитросплетениях было невозможно ещё на заре программирования, когда программы по сложности и обилию выполняемых задач были несоизмеримо проще современных.
Функция long_jmp() печально известна в системах UNIX. С её помощью можно выполнять так называемые нелокальные переходы. Такие переходы позволяют программистам, работающим в С на машинах с UNIX, произвольно перескакивать из одного блока кода в другой, независимо от текущего состояния программы. Когда их применение обосновано и выполнено должным образом, это может стать верхом искусства, но стоит чуть-чуть расслабиться, результаты окажутся столь же живописными, как прыжок ребенка в лужу грязи.
Наша задача состоит в том, чтобы написанные программы были просты для понимания и читабельны. Создание ясного и понятного кода — вот одна из причин, почему существуют функции. С их помощью Вы можете разбивать длинные уродливые нагромождения тяжело воспринимаемого кода в небольшие и лёгкие для понимания блоки. Кроме того, эти блоки можно использовать в программе многократно. Многократное использование функций — очень важное свойство, впрочем, присущее всем языкам программирования. Но Python отличается тем, что значительно облегчает процесс многократного использования одних и тех же функций в независимых программах. Нет никакого здравого смысла в многократном переписывании одного и того же кода для каждой создаваемой Вами программы.
Разбиение программы на множество небольших блоков (тут, конечно, тоже не следует перегибать палку) значительно повышает эффективность программирования, а не просто облегчает восприятие и понимание разных блоков кода. Даже возможность повторного использования функций уходит на второй план по сравнению с тем, что само по себе использование функций в корне изменяет стиль и основополагающие принципы программирования. Для наглядности позвольте мне рассказать об одной из своих самых первых программ, написанных в далеком 1968 году (примите во внимание, что это была эпоха повального увлечения кодом в стиле "спагетти").
В то время я работал оператором вычислительной машины на третьей смене. Каждую неделю мы должны были усаживаться за клавишный перфоратор (а как ещё, по-вашему, появлялись те квадратные дырочки в перфокартах) и набивать титульные перфокарты для хранилища магнитных лент с программами. Эти перфокарты затем загружали в специальную инвентаризационную машину. Каждую неделю нужно было набить приблизительно 50 карточек, что занимало час или два усердной работы, в зависимости от того, насколько проворно мы работали за перфоратором. Вскоре после того как я познакомился с осноВами программирования на COBOL, я понял, что мог бы заставить компьютер вместо меня перфорировать карты, вставляя текущую дату. Все, что мне необходимо было сделать, - это написать программу, которая бы выполняла эту задачу.
Поскольку перфокарты были необходимы только в рабочие дни, а я хотел, чтобы моя программа работала веками, мне пришлось погрузиться в особенности григорианского календаря, т.е. проблема состояла в том, чтобы программа отслеживала рабочие дни в разные годы. Я выяснил, что годы полностью повторяются с периодичностью 28 лет, с незначительными исключениями, проявляющимися каждые 100 лет. Чтобы внести свою лепту в проблему 2000 года, я решил проигнорировать эти незначительные исключения, которые, конечно же, означали, что я использовал юлианский календарь, а не григорианский.
Это происходило в то время, когда до восхода структурного программирования ещё было далеко. Не будучи гением, я не размышлял о всяких там функциях с параметрами, поэтому делал то, что в то время делал бы любой другой, — использовал бесчисленное множество инструкций перехода goto. Сначала я вычислил положение текущего года в 28-летнем цикле, а затем сделал переход к довольно массивному блоку, вычисляющему рабочие дни для годов данной категории. Таким образом, у меня в программе присутствовало 28 почти идентичных блоков кода. Если я находил ошибку в одном месте, то мне приходилось исправлять её 28 раз. В настоящее время аналогичную операцию можно было бы реализовать на Python в виде одной функции, занимающей всего десяток строк кода, заменив все те тысячи строк неимоверно многословного языка COBOL. Моя программа работала, но до проблемы 2000 года не дожила. Прогресс в компьютерной технике очень скоро сделал её ненужной.
Комбинация из инструкций goto, нескольких строк кода и другой goto, которая осуществляет переход назад на строку, следующую за исходной goto, когда-то имела особое название — подпрограмма. Если взглянуть на код ассемблера, производимый современными трансляторами, то можно заметить огромное сходство между кодом, сгенерированным для реализации какой-нибудь функции, и логическим построением подпрограммы, которые мы обычно использовали в те времена. Да, это верно, что по сути своей функции являются всего лишь только красивой оберткой, за которой скрывается старая фундаментальная конструкция — инструкция goto, код подпрограммы и другая инструкция goto. Но именно эта блестящая обёртка позволяет нам мыслить более логично и предельно упрощать код программ. А как мы помним из главы 1, структура языка определяет ход мышления. И эта закономерность особенно ярко проявляется в языках программирования.
Давайте рассмотрим очень маленькую функцию, с элементами которой Вы уже встречались прежде. В листинге 7.1 показано, как выполняется определение функции в Python. Где-то мы такое уже видели, не так ли?
Листинг 7.1. Определение функции
def julian_leap(y):
if (y%4) == 0:
return 1
return 0
Ключевое слово def является инструкцией определения функции. За ним следует произвольное имя функции, круглые скобки, в которых содержится список параметров, и завершает строку двоеточие. Тело функции выделяется отступом от строки, содержащей def. Имена, заключённые между круглыми скобками, являются аргументами функции или параметрами, и для них можно использовать произвольные имена. Они являются всего лишь только удобными идентификаторами, указывающими, какую именно информацию следует передавать функции. Область видимости аргументов ограничена пределами тела функции. Что это означает? Например, в нашем случае для функции была создана временная переменная под именем у. Эта переменная существует только внутри этой функции. Переменные с таким же именем можно использовать в любой другой части кода, даже если перед этим уже происходил вызов функции julian_leap().
В листинге 7.2 показано, как можно использовать функцию, созданную в предыдущем примере.
Листинг 7.2. Пример вызова функции
year = 1999
if julian_leap(year):
print year, "is leap"
else:
print year, "is not leap"
Теперь Вы можете убедиться, что если заменить, вызов функции инструкцией goto (правда, в этом случае это уже был бы не Python), а также ввести инструкции возврата с другой инструкцией goto, то мы получим обычную подпрограмму. Инструкцию return можно рассматривать как своего рода команду "вернуться обратно". Компилятор или интерпретатор фиксирует место, из которого вызывается функция, поэтому инструкция return означает просто "перейти в то место программы, которое следует непосредственно за вызовом функции". Вообще-то на низком уровне (уровне команд процессора) все конструкции управления ходом выполнения программ, которые мы уже изучили, являются всего лишь только наборами команд проверки исходных адресов и переходов. Даже цикл for транслируется интерпретатором Python в набор команд goto, сгруппированных вместе с командами проверки текущих значений переменных, контролирующих окончание списка входных данных. Но насколько логичнее становится код программы, когда вместо бесконечных скачков, переходов и проверок в ней появляются простые и удобочитаемые инструкции if, for, while, а также функции.
Наша функция julian_leap() ограничена использованием юлианского календаря, так как в ней предполагается, что високосным является каждый четвёртый год. Несложно изменить эту функцию для приведения в соответствие с григорианским календарём. В листинге 7.3 демонстрируется этот код.
Листинг 7.3. Функция определения високосного года по григорианскому календарю
def gregorian_leap(y):
if (y%400) == 0:
return 1
elif (y%100) == 0:
return 0
elif (y%4) == 0:
return 1
return 0
Все это Вы уже видели прежде, но теперь код упакован в отдельную функцию. В листинге 7.4 показан вызов обеих функций.
Листинг 7.4. Вызов функций определения високосного года по юлианскому и григорианскому календарям
years = [1999,2000,2001,1900]
for x in years :
if julian_leap(x):
print "Julian", x, "is leap"
else:
print "Julian", x, "is not leap"
if gregorian_leap(x):
print "Gregorian", x, "is leap"
else:
print "Gregorian", x, "is not leap"
Переменная years содержит список годов (имеется в виду не просто список, а такой тип данных, о котором, я надеюсь, Вы ещё помните), представленных целыми числами. Цикл for перебирает все элементы этого списка и выполняет для каждого значения года обе функции julian_leap() и gregorian_leap(), после чего на экран выводятся результаты их выполнения.
Python допускает назначение аргументам функции значений, задаваемых по умолчанию. Делается это очень просто, гораздо проще, чем в других языках программирования. Заданные по умолчанию значения аргумента используются в том случае, если при вызове функции соответствующий аргумент не был определён. Давайте попробуем изменить функцию julian_leap() таким образом, чтобы предоставить ей значение по умолчанию, как показано в листинге 7.5.
Листинг 7.5. Аргументы, заданные по умолчанию
def julian_leap(y=2000):
if (y%4) == 0:
return 1
return 0
Обратите внимание, что всё, что нам необходимо было сделать, — это присвоить аргументу у некоторое значение в определении функции. Если во время вызова функции не будет передан аргумент, то переменная у примет присвоенное ей по умолчанию значение 2000. Но если пользователь всё-таки сподобится снабдить вызов функции аргументом (в нашем случае — значением года), то переменной у будет присвоено именно это значение. Все предельно просто, не так ли? Можете проверить все вышесказанное, выполнив код, показанный в листинге 7.6.
Листинг 7.6. Вызов функции, в которой задан аргумент по умолчанию
if julian_leap():
print "Julian 2000 yes"
В листинге 7.7 используются те же функции, которые мы обсуждали до этого, но теперь код программы помещен в отдельный файл. Воспользуйтесь своим текстовым редактором, чтобы набрать эти строки, и сохраните их в файле под именем lеар2.ру.
Листинг 7.7. Файл lеар2.ру
#!с:\python\python.exe
import sys
import string
def julian_leap(y=2000):
if (y%4) == 0:
return 1
return 0
def gregorian_leap(y=2000):
if (y%400) == 0:
return 1
elif (y%100) == 0:
return 0
elif (y%4) == 0:
return 1
return 0
years = [1999,2000,2001,1900]
print julian_leap()
print gregorian_leap()
if julian_leap():
print "Julian 2000 yes"
if gregorian_leap():
print "Gregorian 2000 yes"
for x in years:
if julian_leap(x):
print "Julian", x, "is leap"
else:
print "Julian", x, "is not leap"
if gregorian_leap(x):
print "Gregorian", x, "is leap"
else:
print "Gregorian", x, "is not leap"
Если после того как Вы сохранили текст предыдущей программы в файле под именем lеар2.ру, ввести в командной строке python 1еар2.ру, то Вы должны увидеть результаты, аналогичные приведенным в листинге 7.8.
с:\python\python.exe leap2.py
Julian 2000 yes
Gregorian 2000 yes
Julian 1999 is not leap
Gregorian 1999 is not leap
Julian 2000 is leap
Gregorian 2000 is leap
Julian 2001 is not leap
Gregorian 2001 is not leap
Julian 1900 is leap
Gregorian 1900 is not leap
C:\>
С аргументами функций можно проделывать множество причудливых фокусов, но, вообще говоря, в большинстве случаев Вам вряд ли понадобятся подобные уловки. Когда Вы приобретёте некоторый опыт и реализуете несколько более-менее сложных задач, то будете способны принимать более изящные решения в вопросах передачи аргументов. К тому же, очень многое на эту тему можно почерпнуть либо из других книг, либо из официальной документации, которую можно загрузить вместе с установочной программой Python. Сейчас Вы уже обладаёте достаточными знаниями о функциях, чтобы на 90% удовлетворить свои потребности в программировании. Поэтому давайте перейдем к следующей теме — модулям.
Всякий раз, когда в предыдущих программах мы использовали выражение import модуль или from модуль import *, в программу добавлялся соответствующий модуль. Под модулем следует понимать файл. Имя этого файла должно заканчиваться стандартным для Python расширением .ру. Вспомните особенности уже известных Вам приёмов импортирования. Если модуль импортируется инструкцией import модуль, необходимо перед именем каждой функции этого модуля устанавливать идентификатор — имя самого модуля. Если же используется инструкция from модуль import *, то все функции модуля становятся частью программы, но тогда могут возникнуть конфликты имён с одноимёнными функциями, которые были определены в самой программе или в других импортированных модулях. (Помните, что произошло с модулями math и cmath в главе 5.) Инструкция импорта требует указания имени файла модуля, но у программы "поедет крыша", если Вы ещё укажете и расширение .ру.
*Прим. В. Шипкова: ко всему сказанному добавлю от себя - имя модуля НЕ ДОЛЖНО начинаться с цифры, хотя файл, так может вполне обзываться. Питон будет усиленно ругаться, и это вполне логично - имя модуля Питон рассматривает как переменную, а переменная не может начинаться с цифры.
Прежде чем Вы сможете создать свой собственный модуль функций, что позволит многократно использовать эти функции в разных программах, необходимо познакомиться с одной идиомой Python. На самом деле Вы уже сталкивались с ней прежде, но мы не обсуждали эту особенность. Каждая выполняемая программа в Python имеет своё имя. Даже когда Вы выполняете программу путём ввода её команд в окне интерпретатора (т.е. в диалоговом режиме), программа имеет имя "__main__". Если же программа выполняется в диалоговом режиме, но в окне IDLE, то она носит имя "__console__".
*Прим. В. Шипкова: в Python 2.4.1
имя программы также "__main__"
Это отличие может показаться несколько странным, но в действительности Вам редко придётся сталкиваться с этими именами, поскольку они создаются в Python автоматически. Можно узнать текущее имя выполняемой программы. Для этого следует вывести на экран содержимое встроенной переменной __name__(о встроенных переменных мы поговорим подробнее в главе 11).
В большинстве случаев выводимое значение будет __main__. Обратите внимание, что __name__ не является именем модуля или другого файла.
Откройте свой излюбленный текстовый редактор и введите код, показанный в листинге 7.9, после чего сохраните свою работу в файле под именем name.py.
Листинг 7.9. Программа name.py
#! с: \python\python.exe
import lеар2
print __name__
Удостоверьтесь в том, что эта программа находится в том же самом каталоге, в котором Вы сохранили lеар2.ру, а затем запустите её обычным способом — вводом команды python name.py. Ожидаемый результат показан в листинге 7.10.
Листинг 7.10. Результаты выполнения программы name.py
С:\Руthon>python name.ру
Julian 2000 yes
Gregorian 2000 yes
Julian 1999 is not leap
Gregorian 1999 is not leap
Julian 2000 is leap
Gregorian 2000 is leap
Julian 2001 is not leap
Gregorian 2001 is not leap
Julian 1900 is leap
Gregorian 1900 is not leap
__main__
Что произошло? Дело в том, что когда Python выполнил инструкцию импорта, он также выполнил и весь код, заключенный внутри модуля lеар2. Если изменить файл lеар2.ру, включив в него (как показано в листинге 7.11) проверку имени программы (убедитесь только, что должным образом установлен отступ строк, следующих за инструкцией if), то тем самым Вы сможете предотвратить нежелательное выполнение модуля.
Листинг 7.11. Проверка имени, добавленного в файл lеар2.ру
if __name__ == "__main__":
years = [1999,2000,2001,1900]
............
Импортированные модули тоже имеют свою переменную __name__, которой присваивается имя файла. Так, в модуле lеар2, который хранится в файле lеар2.ру, имеется переменная __name__, значение которой установлено в "lеар2". Но если запустить файл lеар2 на выполнение самостоятельно, а не как модуль, то в переменной __name__ будет сохранено имя "__main__". Обычно имя модуля, присвоенное переменной __name__, мало кого интересует. Уж если Dы смогли импортировать модуль, то наверняка знаете его имя. Но проверка соответствия переменной __name__ имени "__main__" имеет свой смысл. Это позволяет нам отменять автоматическое выполнение программы, если она загружается как модуль в другую программу. Проверьте это ещё раз, выполнив измененный файл lеар2.ру, в котором Вы добавили проверку имени модуля. Результат должен получиться тот же самый, что и в первый раз. Кроме того, теперь Вы можете использовать функции определения високосного года в любой программе, в которую импортируете модуль lеар2. Причем программа самого модуля выполняться не будет. Так, если теперь Вы выполните программу name.py, на экране появится только имя текущего модуля __main__.
Чтобы позволить модулю __main__ взаимодействовать с пользователями, необходимо снабдить его возможностью считывать параметры командной строки, которые вводит пользователь при запуске программы на исполнение. Для этого в основной модуль программы необходимо добавить строку import sys. Всякий раз, когда программа будет запущена на выполнение, интерпретатор Python будет собирать все параметры командной строки и помещать их в специальный список argv в модуле sys.
Кстати, имя __main__ также пришло из языка С. Программы на этом языке всегда имеют главную функцию с именем main(), с которой начинается их выполнение. В Python, как и в С, самому первому элементу вектора аргументов argv[0] всегда присваивается имя программы.
*Прим. В. Шипкова: вообще Python это термоядерная смесь приличного количества языков.
Поскольку argv является списком, обратиться к нему очень просто. С помощью встроенной функции lеn() можно сначала выяснить, сколько параметров ввёл пользователь: l=len(sys.argv)
Как было указано в приведённом выше примечании, первый элемент списка argv[0] всегда содержит имя программы (имя файла, которое мы вводим при запуске программы). Это полезное свойство, так как в диалоговых окнах, экранных примечаниях и сообщениях об ошибках легко можно выводить имя программы, обратившись к sys.argv[0], вместо того чтобы жёстко вводить имя в код сообщений. Если размер списка sys.argv равен единице, это значит, что пользователь не вводил никакие параметры. Можно управлять выполнением программы в зависимости от того, ввёл ли пользователь свои параметры или нет. В листинге 7.12 вновь показана программа name.py, изменённая таким образом, чтобы учитывать ввод пользователем аргументов в командной строке.
Листинг 7.12. Измененная программа name.py
#!с:\python\python.exe
import sys
import string
import leap2
if __name__=="__main__":
if len(sys.argv) < 2:
print "Usage:", sys.argv[0], "year year year..."
sys.exit(l)
else:
for i in sys.argv[1:]:
y=string.atoi(i)
j=leap2.julian_leap(y)
g=leap2.gregorian_leap(y)
if j!=0:
print i, "is leap in the Julian calendar."
else:
print i, "is not leap in the Julian calendar."
if g!=0:
print i, "is leap in the Gregorian calendar."
else:
print i, "is not leap in the Gregorian calendar."
*Прим. В. Шипкова: как-то раз со мной приключилась неприятная штука - перестала передаваться строка параметров. Как оказалось в последствии, это испортила настройки одна из программ-пакетов для Python. Эту беду удалось победить путём простой переустановки Питона.
Выполнение программы name.py без указания аргументов должно закончиться выводом результата, показанного в листинге 7.13 (на компьютере с UNIX результат может незначительно отличаться).
Листинг 7.13. Результат выполнения измененной программы name.py
С: \Руthon>python name.ру
Usage: name.py year year year...
C:\Python>
Программа выводит строку Usage: name.py year year year... (Использование: год год год...), в которой объясняет пользователю, как её следует использовать. Чтобы определить високосный год, пользователь должен ввести его как аргумент в командной строке. Можно также ввести сразу несколько значений, разделяя их пробелами. Результат выполнения программы в случае ввода в строке с аргументом значения 1900 будет выглядеть так, как показано в листинге 7.14.
Листинг 7.14. Результат выполнения программы name.py с введенным аргументом
C:\Python>python name.py 1900
1900 is leap in the Julian calendar.
1900 is not leap in the Gregorian calendar.
C:\Python>
Теперь Вы имеете программу, которая сообщит Вам, является ли любой интересуемый год високосным в обоих календарях (юлианском и григорианском). Имеет смысл теперь переименовать её, например в ly.py, поскольку имя name.py больше не соответствует сути программы. Значение года, вводимое в списке аргументов командной строки, может быть представлено любым целым числом, естественно, с учётом ограничений, присущих этому типу данных. Так, значения не могут быть больше, чем sys.maxint, или меньше, чем -(sys.maxint-1). В следующей главе при рассмотрении использования исключений я покажу Вам, как можно предотвратить подобные ошибки в ходе выполнения программы.
А как определить, был ли високосным какой-либо год до нашей эры? Вопрос о том, как вычислять даты, предшествующие времени ввода календаря в употребление, действительно интересен как в прикладном, так и в философском плане. Поскольку григорианский календарь впервые стал использоваться с 1582 г., а датой введения юлианского календаря считается 707 A.U.C. (ab urbe condita — "от основания города"; городом, конечно же, является Рим), можно было бы весьма обоснованно принять решение, что лишено всякого смысла использовать любой из этих календарей для времени, предшествующего соответствующим датам их введения. Тем не менее у астрономов, археологов, богословов, студентов и других заинтересованных лиц часто возникает потребность выстроить хронологию событий, происходящих за долго до появления современного календаря, и сопоставить эти события с нашим временем. Обычно в таких случаях годы нумеруются в обратном порядке. Термин "до Рождества Христова" будет звучать несколько противоречиво, если Вы попытаетесь датировать события, происходившие, к примеру, в жизни Иосифа и Марии. Поэтому многие предпочитают более нейтральный термин "до нашей эры", или сокращенно — до н.э. Спорным остаётся вопрос, какой год считать первым годом нашей эры, тот, в который произошло Рождество Христово, или следующий за ним. Астрономы считают год Рождества Христова нулевым, следующий за ним — первым, а предшествующий -минус первым. В системе, использующей обозначение B.C., год, предшествующий первому году нашей эры (A.D.), является 1-м годом B.C., тогда как в обычной предваряющей (proleptic) системе годом, предшествующим 1-му году С.Е., является нулевой год (0), а годом, предшествующим ему, является —1. С позиции математики такой подход имеет глубокий практический смысл. (Кстати, если признать, что существует год 0, то новое тысячелетие действительно наступило 1 января 2000 года, хотя многие с удовольствием отметили приход нового тысячелетия дважды.) Обратите внимание, что программа ly.py также прекрасно работает и с отрицательными годами.
В этой главе мы рассмотрели функции и модули, а именно: определение собственных функций, создание собственных модулей, проверку имени модуля использование аргументов командной строки. В следующей главе мы познакомимся со всякими мелочами, которые, тем не менее, приятно скрашивают жизнь программиста.
Почему именно def? Почему не define?
Как и все остальные программисты, Гуидо не любит набирать на клавиатуре лишние символы.
Имеется ли где-нибудь реальная необходимость в применении инструкции goto и функции long_jmp?
Только не в хорошо продуманном языке. Тем не менее даже в самом С, который многие считают вершиной современного программирования, иногда встречаются инструкции goto, которые действительно делают код более ясным и понятным. Можно сказать, что без них он утратил бы свою читабельность. Применения функции long_jmp требуют некоторые утилиты, написанные также на языке С, особенно утилиты оболочки и интерпретаторы команд.
Прежде я уже слышал об ассемблере. Что это такое? Придется ли мне когда-нибудь изучать его?
Поскольку ассемблер на одну ступеньку выше реального машинного языка, он не использует компилятор. Вместо него он использует транслятор. Это объясняется тем, что буквенные коды, используемые в ассемблере, не требуют вызова большого количества других функций, а просто являются мнемоническими обозначениями, соответствующими конкретным двоичным комбинациям, которые как раз и поддаются трансляции непосредственно компьютером. Знание ассемблера может понадобиться только в том случае, если Вы планируете писать быстродействующие программы, выполняющиеся в режиме реального времени, например высокоскоростные игры, или если Вы захотите писать программы, которые использовались бы в космических проектах. Загляните на Web-страницу по адресу http://www.s-direktnet.de/homepages/neumann/sprachen.htm и найдите там пример программы "Hello, World!", написанной на ассемблере. Вы сразу поймете, что она написана не на Python.
Как в Python определяется функция?
а) defun имя( аргументы)(тело)
б) def имя( аргументы):
тело
в) имя( аргументы){тело}
г) Любой из вышеперечисленных способов.
Если Юлий Цезарь сделал так, что начиная с 46 года до н.э. каждый человек в Римской империи пользовался его календарем, то какой год соответствует основанию Рима?
а) 707 год до н.э.
б) 753 год нашей эры.
в) 753 до н.э.
г) 0-й год
Как выполняется проверка имени модуля?
а) В модуле проверяется соответствие значения переменной __name__ имени модуля, после чего выполняется код модуля.
б) В модуле проверяется, не является ли "__main__" значением переменной __name__, и если является, выполнять код модуля.
в) Проверка соответствия переменной __name__ значению __main__ выполняется не в модуле, а в основной программе.
г) Не стоит об этом беспокоиться.
б. В Python для определения функции используется синтаксис: def имя(аргумента): тело.
в. Годом основания Рима считается 753 год до н.э., или 752-й год по григорианскому календарю.
б. Если переменная __name__ имеет значение "__main__", то выполняется код модуля. Проверку имени модуля нужно выполнять обязательно во всех модулях.
Чтобы получить дополнительную информацию о календарях, посетите Web-страницу по адресу http://www.calendarzone.com/. Обширный перечень часто задаваемых вопросов (и ответов на них) по теме летоисчисления в разных календарях можно найти на Web-странице, которая находится по адресу http://www.pauahtun.org/CalendarFAQ/; её редактором является Клаус Тондерлинг (Claus Tenderling).
Дополнительную информацию об утилитах оболочки UNIX, в которых используется функция long_jmp, можно найти в книге Марка Дж. Рочкинда (Marc J. Rochkind) Advanced UNIX Programming, Prentice-Hall. Но для изучения материала этой книги потребуется хорошее знание языка С. Зато потом Вы сможете создавать свои собственные пользовательские оболочки для UNIX.
