This two-part course is designed to help students with very little or no computing background learn the basics of building simple interactive applications. Our language of choice, Python, is an easy-to learn, high-level computer language that is used in many of the computational courses offered on Coursera. To make learning Python easy, we have developed a new browser-based programming environment that makes developing interactive applications in Python simple. These applications will involve windows whose contents are graphical and respond to buttons, the keyboard and the mouse. In part 1 of this course, we will introduce the basic elements of programming (such as expressions, conditionals, and functions) and then use these elements to create simple interactive applications such as a digital stopwatch. Part 1 of this class will culminate in building a version of the classic arcade game "Pong".
Input Fields
Loading...
来自 Rice University 的课程
An Introduction to Interactive Programming in Python (Part 1)
1850 个评分
从本节课中
Week 2 - Event-driven programming, local/global variables
Learn the basics of event-driven programming, understand difference between local and global variables, create an interactive program that plays a simple guessing game
与讲师见面
John GreinerLecturer
Department of Computer Science
Stephen WongLecturer
Computer Science
Scott RixnerProfessor
Computer Science
Joe WarrenProfessor
Computer Science
In the last lecture, we built the, kind of the basics of a calculator.
We had buttons that did things like print out the answer, add and subtract.
However our calculator has a severe limitation.
It only worked on fifteen and three. So we're probably not ready to start
bragging about our calculator just yet. So what we're going to do this lecture, is
I'm going to show you how to add an input field to your frame that allows you to
enter numbers that can be used inside your calculator.
And when we're done, we'll have something that even though it's still kind of old
school, it's starting to have the bare bones basics of the way a modern
calculator works. Well, let's go to it.
So here we have a kind of a halfway completed version of our calculator.
I've gone through and added a couple of extra buttons so we don't have to work on
the buttons anymore. You can see here we have our glorious
store of twelve and operand of three. As long as your numbers are twelve and
three our calculator's going to be great. So you can see I've implemented
multiplication and division. And, let's just run it right quick.
So a few more buttons. We can print out the contents.
We can add ''em. We can multiply ''em, divide them.
Well, it's starting to come along but we need to figure out how to actually enter
numbers now, so we're not always working on twelve and three.
So let's go look in the docks and see what super gui provides for entering in
information. So we go over in the docks and we see we
have some control objects again, so the thing we're going to enter actually is the
control object. And let's say we have buttons, key
presses, mouse clicks, but of course, here's something, text input.
Now this is not exactly what we want cuz we want to input a number, but it looks
like we don't have our number input function.
So let's just see what we can do in text input.
So, simple enough it said, add input, we give it a string that describe it, a
handler, we give it a width, that's nice. But there's something fundamentally
different between a handler for a button and a handler for an input field.
In a button, we just clicked it, and it did some action.
Here, We have an input field.
We have a number that the users typed in and then maybe hit enter and when they hit
enter. The input field handler gets called and we
need to have that handler have access to whatever the user entered.
So way this is handle is that, The input field handler is called over the
single parameter. That parameter is whatever the user
entered. So, when you implement the handler, you
are going to need to go through, and take this input parameter and do something with
it to react to whatever action the user intended when they entered that number.
So, with that kind of starting point, let's go through now and see we can piece
together how our handler for input field should work.
So, let's add an input field to our calculator code.
So really it's fairly simple. All we're going to do is we need to go
through and define a handler for our input field.
So let's say define enter, remember the handler is going to have one parameter and
that's going to be the, input called INP. And what's it need to do?
It needs to go through, and take that input, and assign it to the operand.
We want to put it in store, that's why we had swap.
So we have to be careful. There's a couple of things that could go
wrong here. Let's see,
We want to take input. We want to assign it in the operand.
So I could say something like, operand is equal to input.
And, I guess I could say output at this point.
But I made two errors here. The first thing is, remember if I want to
modify either the operand or the store, those are global variables.
So I need to go through and say global operand.
I'm gonna leave the other, other error uncorrected and we'll just see what
happens when I try to do it. Let's go through and actually kill off
twelve and three. Let's initialize them to the more rational
values of zero. And let's go down and.
Enter say F dot add input. Say enter, what the heck, enter operand.
Let's see if we can stick it, squeeze it in there.
We'll say enter and give it a width of 100.
And, hmmm, so we created our event handler.
We registered it, we reinitialized the globals.
Let's try running it and see what happens here.
I think it's going to be interesting. Okay, good, so we have enter operand-
that's nice it tells us what we need to enter.
And, well we could print over here. Things are looking good.
Not anything with 0,0, so let's enter an operand here.
So, I am going to enter twelve, my favorite number and to actually, make that
event handler trigger, I have to hit enter.
And, what do we see? The operand is twelve.
Interesting, okay, didn't expect that. Let's watt that in.
And let's enter, three and hit Enter. Boy, it's working great.
We've got twelve and three. But I think something's amiss here.
Let's do the following, let's try to add those two.
Ooh, we get 123, this is really getting good.
I'm going to try something more daring. I'm going to multiply them.
Oh, I just blew up. So what happened in there?
Well, I didn't anticipate things going quite this crazy, but I think it's
actually, you'll see kind of what went on. I said Operand is equal to input.
Now what did I tell you input wise? This was a text input.
This wasn't a number input. So input was extreme.
So whenever I said operand is equal to input.
It actual set the operand to be the string one two.
Then I swapped it, it made the store the string one two.
Then I entered three. So it said operand equal to three.
Now at that point I was expecting it to blow up.
I was thinking, oh okay, you know, we do string twelve plus a string three, what
could happen? Well, huh, it concatenated.
It made the string one, two, three. Okay.
Everything was going merrily, and then I said, hm, let's multiply.
So I said, the string one, two, three times the string three.
At that point, things blew up. Didn't know what to do with
multiplication. So, this is like more of a story why you
should do actually a fair bit of debugging, that was unplanned by the way.
I knew it was gonna, we didn't have the right type for the input, but I didn't
realize it's gonna go so far. But I think, we can actually learn more of
a story from this is, which is we wanted a number here, we wanted the operand to be a
number. This is a string, so we can fix this very
easily, all we need to do is to coerse this string into being a number.
So, we have some functions, we know how to do that well.
The function int converts it to an integer.
So, let's say, int of input. And we'll run it again.
So, let's try our favorite example again. Let's try it then twelve.
Hit enter. Operandus twelve, great.
Let's swap it. Let's enter three.
Looking good, let's add ''em. Well we got fifteen, that was better, we
didn't get 123. And then let's see, let's multiply ''em.
So now it's actually working the way we want.
Well kind of, there's still one more thing.
You notice we're only working on integers here.
Let's see if we can make this work maybe with decimals numbers, cause we really
like to use decimal numbers in our calculator.
So if I said, 3.14159, and I said enter. Threw an argument- threw an error here.
It did not want to take 3.14159 as a string and convert it directly to a
floating point number. So, let's just, we have, easy thing, let's
just make this a float. We can converse a string into a float so
I'll say float. And let's run it one more time.
We come back. Let's see, we can enter twelve.
Enter. And we can swap it.
And now let's enter, say, 3.14159. Enter that.
I notice now it's fine. In fact let's just go through and do
multiplication. So, sure enough, now actually our
calculator is working with floating point numbers so we're really doing decimals.
So we've got the basics of a calculator here, you know, we could kind of make it a
little bit nicer. Next week we'll go through and actually
print out the store and the operand here on the screen make it look like the
display of a regular calculator. But I think you can kind of see the basics
of how this works. This is a nice demonstration of how
buttons and input fields work. And I'll see you back in a second for
guess the number.
