introPython.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25.0\n",
      "4.5\n",
      "Pedro\n"
     ]
    }
   ],
   "source": [
    "# variables\n",
    "# descriptivas l=4 \n",
    "# comienzan por una letra (4l=8)\n",
    "# no usan caracteres especiales (l$=8)\n",
    "# correcto\n",
    "# casting\n",
    "# el nombre de una variable lleva letras y números y algunos simbolos _\n",
    "# el nombre sea descriptivo\n",
    "nombre_persona='Pedro' # cadena de caracteres\n",
    "# area=lado*lado esto es error porque no esta definido aún\n",
    "altura=3 # de tipo flotante, haciendo un casting\n",
    "lado=5.0 # esto es un flotante directo\n",
    "# lado*=4 esto es un error\n",
    "# operadores *,/,+,- (aritméticos) >,<\n",
    "area=lado*lado\n",
    "print(area)\n",
    "base=3\n",
    "area=base*altura/2.0\n",
    "print(area)\n",
    "print(nombre_persona)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tiene coronavirus\n",
      "cuidémonos todos\n",
      "Tiene coronavirus\n",
      "tiene coronavirus\n",
      "Tiene coronavirus\n",
      "cuarentena\n"
     ]
    }
   ],
   "source": [
    "# control de flujo de programa\n",
    "temperaturaPersona=38\n",
    "if temperaturaPersona>37:\n",
    "    print('Tiene coronavirus')\n",
    "print('cuidémonos todos')\n",
    "\n",
    "if temperaturaPersona>37:\n",
    "    print('Tiene coronavirus')\n",
    "else:\n",
    "    print('Esta saludable')\n",
    "\n",
    "if temperaturaPersona<20:\n",
    "    print('ya se petateo')\n",
    "elif temperaturaPersona<28&temperaturaPersona>25:\n",
    "    print('Esta saludable')\n",
    "else:\n",
    "    print('tiene coronavirus')\n",
    "\n",
    "# if anidado\n",
    "nacionalidad='mexicano'\n",
    "if temperaturaPersona>37:\n",
    "    print('Tiene coronavirus')\n",
    "    if nacionalidad=='gringo':\n",
    "        print('repatriarlo')\n",
    "    else:\n",
    "        print('cuarentena')\n",
    "else:\n",
    "    print('Esta saludable')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ejercicios de condiciones\n",
    "# dividir A/B validando que B no sea cero\n",
    "# calcule cuantos segundos hay en m dias, n horas y o minutos\n",
    "# dada una cantidad en pesos, indique cuantos billetes de a 500 y cuantos de 200, de 100 y monedas debe dar el cajero\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "temperatura10\n",
      "temperatura15\n",
      "temperatura25\n",
      "temperatura30\n",
      "clima encendido\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "2\n",
      "3\n",
      "4\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "# ciclo\n",
    "# imprime los número del 0 al 4\n",
    "for i in range(5):\n",
    "    print(i)\n",
    "# imprime los número del 2 al 4\n",
    "for i in range(2,5):\n",
    "    print(i)\n",
    "# imprime los números del 2 al 10 con incrementos de 2\n",
    "for i in range(2,10,2):\n",
    "    print(i)\n",
    "# se usan cuando uno conoce de forma precisa el número de repeticiones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 0)\n",
      "(0, 1)\n",
      "(0, 2)\n",
      "(0, 3)\n",
      "(1, 0)\n",
      "(1, 1)\n",
      "(1, 2)\n",
      "(1, 3)\n",
      "(2, 0)\n",
      "(2, 1)\n",
      "(2, 2)\n",
      "(2, 3)\n",
      "(3, 0)\n",
      "(3, 1)\n",
      "(3, 2)\n",
      "(3, 3)\n"
     ]
    }
   ],
   "source": [
    "# ciclos anidados\n",
    "for i in range(4):\n",
    "    for j in range(4):\n",
    "        print(i,j)\n",
    "\n",
    "# ejercicios \n",
    "# convertidor de números entre diferentes bases"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 1)\n",
      "(1, 2, 2)\n",
      "(1, 3, 3)\n",
      "(1, 4, 4)\n",
      "(1, 5, 5)\n",
      "(1, 6, 6)\n",
      "(1, 7, 7)\n",
      "(1, 8, 8)\n",
      "(1, 9, 9)\n",
      "(1, 10, 10)\n",
      "(2, 1, 2)\n",
      "(2, 2, 4)\n",
      "(2, 3, 6)\n",
      "(2, 4, 8)\n",
      "(2, 5, 10)\n",
      "(2, 6, 12)\n",
      "(2, 7, 14)\n",
      "(2, 8, 16)\n",
      "(2, 9, 18)\n",
      "(2, 10, 20)\n",
      "(3, 1, 3)\n",
      "(3, 2, 6)\n",
      "(3, 3, 9)\n",
      "(3, 4, 12)\n",
      "(3, 5, 15)\n",
      "(3, 6, 18)\n",
      "(3, 7, 21)\n",
      "(3, 8, 24)\n",
      "(3, 9, 27)\n",
      "(3, 10, 30)\n",
      "(4, 1, 4)\n",
      "(4, 2, 8)\n",
      "(4, 3, 12)\n",
      "(4, 4, 16)\n",
      "(4, 5, 20)\n",
      "(4, 6, 24)\n",
      "(4, 7, 28)\n",
      "(4, 8, 32)\n",
      "(4, 9, 36)\n",
      "(4, 10, 40)\n",
      "(5, 1, 5)\n",
      "(5, 2, 10)\n",
      "(5, 3, 15)\n",
      "(5, 4, 20)\n",
      "(5, 5, 25)\n",
      "(5, 6, 30)\n",
      "(5, 7, 35)\n",
      "(5, 8, 40)\n",
      "(5, 9, 45)\n",
      "(5, 10, 50)\n",
      "(6, 1, 6)\n",
      "(6, 2, 12)\n",
      "(6, 3, 18)\n",
      "(6, 4, 24)\n",
      "(6, 5, 30)\n",
      "(6, 6, 36)\n",
      "(6, 7, 42)\n",
      "(6, 8, 48)\n",
      "(6, 9, 54)\n",
      "(6, 10, 60)\n",
      "(7, 1, 7)\n",
      "(7, 2, 14)\n",
      "(7, 3, 21)\n",
      "(7, 4, 28)\n",
      "(7, 5, 35)\n",
      "(7, 6, 42)\n",
      "(7, 7, 49)\n",
      "(7, 8, 56)\n",
      "(7, 9, 63)\n",
      "(7, 10, 70)\n",
      "(8, 1, 8)\n",
      "(8, 2, 16)\n",
      "(8, 3, 24)\n",
      "(8, 4, 32)\n",
      "(8, 5, 40)\n",
      "(8, 6, 48)\n",
      "(8, 7, 56)\n",
      "(8, 8, 64)\n",
      "(8, 9, 72)\n",
      "(8, 10, 80)\n",
      "(9, 1, 9)\n",
      "(9, 2, 18)\n",
      "(9, 3, 27)\n",
      "(9, 4, 36)\n",
      "(9, 5, 45)\n",
      "(9, 6, 54)\n",
      "(9, 7, 63)\n",
      "(9, 8, 72)\n",
      "(9, 9, 81)\n",
      "(9, 10, 90)\n",
      "(10, 1, 10)\n",
      "(10, 2, 20)\n",
      "(10, 3, 30)\n",
      "(10, 4, 40)\n",
      "(10, 5, 50)\n",
      "(10, 6, 60)\n",
      "(10, 7, 70)\n",
      "(10, 8, 80)\n",
      "(10, 9, 90)\n",
      "(10, 10, 100)\n"
     ]
    }
   ],
   "source": [
    "# ciclos anidados\n",
    "for i in range(1,11):\n",
    "    for j in range(1,11):\n",
    "        print(i,j,i*j)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "temperatura5\n",
      "clima agradable\n",
      "temperatura30\n",
      "clima agradable\n",
      "enfriando\n"
     ]
    }
   ],
   "source": [
    "# ciclos\n",
    "temperatura=0\n",
    "while temperatura<30:\n",
    "    temperatura=int(input('temperatura'))\n",
    "    print('clima agradable')\n",
    "print('enfriando')\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 0)\n",
      "(5, 0)\n",
      "(2, 1)\n",
      "(1, 0)\n",
      "(0, 1)\n"
     ]
    }
   ],
   "source": [
    "#10 a binario\n",
    "#10/2=5,0\n",
    "#5/2=2,1\n",
    "#2/2=1, 0\n",
    "#1/2=0,1\n",
    "#10=1010\n",
    "decimal=20\n",
    "while decimal>0:\n",
    "    residuo=decimal%2\n",
    "    decimal=decimal/2\n",
    "    print(decimal,residuo)\n",
    "# tarea convertir de decimal a octal, decimal a hexadecimal\n",
    "# resolver un sistema de ecuaciones por gauss-seidel, \n",
    "# encontrar el cruce por cero de una ecuación: bisección, newton, punto medio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola mundo\n",
      "-1.0 -0.2 -0.6\n",
      "-1.0 -0.6 -0.8\n",
      "-0.8 -0.6 -0.7\n",
      "-0.8 -0.7 -0.75\n",
      "-0.75 -0.7 -0.725\n",
      "-0.725 -0.7 -0.7124999999999999\n",
      "-0.7124999999999999 -0.7 -0.7062499999999999\n",
      "-0.7062499999999999 -0.7 -0.703125\n",
      "-0.703125 -0.7 -0.7015625\n",
      "-0.7015625 -0.7 -0.7007812499999999\n",
      "-0.7007812499999999 -0.7 -0.7003906249999999\n",
      "-0.7003906249999999 -0.7 -0.7001953125\n",
      "-0.7001953125 -0.7 -0.70009765625\n"
     ]
    }
   ],
   "source": [
    "# método de bisección\n",
    "import math\n",
    "x1=-1.0\n",
    "x2=-0.2\n",
    "error=1000000.0\n",
    "while error>0.0001:\n",
    "    xm=(x1+x2)/2\n",
    "    error=abs(x1-xm)\n",
    "    fx1=4*math.pow(x1,2)+3*x1\n",
    "    fx2=4*math.pow(x2,2)+3*x2\n",
    "    fxm=4*math.pow(xm,2)+3*xm\n",
    "    print(x1,x2,xm)\n",
    "    if fxm*fx1<0:\n",
    "        x2=xm\n",
    "    else:\n",
    "        x1=xm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a=4, b=8, c=7\n",
    "# imprimir el menor de estos tres numeros\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 4\n",
      "0 2.0\n",
      "0 1.0\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'sumador' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-4-c19e70c6ce0b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0macumulador\u001b[0m\u001b[0;34m+=\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mcontador\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0mcontador\u001b[0m\u001b[0;34m/=\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msumador\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'sumador' is not defined"
     ]
    }
   ],
   "source": [
    "binario=['1','0','0'] # lista\n",
    "contador=4\n",
    "acumulador=0\n",
    "for i in binario:\n",
    "    print(i,contador)\n",
    "    acumulador+=int(i)*contador\n",
    "    contador/=2\n",
    "print(sumador)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('0', 4)\n",
      "1001\n",
      "1110\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# convertidor de binario a hexadecimal\n",
    "cadena=\"1001\"\n",
    "print(cadena[2], len(cadena))\n",
    "numBinario=\"111101001\"\n",
    "#numBinario=[1,1,1,1,0,1,0,0,1]\n",
    "sobra=len(numBinario)%4\n",
    "numciclos=int((len(numBinario)/4))\n",
    "if sobra>0:\n",
    "    numciclos+=1\n",
    "inicial=4\n",
    "final=0\n",
    "for i in range(numciclos):\n",
    "    if i==0:\n",
    "        numhex=numBinario[-inicial:]\n",
    "    else:\n",
    "        numhex=numBinario[-inicial:-final]\n",
    "    inicial+=4\n",
    "    final+=4\n",
    "    print(numhex)\n",
    "    if numhex==[0,0,0,0]:\n",
    "        print(0)\n",
    "    if numhex==[0,0,0,1]:\n",
    "        print(1)\n",
    "    if numhex==[0,0,1,0]:\n",
    "        print(2)\n",
    "    if numhex==[0,0,1,1]:\n",
    "        print(3)\n",
    "    if numhex==[0,1,0,0]:\n",
    "        print(4)\n",
    "    if numhex==[0,1,0,1]:\n",
    "        print(5)\n",
    "    if numhex==[0,1,1,0]:\n",
    "        print(6)\n",
    "#for i in numBinario:\n",
    "#    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3,) int64\n",
      "2\n",
      "[ 4.  8. 12.]\n",
      "[5 7 9]\n",
      "6\n",
      "3\n",
      "[ 4 10 18]\n"
     ]
    }
   ],
   "source": [
    "# matrices de una dimension\n",
    "import numpy as np\n",
    "vector1=np.array([1,2,3])\n",
    "vector2=np.array([4,5,6])\n",
    "print(vector1.shape,vector1.dtype)\n",
    "multi=np.zeros(3)\n",
    "suma=np.array([0,0,0])\n",
    "# accesando un valor\n",
    "print(vector1[1])\n",
    "# multiplicacion de un vector\n",
    "for i in range(3):\n",
    "    multi[i]=vector1[i]*4\n",
    "print(multi)\n",
    "\n",
    "for i in range(0,3):\n",
    "    suma[i]=vector1[i]+vector2[i]\n",
    "print(suma)\n",
    "    \n",
    "# suma de los elementos\n",
    "# sumador i vector[i] sumador+=vector[i]\n",
    "#   0\n",
    "#   0     0  1        1\n",
    "#   1     1  2        3\n",
    "#   3     2  3        6\n",
    "sumador=0\n",
    "for i in range(3):\n",
    "    sumador+=vector1[i]\n",
    "print(sumador)\n",
    "# calcula el maximo\n",
    "maximo=0\n",
    "for i in range(3):\n",
    "    if vector1[i]>maximo:\n",
    "        maximo=vector1[i]\n",
    "print(maximo)\n",
    "\n",
    "print(vector1*vector2.transpose())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "[3 4]\n",
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "# indexing\n",
    "import numpy as np\n",
    "m1=np.array([1,2,3,4,5,6])\n",
    "# accesando a un elemento\n",
    "print(m1[3])\n",
    "# accesando a los elementos 2,3 y 4\n",
    "print(m1[2:4])\n",
    "# accesando a todos los primeros elementos hasta la posición 3\n",
    "print(m1[:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]] (3, 3)\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# matrices de dos dimensiones\n",
    "import numpy as np\n",
    "m=np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "print(m,m.shape)\n",
    "print(m[1,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# matrices de dos dimensiones\n",
    "# suma de las columnas y renglones\n",
    "# suma de la diagonal principal\n",
    "# solucion de ecuaciones de gauss y gauss-jordan\n",
    "# suma y multiplicacion de dos matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  3   1   1   2]\n",
      " [  0   3 -12   3]\n",
      " [  0   0  18  27]]\n"
     ]
    }
   ],
   "source": [
    "# solución de un sistema de ecuaciones por el método de Gauss\n",
    "from numpy import *\n",
    "m=array([[3,1,1,2],[5,1,-4,1],[7,1,2,3]])\n",
    "for i in range(2):\n",
    "    for j in range(i+1,3):\n",
    "        for k in range(4):\n",
    "            m[j][k]=m[i][i]*m[j][k]-m[j][i]*m[i][k]\n",
    "print(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1.0, 1.0, 1.0)\n",
      "(2.6166666666666667, -2.7945238095238096, 7.005609523809525)\n",
      "(0.1250234998996312, 0.11797736136506948, 0.0007597845414304334)\n",
      "(2.990556507936508, -2.499624684807256, 7.00029081106576)\n"
     ]
    }
   ],
   "source": [
    "# solución de ecuaciones por gauss-seidel\n",
    "errordeseado=.001\n",
    "errorcalculadox1=1000\n",
    "errorcalculadox2=1000\n",
    "errorcalculadox3=1000\n",
    "x1=0.0\n",
    "x2=0.0\n",
    "x3=0.0\n",
    "iteracion=0\n",
    "while errorcalculadox1>errordeseado and errorcalculadox2>errordeseado and errorcalculadox3>errordeseado:\n",
    "    x1n=(7.85+0.1*x2+0.2*x3)/3\n",
    "    x2n=(-19.3-0.1*x1n+0.3*x3)/7\n",
    "    x3n=(71.4-0.3*x1n+0.2*x2n)/10\n",
    "    errorcalculadox1=abs((x1n-x1)/x1n)\n",
    "    errorcalculadox2=abs((x2n-x2)/x2n)\n",
    "    errorcalculadox3=abs((x3n-x3)/x3n)\n",
    "    print(errorcalculadox1,errorcalculadox2,errorcalculadox3)\n",
    "    x1=x1n\n",
    "    x2=x2n\n",
    "    x3=x3n\n",
    "    iteracion+=1\n",
    "    print(x1,x2,x3)\n",
    "    if iteracion>100:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "volkswagen\n",
      "nissan\n",
      "ford\n",
      "volkswagen\n",
      "kia\n",
      "nissan\n",
      "volkswagen\n",
      "kia\n",
      "ford\n",
      "['tsuru', 'tiida']\n",
      "['jetta', 'vento']\n",
      "['rio']\n",
      "['focus']\n",
      "['focus']\n"
     ]
    }
   ],
   "source": [
    "# listas y diccionarios\n",
    "listavacia=[]\n",
    "marcasautos=['nissan','ford','volkswagen']\n",
    "marcasautos.append('kia')\n",
    "print(marcasautos[2])\n",
    "for i in marcasautos:\n",
    "    print(i)\n",
    "diccionariovacio={}\n",
    "diccionarioautos={'nissan':['tsuru','tiida'],'ford':['focus'],'volkswagen':['jetta','vento']}\n",
    "# agregando datos al diccionario\n",
    "diccionarioautos['kia']=['rio']\n",
    "# acceso a las llaves\n",
    "for llave in diccionarioautos:\n",
    "    print(llave)\n",
    "# acceso a los valores de cada llave\n",
    "for valores in diccionarioautos.values():\n",
    "    print(valores)\n",
    "# acceso a los valores de una llave\n",
    "print(diccionarioautos['ford'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 13\n"
     ]
    }
   ],
   "source": [
    "# funciones\n",
    "def sumar(a,b):\n",
    "    resultado=a+b\n",
    "    return resultado\n",
    "\n",
    "print(sumar(4,3),sumar(5,8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1.0, 1.0, 1.0)\n",
      "(2.6166666666666667, -2.7945238095238096, 7.005609523809525)\n",
      "(0.1250234998996312, 0.11797736136506948, 0.0007597845414304334)\n",
      "(2.990556507936508, -2.499624684807256, 7.00029081106576)\n"
     ]
    }
   ],
   "source": [
    "# funciones y funciones lambda\n",
    "def calculaerror(valor1,valor2):\n",
    "    error=abs((valor1-valor2)/valor1)\n",
    "    return error\n",
    "errordeseado=.001\n",
    "errorcalculadox1=1000\n",
    "errorcalculadox2=1000\n",
    "errorcalculadox3=1000\n",
    "x1=0.0\n",
    "x2=0.0\n",
    "x3=0.0\n",
    "iteracion=0\n",
    "while errorcalculadox1>errordeseado and errorcalculadox2>errordeseado and errorcalculadox3>errordeseado:\n",
    "    x1n=(7.85+0.1*x2+0.2*x3)/3\n",
    "    x2n=(-19.3-0.1*x1n+0.3*x3)/7\n",
    "    x3n=(71.4-0.3*x1n+0.2*x2n)/10\n",
    "    errorcalculadox1=calculaerror(x1n,x1)\n",
    "    errorcalculadox2=calculaerror(x2n,x2)\n",
    "    errorcalculadox3=calculaerror(x3n,x3)\n",
    "    print(errorcalculadox1,errorcalculadox2,errorcalculadox3)\n",
    "    x1=x1n\n",
    "    x2=x2n\n",
    "    x3=x3n\n",
    "    iteracion+=1\n",
    "    print(x1,x2,x3)\n",
    "    if iteracion>100:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "global b\n",
    "def sumar(a):\n",
    "    global b\n",
    "    b=3\n",
    "    print(a+b)\n",
    "numero=5\n",
    "sumar(numero)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# funciones lambda\n",
    "sumar= lambda a:a+3\n",
    "restar=lambda a,b:a-b\n",
    "print(sumar(5))\n",
    "print(restar(7,3))\n",
    "# 10 ejercicios con funciones comunes y 10 con funciones lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# manejo de archivos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0\n",
      "0 1\n",
      "0 2\n",
      "1 0\n",
      "1 1\n",
      "1 2\n",
      "[[ 2.  4.  6.]\n",
      " [ 8. 10. 12.]]\n"
     ]
    }
   ],
   "source": [
    "# c(0,0)=a(0,0)+b(0,0) c(0,1)=a(0,1)+b(0,1) a(0,2)+b(0,2)\n",
    "# a(1,0)+b(1,0) a(1,1)+b(1,1) a(1,2)+b(1,2)\n",
    "import numpy as np\n",
    "sumar= lambda a,b:a+b\n",
    "a=np.array([[1,2,3],[4,5,6]])\n",
    "b=np.array([[1,2,3],[4,5,6]])\n",
    "c=np.zeros([2,3])\n",
    "for renglon in range(2):\n",
    "    for columna in range(3):\n",
    "        c[renglon][columna]=sumar(a[renglon][columna],b[renglon][columna])\n",
    "        #c[renglon][columna]=a[renglon][columna]+b[renglon][columna]\n",
    "        print(renglon,columna)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 4  5  6  7]\n",
      " [ 7  8  9 10]]\n",
      "1\n",
      "0 1\n",
      "4\n",
      "0 2\n",
      "7\n",
      "5\n",
      "1 2\n",
      "8\n",
      "9\n",
      "1 0\n",
      "2\n",
      "2 0\n",
      "3\n",
      "2 1\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "# pivotes 0,0 1,1 2,2\n",
    "# pivote (0,0) elementos abajo:4,7 (1,0)(2,0)\n",
    "# pivote(1,1) elementos abajo:8 (2,1)\n",
    "import numpy as np\n",
    "m=np.array([[1,2,3,4],[4,5,6,7],[7,8,9,10]])\n",
    "print(m)\n",
    "renglon,columna=m.shape\n",
    "# ceros los elementos abajo de la diagonal principal\n",
    "for i in range(renglon):\n",
    "    print(m[i][i])\n",
    "    for j in range(i+1,renglon):\n",
    "        print(i,j)\n",
    "        print(m[j][i])\n",
    "# hacer ceros los elementos arriba de la diagonal principal\n",
    "# pivotes 0,0 1,1 2,2\n",
    "#pivote 0,0\n",
    "# pivote (1,1), elementos arriba: 2 (0,1)\n",
    "# pivote (2,2), elementos arriba: 3,6 (0,2) (1,2)\n",
    "for i in range(renglon):\n",
    "    for j in range(0,i):\n",
    "        print(i,j)\n",
    "        print(m[j][i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mi llanta tiene un diametro de 15 y una presion de 30\n",
      "Help on method valores in module __main__:\n",
      "\n",
      "valores() method of __main__.llanta instance\n",
      "    esta es la ayuda del método valores\n",
      "\n",
      "15 30\n",
      "30\n",
      "15 100\n",
      "15 30\n"
     ]
    }
   ],
   "source": [
    "# primera generación\n",
    "# programas cortos\n",
    "# difíciles de actualizar\n",
    "\n",
    "# segunda generación\n",
    "# programación estructurada\n",
    "# sencillo de entender\n",
    "# programas grandes son complejos\n",
    "# no reutilización de código, herencia, abstracción\n",
    "\n",
    "# Programación orientada a objetos\n",
    "# si reutilización de código, herencia, abstracción\n",
    "# forma de pensar diferente (objetos: pelota)\n",
    "class llanta:\n",
    "    # constructor\n",
    "    def __init__(self):\n",
    "        # atributos\n",
    "        self.diametro=15\n",
    "        self.presion=30\n",
    "    def __repr__(self):\n",
    "        return 'mi llanta tiene un diametro de {} y una presion de {}'.format(self.diametro,self.presion)\n",
    "    # métodos\n",
    "    def get_presion(self):\n",
    "        return self.presion\n",
    "    def valores(self):\n",
    "        \"\"\"\n",
    "        esta es la ayuda del método valores\n",
    "        \"\"\"\n",
    "        print(self.diametro,self.presion)\n",
    "        \n",
    "    def inflar(self, valorpresion):\n",
    "        self.presion=valorpresion\n",
    "# objeto\n",
    "goodyear=llanta() \n",
    "print(goodyear)\n",
    "help(goodyear.valores)\n",
    "# imprime los valores asignados por el constructor\n",
    "goodyear.valores()\n",
    "presion=goodyear.get_presion()\n",
    "print(presion)\n",
    "# llama el método y modifica una propiedad\n",
    "goodyear.inflar(100)\n",
    "# imprime los atributos después de ser modificados por un método\n",
    "goodyear.valores()\n",
    "# crea un nuevo objeto\n",
    "firestone=llanta()\n",
    "firestone.valores()\n",
    "#firestone.inflar(15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "estoy rebotando\n",
      "8.0\n",
      "10\n",
      "20\n",
      "estoy rebotando\n"
     ]
    }
   ],
   "source": [
    "# pelota\n",
    "import numpy as np\n",
    "class pelota:\n",
    "    def __init__(self):\n",
    "        # constructor\n",
    "        # propiedades\n",
    "        self.presion=8.0\n",
    "        self.valores_validos=np.array([10,20,30])\n",
    "        self.numero_paneles=4\n",
    "    # métodos\n",
    "    def set_presion(self,valor):\n",
    "        if valor>50:\n",
    "            print('no es posible')\n",
    "        else:\n",
    "            for i in self.valores_validos:\n",
    "                if i==valor:\n",
    "                    self.presion=valor\n",
    "    def get_presion(self):\n",
    "        return self.presion\n",
    "    def rebota(self):\n",
    "        print('estoy rebotando')\n",
    "    def inflar(self):\n",
    "        pass\n",
    "\n",
    "# se crea el objeto\n",
    "pelota1=pelota()\n",
    "# mando a llamar un método del objeto\n",
    "pelota1.rebota()\n",
    "# esto no se debe hacer\n",
    "print(pelota1.presion)\n",
    "pelota1.presion=10\n",
    "print(pelota1.presion)\n",
    "# la forma correcta\n",
    "pelota1.set_presion(20)\n",
    "print(pelota1.get_presion())\n",
    "pelota2=pelota()\n",
    "pelota2.rebota()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "# herencia\n",
    "class pelota:\n",
    "    def __init__(self):\n",
    "        self.presion=10\n",
    "class volleyball(pelota):\n",
    "    pass\n",
    "mibalon=volleyball()\n",
    "print(mibalon.presion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "llanta ponchada\n",
      "30\n",
      "llanta en buen estado\n",
      "25\n",
      "llanta ponchada\n"
     ]
    }
   ],
   "source": [
    "class llanta:\n",
    "    def __init__(self):\n",
    "        self.diametro=15\n",
    "        self.presion=30\n",
    "        self.temperatura=36\n",
    "    def get_presion(self):\n",
    "        return self.presion\n",
    "    def valores(self):\n",
    "        print(self.diametro,self.presion)\n",
    "        \n",
    "    def inflar(self, valorpresion):\n",
    "        self.presion=float(valorpresion)\n",
    "\n",
    "# simulacion\n",
    "# vectores de simulacion, uno o mas por cada caso\n",
    "valoresdepresion=[10,30,25]\n",
    "goodyear=llanta() \n",
    "# análisis del comportamiento por cada vector de simulacion\n",
    "for i in valoresdepresion:\n",
    "    # no recomendable\n",
    "    gooyear.presion=i\n",
    "    # recomendable\n",
    "    goodyear.inflar(i)\n",
    "    print(goodyear.get_presion)\n",
    "    if goodyear.get_presion()<30:\n",
    "        print('llanta ponchada')\n",
    "    else:\n",
    "        print('llanta en buen estado')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# manejo de pandasv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'numpy.ndarray'>\n",
      "(3,)\n",
      "(1, 2, 3)\n",
      "[5 2 3]\n",
      "(2, 3)\n",
      "(1, 2, 4)\n"
     ]
    }
   ],
   "source": [
    "# arreglos con numpy\n",
    "import numpy as np\n",
    "\n",
    "a = np.array([1, 2, 3])   # Create a rank 1 array\n",
    "print(type(a))            # Prints \"<class 'numpy.ndarray'>\"\n",
    "print(a.shape)            # Prints \"(3,)\"\n",
    "print(a[0], a[1], a[2])   # Prints \"1 2 3\"\n",
    "a[0] = 5                  # Change an element of the array\n",
    "print(a)                  # Prints \"[5, 2, 3]\"\n",
    "\n",
    "b = np.array([[1,2,3],[4,5,6]])    # Create a rank 2 array\n",
    "print(b.shape)                     # Prints \"(2, 3)\"\n",
    "print(b[0, 0], b[0, 1], b[1, 0])   # Prints \"1 2 4\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0.]\n",
      " [0. 0.]]\n",
      "[[1. 1.]]\n",
      "[[7 7]\n",
      " [7 7]]\n",
      "[[1. 0.]\n",
      " [0. 1.]]\n",
      "[[0.17852102 0.62203921]\n",
      " [0.11056903 0.63879188]]\n"
     ]
    }
   ],
   "source": [
    "# creando arreglos con numpy\n",
    "import numpy as np\n",
    "\n",
    "a = np.zeros((2,2))   # Create an array of all zeros\n",
    "print(a)              # Prints \"[[ 0.  0.]\n",
    "                      #          [ 0.  0.]]\"\n",
    "\n",
    "b = np.ones((1,2))    # Create an array of all ones\n",
    "print(b)              # Prints \"[[ 1.  1.]]\"\n",
    "\n",
    "c = np.full((2,2), 7)  # Create a constant array\n",
    "print(c)               # Prints \"[[ 7.  7.]\n",
    "                       #          [ 7.  7.]]\"\n",
    "\n",
    "d = np.eye(2)         # Create a 2x2 identity matrix\n",
    "print(d)              # Prints \"[[ 1.  0.]\n",
    "                      #          [ 0.  1.]]\"\n",
    "\n",
    "e = np.random.random((2,2))  # Create an array filled with random values\n",
    "print(e)                     # Might print \"[[ 0.91940167  0.08143941]\n",
    "                             #               [ 0.68744134  0.87236687]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "77\n"
     ]
    }
   ],
   "source": [
    "# slicing in numpy\n",
    "import numpy as np\n",
    "\n",
    "# Create the following rank 2 array with shape (3, 4)\n",
    "# [[ 1  2  3  4]\n",
    "#  [ 5  6  7  8]\n",
    "#  [ 9 10 11 12]]\n",
    "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
    "\n",
    "# Use slicing to pull out the subarray consisting of the first 2 rows\n",
    "# and columns 1 and 2; b is the following array of shape (2, 2):\n",
    "# [[2 3]\n",
    "#  [6 7]]\n",
    "b = a[:2, 1:3]\n",
    "\n",
    "# A slice of an array is a view into the same data, so modifying it\n",
    "# will modify the original array.\n",
    "print(a[0, 1])   # Prints \"2\"\n",
    "b[0, 0] = 77     # b[0, 0] is the same piece of data as a[0, 1]\n",
    "print(a[0, 1])   # Prints \"77\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([5, 6, 7, 8]), (4,))\n",
      "(array([[5, 6, 7, 8]]), (1, 4))\n",
      "(array([ 2,  6, 10]), (3,))\n",
      "(array([[ 2],\n",
      "       [ 6],\n",
      "       [10]]), (3, 1))\n"
     ]
    }
   ],
   "source": [
    "# Integer array indexing\n",
    "import numpy as np\n",
    "\n",
    "# Create the following rank 2 array with shape (3, 4)\n",
    "# [[ 1  2  3  4]\n",
    "#  [ 5  6  7  8]\n",
    "#  [ 9 10 11 12]]\n",
    "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
    "\n",
    "# Two ways of accessing the data in the middle row of the array.\n",
    "# Mixing integer indexing with slices yields an array of lower rank,\n",
    "# while using only slices yields an array of the same rank as the\n",
    "# original array:\n",
    "row_r1 = a[1, :]    # Rank 1 view of the second row of a\n",
    "row_r2 = a[1:2, :]  # Rank 2 view of the second row of a\n",
    "print(row_r1, row_r1.shape)  # Prints \"[5 6 7 8] (4,)\"\n",
    "print(row_r2, row_r2.shape)  # Prints \"[[5 6 7 8]] (1, 4)\"\n",
    "\n",
    "# We can make the same distinction when accessing columns of an array:\n",
    "col_r1 = a[:, 1]\n",
    "col_r2 = a[:, 1:2]\n",
    "print(col_r1, col_r1.shape)  # Prints \"[ 2  6 10] (3,)\"\n",
    "print(col_r2, col_r2.shape)  # Prints \"[[ 2]\n",
    "                             #          [ 6]\n",
    "                             #          [10]] (3, 1)\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False False]\n",
      " [ True  True]\n",
      " [ True  True]]\n",
      "[3 4 5 6]\n",
      "[3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "# boolean array indexing\n",
    "import numpy as np\n",
    "\n",
    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
    "\n",
    "bool_idx = (a > 2)   # Find the elements of a that are bigger than 2;\n",
    "                     # this returns a numpy array of Booleans of the same\n",
    "                     # shape as a, where each slot of bool_idx tells\n",
    "                     # whether that element of a is > 2.\n",
    "\n",
    "print(bool_idx)      # Prints \"[[False False]\n",
    "                     #          [ True  True]\n",
    "                     #          [ True  True]]\"\n",
    "\n",
    "# We use boolean array indexing to construct a rank 1 array\n",
    "# consisting of the elements of a corresponding to the True values\n",
    "# of bool_idx\n",
    "print(a[bool_idx])  # Prints \"[3 4 5 6]\"\n",
    "\n",
    "# We can do all of the above in a single concise statement:\n",
    "print(a[a > 2])     # Prints \"[3 4 5 6]\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int64\n",
      "float64\n",
      "int64\n"
     ]
    }
   ],
   "source": [
    "# datatypes\n",
    "import numpy as np\n",
    "\n",
    "x = np.array([1, 2])   # Let numpy choose the datatype\n",
    "print(x.dtype)         # Prints \"int64\"\n",
    "\n",
    "x = np.array([1.0, 2.0])   # Let numpy choose the datatype\n",
    "print(x.dtype)             # Prints \"float64\"\n",
    "\n",
    "x = np.array([1, 2], dtype=np.int64)   # Force a particular datatype\n",
    "print(x.dtype)                         # Prints \"int64\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6.  8.]\n",
      " [10. 12.]]\n",
      "[[ 6.  8.]\n",
      " [10. 12.]]\n",
      "[[-4. -4.]\n",
      " [-4. -4.]]\n",
      "[[-4. -4.]\n",
      " [-4. -4.]]\n",
      "[[ 5. 12.]\n",
      " [21. 32.]]\n",
      "[[ 5. 12.]\n",
      " [21. 32.]]\n",
      "[[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]]\n",
      "[[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]]\n",
      "[[1.         1.41421356]\n",
      " [1.73205081 2.        ]]\n",
      "219\n",
      "219\n",
      "[29 67]\n",
      "[29 67]\n",
      "[[19 22]\n",
      " [43 50]]\n",
      "[[19 22]\n",
      " [43 50]]\n",
      "10\n",
      "[4 6]\n",
      "[3 7]\n"
     ]
    }
   ],
   "source": [
    "# array math\n",
    "import numpy as np\n",
    "\n",
    "x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
    "y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
    "\n",
    "# Elementwise sum; both produce the array\n",
    "# [[ 6.0  8.0]\n",
    "#  [10.0 12.0]]\n",
    "print(x + y)\n",
    "print(np.add(x, y))\n",
    "\n",
    "# Elementwise difference; both produce the array\n",
    "# [[-4.0 -4.0]\n",
    "#  [-4.0 -4.0]]\n",
    "print(x - y)\n",
    "print(np.subtract(x, y))\n",
    "\n",
    "# Elementwise product; both produce the array\n",
    "# [[ 5.0 12.0]\n",
    "#  [21.0 32.0]]\n",
    "print(x * y)\n",
    "print(np.multiply(x, y))\n",
    "\n",
    "# Elementwise division; both produce the array\n",
    "# [[ 0.2         0.33333333]\n",
    "#  [ 0.42857143  0.5       ]]\n",
    "print(x / y)\n",
    "print(np.divide(x, y))\n",
    "\n",
    "# Elementwise square root; produces the array\n",
    "# [[ 1.          1.41421356]\n",
    "#  [ 1.73205081  2.        ]]\n",
    "print(np.sqrt(x))\n",
    "x = np.array([[1,2],[3,4]])\n",
    "y = np.array([[5,6],[7,8]])\n",
    "\n",
    "v = np.array([9,10])\n",
    "w = np.array([11, 12])\n",
    "\n",
    "# Inner product of vectors; both produce 219\n",
    "print(v.dot(w))\n",
    "print(np.dot(v, w))\n",
    "\n",
    "# Matrix / vector product; both produce the rank 1 array [29 67]\n",
    "print(x.dot(v))\n",
    "print(np.dot(x, v))\n",
    "\n",
    "# Matrix / matrix product; both produce the rank 2 array\n",
    "# [[19 22]\n",
    "#  [43 50]]\n",
    "print(x.dot(y))\n",
    "print(np.dot(x, y))\n",
    "x = np.array([[1,2],[3,4]])\n",
    "\n",
    "print(np.sum(x))  # Compute sum of all elements; prints \"10\"\n",
    "print(np.sum(x, axis=0))  # Compute sum of each column; prints \"[4 6]\"\n",
    "print(np.sum(x, axis=1))  # Compute sum of each row; prints \"[3 7]\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Transpuesta\n",
    "import numpy as np\n",
    "\n",
    "x = np.array([[1,2], [3,4]])\n",
    "print(x)    # Prints \"[[1 2]\n",
    "            #          [3 4]]\"\n",
    "print(x.T)  # Prints \"[[1 3]\n",
    "            #          [2 4]]\"\n",
    "\n",
    "# Note that taking the transpose of a rank 1 array does nothing:\n",
    "v = np.array([1,2,3])\n",
    "print(v)    # Prints \"[1 2 3]\"\n",
    "print(v.T)  # Prints \"[1 2 3]\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n",
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "# broadcasting\n",
    "import numpy as np\n",
    "\n",
    "# We will add the vector v to each row of the matrix x,\n",
    "# storing the result in the matrix y\n",
    "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "v = np.array([1, 0, 1])\n",
    "y = np.empty_like(x)   # Create an empty matrix with the same shape as x\n",
    "\n",
    "# Add the vector v to each row of the matrix x with an explicit loop\n",
    "for i in range(4):\n",
    "    y[i, :] = x[i, :] + v\n",
    "\n",
    "# Now y is the following\n",
    "# [[ 2  2  4]\n",
    "#  [ 5  5  7]\n",
    "#  [ 8  8 10]\n",
    "#  [11 11 13]]\n",
    "print(y)\n",
    "\n",
    "# We will add the vector v to each row of the matrix x,\n",
    "# storing the result in the matrix y\n",
    "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "v = np.array([1, 0, 1])\n",
    "y = x + v  # Add v to each row of x using broadcasting\n",
    "print(y)  # Prints \"[[ 2  2  4]\n",
    "          #          [ 5  5  7]\n",
    "          #          [ 8  8 10]\n",
    "          #          [11 11 13]]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "ImportError",
     "evalue": "cannot import name imageio",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mImportError\u001b[0m                               Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-13-16bb5ab2399a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfrom\u001b[0m \u001b[0mscipy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmisc\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mimread\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimsave\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimresize\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimageio\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# Read an JPEG image into a numpy array\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mimg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mimageio\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'assets/cat.jpg'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mimg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# Prints \"uint8 (400, 248, 3)\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mImportError\u001b[0m: cannot import name imageio"
     ]
    }
   ],
   "source": [
    "from scipy.misc import imread, imsave, imresize, imageio\n",
    "\n",
    "# Read an JPEG image into a numpy array\n",
    "img = imageio.imread('assets/cat.jpg')\n",
    "print(img.dtype, img.shape)  # Prints \"uint8 (400, 248, 3)\"\n",
    "\n",
    "# We can tint the image by scaling each of the color channels\n",
    "# by a different scalar constant. The image has shape (400, 248, 3);\n",
    "# we multiply it by the array [1, 0.95, 0.9] of shape (3,);\n",
    "# numpy broadcasting means that this leaves the red channel unchanged,\n",
    "# and multiplies the green and blue channels by 0.95 and 0.9\n",
    "# respectively.\n",
    "img_tinted = img * [1, 0.95, 0.9]\n",
    "\n",
    "# Resize the tinted image to be 300 by 300 pixels.\n",
    "img_tinted = imresize(img_tinted, (300, 300))\n",
    "\n",
    "# Write the tinted image back to disk\n",
    "imsave('assets/cat_tinted.jpg', img_tinted)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nombre de columnas Index(['16.5656683333', '-93.022155', '23', '0'], dtype='object')\n",
      "Index(['latitud', 'longitud', 'maximo', 'distancia'], dtype='object')\n",
      "     latitud   longitud  maximo  distancia\n",
      "0  16.565668 -93.022155     152        0.0\n",
      "1  16.565668 -93.022155     149        0.0\n",
      "2  16.563968 -93.024222      23      291.0\n",
      "3  16.563968 -93.024222     154        0.0\n",
      "4  16.563968 -93.024222     153        0.0\n",
      "       latitud   longitud  maximo  distancia\n",
      "0    16.565668 -93.022155     152        0.0\n",
      "586  16.344310 -93.758547     114        0.0\n",
      "587  16.344310 -93.758547      15        0.0\n",
      "588  16.344310 -93.758547     129        0.0\n",
      "589  16.344310 -93.758547      19        0.0\n",
      "       latitud   longitud  maximo  distancia\n",
      "933  16.533677 -93.028960      23     3899.0\n",
      "918  16.475477 -93.043037     159     3792.0\n",
      "911  16.449330 -93.065885     149     3755.0\n",
      "165  16.311103 -93.234922      19     3612.0\n",
      "404  16.203188 -93.968747      30     3573.0\n",
      "       latitud   longitud  maximo  distancia\n",
      "600  16.344527 -93.707482       0        0.0\n",
      "957  16.564165 -93.024395       0        0.0\n",
      "963  16.564165 -93.024395       0        0.0\n",
      "949  16.564165 -93.024395       0        0.0\n",
      "981  16.565698 -93.022053       0        0.0\n",
      "600   -93.707482\n",
      "957   -93.024395\n",
      "963   -93.024395\n",
      "949   -93.024395\n",
      "981   -93.022053\n",
      "         ...    \n",
      "609   -93.690120\n",
      "924   -93.043037\n",
      "920   -93.043037\n",
      "936   -93.028960\n",
      "993   -93.022053\n",
      "Name: longitud, Length: 999, dtype: float64\n",
      "       latitud   longitud  maximo  distancia\n",
      "324  16.244957 -93.677878     114        0.0\n",
      "323  16.244957 -93.677878     114        0.0\n",
      "322  16.244957 -93.677878     114        0.0\n",
      "314  16.252095 -93.655268     114        0.0\n",
      "311  16.252095 -93.655268     114        0.0\n",
      "latitud       16.344527\n",
      "longitud     -93.707482\n",
      "maximo       159.000000\n",
      "distancia      0.000000\n",
      "Name: 601, dtype: float64\n",
      "159\n",
      "       latitud   longitud  maximo  distancia\n",
      "979  16.565698 -93.022053       0      235.0\n",
      "825  16.220060 -93.250325       8     2991.0\n",
      "242  16.262517 -93.467707      15     2031.0\n",
      "530  16.262238 -93.862605      15     2243.0\n",
      "564  16.320887 -93.791673      15     2550.0\n",
      "..         ...        ...     ...        ...\n",
      "573  16.333158 -93.778917     152     1927.0\n",
      "547  16.290755 -93.828028     152     2490.0\n",
      "896  16.401070 -93.103845     152     2871.0\n",
      "903  16.422360 -93.087098     153     2965.0\n",
      "918  16.475477 -93.043037     159     3792.0\n",
      "\n",
      "[113 rows x 4 columns]\n"
     ]
    }
   ],
   "source": [
    "# fecha, temperatura, humedad\n",
    "# 6/11/2020,30,15\n",
    "# \n",
    "import pandas as pd\n",
    "data = pd.read_csv(\"dataall.csv\") \n",
    "# muestra los nombres de las columnas\n",
    "print('nombre de columnas',data.columns)\n",
    "# pone nombres a las columnas\n",
    "data.columns=['latitud', 'longitud', 'maximo', 'distancia']\n",
    "print(data.columns)\n",
    "# imprime los primeros datos\n",
    "print(data.head())\n",
    "# ordena los datos tomando como referencia una columna en orden ascendente\n",
    "data.sort_values(by=['distancia'], inplace=True)\n",
    "print(data.head())\n",
    "# ordena los datos en forma descendente\n",
    "data.sort_values(by=['distancia'], inplace=True,  ascending=False)\n",
    "print(data.head())\n",
    "# ordena por varias columnas\n",
    "data.sort_values(by=['maximo','distancia'], inplace=True)\n",
    "print(data.head())\n",
    "# accesando a los datos de una columna\n",
    "print(data['longitud'])\n",
    "# accesando ciertos renglones\n",
    "print(data[600:605])\n",
    "# accesando un dato en particular\n",
    "print(data.loc[601])\n",
    "print(data.loc[601, 'maximo'])\n",
    "# indices booleanos\n",
    "print(data[data['distancia']>30])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tipos de datos particulares\n",
    "# estructuras de datos para almacenamiento de información\n",
    "# pila: los datos se recuperan en orden inverso de como fueron introducidos (LIFO)\n",
    "# cola: los datos se recuperan en el orden en que fueron introducidos (FIFO)\n",
    "# pila.push(5) \n",
    "# pila.push(3)\n",
    "# pila.pop() # me devuelve el 3\n",
    "# pila.pop() # me devuelve el 5\n",
    "# pila.pop() # no devuelve nada\n",
    "# cola.push(5)\n",
    "# cola.push(3)\n",
    "# cola.pop() # me devuelve el 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0\n",
      "5.0\n",
      "0.0\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "class pila():\n",
    "    def __init__(self,tamanio_pila):\n",
    "        self.datos_en_pila=0\n",
    "        self.mis_datos=np.zeros((tamanio_pila))\n",
    "    def push(self,dato):\n",
    "        self.mis_datos[self.datos_en_pila]=dato\n",
    "        self.datos_en_pila+=1\n",
    "    def pop(self):\n",
    "        valor_a_devolver=self.mis_datos[self.datos_en_pila-1]\n",
    "        self.datos_en_pila-=1\n",
    "        return valor_a_devolver\n",
    "mipila=pila(20)\n",
    "mipila.push(5)\n",
    "mipila.push(3)\n",
    "print(mipila.pop())\n",
    "print(mipila.pop())\n",
    "print(mipila.pop())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# árbol binario, árbol genealógico\n",
    "#              1\n",
    "#           2      3\n",
    "#         4   5  6   7\n",
    "# primero profundidad: 1,2,4,5,3,6,7\n",
    "# primero en anchura: 1,2,3,4,5,6,7\n",
    "# dominó\n",
    "# se inicia con la mula de 6\n",
    "# cuantos hijos tendría el nodo? 6,0 6,1 6,2\n",
    "# en el árbol almacenarias las fichas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2. 3.]\n",
      " [2. 4. 5.]\n",
      " [3. 6. 7.]\n",
      " [0. 0. 0.]\n",
      " [0. 0. 0.]]\n",
      "{1: [2, 3], 2: [4, 5], 3: [6, 7]}\n",
      "1\n",
      "[2, 3]\n",
      "[4, 5]\n",
      "[6, 7]\n",
      "1.0\n",
      "2.0\n",
      "3.0\n",
      "4.0\n",
      "5.0\n",
      "6.0\n",
      "7.0\n",
      "1.0\n",
      "2.0\n",
      "3.0\n",
      "4.0\n",
      "5.0\n",
      "6.0\n",
      "7.0\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "class arbol():\n",
    "    def __init__(self):\n",
    "        self.red=np.zeros((5,3))\n",
    "        self.contador=0\n",
    "        self.red_diccionario={}\n",
    "    def agregar(self,nodo_origen,nodo_izquierda,nodo_derecha):\n",
    "        self.red_diccionario[nodo_origen]=[nodo_izquierda,nodo_derecha]\n",
    "        self.red[self.contador,0]=nodo_origen\n",
    "        self.red[self.contador,1]=nodo_izquierda\n",
    "        self.red[self.contador,2]=nodo_derecha\n",
    "        self.contador+=1\n",
    "    def muestra_red(self):\n",
    "        print(self.red)\n",
    "        print(self.red_diccionario)\n",
    "    def anchura(self):\n",
    "        print('1')\n",
    "        print(self.red_diccionario[1])\n",
    "        print(self.red_diccionario[2])\n",
    "        print(self.red_diccionario[3])\n",
    "        print(self.red[0,0])\n",
    "        print(self.red[0,1])\n",
    "        print(self.red[0,2])\n",
    "        print(self.red[1,1])\n",
    "        print(self.red[1,2])\n",
    "        print(self.red[2,1])\n",
    "        print(self.red[2,2])\n",
    "        for i in range(3):\n",
    "            print(self.red[0,i])\n",
    "        for i in range(1,3):\n",
    "            for j in range(1,3):\n",
    "                print(self.red[i,j])\n",
    "miarbol=arbol()\n",
    "miarbol.agregar(1,2,3)\n",
    "miarbol.agregar(2,4,5)\n",
    "miarbol.agregar(3,6,7)\n",
    "miarbol.muestra_red()\n",
    "miarbol.anchura()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2.]\n",
      " [1. 3.]\n",
      " [1. 4.]\n",
      " [2. 5.]\n",
      " [3. 7.]\n",
      " [5. 6.]]\n",
      "1.0\n",
      "2.0\n",
      "3.0\n",
      "4.0\n",
      "5.0\n",
      "7.0\n",
      "6.0\n",
      "nivel pro\n",
      "1.0\n",
      "2.0\n",
      "3.0\n",
      "4.0\n",
      "5.0\n",
      "7.0\n"
     ]
    }
   ],
   "source": [
    "# árbol múltiple\n",
    "# 1\n",
    "# 2          3          4\n",
    "# 5          7\n",
    "# 6 3        \n",
    "# 1, 2 3 4 , 5 7, 6 3 \n",
    "# matriz\n",
    "# padre hijo\n",
    "# 1     2\n",
    "# 1     3\n",
    "# 1     4\n",
    "# 2     5\n",
    "# 3     7\n",
    "# 5     6\n",
    "import numpy as np\n",
    "class red():\n",
    "    def __init__(self):\n",
    "        self.matriz=np.zeros((6,2))\n",
    "        self.apuntador=0\n",
    "    def llenar(self,padre,hijo):\n",
    "        self.matriz[self.apuntador,0]=padre\n",
    "        self.matriz[self.apuntador,1]=hijo\n",
    "        self.apuntador+=1\n",
    "    def mostrar(self):\n",
    "        print(self.matriz)\n",
    "    def anchura(self):\n",
    "        nodo_principal=self.matriz[0,0]\n",
    "        print(nodo_principal)\n",
    "        lista_hijos=[]\n",
    "        # primer nivel\n",
    "        for i in range(self.apuntador):\n",
    "            if self.matriz[i,0]==nodo_principal:\n",
    "                print(self.matriz[i,1])\n",
    "                lista_hijos.append(self.matriz[i,1])\n",
    "        # segundo nivel\n",
    "        for hijo in lista_hijos:\n",
    "            for i in range(self.apuntador):\n",
    "                if self.matriz[i,0]==hijo:\n",
    "                    print(self.matriz[i,1])\n",
    "                    lista_hijos.append(self.matriz[i,1])\n",
    "        # nivel pro\n",
    "        print('nivel pro')\n",
    "        lista_hijos_pro=[]\n",
    "        lista_hijos_pro.append(nodo_principal)\n",
    "        print(nodo_principal)\n",
    "        for k in range(3):\n",
    "            for hijo in lista_hijos_pro:\n",
    "                lista_nietos=[]\n",
    "                for i in range(self.apuntador):\n",
    "                    if self.matriz[i,0]==hijo:\n",
    "                        print(self.matriz[i,1])\n",
    "                        lista_nietos.append(self.matriz[i,1])\n",
    "                lista_hijos_pro=lista_nietos\n",
    "                \n",
    "mired=red()\n",
    "mired.llenar(1,2)\n",
    "mired.llenar(1,3)\n",
    "mired.llenar(1,4)\n",
    "mired.llenar(2,5)\n",
    "mired.llenar(3,7)\n",
    "mired.llenar(5,6)\n",
    "mired.mostrar()\n",
    "mired.anchura()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# juego: dominó, baraja, damas inglesas, ajedrez"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# proyecto mecatrónico"
   ]
  }
 ],
 "metadata": {
  "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}