Comment parcourir une liste en Python

Dans ce tutoriel on va apprendre comment parcourir et afficher les éléments d'un tableau en Python.

Parcourir un tableau python avec la boucle for in

On peut utiliser tout simplement la boucle for in pour pouvoir lire tous les éléments d'un tableau.

equipements = ["Tablette", "Smartphone", "Ordinateur"]

for x in equipements:
  print(x)

Exécution:

Tablette
Smartphone
Ordinateur

Parcourir en utilisant la boucle while()

La boucle while peut être utilisée pour parcourir de la même façon que la boucle for in.

list = [1, 2, 3, 4, 5, 6]
 
i = 0
 
# parcourir avec la boucle while
while i < len(lst): 
    print(list[i]) 
    i = i+1

Exécution:

1
2
3
4
5

Parcourir en utilisant la méthode range()

La méthode range() peut être combinée avec la méthode for pour afficher les éléments d'un tableau en python.

range (debut, fin, pas])

  • debut: ce paramètre est pour définir l'indice du début. 
  • fin; ce paramêtre est pour définir l'indice de fin de la séquence à afficher. 
  • pas(optionnelle): la différence entre chaque valeur pour la séquence à générer.

La fonction range() génère une séquence d'entiers du début jusqu'à la fin. La valeur de la fin n'est pas inclue dans la séquence finale.

list = [3, 6, 32, 96, 43, 22]
for i in range(len(list)): 
    print(lst[i])

Exécution:

3
6
32
96
43
22

Parcourir en utilisant la liste en compréhension

En une seule ligne, c'est possible de parcourir le tableau.

liste = [3, 6, 7, 9, 6]
[print(x) for x in liste] 

Exécution

3
6
7
9
6

Parcourir en utilisant Numpy

Il possible de générer un tableau d'entiers en Python avec la fonction numpy.arange() qui crée une séquence des entiers de 1 à n, ensuite faire le parcours avec la méthode numpy.nditer(array).

numpy.arange(debut, fin, pas)

  • debut: indice du début. 
  • fin; indice de fin. 
  • pas(optionnelle): différence entre chaque valeur pour la séquence à générer.

import numpy as np

n = np.arange(11)

for x in np.nditer(n): 
    print(x) 

Exécution:

1
2
3
4
5
6
7
8
9
10
11

Java - Comment obtenir une sublist de TreeMap

 Dans l'exemple ci-dessous on va voir comment obtenir à partir d'une TreeMap une nouvelle sous TreeMap triée en utilisant la méthode subMap() de la classe TreeMap.

subMap(K fromKey, K toKey)

Exemple:

import java.util.*;

class TreeMapSub {
  
  public static void main(String args[]) {
 
    TreeMap treemap = new TreeMap();

    // elements
    treemap.put("a", "e4");
    treemap.put("b", "e5");
    treemap.put("c", "e1");
    treemap.put("d", "e3");
    treemap.put("e", "e2");
    
    System.out.println("Avant:");
    
    /* parcourir la TreeMap non triée avec Iterator */
    
    Set set = treemap.entrySet();
    Iterator i = set.iterator();
    // Afficher les éléments
    while(i.hasNext()) {
      Map.Entry entry = (Map.Entry)i.next();
      System.out.print(entry.getKey() + " : ");
      System.out.println(entry.getValue());
    }
    
    System.out.println("Après:");
    
    // appeler la méthode subMap()
    SortedMap subM = treemap.subMap("a","d");
 
    /* parcourir la sous map avec Iterator */
    
    set = subM.entrySet();
    i = set.iterator();
    // Afficher les éléments
    while(i.hasNext()) {
      Map.Entry entry = (Map.Entry)i.next();
      System.out.print(entry.getKey() + " : ");
      System.out.println(entry.getValue());
    }
    
  }
}

Exécution

Avant:
a : e4
b : e5
c : e1
d : e3
e : e2
Après:
a : e4
b : e5
c : e1

Références
java.util.TreeMap.subMap() Method

Java - Trier une TreeMap par valeurs avec Comparator

La collection TreeMap est par défaut triée avec ses clés, mais si vous avez besoin de trier TreeMap par valeurs alors Java fournit un moyen pour réaliser ça en utilisant la classe comparator.

Exemple:

package codeurjava;

import java.util.*;

class TreeMapSort {
	
  // Trier les éléments de TreeMap par valeurs
  public static > Map sortByValues(final Map map) {
	  
    Comparator valueComparator = new Comparator() {
      public int compare(K k1, K k2) {
        int compare = map.get(k1).compareTo(map.get(k2));
        if (compare == 0) 
          return 1;
        else 
          return compare;
      }
    };
 
    Map TreeMap_triee_par_valeur = new TreeMap(valueComparator);
    TreeMap_triee_par_valeur.putAll(map);
    return TreeMap_triee_par_valeur;
  }
  
  public static void main(String args[]) {
 
    TreeMap treemap = new TreeMap();

    // elements
    treemap.put("1", "e4");
    treemap.put("2", "e5");
    treemap.put("3", "e1");
    treemap.put("4", "e3");
    treemap.put("5", "e2");
    
    System.out.println("Avant le tri:");
    
    /* parcourir la TreeMap non triée avec Iterator */
    
    Set set = treemap.entrySet();
    Iterator i = set.iterator();
    // Afficher les éléments
    while(i.hasNext()) {
      Map.Entry entry = (Map.Entry)i.next();
      System.out.print(entry.getKey() + " : ");
      System.out.println(entry.getValue());
    }
    
    System.out.println("Après le tri:");
    // appeler la méthode sortByvalues()
    Map TreeMap_triee_par_valeur = sortByValues(treemap);
 
    /* parcourir la nouvelle map triée avec Iterator */
    
    set = TreeMap_triee_par_valeur.entrySet();
    i = set.iterator();
    // Afficher les éléments
    while(i.hasNext()) {
      Map.Entry entry = (Map.Entry)i.next();
      System.out.print(entry.getKey() + " : ");
      System.out.println(entry.getValue());
    }
    
  }
}

Exécution

Avant le tri:
1 : e4
2 : e5
3 : e1
4 : e3
5 : e2
Après le tri:
3 : e1
5 : e2
4 : e3
1 : e4
2 : e5

Références:

Java Documentation - Comparator (JavaSE 8)

Comparer deux tableaux en Java

En Java, on peut comparer deux tableau en comparant chaque élément du tableau. La classe Arrays de Java fournit des méthodes qui peuvent être utiles pour faire la comparaison du deux tableau en Java.

On va apprendre comment comparer deux tableau en Java en utilisant la méthode Arrays.equals() et Arrays.deepEquals()avec des exemples.

Deux tableaux sont égaux s'il ont:

  • Le même type.
  • Le même nombre d'éléments.
  • Chaque pair d'éléments des deux tableaux sont égaux.
  • L'ordre des éléments doit être le même.

La méthode Arrays.equals() 

La classe Java Arrays fournit la méthode equals() pour comparer deux tableaux. Son principe est de comparer les éléments des deux tableaux en faisant le parcours.

public static boolean equals(int[] a1, int[] a2)

La méthode equals renvoie true si les éléments du tableaux sont égaux sinon false.

Exemple:

import java.util.Arrays;  

public class equals  
{   
	public static void main (String[] args)
	{
		// tableaux à comparer
		int[] array1 = new int[] {1, 2, 3, 4, 5};
		int[] array2 = new int[] {1, 2, 3, 4, 5};
		int[] array3 = new int[] {1, 2, 2, 4, 5};
		
		//comparer les tableaux array1 et array2 avec la méthode equals
		if (Arrays.equals(array1, array2))
			System.out.println("Les tableaux sont égaux");
		else
			System.out.println("Les tableaux ne sont pas égaux.");
		
		// comparer array1 avec array3
		if (Arrays.equals(array1, array3))
			System.out.println("Les tableaux sont égaux");
		else  
			System.out.println("Les tableaux ne sont pas égaux.");
	}
}
Exécution:

Les tableaux sont égaux
Les tableaux ne sont pas égaux.

La méthode Arrays.equals() compare les éléments des deux tableaux.

Remarque: si les deux tableaux sont contenus dans des objets différents mais ont les mêmes valeurs, dans ce cas il ne sont pas égaux comme le montre l'exemple ci-dessous.

public class comparaisonTableaux2
{
	public static void main (String[] args)
	{
		// tableaux à comparer
		String[] array1 = new String[] {"a", "b", "c", "d"};
		String[] array2 = new String[] {"a", "b", "c", "d"};
		Object[] arrayObj1 = {array1};
		Object[] arrayObj2 = {array2};
		
		// comparer arrayObj1 et arrayObj2  
		if (Arrays.equals(arrayObj1, arrayObj2))
			System.out.println("Les tableaux sont égaux");
		else  
			System.out.println("Les tableaux ne sont pas égaux.");
	}
}

Exécution:

Arrays are not equal.

On voit que Arrays.equals() ne peut pas effectuer une comparaison plus profonde et pour résoudre ça il faut utiliser la méthode deepEquals().

La méthode Arrays.deepEquals()

La classe Arrays fournit une autre méthode plus efficace pour comparer de façon plus profonde le contenu des tableaux comme son nom indique.

public static boolean deepEquals(Object[] t1, Object[] t2)  

La méthode deepEquals analyse les deux tableaux t1 et t2 et les compare. après l'analyse profonde, elle renvoie ture si les deux sont égaux sinon false.

Deux tableaux t1 et t2 de type Object sont égaux s'ils ont au moins une des propriétés suivantes:

  • t1 = t2
  • equals(t2) retourne true.
  • Si t1 et t2 ont le même type référence objet, la méthode deepEquals(t1,t2) renvoie true.
  • Si t1 et t2 ont le même type primitive, la méthode equals(t1,t2) renvoie true.

Exemple:

public class comparaisonTableaux3
{
	public static void main (String[] args)
	{
		// tableaux à comparer
		String[] array1 = new String[] {"java", "php", "javascript", "c++"};
		String[] array2 = new String[] {"java", "php", "javascript", "c++"};
		Object[] t1 = {array1};
		Object[] t2 = {array2};
		
		// comparer arrayObj1 et arrayObj2  
		if (Arrays.deepEquals(t1, t2))
			System.out.println("Les tableaux sont égaux");
		else  
			System.out.println("Les tableaux ne sont pas égaux.");
	}
}

Exécution:

Les tableaux sont égaux

Références:

Javadoc - Class DeepEquals

Java.util.Arrays.equals(Object[], Object[]) Method

Inverser les clés triées d'une TreeMap

Il est possible d'afficher les clés d'une TreeMap en ordre décroissant mais comment les trier ?

Il existe deux solutions:

Copier TreeMap dans une nouvelle TreeMap

Cette méthode consiste à copier TreeMap dans une nouvelle TreeMap pour pouvoir tirer en ordre décroissant les clés en utilisant descendingKeySet, vous n'avez pas besoin de créer un nouvelle TreeMap.

 private static void printReverseTreeMap(TreeMap treeMap){
    for(String key : treeMap.descendingKeySet()){
        System.out.println("valeur de " + key + " est " + treeMap.get(key));
    }
}

Créer un nouvelle TreeMap en ordre décroissant

Vous pouvez avec cette méthode créer une nouvelle Map en ordre décroissant en utilisant descendingMap ainsi que Collections.reverseOrder()descendingMap retourne un objet NavigableMap

 NavigableMap reveresedTreeMap = treeMap.descendingMap();

Références:

https://stackoverflow.com/questions/9338209/how-to-print-treemap-in-reverse-order

PHP - méthode explode()

La fonction explode() divise un string en un tableau (array) et retourne un tableau de chaîne de caractères. La fonction est disponible depuis la version PHP 4+.
On peut dire que la méthode explode() coupe un string en plusieurs tableaux en utilisant un delimiter et chaque tableau est une sous chaines de caractères.

Notes:
Le  paramètre séparateur ne peut pas être un string vide.
La fonction explode() retourne un type booléen.

Exemple

$str = "Hello world !";
print_r (explode(" ",$str));
Exécution:

Array
(
    [0] => Hello
    [1] => world
    [2] => !
)

Syntaxe

explode(separateur,string,limit)

separateur : obligatoire. Spécifier le séparateur delimiter pour diviser la chaîne de caractères.
string: obligatoire. La chaîne de caractère à diviser.
limit: optionnel. Spécifier le nombre de tableaux à retourner.
Valeur possibles:
  • Supérieure à 0 - Retourne un tableau avec le maximum d'éléments.
  • Inférieure à 0: Retourne un tableau à l’exception des derniers éléments.
  • 0 - Retourne un tableau avec un seul élément.

Exemple:

$str = 'orange, bleu, vert, rouge';

// limite 0
print_r(explode(',',$str,0));

// limite supérieure à 0
print_r(explode(',',$str,2));

// limite inférieure à 0 
print_r(explode(',',$str,-1));
Exécution:

Array
(
    [0] => orange, bleu, vert, rouge
)
Array
(
    [0] => orange
    [1] =>  bleu, vert, rouge
)
Array
(
    [0] => orange
    [1] =>  bleu
    [2] =>  vert
)

Références:
https://www.php.net/manual/fr/function.explode.php

jQuery - méthode resize()

Cette méthode est un raccourci de la méthode .on('resize', handler) ou .trigger('resize').
L’événement resize est envoyé à l'élément window quand la dimension dans la fenêtre du navigateur change.

Syntaxe:

Déclencher la méthode resize() pour un élément:

$(selector).resize()
Attacher une fonction à l’événement de redimensionnement de resize:

$(selector).resize(function)

Exemple:

$( window ).resize(function() {
  $( "#log" ).append( "méthode resize() appelée" );
});
Dans cet exemple un message est concaténé à l'élément <div id="log"> à chaque fois la fenêtre est redimensionnée.

Références:
https://www.w3schools.com/jquery/event_resize.asp
https://api.jquery.com/resize/

jQuery - méthode hover()

La méthode hover() est appelée pour les deux événements mouseenter et mouseleave. Vous pouvez l'utiliser pour détecter quand la souris passe en dessous d'un élément.

.hover( handlerIn, handlerOut )

La méthode hover() est un raccourci de :

$( selector ).mouseenter( handlerIn ).mouseleave( handlerOut );
Syntaxe:

$( selector ).hover( handlerIn, handlerOut )
Exemple:

$( "p" ).hover(
  function() {        // Souris entre dans la zone
    $( this ).addClass( "hover" ); 
  }, function() {     // Souris quitte la zone
    $( this ).removeClass( "hover" ); 
  }
);

.hover( handlerInOut )

Cette méthode est utile quand le même traitement se répète pour les deux événement d'entré et de sortie de la zone d’élément cible. On aura pas besoin de copier le code dans les deux fonctions d’événement d'entrée et de sortie.

Syntaxe:

$(selector).hover(handlerInOut)
Quand on passe une seule fonction à la méthode hover(), elle va exécuter deux événements, mouseenter et mouseleave. Cela permet à l'utilisateur jQuery d'utiliser les différentes méthodes de basculement dans le gestionnaire ou de répondre différemment en fonction de event.type.

Exemple:

$( selector ).on( "Pointeur de souris à entré et quitté la zone", handlerInOut );

Références:
https://api.jquery.com/hover/