El siguiente texto es una traducción del artículo Introduction and Overview de Guido van Rossum publicado en http://python-history.blogspot.com/. Mi objetivo es traducir todos los artículos que se publiquen en ese blog.

Introducción

Python es en la actualidad uno de los lenguajes de programación dinámicos más populares, junto con Perl, Tcl, PHP y ahora Ruby. A pesar de ser a menudo visto como un lenguaje de "scripting", es en realidad un lenguaje de programación de propósito general como Lisp o Smalltalk. Hoy, Python es usado para todo, desde scripts que luego se tiran hasta servidores web de alta escalabilidad que proveen servicio ininterrumpido 24x7. Permite crear interfaces de usuario, programar con bases de datos, realizar programación web tanto del lado del servidor como del cliente y testear aplicaciones. Es usado por científicos que escriben aplicaciones para las más rápidas supercomputadoras del mundo y por niños que están aprendiendo a programar.

En este blog, voy a concentrarme en la historia de Python. En particular, cómo Python fue desarrollado, las principales influencias en su diseño, errores cometidos, lecciones aprendidas y futuras direcciones para el lenguaje.

Reconocimiento: Estoy en deuda con Dave Beazley por muchas de las mejores oraciones en este blog. (Para saber más sobre los orígenes de este blog, vea mi otro blog.)

Un repaso rápido a Python

Cuando uno se encuentra con Python por primera vez, a menudo se sorprende de que el código Python se vea, por lo menos superficialmente, similar a código escrito en otros lenguajes de programación convencionales como C o Pascal. Esto no es un accidente; la sintaxis de Python toma mucho prestado de C. Por ejemplo, muchas de las palabras claves de Python (if, else, while, for, etc.) son las mismas que en C, los identificadores en Python tienen las mismas reglas que los de C, y muchos de los operadores estándares tienen el mismo significado que en C. Por supuesto, Python no es C y una de las principales áreas dónde difiere es que en lugar de usar llaves para agrupar sentencias, usa indentación. Por ejemplo, en lugar de escribir sentencias en C como:

if (a < B) {

    max = b:

} else {

    max = a;

}

Python simplemente se deshace de todas las llaves (y de los punto y coma finales) y usa la siguiente estructura

if a < b:

    max = b

else:

    max = a

Otra área importante en la que Python se diferencia de los lenguajes del estilo de C es en su uso de tipado dinámico. En C, las variables siempre deben ser declaradas explícitamente y se les debe dar un tipo específico como int o double. Esta información es luego usada para hacer verificaciones estáticas en tiempo de compilación del programa y para reservar memoria para almacenar el valor de las variables. En Python, las variables son simplemente nombres que hacen referencia a objetos. No se necesita declarar las variables antes de que sean asignadas e incluso pueden cambiar de tipo en el medio de un programa. Como otros lenguajes de programación dinámicos, todas las verificaciones de tipo se hacen en tiempo de ejecución por un intérprete en lugar de en un paso de compilación separado.

Los tipos de datos primitivos que vienen con Python incluyen booleanos, números (enteros de máquina, enteros de precisión arbitraria, y números de coma flotante reales y complejos), y cadenas de texto (de 8 bits y Unicode). Estos son todos tipos de datos inmutables, esto significa que los valores son representados por objetos que no pueden ser modificados después de su creación. Los tipos de datos compuestos que viene con el lenguaje incluyen tuplas (arrays inmutables), listas (arrays que pueden cambiar de tamaño) y diccionarios (tablas hash).

Para organizar los programas, Python soporta paquetes (grupos de módulos y/o paquetes), módulos (código relacionado agrupado en un solo archivo fuente), clases, métodos o funciones. Para control de flujo, provee if/else, while y una sentencia for de alto nivel que itera sobre cualquier objeto "iterable". Para el manejo de errores, Python usa excepciones. Una sentencia raise lanza una excepción, y las sentencias try/except/finally especifican manejadores para las excepciones. Las operaciones que vienen con el lenguaje lanzan excepciones cuando se encuentran condiciones de error.

En Python, todos los objetos que pueden ser nombrados son llamados "de primera clase". Esto significa que funciones, clases, métodos, módulos y todos los otros objetos nombrados pueden ser libremente pasados como parámetros, inspeccionados y almacenados en distintas estructuras de datos (por ejemplo, listas o diccionarios) en tiempo de ejecución. Y hablando de objetos, Python también tiene soporte completo para programación orientada a objetos; incluyendo clases definidas por el usuario, herencia y asociación de métodos en tiempo de ejecución.

Python tiene una extensa librería estándar, la cual es una de las razones de su popularidad. La librería estándar tiene más de 100 módulos y siempre está evolucionando. Alguno de estos módulos incluyen expresiones regulares, funciones matemáticas típicas, hilos, interfaces con sistemas operativos, redes, protocolos estándares de Internet (HTTP, FTP, SMTP, etc.), manejo de email, procesamiento de XML, procesamiento de HTML y toolkits para GUI (Tcl/Tk).

Además, hay una gran cantidad de módulos y paquetes provistos por terceros, muchos de los cuales también son open source. Aquí uno puede encontrar frameworks web (¡muchos como para listarlos!), más toolkits para GUI, librerías numéricas eficientes (incluyendo wrappers para muchos paquetes populares escritos en Fortran), interfaces con bases de datos relacionales (Oracle, MySQL y otras), SWIG (una herramienta para hacer que librerías C++ estén disponibles como módulos Python), y mucho más.

Un atractivo principal de Python (y de otros lenguajes de programación dinámicos en ese aspecto) es que tareas que parecen complicadas a menudo pueden ser expresadas con muy poco código. Por ejemplo, aquí hay un script en Python simple que obtiene una página web, la revisa buscando referencias a URLs, e imprime las primeras 10.

# Scan the web looking for references



import re

import urllib



regex = re.compile(r'href="([^"]+)"')



def matcher(url, max=10):

    "Print the first several URL references in a given url."

    data = urllib.urlopen(url).read()

    hits = regex.findall(data)

    for hit in hits[:max]:

        print urllib.basejoin(url, hit)



matcher("http://python.org")

Este programa puede ser modificado fácilmente para hacer un web crawler, y en efecto Scott Hassan me ha dicho que escribió el primer web crawler de Google en Python. Hoy, Google emplea millones de líneas de código Python para manejar muchos aspectos de sus operaciones, desde automatización a manejo de avisos (Descargo: en la actualidad soy un empleado de Google.)

Por debajo, Python es implementado como una combinación de intérprete y compilador a bytecode. La compilación es llevada a cabo implícitamente cuando los módulos son cargados, y muchas primitivas del lenguaje necesitan que el compilador esté disponible en tiempo de ejecución. A pesar de que la implementación de referencia de Python está escrita en C, y está disponible para cada plataforma de hardware/software existente, muchas otras implementaciones se han vuelto populares. Jython es una versión que corre sobre la JVM y tiene integración con Java. IronPython es una versión para la plataforma .NET de Microsoft que tiene una integración similar con otros lenguajes que corren sobre la plataforma .NET. PyPy es un compilador/intérprete de Python escrito en Python (aún un proyecto de investigación, financiado con fondos de la UE). También está Stackless Python, una variante de la implementación en C que reduce la dependencia del stack de C para llamadas a funciones/métodos, para permitir co-rutinas, continuations y micro hilos.

Traducido por Juan José Conti.

Revisado por César Portela.

Si encontrás errores en esta traducción, por favor reportalos en un comentario y los corregiremos a la brevedad.

Todas las traducciones de esta serie pueden encontrarse en La historia de Python.

El siguiente texto era parte del informe del proyecto final de carrera de Juan José Conti y Cecilia Lorena Puccinelli, titulado Desarrollo Ágil de un Sistema de Gestión de Negocios Inmobiliarios con Software Libre. Finalmente no fue incluido en la versión definitiva del mismo por lo que lo rescatamos en este blog.

Python

Python es un lenguaje de programación de propósito general de alto nivel. Su filosofía de diseño hace énfasis en lograr productividad para los programadores y legibilidad del código.

Fue creado en el año 1990 por Guido Van Rossum y desde entonces ha sido desarrollado como un proyecto del Software Libre por desarrolladores alrededor del mundo.

A menudo es comparado con lenguajes como C, Java, Perl y Lisp, pero tiene muchas características distintivas que marcan su identidad propia:

Intérprete interactivo

Python viene acompañado de un intérprete interactivo o read-eval-print-loop que permite agilizar el desarrollo de programas ya que se pueden probar ideas y rápidamete ver como resultan sin necesidad de escribir un programa entero en el cual envolverla. Otros lenguajes como Smalltalk, Haskell o Scheme también tienen esta herramienta.

El siguiente es un ejemplo sencillo de uso del intérprete interactivo, los comandos ingresados por el usuario están precedidos por >>>:

>>> 1 + 2

3

>>> "hola"

'hola'

>>> nombre = "fabio"

>>> "hola " + nombre

'hola fabio'

Tipos de datos poderosos

Python incluye de forma nativa tipos de datos poderosos muy útiles a la hora de programar. Las listas y tuplas son secuencias de objetos:

lista = [1,2,3, “cuatro”, Cliente()]

tupla = ('u', 1, 3)

Ambos tipos de datos pueden almacenar cualquier tipo de objetos en orden. La principal diferencia entre estos dos tipos de datos es que las listas pueden cambiar en forma dinámica su tamaño mientras que las tuplas son de tamaño fijo (se dice que es un objeto inmutable, como los números o cadenas de texto).

Los diccionarios son una estructura de datos sin orden que permite almacenar valores asociados a una clave para luego poder recuperarlos a partir de esta. Solo objetos inmutables pueden ser clave de un diccionario.

dicc = {'a': 1, 'b': 10}

dicc['a'] obtiene el objeto 1

dicc[3] = ‘tres’ agrega al diccionario el objeto ‘tres’ asociado a la clave 3 .

Espacios en blanco con significado

En Python los bloques se delimitan mediante el uso de indentación en lugar de utilizar llaves:

if carteles == 0:

    print “No hay carteles disponibles.”

else:

    print “Hay %d carteles disponibles.” % carteles

Esto tiene como objetivo forzar una correcta indentación que redunde en una mayor legibilidad del código escrito.

i = 20

while i > 0:

    print i

    i -= 1

Tipado de pato

El nombre tipado de pato surge de la idea: “si un objeto camina como pato y come como pato, entonces debe ser un pato”.

Las restricciones de tipo no son checkeadas en tiempo de compilación, sino que las operaciones sobre los objetos siempre se intentan llevar a cabo y fallan en tiempo de ejecución si el objeto no puede responder al mensaje que se le envió.

Supongamos que definimos la función saludar como sigue:

def saludar(o):

    print “hola %s“ % o.nombre

A esta función no lo interesa el tipo del objeto o, recibido como parámetro, lo único que le importa es que tenga el atributo nombre.

Así, si la variable m referencia un objeto de la clase Mujer y la variable h referencia un objeto de la clase Hombre y ambas clases tienen un atributo llamado nombre, entonces las siguientes llamadas se ejecutarán sin problemas:

saludar(m)

saludar(h)

Si la variable ‘a’ referencia a un objeto de la clase Anonimo y ésta no tiene un atributo llamado nombre, la llamada a:

saludar(a) lanzará una excepción.

Librería estándar amplia

Al igual que Java, Python cuenta con una amplia librería estándar que acompaña al lenguaje. Ésta incluye módulos para manejar expresiones regulares, crear interfaces gráficas, conectarse a bases de datos entre muchos otros.

Ésta es una de sus mayores ventajas y a esto se debe la popular expresión “Python viene con las baterías incluidas”.

Librerías externas

Además de los muchos componentes incluidos en la librería estándar de Python, hemos utilizando algunas librerías externas:

• PIL: librería para manejo de imágenes.
• Pysicopg: conector para el motor de bases de datos PostgreSQL.
• ReportLab: librería para generar documentos PDF.
• BeautifulSoap: librería para procesar documentos HTML. Su uso es descrito en la sección 1.1.37.
• Pynum2word: módulo que convierte números en palabras.

¿Cómo saber en Django qué sentencias SQL se están ejecutando detrás de su ORM? Según la FAQ, podemos hacerlo de esta forma:

Make sure your Django DEBUG setting is set to True. Then, just do this:

>>> from django.db import connection

>>> connection.queries

[{'sql': 'SELECT polls_polls.id,polls_polls.question,polls_polls.pub_date FROM polls_polls',

'time': '0.002'}]

connection.queries is only available if DEBUG is True. It's a list of dictionaries in order of query execution. Each dictionary has the following:

sql -- The raw SQL statement

time -- How long the statement took to execute, in seconds.

connection.queries includes all SQL statements -- INSERTs, UPDATES, SELECTs, etc. Each time your app hits the database, the query will be recorded.

Cada vez que se realiza una nueva petición, esa variable es sobre escrita con las consultas que se ejecutaron en la vista asociada. La forma de verlas es accediendo a connection.queries en cada vista de nuestro interés. Para facilitar esta tarea y no tener código intrusivo, escribí un decorador:

from django.db import connection

def sql_debug(f):

    '''

    Decorador útil para inspeccionar las sentencias SQL que se ejecutan en

    cada request.

    '''

    def inner(*args, **kwargs):

        r = f(*args, **kwargs)

        for d in connection.queries:

            print "time: %s\n sql:%s\n\n" % (d['time'], d['sql'])

        return r

    return inner

Esta es una traducción de la última sección del PEP 8 de Python, Recomendaciones al programar:

Programming Recommendations

El código debe ser escrito de forma que no tenga desventajas en otras implementaciones de Python aparte de CPython (PyPy, Jython, IronPython, Pyrex, Psyco).

Por ejemplo, no te bases en la implementación eficiente que tiene CPython de concatenación in-place de strings en sentencias de la forma a+=b o a=a+b. Esas sentencias corren más despacio en Jython. En su lugar la forma ''.join() debe ser usada en bibliotecas, en las partes dónde la performance sea importante. Esto asegura que la concatenación ocurra en tiempo lineal en todas las implementaciones.

La comparación con singletons como None siempre debe hacerse con is o is not, nunca con los operadores de igualdad.

También tené cuidado al escribir if x cuando realmente querés decir if x is not None, por ejemplo al testear si a una variable o argumento que por defecto es None le fue asignado a otro valor. El otro valor puede tener un tipo (por ejemplo, un contenedor) que puede ser falso en un contexto booleado! (NdT: por ejemplo [] o {}).

Usá excepciones basadas en clases

Las excepciones basadas en strings en código nuevo deben desaparecer ya que esta característica del lenguaje fue eliminada en Python 2.6.

Los módulos o paquetes deben definir su propia clase base para exepciones específica de su dominio, la cual debe extender la clase built-in Exception. Siempre incluí un docstring a la clase, por ejemplo:

class MessageError(Exception):

"""Clase base para errores en el paquete mail."""

La convención para el nombramiento de clases se aplica aquí, aunque deberías agregar el sufijo 'Error' a tus clases de excepciones, si la excepción es un error. Las excepciones que no sean errores no necesitan un sufijo especial.

Al lanzar una excepción, usá raise ValueError('mensaje') en lugar de raise ValueError, 'message'.

La forma usando paréntesis es preferida porque cuando los argumentos de la excepción son largos o incluyen formateo de strings, no necesitás usar el carácter de continuación de línea () gracias al paréntesis. La forma vieja será quitada en Python 3000.

Al atrapar excepciones, mencioná la excepción específica cuando puedas, en lugar de usar la clausula except:.

Por ejemplo, usá:

try:

    import platform_specific_module

except ImportError:

    platform_specific_module = None

Una clausula except: atrapará las excepciones SystemExit y KeyboardInterrupt, haciendo que sea más difícil interrumpir al programa con Control-C, y puede traer otros problemas. Si querés atrapar todas las excepciones que señalan errores en el programa, usar except Exception:.

Una buena regla es limitar el uso de la clausula except: a dos casos:

1. Si el manejador de excepción estará imprimiendo o logeando el traceback; al menos el usuario se dará cuenta de que ocurrió un error.
2. Si el código necesita hacer algún trabajo de limpieza, pero después deja que la excepción se propague hacia arriba con raise. try...finally es la mejor forma de manejar este caso.

Adicionalmente, para todas las clausulas try/except, limitá la clausula try a la absolutamente mínima cantidad de código necesario. De nuevo, esto evita esconder bugs.

Si:

try:

    value = collection[key]

except KeyError:

    return key_not_found(key)

else:

    return handle_value(value)

No:

try:

    # Too broad!

    return handle_value(collection[key])

except KeyError:

    # Will also catch KeyError raised by handle_value()

    return key_not_found(key)

Usar los métodos de string en lugar del módulo string.

Los métodos de string son siempre más rápidos y comparten la misma API con los strings unicode. Sobreescribí esta regla si necesitás compatibilidad hacia atrás con versiones de Python menores a 2.0.

Usá ''.startswith() y ''.endswith() en lugar de rebanamiento de strings (string slicing) para checkear prefijos y sufijos.

startswith() y endswith() son más limpios y menos propensos a errores. Por ejemplo:

Si: if foo.startswith('bar'):

No: if foo[:3] == 'bar':

La excepción es sin tu código debe funcionar con Python 1.5.2 (pero esperemos que no!).

La comparación entre tipos de objetos debe usar siempre isinstance() en lugar de comparar tipos directamente.

Si: if isinstance(obj, int):

No: if type(obj) is type(1):

Al chequear si un objeto es un string, recordá que hay strings Unicode también! En Python 2.3, str y unicode tienen una clase base común, basestring, así que podés hacer:

if isinstance(obj, basestring):

En Python 2.2, el módulo types tiene el tipo StringTypes definido para ese propósito, por ejemplo:

from types import StringTypes

if isinstance(obj, StringTypes):

En Python 2.0 y 2.1, tenés que hcaer:

from types import StringType, UnicodeType

if isinstance(obj, StringType)

o

isinstance(obj, UnicodeType) :

Para secuencias, (strings, listas, tuplas), hacé uso del hecho de que las secuencias vacías tienen valor de verdad falso:

Si:

if not seq:

if seq:

No:

if len(seq):

if not len(seq):

No escribas strings literales que hagan uso de espacios en blanco al final de una línea. Esos espacios en blanco son visualmente indistingibles y algunos editores (o más recientemente, reindent.py) los eliminan.

No compares valores booleanso con True o False usando ==.

Si:

if greeting:

No:

if greeting == True:

Peor:

if greeting is True:

Fuente: http://www.pythonsantafe.com.ar/inter-s-educativo-provincial-2008

Las listas por comprensión o list comprehension es una característica muy práctica de Python (también incluida en otros lenguajes de programación). Es una herramiente de mucha utilidad y fácil de usar, muchas veces desconocida por quienes vienen de lenguajes como PHP o Java.

Este artículo tiene como objetivo explorar su uso y plantear ejemplos para que los nuevos usuarios puedan incorporarlas rápidamente a su cajita de herramientas.

Cómo lo indica el PEP 202, es una construcción sintáctica que permite crear listas en situaciones en las que se usaría map, filter o for anidados; pero de forma mas concisa.

map

Al llamar a la función map con argumentos f y l ,dónde f es una función y l una lista, retorna una lista con los resultados de aplicar f a cada elemento de l.

En el primer ejemplo usamos la función len, que dado un string retorna su longitud:

>>> len('hola')

4

Esto es lo que sucede al aplicar map a todos los elementos de una lista de palabras:

>>> palabras = ['uno', 'dos', 'Santa Fe', 'Python', '...', 'Soleado']

>>> map(len, palabras)

[3, 3, 8, 6, 3, 7]

La versión equivalente es:

>>> [len(p) for p in palabras]

[3, 3, 8, 6, 3, 7]

La sintaxis de la listas por comprensión es más flexible. Si queremos la lista de palabras, pero en mayúsculas hacemos:

>>> [p.upper() for p in palabras]

['UNO', 'DOS', 'SANTA FE', 'PYTHON', '...', 'SOLEADO']

Para hacer lo anterior utilizando la función map, antes tendríamos que definir una función que llame al método upper de la clase string:

>>> def upper(s):

    return s.upper()

>>> map(upper, palabras)

['UNO', 'DOS', 'SANTA FE', 'PYTHON', '...', 'SOLEADO']

filter

La función filter recibe como argumento una función f y una lista l. Al igual que map, aplica f a todos los elementos de l pero retorna una lista con los elementos de l para los cuales la función f retornó True o un objeto con valor de verdad True.

>>> def incluye_n(s):

    return 'N' in s.upper()

>>> incluye_n('Python')

True

>>> incluye_n('Soleado')

False

>>> filter(incluye_n, palabras)

['uno', 'Santa Fe', 'Python']

La forma de hacer lo anterior con listas por comprensión es:

>>> [p for p in palabras if incluye_n(p)]

['uno', 'Santa Fe', 'Python']

Incluso muchas veces podemos hacerlo sin necesitar de definir una función auxiliar:

>>> [p for p in palabras if 'N' in p.upper()]

['uno', 'Santa Fe', 'Python']

for

También podemos anidar fors de forma similar a cómo lo haríamos en:

>>> range(6)

[0, 1, 2, 3, 4, 5]

>>> for n in range(6):

for p in palabras:

    if len(p) == n:

        print p,n

uno 3

dos 3

... 3

Pero con una sintaxis más cómoda:

>>> [(p,n) for n in range(6) for p in palabras]

[('uno', 0), ('dos', 0), ('Santa Fe', 0), ('Python', 0), ('...', 0), ('Soleado', 0), ('uno', 1), ('dos', 1), ('Santa Fe', 1), ('Python', 1), ('...', 1), ('Soleado', 1), ('uno', 2), ('dos', 2), ('Santa Fe', 2), ('Python', 2), ('...', 2), ('Soleado', 2), ('uno', 3), ('dos', 3), ('Santa Fe', 3), ('Python', 3), ('...', 3), ('Soleado', 3), ('uno', 4), ('dos', 4), ('Santa Fe', 4), ('Python', 4), ('...', 4), ('Soleado', 4), ('uno', 5), ('dos', 5), ('Santa Fe', 5), ('Python', 5), ('...', 5), ('Soleado', 5)]

>>> [(p,n) for n in range(6) for p in palabras if len(p) == n]

[('uno', 3), ('dos', 3), ('...', 3)]

mini-lisp, una implementación pediátrica de Lisp que hice para practicar ply tiene a partir de ahora su código revisionado en: http://svn.juanjoconti.com.ar/lisp

Auditorio de la UTN FRSF, Lighting Talks desarrollándose (5 minutos por disertante para explicar ALGO).

Tuvismos:

<li>Haciendo plata con Software Libre - John Lenton</li>

<li>Python LEX &amp; YACC - Yo</li>

<li>KSS -  Silvestre Huens</li>

<li>svn +Track en USLA - David Casco</li>

<li>Decoradores en Python -  Facundo Batista</li>

<li>Fabián Ezequiel Gallina - Python-mode para Emacs</li>

<li>Procesando Imágenes con Python - Esteban Peiro</li>

<li>Reply (aprendizaje por refuerzo) - Lucio Torre y Ricardo Kirkner</li>

<li>Defendiendo al Software Libre - Calos Miranda Bonina</li>

<li>Creación colaborativa de empresas -  Leandro Monk</li>

<li>PyWars - <span style="text-decoration: line-through;">Arturo Díaz Santor</span> Arturo Elias Antón</li>

<li>Historia de conferencias de Python / PyCON Ar - Facundo Batista</li>

(Si le escribí mal el nombre a alguno, avise!)

Fin del post, el resto del día incluye: sorteos, entega de certificados y luego un sprint gastronómico.

Saludos!

Bonus Track: Una fotito del mediodía

El próximo 4 de Octubre se llevará a cabo en instalaciones de la Universidad Tecnológica Nacional, Facultad Regional Santa Fe, la 3ra Jornada Python en Santa Fe [1]. Orientadas a programadores y profesionales de sistemas, estudiantes y público en general interesado en la programación, los invitamos a participar registrándose en nuestra web [2]. La asistencia es libre y gratuita.

Esta jornada consiste en una serie de charlas relacionadas con el lenguaje de programación Python. Ya está disponible el programa del evento [3].

¿Qué es Python?

Python es un lenguaje de programación interpretado, dinámico y orientado a objetos que puede ser utilizado en diferentes desarrollos de software y en múltiples plataformas. La característica de ser multiplataforma es algo muy interesante para los desarrolladores. El lenguaje se encuentra soportado en Unix, GNU/Linux, Widows/DOS, Macintosh… y la lista sigue. Desde grandes mainframes a pequeñas Palm. En la web oficial [4] del lenguaje encontrará mayor información y mucha documentación.

Y en el país existe una comunidad de desarrolladores muy fuerte, agrupada en PyAR, Python Argentina [5].

¿Quién utiliza Python?

La NASA, Google, Yahoo, Walt Disney y Red Hat son algunas de las grandes organizaciones que trabajan con este lenguaje. Google contrató a su creador, Guido van Rossum. En la mayoría de las distribuciones GNU/Linux encontramos Python ya instalado (se usa mucho como lenguaje de script para automatizar tareas). Y en el país también hay numerosas empresas que trabajan con Python: Lunix, Except, Lambda Sistemas, etc.

Recuerden registrarse [2] y los esperamos el 4 de Octubre!

[1] Web de la jornada: www.pythonsantafe.com.ar

[2] Registración: www.pythonsantafe.com.ar/registracion

[3] Programa: www.pythonsantafe.com.ar/programacion

[4] Web del lenguaje: www.python.org

[5] PyAR: www.python.com.ar

Inteligencia Artificial -un enfoque moderno-, el libro del que estoy estudiando tiene muchos de los algorítmos que explica en pseudo código implementados en Python.

Uno de los autores cuenta que originalmente estaban escritos en Lisp, pero muchos estudiantes tenían problemas con este lenguaje. En especial, saltar del pseudo código del libro a una implementación que corra en sus computadoras. El primer intento fue usar Java, pero no tuvieron éxito:

However, one attempt at getting Java code up and running was largely unsuccesful. Then I discovered Python and Jython, and thought this might be a better way to go than Java.

cita