1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
#import "tpl.typ": *
#show: body => apply(body)
#show heading: set text(font: "New Computer Modern Sans", weight: 450)
#let semibold(body) = text(weight: 600, body)
#let roman(body) = text(weight: 400, body)
// #text(size: 1.3em, font: "New Computer Modern Sans", align(center)[#semibold[Practical Assignments] \ _on_ \ #semibold[Programming in Python Lab]])
#text(size: 1.3em, font: "New Computer Modern Sans", align(center)[#semibold[Programming in Python Lab]])
#align(center, text(size: 1.1em)[DSE-B-1 \ Use of user defined functions are encouraged wherever applicable])
#set enum(full: true, numbering: (..args) => {
let patterns = ("1.", "(a)")
let pattern = patterns.at(calc.min(args.pos().len(), patterns.len()) - 1)
numbering(pattern, args.pos().last())
})
#let nntiv = body => [
#set text(size: 0.9em, fill: rgb("#777777"))
\ #body
]
#set raw(lang: "python")
#set par(justify: true)
#set heading(numbering: "1 ")
#heading(numbering: none)[0 #h(0.25em) Definitions]
- _Interactive interpreter_ allows the user to run one or more lines of code interactively, immediately showing the result and output of code.
- _Programs_ are to be written and saved in text files, usually with the file extension `.py`, and run using the Python executable from CLI (Command Prompt or Powershell in Windows, shell in Linux etc.) or the inbuilt IDLE.
= Basic Python Syntax
+ Using the Python _interactive interpreter_ as a basic calculator, demonstrate the order of operations using parentheses for arithmetic operations.
+ Using the Python _interactive interpreter_, demonstrate at least 15 functions in the math module.
#nntiv[For example, to find the GCD of two numbers, area and perimeter of circle using `math.pi` etc.]
+ Using the Python _interactive interpreter_, demonstrate the use of complex numbers and their operations on them.
#nntiv[For example, in finding the modulus and phase angle (amplitude or argument) of a complex number.]
+ Write a Python program to take two numbers from the user and show their the sum, product, difference and the GCD.
+ Write a Python program to demonstrate the use of _regular expressions_ using `re.split`, `re.join`, `re.search` and `re.match` methods from `re` module.
+ Write a program to take two floating point numbers as input from the user. Concatenate the integral parts of the two numbers and display them, also display the sum of the input floating point numbers rounded upto 2 decimal places.
+ Write a program to divide two numbers and check if the digits at one’s place of the quotient and remainder are equal.
= Decision Control Statements
+ Write a Python program to calculate the sum a list of number of (i) even length and then (ii) any length, using `while` loop: at each step, add $k$th number from the start and end of the list and display it, for $k$ from $0$ to half the length the list.
#nntiv[For example: if the list is `[1, 2, 3, 4, 5, 6]`, the program should output `1 + 6`, `2 + 5`, and `3 + 4` in separate lines, and the result of the addition `21`.]
+ Write a Python program to sperate prime numbers from a given list of numbers and store them in another list.
+ Write a Python program to demonstrate keyword argument `key` of `sum()`, `min()`, `max()`, and `sort()` functions using `lambda`s.
+ Write a Python program to design the following random number guessing game. A random number from 1 to 10 (inclusive) is selected as a secret number, then the user is prompted to guess the number. If the user’s guess matches the secret number, the game ends with an appropriate message, otherwise the user is asked to try again. After 3 unsuccessful guesses, the user loses and the game ends with an appropriate message revealing the secret number. At the end of the game, ask the user whether to play again. (Use the `random` module to obtain the secret number.)
+ Write a Python program to generate the calendar of a month given the start day (`1` for Sunday, `2` for Monday, ... `7` is Saturday) and the number of days in the month.
#nntiv[An example:]
#[
#show raw: block.with(inset: 0pt, fill: white, width: 20em, outset: 0pt)
#show: it => align(center, it)
```text
Enter the starting day: 5
Enter the number of days in the month: 30
Calender for this month:
SUN MON TUE WED THU FRI SAT
1 2 3
4 5 6 7 8 9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30
```]
+ Write a Python program to take input from user as a string and count the lowercase characters, uppercase characters and digits in it.
+ #table(
columns: (1fr, 4em), stroke: none,
inset: 0pt, gutter: 0pt,
column-gutter: 5pt,
[Write a Python program to print the following star pattern of the given size. \
#nntiv[Example (with size 4):]],
[
#set par(leading: 0em)
#set block(inset: 0pt, width: 4em, outset: 0pt)
```text
****
* *
* *
****
```
])
= Strings
+ Write a Python program to ask the user for two strings, print a new string where the first string is reversed, and the second string is converted to upper case, only using string slicing and `+` operator.
#nntiv[Sample strings: `Pets`, `party`, output: `steP PARTY`.]
+ Write a Python program to from a list of words, join all the words in the odd and even indices to form two strings using list slicing and `join` method.
#nntiv[Example: for a list `['abc', 'def', 'ghi', 'jkl', 'mno', 'pqrs', 'tuv', 'wxyz']`, the result are: `'abcghimnotuv'` and `'defjklpqrswxyz'`.]
+ #text(fill: red, sym.convolve)
Write a Python program to input your name in a string, separate the first name and last name using the slice operator with negative indexing, and display your name in reverse using a formatted string.
+ Write a Python program to implement a function that works like `str.count()` method.
+ Write a Python program to take input a string and display it after removing all the vowels.
+ Write a Python program that take a plain text string and generate cyphertext by using $k$th next character with wrap around for each character for a given constant key value $k$.
#nntiv[Also known as _Caesar Cipher_. \ Example: for key $k = 23$, the message `"The quick brown fox jumps over the lazy dog."` encrypts to `"Qeb nrfzh yoltk clu grjmp lsbo qeb ixwv ald."`.]
+ Write a Python program to sperate the username and domain name of an email address.
#{ /*
+ Write a Python program to separate the `local-part` and `domain` of an email address given as per RFC 5322 format for `addr-spec` (§3.4.1):
```text
addr-spec = local-part "@" domain
local-part = dot-atom / quoted-string / obs-local-part
domain = dot-atom / domain-literal / obs-domain
dtext = %d33-90 / ; Printable US-ASCII
%d94-126 / ; characters not including
obs-dtext ; "[", "]", or "\"
FWS = ([*WSP CRLF] 1*WSP) / obs-FW
; Folding white space
ctext = %d33-39 / ; Printable US-ASCII
%d42-91 / ; characters not including
%d93-126 / ; "(", ")", or "\"
obs-ctext
ccontent = ctext / quoted-pair / comment
comment = "(" *([FWS] ccontent) [FWS] ")"
CFWS = (1*([FWS] comment) [FWS]) / FWS
atext = ALPHA / DIGIT / ; Printable US-ASCII
"!" / "#" / ; characters not including
"$" / "%" / ; specials. Used for atoms.
"&" / "'" /
"*" / "+" /
"-" / "/" /
"=" / "?" /
"^" / "_" /
"`" / "{" /
"|" / "}" /
"~"
atom = [CFWS] 1*atext [CFWS]
dot-atom-text = 1*atext *("." 1*atext)
dot-atom = [CFWS] dot-atom-text [CFWS]
qtext = %d33 / ; Printable US-ASCII
%d35-91 / ; characters not including
%d93-126 / ; "\" or the quote character
obs-qtext
quoted-pair = ("\" (VCHAR / WSP)) / obs-qp
obs-qp = "\" (%d0 / obs-NO-WS-CTL / LF / CR)
qcontent = qtext / quoted-pair
quoted-string = [CFWS]
DQUOTE *([FWS] qcontent) [FWS] DQUOTE
[CFWS]
word = atom / quoted-string
obs-local-part = word *("." word)
obs-domain = atom *("." atom)
obs-dtext = obs-NO-WS-CTL / quoted-pair
obs-NO-WS-CTL = %d1-8 / ; US-ASCII control
%d11 / ; characters that do not
%d12 / ; include the carriage
%d14-31 / ; return, line feed, and
%d127 ; white space characters
```
*/}
= Lists
+ Write a Python program to simulate a stack and a queue using lists.
#nntiv[Note that the queue deletion operation won’t run in $O(1)$ time.]
+ Write a Python program to find all the odd numbers and numbers divisible by 3 from a list of numbers using list comprehension.
+ Write a Python program to find the second largest number in a list of numbers.
+ Write a Python program to generate a list of numbers `items` using list comprehension as per the following description:
$ "items"[ i ] = cases(
i^2 quad "if " i "is even",
i^3 quad "if " i "is odd",
) $
where $i$ denotes the index of the list.
+ Write a Python program to use the `map()` method to square each number in a list.
+ Write a Python program to remove all duplicate items in a list.
= Tuples
+ Write a Python program that, given sequences of first and last names, generate a tuple of tuples each of which contains the full name of a person, using the `zip()` function.
+ Write a Python program to create and modify tuples in various ways.
+ Write a Python program to take a nested tuple with the name, Roll No. and marks of some students and find the name of the student having highest marks.
+ Write a Python program to take a list of numbers (both positive and negative) and make a new tuple out from this list with only the positive values.
+ Write a Python program to demonstrate the definition and use of a function taking variable length arguments (scatter and gather) using the `*` symbol.
= Sets
+ Write a Python program to remove duplicate items of a list of numbers and duplicate characters in a string using sets.
+ Write a Python program to implement the Jaccard and cosine similarity of two sets using the set union and intersection operations.
+ Write a Python program to show the difference between `set.remove()` and `set.discard()` methods.
+ Write a Python program that creates two sets of even numbers in the range 1 to 10 and composite numbers in the range 1 to 20 to demonstrate the use of `all()`, `issuperset()`, `len()`, `sum()` methods on the sets.
+ Write a Python program that generates a set of prime numbers and another set of odd numbers. Demonstrate the result of union, intersection, difference, symmetric difference operations on these sets.
+ Write a Python program that creates two sets: squares and cubes in the range 1 to 10 to demonstrate the use of `update()`, `pop()`, `remove()`, `add()` and `clear()` methods.
+ Write a Python program to demonstrate the use of frozensets.
= Dictionaries
+ Write a Python program to count the word and letter occurrences in a long string of text using dictionaries.
+ Write a Python program to invert a dictionary such the previous keys become values and values become keys.
#nntiv[For example: if the initial and inverted dictionaries are `d1` and `d2`, where `d1 = {1: 'a', 2: 'b', 3: 120}`, then `d2 = {'a': 1, 2: 'b', 120: 3}`.]
+ What if the values in 2 are not immutable? Use frozensets, For repeated values, use lists. For example: if `d1 = {1: 'a', 2: 'a', 4: [1, 2]}`, then `d2 = {'a': [1, 2], frozenset([1, 2]): 4}`.
+ Write a Python program with a function to generate the Fibonacci numbers in
+ Exponential time using the naïve algorithm.
+ Linear time using dynamic programming (memoization) with a dictionary.
+ Write a Python program to generate a dictionary where each key is a number and the corresponding value is the number’s square using dictionary comprehensions.
+ Write a Python program to store a sparse matrix as a dictionary.
+ Write a Python program that combines lists of keys and values into a dictionary.
= User-Defined Functions
+ Write a Python program to implement quick sort and merge sort algorithms to sort lists of numbers.
+ Write a Python program that displays the Pascal’s triangle of a given size.
+ Three positive integers $a$, $b$, and $c$ are Pythagorean triples if $a^2 + b^2 = c^2$. Write a Python program with a function to generate all Pythagorean triples in a certain range.
+ Write two functions that simulate the toss of a fair coin, and the roll of an unbiased $n$ sided die using the `random` module.
+ Modify the previous assignment. Now the coin and the die are not fair, with each outcome having a given probability.
= File Handling; `sys`, `pickle` and `csv` modules
+ Basic file operations. Explore the different file modes.
+ Emulate the unix `cp`, `grep`, `cat` programs in Python. In each case, the user should pass the arguments to the program as command line arguments.
+ Use pickle for persistent storage of variables.
= Object Oriented Programming
+ Create a `Graph` class to store and manipulate graphs. It should have the following functions:
+ Read an edge list file, where each edge `(u, v)` appears exactly once in the file as space separated values.
+ Add and remove nodes and edges.
+ Print nodes, and edges in a user readable format.
+ Computes basic statistics of the graph like degree distribution, clustering coefficient, and the number of connected components.
+ Finding all the neighbors of a node.
+ Finding all the connected components and storing them as individual Graph objects inside the class.
+ Finding single source shortest paths using Breadth First Search.
+ Make a `DiGraph` class to handle directed graphs which inherits from the `Graph` class. In addition to all of the functionalities of 1, it should support the following operations
+ Finding the predecessors and successors of a node.
+ Creating a new `DiGraph` object where all the edges are reversed.
+ Finding the strongly connected components.
+ Extend 1 and 2 to handle weighted graphs, and implement Dijkstra’s and Floyd-Warshall algorithms to compute the single source and all pairs shortest paths.
+ Use the graph containers in 1, 2, and 3 to implement additional graph algorithms.
|