Object & data structures.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing and indexing:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = \"hello\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'e'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to do this, you take the variable the string is assigned to and put square brackets after it. Inside the square brackets, you would put the index, which tells the computer which character to pull from the string. Note that the first character is always index 0, and after that it is 1. Remember that it starts from 0, not 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also do reverse indexing, in which the last term is -1, and it counts down as it goes backwards: the seccond to last term would be -2, the third to last would be -3, but the first value is still 0. Here is an example of using reverse indexing to pull e from hello:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "reverse = \"hello\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e\n"
     ]
    }
   ],
   "source": [
    "print(reverse[-4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is usefull if you are trying to grab the last letter of the string but you do not know how long it is: all you have to do is use -1 as the index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing is used to grab a subsection of a string. in order to take a slice of a string, you use the following syntax:\n",
    "\n",
    "variable[start:stop:step]\n",
    "\n",
    "Start is the numerical index for the start of the slice.\n",
    "\n",
    "Stop is the numerical index for the character you will go up to, but not include\n",
    "\n",
    "Step is the size of the jump you will take.\n",
    "\n",
    "Here is an example of slicing the letters 'orl' from the string 'world."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "orl\n"
     ]
    }
   ],
   "source": [
    "test = 'world'\n",
    "print(test[1:4:1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an example of slicing the letters 'w', 'r', and 'd' from the string 'world'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wrd\n"
     ]
    }
   ],
   "source": [
    "print(test[0:5:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To reverse a string, you can use string[::-1] to pull out the terms in reverse step"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Other string stuff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use \\n in a string to start a new line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "world\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello\\nworld\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use \\t to make a tab:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "\tworld\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello\\n\\tworld\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use the built in function len() to find the length of a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "print(len('Hello world'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# String Properties and Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are Immutible, meaning that they cannot be changed. Here is an example of an error code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-12-a948b8677e97>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mname\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"Sam\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mname\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"P\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "name = \"Sam\"\n",
    "name[0] = \"P\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to turn the S into a P, we need to use concatination, which is combinding two strings together. We can splice the am from Sam and add a p to turn it into Pam."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pam'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'P'+name[1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also use Multiplication to print the string a set number of times back to back:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'SamSamSamSamSamSamSamSamSamSam'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name * 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also do a lot of other things with strings, like make them uppercase, lowercase, or whatever, by doing this simple thing:\n",
    "\n",
    "variable_name.tab\n",
    "\n",
    "you put in the variable name, then a period, then press tab, and jupyter will give you a list of possible functions you would want to use. for example, if you wanted to make a string uppercase, you would use variable_name.upper()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'SAM'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'sam'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pam'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name.replace('S','P')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sam', 'P']"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(name+' P').split()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ".split() is a very usefull function that you can use to split up a string. It normally splits on the whitespace, but you can split it by a different character by putting it in the parenthesis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['S', 'm']"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name.split(\"a\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to insert variables into a string, you can use the .format() method. here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Oh no i fell on my keyboardioajffjadksdfkpjtreirti\n"
     ]
    }
   ],
   "source": [
    "insertation = 'ioajffjadksdfkpjtreirti'\n",
    "print('Oh no i fell on my keyboard{}'.format(insertation))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We just put in curly braces inside a string where you want to insert the variable. THen you put .format(), with whatever you want to insert inside the parenthesis. Here is another example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This string is collThis string is collapsing onto itself!apsing onto itself!\n"
     ]
    }
   ],
   "source": [
    "statement = 'This string is collapsing onto itself!'\n",
    "print('This string is coll{}apsing onto itself!'.format(statement))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "YOu can also insert strings or variables multiple at a time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the fox brown quick\n"
     ]
    }
   ],
   "source": [
    "print('the {} {} {}'.format('fox','brown','quick'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, they are not in the order that i want. i want it to print out 'the quick brown fox'. Lucky for me, i can use indexing. Just put the index of the insertation that it appears in inside the .format() statement inside the correct curly brace:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the quick brown fox\n"
     ]
    }
   ],
   "source": [
    "print('the {2} {1} {0}'.format('fox','brown','quick'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "YOu can also print words multiple times using indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the brown brown fox\n"
     ]
    }
   ],
   "source": [
    "print('the {1} {1} {0}'.format('fox','brown','quick'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "you can make this easier by assigning the .format() things keywords and then use them as indexes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the quick brown fox\n"
     ]
    }
   ],
   "source": [
    "print('the {q} {b} {f}'.format(f='fox',b='brown',q='quick'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Changing value, width, and precision of floating point numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, while doing math with python, you will get a really ugly, long number. they are annoying to read, so we are going to change them to have less decimal places when using .format(). YOu do this by using the following syntax:\n",
    "    \n",
    "{value : width.precision f}\n",
    "\n",
    "value is the actuall floating point number or variable, width is the width you want the floating point to have (the amount of whitespace that is before it), and precision is the number of decimal places you want to pring. You need to put f, though, but without a space between it and precision."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pi is approximatley       3.14\n"
     ]
    }
   ],
   "source": [
    "pie = 22/7\n",
    "print('pi is approximatley {p:10.2f}'.format(p=pie))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists are ordered systems that can hold a variety of data types. They are outlined by curly braces, and it's values are called upon by indexing. They can also be spliced just like strings. One thing that makes them unique is that they are mutable, meaning they can be changed. They can even by Here is an example of their use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21 \n",
      "\n",
      "[21, 'b', 67.5] \n",
      "\n",
      "['a', 21, 'b', 67.5, 'c', 22, 'd', 78.6]\n"
     ]
    }
   ],
   "source": [
    "myList = ['a',21,'b',67.5]\n",
    "print(myList[1],'\\n')\n",
    "print(myList[1:],'\\n')\n",
    "myOtherList = ['c',22,'d',78.6]\n",
    "myConcatenatedList = myList + myOtherList\n",
    "print(myConcatenatedList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists also have built in functions, and here are the most important ones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 21, 'b', 67.5, 'c', 22, 'd', 78.6, 'this was appended'] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "myConcatenatedList.append('this was appended')\n",
    "print(myConcatenatedList,'\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 21, 'b', 67.5, 'c', 22, 'd', 78.6] \n",
      "\n",
      "a\n",
      "['a', 'c', 'd', 'e', 'f']\n"
     ]
    }
   ],
   "source": [
    "myConcatenatedList.pop()\n",
    "print(myConcatenatedList,'\\n')\n",
    "popped = myConcatenatedList.pop(0)\n",
    "print(popped)\n",
    "strList = ['a','d','c','f','e']\n",
    "strList.sort()\n",
    "print(strList)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "newlist = [1,2,3,4,5,6]\n",
    "newlist.reverse()\n",
    "print(newlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries are unordered mappings for storing objects. Dictionaries store objects using a key:value method. This allows you to grab values without having to find index locations Dictionaries use curly braces and colons to separate keys and values, like so:\n",
    "\n",
    "{\n",
    "'key1':'value1',\n",
    "'key2':'value2'\n",
    "}\n",
    "\n",
    "Dictionaries are preferable when you are dealing with large sets of data because they are easier to navigate, but lists are preferable if you need to do certain things that require order, like reverse, splice, and pop.\n",
    "\n",
    "You can put all data types inside dictionaries (even dictionaries!)\n",
    "Here are some examples of dictionaries in use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "joust \n",
      "\n",
      "joust \n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'UPPER'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myD = {\n",
    "    'bronze key':'joust',\n",
    "    'jade key':'whistle',\n",
    "    'crystal key':'guitar'\n",
    "}\n",
    "print(myD['bronze key'],'\\n')\n",
    "DD = {\n",
    "    '1' : myD,\n",
    "    '2' : [1,2,3],\n",
    "    '3' : 21.21,\n",
    "    '4' : ['upper']\n",
    "}\n",
    "print(DD['1']['bronze key'],'\\n')\n",
    "DD['4'][0]=DD['4'][0].upper()\n",
    "DD['4'][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are very similar to lists, except that they have parenthesis and are immutable. Just like lists, they can be indexed, spliced, and support multiple data types. There are 2 built in functions for tuples: index, and count. Index tells you the index of the first occurance of the thing that you put in the parenthesis, and count tells you how many of that thing there are. Now, you can see them in action:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 \n",
      "\n",
      "1 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "t = ('one',2,2,[3,4,5])\n",
    "print(t.count(2),'\\n')\n",
    "print(t.index(2),'\\n')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sets are unordered collection of unique elements, meaning that if the same element is put into the Set twice, the one occuring later will be omitted. This is very usefull if you want to have a list that does not repeat anything. \n",
    "\n",
    "To make a set, you just do this:\n",
    "\n",
    "variableName = set('element1','element2','element3')\n",
    "\n",
    "to add elements to a set, you would use the .add() function:\n",
    "\n",
    "variableName.add('element4')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "mylist = [1,2,3,2,3,2,3,3,1,1,1,4]\n",
    "myset = set(mylist)\n",
    "print(myset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Booleans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Booleans are operators that allow you to convey true or false statements from code. They are very useful for logic operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1>2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1==1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2+1==5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2*2==4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Writing text files with Jupyter notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is how to write a text file with jupyter notebook:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting myfirstfile.txt\n"
     ]
    }
   ],
   "source": [
    "%%writefile myfirstfile.txt\n",
    "\n",
    "Hello, this is a text file written with Jupyter notebooks, appearing live from the 9th cell in the Object & data structures notebook, on a beautifull, sunny friday afternoon\n",
    "this is the second line\n",
    "this is the third line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TO open the file, just do this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfirstfile = open('myfirstfile.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TO find where your jupyter notebook is, just do this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C:\\\\Users\\\\aadia\\\\OneDrive\\\\Python\\\\Udemy course python'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pwd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To return out the text in your text file, you can use .read(), though if you use it more than once, it will print out empty, becuase it starts reading where it ended, which was at the end because you already read it. if you want to reread it, you just use .seek(0) to reset it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nHello, this is a text file written with Jupyter notebooks, appearing live from the 9th cell in the Object & data structures notebook, on a beautifull, sunny friday afternoon\\nthis is the second line\\nthis is the third line\\n'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfirstfile.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfirstfile.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfirstfile.seek(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nHello, this is a text file written with Jupyter notebooks, appearing live from the 9th cell in the Object & data structures notebook, on a beautifull, sunny friday afternoon\\nthis is the second line\\nthis is the third line\\n'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfirstfile.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, you will want to make every line of the text file into an element in a list, to do that, you just use this simple method:\n",
    "\n",
    "first, you will want to seek back to zero. after that, you will want to use the .readlines() method, as shown:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfirstfile.seek(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['\\n', 'Hello, this is a text file written with Jupyter notebooks, appearing live from the 9th cell in the Object & data structures notebook, on a beautifull, sunny friday afternoon\\n', 'this is the second line\\n', 'this is the third line\\n']\n"
     ]
    }
   ],
   "source": [
    "File_List = myfirstfile.readlines()\n",
    "print(File_List)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you are done with your file reading, be sure to use the .close() method to avoid errors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfirstfile.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way to open files is the 'with' method. you do this:\n",
    "\n",
    "with open('myfirstfile.txt') as mySeccondFile:\n",
    "    \n",
    "    |\n",
    "    \n",
    "When you get here, you see that there is an indentation at the bottom. in here, we can assign variables with mySeccondFile, like making the variable contents equal to the contents of mySeccondFile:\n",
    "\n",
    "with open('myfirstfile.txt') as mySeccondFile:\n",
    "    \n",
    "    contents = mySeccondFile.read()\n",
    "    \n",
    "when you do this, you no longer need to close the file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('myfirstfile.txt') as mySeccondFile:\n",
    "    contents = mySeccondFile.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nHello, this is a text file written with Jupyter notebooks, appearing live from the 9th cell in the Object & data structures notebook, on a beautifull, sunny friday afternoon\\nthis is the second line\\nthis is the third line\\n'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "contents"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also write and overwrite files using python. to do this , you use the with open method:\n",
    "\n",
    "\n",
    "with open('myfirstfile.txt')\n",
    "\n",
    "\n",
    "then put a comma after the quotes\n",
    "\n",
    "\n",
    "with open('myfirstfile.txt',)\n",
    "\n",
    "\n",
    "after that, you will put your cursor in between the first parenthesis and the quote mark (i marked it with a backslash), and do shift+tab:\n",
    "\n",
    "\n",
    "with open(\\'myfirstfile.txt',)\n",
    "\n",
    "\n",
    "This will give you a pop up menu with a lot of useful information. you will find something that says mode='r'. this means that it is in read mode. if you make that into mode='w', then it will be in writing mode. copy that and paste it into the area after the comma, as shown below, change mode='r' to be mode = 'w' then use the 'as' thing.\n",
    "\n",
    "\n",
    "with open('myfirstfile.txt'mode='w') as writer:\n",
    "\n",
    "    |\n",
    "    \n",
    "    \n",
    "In case you want to know, here are the other modes:\n",
    "\n",
    "\n",
    " mode = 'a': this is to append, or add to a file at the end.\n",
    " \n",
    " mode = 'r': this is to read a file\n",
    " \n",
    " mode = 'w': this is to write on a file (overwrite, or make a new file)\n",
    " \n",
    " mode = 'r+': this is for reading and writing files\n",
    " \n",
    " mode = 'w+': this is for writing and reading files (overwrite, or make a new file)\n",
    "    \n",
    "    \n",
    "lets play around with them, shall we?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Abbot_Costello.txt\n"
     ]
    }
   ],
   "source": [
    "%%writefile Abbot_Costello.txt\n",
    "Who's on first\n",
    "What's on seccond\n",
    "I don't know's on third"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Who's on first\n",
      "What's on seccond\n",
      "I don't know's on third\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with open('Abbot_Costello.txt',mode='r') as r:\n",
    "    cont = r.read()\n",
    "    print(cont)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets add to this file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Who's on first\n",
      "What's on seccond\n",
      "I don't know's on third\n",
      "\n",
      "What's their names?\n"
     ]
    }
   ],
   "source": [
    "with open('Abbot_Costello.txt',mode='a') as r:\n",
    "    r.write(\"\\nWhat's their names?\")\n",
    "with open('Abbot_Costello.txt',mode='r') as r:\n",
    "    cont = r.read()\n",
    "    print(cont)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I think that's enough of reading and appending. Lets get into writing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('wutdafrickitidikitidong.txt',mode='w') as ri:\n",
    "    ri.write('To prove the power of flex tape, i cut a boat in half!\\n<===|  |====>\\nthen i put it together with flex tape and now it rides on the seas!\\n<======>\\n~~~~~~~~')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To prove the power of flex tape, i cut a boat in half!\n",
      "<===|  |====>\n",
      "then i put it together with flex tape and now it rides on the seas!\n",
      "<======>\n",
      "~~~~~~~~\n"
     ]
    }
   ],
   "source": [
    "with open('wutdafrickitidikitidong.txt',mode='r') as ri:\n",
    "    print(ri.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assesment test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Epic job!\n",
    "\n",
    "first try"
   ]
  },
  {
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}