VixyMan
diff --git a/‎course_contents/2_intro_to_python/README.md renamed to ‎course_contents/2_intro_to_python/notes/02. Functions.md
Lines changed: 35 additions & 85 deletions b/‎course_contents/2_intro_to_python/README.md renamed to ‎course_contents/2_intro_to_python/notes/02. Functions.md
Lines changed: 35 additions & 85 deletions
@@ -1,52 +1,23 @@
 # Python functions
 
-Defining a function:
+Define a function using the `def` keyword. Once defined, it can be called (or executed) by using the function name and a pair of brackets.
 
 ```python
 def greet():
     name = input("Enter your name: ")
     print(f"Hello, {name}!")
-```
-
-To call a function use the function's name followed by parentheses:
-
-```python
-# defining the function
-def greet():
-    name = input("Enter your name: ")
-    print(f"Hello, {name}!")
 
 
-# calling the function
 greet()
 ```
 
-## The `def` keyword
-
-A function is defined by 4 elements:
-- the `def` keyword
-- the name of the function
-- parentheses and
-- colon
-
-Syntax: `def name():`
-
-## Indentation
-
-- To write code inside the function, you must increase the indentation level with one
-- When you reduce the indentation level, you exit the function
-
-Example:
-
-```python
-def greet():
-    name = input("Enter your name: ")  # inside the function
-    print(f"Hello, {name}!")  # inside the function
+> Could show small callouts beside each section of the shown code sample.
+> E.g. beside `def greet()` show "Defining the function name"
+> Then beside the function body, show "Function body, will run when we execute the function".
+> Then beside `greet()`, show "Executing the function starts the function body"
+> Highlight the difference in indentation level with a callout.
+> Signal that when we have less indentation, we exit the function.
 
-print("Outside the function")
-
-greet()
-```
 
 ## The `return` keyword
 
@@ -59,56 +30,40 @@ def greet():
     pass  # Do nothing
 
 
-# print the function's return
+# print the function's return value
 print(greet())  # None
 ```
 
-- `pass` it's a keyword, and it means "do nothing"
+- `pass` is a keyword which means "do nothing". It's necessary since a function needs a body.
 - you can control what a function returns using the `return` keyword.
 
 Example:
 
 ```python
-def greet():
+def greet_user():
     name = "John Doe"
     return f"Hello, {name}!"
 
-# printing the function
-print(greet())  # John Doe
+greeting = greet()
+print(greeting)  # John Doe
 ```
 
-A function can return anything.
+A function can return any value.
 
-## Parameters
+## Arguments and parameters
 
-A parameter is the variable defined inside the function's definition parentheses.
+Functions can accept values from the caller, and return a value in their place.
 
-Example:
-
-```python
+```py
 def greet(name):
-    return f"Hello, {name}!"
-```
-
-You can have any number of parameters in a function.
+    return f"Hello, {name}
 
-
-## Arguments
-
-- When a function is called, an argument is the value that is passed to it
-- To call a function that has a parameter, you have to provide an argument
-
-Example:
-
-```python
-def greet(name):
-    return f"Hello, {name}!"
-
-
-print(greet("John Doe"))  # Hello, John Doe!
+greeting = greet("Rolf Smith")
+print(greeting)  # Hello, Rolf Smith
 ```
 
-The variable `name` will hold whatever it was passed inside the function's parentheses upon function call.
+> Here we could have a diagram showing the flow of data using arrows.
+> From the string "Rolf Smith" to the function, then through the return value to the `greeting` variable.
 
 ## Number of parameters
 
@@ -144,20 +99,11 @@ def greet(name="John Doe"):
 
 
 print(greet())  # Hello, John Doe!
+print(greet("Rolf Smith"))  # Hello, Rolf Smith
 ```
 
 When passing an argument to the function, the default parameter value will be overwritten by the given argument.
 
-For example:
-
-```python
-    return f"Hello, {name}!"
-
-
-print(greet("Jimmy Boy"))  # Hello, Jimmy Boy!
-```
-
 If the function has a mix of normal and default parameters, the default parameters have to be passed last.
 
 Correct:
@@ -186,29 +132,30 @@ Read more about Python functions [here](https://www.teclado.com/30-days-of-pytho
 
 - Lambda expressions are an alternative syntax for defining simple functions.
 
-Syntax: `lambda arguments: expression`
+Example: `lambda name: f"Hello, {name}"`
 
-- they don't have a name
-- they can be given a name by assigning them to a variable name
-- they're not so easy to read
+- No name
+- Can be assigned to a variable
+- Can be difficult to read
 
-Example:
+Calling a lambda inline requires multiple pairs of brackets:
 
 ```python
 result = (lambda x, y: x + y)(15, 3)
 ```
 
-Read more about lambda expressions and first-class functions [here](https://www.teclado.com/30-days-of-python/python-30-day-16-lambda-expressions).
-
 # First Class Functions
 
 - Functions in Python are "first class citizens".
-- This means they are objects that can be stored in data structures and passed as arguments, and stored in variables.
+- They can be stored in data structures, passed as arguments, and stored in variables.
 
 Example:
 
 ```python
-# Each of avg, sum, max are functions, and since they are First Class Citizens, they can be stored in this dictionary.
+def avg(*args):
+    return sum(args) / len(args)
+
+
 operations = {
     "average": avg,
     "total": sum,
@@ -220,3 +167,6 @@ selection = "average"
 operation = operations[selection]
 operation() # This is acts the same as simply calling avg()
 ```
+
+Read more about lambda expressions and first-class functions [here](https://www.teclado.com/30-days-of-python/python-30-day-16-lambda-expressions).