More Built-in Functions

Python provides many built-in functions that are useful when working with collections and other data types. This section covers some of the most commonly used built-in functions.

any()

The any() function returns True if any element of the iterable is truthy, otherwise it returns False.

1
print(any([0, 1, 2]))  # True (at least one element is truthy)
2
print(any([0, 0, 0]))  # False (no truthy elements)
3
print(any([]))  # False (empty iterable)
4
print(any([False, None, ""]))  # False (all falsy)
5
print(any((False, 0, "hello")))  # True (at least one truthy)
6
print(any(""))  # False (empty string)
7
print(any({0: "a", 1: "b"}))  # True (has truthy keys)
8
print(any({0, False, None}))  # False (all falsy)

Note
If the iterable is empty, any() returns False.

all()

The all() function returns True if all elements of the iterable are truthy, otherwise it returns False.

1
print(all([1, 2, 3]))  # True (all elements are truthy)
2
print(all([1, 2, 0]))  # False (0 is falsy)
3
print(all([]))  # True (empty iterable)
4
print(all([True, 1, "hello"]))  # True (all truthy)
5
print(all((True, 0, "hello")))  # False (0 is falsy)
6
print(all("hello"))  # True (all characters are truthy)
7
print(all(""))  # True (empty string)
8
print(all({0: "a", 1: "b"}))  # False (0 is falsy)
9
print(all({1, 2, 3}))  # True (all elements are truthy)

Note
If the iterable is empty, all() returns True.

hash()

The hash() function returns the hash value of an object. Hash values are integers used to quickly compare dictionary keys and set elements.

1
print(hash("hello"))  # Some integer value
2
print(hash(42))  # 42 (integers hash to themselves)
3
print(hash((1, 2, 3)))  # Some integer value

Mutable objects are not hashable:

1
# This will raise a TypeError
2
# hash([1, 2, 3])  # TypeError: unhashable type: 'list'
3
# hash({1, 2, 3})  # TypeError: unhashable type: 'set'
4
# hash({"a": 1})  # TypeError: unhashable type: 'dict'

Two objects that are equal must have the same hash value:

Warning
The hash value of an object may change between different Python runs. Do not rely on hash values being consistent across program executions.

divmod()

The divmod() function takes two numbers and returns a tuple containing the quotient and remainder of the division.

1
result = divmod(10, 3)
2
print(result)  # (3, 1)
3
print(result[0])  # 3 (quotient)
4
print(result[1])  # 1 (remainder)
5

6
# Equivalent to:
7
quotient, remainder = divmod(10, 3)
8
print(quotient)  # 3
9
print(remainder)  # 1

divmod() is equivalent to (a // b, a % b):

bin()

The bin() function converts an integer to a binary string prefixed with "0b".

1
print(bin(10))  # 0b1010
2
print(bin(0))  # 0b0
3
print(bin(255))  # 0b11111111
4
print(bin(-10))  # -0b1010

oct()

The oct() function converts an integer to an octal string prefixed with "0o".

1
print(oct(10))  # 0o12
2
print(oct(0))  # 0o0
3
print(oct(64))  # 0o100
4
print(oct(-10))  # -0o12

hex()

The hex() function converts an integer to a lowercase hexadecimal string prefixed with "0x".

1
print(hex(10))  # 0xa
2
print(hex(0))  # 0x0
3
print(hex(255))  # 0xff
4
print(hex(16))  # 0x10
5
print(hex(-10))  # -0xa

zip()

The zip() function takes multiple iterables and returns an iterator of tuples, where each tuple contains the elements from each iterable at the same position.

1
list1 = [1, 2, 3]
2
list2 = ['a', 'b', 'c']
3
result = zip(list1, list2)
4
print(list(result))  # [(1, 'a'), (2, 'b'), (3, 'c')]

zip() stops when the shortest iterable is exhausted:

1
list1 = [1, 2, 3, 4]
2
list2 = ['a', 'b']
3
result = zip(list1, list2)
4
print(list(result))  # [(1, 'a'), (2, 'b')] - stops at shortest

You can zip more than two iterables:

1
numbers = [1, 2, 3]
2
letters = ['a', 'b', 'c']
3
symbols = ['!', '@', '#']
4
result = zip(numbers, letters, symbols)
5
print(list(result))  # [(1, 'a', '!'), (2, 'b', '@'), (3, 'c', '#')]

enumerate()

The enumerate() function adds a counter to an iterable and returns an enumerate object that generates pairs of (index, value).

1
fruits = ['apple', 'banana', 'cherry']
2
result = enumerate(fruits)
3
print(list(result))  # [(0, 'apple'), (1, 'banana'), (2, 'cherry')]

A starting index can be specified:

1
fruits = ['apple', 'banana', 'cherry']
2
result = enumerate(fruits, start=1)
3
print(list(result))  # [(1, 'apple'), (2, 'banana'), (3, 'cherry')]

A common use case is getting both the index and value when looping:

1
fruits = ['apple', 'banana', 'cherry']
2
for index, fruit in enumerate(fruits):
3
    print(f"{index}: {fruit}")
4
# Output:
5
# 0: apple
6
# 1: banana
7
# 2: cherry

Without enumerate(), you would need to use range() and indexing:

1
fruits = ['apple', 'banana', 'cherry']
2
for i in range(len(fruits)):
3
    print(f"{i}: {fruits[i]}")

reversed()

The reversed() function returns a reverse iterator that iterates over the elements of a sequence in reverse order.

1
numbers = [1, 2, 3, 4, 5]
2
reversed_numbers = reversed(numbers)
3
print(list(reversed_numbers))  # [5, 4, 3, 2, 1]
4
print(numbers)  # [1, 2, 3, 4, 5] (original unchanged)

reversed() works with any sequence type:

1
# With tuples
2
t = (1, 2, 3, 4, 5)
3
reversed_t = reversed(t)
4
print(list(reversed_t))  # [5, 4, 3, 2, 1]
5

6
# With strings
7
s = "hello"
8
reversed_s = reversed(s)
9
print(list(reversed_s))  # ['o', 'l', 'l', 'e', 'h']
10
print("".join(reversed_s))  # 'olleh' (but iterator is exhausted)
11
print("".join(reversed("hello")))  # 'olleh'

reversed() returns an iterator, so it needs to be converted to a list or used in a loop:

1
numbers = [1, 2, 3, 4, 5]
2
for num in reversed(numbers):
3
    print(num)
4
# Output:
5
# 5
6
# 4
7
# 3
8
# 2
9
# 1

Note
For lists, you can also use the .reverse() method, but it modifies the list in place and returns None. The reversed() function returns a new iterator without modifying the original sequence.

slice()

The slice() function returns a slice object that can be used for slicing sequences. It’s equivalent to using the slice notation [start:stop:step].

1
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2
s = slice(2, 7, 2)
3
print(numbers[s])  # [2, 4, 6]
4
# Equivalent to: numbers[2:7:2]

Creating slice objects:

1
# slice(stop)
2
s1 = slice(5)
3
print(s1)  # slice(None, 5, None)
4

5
# slice(start, stop)
6
s2 = slice(2, 7)
7
print(s2)  # slice(2, 7, None)
8

9
# slice(start, stop, step)
10
s3 = slice(2, 10, 2)
11
print(s3)  # slice(2, 10, 2)

Using slice objects:

1
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2

3
# First 5 elements
4
s = slice(5)
5
print(numbers[s])  # [0, 1, 2, 3, 4]
6

7
# Elements from index 2 to 7
8
s = slice(2, 7)
9
print(numbers[s])  # [2, 3, 4, 5, 6]
10

11
# Every 2nd element from index 2 to 10
12
s = slice(2, 10, 2)
13
print(numbers[s])  # [2, 4, 6, 8]

Slice objects can be stored and reused:

1
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2
first_half = slice(0, 5)
3
second_half = slice(5, 10)
4

5
print(numbers[first_half])  # [0, 1, 2, 3, 4]
6
print(numbers[second_half])  # [5, 6, 7, 8, 9]
7

8
# Works with strings too
9
text = "Hello, World!"
10
print(text[first_half])  # "Hello"
11
print(text[second_half])  # ", World!"

Slice objects have attributes:

1
s = slice(2, 10, 2)
2
print(s.start)  # 2
3
print(s.stop)  # 10
4
print(s.step)  # 2

More Built-in Functions

Table of Contents

Table of Contents

Course Progress

More Built-in Functions

any()

all()

hash()

divmod()

bin()

oct()

hex()

zip()

enumerate()

reversed()

slice()

Course Progress