learning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python pour Passionnés : Mon Voyage d’Apprentissage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Guide Rapide - Environnement Virtuel Python (Windows)\n",
    "\n",
    "## 1. Installation Python\n",
    "1. Téléchargez Python sur [python.org](https://www.python.org/downloads/)\n",
    "2. **Important** : Cochez \"Add Python to PATH\" pendant l installation\n",
    "3. Vérifiez l installation en tapant dans CMD (Windows + R puis 'cmd') : \n",
    "```bash\n",
    "python --version\n",
    "```\n",
    "\n",
    "## 2. Créer l'environnement virtuel\n",
    "Ouvrez CMD (Windows + R puis tapez 'cmd') et tapez :\n",
    "```bash\n",
    "cd votre_dossier_projet\n",
    "python -m venv venv\n",
    "```\n",
    "\n",
    "## 3. Activer/Désactiver\n",
    "\n",
    "### Pour activer (dans CMD - Windows + R puis 'cmd')\n",
    "```bash\n",
    "C:\\> cd votre_dossier_projet\n",
    "C:\\votre_dossier_projet> venv\\Scripts\\activate\n",
    "(venv) C:\\votre_dossier_projet>\n",
    "```\n",
    "\n",
    "### Pour désactiver\n",
    "```bash\n",
    "(venv) C:\\votre_dossier_projet> deactivate\n",
    "C:\\votre_dossier_projet>\n",
    "```\n",
    "\n",
    "## 4. Installer des paquets (une fois l'environnement activé)\n",
    "```bash\n",
    "(venv) C:\\votre_dossier_projet> pip install nom_du_paquet\n",
    "```\n",
    "\n",
    "## 5. Sauvegarder/Installer les dépendances\n",
    "```bash\n",
    "# Sauvegarder les paquets installés\n",
    "(venv) C:\\votre_dossier_projet> pip freeze > requirements.txt\n",
    "\n",
    "# Installer depuis requirements.txt\n",
    "(venv) C:\\votre_dossier_projet> pip install -r requirements.txt\n",
    "```\n",
    "\n",
    "## À ne pas oublier\n",
    "- Toujours activer l'environnement avant de travailler\n",
    "- Ne pas mettre le dossier `venv` sur GitHub (Utiliser .gitigore)\n",
    "- Mettre à jour `requirements.txt` quand vous ajoutez des paquets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#finding the factorial of a given number\n",
    "num = 5  # Assuming num is defined somewhere\n",
    "def factorial(num):\n",
    "    # Your code goes here.\n",
    "    if num < 0 or isinstance(num, str):\n",
    "        print('None')\n",
    "    else:\n",
    "        result = 1\n",
    "        while num > 0:\n",
    "            result = result * num\n",
    "            num -= 1\n",
    "        return result\n",
    "\n",
    "print(factorial(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#finding of a year is a leap year\n",
    "def is_leap(year) -> bool:\n",
    "    \n",
    "    \"\"\"\n",
    "    Explanation:\n",
    "    The year can be evenly divided by 4, is a leap year, unless:\n",
    "    The year can be evenly divided by 100, it is NOT a leap year, unless:\n",
    "    The year is also evenly divisible by 400. Then it is a leap year.\n",
    "    \"\"\"\n",
    "    if year % 4 == 0:\n",
    "        if year % 100 == 0:\n",
    "            if year % 400 == 0:\n",
    "                return True\n",
    "            else:\n",
    "                return False\n",
    "        else:\n",
    "            return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "year = int(input(\"Enter a year :\"))\n",
    "print(is_leap(year))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Determining the time taken to execute the code using normal for loop and list comprehension\n",
    "import pprint\n",
    "import time\n",
    "\n",
    "\n",
    "print(\"Using normal for loop\")\n",
    "\n",
    "start_time_loop = time.time()\n",
    "\n",
    "pprint = pprint.PrettyPrinter()\n",
    "\n",
    "main_list = []\n",
    "\n",
    "for a in range(5):\n",
    "    l1 = []\n",
    "    for b in range(5):\n",
    "        l2 = []\n",
    "        for num in range(5):\n",
    "            l2.append(num)\n",
    "        l1.append(l2)\n",
    "    main_list.append(l1)\n",
    "\n",
    "pprint.pprint(main_list)\n",
    "\n",
    "end_time_loop = time.time()\n",
    "\n",
    "print(\"Using list comprehension\")\n",
    "\n",
    "start_time_cph = time.time()\n",
    "\n",
    "main_list = [[[num for num in range(5)] for b in range(5)] for a in range(5)]\n",
    "\n",
    "pprint.pprint(main_list)\n",
    "\n",
    "end_time_cph = time.time()\n",
    "\n",
    "if end_time_loop - start_time_loop > end_time_cph - start_time_cph:\n",
    "    print(\"List comprehension is faster\")\n",
    "else:\n",
    "    print(\"Normal for loop is faster\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#checking if a number is odd or even from 0-100\n",
    "even_list =[]\n",
    "odd_list =[]\n",
    "for idx in range(20):\n",
    "    if idx % 2 == 0:\n",
    "        even_list.append(idx)\n",
    "    else:\n",
    "        odd_list.append(idx)\n",
    "\n",
    "print(f\"The even numbers : {even_list}\")\n",
    "print(f\"The odd numbers : {odd_list}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Given a list of numbers, find the maximum and minimum values\n",
    "\n",
    "example_list =[88, 45, 23, 90, 12, 34, 56, 78, 98, 100]\n",
    "\n",
    "print(\"Method 1\")\n",
    "max_list_item = max(example_list)\n",
    "min_list_item = min(example_list)\n",
    "\n",
    "print(f\"Themaximum value is {max_list_item} and the minimum value is {min_list_item}\")\n",
    "\n",
    "print(\"Method 2\")\n",
    "example_list_sorted = sorted(example_list)\n",
    "max_list_item = example_list_sorted[-1]\n",
    "min_list_item = example_list_sorted[0]\n",
    "\n",
    "print(f\"Themaximum value is {max_list_item} and the minimum value is {min_list_item}\")\n",
    "\n",
    "print(\"Method 3\")\n",
    "\n",
    "def sort_list(list):\n",
    "    for i in range(len(list)):\n",
    "        for j in range(len(list)):\n",
    "            if list[i] < list[j]:\n",
    "                list[i], list[j] = list[j], list[i]\n",
    "    return list\n",
    "\n",
    "print(sort_list(example_list))\n",
    "print(\"From  the sorted list you can get the maxi ad mini values\")\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a Python function to check if a given string is a palindrome\n",
    "def check_palindrome(my_string):\n",
    "    \"\"\"\n",
    "    This function checks if a given string is a palindrome.\n",
    "    A palindrome is a word that reads the same backward as forward.\n",
    "    \"\"\"\n",
    "    my_string_rev = my_string[::-1]  # Reversing the string directly\n",
    "    if my_string == my_string_rev:\n",
    "        print(\"The word you entered is a palindrome.\")\n",
    "    else:\n",
    "        print(\"The word you entered is not a palindrome.\")\n",
    "    \n",
    "    print(f\"The original string is '{my_string}'\")\n",
    "    print(f\"The reversed string is '{my_string_rev}'\")\n",
    "\n",
    "check_palindrome(\"madam\")\n",
    "check_palindrome(\"moving\")\n",
    "check_palindrome(\"racecar\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Given a list of integers, find the sum of all positive numbers\n",
    "list_int = [-4, 5, 4, 85, -62, -8, 74, 90, -9, 40, 66, 9]\n",
    "\n",
    "print(\"Method 1.\")\n",
    "sum_of_positive = sum(x for x in range(len(list_int)) if x > 0)\n",
    "print(sum_of_positive)\n",
    "\n",
    "print(\"Method 2.\")\n",
    "sum_of_positive = 0\n",
    "for x in range(len(list_int)):\n",
    "    sum_of_positive = sum_of_positive + x\n",
    "print(sum_of_positive)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a program that takes a sentence as input and counts the number of words in it\n",
    "def count_num_words(sentence):\n",
    "    new_sentence = sentence.split()\n",
    "    num_of_words = len(new_sentence)\n",
    "    return num_of_words\n",
    "test_sentence = \"Hello, how are you doing?\"\n",
    "count_num_words(test_sentence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Implement a program that swaps the values of two variables\n",
    "def swap_values(a,b):\n",
    "    print(f\"values of 'a': {a} and 'b': {b} before swapping\")\n",
    "    temp = a\n",
    "    a = b\n",
    "    b = temp\n",
    "    print(f\"Values of 'a': {a} and 'b': {b} after swapping\")\n",
    "    \n",
    "swap_values(10,8)\n",
    "print(\"-\"*50)\n",
    "swap_values(55,40)\n",
    "print(\"-\"*50)\n",
    "swap_values(-4,99)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Given a list of names, concatenate them into a single string separated by spaces\n",
    "list = [\"John\", \"Doe\", \"Jane\", \"Doe\", \"James\", \"Smith\", \"Grace\", \"Mwangi\"]\n",
    "\n",
    "print(\"Method 1.\")\n",
    "\n",
    "def single_string(my_list):\n",
    "    single_str = \" \".join(list)\n",
    "    return single_str\n",
    "print(single_string(list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write a Python program to check if a given string is a pangram (contains all letters of the alphabet)\n",
    "letters_of_alphabet = [\n",
    "    \"a\", \"b\", \"c\", \"d\", \"e\", \"f\", \"g\", \"h\", \"i\", \"j\", \"k\", \"l\", \"m\",\n",
    "    \"n\", \"o\", \"p\", \"q\", \"r\", \"s\", \"t\", \"u\", \"v\", \"w\", \"x\", \"y\", \"z\"\n",
    "]\n",
    "print(\"Method 1.\")\n",
    "def check_pangram(word):\n",
    "    count = 0\n",
    "    found_letters = []\n",
    "    stripped_word = word.replace(\" \", \"\").lower() #remove spaces in case there are and change any uppercase to lower case.\n",
    "    for i in range(len(stripped_word)):\n",
    "        for j in range(len(letters_of_alphabet)):\n",
    "            if stripped_word[i] == letters_of_alphabet[j] and stripped_word[i] not in found_letters:\n",
    "                found_letters.append(stripped_word[i])  # Add the letter to found_letters to avoid duplicates\n",
    "                count = count + 1 #Increment count\n",
    "    if count == 26:\n",
    "        print(f\"The word, '{word}' is a pangram.\")\n",
    "    else:\n",
    "         print(f\"The word, '{word}' is not a pangram.\")\n",
    "        \n",
    "check_pangram(\"The quick brown fox jumps over a lazy dog\")\n",
    "\n",
    "print(\"Method 2.\")\n",
    "def check_pangram(word):\n",
    "    \"\"\"\n",
    "    This is a function to check if a given word is a pangram\n",
    "    A pangram is a sentence that contains all the letters of the alphabet at least once.\n",
    "    \"\"\"\n",
    "    stripped_word = word.replace(\" \", \"\").lower()  # Remove spaces and convert to lowercase.\n",
    "    \n",
    "    # Create a set to keep track of unique letters found\n",
    "    unique_letters = set()\n",
    "    \n",
    "    for char in stripped_word:\n",
    "        if char in letters_of_alphabet:\n",
    "            unique_letters.add(char)  # Add to set of unique letters\n",
    "    \n",
    "    # Check if the size of the unique_letters set is 26\n",
    "    if len(unique_letters) == 26:\n",
    "        print(f\"The word, '{word}' is a pangram.\")\n",
    "    else:\n",
    "        print(f\"The word, '{word}' is not a pangram.\")\n",
    "\n",
    "check_pangram(\"The quick brown fox jumps over a lazy dog\")\n",
    "        \n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Create a function to count the number of vowels in a given string\n",
    " \n",
    "vowels = [\"a\", \"e\", \"i\", \"o\", \"u\"]\n",
    "\n",
    "def count_num_vowels(word):\n",
    "    stripped_word = word.replace(\" \", \"\").lower()\n",
    "    count = 0\n",
    "    unique_vowels = set() #using a set to avoid duplicates of vowels\n",
    "    for v in stripped_word:\n",
    "        if v in vowels and v not in unique_vowels:\n",
    "            unique_vowels.add(v)\n",
    "            count = count + 1\n",
    "    print(f\"The number of vowels of '{word}' is {count} and the vowels are {unique_vowels} without duplicates. \")\n",
    "\n",
    "count_num_vowels(\"Hello, how are you doing\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write a program to check if a number is prime\n",
    "\n",
    "print(\"Method 1.\")\n",
    "def check_prime(num): #This fcunction does the reverse by checking if the number is divisible by any number other than 1 and itself\n",
    "    if num > 1:\n",
    "        for i in range(2, num):\n",
    "            if num % i == 0:\n",
    "                print(f\"{num} is not a prime number.\")\n",
    "                break\n",
    "        else:\n",
    "            print(f\"{num} is a prime number.\")\n",
    "    else:\n",
    "        print(f\"{num} is not a prime number.\")\n",
    "\n",
    "for i in range(1, 21):\n",
    "    check_prime(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Implement a program that converts a given number of minutes into hours and minutes\n",
    "\n",
    "def convert_minutes_to_hours(minutes):\n",
    "    hours = minutes // 60\n",
    "    minutes = minutes % 60\n",
    "    print(f\"{hours} hours and {minutes} minutes\")   \n",
    "    \n",
    "convert_minutes_to_hours(120)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Given a list of integers, find all the even numbers and store them in a new list\n",
    "random_list= [\n",
    "    44, 55, 66, 77, 88, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110\n",
    "]\n",
    "\n",
    "new_list = []\n",
    "\n",
    "print(\"Method 1 -> using a for loop and and  an 'if' statement\")\n",
    "\n",
    "for even_num in random_list:\n",
    "    if even_num % 2 == 0:\n",
    "        new_list.append(even_num)\n",
    "print(f\"The list of even if number is : {new_list}\")\n",
    "\n",
    "print(\"Method 2 -> using list comprehesion\")\n",
    "\n",
    "# new_list = [random_list[even_num] for even_num in range(len(random_list)) if random_list[even_num] % 2 == 0]\n",
    "print(\"The list of even if number is\",[random_list[even_num] for even_num in range(len(random_list)) if random_list[even_num] % 2 == 0]) #using normal print statement\n",
    "print(f\"The list of even if number is {[random_list[even_num] for even_num in range(len(random_list)) if random_list[even_num] % 2 == 0]}\") #using f-string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a function to find the square of each element in a given list\n",
    "def find_square(list):\n",
    "    square_list = [num ** 2 for num in list]\n",
    "    return square_list\n",
    "numbers = [4,7,8,944,9,9,10]\n",
    "find_square(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Create a program that generates the Fibonacci sequence up to a given number of terms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Given a list of names, print all names starting with the letter 'A'\n",
    "list_names = [\n",
    "    \"Francoise\", \"Florian\", \"Amina\", \"Asha\", \"Wissam\", \"Adele\", \"Adeola\", \"Simon\"\n",
    "]\n",
    "print(\"Method 1 -> Using a for loop and and 'if' statements\")\n",
    "list_names_with_a =[]\n",
    "for x in list_names:\n",
    "    if x[0].lower() == 'a':\n",
    "        list_names_with_a.append(x)\n",
    "print(list_names_with_a)\n",
    "\n",
    "print(\"Method 2 -> Using list comprehension\")\n",
    "print([list_names_with_a for list_names_with_a in list_names if list_names_with_a[0].lower() == 'a'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Implement a program that prints the multiplication table of a given number\n",
    "#here i decided to use a try and except block to handle the ValueError exception that may arise when the user enters a string or float instead of a number\n",
    "while True:\n",
    "    try:\n",
    "        number = int(input(\"Enter a number: \"))\n",
    "        print(\"The multiplication table of\", number, \"is\", [multiplication_table * number for multiplication_table in range(1, number + 1)])\n",
    "        break  # Exit the loop if input is valid\n",
    "    except ValueError as e:\n",
    "        print(e)\n",
    "        print(\"Please enter a valid number.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a loop that prints all prime numbers between 1 and 50\n",
    "\n",
    "list_number = [x for x in range(1, 50 + 1)] #or list_number = list(range(1, 51))\n",
    "\n",
    "def find_prime(num):\n",
    "    if num > 1:\n",
    "        for i in range(2, num):\n",
    "            if num % i == 0:\n",
    "                return None\n",
    "        else:\n",
    "            return num\n",
    "    else:\n",
    "        return None\n",
    "\"\"\"\n",
    "How filter(None, iterable) Works\n",
    "When you pass None as the first argument to filter,\n",
    "it tells Python to filter out all \"falsy\" values in the iterable.\n",
    "\"Falsy\" values include None, False, 0, \"\" (empty string), and empty\n",
    "collections like [] or {}. Only \"truthy\" values (values that are not None\n",
    "or other \"falsy\" values) are kept.\n",
    "\n",
    "Alternatively, you can use the lambda function to achieve the same result:\n",
    "list_of_prime_numbers = list(filter(lambda x: x is not None, map(find_prime, list_number)))\n",
    "\"\"\"\n",
    "list_of_prime_numbers = list(filter(None, map(find_prime, list_number))) \n",
    "print(list_of_prime_numbers)\n",
    "print(\"Method 2.\")\n",
    "\n",
    "# Function to check if a single number is prime\n",
    "def is_prime(num):\n",
    "    if num < 2:  # 0 and 1 are not prime numbers\n",
    "        return None\n",
    "    for factor in range(2, int(num ** 0.5) + 1):  # Check up to the square root of the number + 1 for factors\n",
    "        if num % factor == 0:\n",
    "            return None  \n",
    "    return num  # Return the number if it's prime\n",
    "\n",
    "# Use map to apply `is_prime` to each element in list_number\n",
    "# and filter to remove None values (non-primes)\n",
    "list_of_prime_numbers = list(filter(None, map(is_prime, list_number)))\n",
    "print(list_of_prime_numbers)\n",
    "\n",
    "print(\"Method 3.\")\n",
    "# Function to find prime numbers up to a specified limit\n",
    "lmit:int = 50\n",
    "def find_prime_numbers_up_to(limit):\n",
    "    for num in range(2, limit + 1):  # Start from 2, as 0 and 1 are not prime\n",
    "        for factor in range(2, int(num ** 0.5) + 1):\n",
    "            if num % factor == 0:\n",
    "                break  # Exit the loop if a factor is found\n",
    "        else:\n",
    "            print(num)  # This will print if no factor was found, meaning it's a prime\n",
    "\n",
    "# Example usage to find primes up to 50\n",
    "find_prime_numbers_up_to(50) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Given a list of words, count the number of words with more than five characters\n",
    "list_words = [\n",
    "    \"Hello\", \"Python\", \"Programming\", \"is\", \"fun\", \"and\", \"exciting\"\n",
    "]\n",
    "print(\"Method 1. -> Using filter and map functions with if statement\")\n",
    "def count_number_of_words(word):\n",
    "    if len(word) > 5:\n",
    "        return word\n",
    "    else:\n",
    "        return None \n",
    "\n",
    "words_with_more_than_five_chars = list(filter(None, map(count_number_of_words, list_words))) #filtering out the None values\n",
    "print(f\"Words with more than five characters: {words_with_more_than_five_chars}\")\n",
    "print(\"Method 2. -> Using list comprehension\")\n",
    "words_with_more_than_five_chars = [word for word in list_words if len(word) > 5]\n",
    "print(f\"Words with more than five characters: {words_with_more_than_five_chars}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the sum of digits of a given number\n",
    "number = 451 # Assuming number is defined somewhere\n",
    "sum_of_digits = sum([int(digit) for digit in str(number)])\n",
    "print(sum_of_digits)\n",
    "#alternatively let's decompose the code above\n",
    "number = 451\n",
    "number_str = str(number) # Convert number to a string, that's if number = 451, number_str = '451'\n",
    "digits = [int(digit) for digit in number_str] # Convert each digit to an integer\n",
    "sum_of_digits = sum(digits) # Sum the digits\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Given a list of numbers, create a function to find the sum of all positive numbers\n",
    "import random\n",
    "list_of_numbers = [ random.randint(-100, 100) for i in range(10)] # Generate a list of random numbers\n",
    "print(\"Method 1. -> Using a for loop and an if statement\")\n",
    "sum_of_positive_numbers = 0\n",
    "for number in list_of_numbers:\n",
    "    if number > 0:\n",
    "        sum_of_positive_numbers = sum_of_positive_numbers + number\n",
    "print(sum_of_positive_numbers)\n",
    "\n",
    "print(\"Method 2. -> Using list comprehension\")\n",
    "sum_of_positive_numbers = sum([number for number in list_of_numbers if number > 0])\n",
    "print(sum_of_positive_numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Given a list of words, concatenate them into a single string separated by spaces\n",
    "list_of_words = [\"John\", \"Doe\", \"Jane\", \"Doe\", \"James\", \"Smith\", \"Grace\", \"Mwangi\"]\n",
    "\n",
    "concatenated_words = \" \".join(list_of_words)\n",
    "print(concatenated_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write a Python program to find the length of the longest word in a sentence\n",
    "Given_sentence = \"The quick brown fox jumps over the lazy dog\"\n",
    "print(\"Method 1. -> Using the max() function\")\n",
    "def find_length(sentence):\n",
    "    for word in sentence:\n",
    "        return len(max(sentence.split(), key=len)) \n",
    "    \"\"\"\n",
    "    So basically, the code above splits the sentence into a list of words,\n",
    "    then finds the word with the maximum length using the max() function\n",
    "    and the key argument to specify the length of each word. \n",
    "    \"\"\"\n",
    "print(find_length(Given_sentence))\n",
    "\n",
    "print(\"Method 2. -> Using in-built functions\")\n",
    "list_of_words = Given_sentence.split() # Split the sentence into a list of words\n",
    "lengths = map(len, list_of_words) # Find the length of each word in the list\n",
    "print(max(lengths))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Create a function that takes a sentence as input and returns the sentence in reverse order\n",
    "Given_sentence = \"The quick brown fox jumps over the lazy dog\"\n",
    "def reverse_sentence(sentence):\n",
    "    sentence = sentence.split() # Split the sentence into a list of words\n",
    "    rev_list = sentence[::-1] # Reverse the list of words using slicing it can also be done using the reversed() function as shown below\n",
    "    # rev_list = list(reversed(sentence))\n",
    "    rev_sentence = \" \".join(rev_list)\n",
    "    #In summary, all above can be done in one line as : rev_sentence = \" \".join(list(reversed(sentence)))\n",
    "    return f\"The reversed sentence {rev_sentence}\"\n",
    "\n",
    "print(f\" The original sentence is {Given_sentence}\")\n",
    "print(reverse_sentence(Given_sentence))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a program that finds the common elements between two lists and stores them in a new list\n",
    "list1 = [1, 2, 3, 4, 5, 6]\n",
    "list2 = [4, 5, 6, 7, 8, 9]\n",
    "\n",
    "common_items = set()  # Using a set to avoid duplicates\n",
    "for idx in list1:\n",
    "    for idx2 in list2:\n",
    "        if idx2 == idx and idx not in common_items:\n",
    "            common_items.add(idx)\n",
    "            \n",
    "print(f\"The common items in {list1} and {list2} are {list(common_items)}\") #converting the set to a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write a Python program to count the occurrences of each element in a given list\n",
    "list_of_elements = [1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]\n",
    "list_of_elements2 = [\n",
    "    \"apple\", \"banana\", \"apple\", \"banana\", \"apple\", \"apple\", \"banana\", \"cherry\", \"date\", \"cherry\", \"date\", \"apple\", \"banana\"\n",
    "]\n",
    "\n",
    "def count_occurrences(elements):\n",
    "    occurrences = {} # Using a dictionary to store the occurrences\n",
    "    for element in elements:\n",
    "        if element in occurrences: # Check if the element is already in the dictionary\n",
    "            occurrences[element] =  occurrences[element] + 1 # Increment the count\n",
    "        else:\n",
    "            occurrences[element] = 1 # Add the element to the dictionary with a count of 1\n",
    "    return occurrences\n",
    "\n",
    "#using the in-built function map() to achieve the same result to iterate over the list and count the occurrences of each element\n",
    "print(count_occurrences(list_of_elements))\n",
    "print(count_occurrences(list_of_elements2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a function that takes a list of strings and returns the list sorted by the length of the strings\n",
    "list_of_strings = [\"apple\", \"banana\", \"cherry\", \"date\", \"elderberry\", \"fig\", \"grape\"]\n",
    "\n",
    "print(\"Method 1. -> Using a custom function to calculate the length of each string\")\n",
    "\n",
    "def calculate_len_string(strings):\n",
    "    lengths = {}\n",
    "    for string in strings:\n",
    "        lengths[string] = len(string)  # Calculate the length of each string and store it in a dictionary\n",
    "    return lengths \n",
    "\n",
    "# Calculate the length of each string and return a dictionary of lengths of each string\n",
    "lengths = calculate_len_string(list_of_strings)\n",
    "print(f\"Here are the lengths of each string in the dictionary form : {lengths}\")\n",
    "\n",
    "# Sort the list using the values from the dictionary\n",
    "sorted_list = sorted(list_of_strings, key=lambda string: lengths[string])\n",
    "print(f\"Sorted list of strings based on their length: {sorted_list}\")\n",
    "\n",
    "print(\"Method 2. -> Using the sorted() function with a key argument\")\n",
    "sorted_list = sorted(list_of_strings, key=len)\n",
    "print(sorted_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Some common operations on sets\n",
    "\n",
    "set1 = {1, 2, 3, 4, 5}\n",
    "set2 = {4, 5, 6, 7, 8}\n",
    "\n",
    "# Union of two sets : it's use to find the unique elements in both sets\n",
    "union_set = set1.union(set2) # or union_set = set1 | set2\n",
    "print(union_set)\n",
    "\n",
    "# Intersection of two sets : it's used to find the common elements in both sets\n",
    "intersection_set = set1.intersection(set2) # or intersection_set = set1 & set2\n",
    "print(intersection_set)\n",
    "\n",
    "# Difference of two sets : it's used to find the elements that are in set1 but not in set2\n",
    "difference_set = set1.difference(set2) # or difference_set = set1 - set2\n",
    "print(difference_set)\n",
    "\n",
    "# Symmetric difference of two sets : it's used to find the elements that are in set1 or set2 but not in both\n",
    "symmetric_difference_set = set1.symmetric_difference(set2) # or symmetric_difference_set = set1 ^ set2\n",
    "print(symmetric_difference_set)\n",
    "\n",
    "# Check if a set is a subset of another set : it's used to check if all elements of a set are in another set\n",
    "subset = {4, 5} # This is a subset of set1\n",
    "print(subset.issubset(set1))\n",
    "\n",
    "# Check if a set is a superset of another set : it's used to check if all elements of a set are in another set\n",
    "superset = {4, 5} # This is a superset of subset\n",
    "print(set1.issuperset(subset))\n",
    "\n",
    "# Add an element to a set\n",
    "set1.add(6)\n",
    "print(set1)\n",
    "\n",
    "# Remove an element from a set\n",
    "set1.remove(6)\n",
    "\n",
    "# Remove an element from a set without raising an error if the element is not present\n",
    "set1.discard(6)\n",
    "\n",
    "# Remove and return an arbitrary element from a set\n",
    "element = set1.pop()\n",
    "print(element)\n",
    "\n",
    "# Clear all elements from a set\n",
    "set1.clear()\n",
    "print(set1)\n",
    "\n",
    "# Delete a set\n",
    "del set1\n",
    "\n",
    "# check if sets have common elements\n",
    "set1 = {1, 2, 3}\n",
    "set2 = {4, 5, 6}\n",
    "if set1.isdisjoint(set2):\n",
    "    print(\"The sets have no common elements\")\n",
    "else:\n",
    "    print(\"The sets have common elements\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Given a list of dictionaries, find the dictionary with the highest value for a specific key\n",
    "list_of_dicts = [\n",
    "    {\"name\": \"John\", \"age\": 25},\n",
    "    {\"name\": \"Jane\", \"age\": 30},\n",
    "    {\"name\": \"James\", \"age\": 22},\n",
    "    {\"name\": \"Janet\", \"age\": 35}\n",
    "]\n",
    "# let's create a function to find the highest value\n",
    "print(\"Method 1. -> Using a custom function\")\n",
    "def find_highest_value(list_of_dicts, key):\n",
    "    max_value = 0  # Initialize to 0\n",
    "    max_dict = None # Initialize to None\n",
    "    for dictionary in list_of_dicts:\n",
    "        if dictionary[key] > max_value:\n",
    "            max_value = dictionary[key]\n",
    "            max_dict = dictionary\n",
    "    return max_dict\n",
    "\n",
    "max_dict = find_highest_value(list_of_dicts, 'age')\n",
    "print(f\"The dictionary with the highest value for 'age' is: {max_dict}\")\n",
    "\n",
    "print(\"Method 2. -> Using the max() function with a key argument\")\n",
    "\n",
    "max_dict = max(list_of_dicts, key=lambda x: x['age'])\n",
    "print(f\"The dictionary with the highest value for 'age' is: {max_dict}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write a Python program that counts the number of occurrences of each character in a given string using a dictionary\n",
    "given_string = \"Python Programming\"\n",
    "new_string = given_string.lower().replace(\" \", \"\")\n",
    "\n",
    "def count_number_occ(string):\n",
    "    my_dict = {}\n",
    "    for char in string:\n",
    "        if char in my_dict:\n",
    "            my_dict[char] = my_dict[char] + 1\n",
    "        else:\n",
    "           my_dict[char] = 1\n",
    "    return my_dict\n",
    "\n",
    "print(count_number_occ(new_string))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a function that takes a list of dictionaries and sorts them based on a specified key\n",
    "\n",
    "list_of_dicts = [ \n",
    "    {\"name\": \"John\", \"age\": 25},\n",
    "    {\"name\": \"Jane\", \"age\": 30},\n",
    "    {\"name\": \"James\", \"age\": 22},\n",
    "    {\"name\": \"Janet\", \"age\": 35}\n",
    "]\n",
    "\n",
    "print(\"Method1 without using a custom fucntion.\")\n",
    "sorted_dict = sorted(list_of_dicts, key=lambda x: x[\"age\"]) #sorting the list of dictionaries based on the age key\n",
    "print(f\"So the sorted dictionary in ascending order {sorted_dict}\") #in ascending order\n",
    "#now let's sort in descending order\n",
    "sorted_dict = sorted(list_of_dicts, key=lambda x: x[\"age\"], reverse=True) #sorting the list of dictionaries based on the age key\n",
    "print(f\"So the sorted dictionary in descending order {sorted_dict}\") #in descending order\n",
    "\n",
    "print(\"Method 2 using a custom function.\")\n",
    "def sort_dict(list_of_dicts, key, reverse=False):\n",
    "    return sorted(list_of_dicts, key=lambda x: x[key], reverse=reverse)\n",
    "\n",
    "sorted_dict = sort_dict(list_of_dicts, \"age\")\n",
    "print(f\"So the sorted dictionary in ascending order {sorted_dict}\") #in ascending order\n",
    "#now let's sort in descending order\n",
    "sorted_dict = sort_dict(list_of_dicts, \"age\", reverse=True)\n",
    "print(f\"So the sorted dictionary in descending order {sorted_dict}\") #in descending order"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Gestion des Variables Sensibles en Python\n",
    "\n",
    "## Configuration des Variables d'Environnement\n",
    "\n",
    "### Étapes de Configuration\n",
    "\n",
    "1. **Créer le fichier `.env`**\n",
    "   ```bash\n",
    "   touch .env  # Sur Linux/Mac\n",
    "   type nul > .env  # Sur Windows\n",
    "   ```\n",
    "\n",
    "2. **Installer python-dotenv**\n",
    "   ```bash\n",
    "   pip install python-dotenv\n",
    "   ```\n",
    "\n",
    "3. **Exemple de Fichier `.env`**\n",
    "   ```\n",
    "   API_KEY=votre_cle_api_secrete\n",
    "   DATABASE_PASSWORD=votre_mot_de_passe\n",
    "   ```\n",
    "\n",
    "### Code d'Utilisation\n",
    "\n",
    "```python\n",
    "import os\n",
    "from dotenv import load_dotenv\n",
    "\n",
    "# Charger les variables d'environnement\n",
    "load_dotenv()\n",
    "\n",
    "# Accéder aux variables sensibles\n",
    "api_key = os.getenv(\"API_KEY\")\n",
    "db_password = os.getenv(\"DATABASE_PASSWORD\")\n",
    "```\n",
    "\n",
    "### Configuration `.gitignore`\n",
    "\n",
    "```\n",
    "# Ignorer le fichier .env\n",
    ".env\n",
    "```\n",
    "\n",
    "## Bonnes Pratiques\n",
    "\n",
    "- Ne jamais partager votre fichier `.env`\n",
    "- Utilisez des variables d'environnement pour toutes les informations sensibles\n",
    "- Créez un fichier `.env.example` avec des clés factices comme modèle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Demonstration of how function can be used as a variable\n",
    "# Creating function for text processing example lowercasing, stripping, removing special characters, removing numbers, removing punctuation\n",
    "\n",
    "def lower_case(text):\n",
    "    return text.lower()\n",
    "\n",
    "def strip(text):\n",
    "    return text.strip()\n",
    "\n",
    "def remove_special_characters(text):\n",
    "    special_characters = \"!@#$%^&*()_+{}|:\\\"<>?`~\"\n",
    "    for char in special_characters:\n",
    "        text = text.replace(char, \"\")\n",
    "    return text\n",
    "\n",
    "def remove_numbers(text):\n",
    "    numbers = \"0123456789\"\n",
    "    for num in numbers:\n",
    "        text = text.replace(num, \"\")\n",
    "    return text\n",
    "\n",
    "def remove_punctuation(text):\n",
    "    punctuation = \",.;:\"\n",
    "    for punc in punctuation:\n",
    "        text = text.replace(punc, \"\")\n",
    "    return text\n",
    "\n",
    "# Create a function that applies a list of functions to a given text\n",
    "def process_text(text, functions):\n",
    "    for function in functions:\n",
    "        text = function(text)\n",
    "    return text\n",
    "\n",
    "# Define a list of functions to apply to the text\n",
    "text_processing_functions = [lower_case, strip, remove_special_characters, remove_numbers, remove_punctuation]\n",
    "\n",
    "# Define the text to process\n",
    "text = \" Customization:Delay: Change the delay by modifying the 10000 value in setTimeout().Content: Replace the text in the modal title, body, and buttons to suit your needs.Navigation: button with the appropriate link. Let me know if you need further assistance! \" \n",
    "\n",
    "# Process the text using the list of functions\n",
    "\n",
    "processed_text = process_text(text, text_processing_functions)\n",
    "print(processed_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A small illustration on how to create custom exceptions. \n",
    "\n",
    "class CustomError(Exception): #creating a custom exception by inheriting from the base Exception class\n",
    "    status_code = None\n",
    "    message = None\n",
    "    def __init__(self):\n",
    "        # Initialize with a custom error message\n",
    "        super().__init__(f\"The status code is {self.status_code} and the message is {self.message}\")\n",
    "\n",
    "class ServerError(CustomError): #creating a custom exception by inheriting from CustomError class\n",
    "    status_code = 500\n",
    "    message = \"Internal Server Error\"\n",
    "\n",
    "class ClientError(CustomError): #creating a custom exception by inheriting from CustomError class\n",
    "    status_code = 400\n",
    "    message = \"Bad Request\"\n",
    "\n",
    "class NotFoundError(CustomError): #creating a custom exception by inheriting from CustomError class\n",
    "    status_code = 404\n",
    "    message = \"Not Found\"\n",
    "\n",
    "def raise_error():\n",
    "    raise ServerError()\n",
    "\n",
    "# Using try-except to handle the raised exception\n",
    "try:\n",
    "    raise_error()\n",
    "except CustomError as e:\n",
    "    print(f\"Caught an error: {e}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# File Handling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write a program that reads a text file and prints its contents\n",
    "\n",
    "# Open the file in read mode\n",
    "with open(\"example.txt\", \"r\") as file:\n",
    "    # Read the contents of the file\n",
    "    file_contents = file.read()\n",
    "    print(file_contents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a new text file and write some content into it.\n",
    "\n",
    "with open(\"new_file.txt\", \"w\") as file:\n",
    "    file.write(\"This is a new file created using Python.\")\n",
    "\n",
    "# Read the contents of the new file\n",
    "with open(\"new_file.txt\", \"r\") as file:\n",
    "    file_contents = file.read()\n",
    "    print(file_contents)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write a Python program to copy the contents of one text file into another\n",
    "with open(\"example.txt\", \"r\") as file:\n",
    "    # Read the contents of the file\n",
    "    file_contents = file.read()\n",
    "    \n",
    "# Write the contents to a new file\n",
    "with open(\"new_file.txt\", \"a\", encoding=\"utf-8\") as file: #using the append mode to add the contents to the new file without overwriting the existing content\n",
    "    #I'm using the encoding=\"utf-8\" to avoid any encoding issues because i used the special character 😉 in the content\n",
    "    file.write(\"\\n------------ THIS CONTENT IS COPIED FROM EXAMPLE.TXT 😉 ---------- \\n\")\n",
    "    file.write(file_contents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "\n",
    "# Given a CSV file with student names and scores, find the student with the highest score\n",
    "def find_top_student(file_path):\n",
    "    try:\n",
    "        with open(file_path, \"r\") as file:\n",
    "            csv_reader = csv.reader(file)\n",
    "            next(csv_reader)  # Skip the header row\n",
    "            \n",
    "            # Find the student with the highest score\n",
    "            top_student = max(\n",
    "                csv_reader,\n",
    "                key=lambda row: int(row[2]) if row[2].isdigit() else float(\"-inf\"),\n",
    "            )\n",
    "            print(f\"The student with the highest score is {top_student[0]} with a score of {top_student[2]}\")\n",
    "    except FileNotFoundError:\n",
    "        print(f\"Error: The file '{file_path}' does not exist.\")\n",
    "    except (IndexError, ValueError) as e:\n",
    "        print(f\"Error processing the file: {e}\")\n",
    "\n",
    "# Call the function with the file path\n",
    "find_top_student(\"students.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Implement a program that reads a text file and counts the number of words and lines in it\n",
    "def count_number_of_words(file_path):\n",
    "    \"\"\"This function reads a text file and counts the number of words and lines in it.\n",
    "\n",
    "    Args:\n",
    "        file_path (path): The path to the text file.\n",
    "\n",
    "    Returns:\n",
    "        int: The number of lines and words in the file.\n",
    "    \"\"\"\n",
    "    line_count = 0\n",
    "    word_count = 0\n",
    "    try:\n",
    "        with open(file_path, \"r\") as file:\n",
    "            #putting each line of the file in a list called content\n",
    "            list_of_lines = file.readlines()\n",
    "            #counting the number of lines in the file\n",
    "            line_count = len(list_of_lines)\n",
    "            #counting the number of words in the file by splitting each line and counting the number of words in each line\n",
    "            # note : the split() method splits the string into a list where each word is a list item \n",
    "            word_count = sum(len(line.split()) for line in list_of_lines)\n",
    "            return line_count, word_count\n",
    "    except FileNotFoundError:\n",
    "        print(f\"Error: The file '{file_path} doesn't exist\")\n",
    "    except (IndexError, ValueError) as e:\n",
    "        print(f\"Error processing the file: {e}\")\n",
    "\n",
    "# Call the function with the file path\n",
    "file_path = \"example.txt\"\n",
    "line_count, word_count = count_number_of_words(file_path)\n",
    "print(f\"Number of lines: {line_count}\")\n",
    "print(f\"Number of words: {word_count}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a function that takes a list of sentences and writes them to a new text file, each on a new line\n",
    "list_of_sentences = [\n",
    "    \"This is the first sentence.\",\n",
    "    \"This is the second sentence.\",\n",
    "    \"This is the third sentence.\"\n",
    "]\n",
    "\n",
    "def add_sentences(file_path):\n",
    "    try:\n",
    "        with open(file_path, \"a\") as file:\n",
    "            file.write(\"\\n -------------- NEW SENTENCES -------------- \\n\")\n",
    "            # file.write(\"\\n\".join(list_of_sentences)) using the join() method to join the list of sentences and write them to the file\n",
    "            for sentence in list_of_sentences:\n",
    "                file.write(f\"{sentence}\\n\")\n",
    "    except FileNotFoundError:\n",
    "        print(f\"Error: The file '{file_path} doesn't exist\")\n",
    "    except (IndexError, ValueError) as e:\n",
    "        print(f\"Error processing the file: {e}\")\n",
    "    finally:\n",
    "        print(\"The sentences have been added to the file.\")\n",
    "\n",
    "# Call the function with the file path\n",
    "file_path = \"new_file.txt\"\n",
    "add_sentences(file_path)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Given a CSV file with employee details (name, age, salary), calculate the average salary of all employees\n",
    "def calculate_avg_salary(file_path):\n",
    "    try:\n",
    "        with open(file_path, \"r\") as file:\n",
    "            csv_reader = csv.reader(file)\n",
    "            next(csv_reader)  # Skip the header row, that is the first row (name, age, salary)\n",
    "            salaries = [float(row[2]) for row in csv_reader if row[2].replace(\".\", \"\").isdigit()]\n",
    "            # The use of the replace() method is to remove the decimal point in case the salary is a float number and the isdigit() method to check if the salary is a digit else it will be ignored\n",
    "            avg_salary = sum(salaries) / len(salaries)\n",
    "            print(f\"The average salary of all employees is: {avg_salary}\")\n",
    "    except FileNotFoundError:\n",
    "        print(f\"Error: The file '{file_path}' does not exist.\")\n",
    "    except (IndexError, ValueError) as e:\n",
    "        print(f\"Error processing the file: {e}\")\n",
    "    finally:\n",
    "        print(\"The average salary has been calculated.\")\n",
    "        \n",
    "# Call the function with the file path\n",
    "calculate_avg_salary(\"employees.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "\n",
    "def find_total_sales(file_path, product_name):\n",
    "    try:\n",
    "        with open(file_path, \"r\") as file:\n",
    "            csv_reader = csv.reader(file)\n",
    "            next(csv_reader)  # Skip the header row\n",
    "            total_sales = 0\n",
    "            for row in csv_reader:\n",
    "                try:\n",
    "                    if row[0].strip().lower() == product_name.strip().lower():\n",
    "                        total_sales += float(row[3])\n",
    "                except IndexError:\n",
    "                    print(f\"Skipping a malformed row: {row}\")\n",
    "                except ValueError:\n",
    "                    print(f\"Skipping a row with invalid revenue value: {row}\")\n",
    "            print(f\"The total sales revenue for '{product_name}' is: {total_sales}\")\n",
    "    except FileNotFoundError:\n",
    "        print(f\"Error: The file '{file_path}' does not exist.\")\n",
    "    except Exception as e:\n",
    "        print(f\"An unexpected error occurred: {e}\")\n",
    "\n",
    "# Call the function with the file path and product name\n",
    "find_total_sales(\"sales_data.csv\", \"Laptop\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Given a text file with a list of numbers, write a function that finds the sum of all numbers in the file\n",
    "def sum_numbers(file_path):\n",
    "    try:\n",
    "        with open(file_path, \"r\") as file:\n",
    "            sum = 0\n",
    "            numbers = file.readlines()\n",
    "            for number in numbers:\n",
    "                try:\n",
    "                    sum += float(number)\n",
    "                except ValueError:\n",
    "                    print(f\"Skipping a non-numeric value: {number}\")\n",
    "            print(f\"The sum of all numbers in the file {file_path} is: {sum}\")\n",
    "    except FileNotFoundError:\n",
    "        print(f\"Error: The file '{file_path}' does not exist.\")\n",
    "    except (IndexError, ValueError) as e:\n",
    "        print(f\"Error processing the file: {e}\")\n",
    "    finally:\n",
    "        print(\"End of program...\")\n",
    "\n",
    "# Call the function with the file path\n",
    "sum_numbers(\"numbers.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "from collections import defaultdict\n",
    "# defaultdict is used to create a dictionary with default values for keys that haven't been set yet\n",
    "# Therefore, you can access a key that hasn't been set without raising a KeyError\n",
    "# for example  d = defaultdict(list) d['key'] will return an empty list [] instead of raising a KeyError\n",
    "\n",
    "def calculate_avg_temp(file_path):\n",
    "    days_of_weeks = [\"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\", \"Sunday\"]\n",
    "    \n",
    "    try:\n",
    "        with open(file_path, \"r\") as temp_data:\n",
    "            csv_reader = csv.reader(temp_data)\n",
    "            next(csv_reader)  # Skip the header row\n",
    "            \n",
    "            # Use a dictionary to collect temperatures for each day\n",
    "            result_dict = defaultdict(list)\n",
    "            \n",
    "            for row in csv_reader:\n",
    "                day = row[0].strip()\n",
    "                temp = float(row[1])\n",
    "                if day in days_of_weeks:  # Ensure the day is valid\n",
    "                    result_dict[day].append(temp)\n",
    "            #printing the result_dict to see the dictionary\n",
    "            print(result_dict) # here each day is a key and the temperature is a value in a list \n",
    "            # Calculate the average temperature for each day\n",
    "            avg_temps = {day: sum(temps) / len(temps) for day, temps in result_dict.items()}\n",
    "            return avg_temps\n",
    "    \n",
    "    except FileNotFoundError:\n",
    "        print(f\"Error: The file '{file_path}' does not exist.\")\n",
    "    except (IndexError, ValueError) as e:\n",
    "        print(f\"Error processing the file: {e}\")\n",
    "    finally:\n",
    "        print(\"End of program...\")\n",
    "\n",
    "# Call the function with the file path\n",
    "result = calculate_avg_temp(\"temperature_data.csv\")\n",
    "if result:\n",
    "    print(\"Average Temperatures for Each Day:\")\n",
    "    for day, avg in result.items():\n",
    "        print(f\"{day}: {avg:.2f}°C\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "def extract_info_from_json(file_path):\n",
    "    try:\n",
    "        with open(file_path, \"r\") as file:\n",
    "            data = json.load(file)\n",
    "            \n",
    "            # Extract employee names\n",
    "            employee_names = [employee[\"name\"] for employee in data[\"employees\"]]\n",
    "            \n",
    "            # Extract exmployee ages\n",
    "            employee_ages = [employee[\"age\"] for employee in data[\"employees\"]]\n",
    "            \n",
    "            # Extract company location\n",
    "            company_location = data[\"company\"][\"location\"]\n",
    "            \n",
    "            return employee_names, employee_ages, company_location\n",
    "    \n",
    "    except FileNotFoundError:\n",
    "        print(f\"Error: The file '{file_path}' does not exist.\")\n",
    "    except KeyError as e:\n",
    "        print(f\"Missing key in JSON data: {e}\")\n",
    "    except json.JSONDecodeError:\n",
    "        print(\"Error decoding JSON file.\")\n",
    "\n",
    "# Example Usage\n",
    "file_path = \"data.json\"\n",
    "result = extract_info_from_json(file_path)\n",
    "if result:\n",
    "    employee_names, employee_ages, company_location = result\n",
    "    name_ages = dict(zip(employee_names, employee_ages)) # Combine names and ages into a dictionary\n",
    "    print(f\"The employee names and ages are: {name_ages}\")\n",
    "    print(\"Employee Names:\", employee_names)\n",
    "    print(\"Employee Ages:\", employee_ages)\n",
    "    print(\"Company Location:\", company_location)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You have a JSON file containing information about various products in a store. Each product has a name, category, price, and stock quantity.\n",
    "# Write a Python program that updates the stock quantity of a specific product in the JSON file.\n",
    "# The program should take the product name and the new stock quantity as input and update the JSON file with the new stock quantity.\n",
    "#  Calculate and print the total value of stock for \"Electronics\", \"Accessories\", and \"Furniture\". value of stock = price * stock quantity\n",
    "# list products in the givn price range 100€ - 500€\n",
    "\n",
    "import json\n",
    "\n",
    "#function to update stock quantity of a specific product in the JSON file\n",
    "def update_stock_quantity(file_path, product_name, new_stock_quantity):\n",
    "    try:\n",
    "        with open(file_path, \"r\") as file:\n",
    "            data = json.load(file)\n",
    "            #list the products in the JSON file\n",
    "            print(\"List of products in the JSON file:\")\n",
    "            for product in data[\"products\"]:\n",
    "                print(product[\"name\"])\n",
    "            # Update the stock quantity for the specified product\n",
    "            for product in data[\"products\"]:\n",
    "                if product[\"name\"] == product_name:\n",
    "                    product[\"stock_quantity\"] = new_stock_quantity\n",
    "                    break\n",
    "        # Write the updated data back to the file\n",
    "        with open(file_path, \"w\") as file:\n",
    "            json.dump(data, file, indent=4)\n",
    "        print(f\"Stock quantity for '{product_name}' updated to {new_stock_quantity}\")\n",
    "    except FileNotFoundError:\n",
    "        print(f\"Error: The file '{file_path}' does not exist.\")\n",
    "    except KeyError as e:\n",
    "        print(f\"Missing key in JSON data: {e}\")\n",
    "    except json.JSONDecodeError:\n",
    "        print(\"Error decoding JSON file.\")\n",
    "\n",
    "#function to calculate the total value of stock for each category\n",
    "\n",
    "def cal_value_stock(file_path):\n",
    "    try:\n",
    "        with open(file_path, \"r\") as file:\n",
    "            data = json.load(file)\n",
    "            # Initialize total value for each category\n",
    "            total_value_electronics = 0\n",
    "            total_value_accessories = 0\n",
    "            total_value_furniture = 0\n",
    "            # Calculate the total value of stock for each category\n",
    "            for product in data[\"products\"]:\n",
    "                category = product[\"category\"]\n",
    "                price = product[\"price\"]\n",
    "                stock_quantity = product[\"stock\"]\n",
    "                total_value = price * stock_quantity\n",
    "                if category == \"Electronics\":\n",
    "                    total_value_electronics += total_value\n",
    "                elif category == \"Accessories\":\n",
    "                    total_value_accessories += total_value\n",
    "                elif category == \"Furniture\":\n",
    "                    total_value_furniture += total_value\n",
    "            return total_value_electronics, total_value_accessories, total_value_furniture\n",
    "    except FileNotFoundError:\n",
    "        print(f\"Error: The file '{file_path}' does not exist.\")\n",
    "    except KeyError as e:\n",
    "        print(f\"Missing key in JSON data: {e}\")\n",
    "    except json.JSONDecodeError:\n",
    "        print(\"Error decoding JSON file.\")\n",
    "\n",
    "#function to list products in the given price range\n",
    "def list_products_in_price_range(file_path, min_price, max_price):\n",
    "    try:\n",
    "        with open(file_path, \"r\") as file:\n",
    "            data = json.load(file)\n",
    "            # List products in the given price range\n",
    "            for product in data[\"products\"]:\n",
    "                price = product[\"price\"]\n",
    "                if min_price <= price <= max_price: #checking if the price of the product is in the given price range\n",
    "                    return product[\"name\"]\n",
    "    except FileNotFoundError:\n",
    "        print(f\"Error: The file '{file_path}' does not exist.\")\n",
    "    except KeyError as e:\n",
    "        print(f\"Missing key in JSON data: {e}\")\n",
    "    except json.JSONDecodeError:\n",
    "        print(\"Error decoding JSON file.\")\n",
    "    \n",
    "\n",
    "# Example Usage\n",
    "file_path = \"products.json\"\n",
    "# Update the stock quantity for a specific product\n",
    "update_stock_quantity(file_path, \"Laptop\", 50)\n",
    "# Calculate the total value of stock for each category\n",
    "result = cal_value_stock(file_path)\n",
    "if result:\n",
    "    total_value_electronics, total_value_accessories, total_value_furniture = result\n",
    "    print(f\"Total Value of Stock for Electronics: {total_value_electronics}€\")\n",
    "    print(f\"Total Value of Stock for Accessories: {total_value_accessories}€\")\n",
    "    print(f\"Total Value of Stock for Furniture: {total_value_furniture}€\")\n",
    "# List products in the given price range\n",
    "product_name = list_products_in_price_range(file_path, 100, 500)\n",
    "if product_name:\n",
    "    print(f\"Product in the price range 100€ - 500€: {product_name}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a simple password generator\n",
    "\n",
    "import random\n",
    "import string\n",
    "\n",
    "lower_case = string.ascii_lowercase\n",
    "upper_case = string.ascii_uppercase\n",
    "digits = string.digits\n",
    "special_characters = string.punctuation\n",
    "\n",
    "password_length = int(input(\"Enter the length of the password: \"))\n",
    "\n",
    "def generate_password(password_length=8):\n",
    "    all_characters = lower_case + upper_case + digits + special_characters\n",
    "    password = \"\".join(random.sample(all_characters, password_length)) #using the sample() method to generate a random password based on the specified length\n",
    "    return password\n",
    "\n",
    "password = generate_password(password_length)\n",
    "print(f\"Generated Password: {password}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Documentation sur PyInstaller en Python\n",
    "\n",
    "## Installation de PyInstaller\n",
    "\n",
    "### Étapes d'Installation\n",
    "\n",
    "1. **Installer PyInstaller via pip**\n",
    "   ```bash\n",
    "   pip install pyinstaller\n",
    "   ```\n",
    "\n",
    "2. **Vérifier l'installation**\n",
    "   ```bash\n",
    "   pyinstaller --version\n",
    "   ```\n",
    "\n",
    "---\n",
    "\n",
    "## Création d'un Exécutable Simple\n",
    "\n",
    "### Commande de Base\n",
    "\n",
    "1. **Naviguer dans le dossier du projet contenant le script principal :**\n",
    "   ```bash\n",
    "   cd chemin/vers/votre/projet\n",
    "   ```\n",
    "\n",
    "2. **Créer un exécutable à partir du script Python :**\n",
    "   ```bash\n",
    "   pyinstaller main.py\n",
    "   ```\n",
    "\n",
    "   - Cela génère un dossier `dist/` contenant l'exécutable.\n",
    "   - Par défaut, plusieurs fichiers sont créés (exécutable + dépendances).\n",
    "\n",
    "---\n",
    "\n",
    "## Options Principales\n",
    "\n",
    "### 1. **Créer un Exécutable en Un Seul Fichier**\n",
    "\n",
    "Utilisez l'option `-F` (**--onefile**) pour regrouper tout dans un **seul fichier exécutable** :\n",
    "   ```bash\n",
    "   pyinstaller -F main.py\n",
    "   ```\n",
    "   **Résultat :**  \n",
    "   - Un seul fichier exécutable sera généré dans le dossier `dist/`.\n",
    "\n",
    "---\n",
    "\n",
    "### 2. **Masquer la Console pour les Applications GUI**\n",
    "\n",
    "Utilisez l'option `-W` (**--noconsole**) pour **masquer la fenêtre de console** (recommandé pour les applications avec interface graphique) :\n",
    "   ```bash\n",
    "   pyinstaller -W main.py\n",
    "   ```\n",
    "   **Résultat :**  \n",
    "   - Aucune fenêtre de terminal ne s'ouvrira lors de l'exécution.\n",
    "\n",
    "---\n",
    "\n",
    "### 3. **Combinaison des Options**\n",
    "\n",
    "Pour créer un **exécutable unique sans console** :\n",
    "   ```bash\n",
    "   pyinstaller -F -W main.py\n",
    "   ```\n",
    "\n",
    "---\n",
    "\n",
    "## Structure des Dossiers Générés\n",
    "\n",
    "Lorsque vous exécutez PyInstaller, il génère plusieurs dossiers et fichiers :\n",
    "\n",
    "```\n",
    "project/\n",
    "│\n",
    "├── main.py                 # Votre script Python principal\n",
    "├── build/                  # Fichiers temporaires générés par PyInstaller\n",
    "├── dist/                   # Contient l'exécutable final\n",
    "│   └── main.exe            # Fichier exécutable (Windows)\n",
    "├── main.spec               # Fichier de configuration PyInstaller\n",
    "└── __pycache__/            # Cache de Python\n",
    "```\n",
    "\n",
    "- **`dist/`** : Contient l'exécutable final.\n",
    "- **`build/`** : Dossier temporaire utilisé par PyInstaller.\n",
    "- **`main.spec`** : Fichier de configuration généré pour personnaliser la création.\n",
    "\n",
    "---\n",
    "\n",
    "## Exclure des Fichiers ou Modules Inutiles\n",
    "\n",
    "Si vous souhaitez **exclure des bibliothèques ou modules spécifiques** pour réduire la taille de l'exécutable :\n",
    "   ```bash\n",
    "   pyinstaller --exclude-module nom_du_module main.py\n",
    "   ```\n",
    "\n",
    "---\n",
    "\n",
    "## Personnalisation avec un Fichier `.spec`\n",
    "\n",
    "Le fichier `.spec` est généré automatiquement lors de la première utilisation. Vous pouvez l'éditer pour ajouter des options avancées.\n",
    "\n",
    "**Exemple de Fichier `.spec`** :\n",
    "```python\n",
    "# main.spec\n",
    "a = Analysis(\n",
    "    ['main.py'],\n",
    "    pathex=[],\n",
    "    binaries=[],\n",
    "    datas=[],\n",
    "    hiddenimports=[],\n",
    "    hookspath=[],\n",
    "    excludes=['module_a_exclure'],\n",
    ")\n",
    "pyz = PYZ(a.pure)\n",
    "exe = EXE(pyz, a.scripts, a.binaries, name='main', debug=False, strip=False, upx=True)\n",
    "```\n",
    "\n",
    "Pour relancer PyInstaller avec ce fichier `.spec` :\n",
    "   ```bash\n",
    "   pyinstaller main.spec\n",
    "   ```\n",
    "\n",
    "---\n",
    "\n",
    "## Ajouter une Icône à l'Exécutable\n",
    "\n",
    "Pour inclure une **icône personnalisée** (par exemple, `icon.ico`), utilisez l'option `--icon` :\n",
    "   ```bash\n",
    "   pyinstaller -F --icon=icon.ico main.py\n",
    "   ```\n",
    "\n",
    "---\n",
    "\n",
    "## Exemple de Commande Complète\n",
    "\n",
    "```bash\n",
    "pyinstaller -F -W --icon=icon.ico main.py\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "## Bonnes Pratiques\n",
    "\n",
    "- **Nettoyer les anciens fichiers** : Avant chaque exécution de PyInstaller, supprimez les dossiers `build/` et `dist/` pour éviter les conflits.\n",
    "   ```bash\n",
    "   rm -rf build/ dist/ *.spec\n",
    "   ```\n",
    "\n",
    "- **Tester sur une autre machine** : Testez l'exécutable sur une machine différente pour vous assurer que toutes les dépendances sont correctement incluses.\n",
    "\n",
    "- **Utiliser une icône** : Ajoutez toujours une icône pour rendre votre programme plus professionnel.\n",
    "\n",
    "---\n",
    "\n",
    "## Résumé des Options Utiles\n",
    "\n",
    "| Option             | Description                            |\n",
    "|--------------------|----------------------------------------|\n",
    "| `-F` / `--onefile` | Crée un exécutable unique             |\n",
    "| `-W` / `--noconsole` | Masque la console pour les applications GUI |\n",
    "| `--icon=icon.ico`  | Ajoute une icône personnalisée         |\n",
    "| `--exclude-module` | Exclut un module spécifique           |\n",
    "\n",
    "---\n",
    "\n",
    "## Exemple Final\n",
    "\n",
    "**Commandes complètes :**\n",
    "\n",
    "```bash\n",
    "cd chemin/vers/projet\n",
    "pyinstaller -F -W --icon=icon.ico main.py\n",
    "```\n",
    "\n",
    "**Résultat** :  \n",
    "Un fichier exécutable unique (`main.exe`) est généré dans le dossier `dist/`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programmation Orientée Objet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.12.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}