Skip to content

Instantly share code, notes, and snippets.

@vcma

vcma/functoolsTut.ipynb

Forked from nikhilkumarsingh/functoolsTut.ipynb
Created October 27, 2022 21:33
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save vcma/8ff3ad308fa115dcf312474ff8dde36b to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save vcma/8ff3ad308fa115dcf312474ff8dde36b to your computer and use it in GitHub Desktop.
Download ZIP
functools tutorial
Display the source blob
Display the rendered blob
Raw
functoolsTut.ipynb
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# functools tutorial\n",
"\n",
"https://docs.python.org/3/library/functools.html"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1. reduce\n",
"\n",
"```\n",
"1 2 3 4 5\n",
"3 3 4 5\n",
"6 4 5\n",
"10 5\n",
"15\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"from functools import reduce"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"15"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"reduce(lambda x,y: x+y, [1,2,3,4,5])"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"25"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"reduce(lambda x,y: x+y, [1,2,3,4,5], 10)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2. total_ordering"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"from functools import total_ordering"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"@total_ordering\n",
"class Car:\n",
" def __init__(self, model, mileage):\n",
" self.model = model\n",
" self.mileage = mileage\n",
" \n",
" def __eq__(self, other):\n",
" return self.mileage == other.mileage\n",
" \n",
" def __lt__(self, other):\n",
" return self.mileage < other.mileage"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"c1 = Car(\"Audi\", 700)\n",
"c2 = Car(\"BMW\", 800)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"c1 == c2"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"c1 < c2"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"c1 > c2"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"c1 <= c2"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"c1 >= c2"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3. cached_property"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"from functools import cached_property"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"class Marksheet:\n",
" def __init__(self, *grades):\n",
" self.grades = grades\n",
" \n",
" @cached_property\n",
" def total(self):\n",
" print(\"Calculating total.\")\n",
" return sum(self.grades)\n",
" \n",
" @cached_property\n",
" def average(self):\n",
" print(\"Calculating average.\")\n",
" return self.total/len(self.grades)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"m = Marksheet(100, 90, 95)"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Calculating total.\n"
]
},
{
"data": {
"text/plain": [
"285"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"m.total"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"285"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"m.total"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Calculating average.\n"
]
},
{
"data": {
"text/plain": [
"95.0"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"m.average"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"95.0"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"m.average"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 4. lru_cache"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [],
"source": [
"from functools import lru_cache"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
"@lru_cache\n",
"def fib(n):\n",
" if n < 2:\n",
" return n\n",
" print(f\"calculating fib {n}\")\n",
" return fib(n-1) + fib(n-2)"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"calculating fib 2\n",
"calculating fib 3\n",
"calculating fib 4\n",
"calculating fib 5\n",
"calculating fib 6\n",
"calculating fib 7\n",
"calculating fib 8\n",
"calculating fib 9\n"
]
},
{
"data": {
"text/plain": [
"[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[fib(x) for x in range(10)]"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"CacheInfo(hits=16, misses=10, maxsize=128, currsize=10)"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fib.cache_info()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 5. partial"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [],
"source": [
"from functools import partial"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [],
"source": [
"def add(a,b):\n",
" print(a,b)\n",
" return a + b\n",
"\n",
"\n",
"add_one = partial(add, 1)"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1 4\n"
]
},
{
"data": {
"text/plain": [
"5"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"add_one(4)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 6. wraps"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [],
"source": [
"from functools import wraps"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [],
"source": [
"def mylogger(func):\n",
" \n",
" @wraps(func)\n",
" def wrapper(*args, **kwargs):\n",
" print(f\"Running {func.__name__}\")\n",
" return func(*args, **kwargs)\n",
" return wrapper\n",
"\n",
"\n",
"@mylogger\n",
"def add(a,b):\n",
" \"\"\"add a and b\"\"\"\n",
" return a + b"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'add'"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"add.__name__"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'add a and b'"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"add.__doc__"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 7. singledispatch\n",
"\n",
"### Generic function\n",
"A function composed of multiple functions implementing the same operation for different types. Which implementation should be used during a call is determined by the dispatch algorithm.\n",
"\n",
"### Single dispatch\n",
"A form of generic function dispatch where the implementation is chosen based on the type of a single argument."
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [],
"source": [
"def append_one(obj):\n",
" if type(obj) == list:\n",
" return obj + [1]\n",
" elif type(obj) == set:\n",
" return obj.union({1})\n",
" elif type(obj) == str:\n",
" return obj + str(1)\n",
" else:\n",
" print(\"Unsupported type\")\n",
" return obj"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[1, 2, 3, 1]"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"append_one([1,2,3])"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{1, 2, 3}"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"append_one({1,2,3})"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'abcde1'"
]
},
"execution_count": 33,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"append_one(\"abcde\")"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [],
"source": [
"from functools import singledispatch"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [],
"source": [
"@singledispatch\n",
"def append_one(obj):\n",
" print(\"Unsupported type\")\n",
" return obj\n",
"\n",
"\n",
"@append_one.register\n",
"def _(obj: list):\n",
" return obj + [1]\n",
"\n",
"\n",
"@append_one.register\n",
"def _(obj: set):\n",
" return obj.union({1})\n",
"\n",
"\n",
"@append_one.register\n",
"def _(obj: str):\n",
" return obj + str(1)"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[1, 2, 3, 1]"
]
},
"execution_count": 36,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"append_one([1,2,3])"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{1, 2, 3}"
]
},
"execution_count": 37,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"append_one({1,2,3})"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'abcde1'"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"append_one(\"abcde\")"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Unsupported type\n"
]
},
{
"data": {
"text/plain": [
"{'a': 1}"
]
},
"execution_count": 39,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"append_one({\"a\": 1})"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "pyenv38",
"language": "python",
"name": "pyenv38"
},
"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.8.2"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment