1_Ze_Basic.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hey everyone, in this first tutorial we'll be focusing on print commands, mathematical operations and booleans. Hope you all like it, lets begin."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ZwxGj0WIehZe"
   },
   "source": [
    "so this is the first line of code you will be writing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "28ZeI8OSeYxI"
   },
   "outputs": [],
   "source": [
    "print(\"hello world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_kGp08lkfStX"
   },
   "source": [
    "Why dont you try printing some things on your own. Such as try printing \"heyo, this is thingy, thingy, thingy and thingy, reporting for duty\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "i6HIEMsxecD3"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Heres another neat thing im gonna show you,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"guy_uno: hey guy_dos,\")\n",
    "print(\"whats up?\")\n",
    "print(\"guy_dos: hey man,\")\n",
    "print(\"not much.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From what we're seeing here, the print command takes in anything that is written within a pair of inverted commas as its input. We can say that this input is a parameter of the print command."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets say you wanna type something up and then go to the next line and type something else up but you don't always want to go and type print(\"etc etc etc\"). Heres what you can do instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"guy_uno: hey guy_dos, \\nwhats up? \\nguy_dos: hey man, \\nnot much.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just attach the \\n behind what you wanna type next and voila, you get to the next line. But this looks a little messy and plain ew a lot of the times. And so I introduce yet another solution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"\"\"guy_uno: hey guy_dos, \n",
    "whats up? \n",
    "guy_dos: hey man, \n",
    "not much.\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rather than putting a one pair of double inverted commas (i.e. \" \"), you put three pairs of it and you can write in any way you can get anything written in any way you please. And for pure aesthetic purposes, you can do the following and get the same results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"\"\"\n",
    "guy_uno: hey guy_dos, \n",
    "whats up? \n",
    "guy_dos: hey man, \n",
    "not much.\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3bYEmrjIefA2"
   },
   "source": [
    "You can also use the '#' symbol as a way to comment on lines of code. When you write anything after writing the '#', it does not affect your code and you can write anything beside it. This is used by programmers to basically describe how each line of their code works."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 934,
     "status": "ok",
     "timestamp": 1572973712653,
     "user": {
      "displayName": "Mahir Ahmed-Al",
      "photoUrl": "",
      "userId": "05859649851055572658"
     },
     "user_tz": -360
    },
    "id": "JfMYTQwXhhJF",
    "outputId": "276ca070-9333-4e02-ddc5-b8e794f20394"
   },
   "outputs": [],
   "source": [
    "print(\"yosup fam\") # Here, i printed yosup fam and me writing whatever im writing right now will affect my code later on. I can literally write ANYTHING and it wont affect the code i wrote before the '#'. Pretty cool huh?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "AWJW1WHhijuw"
   },
   "source": [
    "Why dont you guys try it out? Its pretty simple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1219,
     "status": "ok",
     "timestamp": 1572975134623,
     "user": {
      "displayName": "Mahir Ahmed-Al",
      "photoUrl": "",
      "userId": "05859649851055572658"
     },
     "user_tz": -360
    },
    "id": "hEdEqowOipb5",
    "outputId": "82102b2d-dc0f-46bf-9d0e-292a7c381a3c"
   },
   "outputs": [],
   "source": [
    "print(\"type in the '#' and the write anything you want beside it\")\n",
    "print(\"Oh, by the way, you can also write the '' when you print with a double inverted commas\")\n",
    "print('You can also write the \"\" when you print with single inverted commas')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dZJ5wyVrn_XI"
   },
   "source": [
    "Right now, we're gonna go into some simple mathematics which we can use with python. Its pretty basic. The '-' means subtraction, '+' means addition, '*' means multiplication, '/' means division and '%' means modulus (this just gives you the remainder). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 102
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 967,
     "status": "ok",
     "timestamp": 1572975696254,
     "user": {
      "displayName": "Mahir Ahmed-Al",
      "photoUrl": "",
      "userId": "05859649851055572658"
     },
     "user_tz": -360
    },
    "id": "sVe0jDSCpYUY",
    "outputId": "12326ee0-dfe4-438a-96c5-973c831235d5"
   },
   "outputs": [],
   "source": [
    "print(1 + 1)# this adds \n",
    "print(2 * 4) # multiplies\n",
    "print(666/420) # divides\n",
    "print(70 - 1) # subtracts\n",
    "print(2**4) # Oh, i didnt tell you about this but this actually raises to the power, so thats pretty cool too"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "APb8FSnCqHbU"
   },
   "source": [
    "Try some of this out yourself"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "NjmsftU6qNCj"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "k_RidrTeqNvM"
   },
   "source": [
    "Next up we're gonna go through some inequality signs. Pretty simple, once again, '<' is less-than, '>' is greater-than, '<=' is less-than-equal, '=>' is greater-than-equal to. By using this in our program, we can obtain boolean values. We'll go deeper into boolean values later on in this chapter but as of now, you need to understand that a boolean is either True or False. So using these inequalities, we will have boolean values returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "z_-ERrAYsOsY"
   },
   "outputs": [],
   "source": [
    "1 > 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "UVUYNCCisywz"
   },
   "outputs": [],
   "source": [
    "3 > 2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Y2SqtMhFs5kt"
   },
   "outputs": [],
   "source": [
    "3 > 3 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Qsliqc4as7N3"
   },
   "outputs": [],
   "source": [
    "print(\"Is 1 greater than 2?\", 1 > 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "rnbat4dKtpuU"
   },
   "outputs": [],
   "source": [
    "print(\"is 3 greater than 3?\", 3 > 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "q1DWRvOnuQsh"
   },
   "source": [
    "Now we're gonna be moving on to variables in python. So in python variables arent restricted to single letters like the ones you see in mathematical equations. Entire words or names can also be variables. For example, your name (I'm gonna assume your name is Roshid mama) can also be a variable. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1156,
     "status": "ok",
     "timestamp": 1572977435793,
     "user": {
      "displayName": "Mahir Ahmed-Al",
      "photoUrl": "",
      "userId": "05859649851055572658"
     },
     "user_tz": -360
    },
    "id": "Kvto71NEtxxt",
    "outputId": "a63f5112-22d9-4ae2-e3a7-a53547278c87"
   },
   "outputs": [],
   "source": [
    "roshid_mama = 57 \n",
    "print(roshid_mama)\n",
    "x = 2\n",
    "print(x)\n",
    "some_number = roshid_mama - x\n",
    "print(some_number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bNqW4o__w0Ib"
   },
   "source": [
    "As you can see from the examples above, you can also perform mathematical calculations with these variable. Why dont you try it out yourself?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So the cool thing about variables in Python is that you can very easily declare a variable as we've seen above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ten = 10\n",
    "nine = 8 \n",
    "you = 5\n",
    "bla = 3\n",
    "blatwo = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, variables are not restricted to only being equal to numbers. Variables can also be equal to sentences or words, lists (which we will talk about later), floats (floats are really just integer numbers that have a decimal point beside them and they allow for calculations for upto higher decimal places), arrays and so on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we put a sentence or a word in the print command above, by the sentence or word, we were actually referring to a term in programming called strings. Strings in Python is anything that is within a pair of inverted commas or a three pairs of inverted commas. Now, we can make a variable be equal to a string, heres how. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greetings = \"helo\"\n",
    "formal_greetings = \"\"\"henlo, \n",
    "my sire\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we know that the print command takes strings as its parameters. With that logic the print command should also be to take our variables above as its parameters. Lets try that?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(greetings)\n",
    "print(formal_greetings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "the_thing_after_greetings = \"whats up\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also add variables that have strings with each other, as well as variables that have float numbers or integer numbers with each other. But you can't add floats and strings or integers and strings together. Lets demonstrate. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(greetings + the_thing_after_greetings)\n",
    "print(ten + nine)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the output that says \"helowhats up\" doesnt look very pretty because of no space being between \"helo\" and \"whats\". We can fix this in a number of ways. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do this for instances "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(greetings + \" \" + the_thing_after_greetings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or we can change what the variable is equal too and put a space behind or infront of what it is equal too. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "the_thing_after_greetings = \" whats up\"\n",
    "print(greetings + the_thing_after_greetings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "the_thing_after_greetings = \"whats up\"\n",
    "greetings = \"helo \"\n",
    "print(greetings + the_thing_after_greetings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But when we try to run the following, we'll get an error message"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(greetings + nine)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you read the error message, you see that we cant add these two variables because one is a string and the other is a integer. We'll get a similar error message if we attempt to add a string and a float number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can actually check the data type of a variable or a string, float, etc by using the type() command.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(ten))\n",
    "print(type(greetings))\n",
    "print(type(4))\n",
    "print(type(5.67))\n",
    "print(type(\"hello, itssa me, mario\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, why don't you try all that you learned so far out by yourself. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We saw that we werent able to add strings and integers. With the help of the command I'm going to show below we can actually change an integer (or even a float) into a string. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nine = str(nine)\n",
    "print(greetings + nine)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Likewise we could change a string into an integer, or a float to an integer or even a string to float. All we have to do is the following,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#for string to int\n",
    "\n",
    "ten = \"10\"\n",
    "ten = int(ten)\n",
    "ten = int(\"10\")\n",
    "\n",
    "#for float to int\n",
    "\n",
    "eight = 8\n",
    "eightfloat = float(eight)\n",
    "eight = float(eight)\n",
    "eight = float(8)\n",
    "\n",
    "#for string to float\n",
    "\n",
    "six = \"6\"\n",
    "six = float(six)\n",
    "six = float(\"6\")\n",
    "\n",
    "print(ten)\n",
    "print(eight)\n",
    "print(six)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One more thing you gotta learn before we move on is called formatting. So you can actually put in variables inside the print command. We call that formatting. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Originally we would do something like this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Mahir\"\n",
    "print(\"My name is\" + \" \" + name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And this is completely fine but theres a much faster and easier way to do the same thing and we do that by formatting."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"My name is {name}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What we did here is pretty simple, we put f before the first inverted comma that was gonna print whatever we wrote. This f stands for format, and then we put the variable that we wanted within curly braces (  { }  ) and we ran the command. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"This is the new nine, {nine}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It also turns integers into strings. Try some of this out yourself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we're gonna start learning about booleans. \n",
    "\n",
    "In the world of computing, there are two options: True or False. These can be represented by 1s and 0s (respectively) or high voltage and low voltage (respectively). Most things in programming, as far as I know at least, are like this and hence they are called binary. \n",
    "\n",
    "Now True and False are also data types like strings, floats and integars. The name of the data type associated with True and False is called bool, short for boolean. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(True))\n",
    "print(type(False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using mathematical operators such as \">\", \"<\" we can find out bool values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1 > 2)\n",
    "print(10 > 9)\n",
    "print(71 < 14)\n",
    "print(67 < 89)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now lets say we wanted to find out obtain a True value but we wanted to use the \"=\" operator. We can say that \"1 = 1\" and in our heads, this will be True. But when use the \"=\" symbol in Python, we arent really asking if something is equal to something else, we're really assigning to our program that something should be equal to something else. So rather than using \"=\" symbol as the operator, we use \"==\" instead. This may be slightly hard to comprehend, so take your time, hopefully the examples will clear things up."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1 == 1)\n",
    "print(2 == 2)\n",
    "print(2 == 3)\n",
    "print(33 == 66)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the \"=>\" or \"<=\" in these cases as well. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thats all for this tutorial. I'll give you a few more lines so that you can experiment further. Thank you and happy coding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-- Al Mahir Ahmed "
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "Python_Tutorials_1.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}