Can Python variables start with underscore _?

Using underscores in Python variable names can be a powerful tool, but it’s important to use them correctly and in the right context.

We’ll explore the different types of underscores you can use in Python variable names, and when it’s appropriate to use them.

Python variables can start with an underscore (_). This is a perfectly valid syntax in Python, and it can be useful for indicating that a variable is intended for internal use or is a private variable. However, there are some important caveats to keep in mind when using underscores in variable names.

It’s worth noting that using a single underscore at the beginning of a variable name does not actually make the variable private or inaccessible from outside the class or module. Rather, it serves as a signal to other developers that the variable should not be used outside its intended scope.

It is generally considered a convention used to indicate that the variable is intended for internal use or is a private variable. This convention is not enforced by the Python interpreter, but it is widely accepted in the Python community as a best practice for writing clear and maintainable code.

Python underscore before a variable name

In Python, variables can be designated as private or internal using a convention of leading underscores in the variable name. When writing Python code, it’s often useful to designate certain variables as private or internal to a class or module.

Private variables are intended to be used only within the scope of the class or module, and should not be accessed or modified directly by code outside that scope.

Internal variables, on the other hand, are intended for use within a particular implementation of a class or module.

These designations can help to ensure that the code is modular, maintainable, and less prone to bugs or unexpected behavior.

Why use a single underscore (_) when naming Python variables

When a variable name is prefixed with a single underscore, it signals to other developers that the variable should not be accessed or modified outside of the current module or class.

This is known as a weak internal use indicator.

Essentially, it is a way of saying that the variable is part of the internal implementation details of the code and should not be relied upon by code outside of the module or class.

For example, if you have a module with several functions, some of which rely on a shared variable, you might choose to use a single underscore prefix to indicate that the variable should not be accessed or modified outside of the module.

This can help prevent unintended side effects and make the code easier to maintain and understand.

Double underscores (__) before function names in Python

The use of double underscores in Python variables is a convention that indicates that these variables have a special meaning in the context of a class or object.

In Python, variables that are prefixed with double underscores are called “dunder” (short for “double underscore”) variables, and they are also known as special or magic methods.

For example, when you define a class in Python, you can define special methods that are called when certain operations are performed on objects of that class. These special methods have specific names that are prefixed and suffixed with double underscores, such as __init__ (used to initialize objects) or __str__ (used to represent objects as strings).

By using double underscores, Python ensures that these special variables and methods are not accidentally overridden by other variables or methods with the same name.

It also makes it clear to other developers that these variables and methods have a special meaning and should not be treated as regular variables or methods.

Overall, the use of double underscores in Python variables is a way to indicate that they are special and have a specific purpose in the context of a class or object.

With that, let’s see how you can create a private variable and a dunder method in Python using underscores.

How to create a private variable in Python

Python is an object-oriented programming language that allows developers to create and manipulate objects with ease.

One of the features of object-oriented programming is the ability to create private variables. Private variables are variables that are not intended to be accessed or modified outside of the class in which they are defined.

In Python, there is no strict enforcement of private variables, but a convention exists to indicate that a variable is intended to be private.

Here are the actionable steps to take to create a private variable in Python using a convention that is widely accepted by the Python community.

Step 1: Open an existing .py file or create one

Open a new or existing Python file in your preferred Python editor or IDE.

Step 2: Define a class using the class keyword

Define a class by using the class keyword followed by the class name, for example, class BankAccount:.

class BankAccount:
    ...

Step 3: Define an __init__() method to initialize the object’s attributes

Inside the class, define an __init__() method to initialize the object’s attributes. This is where you can define the private variable with a double underscore prefix.

For example,

class BankAccount:
    def __init__(self, initial_balance):
        self.__balance = initial_balance

Step 4: Access your private variable within the class

To access the private variable within the class, use the same double underscore prefix, for example, print(self.__balance).

class BankAccount:
    def __init__(self, initial_balance):
        self.__balance = initial_balance

    def deposit(self, amount):
        self.__balance += amount
        print("Deposit successful. New balance:", self.__balance)

How to create a dunder variable in Python

Dunder variables are used to define special methods that are called when certain operations are performed on objects of that class, such as initialization or string representation.

To create a dunder variable in Python, you simply need to define a method with the appropriate name.

The method should be prefixed and suffixed with double underscores, such as __init__ or __str__.

Here are the steps to create a dunder variable in Python:

Step #1: Identify the purpose of the dunder variable

The first step in creating a dunder variable in Python is to identify the purpose of the variable. Consider what operation or behavior you want to define for objects of the class.

This will help you choose the appropriate dunder method name and define the behavior of the method.

For example, if you want to define how objects of the class are initialized, you would use the __init__ method. If you want to define how objects of the class are compared to each other, you would use the __eq__ method.

Step #2: Choose the appropriate dunder method name

Once you have identified the purpose of the dunder variable, the next step is to choose the appropriate dunder method name.

There are many dunder methods available in Python, each with a specific purpose.

For example, if you want to define how objects of the class are represented as strings, you would use the __str__ method. If you want to define how objects of the class are called as functions, you would use the __call__ method.

Choose the method name that best matches the purpose of your variable.

Step #3: Define the dunder method in your class definition

After choosing the appropriate dunder method name, the next step is to define the dunder method in your class definition.

The method should be defined as a regular method, with the appropriate parameters and return values. Remember to prefix and suffix the method name with double underscores. Here’s an example:

class MyClass:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        ...

In this example, we define the __init__ method to initialize the x and y attributes of objects of the MyClass class.

We also define the __str__ method to represent objects of the class as strings.

Step #4: Implement the behavior of the dunder method

After defining the dunder method, the next step is to implement the behavior of the method. This will depend on the purpose of the variable and the specific requirements of your class.

For example, if you defined the __str__ method to represent objects of your class as strings, you would implement the behavior of the method to return a string representation of the object.

Here’s an example:

class MyClass:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"{self.x}, {self.y}"

In this example, we create an object of the MyClass class with x equal to 1 and y equal to 2. We then call the str function on the object, which calls the __str__ method we defined earlier.

Step #5: Create new objects and call the appropriate method

The final step is to create new objects of the class and call the appropriate dunder method to test your implementation.

Make sure the output matches your expected behavior.

For example, if you defined the __str__ method to represent objects of your class as strings, create a few objects of the class and call the str function on them to check that the string representation is correct.

Here’s an example:

class MyClass:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"{self.x}, {self.y}"

obj = MyClass(1, 2)
obj2 = MyClass(3, 4)


print(str(obj))
print(str(obj2))

In this example, we create two objects of the `MyClass` class with different values for `x` and `y`.

We then call the `str` function on each object to print the string representation of the object. The output should be:

By following these steps, you can create a dunder variable in Python to define the behavior of objects of your class.

Remember to choose the appropriate dunder method name and implement the behavior of the method to match the purpose of the variable.

That’s how you create Python variables and methods while using underscore or underscores as prefix to the variable names.

FAQs

Can variable names contain only underscores in Python?

Variable names cannot contain only underscores in Python. According to the Python naming conventions, variable names must begin with either a letter or an underscore, followed by zero or more letters, underscores, or digits.

A variable name consisting solely of underscores would not meet this requirement, and would therefore be considered invalid.

Additionally, using variable names consisting solely of underscores is not recommended even if it were allowed, as it can lead to confusion and make the code less readable. Variable names should be descriptive and give an indication of their purpose within the code.

What is the difference between _ and __ in variable names?

A variable name that starts with a single underscore, like _my_variable, is conventionally used to indicate that the variable is intended for private use within a class or module.

This means that the variable should not be accessed or modified outside the class or module in which it is defined, although there is no strict enforcement of this convention by the Python interpreter.

On the other hand, a variable name that starts with a double underscore, like __my_variable, is conventionally used to indicate that the variable is intended for internal use within a particular implementation of a class or module.

This means that the variable should not be accessed or modified outside the class or module in which it is defined, and the interpreter actually performs name mangling to modify the variable name to avoid naming conflicts with other classes or modules.

What is name mangling in Python?

Name mangling is a mechanism used by the Python interpreter to modify the names of certain class or instance variables that start with a double underscore (e.g. __my_variable).

This is done to avoid naming conflicts with other classes or modules, and to ensure that the variable can only be accessed through its own class or instance.

When a variable is defined with a double underscore prefix, the interpreter renames the variable by adding an underscore and the name of the class to the beginning of the variable name.

For example, a class named MyClass that defines a variable __my_variable will have that variable renamed to _MyClass__my_variable.

This name mangling effectively creates a unique name for the variable that is specific to the class in which it is defined.

This means that even if another class defines a variable with the same name, the two variables will not conflict with each other.

Additionally, name mangling ensures that the variable can only be accessed through its own class or instance, since attempting to access the variable using its original name (e.g. __my_variable) will result in an AttributeError.

Conclusion

We have seen that Python modules can indeed contain underscores in their names. In fact, underscores are commonly used in module names to separate words and improve readability, according to the naming conventions laid out in PEP 8.

However, it is important to note that modules with names that start with an underscore (e.g. _my_module) are conventionally used to indicate that the module is intended for internal use only, and should not be accessed or imported by code outside the package or module that contains it.

Additionally, module names that start with a double underscore (e.g. __my_module) will undergo name mangling and should be avoided.

Overall, when naming Python modules, it is important to follow the conventions laid out in PEP 8 and choose a name that accurately reflects the purpose and scope of the module. With these guidelines in mind, we can ensure that our modules are well-organized, easy to read, and compatible with the Python language and ecosystem.