[pyar] [ modulos y paquetes... no los entiendo]

[Emiliano Dalla Verde Marcozzi]

>
> 2012/2/5 goosfancito <goosfancito en gmail.com>:
>
>
> > test
> > ------ modulo1
> > ---------programa1.py
> >               def actividad
> > ------ modulo2
> > ----------programa2.py
> >               def correr
> >               def caminar
> > -------programa3.py
> >             def persona
> >
> >
> > si estoy ejecutando programa1.py y necesito a programa2.py como utilizo
> > el import?
> >
>

A ver si por ahi esto te ayuda un poquito ... lo primero que hay que saber
y te
lo explica bien el link del tutorial que te paso Diego, es el tema de como
python
busca y encuentra desde donde ejecutar codigo, por aca una 'sesion' de bash
y
lo que comienza con '#' son mis comentarios:

yuno en Asuka:~/asd$ python  # arranco python
Python 2.7.2+ (default, Oct  4 2011, 20:06:09)
[GCC 4.6.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.

>>> from foo import bar  # trato de importar bar desde foo
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named foo  # me dice que no existe el modulo foo,
bueno, lo creo
>>>

yuno en Asuka:~/asd$ touch foo.py  # aca creo el modulo foo, touch crea el
nuevo archivo
yuno en Asuka:~/asd$ echo '  # uso echo desde bash para escribir un metodo en
el archivo
> def bar():\
>     print 1 + 1' > foo.py

yuno en Asuka:~/asd$ cat foo.py  # asi me quedo foo.py, con el metodo bar
escrito

def bar():\
    print 1 + 1


yuno en Asuka:~/asd$ python  # ahora arranco de nuevo el interprete de python
y trato de importar bar desde foo
Python 2.7.2+ (default, Oct  4 2011, 20:06:09)
[GCC 4.6.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from foo import bar  # esta vez funciona, y es mas, puedo ejecutar la
funcion bar
>>> bar()
2
>>>

Bueno, resumiendo un poco lo de los comentarios ... primero quisimos
importar un metodo bar desde un modulo
foo y ese modulo foo no existia. Entonces, creamos foo.py y el metodo bar
dentro y todo de maravillas. Ahora,
vamos un paso mas adelante y supongamos que queremos usar este metodo 'bar'
que se encuentra definido en
el modulo foo pero, ... desde un nuevo modulo ... llamese 'teta':

yuno en Asuka:~/asd$ touch teta.py
yuno en Asuka:~/asd$ cat teta.py
from foo import bar
bar()
yuno en Asuka:~/asd$ python teta.py
2
yuno en Asuka:~/asd$ ls
foo.py teta.py
yuno en Asuka:~/asd$

Bueno, al ejecutar python teta.py, la primer linea dice 'from foo import
bar', entonces el interprete BUSCA
ese modulo foo ... y como lo busca ? bueno, el primer lugar donde busca es
en el directorio actual donde
vos ejecutaste el comando 'python teta.py' y como en ese directorio tambien
esta foo.py, entonces lo
encuentra (fijate que por eso te copie y pegue la salida del 'ls'). En caso
que no encontrara a foo.py en el
directorio donde vos ejecutaste el comando 'python ... ' va a ir a buscar a
lugares que estan definidos en
sys.path ... y como sabes cuales son esos lugares? pues desde el interprete:

yuno en Asuka:~/asd$ python
Python 2.7.2+ (default, Oct  4 2011, 20:06:09)
[GCC 4.6.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> sys.path
['',
'/usr/local/lib/python2.7/dist-packages/virtualenvwrapper-2.10-py2.7.egg',
'/usr/lib/python2.7', '/usr/lib/python2.7/plat-linux2',
'/usr/lib/python2.7/lib-tk', '/usr/lib/python2.7/lib-old',
'/usr/lib/python2.7/lib-dynload', '/usr/local/lib/python2.7/dist-packages',
'/usr/local/lib/python2.7/dist-packages/setuptools-0.6c11-py2.7.egg-info',
'/usr/lib/python2.7/dist-packages', '/usr/lib/python2.7/dist-packages/PIL',
'/usr/lib/python2.7/dist-packages/gst-0.10',
'/usr/lib/python2.7/dist-packages/gtk-2.0', '/usr/lib/pymodules/python2.7',
'/usr/lib/python2.7/dist-packages/ubuntu-sso-client',
'/usr/lib/python2.7/dist-packages/ubuntuone-client',
'/usr/lib/python2.7/dist-packages/ubuntuone-control-panel',
'/usr/lib/python2.7/dist-packages/ubuntuone-couch',
'/usr/lib/python2.7/dist-packages/ubuntuone-installer',
'/usr/lib/python2.7/dist-packages/ubuntuone-storage-protocol',
'/usr/lib/python2.7/dist-packages/wx-2.8-gtk2-unicode']

Ves todos esos paths, elementos de esa lista sys.path ? bueno, python va a
andar buscando a foo.py por todos esos
lugares en caso de que no lo encontrara en el directorio donde vos
ejecutaste el comando python. Mira, rompamos el
ejemplo que puse antes, osea lo que voy a hacer es mover el modulo foo a
otro directorio y veamos que pasa:

yuno en Asuka:~/asd$ ls -las
total 20
4 drwxrwxr-x  2 yuno yuno 4096 2012-02-06 09:45 .
4 drwxr-xr-x 62 yuno yuno 4096 2012-02-06 09:35 ..
4 -rw-rw-r--  1 yuno yuno   29 2012-02-06 09:38 foo.py
4 -rw-rw-r--  1 yuno yuno   26 2012-02-06 09:47 teta.py

yuno en Asuka:~/asd$ python
Python 2.7.2+ (default, Oct  4 2011, 20:06:09)
[GCC 4.6.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from foo import bar
>>> bar()
2
>>> # aca salgo del interprete con ctrl + d

yuno en Asuka:~/asd$ mv foo.py otracosa.py  # renombro el archivo foo a
otracosa.py
yuno en Asuka:~/asd$ rm foo.pyc  # borro el *.pyc, python a partir de archivos
.py crea archivos .pyc que los lee mas rapido
                                                 # si dejara el foo.pyc ,
python seguiria encontrando al modulo foo, y no queremos eso ;)

yuno en Asuka:~/asd$ python
Python 2.7.2+ (default, Oct  4 2011, 20:06:09)
[GCC 4.6.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from foo import bar
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named foo

>>> from otracosa import bar
>>> bar()
2

Bien, repasando ... renombramos foo.py a otracosa.py y entonces ya no
funcionaba mas el import, puesto
que no se encontraba el modulo foo.py en el directorio donde yo ejecute
'python ...' y porque el modulo foo.py
tampoco se encuentra en ninguno de los paths definidos / listados en
sys.path.

Ahora bien, yo siempre use como módulos archivos .py, pero tambien podes
crear directorios e 'importarlos',
veamos un ejemplo primero con nuestro foo.py pero ahora en forma de
'directorio':

yuno en Asuka:~/asd$ ls -las  # borre todo, osea arrancamos de 0
total 8
4 drwxrwxr-x  2 yuno yuno 4096 2012-02-06 10:00 .
4 drwxr-xr-x 62 yuno yuno 4096 2012-02-06 09:35 ..

yuno en Asuka:~/asd$ mkdir foo  # creo el directorio 'foo'
yuno en Asuka:~/asd$ touch foo/__init__.py  # creo un archivo que SI o SI se
tiene que llamar __init__.py
yuno en Asuka:~/asd$ touch foo/bar.py  # creo un modulo bar.py dentro de foo
yuno en Asuka:~/asd$ cat ./foo/bar.py  # el contenido de bar.py tiene definido
una funcion 'hello'
def hello():
    print('hola')

Ahora nos vamos al interprete de python:

yuno en Asuka:~/asd$ python
Python 2.7.2+ (default, Oct  4 2011, 20:06:09)
[GCC 4.6.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from foo import bar
>>> bar.hello()
hola
>>>

Buenisimo! ejecutamos la funcion hello ! ^^ ... bien, porque es tan
importante ese archivo __init__.py ? porque
le dice a python que ese directorio foo es importante y que lo debe tener
en cuenta a la hora de 'buscar modulos',
fijemosnos que pasa si borramos ese archivito __init__.py:

yuno en Asuka:~/asd$ pwd  # mi directorio actual
/home/yuno/asd
yuno en Asuka:~/asd$ ls  # solo tengo el directorio foo
foo
yuno en Asuka:~/asd$ rm foo/__init__.py  # borramos el __init__.py
yuno en Asuka:~/asd$ rm foo/__init__.pyc  # borramos su correspondiente
archivo .pyc que crea python

yuno en Asuka:~/asd$ python  # ejecutamos el interprete:
Python 2.7.2+ (default, Oct  4 2011, 20:06:09)
[GCC 4.6.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from foo import bar
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named foo
>>>

Al sacar el __init__.py,  python ya no considera al directorio foo,
entonces falla ...
Otra cosa muy importante es 'desde donde' osea desde que lugar en el path
ejecutas tus cosas
python, miremos un ejemplo ...

yuno en Asuka:~/asd$ pwd  # este es el directorio actual donde 'estoy parado'
/home/yuno/asd
yuno en Asuka:~/asd$ touch foo/__init__.py  # creo el archivo que le borre
antes a foo
yuno en Asuka:~/asd$ cd foo/  # me meto dentro del directorio foo

yuno en Asuka:~/asd/foo$ python  # entramos al interprete
Python 2.7.2+ (default, Oct  4 2011, 20:06:09)
[GCC 4.6.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from foo import bar  # NO NOS FUNCIONA! OHHHHHHH NOOOO !!!!!
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named foo
>>>  # salgo del interprete

yuno en Asuka:~/asd/foo$ pwd  # ok, estamos dentro del directorio foo, si esta
bien, nosotros nos metimos aca antes ...
/home/yuno/asd/foo
yuno en Asuka:~/asd/foo$ cd ..  # vamos un directorio arriba
yuno en Asuka:~/asd$ python  # abrimos nuevamente el interprete
Python 2.7.2+ (default, Oct  4 2011, 20:06:09)
[GCC 4.6.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from foo import bar  # Y AHORA NOS FUNCIONA, YES YES YES!!!
>>>

En fin, quedo un poco mas claro el tema ? no dudes en leer detenidamente y
tranca el tutorial y la sección
módulos que te paso Diego que ahí esta muy buen explicado,
Saludos,

-- 
日本語勉強する
https://bitbucket.org/edvm
------------ próxima parte ------------
Se ha borrado un adjunto en formato HTML...
URL: <http://listas.python.org.ar/pipermail/pyar/attachments/20120206/23542553/attachment.html>