Como les decía anteriormente, ahora vamos a dar una sucinta revisión a los “ingredientes” de un programa en Python. Así como en las recetas de cocina son necesarios distintos ingredientes (te desafío a preparar algo con sólo “un” ingrediente). En Python a estos ingredientes, los llamaremos variables.

>>> 2 + 2
4
>>>

¡Sorpresa! El intérprete de Python puede funcionar como una calculadora. Aprovecho de mostrarte los signos que puedes utilizar:

Operador	Descripción
+	Suma
-	Resta
*	Multiplicación
**	Exponente
/	División
//	División entera
%	Módulo (en Chile conocido  como “resto”)

>>> 2**3
18
>>> 10 % 3
1

(3 por 3 nueve, a 10, uno)

La división merece una mención aparte, pero lo veremos en la siguiente sección. Demás está decir la diferencia entre 2 + 3 * 4 y (2 + 3) * 4. Pero esto no es una clase de matemáticas, así que no me detendré en este punto.

Variables

>>> x = 1
>>>

Por mucho que se parezca a una ecuación matemática (no, no huyas, es mucho más simple). La verdad es que el signo “=”, no es realmente el “igual a”. Lo que realmente está haciendo es asignando, siendo específico, con una asociatividad de derecha a izquierda (el valor a la derecha del signo “=”; 1, se asocia al de la izquierda; x. Y no al revés, es decir que: x = 1 no es igual a 1 = x). Esto puede parecer una exquisitez, pero muy pronto veremos lo relevante que es entender esta diferencia. Otra cosa, si te diste cuenta la asignación no entrega ningún mensaje. Al igual que en los intérpretes en *nix, es una buena señal, o bueno, por lo menos, no hay un error.

>>> x + 1
2
>>>

Nota: Para el nombre de las variables puede utilizarse cualquier caracter alfanumérico y el underscore (guión bajo: “_“), es importante si tomar en cuenta que no puede comenzar con un número y es sensible a las mayúsculas, es decir que, variable, es distinto de VARIABLE, de Variable o VaRiAbLe. Por motivos obvios (y de sanidad mental) recomendaría no utilizar. Algunos programadores usan la primera letra mayúscula, por ejemplo PrimerNombre, otros primer_nombre. No importa cuál ocupes, pero recomiendo que sea cuál sea el que escojas, siempre utilices el mismo y que el nombre de las variables -ojalá- se explique por si mismo.

Las variables podemos dividirlas (básicamente) en tipos, a saber:

• Números (y sus respectivos conjuntos)
• Cadenas de textos (strings,[str]) y,
• Valores booleanos (es decir, de true (verdadero) y false (falso))

Bueno, vamos y creemos algunas:

>>> numero = 1
>>> decimal = 0.1
>>> numero_grande = 2**32
>>> caracter = "c"
>>> cadena = "soy una cadena"

Nota: Como Python proviene de un país de habla inglesa utiliza el punto (.) en vez de la coma (,) para dividir decimales como lo hacemos en Chile y -creo- los países de lengua castellana.

A diferencia de otros lenguajes de programación, en Python no es necesario declarar el tipo de variable al inicializarla. En C C++ por ejemplo para el ejemplo anterior debería haber escrito:

int numero = 1;
double decimal = 0.1;
char caracter = "c";
string cadena ="soy una cadena";
bool booleano = true;

Tipos de Números

Enteros (int) y flotantes (float)

>>> numero = 1
>>> type(numero)
>>> decimal = 0.1
>>> type(decimal)

Por defecto, cualquier número ingresado en Python lo hace como entero (integer; int) lo que significa que al intentar una operación como 3/2 entrega un valor que claramente no es el que buscamos:

>>> 3/2
1
>>> type(3/2)

Para sortear el problema tenemos que hacer que al menos alguno de los dos números sean de coma flotante (float):

>>> float(3)/2
1.5
>>> type (float(3)/2)

Del mismo modo:

>>> 3.0/2
1.5
>>> type (3.0/2)

Si queremos ser un poco más prácticos en caso de utilizar el intérprete podemos comenzarlo con el argumento -Qnew:

~$ python -Qnew

Python 2.6.2 (release26-maint, Apr 19 2009, 01:56:41)
[GCC 4.3.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 3/2
1.5
>>>

Si acaso lo necesitamos para un programa podemos importar una función de un curioso módulo llamado future (más adelante les contaré algo sobre el mismo):

>>> from __future__ import division
>>> 3/2
1.5
>>> 3//2
1
>>> a = 3//2
>>> type(a)

(He ahí que significa la división entera, del resultado sólo presenta la parte entera. Duh.)

Básicamente y para no complicarse más de lo debido, si necesitas utilizar números del conjunto de los naturales o enteros (Z, es decir, los naturales más los negativos) se utiliza int, mientras que si necesitas números reales, utiliza float.

>>> from math import pi
>>> pi
3.1415926535897931
>>> type(pi)

Largos (long)

>>> numero_grande = 2**32
>>> type(numero_grande)
<type 'long'>

Por razones técnicas, el computador no es capaz de almacenar números mayores ni menores que los comprendidos entre – 2.147.483.647 y 2.147.483.647. Por supuesto es posible de todas formas: para representar números fuera de dicho rango se utiliza una nueva notación donde los números son almacenados como largos (long):

>>> numero_grande
4294967296L

Estos números funcionan como cualquier otro con el único detalles es la “L” mayúscula al final. Puedes utilizar la minúscula también (l), pero se parece mucho al número uno (1), por lo que se desaconseja.

Nota: ¿Por qué ese límite? En realidad no es trascendental, pero me parece que es interesante: Toda la culpa es que usamos procesadores de 32 bits. Si en cada bit se pueden almacenar dos valores (“0″ y “1″), entonces sólo bastaría elevar el número de opciones (2) al número de bits (32), es decir: 4.294.967.296. Dado que habitualmente requerimos números negativos (y no sólo naturales), podemos dividir el valor por 2 (positivos y negativos), es decir, 2³¹. El único problema que nos queda sería que estamos omitiendo el cero, por ende, el valor máximo en un ordenador de 32 bits sería 2³¹ – 1. En el caso de procesadores de 64 bits los límites son de 2⁶³ – 1.

Python también puede manejar números complejos, pero creo eso ya escapa a los objetivos de estos artículos :). Si te interesa saber más sobre el tema, te recomiendo que visites la documentación oficial.

¿Por qué el detalle de los tipos?

Buena pregunta: Dudo si aún tenga validez (creo que sí), resulta que en los comienzos de la programación los computadores eran mucho más lentos y contaban con mucha menos memoria por lo que cada vez que era posible había que ahorrar. Puesto que por ejemplo, long (al igual que float) utiliza más memoria que int, lo ideal era sólo recurrir a este tipo de variable cuando fuera estrictamente necesario. Un caso interesante al respecto es con el lenguaje C que cuenta con un tipo conocido como unsigned int que funciona como los límites de int, pero sin valores negativos, por lo que su valor máximo es: 2³² – 1. Utilizando éste uno se podía ahorrar utilizar long en los valores positivos (hasta el límite de 4.294.967.295 por supuesto).

Un poco larga esta parte, pero bueno, me pareció que no era muy buena idea cortarla. En la siguiente parte veremos qué son las cadenas y como podemos juguetear un poco ellas.

Tweet