Questions.py

Author: PTHARRISH

Notes/Basic/1.print_statement.py renamed to Notes/1.Basic/1.print_statement.py

@@ -1,10 +1,10 @@
 # Data types
-# Data types are the classification or categorization of data items. 
+# Data types are the classification or categorization of data items.
 # It represents the kind of value that tells what operations can be performed on a particular data.
 # In programming, data type is an important concept.
 
 # Variables can store data of different types, and different types can do different things.
-# Since everything is an object in Python programming, data types are classes and variables 
+# Since everything is an object in Python programming, data types are classes and variables
 # are instances (objects) of these classes.
 
 
@@ -23,45 +23,45 @@
 
 # Getting the Data Type
 # What is Python type()  Function?
-# To define the values ​​of various data types and check their data types we use the type() function. 
+# To define the values ​​of various data types and check their data types we use the type() function.
 # Consider the following examples.
 
-# This code assigns variable ‘x’ different values of various data types in Python. 
-# It covers string, integer, float, complex, list, tuple, range, dictionary, set, 
-# frozenset, boolean, bytes, bytearray, memoryview, and the special value ‘None’ successively. 
-# Each assignment replaces the previous value, making ‘x’ take on the data type and value 
+# This code assigns variable ‘x’ different values of various data types in Python.
+# It covers string, integer, float, complex, list, tuple, range, dictionary, set,
+# frozenset, boolean, bytes, bytearray, memoryview, and the special value ‘None’ successively.
+# Each assignment replaces the previous value, making ‘x’ take on the data type and value
 # of the most recent assignment.
 
 x = "Hello World"
-print(x,"-",type(x))
+print(x, "-", type(x))
 x = 16
-print(x,"-",type(x))
+print(x, "-", type(x))
 x = 0.5
-print(x,"-",type(x))
-x = 3+5j
-print(x,"-",type(x))
+print(x, "-", type(x))
+x = 3 + 5j
+print(x, "-", type(x))
 x = ["Unknown", "Coder"]
-print(x,"-",type(x)) 
-x = ("Code","Hacker")
-print(x,"-",type(x)) 
-x = range(10) 
-print(x,"-",type(x)) 
-x = {"name": "harrish", "age": 23,"Qualification":"MCA"}
-print(x,"-",type(x)) 
+print(x, "-", type(x))
+x = ("Code", "Hacker")
+print(x, "-", type(x))
+x = range(10)
+print(x, "-", type(x))
+x = {"name": "harrish", "age": 23, "Qualification": "MCA"}
+print(x, "-", type(x))
 x = {"harrish", "23", "MCA"}
-print(x,"-",type(x)) 
+print(x, "-", type(x))
 x = frozenset({"harrish", "23", "MCA"})
-print(x,"-",type(x)) 
+print(x, "-", type(x))
 x = True
-print(x,"-",type(x))
+print(x, "-", type(x))
 x = b"Harrish"
-print(x,"-",type(x))
+print(x, "-", type(x))
 x = bytearray(4)
-print(x,"-",type(x)) 
-x = memoryview(bytes(6)) 
-print(x,"-",type(x))
+print(x, "-", type(x))
+x = memoryview(bytes(6))
+print(x, "-", type(x))
 x = None
-print(x,"-",type(x))
+print(x, "-", type(x))
 
 # Hello World - <class 'str'>
 # 16 - <class 'int'>
@@ -83,10 +83,9 @@
 # Python Numeric Data type:
 # In Python, numeric data type is used to hold numeric values.
 
-# Integers, floating-point numbers and complex numbers fall under Python numbers category. 
+# Integers, floating-point numbers and complex numbers fall under Python numbers category.
 # They are defined as int, float and complex classes in Python.
 
 # int - holds signed integers of non-limited length.
 # float - holds floating decimal points and it's accurate up to 15 decimal places.
 # complex - holds complex numbers.
-

Notes/Basic/2.variables.py renamed to Notes/1.Basic/2.variables.py

@@ -0,0 +1,141 @@
+# What is Programming?
+# Programming is the process of writing instructions that a computer
+# can follow to perform tasks like calculations, data processing, automation, etc.
+
+# Think of it as writing a recipe for a computer.
+
+# Example:
+print("Hello, world!")
+# You’re telling the computer: “Display the text ‘Hello, world!’ on the screen.”
+
+# What is Syntax?
+# Syntax is the set of rules that define how you write code correctly in a programming
+# language.
+
+# Like grammar in English — you can’t write "are you how?" instead of "how are you?"
+
+# Incorrect Syntax (will cause error):
+# print "Hello"
+
+# Correct Syntax:
+print("Hello")
+
+# What is Programming Code?
+# Programming Code (or source code) is the set of instructions you write to build a program.
+# It's what the computer runs.
+
+# Example:
+name = "Alice"
+print("Hello, " + name)
+# This is a program written using Python code.
+
+# What is a Programming Language?
+# A programming language is a way to communicate with a computer using specific keywords, rules, and symbols.
+# Python is one such language—others include JavaScript, C++, Java, etc.
+# Python is known for being:
+# Easy to read
+# Powerful
+# Great for beginners and pros alike
+
+# What is Semantics?
+# Semantics is the meaning behind your code.
+# Syntax is how you write it; semantics is what it means.
+
+# Example:
+print("5" + "10")  # Output: "510"
+
+# Correct syntax, but the semantics might be wrong if you expected addition (you got string concatenation instead).
+
+# What is a Script?
+# A script is a file with programming code (usually .py in Python) that runs line-by-line to perform tasks.
+
+# You can run Python scripts to automate tasks like:
+# Sending emails
+# Renaming files
+# Scraping websites
+
+# Example (saved as hello.py):
+# print("Running a script!")
+
+# What is Automation?
+# Automation means writing code to let the computer do tasks for you without manual effort.
+
+# Example: Rename 1000 files instead of doing it one by one.
+
+# Example:
+
+for i in range(1, 4):
+    with open(f"file{i}.txt", "w") as f:
+        f.write("Created by script")
+
+# What is a Function?
+# A function is a reusable block of code that performs a task.
+
+
+# Example:
+def greet(name):
+    print("Hello", name)
+
+
+greet("John")  # Output: Hello John
+# You define it once and can reuse it anywhere.
+
+# What is a Variable?
+# A variable is a container for storing data (like a label you stick on a value).
+
+# Example:
+age = 25
+name = "Alice"
+# Here, age holds a number, and name holds text.
+
+# What is a Generic Label (Variable Name)?
+# It’s just another way of referring to a variable name.
+# Use clear, meaningful names.
+
+# Example:
+temperature = 98.6
+username = "bob123"
+# Avoid vague labels like x or data1 unless truly generic.
+
+# What is print() in Python?
+# The print() function displays output to the screen (like debugging or showing results).
+
+# Example:
+print("Hello!")
+
+# What is an f-string?
+# f-strings (formatted strings) let you insert variable values directly inside strings using {}.
+
+# Example:
+name = "Alice"
+age = 30
+print(f"My name is {name} and I am {age} years old.")
+# Much cleaner than:
+
+print("My name is " + name + " and I am " + str(age) + " years old.")
+
+# What is Implicit Conversion?
+# Python automatically converts data types when safe.
+
+# Example:
+x = 5  # int
+y = 2.0  # float
+result = x + y
+print(result)  # Output: 7.0 (converted to float automatically)
+
+# What is Explicit Conversion?
+# You manually convert one data type to another using functions like int(), str(), float(), etc.
+
+# Example:
+age = "25"
+age_num = int(age)  # Convert string to integer
+print(age_num + 5)  # Output: 30
+
+# What is an Expression?
+# An expression is a piece of code that produces a value.
+
+# Can be math, function calls, logic, etc.
+
+# Example:
+x = 5 + 3  # Expression: 5 + 3
+print(len("hello"))  # Expression: len("hello")

Notes/Basic/3.keywords.py renamed to Notes/1.Basic/3.keywords.py

@@ -0,0 +1,129 @@
+# Closure :
+# Before seeing what a closure is,
+# we have to first understand what nested functions and non-local variables are.
+
+# What are Python Closures
+
+# A Closure in Python is a function object that remembers values in enclosing scopes even
+# if they are not present in memory.
+
+# It is a record that stores a function together with an environment:
+# a mapping associating each free variable of the function
+# (variables that are used locally but defined in an enclosing scope) with the value
+# or reference to which the name was bound when the closure was created.
+# A closure—unlike a plain function—allows the function to access those captured variables
+# through the closure’s copies of their values or references,
+# even when the function is invoked outside their scope.
+
+
+# example 1: This is not closure
+def outerFunction():
+    text = "hi"
+
+    def innerFunction():
+        print("Inside Function")
+        # text is free variable
+        print(text)
+        # text is free variable  it can be access inside a innerfunction
+
+    # Note we are returning function
+    # WITH parenthesis
+    return innerFunction()  # returning and executing innerfunction
+
+
+outerFunction()
+
+
+# Example 2:
+# Python program to illustrate
+# closures
+def outerFunction():
+    text = "Hey"
+
+    def innerFunction():
+        # text is free variable
+        print(text)
+
+    # Note we are returning function
+    # WITHOUT parenthesis it will not execute nothing
+    return innerFunction
+
+
+myFunction = outerFunction()
+# It will execute everything inside a outerfunction and return innerFunction
+print(myFunction)
+# myFunction is a function now because we only returned not execute the innerfunction
+print(myFunction.__name__)
+# display inner function name on it
+myFunction()  # Hey
+myFunction()  # Hey
+myFunction()  # Hey
+
+# It print out message.
+# we are done with executing outer function.
+# but the inner function has still has access to that text variable that is it printing out.
+# Thats what closure is In simple terms a closure is a inner function that remembers and has
+# access to variable in the local scope in which it was created even after the outer function
+# has finished executing
+
+
+# Example 3: Add parameter to a function
+def outerFunction(msg):
+    message = msg
+
+    def innerFunction():
+        print(message)
+
+    return innerFunction
+
+
+hi_Function = outerFunction("Hi!")
+hello_Function = outerFunction("Hello!")
+hi_Function()  # Hi!
+hello_Function()  # Hello!
+
+# One thing you must notice that we stil innerfunction still doesnot take any argument
+# to execute this function only need paranthesis.
+# when call this each function print is own values
+# that closure closes over the free variable from their environment
+# In this case message would be that free variable.
+
+
+# Example 3:
+
+import logging
+
+logging.basicConfig(filename="example.log", level=logging.INFO)  # create logging file
+
+
+def logger(func):
+    def logfun(*args):
+        # *args= any no of arguments can be passed
+        logging.info('running"{}"with arguments {}'.format(func.__name__, args))
+        # print loggin info in example.log file on it
+        print(func(*args))
+        # call those func name passed in outer function and pass the inner function *args values
+
+    return logfun  # it only return the inner function not executed
+
+
+def add(x, y):
+    return x + y
+
+
+def sub(x, y):
+    return x - y
+
+
+add_log = logger(add)  
+# outer function executes and pass the argument
+sub_log = logger(sub)
+
+add_log(10, 20)
+# inner function still have access to the outer function after execution it remember the inner function
+add_log(3, 3)
+# so it can easy to access the free variabe on it
+
+sub_log(20, 10)
+sub_log(5, 2)
+sub_log(5, 2)