1
00:00:00,000 --> 00:00:04,000
К сожалению, у нас пока нет особых поводов для радости.

2
00:00:04,000 --> 00:00:07,000
Себастьян говорит, что пройдет еще несколько лет, прежде чем у меня появится

3
00:00:07,000 --> 00:00:11,000
свой собственный беспилотный автомобиль, но главная проблема в том,

4
00:00:11,000 --> 00:00:13,000
что мы еще не поговорили о том, как использовать процедуры.

5
00:00:13,000 --> 00:00:17,000
Мы всего лишь научились создавать их; пока мы не сможем их использовать,

6
00:00:17,000 --> 00:00:19,000
у нас не будет веской причины для радости.

7
00:00:19,000 --> 00:00:22,000
Мы вскоре научимся ими пользоваться и снова сможем широченно улыбаться.

8
00:00:22,000 --> 00:00:25,000
А сейчас мы собственно и узнаем, как использовать процедуру.

9
00:00:25,000 --> 00:00:32,000
Для этого нам понадобится <имя процедуры>, за которым следует

10
00:00:32,000 --> 00:00:36,000
открывающая скобка и список <входных данных>.

11
00:00:36,000 --> 00:00:40,000
В принципе их может быть сколько угодно, но их количество должно совпадать с

12
00:00:40,000 --> 00:00:42,000
тем, что ожидает процедура.

13
00:00:42,000 --> 00:00:44,000
Эти входные данные иногда называются «операндами».

14
00:00:44,000 --> 00:00:46,000
А иногда – «аргументами».

15
00:00:46,000 --> 00:00:48,000
Мы не будем спорить, что правильнее.

16
00:00:48,000 --> 00:00:50,000
Мы просто будем называть их входными данными.

17
00:00:50,000 --> 00:00:52,000
Вообще-то вы уже использовали похожую запись.

18
00:00:52,000 --> 00:00:57,000
Еще в разделе 1 вы узнали, как использовать метод find() строковых переменных.

19
00:00:57,000 --> 00:00:59,000
В find() передаются один или два входа.

20
00:00:59,000 --> 00:01:01,000
Первый – это строка.

21
00:01:01,000 --> 00:01:04,000
Строка, которую вы ищете – это первый параметр,

22
00:01:04,000 --> 00:01:07,000
а необязательный второй – это целое число, позиция, с которой нужно начать

23
00:01:07,000 --> 00:01:09,000
поиск данной строки.

24
00:01:09,000 --> 00:01:13,000
В лекциях раздела 1 мы нашли множество применений методу find(), а вы закрепили эти знания,

25
00:01:13,000 --> 00:01:15,000
выполняя домашнюю работу.

26
00:01:15,000 --> 00:01:17,000
find() слегка отличается от процедур, которые вы определяете самостоятельно.

27
00:01:17,000 --> 00:01:19,000
Во-первых, он встроен в язык.

28
00:01:19,000 --> 00:01:22,000
Во-вторых, помимо уже упомянутых, у нас есть

29
00:01:22,000 --> 00:01:25,000
еще один вход – вот этот.

30
00:01:25,000 --> 00:01:31,000
У нас есть строка, в которой мы осуществляем поиск – к примеру,

31
00:01:31,000 --> 00:01:34,000
переменная page – которая по сути является просто еще одним входом.

32
00:01:34,000 --> 00:01:38,000
Позже мы поговорим о том, чем отличается такая запись, но в целом она

33
00:01:38,000 --> 00:01:41,000
очень похожа на вызов процедуры, у которой один параметр находится здесь,

34
00:01:41,000 --> 00:01:43,000
а остальные два – вот здесь.

35
00:01:43,000 --> 00:01:46,000
Есть и отличия, но в этом разделе мы не будем на них останавливаться,

36
00:01:46,000 --> 00:01:50,000
однако в дальнейшем вы узнаете, что на самом деле происходит при вызове метода.

37
00:01:50,000 --> 00:01:55,000
У процедур, которые вы объявляете самостоятельно, нет

38
00:01:55,000 --> 00:01:56,000
объекта, от имени которого они вызываются.

39
00:01:56,000 --> 00:02:00,000
Есть только сама процедура и ее аргументы, или операнды, или входы –

40
00:02:00,000 --> 00:02:03,000
как вам больше нравится – которые передаются в нее.

41
00:02:03,000 --> 00:02:06,000
Посмотрим, как это работает, на примере простой процедуры.

42
00:02:06,000 --> 00:02:10,000
Я определю процедуру rest_of_string(), и мы снабдим ее

43
00:02:10,000 --> 00:02:13,000
параметром s; это значит, что у нее один вход и мы будем обращаться к

44
00:02:13,000 --> 00:02:16,000
его значению через имя s.

45
00:02:16,000 --> 00:02:21,000
Мы заставим ее возвращать все символы строки от первой [не нулевой!] позиции до ее конца.

46
00:02:21,000 --> 00:02:25,000
Для этого мы будем использовать оператор индексации строк – return s[1:].

47
00:02:25,000 --> 00:02:31,000
Это даст нам ту же строку без первой буквы, то есть все символы

48
00:02:31,000 --> 00:02:33,000
от позиции 1 до конца строки.

49
00:02:33,000 --> 00:02:35,000
Вот их мы и вернем.

50
00:02:35,000 --> 00:02:39,000
Итак, на выходе rest_of_string() будет новая строка, начинающаяся

51
00:02:39,000 --> 00:02:42,000
со второй буквы входной строки.

52
00:02:42,000 --> 00:02:45,000
Вот пример использования этой процедуры.

53
00:02:45,000 --> 00:02:47,000
Мы можем вызвать ее напрямую.

54
00:02:47,000 --> 00:02:51,000
Мы можем написать print rest_of_string.

55
00:02:51,000 --> 00:02:53,000
Это наша процедура.

56
00:02:53,000 --> 00:02:56,000
Теперь нужно поставить открывающую скобку и передать в нее входное значение.

57
00:02:56,000 --> 00:02:59,000
У rest_of_string() один параметр, так что нам понадобится передать в нее

58
00:02:59,000 --> 00:03:02,000
одно значение, и оно должно быть строкой.

59
00:03:02,000 --> 00:03:05,000
Мы передадим в процедуру строку 'audacity'.

60
00:03:05,000 --> 00:03:07,813
Когда мы вызываем процедуру, контроль переходит

61
00:03:07,813 --> 00:03:10,000
к телу процедуры.

62
00:03:10,000 --> 00:03:10,566
Мы можем представить, что сейчас делает интерпретатор.

63
00:03:10,566 --> 00:03:17,000
Вместо выполнения кода, интерпретатор сделает переход.

64
00:03:17,000 --> 00:03:21,000
Когда мы вызовем процедуру, он перейдет к выполнению кода внутри нее.

65
00:03:21,000 --> 00:03:26,000
Он присвоит параметрам поданные на вход значения.

66
00:03:26,000 --> 00:03:30,000
Мы можем представить это как операцию присваивания, которая присваивает s

67
00:03:30,000 --> 00:03:31,974
переданное в процедуру входное значение.

68
00:03:31,974 --> 00:03:36,000
Теперь нам нужно выполнить тело процедуры.

69
00:03:36,000 --> 00:03:39,000
В данном случае оно состоит из одной команды – вот этой команды return.

70
00:03:39,000 --> 00:03:43,000
Нам нужно вычислить это значение, s[1:].

71
00:03:43,000 --> 00:03:47,000
Оно будет равно строке 'udacity'.

72
00:03:47,000 --> 00:03:49,000
Теперь перехойдем к команде return.

73
00:03:49,000 --> 00:03:51,000
return означает, что мы переходим обратно.

74
00:03:51,000 --> 00:03:56,000
Мы возвращаемся к месту вызова процедуры, но уже

75
00:03:56,000 --> 00:03:58,000
с его результатом.

76
00:03:58,000 --> 00:04:03,000
Когда мы переходим обратно, значение вызова становится равным значению,

77
00:04:03,000 --> 00:04:04,000
которое мы вернули.

78
00:04:04,000 --> 00:04:07,000
В данном случае это строка 'udacity'.

79
00:04:07,050 --> 00:04:08,556
Итак, у нас пока нет собственной машины-беспилотника,

80
00:04:08,556 --> 00:04:10,867
но теперь вы умеете определять и использовать процедуры.

81
00:04:10,867 --> 00:04:12,745
Это очень мощная концепция.

82
00:04:12,902 --> 00:04:14,993
Все, чем мы будем заниматься в рамках этого курса, как и деятельность

83
00:04:14,993 --> 00:04:18,529
практически любого компьютерного программиста сводится к определению

84
00:04:18,529 --> 00:04:20,697
процедур и их использованию.

85
00:04:20,697 --> 00:04:22,778
А теперь у нас должна появиться широкая улыбка.

86
00:04:22,778 --> 00:04:26,777
Мы можем думать о процедурах как о коде, преобразующем входные данные в выходные.

87
00:04:26,777 --> 00:04:30,396
Мы также можем думать о людях как о существах, занимающихся тем же самым.

88
00:04:30,396 --> 00:04:33,065
У нас есть входные значения, поступающие через глаза, через

89
00:04:33,065 --> 00:04:35,689
рот – наверное, даже через нос.

90
00:04:35,689 --> 00:04:39,081
Я не буду пытаться изобразить выходные данные человека-процедуры, но раз уж

91
00:04:39,081 --> 00:04:41,495
процедуры играют настолько важную роль, мы посвятим им несколько

92
00:04:41,495 --> 00:04:44,495
следующих заданий, чтобы убедиться, что вы хорошо их понимаете.