Introduktion

På grund av den för närvarande observerade snabba utvecklingen av persondatorteknik sker en gradvis förändring av kraven på programmeringsspråk. Tolkade språk börjar spela en allt viktigare roll som den växande makten personliga datorer börjar ge tillräcklig körhastighet för tolkade program. Och den enda betydande fördelen med kompilerade programmeringsspråk är höghastighetskoden de producerar. När programexekveringshastigheten inte är ett kritiskt värde, högst det rätta valet det kommer att finnas ett tolkat språk som ett enklare och mer flexibelt programmeringsverktyg.

I detta avseende är det av visst intresse att överväga ett relativt nytt språk Python programmering(Python), som skapades av dess författare Guido van Rossum i början av 90-talet.

Allmän information om Python. Fördelar och nackdelar

Python är ett tolkat, inbyggt objektorienterat programmeringsspråk. Det är extremt enkelt och innehåller ett litet antal nyckelord, men är också väldigt flexibelt och uttrycksfullt. Detta är ett språk på högre nivå än Pascal, C++ och, naturligtvis, C, vilket uppnås främst genom inbyggda datastrukturer på hög nivå (listor, ordböcker, tupler).

Språkets fördelar.
En otvivelaktig fördel är att Python-tolken är implementerad på nästan alla plattformar och operativsystem. Det första språket var C, men dess datatyper på olika maskiner kunde ta upp olika mängder minne och detta fungerade som ett hinder för att skriva ett riktigt bärbart program. Python har inte en sådan nackdel.

Nästa viktiga särdrag är språkets töjbarhet tillmäts detta och, som författaren själv skriver, var språket tänkt just som töjbart. Det betyder att det är möjligt för alla intresserade programmerare att förbättra språket. Tolken är skriven i C och källa tillgänglig för all manipulation. Om det behövs kan du infoga det i ditt program och använda det som ett inbyggt skal. Eller genom att skriva dina egna tillägg till Python i C och kompilera programmet kan du få en "utökad" tolk med nya möjligheter.

Nästa fördel är närvaron av ett stort antal moduler anslutna till programmet, vilket ger olika ytterligare egenskaper. Sådana moduler är skrivna i själva C och Python och kan utvecklas av alla tillräckligt kvalificerade programmerare. Exempel inkluderar följande moduler:

• Numerisk Python - avancerade matematiska funktioner som manipulering av heltalsvektorer och matriser;
• Tkinter - bygger applikationer med ett grafiskt användargränssnitt (GUI) baserat på Tk-gränssnittet som används i stor utsträckning på X-Windows;
• OpenGL - använder ett omfattande bibliotek grafisk modellering två- och tredimensionella objekt Open Graphics Library från Silicon Graphics Inc. Denna standard stöds bland annat i sådana vanliga operativsystem som Microsoft Windows 95 OSR 2, 98 och Windows NT 4.0.

Nackdelar med språk.
Den enda nackdelen som författaren noterat är den relativt låga körhastigheten för Python-programmet, vilket beror på dess tolkningsbarhet. Men enligt vår mening kompenseras detta mer än väl av språkets fördelar när man skriver program som inte är särskilt kritiska för exekveringshastigheten.

Funktioner Översikt

1. Python, till skillnad från många språk (Pascal, C++, Java, etc.), kräver inga variabeldeklarationer. De skapas på den plats där de initieras, dvs. första gången en variabel tilldelas ett värde. Detta innebär att typen av en variabel bestäms av typen av det tilldelade värdet. I detta avseende påminner Python om Basic.
Typen av en variabel är inte oföränderlig. Varje tilldelning till den är korrekt och detta leder bara till att typen av variabeln blir typen av det nya tilldelade värdet.

2. På språk som Pascal, C, C++ gav det vissa svårigheter att organisera listor. För att implementera dem var det nödvändigt att noggrant studera principerna för att arbeta med pekare och dynamiskt minne. Och även med goda kvalifikationer kan programmeraren, varje gång omimplementera mekanismerna för att skapa, arbeta och förstöra listor, lätt göra subtila fel. Med tanke på detta har några verktyg skapats för att arbeta med listor. Till exempel har Delphi Pascal en klass TList som implementerar listor; STL-biblioteket (Standard Template Library) har utvecklats för C++ och innehåller strukturer som vektorer, listor, uppsättningar, ordböcker, stackar och köer. Sådana faciliteter är dock inte tillgängliga på alla språk och deras implementeringar.

En av särdrag Python är närvaron av strukturer inbyggda i själva språket som t.ex tupler(tuppel) listor(lista) och ordböcker(ordbok), som ibland kallas kort(Karta). Låt oss ta en närmare titt på dem.

1. Tuple . Den påminner lite om en array: den består av element och har en strikt definierad längd. Element kan vara vilka värden som helst - enkla konstanter eller objekt. Till skillnad från en array är elementen i en tupel inte nödvändigtvis homogena. Och det som skiljer en tuppel från en lista är att en tupel inte kan ändras, d.v.s. vi kan inte tilldela något nytt till det i-te tupelelementet och kan inte lägga till nya element. Således kan en tupel kallas en konstant lista. Syntaktiskt specificeras en tupel genom att lista alla element separerade med kommatecken, alla omgivna inom parentes:

(1, 2, 5, 8)
(3.14, 'sträng', -4)
Alla element indexeras från början. För att få det i-te elementet måste du ange tuppelnamnet följt av indexet i inom hakparenteser. Exempel:
t = (0, 1, 2, 3, 4)
skriv ut t, t[-1], t[-3]
Resultat: 0 4 2
Således skulle en tupel kunna kallas en konstant vektor om dess element alltid var homogena.
2. Lista . Ett bra, specifikt exempel på en lista är språksträngen Turbo Pascal. Elementen i en rad är enstaka tecken, dess längd är inte fast, det är möjligt att ta bort element eller tvärtom infoga dem var som helst på raden. Elementen i listan kan vara godtyckliga objekt, inte nödvändigtvis av samma typ. För att skapa en lista, lista bara dess element separerade med kommatecken och omge dem alla inom hakparenteser:


['sträng', (0,1,8), ]
Till skillnad från en tuppel kan listor ändras efter önskemål. Tillgång till element utförs på samma sätt som i tupler. Exempel:
l = ]
skriv ut l, l, l[-2], l[-1]
Resultat: 1 s (2,8) 0
3. Lexikon . Det påminner om posttypen i Pascal eller strukturtypen i C. Men istället för "record field" - "value"-schemat används "key" - "value" här. En ordbok är en samling nyckel-värdepar. Här är "nyckeln" en konstant av vilken typ som helst (men strängar används huvudsakligen), den tjänar till att namnge (indexera) något motsvarande värde (som kan ändras).

En ordbok skapas genom att lista dess element (nyckel-värdepar separerade med ett kolon), separerade med kommatecken och omsluta dem alla med hängslen. För att få tillgång till ett visst värde, efter ordboksnamnet, skriv motsvarande nyckel inom hakparenteser. Exempel:
d = ("a": 1, "b": 3, 5: 3,14, "namn": "John")
d["b"] = d
skriv ut d["a"], d["b"], d, d["namn"]
Resultat: 1 3,14 3,14 John
För att lägga till ett nytt nyckel-värdepar, tilldela helt enkelt motsvarande värde till elementet med den nya nyckeln:
d["new"] = "nytt värde"
tryck d
Resultat: ("a":1, "b":3, 5:3.14, "name":"John", "new":"nytt värde")

3. Python, till skillnad från Pascal, C, C++, stöder inte arbete med pekare, dynamiskt minne och adressaritmetik. På så sätt liknar det Java. Som du vet är pekare en källa till subtila fel och att arbeta med dem är mer relaterat till lågnivåprogrammering. För att ge större tillförlitlighet och enkelhet ingick de inte i Python.

4. En av funktionerna i Python är hur en variabel tilldelas en annan, d.v.s. på vardera sidan av operatören" = "det finns variabler.

Efter Timothy Budd (), kommer vi att ringa pekare semantik det fall då uppdraget endast leder till tilldelning av en referens (pekare), d.v.s. den nya variabeln blir bara ett annat namn, vilket anger samma minnesplats som den gamla variabeln. I det här fallet kommer en förändring av värdet som anges av den nya variabeln att leda till en förändring av värdet på den gamla, eftersom de betyder faktiskt samma sak.

När en tilldelning leder till skapandet av ett nytt objekt (här ett objekt - i betydelsen en bit minne för att lagra ett värde av någon typ) och kopiering av innehållet i den tilldelade variabeln till det, kallar vi detta fall kopiera semantik. Således, om kopieringsemantik gäller vid kopiering, kommer variablerna på vardera sidan av "="-tecknet att betyda två oberoende objekt med samma innehåll. Och här kommer en efterföljande förändring av en variabel inte att påverka den andra på något sätt.

Tilldelning i Python fungerar så här: if hänförlig objektet är en instans av sådana typer som siffror eller strängar, då gäller kopieringsemantik, men om det på höger sida finns en instans av en klass, lista, ordbok eller tupel, så gäller pekarsemantik. Exempel:
a = 2; b = a; b = 3
skriv ut "kopiera semantik: a=", a, "b=", b
a = ; b = a; b = 3
skriv ut "pekaresemantik: a=", a, "b=", b
Resultat:
kopia semantik: a= 2 b= 3
pekare semantik: a= b=

För er som vill veta vad som händer här, jag ger er en annan inställning till uppdrag i Python. Om vi ​​i språk som Basic, Pascal, C/C++ hanterade "kapacitet"-variabler och konstanter lagrade i dem (numeriska, symboliska, strängar - det spelar ingen roll), och tilldelningsoperationen innebar att "mata in" konstanten i den tilldelade variabeln , då måste vi i Python redan arbeta med "name"-variabler och objekten de namnger. (Du märker någon analogi med Prologspråk?) Vad är ett objekt i Python? Detta är allt som kan ges ett namn: siffror, strängar, listor, ordböcker, klassinstanser (som i Object Pascal kallas för objekt), själva klasserna (!), funktioner, moduler osv. Så när man tilldelar en variabel till ett objekt, blir variabeln dess "namn", och objektet kan ha så många sådana "namn" som önskas och de är alla oberoende av varandra.

Nu är objekt indelade i modifierbara (föränderliga) och oföränderliga. Föränderliga - de som kan ändra sitt "interna innehåll", till exempel listor, ordböcker, klassinstanser. Och oföränderliga sådana - som siffror, tupler, strängar (ja, strängar också; du kan tilldela en ny sträng som erhållits från en gammal till en variabel, men du kan inte ändra den gamla strängen själv).

Så om vi skriver a = ; b = a; b = 3, Python tolkar det så här:

ge objektet en "lista" " Namn a ;

ge detta objekt ett annat namn - b ;

ändra null-elementet för ett objekt.

Detta är hur vi får "pseudo" semantik av pekare.

En sista sak att säga om detta: även om det inte är möjligt att ändra strukturen på tupeln, är de föränderliga komponenterna den innehåller fortfarande tillgängliga för modifiering:

T = (1, 2, , "sträng") t = 6 # detta är inte möjligt del t # också ett fel t = 0 # tillåtet, nu är den tredje komponenten en lista t = "S" # fel: strängar är inte föränderlig

5. Sättet som Python grupperar operatörer på är väldigt originellt. I Pascal görs detta med operatörsparenteser början-slut, i C, C++, Java - tandställning(), i Basic används slutändelser av språkkonstruktioner (NEXT, WEND, END IF, END SUB).
I Python är allt mycket enklare: att välja ett block med uttalanden utförs genom att flytta den valda gruppen med ett eller flera mellanslag eller tabbtecken åt höger i förhållande till huvudet på strukturen som det givna blocket kommer att tillhöra. Till exempel:

om x > 0: skriv ut ' x > 0 ' x = x - 8 annars: skriv ut ' x<= 0 ’ x = 0 Således, en bra stil för skrivprogram, som lärare i språken Pascal, C++, Java, etc. kräver, förvärvas här från första början, eftersom det helt enkelt inte fungerar på något annat sätt.

Beskrivning av språket. Kontrollstrukturer

Undantagshantering

Prova: <оператор1> [bortsett från[<исключение> [, <переменная>] ]: <оператор2>] [annan <оператор3>]	Genomförde<оператор1>, om ett undantag inträffar<исключение>, då är det uppfyllt<оператор2>. Om<исключение>har ett värde, tilldelas det<переменной>. Efter framgångsrikt slutförande<оператора1>, genomförde<оператор3>.
Prova: <оператор1> till sist: <оператор2>	Genomförde<оператор1>. Om inga undantag förekommer, kör sedan<оператор2>. Annars avrättad<оператор2>och ett undantag tas omedelbart upp.
höja <исключение> [<значение>]	Kastar ett undantag<исключение>med parameter<значение>.

Undantag är bara strängar. Exempel:

My_ex = 'dåligt index' försök: om dåligt: ​​höj mitt_ex, dåligt utom mitt_ex, värde: skriv ut 'Error', value

Funktionsdeklaration

Klassdeklaration

Klass cMyClass: def __init__(self, val): self.value = val # def printVal(self): print ' value = ', self.value # # end cMyClass obj = cMyClass (3.14) obj.printVal() obj.value = " sträng nu" obj.printVal () !} Resultat:
värde = 3,14
värde = sträng nu

Operatorer för alla typer av sekvenser (listor, tupler, strängar)

Operatörer för listor (lista)

s[i] = x	Det i:te elementet s ersätts med x.
s = t	en del av elementen s från i till j-1 ersätts med t (t kan också vara en lista).
del s	tar bort s-delen (samma som s = ).
s.append(x)	lägger till element x i slutet av s.
s.count(x)	returnerar antalet element s lika med x.
s.index(x)	returnerar det minsta i:et så att s[i]==x.
s.insert(i,j)	delen av s, med början från det i:te elementet, förskjuts åt höger och s[i] tilldelas x.
s.remove(x)	samma som del s[ s.index(x) ] - tar bort det första elementet i s lika med x.
s.reverse()	skriver en sträng i omvänd ordning
s.sort()	sorterar listan i stigande ordning.

Operatörer för ordböcker

Arkivera objekt

Skapat av en inbyggd funktion öppen()(se beskrivning nedan). Till exempel: f = open('mydan.dat','r').
Metoder:

Andra språkelement och inbyggda funktioner

=	uppdrag.
skriva ut [ < c1 > [, < c2 >]* [, ] ]	visar värden< c1 >, < c2 >till standardutgång. Placerar ett mellanslag mellan argument. Om det inte finns något kommatecken i slutet av listan med argument flyttas den till en ny rad.
abs(x)	returnerar absolutvärde x.
tillämpa( f , <аргументы>)	anropar funktion (eller metod) f med< аргументами >.
chr(i)	returnerar en en-teckensträng med ASCII-kod i.
cmp(x,y)	returnerar negativt, noll eller positivt om x respektive<, ==, или >än y.
divmod (a, b)	returnerar tupel (a/b, a%b), där a/b är en div b (heltalsdelen av divisionsresultatet), a%b är en mod b (återstoden av divisionen).
eval(er)	returnerar objektet som anges i s som en sträng. S kan innehålla vilken språkstruktur som helst. S kan också vara ett kodobjekt, till exempel: x = 1 ; incr_x = eval("x+1") .
flyta(x)	returnerar ett reellt värde lika med talet x.
hex(x)	returnerar en sträng som innehåller den hexadecimala representationen av x.
inmatning(<строка>)	visas<строку>, läser och returnerar ett värde från standardinmatning.
int(x)	returnerar heltalsvärdet för x.
lins)	returnerar längden (antal element) av ett objekt.
lång (x)	returnerar ett långt heltalsvärde x.
max(ar), min(er)	returnera det största och minsta elementet i sekvensen s (det vill säga s är en sträng, lista eller tupel).
okt(x)	returnerar en sträng som innehåller en representation av talet x.
öppen(<имя файла>, <режим>='r' )	returnerar ett filobjekt som är öppet för läsning.<режим>= 'w' - öppning för skrivning.
ord(c)	returnerar ASCII-koden för ett tecken (sträng med längd 1) c.
pow(x, y)	returnerar värdet av x till potensen av y.
räckvidd(<начало>, <конец>, <шаг>)	returnerar en lista med heltal större än eller lika med<начало>och mindre än<конец>, genererad med en given<шагом>.
rå_ingång( [ <текст> ] )	visas<текст>till standardutgång och läser en sträng från standardinmatning.
rund (x, n=0)	returnerar verkligt x avrundat till n:e decimalen.
str(<объект>)	returnerar en strängrepresentation<объекта>.
typ(<объект>)	returnerar typen av objekt. Till exempel: om typ(x) == typ(‘’): skriv ut ‘det här är en sträng’
xrange (<начало>, <конец>, <шаг>)	liknar intervall, men simulerar bara en lista utan att skapa den. Används i en for-loop.

Specialfunktioner för att arbeta med listor

filter (<функция>, <список>)	returnerar en lista över dessa element<спиcка>, för vilka<функция>tar värdet "true".
Karta(<функция>, <список>)	gäller<функцию>till varje element<списка>och returnerar en lista med resultat.
minska ( f , <список>, [, <начальное значение> ] )	returnerar värdet som erhålls av "reduktion"<списка>funktion f. Det betyder att det finns någon intern variabel p som initieras<начальным значением>, sedan för varje element<списка>, funktionen f anropas med två parametrar: p och elementet<списка>. Resultatet som returneras av f tilldelas p. Efter att ha gått igenom allt<списка>minska avkastningen sid. Med den här funktionen kan du till exempel beräkna summan av elementen i en lista: def func (röd, el): returnera röd+el summa = reducera (func, , 0) # nu summa == 15
lambda [<список параметров>] : <выражение>	En "anonym" funktion som inte har ett namn och skrivs där den kallas. Accepterar parametrarna som anges i<списке параметров>och returnerar värdet<выражения>. Används för att filtrera, reducera, kartlägga. Till exempel: >>>skriv ut filter (lambda x: x>3, ) >>>skriv ut karta (lambda x: x*2, ) >>>p=reducera (lambda r, x: r*x, , 1) >>> skriv ut sid 24

Importera moduler

Standard matematikmodul

Variabler: pi, e.
Funktioner(liknar C-språkfunktioner):

acos(x)	cosh(x)	ldexp(x,y)	sqrt(x)
asin(x)	exp(x)	log(x)	brun(x)
atan(x)	fabs (x)	sinh(x)	frexp(x)
atan2(x,y)	golv(x)	pow(x,y)	modf(x)
tak (x)	fmod(x,y)	sin(x)
cos(x)	log10(x)	tanh(x)

strängmodul

Funktioner:

Slutsats

På grund av Python-språkets enkelhet och flexibilitet kan det rekommenderas till användare (matematiker, fysiker, ekonomer etc.) som inte är programmerare, men som använder datorteknik och programmering i sitt arbete.
Program i Python utvecklas i genomsnitt en och en halv till två (och ibland två till tre) gånger snabbare än i kompilerade språk (C, C++, Pascal). Därför kan språket vara av stort intresse för professionella programmerare som utvecklar applikationer som inte är kritiska för exekveringshastigheten, samt program som använder komplexa datastrukturer. I synnerhet har Python visat sig väl i att utveckla program för att arbeta med grafer och generera träd.

Litteratur

1. Budd T. Objektorienterad programmering. - St. Petersburg: Peter, 1997.
2. Guido van Rossum. Python handledning. (www.python.org)
3. Chris Hoffman. En snabbreferens för Python. (www.python.org)
4. Guido van Rossum. Python Library Reference. (www.python.org)
5. Guido van Rossum. Python referensmanual. (www.python.org)
6. Guido van Rossum. Python-programmeringsverkstad. (http://sultan.da.ru)

Detta material är avsett för dig som redan är bekant med programmering och vill behärska programmeringsspråket Python. Den är utformad för att visa dig på 10 minuter funktionerna i Python-språket, syntaxfunktioner och de grundläggande principerna för att arbeta med Python med hjälp av exempel. Det finns inget "vatten" här - information som inte är direkt relaterad till programmeringsspråket. Låt oss börja!

Programmeringsspråket Python är starkt typifierat (stark typning kännetecknas av att språket inte tillåter att olika typer i uttryck blandas och inte utför automatiska implicita konverteringar, till exempel kan du inte subtrahera en uppsättning från en sträng), det används dynamisk typning— alla typer bestäms under programexekveringen.

Att deklarera variabler är valfritt, namn är skiftlägeskänsliga (var och VAR är två olika variabler).

Python är ett objektorienterat språk, allt i språket är ett objekt.

Få hjälp

Hjälp (hjälp) i Python är alltid tillgänglig direkt i tolken. Om du vill veta hur ett objekt fungerar, ring hjälp(