Vad är nytt i Python 3.8

Redigerare:

Raymond Hettinger

I den här artikeln förklaras de nya funktionerna i Python 3.8 jämfört med 3.7. Python 3.8 släpptes den 14 oktober 2019. För fullständig information, se changelog.

Sammanfattning – Release highlights

Nya funktioner

Uppdragets uttryck

Det finns en ny syntax := som tilldelar värden till variabler som en del av ett större uttryck. Den är kärleksfullt känd som ”valrossoperatorn” på grund av dess likhet med ögon och betar hos en valross.

I det här exemplet hjälper assignment-uttrycket till att undvika att anropa len() två gånger:

if (n := len(a)) > 10:
    print(f"Listan är för lång ({n} element, förväntat <= 10)")

En liknande fördel uppstår vid matchning med reguljära uttryck där matchningsobjekt behövs två gånger, en gång för att testa om en matchning inträffade och en annan gång för att extrahera en undergrupp:

rabatt = 0,0
if (mo := re.search(r'(\d+)% discount', annons)):
    rabatt = float(mo.grupp(1)) / 100,0

Operatorn är också användbar med while-loopar som beräknar ett värde för att testa loopens avslutning och sedan behöver samma värde igen i loopens kropp:

# Loopa över block med fast längd
while (block := f.read(256)) != '':
    process(block)

Ett annat motiverande användningsfall uppstår i listförståelser där ett värde som beräknats i ett filtreringsvillkor också behövs i uttryckskroppen:

[clean_name.title() för namn i namn
 if (clean_name := normalize('NFC', name)) in tillåtna_namn]

Försök att begränsa användningen av valrossoperatorn till rena fall som minskar komplexiteten och förbättrar läsbarheten.

Se PEP 572 för en fullständig beskrivning.

(Bidrag från Emily Morehouse i bpo-35224.)

Parametrar som endast är positionsbestämda

Det finns en ny syntax för funktionsparametrar / för att ange att vissa funktionsparametrar måste anges positionellt och inte kan användas som nyckelordsargument. Detta är samma notation som visas av help() för C-funktioner som är annoterade med Larry Hastings verktyg Argument Clinic.

I följande exempel är parametrarna a och b endast positionella, medan c eller d kan vara positionella eller nyckelord, och e eller f måste vara nyckelord:

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)

Följande är ett giltigt anrop:

f(10, 20, 30, d=40, e=50, f=60)

Dessa är dock ogiltiga samtal:

f(10, b=20, c=30, d=40, e=50, f=60) # b kan inte vara ett nyckelordsargument
f(10, 20, 30, 40, 50, f=60) # e måste vara ett nyckelordsargument

Ett användningsområde för denna notation är att den gör det möjligt för rena Python-funktioner att helt emulera beteenden hos befintliga C-kodade funktioner. Till exempel accepterar den inbyggda divmod()-funktionen inte nyckelordsargument:

def divmod(a, b, /):
    "Emulera den inbyggda divmod()-funktionen"
    return (a // b, a % b)

Ett annat användningsfall är att utesluta nyckelordsargument när parameternamnet inte är till hjälp. Till exempel har den inbyggda funktionen len() signaturen len(obj, /). Detta utesluter besvärliga anrop som:

len(obj='hello') # Nyckelordsargumentet "obj" försämrar läsbarheten

En ytterligare fördel med att markera en parameter som endast positionell är att det gör det möjligt att ändra parameternamnet i framtiden utan att riskera att bryta klientkoden. I modulen statistics kan t.ex. parameternamnet dist ändras i framtiden. Detta möjliggjordes med följande funktionsspecifikation:

def quantiles(dist, /, *, n=4, method='exclusive')
    ...

Eftersom parametrarna till vänster om / inte exponeras som möjliga nyckelord, förblir parameternamnen tillgängliga för användning i **kwargs:

>>> def f(a, b, /, **kwargs):
...     print(a, b, kwargs)
...
>>> f(10, 20, a=1, b=2, c=3)         # a and b are used in two ways
10 20 {'a': 1, 'b': 2, 'c': 3}

Detta förenklar avsevärt implementeringen av funktioner och metoder som behöver acceptera godtyckliga nyckelordsargument. Här är till exempel ett utdrag ur koden i modulen collections:

klass Räknare(dict):

    def __init__(self, iterable=None, /, **kwds):
        # Notera att "iterable" är ett möjligt nyckelordsargument

Se PEP 570 för en fullständig beskrivning.

(Bidrag från Pablo Galindo i bpo-36540.)

Parallell filsystemcache för kompilerade bytecode-filer

Den nya inställningen PYTHONPYCACHEPREFIX (även tillgänglig som -X pycache_prefix) konfigurerar den implicita bytecode-cachen att använda ett separat parallellt filsystemträd, i stället för standardunderkatalogerna __pycache__ i varje källkatalog.

Cachens plats rapporteras i sys.pycache_prefix (None anger standardplatsen i underkatalogerna __pycache__).

(Bidrag från Carl Meyer i bpo-33499.)

Debug build använder samma ABI som release build

Python använder nu samma ABI oavsett om det byggs i release- eller debug-läge. På Unix, när Python byggs i felsökningsläge, är det nu möjligt att läsa in C-tillägg som byggts i release-läge och C-tillägg som byggts med det stabila ABI:t.

Release builds och debug builds är nu ABI-kompatibla: att definiera makrot Py_DEBUG innebär inte längre makrot Py_TRACE_REFS, vilket introducerar den enda ABI-inkompatibiliteten. Makrot Py_TRACE_REFS, som lägger till funktionen sys.getobjects() och miljövariabeln PYTHONDUMPREFS, kan ställas in med det nya byggalternativet ./configure --with-trace-refs. (Bidrag från Victor Stinner i bpo-36465.)

På Unix är C-tillägg inte längre länkade till libpython, förutom på Android och Cygwin. Det är nu möjligt för en statiskt länkad Python att läsa in ett C-tillägg som byggts med hjälp av ett delat Python-bibliotek. (Bidrag från Victor Stinner i bpo-21536.)

På Unix, när Python byggs i felsökningsläge, letar import nu även efter C-tillägg som kompilerats i release-läge och efter C-tillägg som kompilerats med det stabila ABI. (Bidrag från Victor Stinner i bpo-36722.)

För att bädda in Python i ett program måste ett nytt alternativ --embed skickas till python3-config --libs --embed för att få -lpython3.8 (länka programmet till libpython). För att stödja både 3.8 och äldre, prova python3-config --libs --embed först och fallbacka till python3-config --libs (utan --embed) om det föregående kommandot misslyckas.

Lägg till en pkg-config-modul python-3.8-embed för att bädda in Python i ett program: pkg-config python-3.8-embed --libs inkluderar -lpython3.8. För att stödja både 3.8 och äldre, prova pkg-config python-X.Y-embed --libs först och fallbacka till pkg-config python-X.Y --libs (utan --embed) om det föregående kommandot misslyckas (ersätt X.Y med Python-versionen).

Å andra sidan innehåller pkg-config python3.8 --libs inte längre -lpython3.8. C-tillägg får inte länkas till libpython (utom på Android och Cygwin, vars fall hanteras av skriptet); denna ändring är avsiktligt bakåtkompatibel. (Bidrag från Victor Stinner i bpo-36721.)

f-strings stödjer = för självdokumenterande uttryck och felsökning

Lade till en =-specifikator till f-strings. En f-sträng som f'{expr=}' kommer att expandera till uttryckets text, ett likhetstecken och sedan representationen av det utvärderade uttrycket. Ett exempel:

>>> user = 'eric_idle'
>>> member_since = date(1975, 7, 31)
>>> f'{user=} {member_since=}'
"user='eric_idle' member_since=datetime.date(1975, 7, 31)"

De vanliga f-string-formatspecifikationerna ger mer kontroll över hur resultatet av uttrycket visas:

>>> delta = date.today() - member_since
>>> f'{user=!s}  {delta.days=:,d}'
'user=eric_idle  delta.days=16,075'

Specificeraren = visar hela uttrycket så att beräkningar kan visas:

>>> print(f'{theta=}  {cos(radians(theta))=:.3f}')
theta=30  cos(radians(theta))=0.866

(Bidrag från Eric V. Smith och Larry Hastings i bpo-36817.)

PEP 578: Python Runtime Audit Hooks

PEP:n lägger till en Audit Hook och Verified Open Hook. Båda är tillgängliga från Python och inbyggd kod, vilket gör att applikationer och ramverk skrivna i ren Python-kod kan dra nytta av extra meddelanden, samtidigt som inbäddare eller systemadministratörer kan distribuera Python-byggnader där granskning alltid är aktiverad.

Se PEP 578 för fullständig information.

PEP 587: Konfiguration av Python-initialisering

PEP 587 lägger till ett nytt C API för att konfigurera Python Initialization, vilket ger finare kontroll över hela konfigurationen och bättre felrapportering.

Nya strukturer:

Nya funktioner:

Denna PEP lägger också till _PyRuntimeState.preconfig (PyPreConfig type) och PyInterpreterState.config (PyConfig type) fält till dessa interna strukturer. PyInterpreterState.config blir den nya referenskonfigurationen och ersätter globala konfigurationsvariabler och andra privata variabler.

Se Python Initialization Configuration för dokumentation.

Se PEP 587 för en fullständig beskrivning.

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

PEP 590: Vectorcall: ett snabbt anropsprotokoll för CPython

Vectorcall-protokollet har lagts till i Python/C API. Det är tänkt att formalisera befintliga optimeringar som redan gjorts för olika klasser. Alla static type som implementerar en callable kan använda detta protokoll.

Detta är för närvarande provisoriskt. Målet är att göra det helt offentligt i Python 3.9.

Se PEP 590 för en fullständig beskrivning.

(Bidrag från Jeroen Demeyer, Mark Shannon och Petr Viktorin i bpo-36974.)

Pickle-protokoll 5 med buffertar för data utanför bandet

När pickle används för att överföra stora datamängder mellan Python-processer för att dra nytta av bearbetning med flera kärnor eller maskiner är det viktigt att optimera överföringen genom att minska antalet minneskopior och eventuellt tillämpa anpassade tekniker som databeroende komprimering.

Protokollet pickle 5 introducerar stöd för out-of-band buffertar där PEP 3118-kompatibla data kan överföras separat från huvudflödet av pickle, efter kommunikationslagrets gottfinnande.

Se PEP 574 för en fullständig beskrivning.

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

Andra språkliga förändringar

  • En continue-sats var olaglig i finally-satsen på grund av ett problem med implementeringen. I Python 3.8 togs denna begränsning bort. (Bidrag från Serhiy Storchaka i bpo-32489.)

  • Typerna bool, int, och fractions.Fraction har nu en as_integer_ratio()-metod som den som finns i float och decimal.Decimal. Detta mindre API-tillägg gör det möjligt att skriva numerator, denominator = x.as_integer_ratio() och få det att fungera över flera numeriska typer. (Bidrag från Lisa Roach i bpo-33073 och Raymond Hettinger i bpo-37819.)

  • Konstruktörer av int, float och complex kommer nu att använda specialmetoden __index__(), om den är tillgänglig och motsvarande metod __int__(), __float__() eller __complex__() inte är tillgänglig. (Bidrag från Serhiy Storchaka i bpo-20092.)

  • Lagt till stöd för \N{name} escapes i regular expressions:

    >>> notice = 'Copyright © 2019'
    >>> copyright_year_pattern = re.compile(r'\N{copyright sign}\s*(\d{4})')
    >>> int(copyright_year_pattern.search(notice).group(1))
    2019
    

    (Bidrag från Jonathan Eunice och Serhiy Storchaka i bpo-30688.)

  • Dict och dictviews är nu itererbara i omvänd inmatningsordning med reversed(). (Bidrag från Rémi Lapeyre i bpo-33462.)

  • Den syntax som tillåts för nyckelordsnamn i funktionsanrop har begränsats ytterligare. I synnerhet är f((nyckelord)=arg) inte längre tillåtet. Det var aldrig meningen att tillåta mer än ett namn på vänstersidan av ett nyckelords argumenttilldelningsterm. (Bidrag från Benjamin Peterson i bpo-34641.)

  • Generaliserad iterabeluppackning i yield- och return-satser kräver inte längre omslutande parenteser. Detta gör att syntaxen för yield och return stämmer bättre överens med normal syntax för tilldelningar:

    >>> def parse(family):
    ...     lastname, *members = family.split()
    ...     return lastname.upper(), *members
    ...
    >>> parse('simpsons homer marge bart lisa maggie')
    ('SIMPSONS', 'homer', 'marge', 'bart', 'lisa', 'maggie')
    

    (Bidrag från David Cuthbert och Jordan Chapman i bpo-32117.)

  • När ett kommatecken missas i kod som [(10, 20) (30, 40)], visar kompilatorn en SyntaxWarning med ett användbart förslag. Detta är en förbättring jämfört med att bara ha en TypeError som indikerar att den första tupeln inte var anropsbar. (Bidrag från Serhiy Storchaka i bpo-15248.)

  • Aritmetiska operationer mellan underklasser av datetime.date eller datetime.datetime och datetime.timedelta-objekt returnerar nu en instans av underklassen, snarare än basklassen. Detta påverkar också returtypen för operationer vars implementering (direkt eller indirekt) använder datetime.timedelta-aritmetik, till exempel astimezone(). (Bidrag från Paul Ganssle i bpo-32417.)

  • När Python-tolken avbryts av Ctrl-C (SIGINT) och det resulterande KeyboardInterrupt-undantaget inte fångas upp, avslutas Python-processen nu via en SIGINT-signal eller med rätt utgångskod så att den anropande processen kan upptäcka att den dog på grund av ett Ctrl-C. Skal på POSIX och Windows använder detta för att avsluta skript i interaktiva sessioner på rätt sätt. (Bidrag från Google via Gregory P. Smith i bpo-1054041.)

  • Vissa avancerade programmeringsstilar kräver uppdatering av types.CodeType-objektet för en befintlig funktion. Eftersom kodobjekt är oföränderliga måste ett nytt kodobjekt skapas, ett som är modellerat på det befintliga kodobjektet. Med 19 parametrar var detta något tråkigt. Nu gör den nya metoden replace() det möjligt att skapa en klon med några få ändrade parametrar.

    Här är ett exempel som ändrar funktionen statistics.mean() för att förhindra att parametern data används som ett nyckelordsargument:

    >>> from statistics import mean
    >>> mean(data=[10, 20, 90])
    40
    >>> mean.__code__ = mean.__code__.replace(co_posonlyargcount=1)
    >>> mean(data=[10, 20, 90])
    Traceback (most recent call last):
      ...
    TypeError: mean() got some positional-only arguments passed as keyword arguments: 'data'
    

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

  • För heltal tillåter nu pow()-funktionens treargumentform att exponenten är negativ i de fall där basen är relativt prim till modulus. Den beräknar sedan en modulär invers till basen när exponenten är -1, och en lämplig potens av denna invers för andra negativa exponenter. För att till exempel beräkna den modulära multiplikativa inversen av 38 modulo 137, skriv:

    >>> pow(38, -1, 137)
    119
    >>> 119 * 38 % 137
    1
    

    Modulära inverser förekommer vid lösning av linjära diofantiska ekvationer. Till exempel, för att hitta heltalslösningar för 4258𝑥 + 147𝑦 = 369, skriv först om till 4258𝑥 369 (mod 147) och lös sedan:

    >>> x = 369 * pow(4258, -1, 147) % 147
    >>> y = (4258 * x - 369) // -147
    >>> 4258 * x + 147 * y
    369
    

    (Bidrag från Mark Dickinson i bpo-36027.)

  • Dict-komprehensioner har synkroniserats med dict-litteraler så att nyckeln beräknas först och värdet sedan:

    >>> # Dict comprehension
    >>> cast = {input('role? '): input('actor? ') for i in range(2)}
    role? King Arthur
    actor? Chapman
    role? Black Knight
    actor? Cleese
    
    >>> # Dict literal
    >>> cast = {input('role? '): input('actor? ')}
    role? Sir Robin
    actor? Eric Idle
    

    Den garanterade exekveringsordningen är användbar med tilldelningsuttryck eftersom variabler som tilldelats i nyckeluttrycket kommer att vara tillgängliga i värdeuttrycket:

    >>> names = ['Martin von Löwis', 'Łukasz Langa', 'Walter Dörwald']
    >>> {(n := normalize('NFC', name)).casefold() : n for name in names}
    {'martin von löwis': 'Martin von Löwis',
     'łukasz langa': 'Łukasz Langa',
     'walter dörwald': 'Walter Dörwald'}
    

    (Bidrag från Jörn Heissler i bpo-35224.)

  • Metoden object.__reduce__() kan nu returnera en tupel som är mellan två och sex element lång. Tidigare var fem gränsen. Det nya, valfria sjätte elementet är en callable med signaturen (obj, state). Detta möjliggör direkt kontroll över tillståndsuppdateringsbeteendet för ett specifikt objekt. Om inte None, kommer denna callable att ha prioritet över objektets __setstate__()-metod. (Bidrag från Pierre Glaser och Olivier Grisel i bpo-35900.)

Nya moduler

  • Den nya importlib.metadata-modulen ger (provisoriskt) stöd för att läsa metadata från tredjepartspaket. Den kan till exempel extrahera ett installerat pakets versionsnummer, lista över ingångspunkter med mera:

    >>> # Note following example requires that the popular "requests"
    >>> # package has been installed.
    >>>
    >>> from importlib.metadata import version, requires, files
    >>> version('requests')
    '2.22.0'
    >>> list(requires('requests'))
    ['chardet (<3.1.0,>=3.0.2)']
    >>> list(files('requests'))[:5]
    [PackagePath('requests-2.22.0.dist-info/INSTALLER'),
     PackagePath('requests-2.22.0.dist-info/LICENSE'),
     PackagePath('requests-2.22.0.dist-info/METADATA'),
     PackagePath('requests-2.22.0.dist-info/RECORD'),
     PackagePath('requests-2.22.0.dist-info/WHEEL')]
    

    (Bidrag från Barry Warsaw och Jason R. Coombs i bpo-34632.)

Förbättrade moduler

ast

AST-noder har nu attributen end_lineno och end_col_offset, som anger den exakta platsen för nodens slut. (Detta gäller endast för noder som har attributen lineno och col_offset)

Ny funktion ast.get_source_segment() returnerar källkoden för en specifik AST-nod.

(Bidrag från Ivan Levkivskyi i bpo-33416.)

Funktionen ast.parse() har fått några nya flaggor:

  • type_comments=True gör att den returnerar texten i kommentarer av typen PEP 484 och PEP 526 som är associerade med vissa AST-noder;

  • mode='func_type' kan användas för att analysera PEP 484 ”signature type comments” (returneras för funktionsdefinition AST-noder);

  • feature_version=(3, N) gör det möjligt att ange en tidigare Python 3-version. Till exempel, feature_version=(3, 4) kommer att behandla async och await som icke-reserverade ord.

(Bidrag från Guido van Rossum i bpo-35766.)

asyncio

asyncio.run() har gått från provisional till stable API. Denna funktion kan användas för att exekvera en coroutine och returnera resultatet samtidigt som händelseslingan hanteras automatiskt. Till exempel:

import asyncio

async def main():
    await asyncio.sleep(0)
    return 42

asyncio.run(main())

Detta är helt likvärdigt med:

import asyncio

async def main():
    await asyncio.sleep(0)
    return 42

loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
try:
    loop.run_until_complete(main())
finally:
    asyncio.set_event_loop(None)
    loop.close()

Den faktiska implementationen är betydligt mer komplex. Därför bör asyncio.run() vara det föredragna sättet att köra asyncioprogram.

(Bidrag från Yury Selivanov i bpo-32314.)

Genom att köra python -m asyncio startas en inbyggd asynkron REPL. Detta möjliggör snabba experiment med kod som har en toppnivå await. Det finns inte längre något behov av att direkt anropa asyncio.run() vilket skulle skapa en ny händelseslinga vid varje anrop:

$ python -m asyncio
asyncio REPL 3.8.0
Use "await" directly instead of "asyncio.run()".
Type "help", "copyright", "credits" or "license" for more information.
>>> import asyncio
>>> await asyncio.sleep(10, result='hello')
hello

(Bidrag från Yury Selivanov i bpo-37028.)

Undantaget asyncio.CancelledError ärver nu från BaseException snarare än Exception och ärver inte längre från concurrent.futures.CancelledError. (Bidrag från Yury Selivanov i bpo-32528.)

I Windows är standardhändelseslingan nu ProactorEventLoop. (Bidrag från Victor Stinner i bpo-34687.)

ProactorEventLoop stöder nu även UDP. (Bidrag från Adam Meily och Andrew Svetlov i bpo-29883.)

ProactorEventLoop kan nu avbrytas med KeyboardInterrupt (”CTRL+C”). (Bidrag från Vladimir Matveev i bpo-23057.)

Lagt till asyncio.Task.get_coro() för att hämta den omslutna coroutinen inom en asyncio.Task. (Bidrag från Alex Grönholm i bpo-36999.)

Asyncio-uppgifter kan nu namnges, antingen genom att skicka nyckelordsargumentet name till asyncio.create_task() eller create_task() event loop-metoden, eller genom att anropa set_name()-metoden på uppgiftsobjektet. Uppgiftsnamnet är synligt i repr()-utdata från asyncio.Task och kan också hämtas med metoden get_name(). (Bidrag från Alex Grönholm i bpo-34270.)

Stöd för Happy Eyeballs har lagts till i asyncio.loop.create_connection(). För att specificera beteendet har två nya parametrar lagts till: happy_eyeballs_delay och interleave. Happy Eyeballs-algoritmen förbättrar responsen i applikationer som stöder IPv4 och IPv6 genom att försöka ansluta samtidigt med båda. (Bidrag från twisteroid-ambassadören i bpo-33530.)

inbyggda

Den inbyggda compile() har förbättrats för att acceptera ast.PyCF_ALLOW_TOP_LEVEL_AWAIT flaggan. Med denna nya flagga godkänd, kommer compile() att tillåta toppnivå await, async for och async with konstruktioner som vanligtvis anses vara ogiltig syntax. Asynkrona kodobjekt markerade med flaggan CO_COROUTINE kan då returneras. (Bidrag från Matthias Bussonnier i bpo-34616)

samlingar

Metoden _asdict() för collections.namedtuple() returnerar nu en dict istället för en collections.OrderedDict. Detta fungerar eftersom vanliga dicts har garanterad ordning sedan Python 3.7. Om de extra funktionerna i OrderedDict krävs, är den föreslagna lösningen att kasta resultatet till önskad typ: OrderedDict(nt._asdict()). (Bidrag från Raymond Hettinger i bpo-35864.)

cProfil

Klassen cProfile.Profile kan nu användas som en kontexthanterare. Profilera ett kodblock genom att köra:

import cProfile

med cProfile.Profile() som profilerare:
      # kod som ska profileras
      ...

(Bidrag från Scott Sanderson i bpo-29235.)

csv

csv.DictReader returnerar nu instanser av dict istället för en collections.OrderedDict. Verktyget är nu snabbare och använder mindre minne samtidigt som fältordningen bevaras. (Bidrag från Michael Selik i bpo-34003.)

curses

En ny variabel har lagts till som innehåller strukturerad versionsinformation för det underliggande ncurses-biblioteket: ncurses_version. (Bidrag från Serhiy Storchaka i bpo-31680.)

ctyper

I Windows accepterar nu CDLL och underklasser en winmode-parameter för att ange flaggor för det underliggande LoadLibraryEx-anropet. Standardflaggorna är inställda på att endast ladda DLL-beroenden från betrodda platser, inklusive sökvägen där DLL:en är lagrad (om en fullständig eller partiell sökväg används för att ladda den ursprungliga DLL:en) och sökvägar som lagts till av add_dll_directory(). (Bidrag från Steve Dower i bpo-36085.)

datatid

Lagt till nya alternativa konstruktörer datetime.date.fromisocalendar() och datetime.datetime.fromisocalendar(), som konstruerar date och datetime-objekt från ISO-år, veckonummer respektive veckodag; dessa är inversen av varje klass isocalendar-metod. (Bidrag från Paul Ganssle i bpo-36004.)

functools

functools.lru_cache() kan nu användas som en direkt dekorator snarare än som en funktion som returnerar en dekorator. Så båda dessa stöds nu:

@lru_cache
def f(x):
    ...

@lru_cache(maxstorlek=256)
def f(x):
    ...

(Bidrag från Raymond Hettinger i bpo-36772.)

Lagt till en ny functools.cached_property()-dekorator, för beräknade egenskaper som cachas under instansens livstid.

import functools
import statistics

class Dataset:
   def __init__(self, sequence_of_numbers):
      self.data = sequence_of_numbers

   @functools.cached_property
   def variance(self):
      return statistics.variance(self.data)

(Bidrag från Carl Meyer i bpo-21145)

Lagt till en ny functools.singledispatchmethod()-dekorator som konverterar metoder till generiska funktioner med single dispatch:

from functools import singledispatchmethod
from contextlib import suppress

class TaskManager:

    def __init__(self, tasks):
        self.tasks = list(tasks)

    @singledispatchmethod
    def discard(self, value):
        with suppress(ValueError):
            self.tasks.remove(value)

    @discard.register(list)
    def _(self, tasks):
        targets = set(tasks)
        self.tasks = [x for x in self.tasks if x not in targets]

(Bidrag från Ethan Smith i bpo-32380)

gc

get_objects() kan nu ta emot en valfri generation parameter som anger en generation att hämta objekt från. (Bidrag från Pablo Galindo i bpo-36016.)

gettext

Lagt till pgettext() och dess varianter. (Bidrag från Franz Glasner, Éric Araujo och Cheryl Sabella i bpo-2504.)

gzip

Lade till parametern mtime i gzip.compress() för reproducerbar utdata. (Bidrag från Guo Ci Teo i bpo-34898.)

Ett BadGzipFile-undantag tas nu upp istället för OSError för vissa typer av ogiltiga eller korrupta gzip-filer. (Bidrag från Filip Gruszczyński, Michele Orrù och Zackery Spytz i bpo-6584.)

IDLE och idlelib

Utdata över N rader (50 som standard) pressas ner till en knapp. N kan ändras i avsnittet PyShell på sidan Allmänt i dialogrutan Inställningar. Färre, men eventuellt extra långa, rader kan pressas genom att högerklicka på utmatningen. Pressad utdata kan expanderas på plats genom att dubbelklicka på knappen eller till urklippet eller ett separat fönster genom att högerklicka på knappen. (Bidrag från Tal Einat i bpo-1529353.)

Lägg till ”Run Customized” i Run-menyn för att köra en modul med anpassade inställningar. Alla kommandoradsargument som anges läggs till i sys.argv. De visas också igen i rutan för nästa anpassade körning. Man kan också undertrycka den normala omstarten av Shell-huvudmodulen. (Bidrag från Cheryl Sabella, Terry Jan Reedy och andra i bpo-5680 och bpo-37627.)

Valfria radnummer för IDLE-redigeringsfönster har lagts till. Fönster öppnas utan radnummer om inget annat anges på fliken Allmänt i konfigurationsdialogrutan. Radnummer för ett befintligt fönster visas och döljs i menyn Alternativ. (Bidrag från Tal Einat och Saimadhav Heblikar i bpo-17535.)

Nu används OS:s inbyggda kodning för konvertering mellan Python-strängar och Tcl-objekt. Detta gör att IDLE kan arbeta med emoji och andra icke-BMP-tecken. Dessa tecken kan visas eller kopieras och klistras in till eller från urklippet. Konvertering av strängar från Tcl till Python och tillbaka misslyckas nu aldrig. (Många människor arbetade med detta i åtta år men problemet löstes slutligen av Serhiy Storchaka i bpo-13153)

Nytt i 3.8.1:

Lägg till alternativ för att stänga av markörens blinkning. (Bidrag från Zackery Spytz i bpo-4603.)

Escape-tangenten stänger nu IDLE-avslutningsfönster. (Bidrag från Johnny Najera i bpo-38944.)

Ändringarna ovan har backporterats till underhållsversionerna av 3.7.

Lägg till nyckelord i listan för komplettering av modulnamn. (Bidrag från Terry J. Reedy i bpo-37765.)

inspektera

Funktionen inspect.getdoc() kan nu hitta dokumentationssträngar för __slots__ om attributet är en dict där värdena är dokumentationssträngar. Detta ger dokumentationsalternativ liknande de som vi redan har för property(), classmethod() och staticmethod():

klass AudioClip:
    __slots__ = {'bit_rate': 'uttryckt i kilohertz med en decimal',
                 "duration": "i sekunder, avrundat uppåt till ett heltal"}
    def __init__(self, bit_rate, duration):
        self.bit_rate = round(bit_rate / 1000,0, 1)
        self.duration = ceil(duration)

(Bidrag från Raymond Hettinger i bpo-36326.)

io

I utvecklingsläge (-X env) och i debug build, loggar nu io.IOBase finalizer undantaget om metoden close() misslyckas. Undantaget ignoreras tyst som standard i release-versionen. (Bidrag från Victor Stinner i bpo-18748.)

itertools

Funktionen itertools.accumulate() lade till ett alternativ initial nyckelordsargument för att ange ett initialt värde:

>>> from itertools import accumulate
>>> list(accumulate([10, 5, 30, 15], initial=1000))
[1000, 1010, 1015, 1045, 1060]

(Bidrag från Lisa Roach i bpo-34659.)

json.verktyg

Lägg till alternativet --json-lines för att analysera varje inmatningsrad som ett separat JSON-objekt. (Bidrag från Weipeng Hong i bpo-31553.)

loggning

Lade till ett force nyckelordsargument till logging.basicConfig(). När det är satt till true tas alla befintliga hanterare som är kopplade till rotloggaren bort och stängs innan konfigurationen som anges av de andra argumenten utförs.

Detta löser ett långvarigt problem. När en logger eller basicConfig() hade anropats, ignorerades efterföljande anrop till basicConfig() i tysthet. Detta gjorde det svårt att uppdatera, experimentera med eller lära ut de olika konfigurationsalternativen för loggning med hjälp av den interaktiva prompten eller en Jupyter-anteckningsbok.

(Föreslagen av Raymond Hettinger, implementerad av Donghee Na, och granskad av Vinay Sajip i bpo-33897.)

matematik

Lagt till ny funktion math.dist() för beräkning av Euclidean-avstånd mellan två punkter. (Bidrag från Raymond Hettinger i bpo-33089.)

Funktionen math.hypot() har utökats för att hantera flera dimensioner. Tidigare stödde den endast 2D-fallet. (Bidrag från Raymond Hettinger i bpo-33089.)

Lagt till en ny funktion, math.prod(), som en analog funktion till sum() som returnerar produkten av ett startvärde (standard: 1) gånger en iterabel av tal:

>>> prior = 0.8
>>> likelihoods = [0.625, 0.84, 0.30]
>>> math.prod(likelihoods, start=prior)
0.126

(Bidrag från Pablo Galindo i bpo-35606.)

Lade till två nya kombinatoriska funktioner math.perm() och math.comb():

>>> math.perm(10, 3)    # Permutations of 10 things taken 3 at a time
720
>>> math.comb(10, 3)    # Combinations of 10 things taken 3 at a time
120

(Bidrag från Yash Aggarwal, Keller Fuchs, Serhiy Storchaka och Raymond Hettinger i bpo-37128, bpo-37178 och bpo-35431.)

Lagt till en ny funktion math.isqrt() för att beräkna exakta kvadratrötter för heltal utan konvertering till flyttal. Den nya funktionen stöder godtyckligt stora heltal. Den är snabbare än floor(sqrt(n)) men långsammare än math.sqrt():

>>> r = 650320427
>>> s = r ** 2
>>> isqrt(s - 1)         # correct
650320426
>>> floor(sqrt(s - 1))   # incorrect
650320427

(Bidrag från Mark Dickinson i bpo-36887.)

Funktionen math.factorial() accepterar inte längre argument som inte är int-liknande. (Bidrag från Pablo Galindo i bpo-33083.)

mmap

Klassen mmap.mmap har nu en madvise()-metod för att komma åt systemanropet madvise(). (Bidrag från Zackery Spytz i bpo-32941.)

multiprocessing

Lagt till ny multiprocessing.shared_memory modul. (Bidrag från Davin Potts i bpo-35813.)

På macOS används nu startmetoden spawn som standard. (Bidrag från Victor Stinner i bpo-33725.)

os

Lagt till ny funktion add_dll_directory() på Windows för att tillhandahålla ytterligare sökvägar för inbyggda beroenden vid import av tilläggsmoduler eller laddning av DLL:er med ctypes. (Bidrag från Steve Dower i bpo-36085.)

En ny os.memfd_create()-funktion lades till för att omsluta syscallen memfd_create(). (Bidrag från Zackery Spytz och Christian Heimes i bpo-26836.)

I Windows har en stor del av den manuella logiken för hantering av reparse-punkter (inklusive symlinks och directory junctions) delegerats till operativsystemet. Specifikt kommer os.stat() nu att korsa allt som stöds av operativsystemet, medan os.lstat() endast kommer att öppna reparse-punkter som identifieras som ”namnsurrogat” medan andra öppnas som för os.stat(). I samtliga fall kommer stat_result.st_mode endast att ha S_IFLNK inställt för symboliska länkar och inte för andra typer av reparse-punkter. För att identifiera andra typer av reparse-punkter, kontrollera det nya attributet stat_result.st_reparse_tag.

I Windows kan os.readlink() nu läsa katalogförgreningar. Observera att islink() kommer att returnera False för katalogförgreningar, så kod som kontrollerar islink först kommer att fortsätta att behandla förgreningar som kataloger, medan kod som hanterar fel från os.readlink() nu kan behandla förgreningar som länkar.

(Bidrag från Steve Dower i bpo-37834.)

os.path

os.path funktioner som returnerar ett booleskt resultat som exists(), lexists(), isdir(), isfile(), islink(), och ismount() returnerar nu False istället för att ge upphov till ValueError eller dess underklasser UnicodeEncodeError och UnicodeDecodeError för sökvägar som innehåller tecken eller byte som inte kan representeras på OS-nivå. (Bidrag från Serhiy Storchaka i bpo-33721.)

expanduser() på Windows föredrar nu miljövariabeln USERPROFILE och använder inte HOME, som normalt inte är inställd för vanliga användarkonton. (Bidrag från Anthony Sottile i bpo-36264.)

isdir() på Windows returnerar inte längre True för en länk till en icke-existerande katalog.

realpath() på Windows löser nu reparse-punkter, inklusive symlinks och directory junctions.

(Bidrag från Steve Dower i bpo-37834.)

pathlib

pathlib.Path-metoder som returnerar ett booleskt resultat som exists(), is_dir(), is_file(), is_mount(), is_symlink(), is_block_device(), is_char_device(), is_fifo(), is_socket() returnerar nu False istället för att ge upphov till ValueError eller dess underklass UnicodeEncodeError för sökvägar som innehåller tecken som inte kan representeras på OS-nivå. (Bidrag från Serhiy Storchaka i bpo-33721.)

Lagt till pathlib.Path.link_to() som skapar en hård länk som pekar på en sökväg. (Bidrag från Joannah Nanjekye i bpo-26978) Observera att link_to utrangerades i 3.10 och togs bort i 3.12 till förmån för en hardlink_to-metod som lades till i 3.10 och som matchar semantiken i den befintliga symlink_to-metoden.

pickle

pickle-tillägg som underklassar den C-optimerade Pickler kan nu åsidosätta pickling-logiken för funktioner och klasser genom att definiera den speciella reducer_override()-metoden. (Bidrag från Pierre Glaser och Olivier Grisel i bpo-35900.)

plistlib

Lade till ny plistlib.UID och aktiverade stöd för att läsa och skriva NSKeyedArchiver-kodade binära plistor. (Bidrag från Jon Janzen i bpo-26707.)

pprint

Modulen pprint lade till en sort_dicts-parameter till flera funktioner. Som standard fortsätter dessa funktioner att sortera lexikon före rendering eller utskrift. Men om sort_dicts är satt till false behåller ordböckerna den ordning som nycklarna infogades. Detta kan vara användbart vid jämförelse med JSON-inmatningar under felsökning.

Dessutom finns det en ny funktion, pprint.pp() som är som pprint.pprint() men med sort_dicts som standard till False:

>>> from pprint import pprint, pp
>>> d = dict(source='input.txt', operation='filter', destination='output.txt')
>>> pp(d, width=40)                  # Original order
{'source': 'input.txt',
 'operation': 'filter',
 'destination': 'output.txt'}
>>> pprint(d, width=40)              # Keys sorted alphabetically
{'destination': 'output.txt',
 'operation': 'filter',
 'source': 'input.txt'}

(Bidrag från Rémi Lapeyre i bpo-30670.)

py_compile

py_compile.compile() stöder nu tyst läge. (Bidrag från Joannah Nanjekye i bpo-22640.)

shlex

Den nya funktionen shlex.join() fungerar som inversen av shlex.split(). (Bidrag från Bo Bayles i bpo-32102.)

shutil

shutil.copytree() accepterar nu ett nytt dirs_exist_ok nyckelordsargument. (Bidrag från Josh Bronson i bpo-20849.)

shutil.make_archive() använder nu som standard det moderna pax-formatet (POSIX.1-2001) för nya arkiv för att förbättra portabiliteten och överensstämmelsen med standarder, vilket är ett arv från motsvarande ändring i modulen tarfile. (Bidrag från C.A.M. Gerlach i bpo-30661.)

shutil.rmtree() på Windows tar nu bort katalogförgreningar utan att rekursivt ta bort deras innehåll först. (Bidrag från Steve Dower i bpo-37834.)

socket

Lagt till create_server() och has_dualstack_ipv6() bekvämlighetsfunktioner för att automatisera de nödvändiga uppgifter som vanligtvis ingår när man skapar en server socket, inklusive att acceptera både IPv4 och IPv6 anslutningar på samma socket. (Bidrag från Giampaolo Rodolà i bpo-17561.)

Funktionerna socket.if_nameindex(), socket.if_nametoindex() och socket.if_indextoname() har implementerats i Windows. (Bidrag från Zackery Spytz i bpo-37007.)

ssl

Lagt till post_handshake_auth för att aktivera och verify_client_post_handshake() för att initiera TLS 1.3 post-handshake-autentisering. (Bidrag från Christian Heimes i bpo-34670.)

statistics

Lagt till statistics.fmean() som en snabbare variant med flyttal av statistics.mean(). (Bidrag från Raymond Hettinger och Steven D’Aprano i bpo-35904.)

Lagt till statistics.geometric_mean() (Bidrag från Raymond Hettinger i bpo-27181.)

Lagt till statistics.multimode() som returnerar en lista med de vanligaste värdena. (Bidrag från Raymond Hettinger i bpo-35892.)

Lagt till statistics.quantiles() som delar in data eller en fördelning i utjämningsbara intervall (t.ex. kvartiler, deciler eller percentiler). (Bidrag från Raymond Hettinger i bpo-36546.)

Lagt till statistics.NormalDist, ett verktyg för att skapa och manipulera normalfördelningar av en slumpmässig variabel. (Bidrag från Raymond Hettinger i bpo-36018.)

>>> temperature_feb = NormalDist.from_samples([4, 12, -3, 2, 7, 14])
>>> temperature_feb.mean
6.0
>>> temperature_feb.stdev
6.356099432828281

>>> temperature_feb.cdf(3)            # Chance of being under 3 degrees
0.3184678262814532
>>> # Relative chance of being 7 degrees versus 10 degrees
>>> temperature_feb.pdf(7) / temperature_feb.pdf(10)
1.2039930378537762

>>> el_niño = NormalDist(4, 2.5)
>>> temperature_feb += el_niño        # Add in a climate effect
>>> temperature_feb
NormalDist(mu=10.0, sigma=6.830080526611674)

>>> temperature_feb * (9/5) + 32      # Convert to Fahrenheit
NormalDist(mu=50.0, sigma=12.294144947901014)
>>> temperature_feb.samples(3)        # Generate random samples
[7.672102882379219, 12.000027119750287, 4.647488369766392]

sys

Lägg till ny sys.unraisablehook()-funktion som kan åsidosättas för att styra hur ”unraisable exceptions” hanteras. Den anropas när ett undantag har inträffat men det inte finns något sätt för Python att hantera det. Till exempel när en destruktor gör ett undantag eller under skräpplockning (gc.collect()). (Bidrag från Victor Stinner i bpo-36829.)

tarfile

Modulen tarfile använder nu som standard det moderna pax-formatet (POSIX.1-2001) för nya arkiv, i stället för det tidigare GNU-specifika formatet. Detta förbättrar portabiliteten mellan olika plattformar med en konsekvent kodning (UTF-8) i ett standardiserat och utbyggbart format, och ger flera andra fördelar. (Bidrag från C.A.M. Gerlach i bpo-36268.)

threading

Lägg till en ny threading.excepthook()-funktion som hanterar ej fångade threading.Thread.run()-undantag. Den kan åsidosättas för att kontrollera hur ej fångade threading.Thread.run()-undantag hanteras. (Bidrag från Victor Stinner i bpo-1230540.)

Lägg till en ny threading.get_native_id()-funktion och ett native_id-attribut till threading.Thread-klassen. Dessa returnerar det inbyggda integrerade tråd-ID:t för den aktuella tråden som tilldelats av kärnan. Den här funktionen är endast tillgänglig på vissa plattformar, se get_native_id för mer information. (Bidrag från Jake Tesler i bpo-36084.)

tokenize

Modulen tokenize emitterar nu implicit en NEWLINE-token när den förses med indata som inte har en efterföljande ny rad. Detta beteende matchar nu vad C:s tokenizer gör internt. (Bidrag från Ammar Askar i bpo-33899.)

tkinter

Lagt till metoderna selection_from(), selection_present(), selection_range() och selection_to() i klassen tkinter.Spinbox. (Bidrag från Juliette Monsel i bpo-34829.)

Lagt till metoden moveto() i klassen tkinter.Canvas. (Bidrag från Juliette Monsel i bpo-23831.)

Klassen tkinter.PhotoImage har nu metoderna transparency_get() och transparency_set(). (Bidrag från Zackery Spytz i bpo-25451.)

time

Lagt till ny klocka CLOCK_UPTIME_RAW för macOS 10.12. (Bidrag från Joannah Nanjekye i bpo-35702.)

typing

Modulen typing innehåller flera nya funktioner:

  • En ordbokstyp med typer per nyckel. Se PEP 589 och typing.TypedDict. TypedDict använder endast strängnycklar. Som standard måste alla nycklar vara närvarande. Ange ”total=False” för att tillåta att nycklar är valfria:

    class Location(TypedDict, total=False):
        lat_long: tuple
        grid_square: str
        xy_koordinat: tuple
    
  • Litterala typer. Se PEP 586 och typing.Literal. Literal-typer anger att en parameter eller ett returvärde är begränsat till ett eller flera specifika literal-värden:

    def get_status(port: int) -> Literal['connected', 'disconnected']:
        ...
    
  • ”Final”-variabler, -funktioner, -metoder och -klasser. Se PEP 591, typing.Final och typing.final(). Kvalificeraren final instruerar en statisk typkontrollör att begränsa underklassning, överstyrning eller omtilldelning:

    pi: Final[float] = 3,1415926536
    
  • Definitioner av protokoll. Se PEP 544, typing.Protocol och typing.runtime_checkable(). Enkla ABC som typing.SupportsInt är nu Protocol subklasser.

  • Ny protokollklass typing.SupportsIndex.

  • Nya funktioner typing.get_origin() och typing.get_args().

unicodedata

Modulen unicodedata har uppgraderats för att använda utgåvan Unicode 12.1.0.

Den nya funktionen is_normalized() kan användas för att verifiera att en sträng är i en viss normalform, ofta mycket snabbare än genom att faktiskt normalisera strängen. (Bidrag från Max Belanger, David Euresti och Greg Price i bpo-32285 och bpo-37966).

unittest

Lagt till AsyncMock för att stödja en asynkron version av Mock. Lämpliga nya assert-funktioner för testning har också lagts till. (Bidrag från Lisa Roach i bpo-26467).

Lagt till addModuleCleanup() och addClassCleanup() till unittest för att stödja upprensningar för setUpModule() och setUpClass(). (Bidrag från Lisa Roach i bpo-24412.)

Flera mock assert-funktioner skriver nu också ut en lista över faktiska anrop om de misslyckas. (Bidrag från Petter Strandmark i bpo-35047.)

unittest-modulen fick stöd för coroutines som kan användas som testfall med unittest.IsolatedAsyncioTestCase. (Bidrag från Andrew Svetlov i bpo-32972.)

Exempel:

import unittest


class TestRequest(unittest.IsolatedAsyncioTestCase):

    async def asyncSetUp(self):
        self.connection = await AsyncConnection()

    async def test_get(self):
        response = await self.connection.get("https://example.com")
        self.assertEqual(response.status_code, 200)

    async def asyncTearDown(self):
        await self.connection.close()


if __name__ == "__main__":
    unittest.main()

venv

venv innehåller nu ett Activate.ps1-skript på alla plattformar för aktivering av virtuella miljöer under PowerShell Core 6.1. (Bidrag från Brett Cannon i bpo-32718.)

weakref

De proxyobjekt som returneras av weakref.proxy() har nu stöd för matrismultiplikationsoperatorerna @ och @= utöver de andra numeriska operatorerna. (Bidrag från Mark Dickinson i bpo-36669.)

xml

Som en åtgärd mot hämtning av DTD:er och externa entiteter bearbetar modulerna xml.dom.minidom och xml.sax inte längre externa entiteter som standard. (Bidrag från Christian Heimes i bpo-17239.)

Metoderna .find*() i modulen xml.etree.ElementTree stöder sökningar med jokertecken som {*}tag som ignorerar namnrymden och {namespace}* som returnerar alla taggar i den angivna namnrymden. (Bidrag från Stefan Behnel i bpo-28238.)

Modulen xml.etree.ElementTree tillhandahåller en ny funktion -xml.etree.ElementTree.canonicalize() som implementerar C14N 2.0. (Bidrag från Stefan Behnel i bpo-13611.)

Målobjektet för xml.etree.ElementTree.XMLParser kan ta emot namnrymdsdeklarationshändelser genom de nya callback-metoderna start_ns() och end_ns(). Dessutom kan målet xml.etree.ElementTree.TreeBuilder konfigureras för att bearbeta händelser om kommentarer och bearbetningsinstruktioner för att inkludera dem i det genererade trädet. (Bidrag från Stefan Behnel i bpo-36676 och bpo-36673.)

xmlrpc

xmlrpc.client.ServerProxy stöder nu ett valfritt headers nyckelordsargument för en sekvens av HTTP-rubriker som ska skickas med varje förfrågan. Detta gör det bland annat möjligt att uppgradera från grundläggande autentisering till snabbare sessionsautentisering. (Bidrag från Cédric Krier i bpo-35153.)

Optimeringar

  • Modulen subprocess kan nu använda funktionen os.posix_spawn() i vissa fall för bättre prestanda. För närvarande används den endast på macOS och Linux (med glibc 2.24 eller nyare) om alla dessa villkor är uppfyllda:

    • close_fds är falsk;

    • parametrarna preexec_fn, pass_fds, cwd och start_new_session är inte inställda;

    • den exekverbara sökvägen innehåller en katalog.

    (Bidrag från Joannah Nanjekye och Victor Stinner i bpo-35537.)

  • shutil.copyfile(), shutil.copy(), shutil.copy2(), shutil.copytree() och shutil.move() använder plattformsspecifika ”fast-copy” syscalls på Linux och macOS för att kopiera filen mer effektivt. ”Fast-copy” innebär att kopieringsoperationen sker i kärnan, vilket undviker användning av userspace-buffertar i Python som i ”outfd.write(infd.read())”. På Windows använder shutil.copyfile() en större standardbuffertstorlek (1 MiB istället för 16 KiB) och en memoryview()-baserad variant av shutil.copyfileobj() används. Hastighetsökningen för att kopiera en 512 MiB-fil inom samma partition är ca +26% on Linux, +50% on macOS och +40% on Windows. Dessutom förbrukas mycket mindre CPU-cykler. Se avsnittet Plattformsberoende effektiva kopieringsoperationer. (Bidrag från Giampaolo Rodolà i bpo-33671.)

  • shutil.copytree() använder os.scandir()-funktionen och alla kopieringsfunktioner som är beroende av den använder cachade os.stat()-värden. Hastighetsökningen för att kopiera en katalog med 8000 filer är cirka +9% on Linux, +20% on Windows och +30% on en Windows SMB-delning. Även antalet os.stat() syscalls minskas med 38% vilket gör shutil.copytree() särskilt snabbare på nätverksfilsystem. (Bidrag från Giampaolo Rodolà i bpo-33695.)

  • Standardprotokollet i modulen pickle är nu Protocol 4, som först introducerades i Python 3.4. Det erbjuder bättre prestanda och mindre storlek jämfört med Protocol 3 som funnits tillgängligt sedan Python 3.0.

  • Tog bort en Py_ssize_t-medlem från PyGC_Head. Alla GC-spårade objekt (t.ex. tuple, list, dict) minskas med 4 eller 8 byte. (Bidrag från Inada Naoki i bpo-33597.)

  • uuid.UUID använder nu __slots__ för att minska sitt minnesavtryck. (Bidrag från Wouter Bolsterlee och Tal Einat i bpo-30977)

  • Förbättrad prestanda för operator.itemgetter() med 33%. Optimerad argumenthantering och en snabb väg har lagts till för det vanliga fallet med ett enda icke-negativt heltalsindex i en tupel (vilket är det typiska användningsfallet i standardbiblioteket). (Bidrag från Raymond Hettinger i bpo-35664.)

  • Snabbare fältuppslagningar i collections.namedtuple(). De är nu mer än två gånger snabbare, vilket gör dem till den snabbaste formen av instansvariabeluppslagning i Python. (Bidrag från Raymond Hettinger, Pablo Galindo, och Joe Jevnik, Serhiy Storchaka i bpo-32492.)

  • Konstruktorn list overallokerar inte den interna objektbufferten om den ingående iterabeln har en känd längd (den ingående implementerar __len__). Detta gör den skapade listan 12% smaller i genomsnitt. (Bidrag från Raymond Hettinger och Pablo Galindo i bpo-33234.)

  • Fördubblade hastigheten för skrivningar av klassvariabler. När ett icke-dunder-attribut uppdaterades fanns det ett onödigt anrop till update slots. (Bidrag från Stefan Behnel, Pablo Galindo Salgado, Raymond Hettinger, Neil Schemenauer, och Serhiy Storchaka i bpo-36012.)

  • Minskade omkostnaderna för att konvertera argument som skickas till många inbyggda funktioner och metoder. Detta påskyndade anrop av vissa enkla inbyggda funktioner och metoder upp till 20–50%. (Bidrag från Serhiy Storchaka i bpo-23867, bpo-35582 och bpo-36127.)

  • LOAD_GLOBAL instruktionen använder nu den nya ”per opcode cache” mekanismen. Den är ungefär 40% faster nu. (Bidrag från Yury Selivanov och Inada Naoki i bpo-26219.)

Ändringar i Build och C API

  • Standard sys.abiflags blev en tom sträng: flaggan m för pymalloc blev värdelös (byggen med och utan pymalloc är ABI-kompatibla) och har därför tagits bort. (Bidrag från Victor Stinner i bpo-36707.)

    Exempel på förändringar:

    • Endast programmet python3.8 är installerat, programmet python3.8m är borta.

    • Endast skriptet python3.8-config är installerat, skriptet python3.8m-config är borta.

    • Flaggan m har tagits bort från suffixet för dynamiska biblioteksfilnamn: tilläggsmoduler i standardbiblioteket samt de som produceras och installeras av tredjepartspaket, som de som hämtas från PyPI. På Linux, till exempel, blev Python 3.7-suffixet .cpython-37m-x86_64-linux-gnu.so .cpython-38-x86_64-linux-gnu.so i Python 3.8.

  • Huvudfilerna har omorganiserats för att bättre separera de olika typerna av API:er:

    • Include/*.h bör vara det portabla offentliga stabila C API.

    • Include/cpython/*.h bör vara det instabila C API som är specifikt för CPython; offentligt API, med vissa privata API som föregås av _Py eller _PY.

    • Include/internal/*.h är det privata interna C API:et som är mycket specifikt för CPython. Detta API kommer med ingen garanti för bakåtkompatibilitet och bör inte användas utanför CPython. Det är endast exponerat för mycket specifika behov som debuggers och profiler som måste komma åt CPython-interna utan att anropa funktioner. Detta API installeras nu av make install.

    (Bidrag från Victor Stinner i bpo-35134 och bpo-35081, arbete påbörjat av Eric Snow i Python 3.7.)

  • Vissa makron har konverterats till statiska inline-funktioner: parametertyper och returtyp är väldefinierade, de har inte problem som är specifika för makron, variabler har lokala räckvidder. Exempel på detta:

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

  • Funktionerna PyByteArray_Init() och PyByteArray_Fini() har tagits bort. De gjorde ingenting sedan Python 2.7.4 och Python 3.2.0, var uteslutna från det begränsade API:et (stabilt ABI) och var inte dokumenterade. (Bidrag från Victor Stinner i bpo-35713.)

  • Resultatet av PyExceptionClass_Name() är nu av typen const char * istället för char *. (Bidrag från Serhiy Storchaka i bpo-33818.)

  • Dubbelheten mellan Modules/Setup.dist och Modules/Setup har tagits bort. Tidigare, när man uppdaterade CPythons källträd, var man tvungen att manuellt kopiera Modules/Setup.dist (i källträdet) till Modules/Setup (i byggträdet) för att återspegla eventuella ändringar uppströms. Detta var en liten fördel för paketerare på bekostnad av ett ofta förekommande irritationsmoment för utvecklare som följde CPython-utvecklingen, eftersom om man glömde att kopiera filen kunde det leda till byggfel.

    Nu läser byggsystemet alltid från Modules/Setup inuti källträdet. Personer som vill anpassa den filen uppmuntras att underhålla sina ändringar i en git-fork av CPython eller som patch-filer, som de skulle göra för alla andra ändringar i källträdet.

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

  • Funktioner som konverterar Pythontal till C-integral som PyLong_AsLong() och argumentparsingfunktioner som PyArg_ParseTuple() med heltalskonverteringsformatenheter som 'i' kommer nu att använda specialmetoden __index__() istället för __int__(), om tillgänglig. Deprecation-varningen kommer att utfärdas för objekt med metoden __int__() men utan metoden __index__() (som Decimal och Fraction). PyNumber_Check() kommer nu att returnera 1 för objekt som implementerar __index__(). PyNumber_Long(), PyNumber_Float() och PyFloat_AsDouble() använder nu också metoden __index__() om den är tillgänglig. (Bidrag från Serhiy Storchaka i bpo-36048 och bpo-20092.)

  • Heap-allokerade typobjekt kommer nu att öka sitt referensantal i PyObject_Init() (och dess parallella makro PyObject_INIT) istället för i PyType_GenericAlloc(). Typer som modifierar instansallokering eller -deallokering kan behöva justeras. (Bidrag från Eddie Elizondo i bpo-35810.)

  • Den nya funktionen PyCode_NewWithPosOnlyArgs() gör det möjligt att skapa kodobjekt som PyCode_New(), men med en extra posonlyargcount parameter för att ange antalet enbart positionella argument. (Bidrag från Pablo Galindo i bpo-37221.)

  • Py_SetPath() sätter nu sys.executable till programmets fullständiga sökväg (Py_GetProgramFullPath()) istället för till programnamnet (Py_GetProgramName()). (Bidrag från Victor Stinner i bpo-38234.)

Föråldrat

Borttagning av API och funktioner

Följande funktioner och API:er har tagits bort från Python 3.8:

  • Från och med Python 3.3 är import av ABC från collections föråldrad, och import ska göras från collections.abc. Att kunna importera från samlingar var markerat för borttagning i 3.8, men har försenats till 3.9. (Se gh-81134.)

  • Modulen macpath, som är föråldrad i Python 3.7, har tagits bort. (Bidrag från Victor Stinner i bpo-35471.)

  • Funktionen platform.popen() har tagits bort, efter att ha varit föråldrad sedan Python 3.3: använd os.popen() istället. (Bidrag från Victor Stinner i bpo-35345.)

  • Funktionen time.clock() har tagits bort, efter att ha varit föråldrad sedan Python 3.3: använd time.perf_counter() eller time.process_time() istället, beroende på dina krav, för att få ett väldefinierat beteende. (Bidrag från Matthias Bussonnier i bpo-36895.)

  • Skriptet pyvenv har tagits bort till förmån för python3.8 -m venv för att hjälpa till att eliminera förvirring om vilken Python-tolk skriptet pyvenv är knutet till. (Bidrag från Brett Cannon i bpo-25427.)

  • parse_qs, parse_qsl och escape har tagits bort från modulen cgi. De är föråldrade i Python 3.2 eller äldre. De bör importeras från modulerna urllib.parse och html istället.

  • filemode funktionen är borttagen från tarfile modulen. Den är inte dokumenterad och föråldrad sedan Python 3.3.

  • Konstruktorn XMLParser accepterar inte längre argumentet html. Det hade aldrig någon effekt och utrangerades i Python 3.4. Alla andra parametrar är nu keyword-only. (Bidrag från Serhiy Storchaka i bpo-29209.)

  • Tog bort metoden doctype() i XMLParser. (Bidrag från Serhiy Storchaka i bpo-29209.)

  • ”unicode_internal” codec är borttagen. (Bidrag från Inada Naoki i bpo-36297.)

  • Objekten Cache och Statement i modulen sqlite3 är inte exponerade för användaren. (Bidrag från Aviv Palivoda i bpo-30262.)

  • Nyckelordsargumentet bufsize i fileinput.input() och fileinput.FileInput() som ignorerades och var föråldrat sedan Python 3.6 har tagits bort. bpo-36952 (Bidrag från Matthias Bussonnier.)

  • Funktionerna sys.set_coroutine_wrapper() och sys.get_coroutine_wrapper() som är föråldrade i Python 3.7 har tagits bort; bpo-36933 (Bidrag från Matthias Bussonnier.)

Portning till Python 3.8

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

Förändringar i Pythons beteende

  • Yield-uttryck (både yield och yield from-klausuler) är nu inte tillåtna i förståelser och generatoruttryck (förutom det iterabla uttrycket i for-klausulen längst till vänster). (Bidrag från Serhiy Storchaka i bpo-10544.)

  • Kompilatorn producerar nu en SyntaxWarning när identitetskontroller (is och is not) används med vissa typer av literaler (t.ex. strängar, tal). Dessa kan ofta fungera av misstag i CPython, men garanteras inte av språkspecifikationen. Varningen råder användare att använda likhetstester (== och !=) istället. (Bidrag från Serhiy Storchaka i bpo-34850.)

  • CPython-tolken kan svälja undantag under vissa omständigheter. I Python 3.8 händer detta i färre fall. I synnerhet ignoreras inte längre undantag som uppstår när attributet hämtas från typordboken. (Bidrag från Serhiy Storchaka i bpo-35459.)

  • Tog bort __str__ implementationer från inbyggda typer bool, int, float, complex och några klasser från standardbiblioteket. De ärver nu __str__() från object. Som ett resultat kommer definitionen av metoden __repr__() i underklassen av dessa klasser att påverka deras strängrepresentation. (Bidrag från Serhiy Storchaka i bpo-36793.)

  • På AIX innehåller sys.platform inte längre huvudversionen. Den är alltid 'aix', istället för 'aix3''aix7'. Eftersom äldre Python-versioner innehåller versionsnumret, så rekommenderas det att alltid använda sys.platform.startswith('aix'). (Bidrag från M. Felt i bpo-36588.)

  • PyEval_AcquireLock() och PyEval_AcquireThread() avslutar nu den aktuella tråden om de anropas medan tolken håller på att slutföras, vilket gör dem konsekventa med PyEval_RestoreThread(), Py_END_ALLOW_THREADS() och PyGILState_Ensure(). Om detta beteende inte är önskvärt, bevaka anropet genom att kontrollera _Py_IsFinalizing() eller sys.is_finalizing(). (Bidrag från Joannah Nanjekye i bpo-36475.)

Ändringar i Python API

  • Funktionen os.getcwdb() använder nu UTF-8-kodning i Windows, snarare än ANSI-kodsidan: se PEP 529 för motivering. Funktionen är inte längre föråldrad i Windows. (Bidrag från Victor Stinner i bpo-37412.)

  • subprocess.Popen kan nu använda os.posix_spawn() i vissa fall för bättre prestanda. I Windows Subsystem for Linux och QEMU User Emulation ger konstruktorn Popen som använder os.posix_spawn() inte längre upphov till ett undantag vid fel som ”missing program”. Istället misslyckas barnprocessen med en returncode som inte är noll. (Bidrag från Joannah Nanjekye och Victor Stinner i bpo-35537.)

  • Argumentet preexec_fn i * subprocess.Popen är inte längre kompatibelt med undertolkare. Användningen av parametern i en undertolk ger nu upphov till RuntimeError. (Bidrag från Eric Snow i bpo-34651, modifierat av Christian Heimes i bpo-37951.)

  • Metoden imap.IMAP4.logout() ignorerar inte längre godtyckliga undantag. (Bidrag från Victor Stinner i bpo-36348.)

  • Funktionen platform.popen() har tagits bort, efter att ha varit föråldrad sedan Python 3.3: använd os.popen() istället. (Bidrag från Victor Stinner i bpo-35345.)

  • Funktionen statistics.mode() ger inte längre upphov till ett undantag när den får multimodala data. Istället returnerar den det första läget som påträffas i indata. (Bidrag från Raymond Hettinger i bpo-35892.)

  • Metoden selection() i klassen tkinter.ttk.Treeview tar inte längre emot argument. Att använda den med argument för att ändra urvalet var föråldrat i Python 3.6. Använd specialiserade metoder som selection_set() för att ändra urvalet. (Bidrag från Serhiy Storchaka i bpo-31508.)

  • Metoderna writexml(), toxml() och toprettyxml() i xml.dom.minidom, och metoden write() i xml.etree, bevarar nu den attributordning som anges av användaren. (Bidrag från Diego Rojas och Raymond Hettinger i bpo-34160.)

  • En dbm.dumb databas som öppnats med flaggorna 'r' är nu skrivskyddad. dbm.dumb.open() med flaggorna 'r' och 'w' skapar inte längre en databas om den inte existerar. (Bidrag från Serhiy Storchaka i bpo-32749.)

  • Metoden doctype() som definieras i en underklass till XMLParser kommer inte längre att anropas och avger en RuntimeWarning istället för en DeprecationWarning. Definiera metoden doctype() på ett mål för hantering av en XML-doktypdeklaration. (Bidrag från Serhiy Storchaka i bpo-29209.)

  • Ett RuntimeError utlöses nu när den anpassade metaklassen inte tillhandahåller __classcell__-objektet i namnrymden som skickas till type.__new__. En DeprecationWarning gavs ut i Python 3.6–3.7. (Bidrag från Serhiy Storchaka i bpo-23722.)

  • Klassen cProfile.Profile kan nu användas som en kontexthanterare. (Bidrag från Scott Sanderson i bpo-29235.)

  • shutil.copyfile(), shutil.copy(), shutil.copy2(), shutil.copytree() och shutil.move() använder plattformsspecifika ”fast-copy” syscalls (se avsnittet Plattformsberoende effektiva kopieringsoperationer).

  • shutil.copyfile() standardbuffertstorlek i Windows ändrades från 16 KiB till 1 MiB.

  • Strukturen PyGC_Head har ändrats helt. All kod som berör struct-medlemmen bör skrivas om. (Se bpo-33597.)

  • Strukturen PyInterpreterState har flyttats till de ”interna” header-filerna (särskilt Include/internal/pycore_pystate.h). En opak PyInterpreterState är fortfarande tillgänglig som en del av det offentliga API:et (och stabila ABI). Dokumentationen indikerar att inga av strukturens fält är offentliga, så vi hoppas att ingen har använt dem. Men om du förlitar dig på ett eller flera av dessa privata fält och inte har något alternativ, öppna en BPO-fråga. Vi ska försöka hjälpa dig att anpassa dig (eventuellt genom att lägga till accessorfunktioner till det publika API:et). (Se bpo-35886.)

  • Metoden mmap.flush() returnerar nu None vid framgång och ger upphov till ett undantag vid fel under alla plattformar. Tidigare var dess beteende plattformsberoende: ett värde som inte var noll returnerades vid framgång; noll returnerades vid fel under Windows. Ett nollvärde returnerades vid framgång; ett undantag utlöstes vid fel under Unix. (Bidrag från Berker Peksag i bpo-2122.)

  • modulerna xml.dom.minidom och xml.sax bearbetar inte längre externa enheter som standard. (Bidrag från Christian Heimes i bpo-17239.)

  • Om en nyckel raderas från en skrivskyddad dbm-databas (dbm.dumb, dbm.gnu eller dbm.ndbm) uppstår error (dbm.dumb.error, dbm.gnu.error eller dbm.ndbm.error) istället för KeyError. (Bidrag från Xiang Zhang i bpo-33106.)

  • Förenklad AST för literaler. Alla konstanter kommer att representeras som ast.Constant-instanser. Instansiering av gamla klasser Num, Str, Bytes, NameConstant och Ellipsis kommer att returnera en instans av Constant. (Bidrag från Serhiy Storchaka i bpo-32892.)

  • expanduser() på Windows föredrar nu miljövariabeln USERPROFILE och använder inte HOME, som normalt inte är inställd för vanliga användarkonton. (Bidrag från Anthony Sottile i bpo-36264.)

  • Undantaget asyncio.CancelledError ärver nu från BaseException snarare än Exception och ärver inte längre från concurrent.futures.CancelledError. (Bidrag från Yury Selivanov i bpo-32528.)

  • Funktionen asyncio.wait_for() väntar nu korrekt på avbrytande när den använder en instans av asyncio.Task. Tidigare, när timeout nåddes, avbröts funktionen och returnerades omedelbart. (Bidrag från Elvis Pranskevichus i bpo-32751.)

  • Funktionen asyncio.BaseTransport.get_extra_info() returnerar nu ett socket-objekt som är säkert att använda när ’socket’ skickas till parametern name. (Bidrag från Yury Selivanov i bpo-37027.)

  • asyncio.BufferedProtocol har gått över till det stabila API:et.

  • DLL-beroenden för tilläggsmoduler och DLL:er som laddas med ctypes i Windows löses nu på ett säkrare sätt. Endast systemsökvägarna, katalogen som innehåller DLL- eller PYD-filen och kataloger som lagts till med add_dll_directory() genomsöks efter beroenden vid laddningstillfället. Specifikt används inte längre PATH och den aktuella arbetskatalogen, och ändringar av dessa kommer inte längre att ha någon effekt på normal DLL-upplösning. Om ditt program är beroende av dessa mekanismer bör du söka efter add_dll_directory() och om den finns, använda den för att lägga till DLL-katalogen när du laddar ditt bibliotek. Observera att Windows 7-användare måste se till att Windows Update KB2533623 har installerats (detta verifieras också av installationsprogrammet). (Bidrag från Steve Dower i bpo-36085.)

  • Huvudfilerna och funktionerna relaterade till pgen har tagits bort efter att de ersatts av en ren Python-implementation. (Bidrag från Pablo Galindo i bpo-36623.)

  • types.CodeType har en ny parameter i konstruktörens andra position (posonlyargcount) för att stödja enbart positionella argument definierade i PEP 570. Det första argumentet (argcount) representerar nu det totala antalet positionella argument (inklusive enbart positionella argument). Den nya metoden replace() i types.CodeType kan användas för att göra koden framtidssäker.

  • Parametern digestmod för hmac.new() använder inte längre MD5-digest som standard.

Förändringar i C API

  • Strukturen PyCompilerFlags har fått ett nytt fält cf_feature_version. Det bör initialiseras till PY_MINOR_VERSION. Fältet ignoreras som standard och används om och endast om flaggan PyCF_ONLY_AST är inställd i cf_flags. (Bidrag från Guido van Rossum i bpo-35766.)

  • Funktionen PyEval_ReInitThreads() har tagits bort från C API. Den bör inte anropas explicit: använd PyOS_AfterFork_Child() istället. (Bidrag från Victor Stinner i bpo-36728.)

  • På Unix länkas inte längre C-tillägg till libpython, utom på Android och Cygwin. När Python är inbäddat får inte libpython laddas med RTLD_LOCAL utan RTLD_GLOBAL istället. Tidigare, med RTLD_LOCAL, var det redan inte möjligt att ladda C-tillägg som inte var länkade till libpython, som C-tillägg till standardbiblioteket som byggdes av *shared* sektionen i Modules/Setup. (Bidrag från Victor Stinner i bpo-21536.)

  • Användning av # varianter av format vid parsning eller skapande av värde (t.ex. PyArg_ParseTuple(), Py_BuildValue(), PyObject_CallFunction(), etc.) utan PY_SSIZE_T_CLEAN definierad ger upphov till DeprecationWarning nu. Det kommer att tas bort i 3.10 eller 4.0. Läs Tolkning av argument och skapande av värden för detaljer. (Bidrag från Inada Naoki i bpo-36381.)

  • Instanser av heap-allokerade typer (t.ex. de som skapats med PyType_FromSpec()) har en referens till sitt typobjekt. Ökningen av antalet referenser till dessa typobjekt har flyttats från PyType_GenericAlloc() till lågnivåfunktionerna PyObject_Init() och PyObject_INIT(). Detta gör att typer som skapas genom PyType_FromSpec() beter sig som andra klasser i hanterad kod.

    Statiskt allokerade typer påverkas inte.

    För de allra flesta fall bör det inte finnas någon bieffekt. Men typer som manuellt ökar referensantalet efter att ha allokerat en instans (kanske för att kringgå buggen) kan nu bli odödliga. För att undvika detta måste dessa klasser anropa Py_DECREF på typobjektet under avallokering av instansen.

    För att korrekt porta dessa typer till 3.8, gör följande ändringar:

    • Ta bort Py_INCREF på typobjektet efter allokering av en instans - om någon. Detta kan hända efter anrop av PyObject_New, PyObject_NewVar, PyObject_GC_New(), PyObject_GC_NewVar(), eller någon annan anpassad allokator som använder PyObject_Init() eller PyObject_INIT().

      Exempel:

      static foo_struct *
      foo_new(PyObject *type) {
          foo_struct *foo = PyObject_GC_New(foo_struct, (PyTypeObject *) type);
          if (foo == NULL)
              return NULL;
      #if PY_VERSION_HEX < 0x03080000
          // Workaround for Python issue 35810; no longer necessary in Python 3.8
          PY_INCREF(type)
      #endif
          return foo;
      }
      
    • Säkerställ att alla anpassade tp_dealloc-funktioner för heap-allokerade typer minskar typens referensantal.

      Exempel:

      static void
      foo_dealloc(foo_struct *instance) {
          PyObject *type = Py_TYPE(instance);
          PyObject_GC_Del(instance);
      #if PY_VERSION_HEX >= 0x03080000
          // This was not needed before Python 3.8 (Python issue 35810)
          Py_DECREF(type);
      #endif
      }
      

    (Bidrag från Eddie Elizondo i bpo-35810.)

  • Makrot Py_DEPRECATED() har implementerats för MSVC. Makrot måste nu placeras före symbolnamnet.

    Exempel:

    Py_DEPRECATED(3.8) PyAPI_FUNC(int) Py_OldFunction(void);
    

    (Bidrag från Zackery Spytz i bpo-33407.)

  • Tolken låtsas inte längre stödja binär kompatibilitet för tilläggstyper över funktionsutgåvor. En PyTypeObject som exporteras av en tilläggsmodul från tredje part ska ha alla slots som förväntas i den aktuella Python-versionen, inklusive tp_finalize (Py_TPFLAGS_HAVE_FINALIZE kontrolleras inte längre innan läsning av tp_finalize).

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

  • Funktionerna PyNode_AddChild() och PyParser_AddToken() accepterar nu två ytterligare int-argument end_lineno och end_col_offset.

  • Filen libpython38.a som gör det möjligt för MinGW-verktyg att länka direkt mot python38.dll ingår inte längre i den vanliga Windows-distributionen. Om du behöver den här filen kan den genereras med verktygen gendef och dlltool, som ingår i MinGW binutils-paketet:

    gendef - python38.dll > tmp.def
    dlltool --dllname python38.dll --def tmp.def --output-lib libpython38.a
    

    Platsen för en installerad pythonXY.dll beror på installationsalternativen och versionen av och språket i Windows. Se Använda Python på Windows för mer information. Det resulterande biblioteket bör placeras i samma katalog som pythonXY.lib, vilket i allmänhet är libs-katalogen under din Python-installation.

    (Bidrag från Steve Dower i bpo-37351.)

CPython bytecode-ändringar

  • Tolkningsloopen har förenklats genom att logiken för att rulla ut blockstapeln har flyttats till kompilatorn. Kompilatorn ger nu uttryckliga instruktioner för att justera stapeln med värden och anropa uppstädningskoden för break, continue och return.

    Borttagna opkoder BREAK_LOOP, CONTINUE_LOOP, SETUP_LOOP och SETUP_EXCEPT. Lagt till nya opkoder ROT_FOUR, BEGIN_FINALLY, CALL_FINALLY och POP_FINALLY. Ändrat beteende för END_FINALLY och WITH_CLEANUP_START.

    (Bidrag från Mark Shannon, Antoine Pitrou och Serhiy Storchaka i bpo-17611.)

  • Lagt till ny opcode END_ASYNC_FOR för hantering av undantag som uppstår när man väntar på nästa objekt i en async for-loop. (Bidrag från Serhiy Storchaka i bpo-33041.)

  • MAP_ADD förväntar sig nu värdet som det första elementet i stacken och nyckeln som det andra elementet. Denna ändring gjordes så att nyckeln alltid utvärderas före värdet i ordboksförståelser, vilket föreslogs av PEP 572. (Bidrag från Jörn Heissler i bpo-35224.)

Demonstrationer och verktyg

Lagt till ett benchmarkskript för att mäta olika sätt att komma åt variabler: Tools/scripts/var_access_benchmark.py. (Bidrag från Raymond Hettinger i bpo-35884.)

Här är en sammanfattning av prestandaförbättringar sedan Python 3.3:

Python version                       3.3     3.4     3.5     3.6     3.7     3.8
--------------                       ---     ---     ---     ---     ---     ---

Variable and attribute read access:
    read_local                       4.0     7.1     7.1     5.4     5.1     3.9
    read_nonlocal                    5.3     7.1     8.1     5.8     5.4     4.4
    read_global                     13.3    15.5    19.0    14.3    13.6     7.6
    read_builtin                    20.0    21.1    21.6    18.5    19.0     7.5
    read_classvar_from_class        20.5    25.6    26.5    20.7    19.5    18.4
    read_classvar_from_instance     18.5    22.8    23.5    18.8    17.1    16.4
    read_instancevar                26.8    32.4    33.1    28.0    26.3    25.4
    read_instancevar_slots          23.7    27.8    31.3    20.8    20.8    20.2
    read_namedtuple                 68.5    73.8    57.5    45.0    46.8    18.4
    read_boundmethod                29.8    37.6    37.9    29.6    26.9    27.7

Variable and attribute write access:
    write_local                      4.6     8.7     9.3     5.5     5.3     4.3
    write_nonlocal                   7.3    10.5    11.1     5.6     5.5     4.7
    write_global                    15.9    19.7    21.2    18.0    18.0    15.8
    write_classvar                  81.9    92.9    96.0   104.6   102.1    39.2
    write_instancevar               36.4    44.6    45.8    40.0    38.9    35.5
    write_instancevar_slots         28.7    35.6    36.1    27.3    26.6    25.7

Data structure read access:
    read_list                       19.2    24.2    24.5    20.8    20.8    19.0
    read_deque                      19.9    24.7    25.5    20.2    20.6    19.8
    read_dict                       19.7    24.3    25.7    22.3    23.0    21.0
    read_strdict                    17.9    22.6    24.3    19.5    21.2    18.9

Data structure write access:
    write_list                      21.2    27.1    28.5    22.5    21.6    20.0
    write_deque                     23.8    28.7    30.1    22.7    21.8    23.5
    write_dict                      25.9    31.4    33.3    29.3    29.2    24.7
    write_strdict                   22.9    28.4    29.9    27.5    25.2    23.1

Stack (or queue) operations:
    list_append_pop                144.2    93.4   112.7    75.4    74.2    50.8
    deque_append_pop                30.4    43.5    57.0    49.4    49.2    42.5
    deque_append_popleft            30.8    43.7    57.3    49.7    49.7    42.8

Timing loop:
    loop_overhead                    0.3     0.5     0.6     0.4     0.3     0.3

Riktmärkena uppmättes på en Intel® Core™ i7-4960HQ-processor som körde macOS 64-bitars builds som finns på python.org. Benchmarkskriptet visar tidsangivelser i nanosekunder.

Viktiga ändringar i Python 3.8.1

På grund av betydande säkerhetsproblem stöds inte längre parametern reuse_address i asyncio.loop.create_datagram_endpoint(). Detta beror på beteendet hos socket-alternativet SO_REUSEADDR i UDP. För mer information, se dokumentationen för loop.create_datagram_endpoint(). (Bidrag från Kyle Stanley, Antoine Pitrou och Yury Selivanov i bpo-37228.)

Viktiga ändringar i Python 3.8.2

Åtgärdade en regression med ignore callback av shutil.copytree(). Argumenttyperna är nu str och List[str] igen. (Bidrag från Manuel Barkhau och Giampaolo Rodola i gh-83571.)

Viktiga ändringar i Python 3.8.3

De konstanta värdena för framtidsflaggor i modulen __future__ uppdateras för att förhindra kollision med kompilatorflaggor. Tidigare krockade PyCF_ALLOW_TOP_LEVEL_AWAIT med CO_FUTURE_DIVISION. (Bidrag från Batuhan Taskaya i gh-83743)

Noterbara ändringar i Python 3.8.8

Tidigare Python-versioner tillät användning av både ; och & som separatorer för frågeparametrar i urllib.parse.parse_qs() och urllib.parse.parse_qsl(). På grund av säkerhetsproblem och för att överensstämma med nyare W3C-rekommendationer har detta ändrats så att endast en enda separatornyckel tillåts, med & som standard. Denna ändring påverkar även cgi.parse() och cgi.parse_multipart() eftersom de använder de berörda funktionerna internt. För mer information, se deras respektive dokumentation. (Bidrag från Adam Goldschmidt, Senthil Kumaran och Ken Jin i bpo-42967.)

Viktiga ändringar i Python 3.8.9

En säkerhetsfix ändrar ftplib.FTP-beteendet så att det inte litar på den IPv4-adress som skickas från fjärrservern när en passiv datakanal sätts upp. Vi återanvänder istället ftp-serverns IP-adress. För ovanlig kod som kräver det gamla beteendet, ställ in attributet trust_server_pasv_ipv4_address på din FTP-instans till True. (Se gh-87451)

Viktiga ändringar i Python 3.8.10

macOS 11.0 (Big Sur) och stöd för Apple Silicon Mac

Från och med version 3.8.10 stöder Python nu kompilering och körning på macOS 11 (Big Sur) och på Apple Silicon Mac-datorer (baserade på ARM64-arkitekturen). En ny universell kompileringsvariant, universal2, finns nu tillgänglig för att nativt stödja både ARM64 och Intel 64 i en uppsättning körbara filer. Observera att stöd för ”weaklinking”, byggande av binärer avsedda för nyare versioner av macOS som också kommer att fungera korrekt på äldre versioner genom att testa saknade funktioner vid körning, inte ingår i denna bakåtkompatibilitetsuppdatering från Python 3.9. För att stödja en rad macOS-versioner, fortsätt att rikta in dig på och bygga på den äldsta versionen i intervallet.

(Ursprungligen bidragit av Ronald Oussoren och Lawrence D’Anna i gh-85272, med korrigeringar av FX Coudert och Eli Rykoff, och bakåtporterad till 3.8 av Maxime Bélanger och Ned Deily)

Viktiga ändringar i Python 3.8.10

urllib.parse

Förekomsten av newline- eller tabb-tecken i delar av en URL möjliggör vissa former av attacker. I enlighet med WHATWG-specifikationen som uppdaterar RFC 3986, tas ASCII newline n, \r och tabb t-tecken bort från URL:en av parsern i urllib.parse för att förhindra sådana attacker. De borttagna tecknen styrs av en ny variabel på modulnivå, urllib.parse._UNSAFE_URL_BYTES_TO_REMOVE. (Se bpo-43882)

Viktiga ändringar i Python 3.8.12

Ändringar i Python API

Från och med Python 3.8.12 accepterar modulen ipaddress inte längre några ledande nollor i IPv4-adresssträngar. Ledande nollor är tvetydiga och tolkas som oktal notation av vissa bibliotek. Till exempel behandlar den äldre funktionen socket.inet_aton() ledande nollor som oktal notation. glibc-implementeringen av den moderna inet_pton() accepterar inte några ledande nollor.

(Ursprungligen bidragit av Christian Heimes i bpo-36384, och bakåtporterat till 3.8 av Achraf Merzouki.)

Anmärkningsvärd säkerhetsfunktion i 3.8.14

Konvertering mellan int och str i andra baser än 2 (binär), 4, 8 (oktal), 16 (hexadecimal) eller 32 såsom bas 10 (decimal) ger nu upphov till ett ValueError om antalet siffror i strängform är över en gräns för att undvika potentiella överbelastningsattacker på grund av den algoritmiska komplexiteten. Detta är en begränsning av CVE 2020-10735. Den här gränsen kan konfigureras eller inaktiveras med hjälp av en miljövariabel, kommandoradsflagga eller sys API:er. Se dokumentationen Längdsbegränsning för konvertering av heltalssträngar. Standardgränsen är 4300 siffror i strängform.

Viktiga ändringar i 3.8.17

tarfile

  • Extraktionsmetoderna i tarfile och shutil.unpack_archive() har ett nytt filter-argument som gör det möjligt att begränsa tarfunktioner som kan vara överraskande eller farliga, t.ex. att skapa filer utanför destinationskatalogen. Se Filter för utsugning för detaljer. I Python 3.12 kommer användning utan filter-argumentet att visa en DeprecationWarning. I Python 3.14 kommer standardinställningen att ändras till 'data'. (Bidrag från Petr Viktorin i PEP 706.)