Share
Pickles i Python är välsmakande i den meningen att de representerar ett Python-objekt som en bit av byte. Många saker kan faktiskt göras med de byte. Du kan till exempel lagra dem i en fil eller databas eller överföra dem via ett nätverk.
Den betade representationen av ett Python-objekt kallas a pickle-filen. Den betalda filen kan således användas för olika ändamål, till exempel att lagra resultat som ska användas av ett annat Python-program eller skriva säkerhetskopior. För att få det ursprungliga Python-objektet, helt enkelt unpickle den strängen av byte.
Att pissa i Python använder vi ättikslag modul. Som anges i dokumentationen:
Pickle-modulen implementerar binära protokoll för serialisering och de-serialisering av en Python-objektstruktur. "Pickling" är processen där en Python-objekthierarki omvandlas till en byte-ström och "unpickling" är den inverse operationen, varvid en byte-ström (från en binär fil eller bytesliknande objekt) omvandlas tillbaka till en objekthierarki. Pickling (och unpickling) är alternativt känt som "serialisering", "marshalling" eller "flatning"; För att undvika förvirring är de termer som används här "pickling" och "unpickling".
De ättikslag modulen tillåter oss att lagra nästan alla Python objekt direkt till en fil eller sträng utan att behöva göra några omvandlingar. Vad i ättikslag modulen som faktiskt utför är vad som är så kallat objekt serialisering, det vill säga konvertera objekt till och från strängar av byte. Objektet som ska betas kommer att serieiseras i en ström av byte som kan skrivas till en fil, till exempel, och återställas vid en senare punkt.
Accentsconagua
ättikslagDe ättikslag modulen levereras faktiskt redan med din Python-installation. För att få en lista över de installerade modulerna kan du skriva följande kommando i Python-prompten: hjälpa ( 'moduler').
Så allt du behöver göra för att jobba med ättikslag modulen är att import sallad!
Från det här avsnittet tar vi en titt på några exempel på betning för att bättre förstå konceptet. Låt oss börja med att skapa en pickle-fil från ett objekt. Vårt objekt här kommer att vara att göra lista som vi gjorde i Pythons listor handledning.
todo = ['skriv blogginlägg', 'svar på e-post', 'läs i en bok']
För att hämta vårt listobjekt (att göra) kan vi göra följande:
import pickle todo = ['skriv blogginlägg', 'svar på e-post', 'läs i en bok'] pickle_file = file ('todo.pickle', 'w') pickle.dump (todo, pickle_file)Observera att vi har gjort en import sallad för att kunna använda ättikslag modul. Vi har också skapat en pickle-fil för att lagra det betade objektet, nämligen todo.pickle. De dumpa funktionen skriver en betagd representation av att göra till det öppna filobjektet pickle_file. Med andra ord, dumpa funktionen här har två argument: objektet att beta, vilket är att göra lista och ett filobjekt där vi vill skriva pickle, vilket är todo.pickle.
Säg att vi skulle vilja unpickle (återställa) de betalda data; i vårt fall är det här att göra lista. För att göra det kan vi skriva följande skript:
importera pickle pickle_file = file ('todo.pickle') todo = pickle.load (pickle_file) print (todo)Ovanstående skript kommer att mata ut att göra listobjekt:
['skriv blogginlägg', 'svar på e-post', 'läs i en bok']
Som nämnts i dokumentationen är det belastning (fil) funktionen gör följande:
Läs en sträng från den öppna filobjektfilen och tolka den som en hämtningsdataström, rekonstruera och returnera originalobjekthierarkin. Detta motsvararUnpickler (fil) .load ().
I ovanstående avsnitt såg vi hur vi kan skriva / ladda pickles till / från en fil. Detta är emellertid inte nödvändigt. Jag menar att om vi vill skriva / ladda pickles behöver vi inte alltid hantera filer. Vi kan istället arbeta med pickles som strängar. Vi kan således göra följande:
importera pickle todo = ['skriv blogginlägg', 'svar på e-post', 'läs i en bok'] pickled_data = pickle.dumps (todo) print (pickled_data)
Observera att vi har använt soptippar (med funktionen "s" i slutet), vilket enligt dokumentationen:
Returnerar objektets pläterade representation som en sträng istället för att skriva den till en fil.
För att återställa betade data ovan kan vi använda laster (sträng) funktion, enligt följande:
restored_data = pickle.loads (pickled_data)
Enligt dokumentationen, vilken massor funktionen är det det:
Läser en häftad objekthierarki från en sträng. Tecken i strängen över det betalda objektets representation ignoreras.
I ovanstående exempel har vi behandlat betning och återställning (laddning) endast ett objekt i taget. I det här avsnittet ska jag visa hur vi kan göra det för mer än ett objekt. Säg att vi har följande föremål:
namn = 'Abder' hemsida = 'http://abder.io' english_french = 'paper': 'papper', 'penna': 'stylo', 'bil': 'voiture' # ordbok tup = "abder", 4.0) # tuple
Om du vill lära dig mer om Python-ordböcker och tuplar, kolla följande handledning:
Vi kan helt enkelt plocka upp ovanstående föremål genom att köra a serier av dumpa funktioner, enligt följande:
importera pickle name = 'Abder' hemsida = 'http://abder.io' english_french = 'papper': 'papper', 'penna': 'stylo', 'bil': 'voiture' # ordbok tup = 31, 'abder', 4.0) # tuple pickled_file = öppen ('pickled_file.pickle', 'w') pickle.dump (namn, pickled_file) pickle.dump (webbplats, pickled_file) pickle.dump (english_french, pickled_file) pickle. dumpning (tup, pickled_fil)Detta plockar alla fyra objekten i picklefilen pickled_file.pickle.
Det finns ett annat underbart sätt att skriva ovanstående skript med hjälp av Pickler klass i ättikslag modul, enligt följande:
från pickle import Pickler namn = 'Abder' hemsida = 'http://abder.io' english_french = 'papper': 'papper', 'penna': 'stylo', 'bil': 'voiture' # ordbok tup = (31, 'abder', 4.0) # tuple pickled_file = öppen ('pickled_file.pickle', 'w') p = Pickler (pickled_file) p.dump (namn); p.dump (webbplats); p.dump (english_french); p.dump (tup)För att återställa (ladda) originaldata kan vi helt enkelt använda mer än en ladda funktion, enligt följande:
import pickle pickled_file = open ('pickled_file.pickle') namn = pickle.load (pickled_file) webbplats = pickle.load (pickled_file) english_french = pickle.load (pickled_file) tup = pickle.load (pickled_file) print ('Name:' ) Skriv ut (namn) Skriv ut ('Webbplats:') Skriv ut (Webbplats) Skriv ut ('Englsh till Franska:') Skriv ut (engelska_french) Skriv ut ('Tuple data:')Utmatningen av ovanstående skript är:
Namn: Abder Webbplats: http://abder.io Englsh till Franska: 'car': 'voiture', 'pen': 'stylo', 'papper': 'papper' Tuple data: (31, 'abder' , 4,0)
Som med Pickler klass kan vi skriva om ovanstående skript med hjälp av Unpickler klass i ättikslag modul, enligt följande:
från pickle import Unpickler pickled_file = open ('pickled_file.pickle') u = Unpickler (pickled_fil) name = u.load (); webbplats = u.load (); english_french = u.load (); tup = u.load () skriv ut ('Namn:') Skriv ut (namn) Skriv ut ('Webbplats:') Skriv ut (Webbplats) Skriv ut ('Engelska till Franska:') Skriv ut (english_french) trycket (tup)Observera att variablerna måste skrivas och läsas i samma ordning för att få önskad utgång. För att undvika problem här kan vi använda en ordlista för att administrera data, enligt följande:
importera pickle name = 'Abder' hemsida = 'http://abder.io' english_french = 'papper': 'papper', 'penna': 'stylo', 'bil': 'voiture' # ordbok tup = 31, 'abder', 4.0) # tuple pickled_file = open ('pickled_file.pickle', 'w') data = 'namn': namn, 'hemsida': hemsida, 'english_french_dictionary': english_french, 'tuple': tup pickle.dump (data, pickled_fil)För att återställa (ladda) data som systade i ovanstående skript kan vi göra följande:
import pickle pickled_file = open ('pickled_file.pickle') data = pickle.load (pickled_file) namn = data ['name'] website = data ['website'] english_french = data ['english_french_dictionary'] tup = data ['tuple '' print ('Name:') Skriv ut (namn) Skriv ut ('Webbplats:') Skriv ut (Webbplats) Skriv ut ('Engelska till Franska:') Skriv ut (english_french)Tja, det verkar som en intressant kombination. Om du undrar vad Pandas är, kan du lära dig mer om dem från introduktionspandas handledning. Den grundläggande datastrukturen för pandor kallas DataFrame, en tabellformad datastruktur bestående av beställda kolumner och rader.
Låt oss ta ett exempel på DataFrame från Pandas handledning:
importera pandor som pd name_age = 'Name': ['Ali', 'Bill', 'David', 'Hany', 'Ibtisam'], 'Ålder': [32, 55, 20, 43, 30] data_frame = pd.DataFrame (name_age)
För att pickle vår DataFrame, vi kan använda to_pickle () funktion, enligt följande:
data_frame.to_pickle ( 'my_panda.pickle')
För att återställa (ladda) syltad DataFrame, vi kan använda read_pickle () funktion, enligt följande:
restore_data_frame = pd.read_pickle ('my_panda.pickle')Att sätta vad vi har nämnt i det här avsnittet tillsammans är så här det skript som plockar och laddar ett pandasobjekt ser ut som:
importera pandor som pd name_age = 'Name': ['Ali', 'Bill', 'David', 'Hany', 'Ibtisam'], 'Ålder': [32, 55, 20, 43, 30] data_frame = pd.DataFrame (name_age) data_frame.to_pickle ('my_panda.pickle') restore_data_frame = pd.read_pickle ('my_panda.pickle') print (restore_data_frame)I denna handledning har jag täckt en intressant modul kallad ättikslag. Vi har sett hur enkelt den här modulen gör att vi kan lagra Python-objekt för olika ändamål, till exempel att använda objektet med ett annat Python-program, överföra objektet över ett nätverk, spara objektet för senare användning etc. Vi kan helt enkelt plocka Python-objektet , och unpickle (ladda) det när vi vill återställa det ursprungliga objektet.
Tveka inte att se vad vi har till salu och studera på marknaden, och tveka inte att ställa några frågor och ge din värdefulla feedback genom att använda foderet nedan.
