CHAPTER 2: PYTHON REVISION TOUR II
STRING
1. Introduction to Strings
Strings in Python are sequences of characters enclosed in single, double, or triple quotes. Strings are
immutable, meaning they cannot be changed after they are created.
# Example of a string
s = "Hello, World!"
2. Traversing a String
Traversing a string means iterating through each character of the string. You can do this using a for loop
or by using indexing.
Example: Traversing using a for loop
s = "Hello"
for char in s:
print(char)
Output:
H
e
l
l
o
Example: Traversing using indexing
s = "Hello"
for i in range(len(s)):
print(s[i])
Output:
H
e
l
l
o
3. String Operators
Operator Description Example Output
+ Concatenation (joins two strings together) "Hello" + " World!" "Hello World!"
* Repetition (repeats the string multiple times) "Hello" * 3 "HelloHelloHello"
in Membership test (checks if substring exists) "World" in "Hello World!" True
Membership test (checks if substring doesn't "Python" not in "Hello
not in True
exist) World!"
4. String Slicing
String slicing allows you to extract a portion of a string. It uses the syntax: string[start:end:step].
Operation Description Example Output
s[start:end] Extract substring from start to end (exclusive) "Hello"[1:4] "ell"
s[:end] Extract from the beginning up to end (exclusive) "Hello"[:3] "Hel"
s[start:] Extract from start to the end "Hello"[2:] "llo"
s[start:end:step] Extract substring with step (skipping elements) "Hello"[::2] "Hlo"
5. String Functions and Methods
Method/Function Description Example Output
len(s) Returns the length of the string len("Hello") 5
Converts all characters in the string to
s.upper() "hello".upper() "HELLO"
uppercase
Converts all characters in the string to
s.lower() "HELLO".lower() "hello"
lowercase
s.capitalize() Capitalizes the first letter of the string "hello".capitalize() "Hello"
s.strip() Removes leading and trailing spaces " Hello ".strip() "Hello"
s.replace(old, Replaces occurrences of old with new "Hello World".replace("World", "Hello
new) in the string "Python") Python"
Splits the string at each occurrence of ['Hello',
s.split(delim) "Hello,World".split(",")
the delimiter delim 'World']
Returns the index of the first
s.find(sub) "Hello".find("l") 2
occurrence of sub, or -1 if not found
Joins all elements of the iterable with "Hello
s.join(iterable) " ".join(['Hello', 'World'])
the string as a separator World"
Returns True if the string contains
s.isdigit() "1234".isdigit() True
only digits
Returns True if the string contains
s.isalpha() "hello".isalpha() True
only alphabetic characters
Method/Function Description Example Output
Counts how many times sub occurs in
s.count(sub) "hello".count("l") 2
the string
Example Usage:
s = " Hello, World! "
# Strip spaces
print(s.strip()) # Output: "Hello, World!"
# Replace part of the string
print(s.replace("World", "Python")) # Output: " Hello, Python! "
# Split string into list
print(s.split(", ")) # Output: ['Hello', 'World!']
LIST
1. Characteristics of List
1. A list is a collection of items (elements) which are ordered and changeable.
2. Lists are mutable, meaning their contents can be changed after creation.
3. Lists can contain elements of different data types: integers, strings, floats, even other lists.
4. Lists are indexed, with the first element at index 0.
5. Defined using square brackets [].
Example:
my_list = [10, "Hello", 3.14, True]
2. Creation of List
You can create a list in various ways: #
Empty list
list1 = []
# List of integers list2
= [1, 2, 3, 4]
# Mixed data types
list3 = [1, "apple", 3.5, False]
# Nested list
list4 = [1, [2, 3], 4]
3. List Operations
Basic operations you can perform on lists:
Operation Example Result / Description
Concatenation [1, 2] + [3, 4] [1, 2, 3, 4]
Repetition [0] * 3 [0, 0, 0]
Membership 3 in [1, 2, 3] TRUE
Length len([1, 2, 3]) 3
Deletion del mylist[0] Deletes the 1st element
4. List Indexing
Accessing elements using their index (starting from 0):
List Indexing:
fruits = ["apple", "banana", "cherry"]
print(fruits[0]) # apple
print(fruits[-1]) # cherry (negative
indexing)
5. List Slicing
Extracting a part (sublist) from a list:
List Slicing:
numbers = [10, 20, 30, 40, 50]
print(numbers[1:4]) # [20, 30, 40]
print(numbers[:3]) # [10, 20, 30]
print(numbers[::2]) # [10, 30, 50]
6. Functions of List
Some commonly used list functions:
Function Description Example
len() Returns number of elements len([1,2,3]) → 3
max() Returns maximum element max([3,5,1]) → 5
min() Returns minimum element min([3,5,1]) → 1
sum() Returns sum of numeric list sum([1,2,3]) → 6
list() Converts another type (like string) into a list list("abc") → ['a', 'b', 'c']
7. List Methods
Common methods to manipulate lists:
List Methods in Python – With Explanation & Examples:
Method Explanation Example Output
append(x) Adds item x to the end of the list a = [1, 2] [1, 2, 3]
a.append(3)
insert(i, x) Inserts item x at position i a = [1, 3] [1, 2, 3]
a.insert(1, 2)
Adds all elements of lst to the end of the
extend(lst) a = [1, 2] [1, 2, 3, 4]
list
a.extend([3, 4])
remove(x) Removes the first occurrence of value x a = [1, 2, 3, 2] [1, 3, 2]
a.remove(2)
Removes and returns element at index i
pop(i) a = [1, 2, 3] Returns 3, list becomes [1, 2]
(default is last)
a.pop()
index(x) Returns the index of first occurrence of x a = [10, 20, 30] 1
a.index(20)
Returns number of times x appears in
count(x) a = [1, 2, 2, 3] 2
the list
a.count(2)
Sorts the list in ascending order
sort() a = [3, 1, 2] [1, 2, 3]
(modifies list)
a.sort()
reverse() Reverses the elements of the list a = [1, 2, 3] [3, 2, 1]
a.reverse()
clear() Removes all elements from the list a = [1, 2, 3] []
a.clear()
copy() Returns a shallow copy of the list a = [1, 2, 3] b = [1, 2, 3]
b = a.copy()
TUPLE
TUPLE
A tuple is an ordered collection of items, which is immutable (i.e., it cannot be changed after
creation). Tuples are similar to lists but use round brackets () instead of square brackets [].
CHARACTERISTICS OF TUPLE
1. Ordered – Elements are stored in a specific order.
2. Immutable – Once created, elements cannot be changed.
3. Allow duplicates – Tuples can contain repeated values.
4. Can hold different data types – Integers, strings, lists, etc.
5. Indexing – Elements can be accessed using indexes.
6. Faster than lists – Due to immutability.
CREATION OF TUPLE:
1. Empty Tuple
t = ()
2. Tuple with values
t = (1, 2, 3, 4)
3. Tuple without parentheses (not recommended)
t = 1, 2, 3
4. Single element tuple
t = (10,) # Comma is important
5. Nested Tuple
t = (1, 2, (3, 4), [5, 6])
Tuple Operations
Operation Example Description
Concatenation (1, 2) + (3, 4) Adds two tuples
Repetition (1, 2) * 3 Repeats the tuple multiple times
Membership 3 in (1, 2, 3) Checks if an element is in tuple
Length len((1, 2, 3)) Returns number of items
Tuple Indexing:
Just like strings and lists, tuple elements can be accessed using indexes.
t = (10, 20, 30, 40)
print(t[0]) # 10
print(t[-1]) # 40
Tuple Slicing:
You can extract parts of a tuple using slicing.
t = (10, 20, 30, 40, 50)
print(t[1:4]) # (20, 30, 40)
print(t[:3]) # (10, 20, 30)
print(t[::2]) # (10, 30, 50)
FUNCTIONS OF TUPLE (Built-in Functions)
Function Description Syntax Example Output
Returns the number of elements
len() len(t) len((10, 20, 30)) 3
in the tuple
max() Returns the maximum element max(t) max((5, 12, 8)) 12
min() Returns the minimum element min(t) min((5, 12, 8)) 5
sum() Returns the sum of all elements sum(t) sum((10, 20, 30)) 60
Returns a sorted list (not tuple) sorted((50, 10, [10, 20,
sorted() sorted(t)
of elements 20)) 50]
tuple() Converts a sequence into a tuple tuple(seq) tuple([1, 2, 3]) (1, 2, 3)
Tuple Methods:
Method Description Syntax Example Output
Returns the number of times the
count(x) tuple.count(x) (1, 2, 2, 3).count(2) 2
value x appears in the tuple
Returns the index of the first
(10, 20,
index(x) occurrence of the value x in the tuple.index(x) 1
30).index(20)
tuple
DICTIONARY
1. Introduction to Dictionary
1. A dictionary in Python is an unordered collection of items.
2. Each item is a key-value pair.
3. Dictionaries are mutable (can be changed).
4. Defined using curly braces {} with key:value pairs.
🔹 Example:
student = {'name': 'John', 'age': 16, 'grade': 'A'}
🔹 Output:
{'name': 'John', 'age': 16, 'grade': 'A'}
2. Dictionary - Key:Value Pairs
Key: Must be unique and immutable (string, number, tuple)
Value: Can be any datatype and can be duplicate
Keys are used to access values.
🔹 Example:
car = {
'brand': 'Toyota',
'model': 'Corolla',
'year': 2022
}
Accessing a value:
print(car['model'])
🔹 Output:
Corolla
3. Working with Dictionaries
Operation Code Example Description Output
Returns the value of the
Access a value d['name'] 'John'
key
Adds new key-value to {'city':
Add a new pair d['city'] = 'Delhi'
the dictionary 'Delhi'} added
Changes the value of
Modify a value d['age'] = 17 'age': 17
existing key
Removes
Delete a pair del d['grade'] Deletes key-value pair
'grade' key
Check key Returns True if key
'name' in d True
existence exists
Loop through 'name', 'age',
for k in d: Iterates over keys
keys etc.
Loop through for k, v in d.items(): Iterates through key- name Johnage
items print(k, v) value pairs 16city Delhi
🔹 Example Program:
student = {'name': 'John', 'age': 16, 'grade': 'A'}
# Access
print(student['name'])
# Modify
student['grade'] = 'A+'
# Add
student['city'] = 'Delhi'
# Delete
del student['age']
# Display all items
for key, value in student.items():
print(key, ":", value)
🔹 Output:
John
name : John
grade : A+
city : Delhi
4. Dictionary Functions & Methods
Function/Method Description Example Output
Returns number of
len(d) len({'a': 1, 'b': 2}) 2
key-value pairs
Returns list of dict_keys(['a'
d.keys() {'a': 1}.keys()
keys ])
Returns list of dict_values([1
d.values() {'a': 1}.values()
values ])
Returns list of
dict_items([('
d.items() key-value pairs {'a': 1}.items()
a', 1)])
(tuples)
Returns value for
d.get(key) key, or None if {'a': 1}.get('a') 1
not found
Returns value or
d.get(key, default) default if key {'a': 1}.get('b', 0) 0
not found
Removes specified 1 (dictionary
d.pop(key) key and returns {'a': 1, 'b': 2}.pop('a') becomes {'b':
its value 2})
d.clear() Removes all items {'a': 1}.clear() {}
Updates
d.update(other_dict dictionary with {'a': 1, 'b':
{'a': 1}.update({'b': 2})
) another 2}
dictionary
Returns a shallow
Same as
d.copy() copy of copy = d.copy()
original
dictionary
🔹 Example Program:
d = {'name': 'John', 'age': 25}
print(d['name']) # Accessing value
d['age'] = 30 # Modifying value
d['city'] = 'Delhi' # Adding new key:value
print(d.items()) # Getting all key-value pairs
Output:
John
dict_items([('name', 'John'), ('age', 30), ('city', 'Delhi')])
