Days/03/list_comp.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "list_comp.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ksImikWm3E8I",
        "colab_type": "text"
      },
      "source": [
        "This notebook has been created to help me learn about list comprehension in Python as part of my [#100DaysOfCode](https://github.com/pbeens/100DaysOfCode) project."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s9Sqq3cjavLx",
        "colab_type": "text"
      },
      "source": [
        "## Resource 1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yzW7Uu443ceY",
        "colab_type": "text"
      },
      "source": [
        "The first reference I'll be using is [https://www.pythonforbeginners.com/basics/list-comprehensions-in-python](https://www.pythonforbeginners.com/basics/list-comprehensions-in-python).\n",
        "\n",
        "The traditional way opf doing it looks like this:\n",
        "\n",
        "```\n",
        "new_list = []\n",
        "for i in old_list:\n",
        "    if filter(i):\n",
        "        new_list.append(expressions(i))\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bSDGUTaraCEN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "old_list = [1, 2, 3, 'A', [4, 7]]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "udSbTS3X3l9W",
        "colab_type": "code",
        "outputId": "0eda8b0a-1720-432e-e0f4-a28634e4ab4d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# Old-school example:\n",
        "\n",
        "new_list = []\n",
        "for i in old_list: # loop through items\n",
        "    if i != '': # test condition (not necessary here, but included to show how filtering selecting items works)\n",
        "        new_list.append(i) # append to new list\n",
        "print(new_list) # voila! "
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 'A', [4, 7]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QKugw7gmZI-B",
        "colab_type": "text"
      },
      "source": [
        "Redoing the above example in list comprehension looks like this:\n",
        "\n",
        "  ```python\n",
        "  new_list = [expression(i) for i in old_list if filter(i)]\n",
        "  ```\n",
        "\n",
        "This is explained on the resource site as:\n",
        "\n",
        "> new_list:\n",
        "- The new list (result).\n",
        "\n",
        "> expression(i):\n",
        "- Expression is based on the variable used for each element in the old list.\n",
        "\n",
        "> for i in old_list:\n",
        "- The word for followed by the variable name to use, followed by the word in the old list.\n",
        "\n",
        "> if filter(i):\n",
        "- Apply a filter with an If-statement."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9Z3y5X45ZmfF",
        "colab_type": "code",
        "outputId": "47aeb2e7-45d0-4651-b390-0e8e554f7fbd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# re-coded using list comprehension:\n",
        "\n",
        "new_list = [i for i in old_list if i != '']\n",
        "print(new_list)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 'A', [4, 7]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a0oJxkQTcq2K",
        "colab_type": "text"
      },
      "source": [
        "## Some Exercises"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zdl8A6mAcsCf",
        "colab_type": "code",
        "outputId": "b5e3a537-3ffc-43bb-c43d-7f7f199652b4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# first 10 numbers\n",
        "print([i for i in range(10)])"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QofKkSVMc7v7",
        "colab_type": "code",
        "outputId": "50ebfd2c-4699-4a64-9aed-c77256d0c53b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# every 2nd number\n",
        "print([i for i in range(10) if i % 2 == 0])"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 2, 4, 6, 8]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vzzYqsuWdTH8",
        "colab_type": "code",
        "outputId": "e020a1b2-3f40-4a73-8eb3-59911fa7fd6e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# print squares\n",
        "print([x*x for x in range(10)])"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JxfGqpqjdl-b",
        "colab_type": "code",
        "outputId": "063e74ca-22e4-4913-dd27-2c8b55a5eef8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# print squares but only if the square is divisible by 3, up to x = 100\n",
        "print([x*x for x in range(101) if x*x % 3 == 0]) # note that I have to use '101' to get up to 100"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 9, 36, 81, 144, 225, 324, 441, 576, 729, 900, 1089, 1296, 1521, 1764, 2025, 2304, 2601, 2916, 3249, 3600, 3969, 4356, 4761, 5184, 5625, 6084, 6561, 7056, 7569, 8100, 8649, 9216, 9801]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gggqDb0SeZmQ",
        "colab_type": "code",
        "outputId": "18362e75-6b94-4da5-8d89-7978bb2e3086",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "# let's extract every first letter of a list of words\n",
        "s = 'The woods are lovely, dark and deep, But I have promises to keep, and miles to go before I sleep'\n",
        "s2 = [word[0].lower() for word in s.split()]\n",
        "print(s2)\n",
        "# with poem credit to Robert Frost\n",
        "\n",
        "# to assemble the letters we can use join()\n",
        "print(''.join(s2))"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['t', 'w', 'a', 'l', 'd', 'a', 'd', 'b', 'i', 'h', 'p', 't', 'k', 'a', 'm', 't', 'g', 'b', 'i', 's']\n",
            "twaldadbihptkamtgbis\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n7dgVqmh0lo-",
        "colab_type": "text"
      },
      "source": [
        "## Resource 2\n",
        "\n",
        "I found some interactive challenges at https://www.learnpython.org/en/List_Comprehensions which I have also coded below."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mVg6BoFC2COD",
        "colab_type": "text"
      },
      "source": [
        "### Exercise 1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kU436LW01Cj9",
        "colab_type": "code",
        "outputId": "d368e6cb-f35a-4332-bfbd-2b6f1689be29",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "# Old way\n",
        "sentence = \"the quick brown fox jumps over the lazy dog\"\n",
        "words = sentence.split()\n",
        "word_lengths = []\n",
        "for word in words:\n",
        "      if word != \"the\":\n",
        "          word_lengths.append(len(word))\n",
        "print(words)\n",
        "print(word_lengths)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['the', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog']\n",
            "[5, 5, 3, 5, 4, 4, 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wg9JXk8m1-8_",
        "colab_type": "code",
        "outputId": "653e878d-7dd8-4d11-d2b3-9175201eec97",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# and now using list comprehension\n",
        "sentence = \"the quick brown fox jumps over the lazy dog\"\n",
        "words = sentence.split()\n",
        "word_lengths = [len(word) for word in words if word != 'the']\n",
        "print(word_lengths)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[5, 5, 3, 5, 4, 4, 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LF2tytq22Lkn",
        "colab_type": "text"
      },
      "source": [
        "### Exercise 2"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "c8NlApc12ObO",
        "colab_type": "code",
        "outputId": "bc827e0c-ca17-40f2-e4cf-be6a694ba8c1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# Using a list comprehension, create a new list called \"newlist\" out of the list\n",
        "# \"numbers\", which contains only the positive numbers from the list, as \n",
        "# integers.\n",
        "numbers = [34.6, -203.4, 44.9, 68.3, -12.2, 44.6, 12.7]\n",
        "newlist = [num for num in numbers if num >= 0]\n",
        "print(newlist)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[34.6, 44.9, 68.3, 44.6, 12.7]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZD2Yyh6J3rhK",
        "colab_type": "text"
      },
      "source": [
        "### Exercise 3\n",
        "\n",
        "Some challenges posted at https://www.reddit.com/r/learnpython/comments/4d2yl7/i_need_list_comprehension_exercises_to_drill/"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dRsHsP-F3xpj",
        "colab_type": "code",
        "outputId": "c24e1e6d-8b8f-4409-b7f0-cd475b4ffba3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        }
      },
      "source": [
        "# Find all of the numbers from 1-1000 that are divisible by 7\n",
        "nums = [num for num in range(1, 1001) if num % 7 == 0]\n",
        "print(nums)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, 98, 105, 112, 119, 126, 133, 140, 147, 154, 161, 168, 175, 182, 189, 196, 203, 210, 217, 224, 231, 238, 245, 252, 259, 266, 273, 280, 287, 294, 301, 308, 315, 322, 329, 336, 343, 350, 357, 364, 371, 378, 385, 392, 399, 406, 413, 420, 427, 434, 441, 448, 455, 462, 469, 476, 483, 490, 497, 504, 511, 518, 525, 532, 539, 546, 553, 560, 567, 574, 581, 588, 595, 602, 609, 616, 623, 630, 637, 644, 651, 658, 665, 672, 679, 686, 693, 700, 707, 714, 721, 728, 735, 742, 749, 756, 763, 770, 777, 784, 791, 798, 805, 812, 819, 826, 833, 840, 847, 854, 861, 868, 875, 882, 889, 896, 903, 910, 917, 924, 931, 938, 945, 952, 959, 966, 973, 980, 987, 994]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1TIJe0Fl4Ni4",
        "colab_type": "code",
        "outputId": "cb7f8d3e-eb1c-4f8e-99b3-37d27212b4b5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        }
      },
      "source": [
        "# Find all of the numbers from 1-1000 that have a 3 in them\n",
        "nums = [num for num in range(1, 1001) if '3' in str(num)]\n",
        "print(nums)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[3, 13, 23, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 43, 53, 63, 73, 83, 93, 103, 113, 123, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 143, 153, 163, 173, 183, 193, 203, 213, 223, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 243, 253, 263, 273, 283, 293, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 403, 413, 423, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 443, 453, 463, 473, 483, 493, 503, 513, 523, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 543, 553, 563, 573, 583, 593, 603, 613, 623, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 643, 653, 663, 673, 683, 693, 703, 713, 723, 730, 731, 732, 733, 734, 735, 736, 737, 738, 739, 743, 753, 763, 773, 783, 793, 803, 813, 823, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 843, 853, 863, 873, 883, 893, 903, 913, 923, 930, 931, 932, 933, 934, 935, 936, 937, 938, 939, 943, 953, 963, 973, 983, 993]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QcEeS0D64zmj",
        "colab_type": "code",
        "outputId": "4077965c-6e65-4a9a-9d77-508dcbba36d1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "# Count the number of spaces in a string\n",
        "s = '''One word can start a friendship,\n",
        "One kiss a love affair,\n",
        "One smile can bring you laughter,\n",
        "One hug can show you care\n",
        "'''\n",
        "# Read the rest of the poen at \n",
        "# https://www.familyfriendpoems.com/poems/life/inspirational/\n",
        "\n",
        "# traditional way\n",
        "count = s.count(' ')\n",
        "print(count)\n",
        "\n",
        "# LC way\n",
        "spaces = [c for c in s if c == ' ']\n",
        "print(len(spaces))"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "19\n",
            "19\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s4IuJqKP6HSU",
        "colab_type": "code",
        "outputId": "38712264-78fa-4122-e5f3-6c9b84f98296",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# Remove all of the vowels in a string\n",
        "vowels = 'aeiouAEIOU'\n",
        "s = 'Remove all of the vowels in a string'\n",
        "new_string = ''.join([c for c in s if c not in vowels])\n",
        "print(new_string)"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Rmv ll f th vwls n  strng\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "crTFQ3Ys7SQJ",
        "colab_type": "code",
        "outputId": "0c07e66d-092d-4b63-d695-e99aa2e66351",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# Find all of the words in a string that are less than 4 letters\n",
        "words = 'Find all of the words in a string that are less than 4 letters'.split()\n",
        "short_words = [word for word in words if len(word) < 4]\n",
        "print(short_words)"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['all', 'of', 'the', 'in', 'a', 'are', '4']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PYcYKGOx77X0",
        "colab_type": "code",
        "outputId": "24cf4e54-1ce3-4b92-c73a-eb71a0dea2cb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "# A list of all the capital letters (and not white space) in 'The Quick Brown Fox Jumped Over The Lazy Dog'\n",
        "import string\n",
        "s = 'The Quick Brown Fox Jumped Over The Lazy Dog'\n",
        "letters = [letter for letter in s if letter in string.ascii_uppercase]\n",
        "print(letters)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['T', 'Q', 'B', 'F', 'J', 'O', 'T', 'L', 'D']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1hjwcB1dqJaV",
        "colab_type": "text"
      },
      "source": [
        "## Resource 3\n",
        "\n",
        "This site had a tutorial with examples of list comprehensions using nested loops and dictionaries. This might be exactly what I am looking for to solve my #100DaysOfCode Day 1-2 challenge! [https://treyhunner.com/2015/12/python-list-comprehensions-now-in-color/](https://treyhunner.com/2015/12/python-list-comprehensions-now-in-color/)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "91BnS1egrJyB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 85
        },
        "outputId": "23ba3875-347f-45ca-87c9-f688b46dc43c"
      },
      "source": [
        "'''\n",
        "The example on the website for nested loops is this:\n",
        "\n",
        "flattened = []\n",
        "for row in matrix:\n",
        "    for n in row:\n",
        "        flattened.append(n)\n",
        "\n",
        "...which in LC translates to this:\n",
        "\n",
        "flattened = [n for row in matrix for n in row]\n",
        "\n",
        "I'm going to use the data  from the challenge I have to solve, which is...\n",
        "\n",
        "'''\n",
        "\n",
        "matrix1 = [[1, -2], [-3, 4]]\n",
        "matrix2 = [[2, -1], [0, -1]]\n",
        "\n",
        "# let's flatten each\n",
        "\n",
        "m1_flattened = [n for row in matrix1 for n in row]\n",
        "print(f'before: {matrix1} after: {m1_flattened}')\n",
        "\n",
        "# let's test reversing this, just for fun: (from the reference site)\n",
        "m1_back_to_a_matrix = [m1_flattened[i:i + 2] for i in range(0, len(m1_flattened), 2)]\n",
        "print(f'm1_back_to_a_matrix: {m1_back_to_a_matrix}')\n",
        "\n",
        "# and now for matrix2\n",
        "m2_flattened = [n for row in matrix2 for n in row]\n",
        "print(f'before: {matrix2} after: {m2_flattened}')\n",
        "m2_back_to_a_matrix = [m2_flattened[i:i + 2] for i in range(0, len(m2_flattened), 2)]\n",
        "print(f'm2_back_to_a_matrix: {m2_back_to_a_matrix}')\n",
        "\n"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "before: [[1, -2], [-3, 4]] after: [1, -2, -3, 4]\n",
            "m1_back_to_a_matrix: [[1, -2], [-3, 4]]\n",
            "before: [[2, -1], [0, -1]] after: [2, -1, 0, -1]\n",
            "m2_back_to_a_matrix: [[2, -1], [0, -1]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2jpxdgBu3rqc",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "The original of this notebook can be found at https://colab.research.google.com/drive/1fbmH9yDS5fzFcxEZMnUzmb3qCqGQoaEv"
      ]
    }
  ]
}