Day 1 - Basics OF Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "27f6bb94",
   "metadata": {},
   "source": [
    "# Python Output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d57a110a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "# Python is case sensitive\n",
    "print('Hello World')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "8754ffd0",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'hey' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_9556\\1311815035.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mhey\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# it throws error beacuse only string always in \" \"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'hey' is not defined"
     ]
    }
   ],
   "source": [
    "print(hey) # it throws error beacuse only string is always in \" \""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "24c94382",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "print(7) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5f6dad4b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3eb85c33",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello 3 4 5 True\n"
     ]
    }
   ],
   "source": [
    "# how print function strng in python -- it print all the values which we want to print with space\n",
    "print('Hello',3,4,5,True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b49201a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello/3/4/5/True\n"
     ]
    }
   ],
   "source": [
    "# sep\n",
    "print('Hello',3,4,5,True,sep='/') # sep is separator where in print function space is given b sep function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e103c562",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "world\n"
     ]
    }
   ],
   "source": [
    "print('hello')\n",
    "print('world')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9821e303",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "you=me\n"
     ]
    }
   ],
   "source": [
    "# end\n",
    "print('you',end=\"=\")\n",
    "print ('me')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5f5a11b",
   "metadata": {},
   "source": [
    "# Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78009ca8",
   "metadata": {},
   "source": [
    "## 1. Integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9c6d6a1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "print(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5af9c0e1",
   "metadata": {},
   "source": [
    "## 2. Float (Decimal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "45e1e84c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8.44\n"
     ]
    }
   ],
   "source": [
    "print(8.44)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39f75b0e",
   "metadata": {},
   "source": [
    "## 3. Boolean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "2bbb3a5d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(True)\n",
    "print(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d194ac74",
   "metadata": {},
   "source": [
    "## 4. String (Text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "1efa036a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello gem\n"
     ]
    }
   ],
   "source": [
    "print('Hello gem')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64ccdb9b",
   "metadata": {},
   "source": [
    "## 5. Complex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c433968f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5+6j)\n"
     ]
    }
   ],
   "source": [
    "print(5+6j)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7159b46",
   "metadata": {},
   "source": [
    "## 6. List \n",
    "In Python, a list is a data type used to store a collection of values. It is one of the built-in data types and is classified as a sequence type. Lists are ordered, mutable (which means you can change their contents), and can contain elements of different data types, including integers, floats, strings, or even other lists.\n",
    "\n",
    "You can create a list in Python by enclosing a comma-separated sequence of values within square brackets [ ]. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "593dbe2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "print([1,2,3,4])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b03cedb4",
   "metadata": {},
   "source": [
    "## 7. Tuple\n",
    "In Python, a tuple is another data type used to store a collection of values, similar to a list. However, there are some key differences between tuples and lists:\n",
    "\n",
    "* Immutable: The most significant difference is that tuples are immutable, meaning once you create a tuple, you cannot change its contents (add, remove, or modify elements). Lists, on the other hand, are mutable, and you can modify them after creation.\n",
    "\n",
    "* Syntax: Tuples are created by enclosing a comma-separated sequence of values within parentheses (). Lists are created with square brackets []. For example:\n",
    "\n",
    "* Performance: Due to their immutability, tuples can be more efficient in terms of memory and performance for certain use cases compared to lists.\n",
    "\n",
    "Tuples are often used when you have a collection of values that should not be changed during the course of your program. For example, you might use tuples to represent coordinates (x, y), dates (year, month, day), or other data where the individual components should remain constant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b8f9c916",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 4)\n"
     ]
    }
   ],
   "source": [
    "print((1,2,3,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dff07220",
   "metadata": {},
   "source": [
    "## 8. sets\n",
    "In Python, a set is a built-in data type used to store an unordered collection of unique elements. Sets are defined by enclosing a comma-separated sequence of values within curly braces {} or by using the built-in set() constructor. Sets automatically eliminate duplicate values, ensuring that each element is unique within the set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "5be1587f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "print({1,2,3,4,5})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "712527c4",
   "metadata": {},
   "source": [
    "## 9. Dictionary\n",
    "In Python, a dictionary is a built-in data type used to store a collection of key-value pairs. Each key in a dictionary maps to a specific value, creating a relationship between them. Dictionaries are also known as associative arrays or hash maps in other programming languages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "fc705db8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Nitish', 'gender': 'Male', 'weight': 70}\n"
     ]
    }
   ],
   "source": [
    "print({'name':'Nitish','gender':'Male','weight':70})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d20fda1",
   "metadata": {},
   "source": [
    "## How to know which type of Datatype is?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "db8c175b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type([1,2,3,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "610a24df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type({'age':20})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18897d51",
   "metadata": {},
   "source": [
    "# 3. Variables "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a1d4f68",
   "metadata": {},
   "source": [
    "In Python, variables are used to store data values. These values can be numbers, strings, lists, dictionaries, or any other data type. Variables are essential for manipulating and working with data in your programs. Here's how you declare and use variables in Python:\n",
    "\n",
    "1. Variable Declaration: You declare a variable by assigning a value to it using the assignment operator '='.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "74eb02b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5  # Assigning the integer value 5 to the variable 'x'\n",
    "name = \"Alice\"  # Assigning a string value to the variable 'name'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "403cb2e1",
   "metadata": {},
   "source": [
    "2. Variable Names: Variable names (also known as identifiers) must adhere to the following rules:\n",
    "\n",
    "* They can contain letters (a-z, A-Z), digits (0-9), and underscores (_).\n",
    "* They cannot start with a digit.\n",
    "* Variable names are case-sensitive, so myVar and myvar are treated as different variables.\n",
    "* Python has reserved keywords (e.g., if, for, while, print) that cannot be used as variable names.\n",
    "\n",
    "3. Data Types: Python is dynamically typed, which means you don't need to declare the data type of a variable explicitly. Python will determine the data type automatically based on the assigned value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "68f0185d",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5  # 'x' is an integer variable\n",
    "name = \"Alice\"  # 'name' is a string variable"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4aef1b8d",
   "metadata": {},
   "source": [
    "4. Reassignment: You can change the value of a variable by assigning it a new value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "32757978",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "x = x + 1  # Updating the value of 'x' to 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "720ed816",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f40f6027",
   "metadata": {},
   "source": [
    "Multiple Assignment: Python allows you to assign multiple variables in a single line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "7154bf24",
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b, c = 1, 2, 3  # Assigning values 1, 2, and 3 to variables a, b, and c, respectively"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "50fc8d06",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "767ce0e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = 2\n",
    "c = 3\n",
    "print(a,b,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "c5a6fed9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 5 5\n"
     ]
    }
   ],
   "source": [
    "a=b=c= 5\n",
    "print(a,b,c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8579f400",
   "metadata": {},
   "source": [
    "## What is comments in Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2ec0ddf",
   "metadata": {},
   "source": [
    "In Python, comments are used to annotate and provide explanations within your code. Comments are not executed by the Python interpreter; instead, they are meant for human readers to understand the code better. Comments are ignored by the interpreter during program execution.\n",
    "\n",
    "Python supports two types of comments:\n",
    "\n",
    "1. **Single-line Comments**: Single-line comments start with the hash symbol (`#`) and continue until the end of the line. They are used to add comments on a single line.\n",
    "\n",
    "   ```python\n",
    "   # This is a single-line comment\n",
    "   x = 5  # Assigning a value to 'x'\n",
    "   ```\n",
    "\n",
    "   Everything after the `#` symbol on that line is considered a comment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "819bc055",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is a single-line comment\n",
    "x = 5  # Assigning a value to 'x'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bfe5c29",
   "metadata": {},
   "source": [
    "2. **Multi-line or Block Comments**: Python does not have a specific syntax for multi-line comments like some other languages (e.g., C, Java). However, you can create multi-line comments by using triple-quotes (`'''` or `\"\"\"`) as a string delimiter. These strings are not assigned to any variable and are ignored by the interpreter. This is a common practice for writing docstrings (documentation within functions and modules).\n",
    "\n",
    "\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "ca7c7ad5",
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "This is a multi-line comment.\n",
    "It can span multiple lines.\n",
    "'''\n",
    "def my_function():\n",
    "    \"\"\"\n",
    "    This is a docstring.\n",
    "    It provides documentation for the function.\n",
    "    \"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4af8a9b7",
   "metadata": {},
   "source": [
    "While these triple-quoted strings are not technically comments, they are often used as a way to document code effectively.\n",
    "\n",
    "Comments are crucial for making your code more understandable, both for yourself and for others who may read your code. They help explain the purpose of variables, functions, and complex algorithms, making it easier to maintain and debug code. Good commenting practices can significantly improve code readability and maintainability."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46b95ceb",
   "metadata": {},
   "source": [
    "# 4. User Input\n",
    "How to get Input from the user in python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "3397d77a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter EmailSagar@95\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Sagar@95'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input('Enter Email')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "944b288b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter first number1\n",
      "enter second number2\n",
      "3\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "# take input from users and store them in a variable\n",
    "fnum = int(input('enter first number'))\n",
    "snum = int(input('enter second number'))\n",
    "#print(type(fnum),type(snum))\n",
    "# add the 2 variables\n",
    "result = fnum + snum\n",
    "# print the result\n",
    "print(result)\n",
    "print(type(fnum))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5ddfbb7",
   "metadata": {},
   "source": [
    "# 5. Type Conversion\n",
    "How to covert One Datatypeinto another In python?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e5b2d82",
   "metadata": {},
   "source": [
    "* int(): Converts a value to an integer data type. This is useful when you want to convert a string or a floating-point number to an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "5e26344a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "123"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str_number = \"123\"\n",
    "int_number = int(str_number)  # Converts the string \"123\" to an integer\n",
    "int_number"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "385d4327",
   "metadata": {},
   "source": [
    "* float(): Converts a value to a floating-point data type. It is used to convert integers or strings containing numeric values to floating-point numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "595fc69d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42.0"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int_value = 42\n",
    "float_value = float(int_value)  # Converts the integer 42 to a float\n",
    "float_value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "cfabb5de",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_9556\\3112067906.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"24\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "a = 23\n",
    "b = \"24\"\n",
    "\n",
    "print(a+b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "436bd1f5",
   "metadata": {},
   "source": [
    "It Gives error beacause We do not add float into integer datatyupe so we have to convert above opeartion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "12f94596",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "47.0\n"
     ]
    }
   ],
   "source": [
    "a = 23\n",
    "b = \"24\"\n",
    "\n",
    "print(float(a)+float(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecd9374c",
   "metadata": {},
   "source": [
    "# 6. Literals\n",
    "In Python, literals are used to represent fixed values in your code. These values are not variables or expressions but rather constants that have a specific value and data type associated with them. Python supports various types of literals,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "6abcd649",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 100 200 300\n",
      "10.5 150.0 0.0015\n",
      "3.14j 3.14 0.0\n"
     ]
    }
   ],
   "source": [
    "a = 0b1010 #Binary Literals\n",
    "b = 100 #Decimal Literal \n",
    "c = 0o310 #Octal Literal\n",
    "d = 0x12c #Hexadecimal Literal\n",
    "\n",
    "#Float Literal\n",
    "float_1 = 10.5 \n",
    "float_2 = 1.5e2 # 1.5 * 10^2\n",
    "float_3 = 1.5e-3 # 1.5 * 10^-3\n",
    "\n",
    "#Complex Literal \n",
    "x = 3.14j\n",
    "\n",
    "print(a, b, c, d)\n",
    "print(float_1, float_2,float_3)\n",
    "print(x, x.imag, x.real)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "eafc25a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.14\n"
     ]
    }
   ],
   "source": [
    "# binary\n",
    "x = 3.14j\n",
    "print(x.imag)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "827ec158",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is Python\n",
      "This is Python\n",
      "C\n",
      "This is a multiline string with more than one line code.\n",
      "😀😆🤣\n",
      "raw \\n string\n"
     ]
    }
   ],
   "source": [
    "string = 'This is Python'\n",
    "strings = \"This is Python\"\n",
    "char = \"C\"\n",
    "multiline_str = \"\"\"This is a multiline string with more than one line code.\"\"\"\n",
    "unicode = u\"\\U0001f600\\U0001F606\\U0001F923\"\n",
    "raw_str = r\"raw \\n string\"\n",
    "\n",
    "print(string)\n",
    "print(strings)\n",
    "print(char)\n",
    "print(multiline_str)\n",
    "print(unicode)\n",
    "print(raw_str)"
   ]
  }
 ],
 "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}