From fe1143366c9e09793b383c4117b00360659430fe Mon Sep 17 00:00:00 2001 From: asad755 <143116178+asad755@users.noreply.github.com> Date: Mon, 5 Feb 2024 04:43:47 +0500 Subject: [PATCH 1/4] ok --- .../1. Jarvis Virtual Assistant/1. jarvis.py | 1 + 1 file changed, 1 insertion(+) diff --git a/02-Day2-Application-of-Python/1. Jarvis Virtual Assistant/1. jarvis.py b/02-Day2-Application-of-Python/1. Jarvis Virtual Assistant/1. jarvis.py index 6e0baf3..7c1bef6 100644 --- a/02-Day2-Application-of-Python/1. Jarvis Virtual Assistant/1. jarvis.py +++ b/02-Day2-Application-of-Python/1. Jarvis Virtual Assistant/1. jarvis.py @@ -1,3 +1,4 @@ + # pip install pyaudio import pyttsx3 #pip install pyttsx3 From 3ba55749853ef348042374238e1de451379cbdae Mon Sep 17 00:00:00 2001 From: asad755 <143116178+asad755@users.noreply.github.com> Date: Wed, 7 Feb 2024 01:48:11 +0500 Subject: [PATCH 2/4] Created using Colaboratory --- Untitled5.ipynb | 182 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 182 insertions(+) create mode 100644 Untitled5.ipynb diff --git a/Untitled5.ipynb b/Untitled5.ipynb new file mode 100644 index 0000000..d4b5631 --- /dev/null +++ b/Untitled5.ipynb @@ -0,0 +1,182 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyP7rf4eGeYWVbr7xcUcIcSH", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "WNAmyHI8gOS-", + "outputId": "583d2d17-0dce-4b3a-f2dd-b25185bd32e4" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Writing test.py\n" + ] + } + ], + "source": [ + "%%writefile test.py\n", + "print(\"as salamoelkom\")\n", + "a = 10\n", + "print(a)" + ] + }, + { + "cell_type": "code", + "source": [ + "!python /content/test.py" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cvGNFNz3LMBS", + "outputId": "dcc50027-4aec-4ae5-a2b3-0d269e1527da" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "as salamoelkom\n", + "10\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/drive')" + ], + "metadata": { + "id": "5pzPANvWsYBp" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "python /content/drive/MyDrive/another.py.txt" + ], + "metadata": { + "id": "pgcHXXuzvIPH" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "!pip install subprocess" + ], + "metadata": { + "id": "p1LKqYJIvfCX" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import drive/content/drive/MyDrive/another.py.txt" + ], + "metadata": { + "id": "du6tHMfSv8Bn" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "!python '/content/drive/MyDrive/another.py.txt'" + ], + "metadata": { + "id": "Ix3MSLhvwrGj" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "!pip import subprocess" + ], + "metadata": { + "id": "podeslPQvkm5" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "python /content/drive/MyDrive/another.py.txt" + ], + "metadata": { + "id": "E6LHMCpjuk7c" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "!python /content/test.py" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "KdMqg0GxhTHM", + "outputId": "b318fcc5-7f36-4aaa-9981-2e4e389f472b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "as salamoelkom\n", + "10\n" + ] + } + ] + } + ] +} \ No newline at end of file From b3f35758e164afd280c03b06982a940be82e0e10 Mon Sep 17 00:00:00 2001 From: asad755 <143116178+asad755@users.noreply.github.com> Date: Wed, 7 Feb 2024 03:01:46 +0500 Subject: [PATCH 3/4] Created using Colaboratory --- Untitled0.ipynb | 64 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) create mode 100644 Untitled0.ipynb diff --git a/Untitled0.ipynb b/Untitled0.ipynb new file mode 100644 index 0000000..43852e5 --- /dev/null +++ b/Untitled0.ipynb @@ -0,0 +1,64 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "toc_visible": true, + "authorship_tag": "ABX9TyNisnaBaMZhuKvXMJOrqIAx", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 430 + }, + "id": "X4r6mrlBbAu3", + "outputId": "f56f09f6-3033-4c22-9061-7bf2287c7b74" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "xpts = np.array([0,4])\n", + "ypts = np.array([0,100])\n", + "\n", + "plt.plot(xpts, ypts)\n", + "plt.show()" + ] + } + ] +} \ No newline at end of file From 193a80076416e1356949fd9359a45a98b757be9e Mon Sep 17 00:00:00 2001 From: asad755 <143116178+asad755@users.noreply.github.com> Date: Wed, 7 Feb 2024 03:31:02 +0500 Subject: [PATCH 4/4] Created using Colaboratory --- asadtuple.ipynb | 127 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 127 insertions(+) create mode 100644 asadtuple.ipynb diff --git a/asadtuple.ipynb b/asadtuple.ipynb new file mode 100644 index 0000000..8fd3ca1 --- /dev/null +++ b/asadtuple.ipynb @@ -0,0 +1,127 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyOqLWNoMqBYdNI5yT1TVfos", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "xTxkJDH7gihg" + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "source": [ + "mytuple1 = '(\"Asad\", \"craig, \"Ronaldo\",\" Messi\")'\n", + "print(mytuple1)\n", + "\n", + "mytuple2 = (10, 20, 50, 100)\n", + "print(mytupleu2)\n", + "" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 253 + }, + "id": "c-49veoXgtJX", + "outputId": "1fe66eb2-df6d-4f10-8e84-fc8ee4a8fa18" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(\"Asad\", \"craig, \"Ronaldo\",\" Messi\")\n" + ] + }, + { + "output_type": "error", + "ename": "NameError", + "evalue": "name 'mytupleu2' is not defined", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\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[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mmytuple2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m20\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m50\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m100\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmytupleu2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'mytupleu2' is not defined" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# prompt:\n", + "\n", + "# Preceding code has a typo in the second print statement: 'mytupleu2' should be 'mytuple2'.\n", + "# Here's the corrected code:\n", + "\n", + "mytuple1 = ('Asad', 'craig', 'Ronaldo', 'Messi')\n", + "print(mytuple1)\n", + "\n", + "mytuple2 = (10, 20, 50, 100)\n", + "print(mytuple2)\n" + ], + "metadata": { + "id": "D--mIwQLh1Em" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "mytuple1 = ('Asad', 'craig', 'Ronaldo', 'Messi')\n", + "print(mytuple1)\n", + "\n", + "mytuple2 = (10, 20, 50, 100)\n", + "print(mytuple2)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "tDmyvorJiC9s", + "outputId": "3164e37c-57e0-4d74-ea40-7b67010f7672" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "('Asad', 'craig', 'Ronaldo', 'Messi')\n", + "(10, 20, 50, 100)\n" + ] + } + ] + } + ] +} \ No newline at end of file