El post que buscas se encuentra eliminado, pero este también te puede interesar

Aceptando parametros desde la linea de comandos con Python

Aceptando parámetros desde la linea de comandos con Python

Parte 1 - Parte 2 - Parte 3

Bienvenidos a la ya 4ª parte de esta serie de tutoriales, les recuerdo que en los tres anteriores tutoriales creamos tres funciones, las cuales nos permitían ocultar y desolcultar archivos además de una tercera que nos permitía obtener el estado en que se encontraba dicho archivo. En esta oportunidad les mostrare usando a PyHide (Pueden encontrar mas información sobre este proyecto aquí http://wiki.codigopython.com.ar/pyhide) como interactuar con el usuario a través de la linea de comandos aceptando el uso de argumentos, un ejemplo de esto es el uso del comando 'cd' (este comando nos permite cambiar el directorio de trabajo que estamos utilizando) en Linux este acepta un argumento que es el directorio con el que deseamos trabajar, algo similar deberemos de implementar en nuestra aplicación para facilitar su uso pero para esto planteemos cuales serán lo pasos que tendremos que tener en cuenta para conseguirlo

1 - El usuario ejecuta nuestra aplicación con un argumento
2 - Se analizan los argumentos ingresados
3 - Se ejecuta la función 'hide', 'show' o 'check' según corresponda

Eso es una breve descripción de la meta que nos proponemos a lo largo del tutorial, ahora si empecemos por el principio de esto. El primer inciso que nos planteamos implica que nuestra aplicación soporte el uso de argumentos para funcionar, en un principio nuestras funciones ya toman un argumento que es el archivo que se utilizara pero nuestra aplicación va a necesitar dos argumentos uno para indicar el archivo y el otro para indicar la acción ha realizar, es decir si se llama a 'hide' o a 'show', pero veamoslo con un ejemplo.

Supongamos que ejecutamos a nuestra aplicación, en este caso llamada PyHide, la ejecutamos con dos argumentos uno es el archivo y el otro la acción, siendo:

-c = Para utilizar a 'check'
-s = Para utilizar a 'show'
-h = Para utilizar a 'hide'
file = El archivo a utilizar


Un ejemplo seria:

python pyhide file -c
# Dándole un archivo para analizar quedaría
python pyhide /usr/bin/firefox -c

Con lo cual estamos ejecutando nuestra aplicación a través de la linea de comandos para ejecutar la función 'check' sobre el archivo '/usr/bin/firefox', como nos damos cuenta ya dimos un paso viendo los argumentos que usara nuestra aplicación y como se usaran por parte del usuario pero falta empezar con lo mas importante que es empezar a escribir las lineas de código necesarias para que esto que planteamos se haga una realidad y como se imaginaran ya deberemos meternos en una previa de lo que sera la segunda parte.

Empecemos presentado a una función muy útil cortesía del modulo 'sys' llamada 'argv', esta función va a ser el motor que hará funcionar esto. Esta función 'argv' tiene una forma muy simple de trabajar ya que este se encarga de almacenar los parámetros introducidos desde la linea de comandos en una lista a la que podemos acceder escribiendo "sys.argv[]" ingresando desde luego el índice entre los corchetes '[]', una de las cosas que hay que tener en cuenta es el orden en que se almacenan los parámetros. El primer valor que almacena es el nombre del archivo, el segundo es el primer parámetro y el tercero el segundo parámetro, así como se imaginaran para el resto de los parámetros en caso de que existan.

Veamoslo con un ejemplo antes de continuar


Un ejemplo seria
python pyhide.py file1 file2 file3 action
Donde:
sys.argv[0] = pyhide.py
sys.argv[1] = file1
sys.argv[2] = file2
sys.argv[3] = file3
sys.argv[4] = action


Para ver como funciona lo que les mostré arriba es tan simple como crear un archivo (Con o sin la extensión .py) y dentro de este colocamos algo similar a esto:

import sys

for elements in sys.argv:
    print elements

Y a este archivo desde nuestra consola (Recuerden de estar trabajando en la misma carpeta donde se encuentra este archivo) lo ejecutaremos de la siguiente forma:

python archivo.py 1 2 3

Y el resultado sera este:

$ python archivo.py 1 2 3
archivo.py
1
2
3

Lo que conseguimos es imprimir todas la variables almacenadas en la lista 'sys.argv', ahora puede surgir una duda sobre ese pequeño script que usamos para mostrar los parámetros ingresados desde la consola, que aunque este lejos de ser el motivo del tutorial no esta de mas explicar su funcionamiento de forma breve.

Bueno comienzo a explicar el porque y como del uso del siguiente script:

import sys

for elements in sys.argv:
    print elements

En la primer linea se importa el modulo 'sys' que es necesario para poder usar la función de este llamada 'argv', ya en la tercera nos encontramos con el bucle 'for' en esta el cuerpo del bucle se ejecuta tantas veces como elementos tenga la lista en este caso se ejecutaría 4 veces el cuerpo de nuestro bucle, es decir se ejecuta cuatro veces la sentencia 'print', mostrando así los cuatro argumentos almacenados en 'sys.argv'. Para mas información pueden consultar en algún libro o tutorial de Python donde podrán encontrar mas información sobre el bucle 'for'.

Hasta ahora tenemos una idea de como funciona 'argv' y como almacenar estos valores en variables para su posterior uso, pero nos esta faltando un paso importante saber si el usuario esta ejecutando nuestra aplicación desde la linea de comandos o lo esta importando desde otra aplicación.

NOTA:
La diferencia entre ejecutar una aplicación (o script) o importarlo radica en que al importarlo su forma de uso se asemeja a como usamos los módulos de Python porque lo que hacemos es utilizar funciones contenidas dentro de este y la interacción con el usuario lo hace la aplicación que importa a la nuestra, en cambio cuando el usuario ejecuta nuestra aplicación directamente necesitamos establecer una forma de comunicación e interacción con el usuario para su uso (Aunque esto no es siempre necesario cuando se tratan de scripts). En esta oportunidad trabajaremos con la consola aunque mas adelante lo veremos ya con una interfaz gráfica pero sera material para otro tutorial.

Para identificar si nuestra aplicación esta siendo ejecutada desde la consola tenemos que conocer y entender a el modulo '__main__', esto es porque este nos permitirá dividir la parte que analiza si se esta ejecutando nuestra aplicación directamente de el resto del código que tenemos.

Con '__main__' comenzamos ya nuestra segunda parte, no vamos ver muy a fondo tanto a 'sys.argv' como a '__main__' porque mas adelante veremos a estos dos de nuevo pero de una forma mas avanzada en otro tutorial. Cuando se habla de '__main__' y 'sys.argv' se tiende a hablar del siguiente condicional:

if __name__ == "__main__":

Como vemos entran en juego dos factores uno es '__main__' y el otro es '__name__', toda la explicación que les pueda dar sobre estos dos se resume a lo siguiente:

Si '__name__' toma el valor '__main__' nuestra aplicación se esta ejecutando como un programa independiente y no es importada por otra, en cambio si nuestra aplicación es importada '__name__' tomara el nombre del archivo (Sin su extensión) o mejor dicho el nombre del modulo.

RECUERDEN: Recordemos que los módulos cuando se importan no llevan la extensión '.py' solo el nombre del archivo.



Por ejemplo si abrimos la consola de Python y escribimos "__name__" nos responderá lo siguiente:

>>> __name__
'__main__'
>>> 


Esto es porque estamos ejecutando directamente desde la consola, pero para saber si esto no se repite cuando uno importa nuestra aplicación (o script dependerá de con que trabajemos) no nos quedara mas que demostrarlo, acá la cosa se complica por que deberemos crear dos archivos uno que importe un archivo y otro que sea importado. En este caso voy a crear dos archivos uno que se llame 'linux.py' que va a ser el archivo que importe el modulo y el otro sera 'rule.py'

Dentro de linux.py pondremos lo básico que sera importar el archivo 'rule.py'

linux.py

import rule


Dentro de rule.py imprimiremos la salida de '__name__' para ver que resultado nos arroja.

rule.py

print __name__


Una vez creados los dos archivos y ubicados en la misma carpeta (Esto ultimo es muy importante para que funcione) ejecutaremos el archivo 'linux.py' en nuestra consola:


$ python linux.py
rule


Como observamos la salida es lo que habíamos anticipado el nombre del archivo, pero como se que son desconfiados quizás se pregunten si ejecutamos directamente el archivo 'rule.py' se nos da que '__name__' es igual a '__main__', hacerlo es tan simple como escribir en la consola 'rule.py' (Recuerden estar ubicados en la misma directorio donde se encuentran ubicados los dos archivos)

La salida sera la siguiente:


$ python rule.py
__main__


Con lo que corroboramos de que nos les había mentido

Ya vimos a 'sys.argv' y a '__main__' es hora de unirlos y ponerlos a prueba en PyHide, así que lo mejor sera poner lo que ya tenemos hasta ahora:


import os

def hide(file):
    if not os.path.exists(file):
        return
    archive = os.path.basename(file)
    directorio = os.path.dirname(file)
    if archive[0] == '.':
        return
    else:
        newfile = directorio+'/''.'+archive
        os.rename(file, newfile)

def show(file):
    if not os.path.exists(file):
        return
    archive = os.path.basename(file)
    directorio = os.path.dirname(file)
    if archive[0] != '.':
        return
    else:
        while archive[0] is '.':
            archive = archive[1:]
        newfile = directorio+'/'+archive
        os.rename(file, newfile)

def check(file):
    if not os.path.exists(file):
        return "El archivo no existe"
    archive = os.path.basename(file)
    if archive[0] == '.':
        return archive + " Se encuentra oculto"
    else:
        return archive + " No se encuentra oculto"



Para dotarlo de la capacidad de poder utilizar argumentos desde la linea de comando deberemos agregar un par de lineas, una de estas sera obviamente donde importemos al modulo 'sys' las otras serán las que analicen los argumentos ingresados. Cuando llegamos a este punto debemos considerar que el usuario no ingrese parámetros o que no ingrese comandos validos, por esto mismo debemos cubrir esas posibilidades planteando los posibles problemas y soluciones.

Empecemos con una pequeña lista como esta:

El usuario no ingresa argumentos
El usuario no ingresa la cantidad necesaria de argumentos
Los argumentos ingresados no son validos


Empecemos desde el principio, sabemos que la cantidad mínima de valores que contiene la lista generada por 'sys.argv' es de 1 valor el cual es el nombre del archivo, así que la longitud de 'argv' debe mayor a uno, pero si vemos el siguiente punto de nuestra lista tenemos que tener cuenta que nuestra aplicación requiere de dos argumentos como mínimo y máximo los cuales eran el nombre del archivo y la acción a realizar, de esta forma al replantearlo vemos que la cantidad de valores que tiene que tener 'sys.argv' debe ser igual a tres. Para analizar la longitud de 'sys.argv' tenemos que considerar el uso de 'len()', así como se suele utilizar para analizar cadenas de texto se puede utilizar para analizar listas y tuplas entre otros. En nuestro caso tenemos que crear un condicional que analice esta condición de la siguiente forma:


if len(sys.argv) != 3:
    return
else:
    pass


Quedemos con eso por un momento antes de seguir, primero analizamos si la cantidad de argumentos es la correcta en caso de no serlo como vemos terminamos la ejecución del mismo, si la cantidad de argumentos es la indicada continuamos con el condicional ejecutando lo que coloquemos debajo del 'else' en el caso de que lo necesitamos, en nuestro caso prescindiremos de su uso, una vez superado esto comencemos a analizar el tercer valor que tomara 'sys.argv' que sera la acción a realizar por nuestra aplicación. Recordemos los tres valores que podía tomar


-c = Para utilizar a 'check'
-s = Para utilizar a 'show'
-h = Para utilizar a 'hide'


Como observamos dependerá del argumento ingresado para determinar que función se deberá de llamar, lo primero que podemos hacer es tomar los dos valores que nos interesan y asignarlos a dos variables para facilitar su uso.

file = sys.argv[1]
action = sys.argv[2]


El valor de 'file' no lo analizaremos eso lo hará la función que sea llamada luego, lo que si tenemos que analizar es el valor de 'action' y dependiendo de el valor que tome actuar en consecuencia, para esto con unos condicionales nos bastara para que quede de la siguiente forma:


if action == '-c':
    check(file)
elif action == '-h':
    hide(file)
elif action == '-s':
    show(file)
else:
    return


Como observamos de una forma mas que simple analizamos las cuatro posibilidades que se nos puede presentar, la ultima de estas que esta comprendida por el condicional 'else' esta para actuar en caso de que el usuario haya ingresado un valor incorrecto.

NOTA:
En los casos que use la sentencia return se pueden reemplazar por mensajes de error indicándole al usuario que fue lo que sucedió pero eso sera material para otro tutorial.

Hasta ahora tenemos partes que satisfacen nuestras necesidades pero nos queda juntar todo esto dentro del condicional


if __name__ == '__main__':


Para que solo se ejecute cuando el usuario este ejecutando nuestra aplicación desde la consola, así que es cuestión de juntar las partes para formar un todo.


if __name__ == '__main__':
    if len(sys.argv) != 3:
        print "La cantidad de argumentos ingresada no es correcta"
    file = sys.argv[1]
    action = sys.argv[2]
    if action == '-c':
        print check(file)
    elif action == '-h':
        hide(file)
        print "El archivo se encuentra oculto"
    elif action == '-s':
        show(file)
        print "El archivo ya no se encuentra oculto"
    else:
        print "El argumento ingresado no es correcto"


Aunque funciona es una forma un tanto desprolija e incompleta de conseguir esto pero por ahora nos alcanza para dotar a nuestra aplicación de soporte para poder utilizarla desde la linea de comandos. Para probar lo que hicimos hasta ahora es tan simple como juntar todo esto en un archivo al que en mi caso llamare 'PyHide.py' y lo ejecutare con los siguientes valores:

python PyHide.py /usr/bin/firefox -c


Y deberíamos obtener algo similar a esto:

$ python PyHide.py /usr/bin/firefox -c
firefox No se encuentra oculto


Cerrando el tutorial de hoy les dejo el contenido del archivo PyHide.py con su respectiva licencia


#!/usr/bin/env python
# -*- coding: utf-8 -*-

# <Aplicación para ocultar archivos en sistemas Unix.>
# Copyright (C) 2011 Alejandro Alvarez <contacto@codigopython.com.ar>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

# http://www.codigopython.com.ar <contacto@codigopython.com.ar>

import os, sys

def hide(file):
    if not os.path.exists(file):
        return
    archive = os.path.basename(file)
    directorio = os.path.dirname(file)
    if archive[0] == '.':
        return
    else:
        newfile = directorio+'/''.'+archive
        os.rename(file, newfile)

def show(file):
    if not os.path.exists(file):
        return
    archive = os.path.basename(file)
    directorio = os.path.dirname(file)
    if archive[0] != '.':
        return
    else:
        while archive[0] == '.':
            archive = archive[1:]
        newfile = directorio+'/'+archive
        os.rename(file, newfile)

def check(file):
    if not os.path.exists(file):
        return "El archivo no existe"
    archive = os.path.basename(file)
    if archive[0] == '.':
        return archive + " Se encuentra oculto"
    else:
        return archive + " No se encuentra oculto"

if __name__ == '__main__':
    if len(sys.argv) != 3:
        print "La cantidad de argumentos ingresada no es correcta"
    file = sys.argv[1]
    action = sys.argv[2]
    if action == '-c':
        print check(file)
    elif action == '-h':
        hide(file)
        print "El archivo se encuentra oculto"
    elif action == '-s':
        show(file)
        print "El archivo ya no se encuentra oculto"
    else:
        print "El argumento ingresado no es correcto"


NOTA:
El condicional "if __name__ =='__main__':" deberá ir debajo de las funciones/variable que desee o necesite llamar, esto es así porque no podemos ejecutar una función o leer una variable que el interprete aun no ejecuto.


Como conclusión y para cerrar este tutorial podemos decir que junto a 'sys.argv' y el uso de "if __name__ == "__main__"" se puede trabajar como módulos reutilizables o como programas independientes sin tener que crear dos archivos con lo cual estamos ampliando las posibilidades del uso y mantenimiento de nuestra aplicación.



Glosario:
!= : Distinto de


Unos links que les pueden ser útiles
Acerca de PyHide:
http://wiki.codigopython.com.ar/pyhide
__main__:
http://docs.python.org/library/__main__.html
sys.argv:
http://docs.python.org/library/sys.html#sys.argv
Bucle 'for':
http://es.wikipedia.org/wiki/Python#Bucle_for
http://www.mclibre.org/consultar/python/lecciones/le05_for.html
Acerca del comando 'cd':
http://manpages.ubuntu.com/manpages/natty/en/man1/cd.1posix.html

Material de lectura recomendada:
http://www.holamundo.es/lenguaje/python/articulos/acceder-argumentos-pasados-parámetro-python.html
http://mundogeek.net/archivos/2008/04/02/python-entrada-salida-ficheros/
http://foro.elhacker.net/scripting/python_que_es_name_main-t264304.0.html#ixzz1KOZgDEYm

Segui este post tambien en:
http://snipplr.com/view/55160/

Si ves que este post merece alguna modificacion sentite libre de hacerlo a traves de esta Wiki siguiendo el siguiente enlace:
http://wiki.codigopython.com.ar/pyhide:aceptando-parametros-desde-la-linea-de-comandos

Fuente:
http://www.codigopython.com.ar/?p=203

Anuncios

6 comentarios - Aceptando parametros desde la linea de comandos con Python

@8MoCoSo7
Esta bueno lo mando a favs para cuando necesite
@skymloder
Excelente material a favoritos.
@Allowski
por que no usas SWITCH en vez de llenarte de condicionales???
@nolito
Allowski dijo:por que no usas SWITCH en vez de llenarte de condicionales???

Porque python no tiene switch