Python från Scratch - Funktioner och Moduler

Välkommen tillbaka till Python från Scratch-serien. I den tidigare lektionen lärde vi oss hur vi använder variabler och kontrollstrukturer för att lagra och manipulera data. Var noga med att granska den om du behöver en uppdatering!

Video Tutorial

Transkript

I dagens handledning ska vi titta på funktioner - vad de är, hur de jobbar och hur man gör egna. Vi ska också granska några av de inbyggda funktionerna och hur de ska användas effektivt. Slutligen ska vi titta på att skapa och importera moduler.

Funktioner - Skriv din egen

Funktioner är ett viktigt steg för att täcka, när man introducerar ytterligare komplexitet i din programmering. Om en variabel är en namngiven behållare för data, är en funktion en namngiven behållare för ett block av kod som kan utföras på begäran. Det här är användbart om du har ett program som utför en viss operation många gånger. Istället för att kopiera och klistra in koden för att göra den där åtgärden, varje sektion där det behövs, kan du helt enkelt skriva en enda funktion för att göra det för dig.

En funktion är en namngiven behållare för ett block av kod.

Det finns två typer av funktioner: de som du skriver själv och innehåller i din kod, och de som ingår i Python, som utför gemensamma förfaranden, som att konvertera ett heltal till en sträng, eller hitta längden på en sträng.

Vi ska titta på att skriva en enkel funktion nu och visa hur det kan vara användbart i den riktiga världskoden. Sedan tar vi en titt på några av de viktigaste inbyggda funktionerna.

Ett enkelt exempel

Låt oss föreställa oss att vi vill göra ett manus för en kundvagn som kostar alla varor i din kundvagn och lägger dem till för att återställa en total kostnad. Att skriva en funktion som skulle ta två kostnader, lägga till dem och skriv ut resultatet, vi kan göra något sånt:

 #our två kostnader för att lägga till cost1 = 15 cost2 = 20 def sumCart (): totalCost = kostnad1 + cost2 print totalCost sumCart ()

För att definiera funktionen måste vi använda "def'nyckelord, och sedan namnet på funktionen. Därefter skriver vi två paranteser (vi kommer tillbaka till dem senare) och sedan ett kolon. Därefter ska all kod som vi vill vara inneslutna i funktionen vara indragad, precis som med om, medan och för slingor.

För att göra koden i funktionskörningen skriver vi namnet på funktionen, följt av de två parenteserna igen. Om du kör den här koden ser du det skriv ut '35', vilket är rätt utgång.

Argument

Det är bra, men för tillfället är våra funktioner lite styva - allt om funktionen är hårdkodad i dem. Låt oss säga att vi vill använda sumCart funktionen någon annanstans, i en annan del av programmet, men istället för att lägga till cost1 och cost2 tillsammans vill vi lägga till två andra kostnader tillsammans som hölls i olika variabler. Vi skulle behöva skriva en helt ny funktion, även om den nya funktionen skulle vara exakt densamma som den nuvarande, med namnen på variablerna bytte runt - det verkar knappast som en effektiv lösning.

För att lösa detta problem använder vi "argument", och det är vad parenteserna är för. Ett argument är ett sätt att skicka data till en funktion när vi inte vet vilken variabel eller variabler som data kommer att vara in. Om det är förvirrande, låt oss ta det exempel som jag bara refererade till. Vi lägger till ytterligare två kostnader: cost3 och cost4.

Nu ska vi lägga till två argument för de två objekt som vi vill lägga till. Argument definieras inuti parenteserna, och varje argument ges ett namn, med ett kommatecken som skiljer vardera. Ett argument fungerar som en tillfällig hänvisning till de data du skickade in medan funktionen körs.

 cost1 = 15 cost2 = 20 cost3 = 5 cost4 = 10 def sumCart (item1, item2): totalCost = item1 + item2 print totalCost sumCart (kostnad1, kostnad2)

När vi kallar sumCart funktion, de två variablerna som vi har skickat in (cost1 och cost2) läggs in i argumentet item1 och item2. Detta händer alltid i samma ordning som du definierar argumenten - med andra ord, den första variabeln du skickar in tilldelas det första argumentet, det andra till det andra argumentet och så vidare för så många argument som din funktion tar.

Vad som faktiskt händer när funktionen körs är att de två argumenten konverteras till lokala variabler och tilldelas värdena för de variabler som du passerar in i funktionen när du ringer det - i det här fallet värdet av Anskaffnings- värde1 sätts i den lokala variabeln item1, och värdet av kostnaden2 sätts i den lokala variabeln ITEM2. Det betyder att du enkelt kan använda dem inom funktionen.

Ett annat sätt att titta på det är att när du passerar en variabel som ett argument överallt att det här argumentets namn visas i funktionen, ersätts det med den variabel du passerade in. Så i det här exemplet överallt det item1 skrivs inuti funktionen, den ersätts med Anskaffnings- värde1, och samma med ITEM2 och kostnaden2.

För att bevisa att du kan skicka några nummer du vill ha, om du kör den här koden, ska du nu få summan av cost3 och cost4:

 cost1 = 15 cost2 = 20 cost3 = 5 cost4 = 10 def sumCart (item1, item2): totalCost = item1 + item2 print totalCost sumCart (cost3, cost4)

Argumentinställningar

Observera att en funktion kan acceptera ett antal argument, men kom ihåg: när du ringer funktionen måste du skicka den samma antal argument som du definierat, annars får du ett fel. Det finns ett sätt runt detta: du kan definiera ett standardvärde för alla argument som används i de fall då du inte anger ett värde.

Med tanke på vår nuvarande kod, låt oss föreställa oss att vi vill att det andra objektet kostar 5 om vi inte ger funktionen ett annat värde. Det är inte ett troligt scenario, men det kommer att visa konceptet.

 cost1 = 15 cost2 = 20 cost3 = 5 cost4 = 10 def sumCart (item1, item2 = 5): totalCost = item1 + item2 print totalCost sumCart (cost1) sumCart (cost3, cost4)

Om vi kör den här koden ser du att i första samtalet är utmatningen 20, vilket faktiskt är (kostnad 1 + 5). Detta påverkar emellertid inte beteendet när båda argumenten tillhandahålls.

Återkommande värden

Det finns en sista egenskap av funktioner som vi ska granska idag: återvändande värden. Vi har lärt oss hur man gör en funktion som inte tar hänsyn till vilka ingångar som krävs, men om vi ville lagra svaret på totalCost i en variabel i stället för att skriva ut det? Kanske det vi vill göra är att utarbeta kostnaden för de två första objekten och lagra den i en variabel, gör sedan samma med de andra två objekten och lagra det svaret i en andra variabel. Med den nuvarande utformningen av vår funktion kunde vi inte göra det på ett läsligt och lättförståeligt sätt.

Precis som hur vi kan skicka argument till en funktion så att vi inte behöver hardkoda där data kommer från, kan vi göra samma med utgången. Jag ska visa dig med ett exempel - i vår tidigare funktion kommer jag att ersätta ordet "print" med ordet "return":

 cost1 = 15 cost2 = 20 cost3 = 5 cost4 = 10 def sumCart (item1, item2): totalCost = item1 + item2 retur totalCost cart1 = sumCart (kostnad1, kostnad2) cart2 = sumCart (kostnad3, kostnad4) kundvagn1

Självklart kommer funktionen inte längre att skriva ut svaret för oss - vad det kommer att göra istället är att skicka tillbaka värdet av variabeln totalCost till var vi kallade funktionen från. På det sättet kan vi använda svaret i vilket sammanhang vi behöver. Nu, i vårt tidigare program, skulle det inte vara särskilt användbart, eftersom vi inte angav någonstans att lagra den, så jag har också ändrat hur vi kallar funktionen.

Vi måste tillhandahålla Python med en variabel för att lagra svaret, och då ska vi helt enkelt ställa in den variabeln lika med vårt uttalande som kallar funktionen. När funktionen returnerar ett värde, sparas det värdet i den variabel vi angivit.

Funktioner - Inbyggd

Vi har lärt oss hur man gör egna funktioner och hur man använder dem, men det finns vissa operationer som ofta utförs så att Python har inkluderat dem för användning i något program. Det sätt du kallar dem är exakt detsamma som att ringa ditt eget, men du behöver inte definiera dem först. Vi kommer att se en kort titt på de viktigaste nu, men var noga med att titta på Python-dokumentationen eftersom det finns massor av användbara funktioner som är tillgängliga för användning, vilket vi inte har tid att täcka rätt nu.

Se Python-dokumentationen för en lista över alla inbyggda funktioner.

str ()

Låt oss först titta på en av de mest användbara funktionerna i Python: strängomvandlingsfunktionen. Det finns många gånger i skript när du har en variabel som innehåller ett tal eller någon annan typ av data, men du måste konvertera det här värdet till en sträng för att kunna göra något med det - normalt för att skriva ut det på skärmen.

Låt oss säga att vi har ett tal i en variabel, och att vi vill skriva ut det med meddelandet "Numret är" och sedan numret. Om vi skriver:

 nummer = 10 skriv ut 'Numret är' + nummer

? då kommer vi att stöta på ett fel, för det du frågar Python att göra är att lägga till ett nummer och en sträng tillsammans - vilket inte verkligen ger en hel del mening. Vad vi behöver göra är att konvertera talet 10 till strängen 10. Om vi gör det, kommer Python förstå att det vi försöker göra är inte att hitta en summa, men istället sammanfoga de två strängarna till en.

Det är här str funktionen kommer in. Den accepterar ett värde och returnerar en sträng för att representera den. Om du skickar det ett nummer kommer det helt enkelt att returnera numret men i strängformat.

 nummer = 10 skriv ut 'Numret är' + str (nummer)

Nu när vi har encased numret i en strängomvandlingsfunktion körs koden perfekt. De str funktionen behöver dock inte ta ett tal - det kan också ta andra värden, till exempel a Boolean:

 bool = True print 'Värdet är' + str (bool)

De str () funktionen finner den närmaste strängkampen som den kan hitta för värdet av "Sann'och returnerar det, vilket innebär att vi kan leverera det snyggt.

len ()

En annan vanlig uppgift för strängar är att kunna hitta längden på dem, och igen har Python en inbyggd funktion för detta. Låt oss ta strängen "Hello World" och försöka hitta dess längd. För att göra detta behöver vi den inbyggda len () funktion som står för längd. Allt vi behöver göra är att skicka det strängen vi vill använda, och det kommer att returnera antalet tecken i det:

 string = 'Hello World' print len (sträng)

De len () funktionen kan dock mer än detta. Vad det egentligen gör är att räkna antalet objekt i objektet du ger det - om du ger det en sträng så är det antalet tecken, men du kan också ge den en lista eller en tupel, till exempel, och den kommer att returnera mängden objekt i det aktuella objektet.

int ()

Om du fortsätter, får du ofta ett nummer som 10.6 eller 3.896, vilket inte är ett heltal, men du behöver ett heltal från dem. Den inbyggda funktionen att konvertera till ett heltal kallas int (), och det fungerar ganska förutsägbart. Funktionen kommer att returnera heltalskonvertering av det numret. Observera att den här funktionen INTE rundar ingången till närmaste heltal - det tar helt enkelt bort allt efter decimaltalet och returnerar numret till dig. Så kommer inmatningen på 10,6 tillbaka 10, NOT 11. På samma sätt skulle 3,25 returnera 3.

 nummer = 10.6 print int (nummer)

De int funktionen kan också konvertera en sträng till en int data typ. Med tanke på detta skulle utmatningen fortfarande vara 10:

 nummer = '10' print int (nummer)

Men var försiktig, för när den konverterar från en sträng till ett heltal, int () kommer inte att hantera decimaler. Om du anger det:

 number = '10 .6 'print int (number)

Då kommer det att kasta ett fel, eftersom ingången inte var ett heltal, så det visste inte hur man hanterade det.

räckvidd()

Slutligen ska vi snabbt titta på räckvidd() fungera; Det kommer upp förvånansvärt ofta när du börjar göra mer komplexa uppgifter i Python, och medan det kanske inte verkar vara väldigt användbart för tillfället är det värt att titta på och lära känna hur det fungerar. Område är en funktion som du använder för att skapa en lista med siffror som följer ett visst mönster. Det enklaste exemplet är att du kanske behöver en lista som innehåller alla siffrorna 0 till 10. I stället för att skriva ut dem manuellt kan du använda räckvidd funktion att göra det i en rad.

Området accepterar ett heltal som parameter, och i det här fallet kommer vi att överföra det 11. Funktionen thens börjar vid noll och gör en lista räknas uppåt tills den träffar en mindre än det tal du anger. Så här, om vi lägger in 11, det kommer att lagra numren 0 - 10 i listnumren:

 siffror = intervall (11) tryck (siffror)

Vad händer om vi vill skriva ut siffrorna fem till tio istället? Tja, valfritt, kan vi inkludera ett annat argument för startnumret, så detta kommer att skriva ut siffrorna fem till tio:

 siffror = intervall (5, 11) skriv ut (siffror)

Slutligen, vad händer om vi bara skulle skriva ut de udda siffrorna under 10? Tja, accepterar intervall ett tredje värde, vilket är mängden att gå upp varje steg. Så om vi börjar med 1, sätt steg till två och den övre gränsen till 11, borde vi sluta med alla udda tal under tio:

 siffror = intervall (1, 11, 2) tryck (siffror)

Som en slutlig notering kan något av dessa siffror också vara negativt, så om vi ville räkna ner från 10 till 1 istället för upp, kunde vi ställa in steget för att vara negativt 1, utgångsvärdet till 10 och gränsen till 0 , såhär:

 siffror = intervall (10, 0, -1) skriv ut (siffror)

Observera att intervallet endast avser heltal, så se till att du inte ger några värden som inte är heltal eller du kommer att kasta ett fel.

Moduler - Skapa din egen

Okej, vi har nu täckt funktioner; låt oss gå vidare till det andra ämnet i dagens lektion: moduler. Om funktioner är grupper av kod är moduler grupper av funktioner. Det finns mer för dem, men det är ett bra sätt att tänka på dem för nu.

Som vi diskuterade tidigare kan du inte göra ett komplext program utan att sortera kod i funktioner, och när ditt program fortsätter att växa ytterligare, blir de även obehagliga. Du måste sortera dem i en annan hierarkisk nivå. Dessa är moduler. Så vi kan summera dem som ett strukturellt och organisatoriskt verktyg för vår kod.

Moduler är ganska lätta att skapa. De är helt enkelt Python-filer, som dina vanliga skript. För att skapa en modul skriver du en eller flera funktioner i en textfil och sparar sedan den med en .py förlängning. Låt oss göra det nu med ett exempel. Öppna en ny fil, din textredigerare eller IDE, och gör en funktion. Jag ska fortsätta med exemplet på en kundvagn från tidigare och göra en funktion för att beräkna skatt på produkterna.

Skapa en ny fil i din IDE eller textredigerare och låt oss skapa en funktion för att beräkna skatt på en produkt.

 def addTax (pris, skatt): newPrice = pris / 100 * (100 + skatt) returnera newPrice

Om vi sparar den här filen med en .py förlängning i samma katalog som vårt andra skript, vi kan använda det som en modul! Det är viktigt att ge det ett beskrivande namn så att du vet vad det gör när du kommer tillbaka senare, så ring den här finance.py

Importera moduler

För att använda moduler kan vi antingen använda importera eller den från nyckelord. importera är det enklaste och vanligaste, så låt oss försöka det först. Du anger sedan namnet på modulen, som helt enkelt är filnamnet, utan .py förlängning. Till exempel med vår finansiera modul i samma mapp som vårt manus, kunde vi skriva:

importfinansiering

? och vi skulle ha tillgång till alla funktioner i manuset. Vi kan då ringa dem som vi gjorde tidigare. Du kan också använda från sökord, där du kan välja specifika funktioner från biblioteket, om du vet vilka du behöver i förväg. För en modul som har hundratals funktioner, rekommenderas detta - det sparar laddningstiden på funktioner som inte ens används.

från finansiell import addTax

Du kan importera flera genom att skilja deras namn med kommatecken.

från finansiell import addTax, beräknaDiscount

Och du kan även använda stjärnkortet för att importera allt.

från finansiell import *

Efter att du har importerat modulen, använder du funktionerna i den, använder du modulnamnet, följt av en punkt och sedan funktionsnamnet.

 importfinansiering print finance.addTax (100, 5)

Detta bör resultera i 105 när manuset körs. Ett enkelt resultat, men det betyder att du har en fungerande funktion!

Inbyggda moduler

Det finns gott om inbyggda moduler, precis som det finns inbyggda funktioner. Det här är Python som verkligen utmärker sig! Det tar vad som kallas "batterierna ingår? närma sig.

Eftersom Python har ett så stort utbud av inbyggda moduler, finns det inget sätt att täcka dem alla i en lektion. Vissa är ganska obskyra, och det finns ingen anledning att lära ut en mängd information som du aldrig kan använda. Låt oss istället täcka flera av de mest användbara.

slumpmässig
matematik
os
datum Tid
urllib2

`slumpmässig`

En bra att börja med är slumpmässig , eftersom det är lätt att förstå och användbart i de flesta skript du skriver. Som du kan förvänta dig, låter den här modulen generera slumptal. När du till exempel använder Python för att skapa en webbplats kan de användas för att göra din lösenordsdatabas säkrare eller driva en slumpmässig sidfunktion. Om vi ville ha ett slumpmässigt heltal kan vi använda randInt funktion, som så:

 importera slumpmässigt utskrivning random.randint (0, 5)

Detta kommer att mata antingen 1, 2, 3, 4 eller 5. Randint accepterar exakt två parametrar: ett lägsta och ett högsta tal. Som du kan se innehåller den högsta numret men går från 1 över det lägsta numret. Om du vill ha ett slumpmässigt flytpunktsnummer kan du använda slumpmässig fungera:

 importera slumpmässigt random.random ()

? som matar ut ett slumptal mellan 0 och 1, med en decimalavgift. Om du vill ha ett större antal kan du multiplicera det. Till exempel ett slumptal mellan 0 och 100:

 importera slumpmässigt random.random () * 100

De slumpmässig modulen har också en funktion för att välja ett slumpmässigt element från en uppsättning som en lista som heter val.

 importera slumpmässig myList = [1, 8, True, 77, "Lorem", 482, "Ipsum"] random.choice (myList)

`matematik`

De matematik modulen ger tillgång till matematiska konstanter och funktioner.

 importera matematik math.pi #Pi, 3,14? math.e # Eulers nummer, 2,71? math.degrees (2) # 2 radians = 114.59 degrees math.radians (60) # 60 grader = 1.04 radianer math.sin (2) #Sine av 2 radianer math.cos (0.5) #Cosine med 0,5 radianer math.tan 0,23) #Tangent av 0,23 radianer math.factorial (5) # 1 * 2 * 3 * 4 * 5 = 120 math.sqrt (49) #Square rot av 49 = 7

Det finns många fler funktioner i modulen, men dessa är några av de mest användbara. Du kan hitta en fullständig lista här.

`datum Tid`

Om du behöver arbeta med datum och tider, då datum Tid modulen är din vän. Den här är en mycket användbar för att veta om webbutveckling. Om du gör en webbplats med kommentarer eller en blogg så kommer du förmodligen att visa sin ålder eller den tid de skapades.

Låt oss importera modulen som vanligt:

 importera datetime

För enkelhets skyld kan du också importera datum och tidskomponenter separat, så du behöver inte skriva så mycket senare.

 importera datetime från importtidens importdatum för importtid

Låt oss ta en titt på några av de funktioner som den ger:

 time.time () #Returns antalet sekunder sedan Unix epoken, 1 januari 1970 date.fromtimestamp (123456789) #Converts ett antal sekunder till ett datumobjekt date.fromtimestamp (time.time ()) #We kan kombinera två för att få ett objekt som representerar det aktuella tidsdatumet.fromordinalt (10000) #Returnerar datumet ett visst antal dagar sedan 1 januari i år 1 till 28 maj 0018 i det här fallet

Det finns några användbara funktioner för att konvertera datum till användbara strängar. strftime kan du formatera en sträng baserad på specialtecken som föregås av en procent-symbol. % d representerar dag, till exempel.

 currentDate = date.fromtimestamp (time.time ()) #Create en variabel som representerar tiden nuvarandeDate.strftime ("% d /% m /% y") #Format datumet som DD / MM / YY - i detta fall 09 / 07/11 currentDate.isoformat () #Format som ISO-standarddatum - i det här fallet 2011-07-09

`os`

Nästa modul vi tittar på är os, som ger funktioner som låter dig gränsa med det underliggande operativsystemet Python körs på - det är Windows, Mac eller Linux. Vi fokuserar på väg submodul. Det låter dig manipulera och hitta egenskaperna hos filer och mappar på systemet, så det är mest användbart för webbutveckling. Du behöver ofta hantera filer, till exempel användaruppladdningar.

 från os import path path.exists ("/ Users / Giles") #Checks om katalogen existerar, i mitt fall är det True path.exists ("/ Users / Bob") #Fall denna gång

 från oss importväg path.getatime ("/ Users") #Get sista gången den angivna katalogen nås som en tidsstämpel path.getmtime ("/ Users") #Get sista gången den angivna katalogen har ändrats som en tidsstämpel

Dessa tidsstämplar kan konverteras till användbara strängar med hjälp av datum Tid modulen - du kan se hur du kan kombinera moduler.

 från os importväg path.getsize ("/ Users / Giles / Desktop / boot") #Returnerar storleken på en fil i byte - för den här filen var det 314400 byte eller 314kb

Den sista funktionen i OS-modulen vi ska titta på är Ansluta sig. Den kombinerar två vägar i en. Du kanske tänker: "Varför kan jag inte bara sammanfoga strängarna?", Men det är inte så enkelt som det. På Windows är vägavgränsaren en backslash, på Mac och Linux är det en framåt snedstreck. Den här modulen lindrar problem så och ser till att dina Pythons-skript fungerar på alla system.

 path.join ("C:", "Users") #Returns "C: / Users"

`urllib2`

För att avsluta vår rundtur i Pythons standardbibliotek kommer vi att se en kort titt på urllib2. Den här modulen låter dig gränsa med webben, så det är uppenbarligen ganska relevant för oss. Den mest användbara funktionen som den tillhandahåller är urlopen, som hämtar en sida.

Du använder det enligt följande:

 importera urllib2 urllib2.urlopen ("http://net.tutsplus.com")

Du kan självklart byta URL-strängen för vilken webbplats som helst. Detta hämtar HTML-innehållet på sidan. Detta kommer inte att returnera en sträng men, så vi måste läsa data för att få det ut:

 importera urllib2 urllib2.urlopen ("http://net.tutsplus.com") .read (100)

Detta kommer att returnera de första 100 tecknen i HTML-källan till Nettuts +. När du har denna data kan du sortera igenom den och extrahera nödvändiga bitar som du behöver.

Slutliga tips

Om din modul ligger i en annan katalog än ditt skript, är det lite svårare att importera dem. Du måste skapa en fil som berättar Python, mappen är ett paket. Om du till exempel har en mapp, kallad underkatalog, i samma mapp som ditt skript och sedan din modul i den underkatalogen, måste du skapa en fil som heter __init__.py i samma mapp som modulen. Den här filen kan vara tom. Sedan, från ditt skript, skulle du importera det:

% granska det om du behöver en uppdatering!