Un mundo binario¶

Toda la información que maneja un ordenador se almacena en la memoria RAM en forma de ceros y unos.

Los ordenadores son potentes máquinas de cálculo, pero solo saben manejarse con dos dígitos. A esto se le llama sistema de numeración binario.

Bits y bytes¶

A los dígitos binarios se les llama bits, abreviatura de binary digits. ¿Cuantos bytes necesita una variable? Depende del tipo de dato.

Supongamos, por ejemplo, la siguiente variable:

>>> x = 7

La variable es del tipo int:

>>> type(x)
    <class 'int'>

Los objetos de la clase int tienen un método bit_length() asociado, que nos indica cuantos bits ocupa:

>>> x.bit_length()
    3

Por lo tanto, se necesitan 3 dígitos binarios para representar ese valor. ¿Podemos obtener una representación en forma de ceros y unos? La función bin() nos devuelve un texto:

>>> bin(x)
    0b111

La función bin() toma el dato y nos devuelve un texto con los unos y ceros necesarios para representar ese valor, con un prefijo 0b que indica el sistema de numeración.

De todas formas, los ordenadores utilizan paquetes de 8 bits, llamados bytes, por lo que el valor 111 se guardará como 00000111

¿Que pasa cuando tenemos valores muy grandes, que requieren muchos bits? Que la variable tomará de la memoria RAM tantos bytes como necesite. Por ejemplo, supongamos que en una sesión shell introducimos la siguiente expresión:

>>> resultado = 123 ** 234

El operador ** significa "elevado a". El resultado es:

>>> resultado.bit_length()
    854

>>> resultado
    11437436793461719009988029522806627674621807845185022977
    58879750523695047856668964466065683652015421696499747277
    30628842345343196581134895919942820874449837212099476648
    95835902379607854904194900780722062535652692672966406484
    6685758382803707100766740220839267

>>> bin(resultado)
    '0b111100111100000100011101000110011110001000010101100001101
    011000011101011111101110101111100010000110110001100101111110
    000011111011111001010010110000010110001100000001010101011010
    001001001010001101110011110101000001111100000011100001101001
    100010010111111011100101111011011010100110011111001101000001
    100010011110111101100001000101001011000000111001101100010100
    101110011000110000011101000010110010100110111011100010110111
    101100111101011100000011011001000011111001001000101111001101
    110111101000000001000100101001100001100011010100110101000000
    001111000100111110101001110101011001011001111001110111001101
    101100001111101000100111001010000110111011101110100110111100
    100110001110111001001110111110111100111010101001110100011010
    110010010011111100100101001111010100000101101111110101000110
    010100110011101111001010011101011111001101000000000110001010
    11000010101100011'

Representación binaria de los textos¶

Los textos son secuencias de caracteres, y cada carácter se almacena asignando un código a las letras del alfabeto. Si por ejemplo tenemos la variable:

nombre = "Juan"

en la memoria RAM tendremos una secuencia de códigos, uno por cada letra:

    J   u   a   n
    74  117 97  110

Podemos averiguar que código le corresponde a un carácter mediante la función ord():

>>> ord("A")
    65
>>> ord("a")
    97
>>> ord("ñ")
    241

Las variables que representan paquetes de datos, como por ejemplo las listas, también son colecciones de números:

persona = ["Juan", 27]

en la memoria RAM:

    J   u   a   n    27
    74  117 97  110  27

Cada dato se almacena en formato binario:

74   01001010
117  01110101
97   01100001
110  01101110
27   00011011

Con lo que la siguiente lista:

persona = ["Juan", 27]

en la memoria RAM se representa mediante:

0100101001110101011000010110111000011011

... aunque lo habitual es que esta secuencia esté troceada en varios paquetes de ceros y unos, uno por cada dato, y acompañada de información sobre los datos.

Otros objetos¶

En resumen, todo dato, sea de la clase que sea, se representa mediante paquetes de ceros y unos. Veamos como ejemplo, los valores booleanos:

>>> bin(True)
    '0b1'
>>> bin(False)
    '0b0'

Internamente, los conceptos de verdadero y falso se representan mediante un 1 y un cero.

Unidades de medida¶

Cuando manejamos grandes volúmenes de datos, se utilizan diferentes unidades de medida:

un byte son ocho bits
Un kilobyte son 1024 bytes y se representa con el símbolo Kb (o con una k). Como veremos más adelante, 1024 es un número "redondo" en el sistema de numeración binario.

Por ejemplo, si determinado archivo tiene un tamaño de 10k, en realidad contendrá 10 × 1.024 bytes, o lo que es lo mismo, 10 × 1.024 × 8 bits (ceros y unos). Tratándose de un archivo de texto, cada carácter del juego básico de caracteres (letras, números y símbolos) requiere un byte. Otros caracteres tales como los símbolos matemáticos, emojis, etc. pueden necesitar varios bytes por carácter.
Un Megabyte (MB) son 1.024 kilobytes
Un Gigabyte (GB) son 1.024 megabytes
Un Terabyte (TB) son 1.024 gigabytes
Un Petabyte (PB) son 1.024 terabytes
Un Exabyte (EB) son 1.024 petabytes
Un Zettabyte (ZB) son 1.024 exabytes
Un Yottabyte (YB) son 1.024 zettabytes