la méthode__contains__:

définition:
La méthode __contains__ est une méthode spéciale en programmation
orientée objet, souvent utilisée en Python. Elle est associée aux objets pouvant
être considérés comme des conteneurs, tels que des chaînes de caractères, des
listes ou des ensembles. La fonction principale de la méthode __contains__ est
de permettre l'implémentation de l'opérateur d'appartenance in

Dans le contexte des chaînes de caractères en Python, la méthode __contains__

est appelée lorsque l'on utilise l'opérateur in pour vérifier si une sous-chaîne
particulière est présente dans la chaîne

La méthode __contains__ est une méthode spéciale en Python utilisée pour

vérifier si un objet est présent dans une autre séquence d'objets. Lorsque vous
utilisez l'opérateur in pour vérifier si un élément est présent dans une séquence
(comme une liste, un tuple ou une chaîne de caractères), Python fait appel à la
méthode __contains__ de l'objet pour effectuer cette vérification.

exemple:
class ListeDeChaines:
def __init__(self, liste_de_chaines):
self.liste_de_chaines = liste_de_chaines

def __contains__(self, sous_chaine):

for chaine in self.liste_de_chaines:
if sous_chaine.lower() in chaine.lower():
 return True
return False

# Utilisation de la classe personnalisée

liste_chaines = ListeDeChaines(["Bonjour, le monde!", "Python
est génial.", "exellent"])

# Vérification de l'appartenance d'une sous-chaîne dans la liste

sous_chaine_recherchee = "le Monde"
if sous_chaine_recherchee in liste_chaines:
print(f"La sous-chaîne '{sous_chaine_recherchee}' est
présente dans la liste de chaînes.")
else:
print(f"La sous-chaîne '{sous_chaine_recherchee}' n'est pas
présente dans la liste de chaînes.")

la méthode__radd__:
définition:
La méthode __radd__ dest utilisée pour la réflexion de
l'opération d'addition (+). Elle est appelée lorsque l'objet à
droite de l'opérateur d'addition n'implémente pas la méthode
__add__ appropriée.
La méthode __radd__ est une méthode spéciale en Python qui
permet de redéfinir le comportement de l'opérateur + pour les
objets de cette classe. Cette méthode est appelée
automatiquement par Python lorsqu'un objet non + capable
tente d'être ajouté à un objet + capable.

exemple:
class Vector:
def __init__(self, x, y):
self.x = x
self.y = y

def __add__(self, other):

if isinstance(other, Vector):
return Vector(self.x + other.x, self.y + other.y)
else:
return NotImplemented
 def __radd__(self, other):
return self.__add__(other)

v1 = Vector(1, 2)
v2 = Vector(3, 4)

print(v1 + v2) # Output: Vector(x=4, y=6)

print(v2 + v1) # Output: Vector(x=4, y=6)
print(v1 + 1) # Output: NotImplemented
print(1 + v1) # Output: NotImplemented

la méthode__mod__:
définiton:
La méthode __mod__ est une méthode spéciale en
programmation Python associée à l'opérateur de
modulo (%). Elle permet de définir le comportement de
cet opérateur pour les objets de votre classe
personnalisée. Lorsque l'opérateur de modulo est utilisé
avec des objets de votre classe, Python appelle
automatiquement la méthode __mod__ de cette classe.
La méthode __mod__ pour les chaînes en Python est
utilisée pour définir le comportement de l'opérateur de
modulo (%) lorsqu'il est appliqué à des chaînes. Cette
méthode permet de formater une chaîne en remplaçant
les occurrences du caractère de substitution % par les
valeurs spécifiées.

exemple:
class Personne:
def __init__(self, nom, age):
self.nom = nom
self.age = age

def __str__(self):
return "Nom: %s, Age: %d" % (self.nom, self.age)

# Création d'une instance de la classe Personne

john = Personne("John Doe", 30)
# Utilisation de la méthode __mod__ pour formater une
chaîne
message_formatte = "Informations sur la personne : %s"
% john

print(message_formatte)

la méthode__truediv__:
La méthode __truediv__ est une méthode
spéciale en Python associée à l'opérateur de
division (/). Elle est utilisée pour définir le
comportement de l'opérateur de division pour
les objets d'une classe personnalisée.
Cette méthode est appelée lorsque l'opérateur
de division (/) est utilisé avec des objets de la
classe, permettant au développeur de définir
comment les instances de la classe réagissent
lorsqu'elles sont divisées par d'autres objets.
exemple:
class NombrePersonnalise:
def __init__(self, valeur):
self.valeur = valeur

def __truediv__(self, autre_objet):

if isinstance(autre_objet,
NombrePersonnalise) and
autre_objet.valeur != 0:
return
NombrePersonnalise(self.valeur /
autre_objet.valeur)
else:
raise ValueError("L'opération de
division n'est définie qu'avec des objets
de la classe NombrePersonnalise et le
diviseur doit être non nul.")

# Utilisation de la classe personnalisée

nombre1 = NombrePersonnalise(10)
nombre2 = NombrePersonnalise(2)

resultat_division = nombre1 / nombre2

print(resultat_division.valeur)