pythonkid2
diff --git a/‎README.md‎
Lines changed: 2 additions & 2 deletions b/‎README.md‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎handy-stuff-strings.md‎
Lines changed: 5 additions & 4 deletions b/‎handy-stuff-strings.md‎
Lines changed: 5 additions & 4 deletions
diff --git a/‎images/differentlist.png‎
2.65 KB b/‎images/differentlist.png‎
2.65 KB
diff --git a/‎images/drawings.odg‎
4.18 KB b/‎images/drawings.odg‎
4.18 KB
diff --git a/‎images/people.png‎
15.4 KB b/‎images/people.png‎
15.4 KB
diff --git a/‎images/samelist.png‎
2.75 KB b/‎images/samelist.png‎
2.75 KB
diff --git a/‎lists-and-tuples.md‎
Lines changed: 269 additions & 0 deletions b/‎lists-and-tuples.md‎
Lines changed: 269 additions & 0 deletions
@@ -31,8 +31,8 @@ everything should also work on Python 3.2 and all newer Pythons.
 5. [Variables, Booleans and None](variables.md)
 6. [Using functions](using-functions.md)
 7. [If, else and elif](if.md)
-8. [ThinkPython: Lists](lists.md)
-9. [Handy stuff with strings](handy-stuff-strings.md)
+8. [Handy stuff with strings](handy-stuff-strings.md)
+9. [Lists and tuples](lists-and-tuples.md)
 10. [Loops](loops.md)
 11. [Trey Hunner: zip and enumerate](trey-hunner-zip-and-enumerate.md)
 12. [Files](files.md)
 
@@ -213,6 +213,10 @@ True
 >>>
 ```
 
+The things in square brackets that the split method gave us and
+we gave to the join method were lists. We'll talk more about
+them [later](lists-and-tuples.md).
+
 ## String formatting
 
 To add a string in the middle of another string, we can do something
@@ -260,9 +264,6 @@ our problem:
     `'Hello {}.'.format(name)`. I like to use printf-formatting for simple
     things and `.format` when I need more powerful features.
 
-    **TODO:** warn readers about formatting tuples, and show experienced
-    users that dictionaries aren't a problem
-
     ```py
     >>> "Hello %s." % name
     'Hello Akuli.'
@@ -273,7 +274,7 @@ our problem:
 
     In the second example we had `(name, channel, network)` on the right
     side of the `%` sign. It was a tuple, and we'll talk more about them
-    later.
+    [later](lists-and-tuples.md#tuples).
 
     If we have a variable that may be a tuple we need to wrap it in another
     tuple when formatting:
 
@@ -0,0 +1,269 @@
+# Lists and tuples
+
+## Why should we use lists?
+
+Sometimes we may end up doing something like this.
+
+```py
+name1 = 'wub_wub'
+name2 = 'theelous3'
+name3 = 'RubyPinch'
+name4 = 'go|dfish'
+name5 = 'Nitori'
+
+name = input("Enter your name: ")
+if name == name1 or name == name2 or name == name3 or name == name4 or name == name5:
+    print("I know you!")
+else:
+    print("Sorry, I don't know who you are :(")
+```
+
+This code works just fine, but there's a problem. The name check
+is repetitive, and adding a new name requires adding even more
+repetitive, boring checks.
+
+## Our first list
+
+Instead of adding a new variable for each name it might be
+better to store all names in one variable. This means that our
+one variable needs to point to multiple values. An easy way to
+do this is using a list:
+
+```py
+names = ['wub_wub', 'theelous3', 'RubyPinch', 'go|dfish', 'Nitori']
+```
+
+Here the `names` variable points to a list, which then points to
+strings, like this:
+
+![List of names.](images/people.png)
+
+## What can we do with lists?
+
+Let's open the `>>>` prompt and create a name list.
+
+```py
+>>> names = ['wub_wub', 'theelous3', 'RubyPinch', 'go|dfish', 'Nitori']
+>>> names
+['wub_wub', 'theelous3', 'RubyPinch', 'go|dfish', 'Nitori']
+>>> 
+```
+
+There's many things [we can do with strings](handy-stuff-strings.md),
+and some of these things also work with lists.
+
+```py
+>>> len(names)   # we have 5 names
+5
+>>> names + ['Akuli']   # create a new list with me in it
+['wub_wub', 'theelous3', 'RubyPinch', 'go|dfish', 'Nitori', 'Akuli']
+>>> ['theelous3', 'RubyPinch'] * 2    # repeating
+['theelous3', 'RubyPinch', 'theelous3', 'RubyPinch']
+>>> 
+```
+
+With strings indexing and slicing both returned a string, but
+with lists we get a new list when we're slicing and an element
+from the list if we're indexing.
+
+```py
+>>> names[:2]    # first two names
+['wub_wub', 'theelous3']
+>>> names[0]     # the first name
+'wub_wub'
+>>> 
+```
+
+If we want to check if the program knows a name all we need to
+do is to use the `in` keyword.
+
+```py
+>>> 'lol' in names
+False
+>>> 'RubyPinch' in names
+True
+>>> 
+```
+
+We can't use this for checking if a list of names is a part of
+our name list.
+
+```py
+>>> ['RubyPinch', 'go|dfish'] in names
+False
+>>> ['RubyPinch'] in names
+False
+>>> 
+```
+
+Lists have a few [useful
+methods](https://docs.python.org/3/tutorial/datastructures.html#more-on-lists).
+Some of the most commonly used ones are append, extend and
+remove. append adds an item to the end of a list, extend adds
+multiple items from another list and remove removes an item.
+
+```py
+>>> names
+['wub_wub', 'theelous3', 'RubyPinch', 'go|dfish', 'Nitori']
+>>> names.remove('theelous3')  # sorry theelous3
+>>> names.remove('go|dfish')   # and sorry go|dfish
+>>> names
+['wub_wub', 'RubyPinch', 'Nitori']
+>>> names.append('Akuli')    # let's add me here
+>>> names
+['wub_wub', 'RubyPinch', 'Nitori', 'Akuli']
+>>> names.extend(['go|dfish', 'theelous3'])  # wb guys
+>>> names
+['wub_wub', 'RubyPinch', 'Nitori', 'Akuli', 'go|dfish', 'theelous3']
+>>> 
+```
+
+As you can see, **list can be changed in-place**. In other
+words, they are **mutable**. Integers, floats, strings and many
+other built-in types can't, so they are **immutable**.
+
+With [strings](handy-stuff-strings.md) we did something to them
+and then set the result back to the same variable, like
+`message = message.strip()`. This just doesn't work right with
+most mutable things because they're designed to be changed in-place.
+
+```py
+>>> names = names.remove('Akuli')
+>>> print(names)     # now it's None!
+None
+>>> 
+```
+
+This is the same thing that happened way back when [we assigned
+print's return value to a variable](using-functions.md).
+
+## What is what?
+
+After working with lists a while you'll find out that they
+behave like this:
+
+```py
+>>> a = [1, 2, 3]
+>>> b = a
+>>> b.append(4)
+>>> a    # this changed also!
+[1, 2, 3, 4]
+>>> 
+```
+
+This can be confusing at first, but it's actually easy to
+explain. The problem with this code example is the `b = a`
+line. If we draw a diagram of this example it looks like this:
+
+![Same list.](images/samelist.png)
+
+This is when the `is` keyword comes in. It can be used to
+check if two variables point to the **same** thing.
+
+```py
+>>> a is b
+True
+>>> 
+```
+
+Typing `[]` creates a **new** list every time.
+
+```py
+>>> [] is []
+False
+>>> 
+```
+
+If we need a new list with the same content we can use the
+`copy` method:
+
+```py
+>>> a = [1, 2, 3]
+>>> b = a.copy()
+>>> b is a
+False
+>>> b.append(4)
+>>> a
+[1, 2, 3]
+>>> 
+```
+
+If you're using Python 3.2 or older you can do `a[:]` instead
+of `a.copy()`. `a[:]` is a slice of the whole list, just like
+`a[0:]`.
+
+## Tuples
+
+Tuples are a lot like lists, but they're immutable so they
+can't be changed in-place. We create them like lists, but
+with `()` instead of `[]`.
+
+```py
+>>> thing = (1, 2, 3)
+>>> thing
+(1, 2, 3)
+>>> thing = ()
+>>> thing
+()
+>>> 
+```
+
+If we need to create a tuple that contains only one item we
+need to use `(item,)` instead of `(item)` because `(item)` is
+used in places like `(1 + 2) * 3`.
+
+```py
+>>> (3)
+3
+>>> (3,)
+(3,)
+>>> (1 + 2) * 3
+9
+>>> (1 + 2,) * 3
+(3, 3, 3)
+>>> 
+```
+
+Tuples don't have methods like append, extend and remove
+because they can't change theirselves in-place.
+
+```py
+>>> stuff = (1, 2, 3)
+>>> stuff.append(4)
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+AttributeError: 'tuple' object has no attribute 'append'
+>>> 
+```
+
+So, why the heck would we use tuples instead of lists? There's
+a few cases when we don't want mutability, but there's also
+cases when Python programmers just like to use tuples. If you
+want to know more about this you can read [Ned Batchelder's blog
+post about this](http://nedbatchelder.com/blog/201608/lists_vs_tuples.html).
+
+## Summary
+
+- Lists are a way to point to multiple values with just one variable.
+- Lists can be changed in-place and they have methods that change them
+    in-place, like append, extend and remove.
+- Slicing lists returns a **new** list, and indexing them returns an
+    item from them.
+- `thing = another_thing` does not create a copy of `another_thing`.
+- Tuples are like lists, but they can't be changed in-place. They're
+    also used in different places.
+
+## Examples
+
+Here's the same program we had in the beginning of this tutorial, but
+using a list:
+
+```py
+namelist = ['wub_wub', 'theelous3', 'RubyPinch', 'go|dfish', 'Nitori']
+
+name = input("Enter your name: ")
+if name in namelist:
+    print("I know you!")
+else:
+    print("Sorry, I don't know who you are :(")
+```