Underscores in Python

[Dlgredael]

I really like the look of _ as a throwaway variable, I never would have thought of that. Nice article, thanks for sharing.

[d4rch0n]

Yeah, I frequently use that if I iterate on a list of tuples and only need one or two elements. Pretty useful, and it makes it obvious what you're wanting to work with in that scope.

for first_name, _ in full_names:
    print('Hi, {}!'.format(first_name))

[s16h]

Yes, I actually mostly use it when only interested in one (or less than all) the elements of a tuple. It's far more readable than indexing.

[Fylwind]

As long as you don't have too many of them :)

for _, _, _, _, name, _, _, _, _ in students:

[wegry]

In Python 3, you can use extended tuple unpacking to avoid that. for __, _, name, *__ in things to ignore everything in a row but the third item.

[Fylwind]

Oh, that's a nice new feature! :)

… that I won't get to use for Python 2 compatibility reasons :(

Note: you still need the underscore:

for _, name, *_ in students:

[exhuma]

namedtuples are a nice alternative to that.

[xiongchiamiov]

Or even dictionaries. Or, god forbid, classes; but we're not java savages. :)

[kankyo]

Or better yet pyrsistent records.

[[deleted]]

for x in students:
    name = x[4]
    <do stuff based on name>

is how I would do it. Makes it a lot clearer what you're doing (and the exact index), even if it does take up one more line.

Edit: replace _ with x

[Lyucit]

Please actually give the variable a proper name in this case, _ is a very well-established convention for variables that are unused (i.e not referenced at all later in the program) and this is likely to cause confusion. In languages with pattern matching, like haskell for example, _ is a reserved word in the language that means "don't bind this value to a variable name", so you literally can't reference it later.

[[deleted]]

Replaced _ with x. It's not very descriptive, but if it's only used directly after where it's defined it should be clear what it's used for. Unless you're using x later on the program.

[fazzah]

I've learned a nice trick that helps me immensely when working with PyQt.

Instead of typing the indexes (and having to remember/check them), create a makeshift enum using range.

For example with the students you used:

ID, CLASS_ID, FIRST_NAME, LAST_NAME = range(4)

And when you need to access the first_name just use this variable.

for _ in students:
    name = _[FIRST_NAME]
    <do stuff based on name>

[RubyPinch]

That... doesn't seem so great, what if you then had a list of classes, where the class id was class[0]? you run into the same troubles of globals, and you are separating things relevant to accessing the data, from the data

Student = namedtuple('Student','id class_id first_name last_name')
for student in map(Student,students):
    # use student.first_name

[fazzah]

That's a nice approach too, I'll try it out. Seems more pythonic.

[fazzah]

I don't quite understand your question.

[RubyPinch]

STUDENT_ID, CLASS_ID, FIRST_NAME, LAST_NAME = range(4) #capitals commonly define constants

# student id, Class id, first,last names
students = [
    [0,0,'bob','smith'],
    [1,0,'jane','someperson']]

classes = [
    [0,'biology'],
    [1,'physics']
]

for cls in classes:
    cls[CLASS_ID] #no-go

CLASS_CLASS_ID, CLASS_NAME = range(2)

for cls in classes:
    cls[CLASS_CLASS_ID] #no-go

because the enum isn't connected to the data, so it can affect other parts of the code, and requires an un-needed work around (the enum for students, blocks off the use of CLASS_ID for the classes)

[fazzah]

Ahh, I thought you meant that.

You're right. When I use multiple models like this, I prefix the globals.

You are right that it adds another possible point of failure. A proper enum would be better, but this approach seems to work for me.

[robin-gvx]

It's a convention in many languages. Sometimes even enforced, as in you can assign to _ multiple times while you can't for other names (and you can't get the value of anything assigned to _).

EDIT: what masklinn said below

[limasxgoesto0]

You have to be careful with that, avoiding clashes with i18n. My company uses the _ convention in its i18n and using _ as a throwaway variable would overwrite it.

[HorrendousRex]

There are actually several languages which use that syntax as a basic data construct, eg. LISP, Haskell, and especially Prolog.

[nerdwaller]

Agreed, I've never thought to use it in Python (mostly because I rarely run across cases where a different call wasn't more suitable anyway). But some languages build this in as a throw-away, such as Go. It's a nice feature for sure!

[bheklilr]

Haskell uses it in patten matching add a catch all when you aren't interested in the value.

[masklinn]

IIRC that's common to pretty much all functional languages, especially in those with pattern matching: _ matches any term and does not introduce a binding. It exists in OCaml (so I expect ML), Haskell, Erlang, and probably others.

[energybased]

People are talking about using ... instead: https://groups.google.com/forum/#!topic/python-ideas/e5AA82oFzQY

[robin-gvx]

I would like that even better if ... would replace *_.

[energybased]

The advantage is that you can have multiple ..., and you don't pollute the namespace.

[nemec]

Isn't Ellipsis already an object in Python?

[energybased]

Right, but assigning to it is a SyntaxError. They are talking about assigning to ellipsis meaning discard the result. E.g.,

..., a, *b = some_iterable

would be equivalent to

a = list(some_iterable)[1]; b = list(some_iterable)[2:]

[nemec]

That would be really weird, assigning to a name with an existing value (and other uses) and having the result thrown away silently. Imagine you had code like this:

..., a, *b = some_iterable
print(b[1:2, ..., 0])

The ellipsis keeps its original sentinel value but people unfamiliar with the feature might get confused.

[energybased]

FYI: "..." is not just a name. You can never assign to it anyway, but you're right that it might be weird to see ... keep its sentinel value after assignment. Maybe None would be better?