Oct 13, 2023 7 mins

Understanding Python Built-in Functions Part 4

Python Built-in Functions Part 4 Python Built-in Functions Part 4

Python has a rich set of built-in functions that can be used for various programming needs. In this article, we'll dive into each of these functions from S to Z, providing examples and insights into their usage.

This is the part 4 of the Python built-in function tutorial series and will cover following built-in functions. Checkout the these links for other python built-in function tutorials.

set() function

The set() function is used for creating a new set object. A set is an unordered and mutable collection that contains unique elements. The set() function function can be called without arguments to create an empty set, or it can take an iterable as an argument to initialize a set with the elements from that iterable.

Sets in Python are characterized by their ability to perform set operations like union, intersection, and difference, making them suitable for tasks involving distinct elements and set manipulation.

The use of sets is prevalent in scenarios where the uniqueness of elements and the absence of a specific order are key requirements.

my_set = set([1, 2, 3])


{1, 2, 3}

setattr() function

The setattr() function allows the dynamic setting of attributes on an object. It takes three arguments, the object whose attribute is to be set, the name of the attribute as a string, and the value to assign to the attribute. This function is particularly useful when the attribute name or value is determined at runtime or when there is a need for dynamic attribute assignment.

setattr() function provides a programmatic way to modify or add attributes to objects during execution, enhancing the flexibility and adaptability of Python code. However, it’s essential to use setattr() function judiciously, as excessive reliance on dynamic attribute manipulation can lead to code that is harder to understand and maintain.

class Example:

obj = Example()
setattr(obj, 'attribute_name', 'attribute_value')



slice() function

The slice() function allows for concise and expressive slicing. For example, my_list[start:stop:step] is equivalent to using slice(start, stop, step). The slice object encapsulates the start, stop, and step parameters, providing a convenient way to define a slicing pattern that can be reused across different sequences.

Developers often use slices to extract or modify specific portions of a sequence, contributing to the readability and conciseness of Python code.

my_list = [1, 2, 3, 4, 5]
sliced_list = my_list[1:4]


[2, 3, 4]

sorted() function

The sorted() function is used for sorting elements within an iterable. It takes an iterable as its primary argument and returns a new list containing the sorted elements. Optionally, it can take additional parameters, such as a key function to specify custom sorting criteria and a reverse parameter to control the sorting order. The sorted() function function does not modify the original iterable, instead, it generates a new sorted list, leaving the original data unchanged.

This function is widely used for tasks that require ordering elements, ranging from simple lists of numbers to more complex data structures.

unsorted_list = [3, 1, 4, 1, 5, 9, 2]
sorted_list = sorted(unsorted_list)


[1, 1, 2, 3, 4, 5, 9]

staticmethod() function

The staticmethod() function is a built-in function used to declare a static method within a class. Unlike regular methods in a class, static methods do not have access to the instance or its attributes, they operate on the class itself. The staticmethod() function is typically used as a decorator to indicate that a particular method should be treated as a static method. It takes a function as its argument and returns a static method object for that function.

Static methods are often used when a particular functionality is related to a class but does not depend on specific instance data. They provide a way to organize and encapsulate functionality within a class without requiring access to instance attributes.

class MyClass:
    def my_static_method():
        print("This is a static method")



This is a static method

str() function

The str() function is used for converting non-string objects into string representations. It takes an object as its argument and returns a human-readable string version of that object.

This function is particularly useful when you need to represent different data types, such as numbers or other objects, as strings, making them suitable for output or display. Additionally, when defining a custom class, you can implement a special method called __str__() to define the string representation of instances of that class.

The str() function is commonly used in various scenarios, including printing, formatting, or any situation where converting an object to a string is necessary.

string_representation = str(123)



sum() function

The sum() function is used for calculating the sum of elements in an iterable, such as a list or tuple. It takes the iterable as its main argument and, optionally, can include a start value that serves as an initial accumulator. The sum() function is particularly handy when dealing with numerical data, as it provides a concise and efficient way to obtain the total sum of a sequence of numbers.

This function is versatile and can handle various iterable types, making it suitable for different use cases.

my_sum = sum([1, 2, 3, 4])



super() function

The super() function is used to access methods or attributes from a parent or superclass within a derived or subclass. It plays a key role in facilitating inheritance and cooperative method calls in object-oriented programming. By using super() function, a subclass can invoke methods or access attributes from its superclass, allowing for code reuse and promoting a more modular and maintainable design.

The super() function is often called inside a derived class’s methods and provides a way to delegate calls to the corresponding methods in the superclass. This ensures that both the subclass and superclass implementations are executed, fostering a cooperative and extensible approach to method overriding.

class Parent:
    def my_method(self):
        print("Parent method")

class Child(Parent):
    def my_method(self):
        print("Child method")

child_instance = Child()


Parent method
Child method

tuple() function

The tuple() function is used for creating a new tuple object. A tuple is an ordered, immutable collection of elements, and the tuple() function can be called without arguments to create an empty tuple or with an iterable as an argument to initialize a tuple with the elements from that iterable. Tuples in Python are often used to represent fixed sequences of values, and their immutability makes them suitable for use as keys in dictionaries or elements in sets.

Tuples are particularly useful in scenarios where an ordered and unchangeable sequence of elements is desired, and the tuple() function serves as a fundamental tool for working with this data type in Python.

my_tuple = (1, 2, 3)


(1, 2, 3)

type() function

The type() function serves multiple purposes. When used with a single argument, it returns the type of the given object. For example, type(42) would return the class ‘int’. Additionally, when used with three arguments, type() function can be employed to dynamically create a new class. This feature allows for the dynamic definition of classes at runtime, making it a fundamental element in metaprogramming and class creation.

Developers often leverage type() function for tasks such as type checking, determining the class of an object, or dynamically generating new classes and objects during program execution.

my_type = type("Hello")


<class 'str'>

vars() function

The vars() function returns the __dict__ attribute of an object, or the __dict__ of the current module if called without an argument. This function provides access to the namespace or dictionary of an object, which contains its attributes and their values. When applied to a module, vars() function returns a dictionary representing the module’s namespace, allowing for the inspection and manipulation of its attributes.

In the context of an object, such as an instance of a class, vars() function provides a way to access and modify the object’s attributes dynamically. It’s important to note that changes made using vars() function directly affect the object’s underlying dictionary.

class Example:
    def __init__(self):
        self.variable1 = 42
        self.variable2 = "Hello"

obj = Example()
object_vars = vars(obj)


{'variable1': 42, 'variable2': 'Hello'}

zip() function

The zip() function takes one or more iterables as arguments and returns an iterator that generates tuples containing elements from the corresponding positions of the input iterables. If the input iterables are of uneven length, zip() function stops creating tuples when the shortest iterable is exhausted. This function is widely used in scenarios where data from multiple sources needs to be processed in parallel or when creating pairs of related elements.

By zipping together iterables, developers can efficiently iterate over multiple sequences simultaneously, facilitating tasks like data aggregation, parallel iteration, or pairing elements for further processing.

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
zipped_lists = zip(list1, list2)


[(1, 'a'), (2, 'b'), (3, 'c')]


Python’s built-in functions offer a wide array of capabilities, simplifying common programming tasks. Understanding these functions enhances your proficiency as a Python developer, allowing you to write more efficient and concise code. In this comprehensive guide, we’ve explored essential Python functions from S to Z. Incorporating these functions into your Python code will undoubtedly enhance your programming experience.


There are no comments yet.

Write a comment

You can use the Markdown syntax to format your comment.

  • Tags:
  • python built-in functions
  • Share: