Python os.path.join sous Windows

J'essaie d'apprendre le python et je crée un programme qui produira un script. Je veux utiliser os.path.join, mais je suis assez confus. D'après la documentation si je dis:

os.path.join('c:', 'sourcedir')

Je reçois "C:sourcedir". Selon la documentation, c'est normal, non?

Mais lorsque j'utilise la commande copytree, Python le sortira de la manière souhaitée, par exemple:

import shutil
src = os.path.join('c:', 'src')
dst = os.path.join('c:', 'dst')
shutil.copytree(src, dst)

Voici le code d'erreur que j'obtiens:

WindowsError: [Erreur 3] Le système ne trouve pas le chemin spécifié: 'C: src /*.*'

Si j'emballe le os.path.joinavec, os.path.normpathj'obtiens la même erreur.

Si cela os.path.joinne peut pas être utilisé de cette façon, alors je ne sais pas quel but.

Selon les pages suggérées par Stack Overflow, les barres obliques ne doivent pas être utilisées dans la jointure - c'est correct, je suppose?

Windows a un concept de répertoire actuel pour chaque lecteur. Pour cette raison, "c:sourcedir"signifie "sourcedir" dans le répertoire C: actuel, et vous devrez spécifier un répertoire absolu.

N'importe lequel de ceux-ci devrait fonctionner et donner le même résultat, mais je n'ai pas de machine virtuelle Windows activée pour le moment pour vérifier:

"c:/sourcedir"
os.path.join("/", "c:", "sourcedir")
os.path.join("c:/", "sourcedir")

Pour être encore plus pédant, la réponse la plus cohérente de la documentation python serait:

mypath = os.path.join('c:', os.sep, 'sourcedir')

Puisque vous avez également besoin de os.sep pour le chemin racine de posix:

mypath = os.path.join(os.sep, 'usr', 'lib')

La raison os.path.join('C:', 'src')ne fonctionne pas comme prévu est à cause de quelque chose dans la documentation que vous avez lié:

Notez que sous Windows, comme il existe un répertoire courant pour chaque lecteur, os.path.join ("c:", "foo") représente un chemin relatif au répertoire courant sur le lecteur C: (c: foo), pas c : \ foo.

Comme Ghostdog l'a dit, tu veux probablement mypath=os.path.join('c:\\', 'sourcedir')

Pour une solution indépendante du système qui fonctionne à la fois sur Windows et Linux, quel que soit le chemin d'entrée, on pourrait utiliser os.path.join(os.sep, rootdir + os.sep, targetdir)

Sur Windows:

>>> os.path.join(os.sep, "C:" + os.sep, "Windows")
'C:\\Windows'

Sous Linux:

>>> os.path.join(os.sep, "usr" + os.sep, "lib")
'/usr/lib'

Pour être pédant, il n'est probablement pas bon de coder en dur soit / ou \ comme séparateur de chemin. Ce serait peut-être mieux?

mypath = os.path.join('c:%s' % os.sep, 'sourcedir')

ou

mypath = os.path.join('c:' + os.sep, 'sourcedir')

Je dirais que c'est un bogue Python (Windows).

Pourquoi bug?

Je pense que cette déclaration devrait être True

os.path.join(*os.path.dirname(os.path.abspath(__file__)).split(os.path.sep))==os.path.dirname(os.path.abspath(__file__))

Mais c'est Falsesur les machines Windows.

pour rejoindre un chemin Windows, essayez

mypath=os.path.join('c:\\', 'sourcedir')

en gros, vous devrez échapper à la barre oblique

Vous avez quelques approches possibles pour traiter le chemin sur Windows, des plus codées en dur (comme l'utilisation de littéraux de chaîne bruts ou l'échappement de barres obliques inverses) aux plus petites. Voici quelques exemples qui fonctionneront comme prévu. Utilisez ce qui correspond le mieux à vos besoins.

In[1]: from os.path import join, isdir

In[2]: from os import sep

In[3]: isdir(join("c:", "\\", "Users"))
Out[3]: True

In[4]: isdir(join("c:", "/", "Users"))
Out[4]: True

In[5]: isdir(join("c:", sep, "Users"))
Out[5]: True

Consentement avec @ georg-

Je dirais alors pourquoi nous avons besoin de boiteux os.path.join- mieux utiliser str.joinou unicode.joinpar exemple

sys.path.append('{0}'.join(os.path.dirname(__file__).split(os.path.sep)[0:-1]).format(os.path.sep))

répondant à votre commentaire: "les autres '//' 'c:', 'c: \\' n'ont pas fonctionné (C: \\ a créé deux contre-obliques, C: \ n'a pas fonctionné du tout)"

Sur Windows, l'utilisation os.path.join('c:', 'sourcedir') ajoutera automatiquement deux barres obliques inverses \\devant sourcedir .

Pour résoudre le chemin, comme python fonctionne également sur Windows avec des barres obliques -> '/' , ajoutez simplement .replace('\\','/')avec os.path.joincomme ci-dessous: -

os.path.join('c:\\', 'sourcedir').replace('\\','/')

par exemple: os.path.join('c:\\', 'temp').replace('\\','/')

sortie: 'C: / temp'

Les solutions proposées sont intéressantes et offrent une bonne référence, mais elles ne sont que partiellement satisfaisantes. Il est possible d'ajouter manuellement le séparateur lorsque vous avez un seul cas spécifique ou que vous connaissez le format de la chaîne d'entrée, mais il peut y avoir des cas où vous souhaitez le faire par programme sur des entrées génériques.

Avec un peu d'expérimentation, je pense que le critère est que le délimiteur de chemin n'est pas ajouté si le premier segment est une lettre de lecteur, c'est-à-dire une seule lettre suivie de deux points, peu importe si cela correspond à une unité réelle.

Par exemple:

import os
testval = ['c:','c:\\','d:','j:','jr:','data:']

for t in testval:
    print ('test value: ',t,', join to "folder"',os.path.join(t,'folder'))

test value:  c: , join to "folder" c:folder
test value:  c:\ , join to "folder" c:\folder
test value:  d: , join to "folder" d:folder
test value:  j: , join to "folder" j:folder
test value:  jr: , join to "folder" jr:\folder
test value:  data: , join to "folder" data:\folder

Un moyen pratique de tester les critères et d'appliquer une correction de chemin peut être d'utiliser la os.path.splitdrivecomparaison du premier élément renvoyé à la valeur de test, comme t+os.path.sep if os.path.splitdrive(t)[0]==t else t.

Tester:

for t in testval:
    corrected = t+os.path.sep if os.path.splitdrive(t)[0]==t else t
    print ('original: %s\tcorrected: %s'%(t,corrected),' join corrected->',os.path.join(corrected,'folder'))

original: c:    corrected: c:\  join corrected-> c:\folder
original: c:\   corrected: c:\  join corrected-> c:\folder
original: d:    corrected: d:\  join corrected-> d:\folder
original: j:    corrected: j:\  join corrected-> j:\folder
original: jr:   corrected: jr:  join corrected-> jr:\folder
original: data: corrected: data:  join corrected-> data:\folder

il peut probablement être amélioré pour être plus robuste pour les espaces de fin, et je ne l'ai testé que sur windows, mais j'espère que cela donne une idée. Voir aussi Os.path: pouvez-vous expliquer ce comportement? pour des détails intéressants sur les systèmes autres que Windows.