I am new to Python. Here's what I am trying to do:
Here is what I have so far:
def traverse(R):
x = 0
while x < (len(R) - 3):
row = R[x] + R[x+1] + R[x+2]
???
Thanks for your help! It is greatly appreciated.
Something like this should do it:
s = "110101001"
numbers = [int(s[i:i+3], 2) for i in range(0, len(s), 3)]
print numbers
The output is:
[6, 5, 1]
Breaking this down step by step, first:
>>> range(0, len(s), 3)
[0, 3, 6]
The range() function produces a list of integers from 0, less than the max len(s), by step 3.
>>> [s[i:i+3] for i in range(0, len(s), 3)]
["110", "101", "001"]
This is a list comprehension that evaluates s[i:i+3] for each i in the above range. The s[i:i+3] is a slice that selects a substring. Finally:
>>> [int(s[i:i+3], 2) for i in range(0, len(s), 3)]
[6, 5, 1]
The int(..., 2) function converts from binary (base 2, second argument) to integers.
Note that the above code may not properly handle error conditions like an input string that is not a multiple of 3 characters in length.
I'll assume that by "binary string" you actually mean a normal string (i.e. text) whose items are all '0' or '1'.
So for points 1 and 2,
row = [thestring[i:i+3] for i in xrange(0, len(thestring), 3)]
of course the last item will be only 1 or 2 characters long if len(thestring) is not an exact multiple of 3, that's inevitable;-).
For points 3 and 4, I'd suggest building an auxiliary temp dictionary and storing it:
aux = {}
for x in range(8):
s = format(x, 'b')
aux[s] = x
aux[('00'+s)[-3:]] = x
so that points 3 and 4 just become:
numbers = [aux[x] for x in row]
this dict lookup should be much faster than converting each entry on the fly.
Edit: it's been suggested I explain why am I making two entries into aux for each value of x. The point is that s may be of any length from 1 to 3 characters, and for the short lengths I do want two entries -- one with s as it it (because as I mentioned the last item in row may well be shorter than 3...), and one with it left-padded to a length of 3 with 0s.
The sub-expression ('00'+s)[-3:] computes "s left-padded with '0's to a length of 3" by taking the last 3 characters (that's the [-3:] slicing part) of the string obtained by placing zeros to the left of s (that's the '00'+s part). If s is already 3 characters long, the whole subexpression will equal s so the assignment to that entry of aux is useless but harmless, so I find it simpler to not even bother checking (prepending an if len(s)<3: would be fine too, matter of taste;-).
There are other approaches (e.g. formatting x again if needed) but this is hardly the crux of the code (it executes just 8 times to build up the auxiliary "lookup table", after all;-), so I didn't pay it enough attention.
...nor did I unit-test it, so it has a bug in one obscure corner case. Can you see it...?
Suppose row has '01' as the last entry: THAT key, after my code's above has built aux, will not be present in aux (both 1 and 001 WILL be, but that's scanty consolation;-). In the code above I use the original s, '1', and the length-three padded version, '001', but the intermediate length-two padded version, oops, got overlooked;-).
So, here's a RIGHT way to do it...:
aux = {}
for x in range(8):
s = format(x, 'b')
aux[s] = x
while len(s) < 3:
s = '0' + s
aux[s] = x
...no doubt simpler and more obvious, but, even more importantly, CORRECT;-).
Wouldn't this be easier:
(I wanted an array of the upper 3 bits of a variable that contained the integer 29)
format your variables and arrays first
a = ''
b = []
I stole this from a really good example in this forum, it formats the integer 29 into 5 bits, bits zero through four and puts the string of bits into the string variable "a". [edited] Needed to change the format from 0:5b to 0:05b, in order to pad zeros when the integer is < 7.
a = '{0:05b}'.format(29)
look at your string variable
a
'11101'
split your string into an array
b[0:3] = a[0:3]
this is exactly what I wanted.
b
['1', '1', '1']
If you're dealing with processing raw data of any kind, I'd like to recommend the excellent bitstring module:
>>> import bitstring
>>> bits = bitstring.Bits('0b110101001')
>>> [b.uint for b in bits.cut(3)]
[6, 5, 1]
Description from the home page:
A Python module that makes the creation, manipulation and analysis of binary data as simple and natural as possible.
Bitstrings can be constructed from integers, floats, hex, octal, binary, bytes or files. They can also be created and interpreted using flexible format strings.
Bitstrings can be sliced, joined, reversed, inserted into, overwritten, etc. with simple methods or using slice notation. They can also be read from, searched and replaced, and navigated in, similar to a file or stream.
Internally the bit data is efficiently stored in byte arrays, the module has been optimized for speed, and excellent code coverage is given by over 400 unit tests.
Great answers from Greg and Alex! List comprehensions and slicing are so pythonic! For short input strings I wouldn't bother with the dictionary lookup trick, but if the input string were longer, I would, as well as using gen-exps rather than list-comps, i.e.:
row = list(thestring[i:i+3] for i in xrange(0, len(thestring), 3))
and
numbers = list(aux[x] for x in row)
since gen-exp perform better.
list(genexp) (potentially by a sigificant factor) and should generally be preferred when both forms are possible and "obvious".