MySQL – Datos numéricos enteros

Recientemente asistimos con emoción a la creación de la primera tabla en MySQL. Aprendimos a utilizar el tipo de datos VARCHAR para campos con texto de longitud variable y vimos el comando para mostrar la estructura de la tabla recién creada.

Tan sólo con el tipo VARCHAR podríamos modelar buena parte de nuestros datos. Los campos de texto son, indudablemente, una abrumadora mayoría. Incluso podríamos llegar a representar datos numéricos empleando simplemente texto. ¿Qué me impediría, por ejemplo, almacenar un número de teléfono, o el número de cartuchos que tengo en stock de un determinado modelo de impresora, en un campo de tipo VARCHAR?

Es cierto que un número de teléfono podría registrase en un VARCHAR sin mayor problema, pero no así el stock de consumibles. Si entrego un cartucho, ¿cómo decremento en una unidad esa cantidad si estoy en un campo que es de tipo texto?

Para almacenar datos susceptibles a que se realicen sobre ellos operaciones matemáticas necesitamos emplear tipos numéricos.

Vamos a presentar hoy el tipo INTEGER, con el que almacenaremos valores numéricos enteros.

El tipo INTEGER, que puede resumirse como INT, ocupa un espacio de 4 bytes (32 bits), por lo que nos permite almacenar enteros positivos y negativos comprendidos entre -2^{31} hasta 2^{31}-1. Es decir, en el rango comprendido entre

-2147483648 … +2147483647

Una buena amplitud, desde luego, tratándose de enteros, aunque más adelante veremos que puede aumentarse aún más.

Vamos a crear, a título de ejemplo, una tabla para almacenar el stock disponible de nuestros dispositivos de impresión.

mysql> CREATE TABLE consumibles
    -> (
    -> referencia VARCHAR(15),
    -> impresora VARCHAR(20),
    -> stock INT
    -> );
Query OK, 0 rows affected (0.36 sec)

En referencia almacenaremos el código identificativo del tipo de cartucho o tóner; en impresora, el modelo de la máquina al que se asocia y en stock el número cartuchos que tenemos en almacén.

Veamos la estructura de la tabla recién creada:

mysql> DESC consumibles;
+------------+-------------+------+-----+---------+-------+
| Field      | Type        | Null | Key | Default | Extra |
+------------+-------------+------+-----+---------+-------+
| referencia | varchar(15) | YES  |     | NULL    |       |
| impresora  | varchar(20) | YES  |     | NULL    |       |
| stock      | int(11)     | YES  |     | NULL    |       |
+------------+-------------+------+-----+---------+-------+
3 rows in set (0.02 sec)

El tipo INTEGER es un tipo estándar de SQL para representar números enteros. MySQL ha extendido el número de opciones a otros cuantos más de los que hablaremos más adelante, diferenciándose en el número de bytes que ocupan. Veremos también que podemos incluso especificar que los enteros sean rigurosamente sin signo (es decir, números no negativos). Hasta entonces, apuesta por la compatibilidad plena: INTEGER (o INT) es el tipo entero por excelencia.

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2012/05/mysql-datos-numericos-enteros/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta

Posted in MySQL | Tagged , , | Leave a comment

Python – Capítulo 33: Imprimiendo al estilo de C

Tomemos prestada la función desguazar() que diseñamos en el capítulo anterior:

def desguazar(dividendo, divisor):
  cociente = dividendo//divisor
  resto = dividendo%divisor
  return cociente, resto

Vamos a modificarla ligeramente para que, en vez de devolver la tupla con el resto y el divisor nos muestre una frase con el resultado. Esto es, que funcione del siguiente modo:

>>> desguazar(17,5)
El cociente es 3 y el resto es 2.

No parece complicado en absoluto. Una primera aproximación podría ser esta:

def desguazar(dividendo, divisor):
  cociente = dividendo//divisor
  resto = dividendo%divisor
  print("El cociente es", str(cociente), "y el resto es", str(resto),".")

Salvo la excesiva distancia del punto final, el resultado es aceptable (recuerda que por defecto print() establece como separador un espacio en blanco).

>>> desguazar(17,5)
El cociente es 3 y el resto es 2 .

Sin embargo, el modo de lograrlo deja bastante que desear: hemos troceado la cadena para poder intercalar los valores enteros, que previamente hemos tenido que convertir en strings.

Si sabes programar en lenguaje C, tal vez sientas algo de añoranza. Con lo bien que resuelve el problema un programador en C con printf

printf("El cociente es %d y el resto es %d.\n", cociente, resto);

¿No existiría algo semejante en Python? ¿No existiría un modo de formatear una cadena de caracteres con especificaciones en su interior?

Desde luego que existe, y no sólo de un modo semejante, sino más flexible aún.

Hoy voy a mostrarte como resolvía Python esto a la antigua usanza. Hoy día, el método format() hace innecesario recurrir a ella, pero puesto que aún sigue siendo perféctamente válida y no parece haber indicios de que vayan a dejarla obsoleta, he preferido explicártela en primer lugar.

Esta es la nueva función. Presta mucha atención a la última sentencia:

 def desguazar(dividendo, divisor):
  cociente = dividendo//divisor
  resto = dividendo%divisor
  print("El cociente es %d y el resto es %d." % (cociente, resto))

Y observa el resultado:

>>> desguazar(17,5)
El cociente es 3 y el resto es 2.

Perfecto.

Fíjate cómo, al igual que en printf, especificamos un valor entero con %d. Puesto que vamos a sustituir dos enteros, %d aparece dos veces en los lugares adecuados dentro de la cadena.

A continuación, una vez hemos cerrado la cadena con las comillas, aparece el símbolo %, que en este contexto es conocido como operador de especificación, formateo o interpolación.

Tras el figura una tupla con las variables que sustituirán cada especificación. Es muy importante que el número de especificaciones en la cadena coincidan con el número de variables en el lado derecho de %. En caso contrario se produciría un error en tiempo de ejecución (una excepción).

Naturalmente, si sólo hubiera una especificación, en lugar de una tupla aparecería un entero simple:

>>> ovejas=17
>>> print("Tengo un rebaño de %d ovejas..." % ovejas)
Tengo un rebaño de 17 ovejas...

Hemos presentado %d, la especificación para enteros con signo en formato decimal (base 10), pero hay otras más para todo tipo de variables. Las iremos presentando gradualmente; entre tanto, asegúrate de comprender la técnica aquí descrita.

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2012/05/python-capitulo-33-imprimiendo-al-estilo-de-c/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta

Posted in python | Tagged , , , | Leave a comment