Inhoud serie:

We gaan verder met een van de meest interessante onderwerpen loop - objectgeoriënteerd programmeren (OOP) in Python. Vanuit OOP-oogpunt is een klasse een verzameling gegevens. Het gebruik van klassen biedt ons in de eerste plaats de voordelen van een abstracte benadering van programmeren.

1. Polymorfisme: dezelfde bewerking kan in verschillende objecten worden uitgevoerd verschillende functies. Het woord 'polymorfisme' heeft een Griekse oorsprong en betekent 'vele vormen hebben'. Een eenvoudig voorbeeld van polymorfisme is de functie count(), die dezelfde actie uitvoert voor verschillende typen objecten: "abc".count("a") en .count("a") . De plus-operator is polymorf bij het optellen van getallen en bij het toevoegen van tekenreeksen.
2. Inkapseling: u kunt onnodige interne details van de werking van een object voor de buitenwereld verbergen. Dit is het tweede basisprincipe van abstractie. Het is gebaseerd op het gebruik van attributen binnen een klasse. Attributen kunnen verschillende statussen hebben tussen aanroepen van klassemethoden, waardoor het object zelf ontstaat van deze klasse ontvangt ook verschillende staten - staat.
3. Erfenis: U kunt gespecialiseerde klassen maken op basis van basisklassen. Hierdoor kunnen we voorkomen dat er herhaalde code wordt geschreven.
4. Samenstelling: Een object kan samengesteld zijn en andere objecten bevatten.

De objectgeoriënteerde benadering van programmeren impliceert dit volgende algoritme acties.

1. Het probleem wordt beschreven in gewone taal, met behulp van concepten, acties en bijvoeglijke naamwoorden.
2. Op basis van de concepten worden klassen geformuleerd.
3. Methoden zijn ontworpen op basis van acties.
4. Methoden en attributen worden geïmplementeerd.

We ontvingen een skelet - een objectmodel. Op basis van dit model wordt overerving geïmplementeerd. Om het model te controleren:

1. de zogenaamde use cases worden geschreven - een scenario van mogelijk gedrag van het model, waarbij alle functionaliteit wordt getest;
2. functionaliteit kan worden gecorrigeerd of toegevoegd.

De objectgerichte aanpak is goed als het project een langetermijnontwikkeling impliceert en bestaat uit: grote hoeveelheid bibliotheken en interne communicatie.

Klassenmechanisme Python-taal is een combinatie van C++- en Modula-3-klassemechanismen. De belangrijkste kenmerken van klassen in Python:

1. meervoudige overerving;
2. een afgeleide klasse kan alle methoden van basisklassen overschrijven;
3. overal waar je een methode kunt aanroepen met dezelfde naam als de basisklasse;
4. Alle klassenkenmerken in Python zijn standaard openbaar, d.w.z. overal bereikbaar; alle methoden zijn virtueel, d.w.z. overbelast de basis.

Vandaag zullen we de volgende aspecten van objectgeoriënteerd programmeren bekijken.

1. Wat is een klasse?
2. Klasse attributen.
3. zelf.
4. Erfenis.
5. OOP in actie: een voorbeeld van het maken van klassen.

1. Wat is een klasse

Een klasse is een door de gebruiker gedefinieerd type. Het eenvoudigste model van een klassendefinitie ziet er als volgt uit:

klasse klassenaam: instructie 1 .

instructie nr.

Elk dergelijk item genereert zijn eigen klasseobject. Het verschil met C++ is dat, aan de positieve kant, een klassebeschrijving slechts een declaratie is, terwijl het in Python de creatie van een object is. Er is ook een ander type object: een klasse-instantie, die wordt gegenereerd wanneer deze wordt aangeroepen:

class_instance = klasse_naam()

Een klasseobject en een klasse-instantie zijn twee verschillende objecten. De eerste wordt gegenereerd tijdens de klassedeclaratiefase, de tweede bij het aanroepen van de klassenaam. Er kan één klasseobject zijn, maar er kunnen zoveel klasse-instanties zijn als gewenst.

Een instructie is meestal een definitie van een functie. Door een klasse te definiëren, wordt een nieuwe naamruimte gemaakt en een klasseobject gemaakt dat alle instructies omhult.

• Klasseobjecten ondersteunen twee typen bewerkingen:
• toegang tot attributen;

een instantie van een klasse maken.

2. Klassenkenmerken

• Er zijn twee soorten klassekenmerken:
• gegevensattributen;

attributen-methoden.

Gegevensattributen worden meestal bovenaan geschreven. Geheugen voor attributen wordt toegewezen wanneer ze voor het eerst worden toegewezen, extern of intern aan een methode. Methoden beginnen met het functiewoord def.

Attributen zijn toegankelijk via het obj.attrname-schema.

class Eenvoudig: u"Eenvoudige klasse" var = 87 def f(x): return "Hallo wereld"

Hier zijn Simple.var en Simple.f aangepaste kenmerken. Er zijn ook standaardattributen:

>>> afdrukken Eenvoudig.__doc__

Geheel getal

>>> print Simple.var.__doc__ int(x[, basis]) -> geheel getal ...

Het instantiëren van een klasse is vergelijkbaar met het doen van een functieaanroep:

smpl = Eenvoudig()

Er wordt een leeg smpl-object gemaakt. Als we willen dat bepaalde acties worden uitgevoerd tijdens het maken, moeten we een constructor definiëren die automatisch wordt aangeroepen:

klasse Eenvoudig: def __init__(self): self.list =

Wanneer u een smpl-object aanmaakt, wordt er een lege lijst gemaakt. U kunt argumenten doorgeven aan de constructor:

Het data-attribuut kan privé worden gemaakt, d.w.z. van buitenaf ontoegankelijk - hiervoor moet u links twee onderstrepingstekens plaatsen:

class Simple: u"Eenvoudige klasse met privé-attribuut" __private_attr = 10 def __init__(self, count, str): self.__private_attr = 20 print self.__private_attr s = Simple(1,"22") print s.__private_attr

De laatste regel genereert een uitzondering: het attribuut __private_attr is alleen voor intern gebruik.

Methoden hoeven niet gedefinieerd te worden binnen de klassebody:

def method_for_simple(self, x, y): return x + y class Simple: f = method_for_simple >>> s = Simple() >>> print s.f(1,2) 3

Een lege klasse kan worden gebruikt als sjabloon voor een datastructuur:

klasse Klant: pass custom = Klant() custom.name = "Vasya" custom.salary = 100000

3.zelf

Meestal is het eerste argument in de naam van een methode self. Zoals de auteur van de taal, Guido Van Rossum, zegt, is dit niets meer dan een conventie: de naam zelf heeft absoluut geen speciale betekenis.

self is handig voor toegang tot andere klassenkenmerken:

klasse Eenvoudig: def __init__(self): self.list = def f1(self): self.list.append(123) def f2(self): self.f1() >>> s = Simple() >>> s .f2() >>> s.lijst afdrukken

Self is het equivalent van "dit" in C++.

4. Erfenis

De afgeleide klassedefinitie ziet er als volgt uit:

klasse Afgeleid (basis):

Als de basisklasse niet is gedefinieerd in de huidige module:

klasse Afgeleid(modulenaam.Base):

De attribuutnaamomzetting werkt van boven naar beneden: als het attribuut niet in de huidige klasse wordt gevonden, gaat de zoekopdracht recursief verder in de basisklasse, enzovoort. Afgeleide klassen kunnen methoden van basisklassen overschrijven - alle methoden zijn in deze zin virtueel. U kunt een basisklassemethode aanroepen met het voorvoegsel:

Basismethode()

Python heeft beperkte ondersteuning voor meervoudige overerving:

klasse Afgeleid(Base1,Base2,Base3):

Het attribuut wordt in de volgende volgorde gezocht:

1. in Afgeleid;
2. in Base1, vervolgens recursief in Base1-basisklassen;
3. in Base2, en vervolgens recursief in Base2-basisklassen
4. enz.

5. Voorbeeld

Laten we twee klassen maken: Persoon - slaat algemene informatie over mensen op - naam, beroep, salaris; de Manager-klasse is een gespecialiseerde afgeleide klasse. In de klasse Person gaan we onze eigen versie maken van de standaard ingebouwde functie str, die standaard in elke Python-klasse aanwezig is - hiervoor wordt deze voorafgegaan door twee onderstrepingstekens links en rechts. Wanneer we een klasse-instantie proberen af ​​te drukken, wordt __str__ aangeroepen.

# -*- codering: utf-8 -*- class Persoon: def __init__(self, name, job=None, pay=0): self.name = naam self.job = job self.pay = pay def lastName(self ): return self.name.split()[-1] def giveRaise(self, procent): self.pay = int(self.pay * (1 + procent)) def __str__(self): return "" % (self .name, self.pay) class Manager(Person): def __init__(self, name, pay): Person.__init__(self, name, "mgr", pay) def giveRaise(self, percent, bonus=100): Persoon .giveRaise(zelf, percentage + bonus)

Maak het eerste exemplaar van de klasse Person:

>>> ivan = Persoon("Ivan Petrov")

Maak een tweede exemplaar van de klasse Person:

>>> john = Persoon("John Sidorov", job="dev", pay=100000)

Roep de overbelaste functie __str__ op;

>>> afdrukken(ivan) >>> afdrukken(john)

We tonen de achternaam:

>>> print(ivan.achternaam(), john.achternaam())

Wij rekenen bonussen:

>>> john.giveRaise(.10)

En wij krijgen:

>>> afdrukken(johannes)

Maak een exemplaar van de Manager-klasse:

>>> tom = Beheerder("Tom Jones", 50000)

Wij kennen megabonussen toe:

>>> tom.giveRaise(.10) print(tom.achternaam()) print(tom)("Petrov", "Sidorov") Jones

Conclusie

De belangrijkste eigenschappen van OOP zijn polymorfisme, overerving en inkapseling. Een klasse is een door de gebruiker gedefinieerd type dat bestaat uit methoden en attributen. Er wordt een instantie van een klasse gemaakt door de klassenaam aan te roepen als een functie met parameters. Een object bestaat uit attributen en methoden. Een attribuut is een variabele, een methode is een functie. Het verschil tussen een methode en een functie is dat deze een eerste parameter heeft: zelf. Polymorfisme stelt ons in staat om mee te werken verschillende soorten objecten zodat we niet hoeven na te denken over tot welk type ze behoren. Objecten kunnen hun interne toestand verbergen (inkapselen). Dit wordt bereikt doordat attributen niet rechtstreeks toegankelijk zijn, maar via methoden. Een klasse kan worden afgeleid uit één of meerdere klassen. Een afgeleide klasse erft alle methoden van de basisklasse. Er kunnen meerdere basisklassen zijn. Objectontwerp moet transparant en begrijpelijk zijn en, zoals ze zeggen, beschreven worden in ‘termen van menselijke taal’.

Bronnen om te downloaden

static.content.url=http://www.site/developerworks/js/artrating/

Zone=Open source, Linux

ArtikelID=512105

ArticleTitle=Python-programmering: deel 6: klassen

Exploitant	Beschrijving	Voorbeelden
+	Optelling - Telt de waarden links en rechts van de operator op	15 + 5 resultaten in 20 20 + -3 resultaten in 17 13,4 + 7 resultaten in 20,4
-	Aftrekken - Trekt de rechter operand van de linkerkant af	15 - 5 het resultaat is 10 20 - -3 resulteert in 23 13,4 - 7 het resultaat is 6,4
*	Vermenigvuldiging - Vermenigvuldigt de operanden	5 * 5 het resultaat is 25 7 * 3,2 het resultaat is 22,4 -3 * 12 het resultaat is -36
/	Deling - Verdeelt de linker operand door de rechter operand	15 / 5 is het resultaat 3 5/2 resulteert in 2 (in Python 2.x resulteert het delen van twee gehele getallen in een geheel getal) 5.0 / 2 het resultaat zal 2.5 zijn (om het "juiste" resultaat te krijgen moet ten minste één operand zwevend zijn)
%	Modulodeling - Verdeelt de linker operand door de rechter operand en retourneert de rest.	6% 2 het resultaat is 0 7% 2 het resultaat is 1 13,2% 5 als gevolg van 3.2
**	Machtsverheffing - verheft de linker operand tot de macht van de rechter	5 ** 2 het resultaat is 25 2 ** 3 het resultaat is 8 -3 ** 2 het resultaat is -9
//	Deling van gehele getallen - Deling waarin alleen het gehele deel van het resultaat wordt geretourneerd. Het gedeelte na de komma wordt weggegooid.	12 // 5 het resultaat is 2 4 // 3 resulteert in 1 25 // 6 het resultaat is 4

Vergelijkingsoperatoren in Python:

Exploitant	Beschrijving	Voorbeelden
==	Controleert of beide operanden gelijk zijn. Zo ja, dan wordt de voorwaarde waar.	5 == 5 resulteert in Waar Waar == Onwaar, het resultaat zal Onwaar zijn "hallo" == "hallo" resulteert in Waar
!=		12 != 5 het resultaat is True False != False, het resultaat zal False zijn "hi" != "Hoi" het resultaat zal True zijn
<>	Controleert of beide operanden gelijk zijn. Als dit niet het geval is, wordt de voorwaarde waar.	12 <>5 resulteert in Waar. Lijkt op een operator!=
>	Controleert of de waarde van de linker operand groter is dan de waarde van de rechter operand. Zo ja, dan wordt de voorwaarde waar.	5 > 2 resulteert in Waar. Waar > Onwaar resulteert in Waar. "A" > "B" resulteert in False.
<	Controleert of de waarde van de linker operand kleiner is dan de waarde van de rechter operand. Zo ja, dan wordt de voorwaarde waar.	3 < 5 в результате будет True. WAAR< False в результате будет False. "A"< "B" в результате будет True.
>=	Test of de waarde van de linker operand groter is dan of gelijk is aan de waarde van de rechter operand. Zo ja, dan wordt de voorwaarde waar.	1 >= 1 resulteert in Waar. 23 >= 3,2 zal het resultaat Waar zijn. "C" >= "D" resulteert in False.
<=	Test of de waarde van de linker operand kleiner is dan of gelijk is aan de waarde van de rechter operand. Zo ja, dan wordt de voorwaarde waar.	4 <= 5 в результате будет True. 0 <= 0.0 в результате будет True. -0.001 <= -36 в результате будет False.

Toewijzingsoperatoren in Python:

Exploitant	Beschrijving	Voorbeelden
=	Wijst de waarde van de rechter operand toe aan de linker.	c = 23 wijst de waarde 23 toe aan variabele c
+=	Voegt de waarde van de rechter operand toe aan de linker operand en wijst die som toe aan de linker operand.	c = 5 een = 2 c += a is equivalent aan: c = c + a. c zal gelijk zijn aan 7
-=	Trekt de waarde van de rechter operand af van de linker operand en wijst het resultaat toe aan de linker operand.	c = 5 een = 2 c -= a is equivalent aan: c = c - a. c zal gelijk zijn aan 3
*=	Vermenigvuldigt de rechter operand met de linker operand en wijst het resultaat toe aan de linker operand.	c = 5 een = 2 c *= a is equivalent aan: c = c * a. c zal gelijk zijn aan 10
/=	Verdeelt de linker operand door de rechter operand en wijst het resultaat toe aan de linker operand.	c = 10 een = 2 c / = a is gelijk aan: c = c / a. c zal gelijk zijn aan 5
%=	Verdeelt modulo de operanden en wijst het resultaat toe aan de linker.	c = 5 een = 2 c % = a is equivalent aan: c = c % a. c zal gelijk zijn aan 1
**=	Verheft de linker operand tot de macht van de rechter operand en wijst het resultaat toe aan de linker operand.	c = 3 een = 2 c ** = a is equivalent aan: c = c ** a. c zal gelijk zijn aan 9
//=	Voert een gehele deling uit van de linker operand door de rechter operand en wijst het resultaat toe aan de linker operand.	c = 11 een = 2 c //= a is equivalent aan: c = c // a. c zal gelijk zijn aan 5

Bitwise-operatoren in Python:

Bitsgewijze operatoren zijn ontworpen om te werken met gegevens in bitsgewijze (binaire) indeling. Stel dat we twee getallen a = 60 hebben; en b = 13. In binair formaat zien ze er als volgt uit:

Exploitant	Beschrijving	Voorbeelden
&	De binaire AND-operator kopieert alleen een bit naar het resultaat als de bit in beide operanden aanwezig is.	(a & b) geeft ons 12, wat er binair uitziet als 0000 1100
|	De binaire "OR"-operator kopieert een bit als deze in ten minste één operand aanwezig is.	(a | b) geeft ons 61, in binair getal 0011 1101
^	De binaire "Exclusieve OR"-operator kopieert een bit alleen als de bit aanwezig is in een van de operanden, maar niet in beide.	(a^b) geeft ons 49, in binair getal 0011 0001
~	Binaire complementaire operator. Het is unair (dat wil zeggen, het heeft slechts één operand nodig) en verandert de bits in de omgekeerde richting, waarbij er een één was die nul werd en omgekeerd.	(~a) resulteert in -61, wat er binair uitziet als 1100 0011.
<<	Verschuif bitsgewijs naar links. De waarde van de linker operand wordt naar links "verschoven" met het aantal bits dat in de rechter operand is gespecificeerd.	A<< 2 в результате даст 240, в двоичном формате 1111 0000
>>	Bitsgewijs naar rechts verschuiven. De waarde van de linker operand wordt naar rechts "verschoven" met het aantal bits dat in de rechter operand is gespecificeerd.	a >> 2 geeft 15, in binair getal 0000 1111

Logische operatoren in Python:

Exploitant	Beschrijving	Voorbeelden
En	Logische operator "EN". De voorwaarde is waar als beide operanden waar zijn.	Waar en Waar is gelijk aan Waar. Waar en Onwaar zijn gelijk aan Onwaar. Onwaar en Waar zijn gelijk aan Onwaar. Onwaar en Onwaar zijn gelijk aan Onwaar.
of	Logische operator "OR". Als ten minste één van de operanden waar is, zal de gehele expressie waar zijn.	Waar of Waar is gelijk aan Waar. Waar of Onwaar is gelijk aan Waar. Onwaar of Waar is gelijk aan Waar. Onwaar of Onwaar is gelijk aan Onwaar.
niet	Logische operator "NIET". Keert de Booleaanse waarde van de operand om.	niet waar is gelijk aan onwaar. niet Vals is gelijk aan Waar.

Lidmaatschapsoperatoren in Python:

Naast de genoemde operators, in Python Er zijn zogenaamde lidmaatschapsoperatoren die zijn ontworpen om te controleren op de aanwezigheid van een element in complexe gegevenstypen, zoals strings, lijsten, tupels of woordenboeken:

Identiteitsoperatoren in Python:

Identiteitsoperatoren vergelijken de plaatsing van twee objecten in het computergeheugen.

Operatorprioriteit in Python

De volgende tabel beschrijft de uitvoeringsprioriteit van instructies in Python van hoogste (eerst gedaan) naar laagste.

Exploitant	Beschrijving
**	Machtsverheffing
~ + -	Complementaire exploitant
* / % //	Vermenigvuldigen, delen, modulodelen, delen van gehele getallen.
+ -	Optellen en aftrekken.
>> <<	Bitsgewijs naar rechts verschuiven en bitsgewijs naar links verschuiven.
&	Binaire "EN".
^ |	Binair "Exclusieve OR" en binair "OR"
<= < > >=	Vergelijkingsoperatoren
<> == !=	Gelijkheidsoperatoren
= %= /= //= -= += *= **=	Toewijzingsoperatoren
niet	Identiteitsoperatoren
binnen niet binnen	Lidmaatschapsexploitanten
niet of en	Logische operatoren

We hebben wat gepraat, laten we het er nu over hebben tekenreeksfuncties en -methoden.

Ik heb geprobeerd alle stringmethoden en -functies hier te verzamelen, maar als ik iets vergeten ben, corrigeer me dan alstublieft.

Basisbewerkingen

Aaneenschakeling (optelling)

>>> S1 = "spam" >>> S2 = "eieren" >>> print (S1 + S2 ) "spameggs"

• Dubbele lijn

  >>> afdrukken ("spam" * 3 ) spamspamspam

• Snaarlengte (len-functie)

  >>> len ("spam") 4

• Toegang via index

  >>> S = "spam" >>> S [ 0 ] "s" >>> S [ 2 ] "a" >>> S [ - 2 ] "a"

  Zoals je in het voorbeeld kunt zien, is toegang via een negatieve index ook mogelijk in Python, waarbij het tellen begint vanaf het einde van de string.

• Extractie van plakjes

  Operator voor schijfextractie: . X is het begin van het segment en Y is het einde;

  Het symbool met nummer Y is niet opgenomen in het segment. Standaard is de eerste index 0 en de tweede de lengte van de tekenreeks.

  >>> s = "spameggs" >>> s [ 3: 5 ] "ik" >>> s [ 2: - 2 ] "ameg" >>> s [: 6 ] "spameg" >>> s [ 1 :] "pameggs" >>> s [:] "spameggs"

  Bovendien kunt u de stap opgeven waarin u het segment wilt extraheren.

  >>> s [:: - 1 ] "sggemaps" >>> s [ 3: 5: - 1 ] "" >>> s [ 2 :: 2 ] "aeg"

Andere tekenreeksfuncties en -methoden

Bij het aanroepen van methoden moet je onthouden dat strings in Python tot de categorie van onveranderlijke reeksen behoren, dat wil zeggen dat alle functies en methoden alleen nieuwe lijn.

>>> s = "spam" >>> s [ 1 ] = "b" Traceback (meest recente oproep laatste):Bestand "", regel 1, in s = "b" TypeError: "str"-object ondersteunt geen itemtoewijzing>>> s = s [ 0 ] + "b" + s [ 2 :] >>> s "sbam"

Daarom retourneren alle stringmethoden een nieuwe string, die vervolgens aan een variabele moet worden toegewezen.

Tabel "Stringfuncties en -methoden"

Functie of methode	Doel
S = "str"; S = "str"; S = """str"""; S = """str"""
S = "s\np\ta\nbbb"	Ontsnappingssequenties
S = r"C:\temp\nieuw"	Niet-geformatteerde tekenreeksen (onderdruk escapen)
S = b"byte"	Lijn
S1+S2	Concatenatie (tekenreeksen toevoegen)
S1*3	Herhaling van lijnen
Si]	Toegang via index
S	Extractie van plakjes
len(S)	Snaarlengte
S.vind(str, ,)	Een subtekenreeks in een tekenreeks zoeken. Retourneert het nummer van de eerste instantie of -1
S.rvind(str, ,)	Een subtekenreeks in een tekenreeks zoeken. Retourneert het nummer van de laatste gebeurtenis of -1
S.index(str, ,)	Een subtekenreeks in een tekenreeks zoeken. Retourneert het nummer van de eerste instantie of genereert een ValueError
S.rindex(str, ,)	Een subtekenreeks in een tekenreeks zoeken. Retourneert het nummer van de laatste gebeurtenis of genereert een ValueError
S.vervangen(sjabloon, vervanging)	Het sjabloon vervangen
S.split(symbool)	Een tekenreeks splitsen door een scheidingsteken
S.iscijfer()	Bestaat de string uit cijfers?
S.isalpha()	Bestaat de string uit letters?
S.isalnum()	Bestaat de string uit cijfers of letters?
S.islager()	Bestaat de string uit kleine letters?
S.isupper()	Bestaat de string uit hoofdletters?
S.isruimte()	Of de tekenreeks niet-weergeefbare tekens bevat (spatie, paginafeed ("\f"), nieuwe regel ("\n"), regelterugloop ("\r"), horizontale tab ("\t" ) en "verticale tab" ("\v"))
S.istitel()	Beginnen de woorden in de regel met een hoofdletter?
Avondeten()	Een tekenreeks naar hoofdletters converteren
S.lager()	Een tekenreeks naar kleine letters converteren
S.begintmet(str)	Begint de string S met de patroonstr
S.eindigtmet(str)	Eindigt de string S met het patroon str
S. sluit je aan(lijst)	Een string samenstellen uit een lijst met een S-scheidingsteken
ord(symbool)	Een teken voor de ASCII-code ervan
Chr(nummer)	ASCII-code naar teken
S.kapitaliseren()	Converteert het eerste teken van de tekenreeks naar hoofdletter, en alle anderen gaan naar de bodem
S.centrum(breedte, )	Retourneert een gecentreerde tekenreeks, omrand met een opvulteken (standaard spatie)
S.telling(str, ,)	Retourneert het aantal niet-overlappende exemplaren van een subtekenreeks in het bereik [start, end] (0 en standaard tekenreekslengte)
S.tabbladen uitvouwen()	Retourneert een kopie van de tekenreeks waarbij alle tabtekens zijn vervangen door een of meer spaties, afhankelijk van de huidige kolom. Als TabSize niet is opgegeven, wordt aangenomen dat de tabgrootte 8 spaties bedraagt
S.lstrip()	Verwijdering witruimte tekens aan het begin van de regel
S.rstrip()	Het verwijderen van witruimtetekens aan het einde van een regel
S.strip()	Het verwijderen van witruimtetekens aan het begin en einde van een regel
S.partitie(steekproef)	Retourneert een tupel die het gedeelte vóór het eerste patroon, het patroon zelf en het gedeelte na het patroon bevat. Als het patroon niet wordt gevonden, retourneert het een tuple die de string zelf bevat, en vervolgens twee lege regels
S.rpartitie(sep)	Retourneert een tupel die het gedeelte vóór het laatste patroon, het patroon zelf en het gedeelte na het patroon bevat. Als het patroon niet wordt gevonden, retourneert het een tuple met twee lege strings en vervolgens de string zelf
S.ruilcase()	Vertaalt karakters kleine letters naar boven, en van boven naar beneden
S.titel()	Converteert de eerste letter van elk woord naar hoofdletters en alle andere naar kleine letters
S.zfill(breedte)	Zorgt ervoor dat de lengte van de string minimaal gelijk is aan de breedte, en vult de eerste tekens indien nodig met nullen
S.ljust(breedte, fillchar = " ")	Zorgt ervoor dat de lengte van een string minstens gelijk is aan de breedte, en vult indien nodig de laatste tekens met fillchar
S.rjust(breedte, fillchar = " ")	Zorgt ervoor dat de lengte van een string minstens gelijk is aan de breedte, en vult de eerste tekens indien nodig met fillchar
S.formaat(* args, ** kwargs)

Dit artikel geeft de belangrijkste punten weer die van pas kunnen komen bij het overstappen naar de programmeertaal Python vanuit een andere programmeertaal, of voor zelfstudie Python.

Objectoriëntatie

Voor beginners kun je dit voorlopig overslaan en terugkomen nadat je de rest van het materiaal hebt gelezen!

>>> q = >>> p = >>> len(p) 3 >>> p >>> p 2 >>> p.append(’xtra’) >>> p , 4] >>> q

De definitie van een klasse is een object, zoals in wezen alles in de taal.

Dat wil zeggen dat u een klassedefinitie aan een variabele kunt toewijzen:

>>> klasse MijnKlasse: ... i = 12345 ... def f(x): ... print dir(x) ... return x ... >>> c = MijnKlasse() >>> i 123 >>> c.i 12345 >>> vgl > >>> d=MijnKlasse >>> e=MijnKlasse() >>> e<__main__.MyClass instance at 0x000000000239E808>>>>c<__main__.MyClass instance at 0x000000000239E7C8>>>> D >>> d.i 12345 >>> c.i 12345 >>> c.f > >>> e.f. > >>> df >>> g = d() >>> g.f >

Inkepingen

Inspringen wordt in Python gebruikt om groeperingsinstructies te schrijven. Wanneer u bijvoorbeeld de hoofdtekst van een functie of lus definieert, schrijft u alle instructies die in de functie moeten worden opgenomen met dezelfde inspringing:

Def some_func(z): y = z*2 # Functie body return y # Dit is ook een functie # Maar dit is niet langer y = 1 print(some_func(y))

Variabelen in Python

Gehele getallen en getallen met drijvende komma

Door een getal toe te wijzen aan een variabele zonder punt of door int() te gebruiken, krijgt u een variabele van het type geheel getal. Het resultaat van het delen van twee gehele getallen zal ook een geheel getal zijn; de rest van de deling wordt weggegooid.

Voeg een punt toe aan het einde van het getal om een ​​float-variabele te maken:

Tekenreeksen in Python

Waarden vervangen door een string

Met Python kunt u een tekenreeks maken met behulp van een sjabloon en daarin variabele waarden vervangen.

Er zijn twee opties om waarden in een string te vervangen: positionele vervanging en het gebruik van benoemde parameters.

Positionele waardevervanging

Output = "Product %s in categorie %s" % (product, categorie) output = "Je hebt %s $" % usd_count

IN in dit geval De waarden van de variabelen worden opeenvolgend in de string ingevoegd.

Benoemde parameters gebruiken

Uitvoer = "Vandaag is het %(maand)s %(dag)s.") % ("maand": m, "dag": d)

Wanneer benoemde parameters worden gebruikt om waarden in een string te vervangen, wordt de te vervangen waarde geselecteerd op basis van de naam uit het woordenboek.

Deze methode verdient de voorkeur als u van plan bent uw project in meerdere talen te vertalen, omdat vertalers hierdoor de volgorde van woorden in de originele sjabloon kunnen wijzigen.

Tekenreeksen opmaken en uitvoeren

Met de afsluitende komma kunt u een spatie invoegen nadat u een waarde hebt afgedrukt in plaats van een nieuwe regel:

>>> terwijl b< 10: ... print b, ... b += 1 ... 1 2 3 4 5 6 7 8 9 >>> voor x binnen bereik(1, 11): ... print str(x).rjust(2), str(x*x).rjust(3), ... # Let op de komma aan het einde van de vorige regel! ... print str(x*x*x).rjust(4) ...

Geformatteerde uitvoer:

1 1 1 2 4 8 3 9 27 4 16 64 5 25 125 6 36 216 7 49 343 8 64 512 9 81 729 10 100 1000

Dit voorbeeld demonstreert het gebruik van de rjust() string-methode, die een string in een veld met de opgegeven breedte rechts uitlijnt en deze opvult met spaties aan de linkerkant. De methoden ljust() en center() werken op dezelfde manier. Ze voeren niets uit - ze retourneren alleen een nieuwe regel. Als de oorspronkelijke regel te lang is, wordt deze niet afgekapt maar ongewijzigd geretourneerd: het is meestal beter om de kolomindeling onoverzichtelijk te maken dan om af te drukken ongeldige waarde. (Als je het echt wilt bijsnijden, gebruik dan de slice-operator: 's.ljust(n)'.)

De functie zfill() die in de stringmodule is gedefinieerd, kan ook nuttig zijn.
die een string opvult met een getal aan de linkerkant met nullen, waarbij plus- en mintekens correct worden verwerkt:

>>> tekenreeks importeren >>> string.zfill('12', 5) '00012' >>> string.zfill('-3.14', 7) '-003.14' >>> string.zfill('3.14159265359', 5) '3.14159265359'

Het gebruik van de %-operator ziet er ongeveer zo uit:

>>> import wiskunde >>> print ’De PI-waarde is ongeveer %5.3f.’ % \ ... math.pi De PI-waarde is ongeveer 3.142.

% om informatie in 3 kolommen weer te geven:

>>> voor x binnen bereik(1,11): ... print '%2d %3d %4d' % (x, x*x, x*x*x) ... 1 1 1 2 4 8 3 9 27 4 16 64 5 25 125 6 36 216 7 49 343 8 64 512 9 81 729 10 100 1000

Operaties en operanden

Opdracht

U kunt aan meerdere variabelen tegelijk een waarde toekennen

EEN = b = c = 1 een, b = 0, 1

Machtsverheffing

5 tot de macht 2 (5 kwadraat):

Afdrukken 5**2

Logische omstandigheden

De operatoren in en not in controleren of de opgegeven waarde in de reeks aanwezig is. De operators is en is not bepalen of twee variabelen naar hetzelfde object verwijzen. Al deze operatoren hebben dezelfde prioriteit, die lager is dan die van rekenkundige operatoren.

Booleaanse expressies kunnen worden samengevoegd: bijvoorbeeld ‘a< b == c’ проверяет,
of a kleiner is dan b en of b en c gelijk zijn.

Booleaanse expressies kunnen worden gegroepeerd met behulp van Booleaanse operatoren
en en of, en het resultaat kan worden omgekeerd met behulp van de not-operator. Allemaal logisch
operatoren hebben een lagere prioriteit dan vergelijkingsoperatoren. Van de logische operatoren heeft niet de hoogste prioriteit en/of de minste.

Ingebouwde Python-functies

Alle functies die in de taal zijn ingebouwd, kunnen hier worden bekeken:

Cycli

Terwijl lus

Een while-lus wordt gebruikt om herhaaldelijk acties uit te voeren terwijl aan een voorwaarde wordt voldaan:

Terwijl expr: suite1

De while-instructie wordt in de volgende volgorde uitgevoerd:

1. De expr-expressie wordt geëvalueerd en als deze onwaar is, gaat u verder met stap 3.
2. Suite1-codeblok wordt uitgevoerd. In dit geval wordt de break-instructie in het blok uitgevoerd
onderbreekt onmiddellijk de uitvoering van de lus (punt 3 wordt niet uitgevoerd) en uitvoering
continue instructies onderbreken de uitvoering van een codeblok, waarna uitvoering
de cyclus gaat verder vanaf punt 1. Na het voltooien van de uitvoering van het suite1-blok, kunt u
De lus gaat verder vanaf punt 1.
3. Codeblok suite2 (else branch) wordt uitgevoerd. De break- en continue-instructies in
dit blok wordt geacht tot de buitenste lus te behoren.

Voor lus

De for-lus in Python doorloopt de elementen van een willekeurige reeks (bijvoorbeeld een lijst of een tekenreeks) in de volgorde waarin ze verschijnen:

A = ['kat', 'raam', 'weggooien'] >>> voor x in a: ... print x, len(x) ... cat 3 raam 4 weggooien 9

Kenmerken van de for-lus in Python

De for-instructie wordt gebruikt om de elementen van een reeks te doorlopen:

Voor lwaarde op volgorde: suite1

De expressiereeks wordt één keer geëvalueerd en moet een reeks produceren (het object waarvoor de bewerking voor het ophalen van een element via index is gedefinieerd; als de index buiten bereik valt, moet er een IndexError-uitzondering worden gegenereerd).

Voor elk element van de reeks wordt, in oplopende indexvolgorde, beginnend bij 0, een lwaardetoewijzing gedaan aan het reekselement en wordt het codeblok suite1 uitgevoerd.

Nadat de reeks is uitgeput (bepaald door de gegenereerde IndexError), wordt het suite2-blok uitgevoerd als er een else-vertakking aanwezig is.

Het uitvoeren van een break-instructie in het suite1-blok verbreekt onmiddellijk de lus (de else-tak wordt genegeerd). Bij het uitvoeren van een continue-instructie in een suite1-blok wordt de rest van het blok overgeslagen en gaat de lus verder nadat een lvalue is toegewezen aan het volgende element van de reeksreeks, of wordt de else-tak uitgevoerd als er geen volgend element in de reeks is.

U kunt een variabele of variabelen toewijzen die deel uitmaken van een lvalue, zonder dat dit invloed heeft op het volgende element dat aan de lvalue wordt toegewezen. Variabelen die zijn opgenomen in lvalue worden na het einde van de lus niet verwijderd en behouden de laatst toegewezen waarden. Als de reeks echter leeg is, krijgt de lvalue geen enkele waarde toegewezen (dus als u deze variabelen gebruikt zonder extra controle, heeft u kans op een NameError).

De iteratieve volgorde wijzigen

Wees voorzichtig als u de reeks wijzigt waarvan u de elementen uitprobeert. Het huidige element van de reeks wordt bepaald door de waarde van de interne teller. Het einde van de reeks wordt bepaald door een IndexError-uitzondering bij het ophalen van het volgende element. Als u dus in het suite1-blok het huidige of een van de doorlopen elementen van de reeks verwijdert, wordt het volgende element overgeslagen.

Op dezelfde manier, als u een nieuw element aan de reeks vóór het huidige toevoegt, wordt de hoofdtekst van de lus voor het huidige element opnieuw uitgevoerd. Dit gedrag kan leiden tot vervelende fouten die meestal kunnen worden vermeden door de elementen van een kopie van de originele reeks te herhalen, bijvoorbeeld:

Voor x in a[:]: als x< 0: a.remove(x)

range() en xrange() functies

Als u een reeks getallen moet herhalen, dan is de ingebouwde
bereik() functie. Er wordt een lijst gemaakt met daarin rekenkundige progressie:
>>> bereik(10)

De xrange-functie werkt op dezelfde manier, maar in plaats van een lijst te genereren, wordt er een object van het type xrange gemaakt - de waarden ervan kunnen in een lus worden doorlopen, maar kunnen niet worden gewijzigd

>>> type(bereik(2)) >>> type(xbereik(2))

Breek instructies af en ga verder, anders vertakken ze zich in lussen

De break-instructie verlaat de binnenste geneste for- of while-lus. De continue-instructie zet de lus voort vanaf de volgende iteratie.

Lussen kunnen een else-tak hebben, die wordt uitgevoerd bij een “normale” uitgang (uitputting van de reeks in voor lus, het niet voldoen aan een voorwaarde in een while-lus), zonder onderbreking door een break-instructie. Laten we het gebruik ervan demonstreren aan de hand van het voorbeeld van het zoeken naar priemgetallen:

>>> voor n in xbereik(2, 10): ... voor x in xbereik(2, n): ... als n % x == 0: ... print n, '=', x, ' *', n/x ... break ... else: ... print n, '- priemgetal' ... 2 - priemgetal 3 - priemgetal 4 = 2 * 2 5 - priemgetal 6 = 2 * 3 7 - priemgetal 8 = 2 * 4 9 = 3 * 3

Functies

>>> def fib(n):

De instructies die de hoofdtekst van de functie vormen, zijn ingesprongen geschreven, te beginnen met volgende regel. De eerste instructie van een functielichaam kan een docstring zijn.

>>> def fib(n): ... '''Geeft de Fibonacci-getallen weer gegeven nummer''' ... a, b = 0, 1 ... terwijl b< n: ... print b, ... a, b = b, a+b

>>> q = bereik(5) >>> def ch(l): ... l.append("Nieuwe!") ... >>> q >>> ch(q) >>> q

De return-instructie verlaat de functie en retourneert een waarde. Zonder argumenten wordt return gebruikt om het midden van een procedure af te sluiten, in welk geval Geen wordt geretourneerd.

Standaardwaarden worden berekend waar de functie in de scope is gedefinieerd
zichtbaarheid van de definitie, dus

I = 5 def f(arg = i): print arg i = 6 f() zal 5 afdrukken.

Belangrijke opmerking: de standaardwaarde wordt slechts één keer berekend. Dit wordt weerspiegeld wanneer het standaardwaardeargument een veranderbaar object is, zoals een lijst of woordenboek. De volgende functie verzamelt bijvoorbeeld de doorgegeven argumenten.

Def f(a, l = ): l.append(a) return l print f(1) print f(2) print f(3)

Het uitvoeringsresultaat zal als volgt zijn:

Willekeurige reeks argumenten

Ten slotte is een minder vaak gebruikte optie het definiëren van een functie zodat deze met een willekeurig aantal argumenten kan worden aangeroepen. In dit geval worden de argumenten als een tuple doorgegeven. Voor variabel getal argumenten er kan een willekeurig aantal reguliere argumenten zijn:

Def fprintf(bestand, formaat, *args): bestand.write(formaat % args)

Genoemde argumenten

De functie kan worden aangeroepen met behulp van benoemde argumenten (keyword
argumenten) in de vorm 'trefwoord = waarde'.

Def voorbeeld(formeel, *argumenten, **trefwoorden): print "Reguliere argumenten:", formeel print '-'*40 voor arg in argumenten: print arg print '-'*40 voor kw in trefwoorden.keys(): print kw, ':', trefwoorden

Python lambda-functies

De lambdafunctie doet hetzelfde als een reguliere functie.

In tegenstelling tot gewone lambda gebruikt lambda een verkorte syntaxis: de lijst met argumenten wordt zonder haakjes geschreven en er is geen return-trefwoord. De functietekst kan slechts één expressie bevatten. Een lambdafunctie heeft geen naam, maar kan worden aangeroepen via de variabele waaraan deze is toegewezen.

>>> g = lambda x: x*2 >>> g(3)

Gegevensinvoer en -uitvoer in Python

Bestanden lezen en schrijven

De ingebouwde functie open() retourneert een bestandsobject en wordt doorgaans gebruikt met twee argumenten: 'open(bestandsnaam, modus)'.

>>> f=open(’/tmp/werkbestand’, ’wb’) >>> print f

Het eerste argument is een string die de bestandsnaam bevat, het tweede argument is een string die verschillende karakters bevat die de gebruiksmodus van het bestand beschrijven. De modus kan 'r' zijn als het bestand alleen wordt geopend om te lezen, 'w' - om alleen te schrijven (het bestaande bestand wordt overschreven) en 'a' - om toe te voegen aan het einde van het bestand. In de 'r+'-modus wordt het bestand onmiddellijk geopend om te lezen en te schrijven. Het mode-argument is optioneel: als het wordt weggelaten, wordt 'r' aangenomen.

Op Windows (en in sommige gevallen op Macintosh) worden bestanden standaard in tekstmodus geopend. Om een ​​bestand in binaire modus te openen, moet u een 'b' aan de modusregel toevoegen. Houd er rekening mee dat binaire gegevens, zoals JPEG-afbeeldingen en zelfs UNICODE-tekst, beschadigd zullen raken bij het lezen van of schrijven naar een bestand dat in tekstmodus is geopend! De beste manier om uzelf tegen problemen te beschermen is door bestanden altijd in de binaire modus te openen, zelfs op platforms waar de binaire modus de standaard is (misschien wilt u ooit een programma op een ander platform uitvoeren).

augurk module

Als je een object x en een bestandsobject f open hebt staan ​​om te schrijven, de eenvoudigste manier Voor het opslaan van het object is slechts één regel code vereist:

Pickle.dump(x, f)

U kunt ook eenvoudig een object herstellen (f is een bestandsobject dat kan worden gelezen):

X = augurk.lading(f)

Ingebouwde Python-functies

Python wordt geleverd met veel functies, zoals map() en zip(), die berekeningen veel eenvoudiger maken.

Python-gegevensstructuren

Lijsten

Door komma's gescheiden lijst met waarden omsloten door vierkanten
beugels. Het is niet nodig dat de lijstelementen van hetzelfde type zijn

A = ['spam', 'eieren', 100, 1234]

De nummering van lijstelementen is vergelijkbaar met die van regels: het eerste element is genummerd 0.

Methoden voor het werken met lijsten

toevoegen, pop en invoegen

Append voegt een nieuw element toe aan het einde van de lijst.

Met de invoegmethode kunt u een element aan het begin of op een andere positie van de lijst invoegen - u specificeert de index van het element waarvoor het nieuwe element wordt toegevoegd:

>>> a.insert(2, -1)

pop() retourneert het laatste element van de lijst en verwijdert het uit de lijst.

indexeren en tellen

Met Index kunt u achterhalen op welke positie het eerste element met een bepaalde waarde zich bevindt.

verwijderen, sorteren, omkeren

Lijsten gebruiken

Met append en pop kun je lijsten als stapel gebruiken:

>>> stapel = >>> stapel.append(6) >>> stapel.append(7) >>> stapel >>> stapel.pop() 7 >>> stapel

Het is ook gemakkelijk om een ​​lijst als een wachtrij met elementen te gebruiken - toevoegen met append en de eerste in de wachtrij ophalen met pop(0):

>>> wachtrij = ["Eric", "John", "Michael"] >>> wachtrij.append("Terry") # Terry toegevoegd aan de wachtrij >>> wachtrij.append("Graham") # Graham toegevoegd aan de wachtrij >>> wachtrij.pop(0) 'Eric' >>> wachtrij.pop(0) 'John' >>> wachtrij ['Michael', 'Terry', 'Graham']

Plakjes

Er kunnen geen segmenten worden gemaakt van woordenboeken, sets of verzamelingen.
Het meest voorkomende gebruik van segmenten in Python is het maken van een kopie van een reeks of een deel ervan.
Beschouw een segment als onderdeel van een reeks. Bijvoorbeeld meerdere segmenten uit een lijst:

>>> s = #eenvoudige lijst >>> s[:] #kopie van de lijst, vaak erg handig >>> s # alle elementen behalve de eerste >>> s[-3:] # laatste 3 elementen >>> s #weggooien eerste en laatste 2

Segmenten kunnen drie parameters hebben:

S[::2] #gepaarde elementen >>> s #elementen van de eerste tot de vierde in stappen van 2

Al deze acties kunnen worden uitgevoerd met strings, tuples en lijsten.

>>> "Hallo Dolly!" "el ol!"

Een string "uitvouwen" (tupel, lijst):

>>> "God zag dat ik een hond was"[::-1] "god zag dat ik een hond was" >>> #negatieve stap kan een hark blijken te zijn als je de details niet kent.

Er zijn verschillende sliceracties die alleen met lijsten kunnen worden uitgevoerd. Feit is dat dit de enige basissequenties zijn die kunnen veranderen en waarbij de volgorde van belang is. Vervolgens zullen we het hebben over plakjes die de volgorde veranderen.
U kunt verwijderen:

>>> s = list(range(10)) #fill 0..9 >>> del s #delete elementen tussen de derde en voorlaatste in stappen van 2 >>> s [ 0, 1, 2, 4, 6 , 8, 9]

Je kunt ook elementen invoegen:
In de vervangingsoptie:

>>> s=list("AF") #er was een lijst, we hebben de opgegeven elementen vervangen door ['A','F'] >>> #ja, zelfs in zo'n ontwerp moeten de maten overeenkomen, dat is gemakkelijker begrijpen door >>> s [0, 1, "A", 4, "F", 8, 9] te proberen

Nou ja, of een eenvoudigere invoegoptie:

>>> s = ["4 was here"] # vervanging van een opeenvolgend stuk >>> s [ 0, 1, "A", "4 was here", "F", 8, 9] >>> s = [" na nul"] #of, eenvoudigweg, invoegen >>> s [ 0, "na nul", 1, "A", "4 was hier", "F", 8, 9]

U kunt een klasse maken waaruit u segmenten kunt maken.
Overschrijf __getitem__, __setitem__ en __delitem__.
Op het eerste gezicht lijkt alles uiterst eenvoudig, maar als je beter kijkt, ontvangt __getitem__(self, key) slechts één parameter, sleutel, en kunnen we maar liefst 3 cijfers hebben voor een segment... Alles is uiterst eenvoudig: in het geval dat iemand een stuk uit ons object probeert te snijden, ontvangt de functie een object van het type slice als sleutelwaarde:

>>> class MySliceble(): def __getitem__(self, key): if isinstance(key, slice): return list(range(key.start, key.stop, key.step)) else: raise Exception("Probeert toegang via index") >>> mijn = MySliceble() >>> mijn

Het voorbeeld is natuurlijk erg symbolisch, maar je kunt het begrijpen: een object van de slice-klasse heeft drie eigenschappen: start, stop en step, die overeenkomen met de getallen tussen de slice-haakjes. Je moet voorzichtig zijn: als er een getal ontbreekt, dan zal de waarde Geen zijn, bijvoorbeeld [::] zal slice(None, None, None) zijn en [:-3] zal slice(None, -3, Geen).
Het vervangen/inbrengen en verwijderen van plakjes doen wij naar analogie.

Tupels - tupel

Een tupel is een reeks elementen, gescheiden door komma's en tussen haakjes. Het tupel zelf kan niet worden gewijzigd, maar kan wel veranderlijke elementen bevatten.

>>> t = 1, [’foo’, ’bar’] >>> t (1, [’foo’, ’bar’]) >>> t = Traceback (binnenste laatste): Bestand " ", regel 1, in ? TypeError: object ondersteunt geen itemtoewijzing >>> t.append(’baz’) >>> t(1, [’foo’, ’bar’, ’baz’])

Een lege tupel maken

c = ()

Een tupel maken van één element

c = (1,)

Woordenboeken

Je kunt een woordenboek het beste beschouwen als een ongeordende set sleutel:waarde-paren, met de vereiste dat de sleutels uniek zijn binnen één woordenboek. Een paar accolades () creëert een leeg woordenboek. Door een door komma's gescheiden lijst met sleutel:waardeparen tussen accolades te plaatsen, specificeert u de initiële inhoud van het woordenboek. Het woordenboek wordt tijdens de uitvoer in dezelfde vorm geschreven.

Om toegang te krijgen tot een woordenboekelement, moet u de sleutel ervan tussen vierkante haakjes opgeven.

>>> tel = ("jack": 4098, "sape": 4139) >>> tel["guido"] = 4127 >>> tel ("jack": 4139, "guido": 4127, "jack": 4098) >>> tel["jack"] 4098 >>> tel["sape"] >>> tel["irv"] = 4127 >>> tel ("guido": 4127, "irv": 4127, "jack": 4098) >>> tel.keys() ["guido", "irv", "jack"] >>> "guido" in tel Waar

Modules in Python

Een module is een bestand met definities en andere instructies van de Python-taal. Naam
Het bestand wordt gevormd door het achtervoegsel (extensie) ‘.py’ ​​aan de modulenaam toe te voegen. IN
binnen een module is de naam ervan beschikbaar in de globale variabele __name__.

Een module kan alle instructies bevatten die bedoeld zijn om deze te initialiseren, niet alleen functiedefinities. Ze worden alleen uitgevoerd als de module voor de eerste keer wordt geïmporteerd.

Functies en variabelen importeren

Met deze versie van de importinstructie kunt u alle namen importeren die in de module zijn gedefinieerd, behalve namen die beginnen met een onderstrepingsteken (‘_’):
>>> van fibo-import *

Vanaf Python 2.0 kunt u geïmporteerde namen overschrijven bij het uitvoeren van een importinstructie:

Importeer tekenreeks als _string vanuit anydbm import open als dbopen

functie dir()

U kunt de ingebouwde functie dir() gebruiken om de namen te achterhalen die in een module zijn gedefinieerd. Het retourneert een gesorteerde lijst met tekenreeksen:

>>> importeer fibo, sys >>> dir(fibo) ['__name__', 'fib', 'fib2'] >>> dir(sys) ['__name__', 'argv', 'builtin_module_names', 'copyright' , 'exit', 'maxint', 'modules', 'pad', 'ps1', 'ps2', 'setprofile', 'settrace', 'stderr', 'stdin', 'stdout', 'versie']

Zonder argumenten retourneert dir() een lijst met namen die in het huidige bereik zijn gedefinieerd:

De lijst die wordt geretourneerd door de functie dir() bevat niet de namen van ingebouwde functies en variabelen; deze worden gedefinieerd in de standaard __builtin__ module:

Het bestand '__init__.py' is vereist zodat Python kan herkennen dat een map een pakket bevat - waardoor wordt voorkomen dat volwaardige modules verderop in het zoekpad worden gemaskeerd door mappen met algemene namen (zoals 'string'). In het eenvoudigste geval is '__init__.py' een leeg bestand, maar kan het pakketinitialisatiecode bevatten en/of de variabele __all__ instellen,

De importinstructie gebruikt de volgende conventie: als een lijst met de naam __all__ is gedefinieerd in het initialisatiebestand '__init__.py', wordt deze gebruikt als een lijst met modulenamen die moeten worden geïmporteerd bij gebruik van 'from package import *'. Het bijhouden van deze lijst in overeenstemming met de huidige samenstelling van het pakket is de verantwoordelijkheid van de auteur. Het is ook mogelijk om de lijst __all__ niet te definiëren als de auteurs denken dat het niet gepast zou zijn om * te importeren.

Afhandeling van uitzonderingen

In het volgende voorbeeld wordt de gebruiker gevraagd totdat een geheel getal wordt ingevoerd of de uitvoering wordt afgebroken (meestal Ctrl-C). In het tweede geval wordt er een KeyboardInterrupt-uitzondering gegenereerd.

While 1: try: x = int(raw_input("Voer een geheel getal in: ")) break behalve ValueError: print "Je hebt een fout gemaakt, probeer het opnieuw..."

Een try-instructie kan meer dan één Except-clausule bevatten, waarmee handlers voor verschillende uitzonderingen worden gedefinieerd. Slechts één ervan zal worden uitgevoerd (maximaal). Alleen uitzonderingen die in de overeenkomstige try-vertakking worden gegenereerd, worden verwerkt, en niet in andere try-instructiehandlers. Na het trefwoord behalve kunnen verschillende soorten uitzonderingen als tupel worden opgegeven:

Behalve (RuntimeError, TypeError, NameError): ... pass

Na alle behalve vertakkingen kan de try-instructie een else-vertakking bevatten, die zal worden uitgevoerd als er geen uitzonderingen worden gegenereerd tijdens de uitvoering van de try-vertakking.

Lessen in Python

De belangrijkste kenmerken van klassen: het overervingsmechanisme maakt meerdere basisklassen mogelijk, een afgeleide klasse kan alle methoden van de basisklassen overschrijven, en een methode met dezelfde naam als de basisklasse kan vanuit een methode worden aangeroepen. Objecten kunnen elke hoeveelheid eigen gegevens bevatten.

Syntaxis van klassedefinitie

Het eenvoudigste model van een klassendefinitie ziet er als volgt uit:

Klasse klassenaam: een_instructie

Objecten maken - klasse-instanties

Bij het maken van een instantie van een klasse wordt gebruik gemaakt van functieaanroepnotatie. Beschouw een klasseobject eenvoudigweg als een parameterloze functie die een gemaakt exemplaar van de klasse retourneert.

X = MijnKlasse()

In het bovenstaande voorbeeld wordt een “leeg” object gemaakt.

Een voorbeeld van het maken van een klasse met attributen en methoden:

Klasse MijnKlasse: i = 12345 def f(x): return "Hallo wereld!"

In veel gevallen is het nodig om een ​​object met een specifieke beginstatus te maken - hiervoor moet de klasse een speciale __init__() -methode bevatten,

class MijnKlasse: def __init__(self): self.data =

Als voor een klasse een methode __init__() is gedefinieerd, wordt deze automatisch aangeroepen wanneer elke instantie van die klasse wordt gemaakt.

Voor meer flexibiliteit kan de methode __init__() uiteraard argumenten bevatten. In dit geval worden de argumenten die worden gebruikt om een ​​instantie van de klasse te maken, doorgegeven aan de methode __init__(). Bijvoorbeeld:

>>> klasse Complex: ... def __init__(self, realpart, imagpart): ... self.r = realpart ... self.i = imagpart ... >>> x = Complex(3.0, -4.5) >>> x.r, x.i (3,0, -4,5)

Methoden voor klasse-instanties

Meestal wordt de methode rechtstreeks aangeroepen:

In ons voorbeeld retourneert het de string 'Hallo aan de wereld!'. In dit geval is het helemaal niet nodig om de methode rechtstreeks aan te roepen. x.f is een object en kan worden opgeslagen voor later gebruik:

Xf = x.f terwijl 1: print xf()

Het bijzondere aan klassenmethoden is dat ze het object waartoe ze behoren als hun eerste argument ontvangen. In ons voorbeeld is de aanroep van x.f() volledig gelijk aan MyClass.f(x). Over het algemeen is het aanroepen van een methode die gebonden is aan een object met een lijst van n argumenten exact gelijk aan het aanroepen van de overeenkomstige, ongebonden functiemethode met de lijst met argumenten die wordt verkregen door het object vóór het eerste argument toe te voegen.

Erfenis

De definitie van een afgeleide klasse genaamd ClassB ziet er als volgt uit:

Klasse KlasseB(KlasseA): ...

De basisklasse (KlasseA) moet worden gedefinieerd in het bereik dat de afgeleide klassedefinitie KlasseB bevat. U kunt een expressie gebruiken in plaats van de naam van de basisklasse.

Als de basisklasse bijvoorbeeld in een andere module is gedefinieerd:

Klasse KlasseB (ModulA.KlasseA):

Afgeleide klassen kunnen methoden van basisklassen overschrijven. Een methode van een basisklasse die een andere methode aanroept die daarop is gedefinieerd, kan in feite
roep een methode aan van een afgeleide klasse die deze methode overschrijft

>>> klasse KlasseA: ... a = "A" ... b = "B" ... def Print_A(zelf): ... print a ... def Print_B(zelf): ... print zelf .b ... def Print_Both(self): ... pring ... def PrintBoth(self): ... print "Afdrukken A" ... self.Print_A() ... print "Afdrukken B" .. .self.Print_B() ... >>> a = "aaa" >>> cc = KlasseA() >>> cc.Print_A() aaa >>> cc.Print_B() B >>> cc.PrintBoth( ) Afdrukken A aaa Afdrukken B B >>> class ClassB(ClassA): ... def Print_A(self): ... print self.a ... >>> ccc = ClassB() >>> ccc.PrintBoth() Afdrukken A A Afdrukken B B

Wanneer u een methode in een afgeleide klasse overschrijft, wilt u wellicht ook een basisklassemethode met dezelfde naam aanroepen. Dit kan gedaan worden: roep gewoon de methode aan en specificeer expliciet de klassenaam:

>>> class ClassC(ClassA): ... def Print_A(self): ... print "Afdrukken met oude methode vanuit ClassA" ... ClassA.Print_A(self) ... >>> c = ClassC() >>> c.PrintBoth() Een afdruk afdrukken met de oude methode van ClassA aaa Afdrukken B B

Meervoudige overerving in Python

Python biedt ondersteuning voor meervoudige overerving. Aan jouw nieuwe klasse de erfgenaam is geworden van de attributen en methoden van verschillende andere klassen, vermeld ze gewoon gescheiden door komma's in de definitie van de nieuwe klasse:

>>> class ClassD(ClassB, ClassA): ... "Overerving controleren" ... ... >>> d = ClassD() >>> d.PrintBoth() Afdrukken A A Afdrukken B B

Een belangrijke nuance wanneer meerdere erfenissen- dit is een schema voor het zoeken naar objecten (naamresolutie) - eerst wordt er eerst in de diepte gezocht, daarna van links naar rechts.

Dit betekent dat als een methode- of attribuutnaam aanwezig is in beide klassen waarvan u overerft, de naam die aanwezig is in de eerste of de voorouders ervan, zal worden gebruikt.

Privé attributen

>>> klasse clA: ... __privateA = "aaa" ... def prn(s): ... print s.__privateA ... >>> klasse clB(clA): ... __privateA = "bbb" ... >>> A = clB() >>> A.prn() aaa >>> A.__privateA Traceback (meest recente oproep laatste): Bestand "", regel 1, in AttributeError: clB-instantie heeft geen attribuut " __privateA" >>> dir(A) ["__doc__", "__module__", "_clA__privateA", "_clB__privateA", "prn"] >>> A._clB__privateA "bbb" >>>

Praktische voorbeelden

Hoe verwijder ik alle tekens behalve cijfers uit een string in Python?

>>> import re >>> re.sub("[^0-9]", "", "sdkjh987978asd098as0980a98sd") "987978098098098"

Een interessant ding Wat ik vandaag zag, is dat wanneer ik een functie aan een klaslid toewijs, dit een ongebonden methode wordt. Zoals:

Klasse Test(object): @classmethod def initialize_class(cls): def print_string(self, str): print(str) # Hier als ik print(print_string) doe, zie ik een functie cls.print_proc = print_string # Hier als ik dat doe print(cls.print_proc), ik zie een ongebonden methode; dus als ik # een Testobject o krijg, kan ik o.print_proc("Hallo") aanroepen

2018-12-04T00:00Z

nogal moeilijk te begrijpen

Welnu, dit is een behoorlijk complex onderwerp en het heeft te maken met descriptoren.

Laten we beginnen met de functie. Alles is hier duidelijk - je noemt het gewoon, alle opgegeven argumenten worden doorgegeven wanneer het wordt uitgevoerd:

>>> f = A.__dict__["f1"] >>> f(1) 1

Een reguliere TypeError treedt op als er problemen zijn met het aantal parameters:

>>> ", regel 1, in TypeError: f1() heeft precies 1 argument nodig (0 gegeven)

Nu de methoden. Methoden zijn functies met een beetje pit. Er zijn hier beschrijvingen. Zoals beschreven in het datamodel worden A.f1 en A().f1 vertaald naar A.__dict__["f1"].__get__(Geen, A) en type(a).__dict__["f1"].__get__(a , type (a)) respectievelijk. En de resultaten van deze __get__ verschillen van de onbewerkte f1-functie. Deze objecten vormen een omhulsel rond de originele f1 en bevatten wat extra logica.

In het geval van een ongebonden methode houdt deze logica in dat wordt gecontroleerd of het eerste argument een instantie van A is:

>>> f = A.f1 >>> f() Traceback (meest recente oproep laatste): Bestand " ", regel 1, in TypeError: ongebonden methode f1() moet worden aangeroepen met A-instantie als eerste argument (kreeg in plaats daarvan niets) >>> f(1) Traceback (meest recente oproep laatste): File " ", regel 1, in TypeError: ongebonden methode f1() moet worden aangeroepen met A-instantie als eerste argument (kreeg in plaats daarvan int-instantie)

Als deze controle slaagt, wordt de originele f1 uitgevoerd met deze instantie als eerste argument:

>>> f(A())<__main__.A object at 0x800f238d0>

Merk op dat het im_self attribuut Geen is:

>>> f.im_self is Geen Waar

In het geval van de gebonden methode levert deze logica onmiddellijk de originele f1 met de instantie van A die is gemaakt (deze instantie wordt feitelijk opgeslagen in im_self):

>>> f = A().f1 >>> f.im_self<__main__.A object at 0x800f23950>>>> f()<__main__.A object at 0x800f23950>

Zo gebonden betekent dat basisfunctie gebonden aan een bepaald exemplaar. ongebonden betekent dat het nog steeds gebonden is, maar alleen aan de klasse.

2018-12-11T00:00Z

Mijn interpretatie is deze.

Functieklassefragmenten:

Klasse Functie(object): . . .

def __get__(self, obj, objtype=None): "Simuleer func_descr_get() in Objects/funcobject.c" als obj Geen is: return self return types.MethodType(self, obj)

1. Klasse Functie(object): . . .

def __get__(self, obj, objtype=None): "Simuleer func_descr_get() in Objects/funcobject.c" return types.MethodType(self, obj, objtype)
Als een functie zonder klasse of instantie wordt aangeroepen, is het een eenvoudige functie. Als een functie wordt aangeroepen vanuit een klasse of instantie, wordt de __get__ ervan aangeroepen om de ingepakte functie op te halen: A. Bx is hetzelfde als B.__dict__["x"].__get__(Geen, B) . In Python 3 keert dit terug

reguliere functie