Hace un tiempo me presentaron lo que se ha convertido en mi lenguaje de programación/scripting favorito: Python. Es difícil para un desarrollador de lenguaje encontrar algo que sea poderoso y fácil de escribir, algo que fluya naturalmente y le permita concentrarse en lo que es importante en su código. Python hace esto maravillosamente. Hace los tipos correctos de suposiciones, lo que le permite concentrarse más en lo que debe hacer su programa en lugar de cómo debe hacerse exactamente. No hay que preocuparse por la gestión de la memoria, la escritura de variables o esos malditos puntos y comas, simplemente mantenga su mente en la lógica de su aplicación.
Python se desvía bastante de algunos de los lenguajes más tradicionales como C/C++, encajando mejor con los lenguajes dinámicos como Ruby, Smalltalk e incluso Javascript. La capacidad de terminar rápida y fácilmente tareas complejas en Python incluso ha sido objeto de algunos grandes web historietas.
Nota: Python es un lenguaje interpretado, el intérprete se puede descargar aquí. Todos los ejemplos de esta guía están escritos para Python 3.0, que es NO Totalmente compatible con versiones anteriores. Si tiene problemas para ejecutar los ejemplos, verifique su versión de Python.
Ejecutando los ejemplos
Incluiré varios ejemplos a lo largo de esta guía. Una vez que haya instalado el intérprete de Python 3 (asegúrese de que sea Python 3), el código se puede ejecutar de dos maneras:
Archivo de comandos
Puede copiar/pegar el texto completo del código de ejemplo en un archivo de texto. Los archivos de Python normalmente terminan en .py. Abra su símbolo del sistema y ejecute el ejecutable de Python seguido del nombre del archivo. En mi máquina Linux, ejecuto:
Esto también debería ser más o menos igual en Windows y Mac, aunque es posible que deba especificar la ruta completa al intérprete de Python, como
C:\Python30\python.exe myfile.py
Intérprete interactivo
Python también se puede ejecutar en modo interactivo, donde puede escribir comandos uno a la vez para ver cómo responde. Esto puede ser muy útil para solucionar problemas o para probar cosas nuevas. Ejecute el ejecutable de Python por sí solo, sin ningún archivo de secuencia de comandos, y se abrirá el indicador interactivo.
Ctrl + D saldrá del intérprete.
Espacio en blanco
Uno de los aspectos más inusuales de Python es el uso de espacios en blanco para indicar bloques de código. En lugar de comenzar y finalizar, o agrupar por corchetes, Python usa la cantidad de sangría para indicar cómo manejar bloques de código para bucles y demás. Para muchas personas que vienen de otros lenguajes de programación, esto parece una locura. Sin embargo, una vez que te acostumbras a la idea, se vuelve bastante natural y obliga a que tu código sea claro y legible. Todos sangramos los bloques de código de todos modos (o al menos deberíamos), por lo que tiene sentido que el lenguaje comprenda que las declaraciones todas alineadas juntas son parte del mismo bloque.
Como beneficio adicional, Python no es exigente con la cantidad de sangría que le gusta, o incluso si prefiere tabulaciones o espacios. Puede usar una pestaña, un espacio, dos espacios, 137 espacios, a Python no le importa. Todo lo que necesitas hacer es ser consistente. Verificará su código y verá «El primer bloque de código tiene una sangría de 4 espacios, así que asumiré que cada bloque tiene una sangría de otros 4 espacios» o cualquiera que sea el caso. Siempre que sea consistente en la forma en que aplica sangría a su código, Python es lo suficientemente flexible como para comprenderlo. El siguiente ejemplo puede ayudar a aclarar las cosas.
x = 0
while x < 10:
print(x)
x += 1
print("All done")
Desglose del código: los while loop le dice a Python que ejecute el siguiente bloque de código siempre que se cumplan ciertas condiciones. En este caso, la condición es que x sea menor que 10. Continuará recorriendo ese bloque hasta que x llegue a 10. El x += 1 se traduce a x = x + 1 o «hacer x más grande en 1». Observe que la línea final no se ejecuta hasta que while el bucle está terminado. Python ve las líneas sangradas y las trata como el grupo de código que se ejecutará en cada viaje a través del bucle while. La línea final no está sangrada con las demás, por lo que Python no actúa sobre ella hasta que la while el bucle está terminado.
Escritura dinámica
Python no requiere que defina qué tipo de datos habrá en una variable. Puedes poner un número entero, una cadena, un decimal, lo que quieras en una variable sin tener que decirle a Python qué es. Python averiguará, en función de lo que asigne, qué tipo de datos debe contener esa variable. El siguiente ejemplo debería demostrar:
x = 0
print("x is a: ",type(x))
x = 3.14
print("x is a: ",type(x))
x = "Hello"
print("x is a: ",type(x))
x = [1,2,3,4]
print("x is a: ",type(x))
Lo que nos da la salida a continuación.
Estructuras de datos
Las tres estructuras de datos que usará más comúnmente en python son
- Liza
- tuplas
- Diccionarios
Liza
se parecen mucho a las matrices en algunos otros idiomas. Son una secuencia unidimensional de elementos (aunque técnicamente puedes darles tantas dimensiones como quieras). Cada elemento de esa lista se puede cambiar, mover y eliminar a voluntad sin tener que volver a crear la lista y sin causar ningún cambio en los demás elementos. Las listas pueden contener cualquier objeto de Python, ya sea un número, una cadena o incluso otras listas. El siguiente código muestra algunos usos básicos de las listas.
#create a list with a few sample items
myList = [1,2,3,4,5]
#len() gives a count of how many items our list holds
print("myList has ", len(myList), " items.")
#The items in a list don't have to be of the same type
myList.append("six")
myList.append("seven")
myList.append(8)
#We've appended three new items to the end of the list
print("myList now has",len(myList), " items.")
#Now let's see item number 0 (first item)
print("first item:", myList[0])
#and now the fourth item
print("fourth item:",mylist[3])
#Then pop the last item out of the list
print("and ends with" , myList.pop())
print("myList now has",len(myList), " items.")
#And see what we've done
print("The complete contents are:", myList)
tuplas
No cubriré mucho las tuplas, ya que no se usarán en nuestro programa de ejemplo y son similares a las listas en muchos aspectos. Las tuplas, como las listas, son una serie de elementos agrupados. La diferencia es que las tuplas no son mutables. No puede realizar cambios en el lugar en los elementos de una tupla, debe volver a crear la tupla. Esto significa que no hay «agregar» o «abrir» u otras cosas que hagan cambios directamente en el contenido de la tupla. Si ayuda, puede pensar en las tuplas como una lista de solo lectura (aunque eso no es muy preciso).
Diccionarios
Estos, me encantan. Cuando me enseñaron por primera vez sobre diccionarios, recuerdo haber pensado algo como «Bueno… SUPONGO que podría ser útil… a veces». En una semana, los usé cada vez que tuve la oportunidad.
En Python, los diccionarios son pares clave:valor. Es como una lista, excepto que cada elemento tiene dos partes, una clave y un valor. En el siguiente ejemplo, voy a hacer un diccionario para contener información sobre mí.
myDict = {}
# Key Value
myDict["Name"] = "Josh"
myDict["Occupation"] = "Computer Geek"
myDict["FavFood"] = "Hani Special (no lettuce)"
myDict["FavBand"] = "Anything but the B-52s"
myDict["Heroes"] = "Tom Waits, Kurt Vonnegut, SpaceBat"
myDict["FavNumber"] = 3.141592
myDict[42] = "It's also a good number"
print("My name:", myDict["Name"])
print("My heroes:", myDict["Heroes"])
print("My favorite number:", myDict["FavNumber"])
print("What do I think of 42?", myDict[42])
print()
# Now I'll change my favorite number without creating a
# whole new dictionary
myDict["FavNumber"] += 100
print("My NEW favorite number:",myDict["FavNumber"])
Algunas cosas deben quedar claras a partir del ejemplo. Primero, los diccionarios pueden mezclar y combinar datos de cualquier tipo. Tus claves y valores pueden ser de cualquier cosa. Incluso puede volverse realmente loco y poner cosas como funciones dentro de los diccionarios, pero eso está más allá del alcance de esta guía.
En segundo lugar, los diccionarios son mutables. Puede agregar y eliminar elementos sobre la marcha sin volver a crear el diccionario ni afectar a otros elementos.
Si aún no está seguro de la utilidad de los diccionarios, considere usarlos para rastrear la configuración de un usuario. Podría tener un diccionario llamado configuración y almacenar cosas como nombre de usuario, dirección IP y resolución de pantalla. Cada vez que necesite hacer referencia a esos datos, puede extraerlos de la configuración[«username»]o cualquier otra clave que haya especificado.
Llévatelo todo a casa
Ahora vamos a pasar a la acción real, creando un programa Python 3.0 útil. Lo que hará este programa es tomar un número que representa dinero y decirle cuánto cambio de bolsillo generaría esa cantidad. Es un ejercicio de codificación bastante común y es una buena manera de demostrar los conceptos que hemos cubierto hasta ahora.
Debo decirte ahora que este programa NO se va a escribir de la «mejor» manera, mi objetivo es escribirlo usando los conceptos y operaciones más básicos posibles. Hay varias formas «mejores» de escribir esto, como usar funciones y el operador de módulo, e incluir la verificación de errores, pero esta versión debería ser bastante fácil de entender.
#Get the cash amount
total = input("Enter cash amount in dollars: $")
#Reading from text input assumes text, so convert
#to decimal and multiple by 100 so we can count pennies
#(simpler math that way)
pennies = float(total) * 100
#create dictionary to hold our change values
change = {"quarters" : 0,
"dimes" : 0,
"nickels" : 0,
"pennies" : 0}
#Loop until all money has been accounted for
while pennies > 0:
#Subtract each coin from the total, add 1 to count
#for each coin, and restart loop after counting
if pennies >= 25:
change["quarters"] += 1
pennies -= 25
continue
elif pennies >= 10:
change["dimes"] += 1
pennies -= 10
continue
elif pennies >= 5:
change["nickels"] += 1
pennies -= 5
continue
else:
change["pennies"] = int(pennies)
pennies = 0
#Finally, print our results
print("Q:",change["quarters"])
print("D:",change["dimes"])
print("N:",change["nickels"])
print("P:",change["pennies"])
Desglose del código: estamos usando input para obtener una cantidad de dinero desde la línea de comando. Python asume que lo que se ingresa es una cadena de texto, en lugar de un número, por lo que debemos decirle que convierta esa entrada en un número utilizable. Podríamos haber dejado el número solo (es decir, 15,95), pero lo convertimos a centavos (multiplicando por 100) para simplificar las matemáticas y no tener que preocuparnos por los puntos decimales.
A continuación, creamos un diccionario para contener los resultados de nuestra computación. Si este fuera un programa más complejo, podríamos pasar ese diccionario a nuestras funciones, clases, etc. sin preocuparnos por mantener un registro de variables separadas para cada tipo de moneda.
Después de eso viene el verdadero trabajo: el acto de dividir el total de nuestro dinero en monedas individuales. Este programa utiliza un while bucle para seguir ciclando hasta que no nos quede dinero de nuestra entrada original. Cada viaje a través del bucle mira la cantidad de dinero, resta la moneda más grande que pueda y reinicia el bucle. En lugar de hacer restas una y otra vez, este programa probablemente sería mucho más eficiente si hubiéramos usado el operador de módulo, pero la resta es más fácil de entender.
Una vez que hayamos terminado con el ciclo, todo lo que queda por hacer es mostrar nuestros resultados.
Python es capaz de MUCHO más de lo que podría cubrir aquí, pero espero haber podido demostrar los conceptos básicos de cómo funciona y cómo se puede usar para crear rápida y fácilmente herramientas que serían mucho más complicadas en un Lenguaje menos intuitivo.