Qual è il modo più pignolo per importare i moduli in python

Question

Qualcuno può suggerirmi qual è il modo più pignolo per importare i moduli in python? Mi spiego - ho letto un sacco di codice Python e trovato diversi modi di come importare i moduli o se per essere più precisi - quando ad importare:

1. utilizzare uno/più moduli di moduli che includono tutte le importazioni (moduli di terze parti) che sono necessari per l'intero progetto in modo che tutte le importazioni siano concentrate in pochi moduli, quindi è facile mantenere le importazioni. Quando un singolo modulo richiede l'importazione di un modulo, chiedigli il modulo di riferimento. Ad esempio, nel nostro progetto abbiamo un livello separato denominato "riferimenti", quindi contiene moduli come "system.py" (contiene riferimenti a tutte le librerie di sistema), "platform.py" (contiene riferimenti a tutte le librerie di piattaforme), "devexpress". py '(contiene riferimenti a tutte le librerie di devexpress) e così via. Questi moduli assomigliano a:
2. Ogni modulo importa tutte le classi e le funzioni necessarie nella parte superiore del modulo - ad es. c'è una sezione con le importazioni all'interno di ciascun modulo nel progetto
3. Ogni funzione/classe utilizza l'importazione localmente, ad es. subito dopo la definizione, e importa solo le cose di cui realmente hanno bisogno.

Si prega di trovare i campioni di seguito. Modulo

1 campione di importazione - solo 'import' e 'da ... import ...' dichiarazioni (non tutti i metodi o classi):

modulo

#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 con 'importazione' e 'da. .. import ...', nonché i metodi e classi:

modulo

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

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

3 con 'importazione' e 'da ... import ...' affermazioni che vengono utilizzati all'interno di metodi e classi:

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" 

Quindi qual è il modo più pignolo per importare i moduli in python?

Answer 1

E 'in realtà non importa, purché non si from ... import *. Il resto è tutto gusto e andare in giro con problemi di importazione ciclica. PEP 8 afferma che è necessario importare nella parte superiore dello script, ma anche questo non è impostato su pietra.

Answer 2

"importazione" di Python carica un modulo Python in un proprio spazio dei nomi, in modo da avere per aggiungere il nome del modulo seguito da un punto di fronte a riferimenti a tutti i nomi dal modulo importato

import animals 
animals.Elephant() 

"da "carica un modulo Python nel namespace corrente, in modo che si può fare riferimento ad esso, senza la necessità di menzionare il nome del modulo di nuovo

from animals import Elephant 
Elephant() 

o

from animals import * 
Elephant() 

utilizzando da è buono, (ma l'utilizzo di un'importazione di caratteri jolly è scoraggiante). ma se si dispone di un grande progetto ridimensionato, l'importazione da moduli diversi può causare nomenclature.Come importare Elephant function() da due moduli diffrent causerà problemi (come l'utilizzo di importazioni jolly con *)

Quindi, se si dispone di un grande progetto in scala in cui si importano molte cose diffrent da altri moduli, è meglio usare l'importazione e l'uso di oggetti importati con module_name.your_class_or_function. In caso contrario, usano la notazione da ...

Answer 3

La gente ha già commentato le principali questioni di stile (nella parte superiore dello script, ecc), quindi dovrò saltare questo.

Per le mie importazioni, di solito li ho ordinati alfabeticamente in base al nome del modulo (indipendentemente dal fatto che sia "importato" o "da ... import ...". Ho diviso in gruppi di: lib standard, moduli di terze parti (da PyPI o altro);.. moduli interni

import os 
import system 

import twisted 
import zope 

import mymodule_1 
import mymodule_2 

Answer 4

non utilizzare from module import * Ciò inquinare lo spazio dei nomi ed è altamente disapprovata Tuttavia, è possibile importare le cose specifiche usando da,.. from module import something Ciò mantiene lo spazio dei nomi pulita . Per i progetti più grandi, se si utilizza un carattere jolly si potrebbe importare 2 foo o 2 bar nello stesso spazio dei nomi.

PEP 8 dice di avere importazioni su linee separate. Ad esempio:

import os 
import sys 
import yourmodule 
from yourmodule import specific_stuff 

Una cosa che faccio è alfabetizzare le mie importazioni in due gruppi. Uno è std/di terze parti e il secondo è moduli interni.