Lisa Cee

README.md

@@ -1,6 +1,4 @@
-# Intro to Python
-
-## Goals
+# Intro to Python I
 
 It's time to learn a new language! Python!
 
@@ -57,254 +55,59 @@ best for learning new languages.
 
    You can exit the virtual environment by typing `exit`.
 
-## Day 1
-
-### Goals
+## Goals
 
 * Learn the basic syntax and structure of Python
 
-### Summary
-
-* Implement a number of tiny Python programs that demonstrate Python syntax.
+## Summary
 
-### Instructions
+* Implement a number of tiny Python programs that demonstrate Python syntax and
+  language concepts.
 
-Take a look in the `src/` directory.
+## Instructions
 
-NOTE: `adv/` is for Day 2, so ignore it for today.
+Each directory inside the `src/` directory presents exercises revolving around a
+particular concept in Python. Not all of these concepts are unique to Python (in
+fact, most probably aren't). This means that you can leverage knowledge you've
+obtained via exposure to other programming languages towards learning Python. 
 
-Suggested order for implementing the toy programs:
+The suggested order for going through each of the directories is: 
 
 * `hello` -- Hello world
 * `bignum` -- Print some big numbers
 * `datatypes` -- Experiment with type conversion
 * `modules` -- Learn to import from modules
-* `printf` -- Formatted print output
+* `printing` -- Formatted print output
 * `lists` -- Python's version of arrays
 * `tuples` -- Immutable lists typically for heterogenous data
-* `slice` -- Accessing parts of lists
-* `comp` -- List comprehensions
-* `dicts` -- Dictionaries
-* `func` -- Functions
+* `slices` -- Accessing parts of lists
+* `comprehensions` -- List comprehensions
+* `dictionaries` -- Dictionaries
+* `functions` -- Functions
 * `args` -- Arguments and Keyword Arguments
-* `scope` -- Global, Local, and Non-Local scope
-* `fileio` -- Read and write from files
-* `cal` -- Experiment with module imports
-* `obj` -- Classes and objects
-
-## Day 2
-
-### Goals
-
-* Solidify the Python basics
-
-
-### Summary
-
-* Implement a basic text adventure game
-* Add classes for rooms and the player
-* Add a simple parser that reads user input and performs actions
-
-### Instructions
-
-This is in `src/adv/`. Check it out!
-
-* Put the Room class in room.py based on what you see in `adv.py`.
-
-* Put the Player class in `player.py`.
-
-* Follow the instructions `adv.py`.
-
-* Figure out what all those `.pyc` files are that appear after you successfully
-  run the program.
-
-## Day 3
-
-### Goals
-
-* Prepare for more OOP techniques
-* Practice classes and lists
-
-### Summary
-
-* Add items to the game that the user can carry around
-* Make rooms able to hold multiple items
-* Make the player able to carry multiple items
-* Add two-word commands to the parser
-* Add the `get` and `drop` commands to the parser
-
-### Instructions
-
-* Add an `Item` class in a file `item.py`.
-
-  * This will be the _base class_ for specialized item types to be declared
-    later.
-
-  * The item should have `name` and `description` attributes.
-
-     * Hint: the name should be one word for ease in parsing later.
-
-* Add capability to add items to rooms.
-
-  * The `Room` class should be extended with a `list` that holds the `Item`s
-    that are currently in that room.
-
-  * Add functionality to the main loop that prints out all the items that are
-    visible to the player when they are in that room.
-
-* Add capability to add `Item`s to the player's inventory. The inventory can
-  also be a `list` of items "in" the player, similar to how `Item`s can be in a
-  `Room`.
-
-* Add a new type of sentence the parser can understand: two words.
-
-  * Until now, the parser could just understand one sentence form:
-
-     `verb`
-
-    such as "n" or "q".
-
-  * But now we want to add the form:
-
-    `verb` `object`
-
-    such as "take coins" or "drop sword".
-
-  * Split the entered command and see if it has 1 or 2 words in it to determine
-    if it's the first or second form.
-
-* Implement support for the verb `get` followed by an `Item` name. This will be
-  used to pick up `Item`s.
-
-  * If the user enters `get` or `take` followed by an `Item` name, look at the
-    contents of the current `Room` to see if the item is there.
-
-     * If it is there, remove it from the `Room` contents, and add it to the
-       `Player` contents.
-
-     * If it's not there, print an error message telling the user so.
-
-* Implement support for the verb `drop` followed by an `Item` name. This is the
-  opposite of `get`/`take`.
-
-* Add the `i` and `inventory` commands that both show a list of items currently
-  carried by the player.
-
-## Day 4
-
-### Goals
-
-* Practice inheritance
-* Practice method overriding
-* Be able to call superclass methods
-* Implement a callback/event structure
-
-### Summary
-
-* Add scoring
-* Subclass items into treasures
-* Subclass items into light sources
-* Add methods to notify items when they are picked up or dropped
-* Add light and darkness to the game
-
-### Instructions
-
-* Add a `score` to your `Player` class. Set it to 0.
-
-* Add a single word command, `score`, that the user can type in to see their
-  current score.
-
-* Add a subclass to `Item` called `Treasure`.
-
-  * The `Treasure` constructor should accept a name, description, and value.
-
-* During world creation, add three `Treasure`s to convenient `Room`s.
-
-* Add an `on_take` method to `Item`. 
-
-  * Call this method when the `Item` is picked up by the player.
-
-  * The `Item` can use this to run additional code when it is picked up.
-
-* Override `on_take` in `Treasure` so that the player gets the value of the
-  `Treasure` added to their `score` attribute _but only the first time the
-  treasure is picked up_.
-
-  * If the treasure is dropped and picked up again later, the player should
-    _not_ have the value added to their score again.
-
-* Add an `on_drop` method to `Item`. Implement it similar to `on_take`.
-
-* Add a subclass to `Item` called `LightSource`.
-
-* During world creation, add a `lamp` `LightSource` to a convenient `Room`.
-
-* Override `on_drop` in `LightSource` that tells the player "It's not wise to
-  drop your source of light!" if the player drops it. (But still lets them drop
-  it.)
-
-* Add an attribute to `Room` called `is_light` that is `True` if the `Room` is
-  naturally illuminated, or `False` if a `LightSource` is required to see what
-  is in the room.
-
-* Modify the main loop to test if there is light in the `Room` (i.e. if
-  `is_light` is `True` **or** there is a `LightSource` item in the `Room`'s
-  contents **or** if there is a `LightSource` item in the `Player`'s contents).
-
-  * If there is light in the room, display name, description, and contents as
-    normal.
-
-  * If there isn't, print out "It's pitch black!" instead.
-
-  * Hint: `isinstance` might help you figure out if there's a `LightSource`
-    among all the nearby `Item`s.
-
-* Modify the `get`/`take` code to print "Good luck finding that in the dark!" if
-  the user tries to pick up an `Item` in the dark.
+* `scopes` -- Global, Local, and Non-Local scope
+* `file_io` -- Read and write from files
+* `cal` -- Experiment with module imports and implement a text-based calendar
+* `classes` -- Classes and objects
 
 ## Stretch Goals
 
-In arbitrary order:
-
-* Add more rooms.
-
-* Add more items to the game.
-
-* Add a way to win.
-
-* Add more to the parser.
-
-  * Remember the last `Item` mentioned and substitute that if the user types
-    "it" later, e.g.
-
-    ```
-    take sword
-    drop it
-    ```
-
-  * Add `Item`s with adjectives, like "rusty sword" and "silver sword".
-
-    * Modify the parser to handle commands like "take rusty sword" as well as
-      "take sword".
-
-      * If the user is in a room that contains both the rusty sword _and_ silver
-        sword, and they type "take sword", the parser should say, "I don't know
-        which you mean: rusty sword or silver sword."
-
-* Modify the code that calls `on_take` to check the return value. If `on_take`
-  returns `False`, then don't continue picking up the object. (I.e. prevent the
-  user from picking it up.)
-
-  * This enables you to add logic to `on_take` to code things like "don't allow
-    the user to pick up the dirt unless they're holding the shovel.
-
-* Add monsters.
-
-* Add the `attack` verb that allows you to specify a monster to attack.
-
-* Add an `on_attack` method to the monster class.
-
-* Similar to the `on_take` return value modification, above, have `on_attack`
-  prevent the attack from succeeding unless the user possesses a `sword` item.
-
-* Come up with more stretch goals! The sky's the limit!
+1. One of Python's main philosophical tenets is its emphasis on readability. To
+   that end, the Python community has standardized around a style guide called
+   [PEP 8](https://www.python.org/dev/peps/pep-0008/). Take a look at it and
+   then go over the code you've written and make sure it adheres to what PEP 8
+   recommends. Alternatively, PEP 8 linters exist for most code editors (you can
+   find instructions on installing a Python linter for VSCode
+   [here](https://code.visualstudio.com/docs/python/linting)). Try installing
+   one for your editor!
+
+2. Rewrite code challenges you've solved before or projects you've implemented
+   before in a different language in Python. Start getting in as much practice
+   with the language as possible!
+
+3. Write a program to determine if a number, given on the command line, is prime.
+
+   1. How can you optimize this program?
+   2. Implement [The Sieve of
+      Eratosthenes](https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes), one
+      of the oldest algorithms known (ca. 200 BC).

src/00_hello.py

@@ -0,0 +1,2 @@
+# Print "Hello, world!" to your terminal
+print('Hello, world!')

src/01_bignum.py

@@ -0,0 +1,5 @@
+# Print out 2 to the 65536 power
+# (try doing the same thing in the JS console and see what it outputs)
+
+# YOUR CODE HERE
+print(pow(2, 65536))

src/02_datatypes.py

@@ -0,0 +1,22 @@
+"""
+Python is a strongly-typed language under the hood, which means 
+that the types of values matter, especially when we're trying
+to perform operations on them. 
+
+Note that if you try running the following code without making any
+changes, you'll get a TypeError saying you can't perform an operation
+on a string and an integer.
+"""
+
+x = 5
+y = "7"
+
+# Write a print statement that combines x + y into the integer value 12
+
+# YOUR CODE HERE
+print(x + int(y))
+
+# Write a print statement that combines x + y into the string value 57
+
+# YOUR CODE HERE
+print(str(x) + y)

src/03_modules.py

@@ -0,0 +1,32 @@
+"""
+In this exercise, you'll be playing around with the sys module,
+which allows you to access many system specific variables and
+methods, and the os module, which gives you access to lower-
+level operating system functionality.
+"""
+
+import os
+import sys
+# See docs for the sys module: https://docs.python.org/3.7/library/sys.html
+
+# Print out the command line arguments in sys.argv, one per line:
+# YOUR CODE HERE
+print(sys.argv)
+# Print out the OS platform you're using:
+# YOUR CODE HERE
+print(sys.platform)
+# Print out the version of Python you're using:
+# YOUR CODE HERE
+print(sys.version)
+
+# See the docs for the OS module: https://docs.python.org/3.7/library/os.html
+
+# Print the current process ID
+# YOUR CODE HERE
+print(os.getpid())
+# Print the current working directory (cwd):
+# YOUR CODE HERE
+print(os.getcwd())
+# Print out your machine's login name
+# YOUR CODE HERE
+print(os.getlogin())

src/04_printing.py

@@ -0,0 +1,18 @@
+"""
+Python provides a number of ways to perform printing. Research
+how to print using the printf operator, the `format` string 
+method, and by using f-strings.
+"""
+
+x = 10
+y = 2.24552
+z = "I like turtles!"
+
+# Using the printf operator (%), print the following feeding in the values of x,
+# y, and z:
+# x is 10, y is 2.25, z is "I like turtles!"
+print("x is %d, y is %.2f, z is \"%s\"" % (x, y, z))
+# Use the 'format' string method to print the same thing
+print("x is {}, y is {:.2f}, z is \"{}\"".format(x, y, z))
+# Finally, print the same thing using an f-string
+print(f'x is {x}, y is {round(y, 2)}, z is "{z}"')