0

I'm working through a book called "Head First Programming," and there's a particular part where I'm confused as to why they're doing this.
There doesn't appear to be any reasoning for it, nor any explanation anywhere in the text.

The issue in question is in using multiple-assignment to assign split data from a string into a hash (which doesn't make sense as to why they're using a hash, if you ask me, but that's a separate issue). Here's the example code: 

line = "101;Johnny 'wave-boy' Jones;USA;8.32;Fish;21"
s = {}
(s['id'], s['name'], s['country'], s['average'], s['board'], s['age']) = line.split(";")

I understand that this will take the string line and split it up into each named part, but I don't understand why what I think are keys are being named by using a string, when just a few pages prior, they were named like any other variable, without single quotes.
The purpose of the individual parts is to be searched based on an individual element and then printed on screen. For example, being able to search by ID number and then return the entire thing.

The language in question is Python, if that makes any difference. This is rather confusing for me, since I'm trying to learn this stuff on my own.
My personal best guess is that it doesn't make any difference and that it was personal preference on part of the authors, but it bewilders me that they would suddenly change form like that without it having any meaning, and further bothers me that they don't explain it.

EDIT: So I tried printing the id key both with and without single quotes around the name, and it worked perfectly fine, either way. Therefore, I'd have to assume it's a matter of personal preference, but I still would like some info from someone who actually knows what they're doing as to whether it actually makes a difference, in the long run.

EDIT 2: Apparently, it doesn't make any sense as to how my Python interpreter is actually working with what I've given it, so I made a screen capture of it working https://www.youtube.com/watch?v=52GQJEeSwUA

Improve this question
5
  • 1
    Do they really call {} a hash? It's a dict. Hash is the Perl term. Commented Aug 23, 2013 at 9:25
  • 1
    Are you asking us to tell you why the authors write this specific example, based on other examples that you did not quote in your question? There is not much we can tell you. the assigning line is doing multiple assignments to the dict. Nothing special there except combining tuple-unpacking with item assignment. Commented Aug 23, 2013 at 9:25
  • My question is why the (s['id'], s['name'], s['country'], s['average'], s['board'], s['age']) = line.split(";") line puts single quotes around the bits between brackets, when this is obviously not necessary. Commented Aug 23, 2013 at 9:29
  • 1
    @AndrewMcFain Because it is needed. Try it and you'll receive a NameError if you don't. Commented Aug 23, 2013 at 9:30
  • I believed you when you said that using s[id] gave you the same result as s['id'], but that's only because id just, at random, happened to be a built-in Python object that could somehow be used as a dictionary key (in this case a built-in function) and moreover somehow managed to line up with what s['id'] was giving you when used as such. However, what I posted below does explain why one uses quotes or doesn't use quotes in Python, and I hope that explanation helps. Commented Aug 23, 2013 at 9:44

2 Answers 2

Reset to default
2

I don't understand why what I think are keys are being named by using a string, when just a few pages prior, they were named like any other variable, without single quotes

The answer is right there. If there's no quote, mydict[s], then s is a variable, and you look up the key in the dict based on what the value of s is.

If it's a string, then you look up literally that key.

So, in your example s[name] won't work as that would try to access the variable name, which is probably not set.

EDIT: So I tried printing the id key both with and without single quotes around the name, and it worked perfectly fine, either way.

That's just pure luck... There's a built-in function called id:

>>> id
<built-in function id>

Try another name, and you'll see that it won't work.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Okay, tried it with another one and it didn't work, so you're right. How odd that they don't explain that anywhere in the book. Makes me question the overall quality, considering how they're using the wrong terms and then not explaining why they're doing something that makes a huge difference.
2

Actually, as it turns out, for dictionaries (Python's term for hashes) there is a semantic difference between having the quotes there and not.

For example:

s = {}
s['test'] = 1
s['othertest'] = 2

defines a dictionary called s with two keys, 'test' and 'othertest.' However, if I tried to do this instead:

s = {}
s[test] = 1

I'd get a NameError exception, because this would be looking for an undefined variable called test whose value would be used as the key.

If, then, I were to type this into the Python interpreter:

>>> s = {}
>>> s['test'] = 1
>>> s['othertest'] = 2
>>> test = 'othertest'
>>> print s[test]
2
>>> print s['test']
1

you'll see that using test as a key with no quotes uses the value of that variable to look up the associated entry in the dictionary s.

Edit: Now, the REALLY interesting question is why using s[id] gave you what you expected. The keyword "id" is actually a built-in function in Python that gives you a unique id for an object passed as its argument. What in the world the Python interpreter is doing with the expression s[id] is a total mystery to me.

Edit 2: Watching the OP's Youtube video, it's clear that he's staying consistent when assigning and reading the hash about using id or 'id', so there's no issue with the function id as a hash key somehow magically lining up with 'id' as a hash key. That had me kind of worried for a while.

Improve this answer

7 Comments

Yeah, that it does that is strange and probably undesirable behavior, but the fact that passing a random built-in function as a hash key somehow produces the same result as passing a string in with the name of that function doesn't really say much other than that you can wind up getting strange behavior from the interpreter when you use predefined identifiers you didn't know existed.
@Andrew: You change the key both when storing the value and when accessing it. Of course the result will be the same!
aha thanks Junuxx, I missed that. The fact remains that using a string that isn't defined, without quotes, will produce a NameError exception.
Yeah, I tried it with one of the other values, and it failed. How confusing!
Andrew: There is something useful to carry away from this though, which is that you don't have to use basic built-in types as dictionary keys! You can use things like tuples as dictionary keys, or (as in your youtube video) even a built-in Python function. While in this case the name id was already defined and caused all kinds of confusion, that you can use almost anything as a dictionary key can be really handy when you want to come up with creative uses for dictionaries.
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.