Python os.path.join no Windows

Estou tentando aprender python e estou fazendo um programa que irá gerar um script. Quero usar os.path.join, mas estou muito confuso. De acordo com a documentação, se eu disser:

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

Eu entendo "C:sourcedir". Segundo a documentação, isso é normal, certo?

Mas quando eu uso o comando copytree, o Python irá gerar a saída da maneira desejada, por exemplo:

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

Aqui está o código de erro que recebo:

WindowsError: [Erro 3] O sistema não pode encontrar o caminho especificado: 'C: src /*.*'

Se eu embrulhar os.path.joincom os.path.normpath, obtenho o mesmo erro.

Se isso os.path.joinnão pode ser usado dessa forma, fico confuso quanto ao seu propósito.

De acordo com as páginas sugeridas por Stack Overflow, barras não devem ser usadas na junção - correto, presumo?

O Windows tem um conceito de diretório atual para cada unidade. Por causa disso, "c:sourcedir"significa "sourcedir" dentro do diretório C: atual, e você precisará especificar um diretório absoluto.

Qualquer um deles deve funcionar e dar o mesmo resultado, mas não tenho uma VM do Windows ativada no momento para verificar novamente:

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

Para ser ainda mais pedante, a resposta mais consistente do python doc seria:

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

Já que você também precisa de os.sep para o caminho raiz posix:

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

O motivo de os.path.join('C:', 'src')não estar funcionando conforme o esperado é algo na documentação que você vinculou a:

Observe que no Windows, como há um diretório atual para cada unidade, os.path.join ("c:", "foo") representa um caminho relativo ao diretório atual na unidade C: (c: foo), não c : \ foo.

Como o ghostdog disse, você provavelmente quer mypath=os.path.join('c:\\', 'sourcedir')

Para ser pedante, provavelmente não é bom codificar / ou \ como separador de caminho. Talvez isso seja melhor?

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

ou

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

Para uma solução independente de sistema que funciona em Windows e Linux, não importa o caminho de entrada, pode-se usar os.path.join(os.sep, rootdir + os.sep, targetdir)

No Windows:

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

No Linux:

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

Eu diria que este é um bug do Python (Windows).

Por que bug?

Eu acho que esta declaração deveria ser True

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

Mas é Falseem máquinas Windows.

para entrar em um caminho do Windows, tente

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

basicamente, você precisará escapar da barra

Você tem algumas abordagens possíveis para tratar o caminho no Windows, desde as mais codificadas (como o uso de literais de string brutas ou barras invertidas de escape) até as menos importantes. Aqui estão alguns exemplos que funcionarão conforme o esperado. Use o que melhor se adapta às suas necessidades.

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

Consentimento com @ georg-

Eu diria então por que precisamos de coxo os.path.join- melhor usar str.joinou, unicode.joinpor exemplo,

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

respondendo ao seu comentário: "os outros '//' 'c:', 'c: \\' não funcionaram (C: \\ criou duas barras invertidas, C: \ não funcionou de todo)"

No Windows, o uso de os.path.join('c:', 'sourcedir') irá adicionar automaticamente duas barras invertidas \\na frente do código-fonte .

Para resolver o caminho, como o python funciona no Windows também com barras -> '/' , basta adicionar .replace('\\','/')com os.path.joincomo abaixo: -

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

por exemplo: os.path.join('c:\\', 'temp').replace('\\','/')

saída: 'C: / temp'

As soluções propostas são interessantes e oferecem uma boa referência, porém são apenas parcialmente satisfatórias. É normal adicionar manualmente o separador quando você tem um único caso específico ou sabe o formato da string de entrada, mas pode haver casos em que você deseja fazer isso programaticamente em entradas genéricas.

Com um pouco de experimentação, acredito que o critério é que o delimitador de caminho não seja adicionado se o primeiro segmento for uma letra de unidade, ou seja, uma única letra seguida de dois pontos, não importa se corresponde a uma unidade real.

Por exemplo:

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

Uma maneira conveniente de testar os critérios e aplicar uma correção de caminho pode ser usar a os.path.splitdrivecomparação do primeiro elemento retornado com o valor de teste, como t+os.path.sep if os.path.splitdrive(t)[0]==t else t.

Teste:

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

provavelmente pode ser melhorado para ser mais robusto para espaços à direita, e eu testei apenas no Windows, mas espero que dê uma ideia. Veja também Os.path: você pode explicar esse comportamento? para detalhes interessantes sobre sistemas diferentes do Windows.