STTM_Part1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "UzU1BrZWMcC-",
        "_cQ9_tkd2B0a",
        "xpIXon9IG9Nd",
        "DCGWxCTQ3T81",
        "yeXmLmeVH9Px",
        "JrsTm44q4det",
        "sGnfBkq7-XoG",
        "r-gX8NU-6h6I",
        "x6MeTsQTNuDO",
        "NBy3Oq01l20H"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Some tips, tricks, and more\n",
        "\n",
        "\n",
        "Mario Fiorino\n"
      ],
      "metadata": {
        "id": "-bZWtfzr4MXz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Flagged in cyclical way\n"
      ],
      "metadata": {
        "id": "UzU1BrZWMcC-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "contatore = 0\n",
        "colori = [\"rosso\", \"verde\", \"nero\", \"giallo\"]\n",
        "\n",
        "for i in range(0,14):\n",
        "    print(i)\n",
        "    print(colori[contatore % 4])  # scrolls in cyclical way over the 4 colors in the list\n",
        "    contatore += 1\n",
        "\n",
        "    # NOTE\n",
        "    ### The % symbol in Python is called the modulus operator and returns the remainder of division"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b2oT6An0MciO",
        "outputId": "a7ed5ac6-678e-4a5b-f86b-775a8515c426"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "rosso\n",
            "1\n",
            "verde\n",
            "2\n",
            "nero\n",
            "3\n",
            "giallo\n",
            "4\n",
            "rosso\n",
            "5\n",
            "verde\n",
            "6\n",
            "nero\n",
            "7\n",
            "giallo\n",
            "8\n",
            "rosso\n",
            "9\n",
            "verde\n",
            "10\n",
            "nero\n",
            "11\n",
            "giallo\n",
            "12\n",
            "rosso\n",
            "13\n",
            "verde\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Quickly build a matrix"
      ],
      "metadata": {
        "id": "_cQ9_tkd2B0a"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "\n",
        "row= 5\n",
        "col = 6\n",
        "matrix = [[random.randint(0, 9)] * col for _ in range(row)]\n",
        "#print(matrix)\n",
        "\n",
        "for i in range(len(matrix)):\n",
        "    print(\"\")\n",
        "    for j in range(len(matrix[0])):\n",
        "      print(matrix[i][j], end=\" \")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lacDda532Lsw",
        "outputId": "faa5f994-fb2e-4083-df55-ff38902e352e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "7 7 7 7 7 7 \n",
            "6 6 6 6 6 6 \n",
            "4 4 4 4 4 4 \n",
            "5 5 5 5 5 5 \n",
            "1 1 1 1 1 1 "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Nested List Comprehensions: A Deeper Look"
      ],
      "metadata": {
        "id": "xpIXon9IG9Nd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fruits = [1,2,3,4,5,6]\n",
        "\n",
        "newlist = [x  for x in fruits if x<2]\n",
        "print(newlist)\n",
        "newlist = [sum([x + a for x in fruits if x<2]) for a in range(999,1003)]\n",
        "print(newlist)\n",
        "\n",
        "print(\"\\n *** \\n\")\n",
        "\n",
        "newlist = [x  for x in fruits if x<3]\n",
        "print(newlist)\n",
        "newlist = [sum([x + a for x in fruits if x<3]) for a in range(999,1003)]\n",
        "print(newlist) #out : [2001, 2003, 2005, 2007]:  how it works?\n",
        "# for a=999 :  (x=1 the process : 999+1 )  +  (x=2 the process : 999+2) = 2001\n",
        "# for a=1000:  (x=1 the process : 1000+1 )  +  (x=2 the process : 1000+2) = 2003\n",
        "#...\n",
        "# for a=1003:  (x=1 the process : 1003+1 )  +  (x=2 the process : 1003+2) = 2007"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qV_RoY_DHOu3",
        "outputId": "4b91583a-3fdb-4cd1-ffd7-4dcc5210a204"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1]\n",
            "[1000, 1001, 1002, 1003]\n",
            "\n",
            " *** \n",
            "\n",
            "[1, 2]\n",
            "[2001, 2003, 2005, 2007]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Equivalent\n",
        "\n",
        "fruits = [1,2,3,4,5,6]\n",
        "\n",
        "k = []\n",
        "for a in range(999,1003):\n",
        "  m = []\n",
        "  for x in fruits:\n",
        "    if x<3:\n",
        "      m.append(x+a)\n",
        "    else:\n",
        "      break\n",
        "  print(\"Auxiliary array : \",m)\n",
        "  k.append(sum(m))\n",
        "\n",
        "print(\"\\n\")\n",
        "print(k)\n",
        "print(newlist==k)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6df96bbd-e359-4f7f-db6d-3ee7423bba7f",
        "id": "welmlb-eHxk6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Auxiliary array :  [1000, 1001]\n",
            "Auxiliary array :  [1001, 1002]\n",
            "Auxiliary array :  [1002, 1003]\n",
            "Auxiliary array :  [1003, 1004]\n",
            "\n",
            "\n",
            "[2001, 2003, 2005, 2007]\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Find the path in a 2D-Grid"
      ],
      "metadata": {
        "id": "DCGWxCTQ3T81"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def find_paths(matrix, start, end, max_steps):\n",
        "    directions = {'right': (0, 1), 'left': (0, -1), 'up': (-1, 0), 'down': (1, 0)}\n",
        "    paths = []\n",
        "    def explore(x, y, steps, path):\n",
        "        if steps > max_steps or x < 0 or y < 0 or x >= len(matrix) or y >= len(matrix[0]):\n",
        "            return\n",
        "        if [x, y] == end and steps <= max_steps:\n",
        "            paths.append(path)\n",
        "            return\n",
        "        for direction, (dx, dy) in directions.items():\n",
        "            explore(x + dx, y + dy, steps + 1, path + [direction])\n",
        "    explore(start[0], start[1], 0, [])\n",
        "    return paths\n",
        "\n",
        "# Grid\n",
        "row= 5\n",
        "col = 5\n",
        "matrix = [[0] * col for _ in range(row)]\n",
        "#print(matrix)\n",
        "\n",
        "\n",
        "#Example\n",
        "max_steps = 3\n",
        "dest_x = 4\n",
        "dest_y = 2\n",
        "end_point = [dest_x, dest_y]\n",
        "\n",
        "x = 4\n",
        "y = 3\n",
        "start_point = [x, y]\n",
        "\n",
        "paths = find_paths(matrix, start_point, end_point, max_steps)\n",
        "total_paths = len(paths)\n",
        "\n",
        "print(paths)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fgc_YrGb3Vaq",
        "outputId": "bdc5b1cd-4cb9-4b48-f1a6-525d37e90dfa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[['right', 'left', 'left'], ['left'], ['up', 'left', 'down'], ['up', 'down', 'left']]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Edit a dict while preserving a copy of the original"
      ],
      "metadata": {
        "id": "yeXmLmeVH9Px"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Can do it better\n",
        "\n",
        "originalDict = {1: \"A\", 2: \"B\", 3: [\"a\", \"b\"]}\n",
        "print(originalDict)\n",
        "\n",
        "def de(k = originalDict):\n",
        "  print(\"  IN k= \" ,k )\n",
        "  k[1]= \"$t€a££i\"\n",
        "  k[3][0]=999\n",
        "  print(\"  OUT k= \" ,k )\n",
        "\n",
        "de()\n",
        "print(originalDict)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pcVhpKIkINBT",
        "outputId": "bbd5e13b-1f0c-4d57-c007-eedd8b26f6e0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1: 'A', 2: 'B', 3: ['a', 'b']}\n",
            "  IN k=  {1: 'A', 2: 'B', 3: ['a', 'b']}\n",
            "  OUT k=  {1: '$t€a££i', 2: 'B', 3: [999, 'b']}\n",
            "{1: '$t€a££i', 2: 'B', 3: [999, 'b']}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Can do it better\n",
        "\n",
        "import copy\n",
        "\n",
        "originalDict = {1: \"A\", 2: \"B\", 3: [\"a\", \"b\"]}\n",
        "print(originalDict)\n",
        "\n",
        "def de(k = originalDict.copy()):\n",
        "  print(\"  IN k= \" ,k )\n",
        "  k[1]= \"$t€a£i\"\n",
        "  k[3][0]=999\n",
        "  print(\"  OUT k= \" ,k )\n",
        "\n",
        "de()\n",
        "print(originalDict)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xUB09-PGIjcf",
        "outputId": "cd870a84-7b3a-490b-bfca-18aa53f72fc4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1: 'A', 2: 'B', 3: ['a', 'b']}\n",
            "  IN k=  {1: 'A', 2: 'B', 3: ['a', 'b']}\n",
            "  OUT k=  {1: '$t€a£i', 2: 'B', 3: [999, 'b']}\n",
            "{1: 'A', 2: 'B', 3: [999, 'b']}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "originalDict = {1: \"A\", 2: \"B\", 3: [\"a\", \"b\"]}\n",
        "print(originalDict)\n",
        "\n",
        "def de(k = copy.deepcopy(originalDict)):\n",
        "  print(\"  IN k= \" ,k )\n",
        "  k[1]= \"$t€a£i\"\n",
        "  k[3][0]=999\n",
        "  print(\"  OUT k= \" ,k )\n",
        "\n",
        "de()\n",
        "print(originalDict)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_BAWdd55JcTr",
        "outputId": "28906b7a-9bab-4c3b-cac3-5bba6fabf750"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1: 'A', 2: 'B', 3: ['a', 'b']}\n",
            "  IN k=  {1: 'A', 2: 'B', 3: ['a', 'b']}\n",
            "  OUT k=  {1: '$t€a£i', 2: 'B', 3: [999, 'b']}\n",
            "{1: 'A', 2: 'B', 3: ['a', 'b']}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Convert a String List to an Float List"
      ],
      "metadata": {
        "id": "JrsTm44q4det"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cEtbQOj_4LfE",
        "outputId": "791f7720-b206-4d76-dd32-cc3315baee5a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0. 0. 0. 3.5 0. 0. 1. 0. 7890.]\n",
            "<class 'str'>\n",
            "['0.', '0.', '0.', '3.5', '0.', '0.', '1.', '0.', '7890.']\n",
            "<class 'list'>\n",
            "[0.0, 0.0, 0.0, 3.5, 0.0, 0.0, 1.0, 0.0, 7890.0]\n",
            "3.5\n",
            "<class 'float'>\n"
          ]
        }
      ],
      "source": [
        "f = '[0. 0. 0. 3.5 0. 0. 1. 0. 7890.]'\n",
        "print(f)\n",
        "print(type(f))\n",
        "\n",
        "h = f[1:-1].split(\" \")\n",
        "print(h)\n",
        "print(type(h))\n",
        "\n",
        "h = [float(x) for x in h]\n",
        "print(h)\n",
        "print(h[3])\n",
        "print(type(h[3]))"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Seed() -- Can I generate the same random numbers at the beginning of every Python code?\n",
        "\n",
        "The seed() method  is used to initialize the pseudo-random number generator of Python which generates the random values\n",
        "\n",
        "The random module provides a fast pseudorandom number generator based on the Mersenne Twister algorithm.\n",
        "\n",
        "The pseudo-random number generator needs a number to start with (a seed value), to be able to generate a random number.\n",
        "\n",
        "Seed function is used to save the state of a random function, so that it can generate same random numbers on multiple executions of the code on the same machine or on different machines\n",
        "\n",
        "By default the random number generator uses the current system time.You can use the seed() method to customize the start number of the random number generator.\n",
        "\n"
      ],
      "metadata": {
        "id": "8y_kA-DWlH4E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "\n",
        "# If you use the same seed value twice you will get the same sequence of random numbers twice.\n",
        "random.seed(123)\n",
        "print(random.random())\n",
        "print(random.random())\n",
        "print(random.random())\n",
        "print(\"**\")\n",
        "random.seed(123)\n",
        "print(random.random())\n",
        "print(random.random())\n",
        "print(random.random())\n",
        "print(\"**\")\n",
        "random.seed(0)\n",
        "print(random.random())\n",
        "print(random.random())\n",
        "print(random.random())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3alyK2l6lK73",
        "outputId": "bd71aefe-7f78-485e-cded-e1b8844a6703"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.052363598850944326\n",
            "0.08718667752263232\n",
            "0.4072417636703983\n",
            "**\n",
            "0.052363598850944326\n",
            "0.08718667752263232\n",
            "0.4072417636703983\n",
            "**\n",
            "0.8444218515250481\n",
            "0.7579544029403025\n",
            "0.420571580830845\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Variables in Python\n",
        "\n",
        "Python is an object-oriented language.\n",
        "\n",
        "Everything in Python is an object.\n",
        "\n",
        "A Python Variable is a symbolic name that is a reference to an object. Once an object is assigned to a variable, you can refer to the object by that name.\n",
        "\n",
        "*\n",
        "\n",
        "\n",
        "When an object has no longer any reference to, it is orphaned, and there is no way to access it.\n",
        "The life cycle of an object initiates upon its creation, establishing at least one reference to it. An object remains 'alive' as long as there exists at least one reference to it.\n",
        "\n",
        "When the count of references to an object is zero, it becomes unreachable, signaling the end of its life. Python automatically detects such inaccessible objects and reclaims the memory they occupy, making it available for other purposes. This process is commonly known as garbage collection in computer scince.\n",
        "\n",
        "*\n",
        "\n",
        "\n",
        "id()\n",
        "\n",
        "In Python, upon creation, every object is assigned a number that uniquely identifies it.\n",
        "\n",
        "It is guaranteed that no two objects will share the same identifier while their lifetimes.\n",
        "\n",
        "\n",
        "$\\;$\n",
        "\n",
        "More info :\n",
        "\n",
        "https://realpython.com/python-variables/\n",
        "\n"
      ],
      "metadata": {
        "id": "sGnfBkq7-XoG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Informally, in Pytohn you can think of a variable as a \"nickname\" you give to an area of memory.\n",
        "\n",
        "s = 1\n",
        "d = s\n",
        "# With instruction d = s, Python does not create another object.\n",
        "# Instead, it creates a new symbolic name or reference, \"d\" ,\n",
        "# which points to the same object that \"s\" points to. This memory optimization enhances efficiency.\n",
        "print(\"s=\",s, \"@@ id=\", id(s))\n",
        "print(\"d=\",d, \"@@ id=\", id(d))\n",
        "print(\"\")\n",
        "\n",
        "\n",
        "s = s + 98\n",
        "print(\"s=\",s, \"@@ id=\", id(s))\n",
        "print(\"d=\",d, \"@@ id=\", id(d))\n",
        "print(\"\")\n",
        "\n",
        "\n",
        "s = \"Yes!\"\n",
        "print(\"s=\",s, \"@@ id=\", id(s))\n",
        "print(\"d=\",d, \"@@ id=\", id(d))\n",
        "print(s==d)\n",
        "print(s is d)\n",
        "print(\"\")\n",
        "\n",
        "\n",
        "d = 257\n",
        "s = 257\n",
        "print(\"s=\",s, \"@@ id=\", id(s))\n",
        "print(\"d=\",d, \"@@ id=\", id(d))\n",
        "print(s==d)\n",
        "print(s is d)\n",
        "print(\"\")\n",
        "\n",
        "\n",
        "d = 256\n",
        "s = 256\n",
        "print(\"s=\",s, \"@@ id=\", id(s))\n",
        "print(\"d=\",d, \"@@ id=\", id(d))\n",
        "print(s==d)\n",
        "print(s is d)\n",
        "# Python interpreter optimizes performance for small integers.\n",
        "# When you create an int in that range [-5, 256] you actually just get back a reference to the existing object.\n",
        "# This means that assigning separate variables to values in this range will make them refer\n",
        "# to the same underlying object, not creating new ones each time.\n",
        "print(\"\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x8t33X3d-ifX",
        "outputId": "a38ac6a2-0d8e-4337-95fe-a26b299f479b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "s= 1 @@ id= 134462169612528\n",
            "d= 1 @@ id= 134462169612528\n",
            "\n",
            "s= 99 @@ id= 134462169615664\n",
            "d= 1 @@ id= 134462169612528\n",
            "\n",
            "s= Yes! @@ id= 134461059737008\n",
            "d= 1 @@ id= 134462169612528\n",
            "False\n",
            "False\n",
            "\n",
            "s= 257 @@ id= 134461059991568\n",
            "d= 257 @@ id= 134461059994000\n",
            "True\n",
            "False\n",
            "\n",
            "s= 256 @@ id= 134462169620688\n",
            "d= 256 @@ id= 134462169620688\n",
            "True\n",
            "True\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## print() v.s. repr()"
      ],
      "metadata": {
        "id": "kPfmsF0Lgd0x"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import datetime\n",
        "\n",
        "l = \"Hello 123 \"\n",
        "print(repr(l))  # repr() prints an “raw” representation of data\n",
        "print(l)\n",
        "\n",
        "value = np.ones(4)\n",
        "print(repr(value))\n",
        "print(value)\n",
        "\n",
        "today = datetime.datetime.now()\n",
        "print(repr(today))\n",
        "print(today)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ht7b-dvpgjdv",
        "outputId": "8ac6ab5c-8a88-48e3-cfb2-4371160b54f7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "'Hello 123 '\n",
            "Hello 123 \n",
            "array([1., 1., 1., 1.])\n",
            "[1. 1. 1. 1.]\n",
            "datetime.datetime(2024, 1, 4, 12, 53, 43, 304582)\n",
            "2024-01-04 12:53:43.304582\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##np.random.choice()"
      ],
      "metadata": {
        "id": "-vjAeUPV7W0i"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "n = 0\n",
        "supp = [0, 1, 2]\n",
        "\n",
        "a = np.random.choice(supp, p=[0.7, 0.25,  0.05]) # p= probability distribution\n",
        "\n",
        "print(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pCQ6Xslf7XKR",
        "outputId": "2d85e7e8-4238-4982-b770-68e6246f87d7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##np.linspace()"
      ],
      "metadata": {
        "id": "X52Ul9HG_w1N"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = np.linspace(-1, 5, 10)\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PxjTfDxP_xio",
        "outputId": "d41377d6-83f7-410b-95f7-2474bcb8c22f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[-1.         -0.33333333  0.33333333  1.          1.66666667  2.33333333\n",
            "  3.          3.66666667  4.33333333  5.        ]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## To check if one number is equal to or greater than twice the other and vice versa"
      ],
      "metadata": {
        "id": "r-gX8NU-6h6I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def e_il_doppio(x, y):\n",
        "    if y ==0 or x ==0 :\n",
        "      return (\"Error\")\n",
        "    return x / y >= 2 or y / x >= 2\n",
        "\n",
        "x = 30\n",
        "y = 70\n",
        "\n",
        "print(e_il_doppio(x, y))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7jHwLX9K6iR4",
        "outputId": "f2276565-f806-4a7c-c5b0-8299700d47d2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Find if there is at least one element greater than zero in a np.matrix"
      ],
      "metadata": {
        "id": "x6MeTsQTNuDO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "Q = np.zeros((5, 5)).round(3)\n",
        "\n",
        "Q[1][2] = 0.001\n",
        "Q[4][0] = 0.001\n",
        "\n",
        "if np.size(np.where(Q > 0)[0]) != 0:\n",
        "  print(\"Find!\")\n",
        "  print(\"Indexes :\", np.where(Q > 0))\n",
        "  print(\"\\n\",Q,\"\\n\")\n",
        "\n",
        "  # Alternative, if just one element\n",
        "  #row = int(np.where(Q > 0)[0])\n",
        "  #col = int(np.where(Q > 0)[1])\n",
        "  #print(\"It's in row: \", row,\", column: \",col)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mHp8ckNjKRag",
        "outputId": "4d210b3c-030d-48a7-951e-a8363c28c5b5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Find!\n",
            "Indexes : (array([1, 4]), array([2, 0]))\n",
            "\n",
            " [[0.    0.    0.    0.    0.   ]\n",
            " [0.    0.    0.001 0.    0.   ]\n",
            " [0.    0.    0.    0.    0.   ]\n",
            " [0.    0.    0.    0.    0.   ]\n",
            " [0.001 0.    0.    0.    0.   ]] \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Find the maximum value in a dictionary"
      ],
      "metadata": {
        "id": "NBy3Oq01l20H"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "d = {'a': 3, 'b': 2, 'c': 98, 'd': 3, 'e': 95, 'f': 1}\n",
        "\n",
        "max_value = None\n",
        "\n",
        "for value in d.values():\n",
        "    if (max_value is None) or (value > max_value):\n",
        "        max_value = value\n",
        "\n",
        "print(max_value)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fu02dzIKl2N1",
        "outputId": "cf5ff2d3-bfc9-4c72-df68-69b465b8c1f7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "98\n"
          ]
        }
      ]
    }
  ]
}