Day 1 - What is Programming and Python?

What is Programming
Programming is a way for us to tell computers what to do. Computer is a
very dumb machine and it only does what we tell it to do. Hence we learn
programming and tell computers to do what we are very slow at -
computation. If I ask you to calculate 5+6, you will immediately say 11.
How about 23453453 X 56456?
You will start searching for a calculator or jump to a new tab to calculate
the same. This 100 days of code series will help you learn python from
starting to the end. We will start from 0 and by the time we end this
course, I promise you will be a Job ready Python developer!
What is Python?
 Python is a dynamically typed, general purpose programming
language that supports an object-oriented programming approach as
well as a functional programming approach.
 Python is an interpreted and a high-level programming language.
 It was created by Guido Van Rossum in 1989.
Features of Python
 Python is simple and easy to understand.
It is Interpreted and platform-independent which makes debugging very
easy.
 Python is an open-source programming language.

Python provides very big library support. Some of the popular libraries
include NumPy, Tensorflow, Selenium, OpenCV, etc.
 It is possible to integrate other programming languages within
python.
What is Python used for
 Python is used in Data Visualization to create plots and graphical
representations.
 Python helps in Data Analytics to analyze and understand raw data
for insights and trends.
 It is used in AI and Machine Learning to simulate human behavior
and to learn from past data without hard coding.
 It is used to create web applications.
 It can be used to handle databases.
 It is used in business and accounting to perform complex
mathematical operations along with quantitative and qualitative
analysis
 What is a variable?
 Variable is like a container that holds data. Very similar to how our
containers in kitchen holds sugar, salt etc Creating a variable is like
creating a placeholder in memory and assigning it some value. In
Python its as easy as writing:
 a=1
 b = True
 c = "Harry"
 d = None
What is a Data Type?
 Data type specifies the four variables of different data types.
 type of value a variable holds. This is required in programming to do
various operations without causing an error.
In python, we can print the type of any operator using type function:
 a=1
 print(type(a))
 b = "1"
 print(type(b))
 By default, python provides the following built-in data types:
 1. Numeric data: int, float, complex
 int: 3, -8, 0
 float: 7.349, -9.0, 0.0000001
 complex: 6 + 2i
 2. Text data: str
 str: "Hello World!!!", "Python Programming"
 3. Boolean data:
 Boolean data consists of values True or False.
 4. Sequenced data: list, tuple
  list: A list is an ordered collection of data with elements separated
by a comma and enclosed within square brackets. Lists are mutable
and can be modified after creation.
 Example:
 list1 = [8, 2.3, [-4, 5], ["apple", "banana"]]
 print(list1)
 Output:
 [8, 2.3, [-4, 5], ['apple', 'banana']]
 Tuple: A tuple is an ordered collection of data with elements
separated by a comma and enclosed within parentheses. Tuples are
immutable and can not be modified after creation.
 Example:
 tuple1 = (("parrot", "sparrow"), ("Lion", "Tiger"))
 print(tuple1)
 Output:
 (('parrot', 'sparrow'), ('Lion', 'Tiger'))
 5. Mapped data: dict
 dict: A dictionary is an unordered collection of data containing a
key:value pair. The key:value pairs are enclosed within curly
brackets.
 Example:
dict1 = {"name":"Sakshi", "age":20, "canVote":True}
 print(dict1)
 Output:
 {'name': 'Sakshi', 'age': 20, 'canVote': True}
Operators

Python has different types of operators for different operations. To create

a calculator we require arithmetic operators.
Arithmetic operators

Operator Operator Name Example

+ Addition 15+7

- Subtraction 15-7

* Multiplication 5*7

** Exponential 5**3

/ Division 5/3

% Modulus 15%7

// Floor Division 15//7

Exercise

n = 15
m = 7
ans1 = n+m
print("Addition of",n,"and",m,"is", ans1)
ans2 = n-m
print("Subtraction of",n,"and",m,"is", ans2)
ans3 = n*m
print("Multiplication of",n,"and",m,"is", ans3)
ans4 = n/m
print("Division of",n,"and",m,"is", ans4)
ans5 = n%m
print("Modulus of",n,"and",m,"is", ans5)
ans6 = n//m
print("Floor Division of",n,"and",m,"is", ans6)

Explaination

Here 'n' and 'm' are two variables in which the integer value is being
stored. Variables 'ans1' , 'ans2' ,'ans3', 'ans4','ans5' and 'ans6' contains
the outputs corresponding to addition, subtraction,multiplication, division,
modulus and floor division respectively.
 Typecasting in python
The conversion of one data type into the other data type is known as
type casting in python or type conversion in python.
Python supports a wide variety of functions or methods like: int(),
float(), str(), ord(), hex(), oct(), tuple(), set(), list(), dict(), etc. for the
type casting in python.
Two Types of Typecasting:
1. Explicit Conversion (Explicit type casting in python)
2. Implicit Conversion (Implicit type casting in python).
Explicit typecasting:

The conversion of one data type into another data type, done via
developer or programmer's intervention or manually as per the
requirement, is known as explicit type conversion.
It can be achieved with the help of Python’s built-in type conversion
functions such as int(), float(), hex(), oct(), str(), etc .
Example of explicit typecasting:
string = "15"
number = 7
string_number = int(string) #throws an error if the string is not a valid
integer
sum= number + string_number
print("The Sum of both the numbers is: ", sum)
Output:
The Sum of both the numbers is 22
Implicit type casting:
Data types in Python do not have the same level i.e. ordering of data
types is not the same in Python. Some of the data types have higher-
order, and some have lower order. While performing any operations on
variables with different data types in Python, one of the variable's data
types will be changed to the higher data type. According to the level,
one data type is converted into other by the Python interpreter itself
(automatically). This is called, implicit typecasting in python.
Python converts a smaller data type to a higher data type to prevent
data loss.
Example of implicit type casting:
# Python automatically converts
# a to int
a=7
print(type(a))

# Python automatically converts b to float

b = 3.0
print(type(b))

# Python automatically converts c to float as it is a float addition

c=a+b
print(c)
print(type(c))
Ouput:
<class 'int'>
<class 'float'>
10.0
<class 'float'>
Taking User Input in python
In python, we can take user input directly by using input() [Link]
input function gives a return value as string/character hence we have
to pass that into a variable
Syntax:
variable=input()
But input function returns the value as string. Hence we have to
typecast them whenever required to another datatype.
Example:
variable=int(input())
variable=float(input())
We can also display a text using input function. This will make input()
function take user input and display a message as well
Example:
a=input("Enter the name: ")
print(a)
Output:
Enter the name: Harry
Harry
What are strings?
In python, anything that you enclose between single or double
quotation marks is considered a string. A string is essentially a
sequence or array of textual data. Strings are used when working with
Unicode characters.
Example
name = "Harry"
print("Hello, " + name)
Output
Hello, Harry
Note: It does not matter whether you enclose your strings in single or
double quotes, the output remains the same.
Sometimes, the user might need to put quotation marks in between
the strings. Example, consider the sentence: He said, “I want to eat an
apple”.
How will you print this statement in python?: He said, "I want to eat an
apple". We will definitely use single quotes for our convenience
print('He said, "I want to eat an apple".')
Multiline Strings
If our string has multiple lines, we can create them like this:
a = """Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua."""
print(a)
Accessing Characters of a String
In Python, string is like an array of characters. We can access parts of
string by using its index which starts from 0.
Square brackets can be used to access elements of the string.
print(name[0])
print(name[1])
Looping through the string
We can loop through strings using a for loop like this:
for character in name:
print(character)
Above code prints all the characters in the string name one by one!
Example program
name = "Harry"
friend = "Rohan"
anotherFriend = 'Lovish'
apple = '''He said,
Hi Harry
hey I am good
"I want to eat an apple'''

print("Hello, " + name)

# print(apple)
print(name[0])
print(name[1])
print(name[2])
print(name[3])
print(name[4])
# print(name[5]) # Throws an error
print("Lets use a for loop\n")
for character in apple:
print(character)
String Slicing & Operations on String
Length of a String
We can find the length of a string using len() function.
Example:
fruit = "Mango"
len1 = len(fruit)
print("Mango is a", len1, "letter word.")
Output:
Mango is a 5 letter word.
String as an array
A string is essentially a sequence of characters also called an array.
Thus we can access the elements of this array.
Example:
pie = "ApplePie"
print(pie[:5])
print(pie[6]) #returns character at specified index
Output:
Apple
i
Note: This method of specifying the start and end index to specify a
part of a string is called slicing.
Slicing Example:
pie = "ApplePie"
print(pie[:5]) #Slicing from Start
print(pie[5:]) #Slicing till End
print(pie[2:6]) #Slicing in between
print(pie[-8:]) #Slicing using negative index
Output:
Apple
Pie
pleP
ApplePie
 Loop through a String:
Strings are arrays and arrays are iterable. Thus we can loop through
strings.
Example:
alphabets = "ABCDE"
for i in alphabets:
print(i)
Output:
A
B
C
D
E
Example program
fruit = "Mango"
mangoLen = len(fruit)
print(mangoLen)
# print(fruit[0:4]) # including 0 but not 4
# print(fruit[1:4]) # including 1 but not 4
# print(fruit[:5])
# print(fruit[0:-3])
# print(fruit[:len(fruit)-3])
print(fruit[-1:len(fruit) - 3])
print(fruit[-3:-1])

# Quick Quiz:
# nm = "Harry"
# print(nm[-4:-2])
# @codewithharry
String methods
Python provides a set of built-in methods that we can use to alter and
modify the strings.
upper() :
The upper() method converts a string to upper case.
Example:
str1 = "AbcDEfghIJ"
print([Link]())
Output:
ABCDEFGHIJ
lower()
The lower() method converts a string to lower case.
Example:
str1 = "AbcDEfghIJ"
print([Link]())
Output:
abcdefghij
strip() :
The strip() method removes any white spaces before and after the string.
Example:
str2 = " Silver Spoon "
print([Link])
Output:
Silver Spoon
rstrip() :
the rstrip() removes any trailing characters. Example:
str3 = "Hello !!!"
print([Link]("!"))
Output:
Hello
replace() :
The replace() method replaces all occurences of a string with another
string. Example:
str2 = "Silver Spoon"
print([Link]("Sp", "M"))
Output:
Silver Moon
split() :
The split() method splits the given string at the specified instance and
returns the separated strings as list items.
Example:
str2 = "Silver Spoon"
print([Link](" ")) #Splits the string at the whitespace " ".
Output:
['Silver', 'Spoon']
There are various other string methods that we can use to modify our
strings.
capitalize() :
The capitalize() method turns only the first character of the string to
uppercase and the rest other characters of the string are turned to
lowercase. The string has no effect if the first character is already
uppercase.
Example:
str1 = "hello"
capStr1 = [Link]()
print(capStr1)
str2 = "hello WorlD"
capStr2 = [Link]()
print(capStr2)
Output:
Hello
Hello world
center() :
The center() method aligns the string to the center as per the parameters
given by the user.
Example:
str1 = "Welcome to the Console!!!"
print([Link](50))
Output:
Welcome to the Console!!!
We can also provide padding character. It will fill the rest of the fill
characters provided by the user.
Example:
str1 = "Welcome to the Console!!!"
print([Link](50, "."))
Output:
............Welcome to the Console!!!.............
count() :
The count() method returns the number of times the given value has
occurred within the given string.
Example:
str2 = "Abracadabra"
countStr = [Link]("a")
print(countStr)
Output:
4
endswith() :
The endswith() method checks if the string ends with a given value. If yes
then return True, else return False.
Example :
str1 = "Welcome to the Console !!!"
print([Link]("!!!"))
Output:
True
We can even also check for a value in-between the string by providing
start and end index positions.
Example:
str1 = "Welcome to the Console !!!"
print([Link]("to", 4, 10))
Output:
True
find() :
The find() method searches for the first occurrence of the given value and
returns the index where it is present. If given value is absent from the
string then return -1.
Example:
str1 = "He's name is Dan. He is an honest man."
print([Link]("is"))
Output:
10
As we can see, this method is somewhat similar to the index() method.
The major difference being that index() raises an exception if value is
absent whereas find() does not.
Example:
str1 = "He's name is Dan. He is an honest man."
print([Link]("Daniel"))
Output:
-1
index() :
The index() method searches for the first occurrence of the given value
and returns the index where it is present. If given value is absent from the
string then raise an exception.
Example:
str1 = "He's name is Dan. Dan is an honest man."
print([Link]("Dan"))
Output:
13
As we can see, this method is somewhat similar to the find() method. The
major difference being that index() raises an exception if value is absent
whereas find() does not.
Example:
str1 = "He's name is Dan. Dan is an honest man."
print([Link]("Daniel"))
Output:
ValueError: substring not found
isalnum() :
The isalnum() method returns True only if the entire string only consists of
A-Z, a-z, 0-9. If any other characters or punctuations are present, then it
returns False.
Example 1:
str1 = "WelcomeToTheConsole"
print([Link]())
Output:
True
isalpha() :
The isalnum() method returns True only if the entire string only consists of
A-Z, a-z. If any other characters or punctuations or numbers(0-9) are
present, then it returns False.
Example :
str1 = "Welcome"
print([Link]())
Output:
True
islower() :
The islower() method returns True if all the characters in the string are
lower case, else it returns False.
Example:
str1 = "hello world"
print([Link]())
Output:
True

isprintable() :
The isprintable() method returns True if all the values within the given
string are printable, if not, then return False.

Example :
str1 = "We wish you a Merry Christmas"
print([Link]())

Output:
True

isspace() :
The isspace() method returns True only and only if the string contains
white spaces, else returns False.

Example:
str1 = " " #using Spacebar
print([Link]())
str2 = " " #using Tab
print([Link]())

Output:
True
True

istitle() :
The istitile() returns True only if the first letter of each word of the string is
capitalized, else it returns False.

Example:
str1 = "World Health Organization"
print([Link]())
Output:
True

Example:
str2 = "To kill a Mocking bird"
print([Link]())

Output:
False

isupper() :
The isupper() method returns True if all the characters in the string are
upper case, else it returns False.

Example :
str1 = "WORLD HEALTH ORGANIZATION"
print([Link]())

Output:
True

startswith() :
The endswith() method checks if the string starts with a given value. If
yes then return True, else return False.

Example :
str1 = "Python is a Interpreted Language"
print([Link]("Python"))

Output:
True

swapcase() :
The swapcase() method changes the character casing of the string. Upper
case are converted to lower case and lower case to upper case.

Example:
str1 = "Python is a Interpreted Language"
print([Link]())
Output:
pYTHON IS A iNTERPRETED lANGUAGE
title() :
The title() method capitalizes each letter of the word within the string.

Example:
str1 = "He's name is Dan. Dan is an honest man."
print([Link]())
Output:
He'S Name Is Dan. Dan Is An Honest Man.

if-else Statements
Sometimes the programmer needs to check the evaluation of certain
expression(s), whether the expression(s) evaluate to True or False. If the
expression evaluates to False, then the program execution follows a
different path than it would have if the expression had evaluated to True.
Based on this, the conditional statements are further classified into
following types:
 if
 if-else
 if-else-elif
 nested if-else-elif.

An if……else statement evaluates like this:

if the expression evaluates True:
Execute the block of code inside if statement. After execution return to
the code out of the if……else block.\
if the expression evaluates False:
Execute the block of code inside else statement. After execution return to
the code out of the if……else block.

Example:
applePrice = 210
budget = 200
if (applePrice <= budget):
print("Alexa, add 1 kg Apples to the cart.")
else:
print("Alexa, do not add Apples to the cart.")

Output:
Alexa, do not add Apples to the cart.

Example program
a = int(input("Enter your age: "))
print("Your age is:", a)
# Conditional operators
# >, <, >=, <=, ==, !=
# print(a>18)
# print(a<=18)
# print(a==18)
# print(a!=18)
if(a>18):
print("You can drive")
print("Yes")
else:
print("You cannot drive")
print("No")
print("Yay!")

elif Statements
Sometimes, the programmer may want to evaluate more than one
condition, this can be done using an elif statement.
Working of an elif statement
Execute the block of code inside if statement if the initial expression
evaluates to True. After execution return to the code out of the if block.
Execute the block of code inside the first elif statement if the expression
inside it evaluates True. After execution return to the code out of the if
block.
Execute the block of code inside the second elif statement if the
expression inside it evaluates True. After execution return to the code out
of the if block.
.
.
.
Execute the block of code inside the nth elif statement if the expression
inside it evaluates True. After execution return to the code out of the if
block.
Execute the block of code inside else statement if none of the expression
evaluates to True. After execution return to the code out of the if block.

Example:
num = 0
if (num < 0):
print("Number is negative.")
elif (num == 0):
print("Number is Zero.")
else:
print("Number is positive.")

Output:
Number is Zero.

Nested if statements
We can use if, if-else, elif statements inside other if statements as well.

Example:
num = 18
if (num < 0):
print("Number is negative.")
elif (num > 0):
 if (num <= 10):
print("Number is between 1-10")
elif (num > 10 and num <= 20):
print("Number is between 11-20")
else:
print("Number is greater than 20")
else:
print("Number is zero")
Output:
Number is between 11-20

Match case in python

In Python, the match / case statement was introduced in Python 3.10
as part of structural pattern matching.
It works similarly to switch in other languages, but is much more
powerful: you can match values, types, and even unpack data structures

A match statement will compare a given variable’s value to different

shapes, also referred to as the pattern. The main idea is to keep on
comparing the variable with all the present patterns until it fits into one.
The match case consists of three main entities :
1. The match keyword
2. One or more case clauses
3. Expression for each case
The case clause consists of a pattern to be matched to the variable, a
condition to be evaluated if the pattern matches, and a set of statements
to be executed if the pattern matches.
Syntax:
match variable_name:
case ‘pattern1’ : //statement1
case ‘pattern2’ : //statement2
…
case ‘pattern n’ : //statement n
Example:
x=4
# x is the variable to match
match x:
# if x is 0
case 0:
print("x is zero")
# case with if-condition
case 4 if x % 2 == 0:
print("x % 2 == 0 and case is 4")
# Empty case with if-condition
case _ if x < 10:
print("x is < 10")
# default case(will only be matched if the above cases were not
matched)
# so it is basically just an else:
case _:
print(x)
Output:
x % 2 == 0 and case is 4

Introduction to Loops
Sometimes a programmer wants to execute a group of statements a
certain number of times. This can be done using loops. Based on this
loops are further classified into following main types;
 for loop
 while loop

The for Loop

for loops can iterate over a sequence of iterable objects in python.
Iterating over a sequence is nothing but iterating over strings, lists,
tuples, sets and dictionaries.
Example: iterating over a string:
name = 'Abhishek'
for i in name:
print(i, end=", ")
Output:
A, b, h, i, s, h, e, k,
Example: iterating over a list:
colors = ["Red", "Green", "Blue", "Yellow"]
for x in colors:
print(x)
Output:
Red
Green
Blue
Yellow
Similarly, we can use loops for lists, sets and dictionaries.

range():
What if we do not want to iterate over a sequence? What if we want to
use for loop for a specific number of times?
Here, we can use the range() function.
Example:
for k in range(5):
print(k)
Output:
0
1
2
3
4
Here, we can see that the loop starts from 0 by default and increments at
each iteration.
But we can also loop over a specific range.
Example:
for k in range(4,9):
print(k)
Output:
4
5
6
7
8
Quick Quiz
Explore about third parameter of range (ie range(x, y, z))
Answer is: Third parameter is step count

Python while Loop

As the name suggests, while loops execute statements while the
condition is True. As soon as the condition becomes False, the interpreter
comes out of the while loop.
Example:
count = 5
while (count > 0):
print(count)
count = count - 1
Output:
5
4
3
2
1
Here, the count variable is set to 5 which decrements after each iteration.
Depending upon the while loop condition, we need to either increment or
decrement the counter variable (the variable count, in our case) or the
loop will continue forever.
Else with While Loop
We can even use the else statement with the while loop. Essentially what
the else statement does is that as soon as the while loop condition
becomes False, the interpreter comes out of the while loop and the else
statement is executed.
Example:
x=5
while (x > 0):
print(x)
x=x-1
else:
print('counter is 0')
Output:
5
4
3
2
1
counter is 0

Do-While loop in python

do..while is a loop in which a set of instructions will execute at least once
(irrespective of the condition) and then the repetition of loop's body will
depend on the condition passed at the end of the while loop. It is also
known as an exit-controlled loop.
How to emulate do while loop in python?
To create a do while loop in Python, you need to modify the while loop a
bit in order to get similar behavior to a do while loop.
The most common technique to emulate a do-while loop in Python is to
use an infinite while loop with a break statement wrapped in an if
statement that checks a given condition and breaks the iteration if that
condition becomes true:
Example
while True:
number = int(input("Enter a positive number: "))
print(number)
 if not number > 0:
break
Output
Enter a positive number: 1
1
Enter a positive number: 4
4
Enter a positive number: -1
-1
Explanation
This loop uses True as its formal condition. This trick turns the loop into an
infinite loop. Before the conditional statement, the loop runs all the
required processing and updates the breaking condition. If this condition
evaluates to true, then the break statement breaks out of the loop, and
the program execution continues its normal path.
break statement

The break statement enables a program to skip over a part of the code.
A break statement terminates the very loop it lies within.

example

for i in range(1,101,1):
print(i ,end=" ")
if(i==50):
break
else:
print("Mississippi")
print("Thank you")

output

1 Mississippi
2 Mississippi
3 Mississippi
4 Mississippi
5 Mississippi
.
.
.
50 Mississippi

Continue Statement

The continue statement skips the rest of the loop statements and causes
the next iteration to occur.

example

for i in [2,3,4,6,8,0]:
if (i%2!=0):
continue
print(i)

output

2
4
6
8
0
Python Functions
A function is a block of code that performs a specific task whenever it is
called. In bigger programs, where we have large amounts of code, it is
advisable to create or use existing functions that make the program flow
organized and neat.

There are two types of functions:

1. Built-in functions
2. User-defined functions

Built-in functions:

These functions are defined and pre-coded in python. Some examples of

built-in functions are as follows:

min(), max(), len(), sum(), type(), range(), dict(), list(), tuple(), set(),
print(), etc.

User-defined functions:
We can create functions to perform specific tasks as per our needs. Such
functions are called user-defined functions.

Syntax:
def function_name(parameters):
pass
# Code and Statements
 Create a function using the def keyword, followed by a function
name, followed by a paranthesis (()) and a colon(:).
 Any parameters and arguments should be placed within the
parentheses.
 Rules to naming function are similar to that of naming variables.
 Any statements and other code within the function should be
indented.

Calling a function:

We call a function by giving the function name, followed by parameters (if

any) in the parenthesis.

Example:
def name(fname, lname):
print("Hello,", fname, lname)
name("Sam", "Wilson")
Output:
Hello, Sam Wilson

Program example:
def calculateGmean(a, b):
mean = (a*b)/(a+b)
print(mean)

def isGreater(a, b):

if(a>b):
print("First number is greater")
else:
print("Second number is greater or equal")

def isLesser(a, b):

pass

a = 9
b = 8
isGreater(a, b)
calculateGmean(a, b)
# gmean1 = (a*b)/(a+b)
# print(gmean1)
c = 8
d = 74
isGreater(c, d)
calculateGmean(c, d)
# gmean2 = (c*d)/(c+d)
# print(gmean2)

Function Arguments and return statement

There are four types of arguments that we can provide in a function:

 Default Arguments
 Keyword Arguments
 Variable length Arguments
 Required Arguments

Default arguments:
We can provide a default value while creating a function. This way the
function assumes a default value even if a value is not provided in the
function call for that argument.

Example:
def name(fname, mname = "Jhon", lname = "Whatson"):
print("Hello,", fname, mname, lname)
name("Amy")
Output:
Hello, Amy Jhon Whatson

Keyword arguments:
We can provide arguments with key = value, this way the interpreter
recognizes the arguments by the parameter name. Hence, the the order
in which the arguments are passed does not matter.

Example:
def name(fname, mname, lname):
print("Hello,", fname, mname, lname)
name(mname = "Peter", lname = "Wesker", fname = "Jade")
Output:
Hello, Jade Peter Wesker
Required arguments:

In case we don’t pass the arguments with a key = value syntax, then it is
necessary to pass the arguments in the correct positional order and the
number of arguments passed should match with actual function
definition.

Example 1: when number of arguments passed does not match to the

actual function definition.
def name(fname, mname, lname):
print("Hello,", fname, mname, lname)
name("Peter", "Quill")
Output:
name("Peter", "Quill")\
TypeError: name() missing 1 required positional argument:
'lname'
Example 2: when number of arguments passed matches to the actual
function definition.
def name(fname, mname, lname):
print("Hello,", fname, mname, lname)
name("Peter", "Ego", "Quill")
Output:
Hello, Peter Ego Quill

Variable-length arguments:

Sometimes we may need to pass more arguments than those defined in

the actual function. This can be done using variable-length arguments.

There are two ways to achieve this:

Arbitrary Arguments:

While creating a function, pass a * before the parameter name while

defining the function. The function accesses the arguments by processing
them in the form of tuple.

Example:
def name(*name):
print("Hello,", name[0], name[1], name[2])
name("James", "Buchanan", "Barnes")
Output:
Hello, James Buchanan Barnes

Keyword Arbitrary Arguments:

While creating a function, pass a * before the parameter name while
defining the function. The function accesses the arguments by processing
them in the form of dictionary.

Example:
def name(**name):
print("Hello,", name["fname"], name["mname"],
name["lname"])
name(mname = "Buchanan", lname = "Barnes", fname = "James")
Output:
Hello, James Buchanan Barnes

return Statement

The return statement is used to return the value of the expression back to
the calling function.

Example:
def name(fname, mname, lname):
return "Hello, " + fname + " " + mname + " " + lname
print(name("James", "Buchanan", "Barnes"))
Output:
Hello, James Buchanan Barnes
Python Collections (Arrays)

There are four collection data types in the Python programming language:

 List is a collection which is ordered and changeable. Allows

duplicate members.

 Tuple is a collection which is ordered and unchangeable. Allows

duplicate members.

 Set is a collection which is unordered, unchangeable*, and

unindexed. No duplicate members.

 Dictionary is a collection which is ordered** and changeable. No

duplicate members.

Video example
def average(*numbers):
# print(type(numbers))
sum = 0
for i in numbers:
sum = sum + i
# print("Average is: ", sum / len(numbers))
# return 7
return sum / len(numbers)

# average(4, 6)
# average(b=9)

c = average(5, 6, 7, 1)
print(c)

Python Lists

 Lists are ordered collection of data items.

 They store multiple items in a single variable.
 List items are separated by commas and enclosed within square
brackets [].
 Lists are changeable meaning we can alter them after creation.
Example 1:
lst1 = [1,2,2,3,5,4,6]
lst2 = ["Red", "Green", "Blue"]
print(lst1)
print(lst2)
Output:
[1, 2, 2, 3, 5, 4, 6]
['Red', 'Green', 'Blue']
Example 2:
details = ["Abhijeet", 18, "FYBScIT", 9.8]
print(details)
Output:
['Abhijeet', 18, 'FYBScIT', 9.8]
List Index

Each item/element in a list has its own unique index. This index can be
used to access any particular item from the list. The first item has index
[0], second item has index [1], third item has index [2] and so on.

Example:
colors = ["Red", "Green", "Blue", "Yellow", "Green"]
# [0] [1] [2] [3] [4]

Accessing list items

We can access list items by using its index with the square bracket syntax
[]. For example colors[0] will give "Red", colors[1] will give "Green" and so
on...

Positive Indexing:

As we have seen that list items have index, as such we can access items
using these indexes.

Example:
colors = ["Red", "Green", "Blue", "Yellow", "Green"]
# [0] [1] [2] [3] [4]
print(colors[2])
print(colors[4])
print(colors[0])

Output:
Blue
Green
Red
Negative Indexing:

Similar to positive indexing, negative indexing is also used to access

items, but from the end of the list. The last item has index [-1], second
last item has index [-2], third last item has index [-3] and so on.

Example:
colors = ["Red", "Green", "Blue", "Yellow", "Green"]
# [-5] [-4] [-3] [-2] [-1]
print(colors[-1])
print(colors[-3])
print(colors[-5])

Output:
Green
Blue
Red

Check whether an item in present in the list?

We can check if a given item is present in the list. This is done using
the in keyword.
colors = ["Red", "Green", "Blue", "Yellow", "Green"]
if "Yellow" in colors:
print("Yellow is present.")
else:
print("Yellow is absent.")

Output:
Yellow is present.
colors = ["Red", "Green", "Blue", "Yellow", "Green"]
if "Orange" in colors:
print("Orange is present.")
else:
print("Orange is absent.")

Output:
Orange is absent.

Range of Index:
You can print a range of list items by specifying where you want to start,
where do you want to end and if you want to skip elements in between
the range.
Syntax:
listName[start : end : jumpIndex]
Note: jump Index is optional. We will see this in later examples.

Example: printing elements within a particular range:

animals = ["cat", "dog", "bat", "mouse", "pig", "horse",
"donkey", "goat", "cow"]
print(animals[3:7]) #using positive indexes
print(animals[-7:-2]) #using negative indexes'

Output:
['mouse', 'pig', 'horse', 'donkey']
['bat', 'mouse', 'pig', 'horse', 'donkey']
Here, we provide index of the element from where we want to start and
the index of the element till which we want to print the values.

Note: The element of the end index provided will not be included.

Example: printing all element from a given index till the end
animals = ["cat", "dog", "bat", "mouse", "pig", "horse",
"donkey", "goat", "cow"]
print(animals[4:]) #using positive indexes
print(animals[-4:]) #using negative indexes

Output:
['pig', 'horse', 'donkey', 'goat', 'cow']
['horse', 'donkey', 'goat', 'cow']
When no end index is provided, the interpreter prints all the values till the
end.

Example: printing all elements from start to a given index

animals = ["cat", "dog", "bat", "mouse", "pig", "horse",
"donkey", "goat", "cow"]
print(animals[:6]) #using positive indexes
print(animals[:-3]) #using negative indexes

Output:
['cat', 'dog', 'bat', 'mouse', 'pig', 'horse']
['cat', 'dog', 'bat', 'mouse', 'pig', 'horse']
When no start index is provided, the interpreter prints all the values from
start up to the end index provided.
Example: Printing alternate values
animals = ["cat", "dog", "bat", "mouse", "pig", "horse",
"donkey", "goat", "cow"]
print(animals[::2]) #using positive indexes
print(animals[-8:-1:2]) #using negative indexes

Output:
['cat', 'bat', 'pig', 'donkey', 'cow']
['dog', 'mouse', 'horse', 'goat']
Here, we have not provided start and index, which means all the values
will be considered. But as we have provided a jump index of 2 only
alternate values will be printed.

Example: printing every 3rd consecutive value withing a given range

animals = ["cat", "dog", "bat", "mouse", "pig", "horse",
"donkey", "goat", "cow"]
print(animals[1:8:3])

Output:
['dog', 'pig', 'goat
Here, jump index is 3. Hence it prints every 3rd element within given
index.

List Comprehension

List comprehensions are used for creating new lists from other iterables
like lists, tuples, dictionaries, sets, and even in arrays and strings.

Syntax:

List = [Expression(item) for item in iterable if Condition]

Expression: It is the item which is being iterated.

Iterable: It can be list, tuples, dictionaries, sets, and even in arrays and
strings.
Condition: Condition checks if the item should be added to the new list
or not.

Example 1: Accepts items with the small letter “o” in the new list
names = ["Milo", "Sarah", "Bruno", "Anastasia", "Rosa"]
namesWith_O = [item for item in names if "o" in item]
print(namesWith_O)
Output:
['Milo', 'Bruno', 'Rosa']

Example 2: Accepts items which have more than 4 letters

names = ["Milo", "Sarah", "Bruno", "Anastasia", "Rosa"]
namesWith_O = [item for item in names if (len(item) > 4)]
print(namesWith_O)

Output:
['Sarah', 'Bruno', 'Anastasia']

Video example
marks = [3, 5, 6, "Harry", True, 6, 7 , 2, 32, 345, 23]
# print(marks)
# print(type(marks))
# print(marks[0])
# print(marks[1])
# print(marks[2])
# print(marks[3])
# print(marks[4])
# print(marks[5])

# print(marks[-3]) # Negative index

# print(marks[len(marks)-3]) # Positive index
# print(marks[5-3]) # Positive index
# print(marks[2]) # Positive index

# if "6" in marks:
# print("Yes")
# else:
# print("No")

# Same thing applies for strings as well!

# if "Ha" in "Harry":
# print("Yes")

# print(marks[0:7])
# print(marks[1:9])
# print(marks[1:9:3])

LIST COMPREHENSION………………………………………………
lst = [i*i for i in range(10)]
print(lst)
lst = [i*i for i in range(10) if i%2==0]
print(lst)

OUT PUT FOR LIST COMPREHENSION…………………………..

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[0, 4, 16, 36, 64]

List Methods

[Link]()

This method sorts the list in ascending order. The original list is updated

Example 1:

colors = ["voilet", "indigo", "blue", "green"]

[Link]()
print(colors)
num = [4,2,5,3,6,1,2,1,2,8,9,7]
[Link]()
print(num)

Output:

['blue', 'green', 'indigo', 'voilet']\

[1, 1, 2, 2, 2, 3, 4, 5, 6, 7, 8, 9]
What if you want to print the list in descending order?
We must give reverse=True as a parameter in the sort method.

Example:

colors = ["voilet", "indigo", "blue", "green"]

[Link](reverse=True)
print(colors)
num = [4,2,5,3,6,1,2,1,2,8,9,7]
[Link](reverse=True)
print(num)

Output:

['voilet', 'indigo', 'green', 'blue']

[9, 8, 7, 6, 5, 4, 3, 2, 2, 2, 1, 1]
The reverse parameter is set to False by default.

Note: Do not mistake the reverse parameter with the reverse method.
reverse()

This method reverses the order of the list.

Example:

colors = ["voilet", "indigo", "blue", "green"]

[Link]()
print(colors)
num = [4,2,5,3,6,1,2,1,2,8,9,7]
[Link]()
print(num)

Output:

['green', 'blue', 'indigo', 'voilet']

[7, 9, 8, 2, 1, 2, 1, 6, 3, 5, 2, 4]

index()

This method returns the index of the first occurrence of the list item.

Example:

colors = ["voilet", "green", "indigo", "blue", "green"]

print([Link]("green"))
num = [4,2,5,3,6,1,2,1,3,2,8,9,7]
print([Link](3))
Output:
1
3

count()

Returns the count of the number of items with the given value.

Example:

colors = ["voilet", "green", "indigo", "blue", "green"]

print([Link]("green"))
num = [4,2,5,3,6,1,2,1,3,2,8,9,7]

Output:

2
3
copy()

Returns copy of the list. This can be done to perform operations on the
list without modifying the original list.

Example:

colors = ["voilet", "green", "indigo", "blue"]

newlist = [Link]()
print(colors)
print(newlist)

Output:

['voilet', 'green', 'indigo', 'blue']

['voilet', 'green', 'indigo', 'blue']

append():

This method appends items to the end of the existing list.

Example:

colors = ["voilet", "indigo", "blue"]

[Link]("green")
print(colors)

Output:

['voilet', 'indigo', 'blue', 'green']

insert():

This method inserts an item at the given index. User has to specify index
and the item to be inserted within the insert() method.

Example:

colors = ["voilet", "indigo", "blue"]

# [0] [1] [2]
[Link](1, "green") #inserts item at index 1
# updated list: colors = ["voilet", "green", "indigo", "blue"]
# indexs [0] [1] [2] [3]
print(colors)

Output:

['voilet', 'green', 'indigo', 'blue']

extend():

This method adds an entire list or any other collection datatype (set,
tuple, dictionary) to the existing list.

Example 1:

#add a list to a list

colors = ["voilet", "indigo", "blue"]
rainbow = ["green", "yellow", "orange", "red"]
[Link](rainbow)
print(colors)

Output:

['voilet', 'indigo', 'blue', 'green', 'yellow', 'orange',

'red']

Concatenating two lists:

You can simply concatenate two lists to join two lists.

Example:

colors = ["voilet", "indigo", "blue", "green"]

colors2 = ["yellow", "orange", "red"]
print(colors + colors2)

Output:

['voilet', 'indigo', 'blue', 'green', 'yellow', 'orange',

'red']

EXAMPLE VIDEO PROGRAM

l = [11, 45, 1, 2, 4, 6, 1, 1]
print(l)
# [Link](7)
# [Link](reverse=True)
# [Link]()
# print([Link](1))
# print([Link](1))
# m = [Link]()
# m[0] = 0
# [Link](1, 899)
m = [900, 1000, 1100]
k = l + m
# print(k)
# [Link](m)
print(l)

Python Tuples

Tuples are ordered collection of data items. They store multiple items in a
single variable. Tuple items are separated by commas and enclosed
within round brackets (). Tuples are unchangeable meaning we can not
alter them after creation.

Example 1:

tuple1 = (1,2,2,3,5,4,6)
tuple2 = ("Red", "Green", "Blue")
print(tuple1)
print(tuple2)

Output:

(1, 2, 2, 3, 5, 4, 6)
('Red', 'Green', 'Blue')

Example 2:

details = ("Abhijeet", 18, "FYBScIT", 9.8)

print(details)

Output:

('Abhijeet', 18, 'FYBScIT', 9.8)

Tuple Indexes

Each item/element in a tuple has its own unique index. This index can be
used to access any particular item from the tuple. The first item has index
[0], second item has index [1], third item has index [2] and so on.

Example:

country = ("Spain", "Italy", "India",)

# [0] [1] [2]
Accessing tuple items:

I. Positive Indexing:

As we have seen that tuple items have index, as such we can access
items using these indexes.

Example:
country = ("Spain", "Italy", "India",)
# [0] [1] [2]
print(country[0])
print(country[1])
print(country[2])
Output:
Spain
Italy
India

II. Negative Indexing:

Similar to positive indexing, negative indexing is also used to access

items, but from the end of the tuple. The last item has index [-1], second
last item has index [-2], third last item has index [-3] and so on.

Example:

country = ("Spain", "Italy", "India", "England", "Germany")

# [0] [1] [2] [3] [4]
print(country[-1]) # Similar to print(country[len(country) -
1])
print(country[-3])
print(country[-4])

Output:

Germany
India
Italy

III. Check for item:

We can check if a given item is present in the tuple. This is done using
the in keyword.
Example 1:

country = ("Spain", "Italy", "India", "England", "Germany")

if "Germany" in country:
print("Germany is present.")
else:
print("Germany is absent.")

Output:

Germany is present.

Example 2:

country = ("Spain", "Italy", "India", "England", "Germany")

if "Russia" in country:
print("Russia is present.")
else:
print("Russia is absent.")

Output:

Russia is absent.

IV. Range of Index:

You can print a range of tuple items by specifying where do you want to
start, where do you want to end and if you want to skip elements in
between the range.

Syntax:

Tuple[start : end : jumpIndex]

Note: jump Index is optional. We will see this in given examples.

Example: Printing elements within a particular range:

animals = ("cat", "dog", "bat", "mouse", "pig", "horse",

"donkey", "goat", "cow")
print(animals[3:7]) #using positive indexes
print(animals[-7:-2]) #using negative indexes

Output:

('mouse', 'pig', 'horse', 'donkey')

('bat', 'mouse', 'pig', 'horse', 'donkey')
Here, we provide index of the element from where we want to start and
the index of the element till which we want to print the values. Note: The
element of the end index provided will not be included.

Example: Printing all element from a given index till the end

animals = ("cat", "dog", "bat", "mouse", "pig", "horse",

"donkey", "goat", "cow")
print(animals[4:]) #using positive indexes
print(animals[-4:]) #using negative indexes

Output:

('pig', 'horse', 'donkey', 'goat', 'cow')

('horse', 'donkey', 'goat', 'cow')
When no end index is provided, the interpreter prints all the values till the
end.

Example: printing all elements from start to a given index

animals = ("cat", "dog", "bat", "mouse", "pig", "horse",

"donkey", "goat", "cow")
print(animals[:6]) #using positive indexes
print(animals[:-3]) #using negative indexes

Output:

('cat', 'dog', 'bat', 'mouse', 'pig', 'horse')

('cat', 'dog', 'bat', 'mouse', 'pig', 'horse')
When no start index is provided, the interpreter prints all the values from
start up to the end index provided.

Example: Print alternate values

animals = ("cat", "dog", "bat", "mouse", "pig", "horse",

"donkey", "goat", "cow")
print(animals[::2]) #using positive indexes
print(animals[-8:-1:2]) #using negative indexes

Output:

('cat', 'bat', 'pig', 'donkey', 'cow')

('dog', 'mouse', 'horse', 'goat')
Here, we have not provided start and end index, which means all the
values will be considered. But as we have provided a jump index of 2 only
alternate values will be printed.
Example: printing every 3rd consecutive withing given range

animals = ("cat", "dog", "bat", "mouse", "pig", "horse",

"donkey", "goat", "cow")
print(animals[1:8:3])

Output:

('dog', 'pig', 'goat')

Here, jump index is 3. Hence it prints every 3rd element within given
index.

EXAMPLE VIDEO PROOGRAM

tup = (1, 2, 76, 342, 32, "green", True)
# tup[0] = 90
print(type(tup), tup)
print(len(tup))
print(tup[0])
print(tup[-1])
print(tup[2])
# print(tup[34])

if 3421 in tup:
print("Yes 342 is present in this tuple")
tup2 = tup[1:4]
print(tup2)

Manipulating Tuples

Tuples are immutable, hence if you want to add, remove or change tuple
items, then first you must convert the tuple to a list. Then perform
operation on that list and convert it back to tuple.

Example:
countries = ("Spain", "Italy", "India", "England", "Germany")
temp = list(countries)
[Link]("Russia") #add item
[Link](3) #remove item
temp[2] = "Finland" #change item
countries = tuple(temp)
print(countries)

Output:
('Spain', 'Italy', 'Finland', 'Germany', 'Russia')
Thus, we convert the tuple to a list, manipulate items of the list using list
methods, then convert list back to a tuple.

However, we can directly concatenate two tuples without converting

them to list.

Example:
countries = ("Pakistan", "Afghanistan", "Bangladesh",
"ShriLanka")
countries2 = ("Vietnam", "India", "China")
southEastAsia = countries + countries2
print(southEastAsia)

Output:
('Pakistan', 'Afghanistan', 'Bangladesh', 'ShriLanka',
'Vietnam', 'India', 'China')

Tuple methods

As tuple is immutable type of collection of elements it have limited built

in [Link] are explained below

count() Method

The count() method of Tuple returns the number of times the given
element appears in the tuple.

Syntax:

[Link](element)

Example

Tuple1 = (0, 1, 2, 3, 2, 3, 1, 3, 2)
res = [Link](3)
print('Count of 3 in Tuple1 is:', res)

Output

3
index() method

The Index() method returns the first occurrence of the given element
from the tuple.

Syntax:

[Link](element, start, end)

Note: This method raises a ValueError if the element is not found in the
tuple.

Example

Tuple = (0, 1, 2, 3, 2, 3, 1, 3, 2)
res = [Link](3)
print('First occurrence of 3 is', res)

Output

String formatting in python

String formatting can be done in python using the format method.

txt = "For only {price:.2f} dollars!"
print([Link](price = 49))

f-strings in python

It is a new string formatting mechanism introduced by the PEP 498. It is

also known as Literal String Interpolation or more commonly as F-strings
(f character preceding the string literal). The primary focus of this
mechanism is to make the interpolation easier.

When we prefix the string with the letter 'f', the string becomes the f-
string itself. The f-string can be formatted in much same as the
[Link]() method. The f-string offers a convenient way to embed
Python expression inside string literals for formatting.

Example

val = 'Geeks'
print(f"{val}for{val} is a portal for {val}.")
name = 'Tushar'
age = 23
print(f"Hello, My name is {name} and I'm {age} years old.")
Output:

Hello, My name is Tushar and I'm 23 years old.

In the above code, we have used the f-string to format the string. It
evaluates at runtime; we can put all valid Python expressions in them.

We can use it in a single statement as well.

Example

print(f"{2 * 30})"

Output:

60

EXAMPLE VIDEO PROGRAM

etter = "Hey my name is {1} and I am from {0}"
country = "India"
name = "Harry"

print([Link](country, name))
print(f"Hey my name is {name} and I am from {country}")
print(f"We use f-strings like this: Hey my name is {{name}}
and I am from {{country}}")
price = 49.09999
txt = f"For only {price:.2f} dollars!"
print(txt)
# print([Link]())
print(type(f"{2 * 30}"))

output
Hey my name is Harry and I am from India
Hey my name is Harry and I am from India
We use f-strings like this: Hey my name is {name} and I am from
{country}
For only 49.10 dollars!
<class 'str'>

Docstrings in python
Python docstrings are the string literals that appear right after the
definition of a function, method, class, or module.

Example

def square(n):
'''Takes in a number n, returns the square of n'''
print(n**2)
square(5)
Here,

'''Takes in a number n, returns the square of n''' is a docstring which will

not appear in output

Output:

25
Here is another example:
def add(num1, num2):
"""
Add up two integer numbers.
This function simply wraps the ``+`` operator, and does
not
do anything interesting, except for illustrating what
the docstring of a very simple function looks like.
Parameters
----------
num1 : int
First number to add.
num2 : int
Second number to add.
Returns
-------
int
The sum of ``num1`` and ``num2``.
See Also
--------
subtract : Subtract one integer from another.
Examples
--------
>>> add(2, 2)
4
>>> add(25, 0)
25
>>> add(10, -10)
0
 """
return num1 + num2

Python Comments vs Docstrings

Python Comments
Comments are descriptions that help programmers better understand the
intent and functionality of the program. They are completely ignored by
the Python interpreter.

Python docstrings
As mentioned above, Python docstrings are strings used right after the
definition of a function, method, class, or module (like in Example 1).
They are used to document our code.

We can access these docstrings using the doc attribute.

Python doc attribute
Whenever string literals are present just after the definition of a function,
module, class or method, they are associated with the object as
their doc attribute. We can later use this attribute to retrieve this
docstring.

Example

def square(n):
'''Takes in a number n, returns the square of n'''
return n**2
print(square.__doc__)

Output:

Takes in a number n, returns the square of n

PEP 8

PEP 8 is a document that provides guidelines and best practices on how

to write Python code. It was written in 2001 by Guido van Rossum, Barry
Warsaw, and Nick Coghlan. The primary focus of PEP 8 is to improve the
readability and consistency of Python code.

PEP stands for Python Enhancement Proposal, and there are several of
them. A PEP is a document that describes new features proposed for
Python and documents aspects of Python, like design and style, for the
community.

The Zen of Python

Long time Pythoneer Tim Peters succinctly channels the BDFL’s guiding
principles for Python’s design into 20 aphorisms, only 19 of which have
been written down.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to
do it.
Although that way may not be obvious at first unless you're
Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good
idea.
Namespaces are one honking great idea -- let's do more of
those!

Easter egg

import this
Recursion in python

Recursion is the process of defining something in terms of itself.

Python Recursive Function

In Python, we know that a function can call other functions. It is even

possible for the function to call itself. These types of construct are termed
as recursive functions.
Example:

def factorial(num):
if (num == 1 or num == 0):
return 1
else:
return (num * factorial(num - 1))
# Driver Code
num = 7;
print("Number: ",num)
print("Factorial: ",factorial(num))

Output:

number: 7
Factorial: 5040
EXAMPLE PROGRAM
# factorial(7) = 7*6*5*4*3*2*1
# factorial(6) = 6*5*4*3*2*1
# factorial(5) = 5*4*3*2*1
# factorial(4) = 4*3*2*1
# factorial(0) = 1

# factorial(n) = n * factorial(n-1)
def factorial(n):
if (n == 0 or n == 1):
return 1
else:
return n * factorial(n - 1)

print(factorial(5))
# 5 * factorial(4)
# 5 * 4 * factorial(3)
# 5 * 4 * 3 * factorial(2)
# 5 * 4 * 3 * 2 * factorial(1)
# 5 * 4 * 3 * 2 * 1
Python Sets

Sets are unordered collection of data items. They store multiple items in a
single variable. Set items are separated by commas and enclosed within
curly brackets {}. Sets are unchangeable, meaning you cannot change
items of the set once created. Sets do not contain duplicate items.

Example:
info = {"Carla", 19, False, 5.9, 19}
print(info)

Output:
{False, 19, 5.9, 'Carla'}
Here we see that the items of set occur in random order and hence they
cannot be accessed using index numbers. Also sets do not allow duplicate
values.

Quick Quiz: Try to create an empty set. Check using the type() function
whether the type of your variable is a set

Accessing set items:

Using a For loop

You can access items of set using a for loop.

Example:
info = {"Carla", 19, False, 5.9}
for item in info:
print(item)

Output:
False
Carla
19
5.9
Example video program
s = {2, 4, 2, 6}
print(s)

info = {"Carla", 19, False, 5.9, 19}

print(info)

harry = set()
print(type(harry))

for value in info:

print(value)
Joining Sets
Sets in python more or less work in the same way as sets in mathematics.
We can perform operations like union and intersection on the sets just
like in mathematics.

I. union() and update():

The union() and update() methods prints all items that are present in the
two sets. The union() method returns a new set whereas update() method
adds item into the existing set from another set.

Example:
cities = {"Tokyo", "Madrid", "Berlin", "Delhi"}
cities2 = {"Tokyo", "Seoul", "Kabul", "Madrid"}
cities3 = [Link](cities2)
print(cities3)

Output:
{'Tokyo', 'Madrid', 'Kabul', 'Seoul', 'Berlin', 'Delhi'}

Example:
cities = {"Tokyo", "Madrid", "Berlin", "Delhi"}
cities2 = {"Tokyo", "Seoul", "Kabul", "Madrid"}
[Link](cities2)
print(cities)

Output:
{'Berlin', 'Madrid', 'Tokyo', 'Delhi', 'Kabul', 'Seoul'}

II. intersection and intersection_update():

The intersection() and intersection_update() methods prints only items

that are similar to both the sets. The intersection() method returns a new
set whereas intersection_update() method updates into the existing set
from another set.

Example:
cities = {"Tokyo", "Madrid", "Berlin", "Delhi"}
cities2 = {"Tokyo", "Seoul", "Kabul", "Madrid"}
cities3 = [Link](cities2)
print(cities3)

Output:
{'Madrid', 'Tokyo'}
Example :
cities = {"Tokyo", "Madrid", "Berlin", "Delhi"}
cities2 = {"Tokyo", "Seoul", "Kabul", "Madrid"}
cities.intersection_update(cities2)
print(cities)

Output:
{'Tokyo', 'Madrid'}

III. symmetric_difference and symmetric_difference_update():

The symmetric_difference() and symmetric_difference_update() methods

prints only items that are not similar to both the sets. The
symmetric_difference() method returns a new set whereas
symmetric_difference_update() method updates into the existing set from
another set.

Example:
cities = {"Tokyo", "Madrid", "Berlin", "Delhi"}
cities2 = {"Tokyo", "Seoul", "Kabul", "Madrid"}
cities3 = cities.symmetric_difference(cities2)
print(cities3)

Output:
{'Seoul', 'Kabul', 'Berlin', 'Delhi'}

Example:
cities = {"Tokyo", "Madrid", "Berlin", "Delhi"}
cities2 = {"Tokyo", "Seoul", "Kabul", "Madrid"}
cities.symmetric_difference_update(cities2)
print(cities)

Output:
{'Kabul', 'Delhi', 'Berlin', 'Seoul'}

IV. difference() and difference_update():

The difference() and difference_update() methods prints only items that

are only present in the original set and not in both the sets. The
difference() method returns a new set whereas difference_update()
method updates into the existing set from another set.

Example:
cities = {"Tokyo", "Madrid", "Berlin", "Delhi"}
cities2 = {"Seoul", "Kabul", "Delhi"}
cities3 = [Link](cities2)
print(cities3)

Output:
{'Tokyo', 'Madrid', 'Berlin'}

Example:
cities = {"Tokyo", "Madrid", "Berlin", "Delhi"}
cities2 = {"Seoul", "Kabul", "Delhi"}
print([Link](cities2))

Output:
{'Tokyo', 'Berlin', 'Madrid'}

Set Methods

There are several in-built methods used for the manipulation of [Link]
are explained below

isdisjoint():

The isdisjoint() method checks if items of given set are present in another
set. This method returns False if items are present, else it returns True.

Example:

cities = {"Tokyo", "Madrid", "Berlin", "Delhi"}

cities2 = {"Tokyo", "Seoul", "Kabul", "Madrid"}
print([Link](cities2))

Output:

False

issuperset():

The issuperset() method checks if all the items of a particular set are
present in the original set. It returns True if all the items are present, else
it returns False.

Example:

cities = {"Tokyo", "Madrid", "Berlin", "Delhi"}

cities2 = {"Seoul", "Kabul"}
print([Link](cities2))
cities3 = {"Seoul", "Madrid","Kabul"}
print([Link](cities3))

Output:

False
False

issubset():

The issubset() method checks if all the items of the original set are
present in the particular set. It returns True if all the items are present,
else it returns False.

Example:

cities = {"Tokyo", "Madrid", "Berlin", "Delhi"}

cities2 = {"Delhi", "Madrid"}
print([Link](cities))

Output:

True

add()

If you want to add a single item to the set use the add() method.

Example:

cities = {"Tokyo", "Madrid", "Berlin", "Delhi"}

[Link]("Helsinki")
print(cities)

Output:

{'Tokyo', 'Helsinki', 'Madrid', 'Berlin', 'Delhi'}

update()

If you want to add more than one item, simply create another set or any
other iterable object(list, tuple, dictionary), and use the update() method
to add it into the existing set.
Example:

cities = {"Tokyo", "Madrid", "Berlin", "Delhi"}

cities2 = {"Helsinki", "Warsaw", "Seoul"}
[Link](cities2)
print(cities)

Output:

{'Seoul', 'Berlin', 'Delhi', 'Tokyo', 'Warsaw', 'Helsinki', 'Madrid'}

remove()/discard()

We can use remove() and discard() methods to remove items form list.

Example :

cities = {"Tokyo", "Madrid", "Berlin", "Delhi"}

[Link]("Tokyo")
print(cities)

Output:

{'Delhi', 'Berlin', 'Madrid'}

The main difference between remove and discard is that, if we try to

delete an item which is not present in set, then remove() raises an error,
whereas discard() does not raise any error.

Example:

cities = {"Tokyo", "Madrid", "Berlin", "Delhi"}

[Link]("Seoul")
print(cities)

Output:

KeyError: 'Seoul'

pop()

This method removes the last item of the set but the catch is that we
don’t know which item gets popped as sets are unordered. However, you
can access the popped item if you assign the pop() method to a variable.

Example:

cities = {"Tokyo", "Madrid", "Berlin", "Delhi"}

item = [Link]()
print(cities)
print(item)

Output:

{'Tokyo', 'Delhi', 'Berlin'} Madrid

del

del is not a method, rather it is a keyword which deletes the set entirely.

Example:

cities = {"Tokyo", "Madrid", "Berlin", "Delhi"}

del cities
print(cities)

Output:

NameError: name 'cities' is not defined We get an error because our

entire set has been deleted and there is no variable called cities which
contains a set.

What if we don’t want to delete the entire set, we just want to delete all
items within that set?

clear():

This method clears all items in the set and prints an empty set.

Example:

cities = {"Tokyo", "Madrid", "Berlin", "Delhi"}

[Link]()
print(cities)

Output:

set()

Check if item exists

You can also check if an item exists in the set or not.

Example

info = {"Carla", 19, False, 5.9}

if "Carla" in info:
 print("Carla is present.")
else:
print("Carla is absent.")

Output:

Carla is present.

Python Dictionaries

Dictionaries are ordered collection of data items. They store multiple

items in a single variable. Dictionary items are key-value pairs that are
separated by commas and enclosed within curly brackets {}.

Example:

info = {'name':'Karan', 'age':19, 'eligible':True}

print(info)

Output:

{'name': 'Karan', 'age': 19, 'eligible': True}

Accessing Dictionary items:

I. Accessing single values:

Values in a dictionary can be accessed using keys. We can access

dictionary values by mentioning keys either in square brackets or by
using get method.

Example:

info = {'name':'Karan', 'age':19, 'eligible':True}

print(info['name'])
print([Link]('eligible'))

Output:

Karan
True

II. Accessing multiple values:

We can print all the values in the dictionary using values() method.

Example:

info = {'name':'Karan', 'age':19, 'eligible':True}

print([Link]())

Output:

dict_values(['Karan', 19, True])

III. Accessing keys:

We can print all the keys in the dictionary using keys() method.

Example:

info = {'name':'Karan', 'age':19, 'eligible':True}

print([Link]())

Output:

dict_keys(['name', 'age', 'eligible'])

IV. Accessing key-value pairs:

We can print all the key-value pairs in the dictionary using items()
method.

Example:

info = {'name':'Karan', 'age':19, 'eligible':True}

print([Link]())

Output:

dict_items([('name', 'Karan'), ('age', 19), ('eligible',

True)])

Dictionary Methods

Dictionary uses several built-in methods for [Link] are listed

below

update()

The update() method updates the value of the key provided to it if the
item already exists in the dictionary, else it creates a new key-value pair.

Example:

info = {'name':'Karan', 'age':19, 'eligible':True}

print(info)
[Link]({'age':20})
[Link]({'DOB':2001})
print(info)

Output:

{'name': 'Karan', 'age': 19, 'eligible': True}

{'name': 'Karan', 'age': 20, 'eligible': True, 'DOB': 2001}

Removing items from dictionary:

There are a few methods that we can use to remove items from
dictionary.

clear():

The clear() method removes all the items from the list.

Example:

info = {'name':'Karan', 'age':19, 'eligible':True}

[Link]()
print(info)

Output:

{}

pop():

The pop() method removes the key-value pair whose key is passed as a
parameter.

Example:

info = {'name':'Karan', 'age':19, 'eligible':True}

[Link]('eligible')
print(info)

Output:

{'name': 'Karan', 'age': 19}

popitem():

The popitem() method removes the last key-value pair from the
dictionary.
Example:

info = {'name':'Karan', 'age':19, 'eligible':True, 'DOB':2003}

[Link]()
print(info)

Output:

{'name': 'Karan', 'age': 19, 'eligible': True}

del:

we can also use the del keyword to remove a dictionary item.

Example:

info = {'name':'Karan', 'age':19, 'eligible':True, 'DOB':2003}

del info['age']
print(info)

Output:

{'name': 'Karan', 'eligible': True, 'DOB': 2003}

If key is not provided, then the del keyword will delete the dictionary
entirely.

Example:

info = {'name':'Karan', 'age':19, 'eligible':True, 'DOB':2003}

del info
print(info)

Output:

NameError: name 'info' is not defined

Python - else in Loop

As you have learned before, the else clause is used along with the if
statement.

Python allows the else keyword to be used with the for and while loops
too. The else block appears after the body of the loop. The statements in
the else block will be executed after all iterations are completed. The
program exits the loop only after the else block is executed.

Syntax

for counter in sequence:

 #Statements inside for loop block
else:
#Statements inside else block

Example:

for x in range(5):
print ("iteration no {} in for loop".format(x+1))
else:
print ("else block in loop")
print ("Out of loop")

Output:

iteration no 1 in for loop

iteration no 2 in for loop
iteration no 3 in for loop
iteration no 4 in for loop
iteration no 5 in for loop
else block in loop
Out of loop

for value in info:

print(value)
i = 0
while i<7:
print(i)
i = i + 1
# if i == 4:
# break

else:
print("Sorry no i")

for x in range(5):
print ("iteration no {} in for loop".format(x+1))
else:
print ("else block in loop")
print ("Out of loop")
Exception Handling
Exception handling is the process of responding to unwanted or
unexpected events when a computer program runs. Exception handling
deals with these events to avoid the program or system crashing, and
without this process, exceptions would disrupt the normal operation of a
program.

Exceptions in Python

Python has many built-in exceptions that are raised when your program
encounters an error (something in the program goes wrong).

When these exceptions occur, the Python interpreter stops the current
process and passes it to the calling process until it is handled. If not
handled, the program will crash.

Python try...except
try….. except blocks are used in python to handle errors and exceptions.
The code in try block runs when there is no error. If the try block catches
the error, then the except block is executed.

Syntax:

try:
#statements which could generate
#exception
except:
#Soloution of generated exception

Example:

try:
num = int(input("Enter an integer: "))
except ValueError:
print("Number entered is not an integer.")

Output:

Enter an integer: 6.022

Number entered is not an integer.
EXAMPLE DESCRIBED IN VIDEO
#------------lecture 36---------------
# a = input("Enter the number: ")
# print(f"Multiplication table of {a} is: ")
# try:
# for i in range(1, 11):
# print(f"{int(a)} X {i} = {int(a)*i}")
# except:
# print("Invalid Input!")

# print("Some imp lines of code")

# print("End of program")

try:
num = int(input("Enter an integer: "))
a = [6, 3]
print(a[num])
except ValueError:
print("Number entered is not an integer.")

except IndexError:
print("Index Error")
Finally Clause
The finally code block is also a part of exception handling. When we
handle exception using the try and except block, we can include a finally
block at the end. The finally block is always executed, so it is generally
used for doing the concluding tasks like closing file resources or closing
database connection or may be ending the program execution with a
delightful message.

Syntax:

try:
#statements which could generate
#exception
except:
#solution of generated exception
finally:
#block of code which is going to
#execute in any situation
The finally block is executed irrespective of the outcome of try……
except…..else blocks
One of the important use cases of finally block is in a function which
returns a value.

Example:

try:
num = int(input("Enter an integer: "))
except ValueError:
 print("Number entered is not an integer.")
else:
print("Integer Accepted.")
finally:
print("This block is always executed.")

Output 1:

Enter an integer: 19
Integer Accepted.
This block is always executed.

Output 2:

Enter an integer: 3.142

Number entered is not an integer.
This block is always executed.
EXAMPLE DESCRIBED IN VIDEO
--------------lecture 37-------------
def func1():
try:
l = [1, 5, 6, 7]
i = int(input("Enter the index: "))
print(l[i])
return 1
except:
print("Some error occurred")
return 0

finally:
print("I am always executed")
# print("I am always executed")

x = func1()
print(x)
Raising Custom errors
In python, we can raise custom errors by using the raise keyword.
salary = int(input("Enter salary amount: "))
if not 2000 < salary < 5000:
raise ValueError("Not a valid salary")
In the previous tutorial, we learned about different built-in exceptions in
Python and why it is important to handle exceptions. However,
sometimes we may need to create our own custom exceptions that serve
our purpose.

Defining Custom Exceptions

In Python, we can define custom exceptions by creating a new class that
is derived from the built-in Exception class.

Here's the syntax to define custom exceptions:

class CustomError(Exception):
# code ...
pass
try:
# code ...
except CustomError:
# code...
This is useful because sometimes we might want to do something when a
particular exception is raised. For example, sending an error report to the
admin, calling an api, etc.

EAMPLE DESCRIBED IN VIDEO

a = int(input("Enter any value between 5 and 9"))
if(a<5 or a>9):
raise ValueError("Value should be between 5 and 9")
note: simple like if else

If ... Else in One Line

There is also a shorthand syntax for the if-else statement that can be
used when the condition being tested is simple and the code blocks to be
executed are short. Here's an example:
a = 2
b = 330
print("A") if a > b else print("B")
You can also have multiple else statements on the same line:

Example

One line if else statement, with 3 conditions:

a = 330
b = 330
print("A") if a > b else print("=") if a == b else print("B")

Another Example

result = value_if_true if condition else value_if_false

This syntax is equivalent to the following if-else statement:
if condition:
result = value_if_true
else:
result = value_if_false

Conclusion

The shorthand syntax can be a convenient way to write simple if-else

statements, especially when you want to assign a value to a variable
based on a condition.
However, it's not suitable for more complex situations where you need to
execute multiple statements or perform more complex logic. In those
cases, it's best to use the full if-else syntax.
EXAMPLE PROGRM DESCRIBED IN VIDEO
a = 330000
b = 3303
print("A") if a > b else print("=") if a == b else print("B")

c = 9 if a>b else 0
print(c)
Enumerate function in python
The enumerate function is a built-in function in Python that allows you to
loop over a sequence (such as a list, tuple, or string) and get the index
and value of each element in the sequence at the same time. Here's a
basic example of how it works:
# Loop over a list and print the index and value of each
element
fruits = ['apple', 'banana', 'mango']
for index, fruit in enumerate(fruits):
print(index, fruit)
The output of this code will be:
0 apple
1 banana
2 mango
As you can see, the enumerate function returns a tuple containing the
index and value of each element in the sequence. You can use the for
loop to unpack these tuples and assign them to variables, as shown in the
example above.

Changing the start index

By default, the enumerate function starts the index at 0, but you can
specify a different starting index by passing it as an argument to the
enumerate function:
# Loop over a list and print the index (starting at 1) and
value of each element
fruits = ['apple', 'banana', 'mango']
for index, fruit in enumerate(fruits, start=1):
print(index, fruit)
This will output:
1 apple
2 banana
3 mango
The enumerate function is often used when you need to loop over a
sequence and perform some action with both the index and value of each
element. For example, you might use it to loop over a list of strings and
print the index and value of each string in a formatted way:
fruits = ['apple', 'banana', 'mango']
for index, fruit in enumerate(fruits):
print(f'{index+1}: {fruit}')
This will output:
1: apple
2: banana
3: mango
In addition to lists, you can use the enumerate function with any other
sequence type in Python, such as tuples and strings. Here's an example
with a tuple:
# Loop over a tuple and print the index and value of each
element
colors = ('red', 'green', 'blue')
for index, color in enumerate(colors):
print(index, color)
And here's an example with a string:
# Loop over a string and print the index and value of each
character
s = 'hello'
for index, c in enumerate(s):
print(index, c)
EXAMPLE PROGRAM DESCRIBED IN VIDEO
#---------42 lecture-------
marks = [12, 56, 32, 98, 12, 45, 1, 4]

# index = 0
# for mark in marks:
# print(mark)
# if(index == 3):
# print("Harry, awesome!")
# index +=1

for index, mark in enumerate(marks, start=1):

print(mark)
if(index == 3):
print("Harry, awesome!")

What is a Virtual Environment?

A virtual environment (often called venv) in Python is an isolated workspace

that lets you install and manage packages (like numpy, pandas, flask, etc.)
without affecting other projects or your system Python.

Think of it as a private sandbox for each project.

⚙️Why Use a Virtual Environment?

✅ Avoid version conflicts between projects
✅ Keep dependencies separate
✅ Make deployment easier
✅ Prevent breaking system Python installation

Example:

 Project A uses Django 3.2

 Project B uses Django 5.0
→ Both can coexist safely using separate virtual environments.
🪜 How to Create and Use a Virtual Environment
Step 1: Check Python Version
python --version

(Should be 3.6 or higher)

Step 2: Create a Virtual Environment

In your project folder, run:

python -m venv myenv

Here, myenv is the name of your environment folder (you can choose any name).

Step 3: Activate the Environment

 Windows (CMD or PowerShell):

 myenv\Scripts\activate
 macOS / Linux:
 source myenv/bin/activate

After activation, you’ll see (myenv) appear before your command prompt — meaning you’re
inside the virtual environment.

Step 4: Install Packages

Now you can install libraries inside this environment only:

pip install numpy pandas flask

Check installed packages:

pip list

Step 5: Deactivate

When you’re done, simply run:

deactivate

You’ll return to the system’s global Python environment.

Step 6: Delete Virtual Environment (if needed)

Just delete the folder:

rm -rf myenv

or on Windows:
rmdir /s /q myenv

💡 Tip: Save and Reuse Dependencies

If you want to share your project with others:
pip freeze > [Link]

Then, in another system, they can run:

pip install -r [Link]
How importing in python works
Importing in Python is the process of loading code from a Python module into the
current script. This allows you to use the functions and variables defined in the
module in your current script, as well as any additional modules that the imported
module may depend on.

To import a module in Python, you use the import statement followed by the name of
the module. For example, to import the math module, which contains a variety of
mathematical functions, you would use the following statement:

import math
Once a module is imported, you can use any of the functions and variables defined in
the module by using the dot notation. For example, to use the sqrt function from the
math module, you would write:

import math
result = [Link](9)
print(result) # Output: 3.0

from keyword
You can also import specific functions or variables from a module using the from
keyword. For example, to import only the sqrt function from the math module, you
would write:

from math import sqrt

result = sqrt(9)
print(result) # Output: 3.0
You can also import multiple functions or variables at once by separating them with a
comma:

from math import sqrt, pi

result = sqrt(9)
print(result) # Output: 3.0
print(pi) # Output: 3.141592653589793

importing everything
It's also possible to import all functions and variables from a module using the *
wildcard. However, this is generally not recommended as it can lead to confusion and
make it harder to understand where specific functions and variables are coming from.

from math import *

result = sqrt(9)
print(result) # Output: 3.0
print(pi) # Output: 3.141592653589793
Python also allows you to rename imported modules using the as keyword. This can
be useful if you want to use a shorter or more descriptive name for a module, or if you
want to avoid naming conflicts with other modules or variables in your code.

The "as" keyword

import math as m
result = [Link](9)
print(result) # Output: 3.0
print([Link]) # Output: 3.141592653589793

The dir function

Finally, Python has a built-in function called dir that you can use to view the names of
all the functions and variables defined in a module. This can be helpful for exploring
and understanding the contents of a new module.

import math
print(dir(math))
This will output a list of all the names defined in the math module, including functions
like sqrt and pi, as well as other variables and constants.

In summary, the import statement in Python allows you to access the functions and
variables defined in a module from within your current script. You can import the
entire module, specific functions or variables, or use the * wildcard to import
everything. You can also use the as keyword to rename a module, and the dir function
to view the contents of a module.

Example described in video

# from math import sqrt, pi
# from math import pi, sqrt as s
# import math as math_builtin_python

# result = math_builtin_python.sqrt(9) * math_builtin_python.pi

# print(result) # Output: 3.0

# from harry import welcome, harry

import harry as hr
import math

print(dir(math))
print([Link], type([Link]))
[Link]()
print([Link])

Excellent, Ishrath 👏 — this is one of the most important concepts in Python:

the if __name__ == "__main__": idiom.

Let’s go step by step — crystal clear and easy. 🧠👇

🧩 What is if __name__ == "__main__": ?

This line is used to tell Python whether a file is being run directly or imported into another file.

It looks like this:

if __name__ == "__main__":
# code to run only when the file is executed directly

⚙️How It Works
Every Python file has a special built-in variable called __name__.

1️⃣ When you run the file directly:

python [Link]

Then:

__name__ == "__main__"

✅ So, the code inside this block runs.

2️⃣ When you import the file into another script:

import myfile

Then:
__name__ == "myfile"

🚫 So, the code inside if __name__ == "__main__": will not run.

🔍 Example
📄 [Link]

def greet():
print("Hello from mymodule!")

print("This will always run.")

if __name__ == "__main__":
print("This runs only when executed directly.")

📄 [Link]

import mymodule

🧪 Case 1: Run [Link] directly

python [Link]

Output:

This will always run.

This runs only when executed directly.

🧪 Case 2: Run [Link]

python [Link]

Output:

This will always run.

✅ Notice that the second print statement didn’t run — because mymodule was imported, not executed
directly.

💡 Why We Use It
✅ To separate code that should run when the file is executed
from code that should only define functions/classes for import.

It’s mainly used in:

 Reusable modules and libraries

 Testing or demo code sections
 Entry points of large programs
🧠 Real-Life Example
📄 [Link]

def add(a, b):

return a + b

def sub(a, b):

return a - b

if __name__ == "__main__":
print(add(5, 3))
print(sub(5, 3))

📄 [Link]

import calculator

print([Link](10, 20))

✅ When you run [Link], it only prints 30, not the demo code in [Link].

🧩 What is the os Module?

The os module in Python provides functions to interact with your operating system (Windows, Linux,
macOS) — such as working with files, directories, environment variables, and more.

Before using it:

import os

⚙️1. Getting Basic Information

🧠 Current Working Directory
import os
print([Link]())

➡️Returns the current working directory (the folder where your Python script is running).

📁 Change Directory
[Link]("C:\\Users\\Ishrath\\Documents")
print([Link]())

➡️Changes your working directory.

📋 List Files and Folders

print([Link]())

➡️Lists all files and directories in the current folder.

Or specify a path:

print([Link]("C:\\"))

2. Creating and Deleting Directories

🆕 Create Folder
[Link]("new_folder")

🧱 Create Nested Folders

[Link]("parent/child/grandchild")

Remove Folder
[Link]("new_folder")

Remove Nested Folders

[Link]("parent/child/grandchild")

📂 3. Working with Files and Paths

🔎 Check if Path Exists
print([Link]("[Link]"))

📄 Join Paths
path = [Link]("C:\\Users", "Ishrath", "Desktop")
print(path)

📁 Split Path
print([Link]("C:\\Users\\Ishrath\\Desktop\\[Link]"))
# → ('C:\\Users\\Ishrath\\Desktop', '[Link]')

📑 Get File Extension

print([Link]("[Link]"))
# → ('data', '.csv')

🧱 4. Environment Variables
🌍 Get Environment Variables
print([Link])
📦 Access Specific Variable
print([Link]('PATH'))

🔧 5. Run System Commands

You can run terminal/command prompt commands directly:

[Link]("dir") # Windows
[Link]("ls") # Linux/Mac

🧠 6. Useful Utilities
Rename File
[Link]("[Link]", "[Link]")

Remove File
[Link]("[Link]")

Get Absolute Path

print([Link]("[Link]"))

⚡ Summary Table
Function Description
[Link]() Get current directory
[Link](path) Change directory
[Link](path) List files/folders
[Link](name) Create folder
[Link](path) Create nested folders
[Link](file) Delete file
[Link](folder) Delete empty folder
[Link](path) Check if file/folder exists
[Link](a, b) Join two paths safely
[Link] Access environment variables
[Link](cmd) Run system command

🔍 Example Program
import os

# 1. Show current directory

print("Current directory:", [Link]())

# 2. Create a new folder

[Link]("test_folder")
# 3. List contents
print("After creation:", [Link]())

# 4. Rename folder
[Link]("test_folder", "renamed_folder")

# 5. Remove folder
[Link]("renamed_folder")

print("Final contents:", [Link]())

EXAMPLES
import os

for i in range(0, 100):

[Link](f"data/Tutorial{i+1}", f"data/Tutorial {i+1}")

import os

if(not [Link]("data")):
[Link]("data")

for i in range(0, 100):

[Link](f"data/Day{i+1}")

useful video link

"embedUrl": "[Link]

🧩 What Are Variables?

A variable is simply a name that stores data.
But where that variable is created (inside or outside a function) decides its scope — i.e.,
where it can be accessed.

🌍 Global Variables
 Declared outside any function.
 Can be accessed anywhere in the program (inside or outside functions).

Example:
x = 10 # global variable

def show():
print("Inside function:", x)

show()
print("Outside function:", x)
Output:
Inside function: 10
Outside function: 10

✅ x is global, so it’s accessible both inside and outside the function.

🏠 Local Variables
 Declared inside a function.
 Can only be accessed inside that function — not outside.

Example:
def func():
y = 5 # local variable
print("Inside function:", y)

func()
print("Outside function:", y) # ❌ Error: y is not defined

Output:
Inside function: 5
NameError: name 'y' is not defined

⚡ When Local and Global Have the Same Name

If a local variable has the same name as a global variable, the local one shadows (overrides)
the global variable inside that function.

Example:
x = 100

def func():
x = 50
print("Inside function:", x)

func()
print("Outside function:", x)

Output:
Inside function: 50
Outside function: 100

✅ Local variable x = 50 didn’t affect global x = 100.

🧠 Using global Keyword
If you want to modify a global variable inside a function, you must declare it using the
global keyword.

Example:
x = 10

def func():
global x
x = 20 # modifies global x
print("Inside function:", x)

func()
print("Outside function:", x)

Output:
Inside function: 20
Outside function: 20

✅ Because of global x, the change inside the function affected the global variable.

🧱 Example Combining Both

x = 5 # global variable

def outer():
x = 10 # local to outer
def inner():
nonlocal x # refers to x in outer function, not global
x = 15
print("Inner:", x)
inner()
print("Outer:", x)

outer()
print("Global:", x)

Output:
Inner: 15
Outer: 15
Global: 5

Here, nonlocal lets you modify the variable from an enclosing function, not the global one.

📋 Summary Table
 Type Declared In Accessible In Can Modify Global?
Global Outside any function Everywhere ✅ With global
Local Inside a function Inside that function only ❌ No
Nonlocal Inside nested functions In enclosing (outer) function ✅ With nonlocal

🔎 Quick Example Recap

a = 1 # global

def test():
a = 2 # local
print("Inside:", a)

test()
print("Outside:", a)

Output:
Inside: 2
Outside: 1

Example described in video

def my_function():
global x
x = 5 # this will change the value of the global variable x
y = 5 # local variable

my_function()
print(x) # prints 5
# print(y) # this will cause an error because y is a local variable and is not
accessible outside of the function