lessons/1/1_PythonIntroduccio.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Nota**\n",
    "\n",
    "Pots trobar aquest material en format pàgina web a la plataforma [readthedocs](https://tallerpythonfee.readthedocs.io/en/latest/)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"right\">\n",
    "\n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/wisaaco/TallerPythonFEE/blob/main/lessons/1/1_PythonIntroduccio.ipynb)\n",
    "\n",
    "</div>\n",
    "\n",
    "Si no funciona el botó, pots copiar i aferrar la següent direcció al teu navegador: https://colab.research.google.com/github/wisaaco/TallerPythonFEE/blob/main/lessons/1/1_PythonIntroduccio.ipynb"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1 - El ecosistema de Python"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Què és Python?\n",
    "\n",
    "**Python** és un llenguatge de programació interpretat on destaca la seva filosofia d'una sintaxi  fàcilment interpretable. Va ser creat per Guido van Rossum en 1991.\n",
    "\n",
    "És un llenguatge dissenyat perquè les aplicacions siguin independents de la plataforma en la qual s'executen. Això significa que un programa escrit en aquest llenguatge s'executarà sense cap mena de modificació en qualsevol sistema informàtic, almenys en qualsevol sistema que suport-hi **Python**.\n",
    "\n",
    "Emprar Python en lloc d'aplicacions com R, fulls de càlcul o d'altres tipus fa que l'objectiu implementat, per exemple el tractament de dades, sigui un procés més àgil i eficient. És a dir, es pot treballar amb una gran diversitat de formats de dades al mateix temps i amb un gran volum de mostres per obtenir diferents tipus de resultats: numèrics, visuals estadístics, visuals geogràfics i una altra vegada com a dades intermèdies d'altres processos.\n",
    "\n",
    "En definitiva, Python es caracteritza pel seu potencial de funcionalitats ja implementades, i per oferir una fluïdesa a tots els nivells computacionals i lògics.\n",
    "\n",
    "Referències:\n",
    "- Documentació a wikipedia: [enllaç](https://en.wikipedia.org/wiki/Python_(programming_language))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Com executar codi Python?\n",
    "\n",
    "En aquest curs no descriurem com fer una instal·lació de Python al nostre sistema. Emprarem altres mètodes més còmodes per a un curs d'iniciació.\n",
    "\n",
    "Maneres d'executar codi de Python:\n",
    "\n",
    "- Al seu entorn interactiu.\n",
    "- Des d'una terminal del Sistema Operatiu\n",
    "- Amb editors de codi: Visual Studio, PyCharm, Sublime, Atom, etc.\n",
    "- *Amb editors webs interactius basats en Jupyter Notebooks.* > en el nostre cas amb Google Colab\n",
    "\n",
    "\n",
    "### Google Colab\n",
    "Colab és un entorn d'edició i execució de codi Python basat en l'entorn de Jupyter. Jupyter un projecte de codi obert iniciat l'any 2014 que permet l'execució interactiva de petits trossos de codi. Aquesta manera de programar amb interacció contínua facilita l'aprenentatge.\n",
    "\n",
    "És un servei gratuït de Google i només és necessari tenir compte d'usuari. Per accedir a aquest notebook pitja el següent botó:\n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/wisaaco/TallerPythonFEE/blob/main/lessons/1/PythonIntroduccio.ipynb)\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Funcionament\n",
    "\n",
    "Els notebooks es divideixen en cel·les, una cel·la pot contenir codi Python o text en format Markdown ([més informació](https://jupyter-notebook.readthedocs.io/en/stable/examples/Notebook/Working%20With%20Markdown%20Cells.html)). Això ens dona la capacitat d'emprar els notebooks per generar informes intercalant codi i gràfiques amb text descriptiu.\n",
    "\n",
    "Aquesta documentació està feta amb Jupyter Notebooks!\n",
    "\n",
    "Referències a manuals de Markdown:\n",
    "\n",
    "- [Experiencie League](https://experienceleague.adobe.com/docs/contributor/contributor-guide/writing-essentials/markdown.html?lang=es)\n",
    "\n",
    "- [Documentació github](https://docs.github.com/es/get-started/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "is_executing": true
    }
   },
   "outputs": [],
   "source": [
    "# Això és un comentari d'una cella amb codi. \n",
    "# Els comentaris són importants per descriure línies de codi complicades.\n",
    "# Si et trobes a Colab pots executar aquesta cel·la fent: shit+enter o pitjant la icona de triangle\n",
    "\n",
    "print(\"Hello World !\")\n",
    "print(\"Print a list of numbers: %s\" % list(range(10)))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nocions bàsiques de Python\n",
    "\n",
    "Abans de fer feina amb dades, és necessari començar amb els elements més bàsics del llenguatge que ens serviran per entendre la lògica d'un programa.\n",
    "\n",
    "Un *programa* es pot definir com una seqüència d’operacions que s’han d’aplicar a un conjunt de dades en un ordre determinat per realitzar una tasca específica en un computador."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dades i variables\n",
    "\n",
    "Les dades que utilitzen els programes es guarden dins la memòria de l'ordinador mitjançant  variables. Com el nom indica, una variable pot canviar de contingut al llarg de l’execució d’un programa.\n",
    "\n",
    "Tenen tres característiques que les defineixen completament: el seu nom, el seu tipus i el seu valor.\n",
    "\n",
    "A continuació podem observar com podem crear diferents variables de diferents tipus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "caracter = 'a'\n",
    "estring = \"Hello!\" # Un string és una cadena de caràcters\n",
    "enter =  123\n",
    "decimal = 1.23\n",
    "complexe = 1+23j\n",
    "logic = False\n",
    "\n",
    "print(type(caracter))\n",
    "print(type(estring))\n",
    "print(type(enter))\n",
    "print(type(decimal))\n",
    "print(type(complexe))\n",
    "print(type(logic))\n",
    "\n",
    "# Pots crear totes les variables que vulguis amb format lliure.\n",
    "# Intenta que les variables tinguin un nom adequat al seu contingut.\n",
    "# No poden tenir espais, símbols i accents.\n",
    "\n",
    "nameCognoms = \"Pep Vila\"\n",
    "telefono = \"97100000\"\n",
    "dni = \"34989542A\"\n",
    "pes = 80.3\n"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Llistes\n",
    "Les llistes són un tipus de dades especial que permeten guardar diferents valors en una sola variable. De moment només mostrarem un exemple, més endavant en farem més feina:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Definirem una variable de tipus llista que conté 4 valors\n",
    "pesos = [1.3, 40.3, 20.0, -1.0]\n",
    "\n",
    "print(pesos)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operadors\n",
    "Un llenguatge de programació ofereix operacions aritmètiques i lògiques relacionades amb el tipus de dades.\n",
    "\n",
    "En Python, els **operadors** són símbols especials que indiquen que és necessari realitzar algun tipus de computació. Els valors amb els quals actua un operador es diuen **operands**.\n",
    "\n",
    "Ho entendrem amb un petit exemple:\n",
    "```python\n",
    "x = 10.0\n",
    "i = 5\n",
    "resultat = x + i\n",
    "```\n",
    "En aquest cas, l'operador `+` ens permet sumar els operands `x` i `i` junts i guardar el resultat en la variable del mateix nom. Hem de destacar que en aquest codi hem necessitat definir tres variables diferents.\n",
    "\n",
    "Un operand pot ser una variable o literal. Definim els **literals** en un programa com la idea d'expressar un valor que no canvia en el codi font, aquests han de ser d'un dels diferents tipus de dades que hem descrit\n",
    "anteriorment.\n",
    "\n",
    "A continuació tenim un altre fragment de codi en el qual usem altres operadors i literals de tipus sencer:\n",
    "\n",
    "```python\n",
    "a = 10\n",
    "b = 20\n",
    "x = 45\n",
    "r = (a + b - 5) + (x + 10 + 20)\n",
    "```\n",
    "\n",
    "#### Operadors aritmètics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Els explicarem amb un exemple sobre variables de tipus enter\n",
    "a = 10\n",
    "b = 20\n",
    "\n",
    "resultat = a + b # suma\n",
    "print(resultat)\n",
    "print(a-b) # resta\n",
    "print(-a)  # negació\n",
    "print(a*b) # multiplicació\n",
    "print(a/b) # divisió\n",
    "print(a%b) # modul\n",
    "print(a//b) # divisió entera\n",
    "print(a**b) # exponent\n",
    "print(\"---\")\n",
    "\n",
    "# Veurem que es poden emprar els mateixos operadors amb altres tipus de dades.\n",
    "\n",
    "a = 10.3\n",
    "b = 2.34\n",
    "resultat_decimal = a + b # suma\n",
    "print(resultat_decimal)\n",
    "print(a%b) # modul flotant\n",
    "print(a//b) # divisió entera\n",
    "print(a**b) # exponent\n",
    "print(\"---\")\n",
    "\n",
    "# Nombres complexes\n",
    "\n",
    "aj = 1+23j\n",
    "bj = 23j\n",
    "\n",
    "print(aj-bj) # resta complexe\n",
    "print(-aj)  # negació complexe\n",
    "print(aj*bj) # multiplicació complexe\n"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Operadors de Comparació"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "a = 10\n",
    "b = 12\n",
    "\n",
    "print(a==b) # Igualtat\n",
    "print(a!=b) # diferència\n",
    "print(a>b)\n",
    "print(a<b)\n",
    "print(a>=b)\n",
    "print(a<=b)\n",
    "\n",
    "print(\"---\")\n",
    "a = 10.0\n",
    "b = 10.0\n",
    "result = a==b\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Operadors lògics"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "a = 10.0\n",
    "b = 10.0\n",
    "c = True\n",
    "f = False\n",
    "print(not(a==b))\n",
    "print(c or f)\n",
    "print(c and (a==c))\n",
    "print(True and True)\n",
    "print(False or True)\n",
    "print(not(not(not(True))))"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Mostrar informació per pantalla\n",
    "\n",
    "Com podem intuir amb els exemples amb els operadors la funció `print` serveix per mostrar informació per pantalla. A continuació il·lustrarem usos més avançats per donar missatges complets a l'usuari:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print data\n",
    "a = \"HOLA\"  # Això és una cadena de caràcters: String\n",
    "b = 10\n",
    "c = 3.141618\n",
    "\n",
    "print(\"This is the value of a string %s\"%a)\n",
    "print(\"This is the value of a integer %i\"%b)\n",
    "print(\"This is the value of a float %f\"%c)\n",
    "print(\"This is the value of a float %0.2f\"%c)\n",
    "\n",
    "print(\"---\")\n",
    "print(\"Print a float as a integer %i\"%c)\n",
    "print(\"Print a integer as a string %s\"%b)\n",
    "\n",
    "print(\"---\")\n",
    "print(\"Print a string as a float %f\"%a) # Obtenim un ERROR!!!"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operacions de control\n",
    "\n",
    "En aquest curs no volem introduir molta complexitat, però és necessari entendre que podem fer certes operacions de control amb les dades: recorreguts de seqüències, comprovacions, etc.\n",
    "\n",
    "Els operadors condicionals ens permeten realitzar brancaments en el nostre codi.\n",
    "\n",
    "Tenim la següent construcció que permet tenir dues branques d'execució en el codi:\n",
    "```\n",
    "if <expr>:\n",
    "    <cos(+)>\n",
    "else:\n",
    "    <cos(+)>\n",
    "```\n",
    "\n",
    "L' `<expr>` és una expressió de tipus lògic, és a dir s'ha de poder avaluar com a `True` o `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Pep\"\n",
    "grau = 0.3\n",
    "\n",
    "if name == \"Pep\":  # Si el nom és Pep multiplicar per 10\n",
    "    factor = 10\n",
    "else:  # Si és diferent llavors multiplicar per 1\n",
    "    factor = 1\n",
    "\n",
    "grau = grau * factor\n",
    "print(\"Grau d'amistat amb %s es: %f \" % (name, grau))"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "Ens pot ser molt útil fer bucles per iterar sobre les llistes. La seva estructura bàsica és:\n",
    "\n",
    "```\n",
    "for <var> in <iterable>:\n",
    "    <cos(s)>\n",
    "```\n",
    "\n",
    "Una llista és un `iterable` però més endavant veurem que hi ha altres tipus de dades que també ho són.\n",
    "\n",
    "A continuació teniu un exemple:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = [\"Pep\",\"Lluis\",\"Paco\"] # Llista\n",
    "\n",
    "for name in names: # Bucle\n",
    "    grau = 0.3\n",
    "\n",
    "    if name == \"Pep\": # Condicional dins el bucle\n",
    "        factor = 10\n",
    "    else: \n",
    "        factor = 1\n",
    "\n",
    "    grau = grau * factor\n",
    "    print(\"Grau d'amistat amb %s es: %f \"%(name,grau))"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "Potser trobarem aquest altre tipus de bucle, anomenat bucle `while` o indefinit:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = [\"Pep\",\"Lluis\",\"Paco\"]\n",
    "\n",
    "i = 0\n",
    "while i < len(names):\n",
    "    print(names[i]) # accedim als elements d'una llista mitjançant el seu índex\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Activitats inicials\n",
    "\n",
    "1. Tenim una variable anomenada `celsius` amb valor 33 i volem saber quants graus Kelvin són. Construeix una expressió que faci aquesta transformació. Simplement, suma 273,15 als graus Celsius per obtenir la temperatura equivalent en Kelvin.\n",
    "2. Assigna un nombre real a una variable anomenada `nombre` i mostra per pantalla un missatge que indica si `nombre` es troba en el rang (-1.0, 1.0) o no.\n",
    "3. La formula per resoldre una equació de segon grau és la següent: `x` = (-`b` ± √(`b`² - 4`ac`)) / (2`a`). Fes un codi on assignis els coeficients `a`, `b` i `c` i mostris per pantalla els valors de `x`.\n",
    "4. Escriu un programa que calculi la mitjana de la següent llista de nombres. `nombres = [5,7,8,9,3,10]`. Versió difícil, empra un bucle `while`."
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Fer els exercicis aquí"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables més complexes\n",
    "\n",
    "Al principi del tema hem vist un tipus de variable que organitza la informació de manera ordenada i que és mutable: una llista. Però com ja hem comentat abans, existeixen altres estructures de dades per cobrir diferents necessitats:\n",
    "\n",
    "- **Tuples:** Les tuples són similars a les llistes. Es defineixen especificant els elements entre parèntesis en comptes de claudàtors. Per altra banda, són immutables, no es poden modificar.\n",
    "\n",
    "- **Diccionaris:** Un diccionari consisteix en una col·lecció no ordenada de parells de clau-valor. A diferència de les seqüències, indexades per un rang de nombres, els diccionaris són indexats per claus que poden ser de qualsevol tipus immutable; els strings i els nombres sempre poden ser claus d'un diccionario. Les tuples es poden utilitzar com a claus. No podem emprar llistes com a claus, ja que les llistes es poden modificar.\n",
    "\n",
    "- **Conjunts:** també conegut com a _set_, és una col·lecció de dades no ordenada i mutable que pot contenir elements únics. En altres paraules, un set no permet elements duplicats i no manté l'ordre dels elements com ho fa una llista o una tupla.\n",
    "\n",
    "#### Operadors i funcions\n",
    "\n",
    "Python ens proveeix de tota una sèrie d’operacions que ens permeten obtenir informació de les llistes, tenim funcions ja programades que ens permetran estalviar molta feina.\n",
    "\n",
    "*Operadors*\n",
    "\n",
    "L’operador `in` i el modificador `not` ens permeten saber si un element és o no és a la nostra llista. Aquests dos mètodes serveixen, per exemple, per saber si un element és a una llista abans d’eliminar-ho.\n",
    "\n",
    "*Funcions*\n",
    "\n",
    "Hi ha tot un seguit de funcions ja definides a Python que ens permeten obtenir informació d’una estructura de dades:\n",
    "\n",
    "- len: ens retorna un enter amb la longitud de la llista.\n",
    "- min: ens retorna el valor més petit de la llista.\n",
    "- max: ens retorna el valor més gran de la llista.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "llistes =  [\"Pep\",\"Lluis\",\"Paco\"]  # Emprem claudàtor per definir llistes\n",
    "print(llistes)\n",
    "print(llistes[0])  # consultem la primera posició\n",
    "\n",
    "llistes[1] = \"Ramon\"  # Podem modificar una posició d'una llista\n",
    "\n",
    "print(len(llistes))  # La funció len ens indica el nombre d'elements de la llista\n",
    "\n",
    "print(\"-\"*20)\n",
    "\n",
    "tuples = (\"Pep\", 33, \"3490940A\")  # Creació d'una tupla, emprem parèntesi\n",
    "print(tuples)\n",
    "print(tuples[1])  # consultem la primera posició\n",
    "\n",
    "print(\"-\"*20)\n",
    "\n",
    "diccionaris = { \"Pep\": \"324345C\", \"Lluis\":\"493094B\", \"Paco\":\"309403A\"} # Claus\n",
    "print(diccionaris)\n",
    "print(len(diccionaris))\n",
    "print(diccionaris.keys())\n",
    "print(diccionaris.values())\n",
    "print(diccionaris[\"Pep\"])\n",
    "\n",
    "\n",
    "print(\"-\"*20)\n",
    "\n",
    "conjunt = set([0,2,2,3,\"Pep\",\"Paco\",\"Pep\"])\n",
    "print(conjunt)\n",
    "print(len(conjunt))\n",
    "print(\"Paco\" in conjunt)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "És molt important conèixer el tipus de cada composició d'una variable i dels seus mètodes associats, el que es coneix amb el nom de _built types_.\n",
    "\n",
    "Emprarem la funció `type`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "codiPostal = { \"Palma\": [\"07004\",\"07122\"], \"Inca\": [\"07300\"]}\n",
    "\n",
    "print(type(codiPostal))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(codiPostal[\"Palma\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(codiPostal[\"Palma\"][0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if \"07122\" in codiPostal[\"Palma\"]:\n",
    "    print(\"El codi 07122 és el CP de la UIB\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "codiPostal[\"Sineu\"] = [\"07510\"]\n",
    "print(codiPostal)\n",
    "print(len(codiPostal))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "codiPostal[\"Sineu\"].append(\"07511\")\n",
    "\n",
    "for key in codiPostal:\n",
    "    print(key, codiPostal[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Llibreries\n",
    "\n",
    "Python inclou moltes funcionalitats de base, però hi ha llibreries que donem molt de potencial. Pràcticament, ja està tot implementat en el nucli de Python i a les seves llibreries.\n",
    "\n",
    "A Google Colab no cal instal·lar-ne cap, però a una plataforma pròpia si seria necessari. En aquest curs introductori no cobrirem aquest punt.\n",
    "\n",
    "### Llibreria `math`\n",
    "\n",
    "Hi ha llibreries incloses en el nucli de Python. Estan instal·lades, però per defecte no es carreguen. Per exemple  `math`  és una llibreria estàndard que proporciona un conjunt ampli de funcions i constants matemàtiques. Aquesta llibreria inclou funcions i constants que no estan disponibles per defecte a Python, com ara les funcions trigonomètriques, exponencials, logarítmiques i moltes altres que poden ser útils en càlculs científics i matemàtics.\n",
    "\n",
    "Documentació a la llibreria math: [enllaç](https://docs.python.org/3/library/math.html).\n",
    "\n",
    "Per poder emprar-la és necessari carregar-la o en argot informàtic: importar-la. A continuació en teniu un exemple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import math  ## codi per carregar la llibreria math\n",
    "\n",
    "preus = [33, 44.2, 12.4, 5.8]\n",
    "\n",
    "print(math.sqrt(preus[0])) # arrel quadrada de 33\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Llibreria Numpy\n",
    "\n",
    "Numpy és una llibreria de Python que proporciona suport per a arrays multidimensionals (matrius) i funcions matemàtiques d'alt rendiment per a realitzar operacions numèriques i científiques. És una de les llibreries més importants i més utilitzades en el camp de la computació científica, l'anàlisi de dades i la manipulació de dades numèriques en Python.\n",
    "\n",
    "Documentació de la llibreria [Numpy](https://numpy.org/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hi ha d'altres llibreries com Numpy que cal instal·lar-les\n",
    "import numpy as np #np és un alias\n",
    "\n",
    "preus = np.array(preus)  # transformam una llista al tipus de dades de Numpy, una matriu unidimensional (vector)\n",
    "print(preus.mean())\n",
    "print(preus.std())\n",
    "print(preus.min())\n",
    "print(preus.max())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "Numpy permet dur a terme operacions vectorials, el que evita haver de programar bucles:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "preusIVA = preus * 1.21 # Operacions aritmètiques\n",
    "print(preusIVA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(preus>10.0) # Operacions lògiques\n",
    "print(preus[preus>10.0])"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### Slicing\n",
    "\n",
    "Python també permet una sintaxi d’indexació avançada que permet extreure subllistes d’una llista. Aquesta tècnica és coneguda com a slicing. Sigui `ll` una variable que identifica una llista, una expressió de la forma `ll[inici:final]` retorna la porció de ‘ll’ que comença en la posició `inici`, i acaba en la posició `final-1`. És a dir, la posició indexada per `final` no és inclosa dins aquesta subllista.\n",
    "\n",
    "En resum, podem fer les següents seleccions:\n",
    "\n",
    "```\n",
    "a[inici:final]  # elements de la llista de la posició inici fins la posició final-1.\n",
    "a[inici:]       # elements de la llista de la posició inici fins al final de la llista.\n",
    "a[:final]       # elements de la llista de la primera posició fins la posició final-1.\n",
    "a[:]            # seleccionam tota la llista\n",
    "```\n",
    "\n",
    "Vegem un exemple de slicing en codi Python:"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Seleccio (slicing)\n",
    "print(preus)\n",
    "print(preus[3])\n",
    "print(preus[-1])\n",
    "\n",
    "print(\"-\"*30)\n",
    "\n",
    "print(preus[:3])\n",
    "print(preus[:-1])\n",
    "print(preus[2:4])\n",
    "print(preus[6:])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Activitats de resum\n",
    "\n",
    "S'ha fet un petit estudi de mercat del preu d'origen de certs productes. Són preus per kilogram durant quatre dies.\n",
    "\n",
    "Es demana:\n",
    "\n",
    "1. Quin és el preu màxim de cada producte?\n",
    "\n",
    "2. Quin és el producte més car?\n",
    "\n",
    "3. Quin dia són més cares les taronges?\n",
    "\n",
    "4. Si el preu de mercat és tres vegades més (x3), fes un nou diccionari amb el \"preuMercat\".\n",
    "\n",
    "5. Quin és el cost de comprar a \"preu de mercat\", 3 KG de taronges i 2,5 KG de cebes el dia 2?\n",
    "\n",
    "L'objectiu d'aquesta activitat és la consolidació de les estructures bàsiques de Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "preuOrigin = {\n",
    "              \"ceba\":  [30.3, 20.3, 25.9, 39.0], # cèntims/kg !!! ALERTA\n",
    "              \"patata\":[0.33, 0.43, 0.34, 0.12], # euro/kg\n",
    "              \"taronja\":[0.45, 0.56, 0.38, 0.43] # euro/kg\n",
    "              }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 5."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Activitat 1.1 del homework\n",
    "\n",
    "Com a final del dia d'avui i per la setmana que vé heu d'entregar aquesta activitat."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![License: CC BY 4.0](https://img.shields.io/badge/License-CC_BY_4.0-lightgrey.svg)](https://creativecommons.org/licenses/by/4.0/) <br/>\n",
    "Isaac Lera and Gabriel Moya <br/>\n",
    "Universitat de les Illes Balears <br/>\n",
    "isaac.lera@uib.edu, gabriel.moya@uib.edu"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.7 64-bit ('3.9.7')",
   "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.9.7"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "1dd6de46b7c7be538353ccdeaa948031a5b4d43665739a26f55ca28b247c53cc"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}