You will find max six different uses of underscore(_). If you want you can use it for different purposes after you have an idea about underscore(_).
Let's all the uses briefly with examples.1. Use In Interpreter Python automatically stores the value of the last expression in the interpreter to a particular variable called "_." You can also assign these value to another variable if you want. To hold the result of the last executed expression in an interactive interpreter session. You can use it as a normal variable. See the example
>>> 5 + 4 9 >>> _ # stores the result of the above expression 9 >>> _ + 6 15 >>> _ 15 >>> a = _ # assigning the value of _ to another variable >>> a 15
2. Ignoring Values
Underscore(_) is also used to ignore the values. If you don't want to use specific values while unpacking, just assign that value to underscore(_).
Ignoring means assigning the values to special variable underscore(_). We're assigning the values to underscore(_) given not using that in future code.
See the example
## ignoring a value a, _, b = (1, 2, 3) # a = 1, b = 3 print(a, b) ## ignoring multiple values ## *(variable) used to assign multiple value to a variable as list while unpacking ## it's called "Extended Unpacking", only available in Python 3.x a, *_, b = (7, 6, 5, 4, 3, 2, 1) print(a, b)
3. Use In Looping
You can use underscore(_) as a variable in looping. See the examples below to get an idea.
## lopping ten times using _ for _ in range(5): print(_) ##output: 0,1,2,3,4 ## iterating over a list using _ ## you can use _ same as a variable languages = ["Python", "JS", "PHP", "Java"] for _ in languages: print(_) _ = 5 while _ < 10: print(_, end = ' ') # default value of 'end' id '\n' in python. we're changing it to space _ += 1
4. Separating Digits Of Numbers
If you have a long digits number, you can separate the group of digits as you like for better understanding.
Ex:- million = 1_000_000
Next, you can also use underscore(_) to separate the binary, octal or hex parts of numbers.
Ex:- binary = 0b_0010, octa = 0o_64, hexa = 0x_23_ab
Execute all the above examples to see the results.
## different number systems ## you can also check whether they are correct or not by coverting them into integer using "int" method million = 1_000_000 binary = 0b_0010 octa = 0o_64 hexa = 0x_23_ab print(million) ##output: 1000000 print(binary) ##output:2 print(octa) ##output: 52 print(hexa) ##output 9131
5. Naming Using Underscore(_)
Underscore(_) can be used to name variables, functions and classes, etc..,
- Single Pre Underscore:- _variable
- Signle Post Underscore:- variable_
- Double Pre Underscores:- __variable
- Double Pre and Post Underscores:- __variable__
Single Pre Underscore is used for internal use. Most of us don't use it because of that reason.
See the following example.
class Test: def __init__(self): self.name = "datacamp" self._num = 7 obj = Test() print(obj.name) ##output: datacamp print(obj._num) ##output: 7
single pre underscore doesn't stop you from accessing the single pre underscore variable.
But, single pre underscore effects the names that are imported from the module.
Let's write the following code in the my_funtions file.
## filename:- my_functions.py def func(): return "datacamp" def _private_func(): return 7
Now, if you import all the methods and names from my_functions.py, Python doesn't import the names which starts with a single pre underscore.
You avoid the above error by importing the module normally:
>>> from my_functions import * >>> func() 'datacamp' >>> _private_func() Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name '_private_func' is not defined
>>> import my_functions >>> my_functions.func() 'datacamp' >>> my_functions._private_func() 7
Single Pre Underscore is only meant to use for the internal use.
Sometimes if you want to use Python Keywords as a variable, function or class names, you can use this convention for that.
You can avoid conflicts with the Python Keywords by adding an underscore at the end of the name which you want to use.
Let's see the example.
>>> def function(class): File "<stdin>", line 1 def function(class): ^ SyntaxError: invalid syntax >>> def function(class_): ... pass ... >>>
Single Post Underscore is used for naming your variables as Python Keywords and to avoid the clashes by adding an underscore at last of your variable name.
5.3. Double Pre Underscore
Double Pre Underscores are used for the name mangling.
Double Pre Underscores tells the Python interpreter to rewrite the attribute name of subclasses to avoid naming conflicts.
- Name Mangling:- interpreter of the Python alters the variable name in a way that it is challenging to clash when the class is inherited.
It's way more complext, not worthy the time to deal with that.
5.4. Double Pre And Post Underscores
In Python, you will find different names which start and end with the double underscore. They are called as magic methods or dunder methods.
class Sample(): def __init__(self): self.__num__ = 7 obj = Sample() obj.__num__
This will lead to the clashes if you use these methods as your variable names. So, it's better to stay away from them.