Clase Base

Clase Base o también conocida como Clase abstracta le permite definir una clase que puede heredarse en otras clases los atributos y comportamientos definido en esta.

Clase base o abstracta

Use el diagrama anterior para ilustrar el concepto de la herencia, vea el caso de dos clases que tiene algo en común, ambas son personas, con atributos de datos personales y comportamiento típicos como hablar, comer, caminar, entonces para eso se crea una clase base llamada Persona. A continuación un ejemplo de la clase Persona con un método interno:

class Persona(object):
    """Clase que representa una Persona"""

    def __init__(self, cedula, nombre, apellido, sexo):
        """Constructor de clase Persona"""
        self.cedula = cedula
        self.nombre = nombre
        self.apellido = apellido
        self.sexo = sexo

    def __str__(self):
        """Devuelve una cadena representativa de Persona"""
        return "%s: %s, %s %s, %s." % (
            self.__doc__[25:34], str(self.cedula), self.nombre, 
            self.apellido, self.getGenero(self.sexo))

    def hablar(self, mensaje):
        """Mostrar mensaje de saludo de Persona"""
        return mensaje

    def getGenero(self, sexo):
        """Mostrar el genero de la Persona"""
        genero = ('Masculino','Femenino')
        if sexo == "M":
            return genero[0]
        elif sexo == "F":
            return genero[1]
        else:
            return "Desconocido"

En el ejemplo previo, es donde empieza a crear una clase (lo hace con la palabra class). La segunda palabra Persona es el nombre de la clase. La tercera palabra que se encuentra dentro de los paréntesis este hace referencia al objeto object, usando para indicar la clase de la cual precede.

La clase Persona tiene los métodos __init__, __str__, hablar y getGenero. Sus atributos son cedula, nombre, apellido y sexo.

La instancia de dos nuevos objetos Persona seria de la siguiente forma:

persona1 = Persona("V-13458796", "Leonardo", "Caballero", "M")
persona2 = Persona("V-23569874", "Ana", "Poleo", "F")

El método constructor __init__ es un método especial el cual debe escribir como: MiClase(parámetros iniciales si hay cualquiera).

Usted puede llamar esos métodos y atributos con la siguiente notación: claseinstancia.metodo o claseinstancia.atributo.

>>> print persona1.nombre, persona1.apellido
>>> print persona1.getGenero(persona1.sexo)

El método __str__ es un método usando para imprimir la descripción de la instancia de objeto el cual debe mostrar como:

print "\n" + str(persona1) + "\n"

En el anterior código se usan para cierto formato para imprimir la instancia de objeto usando la sentencia print, concatenando el carácter \n para generar un salto de página y seguidamente convertir a formato cadena de caracteres usando la función str() a la instancia de objeto llamada persona2.

Herencia simple

La herencia simple se apoya en el uso de clases base para compartir sus atributos y comportamientos con otros clases derivadas como los siguiente ejemplos el objeto Supervisor y el objeto Obrero.

Diagrama de herencia de Objetos

El siguiente es un ejemplo de la clase Supervisor que derivada de la clase Persona con función interna:

class Supervisor(Persona):
    """Clase que representa a un Supervisor"""

    def __init__(self, cedula, nombre, apellido, sexo, rol):
        """Constructor de clase Supervisor"""

        # Invoca al constructor de clase Persona
        Persona.__init__(self, cedula, nombre, apellido, sexo)

        # Nuevos atributos
        self.rol = rol
        self.tareas = ['10','11','12','13']

    def __str__(self):
        """Devuelve una cadena representativa al Supervisor"""
        return "%s: %s %s, rol: '%s', sus tareas: %s." % (
            self.__doc__[26:37], self.nombre, self.apellido, 
            self.rol, self.consulta_tareas())

    def consulta_tareas(self):
        """Mostrar las tareas del Supervisor"""
        return ', '.join(self.tareas)

Ahora, se creará una nueva clase Supervisor con los mismos métodos y atributos como la clase Persona, pero con dos nuevos atributos rol y tareas. No se copia la clase previa, pero si se hereda de ella.

La instancia del nuevo objeto Supervisor seria de la siguiente forma:

supervisor1 = Supervisor("V-16987456", "Jen", "Paz", "D", "Chivo")

Luego que generá la instancia del nuevo objeto Supervisor llamada supervisor1 se puede imprimir sus detalles de la siguiente forma:

print "\n" + str(supervisor1) + "\n"

Como la instancia de objeto supervisor1 hereda los atributo(s) y método(s) de la clase Persona usted puede reusarlo y llamarlo de la siguiente forma:

print "- Cedula de identidad: {0}.".format(supervisor1.cedula)
print "- Nombre completo: {0} {1}.".format(
	supervisor1.nombre, supervisor1.apellido)
print "- Genero: {0}.".format(
	supervisor1.getGenero(supervisor1.sexo))
print "- {0} {1} dijo: {2}".format(
	supervisor1.nombre, supervisor1.apellido, 
	supervisor1.hablar("A trabajar Leonardo!!!".upper()))

Si desea usar los atributo(s) y método(s) heredados de la clase Supervisor se puede imprimir de la siguiente forma:

print "- Rol: {0}.".format(supervisor1.rol)
print "- N. Tareas: {0}.".format(supervisor1.consulta_tareas())

El uso de las clases y la programación orientada a objetos, le permite a usted que pueda organizar el código con diferentes clases correspondientes a diferentes objetos que encontrará (una clase Persona, una clase Carro, una clase Departamento, etc.), con sus propios métodos y atributos. Luego puede usar la herencia para considerar las variaciones en torno a una clase base y reutilizar el código. Ej.: a partir de una clase base de Persona, usted puede crear clases derivadas como Supervisor, JefeCuadrilla, Obrero, etc.

print """\nHola, Soy el {0} {1} {2}, mi cédula es '{3}', 
mi genero '{4}', con el rol '{5}' y mis tareas
asignadas '{6}'.""".format(
    supervisor1.__doc__[26:37].lower(),
    supervisor1.nombre, supervisor1.apellido, supervisor1.cedula, 
    supervisor1.getGenero(supervisor1.sexo), supervisor1.rol,
    supervisor1.consulta_tareas())

Herencia múltiple

A diferencia de lenguajes como Java y C#, el lenguaje Python permite la herencia múltiple, es decir, se puede heredar de múltiples clases.

La herencia múltiple es la capacidad de una subclase de heredar de múltiples súper clases.

Esto conlleva un problema, y es que si varias súper clases tienen los mismos atributos o métodos, la subclase sólo podrá heredar de una de ellas.

En estos casos Python dará prioridad a las clases más a la izquierda en el momento de la declaración de la subclase:

class Destreza(object):
    """Clase la cual representa la Destreza de la Persona"""

    def __init__(self, area, herramienta, experiencia):
        """Constructor de clase Destreza"""
        self.area = area
        self.herramienta = herramienta
        self.experiencia = experiencia

    def __str__(self):
        """Devuelve una cadena representativa de la Destreza"""
        return """Destreza en el área %s con la herramienta %s, 
        tiene %s años de experiencia.""" % (
            str(self.area), self.experiencia, self.herramienta)


class JefeCuadrilla(Supervisor, Destreza):
    """Clase la cual representa al Jefe de Cuadrilla"""

    def __init__(self, cedula, nombre, apellido, sexo, 
        rol, area, herramienta, experiencia, cuadrilla):
        """Constructor de clase Jefe de Cuadrilla"""

        # Invoca al constructor de clase Supervisor
        Supervisor.__init__(self, cedula, nombre, apellido, sexo, 
            rol)
        # Invoca al constructor de clase Destreza
        Destreza.__init__(self, area, herramienta, experiencia)

        # Nuevos atributos
        self.cuadrilla = cuadrilla

    def __str__(self):
        """Devuelve cadena representativa al Jefe de Cuadrilla"""
        jq = "{0}: {1} {2}, rol '{3}', tareas {4}, cuadrilla: {5}"
        return jq.format(
            self.__doc__[28:46], self.nombre, self.apellido, 
            self.rol, self.consulta_tareas(), self.cuadrilla)

>>> JefeCuadrilla.__mro__
(<class '__main__.JefeCuadrilla'>,
<class '__main__.Supervisor'>,
<class '__main__.Persona'>,
<class '__main__.Destreza'>,
<type 'object'>)

>>> Supervisor.__mro__
(<class '__main__.Supervisor'>,
<class '__main__.Persona'>,
<type 'object'>)

>>> Destreza.__mro__
(<class '__main__.Destreza'>,
<type 'object'>)

POO en Python

El mecanismo de clases de Python agrega clases al lenguaje con un mínimo de nuevas sintaxis y semánticas.

En Python las clases es una mezcla de los mecanismos de clase encontrados en C++ y Modula-3.

Como es cierto para los módulos, las clases en Python no ponen una barrera absoluta entre la definición y el usuario, sino que más bien se apoya en la cortesía del usuario de no «forzar la definición».

Sin embargo, se mantiene el poder completo de las características más importantes de las clases: el mecanismo de la herencia de clases permite múltiples clases base, una clase derivada puede sobrescribir cualquier método de su(s) clase(s) base, y un método puede llamar al método de la clase base con el mismo nombre.

«Los objetos pueden tener una cantidad arbitraria de datos.»

En terminología de C++, todos los miembros de las clases (incluyendo los miembros de datos), son públicos, y todas las funciones miembro son virtuales.

Como en Modula-3, no hay atajos para hacer referencia a los miembros del objeto desde sus métodos: la función método se declara con un primer argumento explícito que representa al objeto, el cual se provee implícitamente por la llamada.

Como en Smalltalk, las clases mismas son objetos. Esto provee una semántica para importar y renombrar.

A diferencia de C++ y Modula-3, los tipos de datos integrados pueden usarse como clases base para que el usuario los extienda.

También, como en C++ pero a diferencia de Modula-3, la mayoría de los operadores integrados con sintaxis especial (operadores aritméticos, de subíndice, etc.) pueden ser redefinidos por instancias de la clase.

(Sin haber una terminología universalmente aceptada sobre clases, haré uso ocasional de términos de Smalltalk y C++. Usaría términos de Modula-3, ya que su semántica orientada a objetos es más cercana a Python que C++, pero no espero que muchos lectores hayan escuchado hablar de él).

Algunas particularidades de POO en Python son las siguientes:

• Todo es un objeto, incluyendo los tipos y clases.
• Permite herencia múltiple.
• No existen métodos ni atributos privados.
• Los atributos pueden ser modificados directamente.
• Permite «monkey patching».
• Permite «duck typing».
• Permite la sobrecarga de operadores.
• Permite la creación de nuevos tipos de datos.

A continuación se procede a definir algunos conceptos necesarios para entender la POO:

Objetos

Los objetos son abstracción de Python para data. Toda la data en un programa Python es representado por objectos o por relaciones entre objectos. (En cierto sentido, y en el código modelo de Von Neumann de una «computadora almacenada del programa» también es un código representado por los objetos.)

Cada objeto tiene una identidad, un tipo y un valor. Una identidad de objecto nunca cambia una vez es creada; usted puede pensar eso como la dirección de objeto en memoria. El operador in compara la identidad de dos objetos; la función id() devuelve un número entero representando la identidad (actualmente implementado como su dirección).

El tipo de un objeto también es inmutable. El tipo de un objeto determina las operaciones que admite el objeto (por ejemplo, «¿tiene una longitud?») Y también define los valores posibles para los objetos de ese tipo. La función «type()» devuelve el tipo de un objeto (que es un objeto en sí mismo). El valor *de algunos objetos puede cambiar. Se dice que los objetos cuyo valor puede cambiar son *mutables; los objetos cuyo valor no se puede cambiar una vez que se crean se llaman immutable. (El valor de un objeto contenedor inmutable que contiene una referencia a un objeto mutable puede cambiar cuando se cambia el valor de este último; sin embargo, el contenedor todavía se considera inmutable, porque la colección de objetos que contiene no se puede cambiar. Por lo tanto, la inmutabilidad no es estrictamente lo mismo que tener un valor incambiable, es más sutil.) La mutabilidad de un objeto está determinada por su tipo; por ejemplo, los números, las cadenas y las tuplas son inmutables, mientras que los diccionarios y las listas son mutables.

Los objetos son la clave para entender la POO. Si mira a nuestro alrededor encontrará un sin fin de objetos de la vida real: perro, escritorio, televisor, bicicleta, etc…

En Python puede definir una clase con la palabra reservada class, de la siguiente forma:

class Persona:
    pass

En el ejemplo anterior, el nombre de la clase es Persona y dentro del bloque de código usa la sentencia pass. Aunque no es requerido por el intérprete, los nombres de las clases se escriben por convención capitalizadas. Las clases pueden (y siempre deberían) tener comentarios.

Los atributos o propiedades de los objetos son las características que puede tener un objeto, como el color. Si el objeto es Persona, los atributos podrían ser: cedula, nombre, apellido, sexo, etc…

Los atributos describen el estado de un objeto. Pueden ser de cualquier tipo de dato.

class Persona:
    """Clase que representa una Persona"""
    cedula = "V-13458796"
    nombre = "Leonardo"
    apellido = "Caballero"
    sexo = "M"

Usted puede probar el código anterior, si lo transcribe en el consola interactiva Python como lo siguiente:

>>> class Persona:
...     """Clase que representa una Persona"""
...     cedula = "V-13458796"
...     nombre = "Leonardo"
...     apellido = "Caballero"
...     sexo = "M"
...
>>> macagua = Persona
>>> type(macagua)
<type 'classobj'>
>>> dir(macagua)
['__doc__', '__module__', 'apellido', 'cedula', 'nombre', 'sexo']
>>> macagua.cedula
'V-13458796'
>>> macagua.nombre
'Leonardo'
>>> macagua.apellido
'Caballero'
>>> macagua.sexo
'M'
>>> print "El objeto de la clase " + macagua.__name__ +"," \
... + macagua.__doc__ + "."
El objeto de la clase Persona, Clase que representa una Persona.
>>> print "Hola, mucho gusto, mi nombre es '"+ \
... macagua.nombre +" "+ \
... macagua.apellido +"', \nmi cédula de identidad es '"+  \
... macagua.cedula +"', y mi sexo es '"+  \
... macagua.sexo +"'."
Hola, mucho gusto, mi nombre es 'Leonardo Caballero',
mi cédula de identidad es 'V-13458796', y mi sexo es 'M'.

Si el nombre de un atributo esta encerrado entre dobles guiones bajos son atributos especiales.

• __name__, describe el nombre del objeto o del método.

>>> macagua.__name__
'Persona'

• __doc__, contiene la documentación de un módulo, una clase, o método especifico, escrita en el formato docstrings.

>>> macagua.__doc__
'Clase que representa una Persona'

Si el nombre de un atributo esta con dobles guiones bajos al principio son atributos «escondidos». A continuación un pseudo código que ilustra un ejemplo:

>>> ms_windows.__privado
'True'

>>> ms_windows.codigo_fuente.__no_tocar
'True'

En la sección encapsulación se describe esto a más profundidad.

Métodos

Los métodos describen el comportamiento de los objetos de una clase. Estos representan las operaciones que se pueden realizar con los objetos de la clase,

La ejecución de un método puede conducir a cambiar el estado del objeto.

Se definen de la misma forma que las funciones normales pero deben declararse dentro de la clase y su primer argumento siempre referencia a la instancia que la llama, de esta forma se afirma que los métodos son funciones, adjuntadas a objectos.

Si el objeto es Persona, los métodos pueden ser: hablar, caminar, comer, dormir, etc.

class Persona:
    """Clase que representa una Persona"""
    cedula = "V-13458796"
    nombre = "Leonardo"
    apellido = "Caballero"
    sexo = "M"
    
    def hablar(self, mensaje):
        """Mostrar mensaje de saludo de Persona"""
        return mensaje

La única diferencia sintáctica entre la definición de un método y la definición de una función es que el primer parámetro del método por convención debe ser el nombre self.

Usted puede probar el código anterior, si lo transcribe en el consola interactiva Python como lo siguiente:

>>> class Persona:
...     """Clase que representa una Persona"""
...     cedula = "V-13458796"
...     nombre = "Leonardo"
...     apellido = "Caballero"
...     sexo = "M"
...
...     def hablar(self, mensaje):
...         """Mostrar mensaje de saludo de Persona"""
...         return mensaje
...
>>>
>>> macagua = Persona
>>> Persona().hablar("Hola, soy la clase {0}.".format(
...     macagua.__name__))
'Hola, soy la clase Persona.'
>>> type(Persona().hablar)
<type 'instancemethod'>
>>> Persona().hablar.__doc__
'Mostrar mensaje de saludo de Persona'

Si crea una instancia de objeto para la clase Persona e intenta llamar al método hablar() esto lanzara una excepción TypeError, como sucede a continuación:

>>> macagua = Persona
>>> macagua.hablar("Hola Plone")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unbound method hablar() must be called with Persona instance as first argument (got str instance instead)

    def __str__(self):
        """Devuelve una cadena representativa de Persona"""
        return "%s: %s, %s %s, %s." % (
            self.__doc__[25:34], str(self.cedula), self.nombre, 
            self.apellido, self.getGenero(self.sexo))

class <Clase>(object):
    ...
    ...
    @classmethod
    def <metodo>(cls, <argumentos>):
        ...
        ...

class <Clase>(object):
    ...
    ...
    @staticmethod
    def <metodo>(<argumentos>):
        ...
        ...

Las clases definen las características del objeto.

Con todos los conceptos anteriores explicados, se puede decir que una clase es una plantilla genérica de un objeto. La clase proporciona variables iniciales de estado (donde se guardan los atributos) e implementaciones de comportamiento (métodos) necesarias para crear nuevos objetos, son los modelos sobre los cuáles serán construidos.

Instancias

Ya sabe que una clase es una estructura general del objeto. Por ejemplo, puede decir que la clase Persona necesita tener una cedula, un nombre, un apellido y una sexo, pero no va a decir cual es cedula, nombre, apellido y sexo, es aquí donde entran las instancias.

Una instancia es una copia específica de la clase con todo su contenido. Por ejemplo:

>>> persona1 = Persona("V-13458796", "Leonardo", "Caballero", "M")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: this constructor takes no arguments

La excepción TypeError indica que el método constructor no toma argumentos, esto se debe a que la momento de definir la clase a cada atributo se le asigno un valor (tipo de dato).

Usted puede definir el metodo constructor de la clase usando el método __init__().

    def __init__(self, cedula, nombre, apellido, sexo):
        """Constructor de clase Persona"""
        self.cedula = cedula
        self.nombre = nombre
        self.apellido = apellido
        self.sexo = sexo

Errores de sintaxis

Los errores de sintaxis, también conocidos como errores de interpretación, son quizás el tipo de queja más común que tenés cuando todavía estás aprendiendo Python:

>>> while True print 'Hola Mundo'
Traceback (most recent call last):
...
    while True print 'Hola Mundo'
                   ^
SyntaxError: invalid syntax

El intérprete repite la línea culpable y muestra una pequeña “flecha” que apunta al primer lugar donde se detectó el error. Este es causado por (o al menos detectado en) el símbolo que precede a la flecha: en el ejemplo, el error se detecta en la sentencia print, ya que faltan dos puntos (':') antes del mismo. Se muestran el nombre del archivo y el número de línea para que sepas dónde mirar en caso de que la entrada venga de un programa.

Excepciones

Incluso si la sentencia o expresión es sintácticamente correcta, puede generar un error cuando se intenta ejecutarla. Los errores detectados durante la ejecución se llaman excepciones, y no son incondicionalmente fatales: pronto aprenderás cómo manejarlos en los programas en Python. Sin embargo, la mayoría de las excepciones no son manejadas por los programas, y resultan en mensajes de error como los mostrados aquí:

>>> 10 * (1/0)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ZeroDivisionError: integer division or modulo by zero
>>> 4 + spam*3
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: cannot concatenate 'str' and 'int' objects

La última línea de los mensajes de error indica qué sucedió. Las excepciones vienen de distintos tipos, y el tipo se imprime como parte del mensaje: los tipos en el ejemplo son: ZeroDivisionError, NameError y TypeError.

La cadena mostrada como tipo de la excepción es el nombre de la excepción predefinida que ocurrió. Esto es verdad para todas las excepciones predefinidas del intérprete, pero no necesita ser verdad para excepciones definidas por el usuario (aunque es una convención útil). Los nombres de las excepciones estándar son identificadores incorporados al intérprete (no son palabras clave reservadas).

El resto de la línea provee un detalle basado en el tipo de la excepción y qué la causó.

La parte anterior del mensaje de error muestra el contexto donde la excepción sucedió, en la forma de un trazado del error listando líneas fuente; sin embargo, no mostrará líneas leídas desde la entrada estándar.

Excepciones integradas, es una lista las excepciones predefinidas y sus significados.

Manejando excepciones

Es posible escribir programas que manejen determinadas excepciones. Mirá el siguiente ejemplo, que le pide al usuario una entrada hasta que ingrese un entero válido, pero permite al usuario interrumpir el programa (usando Control-C o lo que sea que el sistema operativo soporte); notá que una interrupción generada por el usuario se señaliza generando la excepción KeyboardInterrupt.

>>> while True:
...     try:
...         x = int(raw_input(u"Por favor ingrese un número: "))
...         break
...     except ValueError:
...         print u"Oops!  No era válido. Intente nuevamente..."
...

La sentencia try funciona de la siguiente manera:

• Primero, se ejecuta el bloque try (el código entre las sentencias try y except).
• Si no ocurre ninguna excepción, el bloque except se saltea y termina la ejecución de la sentencia try.
• Si ocurre una excepción durante la ejecución del bloque try, el resto del bloque se saltea. Luego, si su tipo coincide con la excepción nombrada luego de la palabra reservada except, se ejecuta el bloque except, y la ejecución continúa luego de la sentencia try.
• Si ocurre una excepción que no coincide con la excepción nombrada en el except, esta se pasa a declaraciones try de más afuera; si no se encuentra nada que la maneje, es una excepción no manejada, y la ejecución se frena con un mensaje como los mostrados arriba.

Una sentencia try puede tener más de un except, para especificar manejadores para distintas excepciones. A lo sumo un manejador será ejecutado. Sólo se manejan excepciones que ocurren en el correspondiente try, no en otros manejadores del mismo try. Un except puede nombrar múltiples excepciones usando paréntesis, por ejemplo:

... except (RuntimeError, TypeError, NameError):
...     pass

El último except puede omitir nombrar qué excepción captura, para servir como comodín. Usá esto con extremo cuidado, ya que de esta manera es fácil ocultar un error real de programación. También puede usarse para mostrar un mensaje de error y luego re-generar la excepción (permitiéndole al que llama, manejar también la excepción):

import sys

try:
    f = open('numeros.txt')
    s = f.readline()
    i = int(s.strip())
except IOError as (errno, strerror):
    print "Error E/S ({0}): {1}".format(errno, strerror)
except ValueError:
    print "No pude convertir el dato a un entero."
except:
    print "Error inesperado:", sys.exc_info()[0]
    raise

Las declaraciones try … except tienen un bloque else opcional, el cual, cuando está presente, debe seguir a los except. Es útil para aquel código que debe ejecutarse si el bloque try no genera una excepción. Por ejemplo:

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except IOError:
        print 'no pude abrir', arg
    else:
        print arg, 'tiene', len(f.readlines()), 'lineas'
        f.close()

El uso de else es mejor que agregar código adicional en el try porque evita capturar accidentalmente una excepción que no fue generada por el código que está protegido por la sentencia try … except.

Cuando ocurre una excepción, puede tener un valor asociado, también conocido como el argumento de la excepción. La presencia y el tipo de argumento depende del tipo de excepción.

El except puede especificar una variable luego del nombre (o tupla) de excepción(es). La variable se vincula a una instancia de excepción con los argumentos almacenados en instance.args. Por conveniencia, la instancia de excepción define __str__() para que se pueda mostrar los argumentos directamente, sin necesidad de hacer referencia a .args.

Uno también puede instanciar una excepción antes de generarla, y agregarle cualquier atributo que se desee:

>>> try:
...    raise Exception('carne', 'huevos')
... except Exception as inst:
...    print type(inst)     # la instancia de excepción
...    print inst.args      # argumentos guardados en .args
...    print inst           # __str__ permite imprimir args directamente
...    x, y = inst          # __getitem__ permite usar args directamente
...    print 'x =', x
...    print 'y =', y
...
<type 'exceptions.Exception'>
('carne', 'huevos')
('carne', 'huevos')
x = carne
y = huevos

Si una excepción tiene un argumento, este se imprime como la última parte (el “detalle”) del mensaje para las excepciones que no están manejadas.

Los manejadores de excepciones no manejan solamente las excepciones que ocurren en el bloque try, también manejan las excepciones que ocurren dentro de las funciones que se llaman (inclusive indirectamente) dentro del bloque try. Por ejemplo:

>>> def esto_falla():
...     x = 1/0
...
>>> try:
...     esto_falla()
... except ZeroDivisionError as detail:
...     print 'Manejando error en tiempo de ejecución:', detail
...
Manejando error en tiempo de ejecución: integer division or modulo by zero

Levantando excepciones

La sentencia raise permite al programador forzar a que ocurra una excepción específica. Por ejemplo:

>>> raise NameError('Hola')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: Hola

El único argumento a raise indica la excepción a generarse. Tiene que ser o una instancia de excepción, o una clase de excepción (una clase que hereda de Exception).

Si necesitás determinar cuando una excepción fue lanzada pero no querés manejarla, una forma simplificada de la sentencia raise te permite relanzarla:

>>> try:
...     raise NameError('Hola')
... except NameError:
...     print u'Ha sucedido una excepción!'
...     raise
...
Ha sucedido una excepción!
Traceback (most recent call last):
  File "<stdin>", line 2, in ?
NameError: Hola

Sentencia assert

La sentencia assert es una vía conveniente para insertar afirmaciones de depuración dentro de un programa:

La forma simple, «assert expression», es equivalente a:

if __debug__:
    if not expression: raise AssertionError

La forma extendida, «assert expression1, expression2», es equivalente a:

if __debug__:
    if not expression1: raise AssertionError(expression2)

Estas equivalencias suponen que __debug__ y la excepción «AssertionError» se refieren a las variables incorporadas con esos nombres. En la corriente implementación, la variable incorporada __debug__ es True en circunstancias normales, False cuando se solicita la optimización (opción del línea de comando -O). El generador de código actual no emite ningún código para una sentencia assert cuando se solicita la optimización en tiempo de compilación. Nota que no es necesario incluir el código fuente de la expresión que falló en el mensaje de error; se mostrará como parte del stack trace.

Asignaciones a __debug__ son ilegales. El valor para la variable integrada es determinada cuando el interprete inicia.

Excepciones definidas por el usuario

Los programas pueden nombrar sus propias excepciones creando una nueva clase excepción (mirá el apartado de Clases para más información sobre las clases de Python). Las excepciones, típicamente, deberán derivar de la clase Exception, directa o indirectamente. Por ejemplo:

>>> class MiError(Exception):
...     def __init__(self, valor):
...         self.valor = valor
...     def __str__(self):
...         return repr(self.valor)
...
>>> try:
...     raise MiError(2*2)
... except MiError as e:
...     print u'Ha ocurrido mi excepción, valor:', e.valor
...
Ocurrió mi excepción, valor: 4
>>> raise MiError('oops!')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
__main__.MiError: 'oops!'

En este ejemplo, el método __init__() de Exception fue sobrescrito. El nuevo comportamiento simplemente crea el atributo valor.

Esto reemplaza el comportamiento por defecto de crear el atributo args.

Las clases de Excepciones pueden ser definidas de la misma forma que cualquier otra clase, pero usualmente se mantienen simples, a menudo solo ofreciendo un número de atributos con información sobre el error que leerán los manejadores de la excepción. Al crear un módulo que puede lanzar varios errores distintos, una práctica común es crear una clase base para excepciones definidas en ese módulo y extenderla para crear clases excepciones específicas para distintas condiciones de error:

class Error(Exception):
    """Clase base para excepciones en el módulo."""
    pass

class EntradaError(Error):
    """Exception lanzada por errores en las entradas.

    Atributos:
        expresion -- expresión de entrada en la que ocurre el error
        mensaje -- explicación del error
    """

    def __init__(self, expresion, mensaje):
        self.expresion = expresion
        self.mensaje = mensaje

class TransicionError(Error):
    """Lanzada cuando una operación intenta una
       transición de estado no permitida.

    Atributos:
        previo -- estado al principio de la transición
        siguiente -- nuevo estado intentado
        mensaje -- explicación de porque la transición no esta permitida
    """
    def __init__(self, previo, siguiente, mensaje):
        self.previo = previo
        self.siguiente = siguiente
        self.mensaje = mensaje

La mayoría de las excepciones son definidas con nombres que terminan en «Error», similares a los nombres de las excepciones estándar.

Muchos módulos estándar definen sus propias excepciones para reportar errores que pueden ocurrir en funciones propias. Se puede encontrar más información sobre clases en el capítulo Clases.

Definiendo acciones de limpieza

La sentencia try tiene otra sentencia opcional que intenta definir acciones de limpieza que deben ser ejecutadas bajo ciertas circunstancias. Por ejemplo:

>>> try:
...     raise KeyboardInterrupt
... finally:
...     print 'Adiós, Mundo!'
...
Chau, Mundo!
KeyboardInterrupt
Traceback (most recent call last):
  File "<stdin>", line 2, in ?

Una sentencia finally siempre es ejecutada antes de salir de la sentencia try, ya sea que una excepción haya ocurrido o no. Cuando ocurre una excepción en la sentencia try y no fue manejada por una sentencia except (o ocurrió en una sentencia except o else), es relanzada luego de que se ejecuta la sentencia finally. La sentencia finally es también ejecutada «a la salida» cuando cualquier otra sentencia de la sentencia try es dejada vía break, continue or return. Un ejemplo más complicado (sentencias except y finally en la misma sentencia try):

>>> def dividir(x, y):
...     try:
...         resultado = x / y
...     except ZeroDivisionError:
...         print "¡división por cero!"
...     else:
...         print "el resultado es", resultado
...     finally:
...         print "ejecutando la clausula finally"
...
>>> dividir(2, 1)
el resultado es 2
ejecutando la clausula finally
>>> dividir(2, 0)
¡división por cero!
ejecutando la clausula finally
>>> divide("2", "1")
ejecutando la clausula finally
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'

Como puedes ver, la sentencia finally es ejecutada siempre. La excepción TypeError lanzada al dividir dos cadenas de caracteres no es manejado por la sentencia except y por lo tanto es relanzada luego de que se ejecuta la sentencia finally.

En aplicaciones reales, la sentencia finally es útil para liberar recursos externos (como archivos o conexiones de red), sin importar si el uso del recurso fue exitoso.

Acciones predefinidas de limpieza

Algunos objetos definen acciones de limpieza estándar que llevar a cabo cuando el objeto no es más necesitado, independientemente de que las operaciones sobre el objeto hayan sido exitosas o no. Mirá el siguiente ejemplo, que intenta abrir un archivo e imprimir su contenido en la pantalla.

for linea in open("numeros.txt"):
    print linea

El problema con este código es que deja el archivo abierto por un periodo de tiempo indeterminado luego de que termine de ejecutarse. Esto no es un problema en scripts simples, pero puede ser un problema en aplicaciones más grandes.

with open("numeros.txt") as f:
    for linea in f:
        print linea

Traceback

El Traceback o trazado inverso, es un listado de las funciones en curso de ejecución, presentadas cuando sucede un error en tiempo de ejecución. Es común que al trazado inverso también se le conozca como trazado de pila, porque lista las funciones en el orden en el cual son almacenadas en la pila de llamadas.

El módulo integrado traceback incorpora el comportamiento de Traceback o trazado inverso ya que extrae, formatea e imprime información acerca de trazado del stack de los errores y excepciones en Python.

>>> import traceback
>>> traceback.__doc__
'Extract, format and print information about Python stack traces.'
>>> help(traceback)

Módulo distutils

Permite «empacar» el código de un proyecto de software para ser redistribuido en otros proyectos Python.

Cada paquete empaquetado se puede distribuir en su propia pagina de proyecto y al mismo tiempo puede optar a publicar su proyecto en el Python Package Index (PyPI), con el cual si lo publica allí su proyecto estará a su alcance y sino de muchos mas programadores, ya que es un repositorio de software publico, solo con ejecutar el comando pip install <paquete> lo convierte en una herramienta tremendamente útil y probablemente sea una de las razones del éxito de Python entre los que empiezan a programar.

Módulo setuptools

El módulo setuptools, incorpora varias extensiones al módulo distutils para distribuciones de software grandes o complejas.

Estructura de proyecto

Para poder empaquetar un proyecto necesita como mínimo la estructura de archivos siguiente:

DIRECTORIO-DEL-PROYECTO
├── LICENSE
├── MANIFEST.in
├── README.txt
├── setup.py
└── NOMBRE-DEL-PAQUETE
     ├── __init__.py
     ├── ARCHIVO1.py
     ├── ARCHIVO2.py
     └── MODULO (OPCIONAL)
           ├── __init__.py
           └── MAS_ARCHIVOS.py

A continuación se detallan el significado y uso de la estructura de directorio anterior:

• DIRECTORIO-DEL-PROYECTO puede ser cualquiera, no afecta en absoluto, lo que cuenta es lo que hay dentro.

• NOMBRE-DEL-PAQUETE tiene que ser el nombre del paquete, si el nombre es tostadas_pipo, este directorio tiene que llamarse también tostadas_pipo. Y esto es así. Dentro estarán todos los archivos que forman la librería.

• LICENSE: es el archivo donde se define los términos de licencia usado en su proyecto. Es muy importate que cada paquete cargado a PyPI incluirle una copia de los términos de licencia. Esto le dice a los usuario quien instala el paquete los términos bajos los cuales pueden usarlo en su paquete. Para ayuda a seleccionar una licencia, consulte https://choosealicense.com/. Una vez tenga seleccionado una licencia abra el archivo LICENSE e ingrese el texto de la licencia. Por ejemplo, si usted elije la licencia GPL:

  License
  =======
  
  PACKAGE-NAME Copyright YEAR, PACKAGE-AUTHOR
  
  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 2 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, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  MA 02111-1307 USA.
  

• MANIFEST.in: es el archivo donde se define los criterios de inclusión y exclusión de archivos a su distribución de código fuente de su proyecto. Este archivo incluye la configuración del paquete como se indica a continuación:

include LICENSE
include *.txt *.in
include *.py
recursive-include tostadas_pipo *
global-exclude *.pyc *.pyo *~
prune build
prune dist

• README.txt: es el archivo donde se define la documentación general del paquete, este archivo es importante debido a que no solo es usado localmente en un copia descargada, sino como información usada el en sitio de PyPI. Entonces abra el archivo README.txt e ingrese el siguiente contenido. Usted puede personalizarlo como quiera:

  ==================
  NOMBRE-DEL-PAQUETE
  ==================
  
  Este es un ejemplo simple de un paquete Python.
  
  Usted puede usar para escribir este contenido la guía
  `Restructured Text (reST) and Sphinx CheatSheet <http://openalea.gforge.inria.fr/doc/openalea/doc/_build/html/source/sphinx/rest_syntax.html>`_.
  

• setup.py: es el archivo donde se define el paquete, el formato es el mismo para el módulo setuptools y para el módulo distutils. Lo puede ver a continuación. Este archivo incluye la configuración del paquete como se indica a continuación:

"""Instalador para el paquete "tostadas_pipo"."""

from setuptools import setup

long_description = (
    open('README.txt').read()
    + '\n' +
    open('LICENSE').read()
    + '\n')

setup(
    name="tostadas_pipo",
    version="0.1",
    description="Sistema Administrativo de Tostadas Pipo C.A.",
    long_description=long_description,
    # Get more https://pypi.org/pypi?%3Aaction=list_classifiers
    classifiers=[
        # ¿Cuan maduro esta este proyecto? Valores comunes son
        #   3 - Alpha
        #   4 - Beta
        #   5 - Production/Stable
        "Development Status :: 3 - Alpha",
        # Indique a quien va dirigido su proyecto
        "Environment :: Console",
        "Intended Audience :: Developers",
        "Topic :: Software Development :: Libraries",
        # Indique licencia usada (debe coincidir con el "license")
        "License :: OSI Approved :: GNU General Public License",
        # Indique versiones soportas, Python 2, Python 3 o ambos.
        "Programming Language :: Python",
        "Programming Language :: Python :: 2.7",
        "Operating System :: OS Independent",
    ],
    keywords="ejemplo instalador paquete tostadas_pipo",
    author="Leonardo J. Caballero G.",
    author_email="leonardocaballero@gmail.com",
    url="https://twitter/macagua",
    download_url="https://github.com/macagua/tostadas_pipo",
    license="GPL",
    platforms="Unix",
    packages=["tostadas_pipo", "tostadas_pipo/utilidades/"],
    include_package_data=True,
)

Entonces debe cree la siguiente estructura de directorios, ya hecha para seguir adelante:

distribucion/
├── LICENSE
├── MANIFEST.in
├── README.txt
├── setup.py
└── tostadas_pipo
    ├── __init__.py
    ├── principal.py
    └── utilidades
        ├── calculos.py
        ├── impuestos.py
        └── __init__.py

Construir dependencias

Para construir cualquier cosas requeridas para instalar el paquete, ejecutando el siguiente comando:

python ./setup.py -v build
running build
running build_py
creating build
creating build/lib.linux-x86_64-2.7
creating build/lib.linux-x86_64-2.7/tostadas_pipo
copying tostadas_pipo/__init__.py -> build/lib.linux-x86_64-2.7/tostadas_pipo
copying tostadas_pipo/principal.py -> build/lib.linux-x86_64-2.7/tostadas_pipo
creating build/lib.linux-x86_64-2.7/tostadas_pipo/utilidades
copying tostadas_pipo/utilidades/__init__.py -> build/lib.linux-x86_64-2.7/tostadas_pipo/utilidades
copying tostadas_pipo/utilidades/calculos.py -> build/lib.linux-x86_64-2.7/tostadas_pipo/utilidades
copying tostadas_pipo/utilidades/impuestos.py -> build/lib.linux-x86_64-2.7/tostadas_pipo/utilidades
not copying tostadas_pipo/principal.py (output up-to-date)
not copying tostadas_pipo/__init__.py (output up-to-date)

De esta forma al terminar la ejecución del comando previo debe tener creado un directorio llamado build e incluyendo el paquete tostadas_pipo construido con todo lo necesario para crear su distribución, como se muestra a continuación:

build/
└── lib.linux-x86_64-2.7
    └── tostadas_pipo
        ├── __init__.py
        ├── principal.py
        └── utilidades
            ├── calculos.py
            ├── impuestos.py
            └── __init__.py

De esta forma ya construyo el paquete tostadas_pipo y todas las cosas necesarias para crear su distribución de código fuente o binaria para su proyecto.

Crear paquete

Usted puede crear diversos tipos de formatos de instalación y distribución de sus paquetes Python, a continuación se describen los mas usados:

python ./setup.py -v sdist
running sdist
running egg_info
creating tostadas_pipo.egg-info
writing tostadas_pipo.egg-info/PKG-INFO
writing top-level names to tostadas_pipo.egg-info/top_level.txt
writing dependency_links to tostadas_pipo.egg-info/dependency_links.txt
writing entry points to tostadas_pipo.egg-info/entry_points.txt
writing manifest file 'tostadas_pipo.egg-info/SOURCES.txt'
reading manifest file 'tostadas_pipo.egg-info/SOURCES.txt'
reading manifest template 'MANIFEST.in'
warning: no previously-included files matching '*.pyc' found anywhere in distribution
warning: no previously-included files matching '*.pyo' found anywhere in distribution
warning: no previously-included files matching '*~' found anywhere in distribution
no previously-included directories found matching 'build'
no previously-included directories found matching 'dist'
writing manifest file 'tostadas_pipo.egg-info/SOURCES.txt'
running check
creating tostadas_pipo-0.1
creating tostadas_pipo-0.1/tostadas_pipo
creating tostadas_pipo-0.1/tostadas_pipo.egg-info
creating tostadas_pipo-0.1/tostadas_pipo/utilidades
copying files to tostadas_pipo-0.1...
copying LICENSE -> tostadas_pipo-0.1
copying MANIFEST.in -> tostadas_pipo-0.1
copying README.txt -> tostadas_pipo-0.1
copying setup.py -> tostadas_pipo-0.1
copying tostadas_pipo/__init__.py -> tostadas_pipo-0.1/tostadas_pipo
copying tostadas_pipo/principal.py -> tostadas_pipo-0.1/tostadas_pipo
copying tostadas_pipo.egg-info/PKG-INFO -> tostadas_pipo-0.1/tostadas_pipo.egg-info
copying tostadas_pipo.egg-info/SOURCES.txt -> tostadas_pipo-0.1/tostadas_pipo.egg-info
copying tostadas_pipo.egg-info/dependency_links.txt -> tostadas_pipo-0.1/tostadas_pipo.egg-info
copying tostadas_pipo.egg-info/entry_points.txt -> tostadas_pipo-0.1/tostadas_pipo.egg-info
copying tostadas_pipo.egg-info/top_level.txt -> tostadas_pipo-0.1/tostadas_pipo.egg-info
copying tostadas_pipo/utilidades/__init__.py -> tostadas_pipo-0.1/tostadas_pipo/utilidades
copying tostadas_pipo/utilidades/calculos.py -> tostadas_pipo-0.1/tostadas_pipo/utilidades
copying tostadas_pipo/utilidades/impuestos.py -> tostadas_pipo-0.1/tostadas_pipo/utilidades
not copying tostadas_pipo.egg-info/SOURCES.txt (output up-to-date)
Reading configuration from tostadas_pipo-0.1/setup.cfg
Adding new section [egg_info] to tostadas_pipo-0.1/setup.cfg
Setting egg_info.tag_build to '' in tostadas_pipo-0.1/setup.cfg
Setting egg_info.tag_date to 0 in tostadas_pipo-0.1/setup.cfg
Writing tostadas_pipo-0.1/setup.cfg
creating dist
Creating tar archive
removing 'tostadas_pipo-0.1' (and everything under it)

dist/
└── tostadas_pipo-0.1.tar.gz

python ./setup.py sdist --formats=zip,gztar,bztar
running sdist
running egg_info
writing tostadas_pipo.egg-info/PKG-INFO
writing top-level names to tostadas_pipo.egg-info/top_level.txt
writing dependency_links to tostadas_pipo.egg-info/dependency_links.txt
writing entry points to tostadas_pipo.egg-info/entry_points.txt
reading manifest file 'tostadas_pipo.egg-info/SOURCES.txt'
reading manifest template 'MANIFEST.in'
warning: no previously-included files matching '*.pyc' found anywhere in distribution
warning: no previously-included files matching '*.pyo' found anywhere in distribution
warning: no previously-included files matching '*~' found anywhere in distribution
no previously-included directories found matching 'build'
no previously-included directories found matching 'dist'
writing manifest file 'tostadas_pipo.egg-info/SOURCES.txt'
running check
creating tostadas_pipo-0.1
creating tostadas_pipo-0.1/tostadas_pipo
creating tostadas_pipo-0.1/tostadas_pipo.egg-info
creating tostadas_pipo-0.1/tostadas_pipo/utilidades
copying files to tostadas_pipo-0.1...
copying LICENSE -> tostadas_pipo-0.1
copying MANIFEST.in -> tostadas_pipo-0.1
copying README.txt -> tostadas_pipo-0.1
copying setup.py -> tostadas_pipo-0.1
copying tostadas_pipo/__init__.py -> tostadas_pipo-0.1/tostadas_pipo
copying tostadas_pipo/principal.py -> tostadas_pipo-0.1/tostadas_pipo
copying tostadas_pipo.egg-info/PKG-INFO -> tostadas_pipo-0.1/tostadas_pipo.egg-info
copying tostadas_pipo.egg-info/SOURCES.txt -> tostadas_pipo-0.1/tostadas_pipo.egg-info
copying tostadas_pipo.egg-info/dependency_links.txt -> tostadas_pipo-0.1/tostadas_pipo.egg-info
copying tostadas_pipo.egg-info/entry_points.txt -> tostadas_pipo-0.1/tostadas_pipo.egg-info
copying tostadas_pipo.egg-info/top_level.txt -> tostadas_pipo-0.1/tostadas_pipo.egg-info
copying tostadas_pipo/utilidades/__init__.py -> tostadas_pipo-0.1/tostadas_pipo/utilidades
copying tostadas_pipo/utilidades/calculos.py -> tostadas_pipo-0.1/tostadas_pipo/utilidades
copying tostadas_pipo/utilidades/impuestos.py -> tostadas_pipo-0.1/tostadas_pipo/utilidades
Writing tostadas_pipo-0.1/setup.cfg
creating 'dist/tostadas_pipo-0.1.zip' and adding 'tostadas_pipo-0.1' to it
adding 'tostadas_pipo-0.1/MANIFEST.in'
adding 'tostadas_pipo-0.1/setup.cfg'
adding 'tostadas_pipo-0.1/PKG-INFO'
adding 'tostadas_pipo-0.1/LICENSE'
adding 'tostadas_pipo-0.1/README.txt'
adding 'tostadas_pipo-0.1/setup.py'
adding 'tostadas_pipo-0.1/tostadas_pipo/principal.py'
adding 'tostadas_pipo-0.1/tostadas_pipo/__init__.py'
adding 'tostadas_pipo-0.1/tostadas_pipo/utilidades/impuestos.py'
adding 'tostadas_pipo-0.1/tostadas_pipo/utilidades/__init__.py'
adding 'tostadas_pipo-0.1/tostadas_pipo/utilidades/calculos.py'
adding 'tostadas_pipo-0.1/tostadas_pipo.egg-info/dependency_links.txt'
adding 'tostadas_pipo-0.1/tostadas_pipo.egg-info/entry_points.txt'
adding 'tostadas_pipo-0.1/tostadas_pipo.egg-info/PKG-INFO'
adding 'tostadas_pipo-0.1/tostadas_pipo.egg-info/SOURCES.txt'
adding 'tostadas_pipo-0.1/tostadas_pipo.egg-info/top_level.txt'
Creating tar archive
Creating tar archive
removing 'tostadas_pipo-0.1' (and everything under it)

dist/
├── tostadas_pipo-0.1.tar.bz2
├── tostadas_pipo-0.1.tar.gz
└── tostadas_pipo-0.1.zip

python ./setup.py bdist_egg
running bdist_egg
running egg_info
writing tostadas_pipo.egg-info/PKG-INFO
writing top-level names to tostadas_pipo.egg-info/top_level.txt
writing dependency_links to tostadas_pipo.egg-info/dependency_links.txt
writing entry points to tostadas_pipo.egg-info/entry_points.txt
reading manifest file 'tostadas_pipo.egg-info/SOURCES.txt'
reading manifest template 'MANIFEST.in'
warning: no previously-included files matching '*.pyc' found anywhere in distribution
warning: no previously-included files matching '*.pyo' found anywhere in distribution
warning: no previously-included files matching '*~' found anywhere in distribution
no previously-included directories found matching 'build'
no previously-included directories found matching 'dist'
writing manifest file 'tostadas_pipo.egg-info/SOURCES.txt'
installing library code to build/bdist.linux-x86_64/egg
running install_lib
running build_py
creating build/bdist.linux-x86_64
creating build/bdist.linux-x86_64/egg
creating build/bdist.linux-x86_64/egg/tostadas_pipo
copying build/lib.linux-x86_64-2.7/tostadas_pipo/principal.py -> build/bdist.linux-x86_64/egg/tostadas_pipo
copying build/lib.linux-x86_64-2.7/tostadas_pipo/__init__.py -> build/bdist.linux-x86_64/egg/tostadas_pipo
creating build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades
copying build/lib.linux-x86_64-2.7/tostadas_pipo/utilidades/impuestos.py -> build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades
copying build/lib.linux-x86_64-2.7/tostadas_pipo/utilidades/__init__.py -> build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades
copying build/lib.linux-x86_64-2.7/tostadas_pipo/utilidades/calculos.py -> build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades
byte-compiling build/bdist.linux-x86_64/egg/tostadas_pipo/principal.py to principal.pyc
byte-compiling build/bdist.linux-x86_64/egg/tostadas_pipo/__init__.py to __init__.pyc
byte-compiling build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades/impuestos.py to impuestos.pyc
byte-compiling build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades/__init__.py to __init__.pyc
byte-compiling build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades/calculos.py to calculos.pyc
creating build/bdist.linux-x86_64/egg/EGG-INFO
copying tostadas_pipo.egg-info/PKG-INFO -> build/bdist.linux-x86_64/egg/EGG-INFO
copying tostadas_pipo.egg-info/SOURCES.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
copying tostadas_pipo.egg-info/dependency_links.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
copying tostadas_pipo.egg-info/entry_points.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
copying tostadas_pipo.egg-info/top_level.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
zip_safe flag not set; analyzing archive contents...
creating 'dist/tostadas_pipo-0.1-py2.7.egg' and adding 'build/bdist.linux-x86_64/egg' to it
removing 'build/bdist.linux-x86_64/egg' (and everything under it)

dist/
└── tostadas_pipo-0.1-py2.7.egg

python ./setup.py bdist_wheel
running bdist_wheel
running build
running build_py
installing to build/bdist.linux-x86_64/wheel
running install
running install_lib
creating build/bdist.linux-x86_64/wheel
creating build/bdist.linux-x86_64/wheel/tostadas_pipo
copying build/lib.linux-x86_64-2.7/tostadas_pipo/principal.py -> build/bdist.linux-x86_64/wheel/tostadas_pipo
copying build/lib.linux-x86_64-2.7/tostadas_pipo/__init__.py -> build/bdist.linux-x86_64/wheel/tostadas_pipo
creating build/bdist.linux-x86_64/wheel/tostadas_pipo/utilidades
copying build/lib.linux-x86_64-2.7/tostadas_pipo/utilidades/impuestos.py -> build/bdist.linux-x86_64/wheel/tostadas_pipo/utilidades
copying build/lib.linux-x86_64-2.7/tostadas_pipo/utilidades/__init__.py -> build/bdist.linux-x86_64/wheel/tostadas_pipo/utilidades
copying build/lib.linux-x86_64-2.7/tostadas_pipo/utilidades/calculos.py -> build/bdist.linux-x86_64/wheel/tostadas_pipo/utilidades
running install_egg_info
running egg_info
writing tostadas_pipo.egg-info/PKG-INFO
writing top-level names to tostadas_pipo.egg-info/top_level.txt
writing dependency_links to tostadas_pipo.egg-info/dependency_links.txt
writing entry points to tostadas_pipo.egg-info/entry_points.txt
reading manifest file 'tostadas_pipo.egg-info/SOURCES.txt'
reading manifest template 'MANIFEST.in'
warning: no previously-included files matching '*.pyc' found anywhere in distribution
warning: no previously-included files matching '*.pyo' found anywhere in distribution
warning: no previously-included files matching '*~' found anywhere in distribution
no previously-included directories found matching 'build'
no previously-included directories found matching 'dist'
writing manifest file 'tostadas_pipo.egg-info/SOURCES.txt'
Copying tostadas_pipo.egg-info to build/bdist.linux-x86_64/wheel/tostadas_pipo-0.1-py2.7.egg-info
running install_scripts
adding license file "LICENSE" (matched pattern "LICEN[CS]E*")
creating build/bdist.linux-x86_64/wheel/tostadas_pipo-0.1.dist-info/WHEEL
creating 'dist/tostadas_pipo-0.1-py2-none-any.whl' and adding 'build/bdist.linux-x86_64/wheel' to it
adding 'tostadas_pipo/__init__.py'
adding 'tostadas_pipo/principal.py'
adding 'tostadas_pipo/utilidades/__init__.py'
adding 'tostadas_pipo/utilidades/calculos.py'
adding 'tostadas_pipo/utilidades/impuestos.py'
adding 'tostadas_pipo-0.1.dist-info/LICENSE'
adding 'tostadas_pipo-0.1.dist-info/METADATA'
adding 'tostadas_pipo-0.1.dist-info/WHEEL'
adding 'tostadas_pipo-0.1.dist-info/entry_points.txt'
adding 'tostadas_pipo-0.1.dist-info/top_level.txt'
adding 'tostadas_pipo-0.1.dist-info/RECORD'
removing build/bdist.linux-x86_64/wheel

dist/
├── tostadas_pipo-0.1-py2.7.egg
└── tostadas_pipo-0.1-py2-none-any.whl

Instalar paquete

Para instalar el paquete de su proyecto, hay dos formas de instalación disponibles a continuación:

pip install --user dist/tostadas_pipo-0.1.tar.gz

pip
bash: pip: no se encontró la orden

sudo apt-get install -y python-pip

pip install --user dist/tostadas_pipo-0.1.tar.gz
Processing ./dist/tostadas_pipo-0.1.tar.gz
Building wheels for collected packages: tostadas-pipo
  Running setup.py bdist_wheel for tostadas-pipo ... done
  Stored in directory: /home/leonardo/.cache/pip/wheels/fd/f9/75/a6965566a3c5a8bff507d7daa30760caca0a7525a3de61eac2
Successfully built tostadas-pipo
Installing collected packages: tostadas-pipo
Successfully installed tostadas-pipo-0.1

pip install --user ./dist/tostadas_pipo-0.1-py2-none-any.whl
Processing ./dist/tostadas_pipo-0.1-py2-none-any.whl
Installing collected packages: tostadas-pipo
Successfully installed tostadas-pipo-0.1

python ./setup.py -v install --user
running install
running bdist_egg
running egg_info
writing tostadas_pipo.egg-info/PKG-INFO
writing top-level names to tostadas_pipo.egg-info/top_level.txt
writing dependency_links to tostadas_pipo.egg-info/dependency_links.txt
reading manifest file 'tostadas_pipo.egg-info/SOURCES.txt'
reading manifest template 'MANIFEST.in'
warning: no previously-included files matching '*.pyo' found anywhere in distribution
warning: no previously-included files matching '*~' found anywhere in distribution
no previously-included directories found matching 'build'
no previously-included directories found matching 'dist'
writing manifest file 'tostadas_pipo.egg-info/SOURCES.txt'
installing library code to build/bdist.linux-x86_64/egg
running install_lib
running build_py
not copying tostadas_pipo/principal.py (output up-to-date)
not copying tostadas_pipo/__init__.py (output up-to-date)
not copying tostadas_pipo/utilidades/impuestos.py (output up-to-date)
not copying tostadas_pipo/utilidades/__init__.py (output up-to-date)
not copying tostadas_pipo/utilidades/calculos.py (output up-to-date)
not copying tostadas_pipo/utilidades/__init__.py (output up-to-date)
not copying tostadas_pipo/utilidades/calculos.py (output up-to-date)
not copying tostadas_pipo/utilidades/impuestos.py (output up-to-date)
creating build/bdist.linux-x86_64
creating build/bdist.linux-x86_64/egg
creating build/bdist.linux-x86_64/egg/tostadas_pipo
copying build/lib.linux-x86_64-2.7/tostadas_pipo/principal.py -> build/bdist.linux-x86_64/egg/tostadas_pipo
copying build/lib.linux-x86_64-2.7/tostadas_pipo/__init__.py -> build/bdist.linux-x86_64/egg/tostadas_pipo
creating build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades
copying build/lib.linux-x86_64-2.7/tostadas_pipo/utilidades/impuestos.py -> build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades
copying build/lib.linux-x86_64-2.7/tostadas_pipo/utilidades/__init__.py -> build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades
copying build/lib.linux-x86_64-2.7/tostadas_pipo/utilidades/calculos.py -> build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades
byte-compiling build/bdist.linux-x86_64/egg/tostadas_pipo/principal.py to principal.pyc
byte-compiling build/bdist.linux-x86_64/egg/tostadas_pipo/__init__.py to __init__.pyc
byte-compiling build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades/impuestos.py to impuestos.pyc
byte-compiling build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades/__init__.py to __init__.pyc
byte-compiling build/bdist.linux-x86_64/egg/tostadas_pipo/utilidades/calculos.py to calculos.pyc
creating build/bdist.linux-x86_64/egg/EGG-INFO
copying tostadas_pipo.egg-info/PKG-INFO -> build/bdist.linux-x86_64/egg/EGG-INFO
copying tostadas_pipo.egg-info/SOURCES.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
copying tostadas_pipo.egg-info/dependency_links.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
copying tostadas_pipo.egg-info/top_level.txt -> build/bdist.linux-x86_64/egg/EGG-INFO
zip_safe flag not set; analyzing archive contents...
creating dist
creating 'dist/tostadas_pipo-0.1-py2.7.egg' and adding 'build/bdist.linux-x86_64/egg' to it
adding 'tostadas_pipo/principal.py'
adding 'tostadas_pipo/principal.pyc'
adding 'tostadas_pipo/__init__.pyc'
adding 'tostadas_pipo/__init__.py'
adding 'tostadas_pipo/utilidades/impuestos.pyc'
adding 'tostadas_pipo/utilidades/calculos.pyc'
adding 'tostadas_pipo/utilidades/impuestos.py'
adding 'tostadas_pipo/utilidades/__init__.pyc'
adding 'tostadas_pipo/utilidades/__init__.py'
adding 'tostadas_pipo/utilidades/calculos.py'
adding 'EGG-INFO/zip-safe'
adding 'EGG-INFO/dependency_links.txt'
adding 'EGG-INFO/PKG-INFO'
adding 'EGG-INFO/SOURCES.txt'
adding 'EGG-INFO/top_level.txt'
removing 'build/bdist.linux-x86_64/egg' (and everything under it)
Processing tostadas_pipo-0.1-py2.7.egg
Copying tostadas_pipo-0.1-py2.7.egg to /home/leonardo/.local/lib/python2.7/site-packages
Adding tostadas-pipo 0.1 to easy-install.pth file
Saving /home/leonardo/.local/lib/python2.7/site-packages/easy-install.pth

Installed /home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo-0.1-py2.7.egg
Processing dependencies for tostadas-pipo==0.1
Finished processing dependencies for tostadas-pipo==0.1

pip list --user --format=freeze | grep "tostadas"
tostadas-pipo==0.1

Usar paquete

Usar el paquete tostadas_pipo-0.1, recuerde que debe usarlo como una librería, entonces puede probar el correcto funcionamiento del paquete, importando este, ejecutando el siguiente comando:

python -c 'from tostadas_pipo.utilidades.impuestos import impuesto_iva14; print "Función importada " + impuesto_iva14.__doc__[1:36] + "."'
Función importada Calcula el impuesto del IVA de 14 %.

El comando previo muestra la docstring de la función importada impuesto_iva14 sino muestra ningún mensaje de error, el paquete tostadas_pipo-0.1 se instalo correctamente.

Eliminar paquete

Para eliminar paquete usando la herramienta pip, ejecute el siguiente comando:

pip uninstall tostadas_pipo
Uninstalling tostadas-pipo-0.1:
  /home/leonardo/.local/bin/tostadas_pipo
  /home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo-0.1.dist-info/DESCRIPTION.rst
  /home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo-0.1.dist-info/INSTALLER
  /home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo-0.1.dist-info/METADATA
  /home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo-0.1.dist-info/RECORD
  /home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo-0.1.dist-info/WHEEL
  /home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo-0.1.dist-info/metadata.json
  /home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo-0.1.dist-info/top_level.txt
  /home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo/__init__.py
  /home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo/__init__.pyc
  /home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo/principal.py
  /home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo/principal.pyc
  /home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo/utilidades/__init__.py
  /home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo/utilidades/__init__.pyc
  /home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo/utilidades/calculos.py
  /home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo/utilidades/calculos.pyc
  /home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo/utilidades/impuestos.py
  /home/leonardo/.local/lib/python2.7/site-packages/tostadas_pipo/utilidades/impuestos.pyc
Proceed (y/n)? y
  Successfully uninstalled tostadas-pipo-0.1

pip esta habilitado a desinstalar la mayoría de paquetes instalados. Las excepciones conocidas son:

• Los paquetes basado en solamente en el módulo distutils los cuales fueron instalados sin la herramienta pip usando el comando python setup.py install desde el código del paquete.

  Instalándolo de esta forma, al momento de desintalarlo usando el comando pip uninstall tostadas_pipo este comando removerá solo la metadata, no detrás dejando de la instalación metadata para determinar que archivos fueron instalados.

  Entonces para solventar este problema tiene que ir manualmente al directorio site-packages a eliminar manualmente el paquete que instalo.

  Advertencia

  Esta entrando a la cueva de los Dragones!!!

• Los scripts wrappers instalados ejecutando el comando python setup.py develop.

De esta forma ya tiene eliminado su paquete de forma manual de su sistema.

Sentencia from

La sentencia from se utiliza en conjunto a la previa sentencia import para importar un módulo.

>>> from utilidades import suma_total

Por ejemplo, cree un directorio llamado tostadas_pipo, que contiene los archivos llamados __init__.py, principal.py (dentro del mismo directorio).

• Archivo __init__.py, este archivo no tiene ningún contenido.
• Archivo principal.py incluye el siguiente código:

from utilidades import impuestos
from utilidades import calculos

monto = int(input("Introduzca un monto entero: "))
# Llama función definida en el módulo "impuestos"
print "El impuesto IVA de 12%:", impuestos.impuesto_iva12(monto)

suma = int(input("Introduzca un monto entero a sumar: "))
# Llama función definida en el módulo "calculos"
print "La suma total es:", calculos.suma_total(suma)

Seguidamente dentro del directorio tostadas_pipo, cree otro directorio llamado utilidades, dentro de este, cree los siguientes archivos:

• Archivo __init__.py, este archivo no tiene ningún contenido.
• Archivo calculos.py incluye el siguiente código:

""" Módulo para cálculos diversos """

def suma_total(monto=0):
    """ Calcula la suma total """
    calculo_suma = 20
    calculo_suma += monto
    return calculo_suma

• Archivo impuestos.py incluye el siguiente código:

""" Módulo para cálculos de diversos impuestos """

def impuesto_iva12(monto=0):
    """ Calcula el impuesto del IVA de 12 % """
    total = ((monto * 12)/100)
    return total


def impuesto_iva14(monto=0):
    """ Calcula el impuesto del IVA de 14 % """
    total = ((monto * 14)/100)
    return total

Al final tendrá la siguiente estructura del directorios del paquete Python llamado tostadas_pipo, como se describe a continuación:

tostadas_pipo/
├── __init__.py
├── principal.py
└── utilidades/
    ├── calculos.py
    ├── impuestos.py
    └── __init__.py

Entonces realizar importaciones desde una estructura de directorios mas completa se realiza de las siguientes formas:

• Importar todos los módulo el sub-paquete utilidades, ejecutando:

import tostadas_pipo.utilidades
from tostadas_pipo import utilidades
from tostadas_pipo.utilidades import *

• Importar el módulo calculos.py desde el sub-paquete utilidades, ejecutando:

from tostadas_pipo.utilidades import calculos

• Importar la función impuesto_iva14() desde el módulo impuestos.py en el sub-paquete utilidades, ejecutando:

from tostadas_pipo.utilidades.impuestos import impuesto_iva14

Por ejemplo, cree un módulo llamado calculo_factura_pipo.py, que contiene las importaciones del paquete tostadas_pipo:

• Archivo calculo_factura_pipo.py incluye el siguiente código:

from tostadas_pipo.utilidades import calculos
from tostadas_pipo.utilidades.impuestos import impuesto_iva14

monto = int(input("Introduzca un monto entero: "))
monto_suma = int(input("Introduzca un monto entero a sumar: "))

suma = impuesto_iva14(monto) + calculos.suma_total(monto_suma)

print "Total a Facturar: {0} BsS, con IVA 14%.".format(suma)

Sentencia import

La sentencia import se utiliza para importar un módulo. Usted puede usar cualquier archivo de código Python como un módulo ejecutando esta sentencia en otro archivo de código Python. La sentencia import tiene la siguiente sintaxis:

>>> import os
>>> import re, datetime

Cuando el interprete encuentra una sentencia import, este importa el módulo si el mismo esta presente en la ruta de búsqueda. Una ruta de búsqueda es una lista de directorios que el interprete busca antes de importar un módulo.

Por ejemplo, al importar el módulo utilidades.py, usted necesita colocar la siguiente sentencia al tope del otro script Python. A continuación un ejemplo de un simple módulo, calculo_factura_pipo.py.

# Importar el modulo llamado "utilidades"
import utilidades

print "Importo el modulo '{0}'\n".format(
    utilidades.__file__.replace(
    	utilidades.__file__, "utilidades.pyc"))

print u"Función '{0}' del módulo '{1}' llamado y mostró:".format(
    utilidades.suma_total.__name__,
    utilidades.__file__.replace(
    	utilidades.__file__, "utilidades.pyc"))

# Usted puede llamar una función definida dentro del módulo
print "Monto total a facturar: {0} BsS.".format(
	utilidades.suma_total(int(input("Ingrese un monto: ")))) 

Cuando el código anterior es ejecutado, ese produce el siguiente resultado:

Importo el modulo 'utilidades.pyc'

Función 'suma_total' del módulo 'utilidades.pyc' llamado y mostró:
Ingrese un monto: 56987
Monto total a facturar: 57007 BsS.

Un módulo se carga solo una vez, independientemente de la cantidad de veces que se importe. Esto evita que la ejecución del módulo ocurra una y otra vez si se producen múltiples importaciones.

La primera vez que un módulo es importado en un script de Python, se ejecuta su código una vez. Si otro módulo importa el mismo módulo este no se cargará nuevamente; los módulos son inicializados una sola vez.

Esto se debe al código objeto compilado que genera en el mismo directorio del módulo que cargo con la extensión de archivo .pyc, ejecutando las siguientes sentencias:

>>> import funciones, os
>>> archivos = os.listdir(os.path.abspath(
...     funciones.__file__).replace("/utilidades.pyc", "/"))
>>> print filter(lambda x: x.startswith('funciones.'), archivos)
['utilidades.py', 'utilidades.pyc']

De esta forma se comprueba que existe el archivo compilado de Python junto con el mismo módulo Python.

Localizando módulos

Cuando usted importa un módulo, el interprete Python busca por el módulo en la secuencia siguiente:

1. El directorio actual.
2. Si el módulo no es encontrado, Python entonces busca en cada directorio en la variable de entorno PYTHONPATH del sistema operativo.
3. Si todas las anteriores fallan, Python busca la ruta predeterminada. En UNIX, la ruta predeterminada normalmente esta /usr/local/lib/python/.

El ruta de búsqueda de módulo es almacenado en el módulo de system sys como la variable sys.path. La variable sys.path contiene el directorio actual, PYTHONPATH, y las predeterminadas dependencia de instalación.

PYTHONPATH

Es una variable de entorno del sistema operativo, consistiendo de una lista de directorios. La sintaxis de PYTHONPATH es la misma como la del shell de la variable PATH.

Así es una típica definición de PYTHONPATH desde un sistema Windows, ejecutando:

set PYTHONPATH = C:\python20\lib;

Así es una típica definición de PYTHONPATH desde un sistema UNIX, ejecutando:

set PYTHONPATH = /usr/local/lib/python

Espacios de nombres y alcance

Las variables son nombres (identificadores) que se asignan a objetos.

Un espacio de nombres o namespace, es un diccionario de nombres de variables (claves) y sus objetos (valores) correspondientes.

Una sentencia de Python puede acceder a las variables en un espacio de nombres local y en el espacio de nombres global. Si una variable local y una variable global tienen el mismo nombre, la variable local sombrea la variable global.

Cada función tiene su propio espacio de nombres local. Los métodos de Clase siguen la misma regla de alcance que las funciones ordinarias.

Python hace conjeturas educadas sobre si las variables son locales o globales. Se supone que cualquier variable asignada a un valor en una función es local.

Por lo tanto, para asignar un valor a una variable global dentro de una función, primero debe usar la sentencia global.

>>> global nombre
>>> nombre
'Leonardo'

La sintaxis global nombre, le dice al interprete Python que la variable nombre es una variable global. Python deja de buscar la variable en el espacio de nombres local.

Por ejemplo, defina una variable Money en el espacio de nombres global. Dentro de la función Money, asigna un valor a Money, por lo tanto, Python asume que Money es una variable local. Sin embargo, accede al valor de la variable local Money antes de configurarlo, por lo que el resultado es una excepción UnboundLocalError. Si descomenta la sentencia global, se soluciona el problema.

Abrir archivo

La forma preferida para abrir un archivo es usando la función integrada open().

Leer archivo

La forma preferida para leer un archivo es usando algunas de los métodos del tipo objeto file como read(), readline() y readlines().

Escribir archivo

La forma preferida para escribir un archivo es usando el método del tipo objeto file llamado write().

Cerrar archivo

La forma preferida para cerrar un archivo es usando el método del tipo objeto file llamado close().

Archivos con modulo os

El módulo os de Python le permite a usted realizar operaciones dependiente del Sistema Operativo como crear una carpeta, listar contenidos de una carpeta, conocer acerca de un proceso, finalizar un proceso, etc. Este módulo tiene métodos para ver variables de entornos del Sistema Operativo con las cuales Python esta trabajando en mucho más. Aquí la documentación Python para el módulo os.

A continuación algunos útiles métodos del módulo os que pueden ayudar a manipular archivos y carpeta en su programa Python:

Crear una nueva carpeta

>>> import os
>>> os.makedirs("Ana_Poleo")

Listar el contenidos de una carpeta

>>> import os
>>> os.listdir("./")
['Ana_Poleo']

Mostrar el actual directorio de trabajo

>>> import os
>>> os.getcwd()
'/home/usuario/python/'

Mostrar el tamaño del archivo en bytes del archivo pasado en parámetro

>>> import os
>>> os.path.getsize("Ana_Poleo")
4096

¿Es un archivo el parámetro pasado?

>>> import os
>>> os.path.isfile("Ana_Poleo")
False

¿Es una carpeta el parámetro pasado?

>>> import os
>>> os.path.isdir("Ana_Poleo")
True

Cambiar directorio/carpeta

>>> import os
>>> os.chdir("Ana_Poleo")
>>> os.getcwd()
'/home/usuario/python/Ana_Poleo'
>>> os.listdir("./")
[]
>>> os.chdir("../")
>>> os.getcwd()
'/home/usuario/python'

Renombrar un archivo

>>> import os
>>> os.rename("Ana_Poleo","Ana_Carolina")
>>> os.listdir("./")
['Ana_Carolina']

Eliminar un archivo

>>> import os
>>> os.chdir("Ana_Carolina")
>>> archivo = open(os.getcwd()+'/datos.txt', 'w')
>>> archivo.write("Se Feliz!")
>>> archivo.close()
>>> os.getcwd()
'/home/usuario/python/Ana_Carolina'
>>> os.listdir("./")
['datos.txt']
>>> os.remove(os.getcwd()+"/datos.txt")
>>> os.listdir("./")
[]

Eliminar una carpeta

>>> os.rmdir("Ana_Carolina")
>>> os.chdir("Ana_Carolina")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
OSError: [Errno 2] No such file or directory: 'Ana_Carolina'

Lanza una excepción OSError cuando intenta acceder al directorio que previamente elimino y este no encuentra.

Ejemplos de archivos

A continuación, se presentan algunos ejemplos del uso del tipo objeto file:

Ejemplo de iterar un archivo para leerlo

Usted puede iterar sobre un archivo como se muestra a continuación:

>>> archivo = open('datos.txt', 'r')
>>> for linea in archivo:
...     print linea
...
Este es una prueba

y otra prueba
>>> archivo.close()