Tutorial_10_Strings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strings\n",
    "\n",
    "This notebook demonstrates some basic string commands."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Packages and Extra Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Printf\n",
    "\n",
    "include(\"src/printmat.jl\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# String Basics\n",
    "\n",
    "The next few cells show how to\n",
    "\n",
    "1. combine several strings\n",
    "\n",
    "2. test if a string contains a specific substring\n",
    "\n",
    "3. replace part of a string with something else\n",
    "\n",
    "4. split a string into a vector of words (and then to join them back into a single string again)\n",
    "\n",
    "5. sort a vector of words in alphabetical order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n",
      "Where are you?\n"
     ]
    }
   ],
   "source": [
    "str1 = \"Hello\"\n",
    "str2 = \"world!\\n\"\n",
    "str3 = \"Where are you?\"\n",
    "\n",
    "str3b = string(str1,\" \",str2,str3)          #combine into one string\n",
    "println(str3b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Highway 62 Revisited\n",
      "\u001b[34m\u001b[1mcontains the word Highway\u001b[22m\u001b[39m\n",
      "\n",
      "\u001b[34m\u001b[1mNew, better string after a replacement: \u001b[22m\u001b[39m\n",
      "Highway 61 Revisited\n"
     ]
    }
   ],
   "source": [
    "str4 = \"Highway 62 Revisited\"\n",
    "\n",
    "if occursin(\"Highway\",str4)                      #test if the string contains a substring\n",
    "    println(str4)\n",
    "    printblue(\"contains the word Highway\")\n",
    "end\n",
    "\n",
    "str4 = replace(str4,\"62\" => \"61\")                #replace part of a string\n",
    "printblue(\"\\nNew, better string after a replacement: \")\n",
    "println(str4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1msplit a string into a vector of words:\u001b[22m\u001b[39m\n",
      "   Highway\n",
      "        61\n",
      " Revisited\n",
      "\n",
      "\n",
      "\u001b[34m\u001b[1mand join the words into a single string:\u001b[22m\u001b[39m\n",
      "Highway 61 Revisited\n"
     ]
    }
   ],
   "source": [
    "words = split(str4)\n",
    "printblue(\"split a string into a vector of words:\")\n",
    "printmat(words)\n",
    "\n",
    "printblue(\"\\nand join the words into a single string:\")\n",
    "println(join(words,\" \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1msort the words alphabetically:\u001b[22m\u001b[39m\n",
      "        61\n",
      "   Highway\n",
      " Revisited\n",
      "\n"
     ]
    }
   ],
   "source": [
    "printblue(\"sort the words alphabetically:\")\n",
    "printmat(sort(words))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reading an Entire  File as a String\n",
    "\n",
    "The next cell reads a file into one single string. It keeps the formatting (spaces, line breaks etc). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Dogs are nicer\\nthan cats.\\n          \\n      This\\n      is a\\nfairly short file.\""
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "txtFile = \"Data/FileWithText.txt\"\n",
    "\n",
    "str = read(txtFile,String)       #read as string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1mtesting if str is a String: \u001b[22m\u001b[39m\n",
      "true\n",
      "\n",
      "Dogs are nicer\n",
      "than cats.\n",
      "          \n",
      "      This\n",
      "      is a\n",
      "fairly short file.\n"
     ]
    }
   ],
   "source": [
    "printblue(\"testing if str is a String: \")   #test if a String \n",
    "println(isa(str,String),\"\\n\")\n",
    "\n",
    "println(str)                #printing the string read from a file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reading all Lines of a File into a Vector of Strings\n",
    "\n",
    "The next cell reads a file into a vector of strings: one string per line of the file. The second cell joins those lines into one string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dogs are nicer\n",
      "than cats.\n",
      "          \n",
      "      This\n",
      "      is a\n",
      "fairly short file.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "lines = readlines(txtFile)\n",
    "\n",
    "printmat(lines)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dogs are nicer\n",
      "than cats.\n",
      "          \n",
      "      This\n",
      "      is a\n",
      "fairly short file.\n"
     ]
    }
   ],
   "source": [
    "linesJoined = join(lines,\"\\n\")      #join the lines of the array,\n",
    "println(linesJoined)                # \"\\n\" to create line breaks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strings and Indexing (extra)\n",
    "\n",
    "can be tricky when the string contains non-ascii characters.\n",
    "\n",
    "Notice that you cannot change a string by indexing. For instance, `str[1] = \"D\"` does not work. However, you can *read* strings by indexing, if you are careful.\n",
    "\n",
    "The next cell gives two versions of a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Δx = -0.9x\""
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = \"Dx = -0.9x\"\n",
    "str2 = \"Δx = -0.9x\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D\n"
     ]
    }
   ],
   "source": [
    "println(str1[1])           #works\n",
    "#println(str2[2])          #uncomment to get an error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`str2[2]` does not work since the first character takes more than one byte to store. Julia has commands to get around this. For instance, see the next cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x\n",
      "x\n"
     ]
    }
   ],
   "source": [
    "                                #this should work in all cases\n",
    "println(str1[nextind(str1,1)])   #nextind() gives the starting point of the character after the number (1)\n",
    "println(str2[nextind(str2,1)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Looping over All Characters in a String\n",
    "\n",
    "in a way that works even if there are some non-ascii characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 Δ\n",
      "3 x\n",
      "4  \n",
      "5 =\n",
      "6  \n",
      "7 -\n",
      "8 0\n",
      "9 .\n",
      "10 9\n",
      "11 x\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "for c in str2              #alternatively, while i <= lastindex(str)\n",
    "    #global i              #only needed in script \n",
    "    println(i,\" \",c)\n",
    "    i = nextind(str2,i)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating a Long String (extra)\n",
    "\n",
    "can be done with `string()`, but it is often quicker to write to an `IOBuffer()`. \n",
    "\n",
    "Both approaches are demonstrated below by combining a vector of words into a string. (This is just meant as an illustration since `join(txt,\" \")` would be a better way to do this particular operation.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "txt = [\"The\",\"highway\",\"is\",\"for\",\"gamblers,\",\"better\",\"use\",\"your\",\"sense\\n\",    #a vector of words from a song\n",
    "       \"Take\",\"what\",\"you\",\"have\",\"gathered\",\"from\",\"coincidence\"];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " The highway is for gamblers, better use your sense\n",
      " Take what you have gathered from coincidence\n"
     ]
    }
   ],
   "source": [
    "BabyBlue1 = \"\"                                 #an empty string\n",
    "for i = 1:length(txt)\n",
    "    #global BabyBlue1                          #only needed in script\n",
    "    BabyBlue1 = string(BabyBlue1,\" \",txt[i])   #add to the string\n",
    "end\n",
    "println(BabyBlue1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " The highway is for gamblers, better use your sense\n",
      " Take what you have gathered from coincidence\n"
     ]
    }
   ],
   "source": [
    "iob = IOBuffer()                             #an IOBuffer\n",
    "for i = 1:length(txt)\n",
    "   write(iob,\" \",txt[i])                     #write to the buffer\n",
    "end\n",
    "BabyBlue2 = String(take!(iob))               #convert to a string\n",
    "println(BabyBlue2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Julia 1.11.1",
   "language": "julia",
   "name": "julia-1.11"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.11.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}