2

Variables and the keys in key-value pairs are both identifiers for values, so, on a conceptual level, these seem very similar ideas.

How would you explain the difference between these two concepts?

  • Is it that key-value pairs are used in collections?
  • Is it that variables point to a memory location?
  • Or something else?

(If I look at code, I'm instinctively aware of the difference, the question's more about how to explain it which doesn't seem too obvious given that they do similar things.)

7
  • This is first time I'm hearing someone thinks it is the same concept. – Euphoric Feb 24 '14 at 18:23
  • 9
    They operate in different domains. For most languages, variable names have meaning at design-time and compile-time, wheras key-value pair keys have meaning at run-time. – MetaFight Feb 24 '14 at 18:30
  • When you implement a key-value pair in your program, you use a variable to store the Key, and another variable to store the Value. – FrustratedWithFormsDesigner Feb 24 '14 at 18:33
  • 2
    @Euphoric: Well, in Python, they are the same concept. Instance variables are actually just entries in the instance variable dictionary, local variables are actually just entries in the locals dictionary, modules are actually just entries in the modules dictionary and so on. – Jörg W Mittag Feb 24 '14 at 23:14
  • 1
    @Euphoric: I'm not talking about the internal implementation of any specific Python runtime here. This is part of the language specification, and those dictionaries are exposed to the programmer. In fact, manipulating the modules or globals dictionaries is a common metaprogramming technique. – Jörg W Mittag Feb 25 '14 at 9:31
4

There is no real difference.

We can think of a variable as a name that maps to some value. All visible variables together make up the environment. This observation is important in some theoretical discussions, and is also used in some language implementations (mostly dynamic languages like Ruby). Especially objects can be represented in different ways – some may be choose static structs where an object member is a field in that struct (e.g. C++), others may use dynamic dictionaries which contain all members as key-value pairs (e.g. JavaScript).

The nice thing is that these are mostly equivalent to each other: you can see one as a generalization, the other as a performance optimization.

In sane languages, the environment is known at compile time, whereas the keys in some dictionary are generally only known at run time. This is the only useful difference: when the key of some mapping is known.

1

I wouldn't say that's exactly the case. I personally think of key-value pairs as tuples (a, b) : A * B in the mathematical sense as an element of a cartesian product A x B. Variables don't even come into the picture. The key is just the first component of the tuple. Just because a key can be used as a convenient handle to the entire tuple is incidental and you're confounding these two cases. You could just as easily flip the whole thing around and use the value to refer to the entire tuple.

4
  • In most "dictionary" type data structures I'm familiar with, "keys" must be unique, while identical "values" may appear associated with several different keys. In this case, I'm not sure how can " flip the whole thing around and use the value to refer to the entire tuple" – The Photon Feb 24 '14 at 20:11
  • In that case you can't but you're talking about dictionaries now and not key-value pairs. If I have a list of key-value pairs I can search through that list however I wish and deal with repetitions and non-uniqueness in all sorts of ways. A dictionary is a very restricted class of key-value pairs. The general case is just some subset of the cartesian product A x B. – davidk01 Feb 24 '14 at 21:11
  • I guess that is me over-interpreting the question. I had in mind that OP would not confuse variables and key-value pairs, unless they had the idea that you could use the key of the key-value pair to look up the value. And that would require not just the existence of some key-value pairs, but also that there is some collection of them in which to look things up. – The Photon Feb 24 '14 at 21:39
  • I think that's probably where the confusion is coming from. I was trying to explain that variables and key-value pairs are different things and in general there is no reason that the key in a key-value pair is anything special other than the first component of a tuple. – davidk01 Feb 24 '14 at 23:58
0

The difference depends on the context of the language. While there is a difference for compiled languages (variable names have meaning at compile-time, whereas keys have meaning at run-time), in Python there is no difference, as variable names are actually stored in a dict:

>>> foo
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'foo' is not defined
>>> globals()['foo'] = 'bar'
>>> foo
'bar'
>>> type(globals())
<class 'dict'>
0

Generally speaking, both are used like memory aliases. But, a variable more directly aliases a memory offset at compile time, and a key informs a memory mapping algorithm at runtime.

Conceptually, the primary difference is one of scope: Whether the alias operates at compile time versus runtime.

Functionally, the primary difference is one of runtime mutability (of all such aliases): Whether the collection of aliases can be changed at runtime. You can't compile your code and add Int32 xyz at runtime. But, you can add key xyz to a collection. (With some interpreted languages being an exception.)

Practically, the primary difference is lookup strategy and efficiency: Variables hold memory offsets. Using them is fast. Keys are piped through a lookup algorithm that, comparatively speaking, eventually determines a memory offset and returns its contents.

Lots of work is done at runtime to make keys work. Variables are sort of just there.

This all assumes you're referring to keys in the context of a collection. You can certainly have key-value pairs that have nothing to do with collections or finding things in memory. But, the keys in that context are far enough removed functionally that ... well ... I'm just assuming the question isn't referring to that.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.