Python is a duck typing language. It means the data types of variables can change as long as the syntax is compatible. Python is also a dynamic programming language. Meaning we can change the program while it runs, including defining new functions and the scope of name resolution. Not only these give us a new paradigm in writing Python code, but also a new set of tools for debugging. In the following, we will see what we can do in Python that cannot be done in many other languages. After finishing this tutorial you will know<\/p>\n
- \n
- How Python manages the variables you defined<\/li>\n
- How Python code uses a variable and why we don\u2019t need to define its type like C or Java<\/li>\n<\/ul>\n
Let\u2019s get started.<\/p>\n
\n![\"\"](\"https:\/\/machinelearningmastery.com\/wp-content\/uploads\/2022\/02\/pexels-julissa-helmuth-4381480-scaled.jpg\")
<\/p>\nDuck-typing, scope, and investigative functions in Python. Photo by Julissa Helmuth<\/a>. Some rights reserved<\/p>\n<\/div>\n
Overview<\/h2>\n
This tutorial is in three parts, they are<\/p>\n
- \n
- Duck typing in programming languages<\/li>\n
- Scopes and name space in Python<\/li>\n
- Investigating the type and scope<\/li>\n<\/ul>\n
Duck typing in programming languages<\/h2>\n
Duck typing is a feature of some modern programming languages that allow data types to be dynamic.<\/p>\n
\n
A programming style which does not look at an object\u2019s type to determine if it has the right interface; instead, the method or attribute is simply called or used (\u201cIf it looks like a duck and quacks like a duck, it must be a duck.\u201d) By emphasizing interfaces rather than specific types, well-designed code improves its flexibility by allowing polymorphic substitution.<\/p>\n<\/blockquote>\n
\u2014 Python Glossary<\/a><\/p>\n
Simply speaking, the program should allow you to swap data structures as long as the same syntax still makes sense. In C, for example, you have to define functions like the following<\/p>\n
float fsquare(float x)\r\n{\r\n return x * x;\r\n};\r\n\r\nint isquare(int x)\r\n{\r\n return x * x;\r\n};<\/pre>\nwhile the operation\u00a0
x * x<\/code>\u00a0is identical for integers and floating point numbers, a function taking an integer argument and a function taking a floating point argument are not the same. Because types are static in C, we must define two functions although they are performing the same logic. In Python, types are dynamic, hence we can define the corresponding function as<\/p>\ndef square(x):\r\n return x * x<\/pre>\n
This feature indeed gives us tremendous power and convenience. For example, from scikit-learn, we have a function to do cross validation<\/p>\n
# evaluate a perceptron model on the dataset\r\nfrom numpy import mean\r\nfrom numpy import std\r\nfrom sklearn.datasets import make_classification\r\nfrom sklearn.model_selection import cross_val_score\r\nfrom sklearn.model_selection import RepeatedStratifiedKFold\r\nfrom sklearn.linear_model import Perceptron\r\n# define dataset\r\nX, y = make_classification(n_samples=1000, n_features=10, n_informative=10, n_redundant=0, random_state=1)\r\n# define model\r\nmodel = Perceptron()\r\n# define model evaluation method\r\ncv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)\r\n# evaluate model\r\nscores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1)\r\n# summarize result\r\nprint('Mean Accuracy: %.3f (%.3f)' % (mean(scores), std(scores)))<\/pre>\nBut in the above, the\u00a0
model<\/code>\u00a0is a variable of a scikit-learn model object. It doesn\u2019t matter if it is a perceptron model as in the above, or a decision tree, or a support vector machine model. What matters is that, inside\u00a0cross_val_score()<\/code>\u00a0function the data will be passed onto the model with its\u00a0fit()<\/code>\u00a0function. Therefore the model must implement the\u00a0fit()<\/code>\u00a0member function and the\u00a0fit()<\/code>\u00a0function behaves identically. The consequence is that,\u00a0cross_val_score()<\/code>\u00a0function is not expecting any particular model type as long as it looks like one. If we are using Keras to build a neural network model, we can make the Keras model looks like a scikit-learn model with a wrapper:<\/p>\n# MLP for Pima Indians Dataset with 10-fold cross validation via sklearn\r\nfrom keras.models import Sequential\r\nfrom keras.layers import Dense\r\nfrom keras.wrappers.scikit_learn import KerasClassifier\r\nfrom sklearn.model_selection import StratifiedKFold\r\nfrom sklearn.model_selection import cross_val_score\r\nfrom sklearn.datasets import load_diabetes\r\nimport numpy\r\n\r\n# Function to create model, required for KerasClassifier\r\ndef create_model():\r\n\t# create model\r\n\tmodel = Sequential()\r\n\tmodel.add(Dense(12, input_dim=8, activation='relu'))\r\n\tmodel.add(Dense(8, activation='relu'))\r\n\tmodel.add(Dense(1, activation='sigmoid'))\r\n\t# Compile model\r\n\tmodel.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\r\n\treturn model\r\n\r\n# fix random seed for reproducibility\r\nseed = 7\r\nnumpy.random.seed(seed)\r\n# load pima indians dataset\r\ndataset = numpy.loadtxt(\"https:\/\/raw.githubusercontent.com\/jbrownlee\/Datasets\/master\/pima-indians-diabetes.csv\", delimiter=\",\")\r\n# split into input (X) and output (Y) variables\r\nX = dataset[:,0:8]\r\nY = dataset[:,8]\r\n# create model\r\nmodel = KerasClassifier(build_fn=create_model, epochs=150, batch_size=10, verbose=0)\r\n# evaluate using 10-fold cross validation\r\nkfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)\r\nresults = cross_val_score(model, X, Y, cv=kfold)\r\nprint(results.mean())<\/pre>\n
In the above, we used the wrapper from Tensorflow. Other wrappers exist, such as scikeras. All it does is to make sure the\u00a0interface<\/strong>\u00a0of Keras model looks like a scikit-learn classifier so you can make use of the\u00a0
cross_val_score()<\/code>\u00a0function. If we replace the\u00a0model<\/code>\u00a0above with<\/p>\n<span class=\"cm-variable\">model<\/span> <span class=\"cm-operator\">=<\/span> <span class=\"cm-variable\">create_model<\/span>()<\/pre>\n
then the scikit-learn function will complain as it cannot find the\u00a0
model.score()<\/code>\u00a0function.<\/p>\nSimilarly, because of duck typing, we can reuse a function that expects a list for NumPy array or pandas series because they all supports the same indexing and slicing operation. For example, the fitting a time series with ARIMA as follows:<\/p>\n
from statsmodels.tsa.statespace.sarimax import SARIMAX\r\nimport numpy as np\r\nimport pandas as pd\r\n\r\ndata = [266.0,145.9,183.1,119.3,180.3,168.5,231.8,224.5,192.8,122.9,336.5,185.9,\r\n 194.3,149.5,210.1,273.3,191.4,287.0,226.0,303.6,289.9,421.6,264.5,342.3,\r\n 339.7,440.4,315.9,439.3,401.3,437.4,575.5,407.6,682.0,475.3,581.3,646.9]\r\nmodel = SARIMAX(y, order=(5,1,0))\r\nres = model.fit(disp=False)\r\nprint(\"AIC = \", res.aic)\r\n\r\ndata = np.array(data)\r\nmodel = SARIMAX(y, order=(5,1,0))\r\nres = model.fit(disp=False)\r\nprint(\"AIC = \", res.aic)\r\n\r\ndata = pd.Series(data)\r\nmodel = SARIMAX(y, order=(5,1,0))\r\nres = model.fit(disp=False)\r\nprint(\"AIC = \", res.aic)<\/pre>\n
The above should produce the same AIC scores for each fitting.<\/p>\n
Scopes and name space in Python<\/h2>\n
In most languages, variables are defined in a limited scope. For example, a variable defined inside a function is accessible only inside that function:<\/p>\n
from math import sqrt\r\n\r\ndef quadratic(a,b,c):\r\n discrim = b*b - 4*a*c\r\n x = -b\/(2*a)\r\n y = sqrt(discrim)\/(2*a)\r\n return x-y, x+y<\/pre>\n
the\u00a0local variable<\/strong>\u00a0
discrim<\/code>\u00a0is no way to be accessible if we are not inside the function\u00a0quadratic()<\/code>. Moreover, this may be surprising for someone:<\/p>\na = 1\r\n\r\ndef f(x):\r\n a = 2 * x\r\n return a\r\n\r\nb = f(3)\r\nprint(a, b)<\/pre>\n<\/p>\n
1 6<\/pre>\n
We defined the variable\u00a0
a<\/code>\u00a0outside function\u00a0f<\/code>\u00a0but inside\u00a0f<\/code>, variable\u00a0a<\/code>\u00a0is assigned to be\u00a02 * x<\/code>. However, the\u00a0a<\/code>\u00a0inside function and the one outside are unrelated except the name. Therefore, as we exit from the function, the value of\u00a0a<\/code>\u00a0is untouched. To make it modifiable inside function\u00a0f<\/code>, we need to declare the name\u00a0a<\/code>\u00a0as\u00a0global<\/code>\u00a0so to make it clear that this name should be from the\u00a0global scope<\/strong>\u00a0not the\u00a0local scope<\/strong>:<\/p>\na = 1\r\n\r\ndef f(x):\r\n global a\r\n a = 2 * x\r\n return a\r\n\r\nb = f(3)\r\nprint(a, b)<\/pre>\n<\/p>\n
6 6<\/pre>\n
However, we may further complicated the issue when we introduced the\u00a0nested scope<\/strong>\u00a0in functions. Consider the following example:<\/p>\n
a = 1\r\n\r\ndef f(x):\r\n a = x\r\n def g(x):\r\n return a * x\r\n return g(3)\r\n\r\nb = f(2)\r\nprint(b)<\/pre>\n<\/p>\n
6<\/pre>\n
The variable\u00a0
a<\/code>\u00a0inside function\u00a0f<\/code>\u00a0is distinct from the global one. However, when inside\u00a0g<\/code>, since there is never anything written to\u00a0a<\/code>\u00a0but merely read from it, Python will see the same\u00a0a<\/code>\u00a0from the nearest scope, i.e., from function\u00a0f<\/code>. The variablex<\/code> however, is defined as argument to the functiong<\/code> and it takes the value3<\/code> when we calledg(3)<\/code> instead of assuming the value ofx<\/code> from functionf<\/code>.<\/p>\nNOTE:<\/strong>\u00a0If a variable has any value assigned to it\u00a0anywhere<\/strong>\u00a0in the function, it is defined in the local scope. And if that variable has its value read from it before the assignment, an error is raised rather than using the value from the variable of the same name from the outer or global scope.<\/p>\n
This property has many uses. Many implementations of memoization decorators in Python make clever use of the function scopes. Another example is the following:<\/p>\n
import numpy as np\r\n\r\ndef datagen(X, y, batch_size, sampling_rate=0.7):\r\n \"\"\"A generator to produce samples from input numpy arrays X and y\r\n \"\"\"\r\n # Select rows from arrays X and y randomly\r\n indexing = np.random.random(len(X)) < sampling_rate\r\n Xsam, ysam = X[indexing], y[indexing]\r\n\r\n # Actual logic to generate batches\r\n def _gen(batch_size):\r\n while True:\r\n Xbatch, ybatch = [], []\r\n for _ in range(batch_size):\r\n i = np.random.randint(len(Xsam))\r\n Xbatch.append(Xsam[i])\r\n ybatch.append(ysam[i])\r\n yield np.array(Xbatch), np.array(ybatch)\r\n \r\n # Create and return a generator\r\n return _gen(batch_size)<\/pre>\n
This is a\u00a0generator function<\/strong>\u00a0that creates batches of samples from the input numpy arrays\u00a0
X<\/code>\u00a0and\u00a0y<\/code>. Such generator is acceptable by Keras models in their training. However, for reasons such as cross validation, we do not want to sample from the entire input arrays\u00a0X<\/code>\u00a0and\u00a0y<\/code>\u00a0but a\u00a0fixed<\/strong>\u00a0subset of rows from them. The way we do it is to randomly select a portion of rows at the beginning of the\u00a0datagen()<\/code>\u00a0function and keep them in\u00a0Xsam<\/code>,\u00a0ysam<\/code>. Then in the inner function\u00a0_gen()<\/code>, rows are sampled from\u00a0Xsam<\/code>\u00a0and\u00a0ysam<\/code>\u00a0until a batch is created. While the lists\u00a0Xbatch<\/code>\u00a0and\u00a0ybatch<\/code>\u00a0are defined and created inside function\u00a0_gen()<\/code>, the arrays\u00a0Xsam<\/code>\u00a0and\u00a0ysam<\/code>\u00a0are not local to\u00a0_gen()<\/code>. What\u2019s more interesting is when the generator is created:<\/p>\nX = np.random.random((100,3))\r\ny = np.random.random(100)\r\n\r\ngen1 = datagen(X, y, 3)\r\ngen2 = datagen(X, y, 4)\r\nprint(next(gen1))\r\nprint(next(gen2))<\/pre>\n<\/p>\n
(array([[0.89702235, 0.97516228, 0.08893787],\r\n [0.26395301, 0.37674529, 0.1439478 ],\r\n [0.24859104, 0.17448628, 0.41182877]]), array([0.2821138 , 0.87590954, 0.96646776]))\r\n(array([[0.62199772, 0.01442743, 0.4897467 ],\r\n [0.41129379, 0.24600387, 0.53640666],\r\n [0.02417213, 0.27637708, 0.65571031],\r\n [0.15107433, 0.11331674, 0.67000849]]), array([0.91559533, 0.84886957, 0.30451455, 0.5144225 ]))<\/pre>\n
The function\u00a0
datagen()<\/code>\u00a0is called two times and therefore two different sets of\u00a0Xsam<\/code>,\u00a0ysam<\/code>\u00a0are created. But since the inner function\u00a0_gen()<\/code>\u00a0depends on them, these two sets of\u00a0Xsam<\/code>,\u00a0ysam<\/code>\u00a0are in memory concurrently. Technically, we say that when\u00a0datagen()<\/code>\u00a0is called, a\u00a0closure<\/strong>\u00a0is created with the specific\u00a0Xsam<\/code>,\u00a0ysam<\/code>\u00a0defined within, and the call to\u00a0_gen()<\/code>\u00a0is accessing that closure. In other words, the scopes of the two incarnation of\u00a0datagen()<\/code>\u00a0calls coexists.<\/p>\nIn summary, whenever a line of code references to a name (whether it is a variable, a function, or a module), the name is resolved in the order of LEGB rule:<\/p>\n
- \n
- Local scope first, i.e., those name that defined in the same function<\/li>\n
- Enclosure, or called the \u201cnonlocal\u201d scope. That\u2019s the upper level function if we are inside the nested function<\/li>\n
- Global scope, i.e., those that defined in the top level of the same script (but not across different program files)<\/li>\n
- Built-in scope, i.e., those created by Python automatically, such as the variable
__name__<\/code> or functionslist()<\/code>\n<\/li>\n<\/ol>\nInvestigating the type and scope<\/h2>\n
Because the types are not static in Python, sometimes we would like to know what we are dealing with but it is not trivial to tell from the code. One way to tell is using the\u00a0
type()<\/code>\u00a0or\u00a0isinstance()<\/code>\u00a0functions. For example:<\/p>\nimport numpy as np\r\n\r\nX = np.random.random((100,3))\r\nprint(type(X))\r\nprint(isinstance(X, np.ndarray))<\/pre>\n<\/p>\n
<class 'numpy.ndarray'>\r\nTrue<\/pre>\n
The\u00a0
type()<\/code>\u00a0function returns a type object. The\u00a0isinstance()<\/code>\u00a0function returns a boolean that allows us to check if something matches a particular type. These are useful in case we need to know what type a variable is. This is useful if we are debugging a code. For example, if we pass on a pandas dataframe to the\u00a0datagen()<\/code>\u00a0function that we defined above:<\/p>\nimport pandas as pd\r\nimport numpy as np\r\n\r\ndef datagen(X, y, batch_size, sampling_rate=0.7):\r\n \"\"\"A generator to produce samples from input numpy arrays X and y\r\n \"\"\"\r\n # Select rows from arrays X and y randomly\r\n indexing = np.random.random(len(X)) < sampling_rate\r\n Xsam, ysam = X[indexing], y[indexing]\r\n\r\n # Actual logic to generate batches\r\n def _gen(batch_size):\r\n while True:\r\n Xbatch, ybatch = [], []\r\n for _ in range(batch_size):\r\n i = np.random.randint(len(Xsam))\r\n Xbatch.append(Xsam[i])\r\n ybatch.append(ysam[i])\r\n yield np.array(Xbatch), np.array(ybatch)\r\n \r\n # Create and return a generator\r\n return _gen(batch_size)\r\n\r\nX = pd.DataFrame(np.random.random((100,3)))\r\ny = pd.DataFrame(np.random.random(100))\r\n\r\ngen3 = datagen(X, y, 3)\r\nprint(next(gen3))<\/pre>\n
Running the above code under the Python\u2019s debugger\u00a0
pdb<\/code>\u00a0will give the following:<\/p>\n> \/Users\/MLM\/ducktype.py(1)<module>()\r\n-> import pandas as pd\r\n(Pdb) c\r\nTraceback (most recent call last):\r\n File \"\/usr\/local\/lib\/python3.9\/site-packages\/pandas\/core\/indexes\/range.py\", line 385, in get_loc\r\n return self._range.index(new_key)\r\nValueError: 1 is not in range\r\n\r\nThe above exception was the direct cause of the following exception:\r\n\r\nTraceback (most recent call last):\r\n File \"\/usr\/local\/Cellar\/python@3.9\/3.9.9\/Frameworks\/Python.framework\/Versions\/3.9\/lib\/python3.9\/pdb.py\", line 1723, in main\r\n pdb._runscript(mainpyfile)\r\n File \"\/usr\/local\/Cellar\/python@3.9\/3.9.9\/Frameworks\/Python.framework\/Versions\/3.9\/lib\/python3.9\/pdb.py\", line 1583, in _runscript\r\n self.run(statement)\r\n File \"\/usr\/local\/Cellar\/python@3.9\/3.9.9\/Frameworks\/Python.framework\/Versions\/3.9\/lib\/python3.9\/bdb.py\", line 580, in run\r\n exec(cmd, globals, locals)\r\n File \"<string>\", line 1, in <module>\r\n File \"\/Users\/MLM\/ducktype.py\", line 1, in <module>\r\n import pandas as pd\r\n File \"\/Users\/MLM\/ducktype.py\", line 18, in _gen\r\n ybatch.append(ysam[i])\r\n File \"\/usr\/local\/lib\/python3.9\/site-packages\/pandas\/core\/frame.py\", line 3458, in __getitem__\r\n indexer = self.columns.get_loc(key)\r\n File \"\/usr\/local\/lib\/python3.9\/site-packages\/pandas\/core\/indexes\/range.py\", line 387, in get_loc\r\n raise KeyError(key) from err\r\nKeyError: 1\r\nUncaught exception. Entering post mortem debugging\r\nRunning 'cont' or 'step' will restart the program\r\n> \/usr\/local\/lib\/python3.9\/site-packages\/pandas\/core\/indexes\/range.py(387)get_loc()\r\n-> raise KeyError(key) from err\r\n(Pdb)<\/pre>\n
We see from the traceback that something is wrong because we cannot get\u00a0
ysam[i]<\/code>. We can use the following to verify that\u00a0ysam<\/code>\u00a0is indeed a Pandas DataFrame instead of a NumPy array:<\/p>\n(Pdb) up\r\n> \/usr\/local\/lib\/python3.9\/site-packages\/pandas\/core\/frame.py(3458)__getitem__()\r\n-> indexer = self.columns.get_loc(key)\r\n(Pdb) up\r\n> \/Users\/MLM\/ducktype.py(18)_gen()\r\n-> ybatch.append(ysam[i])\r\n(Pdb) type(ysam)\r\n<class 'pandas.core.frame.DataFrame'><\/pre>\n
Therefore we cannot use\u00a0
ysam[i]<\/code>\u00a0to select row\u00a0i<\/code>\u00a0from\u00a0ysam<\/code>. Now in the debugger, what can we do to verify how should we modify our code? There are several useful functions you can use to investigate the variables and the scope:<\/p>\n- \n
- \n
dir()<\/code>\u00a0to see the names defined in the scope or the attributes defined in an object<\/li>\n- \n
locals()<\/code>\u00a0and\u00a0globals()<\/code>\u00a0to see the names and values defined locally and globally, respectively.<\/li>\n<\/ul>\nFor example, we can use\u00a0
dir(ysam)<\/code>\u00a0to see what attributes or functions are defined inside\u00a0ysam<\/code>:<\/p>\n(Pdb) dir(ysam)\r\n['T', '_AXIS_LEN', '_AXIS_ORDERS', '_AXIS_REVERSED', '_AXIS_TO_AXIS_NUMBER', \r\n...\r\n'iat', 'idxmax', 'idxmin', 'iloc', 'index', 'infer_objects', 'info', 'insert',\r\n'interpolate', 'isin', 'isna', 'isnull', 'items', 'iteritems', 'iterrows',\r\n'itertuples', 'join', 'keys', 'kurt', 'kurtosis', 'last', 'last_valid_index',\r\n...\r\n'transform', 'transpose', 'truediv', 'truncate', 'tz_convert', 'tz_localize',\r\n'unstack', 'update', 'value_counts', 'values', 'var', 'where', 'xs']\r\n(Pdb)<\/pre>\n
Some of these are attributes, such as\u00a0
shape<\/code>, and some of these are functions, such as\u00a0describe()<\/code>. You can read the attribute or invoke the function in\u00a0pdb<\/code>. By carefully reading this output, we recalled that the way to read row\u00a0i<\/code>\u00a0from a DataFrame is through\u00a0iloc<\/code>\u00a0and hence we can verify the syntax with:<\/p>\n(Pdb) ysam.iloc[i]\r\n0 0.83794\r\nName: 2, dtype: float64\r\n(Pdb)<\/pre>\n
If we call\u00a0
dir()<\/code>\u00a0without any argument, it gives you all the names defined in the current scope, e.g.,<\/p>\n(Pdb) dir()\r\n['Xbatch', 'Xsam', '_', 'batch_size', 'i', 'ybatch', 'ysam']\r\n(Pdb) up\r\n> \/Users\/MLM\/ducktype.py(1)<module>()\r\n-> import pandas as pd\r\n(Pdb) dir()\r\n['X', '__builtins__', '__file__', '__name__', 'datagen', 'gen3', 'np', 'pd', 'y']\r\n(Pdb)<\/pre>\n
which the scope changes as you move around the call stack. Similar to\u00a0
dir()<\/code>\u00a0without argument, we can call\u00a0locals()<\/code>\u00a0to show all locally defined variables, e.g.,<\/p>\n(Pdb) locals()\r\n{'batch_size': 3, 'Xbatch': ...,\r\n 'ybatch': ..., '_': 0, 'i': 1, 'Xsam': ...,\r\n 'ysam': ...}\r\n(Pdb)<\/pre>\nIndeed\u00a0
locals()<\/code>\u00a0returns you a\u00a0dict<\/code>\u00a0that allows you to see all the names and values. Therefore if we need to read the variable\u00a0Xbatch<\/code>, we can get the same with\u00a0locals()[\"Xbatch\"]<\/code>. Similarly, we can use\u00a0globals()<\/code>\u00a0to get a dictionary of names defined in the global scope.<\/p>\nThis technique is beneficial sometimes. For example, we can check if a Keras model is \u201ccompiled\u201d or not by using\u00a0
dir(model)<\/code>. In Keras, compiling a model is to set up the loss function for training and build the flow for forward and backward propagations. Therefore, a compiled model will have an extra attribute\u00a0loss<\/code>\u00a0defined:<\/p>\nfrom tensorflow.keras import Sequential\r\nfrom tensorflow.keras.layers import Dense\r\n\r\nmodel = Sequential([\r\n Dense(5, input_shape=(3,)),\r\n Dense(1)\r\n])\r\n\r\nhas_loss = \"loss\" in dir(model)\r\nprint(\"Before compile, loss function defined:\", has_loss)\r\n\r\nmodel.compile()\r\nhas_loss = \"loss\" in dir(model)\r\nprint(\"After compile, loss function defined:\", has_loss)<\/pre>\n<\/p>\n
Before compile, loss function defined: False\r\nAfter compile, loss function defined: True<\/pre>\n
This allows us to put extra guard on our code before we run into error.<\/p>\n
Further reading<\/h2>\n
This section provides more resources on the topic if you are looking to go deeper.<\/p>\n
Articles<\/h4>\n
- \n
- Duck typing,\u00a0https:\/\/en.wikipedia.org\/wiki\/Duck_typing<\/a>\n<\/li>\n
- Python Glossary (Duck-typing),\u00a0https:\/\/docs.python.org\/3\/glossary.html#term-duck-typing<\/a>\n<\/li>\n
- Python built-in functions,\u00a0https:\/\/docs.python.org\/3\/library\/functions.html<\/a>\n<\/li>\n<\/ul>\n
Books<\/h4>\n
- \n
- Fluent Python, second edition, by Luciano Ramalho,\u00a0https:\/\/www.amazon.com\/dp\/1492056359\/<\/a>\n<\/li>\n<\/ul>\n
Summary<\/h2>\n
In this tutorial, you\u2019ve see how Python organize the naming scopes and how variables are interacting with the code. Specifically, you learned<\/p>\n
- \n
- Python code uses variables through their interfaces, therefore variables\u2019 data type is usually unimportant<\/li>\n
- Python variables are defined in their naming scope or closure, which variables of the same name can coexist in different scopes so they are not interfering each other<\/li>\n
- We have some built-in functions from Python to allow us to examine the names defined in the current scope or the data type of a variable<\/li>\n<\/ul>\n
The post Duck-typing, scope, and investigative functions in Python<\/a> appeared first on Machine Learning Mastery<\/a>.<\/p>\n<\/div>\n
Go to Source<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
- Python Glossary (Duck-typing),\u00a0https:\/\/docs.python.org\/3\/glossary.html#term-duck-typing<\/a>\n<\/li>\n
- \n
- \n