Python1 Strings.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # Let's start with strings\n",
    "\n",
    " We assume you know how to program. You don't need to learn what a loop or a variable is!\n",
    "\n",
    " We are starting with strings as this is a type common to most languages so you likely know what it is. But they also allow us to introduce lots of Python concepts!\n",
    "\n",
    " Using strings, we'll have a look at the following:\n",
    "  - what object-oriented language means\n",
    "  - the print() function and how to format a string\n",
    "  - indexing\n",
    "  - loops\n",
    "  - if constructs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First variable\n",
    "a = \"Claire\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Claire'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a  # Easy to get the value of a variable in a notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Claire'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Can be done in one cell:\n",
    "a = \"Claire\"\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'A' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-4-62579e0dbc5d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Python is case sensitive\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[0mA\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'A' is not defined"
     ]
    }
   ],
   "source": [
    "# Python is case sensitive\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Claire Carouge'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You can add strings:\n",
    "b = \" Carouge\"\n",
    "c = a+b\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ---\n",
    " ## Object-oriented language\n",
    "\n",
    " Everything is an object in Python. That means a variable contains more than a value. It may also contain:\n",
    "  - **functions, called methods**. These are specific to each object type. A string and an array won't have the same methods.\n",
    "  - **attributes**. These are additional information about the object. Think of it a bit like meta-data. Attributes differ from methods because they simply contain a value and not a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find out the type of an object\n",
    "?a\n",
    "a.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__getnewargs__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mod__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'capitalize',\n",
       " 'casefold',\n",
       " 'center',\n",
       " 'count',\n",
       " 'encode',\n",
       " 'endswith',\n",
       " 'expandtabs',\n",
       " 'find',\n",
       " 'format',\n",
       " 'format_map',\n",
       " 'index',\n",
       " 'isalnum',\n",
       " 'isalpha',\n",
       " 'isascii',\n",
       " 'isdecimal',\n",
       " 'isdigit',\n",
       " 'isidentifier',\n",
       " 'islower',\n",
       " 'isnumeric',\n",
       " 'isprintable',\n",
       " 'isspace',\n",
       " 'istitle',\n",
       " 'isupper',\n",
       " 'join',\n",
       " 'ljust',\n",
       " 'lower',\n",
       " 'lstrip',\n",
       " 'maketrans',\n",
       " 'partition',\n",
       " 'replace',\n",
       " 'rfind',\n",
       " 'rindex',\n",
       " 'rjust',\n",
       " 'rpartition',\n",
       " 'rsplit',\n",
       " 'rstrip',\n",
       " 'split',\n",
       " 'splitlines',\n",
       " 'startswith',\n",
       " 'strip',\n",
       " 'swapcase',\n",
       " 'title',\n",
       " 'translate',\n",
       " 'upper',\n",
       " 'zfill']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Find all attributes/methods of an object\n",
    "dir(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " It doesn't tell you if those are methods or simple attributes. There is no information on what the method does. Inline help can help here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ---\n",
    " ## Print function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Obviously, there is a `print()` function builtin. It can print out the values in all sorts of objects, not just strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Claire\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My var is: Claire\n"
     ]
    }
   ],
   "source": [
    "# Print several variables together:\n",
    "print(\"My var is:\",a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Claire , it's me\n"
     ]
    }
   ],
   "source": [
    "b = \"it's me\"\n",
    "print(a,\",\",b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### Formatting\n",
    " It is possible to format a string in Python and there are several ways to do that.\n",
    "\n",
    " Let's start with the new way: f-string "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's 50% off, it costs 100.0 dollars\n"
     ]
    }
   ],
   "source": [
    "a = 100.\n",
    "b = 50\n",
    "print(f\"It's {b}% off, it costs {a} dollars\")  # You put the name of the variable directly in the string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " It is possible to describe the format of the variable in the string.\n",
    "\n",
    "  There are lots of possibilities to format strings. Python refer to it as \"Format Specification Mini-Language\".\n",
    " The complete documentation is here: https://docs.python.org/3/library/string.html#formatspec\n",
    "\n",
    "  A few examples below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's 50% off, it costs 100 dollars\n"
     ]
    }
   ],
   "source": [
    "# Format a fixed-point number\n",
    "print(f\"It's {b}% off, it costs {a:3.0f} dollars\") # Same formatting options"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above we said we wanted a fixed-point notation, with an overall width of 3 charaters and 0 characters after the decimal point (called the precision)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0100.0\n",
      "000100\n"
     ]
    }
   ],
   "source": [
    "# Pad a number on the left with zeros. Remember the type of your variable!\n",
    "b=f\"{a:0>6}\"\n",
    "c=f\"{a:0>6.0f}\"\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.000000e+02\n",
      "1.000e+02\n"
     ]
    }
   ],
   "source": [
    "# Exponent notation:\n",
    "print(f\"{a:e}\")\n",
    "print(f\"{a:.3e}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another method of formating is the string method: `str.format()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's 100.0 dollars\n"
     ]
    }
   ],
   "source": [
    "print(\"It's {} dollars\".format(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " When putting several variables into the same string, it allows you to refer to the `str.format()` arguments by position or name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's 50% off, it costs 100.0 dollars\n",
      "It's 50% off, it costs 100.0 dollars\n"
     ]
    }
   ],
   "source": [
    "a=100.\n",
    "b=50\n",
    "print(\"It's {1}% off, it costs {0} dollars\".format(a,b))\n",
    "print(\"It's {perc}% off, it costs {cost} dollars\".format(perc=b, cost=a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's 100 dollars\n",
      "It's 100 dollars\n"
     ]
    }
   ],
   "source": [
    "# Add some formatting\n",
    "print(\"It's {cost:3.0f} dollars\".format(cost=a))  # with keyword argument\n",
    "print(\"It's {:3.0f} dollars\".format(a))  # with just an argument"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " If you want to learn more but find the Python manual a bit heavy in details:\n",
    "\n",
    " https://realpython.com/python-f-strings/#python-f-strings-the-pesky-details"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Finally there is an old way you shouldn't use. We only see it because you might encounter it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's 100.0 dollars\n"
     ]
    }
   ],
   "source": [
    "print(\"It's %s dollars\"%a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ---\n",
    " ## Indexing\n",
    "\n",
    " Strings are indexable in Python. Indexes start at 0 in Python. It's possible to have negative indexes, thus `-1` refers to the last element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'l'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 'Claire'\n",
    "a[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'e'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'i'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[-3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### len() function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " This is a builtin function in Python. It returns the length of a whole bunch of objects. Be careful when using it with more complex objects as it might not return what you'd like as we'll see later"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C\n",
      "Cla\n",
      "Cla\n",
      "ire\n",
      "Car\n",
      "Clair\n",
      "Clair\n",
      "Claire\n",
      "Cla\n"
     ]
    }
   ],
   "source": [
    "print(a[0:1]) # Last index isn't included. Same as a[0]\n",
    "print(a[0:3])\n",
    "print(a[:3]) # Start and end indexes can be omitted. This means everything from start to index 3-1\n",
    "print(a[3:]) # Means everything from index 3 to the end.\n",
    "print(a[::2]) # You can use a stride. It means from start to end, print every other character.\n",
    "print(a[0:-1]) # That's not the whole string!\n",
    "print(a[:-1]) # This neither\n",
    "print(a[0:len(a)]) # The whole string\n",
    "print(a[0:len(a)-3]) # You can obviously have expressions to define the indexes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " The slice `0:3` means, “Start at index 0 and go up to, but not including, index 3.” The up-to-but-not-including takes a bit of getting used to, but the rule is that the difference between the upper and lower bounds is the number of values in the slice.\n",
    "\n",
    " But it's nice as it avoids having a `-1` all the time. For example, to get the 3 first character, you use this slice `:3`. If the last index was including, you would need: `:3-1`. If you want 2 characters from the 2nd character, you do `2:2+2` and not `2:2+2-1`. Etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ---\n",
    " ## Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " **Important note:** Loops are very ineficient in Python. It is best to avoid them as much as possible. It isn't always possible obviously but it is something you should keep in mind.\n",
    " \n",
    "You can loop on any iterable! No just a range of numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C\n",
      "l\n",
      "a\n",
      "i\n",
      "r\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "for char in a:\n",
    "    print(char)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Note the syntax! `for`, `in`, `:`, indentation to define what is in the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Indentation = in the loop\n",
      "Still in\n",
      "Indentation = in the loop\n",
      "Still in\n",
      "Indentation = in the loop\n",
      "Still in\n",
      "Indentation = in the loop\n",
      "Still in\n",
      "Indentation = in the loop\n",
      "Still in\n",
      "Indentation = in the loop\n",
      "Still in\n",
      "This is outside the loop because it is not indented\n"
     ]
    }
   ],
   "source": [
    "for char in a:\n",
    "    print(\"Indentation = in the loop\")\n",
    "    print(\"Still in\")\n",
    "print(\"This is outside the loop because it is not indented\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unexpected indent (<ipython-input-27-e33d7e7bd96a>, line 4)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-27-e33d7e7bd96a>\"\u001b[0;36m, line \u001b[0;32m4\u001b[0m\n\u001b[0;31m    print(\"OK?\")\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unexpected indent\n"
     ]
    }
   ],
   "source": [
    "# Different indentations = error\n",
    "for char in a:\n",
    "    print(\"Hey\")\n",
    "        print(\"OK?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### Loop over a range:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "5\n",
      "7\n",
      "9\n",
      "11\n",
      "13\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "for i in range(3,17,2):   # End index is excluded here again! There is some consistency.\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### Nested loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C\n",
      "l\n",
      "a\n",
      "Index: 0\n",
      "C\n",
      "l\n",
      "a\n",
      "Index: 1\n"
     ]
    }
   ],
   "source": [
    "for i in range(2):\n",
    "    for char in a[:3]:\n",
    "        print(char)\n",
    "    print(\"Index:\",i)  # In outer loop but not inner loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### Break / continue statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    if i == len(a):\n",
    "        break\n",
    "i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " There is also a `while` construct, which you can discover on your own. It has a similar syntax as the `for` loop construct."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ---\n",
    " ## If constructs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yeah\n"
     ]
    }
   ],
   "source": [
    "if \"l\" in a:\n",
    "    print(\"Yeah\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yeah\n"
     ]
    }
   ],
   "source": [
    "if \"Claire\" == a:\n",
    "    print(\"Yeah\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "oh!\n",
      "oh!\n"
     ]
    }
   ],
   "source": [
    "# Negation\n",
    "if \"Claire\" != a:\n",
    "    print(\"yeah\")\n",
    "if not \"z\" in a:\n",
    "    print(\"oh!\")\n",
    "if \"z\" not in a:\n",
    "    print(\"oh!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yeah\n"
     ]
    }
   ],
   "source": [
    "# and / or\n",
    "if not \"z\" in a and \"l\" in a:\n",
    "    print(\"yeah\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " A lot more details on comparison expressions: https://docs.python.org/3/reference/expressions.html#comparisons\n",
    "\n",
    " And operator precedence: https://docs.python.org/3/reference/expressions.html#operator-precedence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### any() and all() functions\n",
    "\n",
    " Python has `any()` and `all()` functions as built-in.\n",
    "\n",
    " `any(x)` returns true if at least 1 value in x is True,\n",
    "\n",
    "  `all(x)` returns true if all values in x are True or x is null.\n",
    "\n",
    " In Python, 0, False and None are False. Everything else is True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True False\n"
     ]
    }
   ],
   "source": [
    "b=\"\"\n",
    "print(all(b), any(b))"
   ]
  }
 ],
 "metadata": {
  "file_extension": ".py",
  "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.2"
  },
  "mimetype": "text/x-python",
  "name": "python",
  "npconvert_exporter": "python",
  "pygments_lexer": "ipython3",
  "version": 3
 },
 "nbformat": 4,
 "nbformat_minor": 2
}