Vous êtes sur la page 1sur 5

POO GRP6

October 25, 2019

In [31]: class Graphe:

def __init__(self):
"""
__init__ est une méthode magique automatiquement invoquée
par Python lors de l'instanciation d'une nouveau Graphe.
g = Graphe()
==> ...... Graphe.__init__(g)
"""
self.g = dict()

def nb_sommets(self):
"""
retourne le nombre de sommets du graphe
"""
return len(self.g)

def nb_arcs(self):
"""
retourne le nombre total d'arcs du graphe self
"""
return sum(len(v) for v in self.g.values())

def sommets(self):
"""
retourne un frozenset contenant les sommets du graphe
self
"""
return frozenset(self.g)

def ajouter_sommet(self, s):


"""
ajoute le sommet s au graphe self, déclenche une
erreur si s est déjà dans self.
"""
if s in self.g:
raise Exception(" Sommet déjà présent dans le graphe")
self.g[s] = set()

1
def ajouter_arc(self, dp, df):
"""
ajouter l'arc (dp --- > df) au graphe courant self.
Déclenche des erreurs si :
- dp ou df ne sont pas dans le graphe
- dp est déjà relié à df
"""
assert dp in self.g
assert df in self.g
assert df not in self.g[dp]
self.g[dp].add(df) #self.g => dict, self.d[dp] => set

def supprimer_arc(self, dp, df):


"""
supprimer l'arc (dp --> df) du graphe self.
Déclenche des erreurs si :
- dp ou df ne sont pas dans le graphe.
- dp n'est pas relié à df
"""
assert dp in self.g and df in self.g and df in self.g[dp]
self.g[dp].discard(df)

def supprimer_sommet(self, s):


"""
Supprimer un sommet s du graphe self.
Déclenche une erreur si s n'est pas dans self.g.
"""
assert s in self.g
self.g.pop(s) #suppression de la paire (s, successeurs de s)
for n in self.g.values():
n -= {s}

def __getitem__(self, s):


"""
__getitem__ est une méthode magique automatiquement
invoquée par Python lorsque un objet est indexé.
self[s] ==> Graphe.__getitem__(self, s)
"""
assert s in self.g
return frozenset(self.g[s])

def __contains__(self, t):


"""
__contains__ est une méthode magique automatiquement invoquée
par Python lorsque le test d'appartenance (in ou not in)
est appliqué sur instance de la classe.
t in self ==> Graphe.__contains__(self, t).

2
Selon le type de t :
- t est un tuple : On véfie l'existance d'un art (t[0]) --> t[1]
- t est un sommet : On vérifier l'existance du sommet t dans self.
"""
if isinstance(t, tuple):
dp, df = t
if dp in self.g:
return df in self.g[dp]
return False
else: #t est un sommet

return t in self.g

In [33]: #instanciation de gr
gr = Graphe()
#ajout des sommets
for s in range(1, 7):
gr.ajouter_sommet(s)
gr.ajouter_arc(1,1)
gr.ajouter_arc(1,2)
gr.ajouter_arc(1,3)
gr.ajouter_arc(2,4)
gr.ajouter_arc(3,1)
gr.ajouter_arc(3,4)
gr.ajouter_arc(3,5)
gr.ajouter_arc(4,6)
gr.ajouter_arc(6,4)

In [34]: gr.g

Out[34]: {1: {1, 2, 3}, 2: {4}, 3: {1, 4, 5}, 4: {6}, 5: set(), 6: {4}}

In [35]: def ParcoursLargeur(gr, s):


d = {n:False for n in gr.sommets()}
f = list()
v = list()
d[s] = True
f.append(s)
while len(f) != 0:
s = f.pop(0)
v.append(s)
for suc in gr[s]:
if not d[suc]:
d[suc] = True
f.append(suc)
return v

In [37]: ParcoursLargeur(gr,2)

3
Out[37]: [2, 4, 6]

In [6]: def factorielle(n):


if not isinstance(n, int): #type(n) is not int:
raise Exception(" Uniquement les valeur entières sont acceptées")
if n < 0:
raise Exception(" Entier positif attendu !")
if n == 0:
return 1
else:
return n * factorielle(n-1)

In [ ]: def factorielle(n):
assert isinstance(n,int) and n >= 0, "Entier naturel attendu!"
if n == 0:
return 1
else:
return n * factorielle(n-1)

In [7]: factorielle(5)

Out[7]: 120

In [9]: factorielle(-1)

---------------------------------------------------------------------------

Exception Traceback (most recent call last)

<ipython-input-9-71a9c5f638b5> in <module>()
----> 1 factorielle(-1)

<ipython-input-6-d549e107e4bc> in factorielle(n)
3 raise Exception(" Uniquement les valeur entières sont acceptées")
4 if n < 0:
----> 5 raise Exception(" Entier positif attendu !")
6 if n == 0:
7 return 1

Exception: Entier positif attendu !

In [10]: isinstance(5, int)

Out[10]: True

In [11]: s = {1,2,3,4}

4
In [12]: s -= {1}
In [13]: s
Out[13]: {2, 3, 4}
In [14]: s.discard(3)
In [15]: s
Out[15]: {2, 4}
In [16]: s.remove(2)
In [17]: s
Out[17]: {4}
In [18]: d = {1:5,3:5,10:11}
In [19]: d.pop(1)
Out[19]: 5
In [20]: d
Out[20]: {3: 5, 10: 11}
In [21]: del d[10]
In [22]: d
Out[22]: {3: 5}
In [23]: d.popitem()
Out[23]: (3, 5)
In [24]: d
Out[24]: {}
In [25]: l = ["med", "ali", "salah"]
In [26]: l[0]
Out[26]: 'med'
In [27]: l.__getitem__(0)
Out[27]: 'med'
In [28]: list.__getitem__(l,0)
Out[28]: 'med'
In [29]: "med" in l
Out[29]: True
In [30]: list.__contains__(l, "med")
Out[30]: True

Vous aimerez peut-être aussi