02_ai_for_good_music.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "m1MmMlqlPQcz"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Video 02: Lists, Conditions, and Arpeggios\n",
        "# Goal\n",
        "\n",
        "\n",
        "*   Work with Lists\n",
        "*   Use Conditional Logic\n",
        "*   Build a C Major Arpeggio\n",
        "*   Filter A Minor & C Major Arpeggios"
      ],
      "metadata": {
        "id": "LD39xRjOnaxn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### What is an Arpeggio?\n",
        "\n",
        "An arpeggio occurs when the notes of a chord are played in succession, either ascending or descending, rather than simultaneously. The 1st, 3rd, and 5th notes of the C major scale form the chord for that scale—the C major chord, respectively. To combine music and programming, we can use lists and loops to create arpeggios or chords from the notes of the C major scale.\n",
        "\n"
      ],
      "metadata": {
        "id": "qAvlm25oqWOG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Working with Lists\n",
        "\n",
        "In music, a scale is a series of notes arranged in ascending or descending order. In Python, we can represent a scale using a list of objects. Let's create a C major scale and explore how to manipulate these lists."
      ],
      "metadata": {
        "id": "-C7_TlS6OgaQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "scale = ['C', 'D', 'E', 'F', 'G', 'A', 'B']\n",
        "scale[6]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "2TFOvJ65wFT3",
        "outputId": "aa96a843-2123-4470-8eb3-6de3de5f74cf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'B'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "scale"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vyqb3dmxwFQl",
        "outputId": "54c4e10b-bfd3-48ce-8eb1-fd0e704744cf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['C', 'D', 'E', 'F', 'G', 'A', 'B']"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Append\n",
        "scale.append('C')"
      ],
      "metadata": {
        "id": "XwyA3yPtwFNd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "scale"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_tNMfHX8wFKP",
        "outputId": "7fbf295d-0ca3-48c5-e3fb-1d89384ebb65"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['C', 'D', 'E', 'F', 'G', 'A', 'B', 'C']"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Conditional Logic: if, else, and loops\n",
        "Chords are built when certain conditions are met, much like how we use conditional statements in Python. Let's explore how to build a simple chord. We'll also use loops to create rhythmic patterns.\n",
        "\n"
      ],
      "metadata": {
        "id": "KDQbrQzRRL5F"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "notes = ['C', 'E', 'G']\n",
        "chord = [] # initialize list\n",
        "for note in notes:\n",
        "  chord.append(note)\n",
        "  print(f\"Adding {note}\")\n",
        "print(\"Done: \", chord)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WcxzcWbjwEW5",
        "outputId": "40d011ab-921c-4ca2-e608-1d6ade2fc017"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Adding C\n",
            "Adding E\n",
            "Adding G\n",
            "Done:  ['C', 'E', 'G']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "chord"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qYoB4sBLwET0",
        "outputId": "dcace4f8-9645-4a48-cd86-a5a3b3eae80c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['C', 'E', 'G']"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "all_notes = ['C', 'D', 'E', 'F', 'G', 'A', 'B']\n",
        "\n",
        "for note in all_notes:\n",
        "  if note in ['C', 'E', 'G']: # C major arpeggio\n",
        "    print(f'C major: {note}')\n",
        "  elif note in ['A', 'C', 'E']: # A minor arpeggio\n",
        "    print(f'A minor: {note}')\n",
        "  else:\n",
        "    print(f'{note} is not part if C major or A minor chords.')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-OnGF4R0wEQx",
        "outputId": "60dd8926-afe9-4e71-cc69-4d3cbc18747b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "C major: C\n",
            "D is not part if C major or A minor chords.\n",
            "C major: E\n",
            "F is not part if C major or A minor chords.\n",
            "C major: G\n",
            "A minor: A\n",
            "B is not part if C major or A minor chords.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "x2rdsG2XzGbo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "6AKTVGTIyUln"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "_MAtOqVKyUi3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Review\n",
        "\n",
        "\n",
        "*   Worked with Lists\n",
        "*   Used Conditional Logic\n",
        "*   Built a C Major Arpeggio\n",
        "*   Filtered A Minor & C Major Arpeggios Notes\n",
        "\n",
        "\n",
        "## Next Week:\n",
        "Functions and loops! You'll learn how to functionize your loops and keep your code looking clearn and readable."
      ],
      "metadata": {
        "id": "4ECtoTgLNTTs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ],
      "metadata": {
        "id": "DybZ9WgGNQ8q"
      }
    }
  ]
}