Scribd
Upload
17 views13 pages

Python Complete Notes

This document provides comprehensive notes on Python, covering its basics, syntax, data types, and core concepts like OOP, file handling, and exception handling. It also includes an overview of data structures and algorithms (DSA) such as arrays, stacks, queues, linked lists, trees, and graphs, along with sorting and searching algorithms. The notes are designed to prepare beginners for exams and interviews in programming and data structures.

Uploaded by

narayananhemathkumar
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
17 views13 pages

Python Complete Notes

This document provides comprehensive notes on Python, covering its basics, syntax, data types, and core concepts like OOP, file handling, and exception handling. It also includes an overview of data structures and algorithms (DSA) such as arrays, stacks, queues, linked lists, trees, and graphs, along with sorting and searching algorithms. The notes are designed to prepare beginners for exams and interviews in programming and data structures.

Uploaded by

narayananhemathkumar
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd

PYTHON COMPLETE NOTES (Beginner → DSA)

1️⃣ What is Python?

Python is a high-level, interpreted, general-purpose programming language.

 Created by Guido van Rossum in 1991

 Famous for readability, simplicity, and versatility

 Used in:

o Web Development (Django, Flask)

o Data Science (Pandas, NumPy, Matplotlib)

o Machine Learning (TensorFlow, PyTorch)

o Automation, Scripting, Software Development

2️⃣ Why Python?

 Easy syntax → beginner-friendly

 Huge standard library → almost everything included

 Interpreted → runs directly without compilation

 Cross-platform → works on Windows, Linux, Mac

3️⃣ Python IDE / Setup

 Install Python 3.x from [Link]

 Use IDEs: PyCharm, VSCode, Jupyter Notebook, Google Colab

4️⃣ First Python Program

print("Hello, Python!")

 print() → outputs text to console


5️⃣ Variables

name = "Lakshmi"

age = 23

salary = 25000.50

is_student = True

 Variables don’t need explicit declaration

 Python is dynamically typed

6️⃣ Data Types

Primitive

 int → integers

 float → decimal numbers

 bool → True / False

 str → string

Collection Types

 list → ordered, mutable

 tuple → ordered, immutable

 set → unordered, unique elements

 dict → key-value pairs

7️⃣ Operators

# Arithmetic

a + b, a - b, a * b, a / b, a % b, a ** b

# Comparison

a > b, a < b, a == b, a != b
# Logical

and, or, not

8️⃣ Conditional Statements

age = 18

if age >= 18:

print("Adult")

else:

print("Minor")

9️⃣ Loops

for loop

for i in range(1, 6):

print(i)

while loop

i=1

while i <= 5:

print(i)

i += 1

🔟 Functions

def add(a, b):

return a + b

print(add(5, 3))
 Functions group reusable code

 return → outputs value

1️⃣1️⃣ Lists

fruits = ["apple", "banana", "cherry"]

[Link]("orange")

print(fruits[1]) # banana

Common Methods

 append(), extend(), insert(), remove(), pop(), sort(), reverse()

1️⃣2️⃣ Tuples

coords = (10, 20)

print(coords[0])

 Immutable → cannot modify elements

1️⃣3️⃣ Sets

nums = {1, 2, 3, 3, 2}

print(nums) # {1, 2, 3}

 No duplicates

 Unordered

1️⃣4️⃣ Dictionaries

student = {"name": "Lakshmi", "age": 23}

print(student["name"])

student["grade"] = "A"
1️⃣5️⃣ Strings

name = "Python"

print([Link]()) # PYTHON

print([Link]()) # python

print(name[0:4]) # Pyth

 Methods: split(), replace(), strip(), find(), join()

1️⃣6️⃣ OOP in Python

Class & Object

class Student:

def __init__(self, name, age):

[Link] = name

[Link] = age

s1 = Student("Lakshmi", 23)

print([Link])

Inheritance

class Person:

def greet(self):

print("Hello!")

class Teacher(Person):

pass

t = Teacher()

[Link]() # Hello!
Polymorphism

 Method overloading (Python uses default args)

 Method overriding possible in subclass

Encapsulation

class Student:

def __init__(self):

self.__age = 23 # private variable

s = Student()

# print(s.__age) # Error

Abstraction

from abc import ABC, abstractmethod

class Shape(ABC):

@abstractmethod

def area(self):

pass

class Square(Shape):

def __init__(self, side):

[Link] = side

def area(self):

return [Link]**2

s = Square(5)

print([Link]()) # 25
1️⃣7️⃣ File Handling

# Write

with open("[Link]", "w") as f:

[Link]("Hello Python")

# Read

with open("[Link]", "r") as f:

print([Link]())

1️⃣8️⃣ Exception Handling

try:

x = 10 / 0

except ZeroDivisionError:

print("Cannot divide by zero")

finally:

print("Done")

1️⃣9️⃣ Modules & Libraries

import math

print([Link](16))

 Common: math, random, datetime, os, sys, pandas, numpy, matplotlib

🚀 DATA STRUCTURES & ALGORITHMS (DSA)

2️⃣0️⃣ Arrays (Lists)


arr = [1,2,3,4,5]

[Link](6)

print(arr[2])

2️⃣1️⃣ Stack (LIFO)

stack = []

[Link](1)

[Link](2)

[Link]() # 2

2️⃣2️⃣ Queue (FIFO)

from collections import deque

queue = deque()

[Link](1)

[Link](2)

[Link]() # 1

2️⃣3️⃣ Linked List (Basic Example)

class Node:

def __init__(self, data):

[Link] = data

[Link] = None

head = Node(10)

[Link] = Node(20)
2️⃣4️⃣ Searching Algorithms

Linear Search

arr = [1,2,3,4,5]

for i in arr:

if i == 3:

print("Found")

Binary Search (Array must be sorted)

def binary_search(arr, target):

low, high = 0, len(arr)-1

while low <= high:

mid = (low + high) // 2

if arr[mid] == target:

return mid

elif arr[mid] < target:

low = mid + 1

else:

high = mid - 1

return -1

arr = [1,2,3,4,5]

print(binary_search(arr, 4)) # 3

2️⃣5️⃣ Sorting Algorithms

Bubble Sort

arr = [5,2,1,4,3]

for i in range(len(arr)):
for j in range(0,len(arr)-i-1):

if arr[j] > arr[j+1]:

arr[j], arr[j+1] = arr[j+1], arr[j]

print(arr)

Selection Sort

arr = [5,2,1,4,3]

for i in range(len(arr)):

min_idx = i

for j in range(i+1, len(arr)):

if arr[j] < arr[min_idx]:

min_idx = j

arr[i], arr[min_idx] = arr[min_idx], arr[i]

print(arr)

Insertion Sort

arr = [5,2,1,4,3]

for i in range(1,len(arr)):

key = arr[i]

j = i-1

while j>=0 and key<arr[j]:

arr[j+1]=arr[j]

j-=1

arr[j+1]=key

print(arr)

2️⃣6️⃣ Recursion

def factorial(n):
if n==0:

return 1

return n * factorial(n-1)

print(factorial(5)) # 120

2️⃣7️⃣ Trees (Binary Tree)

class Node:

def __init__(self, data):

[Link] = data

[Link] = None

[Link] = None

2️⃣8️⃣ Graphs (Adjacency List)

graph = { "A": ["B","C"], "B":["D"], "C":["D"], "D":[] }

2️⃣9️⃣ BFS & DFS

# BFS

from collections import deque

def bfs(graph,start):

visited = []

queue = deque([start])

while queue:

node = [Link]()

if node not in visited:

[Link](node)

[Link](graph[node])
return visited

# DFS

def dfs(graph,start,visited=[]):

[Link](start)

for n in graph[start]:

if n not in visited:

dfs(graph,n,visited)

return visited

3️⃣0️⃣ Dynamic Programming Examples

Fibonacci

def fib(n, memo={}):

if n in memo: return memo[n]

if n<=1: return n

memo[n] = fib(n-1, memo) + fib(n-2, memo)

return memo[n]

print(fib(10)) # 55

Knapsack (0/1)

def knapsack(wt, val, W, n):

if n==0 or W==0:

return 0

if wt[n-1] > W:

return knapsack(wt,val,W,n-1)

else:

return max(val[n-1]+knapsack(wt,val,W-wt[n-1],n-1), knapsack(wt,val,W,n-1))


✅ Notes Summary

 ✅ Python Basics (Syntax, Variables, Data Types)

 ✅ OOP (Classes, Objects, Inheritance, Polymorphism, Encapsulation)

 ✅ Core Python (Files, Exceptions, Libraries)

 ✅ DSA (Arrays, Stack, Queue, Linked List, Trees, Graphs)

 ✅ Sorting & Searching, Recursion, DP

 ✅ Ready for exams & interviews

Common questions

Powered by AI

Python is favored across diverse fields due to its readability and simplicity, thanks to its easy syntax which makes it beginner-friendly . Furthermore, Python boasts a huge standard library, offering a wide range of modules and tools that suit numerous applications without needing additional resources . Its interpreted nature allows running code without prior compilation, facilitating rapid development and testing . Python is also cross-platform, capable of running on various operating systems like Windows, Linux, and Mac, broadening its usability . These characteristics make Python adaptable for web development, data science, machine learning, and more, supported by popular frameworks and libraries such as Django, Flask, Pandas, NumPy, TensorFlow, and PyTorch .

Arrays (lists in Python) offer constant time complexity for accessing elements by index, making them suitable for applications where random access is crucial . However, they can be inefficient in terms of insertion and deletion, which require shifting elements and have a time complexity of O(n). In contrast, linked lists provide dynamic memory allocation, which is efficient for insertion and deletion operations with a time complexity of O(1) when performed at the start of the list. Yet, they suffer from slow element access time due to sequential traversal (O(n)), which makes them less ideal for applications needing frequent access to elements by index . Therefore, the choice between them depends on the specific performance needs of the application .

Dynamic typing in Python enhances flexibility, allowing variable types to be determined at runtime rather than enforcing fixed declarations, which can speed up development and reduce syntactic overhead . It facilitates the reuse and extension of existing code with minimal modification, making Python particularly attractive for prototyping and iterative development processes. However, it can also lead to runtime errors if not properly managed since type-related errors are only caught during execution, which may necessitate robust testing and careful handling to prevent runtime type mismatches .

Recursion in Python is preferred for problems that can be divided into smaller, similar subproblems like computing factorials or performing complex sorting tasks (like quicksort) due to its elegant and straightforward representation . However, recursion can lead to increased space complexity because each function call is added to the call stack, potentially leading to a stack overflow if not carefully managed, which is a crucial pitfall . Additionally, Python's recursion limit might necessitate adjustments for deeply recursive functions, making iteration a better option for very deep recursive problems .

In Python, data encapsulation is achieved through the use of private variables, which are prefixed by double underscores, indicating they should not be accessed directly outside their class . This practice protects the state of an object, preventing external interference and maintaining the integrity of the data by providing controlled access through methods . Encapsulation in Python promotes modularity and code reusability, allowing change implementations without affecting other parts of the program .

Decorators in Python enhance or modify the behavior of functions or methods without altering their structure. They achieve this by taking another function as an argument, extending its behavior, and returning it . This is especially useful for cross-cutting concerns like logging, access control, and instrumentation, as it promotes code reusability and separation of concerns by allowing the original business logic to remain unaffected . Decorators essentially wrap existing functions, adding pre- or post-execution logic seamlessly, which reduces duplication and streamlines the application of additional functionality across similar function types .

Abstraction in Python allows developers to define complex systems with simplified models, focusing on relevant attributes while hiding unnecessary details . This is exemplified through the use of abstract classes with the ABC module, where methods like area() are defined without implementation, enforcing subclasses to provide specific logic . For instance, the 'Shape' abstract class mandates that all derived classes implement the area method, ensuring consistent behavior across all shape types while enabling polymorphic use. This improves code clarity, maintainability, and reusability by promoting a standard interface .

Method overriding in object-oriented programming allows a subclass to provide a specific implementation of a method that is already defined in its superclass. In Python, this is crucial for achieving polymorphism, enabling objects to be treated as instances of their parent class while executing subclass-specific behaviors . This is implemented by defining a method in the child class with the same name as a method in the parent class. For example, if a base 'Person' class has a greet() method, a 'Teacher' subclass can override greet() to customize its behavior while retaining the ability to call the parent class version if needed .

Exception handling in Python significantly enhances the robustness of a program by allowing developers to anticipate and manage unexpected errors during runtime, rather than letting programs crash . Python provides try-except blocks to catch exceptions and execute code even if an error occurs. The finally clause ensures that specific (cleanup) code runs irrespective of an error occurrence, enhancing stability . This structured approach not only aids in debugging but also ensures programs handle erroneous states gracefully, improving user experience and reliability .

A set in Python is an unordered collection of unique elements, which means it does not allow duplicates and its elements are not stored in any particular order . On the other hand, a list is an ordered collection that allows duplicates and retains the order of insertion . Choosing a set impacts a program by ensuring all elements are unique, which is ideal for tasks like membership testing or removing duplicates from iterables, offering average time complexity of O(1) for such operations. In contrast, lists should be used when order matters or when duplicates are required, though they generally have a higher time complexity for membership tests, O(n).

You might also like