02-data-types-in-python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Programming Design\n",
    "\n",
    "> Data Types in Python\n",
    "\n",
    "Yao-Jen Kuo <yaojenkuo@ntu.edu.tw> from [DATAINPOINT](https://www.datainpoint.com/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## We usually don't just print out literal values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello, world!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## It is more useful to refer a literal value by an object name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello, world!\n",
      "HELLO, WORLD!\n",
      "hELLO, WORLD!\n",
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "hello_world = \"Hello, world!\"\n",
    "print(hello_world.lower())\n",
    "print(hello_world.upper())\n",
    "print(hello_world.swapcase())\n",
    "print(hello_world.title())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## A variable is a name that refers to a value\n",
    "\n",
    "```python\n",
    "variable_name = literal_value\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Choose names for our variables: don'ts\n",
    "\n",
    "- Do not use built-in functions.\n",
    "- Cannot use [keywords](https://docs.python.org/3/reference/lexical_analysis.html#keywords).\n",
    "- Cannot start with numbers.\n",
    "\n",
    "Source: <https://www.python.org/dev/peps/pep-0008/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Choose names for our variables: dos\n",
    "\n",
    "- Use a lowercase single letter, word, or words.\n",
    "- Separate words with underscores to improve readability(so-called snake case).\n",
    "- Be meaningful.\n",
    "\n",
    "Source: <https://www.python.org/dev/peps/pep-0008/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Using `#` to write comments in our program\n",
    "\n",
    "Comments can appear on a line by itself, or at the end of a line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "100.0\n"
     ]
    }
   ],
   "source": [
    "# Turn fahrenheit to celsius\n",
    "def from_fahrenheit_to_celsius(x: int) -> float:\n",
    "    out = (x - 32) * 5/9\n",
    "    return out\n",
    "\n",
    "print(from_fahrenheit_to_celsius(32))  # turn 32 fahrenheit to celsius\n",
    "print(from_fahrenheit_to_celsius(212)) # turn 212 fahrenheit to celsius"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Everything from `#` to the end of the line is ignored during execution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Values belong to different types, we commonly use\n",
    "\n",
    "- `int` and `float` for numeric computing.\n",
    "- `str` for symbolic.\n",
    "- `bool` for conditionals.\n",
    "- `NoneType` for undefined values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use `type` function to check the type of a certain value/variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n",
      "<class 'bool'>\n",
      "<class 'bool'>\n",
      "<class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "print(type(5566))\n",
    "print(type(42.195))\n",
    "print(type(\"Hello, world!\"))\n",
    "print(type(True))\n",
    "print(type(False))\n",
    "print(type(None))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## `str`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## How to form a `str`?\n",
    "\n",
    "Use paired `'`, `\"`, or `\"\"\"` to embrace letters strung together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'str'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "str_with_single_quotes = 'Hello, world!'\n",
    "str_with_double_quotes = \"Hello, world!\"\n",
    "str_with_triple_double_quotes = \"\"\"Hello, world!\"\"\"\n",
    "print(type(str_with_single_quotes))\n",
    "print(type(str_with_double_quotes))\n",
    "print(type(str_with_triple_double_quotes))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## If we have single/double quotes in `str` values we might have `SyntaxError`\n",
    "\n",
    "```python\n",
    "mcd = 'I'm lovin' it!'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use `\\` to escape or paired `\"` or paired `\"\"\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "mcd = 'I\\'m lovin\\' it!'\n",
    "mcd = \"I'm lovin' it!\"\n",
    "mcd = \"\"\"I'm lovin' it!\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Great features of strings formed with paired `\"\"\"`\n",
    "\n",
    "- A paragraph.\n",
    "- Docstring."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use paired `\"\"\"` for a paragraph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "storyline = \"\"\"\n",
    "Chronicles the experiences of a formerly successful banker\\\n",
    " as a prisoner in the gloomy jailhouse of Shawshank after\\\n",
    " being found guilty of a crime he did not commit. The film\\\n",
    " portrays the man's unique way of dealing with his new, torturous\\\n",
    " life; along the way he befriends a number of fellow prisoners,\\\n",
    " most notably a wise long-term inmate named Red.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "sql_query = \"\"\"\n",
    "SELECT *\n",
    "  FROM world\n",
    " WHERE country = 'Taiwan';\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use paired `\"\"\"` for docstring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function from_fahrenheit_to_celsius in module __main__:\n",
      "\n",
      "from_fahrenheit_to_celsius(x: int) -> float\n",
      "    Turns fahrenheit to celsius.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def from_fahrenheit_to_celsius(x: int) -> float:\n",
    "    \"\"\"\n",
    "    Turns fahrenheit to celsius.\n",
    "    \"\"\"\n",
    "    return (x - 32) * 5/9\n",
    "\n",
    "help(from_fahrenheit_to_celsius)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## We've seen arithmetic operators for numeric values\n",
    "\n",
    "How about those for `str`?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## `str` type takes `+` and `*`\n",
    "\n",
    "- `+` for concatenation.\n",
    "- `*` for repetition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm lovin' it!\n",
      "I'm lovin' it!I'm lovin' it!\n",
      "I'm lovin' it!I'm lovin' it!I'm lovin' it!\n"
     ]
    }
   ],
   "source": [
    "mcd = \"I'm lovin' it!\"\n",
    "print(mcd)\n",
    "print(mcd + mcd)\n",
    "print(mcd * 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Format our `str`\n",
    "\n",
    "- The `.format()` way.\n",
    "- **The `f-string` way**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The `f-string` way: uses `{}` for string print with format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Anakin Skywalker!\n",
      "Hello, Luke Skywalker!\n"
     ]
    }
   ],
   "source": [
    "def hello_anyone(anyone: str) -> str:\n",
    "    out = f\"Hello, {anyone}!\"\n",
    "    return out\n",
    "\n",
    "print(hello_anyone(\"Anakin Skywalker\"))\n",
    "print(hello_anyone(\"Luke Skywalker\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Commonly used format\n",
    "\n",
    "- `{:.nf}` for float format.\n",
    "- `{:,}` for comma format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.14\n",
      "3.14\n"
     ]
    }
   ],
   "source": [
    "def format_pi(pi: float) -> str:\n",
    "    return f\"{pi:.2f}\"\n",
    "\n",
    "print(format_pi(3.1415))\n",
    "print(format_pi(3.141592))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1,000 NTD to 42,670 KRW.\n",
      "5,000 NTD to 213,350 KRW.\n"
     ]
    }
   ],
   "source": [
    "def format_krw(ntd: int) -> str:\n",
    "    krw = ntd * 42.67\n",
    "    return f\"{ntd:,} NTD to {krw:,.0f} KRW.\"\n",
    "\n",
    "print(format_krw(1000))\n",
    "print(format_krw(5000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## More formats with `f-string`\n",
    "\n",
    "<https://www.w3schools.com/python/ref_string_format.asp>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## `bool`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## How to form a `bool`?\n",
    "\n",
    "- Use keywords `True` and `False` directly.\n",
    "- Use relational operators.\n",
    "- Use logical operators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use keywords `True` and `False` directly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "<class 'bool'>\n",
      "False\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "print(True)\n",
    "print(type(True))\n",
    "print(False)\n",
    "print(type(False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use relational operators\n",
    "\n",
    "We have `==`, `!=`, `>`, `<`, `>=`, `<=`, `in`, `not in` as common relational operators to compare values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(5566 == 5566.0)\n",
    "print(5566 != 5566.0)\n",
    "print('56' in '5566')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use logical operators\n",
    "\n",
    "- We have `and`, `or`, `not` as common logical operators to manipulate `bool` type values.\n",
    "- Getting a `True` only if both sides of `and` are `True`.\n",
    "- Getting a `False` only if both sides of `or` are `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(True and True)  # get True only when both sides are True\n",
    "print(True and False)\n",
    "print(False and False)\n",
    "print(True or True)\n",
    "print(True or False)\n",
    "print(False or False) # get a False only when both sides are False\n",
    "# use of not is quite straight-forward\n",
    "print(not True)\n",
    "print(not False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## An example of using logical operators\n",
    "\n",
    "Good marathon weather is often described as dry **and** cold. Say, the probabilities of dry and cold on race day are both 50%, there is a 25% of chance for good marathon weather."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def is_good_marathon_weather(is_dry: bool, is_cold: bool) -> bool:\n",
    "    return is_dry and is_cold\n",
    "\n",
    "print(is_good_marathon_weather(True, True))\n",
    "print(is_good_marathon_weather(True, False))\n",
    "print(is_good_marathon_weather(False, True))\n",
    "print(is_good_marathon_weather(False, False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## An example of using logical operators(cont'd)\n",
    "\n",
    "Good marathon weather is often described as dry **or** cold. Say, the probabilities of dry and cold on race day are both 50%, there is a 75% of chance for good marathon weather."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "def is_good_marathon_weather(is_dry: bool, is_cold: bool) -> bool:\n",
    "    return is_dry or is_cold\n",
    "\n",
    "print(is_good_marathon_weather(True, True))\n",
    "print(is_good_marathon_weather(True, False))\n",
    "print(is_good_marathon_weather(False, True))\n",
    "print(is_good_marathon_weather(False, False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## `bool` is quite useful in control flow and filtering data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## `NoneType`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python has a special type, the `NoneType`, with a single value, None\n",
    "\n",
    "- This is used to represent undefined values.\n",
    "- It is not the same as `False`, or an empty string `''` or 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'NoneType'>\n",
      "False\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a_none_type = None\n",
    "print(type(a_none_type))\n",
    "print(a_none_type == False)\n",
    "print(a_none_type == '')\n",
    "print(a_none_type == 0)\n",
    "print(a_none_type == None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## A function without `return` statement actually returns a `NoneType`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Anakin Skywalker!\n",
      "Hello, Luke Skywalker!\n"
     ]
    }
   ],
   "source": [
    "def hello_anyone(anyone: str) -> str:\n",
    "    print(f\"Hello, {anyone}!\")\n",
    "\n",
    "hello_anyone(\"Anakin Skywalker\")\n",
    "hello_anyone(\"Luke Skywalker\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Anakin Skywalker!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func_out = hello_anyone(\"Anakin Skywalker\")\n",
    "type(func_out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Besides `type()` function, data types can also be validated via `isinstance()` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "an_integer = 5566\n",
    "a_float = 42.195\n",
    "a_str = \"5566\"\n",
    "a_bool = False\n",
    "a_none_type = None\n",
    "\n",
    "print(isinstance(an_integer, int))\n",
    "print(isinstance(a_float, float))\n",
    "print(isinstance(a_str, str))\n",
    "print(isinstance(a_bool, bool))\n",
    "print(isinstance(a_none_type, type(None))) # print(a_none_type == None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Data types can be dynamically converted using functions\n",
    "\n",
    "- `int()` for converting to `int`.\n",
    "- `float()` for converting to `float`.\n",
    "- `str()` for converting to `str`.\n",
    "- `bool()` for converting to `bool`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Upcasting(to a supertype) is always allowed\n",
    "\n",
    "`NoneType` -> `bool` -> `int` -> `float` -> `str`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "1\n",
      "1.0\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "print(bool(None))\n",
    "print(int(True))\n",
    "print(float(1))\n",
    "print(str(1.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## While downcasting(to a subtype) needs a second look"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n",
      "1\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(float('1.0'))\n",
    "print(int('1'))\n",
    "print(bool('False'))\n",
    "print(bool('NoneType'))"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}