select — vänta på händelser på en uppsättning strömmar

Denna modul tillhandahåller funktioner för att effektivt vänta tills en eller flera strömmar (filliknande objekt som implementerar strömprotokollet, såsom sockets, UART:er och andra I/O-objekt) är redo för läsning eller skrivning, i stället för att aktivt vänta eller blockera på ett enda objekt.

poll-objektet är det rekommenderade gränssnittet: det skalar till många strömmar och är allokeringsfritt när det används via poll.ipoll(). Funktionen select() på modulnivå är ett mindre effektivt kompatibilitetsgränssnitt.

Exempel med ett poll-objekt:

import select

poller = select.poll()
poller.register(uart, select.POLLIN)

while True:
    # Wait up to 1000 ms for the UART to have data.
    for obj, event in poller.poll(1000):
        if event & select.POLLIN:
            print(obj.read())

Exempel med funktionen select() på modulnivå:

import select

# Wait up to 1 second for the socket to become readable.
rlist, wlist, xlist = select.select([sock], [], [], 1.0)
if rlist:
    data = sock.recv(100)

Funktioner

select.select(rlist: List, wlist: List, xlist: List, timeout: float | None = None) → Tuple[List, List, List]

Vänta tills ett eller flera av de angivna strömobjekten är redo, eller tills timeout löper ut.

  • rlist är en lista över objekt att övervaka för läsbarhet.

  • wlist är en lista över objekt att övervaka för skrivbarhet.

  • xlist är en lista över objekt att övervaka för ett fel- eller frånkopplingstillstånd.

  • timeout är den maximala tiden att vänta, i sekunder (ett flyttal accepteras). Om det utelämnas eller är None blockerar anropet i obestämd tid; 0 returnerar omedelbart (en icke-blockerande pollning).

Returnerar en 3-tupel av listor (rlist, wlist, xlist). Varje returnerad lista är den delmängd av motsvarande indatalista som innehåller de objekt som blev redo för läsning, redo för skrivning, respektive som signalerade ett fel/en frånkoppling. Om timeout löper ut utan att något är redo är alla tre listorna tomma.

Denna funktion är mindre effektiv än poll (den bygger om sin interna pollningsuppsättning vid varje anrop); använd poll i stället där det är möjligt.

Konstanter

select.POLLIN: int

Det finns data tillgängliga att läsa från strömmen.

select.POLLOUT: int

Strömmen kan ta emot mer data att skriva.

select.POLLERR: int

Ett feltillstånd uppstod på strömmen. Detta är en oönskad händelse: den rapporteras av poll.poll() / poll.ipoll() även om den inte begärdes i eventmask, och det är inte giltigt att skicka den som en indata-eventmask.

select.POLLHUP: int

Strömmen kopplades ner / frånkopplades. Detta är en oönskad händelse: den rapporteras av poll.poll() / poll.ipoll() även om den inte begärdes i eventmask, och det är inte giltigt att skicka den som en indata-eventmask.

Klasser

class select.poll

Skapa ett pollningsobjekt som upprätthåller en uppsättning registrerade strömmar (eller vilka objekt som helst som exponerar strömprotokollet) och effektivt väntar tills en eller flera av dem blir läsbara, skrivbara eller signalerar ett undantagstillstånd.

Strömmar läggs till med register(), tas bort med unregister(), och uppsättningen händelser att bevaka kan ändras med modify(). När den väl är konfigurerad, anropa poll() för att blockera tills något är redo (eller en timeout löper ut), eller ipoll() för en allokeringsfri iteratorbaserad variant.

register(obj: Any, eventmask: int = select.POLLIN | select.POLLOUT) → None

Registrera strömmen obj för pollning, med bevakning av de händelser som anges av eventmask (den logiska OR av):

eventmask har som standard select.POLLIN | select.POLLOUT.

select.POLLHUP och select.POLLERR är inte giltiga i en indata-eventmask – de är oönskade händelser som rapporteras av poll() / ipoll() oavsett om de efterfrågades eller ej (detta matchar POSIX-semantiken).

Det går bra att anropa denna metod mer än en gång för samma obj: ett efterföljande anrop uppdaterar obj:s händelsemask och beter sig som modify().

unregister(obj: Any) → None

Ta bort obj från uppsättningen registrerade strömmar. Det är inte ett fel att avregistrera ett obj som inte är registrerat för tillfället (anropet har ingen effekt i det fallet).

modify(obj: Any, eventmask: int) → None

Ändra händelsemasken för ett redan registrerat obj till eventmask. Utlöser OSError med errno.ENOENT om obj inte är registrerat.

poll(timeout: int = -1, /) → List[Tuple]

Blockera tills minst en registrerad ström blir redo eller signalerar ett undantagstillstånd, och returnera sedan listan över de strömmar som utlöstes.

timeout är den maximala tiden att vänta i millisekunder. Om det utelämnas eller är -1 blockerar anropet i obestämd tid; 0 returnerar omedelbart (en icke-blockerande pollning).

Returnerar en lista över (obj, event, ...)-tupler, en per ström som utlöstes. obj är den registrerade strömmen och event är den bitvisa OR av flaggorna select.POLLIN / select.POLLOUT / select.POLLERR / select.POLLHUP som inträffade. Varje tupel kan innehålla ytterligare implementationsdefinierade element, så anta inte en längd på exakt 2. Om timeout löper ut utan att något är redo returneras en tom lista.

select.POLLHUP och select.POLLERR kan returneras när som helst (även om de inte begärts) och måste hanteras – vanligtvis genom att avregistrera och stänga den berörda strömmen – annars kommer efterföljande anrop att fortsätta returnera omedelbart med dessa flaggor satta för den strömmen.

Eventuella väntande schemalagda återanrop garanteras köras innan pollningsloopen påbörjas.

Skillnad mot CPython

Returnerade tupler kan innehålla fler än 2 element, så som beskrivs ovan.

ipoll(timeout: int = -1, flags: int = 0, /) → Iterator[Tuple]

Som poll(), men i stället för att bygga en lista returnerar den en iterator som ger en (obj, event, ...)-tupel åt gången. Detta undviker allokering vid varje anrop, vilket är viktigt för asynkrona I/O-schemaläggare.

Den genererade tupeln är anropad-ägd: den återanvänds (skrivs över) vid nästa iteration, så dess innehåll måste konsumeras inom loopkroppen och referenser till den får inte lagras.

timeout har samma betydelse som för poll(). Om flags är 1 används engångsbeteende: en ström vars händelse utlöstes får sin händelsemask automatiskt nollställd (motsvarande poll.modify(obj, 0)), så inga ytterligare händelser rapporteras för den förrän dess mask sätts igen med modify().

Eventuella väntande schemalagda återanrop garanteras köras innan pollningsloopen påbörjas.

Skillnad mot CPython

Denna metod är en MicroPython-utökning.