mixte des barres obliques avec os.chemin d'accès.rejoindre sur windows

J'ai tendance à utiliser uniquement des barres obliques pour les chemins ('/') et python est heureux avec elle aussi sur windows.
Dans la description de l'os.chemin d'accès.rejoindre il dit que c'est le bon moyen si vous voulez aller à la croix-plate-forme. Mais quand je l'utilise je mêlent des barres obliques:

import os

a = 'c:/'
b = 'myFirstDirectory/'
c = 'mySecondDirectory'
d = 'myThirdDirectory'
e = 'myExecutable.exe'


print os.path.join(a, b, c, d, e)

# Result:
c:/myFirstDirectory/mySecondDirectory\myThirdDirectory\myExecutable.exe

Est-ce correct? Dois-je vérifier et corriger par la suite ou il ya une meilleure façon?

Grâce

EDIT:
J'ai aussi mêlent des barres obliques, lors de la demande pour les chemins

import sys
for item in sys.path:
    print item

# Result:
C:\Program Files\Autodesk\Maya2013.5\bin
C:\Program Files\Autodesk\Maya2013.5\mentalray\scripts\AETemplates
C:\Program Files\Autodesk\Maya2013.5\Python
C:\Program Files\Autodesk\Maya2013.5\Python\lib\site-packages
C:\Program Files\Autodesk\Maya2013.5\bin\python26.zip\lib-tk
C:/Users/nookie/Documents/maya/2013.5-x64/prefs/scripts
C:/Users/nookie/Documents/maya/2013.5-x64/scripts
C:/Users/nookie/Documents/maya/scripts
C:\Program Files\Nuke7.0v4\lib\site-packages
C:\Program Files\Nuke7.0v4/plugins/modules

os est intelligent et les œuvres qui les barres obliques dont vous avez besoin pour votre système d'exploitation. Pour l'utiliser correctement, ne pas mettre les barres obliques dans vos chaînes a,b,c,d et e - os pour les ajouter.
Je vois, mais si je suis mélangé les barres obliques, lors de la demande d'un chemin d'accès? (J'ai mis à jour le premier post avec un exemple)
vous pouvez utiliser os.path.normpath(mixed_slashes_path) et obtenir les barres obliques normalisé. Oh, et je devine que vous êtes en train de faire cela à l'intérieur de Maya; il fait des choses très UNIX-like, donc les barres obliques dans les il y dans les chemins que c'est ajouter pour vous.

InformationsquelleAutor nookie | 2013-05-02

30

Vous êtes maintenant en fournissant une partie de la slash à vous-même et de laisser os.chemin d'accès.join choisir d'autres. Il est préférable de laisser python prendre tous ou de leur fournir tous les vous-même. Python utilise des barres obliques inverses pour la dernière partie du chemin, parce que les barres obliques inverses sont par défaut sur Windows.
```
import os

a = 'c:' # removed slash
b = 'myFirstDirectory' # removed slash
c = 'mySecondDirectory'
d = 'myThirdDirectory'
e = 'myExecutable.exe'

print os.path.join(a + os.sep, b, c, d, e)
```
Je n'ai pas testé, mais j'espère que cette aide. Il est plus courant d'avoir un chemin d'accès de base et de n'avoir à en rejoindre un autre élément, la plupart des fichiers.

Par le chemin; vous pouvez utiliser os.sep pour ces moments vous voulez avoir le meilleur séparateur pour le système d'exploitation python est en cours d'exécution sur.

Edit: de dash-tom-bang unis, apparemment pour Windows, vous avez besoin d'inclure un séparateur pour la racine du chemin d'accès. Sinon, vous créer un chemin d'accès relatif plutôt qu'absolu.
- Merci pour votre réponse, mais est ce que si je reçois des barres obliques dans une chaîne de caractères (quand deux dossiers ou plus)? J'ai mis à jour le premier post avec quelques chemins-je obtenir à partir de sys.chemin
- Cela dépend d'où ce chemin est en venir. Mais la plupart du temps, vous devriez déjà avoir ces barres obliques dans le format correct. C'est, si vous obtenir le chemin d'accès via Python. Si vous avez une source externe vous ne contrôlez pas et cette source fournit des slashes ( / ) au lieu de barres obliques vers l'arrière; vous pouvez corriger cela en premier.
- Je dois donc vérifier la chaîne après et assurez-vous que le format est correct?
- Non, je voudrais vérifier votre entrée externe (l'entrée qui, apparemment, ne contrôle pas le format) avant en le mettant dans os.path.join. De cette façon, vous vous assurez que os.path.join ne pas prendre de mauvaises décisions basées sur les probablement une mauvaise entrée.
- Je ne vois pas le danger d'avoir de mauvais commentaires ici, dans le sens de "mauvais" sens "avoir mélangé les séparateurs". OMI Windows permet heureusement pour le mélange / et \, donc pas de problème ici.
- Pas de réel danger, mais si vous souhaitez que votre code pour être multi-plateforme (comme il le suggère), il est préférable de programme sur la défensive et à désinfecter votre entrée à l'avance. Bien que cela puisse être considéré comme un avis plutôt que d'un fait, bien sûr 😉
- La séparation du répertoire racine et re-joindre ne donnera pas le résultat correct; la racine de C: doit être spécifié. Voir stackoverflow.com/questions/2422798.
- Merci @dash-tom-bang, j'ai mis à jour la réponse en conséquence. Étrange que personne n'a remarqué ça avant, ça pourrait être la version liées ou quelque chose?
- Il n'est pas nécessaire de retirer les barres obliques. suffit d'utiliser la norme os.path.normpath() fonction afin de normaliser les chemins d'accès si vous êtes inquiet au sujet de mixte des barres obliques dans les chemins. Il n'est pas nécessaire de les éviter, de toute façon, comme Windows est heureux d'accepter les chemins avec un mélange de barres obliques.
InformationsquelleAutor pyrocumulus
37

Vous pouvez utiliser .replace() après path.join() pour assurer les barres obliques sont corrects:
```
# .replace() all backslashes with forwardslashes
print os.path.join(a, b, c, d, e).replace("\\","/")
```
Cela donne à la sortie:
```
c:/myFirstDirectory/mySecondDirectory/myThirdDirectory/myExecutable.exe
```
Comme @sharpcloud suggéré, il serait préférable de supprimer les barres obliques de vos chaînes d'entrée, cependant, c'est une alternative.
- Serait-il préférable de simplement importer posixpath au lieu de l'os.chemin d'accès, puis faire posixpath.join(a, b, c, d, e) qui vous donnera toujours des barres obliques.
- n'est-ce pas posixpath le même que l'importation de l'os.chemin d'accès? En tout cas, sur ma machine windows posixpath.join() renvoie toujours mélangé les barres obliques.
- Si vous regardez ici, os.chemin de l'importation d'un des posixpath, ntpath, macpath ou os2emxpath en fonction de votre système d'exploitation. Je suis surpris que vous obtenez toujours mélangé avec des barres obliques posixpath. Je l'ai juste testé sur une machine windows et os.path.join('foo', 'bar') m'a donné 'a\\b' et posixpath.join('foo', 'bar') m'a donné 'a/b'.
- J'aurais du précisé que os.path.join() (et le module importations) ne remplace pas les barres obliques dans les cordes, c'est s'inscrire, ce qui peut conduire à des mélanges de barres obliques (comme c'est le cas dans la question).
- C'est vrai, mais il semblait que le seul barres obliques dans les cordes, il a été rejoint étaient obliques, et comme posixpath utilise également des barres obliques vous n'obtiendrez pas un mixte des barres obliques à l'aide de posixpath dans le cas des OP scénario.
- Même préférable que je dirais serait d'utiliser os.abspath() à normaliser toutes sortes de choses. Peut-être il y a quelque chose dans posixpath qui va satisfaire?
- Cette approche ajoute un bug si le code jamais s'exécute sur quelque chose Unix-ish. OIE il met une bombe à retardement dans votre code, déclenché par le "code est porté" - ce qui est exactement le genre de situation où vous avez trop de problèmes de profondeur vers le bas dans le code déjà.
- Pour quelqu'un (comme moi) qui en était à se demander, "Pourquoi diable la double anti-slash!?" ("\\" au lieu de "\"), voir ici: stackoverflow.com/a/501197/4561887
- La bonne croix-platfom méthode consiste à utiliser os.path.normpath(). Sur Windows, il va normaliser le chemin à l'aide de barres obliques vers l'arrière. Si vous avez d'avoir des barres obliques, alors vous êtes probablement traiter avec des Url et pas de chemins, afin d'utiliser l'URL des méthodes spécifiques telles que urllib.parse.urljoin() (nécessite l'Url, pas seulement un chemin d'accès).
- Mixte des barres obliques est ce n'est pas réellement un problème que Windows est heureux de procédé que ce soit, même si elle est mélangée.
InformationsquelleAutor Maximus
10

essayez d'utiliser abspath (à l'aide de python 3)
```
import os

a = 'c:/'
b = 'myFirstDirectory/'
c = 'mySecondDirectory'
d = 'myThirdDirectory'
e = 'myExecutable.exe'


print(os.path.abspath(os.path.join(a, b, c, d, e)))
```
De SORTIE:

c:\myFirstDirectory\mySecondDirectory\myThirdDirectory\myExecutable.exe

Le processus est terminé avec le code de sortie 0
- os.path.abspath() appels os.path.normpath() premier. Vous pouvez obtenir le même ici, il suffit d'appeler os.path.normpath().
InformationsquelleAutor Andre Odendaal
8

MODIFIER basé sur commentaire: path = os.path.normpath(path)

Ma réponse précédente manque de capacité de manipulation des caractères d'échappement et donc ne doit pas être utilisé:
- D'abord de convertir le chemin d'accès à un éventail de dossiers et le nom de fichier.
- Deuxième, les colle ensemble en utilisant le symbole correct.
```
import os   
path = 'c:\www\app\my/folder/file.php'
# split the path to parts by either slash symbol:
path = re.compile(r"[\/]").split(path)
# join the path using the correct slash symbol:
path = os.path.join(*path)
```
- Notez que si votre chaîne arrive d'utiliser ` \ ` échapper à des espaces à l'intérieur des dossiers, cette méthode va se casser. Par exemple "/usr/my\ files" traduira "usr","my"," files" au lieu de "usr","my files"
- Ne pas ré-inventer la roue. Utilisez simplement os.path.normpath().
InformationsquelleAutor oriadam
2

os ajoute des barres obliques pour vous et fait en sorte de ne pas reproduire les barres obliques afin de les omettre dans vos cordes
```
import os

# Don't add your own slashes
a = 'C:'
b = 'myFirstDirectory' 
c = 'mySecondDirectory'
d = 'myThirdDirectory'
e = 'myExecutable.exe'

print os.path.join(a, b, c, d, e)
C:\myFirstDirectory\mySecondDirectory\myThirdDirectory\myExecutable.exe
```
Supplémentaires:

Je ne suis pas sûr pourquoi vous avez mélangé des barres obliques dans votre sys chemin (avez-vous utilisé un système d'exploitation linux pour ajouter certains dossiers?) mais essayez de vérifier

print os.path.isdir(os.path.join('C:','Users','nookie')).

Si c'est True puis os fonctionne pour votre mélange de barres obliques.

De toute façon, je voudrais éviter de coder en dur les noms de répertoire dans votre programme. Votre sys.path boucle for est un moyen sûr de sortir ces répertoires. Vous pouvez ensuite utiliser certaines méthodes string, ou regex pour choisir le dossier de votre choix.
- os.chemin d'accès.isdir(os.chemin d'accès.join('C:','Utilisateurs','nookie')) renvoie la valeur False. Je n'ai pas utiliser n'importe quel système d'exploitation Linux pour ajouter mes dossiers, ceux-ci venaient tout juste de l'installation des logiciels!
- Quelle version de Python utilisez-vous, @ejrb? Parce que sur le mien, je n'ai pas la première barre oblique. (Je vois C:myFirstDirectory\mySecondDirectory...)
InformationsquelleAutor ejrb

Si pour une raison quelconque, vous devez fournir les chemins vous-même et vous avez utiliser quoi que ce soit au-dessus de python 3.4, vous pouvez utiliser pathlib

from pathlib import Path, PurePosixPath

a = PurePosixPath('c:/')
b = PurePosixPath('myFirstDirectory/')
c = 'mySecondDirectory'
d = 'myThirdDirectory'
e = 'myExecutable.exe'

print(a / b / c / d / e)

# Result
c:/myFirstDirectory/mySecondDirectory/myThirdDirectory/myExecutable.exe

Je l'utilise quand j'ai besoin d'un utilisateur à indiquer l'emplacement d'un répertoire actif et mon code a été à la recherche vers le haut en utilisant windows chaînes de chemin

In [1]: from pathlib import Path, PureWindowsPath
In [2]: USER_ASSETS_DIR = Path('/asset/dir') # user provides this form environment variable
In [3]: SPECIFIC_ASSET = PureWindowsPath('some\\asset')
In [4]: USER_ASSETS_DIR / SPECIFIC_ASSET

Out[4]: PosixPath('/asset/dir/some/asset')

InformationsquelleAutor dinosaurwaltz

Vous devez vous connecter pour publier un commentaire.