[Python 3] Méthodes de tri

ARTICLE EN COURS DE CONSTRUCTION

### 2 - TRI - ###

### 2.1 TRI : tuple
aa = (8, 4, 6, 1, 9, 5, 2, 7, 0, 3)
### 2.1.1 TRI : tuple : sorted()
print("### 2.1.1 TRI : tuple : sorted()")
sorted(aa)
print(aa)
print(sorted(aa))
print()

### 2.2 TRI : list à une dimension
aa = [8, 4, 6, 1, 9, 5, 2, 7, 0, 3]
### 2.2.1 TRI : list à une dimension : sorted()
print("### 2.2.1 TRI : list à une dimension : sorted()")
sorted(aa)
print(aa)
print(sorted(aa))
print()

### 2.2.2 TRI : list à une dimension : sort()
print("### 2.2.2 TRI : list à une dimension : sort()")
aa.sort()
print(aa)
print()

### 2.3 TRI : list à plusieurs dimensions
aa = [
("h", "J", 2),
("j", "I", 8),
("a", "G", 4),
("g", "H", 3),
("i", "E", 6),
("b", "D", 5),
("c", "B", 0),
("d", "F", 7),
("f", "C", 1),
("e", "A", 9)
]
### 2.3.1 TRI : list à plusieurs dimensions : sorted()
print("### 2.3 TRI : list à plusieurs dimensions : sorted()")
sorted(aa)
print(aa)
print(sorted(aa))
print()

### 2.3.2 TRI : list à plusieurs dimensions : lambda
print("### 2.3 TRI : list à plusieurs dimensions : lambda")
xx = sorted(aa, key=lambda x: x[0])
print(*xx)
yy = sorted(aa, key=lambda x: x[1])
print(*yy)
zz = sorted(aa, key=lambda x: x[2])
print(*zz)
print()

### 2.3.3 TRI : list à plusieurs dimensions : itemgetter
aa = [
("abricot ", "catégorie 1 ", "prix 1"),
("pomme ", "catégorie 1 ", "prix 1"),
("orange ", "catégorie 1 ", "prix 1"),
("orange ", "catégorie 2 ", "prix 3"),
("raisin ", "catégorie 1 ", "prix 3"),
("abricot ", "catégorie 2 ", "prix 2"),
("pomme ", "catégorie 1 ", "prix 1"),
("abricot ", "catégorie 2 ", "prix 2"),
("pomme ", "catégorie 1 ", "prix 1"),
("orange ", "catégorie 2 ", "prix 2")
]
from operator import itemgetter as ig
print("### 2.3 TRI : list à plusieurs dimensions : itemgetter")
zz = sorted(aa, key=ig(0,1,2))
print(*zz)
zz = sorted(aa, key=ig(1,0,2))

for i, j, k in zz:
print(i, j, k)

print()

### 2.4 TRI : dict
dico = {"Alain": 2, "Bernard": 3, "Christian": 4, "Dominique": 1}

### 2.4.1 TRI : dict : lambda
print("### 2.4.1 TRI : dict : lambda")
aa = dico.items()

zz = sorted(aa, key=lambda x: x[0])
print(*zz)
zz = sorted(aa, key=lambda x: x[1])
print(*zz)
print()

### 2.4.2 TRI : dict : itemgetter
from operator import itemgetter as ig
print("### 2.4.2 TRI : dict : itemgetter")

aa = dico.items()

zz = sorted(aa, key=ig(0))
print(*zz)
zz = sorted(aa, key=ig(1))
print(*zz)
print()

### 2.5 TRI : class
### 2.5.1 TRI : class : list (ou tuple) : attrgetter
class Fruits:
def __init__(self, aa, bb):
self.prod = aa
self.prix = bb

def __repr__(self):
return "\n{} : {}€".format(self.prod, self.prix)

fruits = [
Fruits("poires ", 3),
Fruits("pommes ", 2),
Fruits("oranges", 2),
Fruits("cerises", 4),
Fruits("abricot", 2)
]

from operator import attrgetter as ag
print("### 2.5.1 TRI : class : list (ou tuple) : attrgetter")
zz = sorted(fruits, key=ag("prod", "prix"))
print(*zz)

zz = sorted(fruits, key=ag("prix", "prod"))
print(*zz)
print()

### 2.5.2 TRI : class : dict : attrgetter
dico = {}
dico["poires"] = Fruits("poires ", 3)
dico["pommes"] = Fruits("pommes ", 2)
dico["oranges"] = Fruits("oranges ", 2)
dico["cerises"] = Fruits("cerises ", 4)
dico["abricots"] = Fruits("abricots", 2)

from operator import attrgetter as ag
print("### 2.5.2 TRI : class : dict : attrgetter")

zz = sorted(dico.values(), key=ag("prod", "prix"))
print(*zz)
zz = sorted(dico.values(), key=ag("prix", "prod"))
print(*zz)
Publicités

[Python 3] Trier un « Dictionnaire »

Dans de nombreux langages informatiques, on retrouve le « Dictionnaire », cette variable un petit peu particulière qui regroupe l’association d’un ensemble de « clés » à leur « valeur », comme un dictionnaire est le regroupement d’un ensemble de mots associés à leur définition.

Je ne m’étendrai pas, ici, sur le fonctionnement du dictionnaire; je rappellerai néanmoins que dans un dictionnaire, chaque clé (le mot) est unique (mais plusieurs clés peuvent avoir la même valeur).

En Python, on remarquera que l’affichage du contenu d’un dictionnaire est aléatoire; ainsi, si j’établis mon dictionnaire dico de la façon suivante et que j’en demande l’affichage par une fonction print()

dico = {"zéro" : 0, "un" : 1, "deux" : 2, "trois" : 3, "quatre" : 4, "cinq" : 5}
print(dico)

Résultat : {‘un’: 1, ‘quatre’: 4, ‘deux’: 2, ‘zéro’: 0, ‘cinq’: 5, ‘trois’: 3}

je constate que, même si l’affichage n’est pas particulièrement attrayant, les éléments qui composent notre dictionnaire sont présentés de façon erratique.

N’ayant pas la possibilité de modifier l’ordre d’affichage dans un dictionnaire, nous allons contourner ce problème en enregistrant l’ensemble de notre dictionnaire dans une variable que nous appellerons ici mavar

mavar = dico.items()

Notons simplement que pour réussir notre opération, nous devons faire appel à la méthode items().
Ensuite, nous appliquons la méthode sorted() pour effectuer le tri et l’enregistrons dans une variable que nous appelons montri

montri = sorted(mavar, key=lambda x: x[1])

La méthode sorted() appelle tout d’abord l’objet que nous souhaitons trier, à savoir la variable mavar dans laquelle nous avons enregistré l’ensemble des binômes contenus dans notre dictionnaire.

Nous choisissons ensuite, avec la suite key=lambda x: x[1], la « clé » key de notre tri (à ne pas confondre avec les clés du dictionnaire), qui va définir le paramètre de tri (tri par clés du dictionnaire – zéro, un, deux etc… – auquel cas la valeur entre crochets sera x[0], ou par valeurs – 0, 1, 2 – avec x[1]).

A noter que si nous voulions notre affichage dans l’ordre descendant, nous aurions rajouté à notre méthode sorted() la commande reverse=True, comme ceci

montri = sorted(mavar, key=lambda x: x[1], reverse=True)

Pour info : il existe d’autres méthodes pour faire un tri en Python, notamment en faisant appel à la commande itemgetter de la bibliothèque operator.

Il ne nous reste plus qu’à afficher le résultat de notre tri, avec une « liste en intention », par exemple, alternative intéressante à la traditionnelle boucle en for

[print(j, i) for i, j in montri]

Quelques explications concernant cette ligne : rappelons que la variable montri est composée de binômes :
zéro, 0
un, 1
deux, 2…
i et j vont respectivement venir extraire les clés (zéro, un, deux, trois…) et les valeurs (0, 1, 2..).
Notre ligne de code demande donc d’afficher successivement chaque binôme j, i (print(j, i) nous avons inversé l’ordre d’affichage) par l’intermédiaire d’une boucle (for i, j) contenu dans notre objet montri.

Voici le code dans sa totalité :

dico = {"zéro" : 0, "un" : 1, "deux" : 2, "trois" : 3, "quatre" : 4, "cinq" : 5}
mavar = dico.items()
montri = sorted(mavar, key=lambda x: x[1])
[print(j, i) for i, j in montri]


0 zéro
1 un
2 deux
3 trois
4 quatre
5 cinq

[VBA] Trier un tableau avec un double-clic

Voici un petit script qui permet de trier un tableau en fonction de la colonne du tableau dans laquelle l’utilisateur fait un double-clic; nous allons aborder ici 2 fonctions d’Excel : la programmation des macros dites évènementielles et la fonction de tri.

Private Sub Worksheet_BeforeDoubleClick(ByVal Target As Range, Cancel As Boolean)

Dim myRange As Range

Cancel = True

Set myRange = Range("D10").CurrentRegion

If Not Intersect(myRange, Target) Is Nothing Then
    myRange.Sort key1:=Cells(myRange.Cells(1).Row, Target.Column), Header:=xlYes
End If

Target.Select

End Sub

Explications

La première notion que nous allons aborder est celle d’évènement.
Un évènement peut être l’ouverture d’un classeur, un clic droit, un changement d’onglet etc… ici, l’évènement qui va automatiquement déclencher notre macro est le double-clic.

Pour configurer l’évènement, nous ouvrons la fenêtre VBA (ALT + F11) et accédons à la fenêtre de projets (CTRL + R) si celle-ci n’est pas ouverte.
Evenement

Nous pouvons choisir d’activer l’évènement à tout le classeur ou bien à une seule des feuilles de ce classeur.
Dans notre cas de figure, il s’agit de l’appliquer à une seule feuille, nous allons donc là sélectionner dans notre fenêtre de projets à gauche et allons ensuite sélectionner l’option Worksheet du petit menu déroulant comme indiqué sur l’image.
Si nous avions voulu appliquer l’évènement à tout le classeur, nous aurions sélectionné l’option ThisWorkbook dans la fenêtre de gauche et ensuite l’option Workbook du menu déroulant.
En sélectionnant l’option Worksheet, le message suivant apparait dans notre fenêtre de droite

Private Sub Worksheet_SelectionChange(ByVal Target As Range)

End Sub

et l’option SelectionChange dans le menu déroulant de droite.
Nous pouvons effacer Private Sub Worksheet_SelectionChange(ByVal Target As Range)
End Sub
et nous allons sélectionner l’option BeforeDoubleClick dans le menu déroulant de droite.
Apparait alors le code suivant dans la fenêtre générale :

Private Sub Worksheet_BeforeDoubleClick(ByVal Target As Range, Cancel As Boolean)

End Sub

Après avoir déclaré notre variable Dim myRange As Range, nous instruisons Excel sur la gestion du double-clic Cancel = True : en temps normal, lorsque nous double-cliquons dans une cellule, le curseur sélectionne cette cellule et se met en position d’écriture. Cette commande empêche le curseur de sélectionner la cellule car ce n’est pas, ici, le but recherché par le double-clic.

L’étape suivante consiste à définir la plage pour laquelle le double-clic sera actif :
Set myRange = Range("D10").CurrentRegion
Une plage est un « objet », donc la variable myRange à laquelle nous allons allouer cette plage est suivi de la commande Set (voir l’article : Déterminer la dernière ligne/colonne d’un tableau pour de plus amples explications).
La commande .CurrentRegion qui suit la cellule D10 (que nous avons choisie arbitrairement, toute autre cellule appartenant au tableau ou adjacente à celui-ci fonctionne)  demande à Excel de prendre en compte la plage de cellules adjacentes et non vides autour de la cellule D10. Pour mieux comprendre son fonctionnement, voici une image sur laquelle apparait en jaune la plage sélectionnée par la commande Range("B4").CurrentRegion.
CurrentRegion

Dans notre cas, la plage correspond au tableau que l’on va trier.

La commande If Not Intersect(myRange, Target) Is Nothing Then va vérifier si le double-clic doit générer le tri du tableau ou pas; pour cela elle va contrôler que le double-clic a lieu dans notre plage myRange précédemment définie, autrement dit, dans le tableau.
Nous connaissons donc la plage définie par myRange; Target correspond à la cellule sur laquelle nous double-cliquons.
Traduisons notre commande : si (If) l’intersection (Intersect) entre la plage de mon tableau et la cellule sur laquelle nous double-cliquons (myRange, Target ) n’est pas rien (Not … Is Nothing) Then (alors exécuter…). autrement dit si la cellule sur laquelle nous double-cliquons se trouve dans la plage de notre tableau, alors exécuter…

myRange.Sort effectue le tri pour la plage myRange.

Header:=xlYes demande à la macro de considérer la première ligne de la plage comme étant l’en-tête du tableau et de ne pas l’inclure dans le tri; une valeur xlNo aurait également procédé au tri de la première ligne de la plage séléctionnée.

key1:=Cells(myRange.Cells(1).Row, Target.Column) cette dernière partie du code détermine la clé du tri; dans un cas figure normal, on peut trier un tableau avec plusieurs clés de tri (Key1, Key2, Key3… en fonction de l’ordre du tri).
Mais, dans notre cas de figure, puisqu’on ne peut double-cliquer que sur une seule cellule à la fois, nous sommes limités à une seule valeur de tri. La clé de tri correspond à la cellule de l’en-tête choisie pour réaliser le tri : Key1 sera donc suivi de l’adresse d’une cellule appartenant à l’en-tête du tableau.

La syntaxe de la commande Cells est la suivante : Cells(N° de ligne de la cellule, N° de colonne de la cellule).
myRange.Cells(1).Row représente donc le N° d’une ligne et Target.Column, le N° d’une colonne.
Target.Column identifie le N° de colonne de la cellule sur laquelle nous avons double-cliqué; .Column signifie N° de colonne, à ne pas confondre avec Columns qui représente une colonne physique.

Pour myRange.Cells(1).Row, c’est à peine plus compliqué. Myrange identifie notre plage; une plage est composée de cellules.
Puisque nous avons une collection (une série) identifiée de cellules, nous savons que chaque cellule de cette collection possède un index (autrement dit un N° d’ordre classant cette cellule par rapport aux autres cellules de la plage; voir l’article Classer les onglets d’un classeur par ordre alphanumérique pour plus d’informations concernant le fonctionnement de l’index). Nous savons que la première cellule de notre plage myRange.Cells(1) correspond à la première cellule composant l’en-tête de notre tableau, autrement dit la cellule B2 nommée N° INSEE.
Pour vous en convaincre, tapez myRange.Cells(1).Select dans le code programme juste sous l’instruction Set myRange = Range("D10").CurrentRegion

Il ne nous en faut pas plus pour définir le N° de ligne de notre cellule. Comme nous avons extrait le N° de colonne, nous allons récupérer le N° de ligne en ajoutant la commande .Row (qui est le N° de ligne à ne pas confondre avec Rows qui représente une ligne physique dans la grille).
Les paramètres de la cellule servant de clé pour le tri sont maintenant définis; il nous reste à spécifier la commande Target.Select afin de maintenir le curseur sur la cellule sur laquelle a été effectué le double-clic.

Fichier au format .xls ci-dessous
Tri Auto

[VBA] Classer les onglets d’un classeur par ordre alphanumérique

Classement alphabétique

Certains classeurs, en particulier ceux dont le nombre d’onglets est conséquent, peuvent nécessiter le classement de leurs feuilles par ordre, alphabétique ou numérique… voici donc un petit script qui s’acquitte de cette tâche.

Sub ClassementAlphabétique()

Dim a As Integer, b As Integer
Application.ScreenUpdating = False

For a = 1 To Sheets.Count
    For b = a + 1 To Sheets.Count
        If UCase(Sheets(a).Name) > UCase(Sheets(b).Name) Then
            Sheets(b).Move before:=Sheets(a)
        End If
    Next b
Next a

End Sub

Explications

Le principe de ce classement est simple : la macro compare le nom de chaque onglet (tour à tour onglet « Référence ») avec tous les autres (onglets « Cible ») et lorsque le nom de l’onglet Référence « est supérieur » (on utilise le signe > pour la comparaison) à l’onglet Cible auquel il est comparé, c’est à dire que le nom de l’onglet Référence arrive après celui de l’onglet Cible dans le classement alphabétique, alors l’onglet Cible est déplacé juste devant l’onglet Référence dans le classeur et devient l’onglet Référence.

Pour faire cette comparaison, nous utiliserons 2 boucles entrelacées.
Après la déclaration des variables Dim a As Integer, b As Integer et la désactivation de la mise à jour écran Application.ScreenUpdating = False qui accélère la vitesse d’exécution de la macro en neutralisant la mise à jour automatique de l’écran, la double boucle compare les noms des onglets et les déplace, au besoin.

For a = 1 To Sheets.Count
Next a

Voici notre première boucle dont la variable a va prendre toutes les valeurs de 1 jusqu’à Sheets.Count autrement dit, le nombre total d’onglets du classeur.
Chaque feuille du classeur possède un nom qui apparait dans son onglet mais également un N° : ce N° est l’ordre dans lequel apprait l’onglet dans le classeur. Ce N° s’appelle l’index et existe pour chaque collection d’objets (c’est a dire tous les objets d’une même famille : les feuilles, les cellules, les colonnes, images etc… ).
Ouvrez un nouveau classeur, créez une nouvelle macro et insérez le code suivant MsgBox Sheets("Feuil2").Index
Déplacez maintenant votre onglet « Feuil2 » et relancez la même macro.

C’est donc cette fonction que nous allons utiliser pour notre classement.
La valeur de la variable a de cette première boucle représente la N° d’index de l’onglet Référence.

La valeur de la variable b de la seconde boucle

For b = a + 1 To Sheets.Count
Next b

représente la N° d’index de l’onglet Cible.

Donc valeur a = index onglet Référence / valeur b = index onglet Cible
L’entrelacement des boucles va donc faire la comparaison suivante :
If Sheets(a).Name > Sheets(b).Name Then
Voici comment commence le processus de comparaison :
a=1
b=a+1 donc 2
Si le nom de la feuille 1 (a) > au nom de la feuille 2 (b) alors
Si le nom de la feuille 1 (a) > au nom de la feuille 3 (b) alors
Si le nom de la feuille 1 (a) > au nom de la feuille 4 (b) alors
etc…
et ce jusqu’à ce que b = le N° d’index de la dernière feuille du classeur.

ensuite

a=2
b=a+1 donc 3
Si le nom de la feuille 2 (a) > au nom de la feuille 3 (b) alors
Si le nom de la feuille 2 (a) > au nom de la feuille 4 (b) alors
Si le nom de la feuille 2 (a) > au nom de la feuille 5 (b) alors
etc…

et ce jusqu’à ce que a = le N° d’index de la dernière feuille du classeur.

Nous avons ignoré la commande UCase dans l’explication précédente
UCase(Sheets(a).Name)
UCase change virtuellement la chaine de caractères qu’il encadre (ici le nom de l’onglet) en caractères majuscules.
Le changement ne se fait pas physiquement dans l’onglet mais lorsque la macro fait sa comparaison entre l’onglet nommé FeUille et celui nommé SheeT , elle lit FEUILLE et SHEET. Cette astuce contourne le fait qu’Excel considère que la valeur d’une lettre en majuscule est différente de la valeur de cette même lettre en minuscule.
Pour vous en convaincre, lancez ce code :
If "F" = "F" Then MsgBox "Pareil" Else MsgBox "Différent"
essayez ensuite en remplaçant le « F » à droite du signe = par « f »
If "F" = "f" Then MsgBox "Pareil" Else MsgBox "Différent"

La ligne suivante de la macro va procéder au déplacement des fichiers lorsque la condition est vérifiée
Sheets(b).Move before:=Sheets(a)
Ici, on demande simplement à l’onglet Cible de venir se placer juste devant l’onglet référence.
Ce déplacement provoque une modification des index : l’index de l’onglet Cible prend donc la valeur a et devient l’onglet Référence et l’onglet Référence prend la valeur a+1 et devient un onglet Cible.
Autrement dit : supposons que La feuille N°1 nommée CCC soit l’onglet Référence et la feuille N°4 nommée AAA soit l’onglet Cible.

AAA < CCC donc la feuille AAA N°4 est déplacée devant la feuille CCC N°1 :
La feuille AAA devient donc la feuille N°1 du classeur et par la même occasion la feuille Référence puisqu’on est en train de « boucler » sur a=1 et la feuille CCC devient la feuille N°2 et donc une feuille Cible.

Voilà comment s’effectue le classement.

Classement numérique

Vous l’avez peut-être déjà remarqué : cette macro fonctionne avec des noms d’onglets alphabétiques mais nous donne des résultats inattendus lorsque nous comparons des noms d’onglets numériques.

supposons que nous ayons des onglets nommés dans cet ordre ci :
42 – 7 – 1 – 9 – 01 – 11 – 4
La macro va faire le classement suivant :
01 – 1 – 11 – 4 – 42 – 7 – 9
c’est tout simplement qu’à ce stade, elle considère ces valeurs non pas comme des valeurs numériques mais comme étant des chaînes de caractères.
Il va falloir lui indiquer que ces valeurs sont des valeurs numériques, nous allons apporter une simple modification en remplaçant la commande UCase qui n’a plus lieu d’être par la commande Val.
If Val(Sheets(a).Name) > Val(Sheets(b).Name) Then.
Val indique tout simplement que la valeur qu’elle encadre est un nombre et pas une chaîne de caractères.

Classement alphanumérique

Si vous avez essayé de classer les noms d’onglets attribués par défaut par Excel : Feuil1, Feuil2, Feuil11 par exemple, vous avez rencontré le même problème qu’en essayant de classer les onglets « numériques » avec la macro sans la commande Val : on se retrouve avec le classement suivant : Feuil1, Feuil11, Feuil2.

Là, ça se complique ! La macro suivante résout le problème pour des noms d’onglets commençant par des lettres et finissant par des nombres. Pour l’inverse, elle nécessiterait quelques légères modifications.
Je ne rentrerai pas dans le détail de sa construction car elle fait appel à des notions de programmation que nous n’avons pas abordées et qui feront l’objet de prochains articles mais l’idée est d’isoler la partie alphabétique du nom de l’onglet de sa partie numérique.
Il s’agit ensuite d’enregistrer ces deux valeurs ainsi obtenues dans une « variable tableau » à 2 dimensions et comparer chacune des 2 valeurs de l’onglet Référence aux valeurs respectives des onglets Cible et effectuer le déplacement physique de l’onglet, le cas échéant ainsi que réactualiser l’ordre dans lequel les valeurs alphabétique et numérique de chaque onglet sont enregistrées dan la variable tableau.
Voici le code :

Option Base 1

Sub ClassementAlphaNumerique()
Application.ScreenUpdating = False

Dim sh As Worksheet, aa As Worksheet, bb As Worksheet
Dim sn As String, zz As String
Dim nbS As Integer, d As Integer
Dim c As Byte
Dim Tablo() As Variant

nbS = Sheets.Count
ReDim Tablo(nbS, 2)

'Split du nom de l'onglet
For Each sh In Worksheets
    sn = sh.Name
    zz = Mid(sn, Len(sn), 1)
    Do While IsNumeric(zz)'boucle à partir du dernier caractère
        c = c + 1
        If c = Len(sn) Then Exit Do's'il n'existe pas de valeur alphabétique
        zz = Mid(sn, Len(sn) - c, 1)
    Loop
    d = d + 1
    Tablo(d, 1) = Mid(sn, 1, Len(sn) - c)'affectation de la partie alphabétique
    Tablo(d, 2) = (Mid(sn, Len(sn) - c + 1, Len(sn)))'affectation de la partie numérique
    c = 0
Next sh

For a = LBound(Tablo) To UBound(Tablo)
    Set aa = Sheets(Tablo(a, 1) & Tablo(a, 2))'reconstitution du nom de l'onglet à partir des valeurs du tablo - Référence
    For b = a + 1 To UBound(Tablo)
        Set bb = Sheets(Tablo(b, 1) & Tablo(b, 2)) 'Cible

        If UCase(Tablo(a, 1)) > UCase(Tablo(b, 1)) Then'classement des onglets de valeurs alphabétiques différentes, exp : AA1 et BBC

            routine Tablo(a, 1), Tablo(a, 2), Tablo(b, 1), Tablo(b, 2), aa, bb, b

        ElseIf UCase(Tablo(a, 1)) = UCase(Tablo(b, 1)) _
        And Val(Tablo(a, 2)) = Val(Tablo(b, 2)) _
        And Len(Tablo(a, 2)) < Len(Tablo(b, 2)) Then'classement des onglets de même valeur numérique mais de formats différents, exp : 1 et 01

            routine Tablo(a, 1), Tablo(a, 2), Tablo(b, 1), Tablo(b, 2), aa, bb, b

        ElseIf UCase(Tablo(a, 1)) = UCase(Tablo(b, 1)) _
        And Val(Tablo(a, 2)) > Val(Tablo(b, 2)) Then 'classement des onglets de valeur même valeur alphabétique mais de valeurs numériques différentes,exp : AA1 et AA8

            routine Tablo(a, 1), Tablo(a, 2), Tablo(b, 1), Tablo(b, 2), aa, bb, b
        End If
    Next b
Next a

End Sub

Sub routine(ta1, ta2, tb1, tb2, aa, bb, b)

'tri du Tablo
Temp1 = ta1
Temp2 = ta2
ta1 = tb1
ta2 = tb2
tb1 = Temp1
tb2 = Temp2

'déplacement des onglets et réaffectation des variable aa et bb
bb.Move before:=aa
Set aa = bb

Set bb = Sheets(tb1 & tb2)
bb.Move after:=Sheets(b)'l'onglet Référence initial prend la place d'onglet Cible afin que l'ordre des onglets soit synchro avec les infos du tablo
End Sub

Cette macro gère également des noms d’onglets entièrement numériques ou alphabétiques.

Et pour ceux qui ont pour habitude de nommer, dans un même classeur, certains onglets avec des chaines alphanumériques commençant par une lettre et d’autres commençant par un chiffre, c’est par là !

Ci-dessous le fichier au format .xls contenant les macros présentées dans cet article et un petit module supplémentaire, « Alea » qui vous permettra de classer aléatoirement les onglets afin d’effectuer vos tests.

Classement onglets