working on stuff

Akuli · Akuli · commit 811da97351bb · 2016-10-30T21:22:11.000+02:00
diff --git a/TODO.md b/TODO.md
@@ -2,35 +2,25 @@
 
 This tutorial is not complete. It still needs:
 
-- Dictionaries and tuples (can be in the same thing since tuples
-    are needed for dict keys)
-- Explain `for a, b in thing` somewhere
+- range somewhere
+- Better lists chapter, also introduce tuples in it
 - **More exercises and examples everywhere!**
-- Exceptions
 - explain bool(x) and why it matters
 - classes part 2
-    - non-public `_variables`
-    - singular inheritance, inheritance of built-in classes
+    - non-public `_variables` (maybe reading PEP-8 is enough to explain this?)
+    - "singular" inheritance, inheritance of built-in classes
     - using super
 - no classes part 3 with multiple inheritance, it's not something people need
-- quick overview of some of the most useful built-in functions and classes
-    - range
-    - zip
-    - classmethod and staticmethod
 - iterables and iterators: something most Python programmers need to be
     aware of
 - last chapter: "What should I do now?" links to other resources
     - GUI programming tutorials
         - easygui
         - tkinter in effbot (warn the readers about star imports)
-        - pyqt5 in zetcode
+        - pyqt5 in zetcode (warn about mixedCase)
         - gtk+ 3 in readthedocs
     - a pygame tutorial
     - David Beazley's metaprogramming and other talks
-    - a regex tutorial
-
-
-## Fix these
-
-- the chapter about installing python should mention that python 2 and 3
-    can be and often are installed at the same time
+    - "What the heck is this?" section for stuff i haven't talked about
+        - regexes
+        - yield
diff --git a/dicts.md b/dicts.md
@@ -0,0 +1,191 @@
+# Dictionaries
+
+**TODO:** write the lists-and-tuples.md this tutorial links to.
+
+Now we know how [lists and tuples](lists-and-tuples.md) work and how
+to [for loop](loops.md#for-loops) over them. We also did an exercise
+with code like this:
+
+```py
+userlist = [
+    ('me', 'my password'),
+    ('you', 'your password'),
+]
+```
+
+Then to check if a username and password were correct we did
+`(username, password) in userlist`. Adding new users was also easy as
+appending to that list.
+
+What if we need to check if a username is in the users, but we don't
+need to know the password? `username in userlist` is always False
+because the user list consists of (username,password) pairs, so we need
+to for loop over the whole list:
+
+```py
+username_exists = False
+for user in userlist:
+    if user[0] == username:
+        username_exists = True
+        break
+if username_exists:
+    # do something
+```
+
+Getting a user's password also requires a similar loop:
+
+```py
+password = None
+for user in userlist:
+    if user[0] == username:
+        password = user[1]
+        break
+# make sure password isn't still None and do something with it
+```
+
+This works just fine because our user list only contains two users, but
+it would be slow if the userlist was bigger.
+
+## What are dictionaries?
+
+A better way to store user information might be a dictionary.
+
+```py
+passwords = {
+    'me': 'my password',
+    'you': 'your password',
+}
+```
+
+Here `'me'` and `'you'` are **keys** in the dictionary, and
+`'my password'` and `'your password'` are their **values**. Dictionaries
+are often named by their values. This dictionary has passwords as its
+values so I named the variable `passwords`.
+
+There are a few big differences between dictionaries and lists of pairs:
+
+- Dictionaries are not ordered. There's **no guarantees** about which
+    order the username:password pairs appear in when we do something
+    with the dictionary.
+- Checking if a key is in the dictionary is simple and fast. We don't
+    need to for loop through the whole dictionary.
+- Getting the value of a key is also simple and fast.
+- We can't have the same key in the dictionary multiple times, but
+    multiple different keys can have the same value. This means that
+    **multiple users can't have the same name, but they can have the
+    same passwords**.
+
+But wait... this is a lot like variables are! Our variables are not
+ordered, getting a value of a variable is fast and easy and we can't
+have multiple variables with the same name.
+
+Variables are actually stored in a dictionary. We can get that
+dictionary with the globals function. In this dictionary, keys are
+variable names and values are what our variables point to.
+
+```py
+>>> globals()
+{'userlist': [('me', 'my password'), ('you', 'your password')],
+ 'passwords': {'me': 'my password', 'you': 'your password'},
+ ...many other things we don't need to care about...
+}
+>>> 
+```
+
+So if you have trouble remembering how dictionaries work just compare
+them to variables.
+
+## What can we do with dictionaries?
+
+Dictionaries have some similarities with lists. For example, both
+lists and dictionaries have a length.
+
+```py
+>>> len(userlist)     # contains two elements
+2
+>>> len(passwords)    # contains two key:value pairs
+2
+>>> 
+```
+
+We can get a value of a key with `the_dict[key]`. Trying to get the
+value of a non-existing key gives us an error. We can also add new
+key:value pairs by doing `the_dict[key] = value`.
+
+```py
+>>> passwords['me']
+'my password'
+>>> passwords['you']
+'your password'
+>>> passwords['lol']
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+KeyError: 'lol'
+>>> passwords["lol"] = "lol's password"
+>>> passwords
+{'lol': "lol's password", 'you': 'your password', 'me': 'my password'}
+>>> 
+```
+
+For looping over a dictionary gets its keys, and checking if something's
+in the dictionary checks if the dictionary has a key like that. This can
+be confusing at first but you'll get used to this.
+
+```py
+>>> 'me' in passwords
+True
+>>> 'my password' in passwords
+False
+>>> for name in passwords:
+...     print(name)
+... 
+lol
+you
+me
+>>> 
+```
+
+Dictionaries have a values method that we can use if we want to do
+something with the values:
+
+```py
+>>> passwords.values()
+dict_values(["lol's password", 'your password', 'my password'])
+>>> 
+```
+
+The values method returned a `dict_values` object. Things like this
+behave a lot like lists and usually we don't need to convert them to
+lists.
+
+```py
+>>> for password in passwords.values():
+...     print(password)
+... 
+lol's password
+your password
+my password
+>>> 
+```
+
+We can do things like `list(passwords.values())` if we need a real list
+for some reason, but doing that can slow down our program if the
+dictionary is big. There's also a keys method, but usually we don't need
+it because the dictionary itself behaves a lot like a list of keys.
+
+If we need both keys and values we can use the items method with the
+`for first, second in thing` trick.
+
+```py
+>>> passwords.items()
+dict_items([('lol', "lol's password"),
+            ('you', 'your password'),
+            ('me', 'my password')])
+>>> for name, password in passwords.items():
+...     print(name + ": " + password)
+... 
+lol: lol's password
+you: your password
+me: my password
+>>> 
+```
diff --git a/loops.md b/loops.md
@@ -3,9 +3,9 @@
 In programming, a **loop** means repeating something multiple times.
 There are different kinds of loops:
 
-- **While loops** repeat something while a condition is true.
-- **Until loops** repeat something until a condition is true.
-- **For loops** repeat something for each element of a sequence.
+- [While loops](#while-loops) repeat something while a condition is true.
+- [Until loops](#until-loops) repeat something while a condition is false.
+- [For loops](#for-loops) repeat something for each element of a list.
 
 We'll talk about all of these in this tutorial.
 
@@ -230,11 +230,22 @@ how about you
 Note that `for thing in stuff:` is not same as `for (thing in stuff):`.
 Here the `in` keyword is just a part of the for loop and it has a
 different meaning than it would have if we had `thing in stuff` without
-a `for`.
+a `for`. Trying to do `for (thing in stuff):` creates an error:
+
+```py
+>>> for (thing in stuff):
+  File "<stdin>", line 1
+    for (thing in stuff):
+                        ^
+SyntaxError: invalid syntax
+>>> 
+```
 
 Right now the while loop version might seem easier to understand for
 you, but later you'll realize that for loops are much easier to work
 with than while loops and index variables, especially in large projects.
+For looping is also a little bit faster than while looping with an index
+variable.
 
 There's only one big limitation with for looping over lists. We
 shouldn't modify the list in the for loop. If we do, the results can
diff --git a/modules.md b/modules.md
@@ -217,7 +217,7 @@ that are built into Python. The official documentation is
 >>> # stdin is short for standard input
 >>> # stdout is short for standard output
 >>> # stderr is short for standard errors
->>> print("Hello!", file=sys.stdout)
+>>> print("Hello!", file=sys.stdout)  # this is where prints go by default
 Hello!
 >>> print("Hello!", file=sys.stderr)  # use this for error messages
 Hello!
diff --git a/trey-hunner-zip-and-enumerate.md b/trey-hunner-zip-and-enumerate.md
@@ -18,7 +18,7 @@ assigning values to multiple variables at once. It works like this:
 
 We can use `()` and `[]` around these values however we want and
 everything will still work the same way. `[]` creates a list, and
-`()` creates a tuple. We'll talk more about tuples later.
+`()` creates a tuple.
 
 ```py
 >>> [a, b] = (1, 2)
@@ -41,7 +41,7 @@ side.
 >>> 
 ```
 
-What actually happened is that Python created a tuple automatically.
+Python created a tuple automatically.
 
 ```py
 >>> 1, 2
@@ -76,67 +76,9 @@ c 3
 >>> 
 ```
 
-Now you're ready to read [this looping
+Now you're ready to read [this awesome looping
 tutorial](http://treyhunner.com/2016/04/how-to-loop-with-indexes-in-python/).
-Read it now, then read the summary and do the exercises.
-
-## Summary
-
-Assigning multiple values at once:
-
-```py
->>> a, b, c = 1, 2, 3
->>> a
-1
->>> b
-2
->>> c
-3
->>> 
-```
-
-For looping over a list of pairs:
-
-```py
->>> stuff = [('a', 1), ('b', 2), ('c', 3)]
->>> for a, b in stuff:
-...     print(a, b)
-... 
-a 1
-b 2
-c 3
->>> 
-```
-
-For looping over two lists at once:
-
-```py
->>> colors = ['red', 'green', 'blue']
->>> letters = ['R', 'G', 'B']
->>> for letter, color in zip(letters, colors):
-...     print(letter, color)
-... 
-R red
-G green
-B blue
->>> 
-```
-
-For looping over a list with indexes:
-
-```py
->>> fillernames = ['foo', 'bar', 'biz', 'baz', 'spam', 'eggs']
->>> for index, name in enumerate(fillernames):
-...     print(index, name)
-... 
-0 foo
-1 bar
-2 biz
-3 baz
-4 spam
-5 eggs
->>> 
-```
+Read it now, then come back here and do the exercises.
 
 ## Exercises
 
diff --git a/what-next.md b/what-next.md
