3.  Objects and Identifiers.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*********************************************************************************************************\n",
    "# A Tour of Python 3  \n",
    "version 1.0.1  \n",
    "Authors: Phil Pfeiffer, Zack Bunch, and Feyisayo Oyeniyi  \n",
    "East Tennessee State University  \n",
    "Last updated June 2021  \n",
    "*********************************************************************************************************"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Objects and Identifiers  \n",
    " 3.1 [Objects](#Objects-And-Identifiers-Objects)  \n",
    " &ensp; 3.1.1 [Overview](#Objects-And-Identifiers-Objects-Overview)  \n",
    " &ensp; 3.1.2 [Using *dir* to Expose Object Attributes](#Objects-And-Identifiers-Objects-Using-Dir-To-Expose-Object-Attributes)  \n",
    " &ensp; 3.1.3 [\"Special\" Attributes](#Objects-And-Identifiers-Objects-Special-Attributes)  \n",
    " &ensp; 3.1.4 [Attribute Inheritance](#Objects-And-Identifiers-Objects-Attribute-Inheritance)  \n",
    " 3.2 [Identifiers](#Objects-And-Identifiers-Identifiers)  \n",
    " &ensp; 3.2.1 [Overview](#Objects-And-Identifiers-Identifiers-Overview)  \n",
    " &ensp; 3.2.2 [Special Identifiers](#Objects-And-Identifiers-Special-Identifiers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 Objects  <a name='Objects-And-Identifiers-Objects'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1.1 Overview <a name='Objects-And-Identifiers-Objects-Overview'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is an *object-oriented* (OO) language. According to Meiler Page-Jones, an *object* is an entity with five characteristics:\n",
    "-  an *identity*: a value that distinguishes it from all other objects in its environment\n",
    "-  a *state*: a collection of (subordinate) objects that \n",
    "   -  are associated with (i.e., \"internal to\") that object\n",
    "   -  can vary over the course of a computation\n",
    "-  an *interface*: a set of identifiers that reference the object's contents.\n",
    "   -  This includes *methods*:  actions associated with an object that can access and possibly update an object's state\n",
    "-  *behaviors*: actions that affect the object itself and its environment, as implemented by its methods.\n",
    "-  a *lifetime*: a duration in an overall computation during which the object exists.\n",
    "\n",
    "All computational entities in a Python environment are realized as objects. ",
    "This includes numbers, strings, collections, executable code -- everything.\n",
    "",
    "Python's objects are organized as a directed graph with a single root object, known as *object*.\n",
    "  All Python objects, directly or indirectly, derive aspects of their interface, state, and behaviors from *object*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1.2 Using *dir* to Expose Object Attributes <a name='Objects-And-Identifiers-Objects-Using-Dir-To-Expose-Object-Attributes'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python refers to the items in an object's interface as its *attributes*.",
    "  Python's `dir` command-- short for \"directory\"-- exposes an object's attributes.",
    "  The following example illustrates this point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.1.2  Using dir to expose object's attributes\n",
    "\n",
    "dir(object)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1.3 \"Special\" Attributes <a name='Objects-And-Identifiers-Objects-Special-Attributes'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By convention, attributes whose names start and end with double underscores are referenced by built-in Python constructs ",
    " when acting on objects or retrieving their content.\n",
    "\n",
    "These, for example, are some of the \"special\" attributes that *object* defines:\n",
    "-  `__dir__` - what *dir* invokes when returning a given object's directory\n",
    "-  `__getattribute__` - what Python uses to retrieve a given attribute; used (e.g.) by *dir*\n",
    "-  `__setattr__` - what Python uses to modify a given attribute; used (e.g.) by Python's assignment operator\n",
    "-  `__lt__`, `__le__`, `__eq__`, `__ne__`, `__ge__`, `__gt__` - what Python's &lt;, &le;, =, !=, &gt;, and &ge; operators invoke when comparing objects\n",
    "-  `__new__` - what Python invokes to create a new, uninitialized instance of an object\n",
    "-  `__init__` - what Python invokes to create a new, initialized instance of an object\n",
    "-  `__str__` - what Python's *str* method invokes to return a string that describes an object.\n",
    "-  `__repr__` - what Python's *repr* method invokes to return a code-based representation of an object; by default, `__repr__` gives the same output as `__str__`\n",
    "-  `__hash__` - what Python uses to create a key for objects that can be included in dictionaries and frozensets.\n",
    "-  `__doc__` - by convention, this references a short description of an object's properties, known as a *docstring*\n",
    "\n",
    "Other Python objects inherit these attributes from *object*. ",
    "These  attributes provide a means for customizing built-in Python operators to a particular application's needs.",
    "  Some of these hooks are left for other, derived objects to define."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.1.3.a the __doc__ attribute\n",
    "print(object.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.1.3.b1 the __str__ and _repr__ attributes, accessed via str() and repr()\n",
    "str(object), repr(object)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.1.3.b2 the __str__ and _repr__ attributes, accessed as themselves\n",
    "object.__str__(object), object.__repr__(object)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.1.3.c1 the __eq__ and __ne__ attributes, accessed via Python relational operators\n",
    "object == object, object != object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.1.3.c2 the __eq__ and __ne__ attributes, accessed as themselves\n",
    "object.__eq__(object, object), object.__ne__(object, object)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.1.3.d1 the comparison attributes, accessed via Python relational operators\n",
    "object < object, object <= object, object >= object, object > object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.1.3.d2 the comparison attributes, accessed as themselves\n",
    "object.__lt__(object, object), object.__le__(object, object), object.__ge__(object, object), object.__gt__(object, object)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1.4 Attribute Inheritance <a name='Objects-And-Identifiers-Objects-Attribute-Inheritance'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As in other OO languages, objects share attributes, via an is-a relation known as *inheritance*.\n",
    " All objects inherit some basic attributes from *object*, along with other Python objects from which they are descended."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.1.4.a1 Using dir to expose object attributes - a sample integer\n",
    "dir(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.1.4.a2 Using dir to expose object attributes - a sample string\n",
    "dir('hello world')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.1.4.a3 Using dir to expose object attributes - a sample list\n",
    "dir([1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All of these objects-- integers, strings, and lists-- as well as all other Python objects inherit a basic set of attributes from *object*, like `__doc__`.",
    "  These derived objects then modify these basic attributes and add others, in order to provide their assigned behaviors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.1.4.b1 the __doc__ attribute for strings, using a sample string\n",
    "print('hello world'.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.1.4.b2 the __doc__ attribute for strings, using the string constructor, str\n",
    "print(str.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.1.4.b3 accessing a string-specific attribute, upper(), in two ways\n",
    "'a sample string'.upper(), str.upper('a sample string')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.1.4.c1 the __doc__ attribute for lists, using a sample list\n",
    "print([1, 2, 3].__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.1.4.c2 the __doc__ attribute for lists, using the list constructor\n",
    "print(list.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.1.4.c3 accessing a string-specific attribute, reverse(), in two ways\n",
    "x = [1, 2, 3]\n",
    "x.reverse()\n",
    "y = [4, 5, 6]\n",
    "list.reverse(y)\n",
    "x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.1.4.d1 the __doc__ attribute for integers, using the integer constructor, int()\n",
    "print(int.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.1.4.d2 accessing an int-specific attribute, __abs__, in two ways\n",
    "int.__abs__(-1), abs(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.1.4.d3 the __doc__ attribute for integers, using a sample integer\n",
    "print(1.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 3.1.4.1:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following markdown cell, ",
    "explain why attempting to use 1.\\_\\_*doc*\\_\\_ to access the integer docstring fails.",
    "</span>\n",
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 3.1.4.2:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "construct commented examples that illustrate the difference between the string object's ",
    "*rpartition*, *rsplit*, and *rstrip* attributes.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 3.1.4.3:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "construct commented examples that illustrate the difference between the string object's ",
    "*capitalize*, *isupper*, and *islower* attributes.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 3.1.4.4:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "construct commented examples that illustrate the difference between the string object's ",
    "*split* and *splitlines* attributes.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 3.1.4.5:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "construct commented examples that illustrate the difference between the integer object's ",
    "*bit_length* and *to_bytes* attributes.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 3.1.4.6:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "construct commented examples that illustrate the difference between the integer object's ",
    "\\_\\_*rrshift*\\_\\_ and \\_\\_*rshift*\\_\\_ attributes.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 3.1.4.7:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "construct commented examples that illustrate the difference between the float object's ",
    "\\_\\_*ceil*\\_\\_, \\_\\_*floor*\\_\\_, and \\_\\_*floordiv*\\_\\_ attributes.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 3.1.4.8:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "construct commented examples that illustrate the difference between the list object's ",
    "*pop*, *remove*, and \\_\\_*delitem*\\_\\_ attributes.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:blue'>",
    "&#128073;&ensp;&ensp;**Exercise 3.1.4.9:**\n\n",
    "</span>",
    "<span style='color:navy'>",
    "In the following code cell, ",
    "construct commented examples that illustrate the difference between list object's ",
    "*append*, *extend*, and *insert* attributes.",
    "</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 Identifiers <a name='Objects-And-Identifiers-Identifiers'></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.1 Overview <a name='Objects-And-Identifiers-Identifiers-Overview'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An *identifier* is a syntactic construct that can reference an object.  Identifiers\n",
    "-  begin with an upper-case letter, a lower-case letter, or an underscore, which can be\n",
    "-  followed by an optional number of *word characters*:  upper- or lower-case letters, underscores, and/or digits\n",
    "\n",
    "Examples of valid identifiers include *a*, *a1*, *_*, *_1*, and *a1_1a*.  Examples of invalid identifiers include *2LiveCrew* and *=stuff-*.\n",
    "\n",
    "Case is significant.  Python treats *XX*, *Xx*, *xX*, and *xx* as four different identifiers.\n",
    "\n",
    "Python reserves certain identifiers, known as *keywords*, for its own use.  Codes may not use these words as identifiers.\n",
    "\n",
    "The following example uses these additional constructs:\n",
    "- *from module_name import entity* - a variant of `import` that imports *entity* under its own name\n",
    "- Python's `len` function, which returns the length of its argument: here, the number of items in a list\n",
    "- `', '.join(list)`, which joins the strings in *list* with commas\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.2.1 listing Python keywords\n",
    "\n",
    "from keyword import kwlist\n",
    "print( f\"Python has {len(kwlist)} keyword{'' if len(kwlist) == 1 else 's'}\" )\n",
    "print( 'They include', ', '.join(kwlist) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.2 Special Identifiers <a name='Objects-And-Identifiers-Special-Identifiers'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By convention, identifiers whose names start and end with double underscores denote \"special\" attributes:",
    " attributes that language constructs associate with Python statements, or library modules associated with certain methods or content.\n",
    "\n",
    "For example, as shown above,\n",
    "-  The built-in Python `dir` (attribute directory) function evaluates `dir(m)` as a call to `m.__dir__()`\n",
    "-  The built-in Python `==` operator evaluates `a == b` as a call to `a.__eq__(a,b)`\n"
   ]
  }
 ],
 "metadata": {
  "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}