2-String.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Working with Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of Content"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"margin-top: 20px\">\n",
    "    <ul>\n",
    "        <li><a href=\"#string\">String Definition</a>\n",
    "        <li><a href=\"#indecies\">Indecies and Slicing</a></li>\n",
    "        <li><a href=\"#concat\">String Concatenation</a></li>\n",
    "        <li><a href=\"#repetition\">String Repetition</a></li>\n",
    "        <li><a href=\"#Sfunction\">String Functions and Methods</a></li>\n",
    "        <li><a href=\"#Cmethod\">Chained Methods</a></li>\n",
    "        <li><a href=\"#inputF\">The Input Function</a></li> \n",
    "        <li><a href=\"#documentation\">Internal Documentation</a></li>         \n",
    "        <li><a href=\"#outputF\">Output</a></li>         \n",
    "        <li><a href=\"#lab\">Practice</a></li>\n",
    "            </ul>\n",
    "       \n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> String </h3>\n",
    "<a id = \"string\"> </a>\n",
    "\n",
    "<p> A string is a sequence of characters which can be created by using single ('') or double (\"\") quotes. Multi-line strings are defined by triple single (''') or triple double (\"\"\") quotes.</p>\n",
    "\n",
    "<p> The following code illustrates string data type examples. </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'This is String'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"This is String\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print('This is String')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type('This is String'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('''This\n",
    "is String''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(\"\"\"This\n",
    "is String\"\"\")"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> Indices and Slicing </h3>\n",
    "<a id = \"indecies\"> </a>\n",
    "\n",
    "<p> Each character position in the string is defined by an <b>index</b> - the number starting from 0, 1, 2, 3,.... In Python, the indexing starts from a 0 - index/position which identifies the first string character, while the second character has index 1, and so on. If the string value is assigned to the variable <i>s</i>, then <i>s[i]</i> is the character of the string having index <i>i</i>.   </p>\n",
    "\n",
    "<p> The following code illustrates string characters and its indexing. \n",
    "<br><b>Note: To se the below picture you would need string.png file in the same location with this jupyter notebook </b></p>\n",
    "\n",
    "![image.png](attachment:image.png)\n",
    "\n",
    "<p> A <b>substring</b> or <b>slice</b> is a part of the string with a sequence of consecutive characters. For example, the \"String\" is a substring from the above example with indices 0 through 5. In other words, if <i>s</i> is the string then, <b><i>s[m:n]</i></b> is a substring with <i>m</i> through <i>n-1</i> indices. Therefore, we can create any substring as long as we provide valid indices within the range of the main string. By creating a substring, we can say that we slice the string. In our previous example, \"String\" is a substring of \"String in Python\"[0:6] indices.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "print(\"String in Python\"[0:6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Python provides <b>find(subStr)</b> and <b>rfind(subStr)</b> methods to find the <i>subStr</i> first and last positive indices where the <i>subStr</i> starts respectively. If a <i>subStr</i> does not exist inside the string, then both methods return a -1 value.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'String in Python'\n",
    "print(s.find('t'))   # print the fisrt index of \"t\" apearence \n",
    "print(s.rfind('t'))  # print the latest index of \"t\" apearence"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> So far we've worked with positive indices that start from the left side. Python also allows for indices that start from the right side of the string. Right side indices are represented by negative numbers where the first right character has -1 index, and so on. Here is an example for better illustration:\n",
    "<br><b>Note: To se the below picture you would need stringr.png file in the same location with this jupyter notebook </b></p>\n",
    "\n",
    "![image.png](attachment:image.png)\n",
    "\n",
    "<p></p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'String in Python'\n",
    "print(s[-4: -1])\n",
    "print(s[-6])\n",
    "print(s[-9: -2]) \n",
    "print(s[-1: -4]) # not corect index seaquence\n",
    "print(s[-9: -7])\n",
    "\n",
    "print(\"----------------------------------------------------------\")\n",
    "# Deafault Bounds for Slices\n",
    "print(s[: -1])   # print substring from begining until -1 index\n",
    "print(s[ : ])    # print all string \n",
    "print(s[-9: ])   # print substring from -9 index to the end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> String Concatenation </h3>\n",
    "<a id = \"concat\"> </a>\n",
    "\n",
    "<p> Several strings can be combined together to form a new string. This process is called <b>concatenation</b> and is represented by the '+' sign.</p> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Today \" + \"is \" + \"a \" + \"great \" + \"day \" + \"to \" + \"code \" + \"in \" + \"Python!\"\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>The <b>String Expression</b> is the combination of strings, plus sign, functions, and methods that can be evaluated before it is assigned to a variable or printed to the screen.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = str(2) + \" + \" + str(2) + \" = \" + str(4)\n",
    "print(s1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> String Repetition </h3>\n",
    "<a id = \"repetition\"> </a>\n",
    "\n",
    "<p> The string can be concatenated with itself 'n' times by using a * - asterisk operator.</p> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(\"Today \"*4)\n",
    "print(\"Python-\"*3)\n",
    "print(\"x\"*10)\n",
    "print(\"cha-\"*2 + \"cha\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> String Functions and Methods </h3>\n",
    "<a id = \"Sfunction\"> </a>\n",
    "\n",
    "<p> The string function takes a string as input and returns a value in a similar way to a numeric function. A string method is a process that performs a task on a string. We have already seen how methods are working on the example of the <b>srt.find()</b> and <b>str.rfind()</b> methods above. The general pattern to apply methods is <i><b>stringName.methodName() </b></i>.</p> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example of String Methods\n",
    "s = \"Python\"\n",
    "\n",
    "# len() - return the number of characters in the string\n",
    "len(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# upper() - return string with all uper characters \n",
    "print(s.upper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lower() - return string with all lower characters \n",
    "print(s.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# count() - return the number of non-overlapping substring \n",
    "print(s.count(\"t\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# capitalize() - return the string with capitalized first letter and lowercases the rest \n",
    "print(\"PYThon\".capitalize())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# title() - return the string with capitalized first letter of each word and lowercases the rest \n",
    "print(\"PYThon cODE\".title())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lstrip() - remove spaces from the left side of the string\n",
    "\"     Python     \".lstrip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rstrip() - remove spaces from the right side of the string\n",
    "\"     Python     \".rstrip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# strip() - remove spaces from the left and right side of the string\n",
    "\"     Python     \".strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Other String Methods:\n",
    "# isalnum() Returns True if all characters in the string are alphanumeric\n",
    "# isalpha()\tReturns True if all characters in the string are in the alphabet\n",
    "# isdecimal()\tReturns True if all characters in the string are decimals\n",
    "# isdigit()\tReturns True if all characters in the string are digits\n",
    "# islower()\tReturns True if all characters in the string are lower case\n",
    "# isnumeric()\tReturns True if all characters in the string are numeric\n",
    "# isspace()\tReturns True if all characters in the string are whitespaces\n",
    "# istitle()\tReturns True if the string follows the rules of a title\n",
    "# isupper()\tReturns True if all characters in the string are upper case\n",
    "#\n",
    "# join()\tJoins the elements of an iterable to the end of the string\n",
    "# ljust()\tReturns a left justified version of the string\n",
    "# rjust()\tReturns a right justified version of the string\n",
    "#\n",
    "# replace()\tReturns a string where a specified value is replaced with a specified value\n",
    "# rsplit()\tSplits the string at the specified separator, and returns a list\n",
    "# split()\tSplits the string at the specified separator, and returns a list\n",
    "# splitlines()\tSplits the string at line breaks and returns a list\n",
    "# swapcase()\tSwaps cases, lower case becomes upper case and vice versa\n",
    "# zfill()\tFills the string with a specified number of 0 values at the beginning\n",
    "#\n",
    "\n",
    "\n",
    "print(s.count(\"t\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> Chained Methods </h3>\n",
    "<a id = \"Cmethod\"> </a>\n",
    "\n",
    "<p> Consider the following code: </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Good Morning\".upper()\n",
    "numOfO = s.count(\"O\")  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> These two lines of code can be replaced by a single line of code through the <b>chain</b> of the two methods.</p> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numOfO = \"Good Morning\".upper().count(\"O\")\n",
    "numOfO"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> The chained methods are executed from left to right and provide a clear code while eliminating unnecessary variables. </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> The Input Function</h3>\n",
    "<a id = \"inputF\"> </a>\n",
    "\n",
    "<p> The input function prompts the user to enter data and it has the general form: </p>\n",
    "<p> <b> variableName = input(prompt) </b></p>\n",
    "<p> where the <i>prompt</i> is a string that requires a response from the user.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "language = input(\"Enter your programming language: \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "age = input(\"Enter your age: \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> When Python executes the input function, the strings \"Enter your programming language: \" and \"Enter your age: \" are displayed first and then the program pauses for user input. After the user enters the language and age and presses the <i>Enter</i> key, the variable language and age are assigned appropriate values.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(language)\n",
    "print(type(language))\n",
    "\n",
    "print(age)\n",
    "print(type(age))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> The input function takes the user's input and stores these values in the string data type. Therefore, if you need a numeric value from your input function for further calculations, we would need to <b>cast</b> the input data into the right data type using the <i>int, float,</i> and <i>eval</i> functions.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# More String Functions\n",
    "print(int(\"25\"))               # convert string \"25\" to integer values\n",
    "print(float(\"25\"))             # convert string \"25\" to float values\n",
    "print(eval(\"25\"))              # evaluate string \"25\" and convert to integer values\n",
    "print(eval(\"25.0\"))            # evaluate string \"25.0\" and convert to float values\n",
    "print(eval(\"25 + 3*5.0\"))      # evaluate string expression and determied the right data type (float)\n",
    "print(str(5) + \" is string\")   # convert int values to string \n",
    "print(str(5.0) + \" is string\") # convert float values to string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> Internal Documentation</h3>\n",
    "<a id = \"documentation\"> </a>\n",
    "\n",
    "<p> The best programming practice is to provide internal code documentation through comments for variables, functions and other tasks that provide clarification of the code. To create comments, we need to start a new line with the number sign (#) or use (#) after the expression like you saw above.</p>\n",
    "\n",
    "<p>Using internal documentation provides the following benefits:</p>\n",
    "<ol>\n",
    "    <li> Other users can understand the code and its functionality </li>\n",
    "    <li> Provides documentation for yourself when you read it later </li>\n",
    "    <li> Long programs are easier to read and understand </li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> Output</h3>\n",
    "<a id = \"outputF\"> </a>\n",
    "\n",
    "<h4> sep and end Arguments</h4>\n",
    "<p> We have seen how the <b>print()</b> function outputs values on the screen. The <b>print()</b> function can further enhance output functionality with two optional arguments (<b>sep</b> and <b>end</b>) and the <b>format</b> method. </p>\n",
    "\n",
    "<p> When you try to print several values by the <b>print()</b> function, it uses a space as the separator among those values.</p> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1,2,3,4,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> We can change the default separator to any string we'd like by setting the <b>sep = 'sepString'</b> argument.</p> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1,2,3,4,5, sep = \"***\" )\n",
    "print(1,2,3,4,5, sep = \"-\" )\n",
    "print(1,2,3,4,5, sep = \"\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> At the end of the <b>print()</b> function execution, it will execute a newline operation so the next <b>print()</b> function will display values on the next line. We can modify this ending behaviour with the <b>end = 'endString'</b> argument.</p> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello\", end = \"***\" )\n",
    "print(\"World!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello\", end = \"\" )\n",
    "print(\"World!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello\", end = \"-\" )\n",
    "print(\"World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4> Justifying Output in a Field</h4>\n",
    "<p> When your program needs to display data in a table format with columns of fixed width, then the <b>ljust(n), rjust(n), </b> and <b>center(n) </b> methods are helpful to left-justify, right-justify and center string output in a field of n characters. If the displayed string is longer than the field width, then the justification method is ignored. </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Example of justification methods\n",
    "print(\"---------------------------------\")\n",
    "print(\"Rank\".ljust(8), \"Car Name\".ljust(20), \"Score\".rjust(5), sep=\"\")\n",
    "print(\"1\".center(8), \"BMW\".ljust(20), \"98\".rjust(5), sep=\"\")\n",
    "print(\"2\".center(8), \"Audi\".ljust(20), \"95\".rjust(5), sep=\"\")\n",
    "print(\"3\".center(8), \"Mercedes\".ljust(20), \"90\".rjust(5), sep=\"\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h4> Justifying Output with <i>format</i> Method</h4>\n",
    "<p> The <b>format</b> method is a new Python addition that can perform the same functionality as the justification (<b>ljust(n), rjust(n), </b> and <b>center(n)</b>) method and much more. The <b>ljust(n), rjust(n), </b> and <b>center(n)</b> are represented as <b> < </b>, <b> > </b> , and <b> ^ </b> in the format method respectively. We are going to demonstrate such functionality below.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Format Method working with string, int and float data types  \n",
    "print(\"---------------------------------\")\n",
    "print(\"{0:<8s}{1:<20s}{2:>5s}\".format(\"Rank\", \"Car Name\", \"Score\"))\n",
    "print(\"{0:^8n}{1:<20s}{2:>2.2f}\".format(1, \"BMW\", 98.0))\n",
    "print(\"{0:^8n}{1:<20s}{2:>2.2f}\".format(2, \"Audi\", 95.0))\n",
    "print(\"{0:^8n}{1:<20s}{2:>2.2f}\".format(3, \"Mercedes\", 90))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Additional number formatting   \n",
    "print(\"{0:<10d}\".format(123456789))              # integer number\n",
    "print(\"{0:<10,d}\".format(123456789))             # with thousands separator\n",
    "print(\"{0:<10.2f}\".format(12345.6789))           # rounded to 2 decimal points \n",
    "print(\"{0:<10,.2f}\".format(12345.6789))          # rounded with added separator\n",
    "print(\"{0:<10.2%}\".format(0.123456789))          # rounded with % added\n",
    "print(\"{0:<10,.3%}\".format(12.3456789))          # rounded with % and separator added"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> Practice</h3>\n",
    "<a id =\"lab\"> </a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q1) Determine the value of the expressions: </p>\n",
    "\n",
    "<p>\"Python\"[4] </p>\n",
    "<p>\"Python\"[-3]</p>\n",
    "<p>\"Python\"[0:3]</p>\n",
    "<p>\"Python\"[:2]</p>\n",
    "<p>\"Python\"[-3:-2]</p>\n",
    "<p>\"Python\"[2:-2]</p>\n",
    "<p>\"Python\"[:]</p>\n",
    "<p>\"Python\".find(\"tho\")</p>\n",
    "<p>\"Python\".find(\"t\")</p>\n",
    "<p>\"whippersnapper\".rfind(\"pp\")</p>\n",
    "<p>\"Mississippi\".find(\"ss\")</p>\n",
    "<p>\"Python\".count(\"s\")</p>\n",
    "<p>\"Python\".upper()</p>\n",
    "<p>\"Python\".lower()</p>\n",
    "<p>len(\"Python\")</p>\n",
    "<p>\"Python\"[3:len(\"Python\")]</p>\n",
    "<p>\"let it go\".title().find(\"G\")</p>\n",
    "<p>\"Amazon\".lower().count(\"a\")</p>\n",
    "<p>\"king kONG\".title()</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q2) Determine output: </p>\n",
    "<p> m = 4 </p>\n",
    "<p> n = 3 </p>\n",
    "<p> s = \"Microsoft\" </p>\n",
    "<p> t = \"soft\" </p>\n",
    "<p> print(len(s))</p>\n",
    "<p> print(s.lower())</p>\n",
    "<p> print(s[m:m+2])</p>\n",
    "<p> print(s.find(t))</p>\n",
    "\n",
    "<p> print(\"Your age is \" + str(21) + \".\")</p>\n",
    "<p> print(\"Fred has \" + str(3) + \"children.\")</p>\n",
    "<p> print(\"F\" + (\"m\" * 6) + \".\")</p>\n",
    "<p> print(\"a\" + (\" \" * 5) + \"b\")</p>\n",
    "<p> print(\"spam\" * 5)</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q3) Determine output: </p>\n",
    "\n",
    "<p>r = \"A ROSE\" </p>\n",
    "<p>b = \" IS \" </p>\n",
    "<p>print(r + b + r + b + r) </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q4) Determine output: </p>\n",
    "\n",
    "<p>var = \"A ROSE\" </p>\n",
    "<p> var += var </p>\n",
    "<p>print(var) </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q5) Determine output: </p>\n",
    "\n",
    "<p>var = \"good\" </p>\n",
    "<p> var += \"bye\" </p>\n",
    "<p>print(var) </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q6) Determine output: </p>\n",
    "\n",
    "<p>num = input(\"Enter the integer: \") </p>\n",
    "<p>print(\"1\" + str(num)) </p>\n",
    "<p><i>(Assume the response is 8.)</i></p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q7) Determine output: </p>\n",
    "\n",
    "<p>num = int(input(\"Enter the integer: \")) </p>\n",
    "<p>print(1 + num) </p>\n",
    "<p><i>(Assume the response is 8.)</i></p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q8) Determine output: </p>\n",
    "\n",
    "<p>num = float(input(\"Enter the number: \")) </p>\n",
    "<p>print(1 + num) </p>\n",
    "<p><i>(Assume the response is 8.)</i></p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q9) Determine output: </p>\n",
    "\n",
    "<p>num = eval(input(\"Enter the number: \")) </p>\n",
    "<p>print(1 + num) </p>\n",
    "<p><i>(Assume the response is 8.)</i></p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q10) Find and correct all errors: </p>\n",
    "\n",
    "<p>phoneNumber = 234-5678</p>\n",
    "<p>print(\"My phone number is \" + phoneNumber) </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q11) Find and correct all errors: </p>\n",
    "\n",
    "<p>quote = I came to Casablanca for the waters.</p>\n",
    "<p>print(quote + \": \"Bogart\") </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q12) Find and correct all errors: </p>\n",
    "\n",
    "<p>for = \"happily ever after\"</p>\n",
    "<p>print(\"They lived \" + for) </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q13) Find and correct all errors: </p>\n",
    "\n",
    "<p>age = input(\"Enter your age: \")</p>\n",
    "<p>print(\"Next year you will be \" + (age + 1)) </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q14) Find and correct all errors: </p>\n",
    "\n",
    "<p>age = 19</p>\n",
    "<p>print(\"Age \" + age) </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q15) Find and correct all errors: </p>\n",
    "\n",
    "<p> num = 1234</p>\n",
    "<p>print(num[3]) </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q16) Find and correct all errors: </p>\n",
    "\n",
    "<p> num = 1234</p>\n",
    "<p>print(num.find(2)) </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q17) Find and correct all errors: </p>\n",
    "\n",
    "<p> num = 45</p>\n",
    "<p>print(len(num)) </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q18) Find and correct all errors: </p>\n",
    "\n",
    "<p> language = \"Python\"</p>\n",
    "<p>print(language[8]) </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q19) Find and correct all errors: </p>\n",
    "\n",
    "<p> show = \"Spamalot\"</p>\n",
    "<p>print(show[9]) </p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q20) Determine output: </p>\n",
    "\n",
    "<p> print(\"Py\", \"th\", \"on\", sep=\"\")</p>\n",
    "<p> print(1, 2, 3, sep=\"x\") </p>\n",
    "<p> print(\"tic\", \"tac\", \"toe\", sep=\"-\")</p>\n",
    "<p> print(\"one\", \"two\", \"three\", sep=\",\")</p>\n",
    "<p> print(\"Hello\\n\") print(\"World\")</p>\n",
    "<p> print(\"One\\tTwo\\tThree\\tFour\")</p>\n",
    "<p> print(\"1\\t2\\t3\\t4\")</p>\n",
    "<p> print(\"Hello\\nWorld\")</p>\n",
    "<p> print(\"Hello\\nWorld\".expandtabs(16))</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q21) Determine output: </p>\n",
    "\n",
    "<p> print(\"01234567890\")</p>\n",
    "<p> print(\"A\".rjust(5), \"B\".center(5), \"C\".ljust(5), sep=\"\")</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> Q22) Determine output: </p>\n",
    "\n",
    "<p> print(\"01234567890123456\")</p>\n",
    "<p> print(\"{0:>5s}{1:^5s}{2:5s}\".format(\"A\",\"B\", \"C\"))</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "%%markdown\n",
    "<p> Q23) Determine output: </p>\n",
    "<p>print(\"0123456789\")</p>\n",
    "<p>print(\"{0:10.2%}\".format(0.123))</p>\n",
    "<p>print(\"{0:^10.1%}\".format(1.23))</p>\n",
    "<p>print(\"{0:<10,.2%}\".format(12.3))</p>b\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "%%markdown\n",
    "<p> Q24) Determine output: </p>\n",
    "<p>print(\"0123456789\")</p>\n",
    "<p>print(\"{0:10,d}\".format(1234))</p>\n",
    "<p>print(\"{0:^10,d}\".format(1234))</p>\n",
    "<p>print(\"{0:<10,d}\".format(1234))</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "<p> Q25) Determine output: </p>\n",
    "\n",
    "<p> print(\"${0:,.2f}\".format(1234.567))</p>\n",
    "<p> print(\"{0:,.0f}\".format(1234.567))</p>\n",
    "<p> print(\"{0:,.0f}\".format(1.234567))</p>\n",
    "<p> print(\"${0:,.2f}\".format(1234567))</p>\n",
    "\n",
    "<p> print(\"{0:10s}{1:^16,d}{2:10.2%}\".format(\"Spanish\",38700000000, 0.0585))</p>"
   ]
  },
  {
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}