{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "eudDL43_A155", "slideshow": { "slide_type": "slide" } }, "source": [ "Astronomical data analysis using Python\n", "====================================\n", "\n", "Lecture 3\n", "---------------------\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Our first program - introduced in the previous lecture\n", "------------------------------------------" ] }, { "cell_type": "code", "execution_count": 126, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hello World!\n", "Sum, Difference = 8 -2\n", "Quotient and Remainder = 0.6 3\n" ] } ], "source": [ "a = 3\n", "b = 5\n", "c = a+b\n", "d = a-b\n", "q, r = a/b, a%b # Yes, this is allowed!\n", "\n", "# Now, let's print!\n", "print (\"Hello World!\") # just for fun\n", "print (\"Sum, Difference = \", c, d)\n", "print (\"Quotient and Remainder = \", q, r)\n" ] }, { "cell_type": "markdown", "metadata": { "id": "ai0osL1GA15-", "slideshow": { "slide_type": "slide" } }, "source": [ "Our First Program - Rewritten!\n", "------------------------------\n", "\n", "Let us introduce the following modifications to the program.\n", "\n", "* We use floats instead of ints.\n", "* We accept the numbers from the user instead of \"hard coding\" them." ] }, { "cell_type": "code", "execution_count": 65, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 280 }, "id": "X6ea5lr4A15_", "outputId": "b82ec197-ce4a-4fc0-922b-15f0c3cdb235", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Please enter number 1: 3\n", "Please enter number 2: 5\n" ] }, { "ename": "TypeError", "evalue": "unsupported operand type(s) for -: 'str' and 'str'", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Please enter number 2: \"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 6\u001b[0m \u001b[0mq\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mi\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m//\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'str' and 'str'" ] } ], "source": [ "# Modified first program.\n", "a = input(\"Please enter number 1: \")\n", "b = input(\"Please enter number 2: \")\n", "\n", "c, d = a+b, a-b\n", "q, i = a/b, a//b\n", "\n", "print (c,d,q,i)" ] }, { "cell_type": "markdown", "metadata": { "id": "7V-T0CGuA16C", "slideshow": { "slide_type": "slide" } }, "source": [ "What happened?\n", "--------------\n", "\n", "* Anything input through the keyboard using input() is ... a \"string\".\n", "* Strings support addition (concatenation) but nothing else.\n", "\n", "So what should we do?\n", "---------------\n", "\n", "* \"3.0\" is a string. 3.0 is a float!\n", "* To convert \"3.0\" into a float, we use a simple function - float(\"3.0\")\n", "\n", "So, let's rewrite our program!" ] }, { "cell_type": "code", "execution_count": 127, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "iv63FWotA16D", "outputId": "f7142fbd-7c29-4477-89d2-f22c01f5f8ae", "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Enter Number 1: 3\n", "Enter Number 2: 5\n", "Addition = 8.000000, Difference = -2.000000 \n", "Quotient = 0.600000, Floor division quotient = 0.000000\n" ] } ], "source": [ "a = float( input(\"Enter Number 1: \") ) # We are nesting functions here.\n", "b = float( input(\"Enter Number 2: \") )\n", "\n", "c,d = a+b, a-b\n", "q,i = a/b, a//b # a//b is the floor division operator\n", "\n", "print (\"Addition = %f, Difference = %f \" % (c,d))\n", "print (\"Quotient = %f, Floor division quotient = %f\" % (q,i))\n" ] }, { "cell_type": "markdown", "metadata": { "id": "ZTPYxTGaA16D", "slideshow": { "slide_type": "-" } }, "source": [ "The output looks ugly. Wish I could control the number of decimal places..." ] }, { "cell_type": "code", "execution_count": 128, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "l0N2n5WyA16E", "outputId": "459217ec-0fb4-4112-dc28-c8491b19147c", "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Enter Number 1: 3\n", "Enter Number 2: 5\n", "Addition = 8.00, Difference = -2.00 \n", "Quotient = 0.60, Floor division quotient = 0.00\n" ] } ], "source": [ "a = float( input(\"Enter Number 1: \") )\n", "b = float( input(\"Enter Number 2: \") )\n", "\n", "c,d = a+b, a-b\n", "q,i = a/b, a//b\n", "\n", "print(\"Addition = %.2f, Difference = %.2f \" % (c,d))\n", "print(\"Quotient = %.2f, Floor division quotient = %.2f\" % (q,i))" ] }, { "cell_type": "markdown", "metadata": { "id": "qnp2OgUAA16F", "slideshow": { "slide_type": "-" } }, "source": [ "Ah! now, that's much better." ] }, { "cell_type": "markdown", "metadata": { "id": "EvA0c5HyA16G", "slideshow": { "slide_type": "slide" } }, "source": [ "String Formatting\n", "----------\n", "\n", "We have seen a powerful of constructing strings in the previous example." ] }, { "cell_type": "code", "execution_count": 68, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "0d_Oh5S7A16G", "outputId": "488d72a7-5625-487b-a238-b77acca8f9d6", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Addition = 8.00, Difference = -2.00 \n" ] } ], "source": [ "print (\"Addition = %.2f, Difference = %.2f \" % (c,d))" ] }, { "cell_type": "markdown", "metadata": { "id": "m_q7pzhTA16H", "slideshow": { "slide_type": "-" } }, "source": [ "C / FORTRAN users amongst you will immediately understand this method of string construction.\n", "\n", "Python supports this and its own way of string formatting.\n", "-------" ] }, { "cell_type": "code", "execution_count": 69, "metadata": { "id": "0VRpFQNsA16I", "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "gal_name = \"NGC 7709\"; int_bmagnitude = 13.6" ] }, { "cell_type": "code", "execution_count": 70, "metadata": { "id": "jc3HmdpBA16I", "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "statement1 = \"The galaxy %s has an integrated \\\n", "B-band magnitude of %.2f\" % (gal_name, int_bmagnitude)" ] }, { "cell_type": "code", "execution_count": 71, "metadata": { "id": "MhFErU9_A16J", "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "statement2 = \"The galaxy {0:s} has an integrated \\\n", "B-band magnitude of {1:.2f}\".format(gal_name, int_bmagnitude)" ] }, { "cell_type": "code", "execution_count": 72, "metadata": { "id": "ngucooc0A16J", "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "statement3 = \"The galaxy {name:s} has an integrated \\\n", "B-band magnitude of {mag:.2f}\".format(name=gal_name, mag=int_bmagnitude)" ] }, { "cell_type": "markdown", "metadata": { "id": "gREaBvSEA16K", "slideshow": { "slide_type": "-" } }, "source": [ "All the above statements are equivalent!\n", "------" ] }, { "cell_type": "code", "execution_count": 73, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "VcYaDMb7A16K", "outputId": "f3853b5d-d161-46a7-ad7d-75a8ff2dbe6d", "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "The galaxy NGC 7709 has an integrated B-band magnitude of 13.60 \n", " The galaxy NGC 7709 has an integrated B-band magnitude of 13.60 \n", " The galaxy NGC 7709 has an integrated B-band magnitude of 13.60 \n", "\n" ] } ], "source": [ "print (statement1,\"\\n\", statement2, \"\\n\", statement3, \"\\n\")" ] }, { "cell_type": "markdown", "metadata": { "id": "LrX7Xq4ZA16L", "slideshow": { "slide_type": "-" } }, "source": [ "You can choose whichever method you like!\n", "\n", "As a former C/C++ user, I tend to use the first method.\n", "\n", "But ... second and third methods are more \"Pythonic\". If you don't have previous experience with the C type formatting use one of the more Pythonic ways." ] }, { "cell_type": "markdown", "metadata": { "id": "r85Y2kNyA16L", "slideshow": { "slide_type": "slide" } }, "source": [ "Raw Strings\n", "------------\n", "\n", "* We have seen the three methods of string declaration. \n", "* We have also seen string formatting.\n", "* String formatting taught us that symbols like { or % have special meanings in Python." ] }, { "cell_type": "code", "execution_count": 74, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "zxHTPu4jA16L", "outputId": "7a9bcd07-6d38-4fa5-85eb-7cbe2f3666cd", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Here is a percentage sign % and a brace }\n" ] } ], "source": [ "# There is a special way of declaring strings where\n", "# we can ask Python to ignore all these symbols.\n", "raw_string = r\"Here is a percentage sign % and a brace }\"\n", "print (raw_string)" ] }, { "cell_type": "markdown", "metadata": { "id": "gfduv2gAA16M", "slideshow": { "slide_type": "slide" } }, "source": [ "Usefulness of Raw Strings - Example\n", "-------\n", "\n", "* Typically, when we make plots and set labels, we would like to invoke a LaTeX parser.\n", "* This would involve a lot \\ $ and {}. \n", "\n", "In such cases, it's best to use raw strings.\n", "\n", " plt.xlabel(r\" \\log \\rm{F}_v\")\n", " \n", "Other examples with special characters include writing Windows file paths, XML code, HTML code, etc." ] }, { "cell_type": "markdown", "metadata": { "id": "G8L9YdzRA16M", "slideshow": { "slide_type": "slide" } }, "source": [ "Conditionals\n", "------" ] }, { "cell_type": "code", "execution_count": 75, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "5XKcjDUsA16N", "outputId": "20ad21bf-bd9e-4949-ecd3-17931d9627a1", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Enter number: 3\n", "3 is odd!\n" ] } ], "source": [ "num = int(input(\"Enter number: \") )\n", "if num %2 == 0:\n", " print (\"%d is even!\" % num)\n", "else:\n", " print (\"%d is odd!\" % num)" ] }, { "cell_type": "markdown", "metadata": { "id": "JlK5XhVlA16N", "slideshow": { "slide_type": "slide" } }, "source": [ "You will use conditionals a lot in your data analysis." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 262 }, "id": "uWVdHH-PA16O", "outputId": "acf83481-692e-46e9-8758-ee2c2fe0fcd7", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Enter choice [1 or 2]: 2\n", "Model 2 fitted.\n" ] } ], "source": [ "model_choice = int(input( \"Enter choice [1 or 2]: \") )\n", "spectrum = 3 # In a realistic case, this will be some complicated object.\n", "\n", "if model_choice == 1:\n", " #model1(spectrum)\n", " print (\"Model 1 fitted.\")\n", "elif model_choice == 2:\n", " #model2(spectrum)\n", " print (\"Model 2 fitted.\")\n", "else:\n", " print (\"Invalid model entered.\")" ] }, { "cell_type": "markdown", "metadata": { "id": "h7kKIwnPA16P", "slideshow": { "slide_type": "slide" } }, "source": [ "What do you notice apart from the syntax in the above example?\n", "------" ] }, { "cell_type": "markdown", "metadata": { "id": "OuBxYPTfA16P", "slideshow": { "slide_type": "-" } }, "source": [ "Indentation - A Vital Part of the Pythonic Way\n", "--------------\n", "\n", "Be it the if-block illustrated above or the loops or the functions (to be introduced soon), indentation is at the heart of the Python's way of delimiting blocks!\n", "\n", "Function definitions, loops, if-blocks - nothing has your typical boundaries like { } as in C/C++/Java.\n", "\n", "The \"level of the indentation\" in the only way to define the scope of a \"block\"." ] }, { "cell_type": "markdown", "metadata": { "id": "YEr6KNyGA16P", "slideshow": { "slide_type": "slide" } }, "source": [ "In support of indentation\n", "------\n", "\n", "Look at the following C-like code.\n", "\n", " if (x>0)\n", " if (y>0)\n", " print \"Woohoo!\"\n", " else\n", " print \"Booboo!\"\n", " \n", "Which \"if\" does the \"else\" belong to?\n", "\n", "In C and C-like languages, the braces {}s do the marking, the indentation is purely optional. In Python, indentation levels determine scopes. In Python the \"the else\" belongs to \"if (x>0)\". \n", "\n", "Python forces you to write clean code! (Obfuscation lovers, go take a jump!)\n", "\n", "Use either spaces or tabs (don't ever ever mix them) and use them consistently. I strongly recommend using 4 spaces for each level of indentation." ] }, { "cell_type": "markdown", "metadata": { "id": "CasnbgxNA16Q", "slideshow": { "slide_type": "slide" } }, "source": [ "Wrapping up if-elif-else\n", "-------\n", "\n", "The general syntax:\n", "\n", " if :\n", " do this\n", " and this\n", " elif :\n", " this\n", " and this\n", " ...\n", " else:\n", " do this \n", " and this\n", " " ] }, { "cell_type": "markdown", "metadata": { "id": "uPLqV1FWA16Q", "slideshow": { "slide_type": "slide" } }, "source": [ "Conditions are anything that return True or False.\n", "------\n", "\n", "* == (equal to)\n", "* !=\n", "* \\>\n", "* \\>=\n", "* < \n", "* <= \n", "\n", "You can combine conditionals using \"logical operators\"\n", "\n", "* and\n", "* or\n", "* not" ] }, { "cell_type": "markdown", "metadata": { "id": "yiVYyZawA16Q", "slideshow": { "slide_type": "slide" } }, "source": [ "The Boolean Data Type\n", "--------------" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "N9KUiHFsA16R", "outputId": "27fb4f6f-5c3f-4cde-f22a-eb0c62caf614", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "This comes on screen.\n", "This also comes on screen.\n" ] } ], "source": [ "a = True\n", "b = False\n", "\n", "if a:\n", " print (\"This comes on screen.\")\n", "\n", "if b:\n", " print (\"This won't come on screen.\")\n", " \n", "if a or b:\n", " print (\"This also comes on screen.\")\n", " \n", "if a and b:\n", " print (\"This won't come on screen either.\")" ] }, { "cell_type": "code", "execution_count": 78, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "zAPBbQtSA16R", "outputId": "efae56c3-2700-4afc-da86-b4df75f15f8c", "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "bool" ] }, "execution_count": 78, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(a) # To check type of object." ] }, { "cell_type": "markdown", "metadata": { "id": "hT5VIRS2A16R", "slideshow": { "slide_type": "slide" } }, "source": [ "Almost all other types have a Boolean Equivalent\n", "------" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "6sIEwLnLA16S", "outputId": "63736e36-8737-43d9-f275-d48d228aa0eb", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hello!\n" ] }, { "data": { "text/plain": [ "int" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = 1\n", "b = 0\n", "\n", "if a:\n", " print (\"Hello!\")\n", "if b:\n", " print (\"Oh No!\")\n", " \n", "type(a) " ] }, { "cell_type": "code", "execution_count": 80, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "axffo2llA16S", "outputId": "e30ccc9a-f6db-45ee-93c3-29efe6c1b911", "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Will be printed.\n" ] } ], "source": [ "s1 = \"\"; s2 = \"Hello\" # s1 is an empty string\n", "\n", "if s1:\n", " print (\"Won't be printed.\")\n", "if s2:\n", " print (\"Will be printed.\")" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "This is bad Python style because remember that explicit is better than implicit. Use an expression that evaluates to a boolean instead. Keep your programs readable." ] }, { "cell_type": "markdown", "metadata": { "id": "aj75rPnGA16S", "slideshow": { "slide_type": "slide" } }, "source": [ "Conditional Expression\n", "-------\n", "\n", "Consider..." ] }, { "cell_type": "code", "execution_count": 81, "metadata": { "id": "aFLx3oosA16T", "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "if 5 > 6:\n", " x = 2\n", "else:\n", " x = 3" ] }, { "cell_type": "code", "execution_count": 82, "metadata": { "id": "St9kX66EA16T", "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "y = 2 if 5 > 6 else 3 # if else block in one line is allowed" ] }, { "cell_type": "code", "execution_count": 83, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "l_urXUCVA16T", "outputId": "ba44f7a5-e65c-4ec4-c940-f28184cee5b7", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3 3\n" ] } ], "source": [ "print (x,y)" ] }, { "cell_type": "markdown", "metadata": { "id": "NnF2zI1JA16U", "slideshow": { "slide_type": "slide" } }, "source": [ "A Second Plunge into the Data Types\n", "===========\n", "\n", "The two other data types we need to know:\n", "\n", "* Lists \n", "* Dictionaries\n", "\n", "Data Types I will not cover (formally):\n", "\n", "* Tuples (immutable lists!)\n", "* Sets (key-less dictionaries!)\n", "* Complex Numbers\n", "* Fractions\n", "* Decimals" ] }, { "cell_type": "markdown", "metadata": { "id": "zwFFCw7gA16U", "slideshow": { "slide_type": "slide" } }, "source": [ "Lists\n", "-----" ] }, { "cell_type": "code", "execution_count": 84, "metadata": { "id": "mfGima1-A16U", "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "a = [1,2,3,4] # simple ordered collection" ] }, { "cell_type": "code", "execution_count": 85, "metadata": { "id": "ueky_qt3A16U", "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "b = [\"Hello\", 45, 7.64, True] # can be heterogeneous" ] }, { "cell_type": "code", "execution_count": 86, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "csRX423tA16U", "outputId": "f3bb19c6-5637-454f-a583-cb54fe9975bf", "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "(1, 4, [2, 3])" ] }, "execution_count": 86, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a[0], a[-1], a[1:3] # All \"sequence\" operations supported." ] }, { "cell_type": "code", "execution_count": 87, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 35 }, "id": "2qAiDsDeA16V", "outputId": "745a547e-5f0a-48f4-dbb2-6aeafe73bb04", "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "'e'" ] }, "execution_count": 87, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b[0][1] # 2nd member of the 1st member" ] }, { "cell_type": "code", "execution_count": 88, "metadata": { "id": "PZQz0TqvA16V", "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "a = [ [1,2,3] , [4,5,6] , [7,8,9] ] # list of lists allowed." ] }, { "cell_type": "code", "execution_count": 89, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "GfoDTS76A16V", "outputId": "b789b0a6-6c5c-4ff5-9b88-e37ae6e1c5a0", "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "8" ] }, "execution_count": 89, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a[2][1] # Accessing elements in nested structures." ] }, { "cell_type": "code", "execution_count": 90, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "zerKPIDzA16W", "outputId": "285fadda-6e2c-43ff-cdab-6738f5550093", "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "[1, 3, 4, 5, 6, 7]" ] }, "execution_count": 90, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[1,3,4] + [5,6,7] # Support concatenation" ] }, { "cell_type": "code", "execution_count": 91, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "1lFG0rfZA16W", "outputId": "4231cca0-fe47-49fe-a249-caa7e4338ae5", "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "[1, 6, 8, 1, 6, 8, 1, 6, 8]" ] }, "execution_count": 91, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[1,6,8] * 3 # Repetition (like strings)" ] }, { "cell_type": "markdown", "metadata": { "id": "8hZkuRJYA16W", "slideshow": { "slide_type": "slide" } }, "source": [ "Lists are Mutable! (Strings are not!)\n", "----" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "id": "4C5frXMzA16W", "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "a = [1,4,5,7]" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "mJqUc-pRA16X", "outputId": "676ab222-7d18-42c1-c398-b0a6d7aeb6cd", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 4, 5, 7]\n" ] } ], "source": [ "print (a)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "id": "yH8loIolA16b", "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "a[2] = 777 # set third element to 777" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "f-fmrb4EA16c", "outputId": "c1077cc2-415b-46d5-a29f-822a837e61c1", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 4, 777, 7]\n" ] } ], "source": [ "print (a)" ] }, { "cell_type": "markdown", "metadata": { "id": "MSOG_286A16c", "slideshow": { "slide_type": "slide" } }, "source": [ "List Methods\n", "----" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "s3H6022FA16c", "outputId": "801da5ac-c9e1-415d-fc7b-328376b395db", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 3, 5]\n" ] } ], "source": [ "a = [1,3,5]\n", "print (a)" ] }, { "cell_type": "code", "execution_count": 97, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "uSoSel5kA16d", "outputId": "bae4fffe-f29d-41f0-be76-b74a45e58309", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 3, 5, 7]\n" ] } ], "source": [ "a.append(7) # adds an element to the end\n", "print (a) # the list has changed (unlike string methods!)" ] }, { "cell_type": "code", "execution_count": 98, "metadata": { "id": "4KxTDi30A16d", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 3, 5, 7, 9, 11, 13]\n" ] } ], "source": [ "a.extend([9,11,13]) # concatenates a list at the end\n", "print (a)" ] }, { "cell_type": "code", "execution_count": 99, "metadata": { "id": "8f80xd3SA16d", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 3, 5, 7, 9, 11]\n" ] } ], "source": [ "a.pop() # Removes one element at the end.\n", "print (a)" ] }, { "cell_type": "code", "execution_count": 100, "metadata": { "id": "ilZCq8USA16e", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 3, 7, 9, 11]\n" ] } ], "source": [ "a.pop(2) # Removes 3rd element. \n", "print (a)" ] }, { "cell_type": "markdown", "metadata": { "id": "056OlUDEA16e", "slideshow": { "slide_type": "slide" } }, "source": [ "Don't Forget!!!\n", "-----\n" ] }, { "cell_type": "code", "execution_count": 101, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "4YvwXXovA16e", "outputId": "0d6fb6c0-3c40-4c70-d469-8a560e890f36", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']\n" ] } ], "source": [ "print (dir(a)) # list of methods for a list \"a\"" ] }, { "cell_type": "code", "execution_count": 102, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "a6Q97rYsA16e", "outputId": "6c295bac-1807-438c-8338-d6841415ca89", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on built-in function sort:\n", "\n", "sort(*, key=None, reverse=False) method of builtins.list instance\n", " Sort the list in ascending order and return None.\n", " \n", " The sort is in-place (i.e. the list itself is modified) and stable (i.e. the\n", " order of two equal elements is maintained).\n", " \n", " If a key function is given, apply it once to each list item and sort them,\n", " ascending or descending, according to their function values.\n", " \n", " The reverse flag can be set to sort in descending order.\n", "\n" ] } ], "source": [ "help(a.sort)" ] }, { "cell_type": "markdown", "metadata": { "id": "wN1t_euxA16f", "slideshow": { "slide_type": "slide" } }, "source": [ "Implications of Mutability\n", "----" ] }, { "cell_type": "code", "execution_count": 103, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "9DAlqj_pA16f", "outputId": "5a2fd795-634b-4696-f0e6-7b53b844b8dc", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 2, 3, 4, 5]\n", "[1, 2, 3, 4, 5]\n" ] } ], "source": [ "l = [1,2,3,4]\n", "m = l\n", "\n", "l.append(5)\n", "print (l)\n", "print (m)" ] }, { "cell_type": "markdown", "metadata": { "id": "auD5Nr7lA16f", "slideshow": { "slide_type": "-" } }, "source": [ "l and m point to the same object. When the object mutates, whether you refer to it using l or m, you get the same mutated object." ] }, { "cell_type": "markdown", "metadata": { "id": "TUtRr_bDA16f", "slideshow": { "slide_type": "slide" } }, "source": [ "How do I make a copy then?\n", "---" ] }, { "cell_type": "code", "execution_count": 104, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "3rigVF6nA16f", "outputId": "69cdaea1-f260-4fca-bbd2-061f6c03a610", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 2, 3, 4, 5]\n", "[1, 2, 3, 4]\n" ] } ], "source": [ "l = [1,2,3,4]\n", "m = l[:] \n", "\n", "l.append(5)\n", "print (l)\n", "print (m)" ] }, { "cell_type": "markdown", "metadata": { "id": "6GBBXIZ7A16g", "slideshow": { "slide_type": "-" } }, "source": [ "Python has a module called \"copy\" available for making copies. Refer to the standard library documentation for details." ] }, { "cell_type": "markdown", "metadata": { "id": "dmoKFrsTA16g", "slideshow": { "slide_type": "slide" } }, "source": [ "Dictionaries\n", "----\n", "\n", "* Imagine a list as a collection of objects obj0, obj1, obj2 ... \n", "* First object has a location 0, second 1 ... \n", "* Now, imagine renaming location 0 as \"something\", location 1 as \"somethingelse\" ...\n", "* Earlier, you accessed objects at numbered locations a[0].\n", "* Now, you access objects by specifying location labels a[\"something\"]\n", "\n", "Let's see this at work." ] }, { "cell_type": "code", "execution_count": 105, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Amcw98N2A16g", "outputId": "7953d6cc-f7bb-48bb-ad4d-87b6c5970413", "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3\n", "5\n" ] } ], "source": [ "d1 = { \"a\" : 3, \"b\" : 5}\n", "print (d1[\"a\"])\n", "print (d1[\"b\"])" ] }, { "cell_type": "markdown", "metadata": { "id": "W2AXXMttA16g", "slideshow": { "slide_type": "-" } }, "source": [ "\"a\", \"b\" are called keys and 3,5 are called values. So formally, a dictionary is a collection of key-value pairs." ] }, { "cell_type": "code", "execution_count": 106, "metadata": { "id": "RZOjVbQBA16g", "outputId": "44077c4c-d31a-4071-a3ee-417ac6f67232", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'a': 1, 'b': 5, 'c': 7}\n" ] } ], "source": [ "d1[\"c\"] = 7 # Since \"c\" does not exist, a new key-value pair is made.\n", "d1[\"a\"] = 1 # Since \"a\" exists already, its value is modified.\n", "print (d1) # the ordering of key-value pairs in the dictionary is not guaranteed." ] }, { "cell_type": "markdown", "metadata": { "id": "oEJoF8tgA16h", "slideshow": { "slide_type": "slide" } }, "source": [ "Dictionary Methods\n", "----" ] }, { "cell_type": "code", "execution_count": 107, "metadata": { "id": "TyoqqQYgA16h", "outputId": "aa1f3fb3-6c51-4eeb-b570-e49a29f45f26", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "dict_keys(['a', 'b', 'c'])\n" ] } ], "source": [ "keys = d1.keys() # Returns a list of all keys which is stored in \"keys\".\n", "print (keys)" ] }, { "cell_type": "code", "execution_count": 108, "metadata": { "id": "0suA_6Y7A16h", "outputId": "801a5377-7c36-4b57-c862-ec73e82992ff", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "dict_values([1, 5, 7])\n" ] } ], "source": [ "values = d1.values() # Returns a list of values.\n", "print (values)" ] }, { "cell_type": "code", "execution_count": 109, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "6t4EkkQsA16h", "outputId": "a41c1ab8-bdef-4b84-b4e0-12f59be68aaf", "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "text/plain": [ "dict_items([('a', 1), ('b', 5), ('c', 7)])" ] }, "execution_count": 109, "metadata": {}, "output_type": "execute_result" } ], "source": [ "d1.items() # List of Tuples of key-value pairs." ] }, { "cell_type": "markdown", "metadata": { "id": "bpt8fQKiA16i", "slideshow": { "slide_type": "slide" } }, "source": [ "Defining Dictionaries - ways to do this\n", "-----" ] }, { "cell_type": "code", "execution_count": 110, "metadata": { "id": "neW8cfwrA16i", "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "d1 = {\"a\":3, \"b\":5, \"c\":7} # we've seen this." ] }, { "cell_type": "code", "execution_count": 111, "metadata": { "id": "85cPTIzvA16i", "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "keys = [\"a\", \"b\", \"c\"]\n", "values = [3,5,7]\n", "d2 = dict( zip(keys,values) ) # creates dictionary similar to d1" ] }, { "cell_type": "code", "execution_count": 112, "metadata": { "id": "-Fj8jH_VA16i", "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "d3 = dict( a=3, b=5, c=7) # again, same as d1,d2" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "id": "U6DbMUChA16i", "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "d4 = dict( [ (\"a\",3), (\"b\",5), (\"c\",7) ] ) # same as d1,d2,d3" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Dictionaries in data analysis\n", "===============\n", "\n", "z['M31']\n", "\n", "rmag['M1']\n", "\n", "lumdist['3C 273']\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "Q4vo-kiZA16j", "slideshow": { "slide_type": "slide" } }, "source": [ "The while loop\n", "-------" ] }, { "cell_type": "code", "execution_count": 114, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "y-ufrjSoA16j", "outputId": "cc1d664b-e855-489f-a408-ec143e7a4797", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n", "4\n" ] } ], "source": [ "x = 0\n", "while x<5:\n", " print (x) \n", " x += 1" ] }, { "cell_type": "code", "execution_count": 115, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "34NonpoXA16j", "outputId": "9cc04a7b-1f89-4ca9-bf9a-57cf04730137", "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x = 1\n", "Do you want to continue? y\n", "x = 2\n", "Do you want to continue? y\n", "x = 3\n", "Do you want to continue? n\n" ] } ], "source": [ "x = 1\n", "while True: # Without the break statement this loop is infinite\n", " print (\"x = %d\" % x)\n", " choice = input(\"Do you want to continue? \") \n", " if choice != \"y\":\n", " break # This statement breaks the loop.\n", " else:\n", " x += 1\n", " " ] }, { "cell_type": "markdown", "metadata": { "id": "Tbda_2CdA16j", "slideshow": { "slide_type": "slide" } }, "source": [ "The \"for\" loop - Pay Attention!\n", "-----\n" ] }, { "cell_type": "code", "execution_count": 116, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "5rjetTEOA16j", "outputId": "1366fd90-4a2e-4dcb-91da-628a337f98c3", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5\n", "6\n", "7\n", "8\n", "9\n", "0\n" ] } ], "source": [ "x = [5,6,7,8,9,0] # a simple list\n", "for i in x:\n", " print (i)" ] }, { "cell_type": "markdown", "metadata": { "id": "tFGXNnAJA16k", "slideshow": { "slide_type": "-" } }, "source": [ "In \" for i in x\", x can be many different things, any iterable object is allowed." ] }, { "cell_type": "code", "execution_count": 117, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "pu2stLx-A16k", "outputId": "e181f757-6101-42a3-9f63-9ce7e6fdd8f1", "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "H\n", "e\n", "l\n", "l\n", "o\n", "!\n" ] } ], "source": [ "s = \"Hello!\"\n", "\n", "for c in s:\n", " print (c)" ] }, { "cell_type": "markdown", "metadata": { "id": "1ZgXFvY3A16k", "slideshow": { "slide_type": "-" } }, "source": [ "No No No! I want my good old for-loop back which generates numbers x to y in steps of z!!!" ] }, { "cell_type": "code", "execution_count": 118, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "NyJf9gD1A16k", "outputId": "e8f97a0f-669d-44db-b0e2-9ec3b1d65c9b", "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2\n", "5\n", "8\n", "11\n", "14\n" ] } ], "source": [ "# OKAY!!! Let's try something here.\n", "\n", "for i in range(2,15,3):\n", " print (i)" ] }, { "cell_type": "markdown", "metadata": { "id": "G4ldbddEA16l", "slideshow": { "slide_type": "slide" } }, "source": [ "Let us see some wicked for-loops." ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "-OWbKGo6A16l", "outputId": "282447e5-b068-4ae1-ef8c-c32e919d2611", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "1 H\n", "2 e\n", "3 l\n", "4 l\n", "5 o\n" ] } ], "source": [ "a = [1,2,3,4,5]\n", "b = \"Hello\"\n", "c = zip(a,b)\n", "print(type(c))\n", "\n", "for i,j in c:\n", " print (i, j)" ] }, { "cell_type": "code", "execution_count": 133, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Z3e4q16PA16l", "outputId": "f61e2a59-f3bc-42c4-8d9a-894d93fc901c", "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Character no. 1 is H\n", "Character no. 2 is e\n", "Character no. 3 is l\n", "Character no. 4 is l\n", "Character no. 5 is o\n", "Character no. 6 is !\n", "\n", "Help on class enumerate in module builtins:\n", "\n", "class enumerate(object)\n", " | enumerate(iterable, start=0)\n", " | \n", " | Return an enumerate object.\n", " | \n", " | iterable\n", " | an object supporting iteration\n", " | \n", " | The enumerate object yields pairs containing a count (from start, which\n", " | defaults to zero) and a value yielded by the iterable argument.\n", " | \n", " | enumerate is useful for obtaining an indexed list:\n", " | (0, seq[0]), (1, seq[1]), (2, seq[2]), ...\n", " | \n", " | Methods defined here:\n", " | \n", " | __getattribute__(self, name, /)\n", " | Return getattr(self, name).\n", " | \n", " | __iter__(self, /)\n", " | Implement iter(self).\n", " | \n", " | __next__(self, /)\n", " | Implement next(self).\n", " | \n", " | __reduce__(...)\n", " | Return state information for pickling.\n", " | \n", " | ----------------------------------------------------------------------\n", " | Class methods defined here:\n", " | \n", " | __class_getitem__(...) from builtins.type\n", " | See PEP 585\n", " | \n", " | ----------------------------------------------------------------------\n", " | Static methods defined here:\n", " | \n", " | __new__(*args, **kwargs) from builtins.type\n", " | Create and return a new object. See help(type) for accurate signature.\n", "\n" ] } ], "source": [ "a = \"Hello!\"\n", "\n", "for i, c in enumerate(a):\n", " print (\"Character no. %d is %s\" % (i+1, c)) # i+1 is used because Python is 0-indexed.\n", "\n", "print()\n", "help(enumerate)" ] }, { "cell_type": "markdown", "metadata": { "id": "Y4DC1xNZA16m", "slideshow": { "slide_type": "slide" } }, "source": [ "You can break and continue for-loops too!" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "NadDIWZsA16m", "outputId": "c9042bb6-0b72-4fb5-c58a-e67ca6f5fa5c", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0 is Even\n", "1 is Odd\n", "2 is Even\n", "3 is Odd\n", "4 is Even\n", "5 is Odd\n", "6 is Even\n", "7 is Odd\n" ] } ], "source": [ "for i in range(10000):\n", " if i%2 == 0: # Even\n", " print (i,\"is Even\")\n", " continue\n", " print (i, \"is Odd\")\n", " \n", " if i == 7: # What if I had said \"i==8 or i==10\" ??????\n", " break" ] }, { "cell_type": "markdown", "metadata": { "id": "64dSUMYYA16m", "slideshow": { "slide_type": "slide" } }, "source": [ "Traversing Dictionaries using for-loops\n", "------" ] }, { "cell_type": "code", "execution_count": 136, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "nrQyE8fRA16m", "outputId": "4cd67f4c-d92e-4fb8-8e77-42b07c83a8d9", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a --> 1\n", "b --> 2\n", "c --> 3\n", "d --> 4\n" ] } ], "source": [ "d = dict( a = 1, b = 2, c = 3, d = 4)\n", "\n", "for key,value in d.items():\n", " print (key, \"-->\", value)" ] }, { "cell_type": "code", "execution_count": 123, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "HI5xfzKmA16n", "outputId": "066d30d2-6ff1-42a4-dc96-5746e286a2d3", "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a --> 1\n", "b --> 2\n", "c --> 3\n", "d --> 4\n" ] } ], "source": [ "for key in d.keys():\n", " print (key, \"-->\", d[key])" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Style Guide for Python Code\n", "----------\n", "\n", "The PEP 8 provides excellent guidance on what to do and what to avoid while writing Python code. I strongly urge you to study PEP 8 carefully and implement its recommendations strictly.\n", "\n", " \n", "https://www.python.org/dev/peps/pep-0008/\n", "\n", "The PEP 8 is very terse. For a more expanded explanation see:\n", "\n", "\n", "https://realpython.com/python-pep8/" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "Python is fully Unicode UTF-8 standard compliant\n", "=====" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "What is your name?\n", "আপনার নাম কি?\n", "உங்கள் பெயர் என்ன?\n", "तुझं नाव काय आहे?\n", "तुम्हारा नाम क्या हे?\n" ] } ], "source": [ "print(\"What is your name?\")\n", "print(\"আপনার নাম কি?\")\n", "print(\"உங்கள் பெயர் என்ன?\")\n", "print(\"तुझं नाव काय आहे?\")\n", "print(\"तुम्हारा नाम क्या हे?\")" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "Google provides the Cloud Translation API client library for Python \n", "\n", "https://cloud.google.com/translate/docs/reference/libraries/v2/python" ] } ], "metadata": { "celltoolbar": "Slideshow", "colab": { "name": "basicpython2.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.9.7" } }, "nbformat": 4, "nbformat_minor": 1 }