A Beginners Guide to Python/_12. Strings & Methods.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strings & Methods\n",
    "\n",
    "In this lecture we are going to be looking at *methods*. To simplify, a method is a function that is bound to a particular type of object. String methods, for example, are functions that only work on strings. List methods meanwhile, are a set of functions that only work on lists. And so and so on. If you read the OOP lecture this should make sense to you already. \n",
    "\n",
    "To call these methods, I have to introduce you to a new syntax:                    \n",
    "\n",
    "        Syntax:\n",
    "        {Object}.{method name}({arguments, if any})\n",
    "\n",
    "The syntax above is called ‘dot notation’ and this is one of the main ways we can call an objects method. \n",
    "\n",
    "Let’s look at an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HELLO\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "descriptor 'upper' of 'str' object needs an argument",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-5f8995cc3436>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"hello\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m    \u001b[0;31m# returns an error, upper needs an argument\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: descriptor 'upper' of 'str' object needs an argument"
     ]
    }
   ],
   "source": [
    "print(\"hello\".upper())\n",
    "print(str.upper())    # returns an error, upper needs an argument"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So the method 'upper' capitalises a string; \"hi\" becomes \"HI\".\n",
    "\n",
    "Now, remember in the *'Calling Functions'* lecture I talking about functions that take zero arguments? Well, at first glance it might look like upper() takes zero arguments, but actually this isn’t true, object methods *take themselves* as an argument.\n",
    "\n",
    "So:\n",
    "\n",
    "    “hello”.upper()   ---> \"HELLO\"\n",
    "\n",
    "Would look like this (if expressed as a function):\n",
    "\n",
    "    upper(“hello”)   ---> \"HELLO\"\n",
    "\n",
    "The syntax is a bit different, but semantically these two things are more of less the same.\n",
    "\n",
    "Anyway, what happens if we call upper on a float?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens if we call upper on a float?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "num = 3.4\n",
    "print(num.upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We get an error when we try to call upper on a float and understanding why is super simple: string methods are for strings! And the reason float objects do not have an upper method defined is simply because that method makes no sense when applied to numbers. \n",
    "\n",
    "In the remainder of this lecture I’m going to cover some of the more useful string methods. \n",
    "\n",
    "## Isdigit method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(\"Hello\".isdigit())\n",
    "print(\"99\".isdigit())\n",
    "print(\"103.2\".isdigit())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the above three lines you can probably get a good idea what the \"isdigit\" method is doing; This method checks checks to see if each character in the string is a digit or not. If every single character is a digit the method returns True, false otherwise *(note that just because string methods take strings as input DOES NOT mean they must output strings as well).* \n",
    "\n",
    "## Count Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(\"nananananananaBATMAN\".count(\"A\")) # Note count is case sensitive.\n",
    "print(\"nananananananaBATMAN\".count(\"BATMAN\"))\n",
    "print(\"nananananananaBATMAN\".count(\"ROBIN\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The count method shown above can be pretty useful, it takes two arguments and returns the total number of times the second string appears in the first. Do note that it is case-sensitive and it looks for an EXACT match. For example:\n",
    "\n",
    "    \"abc\".count(\"ab\") --> 1\n",
    "    \"acb\".count(\"ab\") --> 0\n",
    "\n",
    "In short, count is looking for instances of the whole pattern and NOT how many times a and b appear individually. \n",
    "\n",
    "## Replace method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "text = input(\"feed me characters...FEED ME NOW GRRRR!!!  \")\n",
    "#print(\"[You hear digusting chewing sounds from afar...]\")\n",
    "replace_this = input(\"Now give me a single character to change in the text \")\n",
    "replace_with = input(\"What should we change that character to ? \")\n",
    "\n",
    "print(text.replace(replace_this, replace_with))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    \"aa\".replace(\"aa\", \"b\")  ---> 'b'\n",
    "    \"aa\".replace(\"a\", \"b\")   ---> 'bb'\n",
    "    \"aa\".replace(\"c\", \"b\")   ---> 'aa'\n",
    "\n",
    "## Getting side-tracked with Style\n",
    "\n",
    "Now these variables names are pretty good overall, but readability isn't just about having good function names, its also about creating names that ‘fit’ together, that is, a naming structure consistent through-out the code. \n",
    "After a little bit of thought I came up with a much better name than \"old_sequence\", I swapped it to \"replace_this\". This new name is not any better in and of itself, but when we juxtapose it alongside \"replace_with\" it is obviously a more elegant name. \n",
    "\n",
    "* replace_this\n",
    "* replace_with\n",
    "\n",
    "The main insight is swapping is using a name convention across multiple variable names; ‘old_sequence’ although a perfectly reasonable description doesn’t show the reader that the this two variables are related to one another. The result of changing to a more consistent name is having a line of code could *almost pass* for normal English.\n",
    "\n",
    "    text.replace(replace_this, replace_with)\n",
    "                    vs. \n",
    "    text.replace(old_sequence, replace_with)\n",
    "\n",
    "In the grand scheme of things we are making tiny little changes here, but this tiny little change makes my code more beautiful, more elegant, and above all, more readable. \n",
    "\n",
    "Hopefully this weeks homework (#2) will make these concepts more clear to you. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Format\n",
    "\n",
    "If you read my code snippets you will see me use format a lot. At heart, format is a way to create strings with moving parts inside them. \n",
    "\n",
    "For example, if I want to greet the user I probably want some code that returns “hello, {user’s name)”. \n",
    "We can do this with concatenation of course, like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi, chris\n"
     ]
    }
   ],
   "source": [
    "name = \"chris\"\n",
    "greeting = \"hi, \" + name\n",
    "\n",
    "print(greeting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, concatenation can become a little cumbersome when we start trying to create strings with several moving parts and/or with different data-types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi, chris your age is 29 and you have 203 wombat's. wow, thats a lot of wombat's\n"
     ]
    }
   ],
   "source": [
    "name = \"chris\"\n",
    "age = 29\n",
    "no_of_pets = 203\n",
    "pet = \"wombat\"\n",
    "\n",
    "s = \"Hi, \" + name + \" your age is \" + str(age) + \" and you have \" + str(no_of_pets) + \" \" + pet + \"'s. Wow, thats a lot of \" + pet + \"'s\"\n",
    "\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I think you will all agree that the string s is getting bloody clunky right now. Its so large now that we have to scroll sideways just to see the end of it. \n",
    "\n",
    "Format to the rescue!\n",
    "\n",
    "\tThe Syntax\n",
    "\t“I have {x} cats and {y}{z}”.format (x, y, z)\n",
    "\n",
    "Normally when I write syntax I use {} for my own commentary, but on this occasion you need to be aware {} is literally what you type in. \n",
    "\n",
    "Python will then replace the {} with a value, which happens to the value you give as an argument to format. So format(x) will insert data at position {x}. Maybe this is easier understood with actual examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I have 2 cats and 3 dogs\n"
     ]
    }
   ],
   "source": [
    "s = \"I have {} cats and {} {}.\".format(2, 3, \"dogs\")\n",
    "\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So as you can hopefully see the first {} is replaced with the number 2, and then the second {} is replaced with 3 and so on. Also note that the format method automatically converts the numbers to strings so we don't have to even type out str(2). \n",
    "\n",
    "Alright, lets see if we can simplify that string rambling about my 203 wombats..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi, chris your age is 29 and you have 203 wombat's. Wow, thats a lot of wombat's\n"
     ]
    }
   ],
   "source": [
    "name = \"chris\"\n",
    "age = 29\n",
    "no_of_pets = 203\n",
    "pet = \"wombat\"\n",
    "\n",
    "s = \"Hi, {} your age is {} and you have {} {}'s. Wow, thats a lot of {}'s.\".format(name, age, no_of_pets, pet, pet)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Homework Assignment #1\n",
    "\n",
    "Your first homework assignment for this week is to take the variable named \"text\" (this has been defined for you)  and count the number of times \"z\" occurs AND the letter \"k\" occurs. Add those numbers up and print the result.\n",
    "\n",
    "As a further complication,  we **DO NOT** care about case (e.g. ‘z’ and ‘Z’ should both be included in the count).\n",
    "\n",
    "Don’t feel bad if you struggle, this homework is a step up in difficulty compared to normal. Oh and I have also included a few test cases below that should help you figure out what do to (just in case my instructions were not clear enough).\n",
    "\n",
    "For bonus difficulty, make your code work for any letter (e.g. \"a\", \"b\" returns the count of 'a' + 'A' + 'b' + 'B')."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "text = \"zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzZZZZeeeewwwwwwwwkKewewe2324____23!!!!!fsdffskdsdzzzzZZZZZZZZZZZZZZZZroiooioi\"\n",
    "\n",
    "# Simple Examples (string --> total you should return)\n",
    "# \"zZ\"       --> 2\n",
    "# \"kK\"       --> 2\n",
    "# \"KZ\"       --> 2\n",
    "# \"1aZZZabc\" --> 3\n",
    "# \"hello\"    --> 0\n",
    "# \"ZzKk\"     --> 4\n",
    "\n",
    "\n",
    "# Your code goes here..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Homework Assignment #2\n",
    "\n",
    "You working on a program that has a greeting message and a goodbye message for several languages. Your job is to simply make the code more elegant and readable. Do what ever you think needs doing (note, there isn't really a right/wrong awnser). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Make this more readable...\n",
    "\n",
    "bye_spain = \"buenas noches\"\n",
    "english_greeting = \"hello\"\n",
    "english_goodbye = \"sod off, lad\"\n",
    "greeting_japanese = \"konichiwa\"\n",
    "spanish_greeting = \"hola\"\n",
    "hello_in_french = \"bonjour\"\n",
    "japanese_bye = \"sayonara\""
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}