
English: 
ANNOUNCER: Open 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 JOHN GUTTAG:
Good morning.
We should start with the
confession, for those of you
looking at this on
OpenCourseWare, that I'm
currently lecturing to
an empty auditorium.
The fifth lecture for 600 this
term, we ran into some
technical difficulties, which
left us with a recording we
weren't very satisfied with.
So, I'm-- this is a redo, and if
you will hear no questions
from the audience and that's
because there is no audience.
Nevertheless I will do
my best to pretend.

Korean: 
이 강의의 한국어자막은 www.snow.or.kr 자원활동가들에 의해 작성되었습니다.
이 강의의 한국어자막은 www.snow.or.kr 자원활동가들에 의해 작성되었습니다. 다음 내용은 저작권으로
보호되어 있습니다.
MIT OCW(무료공개강좌)는 계속해서 고품질의 교육지원을
무료로 제공함으로써 여러분을 도와줄 것입니다.
추가로 MIT 코스의 자료를 보거나
제공하시려면 ocw.mit.edu 으로
방문해주세요.
안녕하세요
이 강의를 OpenCourseWare 로 보고 있는 여러분을 위해 
제가 빈 강당에서 현재 강의를 하고 있다는 
고백으로 시작 해야겠군요. 
이번 학기 600의 5번 째 강의에서,
우리는 기술적 문제가 있었어요,
그것은 우리가 매우 만족 할 수 없는 녹화를 남겼습니다. 
그래서, 저는 다시 하고 있습니다, 그리고 여러분이 학생들로부터 아무 대답도 듣지 못한다면
그것은 학생들이 아무도 없기 때문 입니다. 
그렇지만 저는 그런 최대한 학생들이 있는 척 할겁니다

Korean: 
저는 C-SPAN이 유일하게 보는 것일 때
미국 국회 전에 이야기 하는 것과 약간 비슷하게 이것을 들었습니다.
좋아요.
컴퓨터는 숫자들을 고속으로 처리하는데 좋은 것입니다. 
그리고 우리는 이 학기에 숫자들을 약간 볼 것입니다. 그러나 저는 
우리가 하고 있는 것 보다 지금 그것들에 대해 더욱 깊이 알아 보고 싶습니다.
우리가 지금까지 계속해서 하고 있죠.
파이썬은 두 개의 다른 수의 종류들을 가지고 있습니다.
지금까지, 우리가 정말 주의를 기울였던 유일한 것은 
int 타입이었습니다.
그리고 그것들이 정수들을 반영하려는 의도였습니다.
우리 모두가 초등학교 때부터 배우기 시작했던 것처럼요.
그리고 그들은 여러분이 셀 수 있는 것을 위해 좋습니다. 
여러분은 어디서나 전체의 수를 사용할 수 있어요.

English: 
I've been told this is a little
bit like giving a
speech before the US Congress
when C-SPAN is
the only thing watching.
OK.
Computers are supposed to be
good for crunching numbers.
And we've looked a little bit
at numbers this term, but I
now want to get into looking
at them in more depth than
we've been doing.
Python has two different
kinds of numbers.
So far, the only kind we've
really paid any attention to
is type int.
And those were intended to
mirror the integers, as we all
learned about starting
in elementary school.
And they're good for things
that you can count.
Any place you'd use
whole numbers.

Korean: 
흥미롭게도, 다른 언어와 달리, 파이썬은 
임의 정밀도 정수라고 불리는 것을 가집니다. 
그것에 의해, 여러분은 여러분이 원하는 한
크게 숫자들을 만들 수 있습니다.
예를 들어 봅시다. 
우리는 a 를 변수 이름으로 가질 것입니다, 그리고 우리는 
a 를 2의 1000승 으로 할 것입니다.
그런데, 그것은 정말 큰 수네요.
그리고 지금 우리가 이것을 시도해서 보여 주려고 하면 무슨 일이 일어나죠?
우리는 많은 숫자를 얻게됩니다
여러분은 왜 제가 이것을 칠판에 쓰는 대신
스크린에 하는지 알 수 있습니다.
저는 여러분에게 여러분이 이것이 옳은 답이라고 믿는지 아닌지를 
물어보지 않을 것 입니다, 저를 믿으세요, 파이썬을 믿으세요. 
여러분에게 알려주고 싶군요, 이것의 가장 마지막은
문자 L 입니다. 
이것이 무엇을 의미하죠?

English: 
Interestingly, Python, unlike
some languages, has what are
called arbitrary precision
integers.
By that, we mean, you can
make numbers as big as
you want them to.
Let's look at an example.
We'll just take a for a variable
name, and we'll set a
to be two raised to the
one-thousandth power.
That, by the way, is a
really big number.
And now what happens if
we try and display it?
We get a lot of digits.
You can see why I'm doing this
on the screen instead of
writing it on the blackboard.
I'm not going to ask you whether
you believe this is
the right answer, trust
me, trust Python.
I would like you to notice, at
the very end of this is the
letter L.
What does that mean?

Korean: 
그것은 길다는 것을 의미합니다. 
그것은 우리에게 그것이 이것을 나타 낸다는 것을 알려 줍니다
이것은 소위 내부의 긴 형식의
특정한 정수에요. 
여러분은 그것에 대해 걱정할 필요가 없습니다.
긴 정수를 다룰 때, 그것에 대해 말하는 오직 한 가지는, 
그것은 여러분이 작은 수들을 다룰 때 보다
많이 덜 효율적이라는 것입니다
그리고 그것이 여러분에게 경고해 주는 전부에요
이 L 을 프린트해 줌으로써요. 
20억은 마법의 수입니다
여러분에 20억을 넘으면, 긴 정수들을 다룰 것입니다.
예를 들어, 여러분이 
미국 재정 적자를 다루고자 한다면, 여러분은 L 타입의 정수가 필요할 것입니다. 
좋습니다.
다른 흥미로운 예를 살펴 봅시다.

English: 
It means long.
That's telling us that it's
representing these-- this
particular integer in
what it calls it's
internal long format.
You needn't worry about that.
The only thing to say about it
is, when you're dealing with
long integers, it's a lot less
efficient than when you're
dealing with smaller numbers.
And that's all it's kind of
warning you, by printing this
L.
About two billion is
the magic number.
When you get over two billion,
it's now going to deal with
long integers, so if, for
example, you're trying to deal
with the US budget deficit, you
will need integers of type
L.
OK.
Let's look at another
interesting example.

Korean: 
제가 b 가 2의 999승이라고 말했다고 
가정해 보세요. 
저는 b 를 보여 줄 수 있습니다. 그리고 그것은
다른 수 입니다. 상당히 더 작지만, 다시, L 로 끝납니다. 
그리고 지금, 우리가 a 를 b 로 나누려고 한다면 저는 무엇을 얻죠?
그리고 기억하세요, 우리는 지금 정수 나눗셈을 하고 있습니다. 
자, 봅시다. 
우리는 2L 을 얻습니다. 
2라고 예상했을 겁니다. 왜냐하면 여러분이 멱법에 대해 생각해 보면
정말로, 무엇을 999 힘과 
1000번 째 힘으로 올리는 것의 차이는, 
이 경우에 2입니다.
왜냐하면 그것은 우리가 곱으로 올리는 것이기 때문 입니다.
왜 그것이 2L 입니까, 네?
2는 20억 보다 상당히 작습니다, 그리고 그것은 

English: 
Suppose I said, b equal to two
raised to the nine hundred
ninety-ninth power.
I can display b, and it's a
different number, considerably
smaller, but again,
ending in an L.
And now, what you think I'll get
if we try a divided by b?
And remember, we're now doing
integer division.
Well, let's see.
We get 2L.
Well, you'd expect it to be
two, because if you think
about the meaning of
exponentiation, indeed, the
difference between raising
something to the nine hundred
ninety-ninth power and to the
one-thousandth power should
be, in this case, two, since
that's what we're
raising to a power.
Why does it say 2L, right?
Two is considerably less than
two billion, and that's

Korean: 
여러분이 한 번 (긴정수) L을 얻으면, L의 형태를 유지하기 때문입니다.
특별히 중요한 것은 아니지만, 여러분이 알아 둘 만한 것입니다. 
자, 왜 제가 숫자들이 컴퓨터에 어떻게 나타 나는지에 대한 이 전체 이슈로 
여러분을 귀찮게 하고 있습니까? 
이상적인 세계에서, 여러분은 이 것을 완전히 무시할 수 있습니다, 그리고 
이렇게 말합니다, 숫자들은 숫자들이 하기로 되어 있는 것을 한다고요. 
그러나 우리가 보려고 하는 것처럼, 때때로 파이썬 에서, 그리고 
사실 모든 프로그래밍 언어에서, 그것들은
여러분의 직관이 제안하는 것과 반대로 행동합니다. 
그리고 저는 여러분이 왜 이것이 일어 나는지 이해하는 것을 돕는데 
시간을 조금 쓰고 싶습니다. 
그래서 다른 종류의 수를 봅시다.
 
93
00:05:41,589 --> 00:05:48,619
그리고 이제 우리는 파이썬, 그리고 거의 모든 
다른 프로그래밍 언어가 실수 타입을 부르는 것을 보려고 합니다.

English: 
because once you get L, you
stay L. Not particularly
important, but kind
of worth knowing.
Well, why am I bothering you
with this whole issue of how
numbers are represented
in the computer?
In an ideal world, you would
ignore this completely, and
just say, numbers do what
numbers are supposed to do.
But as we're about to see,
sometimes in Python, and in
fact in every programming
language, things behave
contrary to what your
intuition suggests.
And I want to spend a little
time helping you understand
why this happens.
So let's look at a different
kind of number.
And now we're going to look at
what Python, and almost every
other programming language,
calls type float.

English: 
Which is short for
floating point.
And that's the way that
programming languages
typically represent what we
think of as real numbers.
So, let's look at an example.
I'm going to set the variable
x to be 0.1, 1/10, and now
we're going to display x.
Huh?
Take a look at this.
Why isn't it .1?
Why is it 0.1, a whole bunch
of zeros, and then this
mysterious one appearing
at the end?
Is it because Python just wants
to be obnoxious and is
making life hard?
No, it has to do with the way
the numbers are represented
inside the computer.
Python, like almost every modern
programming language,

Korean: 
그것은 부동 소수점의 준말 입니다.
그리고 그것은 프로그래밍 언어가 전형적으로 
우리가 실제 수로 생각하는 것을 나타 내는 방법 입니다. 
그래서, 한 가지 예를 봅시다. 
저는 변수 x를 0.1, 1/10 로 할 것입니다, 그리고 지금 
우리는 x 를 보여 줄 것 입니다. 
어?
 
102
00:06:29,750 --> 00:06:31,639
이것을 봅시다.
왜 .1 이 아닙니까?
왜 0들의 전체 묶음인 0.1 이고 이 미스터리 한 것이 
결국엔 나타 납니까? 
이것은 파이썬이 단지 아주 불쾌한 것이 되려 하고
삶을 힘들게 만들기 때문 입니까? 
아닙니다, 그것은 컴퓨터 내부에 숫자들이 나타 나는 방법과 
관련이 있습니다.
대부분의 모든 현대 프로그래밍 언어처럼, 파이썬은
 
111
00:06:59,800 --> 00:07:05,560
i 트리플 e 부동 소수점 표준을 사용하는 숫자들을

English: 
represents numbers using the
i triple e floating point
standard, and it's
i triple e 754.
Never again will you have to
remember that it's 754.
I promise not to ask you that
question on a quiz.
But that's what they do.
This is a variant of scientific
notation.
Something you probably learned
about in high school, as a way
to represent very
large numbers.
Typically, the way we do that,
is we represent the numbers in

Korean: 
나타 냅니다, 그리고 그것은 i 트리플 e 754 입니다. 
여러분은 그것이 754 라는 것을 절대 다시 기억하지 않아도 될 것입니다.
저는 여러분에게 그 질문을 퀴즈에서 하지 않을 것임을 약속 합니다.
그러나 그것이 그것들이 하는 것 입니다. 
이것은 과학적인 표기법의 변종 입니다. 
여러분은 아마 고등 학교에서 배웠을 것입니다, 
매우 큰 수들을 나타 내는 방법으로써요. 
전형적으로, 우리가 그것을 하는 방법은 우리가 가수와 지수의 형태에서

Korean: 
숫자들을 나타내는 것 입니다. 
그래서 우리는 부동 소수점 수를 
가수와 지수의 쌍으로 나타냅니다. 
그리고 컴퓨터가 이진 시스템에서 작동하기 때문에, 
그것은 여러분이 아마 고등 학교에서 배운 것과 다를 것입니다. 
거기선 우리가 10을 어떤 수로 제곱했었죠 .
여기서 우리는 항상 2를 어떤 수로 제곱할 겁니다. 
아마 학기 조금 나중에, 만약 여러분이 컴퓨터 건축에 대해 이야기 한다면
우리는 왜 컴퓨터가 이진으로 작동하는지 설명할 것입니다
그러나 지금은, 단지 그들이 한다고 가정하세요 그리고 
사실 그들은 항상 그렇게 합니다. 
좋아요.

English: 
the form of a mantissa
and an exponent.
So we represent a floating point
number as a pair, of a
mantissa and an exponent.
And because computers work in
the binary system, it's unlike
what you probably learned in
high school, where we raise
ten to some power.
Here we'll always be raising
two to some power.
Maybe a little later in the
term, if we talk about
computer architecture, we'll get
around to explaining why
computers working binary, but
for now, just assume that they
do and in fact they
always have. All right.

English: 
Purists manage to refer to the
mantissa as a significant, but
I won't do that, because I'm
an old guy and it was a
mantissa when I first learned
about it and I just can't
break myself of the habit.
All right.
So how does this work?
Well, when we recognize so--
when we represent something,
the mantissa is between
one and two.
Whoops.
Strictly less than two, greater
than or equal to one.

Korean: 
순수주의자들은 가수를 중요한 것으로 언급합니다, 그러나 
나는 그렇게 하지 않을 것입니다, 왜냐하면 저는 오래 된 사람이고
처음 가수를 배웠을 때의 가수이고  
저는 습관을 깰 수 없기 때문 입니다.
좋아요.
그래서 이것이 어떻게 작동하죠? 
자, 우리가 깨달았을 때-- 우리가 무엇을 나타낼 때,
가수는 1과 2 사이 입니다. 
아이고
엄격히 말하면 2 보다 작고, 1 보다 크거나 같습니다. 

Korean: 
지수의 범위는 -1022 에서 +1023 까지 입니다. 
그래서 이것은 우리가 10의 308승 수까지를 
나타 내도록 합니다, 플러스 마이너스 10의 308승이요
그래서, 꽤 큰 범위의 수들 입니다. 
이 마법 같은 일들이 어디서 왔나요? 
여기 이상한 수들이 있어요. 
자, 이것은 컴퓨터가 전형적으로 그 안에 워드들을 가지고 있다는 사실과 
관련이 있습니다. 그리고 현대 컴퓨터에서 워드는 
오늘날 64 비트 입니다. 
오래 동안 그들은 32 비트 였고, 그 전에는 16 비트 였습니다,
그 전에는 8 비트 였어요, 그들은 계속 해서 
증가해 왔습니다, 그러나 우리는 당분 간은 64 비트에 있습니다 그리고 저는 우리가 

English: 
The exponent, is in the
range, -1022 to +1023.
So this lets us represent
numbers up to about 10 to the
308th, plus or minus 10 to
the 308th, plus or minus.
So, quite a large range
of numbers.
Where did these magic
things come from?
You know, what-- kind of a
strange numbers to see here.
Well, it has to do with the fact
that computers typically
have words in them, and the
words today in a modern
computer are 64 bits.
For many years they were 32
bits, before that they were 16
bits, before that they were 8
bits, they've continually
grown, but we've been at 64 for
a while and I think we'll

Korean: 
당분 간은 64 비트에 머물 것이라고 생각 합니다.
그래서 우리가 이것을 할 때, 우리가 하는 것은, 우리는 그 사인에서 1 비트를 얻습니다
양수 인가요 음수 인가요 — 지수로는 11
그것은, 그리고 그것은 가수로는 52를 남깁니다. 
그리고 그것은 기본적으로 우리에게 우리가 어떻게 숫자들을 저장하는지 알려 줍니다. 
안녕하세요, 학생 600 강의를 위해 왔나요? 
오늘은 수업이 없어요, 왜냐하면 우리는 오늘 저녁에 퀴즈가 있습니다. 
지금은 정상적으로 수업이 시작되는 시간 입니다, 
그리고 우리가 오늘 저녁에 강의 대신 퀴즈가 있다는 것을 
잊어 버린 몇몇 학생들이 왔었고, 
지금은 나갔군요. 
좋습니다.

English: 
be stuck at 64 for a while.
So as we do this, what we do
is, we get one bit for the
sign-- is it a positive
or negative number?--
11 for the exponent, and that
leaves 52 for the mantissa.
And that basically tells us
how we're storing numbers.
Hi, are you here for
the 600 lecture?
There is none today, because we
have a quiz this evening.
It's now the time that the
lecture would normally have
started, and a couple of
students who forgot that we
have a quiz this evening,
instead of a lecture, just
strolled in, and now
strolled out.
OK.

English: 
You may never need to know these
constants again, but
it's worth knowing that they
exist, and that basically,
this gives us about the
equivalent of seventeen
decimal digits of precision.
So we can represent numbers
up to seventeen
decimal digits long.
This is an important concept to
understand, that unlike the
long ints where they can grow
arbitrarily big, when we're
dealing with floating points, if
we need something more than
seventeen decimal digits, in
Python at least, we won't be
able to get it.
And that's true in
many languages.
Now the good news is, this is
an enormous number, and it's
highly unlikely that ever in
your life, you will need more
precision than that.
All right.

Korean: 
여러분은 이 정수들을 다시 알아야 할 필요는 전혀 없습니다, 그러나 
그들이 존재 한다는 것은 알아 둘 가치가 있습니다. 그리고 기본적으로, 이것은 
우리에게 정확한 십진수 17 과 
동등한 것에 대해 알려 줍니다. 
그결과 우리는 17까지의 숫자들을
10진법의 숫자들로 나타낼 수 있죠.
이것은 다음을 이해하기 위한 중요한 개념 입니다.
 
173
00:12:26,409 --> 00:12:30,219
제멋대로 커질 수 있는 긴 정수들과 달리, 
우리가 부동 소수점을 다룰 때, 우리가 17자리수의 수 보다 
더 큰 것이 필요하다면, 적어도 파이썬 에서는, 
우리는 그것을 얻으 필요가 없습니다. 
그리고 그것은 많은 프로그래밍 언어들에서도 그렇습니다. 
이제 좋은 소식은, 이것은 거대한 수이고,
그것은 여러분의 인생에서 있을 것 같지 않은 것 이에요, 여러분은 
그것 보다 더욱 정확성이 필요할 것 입니다.
좋아요.

Korean: 
이제, 우리가 시작했던 0.1 미스터리로 돌아 가 봅시다. 그리고 
우리 스스로 왜 우리가 그 숫자들을 컴퓨터에서 나타 내는데 
문제가 있는지 물어 봅시다. 그러므로, 우리는 우리가 시도한 것으로부터 
재미있는 것을 얻고 그것을 다시 프린트 해 줍니다. 
자, 먼저 쉬운 문제를 봅시다. 
분수 1/8 를 나타 내는 것을 봅시다. 
그것은 좋은 표현입니다. 
그것은 십진수로 0.125와 같습니다.
그리고 우리는 그것을 10 기반과 2 기반 모두 편리하게 나타 낼 수 있습니다. 
그래서 여러분이 그것을 10 기반으로 나타 내고 싶다면, 그것은 무엇이죠? 
무엇과 같습니까? 

English: 
Now, let's go back to the 0.1
mystery that we started at,
and ask ourselves, why we have
a problem representing that
number in the computer, hence,
we get something funny out
from we try and print it back.
Well, let's look at an easier
problem first. Let's look at
representing the fraction 1/8.
That has a nice representation.
That's equal in decimal to
0.125, and we can represent it
conveniently in both
base 10 and base 2.
So if you want to represent
it in base 10, what is it?
What is that equal to?

English: 
Well, we'll take a mantissa,
1.25, and now we need to
multiply it by something that
we can represent nicely, and
in fact that will be
times 10 to the -1.
So the exponent would simply
be -1, and we have a nice
representation.
Suppose we want to represent
it in base 2?
What would it be?
1.0 times-- anybody?--
Well, 2 to the -3.
So, in binary notation, that
would be written as 0.001.
So you see, 1/8 is kind
of a nice number.

Korean: 
자, 우리는 가수 1.25 를 가질 것 입니다, 그리고 이제 우리는
그것을 우리가 좋게 나타 낼 수 있는 것과 곱할 필요가 있습니다. 그리고 
사실 그것은 -1 곱하기 10이 될 것 입니다. 
그래서 지수는 간단히 -1이 될 것이고 우리는 
좋은 표현을 가집니다.
우리가 2 기반으로 나타 내고 싶다고 가정해 볼까요?
그것은 무엇이 되죠? 
1.0 곱하기 — 누가 말해 볼래요? – 자, 2의 -3 입니다. 
그래서, 이진 표기에서, 그것은 0.001로 써 집니다.
그래서 1/8 은 약간 좋은 수 입니다. 

Korean: 
우리는 그것을 10 기반 또는 2 기반으로 좋게 표현할 수 있습니다. 
그러나 성가신 분수 1/10 은 어떻습니까?
 
205
00:15:14,970 --> 00:15:23,710
자, 10 기반에서, 우리는 나타 내는 방법을 압니다, 그것은 
1 곱하기 10의 — 10의 무엇 입니까? 10의 1? 
아닙니다. 
그러나 2 기반에서, 문제가 있습니다. 
이 십진수 분수를 정확히 표현하는 
유한한 이진수가 없습니다. 
사실, 우리가 이진수를 찾으려고 한다면, 우리가 찾는 것은, 
우리는 무한히 반복되는 시리즈들을 얻습니다. 

English: 
We can represent it nicely in
either base 10 or base 2.
But how about that pesky
fraction 1/10?
Well, in base 10, we know
how to represent, it's
1 times 10 to the--
10 to the what?--
10 to the 1?
No.
But in base 2, it's a problem.
There is no finite binary number
that exactly represents
this decimal fraction.
In fact, if we try and find
the binary number, what we
find is, we get an infinitely
repeating series.

Korean: 
0 0 0 1 1 0 0 1 1 0 0 등 이요. 
0 0 0 1 1 0 0 1 1 0 0 등 이요. 
어떤 유한한 비트의 수에서 멈추세요, 그러면 여러분은 오직 
십진수 분수 1/10 의 근사치를 얻을 것 입니다. 
그래서 대부분의 컴퓨터에서, 여러분이 이진 근사치의 십진수 값을 
프린트 하려고 한다면 — 그러면 그것이 우리가
여기 프린트 하려고 하는 것 입니까, 네? 
우리는 십진법에서 생각합니다, 그래서 파이썬은 꽤 좋게 우리에게 십진법으로 프린트 해 줍니다 
그것은 나타 나야 합니다 – 자 제가 그것을 쓰지 않을 것 입니다,
그것은 많은 숫자를 가지는 매우 긴 수에요, 숫자들이 매우 많죠.
파이썬에서, 우리가 무엇을 나타 낼 때 마다, 그것은 

English: 
Zero zero zero one one zero
zero one one zero
zero, and et cetera.
Stop at any finite number of
bits, and you get only an
approximation to the decimal
fraction 1/10.
So on most computers, if you
were to print the decimal
value of the binary
approximation-- and that's
what we're printing here,
on this screen, right?
We think in decimal, so Python
quite nicely for us is
printing things in decimal--
it would have to display--
well I'm not going to write it,
it's a very long number,
lots of digits-- however, in
Python, whenever we display

Korean: 
그러나 내장 된 함수 repr 를 사용 합니다, representation의 준말 입니다, 
그것은 이 숫자의 경우에, 내부의 표현을 
문자로 바꿔 줍니다, 그리고 나서 이 경우에 그 문자를 
스크린에 보여 줍니다. 
float형의 경우, 17자릿수의 수로 반올림 됩니다. 
여기서도 17이라는 마법의 수가 등장하는 군요.
결국, 17자릿수로 반올림될 때 우리는 정확히 
여기 스크린 아래에서 볼 수 있는 것을 얻을 겁니다.
미스터리에 대해 답해 보세요, 왜 그것이 이것을 나타 내죠? 
이제 우리는 무엇을 신경 써야 합니까? 
자, 그것은 우리가 보여지는 것에 대해 많이 신경 쓰는 것이 아닙니다, 
그러나 우리는 함축 된 것에 대하여 생각해야 합니다, 적어도 

English: 
something, it uses the built-in
function repr, short
for representation, that it
converts the internal
representation in this case of
a number, to a string, and
then displays that string in
this case on the screen.
For floats, it rounds it
to seventeen digits.
There's that magic number
seventeen again.
Hence, when it rounds it to
seventeen digits, we get
exactly what you see in the
bottom of the screen up there.
Answer to the mystery, why
does it display this?
Now why should we care?
Well, it's not so much that
we care about what gets
displayed, but we have to think
about the implications,

English: 
at least sometimes we have to
think about the implications,
of what this inexact
representation of numbers
means when we start doing
more-or-less complex
computations on those numbers.
So let's look at a little
example here.
I'll start by starting the
variable s to 0.0 .
Notice I'm being careful
to make it a float.
And then for i in range, let's
see, let's take 10, we'll
increase s by 0.1 .
All right, we've done that,
and now, what happens
when I print s?
Well, again you don't get
what your intuition
says you should get.

Korean: 
때때로 우리는 우리가 이 숫자들의 
더 혹은 덜 복잡한 계산을 시작할 때를 의미하는 숫자들의
이 부정확한 표현의 함축 된 것에 대하여 생각해야 합니다. 
자 여기 작은 예를 봅시다. 
저는 변수 s를 0.0 으로 두고 시작할 것 입니다. 
제가 그것을 실수로 만드는 것에 주의하는 것을 주목하세요. 
그리고 나서 범위에서 i 를 위해, 봅시다, 10을 취합시다, 우리는 
s를 0.1로 증가시킬 것입니다. 
좋아요, 우리는 그것을 했습니다, 그리고 이제,
제가 s를 출력할 때 무슨 일이 일어나죠?
자, 다시 여러분은 직관이 여러분이 얻어야 한다고
말하는 것을 얻지 않습니다. 

English: 
Notice the last two digits,
which are eight and nine.
Well, what's happening here?
What's happened, is the
error has accumulated.
I had a small error when I
started, but every time I
added it, the error got bigger
and it accumulates.
Sometimes you can get in trouble
in a computation
because of that.
Now what happens, by the
way, if I print s?
That's kind of an interesting
question.
Notice that it prints one.
And why is that?
It's because the print command
has done a rounding here.
It automatically rounds.
And that's kind of good, but
it's also kind of bad, because
that means when you're debugging
your program, you
can get very confused.

Korean: 
마지막 두 숫자에 주목하세요, 그것은 8과 9 입니다. 
자, 여기 무슨 일이 일어 나고 있죠? 
무슨 일이 일어나나요, 에러는 축적 됩니다. 
저는 시작할 때, 작은 에러를 가지고 있었습니다, 그러나 제가 그것을 더할 때 마다 매번
에러는 점점 커졌고 축적 됩니다. 
이따금씩 여러분은 연산에 문제가 생길 수 있어요
그것 때문이죠.
아 그런데, 내가 s를 출력하면 어떻게될까요?
그것은 흥미로운 질문 입니다. 
그것이 1을 출력하는 것에 주목하세요.
그리고 왜 그렇죠? 
그것은 출력 명령이 여기서 반올림을 했기 때문입니다. 
그것은 자동적으로 반올림 합니다
그리고 그것은 좋은 것이죠, 그러나 그것은 또한 나쁜 것이기도 합니다. 왜냐하면 
그것은 여러분이 여러분의 프로그램을 디버깅할 때
여러분이 매우 혼란스러울 수 있다는 것을 의미하기 때문 입니다

Korean: 
여러분은 그것이 1이라고 했습니다, 왜 제가 계산을 할 때 
다른 답을 얻나요?
그리고 그 이유는 그것이 정말 하나의 내부가 아니기 때문 입니다. 
그래서 여러분은 주의해야 합니다. 
이제 대부분, 이 반올림 에러들은 서로 균형이 잡힙니다
어떤 실수들은 그들이 예상 되었던 것 보다 약간 더 크고,
어떤 것은 약간 더 작습니다, 그리고 대부분의 계산에서 그것 모두는 
곧 알게 되고 여러분은 옳은 답을 얻습니다. 
사실을 말하자면, 대부분의 시간, 여러분은 이것에 대해 
걱정하는 것을 피할 수 있습니다
그러나, 우리가 라틴계에서 말했던 것처럼, 통고 계산자를 말합니다
때때로 여러분은 약간 걱정해야 합니다.
이제 여러분이 항상 걱정해야 하는 부동 소수점에 대한
한 가지가 있습니다. 
그리고 그것은 정말로 제가 정말로 여러분이 알아 듣게 하고 싶은 점 입니다. 그리고 그것은 

English: 
You say, it says it's one, why
am I getting a different
answer when I do the
computation?
And that's because it's
not really one inside.
So you have to be careful.
Now mostly, these round-off
errors balance each other out.
Some floats are slightly higher
than they're supposed
to be, some are slightly
lower, and in most
computations it all comes out
in the wash and you get the
right answer.
Truth be told, most of the time,
you can avoid worrying
about these things.
But, as we say in Latin,
caveat computor.
Sometimes you have to
worry a little bit.
Now there is one thing about
floating points about which
you should always worry.
And that's really the point I
want to drive home, and that's

English: 
about the meaning
of double equal.
Let's look at an example
of this.
So we've before seen the use
of import, so I'm going to
import math, it gives me some
useful mathematical functions,
then I'm going to set the
variable a to the
square root of two.
Whoops.
Why didn't this work?
Because what I should have
said is math dot
square root of two.
Explaining to the interpreter
that I want to get the
function sqrt from
the module math.
So now I've got a here, and I
can look at what a is, yeah,

Korean: 
double equal(==) 의 의미에 대한 것 입니다. 
이것의 예를 봅시다. 
그래서 우리는 전에 import의 사용을 보았습니다. 그래서 저는 
math를 import 하려고 합니다. 그것은 저에게 유용한 수학적인 함수들을 제공해 줍니다, 그리고 
저는 변수 a를 2의 제곱근으로 둘 것 입니다. 
아이고
왜 실행되지 않죠?
왜냐하면 제가 말해야 했던 것은 math.sqrt(2)이기 때문 입니다. 
Math 모듈로부터 제가 sqrt 함수를 얻기를 원하는 
인터프리터에 설명을 해야 합니다
그래서 저는 여기서 a를 얻습니다, 그리고 저는 a가 무엇인지 알 수 있습니다, 예, 

Korean: 
2의 제곱근의 어떤 근사치이죠. 
이제 여기 흥미로운 질문이 있습니다. 
제가 Boolean형으로 a 곱하기 a 는 2에 대해 물어 봤다고 가정해 보세요
이제 제 마음 속에, 제가 수의 제곱근을 구해서 
그것을 그것 자체에 곱하면
다시 원래 수를 얻을 수 있다고 생각 합니다
결국, 그것은 제곱근의 의미 입니다
그러나 이제, 여러분은 이것의 값이 false이더라도 놀라지 않을 것 입니다
왜냐하면 우리는 우리가 저장했던 것이 오직 
제곱근의 근사치라는 것을 알기 때문 입니다. 
그리고 그것은 흥미로운 것이에요. 
그래서 우리는 제가 a 곱하기 a 를 하면, 
저는 2 점 엄청난 수의 영과 끝에 4 를 얻을 것이라는 것을 알 수 있습니다. 
그래서 이것은, 제가 제 프로그램에서 테스트를 하면, 어떤 경우에 
그것은 저에게 예상치 못한 틀린 답을 줄 수 있다는 것을 의미합니다. 

English: 
some approximation to the square
root about of two.
Now here's the interesting
question.
Suppose I ask about the Boolean
a times a equals
equals two.
Now in my heart, I think, if
I've taken the square root of
number and then I've multiplied
it by itself, I
could get the original
number back.
After all, that's the meaning
of square root.
But by now, you won't be
surprised if the answer of
this is false, because we know
what we've stored is only an
approximation to the
square root.
And that's kind of
interesting.
So we can see that, by, if I
look at a times a, I'll get
two point a whole bunch
of zeros and then
a four at the end.
So this means, if I've got a
test in my program, in some
sense it will give me the
unexpected answer false.

Korean: 
이것이 우리에게 말해 주는 것은 그것이 내장된 == 를
소수점을 비교하기 위해 사용하는 것은 매우 위험 하다는 것 입니다
여러분은 균등을 위한 테스트를 절대 할 수 없습니다. 여러분은 
항상 충분히 가까운 것을 위한 테스트를 할 수 있습니다
그래서 전형적으로, 여러분이 여러분의 프로그램에서 원하는 것은 다음 질문을 하는 것입니다
a 곱하기 a 마이너스 2.0 의
절대 값은 입실론 보다 작습니까? 
우리가 그리스어를 쉽게 타이핑할 수 있다면, 우리는 그것을 그 방식으로 썼을 것입니다,
그러나 우리는 그럴 수 없습니다
그래서 그것은 적용을 위해 적절해 지는 것으로 골라지는 
어떤 작은 값 입니다. 
이 두 가지가 서로의 입실론 내에 있다면, 

English: 
What this tells us, is that it's
very risky to ever use
the built-in double--equals to
compare floating points, and
in fact, you should never be
testing for equality, you
should always be testing
for close enough.
So typically, what you want to
do in your program, is ask the
following question: is the
absolute value of a times a
minus 2.0 less than epsilon?
If we could easily type Greek,
we'd have written it that way,
but we can't.
So that's some small value
chosen to be appropriate for
the application.
Saying, if these two things
are within epsilon of each

Korean: 
저는 그것들을 같은 것으로 다룰 것 입니다.
그리고 제가 이동 소수점 수를 다룰 것인 파이썬 코드를 쓸 때 
제가 전형적으로 하는 것, 그리고 제가 
가끔 이것을 하는 것은 거의 같거나 가깝거나 저를 위해 이것을 하는 여러분이 
어떤 좋아하는 단어로 부르는 . 함수를 소개할 것입니다
어떤 좋아하는 단어로 부르는 . 함수를 소개할 것입니다
그리고 제가 near x, y 라고 쓰는 대신에 더블 x 는 y 와 같다고 쓸 때 마다, 
그리고 그것은 그것을 저에게 계산해 줍니다. 
큰 문제가 아닙니다, 그러나 이것을 기억하세요, 그렇지 않으면 
여러분은 곧 수를 다루기 시작하면서, 여러분은 
프로그램이 하는 것을 이해 하려고 노력할 때 매우 좌절할 것 입니다. 
좋습니다.
잠시 동안 충분한 수에서, 저는 여러분이 
이것이 안도라는 것을 알아 낼 것이라는 것을 확신 합니다
저는 이제 부동 소수점의 자세한 것으로부터 벗어 나고 싶습니다, 그리고 

English: 
other, then I'm going to
treat them as equal.
And so what I typically do when
I'm writing a Python code
that's going to deal with
floating point numbers, and I
do this from time to time, is I
introduce a function called
almost equal, or near, or pick
your favorite word, that does
this for me.
And wherever I would normally
written double x equals y,
instead I write, near x,y, and
it computes it for me.
Not a big deal, but keep this
in mind, or as soon as you
start dealing with numbers, you
will get very frustrated
in trying to understand what
your program does.
OK.
Enough of numbers for a while,
I'm sure some of you will find
this a relief.
I now want to get away from
details of floating point, and

English: 
talk about general methods
again, returning to the real
theme of the course of solving
problems using computers.
Last week, we looked at the
rather silly problem of
finding the square root
of a perfect square.
Well, that's not usually
what you need.
Let's think about the more
useful problem of finding the
square root of a real number.
Well, you've just seen
how you do that.
You import math and
you call sqrt.
Let's pretend that we didn't
know that trick, or let's
pretend it's your job to
introduce-- implement,
rather-- math.
And so, you need to figure out
how to implement square root.
Why might this be a challenge?
What are some of the issues?
And there are several.

Korean: 
다시 일반적인 함수에 대해 이야기 하고 싶군요, 
컴퓨터를 사용해 문제를 푸는 강의의 진정한 테마로 돌아 가고 싶습니다. 
지난 주에, 우리는 완벽한 제곱의 제곱근을 구하는
다소 바보 같은 프로그램을 보았습니다. 
자, 그것은 여러분이 대개 필요한 것이 아닙니다. 
진짜 수의 제곱근을 구하는 
더욱 유용한 프로그램에 대해 생각해 봅시다. 
자, 여러분은 여러분이 그것을 어떻게 하는지 방금 보았습니다.
여러분은 math를 import 하고 sqrt를 부릅니다. 
여러분이 그 방법을 모르는 척 해 보거나 또는 
implement 를 소개하는 것이 여러분이 일 인척 해 봅시다
수학도요
그리고, 여러분은 제곱근을 구현하는 방법을 알아 낼 필요가 있습니다. 
이것이 왜 도전이 될 수 있습니까?
이슈들은 무엇이죠? 
그리고 몇 가지가 있습니다. 

English: 
One is, what we've just seen
might not be an exact answer.
For example, the square
root of two.
So we need to worry about that,
and clearly the way
we're going to solve that, as
we'll see, is using a concept
similar to epsilon.
In fact, we'll even
call it epsilon.
Another problem with the method
we looked at last time
is, there we were doing
exhaustive enumeration.
We were enumerating all the
possible answers, checking
each one, and if it was
good, stopping.
Well, the problem with reals, as
opposed to integers, is we

Korean: 
하나는, 우리가 방금 본 것이 정확한 답이 아닐 수도 있다는 것입니다.
예를 들어, 2의 제곱근 이죠. 
그래서 우리는 그것에 대해 걱정할 필요가 있습니다, 그리고 정확히 그것을 
우리가 풀려고 하는 방법은, 우리가 볼 것인데, 그것은 
입실론과 비슷한 개념을 이용하는 것 입니다
사실, 우리는 그것을 심지어 입실론 이라고 부를 것입니다. 
우리가 지난 시간에 본 함수와의 문제는
우리가 철저한 계산을 하고 있었다는 것 입니다
우리는 모든 가능한 문제를 계산 하고 있었습니다.
각 하나를 체크하면서요, 그리고 그것이 좋으면, 멈춥니다
자, 정수들과 반대 되는 reals 의 문제는 우리가 모든 추측들을 

Korean: 
계산할 수 없다는 것 입니다. 
그리고 그것은 reals가 셀 수 없기 때문 입니다.
제가 여러분에게 양의 정수를 계산하라고 한다면, 여러분은 
1, 2, 3, 4, 5 라고 말할 것 입니다.
제가 여러분에게 reals를 계산하라고 한다면, 양의 reals는
어디서부터 시작할 것 입니까? 
10억 이상의 수 일지 누가 알죠? 
이제, 우리가 사실 본 것처럼, 정밀한 부동 소수점에 
한계가 있기 때문에, 기술적으로 여러분은 
모든 이동 소수점 수를 계산할 수 있습니다
그리고 저는 기술적으로, 여러분이 그것을 하려고 시도한다면,
여러분의 계산은 곧 끝나지 않을 것이라고 말합니다. 
그래서 원칙적으로 여러분이 그것들을 계산하려고 하더라도, 
사실 여러분은 할 수 없습니다. 

English: 
can't enumerate all guesses.
And that's because the reals
are uncountable.
If I ask you to enumerate the
positive integers, you'll say
one, two, three, four, five.
If I ask you to enumerate the
reals, the positive reals,
where do you start?
One over a billion,
plus who knows?
Now as we've just seen in fact,
since there's a limit to
the precision floating point,
technically you can enumerate
all the floating
point numbers.
And I say technically, because
if you tried to do that, your
computation would not terminate
any time soon.
So even though in some, in
principle you could enumerate
them, in fact you
really can't.

Korean: 
그리고 우리는 부동 소수점을 셀 수 없는 reals와 같은 것으로 
생각할 수 있습니다
셀 수 없으면, 셀 수 없는 것이 됩니다. 
그래서 우리는 그것을 할 수 없습니다. 
그래서 우리는 현명한 무언가를 찾아야 합니다. 왜냐하면 우리는 이제 
매우 큰 공간의 가능한 답을 찾아야 하기 때문이죠. 
그것은, 여러분은 큰 상태의 공간으로 부를 수도 있습니다. 
그래서 우리는 추측하고 검사하는 이전의 방법을 취할 것입니다, 그리고 
그것을 추측, 검사, 개선으로 불리는 것으로 
교체할 것입니다.
이전에, 우리는 체계적인 방법으로 추측들을 생성했습니다,
그러나 그것을 알지 못하고 우리는 답에 
가까워 졌습니다. 
닭과 머리와 다리의 원래 농가 문제를 생각해 보세요

English: 
And so we think of the floating
points, like the
reals, as being innumerable.
Or not innumerable, as to say
as being uncountable.
So we can't do that.
So we have to find something
clever, because we're now
searching a very large space
of possible answers.
What would, technically
you might call
a large state space.
So we're going to take our
previous method of guess and
check, and replace it by
something called guess, check,
and improve.
Previously, we just generated
guesses in some systematic
way, but without knowing
that we were getting
closer to the answer.
Think of the original barnyard
problem with the chickens and

Korean: 
우리는 방금 가능성을 계산했지만, 
우리는 한 가지 추측이 이전의 추측 보다 나을 수 있다는 것을 
몰랐습니다. 
이제 우리는 각 추측이 이전의 추측 보다 낫다는 것을 믿는
좋은 이유를 가지는 상황에서, 적어도 높은 가능성을 가지고, 
계산을 하는 방법을 찾을 것 입니다. 
이것은 연차 근사법 이라는 것 입니다. 
그리고 그것은 매우 중요한 개념 입니다. 
많은 문제들은 연차 근사법을 사용하여 
계산적으로 풀어 집니다. 

English: 
the heads and the legs, we just
enumerated possibilities,
but we didn't know that one
guess was better than the
previous guess.
Now, we're going to find a way
to do the enumeration where we
have good reason to believe,
at least with high
probability, that each
guess is better than
the previous guess.
This is what's called successive
approximation.
And that's a very important
concept.
Many problems are solved
computationally using
successive approximation.

English: 
Every successive approximation
method has
the same rough structure.
You start with some guess, which
would be the initial
guess, you then iterate-- and in
a minute I'll tell you why
I'm doing it this particular
way, over some range.
I've chosen one hundred, but
doesn't have to be one
hundred, just some number
there-- if f of x, that is to
say some some function of my--
Whoops, I shouldn't
have said x.
My notes say x, but it's the
wrong thing-- if f of x, f of

Korean: 
모든 연차 근사법은 같은 대략적인 
구조를 가집니다. 
여러분은 어떤 추측으로 시작합니다, 그것은 최초의 추측이 될 수 있습니다
여러분은 그리고 반복합니다. 그리고 곧 저는 여러분에게 왜 제가 
그것을 몇 가지 범위를 넘어 이 특별한 방법으로 하는지 말해 줄 것입니다
저는 100을 골랐습니다. 그러나 100이 되어서는 안됩니다
그것은 어떤 수여야 하냐면 — f x, 그것은
제 어떤 함수를 말하는 것인데 
아이고, 저는 x에 대해 말했어야 했군요. 
제 노트는 x를 말합니다, 그런데 그것은 틀렸어요 – 

English: 
the guess, is close enough, so
for example, if when I square
guess, I get close enough to
the number who's root I'm--
square root I'm looking for,
then I'll return the guess.
If it's not close enough,
I'll get a better guess.
If I do my, in this case, one
hundred iterations, and I've
not get-- gotten a guess that's
good enough, I'm going
to quit with some error.
Saying, wow.
I thought my method was good
enough that a hundred guesses

Korean: 
f x, 추측의 f가 충분히 가까우면, 예를 들어, 
제가 추측을 제곱했을 때, 저는 그 수에 충분히 가까워 집니다 
제가 찾는 제곱근이죠, 그리고 나서 저는 추측 값을 돌려 받습니다
그것이 충분히 가깝지 않으면, 저는 더 나은 추측을 얻을 것 입니다. 
제가, 이 경우에, 100 번 반복을 하고 
충분한 추측 값을 얻지 못하면, 저는 
어떤 에러로 끝날 것 입니다
와우. 
저는 제 방법이 100 개의 추측이 저에게 주었으면 했던 것만큼 

English: 
should've gotten me there.
If it didn't, I may be wrong.
I always like to have some
limit, so that my program
can't spin off into the ether,
guessing forever.
OK.
Let's look at an example
of that.
So here's a successive
approximation
to the square root.
I've called it square root bi.
The bi is not a reference to the
sexual preferences of the
function, but a reference to
the fact that this is an

Korean: 
좋다고 생각했습니다. 
그렇지 않으면, 저는 틀릴 것 입니다.
저는 항상 어떤 한계를 가지길 좋아합니다, 그래서 제 프로그램은 
에테르로 분리될 수 없습니다. 
좋아요. 
그것의 예를 봅시다. 
여기 제곱근의 연차 근사법이 
있습니다. 
저는 그것을 제곱근 bi 라고 불렀습니다
bi는 함수의 성적선호도를 의미할 때 
그 bi가 아니라 bi-section method(이분법) 

Korean: 
이라는 것의 예 입니다. 
어떤 bi 부분 방법 뒤의 기본적인 아이디어는 같습니다, 
그리고 우리는 이 학기에 많은 예들을 볼 것입니다,
그것은 어떤 가능한 답들의 선형으로 배열된 것을 가집니다.
그리고 그것은 제가 어디서 추측을 하면, 저기라고 하죠, 
저는 그것이 그 질문의 답이라는 것을 알 수 있는 특성을 가집니다
그것이 답이 아닌 것으로 드러나면, 저는 그 답이 
추측의 왼쪽에 있는지 오른쪽에 있는지 쉽게 결정할 수 있습니다.
그래서 제가 89.12 가 어떤 수의 제곱근이라고 한다면, 

English: 
example of what's called
a bi-section method.
The basic idea behind any
bi-section method is the same,
and we'll see lots of examples
of this semester, is that you
have some linearly-arranged
space of possible answers.
And it has the property that if
I take a guess somewhere,
let's say there, I guess that's
the answer to the
question, if it turns out that's
not the answer, I can
easily determine whether the
answer lies to the left or the
right of the guess.
So if I guess that 89.12 is the
square root of a number,

Korean: 
그리고 그것이 어떤 수의 제곱근이 아닌 것으로 드러났다면, 
저는 89.12 가 너무 크거나 작다고 말할 수 있는 방법을 가집니다
그것이 너무 크다면, 저는 여기 이 수가 더 낫다는 것을 
알 수 있습니다.
그것이 너무 작다면, 저는 여기 이 수가 더 낫다는 것을 
알 수 있습니다
왜 제가 그것을 bi 섹션 이라고 부르나요?
왜냐하면 저는 그것을 반으로 나누고, 일반적으로 우리가 보다시피
제가 답의 제 공간이 무엇인지 알 때, 저는 항상, 
저의 다음 추측으로써, 그 라인을 따라 절반을 선택하기 때문 입니다. 
그래서 저는 추측을 했습니다, 그리고 너무 작다고 말해 봅시다, 그리고 
저는 여기와 여기 사이의 답이 무엇인지 압니다, 이것은 너무 작습니다, 저는 이제 
그 답이 여기와 여기 사이라는 것을 압니다, 그래서 제 다음 
추측은 그 중간이 될 것입니다
각 추측에서, 중간에서 항상 추측하는 것의 미는, 

English: 
and it turns out not to be the
square root of the number, I
have a way of saying, is 89.12
too big or too small.
If it was too big, then I
know I'd better guess
some number over here.
It was too small, then
I'd better guess
some number over here.
Why do I call it bi-section?
Because I'm dividing it in half,
and in general as we'll
see, when I know what my space
of answers is, I always, as my
next guess, choose something
half-way along that line.
So I made a guess, and let's say
was too small, and I know
the answer is between here and
here, this was too small, I
now know that the answer is
between here and here, so my
next guess will be
in the middle.
The beauty of always guessing
in the middle is, at each

English: 
guess, if it's wrong, I
get to throw out half
of the state space.
So I know how long it's going
to take me to search the
possibilities in some sense,
because I'm getting
logarithmically progressed.
This is exactly what we saw when
we looked at recursion in
some sense, where we solved the
problem by, at each step,
solving a smaller problem.
The same problem, but on a
smaller solution space.
Now as it happens, I'm not
using recursion in this
implementation we have up on
the screen, I'm doing it
iteratively but the
idea is the same.
So we'll take a quick look at
it now, then we'll quit and
we'll come back to in the next
lecture a little more
thoroughly.
I'm going to warn you right
now, that there's a bug in
this code, and in the next
lecture, we'll see if we can

Korean: 
그것이 틀렸다면, 저는 그 상태 공간의 절반을
버릴것입니다.
그래서 저는 그것이 제가 어떤 의미에서 가능성을 찾는데 
얼마나 오래 걸리는지 압니다, 왜냐하면 저는 
대수적으로 진행하고 있기 때문 입니다
이것은 정확히 우리가 어떤 의미에서 반복을 했을 때 
우리가 본 것 입니다. 각 단계에서
우리가 더 작은 문제를 풀으면
문제를 풀 수 있는 곳 입니다.
이제 일어 난 대로, 저는 화면에 있는 이 구현에서 
반복을 사용하지 않을 것입니다, 저는 그것을
반복적으로 하지만 아이디어는 같습니다. 
그래서 우리는 이제 그것을 빠르게 살펴 볼 것 입니다, 그리고 나서 우리는 
그만 둘 것이고 조금 더 철저하게 다음 강의에서 
돌아 올 것 입니다
저는 지금 여러분에게 경고할 것 입니다, 이 코드에는
버그가 있습니다, 그리고 다음 강의에서, 우리는 

Korean: 
우리가 버그가 무엇인지 발견할 수 있는지를 볼 것 입니다. 
그래서 그것은 두 인자를 가집니다; 우리가 찾는 제곱근의 수인 x,
그리고 입실론, 우리가 얻기 위해 얼마나 가까워 져야 하나요, 
그것은 x가 음수가 아니라고 가정 합니다, 그리고 입실론이 
0 보다 크다고 가정 합니다. 
왜 우리는 입실론이 0 보다 크다고 가정할 필요가 있습니까? 
자, 여러분이 입실론 0을 만든다면, 그리고 2의 제곱근을 찾는다고 말한다면
우리는 우리가 절대 답을 찾지 못할 것이라는 것을 압니다. 
그래서 우리는 그것이 양수가 되기를 원합니다, 그리고 나서 그것은 y를 리턴 해 줍니다. 
Y 곱하기 y 는 x의 입실론 내에 있습니다
그것은 우리가 전에 사용했던 용어들을 사용하기 가깝습니다
우리가 프로그램에서 볼 다음 것은 
두 가지 assert 문 입니다. 
이것은 제가 제 함수들이 옳은 것을 하고 있다고 말하는 사람들을 
전혀 믿지 않기 때문 입니다.

English: 
discover what that is.
So, it takes two arguments; x,
the number whose square root
we're looking for,
and epsilon, how
close we need to get.
It assumes that x is
non-negative, and that epsilon
is greater than zero.
Why do we need to assume
that's epsilon is
greater than zero?
Well, if you made epsilon zero,
and then say, we're
looking for the square root
of two, we know we'll
never get an answer.
So, we want it to be positive,
and then it returns y such
that y times y is within
epsilon of x.
It's near, to use the
terminology we used before.
The next thing we see in the
program, is two assert
statements.
This is because I never trust
the people who call my
functions to do the
right thing.

English: 
Even though I said I'm going to
assume certain things about
x and epsilon, I'm actually
going to test it.
And so, I'm going to assert
that x is greater than or
equal to zero, and that epsilon
is greater than zero.
What assert does, is it tests
the predicate, say x greater
than or equal to zero, if it's
true, it does nothing, just
goes on to the next statement.
But if it's false, it prints a
message, the string, which is
my second argument here, and
then the program just stops.
So rather than my function going
off and doing something
bizarre, for example running
forever, it just stops with a
message saying, you called me
with arguments you shouldn't
have called me with.
All right, so that's the
specification and then my
check of the assumptions.
The next thing it does, is it
looks for a range such that I

Korean: 
심지어 제가 x와 입실론에 대한 어떤 것들에 대해 가정할 것이라고 말했을 지라도
저는 실제로 그것을 테스트 해 볼 것 입니다
그리고, 저는 x가 0 보다 크거나 같다고 주장할 것 입니다.
그리고 입실론은 0 보다 크다고 가정할 것 입니다
assert가 하는 것은, 그것은 x가 0 보다 크거나 같다고 한 것을 테스트 합니다.
그것이 옳다면, 그것은 아무 것도 하지 않습니다. 
단지 다음 문장으로 갈 뿐 입니다. 
그러나 그것이 틀리 다면, 그것은 메시지를 출력할 것 입니다. 그 문자열은 
여기 내 두 번째 인자이고, 그리고 나서 프로그램은 멈춥니다.
그래서 제 함수가 가서 예를 들어 영원히 실행 하는 것 과 같은 
기이한 무언가를 하기 보다는, 그것은 멈추고 메시지를 출력 합니다
메시지는 여러분이 부르면 안 되는 인자들로 
저를 불렀다는 메시지 입니다. 
좋아요, 그래서 그것은 구체적인 것 이었습니다 그리고 
가정들에 대한 검사였습니다. 
그것이 하는 다음 것은, 그것은 범위를 찾습니다. 

English: 
believe I am assured that my
answer lies between the ran--
these values, and I'm going to
say, well, my answer will be
no smaller than zero, and
no bigger than x.
Now, is this the tightest
possible range?
Maybe not, but I'm not
too fussy about that.
I'm just trying to make sure
that I cover the space.
Then I'll start with a guess,
and again I'm not going to
worry too much about the guess,
I'm going to take low
plus high and divide by two,
that is to say, choose
something in the middle of
this space, and then
essentially do what
we've got here.
So it's a little bit more
involved here, I'm going to
set my counter to one, just to
keep checking, then say, while
the absolute value of the
guess squared minus x is
greater than epsilon, that is
to say, why my guess is not

Korean: 
제가 제 답이 이 값들 사이라고 가정한 것들과 같은 것을요
저는 제 답이 0 보다 작지 않고 x 보다 
크지 않다고 말할 것 입니다.
이제, 이것은 가능한 타이트한 범위 입니까? 
아마 아닐 것입니다, 그러나 저는 그것에 대해 많이 까다롭지 않습니다
저는 단지 제가 커버하는 범위를 확실히 하려고 할 것 입니다. 
그리고 저는 추측으로 시작할 것 입니다, 그리고 다시 저는 
그 추측에 대해 걱정하지 않을 것 입니다, 저는 낮은 것과 높은 것을 더하고 
둘로 나눌 것 입니다, 즉, 이 공간의 중간에 있는 어떤 것을 
고를 것 입니다, 그리고 나서 필수적으로 
우리가 여기에서 한 것을 할 것 입니다
그래서 그것은 여기에 조금 더 포함되어 있습니다. 
저는 제 카운터를 1로 둘 것 입니다, 단지 검사하기 위해서요. 그리고 
마이너스 x 로 제곱 된 추측의 절대 값이 입실론 보다 큰 반면, 

Korean: 
즉, 왜 제 추측은 아직 충분히 알맞지 않나요 라고 말하겠죠, 
그리고 카운터는 100 보다 크지 않을 것 입니다, 저는
다음 추측을 얻을 것 입니다
그런데 제가 언급 했던 것을 여기 출력 했다는 것에 주목하세요.
그러나 저는 제 프로그램이 처음에 정확히 작동하지 않는다는 것을 
알아 냈습니다. 그리고 제가 처음으로 
타이핑하고 출력 문을 두었을 때, 
그것은 제가 이 루프를 통한 각 반복이 일어난 것을 보게 해 주었습니다, 그래서 
그것이 작동하지 않으면, 저는 왜 그렇지 않은지를 알 수 있습니다. 
다음 강의에서, 우리가 이 프로그램의 버그를 찾아 볼 때, 
여러분은 제가 그 출력 문을 언급하지 않는 것을 보게 될 것 입니다,
그러나 지금은, 우리는 다음 것으로 갑시다.
그리고 우리는 여기에 있습니다. 우리는 추측이 충분히 좋지 않았다는 것을 압니다, 그래서 저는 
지금, 제곱 된 추측 값이 x 보다 작다면, 
저는 추측하기 위한 low값을 바꿀 것입니다. 

English: 
yet good enough, and the counter
is not greater than a
hundred, I'll get
the next guess.
Notice by the way, I have a
print statement here which
I've commented out, but I sort
of figured that my program
would not work correctly the
first time, and so, I, when I
first typed and put in a print
statement, it would let me see
what was happening each
iteration through this loop,
so that if it didn't work, I
could get a sense of why not.
In the next lecture, when we
look for the bug in this
program, you will see me
uncomment out that print
statement, but for now, we
go to the next thing.
And we're here, we know the
guess wasn't good enough, so I
now say, if the guess squared
was less than x, then I will
change the low bound
to be the guess.

English: 
Otherwise, I'll change the high
bound to be the guess.
So I move either the low bound
or I move the high bound,
either way I'm cutting
the search space
in half each step.
I'll get my new guess.
I'll increment my counter,
and off I go.
In the happy event that
eventually I get a good enough
guess, you'll see a--
I'll exit the loop.
When I exit the loop, I checked,
did I exit it because
I exceeded the counter,
I didn't have
a good-enough guess.
If so, I'll print the message
iteration count exceeded.
Otherwise, I'll print the
result and return it.
Now again, if I were writing a
square root function to be
used in another program, I
probably wouldn't bother
printing the result and the
number of iterations and all
of that, but again, I'm doing
that here for, because we want
to see what it's doing.

Korean: 
그렇지 않으면, 저는 추측 하기위한 high값을 바꿀 것 입니다. 
두 가지 방법으로 저는 각 단계 마다
검색 공간을 반으로 줄일 수 있습니다. 
저는 제 새로운 추측을 얻을 것 입니다
저는 제 카운터를 증가 시키고, 다시 갈 것 입니다. 
결과적으로 제가 좋은 추측 값을 얻게 되는 
행복한 상황에서, 여러분은 보게 될 것 입니다 – 저는 루프를 빠져나갈 것 입니다
제가 루프를 빠져 나갈 때, 저는 제가 빠져 나왔는지를 검사했습니다. 왜냐하면 
제가 카운터를 초과했기 때문 입니다. 
저는 충분히 좋은 추측을 하지 못했습니다
그렇다면, 저는 반복 카운트가 초과했다는 메시지를 출력할 것 입니다
그렇지 않으면, 저는 결과 값을 출력하고 그것을 리턴 할 것 입니다. 
이제 다시, 제가 다른 프로그램에서 사용되는 제곱근 함수를 썼다면,
저는 아마 결과 값과 반복 수와 그것의 모든 것을 출력하는 것을
방해히지 않을 것 입니다. 그러나 다시
저는 여기서 그것을 할 것 입니다. 왜냐하면 우리는 
그것이 무엇을 하는지 보길 원하기 때문 입니다

English: 
All right.
We'll run it a couple times
and then I'll let
you out for the day.
Let's go do this.
All right.
We're here.
Well, notice when I run
it, nothing happens.
Why did nothing happen?
Well, nothing happens, it
was just a function.
Functions don't do anything
until I call them.
So let's call it.
Let's call square root bi with
40.001 Took only one at--
iteration, that was pretty
fast, estimated two as an
answer, we're pretty happy
with that answer.
Let's try another example.

Korean: 
좋아요.
우리는 그것을 몇 번 돌려 볼 것입니다. 그리고 나서 
저는 여러분이 이것에서 벗어나게 할 것 입니다. 
이것을 해 봅시다. 
좋아요.
우리는 여기에 있습니다.
자, 제가 그것을 돌릴 때, 아무 것도 일어나지 않습니다
왜 아무 것도 일어나지 않죠? 
자, 아무것도 일어나지 않아요, 그것은 단지 함수일 뿐 입니다
함수들은 제가 그것을 부를 때까지 아무것도 하지 않습니다.
그래서 함수를 불러 봅시다. 
제곱근 bi 를 40.001 로 부릅시다. 한 번만 반복 합시다
그것은 꽤 빨랐습니다, 답은 2 로 추정되는 값입니다
우리는 그 답에 매우 행복 합니다. 
이제 다른 예제를 해 봅시다. 

English: 
Let's look at nine.
I always like to, by the way,
start with questions whose
answer I know.
We'll try and get a little
bit more precise.
Well, all right.
Here it took eighteen
iterations.
Didn't actually give me the
answer three, which we know
happens to be the answer, but it
gave me something that was
within epsilon of three, so it
meets the specification, so I
should be perfectly happy.
Let's look at another example.
Try a bigger number here.
All right?
So I've looked for the square
root of a thousand, here it
took twenty-nine iterations,
we're kind of creeping up
there, gave me an estimate.
Ah, let's look at our infamous
example of two, see

Korean: 
9 를 봅시다. 
그런데, 저는 항상 그것의 답이 제가 아는 것 인지의 질문으로 
시작하는 것을 좋아합니다. 
우리는 시도하고 좀 더 정확한 답을 얻을 것 입니다. 
자, 좋아요
여기에서 그것은 18번 반복 합니다. 
사실 저에게 답 3을 주지 않았습니다, 
그것은 우리가 아는 대로 답 입니다, 그러나 그것은 저에게 
3의 입실론 내의 무언가를 주었습니다. 그래서 그것은 구체적으로 됐구요,
그래서 저는 완벽하게 행복해질 것 입니다
다른 예제를 봅시다.
여기 더 큰 수가 있습니다. 
알겠죠? 
그래서 저는 1000의 제곱근을 보았습니다, 여기서 그것은 
29번 반복합니다, 우리는 저기서 일종의 치켜 올리기를 하고,
저에게 추정 값을 줍니다. 
아, 우리의 2의 유명하지 않은 예제를 봅시다

Korean: 
여기서 그것이 무엇을 하는지 보세요.
주변에서 작동 합니다
이제, 우리는 그것이 실제로 작동하고 있는 것을 보았습니다, 그리고 저는 
우리가 충분히 좋은 답이라고 믿는 답을 얻을 것 입니다, 그러나 우리는 
또한 우리가 수렴으로써 말하는 것의 속도를 봅니다 
얼마나 많이 반복하고, 반복의 수는 무엇인지 
그것은 가변적 입니다, 그리고 그것은 적어도 두 가지와 관련되어 있는 것 같아 보입니다,
그리고 우리는 다음 강의에서 이것에 대해 더 알아 볼 것 입니다
그것의 제곱근이 우리가 찾는 것인 수의 크기와 
제가 답하고 싶은 정확성에 대해서요
다음 강의에서, 우리는 이 하나에 무엇이 잘못 되었는지 알아 볼 것 입니다, 그리고 
저는 여러분에게 지금과 다음 강의 사이에 물어 볼 것 입니다

English: 
what it does here.
Worked around.
Now, we can see it's actually
working, and I'm getting
answers that we believe are
good-enough answers, but we
also see that the speed of
what we talk about as
convergence-- how many
iterations it takes, the
number of iterations-- is
variable, and it seems to be
related to at least two things,
and we'll see more
about this in the
next lecture.
The size of the number whose
square root we're looking for,
and the precision to which
I want the answer.
Next lecture, we'll look at a,
what's wrong with this one,
and I would ask you to between
now and the next lecture,

Korean: 
그것에 대해 생각해 보세요. 여러분이 스스로 버그를 찾을 수 있는지 보세요, 우리는 
버그를 처음 볼 것 입니다, 그리고 나서 그 후에
우리는 답을 찾는 더 나은 방법을 볼 것 입니다. 
감사합니다. 

English: 
think about it, see if you can
find the bug yourself, we'll
look first for the bug, and then
after that, we'll look at
a better method of finding
the answer.
Thank you.
