Fråga om Python uppgift

def dec2bin(värde, antal_bitar):
    if värde > 1:
        dec2bin(värde // 2)
    print(värde % 2, end = '')
    
    bitvärde = 2 ** (antal_bitar - 1)
    
    if värde >= bitvärde:
        print('1')
        värde = värde - bitvärde  
    else:
        print('0')
    
        antal_bitar = antal_bitar - 1

För att kolla om bit bit_pos är satt hos value, gör detta

    if (1 << bit_pos) & value != 0:
        # bit 2^bit_pos är satt i value
    else:
        # bit 2^bit_pos är inte satt i value

Vet inte om ni har gått igenom for-loopar och liknande, är i alla fall möjligt att gå igenom alla bitar upp till bit_width på detta sätt

    for bit_pos in reversed(range(bit_width)):
        # bit_pos kommer här vara 3, 2, 1, 0 om bit_width är 4

Edit: Ser att du använt rekursiva anrop ovan, är möjligt att skriva ovan så här

def for_bit_pos_msb_to_lsb(value, bit_pos):
    if bit_pos >= 0:
        if (1 << bit_pos) & value != 0:
            # bit_pos är satt
        else:
            # bit_pos är inte satt
        for_bit_pos_msb_to_lsb(value, bit_pos - 1)

Det finns flera sätt att lösa uppgiften, listar bara några exempel på byggstenar ovan. En möjlighet är att låta dec2bin() anropa en hjälpfunktion som i sin tur är rekursiv. Men är möjligt att lösa problemet enbart med dec2bin().

Uppgiften nämner att ni gått igenom binära tal och digitalteknik (gissar att det innefattar logiska operationer på bitnivå), i så fall borde du har flera verktyg att reda ut om en viss bit är satt eller ej från Python-kod. Även här finns flera sätt att lösa det hela.

Ett exempel, som du inte ska kopiera då det är en dålig idé att rekursivt hantera indata som leder till okänt rekursionsdjup (i alla fall i språk likt Python som inte dynamiskt kan växa anropsstacken) samt att den inte fixar talet 0, där man endast tittar på minst signifikanta biten och använder sig av bit-shift för att hantera godtyckligt stora tal

def dec2bin(value):
    if value > 0:
        dec2bin(value >> 1)
        print('0' if value & 1 == 0 else '1', end='')

Du kan ju alltid fixa till denna så den hanterar bitbredd 8 samt 16, i det läget är rekursion helt OK då djupet är begränsat till ett rimligt djup.

def dec2bin(value):
    if value > 0:
        dec2bin(value >> 1)
        print('0' if value & 1 == 0 else '1', end='')

Här kommer ett annat exempel utan rekursion:

def dec2bin(varde, antal_bitar):
    mask = 1 << antal_bitar-1
    for x in range (antal_bitar):
        if (varde & mask):
            print('1',end='')
        else:
            print('0',end='')
        mask = mask >> 1
    print(' ')

Nu är det lite knepigt att se vad koden gör eftersom den inte är korrekt indenterad. Du borde ha code-taggar runt.

[code]
din kod
[/code]

Om koden i sig kan jag säga att du tänkt rätt och är på god väg, men...

Funktionen dec2bin räknar ut om det skall vara en etta eller nolla, och skriver ut den siffran, men när du använder dig av dec2bin ser det ut som att du vill att den skall returnera ett värde snarare än att skriva ut det.

När du kollat om invarde är korrekt så tilldelar du bitvarde funktionen dec2bin (japp, det kan man göra i Python). Jag tror att du vill anropa funktionen istället: bitvarde = dec2bin(invarde, 8)

Själva idèn för konvertering av decimala tal till binära är inte svår så jag tror inte det är fokus i uppgiften.

Algoritmen är välkänd, omvandla decimala talet 10 till binär form

 n | heltalsdelat med 2 | spara resten
10 |        => 5        | => 0
 5 |        => 2        | => 1
 2 |        => 1        | => 0
 1 |                    | => 1

Skriv ut resterna i omvänd ordning: 1010

Ett exempel till, 77:

 n | heltalsdelat med 2 | spara resten
77 |        => 38       | => 1
38 |        => 19       | => 0
19 |        =>  9       | => 1
 9 |        =>  4       | => 1
 4 |        =>  2       | => 0
 2 |        =>  1       | => 0
 1 |                    | => 1

Skriv ut resterna i omvänd ordning: 1001101

En idé vore att börja med en tom text och sedan för varje siffra man får fram, lägga den som ett tecken först i texten och sedan fylla på nollor längst fram i texten tills textens längd är en multipel av 8. Det blir en ganska kort kod (här som pseudokod):

Skapa txt som en tom textvariabel
Så länge som n är större än 1
    sätt n till n heltalsdividerat med 2
    sätt resten vid divisionen som text först i txt
Lägg det som blev kvar av n först i txt
(alltid en etta om inte n från början var 0) 
Så länge txt:s längd inte är jämt delbar med 8
    fyll ut med noll i början av txt
Skriv ut txt

Följande lilla testprogram visar att min idé fungerar

for n in [10, 77, 255, 256, 234321]:
    print('decimal:', n, '=> binary:', end=' ')
    dec2bin(n)

och ger utskriften:

decimal:     10 => binary: 00001010
decimal:     77 => binary: 01001101
decimal:    255 => binary: 11111111
decimal:    256 => binary: 0000000100000000
decimal: 234321 => binary: 000000111001001101010001

och visar att det inte spelar någon roll hur stort tal man skickar till dec2bin.
EDIT: Jag har editerat utskriften, den blir inte lika snyggt formaterad direkt från progammet.