QuantEcon
diff --git a/Collapse file
‎lectures/functions.md‎
Copy file name to clipboardExpand all lines: lectures/functions.md
+130Lines changed: 130 additions & 0 deletions
Display the source diff
Display the rich diff b/Collapse file
‎lectures/functions.md‎
Copy file name to clipboardExpand all lines: lectures/functions.md
+130Lines changed: 130 additions & 0 deletions
Display the source diff
Display the rich diff
diff --git a/Collapse file
‎lectures/python_essentials.md‎
Copy file name to clipboardExpand all lines: lectures/python_essentials.md
-136Lines changed: 0 additions & 136 deletions
Display the source diff
Display the rich diff b/Collapse file
‎lectures/python_essentials.md‎
Copy file name to clipboardExpand all lines: lectures/python_essentials.md
-136Lines changed: 0 additions & 136 deletions
Display the source diff
Display the rich diff
@@ -171,6 +171,135 @@ print(new_abs_function(3))
 print(new_abs_function(-3))
 ```
 
+### Keyword Arguments
+
+```{index} single: Python; keyword arguments
+```
+
+In a {ref}`previous lecture <python_by_example>`, you came across the statement
+
+```{code-block} python3
+:class: no-execute
+
+plt.plot(x, 'b-', label="white noise")
+```
+
+In this call to Matplotlib's `plot` function, notice that the last argument is passed in `name=argument` syntax.
+
+This is called a *keyword argument*, with `label` being the keyword.
+
+Non-keyword arguments are called *positional arguments*, since their meaning
+is determined by order
+
+* `plot(x, 'b-', label="white noise")` is different from `plot('b-', x, label="white noise")`
+
+Keyword arguments are particularly useful when a function has a lot of arguments, in which case it's hard to remember the right order.
+
+You can adopt keyword arguments in user-defined functions with no difficulty.
+
+The next example illustrates the syntax
+
+```{code-cell} python3
+def f(x, a=1, b=1):
+    return a + b * x
+```
+
+The keyword argument values we supplied in the definition of `f` become the default values
+
+```{code-cell} python3
+f(2)
+```
+
+They can be modified as follows
+
+```{code-cell} python3
+f(2, a=4, b=5)
+```
+
+### The Flexibility of Python Functions
+
+As we discussed in the {ref}`previous lecture <python_by_example>`, Python functions are very flexible.
+
+In particular
+
+* Any number of functions can be defined in a given file.
+* Functions can be (and often are) defined inside other functions.
+* Any object can be passed to a function as an argument, including other functions.
+* A function can return any kind of object, including functions.
+
+We already {ref}`gave an example <test_program_6>` of how straightforward it is to pass a function to
+a function.
+
+Note that a function can have arbitrarily many `return` statements (including zero).
+
+Execution of the function terminates when the first return is hit, allowing
+code like the following example
+
+```{code-cell} python3
+def f(x):
+    if x < 0:
+        return 'negative'
+    return 'nonnegative'
+```
+
+Functions without a return statement automatically return the special Python object `None`.
+
+
+### Docstrings
+
+```{index} single: Python; Docstrings
+```
+
+Python has a system for adding comments to functions, modules, etc. called *docstrings*.
+
+The nice thing about docstrings is that they are available at run-time.
+
+Try running this
+
+```{code-cell} python3
+def f(x):
+    """
+    This function squares its argument
+    """
+    return x**2
+```
+
+After running this code, the docstring is available
+
+```{code-cell} ipython
+f?
+```
+
+```{code-block} ipython
+:class: no-execute
+
+Type:       function
+String Form:<function f at 0x2223320>
+File:       /home/john/temp/temp.py
+Definition: f(x)
+Docstring:  This function squares its argument
+```
+
+```{code-cell} ipython
+f??
+```
+
+```{code-block} ipython
+:class: no-execute
+
+Type:       function
+String Form:<function f at 0x2223320>
+File:       /home/john/temp/temp.py
+Definition: f(x)
+Source:
+def f(x):
+    """
+    This function squares its argument
+    """
+    return x**2
+```
+
+With one question mark we bring up the docstring, and with two we get the source code as well.
 
 ### One-Line Functions: `lambda`
 
@@ -351,6 +480,7 @@ In the context of our program, the ability to bind new names to functions
 means that there is no problem *passing a function as an argument to another
 function*---as we did above.
 
+
 ## Exercises
 
 ```{exercise}
 
@@ -600,142 +600,6 @@ Note:
 * `all()` returns `True` when *all* boolean values/expressions in the sequence are `True`
 * `any()` returns `True` when *any* boolean values/expressions in the sequence are `True`
 
-## More Functions
-
-```{index} single: Python; Functions
-```
-
-Let's talk a bit more about functions, which are all important for good programming style.
-
-### The Flexibility of Python Functions
-
-As we discussed in the {ref}`previous lecture <python_by_example>`, Python functions are very flexible.
-
-In particular
-
-* Any number of functions can be defined in a given file.
-* Functions can be (and often are) defined inside other functions.
-* Any object can be passed to a function as an argument, including other functions.
-* A function can return any kind of object, including functions.
-
-We already {ref}`gave an example <test_program_6>` of how straightforward it is to pass a function to
-a function.
-
-Note that a function can have arbitrarily many `return` statements (including zero).
-
-Execution of the function terminates when the first return is hit, allowing
-code like the following example
-
-```{code-cell} python3
-def f(x):
-    if x < 0:
-        return 'negative'
-    return 'nonnegative'
-```
-
-Functions without a return statement automatically return the special Python object `None`.
-
-### Docstrings
-
-```{index} single: Python; Docstrings
-```
-
-Python has a system for adding comments to functions, modules, etc. called *docstrings*.
-
-The nice thing about docstrings is that they are available at run-time.
-
-Try running this
-
-```{code-cell} python3
-def f(x):
-    """
-    This function squares its argument
-    """
-    return x**2
-```
-
-After running this code, the docstring is available
-
-```{code-cell} ipython
-f?
-```
-
-```{code-block} ipython
-:class: no-execute
-
-Type:       function
-String Form:<function f at 0x2223320>
-File:       /home/john/temp/temp.py
-Definition: f(x)
-Docstring:  This function squares its argument
-```
-
-```{code-cell} ipython
-f??
-```
-
-```{code-block} ipython
-:class: no-execute
-
-Type:       function
-String Form:<function f at 0x2223320>
-File:       /home/john/temp/temp.py
-Definition: f(x)
-Source:
-def f(x):
-    """
-    This function squares its argument
-    """
-    return x**2
-```
-
-With one question mark we bring up the docstring, and with two we get the source code as well.
-
-### Keyword Arguments
-
-```{index} single: Python; keyword arguments
-```
-
-In a {ref}`previous lecture <python_by_example>`, you came across the statement
-
-```{code-block} python3
-:class: no-execute
-
-plt.plot(x, 'b-', label="white noise")
-```
-
-In this call to Matplotlib's `plot` function, notice that the last argument is passed in `name=argument` syntax.
-
-This is called a *keyword argument*, with `label` being the keyword.
-
-Non-keyword arguments are called *positional arguments*, since their meaning
-is determined by order
-
-* `plot(x, 'b-', label="white noise")` is different from `plot('b-', x, label="white noise")`
-
-Keyword arguments are particularly useful when a function has a lot of arguments, in which case it's hard to remember the right order.
-
-You can adopt keyword arguments in user-defined functions with no difficulty.
-
-The next example illustrates the syntax
-
-```{code-cell} python3
-def f(x, a=1, b=1):
-    return a + b * x
-```
-
-The keyword argument values we supplied in the definition of `f` become the default values
-
-```{code-cell} python3
-f(2)
-```
-
-They can be modified as follows
-
-```{code-cell} python3
-f(2, a=4, b=5)
-```
-
 ## Coding Style and PEP8
 
 ```{index} single: Python; PEP8