This document is a course report on a MOOC focusing on programming, data structures, and algorithms in Python, submitted by Rohan Sharma. It outlines the weekly curriculum covering topics from basic Python syntax to advanced techniques like dynamic programming and data structures. The report includes lecture topics, programming concepts, and a summary of Python's features and applications.

1. A MOOC Course Report
on
PROGRAMMING,
DATA STRUCTURES AND
ALGORITHMS IN PYTHON
Submitted by
Rohan Sharma [RA2011003030052]
under the guidance of
Mr. Lalit Sagar
Under the governing ( NPTEL /COURSEERA/SEMINAR/ INDUSTRIAL TRAINING) body
of
BACHELOR OF TECHNOLOGY
in
COMPUTER SCIENCE & ENGINEERING
of
FACULTY OF ENGINEERING AND TECHNOLOGY
SRM INSTITUTE OF SCIENCE & TECHNOLOGY,NCR CAMPUS
NOV 2022

2. Certificate
●Add the image of the certificate

3. Outline
●Week 1: Introduction
●Week 2: Basics of Python
●Week 3: Lists, Inductive functions definitions, Sorting
●Week 4: Sorting ,Tuples,Dictionaries, Passing functions
●Week 5: Exception handling,Input/Output,file handling,string
●Week 6: Backtracing, Scope,Data structures,stacks ,queues ,heap
●Week 7: Classes,Objects and user defined datatypes
●Week 8: dynamic programming

4. Week1
●Lecture 1: Algorithms and Programming : Simple gcd
●Lecture 2: Improving naive gcd
●Lecture 3:Euclid’s algorithm for gcd
●Lecture 4: Downloading and Installing Python

5. Algorithms, programming
● Algorithm: how to systematically perform a task
● Write down as a sequence of steps
● “Recipe”, or program
● Programming language describes the steps
● What is a step? Degrees of detail
● “Arrange the chairs” vs “Make 8 rows with 10
● chairs in each row”

6. Computing gcd(m,n)
●List out factors of m
●List out factors of n
●Report the largest number that appears on both lists
●Is this a valid algorithm?
●Finite presentation of the “recipe”
●Terminates after a finite number of steps

7. Python program
● def gcd(m,n):
● fm = []
● for i in range(1,m+1):
● if (m%i) == 0:
● fm.append(i)
● fn = []
● for j in range(1,n+1):
● If (n%j) == 0:
● fn.append(j)
● cf = []
● for f in fm:
● if f in fn:
● cf.append(f)
● return(cf[-1])

8. Week2
●Lecture 1: Assignment statement, basic types- int ,float,bool
●Lecture 2: Strings
●Lecture 3: Lists
●Lecture 4:Control Flow
●Lecture 5:Functions

9. Assignment statement
●Assign a value to a name
●i = 5
●j = 2*i
●j = j + 5
●Left hand side is a name
●Right hand side is an expression
●Operations in expression depend on type of value

10. int vs float
● Why are these different types?
● Internally, a value is stored as a finite sequence of
● 0’s and 1’s (binary digits, or bits)
● For an int, this sequence is read off as a binary
● number
● For a float, this sequence breaks up into a
● mantissa and exponent
● Like “scientific” notation: 0.602 x 1024

11. Strings —type str
●Text values — type str, sequence of characters
●Single character is string of length 1
●Extract individual characters by position
●Slices extract substrings
●+ glues strings together
●Cannot update strings directly — immutable

12. Lists
●Lists are sequences of values
●Values need not be of uniform type
●Lists may be nested
●Can access value at a position, or a slice
●Lists are mutable, can update in place
●Assignment does not copy the value
●Use full slice to make a copy of a list

13. Control flow
●Normally, statements are executed top to bottom,
●in sequence
●Can alter the control flow
●if ... elif ... else — conditional execution
●for i in ... — repeat a fixed number of times
●while ... — repeat based on a condition

14. Week3
●Lecture 1: More about range()
●Lecture 2: Manipulating lists
●Lecture 3: Breaking out of a loop
●Lecture 4: Arrays vs lists, binary search
●Lecture 5: Efficiency
●Lecture 6: Selection Sort
●Lecture 7: Insertion Sort
●Lecture 8: Recursion

15. More about range()
●range(n) has is implicitly from 0 to n-1
●range(i,j,k) produces sequence in steps of k
●Negative k counts down
●Sequence produced by range() is not a list
●Use list(range(..)) to get a list

16. Lists
●To extend lists in place, use l.append(),
●l.extend()
●Can also assign new value, in place, to a slice
●Many built in functions for lists — see
●documentation
●Don’t forget to assign a value to a name before it
●is first used

17. Loops revisited
●Can exit prematurely from loop using break
●Applies to both for and while
●Loop also has an else: clause
●Special action for normal termination

18. ●Are built in lists in Python lists or arrays?
●Documentation suggests they are lists
●Allow efficient expansion, contraction
●However, positional indexing allows us to treat
●them as arrays
●In this course, we will “pretend” they are arrays
●Will later see explicit implementation of lists

19. Efficiency
●Theoretically T(n) = O(nk) is considered efficient
●Polynomial time
●In practice even T(n) = O(n2) has very limited
●effective range
●Inputs larger than size 5000 take very long

20. Sorting
●Finding minimum in unsorted segment of length k
●requires one scan, k steps
●In each iteration, segment to be scanned reduces
●by 1
●T(n) = n + (n-1) + (n-2) + ... + 1 = n(n+1)/2 = O(n2)

21. Insertion Sort
●Inserting a new value in sorted segment of length
●k requires upto k steps in the worst case
●In each iteration, sorted segment in which to insert
●increased by 1
●T(n) = 1 + 2 + ... + n-1 = n(n-1)/2 = O(n2)

22. O(n2) sorting algorithms
●Selection sort and insertion sort are both O(n2)
●O(n2) sorting is infeasible for n over 5000
●Among O(n2) sorts, insertion sort is usually better
●than selection sort
●What happens when we apply insertion sort to
●an already sorted list?
●Next week, some more efficient sorting algorithms

23. Week4
●Lecture 1: Merge Sort
●Lecture 2: Mergesort , analysis
●Lecture 3: Quicksort
●Lecture 4: Quicksort analysis
●Lecture 5: Tuples and Dictionaries
●Lecture 6: Functions Definitions
●Lecture 7: List Comprehension

24. Merge Sort
● def mergesort(A,left,right):
● # Sort the slice A[left:right]
● if right - left <= 1: # Base case
● return(A[left:right])
● if right - left > 1: # Recursive call
● mid = (left+right)//2
● L = mergesort(A,left,mid)
● R = mergesort(A,mid,right)
● return(merge(L,R))

25. Quicksort
●Quicksort, as described, is not stable
●Swap operation during partitioning disturbs
●original order
●Merge sort is stable if we merge carefully
●Do not allow elements from right to overtake
●elements from left
●Favour left list when breaking ties

26. Tuples and Dictionaries
● Dictionaries allow a flexible association of values to
● keys
● Keys must be immutable values
● Structure of dictionary is internally optimized for key-
● based lookup
● Use sorted(d.keys()) to retrieve keys in
● predictable order
● Extremely useful for manipulating information from
● text files, tables ... — use column headings as keys

27. Function definitions
●Function definitions behave like other assignments
●of values to names
●Can reassign a new definition, define conditionally
●Can pass function names to other functions

28. Week5
●Lecture 1: Exception Handling
●Lecture 2: Standard input and output
●Lecture 3: Handling files
●Lecture 4: String Functions
●Lecture 5: Formatting printed output
●Lecture 6: pass, del() and None

29. Exception handling
●Exception handling allows us to gracefully deal
●with run time errors
●Can check type of error and take appropriate
●action based on type
●Can change coding style to exploit exception
●handling
●When dealing with files and input/output,
●exception handling becomes very important

30. ● Read from keyboard using input()
● Can also display a message
● Print to screen using print()
● Caveat: In Python 2, () is optional for print
● Can control format of print() output
● Optional arguments end="...", sep="..."
● More precise control later

31. ●Use pass for an empty block
●Use del() to remove elements from a list or
●dictionary
●Use the special value None to check if a name has
●been assigned a valid value

32. Week6
●Lecture 1: Backtracking, N queens
●Lecture 2: Global scope , nested function
●Lecture 3: Generating permutations
●Lecture 4: Sets , Stacks , queues
●Lecture 5: Priority queues and heaps

33. ●Python names are looked up inside-out from
●within functions
●Updating a name with immutable value creates a
●local copy of that name
●Can update global names with mutable values
●Use global definition to update immutable values
●Can nest helper function — hidden to the outside

34. Data structures
●Data structures are ways of organising information
●that allow efficient processing in certain contexts
●Python has a built-in implementation of sets
●Stacks are useful to keep track of recursive
●computations
●Queues are useful for breadth-first exploration

35. ● Heaps are a tree implementation of priority queues
● insert( ) and delete_max( ) are both O(log N)
● heapify( ) builds a heap in O(N)
● Tree can be manipulated easily using an array
● Can invert the heap condition
● Each node is smaller than its children
● Min-heap, for insert( ), delete_min( )

36. Week7
●Lecture 1: Abstract datatypes,classes and objects
●Lecture 2: Classes and Objects in Python
●Lecture 3: User defined lists
●Lecture 4: Search trees

37. Abstract datatype
●An abstract data type is a black box description
●Public interface — update/query the data type
●Private implementation — change does not
●affect functionality
●Classes and objects can be used for this

38. Classes and objects
●Class
● Template for a data type
● How data is stored
● How public functions manipulate data
●Object
● Concrete instance of template

39. Complexity
●All operations on search trees walk down a single
●path
●Worst-case: height of the tree
●Balanced trees: height is O(log n) for n nodes
●Tree can be balanced using rotations — look up
●AVL trees

40. Week8
●Lecture 1: Memoization and dynamic programming
●Lecture 2:Grid paths
●Lecture 3: longest common subsequence
●Lecture 4: matrix multiplication
●Lecture 5: Wrap-Up

41. Dynamic programming
● Memoization
● Store values of subproblems in a table
● Look up the table before making a recursive call
● Dynamic programming:
● Solve subproblems in order of dependency
● Dependencies must be acyclic
● Iterative evaluation

42. Wrap-Up
●No programming language is “universally” the best
●Otherwise why are there so many?
●Python’s simplicity makes it attractive to learn
●But also results in some limitations
●Use the language that suits your task best
●Learn programming, not programming languages!