0:00:00.000,0:00:04.000
不幸的是 我们还不能高兴得太早

0:00:04.000,0:00:07.000
Sebastian 告诉我 我还需要几年时间才能拥有一辆自己的无人驾驶汽车

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
在第一单元中 你学了如何对于 “string”（字符串）使用 “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
在第一单元 我们用不同的方法来使用 “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
另外一个差别是 我们并非只有 “find”

0:01:22.000,0:01:25.000
我们还有另外一个输入

0:01:25.000,0:01:31.000
我们有使用 “find” 功能的字符串（在变量 “page” 当中）

0:01:31.000,0:01:34.000
那才是我们要查找的另一个输入

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.810
当我们调用这样一个程序时

0:03:07.810,0:03:10.000
其执行会跳转到过程的主体

0:03:10.000,0:03:10.560
我们能够想到现在解释程序在做什么

0:03:10.560,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
我们可以把它视作一个赋值

0:03:30.000,0:03:31.970
即现在 “s” 的值就是我们所传入的输入的值

0:03:31.970,0:03:36.000
现在我们将执行过程的主体

0:03:36.000,0:03:39.000
在这种情况下 只有一个语句 就是返回语句

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
接着我们要返回

0:03:49.000,0:03:51.000
返回的意思是我们会跳转

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.500,0:04:08.550
让我们在 Python 的解释器里尝试一下

0:04:08.550,0:04:10.860
我们将定义 "rest_of_string" 这个过程 使用 “s” 这个输入

0:04:10.860,0:04:12.740
我们会返回 s[1:]

0:04:12.900,0:04:14.990
我们在今后课程中所要做的任何事

0:04:14.990,0:04:18.510
以及任何人在计算机编程中所做的事情都是关于

0:04:18.519,0:04:20.690
定义和使用过程

0:04:20.690,0:04:22.770
现在我们可以高枕无忧了

0:04:22.770,0:04:26.770
我们可以将过程视作把输入映射到输出中

0:04:26.770,0:04:30.390
我们也可以将人类视作把输入映射到输出中

0:04:30.390,0:04:33.600
我们通过眼睛和嘴巴来输入

0:04:33.600,0:04:35.680
甚至可能会用到鼻子

0:04:35.680,0:04:39.800
我不会画任何人类过程的输出

0:04:39.800,0:04:41.490
但既然过程是如此重要的一个概念

0:04:41.490,3:59:59.000
那么现在我们会有几个小测验 来检测你是否理解它们