first draft of the intro to python lessons

Author: ProbablyComputingSquid

.idea/.gitignore

@@ -0,0 +1,315 @@
+{
+ "cells": [
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "# Introduction to Python!\n",
+    "In today's lesson, we will be discussing the following questions: What is Python? How do I use it, and more importantly, why should I use it?\n",
+    "\n",
+    "Python is a high level programming language, meaning that you are dealing more with concepts and ideas rather than manipulating the bits and bytes of a computer. This makes it an easy language for beginners, and when coupled with its intuitive syntax is a great language for people first learning how to code. But fear not, for if you are not a beginner, Python is popularly used in real-life professions, ranging from ML/Data Analysis to mathematics and developing desktop applications.\n",
+    "\n",
+    "Python is designed to be easy to read and write, which makes it a great language for beginners. It does away with curly braces and semicolons, and instead uses indentation and whitespace to define code blocks. This makes it easier to read and understand, especially for those who are new to programming. For this set of lessons, we will be using Python 3, which is the latest version of the language. Although Python 2 is still in use in some legacy systems, it only receives security patches.\n",
+    "\n",
+    "## Your First Python Script\n",
+    "\n",
+    "For now, let's start with the basics. The first \"tool\" under your toolbelt will be printing output to the console. While you will not find a lot of command-line applications for popular use written in Python (except tools for other developers!), printing is still an essential tool for debugging your programs and in the first stages of development. To print to the console, type (or run the following code cell):\n",
+    "\n"
+   ],
+   "id": "5cfc0bb57c4e4fb9"
+  },
+  {
+   "metadata": {
+    "collapsed": true
+   },
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": "print(\"Hello, World!\")",
+   "id": "initial_id"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "Wonderful! You have just written your first Python script. Well, I actually wrote it. Let's take the magnifying glass to this code. The `print` function is a built-in function in Python that takes in a string (a sequence of characters) and outputs it to the console. The string is enclosed in quotation marks, which tells Python that it is a string and not a variable or some other type of data. Now, let's try printing something of your choice. Run the following code cell, replacing the text in quotation marks with some text of your choosing.",
+   "id": "f97b19198e4677fd"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": "print(\"I'm lazy and can't change this small block of text!\")",
+   "id": "1f40c56b228dc899"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "## Python syntax\n",
+    "\n",
+    "As mentioned earlier, Python relies strongly on indentation and whitespace to define code blocks. For an example, we will be using `if` statements, which we will be discussing in more detail later. An `if` statement is a conditional statement that allows you to execute a block of code only if a certain condition is met. Here is an example of an `if` statement in Python:"
+   ],
+   "id": "b1031d38b70e2065"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "if 2 + 2 > 3:\n",
+    "    print(\"1 + 1 is greater than 3\")"
+   ],
+   "id": "54b20809fb8db9df"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "This indentation is crucial in Python, as it tells the interpreter which lines of code belong to the `if` statement. In this case, the line `print(\"1 + 1 is greater than 3\")` is indented, which means that it will only be executed if the condition `2 + 2 > 3` is true. If we were to remove the indentation, we would get an error. Try it out by running the following code cell:",
+   "id": "bdee50a075aa5335"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "if 1 + 1 > 3:\n",
+    "print(\"1 + 1 is greater than 3\")"
+   ],
+   "id": "13574443eb9907fa"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "Removing the indentation means that a line no longer belongs to the `if` statement, and thus will always be executed. However, since Python expects an indented block after the `if` statement, it raises an `IndentationError`. This is a common mistake for beginners, so be sure to always check your indentation when writing Python code.\n",
+    "This following code cell is an example of correct indentation. Run it to see that it works."
+   ],
+   "id": "408b27d45c29e58a"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "if 1 + 1 > 3:\n",
+    "    print(\"1 + 1 is greater than 3\")\n",
+    "print(\"This line is not indented, so it will always be executed.\")"
+   ],
+   "id": "8e23c5c5a5850055"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "## Variables in Python\n",
+    "\n",
+    "Variables are a way to store data in Python. They allow you to give a value a name, which you can then use to refer to that value later. It's also a great way to make your code more readable and maintainable, as you can store user data in variables and use them throughout your code. In Python, you can create a variable by simply assigning a value to it using the `=` operator. For example, you can create a variable called `x` and assign it the value of `5` like this:"
+   ],
+   "id": "8454f87370a3242d"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-08-12T15:10:22.174124Z",
+     "start_time": "2025-08-12T15:10:22.153190Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "x = 5\n",
+    "print(x)\n",
+    "pi = 3.1415962\n",
+    "print(\"I love \" + str(pi))"
+   ],
+   "id": "695b335ef1c2d239",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "5\n",
+      "I love 3.1415962\n"
+     ]
+    }
+   ],
+   "execution_count": 2
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "As you can see below, I'm naming variables using the `snake_case` convention (haha, because its Python, which is a snake). This means that you use lowercase letters and underscores to separate words in a variable name. For example, `my_variable` is a valid variable name, while `MyVariable` is not. This is just a convention, but it helps make your code more readable and consistent.\n",
+    "\n",
+    "You can also create variables that store strings, which are sequences of characters. You can store all sorts of things other than strings and numbers, like booleans (true/false), objects, or functions! For now, let's create a variable called `name` and assign it the value of `\"John\"` like this:"
+   ],
+   "id": "e9120204536ff49f"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "his_name = \"John\"\n",
+    "print(\"His name is \" + his_name)"
+   ],
+   "id": "386473072062d87b"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "Now, try creating your own variables and printing them out. How about you make a few variables that store your `name`, `age`, and `favorite_icecream_flavor`? Then print out a sentence that includes them all!\n",
+    "###### _A little tip: Just remember to use the `+` operator to concatenate strings, and use `str()` to convert non-string variables to strings when necessary. In Python, you cannot add a string and a number together, because they are different data types. If you try to do that, you will get a `TypeError`._\n"
+   ],
+   "id": "37cd9ed0e9ca1cc3"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "",
+   "id": "9e23604b2828ea85"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": "## Your turn :3",
+   "id": "7a37bd8062631e39"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "### Types in Python",
+   "id": "a9646bc085e9b372"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "Here's a list of the different types a variable can be in python. Each type has its own characteristics and uses, so it's important to understand them when writing Python code.\n",
+    "- Text Type: `str` (string, a sequence of characters)\n",
+    "- Numeric Types: `int`, `float`, `complex` (whole numbers, decimal numbers, and complex numbers)\n",
+    "- Sequence Types: `list`, `tuple`, `range` (ordered collections of items)\n",
+    "  - `list`: mutable (can be changed), ordered collection of items\n",
+    "  - `tuple`: immutable (cannot be changed), ordered collection of items\n",
+    "  - `range`: represents a sequence of numbers, often used in loops\n",
+    "- Mapping Type: `dict` (key-value pairs)\n",
+    "- Set Types: `set`, `frozenset` (unordered collections of unique items)\n",
+    "  - `set`: mutable (can be changed), unordered collection of unique items\n",
+    "  - `frozenset`: immutable (cannot be changed), unordered collection of unique items\n",
+    "- Boolean Type: `bool` (`True`/`False`)\n",
+    "- Binary Types: `bytes`, `bytearray`, `memoryview` (we will not be covering these)\n",
+    "- None Type: `NoneType` (`None`, used to represent the absence of a value)\n",
+    "\n",
+    "If you ever want to check the type of a variable, you can use the `type()` function. For example:"
+   ],
+   "id": "34cedd8a8575b74b"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "print(type(5))  # This will print <class 'int'>\n",
+    "print(type(\"3.14\"))  # This will print <class 'str'>"
+   ],
+   "id": "84cf565e5b64f5ab"
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "If you want to change the type of a variable, you can use type conversion functions like `int()`, `float()`, and `str()`. However, not all conversions will work. You cannot turn the sentence `\"Reggie the Regent\"` into a number (although it would probably be 1, because West is the Best).\n",
+    "For example of type conversion, you can convert a string to an integer like this:"
+   ],
+   "id": "e63d1426ca778288"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-08-14T16:46:31.590578Z",
+     "start_time": "2025-08-14T16:46:31.586635Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "print(int(\"5\"))  # This will print 5 as an integer\n",
+    "print(type(int(\"5\"))) # This will print <class 'type'>, which is the type of the int class itself"
+   ],
+   "id": "29b4d8bb4505105f",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "5\n",
+      "<class 'int'>\n"
+     ]
+    }
+   ],
+   "execution_count": 4
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": [
+    "## Comments in Python\n",
+    "\n",
+    "Comments are like adding notes to your code, just like how my English teacher marks up my essays for grammar mistakes! They are not executed by the interpreter, but they can be very useful for explaining what your code does or for leaving reminders for yourself. You can also \"comment out\" code that you don't want to run.\n",
+    "In Python, you can create a comment by using the `#` symbol. For example:"
+   ],
+   "id": "eedd4c11032bb426"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "# The following code prints out 2\n",
+    "print (1 + 1)"
+   ],
+   "id": "3f44a0cb05c950dd"
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "# try commenting out the line below by adding a `#` at the beginning of the line\n",
+    "# print(\"This line is commented out and will not be executed.\")\n",
+    "print(\"Comment out this line!\")"
+   ],
+   "id": "b18a664c7e3bdf06"
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}