Senaste uppdatering: 2018-01-24

Python är ett populärt programmeringsspråk på hög nivå som är designat för att skapa olika typer av applikationer. Dessa inkluderar webbapplikationer, spel, skrivbordsprogram och att arbeta med databaser. Python har blivit ganska utbredd inom området maskininlärning och forskning om artificiell intelligens.

Språket Python tillkännagavs första gången 1991 av den holländska utvecklaren Guido Van Rossum. Sedan dess har detta språk kommit långt i utvecklingen. År 2000 publicerades version 2.0 och 2008 version 3.0. Trots de till synes stora klyftorna mellan versionerna släpps subversioner hela tiden. Så den aktuella versionen vid tidpunkten för detta material är 3.7. Mer detaljerad information om alla utgåvor, versioner och språkändringar, såväl som tolkarna själva och nödvändiga verktyg för arbete och annan användbar information finns på den officiella webbplatsen https://www.python.org/.

Huvuddragen i programmeringsspråket Python:

Python är ett väldigt enkelt programmeringsspråk det har en kortfattad och samtidigt ganska enkel och begriplig syntax. Följaktligen är det lätt att lära sig, och i själva verket är detta en av anledningarna till att det är ett av de mest populära programmeringsspråken specifikt för inlärning. I synnerhet 2014 erkändes det som det mest populära programmeringsspråket för lärande i USA.

Python är också populärt inte bara inom utbildningsområdet, utan även när det gäller att skriva specifika program, inklusive kommersiella. Det är till stor del därför som många bibliotek har skrivits för detta språk som vi kan använda.

Dessutom har detta programmeringsspråk en mycket stor gemenskap på Internet, du kan hitta mycket användbart material och exempel på detta språk, och få kvalificerad hjälp av specialister.

För att skapa program i Python behöver vi en tolk. För att installera det, gå till webbplatsen https://www.python.org/ och på huvudsidan i avsnittet Nedladdningar hittar vi en länk för att ladda ner den senaste versionen av språket (för närvarande 3.7.2):

Låt oss följa länken till sidan som beskriver den senaste versionen av språket. Närmare längst ner kan du hitta en lista över distributioner för olika operativsystem. Låt oss välja det paket vi behöver och ladda ner det. Till exempel, i mitt fall är det Windows 64-bitars, så jag väljer paketlänken Windows x86-64 körbart installationsprogram. När du har laddat ner distributionen installerar du den.

Följaktligen kan du för MacOS välja macOS 64-bitars installationsprogram.

På Windows OS, när du startar installationsprogrammet, öppnas installationsguidens fönster:

Här kan vi ställa in sökvägen där tolken ska installeras. Låt oss lämna det som standard, det vill säga C:\Users\[användarnamn]\AppData\Local\Programs\Python\Python36\.

Dessutom, längst ner, markera kryssrutan "Lägg till Python 3.6 till PATH" för att lägga till sökvägen till tolken till miljövariablerna.

Efter installationen kan vi hitta ikoner för åtkomst till olika Python-verktyg i Start-menyn på Windows OS:

Här tillhandahåller verktyget Python 3.7 (64-bitars) en tolk där vi kan köra skriptet. I filsystemet kan själva tolkfilen hittas längs vägen där installationen utfördes. På Windows är detta standardsökvägen C:\Users\[användarnamn]\AppData\Local\Programs\Python\Python37, och tolken själv representerar filen python.exe. På Linux OS utförs installationen längs sökvägen /usr/local/bin/python3.7.

I vilken, i en kondenserad form,
prata om grunderna i Python-språket. Jag erbjuder dig en översättning av denna artikel. Översättningen är inte bokstavlig. Jag försökte förklara några punkter mer i detalj som kanske inte är tydliga.

Om du planerar att lära dig Python-språket, men inte kan hitta en lämplig guide, då detta
Artikeln kommer att vara mycket användbar för dig! På kort tid kan du lära känna
grunderna i Python-språket. Även om denna artikel ofta förlitar sig
att du redan har erfarenhet av programmering, men, hoppas jag, även för nybörjare
detta material kommer att vara användbart. Läs varje stycke noggrant. På grund av
materialets kortfattadhet, vissa ämnen diskuteras ytligt, men innehåller allt
obligatoriskt mått.

Grundläggande egenskaper

Python kräver inte explicit deklaration av variabler, och är ett objektorienterat språk (var-variabel är inte ekvivalent med Var eller VAR - de är tre olika variabler).

Syntax

För det första är det värt att notera en intressant egenskap hos Python. Den innehåller inte operatorparenteser (börjar..slutar på pascal eller (..) på C), istället blocken är indragna: mellanslag eller tabbar, och inmatning av ett block av satser görs med kolon. Enradiga kommentarer börjar med ett pundtecken "#", flerradskommentarer börjar och slutar med tre dubbla citattecken """.
För att tilldela ett värde till en variabel, använd tecknet "=" och för att jämföra -
"==". För att öka värdet på en variabel eller lägga till en sträng, använd operatorn "+=" och "-=" för att minska det. Alla dessa operationer kan interagera med de flesta typer, inklusive strängar. Till exempel

>>> myvar = 3
>>> myvar += 2
>>> myvar -= 1
"""Detta är en kommentar med flera rader
Rader omslutna av tre dubbla citattecken ignoreras"""
>>> mystring = "Hej"
>>> mystring += "värld."
>>> skriva ut mystring
Hej världen.
# Nästa rad ändras
variablernas värden byts om. (Bara en rad!)
>>> myvar, mystring = mystring, myvar

Data struktur

Python innehåller datastrukturer som t.ex listor, tupler och ordböcker). Listor liknar endimensionella arrayer (men du kan använda en List inklusive listor - en flerdimensionell array), tupler är oföränderliga listor, ordböcker är också listor, men index kan vara av vilken typ som helst, inte bara numeriska. "Arrayer" i Python kan innehålla data av vilken typ som helst, det vill säga en array kan innehålla numeriska, strängar och andra datatyper. Matriser börjar vid index 0 och det sista elementet kan nås vid index -1. Du kan tilldela funktioner till variabler och använda dem därefter.

>>> prov = , ("a" , "tuppel")] #Listan består av ett heltal, en annan lista och en tupel
>>> #Den här listan innehåller en sträng, ett heltal och ett bråktal
>>> mylist = "Lista objekt 1 igen" #Ändra det första (noll) elementet i arkets mylist
>>> mylist[-1 ] = 3 .14 #Ändra det sista elementet i arket
>>> mydict = ("Key 1" : "Värde 1", 2 : 3, "pi" : 3 .14 ) #Skapa en ordbok med numeriska och heltalsindex
>>> mydict["pi" ] = 3 .15 #Ändra ordbokselementet under indexet "pi".
>>> mytupel = (1 , 2 , 3 ) #Ange en tuppel
>>> minfunktion = len #Python låter dig deklarera funktionssynonymer på detta sätt
>>> skriva ut min funktion(lista)
3

Du kan använda en del av en array genom att ange det första och sista indexet åtskilda av ett kolon ":". I det här fallet kommer du att få en del av arrayen, från det första indexet till det andra, inte inklusive. Om det första elementet inte är specificerat börjar räkningen från början av arrayen, och om det sista elementet inte är specificerat läses arrayen till det sista elementet. Negativa värden bestämmer elementets position från slutet. Till exempel:

>>> mylist = ["Listobjekt 1" , 2 , 3 .14 ]
>>> skriva ut min lista[:] #Alla element i arrayen läses
["Listobjekt 1" , 2 , 3 .14000000000000001 ]
>>> skriva ut min lista #Nollan och det första elementet i arrayen läses.
["Listobjekt 1" , 2 ]
>>> skriva ut mylist[-3 :-1 ] #Element läses från noll (-3) till sekund (-1) (inte inklusive)
["Listobjekt 1" , 2 ]
>>> skriva ut min lista #Element läses från första till sist

Strängar

Strängar i Python åtskilda av dubbla citattecken """ eller enkla citattecken """. Dubbla citattecken kan innehålla enkla citattecken, eller vice versa. Till exempel raden "Han sa hej!" kommer att visas som "Han sa hej!". Om du behöver använda en sträng med flera rader, måste denna rad börja och sluta med tre dubbla citattecken. Du kan ersätta element från en tupel eller ordbok i strängmallen och tuppeln ersätter tecken i strängen "%s" till ett tupelelement. Ordböcker låter dig infoga ett element vid ett givet index i en sträng. För att göra detta, använd "%(index)s"-konstruktionen i strängen. I det här fallet, istället för "%(index)s" kommer ordboksvärdet vid det givna indexet att ersättas.

>>>skriva ut "Namn: %s\nNummer: %s\nSträng: %s"% (min klass.name, 3 , 3 * "-" )
Namn: Poromenos
Nummer 3
Sträng: -
strString = """Denna text finns
på flera rader"""

>>> skriva ut"Detta %(verb) är ett %(substantiv)s." %("substantiv" : "test" , "verb" : "är")
Detta är ett prov.

Operatörer

Medan uttalanden om, för sminka flyttoperatörer. Det finns ingen motsvarighet till select-satsen, så du får klara dig om. I operatören för jämförelse sker variabel och lista. För att få en lista med siffror upp till ett nummer - använd funktionen range( ). Här är ett exempel på hur du använder operatorer

rangelist = range(10) #Få en lista med tio siffror (från 0 till 9)
>>> skriva ut intervalllista
för nummer i intervalllistan: #Så länge variabelnumret (som ökar med en varje gång) finns med i listan...
# Kontrollera om variabeln ingår
# nummer till en tuppel av nummer(3 , 4 , 7 , 9 )
om nummer i (3 , 4 , 7 , 9 ): #Om variabelnumret finns i tupeln (3, 4, 7, 9)...
# Operation " ha sönder» tillhandahåller
# avsluta loopen när som helst
ha sönder
annan :
# « Fortsätta"rullar"
# slinga. Detta krävs inte här, eftersom efter denna operation
# i alla fall går programmet tillbaka till att bearbeta slingan
Fortsätta
annan :
# « annan» Det är inte nödvändigt att ange. Villkoret är uppfyllt
# om slingan inte avbröts med " ha sönder».
passera # Inget att göra

om intervalllista == 2:
skriva ut "Det andra objektet (listorna är 0-baserade) är 2"
elif intervalllista == 3:
skriva ut "Det andra objektet (listorna är 0-baserade) är 3"
annan :
skriva ut"Vet inte"

medan intervalllista == 1 :
passera

Funktioner

För att deklarera en funktion, använd nyckelord " def» . Funktionsargument anges inom parentes efter funktionsnamnet. Du kan ange valfria argument och ge dem ett standardvärde. Funktioner kan returnera tupler, i vilket fall du måste skriva returvärdena separerade med kommatecken. Nyckelord " lambda" används för att deklarera elementära funktioner.

# arg2 och arg3 är valfria argument, ta värdet som deklareras som standard,
# om du inte ger dem ett annat värde när du anropar funktionen.
def myfunction(arg1, arg2 = 100, arg3 = "test"):
lämna tillbaka arg3, arg2, arg1
#Funktionen anropas med värdet av det första argumentet - "Argument 1", det andra - som standard och det tredje - "Namnsamt argument".
>>>ret1, ret2, ret3 = myfunction("Argument 1" , arg3 = "Namnlagt argument")
# ret1, ret2 och ret3 tar värdena "Named argument", 100, "Argument 1" respektive
>>> skriva ut ret1, ret2, ret3
Namngiven argument 100 Argument 1

# Följande post är likvärdig def f(x): lämna tillbaka x+1
functionvar = lambda x:x+1
>>> skriva ut functionvar(1)
2

Klasser

Python-språket är begränsat i multipla arv i klasser. Interna variabler och interna klassmetoder börjar med två understreck "__" (till exempel "__myprivatevar"). Vi kan även tilldela en klassvariabel ett värde utifrån. Exempel:

klass Min klass:
vanligt = 10
def __i sig själv):
self .myvariable = 3
def min funktion(själv, arg1, arg2):
lämna tillbaka self .myvariable

# Här har vi deklarerat klassen My klass. Funktionen __init__ anropas automatiskt när klasser initieras.
>>> klassinstans = Min klass() # Vi har initierat klassen och variabeln myvariable har värdet 3 som anges i initialiseringsmetoden
>>> #Metod minfunktion i klass My klass returnerar värdet på variabeln minvariabel
3
# Den gemensamma variabeln deklareras i alla klasser
>>> classinstance2 = Min klass()
>>> classesinstance.common
10
>>> classesinstance2.common
10
# Så om vi ändrar dess värde i Min klass klass Kommer förändras
# och dess värden i objekt som initierats av klassen Min klass
>>> Myclass.common = 30
>>> classesinstance.common
30
>>> classesinstance2.common
30
# Och här ändrar vi inte klassvariabeln. Istället för det här
# vi deklarerar det i ett objekt och tilldelar det ett nytt värde
>>> classesinstance.common = 10
>>> classesinstance.common
10
>>> classesinstance2.common
30
>>> Myclass.common = 50
# Att ändra klassvariabeln kommer inte att påverka
# variabla objekt av denna klass
>>> classesinstance.common
10
>>> classesinstance2.common
50

# Nästa klass är en ättling till Min klass klass
# genom att ärva dess egenskaper och metoder, vem kan klassen
# ärva från flera klasser, i det här fallet posten
# så här: klass Otherclass(Minklass1, Minklass2, MinklassN)
klass Annanklass (Min klass):
def __init__(själv, arg1):
self .myvariable = 3
skriva ut arg1

>>> classinstance = Otherclass("hej")
Hallå
>>> classesinstance.myfunction(1 , 2 )
3
# Den här klassen har inte egenskapstestet, men vi kan
# deklarera en sådan variabel för ett objekt. Dessutom
# denna variabel kommer bara att vara medlem klass exempel.
>>> classinstance.test = 10
>>> classesinstance.test
10

Undantag

Undantag i Python har en struktur Prova-bortsett från [bortsett från jonnamn]:

def somefunction():
Prova :
# Division med noll orsakar ett fel
10 / 0
bortsett från ZeroDivisionError:
# Men programmet "Utför en olaglig operation"
# Och hanterar undantagsblocket som motsvarar felet "ZeroDivisionError".
skriva ut"Hoppsan, ogiltig."

>>> fn bortsett från()
Hoppsan, ogiltig.

Importera

Externa bibliotek kan anslutas med proceduren " importera", var är namnet på biblioteket som ansluts. Du kan också använda kommandot " från importera" så att du kan använda en funktion från biblioteket

importera slumpmässig #Importera det "slumpmässiga" biblioteket
från tid importera klocka #Och samtidigt "klocka"-funktionen från "tid"-biblioteket

Randomint = random .randint(1 , 100 )
>>> skriva ut slumpmässigt
64

Arbeta med filsystemet

Python har många inbyggda bibliotek. I det här exemplet kommer vi att försöka spara en liststruktur i en binär fil, läsa den och spara strängen i en textfil. För att transformera datastrukturen kommer vi att använda standardbiblioteket "pickle"

importeraättikslag
mylist = ["Detta" , "är" , 4 , 13327 ]
# Öppna filen C:\binary.dat för att skriva. "r" symbol
# förhindrar ersättning av specialtecken (som \n, \t, \b, etc.).
minfil = fil (r"C:\binary.dat" , "w")
pickle .dump(mylist, myfile)
myfile.close()

Min fil = fil (r"C:\text.txt", "w")
myfile.write("Detta är en exempelsträng" )
myfile.close()

Min fil = fil (r"C:\text.txt")
>>> skriva ut myfile.read()
"Detta är en exempelsträng"
myfile.close()

# Öppna filen för läsning
minfil = fil (r"C:\binary.dat")
loadedlist = pickle .load(minfil)
myfile.close()
>>> skriva ut laddad lista
["Detta" , "är" , 4 , 13327 ]

Egenheter

• Villkor kan kombineras. 1 < a < 3 выполняется тогда, когда а больше 1, но меньше 3.
• Använd operationen " del"till rensa variabler eller arrayelement.
• Python erbjuder stora möjligheter för arbetar med listor. Du kan användaer. Operatör för låter dig specificera listelement i en specifik sekvens, och om- låter dig välja element efter villkor.

>>> lst1 =
>>> lst2 =
>>> skriva ut
>>> skriva ut
# Operatören "alla" returnerar sant om fastän
# om ett av villkoren som ingår i den är uppfyllt.
>>> någon(i % 3 för jag i)
Sann
# Följande procedur räknar antalet
# matchande element i listan
>>> summa (1 för jag in om jag == 3)
3
>>> del lst1
>>> skriva ut lst1
>>> del lst1

• Globala variabler deklareras utanför funktioner och kan läsas utan några deklarationer. Men om du behöver ändra värdet på en global variabel från en funktion, måste du deklarera det i början av funktionen med nyckelordet " global" om du inte gör detta kommer Python att deklarera en variabel som bara är tillgänglig för den funktionen.

nummer = 5

def myfunc():
# Utgångar 5
skriva ut siffra

def anotherfunc():
# Detta ger ett undantag eftersom den globala variabeln
# anropades inte från en funktion. Python i det här fallet skapar
# variabel med samma namn i den här funktionen och tillgänglig
# endast för operatörer av denna funktion.
skriva ut siffra
nummer = 3

def yetanotherfunc():
global siffra
# Och endast från denna funktion ändras värdet på variabeln.
nummer = 3

Epilog

Naturligtvis beskriver den här artikeln inte alla funktioner i Python. Jag hoppas att den här artikeln kommer att hjälpa dig om du vill fortsätta lära dig detta programmeringsspråk.

Fördelar med Python

• Exekveringshastigheten för program skrivna i Python är mycket hög. Detta beror på det faktum att de viktigaste Python-biblioteken
  är skrivna i C++ och tar mindre tid att slutföra uppgifter än andra högnivåspråk.
• På grund av detta kan du skriva dina egna Python-moduler i C eller C++
• I de vanliga Python-biblioteken kan du hitta verktyg för att arbeta med e-post, protokoll
  Internet, FTP, HTTP, databaser, etc.
• Skript skrivna med Python körs på de flesta moderna operativsystem. Denna portabilitet gör att Python kan användas i ett brett spektrum av applikationer.
• Python är lämplig för alla programmeringslösningar, oavsett om det är kontorsprogram, webbapplikationer, GUI-applikationer, etc.
• Tusentals entusiaster från hela världen arbetade med utvecklingen av Python. Stödet för modern teknik i standardbibliotek kan tillskrivas det faktum att Python var öppet för alla.

Taggar:

• Pytonorm
• programmering
• lektion

Lägg till taggar

Python kommer till sådana sällsynta programmeringsstilar som kan läras enkelt och samtidigt svåra. Du kommer att bli glad över att lätt kunna koncentrera dig på själva problemets tyngd snarare än på syntaxen och strukturen i språket du skriver.

Officiell introduktion till Python-språket kommer:

Python är lätt att lära sig och lätt att programmera. Den erbjuder effektiva datastrukturer på hög nivå och en enkel men effektiv metod för objektorienterad programmering. Språkets eleganta syntax och dynamiska skrivning kombineras med den kommandotolkade karaktären hos Python för att göra det idealiskt för skript och snabb programutveckling inom ett brett spektrum av industrier och plattformar.

Det räcker inte att bara visa "Hello, World" på skärmen, eller hur? Du vill tjäna mer för detsamma - du vill ta bort vissa data från handlaren, bestämma vilka åtgärder du kan vidta från dem och vad du ska ta bort från dem. Vi kan få det här från Python Vicor. konstanter och förändringar.

Bokstavliga konstanter

Ett exempel på en bokstavlig konstant kan till exempel vara ett tal. 5, 1,23 chi, till exempel, rad: "Rad!". Hushålls PD LITHERIAL KONTAKT ROSUMENT Konstant (PISLLY VROKENSHENT INTE JA I SLEKTIONEN), Yak ingår i texten till passen av BezpoS -S -Serdanyo, bokstavligen, Tobto kan inte återvända åtkomst, efter att ha kallat ZI Zmіninoi. Detaljerna är grumliga, även om den numeriska sekventiella typen ingår i programmet som ett resultat (ändringen kan inte påverkas av en bokstavlig konstant).

Tal

Det finns tre typer av tal i Python: heltal, flyttal och komplexa tal.

Ett exempel på ett heltal kan vara talet 2.

Rumpan av siffror med en flytande klump är 3,23.

Exemplet på komplexa tal är: 52.3E-4.

Respekt för avancerade testprogrammerare

Python har ingen datatyp associerad med "long int". Skriv int mozhe buti yak zavgodno dovgim.

Rader

En rad är en sekvens av symboler. Zagalom, raderna pressar helt enkelt avloppet. Ord kan skrivas på vilket språk som helst som följer Unicode-standarden, vilket innebär att de kan skrivas på vilket språk som helst på jorden.

Jag kan försäkra dig om att du kommer att vinna raderna i alla Python-program, så var respektfull till slutet av dagen.

Enstaka fötter

Du kan skapa en rad med viktori och enstaka ben precis som "Citat mig på detta". Alla deltecken visas som t.ex.

Dubbla ben

Raderna på dubbelbenen bildas på samma sätt som raderna på enkelbenen. Exempel: "Vad heter du?".

Trippel tassar

Du kan utse ett stort antal rader av segrare. trippelben (""" eller """). Dubbla och enkelben kan mycket väl placeras mitt på benen. Stånga:

"""Detta är en flerradssträng. Det här är den första raden. Det här är den andra raden. "Vad heter du?" frågade jag. Han sa "Bond, James Bond". """

Nyckelsekvenser

Låt oss säga, vad vill du göra i en rad som med en enkel fot (""), hur menar du till exempel raden Vad heter du?. Du kan inte skriva "Vad heter du?" eftersom Python inte kan se var en rad börjar och var den slutar. Så du måste påpeka att tassen inte indikerar slutet på en rad. Du kan tjäna pengar genom att snabbt tjäna sådana titlar kärnsekvenser.Du måste skriva \" - respektera kragens flätningslinje. Nu kan du markera raden så här: "Vad heter du?

Ett annat sätt på vilket du kan identifiera den här specifika raden är att skriva axeln så här: "Vad heter du?"

Varför skulle du vilja visa en logisk sekvens av expansioner på två fysiska rader? Ett av de möjliga sätten att vrida de tredje benen, men det finns också ett annat alternativ - att vrida kärnsymbolen för att tilldela kolven för en ny rad - \n. Vikoristan rumpa:

(pre class="brush: python; gutter:false;" )Detta är den första raden\nDetta är den andra raden(/pre)

En annan vanlig sekvens av nyckeltecken i denna post är \t. Det finns många andra viktiga symboler, men jag respekterar bara de viktigaste.

Observera att en symbol \ i slutet av raden betyder att raden fortsätter på den framåtgående raden, annars kommer inga symboler att läggas till på den nya raden! Stånga:

"Detta är den första meningen.\ Det här är den andra meningen."

vilket motsvarar "Detta är den första meningen." Det här är den andra meningen."

Outplånade rader

Om du behöver ange en rad behöver du inte bearbeta samma specialtecken, vilket kräver att du skriver bokstaven r eller R överst på raden. Stånga:

R"Nylinjer indikeras av \n"

Rader är oföränderliga

Det betyder att från det ögonblick du skapar en rad kan du inte ändra den. Skriv till exempel someString="a". Det kan se dåligt ut, men i verkligheten är det inte så.

Kombinera rader

Om du placerar två rader i rad kommer stinken automatiskt att kombineras (sammanläts). Till exempel, "Vad är" "ditt namn?" blir automatiskt "Vad heter du?".

Respekt för C/C++-programmerare

Python har ingen datatyp associerad med char. Det finns inget riktigt behov av det, och jag undrar vad du går igenom.

Respekt för Perl/PHP-programmerare

Kom ihåg att det inte är någon skillnad mellan raderna med dubbel- och enkelben.

Respekt för koristuvachs av vanliga virus

För det första plockas inte raderna upp om du tar upp vanliga grödor. Annars kan du behöva många skärmar. Till exempel kan grindlänkar betecknas som "\\1" eller "\1".

formatmetod

Ibland kanske vi vill skapa en rad annan information. Axis de method format() används nu.

#!/usr/bin/python # Filnamn: str_format.py ålder = 25 namn = "Swaroop" print("(0) är (1) år gammal".format(namn, ålder)) print("Varför är (0) ) leker med den där pytonen?".format(name))

Vivede:

$python str_format.py

Swaroop är 25 år gammal

Varför spelar Swaroop med den pytonen?

Hur fungerar detta?

I mitten av raden satte vi in ​​specifikationssträngarna och kallade formatmetoden. Detta ersätter dessa specifikationer med samma argument som skickas till metoden. Den första specifikationen är (0), vilket indikerar variabelnamnet, vilket är det första argumentet för det angivna metodformatet. Samma historia med en annan specificator - (1), vilket motsvarar ett annat argument - ålder.

Observera att vi också kan uppnå samma resultat genom att påskynda sammansättningen av rader: namn + "är" + str(ålder) + "år gammal", men kom också ihåg de som är svårare att uppnå, dessutom denna metod kan öka kvantiteten benådning. Konvertering till en radtyp genereras automatiskt (med formatmetoden). Det finns inget behov av att göra det explicit, manuellt. Koli Vikor. Formatmetoden kan ändras utan krångel.

Vad Python gör är att ersätta vissa specifikationer med argument. Du kan använda snabbare och mer detaljerade specifikationer:

>>> "(0:.3)".format(1/3)# tal med bråkdel (.). Noggrannhet 3 tecken "0.333" >>> "(0”__^11)".format("hej")# fyll i de nedre blocken. Text #vіdcentered (^) to date 11 "___hello___" >>> "(name) wrote (book)".format(name="Swaroop", book="A Byte of Python")#keywords "Swaroop wrote A Byte of Pytonorm"

Detaljer om formateringen av specifikationen förklaras i Python Enhancement Proposal No. 3101 (http://www.python.org/dev/peps/pep-3101/).

Begreppet förändring

Att bara använda bokstavliga konstanter kan snabbt bli tråkigt – vi behöver ett sätt att lagra och manipulera information. Yxor här kommer att vara till stor nytta för oss. Begreppet föränderlig betyder samma sak som ordet i sig betyder - dess betydelser kan ändras, med andra ord, du kan spara vilken data som helst genom att ändra den. Minnet är helt enkelt en del av din dators minne som innehåller information. När du byter ut bokstavliga konstanter behöver du något sätt att neka åtkomst till bokstavliga konstanter och därigenom ge dem namn.

Namnge identifierare

Ändringar inkluderar ändan av identifierare. I sin tur är identifierare namn som indikerar (identifierar). Här är reglerna du måste följa när du namnger identifierare:

1) Det första tecknet i identifieraren är bokstavsstarten (ett tecken från ASCII- eller Unicode-teckenuppsättningen, beroende på vilket register) och understrecket är "_".

2) Svaret på identifieraren kan bestå av bokstäver, siffror eller lägre symboler.

3) Identifieringsnamn är skiftlägeskänsliga. Till exempel, myname och myName är inte samma sak (det finns olika ändringar).

4) Exemplet på de korrekta identifierarnamnen är i, __my_name, name_23, a1b2_c3 och resumÃÆ'Æâ€TMÆ’ÃÆ'‚Ã⠀šÃ‚©_count .

5) Exempel på felaktiga identifierarnamn: 2 saker, detta är utskilt, mitt namn, "detta_är_i_citattecken".

Tipi hyllar

Alternativ kan innehålla värden som gäller för olika typer av data. De grundläggande typerna är siffror och rader. Därefter kommer vi att titta på hur man skapar kraft i dessa typer av data genom att korrumpera klasser.

Föremål

Kom ihåg att Python gäller allt som läggs till programmet som ett objekt.

Respekt för medlemmarna i PLO

Python är ännu mer objektorienterat eftersom allt är ett objekt, inklusive grundläggande typer som rader, siffror och funktioner.

Vi kan nu börja använda bokstavliga konstanter samtidigt. Spara din rumpa och kör programmet.

Exempel: en studie av variabla och bokstavliga konstanter

#Filnamn: var.py i = 5 print(i) i=i+1 #eller i+=1. Denna konstruktion är mer effektiv print(i) s="""Detta är en flerradssträng. Detta är den andra raden""" print(s)

Vad ser du på skärmen:

$python var.py

Detta är en flerradssträng.

Detta är den andra raden.

Så här fungerar det:

Vi tilldelade först siffran 5 till namnet i med hjälp av tilldelningsoperatorn (=). Den här raden kallas bekräftelsen på att den är baserad på att den kan delas upp, i det här fallet har vi tagit värdet på förändringen från siffran 5. Därefter har vi visat på skärmen värdet på förändringen och vikory-funktionen ktsіyu print, yak, yak det är inte underbart, visa bara ändringsvärdena på skärmen.

Sedan lade vi till 1 till värdet som skulle placeras i ändringen och vände tillbaka det till samma ändring. Generellt går konstruktionen i=i+1 upp till värdet där siffran 1 är placerad i variabeln i, och tilldelar sedan variabeln i till nya värden (den roterar resultatet av operationen 5+1 i variabel). Följande ska läsas från höger till vänster (Starta Python-tolken i interaktivt läge och försök att skriva i=5 först och sedan i+1. Efter skaloperationen visas värdena för ändringen (bara skriv namnet på ormen nnnoї)).

Respekt för programmerare på statisk språkprogrammering

Ändringar tilldelas (de kan börja modifieras) omedelbart efter att något värde har tilldelats (skriv bara namnet på ändringen, operatören som tilldelats och värdet för ändringen). Det behövs ingen specifik information om typen av data.

Skillnaden mellan logiska och fysiska rader av text

I en logisk ordning, betrakta EN avslutad påstående (vi kommer att notera att en sådan färdig konstruktion är en påstående) för Python. Tricket är att sådana instruktioner har ett tecken i slutet som indikerar att de är slutförda (som en fläck i en mening, om du inte sätter en fläck i slutet av meningen kommer det inte att vara tydligt att processen är klar Du vill fortfarande säga). Kalla det med detta tecken є ;. På sådana språk, programmerade som C, C++, etc., i slutet av hudinstruktionerna, satte OBOVYAZKOVO en prick med koma. Python, å andra sidan, är boven - det är inte svårt att arbeta här, och de flesta Python-program kommer inte att störa dig. Ale respektera att om du inte bryr dig, så kan operatören sprida ut sig på en rad, så

A=5 print(a)

fel, men från

A=5 print(a)

Höger.
För att sprida dekalen för operatörerna på en fysisk rad av spåret efter huden, sätt in en prick med koma:

A=5; print(a); b=input("Hur gammal är du?")#den här koden fungerar. Det är ingen tystnad i slutet; så det fanns en fortsättning på strukturen i denna fysiska sekvens

Implicit vill Python öva en rad - en instruktion. Målet är att göra koden mer läsbar (och lättare att tolka).

Det är inte heller bra att blanda olika stilar i ett program.

Eftersom det inte finns något behov av att visa en lång rad med text på skärmen, som ska delas upp i flera fysiska rader i programmets text, och som måste finnas på en fysisk rad på skärmen, skriv följande:

S="Detta är en sträng. \ Detta fortsätter strängen." grafik)

Efter att ha angett denna kod kommer följande att visas på skärmen:

Det här är ett snöre. Detta fortsätter strängen

I en liknande rang,

samma

Det kommer att finnas nedfall om det inte är nödvändigt att uttryckligen förena raderna. Det finns rader i mitten av armarna, fyrkantiga och formade armar.

Stiga på

Ingångar spelar en ännu viktigare roll i Python. Mellanslag eller poster (tabi) på huvudet av en logisk serie indikerar nivån av kapsling av en logisk serie, som på sitt eget sätt segrar för att gruppera operatörer (på många andra språk, vars programmering är vikoriserad ()).

Det innebär att operatörerna samtidigt ansvarar för samma investeringsnivå. En sådan uppsättning operatörer kallas ett block. Senare får vi lära oss hur viktiga blocken är.

Du kommer inte ihåg ett mycket viktigt tal, men fel antal ingångar kan leda till skuldkänslor.. För baken:

I=5 print("Värdet är ", i) #Gör en deal! Respektera utrymmet på kolvtrycket ("Jag upprepar, värdet är", i)

Om du släpper det kommer du att avbryta välviljan:

Filen "whitespace.py", rad 4

print("Värdet är", i) #Gör en deal! Respekten slog mot kolven

IndentationError: oväntat indrag

Hur närmar man sig rätt?

Det är inte på något sätt en viktoriumblandning av luckor och kopplingar! Varto vikoristuvati endast eller 4-Ochnedtryckt eller en inmatning (Tabb-tangent)

Python programmering

Del 1. Språkförmågor och grundläggande syntax

Innehållsserie:

Är det värt att lära sig Python?

Python är ett av de mest populära moderna programmeringsspråken. Det är lämpligt för att lösa en mängd olika problem och erbjuder samma möjligheter som andra programmeringsspråk: dynamik, OOP-stöd och plattformsoberoende. Utvecklingen av Python började av Guido Van Rossum redan i mitten av 1990-talet, så vid det här laget har det varit möjligt att bli av med vanliga "barnsjukdomar", avsevärt utveckla de bästa aspekterna av språket och attrahera många programmerare som använder Python för att implementera deras projekt.

Många programmerare tror att det är nödvändigt att bara lära sig "klassiska" programmeringsspråk som Java eller C++, eftersom andra språk ändå inte kommer att kunna tillhandahålla samma möjligheter. Men nyligen har det uppstått en uppfattning om att det är tillrådligt för en programmerare att kunna mer än ett språk, eftersom detta vidgar hans vyer, gör att han kan lösa problem mer kreativt och öka sin konkurrenskraft på arbetsmarknaden.

Att lära sig två språk som Java och C++ perfekt är ganska svårt och skulle ta mycket tid; dessutom motsäger många aspekter av dessa språk varandra. Samtidigt är Python idealisk för rollen som ett andra språk, eftersom det omedelbart absorberas tack vare den redan befintliga kunskapen om OOP, och det faktum att dess kapacitet inte står i konflikt, utan kompletterar erfarenheten från att arbeta med en annan programmering språk.

Om en programmerare precis har börjat inom området mjukvaruutveckling, kommer Python att vara ett idealiskt "introduktions" programmeringsspråk. Tack vare dess korthet kommer det att tillåta dig att snabbt behärska språkets syntax, och frånvaron av "arv" i form av axiom bildade under många år kommer att hjälpa dig att snabbt bemästra OOP. På grund av dessa faktorer kommer inlärningskurvan för Python att vara ganska kort, och programmeraren kommer att kunna gå från pedagogiska exempel till kommersiella projekt.

Därför, oavsett vem läsaren av den här artikeln är - en erfaren programmerare eller en nybörjare inom området mjukvaruutveckling, bör svaret på frågan, som är rubriken på det här avsnittet, vara ett rungande "ja".

Den här artikelserien är utformad för att hjälpa dig att framgångsrikt övervinna inlärningskurvan genom att tillhandahålla information från språkets mest grundläggande principer till dess avancerade möjligheter för integration med andra teknologier. Den första artikeln kommer att täcka de grundläggande funktionerna och syntaxen i Python. I det följande kommer vi att titta på mer avancerade aspekter av att arbeta med detta populära språk, i synnerhet objektorienterad programmering i Python.

Python arkitektur

Alla språk, oavsett om det är för programmering eller kommunikation, består av minst två delar - ordförråd och syntax. Python-språket är organiserat på exakt samma sätt och tillhandahåller en syntax för att bilda uttryck som bildar körbara program, och ett ordförråd - en uppsättning funktioner i form av ett standardbibliotek och plugin-program.

Som nämnts är Pythons syntax ganska kortfattad, speciellt jämfört med Java eller C++. Å ena sidan är detta bra, eftersom ju enklare syntax, desto lättare är det att lära sig och desto färre misstag kan du göra när du använder den. Sådana språk har dock en nackdel - de kan användas för att förmedla den enklaste informationen och kan inte uttrycka komplexa strukturer.

Detta gäller inte Python, eftersom det är ett enkelt men förenklat språk. Faktum är att Python är ett språk med en högre abstraktionsnivå, högre till exempel än Java och C++, och låter dig förmedla samma mängd information i en mindre mängd källkod.

Python är också ett allmänt bruksspråk, så det kan användas i nästan alla områden av mjukvaruutveckling (fristående, klient-server, webbapplikationer) och inom alla ämnesområden. Dessutom integreras Python enkelt med befintliga komponenter, vilket gör att du kan bädda in Python i applikationer du redan har skrivit.

En annan komponent i Pythons framgång är dess tilläggsmoduler, både standard och specifika. Standard Python-tilläggsmoduler är väldesignade och beprövade funktionalitet för att lösa problem som uppstår i varje programvaruutvecklingsprojekt, sträng- och textbehandling, interaktion med operativsystemet och stöd för webbapplikationer. Dessa moduler är också skrivna i Python, så de har sin viktigaste egenskap - plattformsoberoende, vilket gör att du smärtfritt och snabbt kan överföra projekt från ett operativsystem till ett annat.

Om den nödvändiga funktionaliteten inte finns i Python-standardbiblioteket kan du skapa din egen tilläggsmodul för efterföljande upprepad användning. Det är värt att notera här att tilläggsmoduler för Python kan skapas inte bara i själva Python-språket, utan även med andra programmeringsspråk. I det här fallet är det möjligt att mer effektivt implementera resurskrävande uppgifter, såsom komplexa vetenskapliga beräkningar, men fördelen med plattformsoberoende går förlorad om tilläggsmodulens språk inte i sig är plattformsoberoende, som Python.

Python körtid

Som ni vet är alla plattformsoberoende programmeringsspråk byggda på samma modell: det är verkligen bärbar källkod och en runtime-miljö, som inte är portabel och specifik för varje specifik plattform. Denna exekveringsmiljö inkluderar vanligtvis en tolk som kör källkoden och olika verktyg som behövs för att underhålla applikationen - en debugger, omvänd assembler, etc.

Java runtime-miljön innehåller också en kompilator eftersom källkoden måste kompileras till bytekod för den virtuella Java-maskinen. Python-körtiden innehåller endast en tolk, som också är en kompilator men kompilerar Python-källkoden direkt till maskinkoden på målplattformen.

Det finns för närvarande tre kända runtime-implementationer för Python: CPython, Jython och Python.NET. Som namnet antyder är det första ramverket implementerat i C, det andra i Java och det sista i .NET-plattformen.

CPython-körtiden brukar kallas för Python, och när folk pratar om Python menar de oftast denna implementering. Denna implementering består av en tolk och tilläggsmoduler skrivna i C, och kan användas på vilken plattform som helst för vilken en standard C-kompilator finns. Dessutom finns det förkompilerade versioner av körtiden för olika operativsystem, inklusive olika versioner av Windows OS och olika distributioner Linux. I denna och efterföljande artiklar kommer CPython att beaktas, om inte annat anges separat.

Jython runtime är en Python-implementation för att köra Java Virtual Machine (JVM). Alla JVM-versioner stöds, från och med version 1.2.2 (den nuvarande Java-versionen är 1.6). Att arbeta med Jython kräver en installerad Java-maskin (Java runtime-miljö) och viss kunskap om programmeringsspråket Java. Det är inte nödvändigt att veta hur man skriver källkod i Java, men du kommer att behöva hantera JAR-filer och Java-appletar, samt dokumentation i JavaDOC-format.

Vilken version av miljön som ska väljas beror enbart på programmerarens preferenser i allmänhet, det rekommenderas att behålla både CPython och Jython på datorn, eftersom de inte kommer i konflikt med varandra, utan kompletterar varandra. CPython-miljön är snabbare eftersom det inte finns något mellanlager i form av en JVM; Dessutom släpps uppdaterade versioner av Python först som CPython-miljön. Jython kan dock använda vilken Java-klass som helst som en tilläggsmodul och köras på vilken plattform som helst för vilken det finns en JVM-implementering.

Båda runtime-miljöerna släpps under en licens som är kompatibel med den välkända GPL-licensen, så de kan användas för utveckling av både kommersiell och fri programvara. De flesta Python-tillägg är också GPL-licensierade och kan användas fritt i alla projekt, men det finns även kommersiella tillägg eller tillägg med strängare licenser. Därför, när du använder Python i ett kommersiellt projekt, måste du veta vilka begränsningar som finns i tilläggsplugin-licenserna.

Komma igång med Python

Innan du börjar använda Python måste du installera dess exekveringsmiljö - i den här artikeln är detta CPython och följaktligen pythontolken. Det finns olika installationsmetoder: erfarna användare kan själva kompilera Python från dess allmänt tillgängliga källkod, de kan också ladda ner färdiga körbara filer för ett specifikt operativsystem från webbplatsen www.python.org, och slutligen kommer många Linux-distributioner med en förinstallerad Python-tolk. Den här artikeln använder Windows-versionen av Python 2.x, men exemplen som presenteras kan köras på alla versioner av Python.

Efter att installationsprogrammet har distribuerat Python-körbara filer till den angivna katalogen, måste du kontrollera värdena för följande systemvariabler:

• VÄG. Denna variabel måste innehålla sökvägen till katalogen där Python är installerad så att operativsystemet kan hitta den.
• PYTHONHOME. Denna variabel bör endast innehålla sökvägen till katalogen där Python är installerat. Denna katalog bör också innehålla en lib-underkatalog som kommer att sökas efter standard Python-moduler.
• PYTHONPATH. En variabel med en lista över kataloger som innehåller tilläggsmoduler som kommer att kopplas till Python (listelement måste separeras med en systemavgränsare).
• PYTHONSTARTUP. En valfri variabel som anger sökvägen till Python-skriptet som ska köras varje gång en interaktiv Python-tolksession startas.

Kommandoraden för att arbeta med tolken har följande struktur.

PYTHONHOME\python (alternativ) [ -c kommando | skriptfil | - ] (argument)

Python interaktivt läge

Om du startar tolken utan att ange ett kommando eller en skriptfil kommer den att starta i interaktivt läge. I det här läget startas ett speciellt Python-skal i vilket enskilda kommandon eller uttryck kan matas in, och deras värde beräknas omedelbart. Detta är mycket praktiskt när du lär dig Python, eftersom du omedelbart kan kontrollera riktigheten av en viss konstruktion.

Värdet på det utvärderade uttrycket lagras i en speciell variabel som kallas Single Underscore (_) så att det kan användas i efterföljande uttryck. Du kan avsluta en interaktiv session med kortkommandot Ctrl–Z på Windows eller Ctrl–D på Linux.

Alternativ är valfria strängvärden som kan ändra beteendet hos tolken under en session; deras betydelse kommer att diskuteras i denna och efterföljande artiklar. Alternativen anger antingen ett specifikt kommando som ska köras av tolken eller sökvägen till en fil som innehåller skriptet som ska köras. Det är värt att notera att ett kommando kan bestå av flera uttryck, separerade med semikolon, och måste omges av citattecken så att operativsystemet korrekt kan skicka det till tolken. Argument är de parametrar som skickas för efterföljande bearbetning till det körbara skriptet; de skickas till programmet som strängar och separeras med mellanslag.

För att verifiera att Python är korrekt installerat och fungerar korrekt kan du köra följande kommandon:

c:\>python-v
c:\> python –c “importtid; print time.asctime()"

Alternativet -v skriver ut versionen av Python-implementationen som används och avslutas, medan det andra kommandot skriver ut systemets tidsvärde på skärmen.

Du kan skriva Python-skript i vilken textredigerare som helst, eftersom de är vanliga textfiler, men det finns också speciella utvecklingsmiljöer som är utformade för att fungera med Python.

Grundläggande om Python-syntax

Python-källkodsskript består av sk logiska strängar, som var och en i sin tur består av fysiska linjer. Symbolen # används för att beteckna kommentarer. Tolken ignorerar kommentarer och tomma rader.

Följande är en mycket viktig aspekt som kan tyckas konstigt för programmerare som lär sig Python som ett andra programmeringsspråk. Faktum är att det i Python inte finns någon symbol som skulle vara ansvarig för att separera uttryck från varandra i källkoden, som semikolon (;) i C++ eller Java. Ett semikolon låter dig separera flera instruktioner om de är på samma fysiska linje. Det finns inte heller någon konstruktion som lockiga hängslen (), som låter dig kombinera en grupp instruktioner till ett enda block.

Fysiska linjer separeras av själva radens sluttecken, men om uttrycket är för långt för en rad, kan de två fysiska linjerna kombineras till en logisk rad. För att göra detta måste du ange ett omvänt snedstreck (\) i slutet av den första raden, och sedan tolkar tolken nästa rad som en fortsättning på den första, men det är omöjligt att det finns andra tecken på första raden efter \-tecknet, till exempel en kommentar med #. Endast indrag används för att markera kodblock. Logiska linjer med samma indragsstorlek bildar ett block, och blocket slutar när en logisk linje med mindre indragsstorlek visas. Det är därför den första raden i ett Python-skript inte bör indragas. Att bemästra dessa enkla regler hjälper dig att undvika de flesta misstag som är förknippade med att lära dig ett nytt språk.

Det finns inga andra radikala skillnader i Python-syntax från andra programmeringsspråk. Det finns en standarduppsättning med operatorer och nyckelord, av vilka de flesta redan är bekanta för programmerare, medan Python-specifika kommer att behandlas i denna och efterföljande artiklar. Standardregler används också för att specificera identifierare för variabler, metoder och klasser - namnet måste börja med ett understreck eller ett latinskt tecken oavsett skiftläge och får inte innehålla tecknen @, $, %. Dessutom kan endast ett understreckstecken inte användas som en identifierare (se fotnoten som talar om interaktivt driftläge).

Datatyper som används i Python

Datatyperna som används i Python är också desamma som andra språk - heltals- och riktiga datatyper; Dessutom stöds en komplex datatyp - med en reell och imaginär del (ett exempel på ett sådant tal är 1,5J eller 2j, där J är kvadratroten av -1). Python stöder strängar som kan omges av enkla, dubbla eller trippelcitattecken, och strängar, som Java, är oföränderliga objekt, d.v.s. kan inte ändra deras värde efter skapandet.

Python har också en logisk datatyp bool med två värdealternativ – True och False. Men i äldre versioner av Python fanns det ingen sådan datatyp, och dessutom kunde vilken datatyp som helst castas till det booleska värdet True eller False. Alla icke-nolltal och icke-tomma strängar eller samlingar av data behandlades som Sant, och tomma värden och nollvärden behandlades som Falskt. Den här funktionen har bevarats i nya versioner av Python, men för att öka kodläsbarheten rekommenderas det att använda bool-typen för booleska variabler. Samtidigt, om du behöver bibehålla bakåtkompatibilitet med äldre Python-implementeringar, bör du använda 1 (True) eller 0 (False) som booleska variabler.

Funktionalitet för att arbeta med datamängder

Python definierar tre typer av samlingar för lagring av datamängder:

• tupel (tupel);
• lista(lista);
• lexikon.

En tupel är en oföränderlig ordnad sekvens av data. Den kan innehålla element av olika typer, som andra tupler. En tupel definieras inom parentes och dess element separeras med kommatecken. En speciell inbyggd funktion, tuple(), låter dig skapa tupler från en given datasekvens.

En lista är en föränderlig, ordnad sekvens av element. Listelement separeras också med kommatecken, men anges inom hakparenteser. För att skapa listor föreslås list()-funktionen.

En ordbok är en hashtabell som lagrar ett element tillsammans med dess identifieringsnyckel. Efterföljande åtkomst till element utförs också med nyckel, så lagringsenheten i en ordbok är ett objekt-nyckelpar och ett tillhörande värdeobjekt. En ordbok är en föränderlig men oordnad samling, så ordningen på element i ordboken kan ändras över tiden. Ordboken är specificerad med klammerparenteser, nyckeln separeras från värdet med ett kolon och själva nyckel/värdeparen separeras med kommatecken. Funktionen dict() är tillgänglig för att skapa ordböcker.

Lista 1 visar exempel på de olika samlingarna som finns tillgängliga i Python.

Lista 1. Typer av samlingar tillgängliga i Python

('w','o','r','l','d') # tuppel av fem element (2.62,) # tupel av ett element ["test","mig"] # lista med två element # tom lista ( 5:'a', 6:'b', 7:'c') # ordbok med tre element med nycklar av typen int

Definiera funktioner i Python

Även om Python stöder OOP, är många av dess funktioner implementerade som separata funktioner; Dessutom görs tilläggsmoduler oftast i form av ett bibliotek med funktioner. Funktioner används också i klasser, där de traditionellt kallas metoder.

Syntaxen för att definiera funktioner i Python är extremt enkel; med hänsyn till ovanstående krav:

def FUNCTION_NAME(parametrar): uttryck nr 1 uttryck nr 2 ...

Som du kan se är det nödvändigt att använda funktionsordet def, kolon och indrag. Att anropa funktionen är också väldigt enkelt:

FUNCTION_NAME(parametrar)

Det finns bara några Python-specifika saker att tänka på. Som i Java skickas primitiva värden av värde (en kopia av parametern skickas till funktionen, och den kan inte ändra värdet som sattes innan funktionen anropades), och komplexa objekttyper skickas genom referens (en referens är skickas till funktionen och det kan mycket väl ändra objektet).

Parametrar kan skickas antingen helt enkelt genom listordning eller genom namn, i det här fallet behöver du inte specificera när du anropar de parametrar för vilka det finns standardvärden, utan skicka endast obligatoriska sådana eller ändra ordningen på parametrar när du anropar en funktion:

#funktion som utför heltalsdivision - med operatorn // def foo(delimoe, delitel): return delimoe // delitel print divide(50,5) # resultat av arbetet: 10 print divide(delimoe=50) # resultat fungerar: 10

En funktion i Python måste returnera ett värde – detta görs antingen explicit genom att använda en return-sats följt av retur-värdet, eller, i avsaknad av en return-sats, genom att returnera en None-konstant när slutet av funktionen nås. Som du kan se från exempelfunktionsdeklarationerna behöver man i Python inte specificera om något returneras från en funktion eller inte, men om en funktion har en retursats som returnerar ett värde måste andra retursatser i den funktionen returnera värden, och om ett sådant värde nej, måste du uttryckligen ange return None.

Om funktionen är väldigt enkel och består av en rad, så kan den definieras precis vid användningsstället i Python, en sådan konstruktion kallas för en lambdafunktion. En lambda-funktion är en anonym funktion (utan sitt eget namn), vars brödtext är en retursats som returnerar värdet av något uttryck. Det här tillvägagångssättet kan vara praktiskt i vissa situationer, men det är värt att notera att det är omöjligt att återanvända sådana funktioner ("där det föddes kom det väl till pass").

Det är också värt att beskriva Pythons inställning till användningen av rekursion. Som standard är rekursionsdjupet begränsat till 1000 nivåer, och när denna nivå har passerats kommer ett undantag att höjas och programmet slutar köra. Vid behov kan dock värdet på denna gräns ändras.

Funktioner i Python har andra intressanta funktioner, såsom dokumentation och möjligheten att definiera kapslade funktioner, men dessa kommer att utforskas i senare artiklar i serien med mer komplexa exempel.