Sophämtning i Python är en automatisk process som hanterar minnesallokering och -deallokering vilket säkerställer effektiv användning av minnet. Till skillnad från språk som t.ex C eller C++ där programmeraren manuellt måste allokera och avallokera minne Python hanterar automatiskt minne genom två primära strategier:

1. Referensräkning
2. Sophämtning

Referensräkning

Python använder referensräkning för att hantera minnet. Varje objekt håller reda på hur många referenser som pekar på det. När referensantalet sjunker till noll, dvs inga referenser kvarstår, avallokerar Python automatiskt objektet. Exempel:

import sys x = [1 2 3] print(sys.getrefcount(x)) y = x print(sys.getrefcount(x)) y = None print(sys.getrefcount(x)) 

2 3 2 

Förklaring:

• x refereras två gånger initialt (en gång av x en gång av getrefcount()).
• Tilldelar y = x ökar antalet.
• Miljö y = Ingen tar bort en referens.

Problem med referensräkning

Referensräkning misslyckas i närvaro av cykliska referenser, dvs objekt som refererar till varandra i en cykel. Även om inget annat pekar på dem når deras referensantal aldrig noll. Exempel:

import sys x = [1 2 3] y = [4 5 6] x.append(y) y.append(x) print(sys.getrefcount(x)) print(sys.getrefcount(y)) 

3 3 

Förklaring:

• x innehåller och och och innehåller x .
• Även efter radering x och och Python kommer inte att kunna frigöra minnet bara genom att använda referensräkning eftersom var och en fortfarande refererar till den andra.

Sophämtning för cykliska referenser

Sophämtning är en minneshanteringsteknik som används i programmeringsspråk för att automatiskt återta minne som inte längre är tillgängligt eller används av applikationen. För att hantera sådana cirkulära referenser använder Python en Sophämtare (GC) från den inbyggda gc-modulen. Denna samlare kan upptäcka och städa upp föremål som är inblandade i referenscykler.

Generationell sophämtning

Pythons Generational Garbage Collector är designad för att hantera cykliska referenser. Den organiserar föremål i tre generationer baserat på deras livslängd:

• Generation 0: Nyskapade objekt.
• Generation 1: Objekt som överlevde en insamlingscykel.
• Generation 2: Långlivade föremål.

När referenscykler inträffar upptäcker sopsamlaren automatiskt och rensar dem och frigör minnet.

Automatisk sophämtning av cykler

Sophämtning körs automatiskt när antalet tilldelningar överstiger antalet deallokeringar med en viss tröskel. Denna tröskel kan inspekteras med hjälp av gc-modulen.

import gc print(gc.get_threshold()) 

(2000 10 10) 

Förklaring: Den returnerar tröskeltuppeln för generationerna 0 1 och 2. När allokeringarna överskrider utlöses tröskelvärdet.

Manuell sophämtning

Ibland är det fördelaktigt att manuellt anropa sopsamlaren, särskilt när det gäller referenscykler. Exempel:

import gc # Create a cycle def fun(i): x = {} x[i + 1] = x return x # Trigger garbage collection c = gc.collect() print(c) for i in range(10): fun(i) c = gc.collect() print(c) 

0 10 

Förklaring:

• deff roligt(i) skapar en cyklisk referens genom att själv göra en ordboksreferens.
• gc.collect() utlöser sophämtning och lagrar antalet insamlade föremål (initialt 0).
• för i inom intervallet(10) samtal kul (i) 10 gånger skapa 10 cykliska referenser.
• gc.collect() utlöser sophämtning igen och skriver ut antalet insamlade cykler.

Typer av manuell sophämtning

• Tidsbaserad sophämtning: Sophämtaren utlöses med fasta tidsintervall.

• Händelsebaserad sophämtning: Sophämtaren anropas som svar på specifika händelser som när en användare lämnar applikationen eller när applikationen blir inaktiv.

Påtvingad sophämtning

Pythons garbage collector (GC) körs automatiskt för att rensa bort oanvända föremål. För att tvinga det manuellt använd gc.collect() från gc-modulen. Exempel:

import gc a = [1 2 3] b = {'a': 1 'b': 2} c = 'Hello world!' del abc gc.collect() 

Förklaring:

• från a b c tar bort referenser till a b och c gör dem berättigade till sophämtning.
• gc.collect() tvingar sophämtning att frigöra minne genom att rensa upp objekt som inte hänvisas till.

Inaktiverar sophämtning

I Python körs sopsamlaren automatiskt för att rensa bort objekt som inte hänvisas till. För att förhindra att det körs kan du inaktivera det med gc.disable() från gc-modulen. Exempel:

import gc gc.disable() gc.enable() 

Förklaring:

• gc.disable() inaktiverar automatisk sophämtning.
• gc.enable() återaktiverar automatisk sophämtning.

Interagerar med python sophämtare

En inbyggd mekanism som kallas Python garbage collector eliminerar automatiskt objekt som inte längre refereras för att frigöra minne och stoppa minnesläckor. Python gc-modulen erbjuder ett antal sätt att interagera med sopsamlaren som ofta körs automatiskt.

1. Aktivera och inaktivera sopsamlaren: Du kan aktivera eller inaktivera sopsamlaren med hjälp av gc. aktivera() och gc. inaktivera() funktioner respektive. Exempel :

nackdelar med internet

import gc # Disable  gc.disable() # Enable gc.enable() 

2. Framtvinga sophämtning: Du kan manuellt utlösa en sophämtning med hjälp av gc. samla() fungera. Detta kan vara användbart i fall där du vill tvinga fram omedelbar sophämtning istället för att vänta på att automatisk sophämtning ska ske.  Exempel:

import gc gc.collect() 

3. Inspektera inställningar för sophämtare: Du kan inspektera de aktuella inställningarna för sopsamlaren med hjälp av gc.get_threshold() funktion som returnerar en tupel som representerar de aktuella tröskelvärdena för generationerna 0 1 och 2.  Exempel:

import gc t = gc.get_threshold() print(t) 

(2000 10 10) 

4. Ställa in sopsamlartrösklar: Du kan ställa in tröskelvärdena för sophämtning med hjälp av gc.set_threshold() fungera. Detta gör att du manuellt kan justera trösklarna för olika generationer vilket kan påverka frekvensen av sophämtning.  Exempel:

import gc gc.set_threshold(500 5 5) t = gc.get_threshold() print(t) 

(500 5 5) 

Fördelar och nackdelar 

Låt oss utforska några av fördelarna och nackdelarna med Pythons sophämtning.