Así que ya saben, siéntanse libres de hacerme llegar sus dudas comentarios o sugerencias que no molestan.

Como palabras finales les recuerdo que pueden seguir el desarrollo desde el repositorio GIT (https://github.com/eliluminado/Guia-Tkinter), cualquier corrección que vean que necesita la guía me mandan un correo o lo dejan en el repositorio en GitHub (https://github.com/eliluminado/Guia-Tkinter/issues).

Saludos y nos estamos volviendo a ver dentro de poco.

El porque del nombre:
El nombre lo tome del nombre de la función implementada en JavaScript en la pagina de la AFIP para verificar la validez de una CUIT y como resulta muy intuitivo y fácil de recordar decidí utilizarlo y espero que esto no genere conflictos los programadores de la AFIP .

Gran parte del código son comentarios y reglas de validación.

El código mencionado es este:

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

# <Aplicacion en Python para verificar la valides de la CUIT.>
# Copyright (C) 2012 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>

def esCUITValida(cuit):
    """
    Funcion destinada a la validacion de CUIT
    """
    # Convertimos el valor a una cadena
    cuit = str(cuit)
    # Aca removemos guiones, espacios y puntos para poder trabajar
    cuit = cuit.replace("-", "") # Borramos los guiones
    cuit = cuit.replace(" ", "") # Borramos los espacios
    cuit = cuit.replace(".", "") # Borramos los puntos
    # Si no tiene 11 caracteres lo descartamos
    if len(cuit) != 11:
        return False, cuit
    # Solo resta analizar si todos los caracteres son numeros
    if not cuit.isdigit():
        return False, cuit
    # Despues de estas validaciones podemos afirmar
    #   que contamos con 11 numeros
    # Aca comienza la magia
    base = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
    aux = 0
    for i in xrange(10):
        aux += int(cuit[i]) * base[i]
    aux = 11 - (aux % 11)
    if aux == 11:
        aux = 0
    elif aux == 10:
        aux = 9
    if int(cuit[10]) == aux:
        return True, cuit
    else:
        return False, cuit

if __name__ == "__main__":
    while True:
        print "Para salir ingrese 'Salir'"
        cuit = raw_input('Ingrese la CUIT:\t')
        if cuit == 'Salir' or cuit == 'salir':
            break
        demo = esCUITValida(cuit)
        if not demo[0]:
            print demo[1], "No parece ser un CUIT valido, por favor vuelva a ingresarlo"
        else:
            print demo[1], "Es un numero de CUIT valido"
            break

Pueden encontrar la ultima versión desde el repositorio de la aplicación:
https://github.com/eliluminado/esCUITValida
Licencia:
Esta aplicación esta licenciada bajo licencia GNU GPL v3

Saludos.

Me despido y nos veremos cuando haya nuevos avances en la guía.

La guía como les había comentado en “http://www.codigopython.com.ar/?p=214” va ir siendo almacenada en los servidores de GitHub en sus repositorios Git como si se tratara del desarrollo de una aplicación, en ellos iré subiendo periódicamente los cambios y avances que vaya realizando. Para descargar una copia de la guía y todos los archivos que la complementan así como las imágenes, las podemos obtener haciendo click en el siguiente enlace en donde se generara un archivo .zip donde estarán contenidos los archivos mencionados

https://github.com/eliluminado/Guia-Tkinter/zipball/master

Otra forma un poco mas compleja pero mas útil es teniendo en nuestra PC instalado Git para así poder crear una copia del repositorio y con unas simples ordenes desde la consola actualizar los archivos a sus ultimas versiones. Para esto deberán tener como mencione instalado Git (Pueden encontrar varias guías de instalación en la web) y desde la consola escribir los siguiente:

git clone git://github.com/eliluminado/Guia-Tkinter.git DIRECTORIO

Donde se tiene que reemplazar la palabra ‘DIRECTORIO’ por el nombre de la carpeta donde desean crear la copia de los archivos.

Con esto hecho ya obtendrán una copia de los archivos, para actualizarlos deberán escribir en la consola:

git pull

Cualquier duda que tengan pueden dejar su comentario aqui y se los respondere.

Saludos y nos estaremos viendo en otro post

Todos los que deseen colaborar o hacer sus comentarios pueden ponerse en contacto conmigo dando su comentario en este post o escribiéndome a:

contacto@codigopython.com.ar

Para consultar la guiá pueden hacerlo desde mi repositorio en GitHub y ver como va avanzando, si lo desean también pueden colaborar desde allí con su desarrollo.

https://github.com/eliluminado/Guia-Tkinter

Para los que desean colaborar van a notar que use varios símbolos y caracteres, esos caracteres sirven para proveer de un formato al texto y gracias a txt2tags luego poder convertir ese texto a a por ejemplo HTML. Los que estén interesados en colaborar pueden pasar por la pagina de txt2tags para buscar mas información sobre el tema

http://txt2tags.org

Me despido y los iré manteniendo al tanto de mis avances.

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

def hide(file):
    import os
    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):
    import os
    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)

Antes de comenzar a escribir nuestra función debemos plantear que es lo que deseamos conseguir y como lo venimos haciendo pasemos a enumerar las cosas que haremos para conseguir desarrollar esta pequeña pero útil función.

1 – Entra como parámetro un archivo
2 – Se verifica si el archivo se encuentra oculto

La primera parte se vuelve a repetir quedándonos de la misma forma pero ahora estará contenido dentro de ‘check‘

def check(file):
    import os
    if not os.path.exists(file):
        return

Ahora debemos ver si el archivo se encuentra o no oculto para retornar el mensaje que corresponda, para esto como ya habíamos visto debemos obtener el nombre del archivo de la siguiente forma:

archive = os.path.basename(file)

Y analizar si se encuentra oculto el archivo tal cual lo hicimos en ‘hide‘:

if archive[0] == '.':

Esta vez si retornaremos un mensaje para luego verificar su funcionamiento, el mensaje que retornara sera el siguiente “Se encuentra oculto” junto con el nombre del archivo que se analizo en este caso usando la variable ‘archive‘, todo esto nos quedaría de la siguiente forma:

if archive[0] == '.':
    return archive + " Se encuentra oculto"

Si la condición que analiza ese ‘if‘ no se cumple es porque el archivo no se encuentra oculto, para manejar esta segunda condición nos alcanza usando a ‘else‘ de la siguiente forma:

if archive[0] == '.':
    return archive + " Se encuentra oculto"
else:
    return archive + " No se encuentra oculto"

Ahora estamos en condiciones de probarlo, para esta tarea podemos usar tanto Ninja-IDE como a IDLE, como seguramente ustedes ya tienen instalado a IDLE en su sistema lo usare para este ejemplo.

Primero lo mas básico de todo abrimos IDLE, una vez abierto vamos a “File” que se encuentra en la barra de menú superior y en el hacemos click en “Open…” y buscamos y abrimos el archivo donde tengamos nuestra función “check“, en caso de que no lo tuviésemos contenido dentro de un archivo lo podemos crear haciendo click en “New Window” en el menú “File” y este nos abrirá el editor donde podremos empezar a escribir nuestra función “check“. Una vez abierto o creado el archivo estaremos dentro del editor de IDLE, cabe destacar que siempre tendremos dos ventanas abiertas una con el editor o otra con la shell de Python, ahora que estamos en el editor necesitamos ejecutar nuestra aplicación para esto es tan simple con ir al menú “Run” y hacer click en “Run Module” o simplemente usando el atajo que nos facilita este editor apretando la tecla F5 de nuestro teclado conseguiremos ejecutar nuestra aplicación o guion dentro de la shell que les habia mencionado. Ahora dentro de la shell podremos ejecutar la función ‘check‘ simplemente escribiendo lo siguiente:

check()

Y su salida sera la siguiente:

>>> check()

Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    check()
TypeError: check() takes exactly 1 argument (0 given)
>>>

Ese mensaje de error al ejecutar la función nos indica que la función requiere de un argumento para poder funcionar que es nada menos que el archivo que deseamos analizar, para este ejemplo podemos crear dos archivos ubicados en la misma carpeta, una que este oculto y el otro no debe estarlo, en mi caso quedaría algo así:

/home/alejandro/.codigopython
/home/alejandro/codigopython

Dentro de la shell podemos asignar a estos dos archivos a dos variables para poder utilizarlas en la función ‘check‘ o podemos también usarlos sin tener que asignarlos a dos variables, empecemos con el primer archivo ‘.codigopython‘ este se encuentra oculto y nuestra función debería distinguirlo pero para saberlo ejecutemos a ‘check‘ con ‘/home/alejandro/.codigopython‘ como argumento:

>>> check("/home/alejandro/.codigopython")
'.codigopython Se encuentra oculto'
>>>

Como vemos paso la primer prueba ahora solo nos resta ver si identifica de forma correcta cuando el archivo no se encuentra oculto, para esto hacemos lo mismo que antes pero con el otro archivo

>>> check("/home/alejandro/codigopython")
'codigopython No se encuentra oculto'
>>>

Paso las dos pruebas que nos habíamos propuesto desde un principio y ademas podemos intentar para un archivo inexistente como argumento para corroborar que retorne el mensaje que le indicamos

>>> check(/home/alejandro/codigo_python)
'El archivo no existe'
>>>

Hoy hemos conseguido no solo crear a ‘check‘ sino que ademas la hemos probado en IDLE y con esto doy por finalizado el tutorial numero tres.

Unos links que pueden ser útiles

IDLE:
http://docs.python.org/library/idle.html

Ninja-IDE:
http://ninja-ide.org/

Seguí este post también en

Snipplr.com

Taringa

Si ves que este post merece alguna modificación sentite libre de hacerlo a través de nuestra Wiki siguiendo el siguiente enlace:

http://wiki.codigopython.com.ar/pyhide:analizando-el-estado-de-los-archivos

Nota:
Hago una aclaración para los que siguen esta serie de tutoriales, quizás se pregunten porque en todas las funciones llamo al modulo ‘os‘, esto es porque no tomo a las funciones como si estuvieran contenidas dentro del mismo script, pero es una practica que solo uso para mostrar la construcción de las funciones.