Verschil tussen Python-methodemethoden - Wat is het verschil tussen een functie, een ongebonden methode en een gebonden methode? Bestanden lezen en schrijven. Operaties en operanden

Overzicht van de syntaxisverschillen tussen python2 en python3.

Afdrukken - functie

De print-instructie is vervangen door de print()-functie, met benoemde argumenten om een ​​groot deel van de syntaxis van de oude print-instructie te vervangen. Voorbeelden:

U kunt ook de scheiding tussen elementen aanpassen, bijvoorbeeld:

De functie print() ondersteunt de soft space-functie van de oude print-instructie niet. In Python 2 drukt u bijvoorbeeld "A\n" af, terwijl "B" "A\nB\n" afdrukt; maar in Python 3 zal print("A\n", "B") "A\n B\n" afdrukken.

Mappings en iterators in plaats van lijsten

Sommige zijn goed bekende methoden keert niet terug in Python 3:

• De woordenboekmethoden dict.keys(), dict.items() en dict.values() retourneren "toewijzingen" in plaats van lijsten. Het werkt bijvoorbeeld niet meer: ​​k = d.keys(); k.sort(). Gebruik k = gesorteerd(d).
• Dienovereenkomstig worden de methoden dict.iterkeys(), dict.iteritems() en dict.itervalues() niet langer ondersteund.
• map() en filter() retourneren iteratoren. Als je echt een lijst nodig hebt, is een snelle oplossing list(map(...)), maar vaak is de beste oplossing het gebruik van lijstgeneratoren (vooral als de originele code lambda-expressies gebruikt), of het herschrijven van de lijst. code zodat er geen dergelijke lijst nodig is. Bijzonder lastig is dat map() aanroept bijwerkingen functies; de juiste conversie is het gebruik van een lus (het maken van een lijst is gewoon verspilling).
• range() gedraagt ​​zich nu als xrange(), maar werkt met waarden van elke grootte. xrange() bestaat niet meer.
• zip() retourneert een iterator.

Vergelijkingsoperatoren

Python 3 heeft de regels voor vergelijkingsoperatoren vereenvoudigd:

Vergelijkingsoperatoren (<, <=, >=, >) genereert een TypeError-uitzondering wanneer de operanden niet kunnen worden besteld. Dus uitdrukkingen van type 1< "", 0 >Geen of len<= len более не разрешены, и, например, None < None поднимает TypeError, а не возвращает False. Следствием является то, что сортировка списка с разными типами данных больше не имеет смысла - все элементы должны быть сравнимы друг с другом. Обратите внимание, что это не относится к операторам == и!=: объекты различных несравнимых типов всегда неравны друг другу.

ingebouwde.sorted() en list.sort() accepteren niet langer een cmp-argument dat een vergelijkingsfunctie biedt. Gebruik in plaats daarvan het sleutelargument. De sleutel- en omgekeerde argumenten zijn nu 'alleen trefwoord'.

De functie cmp() moet als verouderd worden beschouwd en de speciale methode __cmp__() wordt niet ondersteund in Python 3. Gebruik __lt__() om te sorteren, __eq__() met __hash__() voor vergelijking. (Als je de cmp()-functionaliteit echt nodig hebt, kun je de uitdrukking (a > b) - (a< b) в качестве эквивалента для cmp(a, b).)

gehele getallen

• PEP 0237: lang hernoemd naar int.
• PEP 0238: Een uitdrukking als 1/2 retourneert een float. Gebruik 1//2 om het fractionele deel af te snijden. (Deze syntaxis bestaat sinds Python 2.2)
• De constante sys.maxint is verwijderd omdat er geen limiet meer is voor de waarde van gehele getallen. Sys.maxsize kan echter worden gebruikt als een getal dat groter is dan welke praktische lijst of stringindex dan ook. sys.maxsize komt overeen met de "natuurlijke" grootte van het gehele getal en heeft doorgaans dezelfde waarde als sys.maxint op hetzelfde platform (uitgaande van dezelfde build-opties).
• repr() op een lang geheel getal bevat niet het afsluitende L-teken, dus code die dat teken onvoorwaardelijk afsnijdt, zal het in plaats daarvan afknippen laatste cijfer. (Gebruik in plaats daarvan str().)
• Octale letterlijke waarden hebben niet langer de vorm 0720; gebruik 0o720.

Tekst-, Unicode- en 8-bit-reeksen

Alles wat u wist over binaire gegevens en Unicode is veranderd.

Python 3 gebruikt de concepten tekst en (binaire) data in plaats van Unicode-strings en 8-bit-strings. Alle tekst is Unicode; Unicode-gecodeerde tekenreeksen worden echter weergegeven als binaire gegevens. Het type dat wordt gebruikt om tekst op te slaan is , het type dat wordt gebruikt om gegevens op te slaan is . Het grootste verschil met Python 2.x is dat elke poging om tekst en gegevens in Python 3.0 te combineren een TypeError oplevert, terwijl als je Unicode- en 8-bits strings zou mixen in Python 2.x het zou werken als de 8-bits string er maar 7 zou bevatten. -bit (ASCII) tekens, maar u krijgt een UnicodeDecodeError als deze niet- ASCII-tekens. Dit gedrag heeft door de jaren heen voor talloze treurige gezichten gezorgd.

Als gevolg van deze verandering in de filosofie zal waarschijnlijk een groot deel van de code die Unicode, coderingen of binaire gegevens gebruikt, moeten veranderen. Dit is een verandering ten goede, aangezien Python 2.x talloze bugs bevatte die verband hielden met het mixen van gecodeerde en gedecodeerde tekst. Om hierop voorbereid te zijn, zou Python 2.x Unicode moeten gaan gebruiken voor alle niet-gecodeerde tekst, en str alleen voor binaire of gecodeerde gegevens. Dan is de 2to3-tool voldoende de meeste werk voor jou.

U kunt de letterlijke u"..." niet langer gebruiken voor Unicode-tekst. U moet echter de letterlijke b"..." gebruiken voor binaire gegevens.

Omdat str en bytes niet kunnen worden gemengd, moet u ze altijd expliciet converteren. Gebruik str.encode() om van str naar bytes te gaan en bytes.decode() om van bytes naar str te gaan. U kunt ook respectievelijk bytes(s, encoding=...) en str(b, encoding=...) gebruiken.

Net als str is het bytestype onveranderlijk. Er is een apart veranderbaar type voor binaire gegevens, bytearray. Bijna alle functies die bytes accepteren, accepteren ook bytearray.

Alle backslashes in letterlijke letterlijke tekenreeksen worden letterlijk geïnterpreteerd. Dit betekent dat er geen speciale aandacht wordt besteed aan "\U" en "\u" in onbewerkte tekenreeksen. R"\u20ac" is bijvoorbeeld een reeks van zes tekens in Python 3.0, terwijl in 2.6 ur"\u20ac" een enkel "euro"-teken was. (Deze wijziging heeft uiteraard alleen invloed op de letterlijke letterlijke tekenreeksen.)

Ingebouwd abstracte soort basisstring is verwijderd. Gebruik in plaats daarvan str. str en bytes hebben niet genoeg gemeenschappelijke functionaliteit om een ​​gemeenschappelijke basisklasse te rechtvaardigen. De 2to3-tool (zie hieronder) vervangt elk voorkomen van basestring door str.

PEP 3138: repr() op een string ontsnapt niet langer aan niet-ASCII-tekens. Het ontsnapt echter nog steeds aan de controlekarakters

PEP 3120: De standaardbroncodering is nu UTF-8.

PEP 3131: Niet-ASCII-tekens zijn toegestaan ​​in ID's. (Hoe dan ook, standaard bibliotheek blijft ASCII, behalve de auteursnamen in de opmerkingen.)

De StringIO- en cStringIO-modules zijn verwijderd. Importeer in plaats daarvan de io-module en gebruik respectievelijk io.StringIO of io.BytesIO voor tekst en gegevens.

Overzicht van syntaxiswijzigingen

Deze sectie geeft een kort overzicht van elke syntaxiswijziging in Python 3.0.

Nieuwe syntaxis

PEP 3107: Annotaties voor functieargumenten en retourwaarden.

PEP 3102: Argumenten met alleen trefwoorden.

PEP 3104: niet-lokaal. Een variabele met een buitenste (maar niet globale) reikwijdte.

PEP 3132: Uitgebreid itereerbaar uitpakken

Woordenboekgeneratoren: (k: v voor k, v in stuff) (hetzelfde als dict(stuff))

Stel letterlijke waarden in (bijvoorbeeld (1, 2)). Merk op dat () een leeg woordenboek is. Gebruik set() voor lege sets. Generatoren instellen: (x voor x in dingen)

Nieuwe octale letterlijke waarden, zoals 0o720, in plaats van de oude (0720).

Nieuwe binaire letterlijke waarden, zoals 0b1010. Nieuwe ingebouwde functie, bin().

Gewijzigde syntaxis

PEP 3109 en PEP 3134: Nieuwe syntaxis voor de uitdrukking raise: raise ].

"als" en "met" zijn gereserveerde woorden.

'Waar' en 'Onwaar' en 'Geen' zijn gereserveerde woorden.

Gewijzigd "behalve exc, var" in "behalve exc als var".

PEP 3115: Nieuwe syntaxis voor metaklassen. In plaats van:

Je zou moeten gebruiken:

De variabele __metaclass__ wordt niet langer ondersteund.

Lijstgenerators worden niet langer ondersteund syntactische vorm[... voor var in item1, item2, ...]. Gebruik [... voor var in (item1, item2, ...)].

Syntaxis op afstand

PEP 3113: Het uitpakken van tupels in parameters is verwijderd. Je kunt niet meer schrijven

Achterstreep verwijderd. Gebruik repr().

Verwijderd<>. Gebruik !=.

exec - functie. Niet langer een gereserveerd woord.

van module import * kan niet worden gebruikt binnen functies.

Ingebouwde functies

PEP3135: Nieuwe super(). Je kunt nu super() aanroepen zonder argumenten en (ervan uitgaande dat het een instantiemethode is die is gedefinieerd binnen de klassedefinitie) zullen de klasse en instantie automatisch worden geselecteerd. Met argumenten blijft het gedrag van super() ongewijzigd.

PEP 3111: Hernoemd naar raw_input() naar input(). In plaats van input() in Python 2 kun je eval(input()) gebruiken.

Functie next() toegevoegd, die de methode __next__() van het object aanroept.

Intern() verplaatst naar sys.intern().

Verwijderd: toepassen(). Gebruik f(*args) in plaats van apply(f, args).

Verwijderd: opvraagbaar(). In plaats van callable(f), gebruik je hasattr(f, "__call__"). De functie operator.isCallable() is ook verwijderd.

Verwijderd: dwingen().

Verwijderd: execbestand(). In plaats van execfile(fn), gebruik je exec(open(fn).read()).

Verwijderd: bestand. Gebruik open().

Verplaatst: reduce() naar functools.reduce()

Verplaatst: reload() naar imp.reload().

Verwijderd: dict.has_key(). Gebruik de in-operator.

In dit artikel vindt u de belangrijkste punten die nuttig kunnen zijn bij het overschakelen naar een taal Python-programmering 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!

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 voor het vervangen van waarden in een string: 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 de waarde hebt afgedrukt, in plaats van naar te gaan nieuwe lijn:

>>> 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 tekenreeks te lang is, wordt deze niet afgekapt, maar ongewijzigd geretourneerd: het is meestal beter om de kolomindeling te verpesten dan om de verkeerde waarde uit te voeren. (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 operatoren 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, evenals 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.

Hetzelfde geldt als u iets aan de reeks toevoegt nieuw onderdeel vóór de huidige 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 een rekenkundige progressie:
>>> bereik(10)

De functie xrange 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, ontevredenheid over de omstandigheden in terwijl lus), zonder onderbreking door de break-instructie. Laten we het gebruik ervan demonstreren met behulp van een zoekvoorbeeld. 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

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

>>> def fib(n): ... '''Toont Fibonacci-getallen binnen een bepaald getal''' ... a, b = 0, 1 ... while 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. Bijvoorbeeld, volgende functie verzamelt 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 tupel doorgegeven. Een variabel aantal argumenten kan worden voorafgegaan door een willekeurig aantal reguliere argumenten:

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 " Regelmatige argumenten:", formele 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 afbeeldingen in JPEG-formaat en zelfs tekst in UNICODE zal beschadigd raken wanneer u leest uit een bestand of schrijft naar een bestand dat in tekstmodus is geopend! De beste manier Om uzelf tegen problemen te beschermen, moet u bestanden altijd in de binaire modus openen, zelfs op platforms waar de binaire modus standaard wordt gebruikt (misschien wilt u het programma ooit 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)

Python ingebouwde

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 basisreeksen 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 voeg gewoon >>> s in [ 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 omsloten door 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

Een tupel maken van één element

Woordenboeken

Je kunt een woordenboek het beste beschouwen als een ongeordende set sleutel:waarde-paren, met de vereiste dat de sleutels uniek zijn binnen hetzelfde woordenboek. Een paar accolades () creëert een leeg woordenboek. Door een door komma's gescheiden lijst met sleutel-waardeparen in te voeren beugel, U geeft de initiële inhoud van het woordenboek op. 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 ("sape": 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

Module - een bestand met definities en andere instructies 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, '__init__.py' - leeg bestand, maar kan 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 trefwoord behalve kan verschillende soorten uitzonderingen specificeren als een tuple:

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 specifiek object te maken initiële staat- hiervoor moet de klasse een speciale methode __init__() bevatten,

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 is gebonden 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 de oude methode van 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

Praktische voorbeelden

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

Een interessant ding Wat ik vandaag zag, is dat wanneer ik een functie aan een klaslid toewijs, het 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: