python_lesson_0.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5b2eb36b",
   "metadata": {},
   "source": [
    "\n",
    "# Introduction to Python\n",
    "Welcome to this Python tutorial! In this tutorial, you'll learn the basics of Python, a popular programming language that is widely used in many fields, including data science, web development, and artificial intelligence. By the end of this tutorial, you'll be able to write simple Python programs and understand some of the key concepts of programming.\n",
    "\n",
    "## Installing Python\n",
    "Before we get started, you'll need to install Python on your computer. You can download Python from the official website, https://www.python.org/downloads/. Follow the installation instructions for your operating system to get Python up and running on your computer.\n",
    "\n",
    "## Jupyter Notebook\n",
    "In this tutorial, we'll be using Jupyter Notebook, a popular tool for writing and running Python code. Jupyter Notebook allows you to write and execute Python code in a web-based environment, and it's great for experimentation and data analysis.\n",
    "\n",
    "To install Jupyter Notebook, you can use pip, the Python package manager. Open a terminal or command prompt and type:\n",
    "\n",
    "```\n",
    "pip install jupyter\n",
    "```\n",
    "This will install Jupyter Notebook and its dependencies on your computer.\n",
    "\n",
    "To launch Jupyter Notebook, open a command prompt or terminal window on your computer and navigate to the directory where you want to create or access a notebook. Once you're in the desired directory, type the command `jupyter notebook` and press Enter. This will start a Jupyter Notebook server and open a new tab in your web browser, displaying the Jupyter Notebook interface. From here, you can create new notebooks, open existing ones, and run Python code interactively. When you're done using Jupyter Notebook, you can shut down the server by closing the web browser tab and pressing Ctrl-C in the command prompt or terminal window where you started it.\n",
    "\n",
    "\n",
    "## Getting Started with Python\n",
    "Now that you have Python and Jupyter Notebook installed, let's get started with some basic Python programming. In Jupyter Notebook, we write Python code in cells. To create a new cell, click the \"+\" button in the top left corner of the screen.\n",
    "\n",
    "Type the following code in the first cell:\n",
    "```py\n",
    "print(\"Hello, world!\")\n",
    "```\n",
    "\n",
    "Then click the \"Run\" button or press \"Shift + Enter\" to execute the code. You should see the output \"Hello, world!\" printed below the cell.\n",
    "\n",
    "Congratulations, you've written your first Python program!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "b5b08eb5",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello, world!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cb886e1",
   "metadata": {},
   "source": [
    "# Variables and Data Types\n",
    "\n",
    "\n",
    "## Variables\n",
    "In Python, a variable is a named storage location that holds a value. You can think of a variable as a container that stores a value.\n",
    "\n",
    "To create a variable in Python, you simply choose a name for the variable and use the equal sign (=) to assign a value to the variable. For example, the following code creates a variable named x and assigns it the value 5:\n",
    "\n",
    "```py\n",
    "x = 5\n",
    "```\n",
    "Once you've created a variable, you can use it in your code. For example, you can print the value of the x variable using the print function:\n",
    "\n",
    "```py\n",
    "print(x)\n",
    "```\n",
    "This will output 5.\n",
    "\n",
    "```py\n",
    "name = \"Alice\"\n",
    "```\n",
    "We can then use the variable in our program:\n",
    "\n",
    "```py\n",
    "print(\"Hello, \" + name + \"!\")\n",
    "```\n",
    "This will print \"Hello, Alice!\" to the screen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4435b36a",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "dfe50ca8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7a4a4d83",
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Alice\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "bb64ea7a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Alice!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello, \" + name + \"!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2601da7",
   "metadata": {},
   "source": [
    "### Variables Names\n",
    "\n",
    "In Python, variable names can contain letters, numbers, and underscores, but they cannot start with a number. It's a good idea to use descriptive variable names that make it clear what the variable is used for. \n",
    "\n",
    "Python also has a convention for naming variables called \"snake case\". This means that variable names should be written in lowercase, and words should be separated by underscores. For example, if you're using a variable to store a person's age, you could name the variable person_age.\n",
    "\n",
    "Here are some examples of valid and invalid variable names in Python:\n",
    "```py\n",
    "# Valid variable names\n",
    "age = 27\n",
    "list_length = 5\n",
    "person_age = 42\n",
    "my_variable = \"Hello, world!\"\n",
    "\n",
    "# Invalid variable names\n",
    "1st_variable = \"This is not a valid variable name\"\n",
    "variable-name = \"This is also not a valid variable name\"\n",
    "```\n",
    "\n",
    "By following these variable naming conventions, you can write code that is easy to read and understand, both for yourself and for others who may read your code in the future."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6984907d",
   "metadata": {},
   "source": [
    "## Data Types\n",
    "Python has several built-in data types, including:\n",
    "\n",
    "- Integers: whole numbers (e.g. 1, 2, 3)\n",
    "- Floats: decimal numbers (e.g. 3.14, 2.0, 1.5)\n",
    "- Strings: text (e.g. \"hello\", \"world\", \"42\")\n",
    "- Booleans: True or False\n",
    "\n",
    "When you create a variable, you can assign it a value of any of these data types. For example:\n",
    "\n",
    "```py\n",
    "# Integer\n",
    "x = 5\n",
    "\n",
    "# Float\n",
    "y = 3.14\n",
    "\n",
    "# String\n",
    "z = \"Hello, world!\"\n",
    "\n",
    "# Boolean\n",
    "w = True\n",
    "```\n",
    "Python is a dynamically typed language, which means that you don't need to specify the data type of a variable when you create it. Python will automatically determine the data type based on the value that you assign to the variable.\n",
    "\n",
    "You can use the type function to check the data type of a variable. For example:\n",
    "\n",
    "```py\n",
    "x = 5\n",
    "print(type(x))  # Output: <class 'int'>\n",
    "\n",
    "y = 3.14\n",
    "print(type(y))  # Output: <class 'float'>\n",
    "\n",
    "z = \"Hello, world!\"\n",
    "print(type(z))  # Output: <class 'str'>\n",
    "\n",
    "w = True\n",
    "print(type(w))  # Output: <class 'bool'>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "a6b65f9f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "print(type(x))  # Output: <class 'int'>\n",
    "\n",
    "y = 3.14\n",
    "print(type(y))  # Output: <class 'float'>\n",
    "\n",
    "z = \"Hello, world!\"\n",
    "print(type(z))  # Output: <class 'str'>\n",
    "\n",
    "w = True\n",
    "print(type(w))  # Output: <class 'bool'>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dfc4573",
   "metadata": {},
   "source": [
    "## Type Conversion\n",
    "You can convert a variable from one data type to another using type conversion. For example, you can convert an integer to a float using the float function:\n",
    "\n",
    "```py\n",
    "x = 5\n",
    "y = float(x)\n",
    "print(y)  # Output: 5.0\n",
    "```\n",
    "You can also convert a float to an integer using the int function:\n",
    "\n",
    "```py\n",
    "x = 3.14\n",
    "y = int(x)\n",
    "print(y)  # Output: 3\n",
    "```\n",
    "When converting a float to an integer, Python will round down to the nearest whole number.\n",
    "\n",
    "You can convert a string to an integer or float using the int or float functions, respectively. For example:\n",
    "\n",
    "```py\n",
    "x = \"5\"\n",
    "y = int(x)\n",
    "print(y)  # Output: 5\n",
    "\n",
    "z = \"3.14\"\n",
    "w = float(z)\n",
    "print(w)  # Output: 3.14\n",
    "```\n",
    "If the string contains non-numeric characters, you'll get a ValueError:\n",
    "\n",
    "```py\n",
    "x = \"hello\"\n",
    "y = int(x)  # Raises ValueError\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "6c796bed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "y = float(x)\n",
    "print(y)  # Output: 5.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "12cb4f6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "x = 3.14\n",
    "y = int(x)\n",
    "print(y)  # Output: 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "9c0044d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "3.14\n"
     ]
    }
   ],
   "source": [
    "x = \"5\"\n",
    "y = int(x)\n",
    "print(y)  # Output: 5\n",
    "\n",
    "z = \"3.14\"\n",
    "w = float(z)\n",
    "print(w)  # Output: 3.14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "f0fec9f0",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'hello'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[22], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhello\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m----> 2\u001b[0m y \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m# Raises ValueError\u001b[39;00m\n",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'hello'"
     ]
    }
   ],
   "source": [
    "x = \"hello\"\n",
    "y = int(x)  # Raises ValueError"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8207691c",
   "metadata": {},
   "source": [
    "## Lists\n",
    "A list is a collection of values, which can be of different data types. You can create a list by enclosing values in square brackets and separating them with commas. For example:\n",
    "\n",
    "```py\n",
    "my_list = [1, 2, \"three\", 4.0, True]\n",
    "```\n",
    "This code creates a list called my_list with five values of different data types.\n",
    "\n",
    "You can access individual values in a list using their index, which starts at 0. For example, to get the second value in my_list, you would use:\n",
    "\n",
    "```py\n",
    "second_value = my_list[1]\n",
    "```\n",
    "You can also use negative indices to count from the end of the list. For example, to get the last value in my_list, you would use:\n",
    "\n",
    "```py\n",
    "last_value = my_list[-1]\n",
    "```\n",
    "You can add values to the end of a list using the append() method. For example:\n",
    "\n",
    "```py\n",
    "my_list.append(\"new value\")\n",
    "```\n",
    "This code adds the string \"new value\" to the end of my_list.\n",
    "\n",
    "You can also slice a list to get a subset of values. For example, to get the first three values in my_list, you would use:\n",
    "\n",
    "```py\n",
    "first_three_values = my_list[:3]\n",
    "```\n",
    "This code slices my_list from the beginning up to (but not including) the third value, and returns a new list with those values.\n",
    "\n",
    "Lists are mutable, which means you can change their values. For example, to change the second value in my_list, you would use:\n",
    "\n",
    "```py\n",
    "my_list[1] = \"two\"\n",
    "```\n",
    "This code changes the second value in my_list from the integer 2 to the string \"two\".\n",
    "\n",
    "Lists can be very useful for storing and manipulating collections of data in your programs.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "17211e10",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [1, 2, \"three\", 4.0, True]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "f3e9895a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "second_value = my_list[1]\n",
    "print(second_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "571325ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "last_value = my_list[-1]\n",
    "print(last_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "c29c9b91",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list.append(\"new value\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "4173b616",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 'three', 4.0, True, 'new value']\n"
     ]
    }
   ],
   "source": [
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "89c9a582",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 'three']\n"
     ]
    }
   ],
   "source": [
    "first_three_values = my_list[:3]\n",
    "print(first_three_values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "eb69f9e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'two', 'three', 4.0, True, 'new value']\n"
     ]
    }
   ],
   "source": [
    "my_list[1] = \"two\"\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "47b666ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 'three']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_three_values"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9644c37b",
   "metadata": {},
   "source": [
    "### The len() function\n",
    "\n",
    "The len() function takes a sequence as an argument, and returns the number of items in the sequence. For example, to get the length of a list called my_list, you would use the following code:\n",
    "\n",
    "```py\n",
    "my_list = [1, 2, 3, 4, 5]\n",
    "length = len(my_list)\n",
    "print(length) # Output: 5\n",
    "```\n",
    "\n",
    "In this example, we define a list called my_list with five items. We then use the len() function to get the length of the list, and assign the result to a variable called length. Finally, we print the value of length to the console. The output should be 5, which is the number of items in the list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "78d67462",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 5]\n",
    "length = len(my_list)\n",
    "print(length) # Output: 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9cfb642",
   "metadata": {},
   "source": [
    "### List's max(), min(), and sum() functions\n",
    "\n",
    "Python provides built-in functions that can be used with lists to find maximum, minimum, and sum of the values in a list.\n",
    "\n",
    "The max() function returns the largest value in a list, while the min() function returns the smallest value. Here's an example:\n",
    "\n",
    "```py\n",
    "my_list = [1, 2, 3, 4, 5]\n",
    "max_value = max(my_list)\n",
    "min_value = min(my_list)\n",
    "print(max_value) # Output: 5\n",
    "print(min_value) # Output: 1\n",
    "```\n",
    "In this example, we define a list called my_list with five integer values. We then use the max() and min() functions to find the largest and smallest values in the list, respectively. We assign the results to the variables max_value and min_value, and finally, we print the values of these variables to the console.\n",
    "\n",
    "The sum() function, on the other hand, returns the sum of all the values in a list. Here's an example:\n",
    "\n",
    "```py\n",
    "my_list = [1, 2, 3, 4, 5]\n",
    "sum_value = sum(my_list)\n",
    "print(sum_value) # Output: 15\n",
    "```\n",
    "In this example, we define a list called my_list with five integer values. We then use the sum() function to find the sum of all the values in the list, and assign the result to the variable sum_value. Finally, we print the value of sum_value to the console. The output should be 15, which is the sum of all the values in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "2cfed5f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "5\n",
      "1\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 5]\n",
    "max_value = max(my_list)\n",
    "min_value = min(my_list)\n",
    "sum_value = sum(my_list)\n",
    "print(max_value) # Output: 5\n",
    "print(min_value) # Output: 1\n",
    "print(sum_value) # Output: 15"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87710e4f",
   "metadata": {},
   "source": [
    "### List's reverse() method\n",
    "\n",
    "The reverse() method is a list method in Python that allows you to reverse the order of the elements in a list. The method modifies the original list and does not return a new list. The syntax to use the reverse() method is quite simple - you just need to call the method on a list object.\n",
    "\n",
    "Here is an example of how to use the reverse() function:\n",
    "\n",
    "```py\n",
    "my_list = [1, 2, 3, 4, 5]\n",
    "my_list.reverse()\n",
    "print(my_list)  # output: [5, 4, 3, 2, 1]\n",
    "```\n",
    "In this example, we first create a list my_list containing the elements 1, 2, 3, 4, and 5. We then call the reverse() method on the list, which reverses the order of the elements in-place. Finally, we print the modified list, which now contains the elements 5, 4, 3, 2, and 1.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "d92720a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 2, 3, 4, 5]\n",
    "my_list.reverse()\n",
    "print(my_list)  # output: [5, 4, 3, 2, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b71c93f",
   "metadata": {},
   "source": [
    "## Strings\n",
    "A string is a sequence of characters. You can create a string by enclosing text in single or double quotes. For example:\n",
    "\n",
    "```py\n",
    "my_string = \"Hello, world!\"\n",
    "```\n",
    "This code creates a string called my_string with the value \"Hello, world!\".\n",
    "\n",
    "You can access individual characters in a string using their index, which starts at 0. For example, to get the second character in my_string, you would use:\n",
    "\n",
    "```py\n",
    "second_character = my_string[1]\n",
    "```\n",
    "You can also use negative indices to count from the end of the string. For example, to get the last character in my_string, you would use:\n",
    "\n",
    "```py\n",
    "last_character = my_string[-1]\n",
    "```\n",
    "You can concatenate strings using the + operator. For example:\n",
    "\n",
    "```py\n",
    "greeting = \"Hello\"\n",
    "name = \"Alice\"\n",
    "message = greeting + \", \" + name + \"!\"\n",
    "```\n",
    "This code creates three strings (greeting, name, and message) and concatenates them to create a message that says \"Hello, Alice!\".\n",
    "\n",
    "You can also format strings using the format() method. For example:\n",
    "\n",
    "```py\n",
    "name = \"Bob\"\n",
    "age = 30\n",
    "message = \"My name is {} and I am {} years old.\".format(name, age)\n",
    "```\n",
    "This code creates three variables (name, age, and message) and uses the format() method to insert their values into a string. The resulting message variable has the value \"My name is Bob and I am 30 years old.\".\n",
    "\n",
    "Strings are immutable, which means you can't change their values directly. However, you can create a new string with modified content. For example, to change the second character in my_string to \"E\", you would use:\n",
    "\n",
    "```py\n",
    "new_string = my_string[:1] + \"E\" + my_string[2:]\n",
    "```\n",
    "This code slices my_string into two parts (up to the second character, and after the second character), inserts the string \"E\" in the middle, and concatenates the three parts to create a new string with the value \"HEllo, world!\".\n",
    "\n",
    "The len() function can also be used to get the length of a string in Python. In the case of a string, the number of items is the number of characters in the string. Here's an example of how to use len() with a string:\n",
    "\n",
    "```py\n",
    "my_string = \"Hello, world!\"\n",
    "length = len(my_string)\n",
    "print(length) # Output: 13\n",
    "```\n",
    "In this example, we define a string called my_string with 13 characters. We then use the len() function to get the length of the string, and assign the result to a variable called length. Finally, we print the value of length to the console. The output should be 13, which is the number of characters in the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e35995cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Alice!\n"
     ]
    }
   ],
   "source": [
    "greeting = \"Hello\"\n",
    "name = \"Alice\"\n",
    "message = greeting + \", \" + name + \"!\"\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "99477a81",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Bob and I am 30 years old.\n"
     ]
    }
   ],
   "source": [
    "name = \"Bob\"\n",
    "age = 30\n",
    "message = \"My name is {} and I am {} years old.\".format(name, age)\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f018e86f",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"Hello, world!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "cf9321d0",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[4], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mmy_string\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mE\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;66;03m# Raise Exception\u001b[39;00m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "my_string[1] = 'E' # Raise Exception"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4ce8ba29",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HEllo, world!\n"
     ]
    }
   ],
   "source": [
    "new_string = my_string[:1] + \"E\" + my_string[2:]\n",
    "print(new_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "80eb6434",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "my_string = \"Hello, world!\"\n",
    "length = len(my_string)\n",
    "print(length) # Output: 13"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffc0ba7c",
   "metadata": {},
   "source": [
    "### String's split() and join() method\n",
    "\n",
    "In Python, a string has a built-in split() method that can be used to split a string into a list of substrings based on a specified separator. The separator can be any character or string that appears in the original string. When called without any arguments, split() uses whitespace characters (spaces, tabs, and newlines) as the default separator.\n",
    "\n",
    "For example, the following code splits a string into a list of words based on spaces:\n",
    "\n",
    "```py\n",
    "text = \"hello world\"\n",
    "words = text.split()\n",
    "print(words)\n",
    "```\n",
    "Output:\n",
    "\n",
    "```py\n",
    "['hello', 'world']\n",
    "```\n",
    "You can also specify a custom separator by passing it as an argument to the split() method. For example, the following code splits a string into a list of words based on commas:\n",
    "\n",
    "```py\n",
    "text = \"apple,banana,orange\"\n",
    "fruits = text.split(\",\")\n",
    "print(fruits)\n",
    "```\n",
    "Output:\n",
    "\n",
    "```py\n",
    "['apple', 'banana', 'orange']\n",
    "```\n",
    "The split() method can be very useful for parsing text data, such as CSV files or log files, where the data is separated by a specific character or string.\n",
    "\n",
    "\n",
    "On the other hand, join() is a method that allows you to join a list of strings together using a separator. It takes an iterable (usually a list) of strings as an argument and returns a new string that contains all the strings concatenated together, separated by the specified separator. Here's an example of how to use it:\n",
    "\n",
    "```py\n",
    "words = [\"hello\", \"world\", \"how\", \"are\", \"you\"]\n",
    "separator = \" \"\n",
    "new_string = separator.join(words)\n",
    "print(new_string)  # Output: \"hello world how are you\"\n",
    "```\n",
    "Note that you can use any separator you like - it doesn't have to be a space.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "940862ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['hello', 'world']\n"
     ]
    }
   ],
   "source": [
    "text = \"hello world\"\n",
    "words = text.split()\n",
    "print(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "dbbd0509",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'banana', 'orange']\n"
     ]
    }
   ],
   "source": [
    "text = \"apple,banana,orange\"\n",
    "fruits = text.split(\",\")\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "27e6270b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world how are you\n"
     ]
    }
   ],
   "source": [
    "words = [\"hello\", \"world\", \"how\", \"are\", \"you\"]\n",
    "separator = \" \"\n",
    "new_string = separator.join(words)\n",
    "print(new_string)  # Output: \"hello world how are you\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7bf2efc",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "In Python, a dictionary is an unordered collection of key-value pairs. It is a powerful data structure for organizing and manipulating data, and it can be used to represent a wide range of real-world entities such as user profiles, product listings, and more.\n",
    "\n",
    "To define a dictionary, we use curly braces {} and separate the key-value pairs using a colon :. For example:\n",
    "\n",
    "```py\n",
    "my_dict = {'apple': 2, 'banana': 3, 'orange': 4}\n",
    "```\n",
    "In this example, my_dict is a dictionary with three key-value pairs. The keys are strings ('apple', 'banana', and 'orange') and the values are integers (2, 3, and 4).\n",
    "\n",
    "We can access the values in a dictionary using their keys:\n",
    "\n",
    "```py\n",
    "print(my_dict['banana'])  # Output: 3\n",
    "```\n",
    "We can also add, modify, and remove key-value pairs in a dictionary using the following methods:\n",
    "\n",
    "```py\n",
    "# Add a new key-value pair\n",
    "my_dict['pear'] = 5\n",
    "\n",
    "# Modify an existing value\n",
    "my_dict['banana'] = 6\n",
    "\n",
    "# Remove a key-value pair\n",
    "del my_dict['orange']\n",
    "```\n",
    "Dictionaries are commonly used in Python programs, especially in data analysis and manipulation. For example, we could use a dictionary to represent a set of user profiles, where each key is a unique user ID and each value is a dictionary of user information (name, email, age, etc.). We could then use various methods to add, modify, and retrieve user information as needed.\n",
    "\n",
    "\n",
    "The len() function can also be used to get the number of items in a dictionary in Python. When used with a dictionary, the len() function returns the number of key-value pairs in the dictionary. Here's an example of how to use len() with a dictionary:\n",
    "\n",
    "```py\n",
    "my_dict = {'apple': 3, 'banana': 2, 'orange': 1}\n",
    "length = len(my_dict)\n",
    "print(length) # Output: 3\n",
    "```\n",
    "In this example, we define a dictionary called my_dict with three key-value pairs. We then use the len() function to get the length of the dictionary, and assign the result to a variable called length. Finally, we print the value of length to the console. The output should be 3, which is the number of key-value pairs in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "bd7c4958",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dict = {'apple': 2, 'banana': 3, 'orange': 4}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "cb32ccc9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(my_dict['banana'])  # Output: 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "3c4e2eef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'apple': 2, 'banana': 3, 'orange': 4, 'pear': 5}\n"
     ]
    }
   ],
   "source": [
    "# Add a new key-value pair\n",
    "my_dict['pear'] = 5\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e14a8230",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'apple': 2, 'banana': 6, 'orange': 4, 'pear': 5}\n"
     ]
    }
   ],
   "source": [
    "# Modify an existing value\n",
    "my_dict['banana'] = 6\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f5970cdb",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'apple': 2, 'banana': 6, 'pear': 5}\n"
     ]
    }
   ],
   "source": [
    "# Remove a key-value pair\n",
    "del my_dict['orange']\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "47e6cdce",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "length = len(my_dict)\n",
    "print(length) # Output: 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74542488",
   "metadata": {},
   "source": [
    "### Dictionary's get() method\n",
    "\n",
    "The get() method is a very useful method in Python dictionaries that allows you to access the value associated with a given key. If the key doesn't exist in the dictionary, you can provide a default value to return instead of raising a KeyError exception.\n",
    "\n",
    "The syntax of the get() method is as follows:\n",
    "\n",
    "```py\n",
    "my_dict.get(key, default_value)\n",
    "```\n",
    "where key is the key you want to look up, and default_value is the value that should be returned if the key doesn't exist in the dictionary.\n",
    "\n",
    "Here is an example of using the get() method:\n",
    "\n",
    "```py\n",
    "my_dict = {\"apple\": 1.99, \"banana\": 0.99, \"orange\": 0.79}\n",
    "\n",
    "price_of_grapes = my_dict.get(\"grapes\", \"Sorry, that item is not in stock.\")\n",
    "\n",
    "print(price_of_grapes)\n",
    "```\n",
    "Output:\n",
    "\n",
    "```py\n",
    "Sorry, that item is not in stock.\n",
    "```\n",
    "In the above example, we tried to look up the price of grapes, but since grapes are not in the dictionary, the get() method returned the default value we specified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "c69b9b1b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorry, that item is not in stock.\n"
     ]
    }
   ],
   "source": [
    "my_dict = {\"apple\": 1.99, \"banana\": 0.99, \"orange\": 0.79}\n",
    "\n",
    "price_of_grapes = my_dict.get(\"grapes\", \"Sorry, that item is not in stock.\")\n",
    "\n",
    "print(price_of_grapes)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d8faa67",
   "metadata": {},
   "source": [
    "# Formatting Output\n",
    "\n",
    "Formatting output is an essential skill in programming because it allows you to present your program's results in a readable and organized way. In Python, you can use the print() function to display output on the console, and you can use string formatting to control the output's appearance.\n",
    "\n",
    "One way to format output in Python is to use the format() method. This method allows you to insert values into a string template and control their appearance using formatting codes. For example, consider the following code:\n",
    "\n",
    "```py\n",
    "name = \"Alice\"\n",
    "age = 25\n",
    "print(\"My name is {} and I'm {} years old.\".format(name, age))\n",
    "```\n",
    "This code uses the format() method to insert the values of name and age into the string template. The curly braces {} act as placeholders for the values to be inserted. The format() method replaces each placeholder with its corresponding value, producing the output:\n",
    "\n",
    "```\n",
    "My name is Alice and I'm 25 years old.\n",
    "```\n",
    "You can also use formatting codes to control the output's appearance. For example, you can specify the number of decimal places for a floating-point value using the :.Nf code, where N is the number of decimal places. Consider the following code:\n",
    "\n",
    "```py\n",
    "x = 3.14159\n",
    "print(\"The value of pi is approximately {:.2f}.\".format(x))\n",
    "```\n",
    "This code uses the :.2f code to specify that the value of x should be displayed with two decimal places. The output is:\n",
    "\n",
    "```\n",
    "The value of pi is approximately 3.14.\n",
    "```\n",
    "There are many other formatting codes you can use to control the output's appearance. You can find a comprehensive list in the Python documentation.\n",
    "\n",
    "In addition to the format() method, Python 3.6 introduced a new way to format strings using f-strings. F-strings allow you to embed expressions inside string literals, making string formatting more concise and easier to read. Here's an example:\n",
    "\n",
    "```py\n",
    "name = \"Alice\"\n",
    "age = 25\n",
    "print(f\"My name is {name} and I'm {age} years old.\")\n",
    "```\n",
    "This code uses an f-string to embed the values of name and age directly inside the string template. The output is the same as before:\n",
    "\n",
    "```\n",
    "My name is Alice and I'm 25 years old.\n",
    "```\n",
    "F-strings offer many benefits over the format() method, including improved readability, better performance, and more expressive power. However, they require Python 3.6 or later, so they may not be available in all environments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "3b70ea98",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Alice and I'm 25 years old.\n"
     ]
    }
   ],
   "source": [
    "name = \"Alice\"\n",
    "age = 25\n",
    "print(\"My name is {} and I'm {} years old.\".format(name, age))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "e559765b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of pi is approximately 3.14.\n"
     ]
    }
   ],
   "source": [
    "x = 3.14159\n",
    "print(\"The value of pi is approximately {:.2f}.\".format(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "890c3c2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Alice and I'm 25 years old.\n"
     ]
    }
   ],
   "source": [
    "name = \"Alice\"\n",
    "age = 25\n",
    "print(f\"My name is {name} and I'm {age} years old.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9418b1f5",
   "metadata": {},
   "source": [
    "# Exercises\n",
    "\n",
    "\n",
    "1. Give a list of numbers, calculate the sum, minimum value, and maximum value of the list using built-in functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "58dbe47b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The maximum value of the list is: 9\n",
      "The minimum value of the list is: 1\n",
      "The average value of the list is: 4.57\n"
     ]
    }
   ],
   "source": [
    "lst = [2, 3, 1, 5, 7, 5, 9]\n",
    "print(\"The maximum value of the list is: {}\".format(max(lst)))\n",
    "print(\"The minimum value of the list is: {}\".format(min(lst)))\n",
    "print(\"The average value of the list is: {:.2f}\".format(sum(lst)/len(lst)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fef5c6d6",
   "metadata": {},
   "source": [
    "2. Write a program that takes a dictionary representing a set of stocks and their prices and returns the stock with the highest price."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "b76b6850",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The stock with the highest price is TSLA at $196.88.\n"
     ]
    }
   ],
   "source": [
    "stocks = {\n",
    "    'AAPL': 146.71,\n",
    "    'GOOG': 89.35,\n",
    "    'TSLA': 196.88,\n",
    "    'AMZN': 93.50\n",
    "}\n",
    "\n",
    "# Find the stock with the highest price\n",
    "highest_stock = max(stocks, key=stocks.get)\n",
    "\n",
    "# Print the result\n",
    "print(f\"The stock with the highest price is {highest_stock} at ${stocks[highest_stock]:.2f}.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b437115",
   "metadata": {},
   "source": [
    "3. Write a program that takes a sentence as input from the user and prints out the words in the sentence in reverse order.\n",
    "\n",
    "Here's an example of how the program should work:\n",
    "\n",
    "```\n",
    "Enter a sentence: The quick brown fox jumps over the lazy dog.\n",
    "Output: dog. lazy the over jumps fox brown quick The\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "0d4cfa69",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a sentence: The quick brown fox jumps over the lazy dog.\n",
      "Output: dog. lazy the over jumps fox brown quick The\n"
     ]
    }
   ],
   "source": [
    "sentence = input(\"Enter a sentence: \")\n",
    "words = sentence.split()\n",
    "words.reverse()\n",
    "output = \" \".join(words)\n",
    "print(\"Output:\", output)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}