Google Python Class Day 1 Part 1_6

download Google Python Class Day 1 Part 1_6

of 33

description

Python

Transcript of Google Python Class Day 1 Part 1_6

  • Youtube subtitles download by mo.dbxdb.com

    >> 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 alsoas 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. Subtitles End: mo.dbxdb.com