Phyton Lenguaje de Programación
Python es uno de los lenguajes de programación dinámicos más populares que existen entre los que se encuentran Perl, Tcl, PHP y Ruby. Aunque es considerado a menudo como un lenguaje "scripting", es realmente un lenguaje de propósito general. En la actualidad, Python es usado para todo, desde simples "scripts", hasta grandes servidores web que proveen servicio ininterrumpido 24x7. Es utilizado para la programación de interfaces gráficas y bases de datos, programación web tanto en el cliente como en el servidor (véase Django o Flask) y "testing" de aplicaciones. Además tiene una amplia aceptación por científicos que hacen aplicaciones para las supercomputadores más rápidas del mundo y por los niños que recién están comenzando a programar. La historia del lenguaje de programación Python se remonta hacia finales de los 80s principio de los 90s y su implementación comenzó en diciembre de 1989 cuando en Navidad Guido Van Rossum que trabajaba en el (CWI) (un centro de investigación holandés de carácter oficial que, entre otras cosas, actualmente alberga la oficina central del W3C) decidió empezar el proyecto como un pasatiempo dándole continuidad al lenguaje de programación ABC del que había formado parte del equipo de desarrollo en el CWI,3 dicho lenguaje se enfocaba en ser fácil de usar y aprender manteniendo potencia en su desempeño pero el hardware disponible en la época de su creación hacía difícil su uso y el proyecto no trascendió como se esperaba. Van Rossum es por tanto el autor principal de Python y continúa ejerciendo un rol central decidiendo la dirección del lenguaje, en la comunidad de Python se le conoce como Benevolente Dictador Vitalicio (en inglés: Benevolent Dictator for Life, BDFL). El nombre "Python" viene dado por la
Es un lenguaje de programación
interpretado cuya filosofía
hace hincapié en una sintaxis
que favorezca un código legible. Se trata de un lenguaje de programación multiparadigma,
ya que soporta orientación a objetos, programación imperativa y, en menor
medida, programación funcional. Fue creado a principios de los años 90. tiene
similitud a lenguaje de programación PERL.
script
En informática, un script, archivo de órdenes, archivo de procesamiento por lotes o, cada vez más aceptado en círculos profesionales y académicos, guion es un programa usualmente simple, que por lo regular se almacena en un archivo de texto plano. Los guiones son casi siempre interpretados, pero no todo programa interpretado es considerado un guion. El uso habitual de los guiones es realizar diversas tareas como combinar componentes, interactuar con el sistema operativo o con el usuario. Por este uso es frecuente que los intérpretes de órdenes sean a la vez intérpretes de este tipo de programas.
Caracterosticas
Principales influencias de otros lenguajes
El núcleo de la sintaxis de Python y grandes aspectos de su filosofía fueron heredados directamente del lenguaje de programación ABC. Por ejemplo el siguiente código muestra una función para obtener el conjunto de todas las palabras en un documento en ABC y en Python:
Recuperar las palabras de un documento en ABC
Las principales ideas de ABC que influyeron o se incluyeron en Python fueron según el propio Guido:
Los generadores e iteradores fueron inspirados por Icon, y fusionados con las ideas de la programación funcional en un modelo unificado. Modula-3 fue la base del modelo de excepciones y del sistema de módulos. Perl contribuyó en las expresiones regulares, usadas para la manipulación de "string". Las adiciones a biblioteca estandar de Python standard library y algunas opciones sintácticas fueron influenciadas por Java algunos ejemplos son: el paquete de
Cronología de Python
Comienzo de la implementación - December, 1989
En informática, un script, archivo de órdenes, archivo de procesamiento por lotes o, cada vez más aceptado en círculos profesionales y académicos, guion es un programa usualmente simple, que por lo regular se almacena en un archivo de texto plano. Los guiones son casi siempre interpretados, pero no todo programa interpretado es considerado un guion. El uso habitual de los guiones es realizar diversas tareas como combinar componentes, interactuar con el sistema operativo o con el usuario. Por este uso es frecuente que los intérpretes de órdenes sean a la vez intérpretes de este tipo de programas.
Caracterosticas
Tipado
Dinámico:
No
es necesario declarar nuestras variables estas se adaptan según el tipo de data
que designemos al programa.
Fuerte
Tipado:
no se
puede combinar variables de diferentes tipos.
Multiple
plataforma:
Linux,
Mac, Windows y otros lo
cual hará que nuestro programa corra sin ningún problema en las distintas
plataforma que hay hoy en día en nuestro mercado.
Orientado a Objeto:
es
un paradigma
de programación que viene a innovar la forma de obtener resultados.
Principales influencias de otros lenguajes
El núcleo de la sintaxis de Python y grandes aspectos de su filosofía fueron heredados directamente del lenguaje de programación ABC. Por ejemplo el siguiente código muestra una función para obtener el conjunto de todas las palabras en un documento en ABC y en Python:
Recuperar las palabras de un documento en ABC
HOW TO RETURN words document:
PUT {} IN collection
FOR line IN document:
FOR word IN split line:
IF word not.in collection:
INSERT word IN collection
RETURN collection
Recuperar las palabras de un documento en Python
def words(document): collection = set() for line in document: for word in line.split(): if word not in collection: collection.add(word) return collection
En ABC no existe propiamente el tipo de dato conjunto, sino algo como
multiconjuntos, es decir, si se inserta un elemento dos veces,
aparecerá dos veces en esa colección, pero en Python el if puede ser eliminado porque la operación add
sobre los conjuntos en Python no hace nada si el elemento ya está en el
conjunto. Se puede observar perfectamente las similitudes entre ambos
códigos, la indentación, el ciclo for, el operador in,
pero también sus diferencias, como por ejemplo en ABC no se utilizan
paréntesis y en Python sí, además las palabras claves en ABC son
escritas en mayúsculas así como los nombres de los procedimientos o
funciones; ABC hace distinción entre procedimiento y función, otra
diferencia con Python.Las principales ideas de ABC que influyeron o se incluyeron en Python fueron según el propio Guido:
- La indentación para agrupar el código
- El carácter : para indicar que comienza un bloque indentado (después de pruebas con usuarios)
- El diseño simple de las instrucciones:
if,while,for,... - Tuplas, listas, diccionarios (fuertemente modificados en Python)
- Tipos de datos inmutables
- No imponer límites, como tamaño de un array, etc...
- El "prompt" >>>
if, else, while, for,
etc.) son las mismas que en C, los identificadores tienen las mismas
reglas para nombrarlos que C, y la mayoría de los operadores estándar
tienen el mismo significado que en C. Una de las mayores diferencias es
que Python en lugar de usar llaves para agrupar código usa indentación,
la otra gran diferencia es que Python usa tipado dinámico.Los generadores e iteradores fueron inspirados por Icon, y fusionados con las ideas de la programación funcional en un modelo unificado. Modula-3 fue la base del modelo de excepciones y del sistema de módulos. Perl contribuyó en las expresiones regulares, usadas para la manipulación de "string". Las adiciones a biblioteca estandar de Python standard library y algunas opciones sintácticas fueron influenciadas por Java algunos ejemplos son: el paquete de
logging, introducido en la versión 2.3, el paquete threading para aplicaciones multihilos, el parser SAX, introducido en la versión 2.0, y la sintáxis del decorador que usa @, incluida en la versión 2.4Cronología de Python
Comienzo de la implementación - December, 1989
Publicación interna en CWI - 1990
- Python 0.9 - 20 de febrero de 1991 (publicado en alt.sources)
- Python 0.9.1 - Febrero de 1991
- Python 0.9.2 - Otoño de 1991
- Python 0.9.4 - 24 de diciembre de 1991
- Python 0.9.5 - 2 de enero de 1992 (solo para Macintosh)
- Python 0.9.6 - 6 de abril de 1992
- Python 0.9.7 beta - 1992
- Python 0.9.8 - 9 de enero de 1993
- Python 0.9.9 - 29 de julio de 1993
- Python 1.0 - Enero de 1994
- Python 1.5 - 31 de diciembre de 1997
- Python 1.6 - 5 de septiembre de 2000
- Python 2.0 - 16 de octubre de 2000
- Python 2.1 - 17 de abril de 2001
- Python 2.2 - 21 de diciembre de 2001
- Python 2.3 - 29 de julio de 2003
- Python 2.4 - 30 de noviembre de 2004
- Python 2.5 - 19 de septiembre de 2006
- Python 2.6 - 1 de octubre de 2008
- Python 2.7 - 3 de julio de 2010
- Python 3.0 - 3 de diciembre de 2008
- Python 3.1 - 27 de junio de 2009
- Python 3.2 - 20 de febrero de 2011
- Python 3.3 - 29 de septiembre de 2012
- Python 3.4 - 16 de marzo de 2014
- Python 3.4.4 2015-12-21
- Python 3.5.1 2015-12-07
- Python 2.7.11 2015-12-05
- Python 3.5.0 2015-09-13
- Python 2.7.10 2015-05-23
- Python 3.4.3 2015-02-25
- Python 3.6.0 2016-12-23
- Python 2.7.13 2016-12-17
- Python 3.4.5 2016-06-27
- Python 3.5.2 2016-06-27
- Python 2.7.12 2016-06-25
- Python 3.3.7 2017-09-19
- Python 2.7.14 2017-09-16
- Python 3.4.7 2017-08-09
- Python 3.5.4 2017-08-08
- Python 3.6.2 2017-07-17
- Python 3.6.1 2017-03-21
- Python 3.4.6 2017-01-17
- Python 3.5.3 2017-01-17
Primera publicaciónEn 1991, Van Rossum publicó el código de la versión 0.9.0 en alt.sources. En esta etapa del desarrollo ya estaban presentes clases con herencia, manejo de excepciones, funciones y los tipos modulares, como: str, list, dict, entre otros. Además en este lanzamiento inicial aparecía un sistema de módulos adoptado de Modula-3; Van Rossum describe el módulo como “una de las mayores unidades de programación de Python”.
El modelo de excepciones en Python es parecido al de Modula-3, con la adición de una cláusula else. En el año 1994 se formó comp.lang.python, el foro de discusión principal de Python, marcando un hito en el crecimiento del grupo de usuarios de este lenguaje.
Versión 1.0
Python llega a la versión 1.0 en enero de 1994. Las características más importantes incluidas en esta publicación fueron las herramientas de la programación funcional lambda, reduce, filter y map. Van Rossum ha comentado que "Python adquiere lambda, reduce(), filter() and map(), cortesía de un hacker de Lisp que las extrañaba y envió parches que funcionaban".
La última versión liberada proveniente de CWI fue Python 1.2. En 1995, van Rossum continuó su trabajo en Python en la Corporation for National Research Initiatives (CNRI) en Reston, Virginia, donde lanzó varias versiones del software.
Para la versión 1.4, Python adquirió varias características nuevas. Es notable entre estas los argumentos por nombre inspirados por Modula-3 (que también son similares a los de Common Lisp) y soporte "built-in" para los números complejos.
Durante su estancia en CNRI, Van Rossum lanzó la iniciativa Computer Programming for Everybody (CP4E), con el fin de hacer la programación más accesible a más gente, con un nivel de 'alfabetización' básico en lenguajes de programación, similar a las habilidades básicas en inglés y matemáticas necesarias por muchos empleadores. Python tuvo un papel crucial en este proceso: debido a su orientación hacia una sintaxis limpia, ya era idóneo, y las metas de CP4E presentaban similitudes con su predecesor, ABC. El proyecto fue patrocinado por DARPA.El proyecto CP4E está inactivo, y mientras tanto Python intenta ser fácil de aprender y no muy arcano en su sintaxis y semántica, pero alcanzar a los no-programadores ya no es una preocupación activa.
BeOpen
En el año 2000, el equipo principal de desarrolladores de Python se cambió a BeOpen.com para formar el equipo BeOpen PythonLabs. CNRI pidió que la versión 1.6 fuera publicada hasta el punto de desarrollo en que el equipo abandonó CNRI. Consecuentemente su agenda de lanzamiento para la versión 1.6 y la versión 2.0 tenían una significativa cantidad de solapamiento. Python 2.0 fue el primer y único lanzamiento de BeOpen.com. Después que Python 2.0 fuera publicado por BeOpen.com, Guido van Rossum y los otros desarrolladores de PythonLabs se unieron a Digital Creations.
La publicación de Python 1.6 incluía una nueva licencia de CNRI que era substancialmente más larga que la licencia de CWI que había sido usada en las publicaciones anteriores. La nueva licencia incluía una cláusula estipulando que la licencia estaba gobernada por las leyes del estado de Virginia. La Free Software Foundation (FSF) argumento la cláusula era incompatible con GNU GPL. Entonces BeOpen, CNRI, y FSF acordaron cambiar Python hacia una licencia de software libre que lo haría compatible con GPL. Python 1.6.1 es básicamente el mismo que Python 1.6, con unos arreglos de bugs, y con la nueva licencia compatible con GPL.
Versión 2.0
Python 2.0 tomó una importante característica del lenguaje de programación funcional Haskell: generación de listas. La sintaxis de Python para esta construcción es muy similar a la de Haskell, salvo por la preferencia de los caracteres de puntuación en Haskell, y la preferencia de Python por palabras claves. Python 2.0 introdujo además un sistema de recolección de basura capaz de recolectar referencias cíclicas.
Python 2.1 fue un trabajo derivado de Python 1.6.1, así como también de Python 2.0. Su licencia fue renombrada a: Python Software Foundation License. Todo el código, documentación y especificaciones añadidas, desde la fecha del lanzamiento de la versión alfa de Python 2.1, pertenece a Python Software Foundation (PSF), una organización sin ánimo de lucro fundada en el año 2001, tomando como modelo la Apache Software Foundation. Este lanzamiento incluyó un cambio en el lenguaje para soportar ámbitos anidados (más conocido en programación como "nested scopes") como lo soportan otros lenguajes de "static scoping" (del cual Scheme es el originador). (Esta características fue deshabilitada por defecto, y no requerida, hasta Python 2.2.)
Una gran innovación en Python 2.2 fue la unificación de los tipos en Python (tipos escritos en C), y clases (tipos escritos en Python) dentro de una jerarquía. Esa unificación logró un modelo orientado a objetos de Python puro y consistente. También fueron agregados los generadores que fueron inspirados por el lenguaje Icon.
Versión 3.0
Python 3.0
(también conocido como "Python 3000" o "Py3K") fue diseñado para rectificar ciertas fallas fundamentales en el diseño del lenguaje (los cambios requeridos no podían ser implementados mientras se mantuviera compatibilidad hacia atrás con la serie 2.x).
El principio que guía Python 3 es: "reducir la duplicación de características eliminando viejas formas de hacer las cosas (reduce feature duplication by removing old ways of doing things)".
Filosofía
Python 3.0 fue desarrollado con la misma filosofía que en las versiones anteriores. Sin embargo, como Python ha acumulado nuevas y redundantes formas de programar la misma tarea, Python 3.0 ha hecho énfasis en eliminar constructores duplicados y módulos, en consecuencia con "Debe haber un— y preferiblemente solo un —modo obvio de hacerlo".
A pesar de esto, Python 3.0 se mantiene como un lenguaje de programación multiparadigma. Los programadores todavía tienen opciones entre orientación a objetos, programación estructurada, programación funcional y otros paradigmas, pero dentro de estas amplias opciones, los detalles intentan ser más obvios en Python 3.0 que como eran en Python 2.x.
Cronología y compatibilidad
Python 3.0 fue liberado el 3 de diciembre de 2008. Las series Python 2.x y Python 3.x estaban planeadas para coexistir por varias publicaciones lanzándolas en paralelo, con la serie 2.x existente mayormente por compatibilidad y con algunas nuevas características siendo importadas hacia atrás de la serie 3.x. Python 2.6 fue liberado para coincidir con Python 3.0, e incluye algunas características de esa publicación, así como un modo de "alertas (warnings)" que resalta el uso de características que han sido eliminadas en Python 3.0. Similarmente, Python 2.7 coincide e incluye características de Python 3.1,que fue publicado el 26 de junio de 2009. Python 2.7 fue la última publicación en la serie 2.x; las publicaciones en paralelo terminaron con Python 3.2.
Python 3.0 rompe la compatibilidad hacia atrás. El código de Python 2.x no necesariamente debe "correr" en Python 3.0 sin modificarlo. Hay cambios básicos tales como el cambio de print en una función (por lo tanto cualquier uso como print "Hello Python" provocará un error en Python 3.x), y el cambio a Unicode para todos los textos "strings".
El tipado dinámico de Python combinado con los planes para cambiar la semántica de ciertos métodos de los diccionarios, por ejemplo, hacen que convertir perfectamente de Python 2.x a Python 3.0 sea muy díficil de manera automática. Sin embargo, una herramiento llamada "2to3" puede hacer la mayoría del trabajo de "traducción", señalando areas que confusas para ella usando comentarios o alertas. Incluso en la etapa "alpha", 2to3 se mostraba claramente satisfactoria para ejecutar las traducciones del código. For projects requiring compatibility with both the 2.x and 3.x series, the Python development team recommended keeping one source (for the 2.x series), and producing releases for the Python 3.x platform using 2to3. Edits to the Python 3.x code were discouraged for so long as the code needed to run on Python 2.x.
Características
Algunos de los mayores cambios anunciados para Python 3.0 fueron:
Cambiar la instrucción print de modo que sea una función "built-in", no una instrucción. Esto ha hecho que sea más fácil cambiar un módulo para usar una función print diferente, así como hacer la sintaxis más regular. En Python 2.6 y 2.7 esta característica puede ser habilitada usando from __future__ import print_function.
Moviendo reduce (pero no map o filter) fuera del espacio de nombres "built-in" dentro de "functools".
Adicionar soporte para anotación opcional en funciones que pueda ser usar para la declaración informal de tipos u otros propósitos.
Unificar los tipos str/unicode, representando texto, e introduciendo un tipo immutable bytes; y un más correspondiente tipo mutable bytearray, ambos de los cuales representas "arrays" de bytes;
Eliminar compatibilidad hacia atrás, incluidas clases "old-style", excepciones "string", e implícitos "imports" relativos.
Las subsecuentes publicaciones de la serie Python 3.x han incluido sustanciales nuevas características; todas al corriente del desarrollo que el lenguaje ha tenido en la serie 3.x.
Abrir un archivo
El proceso natural que tenemos para llevar a cabo con el fin de hacer cualquier operación con archivos es poder abrirlo. Antes que nada, descárgate el archivo Text.txt, que es el archivo que vamos a utilizar para llevar a cabo nuestros experimentos.
Con el fin de abrir el archivo utilizando Python, usaremos la función open(). Tal y como narra la documentación:
open() devuelve un objeto file, y comúnmente se utiliza con dos argumentos: open(nombre del archivo, modo)
Como has podido ver en el extracto de la documentación, la función open() cuenta con dos argumentos: el nombre del archivo y el modo. Estos argumentos se parecen a la función de stdio (es decir, de C) fopen(). El nombre del archivo hace referencia al nombre (y la ruta) del archivo que desees abrir. El modo es un valor string que indica cómo se va a abrir el archivo. Aquí puedes ver los distintos modos en los que se puede abrir un archivo:
Versión 2.0
Python 2.0 tomó una importante característica del lenguaje de programación funcional Haskell: generación de listas. La sintaxis de Python para esta construcción es muy similar a la de Haskell, salvo por la preferencia de los caracteres de puntuación en Haskell, y la preferencia de Python por palabras claves. Python 2.0 introdujo además un sistema de recolección de basura capaz de recolectar referencias cíclicas.
Python 2.1 fue un trabajo derivado de Python 1.6.1, así como también de Python 2.0. Su licencia fue renombrada a: Python Software Foundation License. Todo el código, documentación y especificaciones añadidas, desde la fecha del lanzamiento de la versión alfa de Python 2.1, pertenece a Python Software Foundation (PSF), una organización sin ánimo de lucro fundada en el año 2001, tomando como modelo la Apache Software Foundation. Este lanzamiento incluyó un cambio en el lenguaje para soportar ámbitos anidados (más conocido en programación como "nested scopes") como lo soportan otros lenguajes de "static scoping" (del cual Scheme es el originador). (Esta características fue deshabilitada por defecto, y no requerida, hasta Python 2.2.)
Una gran innovación en Python 2.2 fue la unificación de los tipos en Python (tipos escritos en C), y clases (tipos escritos en Python) dentro de una jerarquía. Esa unificación logró un modelo orientado a objetos de Python puro y consistente. También fueron agregados los generadores que fueron inspirados por el lenguaje Icon.
Versión 3.0
Python 3.0
(también conocido como "Python 3000" o "Py3K") fue diseñado para rectificar ciertas fallas fundamentales en el diseño del lenguaje (los cambios requeridos no podían ser implementados mientras se mantuviera compatibilidad hacia atrás con la serie 2.x).
El principio que guía Python 3 es: "reducir la duplicación de características eliminando viejas formas de hacer las cosas (reduce feature duplication by removing old ways of doing things)".
Filosofía
Python 3.0 fue desarrollado con la misma filosofía que en las versiones anteriores. Sin embargo, como Python ha acumulado nuevas y redundantes formas de programar la misma tarea, Python 3.0 ha hecho énfasis en eliminar constructores duplicados y módulos, en consecuencia con "Debe haber un— y preferiblemente solo un —modo obvio de hacerlo".
A pesar de esto, Python 3.0 se mantiene como un lenguaje de programación multiparadigma. Los programadores todavía tienen opciones entre orientación a objetos, programación estructurada, programación funcional y otros paradigmas, pero dentro de estas amplias opciones, los detalles intentan ser más obvios en Python 3.0 que como eran en Python 2.x.
Cronología y compatibilidad
Python 3.0 fue liberado el 3 de diciembre de 2008. Las series Python 2.x y Python 3.x estaban planeadas para coexistir por varias publicaciones lanzándolas en paralelo, con la serie 2.x existente mayormente por compatibilidad y con algunas nuevas características siendo importadas hacia atrás de la serie 3.x. Python 2.6 fue liberado para coincidir con Python 3.0, e incluye algunas características de esa publicación, así como un modo de "alertas (warnings)" que resalta el uso de características que han sido eliminadas en Python 3.0. Similarmente, Python 2.7 coincide e incluye características de Python 3.1,que fue publicado el 26 de junio de 2009. Python 2.7 fue la última publicación en la serie 2.x; las publicaciones en paralelo terminaron con Python 3.2.
Python 3.0 rompe la compatibilidad hacia atrás. El código de Python 2.x no necesariamente debe "correr" en Python 3.0 sin modificarlo. Hay cambios básicos tales como el cambio de print en una función (por lo tanto cualquier uso como print "Hello Python" provocará un error en Python 3.x), y el cambio a Unicode para todos los textos "strings".
El tipado dinámico de Python combinado con los planes para cambiar la semántica de ciertos métodos de los diccionarios, por ejemplo, hacen que convertir perfectamente de Python 2.x a Python 3.0 sea muy díficil de manera automática. Sin embargo, una herramiento llamada "2to3" puede hacer la mayoría del trabajo de "traducción", señalando areas que confusas para ella usando comentarios o alertas. Incluso en la etapa "alpha", 2to3 se mostraba claramente satisfactoria para ejecutar las traducciones del código. For projects requiring compatibility with both the 2.x and 3.x series, the Python development team recommended keeping one source (for the 2.x series), and producing releases for the Python 3.x platform using 2to3. Edits to the Python 3.x code were discouraged for so long as the code needed to run on Python 2.x.
Características
Algunos de los mayores cambios anunciados para Python 3.0 fueron:
Cambiar la instrucción print de modo que sea una función "built-in", no una instrucción. Esto ha hecho que sea más fácil cambiar un módulo para usar una función print diferente, así como hacer la sintaxis más regular. En Python 2.6 y 2.7 esta característica puede ser habilitada usando from __future__ import print_function.
Moviendo reduce (pero no map o filter) fuera del espacio de nombres "built-in" dentro de "functools".
Adicionar soporte para anotación opcional en funciones que pueda ser usar para la declaración informal de tipos u otros propósitos.
Unificar los tipos str/unicode, representando texto, e introduciendo un tipo immutable bytes; y un más correspondiente tipo mutable bytearray, ambos de los cuales representas "arrays" de bytes;
Eliminar compatibilidad hacia atrás, incluidas clases "old-style", excepciones "string", e implícitos "imports" relativos.
Las subsecuentes publicaciones de la serie Python 3.x han incluido sustanciales nuevas características; todas al corriente del desarrollo que el lenguaje ha tenido en la serie 3.x.
Escribir y leer ficheros en Python
Si te fijas en el escritorio de tu ordenador, ¿qué ves? Cientos de archivos que se extienden por todas partes, ¿verdad? Casi todo el mundo cae en este penoso hábito, nos resulta imposible, por un extraño vericueto del destino, el poner en orden los ficheros de nuestro equipo. Pero la clave de este artículo es saber cómo tratar todos esos archivos. Hoy vamos a hablar de Python, y de cómo trabajar con ficheros utilizando Python. Así que, si estás interesado, no te pierdas ni una coma de este tutorial.Abrir un archivo
El proceso natural que tenemos para llevar a cabo con el fin de hacer cualquier operación con archivos es poder abrirlo. Antes que nada, descárgate el archivo Text.txt, que es el archivo que vamos a utilizar para llevar a cabo nuestros experimentos.
Con el fin de abrir el archivo utilizando Python, usaremos la función open(). Tal y como narra la documentación:
open() devuelve un objeto file, y comúnmente se utiliza con dos argumentos: open(nombre del archivo, modo)
Como has podido ver en el extracto de la documentación, la función open() cuenta con dos argumentos: el nombre del archivo y el modo. Estos argumentos se parecen a la función de stdio (es decir, de C) fopen(). El nombre del archivo hace referencia al nombre (y la ruta) del archivo que desees abrir. El modo es un valor string que indica cómo se va a abrir el archivo. Aquí puedes ver los distintos modos en los que se puede abrir un archivo:
- r: Abrir fichero para lectura. El puntero se posiciona al principio del fichero
- r+: Abrir fichero para lectura y escritura. El puntero se posiciona al principio del fichero
- w: Trunca a cero la longitud o crea un fichero de texto para escritura. El puntero se posiciona al principio del fichero
- w+: Abrir fichero para lectura y escritura. Si el fichero no existe, se crea, de lo contrario se trunca. El puntero se posiciona al principio del fichero
- a: Abrir fichero para lectura. Se creará el fichero si no exsite. El puntero se posiciona al final del fichero.
- a+: Abrir fichero para lectura y escritura. Se creará el fichero si no exsite. El puntero se posiciona al final del fichero.
Puedes ver más modos en la documentación de Python.
Vamos a continuar con el tutorial, y para eso necesitamos abrir el fichero Text.txt. Es tan simple como escribir lo siguiente: text_file = open('Text.txt')
Como puedes ver, no hemos especificado el modo. Para saber el modo por defecto que utiliza open(), escribe print text_file, y obtendrás algo parecido a esto: open file 'Text.txt', mode 'r' at 0x10728c810
Así, como indica el código, el modo por defecto es r. En este punto es posible que notes que no has avanzado nada, pero creeme que abrir el fichero ya es un gran paso.
Leyendo un fichero
Un fichero es como una caja sorpresa. La hemos abierto en el paso anterior y ahora queremos saber que tiene dentro. Leer un archivo en Python es muy sencillo, para se utiliza el método read() tal que así: text_file.read()
Para ver la salida de la sentencia anterior, escribe print text_file.read(). Mediante esto, por fin el secreto (contenido) será revelado: I'm enjoying learning about "file handling" in Python
Ahora vamos a probar una cosa. Escribe de nuevo la sentencia anterior, ¿Qué devuelve? En efecto, nada de nada. Esto es debido a que ya has leido el fichero completo, a diferencia de leerlo línea por línea, como por ejemplo con readline().
Escribiendo en un fichero
Tal vez quieras agregar una frase o un párrafo en el fichero una vez que lo has leído. Vamos a simular un caso, imagina que quieres añadir la siguiente frase: and I'm looking for more. Esto puede llevarse a cabo en Python utilizando el método write(). text_file.write('and I'm looking for more')
Ups, parece que hay un error... Traceback (most recent call last):
File "test.py", line 2, in
text_file.write(' and I'm looking for more')
IOError: File not open for writing
¿Has averiguado por qué? ¿Recuerdas cuando hemos abierto el archivo en la primera sección de la siguiente manera: open('Text.text');? Dado que no estamos especificando el modo, por defecto se establece en r. Esto nos permitirá únicamente leer el archivo, y en el ejemplo lo que queremos es escribir en él. Por lo tanto, vamos a abrir el fichero de nuevo, pero esta vez en modo w: text_file = open('Text.txt', 'w')
Prueba ahora a escribir la sentencia otra vez utilizando el código de arriba. ¿Qué has obtenido? Vamos a abrir con open() y a leer read() el archivo tal y como te hemos mostrado en las dos primeras secciones de este tutorial, para ver lo que hay dentro del fichero: text_file = open('Text.txt','r')
print text_file.read()
La salida de este script es: and I'm looking for more
¿Esperabas ver esta nueva frase acompañada por la frase original que hay dentro del fichero? Sí, ya sabes, esa que dice: “I'm enjoying learning about "file handling" in Python”, ¿verdad? El modo w sobreescribe el contenido del archivo en el que estás escribiendo. Si estás interesado en mantener el texto original del documento, utiliza el modo a. text_file = open('Text.txt','a')
text_file.write(' and I'm looking for more')
En este caso, sí que obtendrás lo esperado: I'm enjoying learning about "file handling" in Python and I'm looking for more
Vamos a poner todo lo que hemos aprendido, junto: with open('Text.txt', 'r+') as text_file:
print 'The file content BEFORE writing content:'
print text_file.read()
text_file.write(' and I'm looking for more')
print 'The file content AFTER writing content:'
text_file.seek(0)
print text_file.read()
Cerrando un fichero
Tener el hábito de cerrar un archivo después de leerlo o escribir en él te permitirá liberar memoria. Sí, Python cerrará automáticamente los archivos después de que finalice el script, pero si no lo haces previamente, los archivos abiertos ocuparán cierto espacio del que Python podría beneficiarse. Cerrar un archivo se lleva a cabo simplemente utilizando el método close(). text_file = open('Text.txt','a+')
print text_file.read()
text_file.write(' and I'm looking for more')
¿Que pasa si cerramos close() un archivo antes de leerlo read()? Pues lógicamente, Python mostrará un error: Traceback (most recent call last):
File "test.py", line 4, in module
text_file.write(' and I'm looking for more')
ValueError: I/O operation on closed file
Programas para Instalar Python
http://www.aptana.com
http://www.pydev.org/download.html
Aptana: http://www.aptana.com/products/studio...
Java JRE: http://www.java.com/es/download/win10...
Node: https://nodejs.org/dist/v0.10.13/node...
Para Descargar Codigo:
http://www.pydev.org/manual_adv_django.html
