Introduction_2_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3c75d899",
   "metadata": {},
   "source": [
    "# Introduction to Python\n",
    "Python is a high-level, interpreted, and general-purpose programming language. It was created by Guido van Rossum and first released in 1991. Python is known for its simplicity, readability, and versatility, making it a popular choice for various applications, including web development, data science, artificial intelligence, automation, and scientific computing.\n",
    "\n",
    "## Introducing Variables\n",
    "In any programming language, variables are used to store and manipulate data. A variable is essentially a named storage location in a computer's memory where a programmer can store data, and its value can be changed during the execution of a program. Variables have a specific data type, such as integer, floating-point, character, etc., which defines the kind of data they can hold.\n",
    "\n",
    "The assignment operator (=) is used to assign a value to a variable. The syntax is typically as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d58d6f6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "# x is a variable. '=' is used to assign the value 10 to variable x.\n",
    "x=10;\n",
    "print(x);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c2d2638",
   "metadata": {},
   "source": [
    "It is very important to remember what name you are giving each variable . Python has some reserved keywords which cannot be used to name any variable : e.g. def, class, global, if, in, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d296824",
   "metadata": {},
   "source": [
    "## Data Types in Python\n",
    "Python has several built-in data types that are used to represent different kinds of data. Here are some of the fundamental data types in Python:\n",
    "\n",
    "* Numeric Types:\n",
    "\n",
    "-int: Integer type, e.g., 10, -3, 42.\\\n",
    "-float: Floating-point type, e.g., 3.14, -0.5, 2.0.\n",
    "\n",
    "* Sequence Types:\n",
    "\n",
    "-str: String type, e.g., \"Hello, World!\", 'Python'.\\\n",
    "-list: List type, ordered and mutable sequence, e.g., [1, 2, 3], ['apple', 'banana'].\\\n",
    "-tuple: Tuple type, ordered and immutable sequence, e.g., (1, 2, 3), ('a', 'b').\n",
    "\n",
    "* Set Types:\n",
    "\n",
    "-set: Unordered collection of unique elements, e.g., {1, 2, 3}, {'apple', 'orange'}.\n",
    "\n",
    "* Mapping Type:\n",
    "\n",
    "-dict: Dictionary type, a collection of key-value pairs, e.g., {'name': 'John', 'age': 25}.\n",
    "\n",
    "* Boolean Type:\n",
    "\n",
    "-bool: Boolean type, representing True or False.\n",
    "* None Type:\n",
    "\n",
    "-NoneType: The type of the None object, representing the absence of a value."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1050685",
   "metadata": {},
   "source": [
    "### Numeric DataType\n",
    "In Python, numeric data types are used to represent numerical values. The primary numeric data types in Python are: \\\n",
    "\n",
    "* int (Integer): Integer data type represents whole numbers without any decimal points. ​\n",
    "\n",
    "* float (Floating-Point): Float data type represents numbers with decimal points or exponential notation.​\n",
    "\n",
    "* complex (Complex Numbers): Complex data type represents numbers in the form of a real part and an imaginary part. Complex numbers are written as a + bj, where a is the real part, b is the imaginary part, and j is the imaginary unit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c0f5d1b8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Numeric data type\n",
    "x = 10\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4a426159",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = 2.34\n",
    "type(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cee2f64f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "complex"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = 2 + 3j\n",
    "type(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3310e5ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of x,y,z is  (14.34+3j)\n",
      "Product is  23.4\n"
     ]
    }
   ],
   "source": [
    "#Arithmatic operations on Numeric datatypes\n",
    "addition = x+y+z\n",
    "print(\"Sum of x,y,z is \",addition)\n",
    "\n",
    "product= x*y\n",
    "print(\"Product is \",product)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fd19811",
   "metadata": {},
   "source": [
    "### Sequence Data Type\n",
    "Sequence data types in Python are collections of ordered and indexed elements. These elements can be of different data types, and the sequence maintains the order in which they are inserted. Here are some of the main sequence data types in Python: \n",
    "\n",
    "Lists: \n",
    "\n",
    "* Lists are ordered and mutable sequences.​\n",
    "\n",
    "* Elements can be of different data types.​\n",
    "\n",
    "* Lists are defined using square brackets [].​\n",
    "\n",
    "Tuples:​\n",
    "\n",
    "* Tuples are ordered and immutable sequences.​\n",
    "\n",
    "* Elements can be of different data types.​\n",
    "\n",
    "* Tuples are defined using parentheses ()​\n",
    "\n",
    "Strings:​\n",
    "\n",
    "* Strings are ordered sequences of characters.​\n",
    "\n",
    "* Strings are immutable in Python.​\n",
    "\n",
    "* Strings are defined using single (') or double (\") quotes.​\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "42176adb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The list is [1, 2, 'apple', 3.14, True] , the tuple is (1, 2, 'banana', 3.14, False) and string is Hello, Python!.\n"
     ]
    }
   ],
   "source": [
    "#Sequence Data Type\n",
    "my_list = [1, 2, 'apple', 3.14, True] #this is a list character\n",
    "my_tuple = (1, 2, 'banana', 3.14, False)\n",
    "my_string = \"Hello, Python!\"\n",
    "my_range = range(5)  # Represents the numbers 0, 1, 2, 3, 4\n",
    "print(\"The list is {} , the tuple is {} and string is {}.\".format(my_list,my_tuple,my_string))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "70c9952a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "14\n",
      "[13, 14, 15, 16, 17, 18]\n",
      "[12, 13, 14, 15, 16, 17, 18]\n",
      "[14, 15, 16, 17, 18, 19, 20, 22, 28, 29, 32, 24, 25, 32, 35]\n",
      "35\n",
      "32\n"
     ]
    }
   ],
   "source": [
    "#Slicing and Indexing elements from a list\n",
    "\n",
    "abc=[12,13,14,15,16,17,18,19,20,22,28,29,32,24,25,32,35];\n",
    "print(abc[0]);\n",
    "print(abc[2]);\n",
    "print(abc[1:7]) #start index: end index -1th index\n",
    "print(abc[:7]) #0th index : 7-1th index\n",
    "print(abc[2:])\n",
    "print(abc[-1])\n",
    "print(abc[-2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "1a5e486f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "26\n",
      "46\n",
      "78\n"
     ]
    }
   ],
   "source": [
    "#nested_lists\n",
    "\n",
    "pqr=[12,13,[25,26,27],14,16,17,[44,46,[76,77,78],48],19];\n",
    "print(pqr[1]);\n",
    "print(pqr[2][1]);\n",
    "print(pqr[6][1]);\n",
    "print(pqr[6][2][2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "368b9a8b",
   "metadata": {},
   "source": [
    "### Set DataType\n",
    "In Python, a set is a built-in data type that represents an unordered collection of unique elements. Sets are useful for various operations, such as testing membership, removing duplicates from a sequence, and performing set operations like union, intersection, and difference.Sets are particularly useful when you need to work with unique elements, and they offer efficient methods for performing set operations. Additionally, sets are mutable, allowing you to modify their contents after creation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "7310772b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5}\n",
      "{2, 4, 6, 8, 10}\n"
     ]
    }
   ],
   "source": [
    "#Set Data Type\n",
    "# Using curly braces\n",
    "my_set = {1, 2, 3, 4, 5}\n",
    "\n",
    "# Using set() constructor\n",
    "another_set = set([2, 4, 6, 8, 10])\n",
    "print(my_set)\n",
    "print(another_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "484e8763",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 4, 5, 6}\n"
     ]
    }
   ],
   "source": [
    "#Adding and Removing Elements:\n",
    "\n",
    "#You can add elements to a set using the add() method.\n",
    "#Elements can be removed using the remove() or discard() methods.\n",
    "my_set.add(6)\n",
    "my_set.remove(3)\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "4de8e781",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6}\n",
      "{3, 4}\n",
      "{1, 2}\n",
      "{1, 2, 5, 6}\n"
     ]
    }
   ],
   "source": [
    "#Operations on Sets:\n",
    "\n",
    "#Union (|): Combines elements from two sets.\n",
    "#Intersection (&): Retrieves common elements between two sets.\n",
    "#Difference (-): Retrieves elements in the first set but not in the second.\n",
    "#Symmetric Difference (^): Retrieves elements in either set, but not both.\n",
    "set1 = {1, 2, 3, 4}\n",
    "set2 = {3, 4, 5, 6}\n",
    "\n",
    "union_result = set1 | set2\n",
    "intersection_result = set1 & set2\n",
    "difference_result = set1 - set2\n",
    "symmetric_difference_result = set1 ^ set2\n",
    "\n",
    "print(union_result)\n",
    "print(intersection_result)\n",
    "print(difference_result)\n",
    "print(symmetric_difference_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "0501e0e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#Membership Test:\n",
    "\n",
    "#You can check if an element is present in a set using the in keyword.\n",
    "print(2 in my_set) \n",
    "print(7 in my_set) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "b95f5fdb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "#Set Methods:\n",
    "#Sets have various methods for performing operations and manipulations, \n",
    "#such as pop(), clear(), copy(), and update().\n",
    "my_set.pop()        # Removes and returns an arbitrary element\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "42c97d80",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "set_copy = my_set.copy()  # Creates a shallow copy of the set\n",
    "print(set_copy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "6cfc374a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set()\n"
     ]
    }
   ],
   "source": [
    "my_set.clear()      # Removes all elements from the set\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c799994b",
   "metadata": {},
   "source": [
    "### Mapping DataType\n",
    "\n",
    "In Python, the built-in mapping data type is called a dictionary. A dictionary is an unordered collection of key-value pairs, where each key must be unique. Dictionaries are also known as associative arrays or hash maps in other programming languages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "7507213f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'John', 'age': 25, 'city': 'New York'}\n"
     ]
    }
   ],
   "source": [
    "#Creating a Dictionary:\n",
    "#You can create a dictionary using curly braces {} and specifying key-value pairs using colons ':'.\n",
    "my_dict = {'name': 'John', 'age': 25, 'city': 'New York'}\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "250c1672",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John\n"
     ]
    }
   ],
   "source": [
    "#Accessing Values:\n",
    "#You can access the values in a dictionary using the keys.\n",
    "print(my_dict['name'])  # Output: John\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "1609e412",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'John', 'age': 26, 'city': 'New York', 'occupation': 'Engineer'}\n"
     ]
    }
   ],
   "source": [
    "#Adding and Modifying Elements:\n",
    "#You can add new key-value pairs or modify existing ones.\n",
    "my_dict['occupation'] = 'Engineer'\n",
    "my_dict['age'] = 26\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "f47db300",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'city': 'New York', 'occupation': 'Engineer'}\n"
     ]
    }
   ],
   "source": [
    "#Removing Elements:\n",
    "#You can remove a key-value pair using the pop() method or the del statement.\n",
    "my_dict.pop('age')\n",
    "# or\n",
    "del my_dict['name']\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6cd0a64",
   "metadata": {},
   "source": [
    "### Boolean and None Data Types\n",
    "\n",
    "Both the boolean data type and the NoneType are fundamental in Python, and understanding their usage is crucial for writing effective and correct code. Booleans are commonly used in logical and conditional statements, while None is often used to represent the absence of a value or to initialize variables.\n",
    "\n",
    "~ Boolean Data Type (bool):\n",
    "\n",
    "The bool data type represents boolean values, either True or False.\n",
    "Boolean values are often used for making decisions in control flow statements, such as if statements.\n",
    "Boolean values can result from comparison operations, logical operations, and other boolean expressions.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad032a0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# boolean data type\n",
    "x = True\n",
    "y = False\n",
    "\n",
    "result = x and y  # Logical AND\n",
    "print(result)\n",
    "\n",
    "#In addition to True and False, \n",
    "#boolean values can also be the result of various expressions, \n",
    "#such as comparisons (<, >, ==, etc.) or logical operations (and, or, not)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5fefe62",
   "metadata": {},
   "source": [
    "~None Type (NoneType):\n",
    "\n",
    "The NoneType has a single value, None, which represents the absence of a value or a null value.\n",
    "It is often used to signify that a variable or a function does not have a meaningful result or to initialize a variable before assigning a real value."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b334e941",
   "metadata": {},
   "source": [
    "## Basic Operations\n",
    "\n",
    "Basic operations in Python cover a wide range of tasks, from arithmetic and logical operations to string manipulations. Here are some fundamental operations you can perform in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "e5b5ced1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "5\n",
      "24\n",
      "5.0\n",
      "5\n",
      "2\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "##Arithmatic Operations\n",
    "\n",
    "# Addition\n",
    "result_addition = 5 + 3\n",
    "print(result_addition)\n",
    "\n",
    "# Subtraction\n",
    "result_subtraction = 7 - 2\n",
    "print(result_subtraction)\n",
    "\n",
    "# Multiplication\n",
    "result_multiplication = 4 * 6\n",
    "print(result_multiplication)\n",
    "\n",
    "# Division\n",
    "result_division = 10 / 2\n",
    "print(result_division)\n",
    "\n",
    "# Floor Division (returns the integer part of the division)\n",
    "result_floor_division = 17 // 3\n",
    "print(result_floor_division)\n",
    "\n",
    "# Modulus (returns the remainder of the division)\n",
    "result_modulus = 17 % 3\n",
    "print(result_modulus)\n",
    "\n",
    "# Exponentiation\n",
    "result_exponentiation = 2 ** 4\n",
    "print(result_exponentiation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "81b99e81",
   "metadata": {},
   "outputs": [],
   "source": [
    "##Comparison Operations\n",
    "\n",
    "# Equality\n",
    "result_equal = 5 == 5\n",
    "\n",
    "# Inequality\n",
    "result_not_equal = 7 != 3\n",
    "\n",
    "# Greater than\n",
    "result_greater_than = 10 > 8\n",
    "\n",
    "# Less than\n",
    "result_less_than = 3 < 9\n",
    "\n",
    "# Greater than or equal to\n",
    "result_greater_equal = 5 >= 5\n",
    "\n",
    "# Less than or equal to\n",
    "result_less_equal = 4 <= 6\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "0ca9a1b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "##Logical Operations\n",
    "# Logical AND\n",
    "result_logical_and = True and False\n",
    "print(result_logical_and)\n",
    "\n",
    "# Logical OR\n",
    "result_logical_or = True or False\n",
    "print(result_logical_or)\n",
    "\n",
    "# Logical NOT\n",
    "result_logical_not = not True\n",
    "print(result_logical_not)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "94b8dc12",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n",
      "PythonPythonPython\n",
      "5\n",
      "P\n",
      "yth\n"
     ]
    }
   ],
   "source": [
    "## String Operations\n",
    "# Concatenation\n",
    "result_concatenation = \"Hello, \" + \"World!\"\n",
    "print(result_concatenation)\n",
    "\n",
    "# Repetition\n",
    "result_repetition = \"Python\" * 3\n",
    "print(result_repetition)\n",
    "\n",
    "# String Length\n",
    "string_length = len(\"Hello\")\n",
    "print(string_length)\n",
    "\n",
    "# Indexing\n",
    "first_char = \"Python\"[0]  # Accessing the first character\n",
    "print(first_char)\n",
    "\n",
    "# Slicing\n",
    "substring = \"Python\"[1:4]  # Extracting a substring\n",
    "print(substring)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "6b9fdfbf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[1, 2, 3, 4, 5, 6]\n",
      "[1, 2, 4, 5, 6]\n",
      "5\n",
      "1\n",
      "[2, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "##List Operations\n",
    "# Creating a list\n",
    "my_list = [1, 2, 3, 4, 5]\n",
    "print(my_list)\n",
    "\n",
    "# Appending an element\n",
    "my_list.append(6)\n",
    "print(my_list)\n",
    "\n",
    "# Removing an element\n",
    "my_list.remove(3)\n",
    "print(my_list)\n",
    "\n",
    "# List Length\n",
    "list_length = len(my_list)\n",
    "print(list_length)\n",
    "\n",
    "# Indexing\n",
    "first_element = my_list[0]\n",
    "print(first_element)\n",
    "\n",
    "# Slicing\n",
    "sublist = my_list[1:4]\n",
    "print(sublist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "b500563c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n",
      "<class 'str'>\n",
      "123\n",
      "3\n",
      "7.0\n"
     ]
    }
   ],
   "source": [
    "##Type Conversion \n",
    "# Integer to String\n",
    "int_to_str = str(42)\n",
    "print(int_to_str)\n",
    "print(type(int_to_str))\n",
    "\n",
    "# String to Integer\n",
    "str_to_int = int(\"123\")\n",
    "print(str_to_int)\n",
    "\n",
    "# Float to Integer\n",
    "float_to_int = int(3.14)\n",
    "print(float_to_int)\n",
    "\n",
    "# Integer to Float\n",
    "int_to_float = float(7)\n",
    "print(int_to_float)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2b5ea8b",
   "metadata": {},
   "source": [
    "## Controlled Structures \n",
    "In programming, control structures are used to manage the flow of a program by making decisions and repeating actions based on conditions. There are three main types of control structures: sequential, selection (conditional), and iteration (repetition). Let's explore each of them:\n",
    "\n",
    "1. Sequential Structure:\\\n",
    "In a sequential structure, statements are executed one after another in a linear fashion. It is the default behavior of most programming languages.\n",
    "2. Selection (Conditional) Structure:\\\n",
    "Selection structures allow the program to make decisions based on conditions. The most common form is the if statement.\n",
    "3. Iteration (Repetition) Structure:\\\n",
    "Iteration structures allow the program to repeat a block of code multiple times. The most common forms are for and while loops.\n",
    "\n",
    "In addition to these basic structures, Python also supports more advanced constructs like break and continue statements within loops, allowing for more fine-grained control over the flow of the program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "906e4a17",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is the first statement.\n",
      "This is the second statement.\n"
     ]
    }
   ],
   "source": [
    "# Sequential structure\n",
    "statement1 = \"This is the first statement.\"\n",
    "statement2 = \"This is the second statement.\"\n",
    "\n",
    "print(statement1)\n",
    "print(statement2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "1c611f13",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is positive.\n"
     ]
    }
   ],
   "source": [
    "# Simple if statement\n",
    "x = 10\n",
    "\n",
    "if x > 0:\n",
    "    print(\"x is positive.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "71ac81a2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y is non-positive.\n"
     ]
    }
   ],
   "source": [
    "# If-else statement\n",
    "y = -5\n",
    "\n",
    "if y > 0:\n",
    "    print(\"y is positive.\")\n",
    "else:\n",
    "    print(\"y is non-positive.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "b19117ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z is zero.\n"
     ]
    }
   ],
   "source": [
    "# If-elif-else statement\n",
    "z = 0\n",
    "\n",
    "if z > 0:\n",
    "    print(\"z is positive.\")\n",
    "elif z < 0:\n",
    "    print(\"z is negative.\")\n",
    "else:\n",
    "    print(\"z is zero.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "f2c2bc26",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# For loop\n",
    "for i in range(5):\n",
    "    print(i)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "36955915",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# While loop\n",
    "counter = 0\n",
    "\n",
    "while counter < 5:\n",
    "    print(counter)\n",
    "    counter += 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2380a386",
   "metadata": {},
   "source": [
    "## Modules in Python\n",
    "A module is a file containing Python definitions and statements. The file name is the module name with the suffix .py added. Modules allow you to logically organize your Python code by grouping related functionality into separate files."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "157d9e6c",
   "metadata": {},
   "source": [
    "## os Module\n",
    "\n",
    "The os module in Python provides a way of interacting with the operating system. It offers a range of functions to perform operations on the file system, handle paths, and execute system commands. Here are some commonly used features of the os module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "40d36cc7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/mediomix/Desktop/BioPython_Module\n"
     ]
    }
   ],
   "source": [
    "#Get the Current Working Directory:\n",
    "import os\n",
    "\n",
    "current_directory = os.getcwd()\n",
    "print(current_directory)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "41fc85eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/mediomix/Desktop/BioPython_Module\n"
     ]
    }
   ],
   "source": [
    "#Change Directory \n",
    "#os.chdir('/path/to/new/directory')\n",
    "#for e.g. : os.chdir('/home/mediomix/Desktop/')\n",
    "os.chdir('/home/mediomix/Desktop/BioPython_Module/')\n",
    "print(os.getcwd())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "f37660fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Class 4.ipynb', 'Day 10.ipynb', 'Day 8.ipynb', 'Day 9.ipynb', 'Day1.ipynb', 'Day 6.ipynb', 'Day 11.ipynb', 'Day 5.ipynb', 'Day3.ipynb', 'Introduction_2_Python.ipynb', 'Day 12.ipynb', 'Day 7.ipynb', 'iris.csv', 'Day2.ipynb', '.ipynb_checkpoints']\n",
      "['OmicsBox.desktop', 'Blast2GO.desktop', 'mag', 'cnvtrial1', 'ezTree', 'Sample_Metagenome_data-20230619T041709Z-001.zip', 'WGS-report-standard', 'PANKAJ', 'Microbial_genomics_Demo', 'ANISA', 'cache', 'Dr.Vivek', 'meeting_31-10-2023', 'Dr.Rakesh', 'Kalai_selvi', 'server', 'MISC', 'gatk-sv', 'BioPython_Module', 'Anshu', 'random', 'cnvkit', 'nextflow_scripts', 'Kraken_Reports', 'WGS', 'qiime _master_script.sh', 'TIDDIT', 'WGS-report-tools.docx', 'HiC', 'sratoolkit.3.0.6-ubuntu64', 'WGS_workshop', 'Untitled.ipynb', 'Sample_Metagenome_data', 'scripts', 'Clinical_exome_sequencing', 'SPAdes-3.15.5-Linux', 'blast-QC', 'Dr.Vinay_Tick_Borrelia', 'Dr.Sebastian', 'ML', 'methylC', 'breakdancer', '.ipynb_checkpoints', 'Sanger_Sequencing_Projects', 'Pendrive', 'Dr Shirish', 'Anju', 'Clinical_Genomics_Demo', 'brumir']\n"
     ]
    }
   ],
   "source": [
    "#list_files_in_a_Directory\n",
    "files_and_directories = os.listdir()  # in current directory what files are there\n",
    "print(files_and_directories)\n",
    "\n",
    "files_Desktop = os.listdir('/home/mediomix/Desktop/')\n",
    "print(files_Desktop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "5103f768",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creating a new Directory\n",
    "#os.mkdir('/path/to/new/directory')\n",
    "os.mkdir('/home/mediomix/Desktop/New_folder')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "cb7f399c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Removing a Directory\n",
    "#os.rmdir('/path/to/directory')\n",
    "os.rmdir('/home/mediomix/Desktop/New_folder/')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d27ba9e8",
   "metadata": {},
   "source": [
    "## re Module ( Regular Expression)\n",
    "\n",
    "The re module in Python provides regular expression matching operations. Regular expressions (regex or regexp) are powerful tools for pattern matching and searching in strings. The re module allows you to work with regular expressions in Python. Here are some common functions provided by the re module:\n",
    "1. re.search() \\\n",
    "The re.search() function searches for a specified pattern within a string. It returns a match object if the pattern is found, otherwise, it returns None.\n",
    "2. re.match() \\\n",
    "The re.match() function checks if the pattern occurs at the beginning of the string. It returns a match object if the pattern is found at the beginning, otherwise, it returns None.\n",
    "3. re.findall() \\\n",
    "The re.findall() function returns a list of all occurrences of the pattern in the string.\n",
    "4. re.sub() \\\n",
    "The re.sub() function replaces occurrences of the pattern with a specified string.\n",
    "5. Other Functions \\\n",
    "re.split(): Splits the string at each occurrence of the pattern. \\\n",
    "re.finditer(): Returns an iterator yielding match objects for all occurrences of the pattern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "acecb5ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pattern found: apple\n"
     ]
    }
   ],
   "source": [
    "# re.search()\n",
    "import re\n",
    "\n",
    "pattern = r'apple'\n",
    "text = 'I have an apple.'\n",
    "\n",
    "match = re.search(pattern, text)\n",
    "\n",
    "if match:\n",
    "    print('Pattern found:', match.group())\n",
    "else:\n",
    "    print('Pattern not found.')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "5a1fbc68",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pattern found at the beginning: apple\n"
     ]
    }
   ],
   "source": [
    "# re.match()\n",
    "import re\n",
    "\n",
    "pattern = r'apple'\n",
    "text = 'apple is a fruit.'\n",
    "\n",
    "match = re.match(pattern, text)\n",
    "\n",
    "if match:\n",
    "    print('Pattern found at the beginning:', match.group())\n",
    "else:\n",
    "    print('Pattern not found at the beginning.')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "3e1467d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matches: ['10', '20']\n"
     ]
    }
   ],
   "source": [
    "# re.findall()\n",
    "import re\n",
    "\n",
    "pattern = r'\\d+'  # Match one or more digits\n",
    "text = 'There are 10 apples and 20 oranges.'\n",
    "\n",
    "matches = re.findall(pattern, text)\n",
    "print('Matches:', matches)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "8d8a59d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Modified Text: There are X apples and X oranges.\n"
     ]
    }
   ],
   "source": [
    "# re.sub()\n",
    "import re\n",
    "\n",
    "pattern = r'\\d+'  # Match one or more digits\n",
    "text = 'There are 10 apples and 20 oranges.'\n",
    "\n",
    "modified_text = re.sub(pattern, 'X', text)\n",
    "print('Modified Text:', modified_text)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "5abaf530",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Words: ['Split', 'this', 'text', 'into', 'words.']\n"
     ]
    }
   ],
   "source": [
    "#re.split()\n",
    "import re\n",
    "\n",
    "pattern = r'\\s+'  # Match one or more whitespace characters\n",
    "text = 'Split this text into words.'\n",
    "\n",
    "words = re.split(pattern, text)\n",
    "print('Words:', words)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db917a94",
   "metadata": {},
   "source": [
    "### Numpy \n",
    "\n",
    "NumPy, which stands for Numerical Python, is a powerful library in Python for numerical and mathematical operations. It provides support for large, multi-dimensional arrays and matrices, along with a collection of high-level mathematical functions to operate on these arrays. NumPy is a fundamental package for scientific computing in Python.\n",
    "\n",
    "Here are some key features and aspects of NumPy:\n",
    "* Arrays: The core feature of NumPy is the numpy.ndarray (n-dimensional array) data structure. This array is a table of elements, usually of the same type, indexed by a tuple of positive integers. NumPy arrays are more efficient than Python lists for numerical operations.\n",
    "* Vectorized Operations: NumPy allows you to perform operations on entire arrays without the need for explicit loops. This is known as vectorization and is a key feature that makes NumPy powerful and efficient.\n",
    "* Broadcasting: NumPy provides a mechanism called broadcasting that allows operations between arrays of different shapes and sizes.\n",
    "* Mathematical Functions: NumPy includes a wide range of mathematical functions that operate element-wise on arrays, such as np.sin(), np.cos(), np.exp(), and more.\n",
    "* Linear Algebra Operations: NumPy provides functions for linear algebra operations, including matrix multiplication (np.dot()), eigenvalue decomposition, and more.\n",
    "* Random Number Generation: NumPy includes a subpackage numpy.random for generating random numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "bd981e9f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "#Arrays\n",
    "import numpy as np\n",
    "\n",
    "# Creating a NumPy array\n",
    "arr = np.array([1, 2, 3, 4, 5])\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "736331a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11 12 13 14 15]\n"
     ]
    }
   ],
   "source": [
    "# Vectorized addition\n",
    "result = arr + 10\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "414ab708",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[[10]\n",
      " [20]\n",
      " [30]]\n",
      "[[11 12 13]\n",
      " [21 22 23]\n",
      " [31 32 33]]\n"
     ]
    }
   ],
   "source": [
    "# Broadcasting example\n",
    "arr1 = np.array([1, 2, 3])\n",
    "arr2 = np.array([[10], [20], [30]])\n",
    "result = arr1 + arr2\n",
    "print(arr1)\n",
    "print(arr2)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "6ee50068",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 4 9]\n"
     ]
    }
   ],
   "source": [
    "# Mathematical functions\n",
    "arr = np.array([1, 2, 3])\n",
    "result = np.square(arr)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "c48931e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[19 22]\n",
      " [43 50]]\n",
      "[-4 -4]\n"
     ]
    }
   ],
   "source": [
    "# Matrix multiplication\n",
    "matrix1 = np.array([[1, 2], [3, 4]])\n",
    "matrix2 = np.array([[5, 6], [7, 8]])\n",
    "result_dot = np.dot(matrix1, matrix2)\n",
    "result_cross = np.cross(matrix1, matrix2)\n",
    "\n",
    "print(result_dot)\n",
    "print(result_cross)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "6a86f381",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.02017728 0.08879981 0.78867674]\n",
      " [0.21658799 0.07673532 0.86514664]\n",
      " [0.96772185 0.56826858 0.15989148]]\n"
     ]
    }
   ],
   "source": [
    "# Random number generation\n",
    "random_array = np.random.rand(3, 3)\n",
    "print(random_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f148276d",
   "metadata": {},
   "source": [
    "## Pandas \n",
    "\n",
    "Pandas is a powerful open-source data manipulation and analysis library for Python. It provides easy-to-use data structures, such as Series and DataFrame, and functions designed for efficient data analysis and manipulation. Pandas is widely used in data science, machine learning, and other domains where data manipulation and analysis are crucial.\n",
    "* DataFrame:The DataFrame is a two-dimensional, tabular data structure with labeled axes (rows and columns).It is similar to a spreadsheet or SQL table and can handle heterogeneous data types.DataFrames can be created from various data sources, including CSV files, Excel spreadsheets, databases, and more.\n",
    "* Series:A Series is a one-dimensional labeled array capable of holding any data type.It is similar to a column in a DataFrame or a single column of data in a spreadsheet.\n",
    "* Data Input/Output: Pandas supports reading and writing data in various formats, including CSV, Excel, SQL databases, JSON, and more.\n",
    "* Data Cleaning and Transformation:Pandas provides functions for handling missing data, filtering, sorting, and transforming data.\n",
    "* Indexing and Selection:Pandas allows for easy indexing and selection of data, making it convenient to extract specific subsets of a DataFrame.\n",
    "* Grouping and Aggregation:Pandas supports grouping data by one or more columns and applying aggregate functions.\n",
    "* Merging and Joining:Pandas provides functionality for combining multiple DataFrames based on common columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "63ce3326",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      Name  Age           City\n",
      "0    Alice   25       New York\n",
      "1      Bob   30  San Francisco\n",
      "2  Charlie   35    Los Angeles\n"
     ]
    }
   ],
   "source": [
    "# Creating a DataFrame\n",
    "import pandas as pd\n",
    "\n",
    "data = {'Name': ['Alice', 'Bob', 'Charlie'],\n",
    "        'Age': [25, 30, 35],\n",
    "        'City': ['New York', 'San Francisco', 'Los Angeles']}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "print(df)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "38a07632",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    25\n",
      "1    30\n",
      "2    35\n",
      "Name: Age, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# Creating a Series\n",
    "ages = pd.Series([25, 30, 35], name='Age')\n",
    "print(ages)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "d4c0829c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     sepal.length  sepal.width  petal.length  petal.width    variety\n",
      "0             5.1          3.5           1.4          0.2     Setosa\n",
      "1             4.9          3.0           1.4          0.2     Setosa\n",
      "2             4.7          3.2           1.3          0.2     Setosa\n",
      "3             4.6          3.1           1.5          0.2     Setosa\n",
      "4             5.0          3.6           1.4          0.2     Setosa\n",
      "..            ...          ...           ...          ...        ...\n",
      "145           6.7          3.0           5.2          2.3  Virginica\n",
      "146           6.3          2.5           5.0          1.9  Virginica\n",
      "147           6.5          3.0           5.2          2.0  Virginica\n",
      "148           6.2          3.4           5.4          2.3  Virginica\n",
      "149           5.9          3.0           5.1          1.8  Virginica\n",
      "\n",
      "[150 rows x 5 columns]\n"
     ]
    }
   ],
   "source": [
    "# Reading from CSV\n",
    "df= pd.read_csv('iris.csv')\n",
    "print(df)\n",
    "\n",
    "# Writing to Excel\n",
    "#df.to_excel('output.xlsx', index=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "1d6d17cf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal.length</th>\n",
       "      <th>sepal.width</th>\n",
       "      <th>petal.length</th>\n",
       "      <th>petal.width</th>\n",
       "      <th>variety</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>Setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>145</th>\n",
       "      <td>6.7</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.2</td>\n",
       "      <td>2.3</td>\n",
       "      <td>Virginica</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>146</th>\n",
       "      <td>6.3</td>\n",
       "      <td>2.5</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1.9</td>\n",
       "      <td>Virginica</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>147</th>\n",
       "      <td>6.5</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.2</td>\n",
       "      <td>2.0</td>\n",
       "      <td>Virginica</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>148</th>\n",
       "      <td>6.2</td>\n",
       "      <td>3.4</td>\n",
       "      <td>5.4</td>\n",
       "      <td>2.3</td>\n",
       "      <td>Virginica</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149</th>\n",
       "      <td>5.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.1</td>\n",
       "      <td>1.8</td>\n",
       "      <td>Virginica</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>150 rows × 5 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     sepal.length  sepal.width  petal.length  petal.width    variety\n",
       "0             5.1          3.5           1.4          0.2     Setosa\n",
       "1             4.9          3.0           1.4          0.2     Setosa\n",
       "2             4.7          3.2           1.3          0.2     Setosa\n",
       "3             4.6          3.1           1.5          0.2     Setosa\n",
       "4             5.0          3.6           1.4          0.2     Setosa\n",
       "..            ...          ...           ...          ...        ...\n",
       "145           6.7          3.0           5.2          2.3  Virginica\n",
       "146           6.3          2.5           5.0          1.9  Virginica\n",
       "147           6.5          3.0           5.2          2.0  Virginica\n",
       "148           6.2          3.4           5.4          2.3  Virginica\n",
       "149           5.9          3.0           5.1          1.8  Virginica\n",
       "\n",
       "[150 rows x 5 columns]"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Handling missing data\n",
    "df.dropna()  # Drop rows with missing values\n",
    "df.fillna(0)  # Fill missing values with a specified value\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "533be513",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Name</th>\n",
       "      <th>Age</th>\n",
       "      <th>City</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Charlie</td>\n",
       "      <td>35</td>\n",
       "      <td>Los Angeles</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Name  Age         City\n",
       "2  Charlie   35  Los Angeles"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = {'Name': ['Alice', 'Bob', 'Charlie'],\n",
    "        'Age': [25, 30, 35],\n",
    "        'City': ['New York', 'San Francisco', 'Los Angeles']}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "# Selecting columns\n",
    "df['Name']\n",
    "\n",
    "# Selecting rows based on condition\n",
    "df[df['Age'] > 30]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5781183b",
   "metadata": {},
   "source": [
    "## Matplotlib\n",
    "\n",
    "Matplotlib is a comprehensive 2D and 3D plotting library for Python. It produces high-quality static, animated, and interactive visualizations in Python. Matplotlib is widely used for creating a variety of plots and charts, making it an essential tool for data visualization and scientific computing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d9a53953",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Data Visualization using Matplotlib.pyplot\n",
    "# Lineplots\n",
    "\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "matplotlib.use('TkAgg')\n",
    "x = [1, 2, 3, 4, 5]\n",
    "y = [2, 4, 6, 8, 10]\n",
    "\n",
    "plt.plot(x, y)\n",
    "plt.xlabel('X-axis')\n",
    "plt.ylabel('Y-axis')\n",
    "plt.title('Simple Line Plot')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "f4dd33d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Scatterplots\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = [1, 2, 3, 4, 5]\n",
    "y = [2, 4, 6, 8, 10]\n",
    "\n",
    "plt.scatter(x, y)\n",
    "plt.xlabel('X-axis')\n",
    "plt.ylabel('Y-axis')\n",
    "plt.title('Scatter Plot')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "d21009e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Bar plot\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "categories = ['A', 'B', 'C', 'D']\n",
    "values = [3, 7, 1, 5]\n",
    "\n",
    "plt.bar(categories, values)\n",
    "plt.xlabel('Categories')\n",
    "plt.ylabel('Values')\n",
    "plt.title('Bar Plot')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "14e329ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Histogram\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "data = np.random.randn(1000)  # Random data\n",
    "\n",
    "plt.hist(data, bins=30)\n",
    "plt.xlabel('Value')\n",
    "plt.ylabel('Frequency')\n",
    "plt.title('Histogram')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "5e878740",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pie chart\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "labels = ['A', 'B', 'C', 'D']\n",
    "sizes = [25, 30, 15, 30]\n",
    "\n",
    "plt.pie(sizes, labels=labels, autopct='%1.2f%%')\n",
    "plt.title('Pie Chart')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "a97841ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3D scatter plot\n",
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "\n",
    "x = [1, 2, 3, 4, 5]\n",
    "y = [2, 4, 6, 8, 10]\n",
    "z = [1, 1, 2, 2, 3]\n",
    "\n",
    "ax.scatter(x, y, z)\n",
    "ax.set_xlabel('X-axis')\n",
    "ax.set_ylabel('Y-axis')\n",
    "ax.set_zlabel('Z-axis')\n",
    "\n",
    "plt.show()\n"
   ]
  }
 ],
 "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.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}