Een tijdje terug werd ik voorgesteld aan wat mijn # 1 favoriete programmeer- / scriptingtaal is geworden: Python. Het is moeilijk voor een taalontwikkelaar om iets te bedenken dat zowel krachtig als gemakkelijk te schrijven is, iets dat op een natuurlijke manier vloeit en u in staat stelt om u te concentreren op wat belangrijk is in uw code. Python doet dit prachtig. Het maakt precies de juiste soorten veronderstellingen, waardoor je je meer kunt concentreren op wat je programma zou moeten doen in plaats van precies hoe het zou moeten gebeuren. U hoeft zich geen zorgen te maken over geheugenbeheer, variabel typen of die gestraalde puntkomma's, u houdt gewoon uw gedachten aan de logica van uw toepassing.

Python neemt behoorlijk grote afwijkingen van enkele van de meer traditionele talen zoals C / C ++, passend bij de dynamische talen zoals Ruby, Smalltalk en zelfs Javascript. De mogelijkheid om complexe taken in Python snel en gemakkelijk te voltooien, is zelfs het onderwerp geweest van een aantal fantastische webstrips.

Opmerking - Python is een geïnterpreteerde taal, de interpreter kan hier worden gedownload. Alle voorbeelden in deze handleiding zijn geschreven voor Python 3.0 en NIET volledig compatibel met voorgaande versies. Als u problemen ondervindt bij het uitvoeren van de voorbeelden, controleert u uw Python-versie.

De voorbeelden uitvoeren

Ik zal verschillende voorbeelden in deze gids opnemen. Zodra je de Python 3-interpreter hebt geïnstalleerd (zorg ervoor dat het Python 3 is), kan de code op twee manieren worden uitgevoerd:

Script bestand

U kunt de volledige tekst van de voorbeeldcode in een tekstbestand kopiëren / plakken. Python-bestanden eindigen meestal in .py. Open uw opdrachtprompt en voer het Python-uitvoerbare bestand uit gevolgd door de naam van het bestand. Op mijn Linux-computer voer ik het volgende uit:

 python3.0 myfile.py

Dit zou ongeveer hetzelfde moeten zijn op Windows en Mac, hoewel je misschien het volledige pad naar de Python-interpreter moet opgeven, zoals

 C: \ Python30 \ python.exe myfile.py

Interactieve vertolker

Python kan ook worden uitgevoerd in de interactieve modus, waar u de opdrachten één voor één kunt invoeren om te zien hoe deze reageert. Dit kan erg handig zijn bij het oplossen van problemen of bij het uitproberen van nieuwe dingen. Voer het Python-bestand op zichzelf uit, zonder een scriptbestand, en het opent de interactieve prompt.

Ctrl-D verlaat de tolk.

Witte ruimte

Een van de meest ongewone aspecten van Python is het gebruik van witruimte om blokken code aan te geven. In plaats van beginnen en eindigen, of groeperen door haakjes, gebruikt Python de hoeveelheid inspringing om te vertellen hoe blokken code moeten worden verwerkt voor lussen en dergelijke. Voor veel mensen uit andere programmeertalen lijkt dit krankzinnigheid. Als je eenmaal gewend bent aan het idee, wordt het echter heel natuurlijk en wordt je code duidelijk en leesbaar. We gaan sowieso code blokken in (of op zijn minst zou moeten), dus het is gewoon logisch dat de taal begrijpt dat alle zinnen die samen in een rij staan ​​deel uitmaken van hetzelfde blok.

Als bijkomend voordeel is Python niet kieskeurig over hoe graag je wilt inspringen, of zelfs of je de voorkeur geeft aan tabbladen of spaties. Je kunt een tab, een spatie, twee spaties, 137 spaties gebruiken, Python maakt zich er niets van. Het enige dat u hoeft te doen, is consistent zijn. Het zal uw code controleren en zien "Het eerste codeblok is ingesprongen door 4 spaties, dus ik ga ervan uit dat elk blok is ingesprongen door nog eens 4 spaties" of wat het geval ook moge zijn. Zolang je consistent bent in de manier waarop je je code indent, is Python flexibel genoeg om te begrijpen. Het volgende voorbeeld kan helpen om dingen duidelijk te maken.

 1 2 3 4 5 
 x = 0 while x <10: print (x) x + = 1 print ("Alles gedaan")

Code Breakdown: de while- lus vertelt Python dat het volgende blok code moet worden uitgevoerd zolang bepaalde voorwaarden waar zijn. In dit geval is de voorwaarde dat x kleiner is dan 10. Het blijft lussen over dat blok tot x hits 10. De "x + = 1" vertaalt naar "x = x + 1" of "make x groter met 1 ". Merk op dat de laatste regel niet wordt uitgevoerd totdat de while- lus is voltooid. Python ziet de ingesprongen lijnen en behandelt die als de groep code die moet worden uitgevoerd op elke reis door de while- lus. De laatste regel is niet ingesprongen met de andere, dus Python handelt er niet mee totdat de while- lus is voltooid.

Dynamisch typen

Python vereist niet dat u definieert welk type gegevens zich in een variabele bevindt. Je kunt een geheel getal, een tekenreeks, een decimaal, alles wat je wilt in een variabele zetten zonder Python te vertellen wat het is. Python zal uitzoeken, op basis van wat u toewijst, welk type gegevens die variabele moet bevatten. Het volgende voorbeeld moet aantonen:

 1 2 3 4 5 6 7 8 
 x = 0 afdrukken ("x is a:", type (x)) x = 3.14 afdrukken ("x is a:", type (x)) x = "Hallo" afdrukken ("x is a:", type ( x)) x = [1, 2, 3, 4] print ("x is a:", type (x))

Welke ons de onderstaande output geeft

Data structuren

De drie gegevensstructuren die u het meest gebruikt in Python zijn

  • lijsten
  • tuples
  • Woordenboeken

lijsten

lijken veel op arrays in sommige andere talen. Ze zijn een eendimensionale reeks items (hoewel je ze technisch zoveel dimensies kunt geven als je wilt). Elk item in die lijst kan naar believen worden gewijzigd, verplaatst en verwijderd zonder dat de lijst opnieuw hoeft te worden gemaakt en zonder de andere items te wijzigen. Lijsten kunnen elk Python-object bevatten, ongeacht of het een nummer, een tekenreeks of zelfs andere lijsten betreft. De volgende code toont een basisgebruik van lijsten.

 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 
 # maak een lijst met een paar voorbeelditems myList = [1, 2, 3, 4, 5] #len () geeft een telling van hoeveel items onze lijst bevat ("myList has", len (myList), "items . ") #De items in een lijst hoeven niet van hetzelfde type te zijn myList.append (" six ") myList.append (" seven ") myList.append (8) # We hebben drie nieuwe items toegevoegd aan het einde van de lijst print ("myList now has", len (myList), "items.") #Now laten we item nummer 0 zien (eerste item) print ("eerste item:", myList [0]) #en nu het vierde item print ("fourth item:", mylist [3]) #Then pop het laatste item uit de lijst print ("en eindigt met", myList.pop ()) print ("myList now has", len ( myList), "items.") #En zie wat we hebben gedaan print ("De volledige inhoud is:", myList)

tuples

Ik zal tuples niet veel bedekken, omdat ze ons voorbeeldprogramma niet zullen gebruiken en ze lijken op veel manieren op lijsten. Tuples, zoals lijsten, zijn een reeks items die bij elkaar horen. Het verschil is dat tuples niet veranderbaar zijn. U kunt de items in een tuple niet op de juiste plaats wijzigen, u moet de tuple opnieuw maken. Dit betekent geen "toevoegen" of "poppen" of andere dingen die rechtstreeks wijzigingen aanbrengen in de inhoud van het tuple. Als het helpt, kun je tuples zien als een alleen-lezen lijst (hoewel dat niet echt heel accuraat is).

Woordenboeken

Deze, ik hou van. Toen ik voor het eerst over woordenboeken werd geleerd, herinner ik me dat ik iets dacht in de trant van: "Nou .. ik denk dat dat nuttig kan zijn ... soms". Binnen een week gebruikte ik ze elke kans die ik kreeg.

In Python zijn woordenboeken de sleutelwoorden: waardeparen. Het is een beetje zoals een lijst, behalve dat elk item uit twee delen bestaat, een sleutel en een waarde. In het volgende voorbeeld ga ik een woordenboek maken om informatie over mezelf te bewaren.

 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 
 myDict = {} # Sleutelwaarde myDict ["Naam"] = "Josh" myDict ["Beroep"] = "Computer Geek" myDict ["FavFood"] = "Hani Special (geen sla)" myDict ["FavBand"] = "Alles behalve de B-52's" myDict ["Heroes"] = "Tom Waits, Kurt Vonnegut, SpaceBat" myDict ["FavNumber"] = 3.141592 myDict [42] = "Het is ook een goed cijfer" print ("Mijn naam: ", myDict [" Naam "]) print (" Mijn helden: ", myDict [" Helden "]) print (" Mijn favoriete nummer: ", myDict [" FavNumber "]) print (" Wat denk ik van 42? ", myDict [42]) print () # Nu zal ik mijn favoriete nummer veranderen zonder een # heel nieuw woordenboek te maken myDict [" FavNumber "] + = 100 print (" My NEW favorite number: ", myDict [" FavNumber " ])

Een paar dingen moeten uit het voorbeeld duidelijk zijn. Ten eerste kunnen woordenboeken gegevens van elk type mixen en matchen. Je sleutels en waarden kunnen van alles zijn. Je kunt zelfs heel gek worden en dingen als functies in woordenboeken plaatsen, maar dat is ver buiten het bereik van deze handleiding.

Ten tweede kunnen woordenboeken worden gewijzigd. U kunt items tijdens het spelen toevoegen en verwijderen zonder het woordenboek opnieuw te maken of andere items te beïnvloeden.

Als u nog steeds niet zeker bent van het nut van woordenboeken, overweeg dan om ze te gebruiken om de instellingen van een gebruiker bij te houden. Je zou een woordenboek kunnen hebben met de naam instellingen en dingen opslaan zoals gebruikersnaam, ip-adres en schermresolutie. Telkens wanneer u naar die gegevens moet verwijzen, kunt u deze gewoon van instellingen ["gebruikersnaam"] of welke andere sleutel dan ook die u hebt opgegeven, verwijderen.

Breng het allemaal naar huis

Nu gaan we naar de echte actie en maken we een nuttig Python 3.0-programma. Wat dit programma zal doen, is een getal nemen dat staat voor geld, en je vertellen hoeveel pocketverwisseling dat bedrag zou opleveren. Het is een vrij algemene codeeroefening en het is een goede manier om de concepten te demonstreren die we tot nu toe hebben behandeld.

Ik zou je nu moeten vertellen dat dit programma NIET op de "beste" manier zal worden geschreven, mijn doel is het te schrijven met behulp van de meest elementaire concepten en bewerkingen die mogelijk zijn. Er zijn verschillende "betere" manieren om dit te schrijven, zoals het gebruik van functies en de modulus-operator, en inclusief foutcontrole, maar deze versie moet vrij gemakkelijk te begrijpen zijn.

 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 
 #Krijg het contante bedrag in totaal = invoer ("Voer contant bedrag in dollars: $ in") #Het lezen van tekstinvoer gaat uit van tekst, dus zet #naar decimaal en meerdere naar 100 zodat we pence # kunnen tellen (eenvoudiger wiskunde op die manier) centen = float (totaal) * 100 # maak een woordenboek om onze veranderingswaarden te behouden verander = {"quarters": 0, "dimes": 0, "nickels": 0, "pennies": 0} #Loop tot alle geld is verwerkt terwijl penny's> 0: #Stel elke munt uit het totaal, tel 1 op voor elke munt en start de lus opnieuw na het tellen als pennies> = 25: verander ["kwartalen"] + = 1 centen - = 25 ga verder elif pennies> = 10: wijziging ["dimes"] + = 1 pence - = 10 ga verder elif pennies> = 5: verander ["nickels"] + = 1 pence - = 5 ga verder anders: verander ["pence"] = int (pence) centen = 0 # Eindelijk, print onze resultaten print ("Q:", verander ["kwartalen"]) print ("D:", verander ["dimes"]) print ("N:", verander ["nickels"] ) print ("P:", verander ["pence"])

Code verdeling: we gebruiken invoer om een ​​hoeveelheid geld binnen te krijgen via de opdrachtregel. Python gaat ervan uit dat wat wordt ingevoerd een reeks tekst is, in tegenstelling tot een getal, dus we moeten het vertellen om die invoer om te zetten in een bruikbaar nummer. We hadden het nummer alleen kunnen laten staan ​​(15, 95), maar in plaats daarvan hebben we het omgezet naar centen (vermenigvuldigd met 100) om de wiskunde eenvoudiger te maken, zodat we ons geen zorgen hoeven te maken over decimale punten.

Vervolgens maken we een woordenboek om de resultaten van onze computer te bewaren. Als dit een complexer programma zou zijn, zouden we dat woordenboek kunnen doorgeven aan onze functies, klassen enz. Zonder zich zorgen te hoeven maken over het bijhouden van afzonderlijke variabelen voor elk type muntstuk.

Daarna komt het echte werk - de daad van het splitsen van ons geld totaal in individuele munten. Dit programma gebruikt een while- lus om te blijven fietsen totdat we geen geld meer hebben van onze oorspronkelijke invoer. Elke trip door de lus kijkt naar de hoeveelheid geld, trekt de grootste hoeveelheid geld eruit en start de lus opnieuw. In plaats van keer op keer aftrekken, zou dit programma waarschijnlijk veel efficiënter zijn als we de modulus-operator zouden hebben gebruikt, maar de aftrekking is gemakkelijker te begrijpen.

Zodra we klaar zijn met de lus, hoeven we alleen nog maar onze resultaten weer te geven.

Python kan veel meer dan ik hier zou kunnen bespreken, maar ik hoop dat ik in staat ben geweest om de basis van hoe het werkt te demonstreren en hoe het kan worden gebruikt om snel en gemakkelijk tools te maken die veel gecompliceerder zouden zijn in een minder intuïtieve taal.

In het geval dat iemand zo nieuwsgierig is als ik was over hoe ik "tuple" correct uitspreek, had ik het geluk dat ik Guido van Rossum zelf kon vragen of het "toople" of "tupple" was, en hij gaf het enigszins onbevredigende antwoord "Het is wat je maar wilt."