К сожалению, у нас пока нет особых поводов для радости.

Себастьян говорит, что пройдет еще несколько лет, прежде чем у меня появится

свой собственный беспилотный автомобиль, но главная проблема в том,

что мы еще не поговорили о том, как использовать процедуры.

Мы всего лишь научились создавать их; пока мы не сможем их использовать,

у нас не будет веской причины для радости.

Мы вскоре научимся ими пользоваться и снова сможем широченно улыбаться.

А сейчас мы собственно и узнаем, как использовать процедуру.

Для этого нам понадобится <имя процедуры>, за которым следует

открывающая скобка и список <входных данных>.

В принципе их может быть сколько угодно, но их количество должно совпадать с

тем, что ожидает процедура.

Эти входные данные иногда называются «операндами».

А иногда – «аргументами».

Мы не будем спорить, что правильнее.

Мы просто будем называть их входными данными.

Вообще-то вы уже использовали похожую запись.

Еще в разделе 1 вы узнали, как использовать метод find() строковых переменных.

В find() передаются один или два входа.

Первый – это строка.

Строка, которую вы ищете – это первый параметр,

а необязательный второй – это целое число, позиция, с которой нужно начать

поиск данной строки.

В лекциях раздела 1 мы нашли множество применений методу find(), а вы закрепили эти знания,

выполняя домашнюю работу.

find() слегка отличается от процедур, которые вы определяете самостоятельно.

Во-первых, он встроен в язык.

Во-вторых, помимо уже упомянутых, у нас есть

еще один вход – вот этот.

У нас есть строка, в которой мы осуществляем поиск – к примеру,

переменная page – которая по сути является просто еще одним входом.

Позже мы поговорим о том, чем отличается такая запись, но в целом она

очень похожа на вызов процедуры, у которой один параметр находится здесь,

а остальные два – вот здесь.

Есть и отличия, но в этом разделе мы не будем на них останавливаться,

однако в дальнейшем вы узнаете, что на самом деле происходит при вызове метода.

У процедур, которые вы объявляете самостоятельно, нет

объекта, от имени которого они вызываются.

Есть только сама процедура и ее аргументы, или операнды, или входы –

как вам больше нравится – которые передаются в нее.

Посмотрим, как это работает, на примере простой процедуры.

Я определю процедуру rest_of_string(), и мы снабдим ее

параметром s; это значит, что у нее один вход и мы будем обращаться к

его значению через имя s.

Мы заставим ее возвращать все символы строки от первой [не нулевой!] позиции до ее конца.

Для этого мы будем использовать оператор индексации строк – return s[1:].

Это даст нам ту же строку без первой буквы, то есть все символы

от позиции 1 до конца строки.

Вот их мы и вернем.

Итак, на выходе rest_of_string() будет новая строка, начинающаяся

со второй буквы входной строки.

Вот пример использования этой процедуры.

Мы можем вызвать ее напрямую.

Мы можем написать print rest_of_string.

Это наша процедура.

Теперь нужно поставить открывающую скобку и передать в нее входное значение.

У rest_of_string() один параметр, так что нам понадобится передать в нее

одно значение, и оно должно быть строкой.

Мы передадим в процедуру строку 'audacity'.

Когда мы вызываем процедуру, контроль переходит

к телу процедуры.

Мы можем представить, что сейчас делает интерпретатор.

Вместо выполнения кода, интерпретатор сделает переход.

Когда мы вызовем процедуру, он перейдет к выполнению кода внутри нее.

Он присвоит параметрам поданные на вход значения.

Мы можем представить это как операцию присваивания, которая присваивает s

переданное в процедуру входное значение.

Теперь нам нужно выполнить тело процедуры.

В данном случае оно состоит из одной команды – вот этой команды return.

Нам нужно вычислить это значение, s[1:].

Оно будет равно строке 'udacity'.

Теперь перехойдем к команде return.

return означает, что мы переходим обратно.

Мы возвращаемся к месту вызова процедуры, но уже

с его результатом.

Когда мы переходим обратно, значение вызова становится равным значению,

которое мы вернули.

В данном случае это строка 'udacity'.

Итак, у нас пока нет собственной машины-беспилотника,

но теперь вы умеете определять и использовать процедуры.

Это очень мощная концепция.

Все, чем мы будем заниматься в рамках этого курса, как и деятельность

практически любого компьютерного программиста сводится к определению

процедур и их использованию.

А теперь у нас должна появиться широкая улыбка.

Мы можем думать о процедурах как о коде, преобразующем входные данные в выходные.

Мы также можем думать о людях как о существах, занимающихся тем же самым.

У нас есть входные значения, поступающие через глаза, через

рот – наверное, даже через нос.

Я не буду пытаться изобразить выходные данные человека-процедуры, но раз уж

процедуры играют настолько важную роль, мы посвятим им несколько

следующих заданий, чтобы убедиться, что вы хорошо их понимаете.