Skip to content

Instantly share code, notes, and snippets.

@samsol38

samsol38/python_class_15_06_24.ipynb

Last active July 6, 2024 14:50
Show Gist options
  • Save samsol38/bf220cae7c9bd12d8b38b2ae0abb95c6 to your computer and use it in GitHub Desktop.
Save samsol38/bf220cae7c9bd12d8b38b2ae0abb95c6 to your computer and use it in GitHub Desktop.
Download ZIP
python_class_15_06_24
Display the source blob
Display the rendered blob
Raw
python_class_15_06_24.ipynb
{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"provenance": []
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"language_info": {
"name": "python"
}
},
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"id": "Q2XnF3vOU7Mz",
"colab": {
"base_uri": "https://localhost:8080/"
},
"outputId": "2690432b-1060-4dec-c675-636b4ce5c7d5"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Requirement already satisfied: matplotlib-venn in /usr/local/lib/python3.10/dist-packages (0.11.10)\n",
"Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/dist-packages (from matplotlib-venn) (3.7.1)\n",
"Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from matplotlib-venn) (1.25.2)\n",
"Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (from matplotlib-venn) (1.11.4)\n",
"Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->matplotlib-venn) (1.2.1)\n",
"Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib->matplotlib-venn) (0.12.1)\n",
"Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->matplotlib-venn) (4.53.0)\n",
"Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->matplotlib-venn) (1.4.5)\n",
"Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->matplotlib-venn) (24.1)\n",
"Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->matplotlib-venn) (9.4.0)\n",
"Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->matplotlib-venn) (3.1.2)\n",
"Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib->matplotlib-venn) (2.8.2)\n",
"Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib->matplotlib-venn) (1.16.0)\n"
]
}
],
"source": [
"!pip install matplotlib-venn"
]
},
{
"cell_type": "markdown",
"source": [
"# Python Data Types\n",
"\n",
"| Datatype | Name | Sample Code | Output |\n",
"|------------|----------------|-------------------------|-----------------------|\n",
"| `int` | Integer | `x = 5` | `5` |\n",
"| `float` | Floating Point | `y = 3.14` | `3.14` |\n",
"| `str` | String | `name = \"Alice\"` | `\"Alice\"` |\n",
"| `bool` | Boolean | `is_valid = True` | `True` |\n",
"| `list` | List | `numbers = [1, 2, 3]` | `[1, 2, 3]` |\n",
"| `tuple` | Tuple | `coords = (10, 20)` | `(10, 20)` |\n",
"| `dict` | Dictionary | `person = {\"name\": \"Bob\", \"age\": 30}` | `{'name': 'Bob', 'age': 30}` |\n",
"| `set` | Set | `unique = {1, 2, 3}` | `{1, 2, 3}` |\n",
"| `frozenset`| Frozen Set | `frozen = frozenset([1, 2, 3])` | `frozenset({1, 2, 3})` |\n",
"| `NoneType` | None | `x = None` | `None` |\n"
],
"metadata": {
"id": "P89w6TAHc9lq"
}
},
{
"cell_type": "code",
"source": [],
"metadata": {
"id": "C55FS-p0bKLR"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"# Python Operators\n",
"\n",
"\n",
"| Operator | Name | Example |\n",
"|----------|-------------------------|-----------------------|\n",
"| `+` | Addition | `a + b` |\n",
"| `-` | Subtraction | `a - b` |\n",
"| `*` | Multiplication | `a * b` |\n",
"| `/` | Division | `a / b` |\n",
"| `%` | Modulus | `a % b` |\n",
"| `**` | Exponentiation | `a ** b` |\n",
"| `//` | Floor Division | `a // b` |\n",
"| `==` | Equal to | `a == b` |\n",
"| `!=` | Not equal to | `a != b` |\n",
"| `>` | Greater than | `a > b` |\n",
"| `<` | Less than | `a < b` |\n",
"| `>=` | Greater than or equal to| `a >= b` |\n",
"| `<=` | Less than or equal to | `a <= b` |\n",
"| `&` | Bitwise AND | `a & b` |\n",
"| `|` | Bitwise OR | `a | b` |\n",
"| `^` | Bitwise XOR | `a ^ b` |\n",
"| `~` | Bitwise NOT | `~a` |\n",
"| `<<` | Bitwise left shift | `a << b` |\n",
"| `>>` | Bitwise right shift | `a >> b` |\n",
"| `=` | Assignment | `a = b` |\n",
"| `+=` | Addition assignment | `a += b` |\n",
"| `-=` | Subtraction assignment | `a -= b` |\n",
"| `*=` | Multiplication assignment| `a *= b` |\n",
"| `/=` | Division assignment | `a /= b` |\n",
"| `%=` | Modulus assignment | `a %= b` |\n",
"| `//=` | Floor Division assignment| `a //= b` |\n",
"| `**=` | Exponentiation assignment| `a **= b` |\n",
"| `&=` | Bitwise AND assignment | `a &= b` |\n",
"| `|=` | Bitwise OR assignment | `a |= b` |\n",
"| `^=` | Bitwise XOR assignment | `a ^= b` |\n",
"| `>>=` | Bitwise right shift assignment | `a >>= b` |\n",
"| `<<=` | Bitwise left shift assignment | `a <<= b` |\n",
"| `and` | Logical AND | `a and b` |\n",
"| `or` | Logical OR | `a or b` |\n",
"| `not` | Logical NOT | `not a` |\n",
"| `in` | Membership | `a in b` |\n",
"| `not in` | Membership (negation) | `a not in b` |\n",
"| `is` | Identity | `a is b` |\n",
"| `is not` | Identity (negation) | `a is not b` |\n"
],
"metadata": {
"id": "54IVZoMYcOmX"
}
},
{
"cell_type": "code",
"source": [],
"metadata": {
"id": "UKLgdE9Kcn-k"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"import sys\n",
"\n",
"# Integer (`int`)\n",
"# In Python 3, the `int` type is of arbitrary precision.\n",
"# Therefore, there is no fixed range for integers.\n",
"# Check the size of an integer (platform dependent)\n",
"int_size = sys.maxsize\n",
"print(f\"Maximum size for an integer (platform dependent): {int_size}\")\n",
"\n",
"# Floating Point (`float`)\n",
"# The `float` type in Python is based on the IEEE 754 double-precision floating-point format.\n",
"# Typical range and precision:\n",
"# Range: Approximately 1.7e-308 to 1.7e+308\n",
"# Precision: 15-17 significant decimal digits\n",
"\n",
"# Check the maximum and minimum float values\n",
"max_float = sys.float_info.max\n",
"min_float = sys.float_info.min\n",
"epsilon_float = sys.float_info.epsilon\n",
"\n",
"print(f\"Maximum representable positive float: {max_float}\")\n",
"print(f\"Minimum positive normalized float: {min_float}\")\n",
"print(f\"Epsilon (difference between 1 and the least value greater than 1 that is representable): {epsilon_float}\")\n",
"\n",
"# Example usage of large integers (\n"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "m4Ju_iaIbzLz",
"outputId": "286100a3-928d-452e-e7fd-e5e5d8bd7e78"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Maximum size for an integer (platform dependent): 9223372036854775807\n",
"Maximum representable positive float: 1.7976931348623157e+308\n",
"Minimum positive normalized float: 2.2250738585072014e-308\n",
"Epsilon (difference between 1 and the least value greater than 1 that is representable): 2.220446049250313e-16\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"##### Python String Index Manipulation\n",
"##### (String Example: \"Hello World\")\n",
"\n",
"| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |\n",
"|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|\n",
"| H | e | l | l | o | | W | o | r | l | d |\n",
"\n",
"---\n",
"\n",
"| -11 | -10 | -9 | -8 | -7 | -6 | -5 | -4 | -3 | -2 | -1 |\n",
"|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----|\n",
"| H | e | l | l | o | | W | o | r | l | d |\n",
"\n",
"---\n",
"\n",
"| Format | Name | Sample Code | Output |\n",
"|-----------------|--------------------|----------------------------|--------------------|\n",
"| Slice | First two elements | `string[:2]` | `'He'` |\n",
"| Slice | Last two elements | `string[-2:]` | `'ld'` |\n",
"| Slice | Middle elements | `string[3:8]` | `'lo Wo'` |\n",
"| Slice | Every second element | `string[::2]` | `'HloWrd'` |\n",
"| Slice | Reverse string | `string[::-1]` | `'dlroW olleH'` |\n",
"| Single Index | First element | `string[0]` | `'H'` |\n",
"| Single Index | Last element | `string[-1]` | `'d'` |\n",
"| Single Index | Second to last element | `string[-2]` | `'l'` |\n",
"| Out of bounds | Non-existent index | `string[20]` | `IndexError` |\n",
"| Slice with step | Skip every second element | `string[1::2]` | `'el ol'` |\n",
"| Slice with step | Reverse every second element | `string[::-2]` | `'drWolH'` |\n",
"| Empty slice | Empty slice | `string[5:5]` | `''` |\n",
"| Whole list | Whole string | `string[:]` | `'Hello World'` |\n"
],
"metadata": {
"id": "OkrLNo5l6QJ4"
}
},
{
"cell_type": "code",
"source": [
"\n",
"file = open('/root/test.txt', 'w')\n",
"file.write(\"My name is test user.\")\n",
"file.writelines(\"Test user\")\n",
"file.close()"
],
"metadata": {
"id": "wU-BCuwA78MA"
},
"execution_count": null,
"outputs": []
},
{
"cell_type": "code",
"source": [
"pwd"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 36
},
"id": "tRzzxr_HDweM",
"outputId": "b3248bd4-e5d8-4c83-fc5c-5ece612a853c"
},
"execution_count": null,
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"'/content'"
],
"application/vnd.google.colaboratory.intrinsic+json": {
"type": "string"
}
},
"metadata": {},
"execution_count": 7
}
]
},
{
"cell_type": "code",
"source": [
"file = open('test.txt', 'r')\n",
"print(file.read())\n",
"file.close()"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "AxQZsPXgCJse",
"outputId": "2ab6ed37-7b3d-47ca-f650-8794c60a0186"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"My name is test user.Test user\n"
]
}
]
},
{
"cell_type": "markdown",
"source": [
"\n",
"\n",
"### Sample List\n",
"\n",
"```python\n",
"sample_list = [1, 2, 3, 4, 5]\n",
"```\n",
"\n",
"### Sample List Table\n",
"\n",
"| Index | 0 | 1 | 2 | 3 | 4 |\n",
"|---------|-----|-----|-----|-----|-----|\n",
"| Element | 1 | 2 | 3 | 4 | 5 |\n",
"\n",
"\n",
"### List Functions Cheatsheet\n",
"\n",
"| Function Name | Description | Code Example | Output |\n",
"|----------------|------------------------------------------------------------------------|----------------------------------------|-------------------------|\n",
"| `append()` | Adds an element to the end of the list. | `sample_list.append(6)` | `[1, 2, 3, 4, 5, 6]` |\n",
"| `extend()` | Extends the list by adding all elements from another list. | `sample_list.extend([7, 8])` | `[1, 2, 3, 4, 5, 6, 7, 8]` |\n",
"| `insert()` | Inserts an element at a specified position. | `sample_list.insert(1, 9)` | `[1, 9, 2, 3, 4, 5]` |\n",
"| `remove()` | Removes the first item with the specified value. | `sample_list.remove(2)` | `[1, 3, 4, 5]` |\n",
"| `pop()` | Removes and returns the element at the specified position. | `sample_list.pop(1)` | `2` (list becomes `[1, 3, 4, 5]`) |\n",
"| `clear()` | Removes all elements from the list. | `sample_list.clear()` | `[]` |\n",
"| `index()` | Returns the index of the first element with the specified value. | `sample_list.index(3)` | `2` |\n",
"| `count()` | Returns the number of elements with the specified value. | `sample_list.count(1)` | `1` |\n",
"| `sort()` | Sorts the list in ascending order. | `sample_list.sort()` | `[1, 2, 3, 4, 5]` |\n",
"| `reverse()` | Reverses the order of the list. | `sample_list.reverse()` | `[5, 4, 3, 2, 1]` |\n",
"| `copy()` | Returns a shallow copy of the list. | `new_list = sample_list.copy()` | `new_list` becomes `[1, 2, 3, 4, 5]` |\n"
],
"metadata": {
"id": "TUtgeelDKjgL"
}
},
{
"cell_type": "markdown",
"source": [],
"metadata": {
"id": "Qhi-A8DPPkzu"
}
},
{
"cell_type": "markdown",
"source": [
"### Sample Dictionary\n",
"\n",
"```python\n",
"sample_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}\n",
"```\n",
"### Sample Dictionary Table\n",
"\n",
"| Key | a | b | c | d | e |\n",
"|-------|-----|-----|-----|-----|-----|\n",
"| Value | 1 | 2 | 3 | 4 | 5 |\n",
"\n",
"### Dictionary Functions Cheatsheet\n",
"\n",
"| Function Name | Description | Code Example | Output |\n",
"|-------------------|------------------------------------------------------------------------|--------------------------------------------|-------------------------------|\n",
"| `clear()` | Removes all items from the dictionary. | `sample_dict.clear()` | `{}` |\n",
"| `copy()` | Returns a shallow copy of the dictionary. | `new_dict = sample_dict.copy()` | `new_dict` becomes `{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}` |\n",
"| `fromkeys()` | Creates a new dictionary from the given keys and value. | `dict.fromkeys(['a', 'b', 'c'], 0)` | `{'a': 0, 'b': 0, 'c': 0}` |\n",
"| `get()` | Returns the value for the specified key. | `sample_dict.get('a')` | `1` |\n",
"| `items()` | Returns a view object of the dictionary's key-value pairs. | `sample_dict.items()` | `dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)])` |\n",
"| `keys()` | Returns a view object of the dictionary's keys. | `sample_dict.keys()` | `dict_keys(['a', 'b', 'c', 'd', 'e'])` |\n",
"| `pop()` | Removes and returns the value for the specified key. | `sample_dict.pop('a')` | `1` (dictionary becomes `{'b': 2, 'c': 3, 'd': 4, 'e': 5}`) |\n",
"| `popitem()` | Removes and returns the last inserted key-value pair. | `sample_dict.popitem()` | `('e', 5)` (dictionary becomes `{'a': 1, 'b': 2, 'c': 3, 'd': 4}`) |\n",
"| `setdefault()` | Returns the value for the specified key. If the key does not exist, inserts the key with the specified value. | `sample_dict.setdefault('f', 6)` | `6` (dictionary becomes `{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}`) |\n",
"| `update()` | Updates the dictionary with the specified key-value pairs. | `sample_dict.update({'g': 7})` | `{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'g': 7}` |\n",
"| `values()` | Returns a view object of the dictionary's values. | `sample_dict.values()` | `dict_values([1, 2, 3, 4, 5])` |\n"
],
"metadata": {
"id": "LK6ruNr9Rjky"
}
},
{
"cell_type": "code",
"source": [
"import matplotlib.pyplot as plt\n",
"from matplotlib_venn import venn3, venn3_circles\n",
"\n",
"# Sample sets\n",
"set1 = {1, 2, 3, 4}\n",
"set2 = {3, 4, 5, 6}\n",
"set3 = {4, 5, 6, 7}\n",
"\n",
"# Calculate union of sets\n",
"union_set = set1.union(set2).union(set3)\n",
"\n",
"# Create a Venn diagram\n",
"venn_diagram = venn3([set1, set2, set3], ('Set 1\\n' + str(set1), 'Set 2\\n' + str(set2), 'Set 3\\n' + str(set3)))\n",
"\n",
"# Annotate sets with elements\n",
"venn_diagram.get_label_by_id('100').set_text('\\n'.join(map(str, set1 - (set2 | set3))))\n",
"venn_diagram.get_label_by_id('010').set_text('\\n'.join(map(str, set2 - (set1 | set3))))\n",
"venn_diagram.get_label_by_id('001').set_text('\\n'.join(map(str, set3 - (set1 | set2))))\n",
"venn_diagram.get_label_by_id('110').set_text('\\n'.join(map(str, (set1 & set2) - set3)))\n",
"venn_diagram.get_label_by_id('101').set_text('\\n'.join(map(str, (set1 & set3) - set2)))\n",
"venn_diagram.get_label_by_id('011').set_text('\\n'.join(map(str, (set2 & set3) - set1)))\n",
"venn_diagram.get_label_by_id('111').set_text('\\n'.join(map(str, set1 & set2 & set3)))\n",
"\n",
"# Add union set explicitly\n",
"venn_diagram.get_label_by_id('100').set_text(venn_diagram.get_label_by_id('100').get_text() + \"\\n\\nUnion:\\n\" + '\\n'.join(map(str, union_set)))\n",
"\n",
"# Add circle outlines for clarity\n",
"venn3_circles([set1, set2, set3], linestyle='dotted', linewidth=1, color='gray')\n",
"\n",
"# Add title\n",
"plt.title('Venn Diagram illustrating Union of 3 Sets')\n",
"\n",
"# Show the plot\n",
"plt.show()\n"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 485
},
"id": "ieuAhzQySD8e",
"outputId": "a26d32d2-d742-44f8-c874-4bad946291c1"
},
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stderr",
"text": [
"/usr/local/lib/python3.10/dist-packages/matplotlib_venn/_venn3.py:117: UserWarning: Bad circle positioning\n",
" warnings.warn(\"Bad circle positioning\")\n"
]
},
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
],
"image/png": "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\n"
},
"metadata": {}
}
]
}
]
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment