{ "cells": [ { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Notes on Variables\n", "\n", "### Links for more information\n", "- [Call by value, call by reference](https://www.geeksforgeeks.org/python/is-python-call-by-reference-or-call-by-value/#google_vignette)\n", "- [Scope of variables in Python tutorial](https://www.datacamp.com/community/tutorials/scope-of-variables-python#var)\n", "- [Namespaces](https://www.programiz.com/python-programming/namespace)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Value types and reference types\n", "- C++ and others primarily use value types.\n", " - Variables are named memory locations (boxes) that hold values.\n", " - Each variable is its own named box and holds its own value.\n", "- Python variables are different than in many languages. \n", " - For convenience, we can think of Python as using reference types.\n", " - The object is what is special. \n", " - **Variable names are like tags bound to a given object.**\n", "\n", "" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "- The `id` function in Python shows the memory location of a given object." ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Location of x is 13418444784\n", "Location of y is 13418444784, the same as x\n" ] } ], "source": [ "x = 5.5\n", "y = x\n", "print(f\"Location of x is {id(x)}\")\n", "print(f\"Location of y is {id(y)}, the same as x\")" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "- Given variables `x` and `y`, if we now set y=6.6, we create a new object, 6.6, and tag it with the variable named `y`" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Location of y is 13420071632, now different than x above\n" ] } ], "source": [ "y = 6.6\n", "print(f\"Location of y is {id(y)}, now different than x above\")" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "- **For simple variables and assignments like this the difference is hardly noticeable and we can practically ignore it (as we have been).**\n", " - This is because we have mostly been working with *immutable objects*." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Mutable and immutable objects\n", "- **Python is object-centric.**\n", "- Objects come in two flavors: \n", " - **immutable** (not changeable),\n", " - numbers, strings, booleans, tuples, etc.\n", " - **mutable** (changeable). \n", " - lists, dictionaries, numpy arrays, etc. \n" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[101325 2 3 4]\n" ] }, { "data": { "image/png": "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", "text/latex": [ "$\\displaystyle \\left( 13421333744, \\ 13421333744\\right)$" ], "text/plain": [ "(13421333744, 13421333744)" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "\n", "a = np.array([1,2,3,4])\n", "\n", "b = a # try b = a.copy() instead\n", "\n", "a[0] = 101325 \n", "print(b)\n", "id(a), id(b)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "- Variables `a` and `b` both tag the same list object.\n", "- If we change that object through `a[0] = 101325`, then `b` *appears* to have also changed.\n", "- This seems strange and confuses beginners.\n", "- But it makes sense when we realize that `a` and `b` both *tag* the same object. \n", " - So, if the underlying object changes, that will be reflected in both `a[0]` and `b[0]`.\n", "- **If you want `a` and `b` to refer to separate objects so that setting `a[0]=101325` won't affect ```b```, the use `b=a.copy()`**" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "id(a) = 13690545280\n", "id(b) = 13690537920, is different than a\n", "setting a[0]= 101325\n", "b[0] hasn't changed: 1\n" ] } ], "source": [ "a = [1,2,3,4]\n", "print(f\"id(a) = {id(a)}\")\n", "\n", "b = a.copy()\n", "print(f\"id(b) = {id(b)}, is different than a\")\n", "\n", "a[0] = 101325\n", "print(f\"setting a[0]= 101325\")\n", "print(f\"b[0] hasn't changed: {b[0]}\") " ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "image/png": "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", "text/latex": [ "$\\displaystyle \\left( 13421333552, \\ 13421334800\\right)$" ], "text/plain": [ "(13421333552, 13421334800)" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = np.array([1,2,3,4])\n", "\n", "b = a*2 # assigns b to a new object array a*2; a is unchanged\n", "\n", "a[0] = 101325 # b is unchanged\n", "b\n", "id(a), id(b)" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "slideshow": { "slide_type": "skip" } }, "outputs": [], "source": [ "def f(x):\n", " return \"kittens\"\n", "\n", "print = f\n", "\n", "print(\"101325\")\n", "\n", "del(print) # to reset print" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Function arguments and scope\n", "\n", "\n", "\n", "- Variable names (tags) are bound to objects.\n", "- Variables can be seen and used in enclosing scopes.\n", " - Functions can *see* variables defined in the global scope.\n", "- A function cannot rebind a global variable to a different object. \n", " - But it can make a *different* variable with the same name and bind that to a new object. \n", " - *(in a lower scope)*\n", " - That is: same name, different variable, bound to a different object. \n", " - The global scope variable-object binding are unchanged." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Example 1\n", "- The same variable **name** can be used to tag different objects in different scopes.\n", " - The variables are different, but the names are the same. \n", " - Think of two different people with the same name.\n", "\n", "\n", "1. In the following example, outside the function in the global scope we create an immutable object ```2``` (an integer) and tag it with variable ```x```.\n", " - ```x``` here is a **global** variable.\n", "1. We call the function ```f(x)```\n", " 1. Then ```x=6``` creates a new object ```6```, and tags it with the **local** variable ```x```. \n", " - Same name, different object, different scope\n", " - That is, we are not allowed to change the global tag-object binding ```x``` to ```2```, so we create a **local** ```x``` tag that is bound to the object ```6```.\n", "1. The outside object ```2``` still exists and is still tagged by the global variable ```x```." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x top of func: 2 4300629376\n", "x end of func: 6 4300629504\n", "x final: 2 4300629376\n" ] } ], "source": [ "x = 2 # 1. create integer object 2 tagged by x\n", "#-----------------------------------\n", "def f(x): \n", " print(\"x top of func:\", x, id(x))\n", " x = 6 # 2A. create LOCAL tag x bound to different object 6\n", " print(\"x end of func:\", x, id(x))\n", "#-----------------------------------\n", "f(x) # 2. call the function\n", "print(\"x final: \", x, id(x)) # 3. outer object x is unchanged" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Example 2\n", "1. Create the mutable list object tagged by variable ```myx```.\n", "1. Pass this to the function.\n", "1. The function tags this **same** object with **local** variable ```x```.\n", "1. The function then changes an element of this list object.\n", "1. That object is still changed outside the function, because it is the same object.\n", " - The list container itself is the object, not what it holds.\n", " \n", "So, you can change mutable objects through the function argument list, without using a ```return``` statement.\n", " " ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[2, 6]\n" ] } ], "source": [ "def f(x): # 3. same object tagged with variable name x\n", " x[1] = 6 # 4. change value of element in same object\n", " \n", "#---------------------\n", "\n", "myx = [2,2] # 1. define list object tagged by variable name myx\n", "\n", "f(myx) # 2. call function: changes object, prints address\n", "\n", "print(myx) # 5. print values: list is still changed outside" ] } ], "metadata": { "celltoolbar": "Slideshow", "kernelspec": { "display_name": "base", "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.14.7" }, "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": 4 }