Das deutsche Python-Forum

Code: Alles auswählen

def dez255ToBin(dez):
    ret = ""
    for hochX in (7,6,5,4,3,2,1,0):
        ret += "%d"%((dez & 2**hochX) > 0)
    return ret
    
print dez255ToBin(42)

Code: Alles auswählen

def dual(zahl):
    zahl=int(zahl)
    erg=''
    while zahl != 0:
        erg=str(zahl%2)+erg
        zahl=zahl/2
    return erg

def decimal(zahl):
    zahl=str(zahl)
    erg=0
    laenge=len(zahl)
    for i in xrange(laenge):
        erg+=int(zahl[i])*(2**(laenge-i-1))
    return str(erg)

Code: Alles auswählen

#!/usr/bin/env python
# $Id: BinaryTools.py,v 1.3 2003/03/11 13:22:30 joerg Exp $
import operator

version = '0.42'

# the value of a bit will not be calculated every time it is needed
# but stored in a cache list.
# initial cache for bitvalues, may be enlarged
_bitcache = map(lambda b: 2 ** b, range(32))


def _enlarge_bitcache(n):
    """enlarges internal _bitcache, will be called automatically.
    There's no need to call this function from outside"""
    for b in range(len(_bitcache), n):
        _bitcache.append(2 ** b)


def bit(i):
    """convert values to 0 or 1, depending on the truth value"""
    if i: return 1
    else: return 0


def bitsize(x, s=0):
    """give required bitsize to store the value x, s is the minimum size"""
    while x > (2 * _bitcache[-1] - 1):
        _enlarge_bitcache(len(_bitcache)+1)
    while s < len(_bitcache) and x > (2 * _bitcache[s] - 1):
        s += 1
    return s + 1


def bitmap(x, n=8):
    """return a bitlist from integer x, using n bits"""
    if n < len(_bitcache):
        _enlarge_bitcache(n)
    return map(lambda b: bit(x & b), _bitcache[:n])


def bstrip(l):
    """strip highest bits if not set"""
    s = l[:]
    while not s[-1]:
        del s[-1]
    return s


def ivalue(l):
    """return an integer from bitlist"""
    if len(l) > len(_bitcache):
        _enlarge_bitcache(len(l))
    return reduce(operator.add, map(lambda a, b: bit(a) * b, l, _bitcache[:len(l)]))


def bitstr(l):
    """return bitmap as string of zeros and ones"""
    return ''.join(map(str, l))


if __name__ == '__main__':
    print "\nThis is BinaryTools, version %s." % version

    # test overflow
    print "\nUsing 8 bit (default), will overflow at 256:"
    for x in range(250, 260):
        y = bitmap(x)
        z = ivalue(y)
        print '%3d -> %s -> %3d' % (x, bitstr(y), z)

    # test larger bitsize
    print "\nUsing 10 bit to cover larger values:"
    for x in range(250, 260):
        y = bitmap(x, 10)
        z = ivalue(y)
        print '%3d -> %s -> %3d' % (x, bitstr(y), z)

    # test bitlen
    print "\nRequired bitsize for numbers:"
    for x in range(1, 10):
        print "%d needs %d bit%c (%s)" % (x, bitsize(x), x==1 and ' ' or 's',
                                          bitstr(bstrip(bitmap(x))))

    # test large numbers
    print "\nNow testing real large numbers..."
    x = long('1234567890'*30)
    l = bitsize(x)
    b = bitmap(x, l)
    print "The number %d\nneeds %d bits, and has a binary representation of:\n%s" % (x, l, bitstr(b))
    if not ivalue(b) == x:
        raise Exception("Error during conversion")

Code: Alles auswählen

import math
import string
 
def eingabe2():

def dez2dual(dezimalzahl):

def ausgabe2(inv_dual_liste):
    while len(inv_dual_liste)<8:
        inv_dual_liste.append("0")
    inv_dual_liste.reverse()

    bytedarstellung=""
    for i in range(0,len(inv_dual_liste)):
        bytedarstellung = bytedarstellung + str(inv_dual_liste[i])

    print "Dualzahl: ", bytedarstellung

# Hauptprogramm