Holi_numpy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Holi_numpy.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/marisbotero/DataScienceFEM/blob/master/Holi_numpy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mjDeszBVdLLZ",
        "colab_type": "code",
        "outputId": "542d9d6a-0d4b-46f3-b0d6-aa5262095181",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "lista = ['a', 3, 4.5, 'b', 7]\n",
        "enteros_lista = [i for i in lista if type(i) == int]\n",
        "print(enteros_lista)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[3, 7]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ICISJzeYdMNg",
        "colab_type": "code",
        "outputId": "f9997e93-76e2-43b6-dead-f7831fea3714",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "\n",
        "import numpy as np \n",
        "\n",
        "vector_a = np.array([1,4,8])\n",
        "vector_a"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 4, 8])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yfgdE45zd2Uc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ci5c1mvgeC-9",
        "colab_type": "text"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FfG-by5oBMP-",
        "colab_type": "text"
      },
      "source": [
        "# ¿Qué es Numpy?#\n",
        "\n",
        "es una biblioteca de álgebra lineal para Python que tiene enlaces a bibliotecas C, estructuras de datos y funcionalidades que la hace increíblemente rápida y eficiente para procesar arreglos y matices.\n",
        "\n",
        "#¿ Por qué usar numpy?#\n",
        "\n",
        "Es una forma útil de resolver algunos problemas que pueden ser demandantes al usar arreglos e iteraciones regulares\n",
        "\n",
        "#¿ cómo obtener numpy?#\n",
        "\n",
        "**La forma fácil**\n",
        "\n",
        "Si se tiene python y pip, se puede instalar mediante este sistema, solamente es abrir un terminal y digitar:\n",
        "\n",
        "```\n",
        "pip install numpy\n",
        "```\n",
        "\n",
        "#¿Cómo usar numpy#\n",
        "Luego de instalarlo (o de crear un cuaderno), el primer paso para utilizar numpy es importar el paquete."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lLVhSetqrl0X",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GG9ZU2gHWq62",
        "colab_type": "text"
      },
      "source": [
        "##Acceso a  los elementos del arreglo##\n",
        "\n",
        "Para acceder a los elementos de un arreglo o matriz en numpy se utiliza la misma notación que en los arreglos regulares de Python (incluyendo las subdivisiones)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v_Np08sbeD5u",
        "colab_type": "code",
        "outputId": "44895587-71e8-4128-e59c-8302c717fc65",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 243
        }
      },
      "source": [
        "my_array = np.random.randint(0, 100, 10) # crea un arreglo de 10 enteros entre 0 y 99 \n",
        "# Devuelve enteros aleatorios de bajo (inclusivo) a alto (exclusivo).\n",
        "\n",
        "print(\"arreglo original\\n\", my_array)\n",
        "\n",
        "print(\"el quinto elemento\\n\", my_array[4] )\n",
        "\n",
        "print(\"antes del quinto elemento\\n\", my_array[:4])\n",
        "\n",
        "print(\"despues del quinto elemento\\n\", my_array[4:])\n",
        "\n",
        "print(\"elementos intermedios\\n\", my_array[2:7])\n",
        "\n",
        "print(\"último elemento\", my_array[-1])\n",
        "\n",
        "print(\"elementos en posiciones impares\", my_array[1::2])\n",
        "\n",
        "print(\"arreglo invertido\", my_array[::-1])\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "arreglo original\n",
            " [75 36 56 85 47 96 68 51  0 58]\n",
            "el quinto elemento\n",
            " 47\n",
            "antes del quinto elemento\n",
            " [75 36 56 85]\n",
            "despues del quinto elemento\n",
            " [47 96 68 51  0 58]\n",
            "elementos intermedios\n",
            " [56 85 47 96 68]\n",
            "último elemento 58\n",
            "elementos en posiciones impares [36 85 96 51 58]\n",
            "arreglo invertido [58  0 51 68 96 47 85 56 36 75]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2JBwmI4lgZVe",
        "colab_type": "text"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "asnCOW_8engR",
        "colab_type": "code",
        "outputId": "68f40c98-fc04-4f57-8a44-b7dab9ffda61",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 69
        }
      },
      "source": [
        "# Array de 3 filas y tres columnas, creado implícitamente\n",
        "arr0 = np.array([[10,20,30],[9, 99, 999],[0, 2, 3]])\n",
        "print(arr0)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 10  20  30]\n",
            " [  9  99 999]\n",
            " [  0   2   3]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "buCbhBSJpzVI",
        "colab_type": "code",
        "outputId": "0dbb7456-3c9c-4ec8-b0b0-dcdcba256913",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "# Array de ceros con 2 filas y 3 columnas\n",
        "arr1 = np.zeros((2,3))\n",
        "print(arr1)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0. 0. 0.]\n",
            " [0. 0. 0.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tWZdNl3yqJZv",
        "colab_type": "code",
        "outputId": "7ecf9a96-a2e9-4b6b-ea2e-4675f5f092bc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 69
        }
      },
      "source": [
        "# Array unidimensional de 9 elementos y cambio su forma a 3x3\n",
        "arr3 = np.arange(9).reshape((3, 3))\n",
        "print(arr3)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0 1 2]\n",
            " [3 4 5]\n",
            " [6 7 8]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rEt57Ktvgenc",
        "colab_type": "code",
        "outputId": "92c12efc-ae95-4a92-8fc4-28fa046137bc",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 139
        }
      },
      "source": [
        "#creación de una matriz de 6 filas y 5 columnas en numpy con numeros aleatorios entre 0 y 99\n",
        "array6x5= np.random.randint(0,100,size=(6,5))\n",
        "print(\"matriz de 6 filas y 5 columnas\\n\", array6x5)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "matriz de 6 filas y 5 columnas\n",
            " [[ 6 72 66  9  0]\n",
            " [54 37 27 41 35]\n",
            " [27 79 52 38 68]\n",
            " [48 77 64 94 52]\n",
            " [26 98 43 20 38]\n",
            " [31 42 98 61 84]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W_Wfdnqoj-1N",
        "colab_type": "text"
      },
      "source": [
        "El método reshape()  permite reorganizar la matriz de acuerdo a cómo se necesite"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "brOLYBOwg2qI",
        "colab_type": "code",
        "outputId": "efdaf395-55cf-4fbc-ea99-98cbb71a8bf0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 468
        }
      },
      "source": [
        "array5x6 = array6x5.reshape(5,6)\n",
        "print(\"matriz de 5 filas y 6 columnas\\n\", array5x6)\n",
        "\n",
        "array3x10 = array6x5.reshape(3,10)\n",
        "print(\"matriz de 3 filas y 10 columnas\\n\", array3x10)\n",
        "\n",
        "#si solamente se conoce una dimensión se puede pasar un parámetro para que numpy lo asuma\n",
        "array_x15 = array6x5.reshape(15,-1)\n",
        "print(\"matriz de ? filas y 15 columnas\\n\", array_x15)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "matriz de 5 filas y 6 columnas\n",
            " [[ 6 72 66  9  0 54]\n",
            " [37 27 41 35 27 79]\n",
            " [52 38 68 48 77 64]\n",
            " [94 52 26 98 43 20]\n",
            " [38 31 42 98 61 84]]\n",
            "matriz de 3 filas y 10 columnas\n",
            " [[ 6 72 66  9  0 54 37 27 41 35]\n",
            " [27 79 52 38 68 48 77 64 94 52]\n",
            " [26 98 43 20 38 31 42 98 61 84]]\n",
            "matriz de ? filas y 15 columnas\n",
            " [[ 6 72]\n",
            " [66  9]\n",
            " [ 0 54]\n",
            " [37 27]\n",
            " [41 35]\n",
            " [27 79]\n",
            " [52 38]\n",
            " [68 48]\n",
            " [77 64]\n",
            " [94 52]\n",
            " [26 98]\n",
            " [43 20]\n",
            " [38 31]\n",
            " [42 98]\n",
            " [61 84]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RSD82Ehkhm2e",
        "colab_type": "text"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pipiLaZymuXe",
        "colab_type": "text"
      },
      "source": [
        "##resolviendo un problema de álgebra lineal##\n",
        "\n",
        "Se desea resolver el sistema de ecuaciones lineales:\n",
        "\n",
        "$6x_1 -3x_2+x_3=11$\n",
        "\n",
        "$x_1 - 7x_2+x_3=10$\n",
        "\n",
        "$2x_1 +x_2-8x_3=-15$\n",
        "\n",
        "A continuación se mostrarán dos técnicas para resolver este sistema"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vGasgchlhjY-",
        "colab_type": "code",
        "outputId": "5a482cac-bfcd-4117-9667-3d1c7aca3b94",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 156
        }
      },
      "source": [
        "#independientemente de la técnica a resolver se deben crear las matrices A (coeficientes) y b (resultados)\n",
        "A=np.array([[6,-3, 1],[1, -7, 1],[2, 1, -8]])\n",
        "resultados = np.array([11, 10,-15])\n",
        "b=resultados.reshape(3,1) #se transpone la matriz \n",
        "print(\"A:\\n\",A)\n",
        "print(\"b:\\n\",b)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A:\n",
            " [[ 6 -3  1]\n",
            " [ 1 -7  1]\n",
            " [ 2  1 -8]]\n",
            "b:\n",
            " [[ 11]\n",
            " [ 10]\n",
            " [-15]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ji_G9r1IiNtG",
        "colab_type": "code",
        "outputId": "4b44cbdb-6cd7-4024-869c-1d6c4e4d1e83",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 225
        }
      },
      "source": [
        "#primera técnica (aplicar la multiplicación por la inversa)\n",
        "Ainv = np.linalg.inv(A)\n",
        "print(\"A multiplicado por su inversa\\n\", np.dot(A,Ainv))\n",
        "print(\"inversa de A:\\n\",Ainv)\n",
        "sol1 = np.dot(Ainv,b)\n",
        "print(\"solución técnica 1\\n\", sol1)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "A multiplicado por su inversa\n",
            " [[ 1.00000000e+00 -5.55111512e-17  0.00000000e+00]\n",
            " [-2.77555756e-17  1.00000000e+00  1.38777878e-17]\n",
            " [-5.55111512e-17  0.00000000e+00  1.00000000e+00]]\n",
            "inversa de A:\n",
            " [[ 0.17460317 -0.07301587  0.01269841]\n",
            " [ 0.03174603 -0.15873016 -0.01587302]\n",
            " [ 0.04761905 -0.03809524 -0.12380952]]\n",
            "solución técnica 1\n",
            " [[ 1.]\n",
            " [-1.]\n",
            " [ 2.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5jo_gAPminLp",
        "colab_type": "code",
        "outputId": "7cd1c5e2-4a1f-469d-ad46-9720218dcbcd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 87
        }
      },
      "source": [
        "#segunda técnica (resolver directamente en numpy)\n",
        "sol2 = np.linalg.solve(A,b)\n",
        "print(\"solución técnica 2\\n\", sol2)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "solución técnica 2\n",
            " [[ 1.]\n",
            " [-1.]\n",
            " [ 2.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vtKsIUAsjgIL",
        "colab_type": "code",
        "outputId": "288ca869-cce1-42ef-f9c6-5a4f7f8b9ba3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 87
        }
      },
      "source": [
        "print(\"la solución del sistema de ecuaciones es:\")\n",
        "i=1\n",
        "for x in sol1:\n",
        "  print(\"x_\",i,\"=\", x[0])\n",
        "  i+=1"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "la solución del sistema de ecuaciones es:\n",
            "x_ 1 = 0.9999999999999993\n",
            "x_ 2 = -1.0\n",
            "x_ 3 = 2.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qf_0PvXKjlfJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}