Hjälp med Python uppgift, rekursivt. Nybörjare

Rekursion består alltid av 3 delar

1. villkor när du är "färdig"

2. utföra operationen på första elementet du har just nu

3. anropa dig själv med det första elementet borttaget

I ditt fall är du färdig när du anropar funktionen med en tom sträng. Så skriv den delen först. Tänk också igenom vad du bör retunera om du kommit till slutet på strängen.

Att ta hand om ett element i ditt fall blir att avgöra om första tecknet är en bokstav, siffra eller mellanslag. Är första tecknet inte något av dessa tre, vet du då inte vad funktionen ska retunera som helhet?

Annars, ta bort första bokstaven och retunera resultatet av anrop dig själv med den kvarvarande strängen.

Detta är funktionen skriven på svenska, nu får du skriva den i Python

Edit: Hehe, jag läste definitivt inte problembeskrivning ordentligt. Har fixat min "implementation" nu

Något som är grundläggande i programmering är att bryta ned ett stort problem i mindre delproblem tills delproblemen är så små att deras lösning är trivial.

För att se om en sträng består av uteslutande alfanumeriska tecken skulle nog få programmerare välja en rekursiv algoritm, men det är oväsentligt då din uppgift kräver det.

En mer rättfram iterativ approach skulle ställa frågorna "Är det första tecknet alfanumeriskt?", "Om ja, är det andra tecknet alfanumeriskt?", "Om ja, är det tredje tecknet alfanumeriskt?" o.s.v. till strängen är slut (eller svaret blir "nej").

Rekursivt skulle frågan snarare ställas "Är det första tecknet alfanumeriskt?", "Om ja, är resten av strängen alfanumerisk?" och sedan upprepa dessa frågor till strängen tar slut (eller svaret blir "nej").

Du behöver inte len för en rekursiv lösning (men du kan använda det när du kollar om strängen är tom).

Normalt kunde man löst uppgiften med

def is_alphanumeric(s)
    if len(s) > 0:
        for x in range(0, len(s)-1):
            if not (s[x].isalpha() or s[x].isdigit() or s[x].isspace()):
                return False
     return True

men den lösningen är inte rekursiv.

Rekursivt innebär att du använder samma funktion (d.v.s. ställer samma fråga/frågor) på en mindre del av problemet. Tänk dig att du skall kolla strängen "Alfa", då kan du minska problemet genom att kolla strängarna "A" och "lfa". Strängen "A" är trivial, och för att kolla "lfa" kan du minska problemet genom att kolla "l" och "fa" etc. Hoppas jag inte gett dig för mycket hjälp nu, men jag antar att det viktigaste är att du lär dig konceptet rekursion.

Om du tänker på basvillkoret så kan kontrollen om listan är tom göras med "if not s" istället för att kontrollera att strängens längd är noll (python definierar en tom sträng som False och en icke-tom som True...om jag inte missminner mig).

@TS: Att använda len faller sig ganska naturligt, om än inte nödvändigt, i ditt fall (så ignorera vad jag skrev till VirtualIntent). Du har dock ingen större nytta av att veta längden på det du skrev in i det allmänna fallet, du behöver bara veta om/när längden är noll.

Behöver du ytterligare hjälp så säg bara till. Rekursion (anrop till sig själv / definition i termer av sig själv) kan vara klurigt i början.

Vad ska funktionen returnera när den får in ""?

När funktionen får in en tom sträng ("") bör den returnera True. Om man till en alfanumerisk sträng lägger till en tom sträng så måste den resulterande strängen också vara alfanumerisk då den är identisk med den initiala strängen (Exempel: "Alfa" + "" = "Alfa"). Detta uppnås endast om en tom sträng definieras som alfanumerisk.

Intressant tanke, jag förstår hur du tänker men tycker fortfarande det är mer logiskt att slänga exception. En alfanumerisk sträng är enligt den givna definitionen "en sträng som bara innehåller bokstäver, siffror och mellanslag". En tom sträng innehåller inget av det.

edit: det backas även upp av att "".isalpha() och "".digit() returnerar false

Att slänga en exception slår mig som det minst logiska då en tom sträng är en sträng. Att "".isalpa() och "".isdigit() returnerar False istället för att kasta exceptions visar helt klart att "" är en sträng. is_alphanumeric() bör således returnera True eller False när den matas med en tom sträng.

Om isdigit() definieras som sant för "en sträng som innehåller siffror" blir "".isdigit() False.
Om isdigit() definieras som sant för "en sträng som inte innehåller icke-siffror" blir "".isdigit() True.

Om du kollar documentationen för isdigit() står att läsa: "It return true if all characters in the string are digits and there is at least one character, false otherwise.". De har alltså valt den översta definitionen

Efter att ha funderat lite får jag lov att hålla med dig angående exception. Min ursprungliga tanke var att en tom sträng vare sig är eller "inte-är" en alfanumerisk sträng, om man definierar att en sådan endast får innehålla tecken som antingen är siffror, bokstäver eller mellanslag — "inget innehåll" är vare sig en siffra, bokstav eller ett mellanslag.

Däremot tycker jag fortfarande det är felaktigt att låta funktionen returnera true för tom sträng och vidhåller att man bör använda antingen len eller något liknande.

*Fullständiga svar borttagna*

Det finns ingen explicit regel mot att ge fullt svar så jag kan inte hänvisa till någon fin paragraf, och anser inte att någon gjorde "fel", men i läxtrådar o dyl så är ett fullt svar inte optimalt. Låt trådskaparen vara drivande med frågor om sin egen implementation, så som det redan har fungerat ett längre tag i tråden.

Det är ju en definitionsfråga, men med tanke på 1. hur de som skrivit funktionen i python definierat isalpha, isdigit, isspace och 2. hur frågan är formulerad i uppgiften så får jag nog hålla med dig. Rekursionens stoppvillkor/basvillkor bör sättas vid längden 1, och längden 0 bör returnera falskt.

Tack vare hur just isalpha et al. är definierade kan man även sätta stoppvillkoret till mindre än 2 för att undvika en extra if

Om du har en funktion som heter foo och ser ut så här

def foo():
    return False

och kör detta

if foo:
    print "foo is true"
else:
    print "foo is false"

if foo():
    print "foo() is true"
else:
    print "foo() is false"

så blir utskriften från programmet

foo is true
foo() is false

Varför då? Jo, "foo" är en referens till den plats som funktionen är lagrad och den har ett värde som Python tolkar som "inte lika med False". "foo()" ger däremot ett anrop till funktionen med namnet "foo", som i sin tur alltid ger resultatet "False".

Det var ditt ena misstag, du glömde "()" så det blev inget anrop.

Det andra är att du måste använda nyckelordet "return <something>" för att din funktion ska avsluta med resultatet av "<something>". Du gjorde ett korrekt rekursivt anrop, men du använda aldrig resultatet från detta anrop, ska vara "return is_alphanumeric(s ,x+1)". Antar att din lärare fixade dessa två saker för sedan var det nästan korrekt (ett return False ska ändras till return True också).

@TS:

Det finns tre fall du behöver ta hänsyn till:
1. Strängen är 0 tecken lång (du returnerar false).
2. Strängen är ett tecken lång (du returnerar True eller False baserat på om tecknet är alfanumeriskt eller ej).
3. Strängen är flera tecken lång (du returnerar True eller False baserat på om 1. första tecknet är alfanumeriskt och 2. resten av strängen är alfanumerisk).

När du använder din x-variabel så säger du till funktionen "Kolla strängen med början på tecken nr x". Ett smidigare sätt att göra detta är att helt enkelt bara mata funktionen med delsträngen som börjar på tecken nr x. Exempel:
is_alphanumeric("Alfa", 0)
is_alphanumeric("Alfa", 1)
is_alphanumeric("Alfa", 2)
is_alphanumeric("Alfa", 3)
skulle lika gärna kunna hanteras som
is_alphanumeric("Alfa")
is_alphanumeric("lfa")
is_alphanumeric("fa")
is_alphanumeric("a")
om du vid varje anrop, istället för att öka din x-variabel (som inte behövs), plockar bort det första tecknet från strängen. För att ta bort första tecknet använder du t.ex. s[1:]

Skriv [code] innan och [/code] efter koden så blir den formaterad så här i forumet:

def is_alphanumeric(s, x=0):
    if x < len(s):
        if s[x].isdigit() or s[x].isalpha or s[x].isspace:
            is_alphanumeric(s, x+1)
            return True
        else:
            return False
    else:
        return False

vilket gör det mycket lättare att läsa; speciellt i fallet med Python där det snabbt faktiskt blir omöjligt att se hur din kod fungerar om man inte får med indragen.