Add lessons and challenges for Functions chapter

Author: bgroveben

challenges/8.1.Built_In_Functions/lesson.md

@@ -0,0 +1,23 @@
+## Built-in Functions  
+
+The Python interpreter has a number of functions and types built into it that are always available.  
+They are listed [here](https://docs.python.org/3/library/functions.html) in alphabetical order.  
+Python 3's builtins module provides direct access to all of the built-in functions.  
+You don't need to import any modules when using a built-in function, just call the function with the appropriate arguments.   
+- https://docs.python.org/3/library/functions.html#built-in-functions
+- https://docs.python.org/3/library/builtins.html#module-builtins
+- https://github.com/python/cpython/blob/3.6/Python/bltinmodule.c
+```
+>>> print("print() is a built-in function in Python 3")
+print() is a built-in function in Python 3
+>>> type([1,2,3,4,5])
+<class 'list'>
+>>> sum([1,2,3,4,5])
+15
+>>> id(sum([1,2,3,4,5]))
+4412662784
+```
+**_Instructions:_**  
+**In the console you will find a list of numbers.**  
+**There is a built-in function that will return a new sorted list from the items in numbers.**  
+**Find this function, call it using the variable named numbers as the argument, and assign this function call to the variable named result.**

challenges/8.1.Built_In_Functions/lesson_settings.json

@@ -0,0 +1,7 @@
+{
+  "lesson_title": "Built In Functions",
+  "chapter_number": 8,
+  "lesson_number": 1,
+  "id": "",
+  "repl": ""
+}

challenges/8.1.Built_In_Functions/lesson_tests.py

@@ -0,0 +1,10 @@
+import unittest
+from main import *
+
+class BuiltInFunctionsTests(unittest.TestCase):
+    def test_main(self):
+        self.assertIsInstance(result, list)
+        self.assertNotIsInstance(result, str)
+        self.assertEqual(result, [1, 2, 3, 4, 5, 6, 7, 8])
+        self.assertNotEqual(result, [6, 3, 1, 8, 5, 2, 4, 7])
+        self.assertNotEqual(result, numbers)

challenges/8.1.Built_In_Functions/main.py

@@ -0,0 +1,8 @@
+numbers = [6, 3, 1, 8, 5, 2, 4, 7]
+
+### Assign the correct built-in function to the variable named result below: ###
+
+result = "Replace this string with the correct answer"
+
+### Write your code above this line
+print(result)

challenges/8.2.User_Defined_Functions/lesson.md

@@ -0,0 +1,25 @@
+## User Defined Functions
+
+The keyword `def` introduces a function definition.  
+It must be followed by the function name and a parenthesized list of formal parameters (if any).  
+The statements that form the body of the function start at the next line, and must be indented.  
+After a function has been defined, it can be called by typing the function name immediately followed by parentheses that contain the function's arguments (if any).
+- https://docs.python.org/3/glossary.html#term-function
+- https://docs.python.org/3/glossary.html#term-parameter
+- https://docs.python.org/3/glossary.html#term-argument
+- https://docs.python.org/3/tutorial/controlflow.html#defining-functions  
+- https://docs.python.org/3/reference/compound_stmts.html#def
+- https://docs.python.org/3/reference/expressions.html#calls
+- https://www.python.org/dev/peps/pep-0008/#function-names  
+```
+>>> def the_truth():
+...     return True
+...
+>>> the_truth()
+True
+```
+
+**_Instructions:_**  
+**Define a function named say_hello() that has no parameters and prints the string "Hello World!" to the console.**  
+**Your function should not contain a return statement, only a print statement.**  
+**After you have defined the function, call it.**

challenges/8.2.User_Defined_Functions/lesson_settings.json

@@ -0,0 +1,7 @@
+{
+  "lesson_title": "User Defined Functions",
+  "chapter_number": 8,
+  "lesson_number": 2,
+  "id": "",
+  "repl": ""
+}

challenges/8.2.User_Defined_Functions/lesson_tests.py

@@ -0,0 +1,28 @@
+import unittest
+import sys
+from io import StringIO
+from main import *
+
+class UserDefinedFunctionsTests(unittest.TestCase):
+    def test_main(self):
+        # Make sure there is no return statement.
+        self.assertIsNone(say_hello())
+
+    def test_function_name(self):
+        # Make sure that the function has the correct name.
+        f = open('main.py')
+        lines = str(f.readlines())
+        f.close()
+        self.assertRegex(lines, 'say_hello()', msg="The name of the function is incorrect.")
+
+    def test_output(self):
+        # Make sure that calling say_hello() outputs the correct string.
+        saved_stdout = sys.stdout
+        try:
+            out = StringIO()
+            sys.stdout = out
+            say_hello()
+            output = out.getvalue().strip()
+            assert output == "Hello World!"
+        finally:
+            sys.stdout = saved_stdout

challenges/8.2.User_Defined_Functions/main.py

@@ -0,0 +1,6 @@
+### Define the say_hello() function and fill in the function body below this line: ###
+
+
+
+### Call the say_hello() function below this line: ###
+say_hello()

challenges/8.3.Function_Documentation_Strings/lesson.md

@@ -0,0 +1,31 @@
+## Function Documentation Strings
+
+Function documentation strings (docstrings) offer a way to provide additional information about a function and its properties.  
+A docstring is a string literal that occurs as the first statement in a module, function, class, or method definition.  
+Such a docstring becomes the \_\_doc\_\_ special attribute of that object.  
+The docstring for a function or method should summarize its behavior and document its arguments, return value(s), side effects, exceptions raised, and restrictions on when it can be called (all if applicable).  
+Optional arguments should be indicated.   
+There are two forms of docstrings: one-liners and multi-line docstrings.    
+For consistency, always use """triple double quotes""" around docstrings.
+
+- https://docs.python.org/3/tutorial/controlflow.html#documentation-strings
+- https://www.python.org/dev/peps/pep-0257/
+```
+>>> def some_function():
+...     """
+...     This function does nothing, but it's documented.
+...     
+...     Multiline docstrings are for more detailed descriptions.
+...     """
+...     pass
+...
+>>> print(some_function.__doc__)
+
+	This function does nothing, but it's documented.
+
+	Multiline docstrings are for more detailed descriptions.
+```
+
+**_Instructions:_**  
+**In the console you will find a function named docstring\_function().**  
+**In the space between the function definition and the `pass` keyword, write any string you like using the docstring triple-double quotes convention.**    

challenges/8.3.Function_Documentation_Strings/lesson_settings.json

@@ -0,0 +1,7 @@
+{
+  "lesson_title": "Function Documentation Strings",
+  "chapter_number": 8,
+  "lesson_number": 3,
+  "id": "",
+  "repl": ""
+}

challenges/8.3.Function_Documentation_Strings/lesson_tests.py

@@ -0,0 +1,8 @@
+import unittest
+from main import *
+
+class FunctionDocumentationStringsTests(unittest.TestCase):
+    def test_main(self):
+        self.assertIsNone(docstring_function())
+        self.assertIsNotNone(docstring_function.__doc__)
+        self.assertIsInstance(docstring_function.__doc__, str)

challenges/8.3.Function_Documentation_Strings/main.py

@@ -0,0 +1,9 @@
+def docstring_function():
+    ### Write your docstring below this line. ###
+
+
+
+    ### Write your docstring above this line. ###
+    pass
+
+print(docstring_function.__doc__)

challenges/8.4.Arguments_Vs_Parameters/lesson.md

@@ -0,0 +1,25 @@
+## Arguments vs Parameters
+
+When dealing with functions, the terms argument and parameter are sometimes used interchangeably, but they do NOT mean the same thing.  
+The difference between arguments and parameters can cause some confusion, especially for novice programmers.  
+Parameters are defined by the names that appear in a function definition and define what types of arguments a function can accept.  
+Arguments are the values actually passed to a function when calling it.  
+When you DEFINE a function after the `def` keyword, the parameters are named inside the parentheses that follow.
+When you CALL a function, the arguments are assigned inside the parentheses that follow.  
+- https://docs.python.org/3/faq/programming.html#what-is-the-difference-between-arguments-and-parameters
+- https://docs.python.org/3/glossary.html#term-argument
+- https://docs.python.org/3/glossary.html#term-parameter
+```
+# The parameters are inside the parentheses in the function definition.
+>>> def some_function(foo, bar=None):
+...     return foo, bar
+...
+# The arguments are inside the parentheses in the function call.
+>>> some_function(42, bar='baz')
+(42, 'baz')
+```
+**_Instructions:_**  
+**In the console, above the variable named result, define a function named my_function that has a single parameter named parameter.**  
+**In the function body, tell the function to return parameter.**  
+**After the equal sign for the variable named result, call my_function() and set the argument as the string 'argument'.**  
+**When finished, you will have assigned the result of the my_function() call to the variable named result.**

challenges/8.4.Arguments_Vs_Parameters/lesson_settings.json

@@ -0,0 +1,7 @@
+{
+  "lesson_title": "Arguments vs Parameters",
+  "chapter_number": 8,
+  "lesson_number": 4,
+  "id": "",
+  "repl": ""
+}

challenges/8.4.Arguments_Vs_Parameters/lesson_tests.py

@@ -0,0 +1,17 @@
+import unittest
+from main import *
+
+class ArgumentsVsParametersTests(unittest.TestCase):
+    def test_output(self):
+        self.assertIsNotNone(result)
+        self.assertIsInstance(result, str)
+        self.assertEqual(result, 'argument')
+
+    def test_names_for_function_parameter_and_argument(self):
+        f = open('main.py')
+        lines = str(f.readlines())
+        f.close()
+        # The following tests only ensure that the named strings exist somewhere in the file, not that they are where they should be or have the correct values assigned.
+        self.assertRegex(lines, 'my_function()', msg="The name of the function is incorrect.")
+        self.assertRegex(lines, 'parameter', msg="The parameter must have the correct name.")
+        self.assertRegex(lines, 'argument', msg="The argument must have the correct name.")

challenges/8.4.Arguments_Vs_Parameters/main.py

@@ -0,0 +1,9 @@
+### Define your function with the appropriate parameter below this line: ###
+
+
+
+### Assign the function call with the appropriate argument to the variable named result below this line: ###
+
+result = "Replace this string with the correct answer"
+
+print(result)

challenges/8.5.Default_Arguments/lesson.md

@@ -0,0 +1,22 @@
+## Default Arguments  
+
+When a function is defined in Python, you can specify formal parameters inside of the trailing parentheses.  
+If any of those parameters are declared using the "argument=value" format, then you don't necessarily have to specify a value for those arguments when the function is called.  
+If a value is not specified, then that parameter uses the default argument value when the function executes.  
+A default value can be specified for any or all of the arguments, which creates a function that can be called with fewer arguments than it is defined to allow.
+- https://docs.python.org/3.6/tutorial/controlflow.html#default-argument-values  
+```
+>>> def greeting(number=1, message='Hello'):
+...     print(number, message)
+...
+>>> greeting()
+1 Hello
+>>> greeting(2, message='Ahoy There!')
+2 Ahoy There!
+>>> greeting(number='Three')
+Three Hello
+```
+**_Instructions:_**  
+**In the console there is a function named favorite_python() with a single parameter named member that has a default argument of None.**  
+**Call the function and change the default argument to a string containing the name of your favorite Monty Python member.**  
+**Assign that function call to the variable named my_choice.**

challenges/8.5.Default_Arguments/lesson_settings.json

@@ -0,0 +1,7 @@
+{
+  "lesson_title": "Default Arguments",
+  "chapter_number": 8,
+  "lesson_number": 5,
+  "id": "",
+  "repl": ""
+}

challenges/8.5.Default_Arguments/lesson_tests.py

@@ -0,0 +1,9 @@
+import unittest
+from main import *
+
+class DefaultArgumentsTests(unittest.TestCase):
+    def test_main(self):
+        self.assertIsNotNone(my_choice)
+        self.assertTrue(my_choice)
+        self.assertIsInstance(my_choice, str)
+        self.assertNotEqual(my_choice, "Replace this string with the correct function call.")

challenges/8.5.Default_Arguments/main.py

@@ -0,0 +1,11 @@
+def favorite_python(member=None):
+    print(member)
+    return member
+
+### Call the favorite_python() function with the default argument changed to
+### the name of your favorite Monty Python member, and assign that function
+### call to the variable named my_choice.
+
+my_choice = "Replace this string with the correct function call."
+
+### Call the function above this line.

challenges/8.6.Calling_Functions/lesson.md

@@ -0,0 +1,25 @@
+## Calling Functions
+
+Once a function has been defined, it must be called in order to be executed.  
+A function is a callable object that can execute when its `__call__()` method is invoked.  
+A function can be called by appending the arguments in parentheses to the function name.  
+If a function has no parameters, or if the parameters have default arguments that you do not want to change, then you can invoke the call method by appending empty parentheses to the function name.  
+- https://docs.python.org/3/reference/datamodel.html#object.\_\_call\_\_
+- https://docs.python.org/3.6/tutorial/controlflow.html#defining-functions
+- https://docs.python.org/3/library/functions.html#callable
+```
+# Define the function:
+>>> def call_something(something=None):
+...     return something
+...
+# Call the function with the parameter's default argument of None:
+>>> call_something()  
+# Nothing is returned.
+# Now call the function with an argument that changes the default:
+>>> call_something(something="Here's something")
+"Here's something"
+```
+**_Instructions:_**  
+**In the console, there is a function named say_hello() that returns a greeting.**  
+**Call the function and put any string you want as the greeting argument inside of the parentheses.**  
+**Assign the function call to the variable named result in the console.**

challenges/8.6.Calling_Functions/lesson_settings.json

@@ -0,0 +1,7 @@
+{
+  "lesson_title": "Calling Functions",
+  "chapter_number": 8,
+  "lesson_number": 6,
+  "id": "",
+  "repl": ""
+}

challenges/8.6.Calling_Functions/lesson_tests.py

@@ -0,0 +1,8 @@
+import unittest
+from main import *
+
+class CallingFunctionsTests(unittest.TestCase):
+    def test_output(self):
+        self.assertIsNotNone(result)
+        self.assertIsInstance(result, str)
+        self.assertNotEqual(result, "Replace this string with the correct function call.")

challenges/8.6.Calling_Functions/main.py

@@ -0,0 +1,9 @@
+def say_hello(greeting):
+    return greeting
+
+### Call the say_hello function below this line: ###
+
+result = "Replace this string with the correct function call."
+
+### Call the say_hello function above this line: ###
+print(result)

challenges/8.7.Keyword_Arguments/lesson.md

@@ -0,0 +1,40 @@
+## Keyword and Variable Keyword Arguments  
+
+A keyword argument can be an argument preceded by an identifier in a function call using the form `kwarg=value`.  
+Variable keyword arguments can be passed as values in a dictionary preceded by `**`, like this:    
+`def example(default_arguments, *args, **kwargs):`  
+In a function call, keyword arguments must follow positional arguments, and all keyword arguments passed must match one of the arguments accepted by the function.  
+[Here is a detailed explanation](https://docs.python.org/3/reference/expressions.html#calls) of how keyword arguments are dealt with when the function is called.  
+- https://docs.python.org/3.6/tutorial/controlflow.html#keyword-arguments
+- https://docs.python.org/3.6/glossary.html#term-argument
+- https://docs.python.org/3/reference/expressions.html#grammar-token-keywords_arguments
+- https://docs.python.org/3/glossary.html#term-parameter  
+- https://www.python.org/dev/peps/pep-0362/
+- https://www.python.org/dev/peps/pep-0448/
+- https://docs.python.org/3/reference/expressions.html#calls
+- https://docs.python.org/3/reference/compound_stmts.html#function-definitions
+```
+>>> # 3 and 5 are both keyword arguments in the following calls to complex()
+...
+>>> complex(real=3, imag=5)
+(3+5j)
+>>> complex(**{'real': 3, 'imag': 5})
+(3+5j)
+```
+```
+>>> # arg1 and arg2 are keyword arguments, **kwargs is for variable keyword arguments
+...
+>>> >>> def some_dr_seuss(arg1='arg1', arg2='arg2', **kwargs):
+...     return arg1, arg2, kwargs
+...
+>>> print(some_dr_seuss(**{'arg3': 'arg_red', 'arg4': 'arg_blue'}))
+('arg1', 'arg2', {'arg3': 'arg_red', 'arg4': 'arg_blue'})
+```
+**_Instructions:_**  
+**In the console there is a function named keyword_argument_example() that takes a default argument an an unspecified number of keyword arguments.**  
+**When you call the function:**  
+- **Enter an integer, your age, as the value for the default argument named your_age.**
+- **Create two keyword arguments named first and last.**
+- **Assign a string with your first name to first, and your last name to last.**  
+
+**Assign your function call to the variable named about_me.**

challenges/8.7.Keyword_Arguments/lesson_settings.json

@@ -0,0 +1,7 @@
+{
+  "lesson_title": "Keyword Arguments",
+  "chapter_number": 8,
+  "lesson_number": 7,
+  "id": "",
+  "repl": ""
+}

challenges/8.7.Keyword_Arguments/lesson_tests.py

@@ -0,0 +1,17 @@
+import unittest
+from main import *
+
+class KeywordArgumentsTests(unittest.TestCase):
+    def test_main(self):
+        self.assertIsNotNone(about_me)
+        self.assertTrue(about_me)
+        self.assertNotEqual(about_me, "Replace this string with the correct function call.")
+
+    def test_about_me_variable_has_correct_types(self):
+        self.assertIsInstance(about_me, tuple)
+        self.assertIsInstance(about_me[0], int)
+        self.assertIsInstance(about_me[1], dict)
+
+    def test_correct_keyword_arguments(self):
+        self.assertIn("first", about_me[1].keys())
+        self.assertIn("last", about_me[1].keys())

challenges/8.7.Keyword_Arguments/main.py

@@ -0,0 +1,10 @@
+def keyword_argument_example(your_age, **kwargs):
+    return your_age, kwargs
+
+### Write your code below this line ###
+
+about_me = "Replace this string with the correct function call."
+
+### Write your code above this line ###
+
+print(about_me)

challenges/8.8.Positional_Arguments/lesson.md

@@ -0,0 +1,40 @@
+## Positional and Variable Positional Arguments  
+
+A positional argument is, simply put, any argument that is not a keyword argument.  
+Positional refers to the fact that the relative position, or order, of the arguments is significant when they are stored in their corresponding tuple.  
+Positional arguments can be used to form [arbitrary argument lists](https://docs.python.org/3.6/tutorial/controlflow.html#arbitrary-argument-lists).  
+Functions can accept a variable number of (optional) positional arguments by using the `*args` syntax in the def statement, like this:    
+`def example(default_arguments, *args, **kwargs):`    
+The `*` operator instructs Python to pass argument inputs to a tuple that receives any excess positional parameters, defaulting to the empty tuple.      
+When a function is defined and the parameters are declared, variable positional arguments must follow normal/default arguments (if any) and precede any variable keyword arguments (if any).  
+- https://docs.python.org/3.6/tutorial/controlflow.html#arbitrary-argument-lists
+- https://docs.python.org/3/glossary.html#term-argument
+- https://docs.python.org/3/reference/expressions.html#grammar-token-positional_arguments
+- https://www.python.org/dev/peps/pep-0362/
+- https://www.python.org/dev/peps/pep-0448/
+- https://docs.python.org/3/reference/expressions.html#calls
+- https://docs.python.org/3/reference/compound_stmts.html#function-definitions
+```
+>>> # 3 and 5 are both positional arguments in the following calls to complex()
+...
+>>> complex(3, 5)
+(3+5j)
+>>> complex(*(3, 5))
+(3+5j)
+```
+```
+>>> # arg1 and arg2 are positional arguments, *args is for variable positional arguments
+...
+>>> def some_dr_seuss(arg1, arg2, *args):
+...     return arg1, arg2, args
+...
+>>> print(some_dr_seuss('arg1', 'arg2', 'arg_red', 'arg_blue'))
+('arg1', 'arg2', ('arg_red', 'arg_blue'))
+```
+**_Instructions:_**  
+**In the console there is a function named positional_argument_example() that takes a default argument and an unspecified number of positional arguments.**  
+**When you call the function:**  
+- **Enter an integer, your age, as the value for the default argument named your_age.**
+- **Assign two strings, the first with your first name, the second with your last name, as the variable positional arguments**.  
+
+**Assign your function call to the variable named about_me.*

challenges/8.8.Positional_Arguments/lesson_settings.json

@@ -0,0 +1,7 @@
+{
+  "lesson_title": "Positional Arguments",
+  "chapter_number": 8,
+  "lesson_number": 8,
+  "id": "",
+  "repl": ""
+}

challenges/8.8.Positional_Arguments/lesson_tests.py

@@ -0,0 +1,15 @@
+import unittest
+from main import *
+
+class PositionalArgumentsTests(unittest.TestCase):
+    def test_main(self):
+        self.assertIsNotNone(about_me)
+        self.assertTrue(about_me)
+        self.assertNotEqual(about_me, "Replace this string with the correct function call.")
+
+    def test_correct_types(self):
+        self.assertIsInstance(about_me, tuple)
+        self.assertIsInstance(about_me[0], int)
+        self.assertIsInstance(about_me[1], tuple)
+        self.assertIsInstance(about_me[1][0], str)
+        self.assertIsInstance(about_me[1][1], str)

challenges/8.8.Positional_Arguments/main.py

@@ -0,0 +1,10 @@
+def positional_argument_example(your_age, *args):
+    return your_age, args
+
+### Write your code below this line ###
+
+about_me = "Replace this string with the correct function call."
+
+### Write your code above this line ###
+
+print(about_me)