Unfortunately, we're not quite ready to be all smiley.
Sebastian tells me it's going to be a few years before I can get
my own self-driving car, but the bigger problem is we haven't yet talked about
how to actually use the procedure.
All we've done is make them; until we can actually use them
we don't have a good reason to be really happy yet.
We're going to learn how to use them next, then we'll be back to being smiley.
Now we are going to learn how to use a procedure.
The way to use a procedureÃ¢ÂÂwe need the name of the procedure, followed by
a left paren, followed by a list of inputs.
There could be any number of inputs, but it has to match the number of inputs
the procedure expects.
These inputs are sometimes called "operands."
They are sometimes called "arguments."
We're not going to argue about that.
We're just going to call them inputs.
You have actually already done something quite similar to this.
Back in Unit 1, you learned about using "find" on "strings."
With "find" you would pass in one or two inputs.
The first input was a "string."
That was the string you are looking forÃ¢ÂÂthat's the first inputÃ¢ÂÂ
and the second input could be a numberÃ¢ÂÂthe position where you start
looking for that string.
We use "find" in many ways in Unit 1, as well as you used it
yourself in the homework for Unit 1.
"Find" is a little different from the procedures that you define yourself.
First of all, it's built in.
The other thing that was different is that, instead of just having "find," we had
another input that was really over here.
We have the string that we were doing the "find" inÃ¢ÂÂlet's say it was
in the variable pageÃ¢ÂÂthat's really another input to find.
We'll talk in a later class about why that's done differently, but it's
very similar to calling a procedure where one of the inputs is over hereÃ¢ÂÂ
the other two are here.
It's a little different from that and we won't get into that in this course but
in a later course you'll learn more about what this really means.
For all the procedures that you define yourself, we won't have any
object to invoke them on.
We'll just have the procedure to call and the arguments or operands or inputsÃ¢ÂÂ
as you like to call themÃ¢ÂÂto pass in.
Let's see how that works with a simple procedure.
I am going to define the procedure "rest_of_string," and we'll give it the
parameter "s," so that means it takes one input and we are going to use the
name "s" to refer to the value of that input.
We'll make it "return to string" from the first character to the end.
We will use the "string" indexing operator "return s [1:]."
This will evaluate to the "string," with the first letter removed, so all "strings" from
position 1 until the end of the "string."
That's what we return.
So, the output of "rest_of_string" is that new string that starts from
the second letter in the input "string."
Here's an example of how to use this procedure.
We could call it directly.
We could say "print rest_of_string."
That's our procedure.
Now we are going to have our paren and we are going to pass in an input.
There's one parameter to "rest_of_string," so we need one input
to pass in and it should be a "string."
We'll pass in the string 'audacity'.
What happens when we call a procedure like this, execution will jump
into the body of the procedure.
We can think of what the interpreter is doing now.
Instead of running the code here, the interpreter will move.
When we call a procedure, it will jump to run the code inside the procedure.
It will assign to the parameters the values passed in as the inputs.
We can think of this as there being an assignment that says now the value of
"s" is the value of this input that was passed in.
Now we are going to evaluate the body of the procedure.
In this case there's only one statementÃ¢ÂÂit's this return statement.
We are going to find this value, so s [1:].
The result of that is going to be the string 'udacity'.
Then we got to the return.
What return means is we're going to jump back.
We're jumping back to where we called the procedure, but now we actually
have a result.
When we jump back, the value that this evaluates to is whatever value we
returned.
In this case, it's the string 'udacity.'
So we don't have our self driving car,
but now you can define and use procedures.
This is a really powerful concept
Anything that we are going to do in the rest of the course and anything
almost anyone does in programming computers is all about defining
procedures and using procedures.
Now we should have a big smile.
We can think of our procedures in terms of mapping inputs to outputs.
We can think of our humans as also mapping inputs to outputs.
We have inputs coming in through the eyes, through the
mouthÃ¢ÂÂmaybe we even have a nose.
I won't try to draw any of the outputs of our human procedure, but since
procedures are such an important concept, we are going to have several
quizzes now to check that you understand them well.
Desafortunadamente, no estamos completamente listos para estar sonrientes.
Sebastian me dijo que van a pasar algunos años antes de que tenga
mi propio auto que se conduce solo, pero el mayor problema es que todavía no hemos hablado realmente de
como usar un procedimiento.
Todo lo que hemos hecho es crearlos, hasta que no podamos usarlos
no tenemos ninguna razon para estar felices.
Enseguida vamos a aprender a usarlos, luego estaremos nuevamente sonrientes.
Ahora vamos a aprender a usar un procedimiento.
La forma de usar un procedimiento- necesitamos el nombre del procedimiento, seguido de
un parentesis izquierdo, seguido de una lista de entradas.
Podría ser cualquier cantidad de entradas, pero tiene que coincidir con el número de entradas
que espera el procedimiento.
Estas entradas son algunas veces llamadas operandos,
algunas veces son llamadas argumentos.
No vamos a debatir al respecto.
Nosotros simplemente las llamaremos entradas.
Ustedes ya hicieron algo parecido a esto.
En la unidad 1, aprendieron a usar find con las cadenas.
con find podían pasar una o dos entradas.
La primera entrada era una cadena.
Esa fue la cadena en la que estaban buscando, esa fue la primera entrada,
y la segunda entrada podía ser la posición desde donde empezar a
buscar dentro esa cadena.
Usamos find en varias formas en la unidad 1, así como ustedes
la usaron por su cuenta en la tarea de la unidad 1.
Find es un poco diferente del procedimiento que define uno por su cuenta.
Antes que nada, es interno.
La otra cosa que era diferente es que en lugar de tener simplemente find tuvimos
otra entrada que estaba por aquí.
Tenemos la cadena en la que estamos haciendo la busqueda, digamos
que era la variable page- esa fue otra entrada a buscar.
En una clase posterior hablaremos porque está hecha diferente, pero es
muy similar llamar un procedimiento donde una de las entradas esta por aquí.
y la otra por aquí.
Esto es un poco diferente de eso y no trataremos más en este curso, pero
en un curso posterior aprenderás más acerca de que significa esto realmente.
En todos los procedimientos que definan por su cuenta, no tendremos ningun
objeto sobre el cual invocarlos.
Simplemente tendremos el procedimiento a llamar y los argumentos, operandos o entradas,
como quieran llamarlos, para pasarlos.
Veamos como funciona con un simple procedimiento.
voy a definir el procedimiento rest_of_string y le daremos el
parámetro s, eso significa que toma una entrada y vamos a usar el
nombre s para referirnos al valor de esa entrada.
Haremos que retorne la cadena desde el primer caracter hasta final.
usaremos la operador indexado return s[1:]
Esto evaluará la cadena con la primera letra removida, es decir toda la cadena desde
la posición uno hasta el final de la cadena.
Eso es lo que retornamos.
Entonces, la salida de rest_of_string es la nueva cadena que empieza desde
la segunda letra de la cadena de entrada.
Aqui tienen un ejemplo de como usar este procedimiento.
Podríamos llamarlo directamente.
podríamos decir print rest_of_string
ese es nuestro procedimiento.
Ahora vamos a tener nuestro parentesis y vamos a pasar la entrada.
Hay un parámetro de rest_of_string, entonces necesitamos una entrada
y esa sería string
pasaremos la cadena audacity.
Lo que sucede cuando llamamos a un procedimiento como este, es que la ejecución
salta al cuerpo de procedimiento.
podemos pensar acerca de lo que el intérprete está haciendo ahora.
En lugar de ejecutar el código aquí, el intérprete se moverá
cuando llama al procedimiento, y saltará para ejecutar el código dentro del procedimiento.
Asignará los valores a los parámetros pasados como entradas.
podemos concebir esto como una asignación que dice ahora el valor de
s es el valor de esta entrada que fue pasada.
Ahora vamos a evaluar el cuerpo del procedimiento.
En este caso hay una sola sentecia, la sentencia return,
vamos a encontrar este valor, así s[1:]
El resultado de esto va a ser la cadena udacity.
Luego tendremos la sentencia return.
Lo que return significa es que vamos a saltar de regreso,
de regreso a donde llamamos al procedimiento, pero ahora de verdad
tenemos un resultado.
Cuando saltamos de regreso, el valor que es evaluado es cualquier valor que
retornamos.
En este caso, es la cadena udacity.
Entonces no tenemos nuestro auto que se conduce solo,
pero ahora podemos definir y usar procedimientos.
Este es de verdad un concepto poderoso.
Cualquier cosa que hagamos en lo que queda del curso y cualquier cosa
que casi cualquiera hace en la programación de computadoras está relacionado con definir
y usar procedimientos.
Ahora deberíamos tener una gran sonrisa.
Podemos pensar acerca de los procedimientos como el mapeo de entradas a salidas.
Podemos pensar acerca de los humanos que también mapean entradas a salidas.
Tenemos entradas viniendo a través de nuestros ojos, de
nuestra boca, quizá incluso a través de nuestra nariz.
No intentaré mencionar ninguna de las salidas de nuestro procedimiento humano, pero dado que
el procedimiento es un concepto importante, vamos a tener varias
pruebas para verificar que los entendimos bien.
Al di fuori della procedura--quando arriviamo alla riga 7--"s" è non definito.
Così ora stiamo provando a stampare.
E' un concetto davvero potente.
Ghiamiamo ora "t".
La definizione di "s" dura finchè siamo all'interno della procedura.
Nel corpo della procedura, il parametro "s" ha un valore che
Nel corpo della procedura, il valore di "s"
Non abbiamo la nostra auto "self--driving", ma ora puoi
Non proverò a disegnare nessuno degli output della nostra procedura umana, ma dal momento
Non è definito.
Ora puoi pensare che stampi "s" prima di usare il nome "s" qui.
Possiamo fare quello che vogliamo col risultato della procedura--come ogni
Possiamo pensare alle nostre procedure in termini di mappare input e output.
Possiamo pensare anche a noi umani come a una mappatura di input e output. Abbiamo input che vengono dagli occhi,
Possiamo vedere "s" mentre è in "restofstring".
Possiamo vedere che l'esecuzione è cominciata dalla print;
Quando eseguiamo ciò, quello che otteniamo è un errore.
Quello che voglio farvi vedere--supponiamo non chiameremo quella "s"
Questo è il perchè dell'errore di nome quando stampiamo il valore di "s" qui.
Quindi vediamo i i risultat "udacity".
Vedremo il "Sono qui" in "reat:of:string.
altra espressione in Python, così possiamo memorizzare una variabile
che le procedure sono un concetto così importante, avremo diversi quiz ora che verificheranno che tu li abbia capiti bene.
che è il risultato che abbiamo nel tabulato.
chiamare "restofstring", eseguire questo codice, ritornare il risultato
dalla bocca, magari anche dal naso.
definire ed usare le procedure.
praticamente tutti quelli che programmano computers hanno a che fare con definire procedure ed utilizzare procedure. Ora dovremmo avere un gran sorriso.
è passato ai corrispondenti church
Sfortunatamente, non siamo ancora pronti per essere del tutto sorridenti.
Sebastian mi ha detto ci vorrà ancora qualche anno prima che possa avere
la mia auto "self-driving", ma il problema maggiore di cui non abbiamo ancora parlato
è come usare veramente la procedura.
Quello che abbiamo fatto è crearne, finchè non ne useremo veramente
non abbiamo ancora una buona ragione per essere veramente felici.
Impareremo ad usarle e poi torneremo ad essere sorridenti.
Impareremo ora ad usare le procedure.
Il modo di usare una procedura. Ci servirà il nome della procedura, seguito da
una parentesi aperta, seguita da una lista di inputs.
Può esserci qualsiasi numero di input, ma deve essere lo stesso numero di inputs che
la procedura si aspetta.
Questi input sono a volte chiamati "operandi".
Altre volte sono chiamati "argomenti".
Non discuteremo su questo.
Li chiameremo semplicemente inputs.
Hai realmente già fatto qualcosa di molto simile a questo.
Nella Unit 1, hai imparato ad usare "find" su "stringhe".
A "find" passeresti uno o due input.
Il primo input è una "stringa".
Che è la stringa che stai cercando--è il primo input--
e il secondo input potrebbe essere un numero--la posizione da cui partire
nella ricerca di tale stringa.
Abbiamo usato "find" in molti modi nella Unit 1, così come l'hai usata
da te nell'homework per l'Unit 1.
"find" è un po' diversa dalla procedura che hai definito.
Prima di tutto, è incorporata [built in].
L'altro motivo è che, invece di avere solo "find", abbiamo
un'altro input coinvolto.
Abbiamo la stringa sulla quale operiamo "find", diciamo
sia la variabile "page"--che è davvero un altro input a "find".
Parleremo in un corso successivo del perchè questo sia diverso, ma è
molto simile a chiamare una procedura dove uno degli input è implicito
e gli altri due sono espliciti.
E' un po' diverso da questo e non ci addentreremo oltre in questo corso ma
in un corso successivo impareremo di più su cosa questo significhi realmente.
Per tutte le procedure che stai definendo, non avremo nessun
oggetto su cui invocarle.
Avremo solo la procedura da chiamare e gli argomenti o operandi o input,
come preferisci chiamarli, da passare in ingresso.
Vediamo ora come ciò funziona con una semplice procedura.
Definisco la procedura "restofstring" e gli daremo
parametro "s", che significa che prende un input e useremo
il nome "s" per riferirci al valore dell'input.
Gli faremo ritornare una stringa dal primo carattere alla fine.
Uiseremo l'operatore di indiczzazione della stringa "return s[1:]".
Questo valuterà la "stringa", rimuovendo il primo carattere, e questo per tutte le stringhe, da
posizione 1 fino alla fine della "stringa".
Questo è quello che ritorniamo.
Quindi l'output di "restofstring" è la stringa che parte dalla
seconda lettera della stringa in ingresso.
Qui c'è un esempio di come usare questa procedura.
Possiamo chiamarla direttamente.
Possiamo dire "print restofstring".
E' la nostra procedura.
Ora metteremo la nostra parentesi e passeremo un input.
C'è un parametro a "restofstring", così dobbiamo
passare in ingresso un input che dovrebbe essere una "stringa".
Passeremo la stringa "audacity".
Quello che succede quando chiamiamo la procedura, è che l'esecuzione salterà
al corpo della procedura.
Possiamo pensare a costa sta facendo ora l'interprete.
Invece di eseguire il codice qui,l'interprete si moverà.
Quando chiamiamo una procedura, salterà al codice dentro la procedura.
Assegnerà ai parametri i valori passati come input.
Possiamo pensare ci sia un assegnamento che dice che ora il valore
"s" è il valore dell'input da passare in ingresso.
Ora valuteremo il corpo della procedura.
In questo caso c'è una sola istruzione--è l'istruzione di return.
Troveremo che il valore in uscita è s[1:].
Il risultato sarà quindi la stringa "udacity".
Poi abbiamo il valore di ritorno.
"return" significa che salteremo indietro.
Stiamo saltando indietro a dove abbiamo chiamato la procedura, ma ora
abbiamo davvero un risultato.
Quando saltiamo indietro, il valore che questo valuta è qualsiasi valore
abbiamo ritornato.
In questo caso è la stringa "udacity".
Non abbiamo la nostra auto "self--driving", ma ora puoi
definire ed usare le procedure.
E' un concetto davvero potente. Qualsiasi cosa faremo nel proseguo del corso e qualsiasi cosa
Qualsiasi cosa faremo nel proseguo del corso e qualsiasi cosa
praticamente tutti quelli che programmano computers hanno a che fare con definire
procedure ed utilizzare procedure.
Ora dovremmo avere un gran sorriso.
Possiamo pensare alle nostre procedure in termini di mappare input e output.
Possiamo pensare anche a noi umani come a una mappatura di input e output.
x
dalla bocca--magari anche dal naso.
Non proverò a disegnare nessuno degli output della nostra procedura umana, ma dal momento
che le procedure sono un concetto così importante, avremo diversi
quiz ora che verificheranno che tu li abbia capiti bene.
残念ながらまだ完全なスマイルマークではありません
数年も経てば私も自動走行車に 乗れるようになるらしいです
それより関数の実際の使い方について まだお話ししていないことが大きな問題です
関数を実際に使用する前の 関数の作成について学びました
まだ喜べる状態ではありません
関数の使い方を学んで笑顔になりましょう
それでは関数の使い方についてです
関数を使うには関数の名前 それに続く左の括弧
それに続く入力リストが必要となります
入力の数はいくつでも可能ですが
関数が要求する入力数と一致しなければなりません
これらの入力はオペランドや引数と呼ばれます
これについては論議せず入力と呼びましょう
これとよく似たことをすでに行っています
レッスン1で文字列にfindを使用することを学びました
findで1つか2つの入力を渡します
1つ目の入力は文字列つまりその文字列を探します
2つ目の入力は数値 つまりその文字列を探し始める位置です
レッスン１では様々な方法でfindを使用しただけでなく ホームワークにも使用しました
findは皆さんが定義した関数とは少し異なります
まず初めにこれは組み込みです
その他に異なるのはfindをただ持つだけではなく ここに別の入力があることです
findを行う文字列です 変数をpageとします これがfindの別の入力です
なぜ別に行われるのかこのあとのレッスンで お話ししたいと思いますが
ここにある入力が 関数を呼び出すこととよく似ています
別の2つはここです
少し異なりますがこのコースでは扱いません
あとのコースでこの意味をより詳しく学びます
自身で定義した関数では 関数を呼び出すオブジェクトはありません
呼ぶための関数と
呼び出して渡す入力があります 引数またはオペランドと呼んでも構いません
シンプルな関数を使って どのように機能するのか確認してみましょう
rest＿of＿string関数を定義し それにパラメータsを与えます
つまり1つの入力で その入力の値を参照する名前sを使います
1つ目の文字から終わりまで返す文字列にします
s［1：］を返すインデックス演算子の文字列を 使用します
これは削除された1つ目の文字で文字列を評価します
つまり位置1から最後までのすべての文字列です
これが返すものです
ですからrest＿of＿stringの出力は 入力文字列の2つ目の文字から
開始する新たな文字列です
この関数の使い方の例を挙げましょう
直接関数を呼び出します
print rest＿of＿stringとします
これが関数です ここで括弧を使い入力を渡します
rest＿of＿stringの1つのパラメータがあります
渡すための入力が1つ必要です それは文字列です 文字列audacityを渡します
このように関数を呼び出すと 関数の主要部分を直接実行できます
インタプリタが何を行っているのか判断できます コードを実行する代わりにインタプリタが作動します
関数を呼び出すと関数内でコードを直接実行します
パラメータに入力として渡した値を代入します
これをsの値が渡した入力の値になる代入だと考えます
関数の主要部分を評価します
唯一の文です
このreturn文の値s［1：］を探します
結果は文字列udaictyになります
ここでreturnしなければなりません
returnはジャンプするという意味で 関数を呼び出した場所へ一気に戻ります
しかし実際には結果が分かっています
何であれジャンプした際評価する値が 返した値になります
この場合は文字列udacityです
自動走行車は持っていませんが 関数を定義し使うことができます
これは本当に強力な概念です
コースで今後行うこと
コンピュータプログラミングで行う中心となるのが
関数を定義して使用することです
大きなスマイルマークになりました
入力を出力に対応づけるという観点で 関数を考えることができます
入力を出力に対応づけることは人間にも例えられます
目を通して入力されます 口や鼻を通すこともあります
人間の出力については描きませんが 関数はこのように重要な概念です
関数を理解できているか確認するために 小テストを行います
Infelizmente, ainda não estamos prontos para ficar completamente felizes.
Sebastian me disse que ainda levará alguns anos até que eu possa ter
meu próprio carro autônomo. Mas o maior problema é que ainda não falamos sobre
como usar um procedimento.
Tudo o que fizemos foi definir um. Até que possamos realmente usá-los,
não temos uma boa razão para ficar muito felizes.
Vamos aprender como usá-los a seguir, e então poderemos ficar mais felizes.
Agora, vamos aprender como usar um procedimento.
A maneira como usamos procedimento é: precisamos do nome do procedimento, seguido de
( seguido de uma lista de entradas e ).
O número de entradas pode ser qualquer, mas deve casar com o número de entradas
que o procedimento espera.
Essas entradas são algumas vezes chamadas de operandos.
E algumas vezes chamadas de argumentos.
Não vamos discutir sobre isso.
Vamos simplesmente chamá-las de entradas.
Você de fato já fez algo bem similar a isso.
Voltando na Unidade 1, você aprendeu a usar find sobre strings.
Com find, você pode passar uma ou duas entradas.
A primeira entrada era uma string:
a string pela qual você estava procurando -- essa era a primeira entrada;
e a segunda entrada poderia ser um número: a posição onde você começa
a pesquisar por essa string.
Nós usamos find de várias maneiras na Unidade 1, e você também usou
nos exercícios da Unidade 1.
find é um pouco diferente dos procedimentos que você vai definir aqui.
Em primeir lugar, ele é pré-definido.
A outra coisa que é diferente é que, ao invés de ter apenas find, nós temos
outra entrada que está aqui.
Temos o string no qual vamos fazer a pesquisa -- digamos que ele fosse
a variável page -- isso é, de fato, uma outra entrada para find.
Mais adiante vamos falar sobre porque isso é feito de maneira diferente, mas é
bastante semelhante a chamar um procedimento em que uma das entradas está aqui,
e as outras duas estão aqui.
É um pouco diferente disso, e não vamos ver isso neste curso, mas
em um curso posterior você vai aprender mais sobre o que isso significa.
Para todos os procedimentos que você vai definir aqui, não haverá nenhum
objecto sobre o qual eles serão invocados.
Simplesmente teremos o procedimento a chamar e os argumentos, ou operandos, ou entradas --
como você queira chamá-los -- que serão passados.
Vamos ver como isso funciona, com um procedimento simples.
Eu vou definir o procedimento rest_of_string, que vai ter
um parâmetro s -- isso significa que ele tem uma entrada, e vamos usar o nome
s para nos referirmos ao valor dessa entrada.
Ele vai retornar a string que vai desde o caractere na posição 1 até o final da string.
Vamos usar o operador de indexação de string: return s[1:].
Isso avalia para a string obtida removendo-se a primeira letra; portanto, toda a string a partir
da posição 1 até o final da string.
É isso que é retornado.
Então, a saída de rest_of_string é esta nova string, que começa da
segunda letra da string de entrada.
Aqui está um exemplo de como usar este procedimento.
Podemos chamá-lo diretamente.
Podemos dizer print rest_of_string --
este é o nosso procedimento --
e agora temos ( e vamos passar uma entrada.
rest_of_string tem 1 parâmentro e, portanto, precisamos passar de 1 entrada
para ele, que deve ser uma string.
Vamos passar a string 'audacity'.
O que acontece quando chamamos um procediento como esse é que a execução desvia
para o corpo desse procedimento.
Podemos pensar no que o interpretador está fazendo agora.
Ao invés de executar este código aqui, o interpretador desvia:
quando chamamos um procedimento, ele desvia para executar o código que está dentro do procedimento.
Ele vai atribuir aos parâmetros os valores que são passados como entrada.
Podemos pensar nisso como sendo uma atribuição, que diz que agora o valor de
s é o valor dessa entrada que está sendo passada.
Agora, vamos avaliar o corpo do procedimento.
Neste caso, existe apenas um comando -- este comando return.
Vamos encontrar o valor de s[1:] --
o resultado disso será a string 'udacity' --
e então chegamos ao return.
O que return significa é que vamos desviar de volta.
Vamos voltar para onde o procedimento foi chamado, mas agora realemte
temos um resultado.
Quando voltamos, o valor para o qual isso é avaliado é o valor que nós
retornamos.
Neste caso, é a string 'udacity'.
Então, não temos ainda nosso carro autônomo,
mas agora você já sabe definir e usar procedimentos.
Esse é um conceito realmente poderoso!
Tudo o que vamos fazer no resto do curso e quase tudo
que todo mundo faz em programação de computadores tem a ver com dedinir
procedimentos e usar procedimentos.
Agora podemos abrir um grande sorriso.
Podemos pensar em nossos procedimentos em termos de mapeamento de entradas em saídas.
Podemos pensar pensar em nós, humanos, também como mapeamentos de entradas em saídas:
temos entradas vindo de nossos olhos, por meio da
boca, e até pelo nosso nariz.
Eu não vou tentar desenhar nenhuma das saídas do nosso procedimento 'humano', mas como
procedimentos são um conceito tão importante, vamos ter vários
testes agora, para verificar se você entendeu bem esse conceito.
К сожалению, у нас пока нет особых поводов для радости.
Себастьян говорит, что пройдет еще несколько лет, прежде чем у меня появится
свой собственный беспилотный автомобиль, но главная проблема в том,
что мы еще не поговорили о том, как использовать процедуры.
Мы всего лишь научились создавать их; пока мы не сможем их использовать,
у нас не будет веской причины для радости.
Мы вскоре научимся ими пользоваться и снова сможем широченно улыбаться.
А сейчас мы собственно и узнаем, как использовать процедуру.
Для этого нам понадобится <имя процедуры>, за которым следует
открывающая скобка и список <входных данных>.
В принципе их может быть сколько угодно, но их количество должно совпадать с
тем, что ожидает процедура.
Эти входные данные иногда называются «операндами».
А иногда – «аргументами».
Мы не будем спорить, что правильнее.
Мы просто будем называть их входными данными.
Вообще-то вы уже использовали похожую запись.
Еще в разделе 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'.
Итак, у нас пока нет собственной машины-беспилотника,
но теперь вы умеете определять и использовать процедуры.
Это очень мощная концепция.
Все, чем мы будем заниматься в рамках этого курса, как и деятельность
практически любого компьютерного программиста сводится к определению
процедур и их использованию.
А теперь у нас должна появиться широкая улыбка.
Мы можем думать о процедурах как о коде, преобразующем входные данные в выходные.
Мы также можем думать о людях как о существах, занимающихся тем же самым.
У нас есть входные значения, поступающие через глаза, через
рот – наверное, даже через нос.
Я не буду пытаться изобразить выходные данные человека-процедуры, но раз уж
процедуры играют настолько важную роль, мы посвятим им несколько
следующих заданий, чтобы убедиться, что вы хорошо их понимаете.
不幸的是 我们还不能高兴得太早
Sebastian 告诉我 我还需要几年时间才能拥有一辆自己的无人驾驶汽车
但更大的问题是我们还没谈到
即如何实际地使用这个过程
我们所做的一切只是写出过程 在我们能够实际地使用它们之前
我们还不能高兴得太早
下面我们会学习如何使用它们 然后我们就高枕无忧了
现在我们将要学习如何使用一个过程
要使用一个过程 我们需要过程名称
后面加上一个左括号 再加上一系列输入
输入的数量不是固定的 但是它必须匹配
该过程所预期的输入数量
这些输入有时被称为操作对象
它们有时又被称为参数
我们不会在这个上面多作讨论
我们就叫它们输入
其实你已经做过一些类似的事情了
在第一单元中 你学了如何对于 “string”（字符串）使用 “find”（查找）的功能
通过 “find” 你能够传入一个或两个输入
第一个输入是个字符串
那正是你在查找的字符串
那是第一个输入 第二个输入可能是个数字
也就是你从何处开始查找那个字符串
在第一单元 我们用不同的方法来使用 “find”
你在第一单元的作业中也使用过了
“Find” 与你自己定义的过程还有细微的差别
首先 它是内置的
另外一个差别是 我们并非只有 “find”
我们还有另外一个输入
我们有使用 “find” 功能的字符串（在变量 “page” 当中）
那才是我们要查找的另一个输入
我们会在今后的课程中谈到为什么会有这些差别
但这与调用程序很相似
在此过程中 一个输入在那里 另外两个在这里
两者间有细微的差别 我们在本课程中不会谈到这一点
但在今后的课程中 你会学到其真正的意义
对于所有你自己定义的过程
我们不会调用它们
我们需要的只是有程序可供调用 以及有参数 或者操作对象或者输入
（不论你喜欢怎么称呼它们）可供传入
让我们用一个简单的过程来看一看它如何工作
我将会定义 "rest_of_string" 这个过程
给它一个名为 “s” 的参数 这意味着该过程需要一个输入
并且我们会用 “s” 这个名称来指代这个输入的值
我们将会用从第一个字符到最后一个字符来让它返回字符串
我们会用字符串索引操作符 "return s [1:]"
这将是首字母被除去的字符串
所以 所有得出的字符串从1这个位置一直到字符串结尾处连成一排
这就是返回的结果
所以 "rest_of_string" 的输出
是从输入的字符串的第二个字母开始的新字符串
这里有个例子 显示如何使用这个过程
我们可以直接调用
我们可以写 "print rest_of_string"
这就是我们的过程
现在我们将用括弧 并传入一个输入
"rest_of_string" 有一个参数
所以我们需要传入这个参数 且它应该是个字符串
我们会传入 audacity 这个字符串
当我们调用这样一个程序时
其执行会跳转到过程的主体
我们能够想到现在解释程序在做什么
它不会运行这里的代码 而会移动
当我们调用一个程序时 它会跳转到过程内部运行代码
它会给我们传入的输入赋值
我们可以把它视作一个赋值
即现在 “s” 的值就是我们所传入的输入的值
现在我们将执行过程的主体
在这种情况下 只有一个语句 就是返回语句
我们将找到这个值 也就是 s [1:]
得出的结果将是字符串 udacity
接着我们要返回
返回的意思是我们会跳转
跳转至我们调用程序的地方
但是现在实际上我们已有了一个结果
当我们跳转时
得出的值正是我们所返回的值
在这种情况下 就是字符串 udacity
让我们在 Python 的解释器里尝试一下
我们将定义 "rest_of_string" 这个过程 使用 “s” 这个输入
我们会返回 s[1:]
我们在今后课程中所要做的任何事
以及任何人在计算机编程中所做的事情都是关于
定义和使用过程
现在我们可以高枕无忧了
我们可以将过程视作把输入映射到输出中
我们也可以将人类视作把输入映射到输出中
我们通过眼睛和嘴巴来输入
甚至可能会用到鼻子
我不会画任何人类过程的输出
但既然过程是如此重要的一个概念
那么现在我们会有几个小测验 来检测你是否理解它们
可惜的是，我們還不能高興得太早
Sebastian 告訴我，還需要幾年時間
我才能擁有一輛自己的自動駕駛車， 但更大的問題是，我們還沒談到
如何實際地使用程序
我們所做的一切只是定義程序， 在我們能夠實際地使用它們之前
我們還不能高興得太早
下面我們將學習如何使用它們，之後我們就能重展笑顏
現在我們將要學習如何使用程序
要使用程序，我們需要程序名稱
後面加上左括弧，再跟著一系列的輸入
輸入的數目可以是任何數字，但是它必須
與程序所預期的輸入個數相同
這些輸入有時被稱為 "運算元" (operand)
有時被稱為參數 (argument)
我們不在這上面多作討論
我們就稱它們為輸入 (input)
其實你已經做過一些類似的事情
在第一單元中，你學到如何對字串使用 find
透過 find，你能夠傳入一個或兩個輸入
第一個輸入是個字串
那是你要尋找的字串，那是第一個輸入
第二個輸入是個數字
也就是你從何處開始尋找那個字串
在第一單元，我們以不同的方法使用 find
在第一單元的家庭作業中，你也使用過
find 與你自己定義的程序有點不同
首先，它是內建的 (built-in)
另外一個不同點是，除了 find 之外
還有另外一個輸入，在這個位置
我們使用 find 功能時，還有這個字串
我們稱為變數 page，實際上那是 find 的另一個輸入
之後的課程，我們會談到為什麼有這些差別
但這與呼叫程序很相似，一個輸入在那裡
另外兩個在這裡
兩者稍有不同，我們在這裡並不深入地討論它
但在之後的課程中，你會學到其真正的意義
對於所有你自己定義的程序
我們不會以物件 (object) 的方式呼叫它們
我們只要呼叫程序，並且傳入
參數、運算元或者輸入 (隨你如何稱呼)
讓我們用一個簡單的程序，來看它如何運作
我要定義程序 rest-of-string
給它一個參數 s，也就是說， 此程序需要一個輸入
我們用名稱 s 指向輸入的值
我們會傳回字串，從第一個字元到最後一個字元
我們會用字串的指標運算子 (index operator) 傳回 s[1:]
字串被除去第一個字母
所以，得到從位置 1 一直到結尾的字串
這就是傳回的結果
所以 rest-of-string 的輸出是個新字串
從輸入的字串的第二個字母開始
這裡有個例子，顯示如何使用這個程序
我們可以直接呼叫它
我們可以寫 print rest-of-string
這就是我們的程序
我們使用括弧，並傳入一個輸入
rest-of-string 有一個參數
所以我們需要傳入一個輸入，而且它應該是個字串
我們傳入字串 'audacity'
當我們呼叫這樣一個程序時
執行會跳進到程序的主體
我們可以想想解譯器正在做什麼
它不會執行這裡的程式，解譯器會移開
當我們呼叫程序時，解譯器跳到程序內部執行程式碼
它把我們傳入的輸入值，指定給參數
我們可以把它視為一個指定 (assignment)
現在的 s 值，就是我們所傳入的輸入值
現在，我們要執行程序的主體
在這裡，只有一個陳述，就是 return 陳述
我們會找到這個值，也就是 s[1:]
得出的結果將是字串 'udacity'
接著我們執行到 return
return 的意思是 "跳回"
跳回到我們呼叫程序的地方
現在，我們已經有了結果
當我們跳回時，得到的值
是我們所傳回的值
在這裡，就是字串 'udacity'
雖然我們沒有自動駕駛車
但是，你現在能夠定義並使用程序了
這是一個非常具有威力的觀念
我們在今後課程中所要做的任何事
以及任何人在寫電腦程式中所做的事情
幾乎都是關於定義程序，和使用程序
現在我們應該有一個燦爛的笑容
我們可以把程序當作從輸入映射到輸出
我們也可以把人類當作從輸入映射到輸出
我們透過眼睛和嘴巴來輸入
甚至還有鼻子
我不想畫出任何人類程序的輸出
但既然程序是如此重要的一個概念
那麼我們現在來做幾個測驗，檢測你是否已經理解