notebooks/01_Python_Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \"Hello World\" in Python\n",
    "\n",
    "When you start learning a new programming language, the first thing you learn is how to print \"Hello, World!\". Here is how you do it in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables, Strings, and Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "Variables are containers for storing data values. In Python, variables are created when you assign a value to it. You don't need to declare the type of the variable. Python automatically assigns the data type based on the value you assign to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "message = \"Hello, World!\"\n",
    "\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can assign a value to a variable using the `=` operator at any time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "message = \"Hello world!\"\n",
    "print(message)\n",
    "\n",
    "message = \"Hello world again!\"\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Naming Rules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. A variable name must start with a letter or the underscore character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct\n",
    "my_variable = 10\n",
    "_variable = 20\n",
    "\n",
    "# Incorrect\n",
    "# 1variable = 30  # This will cause a syntax error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. A variable name cannot start with a number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct\n",
    "variable1 = 10\n",
    "\n",
    "# Incorrect\n",
    "# 1variable = 10  # This will cause a syntax error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. A variable name can only contain alpha-numeric characters and underscores (A-z, 0-9, and _)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct\n",
    "my_variable_1 = 10\n",
    "\n",
    "# Incorrect\n",
    "# my-variable = 10  # This will cause a syntax error\n",
    "# my variable = 10  # This will cause a syntax error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Variable names are case-sensitive (age, Age, and AGE are three different variables)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age = 10\n",
    "Age = 20\n",
    "AGE = 30\n",
    "\n",
    "print(age)  # Outputs: 10\n",
    "print(Age)  # Outputs: 20\n",
    "print(AGE)  # Outputs: 30"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. The variable name should be descriptive and meaningful."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Descriptive and meaningful\n",
    "student_age = 15\n",
    "total_price = 100.50\n",
    "\n",
    "# Not descriptive or meaningful\n",
    "x = 15\n",
    "y = 100.50"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. Avoid using Python keywords as variable names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct\n",
    "my_variable = 10\n",
    "\n",
    "# Incorrect\n",
    "# for = 10  # This will cause a syntax error because 'for' is a keyword"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7. Avoid using special characters in variable names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct\n",
    "my_variable = 10\n",
    "\n",
    "# Incorrect\n",
    "# my@variable = 10  # This will cause a syntax error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8. Use underscores to separate words in a variable name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct\n",
    "student_name = \"John\"\n",
    "\n",
    "# Incorrect\n",
    "studentname = \"John\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9. Use lowercase letters for variable names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "student_name = \"John\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10. Use uppercase letters for constants."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "PI = 3.14159\n",
    "GRAVITY = 9.8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "11.  Use camel case for function names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculateTotalPrice():\n",
    "    pass\n",
    "\n",
    "# Incorrect\n",
    "def calculate_total_price():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "12. Use snake case for variable names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct\n",
    "total_price = 100.50\n",
    "\n",
    "# Incorrect\n",
    "totalPrice = 100.50"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "13. Use Pascal case for class names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correct\n",
    "class Student:\n",
    "    pass\n",
    "\n",
    "# Incorrect\n",
    "class student:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "14. Use a leading underscore for private variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student:\n",
    "    def __init__(self):\n",
    "        self._name = \"John\"  # Private variable\n",
    "\n",
    "student = Student()\n",
    "print(student._name)  # Accessing private variable (generally discouraged)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "15. Use a leading and trailing double underscore for special variables or methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student:\n",
    "    def __init__(self):\n",
    "        self.__name__ = \"John\"  # Special variable\n",
    "\n",
    "    def __str__(self):\n",
    "        return self.__name__\n",
    "\n",
    "student = Student()\n",
    "print(student)  # Uses the __str__ method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "16. Use a leading underscore for protected methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student:\n",
    "    def _calculate_grade(self):\n",
    "        pass  # Protected method\n",
    "\n",
    "class HighSchoolStudent(Student):\n",
    "    def access_protected_method(self):\n",
    "        self._calculate_grade()  # Accessing protected method within a subclass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "17. Use a leading double underscore for name mangling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student:\n",
    "    def __init__(self):\n",
    "        self.__name = \"John\"  # Name mangling\n",
    "\n",
    "    def get_name(self):\n",
    "        return self.__name\n",
    "\n",
    "student = Student()\n",
    "# print(student.__name)  # This will cause an error\n",
    "print(student._Student__name)  # This works because of name mangling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "\n",
    "Strings are sequences of characters used to store and manipulate text in Python. Strings can be created by enclosing characters in either single quotes `'` or double quotes `\"`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating Strings\n",
    "\n",
    "You can create a string by enclosing text in quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Single quotes\n",
    "single_quote_string = 'Hello, world!'\n",
    "print(single_quote_string)\n",
    "\n",
    "# Double quotes\n",
    "double_quote_string = \"Hello, world!\"\n",
    "print(double_quote_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Concatenation\n",
    "\n",
    "You can combine (concatenate) two or more strings using the `+` operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string1 = \"Hello\"\n",
    "string2 = \"world\"\n",
    "combined_string = string1 + \" \" + string2\n",
    "print(combined_string)  # Outputs: Hello world"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Length\n",
    "\n",
    "You can find the length of a string using the `len()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"Hello, world!\"\n",
    "print(len(my_string))  # Outputs: 13"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing Strings\n",
    "\n",
    "You can extract a substring from a string using slicing. Slicing is done using the `start:end` syntax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"Hello, world!\"\n",
    "print(my_string[0:5])  # Outputs: Hello\n",
    "print(my_string[7:12])  # Outputs: world"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `upper()`: Converts a string to uppercase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"Hello, world!\"\n",
    "print(my_string.upper())  # Outputs: HELLO, WORLD!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `lower()`: Converts a string to lowercase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"Hello, WORLD!\"\n",
    "print(my_string.lower())  # Outputs: hello, world!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `strip()`: Removes any leading and trailing whitespace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"  Hello, world!  \"\n",
    "print(my_string.strip())  # Outputs: Hello, world!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `replace()`: Replaces a substring with another substring."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"Hello, world!\"\n",
    "print(my_string.replace(\"world\", \"Python\"))  # Outputs: Hello, Python!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `split()`: Splits the string into a list of substrings based on a delimiter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"Hello, world!\"\n",
    "print(my_string.split(\", \"))  # Outputs: ['Hello', 'world!']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Formatting\n",
    "\n",
    "You can format strings using the format() method or f-strings (formatted string literals)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Using `format()` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Alice\"\n",
    "age = 25\n",
    "formatted_string = \"My name is {} and I am {} years old.\".format(name, age)\n",
    "print(formatted_string)  # Outputs: My name is Alice and I am 25 years old."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Using f-strings (available in Python 3.6 and later)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Alice\"\n",
    "age = 25\n",
    "formatted_string = f\"My name is {name} and I am {age} years old.\"\n",
    "print(formatted_string)  # Outputs: My name is Alice and I am 25 years old."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiline Strings\n",
    "\n",
    "You can create multiline strings using triple quotes (`'''` or `\"\"\"`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "multiline_string = \"\"\"This is a\n",
    "multiline string\n",
    "that spans multiple\n",
    "lines.\"\"\"\n",
    "print(multiline_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numbers\n",
    "\n",
    "In Python, numbers are a fundamental data type used to represent and perform operations on numerical values. There are three main types of numbers in Python: integers, floating-point numbers, and complex numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Integers\n",
    "\n",
    "Integers are whole numbers that can be positive, negative, or zero. In Python, integers are created by simply assigning a numerical value without a decimal point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Examples of integers\n",
    "positive_integer = 10\n",
    "negative_integer = -5\n",
    "zero = 0\n",
    "\n",
    "print(positive_integer)  # Outputs: 10\n",
    "print(negative_integer)  # Outputs: -5\n",
    "print(zero)              # Outputs: 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Floating-Point Numbers\n",
    "\n",
    "Floating-point numbers, or floats, are numbers with a decimal point. They can represent fractional values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Examples of floating-point numbers\n",
    "positive_float = 10.5\n",
    "negative_float = -2.75\n",
    "zero_float = 0.0\n",
    "\n",
    "print(positive_float)  # Outputs: 10.5\n",
    "print(negative_float)  # Outputs: -2.75\n",
    "print(zero_float)      # Outputs: 0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Complex Numbers\n",
    "\n",
    "Complex numbers consist of a real part and an imaginary part. In Python, complex numbers are written with a \"j\" or \"J\" to indicate the imaginary part."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of a complex number\n",
    "complex_number = 3 + 4j\n",
    "\n",
    "print(complex_number)        # Outputs: (3+4j)\n",
    "print(complex_number.real)   # Outputs: 3.0 (real part)\n",
    "print(complex_number.imag)   # Outputs: 4.0 (imaginary part)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Arithmetic Operations\n",
    "\n",
    "Python supports various arithmetic operations, such as addition, subtraction, multiplication, and division."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 3\n",
    "\n",
    "# Addition\n",
    "sum_result = a + b\n",
    "print(sum_result)  # Outputs: 13\n",
    "\n",
    "# Subtraction\n",
    "difference = a - b\n",
    "print(difference)  # Outputs: 7\n",
    "\n",
    "# Multiplication\n",
    "product = a * b\n",
    "print(product)  # Outputs: 30\n",
    "\n",
    "# Division\n",
    "quotient = a / b\n",
    "print(quotient)  # Outputs: 3.3333333333333335\n",
    "\n",
    "# Floor Division (integer division)\n",
    "floor_division = a // b\n",
    "print(floor_division)  # Outputs: 3\n",
    "\n",
    "# Modulus (remainder)\n",
    "remainder = a % b\n",
    "print(remainder)  # Outputs: 1\n",
    "\n",
    "# Exponentiation (power)\n",
    "power = a ** b\n",
    "print(power)  # Outputs: 1000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type Conversion\n",
    "\n",
    "You can convert between different numerical types using built-in functions: `int()`, `float()`, and `complex()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Converting to an integer\n",
    "float_number = 10.75\n",
    "integer_number = int(float_number)\n",
    "print(integer_number)  # Outputs: 10\n",
    "\n",
    "# Converting to a float\n",
    "integer_number = 5\n",
    "float_number = float(integer_number)\n",
    "print(float_number)  # Outputs: 5.0\n",
    "\n",
    "# Converting to a complex number\n",
    "integer_number = 7\n",
    "complex_number = complex(integer_number)\n",
    "print(complex_number)  # Outputs: (7+0j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Built-in Functions for Numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Absolute value\n",
    "negative_number = -15\n",
    "absolute_value = abs(negative_number)\n",
    "print(absolute_value)  # Outputs: 15\n",
    "\n",
    "# Power function\n",
    "base = 2\n",
    "exponent = 3\n",
    "result = pow(base, exponent)\n",
    "print(result)  # Outputs: 8\n",
    "\n",
    "# Maximum and minimum\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "max_value = max(numbers)\n",
    "min_value = min(numbers)\n",
    "print(max_value)  # Outputs: 5\n",
    "print(min_value)  # Outputs: 1\n",
    "\n",
    "# Rounding\n",
    "float_number = 10.75\n",
    "rounded_number = round(float_number)\n",
    "print(rounded_number)  # Outputs: 11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists and Tuples\n",
    "\n",
    "In Python, lists and tuples are used to store collections of items. Both are sequence data types that can hold multiple items, but they have some key differences."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "\n",
    "A list is a collection of items that are ordered and changeable. Lists are defined by enclosing the elements in square brackets `[]`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating an empty list\n",
    "empty_list = []\n",
    "\n",
    "# Creating a list with initial items\n",
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "print(fruits)  # Outputs: ['apple', 'banana', 'cherry']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing List Items\n",
    "\n",
    "You can access individual items in a list using an index. Indexing starts at 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Accessing items in a list\n",
    "print(fruits[0])  # Outputs: apple\n",
    "print(fruits[1])  # Outputs: banana\n",
    "print(fruits[2])  # Outputs: cherry"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modifying List Items\n",
    "\n",
    "You can modify individual items in a list by assigning a new value to the item's index."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Changing an item in a list\n",
    "fruits[1] = \"blueberry\"\n",
    "print(fruits)  # Outputs: ['apple', 'blueberry', 'cherry']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding Items to a List\n",
    "\n",
    "You can add items to a list using the `append()`, `insert()`, or `extend()` methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adding an item to the end of the list\n",
    "fruits.append(\"date\")\n",
    "print(fruits)  # Outputs: ['apple', 'blueberry', 'cherry', 'date']\n",
    "\n",
    "# Inserting an item at a specific position\n",
    "fruits.insert(1, \"banana\")\n",
    "print(fruits)  # Outputs: ['apple', 'banana', 'blueberry', 'cherry', 'date']\n",
    "\n",
    "# Extending the list with another list\n",
    "more_fruits = [\"elderberry\", \"fig\"]\n",
    "fruits.extend(more_fruits)\n",
    "print(fruits)  # Outputs: ['apple', 'banana', 'blueberry', 'cherry', 'date', 'elderberry', 'fig']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Removing Items from a List\n",
    "\n",
    "You can remove items from a list using the `remove()`, `pop()`, or `del` statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Removing an item by value\n",
    "fruits.remove(\"banana\")\n",
    "print(fruits)  # Outputs: ['apple', 'blueberry', 'cherry', 'date', 'elderberry', 'fig']\n",
    "\n",
    "# Removing an item by index\n",
    "fruits.pop(2)\n",
    "print(fruits)  # Outputs: ['apple', 'blueberry', 'date', 'elderberry', 'fig']\n",
    "\n",
    "# Removing an item by index using del\n",
    "del fruits[0]\n",
    "print(fruits)  # Outputs: ['blueberry', 'date', 'elderberry', 'fig']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "\n",
    "A tuple is a collection of items that are ordered and unchangeable. Tuples are defined by enclosing the elements in parentheses `()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating an empty tuple\n",
    "empty_tuple = ()\n",
    "\n",
    "# Creating a tuple with initial items\n",
    "fruits = (\"apple\", \"banana\", \"cherry\")\n",
    "print(fruits)  # Outputs: ('apple', 'banana', 'cherry')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing Tuple Items\n",
    "\n",
    "You can access items in a tuple using their index, just like lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Accessing items in a tuple\n",
    "print(fruits[0])  # Outputs: apple\n",
    "print(fruits[1])  # Outputs: banana\n",
    "print(fruits[2])  # Outputs: cherry"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modifying Tuple Items\n",
    "\n",
    "Tuples are immutable, so you cannot change their items. However, you can convert a tuple to a list, modify the list, and convert it back to a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Trying to change an item in a tuple will result in an error\n",
    "# fruits[1] = \"blueberry\"  # Uncommenting this line will cause a TypeError\n",
    "\n",
    "# Converting a tuple to a list\n",
    "fruits_list = list(fruits)\n",
    "print(fruits_list)  # Outputs: ['apple', 'banana', 'cherry']\n",
    "\n",
    "# Modifying the list\n",
    "fruits_list[1] = \"blueberry\"\n",
    "print(fruits_list)  # Outputs: ['apple', 'blueberry', 'cherry']\n",
    "\n",
    "# Converting the list back to a tuple\n",
    "fruits = tuple(fruits_list)\n",
    "print(fruits)  # Outputs: ('apple', 'blueberry', 'cherry')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionaries and Sets\n",
    "\n",
    "In Python, dictionaries and sets are built-in data types used to store collections of items. Both have unique characteristics and uses."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "\n",
    "A dictionary is a collection of key-value pairs. Each key is unique and maps to a value. Dictionaries are mutable, meaning you can change their content. They are created using curly braces `{}` or the `dict()` function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Creating a Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating an empty dictionary\n",
    "empty_dict = {}\n",
    "\n",
    "# Creating a dictionary with initial key-value pairs\n",
    "student = {\n",
    "    \"name\": \"Alice\",\n",
    "    \"age\": 17,\n",
    "    \"grade\": \"A\"\n",
    "}\n",
    "print(student)  # Outputs: {'name': 'Alice', 'age': 17, 'grade': 'A'}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Accessing Values in a Dictionary\n",
    "\n",
    "You can access the value associated with a key using square brackets `[]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Accessing values\n",
    "print(student[\"name\"])  # Outputs: Alice\n",
    "print(student[\"age\"])   # Outputs: 17\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Modifying Values in a Dictionary\n",
    "\n",
    "You can change the value associated with a key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modifying values\n",
    "student[\"age\"] = 18\n",
    "print(student)  # Outputs: {'name': 'Alice', 'age': 18, 'grade': 'A'}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Adding and Removing Key-Value Pairs\n",
    "\n",
    "You can add new key-value pairs or remove existing ones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adding a new key-value pair\n",
    "student[\"school\"] = \"High School\"\n",
    "print(student)  # Outputs: {'name': 'Alice', 'age': 18, 'grade': 'A', 'school': 'High School'}\n",
    "\n",
    "# Removing a key-value pair\n",
    "del student[\"grade\"]\n",
    "print(student)  # Outputs: {'name': 'Alice', 'age': 18, 'school': 'High School'}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Iterating Through a Dictionary\n",
    "\n",
    "You can iterate through the keys, values, or key-value pairs in a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Iterating through keys\n",
    "for key in student:\n",
    "    print(key)\n",
    "\n",
    "# Iterating through values\n",
    "for value in student.values():\n",
    "    print(value)\n",
    "\n",
    "# Iterating through key-value pairs\n",
    "for key, value in student.items():\n",
    "    print(f\"{key}: {value}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets\n",
    "\n",
    "A set is an unordered collection of unique items. Sets are mutable, but they do not allow duplicate values. Sets are created using curly braces `{}` or the `set()` function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Creating a Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating an empty set\n",
    "empty_set = set()\n",
    "\n",
    "# Creating a set with initial values\n",
    "fruits = {\"apple\", \"banana\", \"cherry\"}\n",
    "print(fruits)  # Outputs: {'apple', 'banana', 'cherry'}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Adding and Removing Items in a Set\n",
    "\n",
    "You can add new items or remove existing ones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adding an item to the set\n",
    "fruits.add(\"date\")\n",
    "print(fruits)  # Outputs: {'apple', 'banana', 'cherry', 'date'}\n",
    "\n",
    "# Removing an item from the set\n",
    "fruits.remove(\"banana\")\n",
    "print(fruits)  # Outputs: {'apple', 'cherry', 'date'}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Set Operations\n",
    "\n",
    "Sets support various operations like union, intersection, and difference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1 = {\"apple\", \"banana\", \"cherry\"}\n",
    "set2 = {\"banana\", \"cherry\", \"date\"}\n",
    "\n",
    "# Union of sets\n",
    "union_set = set1.union(set2)\n",
    "print(union_set)  # Outputs: {'apple', 'banana', 'cherry', 'date'}\n",
    "\n",
    "# Intersection of sets\n",
    "intersection_set = set1.intersection(set2)\n",
    "print(intersection_set)  # Outputs: {'banana', 'cherry'}\n",
    "\n",
    "# Difference of sets\n",
    "difference_set = set1.difference(set2)\n",
    "print(difference_set)  # Outputs: {'apple'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions\n",
    "\n",
    "Functions are a fundamental concept in programming that allow you to group a set of instructions under a single name. Functions help in organizing code, making it more readable, reusable, and easier to debug."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining a Function\n",
    "\n",
    "A function is defined using the `def` keyword, followed by the function name, parentheses `()`, and a colon `:`. The code block within the function is indented."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining a function\n",
    "def greet():\n",
    "    print(\"Hello, world!\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calling a Function\n",
    "\n",
    "Once a function is defined, you can call it by using its name followed by parentheses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calling the function\n",
    "greet()  # Outputs: Hello, world!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function Parameters\n",
    "\n",
    "Functions can take parameters (arguments) to customize their behavior. Parameters are specified within the parentheses during function definition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining a function with parameters\n",
    "def greet_person(name):\n",
    "    print(f\"Hello, {name}!\")\n",
    "\n",
    "# Calling the function with an argument\n",
    "greet_person(\"Alice\")  # Outputs: Hello, Alice!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Default Parameters\n",
    "\n",
    "You can provide default values for parameters. If no argument is passed, the default value is used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining a function with default parameters\n",
    "def greet_person(name=\"stranger\"):\n",
    "    print(f\"Hello, {name}!\")\n",
    "\n",
    "# Calling the function with and without arguments\n",
    "greet_person(\"Bob\")     # Outputs: Hello, Bob!\n",
    "greet_person()          # Outputs: Hello, stranger!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Returning Values\n",
    "\n",
    "Functions can return values using the return statement. This allows you to get a result from the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining a function that returns a value\n",
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "# Calling the function and storing the result\n",
    "result = add(5, 3)\n",
    "print(result)  # Outputs: 8\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple Return Values\n",
    "\n",
    "Functions can return multiple values as a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining a function that returns multiple values\n",
    "def get_full_name(first_name, last_name):\n",
    "    full_name = f\"{first_name} {last_name}\"\n",
    "    initials = f\"{first_name[0]}.{last_name[0]}.\"\n",
    "    return full_name, initials\n",
    "\n",
    "# Calling the function and unpacking the result\n",
    "name, initials = get_full_name(\"John\", \"Doe\")\n",
    "print(name)      # Outputs: John Doe\n",
    "print(initials)  # Outputs: J.D.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Keyword Arguments\n",
    "\n",
    "You can call functions using keyword arguments, which makes the function call more readable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining a function\n",
    "def describe_pet(pet_name, animal_type=\"dog\"):\n",
    "    print(f\"I have a {animal_type} named {pet_name}.\")\n",
    "\n",
    "# Calling the function using keyword arguments\n",
    "describe_pet(pet_name=\"Willie\", animal_type=\"hamster\")\n",
    "describe_pet(animal_type=\"cat\", pet_name=\"Whiskers\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variable Scope\n",
    "\n",
    "Variables defined inside a function are local to that function and cannot be accessed outside."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function():\n",
    "    local_variable = 10\n",
    "    print(local_variable)\n",
    "\n",
    "my_function()  # Outputs: 10\n",
    "# print(local_variable)  # Uncommenting this line will cause an error because local_variable is not accessible outside the function\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lambda Functions\n",
    "\n",
    "Lambda functions are small anonymous functions defined using the lambda keyword. They are often used for short, simple functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining a lambda function\n",
    "square = lambda x: x * x\n",
    "\n",
    "# Using the lambda function\n",
    "print(square(5))  # Outputs: 25\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# if statements\n",
    "\n",
    "The `if` statement is used to execute a block of code only if a specified condition is true."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparison Operators\n",
    "\n",
    "| Operator | Description |\n",
    "|----------|-------------|\n",
    "| == | Equal |\n",
    "| != | Not equal |\n",
    "| > | Greater than |\n",
    "| < | Less than |\n",
    "| >= | Greater than or equal to |\n",
    "| <= | Less than or equal to |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logical Operators\n",
    "\n",
    "| Logic Operator | Description |\n",
    "|----------------|-------------|\n",
    "| and | Returns True if both statements are true |\n",
    "| or | Returns True if one of the statements is true |\n",
    "| not | Reverse the result, returns False if the result is true |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The if-elif...else chain\n",
    "\n",
    "You can use the `elif` and `else` statements to add more conditions to your code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Basic if Statement\n",
    "\n",
    "The `if` statement is used to test a condition. If the condition is `True`, the block of code inside the `if` statement is executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Basic if statement\n",
    "age = 18\n",
    "if age >= 18:\n",
    "    print(\"You are an adult.\")  # This will be printed because the condition is True\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `if-else` Statement\n",
    "\n",
    "The `else` statement can be used to define a block of code to be executed if the condition in the `if` statement is `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if-else statement\n",
    "age = 16\n",
    "if age >= 18:\n",
    "    print(\"You are an adult.\")\n",
    "else:\n",
    "    print(\"You are a minor.\")  # This will be printed because the condition is False\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `if-elif-else` Statement\n",
    "\n",
    "The `elif` (short for \"else if\") statement can be used to check multiple conditions. If the condition in the if statement is `False`, the program checks the condition in the `elif` statement. If none of the conditions are `True`, the block of code inside the `else` statement is executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if-elif-else statement\n",
    "age = 20\n",
    "if age < 13:\n",
    "    print(\"You are a child.\")\n",
    "elif age < 18:\n",
    "    print(\"You are a teenager.\")\n",
    "else:\n",
    "    print(\"You are an adult.\")  # This will be printed because the first two conditions are False\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# while Loops\n",
    "\n",
    "In Python, the `while` loop is used to repeatedly execute a block of code as long as a condition is `True`. This is useful for tasks that require repetition until a certain condition is met."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Basic Syntax\n",
    "\n",
    "The basic syntax of a `while` loop is:\n",
    "\n",
    "```python\n",
    "while condition:\n",
    "    # code block\n",
    "```\n",
    "\n",
    "The `condition` is evaluated before each iteration of the loop. If the condition is `True`, the code block inside the `while` loop is executed. If the condition is `False`, the loop stops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example: counting from 1 to 5.\n",
    "count = 1\n",
    "while count <= 5:\n",
    "    print(count)\n",
    "    count += 1  # Increment count by 1\n",
    "\n",
    "# Example: printing the numbers from 1 to 10.\n",
    "number = 1\n",
    "while number <= 10:\n",
    "    print(number)\n",
    "    number += 1\n",
    "\n",
    "# Example: keep asking the user for a password until the correct one is entered.\n",
    "correct_password = \"python123\"\n",
    "user_password = \"\"\n",
    "\n",
    "while user_password != correct_password:\n",
    "    user_password = input(\"Enter the password: \")\n",
    "\n",
    "print(\"Access granted!\")\n",
    "\n",
    "\n",
    "# Example: ensure that the user enters a positive number.\n",
    "number = -1\n",
    "while number <= 0:\n",
    "    number = int(input(\"Enter a positive number: \"))\n",
    "\n",
    "print(f\"You entered: {number}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Infinite Loop\n",
    "\n",
    "An infinite loop runs forever unless stopped by a break statement or an external interruption. Be cautious with infinite loops, as they can cause your program to become unresponsive.\n",
    "\n",
    "```python\n",
    "while True:\n",
    "    user_input = input(\"Type 'exit' to stop: \")\n",
    "    if user_input == \"exit\":\n",
    "        break  # Exit the loop\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- While Loop with Else\n",
    "\n",
    "You can use an `else` block with a `while` loop. The `else` block is executed when the loop condition becomes `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "count = 1\n",
    "while count <= 5:\n",
    "    print(count)\n",
    "    count += 1\n",
    "else:\n",
    "    print(\"Counting finished.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classes\n",
    "\n",
    "In Python, a class is a blueprint for creating objects. Objects are instances of classes and can have attributes (data) and methods (functions). Classes allow you to bundle data and functionality together, providing a way to model real-world entities and their interactions in your programs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Syntax of a Class\n",
    "\n",
    "A class is defined using the `class` keyword, followed by the class name and a colon. The class name should follow the Pascal case naming convention (e.g., `MyClass`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining a simple class\n",
    "class Person:\n",
    "    pass  # The pass statement is used as a placeholder for future code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating an Object\n",
    "\n",
    "An object is created by calling the class as if it were a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating an object of the Person class\n",
    "person1 = Person()\n",
    "print(person1)  # Outputs: <__main__.Person object at xxxxxxxxxx>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The `__init__` Method\n",
    "\n",
    "The `__init__` method is a special method called a constructor. It is automatically called when an object is created and is used to initialize the object's attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name  # Instance attribute\n",
    "        self.age = age    # Instance attribute\n",
    "\n",
    "# Creating an object with attributes\n",
    "person1 = Person(\"Alice\", 30)\n",
    "print(person1.name)  # Outputs: Alice\n",
    "print(person1.age)   # Outputs: 30\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining Methods\n",
    "\n",
    "Methods are functions defined inside a class that describe the behaviors of the objects. They take `self` as the first parameter, which refers to the instance calling the method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    def greet(self):\n",
    "        print(f\"Hello, my name is {self.name} and I am {self.age} years old.\")\n",
    "\n",
    "# Creating an object and calling its method\n",
    "person1 = Person(\"Bob\", 25)\n",
    "person1.greet()  # Outputs: Hello, my name is Bob and I am 25 years old.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class Attributes\n",
    "\n",
    "Class attributes are shared across all instances of the class. They are defined outside the `__init__` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    species = \"Homo sapiens\"  # Class attribute\n",
    "\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "# Creating objects and accessing class attributes\n",
    "person1 = Person(\"Carol\", 22)\n",
    "person2 = Person(\"Dave\", 35)\n",
    "\n",
    "print(person1.species)  # Outputs: Homo sapiens\n",
    "print(person2.species)  # Outputs: Homo sapiens\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: Defining a Class for Students\n",
    "\n",
    "Let's create a `Student` class with attributes for name, age, and grade, and methods to display information and update the grade."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student:\n",
    "    def __init__(self, name, age, grade):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.grade = grade\n",
    "\n",
    "    def display_info(self):\n",
    "        print(f\"Student Name: {self.name}\")\n",
    "        print(f\"Age: {self.age}\")\n",
    "        print(f\"Grade: {self.grade}\")\n",
    "\n",
    "    def update_grade(self, new_grade):\n",
    "        self.grade = new_grade\n",
    "\n",
    "# Creating objects and using methods\n",
    "student1 = Student(\"Emma\", 16, \"A\")\n",
    "student1.display_info()\n",
    "\n",
    "student1.update_grade(\"A+\")\n",
    "student1.display_info()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inheritance\n",
    "\n",
    "Inheritance allows a class to inherit attributes and methods from another class. The class being inherited from is called the parent or base class, and the class inheriting from it is called the child or derived class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    def greet(self):\n",
    "        print(f\"Hello, my name is {self.name} and I am {self.age} years old.\")\n",
    "\n",
    "# Inheriting from the Person class\n",
    "class Student(Person):\n",
    "    def __init__(self, name, age, grade):\n",
    "        super().__init__(name, age)  # Call the constructor of the parent class\n",
    "        self.grade = grade\n",
    "\n",
    "    def display_info(self):\n",
    "        super().greet()  # Call the greet method of the parent class\n",
    "        print(f\"Grade: {self.grade}\")\n",
    "\n",
    "# Creating an object of the Student class\n",
    "student2 = Student(\"Frank\", 18, \"B\")\n",
    "student2.display_info()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Q&A on Python Basics\n",
    "\n",
    "Try to complete the following questions to test your understanding of Python basics. You can run the code cell to see the output. And the answers are provided in the code file [python_quizs_answer.py](./python_quizs_answer.py)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q1: Define variables and print them\n",
    "\n",
    "Define variables `student_name` and `student_age` with your name and age, respectively.\n",
    "\n",
    "Print the variables using the `print()` function by following the format: `My name is [student_name] and I am [student_age] years old.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define variables\n",
    "student_name = \n",
    "student_age = \n",
    "\n",
    "# Print the variables using the 'format()' method\n",
    "\n",
    "\n",
    "# Print the variables using the 'f-string' method\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q2: Calculate and print average score\n",
    "\n",
    "Calculate the average score of `math_score` and `science_score`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "math_score = 85\n",
    "science_score = 90\n",
    "\n",
    "# Calculate the average score\n",
    "average_score = \n",
    "\n",
    "# Print the average score\n",
    "print(f\"Average Score: {average_score}\") # Outputs: Average Score: 87.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q3: Work with lists\n",
    "\n",
    "- Create a list of `subjects` with the following items: \"Math\", \"Science\", \"English\".\n",
    "- Create a tuple of `grades` with the following items: \"A\", \"B+\", \"A-\".\n",
    "- Add a new subject \"History\" to the `subjects` list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "subjects = \n",
    "grades = \n",
    "\n",
    "# Add a new subject to the list and print the list\n",
    "# Your code here\n",
    "print(f\"Updated Subjects: {subjects}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q4: Create and modify a dictionary\n",
    "\n",
    "- Create a dictionary `student_info` with the following key-value pairs:\n",
    "  - \"name\": \"Alice\"\n",
    "  - \"age\": 20\n",
    "  - \"major\": \"Computer Science\"\n",
    "  - \"GPA\": 3.5\n",
    "\n",
    "- Update the `GPA` to 3.8 and add a new key-value pair \"year\": 2 to the `student_info` dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a dictionary with key-value pairs\n",
    "student_info = \n",
    "\n",
    "# Update the `GPA` to 3.8\n",
    "# Your code here\n",
    "\n",
    "# Add the key-value pair \"year\": 2\n",
    "# Your code here\n",
    "\n",
    "# Print the updated dictionary\n",
    "print(f\"Student Info:\\n{student_info}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q5: Create and manipulate a set\n",
    "\n",
    "- Create the set `unique_subjects` with the following items: \"Math\", \"Science\", \"English\", \"Math\".\n",
    "- Add a new subject \"History\" to the `unique_subjects` set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a set wiht duplicate subjects\n",
    "unique_subjects = {\"Math\", \"Science\", \"English\", \"Math\"}\n",
    "\n",
    "# Print the set of unique subjects\n",
    "print(f\"Unique Subjects: {unique_subjects}\")\n",
    "\n",
    "# Add a new item \"History\" to the set\n",
    "# Your code here\n",
    "\n",
    "# Print the updated set\n",
    "print(f\"Updated Set: {unique_subjects}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q6: Define and call a function to calculate grade\n",
    "\n",
    "- Define a function `calculate_grade` that takes `score` as a parameter and returns the grade based on the following criteria:\n",
    "  - 90 or above: \"A\"\n",
    "  - 80-89: \"B\"\n",
    "  - 70-79: \"C\"\n",
    "  - 60-69: \"D\"\n",
    "  - Below 60: \"F\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_grade(score):\n",
    "    if score >= 90:\n",
    "        return \"A\"\n",
    "    elif score >= 80:\n",
    "        return \"B\"\n",
    "    # Add the remaining conditions here\n",
    "\n",
    "print(calculate_grade(85))  # Expected output: B\n",
    "print(calculate_grade(70))  # Expected output: C\n",
    "print(calculate_grade(95))  # Expected output: A\n",
    "print(calculate_grade(55))  # Expected output: F"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q7: Use `if-elif-else` statements to provide feedback based on grade\n",
    "\n",
    "- Use the `calculate_grade` function to calculate the grade for a score of 85.\n",
    "- Then, use `if-elif-else` statements to provide feedback based on the grade:\n",
    "  - \"Excellent work!\" for \"A\"\n",
    "  - \"Good job!\" for \"B\"\n",
    "  - \"Keep trying!\" for other grades"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "student_grade = calculate_grade(85)\n",
    "\n",
    "# `if-elif-else` statements to print messages based on the student's grade\n",
    "# Your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q8: Implement a while loop for a countdown\n",
    "\n",
    "- Use a `while` loop to count down from 5 to 1 and print the countdown numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "countdown = 5\n",
    "\n",
    "# Implement a while loop to count down from 5 to 1\n",
    "# Your code here\n",
    "\n",
    "print(\"Blast off!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q9: Define a class and create an object\n",
    "\n",
    "  - Define a class `Student` with the `__init__` method that initializes the `name`, `age`, `average_score` attributes.\n",
    "\n",
    "  - And define a method `display_info` that prints the student's information, following the format: `Name: [name], Age: [age], Average Score: [average_score]`.\n",
    "\n",
    "  - And define a method `update_score` that takes `new_score` as a parameter and updates the `average_score`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student:\n",
    "    # the __init__ method with three parameters as instance attributes\n",
    "    def __init__(self, name, age, average_score):\n",
    "        # Your code here\n",
    "\n",
    "    # the display_info method to display the student's information\n",
    "    def display_info(self):\n",
    "        print(\n",
    "            f\"Name: {self.name}, Age: {self.age}, Average Score: {self.average_score}\"\n",
    "        )\n",
    "\n",
    "    # the update_score method to update the student's average score\n",
    "    def update_score(self, new_score):\n",
    "        # Your code here\n",
    "\n",
    "# Create a Student object\n",
    "student1 = Student(\"Alice Smith\", 16, 88.5)\n",
    "student1.display_info() # Expected output: Name: Alice Smith, Age: 16, Average Score: 88.5\n",
    "student1.update_score(90.0) # Update the average score\n",
    "student1.display_info() # Expected output: Name: Alice Smith, Age: 16, Average Score: 90.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q10: Define a subclass and create an object\n",
    "\n",
    "- Define a subclass `HighSchoolStudent` that inherits from the `Student` class.\n",
    "- Update the `__init__` method to include the `grade_level` attribute.\n",
    "- Update the `display_info` method to include the `grade_level`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HighSchoolStudent(Student):\n",
    "    def __init__(self, name, age, average_score, grade_level):\n",
    "        # Call the constructor of the parent class\n",
    "\n",
    "        # Add a new instance attribute for the grade level\n",
    "\n",
    "    def display_info(self):\n",
    "        # Call the display_info method of the parent class\n",
    "\n",
    "        # Display the grade level\n",
    "        print(f\"Grade Level: {self.grade_level}\")\n",
    "\n",
    "# Create an object of the HighSchoolStudent class and call its methods\n",
    "high_school_student = HighSchoolStudent(\"Bob Johnson\", 17, 85.0, 11)\n",
    "high_school_student.display_info()  # Output: Name: Bob Johnson, Age: 17, Average Score: 85.0, Grade Level: 11"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "summer_camp",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}