Say I have the list score=[1,2,3,4,5] and it gets changed whilst my program is running. How could I save it to a file so that next time the program is run I can access the changed list as a list type?
I have tried:
score=[1,2,3,4,5] with open("file.txt", 'w') as f: for s in score: f.write(str(s) + 'n') with open("file.txt", 'r') as f: score = [line.rstrip('n') for line in f] print(score)
But this results in the elements in the list being strings not integers.
You can use
pickle module for that.
This module have two methods,
- Pickling(dump): Convert Python objects into string representation.
- Unpickling(load): Retrieving original objects from stored string representstion.
import pickle l = [1,2,3,4] with open("test.txt", "wb") as fp: #Pickling pickle.dump(l, fp) with open("test.txt", "rb") as fp: # Unpickling b = pickle.load(fp) b [1, 2, 3, 4]
- dump/dumps: Serialize
- load/loads: Deserialize
import json with open("test.txt", "w") as fp: json.dump(l, fp) ... with open("test.txt", "r") as fp: b = json.load(fp) ... b [1, 2, 3, 4]
I decided I didn’t want to use a pickle because I wanted to be able to open the text file and change its contents easily during testing. Therefore, I did this:
score = [1,2,3,4,5] with open("file.txt", "w") as f: for s in score: f.write(str(s) +"n")
score =  with open("file.txt", "r") as f: for line in f: score.append(int(line.strip()))
So the items in the file are read as integers, despite being stored to the file as strings.
Although the accepted answer works, you should really be using python’s
import json score=[1,2,3,4,5] with open("file.json", 'w') as f: # indent=2 is not needed but makes the file human-readable json.dump(score, f, indent=2) with open("file.json", 'r') as f: score = json.load(f) print(score)
jsonis a widely adopted and standardized data format, so non-python programs can easily read and understand the json files
jsonfiles are human-readable
- Any nested or non-nested list/dictionary structure can be saved to a
jsonfile (as long as all the contents are serializable).
- The data is stored in plain-text (ie it’s uncompressed), which makes it a slow and bloated option for large amounts of data (ie probably a bad option for storing large numpy arrays, that’s what
- The contents of a list/dictionary need to be serializable before you can save it as a json, so while you can save things like strings, ints, and floats, you’ll need to write custom serialization and deserialization code to save objects, classes, and functions
When to use
- If you want to store something you know you’re only ever going to use in the context of a python program, use
- If you need to save data that isn’t serializable by default (ie objects), save yourself the trouble and use
- If you need a platform agnostic solution, use
- If you need to be able to inspect and edit the data directly, use
Common use cases:
- Configuration files (for example,
package.jsonfile to track project details, dependencies, scripts, etc …)
jsonto transmit and receive data
- Data that requires a nested list/dictionary structure, or requires variable length lists/dicts
- Can be an alternative to
If you don’t want to use pickle, you can store the list as text and then evaluate it:
data = [0,1,2,3,4,5] with open("test.txt", "w") as file: file.write(str(data)) with open("test.txt", "r") as file: data2 = eval(file.readline()) # Let's see if data and types are same. print(data, type(data), type(data)) print(data2, type(data2), type(data2))
[0, 1, 2, 3, 4, 5] class ‘list’ class ‘int’
[0, 1, 2, 3, 4, 5] class ‘list’ class ‘int’
If you want you can use numpy’s save function to save the list as file.
Say you have two lists
here’s the function to save the list as file, remember you need to keep the extension .npy
def saveList(myList,filename): # the filename should mention the extension 'npy' np.save(filename,myList) print("Saved successfully!")
and here’s the function to load the file into a list
def loadList(filename): # the filename should mention the extension 'npy' tempNumpyArray=np.load(filename) return tempNumpyArray.tolist()
a working example
'sampleList1.npy') Saved successfully! saveList(sampleList2,'sampleList2.npy') Saved successfully! # loading the list now loadedList1=loadList('sampleList1.npy') loadedList2=loadList('sampleList2.npy') loadedList1==sampleList1 True print(loadedList1,sampleList1) ['z', 'x', 'a', 'b'] ['z', 'x', 'a', 'b']saveList(sampleList1,
pickle and other serialization packages work. So does writing it to a
.py file that you can then import.
1,2,3,4,5] with open('file.py', 'w') as f: f.write('score = %s' % score) from file import score as my_list print(my_list) [1, 2, 3, 4, 5]score = [
What I did not like with many answers is that it makes way too many system calls by writing to the file line per line. Imho it is best to join list with ‘n’ (line return) and then write it only once to the file:
mylist = ["abc", "def", "ghi"] myfile = "file.txt" with open(myfile, 'w') as f: f.write("n".join(mylist))
and then to open it and get your list again:
with open(myfile, 'r') as f: mystring = f.read() my_list = mystring.split("n")
I am using pandas.
import pandas as pd x = pd.Series([1,2,3,4,5]) x.to_excel('temp.xlsx') y = list(pd.read_excel('temp.xlsx')) print(y)
Use this if you are anyway importing pandas for other computations.