{ "cells": [ { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## 3. Objetos Built-in (int, float,str,...) " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Booleanos\n", "\n", "En Python, los valores booleanos de verdadero y falso se referencian con `True` y `False` respectivamente.\n", "\n", "Operación | Resultado\n", "----------|----------\n", "`x` **and** `y` | si `x` es `False` entonces `x`, si no, `y`\n", "`x` **or** `y` | si `x` es `True` entonces `x`, si no, `y`\n", "**not** `x` | si `x` es `False` entonces `True`, si no, `False`\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Númericos\n", "\n", "Cualquier dígito, entero (`42`) o con decimales (`2.7182`) se consideran valores numéricos.\n", "\n", "Para aprender a usar el intérprete de Python, empezaremos usándolo como una calculadora." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "#### Operadores aritméticos\n", "\n", "Símbolo | Operación\n", "---|------\n", " + | suma\n", " - | resta\n", " / | división\n", " // | división entera\n", " * | producto\n", " ** | potencia\n", " % | módulo" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "#### Operadores de comparación\n", "\n", "Símbolo | Operación\n", "---|------\n", " < | menor que\n", " > | mayor que\n", " <= | menor o igual que\n", " >= | mayor o igual que\n", " == | igual a\n", " != | no igual a\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "- Los número enteros (`2`, `4`, `20`) tienen tipo `int`. Los números con parte decimal (`5.0`, `1.6`) son de tipo `float`.\n", "\n", "- La operación de `/` entre `int` da un `float`. Para que el resultado\n", "siga siendo `int`, usamos el operador `//`.\n", "\n", "- En el modo interactivo se puede usar `_` para hacer referencia al ultimo valor\n", "que se ha obtenido." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "21.105" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tax = 21.0 / 100\n", "price = 100.5\n", "price * tax\n", "21.105" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/plain": [ "121.605" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "price + _ + 11\n", "121.605" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Variables, declaración de variables, tipado dinámico." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "Las variables no se definen, se se les asigna un valor usando el operador `=`.\n", "\n", "Todo nombre de variable está asociada únicamente a un objeto. Nos referiremos a estas también como nombres, ya que, realmente lo que estamos haciendo es asignarle un nombre a un objeto determinado." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "900" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "width = 20\n", "height = 5 * 9\n", "width * height" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "- No se pueden crear variables con nombres de palabras reservadas del lenguaje.\n", "- Las variables no pueden epezar por un número." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "ename": "SyntaxError", "evalue": "invalid syntax (, line 1)", "output_type": "error", "traceback": [ "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m 2var = \"foo\"\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" ] } ], "source": [ "2var = \"foo\"" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "ename": "SyntaxError", "evalue": "invalid syntax (, line 1)", "output_type": "error", "traceback": [ "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m break = 100\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" ] } ], "source": [ "break = 100" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n" ] } ], "source": [ "import keyword\n", "print(keyword.kwlist)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Python usa **duck typing**, que viene de la expresión de *\"si camina como un pato, y suena como un pato, debe de ser un pato\"*.\n", "\n", "Esto significa que en tiempo de ejecución se comprueba que una variable tiene ciertos atributos o métodos en vez de comprobar el tipo de la variable realmente." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "\n" ] } ], "source": [ "foo = 2 # foo contiene un dato tipo int\n", "print(type(foo))\n", "foo = 4.2 # foo contiene ahora un dato tipo float\n", "print(type(foo))" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Las variables funcionan como etiqutas, es decir, en realidad están apuntando a a una dirección en memoria que contiene el objeto.\n", "\n", "```python\n", ">>> name = \"Antonio\"\n", ">>> first = name\n", "```\n", "\n", "![variables](img/variables1.png)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Los típos básicos de Python son **inmutables**, esto quiere decir que si son modificados, realmente se crea un **nuevo** objeto con esta modificación." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "```python\n", "a = 1000\n", "```\n", "\n", "![variables](img/variables2.png)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "```python\n", "a = a + 1\n", "```\n", "\n", "![variables](img/variables3.png)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "```python\n", "a = a + 1\n", "```\n", "\n", "![variables](img/variables4.png)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Cadenas de texto, formato, encoding, métodos de cadenas." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "- Se considera una cadena de texto cualquier sucesión de caracteres entre comillas dobles, `\"`, o comillas simples, `'`. \n", "- Se puede usar `\\` para escapar las comillas.\n", "- Se considera que una cadena es una secuencia, de caracteres, y por tanto se puede acceder a un caracter usando su índice, aunque es un tipo de datos **inmutable**, por lo que no puede ser modificado de esta forma." ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "P\n", "n\n" ] } ], "source": [ "word = 'Python'\n", "print(word[0]) # caracter en posición 0\n", "print(word[5]) # caracter en posición 5" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "ename": "TypeError", "evalue": "'str' object does not support item assignment", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# no se puede modificar, da una excepción\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mword\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"a\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment" ] } ], "source": [ "# no se puede modificar, da una excepción\n", "word[4] = \"a\"" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "Por defecto, todas las cadenas de texto son de tipo `str` y se considera texto en UTF-8. " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "#### Operaciones sobre cadenas de texto" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "`str.capitalize()`\n", "\n", "Devuelve una copia de la cadena con la primera letra en mayúscula y el resto en minúscula.\n", "\n", "`str.count(sub[, start[, end]])`\n", "\n", "Cuenta el número de veces que `sub` se encuentra en la cadena, desde `start` a `end`.\n", "\n", "`str.endswith(suffix[, start[, end]])`\n", "\n", "Devuelve si la cadena de texto termina con `suffix`.\n", "\n", "`str.isalnum()`\n", "\n", "Comprueba si la cadena de texto es alfanumérica.\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "`str.isalpha()`\n", "\n", "Comprueba si la cadena de texto sólo tiene caracteres alfabéticos.\n", "\n", "`str.isdecimal()`\n", "\n", "Comprueba que todos los dígitos son decimales.\n", "\n", "`str.join(iterable)`\n", "\n", "Devuelve una cadena que es la concatenación de las cadenas en `iterable` usando la propia cadena como separador.\n", "\n", "`str.lower()`\n", "\n", "Devuelve una copia de la cadena con todos los caracteres en minúsculas." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "`str.split(sep=None, maxsplit=-1)`\n", "\n", "Devuelve una lista resultado de dividir la cadena usando `sep` como separador.\n", "\n", "`str.splitlines([keepends])`\n", "\n", "Devuelve una lista resultado de dividir la cadena usando saltos de línea como separadores.\n", "\n", "`str.startswith(prefix[, start[, end]])`\n", "\n", "Devuelve si la cadena de texto empieza con `prefix`." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "`str.strip([chars])`\n", "\n", "Devuelve una copia de la cadena eliminando del principio y del final los caracteres indicados en `char`. Si no se indican, se eliminan los espacios en blanco.\n", "\n", "`str.upper()`\n", "\n", "Devuelve una copia de la cadena con todos los caracteres en mayúsculas." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "#### Raw strings\n", "\n", "Los caracteres especiales, como saltos de línea, tabulaciones, etc. se introducen\n", "de la forma habitual, `\\n`, `\\t`. Pero, si no se quiere que se tengan en cuenta,\n", "se puede usar una *raw string*, añadiendo `r` delante de las comillas iniciales.\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "C:\\some\n", "ame\n", "C:\\some\\name\n" ] } ], "source": [ "print('C:\\some\\name') # aquí \\n es un salto de línea\n", "print(r'C:\\some\\name') # aquí no se considera un caracter especial" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "#### Strings multilíneas\n", "\n", "Podemo crear una cadena de texto que tenga más de una líena. Para ello, se declara el literal usando las triples comillas." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Usage: thingy [OPTIONS]\n", " -h Display this usage message\n", " -H hostname Hostname to connect to\n", "\n" ] } ], "source": [ "print(\"\"\"\\\n", "Usage: thingy [OPTIONS]\n", " -h Display this usage message\n", " -H hostname Hostname to connect to\n", "\"\"\")" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "#### Format strings\n", "\n", "Para mostrar valores de variables en cadenas de texto podemos usar *format strings*. Estas se pueden definir usando `f` como prefijo del literal de cadena de texto o usando el método `format`.\n", "\n", "Las variables se sustituirán en los lugares que se indiquen entre llaves, `{}`." ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Vamos a hablar sobre Antonio\n", "Vamos a hablar sobre Antonio\n" ] } ], "source": [ "name = \"Antonio\"\n", "print(f\"Vamos a hablar sobre {name}\")\n", "print(\"Vamos a hablar sobre {}\".format(name))" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Algunos ejemplos de como se pueden asociar valores a una cadena:\n", "\n", "```python\n", "\"First, thou shalt count to {0}\" # Referencia al primer argumento posicional\n", "\"Bring me a {}\" # Referencia al primer argumento posicional de forma implícita\n", "\"From {} to {}\" # Lo mismo que \"From {0} to {1}\"\n", "\"My quest is {name}\" # Referencia el argumento con nombre 'name'\n", "\"Weight in tons {0.weight}\" # Referencia al atributo 'weight' del primer argumento posicional\n", "\"Units destroyed: {players[0]}\" # Referencia al primer elemento del argumento con nombre 'players'\n", "```" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "#### Concatenación de Cadenas\n", "\n", "Las cadenas de texto se pueden concatenar usando el operador `+`, y se pueden repetir usando el operador `*`." ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/plain": [ "'unununium'" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 3 veces 'un', seguido de un 'ium'\n", "3 * 'un' + 'ium'" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "Los literales de strings (las cadenas indicadas con comillas, no las variables) se pueden concatenar poniendo una detrás de otra." ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/plain": [ "'Python'" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "'Py' 'thon'" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "- Se considera una secuencia de bytes un literal declarado con `b''` o con `b\"\"`, igual que las cadenas de texto, pero usando `b` como prefijo.\n", "- Sólo se aceptan caracteres ASCII.\n", "- Son de tipo `bytes`" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "b'De perdidos al rio'" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "text = b'De perdidos al rio'\n", "text" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/plain": [ "'De perdidos al rio'" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "text.decode(\"utf-8\")" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/plain": [ "b'De perdidos al rio'" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"De perdidos al rio\".encode(\"utf-8\")" ] } ], "metadata": { "celltoolbar": "Slideshow", "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.1" } }, "nbformat": 4, "nbformat_minor": 2 }