So, here I am, back at the code, and
here I can see my class movie, and within it
I will begin to define, [SOUND] the function, init.
Now, there is something very curious about this function already,
which is that, there are two underscores on both
sides of the word in it. These underscores are a
way for Python to tell us, the programmers, that hey,
the name init, is essentially reserved in Python, and that,
this is a special function or method. What's
special about init? Is that, it initializes or creates
space in memory. To remember details like title, story
line, et cetera, for new movies that we are
about to create. Now init, takes a few
pieces of information or arguments. The first of which,
is always the python keyword, self. Now, what is
this thing called, self, you ask? Well, you can
think of self as itself, or the instance being created.
So, when we run this line of code in our
other Python file, by the way, just to remind you,
here we are trying to create a new movie called, toy_story.
And when we run this line of code, we know
that the __init__ function inside the class Movie gets called. Self,
in that case, points to toy_story. Now here, I have
a confession to make. I remember when I was first learning
object oriented programming years ago in college. This concept of
self, was really difficult for me to understand. If that
is the case with you, don't worry about it too
much for now. This will get, really clear when we
learn this entire piece of coding a few seconds. In
any case, let's add the keyword self, to our list
of new words. Okay, I'm going to go back to
the class movie, and continue to define the function, init.
Now, we want init, to initialize pieces of information like title, story line
and others that we want to remember inside our class. Here's a way to do that. I
will say, self.title, then self.storyline.
[SOUND] The next one is, poster_image_url, and
finally, trailer_youtube_url. Now, we have to somehow initialize
these variables, with information init is going to
receive. And in particular, it's going to receive, four
pieces of information. The first of which is,
a movie title, [SOUND] next is, the movie storyline,
then the poster image of the movie, and
finally, the trailer on YouTube. So,get this, once I've
received these four pieces of information as arguments to
the __init__ function, I can initialize my Movie variables.
Here's how to do that. self.title, is the movie
title. Self.storyline, is the movie story line. Next is,
[SOUND] the poster image. And finally, [SOUND] the trailer
on youtube. Now here, I have a confession to
make. Which is, that we've written a lot of
code that looks new and strange. Well, the one
thing I can say is that, we should all
just take a pause and a deep breath together.
[SOUND]. For now, all I want you to do, is
pause this video, and write down this code on your
computer. All of this code will make sense as soon
as we run this program. Now, there is one key point
I would like to highlight, before I execute this piece
of code, which is, that if I go to my
other Python file, which is entertainment_center.py. And run this piece
of code. It will throw an error. The error will happen,
because when we try to create the movie, Toy
Story, the init function gets called, which is now
looking for several arguments or pieces of information, although,
we are not sending it any information whatsoever. So
let me change that. Now, I know that first
argument for the __init__ function is, self. Which is
added by default in Python. So I will skip
it. The next one is movie title, which I know
is, Toy Story, so I will add that. After that, is the movie
storyline, so I will type that in next. A Story. Of
a boy and his toys that come to
life. The next one is, the power image, so I will add that.
[SOUND] I had previously gone on Wikipedia and found a link to, Toy Story's
poster, so I added that and finally, the Youtube trailer, which I will add also.
[SOUND] There it is. Now, let me just scroll
back so we can see the beginning of the
code. Here, I recognize that you can't see all
of the code, so what I've done is, take an
image of the code, and put it in the
instructor notes for you to look at. All right,
the last thing I'm going to do here, is
type Toy Story's story line. Let me save this file,
and then go back to my class Movie file, and save that one also. And then
come back again, to my entertainment_center.py file. Now
here, if everything goes correctly, my program should
print out, toy_story.storyline. Let's run it. And there
it is, Toy story, storyline is getting printed.
Okay, so, in the next video we are
going to see what happens behind the scenes when
we run this piece of code.
،بعد العودة إلى التعليمة البرمجية
نرى الفئة movie وسنقوم
.بداخلها بتعريف [SOUND] الدالة init
،ثمة شيء يثير الفضول بشأن هذه الدالة بالفعل
ألا وهو وجود شرطتين سفليتين على كلا
جانبي الكلمة بداخلها. من خلال هاتين الشرطتين السفليتين
يخبرنا Python نحن المبرمجين أن
الاسم init يحمل قيمة كبيرة في Python وأن
هذا يعد دالة أو أسلوبًا خاصًا. فما هو
الشيء الخاص بشأن init؟ إنها تقوم بتهيئة
أو إنشاء مساحة بالذاكرة. لتذكر تفاصيل مثل العنوان والقصة
وغيرها من الأمور للأفلام الجديدة التي
سنقوم بإنشائها. تتلقى init بعض
المعلومات أو الوسائط. وأولها هي
كلمة python الأساسية، self. قد تسألون ما هو هذا الشيء
الذي يسمى self؟ يمكن التفكير في self على أنها
.الشيء نفسه أو المثيل قيد الإنشاء
لذا، عند تشغيل هذا السطر من التعليمة البرمجية في ملف
Python آخر، أود أن أذكركم
.بأننا نقوم بمحاولة إنشاء فيلم جديد باسم toy_story
من التعليمة البرمجية، يتم استدعاء دالة __init__
،من داخل الفئة Movie. تشير Self
في هذه الحالة، إلى toy_story. وأود أن أعترف
لكم الآن. أنني أتذكر حينما كنت أتعلم
البرمجة القائمة على الكائنات لأول مرة في الكلية منذ سنوات، كان يصعب عليّ استيعاب مفهوم
self. فإذا
كنتم أنتم أيضًا كذلك، فلا داع للقلق
كثيرًا الآن. سوف يتضح الأمر عندما
نتعلم هذا الجزء بالكامل من التعليمة البرمجية بعد ثوان قليلة. على
أية حال، هيا نضيف الكلمة الأساسية self إلى
قائمة الكلمات الجديدة. حسنًا، سنعود إلى
.الفئة movie ونواصل تعريف الدالة init
نريد تهيئة init لبعض المعلومات مثل العنوان والقصة
وغيرها من الأمور المطلوب تذكرها داخل الفئة. وإليكم كيفية القيام بذلك. سنكتب
.self.title، ثم self.storyline
SOUND] المعلومة التالية هي poster_image_url، و]
الأخيرة هي trailer_youtube_url. يتعين الآن تهيئة
هذه المتغيرات باستخدام المعلومات التي تتلقاها
init. وعلى وجه الخصوص، تتلقى أربع
معلومات. أولها
،عنوان الفيلم، [SOUND] والمعلومة التالية هي قصة الفيلم
،يليها صورة ملصق إعلان الفيلم
وفي النهاية، العرض الترويجي على YouTube. لذلك، فبمجرد
،الحصول على هذه المعلومات الأربع كوسائط للدالة __init__
.يمكن تهيئة متغيرات Movie
إليكم طريقة التنفيذ. self.title هو عنوان
الفيلم. Self.storyline هي قصة الفيلم. التالي هو
SOUND] صورة ملصق الإعلان. وفي النهاية، [SOUND] العرض الترويجي]
على youtube. ثمة أعترف
الآن. قمنا بكتابة
أمور عديدة في التعليمة البرمجية، والتي تبدو جديدة وغريبة. والشيء الوحيد
الذي يمكن قوله في مثل هذا الموقف
.هو أنه ينبغي أن نتوقف مؤقتًا ونلتقط أنفاسنا
SOUND]. كل ما نريده منكم الآن هو]
إيقاف هذا الفيديو مؤقتًا وكتابة هذه التعليمة البرمجية على
الكمبيوتر. تتضح هذه التعليمة البرمجية بمجرد
تشغيل هذا البرنامج. ثمة نقطة أساسية
نود إلقاء الضوء عليها قبل تنفيذ هذا الجزء
من التعليمة البرمجية، ألا وهي أنه عند الانتقال إلى
ملف Python الآخر وهو entertainment_center.py وتشغيل هذا الجزء من
التعليمة البرمجية، فسوف يظهر خطأ. سيحدث الخطأ
لأننا حينما نحاول إنشاء الفيلم Toy
Story، يتم استدعاء الدالة init والتي تقوم بدورها بالبحث عن
عدة وسائط أو معلومات
،بينما لم نقم بإرسال أية معلومات إليها. إذًا
دعونا نقوم بتغيير هذا. نعلم الآن أن أول وسيطة لدالة التحرير
هي self، والتي
تتم إضافتها كإعداد افتراضي في Python. إذًا، سنتخطى
ذلك. الوسيطة التالية هي عنوان الفيلم، وهو
Toy Story، وسنقوم بإضافته. بعد ذلك، قصة
الفيلم، لذا سنكتبها فيما يلي. قصة الصبي
الذي دبت الحياة في
.ألعابه. الوسيطة التالية هي صورة الملصق، والتي سنقوم بإضافتها
،SOUND] لقد قمت من قبل بالبحث في Wikipedia ووجدت رابط يؤدي إلى ملصق إعلان Toy Story]
.فسنقوم بإضافته. وفي النهاية، العرض الترويجي على Youtube، والذي سنقوم بإضافته أيضًا
SOUND] ها هو ذا. فلنقم بالتمرير للخلف]
حتى يتسنى لنا مشاهدة بداية
التعليمة البرمجية. ندرك أنه يتعذر عليكم مشاهدة
كل أجزاء التعليمة البرمجية، ومن ثم قمنا بالتقاط
صورة للتعليمة البرمجية ووضعها في
،ملاحظات المدرب للاطلاع عليها. حسنًا
الشيء الأخير الذي سأفعله هنا هو
كتابة قصة Toy Story. فلنحفظ هذا الملف
ثم نعود إلى ملف الفئة Movie ونحفظه هو أيضًا. وها
،قد عدنا مجددًا إلى ملف entertainment_center.py. والآن
إذا سار كل شيء بصورة صحيحة، فيجب أن يقوم البرنامج
بطباعة toy_story.storyline. فلنشغله. وهكذا
.تتم طباعة قصة Toy story
،حسنًا، في الفيديو القادم
سنرى ماذا يحدث خلف الكواليس عند
.تشغيل هذا الجزء من التعليمة البرمجية
Bien, estoy de vuelta con el código y
puedo ver mi clase Movie, voy a empezar
a definir dentro de ella la función init.
Bueno, ya hay algo muy curioso acerca de esta función,
y es que hay dos guiones bajos en ambos
lados de la palabra init. Estos guiones bajos son una
forma que Python tiene para decirnos a los programadores ¡hey!
el nombre init, está reservado esencialmente en Python y que
esta es una función o método especial. ¿Qué tiene
de especial init? Lo especial es que inicia o crea
espacio en la memoria para recordar detalles como el título, la trama
etcétera para las nuevas películas que estamos
a punto de crear. Pues bien, init necesita cierta
información o valores. El primero de los cuales
es siempre la palabra clave de Python, self. Bien, se preguntarán
que es esta cosa llamada self. Bueno, se puede
pensar en self como en "sí mismo", o como la instancia que se está creando.
Entonces, cuando ejecutamos esta línea de código en nuestro
otro archivo Python, por cierto, sólo para recordarles que,
aquí estamos tratando de crear una nueva película llamada, toy_story.
Y cuando ejecutamos esta línea de código, sabemos
que se invoca a la función __init__ dentro de la clase Movie. Self,
en ese caso, apunta a toy_story. Bien, tengo que
confesarles algo. Recuerdo que cuando comencé a aprender
programación orientada al objeto hace años en la universidad, este concepto de
self era realmente difícil de entender para mí. Si ese
es el caso con ustedes, no se preocupen
mucho por ahora. Esto se facilitará cuando
ejecutemos todo el código dentro de unos segundos. En
cualquier caso, vamos a añadir la palabra clave self a nuestra lista
de nuevas palabras. De acuerdo, voy a regresar a
la clase Movie y continuaré para definir la función init.
Bueno, queremos que init inicie partes de la información como el título, la trama
y otras que queremos recordar dentro de nuestra clase. Esta es una manera de hacerlo. Voy a
decir, self.title, entonces self.storyline.
El siguiente es, poster_image_url y
finalmente, trailer_youtube_url. Bueno, de alguna manera tenemos que iniciar
estas variables, con la información que init
va a recibir. En particular, va a recibir información
en cuatro partes. La primera de las cuales es
el título de una película, enseguida, la trama de la película,
luego la imagen del póster de la película y
por último, el trailer en YouTube. Entonces, observen, una vez que he
recibido esta información en cuatro partes como valores
de la función __init__, puedo iniciar las variables de mi Movie.
Así es como lo hacemos: self.title es el título
de la película, self.storyline es la trama de la película. Lo siguiente es
la imagen del póster. Por último, el trailer
en YouTube. Bueno, tengo que confesar
algo. Y eso es, que hemos escrito mucho
código que parece nuevo y extraño. Bueno, lo que
puedo decir es que todos debemos
hacer una pausa y respirar profundamente.
[SONIDO] Por ahora, todo lo que quiero que hagan, es
hacer una pausa en el vídeo y anotar este código en su
computadora. Todo este código será coherente tan pronto
como ejecutemos este programa. Bueno, hay un punto clave
que me gustaría destacar, antes de que ejecute esta fracción
del código, lo cual es, que si voy a mi
otro archivo Python, que es entertainment_center.py. Y ejecuto esta fracción
del código, arrojará un error. El error va a suceder
porque cuando tratamos de crear la película Toy
Story, se llama a la función init, que ahora
está buscando varios valores o elementos de información, aunque
de ninguna manera estemos enviando ninguna información. Bueno,
déjenme cambiar eso. De acuerdo, sé que el primer
valor de la función init es self. Lo cual es
agregado por defecto en Python. Por lo tanto, me saltaré
esa parte. El siguiente es movie_title, que sé
es Toy Story, así que agregaré eso. Después de eso, sigue la trama
de la película, así que voy a escribir eso a continuación. La historia de
un niño y sus juguetes que cobran
vida. El siguiente es el poster_image, así que voy a añadir eso.
Previamente entré a Wikipedia y encontré un enlace al póster
de Toy Story y lo añadí. Por último, el avance de YouTube, el cual también añadiré.
Ahí está. Ahora, permítanme desplazarme hacia
atrás para que podamos ver el inicio del
código. Bien, admito que no se puede ver todo
el código, así que lo que he hecho es tomar una
imagen del código y ponerlo en las
notas del instructor para que lo vean. Perfecto,
lo último que voy a hacer es
imprimir la trama de Toy Story. Déjenme guardar este archivo
y regresar a mi archivo de la clase Movie y guardarlo también. Enseguida voy a
regresar a mi archivo entertainment_center.py. Bueno,
si todo va bien, mi programa debe
imprimir toy_story.storyline. Vamos a ejecutarlo. Y ahí
está, la trama de Toy Story se está imprimiendo.
Bien, en el siguiente video
vamos a ver lo que sucede detrás de escenas cuando
ejecutamos esta fracción de código.
ではコードに戻りましょう
Movieクラスがあります
ます＿＿init＿＿関数を定義することから始めます
この関数はかなり変わっていますね
initの両側にアンダースコアが2つずつあります
このアンダースコアが何を意味しているかというと
＿＿init＿＿は基本的にPythonに予約されたもので
特殊な関数やメソッドだということです
＿＿init＿＿の特徴は初期化やメモリに スペースを作ることで
そこにタイトルやあらすじなど
Movieファイルを作るための情報が記憶されます
さて＿＿init＿＿関数は情報や引数を受け取ります
最初は常にPythonの予約語selfで始まります
ではこのselfとは何のことかというと
作成されたインスタンス自体のことです
このコード行を別のPythonファイルで実行します
ちなみに今回の場合は
今作ろうとしてるtoy＿storyですね
このコード行を実行すると
Movieクラスの中にある ＿＿init＿＿関数が呼び出されます
selfは今回の場合toy＿storyを指します
私がオブジェクト指向プログラミングを 初めて勉強したのは
数年前の大学時代のことです
実はselfを理解するのは非常に難しいと感じました
もし今そう感じている方も大丈夫です
このあとコードの全体像を習えば
だいぶ分かりやすくなります
selfも必ず単語リストに追加してください
ではMovieクラスに話を戻しましょう
＿＿init＿＿関数の定義を続けます
それでは＿＿init＿＿関数でタイトルやあらすじなどの
クラスに記憶させたい情報を初期化しましょう
コードはself．title self．storylineと記述します
次にself．poster＿image＿urlと書いて
最後にself．trailer＿youtube＿urlと書きます
それではこの変数を初期化しましょう
＿＿init＿＿関数でこの情報を受け取ります
特にこの4つの情報を取得します
最初の情報はmovie＿title、次はmovie＿storylineです
次にposter＿imageと続き
最後にtrailer＿youtubeです
＿＿init＿＿関数の引数として この4つの情報を取得したら
Movieの変数の初期化が可能になります
やり方としてはself．titleにはmovie＿titleと書き
self．storylineにはmovie＿storyと書きます
次がposter＿imageで 最後がtrailer＿youtubeとなります
率直に言って
たくさんコードを書きましたが
新しくて見慣れないでしょう
私に言えることは1つです
一呼吸置いて深く息を吸いましょう
これから皆さんには
ビデオを止めて自分でコードを書いてもらいます
プログラムを実行すればコードの意味が分かります
コードを実行する前に
重要なことをお伝えしておきます
他のPythonのファイルである entertainment＿center．pyを開いて
このコードを実行するとエラーが返ってきます
インスタンスtoy＿storyを作る時に
＿＿init＿＿関数が呼び出されるためです
この関数が引数や情報を探しているのに
こちらからは情報を送っていません
これを変更しましょう
＿＿init＿＿関数の最初の引数はselfです
Pythonの初期設定なので変更しません
次はmovie＿titleです
ここに「トイ・ストーリー」と記述します
次は映画のあらすじですから隣にこのように書きます
“少年と”
“生命が吹き込まれたおもちゃの物語”
次のposter＿imageはポスターの画像です
Wikipediaで事前に見つけた 「トイ・ストーリー」のポスターのリンクを追加します
最後のtrailer＿youtubeにも YouTubeにある予告編のリンクを追加します
以上です スクロールして戻ると
コードの最初から確認できます
この画面ではコードが一部見えないので
コード全体をコピーして講師メモに載せました
確認したい方はご覧ください
それでは最後に 「トイ・ストーリー」のあらすじを出力します
まずこのファイルを保存します
続いてMovieクラスのファイルに戻って これも保存します
そしてもう一度entertainment＿center．pyに戻ります
プログラムが正しく実行されれば
あらすじが出力されますのでやってみましょう
見てください 無事に出力されました
次はコードを実行する時 裏で何が起きているかを見ていきます
Aqui estou, de volta ao código.
Posso ver a classe Movie, e nela
começarei a definir [SOUND] a função init.
Há algo muito curioso sobre essa função,
que é a presença de dois sublinhados nos dois
lados do termo init. Esses sublinhados são uma
maneira de o Python dizer aos programadores que
o nome init é essencialmente reservado no Python, e que
essa é uma função ou método especial. O que há de
especial no init? A inicialização ou criação de
espaço na memória para lembrar detalhes, como título, história,
etc., para novos filmes que estamos
prestes a criar. O init usa algumas
partes de informações ou argumentos. A primeira delas
é sempre a palavra-chave Python self. Mas o que é
isso que chamamos de self, você pergunta? Bem, você pode
pensar em "self" como "si próprio" ou a instância sendo criada.
Portanto, quando executamos essa linha de código em
outro arquivo Python - a propósito, apenas para lembrá-los,
estamos tentando criar um novo filme chamado toy_story.
Quando executamos essa linha de código, sabemos
que a função init dentro da classe Movie é chamada. Self,
nesse caso, indica toy_story. Tenho que
fazer uma confissão. Lembro-me de quando aprendi pela primeira vez sobre
programação orientada a objeto anos atrás na faculdade. Esse conceito de
self era muito difícil de compreender. Se esse
for o seu caso, não se preocupe
muito com isso no momento. Isso será esclarecido quando
conhecermos toda essa parte da codificação em alguns segundos. De
qualquer maneira, vamos adicionar a palavra-chave self a nossa lista
de palavras novas. Muito bem, vou voltar à
classe Movie e continuar a definir a função init.
Queremos que init inicialize informações, como título, história
, entre outras, que devemos lembrar em nossa classe. Veja uma forma de fazer isso. Vou
escrever self.title e self.storyline.
[SOUND] Depois poster_image_url e,
finalmente, trailer_youtube_url. Temos que, de alguma maneira, inicializar
essas variáveis com as informações que o init
receberá. Nesse caso, ele receberá quatro
informações. A primeira é
o título de um filme, [SOUND] a segunda é a história do filme
depois a imagem do cartaz do filme, e
por fim, o trailer no YouTube. Após
recebermos essas quatro informações como argumentos para
a função init, posso inicializar minhas variáveis de Movie.
Veja aqui como fazer isso. "self.title" é o título do
filme. "Self.storyline" é a história do filme. Depois vem
[SOUND] a imagem do cartaz. E finalmente, [SOUND] o trailer
no Youtube. Tenho uma confissão a fazer
. Criamos muitos
códigos que parecem novos e estranhos. Só posso
sugerir que todos façamos
uma pausa e respiremos fundo.
[SOUND]. Por enquanto, vou interromper
o vídeo e anotar esses códigos no
computador. Todos esses códigos farão sentido
assim que executarmos esse programa. Há um ponto importante
que quero destacar antes de executar esse
código. Se eu acessar o
outro arquivo Python, que é entertainment_center.py, e executar esse
código, ele retornará um erro. O erro ocorrerá
porque, quando tentamos criar o filme toy_story,
a função init é chamada e busca
vários argumentos ou informações, embora
não estejamos enviando qualquer informação para ela.
Vamos alterar isso. Eu sei que o primeiro
argumento para a função de edição é self, que é
adicionado por padrão ao Python. Vamos pular
ele. O próximo é o título do filme,
"Toy Story", que será adicionado. Depois vem a história do
filme, que digitarei a seguir. A história de
um menino e seus brinquedos que ganham
vida. O próximo é a imagem do cartaz, que será adicionada.
[SOUND] Pesquisei anteriormente na Wikipedia e encontrei um link para o cartaz de Toy Story,
que já adicionei, e o trailer no Youtube, que também será adicionado.
[SOUND] Tudo pronto. Vou rolar de
volta para ver o início do
código. Sei que você não pode ver todos os
códigos, por isso, criei uma
imagem do código e inseri nas
Notas do instrutor para você consultar. Muito bem,
só falta
imprimir a história de Toy Story. Vou salvar o arquivo
e voltar ao arquivo de classe Movie e salvá-lo também. Em seguida,
volto mais uma vez ao arquivo entertainment_center.py. Se
tudo estiver correto, o programa deverá
imprimir toy_story.storyline. Vamos executá-lo. Pronto,
a história de Toy Story está sendo impressa.
No próximo vídeo,
veremos o que acontece nos bastidores quando
executamos esses códigos.
那么 我在这儿 回到代码中 然后
这里我看见我的类 movie 然后在里面
我会开始定义 这个函数 init
现在 这个函数有一个特别令人好奇的地方
就是 在单词 init 的两边都有
双下划线 这些下划线是 Python
的一种方式告诉我们 程序员 嘿
这个名字 init 是在 Python 的基本中保留的 于是
这是一个特殊的函数或者方法 init
有什么特殊的呢？ 是这样 它初始化或者在内存中
创建空间 来记住像标题 故事情节 之类
这样的细节 对于我们将要创建的
新的电影实例 现在 init 接收一些
信息或者参数 其第一个
总会是 python 关键字 self 现在
这个调用的 self 是什么呢？ 好吧 你可以
把 self 认为是它自己 或者被创建的实例自己
所以 当我们在其他 Python 文件运行
这行代码 顺便一提 只是为了提醒你
这里我们想要创建一个新的电影叫 toy_story
然后当我们运行这行代码时 我们知道
在类 Movie 中函数 __init__ 被调用 Self
在这个例子中 指向 toy_story 现在 我需要
坦白一件事 我记得多年前在大学时当我
第一次学到面向对象编程 这个 self 的概念
对我来说十分的难理解 如果
你也是这样 现在别太
担心 它会在我们学习这个整个
代码一会儿后变得清晰起来
总之 让我们加上这个关键字 self 到我们的
新词列表中 好的 我将回到
类 movie 并接着定义函数 init
现在 我们想 init 来初始化如标题 故事情节之类的信息和
其他我们想要在类中记得的 一种做到的方法是 我
会调用 self.title 接着 self.storyline
下一个是 poster_image_url
最终 trailer_youtube_url 现在 我们必须初始化
这些变量 与 init 收入的信息
一起 接着尤其是 它将接收 四个
信息 第一个是
电影标题 下一个是 电影故事情节
接着电影的海报
最后 在 Youtube 上的预告 所以 看这个 一旦我
接收到这四个信息并作为参数给
__init__ 函数 我可以初始化我的 Movie 变量
这里是怎么做 self.title 是电影
标题 Self.storyline 是电影故事情节 下一个是
海报图 接着最后 在
youtube 上的预告 现在 我坦白
一下 就是 我们已经写了很多
看上去新且奇怪的代码 好吧 我要说
的一件事是 我们应该
都休息一下并深呼吸
现在 我想让你做的是
暂停这个视频 接着在你的电脑上写下
这个代码 一旦我们运行这个程序这个代码
的一切会变得有道理起来 现在 有一个关键点
我想标起来 在我执行这个
代码前 就是 如果我打开
我的另一个 Python 文件 其为 entertainment_center.py 并运行这个
代码 它会抛出一个错误 这个错误会发生
因为当我们尝试创建电影 玩具
总动员时 init 函数被调用 其现在
在寻找多个参数或者信息 尽管
我们不发送任何的信息 所以
让我改变一下 现在 我知道第一个
edit 函数的参数是 self 其默认
被 Python 添加 所以我会跳过
它 下一个是电影标题 我知道的是
玩具总动员 那么我会添加它 之后 是电影
故事情节 所以我会输入它 一个
男孩和他的活过来的玩具的
故事 下一个是 有力的图像 所以我将加上它
我已经在维基百科上找到一个 玩具总动员的海报
的链接 所以我加上它最后 Youtube 预告 我也加上了
好了 现在 让我滚动回
去使我们可以看到代码的
开始 这里 我发现你不能看到所有的
代码 那么我做的是 用代码的
图像 接着将它放在
导师笔记中以便你看 好的
我要做的最后一件事是
输入玩具总动员的故事情节 让我保存这个文件
接着回到我的类 Movie 的文件 接着保存它 然后
再回来 到我的 entertainment_center.py 文件 现在
这里 如果一切顺利的话 我的程序应该
输出 toy_story.storyline 让我们运行它 接着
看 玩具总动员 故事情节输出了
好的 那么 在下一个视频我们
将看看在屏幕后面发生了什么当
我们运行这个代码
那麼，在這裡，我回到程式碼中，
然後我看見我的movie類別， 接著在裡面
我會開始定義這個名為init的函數。
現在，這個函數有一個特別令人好奇的地方
就是，在 init單字的兩邊都有兩條底線
這些底線是
Python告訴我們程式設計師的方式， 就是，嘿 !
這個名字init ，基本上是預先保留在Python中的，
所以這是一個特殊的函數或是方法。
init這個方法有什麼特殊的呢？是這樣的， 它會初始化或是在記憶體中
建立一塊空間，來記住像標題故事情節，
之類的細節，用於我們將要建立的
新的movies實例。現在 init 接收一些
訊息或者參數。其中第一個
參數是python 關鍵字self 。
現在這個被呼叫的self 是什麼呢？好吧，
你可以把 self 認為是它自己或者被建立的實例。
所以，當我們在其他 Python 文件執行這行代碼時，
順便一提，只是為了提醒你
這裡我們想要建立一個新的電影叫 toy_story。
然後當我們執行這行程式碼時，我們知道
在Movie類別中函數 __init__ 會被呼叫。
而Self參數，在這個例子中指向toy_story 。現在，我需要
坦白一件事，我記得多年前在大學時當我第一次學習
物件導向程式設計，這個 self 的概念
對我來說十分的難理解。
如果你也是這樣，現在別太擔心，
它會在我們學習這個整個程式碼後，
一會兒後變得清晰起來
總之，讓我們加上這個關鍵字self 到我們的
新字彙列表中。好的，我將回到movie類別，
並接著定義 init函數。
現在，我們想用 init 來初始化，如標題、 故事情節之類的訊息和
其他我們想要在類別中記下的。有一種能做到的方法是，我
會呼叫self.title 接著呼叫self.storyline。
下一個呼叫 poster_image_url，
最終是呼叫 trailer_youtube_url 。現在，我們必須初始化這些變數，
與 init 接收的參數。
接著尤其是它將接收四個參數。
第一個是電影標題，
下一個是電影故事情節，
接著電影的海報
最後，是在 Youtube 上的預告。所以在這裡，一旦我
接收到這四個訊息並當作為參數給__init__ 函數，
我就可以初始化我的Movie變數。
這裡是怎麼做的。 self.title， 是電影標題
Self.storyline 是電影故事情節。 下一個是
海報圖。接著最後，在youtube 上的預告。
現在，我承認，
我們已經寫了很多
看上去新奇古怪的程式碼。 好吧， 我要說
的一件事是，
我們應該都休息一下，並深呼吸
現在，我想讓你做的是
暫停這個影片， 接著在你的電腦上寫下
這個程式碼， 一旦我們執行這個程式的程式碼
這一切會變得有道理起來。現在， 有一個關鍵點
我想標記起來。在我執行這個程式碼前，
就是，如果我打開我的另一個 Python 文件
entertainment_center.py ，並執行這個程式碼。
它會拋出一個錯誤。這個錯誤會發生，
因為當我們嘗試建立電影、 玩具總動員時，
init 函數被呼叫，
它現在在尋找多個參數或者訊息，
儘管我們不發送任何的訊息，
所以讓我改變一下，現在，我知道
__init__ function函數的第一個參數是self，
它是預先定義在Python裡的。所以我會跳過它。
下一個是電影標題，我知道的是
玩具總動員，那麼我會加入它，之後是電影
故事情節 ，所以我會輸入，
一個男孩和他活過來的玩具的故事
下一個是形像圖片， 我也會把它加入
我已經在維基百科上找到一個，玩具總動員的海報
的連結，把它加入，最後 Youtube 預告，我也加上了
好了。現在，讓我將頁面滾動回去
使我們可以看到程式碼的開始
這裡，我認為你不能看到所有的程式碼，
那麼我會將程式碼和有用到的圖片檔案，
放在導師筆記中，
方便你看。好的
我要做的最後一件事是
輸入玩具總動員的故事情節。讓我儲存這個文件
接著回到我的Movie類別的文件。接著儲存， 然後
再回來到我的 entertainment_center.py 文件，
現在，如果一切順利的話，我的程式應該
輸出 toy_story.storyline 。讓我們執行一下。
接著看，玩具總動員故事情節輸出了。
好的，那麼，在下一個影片我們將看看，
當我們執行這個程式碼時，
在螢幕後面(後端)發生了什麼。