Added code sections 2 to 6.

Author: Jose Salvatierra

.gitignore

@@ -0,0 +1,5 @@
+*.pyc
+.idea/
+__pycache__/
+*.db
+.DS_Store

README.md

@@ -0,0 +1,37 @@
+# REST APIs with Flask and Python
+
+This repository contains code that is created in my course, REST APIs with Flask and Python.
+
+The code is divided in folders, one for each section of the course which contains code.
+
+## Section 2
+
+The code is in files numbered between 1 and 11, covering concepts ranging from beginner to advanced.
+
+1. Variables
+2. Methods
+3. Lists, tuples, and sets
+4. If statements
+5. List comprehension
+6. Dictionaries
+7. Classes and objects
+8. Static and class methods
+9. Args and Kwargs
+10. Passing functions as arguments
+11. Decorators
+
+## Section 3
+
+The code in this section includes a simple Flask app and a HTML and JavaScript file which calls the Flask app endpoints.
+
+## Section 4
+
+The code in this section includes a Flask app which is an API that represents items. It also includes user registration and authentication.
+
+## Section 5
+
+The code in this section extends the last section by adding persistent storage of Items to a SQLite database.
+
+## Section 6
+
+The code in this section extends the previous section by replacing the manual integration with SQLite, with SQLAlchemy—an ORM (Object-Relational Mapping)—which allows us to easily replace SQLite with something like PostgreSQL or MySQL.

section2/10_args_and_kwargs.py

@@ -0,0 +1,39 @@
+def my_method(arg1, arg2):
+    return arg1 + arg2
+
+def my_really_long_addition(arg1, arg2, arg3, arg4, arg5):
+    return arg1 + arg2 + arg3 + arg4 + arg5
+
+my_really_long_addition(13, 45, 66, 3, 4)
+
+def adding_simplified(arg_list):
+    return sum(arg_list)
+
+adding_simplified([13, 45, 66, 3, 4])
+
+# But you need a list :(
+
+def what_are_args(*args):
+    print(args)
+
+what_are_args(12, 35, 64, 'hello')
+
+def adding_more_simplified(*args):
+    return sum(args)  # args is a tuple of arguments passed
+
+adding_more_simplified(13, 45, 66, 3, 4)
+
+###
+
+# As well as a tuple of args, we can pass kwargs
+
+def what_are_kwargs(*args, **kwargs):
+    print(args)
+    print(kwargs)
+
+what_are_kwargs(name='Jose', location='UK')
+what_are_kwargs(12, 35, 66, name='Jose', location='UK')
+
+# args are a tuple
+# kwargs is a dictionary
+# This will come in handy!

section2/11_passing_functions.py

@@ -0,0 +1,24 @@
+def methodception(another):
+    return another()
+
+def add_two_numbers():
+    return 35 + 77
+
+methodception(add_two_numbers)
+
+###
+
+methodception(lambda: 35 + 77)
+
+my_list = [13, 56, 77, 484]
+list(filter(lambda x: x != 13, my_list))  # A lambda function is just a short, one-line function that has no name.
+
+# We could also do
+
+def not_thirteen(x):
+    return x != 13
+
+list(filter(not_thirteen, my_list))
+
+# filter() passes each element of my_list as a parameter to the function.
+# Pretty neat, eh?

section2/12_decorators.py

@@ -0,0 +1,55 @@
+# A decorator is just a function that gets called before another function
+
+import functools  # function tools
+
+def my_decorator(f):
+    @functools.wraps(f)
+    def function_that_runs_f():
+        print("Hello!")
+        f()
+        print("After!")
+    return function_that_runs_f
+
+@my_decorator
+def my_function():
+    print("I'm in the function.")
+
+my_function()
+
+
+###
+
+def my_decorator(f):
+    @functools.wraps(f)
+    def function_that_runs_f(*args, **kwargs):
+        print("Hello!")
+        f(*args, **kwargs)
+        print("After!")
+    return function_that_runs_f
+
+@my_decorator
+def my_function(arg1, arg2):
+    print(arg1 + arg2)
+
+my_function(56, 89)
+
+###
+
+def decorator_arguments(number):
+    def my_decorator(f):
+        @functools.wraps(f)
+        def function_that_runs_f(*args, **kwargs):
+            print("Hello!")
+            if number == 56:
+                print("Not running!")
+            else:
+                f(*args, **kwargs)
+            print("After")
+        return function_that_runs_f
+    return my_decorator
+
+@decorator_arguments(56)
+def my_function():
+    print("Hello!")
+
+my_function()

section2/1_variables_methods.py

@@ -0,0 +1,27 @@
+a = 5
+b = 10
+my_variable = 56
+any_variable_name = 100
+
+string_variable = "hello"
+single_quotes = 'strings can have single quotes'
+
+print(string_variable)
+print(my_variable)
+
+# print is a method with one parameter—what we want to print
+
+def my_print_method(my_parameter):
+    print(my_parameter)
+
+my_print_method(string_variable)
+
+def my_multiplication_method(number_one, number_two):
+    return number_one * number_two
+
+result = my_multiplication_method(a, b)
+print(result)
+
+print(my_multiplication_method(56, 75))
+
+my_print_method(my_multiplication_method('b', 5))  # What would this do?

section2/2_lists_tuples_sets.py

@@ -0,0 +1,40 @@
+my_variable = 'hello'
+my_list_variable = ['hello', 'hi', 'nice to meet you']
+my_tuple_variable = ('hello', 'hi', 'nice to meet you')
+my_set_variable = {'hello', 'hi', 'nice to meet you'}
+
+print(my_list_variable)
+print(my_tuple_variable)
+print(my_set_variable)
+
+my_short_tuple_variable = ("hello",)
+another_short_tuple_variable = "hello",
+
+print(my_list_variable[0])
+print(my_tuple_variable[0])
+print(my_set_variable[0])  # This won't work, because there is no order. Which one is element 0?
+
+my_list_variable.append('another string')
+print(my_list_variable)
+
+my_tuple_variable.append('a string')  # This won't work, because a tuple is not a list.
+my_tuple_variable = my_tuple_variable + ("a string",)
+print(my_tuple_variable)
+my_tuple_variable[0] = 'can I change this?'  # No, you can't
+
+my_set_variable.add('hello')
+print(my_set_variable)
+my_set_variable.add('hello')
+print(my_set_variable)
+
+
+###### Set Operations
+
+set_one = {1, 2, 3, 4, 5}
+set_two = {1, 3, 5, 7, 9, 11}
+
+print(set_one.intersection(set_two))  # {1, 3, 5}
+
+print({1, 2}.union({2, 3}))  # {1, 2, 3}
+
+print({1, 2, 3, 4}.difference({2, 4}))  # {1, 3}

section2/3_loops.py

@@ -0,0 +1,23 @@
+my_string = "hello"
+
+for character in my_string:
+    print(character)
+
+for asdf in my_string:
+    print(asdf)
+
+my_list = [1, 2, 5, 3, 67]
+
+for number in my_list:
+    print(number)
+
+for number in my_list:
+    print(number ** 2)
+
+should_continue = True
+while should_continue:
+    print("I'm continuing!")
+
+    user_input = input("Should we continue? (y/n)")
+    if user_input == 'n':
+        should_continue = False

section2/4_if_statements.py

@@ -0,0 +1,31 @@
+my_known_people = ["John", "Rolf", "Anne"]
+user_name = input("Enter your name: ")
+if user_name in my_known_people:
+    print("Hello, I know you!")
+
+
+if user_name in my_known_people:
+    print("Hello {}, I know you!".format(user_name))
+
+
+if user_name in my_known_people:
+    print("Hello {name}, I know you!".format(name=user_name))
+
+"Hello {name}, I know you {}!".format("well", name=user_name)
+"Hello {}, I know you {}!".format("John", "well")
+
+#### Exercise
+
+def who_do_you_know():
+    names = input("Enter the names of people you know, separated by commas: ")
+    names_list = names.split(",")
+    return names_list
+
+def ask_user():
+    # Ask user for their name
+    # See if their name is in list of people
+    # Print something if it is
+
+    user_name = input("Enter your name: ")
+    if user_name in who_do_you_know():
+        print("Hello {}, I know you!".format(user_name))

section2/5_list_comprehension.py

@@ -0,0 +1,20 @@
+my_list = [0, 1, 2, 3, 4]
+an_equal_list = [x for x in range(5)]
+
+for my_number in range(10):
+    print(my_number)
+
+[my_number for my_number in range(10)]
+
+[my_number * 2 for my_number in range(10)]
+
+1 % 2
+2 % 2
+5 % 2
+8 % 3
+
+[n for n in range(10) if n % 2 == 0]
+
+names_list = ["John", "Rolf", "Anne"]
+lowercase_names = [name.lower() for name in names_list]
+print(lowercase_names)