paquetes - ¿Cómo escribir un módulo/paquete Python?

lista de modulos de python

Question

He estado haciendo scripts de Python para tareas sencillas en el trabajo y nunca me molesté en empaquetarlos para que otros los usen. Ahora se me asignó hacer un envoltorio de Python para una API REST. No tengo ni idea de cómo empezar y necesito ayuda.

Lo que tengo:

(Solo quiero ser lo más específico posible) Tengo el virtualenv listo, también está en github , el archivo .gitignore para python también está allí, y la biblioteca de solicitudes para interactuar con la API REST. Eso es.

Aquí está el árbol de directorios actual

.
├── bin
│   └── /the usual stuff/
├── include
│   └── /the usual stuff/
├── lib
│   └── python2.7
│   └── /the usual stuff/
├── local
│   └── /the usual stuff/
└── README.md
27 directories, 280 files

Ni siquiera sé dónde colocar los archivos .py, si alguna vez hago uno.

Lo que quise hacer:

Haz un módulo de python que se pueda instalar con "pip install ..."

Si es posible, quiero un proceso general paso a paso para escribir módulos de Python.

Answer 1

Como nadie cubrió esta pregunta del OP todavía:

Lo que quise hacer:

Haz un módulo de python que se pueda instalar con "pip install ..."

Este es un ejemplo absolutamente mínimo, que muestra los pasos básicos para preparar y cargar su paquete a PyPI usando setuptools y twine .

Esto no es de ninguna manera un sustituto para leer al menos el tutorial , hay mucho más que lo que se explica en este ejemplo tan básico.

La creación del paquete en sí ya está cubierta por otras respuestas aquí, así que asumamos que hemos cubierto ese paso y nuestra estructura de proyecto es la siguiente:

.
└── hellostackoverflow/
├── __init__.py
└── hellostackoverflow.py

Para poder usar setuptools para el empaquetado, necesitamos agregar un archivo setup.py , que va a la carpeta raíz de nuestro proyecto:

.
├── setup.py
└── hellostackoverflow/
├── __init__.py
└── hellostackoverflow.py

Como mínimo, especificamos los metadatos de nuestro paquete, nuestro setup.py se vería así:

from setuptools import setup
setup(
name=''hellostackoverflow'',
version=''0.0.1'',
description=''a pip-installable package example'',
license=''MIT'',
packages=[''hellostackoverflow''],
author=''Benjamin Gerfelder'',
author_email=''[email protected]'',
keywords=[''example''],
url=''https://github.com/bgse/hellostackoverflow''
)

Como hemos establecido license=''MIT'' , incluimos una copia en nuestro proyecto como LICENCE.txt , junto con un archivo readme en reStructuredText como README.rst :

.
├── LICENCE.txt
├── README.rst
├── setup.py
└── hellostackoverflow/
├── __init__.py
└── hellostackoverflow.py

En este punto, estamos listos para comenzar a empaquetar utilizando setuptools , si aún no lo tenemos instalado, podemos instalarlo con pip :

pip install setuptools

Para hacer eso y crear una source distribution , en nuestra carpeta raíz del proyecto llamamos a nuestro setup.py desde la línea de comandos, especificando que deseamos sdist :

python setup.py sdist

Esto creará nuestro paquete de distribución y información de huevo, y resultará en una estructura de carpetas como esta, con nuestro paquete en dist :

.
├── dist/
├── hellostackoverflow.egg-info/
├── LICENCE.txt
├── README.rst
├── setup.py
└── hellostackoverflow/
├── __init__.py
└── hellostackoverflow.py

En este punto, tenemos un paquete que podemos instalar usando pip , así que desde nuestra raíz del proyecto (asumiendo que tiene todos los nombres como en este ejemplo):

pip install ./dist/hellostackoverflow-0.0.1.tar.gz

Si todo va bien, ahora podemos abrir un intérprete de Python, diría que en algún lugar fuera de nuestro directorio de proyectos para evitar cualquier confusión, y tratar de usar nuestro nuevo paquete brillante:

Python 3.5.2 (default, Sep 14 2017, 22:51:06)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> from hellostackoverflow import hellostackoverflow
>>> hellostackoverflow.greeting()
''Hello Stack Overflow!''

Ahora que hemos confirmado que el paquete se instala y funciona, podemos subirlo a PyPI.

Dado que no queremos contaminar el repositorio en vivo con nuestros experimentos, creamos una cuenta para el repositorio de pruebas e instalamos el twine para el proceso de carga:

pip install twine

Ahora que casi estamos allí, con nuestra cuenta creada simplemente le pedimos a twine que cargue nuestro paquete, le pedirá nuestras credenciales y subirá nuestro paquete al repositorio especificado:

twine upload --repository-url https://test.pypi.org/legacy/ dist/*

Ahora podemos iniciar sesión en nuestra cuenta en el repositorio de prueba PyPI y maravillarnos con nuestro paquete recién cargado por un tiempo, y luego capturarlo usando pip :

pip install --index-url https://test.pypi.org/simple/ hellostackoverflow

Como podemos ver, el proceso básico no es muy complicado. Como dije anteriormente, hay mucho más que lo que se trata aquí, así que sigue adelante y lee el tutorial para obtener una explicación más detallada.

Answer 2

Hacer un archivo llamado "hello.py"

Si está utilizando Python 2.x

def func():
print "Hello"

Si está utilizando Python 3.x

def func():
print("Hello")

Ejecuta el archivo. Luego, puedes probar lo siguiente:

>>> import hello
>>> hello.func()
Hello

Si quieres un poco duro, puedes usar lo siguiente:

Si está utilizando Python 2.x

def say(text):
print text

Si está utilizando Python 3.x

def say(text):
print(text)

Ver el uno en el paréntesis al lado de definir? Eso es importante. Es el que puedes usar dentro de la definición.

Texto: puedes usarlo cuando quieras que el programa diga lo que quieres. Según su nombre, es texto. Espero que sepas lo que significa el texto. Significa "palabras" u "oraciones".

Ejecuta el archivo. Luego, puedes probar lo siguiente si estás usando Python 3.x:

>>> import hello
>>> hello.say("hi")
hi
>>> from hello import say
>>> say("test")
test

Para Python 2.x - ¿Supongo que lo mismo con Python 3? Ni idea. Corríjame si cometí un error en Python 2.x (sé Python 2 pero estoy usado con Python 3)

Answer 3

Un módulo es un archivo que contiene definiciones y declaraciones de Python. El nombre del archivo es el nombre del módulo con el sufijo .py

crear hello.py luego escribir la siguiente función como su contenido:

def helloworld():
print "hello"

Entonces puedes importar hello :

>>> import hello
>>> hello.helloworld()
''hello''
>>>

Para agrupar muchos archivos .py en una carpeta. Cualquier carpeta con un __init__.py se considera un módulo de python y puede llamarlos un paquete

|-HelloModule
|_ __init__.py
|_ hellomodule.py

Puede continuar con la declaración de importación en su módulo de la manera habitual.

Para más información, ver 6.4. Paquetes .

Answer 4

Una vez que haya definido los comandos elegidos, simplemente puede arrastrar y soltar el archivo guardado en la carpeta Lib en sus archivos de programa de python.

>>> import mymodule
>>> mymodule.myfunc()

Answer 5

Creé un proyecto para iniciar fácilmente un esqueleto de proyecto desde cero . github.com/MacHu-GWU/pygitrepo-project .

Y puede crear un proyecto de prueba, digamos, learn_creating_py_package .

Puedes aprender qué componente deberías tener para diferentes propósitos como :

• crear virtualenv
• instalarse
• ejecutar unittest
• cobertura de código de ejecución
• documento de compilación
• desplegar documento
• ejecuta unittest en diferentes versiones de python
• desplegar a PYPI

La ventaja de usar pygitrepo es que esos tediosos se crean automáticamente y adaptan su project_name , github_account , github_account , el document host service , windows or macos or linux .

Es un buen lugar para aprender a desarrollar un proyecto de python como un profesional.

Espero que esto pueda ayudar.

Gracias.

Answer 6

Python 3 - ACTUALIZADO el 18 de noviembre de 2015

Encontró útil la respuesta aceptada, pero deseaba ampliar varios puntos para beneficio de otros basados ​​en mis propias experiencias.

Módulo: Un módulo es un archivo que contiene definiciones y declaraciones de Python. El nombre del archivo es el nombre del módulo con el sufijo .py anexado.

Ejemplo de módulo : Supongamos que tenemos un solo script de Python en el directorio actual, aquí lo llamo mymodule.py

El archivo mymodule.py contiene el siguiente código:

def myfunc():
print("Hello!")

Si ejecutamos el intérprete de python3 desde el directorio actual, podemos importar y ejecutar la función myfunc de las siguientes maneras (normalmente solo elegiría una de las siguientes):

>>> import mymodule
>>> mymodule.myfunc()
Hello!
>>> from mymodule import myfunc
>>> myfunc()
Hello!
>>> from mymodule import *
>>> myfunc()
Hello!

Ok, eso fue bastante fácil.

Ahora suponga que tiene la necesidad de colocar este módulo en su propia carpeta dedicada para proporcionar un espacio de nombre de módulo, en lugar de simplemente ejecutarlo ad-hoc desde el directorio de trabajo actual. Aquí es donde vale la pena explicar el concepto de un paquete .

Paquete : Los paquetes son una forma de estructurar el espacio de nombres de los módulos de Python mediante el uso de "nombres de módulos punteados". Por ejemplo, el nombre del módulo AB designa un submódulo llamado B en un paquete llamado A. Así como el uso de módulos evita que los autores de diferentes módulos tengan que preocuparse por los nombres de las variables globales de cada uno, el uso de nombres de módulos de puntos ahorra a los autores de paquetes de múltiples módulos como NumPy o la Biblioteca de imágenes de Python por tener que preocuparse por los nombres de los módulos de los demás.

Ejemplo de paquete : ahora asumamos que tenemos la siguiente carpeta y archivos. Aquí, mymodule.py es idéntico a antes, y __init__.py es un archivo vacío:

.
└── mypackage
├── __init__.py
└── mymodule.py

Los archivos __init__.py son necesarios para que Python trate los directorios como paquetes que contienen. Para obtener más información, consulte el enlace de documentación de los módulos que se proporciona más adelante.

Nuestro directorio de trabajo actual está un nivel por encima de la carpeta ordinaria llamada mypackage

$ ls
mypackage

Si ejecutamos el intérprete de python3 ahora, podemos importar y ejecutar el módulo mymodule.py que contiene la función myfunc requerida de las siguientes maneras (normalmente solo elegiría una de las siguientes):

>>> import mypackage
>>> from mypackage import mymodule
>>> mymodule.myfunc()
Hello!
>>> import mypackage.mymodule
>>> mypackage.mymodule.myfunc()
Hello!
>>> from mypackage import mymodule
>>> mymodule.myfunc()
Hello!
>>> from mypackage.mymodule import myfunc
>>> myfunc()
Hello!
>>> from mypackage.mymodule import *
>>> myfunc()
Hello!

Suponiendo Python 3, hay excelente documentación en: Modules

En cuanto a las convenciones de nomenclatura para paquetes y módulos, las pautas generales se encuentran en PEP-0008; consulte Nombres de paquetes y módulos

Los módulos deben tener nombres cortos, todo en minúsculas. Los guiones bajos se pueden usar en el nombre del módulo si mejora la legibilidad. Los paquetes de Python también deben tener nombres cortos en minúsculas, aunque se desaconseja el uso de guiones bajos.