Class. My name is Nick Parlante and I work in Google's engEDU group which deals with

sort of technical training in engineering. And also I have a job at Stanford where I

work as a lecturer. So, the Python today is--or rather, it's actually a 2-day class. So this

class is about just the basic useful normal Python. And Python is sort of--you know, it's

a nice friendly learn--and you can actually learn a lot of Python in two days. So, that's

the good news. This is the class where the prerequisite is not--you don't need to be

like super-expert engineer to come in here and learn Python. What we want is just that

you have some experience in some language. So, like, yeah, you have some idea what a

variable is or something like that. And then, and Python's going to meet you halfway on

this. Python, like I was saying before, you know, it's a nicely designed language. It--a

lot of things work pretty easily and so you can learn a lot of Python pretty quickly.

So, this is a 2-day class. And what's going to happen is it'll be a mix of lecture and

coding sections. I'll kind of alternate between the two. The good news or I guess the bad

news or whatever; the news is that the class moves pretty quickly. So, I'll show few things

in lecture and, you know, kind of demonstrate couple of things. And I want to get pretty

quickly to you trying that in coding because, really, when you code it up, you know, that's

when you're going to learn it. So, as I lecture through stuff, don't feel like--I don't want

you to have the idea like, "Oh,"--where you're memorizing or writing down everything that

I say. So, [INDISTINCT] few here for a second, so there's a--for the PyQuick class, we have

a whole set of written materials and here's the PyQuick page, it links all of them. And

particular today, there's this one PyQuick Basics. And that's pretty much what we're

going to talk about today. It's pretty long and it talks about strings and lists and modules

and a bunch of things that I'm going to lecture about. So, my goal is in the lecture sections,

just kind of pick up the basic idea of what I'm showing you. But don't feel like you need

to memorize every detail of it. And then later, when we're in the lab section, yeah, you can

go to the [INDISTINCT] packing it. You can go, "Oh, rightly, he said something about

strings," you can sort of orient yourself a little bit and figure it out how this stuff

works. So, there's also--I had, sort of--I printed some copies of this Basics thing but

then I didn't make quite enough before class started, so I'll go get those when we're at

the next break so I'll also give you a printed dead-tree version of this document for you

to get started. Alrighty, so, let's just get started. So, Python is a--actually kind of

an old language. It was created by a guy name Guido van Rossum, who actually works at Google,

and it was created in 1990. So, I think about it as, like, a little bit old by, you know,

hip language standards. However, in the most recent years, Python seems to have gotten

a lot of momentums. It's becoming pretty popular. And I think it stems from--I get it, it's

basically a pretty good language. I think of Python as being sort of a quick and light

language. So, if I have some little tasks, some little automation, I just want to just

dance, encode and be done. Python seems to work very well, like it's very, sort of, frictionless.

It's just--quick little things just happen very nicely. I think you would categorize

Python as a scripting language. So, it's similar to maybe Pearl or Bash or Ruby or maybe JavaScript,

the whole sort of space of languages that don't have a real heavy type system. So, Python

is certainly a nice example in there. Python as a--I'll show you as we start mess around

with Python. Python is good at, sort of, quick turnaround. So, you could--if you have an

idea, a little experiment you want to run, you just type it in and you could just try

it immediately. There's not a big compile stuff or anything, sort of, slow. So, we're

going to--I'm going to encourage you to have a development style where you have a, sort

of, quick turnaround between editing and running and I'll demo that in a minute. So Python

is certainly very appropriate for small projects, with little bits of animation. Within Google,

Python gets used for all sorts of little things like that. There is debate about whether or

not Python is also good for huge projects, since it lacks a big type system--and I'm

not going to settle that debate today. But, you know, there's certainly advocates for

both sides. But, certainly, as you know, Python is a wonderful language to learn for solving

small encoding problems. Ah, all right. So, let me show you--a little bit of Python code

here. Let's see. So, Python is an interpretive language. So, there's this program called

Python. And later on, we're going to write Python programs, the Python--this is called

the Python interpreter. It's actually going to, kind of, do the running for us. So, one

of the nice qualities of Python is that you can just run the interpreter, so I just type

"python" in here. And then, I can just type little snippets of codes, just add it and

it'll, sort of, compile and run them just as we go. And so, this is a marvelous way

to sort of see what's going on. So, I can just show you some basic Python here. So,

I'll assign a variable "a," I'll say, you know, "a is 6." And so, what the interpreter

does here is what's called the read eval print loop. So, I type a little bit of code to it.

When I hit return, it's going to evaluate it and its going to come back with a prompt.

It'll say, "Okay, I know you--now what do you want to do?" So if I type "a," just a

value, what it does is it evaluates it. In some sense, it kind of prints like, "Well,

here's, sort of, the ASCII form of that," and then it comes back with a prompt. This

is a very standard interpreter sort of thing. So, a couple of notes; please notice there.

Notice I didn't have to declare that I was going to have a variable "a" or that it was

going to be an "int," no. Python, it's all about quick light. We're just like, get right

to it. So, just by assigning to "a" that it cause us to exist. Later on, I could say,

"Oh, let's have 'a' be the string 'hello,'" Well, okay. We're fine. So, there's not a

compiled time type that associated with "a." Instead, "a" just points to whatever it points

to. So right now--so I have to hit "a" here. So, yeah, so now it's a string, earlier it

wasn't it. Though, with the jolly a little bit aligned, the way you can think about in

Python is that a value, you know, "a" in this case, it points to something and in or a string.

And whatever it points to knows what type it is. That's stored at runtime. And so, then,

as the code runs, it just uses the types of the objects as they are at runtime. And we'll

certainly see that theme in a lot of the cases. Okay, I'll show you just syntax, at least.

So, there's a built-in function called Len. And so, if I wanted to take the, you know,

find the length of that string, I could say, "Len of a," and okay, it turns out, that's

"5." Also, Python is case sensitive. So, if I type an upper case "A" I'm going to get

this error. So it says, "nah, blah-blah." This bottom part, I think it's almost English,

"Name error: name "A" is not defined." Okay, well, that's telling you something. So, in

Python, if it comes across a variable or some other symbol which has not previously been

given some value, then that's an error. Then there's a little bit in contrast to some languages

where if it's undefined, it's like, "Well, you know, let's just use the empty string."

Or, you know, "Let's just kind of blunder ahead." Python is not that way. So, this will

also come up like when you go out and bounce an array or do some other thing where it's

a little bit like it doesn't seem to match up, Python will halt. And I think giving you

an experience, the Python language is just--since the greatest source of delays in your code-working

is bugs. And so, it's bad, or if it's been found, it's bad if a bug is, sort of, sitting

in there, hidden. Really, if there's an error, you want to know. And so, Python reflects,

or reflects that style. So, let me show--so, what's going to happen is we're going to do

all sorts of Python. And the interpreter is a great source of doing little experiments.

So, for example, what's going to happen is someone's going to ask me some questions about

Python and I'm just not going to know the answer. I mean, of course. And--but rather

than admit that, what I'm going to say is, "Oh, that's an excellent question. Hey, let's

try it in the interpreter and see." And in that way, I'm never at risk of being wrong,

or whatever, it's just going to do whatever it is going to do. So, for example, you might

wonder, "Oh, well, what if I want to have a string and an int together?" So, I'll say,

"'Hello' + 6." Now, what does that do? Okay, it turns out that doesn't work. I was mentioning

the solution, so you're already at "+"--in Java that works and some of the--in Python

though, "+" between a string and it does not automatically convert then it fix it. Oh,

in the interpreter, by the way, the "Up arrow" works. So it's, sort of, like in Bash, I can,

like, flip the previous lines. So it just happens, if I call, there's an "str" function.

So, if I do "str" on it then "str" on kind of anything. Then that makes, or tries to

make a string out of it and then the code works. I'll talk more about strings and stuff

later on. But you can do that yourself, right? You can be the interpreter and if you have

some questions about, "Oh, what if I do to--do the--where?" It's just so quick like, well,

just, you know, fire up the interpreter and try it out. And so, Python does work. I guess

it's in an interactive style. And I'm being a little repetitious about this because coming

from a Java or C++ background, this feature isn't very foreign. So, it's not something

you would necessary have an instinct to do. But in Python, it works very well. So I will

certainly encourage you to go that way. Oh, all right. So let me get out this. I'll show

you how quit the interpreter; the way I do it. What I do is I type the word, "quit,"

and it doesn't work. But in the error message, it says--"Oh, right, right, Control D." Okay,

good. And so then I type 'control'--Oops. So, here we go. So, in our in--you know, later

on, oh, you don't have to do it now, but later on we'll have this PyQuick directory. It's

going to have a bunch of exercises for you to do. And I'll analyze my selling here. And

in particular, I've got this "hello.py" file. And so, I'm going to use that as kind of a--just

real basic example to start things up. So, one of the required, you know, in order to

do this class, what you want to do is you're going to have a way of editing and running,

and switching between those two very quickly. And there's a separate handout that talks

about that. So, I won't repeat that in lecture. In this case, I'm going to have these two

windows. So up here, I've got this like, you know, whatever, primitive EmEx editor but

while I can do editing in that screen and then in this screen, I can do running. So,

what I'd like to do is, you know, right here is a very basic Python program. I'd like to

just talk about the parts of this thing. So, up here at the very top, you've have this

standard user bin, Python, you know, sort of, or, you know, number sign--bang! Just

talking about what interpreter is going to use this. We're going to--today, we're going

to use Python 2.4. It's a perfectly modern version and this is also the official modern

version used here in Google. There's also a 2.5 and a 2.6. But those differences are

like not real big, so I wouldn't worry about those. I would not use Python 2.2 because

that at--is actually different. So, 2.4. Go with that. Python 3 actually just came out

and it does have some real differences; although, it's not in wide use yet. Here and there--mostly,

we're doing just totally straight-ahead normal standard Python. And so, that's not very different

in Python 3000--in Python 3. But in a couple of places, I may point out things that are

going to be over little different in Python 3. But for the most part, the stuff we're

going to do, we'll all come through fine. The "-tt" thing, I'll talk about in a second.

Okay, let's get rid with this import system. There. So, what this says, this is a "def

main: print 'Hello.'" That defines a function. So, you say, "def" and space and then the

name of the thing. Yeah, question? >> [INDISTINCT]

>> PARLANTE: Oh, I'm sorry. It's coming off a bit. Oh, thank you. There we go, all right.

So, this is just a simple function definition. In this case, I can get whatever name I want.

But it's very conventional in Python that whatever is going to be, kind of, like the

main thing you do, you'll call lower case m, "main." In this case, it turns out Python

has a print operator. And so, you can say "print" and then there's a series of things

and separate them with commas and it prints them. So, in this case, it just prints out,

"Hello." This thing at the bottom is a little unfortunate but I'm going to--it's boilerplate

syntax. And that is the boilerplate syntax to run the "main," that we find above. And

I will mention very briefly why this is here. But then, you should think of this as just

something that's just mechanically you just put at the bottom of the file and then don't

think about too much. The way this works is that a Python program can be--in this case,

"Hello.py," you can run it like [INDISTINCT] like I want to invoke this program. And in

that case, that if statement will be true, the way the interpreter sets things up. And

so, since it's true then here what does is it's calling the main function. So, actually,

I can just demonstrate that. So, if I go down here to my--same directory, so, the way you

run this thing--well, there's two ways, you could type "python," the name of the interpreter,

and then give it "hello.py," say, "Hey, please run that." And then, you could see here it

prints, "Hello." So, there's my marvelous program functioning. In the Unix way, the