
Ma_variable =  10
print(Ma_variable)


x, y, z = "Chocolat", "Vanille", "Fraise"

print(x)
print(y)
print(z)


x = y = z = "Chocolat"

print(x)
print(y)
print(z)


type("Hello")


# Définition de plusieurs variables 
nom = "Alice"
age = 25       
taille = 1.70  
estVrai = True 
estFaux = False


print("la variable nom est de type :", type(nom))
print("la variable age est de type :",type(age))
print("la variable taille est de type :",type(taille))
print("la variable estVrai est de type :",type(estVrai))
print("la variable estFaux est de type :",type(estFaux))


# Depuis une chaîne de caractères :
chaine = "123"
nombre = int(chaine)  # Convertit la chaîne "123" en entier 123

## Depuis un booléen :
vrai = True
entier = int(vrai)  # Convertit True en 1

## Depuis un float :
flottant = 9.99
entier = int(flottant)  # Convertit 9.99 en 9 (troncature, pas d'arrondi)


## Depuis un entier ou un float :
nombre = 123
chaine = str(nombre)  # Convertit l'entier 123 en chaîne "123"

## Depuis un booléen :
faux = False
chaine = str(faux)  # Convertit False en "False"


## Depuis une chaîne de caractères** :
chaine = ""
booleen = bool(chaine)  # Convertit une chaîne vide en False
chaine2 = "Python"
booleen2 = bool(chaine2)  # Convertit "Python" en True

## Depuis un nombre** : 
nombre = 0
booleen = bool(nombre)  # Convertit 0 en False
nombre2 = 123
booleen2 = bool(nombre2)  # Convertit 123 en True


## Depuis une chaîne de caractères** :
chaine = "123.45"
flottant = float(chaine)  # Convertit la chaîne "123.45" en float 123.45

## Depuis un entier** :
entier = 100
flottant = float(entier)  # Convertit l'entier 100 en float 100.0

## Depuis un booléen** :
vrai = True
flottant = float(vrai)  # Convertit True en 1.0


somme = 10 + 5       # Résultat: 15
difference = 10 - 5  # Résultat: 5
produit = 10 * 5     # Résultat: 50
quotient = 10 / 5    # Résultat: 2.0


reste = 10 % 3       # Résultat: 1
puissance = 2 ** 3   # Résultat: 8
puissance_bis = 2 ^ 3


message = "Bonjour" + " le monde"  # Résultat: "Bonjour le monde"
echo = "Ha" * 3                    # Résultat: "HaHaHa"


# Initialisation de x
x = 5
print(x)


# Ajouter et assigner
x += 2  # x est maintenant 7
print(x)


# Soustraire et assigner
x -= 3  # x est maintenant 4
print(x)


# Multiplier et assigner
x *= 4  # x est maintenant 16
print(x)


# Diviser et assigner
x /= 2  # x est maintenant 8
print(x)


# Division entière et assigner
x //= 3  # x est maintenant 2
print(x)


# Modulo et assigner
x %= 3  # x est maintenant 2
print(x)


# Exponentielle et assigner
x **= 2  # x est maintenant 4
print(x)


# Ceci est un commentaire simple 

x = 5  # Ceci est un commentaire suivant une instruction

# Vous pouvez utiliser les commentaires pour expliquer
# ce que votre code est censé faire :
y = x + 2  # Ajout de 2 à x et stockage du résultat dans y


print("Bonjour, monde !")  # Affiche un message simple

nombre = 10
print(nombre)  # Affiche la valeur de la variable 'nombre'

# Vous pouvez aussi combiner du texte et des variables :
print("Le nombre est", nombre)  # Affiche "Le nombre est 10"


prenom = 'Marie'
age = 15
taille = 207

# Formatage de chaînes avec f-string pour une lisibilité améliorée :
print(f"Marie a {age}") 
print(f"{prenom}, est partie")


print(f"{prenom} mesure {taille} metres et a {age} ans")


print("{} a {} ans ".format(prenom, age))


prop = 2543276 / 678
print(prop)


print(f"le resultat est {prop:.3f}")


# Exemples d'opérateurs de comparaison
print("Opérateurs de comparaison:")
print(5 == 5)  # Égalité, renvoie True
print(5 != 2)  # Différent de, renvoie True
print(5 > 3)   # Supérieur à, renvoie True
print(5 < 8)   # Inférieur à, renvoie True
print(5 >= 3)  # Supérieur ou égal à, renvoie True
print(5 <= 8)  # Inférieur ou égal à, renvoie True


# opérateurs logiques 
## and 
(5 > 3) and (10 < 100)


not ((5 > 3) and (10 > 100))


## or 
(5 > 3) or (10 < 100)
(5 > 3) or (10 > 100)


# operateurs d'appartenance
# in et not in 
x = [5, 10, 24] 
10 in x 
10 not in x


a, b, c = 1, 10, 100
a < b < c


a > b < c


# condition
x = 40 

# Première condition : vérifie si x est inférieur à 10
if x < 10:
    print("x est inférieur à 10")
# Deuxième condition : vérifie si x est supérieur ou égal à 100 
elif x >= 100:
    print("x est supérieur ou égal à 100")
# Dernière condition : si toutes les conditions précédentes sont fausses
else:
    print("x est supérieur à 10 mais inférieur à 100")


# Initialisation des variables
x = 100 
y = 30 

# Première condition : vérifie si x est inférieur à 10 ET y est supérieur à 20
if (x < 10) and (y > 20):
    print("x est inférieur à 10 et y est supérieur à 20")
# Deuxième condition : vérifie si x est supérieur ou égal à 100 OU y est supérieur ou égal à 30
elif (x >= 100) or (y >= 30):
    print("x est supérieur ou égal à 100 ou y est supérieur ou égal à 30")
# Dernière condition : si toutes les conditions précédentes sont fausses
else:
    print("x est supérieur à 10")


liste = list(range(5))
liste


# Exemple de boucle for
for i in liste:
    print(i)


fruits = ["pomme", "banane", "mangue", "cerise"]
for fruit in fruits:
    print(fruit)


# print("Boucle for sur une liste:")
# ma_liste = [1, 2, 3, 4, 5]
# for element in ma_liste:
#     print(element)

nombres = [1, 2, 3, 4, 5]
for nombre in nombres:
    if nombre % 2 == 0:
        print(f"{nombre} est pair")
    else:
        print(f"{nombre} est impair")


# Boucle while avec break
print("\nBoucle while avec break:")
i = 1
while i <= 5:
    print(i)
    if i == 3:
        print("Break à 3")
        break
    i += 1


# Boucle while avec continue
print("\nBoucle while avec continue:")
i = 0
while i < 5:
    i += 1
    if i == 3:
         continue
     print(i)


# Boucle while avec else
print("\nBoucle while avec else:")
i = 1
while i <= 5:
    print(i)
    i += 1
else:
    print("La condition n'est plus vraie (i > 5)")


# Exemple de boucle while True
print("Boucle while True avec un mécanisme de sortie :")

compteur = 0
while True:
    compteur += 1
    print(compteur)

    # Interrompre la boucle si compteur atteint 5
    if compteur == 5:
        print("Compteur a atteint 5, sortir de la boucle.")
        break


saisi = int(input("Saisissez un chiffre: "))
while True:  
    if saisi == 5:
        print("Vous avez saisi la valeur 5")
        break
    else: 
        saisi = int(input("Saisissez un chiffre: "))


saisi_mot_de_passe = input("Saisissez votre mdp: ")

while True:  
    if saisi_mot_de_passe == "azerty":
        print("Login success")
        break
    else: 
        print("Login fail")
        saisi_mot_de_passe = input("Re-Saisissez votre mdp: ")


import random 

nombre_aleatoire = random.randint(1, 10)
nombre_aleatoire

citation = "Elle a dit \"Bonjour!\""
retour_ligne = "Ligne 1\nLigne 2"


# Définition chaines de caractères
chaine_simple = 'Bonjour'
longueur = len(chaine_simple) # 7
print(f"{chaine_simple}, 'la longueur est {longueur}")


chaine_simple[3]


chaine_double = "Python"
chaine_multiligne = """Ceci est une
chaîne sur plusieurs
lignes."""
print(chaine_double,"\n", chaine_multiligne)

# Acces aux éléments
premier_char = chaine_simple[0]  # 'B'
sous_chaine = chaine_double[1:4] # 'yth'
print(premier_char, "et",  sous_chaine)

# Concaténation 
salutation = chaine_simple + ", " + chaine_double # 'Bonjour, Python'
print(salutation)

# Répétition
echo = "echo " * 3  # 'echo echo echo '
print(echo)


# Méthodes str.isupper() et str.islower()
majuscules = "PYTHON"
minuscules = "python"

is_upper = majuscules.isupper()
is_lower = minuscules.islower()
print(is_upper)  # Résultat : True
print(is_lower)  # Résultat : True

# Méthode str.upper()
texte_upper = "python est génial".upper()
print(texte_upper)  # Résultat : "PYTHON EST GÉNIAL"

# Méthode str.lower()
texte_lower = "Python est GÉNIAL".lower()
print(texte_lower)  # Résultat : "python est génial"

# Méthode str.capitalize()
texte_capitalize = "python est génial".capitalize()
print(texte_capitalize)  # Résultat : "Python est génial"

# Méthode str.title()
texte_title = "python est génial".title()
print(texte_title)  # Résultat : "Python Est Génial"

# Méthode str.find(substring)
texte = "Python est génial"
position = texte.find("est")
print(position)  # Résultat : 7

# Méthode str.replace(old, new)
texte_replace = "Les pommes sont rouges.".replace("pommes", "bananes")
print(texte_replace)  # Résultat : "Les bananes sont rouges."

# Méthode str.split(separator)
texte_split = "apple orange banana".split(" ")
print(texte_split)  # Résultat : ["apple", "orange", "banana"]

# Méthode str.join(iterable)
elements = ["apple", "orange", "banana"]
texte_join = ", ".join(elements)
print(texte_join)  # Résultat : "apple, orange, banana"

# Méthode str.strip()
texte_strip = "   Bonjour   ".strip()
print(texte_strip)  # Résultat : "Bonjour"

# Méthode str.startswith(prefix)
texte_startswith = "Bonjour, comment ça va ?".startswith("Bonjour")
print(texte_startswith)  # Résultat : True

# Méthode str.endswith(suffix)
texte_endswith = "Leçon terminée.".endswith("terminée.")
print(texte_endswith)  # Résultat : True


# Définition de liste
ma_liste = [1, 2, 3, "Python", 3.14, True]
print(ma_liste)

premier_element = ma_liste[0]  # Accède au premier élément (1)
dernier_element = ma_liste[-1] # Accède au dernier élément (True)
print(premier_element,"\n", dernier_element)

 # Modifie le deuxième élément
ma_liste[1] = "deux" 
print(ma_liste)

# Concaténation et Répétition
combinee = ma_liste + ["autre", "liste"]
print(combinee)
repetee = [1, 2, 3] * 3
print(repetee)


nums = list(range(5)) # range est une fonction intégrée qui crée une liste d'entiers
nums                  # Renvoie "[0, 1, 2, 3, 4]"
nums[2:4]             # Obtenir une tranche de l'index 2 à 4 (exclusif); renvoie "[2, 3]"
nums[2:]              # Obtenir une tranche de l'index 2 jusqu'à la fin; renvoie "[2, 3, 4]"
nums[:2]              # Obtenir une tranche du début jusqu'à l'index 2 (exclusif); renvoie "[0, 1]"
nums[:]               # Obtenir une tranche de toute la liste; renvoie "[0, 1, 2, 3, 4]"
nums[:-1]             # Les indices de tranche peuvent être négatifs; renvoie "[0, 1, 2, 3]"
nums[::-1]            # Les indices de tranche peuvent être négatifs pour inverser l'ordre ; renvoie "[4, 3, 2, 1, 0]"


# Cas 1: source de même longueur
nums1 = [1, 2, 3]
nums1[1:] = [4, 5]     # Assigner une nouvelle sous-liste à une tranche
nums1                  # Renvoie "[1, 4, 5]"

# Cas 2: source de longueur différente
nums2 = nums1
nums2[1:] = [6]        # Assigner une nouvelle sous-liste à une tranche
nums2                  # Renvoie "[1, 6]"
id(nums1) == id(nums2) # Renvoie True car les listes sont mutables, c'est-à-dire qu'elles peuvent être modifiées sur place


a = [1, 2, 3] # Index maximal adressable: 2
a[:3]         # NE renvoie PAS d'erreur, renvoie plutôt [1, 2, 3]


# Création d'une liste de base
ma_liste = [1, 2, 3]
print(ma_liste)

# Utilisation de append()
ma_liste.append("quatre")
print("Après append(quatre):", ma_liste)


# Utilisation de extend()
ma_liste.extend([5, 6])
print("Après extend([5, 6]):", ma_liste)


# Utilisation de insert()
ma_liste.insert(1, 'elephant')
print("Après insert(1, 'elephant'):", ma_liste)


# Utilisation de remove()
ma_liste.remove('elephant')
print("Après remove('elephant'):", ma_liste)


# Utilisation de pop()
element_supprime = ma_liste.pop()
print("Après pop():", ma_liste, ", Élément supprimé:", element_supprime)


# Utilisation de clear()
ma_liste.clear()
print("Après clear():", ma_liste)


# Recréation de la liste pour les autres méthodes
ma_liste = [3, 1, 4, 2, 2]

# Utilisation de index()
index_de_4 = ma_liste.index(4)
print("Index de 4:", index_de_4)

# Utilisation de count()
compte_de_2 = ma_liste.count(2)
print("Nombre d'occurrences de 2:", compte_de_2)

# Utilisation de sort()
ma_liste.sort()
print("Après sort():", ma_liste)

# Utilisation de reverse()
ma_liste.reverse()
print("Après reverse():", ma_liste)

[nouvelle_expression for item in iterable if condition]


# récupérer tous les fruits avec un "a"
fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
newlist = []

for f in fruits:
    if "a" in f:
        newlist.append(f)

print(newlist)


newlist = [f for f in fruits if "a" in f ]
print(newlist)


nombre = [1, 10, 100]
nombre_carres = [x**2 for x in nombre]
nombre_carres


# Créer une liste des carrés des nombres de 0 à 9 :
carres = [x**2 for x in range(10)]


# Filtrer les nombres pairs dans une liste :
nombres_pairs = [x for x in range(10) if x % 2 == 0]


# Appliquer une fonction à tous les éléments :
noms_majuscules = [nom.upper() for nom in ["alice", "bob", "charlie"]]
noms_majuscules


list(map(lambda x: x + 10, [1, 2, 3]))          # Retourne [11, 12, 13]
list(map(max, [1, 2, 3], [4, 2, 1]))            # Retourne [4, 2, 3]
list(filter(lambda x: x > 5, [3, 4, 5, 6, 7]))  # Retourne [6, 7]


flattened = []
for row in matrix:
    for n in row:
        flattened.append(n)


flattened = [n for row in matrix for n in row]


flattened = [n for n in row for row in matrix]


# Définition d'un tuple
mon_tuple = (1, "a", 3.14)
mon_tuple


un_autre_tuple = 2, "b", 4.28
un_autre_tuple


mon_tuple[1]


# Tuple à Un Élément
tuple_singleton = 5,
tuple_singleton


# Tuple à Un Élément
tuple_singleton = (5,)

# Imbrication
tuple_imbrique = (1, (2, 3), (4, 5))

# Méthodes Utiles


longueur = len(mon_tuple)  # Retourne la longueur de mon_tuple, ici 3
longueur


compteur = mon_tuple.count("a")  # Compte le nombre de fois que 1 apparaît dans mon_tuple, ici 1
compteur


indice = mon_tuple.index("a")  # Trouve l'indice de "a" dans mon_tuple, ici 1
indice


# L'affectation n'est pas possible
# mon_tuple[1] = "b"


# Définition des ensembles
ensemble_a = {1, 2, 3, 4}
ensemble_b = {3, 4, 5, 6}
print(ensemble_a, ensemble_b)

# Seule une valeur est représentée
ensemble_c = {1, 1, 1}
print(ensemble_c)


# Opérations d'ensemble
union = ensemble_a | ensemble_b
intersection = ensemble_a & ensemble_b
difference_a = ensemble_a - ensemble_b
difference_b = ensemble_b - ensemble_a
difference_symetrique = ensemble_a ^ ensemble_b

# Affichage des résultats
print("Union :", union)
print("Intersection :", intersection)
print("Différence a :", difference_a)
print("Différence b :", difference_b)
print("Différence Symétrique :", difference_symetrique)


print(ensemble_a)

# Ajout et suppression
ensemble_a.add(7)
print("Après ajout :", ensemble_a)


ensemble_a.remove(1)
print("Après suppression :", ensemble_a)


ensemble_a.discard(2)  
ensemble_a


for i in range(1,5):
    for j in range(1,5):
        "*".join(j)
        print("*" * i * j)


# Définition d'un dictionnaire
personne = {"nom": "Alice", "age": 30}
autre_dict = dict(nom="Bob", age=25)


personne


# Ajout et Mise à Jour
personne["profession"] = "Développeur"
personne


# Mise à Jour de plusieurs clés
personne.update([('nom', "Romain"), ('profession', "Data Scientist")])
personne


# Utilisation de keys()
cles = personne.keys()
print("Clés:", cles)

# Utilisation de values()
valeurs = personne.values()
print("Valeurs:", valeurs)

# Utilisation de items()
paires = personne.items()
print("Paires clé-valeur:", paires)


# Utilisation de get()
nom_personne = personne.get("nom") 
age_personne = personne.get("age")

nom_personne, age_personne


ville = personne.get("ville")
ville


ville = personne.get("ville", "Non spécifiée")  # Retourne 'Non spécifiée' car 'ville' n'existe pas
print("Ville:", ville)


# Parcours des clés
print("\nParcours des clés:")
for cle in personne.keys():
    print(cle)

# Parcours des valeurs
print("\nParcours des valeurs:")
for valeur in personne.values():
    print(valeur)

# Parcours des paires clé-valeur
print("\nParcours des paires clé-valeur:")
for cle, valeur in personne.items():
    print(cle, ":", valeur)


print("\nParcours des paires clé-valeur avec enumerate:")
for index, (cle, valeur) in enumerate(personne.items()):
    print(f"Index {index}: Clé = {cle}, Valeur = {valeur}")


personne


# Suppression
del personne["age"]


personne


profession = personne.pop("profession")


profession


personne


flipped = {}
original = {"a": 0, "b": 5, "c": 6, "d": 7, "e": 11, "f": 19}
for key, value in original.items():
    flipped[value] = key

flipped


flipped = {value: key for key, value in original.items()}


nums = [0, 1, 2, 3, 4]
even_num_to_square = {x: x ** 2 for x in nums if x % 2 == 0}
print(even_num_to_square)


{x: x**2 for x in range(5)}

def ma_fonction():
    # Ici, nous mettons le code que la fonction exécutera.


def saluer(nom):
    print(f"Bonjour, {nom}!")


saluer(nom = "Paul")
saluer(nom = "Ményssa")
saluer(nom = "Kévin")
saluer(nom = "Axel")


def affiche_message(message):
    print(f"Message reçu : {message}")

affiche_message("Bonjour, ca  va ?")
affiche_message("Python c'est cool!")


def additionner(a, b):
    somme = a + b
    print(f"La somme de {a} et {b} est {somme}")


additionner(a = 5, b = 3)
additionner(5, 3)


additionner(b = 10, a = 67)


def division(a, b):
    quotient = a / b
    print(f"Le quotient de {a} et {b} est {quotient}")

division(a = 5, b = 3)
division(b = 3, a = 5)

division(3, 5)
division(5, 3)


def puissance(base, exposant):
    resultat = base ** exposant
    print(f"{base} élevé à la puissance {exposant} est égal {resultat}")
    
puissance(exposant = 2, base =  3)


import math

def perimetre_cercle(rayon):
    perimetre = 2 * math.pi * rayon
    print(f"Le périmètre d'un cercle de rayon {rayon} est {perimetre:.2f}")

perimetre_cercle(5)

def ma_fonction(param1, param2=42):
    print(f"Paramètre 1 : {param1}, Paramètre 2 : {param2}")


def ma_fonction(param1, param2=42):
    print(f"Paramètre 1 : {param1}, Paramètre 2 : {param2}")


ma_fonction(2)


ma_fonction(2, 30)

def ma_fonction():
    return "valeur retournée"


def divison_par_deux(a, b = 2):
    print( a / b )

resultat = divison_par_deux(5)
print(resultat)


def divison_par_deux(a, b = 2):
    return a / b

resultat = divison_par_deux(5)
print(resultat)


def carre(nombre):
    return nombre * nombre

resultat = carre(4)
print(resultat)  # Affichera 16

def celsius_en_fahrenheit(celsius):
    return (celsius * 9/5) + 32

temperature_fahrenheit = celsius_en_fahrenheit(0)
print(temperature_fahrenheit)  # Affichera 32

def est_pair(nombre):
    return nombre % 2 == 0

resultat = est_pair(10)
print(resultat)  # Affichera True

def maximum(a, b):
    if a > b:
        return a
    else:
        return b


max_nombre = maximum(10, 20)
print(max_nombre)  # Affichera 20


x = "global"  # Variable globale
x


def ma_fonction():
    x = "local"  # Variable locale
    print(x)

ma_fonction()
x


# le mot-clé `global` est utilisé pour modifier la variable globale
#  `z` à l'intérieur de la fonction `modifier_globale`.

z = 10

def modifier_globale():
    global z
    z = 20

print(z)  # Affiche 10
modifier_globale()
print(z)  # Affiche 20


# Les arguments mot-clé permettent de passer des arguments
#  à une fonction en spécifiant le nom du paramètre.
def ma_fonction(nom, age):
    print(f"Nom : {nom}, Âge : {age}")

ma_fonction(age=25, nom="Alice")


def multiplication(a, b, c, d, e, f):
    return a * b

multiplication(2, 3)


import numpy as np
# arguments arbitraire on ne connait pas le nombre de parametre à l'avance
def multiplication(*nombre):
    res = np.prod(nombre)
    return res


multiplication(4, 3, 4, 90)


def multiplication(*nombre):
    print(nombre[0]*nombre[1]*nombre[2]*nombre[3])


multiplication(4, 3, 4, 90)


def param_args(*parametres):
    print(parametres[0]*parametres[1])
    print(f"Message : {parametres[2]}")
    
param_args(2, 3, "Salut!")


args_tuple = (5, 6, 8, 9)
nombre_args(*args_tuple) # mettre etoile pour le tuple


# pratique pour définir des clé d'arguments
def nombre_kwarg(**nombre):
    print('Mon age est : ' + nombre['age'] + ' ans' + ' et ma taille est : ' + nombre["taille"] + ' metres')

nombre_kwarg(age  = '15', taille = '1.65', profession = " Dev")


# `args` est un tuple contenant tous les arguments positionnels
# `kwargs` est un dictionnaire contenant tous les arguments nommés.

def ma_fonction(*args, **kwargs):
    print("args:", args)
    print("kwargs:", kwargs)

ma_fonction(1, 2, 3, nom="Alice", age=25)

def ma_fonction():
    """
    Description de ce que fait la fonction.
    Peut inclure des détails sur les paramètres et la valeur de retour.
    """
    # corps de la fonction


# fonction qui renvoie un nombre à la puissance
def nombre_puissance(nombre, puissance): 
    # documenter le code
    """
    cette fonction calcule un nombre à la puissance et retourne le résultat.    
    Parameters:    
    nombre    (int): le premier nombre 
    puissance (int): le deuxième nombre    
    Returns   (int): le resultat nombre a la puissance     
    
    """
    return nombre ** puissance

# interaction  avec un utilisateur 
num = int(input("Saississez un nombre entier : "))
power = int(input("Saississez une puissance : "))

print("Le résultat est :", nombre_puissance(nombre = num, puissance = power))


c_to_f = lambda x: (x * 9/5) + 32 
c_to_f(0)


people = [{'name': 'Alice', 'age': 25}, 
          {'name': 'Bob', 'age': 30}, 
          {'name': 'Charlie', 'age': 20}]
sorted(people, key=lambda x: x['age'])


ma_liste = ['abcd', 'abc', 'a', 'ab', 'abcde']
sorted(ma_liste, key=lambda x: len(x))


carre  = lambda x: x**2
liste_carre = [carre(nombre) for nombre in [5, 9, 10]]
liste_carre

liste_carre = [(lambda x: x**2)(nombre) for nombre in [5, 9, 10]]
liste_carre


personnes = [
  {"nom": "Alice", "age": 25},
  {"nom": "Bob", "age": 30},
  {"nom": "Charlie", "age": 20},
]

personnes.sort(key=lambda personne: personne["age"])

print(personnes)


produits = [
  {"nom": "Produit 1", "en_stock": True},
  {"nom": "Produit 2", "en_stock": False},
  {"nom": "Produit 3", "en_stock": True},
]

produits_en_stock = list(filter(lambda produit: produit["en_stock"], produits))

print(produits_en_stock)


**Lambda avec Map et Filter**

Les fonctions map et filter de Python sont presque toujours associées à des expressions lambda. 
Il est courant de voir des questions sur StackOverflow demandant "qu'est-ce que lambda" répondre avec des exemples de code comme celui-ci :


numbers = [2, 1, 3, 4, 7, 11, 18]

# Appliquer la fonction map pour obtenir les carrés de chaque élément de numbers
squared_numbers = map(lambda n: n**2, numbers)

# Appliquer la fonction filter pour obtenir les nombres impairs de numbers
odd_numbers = filter(lambda n: n % 2 == 1, numbers)

# Afficher les résultats
print("Squared numbers:", squared_numbers)
print("Odd numbers:", odd_numbers)


# Afficher les résultats
print("Numbers:", numbers)
print("Squared numbers:", list(squared_numbers))
print("Odd numbers:", list(odd_numbers))


def nom():
    prenom = input("Nom :")
    if prenom == "Ményssa":
        return f'ok'
    else:
        nom()
nom()


def countdown(n):
    if n <= 0:
        print("Lancement terminé!")
    else:
        print(n)
        countdown(n - 1)

countdown(5)


def recursive_sum(arr):
    if len(arr) == 0:
        return 0
    else:
        return arr[0] + recursive_sum(arr[1:])

my_list = [1, 2, 3, 4, 5]
print("La somme des éléments de la liste est:", recursive_sum(my_list))


def mon_generateur():
    yield 1
    yield 2
    yield 3

# Utilisation du générateur
gen = mon_generateur()
print(next(gen)) # Affiche : 1
print(next(gen)) # Affiche : 2
print(next(gen)) # Affiche : 3
print(next(gen)) # `StopIteration`


def pairs_infinis():
    n = 0
    while True:
        yield n
        n += 2

# Utilisation du générateur
gen = pairs_infinis()

for _ in range(10):
    print(next(gen)) # Affiche : 0, 2, 4, 6, 8


def fibonacci(n):
    sequence = [0, 1]
    while len(sequence) < n:
        sequence.append(sequence[-1] + sequence[-2])
    return sequence

# Utilisation de la fonction
print(fibonacci(10))  # Affiche les 10 premiers nombres de la séquence Fibonacci


def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# Utilisation du générateur
gen = fibonacci()
for _ in range(10):
    print(next(gen)) # Affiche les 10 premiers nombres de la séquence Fibonacci


import random
import string

def chaine_aleatoire(longueur):
    while True:
        yield ''.join(random.choices(string.ascii_letters, k=longueur))

# Utilisation du générateur
gen = chaine_aleatoire(5)
for _ in range(3):
    print(next(gen)) # Affiche 3 chaînes de 5 caractères aléatoires


def decorateur(fonction):
    def fonction_decoration():
        print("Début de la fonction décorée")
        fonction()
        print("Fin de la fonction décorée")
    return fonction_decoration

@decorateur
def ma_fonction():
    print("Corps de ma fonction")

# Utilisation de la fonction décorée
ma_fonction()


def decorateur_args(argument):
    def decorateur(fonction):
        def fonction_decoration():
            print("Début de la fonction décorée avec l'argument :", argument)
            fonction()
            print("Fin de la fonction décorée avec l'argument :", argument)
        return fonction_decoration
    return decorateur

@decorateur_args("mon_argument")
def ma_fonction():
    print("Corps de ma fonction")

# Utilisation de la fonction décorée
ma_fonction()


ma_liste = ["A", 3, "serpent"]
element = ma_liste[5]  # IndexError car l'index 5 n'existe pas dans une liste de taille 3


nombre = int("123373829173487472474")
nombre


nombre = int("abc")  # ValueError car "abc" ne peut pas être converti en entier


somme = 10 + 5 
somme


"message" + " : voici mon texte"


somme = "texte" + 5  # TypeError car on ne peut pas ajouter une chaîne de caractères et un entier


somme = 5  + "5"


# with open("../data/Orgueil_et_Prejuges.txt", "r", encoding = 'utf-8') as fichier:
#     contenu = fichier.read()  

# print(contenu)


with open("fichier_inexistant.txt", "r") as fichier:
    contenu = fichier.read()  # FileNotFoundError si "fichier_inexistant.txt" n'existe pas


resultat = 10 / 0  # ZeroDivisionError car on ne peut pas diviser par zéro


def ma_fonction():
    variable_a_afficher = "Bonjour"
    print(variable_a_afficher)

ma_fonction()
ma_fonction()
ma_fonction()


print(variable_a_afficher)  # NameError car 'variable_a_afficher' n'est pas définie en dehors de la fonction

try:
    # Bloc de code à essayer
    result = 10 / 0
except ZeroDivisionError:
    # Ce bloc est exécuté en cas d'erreur ZeroDivisionError
    print("Division par zéro !")


result = 10 / 0


try:
    # Bloc de code à essayer
    result = 10 / 0
except ZeroDivisionError:
    # Ce bloc est exécuté en cas d'erreur ZeroDivisionError
    print("Division par zéro !")


def gestion_index_error(liste, index):
    try:
        return liste[index]
    except IndexError as e:
        return f"Ce n'est pas possible, Erreur d'index  : {e}"

# Test
ma_liste = ["A", 3, "serpent"]
print(gestion_index_error(ma_liste, 1))
print(gestion_index_error(ma_liste, 5))


def conversion_en_entier(entree):
    try:
        return int(entree)
    except ValueError as e:
        return f"La conversion n'est pas possible, Erreur de valeur : {e}"

# Test
val_entree = "190"
print(conversion_en_entier(val_entree))
val_entree = "Robert"
print(conversion_en_entier(val_entree))


def additionner(a, b):
    try:
        return a + b
    except TypeError as e:
        return f"Erreur de type : {e}"

# Test
print(additionner(2, 5))
print(additionner("texte", 5))


def lire_fichier(nom_fichier):
    try:
        with open(nom_fichier, "r", encoding = 'utf-8') as fichier:
            return fichier.read()
    except FileNotFoundError as e:
        return f"Erreur de fichier non trouvé : {e}"

# Test
# data = lire_fichier("../data/Orgueil_et_Prejuges.txt")
# print(data)

data = lire_fichier("../data/fichier_inexistant.txt")
print(data)


def diviser(a, b):
    try:
        return a / b
    except ZeroDivisionError as e:
        return f"Erreur de division par zéro : {e}"

# Test
print(diviser(10, 0))


def acceder_variable(nom_variable):
    try:
        return eval(nom_variable) # renvoie contenu de la variable
    except NameError as e:
        return f"Erreur de nom : {e}"

# Test   
print(acceder_variable("val_entree")) 
print(acceder_variable("variable_inexistante"))


def conversion_en_entier(chaine):
    try:
        return int(chaine)
    except ValueError as e:
        return f"Erreur de valeur : {e}"

def additionner(a, b):
    try:
        return a + b
    except TypeError as e:
        return f"Erreur de type : {e}"

def convertir_et_additionner(chaine1, chaine2):
    valeur1 = conversion_en_entier(chaine1)
    valeur2 = conversion_en_entier(chaine2)

    # Vérification si les conversions se sont bien passées
    if isinstance(valeur1, int) and isinstance(valeur2, int):
        return additionner(valeur1, valeur2)
    else:
        # Retourne les messages d'erreur si la conversion a échoué
        return valeur1 if isinstance(valeur1, str) else valeur2

# Test
print(convertir_et_additionner("3", "4"))  
print(convertir_et_additionner(3.8, "4"))  
# print(convertir_et_additionner("a", "4"))

try:
    # Tentative d'exécution de code
    ...
except TypeError:
    # Gestion de TypeError
    ...
except ValueError:
    # Gestion de ValueError
    ...


def operation_complexe(a, b, c):
    try:
        resultat = (a + b) / c
        return resultat
    except TypeError as e:
        return f"Erreur de type : {e}"
    except ZeroDivisionError as e:
        return f"Erreur de division par zéro: {e}"
    except Exception as e:
        return f"Autre erreur : {e}"

# Exemple d'utilisation

print(operation_complexe(1, 3, 2))  
print(operation_complexe(1, 2, 0))  
print(operation_complexe(1, "deux", 3))


def calculer_division(a, b):
    try:
        resultat = a / b
        return resultat
    except ZeroDivisionError:
        return "Une division par zéro a été tentée."
    finally:
        print("Opération terminée (réussie ou non).")
        return a + b

# Exemple d'utilisation
print(calculer_division(10, 2))  # Pas d'erreur, affiche le résultat et le message de finally
print(calculer_division(10, 0))  # Attrape ZeroDivisionError, affiche le message d'erreur et le message de finally


def exemple_finally():
    try:
        fichier = open("../data/Orgueil_et_Prejuges.txt", "r")
        contenu = fichier.read()
        return contenu
    except FileNotFoundError as e:
        return f"Erreur : {e}"
    finally:
        fichier.close()
        print("Fichier fermé.")

# Exemple d'utilisation
print(exemple_finally())


def exemple_else(chaine):
    try:
        num = int(chaine)
    except ValueError:
        return "Ce n'est pas un nombre valide."
    else:
        return f"Conversion réussie : {num}"

# Exemple d'utilisation
print(exemple_else("1233717237"))
print(exemple_else("abc"))


def division_avec_verification(a, b):
    try:
        resultat = a / b
    except ZeroDivisionError:
        return "Une division par zéro a été tentée."
    else:
        if resultat > 50:
            return "Le résultat est étonnamment grand."
    finally:
        print("Opération de division terminée (réussie ou non).")


# Exemple d'utilisation
print(division_avec_verification(1000, 10))  # Division réussie, vérification dans 'else', puis 'finally'


print(division_avec_verification(10, 0))    # Attrape ZeroDivisionError, puis exécute 'finally'


def diviser_par_deux(n):
    assert n % 2 == 0, "Le nombre doit être pair."
    return n / 2


# Exemple d'utilisation
print(diviser_par_deux(10))  # Fonctionne bien


print(diviser_par_deux(3))  # Déclenche AssertionError


def ma_fonction(x):
  assert isinstance(x, int), "La variable doit être un nombre entier"
  # ...

ma_fonction(10)  # OK
ma_fonction("toto")  # Assertion error


def ma_fonction(x):
  assert x > 0, "La variable doit être positive"
  # ...

ma_fonction(5)  # OK
ma_fonction(-1)  # Assertion error


def ma_fonction(x, y):
  assert x != y, "Les deux variables doivent être différentes"
  # ...

try:
  ma_fonction(10, 10)
except AssertionError:
  print("Les deux variables sont identiques")


def set_age(age):
    if age < 0:
        raise ValueError("L'âge ne peut pas être négatif.")
    print(f"Âge défini à {age} ans.")

try:
    set_age(-10)
except ValueError as e:
    print(e)


def diviser(a, b):
    if b == 0:
        raise ZeroDivisionError("Le diviseur ne peut pas être zéro.")
    return a / b

try:
    resultat = diviser(10, 0)
except ZeroDivisionError as e:
    print(e)


def ma_fonction(x):
  if x < 0:
    raise ValueError("La variable doit être positive")
  # ...

ma_fonction(10)  # OK
ma_fonction(-1)  # ValueError: La variable doit être positive


def ma_fonction(x):
  try:
    y = 1 / x
  except ZeroDivisionError:
    raise ValueError("La variable ne peut pas être égale à 0")
  # ...

ma_fonction(10)  # OK
ma_fonction(0)  # ValueError: La variable ne peut pas être égale à 0


print(dir(locals()['__builtins__']))


chemin_fichier = "../data/fichier_lu.txt"

# Lire un fichier
with open(chemin_fichier, 'r', encoding='utf-8') as fichier:
    contenu = fichier.read()
    print(contenu)


# Écrire dans un fichier
chemin_ecriture = '../data/fichier_ecris.txt'

with open(chemin_ecriture, 'w') as fichier:
    fichier.write("Bonjour!Comment allez-vous ?")


chemin_fichier = "../data/fichier_lu.txt"

# Lire un fichier ligne par ligne
with open(chemin_fichier, 'r', encoding='utf-8') as omelette:
    for ligne in omelette:
        print("***")
        print(ligne.strip())


for line in open('vraiment_gros_fichier.dat'):
    process_data(line)


def lire_par_morceaux(objet_fichier, taille_morceau=1024):
    """Fonction paresseuse (générateur) pour lire un fichier morceau par morceau.
    Taille de morceau par défaut : 1 ko."""
    while True:
        donnees = objet_fichier.read(taille_morceau)
        if not donnees:
            break
        yield donnees

with open('vraiment_gros_fichier.dat') as f:
    for morceau in lire_par_morceaux(f):
        process_data(morceau)


# Écrire dans un fichier
chemin_ecriture = '../data/rapport.txt'

with open(chemin_ecriture, 'w',  encoding='utf-8') as fichier:
    fichier.write("Rapport du Jour\n")
    fichier.write("=====================\n")
    fichier.write("Le temps était ensoleillé et le parc était paisible.\n")


# Écrire une liste de lignes
lignes = ["Première ligne\n", "Deuxième ligne\n", "Troisième ligne\n"]

with open(chemin_ecriture, 'a', encoding='utf-8') as fichier:
    fichier.writelines(lignes)


import csv

# Lire un fichier CSV
with open('../data/donnees.csv', mode ='r') as fichier_csv:
    lecteur_csv = csv.reader(fichier_csv)
    for ligne in lecteur_csv:
        print(ligne)


# Dictionnaire
donnees = [{"nom": "Dupont", "age": 30}, 
           {"nom": "Martin", "age": 40, "ville": "Nice", "profession": "Médecin"}]
print(donnees)


import json

# Écrire et lire des données JSON
with open('../data/donnees.json', 'w', encoding='utf-8') as fichier_json:
    json.dump(donnees, fichier_json)


with open('../data/donnees.json', 'r', encoding='utf-8') as fichier_json:
    donnees_lues = json.load(fichier_json)
    print(donnees_lues)

def additionner(a, b):
  return a + b

def soustraire(a, b):
  return a - b

def multiplier(a, b):
  return a * b


import fichier

fichier.addition(2, 4 )


import csv
import math

# help(csv)
# help(math)

math.log10(34)
math.floor(977713.710937)

import package.module1


from monpackage import operations

print(operations.somme(2, 3))
print(operations.division(2, 3))


from operations import division # plus nécessaire de préciser le module et importe que la fonction

resultat = division(4, 2)
print(resultat)


from operations import division, somme # plusieurs fonctions d'un module

resultat = somme(4, 2)
print(resultat)


import random
# help(random)

nombre_aleatoire = random.randint(1, 90)
liste_nombre_aleatoire = random.sample(range(1, 100), 18)
print(nombre_aleatoire, '\n', liste_nombre_aleatoire)


import random

# tirer au sort aléatoire un objet d'une liste 
objects = ['table', "stylo", "livre"]

object_aleatoire = random.choice(objects)
print(f" l'objet tiré est : {object_aleatoire}")


from monpackage import pierre_feuille_ciseaux

pierre_feuille_ciseaux.jeu()

def f(x,y):return x+y

Méthode	Description	Exemple d'Utilisation
`append()`	Ajoute un élément à la fin de la liste.	`liste.append(5)`
`extend()`	Étend la liste en ajoutant tous les éléments d'une autre liste.	`liste.extend([6, 7])`
`insert()`	Insère un élément à une position donnée.	`liste.insert(1, 'a')`
`remove()`	Supprime la première occurrence d'un élément.	`liste.remove('a')`
`pop()`	Supprime et renvoie un élément à une position donnée (par défaut, le dernier).	`liste.pop()`
`clear()`	Supprime tous les éléments de la liste.	`liste.clear()`
`index()`	Retourne l'indice du premier élément correspondant.	`liste.index('a')`
`count()`	Compte le nombre d'occurrences d'un élément spécifique.	`liste.count(5)`
`sort()`	Trie les éléments de la liste (dans un ordre spécifique).	`liste.sort()`
`reverse()`	Inverse l'ordre des éléments de la liste.	`liste.reverse()`

Avantage	Description
Sécurité des Données	Parfait pour protéger les données contre les modifications.
Performance	Plus rapides à parcourir que les listes.
Utilisation en tant que Clés de Dictionnaire	Peuvent être utilisés comme clés dans les dictionnaires, contrairement aux listes.
Retour de Plusieurs Valeurs de Fonction	Utilisés pour retourner plusieurs valeurs depuis une fonction.
Stockage de Données Constantes	Idéaux pour stocker des données qui ne doivent pas être modifiées.

Opération	Syntaxe	Description
Union	`a \| b`	Retourne un nouvel ensemble contenant tous les éléments uniques des ensembles `a` et `b`.
Intersection	`a & b`	Retourne un nouvel ensemble contenant uniquement les éléments communs aux ensembles `a` et `b`.
Différence	`a - b`	Retourne un nouvel ensemble contenant les éléments de `a` qui ne sont pas dans `b`.
Différence Symétrique	`a ^ b`	Retourne un nouvel ensemble contenant tous les éléments qui sont dans `a` ou `b`, mais pas dans les deux.
Ajout	`a.add(x)`	Ajoute l'élément `x` à l'ensemble `a`.
Suppression	`a.remove(x)`	Supprime l'élément `x` de l'ensemble `a` ; lève une erreur si `x` n'est pas présent.
Suppression (sans erreur)	`a.discard(x)`	Supprime l'élément `x` de l'ensemble `a` si `x` est présent ; ne fait rien sinon.

Exception	Cause de l'Erreur
AssertionError	Levée lorsque l'instruction assert échoue.
AttributeError	Levée lorsque l'assignation ou la référence à un attribut échoue.
EOFError	Levée lorsque input() atteint la fin du fichier.
FloatingPointError	Levée lorsqu'une opération sur les nombres à virgule flottante échoue.
GeneratorExit	Levée lorsque la méthode close() d'un générateur est appelée.
ImportError	Levée lorsque le module importé n'est pas trouvé.
IndexError	Levée lorsque l'index d'une séquence est hors de portée.
KeyError	Levée lorsque une clé n'est pas trouvée dans un dictionnaire.
KeyboardInterrupt	Levée lorsque l'utilisateur appuie sur la touche d'interruption (Ctrl+C ou Suppr).
MemoryError	Levée lorsqu'une opération manque de mémoire.
NameError	Levée lorsqu'une variable n'est pas trouvée dans la portée locale ou globale.
NotImplementedError	Levée par des méthodes abstraites.
OSError	Levée lorsqu'une opération système provoque une erreur liée au système.
OverflowError	Levée lorsque le résultat d'une opération arithmétique est trop grand pour être représenté.
ReferenceError	Levée lorsqu'une référence faible est utilisée pour accéder à un référent collecté par le ramasse-miettes.
RuntimeError	Levée lorsqu'une erreur ne rentre dans aucune autre catégorie.
StopIteration	Levée par next() pour indiquer qu'il n'y a plus d'élément à renvoyer par l'itérateur.
SyntaxError	Levée par l'analyseur lorsque une erreur de syntaxe est rencontrée.
IndentationError	Levée lorsqu'il y a une indentation incorrecte.
TabError	Levée lorsque l'indentation est composée de tabulations et d'espaces inconsistants.
SystemError	Levée lorsque l'interpréteur détecte une erreur interne.
SystemExit	Levée par la fonction sys.exit().
TypeError	Levée lorsqu'une fonction ou une opération est appliquée à un objet de type incorrect.
UnboundLocalError	Levée lorsqu'une référence est faite à une variable locale dans une fonction ou une méthode, mais aucune valeur n'a été liée à cette variable.
UnicodeDecodeError	Levée lorsqu'une erreur liée à Unicode se produit pendant le décodage.
ValueError	Levée lorsqu'une fonction reçoit un argument de type correct mais de valeur incorrecte.
ZeroDivisionError	Levée lorsque le deuxième opérande de l'opération de division ou de modulo est zéro.

Méthode	Description
close()	Ferme un fichier ouvert. Elle n'a aucun effet si le fichier est déjà fermé.
detach()	Sépare le tampon binaire sous-jacent du TextIOBase et le renvoie.
fileno()	Renvoie un numéro entier (descripteur de fichier) du fichier.
flush()	Vide le tampon d'écriture du flux de fichier.
isatty()	Renvoie True si le flux de fichier est interactif.
read(n)	Lit au plus n caractères du fichier. Lit jusqu'à la fin du fichier s'il est négatif ou None.
readable()	Renvoie True si le flux de fichier peut être lu.
readline(n=-1)	Lit et renvoie une ligne du fichier. Lit au plus n octets si spécifié.
readlines(n=-1)	Lit et renvoie une liste de lignes du fichier. Lit au plus n octets si spécifié.
seek(offset, from=SEEK_SET)	Modifie la position du fichier à offset octets, par rapport à from (début, courant, fin).
seekable()	Renvoie True si le flux de fichier prend en charge l'accès aléatoire.
tell()	Renvoie l'emplacement actuel du fichier.
truncate(size=None)	Redimensionne le flux de fichier à size octets. Si size n'est pas spécifié, redimensionne à l'emplacement actuel.
writable()	Renvoie True si le flux de fichier peut être écrit.
write(s)	Écrit la chaîne s dans le fichier et renvoie le nombre de caractères écrits.
writelines(lines)	Écrit une liste de lignes dans le fichier.

Opérateur comparaison	Description
Egalité	==
Différent de	!=
Supérieur	>
Inférieur	<
Supérieur ou égale	>=
Inférieur ou égale	<=

Opérateur logique	Description	Résultat
And	and	True si les deux propositions sont vraies
Or	or	True si au moins une des propositions est Vraie
Not	not	inverse de l'instruction

Opérateur logique	Description	Résultat
In	in	True si la valeur spécifiée est présente dans l'objet.
Not in	not in	True si la valeur spécifiée n'est pas présente dans l'objet.

Introduction à Python

Table des matières📝

1. C’est quoi Python ? 💡

2. Les Fondamentaux de Python 👩‍💻

2.1. Variables (types natifs)

2.1.1. Types de variables

2.1.2. Conversion de types

2.1.3. Opérations arithmétiques

2.1.4. Opérations sur les chaines de caractères

2.1.5. Opérateurs d'affectation composés

2.2 Commentaires et affichage

2.3. Structures de contrôle

2.3.1 Les opérateurs

2.3.1 Les opérateurs

¶

Chainer les comparateurs¶

2.3.2 Les conditions

2.3.3 Les boucles

2.4 Types de Données (Structures Séquentielles)

2.4.1 Les chaines de caractères

2.4.2 Les listes

2.4.3 Les tuples

2.4.4 Les ensembles

2.4.5 Les dictionnaires

2.5 Les fonctions : définition et rappel

Qu'est-ce qu'une Fonction ?¶

Pourquoi Utiliser des Fonctions ?¶

Définition d'une Fonction¶

2.5.1 Les paramètres et arguments

2.5.2 Les types de fonctions

2.5.3 La portée des variables

2.5.4 Nombre variable d'arguments

2.5.5 Les fonctions anonymes : lambda

2.5.6 Les fonctions et la récursivité

2.5.7 Générateurs et décorateurs

3. Gestion des exceptions ⚠️

3.1 Définition

3.2 Traitement des exceptions

3.2.1 Try-except

3.2.2 Finally

3.2.3 Else

3.3 Assertions

3.4 Raise

4. Lecture et écriture de fichiers 📖

4.1 Gestion simple des fichiers

4.2 Travailler avec différents types de fichiers

5. Modules et Packages 🗂️

5.1. Modules

5.2. Packages

6. Bonnes Pratiques de Programmation

6.1 Introduction¶

Code Sans Bonnes Pratiques¶

Code Avec Bonnes Pratiques¶

6.2 La conformité PEP¶

6.3 Outils de contrôle qualité du code¶

7.Certification avec DataCamp - bonus 🐍

🐍 Aller plus loin en programmation Python !¶

8. Références