
Korean: 
이 강의의 한국어자막은 www.snow.or.kr 자원활동가들에 의해 작성되었습니다.
이 강의의 한국어자막은 www.snow.or.kr 자원활동가들에 의해 작성되었습니다. 다음 내용은 저작권으로 보호되어 있습니다. 
이 강의의 한국어자막은 www.snow.or.kr 자원활동가들에 의해 작성되었습니다. 다음 내용은 저작권으로 보호되어 있습니다. 
MIT OCW(무료공개강좌) 는 계속해서 고품질의 교육자원을  
무료로 제공함으로써 여러분을 도와줄 것입니다. 
추가적인 MIT 코스의 자료를 보거나
기부하시려면 ocw.mit.edu을 방문해주세요.
지난 시간에, 구탁 교수가 객체와 
클래스에 대한 생각과 객체 지향 프로그래밍이라는 
이 훌륭한 구문을 소개 했습니다
그리고 그것은 제가 오늘 꺼내려고 하는 주제 입니다, 우리는 다음
몇 강의 동안 할 것 입니다, 그리고 그것은 제가 시간을 
쏟고 싶은 주제 입니다 왜냐하면 데이터와 메소드들을 포착하는 이 생각, 
우리가 그것을 위해 사용 할 용어, 그러나 그 데이터에 속하는 함수들과 데이터,
그것들을 만들어 내는데 사용 될 수 있는 것들,
이것들은 정말 강력한 것 이기 때문 입니다.
우리가 정말 얻으려고 하는 것은 제가 정보를 의미 있는 
단위들로 함께 그룹 짓는 방법을 가지고 싶어 한다고 
말하는 생각 입니다. 

English: 
OPERATOR: The following content
is provided under a
Creative Commons license.
Your support will help MIT
OpenCourseWare continue to
offer high quality educational
resources for free, To make a
donation or view additional
materials from hundreds of MIT
courses, visit MIT
OpenCourseWare at ocw.mit.edu.
PROFESSOR: Last time, Professor
Guttag introduced
the idea of objects and classes
and this wonderful
phrase called object-oriented
programming.
And it's a topic I want to pick
up on today, we're going
to do for the next few lectures,
and it's a topic I
want to spend some time on
because this idea of capturing
data and methods, the term we're
going to use for it, but
data and functions that belong
to that data, things that can
be used to manipulate them,
is a really powerful one.
What we're really getting at is
the idea of saying I want
to have a way of grouping
together information into
units that make sense.

English: 
So I can go back to one of those
topics we had at the
beginning, which is the idea
of abstraction, that I can
create one of those units as a
simple entity, bury away the
details and write really
modular code.
And so we're going to
talk about that a
lot as we go along.
What we're really doing, or
I shouldn't say what we're
really doing, a basic piece of
what we're doing, when we talk
about classes or objects, is
we're doing something that
Professor Guttag mentioned,
we're defining an
abstract data type.
Now what in the world
does that mean?
Well basically what we're
doing is we're giving
ourselves the ability to create
data types the same way
that we have some built-ins,
so we have things like int,
float, string, these are
built-in data types.
And if you think about it,
associated with each one of
those data types is a set
of functions it's
intended to apply to.
Sometimes the functions --
sometimes a function can be
used on multiple data types,
plus, for example, we saw
could add strings, or could
add ints, but each one of
those data types has associated
with it a set of

Korean: 
그래서 저는 우리가 시작에서 가졌던 이 주제들 중 하나로 돌아 올 수 있습니다, 
그것은 추상화의 개념 입니다, 그것은 제가 
그런 단위들 중 하나를 단일한 개체로 만들 수 있고, 자세한 것은 묻어 두고 
정말로 모듈적인 코드를 쓸 수 있는 것 입니다. 
그리고 그래서 우리는 우리가 해 나가면서 그것에 대해
많이 이야기 할 것 입니다. 
우리가 클래스와 객체들에 대해 이야기 할 때, 우리가 정말 하는 것, 또는 우리가 
정말 하고 있다고 말할 수는 없는,
우리가 하고 있는 기본 적인 것들, 그것은 구탁 교수가 
언급 했던 것을 하는 것입니다, 추상 데이터 타입을 정의하는 것이죠. 
이제 세계에서 그것이 의미 하는 것은 무엇이죠? 
자 기본적으로 우리가 하려고 하는 것은 우리가 우리 스스로에게
스스로에게 데이터 타입을 만드는 능력을 주는 것 입니다, 
우리가 어떤 내장 된 것을 가졌던 것과 같은 방식으로요, 그래서 우리는 int, float, string
과 같은 것을 가집니다, 이것들은 내장 데이터 타입 입니다. 
그리고 여러분이 그것에 대해 생각해 보면, 이 데이터 타입들과 관련 된 각각의 
것은 그것이 적용하려고 하는 
함수들의 세트 입니다.
때때로 함수들은 – 때때로 함수는 
다양한 데이터 타입, 더하기 에 사용 될 수 있습니다, 예를 들어, 우리는
문자열을 더하거나, 또는 정수들을 더할 수 있는 것을 봅니다, 그러나 
그 데이터 타입들 중 각각은 그것과 연관 되어 있습니다, 

English: 
functions that are geared
to handling them.
We want to do the same thing,
but with our data types.
We want to create data types and
functions, or we're going
to call them methods, that
are specifically aimed at
manipulating those
kinds of objects.
And our goal is then to
basically see how we can build
systems that take advantage
of that modularity.
Right, so the fundamental idea
then, is, I want to glue
together information, I want
to take pieces of data that
naturally belong together, glue
them together, and attach
some methods to it.
And that's, you know, saying
a lot of words, let's do an
example because it's probably
easiest to see this by looking
at a specific example.
So here's the example I'm
going to start with.
Suppose I want to do little
piece of code that's going to
do planar geometry, points
in the plane.
All right, so I want to have
some way of gluing those
things together.
Well you know what a point is,
it's got an x- and a y-
coordinate, it's natural to
think about those two things
as belonging as a
single entity.

Korean: 
그것들을 다루고자 하는 함수들의 세트 입니다. 
우리는 우리의 데이터 타입으로도 같은 것을 하길 원합니다,
우리는 데이터 타입과 함수들, 혹은 메소드라고 
부르는 것을 만들길 원합니다, 그것들은 구체적으로
그 종류의 객체들을 만들어 내는 것이 목적 입니다. 
그리고 우리의 목표는 그리고 나서 기본적으로 우리가 어떻게
그 모듈 방식에 이점이 되는 시스템을 구축 할 수 있는지 보는 것 입니다.
좋아요, 그래서 근본적인 생각은, 제가 정보를 함께 붙이길 
원한다는 것 입니다, 저는 원래 함께 속한 데이터들을 가지고,
그것들을 함께 붙여서, 그것에 
어떤 메소드들을 부착하길 원합니다. 
그리고 그것은, 여러분이 알다시피, 설명할 것이 아주 많습니다,
예를 들어 봅시다 왜냐하면 이것을 구체적인 예로 살펴 보는 것이 
아마 가장 쉬울 테니까요. 
그래서 여기에 제가 시작 하려고 하는 예가 있습니다.
저는 평면의 기하학을 하는, 면위의 점을 
의미하는 약간의 코드를 쓰고 싶습니다. 
좋아요, 그래서 저는 이것들을 함께 붙이는
어떤 방식을 가지길 원합니다. 
자 여러분은 점이 무엇인지 알고 있습니다, 그것은 x 좌표를 가집니다 
– 그리고 y 좌표를 가집니다, 이 두 가지를 단일한 개체에 
속하는 것으로 생각하는 것은 자연스럽습니다. 

English: 
So an easy way to do this would
be to say, let's just
represent them as a list.
Just as a 2-list,
or a list of 2 elements.
It's easy to think of a point as
just a list of an x- and a
y- coordinate.
OK, for example, I might say
point p1 is that list, x is 1,
y is 2. in fact, if I draw
a little simple -- it's
basically pointing to that point
in the plane, right, x
is 1, y is 2.
OK, fine, there's another way
to represent points on the
plane now, and that's in
polar form, so this, if
you like, is Cartesian.
Another way to represent a point
in a plane is I've got a
radius and I've got an angle
from the x-axis, right, and
that's a standard thing
you might do.

Korean: 
그래서 이것을 하는 쉬운 방법은 말하는 것 입니다, 
그것들을 리스트로 나타냅시다 라고요
2-list 처럼, 또는 2 요소들의 리스트 처럼요. 
점을 x 좌표, 그리고 y 좌표의 리스트로 생각하는 것은 
쉽습니다. 
좋아요, 예를 들어, 저는 점 p1 이 x 가 1 이고, 
y 가 2인 리스트 라고 말할 수 있습니다. 사실, 만약 제가 간단하게 그려보면 
– 그것은 기본적으로 평면에서 그 점을 가리키는 것 입니다, 그래요, x 는 1 이고, y 는 2 입니다. 
네, 좋아요, 이제 평면에서 점을 나타낼 수 있는
또 다른 방법이 있습니다, 그것은 극좌표의 형태입니다. 
이것은 데카르트 (Cartesian)의 좌표 입니다.(극좌표와 다른개념).
점을 평면에서 나타낼 수 있는 또 다른 방법은 제가 
반지름을 갖고, 제가 x 축으로부터의 각을 갖는 것 입니다, 네, 
그리고 그것은 여러분이 할 표준적인 것 입니다. 

Korean: 
그래서 저는 정의할 수 있습니다, 예를 들어, 극좌표 형태 p 2 에서,
자 봅시다, 제가 여기서 어떤 예를 했었을 까요, 우리는 이것을 
반지름 2 그리고 각도 pi 나누기 2 의 점으로 만들 것 입니다. 저는 그것을 쉽게 만들 것 입니다 
왜냐하면 pi 나누기 2는 이 축을 따른 것이기 때문 입니다, 
그리고 그것은 기본적으로 그 점 입니다.
네, 좋아요, 그것은 큰 문제가 아닙니다. 
그러나 여기 이제 문제가 있습니다
저는 이것들을 붙였습니다 그러나 단지 리스트를 사용해서요.
제가 여러분에게 이 리스트들 중 하나를 건네 준다고 가정해 보세요.
여러분은 그것이 어떤 종류 인지 어떻게 알죠? 
여러분은 그것이 데카르트의 형태인지 
아니면 평면 형태인지 어떻게 알죠?
여러분은 거기서 그것을 나타 내는 것을 아무 것도 가지고 있지 않습니다, 
여러분은 이 그룹화하는 것이 실제로 무엇을 의미하는지 말할 방법이 없습니다. 
좋아요, 그리고 이것의 의미를 들어가 보면, 간단한 작은 예를 봅시다, 
그래서 여러분의 핸드 아웃에, 여러분은 제가 작은 코드를 
써둔 것을 볼 수 있을 겁니다, 그것은 제가 이 점들 중 하나를 
가진다고 가정 했을 때, 제가 그것을 가지고 무엇을 하길 원한다고 말합니다, 예를 들어 
제가 그것들을 함께 더하길 원하는 것 같은 거요.
그래서 여기 있는 이 첫 번째 작은 코드는, 네 여러분은 

English: 
So I might define, for example,
in polar form p 2,
and let me see, which example
did I do here, we'll make this
the point of radius 2 and at
angle pi by 2, I'm going to
make it easy because pi by 2
is up along this axis, and
that's basically that point.
Ok, just fine, it's
no big deal.
But here now becomes
the problem.
I've glued things together but
just using a list. Suppose I
hand you one of these lists.
How do you know which
kind it is?
How do you know whether
it's in Cartesian
form or in polar form?
You have nothing that identifies
that there, you
have no way of saying what this
grouping actually means.
Right, and just to get a sense
of this, let's look at a
simple little example, so on
your hand-out, you'll see I've
got a little piece of code that
says assuming I've got
one of these points, I want to
do things with it, for example
I might want to add
them together.
So this first little piece of
code right here says, ok you

Korean: 
저에게 2 개의 점을 주었습니다, 저는 이 리스트들의 또 다른 점 을 만들 것 입니다 그리고 
저는 단순히 x 를 가지고 할 것 입니다, x 라고 확실히 말 할 수는 없지만, 저는
그것이 x 라고 가정할 것 입니다, x 값들은 두 점을 가집니다, 그것들을 함께 더하세요, 
바로 저기서요, 그리고 y 값들도 함께 더하세요 그리고
그 리스트를 리턴 하세요.
그리고 만약 제가 실제로 이것을 실행하면, -미안해요
그것을 다시 하겠습니다 – 네, 여러분은 제가 함께 더하고
r의 값을 출력 해 온 것을 볼 수 있을 것 입니다, 그리고 저는 여러분에게 
제가 가진 것이 그것이라는 것을 보여 줄 것 입니다. 
이것은 좋아 보입니다, 네, 저는 옳은 것을 하고 있습니다,
그것을 말하는 또 다른 방법은, 제가 실제로 말했었는데, 제가 거기서 
사용한 것은, (1,2) 그리고 (3,1) 입니다. 그것은 기본적으로
첫 번째 점이 있고, 두 번째 점이 있다는 것을 말합니다, 그것들을 함께 더하고 
저는 그 점을 얻습니다.
네, 그것은 좋게 들리는군요. 
이제, 사실 x 와 y 가 함께 붙어 있지 않다고 가정해 보세요
이것들은 반지름과 각도가 함께 붙어 있는 것 이었습니다.

English: 
give me 2 points, I'll create
another 1 of these lists and
I'll simply take the x, sorry
I shouldn't say x, I'm going
to assume it's the x, the
x-values are the two points,
add them together, just right
there, the y-values, add them
together and return that list.
And if I actually run this,
which I'm going to do -- excuse
me, do it again --
OK, you can see that I've
added together and I've
printed out the value of r, and
I'll just show you that in
fact that's what I've got.
This looks fine, right, I'm
doing the right thing.
Another way of saying it is,
I've actually said, what did I
use there, (1,2) and (3,1), It's
basically saying there is
the first point, there's the
second point, add them
together and I get that point.
OK, that sounds fine.
Now, suppose in fact these
weren't x and y glued
together, these were radius
and angle glued together.

Korean: 
그 경우에서 점 p 1 은 이 점과 일치 하지 않습니다, 그것은 
실제로 반지름 2 그리고 각도 1 의 점과 
일치 합니다, 그것은 여기 쯤에 있습니다. 
저는 제가 이것을 주의 깊게 써서
옳게 했다고 확신 합니다.
미안해요, 잘 못 말했네요, 반지름 1 그리고 각도 2 입니다, 2 라디언은
파이의 절반 보다 약간 더 작습니다. 
그리고 두 번째 점은 반지름 3 그리고 각도 1 입니다,
그것은 저기즈음에 있지요
그래서 무슨 점, 미안해요, 나쁘군요, 제가 여기서 만들려고 하는 
점은 무엇인가요? 
그것이 의미하는 것에 대한 다른 이해들이 여러분에게
다른 값들을 줍니다, 그리고 그것이 약간 문제 입니다.
두 번째 문제는, 실제로 제가 평면에 있는 p 1 과 p 2 를 
가진다고 가정해 보세요, 그리고 저는 그것들에서 두 점을 더했습니다. 
여기 이 작은 코드가 제가 한 것 입니다.
그것이 말이 되나요? 
당연히 아닙니다, 그렇죠?
여러분은 여러분이 2 개의 극좌표형태 을 더할 때, 여러분이 반지름들을

English: 
In that case point p 1 doesn't
correspond to this point, it
actually corresponds to the
point of radius 2 and angle 1,
which is about here.
I think I wrote this down
carefully so I would make sure
I did it right.
Sorry, said that wrong, radius
1 and angle 2, 2 radians is a
little bit more than pi half.
And the second point is of
radius 3 and angle 1, which is
up about there.
So what point, sorry, bad
pun, what point am I
trying to make here?
Different understandings of what
that piece means gives
you different values, and that's
a bit of a problem.
The second problem is, suppose
actually I had p 1 and p 2
were in polar form, and I
ran add points on them.
This little piece of code
here that I did.
Does that even make any sense?
Course not, right?
You know when you add 2 polar
forms, you add the radii

English: 
together, you don't add the
angles together, you need to
do it in Cartesian form.
So what I'm leading up to here
is that we've got a problem.
And the problem is, that we want
to build this abstract
data type, but we'd like to
basically know what kind of
object is it, and what functions
actually belong to
it, how do we use them?
And so I'm going to go back to
this idea of a class, and
let's build the first of these,
and that is shown right
here on this piece
of your handout.
I'm going to define a class,
and in particular, what I'm
going to do, is walk through
what that says.
So I'm going to now build
an object, it's going to
represent a point.
So what does that thing
say up there?
It's got this funky looking
form, right, it says, I've got
something that I'm going to
call a class, got that key
word class right here.
And I'm going to give it a name,
and right now I'm just

Korean: 
함께 더합니다, 여러분은 각도들을 함께 더하지 않습니다, 여러분은 
데카르트의 형태에서 그것을 할 필요가 있습니다. 
그래서 제가 여기까지 이끌어 오고 있는 것은 우리가 문제를 가지고 있다는 것입니다. 
그 문제는, 우리가 이 추상 데이터 타입을 만들고 싶은데, 
우리는 객체가 무엇인지 기본적으로
알고 싶습니다, 그리고 어떤 함수들이 실제로 그것에 속하는지 
알고 싶은것입니다, 우리가 어떻게 그것들을 사용 하나요? 
그리고 그래서 저는 클래스의 시작으로 돌아와서, 이것의 첫 번째를 
생각해보도록 합시다, 그리고 그것은 여기 여러분의
핸드 아웃 이곳에서 바로 보여 집니다. 
저는 클래스를 정의하고 싶습니다. 그리고 특히, 제가 
하려고 하는 것은 그것이 말하는 것을 보여 주는 것 입니다. 
그래서 제가 지금 객체를 구축할 것 입니다, 
그것은 점을 나타낼 것 입니다. 
그래서 그것이 여기서 무엇이라고 말하고 있나요? 
그것은 이 재미 있게 보이는 형태를 갖습니다, 네, 그것은 말합니다, 저는 
제가 클래스라고 불리는 것을 가집니다, 바로 여기서 
그 핵심 단어 클래스를 갖습니다. 
그리고 제가 그것에 이름을 줄 것 입니다, 그리고 이제 저는 

Korean: 
그것의 간단한 것을 만들 것 입니다 – 그러나 무엇 보다도,
클래스가 무엇을 하나요? 
이것이 객체의 인스턴스들을 만드는 템플릿 이라고
생각해 보세요.
바로 지금, 그것은 정말 바보 같은 템플릿 입니다. 
저는 곧 그것에 더할 것 입니다, 그러나 저는 이것에 
만들고 싶습니다. 
바로 지금 그것은 저기서 pass 라고 불리는 두 번째 핵심 단어를 갖습니다,
그것은 여기 함수의 body 부분이 비었다고 말하는
파이썬의 방법 입니다.
좋아요, 우리는 곧 그것에 더할 것 입니다, 그러나 기본아이디어는 
클래스가 인스턴스들을 만들기 위한 템플릿이라는 것 입니다. 
제가 그것을 어떻게 사용 하나요? 
자, 저는 클래스를 함수처럼 부를 것 입니다, 그리고 
여러분은 아래에서 볼 수 있습니다. 
데카르트의 점 (Cartesian point) 이라고 불리는 것을 만들고 저는 그것의 
두 가지 인스턴스들을 만들 것 입니다. c p 1 그리고 c p 2 입니다. 
그것의 형태에 주목 하세요, 바로 
open paren, close paren 에 뒤이어 오는 클래스의 이름 입니다, 
그것을 함수 처럼 다룹니다. 

English: 
building a simple piece of it --
but first of all, what does
a class do?
Think of this as, this is
a template for creating
instances of an object.
At the moment, it's a really
dumb template.
I'm going to add to it in
a second, but I want
to build up to this.
Right now it's got that second
key word there called pass,
which is just Python's way
of saying there's an
empty body in here.
Right,, we're going to add to
it in a second, but the idea
is class is going
to be a template
for creating instances.
How do I use it?
Well, I call class just like
a function, and you
can see that below.
Having created this thing called
Cartesian point, I'm
going to create two instances
of it. c p 1 and c p 2.
Notice the form of it, it's
just the name of the class
followed by open paren,
close paren,
treating it like a function.

Korean: 
그것의 역할은 만드는 것 입니다, c p 1 그리고 c p 2 는 모두
이 타입의 인스턴스들 이며 이 타입의 구체적인 버전들 입니다. 
지금은 이것에 대해 생각 하는 방법이, 제가 그것을 클래스 정의를 호출할 때, 
그것은 가 버리고 그 인스턴스와 일치하는 메모리의 
구체적인 장소를 할당 합니다. 
바로 지금 그것은 비었습니다, 사실 그것은 확실히 비어있지 않습니다, 
그것은 클래스로 돌아 가는 포인터를 가지고 있습니다. 
그리고 제가 그것에 이름을 줄 수 있습니다, 그래서 c p 1 그리고 c p 2 는 모두
그것을 가리킵니다. 
제가 그것을 가지면, 저는 그 변수에 이름을 주는 것을 시작 할 수 있습니다, 
미안해요 아닙니다, 다시 말하면, 저는 어떤 
속성들을 줄 수 있습니다, 저는 이 클래스들에 어떤 특징들을 
줄 수 있습니다
그래서 각 인스턴스는 어떤 내부적인 것을 가지거나 
가질 것 입니다.

English: 
What that does, is that it
creates, c p 1 and c p 2 are
both instances of this
type, specific
versions of this type.
For now the way to think about
this is, when I call that
class definition, it goes off
and allocates a specific spot
in memory that corresponds
to that instance.
Right now it's empty, actually
it's not quite empty, it has a
pointer back to the class.
And I can give a name to that,
so c p 1 and c p 2 are both
going to point to that.
Once I've got that, I can now
start giving some variable
names, sorry not, rephrase
that, I can give some
attributes, I can give some
characteristics to these classes.
So each instance has some
internal, or will have some
internal attributes.

Korean: 
제가 어떻게 여기서 했는지 주목하세요
c p 1 그리고 c p 2 를 만들고, 저는 여기 
이 이상하게 보이는 형태를 가졌습니다. 
그렇게 이상하지는 않아요, 여러분은 전에 그것을 실제로 봤습니다.
거기서 저는 c p 1.x 는 1.0 과 같다고 말했습니다. 
이것이 무엇을 하고 있죠? c p 1은 하나의 인스턴스를 가리킵니다.
그것은 이 클래스의 특정한 버전을 가리킵니다. 
그리고 저는 이제 내부의 변수명 x와
그값을 받았습니다. 
그래서 저는 그것에 x 변수를 주었습니다.
좋아요, c p 1.y 는, 저는 그것에
값 2 를 지정 한다고 말했습니다, 2.0 을요. 
그래서 지금 cp1은 x좌표, y좌표값을 가지고 있습니다. 
cp2도 같은 방식으로 다른 어떤 
x와 y값을 갖습니다.
상기 시켜 보세요, c p 2 는 이 데이터 타입의 
다른 인스턴스 입니다. 
좋아요, 제가 클래스의 정의를 부를 때 그것은 가 버리고 
메모리에서 다른 장소를 찾습니다,즉 
돌아갈 주소의 포인터값을 여러분에게 주고 그것에 이름

English: 
Notice how I did
that up there.
Having created c p 1 and
c p 2, I had this weird
looking form here.
Not so weird, you've actually
seen it before.
In which I said c p 1
dot x equals 1.0.
What's this doing? c p 1 points
to an instance, it
points to a particular version
of this class.
And I have now given an internal
variable name x and a
value associated with that.
So I've just given
it an x variable.
All right, c p 1 dot y, I've
said assign that to
the value 2, 2,0.
So now c p 1 has inside of
it an x and y value.
Did the same thing with
c p 2, give it a
different x and y value.
Again, remind you, c p 2
is a different instance
of this data type.
All right, when I call the class
definition it goes off
and finds another spot in
memory, says that the spot I'm
going to give you a pointer back
to that, give it the name

English: 
c p 2, and then by running these
2 little assignments
statements here, I've given it
an x and a y value for c p 2.
So you see why I say it's
a template, right?
Right now it's a simple
template, but it's a template
for creating what a class looks
like, and I now have an
x- and y- value associated with
each instance of this.
OK, and if I wanted to look at
it, we can come back over
here, and we can see what does
c p 1 look like, interesting.
It says some funky stuff,
and says it's a kind
of Cartesian point.
And that's going to be valuable
to me when I want to
get back to using these
things, right?
You see that little thing says
dot Cartesian point in there.
If I want to get out right now
the versions of these things,
I can ask what's the value
of c p 1 x, and it
returns it back out.
I could say c p 2 dot x, that
was a bad one to use because
they use the same valuable
in both places, didn't I?

Korean: 
c p 2 를 줍니다, 그리고 나서 이 2개의 작은 대입문을 
돌림으로써, 저는 그것에 c p 2 를 위한 x 와 y 값을 부여하게됩니다. 
그래서 여러분은 제가 그것을 왜 템플릿 이라고 말했는지 알 것 입니다, 그렇죠? 
바로 지금 그것은 간단한 템플릿 입니다, 그러나 그것은 클래스의 
모습을 만들어 내기 위한 템플릿 입니다, 그리고 저는 이제 x 그리고
y 값을 가집니다.
네, 그리고 만약 여러분이 그것을 보길 원한다면, 우리는 여기로 다시 돌아 갈 수 있습니다, 
그리고 우리는 c p 1이 어떤 것인지 볼 수 있습니다, 흥미로워요. 
그것은 어떤 재미있는 것이라고 말합니다, 그리고 그것은 일종의 
데카르트의 점 이라고 말합니다. 
그리고 그것은 저에게 변수가 될 것 입니다 제가 이것들을 사용해서 
돌아 가길 원할 때요, 그렇죠? 
여러분은 작은 것이 점 데카르트의 점이 거기 있다고 말하는 것을 볼 수 있습니다. 
제가 지금 바로 이것들의 버전에서 나가길 원하면, 
저는 c p 1의 x 의 값이 무엇인지 물을 수 있습니다, 그리고 그것은 그것을 다시
리턴 합니다. 
저는 c p 2. x 를 말할 수 있습니다, 그것은 사용하기 나쁜 것 입니다 왜냐하면 
그것들은 양쪽 장소에서 같은 변수를 사용하기 때문 입니다, 그렇죠? 

Korean: 
그래서 c p 1 .y, c p 2 . y 를 해 봅시다. 
좋아요, 그래서 저는 이 객체들 각각을 가지고 변수들의 지역적인 
버전을 만들었습니다.
저는 제가 전에 한 것처럼 그것들에서 얻을 수 있습니다, 
저는 제가 전에 했기 때문에 그것들을 할당할 수 있습니다. 
좋아요, 제가 그것을 가졌기 때문에, 
우리는 이 점들로 제가 무엇을 하고 싶은지에 대해 생각할 수 있습니다.
자 제가 하고 싶은 한 가지는, 
이것은 같은 점 인가요 아닌가요? 
그래서 제가 여기 쓴 다음 코드는, 그곳으로 
살짝 움직여봅니다
저는 samepoint 라는 코드를 가지고 있습니다. 
그리고 여러분은 그것을 볼 수 있습니다. 
무엇을 한다고 말하나요?
그것은 말합니다, 여러분이 저에게 이 데이터 객체의 두 가지를 주면, 
저는 그것들을 p 1 그리고 p 2 라고 부를 것 입니다.
저는 말할 것 입니다, x 값이 그것들 모두에서와 같나?,
만약 그것이 그렇다면, y 값도 같습니다, 그리고 나서 이것은 
같은 점 입니다. 저는 true 를 리턴 할 것 입니다. 
형태에 주목 하세요.
 클래스네요, 미안해요, 클래스의 인스턴스 입니다

English: 
So let's do c p 1 dot
y, c p 2 dot y.
OK, so I've just created local
versions of variables with
each one of these objects.
I can get at them just like I
would before, I can assign
them in as I might
have done before.
OK, now that I've got that, we
could think about what would I
want to do with these points?
Well one thing I might want to
do is say, is this the same
point or not?
So the next little piece of code
I've written here, just
move down to it slightly.
I've got a little piece of
code called same point.
And you can look at it.
What does it say to do?
It says, if you give me two of
these data objects, I'm going
to call them p 1 and p 2.
I'm going to say, gee, is the
x value the same in both of
them, and if it is, and the y
value's the same, then this is
the same point, I'm going
to return true.
Notice the form.
This is saying, that's a class,
or sorry, an instance

English: 
of a class, and I'm going
to get the x value
associated with it.
I going to come back in a second
to how it actually does
that, but it basically says, get
me x value for p 1, get me
the x value for p 2,
compare them, just
as you would normally.
I've got another little thing
here that I'm going to use a
little later on that just prints
out values of things.
OK, let's see what happens
if I do this.
Let me show you simple
little example.
I'm going to go over here, and
let me define a couple of
these things.
I'm going to say p 1, try it
again, p 1 is a Cartesian, it
would help if I could type,
Cartesian point, and I'm going
to say p 1 of x is 3, p 1 of y
is 4, and I'm going to make p

Korean: 
그리고 그 인스턴스와 연관 된 x 값을 얻을 것 입니다
저는 곧 그것이 실제로 그것을 어떻게 하는지 이야기 해 볼것입니다,
그러나 그것은 기본적으로 말합니다, 저에게 p 1 의 x 값을 주세요
저에게 p 2 의 x 값을 주세요, 그것들을 
비교 하세요, 여러분이 보통 하는 것 처럼요. 
저는 여기 또 다른 작은 것이 있습니다 그것은 제가 조금 
나중에 사용 하려는 것인데 그것들의 값을 출력하는 일을 하는 것입니다. 
좋아요, 제가 이것을 하면 무슨 일이 일어 나는지 봅시다. 
여러분에게 간단한 작은 예를 보여 주겠습니다.
계속 하겠습니다, 그리고 저는 이 것들 중 몇 가지를 
정의할 것 입니다.
저는 p 1 을 말할 것 입니다, 그것을 다시 해 보세요, p 1 은 데카르트적 입니다, 
그것은 제가 데카르트의 점을 타이프 할 수 있으면 도움이 됩니다, 
그리고 저는 p 1 은 x값은 3 이고, p 1 은 y값은 4 라고 말할 것 입니다, 그리고

English: 
2 another Cartesian point.
And I'll give it an x value
of 3 and a y value of 4.
OK, now I want to say,
are these the same?
Thing I've got a little
procedure that could do that,
but you know the simplest thing
I could do is to say
well, gee, wait a minute, why
don't I just check to see if
these are the same thing?
So I can say is p 1 the same
as p 2, using Scheme's
built-in is comparator.
Say -- sorry?
PROFESSOR 2: Part of Python?
PROFESSOR: Part of Scheme, whoa,
there's a Freudian slip,
thank you, John.
I'm showing my age, and my
history here, is p 1 and p 2
the same thing?
Hey, there's a bad English
sentence even worse, now I'm
really thrown off.
I'm using Python's is comparator
to say is it the
same thing?
It says no.

Korean: 
저는 또 다른 데카르트의 점인 p 2 를 만들 것 입니다. 
그리고 저는 그것에 3 의 x 값 그리고 4의 y 값을 줄 것 입니다. 
좋아요, 이제 저는 말할 것 입니다, 이것들은 같은 것 입니까?
여기 그것을 할 수 있는 작은 프로시저가 있습니다, 
그러나 여러분은 제가 할 수 있는 가장 간단한 것이, 이런,
잠시만 기다리세요, 그냥 단지 이것들이 같은 것인지 
검사를 하면 어떨까요?
그래서 저는 p 1 이 p 2 와 같다고 말할 수 있습니다, 스키마의 
내장 된 비교를 사용하면 됩니다. 
뭐라고요? 
교수 2 : 파이썬의 부분 입니까? 
스키마의 부분 입니다, 아, 은연중에 속마음을 드러내는 실수를 했군요, 
고마워요, 존.
저는 제 나이를 보여주고 있습니다, 그리고 여기서 제 역사를요, 
p 1 그리고 p 2 는 같은 것 입니까? 
자, 나쁜 영어 문장이 있습니다, 이제
저는 정말 던져졌습니다.
저는 파이썬의 비교기 라는 것을 사용 합니다 
그점이 같은 점 인가요? 
아니라고 말합니다

English: 
But if I say, are p 1 and p 2
the same point, it says yes.
And this is a point I
want to stress here.
So what's going on in this case
is, I want to distinguish
between shallow equality
and deep equality.
The first thing is testing
shallow equality.
What it is doing, that's another
bad English sentence,
but what it is doing?
Is is essentially saying, given
2 things, do they point
to exactly the same referent?
Or another way of thinking about
it, is remember I said
when I call that class
definition it creates an
instance, that's a pointer to
some spot in memory that's got
some local information
around it.
Is is saying, do these things
point to exactly the same spot
in memory, the same instance.
Deep equality, we get to define,
that's what I did by
writing same point.

Korean: 
그러나 만약, p 1 그리고 p 2 가 같다 라고 말한다면, 그것은 맞다고 말할 것 입니다. 
그리고 이것이 제가 여기서 강조 하는 점 입니다. 
이 경우에, 저는 얕은 동일성과 깊은 동일성을 
구별 하고 싶습니다. 
첫 번째 것은 얕은 동일성을 테스트 하는 것 입니다. 
그것이 무엇을 하고 있나요
그것은 본질적으로 말하고 있습니다,
주어진 2 가지 에서, 그들은 정확히
같은 지시 대상을 가리키고 있는지 묻습니다. 
아니면 또 다른 방법은 제가 클래스 정의를 호출 했을 때
그것이 인스턴스를 만든다고 제가 말했던 것을 기억하세요. 
그것은 메모리의 어떤 장소의 포인터 입니다.
그것은 그 주위의 어떤 지역적인 정보를 갖습니다. 
그것은 말하고 있습니다, 이 것들이 정확히 메모리에서 같은 곳, 
즉 같은 인스턴스를 가리키고 있는 지를요. 
우리는 깊은 동일성을 정의할 것 입니다. 
그것은 제가 같은 점을 씀으로써 한 것 입니다. 

English: 
OK, as I said, I want equality
in the case of points to be,
are the x- and y- coordinates
the same?
And I'm actually going to change
it. just to show you
this point.
If I do the following, and
I say, I'm going to
assign p 1 to be p 2.
What's that doing?
It's taking the name p 1 and
it's changing its value to
point to exactly what
p 2 points to.
And then I say, are they
the same thing?
Answer's yes, because now they
are pointing to exactly the
same spot in memory.
The same instance.
OK, the reason I'm saying this
is, we have one class
definition, is a cookie cutter,
it's a template that's
going to let us build versions
of these things.
Every time I use it, I'm
creating a new instance,
that's a different thing
inside of memory.
And I want to have that because
I want to have lots of
versions of points.
OK, now, let's go back
to where I was.
I said one of the things I want
to do is, I want to have
different versions of points.

Korean: 
좋아요, 제가 말한 것 처럼, 저는 포인터의 경우에 있어서 동일성을 원합니다, 
x 그리고 y 좌표는 같습니까?
그리고 저는 실제로 그것을 바꿀 것 입니다. 단지 
여러분에게 이 점을 보여주기 위해서요.
만약 제가 다음을 한다면, 그리고 제가 말한다면, 
저는 p 1 을 p 2에 배정할 것 입니다. 
그것이 무엇을 하나요? 
그것은 이름 p 1 을 가지고 있습니다 그리고 그것의 값을 
정확히 p 2 가 가리키는 것을 가리키는 그 값으로 바꾸고 있습니다. 
그리고 나서 저는 말합니다, 그것들이 같은 것 인가요?
답은 yes 입니다. 왜냐하면 지금 그것들은 메모리에서 정확히 
같은 곳을 가리키고 있기 때문 입니다. 
같은 인스턴스를 말합니다. 
좋아요, 제가 이것을 말하는 이유는, 우리는 하나의 클래스 정의를 가지고 있는데, 
그것은 쿠키 모양을 찍는 데 쓰는 모형과 비슷합니다. 
그것은 우리가 이것들의 버전들을 만들게 하는 템플릿 입니다.
제가 그것을 사용할 때 마다 매번, 새로운 인스턴스를 만들 것 입니다, 
그것은 메모리 내부의 어떤 다른 것 입니다.
그리고 저는 그것을 가질 것 입니다 왜냐하면 저는 다양한 점을 
가지길 원하기 때문 입니다. 
좋아요, 이제, 다시 돌아 가겠습니다.
저는 제가 하고 싶은 것들 중 하나를 말했습니다, 저는 다양한 버전의 
점들을 가지길 원합니다. 

English: 
So I've got now things that
are Cartesian points.
I could do the same thing, I
could build polar point.
I wanted to show
it to you here.
I've got a class called polar
point, which is right there,
and same kind of thing, I can
create instances of it, and
then assign to them things like
a radius and an angle,
make instances of those.
OK, John?
PROFESSOR 2: I just want to
maybe mention that in some of
the reading, you'll see terms
like object equality and value
equality, instead of shallow
equality and deep equality.
PROFESSOR: Right, so, this
object, this is,
right, value quality.
Right.
And you will see both
terms used.
Some people like to use shallow
and deep, object and
value, but they're talking about
the same thing, which is
it the same object or is it the
same, in this case, set of
values, depending on what you
want to define as you use it.
OK, so as I said, now I can go
off and I could create a
different class.

Korean: 
저는 이제 데카르트의 점인 것을 가지고 있습니다. 
저는 같은 것을 할 수 있습니다, 저는 polar 점을 만들 수 있습니다
저는 여기서 여러분에게 그것을 보여 주고 싶습니다. 
저는 polar point 라는 클래스를 가지고 있습니다, 그것은 바로 저기에 있습니다, 
그리고 이전과 같이, 제가 그것의 인스턴스들을 만들 수 있습니다, 그리고 
나서 반지름과 각도 같은 것을 그것들에 지정할 수 있습니다, 
이렇게 그것들의 인스턴스들을 만들 수 있습니다. 
그렇죠, 존? 
교수 2 : 저는 방금 막 말하고 싶었는데요, 
읽기 자료에서, 여러분들은 얕은 동일성 그리고 깊은 동일성 대신에, 객체 동일성 
그리고 값 동일성 이라는 용어를 보게 될 것 입니다. 
교수 : 좋아요, 그래서, 이 객체는, 이것은, 
네, 값 동일성 입니다.
좋아요. 
그리고 여러분은 두용어가 모두 사용됨을 볼 것 입니다.
어떤 사람들은 깊은 그리고 얕은, 또 다른 이들은 객체 그리고 값 을 사용하길 좋아합니다, 그러나 
그들은 같은 것을 말하고 있는 것 입니다. 
그것은 같은 객체이고 같은 것 입니다, 이 경우에서, 값의 집합이 있습니다, 
여러분이 그것을 사용하는 것으로써 여러분이 무엇을 정의하고 싶은지에 따를 값입니다. 
좋아요, 제가 말한 것 처럼, 저는 이제 나갈 수 있고 저는 다른
클래스를 만들 수 있습니다. 

English: 
I've got Cartesian points, I
could create a polar points.
And I'm going to run it in a
sec, but you can see, the same
kind of idea.
I define a class call polar
point, I create a couple of
them, and I give them a
radius and an angle.
And then I could do things like
again, say, okay having
done, that let me just run it
here, run that, so I've now
got polar point 1, and
polar point 2.
I can say is polar point 1 the
same as polar point 2, and the
answer should be no.
And then I could say well, gee,
are they the same point?
Oops.
What happened?
Well it bombed out.
Because, what was I
expecting to do?
I was expecting to compare
x- and y- values,
not radius and angle.
And so this doesn't know how
to do it, it doesn't have a
method to deal with it,
so it complains.
So what's my problem here, and
this is what I want to now
lead up to.
I could imagine writing another
function for same

Korean: 
저는 데카르트의 점을 가지고 있고 이 점들로 polar 점들을 만들 수 있습니다. 
그리고 저는 그것을 1초 안에 돌릴 수 있습니다,
여러분은 같은 아이디어를 볼 수 있습니다. 
저는 polar point 라는 클래스를 정의합니다, 저는 그것들 중 
몇 가지를 만듭니다, 그리고 저는 그것들에게 반지름 그리고 각도를 줍니다. 
그리고 나서 저는 다시 그것들을 할 수 있습니다, 
네 그것들을 가지고, 그것은 제가 그것을 여기서 돌립니다, 그것을 돌립니다,
그래서 저는 이제 polar point 1, 그리고 polar point 2 를 가지게 되었습니다. 
저는 말할 수 있습니다, polar point 1 은 polar point 2 와 같냐?
그리고 답은 아니오 가 될 것 입니다. 
그리고 나서 저는 말할 수 있습니다, 자, 그것들은 같은 점 입니까? 
웁스. 
무슨 일이 일어났죠? 
그것은 터져 버렸습니다
왜냐하면, 제가 하려고 기대한 것이 무엇 이었죠? 
저는 x 와 y 값을 비교하기를 기대 했습니다, 
반지름과 각도가 아니라요
그래서 이것은 그것을 어떻게 하는지를 알지 못합니다, 그것은 
반지름과 각도를 다루는 메소드를 가지고 있지 않습니다, 
그래서 제대로 처리하지 못한 것이죠, 그래서 여기 제 문제는,
그리고 제가 이제 이끌어 가려고 하는 것은 
같은 점을 위한 또 다른 함수를 쓰는 것입니다, 

Korean: 
그리고 저는 그것에 samepointpolar 같은 이름을 줄 수 있습니다, 
그리고 samepointcartesian을요. 
polar 버전의 점들을 비교하기 위한 다른 함수 입니다. 
그러나 그것은 성가심이 되기를 시작할 것 입니다. 
제가 정말로 하고 싶은 것은 여러 정보를 생산해 내는 
다른 방법들을 지원하는 점의 표현을 갖는 것 입니다.
그리고 그것이 같은 점인지 아닌지를 
제가 알 수 있는 방법 같은 것을 다루기 위한
메소드 또는 함수인 것 입니다
그래서 지금 이 아이디어를 클래스에 적용해 봅시다. 
그리고 일반화 해봅시다.
좋아요, 그리고 이것들을 통해 
재미있는 일을 할 수 있습니다.
여기서, 아 그리고 유인물도
보기바랍니다
네, 클래스를 만들겁니다, 그리고 다시 
여러분께 상기시켜주기 위해서 말하면,
이 클래스는 이 탬플릿입니다. 
하지만 지금 이것을 고칠겁니다.
새 버전의 클래스는 
c point라고 불리고 
더 짧습니다. 
여러분은 그 안에서 정의들의 집합을 볼 수 있고,

English: 
point, and I have to give it a
name like same point polar,
and same point Cartesian.
A different function to compare
polar versions of
these points.
But that's starting to
get to be a nuisance.
What I'd really like to do is to
have 1 representation for a
point that supports different
ways of getting information
out, but has gathered within it,
a method or a function for
dealing with things like how
do I know if it's the same
point or not.
So I want to take this idea
classes now, and I want to
generalize it.
Right, and that is going to
lead us then to this funky
looking thing.
Right there, and I'd
like you to look at
that in your handout.
OK, I'm going to go back
and rebuild the class.
Ok, and again, I'm going
to remind you, the
class is this template.
But now I'm going to change
it, so what is that new
version of class say.
I'm going to call it
c point just to
make it a little shorter.

English: 
You can see inside of it, it's
got a set of definitions for
things like functions.
And that first one is this kind
of interesting thing,
it's two underbars, init,
and two underbars.
Underscores, I guess
is the right way
to say it, not underbars.
Right that's a specific name,
and what it basically says is,
when I call the class
instance.
That's a bad mistake.
When I call the class
definition, that is I call c
point, I'm going to
call it with a
specific set of arguments.
And what is it going to
happen is that init is
going to then apply.
It's going to apply to
those arguments.
So let me in fact show
you an example.
I've got a definition of
Cartesian point, I've got a
definition of polar point.
Let me just run these to
get them in there.
Now let's do the following.

Korean: 
함수 같은 것들도 볼 수 있습니다. 
그리고 첫번째 것이 재미있습니다. 
__init__입니다. 
언더바 보다는 언더스코어라고 
부르는 것이 맞는 거 같네요. 
네, 그것이 이름입니다. 그리고 기본적으로
클래스 인스턴스를
호출하면 안됩니다. 
클래스 정의인 c point를 호출해야 합니다. 
그것을 특정 명령의 집합으로
부를겁니다.
그리고 init함수가 실행되고 
저 명령들을 
수행하게 됩니다.
그래서 사실 여러분에게 예를 보여줄 것 입니다. 
저는 Cartesian point 의 정의를 가지고 있습니다. 
저는 polar point 의 정의를 가지고 있습니다. 
제가 저기서 그것들을 얻기 위해 이것들을 돌려 보겠습니다. 
이제 다음을 해 봅시다. 
p 를 Cartesian point 라고 합니다 그리고

English: 
Let's let p be Cartesian point,
and we'll give it a
couple of values.
OK?
So what happened?
Notice in the class definition
here, is there, this is the
first thing that's got called,
and I just called with the
value for x and the value for
y, and it went off and did
something for me.
Does that look right?
This is where you all hate it, I
get no eye contact anywhere.
Anything look odd about that?
I said.
When I call this class
definition, it calls init, and
I give it an x and a y value.
How many arguments
does init take?
Three.
How many arguments
did I give it?
Two.
What in the world's going on?
Well, this is a piece of
object-oriented coding that we
get to talk about
a little bit.
There's this weird extra
variable in there called self.
So what is self?
And I have to admit, I did the
standard thing you do every

Korean: 
우리는 그것에 몇 가지 값들을 줄 것 입니다. 
네?
그래서 무엇이 일어났죠? 
여기 클래스 정의에서, 저기에, 
이것이 불려 진 첫 번째 것 이라는 것을 주목하세요, 
그리고 저는 x 의 값과 y 의 값 으로 부를 것 입니다, 
그리고 그것은 가 버렸고 저를 위해 무엇을 했습니다. 
그것은 옳게 보입니까? 
이것은 여러분 모두가 그것을 싫어 하는 곳 입니다, 저는 어디서도 눈을 맞출 수가 없네요. 
그것이 이상해 보이나요? 
저는 말했습니다. 
제가 이 클래스 정의를 부를 때, 그것은 init 을 호출 합니다, 
그리고 저는 그것에 x 그리고 y 값을 줍니다. 
Init 은 얼마나 많은 인자들을 가지나요? 
3 입니다.
제가 그것에 얼마나 많은 인자들을 주었지요? 
2 입니다. 
무슨 일이 일어 나고 있나요?
자, 이것은 객체 지향 코드 입니다.
그것은 우리가 약간 이야기 한 것 입니다
self 라고 불리는 이 이상한 외부 변수가 저기에 있습니다. 
그래서 self 가 무엇 입니까? 
그리고 저는 받아 들여야 합니다, 저는 여러분이 모르는 것을 우연히 만날 때 마다

Korean: 
매번 여러분이 하는 표준적인 것을 합니다, 
여러분은 위키피디아로 갑니다.
그래서 저는 갔고 self 를 위키피디아에서 찾아 보았습니다. 
그리고 저는 그것을 읽어 주어야 합니다.
위키피디아는 우리에게 self 가 통합 된 것의 개념 이라는 것을 알려 줍니다, 
그것은 특유한 의식의 원천 입니다. 
더욱이, 이 self 는 그들이 생각 되어 지는 것의 각각의 생각 
그리고 행동을 위한 대리인의 책임이 있습니다. 
그것은 그러므로 
시간 내내 견디는 물질 입니다, 
따라서 다른 시간 에서의 생각 그리고 행동은 
같은 self 와 관련 됩니다. 
좋아요, 우리가 어떻게 그것을 코딩 하나요? 
AI 문제 처럼 들리는 군요, 그렇나요? 
그러나 사실 거기에는 중요한 요소가 숨겨져 있습니다,
그리고 그것은, 제가 인스턴스를 만들 때, 제가 그 인스턴스를 
특징화 하는 것에 접근할 수 있어야 하는 것 입니다. 
저는 그들이 사고 그리고 감정 같은
것이라고 말하지 않을 것 입니다, 그러나 여기서 인스턴스를 특징 짓는 것은, 
무엇이 계속 되는지를 구체화하는 내부의 인자들 입니다.
그래서 사실 객체 지향 시스템의 내부에서 

English: 
time you run across something
you don't know about, you go
to Wikipedia.
So I went and looked up self
in Wikipedia, and I have to
read it out.
Wikipedia informs us that the
self is the idea of a unified
being, which is the source
of an idiosyncratic
consciousness.
Moreover, this self is the
agent responsible for the
thoughts and actions
of an individual to
which they are ascribed.
It is a substance which
therefore endures through
time, thus thoughts and actions
at different moments
of time may pertain
to the same self.
OK, how do we code that up?
Sounds like an AI problem,
I guess right?
But there's actually hidden in
there an important element,
and that is, when I create an
instance, I have to be able to
get access to the things that
characterize that instance.
I won't say that they're
thoughts and emotions or
things, but what characterizes
an instance here, it's the
internal parameters that specify
what is going on.
So in fact what happens inside
of an object-oriented system,
and particularly in Python's
object-oriented

English: 
system, is the following.
When we call init, it's going
to create the instance, all
right, just as we said before.
But in particular, it's
going to use self to
refer to that instance.
Right, so let me say this
a little differently.
I have a class definition.
It's actually an object
somewhere.
It has inside of it all those
internal definitions.
When I call that class
definition, it calls init.
Init creates a pointer
to the instance.
And then it needs to have access
to that, so it calls
it, passing in self as the
pointer to the instance.
That is, it says it has access
to that piece in memory, and

Korean: 
무슨 일이 일어나는지, 그리고 특별히 파이썬의 객체 지향 시스템에서, 
다음과 같습니다 
우리가 init 을 부를 때, 그것은 인스턴스를 만들 것 입니다, 
좋아요, 전에 우리가 말했던 것 처럼요. 
그러나 특히, 그것은
self 를 그 인스턴스를 언급하기 위해 사용할 것 입니다. 
네, 제가 이것을 약간 다르게 말해 보겠습니다. 
저는 클래스 정의를 가지고 있습니다. 
저는 클래스 정의를 가지고 있습니다. 
그것은 그것의 내부에 이 모든 내부적인 정의들을 가지고 있습니다. 
제가 그 클래스 정의를 부를 때, 그것은 init 을 호출 합니다.
Init 은 그 인스턴스에 대한 포인터를 만들어 냅니다. 
그리고 나서 그것은 그것에 접근할 필요가 있습니다,
그래서 그것은 그것을 호출 합니다, self 를 인스턴스의 포인터로 전해 주면서요. 
init 즉, pointer 그것이 메모리에 있는 그 부분에 접근했다고 말합니다. 

Korean: 
그리고 이제 그 메모리 내부에, 
여러분이 여기서 보는 것처럼 저는 self.x 를
x 를 위해 전해 지는 값으로 정의 합니다. 
그것이 무엇을 하고 있습니까? 
그것은 self 가 어디를 가리키는지 말하고 있습니까?
그 구조 내부에, 변수 이름 x 를 만들고,
그리고 그것과 연관 된 값을 만드세요. 
제가 여기서 또한 무엇을 하는지 주목하세요, 저는 self 점 y 를 만듭니다, 
그것에 값을 줍니다, 그리고 나서, 오 좋아요, 저는 이 점을 위해 무엇이 반지름이고 
무엇이 각도 인지를 도한 정할 수 있습니다, 단지 약간의 
일을 함으로써요. 
좋아요, 사실 여러분이 그것이 저기서 무엇을 하는지 보면, 
포인터를 여기 놓습니다, 그것은 말합니다, 제가 저장한 x 값의
제곱과 제곱 된 y의 값을 더하세요, 그리고 나서
제곱근을 가지세요, 
그것을 다시 돌려주세요. 
그래서 저는 그 특정한 것의 반지름을 계산 했습니다. 
그렇죠? 
같은 방법으로 각도를 계산하세요, 단지 
적절한 것을 사용함으로써요. 
그래서 self 가 항상 특정한 인스턴스를 가리킨다는
것이 생각 입니다. 
이제 여러분은 말할 지도 모릅니다, 왜 그렇지? 

English: 
now inside of that piece of
memory, I can do things like,
as you see here, define self
dot x to be the value
passed in for x.
What's that doing?
It's saying where's
self pointing to?
Inside of that structure, create
a variable name x, and
a value associated with it.
Notice what I also do here, I
create self dot y, give it a
value, and then, oh cool, I
can also set up what's the
radius and angle for this point,
by just doing a little
bit of work.
OK, in fact if you look at what
it does there, just put
the pointer over here, it says,
get the value of x that
I just stored away, square it,
add it to the value of y
squared that I just stored away,
and then take square
root, pass it back out.
So I just computed the radius
of that particular thing.
Right?
Compute the angle the same
way, just using the
appropriate things.
So the idea is that self
will always point to
the particular instance.
Now you might say, why?

Korean: 
왜 그것이 이 방법을 하는 것일까? 
자, 기본적으로 그것은 디자인 선택이었기 때문 입니다,
파이썬을 만든 사람이 언어를 만들기로 결심했을 때요
그들은 기본적으로 말했습니다, 우리는 항상 인스턴스에 명백한 
포인터를 써야 할 것 이라고요
어떤 다른 객체 지향 프로그래밍 언어들은 
그 포인터를 제공하지 않습니다. 
이것은 제 견해에서 좋은 것 입니다, 
저는 존이 동의할지 모르겠어요, 그러나 이것은 명백 합니다. 
그것은 사실 여러분이 어떻게 그 포인터에 접근해서 
여러분이 참조하는 것이 무엇인지 알도록 해 줍니다. 
그러나 그것은 간단한 설계의 선택 입니다. 
그래서 그것을 다시 말하는 또 다른 방법은, 제가 클래스 
정의를 부를 때, 기본적으로 제가 보는 것은 거기에 
init 메소드가 있는지 입니다, 그리고 거기에 있으면, 저는 그것을 사용할 것 입니다. 
관습에 의해 첫 번째 인자는 항상 self 입니다, 왜냐하면 
그것은 인스턴스의 포인터여야 하기 때문 입니다, 그리고 나서 저는 지나 갑니다,
이 경우에요, 또 다른 몇 개의 인자들도 있습니다. 
좋아요, 이제, 만약 제가 이것을 실제로 하면, 그리고 제가 여러분에게 
예를 보여 줄 것 입니다, 제가, 제가 저기서 타이핑 한 것은, 
p 는 c point 입니다
제가 만약 다시 값들을 생산하길 원하면, 저는 사실 단순히 
그 인스턴스에게 메시지를 보낼 수 있습니다, 이 경우에 
저는 p .x 라고 하면됩니다. 

English: 
Why do it this way?
Well, basically because it was
a design choice when the
creators of Python decided to
create the language, they
basically said, we're always
going to have an explicit
pointer to the instance.
Some other object-oriented
programming languages do not
provide that pointer.
This is kind of nice in my view,
I don't know if John,
you'd agree, but this
is explicit.
It actually lets you see how to
get access to that pointer
so you know what you're
referring to.
But it's simply design choice.
So another way saying it again
is, when I call the class
definition, by default I'm going
to look to see is there
an init method there, and if
there is, I'm going to use it.
First argument by convention is
always self, because it has
to point to the instance, and
then I pass, in this case,
another couple of
arguments in.
OK, now, if I actually do this,
and I'm going to show
you the example, I just, what
did I type over there, I got p
was a c point.
If I want to get values back
out, I could in fact simply
send to that instance a message,
in this case I could
say p dot x.

Korean: 
그것을 해 봅시다. 
만약 제가 그것을 여기서 하면 – 아하 – 그것은 저에게 값을 돌려 보내는 군요.
이것이 실제로 무엇을 하고 있습니까? 
P 는 인스턴스 입니다. 
그것은 압니다, 또는 저장 했습니다, 그것을 봅시다, 
만약 우리가 p 가 하는 것을 보면, 여기서 이것을 약간 살펴봅니다, 
그것은 말합니다 그것은 일종의 
Cartesian point 입니다, 그것은 인스턴스 입니다, 그것이 
있는 메모리 위치가 있습니다. 그래서 그것이 
구체적인 곳 에서의 인스턴스 임을 알수 있습니다. 
c point 로부터 나왔다는 것을 압니다. 
그래서 제가 타이핑 할 때, 아니, 타이핑이아니라,  
제가 쓸 때, 비록 제가 그것을 타이프 하더라도, p 점 x 입니다, 여기 
기본적으로 일어 나는 것이 있습니다. P는 인스턴스 이고 메시지를 받았습니다. 
이 경우 메시지는 x가 x의 값을 
원한다는 것입니다. P 는 일종의 Cartesian point 입니다. 
그것은 사실 가고 그리고 얻습니다, 여러분이 만약 필요 하다면, 

English: 
In fact let's do it.
If I do that over here -- aha --
it gets me back the value.
Now let me spend just a second
to say, what was this actually
doing? p is an instance.
It knows, or has stored away,
and in fact let's look at it,
if we look at what p does,
p says -- it says reading
through a little bit of this
stuff here, it says -- it's a
kind of Cartesian point, it's an
instance, there's actually
the memory location that it's
at, that's why I say this idea
of it's an instant at
a specific spot.
It knows that it came from
this class, c point.
So when I type, I'm sorry, I
shouldn't say type, when I
write, although I would have
typed it, p dot x, here's what
basically happens. p is an
instance, it's being sent a
message, in this case the
message x, it says I want the
x-value back out. p knows that
it is a kind of Cartesian

English: 
point, it actually goes and
gets, if you like, the class
definition up here.
And is able to then say,
inside of that class
definition, find
the value of x.
All right, now, that's one of
the ways we could get things
out, but in fact it's really
not a good way.
A better way to do this would
be the following.
If I could type.
What did I just do there?
One of the things that I
defined inside my class
definition here was an
internal method.
That method has a name,
obviously, and
what does it do?
It's going to go off and get the
values of x and y attached
to this thing and return
them to me.
And that's one of the
things I want.
I would like my classes
to have methods.

Korean: 
여기 클래스 정의가 있습니다. 
그리고 나서 말할 수 있습니다, 그 클래스 정의 내부에서,
x 의 값을 찾으세요.
좋아요, 이제, 그것이 우리가 그것을 얻어 내는 방법들 중 하나 입니다, 
그러나 사실 그것은 정말 좋은 방법이 아닙니다. 
이것을 하는 더 좋은 방법은 다음과 같습니다. 
제가 타이프를 할 수 있으면요
제가 저기서 방금 무엇을 했죠? 
제가 여기 제 클래스 정의 내부에서 
정의한 것들 중 하나는 내부의 메소드 였습니다.
그 메소드는 이름을 가지고 있습니다, 명백히요, 그리고 그것은 무엇을 하나요? 
그것은 가 버릴 것 이고 이 것에 붙여 진 x 그리고
y 의 값을 얻습니다 그리고 그것들을 저에게 리턴해 줍니다. 
그리고 그것이 제가 원하는 것들 중 하나 입니다. 
저는 제 클래스들이 메소드들을 가지길 원합니다..

Korean: 
그래서 여러분은 특정한 인스턴스의 값에 접근할 수 있습니다. 
아직도 이것은 여전히 미묘한 차이가 있습니다, 왜 제가 이것을 하길 좋아 합니까? 
자 이것은 왜 제가 클래스에서 시작할 것들을 
함께 모아야 하는가의 의문이 들게 합니다. 
파이썬에서 그것을 타이프 하고 값을 돌려 받는 것은
완벽하게 합법적 입니다. 
제가 말한 것 처럼, 저는 제가 썼던 접근자를 사용하는 
것을 하기를 선호 합니다. 
p.Cartesian 은 일종의 접근자 입니다, 그것은
데이터에 접근 합니다. 
그리고 여기에 왜 제가 그것을 좋아 하는지가 있습니다.
지금 바로, 저는 여전히 문제를 가지고 있습니다.
그 문제는 이 클래스들이, 이 클래스들의 인스턴스들이, 노출 되었다는 것 입니다. 
제가 의미하는 것은 무엇이죠? 
여기 제가 할 수 있는 것이 있습니다

English: 
So you can access the values
of the specific instance.
Now, this is still a nuance, why
would I like to do this?
Well this is leading up to why
I want to gather things
together in classes
to start with.
It's perfectly legal in Python
to type that in and get the
value back out.
As I said, I would prefer to
do something that uses an
accessor that I just wrote.
So p dot Cartesian is a kind
of accessor, it's getting
access to the data.
And here's why I'd
like to have it.
Right now, I still have the
problem that those classes,
those instances of classes,
are exposed.
What do I mean by that?
Here's something I could do.

English: 
Let's do it in fact.
OK.
What point in the plane
does p now point to?
X-axis is foobar y-axis
ought to be foobass
something else, right?
I know it looks like a simple
and silly little example, but
at the moment, I still have
the ability to go in and
change the values of the
parameters by that little
definition.
And this makes no sense.
And this is because I don't have
something I would really
like to have, which
is data hiding.
So you'll see lots of
definitions of this.
I think of data hiding as
basically saying, one can only
access instance values, or,
we'll call them that, instance

Korean: 
해 봅시다. 
좋아요. 
p가 가리키는 어떤 점은 무엇인가요?
X 축은 foobar y 축은 foobass 여야 합니다, 
네? 
저는 그것이 간단하고 웃긴 작은 예 같아 보이는 것을 압니다
그러나 여전히, 들어 가서 정의에 의해서 인자들의 값을
바꿀수 있습니다. 
그리고 이것은 이치에 맞지 않습니다. 
그리고 이것을 하지 못합니다. 
그것은 데이터 은닉 입니다. 
그래서 여러분은 이것의 많은 정의들을 볼 수 있을 겁니다. 
저는 데이터 은닉을 기본적으로 다음과 같이 생각 합니다, 하나는 
오직 인스턴스 값에 접근할 수 있습니다, 또는, 우리는 값들을

English: 
values through defined
methods.
And that's a wonderful thing to
have because it gives you
that modularity, that
encapsulation that basically
says, when I create a point, the
only way I can get at the
values, is by using one of the
defined methods, in this case
it could be Cartesian, and get
all the pieces of that.
Unfortunately, Python
doesn't do this.
Which is really a shame.
Or another way of saying it
is, please don't do that.
Don't go in and change the
values of things by using the
direct access.
Have the computational hygiene,
if you like, to only
go through accessors, only go
through methods that are
actually provided to
you as you do this.
I actually don't remember,
John, C++ does have data
hiding, I think, right?
PROFESSOR 2: And not only
shouldn't you change it, you
shouldn't even read it.
PROFESSOR: Exactly.

Korean: 
정의된 메소스들을 통해 호출합니다. 
그리고 그것은 가지면 편리한 것입니다 왜냐하면 그것은 
여러분에게 모듈 방식, 캡슐화를 주기 때문 입니다 그것이 기본적으로 말하는 것은, 
제가 점을 만들 때, 제가 값들에 접근할 수 있는 유일한 방법은
정의된 메소드들 중 하나를 사용하는 것입니다, 이 경우에 
그것은 Cartesian 이 될 수 있습니다, 그리고 그것의 모든 부분들을 얻어낼 수 있습니다. 
불행히도, 파이썬은 이것을 하지 못합니다. 
정말 창피한 것이죠.
또는 이것을 말하는 또 다른 방법은, 그렇게 하지 마세요.
들어 가서 직접적인 접근을 사용함으로써
그것들의 값을 바꾸지 마세요.
계산적인 위생을 가지세요, 오직 접근자,값을 바꿔주는 기능을 하는 메소드들을 통해서 하세요.
여러분이 좋아하면, 오직 접근자를 통해서요, 오직 메소드들을 통해서요, 
메소드들은 실제로 여러분에게 여러분이 이것을 할 때 주어 집니다. 
저는 사실 기억이 잘 나지 않는데, 존, C++ 는 
데이터 은닉을 가지고 있는거 같아요, 제 생각에 그렇습니다, 그렇죠? 
교수 2 : 그리고 여러분이 그것을 바꾸면 안될 뿐만 아니라, 여러분은 
심지어 그것을 읽어서도 안 됩니다. 
교수 : 정확합니다. 

Korean: 
여러분이 곧 볼 것은 제가 제 코드에서 위반한 것 입니다, 
그것은 구탁 교수가 저에게 곧 소리칠 것이죠
왜냐하면 저는 그것을 접근자를 통해 했어야 하기 때문인데 그러지 못해서 입니다,
그러나, 그는 정확하게 맞습니다. 
이것을 하는 좋은 위생적인 방법은, 제가 들어 가서 그것을 바꾸지 않을 뿐 아니라 
미리 정의된 메소드를 통한 것입니다. 
미리 정의된 메소드를 통하지 않고서는 저는 그것을 읽어서도 안됩니다. 
저는 그것의 것들을 알아 내기 위해서 Cartesian 또는 polar 를 사용 해야 합니다. 
제가 한 번 그것을 얻으면, 여러분은 제가 이제 polar point 를 정의할 수 있다는 것을 알 수 있을겁니다, 
같은 방법으로요. 
제가 이제 제 문제들 중 하나를 풀었다는 것도 알수 있습니다, 
그것은, 여기 이 경우들 중 하나에서, 저는 x y 모두 그리고 반지름 
각도 값들을 거기 내부에 만들 것 입니다.
만약 그것이polar 형태이면 제가 반지름과 각도로 전해 주고
x 와 y 값이 무엇인지 계산할 것 입니다.
만약 Cartesian 형태 이면, 저는 그것을 x 와 y 를 넘겨 줄 것이고
반지름과 각도가 무엇인지 계산 할 것 입니다.
지금 그것의 형태가 무엇이든, 
저는 그 종류의 정보를 얻을 수 있다고 말하고 있습니다. 

English: 
What you're going to see in a
second I violated in some of
my code, which Professor Guttag
is going to yell at me
shortly because I should have
done it through accessors,
but, he's exactly right.
A good, hygienic way of doing
this is, not only do I not go
in and change things except
through a pre-defined method,
I shouldn't read it other than
through a pre-defined method.
I should use Cartesian
or polar to pull out
those pieces of it.
Once I've got that, you notice
I can now define a polar
point, same way.
Notice I've now solved one of my
problems, which is, in each
one of these cases here, I'm
creating both x y and radius
angle values inside of there.
If it's in polar form I passed
in a radius and angle and I'll
compute what the x-
and y- value is.
If its in Cartesian form I'll
pass in an x and y and compute
what a radius and angle is.
But it now says that in any, in
no matter what kind of form
I made it from, I can get out
that kind of information.

English: 
So for example I defined p,
remember back over here, as a
Cartesian point, but
I can actually ask
for its polar form.
It's there accessible to me.
OK, this is great.
Just to drive home one more
reason why I don't want to
have changes to the
values other than
through pre-defined things.
Notice what happens if
I do the following.
I could say I want to
change the radius of
this particular thing.
OK, perfectly reasonable
thing to do.
And if I go look at the polar
form of this, OK, good, looks
right, right?
It's now got a different radius,
same angle, so I just
changed the radius of it.
Oh, but what happened to
the Cartesian form.
I should have done this
earlier by typing the
Cartesian form earlier, so let
me go back to where I was,
sorry for that, let me go
make this a 1 again.

Korean: 
그래서 예를 들어 제가 p로 정의하면, 여기로 다시 돌아 오는 것을 
기억하세요, Cartesian point 처럼요, 그러나 저는 실제로 
그것의 polar 형태로 물어 볼 수 있습니다. 
그것은 저기서 접근 가능 합니다. 
좋아요, 이것은 훌륭합니다. 
제가 미리 정의 된 것들 외에 값들을 
변경시키지 않길 원하는
한 가지 더 이유가 있습니다.
제가 다음을 하면 무슨 일이 일어 나는지 주목하세요.
저는 말할 수 있습니다 제가 이 특정한 것의 반지름을 
바꾸길 원한다고요. 
좋아요, 완벽하게 합리적인 것 입니다.
그리고 제가 이것의 polar 형태를 보면, 네, 좋아요, 
옳게 보이죠, 그렇죠? 
그것은 이제 다른 반지름, 같은 각도를 갖습니다, 그래서 저는 
그것의 반지름을 바꿉니다. 
오, 그러나 Cartesian 형태에 무슨 일이 일어 났나요. 
저는 이것을 Cartesian 형태로 쉽게 타이프 함으로써 더 쉽게 했어야 하는데 
그러지 못했습니다, 그래서 제가 있었던 때로 돌아 가겠습니다
이것을 다시 가서 1로 만들겠습니다. 

English: 
If I look at the Cartesian, oh,
I did have the Cartesian
form, don't mind me while I
mutter to myself here quietly.
Yeah, that's right, I did
screw that up badly.
All right, we try one more time,
here we go, let's try
one more time.
We'll make p a new point, ok?
There's the Cartesian
representation of it, which is
right, (1,2).
Here's the polar representation
of it, some
random set of numbers
which makes sense.
If I now say, I'm going to go
ahead and change the radius of
this, something, my polar form
did it right, but what
happened to the Cartesian
form?
Ah yes, didn't change.
Which makes sense if you
think of my code.

Korean: 
만약 제가 Cartesian 을 볼 수 있다면, 오, 저는 Cartesian 형태를 가졌었네요, 
제가 여기서 혼잣말 하는 것에 신경쓰지 마세요.
네, 그것은 맞았었네요, 저는 그것을 나쁘게 망쳐 버렸었습니다. 
좋아요, 우리는 한 번 더 해보겠습니다, 시작합시다, 
한 번 더 해 봅시다.
우리는 p 를 새로운 점으로 만들 것 입니다, 그렇죠? 
그것의 Cartesian 표기가 있습니다, 
그것은 옳습니다, (1, 2) 입니다. 
여기에 그것의 polar 표기가 있습니다, 
적절한 숫자들의 어떤 랜덤한 세트 입니다. 
저는 미리 가서 이것의 반지름을 바꿀 것 입니다, 
제 polar의 형태는 그것을 옳게 했습니다, 그러나 
Cartesian 형태에 무엇이 일어 났나요? 
아 네, 변하지 않았습니다. 
여러분이 제 코드를 생각 하면 무엇이 말이 되나요.

Korean: 
저는 저기서 아무 것도 가지지 않습니다, 만약 여러분이 
이 값들 중 하나를 바꾼다면, 다른 값들은 그것에 영향받습니다, 그리고 저는 
그것에 그 변화를 만들고 싶습니다. 
그래서 이것은 왜 제가 정의된 메소드를 통해서만 
인스턴스에 접근하길 원하는지를 강조하는 한 가지 더 예 입니다.
왜냐하면 저는 그것을 안에 만들 수 있어야 했기 때문 입니다, 그것은 말합니다, 
여러분이 만약 이 것의 값을 바꾸면, 그런데 여러분은 이것을 위해서 
이 다른 값들을 다시 계산할 필요가 있습니다. 
좋아요, 그래서 그러면 여기 제 작은 클래스 정의에서  
제가 무엇을 더 가지나요?
그래서, 저는 모든 2가지의 경우에 init 을 가집니다. 
저는 init을 집어 넣을 필요는 없지만, 그것을 
집어 넣는 것은 좋은 생각 입니다. 
저는 얻었고 init 은 여러분이 인스턴스를 만들 때, 
여기에 여러분이 하는 것이 있습니다. 
전형적으로 그것은 또한 저를 위해 
내부의 변수들이 무엇인지, 클래스의 내부의 특징들이
무엇이 되는지 정의 합니다. 
다시, 저는 그것들을 계산하는 어떤 다른 함수들을 가질 수 있습니다,
그러나 이것은 전형적으로 제가 그것들을 집어 넣는 곳 입니다. 
그래서 이것은 저에게 지금 그 템플릿을 주고 있습니다, 좋아요, 
이제 점을 위한 템플릿은 x,
y, 반지름, 각도 입니다. 
그리고 저는 이런것들을 저기서 볼 수 있습니다. 

English: 
I didn't have anything in there
that says, if you change
one of these values, other
values depend on it, and I
want to make that
change to it.
So this is one more example of
stressing why I only want to
come access to the instances
through defined methods.
Because I could've built that
in, it says if you change the
value of this thing, by the
way you need to change
recompute those other values in
order to make this hold up.
OK, so what else do I have
then in my little class
definitions here?
So, I've got an init
in both cases.
I don't have to put an init in,
but it's again, usually a
good idea to put that
in originally.
I've got and init that says,
when you create an instance,
here's what you do.
Notice that that typically also
defines for me what the
internal variables are, what the
internal characteristics
of the class are going to be.
Again, I could have some other
functions to compute things,
but this is typically
the place where I'm
going to put them in.
So this is giving me now that
template, better way of saying
it, all right, a template
now, for a point is
x, y, radius, angle.
And I can see that in
those pieces there.

Korean: 
그리고 나서 저는 그것들에 대해 저에게 
정보를 돌려 주는 어떤 것을 갖습니다
그러나 저는 거기서 그것들에 언더바를 가진 메소드를 찾는 이 이상한 것들의  
다른 몇 가지를 갖습니다. 
그래서 클래스들을 위한 어떤 전형적인 메소드들이
파이썬에 있는지 살펴 봅시다
init 을 가지고 있습니다. 
이것은 실제로 인스턴스를 만들고, 
그것을 초기화 하고 변수 값들의 
세트를 만듭니다. 
좋아요, 저는 거기서 또 다른 하나를 가집니다, 언더바, 언더바,(__)str 입니다. 
그것이 무엇을 하고 있는지 아는 학생 있나요? 
그것은 – 미안합니다, 저는 무엇을 들었어요, 미안해요 계속 하세요. 
학생 : 제가 가지고 있는 것을 보여 줍니다. 
학생 : 제가 가지고 있는 것을 보여 줍니다. 
고마워요. 
네, 저는 그것을 말하려고 했습니다, 
str 이 하는 것에 대해 생각해 보세요, 일반적으로요. 
그것은 이것들을 스트링 타입으로 전환 시킵니다. 
우리가 이것들을 전형적으로 어떻게 출력 하나요, 
우리는 그것들을 스트링으로 전환 합니다. 
그래서 str 은 기본적으로 어떻게 그것이

English: 
And then I've got some things
that get me back out
information about them.
But I got a couple of other of
these strange looking things
in there with underbars
to them.
So let's look at what some of
the traditional methods for
classes are in Python.
I have init.
This is what's actually going
to create the instance,
instantiate it, create what
the set of variable
values are for it.
OK, I have another
one in there,
underbar, underbar, str.
Anybody have a sense of
what that's doing?
What's s -- sorry, I heard
something, sorry go ahead.
STUDENT: Display what I have.
PROFESSOR: Displaying what
I have. Thank you.
Yeah, I was going to say, think
about what does str do,
in general?
It converts things into
a string type.
How do we typically
print things, we
convert them to strings.
So str is basically telling
us how we want to

Korean: 
프린트 되기를 원하는지 말해 주고 있습니다
좋아요, 사실 우리가 이것을 본다면, p 를 출력하라고 하면, 
그것은 그것을 저 형태로 출력 합니다. 
이것은 사실 좋지 않은 방법 입니다, 왜냐하면 
여러분은 말할 지도 모릅니다, 자, 그것은 단지 리스트 이라고요.
그러나 기억하세요, 그것은 리스트가 아니 였습니다. 
그것은 무엇을 하죠? 
그것은 말합니다, 만약 제가 여기 Cartesian 형태에 있는 것을 만든 것을 
출력 하길 원한다면, 말합니다, 다시, 저는 그것을 포인터에서
인스턴스로 전해 줄 것 입니다, 그것은 self 같은 것 입니다, 그리고 나서 
저는 제가 열린 괄호와 닫힌 괄호로 함께 묶은 문자열을 리턴 할 것 입니다, 
중간에 콤마가 있습니다, 그리고 x 값 그리고 y 값 을 가지고
그것들을 문자열로 변환하죠,
제가 전체의 것을 함께 두기 전에요.
그래서 그것은 저에게 기본적으로 제 프린트 된 표현을 줍니다. 
좋아요. 
제가 여기서 무엇을 더 가지나요? 
자, 저는 cmp 를 가집니다. 
제 핸드 아웃에 오타가 있습니다, 그것은 제가 모두 출력하고 나서 오늘 아침에 
발견 했습니다. 

English: 
have it printed out.
OK, in fact if we look at this,
if I say, print of p, it
prints it out in that form.
Now this is actually a poor
way to do it, because you
might say, well, it's just the
list. But remember, it wasn't
a list. What does it do?
It says, if I want to print
out something I built in
Cartesian form up here, says,
again, I'm going to pass it in
a pointer to the instance, that
self thing, and then I'm
going to return a string that
I combine together with an
open and close paren, a comma in
the middle, and getting the
x-value and the y-value and
converting them into strings
before I put the whole
thing together.
So it gives me basically my
printed representation.
OK.
What else do I have in here?
Well, I have cmp.
My handout's wrong, which I
discovered this morning after
I printed them all out.

Korean: 
그래서 제가 여러분이 사용하길 바라는 것은, 같다를
크다로 바꾸는 겁니다. 
Cmp 가 메소드로써 하는 것은 무엇 입니까?
네? 
학생 : 값들을 비교 하나요? 
교수 : 네, 값들을 비교 해요, 그렇나요? 
그리고 다시, 그것은 cmp 가 파이썬에서 일반적으로
하는 것과 유사 합니다. 
그것은 비교를 하는 방법입니다. 
이것은 비교를 하고 있습니다. 
이제, 저는 거기서 버전을 올리겠습니다, 저는 이것이 비교를 하는
옳은 방법 인지 아닌지 잘 모르겠습니다. 
저는 x 그리고 y 좌표 모두 더 크다는 것을 말했습니다, 
그리고 나서 저는 그것에 어떤 것을 리턴 할 것 입니다
그리고 제가 말했던 polar의 것에서 저는 제가 거기서 한 것이 
무엇인지 생각 합니다, 저는 말했습니다, 네, 다시 만약 x 와 y 가 다른 것 보다 더 크다면, 
저는 그것들을 그것에 리턴 할 것 입니다. 
핸드 아웃에 있는 버전 에서 그것이 하고 있었던 것은 무엇 입니까? 
여러분은 핸드 아웃을 보세요. 

English: 
So the version I'd like you to
have uses, that, greater than
rather than equals that
I had in my handout.
What's cmp doing as a method?
Yeah?
STUDENT: Comparing values?
PROFESSOR: Yeah, comparing
values, right?
And again, it's similar
to what cmp would do
generically in Python.
It's a way of doing
comparisons.
So this is doing comparisons.
Now, I put a version up there,
I have no idea if this is the
right way to do comparisons
or not.
I said both the x- and y-
coordinates are bigger, then
I'm going to return
something to it.
And I think in the polar one I
said, if, what did I do there,
I said, yeah, again if the x
and y are greater than the
other one, I'm going to
return them to it.
The version in the handout, what
was that actually doing?
You could look at the handout.

Korean: 
그것이 비교하는 것 이라고 생각 합니다, 같습니까? 
그래서 그것은 사실 제가 집어 넣을 수 있는 또 다른 하나의 메소드가 될 것 입니다. 
언더바 언더바 eq, 언더바 언더바.
비교를 하는 기본적인 또는 일반적인 방법이 될 것 입니다, 
이 것들은 같은 것 입니까? 
네, 각 경우에서, 이것들이 하고 있는 것은 
때때로 연산자 오버로딩
으로 언급되는 것 이죠. 
저는 여러분이 그것을 다시 기억하지 못한 다는 것을 알고 있습니다,
그러나 두 번째 강의 쯤에 저는 구탁 교수의 농담을 했습니다, 
여러분은 웃지 않았습니다, 그도 웃지 않았습니다, 그것은 괜찮습니다. 
제가 말했던 것에서, 여러분이 알다시피, 저는 더하기 같은 것들이
오버로드 된다는 사실을 좋아하지 않습니다, 왜냐하면 여러분은 
문자열을 더하기 위해 플러스를 사용할 수 있기 때문 입니다, 여러분은 숫자들을 더하기 위해 
플러스를 사용할 수 있습니다, 여러분은 실수들을 더하기 위해 플러스를 사용할 수 있습니다. 
그리고 그는 꽤 정확하게, 왜냐하면 그가 저 보다 시니어 이기 때문에,
저 보다 더 경험을 많이 했습니다, 
그래서 그는 그것이 사실 좋은 것 이라고 말했습니다.
그리고 그는 대부분 옳습니다.
그리고 그는 대부분 옳습니다.

English: 
Well I think it was comparing,
are they the same?
So that would actually be
another method I could put in.
Underbar underbar eq,
underbar underbar.
Would be a default or generic
way of doing, are
these things the same?
OK, in each case, what these
things are doing, is they're
doing, what sometimes gets
referred to as operator
overloading.
I know you don't remember that
far back, but in about the
second lecture I made a joke of
Professor Guttag which, you
know, you didn't laugh at, he
didn't laugh at, that's okay.
In which I said, you know, I
didn't like the fact that
things like plus are overloaded,
because you can
use plus to add strings, you can
use plus to add numbers,
you can use plus
to add floats.
And he quite correctly, because
he's more senior than
I am, more experienced
than I am, said it's
actually a good thing.
And he's right.
Most of the time.

Korean: 
제가 이것을 말하는 이유는, 연산자 오버로딩을 가짐으로써, 
저는 제가 사용하고 싶은 모든 객체들의 하나의
제너릭 인터페이스를 사용할 수 있습니다. 
그래서 그것은 말할 수 있는 이치에 맞습니다,
제가 비교를 하는 방법으로 가지길 원하는 많은 메소드들을 찾아 보세요, 그리고 저는 
기억할 필요가 없습니다, 높은 수준에서, 비교 메소드의
이름이 무엇인지를요.
저는 단순이 내장된 것을 사용할 수 있습니다 – 다시 스키마를 말합니다 – 
내장 된 파이썬 비교 연산 입니다.
이 2 가지는 같은 것 입니까?
Cmp 와 같은 것 입니다, 그것은 더 큰 것 이라고 말하고 있습니다, 
그리고 지금 보다 더 큰 것은 문자열에 적용할 수 있습니다. 
그것은 실수에 적용할 수 있습니다, 그것은 점에 적용할 수 있습니다, 
그것은 다른 것에 그것을 더할 수 있습니다. 
그래서 몇 가지 불리한 면이 있습니다, 제 견해로는,
연산자 오버로딩을 하는데 있어서요, 그러나 정말 도움이 되는 점도 있습니다. 
그리고 메인의 것은, 제가 결정하려고 하는 것은, 제가 이것을 어떻게 
사용하길 원하는지 입니다, 그리고 어떻게 호출하는지 입니다. 
네, 학생? 
교수 : 맞아요, cmp 다른 것 입니다, 그래서 제가 이것을 어떻게 호출합니까?
좋은 질문 입니다. 
여기에 제가 그것을 호출하는 방법이 있습니다. 
여러분에게 제가 보여주겠습니다, 저는 polar point 를 만들 것 입니다, 

English: 
The reason I say that is, by
having operator overloading I
can use 1 generic interface
to all of the objects
that I want to use.
So it makes sense to be able to
say, look for many methods
I do want to have a way of doing
comparison, and I don't
have to remember, at top level,
what the name of the
comparison method was.
I can simply use the built-in
Sc -- about to say Scheme
again -- the built-in Python
comparison operation.
Say, are these 2 things
the same?
Same thing with cmp, that's just
saying greater than, and
greater than now can apply to
strings, it can apply to
floats, it could apply to
points, it could add other
pieces into it.
So there are some downsides, in
my view, to doing operator
overloading, but there's
some real pluses.
And the main one is, I get to
just decide, how do I want to
use this, and call it.
Yes, ma'am?
STUDENT: [INAUDIBLE]
PROFESSOR: Right, cmp other,
so how would I call this?
A good question.
Here's the way I
would call it.
Let me give you, I'm going to
create, a polar point, I'm

English: 
going to call it q, and we'll
give it some random values.
OK, and now I want to know,
is p greater than q?
Now happens to return true here,
but the question is,
where's the other come from?
P is a particular object type.
When I try and evaluate that
expression of greater than, is
going to go into the class
to say greater
than is a comp method.
So let me say it very
carefully here.
When I evaluate, yeah, when
I evaluate this, p is an
instance of a point, in this
case it was actually a
Cartesian point, it sends a
message to the instance, which
sends a message to the
class, to get the cmp
method from the class.
And that then gets applied to
itself, just p, and one other
argument, which is the second
piece there, so other points
to the second argument
that was present.
OK.
John?

Korean: 
저는 그것을 q 라고 부를 것 입니다, 그리고 우리는 그것에 어떤 랜덤한 값들을 줄 것 입니다.
좋아요, 그리고 지금 제가 알기 원하는 것은, p 가 q 보다 큽니까?입니다.
이제 여기서 true 를 리턴 해 줍니다, 그러나 질문은, 
다른 것들은 어디로부터 옵니까? 
P 는 특정한 객체 타입 입니다.
제가 그 큰 것의 표현을 평가 하려고 시도 할 때는 
큰 것이 comp 메소드 라는 것을 말하기 위해 
클래스로 들어 가는 것 입니다. 
그래서 제가 그것을 여기서 매우 주의 깊게 말해 주겠습니다.
제가 평가할 때, 네, 제가 이것을 평가 할 때, p 는 점의 인스턴스 입니다, 
이 경우에 그것은 실제로 Cartesian 점 입니다, 
그것은 인스턴스에 메시지를 보냅니다, 그리고 인스턴스는 
클래스에 메시지를 보냅니다, 클래스로부터 cmp 메소드를 얻기 위해서요. 
그리고 그것은 이제 그것 스스로에게 적용 됩니다, p 에요, 그리고 하나의
다른 인자에요, 거기 두 번째 인자도요,
그래서 두 번째 인자의 다른 점들이 있습니다. 
네. 
존? 

Korean: 
교수 2 : -- 다른 것, 그것은 누구인지 또는 zort 또는 무엇인지 말할 수 있어야 했어요 -- 
교수 : 네, 미안합니다, 그것은 질문의 부분 입니다, 
저는 foobar 를 고를 수 있어야 했어요, 여기에 어떤 것을 집어 넣을 수 있게요.
그것은 단순 합니다, 여기서 그것의 형태가 무엇인지 주목하세요
그것은 두 인자를 가질 것 입니다, 그리고 교수님이 맞습니다, 
self 는 원래의 인스턴스 입니다. 
이것은 말합니다, 저는 그것에 두 번째 인자가 필요 합니다, 그리고 그 두 번째 
인자는 점이 되는 것이 좋습니다. 비교를 하기위해서입니다
네 학생? 
교수 : 여러분은 무엇이 일어 난다고 생각 하나요? 
미안해요, 질문은, 제가 만약 p 가 q 보다 작다고 말하면
무슨 일이 일어 나나요?입니다. 
해 보세요, 네? 
매우 명백해 보이는 군요, 그렇죠? 
다음 시간에 저는 맞는 안경을 가지고 오겠습니다.
그것은 여전이 cmp 를 부릅니다, 그러나 그것은 cmp 가
단지 인자들의 순서를 뒤집는 다는 것을 알고 있습니다. 
네, 이것은 말이 되네요.
x y 순서의 인자들이 바뀌어 

English: 
PROFESSOR 2: -- other,
it could have said
who or zort or --
PROFESSOR: Yeah, sorry, that
was part of the question, I
could have a picked foobar could
put anything in here.
It's simply, notice the form of
it here is, it's going to
take two arguments, and
you're right, self is
the original instance.
This says, I need a second
argument to it, and that
second argument better be
a point so I can do the
comparison.
Yes ma'am?
STUDENT: [INAUDIBLE]
PROFESSOR: What do you
think happens?
Sorry, the question was, what
happens if I said p
is less than q?
Got it, yes?
Seems pretty obvious, right?
Next time I bring the
right glasses.
It's still calling cmp, but it's
knowing that cmp is just
reversing the order
of the arguments.
Ok, which makes sense.
If greater than takes, expects,
arguments in order x

English: 
y, less than simply takes
greater than, but with the
arguments reversed.
OK, so I don't have to, it's a
great question, I don't have
to create a second
one for cmp.
Cmp is just saying, is this
bigger than, and if I want to
reverse it, it goes
the other way.
Question?
STUDENT: [INAUDIBLE]
PROFESSOR: Or equal equal?
Let's try equal equal because
I didn't define it here.
It says they're not the same,
and boy, I need help on this
one, John, it's not, there's
no pre-defined eq in there.
PROFESSOR 2: So, what cmp does,
and maybe this isn't
exactly the right way to write
is, is cmp actually returns 1
of 3 values.
A 0, minus a positive value,
zero or a negative value,
depending upon whether
it's less than,
equal, or greater than.
PROFESSOR: Right.
PROFESSOR2: So it's not really
a Boolean-valued function.
It has 3 possible values
it could return.

Korean: 
작은 것이 큰 것을 가집니다, 
뒤 바뀐 인자들을 가지고요. 
네, 그래서 저는 하지 않아야 합니다, 그것은 좋은 질문 입니다. 
저는 cmp 를 위한 두 번째 것을 만들지 않아야 합니다.
Cmp 는 단지 말합니다, 이것은 더 크냐고요, 그리고 만약 
제가 그것을 바꾸고 싶으면, 그것은 다른 방법으로 갑니다.
질문 있나요? 
 
교수 : 또는 = = 이면요?
= = 을 시도 해 봅시다. 왜냐하면 저는 여기서 그것을 정의하지 않았기 때문 입니다. 
그것은 그들이 같지 않다고 말하는 군요, 그리고 학생, 저는 이 도움이 필요합니다. 
존, 그것은 아닙니다, 거기서는 미리 정의된 eq 가 없습니다. 
교수 2 : 그래서, cmp 가 하는 것, 그리고 아마 이것이 정확히 
쓰는 옳은 방법이 아닌 것은 cmp 가
실제 3 개중 1개의 값을 리턴 합니다. 
양수 값, 0 또는 음수 값, 
그것이 더 작은지, 같은지, 
더 큰지에 따라서요. 
교수 : 맞습니다. 
교수 2 : 그래서 그것은 정말로 불리언 값의 함수가 아닙니다. 
그것은 그것이 리턴 할 수 있는 3 가지 값을 가집니다. 

English: 
PROFESSOR: And so in this case,
it's using the same
piece, but it's returning that
middle value that says they're
actually the same.
Right, one the things you can
see now is, we start building
up classes, we get
these methods.
So you can actually say, how
do I know which methods are
associated with the class?
For that, we can call dir.
And what it does, is it gives
me back a listing of all the
things, all the methods, that
are associated with it.
Some of which I built:
cmp, init, str.
And there, notice, are the
internal definitions and there
are the internal variables.
And in fact I should've
said, we often call
those things fields.
So inside of an instance,
associated with an instance,
we have both methods
and fields.
These are both altogether
called
attributes of the instance.
And then there were a couple of
other ones in there that I

Korean: 
교수 : 그리고 그래서 이 경우에, 그것은 같은 것을 사용하고 있습니다, 그러나 
그것은 그 중간 값을 리턴 하고 있습니다 그것은 그들이
실제 같은 것 이라고 말하고 있습니다. 
맞아요, 여러분이 이제 볼 수 있는 한 가지는, 우리는 클래스를 
만들기 시작 했습니다, 우리는 이 메소드들을 가집니다
그래서 여러분은 실제로 말합니다, 제가 어떻게 어떤 메소드들이
클래스와 연관 되어 있는지 알 수 있나요? 
그것을 위해서, 우리는 dir 를 호출 합니다
그리고 그것이 하는 것은, 그것은 저에게 모든 것의 리스트를 돌려 줍니다,
모든 연관된 메소드들을요
제가 만든 것 들 중 몇 가지 입니다 : cmp, init, str. 
그리고 주목하세요, 내부의 정의들이 있습니다.
그리고 내부의 변수들이 있습니다. 
그리고 사실 저는 말했어야 했어요, 우리는 종종 
그것들을 fields 라고 부릅니다.
그래서 인스턴스 내부에, 인스턴스와 연관 되어 있어서, 
우리는 메소드들과 fields 를 갖습니다.
이것들은 모두 함께 인스턴스의 속성들 이라고 불립니다.
이것들은 모두 함께 인스턴스의 속성들 이라고 불립니다.
그리고 나서 거기에는 다른 것들이 있습니다

English: 
hadn't actually dealt with.
The reason I want to point this
out to you is, if we go
back up to the kinds of data
objects we started with,
floats, ints, strings, they
actually behave the same way.
They are instances of a class,
and associated with that class
is a set of methods.
So for example, I can say,
what are all the methods
associated with the number,
or the integer 1?
And you probably recognize some
of them in there, right,
absolute value, add, comp, cors,
well we didn't do cors,
we did a bunch of
other things.
It could also say, what are the
methods associated with
the string, 1.
I'm sure you can quickly
graph it, but notice
they aren't the same.
That makes sense.
We have some set of things we
want to do with strings, and
different set of things we
want to do with numbers.
But underlying Python
is the same idea.
These are instances of a class,
and associated with
that class are a set
of methods, things

Korean: 
아직 사실 그것을 다루지는 않았습니다. 
제가 이것을 여러분에게 지적하고 싶은 이유는, 만약 우리가 시작한 
데이터 객체들, floats, ints,
strings 로 우리가 돌아 간다면, 그것들을 사실 같은 방법으로 행동 합니다. 
그것들은 클래스의 인스턴스들 입니다, 그리고 그 클래스와
연관 된 것은 메소드의 집합 입니다. 
그래서 예를 들어, 저는 말할 수 있습니다, 
숫자, 또는 정수 1 과 연관된 모든 메소드들은 무엇 입니까?
그리고 여러분은 아마 거기서 그것들 중 몇 가지를 알아차릴 것 입니다, 
네, 절대 값, add, comp, cors 입니다, 그런데 우리는 cors 를 하지 않았습니다,
우리는 많은 다른 것들을 했습니다.
그것은 또한 말할 수 있습니다, 
문자, 1 과 관련 있는 메소드들은 무엇인지를요. 
저는 여러분이 빠르게 그 도표를 본다고 확신합니다, 그러나 
그것들이 같지 않다는 것에 주목하세요. 
그것은 말이 됩니다. 
우리는 우리가 문자열들로 하길 원하는 것들의 어떤 집합을 가지고 있습니다,
그리고 우리가 숫자들로 하길 원하는 것들의 다른 집합 도요. 
그러나 파이썬에 내재 된 것도 같은 생각 입니다.
이것들은 클래스의 인스턴스들 입니다, 그리고 

English: 
that I can deal with.
So this is a handy way of being
able to see, what are in
fact the methods that are
available if I don't happen to
remember them, and want
to go back to them.
OK, I want to spend the last few
minutes just showing you a
couple of other things that
we can do in here.
Let me see where I want
to go with this.
So let's add one more
piece to this.
OK, now that I've got points,
I might want to do something
with points.
So an easy thing to do in planar
geometry is I want to
make a line segment.
It's got a start point,
it's got an end point.
Right, if you want to think
of it back over here.
There's a line segment, it's
got a starting point and
ending point.
Well, I can do the same thing.
And the reason I want to use
this as an example is, here's
my little definition
of segment.
Again, it's got an initializer,
or an instance
creator, right there.
Takes a start and an end point,
just going to bind

Korean: 
그것과 관련 된 것은 메소드들의 집합 입니다. 그것은 제가 다룰 수 있는 것 입니다. 
그래서 이것은 볼 수 있는 간단한 방법 입니다, 사실
사용 가능한 어떤 메소드들이 있는지를요, 만약 제가 그것들을 기억하지 않았는데, 
그것들로 돌아가고 싶을 때 사용할 수 있습니다. 
네, 저는 남은 몇 분을 단지 여러분에게 우리가 여기서 할 수 있는 
다른 것들 몇 가지를 보여주는데 보내길 원합니다.
제가 이것과 무엇을 하고 싶은지 보겠습니다.
이것에 한 가지를 더 더해보겠습니다. 
네, 이제 제가 점을 갖기 때문에, 저는 점으로
하는 것을 원합니다. 
그래서 평면의 기하학에서 하는 쉬운 방법은 
제가 라인 세그먼트를 만드는 것 입니다
그것은 시작 점을 가집니다, 그것은 끝 점을 가집니다. 
좋아요, 만약 여러분이 그것을 여기 뒤에서 다시 생각하고 싶으면요. 
라인 세그먼트가 있습니다, 그것은 
시작 점과 끝 점을 가집니다. 
자, 저는 같은 것을 할 수 있습니다.
그리고 제가 이것을 예제로 사용하길 원하는 이유는 여기에 
제 작은 세그먼트의 정의가 있기 때문 입니다. 
다시, 그것은 초기화하는 것을 갖습니다, 또는 인스턴스 
생성자를 갖습니다, 바로 저기서요. 
시작 그리고 끝 점을 갖습니다, 지역 변수 이름 start 그리고 end 를 

English: 
local variable names start
and end to those pieces.
But notice now, those aren't
just simple things like
numbers, those are
actually points.
And that's where the modularity
comes in.
Now I have the ability to say,
I've got a new class, I can
create instances of a line
segment, and it's elements are
themselves instances of points.
OK?
And then what might I want
to do with the segment?
I might want to get the
length of the segment.
And I know it's kind of, you can
see it on your handout, it
has the rest of the
pieces over here.
Ok, what's the geometry say?
The length of a line segment?
Well, it's Pythagoras, right?
I take the difference in the
x-values, squared, the
difference in the y-values,
squared, add them up, take the
square root of that.
Notice what this says to do.
It says if I want to get the
length of a segment, going to
pass in that instance, it says
from that instance, get the
start point, that's the
thing I just found.
And then from that start
point, get the x-value.
Same thing, from that instance,
get the endpoint,

Korean: 
이것들로 묶을 것 입니다.
그러나 지금은 주목하세요, 이것들은 숫자들과 같은 단순한 것이 아닙니다, 
이것들은 실제 점들 입니다. 
그리고 그것은 모듈 방식이 들어 오는 곳 입니다
이제 저는 말할 수 있습니다, 저는 새 클래스를 가집니다, 
저는 라인 세그먼트의 인스턴스들을 만들 수 있습니다, 그리고 그것의 요소들은
점의 인스턴스들 입니다. 
그렇죠? 
그리고 나서 제가 세그먼트로 하고 싶은 것은 무엇 입니까? 
저는 세그먼트의 길이를 얻고 싶습니다. 
저는 알수 있습니다, 여러분은 그것을 여러분의 핸드 아웃에서 볼 수 있습니다
그것은 여기 나머지에서 볼수 있습니다. 
네, 기하학이 뭐라고 말합니까? 
라인 세그먼트의 길이요? 
자, 그것은 피타고라스 입니다, 네? 
저는 제곱 된 x 값들에서의 차,
제곱 된 y 값들에서의 차를 가집니다, 그것들을 더합니다, 
그것의 제곱근을 구합니다.
이것이 무엇을 하는 것을 말하는지 주목하세요. 
그것은 제가 세그먼트의 길이를 구하고 싶으면,
그 인스턴스에서 전해 주고, 그것은 그 인스턴스에서 말합니다,
시작 점을 얻습니다, 그것은 제가 방금 찾은 것 입니다. 
그리고 나서 그 시작 점으로부터, x 값을 구합니다. 

English: 
from that end point get
the x-value, square.
Add the same thing to the
y-values, squared, take the
square root.
Yes, ma'am?
STUDENT: So are you entering a
tuple in for start and end?
PROFESSOR: No.
I'm entering -- well,
let's look at the
example right down here.
In fact, let me uncomment
it so we can look at it.
All right.
I'm going to uncomment that.
So notice what I'm
going to do.
I'm going to build, this case,
a Cartesian point, I'm going
to build a second Cartesian
point, and my segment passes
in those class instances.
All right, they're not tuples,
they're simply an instance
with some structuring.
And in fact if I go off and
run this, OK, what I was
printing here was s 1 dot
length, and that's --
What is it doing?
S 1 is a segment.
It has inside of it
pointers to 2
points which are instances.
And when I call length on this,
it takes that starting

Korean: 
마찬가지로 그 인스턴스로부터 끝 점을 얻습니다, 
그 끝 점으로부터 제곱 된 x 값 을 얻습니다. 
또 제곱 된 y 값에 더하세요, 
제곱근을 구하세요. 
네, 학생? 
학생 : 그래서 시작과 끝을 위해 교수님이 튜플로 들어 갑니까? 
교수 : 아니요, 
저는 들어 갑니다 – 자, 바로 아래 
여기 예를 봅시다. 
사실, 저는 그것을 말하지 않을 것 입니다
좋아요.
저는 그것을 말하지 않을 것 입니다. 
그래서 제가 하려는 것이 무엇인지 주목하세요. 
저는 이 경우에 Cartesian point 를 만들려고 합니다,
저는 두 번째 Cartesian point 를 만들 것 입니다, 그리고 제 세그먼트는 
이 클래스 인스턴스들에 전해 집니다.
좋아요, 그것들은 튜플들이 아닙니다, 그것들은 어떤 구조를 가진 단지 
인스턴스 입니다. 
그리고 사실 제가 가서 이것을 런 하면, 네, 제가 여기서 출력 하는 것은
점 길이입니다. s.length죠,
S 1 은 세그먼트 입니다. 
그것은 그것의 내부에 포인터를 가지고 있습니다, 인스턴스들인 2 점들을요.

Korean: 
그리고 제가 이것에서 길이를 호출 할 때, 그것은 그 시작 점을 가지고, 
x 좌표를 보내라고 말하는 메시지를 보냅니다, 
끝 점을 가지고, x 좌표를 주라고 말합니다, 
그리고 그것들을 함께 더합니다.
이제, 저는 이것을 몇 분 전에 미리 보았습니다 
구탁 교수가 저를 좋아하지 않는 것을 말하는 것에 대해서요.
그는 일반적으로 저를 좋아하지 않습니다, 그러나 그것은 그와 나 사이의 문제 입니다. 
그는 테니스에서 정기적으로 저를 이깁니다, 
그것은 제가 그를 좋아하지 않는 이유 입니다.
미안해요, 존.
이것은 녹화 되고 있습니다, 그것은 정말 좋은 것이에요, 그렇죠? 
그래서 왜 제가 그것을 말하고 있죠? 
저는 말했습니다, 만약 제가 정말로 위생적이면, 
그러면 여러분은 이제 제가 얼마나 자주 샤워를 하는지 궁금할 수 있나요?
만약 제가 정말 위생적 이라면요. 
저는 메소드를 통해서 변수들에 오직 접근 합니다. 
그리고 여기서 저는 속이고 있습니다, 네, 왜냐하면 제가 무엇을 하고 있죠?
시작이 점이 된다는 사실의 이점을 취하고 있습니다, 
그리고 저는 직접적으로 말하고 있습니다, x 값을 주세요. 
그래서 저는 알지 못합니다, 존, 저는 제가 이것을 더 좋게 쓸 수 있다면, 
저는 x 그리고 y 값을 리턴 하는 
메소드를 갖는다고 주장 합니다, 그리고 그 방식으로
그것 후에 가는 것은 더 깨끗 합니다. 
이것은 좋은 지름길 입니다, 좋아요, 그러나 그것은 
사실 제가 아마도 다르게 하길 원하는 것 입니다. 
왜 저는 그것을 다르게 하길 원하나요?

English: 
point, sends it the message
saying give me your
x-coordinate, takes the
endpoint, says give me your
x-coordinate, and add
them together.
Now, I prefaced this a few
minutes ago about saying
Professor Guttag wasn't
going to like me.
He doesn't like me generally,
but that's between he and I.
He beats me regularly at
tennis, which is why
I don't like him.
Sorry, John.
This is being taped, which
is really good, isn't it?
So why am I saying that?
I said that if I was really
hygienic, and you can now
wonder about how often
do I shower?
If I was really hygienic.
I would only ever access the
values through a method.
And I'm cheating here, right,
because what am I doing?
I'm taking advantage of the fact
that start is going to be
a point, and I'm just directly
saying, give me your x-value.
So I don't know don't, John, I
would argue if I'd written
this better, I would have had a
method that returned the x-
and the y- value, and it
would be cleaner to go
after it that way.
This is nice shorthand, all
right, but it's something that
in fact I probably would
want to do differently.
Why would I want to
do it differently?

English: 
Imagine that I've written
code like this,
written a bunch of code.
And I originally decided I was
going to have as points, it's
going to have internal values
of an x and a y.
And then somewhere along the
line, I decide to store things
in a different representation.
If I had had a clean interface,
that I had a
specific method to get those
values out, I wouldn't have to
change anything.
Other than that interface.
But here, if I decide I'm going
to store things not in x
and y, but with some other set
of names, for example, I've
gotta go back into these pieces
of code that use the
points, and change them.
So I've lost modularity.
I'd really like to have that
modularity that says, I'm only
going to get access to the
values, not by calling their
names, but by calling some
specific method to get access
to their names.
You could argue, well, x is
in some sense inherently a
method, but it's not nearly as
clean as what I would like.
And the last piece I want you to
see here, and then I'll let
you go is, notice now how that
encapsulation, that binding

Korean: 
제가 이와 같은 코드를 썼다고 상상해 보세요, 
많은 코드를요.
그리고 저는 원래 점으로써 기질 것이라고 결심 했습니다, 
그것은 x 그리고 y 의 내부 값을 가질 것 입니다. 
그리고 나서 라인을 따라 어딘가에서, 저는 그것들을 
다른 표현으로 저장하기로 결심 했습니다. 
만약 제가 깨끗한 인터페이스를 가지고 있다면, 저는 이 값들을 만들어 내는 구체적인 메소드를
가지고 있습니다, 그러면 저는 어떤 것도
바꾸지 않아야 합니다. 
그 인터페이스 외에는요
그러나 여기서, 만약 제가 그것들을 x 와 y 가 아니라, 
다른 이름의 집합들로 저장하기로 결심했다면, 예를 들어,
저는 점을 사용한 이 코드들로 다시 돌아 와서, 바꾼다면
그들의 이름에 접근하는 어떤 특정한 메소드를 호출함으로써 접근 할 것입니다.
그래서 저는 모듈 방식을 잃습니다. 
저는 정말로 그 모듈 방식을 가지고 싶습니다, 
그들의 이름을 부름으로써가 아니라, 
그들의 이름에 접근하는 어떤 특정한 메소드를 호출함으로써 
접근 할 것입니다.
여러분은 주장할 수 있습니다, 자, x 는 어떤 의미에서 선천적으로 메소드 입니다, 
그러나 그것은 제가 좋아하는 것 만큼 거의 깨끗하지 않습니다. 
그리고 제가 여기서 여러분에게 보여 주고 싶은 마지막 것은, 그리고 나서 
저는 여러분을 보내 드릴게요, 이제 그 캡슐화가, 

Korean: 
그 함께 묶은 것이 정말 저를 도와주었는지 주목하세요. 
주어진 추상화에서, 어떤 값을 가진
인스턴스로써의 점의 개념을 추상화하면서, 저는 이제 
세그먼트를 만드는 것을 시작할 수 있습니다.
그리고 저는 이제 그것을 연장 할 수 있습니다. 
저는 다각형의 것을 가질 수 있습니다,
그것은 세그먼트의 연속입니다. 
이 다른 인스턴스들이 어디로부터 만들어졌는지 
클래스에서 간단히 메소드를 호출함으로써
어떻게 제가 그것들을 사용하고 싶은지에 대한 자세한 것들은
다음에 알아 보겠습니다. 우리는 이 다음 시간에 돌아 오겠습니다. 

English: 
things together has
really helped me.
Given the abstraction, the
notion of a point as an
instance with some
values, I can now
start building segments.
And I could now extend that.
I could have, you know,
polygonal figures, that are a
sequence of segments.
And I would be able to simply
bury away the details of how
those other instances are
created from how I want to use
them by simply calling methods
on the classes.
We'll come back to
this next time.
