Removed numbering on tutorials

1 files changed, 127 insertions, 0 deletions

diff --git a/tutorials/module_1/1_control_structures.md b/tutorials/module_1/1_control_structures.md
new file mode 100644
index 0000000..15e97eb
--- /dev/null
+++ b/tutorials/module_1/1_control_structures.md
@@ -0,0 +1,127 @@
+# Control Structures
+Control structures allow us to control the flow of execution in a Python program. The two main types are **conditional statements (`if` statements)** and **loops (`for` and `while` loops)**.
+
+## Conditional Statements
+
+Conditional statements allow a program to execute different blocks of code depending on whether a given condition is `True` or `False`. These conditions are typically comparisons, such as checking if one number is greater than another.
+
+### The `if` Statement
+
+The simplest form of a conditional statement is the `if` statement. If the condition evaluates to `True`, the indented block of code runs. Otherwise, the program moves on without executing the statement.
+
+For example, consider a situation where we need to determine if a person is an adult based on their age. If the age is 18 or greater, we print a message saying they are an adult.
+
+### The `if-else` Statement
+
+Sometimes, we need to specify what should happen if the condition is `False`. The `else` clause allows us to handle this case. Instead of just skipping over the block, the program can execute an alternative action.
+
+For instance, if a person is younger than 18, they are considered a minor. If the condition of being an adult is not met, the program will print a message indicating that the person is a minor.
+
+### The `if-elif-else` Statement
+
+When dealing with multiple conditions, the `if-elif-else` structure is useful. The program evaluates conditions in order, executing the first one that is `True`. If none of the conditions are met, the `else` block runs.
+
+For example, in a grading system, different score ranges correspond to different letter grades. If a student's score is 90 or higher, they receive an "A". If it's between 80 and 89, they get a "B", and so on. If none of the conditions match, they receive an "F".
+
+### Nested `if` Statements
+
+Sometimes, we need to check conditions within other conditions. This is known as **nesting**. For example, if we first determine that a person is an adult, we can then check if they are a student. Based on that information, we print different messages.
+
+
+```python
+# Getting user input for the student's score
+score = int(input("Enter the student's score (0-100): "))
+
+if 0 <= score <= 100:
+    if score >= 90:
+        grade = "A"
+    elif score >= 80:
+        grade = "B"
+    elif score >= 70:
+        grade = "C"
+    elif score >= 60:
+        grade = "D"
+    else:
+        grade = "F"  # Score below 60 is a failing grade
+
+
+    if grade == "F":
+        print("The student has failed.")
+        retake_eligible = input("Is the student eligible for a retest? (yes/no): ").strip().lower()
+        
+        if retake_eligible == "yes":
+            print("The student is eligible for a retest.")
+        else:
+            print("The student has failed the course and must retake it next semester.")
+
+	
+```
+
+---
+
+## Loops in Python
+
+Loops allow a program to execute a block of code multiple times. This is especially useful for tasks such as processing lists of data, performing repetitive calculations, or automating tasks.
+
+### The `for` Loop
+
+A `for` loop iterates over a sequence, such as a list, tuple, string, or a range of numbers. Each iteration assigns the next value in the sequence to a loop variable, which can then be used inside the loop.
+
+For instance, if we have a list of fruits and want to print each fruit's name, a `for` loop can iterate over the list and display each item.
+
+Another useful feature of `for` loops is the `range()` function, which generates a sequence of numbers. This is commonly used when we need to repeat an action a specific number of times. For example, iterating from 0 to 4 allows us to print a message five times.
+
+Additionally, the `enumerate()` function can be used to loop through a list while keeping track of the index of each item. This is useful when both the position and the value in a sequence are needed.
+
+```python
+fruits = ["apple", "banana", "cherry"]  
+for x in fruits:  
+  print(x)
+```
+
+```python
+for x in range(6):  
+  print(x)  
+else:  
+  print("Finally finished!")
+```
+### The `while` Loop
+
+Unlike `for` loops, which iterate over a sequence, `while` loops continue running as long as a specified condition remains `True`. This is useful when the number of iterations is not known in advance.
+
+For example, a countdown timer can be implemented using a `while` loop. The loop will continue decreasing the count until it reaches zero.
+
+It's important to be careful with `while` loops to avoid infinite loops, which occur when the condition never becomes `False`. To prevent this, ensure that the condition will eventually change during the execution of the loop.
+
+A `while` loop can also be used to wait for a certain event to occur. For example, in interactive programs, a `while True` loop can keep running until the user provides a valid input, at which point we break out of the loop.
+
+```python
+i = 1  
+while i < 6:  
+  print(i)  
+  i += 1
+```
+
+---
+
+## Loop Control Statements
+
+Python provides special statements to control the behavior of loops. These can be used to break out of a loop, skip certain iterations, or simply include a placeholder for future code.
+
+### The `break` Statement
+
+The `break` statement is used to exit a loop before it has iterated through all its elements. When the `break` statement is encountered, the loop stops immediately, and the program continues executing the next statement outside the loop.
+
+For instance, if we are searching for a specific value in a list, we can use a `break` statement to stop the loop as soon as we find the item, instead of continuing unnecessary iterations.
+
+### The `continue` Statement
+
+The `continue` statement is used to skip the current iteration and proceed to the next one. Instead of exiting the loop entirely, it simply moves on to the next cycle.
+
+For example, if we are iterating over numbers and want to skip processing number 2, we can use `continue`. The loop will ignore that iteration and proceed with the next number.
+
+### The `pass` Statement
+
+The `pass` statement is a placeholder that does nothing. It is useful when a block of code is syntactically required but no action needs to be performed yet.
+
+For example, in a loop where a condition has not yet been implemented, using `pass` ensures that the code remains valid while avoiding errors.