¿Cuál es la forma más pitónica de importar módulos en python?

Question

¿Alguien puede sugerirme cuál es la forma más pitónica de importar módulos en python? Me explico - He leído un montón de código Python y ha encontrado varias maneras diferentes de cómo importar módulos o si para ser más precisos - cuando a importar:

1. utilizar uno de varios módulos del módulo/incluidas sus respectivas importaciones (módulos de terceros) que son necesarios para todo el proyecto, por lo que todas las importaciones se concentran en pocos módulos, por lo que es fácil mantener las importaciones. Cuando un módulo individual requiere que se importe un módulo, solicite el módulo de referencias. Por ejemplo, en nuestro proyecto hemos separado el nivel llamado 'referencias' por lo que contiene módulos como 'system.py' (contiene referencias a todas las bibliotecas del sistema), 'platform.py' (contiene referencias a todas las bibliotecas de plataforma), 'devexpress. py '(contiene referencias a todas las bibliotecas devexpress) y así sucesivamente. Estos módulos tienen el siguiente aspecto:
2. Cada módulo importa todas las clases y funciones necesarias en la parte superior del módulo, p. hay una sección con importaciones dentro de cada módulo en el proyecto
3. Cada función/clase usa importación localmente, por ejemplo, inmediatamente después de la definición e importa solo cosas que realmente necesitan.

Por favor, encuentre ejemplos a continuación.

1 muestra módulo de importación - sólo 'importación' y 'de ... importación ...' declaraciones (no hay ningún método o clases):

#references.py 
import re 
import clr 
import math 

import System 
import System.Text.RegularExpressions 
import System.Random 
import System.Threading 
import System.DateTime 

# System assemblies 

clr.AddReference("System.Core") 
clr.AddReference("System.Data") 
clr.AddReference("System.Drawing") 
... 

#test.py 
from references.syslibs import (Array, DataTable, OleDbConnection, OleDbDataAdapter, 
           OleDbCommand, OleDbSchemaGuid) 

def get_dict_from_data_table(dataTable): 
    pass 

2 módulo con 'importación' y 'de. .. importación ...', así como los métodos y clases:

from ... import ... 
from ... import ... 

def Generate(param, param1 ...): 
    pass 

3 módulos con 'importación' y 'de ... importar ...' declaraciones que se utilizan en el interior de los métodos y clases:

import clr 
clr.AddReference("assembly")  

from ... import ... 
... 

def generate_(txt, param1, param2): 
    from ... import ... 
    from ... import ... 
    from ... import ... 

    if not cond(param1): res = "text" 
    if not cond(param2): name = "default" 

Entonces, ¿cuál es la forma más pitónica de importar módulos en python?

Answer 1

Es realmente no importa, siempre y cuando no lo haga from ... import *. El resto es todo gusto y evita problemas cíclicos de importación. PEP 8 indica que debe importar en la parte superior del script, pero incluso eso no está escrito en piedra.

Answer 2

"importación" de Python carga un módulo de Python en su propio espacio de nombres, por lo que hay que añadir el nombre del módulo seguido de un punto frente a las referencias a los nombres del módulo importado

import animals 
animals.Elephant() 

"de "carga un módulo de Python en el espacio de nombres actual, por lo que se puede hacer referencia a ella sin la necesidad de mencionar el nombre del módulo nuevo

from animals import Elephant 
Elephant() 

o

from animals import * 
Elephant() 

usar de es bueno, (pero usar una importación de comodín es desalentador). pero si tiene un gran proyecto a escala, la importación desde diferentes módulos puede causar confilamientos de nombres.Al igual que la importación de elefante() función de dos módulos diffrent causará problemas (como el uso de las importaciones comodín con *)

Por lo tanto, si usted tiene un proyecto grande en escala, donde se importan muchas cosas diffrent de otros módulos, es es mejor usar importación y usar elementos importados con module_name.your_class_or_function. De lo contrario, use de notación ...

Answer 3

La gente ya ha comentado sobre los principales problemas de estilo (en la parte superior del guión, etc.), así que me saltearé eso.

Para mis importaciones, generalmente las ordené alfabéticamente por nombre de módulo (independientemente de si es 'importación' o 'de ... importación ...'. Lo dividí en grupos de: lib estándar; módulos de terceros (de PyPI o de otro tipo);.. módulos internos

import os 
import system 

import twisted 
import zope 

import mymodule_1 
import mymodule_2 

Answer 4

no utilice from module import * Este va a contaminar el espacio de nombres y es muy mal visto sin embargo, puede importar cosas específicas utilizando de;.. from module import something Esto mantiene el espacio de nombres limpia En proyectos más grandes, si usa un comodín, puede estar importando 2 foo o 2 barras en el mismo espacio de nombres.

PEP 8 dice tener importaciones en líneas separadas. Por ejemplo:

import os 
import sys 
import yourmodule 
from yourmodule import specific_stuff 

Una cosa que hago es ordenar por orden alfabético mis importaciones en dos grupos. Uno es estándar/de terceros y el segundo es módulos internos.