CT_2_APP.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# 4-marks:"
      ],
      "metadata": {
        "id": "493Z5qzAiuZo"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Python code to work with SQL commands\n",
        "```py\n",
        "import mysql.connector \n",
        "database = mysql.connector.connect(host=\"localhost\",user=\"username\",password=\"password\")\n",
        "cursor = database.cursor()\n",
        "query = \"CREATE database Student\"\n",
        "cursor.execute(query)\n",
        "query1 = \"CREATE TABLE students (name varchar(25), roll_no int(10), class varchar(5)\n",
        "cursor.execute(query1)\n",
        "```"
      ],
      "metadata": {
        "id": "qaBLRFyAaQiv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## First class Function\n",
        "```py\n",
        "def shout(text):\n",
        "  return text.upper()\n",
        "def whisper(text):\n",
        "  return text.lower()\n",
        "\n",
        "input_ = str(input(\"Enter shout/whisper\"))\n",
        "text_ = str(input(\"enter text\"))\n",
        "if(input_ ==\"shout\"):\n",
        "  shout = shout(text_)\n",
        "else:\n",
        "  whisper = whisper(text_)\n",
        "\n",
        "print(shout)\n",
        "print(whisper)\n"
      ],
      "metadata": {
        "id": "LsvlIx81aX2m"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Closure in python\n",
        "Python closure is a nested function that allows us to access variables of the outer function even after the outer function is closed.\n",
        "\n",
        "In Python, we can create a function inside another function. This is known as a nested function. For example,\n",
        "\n",
        "```py\n",
        "def greet(name):\n",
        "    def display_name():\n",
        "        print(\"Hi\", name)\n",
        "    display_name()\n",
        "\n",
        "greet(\"Anirudh\")  \n"
      ],
      "metadata": {
        "id": "LkVUYNbrbnmu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "## Functional and Procedural\n",
        "\n",
        "Functional: Python too supports Functional Programming paradigms without the support of any special features or libraries.\n",
        "\n",
        "Pure Functions\n",
        "pure functions have two properties.\n",
        "\n",
        "It always produces the same output for the same arguments. For example, 3+7 will always be 10 no matter what.\n",
        "It does not change or modifies the input variable.\n",
        "\n",
        "```py\n",
        "def pure_func(List):\n",
        "    New_List = []\n",
        "    for i in List:\n",
        "        New_List.append(i**2)\n",
        "    return New_List\n",
        "```\n",
        "\n",
        "Procedural: Procedural programming simply contains a series of computational steps, these steps instruct the computer on how to solve a task in logical steps. Procedural programming is best for simple programs but is better is use other programming paradigms for solving complex programs.\n",
        "\n",
        "```py\n",
        "def sum_of(elements=None):\n",
        "  if(elements==None):\n",
        "    return False\n",
        "  else:\n",
        "    return sum(elements)\n",
        "```"
      ],
      "metadata": {
        "id": "RRUX8ueRb_Em"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Variation in font size using html tags \n",
        "\n",
        "**Write these in python:**\n",
        "```py\n",
        "f = open('fonts.html', 'w')\n",
        "html_template = \"\"\"<!DOCTYPE html>\n",
        "<html>\n",
        "\n",
        "   <head>\n",
        "      <title>Setting Font Size</title>\n",
        "   </head>\n",
        "\n",
        "   <body>\n",
        "      <font size = \"1\">Font size = \"1\"</font><br />\n",
        "      <font size = \"2\">Font size = \"2\"</font><br />\n",
        "      <font size = \"3\">Font size = \"3\"</font><br />\n",
        "      <font size = \"4\">Font size = \"4\"</font><br />\n",
        "      <font size = \"5\">Font size = \"5\"</font><br />\n",
        "      <font size = \"6\">Font size = \"6\"</font><br />\n",
        "      <font size = \"7\">Font size = \"7\"</font>\n",
        "   </body>\n",
        "\n",
        "</html>\n",
        "\"\"\"\n",
        "f.write(html_template)\n",
        "f.close()\n",
        "```"
      ],
      "metadata": {
        "id": "5se15RRadHg_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Higher order functions\n",
        "A function is called Higher Order Function if it contains other functions as a parameter or returns a function as an output i.e, the functions that operate with another function are known as Higher order Functions. It is worth knowing that this higher order function is applicable for functions and methods as well that takes functions as a parameter or returns a function as a result. Python too supports the concepts of higher order functions.\n",
        "\n",
        "```py\n",
        "def create_adder(x): \n",
        "    def adder(y): \n",
        "        return x + y \n",
        "    return adder \n",
        "add_15 = create_adder(15) \n",
        "print(add_15(10))\n",
        "```"
      ],
      "metadata": {
        "id": "czuk89F3eA62"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 12-marks:"
      ],
      "metadata": {
        "id": "OFGuoAoqixnA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Turtle package:\n",
        "\n",
        "“Turtle” is a Python feature like a drawing board, which lets us command a turtle to draw all over it! We can use functions like turtle.forward(…) and turtle.right(…) which can move the turtle around.\n",
        "\n",
        "To make use of the turtle methods and functionalities, we need to import turtle.”turtle” comes packed with the standard Python package and need not be installed externally. The roadmap for executing a turtle program follows 4 steps:  \n",
        "\n",
        "1. Import the turtle module\n",
        "2. Create a turtle to control.\n",
        "3. Draw around using the turtle methods.\n",
        "4. Run turtle.done().\n",
        "\n",
        "\n",
        "*Programs:*\n",
        "```py\n",
        "from turtle import *\n",
        "c = turtle.Turtle()\n",
        "for i in range(4):\n",
        "    c.forward(50)\n",
        "    c.right(90)\n",
        "     \n",
        "turtle.done()\n",
        "```\n",
        "*Output*:\n",
        "\n",
        "![image.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAARYAAADKCAIAAADvpPj4AAAEVklEQVR4nO3aMU6afxzH8Qf/bToBE066OkAv0KFJJ72AxB6gFzAeQD2A8QbOJgyeoRNeACbjAHRyaHHr0uc/PIlpmi74Kf6qfb0mCA6f5R2+gK26rivgsTZKD4DnTUIQkRBEJAQRCUFEQhCREEQkBBEJQURCEJEQRCQEEQlBREIQkRBEJAQRCUFEQhCREEQkBBEJQURCEJEQRCQEEQlBREIQkRBEJAQRCUFEQhCREEQkBBEJQURCEJEQRCQEEQlBREIQkRBEJAQRCUFEQquZTCanp6fT6bT0EP4Wr0oPeGaahDqdTl3XVVVtb293Op3SoyjJu9DK6ro+Pz8/ODg4ODi4vr4uPYfC/js5OSm94Znp9Xo3NzfT6fTu7u779+/T6fTz58+bm5u9Xq/0NApwyK1mMBj0+/3pdNp8HBqNRqPRqKoqp90/yyH3ZzycduPxuPQWnpRDbmWtVqt58PP3cvf393d3dz+fdr1eb3Nzs9BGno5D7jGGw2Fd180J94uH067dbj/5rqfWbre3trY2Nv7pW0ZC63J+fn5xcVF6xXp9+PDh7OzszZs3pYeUJKF1WSwWnU5nOBw+HH4vzNXV1Ww2+/HjR+khhUnoMebz+WKx+O1LW1tb3W63+ZvBYHB8fPxSE7q9vf369WvpFeVJaGXNT6u//SBUVdXh4eHe3l5VVUdHR0+7izIk9BiLxeKXd6HhcDgYDKqq2tvbax50u93mlyJeNgmt5v7+fjabLZfL5unDD6mfPn3a3d0tOo0yJLSa8Xh8dHQ0n8+bp4eHh00529vbRXdRjIRWs1wuJ5PJz2dbv98vPYqSJLSabrf79u1bZxsPJLSad+/eXV5eOtt4IKHVdDqd5oSDxj/9302QkxBEJAQRCUFEQhCREEQkBBEJQURCEJEQRCQEEQlBREIQkRBEJAQRCUFEQhCREEQkBBEJQURCEJEQRCQEEQlBREIQkRBEJAQRCUFEQhCREEQkBBEJQURCEJEQRCQEEQlBREIQkRBEJAQRCUFEQhCREEQkBBEJQURCEJEQRCQEEQlBREIQkRBEJAQRCUFEQhCREEQkBBEJQURCEJEQRCQEEQlBREIQkRBEJASRV6UHvGTL5XIymbRardJD1uLbt2+lJ/wVJLRG19fXHz9+LL1iXb58+fL+/fvSK8qT0Lrs7+/3+/3SK9ZrZ2fn9evXpVcU1qrruvQGeMZ8nQARCUFEQhCREEQkBBEJQURCEJEQRCQEEQlBREIQkRBEJAQRCUFEQhCREEQkBBEJQURCEJEQRCQEEQlBREIQkRBEJAQRCUFEQhCREEQkBBEJQURCEJEQRCQEEQlBREIQkRBEJAQRCUFEQhCREEQkBBEJQURCEJEQRCQEEQlBREIQkRBEJAQRCUFEQhCREEQkBBEJQURCEJEQRCQEEQlBREIQkRBEJAQRCUFEQhCREEQkBBEJQURCEJEQRCQEEQlBREIQkRBEJAQRCUHkf040zZMwmvyCAAAAAElFTkSuQmCC)\n",
        "\n",
        "```py\n",
        "screen = turtle.Screen()\n",
        "screen.bgcolor(\"white\")\n",
        "pen = turtle.Turtle()\n",
        "pen.speed(0)\n",
        "pen.fillcolor(\"red\")\n",
        "pen.begin_fill()\n",
        "pen.circle(100)\n",
        "pen.end_fill()\n",
        "pen.hideturtle()\n",
        "turtle.done()\n",
        "```\n",
        "*Output:*\n",
        "\n",
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "kO5sKoDNi4CH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Webpage using HTML tags:\n",
        "\n",
        "```html\n",
        "<!DOCTYPE html>\n",
        "<html>\n",
        "\n",
        "<head>\n",
        "  <meta charset=\"utf-8\">\n",
        "  <meta name=\"viewport\" content=\"width=device-width\">\n",
        "  <title>replit</title>\n",
        "  <link href=\"style.css\" rel=\"stylesheet\" type=\"text/css\" />\n",
        "</head>\n",
        "\n",
        "<body>\n",
        "  <h1>Welcome!</h1>\n",
        "  </br>\n",
        "  <h3>Popular Programming languages:</h3>\n",
        "  <ul>\n",
        "    <li>Python</li>\n",
        "    <li>Javascript</li>\n",
        "    <li>C++</li>\n",
        "    <li>Java</li>\n",
        "  </ul>\n",
        "  <h3>Popular Technologies:</h3>\n",
        "  <ol>\n",
        "    <li>Cloud</li>\n",
        "    <li>Database</li>\n",
        "    <li>Automation</li>\n",
        "  </ol>\n",
        "</body>\n",
        "\n",
        "</html>\n",
        "```"
      ],
      "metadata": {
        "id": "JDZTl_pHkcdY"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Locks and Rlocks in python:\n",
        "\n",
        "**Locks:**\n",
        "\n",
        "These are the simplest primitive for synchronization in Python. There are two states of a lock i.e locked and unlocked. A lock is a class in the threading module whose object generated in the unlocked state and has two primary methods i.e acquire() and release(). When the acquire() method is called, it locks the execution of the Lock and blocks it’s execution until the release() method is called in some other thread which sets it to unlock state. Locks help us in efficiently accessing a shared resource in a program in order to prevent corruption of data, it follows mutual exclusion as only one thread can access a particular resource at a time.\n",
        "\n",
        "```py\n",
        "import threading\n",
        "lock = threading.Lock()\n",
        "a = 0\n",
        "def sumOne():\n",
        "       global a\n",
        "       lock.acquire()\n",
        "       a +=1\n",
        "       lock.release()\n",
        "def sumTwo():\n",
        "       global a\n",
        "       lock.acquire()\n",
        "       a+=2\n",
        "       lock.release()\n",
        "sumOne()\n",
        "sumTwo()\n",
        "print(a)\n",
        "```\n",
        "\n",
        "**RLocks:**\n",
        "\n",
        "The default Lock doesn’t recognize which thread the lock currently holds. If the shared resource is being accessed by any thread then other threads trying to access the shared resource will get blocked even if it is the same thread that locked the shared resource. The Re-entrant lock or RLock is used in these situations to prevent undesired blocking from accessing the shared resource. If a shared resource is in RLock then it can be called again safely. The RLocked resource can be accessed repeatedly by various threads, though it still works correctly when called by different threads.\n",
        "\n",
        "```py\n",
        "import threading\n",
        "lock = threading.RLock()\n",
        "a = 0\n",
        "lock.acquire()\n",
        "a +=1\n",
        "lock.acquire()\n",
        "a+=2\n",
        "lock.release()\n",
        "lock.release()\n",
        "print(a)\n",
        "```"
      ],
      "metadata": {
        "id": "97HtbMhbl4Dp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Types and methods for parallelism\n",
        "\n",
        "**Types:**\n",
        "\n",
        "i) Explicit parallelism:\n",
        "- Characterized by the presence of explicit constructs in the programming language, aimed at describing the way in which the parallel computation will take place.\n",
        "- A wide range of solutions exists within this framework.\n",
        "\n",
        "ii) Implicit parallelism:\n",
        "- Allows programmers to write their programs without any concern about the exploitation of parallelism. Parallelism is transparent  to the programmer maintaining the complexity of software development at the same level of standard sequential programming.\n",
        "- Declarative programming languages and in particular functional and logic languages are characterized by very high level of abstraction\n",
        "- opened new doors to automatic exploitation of parallelism\n",
        "\n",
        "\n",
        "There are many methods of programming parallel computers. Two of the most common are message passing and data parallel.\n",
        "1. Message passing - The user makes calls to libraries to explicitly share information between processors.\n",
        "2. Data Parallel - data partitioning determines parallelism\n",
        "3. Shared Memory - multiple processes sharing common memory space\n",
        "4. Remote Memory Operation - set of processes in which a process can access the memory of another process without its participation\n",
        "5. Threads - a single process having multiple execution paths\n",
        "6. Combined Models - composed of two or more of the above\n",
        "\n",
        "**Message passing:**\n",
        "* Each processor has direct access only to its local memory \n",
        "* Processors are connected via high-speed interconnect\n",
        "* Data exchange is done via explicit processor-to-processor communication\n",
        "* Data transfer requires cooperative operations to be performed by each process\n",
        "\n",
        "**Data Parallel:**\n",
        "* Each process works on a different part of the same data structure.\n",
        "* Processors have direct access to global memory and I/O thru bus or fast switching network.\n",
        "* Each processor also has its own memory \n",
        "* All message passing is done invisibly to the programmer.\n",
        "\n",
        "**Steps in parallelism:**\n",
        "\n",
        "* Independently from the specific paradigm considered, in order to execute a\n",
        "program which exploits parallelism, the programming language must supply the\n",
        "means to:\n",
        "  * Identify parallelism, by recognizing the components of the program execution\n",
        "that will be (potentially) performed by different processors;\n",
        "  * Start and stop parallel executions.\n",
        "  * Coordinate the parallel executions"
      ],
      "metadata": {
        "id": "bzpvuSBsnok5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        " "
      ],
      "metadata": {
        "id": "2GTssVnOaAmu"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}