So in a previous lesson we created a class
called movie. Now this class had the following attributes,
the movie's title, its storyline, a link to the
movie's poster image, and a link to its YouTube
trailer. Now in addition to these things, the class
movie also had a function called show_trailer. After we
had defined this class movie we created several instances
of this class. Instances like Toy Story and Avatar.
Now further imagine that we wanted to create
another class called TvShow. I would think that
this class would have details like the title
of the show, its season and episode number. And
also, the TV station that this show is
aired on. Additionally, this class could also have
a function called, get_local_listings. Once we've created a
class called TvShow, we can create multiple instances of
this class, instances like, season one, episode one
of Breaking Bad, and the final episode of Seinfeld.
Alright, so if we continue our thought experiment
here, we can further imagine that there can be
several items that both of these classes can
share amongst each other. Things like title for sure,
also things like duration of the movie and
duration of the TV show in minutes. So the
best way to structure this code would be
to create another class called Video, which would
have two attributes. The video's title, and the
video's duration. And the class Movie, could inherit from
this class Video. To do this, we would
have to add the class name Video, inside these
parentheses. Now, this would mean that class Movie,
would inherit title and duration, from class Video. Additionally,
the class TvShow could also inherit from class
Video. To do this we would also have
to add the class name Video inside these
parentheses. Now this would mean that class TvShow would
inherit title and duration from class video. Now
you can clearly see how we can write a
piece of code. In this case, class Video,
and continue to reuse it in multiple different places.
Another big benefit of writing code this way,
in addition to just reusing code, is that
it allows us to follow an intuitive model
of how things exist in our brain. So intuitively
speaking, we know what videos are, we also know what TV shows and movies are. So
writing code in this way allows programmers to
map how things exist in our brain onto code.
حسنًا، في درس سابق أنشأنا فئة
،تسمى الفيلم. الآن تحتوي هذه الفئة على السمات التالية
عنوان الفيلم وقصته ورابط إلى
صورة ملصق الدعاية ورابط إلى العرض الترويجي للفيلم
على موقع YouTube. الآن إلى جانب هذه السمات، كانت
فئة الفيلم تحتوي على دالة تسمى show_trailer. وبعد
أن حددنا فئة الفيلم هذه، أنشأنا مثيلات متعددة
.من هذه الفئة. مثيلات مثل Toy Story وAvatar
تخيلوا الآن أيضًا أننا نريد إنشاء
فئة أخرى تُسمى TvShow. اعتقد أن
هذه الفئة ستحتوي على تفاصيل مثل عنوان
البرنامج وموسمه ورقم الحلقة. و أيضًا
القناة التليفزيونية التي يُبث من خلالها ،
هذا البرنامج. بالإضافة إلى ذلك، يمكن أن تحتوي هذه الفئة أيضًا على
دالة تُسمى get_local_listings. بمجرد إنشاء فئة
تُسمى TvShow، يمكننا إنشاء مثيلات متعددة منها
مثيلات مثل، الموسم الأول والحلقة الأولى ،
.من Breaking Bad والحلقة الأخيرة من Seinfeld
حسنًا، إذا واصلنا تجربتنا الذهنية
يمكننا أن نتخيل أيضًا وجود عناصر متعددة ،
يمكن لكلا الفئتين
،الاشتراك فيها. عناصر من قبيل؛ العنوان، بالتأكيد
،ومدة الفيلم
،ومدة البرنامج التليفزيوني بالدقائق. حسنًا
أفضل طريقة لبناء هذه التعليمة البرمجية
هي إنشاء فئة أخرى تُسمى Video، تحتوي على
،سمتين. عنوان الفيديو
ومدة الفيديو. ويمكن لفئة Movie، أن ترث من
فئة Video هذه. لفعل هذا، يجب
إضافة اسم الفئة Video داخل هذه
،الأقواس. الآن، يعني هذا أن فئة Movie تلك
،سترث العنوان والمدة من فئة Video. بالإضافة إلى ذلك
يمكن للفئة TvShow أن ترث أيضًا من الفئة
Video. لفعل هذا، يجب علينا أيضًا
إضافة اسم الفئة Video داخل هذه
،الأقواس. الآن هذا يعني أن فئة TvShow تلك
،سترث العنوان والمدة من فئة Video. حسنًا
يمكنكم أن تروا بوضوح كيف يمكننا كتابة
،جزء من تعليمة برمجية، في هذه الحالة، فئة Video
.ومتابعة إعادة استخدامها في العديد من الأماكن المختلفة
،هناك فائدة كبيرة أخرى من كتابة التعليمة البرمجية بهذه الطريقة
،إلى جانب مجرد إعادة استخدام التعليمة البرمجية
أنها تسمح لنا بمتابعة نموذج بديهي
،للكيفية التي توجد بها الأشياء في عقولنا. بديهيًا
نحن نعرف ما هي مقاطع الفيديو، ونعرف أيضًا ما هي البرامج التليفزيونية والأفلام. إذن
كتابة التعليمة البرمجية بهذه الطريقة، يتيح للمبرمجين
.تخطيط طريقة وجود الأشياء في عقولهم ونقلها في شكل تعليمة برمجية
Bien, en una lección anterior creamos una clase
llamada Movie. Bueno, esta clase tenía los siguientes atributos,
título de la película, su trama, un enlace a la
imagen del póster de la película y el enlace a su
tráiler de YouTube. Además de estas cosas, la clase
Movie también tenía una función llamada show_trailer. Después de que
definimos esta clase Movie creamos varias instancias
de esta clase. Instancias como, Toy Story y Avatar.
Bien, imaginemos además que queríamos crear
otra clase llamada TvShow. Pensaría que
esta clase tendría detalles como el título
del programa, su temporada y el número episodio. Y
también, el canal de televisión que transmite
el programa. Además, esta clase también podría tener
una función llamada, get_local_listings. Una vez que creamos una
clase llamada TvShow, podemos crear instancias múltiples de
esta clase, instancias como, primera temporada, episodio uno
de Breaking Bad y el último episodio de Seinfeld.
Perfecto, si continuamos con nuestro experimento mental,
podemos imaginar, además, que puede haber
varios artículos que ambas clases pueden
compartir entre sí. Cosas como el título por supuesto,
también la duración de la película y
la duración del programa de televisión en minutos. Entonces, la
mejor manera de estructurar este código sería
crear otra clase llamada Video, que tendría
dos atributos. El título del video y su
duración. Y la clase Movie podría heredar de
esta clase Video. Para esto, tendríamos
que añadir el nombre de la clase Video dentro de estos
paréntesis. Ahora, esto significaría que la clase Movie,
heredaría el título y duración de la clase Video. Adicionalmente,
la clase TvShow también podría heredar de la clase
Video. Para esto, también tendríamos
que añadir el nombre de la clase Video dentro de estos
paréntesis. Bueno, esto significaría que la clase TvShow
heredaría el título y la duración de la clase Video. Ahora
pueden ver claramente como podemos escribir una
parte del código, en este caso la clase Video,
y seguir reutilizándolo en múltiples lugares diferentes.
Otro gran beneficio de escribir código de esta manera,
además de solo reutilizar el código, es que
nos permite seguir un modelo intuitivo
de cómo existen las cosas en nuestro cerebro. Así que hablando
intuitivamente, sabemos que son los vídeos, sabemos también que son los programas de televisión y las películas. Entonces,
escribir código de esta manera le permite a los programadores
hacer un mapa de cómo existen las cosas en nuestro cerebro al escribir código.
以前の講義で作成したMovieクラスの属性は 次のとおりです
映画のtitle、storylineと
poster＿imageとyoutube＿trailerです
この4つの属性に加えて
Movieクラスにはshow＿trailerという関数もありました
Movieクラスを定義したあと クラスのインスタンスをいくつか作りました
「トイ・ストーリー」や「アバター」の インスタンスです
次は他のクラスを作りましょう
名前はTvShowです
このクラスに必要な情報は
番組のタイトルやシーズン、話数 オンエアされる放送局などです
さらにこのクラスには
get＿local＿listingsという関数も必要です
TvShowのクラスを作成したら 複数のクラスインスタンスも作ります
例えば「ブレイキング・バッド」の シーズン1の第1回目とか
「となりのサンフェイルド」の最終回などの インスタンスです
いろいろな方向から
他に項目がないか考えてみましょう
例えば2つのクラスで共通するクラスはあるでしょうか
タイトルがそうですね
映画やテレビ番組の尺もそうです
コードを作成する一番いい方法は
Videoクラスという別のクラスを作ることです
ビデオのタイトルと長さの2つの属性を持たせます
MovieクラスはVideoクラスを継承できます
そのためにはVideoという名前を 括弧の中に追加します
そうすればMovieクラスは
Videoクラスからタイトルと長さを継承します
TvShowクラスも Videoクラスを継承することができます
括弧内にVideoという名前を追加すれば
TvShowクラスは Videoクラスのタイトルと長さを継承します
これでコードの書き方が分かったと思います
これでVideoクラスは
複数の場所で再利用されます
このようなコードの書き方のいい点は
コードを再利用できることに加えて
頭の中の直感的なアイデアに従うことができることです
直感的にVideoの内容が分かり TVやMovieも理解できるのです
プログラマはこのようにコードを書くことで
頭の中のアイデアをコードに変換することができます
Em uma lição anterior, criamos uma classe
chamada Movie. Essa classe tinha os seguintes atributos:
o título e a história do filme, um link para
a imagem do cartaz do filme e um link para o trailer no YouTube
. Além desses itens, a classe
Movie também tinha uma função chamada show_trailer. Após
definirmos essa classe, criamos várias instâncias
dela. Instâncias como toy_story e avatar.
Agora, imagine ainda que desejássemos criar
outra classe chamada TvShow. Acho que
essa classe teria detalhes como título
do programa, temporada e número do episódio, bem
como o canal de TV que exibe esse
programa. Essa classe também poderia ter
uma função chamada get_local_listings. Após criarmos uma
classe chamada TvShow, poderemos criar várias instâncias dessa
classe, como o primeiro episódio da primeira temporada
de Breaking Bad e o episódio final de Seinfeld.
Continuando com nosso experimento,
podemos imaginar ainda que possa haver
vários itens que essas duas classes
compartilhem. Itens como o título,
a duração do filme e a
duração do programa de TV em minutos. A melhor
forma de estruturar esse código seria
criar outra classe chamada Video, com
dois atributos: O título e a
duração do vídeo. A classe Movie poderia herdar itens dessa
classe Video. Para tanto, seria necessário
adicionar o nome de classe Video entre
parênteses. Isso significaria que a classe Movie
herdaria o título e a duração da classe Video. Além disso,
a classe TvShow também herdaria itens da classe
Video. Para tanto, também seria necessário
adicionar o nome de classe Video entre
parêntese. Isso significaria que a classe TvShow
herdaria o título e a duração da classe Video. Você
pode ver claramente como é possível escrever
um código, neste caso, a classe Video,
e reutilizá-lo em vários pontos diferentes.
Outra grande vantagem de escrever códigos dessa forma,
além de reutilizá-los, é que
isso nos permite seguir um modelo intuitivo
de organização do nosso cérebro. Assim, intuitivamente,
sabemos o que são vídeos, programas de TV e filmes. Portanto,
escrever códigos dessa maneira possibilita aos programadores
reproduzir nos códigos a organização em nossa cabeça.
在之前的一节课中 我们创建了
一个名为 movie 的类 这个类有以下属性
电影的名称、故事情节、
海报图片的链接及 YouTube 预告片
链接 除了这些外 类
movie 还有一个名为 show_trailer 的函数 在
我们定义了类 movie 后 我们创建了
该类的几个实例 如 Toy Story 和 Avatar
现在 想象一下我们想创建
另一个名为 TvShow 的类 这个
类会有这样一些详细信息 如电视剧
名称、季数和集数 然后
还有播放这个电视剧的
电视台 除此之外 这个类还有
一个函数 名为 get_local_listings 在我们创建了
类 TvShow 后 我们可以创建该类的
多个实例 如 Breaking Bad 第一季
第一集 Seinfeld 最后一集
好的 如果我们继续这个思考实验
我们可以进一步想象这两个类
有几个项是
可以共享的 名称肯定算一个
还有电影和电视剧的
持续分钟数 要构造这个
代码 最好的方式
就是创建另一个名为 Video 的类 它会有
两个属性 视频的名称和
持续时间 类 Movie 可以继承
类 Video 要做到这一点 我们
必须在这些括号内
加入类名 Video 这就意味着类 Movie 将
从类 Video 继承名称和持续时间 而且
类 TvShow 也可以继承类
Video 同样 我们也得
在这些括号中加入
类名 Video 这就意味着类 TvShow 将
从类 video 继承名称和持续时间 现在
你可以清楚地看见我们编写了
一条代码 在这个情形中 类 Video
并继续在多个不同的地方重用它
这些写代码的另一个好处是
除了重用代码外 它还
允许我们遵从我们大脑中
事物存在的直觉模式 从直觉
方面来说 我们知道视频是什么 电视剧和电影是什么 所以
以这种方式编写代码可以使程序员将
我能大脑中存在的东西映射到代码中
所以在上一堂課程中， 我們建立了一個類別名稱為movie。
現在這個類別有以下的屬性
電影的名稱、故事情節，一個電影海報圖片的連結
及YouTube 預告片的連結
除此之外，這個movie類別
還有一個函式叫做show_trailer。
接著在我們定義了movie 類別後，我們在類別內
建立了幾個實例 如:Toy Story 和 Avatar。
現在，想像一下我們想建立
另一個名為 TvShow 的類別。
這個類別會有這樣一些詳細資訊，如電視劇名稱
季數和集數。
然後還有播放這個電視劇的電視台
除此之外，這個類別還有
一個函數名為 get_local_listings ，
在我們建立了TvShow類別後， 我們可以建立這個類別的多個實例
如 Breaking Bad 第一季第一集
和 Seinfeld 最後一集
好，如果我們繼續這個實驗
我們可以進一步想像這兩個類別
有幾個項目是在兩個類別中可以共享的。
名稱title肯定算一個
還有電影和電視劇的片長
要建構這個程式碼
最好的方式是
建立另一個類別名稱為Video，
它會有兩個屬性。影片的名稱，和影片片長
接著Movie類別，可以繼承自Video類別
要做到這一點，我們必須
在這些括號內加入Video類別，
這就意味著Movie類別
將從 Video 類別繼承名稱和片長。
而且TvShow類別也可以繼承自Video類別
同樣，我們也得
在這些括號中加入Video類別
這就意味著TvShow類別，
將從 video類別繼承名稱和片長。
現在你可以清楚地看見我們撰寫了一段程式碼。
在這個情形中，Video類別，
繼續在多個不同的地方重覆利用它
寫這些程式碼的另一個好處是，
除了重覆利用程式碼外，
它還能夠遵循我們大腦
對處理事物方式的直覺。
直觀來說，我們知道影片是什麼，電視劇和電影是什麼。
所以以這種方式撰寫程式碼可以讓程式設計師將
大腦中存在的東西映射到程式碼中