Para a conversão de código Python2 para Python3, qual versão do Python e Django é mais adequada?

Atualmente, estou trabalhando em uma grande empresa, na qual precisamos converter o grande projeto antigo do Django do python2 para a versão python3, por isso fiz muitas pesquisas relacionadas, mas ainda não consegui encontrar nenhuma resposta perfeita relacionada à versão do Python e Django mais adequada para a conversão.

Atualmente, estou usando Python: 2.7.16 e Django: 1.9.13 na minha versão antiga.

Qualquer pessoa pode me sugerir a versão mais adequada do Python e Django para a versão anterior para conversão python2 em python3.

Eu pensei em acrescentar um pouco à estratégia defendida pela resposta de Wim - obter a versão apropriada do Django trabalhando primeiro nos 2.7 e 3.x - e descrever algumas táticas que funcionaram para mim.

Python 2.7 é o seu pod de escape, até você pressionar o gatilho no 3.x

• seus testes devem ser executados em ambos
• não use nenhum recurso específico do 3.x, como strings-f
• primeiro Python 3.x, depois apenas o Django 2.x que não roda no 2.7
• comece cedo, não analise demais, mas evite a abordagem do big bang
  • arquivo por arquivo em primeiro lugar.
  • comece com o código de nível mais baixo, como bibliotecas de utilitários, para o qual você tem suítes de teste.
  • se possível, tente mesclar gradualmente suas alterações nas ramificações de produção 2.7 e mantenha seu código de portagem 3.x atualizado com as alterações de prod.

Qual versão menor do Django para começar?

Meu critério aqui é que as migrações do Django podem ser bastante envolvidas (e realmente requerem mais reflexão do que 2 => 3 trabalhos). Gostaria de passar para o 1.11 mais recente e melhor, dessa forma, você já está fornecendo algum valor aos seus usuários 2.7. Provavelmente, existe um bom número de calços de compatibilidade pré-2.x no 1.11 e você receberá seus avisos de descontinuação do 2.x.

Qual versão secundária do Python 3.x para começar?

É melhor considerar todos os ângulos, como a disponibilidade de suas bibliotecas de terceiros, o suporte do seu pacote CI / devops e a disponibilidade nas imagens do sistema operacional do servidor escolhido. Você sempre pode instalar o 3.8 e tentar instalar um pip dos seus requisitos.txt por si só, por exemplo.

Aproveite o git (ou qualquer outro scm que você use) e o virtualenv .

• requirement.txtarquivos separados , mas ...
• se você tiver um repositório git baseado em arquivo, poderá apontar cada venv para a mesma linha de código com a pip install -e <your directory>. isso significa que, em 2 terminais diferentes, você pode executar 2.7 e 3.x contra o (s) mesmo (s) mais (s).
• você pode até rodar servidores Django 2.7 e 3.x lado a lado em portas diferentes e apontar, digamos, Firefox e Chrome para eles.
• cometa frequentemente (pelo menos no ramo de portabilidade) e aprenda sobre o git bisect .

faça uso de 2to3

Sim, ele quebrará o código 2.7 e o Django, se você permitir. Assim...

• execute-o no modo de visualização ou em um único arquivo. veja o que quebra, mas também veja o que fez certo.

• acelere para apenas certas conversões que não quebram o 2.7 ou o Django. print x=> print (x)e except(Exception) as esão 2 não-intelectuais.

É assim que meu comando regulado era:

2to3 $tgt -w -f except -f raise -f next -f funcattrs -f print

• execute-o arquivo por arquivo até que você esteja realmente confiante.

use sed ou awk em vez de seu editor para conversões em massa.

A vantagem é que, à medida que você se torna mais ciente das preocupações específicas de seus aplicativos, pode criar um conjunto de alterações que podem ser executadas em 1 arquivo ou em muitos arquivos e executar a maior parte do trabalho sem quebrar o 2.7 ou o Django. Aplique isso após o seu passe 2to3 adequadamente otimizado . Isso deixa você com limpezas residuais no seu editor e com a aprovação nos testes.

(opcional) comece a ficar preto no código 2.7.

black, que é um formatador de código, usa ASTs do Python 3 para executar sua análise. Ele não tenta executar o código, mas sinaliza erros de sintaxe que impedem que ele chegue ao estágio AST. Você terá que trabalhar com alguma mágica global de instalação de pip para chegar lá e precisará comprar a utilidade do preto.

Outras pessoas fizeram isso - aprenda com elas.

Ouvindo o número 155 As etapas práticas para mudar para o Python 3 devem lhe dar algumas idéias do trabalho. Veja os links do programa. Eles adoram falar sobre o movimento do Instagram (?) Que envolveu um ajuste gradual da execução do código 2.7 para a sintaxe 3.x em uma base de código comum e no mesmo ramo git, até o dia do acionamento.

Consulte também o Guia de portabilidade do Conservative Python 3

e Instagram fazem uma transição suave para Python 3 - The New Stack

Conclusão

Seu tempo para o Django 1.11 EOL (abril de 2020) é bastante curto, portanto, se você tiver mais de 2 recursos de desenvolvimento, considere fazer o seguinte em paralelo:

• DEV # 1: inicie com um salto do Django 1.11 (a teoria é que o Django 1.11 provavelmente está melhor posicionado como um ponto de partida para o Django 2.x), usando 2.7.

• DEV # 2: inicie no Python 3.6 / 3.7 do seu código utilitário não Django. Como o código é compatível com 2.7 neste ponto, mescle-o ao número 1 à medida que avança.

Veja como as duas tarefas prosseguem, avalie qual é o risco do projeto relacionado ao Django e qual é a aparência do Python 3. Você já está sentindo falta da EOL do Python 2.7, mas uma estrutura da Web obsoleta é provavelmente mais perigosa que o Python 2.7 herdado, pelo menos por alguns meses. Portanto, não esperaria muito tempo para começar a migrar para o Django 1.9 e seu trabalho não será desperdiçado. Conforme você vê o progresso, começará a ver melhor os riscos do projeto.

Seu progresso inicial de 2 a 3 será lento, mas as ferramentas e as orientações são boas o suficiente para você acelerar rapidamente, portanto, não pense demais antes de começar a reunir experiência. O lado do Django depende da sua exposição a mudanças no quadro, e é por isso que acho melhor começar cedo.

PS (opinião controversa / pessoal): Não usei muito seis ou outras bibliotecas de pontes 2 a 3 enlatadas.

É não porque eu não confiar nele - é brilhante para libs 3rd party - mas sim que eu não queria adicionar uma dependência permanente complexo (e eu estava com preguiça de ler seu doc). Eu estava escrevendo código 2.7 na sintaxe compatível com 3.x por um longo tempo, então não senti a necessidade de usá-los. Sua milhagem pode variar e não seguir esse caminho se parecer muito trabalhoso .

Em vez disso, criei um py223.py (57 LOC, incluindo comentários) com esse tipo de conteúdo, a maioria relacionada a soluções alternativas para reprovações e alterações de nome na biblioteca padrão.

try:
    basestring_ = basestring
except (NameError,) as e:
    basestring_ = str

try:
    cmp_ = cmp
except (NameError,) as e:
    # from http://portingguide.readthedocs.io/en/latest/comparisons.html
    def cmp_(x, y):
        """
        Replacement for built-in function cmp that was removed in Python 3
        """
        return (x > y) - (x < y)

Em seguida, importe desse py223 para solucionar essas preocupações específicas. Mais tarde, eu só vai abandonar a importação e mover aqueles estranho isinstance(x, basestr_)para isinstance(x, str)mas sei de antemão que há pouco para se preocupar.

Minha sugestão é atualizar primeiro para Django==1.11.26, que é a versão mais recente do Django que suporta o Python 2 e o Python 3. Continue na sua versão atual do Python 2.7 por enquanto.

Leia atentamente as notas de versão de 1.10.xe 1.11.x, verificando preterimentos e corrigindo qualquer coisa que tenha parado de funcionar no seu código 1.9.x. As coisas vão quebrar. O Django se move rápido. Para um projeto grande do Django, pode haver muitas alterações de código necessárias, e se você estiver usando muitos plugins ou bibliotecas de terceiros, poderá ser necessário manipular suas versões. Algumas de suas dependências de terceiros provavelmente foram totalmente abandonadas, portanto, é necessário encontrar substituições ou remover os recursos.

Para encontrar as notas de versão para cada atualização de versão, apenas pesquise no Google "O que há de novo no Django". Os hits documentam meticulosamente todas as deprecações e alterações:

• https://docs.djangoproject.com/en/2.2/releases/1.10/
• https://docs.djangoproject.com/en/2.2/releases/1.11/

Uma vez que o webapp parece estar funcionando bem no Django 1.11, com todos os testes de passagem (você fazer tem um conjunto de testes, certo?), Então você pode fazer a conversão Python 3, mantendo a versão Django o mesmo. O Django 1.11 suporta até Python 3.7, portanto essa seria uma boa versão para o seu destino. Espere unicode em todo o lugar, já que as conversões implícitas entre bytes e texto desapareceram agora e muitos webapps do Python 2 dependiam disso.

Quando o projeto parece estar funcionando bem no Django 1.11 e no Python 3.7, você pode pensar em atualizar para o Django 3.0, seguindo o mesmo processo de antes - lendo as notas de versão, fazendo as alterações necessárias, executando o conjunto de testes e fazendo check-out o webapp em um servidor dev manualmente.

Eu atualizaria para py3 primeiro. Você precisará olhar no setup.pyrepositório do Django no branch stable / 1.9.x ( https://github.com/django/django/blob/stable/1.9.x/setup.py ) para descobrir que o py3 as versões suportadas são 3.4 (inativas) e 3.5.

Uma vez no py3.5 e no Django 1.9, você pode atualizar um de cada vez até chegar à versão em que deseja terminar. Por exemplo, o Django 1.11 suporta py3.5 e py3.7, então

py27/dj19 -> py35/dj19 -> py35/dj1.11 -> py37/dj1.11 ... -> py37/dj2.2

O dj2.2 é a primeira versão que suporta o py3.8, mas eu provavelmente pararia no py37 / dj2.2 se você estiver trabalhando em um ambiente normalmente conservador.

Se você tiver outros pacotes, precisará encontrar combinações de versões que funcionem juntas em cada etapa. Ter um plano é fundamental, e atualizar apenas um componente por vez geralmente acaba economizando seu tempo.

A futura biblioteca ( https://python-future.org/ ) o ajudará em muitas situações nojentas, enquanto você precisa de código para executar nos py27 e 3.x. seis também é ótimo. Eu evitaria rolar sua própria camada de compatibilidade (por que reinventar a roda?)

Se possível, tente obter uma cobertura de teste de unidade de 75 a 85% antes de iniciar e, definitivamente, configure o teste automático nas versões "de" e "para" para cada etapa da atualização. Certifique-se de ler e corrigir todos os avisos do Django antes de atualizar para a próxima versão - o Django se preocupa muito pouco com a compatibilidade com versões anteriores, então eu normalmente sugiro que você atinja todas as versões secundárias no caminho da atualização (ou pelo menos certifique-se de ler as "versões anteriores incompatibilidades "e listas de reprovação para cada versão secundária).

Boa sorte (estamos atualizando uma base de código 300 + Kloc de py27 / dj1.7 agora, então sinto sua dor ;-)

Eu tenho o mesmo tipo de problema com o meu projeto e tentei o python 3.7.5 com o Django versão 2.2.7.

Você não deve usar a versão mais recente do python 3.8 ou a versão mais recente do Django 3.0, pois pode haver chances de que, para qualquer tipo de bug, você não consiga obter a solução adequada para as versões mais recentes.

Você deve tentar filmar as versões atuais. Python 3.8 e Django 3.0. A biblioteca Six ajudará com algumas mudanças nas convenções. De qualquer maneira, você precisará refatorar para torná-lo atual.