tutorials/GitHub_MD_rendering/Key differences between Python 2 and 3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
""   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "**What?** Key differences between Python 2 and 3\n",
    "    \n",
""   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Key differences between Python 2 and 3\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are some good articles already that are summarizing the differences between Python 2 and 3, e.g.,  \n",
    "- [https://wiki.python.org/moin/Python2orPython3](https://wiki.python.org/moin/Python2orPython3)\n",
    "- [https://docs.python.org/3.0/whatsnew/3.0.html](https://docs.python.org/3.0/whatsnew/3.0.html)\n",
    "- [http://python3porting.com/differences.html](http://python3porting.com/differences.html)\n",
    "- [https://docs.python.org/3/howto/pyporting.html](https://docs.python.org/3/howto/pyporting.html)  \n",
    "etc.\n",
    "\n",
    "But it might be still worthwhile, especially for Python newcomers, to take a look at some of those!\n",
    "(Note: the the code was executed in Python 3.4.0 and Python 2.7.5 and copied from interactive shell sessions.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Overview - Key differences between Python 2 and 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "- [Unicode](#unicode)\n",
    "- [The print statement](#print)\n",
    "- [Integer division](#integer_div)\n",
    "- [xrange()](#xrange)\n",
    "- [Raising exceptions](#raising_exceptions)\n",
    "- [Handling exceptions](#handling_exceptions)\n",
    "- [next() function and .next() method](#next_next)\n",
    "- [Loop variables and leaking into the global scope](#loop_leak)\n",
    "- [Comparing unorderable types](#compare_unorder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unicode..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "#### Python 2: \n",
    "We have ASCII `str()` types, separate `unicode()`, but no `byte` type\n",
    "#### Python 3: \n",
    "Now, we finally have Unicode (utf-8) `str`ings, and 2 byte classes: `byte` and `bytearray`s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "#############\n",
    "# Python 2  #\n",
    "#############\n",
    "\n",
    ">>> type(unicode('is like a python3 str()'))\n",
    "<type 'unicode'>\n",
    "\n",
    ">>> type(b'byte type does not exist')\n",
    "<type 'str'>\n",
    "\n",
    ">>> 'they are really' + b' the same'\n",
    "'they are really the same'\n",
    "\n",
    ">>> type(bytearray(b'bytearray oddly does exist though'))\n",
    "<type 'bytearray'>\n",
    "\n",
    "#############\n",
    "# Python 3\n",
    "#############\n",
    "\n",
    ">>> print('strings are now utf-8 \\u03BCnico\\u0394é!')\n",
    "strings are now utf-8 μnicoΔé!\n",
    "\n",
    "\n",
    ">>> type(b' and we have byte types for storing data')\n",
    "<class 'bytes'>\n",
    "\n",
    ">>> type(bytearray(b'but also bytearrays for those who prefer them over strings'))\n",
    "<class 'bytearray'>\n",
    "\n",
    ">>> 'string' + b'bytes for data'\n",
    "Traceback (most recent call last):s\n",
    "  File \"<stdin>\", line 1, in <module>\n",
    "TypeError: Can't convert 'bytes' object to str implicitly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The print statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Very trivial, but this change makes sense, Python 3 now only accepts `print`s with proper parentheses - just like the other function calls ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2\n",
    ">>> print 'Hello, World!'\n",
    "Hello, World!\n",
    ">>> print('Hello, World!')\n",
    "Hello, World!\n",
    "\n",
    "# Python 3\n",
    ">>> print('Hello, World!')\n",
    "Hello, World!\n",
    ">>> print 'Hello, World!'\n",
    "  File \"<stdin>\", line 1\n",
    "    print 'Hello, World!'\n",
    "                        ^\n",
    "SyntaxError: invalid syntax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And if we want to print the output of 2 consecutive print functions on the same line, you would use a comma in Python 2, and a `end=\"\"` in Python 3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2\n",
    ">>> print \"line 1\", ; print 'same line'\n",
    "line 1 same line\n",
    "\n",
    "# Python 3\n",
    ">>> print(\"line 1\", end=\"\") ; print (\" same line\")\n",
    "line 1 same line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integer division"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a pretty dangerous thing if you are porting code, or executing Python 3 code in Python 2 since the change in integer-division behavior can often go unnoticed.  \n",
    "So, I still tend to use a `float(3)/2` or `3/2.0` instead of a `3/2` in my Python 3 scripts to save the Python 2 guys some trouble ... (PS: and vice versa, you can `from __future__ import division` in your Python 2 scripts)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2\n",
    ">>> 3 / 2\n",
    "1\n",
    ">>> 3 // 2\n",
    "1\n",
    ">>> 3 / 2.0\n",
    "1.5\n",
    ">>> 3 // 2.0\n",
    "1.0\n",
    "\n",
    "# Python 3\n",
    ">>> 3 / 2\n",
    "1.5\n",
    ">>> 3 // 2\n",
    "1\n",
    ">>> 3 / 2.0\n",
    "1.5\n",
    ">>> 3 // 2.0\n",
    "1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `xrange()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " \n",
    "`xrange()` was pretty popular in Python 2.x if you wanted to create an iterable object. The behavior was quite similar to a generator ('lazy evaluation'), but you could iterate over it infinitely. The advantage was that it was generally faster than `range()` (e.g., in a for-loop) - not if you had to iterate over the list multiple times, since the generation happens every time from scratch!  \n",
    "In Python 3, the `range()` was implemented like the `xrange()` function so that a dedicated `xrange()` function does not exist anymore."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2\n",
    ">> > python - m timeit 'for i in range(1000000):' ' pass'\n",
    "10 loops, best of 3: 66 msec per loop\n",
    "\n",
    "> python - m timeit 'for i in xrange(1000000):' ' pass'\n",
    "10 loops, best of 3: 27.8 msec per loop\n",
    "\n",
    "# Python 3\n",
    ">> > python3 - m timeit 'for i in range(1000000):' ' pass'\n",
    "10 loops, best of 3: 51.1 msec per loop\n",
    "\n",
    ">> > python3 - m timeit 'for i in xrange(1000000):' ' pass'\n",
    "Traceback(most recent call last):\n",
    "    File \"/Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4/timeit.py\", line 292, in main\n",
    "    x = t.timeit(number)\n",
    "    File \"/Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4/timeit.py\", line 178, in timeit\n",
    "    timing = self.inner(it, self.timer)\n",
    "    File \"<timeit-src>\", line 6, in inner\n",
    "    for i in xrange(1000000):\n",
    "NameError: name 'xrange' is not defined"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Raising exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Where Python 2 accepts both notations, the 'old' and the 'new' way, Python 3 chokes (and raises a `SyntaxError` in turn) if we don't enclose the exception argument in parentheses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2\n",
    ">>> raise IOError, \"file error\"\n",
    "Traceback (most recent call last):\n",
    "  File \"<stdin>\", line 1, in <module>\n",
    "IOError: file error\n",
    ">>> raise IOError(\"file error\")\n",
    "Traceback (most recent call last):\n",
    "  File \"<stdin>\", line 1, in <module>\n",
    "IOError: file error\n",
    "\n",
    "    \n",
    "# Python 3    \n",
    ">>> raise IOError, \"file error\"\n",
    "  File \"<stdin>\", line 1\n",
    "    raise IOError, \"file error\"\n",
    "                 ^\n",
    "SyntaxError: invalid syntax\n",
    ">>> raise IOError(\"file error\")\n",
    "Traceback (most recent call last):\n",
    "  File \"<stdin>\", line 1, in <module>\n",
    "OSError: file error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Handling exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Also the handling of exceptions has slightly changed in Python 3. Now, we have to use the `as` keyword!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2\n",
    ">>> try:\n",
    "...     blabla\n",
    "... except NameError, err:\n",
    "...     print err, '--> our error msg'\n",
    "... \n",
    "name 'blabla' is not defined --> our error msg\n",
    "\n",
    "# Python 3\n",
    ">>> try:\n",
    "...     blabla\n",
    "... except NameError as err:\n",
    "...     print(err, '--> our error msg')\n",
    "... \n",
    "name 'blabla' is not defined --> our error msg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The `next()` function and `.next()` method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "Where you can use both function and method in Python 2.7.5, the `next()` function is all that remains in Python 3!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 2\n",
    ">>> my_generator = (letter for letter in 'abcdefg')\n",
    ">>> my_generator.next()\n",
    "'a'\n",
    ">>> next(my_generator)\n",
    "'b'\n",
    "\n",
    "# Python 3\n",
    ">>> my_generator = (letter for letter in 'abcdefg')\n",
    ">>> next(my_generator)\n",
    "'a'\n",
    ">>> my_generator.next()\n",
    "Traceback (most recent call last):\n",
    "  File \"<stdin>\", line 1, in <module>\n",
    "AttributeError: 'generator' object has no attribute 'next'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### In Python 3.x for-loop variables don't leak into the global namespace anymore"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This goes back to a change that was made in Python 3.x and is described in [What’s New In Python 3.0](https://docs.python.org/3/whatsnew/3.0.html) as follows:\n",
    "\n",
    "*\"List comprehensions no longer support the syntactic form `[... for var in item1, item2, ...]`. Use `[... for var in (item1, item2, ...)]` instead. Also note that list comprehensions have different semantics: they are closer to syntactic sugar for a generator expression inside a `list()` constructor, and in particular the loop control variables are no longer leaked into the surrounding scope.\"*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    ">>> from platform import python_version\n",
    ">>> print 'This code cell was executed in Python', python_version()\n",
    "'This code cell was executed in Python 2.7.6'\n",
    ">>> i = 1\n",
    ">>> print [i for i in range(5)]\n",
    "'[0, 1, 2, 3, 4]'\n",
    ">>> print i, '-> i in global'\n",
    "'4 -> i in global'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This code cell was executed in Python 3.6.4\n",
      "[0, 1, 2, 3, 4]\n",
      "1 -> i in global\n"
     ]
    }
   ],
   "source": [
    "%%python3\n",
    "from platform import python_version\n",
    "print('This code cell was executed in Python', python_version())\n",
    "\n",
    "i = 1\n",
    "print([i for i in range(5)])\n",
    "print(i, '-> i in global')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python 3.x prevents us from comparing unorderable types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Couldn't find program: 'python2'\n"
     ]
    }
   ],
   "source": [
    ">>> from platform import python_version\n",
    ">>> print 'This code cell was executed in Python', python_version()\n",
    "'This code cell was executed in Python 2.7.6'\n",
    ">>> print [1, 2] > 'foo'\n",
    "'False'\n",
    ">>> print (1, 2) > 'foo'\n",
    "'True'\n",
    ">>> print [1, 2] > (1, 2)\n",
    "'False'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This code cell was executed in Python 3.6.4\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'>' not supported between instances of 'list' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-67-40a145eac137>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'This code cell was executed in Python'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpython_version\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[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;34m'foo'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;34m'foo'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: '>' not supported between instances of 'list' and 'str'"
     ]
    }
   ],
   "source": [
    "from platform import python_version\n",
    "print('This code cell was executed in Python', python_version())\n",
    "\n",
    "print([1, 2] > 'foo')\n",
    "print((1, 2) > 'foo')\n",
    "print([1, 2] > (1, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# References\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "- https://nbviewer.org/github/rasbt/python_reference/blob/master/tutorials/not_so_obvious_python_stuff.ipynb?create=1\n",
    "\n",
""   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "trainingAI",
   "language": "python",
   "name": "trainingai"
  },
  "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.9.7"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}