python sirve ¿Qué es__init__.py para?




que es def__ init__ (8)

¿ __init__.py qué sirve __init__.py en un directorio de origen de Python?

https://code.i-harness.com


Además de etiquetar un directorio como un paquete de Python y definir __all__ , __init__.py permite definir cualquier variable en el nivel del paquete. A menudo es conveniente hacerlo si un paquete define algo que se importará con frecuencia, de manera similar a la API. Este patrón promueve la adherencia a la filosofía "plana es mejor que anidada" de Pythonic.

Un ejemplo

Aquí hay un ejemplo de uno de mis proyectos, en el que frecuentemente importo un sessionmaker llamado Session para interactuar con mi base de datos. Escribí un paquete de "base de datos" con algunos módulos:

database/
    __init__.py
    schema.py
    insertions.py
    queries.py

Mi __init__.py contiene el siguiente código:

import os

from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine

engine = create_engine(os.environ['DATABASE_URL'])
Session = sessionmaker(bind=engine)

Desde que definí la Session aquí, puedo comenzar una nueva sesión usando la sintaxis a continuación. Este código sería el mismo ejecutado desde dentro o fuera del directorio del paquete "base de datos".

from database import Session
session = Session()

Por supuesto, esto es una pequeña conveniencia; la alternativa sería definir la Session en un nuevo archivo como "create_session.py" en mi paquete de base de datos, y comenzar nuevas sesiones usando:

from database.create_session import Session
session = Session()

Otras lecturas

Hay un hilo reddit bastante interesante que cubre los usos apropiados de __init__.py aquí:

http://www.reddit.com/r/Python/comments/1bbbwk/whats_your_opinion_on_what_to_include_in_init_py/

La opinión de la mayoría parece ser que los archivos __init__.py deben ser muy finos para evitar violar la filosofía "explícito es mejor que implícito".


Aunque Python funciona sin un archivo __init__.py , aún debe incluir uno.

Especifica que un paquete debe tratarse como un módulo, por lo tanto, inclúyalo (incluso si está vacío).

También hay un caso en el que puede usar un archivo __init__.py :

Imagina que tienes la siguiente estructura de archivos:

main_methods 
    |- methods.py

Y methods.py contenía esto:

def foo():
    return 'foo'

Para usar foo() necesitarías uno de los siguientes:

from main_methods.methods import foo # Call with foo()
from main_methods import methods # Call with methods.foo()
import main_methods.methods # Call with main_methods.methods.foo()

Quizás allí necesite (o desee) mantener main_methods dentro de main_methods (tiempos de ejecución / dependencias, por ejemplo), pero solo desea importar main_methods .

Si cambió el nombre de __init__.py a __init__.py entonces podría usar foo() importando main_methods :

import main_methods
print(main_methods.foo()) # Prints 'foo'

Esto funciona porque __init__.py se trata como parte del paquete.

Algunos paquetes de Python realmente hacen esto. Un ejemplo es con JSON , donde la ejecución de import json realidad está importando __init__.py del paquete json ( vea la estructura de archivos del paquete aquí ):

Código fuente: Lib/json/__init__.py


El archivo __init__.py hace que Python trate los directorios que lo contienen como módulos.

Además, este es el primer archivo que se carga en un módulo, por lo que puede usarlo para ejecutar el código que desea ejecutar cada vez que se carga un módulo, o especificar los submódulos que se exportarán.


En Python la definición de paquete es muy simple. Al igual que Java, la estructura jerárquica y la estructura de directorios son las mismas. Pero tienes que tener __init__.py en un paquete. Explicaré el archivo __init__.py con el siguiente ejemplo:

package_x/
|--  __init__.py
|--    subPackage_a/
|------  __init__.py
|------  module_m1.py
|--    subPackage_b/
|------  __init__.py
|------  module_n1.py
|------  module_n2.py
|------  module_n3.py

__init__.py puede estar vacío, siempre que exista. Indica que el directorio debe ser considerado como un paquete. Por supuesto, __init__.py también puede establecer el contenido apropiado.

Si agregamos una función en module_n1:

def function_X():
    print "function_X in module_n1"
    return

Despues de correr:

>>>from package_x.subPackage_b.module_n1 import function_X
>>>function_X()

function_X in module_n1 

Luego seguimos el paquete de jerarquía y llamamos a module_n1 la función. Podemos usar __init__.py en el subpaquete_b de esta manera:

__all__ = ['module_n2', 'module_n3']

Despues de correr:

>>>from package_x.subPackage_b import * 
>>>module_n1.function_X()

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named module_n1

Por lo tanto, al usar * importing, el paquete del módulo está sujeto al contenido __init__.py .


Facilita la importación de otros archivos de python. Cuando coloca este archivo en un directorio (digamos cosas) que contiene otros archivos py, entonces puede hacer algo como importar cosas. Otro.

root\
    stuff\
         other.py

    morestuff\
         another.py

Sin este __init__.py dentro del directorio, no podría importar other.py, porque Python no sabe dónde está el código fuente del material y no puede reconocerlo como un paquete.


Hay 2 razones principales para __init__.py

  1. Para su comodidad: los otros usuarios no necesitarán conocer la ubicación exacta de sus funciones en la jerarquía de paquetes.

    your_package/
      __init__.py
      file1.py/
      file2.py/
        ...
      fileN.py
    
    # in __init__.py
    from file1 import *
    from file2 import *
    ...
    from fileN import *
    
    # in file1.py
    def add():
        pass
    

    entonces otros pueden llamar a add () por

    from your_package import add
    

    sin saber archivo1, como

    from your_package.file1 import add
    
  2. Si quieres que se inicialice algo; por ejemplo, el registro (que se debe poner en el nivel superior):

    import logging.config
    logging.config.dictConfig(Your_logging_config)
    

__init__.py tratará el directorio en el que se encuentra como un módulo cargable.

Para las personas que prefieren leer el código, pongo el comentario de Two-Bit Alchemist aquí.

$ find /tmp/mydir/
/tmp/mydir/
/tmp/mydir//spam
/tmp/mydir//spam/__init__.py
/tmp/mydir//spam/module.py
$ cd ~
$ python
>>> import sys
>>> sys.path.insert(0, '/tmp/mydir')
>>> from spam import module
>>> module.myfun(3)
9
>>> exit()
$ 
$ rm /tmp/mydir/spam/__init__.py*
$ 
$ python
>>> import sys
>>> sys.path.insert(0, '/tmp/mydir')
>>> from spam import module
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named spam
>>> 

¿Para qué se usa __init__.py?

El uso principal de __init__.py es inicializar los paquetes de Python. La forma más sencilla de demostrar esto es observar la estructura de un módulo estándar de Python.

package/
    __init__.py
    file.py
    file2.py
    file3.py
    subpackage/
        __init__.py
        submodule1.py
        submodule2.py

Como puede ver en la estructura anterior, la inclusión del archivo __init__.py en un directorio indica al intérprete de Python que el directorio debe tratarse como un paquete de Python

¿Qué pasa en __init__.py ?

__init__.py puede ser un archivo vacío, pero a menudo se usa para realizar la configuración necesaria para el paquete (importar cosas, cargar cosas en la ruta, etc.).

Una cosa común que se debe hacer en su __init__.py es importar las Clases, funciones, etc. seleccionadas al nivel del paquete para que puedan ser importadas convenientemente desde el paquete.

En el ejemplo anterior podemos decir que file.py tiene el archivo de clase. Así que sin nada en nuestro __init__.py usted importaría con esta sintaxis:

from package.file import File

Sin embargo, puede importar un archivo en su __init__.py para que esté disponible a nivel de paquete:

# in your __init__.py
from file import File

# now import File from package
from package import File

Otra cosa que hacer es a nivel de paquete hacer que los subpaquetes / módulos estén disponibles con la variable __all__ . Cuando el __all__ ve una variable __all__ definida en un __init__.py , importa los módulos listados en la variable __all__ cuando hace:

from package import *

__all__ es una lista que contiene los nombres de los módulos que desea importar con import *, por lo que, si volvemos a importar los submódulos en el subpaquete, la variable subpackage/__init__.py en el subpackage/__init__.py sería:

__all__ = ['submodule1', 'submodule2']

Con la variable __all__ poblada así, cuando se realiza

from subpackage import *

Importaría submódulo1 y submódulo2.

Como puede ver, __init__.py puede ser muy útil además de su función principal de indicar que un directorio es un módulo.

Reference







module