{"cells":[{"metadata":{"run_control":{"marked":false}},"cell_type":"markdown","source":"# TD_10_1 - Représentation d'un graphe"},{"metadata":{"run_control":{"marked":false},"hide_input":true,"trusted":true},"cell_type":"code","source":"import matplotlib.pyplot as plt\nimport networkx as nx\nimport numpy as np\nimport pydot\nfrom networkx.drawing.nx_pydot import graphviz_layout\nfrom networkx.drawing.nx_agraph import to_agraph \nimport matplotlib.image as mpimg\n","execution_count":2,"outputs":[{"output_type":"stream","text":"Traceback (most recent call last):\n  File \"<basthon-input-2-787db96fd013>\", line 4, in <module>\n    import pydot\nModuleNotFoundError: No module named 'pydot'\n","name":"stderr"}]},{"metadata":{},"cell_type":"markdown","source":"Ce cours est une version \"jupyter notebook\" du [cours proposé par Stéphan Van Zuijlen](http://isn-icn-ljm.pagesperso-orange.fr/NSI-TLE/co/section_chapitre3.html)"},{"metadata":{},"cell_type":"markdown","source":"## Comment représenter un graphe"},{"metadata":{"run_control":{"marked":false}},"cell_type":"markdown","source":"Un graphe est caractérisé par sa matrice d’adjacence composée de 1 et de 0 selon que deux sommets sont ou ne sont pas reliés par une arête.  \n  \nUne façon d’encoder un graphe sous Python est d’utiliser un dictionnaire qui sera la représentation de sa matrice d’adjacence.  \n  \nLes clés seront les sommets du graphe et leur valeur sera la liste des sommets adjacents.  \n  \nPrenons par exemple ce graphe :"},{"metadata":{"run_control":{"marked":false},"hide_input":true,"cell_style":"split","trusted":true},"cell_type":"code","source":"G = nx.DiGraph([(\"a\",\"b\"), (\"a\",\"c\"), (\"b\",\"d\"), (\"c\",\"d\"),\n                (\"b\",\"e\"), (\"d\",\"e\"), (\"e\",\"g\"), (\"e\",\"f\"),\n                (\"f\",\"g\"), (\"g\",\"h\")])\nG.nodes[\"a\"]['pos'] = \"0,10!\"\nG.nodes[\"b\"]['pos'] = \"10,20!\"\nG.nodes[\"c\"]['pos'] = \"10,0!\"\nG.nodes[\"d\"]['pos'] = \"20,10!\"\nG.nodes[\"e\"]['pos'] = \"30,20!\"\nG.nodes[\"f\"]['pos'] = \"50,20!\"\nG.nodes[\"g\"]['pos'] = \"40,10!\"\nG.nodes[\"h\"]['pos'] = \"30,0!\"\n\n\npos = graphviz_layout(G)\n\nplt.figure(\"cycle\")\nnx.draw_networkx_nodes(G, pos, node_color=\"cyan\")\nnx.draw_networkx_labels(G, pos)\nnx.draw_networkx_edges(G, pos, edge_color='r', arrows=False)\nplt.box(False)\nplt.show()","execution_count":3,"outputs":[{"output_type":"stream","text":"Traceback (most recent call last):\n  File \"<basthon-input-3-3c616d50977d>\", line 14, in <module>\n    pos = graphviz_layout(G)\n          ^^^^^^^^^^^^^^^\nNameError: name 'graphviz_layout' is not defined\n","name":"stderr"}]},{"metadata":{"cell_style":"split"},"cell_type":"markdown","source":"$\\begin{array}{ccccccccc}\n & \\left. \\begin{matrix} a & b & c & d & e & f & g & h\\end{matrix} \\right. \\\\\n \\begin{matrix} a\\\\\n b\\\\\n c\\\\\n d\\\\\n e\\\\\n f\\\\\n g\\\\\n h \\end{matrix} & \\left( \\begin{matrix}\n 0 & 1 & 1 & 0 & 0 & 0 & 0 & 0\\\\\n 1 & 0 & 0 & 1 & 1 & 0 & 0 & 0\\\\\n 1 & 0 & 0 & 1 & 0 & 0 & 0 & 0\\\\\n 0 & 1 & 1 & 0 & 1 & 0 & 0 & 0\\\\\n 0 & 1 & 0 & 1 & 0 & 1 & 1 & 0\\\\\n 0 & 0 & 0 & 0 & 1 & 0 & 1 & 0\\\\\n 0 & 0 & 0 & 0 & 1 & 1 & 0 & 1\\\\\n 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0\n\\end{matrix} \\right)\n\\end{array}$"},{"metadata":{},"cell_type":"markdown","source":"Cela donne:"},{"metadata":{"trusted":true},"cell_type":"code","source":"G = {}\nG['a'] = ['b','c']\nG['b'] = ['a','d','e']\nG['c'] = ['a','d']\nG['d'] = ['b','c','e']\nG['e'] = ['b','d','f','g']\nG['f'] = ['e','g']\nG['g'] = ['e','f','h']\nG['h'] = ['g']","execution_count":4,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Pour la matrice d’adjacence, on peut l’écrireà la main, en utilisant une liste de liste :"},{"metadata":{"trusted":true},"cell_type":"code","source":"A1=[[0, 1, 1, 0, 0, 0, 0, 0],\n    [1, 0, 0, 1, 1, 0, 0, 0],\n    [1, 0, 0, 1, 0, 0, 0, 0],\n    [0, 1, 1, 0, 1, 0, 0, 0],\n    [0, 1, 0, 1, 0, 1, 1, 0],\n    [0, 0, 0, 0, 1, 0, 1, 0],\n    [0, 0, 0, 0, 1, 1, 0, 1],\n    [0, 0, 0, 0, 0, 0, 1, 0]]\n\nA1","execution_count":5,"outputs":[{"output_type":"execute_result","execution_count":5,"data":{"text/plain":"[[0, 1, 1, 0, 0, 0, 0, 0], [1, 0, 0, 1, 1, 0, 0, 0], [1, 0, 0, 1, 0, 0, 0, 0], [0, 1, 1, 0, 1, 0, 0, 0], [0, 1, 0, 1, 0, 1, 1, 0], [0, 0, 0, 0, 1, 0, 1, 0], [0, 0, 0, 0, 1, 1, 0, 1], [0, 0, 0, 0, 0, 0, 1, 0]]"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"Ou bien utiliser ce code pour la fabriquer à partir de la liste des sommets et du dictionnaire G:"},{"metadata":{"trusted":false},"cell_type":"code","source":"liste=['a','b','c','d','e','f','g','h']\nn = len(liste)\nA=[[0]*n for i in range(n)]\n\nfor i in range(n):\n    for j in range(n):\n        if liste[j] in G[liste[i]]:\n            A[i][j]=1\n            \nA","execution_count":9,"outputs":[{"output_type":"execute_result","execution_count":9,"data":{"text/plain":"[[0, 1, 1, 0, 0, 0, 0, 0],\n [1, 0, 0, 1, 1, 0, 0, 0],\n [1, 0, 0, 1, 0, 0, 0, 0],\n [0, 1, 1, 0, 1, 0, 0, 0],\n [0, 1, 0, 1, 0, 1, 1, 0],\n [0, 0, 0, 0, 1, 0, 1, 0],\n [0, 0, 0, 0, 1, 1, 0, 1],\n [0, 0, 0, 0, 0, 0, 1, 0]]"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"## Quelques fonctions pour exploiter le graphe"},{"metadata":{},"cell_type":"markdown","source":"Voici quelques rappels sur les dictionnaires:"},{"metadata":{"trusted":false},"cell_type":"code","source":"print(G.keys()) # affiche les clés","execution_count":14,"outputs":[{"output_type":"stream","text":"dict_keys(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])\n","name":"stdout"}]},{"metadata":{"trusted":false},"cell_type":"code","source":"print(G.values()) # affiche les valeurs","execution_count":15,"outputs":[{"output_type":"stream","text":"dict_values([['b', 'c'], ['a', 'd', 'e'], ['a', 'd'], ['b', 'c', 'e'], ['b', 'd', 'f', 'g'], ['e', 'g'], ['e', 'f', 'h'], ['g']])\n","name":"stdout"}]},{"metadata":{"trusted":false},"cell_type":"code","source":"print(len(G)) # affiche le nombre de clés","execution_count":16,"outputs":[{"output_type":"stream","text":"8\n","name":"stdout"}]},{"metadata":{"trusted":false},"cell_type":"code","source":"print(G['e']) # affiche la valeur de la clé ’e’","execution_count":17,"outputs":[{"output_type":"stream","text":"['b', 'd', 'f', 'g']\n","name":"stdout"}]},{"metadata":{"trusted":false},"cell_type":"code","source":"# G.keys() et G.values() sont itérables\n\n# affiche les valeurs du dictionnaire\nfor el in G.values():\n    print(el)","execution_count":18,"outputs":[{"output_type":"stream","text":"['b', 'c']\n['a', 'd', 'e']\n['a', 'd']\n['b', 'c', 'e']\n['b', 'd', 'f', 'g']\n['e', 'g']\n['e', 'f', 'h']\n['g']\n","name":"stdout"}]},{"metadata":{"trusted":false},"cell_type":"code","source":"# affiche les clés et les valeurs des clés\nfor key in G.keys():\n    print(key,G[key])","execution_count":20,"outputs":[{"output_type":"stream","text":"a ['b', 'c']\nb ['a', 'd', 'e']\nc ['a', 'd']\nd ['b', 'c', 'e']\ne ['b', 'd', 'f', 'g']\nf ['e', 'g']\ng ['e', 'f', 'h']\nh ['g']\n","name":"stdout"}]},{"metadata":{},"cell_type":"markdown","source":"### Exercice 1:  \nÉcrire des fonctions permettant d’obtenir les informations suivante sur le graphe G:  \n* le nombre de sommets du graphe  \n* le nombre d’arêtes du graphe  \n* le degré d’un sommet  \n* le sommet de plus haut degré  \n* les voisins d’un sommet"},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Exercice 2:\nImplémenter le graphe du réseau social du cours et faire afficher celui qui a le plus d’amis."},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Avec une bibliothèque"},{"metadata":{},"cell_type":"markdown","source":"La bibliothèque [networkX](https://networkx.github.io/)  permet de manipuler des graphes. Continuons avec le graphe du début."},{"metadata":{"trusted":false},"cell_type":"code","source":"# On importe le module\nimport networkx as nx","execution_count":21,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"code","source":"# Création du graphe\ng1 = nx.Graph()","execution_count":22,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"code","source":"# On ajoute les sommets (appelés node)\ng1.add_node('a')\ng1.add_node('b')\ng1.add_node('c')\ng1.add_node('d')\ng1.add_node('e')\ng1.add_node('f')\ng1.add_node('g')\ng1.add_node('h')","execution_count":23,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"code","source":"# On ajoute les arêtes (appelées edge)\ng1.add_edge('a','b')\ng1.add_edge('a','c')\ng1.add_edge('b','d')\ng1.add_edge('b','e')\ng1.add_edge('c','d')\ng1.add_edge('d','e')\ng1.add_edge('e','g')\ng1.add_edge('e','f')\ng1.add_edge('g','f')\ng1.add_edge('g','h')","execution_count":24,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"On peut visualiser le graphe grâce à matplotlib et la fonction draw.  \n  \nIci on a de plus configuré l’affichage pour que les étiquettes des sommets soient affichées, la taille des sommets soit de 800, la couleur de fond des sommets gris clair."},{"metadata":{"trusted":false},"cell_type":"code","source":"import matplotlib.pyplot as plt\n\nnx.draw(g1, with_labels=True, font_weight='bold',\n        node_size=800, node_color='lightgrey')\nplt.show()","execution_count":25,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"On peut également le faire avec des listes de sommets et d’arêtes:"},{"metadata":{"trusted":false},"cell_type":"code","source":"import networkx as nx\nimport matplotlib.pyplot as plt\n#création du graphe à partir de listes\nliste1 = ['a','b','c','d','e','f','g','h']\ng2 = nx.Graph()\ng2.add_nodes_from(liste1)\n\nliste2=[('a','b'),('a','c'),('b','d'),('b','e'),\n        ('c','d'),('d','e'),('e','g'),('e','f'),\n        ('g','f'),('g','h')]\ng2.add_edges_from(liste2)\n\nnx.draw(g2, with_labels=True, font_weight='bold', node_size=800,node_color='lightgrey')\nplt.show()","execution_count":26,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"Pour la matrice d’adjacence:  \nnetworkx propose une méthode **nx.adjacency_matrix(g2)** qui stocke les coefficients $a_{ij}$ de la matrice d’adjacence. Il suffit alors de remplir un tableau avec ces coefficients."},{"metadata":{"trusted":false},"cell_type":"code","source":"B = nx.adjacency_matrix(g2)\nprint(B[(0,0)])\n\nn=len(liste1)\nA=[[0]*n for i in range(n)] \n\nfor i in range(n):\n    for j in range(n):\n        A[i][j] = B[(i,j)]\nprint(A)","execution_count":33,"outputs":[{"output_type":"stream","text":"0.0\n[[0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0]]\n","name":"stdout"}]},{"metadata":{},"cell_type":"markdown","source":"## Exploiter la bibliothèque"},{"metadata":{},"cell_type":"markdown","source":"La documentation de NetworkX est divisée en sections. Il existe notamment:  \n* une section pour obtenir les [méthodes sur les sommets et les arêtes](https://networkx.github.io/documentation/stable/reference/functions.html)\n* une section pour obtenir [les algorithmes disponibles](https://networkx.github.io/documentation/stable/reference/algorithms/index.html)\n* on pourra aussi consulter [le tutoriel de NetworkX](https://networkx.github.io/documentation/stable/tutorial.html)\n  \nEn voici quelques unes:\ndegré d’un sommet du graphe g:  \n**g.degree('a')**  \n  \nnombre de sommets du graphe g:  \n**g.number_of_nodes()**  \n  \nnombre d’arcs du graphe g:  \n**g.number_of_edges()**  \n  \n**g.predecessors(i)**: liste des prédecesseurs du sommet i  \n**g.successors(i)**: liste des successeurs du sommet i  \n**g.neighbors(i)**: liste des voisins du sommet i"},{"metadata":{},"cell_type":"markdown","source":"### Exercice 3"},{"metadata":{},"cell_type":"markdown","source":"Avec NetworkX, cherchez les méthodes pour obtenir les informations suivantes sur le graphe G:  \n* le nombre de sommets du graphe  \n* le nombre d’arêtes du graphe  \n* le degré d’un sommet  \n* le sommet de plus haut degré  \n* les voisins d’un sommet"},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Exercice 4:  \nImplémenter le graphe du réseau social du cours et faire afficher celui qui a le plus d’amis."},{"metadata":{"trusted":false},"cell_type":"code","source":"","execution_count":null,"outputs":[]}],"metadata":{"celltoolbar":"None","kernelspec":{"name":"python3","display_name":"Python 3","language":"python"},"language_info":{"name":"python","version":"3.7.10","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"varInspector":{"window_display":false,"cols":{"lenName":16,"lenType":16,"lenVar":40},"kernels_config":{"python":{"library":"var_list.py","delete_cmd_prefix":"del ","delete_cmd_postfix":"","varRefreshCmd":"print(var_dic_list())"},"r":{"library":"var_list.r","delete_cmd_prefix":"rm(","delete_cmd_postfix":") ","varRefreshCmd":"cat(var_dic_list()) "}},"types_to_exclude":["module","function","builtin_function_or_method","instance","_Feature"]}},"nbformat":4,"nbformat_minor":2}