diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/02_datos.md | 587 |
1 files changed, 587 insertions, 0 deletions
diff --git a/src/02_datos.md b/src/02_datos.md new file mode 100644 index 0000000..3a35bea --- /dev/null +++ b/src/02_datos.md @@ -0,0 +1,587 @@ +# Trabajando con datos + +Programar es, principalmente, tratar con datos y los datos no son más que +piezas de información que se estructura de una forma concreta. + +## Nombrando datos + +Aunque no lo hemos mencionado, los datos se almacenan en la memoria principal +de la computadora. Puedes imaginarte la memoria como un conjunto de cajas +identificadas con direcciones, como si fuesen los buzones de un portal con +muchos pisos. Para utilizar datos, éstos se guardan en los diferentes cajones y +se van extrayendo y actualizando. La importancia de nombrar las cosas es +evidente, si no guardamos un listado de dónde hemos guardado qué no podemos +recuperar los datos que hemos creado. + +Al igual que en las matemáticas se utilizan los símbolos para representar +posibles valores y simplificar los procesos, en los lenguajes de programación +se utilizan símbolos para definir referencias a los datos y así poder referirse +a los mismos datos por su nombre sin tener que introducir su contenido +constantemente. Los lenguajes de programación aportan al programador la +facilidad de poder crear sus propios nombres para no tener que usar las +direcciones propias de la memoria, que normalmente son número sin más +significado que su posición, la mayor parte de las veces permitiendo al +programador abstraerse de estos detalles internos. + +En python existe un operador para declarar símbolos que hacen referencia a un +valor: el operador `=`. Este operador enlaza el valor de la derecha con el +nombre de la izquierda. Con un ejemplo es más fácil de comprender. Probando en +la REPL: + +``` +>>> a = 10 +>>> a +10 +>>> a + 1 +11 +``` + +Como ves, en el primer paso se asocia el valor `10` al identificador `a` y más +adelante se puede utilizar `a` para hacer referencia al valor enlazado. + +Las referencias han de ser declaradas antes de usarse, si no, el intérprete no +las conoce y lanza una excepción: + +``` +>>> b +Traceback (most recent call last): + File "<pyshell#6>", line 1, in <module> + b +NameError: name 'b' is not defined +``` + +### Todo es una referencia + +El comportamiento de estas referencias puede no ser intuitivo si vienes de +otros lenguajes. El operador `=` enlaza, como se dice anteriormente, un nombre +a un valor concreto, pero eso no significa que copie su contenido. En python +los valores y los nombres son conceptos independientes. Los valores ocupan su +lugar en la memoria y los nombres hacen referencia a dónde se encuentran estos +valores. Es muy común tener muchas referencias a la misma estructura de datos y +transformar su contenido desde todas las referencias. + +A nivel técnico, lo que en python se conoce como variable y en este documento +hemos hecho el esfuerzo de llamar referencia es lo que en otros lenguajes se +conoce como un puntero y la labor del operador `=` es la de asignar el puntero +a la dirección donde se encuentran los datos a los que debe apuntar. + +Volviendo a la metáfora de los buzones, en lenguajes de más bajo nivel como C +estás obligado a seleccionar qué buzón vas a utilizar para introducir cada +dato. Por lo que si cambia el tipo de dato a gestionar, puede que el buzón se +quede pequeño o que los datos se interpreten de forma incorrecta. Sin embargo, +python guarda las referencias de forma independiente a los valores y adecua el +número de buzones en uso al tamaño de los datos de los que dispones +reordenando, si es necesario, la estructura completa de valores y referencias. +A este concepto se le conoce como gestión automática de memoria (*automatic +memory management*). + +En resumen, las referencias en python son únicamente un recordatorio que sirve +para poder acceder a un valor. Esto cobra importancia más adelante, y no vamos +a rehuir la responsabilidad de enfangarnos en ello. + +## Tipos + +Tal y como aclaraba el texto de la introducción, python tiene un sistema de +tipos dinámico (*dynamic type system*). Lo que significa que gestiona los tipos +de forma automática, permitiendo a los nombres hacer referencia a diferentes +tipos de valor durante la ejecución del programa a diferencia de otros +lenguajes como, por ejemplo, C, donde el tipo de las variables debe ser +declarado de antemano y no puede cambiarse. + +Esto es posible debido al fenómeno explicado en el apartado anterior por un +lado, y, por el otro, a que los datos de python son un poco más complejos que +en otros lenguajes y guardan una pequeña nota que indica cómo deben ser +interpretados. + +Si en algún momento se le pide a python que asigne un valor de un tipo distinto +al que una referencia tenía no habrá problemas porque es el propio dato quien +guarda la información suficiente para saber cómo entenderlo. Las referencias +sólo almacenan dónde se guarda este dato. + +> NOTA: Seguramente te habrás dado cuenta de que el funcionamiento de python es +> más ineficiente que el de C o lenguajes similares pero mucho más flexible. Y +> así es. A la hora de elegir el lenguaje debemos valorar cuál nos interesa +> más para la labor que vamos a realizar. + +### Tipos simples + +Hemos denominado tipos simples a los que no empaquetan más de un valor +internamente. En otros lenguajes o contextos se les conoce como escalares. + + +#### La nada + +La nada en python se representa con el valor `None` y es útil en innumerables +ocasiones. + +#### Boolean + +Los valores booleanos expresan *verdad* (`True`) o *mentira* (`False`) y sirven +para gestionar lógica desde esos términos. Mas adelante los veremos en acción. + +#### Integer + +Los Integer, números enteros en inglés, ya han aparecido anteriormente. Para +usar un número entero puedes introducirlo tal cual. Recuerda que hay enteros +positivos y negativos. El símbolo para marcar números negativos en python es el +`-`, que coincide con el operador de la resta. + +``` +>>> 14 +14 +>>> -900 +-900 +>>> +``` + +Los números enteros también pueden expresarse en otras bases, como en +hexadecimal. Dependiendo de la aplicación en la que te encuentres igual +necesitas mirarlo más en detalle: + +``` +>>> 0x10 +16 +``` + +#### Float + +Los números Float, o de coma flotante, son números no-enteros. Ten cuidado +con ellos porque la coma flotante es peculiar. + +El nombre coma flotante viene de que la coma no siempre se mantiene con la +misma precisión. En realidad estos números se guardan como los números en +notación científica ($2.997e8 m/s$ para la velocidad de la luz, por ejemplo). +La notación científica siempre implica tener una coma, pero cuya posición se +varía con el exponente posterior. + +El modo de almacenamiento de los números de coma flotante es muy similar a la +notación científica: se almacenan dos valores de tamaño fijo, la *mantisa* y el +*exponente* para, de este modo, poder ajustar la precisión en función del +tamaño del número almacenado. No es lo mismo expresar la velocidad de la luz, +$2.997e8 m/s$, que la longitud de onda del color rojo, $6,250e-7 m$, ambos +valores tienen un tamaño muy distinto, pero usando dos *mantisas* de tamaño +similar, cuatro dígitos (2997 y 6250), y dos exponentes de tamaño similar, un +dígito (8 y -7), hemos expresado valores muy diferentes, ambos con la misma +precisión relativa. + +El problema viene cuando nos apetece mezclarlos, por ejemplo, sumándolos. +Imagina que tienes dos valores de esas dimensiones, uno de millones y otro de +millonésimas partes de la unidad, y los quieres sumar entre ellos. Si sólo +tienes una mantisa limitada para representarlos, la suma resultará en el +redondeo de ambos a la precisión que tienes disponible. Es decir: el resultado +será el valor grande y el pequeño se perderá en el redondeo. + +Aunque en este caso la suma es precisa, si tratas con un billón de valores +pequeños y uno grande y quieres obtener la suma de todos y los sumas en parejas +siempre con el grande, en cada suma se descartará el valor pequeño en el +redondeo y el resultado total será el valor grande que tenías. Sin embargo, si +sumas los valores de tamaño similar entre ellos primero, obtendrás un valor +suficientemente grande como para alterar el resultado de la suma contra el +valor grande al final, dando así un resultado distinto. Te recomiendo entonces, +que si te encuentras en una situación como ésta tengas cuidado y, por ejemplo, +ordenes los números de menor a mayor antes de sumarlos, para obtener una suma +de buena precisión. + +En realidad, el exponente en el caso de python (y en casi todos los demás +lenguajes) no está elevando un 10 a la enésima potencia, si no que lo hace con +un 2. Por lo que lo expresado anteriormente es un poco distinto. Esto provoca +que algunos números de coma flotante no sean tan redondos como deberían (por +ejemplo, `2.999999999`, cuando debería ser `3.0`) y compararlos entre ellos +puede ser desastroso. Para evitarlo, te recomiendo que *siempre* redondees los +valores a una precisión que puedas controlar. + +Aunque realmente es algo más complejo[^1], lo que sabes ahora te evitará +problemas en el futuro, sobre todo cuando analices datos, uno de los sectores +donde python se usa de forma extensiva. + +[^1]: https://en.wikipedia.org/wiki/Floating-point_arithmetic + +Declarar números de coma flotante es natural porque usa una sintaxis a la que +estamos acostumbrados: + +``` +>>> 1E10 +10000000000.0 +>>> 1.0 +1.0 +>>> 0.2E10 +2000000000.0 +>>> +``` + + +#### Complex + +Python soporta números complejos y los expresa utilizando la letra `j`. Como +suponen un caso bastante concreto no los analizaremos en detalle. Pero tienes +disponible la documentación de python para lo que quieras. + +``` +>>> 1-23j +(1-23j) +``` + +#### String + +Un String es una cadena de caracteres. Los Strings en python son, a diferencia +de en otros lenguajes, un escalar, al contrario de lo que la primera definición +que hemos expresado puede hacernos pensar. En python los Strings no son un +conjunto de caracteres alfanuméricos sueltos que se comportan como un valor, es +al revés. El concepto de carácter no existe y ha de expresarse con un String de +longitud 1. + +Los strings se expresan rodeando texto con comillas dobles, `"`, o simples `'` +(el símbolo del apóstrofe). + +``` +>>> "Hola" +'Hola' +>>> 'Hola' +'Hola' +``` + +El hecho de que haya dos opciones para delimitar los strings facilita el +etiquetado como string de valores que contienen las propias comillas en su +contenido. También puede utilizarse la contrabarra `\` para cancelar la acción +de las comillas. + + +``` +>>> "Tiene un apóstrofe: Luke's" +"Tiene un apóstrofe: Luke's" +>>> 'Tiene un apóstrofe: Luke's' +SyntaxError: invalid syntax +>>> 'Tiene un apóstrofe: Luke\'s' +"Tiene un apóstrofe: Luke's" +``` + +> NOTA: la contrabarra sirve para introducir caracteres especiales o caracteres +> de escape[^2]: `\n` salto de línea, `\t` tabulador, etc. Que son una herencia +> de los tiempos de las máquinas de escribir, pero son aún útiles y muy usados. +> Para expresar la propia contrabarra ha de escaparse a sí misma con otra +> contrabarra para que no evalúe el siguiente caracter como un caracter de +> escape.: `\\`. + +[^2]: https://en.wikipedia.org/wiki/Escape_character + + +### Tipos compuestos + +Hemos denominado tipos compuestos a los que pueden incluir diferentes +combinaciones de tipos simples. Estos tipos dejan de ser escalares y se +comportan como vectores o conjuntos de datos. Estos tipos de dato pueden +contenerse a sí mismos, por lo que pueden crear estructuras anidadas complejas. + +#### Tuple + +Las tuplas a *tuple* en inglés son el tipo compuesto más sencillo en python. +Las tuplas definen un conjunto de valores de cualquier tipo. + +Se declaran utilizando paréntesis añadiendo sus elementos separados por comas. +Y se accede a sus contenidos utilizando los corchetes e introduciendo el índice +del elemento que se quiere extraer. + +``` +>>> (2, 3, "HOLA") +(2, 3, 'HOLA') +>>> (2, 3, "HOLA")[0] +2 +``` +En python los índices comienzan en `0`. + +#### List + +Las listas o *list* son muy similares a las tuplas, pero son algo más complejas +porque pueden alterarse así mismas. A diferencia de todos los tipos que hemos +visto hasta ahora, tanto las listas como los diccionarios que veremos a +continuación son inmutables. Esto significa que no puede transformarse su +valor, más adelante trataremos esto en detalle. + +De momento, recuerda que las listas se construyen de forma similar a las +tuplas, pero utilizando corchetes en lugar de paréntesis. La forma de acceder a +los índices es idéntica. + +``` +>>> [2, 3, "HOLA"] +[2, 3, 'HOLA'] +>>> [2, 3, "HOLA"][0] +2 +``` + +#### Dictionary + +Los diccionarios o *dictionary* son un tipo de dato similar a los dos +anteriores, pero que en lugar de utilizar índices basados en la posición de sus +elementos usan claves arbitrarias definidas por el usuario. + +Además, los diccionarios no están ordenados así que no se puede suponer que las +claves siempre van a estar en el orden en el que se introducen. + +Para declarar diccionarios es necesario indicar qué claves se quieren usar. Las +claves son de tipo string. En el caso de los diccionarios, además, se utilizan +llaves para definirlos. El acceso a sus valores se realiza con los corchetes, +del mismo modo que en las listas, pero es necesario seleccionar la clave para +acceder. + +Los diccionarios, al igual que las listas, son mutables. Como veremos en +seguida. + +``` +>>> {"nombre": "Guido", "apellido": "Van Rossum", "popularidad": 8.0} +{'nombre': 'Guido', 'apellido': 'Van Rossum', 'popularidad': 8.0} +>>> {"nombre": "Guido", "apellido": "Van Rossum", "popularidad": 8.0}["popularidad"] +8.0 +``` + +## Conversión + +Ahora que conoces los valores sé que quieres saber cómo cambiar de uno a otro. +Cómo leer un Integer desde un String etc. Python tiene funciones para construir +sus diferentes tipos de datos a partir de los diferentes inputs posibles. + +Aunque aún no sabes ejecutar funciones te adelanto como se hace con algunos +ejemplos: + +``` +>>> bool(1) +True +>>> bool(0) +False +>>> int("hola") +Traceback (most recent call last): + File "<pyshell#27>", line 1, in <module> + int("hola") +ValueError: invalid literal for int() with base 10: 'hola' +>>> int("10") +10 +>>> float(10) +10.0 +>>> complex(19) +(19+0j) +>>> str(10) +'10' +>>> tuple([1,2,3]) +(1, 2, 3) +>>> list((1,2,3)) +[1, 2, 3] +>>> dict((("a", 1),("b", 2))) +{'a': 1, 'b': 2} +``` + +Los propios nombres de las funciones son bastante representativos de a qué tipo +convierten. Si quieres saber más puedes ejecutar `help(nombre)` y ver qué te +cuenta la ayuda. + +## Operadores + +Ahora que sabes el contexto en el que vas a jugar, necesitas poder alterar los +datos. + +Existen operadores básicos que te permiten transformar los datos, algunos ya +los has visto antes, el operador `=`, que sirve para nombrar cosas, la suma +(`+`) o la resta (`-`), pero hay otros. + +``` +>>> 1 + 1 +2 +>>> 10 - 9 +1 +>>> 10 ** 2 +100 +>>> +``` + +Los siguientes apartados muestran algunos operadores que es interesante +memorizar. + + +### Pruebas de verdad + +Las pruebas de verdad generan un valor booleano desde una pareja de valores. A +continuación una lista de las pruebas de verdad con unos ejemplos: + +| operator | meaning | +|---|---| +| < | strictly less than | +| <= | less than or equal | +| > | strictly greater than | +| >= | greater than or equal | +| == | equal | +| != | not equal | +| is | object identity | +| is not | negated object identity | +| in | containment test | +| not in | negated containment test | + +``` +>>> 1 > 1 +False +>>> 1 >= 1 +True +>>> 1 not in (0, 2, 3) +True +``` + +### Operadores lógicos + +Los operadores lógicos mezclan booleanos y son muy importantes, sobre todo para +combinar las pruebas de verdad. + +| operator | meaning | +|---|---| +| and | logical and, returns True if both True, False otherwise | +| or | logical or, returns True if any True, False otherwise | +| not | logical not, returns True if False, True otherwise | + +La mayor parte de los operadores son binarios (como la suma), necesitan dos +valores y devuelven otro, pero existe al menos una excepción que funciona con +un único valor. El operador `not` sirve para darle la vuelta a un Booleano. + +``` +>>> not True +False +>>> True and True +True +>>> False and True +False +>>> False or True +True +>>> 1 > 0 and 2 > 1 +True +``` + +### Matemáticos + +Los operadores matemáticos transforman números entre ellos. Casi todos son +conocidos por su operación matemática. + +| operator | meaning | +|---|---| +| + | addition | +| - | subtraction or negative | +| `*` | multiplication | +| / | division | +| `**` | power | +| % | remainder | + +### Operación en función del tipo + +Python simplifica muchas tareas transformando el comportamiento de los +operadores en función del tipo de dato sobre el que trabajan. Los operadores +matemáticos están preparados para trabajar sobre números (de cualquier tipo) +pero la verdad es que algunos pueden ejecutarse sobre otros formatos. Por +ejemplo: + +``` +>>> "a" + "a" +'aa' +``` + +Esto se debe a que la funcionalidad del operador `+` ha sido diseñada para +operar de forma especial en Strings, haciendo una concatenación. + +En el futuro, cuando aprendas a diseñar tus propios tipos podrás hacer que los +operadores les afecten de forma especial, tal y como pasa aquí. + +### Precedencia + +La precedencia en python es muy similar a la matemática y usa las mismas reglas +para marcarla de forma explícita. Recuerda, en matemáticas se utilizan los +paréntesis para esto. + +Los operadores siempre trabajan con sus correspondientes valores y python los +resuelve de forma ordenada. Si generas una operación muy compleja, python la +irá desgranando paso a paso y resolviendo las parejas una a una, cuanto más te +acostumbres a hacerlo en tu mente menos errores cometerás. + +``` +>>> 8 + 7 * 10 == (8 + 7) * 10 +False +>>> 8 + 7 * 10 +78 +>>> (8 + 7) * 10 +150 +>>> 78 == 150 +False +``` + +## Mutabilidad + +Ya adelantamos que el operador `=` sirve para nombrar cosas. Ahora vamos a +combinar esa propiedad con la mutabilidad, o la propiedad de las cosas de +alterarse a sí mismas. Empecemos con un ejemplo: + +``` +>>> a = 10 +>>> b = a + 10 +>>> b +20 +>>> a = b +>>> a +20 +``` + +En este ejemplo hacemos que `a` haga referencia al valor 10, y después creamos +`b` a partir de `a` y otro 10. Gracias a la precedencia, primero se resuelve el +lado derecho completo obteniendo un 20 y después se asigna la referencia `b` a +ese valor. + +Si queremos, después podemos reasignar el símbolo `a` a otro valor nuevo, en +este caso al que hacer referencia `b` que es 20. + +En este primer ejemplo, ningún valor está siendo alterado, si te fijas, sólo +estamos creando nuevos valores y cambiando las referencias a éstos. + +Con los datos mutables podemos alterar los valores. Lo vemos con otro ejemplo: + +``` +>>> a = {} +>>> b = a +>>> a["cambio"] = "hola!" +>>> b +{'cambio': 'hola!'} +``` + +Primero creamos un diccionario vacío y le asignamos la referencia `a`. Después +le asignamos la referencia `b` a quien referenciaba `a`, es decir, al +diccionario vacío. Ambas referencias apuntan al mismo dato. Si después usamos +alguna alteración en el diccionario `a` como asignarle una nueva clave, `b`, +que hace referencia al mismo diccionario, también ve los cambios. Esto mismo +podría hacerse si se tratara de listas, ya que tienen la capacidad de alterarse +a sí mismas, pero nunca podría hacerse en tuplas, porque son inmutables. + +> NOTA: Los diccionarios y las listas soportan un montón de funciones y +> alteraciones, no se mencionan en este apartado porque nunca terminaría. Se +> dejan para el futuro y para los ejemplos que se verán durante el documento. + +Si intentásemos un ejemplo similar en tupla, no nos dejaría: + +``` +>>> a = () +>>> b = a +>>> a[0] = 1 +Traceback (most recent call last): + File "<pyshell#67>", line 1, in <module> + a[0] = 1 +TypeError: 'tuple' object does not support item assignment +``` + +Ten cuidado cuando trates con elementos mutables, sobre todo si tienen muchas +referencias, porque puede que estés alterando los valores en lugares que no te +interesa. Para evitar este tipo de problemas, puedes generar copias de los +objetos, pero el proceso es poco eficiente y tedioso. + +En este segundo caso, creamos una copia de `a` para que `b` sea independiente +de los cambios que ocurran en ésta. Aquí ya no estamos haciendo referencia +desde `b` a los datos que había en `a`, sino a una copia de éstos, almacenada +en otro lugar. + +``` +>>> a = {} +>>> b = dict(a) +>>> a["cambio"] = "hola!" +>>> b +{} +>>> a +{'cambio': 'hola!'} +``` |