>> PARLANTE: All right, hey there. Hey, good
morning. Welcome to the PyQuick Basic Python 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 more modern thing is that you would--you have
the XQ bit set--I'll have talk about this a little bit, and so then, you can just say,
that's the, you know, whatever. "hello.py" and it just runs it. So, either of those techniques
will work okay. All right. So, in that example, I'm running it and so that then this if statement
is trying out to be true and so then it runs "main." There is this other way that you can
load a Python program. Where one Python module wants to load another one and use it essentially
like a library--which I, actually, am going to demonstrate, I think, tomorrow. And in
that case, I want to load the Python module, it's sort of synonymous with [INDISTINCT]
file in Python. I want to load it but I don't want to run it. I just want to have its definitions
available and so, in that case, this if statement will be false if I load it. And so then, it
will bring the module in but it won't run its main. So, that's what the if statement
is for. But for today, we're just always going to run it just like hello.py so you don't
need to worry about this too much. Okay, so let me show you--I want to, you know, I going
to add a few features to this thing; and so just to, kind of, show you some things. So
first thing I'm going to do is, I want to print out the command-line arguments from
my main here. It's just a very common thing to want to do. And it turns out, there's a
module called "sys." And the sys module, there's a Python--standard Python thing, it includes
a lot of, sort of, operating system interface-type stuff. So, you could access command-line arguments
or you could exit the whole program or whatever. I'll show you how to bring up the documentation
in a second. In Python, the way that you refer to some external module of stuff you'd like
to pull in is you have an import statement. You say, "import sys" or import--I'll show
you a bunch of different ones over the next few days. And then, down here, to refer to
something inside of the module, you say module name, so "sys" and then dot and then and you'll
just need to know the name. In this case, it's, "sys.argv," is the name of the command-line
arguments in that module. So, I'm going to save that and then down here, I'll run, "hello,"
and I'll just say like "aaa bbb ccc," right? So, those are command-line arguments. So now,
when I run it, see it prints these out. So that is a Python list. It has four--so Python
lists have square brackets around them. And we'll mess with this a lot more later on.
In this case, this list has four elements in it, which is, kind of, the old Unix standard
way of doing command-line arguments. The first argument, it points to the script itself,
so that's "./hello.py." And then, the subsequently three elements--these guys here, that's just--Oops!
These guys then just correspond to the arguments here of that I passed at. So, what I want
to show you--so, I'm going back to my source code here. So, so far, this part doesn't really
do anything very useful. But I do want to show you just the idea of a module like, yeah,
there's--we're going to use modules a lot today. So, that's how we're going to pull
stuff, you know, you use codec way to write by code of my program. Now, a very reasonable
question is like, "Oh, 'sys,' like, how am I supposed to know that?" like, "Where did
that come from?" So, I want to show you two ways that you can, kind of, research what
a module is and what it has in it. And I'm going to show you two. There's the hi-tech
way and there's the easy way. And they both work fine. So, you could use either of these
ways. First of all, I'll show you the hi-tech way. All right, so I'm going to fire up the
Python interpreter, and actually in the Python interpreter, I can say "import sys." I mean,
it really kind of looks like a program. It's just that I get to type stuff interactively.
So then, inside of--there are two functions in here. One is "dir," so I can do a "dir"
on sys. And what that does is to just, kind of, shows me all the symbols that are defined
in there. So, it's sort of an homage to dash, I always think of dir. And so, you can see,
you know, if you didn't know about "argv," or whatever, you'd say like, "Oh, exit." "Oh,
that's probably the exit function," and--where's "argv?" Oh, all right. Check it out. There's
"argv." So this--some of these are data, some of them are codes but you can at least get
a feel for what's inside of there. So, dir, that's the first one; then there's a companion
called help. And what help does is it kind of pulls up sort of a JavaDoc, sort of a man
page documents about like, oh, what is going on with this module? And so, with dir and
help, you can kind of poke around a little bit and orient yourself. And what's nice--if
you look at my list here, for example, there's--this is my example, there's exit. So, that's sys
dot exit that's a function. I can actually say help of sys dot exit, and then it pulls
up just help about that function. So, just in Python and in lecture or whatever, I will
say, "Oh, use the Ebola ABC Module," and I'll kind of mention a couple of functions that
you need to use but I won't give you further direction than that. And so then, what you
know, which is a very realistic position to be in. And what will happen is that in Python,
you can use dir and help to kind of dig around and get better docs, or you know, using--using
this technique. I'll do another example. Remember I talked about the len function earlier? So,
I could say help of len and that like, gives you like, okay--not pretty scant description
but a little bit of description about that. One thing I'll point out about this first
of all, usual--notice why, when I type help len, I'm just typing len without a set of
parentheses after it? And that's a kind of subtle syntactic distinction. When I say len
paren hello like that, I'm calling the len function. But when I just say len with no
parens like that, I'm just referring to the len function. I'm pointing to say, well, here
is some code. Don't run it, I just want to talk about this code. So, here when I call
help, notice it's just len and it's just unadorned, all righty? So, let me show you--so that's
the high-tech way of doing dir and help, certainly very useful. Now, I'll show you the easy way.
The easy way is you go to your browser and you just go to Google and you just type Python--like
what did we just do? I'll say Python sys exit and then whatever; Google searches, for whatever
reason, just work really well with Python. So, like the first couple hits, like yeah,
it just is the docs for the Python sys exit function or I've been doing a Python--I'll
show you strings in a second. So, if I say Python string, type that out, oh yeah, first
hit here. So, Python.org is the official--so, Python, I should mention, is you know open-source
and all, like good minor stuff. Python.org is sort of the official Python home and so
if you see a link that's docs.Python.org a lot--you know that--Python.org has excellent
documentation and tutorials and all sorts of stuff like that. And so, if you get a Google
search that just kind of points into that a lot of times, so that's going to be nice
authoritative answer. So, just doing Google actually works amazing alone. I was feel like
I'm being kind of powerful and hip if I use like, dir and help to dig around, but I must
admit that in fact, just doing a Google search that, like, any six-year old could do, like,
in fact, works great. And so, you know, both those techniques are available, you have to
use whichever one you like, all righty. So, let me show you--let me go back to my--get
out of here. So, I want to build up the Python code inside of a--inside of this function
bit, show you couple of things. One thing, I'm going to show you a very common error,
real quick. So, I'm going to comment out the import sys. So, incidentally the number sign
is the comment character, so like, and that just goes to the end of the line. So, this
is a very typical way I would write this code. I'm using sys.argv, but I've forgotten to
do the import. So, I want to show you what that looks like. So, if I say hello, I get
an error. So, this is a Python error trace. So, the most interesting part here is maybe
at the bottom, says, "Global name sys is not defined." Now, the error is not very specific
here but it's kind of--it doesn't quite know if I wanted to have a variable name sys or
module, it doesn't know. It just looks like S-Y-S to it, but it is that error like, while
I came across the symbol and it was not previously defined. So, you could see that that is one
of the basic rules of Python that if you--if you're going to use a symbol, it previously
needs to have been given a value. So, when you see something like that and it refers
to a module that you're trying to use, then what that means is--oh, right, I forgot to
do the import. So, I go back here, I'll put the import back. So, essentially what the
import does is it takes the symbol S-Y-S and it binds it to point to something so that
then down stream, when you say sys dot whatever, it's able to see if it'll actually work. So,
let's try that much and now work again. Okay good, now we're back to just pitching the
arguments. All right, so I'd like to do--well, I'll show you how to build a real program
out of this. So, I'm going to define a hello function that does something. So, I'll say
hello and then let's say this will take in a string. So, I'm doing a second def here
and let's say--let's say this is a name, actually. I'll say prints, "hello" and then the print--you
can actually separate things with commas. So, if I say "hello" name--and you can have
multiple comments, multiple things in it; it sort of prints those out and puts them
on a line. So, what I'll do down here actually and when I'm all set, let's have--let's put
a bunch of exclamation marks after the name. So, that's my little "hello" function that
has two lines in it and I'll talk about the plus and--you know, I'm glossing over some
details there, but you can sort of see what it does. And then down here, I'll call my
"hello" function and what I'm going to do is I'm going to pass in the first command
line argument. So that was sys.argv and that turns out the zeroth element refers to the
script itself which is--that's just an ancient convention. So, the element that I really
care about is sys.argv one there. So, I'm going to save that and I'll see if this works,
so I'll say, "Hello Alice," and so there, check it out. All right, so now it prints
"Hello Alice," you can sort of see the results there. All right, so let me talk a little
bit. I just want to use this as a vehicle to kind of talk about what's going on syntactically
with Python. So, I'll sort of o through this top to bottom. So, I give this thing an argument
called name. Notice just like--just as with the variables, I didn't have to declare that
this was a string or an ant or anything like that. I just say well, whatever; it's just
called name and it just points to whatever it points to. So, arguments and variables
are similar, they're both just names that point to some value. Then, in Python when
you want set off a block of code, it very often uses the colon, as you see here. So,
I'm going to say define this function and there's a colon. Now, I'm going to go to the
next line and I'm going to have, you know, how are many lines of code I want to have.
Now, this brings us to Python's most sort of famous syntactic feature which is that
Python does not have any sort--any left curly brace, right curly brace notion to enclose
a block of code, instead, Python uses indentation. So, notice under the def here--so the Google
standard is to indent by two spaces, and so that's a fine thing to do for today. So under
the def, this first line is indented by two and this next line is indented by two. So,
that's what's putting them inside of that function and there just isn't a left curly
brace or right curly brace I typed to put those in there. So, this is--it's a little
bit controversial. I'll just give you my take on it. I think the idea is that if we were
writing this in Java--I'll disturb all the real Python people here, you know. I don't
know. Suppose it looked like this ... sounds really funny, all right. Suppose we had that,
right? We're blocking out the code that makes this function and what we would've indented--like
we would've had one set of brain cells that was managing the curly bracers and putting
them in right. But then, we also would've indented correctly, right? And we were raised
right and it looks terrible. So, of course, we would've indented correctly as well; that
would've been a second set of brain cells, those. So, we would've maintaining these two
things kind of in parallel. But if you start to think about it, those two bits of syntax
would've been reflecting the same piece of information; they always would've moved in
tandem. And so, the Python idea is like you know, having two bits of syntax that represent
the same thing and then we're just trying to keep them in sync is dumb. Like, we want
to just do the quickest, most minimal, clean thing and that's kind what Python looks like,
and so it's like, you know what? Let's just get rid of the curly braces. If the--if we
want to look right--so I'll put the colon back there--let's just have the indentation
define how the blocks of code go. I'll fill this--this function have to be little longer
so you'd get a better feel for what indentation looks like. My advice about this is that it
seems extremely foreign, weird and slightly wrong for about the first 11 minutes that
you use it. And then, it's just fine. I mean, it's just basically very logical and reason
why--it's kind of visual and so, it very quickly just seems normal. So I encourage you just
not worry about it. All right, so let me--I want to make this function a little longer;
then allow me to demonstrate the indentation a little more. Yeah, question?
>> It has space between hello and Alice [INDISTINCT]. >> PARLANTE: Oh, so yeah, the question is,
where does the space come? That's a quality of print that when you separate things with
a comma, it puts a single space between them. If I wanted to bunch those together, I could've
done a plus. The plus in string space just crams them together, so that would've done
it. All right, so, let me show you--so, I want to make this a little fancier here. I'm
going to put in an If statement. So, let's see. I'll say if--let's say, if name and I
know I'll just end up showing you how Boolean this stuff work. If name is, let's say, Alice,
then we'll say--I'm just going to--this won't be very meaningful. Here, we'll add some question
marks on there. So the--I'll just start at the top here. So, this is what an If statement
looks like. You say if and then you have the test and then there's a colon and then it
has whatever--block of statements underneath it. Now, just to get with this idea of indentation,
if I wanted to also do multiple things, I could say you know, you know, I'd consider,
you know, "Alert: Alice Mode" here or something. The fact that those two lines, the print alert
and these two lines are underneath the If, that's what's putting them, you know, under
the control of that if statement. And then here, when this line is indented back to Alt
that--that's what putting me outside the If statement. So, this is what it means to say
that the indentation is significant, right? Where something is placed left-right does
control what the code means and so that's the foreign part. All right, so let's start
about this If statement. Here, I'm using "= =." "= =" does sort of an intuitive deep comparison. In some
languages, you kind of have to worry, well, is this a point of comparison or whatever?
In Python, you do not to have that worry. "= =" does what I have described as a kind
of a real comparison. It takes the thing on the left, the thing in the right and it really
fleshes them out and compares them. So, it works for integers, it works for strings;
later on, I'll show you it works for entire lists. So, you could have relatively big data
structures and just compare them with "= =" and you'd still get a reasonable result. In C++
or Java, you always got to have the parentheses around the test. In Python, the parentheses
are not required. And then, so it's regarded as the best Python style to not put them in.
It's a little bit like--it's like speaking with your sort of vulgar accent. Like if you
put the parens in, then everyone's like, "Oh, I see. One of you is, you know, C++ refugees."
So, you could sort of show off your modernity by, like, not putting in it. If you want to
have a logical connective, this is a little bit strange. The logical connectives are spelled
out with letters. So, or is O-R and is A-N-D and not is--it's a little hard to say in English--not
isn't the thing above the one on the keyboard, its N-O-T. So, I'll say, you know, if name
is, you know, Nick. So, finally, I'll put a--I'll put an else in here just to show off.
So I'll say else colon--what do we do in the else case? I'll print "Else." Okay. So, now
you that--you could sort of see the indentation and you're really working here and we've got
this kind of modest Python program. All those mentioned, you know, all the regular Boolean
stuff. You know, there's less than and equal equal and, you know, all the kind of regular
Boolean stuff works in Python as it does in other languages. There are Boolean true and
false values, although those aren't used very often. The rule in Python is that if you have
appointed (ph) or something, there's a few kind of null values that count as false. So,
if a number is zero that counts as false. If a string is the empty string that counts
as false and any other value or, you know, and the--or if the string is not empty or
if a number is not zero, then those count as true. So, that's similar to how other languages
do it. All right, so let me just try running this a little bit. So, I guess if I run this
and I say "Hello Alice," then my If statement kicks in, so I get all those question marks
and then the line below kicks in and I go--oh, it's pretty doofy, pretty doofy looking out,
but hey, at least it works. So, I'm going to show you--I'm going to make a very sweeping
claim about how Python works. Python does everything at the last possible second. So,
in C++ or Java, it takes your code and it compiles and it checks it in a million different
ways and you might get a lot of different compile errors, and then only after all that
compile checking, then it runs it. That's not how Python works. When you feed your Python
code like my hello.py in the Python, it just looks at it in the most superficial way, it
checks pretty much nothing; it just starts running it. And each line it gets to, it evaluates
at that line kind of in the moment. So, in the moment, it looks at what those variables
point to and oh, he's got a string and an ant here and it just tries to do it just at
the last possible second. And only at that second does it notice if there's an error,
maybe a variable is not defined or you're calling a function that doesn't exist or you
know, dividing by zero--I mean, we're always, you know, aware of bugs. So, to highlight
that, I want to try calling a function here. I'm going to call a function called DoesNotExist.
Here, I'll pass in a name. Now, there is no such function. I haven't defined it, there's
not a built in code DoesNotExist, it's just wrong, all right? That else is just incorrect.
This does demonstrate a deep quality of Python. Now, if I call hello.py and pass Alice, you
know what? It's going to work fine. All right, this is what I mean. What happens is Python
only checks a line when it runs that line, all right? And so, because it just kind of
never hit this else, whatever, it just kind of never knows that that was wrong. Now, in
the great, you know--as we understand the universe, you don't get something for nothing.
Well, in Python it means there's not a big barrier between you and just, like, your code
running. And that can be a real virtue in a lot of cases. But also, you're giving up
a certain amount of checking that some languages might have done. This also means that in a
more industrial sense, because Python doesn't really check a lot at a compel time, for industrial
code, it's more important for it have to have good units test coverage. Like you actually
need to have run all the lines to see that they're correct. Now, for our two days, we're
going to work on things that are just kind of medium sized little utilities where, you
know, if they're incorrect, you can see pretty clearly and so for that kind of problem Python
is really a good match. All righty. So, let me show you--I think I'm going to go back
to the Python interpreter here. And I've showed you--I've sort of used strings and lists and
a few things informally, but I never really explained them, so I want to kind of slowdown
a little bit here and actually talk about how some of these things work. So, the Python
string-type is enclosed in quotes. So, there's like this string "hello" I've been done. You
can also actually put the string in double quotes or--here I'll do a different one. Isn't--oops--that
works the same. There's not a deep semantic difference you could--it's just your choice,
you can either use single quotes or double quotes. The one difference is that inside
of a double quoted string, as I have here, you can put a single quote like isn't there
and it just, just works. And, likewise, if I'd use single quotes, on the outside, I could
put a double quote inside. There's not a real strong preference. You can kind of use which
the one you prefer. I tend to use the single quote one. It's just, it looks a little Python
to me. Yeah, question. >> What kind string that you want include
single and double quotes? >> PARLANTE: Ah, in fairness to your question,
so if want to--so let's say I'll do a double quoted one and I want to put a double quote
inside of it. So say like--I--what would you say, I'd say like--I--what you do is you put
a back quote, a back taken from it. So I'd say, "I love this exercise," yeah, that's
fine. Well, alternately, I could have done it, and set some quotes. All right. So, I
should you--let's see what's a--isn't. So I showed you the "len." Oops. The "len" function
earlier. So strings also––as I think I've already done, they--the plus works. So if
I'd say "a + you know yay" then that puts it together, you know, plus put strings together
to make a bigger string. Strings in Python are what is called immutable and that means
that once the string is created it never changes. It's like a little read only thing. That's
a pretty modern style that turns out to be pretty popular in a lot of languages. So for
an example when I did that little plus there, if I look at the original "a" it's unchanged.
All right, the--so whenever anything you do with strings, lowercase, uppercase, I'm gonna
show you a few things. It's always creating new strings to sort of show you the result,
but the original string it's always left unchanged. So, well, maybe I'll do is I'll set "a" to
let's say uppercase "hello." Now it turns out there are a bunch of built-in string what
are called methods and I'll show you one now. So for example there's one called "lower"
and what that does is it makes the lowercase version of a string. Now the reason this is
called a method and this is basic object oriented programming just as a--you know there's some--a
few things that are very easy and that's we're going to work on for the next couple of days.
"A" this is, it points to the string, all right, I could think of a string object and
with this syntax where I say pointer to a thing dot and them the name of the method
I want to run. What that means is run that method on that object. So if I had "b" is
equal to like "yay," so if I say "b.lower" okay, well, it runs on that string. Whereas
when I'd say "a.lower" then it ran on "a," so that's basic, it's, it's, it doesn't, it's
a different syntax for running a piece of code called the method on an object and that's
you know hopefully pretty--that's done pretty intuitively. So, what I was saying before
is that strings are immutable, they are never changed. So for example, if I look at the
original--so here, I'll do it again. If I say "a.lower" that's not changing "a" that's
returning to me a new string that's the lowercase version I wanted. d if I look at the original
"a, it's unchanged. Now Python has--there are many built-in string methods. I showed
you lower. I can show you--there's like a find, just for example. So if I say "a.find
of "e" and what that does is it searches in the string for the first occurrence of that
and then returns to me in the index. Now in reality, there are probably dozens of built-in
string methods and I'm not gonna demo them all in lecture. I just want you to know that
there are a lot of built-in ones and either you could look at the Python (ph) where it
talks about some of the common ones, or you could type, you know, in Google, type, Python
string, or maybe Python string method and go to the page where it list them all. One
of the theme--you know one of the reasons that software is a lot more productive than
it was say 15 years ago is that we've gotten better at having what I think sort of built-in
codes. Like a code you didn't write that, but that you can call and it just solves basic
problems for you, sort of code reuse, and Python like any modern language actually has
a lot of code already done for you. And so one of the basic skills--I think it's kind
of living higher on the food chain is when you're solving a problem, you don't necessarily
like, "Oh, now I'm gonna manually ride a loop to solve that." Very often your first instinct
is to find the module and dig around a little bit to find some code that somebody else already
wrote, it's already done and you're going to build your solution on top of that. That
is, that's a sort of good modern technique and it's an excellent Python technique. Python
has a lot of built-in stuff and you know over the cost of few days, I will certainly point
you where a lot of that code list. All right. So, I haven't talked about how to look inside
of a string. It turns out you can use a square brackets to look inside of a string. So if
I'd say, "a [0]" that's the left most character in "a [1]" that's the "e" and so on. If I
go out of bounds here then that's an error, so I really need to adjust you know keep within
the bounds of the actual thing. So one last--some text--I'll show you for this--this is a little
less--so you can use the plus to put together. You know if I wanted to have a string and
whatever, I could use the plus to put together. There's another form that uses seized print-up
syntax where I could say like "hi % s" and the "% s" is a place holder where I'd like
a string to go and I could say like, "I have" you know "% d donuts" and so that's, that's
called a format string and it a sort of--it's a good way of mixing in. You have this outer
skeleton and you want to sort of substitute in a few things and so then you use the "%" sign
and then you combine it with what you want. So here I'll say, "Alice and 42." And so using
this sort of "%" construct, you can have a string in sort of substitute values into it
into make a bigger string. Does not it really ever required, you could always have gotten
that result using plus to kind of put the string together but, it's fairly common to
use this so I'll just, I'll just mention it. The last thing I'll say about strings is that,
the strings that I'm showing you right here these are Unicode strings. Python's Unicode
treatment has been like a little uneven and particular in Python 3 it changed a little
bit, it got better. So for here I just want you to realize like, yeah, these are not Python
strings. These are not Unicode strings but--and in the handout talks about there's a slightly
difference route by which you create Unicode string. But once you've got a Unicode string
then all the things I showed you still work. The square brackets, the "len", the ".lower,"
all that kind of stuff, it's the same interface is just you created or so in a different way.
And so, I will--but for our purposes this will work. These strings essentially are just
serious and bites, it's just a (buck) of bites. All right. So that's almost--I'm going to
show there. So, I want to, I want to show you this one--how are we do on time? Oh, excellent.
I want to show this last string feature and I want to block out time for our first exercise.
So, in order to show you this, I'm going to go to the py quick basics document. I want
to--very high tech here. I'm going to attempt to--here we go. It's just possible. I'm going
to try and show the interpreter in a little bit of art that I put in there to end up.
Okay, oh, perfect. All right. So here, I'll say, "a = hello," so I've got the same string.
So, in that little piece of art, all I've done is I've drawn in the index numbers, so
like all the languages in Python, the things are--if I want a number and when your sequence
of things, they are numbered from zero, starting at the left. So, if I'd say--if I refer to
"a [0]" that's the "h"--this is how I should have done it for or "a [1]" that's the "e."
Or if I say, "What's the len of this thing?" that's "5," so that just sort of conventional
indexing into something. Now Python has a syntax for referring to not just a single
element in a string like this but a kind of subpart of it, and this syntax is gonna use
the colon. So the way this is going to work is if I say "a" and I'll put the square bracket
but I'm going to put a colon in the middle here, and I'm going to refer--I'm going to
indicate both the start and the end. So, for example, if I'd say, "What, what?" I want
you to start at one; so that's the first index number and then the second number--yeah, it's
going to say, it's going to go up to but not including that one. In Python, this is called
a slice. So if I'd say "a [1:3]" that's the subpart of the string starting at the one
and going up to but not including the three. This is called--it's only entitled called
the slice. There's a--the word Pythonic is not a word I just made up, it's a real one,
in the nerdoroty (ph), and this is a very Pythonic feature. Python likes having syntaxes
which are sort of very short but crisp but then again you know it express something that
a common thing that you might want to do. So, if I wanted to--if I wanted to say, "Hello,"
I guess, I could say, what is it, a one--oops, "a [1:5]." That's a little weird. The five
is kind of one out of bounds there but, actually, what you could do in the slice syntax is if
you omit the second, the thing after the colon, it just goes all the way through the end of
the string. And, if you omit the first one, it starts at the beginning. So actually it
is a truism that if I'd just say square bracket, colon square bracket, well, I just get the
whole of whatever it was. So this is a very heavy syntax. For say, for example, if I want
to, you know, remove the first level--level--letter. I could just say one colon (ph) so like instead
of starting at zero, start at one and then just go through the end. So that's, so far
that's like pretty neat. But now, just a little bit of scrolling, I'd show you the slightly
other crazy thing it does. So, thus far, I've just used the positive numbers, but in Python,
they also added a second set of numbers that also index into the strings. So it's just
using the negative numbers and the negative numbers instead of starting at the left, they
start at the right. So minus one refers to the rightmost character and minus two refers
to the next one and the minus three and so on. You can think of essentially as there's
an implicit len there that--the minus one essentially saying len minus one, right. So
len in this case is five. Len minus one is four. I'll check it out for you. So do you
have written a code in a zero based system but it means that referring to things that
happen to be at the left is very convenient because like zero, one, two, you always know
where you are. But then referring to things at the right is like a pain because you always
have to add len and subtract something. So the negative numbers scheme just also makes
it convenient to refer to things on the right hand side, and they work in slices too. So,
for example, how about I say that I want to omit--first, I'll just do my earlier example.
So I could say what is it? "[-4:-2]"--oops. I'll put the "a" there. That's exactly equivalent
to the one where earlier it was a one colon three, right. The minus four is just another
way of saying that. I'm going to get a more realistic example. Say for example, I wanted
to omit the last three characters of the string. I didn't know how long it was. I could just
write that as colon minus three. All right, that it's going to go up to but not included.
I know minus three is the third in. So like I could "he" or I could do a getaway. What
if I only want the last three characters of a string? I guess right that is minus three
colon. So, it just--I think, syntactically, this is maybe it looks a little bit weird
but I found--the slice syntax, I find it--it's just useful in a lot of situations. So I would
encourage you to go ahead and actually learn this one and we're going to have all these
exercises and stuff in a little bit. Certainly, I have hidden inside of their little opportunities
for you to end up going to use the slice syntax. So that is a nice one to get the stuff going.
Okay, so that actually concludes the first lecture section. So what I would like you
to do is pull up the exercises and so if you go to the py quick page--just do it here--it
points to this page, py quick exercises, here you go. And then that explains how you copy
and I--if you could raise your hand, I'm happy to kind of walk on. How you can copy--this
is--said directory, direct, directories. It's going to look like this and let me--now, let
me show what I want you to do. So inside here, there's like day one, day two, and some other
stuff. Today, we're doing day one. So go in the day one directory, and the first thing
I want you to look at is there's this, there's a file there called--oops, no, not that one.
There's a file there called "string1.py" and I'm just going to look inside of there. A
so what this thing has--is in the comments--sorry, I'll make this a little bigger. There are
some little exercises in here that just use the stuff in lecture that we've done so far.
So, for example, here's, you know, exercise "A: Dr. Evil" and just in English, there's
a little description of like what it is I want you to do and it gives a little example
but then the code it just not done. And so your job is fill in the code there to actually
compute what it's suppose to compute; there's a few of these things. And then at the bottom,
I have filled in little bits of test code. And so you see that you don't have to touch
that, that's already done. They're just going to call the functions above and just kind
of check that they were trying the right thing. So it's kind of a primitive form of unit testing.
So if I run this thing right now, what it does is they all fail, because yeah, there
is no code and so what's gonna happen is as you fill those bits of function in then somebody's
pass--this discussion start passing. You can just run it each time to just very quickly
just get feedback about how it's going. So that is string one, I'd like everyone to do
string one. If you are just so fast, you get a little bored, there's also a string two.
In string two, it just contains more. And so, optionally, if we you have more time to
kill, I'd be happy for you to go ahead and do that. The last thing I need to point out
here--let's see, I'll just look at string one here. There's a thing I mentioned earlier
that I never explained. This "-tt" flag. What that refers to is in a Python file, what I
would recommend is you just always indent with spaces and that that is the Google standard,
just always indent with spaces and you're okay. But, in your editor, maybe by habit
or whatever you might accidentally hit the tab key, and if you have a Python file that
has a mixture where it uses and spaces in some places, in tabs and other places that
is deeply confusing, because visually where the codes appears to vertically appears to
a line may not correspond to how it really aligns as far as Python is concerned. So what
the "-tt" flag does is if it ever finds a mixture of spaces and tabs, it just immediately
halts, which is for--when you're on your first day of Python programming that's absolutely
what you want. So this will help you find the case where you want to do is the [INDISTINCT]
I've talked about. You want to set your editor so that if you ever hit the tab key, it understands
to just put in spaces. So put the "-tt" flag will protect you if, if you end up with--make
a mistake with that. Oh, all right so here's what I'd like to do, it's now, it's about
10:50, so I'm going to imagine; I want you to work on this with me maybe about half hour
for that, so that's--what I'd like you to do is then go have lunch. So what I'd like
you to do is be back in here--I'll have do all the math here. Back in here at 1:15 and
so I'm going to leave you some time for doing Python coding and then some time for having
for having lunch. You, it allows you to bounce something and of course, you know, I'm in
here to answer questions or whatever during that whole time. All right. So, so please
go ahead and get started with that.
If you missed the link in the youtube description, here is where the class notes and examples are.
http://code.google.com/edu/languages/google-python-class/
Also, python setup guides and links to everything you need to download to get started with python.
I've been wanting to learn Python for a bit now... and holy shit, this dude loves his job. "So this class is about, basic, useful, normal, Python :D. Python :D, is a friendly language :D....."
I know Python. I just don't have anything good to make with it. :-\
I bookmarked it for another morning. =)
I believe the technical term is Parseltongue
here is a tip when watching tutorials.. it's generally a good idea to download the .flv file (via firefox dl helper) and then play it in KMPLAYER or VLC which support options to speed up the video to 125 or 150% without affecting the voice or pitch. i've rarely come across a video tut that didn't make sense when sped-up, yet sped-up videos save you time and because information is flowing so fast you don't get time to get distracted.. so try it once :)
It turns out I wasn't that bored.
I recommend Zed Shaw's ebook http://learnpythonthehardway.org/index
...and video tutorials for all the main languages try Bucky's channel http://www.youtube.com/user/thenewboston
I'm liking this but I'm having trouble not yelling "CONCATENATE! THE WORD IS CONCATENATE!" at my computer screen every time he says "you can, like, put two strings together."
I need a programming intervention.