8. Python_Lists.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Startrek Python - Lists (Arrays)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- List is a collection which is ordered and changeable. Allows duplicate members.\n",
    "- Tuple is a collection which is ordered and unchangeable. Allows duplicate members.\n",
    "- Set is a collection which is unordered and unindexed. No duplicate members.\n",
    "- Dictionary is a collection which is unordered, changeable and indexed. No duplicate members.\n",
    "\n",
    "When choosing a collection type, it is useful to understand the properties of that type. Choosing the right type for a particular data set could mean retention of meaning, and, it could mean an increase in efficiency or security."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Phaser1\n",
      "Phaser4\n"
     ]
    }
   ],
   "source": [
    "phaser_array = ['Phaser1','Phaser2','Phaser3','Phaser4']\n",
    "\n",
    "# access the first element in array\n",
    "print(phaser_array[0])\n",
    "\n",
    "\n",
    "# access the last element\n",
    "print(phaser_array[-1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Antide Prime', 'Arakis Prime', 'Atbar Prime', 'Azati Prime']\n"
     ]
    }
   ],
   "source": [
    "prime_planets = [\"Adarak Prime\",\"Adigeon Prime\", \"Ajilon Prime\", \\\n",
    "                 \"Amleth Prime\", \"Andoria Prime\", \"Antide Prime\",\\\n",
    "                 \"Arakis Prime\", \"Atbar Prime\", 'Azati Prime',\\\n",
    "                 'Barisa Prime','Bernay Prime','Bozel Prime',\\\n",
    "                 'Burala Prime','Caldik Prime','Cardassia Prime']\n",
    "\n",
    "# silce out elements from index 5 to 9\n",
    "print(prime_planets[5:9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Adarak Prime', 'Adigeon Prime', 'Ajilon Prime', 'Amleth Prime']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# slice out elements before 4th index\n",
    "prime_planets[:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Arakis Prime',\n",
       " 'Atbar Prime',\n",
       " 'Azati Prime',\n",
       " 'Barisa Prime',\n",
       " 'Bernay Prime',\n",
       " 'Bozel Prime',\n",
       " 'Burala Prime',\n",
       " 'Caldik Prime',\n",
       " 'Cardassia Prime']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# slice out elements from index position to end\n",
    "prime_planets[6:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Change element at index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Antide Prime', 'Arakis Prime', 'Amazon_Prime']"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's change the element \"Atbar Prime\" to \"Amazon Prime\"\n",
    "prime_planets[7] = \"Amazon_Prime\"\n",
    "\n",
    "prime_planets[5:8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List For Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple loops!\n",
      "banana loops!\n",
      "cherry loops!\n"
     ]
    }
   ],
   "source": [
    "# you can get elements out of a list by using a for-loop function\n",
    "# the basics of loops are: whatever is in a list, for-loop goes through the\n",
    "# list and does what you tell it to\n",
    "\n",
    "# the 'fruit' variable is often an x in code examples. It can be whatever\n",
    "loops = [\"apple\", \"banana\", \"cherry\"]\n",
    "for fruit in loops:\n",
    "    print(fruit,'loops!')\n",
    "    \n",
    "# however long your list is, the for-loop will iterate through every item\n",
    "# if you were to run same function on prime_planets with 15 elements, \n",
    "# the print out is long, give it a try! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes, 'apple' is in the loops list\n"
     ]
    }
   ],
   "source": [
    "# check if element item is in the list\n",
    "\n",
    "loops = [\"apple\", \"banana\", \"cherry\"]\n",
    "if \"apple\" in loops:\n",
    "    print(\"Yes, 'apple' is in the loops list\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# just like length of strings, the same function applies \n",
    "\n",
    "# how many elements in prime_planets ?\n",
    "# len(<list_name>)\n",
    "\n",
    "print(\" There are {} {}\".format(len(prime_planets),\"Prime Planets\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add items to list "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " fruit in loops ['apple', 'banana', 'cherry']\n"
     ]
    }
   ],
   "source": [
    "# use the .append() function to add items to a list\n",
    "# list_name.append('appending_item')\n",
    "\n",
    "print(' fruit in loops', loops) # original list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "loops.append('Mango')  # if you run this cell,'Mango' gets added each time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " fruit in loops ['apple', 'banana', 'cherry', 'Mango', 'Mango']\n"
     ]
    }
   ],
   "source": [
    "print(' fruit in loops', loops) # updated list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Remove item from List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'banana', 'cherry', 'Mango', 'Mango']"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loops # appended Mango 2x's"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "loops.remove(\"Mango\") # remove 1 mango"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'banana', 'cherry', 'Mango']"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loops # 1 mango remains"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'bread toast'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the function pop() does the same thing as remove() BUT with pop you \n",
    "# get to say \"pop the stack\" which a list array is, plus pop sounds more fun\n",
    "\n",
    "stack = ['pancakes','waffles','bread toast']\n",
    "stack.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " root beer Jones goes pop!\n"
     ]
    }
   ],
   "source": [
    "root_beer = ['A&W',\"Barq'\\s\",'Hires','Jones']\n",
    "print(' root beer', root_beer.pop(),'goes pop!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " remaining Borgs ['Borg_0001', 'Borg_0010', 'Borg_0110']\n"
     ]
    }
   ],
   "source": [
    "# if you want to delete an element at index use del function\n",
    "\n",
    "Borgs = ['Borg_0001','Borg_0010','Borg_0110','Borg_0101']\n",
    "\n",
    "# The Borg Queen has decided to delete an inefficient Borg\n",
    "del Borgs[3]\n",
    "print(' remaining Borgs', Borgs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " you have 0 files in your bad memories list\n"
     ]
    }
   ],
   "source": [
    "# if you want to delete all elements in list use clear()\n",
    "\n",
    "# let's clear your memories\n",
    "bad_memories = ['Bullies','Broken Hearts','Sad Memories','Disturbing Content']\n",
    "\n",
    "bad_memories.clear()\n",
    "print(' you have {} files in your {}'.format(len(bad_memories),\"bad memories list\"))\n",
    "                                             \n",
    "# only if it were that simple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Copy a List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Vorta Weyoun Clones copy ['Weyoun V', 'Weyoun VI', 'Weyoun VII']\n"
     ]
    }
   ],
   "source": [
    "Vorta_Weyoun = [\"Weyoun V\", \"Weyoun VI\", \"Weyoun VII\"]\n",
    "\n",
    "Vorta_Weyoun_clones = Vorta_Weyoun.copy()\n",
    "print(' Vorta Weyoun Clones copy',Vorta_Weyoun_clones)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Join 2 Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Atbar Prime', 'Avenal VII', 'Cardassia I', 'Cardassia Prime', 'Cardassia III', 'Cardassia IV', 'Cardassia V', \"Qo'noS\", 'Boreth', 'Rura Penthe', 'Narendra III']\n"
     ]
    }
   ],
   "source": [
    "Cardassian_planets = ['Atbar Prime','Avenal VII','Cardassia I','Cardassia Prime',\\\n",
    "                     'Cardassia III','Cardassia IV','Cardassia V']\n",
    "Klingon_planets = [\"Qo'noS\",'Boreth','Rura Penthe','Narendra III']\n",
    "\n",
    "Dominion_attacked_planets = Cardassian_planets + Klingon_planets\n",
    "print(Dominion_attacked_planets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "group 1 planets appended ['Gorn', 'Hirogen', 'Orion', 'Lessepians', 'Bajor', 'Torna IV', 'Khitomer']\n"
     ]
    }
   ],
   "source": [
    "# you can use the for-loop method to append list items to another list\n",
    "\n",
    "group1 = [\"Gorn\",'Hirogen','Orion','Lessepians']\n",
    "group2 = ['Bajor','Torna IV','Khitomer']\n",
    "\n",
    "for x in group2:\n",
    "    group1.append(x)\n",
    "    \n",
    "print('group 1 planets appended',group1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " group1 extended ['Gorn', 'Hirogen', 'Orion', 'Lessepians', 'Bajor', 'Torna IV', 'Khitomer']\n"
     ]
    }
   ],
   "source": [
    "# another way to do the append is the extend() function\n",
    "group1 = [\"Gorn\",'Hirogen','Orion','Lessepians']\n",
    "group2 = ['Bajor','Torna IV','Khitomer']\n",
    "\n",
    "group1.extend(group2)\n",
    "print(' group1 extended',group1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Quark and crime count is 3\n",
      " phaser254 at index 2\n",
      "['Phaser11', 'Phaser12', 'Phaser254', 'Phaser3000_XT', 'Phaser4', 'Phaser17']\n",
      " list in reverse  ['cherry', 'banana', 'apple', 'Mango']\n"
     ]
    }
   ],
   "source": [
    "# append()  clear()  copy()   count()  extend()  index()  insert()\n",
    "# pop()   remove()   reverse()  sort()\n",
    "\n",
    "Quarks_business = ['Crime', 'Holosuites', 'Crime','Beverages','Crime']\n",
    "\n",
    "x = Quarks_business.count(\"Crime\")\n",
    "print(' Quark and {} count is {}'.format(\"crime\", x))\n",
    "\n",
    "\n",
    "phaser_array =['Phaser11','Phaser12','Phaser254','Phaser4','Phaser17']\n",
    "p = phaser_array.index('Phaser254')\n",
    "print(' phaser254 at index',p)\n",
    "\n",
    "# insert( index, <insert>)\n",
    "phaser_array.insert(3,'Phaser3000_XT')\n",
    "print(phaser_array)\n",
    "\n",
    "# reverse \n",
    "loops.reverse() # call original list, reverse()\n",
    "loops           # print it\n",
    "print(' list in reverse ',loops)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " fruit loops in order  ['Mango', 'apple', 'banana', 'cherry']\n"
     ]
    }
   ],
   "source": [
    "# sort a list, default is ascending order (least to greatest)\n",
    "loops.sort()\n",
    "loops\n",
    "print(' fruit loops in order ', loops)\n",
    "\n",
    "# Mango has capital letter, capital letters go after lowercase\n",
    "# if element was 'mango' it would be at the end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}