What is the purpose of the single underscore “_” variable in Python?

Question

What is the meaning of _ after for in this code?

if tbh.bag:
   n = 0
   for _ in tbh.bag.atom_set():
      n += 1

Answer 1

_ has 5 main conventional uses in Python:

1. To hold the result of the last executed expression(/statement) in an interactive interpreter session. This precedent was set by the standard CPython interpreter, and other interpreters have followed suit
2. As a general purpose "throwaway" variable name to indicate that part of a function result is being deliberately ignored (Conceptually, it is being discarded.), as in code like: label, has_label, _ = text.partition(':').
3. As part of a function definition (using either def or lambda), where the signature is fixed (e.g. by a callback or parent class API), but this particular function implementation doesn't need all of the parameters, as in code like: callback = lambda _: True
4. The python linter recognizes the underscore as a purposefully unused variable (both use cases above). For example year,month,day = date() will raise a lint warning if the day variable is not used later on in the code, the fix if the day is truly not needed is to write year,month,_ = date(). Same with lambda functions, lambda arg: 1.0 is creating a function requiring one argument but not using it, that will be caught by lint, the fix is to write lambda _: 1.0. An unused variable is often hiding a bug/typo (set day but used dya the next line).
5. For translation lookup in i18n (see the gettext documentation for example), as in code like raise forms.ValidationError(_("Please enter a correct username")).

    # the usage of underscore in translation comes from examples in the doc
    # that have been copy/pasted over decades, like this one:
    import gettext
    gettext.bindtextdomain('myapplication', '/path/to/my/language/directory')
    gettext.textdomain('myapplication')
    _ = gettext.gettext
    # ...
    print(_('This is a translatable string.'))

2019 update: Added lambda. For a long time this answer only listed three use cases, but the lambda case came up often enough, as noted here, to be worth listing explicitly

2020 update: Added lint. Surprised nobody has highlighted this because it's common to have lint checks enforced on CI, flagging unused variables and potentially failing the build with a hard error if strict.

The latter "throwaway variable or parameter name" uses cases can conflict with the translation lookup use case, so it is necessary to avoid using _ as a throwaway variable in any code block that also uses it for i18n translation (many folks prefer a double-underscore, __, as their throwaway variable for exactly this reason).

Answer 2

As far as the Python languages is concerned, _ has no special meaning. It is a valid identifier just like _foo, foo_ or _f_o_o_.

Any special meaning of _ is purely by convention. Several cases are common:

• A dummy name when a variable is not intended to be used, but a name is required by syntax/semantics.

  # iteration disregarding content
  sum(1 for _ in some_iterable)
  # unpacking disregarding specific elements
  head, *_ = values
  # function disregarding its argument
  def callback(_): return True
  

• Many REPLs/shells store the result of the last top-level expression to builtins._.

  The special identifier _ is used in the interactive interpreter to store the result of the last evaluation; it is stored in the builtins module. When not in interactive mode, _ has no special meaning and is not defined. [source]

  Due to the way names are looked up, unless shadowed by a global or local _ definition the bare _ refers to builtins._ .

  >>> 42
  42
  >>> f'the last answer is {_}'
  'the last answer is 42'
  >>> _
  'the last answer is 42'
  >>> _ = 4  # shadow ``builtins._`` with global ``_``
  >>> 23
  23
  >>> _
  4
  

  Note: Some shells such as ipython do not assign to builtins._ but special-case _.

• In the context internationalization and localization, _ is used as an alias for the primary translation function.

  gettext.gettext(message)

  Return the localized translation of message, based on the current global domain, language, and locale directory. This function is usually aliased as _() in the local namespace (see examples below).

Answer 3

Underscore _ is considered as "I don't Care" or "Throwaway" variable in Python

• The python interpreter stores the last expression value to the special variable called _.

  >>> 10 
  10
  
  >>> _ 
  10
  
  >>> _ * 3 
  30
  

• The underscore _ is also used for ignoring the specific values. If you don’t need the specific values or the values are not used, just assign the values to underscore.

  Ignore a value when unpacking

  x, _, y = (1, 2, 3)
  
  >>> x
  1
  
  >>> y 
  3
  

  Ignore the index

  for _ in range(10):     
      do_something()
  

Answer 4

There are 5 cases for using the underscore in Python.

1. For storing the value of last expression in interpreter.

2. For ignoring the specific values. (so-called “I don’t care”)

3. To give special meanings and functions to name of vartiables or functions.

4. To use as ‘Internationalization(i18n)’ or ‘Localization(l10n)’ functions.

5. To separate the digits of number literal value.

Here is a nice article with examples by mingrammer.

Answer 5

It's just a variable name, and it's conventional in python to use _ for throwaway variables. It just indicates that the loop variable isn't actually used.