La manipulation de listes et dictionnaires dans différents langages de programmation

  
    Au commencement était le tableau. 
    A une dimension dont l'indice commençait à 0 ou 1 (... et oui !).
    Puis il y eu des tableaux de tableaux ... mais tous les sous-tableaux de même longueur.
    Ces tableaux pouvaient contenir des entiers, des flottants ou du texte ... mais, attention, pas de mélanges !!!
    Il fallait les déclarer avant la compilation ... et ils occupaient beaucoup de place, même vides.
    Et ils étaient souvent trop petits à l'exécution.
  
    Puis les choses s'améliorèrent ...  
  

  Du texte à la liste : 
                  Tcl           set L [split $T " "] 
                  Python        L = T.split(" ")
                  Javascript    L = T.split(" ")
                  PHP           $L = explode(" ", $T)
  De la liste au texte :  
                  Tcl           set T [join $L " "]
                  Python        T = " ".join(L)
                  Javascript    T = L.join(" ")
                  PHP           T = implode(" ", L)
  Rajouter un élément à la liste :  
                  Tcl           lappend L "Coucou"
                  Python        L.append("Coucou")
                  Javascript    L.push("Coucou")
                  PHP           array_push(L, "Coucou")
  Extraire une sous-liste :  
                  Tcl           set P [lrange $L 8 45] 
                  Python        P = L[8:45]
                  Javascript    P = L.slice(8, 45)
                  PHP           P = array_slice(L, 8, 45-8+1)
                  
  En résumé on voit que tout le monde fait à peu près la même chose. Il n'y a que la notation qui change.
  
  En Tcl on a toujours une notation fonctionnelle car les listes ne sont pas traitées en tant qu'objet.
  Pour les autres langages c'est souvent un mix des deux types de notations, et il arrive que pour un même langage il y ait plusieurs manières possibles.

  
  La base absolument nécessaire pour tout langage correct est de pouvoir manipuler facilement
  
     les chaînes de caractères
     les listes
     et ...
     les dictionnaires (ou array ou tableaux associatifs, ...)
     
     Les listes servent à manipuler des éléments les uns après les autres dans un certain ordre, ordre qui est important.
     
     Les dictionnaires c'est : associer une valeur à une clé.
     
     La clé peut être un nombre une chaîne de caractères ou n'importe quoi d'autre ...
     La valeur associée peut aussi être n'importe quoi.
     L'important est d'avoir 
     
                               valeur  =  dict(clé)
                               
     Pour un dictionnaire donné on a aussi : la liste des clés, la liste des valeurs
     Attention ces listes ne sont pas toujours ordonnées, ... cela dépend du langage et même pour un langage donné du type de dictionnaire utilisé.
     Pire, d'un appel à l'autre la liste peut ne pas avoir le même ordre. 
                            
     Souvent les listes sont des tableaux (indicés par des entiers) et si l'indice peut être autre chose on a du coup un dictionnaire.
     
     En Tcl         on a list, dict et array
     En Python      on a list, dict, set (ensemble avec une seule fois chaque élément)
     En Javascript  on a list, dict, ... 
     En PHP         on a des array indicés à la fois par des entiers ou (et même en même temps) par autre chose.
     
     On peut évidemment avoir des listes de listes, des dictionnaires de listes, de dictionnaires ... à préciser pour chaque langage.
     
     Comme tous ces langages sont des langages objet on peut bien sûr tout construire ou reconstruire comme on veut, ou utiliser des packages additionnels.