Get MAC address of current interface in one line of code (Python recipe) by Leonid Vasilyev

ActiveState Code (http://code.activestate.com/recipes/578277/)

This would appear as a bad idea, for the following reasons:

1. The value returned may turn out to be not useful in the intended sense - it may as return unintended values e.g., the MAC address of a Bluetooth interface or even virtual interfaces ("Microsoft ISATAP Adapter"),
2. If a computer has no interfaces with MAC address, uuid.getnode() will return a random return value), which will change from run to run.
3. If a computer has several interfaces with MAC address, it may still return inconsistent values between runs (e.g., due to initialization of virtual interfaces in different orders)
4. For almost any need involving MAC addresses, a scenario exists wherein the change of the address at some point in time will cause breakage to the application.

If I may suggest advise to an engineer that needs to fetch the MAC address, I'd advise him to:

1. If he/she needs a transient unique value, I'd suggest generating it using uuid.
2. If he/she needs a stationary unique value, I'd suggest generating it once during application deployment using uuid and storing it as part of the application data.
3. If he/she needs a computer fingerprint, it is a much more complicated, platform-dependent endeavour; CPUID is probably a decent way of doing it on x86 and there's a library for that;
4. Finally, if a programmer needs to get MAC addresses for all of the interfaces of the computer, it asks for a library that would take care of the problems above by describing the problem domain (e.g., a set of Layer2Interface each with an Address property); such a library would necessarily be at least several hundred LOCs big and be platform dependent; if you (the reader) happen to be implementing it, I'd implore you to publish it open-source. (I'm considering doing it now, but I have no concrete needs for it, and I'd need to have at least one specific use case in front of me to know I'm creating something usable).

This code is not intended for production use, nor it is intended to work across all the variety of available platforms. What I'm showing here is just a one-line hack, which I found useful in some cases.

Splitting a string to chunks of some fixed length is easy and readable using the re module:

import re, uuid
print ':'.join(re.findall('..', '%012x' % uuid.getnode()))

Wow, this is cool I didn't knew that. Thanks Oren!