Existem três estágios de conhecimento: você usa a ferramenta, entende como ela funciona, pode ensinar outras pessoas a trabalhar com esta ferramenta. Aos poucos, ele começou a fluir para o terceiro e começou a se fazer perguntas que não havia feito antes.

Por exemplo, o que é melhor: import module



ou from module import function



?

Decidi me aprofundar um pouco mais nisso, as respostas no StackOverflow não me satisfizeram.

Para quem tem preguiça de ler: todas as opções são boas.

Dicas dos criadores da linguagem

Vamos nos voltar para as fontes primárias, a saber - para PEP8

Ao importar uma classe de um módulo, não há problema em fazer assim:

from myclass import MyClass
from foo.bar.yourclass import YourClass
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, :

import myclass
import foo.bar.yourclass
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

myclass.MyClass



foo.bar.yourclass.YourClass





PEP-8 .

?

, . . , .

, — . , , .

"" "" .

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

from bottle import route, run, template

@route('/hello/<name>')
def index(name):
    return template('<b>Hello {{name}}</b>!', name=name)

run(host='localhost', port=8080)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

.

import pytest

def test_zero_division():
    with pytest.raises(ZeroDivisionError):
        1 / 0
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, .

.

, .

. , .

import json

json.load(...)
json.loads(...)
json.dump(...)
json.dumps(...)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

.

from pickle import load
from marshal import dumps
from xmlrpc.client import loads
from xml.etree.ElementTree import dump
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

load



json.load



, pickle.load



.

. – . , – . , . , .

, . , .

— , .

, IDE , . , . , isort.

.

. . .

, .

IDE , . : , / . , , ,

– .

100% – . , .

MonkeyPatch

- . . , , , , , , , .

, , - .

– .

, / . , .

, . import module



, from module import item as module_item



. , as



, , . .

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Em minha opinião, usar ambas as abordagens não viola muito a uniformidade e você pode misturá-las com segurança. É desejável, entretanto, não para o mesmo módulo. Algumas ferramentas juram isso: https://lgtm.com/rules/1818040193/

Conclusão

Para mim, utilizo a seguinte abordagem ao importar e escrever meus módulos.

Use import from



, exceto quando:

• há (ou provavelmente mais tarde) um conflito de nomes;
• funções / classes do módulo têm nomes curtos e comuns ( json
  
  
  
  );
• existem tradições bem estabelecidas ou recomendações específicas dos autores do módulo, por exemplo pytest
  
  
  
  .