- Okay, so we've taken a look at loops
    and now we're going to just take a little
    bit of a look at some of the operations
    that you can do with loops.
    - Um, Python has this,
    as we'll soon learn,
    object orient approach to its operators.
    And, the plus can add strings
    and it can add numbers,
    it can add floating-point numbers,
    integer numbers, strings, etc.
    And, so the plus similarly
    works this way with lists.
    The plus looks to its left
    and looks to its right
    and says, what am I adding?
    And in the case that I'm adding the list
    one, two, three and the
    list four, five, six.
    It concatenates them together
    and in this way it sort of
    functions like a string.
    And so, we get one, two,
    three, four, five, six.
    It just concatenates lists,
    this list to another list.
    And, it doesn't change a or b,
    just like in any kind
    of assignment statement
    Its calculations on the right side
    don't change the variables and
    then produce a new variable
    and then assign that into c.
    You can also use list slicing.
    It's easy to remember,
    if you remember how strings work,
    lists work exactly the same way.
    So, of course, it's a little tricky,
    the first number's the starting position.
    They start at zero.
    So, one is right there,
    so it's the zero position, one position,
    start at one, right, but go
    up to but not including three.
    There's one, two, three.
    So, this goes up to but
    not including three.
    And, that's why we get
    forty-one, twelve out of that.
    So, up to but not including,
    I'll just say that over
    and over and over again.
    If we do, you can leave
    the first part out,
    you can leave the first part out here
    and you can say up to
    but not including four.
    So, that starts at the
    beginning goes up to
    but not including four,
    and so that's how we get
    that piece right there.
    We can say, um,
    start at the position three,
    zero, one, two, three.
    Start at position three and go to the end.
    Now, the fact the number three is in here,
    is sort of irrelevant.
    Um, three to the end
    is those three numbers.
    And, then you can do the whole
    list with slicing as well.
    Again, these are pretty
    much the exact same examples
    I used when I was doing strings,
    they're pretty much the same.
    There's a number of different methods
    and you can look up all the
    documentation in the list.
    I often just use the dir command
    to remind myself of them,
    append we'll look at,
    count looks for certain
    values in the list,
    extend adds things to the end of the list,
    index looks things up in the list,
    insert allows them,
    the list to sort of be
    expanded in the middle,
    pop pulls things off the top,
    remove removes an item in the middle,
    reverse flips the order of them,
    and sort puts them sort of
    into order based on the values.
    So, let's look at a couple of these.
    Um, so if we build a list from scratch,
    we have a way to ask for an empty list.
    There are a couple of different ways
    to ask for an empty list.
    We could use just two square
    brackets next to each other.
    But, this is a form we
    call a constructor form
    where we say, hey Python, make a list.
    And, in this case the word list
    is like a reserved word to Python,
    it's really reserve class, but, um.
    Say list, list parenthesis
    says makes me an empty list
    and then, assign that list into stuff.
    So, stuff is now a list object,
    it's a type list but it has nothing in it.
    And, then we can call the append methods,
    stuff out of append and stick book in.
    And then, we say oh,
    and that knows how long,
    and the stuff knows how long it is,
    where the end is and how
    to add something to it,
    then add a ninety-nine to
    it and we print it out.
    And, we got book and ninety-nine,
    reminding ourselves that lists,
    while they're often the
    same types of variables,
    same types of values, in the
    various positions in the list,
    it doesn't always have to be that way.
    Then we say, oh, we'll
    stuff append cookie,
    you can keep on going
    and then we end up with
    three things and the cookie.
    We have an in operator,
    it works pretty much like
    the in operator in a string.
    Uh, is nine in my list?
    And, that's pretty simple and
    the answer of course is yes,
    nine is in my list.
    Is fifteen in my list?
    Looking through, no it's not,
    fifteen is not in my list.
    And then, there's the not in operator,
    you can think of that as
    kind of like one operator.
    Is twenty not in the list?
    And the answer, since
    it's not there, is true.
    And, so that's a way to just, you know,
    it's kind of like starts
    with or end for strings.
    Same kind of stuff.
    Lists are in order and they're sortable,
    and so this is something
    we take good advantage of.
    A lot of what computers
    want to do is sort stuff,
    you know look all these things up,
    append them and then get them sorted.
    And so, there is this
    method inside of list
    that's just the sort method.
    So, here we you know put three values
    in zero, one, two positions.
    Zero, one, and two,
    Joseph, Glenn, and Sally.
    And, then we tell the list to sort itself
    and then we print it out.
    Now, this is actually
    sorting the list in place
    which is different like
    than upper and lower,
    because if you remember
    strings are not mutable,
    but lists are mutable and so you say,
    hey, just sort yourself.
    Okay, and so just sort
    yourself and then it sorts it.
    And then, it's in alphabetical order,
    Glenn, Joseph, and Sally.
    I happen to be clever, I
    only put strings in there
    and I put my uppercase and lowercase
    in a very consistent pattern.
    But, the list has changed,
    and if I look at list sub one
    that is the second item, which is Joseph,
    that prints out right down there.
    There's a whole bunch
    of built in functions
    to help manipulate lists,
    the other things I was
    showing was method sort
    is a method that's part of lists
    but there are other functions
    that take lists as their arguments.
    Um, we already talked
    about the len function,
    it tells you how many items there are.
    There is, pretty obvious, max,
    it says go through and find the largest.
    Min, go through and find the smallest.
    Sum, goes through adds them all up.
    And, we can say, let's do average
    by taking the sum of all of them
    and dividing it by the length.
    And you might think to yourself, oh wow,
    I wish we'd had known
    this a few chapters back
    when we were having to
    write all those loops
    to do max, min, sum,
    largest, smallest, etc.
    You can kind of think in
    your mind that inside each
    one of these functions
    is a loop that does,
    pretty much, what you
    did in those chapters.
    Part of the reason we did that back then,
    was even though these things were here,
    was they're kind of easy
    loops to understand.
    And so, those are there and
    basically there allows two different ways
    of building loops to do
    the maximum and minimum.
    Now, it's not necessarily
    all that much easier to
    do something using these
    because you either can do them the old way
    or you can make a list
    and use these functions.
    So, let's take a look, and
    I'll just say that these
    two bits of code are doing
    the exact same thing,
    and what they are is
    implementing a program,
    that's going to repeatedly ask for numbers
    until we type the word done,
    and then it's going to compute the average
    and tell us what they are.
    And, so using sort of the
    stuff from the loop chapter,
    we start with a total
    variable and a count variable,
    set them to zero and
    then we read a number,
    check for done to break out,
    but then we convert it
    to a floating-point value
    and then we say total
    equals total plus value
    and count equals count plus one.
    So, this is gonna run over
    and over and over again,
    how ever many times
    we're going to do this.
    And then, it's going to
    pop out and when it's done,
    it's going to have this value of total,
    the running total will
    become the overall total
    divided by count and then it'll
    print the average out, okay.
    So, that, that's kind of
    how we would have done this
    before we knew how to do this with lists.
    Now, let's take a look at the other one.
    And, the other one, we say
    lets make an empty list,
    remember this is that constructive syntax
    that says to Python, make me an empty list
    and assign the empty list.
    It has nothing in it. Right.
    But it is a list.
    Has nothing in it, into
    the variable numlist.
    Now, we're going to write another loop,
    we're going to, this
    part here is the same.
    These three lines.
    Read the number, if it's done,
    quit and convert to value.
    But instead of doing the
    actual calculation right now,
    all we're going to do is
    just append it to the list.
    So, the list will start out empty,
    then the three will be in the list,
    then the nine will be in the list,
    then the five will be in the list.
    So, we're appending each
    time through the loop
    we're appending into the list.
    So, we're just growing the list
    every time I read it value.
    Instead of actually computing something
    with the value that we've got,
    so in either case we get value
    and in one case we append it to the list.
    And then finally, it
    finishes, the break happens
    and then we just say, oh hey Python,
    sum up everything in the list,
    add these three numbers together,
    and then take the, divide it by the length
    of all those things and
    you'll have the average.
    And, so these two things give
    us exactly the same output.
    Now, there is one difference,
    if there was like one million
    or one billion numbers,
    they actually all have to be stored
    in the memory simultaneously.
    Where as here, it's actually
    doing the calculation
    of the billion numbers and
    not using up so much memory.
    For most of the things
    you're going to be doing,
    the difference in memory, there
    is a difference in memory,
    this uses, this one here uses more memory,
    but I can't draw very well.
    More memory, um, it uses more memory,
    but it doesn't really matter
    by the time it's all said and done.
    And so, for you, the
    difference between these things
    is not all that significant,
    but it's important to
    understand that they're just two
    techniques to accomplish
    the same thing with lists.