Built in Functions

Built-in String Functions and Example Program

1. `find(substring [, start [, end]])`: Searches for the first occurrence of a substring

within a string and returns its index. Returns -1 if the substring is not found.

s = "Python Programming"
index = s.find("Programming")
print(index)

# Output: 7
Return type: `int`

2. `rfind(substring [, start [, end]])`: Similar to `find()`, but searches for the last
occurrence of the substring within the string.

s = "Python Programming"
index = s.rfind("o")
print(index)

# Output: 9
Return type: `int`

3. `index(substring [, start [, end]])`: Similar to `find()`, but raises a ValueError if

the substring is not found.

s = "Python Programming"
index = s.index("Programming")
print(index)

# Output: 7
Return type: `int`
 4. `rindex(substring [, start [, end]])`: Similar to `index()`, but searches for the last
occurrence of the substring within the string.

s = "Python Programming"
index = s.rindex("o")
print(index)

# Output: 9
Return type: `int`

5. `count(substring [, start [, end]])`: Counts the occurrences of a substring within a

string.

s = "Python Programming"
count = s.count("P")
print(count)

# Output: 2
Return type: `int`

6. `replace(old, new [, count])`: Replaces occurrences of a substring with another

substring.

s = "Python Programming"
new_s = s.replace("Python", "Java")
print(new_s)

# Output: Java Programming

Return type: `str`

7. `split([sep [, maxsplit]])`: Splits a string into a list of substrings based on a delimiter.

s = "Python Programming"
parts = s.split(" ")
print(parts)

# Output: ['Python', 'Programming']

Return type: `list`
8. `join(iterable)`: Joins elements of an iterable into a string using the string as a
separator.

parts = ['Python', 'Programming']

s = " ".join(parts)
print(s)

# Output: Python Programming

Return type: `str`

9. `strip([chars])`: Removes leading and trailing whitespace (or specified characters)

from a string.

s = " Python Programming "

clean_s = s.strip()
print(clean_s)
# Output: "Python Programming"
Return type: `str`

10. Character type checking functions:

- `isalnum()`: Checks if all characters in the string are alphanumeric.
- `isalpha()`: Checks if all characters in the string are alphabetic.
- `isdigit()`: Checks if all characters in the string are digits.
- `islower()`: Checks if all characters in the string are lowercase.
- `isupper()`: Checks if all characters in the string are uppercase.
- `isspace()`: Checks if all characters in the string are whitespace.

Example:
s = "PythonProgramming123"
print(s.isalnum()) # Output: True
print(s.isalpha()) # Output: False
print(s.isdigit()) # Output: False
print(s.islower()) # Output: False
print(s.isupper()) # Output: False
print(s.isspace()) # Output: False

Return type: `bool`

Built-in List Functions and Example Program

1. `count(value)`: Counts the number of occurrences of a value in a list.

my_list = [1, 2, 3, 4, 1, 2, 1]
count = my_list.count(1)
print(count)

# Output: 3
Return type: `int`

2. `index(value [, start [, end]])`: Returns the index of the first occurrence of a value in a
list.

my_list = [1, 2, 3, 4, 1, 2, 1]
index = my_list.index(2)
print(index)

# Output: 1
Return type: `int`

3. `remove(value)`: Removes the first occurrence of a value from a list.

my_list = [1, 2, 3, 4, 1, 2, 1]
my_list.remove(2)
print(my_list)

# Output: [1, 3, 4, 1, 2, 1]
Return type: `None`

4. `pop([index])`: Removes and returns the element at the specified index. If no index is
specified, removes and returns the last element.

my_list = [1, 2, 3, 4, 5]
element = my_list.pop(2)
print(element)
# Output: 3
print(my_list)

# Output: [1, 2, 4, 5]
Return type: `int`
5. `reverse()`: Reverses the elements of a list in place.

my_list = [1, 2, 3, 4, 5]
my_list.reverse()
print(my_list)

# Output: [5, 4, 3, 2, 1]
Return type: `None`

6. `sort(key=None, reverse=False)`: Sorts the elements of a list in place.

my_list = [3, 1, 4, 1, 5, 9, 2, 6, 5]
my_list.sort()
print(my_list)

# Output: [1, 1, 2, 3, 4, 5, 5, 6, 9]
Return type: `None`

7. `append(value)`: Adds a single element to the end of a list.

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)

# Output: [1, 2, 3, 4]
Return type: `None`

8. `extend(iterable)`: Extends the list by appending elements from the iterable.

my_list = [1, 2, 3]
other_list = [4, 5, 6]
my_list.extend(other_list)
print(my_list)

# Output: [1, 2, 3, 4, 5, 6]
Return type: `None`

9. `del`: Deletes elements from a list or deletes the entire list.

my_list = [1, 2, 3, 4, 5]
del my_list[2]
print(my_list) # Output: [1, 2, 4, 5]
Return type: `None`
Built-in Tuple Functions and Example Program

1. `count(value)`: Counts the number of occurrences of a value in a tuple.

my_tuple = (1, 2, 3, 4, 1, 2, 1)
count = my_tuple.count(1)
print(count)

# Output: 3
Return type: `int`

2. `index(value [, start [, end]])`: Returns the index of the first occurrence of a value
in a tuple.

my_tuple = (1, 2, 3, 4, 1, 2, 1)
index = my_tuple.index(2)
print(index)

# Output: 1
Return type: `int`

3. `len()`: Returns the number of elements in a tuple.

my_tuple = (1, 2, 3, 4, 5)
length = len(my_tuple)
print(length)

# Output: 5
Return type: `int`

4. `min()`: Returns the smallest element in a tuple.

my_tuple = (3, 1, 4, 1, 5, 9, 2, 6, 5)
minimum = min(my_tuple)
print(minimum)

# Output: 1
Return type: Same type as elements in the tuple
5. `max()`: Returns the largest element in a tuple.

my_tuple = (3, 1, 4, 1, 5, 9, 2, 6, 5)
maximum = max(my_tuple)
print(maximum)

# Output: 9
Return type: Same type as elements in the tuple

6. `del`: Deletes the entire tuple.

my_tuple = (1, 2, 3, 4, 5)
del my_tuple

Return type: `None`

Built-in Set Functions and Example Program

1. `add(element)`: Adds a single element to a set.

my_set = {1, 2, 3}
my_set.add(4)
print(my_set)

# Output: {1, 2, 3, 4}
Return type: `None`

2. `remove(element)`: Removes a specified element from a set. Raises a KeyError if

the element is not present.

my_set = {1, 2, 3, 4}
my_set.remove(3)
print(my_set)

# Output: {1, 2, 4}
Return type: `None`
3. `discard(element)`: Removes a specified element from a set if it is present.
Does not raise an error if the element is not found.

my_set = {1, 2, 3, 4}
my_set.discard(5)
print(my_set)
# Output: {1, 2, 3, 4}
Return type: `None`

4. `pop()`: Removes and returns an arbitrary element from a set. Raises a

KeyError if the set is empty.

my_set = {1, 2, 3, 4}
element = my_set.pop()
print(element)

# Output: 1 or any other element

Return type: Same type as the elements in the set

5. `clear()`: Removes all elements from a set.

my_set = {1, 2, 3, 4}
my_set.clear()
print(my_set)

# Output: set()
Return type: `None`

6. `copy()`: Returns a shallow copy of a set.

my_set = {1, 2, 3, 4}
new_set = my_set.copy()
print(new_set)

# Output: {1, 2, 3, 4}
Return type: `set`
 7. `union(*others)`: Returns a new set containing the union of the original set and
other sets.

set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1.union(set2)
print(union_set)

# Output: {1, 2, 3, 4, 5}
Return type: `set`

8. `intersection(*others)`: Returns a new set containing the intersection of the

original set and other sets.

set1 = {1, 2, 3}
set2 = {3, 4, 5}
intersection_set = set1.intersection(set2)
print(intersection_set)

# Output: {3}
Return type: `set`

Built-in Dictionary Functions and Example Program

1. `clear()`: Removes all elements from a dictionary.

my_dict = {'a': 1, 'b': 2, 'c': 3}

my_dict.clear()
print(my_dict)

# Output: {}
Return type: `None`
2. `copy()`: Returns a shallow copy of a dictionary.

my_dict = {'a': 1, 'b': 2, 'c': 3}

new_dict = my_dict.copy()
print(new_dict)

# Output: {'a': 1, 'b': 2, 'c': 3}

Return type: `dict`

3. `keys()`: Returns a view of all keys in the dictionary.

my_dict = {'a': 1, 'b': 2, 'c': 3}

keys = my_dict.keys()
print(keys)

# Output: dict_keys(['a', 'b', 'c'])

Return type: `dict_keys`

4. `values()`: Returns a view of all values in the dictionary.

my_dict = {'a': 1, 'b': 2, 'c': 3}

values = my_dict.values()
print(values)

# Output: dict_values([1, 2, 3])

Return type: `dict_values`

5. `items()`: Returns a view of all key-value pairs in the dictionary.

my_dict = {'a': 1, 'b': 2, 'c': 3}

items = my_dict.items()
print(items)

# Output: dict_items([('a', 1), ('b', 2), ('c', 3)])

Return type: `dict_items`
6. `get(key [, default])`: Returns the value associated with a specified key. If the key is
not found, returns the default value or None if not specified.

my_dict = {'a': 1, 'b': 2, 'c': 3}

value = my_dict.get('b')
print(value)

# Output: 2
Return type: Same type as the values in the dictionary or the
specified default value.

7. `pop(key [, default])`: Removes and returns the value associated with a specified key.
If the key is not found, returns the default value or raises a KeyError if not specified.

my_dict = {'a': 1, 'b': 2, 'c': 3}

value = my_dict.pop('b')
print(value)

# Output: 2
Return type: Same type as the values in the dictionary or the
specified default value.