← Back to course index Module 5 · Functions & Modules

Python Built-in Functions

Fifteen functions that are always there, no import needed — I/O, type conversion, math, number-base conversion, iterables, introspection, and documentation lookup.

Overview

This session covers Python's built-in functions — functions that are always available without needing to import anything. These are fundamental utilities used constantly in everyday Python programming: I/O, type conversion, math operations, and introspection (inspecting objects/functions).

Key Concepts

Built-in functions are pre-defined in Python and don't need any import.
They cover categories like: I/O (print, input), type conversion (int, type), math (abs, pow, round, divmod), number base conversion (bin, oct, hex), iterable operations (len, sum, min, max), character/code conversion (ord), object introspection (id), and documentation lookup (help).

Detailed Explanation

1. print()

Prints output to the console (stdout by default).

print("Hello world")

Output:

Hello world

📌 Full signature (from help('print')):

print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

Optional keyword arguments:

Argument	Meaning	Default
`file`	A file-like stream to write to	`sys.stdout`
`sep`	String inserted between multiple values	`' '` (space)
`end`	String appended after the last value	`'\n'` (newline)
`flush`	Whether to forcibly flush the stream	`False`

💡 Tip: Use sep and end to customize how multiple print statements or values are formatted, e.g. print("a", "b", sep="-") → a-b.

2. input()

Reads a line of text typed by the user and returns it as a string.

input("Enter your name")

Interaction:

Enter your nameNitish

Output:

'Nitish'

Important Points

input() always returns a string, even if the user types a number — you must manually convert it (e.g., using int()) if numeric use is needed.
The prompt text and the user's typed input appear on the same line in the console.

3. type()

Returns the data type/class of an object.

a = True
type(a)

Output:

bool

💡 Useful for debugging — quickly check what kind of object a variable is.

4. int() and other type conversion functions

int() converts a value (like a float or string) into an integer.

int(5.6)
# float
# str
# list
# tuple

Output:

Important Points

int(5.6) truncates the decimal part (does not round) → result is 5, not 6.
Similar conversion functions exist for other types: float(), str(), list(), tuple() — these convert values into their respective types.

⚠️ Screenshot text unclear — the comments (# float, # str, # list, # tuple) appear to just be a note-to-self listing related conversion functions, not executable code.

5. abs()

Returns the absolute value (removes the negative sign) of a number.

abs(-4)

Output:

6. pow()

Returns the value of a number raised to a power (like **, but as a function).

pow(2, 3)

Output:

pow(2, -3)

Output:

0.125

Important Points

pow(base, exponent) — a negative exponent produces a fractional (float) result, since it's equivalent to 1 / (base ** abs(exponent)).
pow() also supports an optional third argument for modular exponentiation: pow(base, exp, mod) (not shown in this screenshot, but part of Python's standard signature).

7. min() / max()

Return the smallest or largest item in an iterable.

max([2, 1, 3, 0])

Output: 3

min([2, 1, 3, 0])

Output: 0

min("kolkata")

Output: 'a'

Important Points

Works on lists, strings, and other iterables.
For strings, comparison is done character by character based on alphabetical/ASCII order — min("kolkata") returns 'a' because 'a' has the lowest character value among the letters present.

8. round()

Rounds a number to the nearest value, optionally to a specified number of decimal places.

c = 22/7
round(c, 2)

Output: 3.14

round(c)

Output: 3

Important Points

round(number, ndigits) → rounds to ndigits decimal places.
round(number) (no second argument) → rounds to the nearest whole integer.

9. divmod()

Returns a tuple containing the quotient and remainder of a division, in one call.

divmod(5, 2)

Output:

(2, 1)

💡 Equivalent to (5 // 2, 5 % 2) but computed in a single, efficient call. Useful when you need both quotient and remainder together.

10. bin() / oct() / hex()

Convert an integer into its binary, octal, or hexadecimal string representation.

hex(4)

Output: '0x4'

oct(4)

Output: '0o4'

Important Points

hex() output is prefixed with 0x.
oct() output is prefixed with 0o.
(Not shown in screenshots, but implied by the section title) bin() would return a string prefixed with 0b.

11. id()

Returns the unique memory identity (address) of an object — an integer that is unique for the object's lifetime.

a = 3
id(a)

Output:

140721404847984

Important Points

Every object in Python has a unique id() while it exists in memory.
Commonly used to check whether two variables point to the same object (id(a) == id(b)) rather than just equal values.
The actual number will vary between runs/machines — it's a memory address, not a fixed value.

12. ord()

Returns the Unicode/ASCII code point (integer) of a single character.

ord('A')

Output:

💡 The reverse function is chr(), which converts a code point back into a character (not shown in screenshots, but a natural pairing to remember).

13. len()

Returns the number of items in a sequence or collection (list, string, tuple, dict, etc.).

len([1, 2, 3])

Output:

14. sum()

Returns the sum of all items in an iterable, plus an optional starting value.

sum()  # (being typed in the notebook — incomplete example)

📌 Full signature (from help('sum')):

sum(iterable, /, start=0)

Behavior:

Returns the sum of a start value (default 0) plus all items of an iterable of numbers.
If the iterable is empty, it returns the start value.
Intended specifically for numeric values; may reject non-numeric types.

Example (inferred usage pattern):

sum([1, 2, 3])        # → 6
sum([1, 2, 3], 10)     # → 16 (start=10)

15. help()

Displays the documentation (docstring) for a function, module, or object — extremely useful for quickly checking a function's signature and behavior without leaving the notebook.

help('print')

Output (partial):

Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

help('sum')

Output (partial):

Help on built-in function sum in module builtins:

sum(iterable, /, start=0)
    Return the sum of a 'start' value (default: 0) plus an iterable of numbers

    When the iterable is empty, return the start value.
    This function is intended specifically for use with numeric values and may
    reject non-numeric types.

💡 Tip: help() can be called with either the function name as a string (help('print')) or the function object itself (help(print)) — both work.

Commands / Syntax Cheat Sheet

print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
input("prompt")                # always returns a string
type(obj)                      # returns the class/type of obj
int(x)                         # converts x to int (truncates floats)
abs(x)                         # absolute value
pow(base, exp)                 # exponentiation (like base ** exp)
min(iterable)                  # smallest item
max(iterable)                  # largest item
round(number, ndigits=None)    # rounds; ndigits omitted → nearest int
divmod(a, b)                   # returns (a // b, a % b) as a tuple
bin(x)                         # binary string, prefixed '0b'
oct(x)                         # octal string, prefixed '0o'
hex(x)                         # hex string, prefixed '0x'
id(obj)                        # unique memory identity of obj
ord(char)                      # Unicode code point of a single character
len(sequence)                  # number of items
sum(iterable, start=0)         # sum of items + start value
help(obj_or_name)              # shows documentation

Things to Remember

input() always returns a string — convert explicitly if you need a number.
int() truncates, it does not round.
round(x) with no second argument rounds to the nearest whole number; round(x, n) rounds to n decimal places.
divmod(a, b) saves you from writing a // b and a % b separately.
bin, oct, hex return strings, each with a distinctive prefix (0b, 0o, 0x).
id() gives a memory address — useful to check object identity, not equality.
ord() and chr() are inverse operations (character ↔ code point).
help() is a quick way to check any function's official docstring/signature directly in the notebook.

Quick Revision

Python has many built-in functions that require no imports:

I/O: print() outputs, input() reads a string from the user.
Type tools: type() shows an object's class; int(), float(), str(), list(), tuple() convert between types.
Math: abs() (absolute value), pow() (exponentiation), round() (rounding), divmod() (quotient + remainder together).
Number systems: bin(), oct(), hex() convert integers to binary/octal/hex strings.
Iterables: len() (count items), sum() (add items), min()/max() (smallest/largest).
Character codes: ord() converts a character to its Unicode code point.
Introspection: id() returns an object's unique memory identity.
Documentation: help() prints the docstring of any function — great for quick reference while coding.