From 116569941a87f3efbc2d65fabcb48bfb6af8a5b3 Mon Sep 17 00:00:00 2001
From: Victoria Lee <57614185+VictoriaRaven@users.noreply.github.com>
Date: Tue, 28 Oct 2025 13:45:20 -0700
Subject: [PATCH] Add files via upload
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Completed Course 7 out of 9 for Python. Automate Cybersecurity Tasks with Python
— Explore the Python programming language and write code to automate cybersecurity tasks.
---
Activity_Assign Python variables.ipynb | 1057 ++++++++++++++++
Activity_Assign Python variables.pdf | Bin 0 -> 67383 bytes
Activity_Create another algorithm.ipynb | 1115 +++++++++++++++++
Activity_Create another algorithm.pdf | Bin 0 -> 77209 bytes
Activity_Create more functions.ipynb | 894 +++++++++++++
Activity_Create more functions.pdf | Bin 0 -> 68692 bytes
Activity_Define and call a function.ipynb | 665 ++++++++++
Activity_Define and call a function.pdf | Bin 0 -> 58851 bytes
Activity_Develop an algorithm.ipynb | 1062 ++++++++++++++++
Activity_Develop an algorithm.pdf | Bin 0 -> 79395 bytes
Activity_Import and parse a text file.ipynb | 813 ++++++++++++
Activity_Import and parse a text file.pdf | Bin 0 -> 69589 bytes
...regular expressions to find patterns.ipynb | 932 ++++++++++++++
...e regular expressions to find patterns.pdf | Bin 0 -> 79128 bytes
Activity_Work with strings in Python.ipynb | 887 +++++++++++++
Activity_Work with strings in Python.pdf | Bin 0 -> 62040 bytes
...r-file-updates-in-Python-MY-RESPONSES.docx | Bin 0 -> 2351478 bytes
...or-file-updates-in-Python-MY-RESPONSES.pdf | Bin 0 -> 192569 bytes
Course-7-glossary.docx | Bin 0 -> 2748492 bytes
Exemplar_Create loops.ipynb | 877 +++++++++++++
Exemplar_Create loops.pdf | Bin 0 -> 64172 bytes
LAB_014_Activity.ipynb | 798 ++++++++++++
LAB_014_Activity.pdf | Bin 0 -> 62935 bytes
...Activity_CreateAConditionalStatement.ipynb | 944 ++++++++++++++
LAB_Activity_CreateAConditionalStatement.pdf | Bin 0 -> 74454 bytes
LAB_Activity_PracticeWritingPythonCode.ipynb | 529 ++++++++
LAB_Activity_PracticeWritingPythonCode.pdf | Bin 0 -> 45268 bytes
Python concepts from module 1.pdf | Bin 0 -> 61118 bytes
Python concepts from module 2.pdf | Bin 0 -> 56752 bytes
Python concepts from module 3.pdf | Bin 0 -> 70515 bytes
Python concepts from module 4.pdf | Bin 0 -> 47717 bytes
...e Guide_ Python concepts from Course 7.pdf | Bin 0 -> 109569 bytes
32 files changed, 10573 insertions(+)
create mode 100644 Activity_Assign Python variables.ipynb
create mode 100644 Activity_Assign Python variables.pdf
create mode 100644 Activity_Create another algorithm.ipynb
create mode 100644 Activity_Create another algorithm.pdf
create mode 100644 Activity_Create more functions.ipynb
create mode 100644 Activity_Create more functions.pdf
create mode 100644 Activity_Define and call a function.ipynb
create mode 100644 Activity_Define and call a function.pdf
create mode 100644 Activity_Develop an algorithm.ipynb
create mode 100644 Activity_Develop an algorithm.pdf
create mode 100644 Activity_Import and parse a text file.ipynb
create mode 100644 Activity_Import and parse a text file.pdf
create mode 100644 Activity_Use regular expressions to find patterns.ipynb
create mode 100644 Activity_Use regular expressions to find patterns.pdf
create mode 100644 Activity_Work with strings in Python.ipynb
create mode 100644 Activity_Work with strings in Python.pdf
create mode 100644 Algorithm-for-file-updates-in-Python-MY-RESPONSES.docx
create mode 100644 Algorithm-for-file-updates-in-Python-MY-RESPONSES.pdf
create mode 100644 Course-7-glossary.docx
create mode 100644 Exemplar_Create loops.ipynb
create mode 100644 Exemplar_Create loops.pdf
create mode 100644 LAB_014_Activity.ipynb
create mode 100644 LAB_014_Activity.pdf
create mode 100644 LAB_Activity_CreateAConditionalStatement.ipynb
create mode 100644 LAB_Activity_CreateAConditionalStatement.pdf
create mode 100644 LAB_Activity_PracticeWritingPythonCode.ipynb
create mode 100644 LAB_Activity_PracticeWritingPythonCode.pdf
create mode 100644 Python concepts from module 1.pdf
create mode 100644 Python concepts from module 2.pdf
create mode 100644 Python concepts from module 3.pdf
create mode 100644 Python concepts from module 4.pdf
create mode 100644 Reference Guide_ Python concepts from Course 7.pdf
diff --git a/Activity_Assign Python variables.ipynb b/Activity_Assign Python variables.ipynb
new file mode 100644
index 0000000..570d309
--- /dev/null
+++ b/Activity_Assign Python variables.ipynb
@@ -0,0 +1,1057 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ISr45HAPh1Xq"
+ },
+ "source": [
+ "# Activity: Assign Python variables"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ivt8p77hCKcO"
+ },
+ "source": [
+ "## Introduction\n",
+ "\n",
+ "Variables help security analysts to keep track of a variety of security-related information. For example, analysts may need to create Python variables for the users who are allowed to log in, the number of login attempts that they're permitted, and the current number of attempts that a user has made.\n",
+ "\n",
+ "In this lab, you'll practice assigning values to variables and determining their data types."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "eW4pA4LsC-vb"
+ },
+ "source": [
+ "Tips for completing this lab
\n",
+ "\n",
+ "As you navigate this lab, keep the following tips in mind:\n",
+ "\n",
+ "- `### YOUR CODE HERE ###` indicates where you should write code. Be sure to replace this with your own code before running the code cell.\n",
+ "- Feel free to open the hints for additional guidance as you work on each task.\n",
+ "- To enter your answer to a question, double-click the markdown cell to edit. Be sure to replace the \"[Double-click to enter your responses here.]\" with your own answer.\n",
+ "- You can save your work manually by clicking File and then Save in the menu bar at the top of the notebook.\n",
+ "- You can download your work locally by clicking File and then Download and then specifying your preferred file format in the menu bar at the top of the notebook.\n",
+ "\n",
+ " Hint 1
\n",
+ "\n",
+ "Use quotation marks around the value that you assign to the `device_id` variable.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "jj2jLLzLUcW5"
+ },
+ "source": [
+ "\n",
+ " Hint 2
\n",
+ "\n",
+ "Assign the value `\"72e08x0\"` to the variable `device_id`. To do this, place the value to right of the `=` operator.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "qpHMOi8vUcW5"
+ },
+ "source": [
+ "\n",
+ " Hint 3
\n",
+ "\n",
+ "To display the contents of `device_id`, place the name of this variable inside the `print()` function.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Xky9BjthiYqm"
+ },
+ "source": [
+ "## Task 2\n",
+ "Now that the variable `device_id` is defined, you can return its data type.\n",
+ "\n",
+ "In this task, use a Python function to find the data type of the variable `device_id`. Store the data type in another variable called `device_id_type`. Then, display `device_id_type` to examine the output.\n",
+ "\n",
+ "Be sure to replace each `### YOUR CODE HERE ###` with your own code before you run the following cell.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {
+ "id": "9w0g21J7i01H"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Assign the `device_id` variable to the device ID that only specified users can access\n",
+ "\n",
+ "device_id = \"72e08x0\"\n",
+ "\n",
+ "# Assign `device_id_type` to the data type of `device_id`\n",
+ "\n",
+ "device_id_type = type(device_id)\n",
+ "\n",
+ "# Display `device_id_type`\n",
+ "\n",
+ "print(device_id_type)\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "SF-DtKYyrLak",
+ "tags": []
+ },
+ "source": [
+ "\n",
+ " Hint 1
\n",
+ "\n",
+ "The `type()` function allows you to get the data type of a given value.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "PEcJeExRrLat"
+ },
+ "source": [
+ "\n",
+ " Hint 2
\n",
+ "\n",
+ "Use `type(device_id)` to get the data type of the `device_id` variable.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "fLVHruphrp49"
+ },
+ "source": [
+ "\n",
+ " Hint 3
\n",
+ "\n",
+ "To display `device_id_type`, place the name of this variable inside the `print()` function.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "g_03rNzrd8F0"
+ },
+ "source": [
+ "#### **Question 1**\n",
+ "**Based on the output above, what do you observe about the data type of `device_id`?**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "yxv9ICX_egCB"
+ },
+ "source": [
+ "After puting type to device_id_type and then inserting the device_id to it, it outputs when device_id_type is called. This means it is a string type."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "QP05AxAwi_vL"
+ },
+ "source": [
+ "## Task 3\n",
+ "As you continue your work, you're provided a list of usernames of users who are allowed to access the device. The usernames with this access are `\"madebowa\"`, `\"jnguyen\"`, `\"tbecker\"`, `\"nhersh\"`, and `\"redwards\"`.\n",
+ "\n",
+ "In this task, create a variable called `username_list`. Assign a list with the approved usernames to this variable. Then, display the value of the `username_list` variable.\n",
+ "\n",
+ "Be sure to replace each `### YOUR CODE HERE ###` with your own code before you run the following cell."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {
+ "id": "cgmlPvWLkBEM"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "['madebowa', 'jnguyen', 'tbecker', 'nhersh', 'redwards']\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Assign `username_list` to the list of usernames who are allowed to access the device\n",
+ "\n",
+ "username_list = [\"madebowa\", \"jnguyen\", \"tbecker\", \"nhersh\", \"redwards\"]\n",
+ "\n",
+ "# Display `username_list`\n",
+ "\n",
+ "print(username_list)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "9zon3fxlbZiG"
+ },
+ "source": [
+ "\n",
+ " Hint 1
\n",
+ "\n",
+ "To create a list in Python, use square brackets. Inside the square brackets, write the elements of the list, with a comma between elements.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "J73Rv91PUoES"
+ },
+ "source": [
+ "\n",
+ " Hint 2
\n",
+ "\n",
+ "To assign a value to a variable in Python, place the name of the variable to the left of the `=` operator, and place the value to the right of the `=` operator.\n",
+ "\n",
+ "In this task, make sure to place `[\"madebowa\", \"jnguyen\", \"tbecker\", \"nhersh\", \"redwards\"]` to the right of the `=` operator.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "OQTnnv6TbZiG"
+ },
+ "source": [
+ "\n",
+ " Hint 3
\n",
+ "\n",
+ "To display `username_list`, place the name of this variable inside the `print()` function.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "89fOQheQ076R"
+ },
+ "source": [
+ "## Task 4\n",
+ "In this task, find the data type of the `username_list`. Store the type in a variable called `username_list_type`. Then, display `username_list_type` to examine the output.\n",
+ "\n",
+ "Be sure to replace each `### YOUR CODE HERE ###` with your own code before you run the following cell."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {
+ "id": "Yzpvr9WJ1Pi8"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Answer:\n",
+ "\n",
+ "\n",
+ "Now for Alt (Specific) is below:\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Assign `username_list` to the list of usernames who are allowed to access the device\n",
+ "\n",
+ "username_list = [\"madebowa\", \"jnguyen\", \"tbecker\", \"nhersh\", \"redwards\"]\n",
+ "\n",
+ "# Assign `username_list_type` to the data type of `username_list`\n",
+ "\n",
+ "username_list_type = type(username_list)\n",
+ "\n",
+ "# Display `username_list_type`\n",
+ "print(\"Answer:\")\n",
+ "print(username_list_type)\n",
+ "\n",
+ "# Optionla: Alternative method (Specific)\n",
+ "print()\n",
+ "print(\"Now for Alt (Specific) is below:\")\n",
+ "username_list_type = type(username_list[0])\n",
+ "print(username_list_type)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "_A6GgpvQcEdv"
+ },
+ "source": [
+ "\n",
+ " Hint 1
\n",
+ "\n",
+ "The `type()` function allows you to get the data type of a given value.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "sk0EVD3ecEdw"
+ },
+ "source": [
+ "\n",
+ " Hint 2
\n",
+ "\n",
+ "To get the data type of `username_list`, call the `type()` function and pass in `username_list`.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "pEetodFVcEdw"
+ },
+ "source": [
+ "\n",
+ " Hint 3
\n",
+ "\n",
+ "In Python, you can use the `print()` function to display the value of a variable. To display `username_list_type`, call the `print()` function and pass in `username_list_type`.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "2Q916P--eiMt"
+ },
+ "source": [
+ "#### **Question 2**\n",
+ "**Based on the output above, what do you observe about the data type of `username_list`?**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "a__dHuhGeiMt"
+ },
+ "source": [
+ "After puting type to username_list_type and then inserting the username_list to it, it outputs when username_list_type is called. This means it is a list type. However, if you change the code as below the print to alternative method and be very specific of what is username_list like username_list[0], you will get the type of the first element in the list which is a string type."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "cvV_L70okWNI"
+ },
+ "source": [
+ "## Task 5\n",
+ "Now, imagine that you've been informed that the previous list is not up-to-date and that there is another employee that now has access to the device. You're given the updated list of usernames with access, including the new employee, as follows: `\"madebowa\"`, `\"jnguyen\"`, `\"tbecker\"`, `\"nhersh\"`, `\"redwards\"`, and `\"lpope\"`.\n",
+ "\n",
+ "In this task, reassign the variable `username_list` to the new list. Run the code to display the list before and after it's been updated to observe the difference.\n",
+ "\n",
+ "Be sure to replace each `### YOUR CODE HERE ###` with your own code before you run the following cell."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {
+ "id": "fLt9BzUFkXmG"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "['madebowa', 'jnguyen', 'tbecker', 'nhersh', 'redwards']\n",
+ "['madebowa', 'jnguyen', 'tbecker', 'nhersh', 'redwards', 'lpope']\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Assign `username_list` to the list of usernames who are allowed to access the device\n",
+ "\n",
+ "username_list = [\"madebowa\", \"jnguyen\", \"tbecker\", \"nhersh\", \"redwards\"]\n",
+ "\n",
+ "# Display `username_list`\n",
+ "\n",
+ "print(username_list)\n",
+ "\n",
+ "# Assign `username_list` to the updated list of usernames who are allowed to access the device\n",
+ "\n",
+ "username_list = [\"madebowa\", \"jnguyen\", \"tbecker\", \"nhersh\", \"redwards\", \"lpope\"]\n",
+ "\n",
+ "# Display `username_list`\n",
+ "\n",
+ "print(username_list)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "02bW-FQSgYX7"
+ },
+ "source": [
+ "\n",
+ " Hint 1
\n",
+ "\n",
+ "When reassigning a variable to a new value in Python, place the name of the variable to the left of the `=` operator, just as you would when assigning the variable for the first time.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ETcEZOqnU1pz"
+ },
+ "source": [
+ "\n",
+ " Hint 2
\n",
+ "\n",
+ "To reassign `username_list` to the updated list, place `username_list` to the left of the `=` operator.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "JvpvqtW6g-QT"
+ },
+ "source": [
+ "#### **Question 3**\n",
+ "**Based on the output above, what do you observe about the contents of `username_list`?**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "OavH92wXg-QU"
+ },
+ "source": [
+ "After putting type to username_list and then printing out username_list to it, it outputs ['madebowa', 'jnguyen', 'tbecker', 'nhersh', 'redwards'] when username_list is called. The second one, I noticed just change the list but when called it has a differnt output. After puting type to username_list and then printing out username_list to it, it outputs ['madebowa', 'jnguyen', 'tbecker', 'nhersh', 'redwards', 'lpope'] when username_list is called. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "iYDV65CclQlc"
+ },
+ "source": [
+ "## Task 6\n",
+ "In this task, define a variable called `max_logins` that represents the maximum number of login attempts allowed per user. Store the value `3` in this variable. Then, store its data type in another variable called `max_logins_type`. Display `max_logins_type` to examine the output.\n",
+ "\n",
+ "Be sure to replace each `### YOUR CODE HERE ###` with your own code before you run the following cell."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "id": "rrmY4XeNx_d7"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Assign `max_logins` to the value 3\n",
+ "\n",
+ "max_logins = 3\n",
+ "\n",
+ "# Assign `max_logins_type` to the data type of `max_logins`\n",
+ "\n",
+ "max_logins_type = type(max_logins)\n",
+ "\n",
+ "# Display `max_logins_type`\n",
+ "\n",
+ "print(max_logins_type)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "bDTRW5iDVZvb"
+ },
+ "source": [
+ "\n",
+ " Hint 1
\n",
+ "\n",
+ "When assigning a value to a variable in Python, use the `=` operator. Place the name of the variable to the left of the `=` operator, and place the value to the right of the `=` operator.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "HnwzqIY5xknA"
+ },
+ "source": [
+ "\n",
+ " Hint 2
\n",
+ "\n",
+ "To assign `3` to `max_logins`, place `max_logins` to the left of the `=` operator, and place `3` to the right of the `=` operator.\n",
+ "\n",
+ "To assign `max_logins_type`, place `max_logins_type` to the left of the `=` operator before the `type()` function call.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "kQbcfpbjVZvc"
+ },
+ "source": [
+ "\n",
+ " Hint 3
\n",
+ "\n",
+ "In Python, you can use the `print()` function to display the value of a variable. To display `max_logins_type`, call `print()` and pass in `max_logins_type`.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Bl35H3myh4xZ"
+ },
+ "source": [
+ "#### **Question 4**\n",
+ "**Based on the output above, what do you observe about the data type of `max_logins`?**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "MCTU3HsXh4xi"
+ },
+ "source": [
+ "After puting type to max_logins_type and then inserting the max_logins to it, it outputs when max_logins_type is called. This means it is an integer type."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "85o9hfJmyH3W"
+ },
+ "source": [
+ "## Task 7\n",
+ "In this task, define a variable called `login_attempts` that represents the current number of login attempts made by a user. Store the value `2` in this variable. Then, store its data type in a variable called `login_attempts_type`. Display `login_attempts_type` to observe the output.\n",
+ "\n",
+ "Be sure to replace each `### YOUR CODE HERE ###` with your own code before you run the following cell."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {
+ "id": "-3YDmrBWzOFc"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Assign `login_attempts` to the value 2\n",
+ "\n",
+ "login_attempts = 2\n",
+ "\n",
+ "# Assign `login_attempts_type` to the data type of `login_attempts`\n",
+ "\n",
+ "login_attempts_type = type(login_attempts)\n",
+ "\n",
+ "# Display `login_attempts_type`\n",
+ "\n",
+ "print(login_attempts_type)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "t-l9SR2mVeqc"
+ },
+ "source": [
+ "\n",
+ " Hint 1
\n",
+ "\n",
+ "When assigning a value to a variable in Python, use the `=` operator. Place the name of the variable to the left of the `=` operator, and place the value to the right of the `=` operator.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "NNEn8rkpVnMQ"
+ },
+ "source": [
+ "\n",
+ " Hint 2
\n",
+ "\n",
+ "To assign `2` to `login_attempts`, place `login_attempts` to the left of the `=` operator, and place `2` to the right of the `=` operator.\n",
+ "\n",
+ "To assign `login_attempts_type`, place `login_attempts_type` to the left of the `=` operator, and place a call to the `type()` function to the right of the `=` operator.\n",
+ "\n",
+ "When calling `type()`, make sure to pass in `login_attempts`.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "IM8picKtVnMQ"
+ },
+ "source": [
+ "\n",
+ " Hint 3
\n",
+ "\n",
+ "In Python, you can use the `print()` function to display the value of a variable. To display `login_attempts_type`, call `print()` and pass in `login_attempts_type`.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "sFSn1Xvuj0a8"
+ },
+ "source": [
+ "#### **Question 5**\n",
+ "**Based on the output above, what do you observe about the data type of `login_attempts`?**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "XomtDQZ2j0a9"
+ },
+ "source": [
+ "After puting type to login_attempts_type and then inserting the login_attempts to it, it outputs when login_attempts_type is called. This means it is an integer type."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "JKNwC4lKzWW6"
+ },
+ "source": [
+ "## Task 8\n",
+ "In this task, you'll determine the Boolean value that represents whether the current number of login attempts a user has made is less than or equal to the maximum number of login attempts allowed.\n",
+ "\n",
+ "Be sure to replace each `### YOUR CODE HERE ###` with your own code before you run the following cell.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "id": "2mwU0rO40CSU"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "True\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Assign `max_logins` to the value 3\n",
+ "\n",
+ "max_logins = 3\n",
+ "\n",
+ "# Assign `login_attempts` to the value 2\n",
+ "\n",
+ "login_attempts = 2\n",
+ "\n",
+ "# Determine whether the current number of login attempts a user has made is less than or equal to the maximum number of login attempts allowed,\n",
+ "# and display the resulting Boolean value\n",
+ "\n",
+ "print(login_attempts <= max_logins)\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "CcFDQ5iMklzz"
+ },
+ "source": [
+ "\n",
+ " Hint 1
\n",
+ "\n",
+ "In Python, you can use the `<=` comparison operator to determine whether one value is less than or equal to another value.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "nmT8q0j-klzz"
+ },
+ "source": [
+ "\n",
+ " Hint 2
\n",
+ "\n",
+ "To determine whether the current number of login attempts a user has made is less than or equal to the maximum number of login attempts allowed, use the `<=` operator. Place `login_attempts` to the left of the `<=` operator, and place `max_logins` to the right of the `<=` operator.\n",
+ "\n",
+ "To make sure the resulting Boolean value is displayed, write this code inside of the parantheses where `print()` is called.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "RS9AaPuVklz0"
+ },
+ "source": [
+ "#### **Question 6**\n",
+ "**What is the output? What does this mean?**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "hzye4hciklz0"
+ },
+ "source": [
+ "The code print(login_attempts <= max_logins) asks the python machine is 2 <= 3 true? If so print true and if not print false. Since it prints true, this is a boolean type that outputs true for this statement 2 <=3 or \n",
+ "print(login_attempts <= max_logins)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "rjxdlE170I70"
+ },
+ "source": [
+ "## Task 9\n",
+ "This code continues to check for the Boolean value of whether `max_logins` is less than or equal to `login_attempts`. In this task, reassign other values to `login_attempts`. For example, you might choose a value that is higher than the maximum number of attempts allowed. Observe how the output changes.\n",
+ "\n",
+ "Be sure to replace each `### YOUR CODE HERE ###` with your own code before you run the following cell."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {
+ "id": "uIdS23Qr0NG9"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "False\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Assign `max_logins` to the value 3\n",
+ "\n",
+ "max_logins = 3\n",
+ "\n",
+ "# Assign `login_attempts` to a specific value\n",
+ "\n",
+ "login_attempts = 7\n",
+ "\n",
+ "# Determine whether the current number of login attempts a user has made is less than or equal to the maximum number of login attempts allowed,\n",
+ "# and display the resulting Boolean value\n",
+ "\n",
+ "print(login_attempts <= max_logins)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ApSY7aQamLZE"
+ },
+ "source": [
+ "\n",
+ " Hint 1
\n",
+ "\n",
+ "To assign `login_attempts` to a specific value, make sure to write the value to the right of the `=` operator.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "MbJ5mMuPmLZF"
+ },
+ "source": [
+ "#### **Question 7**\n",
+ "**Based on the different values you assigned to `login_attempts`, what did you observe about the output?**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "LPl0u_jOmLZF"
+ },
+ "source": [
+ "The code print(login_attempts <= max_logins) asks the python machine is 7 <= 3 true? If so print true and if not print false. Since it prints false, this is a boolean type that outputs false for this statement 7 <= 3 or \n",
+ "print(login_attempts <= max_logins)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "toglOMvH0bx4"
+ },
+ "source": [
+ "## Task 10\n",
+ "Finally, you can also assign a Boolean value of `True` or `False` to a variable.\n",
+ "\n",
+ "In this task, you'll create a variable called `login_status`, which is a Boolean that represents whether a user is logged in. Assign `False` to this variable and store its data type in a variable called `login_status_type` and display it.\n",
+ "\n",
+ "Be sure to replace each `### YOUR CODE HERE ###` with your own code before you run the following cell."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {
+ "id": "BwjxdmYc1sDY"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Assign `login_status` to the Boolean value False\n",
+ "\n",
+ "login_status = False\n",
+ "\n",
+ "# Assign `login_status_type` to the data type of `login_status`\n",
+ "\n",
+ "login_status_type = type(login_status)\n",
+ "\n",
+ "# Display `login_status_type`\n",
+ "\n",
+ "print(login_status_type)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "v9mAtdMHrkiS"
+ },
+ "source": [
+ "\n",
+ " Hint 1
\n",
+ "\n",
+ "To assign the Boolean value `False` to the `login_status` variable, make sure to write `False` to the right of the `=` operator.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "9LZYgEvKQ9tA"
+ },
+ "source": [
+ "\n",
+ " Hint 2
\n",
+ "\n",
+ "Note that Boolean values should not have quotation marks around them in code.\n",
+ "\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "EpuzbcA0rkiS"
+ },
+ "source": [
+ "#### **Question 8**\n",
+ "**Based on the output above, what do you observe about the data type of `login_status`?**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "AZAqQKoFrkiS"
+ },
+ "source": [
+ "After setting login_status to False, and then find data type with login_status_type and then inserting the login_status to it, it outputs when login_status_type is called. This means it is a bool type."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ru2ytGBLCh4q"
+ },
+ "source": [
+ "## Conclusion\n",
+ "\n",
+ "**What are your key takeaways from this lab?**"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ls2WEGqsiSAd"
+ },
+ "source": [
+ "In this lesson, I learned about Python variables and data types. I practiced assigning values to variables like `device_id`, `username_list`, and `max_logins`. I also explored different data types, including strings, lists, integers, and booleans, and used the `type()` function to check their types. I learned how to print and compare values using operators like `<=`, and how to manage Boolean values like `True` and `False` in conditions. The main takeaway is how important it is to understand data types and how to manipulate and check them in Python to perform various tasks like authentication or tracking login attempts."
+ ]
+ }
+ ],
+ "metadata": {
+ "colab": {
+ "collapsed_sections": [
+ "JvpvqtW6g-QT",
+ "Bl35H3myh4xZ",
+ "sFSn1Xvuj0a8",
+ "RS9AaPuVklz0",
+ "MbJ5mMuPmLZF",
+ "EpuzbcA0rkiS"
+ ],
+ "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
+}
diff --git a/Activity_Assign Python variables.pdf b/Activity_Assign Python variables.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..ef001e6e6b10072e8e3eb107fb8077992673ecf1
GIT binary patch
literal 67383
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