La méthode str.join() des listes Python

Contenu du cours

A propos de la méthode join()
Utilisation Basique et Exemples
Travailler avec Différents Types d'Itérables
Cas d'Utilisation Avancés
Bonnes Pratiques et Pièges à Éviter
Fonctions Utilitaires et Exemples Complets

1. A propos de la méthode join()

1.1 Qu'est-ce que join() ?

La méthode join() est une méthode de la classe str (chaîne de caractères) en Python qui permet de concaténer les éléments d'un itérable en une seule chaîne, en insérant la chaîne appelante comme séparateur entre chaque élément.

1.2 La syntaxe fondamentale

separateur.join(iterable)

1	separateur.join(iterable)

Où separateur est la chaîne qui sera insérée entre les éléments et iterable est une collection (liste, tuple, etc.) d'éléments qui doivent être des chaînes de caractères.

2. Utilisation Basique et Exemples

2.1 Concaténation simple de liste de mots

# Séparateur espace
mots = ["Bonjour", "le", "monde"]
resultat = " ".join(mots)
print(resultat)  # "Bonjour le monde"

# Séparateur virgule
noms = ["Alice", "Bob", "Charlie"]
resultat = ", ".join(noms)
print(resultat)  # "Alice, Bob, Charlie"

# Séparateur vide (concaténation simple)
lettres = ["P", "y", "t", "h", "o", "n"]
mot = "".join(lettres)
print(mot)  # "Python"

# Séparateur espace

mots = ["Bonjour", "le", "monde"]

resultat = " ".join(mots)

print(resultat) # "Bonjour le monde"

# Séparateur virgule

noms = ["Alice", "Bob", "Charlie"]

resultat = ", ".join(noms)

print(resultat) # "Alice, Bob, Charlie"

# Séparateur vide (concaténation simple)

lettres = ["P", "y", "t", "h", "o", "n"]

mot = "".join(lettres)

print(mot) # "Python"

2.2 Différents types de séparateurs

# Séparateur nouvelle ligne
lignes = ["Ligne 1", "Ligne 2", "Ligne 3"]
texte = "\n".join(lignes)
print(texte)
# Sortie:
# Ligne 1
# Ligne 2
# Ligne 3

# Séparateur tabulation
colonnes = ["Nom", "Âge", "Ville"]
entete = "\t".join(colonnes)
print(entete)  # "Nom	Âge	Ville"

# Séparateur personnalisé
elements = ["A", "B", "C"]
resultat = " -> ".join(elements)
print(resultat)  # "A -> B -> C"

# Séparateur multiple caractères
resultat = "---".join(["Début", "Milieu", "Fin"])
print(resultat)  # "Début---Milieu---Fin"

# Séparateur nouvelle ligne

lignes = ["Ligne 1", "Ligne 2", "Ligne 3"]

texte = "\n".join(lignes)

print(texte)

# Sortie:

# Ligne 1

# Ligne 2

# Ligne 3

# Séparateur tabulation

colonnes = ["Nom", "Âge", "Ville"]

entete = "\t".join(colonnes)

print(entete) # "Nom Âge Ville"

# Séparateur personnalisé

elements = ["A", "B", "C"]

resultat = " -> ".join(elements)

print(resultat) # "A -> B -> C"

# Séparateur multiple caractères

resultat = "---".join(["Début", "Milieu", "Fin"])

print(resultat) # "Début---Milieu---Fin"

3. Travailler avec Différents Types d'Itérables

3.1 Listes, tuples et autres collections

# Avec une liste
liste = ["a", "b", "c"]
print("Liste:", "-".join(liste))  # "a-b-c"

# Avec un tuple
tuple_ex = ("x", "y", "z")
print("Tuple:", "+".join(tuple_ex))  # "x+y+z"

# Avec un set (attention: ordre non garanti)
ensemble = {"pomme", "banane", "orange"}
print("Set:", ", ".join(ensemble))

# Avec une chaîne de caractères (itérable de caractères)
chaine = "Python"
print("Chaîne:", ".".join(chaine))  # "P.y.t.h.o.n"

# Avec un range converti
nombres = map(str, range(1, 6))
print("Range:", "|".join(nombres))  # "1|2|3|4|5"

# Avec une liste

liste = ["a", "b", "c"]

print("Liste:", "-".join(liste)) # "a-b-c"

# Avec un tuple

tuple_ex = ("x", "y", "z")

print("Tuple:", "+".join(tuple_ex)) # "x+y+z"

# Avec un set (attention: ordre non garanti)

ensemble = {"pomme", "banane", "orange"}

print("Set:", ", ".join(ensemble))

# Avec une chaîne de caractères (itérable de caractères)

chaine = "Python"

print("Chaîne:", ".".join(chaine)) # "P.y.t.h.o.n"

# Avec un range converti

nombres = map(str, range(1, 6))

print("Range:", "|".join(nombres)) # "1|2|3|4|5"

3.2 Gestion des éléments non-string

# ERREUR: éléments non-string
nombres = [1, 2, 3, 4, 5]
# erreur = "-".join(nombres)  # TypeError: sequence item 0: expected str instance, int found

# Solution 1: Utiliser map() pour convertir
nombres_str = map(str, nombres)
resultat = "-".join(nombres_str)
print("Avec map:", resultat)  # "1-2-3-4-5"

# Solution 2: List comprehension
resultat = "-".join([str(x) for x in nombres])
print("Avec comprehension:", resultat)  # "1-2-3-4-5"

# Solution 3: Generator expression
resultat = "-".join(str(x) for x in nombres)
print("Avec générateur:", resultat)  # "1-2-3-4-5"

# Solution 4: Formatage
flottants = [3.14, 2.71, 1.41]
resultat = " | ".join(f"{x:.2f}" for x in flottants)
print("Formaté:", resultat)  # "3.14 | 2.71 | 1.41"

# ERREUR: éléments non-string

nombres = [1, 2, 3, 4, 5]

# erreur = "-".join(nombres) # TypeError: sequence item 0: expected str instance, int found

# Solution 1: Utiliser map() pour convertir

nombres_str = map(str, nombres)

resultat = "-".join(nombres_str)

print("Avec map:", resultat) # "1-2-3-4-5"

# Solution 2: List comprehension

resultat = "-".join([str(x) for x in nombres])

print("Avec comprehension:", resultat) # "1-2-3-4-5"

# Solution 3: Generator expression

resultat = "-".join(str(x) for x in nombres)

print("Avec générateur:", resultat) # "1-2-3-4-5"

# Solution 4: Formatage

flottants = [3.14, 2.71, 1.41]

resultat = " | ".join(f"{x:.2f}" for x in flottants)

print("Formaté:", resultat) # "3.14 | 2.71 | 1.41"

4. Cas d'Utilisation Avancés

4.1 Construction de chemins de fichiers

import os

# Construction manuelle avec join()
repertoires = ["home", "utilisateur", "documents", "rapport.txt"]
chemin_linux = "/".join(repertoires)
print("Chemin Linux:", chemin_linux)  # "home/utilisateur/documents/rapport.txt"

chemin_windows = "\\".join(repertoires)
print("Chemin Windows:", chemin_windows)  # "home\utilisateur\documents\rapport.txt"

# Comparaison avec os.path.join (meilleure pratique)
chemin_os = os.path.join("home", "utilisateur", "documents", "rapport.txt")
print("Avec os.path.join:", chemin_os)

# Construction de URL
parties_url = ["https:", "", "example.com", "api", "v1", "users"]
url = "/".join(parties_url)
print("URL:", url)  # "https://example.com/api/v1/users"

import os

# Construction manuelle avec join()

repertoires = ["home", "utilisateur", "documents", "rapport.txt"]

chemin_linux = "/".join(repertoires)

print("Chemin Linux:", chemin_linux) # "home/utilisateur/documents/rapport.txt"

chemin_windows = "\\".join(repertoires)

print("Chemin Windows:", chemin_windows) # "home\utilisateur\documents\rapport.txt"

# Comparaison avec os.path.join (meilleure pratique)

chemin_os = os.path.join("home", "utilisateur", "documents", "rapport.txt")

print("Avec os.path.join:", chemin_os)

# Construction de URL

parties_url = ["https:", "", "example.com", "api", "v1", "users"]

url = "/".join(parties_url)

print("URL:", url) # "https://example.com/api/v1/users"

4.2 Génération de CSV et formats structurés

# Génération de ligne CSV
donnees = ["Alice", "30", "Paris", "Développeuse"]
ligne_csv = ";".join(donnees)
print("CSV:", ligne_csv)  # "Alice;30;Paris;Développeuse"

# Génération de HTML
items = ["Pommes", "Bananes", "Oranges"]
liste_html = "<ul>\n" + "\n".join(f"  <li>{item}</li>" for item in items) + "\n</ul>"
print("HTML:")
print(liste_html)

# Génération de SQL
valeurs = ["Alice", "Paris", "3000"]
sql = "INSERT INTO users (nom, ville, salaire) VALUES ('" + "', '".join(valeurs) + "')"
print("SQL:", sql)
# ATTENTION: risque d'injection SQL, utiliser des paramètres préparés en pratique

# Génération de ligne CSV

donnees = ["Alice", "30", "Paris", "Développeuse"]

ligne_csv = ";".join(donnees)

print("CSV:", ligne_csv) # "Alice;30;Paris;Développeuse"

# Génération de HTML

items = ["Pommes", "Bananes", "Oranges"]

liste_html = "<ul>\n" + "\n".join(f" <li>{item}</li>" for item in items) + "\n</ul>"

print("HTML:")

print(liste_html)

# Génération de SQL

valeurs = ["Alice", "Paris", "3000"]

sql = "INSERT INTO users (nom, ville, salaire) VALUES ('" + "', '".join(valeurs) + "')"

print("SQL:", sql)

# ATTENTION: risque d'injection SQL, utiliser des paramètres préparés en pratique

4.3 Performance et comparaison avec l'opérateur +

import time

def test_performance_concat(n):
    """Test de performance: join() vs concaténation avec +"""
    
    # Test avec join()
    debut = time.time()
    mots = ["mot"] * n
    resultat = " ".join(mots)
    temps_join = time.time() - debut
    
    # Test avec opérateur +
    debut = time.time()
    resultat = ""
    for i in range(n):
        resultat += " mot" if i > 0 else "mot"
    temps_concat = time.time() - début
    
    return temps_join, temps_concat

# Test avec différentes tailles
tailles = [100, 1000, 10000, 100000]
print("Performance join() vs +:")
print("N\tjoin()\t\t+")
print("-" * 30)

for n in tailles:
    t1, t2 = test_performance_concat(n)
    print(f"{n}\t{t1:.6f}\t{t2:.6f}")

# join() est plus efficace car il alloue la mémoire une seule fois
# L'opérateur + crée une nouvelle chaîne à chaque itération

import time

def test_performance_concat(n):

"""Test de performance: join() vs concaténation avec +"""

# Test avec join()

debut = time.time()

mots = ["mot"] * n

resultat = " ".join(mots)

temps_join = time.time() - debut

# Test avec opérateur +

debut = time.time()

resultat = ""

for i in range(n):

resultat += " mot" if i > 0 else "mot"

temps_concat = time.time() - début

return temps_join, temps_concat

# Test avec différentes tailles

tailles = [100, 1000, 10000, 100000]

print("Performance join() vs +:")

print("N\tjoin()\t\t+")

print("-" * 30)

for n in tailles:

t1, t2 = test_performance_concat(n)

print(f"{n}\t{t1:.6f}\t{t2:.6f}")

# join() est plus efficace car il alloue la mémoire une seule fois

# L'opérateur + crée une nouvelle chaîne à chaque itération

5. Bonnes Pratiques et Pièges à Éviter

5.1 Gestion des cas vides et None

# Itérable vide
resultat = ", ".join([])
print("Liste vide:", resultat)  # "" (chaîne vide)
print("Longueur:", len(resultat))  # 0

# Itérable avec un seul élément
resultat = "-".join(["seul"])
print("Un seul élément:", resultat)  # "seul"

# Itérable avec valeurs None et vides
donnees = ["a", "", "c", None, "e"]

# Méthode 1: Filtrer les None
resultat = "-".join(str(x) for x in donnees if x is not None)
print("Sans None:", resultat)  # "a--c-e"

# Méthode 2: Remplacer les None
resultat = "-".join("N/A" if x is None else str(x) for x in donnees)
print("Avec remplacement:", resultat)  # "a--c-N/A-e"

# Méthode 3: Filtrer les valeurs "fausses"
resultat = "-".join(filter(None, donnees))
print("Filtre des falsy:", resultat)  # "a-c-e"

# Itérable vide

resultat = ", ".join([])

print("Liste vide:", resultat) # "" (chaîne vide)

print("Longueur:", len(resultat)) # 0

# Itérable avec un seul élément

resultat = "-".join(["seul"])

print("Un seul élément:", resultat) # "seul"

# Itérable avec valeurs None et vides

donnees = ["a", "", "c", None, "e"]

# Méthode 1: Filtrer les None

resultat = "-".join(str(x) for x in donnees if x is not None)

print("Sans None:", resultat) # "a--c-e"

# Méthode 2: Remplacer les None

resultat = "-".join("N/A" if x is None else str(x) for x in donnees)

print("Avec remplacement:", resultat) # "a--c-N/A-e"

# Méthode 3: Filtrer les valeurs "fausses"

resultat = "-".join(filter(None, donnees))

print("Filtre des falsy:", resultat) # "a-c-e"

5.2 Erreurs courantes et solutions

# ERREUR 1: Inverser l'ordre
mots = ["Hello", "World"]
# erreur = mots.join(" ")  # AttributeError: 'list' object has no attribute 'join'

# CORRECTION
correct = " ".join(mots)
print("Correct:", correct)  # "Hello World"

# ERREUR 2: Oublier de convertir les nombres
nombres = [1, 2, 3]
# erreur = ",".join(nombres)  # TypeError

# CORRECTION
correct = ",".join(map(str, nombres))
print("Nombres convertis:", correct)  # "1,2,3"

# ERREUR 3: Itérable non itérable
# erreur = "-".join(42)  # TypeError: 'int' object is not iterable

# CORRECTION
correct = "-".join(str(42))
print("Nombre seul:", correct)  # "4-2" (car str(42) = "42" qui est itérable)

# Pour un seul nombre à afficher
correct = str(42)
print("Nombre en chaîne:", correct)  # "42"

# ERREUR 1: Inverser l'ordre

mots = ["Hello", "World"]

# erreur = mots.join(" ") # AttributeError: 'list' object has no attribute 'join'

# CORRECTION

correct = " ".join(mots)

print("Correct:", correct) # "Hello World"

# ERREUR 2: Oublier de convertir les nombres

nombres = [1, 2, 3]

# erreur = ",".join(nombres) # TypeError

# CORRECTION

correct = ",".join(map(str, nombres))

print("Nombres convertis:", correct) # "1,2,3"

# ERREUR 3: Itérable non itérable

# erreur = "-".join(42) # TypeError: 'int' object is not iterable

# CORRECTION

correct = "-".join(str(42))

print("Nombre seul:", correct) # "4-2" (car str(42) = "42" qui est itérable)

# Pour un seul nombre à afficher

correct = str(42)

print("Nombre en chaîne:", correct) # "42"

5.3 Utilisation avec des générateurs

# Générateur simple
def generateur_nombres(n):
    """Génère les nombres de 1 à n"""
    for i in range(1, n + 1):
        yield str(i)

# Utilisation avec join()
resultat = "-".join(generateur_nombres(5))
print("Avec générateur:", resultat)  # "1-2-3-4-5"

# Générateur infini (mais join() s'arrête quand même)
def nombres_infinis():
    i = 1
    while True:
        yield str(i)
        i += 1

# Attention: cela créerait une chaîne infinie!
# resultat = "-".join(nombres_infinis())  # Ne pas exécuter!

# Utilisation avec itertools.islice pour limiter
from itertools import islice
resultat = "-".join(islice(nombres_infinis(), 5))
print("Générateur limité:", resultat)  # "1-2-3-4-5"

# Expression génératrice avec condition
nombres = range(1, 11)
resultat = "|".join(str(x) for x in nombres if x % 2 == 0)
print("Pairs seulement:", resultat)  # "2|4|6|8|10"

# Générateur simple

def generateur_nombres(n):

"""Génère les nombres de 1 à n"""

for i in range(1, n + 1):

yield str(i)

# Utilisation avec join()

resultat = "-".join(generateur_nombres(5))

print("Avec générateur:", resultat) # "1-2-3-4-5"

# Générateur infini (mais join() s'arrête quand même)

def nombres_infinis():

i = 1

while True:

yield str(i)

i += 1

# Attention: cela créerait une chaîne infinie!

# resultat = "-".join(nombres_infinis()) # Ne pas exécuter!

# Utilisation avec itertools.islice pour limiter

from itertools import islice

resultat = "-".join(islice(nombres_infinis(), 5))

print("Générateur limité:", resultat) # "1-2-3-4-5"

# Expression génératrice avec condition

nombres = range(1, 11)

resultat = "|".join(str(x) for x in nombres if x % 2 == 0)

print("Pairs seulement:", resultat) # "2|4|6|8|10"

6. Fonctions Utilitaires et Exemples Complets

6.1 Fonctions wrapper personnalisées

def join_avec_gestion_erreurs(separateur, iterable, default=""):
    """
    Version sécurisée de join() avec valeur par défaut
    """
    try:
        return separateur.join(str(item) for item in iterable)
    except (TypeError, AttributeError):
        return default

def join_formatte(separateur, iterable, format_spec=""):
    """
    Join avec formatage optionnel des éléments
    """
    if format_spec:
        return separateur.join(f"{item:{format_spec}}" for item in iterable)
    else:
        return separateur.join(str(item) for item in iterable)

# Tests
print("Avec gestion erreurs:", join_avec_gestion_erreurs(", ", [1, 2, 3]))
print("Valeur par défaut:", join_avec_gestion_erreurs(", ", None, "N/A"))

nombres = [3.14159, 2.71828, 1.41421]
print("Formaté:", join_formatte(" | ", nombres, ".3f"))  # "3.142 | 2.718 | 1.414"

def join_avec_gestion_erreurs(separateur, iterable, default=""):

"""

Version sécurisée de join() avec valeur par défaut

"""

try:

return separateur.join(str(item) for item in iterable)

except (TypeError, AttributeError):

return default

def join_formatte(separateur, iterable, format_spec=""):

"""

Join avec formatage optionnel des éléments

"""

if format_spec:

return separateur.join(f"{item:{format_spec}}" for item in iterable)

else:

return separateur.join(str(item) for item in iterable)

# Tests

print("Avec gestion erreurs:", join_avec_gestion_erreurs(", ", [1, 2, 3]))

print("Valeur par défaut:", join_avec_gestion_erreurs(", ", None, "N/A"))

nombres = [3.14159, 2.71828, 1.41421]

print("Formaté:", join_formatte(" | ", nombres, ".3f")) # "3.142 | 2.718 | 1.414"

6.2 Exemple complet: Construction de rapport

def generer_rapport(donnees, titre, separateur=" | "):
    """
    Génère un rapport formaté à partir de données
    """
    # En-tête
    lignes = []
    lignes.append("=" * 50)
    lignes.append(f"RAPPORT: {titre}")
    lignes.append("=" * 50)
    lignes.append("")
    
    # Données
    for i, ligne_donnees in enumerate(donnees, 1):
        # Convertir tous les éléments en chaînes
        ligne_formatee = separateur.join(str(item) for item in ligne_donnees)
        lignes.append(f"{i:3d}. {ligne_formatee}")
    
    # Pied de page
    lignes.append("")
    lignes.append(f"Total: {len(donnees)} éléments")
    lignes.append("=" * 50)
    
    # Joindre toutes les lignes
    return "\n".join(lignes)

# Données de test
donnees_ventes = [
    ["Produit A", 150, 24.99, "2024-01-15"],
    ["Produit B", 89, 49.99, "2024-01-16"],
    ["Produit C", 215, 12.50, "2024-01-17"],
    ["Produit D", 42, 99.99, "2024-01-18"]
]

# Génération du rapport
rapport = generer_rapport(donnees_ventes, "Ventes Janvier 2024")
print(rapport)

def generer_rapport(donnees, titre, separateur=" | "):

"""

Génère un rapport formaté à partir de données

"""

# En-tête

lignes = []

lignes.append("=" * 50)

lignes.append(f"RAPPORT: {titre}")

lignes.append("=" * 50)

lignes.append("")

# Données

for i, ligne_donnees in enumerate(donnees, 1):

# Convertir tous les éléments en chaînes

ligne_formatee = separateur.join(str(item) for item in ligne_donnees)

lignes.append(f"{i:3d}. {ligne_formatee}")

# Pied de page

lignes.append("")

lignes.append(f"Total: {len(donnees)} éléments")

lignes.append("=" * 50)

# Joindre toutes les lignes

return "\n".join(lignes)

# Données de test

donnees_ventes = [

["Produit A", 150, 24.99, "2024-01-15"],

["Produit B", 89, 49.99, "2024-01-16"],

["Produit C", 215, 12.50, "2024-01-17"],

["Produit D", 42, 99.99, "2024-01-18"]

]

# Génération du rapport

rapport = generer_rapport(donnees_ventes, "Ventes Janvier 2024")

print(rapport)

6.3 Comparaison avec d'autres méthodes

from io import StringIO

# Méthode 1: join() (recommandée)
def methode_join(iterable):
    return " ".join(str(x) for x in iterable)

# Méthode 2: Boucle avec +
def methode_concat(iterable):
    resultat = ""
    for i, item in enumerate(iterable):
        if i > 0:
            resultat += " "
        resultat += str(item)
    return resultat

# Méthode 3: StringIO
def methode_stringio(iterable):
    with StringIO() as buffer:
        for i, item in enumerate(iterable):
            if i > 0:
                buffer.write(" ")
            buffer.write(str(item))
        return buffer.getvalue()

# Test des méthodes
test_data = ["Python", "est", "génial", "!"]

print("Méthode join():", methode_join(test_data))
print("Méthode concat:", methode_concat(test_data))
print("Méthode StringIO:", methode_stringio(test_data))

# Toutes donnent: "Python est génial !"

from io import StringIO

# Méthode 1: join() (recommandée)

def methode_join(iterable):

return " ".join(str(x) for x in iterable)

# Méthode 2: Boucle avec +

def methode_concat(iterable):

resultat = ""

for i, item in enumerate(iterable):

if i > 0:

resultat += " "

resultat += str(item)

return resultat

# Méthode 3: StringIO

def methode_stringio(iterable):

with StringIO() as buffer:

for i, item in enumerate(iterable):

if i > 0:

buffer.write(" ")

buffer.write(str(item))

return buffer.getvalue()

# Test des méthodes

test_data = ["Python", "est", "génial", "!"]

print("Méthode join():", methode_join(test_data))

print("Méthode concat:", methode_concat(test_data))

print("Méthode StringIO:", methode_stringio(test_data))

# Toutes donnent: "Python est génial !"

Younes Derfoufi
CRMEF OUJDA

Post Views: 71

La méthode str.join() des listes Python

1. A propos de la méthode join()

1.1 Qu'est-ce que join() ?

1.2 La syntaxe fondamentale

2. Utilisation Basique et Exemples

2.1 Concaténation simple de liste de mots

2.2 Différents types de séparateurs

3. Travailler avec Différents Types d'Itérables

3.1 Listes, tuples et autres collections

3.2 Gestion des éléments non-string

4. Cas d'Utilisation Avancés

4.1 Construction de chemins de fichiers

4.2 Génération de CSV et formats structurés

4.3 Performance et comparaison avec l'opérateur +

5. Bonnes Pratiques et Pièges à Éviter

5.1 Gestion des cas vides et None

5.2 Erreurs courantes et solutions

5.3 Utilisation avec des générateurs

6. Fonctions Utilitaires et Exemples Complets

6.1 Fonctions wrapper personnalisées

6.2 Exemple complet: Construction de rapport

6.3 Comparaison avec d'autres méthodes

Imprimante Multifonction HP Envy Inspire 7920e - Recto Verso Auto, Wi-Fi, HP Smart

Linksys Hydra Pro 6E - Routeur Mesh WiFi 6E Triple Bande pour Gaming et Maison Connectée

Imprimante HP Tout-en-Un OfficeJet 250 -Portable avec Wi-Fi | Impression, Copie, Scan 600 dpi

Leave a Reply Cancel reply

Moniteur Gamer & Créatif Dell 27" Full HD 144Hz IPS - S2725HSM - Fluidité Extrême 1ms, FreeSync, Couleurs 99% sRGB

Ordinateur Portable Acer Aspire 1 15.6" Full HD - Intel Celeron, 4 Go RAM, 128 Go, Windows 11 + Microsoft 365 OFFERT 1 an

Point d’accès WiFi 6 AX3000 Tenda I29 2 Ports Ethernet Gigabit, Support PoE/PoE+, Itinérance WLAN, MU-MIMO, OFDMA, Plusieurs SSID