Documentaire : “Derrière nos écrans de fumée”, un réquisitoire contre « l’algorithmisation » de nos vies

Derrière nos écrans de fumée (The Social Dilemma) , (documentaire sorti sur Netflix le 9 septembre, met en garde contre les dérives de ces algorithmes qui cherchent, avec chaque jour un peu plus d’efficacité, à nous maintenir « engagés » sur Facebook, YouTube, Instagram ou Twitter. Polarisation des débats, bulles de filtres qui nous mettent uniquement en relation avec des gens qui pensent comme nous, addiction, prime à la désinformation, dépression, le documentaire balaye largement les problèmes causés, plus ou moins directement, par « l’algorithmisation » croissante de nos vies.

Les données collectées ne posent pas de problème

Nous brandissons souvent le spectre des données, ces données personnelles que toutes collectent auprès de ces entreprises pour les vendre à un prix plus élevé. Derrière nos écrans de fumée pousse l’analyse beaucoup plus loin. Le problème n’est pas seulement les données, mais le comportement de l’utilisateur. Il est rappelé que si nous ne payons pas pour un produit, alors, c’est que nous sommes le produit. Et si nous constatons une «dérive» de l’usage sur quelques années, c’est parce que cela fait partie intégrante des stratégies de ces entreprises.

Hypocrisie du processus

Un joli paradoxe est Derrière nos écrans de fumée projetés sur Netflix, qui utilise exactement cela pour faire des recommandations aux abonnés. Le comble de la tartuferie apparaît à la fin du documentaire, lorsque le réalisateur invite le public à visiter son site Internet. Parmi les actions recommandées à éviter, les téléspectateurs sont encouragés à faire de la publicité pour des documentaires… sur les réseaux sociaux. On sera sensible à l’ironie, ou l’hypocrisie, du procédé.

Des révélations qui sont à relativiser

Que ce soit la polarisation du débat chez nous sur l’augmentation exponentielle des hospitalisations pour automutilation, ou chez les adolescentes américaines, tout est de la faute des réseaux sociaux? La réalité est un peu plus compliquée et manque de point de référence et de contexte historique.

Réponse de Facebook

Facebook décompose point par point les sept domaines qu’il estime que le film déforme : la soi-disant dépendance aux réseaux sociaux, la présentation des utilisateurs comme étant le produit ultime, la manière dont Facebook déploie ses algorithmes, la collecte de données, la polarisation politique, l’intégrité des élections et la désinformation.

What ‘The Social Dilemma’ Gets Wrong

Comment convertir un nombre décimal en hexadécimal ?

Les systèmes de numérations binaire et hexadécimal sont très utilisés dans les domaines de l’électronique et de l’informatique.Tout étudiant dans les filières de l’informatique et plus généralement dans les filières technologiques se doit de les connaître.

Le système hexadécimal, est un système de numérotation en base 16 qui utilise 16 caractères.

Dans le système décimal on utilise que 10 chiffres, le système a été donc complété de 6 lettres. Le système hexadécimal utilise donc :

  • les chiffres 1,2, 3, 4, 5, 6, 7, 8, 9, et 0
  • les lettres A, B, C, D, E et F

Les lettres ont les valeurs suivantes :

  • A vaut 10
  • B vaut 11
  • C vaut 12
  • D vaut 13
  • E vaut 14
  • F vaut 15

Numeral System Converter est une application permettant de convertir des nombres dans différents systèmes de numération comme le système binaire, hexadécimal, octal pour les plus courants, mais aussi dans toute autre base et jusqu’à la base 36.

Numeral System ConverterJ’ai testé la version gratuite 2.0. Pour l’installer sur votre Smartphone ou sur votre tablette, vous avez besoin de la version Android 4 ou une version ultérieure.

L’application Android « Numeral System Converter » est gratuite et comme toute application de ce genre, vous recevrez de temps en temps de la publicité, mais elle ne gêne en rien son utilisation.

L’application est en langue anglaise, mais ne nécessite aucun niveau particulier. Un simple niveau en anglais de fin de collège ou de début du lycée permet non seulement d’utiliser l’application, mais aussi de comprendre aisément la partie méthodologie pour obtenir la conversion.

Il existe de nombreuses applications de conversion dans différents systèmes de numération. La force de cette application est de proposer en plus le détail des calculs pour comprendre la méthodologie employée.

Pour présenter les fonctionnalités de l’application « Numeral System Converter« , je vais utiliser dans la suite de cet article deux exemples basiques de conversion.

  • Une conversion d’un nombre décimal en un nombre hexadécimal;
  • Une conversion d’un nombre hexadécimal en un nombre décimal.

Conversion d’un nombre décimal en hexadécimal

Dans ce premier exemple, je cherche à convertir le nombre décimal 172 en un nombre binaire.

Une conversion décimale en hexadécimal, se fait très simplement comme sur l’image ci-dessous. Vous sélectionnez tout d’abord le système de numération initiale (source system), puis le système de numération finale (destination system). Pour finir, vous saisissez le nombre à convertir.

Nous obtenons ici le nombre hexadécimal : AC(16)

Sans titre 1

Si vous souhaitez le détail du calcul, l’application affiche dans autre écran quelques lignes expliquant la méthode utilisée et surtout le détail du calcul étape par étape.

Sans titre 2

Dans notre cas il s’agit d’une succession de division par 16. Chaque reste de la division permet d’obtenir un chiffre du nombre hexadécimal. À chaque nouvelle ligne de calcul, le reste obtenu est placé à gauche du reste précédent. On obtient ainsi par cette méthodologie, à la fin des calculs directement le nombre hexadécimal.

Conversion d’un nombre hexadécimal en décimal

Dans ce deuxième exemple, je cherche à convertir le nombre hexadécimal 5AF(16) hexadécimal en un nombre décimal.

La procédure de conversion d’un nombre hexadécimal en un nombre décimal se fait aussi simplement que dans l’exemple précédent.

Nous obtenons ici le nombre décimal 1455.

Sans titre 5

Une nouvelle fois vous pouvez obtenir le détail du calcul. Ici, chaque chiffre ou lettre du nombre hexadécimal est multiplié par une puissance de 16 de la position de celui-ci.

Sans titre 6

Pour aller plus loin

Pour approfondir vos connaissances, et développer vos compétences, je vous propose cette sélection de livre.

Comment convertir un nombre décimal en binaire ?

Dans les technologies de l’information et des communications, et plus généralement dans le monde numérique, les ordinateurs du monde entier fonctionnent sur un système binaire (ou de base deux), où les chiffres ne peuvent prendre que deux valeurs, 0 ou 1.

binaire

Numeral System Converter est une application permettant de convertir des nombres dans différents systèmes de numération comme le système binaire, hexadécimal, octal pour les plus courants, mais aussi dans toute autre base et jusqu’à la base 36.

Numeral System ConverterJ’ai testé la version gratuite 2.0. Pour l’installer sur votre Smartphone ou sur votre tablette, vous avez besoin de la version Android 4 ou une version ultérieure.

L’application Android “Numeral System Converter” est gratuite et comme toute application de ce genre, vous recevrez de temps en temps de la publicité, mais elle ne gêne en rien son utilisation.

L’application est en langue anglaise, mais ne nécessite aucun niveau particulier. Un simple niveau en anglais de fin de collège ou de début du lycée permet non seulement d’utiliser l’application, mais aussi de comprendre aisément la partie méthodologie pour obtenir la conversion.

Il existe de nombreuses applications de conversion dans différents systèmes de numération. La force de cette application est de proposer en plus le détail des calculs pour comprendre la méthodologie employée.

Pour présenter les fonctionnalités de l’application “Numeral System Converter“, je vais utiliser dans la suite de cet article deux exemples basiques de conversion.

  • Une conversion d’un nombre décimal en un nombre binaire;
  • Une conversion d’un nombre binaire en un nombre décimal.

Conversion d’un nombre décimal en binaire

Dans ce premier exemple, je cherche à convertir le nombre décimal 172 en un nombre binaire.

Une conversion décimale en binaire, se fait très simplement comme sur l’image ci-dessous. Vous sélectionnez tout d’abord le système de numération initiale (source system), puis le système de numération finale (destination system). Pour finir, vous saisissez le nombre à convertir.

Nous obtenons ici le nombre binaire 1010 1100.

convertion binaire decimal_2Si vous souhaitez le détail du calcul, l’application affiche dans autre écran quelques lignes expliquant la méthode utilisée et surtout le détail du calcul étape par étape.

convertion binaire decimal_1Dans notre cas il s’agit d’une succession de division par deux. Chaque reste de la division permet d’obtenir un chiffre du nombre binaire. À chaque nouvelle ligne de calcul, le reste obtenu est placé à gauche du reste précédent. On obtient ainsi par cette méthodologie, à la fin des calculs directement le nombre binaire.

Conversion d’un nombre binaire en décimal

Dans ce deuxième exemple, je cherche à convertir le nombre binaire 1011 0111 binaire en un nombre décimal.

La procédure de conversion d’un nombre binaire en un nombre décimal se fait aussi simplement que dans l’exemple précédent.

Nous obtenons ici le nombre décimal 183.

convertion binaire decimal_4Une nouvelle fois vous pouvez obtenir le détail du calcul. Ici, chaque bit du nombre binaire est multiplié par une puissance de deux de la position de celui-ci.

convertion binaire decimal_3Une particularité de cette application est de détailler le calcul en commençant par le bit de poids faible jusqu’au bit de poids fort, ce qui inhabituel. Généralement, c’est plutôt l’inverse que l’ont fait pour respecter le sens de lecture du nombre binaire.

Pour aller plus loin

Pour approfondir vos connaissances, et développer vos compétences, je vous propose cette sélection de livre.

Brexit : comment le référendum européen a été gagné grâce à la science des données

« Tout le monde sait qui a gagné, mais peu de gens savent comment »

Brexit La Guerre incivile nous a montré comment le référendum européen a été gagné grâce à la science des données

QUI SE CACHE DERRIÈRE LE VOTE « NON » DU BREXIT ?

Été 2016. Le Royaume-Uni est en pleine campagne électorale. Les camps du « Leave » (quitter l’Europe) ou du « Remain » (rester dans l’Europe) s’affrontent. Dominic Cummings (Benedict Cumberbatch), directeur de la campagne en faveur du Brexit, use d’une stratégie inédite. Basé sur les données d’algorithmes sophistiqués explorant les recoins les plus sombres d’Internet, le but est de rechercher les électeurs cachés. Cette tactique ne fait pas l’unanimité auprès des partisans du Leave. Les coups bas et les trahisons commencent…

Brexit La Guerre incivile

Dans Brexit La Guerre incivile, on peut voir comment Dominic a fait enfermer une équipe de Data Scientists de AggregateIQ dans une pièce ombragée, comme une sorte de projet séparé du reste de la campagne de Leave.

La première chose qu’on les voit faire est de créer une campagne pour savoir ce que les différents groupes d’électeurs pensent des différentes questions concernant l’UE. Pour ce faire, ils ont donné aux gens la possibilité de gagner un pari global, qui serait statistiquement presque impossible à gagner (une chance sur 5 000 000 000 000 000 000 000 000). Ils ont ensuite utilisé les résultats de cette recherche pour créer des messages comportementaux microciblés à l’intention de différents segments de l’électorat.

 

Il a été constaté que pendant le référendum, ils ont diffusé plus d’un milliard de publicités sur Facebook, avec divers messages en faveur du congé. Par exemple, des segments d’électeurs moins “racistes” ont pu recevoir des photos de Boris Johnson déclarant : “Je suis pro-immigration, mais surtout, je suis pour l’immigration contrôlée”. Alors que d’autres ont reçu des messages tels que “La TURQUIE A UNE POPULATION DE 76 MILLIONS. LA TURQUIE REJOINT L’UE. BONNE IDÉE ?”.

 

S’ils cliquaient sur l’annonce correspondante, ils recevraient alors une horde d’annonces en continu sur le même sujet, ce qui renforcerait ce point de vue. M. Cummings a déjà expliqué comment ils ont retenu la majorité de leur budget et l’ont consacré à ce type de publicité dans les dix derniers jours précédant le référendum européen. Il affirme qu’environ 7 millions de personnes ont été visées pendant cette période.

 

Dans Brexit La Guerre incivile, on voit même l’équipe de la campagne “Leave” demander pourquoi les publicités ne sont pas diffusées à la télévision et dans les journaux télévisés, alors qu’elle pensait que l’autre camp n’avait aucune idée de ce qui se passait.

Pourquoi la science des données modifie-t-elle le paysage politique ?

Bien sûr, quiconque suit même légèrement le cycle des nouvelles en Occident aura probablement entendu parler du scandale de Cambridge Analytica. Cambridge Analytica a été créé et dirigé par Robert Mercer (un expert milliardaire de l’IA) et Steve Bannon, le financier et directeur de campagne de Donald Trump. Christopher Wyle, dénonciateur de Cambridge Analytica, a souligné les liens étroits entre AggregateIQ et Cambridge Analytica.

Ce scandale nous a montré que, grâce à l’utilisation abusive des données des utilisateurs de Facebook, ils pouvaient établir le profil psychométrique de l’ensemble de l’électorat. En utilisant une application de personnalité virale appelée myPersonality, ils ont pu croiser les types de personnalité avec ce que les gens avaient aimé sur Facebook pour profiler les gens avec un haut degré d’exactitude.

Les données recueillies et utilisées pour alimenter les algorithmes de profilage de l’électorat sont devenues une arme essentielle lors du référendum européen et des élections américaines. Wyle a même décrit comment Steve Bannon a qualifié ces outils d’armes dans sa “guerre psychologique”, avec pour objectif de susciter des mouvements populistes nationalistes dans le monde entier.

Si certains peuvent s’opposer à cette forme de manipulation politique et la considèrent comme effrayante. Sur une note positive, Cambridge Analytica a maintenant fermé ses portes en raison de la pression politique intense qui a suivi les retombées de l’élection de Donald Trump, Facebook a pris des mesures pour lutter contre la fuite de données de tiers qui a permis la création de ces outils scientifiques, et la protection des citoyens européens par RGPD signifie que vous avez désormais plus de contrôle sur l’utilisation de vos données personnelles. La prochaine fois que cela se produira, ce ne sera probablement pas aussi facile ni aussi inaperçu.

Malheureusement, d’autres entreprises comme Cambridge Analytica existent toujours et continueront à le faire tant qu’il y aura une demande suffisante. Les politiciens dépensent beaucoup d’argent dans des campagnes, bien sûr, ils vont utiliser les dernières techniques et technologies pour essayer de gagner.

Attendez-vous à ce que ce soit la nouvelle norme

Vous pouvez vous en défaire si vous n’êtes pas satisfait du résultat du référendum européen ou de l’élection de Donald Trump. C’est simplement parce que les mouvements populistes nationaux sont arrivés les premiers.

Depuis que nous sommes entrés dans l’ère numérique, nous partageons de plus en plus de données sur nous-mêmes et nous créons de nouvelles voies pour que l’information nous atteigne. Le marketing et la publicité modernes consistent de plus en plus à créer des messages pertinents et personnalisés à l’intention de segments cibles de plus en plus granuleux, la politique n’étant qu’un client parmi d’autres sur ce marché.

La science des données trouvera des moyens d’assembler nos informations pour créer des profils de nous afin de s’assurer que les bons messages nous parviennent. Les campagnes politiques trouveront des moyens de rechercher nos états émotionnels sur des questions particulières et de créer des messages qui suscitent en nous une réaction de vote particulière. Des plateformes continueront d’exister pour permettre à ces messages de campagne ciblés de nous atteindre.

Si Brexit La Guerre incivile m’a montré quelque chose, c’est l’échec de la campagne Remain à adopter les derniers outils et technologies disponibles grâce à l’explosion de la science des données. Ils auraient pu eux aussi cibler les électeurs que la campagne “Leave” visait et ceux qui ne se sont pas donné la peine d’aller voter. Comme les sondeurs traditionnels, ils ont utilisé les mêmes vieilles techniques qui ont été utilisées pendant des décennies et n’ont pas réussi à les appliquer correctement.

Il est temps que la politique entre dans le 21ème siècle

Nous vivons maintenant dans ce que l’on appelle l’ère de l’après-vérité, il s’agit moins d’argumenter le pour et le contre dans un débat rationnel, mais de lancer des “grenades” d’informations (qu’elles soient vraies ou fausses) qui résonnent avec l’électorat de manière émotionnelle, ce qui oblige ensuite l’opposition à “éteindre les feux”.

Cela peut être une voie à double sens, je ne propose certainement pas que le mensonge soit acceptable, il serait parfaitement possible de construire de meilleurs outils de vérification des faits qui permettraient de vérifier en temps réel les fausses informations à l’avenir pour aider à faire face à cela. Mais je dis que les campagnes, quel que soit le côté de l’argument, doivent apprendre de Cambridge Analytica et d’AggregateIQ que l’ancienne façon de faire de la politique est révolue, la science des données est là pour rester. Le gagnant est celui qui reste en tête du jeu.

Brexit La Guerre incivile

Pour aller plus loin

Data scientist : Connaissez-vous Billy Beane ?

Le Stratège, film de Bennett Miller sorti en 2011, raconte l’histoire de Billy Beane, sélectionneur d’une équipe de baseball qui décida d’utiliser des méthodes statistiques et d’analyse de données pour assembler une équipe capable de gagner la Ligue majeure de baseball américaine.

Billy Beane, pionnier de l’utilisation de la data

En 2002, l’équipe de baseball Oakland Athletics se fait rafler ses meilleurs joueurs par les Yankees. Une équipe de renom au budget gargantuesque : 125 millions de dollars par an. Quand on sait que les Athletics doivent même payer leurs canettes de soda, on comprend vite le déséquilibre…

Frustré et à cours d’argent, Billy Beane décide de former une toute nouvelle équipe avec l’aide d’un économiste particulièrement fan des théories mathématiques de Bill James. Tous les deux vont alors utiliser les statistiques « sabermetrics » pour recruter des talents moins cotés et pour sélectionner les meilleurs joueurs à chaque poste. Une méthode raillée à ses débuts mais qui porte ses fruits très rapidement ! Aujourd’hui, pas une équipe de sport ne travaille sans l’analyse statistique des datas.

La victoire des canards boiteux… et des stats

Jugée au départ comme une équipe de bras cassés (trop vieux, blessés, impopulaires…), les Athletics remportent finalement 20 victoires consécutives, battant ainsi le record de l’American League. Et le tout pour un budget de 41 millions de dollars, soit 3 fois moins que celui des Yankees.

Le Stratège de Bennett Miller avec Brad Pitt et Jonah Hill est sorti en 2011 et est adapté du livre Moneyball de Michael Lewis publié en 2003.

Moneyball – The Art of Winning an Unfair Game

Source : Le Stratège : l’analyse statistique au service de la performance

Comment insérer des éléments dans une liste chainée en Python ?

Insertion des éléments

Selon l’endroit où vous souhaitez insérer un élément, il existe différentes façons d’insérer des éléments dans une seule liste chaînée

.Insertion d’éléments au début

La façon la plus simple d’insérer un élément dans une liste chaînée est d’ajouter un élément au début de la liste. La fonction suivante permet d’insérer un élément au début de la liste. Ajoutez cette fonction à la classe LinkedList que nous avons créée précédemment.

    def insert_at_start(self, data):
        new_node = Node(data)
        new_node.ref = self.start_node
        self.start_node= new_node

Dans le script ci-dessus, nous créons une méthode insert_at_start(), la méthode accepte un paramètre, qui est essentiellement la valeur de l’élément que nous voulons insérer. À l’intérieur de la méthode, nous créons simplement un objet de la classe Node et nous fixons sa référence au start_node puisque start_node stockait auparavant le premier nœud, qui après l’insertion d’un nouveau nœud au départ deviendra le deuxième nœud.

Par conséquent, nous ajoutons la référence de start_node à la variable ref du nouveau nœud. Maintenant, puisque new_node est le premier nœud, nous fixons la valeur de la variable start_node à new_node.

Insertion d’éléments à la fin

La fonction suivante est utilisée pour ajouter un élément à la fin de la liste chaînée.

  def insert_at_end(self, data):
        new_node = Node(data)
        if self.start_node is None:
            self.start_node = new_node
            return
        n = self.start_node
        while n.ref is not None:
            n= n.ref
        n.ref = new_node;

Dans le script ci-dessus, nous créons une fonction insert_at_end(), qui insère l’élément à la fin de la liste chaînée. La valeur de l’élément que nous voulons insérer est passée en argument à la fonction. La fonction se compose de deux parties. Tout d’abord, nous vérifions si la liste chaînée est vide ou non. Si la liste chaînée est vide, il suffit de fixer la valeur de la variable start_node à l’objet new_node.

D’autre part, si la liste contient déjà quelques nœuds. Nous initialisons une variable n avec le nœud de départ. Nous itérons ensuite à travers tous les nœuds de la liste en utilisant une boucle while comme nous l’avons fait dans le cas de la fonction traverse_list. La boucle se termine lorsque nous atteignons le dernier nœud. Nous fixons alors la référence du dernier nœud au nouveau new_node nouvellement créé.

Ajoutez la fonction insert_at_end() à la classe LinkedList.

Insertion d’un élément après un autre élément

Il se peut que nous devions ajouter un élément après l’autre dans une seule liste chaînée. Pour ce faire, nous pouvons utiliser la fonction insert_after_item() telle que définie ci-dessous :

    def insert_after_item(self, x, data):

        n = self.start_node
        print(n.ref)
        while n is not None:
            if n.item == x:
                break
            n = n.ref
        if n is None:
            print("Elément dans la liste")
        else:
            new_node = Node(data)
            new_node.ref = n.ref
            n.ref = new_node

La fonction insert_after_item() accepte deux paramètres : x et data. Le premier paramètre est l’élément après lequel vous voulez insérer le nouveau noeud tandis que le second paramètre contient la valeur du nouveau noeud.

Nous commençons par créer une nouvelle variable n et lui attribuer la variable start_node. Ensuite, nous parcourons la liste liée en utilisant la boucle while. La boucle while s’exécute jusqu’à ce que n devienne None. Au cours de chaque itération, nous vérifions si la valeur stockée dans le nœud actuel est égale à la valeur passée par le paramètre x. Si la comparaison est vraie, nous rompons la boucle.

Ensuite, si l’élément est trouvé, la variable n ne sera pas None. La référence du new_node est définie comme référence stockée par n et la référence de n est définie comme new_node. Ajoutez la fonction insert_after_item() à la classe LinkesList.

Insertion d’un élément avant un autre élément

      def insert_before_item(self, x, data):
        if self.start_node is None:
            print("La liste n'a pas d'élément.")
            return

        if x == self.start_node.item:
            new_node = Node(data)
            new_node.ref = self.start_node
            self.start_node = new_node
            return

        n = self.start_node
        print(n.ref)
        while n.ref is not None:
            if n.ref.item == x:
                break
            n = n.ref
        if n.ref is None:
            print("L'élément n'est pas dans la liste.")
        else:
            new_node = Node(data)
            new_node.ref = n.ref
            n.ref = new_node

Dans le script ci-dessus, nous définissons la fonction insert_before_item(). Cette fonction comporte trois parties. Examinons chaque partie en détail.

   if self.start_node is None:
        print("La liste n'a pas d'élément.")
        return

Dans le script ci-dessus, nous vérifions si la liste est vide. Si elle est effectivement vide, nous imprimons simplement que la liste n’a pas d’élément et nous revenons de la fonction.

Ensuite, nous vérifions si l’élément se trouve dans le premier index. Regardez le script suivant :

     if x == self.start_node.item:
        new_node = Node(data)
        new_node.ref = self.start_node
        self.start_node = new_node
        return

Si l’élément après lequel on veut insérer un nouveau nœud se trouve au premier index. Nous fixons simplement la référence du nœud nouvellement inséré au start_node, puis nous fixons la valeur de start_node à new_node.

Enfin, si la liste n’est pas None et que l’élément ne se trouve pas au premier index, nous créons une nouvelle variable n et lui attribuons la variable start_node. Ensuite, nous parcourons la liste liée en utilisant la boucle while. La boucle while-loop s’exécute jusqu’à ce que n.ref devienne None. Au cours de chaque itération, nous vérifions si la valeur stockée dans la référence du nœud courant est égale à la valeur passée par le paramètre x. Si la comparaison est vraie, nous cassons la boucle.

Ensuite, si l’élément est trouvé, la variable n.ref ne sera pas None. La référence du nouveau_nœud est fixée à la référence de n et la référence de n est fixée à new_node. Regardez le script suivant :

    if n.ref is None:
        print("L'élément n'est pas dans la liste.")
    else:
        new_node = Node(data)
        new_node.ref = n.ref
        n.ref = new_node

Ajoutez la fonction insert_before_item() à la classe LinkedList.

Insertion d’un élément à un index spécifique

Parfois, nous avons besoin d’insérer un élément à un index spécifique, nous pouvons le faire à l’aide du script suivant :

    def insert_at_index (self, index, data):
        if index == 1:
            new_node = Node(data)
            new_node.ref = self.start_node
            self.start_node = new_node
        i = 1
        n = self.start_node
        while i < index-1 and n is not None:
            n = n.ref
            i = i+1
        if n is None:
            print("Index out of bound")
        else: 
            new_node = Node(data)
            new_node.ref = n.ref
            n.ref = new_node

Dans le script, nous vérifions d’abord si l’index dans lequel nous voulons stocker l’élément est 1, puis nous attribuons simplement start_node à la référence du new_node et nous fixons ensuite la valeur de start_node à new_node.

Ensuite, on exécute une boucle while qui s’exécute jusqu’à ce que le compteur i devienne supérieur ou égal à l’index-1. Par exemple, si vous voulez ajouter un nouveau nœud au troisième index. Au cours de la première itération de la boucle while, i deviendra 2 et le nœud actuellement itéré sera “2”. La boucle ne s’exécutera pas à nouveau puisque i est maintenant 2, ce qui est égal à l’index 1 (3-1=2). Par conséquent, la boucle sera interrompue. Ensuite, nous ajoutons un nouveau nœud après le nœud actuellement itéré (qui est le nœud 2), ce qui fait que le nouveau nœud est ajouté à l’index.

Il est important de mentionner que si l’index ou l’emplacement passé en argument est supérieur à la taille de la liste liée, un message sera affiché à l’utilisateur indiquant que l’index est hors de portée ou hors limite.

Il ne vous reste plus qu’à tester vos fonctions d’insertion en Python.

Pour aller plus loin

Pour approfondir vos connaissances, et développer vos compétences, je vous propose cette sélection de livre.

Pour aller plus loin

Pour approfondir vos connaissances, et développer vos compétences, je vous propose cette sélection de livre.

Programmation d’une liste chainée en Python

Introduction

Les listes chaînées sont une structure de données qui représente une collection linéaire de nœuds. Une caractéristique spécifique des listes chaînées est que l’ordre des nœuds n’est pas dicté par leur présence en mémoire, mais plutôt par les pointeurs que chaque nœud possède vers le nœud suivant dans la séquence.

Il existe plusieurs types de listes chaînées :

  • Listes chaînées simples – Une liste chaînée classique, comme celle présentée dans l’image ci-dessus. Les nœuds des listes à liens simples contiennent un pointeur vers le nœud suivant de la liste.
  • Listes doublement chaînées – Ce type de liste chaînée contient à la fois un pointeur vers le nœud suivant, mais aussi un pointeur vers le nœud précédent de la liste.
  • Listes chaînées circulaires – Au lieu de contenir un pointeur nul à la fin de la liste, le dernier nœud de ces listes contient un pointeur vers le premier nœud, ce qui les rend circulaires.

Nous aborderons ici la liste chainée simple.

Liste chaînée simple

Une seule liste chaînée est la plus simple de toutes les variantes de listes chaînées. Chaque nœud d’une liste chaînée unique contient un élément et une référence à l’élément suivant, et c’est tout.

Dans cette partie, nous verrons comment créer un nœud pour la liste chaînée unique ainsi que les fonctions pour les différents types d’insertion, de parcourt et de suppression.

Création de la classe de nœuds

La première chose à faire est de créer une classe pour les nœuds. Les objets de cette classe seront les nœuds réels que nous insérerons dans notre liste de liens. Nous savons qu’un nœud pour une seule liste chaînée contient l’objet et la référence au nœud suivant. Par conséquent, notre classe de nœuds contiendra deux variables membres : item et ref. La valeur de l’élément sera fixée par la valeur passée dans le constructeur, tandis que la référence sera initialement fixée à zéro.

Exécutez le script suivant :

class Node:
    def __init__(self, data):
        self.item = data
        self.ref = None

Création de la classe de liste chainée simple

Ensuite, nous devons créer une classe pour la liste des liens. Cette classe contiendra les méthodes pour insérer, supprimer, parcourir et trier la liste. Au départ, la classe ne contiendra qu’un seul membre start_node qui pointera vers le nœud de départ ou le premier nœud de la liste. La valeur de start_node sera fixée à null à l’aide du constructeur puisque la liste liée sera vide au moment de sa création. Le script suivant crée une classe pour la liste chaînée.

class LinkedList:
    def __init__(self):
        self.start_node = None

 

Nous avons maintenant créé une classe pour notre liste unique. L’étape suivante consiste à ajouter une fonction d’insertion pour insérer des éléments dans la liste chaînée. Mais avant cela, nous allons ajouter une fonction pour parcourir une liste chaînée. Cette fonction nous aidera à lire les données de notre liste.

Parcourir les éléments de la liste liée

Le code Python pour la fonction de parcours est le suivant. Ajoutez la fonction ci-dessous à la classe LinkedList que nous avons créée dans la dernière section.

def traverse_list(self):
    if self.start_node is None:
        print("Pas d'élément dans la liste")
        return
    else:
        n = self.start_node
        while n is not None:
            print(n.item , " ")
            n = n.ref

 

Voyons ce qui se passe dans la fonction ci-dessus. Cette fonction comporte deux parties principales. Premièrement, elle vérifie si la liste chaînée est vide ou non. Le code suivant vérifie cela :

    if self.start_node is None:
        print("Pas d'élément dans la liste")
        return

 

Si la liste chaînée est vide, cela signifie qu’il n’y a pas d’élément à itérer. Dans ce cas, la fonction traverse_list() affiche simplement l’instruction que la liste n’a pas d’élément.

Sinon, si la liste comporte un élément, le code suivant s’exécutera :

        n = self.start_node
        while n is not None:
            print(n.item , " ")
            n = n.ref

 

Comme nous l’avons dit précédemment, la variable de départ contiendra une référence aux premiers nœuds. Par conséquent, nous initialisons une variable n avec la variable de départ. Ensuite, nous exécutons une boucle qui s’exécute jusqu’à ce que n devienne nul. À l’intérieur de la boucle, nous imprimons l’élément stocké au nœud actuel, puis nous fixons la valeur de la variable n à n.ref, qui contient la référence au nœud suivant. La référence du dernier noeud est None puisqu’il n’y a pas de noeud après cela. Par conséquent, lorsque n devient None, la boucle se termine.

Maintenant, nous avons une fonction pour parcourir une liste chaînée, nous verrons dans un prochain article  comment nous pouvons ajouter des éléments à une  liste chaînée.

 

Pour aller plus loin

Pour approfondir vos connaissances, et développer vos compétences, je vous propose cette sélection de livre.

Comment ajouter des éléments à une liste en Python?

En bref, une liste est une collection d’objets arbitraires, un peu comme un tableau dans de nombreux autres langages de programmation, mais plus flexible. Les listes sont définies en Python en mettant entre crochets ([]) une séquence d’objets séparés par des virgules, comme indiqué ci-dessous :

Les caractéristiques importantes des listes Python sont les suivantes :

  • Les listes sont ordonnées.
  • Les listes peuvent contenir n’importe quel objet arbitraire.
  • Les éléments des listes sont accessibles par index.
  • Les listes peuvent être imbriquées à une profondeur arbitraire.
  • Les listes sont modifiables.
  • Les listes sont dynamiques.

Pour ajouter des éléments ou item à une liste en Python, il existe 3 grandes méthodes.

Utilisation de la méthode append()

Les éléments peuvent être ajoutés à la liste en utilisant la fonction append() intégrée. Un seul élément à la fois peut être ajouté à la liste en utilisant la méthode append(), pour l’ajout de plusieurs éléments avec la méthode append(), des boucles sont utilisées. Les tuples peuvent également être ajoutés à la liste en utilisant la méthode append() car les tuples sont immuables. Contrairement aux Sets, les Listes peuvent également être ajoutées à la liste existante avec l’utilisation de la méthode append().

# Ajout d'éléments dans une liste  
  
# Créer une liste
List = [] 
print("Liste initiale vierge : ") 
print(List) 
  
# Ajout d'éléments dans la liste 
List.append(1) 
List.append(2) 
List.append(4) 
print("\nListe après l'ajout de trois éléments : ") 
print(List) 
  
# Ajout d'éléments à la liste en utilisant l'itérateur 
for i in range(1, 4): 
    List.append(i) 
print("\nListe après l'ajout d'éléments de 1-3: ") 
print(List) 
  
# Ajout de tuples à la liste 
List.append((5, 6)) 
print("\nListe après l'ajout d'un n-uplet : ") 
print(List) 
  
# Ajout d'une liste à une liste  
List2 = ['Pour', 'Geeks'] 
List.append(List2) 
print("\nListe après l'ajout d'une liste : ") 
print(List) 

Utilisation de la méthode insert()

La méthode append() ne fonctionne que pour l’ajout d’éléments à la fin de la liste, pour l’ajout d’un élément à la position souhaitée, la méthode insert() est utilisée. Contrairement à append() qui ne prend qu’un seul argument, la méthode insert() nécessite deux arguments (position, valeur).

# Ajout d'éléments dans une liste 
   
# Créer une liste 
List = [1,2,3,4] 
print("Liste initiale :  ") 
print(List) 
  
# Ajout d'un élément à position spécifique (en utilisant la méthode d'insertion)  
List.insert(3, 12) 
List.insert(0, 'Geeks') 
print("\nListe après avoir effectué l'opération d'insertion : ") 
print(List) 

Utilisation de la méthode extend()

Outre les méthodes append() et insert(), il existe une autre méthode pour l’ajout d’éléments, extend(), cette méthode est utilisée pour ajouter plusieurs éléments en même temps à la fin de la liste.

# Ajout d'éléments dans une liste 
    
# Créer une liste 
List = [1,2,3,4] 
print("Liste initiale : ") 
print(List) 
  
# Ajout d'éléments multiples à la liste à la fin (en utilisant la méthode Extend) 
List.extend([8, 'Geeks', 'Toujours']) 
print("\nListe après avoir effectué l'opération Extend Operation: ") 
print(List) 

Pour aller plus loin

Pour approfondir vos connaissances, et développer vos compétences, je vous propose cette sélection de livre.

Algorithme et politique

Été 2016. Le Royaume-Uni est en pleine campagne électorale. Les camps du « Leave » (quitter l’Europe) ou du « Remain » (rester dans l’Europe) s’affrontent. Dominic Cummings (Benedict Cumberbatch), directeur de la campagne en faveur du Brexit, use d’une stratégie inédite. Basé sur les données d’algorithmes sophistiqués explorant les recoins les plus sombres d’Internet, le but est de rechercher les électeurs cachés. Cette tactique ne fait pas l’unanimité auprès des partisans du Leave. Les coups bas et les trahisons commencent…

QUI SE CACHE DERRIÈRE LE VOTE « NON » DU BREXIT ?

« Tout le monde sait qui a gagné, mais peu de gens savent comment » Voilà un slogan qui résume parfaitement BREXIT, le brillant thriller qui fait la lumière sur le plus grand tremblement de terre politique depuis la chute du Mur de Berlin. CE film dévoile les dessous du vote qui a non seulement changé l’avenir du Royaume-Uni et de l’Europe, mais aussi changé à jamais la politique internationale.

« Le portrait atroce et à peine exagéré d’une nation gouvernée par des charlatans et manipulée par des algorithmes »

Brexit La Guerre incivile

Le film Brexit La Guerre incivile raconte l’émergence d’un nouveau combat politique, sur les réseaux sociaux. Il reprend brillamment les dernières révélations sur l’utilisation des données personnelles.

“Sans Cambridge Analytica, le Brexit n’aurait pas eu lieu”:  comment les réseaux sociaux influencent les comportements

L’une des leçons du Brexit est que nos démocraties sont désormais fragilisées par des opérations de manipulation de l’électorat. “Sans Cambridge Analytica, le Brexit n’aurait pas eu lieu”, déclarait en 2018 Christopher Wylie, un ancien employé de cette firme britannique qui a siphonné les informations contenues dans 87 millions de comptes Facebook. Armée d’une telle quantité de données, la firme avait ciblé les électeurs, développé des algorithmes jouant sur leurs émotions et boosté le camp du Leave EU.