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

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

0:00:07.000,0:00:11.000
свой собственный беспилотный автомобиль, но главная проблема в том,

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

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

0:00:17.000,0:00:19.000
у нас не будет веской причины для радости.

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

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

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

0:00:32.000,0:00:36.000
открывающая скобка и список <входных данных>.

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

0:00:40.000,0:00:42.000
тем, что ожидает процедура.

0:00:42.000,0:00:44.000
Эти входные данные иногда называются «операндами».

0:00:44.000,0:00:46.000
А иногда – «аргументами».

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

0:00:48.000,0:00:50.000
Мы просто будем называть их входными данными.

0:00:50.000,0:00:52.000
Вообще-то вы уже использовали похожую запись.

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

0:00:57.000,0:00:59.000
В find() передаются один или два входа.

0:00:59.000,0:01:01.000
Первый – это строка.

0:01:01.000,0:01:04.000
Строка, которую вы ищете – это первый параметр,

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

0:01:07.000,0:01:09.000
поиск данной строки.

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

0:01:13.000,0:01:15.000
выполняя домашнюю работу.

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

0:01:17.000,0:01:19.000
Во-первых, он встроен в язык.

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

0:01:22.000,0:01:25.000
еще один вход – вот этот.

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

0:01:31.000,0:01:34.000
переменная page – которая по сути является просто еще одним входом.

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

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

0:01:41.000,0:01:43.000
а остальные два – вот здесь.

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

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

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

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

0:01:56.000,0:02:00.000
Есть только сама процедура и ее аргументы, или операнды, или входы –

0:02:00.000,0:02:03.000
как вам больше нравится – которые передаются в нее.

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

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

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

0:02:13.000,0:02:16.000
его значению через имя s.

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

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

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

0:02:31.000,0:02:33.000
от позиции 1 до конца строки.

0:02:33.000,0:02:35.000
Вот их мы и вернем.

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

0:02:39.000,0:02:42.000
со второй буквы входной строки.

0:02:42.000,0:02:45.000
Вот пример использования этой процедуры.

0:02:45.000,0:02:47.000
Мы можем вызвать ее напрямую.

0:02:47.000,0:02:51.000
Мы можем написать print rest_of_string.

0:02:51.000,0:02:53.000
Это наша процедура.

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

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

0:02:59.000,0:03:02.000
одно значение, и оно должно быть строкой.

0:03:02.000,0:03:05.000
Мы передадим в процедуру строку 'audacity'.

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

0:03:07.813,0:03:10.000
к телу процедуры.

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

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

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

0:03:21.000,0:03:26.000
Он присвоит параметрам поданные на вход значения.

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

0:03:30.000,0:03:31.974
переданное в процедуру входное значение.

0:03:31.974,0:03:36.000
Теперь нам нужно выполнить тело процедуры.

0:03:36.000,0:03:39.000
В данном случае оно состоит из одной команды – вот этой команды return.

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

0:03:43.000,0:03:47.000
Оно будет равно строке 'udacity'.

0:03:47.000,0:03:49.000
Теперь перехойдем к команде return.

0:03:49.000,0:03:51.000
return означает, что мы переходим обратно.

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

0:03:56.000,0:03:58.000
с его результатом.

0:03:58.000,0:04:03.000
Когда мы переходим обратно, значение вызова становится равным значению,

0:04:03.000,0:04:04.000
которое мы вернули.

0:04:04.000,0:04:07.000
В данном случае это строка 'udacity'.

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

0:04:08.556,0:04:10.867
но теперь вы умеете определять и использовать процедуры.

0:04:10.867,0:04:12.745
Это очень мощная концепция.

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

0:04:14.993,0:04:18.529
практически любого компьютерного программиста сводится к определению

0:04:18.529,0:04:20.697
процедур и их использованию.

0:04:20.697,0:04:22.778
А теперь у нас должна появиться широкая улыбка.

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

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

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

0:04:33.065,0:04:35.689
рот – наверное, даже через нос.

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

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

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