Vad är nytt i Python 3.3

I den här artikeln förklaras de nya funktionerna i Python 3.3 jämfört med 3.2. Python 3.3 släpptes den 29 september 2012. För fullständig information, se changelog.

Se även

PEP 398 - Python 3.3 Utgivningsschema

Sammanfattning – Release highlights

Nya syntaxfunktioner:

Nya biblioteksmoduler:

  • faulthandler (hjälper till att felsöka krascher på låg nivå)

  • ipaddress (högnivåobjekt som representerar IP-adresser och masker)

  • lzma (komprimera data med hjälp av XZ/LZMA-algoritmen)

  • unittest.mock (ersätt delar av ditt system under test med låtsasobjekt)

  • venv (Python virtuella miljöer, som i det populära paketet virtualenv)

Nya inbyggda funktioner:

Förbättringar av genomförandet:

Betydligt förbättrade biblioteksmoduler:

Förbättringar av säkerheten:

  • Hash-randomisering är aktiverad som standard.

Läs vidare för en omfattande lista över förändringar som riktar sig till användarna.

PEP 405: Virtuella miljöer

Virtuella miljöer hjälper till att skapa separata Python-installationer samtidigt som de delar en systemomfattande basinstallation för att underlätta underhållet. Virtuella miljöer har sin egen uppsättning privata webbplatspaket (dvs. lokalt installerade bibliotek) och är valfritt separerade från de systemomfattande webbplatspaketen. Konceptet och implementeringen är inspirerat av det populära tredjepartspaketet virtualenv, men har en tätare integration med tolkens kärna.

Denna PEP lägger till modulen venv för programmatisk åtkomst och skriptet pyvenv för kommandoradsåtkomst och administration. Python-tolken kontrollerar om det finns en ”pyvenv.cfg”-fil, vars existens signalerar basen i en virtuell miljös katalogträd.

Se även

PEP 405 - Virtuella Python-miljöer

PEP skriven av Carl Meyer; implementation av Carl Meyer och Vinay Sajip

PEP 420: Implicita namnrymdsförpackningar

Inbyggt stöd för paketkataloger som inte kräver __init__.py-markörfiler och som automatiskt kan sträcka sig över flera sökvägssegment (inspirerat av olika tredjepartsansatser för namnrymdspaket, som beskrivs i PEP 420)

Se även

PEP 420 - Implicita paket i namnrymden

PEP utarbetat av Eric V. Smith; genomförande av Eric V. Smith och Barry Warsaw

PEP 3118: Ny implementering av memoryview och dokumentation av buffertprotokoll

Implementeringen av PEP 3118 har förbättrats avsevärt.

Den nya implementeringen av memoryview åtgärdar alla ägande- och livstidsproblem med dynamiskt allokerade fält i Py_buffer-strukturen som ledde till flera kraschrapporter. Dessutom har flera funktioner som kraschade eller returnerade felaktiga resultat för icke-sammanhängande eller flerdimensionell indata åtgärdats.

Memoryview-objektet har nu en PEP-3118-kompatibel getbufferproc() som kontrollerar konsumentens begärandetyp. Många nya funktioner har lagts till, de flesta av dem fungerar i full generalitet för icke sammanhängande arrayer och arrayer med suboffsets.

Dokumentationen har uppdaterats och anger tydligt ansvarsområdena för både exportörer och konsumenter. Flaggor för buffertbegäran är indelade i grundläggande och sammansatta flaggor. Minneslayouten för icke-sammanhängande och flerdimensionella matriser i NumPy-stil förklaras.

Funktioner

  • Alla inbyggda formatspecifikatorer för enstaka tecken i struct-modulsyntax (eventuellt med prefixet ’@’) stöds nu.

  • Med vissa begränsningar kan cast()-metoden ändra format och form på C-slutna matriser.

  • Flerdimensionella listrepresentationer stöds för alla array-typer.

  • Flerdimensionella jämförelser stöds för alla typer av matriser.

  • Endimensionella minnesvyer av hashbara (skrivskyddade) typer med formaten B, b eller c är nu hashbara. (Bidrag från Antoine Pitrou i bpo-13411.)

  • Stöd finns för godtycklig skivning av alla typer av 1-D matriser. Till exempel är det nu möjligt att vända en minnesvy i O(1) genom att använda ett negativt steg.

API-ändringar

  • Det maximala antalet dimensioner är officiellt begränsat till 64.

  • Representationen av tom form, strides och suboffsets är nu en tom tupel istället för None.

  • Åtkomst till ett memoryview-element med formatet ’B’ (unsigned bytes) returnerar nu ett heltal (i enlighet med struct-modulens syntax). För att returnera ett bytes-objekt måste vyn först castas till ’c’.

  • memoryview-jämförelser använder nu operandernas logiska struktur och jämför alla arrayelement med värde. Alla formatsträngar i struct-modulsyntax stöds. Vyer med formatsträngar som inte känns igen är fortfarande tillåtna, men kommer alltid att jämföras som ojämlika, oavsett vyns innehåll.

  • För ytterligare ändringar se Build and C API Changes och Porting C code.

(Bidrag från Stefan Krah i bpo-10181.)

Se även

PEP 3118 - Revidering av buffertprotokollet

PEP 393: Flexibel strängrepresentation

Unicode-strängtypen ändras för att stödja flera interna representationer, beroende på tecknet med den största Unicode-ordinalen (1, 2 eller 4 byte) i den representerade strängen. Detta möjliggör en utrymmeseffektiv representation i vanliga fall, men ger tillgång till fullständig UCS-4 på alla system. För kompatibilitet med befintliga API:er kan flera representationer existera parallellt; med tiden bör denna kompatibilitet fasas ut.

På Python-sidan bör det inte finnas några nackdelar med denna förändring.

På C API-sidan är PEP 393 helt bakåtkompatibel. Det äldre API:et bör vara tillgängligt i minst fem år. Program som använder det äldre API:et kommer inte att dra full nytta av minnesminskningen, eller - ännu värre - kan använda lite mer minne, eftersom Python kan behöva underhålla två versioner av varje sträng (i det äldre formatet och i den nya effektiva lagringen).

Funktionalitet

Ändringar införda av PEP 393 är följande:

  • Python stöder nu alltid hela utbudet av Unicode-kodpunkter, inklusive icke-BMP-kodpunkter (dvs. från U+0000 till U+10FFFF). Skillnaden mellan narrow och wide builds finns inte längre och Python beter sig nu som en wide build, även under Windows.

  • Med döden för smala byggnader har de problem som är specifika för smala byggnader också åtgärdats, till exempel:

    • len() returnerar nu alltid 1 för icke-BMP-tecken, så len('\U0010FFFF') == 1;

    • surrogatpar kombineras inte om i stränglitteraler, så '\uDBFF\uDFFF' != '\U0010FFFF';

    • indexering eller skärning av icke-BMP-tecken returnerar det förväntade värdet, så '\U0010FFFF'[0] returnerar nu '\U0010FFFF' och inte '\uDBFF';

    • alla andra funktioner i standardbiblioteket hanterar nu korrekt icke-BMP-kodpunkter.

  • Värdet för sys.maxunicode är nu alltid 1114111 (0x10FFFF i hexadecimal). Funktionen PyUnicode_GetMax() returnerar fortfarande antingen 0xFFFF eller 0x10FFFF för bakåtkompatibilitet, och den bör inte användas med det nya Unicode API:et (se bpo-13054).

  • Flaggan ./configure --with-wide-unicode har tagits bort.

Prestanda och resursanvändning

Lagringen av Unicode-strängar beror nu på den högsta kodpunkten i strängen:

  • rena ASCII- och Latin1-strängar (U+0000-U+00FF) använder 1 byte per kodpunkt;

  • BMP-strängar (U+0000-U+FFFF) använder 2 byte per kodpunkt;

  • icke-BMP-strängar (U+10000-U+10FFFF) använder 4 byte per kodpunkt.

Nettoeffekten är att för de flesta applikationer bör minnesanvändningen för stränglagring minska avsevärt - särskilt jämfört med tidigare breda unicode-byggnader - eftersom strängar i många fall kommer att vara ren ASCII även i internationella sammanhang (eftersom många strängar lagrar data som inte är mänskligt språk, t.ex. XML-fragment, HTTP-rubriker, JSON-kodade data etc.). Vi hoppas också att det, av samma skäl, kommer att öka CPU-cacheeffektiviteten i icke-triviala applikationer. Minnesanvändningen för Python 3.3 är två till tre gånger mindre än för Python 3.2 och lite bättre än för Python 2.7 i ett Django-benchmark (se PEP för detaljer).

Se även

PEP 393 - Flexibel strängrepresentation

PEP skriven av Martin von Löwis; implementation av Torsten Becker och Martin von Löwis.

PEP 397: Python Launcher för Windows

Windows-installationsprogrammet för Python 3.3 innehåller nu en startapplikation för Python som kan användas för att starta Python-applikationer på ett versionsoberoende sätt.

Den här startprogrammet anropas implicit när man dubbelklickar på *.py-filer. Om bara en enda Python-version är installerad på systemet kommer den versionen att användas för att köra filen. Om flera versioner är installerade används den senaste versionen som standard, men detta kan åsidosättas genom att inkludera en Unix-liknande ”shebang-rad” i Python-skriptet.

Startprogrammet kan också användas explicit från kommandoraden som programmet py. Att köra py följer samma regler för versionsval som implicit start av skript, men en mer specifik version kan väljas genom att skicka lämpliga argument (t.ex. -3 för att begära Python 3 när Python 2 också är installerat, eller -2.6 för att specifikt begära en tidigare Python-version när en nyare version är installerad).

Förutom startprogrammet innehåller Windows-installationsprogrammet nu ett alternativ för att lägga till det nyinstallerade Python i systemets PATH. (Bidrag från Brian Curtin i bpo-3561.)

Se även

PEP 397 - Python Launcher för Windows

PEP skriven av Mark Hammond och Martin v. Löwis; implementation av Vinay Sajip.

Dokumentation om startprogrammet: Pythons installationshanterare

Ändring av installationsprogrammets PATH: Pythons installationshanterare

PEP 3151: Omarbetning av undantagshierarkin för OS och IO

Hierarkin av undantag som orsakas av fel i operativsystemet är nu både förenklad och mer finkornig.

Du behöver inte längre oroa dig för att välja rätt undantagstyp mellan OSError, IOError, EnvironmentError, WindowsError, mmap.error, socket.error eller select.error. Alla dessa undantagstyper är nu bara en: OSError. De andra namnen behålls som alias av kompatibilitetsskäl.

Det är nu också lättare att fånga upp ett specifikt feltillstånd. Istället för att inspektera attributet errno (eller args[0]) för en viss konstant från modulen errno, kan du fånga den lämpliga underklassen OSError. De tillgängliga underklasserna är följande:

Och ConnectionError i sig har finkornigare underklasser:

  • BrokenPipeError

  • Fel vid avbruten anslutning

  • AnslutningRefusedError

  • Fel vid återställning av anslutning

Tack vare de nya undantagen kan vanliga användningar av errno nu undvikas. Till exempel, följande kod skriven för Python 3.2:

från errno import ENOENT, EACCES, EPERM

försök:
    med open("document.txt") som f:
        innehåll = f.read()
except IOError as err:
    if err.errno == ENOENT:
        print("filen document.txt saknas")
    elif err.errno in (EACCES, EPERM):
        print("Du har inte tillåtelse att läsa document.txt")
    else:
        raise

kan nu skrivas utan errno-importen och utan manuell inspektion av undantagsattribut:

försök:
    med open("document.txt") som f:
        innehåll = f.read()
except FileNotFoundError:
    print("filen document.txt saknas")
except PermissionError:
    print("Du har inte tillåtelse att läsa document.txt")

Se även

PEP 3151 - Omarbetning av undantagshierarkin för OS och IO

PEP skrivet och genomfört av Antoine Pitrou

PEP 380: Syntax för delegering till en undergenerator

PEP 380 lägger till uttrycket yield from, vilket gör det möjligt för en generator att delegera en del av sina operationer till en annan generator. Detta gör att ett kodavsnitt som innehåller yield kan faktoriseras ut och placeras i en annan generator. Dessutom tillåts subgeneratorn att returnera ett värde, och värdet görs tillgängligt för den delegerande generatorn.

Uttrycket yield from är främst avsett att användas för delegering till en subgenerator, men det tillåter faktiskt delegering till godtyckliga subiteratorer.

För enkla iteratorer är yield from iterable i huvudsak bara en förkortad form av for item in iterable: yield item:

>>> def g(x):
...     yield from range(x, 0, -1)
...     yield from range(x)
...
>>> list(g(5))
[5, 4, 3, 2, 1, 0, 1, 2, 3, 4]

Till skillnad från en vanlig loop tillåter dock yield from undergeneratorer att ta emot skickade och kastade värden direkt från det anropande området och returnera ett slutvärde till den yttre generatorn:

>>> def accumulate():
...     tally = 0
...     while 1:
...         next = yield
...         if next is None:
...             return tally
...         tally += next
...
>>> def gather_tallies(tallies):
...     while 1:
...         tally = yield from accumulate()
...         tallies.append(tally)
...
>>> tallies = []
>>> acc = gather_tallies(tallies)
>>> next(acc)  # Ensure the accumulator is ready to accept values
>>> for i in range(4):
...     acc.send(i)
...
>>> acc.send(None)  # Finish the first tally
>>> for i in range(5):
...     acc.send(i)
...
>>> acc.send(None)  # Finish the second tally
>>> tallies
[6, 10]

Huvudprincipen bakom denna ändring är att även generatorer som är utformade för att användas med metoderna send och throw ska kunna delas upp i flera undergeneratorer lika enkelt som en enda stor funktion kan delas upp i flera underfunktioner.

Se även

PEP 380 - Syntax för att delegera till en undergenerator

PEP skriven av Greg Ewing; implementering av Greg Ewing, integrerad i 3.3 av Renaud Blanch, Ryan Kelly och Nick Coghlan; dokumentation av Zbigniew Jędrzejewski-Szmek och Nick Coghlan

PEP 409: Undertryckande av undantagskontext

PEP 409 introducerar en ny syntax som gör det möjligt att inaktivera visningen av den kedjade undantagskontexten. Detta möjliggör renare felmeddelanden i applikationer som konverterar mellan undantagstyper:

>>> class D:
...     def __init__(self, extra):
...         self._extra_attributes = extra
...     def __getattr__(self, attr):
...         try:
...             return self._extra_attributes[attr]
...         except KeyError:
...             raise AttributeError(attr) from None
...
>>> D({}).x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 8, in __getattr__
AttributeError: x

Utan suffixet from None för att undertrycka orsaken skulle det ursprungliga undantaget visas som standard:

>>> class C:
...     def __init__(self, extra):
...         self._extra_attributes = extra
...     def __getattr__(self, attr):
...         try:
...             return self._extra_attributes[attr]
...         except KeyError:
...             raise AttributeError(attr)
...
>>> C({}).x
Traceback (most recent call last):
  File "<stdin>", line 6, in __getattr__
KeyError: 'x'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 8, in __getattr__
AttributeError: x

Ingen felsökningskapacitet går förlorad, eftersom den ursprungliga undantagskontexten förblir tillgänglig om det behövs (till exempel om ett mellanliggande bibliotek felaktigt har undertryckt värdefulla underliggande detaljer):

>>> try:
...     D({}).x
... except AttributeError as exc:
...     print(repr(exc.__context__))
...
KeyError('x',)

Se även

PEP 409 - Undertryckande av undantagskontext

PEP skriven av Ethan Furman; implementerad av Ethan Furman och Nick Coghlan.

PEP 414: Explicita Unicode-litteraler

För att underlätta övergången från Python 2 för Unicode-medvetna Python-applikationer som använder Unicode-litteraler i stor utsträckning, stöder Python 3.3 återigen prefixet ”u” för stränglitteraler. Detta prefix har ingen semantisk betydelse i Python 3, det tillhandahålls enbart för att minska antalet rent mekaniska förändringar vid migrering till Python 3, vilket gör det lättare för utvecklare att fokusera på de mer betydande semantiska förändringarna (såsom den striktare standardseparationen av binär- och textdata).

Se även

PEP 414 - Explicita Unicode-litteraler

PEP skriven av Armin Ronacher.

PEP 3155: Kvalificerade namn för klasser och funktioner

Funktioner och klassobjekt har ett nytt attribut __qualname__ som representerar ”sökvägen” från modulens toppnivå till deras definition. För globala funktioner och klasser är detta samma sak som __name__. För andra funktioner och klasser ger det bättre information om var de faktiskt definierades och hur de kan vara åtkomliga från det globala omfånget.

Exempel med (icke bundna) metoder:

>>> class C:
...     def meth(self):
...         pass
...
>>> C.meth.__name__
'meth'
>>> C.meth.__qualname__
'C.meth'

Exempel med nästlade klasser:

>>> class C:
...     class D:
...         def meth(self):
...             pass
...
>>> C.D.__name__
'D'
>>> C.D.__qualname__
'C.D'
>>> C.D.meth.__name__
'meth'
>>> C.D.meth.__qualname__
'C.D.meth'

Exempel med nästlade funktioner:

>>> def outer():
...     def inner():
...         pass
...     return inner
...
>>> outer().__name__
'inner'
>>> outer().__qualname__
'outer.<locals>.inner'

Strängrepresentationen av dessa objekt ändras också för att inkludera den nya, mer exakta informationen:

>>> str(C.D)
"<class '__main__.C.D'>"
>>> str(C.D.meth)
'<function C.D.meth at 0x7f46b9fe31e0>'

Se även

PEP 3155 - Kvalificerat namn för klasser och funktioner

PEP skrivet och genomfört av Antoine Pitrou.

PEP 412: Ordbok för nyckelutbyte

Dictionaries som används för lagring av objektens attribut kan nu dela en del av sitt interna minne mellan varandra (nämligen den del som lagrar nycklarna och deras respektive hash). Detta minskar minnesförbrukningen i program som skapar många instanser av icke byggda typer.

Se även

PEP 412 - Ordbok för nyckeldelning

PEP skrivet och genomfört av Mark Shannon.

PEP 362: Funktion Signatur Objekt

En ny funktion inspect.signature() gör introspektion av python callables enkel och okomplicerad. Ett brett spektrum av anropsbara objekt stöds: pythonfunktioner, dekorerade eller ej, klasser och functools.partial()-objekt. De nya klasserna inspect.Signature, inspect.Parameter och inspect.BoundArguments innehåller information om anropssignaturer, t.ex. annoteringar, standardvärden, parametertyper och bundna argument, vilket avsevärt förenklar skrivandet av dekoratorer och annan kod som validerar eller ändrar anropssignaturer eller argument.

Se även

PEP 362: - Funktion Signatur Objekt

PEP skriven av Brett Cannon, Yury Selivanov, Larry Hastings, Jiwon Seo; implementerad av Yury Selivanov.

PEP 421: Lägga till sys.implementation

Ett nytt attribut på modulen sys visar detaljer som är specifika för implementationen av den tolk som körs för tillfället. Den första uppsättningen attribut på sys.implementation är name, version, hexversion och cache_tag.

Avsikten med sys.implementation är att konsolidera implementationsspecifika data som används av standardbiblioteket i ett namnrymd. Detta gör det möjligt för olika Python-implementationer att dela en enda kodbas för standardbiblioteket mycket lättare. I sitt initiala tillstånd innehåller sys.implementation endast en liten del av de implementationsspecifika data. Med tiden kommer detta förhållande att förändras för att göra standardbiblioteket mer portabelt.

Ett exempel på förbättrad standardbiblioteksportabilitet är cache_tag. Från och med Python 3.3 används sys.implementation.cache_tag av importlib för att stödja PEP 3147 efterlevnad. Alla Python-implementationer som använder importlib för sitt inbyggda importsystem kan använda cache_tag för att kontrollera cachelagringsbeteendet för moduler.

SimpleNamespace

Implementationen av sys.implementation introducerar också en ny typ i Python: types.SimpleNamespace. I motsats till en mappningsbaserad namnrymd, som dict, är SimpleNamespace attributbaserad, som object. Men till skillnad från object är SimpleNamespace-instanser skrivbara. Detta innebär att du kan lägga till, ta bort och ändra namnrymden genom normal attributåtkomst.

Se även

PEP 421 - Lägger till sys.implementation

PEP skrivet och implementerat av Eric Snow.

Använda importlib som implementering av import

bpo-2377 - Ersätt __import__ med importlib.__import__ bpo-13959 - Återimplementera delar av imp i ren Python bpo-14605 - Gör importmaskiner explicit bpo-14646 - Kräv att laddare anger __loader__ och __package__

Funktionen __import__() drivs nu av importlib.__import__(). Detta arbete leder till slutförandet av ”fas 2” av PEP 302. Det finns flera fördelar med den här förändringen. För det första har det gjort det möjligt att exponera mer av maskineriet som driver import istället för att vara implicit och dolt i C-koden. Det ger också en enda implementering för alla Python VMs som stöder Python 3.3 att använda, vilket hjälper till att avsluta alla VM-specifika avvikelser i import semantik. Och slutligen underlättar det underhållet av import, vilket gör att framtida tillväxt kan ske.

För den vanliga användaren bör det inte finnas någon synlig förändring i semantiken. För dem vars kod för närvarande manipulerar import eller anropar import programmatiskt, beskrivs de kodändringar som eventuellt kan krävas i avsnittet Porting Python code i detta dokument.

Nya API:er

En av de stora fördelarna med detta arbete är exponeringen av vad som krävs för att importdeklarationen ska fungera. Det innebär att de olika importörer som en gång var implicita nu är helt exponerade som en del av importlib-paketet.

De abstrakta basklasserna som definieras i importlib.abc har utökats för att korrekt skilja mellan meta path finders och path entry finders genom att introducera importlib.abc.MetaPathFinder respektive importlib.abc.PathEntryFinder. Den gamla ABC:en importlib.abc.Finder finns nu bara för bakåtkompatibilitet och upprätthåller inga metodkrav.

När det gäller sökare visar importlib.machinery.FileFinder den mekanism som används för att söka efter käll- och bytecode-filer för en modul. Tidigare var denna klass en implicit medlem av sys.path_hooks.

För laddare hjälper den nya abstrakta basklassen importlib.abc.FileLoader till att skriva en laddare som använder filsystemet som lagringsmekanism för en moduls kod. Laddaren för källfiler (importlib.machinery.SourceFileLoader), sourceless bytecode-filer (importlib.machinery.SourcelessFileLoader) och tilläggsmoduler (importlib.machinery.ExtensionFileLoader) är nu tillgängliga för direkt användning.

ImportError har nu attributen name och path som anges när det finns relevanta data att tillhandahålla. Meddelandet för misslyckad import kommer nu också att innehålla modulens fullständiga namn istället för bara slutet av modulens namn.

Funktionen importlib.invalidate_caches() kommer nu att anropa metoden med samma namn på alla sökare som cachats i sys.path_importer_cache för att hjälpa till att rensa upp i lagrat tillstånd vid behov.

Synliga förändringar

För eventuella nödvändiga ändringar i koden, se avsnittet Porting Python code.

Utöver den stora mängden av vad importlib nu exponerar, finns det andra synliga förändringar i import. Den största är att sys.meta_path och sys.path_hooks nu lagrar alla metasökvägssökare och sökvägskrokar som används av import. Tidigare var sökarna implicita och gömda i C-koden för import i stället för att vara direkt exponerade. Detta innebär att man nu enkelt kan ta bort eller ändra ordningen på de olika sökarna så att de passar ens behov.

En annan förändring är att alla moduler har ett __loader__-attribut, som lagrar den laddare som användes för att skapa modulen. PEP 302 har uppdaterats för att göra detta attribut obligatoriskt för laddare att implementera, så i framtiden när laddare från tredje part har uppdaterats kommer folk att kunna lita på att attributet finns. Fram till dess ställer dock import in modulen efter laddning.

Laddare förväntas nu också ställa in attributet __package__ från PEP 366. Än en gång, import själv ställer redan in detta på alla laddare från importlib och import själv ställer in attributet efter laddning.

None infogas nu i sys.path_importer_cache när ingen sökare kan hittas i sys.path_hooks. Eftersom imp.NullImporter inte är direkt exponerad på sys.path_hooks kan man inte längre förlita sig på att den alltid är tillgänglig för att användas som ett värde som representerar att ingen sökare hittats.

Alla andra ändringar avser semantiska ändringar som bör beaktas vid uppdatering av kod för Python 3.3, och bör därför läsas om i avsnittet Porting Python code i detta dokument.

(Genomförande av Brett Cannon)

Andra språkliga förändringar

Några mindre ändringar som gjorts i Python-språkets kärna är:

  • Stöd för Unicode-namnaliaser och namngivna sekvenser har lagts till. Både unicodedata.lookup() och '\N{...}' löser nu namnaliaser, och unicodedata.lookup() löser även namngivna sekvenser.

    (Bidrag från Ezio Melotti i bpo-12753.)

  • Unicode-databasen uppdaterad till UCD version 6.1.0

  • Jämlikhetsjämförelser på range()-objekt returnerar nu ett resultat som återspeglar likheten mellan de underliggande sekvenser som genereras av dessa range-objekt. (bpo-13201)

  • Metoderna count(), find(), rfind(), index() och rindex() för objekten bytes och bytearray accepterar nu ett heltal mellan 0 och 255 som sitt första argument.

    (Bidrag från Petri Lehtinen i bpo-12170.)

  • Metoderna rjust(), ljust() och center() i bytes och bytearray accepterar nu bytearray som argument för fill. (Bidrag från Petri Lehtinen i bpo-12380.)

  • Nya metoder har lagts till i list och bytearray: copy() och clear() (bpo-10516). Följaktligen definierar MutableSequence nu också en clear()-metod (bpo-11388).

  • Raw bytes literaler kan nu skrivas rb"..." såväl som br"...".

    (Bidrag från Antoine Pitrou i bpo-13748.)

  • dict.setdefault() gör nu bara en uppslagning för den angivna nyckeln, vilket gör den atomisk när den används med inbyggda typer.

    (Bidrag från Filip Gruszczyński i bpo-13521.)

  • De felmeddelanden som visas när ett funktionsanrop inte stämmer överens med funktionssignaturen har förbättrats avsevärt.

    (Bidrag från Benjamin Peterson.)

Ett mer finfördelat importlås

Tidigare versioner av CPython har alltid förlitat sig på ett globalt importlås. Detta ledde till oväntade irritationsmoment, t.ex. dödlägen när import av en modul skulle utlösa kodkörning i en annan tråd som en bieffekt. Klumpiga lösningar användes ibland, till exempel C API-funktionen PyImport_ImportModuleNoBlock().

I Python 3.3 tar import av en modul ett lås per modul. Detta serialiserar importen av en viss modul från flera trådar på ett korrekt sätt (vilket förhindrar exponering av ofullständigt initialiserade moduler), samtidigt som de tidigare nämnda irritationsmomenten elimineras.

(Bidrag från Antoine Pitrou i bpo-9260.)

Inbyggda funktioner och typer

  • open() får en ny parameter opener: den underliggande filbeskrivaren för filobjektet erhålls sedan genom att anropa opener med (file, flags). Det kan användas för att använda anpassade flaggor som till exempel os.O_CLOEXEC. Läget 'x' lades till: öppet för exklusivt skapande, misslyckas om filen redan finns.

  • print(): lade till nyckelordsargumentet flush. Om nyckelordsargumentet flush är sant, spolas flödet med våld.

  • hash(): hashslumpning är aktiverad som standard, se object.__hash__() och PYTHONHASHSEED.

  • Typen str får en ny casefold()-metod: returnerar en casefoldad kopia av strängen, casefoldade strängar kan användas för caseless matchning. Till exempel, 'ß'.casefold() returnerar 'ss'.

  • Dokumentationen för sekvenser har skrivits om i stor utsträckning för att bättre förklara skillnaden mellan binära och textsekvenser och för att tillhandahålla specifika dokumentationsavsnitt för de enskilda inbyggda sekvenstyperna (bpo-4966).

Nya moduler

felhanterare

Denna nya felsökningsmodul faulthandler innehåller funktioner för att dumpa Python-spårningar explicit, vid ett fel (en krasch som ett segmenteringsfel), efter en timeout eller vid en användarsignal. Anropa faulthandler.enable() för att installera felhanterare för signalerna SIGSEGV, SIGFPE, SIGABRT, SIGBUS och SIGILL. Du kan också aktivera dem vid start genom att ställa in miljövariabeln PYTHONFAULTHANDLER eller genom att använda kommandoradsalternativet -X faulthandler.

Exempel på ett segmenteringsfel på Linux:

$ python -q -X faulthandler
>>> import ctypes
>>> ctypes.string_at(0)
Fatal Python error: Segmentation fault

Current thread 0x00007fb899f39700:
  File "/home/python/cpython/Lib/ctypes/__init__.py", line 486 in string_at
  File "<stdin>", line 1 in <module>
Segmentation fault

ipadress

Den nya modulen ipaddress tillhandahåller verktyg för att skapa och manipulera objekt som representerar IPv4- och IPv6-adresser, nätverk och gränssnitt (dvs. en IP-adress som är associerad med ett specifikt IP-subnät).

(Bidrag från Google och Peter Moody i PEP 3144.)

lzma

Den nyligen tillagda modulen lzma tillhandahåller datakomprimering och dekomprimering med hjälp av LZMA-algoritmen, inklusive stöd för filformaten .xz och .lzma.

(Bidrag från Nadeem Vawda och Per Øyvind Karlsen i bpo-6715.)

Förbättrade moduler

abc

Förbättrat stöd för abstrakta basklasser som innehåller deskriptorer som består av abstrakta metoder. Det rekommenderade tillvägagångssättet för att deklarera abstrakta deskriptorer är nu att tillhandahålla __isabstractmethod__ som en dynamiskt uppdaterad egenskap. De inbyggda deskriptorerna har uppdaterats i enlighet med detta.

(Bidrag från Darren Dale i bpo-11610.)

abc.ABCMeta.register() returnerar nu den registrerade underklassen, vilket innebär att den nu kan användas som en klassdekorator (bpo-10868).

array

Modulen array stöder typen long long med hjälp av typkoderna q och Q.

(Bidrag från Oren Tirosh och Hirokazu Yamamoto i bpo-1172711.)

base64

ASCII-only Unicode-strängar accepteras nu av avkodningsfunktionerna i det moderna gränssnittet base64. Till exempel, base64.b64decode('YWJj') returnerar b'abc'. (Bidrag från Catalin Iacob i bpo-13641.)

binascii

Förutom de binära objekt som de normalt accepterar, accepterar nu alla a2b_-funktioner även ASCII-strängar som indata. (Bidrag från Antoine Pitrou i bpo-13637.)

bz2

Modulen bz2 har skrivits om från grunden. Under processen har flera nya funktioner lagts till:

  • Ny bz2.open()-funktion: öppna en bzip2-komprimerad fil i binärt eller textläge.

  • bz2.BZ2File kan nu läsa från och skriva till godtyckliga filliknande objekt, med hjälp av konstruktörens fileobj-argument.

    (Bidrag från Nadeem Vawda i bpo-5863.)

  • bz2.BZ2File och bz2.decompress() kan nu dekomprimera inmatningar med flera strömmar (t.ex. de som produceras av verktyget pbzip2). bz2.BZ2File kan nu också användas för att skapa den här typen av filer med läget 'a (append).

    (Bidrag från Nir Aides i bpo-1625.)

  • bz2.BZ2File implementerar nu hela io.BufferedIOBase API, förutom metoderna detach() och truncate().

codecs

Codec mbcs har skrivits om för att korrekt hantera felhanterarna replace och ignore på alla Windows-versioner. Codecen mbcs stöder nu alla felhanterare, istället för bara replace för kodning och ignore för avkodning.

En ny codec för enbart Windows har lagts till: cp65001 (bpo-13216). Det är Windows-kodsidan 65001 (Windows UTF-8, CP_UTF8). Den används till exempel av sys.stdout om kodsidan för konsolutmatning är inställd på cp65001 (t.ex. med kommandot chcp 65001).

CJK-avkodare för flera byte återsynkroniseras nu snabbare. De ignorerar bara den första byten i en ogiltig byte-sekvens. Till exempel, b'\xff\n'.decode('gb2312', 'replace') returnerar nu ett \n efter ersättningstecknet.

(bpo-12016)

Inkrementella CJK-codec-kodare nollställs inte längre vid varje anrop till deras encode()-metoder. Till exempel:

>>> import codecs
>>> encoder = codecs.getincrementalencoder('hz')('strict')
>>> b''.join(encoder.encode(x) for x in '\u52ff\u65bd\u65bc\u4eba\u3002 Bye.')
b'~{NpJ)l6HK!#~} Bye.'

Detta exempel ger b'~{Np~}~{J)~}~{l6~}~{HK~}~{!#~} Bye.' med äldre Python-versioner.

(bpo-12100)

Codec unicode_internal har utgått.

samlingar

Tillägg av en ny ChainMap-klass som gör det möjligt att behandla ett antal mappningar som en enda enhet. (Skrivet av Raymond Hettinger för bpo-11089, publicerat i bpo-11297.)

De abstrakta basklasserna har flyttats till en ny modul collections.abc för att bättre skilja mellan de abstrakta och de konkreta samlingsklasserna. Alias för ABC finns fortfarande kvar i modulen collections för att bevara befintlig import. (bpo-11085)

Klassen Counter har nu stöd för de unära operatorerna + och -, samt för in-place-operatorerna +=, -=, |= och &=. (Bidrag från Raymond Hettinger i bpo-13121.)

contextlib

ExitStack ger nu en solid grund för programmatisk manipulation av kontexthanterare och liknande upprensningsfunktioner. Till skillnad från det tidigare API:et contextlib.nested (som föråldrades och togs bort), är det nya API:et utformat för att fungera korrekt oavsett om kontexthanterare förvärvar sina resurser i sin __init__-metod (till exempel filobjekt) eller i sin __enter__-metod (till exempel synkroniseringsobjekt från modulen threading).

(bpo-13585)

kryptan

Tillägg av salt och modulärt kryptformat (hashingmetod) och funktionen mksalt() till modulen crypt.

(bpo-10924)

curses

  • Om modulen curses är länkad till biblioteket ncursesw, använd Unicode-funktioner när Unicode-strängar eller tecken skickas (t.ex. waddwstr()), och bytes-funktioner annars (t.ex. waddstr()).

  • Använd den lokala kodningen istället för utf-8 för att koda Unicode-strängar.

  • curses.window har ett nytt attribut curses.window.encoding.

  • Klassen curses.window har en ny get_wch()-metod för att få ett brett tecken

  • Modulen curses har en ny unget_wch()-funktion för att skjuta upp ett brett tecken så att nästa get_wch() returnerar det

(Bidrag från Iñigo Serna i bpo-6755.)

datatid

decimal

bpo-7652 - integrera snabb inbyggd decimalaritmetik.

C-modul och libmpdec skrivna av Stefan Krah.

Den nya C-versionen av decimalmodulen integrerar det snabba libmpdec-biblioteket för flyttalsaritmetik med godtycklig precision och korrekt avrundad decimal. libmpdec överensstämmer med IBM:s General Decimal Arithmetic Specification.

Prestandavinsterna varierar från 10x för databasapplikationer till 100x för numeriskt intensiva applikationer. Dessa siffror är förväntade vinster för standardprecisioner som används i decimal aritmetik med flyttal. Eftersom precisionen kan konfigureras av användaren kan de exakta siffrorna variera. Till exempel kan skillnaderna vara betydligt större i aritmetik med heltal och bignum.

Följande tabell är avsedd som en illustration. Benchmarks finns tillgängliga på https://www.bytereef.org/mpdecimal/quickstart.html.

decimal.py

_decimal

acceleration

pi

42.02s

0.345s

120x

telekom

172.19s

5.68s

30x

psycopg

3.57s

0.29s

12x

Funktioner

  • Signalen FloatOperation ger möjlighet till striktare semantik för att blanda floats och decimaler.

  • Om Python kompileras utan trådar, inaktiverar C-versionen automatiskt den dyra lokala kontextmekanismen för trådar. I detta fall sätts variabeln HAVE_THREADS till False.

API-ändringar

  • C-modulen har följande kontextgränser, beroende på maskinens arkitektur:

    32-bitars

    64-bitars

    MAX_PREC

    425000000

    999999999999999999

    MAX_EMAX

    425000000

    999999999999999999

    MIN_EMIN

    -425000000

    -999999999999999999

  • I kontextmallarna (DefaultContext, BasicContext och ExtendedContext) har storleken på Emax och Emin ändrats till 999999.

  • Konstruktorn Decimal i decimal.py följer inte kontextgränserna och konverterar värden med godtyckliga exponenter eller precision exakt. Eftersom C-versionen har interna gränser används följande schema: Om möjligt konverteras värden exakt, annars InvalidOperation och resultatet blir NaN. I det senare fallet är det alltid möjligt att använda create_decimal() för att få ett avrundat eller inexakt värde.

  • Potensfunktionen i decimal.py är alltid korrekt avrundad. I C-versionen definieras den i termer av de korrekt avrundade funktionerna exp() och ln(), men slutresultatet är bara ”nästan alltid korrekt avrundat”.

  • I C-versionen är kontextordboken som innehåller signalerna en MutableMapping. Av hastighetsskäl refererar flags och traps alltid till samma MutableMapping som kontexten initialiserades med. Om en ny signalordbok tilldelas, uppdateras flags och traps med de nya värdena, men de refererar inte till RHS ordbok.

  • Pickling av en Context ger en annan utdata för att ha ett gemensamt utbytesformat för Python- och C-versionerna.

  • Ordningen på argumenten i Context-konstruktören har ändrats så att den stämmer överens med den ordning som visas av repr().

  • Parametern watchexp i metoden quantize() är föråldrad.

e-post

Politiskt ramverk

E-postpaketet har nu ett policy-ramverk. En policy är ett objekt med flera metoder och egenskaper som styr hur e-postpaketet beter sig. Den primära policyn för Python 3.3 är Compat32-policyn, som ger bakåtkompatibilitet med e-postpaketet i Python 3.2. En policy kan anges när ett e-postmeddelande analyseras av en parser, eller när ett Message-objekt skapas, eller när ett e-postmeddelande serialiseras med en generator. Om den inte åsidosätts ärvs en policy som skickas till en parser av alla Message-objekt och underobjekt som skapas av parser. Som standard kommer en generator att använda policyn för det Message-objekt som den serialiserar. Standardpolicyn är compat32.

Den minsta uppsättning kontroller som implementeras av alla policy-objekt är:

max_radlängd

Den maximala längden, exklusive linesep-tecknet/tecknen, som enskilda rader kan ha när ett Message serialiseras. Standardvärdet är 78.

linjespets

Det tecken som används för att separera enskilda rader när ett Message serialiseras. Standard är n.

cte_typ

7bit eller 8bit. 8bit gäller endast för en Bytes generator och innebär att icke-ASCII kan användas där det är tillåtet enligt protokollet (eller där det finns i den ursprungliga inmatningen).

höja_på_defekt

Gör att en parser utlöser ett fel när defekter påträffas istället för att lägga till dem i Message-objektets defects-lista.

En ny policyinstans med nya inställningar skapas med hjälp av metoden clone() för policyobjekt. clone tar någon av ovanstående kontroller som nyckelordsargument. Alla kontroller som inte anges i anropet behåller sitt standardvärde. På så sätt kan du skapa en policy som använder linjära tecken som ”r” så här:

mypolicy = compat32.clone(linesep='\r\n')

Policies kan användas för att förenkla genereringen av meddelanden i det format som behövs i din applikation. Istället för att behöva komma ihåg att ange linesep='\r\n' på alla ställen där du anropar en generator, kan du ange det en gång, när du anger den policy som används av parser eller Message, beroende på vilket ditt program använder för att skapa Message-objekt. Om du å andra sidan behöver generera meddelanden i flera olika former kan du fortfarande ange parametrarna i det lämpliga anropet till generator. Eller så kan du ha anpassade policyinstanser för dina olika fall och skicka in dem när du skapar generator.

Provisorisk policy med nytt Header API

Policyramverket är värdefullt i sig, men huvudmotivet för att introducera det är att möjliggöra skapandet av nya policyer som implementerar nya funktioner för e-postpaketet på ett sätt som bibehåller bakåtkompatibilitet för dem som inte använder de nya policyerna. Eftersom de nya policyerna introducerar ett nytt API, släpper vi dem i Python 3.3 som en provisional policy. Bakåtkompatibla ändringar (upp till och inklusive borttagning av koden) kan förekomma om det anses nödvändigt av kärnutvecklarna.

De nya policyerna är instanser av EmailPolicy, och lägger till följande ytterligare kontroller:

refold_källa

Styr om rubriker som analyseras av en parser ska vikas om av generator eller inte. Det kan vara none, long eller all. Standardvärdet är long, vilket innebär att källhuvuden med en rad längre än max_line_length viks om. none innebär att ingen rad viks om och all innebär att alla rader viks om.

header_factory

En callable som tar ett namn och värde och producerar ett anpassat header-objekt.

header_factory är nyckeln till de nya funktioner som de nya policyerna ger. När en av de nya policyerna används är varje header som hämtas från ett Message-objekt ett objekt som produceras av header_factory, och varje gång du ställer in en header på ett Message blir det ett objekt som produceras av header_factory. Alla sådana headerobjekt har attributet name som är lika med headerns namn. Adress- och datumrubriker har ytterligare attribut som ger dig tillgång till rubrikens analyserade data. Detta innebär att du nu kan göra saker som detta:

>>> m = Message(policy=SMTP)
>>> m['To'] = 'Éric <foo@example.com>'
>>> m['to']
'Éric <foo@example.com>'
>>> m['to'].addresses
(Address(display_name='Éric', username='foo', domain='example.com'),)
>>> m['to'].addresses[0].username
'foo'
>>> m['to'].addresses[0].display_name
'Éric'
>>> m['Date'] = email.utils.localtime()
>>> m['Date'].datetime
datetime.datetime(2012, 5, 25, 21, 39, 24, 465484, tzinfo=datetime.timezone(datetime.timedelta(-1, 72000), 'EDT'))
>>> m['Date']
'Fri, 25 May 2012 21:44:27 -0400'
>>> print(m)
To: =?utf-8?q?=C3=89ric?= <foo@example.com>
Date: Fri, 25 May 2012 21:44:27 -0400

Du kommer att märka att det unicodade visningsnamnet automatiskt kodas som utf-8 när meddelandet serialiseras, men att du får den unicodade versionen när rubriken öppnas direkt. Detta eliminerar behovet av att hantera funktionerna email.header decode_header() eller make_header().

Du kan också skapa adresser från delar:

>>> m['cc'] = [Group('pals', [Address('Bob', 'bob', 'example.com'),
...                           Address('Sally', 'sally', 'example.com')]),
...            Address('Bonzo', addr_spec='bonz@laugh.com')]
>>> print(m)
To: =?utf-8?q?=C3=89ric?= <foo@example.com>
Date: Fri, 25 May 2012 21:44:27 -0400
cc: pals: Bob <bob@example.com>, Sally <sally@example.com>;, Bonzo <bonz@laugh.com>

Avkodning till unicode sker automatiskt:

>>> m2 = message_from_string(str(m))
>>> m2['to']
'Éric <foo@example.com>'

När du analyserar ett meddelande kan du använda attributen addresses och groups i rubrikobjekten för att komma åt grupperna och de enskilda adresserna:

>>> m2['cc'].addresses
(Address(display_name='Bob', username='bob', domain='example.com'), Address(display_name='Sally', username='sally', domain='example.com'), Address(display_name='Bonzo', username='bonz', domain='laugh.com'))
>>> m2['cc'].groups
(Group(display_name='pals', addresses=(Address(display_name='Bob', username='bob', domain='example.com'), Address(display_name='Sally', username='sally', domain='example.com')), Group(display_name=None, addresses=(Address(display_name='Bonzo', username='bonz', domain='laugh.com'),))

Om du använder en av de nya policyerna fungerar manipuleringen av rubriker som den ska: din applikation arbetar med unicode-strängar och e-postpaketet kodar och avkodar unicode på ett transparent sätt till och från RFC-standarden Content Transfer Encodings.

Andra API-ändringar

Ny BytesHeaderParser, tillagd i modulen parser för att komplettera HeaderParser och komplettera Bytes API.

Nya nyttofunktioner:

ftplib

  • ftplib.FTP accepterar nu ett source_address nyckelordsargument för att ange (host, port) att använda som källadress i bind-anropet när man skapar den utgående sockeln. (Bidrag från Giampaolo Rodolà i bpo-8594.)

  • Klassen FTP_TLS tillhandahåller nu en ny ccc()-funktion för att återställa kontrollkanalen till klartext. Detta kan vara användbart för att dra nytta av brandväggar som vet hur man hanterar NAT med icke-säker FTP utan att öppna fasta portar. (Bidrag från Giampaolo Rodolà i bpo-12139.)

  • Lagt till ftplib.FTP.mlsd()-metoden som tillhandahåller ett analyserbart kataloglistningsformat och tar bort ftplib.FTP.nlst() och ftplib.FTP.dir(). (Bidrag från Giampaolo Rodolà i bpo-11072.)

functools

Dekoratorn functools.lru_cache() accepterar nu ett typed nyckelordsargument (som standard är False för att säkerställa att den cachar värden av olika typer som jämför lika i separata cacheplatser. (Bidrag från Raymond Hettinger i bpo-13227.)

gc

Det är nu möjligt att registrera callbacks som anropas av garbage collector före och efter insamlingen med hjälp av den nya callbacks-listan.

hmac

En ny compare_digest()-funktion har lagts till för att förhindra sidokanalattacker på sammanställningar genom tidsanalys. (Bidrag från Nick Coghlan och Christian Heimes i bpo-15061.)

http

http.server.BaseHTTPRequestHandler buffrar nu headers och skriver dem alla på en gång när end_headers() anropas. En ny metod flush_headers() kan användas för att direkt hantera när de ackumulerade headers skickas. (Bidrag från Andrew Schaaf i bpo-3709.)

http.server producerar nu giltig HTML 4.01 strict utdata. (Bidrag från Ezio Melotti i bpo-13295.)

http.client.HTTPResponse har nu en readinto()-metod, vilket innebär att den kan användas som en io.RawIOBase-klass. (Bidrag från John Kuhn i bpo-13464.)

html

html.parser.HTMLParser kan nu analysera trasig markup utan att orsaka fel, därför är strict-argumentet i konstruktorn och HTMLParseError-undantaget nu föråldrade. Möjligheten att parsa trasig markup är resultatet av ett antal buggfixar som också finns tillgängliga i de senaste buggfixversionerna av Python 2.7/3.2. (Bidrag från Ezio Melotti i bpo-15114, and bpo-14538, bpo-13993, bpo-13960, bpo-13358, bpo-1745761, bpo-755670, bpo-13357, bpo-12629, bpo-1200313, bpo-670664, bpo-13273, bpo-12888, bpo-7311.)

En ny html5-ordbok som mappar HTML5 namngivna teckenreferenser till motsvarande Unicode-tecken (t.ex. html5['gt;'] == '>') har lagts till i modulen html.entities. Ordboken används nu även av HTMLParser. (Bidrag från Ezio Melotti i bpo-11113 och bpo-15156.)

imaplib

Konstruktorn IMAP4_SSL accepterar nu en SSLContext-parameter för att styra parametrarna för den säkra kanalen.

(Bidrag från Sijin Joseph i bpo-8808.)

inspektera

En ny getclosurevars()-funktion har lagts till. Denna funktion rapporterar den aktuella bindningen av alla namn som refereras från funktionskroppen och var dessa namn löstes, vilket gör det lättare att verifiera korrekt internt tillstånd när man testar kod som förlitar sig på stateful closures.

(Bidrag från Meador Inge och Nick Coghlan i bpo-13062.)

En ny getgeneratorlocals()-funktion har lagts till. Denna funktion rapporterar den aktuella bindningen av lokala variabler i generatorns stackram, vilket gör det lättare att verifiera korrekt internt tillstånd vid testning av generatorer.

(Bidrag från Meador Inge i bpo-15153.)

io

Funktionen open() har ett nytt 'x'-läge som kan användas för att uteslutande skapa en ny fil, och ge upphov till ett FileExistsError om filen redan finns. Det är baserat på C11 ’x’-läget för fopen().

(Bidrag från David Townshend i bpo-12760.)

Konstruktorn för klassen TextIOWrapper har ett nytt write_through valfritt argument. Om write_through är True garanteras att anrop till write() inte buffras: all data som skrivs på TextIOWrapper-objektet hanteras omedelbart till dess underliggande binära buffert.

itertools

accumulate() tar nu ett valfritt func-argument för att tillhandahålla en binär funktion från användaren.

loggning

Funktionen basicConfig() stöder nu ett valfritt handlers-argument som tar en iterabel av handläggare som ska läggas till rotloggaren.

Ett klassnivåattribut append_nul har lagts till i SysLogHandler för att möjliggöra kontroll av tillägget av byte NUL (\000) till syslogposter, eftersom det krävs för vissa daemoner medan det för andra skickas vidare till loggen.

matematik

Modulen math har en ny funktion, log2(), som returnerar bas-2-logaritmen för x.

(Skrivet av Mark Dickinson i bpo-11888.)

mmap

Metoden read() är nu mer kompatibel med andra filliknande objekt: om argumentet utelämnas eller anges som None returnerar den bytena från den aktuella filpositionen till slutet av mappningen. (Bidrag från Petri Lehtinen i bpo-12021.)

multiprocessing

Den nya funktionen multiprocessing.connection.wait() gör det möjligt att polla flera objekt (t.ex. anslutningar, sockets och pipes) med en timeout. (Bidrag från Richard Oudkerk i bpo-12328.)

multiprocessing.Connection-objekt kan nu överföras över multiprocessing-anslutningar. (Bidrag från Richard Oudkerk i bpo-4892.)

multiprocessing.Process accepterar nu ett daemon nyckelordsargument för att åsidosätta standardbeteendet att ärva daemon flaggan från den överordnade processen (bpo-6064).

Med det nya attributet multiprocessing.Process.sentinel kan ett program vänta på flera Process-objekt samtidigt med hjälp av lämpliga OS-primitiver (t.ex. select på posix-system).

Nya metoder multiprocessing.pool.Pool.starmap() och starmap_async() ger itertools.starmap() motsvarigheter till de befintliga funktionerna multiprocessing.pool.Pool.map() och map_async(). (Bidrag från Hynek Schlawack i bpo-12708.)

nntplib

Klassen nntplib.NNTP stöder nu kontexthanteringsprotokollet för att ovillkorligen konsumera socket.error undantag och för att stänga NNTP-anslutningen när den är klar:

>>> from nntplib import NNTP
>>> with NNTP('news.gmane.org') as n:
...     n.group('gmane.comp.python.committers')
...
('211 1755 1 1755 gmane.comp.python.committers', 1755, 1, 1755, 'gmane.comp.python.committers')
>>>

(Bidrag från Giampaolo Rodolà i bpo-9795.)

os

  • Modulen os har en ny funktion pipe2() som gör det möjligt att skapa en pipe med flaggorna O_CLOEXEC eller O_NONBLOCK atomiskt. Detta är särskilt användbart för att undvika tävlingsförhållanden i flertrådade program.

  • Modulen os har en ny funktion sendfile() som ger ett effektivt ”zero-copy”-sätt att kopiera data från en fil- (eller socket-) deskriptor till en annan. Uttrycket ”zero-copy” syftar på det faktum att all kopiering av data mellan de två deskriptorerna görs helt av kärnan, utan att data kopieras till buffertar i userspace. sendfile() kan användas för att effektivt kopiera data från en fil på disk till en nätverkssocket, t.ex. för att ladda ner en fil.

    (Patch inlämnad av Ross Lagerwall och Giampaolo Rodolà i bpo-10882.)

  • För att undvika tävlingsförhållanden som symlänkattacker och problem med temporära filer och kataloger är det mer tillförlitligt (och även snabbare) att manipulera filbeskrivare istället för filnamn. Python 3.3 förbättrar befintliga funktioner och introducerar nya funktioner för att arbeta med filbeskrivare (bpo-4761, bpo-10755 och bpo-14626).

  • access() accepterar ett effective_ids nyckelordsargument för att aktivera användning av effektiv uid/gid istället för verklig uid/gid i åtkomstkontrollen. Plattformsstöd för detta kan kontrolleras via uppsättningen supports_effective_ids.

  • Modulen os har två nya funktioner: getpriority() och setpriority(). De kan användas för att hämta eller ställa in processens niceness/prioritet på ett sätt som liknar os.nice() men utökat till alla processer istället för bara den aktuella.

    (Patch inlämnad av Giampaolo Rodolà i bpo-10784.)

  • Den nya funktionen os.replace() gör det möjligt att byta namn på en fil över flera plattformar med överskrivning av destinationsfilen. Med os.rename() skrivs en befintlig destinationsfil över under POSIX, men ger upphov till ett fel under Windows. (Bidrag från Antoine Pitrou i bpo-8828.)

  • Stat-familjen av funktioner (stat(), fstat() och lstat()) stöder nu läsning av en fils tidsstämplar med nanosekunders precision. Symmetriskt kan utime() nu skriva filens tidsstämplar med nanosekundsprecision. (Bidrag från Larry Hastings i bpo-14127.)

  • Den nya funktionen os.get_terminal_size() frågar efter storleken på terminalen som är kopplad till en filbeskrivare. Se även shutil.get_terminal_size(). (Bidrag från Zbigniew Jędrzejewski-Szmek i bpo-13609.)

pdb

Tabbkomplettering är nu tillgänglig inte bara för kommandonamn utan även för deras argument. För kommandot break kompletteras t.ex. funktions- och filnamn.

(Bidrag från Georg Brandl i bpo-14210)

gurka

pickle.Pickler-objekt har nu ett valfritt dispatch_table-attribut som gör det möjligt att ställa in reduktionsfunktioner för varje pickler.

(Bidrag från Richard Oudkerk i bpo-14166.)

pydoc

Tk GUI och funktionen serve() har tagits bort från modulen pydoc: pydoc -g och serve() har utgått i Python 3.2.

re

str reguljära uttryck stöder nu \u och U escapes.

(Bidrag från Serhiy Storchaka i bpo-3665.)

schema

  • run() accepterar nu en blockerande parameter som när den sätts till false gör att metoden kör de schemalagda händelser som kommer att löpa ut tidigast (om det finns några) och sedan återgår omedelbart. Detta är användbart om du vill använda scheduler i icke-blockerande applikationer. (Bidrag från Giampaolo Rodolà i bpo-13449.)

  • scheduler kan nu användas på ett säkert sätt i flertrådade miljöer. (Bidrag från Josiah Carlson och Giampaolo Rodolà i bpo-8684.)

  • timefunc och delayfunct parametrarna i scheduler klasskonstruktören är nu valfria och standardvärdena är time.time() respektive time.sleep(). (Bidrag från Chris Clark i bpo-13245.)

  • enter() och enterabs() argument parametern är nu valfri. (Bidrag från Chris Clark i bpo-13245.)

  • enter() och enterabs() accepterar nu en kwargs parameter. (Bidrag från Chris Clark i bpo-13245.)

välj

Solaris och avledda plattformar har en ny klass select.devpoll för högpresterande asynkrona sockets via /dev/poll. (Bidrag från Jesús Cea Avión i bpo-6397.)

shlex

Den tidigare odokumenterade hjälpfunktionen quote från pipes-modulerna har flyttats till shlex-modulen och dokumenterats. quote() undviker på rätt sätt alla tecken i en sträng som annars skulle kunna ges en speciell betydelse av skalet.

shutil

  • Nya funktioner:

    • disk_usage(): ger statistik över totalt, använt och ledigt diskutrymme. (Bidrag från Giampaolo Rodolà i bpo-12442.)

    • chown(): gör det möjligt att ändra användare och/eller grupp för den angivna sökvägen genom att ange användarens/gruppens namn och inte bara deras numeriska id. (Bidrag från Sandro Tosi i bpo-12191.)

    • shutil.get_terminal_size(): returnerar storleken på terminalfönstret som tolken är kopplad till. (Bidrag från Zbigniew Jędrzejewski-Szmek i bpo-13609.)

  • copy2() och copystat() bevarar nu filernas tidsstämplar med nanosekundsprecision på plattformar som stöder detta. De bevarar även filens ”utökade attribut” på Linux. (Bidrag från Larry Hastings i bpo-14127 och bpo-15238.)

  • Flera funktioner tar nu ett valfritt symlinks-argument: när den parametern är sann, avrefereras inte symlinks och operationen agerar istället på själva symlinken (eller skapar en, om relevant). (Bidrag från Hynek Schlawack i bpo-12715.)

  • Vid kopiering av filer till ett annat filsystem hanterar move() nu symbollänkar på samma sätt som posix-kommandot mv gör, genom att återskapa symbollänken istället för att kopiera innehållet i målfilen. (Bidrag från Jonathan Niehof i bpo-9993.) move() returnerar nu även argumentet dst som sitt resultat.

  • rmtree() är nu resistent mot symlänk-attacker på plattformar som stöder den nya dir_fd-parametern i os.open() och os.unlink(). (Bidrag från Martin von Löwis och Hynek Schlawack i bpo-4489.)

signal

  • Modulen signal har fått nya funktioner:

  • Signalhanteraren skriver signalnumret som en enda byte i stället för en nul-byte i wakeup-filens deskriptor. Det är alltså möjligt att vänta på mer än en signal och veta vilka signaler som utlöstes.

  • signal.signal() och signal.siginterrupt() ger upphov till ett OSError, istället för ett RuntimeError: OSError har ett errno attribut.

smtpd

Modulen smtpd stöder nu RFC 5321 (extended SMTP) och RFC 1870 (size extension). Enligt standarden aktiveras dessa tillägg om och endast om klienten initierar sessionen med ett EHLO-kommando.

(Initialt stöd för ELHO av Alberto Trevino. Storleksutökning av Juhana Jauhiainen. Betydande ytterligare arbete på patchen bidragit av Michele Orrù och Dan Boswell. bpo-8739)

smtplib

Klasserna SMTP, SMTP_SSL och LMTP accepterar nu ett source_address nyckelordsargument för att ange (host, port) att använda som källadress i bind-anropet när det utgående uttaget skapas. (Bidrag från Paulo Scardine i bpo-11281.)

SMTP har nu stöd för kontexthanteringsprotokollet, vilket gör att en SMTP-instans kan användas i en with-sats. (Bidrag från Giampaolo Rodolà i bpo-11289.)

Konstruktorn SMTP_SSL och metoden starttls() accepterar nu en SSLContext-parameter för att kontrollera parametrarna för den säkra kanalen. (Bidrag från Kasun Herath i bpo-8809.)

kortplats

socketserver

BaseServer har nu en åsidosättbar metod service_actions() som anropas av metoden serve_forever() i serviceslingan. ForkingMixIn använder nu detta för att rensa upp zombiebarnprocesser. (Bidrag från Justin Warkentin i bpo-11109.)

sqlite3

Ny sqlite3.Connection-metod set_trace_callback() kan användas för att fånga en spårning av alla sql-kommandon som bearbetas av sqlite. (Bidrag från Torsten Landschoff i bpo-11688.)

ssl

  • Modulen ssl har två nya funktioner för slumpgenerering:

    • RAND_bytes(): genererar kryptografiskt starka pseudoslumpmässiga bytes.

    • RAND_pseudo_bytes(): generera pseudoslumpmässiga byte.

    (Bidrag från Victor Stinner i bpo-12049.)

  • Modulen ssl visar nu en mer finfördelad undantagshierarki för att göra det enklare att inspektera olika typer av fel. (Bidrag från Antoine Pitrou i bpo-11183.)

  • load_cert_chain() accepterar nu ett password-argument som ska användas om den privata nyckeln är krypterad. (Bidrag från Adam Simpkins i bpo-12803.)

  • Diffie-Hellman nyckelutbyte, både vanligt och Elliptic Curve-baserat, stöds nu genom metoderna load_dh_params() och set_ecdh_curve(). (Bidrag från Antoine Pitrou i bpo-13626 och bpo-13627.)

  • SSL-sockets har en ny get_channel_binding()-metod som gör det möjligt att implementera vissa autentiseringsmekanismer som SCRAM-SHA-1-PLUS. (Bidrag från Jacek Konieczny i bpo-12551.)

  • Du kan fråga vilken SSL-komprimeringsalgoritm som används av en SSL-socket tack vare den nya metoden compression(). Det nya attributet OP_NO_COMPRESSION kan användas för att inaktivera komprimering. (Bidrag från Antoine Pitrou i bpo-13634.)

  • Stöd har lagts till för tillägget Next Protocol Negotiation med hjälp av metoden ssl.SSLContext.set_npn_protocols(). (Bidrag från Colin Marc i bpo-14204.)

  • SSL-fel kan nu introspekteras lättare tack vare attributen library och reason. (Bidrag från Antoine Pitrou i bpo-14837.)

  • Funktionen get_server_certificate() har nu stöd för IPv6. (Bidrag från Charles-François Natali i bpo-11811.)

  • Nytt attribut OP_CIPHER_SERVER_PREFERENCE tillåter inställning av SSLv3-serveruttag för att använda serverns preferens för chifferordning snarare än klientens (bpo-13635).

stat

Den odokumenterade funktionen tarfile.filemode har flyttats till stat.filemode(). Den kan användas för att konvertera en fils läge till en sträng av formen ’-rwxrwxrwx’.

(Bidrag från Giampaolo Rodolà i bpo-14807.)

struktur

Modulen struct stöder nu ssize_t och size_t via de nya koderna n respektive N. (Bidrag från Antoine Pitrou i bpo-3163.)

delprocess

Kommandosträngar kan nu vara bytesobjekt på posix-plattformar. (Bidrag från Victor Stinner i bpo-8513.)

En ny konstant DEVNULL gör det möjligt att undertrycka utdata på ett plattformsoberoende sätt. (Bidrag från Ross Lagerwall i bpo-5870.)

system

Modulen sys har en ny thread_info named tuple som innehåller information om trådimplementationen (bpo-11223).

tarfil

tarfile stöder nu lzma-kodning via modulen lzma. (Bidrag från Lars Gustäbel i bpo-5689.)

tempfil

tempfile.SpooledTemporaryFile’s truncate() method accepterar nu en size parameter. (Bidrag från Ryan Kelly i bpo-9957.)

textbrytning

Modulen textwrap har fått en ny indent() som gör det enkelt att lägga till ett gemensamt prefix till markerade rader i ett textblock (bpo-13857).

gängning

threading.Condition, threading.Semaphore, threading.BoundedSemaphore, threading.Event, och threading.Timer, som alla tidigare var fabriksfunktioner som returnerade en klassinstans, är nu klasser och kan underklassas. (Bidrag från Éric Araujo i bpo-10968.)

Konstruktorn threading.Thread accepterar nu ett nyckelordsargument daemon för att åsidosätta standardbeteendet att ärva flaggvärdet daemon från den överordnade tråden (bpo-6064).

Den tidigare privata funktionen _thread.get_ident är nu tillgänglig som den publika funktionen threading.get_ident(). Detta eliminerar flera fall av direktåtkomst till _thread-modulen i stdlib. Tredjepartskod som använde _thread.get_ident bör också ändras för att använda det nya publika gränssnittet.

tid

Med PEP 418 lades nya funktioner till i modulen time:

  • get_clock_info(): Hämta information om en klocka.

  • monotonic(): Monotonisk klocka (kan inte gå bakåt), påverkas inte av uppdateringar av systemklockan.

  • perf_counter(): Prestandaräknare med högsta tillgängliga upplösning för att mäta en kort varaktighet.

  • process_time(): Summan av systemets och användarens CPU-tid för den aktuella processen.

Andra nya funktioner:

För att förbättra konsistensen mellan plattformar ger sleep() nu upphov till ett ValueError när ett negativt sömnvärde skickas. Tidigare var detta ett fel på posix, men producerade en oändlig sömn på Windows.

typer

Lägg till en ny types.MappingProxyType-klass: Skrivskyddad proxy för en mappning. (bpo-14386)

De nya funktionerna types.new_class() och types.prepare_class() ger stöd för dynamisk typskapning i enlighet med PEP 3115. (bpo-14588)

unittest

assertRaises(), assertRaisesRegex(), assertWarns() och assertWarnsRegex() accepterar nu ett nyckelordsargument msg när de används som kontexthanterare. (Bidrag från Ezio Melotti och Winston Ewert i bpo-10775.)

unittest.TestCase.run() returnerar nu TestResult-objektet.

urllib

Klassen Request accepterar nu ett method-argument som används av get_method() för att avgöra vilken HTTP-metod som ska användas. Till exempel kommer detta att skicka en 'HEAD' begäran:

>>> urlopen(Request('https://www.python.org', method='HEAD'))

(bpo-1673007)

webbläsare

Modulen webbrowser stöder fler ”webbläsare”: Google Chrome (med namnen chrome, chromium, chrome-browser eller chromium-browser beroende på version och operativsystem), och de generiska startprogrammen xdg-open, från FreeDesktop.org-projektet, och gvfs-open, som är standard URI-hanteraren för GNOME 3. (Det förstnämnda bidraget kommer från Arnaud Calmettes i bpo-13620, det sistnämnda från Matthias Klose i bpo-14493)

xml.etree.ElementTree

Modulen xml.etree.ElementTree importerar nu sin C-accelerator som standard; det finns inte längre något behov av att uttryckligen importera xml.etree.cElementTree (denna modul finns kvar för bakåtkompatibilitet, men är nu avskriven). Dessutom har iter-familjen av metoder i Element optimerats (omskrivna i C). Modulens dokumentation har också förbättrats avsevärt med fler exempel och en mer detaljerad referens.

zlib

Det nya attributet zlib.Decompress.eof gör det möjligt att skilja mellan en korrekt formad komprimerad ström och en ofullständig eller avkortad ström. (Bidrag från Nadeem Vawda i bpo-12646.)

Nytt attribut zlib.ZLIB_RUNTIME_VERSION rapporterar versionssträngen för det underliggande zlib-biblioteket som laddas vid körning. (Bidrag från Torsten Landschoff i bpo-12306.)

Optimeringar

Stora prestandaförbättringar har lagts till:

  • Tack vare PEP 393 har vissa operationer på Unicode-strängar optimerats:

    • minnesavtrycket delas med 2 till 4 beroende på texten

    • koda en ASCII-sträng till UTF-8 behöver inte koda tecken längre, UTF-8-representationen delas med ASCII-representationen

    • uTF-8-kodaren har optimerats

    • att upprepa en enda ASCII-bokstav och få en delsträng av en ASCII-sträng är 4 gånger snabbare

  • UTF-8 är nu 2x till 4x snabbare. UTF-16-kodning är nu upp till 10x snabbare.

    (Bidrag från Serhiy Storchaka, bpo-14624, bpo-14738 och bpo-15026.)

Ändringar i Build och C API

Ändringar i Pythons byggprocess och i C API inkluderar:

Föråldrat

Operativsystem som inte stöds

OS/2 och VMS stöds inte längre på grund av avsaknad av en underhållare.

Windows 2000 och Windows-plattformar som ställer in COMSPEC till command.com stöds inte längre på grund av underhållsbehov.

OSF-stödet, som inte längre var aktuellt i 3.2, har tagits bort helt.

Föråldrade Python-moduler, -funktioner och -metoder

Föråldrade funktioner och typer i C API

Py_UNICODE har blivit föråldrad av PEP 393 och kommer att tas bort i Python 4. Alla funktioner som använder denna typ är föråldrade:

Unicode-funktioner och -metoder som använder typerna Py_UNICODE och Py_UNICODE*:

Funktioner och makron som manipulerar Py_UNICODE*-strängar:

Kodare:

Föråldrade funktioner

Modulen array 'u' formatkod är nu föråldrad och kommer att tas bort i Python 4 tillsammans med resten av (Py_UNICODE) API.

Portning till Python 3.3

I det här avsnittet listas tidigare beskrivna ändringar och andra buggfixar som kan kräva ändringar i din kod.

Portning av Python-kod

  • Randomisering av hash är aktiverat som standard. Ställ in miljövariabeln PYTHONHASHSEED till 0 för att inaktivera hashslumpning. Se även metoden object.__hash__().

  • bpo-12326: På Linux innehåller sys.platform inte längre huvudversionen. Den är nu alltid ’linux’, istället för ’linux2’ eller ’linux3’ beroende på vilken Linux-version som används för att bygga Python. Ersätt sys.platform == ’linux2’ med sys.platform.startswith(’linux’), eller direkt sys.platform == ’linux’ om du inte behöver stödja äldre Python-versioner.

  • bpo-13847, bpo-14180: time och datetime: OverflowError visas nu istället för ValueError om en tidsmarkör är utanför intervallet. OSError visas nu om C-funktionerna gmtime() eller localtime() misslyckades.

  • De standardsökare som används av import använder nu en cache av vad som finns i en specifik katalog. Om du skapar en Python-källfil eller en bytecode-fil utan källa, se till att anropa importlib.invalidate_caches() för att rensa cacheminnet så att sökarna märker den nya filen.

  • ImportError använder nu det fullständiga namnet på modulen som man försökte importera. Doctests som kontrollerar ImportErrors meddelande måste uppdateras för att använda modulens fullständiga namn istället för bara svansen av namnet.

  • Argumentet index till __import__() har nu standardvärdet 0 istället för -1 och stöder inte längre negativa värden. Det var ett förbiseende när PEP 328 implementerades att standardvärdet förblev -1. Om du behöver fortsätta att utföra en relativ import följt av en absolut import, utför då den relativa importen med ett index på 1, följt av en annan import med ett index på 0. Det är dock att föredra att du använder importlib.import_module() snarare än att anropa __import__() direkt.

  • __import__() tillåter inte längre att man använder ett annat indexvärde än 0 för moduler på högsta nivån. T.ex. __import__('sys', level=1) är nu ett fel.

  • Eftersom sys.meta_path och sys.path_hooks nu har sökare som standard kommer du troligen att vilja använda list.insert() i stället för list.append() för att lägga till i dessa listor.

  • Eftersom None nu är infogad i sys.path_importer_cache, om du rensar ut poster i ordlistan över sökvägar som inte har en sökare, måste du ta bort nycklar som är parade med värden av None och imp.NullImporter för att vara bakåtkompatibel. Detta kommer att leda till extra overhead på äldre versioner av Python som återinför None i sys.path_importer_cache där det representerar användningen av implicita sökare, men semantiskt bör det inte ändra någonting.

  • importlib.abc.Finder anger inte längre en abstrakt metod find_module() som måste implementeras. Om du förlitade dig på att underklasser skulle implementera den metoden, se till att kontrollera att metoden finns först. Du kommer förmodligen att vilja kontrollera för find_loader() först, dock, i fallet med att arbeta med path entry finders.

  • pkgutil har konverterats till att använda importlib internt. Detta eliminerar många kantfall där det gamla beteendet hos PEP 302 import-emuleringen inte stämde överens med beteendet hos det riktiga importsystemet. Själva import-emuleringen finns fortfarande kvar, men är nu föråldrad. Funktionerna pkgutil.iter_importers() och pkgutil.walk_packages() är specialfall för standardimportkrokarna så de stöds fortfarande även om de inte tillhandahåller den icke-standardiserade metoden iter_modules().

  • Ett långvarigt fel i RFC-kompatibiliteten (bpo-1079) i parsningen som utförs av email.header.decode_header() har åtgärdats. Kod som använder standarduttrycket för att konvertera kodade rubriker till unicode (str(make_header(decode_header(h))) kommer inte att förändras, men kod som tittar på de enskilda tuplerna som returneras av decode_header kommer att se att blanksteg som föregår eller följer ASCII-sektioner nu ingår i ASCII-sektionen. Kod som bygger rubriker med make_header bör också fortsätta att fungera utan ändringar, eftersom make_header fortsätter att lägga till blanktecken mellan ASCII- och icke-ASCII-sektioner om de inte redan finns i indata-strängarna.

  • email.utils.formataddr() gör nu rätt innehållsöverföringskodning när den skickas till displaynamn som inte är ASCII. All kod som var beroende av det tidigare buggiga beteendet som bevarade unicode som inte var ASCII i den formaterade utdatasträngen måste ändras (bpo-1690608).

  • poplib.POP3.quit() kan nu orsaka protokollfel precis som alla andra poplib-metoder. Kod som antar att quit inte orsakar poplib.error_proto-fel kan behöva ändras om fel på quit uppstår i en viss applikation (bpo-11291).

  • Argumentet strict till email.parser.Parser, föråldrat sedan Python 2.4, har slutligen tagits bort.

  • Den föråldrade metoden unittest.TestCase.assertSameElements har tagits bort.

  • Den föråldrade variabeln time.accept2dyear har tagits bort.

  • Det föråldrade attributet Context._clamp har tagits bort från modulen decimal. Det ersattes tidigare av det publika attributet clamp. (Se bpo-8540.)

  • Den odokumenterade interna hjälpklassen SSLFakeFile har tagits bort från smtplib, eftersom dess funktionalitet sedan länge tillhandahålls direkt av socket.socket.makefile().

  • Att skicka ett negativt värde till time.sleep() på Windows ger nu upphov till ett fel istället för att sova för evigt. Det har alltid gett ett felmeddelande på posix.

  • Konstanten ast.__version__ har tagits bort. Om du behöver fatta beslut som påverkas av AST-versionen, använd sys.version_info för att fatta beslutet.

  • Kod som brukade kringgå det faktum att modulen threading använde fabriksfunktioner genom att underklassa de privata klasserna måste ändras till att underklassa de nu offentliga klasserna.

  • Det odokumenterade felsökningsmaskineriet i threading-modulen har tagits bort, vilket förenklar koden. Detta bör inte ha någon effekt på produktionskoden, men nämns här ifall något ramverk för felsökning av applikationer interagerar med den (bpo-13550).

Portning av C-kod

  • I samband med ändringar i buffert-API:et har den odokumenterade smalltable-medlemmen i Py_buffer-strukturen tagits bort och layouten för PyMemoryViewObject har ändrats.

    Alla tillägg som förlitar sig på de relevanta delarna i memoryobject.h eller object.h måste byggas om.

  • På grund av PEP 393, är typen Py_UNICODE och alla funktioner som använder denna typ föråldrade (men kommer att vara tillgängliga i minst fem år). Om du använder Unicode API:er på låg nivå för att konstruera och komma åt Unicode-objekt och du vill dra nytta av den minskning av minnesavtrycket som PEP 393 ger, måste du konvertera din kod till den nya Unicode API.

    Men om du bara har använt högnivåfunktioner som PyUnicode_Concat(), PyUnicode_Join() eller PyUnicode_FromFormat(), kommer din kod automatiskt att dra nytta av de nya unicode-representationerna.

  • PyImport_GetMagicNumber() returnerar nu -1 vid fel.

  • Eftersom ett negativt värde för level-argumentet till __import__() inte längre är giltigt, gäller nu samma sak för PyImport_ImportModuleLevel(). Detta innebär också att värdet för level som används av PyImport_ImportModuleEx() nu är 0 istället för -1.

Tillbyggnad av byggnad C

  • Utbudet av möjliga filnamn för C-tillägg har minskats. Mycket sällan använda stavningar har undertryckts: under POSIX erkänns inte längre filer med namnen xxxmodule.so, xxxmodule.abi3.so och xxxmodule.cpython-*.so som implementeringar av xxx-modulen. Om du har genererat sådana filer måste du byta till de andra stavningarna (dvs. ta bort strängen module från filnamnen).

    (implementerad i bpo-14040.)

Ändringar i kommandoradsväxeln

  • Kommandoradsflaggan -Q och relaterade artefakter har tagits bort. Kod som kontrollerar sys.flags.division_warning behöver uppdateras.

    (bpo-10998, bidrag från Éric Araujo.)

  • När python startas med -S, kommer import site inte längre att lägga till platsspecifika sökvägar till modulens sökvägar. I tidigare versioner gjorde den det.

    (bpo-11591, bidrag från Carl Meyer med redigering av Éric Araujo.)