1_1_Introduction to Python.ipynb

{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"name":"1_1_Introduction to Python.ipynb","provenance":[],"collapsed_sections":["P6N7HYGJpOZc","b4jfwG7f1UcK","YA8ZGoed2D-G"]},"kernelspec":{"name":"python3","display_name":"Python 3"},"gpuClass":"standard"},"cells":[{"cell_type":"markdown","metadata":{"id":"AyF07xJ9y3bO"},"source":["# What is Programming?\n","\n","Programming is the simple act of writing instructions that the computer will execute. "]},{"cell_type":"markdown","source":["The function print() in Python allows us to write messages on screen that are  shown to the users of the program."],"metadata":{"id":"4PoP8jXyEkJa"}},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"kf9AxNtYyv4H","outputId":"de9aac99-ab9f-43ce-de9e-0ad7b79b9978"},"source":["print('welcome')"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["welcome\n"]}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"0b_DZIGHyoeb","outputId":"feb8f0b0-17c0-496f-b4b4-98ee1e96b793"},"source":["print('hello world')"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["hello world\n"]}]},{"cell_type":"markdown","metadata":{"id":"P6N7HYGJpOZc"},"source":["# In this workshop we will work using Google Colab.\n","This is an example of how to make notes in google colab: double click over this text to start editing it.\n"]},{"cell_type":"markdown","metadata":{"id":"b4jfwG7f1UcK"},"source":["#Arithmetic Operators\n","\n","An arithmetic operator takes two inputs, executes a calculation and returns the result of the operation."]},{"cell_type":"markdown","metadata":{"id":"YA8ZGoed2D-G"},"source":["# List of Operators\n","- \"+\" ->\tAddition of two operands 12 + 3 = 15\n","- \"-\"\t-> Substraction\t12 - 3 = 9\n","- \"\\*\" ->\tMultiplication\t12 \\* 3 = 36\n","- \"/\"\t-> Division\t12 / 3 = 4\n","- \"%\"\t-> Modulus operation\t16 % 3 = 1\n","- \"\\**\"\t-> Exponentiation\t12 \\** 3 = 1728\n","- \"//\" -> Executes Floor division\t18 // 5 = 3\n","\n"]},{"cell_type":"markdown","source":["Estos son algunos ejemplos de operadores en matematicos en Python."],"metadata":{"id":"smsBHInDE2fo"}},{"cell_type":"code","metadata":{"id":"xGEQWq3I0wb9","colab":{"base_uri":"https://localhost:8080/"},"outputId":"bed47819-68f6-4955-8e0b-8974798796d4"},"source":["2 + 4 * 80\n"],"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["322"]},"metadata":{},"execution_count":3}]},{"cell_type":"code","metadata":{"id":"Soi6w5DQ1GYb","colab":{"base_uri":"https://localhost:8080/"},"outputId":"3520b4be-908d-450c-818f-20e9633176f4"},"source":["(2+3) * 9\n"],"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["45"]},"metadata":{},"execution_count":4}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"23kMbABG21qr","outputId":"d7e5281e-ba25-4b4b-8f20-5e7978b51825"},"source":["30 * 10"],"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["300"]},"metadata":{},"execution_count":5}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"9EOfsSI02_Xv","outputId":"60913c8d-2785-48e8-e2fc-9173cb626baa"},"source":["2 ** 8"],"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["256"]},"metadata":{},"execution_count":6}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"5UnUQNoz3MGY","outputId":"b2647aff-dffa-45f7-95a9-cbe36ae59ff2"},"source":["23 / 7"],"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["3.2857142857142856"]},"metadata":{},"execution_count":7}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"i-46NLcY3Vkh","outputId":"f36e1168-ab9d-4666-8729-44885886a39b"},"source":["23 // 7"],"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["3"]},"metadata":{},"execution_count":8}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"Souik-xm3XSg","outputId":"ded2d807-1f77-4861-ff13-2c9e6cb802fb"},"source":["9 % 2"],"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["1"]},"metadata":{},"execution_count":9}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"rQI2sBka40vG","outputId":"b58ec4b3-cb8f-4890-9fe4-7f50a8e735ef"},"source":["25 % 7"],"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["4"]},"metadata":{},"execution_count":10}]},{"cell_type":"markdown","metadata":{"id":"YPmkwU6E54Gu"},"source":["# What are data types?\n","In any high level programming language there is support for data types. Data types have sets of rules that define how they behave and what are their properties or characteristics."]},{"cell_type":"markdown","metadata":{"id":"ycTpucp06bO6"},"source":["## Data types in Python\n","- Text Type:\tstr \n","- Numeric Types:\tint, float, complex\n","- Sequence Types:\tlist, tuple, range\n","\n","> Indented block\n","\n"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":35},"id":"7VP8f1rH6dfu","outputId":"7d3d174f-761e-409e-b939-71d4865c1c15"},"source":["'Rick' + ' '+'Pepe'"],"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["'Rick Pepe'"],"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"}},"metadata":{},"execution_count":1}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":165},"id":"S11oZKJ97DhQ","outputId":"d8a4ca78-4e71-4e16-8d73-1321a8819a8a"},"source":["'Rick' + 12"],"execution_count":null,"outputs":[{"output_type":"error","ename":"TypeError","evalue":"ignored","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)","\u001b[0;32m<ipython-input-3-d06c38203cb4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m'Rick'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m12\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"]}]},{"cell_type":"markdown","source":["# ¿What happened with this code?\n","\n","Errors are part of programming. Python includes precise error messages that inform even the line of our program that contains an error.\n","\n","In this case, the error message says \"can only concatenate str (not \"int\") to str\". This tells us that the error is the type of data we're using, because it is not possible to add text and an integer number.\n","\n","Now we can see a text operation and integer numbers that is allowed in Python."],"metadata":{"id":"9S_KwYp8GWAg"}},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":35},"id":"Ek_soQoy7MAW","outputId":"32c27a0a-8606-454f-a258-a0fd760f778e"},"source":["'Rick' * 5"],"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["'RickRickRickRickRick'"],"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"}},"metadata":{},"execution_count":1}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":165},"id":"eG7TILvQ7Ypq","outputId":"88a04e76-c7ee-49f6-ed08-e740f160b41c"},"source":["'Rick' * 'Joe'"],"execution_count":null,"outputs":[{"output_type":"error","ename":"TypeError","evalue":"ignored","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)","\u001b[0;32m<ipython-input-2-b980620a7278>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m'Rick'\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;34m'Joe'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;31mTypeError\u001b[0m: can't multiply sequence by non-int of type 'str'"]}]},{"cell_type":"markdown","source":["Additionally, COLAB offers help for error handling that allowes us to query StackOverflow. This is a website for questions and answers dedicated to programming where we can find a large amount  of users. It is possible to find help from users or others who have seen and solved the same errors.\n","\n","You can test this functionality by clicking the \"SEARCH STACK OVERFLOW\".\n"],"metadata":{"id":"CRPL3GF0HyXz"}},{"cell_type":"code","metadata":{"id":"7n8AQW1070c9","colab":{"base_uri":"https://localhost:8080/"},"outputId":"0ab2c004-4f0d-41e9-8c00-aabf031a2d15"},"source":["# Within Python it is possible to add notes or comments using the character #\n","\n","# My program says Hi and asks for your name\n","\n","print('Hello world!')\n","print('What is your name?')\n","\n","# Now we create a variable that will store the name of the user\n","# Variables allow us to store data within python that can be used in our program.\n","# For our first program we create a variable called 'my_name' which will store the result of the input() function.\n","# The input() function allows the user to enter data into the program.\n","\n","\n","my_name = input()  \n","print('Nice to meet you, ' + my_name)\n","print('Your name has ',len(my_name),' letters') # The len() function calculates the amount of character within the object we specify as parameter. \n","\n","#We will see more about functions soon, and we'll create our own.\n","\n","print('how old are you?')\n","my_age = input()\n","\n","# To \"cast\" is the action of changing the data type of an object in order to do allowed operations within the program.\n","# in this case we want to add 1 to the age of our user.\n","# The input() function we used stored a text in the my_age variable. To add 1 to it we need to change my_age to a number.\n","# Lastly we can change the new number into a String so we can concatenate it to our text.\n","\n","print('You will be ' + str(int(my_age)+1) + ' next year!')\n","\n"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Hello world!\n","What is your name?\n","Arki\n","Nice to meet you, Arki\n","Your name has  4  letters\n","how old are you?\n","20\n","You will be 21 next year!\n"]}]},{"cell_type":"markdown","source":["# Boolean type and Binary Boolean Operators\n","\n","A Boolean is a data type with a single value: True or False.\n","They can be used to control the flow of our program (more on this in the next class). We get boolean values when we use **comparative operators**.\n","\n","* This is a list of comparative operators in Python:\n","\n","![image.png](data:image/png;base64,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)\n","\n","Image from the book from Al Sweigart, \"Automate the boring stuff with Python\""],"metadata":{"id":"Ghh5Kx8PRsN8"}},{"cell_type":"code","source":["# We can compare values and get a Boolean as result\n","42 == 42"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"OLFj3cDiSinZ","outputId":"4f7564fb-a070-49a0-d08c-5a33a466e7a3"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["True"]},"metadata":{},"execution_count":4}]},{"cell_type":"code","source":["42 == 65"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"Tju4gAo_Sr5h","outputId":"b87f4ace-5ae9-463a-bce9-7150b330baf4"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["False"]},"metadata":{},"execution_count":5}]},{"cell_type":"code","source":["'dog' != 'cat'"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"vokXj2w9SvUn","outputId":"87288447-ecb6-4d8b-8027-5afd6252ccf5"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["True"]},"metadata":{},"execution_count":6}]},{"cell_type":"code","source":["# The symbol = is used to assign a value to a variable. It is not an operator, like == is\n","age = 30\n","age == 30"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"Q8kURuoOS1Kb","outputId":"445a91d0-9bb0-418a-fc5d-908681845ff6"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["True"]},"metadata":{},"execution_count":11}]},{"cell_type":"markdown","source":["## Binary Booleans\n","\n","Binary booleans are operators that use booleans to evaluate two statements and define the result of the boolean. These operators are 'and', 'not' and 'or'.\n"],"metadata":{"id":"_IdkQCFYb9Bo"}},{"cell_type":"code","source":["# Binary Boolean help us to evaluate multiple statements.\n","# We can add a message if the name is outside a range.\n","# \n","import random\n","\n","guess_number = input('Guess a number from 1 to 5: ') # User entry\n","winning_number = random.randint(1, 5) # variable with the winning number\n","\n","if guess_number == str(winning_number):\n","    print('Congratulations, you guessed right!') # Mensaje al ganador\n","elif int(guess_number) >= 6 or int(guess_number) <= 0:  \n","        print('Please read the instructions and try again.') # message for number out of range\n","else:print('The winning number was {}'.format(winning_number))"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"K6Tw8_xycDCl","outputId":"a6e88451-01d4-4875-a436-c1e972b5abf8"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Guess a number from 1 to 5: 2\n","Congratulations, you guessed right!\n"]}]},{"cell_type":"code","source":["# Operaciones con operadores binarios\n","(4 < 5) and (5 < 6)"],"metadata":{"id":"f44c7V9ScF8T"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["(4 < 5) and (9 < 6)"],"metadata":{"id":"KshWGyU1cIMs"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["(1 == 2) or (2 == 2)"],"metadata":{"id":"k3UGSWxwcJqp"},"execution_count":null,"outputs":[]},{"cell_type":"code","source":["2 + 2 == 4 and not 2 + 2 == 5 and 2 * 2 == 2 + 2"],"metadata":{"id":"QBsu4xvhcLmN"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["#.format()\n","\n","With the format variable we can write variables within a string using brackets {} as containers for the result."],"metadata":{"id":"vWsgrg5Tmmv3"}},{"cell_type":"code","source":["# from Python 3\n","i = 3.543546\n","print('Test string print: {}'.format(i))\n","\n","# newer form in Python 3.6+\n","print(f'Second test string print: {i}')\n","\n","# More than one variable\n","apples = 2\n","oranges = 4\n","\n","print('I have {} apples and you have {} oranges.'.format(apples, oranges)) # We can add multiple variables by separating them with ,\n","\n"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"sZxPTun5ggVQ","outputId":"ce7d91a9-267e-4cdf-ae1b-8f17f56b7e73"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Test string print: 3.543546\n","Second test string print: 3.543546\n","I have 2 apples and you have 4 oranges.\n"]}]},{"cell_type":"markdown","source":["## String Literals"],"metadata":{"id":"nSzwvjixmxVc"}},{"cell_type":"code","source":["# MORE VARIABLES!!!\n","var1='Hello,'\n","var2='is'\n","var3='my'\n","var4='Dave'\n","var5='name'\n","my_date= '2022-07-25'\n","print('Third test string print: {} {} {} {} {} and today is {}'.format(var1,var3,var5,var2,var4, my_date))\n","print(f'Third test string print: {var1} {var3} {var5} {var2} {var4} and today is {my_date}')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"MLs4HLbJmTHu","outputId":"6934553b-65b3-4e7d-e4a3-e893fdf8f7bc"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Third test string print: Hello, my name is Dave and today is 2022-07-25\n","Third test string print: Hello, my name is Dave and today is 2022-07-25\n"]}]},{"cell_type":"markdown","source":["# Important things to learn from the last example:\n","\n","\n","*   Use descriptive variable names\n","*   When writing it, think of making it understandatable for someone else (your future self will thank you)\n","*   Use comments!\n","\n","\n","\n","\n","\n","\n"],"metadata":{"id":"8DT2HiArjBtw"}}]}