Intro_to_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Intro_to_Python.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyOJ8LWISAfvtkqapDmlYxAR",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/clizarraga-UAD7/Notebooks/blob/main/Intro_to_Python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "or_6ZeCCs3vp"
      },
      "outputs": [],
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# A very short introduction to Python"
      ],
      "metadata": {
        "id": "Jxy7ZP-2s9NC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Basic Arithmetic in Python**\n",
        " \n",
        "Integer operators: +, -, \\*, /, //, %.\n",
        "\n",
        "Floating numbers operators: +, -, \\*, /, \\*\\*.\n",
        "\n",
        "Boolean Expressions: True, False.\n",
        "\n",
        "Equality (==): 5 == 5 returns True.\n",
        "\n",
        "Not equal (!=): 5 != 5 returns False.\n",
        "\n",
        "Greater than (>): 5 > 4 returns True.\n",
        "\n",
        "Greater or equal than (>=): 5 >= 5 returns True.\n",
        "\n",
        "Same applies to Less than (<) and Less or equal than (<=)\n",
        "\n",
        "Boolean operators and, or, and not: True and False, True or False, not True\n"
      ],
      "metadata": {
        "id": "ifDR4ctYta0X"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Flow control examples**\n",
        " "
      ],
      "metadata": {
        "id": "MjgqSwI9vP2N"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Modify and run the cell as desired\n",
        "# Conditional: if\n",
        "x = 3\n",
        "y = 2\n",
        "z = 1\n",
        "\n",
        "if x == y:\n",
        "     print(\"Hello\")\n",
        "elif x == z:\n",
        "     print(\"Good bye\")\n",
        "else:\n",
        "     print(\"???\")\n",
        "\n",
        "# Remember: SHIFT+ENTER to run a cell of select the \"play button\"."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2LXupvwXtZ5f",
        "outputId": "5b2535d7-64f2-47ff-d5e7-0ade228a3e35"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "???\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Loop: for\n",
        " \n",
        "print(\"loop 1\")\n",
        "for i in range(5): # default - starts with 0, increases by 1\n",
        "     print(i)\n",
        " \n",
        "print(\"\\nloop 2\")\n",
        "for i in range(10, 2, -2): # arguments: start, end, step size\n",
        "     print(i)\n",
        " \n",
        "# Loop: while\n",
        " \n",
        "i = 1\n",
        "while i < 10:\n",
        "     print('Next i is = ',i)\n",
        "     i = i+1 # Next i value is defined\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ioGYjVmdv6Vv",
        "outputId": "bdf1cc3c-cff2-46cb-9458-cd03a15fcc5a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loop 1\n",
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "\n",
            "loop 2\n",
            "10\n",
            "8\n",
            "6\n",
            "4\n",
            "Next i is =  1\n",
            "Next i is =  2\n",
            "Next i is =  3\n",
            "Next i is =  4\n",
            "Next i is =  5\n",
            "Next i is =  6\n",
            "Next i is =  7\n",
            "Next i is =  8\n",
            "Next i is =  9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Lists \n",
        "list1 = [1,2,3.0,4]\n",
        "list2 = [1.,2,'3',4]\n",
        "print(list1)\n",
        "print(list2)\n",
        "# Appends list2 at the end of list1. It cannot not be a sum.\n",
        "print(list1+list2)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kQsMP6eZwzt7",
        "outputId": "1fbd4d02-b523-4993-ed1c-9af86b1be058"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3.0, 4]\n",
            "[1.0, 2, '3', 4]\n",
            "[1, 2, 3.0, 4, 1.0, 2, '3', 4]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Arrays (n-dimensional vectors)\n",
        "import numpy as np\n",
        " \n",
        "# One dimensional arrays examples\n",
        "s1 = np.array([1,2,3,4])      # Array of integer numbers\n",
        "s2 = np.array([1,2,3,4.0])    # Will be converted to floating numbers array, since 4.0 is a float (real)\n",
        "s3 = np.array([1,2,3,'4'])    # Will be converted to a character array, since '4' is a character\n",
        "s4 = np.arange(0,5,0.5)       # An array of 0.5 spaced points between 0 and 5, but not including end point 5\n",
        "s5 = np.linspace(0,5,20)      # Inserts 20 between 0 and 5, includes both end points. \n",
        "\n",
        "# Adding 2 numeric array makes sense. Since s2 is a float array, the sum s1 + s2 is a float\n",
        "# or we can scale numeric arrays by multiplying or dividing them by a factor. \n",
        "\n",
        "print('s1 is ', s1)\n",
        "print('s2 is ', s2)\n",
        "print('s3 is ', s3)\n",
        "print('s4 is ', s4)\n",
        "print('s1 + s2 = ', s1 + s2)\n",
        "print('5*s2 = ', 5*s2)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ApSYGo0W3_UF",
        "outputId": "c08afca1-dc39-48fb-ff1e-929141ad6014"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "s1 is  [1 2 3 4]\n",
            "s2 is  [1. 2. 3. 4.]\n",
            "s3 is  ['1' '2' '3' '4']\n",
            "s4 is  [0.  0.5 1.  1.5 2.  2.5 3.  3.5 4.  4.5]\n",
            "s1 + s2 =  [2. 4. 6. 8.]\n",
            "5*s2 =  [ 5. 10. 15. 20.]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# How to access the elements of an array\n",
        "print('s1 = ', s1)\n",
        "print('s1[2] = ', s1[2])      # Obtain the 3rd element of s1... Python starts counting from 0\n",
        "print('s1[1:3] = ', s1[1:3])    # Obtain the second upto before the fourth elements \n",
        "\n",
        " \n",
        "# Two and three dimensional arrays\n",
        "x2 = np.array([[0, 1], [2, 3]])\n",
        "y3 = np.array([[4, 5, 6], [7, 8, 9], [10, 11, 12]])\n",
        "\n",
        "print(' x2 = ',x2,'\\n y3 = ', y3)\n",
        "#print('x2[[:,1]]', x2[[:,1]], ' prints the second column of x2')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N5YDg9BY6DGq",
        "outputId": "4d162bcc-46ff-49a1-f5ff-796141f120b3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "s1 =  [1 2 3 4]\n",
            "s1[2] =  3\n",
            "s1[1:3] =  [2 3]\n",
            " x2 =  [[0 1]\n",
            " [2 3]] \n",
            " y3 =  [[ 4  5  6]\n",
            " [ 7  8  9]\n",
            " [10 11 12]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Selecting a row or column of an array\n",
        "# Remember, Python starts counting from 0.\n",
        "print(' Second row of x2: ', x2[1,:])  # Selects the second row of x2, (here ':'  means 'all columns')\n",
        "print(' First column of y3: ', y3[:,0]) # Selects the first column of y3 (here ':' means 'all rows')\n",
        "print('Last element of second row of y3: ', y3[1,2]) # Selects a specific element on a two dimensional array."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ggbiuxj46kn1",
        "outputId": "8b1345eb-c802-4e07-f96d-3b522a2fb73b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            " Second row of x2:  [2 3]\n",
            " First column of y3:  [ 4  7 10]\n",
            "Last element of second row of y3:  9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Some basic array operations (Only if elements are numbers) \n",
        "import numpy as np\n",
        "\n",
        "# Two and three dimensional arrays\n",
        "x = np.array([[1, 2], [3, 4]])\n",
        "y = np.array([[5, 6], [7, 8]])\n",
        "c = 2\n",
        "\n",
        "# Print specified values \n",
        "print('x = ', x)\n",
        "print('y = ', y)\n",
        "print('c =', c) \n",
        "\n",
        "\n",
        "print('Sum x+y =', x+y)          # sum\n",
        "print(' Sum of x + c =', x+c)    # sum a constant c\n",
        "print('Division of x/y =', x/y)  # division\n",
        "print(' Multiply c*x =', c*x)    # multiply by a constant c\n",
        "print('Square of x =', x**2)     # Square of a number\n",
        "print('Array multiplication x @ y = ', x@y)   # Array multiplication - is a standard matrix multiplication\n",
        "\n",
        "print('Square root of x =', np.sqrt(x))            # Computes the square root of all array elements\n",
        "print('Exponential of array x = ', np.exp(x))      # Computes the expo0nential of the array\n",
        "print('Log of x = ', np.log(x))                    # Computes the natural logarithm of the array \n",
        "print('Sum of elements of x = ', np.sum(x))        # Computes the sum of the elements of the array\n",
        "print('Computes the arithmetic mean of elements of x = ', np.mean(x))   # Computes the arithmetic mean of the array \n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "21wU8OeN6nW9",
        "outputId": "19e168c8-9d08-476d-ca39-1b2f5344e454"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x =  [[1 2]\n",
            " [3 4]]\n",
            "y =  [[5 6]\n",
            " [7 8]]\n",
            "c = 2\n",
            "Sum x+y = [[ 6  8]\n",
            " [10 12]]\n",
            " Sum of x + c = [[3 4]\n",
            " [5 6]]\n",
            "Division of x/y = [[0.2        0.33333333]\n",
            " [0.42857143 0.5       ]]\n",
            " Multiply c*x = [[2 4]\n",
            " [6 8]]\n",
            "Square of x = [[ 1  4]\n",
            " [ 9 16]]\n",
            "Array multiplication x @ y =  [[19 22]\n",
            " [43 50]]\n",
            "Square root of x = [[1.         1.41421356]\n",
            " [1.73205081 2.        ]]\n",
            "Exponential of array x =  [[ 2.71828183  7.3890561 ]\n",
            " [20.08553692 54.59815003]]\n",
            "Log of x =  [[0.         0.69314718]\n",
            " [1.09861229 1.38629436]]\n",
            "Sum of elements of x =  10\n",
            "Computes the arithmetic mean of elements of x =  2.5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plotting functions example\n",
        "\n",
        "# Load the required Python libraries \n",
        "import numpy as np              # Numpy is the Numeric/Mathematics Python library \n",
        "import matplotlib.pyplot as plt # Matplotlib is the graphics library\n",
        "\n",
        "# Variable and function definitions\n",
        "x = np.linspace(-np.pi,np.pi,100)  # A 100 equally spaced points between  -pi  and  pi (pi=3.1415...)\n",
        "y = np.sin(x)      # y will be a 100 points array automatically defined by x\n",
        "\n",
        "# Define the functions as follows...elements of a Taylor Series  \n",
        "y1 = x\n",
        "y3 = x**3/(3*2)\n",
        "y5 = x**5/(5*4*3*2)\n",
        "sT = y1 - y3 + y5 # Truncated Taylor series of sin(x) to 5th order.\n",
        " \n",
        "# Create plots\n",
        "plt.figure(figsize=(8, 5)) # A plot width=8, height=5\n",
        "plt.subplot(111)\n",
        "plt.xlabel(\"X label\")\n",
        "plt.ylabel(\"Y label\")\n",
        "plt.title(\"Title\")\n",
        "\n",
        "# Plot the defined functions\n",
        "plt.plot(x,y, label=\"sin(x)\")\n",
        "plt.plot(x,y1, label='x')\n",
        "plt.plot(x,sT, label='5th order Taylor Series')\n",
        "\n",
        "# Add a grid for easier visualization\n",
        "plt.grid(True)\n",
        "\n",
        "# Fix Y-axis limits.\n",
        "plt.ylim(-2, 2)\n",
        "\n",
        "# Location of functions labels\n",
        "plt.legend(bbox_to_anchor=(1,1), loc=\"upper left\")\n",
        "\n",
        "plt.show()\n",
        "#plt.savefig('plot.png')  # If saving a PNG image to a file is desired. \n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 349
        },
        "id": "IXTrruTyAQ-W",
        "outputId": "6f9c855c-4d9a-458c-aa16-d5038df1ff81"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 576x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Example 1.**\n",
        "The following given program computes the area of a rectangle. "
      ],
      "metadata": {
        "id": "on9h-rT1YkSa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        " \n",
        "# \n",
        "# The following area function computes the area of a rectangle (length times width)\n",
        "def area(x, y):\n",
        "    return x*y\n",
        "\n",
        "print(\"Please input the rectangle length and width \", end=\"\")\n",
        "l = float(input())\n",
        "w = float(input())\n",
        "a = area(l, w)\n",
        "# Print the computed area in free format.\n",
        "print(\"\\nArea = \", a)\n",
        "# Print the computed area with 2 decimals. \n",
        "print(\"\\nArea = {:.2f}\".format(a))\n",
        "   \n",
        "# Note: The Numpy library has the π number defined\n",
        "\n",
        "# Example\n",
        "import numpy as np\n",
        " \n",
        "# Prints the value of pi. \n",
        "print(np.pi)\n",
        "# Prints the computed square root of pi\n",
        "np.sqrt(np.pi)\n",
        "# Computes the value of Sin(√π) \n",
        "np.sin(np.sqrt(np.pi))\n",
        " "
      ],
      "metadata": {
        "id": "NQCn4KM7XGrT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**To do Examples**. Using the above example, make a copy of the Area program code, copy it into a new cell and modify it to compute the following areas and volumes:\n",
        "\n",
        "*   Area of a: circle and ellipse\n",
        "*   Volume of a: sphere and a circular cylinder\n",
        "\n"
      ],
      "metadata": {
        "id": "t4Nt3GbQabwH"
      }
    }
  ]
}