Introducción a Python (trabajando en él)

El código escrito en python, dada su siplicidad, es muy similar a la solución en lenguaje algorítmico del  del problema que deseamos resolver. Es así muy encertado pensar en python como pseudo-código.

Shell, la consola interactiva.

Un de las grandes bazas de python, es la posibilidad de probar trozos de código de forma interactiva, gracias al interprete interactivo que incorpora. Si ejecutamos python en una consola de un entorno unix, o ejecutamos la aplicación “Python(comand line)” en Windows el resultado es el siguiente:

Python 2.5.4 (r254:67916, Dec 23 2008, 15:10:30) [MSC v.1310 32 bit (intel)] on win 32
Type “help”, “copyright”, “credits”, or “license” for more information
>>>

La Shell de Python es un muy buen lugar para aprender muchas de las características del lenguaje. Se pueden ejecutar operaciones directamente.

>>> 2+5
7
>>> 4-3
1

Los ejemplos de los siguientes capítulos serán tratados directamente en la Shell.

Asignación de variables.

La asignación se realiza mediante el operador “=”. Se pueden asigar una o varias variables a la vez:

>>> x = “qwerty”
>>> x,y,z = 1,2,3
>>> a = b = 123

En la asignación de las variables hay ciertas reglas: los identificadores deben de empezar por alguna letra de la tabla ascii y ni pueden ser ninguna de las siguientes palabras reservadas por Python:

and, del, fo, is, raise, asser, elif, from, lambda, return, break, else, global, not, try, class, except, if, or while, continue, exec, import, pass, yield, def, finally, in, print.


Tipos de variable simple.

Una variable es un conjunto de bits situados en memoria, para saber donde se encuentran se encuentran indexados por un identificador. Lo  que distingue a la variable de otra es el identificador, no el contenido de la misma.

Números

Python nativamente soporta cuatro tipos de números:

• int(enteros)
• long(enteros largos)
• float(reales de coma flotante)
• complex(complejos)

Los más utilizados en el proyecto serán los reales de coma flotante “float”, y los enteros “int”. Utilizando las funciones internas de Python con el mismo nombre se puede cambiar la tipología del número. Es de importancia anotar que en los reales de coma flotante el punto marca el inicio de los decimales.

>>> entero = 12
>>> flotante = float(entero)
>>> flotante

Python dispone para los numerales de las operaciones aritméticas más habituales:

Operación Operador

Suma                                 +
Resta                                 -
Exponenciación                **
Multiplicación                    *
División                              /
Módulo (o resto)                %

>>> 3+5
8
>>24-27
-3
>>> 3*4
12
>>> 25.4/4
6.3499999999999996
>>> 2**3
8
>>> 17 % 2
1
>>> a = 2
>>> b = 6.4
>>> 34*(a+b)
285.6000000000002

Cadenas

Python identifica cualquier carácter envuelto con comillas simples o dobles como una cadena “str”. Las cadenas se pueden cortar, concatenar e incluso concatenar consigo mismo varias veces.

Concatenar entre ellas y consigo mismas:

>>> nombre = “Juan”
>>> apellido = “Salgado”
>>> frase = “Se llama ” + nombre + “ ” + apellido
“Se llama Juan Salgado”
>>> a = “Pedro”
>>> repetido = a*5
>>> repetido
PedroPedroPedroPedroPedro

Cortar porciones de una cadena, el llamado slicing, es un procedminento muy útil en le programación. Se debe tener siempre en cuenta que se empieza a contar desde [0], enonces pués el carácter [1] de la cadena será el segundo. Con unos ejemplos se entiende muy bien el concepto.

>>> cadena = “Manzana”
>>> cadena [3]
“z”
>>> cadema[2:6]
“nzan”

A observar que el índice final no se incluye en el resultado. Si se omite uno de los índices se supone que se quiere obtener todo en la dirección correspondiente. Esto es, “lista[:3]” quiere decir “cada elemento desde el principio de lista hasta el elemento 3, no incluido”. (se podría decir en realidad el elemento 4, ya que contamos desde 0). “lista[3:]” significaría, por otra parte “cada elemento de lista, empezando por el 3 (inclusive), hasta el último”. Se pueden utilizar números negativos para obtener resultados muy interesantes: “lista[-3]” es el tercer elemento desde el final de la lista.

Cabe destacar que Python distingue entre mayúsculas y minúsculas. Algo que hasta el momento ha tenido relativa importancia la tendrá, mucho, a partir de ahora y es una de las principales causas de errores en los primeros scripts.

Valores lógicos.

Primeramente se ha de averiguar qué valor en álgebra de bool se le atribuyen a los objetos de python. Para ello se puede utilizar la función interna bool().

Los valores falsos de los tipos de variable conocidos hasta ahora:

>>> bool(False)
False
>>>bool(None)
False
>>> bool(0)
False
>>> bool(“”)
False

Los valores verdaderos:

>>> bool(True)
True
>>> bool(1)
True
>>> bool(“Juan”)
True

Operadores de comparación.

Además del valor booleano de una variable se puede calcular el valor booleano de un conjunto de ellas.

Operación Operador

Más grande que                            >
Más grande o igual que                >=
Más pequeño que                         <
Más pequeño o igual que              <=
Igual que                                       ==
Diferente que                                !=

Estas operadores pueden interactuar tanto con variables de tipo numeral como con cadenas. Con estás últimas los cuatro primero carecen de gran importancia y utilidad, salvo casos muy específicos, por lo tanto no se explicarán.

>>>  2 > 3
False
>>> 4 > 3
True
>>> 5 >= 5
True
>>> 9 <= 16
True
>>> 1 == 1
True
>>> “juan” == “juan”
True
>>> “juan” != “pedro”

Operaciones condicionales.

Una vez conocido que valor en álgebra de bool tiene cada variable  o conjunto de ellas se pueden utilizar con los operadores condicionales.

Operación Operador

Y                                       and

O                                        or

Negación                           not

and solo devuelve True como resultado si las dos premisas con las que opera son True.

or devuelve True si alguna de las premisas, o las dos, son True.

not invierte el valor de entrada.

>>> 4 > 3 and 8 == 4+4
True
>>> False and True
False
>>> not(8 == 4) and 7 == 7
True
>>> True or True
True
>>> True or False
True
>>> not(True) or False
False

Guardar los scripts

La Shell de python es realmente útil para el testeo y el aprendizaje del lenguaje, para utilizarlo como calculadora interactiva. Exige sin embargo de escribir el programa cada vez que se tiene que utilizar, algo no muy útil para tareas repetitivas. Python nos permite guardar los programas en archivos de texto plano para su posterior ejecución.

Al ser multiplataforma el mismo script debería de poderse ejecutar en todos los sistemas que tuvieran un intérprete python. Por convenio los archivos de scritps python tienen la terminación “.py”.

Dependiendo del sistema operativo en el que se encuentre el script la forma de ejecutarlo puede ser distinta o no, por ejemplo, en el sistema operativo Windows basta con clicar encima del mismo para que se ejecute, en la consola de entornos unix seria:

$ python nombre_del_script.py

Cabe señalar que la cabecera de un script en python deveria incluir el path del programa que lo ha de ejecutar (para entornos unix), y , si se necesitan caracteres especiales como acentos, la codificación que se desea utilizar. Para los hispano hablantes y todas las lenguas que utlizan la misma codificación:

#!/usr/bin/env python
# encoding: utf-8

Por ahorro de espacio a partir de ahora se no escribirá esta cabezera al principio de los scripts, aunque en todos sea necesario.

Salida de datos, sentencia print.

Hasta el momento al trabajar con la Shell interactiva de Python bastaba con escribir el identificador de la variable para que ella devolviera el valor. Al guardar el script en un archivo se hace necesario un mecanismo que pueda mostrar valores de variable. Python dispone de la sentencia print, que imprime el valor por pantalla.

#!/usr/bin/env python
# encoding: utf-8

a = “Juan”
multiplicador = 5
print a*multiplicador

Al ejecutar el script, mostrará: JuanJuanJuanJuanJuan

Es posible imprimir diferentes variables en la misma línea de la pantalla.

#!/usr/bin/env python
# encoding: utf-8

a = “tomate”
b = “pan”
c = “sal”
print “Necesitamos ”, a, “ ”, b, “ y ”, c

Mostrará: Necesitamos tomate pan y sal

Los usuarios Windows tienen el problema de que el mensaje es mostrado y la ventana cerrada tan rápidamente que no da tiempo tansiquiera a poder verlo. Una solución es poner al final la sentencia raw_imput(), que detendrá el script hasta que el usuario presione “enter”.

#!/usr/bin/env python
# encoding: utf-8

a = “Juan”
multiplicador = 5
print a*multiplicador
raw_imput()

Mostrará: “JuanJuanJuanJuanJuan”, esta vez esperando a que el ususria pulse “enter” para cerrar la ventana.

Entrada de datos, la función interna raw_input().

Los programas necesitan de cierta interación con el usuario, necesitan recibir datos. “raw_input()” detendrá en programa esperando la entrada de datos y la confirmación. Dos ejemplos muy sencillos:

#!/usr/bin/env python
# encoding: utf-8

nombre = raw_input(“Escriba su nombre :”)
print “Hola ”,nombre
raw_imput()

Este script pedirá el nombre y saludará a ese nombre.

#!/usr/bin/env python
# encoding: utf-8

print “si me das números los multiplico”
primer = raw_input(“Escriba el primer número: ”)
segundo = raw_input(“Escriba el segundo número: ”)
print “El resultado es “,primer*segundo</li>

Comentarios

Como bien sabe cualquier programador, el código siempre es más veces leído que escrito. Los comentarios ayudan a la comprensión de código. Tanto entre programadores diferentes como con un mismo, un programa desarrollado años atrás debe estar correctamente comentado para poder recordar como funcionaba. El comienzo de los comentarios es marcado por el carácter “#”.

#!/usr/bin/env python
# encoding: utf-8

x = “pan” # esto es un comentario
# esto también es un comentario

Bloques de código

Un programa no solo es una serie de instrucciones una seguida de la otra, un programa ha de pe permitir variar las operaciones entre las variables dependiendo de una serie de premisas, en este punto entran en juego los condicionales y los bloques de código.

En python los bloques de código se separan por niveles de indentación. Esto quiere decir que si un bloque de código no se encuentra con un bloque de código de nivel superior se ejecutará íntegro.

Sentencias if, elif, else.

Para que el programa pueda decidir  qué bloque ejecutar, dependiendo de un valor condicional disponemos de las construcciones if, elif, else.

#!/usr/bin/env python
# encoding: utf-8

a = raw_input(“Escriba el primer número: ”)
b = raw_input(“Escriba el segundo número: ”)
if a > b:
	print a, “ es más grande que ”, b
elif b > a
	print b, “ es más grande que ”, a
else:
	print “Me diste dos números iguales”

La línea 4 es equivalente a: si a es mayor que b, ejecuta lo que tengo debajo de mi nivel de indetación. La línea 6 solo se ejecuta en caso de que el primer if diera falso. El else es equivalente a: si ninguno de los condicionales anteriores ha dado cierto ejecuta las sentencias que tengo dentro de mi nivel de indentación.

Siempre ha de haver una primera sentencia if, tantas sentencias elif como se quieran y un solo else final opcional.

Tipos de variable complejas, colecciones.

Listas

Un tipo de colección de datos que pone Python a disposición del programador es la lista, la lista es una simple colección de otras variables, sean del tipo que sean, incluso otras listas. Las listas están se forman con “[“ ,“]”.

>>> nombres = ["pedro", "juan"]

>>> x = [[1,2,3],[y,z],[[[]]]]

Las listas permiten indexado, corte i concatenación al igual que las cadenas.


>>> nombre = ["pedro", "juan"]
>>> nombre[1], nombre[0]
"juan pedro"
>>> comida = ["pan","pan","pan","huevos","y","pan"]
>>>comida[3:7]
["pan","y"]
>>> comida[3:7]+[“tomate”, “cerveza”]
[“pan”, “y”, “tomate”, “cerveza”]


Pero la caracterísitca más destacada, y de las más útiles, de las listas es la mutabilidad. Se puede cambiar el valor de cualquiera de los índices, se pueden eliminar y añadir elementos.

>>> comida = ["pan","pan","pan","huevos","pan"]
>>> comida[1] = “tomate”
>>> comida
["pan","tomate","pan","huevos","pan"]
>>> comida.append(“aceite”)
>>> comida
["pan","tomate","pan","huevos","pan", “aceite”]


Tuplas

Las tuplas son colecciones de datos al igual que las listas, con una única diferencia, no son mutables. Esto está compensado por su velocidad, mucho mayor que el de las listas. Las tuplas se crean con las comas, el paréntesis es un simple convenio.

>>> cadena = (“tomate”)
>>> cadena
“tomate”
>>> tupla = “tomate”,
>>> tupla
(“toamte”,)


Funciones

El próximo paso es la abstracción. Englobar un procedimiento para que pueda ser utilizado tantas veces como se quiera, se quiere definir una función.

#!/usr/bin/env python
# encoding: utf-8

def cuadrado(x):
	return x*x

print cuadrado(2)

Mostrará: 4

La línea primera línea se crea la función, con el  dato de entrada. En la segunda línea la función junto a la palabra clave “return”, que para la ejecución para devolver un resultado, se define el procedimiento.

Algo que podría resultar interesante conocer, sin embargo, es que las funciones son valores en Python. Así que, si tiene una función como “cuadrado”, podría hacer cosas como:

#!/usr/bin/env python
# encoding: utf-8

def cuadrado(x):
	return x*x
cosa = cuadrado
print cosa(2)

Mostrará: 4

Bucles

En algo en que los ordenadores son mejores que las personas, es en repetir la misma acción infinidad de veces con la misma precisión. Si se quiere repetir un proceso X veces serán muy útiles las construcciones con lso bucles while y for in.

While

Como su nombre indica (mientras) reiniciará el bucle mientras el resultado de su operación sea verdadero:

#!/usr/bin/env python
# encoding: utf-8

a = 0
while a >= 10:
    print a
    a = a+1

Mostrará todos los números del 0 al 10

For in:

#!/usr/bin/env python
# encoding: utf-8

for valor in [valor1,valor2,valor3]:
    print valor

Muestra uno a uno los valores de la lista.

Para poder hacer bucles sobre valores numéricos tenemos la función “range(n)”, siendo n el número de valores.

Ejemplo:

#!/usr/bin/env python
# encoding: utf-8

for valor in range(10):
	print valor

Esto imprime 10 valores, desde el 0 hasta el 9.

Continuidad.

Como mi trabajo de investigación no se empezó un día concreto, para conseguir una nota concreta, no tendrá un día concreto de final de desarrollo. Este blog contendrá las actualizaciones del juego completo, más pequeñas muestras de lo aprendido: antes, durante y despúes del redactado del trabajo.