3 Working_with_strings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Working with strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings, as has been explained, consists of sequences of characters. They can be created using single, double and triple quotes. The single and the double quotes are used most commonly. Once created, such strings can be examined and manipulated in a number of ways. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Number of characters\n",
    "\n",
    "To get information about the number of characters in a string, you can make use of the `len()` function. The characters 'len' stand for 'length'. When you work with `len()`, the spaces in strings are also counted as characters. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "title = \"The Hitchhiker's Guide to the Galaxy\"\n",
    "nr_characters = len(title)\n",
    "print( f'The title consists of {nr_characters} charaters.' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that a string can also be empty. In that situation, the length of the string is zero. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_string = ''\n",
    "print(len(empty_string))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Methods for strings\n",
    "\n",
    "`len()` is an example of a function, a chunk of code that can be reused. A function always has a name, which can be used to request the actions that can be carried out via function. Functions such as `len()` can generally be applied to a wide range of variable types. \n",
    "\n",
    "\n",
    "A method is very similar to a function. An important difference, however, is that a method can only be run on very specific variable types. A number of methods have been developed specifically for strings, for example. While functions can be used independently, methods are always associated with a specific type of variable. We can call a method by appending the name of the method to the name of the variable. The variable and the method must be delimited by a period. The differences between methods and functions will be explained in more detail in another part of this tutorial. \n",
    "\n",
    "The following methods are available for string objects:\n",
    "\n",
    "<table width=\"80%; \" style=\"font-size: 1.0em; text-align: left; \">\n",
    "      <tr style=\"font-size: 1.0em; text-align: left; \">\n",
    "          <td  width=\"15%\" style=\"text-align: center;\"><b>Method name</b></td><td ><b>Description</b></td>\n",
    "    </tr>\n",
    "    <tr style=\"font-size: 1.0em; text-align: left; \">\n",
    "        <td width=\"15%\" style=\"text-align: center;\">lower()</td><td  style=\"text-align: left; \">Converts all the characters of the string into lower case.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td width=\"15%\" style=\"text-align: center;\">upper()</td><td  style=\"text-align: left; \">Converts all the characters of the string into lower case.</td>\n",
    "    </tr>\n",
    "       <tr>\n",
    "        <td  width=\"15%\" style=\"text-align: center;\">replace()</td><td  style=\"text-align: left; \">Replaces a substring with a new set of characters.</td>\n",
    "    </tr>\n",
    "     <tr>\n",
    "        <td  width=\"15%\" style=\"text-align: center;\">strip()</td><td  style=\"text-align: left; \">Removes all white space (such as spaces, hard returns or tabs) from the beginning and the end of a string.</td>\n",
    "    </tr>\n",
    "</table>    \n",
    "\n",
    "\n",
    "The code below gives a demonstration of some of these mehods and functions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "title = \"   The Hitchhiker's Guide to the Galaxy   \"\n",
    "\n",
    "title = title.strip()\n",
    "#this removes the spaces before and after the original string\n",
    "print( f'-{title}-')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( title.lower() )\n",
    "## This prints 'the hitchhiker's guide to the galaxy'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print( title.upper() )\n",
    "## This prints 'THE HITCHHIKER'S GUIDE TO THE GALAXY'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Th method `replace()` takes two parameters. You firstly need to mention the substring you want to replace. A substring is a sequence of characters contained within the original string. Secondly, you need to specify the substring that you want to replace it with. The old and the new substring do not need to have the same number of characters. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "title = 'Paradise Lost'\n",
    "new_title = title.replace('Lost' , 'Regained')\n",
    "print(new_title)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3.1.\n",
    "\n",
    "Create a variable and assign it your full name as a string. Next, print the number of characters in your name, excluding the space. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Selecting individual characters of a string\n",
    "\n",
    "When you create a string, it is useful to bear in mind that all the inividual characters that make up the string are numbered behind the scenes. These numbers are referred to as indices. The first character is given the index 0. Individual characters can be accessed by appending a set of square brackets to the name of the string variable, and by supplying the index of the character you want to access within these brackets. Using these indices, it becomes possible to extract specific characters from variables. When you use negative numbers (e.g. -1 or -2), Python starts selecting characters at the end of the string and moves back."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'Albert Einstein'\n",
    "\n",
    "print( name[0] )\n",
    "## This prints 'A'\n",
    "\n",
    "print( name[5] )\n",
    "## This prints 't'\n",
    "\n",
    "print ( name[-1] )\n",
    "## This prints 'n'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also extract a range of characters from a given string by mentioning the start position and the end position of the substring you want to create within a set of square brackets. The two indices must be separated by a colon. Strings such as these, which are created by extracting a substring from a longer string, are referred to as ‘slices’."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "title = 'Romeo and Juliet'\n",
    "\n",
    "print( title[0:5] )\n",
    "# this prints 'Romeo'\n",
    "\n",
    "print( title[10:16])\n",
    "# this prints 'Juliet'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you leave out the number to the left of the column, Python will assume that the slicing operation needs to start at the beginning of the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "title = 'Antony and Cleopatra'\n",
    "\n",
    "print( title[:6] )\n",
    "# this prints 'Antony'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If no number is provided to the right of the colon, Python will select all characters until it reaches the end of the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "title = 'King John'\n",
    "\n",
    "print( title[-4:] )\n",
    "# This prints 'John'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3.2.\n",
    "\n",
    "Create two string variables. The first variable must be assigned the value 'unique' and the second variable should be assigned the value 'biodiversity'. Create a third variable with the value 'university', by firstly slicing the first two string variables, and by subsequently concatenating the substrings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "variable1 = 'unique'\n",
    "variable2 = 'biodiversity'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3.3.\n",
    "\n",
    "Create the following two string variables:\n",
    "\n",
    "```\n",
    "first = 'vladimir'\n",
    "last = 'nabokov'\n",
    "```\n",
    "\n",
    "Using these two existing variables, create a third variable named ‘fullName’ with the following value: “Nabokov, Vladimir”. Note that the first character of the first name and the last name must be in upper case. Also try to print the initials of the author in upper case, as follows: ‘VN’"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The index() method \n",
    "\n",
    "The method 'index()' can help you to find the index of a given character. This method can be used productively in string slices.\n",
    "\n",
    "The method firstly determines whether a string contains a given substring. If it does, the method returns a number indicating the starting position (i.e. the index) of this substring. The function always returns the index of the first occurrence of the substring. If the string does not contain the substring that is mentioned as a parameter, the method produces an error message."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "email = 'person@test.com'\n",
    "\n",
    "at_index = email.index('@')\n",
    "print(at_index)\n",
    "## at_index has been assigned value 6\n",
    "\n",
    "user_name = email[0:at_index]\n",
    "print(user_name)\n",
    "\n",
    "#at_index = email.index('#')\n",
    "## This line will produce an error message: 'substring not found'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have found the exact index (i.e. the position) of the character you are searching for, you can use it in a string slice, as follows. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "email = 'person@test.com'\n",
    "\n",
    "position_at = email.index('@')\n",
    "\n",
    "username = email[ 0 : position_at ]\n",
    "print(username)\n",
    "## prints 'person'\n",
    "\n",
    "domain = email[ position_at + 1 : len(email) ]\n",
    "print(domain)\n",
    "## prints 'test.com'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3.4.\n",
    "\n",
    "Create a variable named `url` and assign it following string: `https://www.universiteitleiden.nl`.\n",
    "\n",
    "Try to write code which can extract the top level domain (i.e. the country code) from this url.\n",
    "Tip: this problem can be solved by creating a string slice with the last two characters only, but top domain levels may of course consists of more than two characters. An alternative approach is to make use of the `rindex()` function, which returns the LAST occurrence of a character. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "url = 'https://www.universiteitleiden.nl'"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}