WEBVTT 00:00:00.000 --> 00:00:04.000 К сожалению, у нас пока нет особых поводов для радости. 00:00:04.000 --> 00:00:07.000 Себастьян говорит, что пройдет еще несколько лет, прежде чем у меня появится 00:00:07.000 --> 00:00:11.000 свой собственный беспилотный автомобиль, но главная проблема в том, 00:00:11.000 --> 00:00:13.000 что мы еще не поговорили о том, как использовать процедуры. 00:00:13.000 --> 00:00:17.000 Мы всего лишь научились создавать их; пока мы не сможем их использовать, 00:00:17.000 --> 00:00:19.000 у нас не будет веской причины для радости. 00:00:19.000 --> 00:00:22.000 Мы вскоре научимся ими пользоваться и снова сможем широченно улыбаться. 00:00:22.000 --> 00:00:25.000 А сейчас мы собственно и узнаем, как использовать процедуру. 00:00:25.000 --> 00:00:32.000 Для этого нам понадобится <имя процедуры>, за которым следует 00:00:32.000 --> 00:00:36.000 открывающая скобка и список <входных данных>. 00:00:36.000 --> 00:00:40.000 В принципе их может быть сколько угодно, но их количество должно совпадать с 00:00:40.000 --> 00:00:42.000 тем, что ожидает процедура. 00:00:42.000 --> 00:00:44.000 Эти входные данные иногда называются «операндами». 00:00:44.000 --> 00:00:46.000 А иногда – «аргументами». 00:00:46.000 --> 00:00:48.000 Мы не будем спорить, что правильнее. 00:00:48.000 --> 00:00:50.000 Мы просто будем называть их входными данными. 00:00:50.000 --> 00:00:52.000 Вообще-то вы уже использовали похожую запись. 00:00:52.000 --> 00:00:57.000 Еще в разделе 1 вы узнали, как использовать метод find() строковых переменных. 00:00:57.000 --> 00:00:59.000 В find() передаются один или два входа. 00:00:59.000 --> 00:01:01.000 Первый – это строка. 00:01:01.000 --> 00:01:04.000 Строка, которую вы ищете – это первый параметр, 00:01:04.000 --> 00:01:07.000 а необязательный второй – это целое число, позиция, с которой нужно начать 00:01:07.000 --> 00:01:09.000 поиск данной строки. 00:01:09.000 --> 00:01:13.000 В лекциях раздела 1 мы нашли множество применений методу find(), а вы закрепили эти знания, 00:01:13.000 --> 00:01:15.000 выполняя домашнюю работу. 00:01:15.000 --> 00:01:17.000 find() слегка отличается от процедур, которые вы определяете самостоятельно. 00:01:17.000 --> 00:01:19.000 Во-первых, он встроен в язык. 00:01:19.000 --> 00:01:22.000 Во-вторых, помимо уже упомянутых, у нас есть 00:01:22.000 --> 00:01:25.000 еще один вход – вот этот. 00:01:25.000 --> 00:01:31.000 У нас есть строка, в которой мы осуществляем поиск – к примеру, 00:01:31.000 --> 00:01:34.000 переменная page – которая по сути является просто еще одним входом. 00:01:34.000 --> 00:01:38.000 Позже мы поговорим о том, чем отличается такая запись, но в целом она 00:01:38.000 --> 00:01:41.000 очень похожа на вызов процедуры, у которой один параметр находится здесь, 00:01:41.000 --> 00:01:43.000 а остальные два – вот здесь. 00:01:43.000 --> 00:01:46.000 Есть и отличия, но в этом разделе мы не будем на них останавливаться, 00:01:46.000 --> 00:01:50.000 однако в дальнейшем вы узнаете, что на самом деле происходит при вызове метода. 00:01:50.000 --> 00:01:55.000 У процедур, которые вы объявляете самостоятельно, нет 00:01:55.000 --> 00:01:56.000 объекта, от имени которого они вызываются. 00:01:56.000 --> 00:02:00.000 Есть только сама процедура и ее аргументы, или операнды, или входы – 00:02:00.000 --> 00:02:03.000 как вам больше нравится – которые передаются в нее. 00:02:03.000 --> 00:02:06.000 Посмотрим, как это работает, на примере простой процедуры. 00:02:06.000 --> 00:02:10.000 Я определю процедуру rest_of_string(), и мы снабдим ее 00:02:10.000 --> 00:02:13.000 параметром s; это значит, что у нее один вход и мы будем обращаться к 00:02:13.000 --> 00:02:16.000 его значению через имя s. 00:02:16.000 --> 00:02:21.000 Мы заставим ее возвращать все символы строки от первой [не нулевой!] позиции до ее конца. 00:02:21.000 --> 00:02:25.000 Для этого мы будем использовать оператор индексации строк – return s[1:]. 00:02:25.000 --> 00:02:31.000 Это даст нам ту же строку без первой буквы, то есть все символы 00:02:31.000 --> 00:02:33.000 от позиции 1 до конца строки. 00:02:33.000 --> 00:02:35.000 Вот их мы и вернем. 00:02:35.000 --> 00:02:39.000 Итак, на выходе rest_of_string() будет новая строка, начинающаяся 00:02:39.000 --> 00:02:42.000 со второй буквы входной строки. 00:02:42.000 --> 00:02:45.000 Вот пример использования этой процедуры. 00:02:45.000 --> 00:02:47.000 Мы можем вызвать ее напрямую. 00:02:47.000 --> 00:02:51.000 Мы можем написать print rest_of_string. 00:02:51.000 --> 00:02:53.000 Это наша процедура. 00:02:53.000 --> 00:02:56.000 Теперь нужно поставить открывающую скобку и передать в нее входное значение. 00:02:56.000 --> 00:02:59.000 У rest_of_string() один параметр, так что нам понадобится передать в нее 00:02:59.000 --> 00:03:02.000 одно значение, и оно должно быть строкой. 00:03:02.000 --> 00:03:05.000 Мы передадим в процедуру строку 'audacity'. 00:03:05.000 --> 00:03:07.813 Когда мы вызываем процедуру, контроль переходит 00:03:07.813 --> 00:03:10.000 к телу процедуры. 00:03:10.000 --> 00:03:10.566 Мы можем представить, что сейчас делает интерпретатор. 00:03:10.566 --> 00:03:17.000 Вместо выполнения кода, интерпретатор сделает переход. 00:03:17.000 --> 00:03:21.000 Когда мы вызовем процедуру, он перейдет к выполнению кода внутри нее. 00:03:21.000 --> 00:03:26.000 Он присвоит параметрам поданные на вход значения. 00:03:26.000 --> 00:03:30.000 Мы можем представить это как операцию присваивания, которая присваивает s 00:03:30.000 --> 00:03:31.974 переданное в процедуру входное значение. 00:03:31.974 --> 00:03:36.000 Теперь нам нужно выполнить тело процедуры. 00:03:36.000 --> 00:03:39.000 В данном случае оно состоит из одной команды – вот этой команды return. 00:03:39.000 --> 00:03:43.000 Нам нужно вычислить это значение, s[1:]. 00:03:43.000 --> 00:03:47.000 Оно будет равно строке 'udacity'. 00:03:47.000 --> 00:03:49.000 Теперь перехойдем к команде return. 00:03:49.000 --> 00:03:51.000 return означает, что мы переходим обратно. 00:03:51.000 --> 00:03:56.000 Мы возвращаемся к месту вызова процедуры, но уже 00:03:56.000 --> 00:03:58.000 с его результатом. 00:03:58.000 --> 00:04:03.000 Когда мы переходим обратно, значение вызова становится равным значению, 00:04:03.000 --> 00:04:04.000 которое мы вернули. 00:04:04.000 --> 00:04:07.000 В данном случае это строка 'udacity'. 00:04:07.050 --> 00:04:08.556 Итак, у нас пока нет собственной машины-беспилотника, 00:04:08.556 --> 00:04:10.867 но теперь вы умеете определять и использовать процедуры. 00:04:10.867 --> 00:04:12.745 Это очень мощная концепция. 00:04:12.902 --> 00:04:14.993 Все, чем мы будем заниматься в рамках этого курса, как и деятельность 00:04:14.993 --> 00:04:18.529 практически любого компьютерного программиста сводится к определению 00:04:18.529 --> 00:04:20.697 процедур и их использованию. 00:04:20.697 --> 00:04:22.778 А теперь у нас должна появиться широкая улыбка. 00:04:22.778 --> 00:04:26.777 Мы можем думать о процедурах как о коде, преобразующем входные данные в выходные. 00:04:26.777 --> 00:04:30.396 Мы также можем думать о людях как о существах, занимающихся тем же самым. 00:04:30.396 --> 00:04:33.065 У нас есть входные значения, поступающие через глаза, через 00:04:33.065 --> 00:04:35.689 рот – наверное, даже через нос. 00:04:35.689 --> 00:04:39.081 Я не буду пытаться изобразить выходные данные человека-процедуры, но раз уж 00:04:39.081 --> 00:04:41.495 процедуры играют настолько важную роль, мы посвятим им несколько 00:04:41.495 --> 00:04:44.495 следующих заданий, чтобы убедиться, что вы хорошо их понимаете.