Функции json. Сохранение данных Python
Большинство программ запрашивают у пользователей информацию, например вводят личные данные, настройки игры и т.д. Когда пользователь закрывает программу или покидает ваше приложение, введенные данные лучше сохранить, чтобы пользователь не вводил их при каждом посещение. Простейший способ сохранения данных основан на использовании модуля json .
| Содержание страницы: |
|---|
| 1. Функции json.dump() и json.load() |
| 2. Сохранение и чтение данных, сгенерированных пользователем |
1. Функции json.dump() и json.load() в Python
Модуль json обеспечивает запись простых данных Python в файл и загружает данные из файла при следующем запуске программы. Формат данных json не привязан к Python, поэтому данные в этом формате могут передаваться программам, написанные на других языках программирования. Формат JSON(JavaScript Object Notation) был разработан для JavaScript, а после стал использоваться во многих языках программирования. Модуль json может использоваться для обмена данными между программами.
Приведем пример простой программы, которая сохраняет список чисел в память с помощью функции json.dump() и вторую программу, которая читает этот список c помощью функции json.load() обратно в память.
numbers = [1, 2, 3, 4, 5]
filename = 'numbers.json'
with open (filename, 'w') as f :
json.dump (numbers, f )
В начале импортируем модуль json . Затем создаем список numbers. В переменной filename присваиваем название файла, в которым будем сохранять список. Обычно для таких файлов принято использовать расширение .json , указывающее что данные хранятся в формате JSON. Затем файл открывается в режиме записи ' w '. В конце функция json.dump() сохраняет список numbers в файле 'numbers.json'.
Данная программа ничего не выводит, но если открыть папку, в которой написана программа, то там появится файл numbers.json, внутри которого хранится наш список.
[1, 2, 3, 4, 5]
Теперь напишем вторую программу, которая читает список обратно в память с помощью функции json.load().
filename = 'numbers.json'
with open (filename) as f :
numbers = json.load ( f )
print(numbers)
В начале импортируем модуль json . В переменной filename используем тот же файл, в который ранее были записаны данные 'numbers.json'. Далее файл открываем в режиме чтения. Данные с помощью функции json.load() загружаются и сохраняются в переменную numbers и с помощью функции print выводятся на экран:
[1, 2, 3, 4, 5]
Модуль json позволяет организовать простейший обмен данными между программами.
2. Сохранение и чтение данных, сгенерированных пользователем на Python
При работе с данными, сгенерированными пользователем, можно использовать модуль json . Без сохранения информация о пользователе будет потеряна при остановке программы. Приведем пример программы, которая запрашивает у пользователя имя при первом запуске и выводит его при последующих запусках программы:
name = input ("Введите ваше имя: ")
filename = 'name.json'
with open (filename, 'w') as f :
json.dump (numbers, f )
print(f"Добро пожаловать на сайт
В начале программа запрашивает имя пользователя с помощью функции input и сохраняет имя в переменной name. Далее открываем файл, находящийся в переменной filename в режиме записи ' w ' и с помощью функции json.dump() сохраняем имя пользователя в файле. Запустив эту программу, мы получим:
Введите ваше имя: Артур
Добро пожаловать на сайт Артур!
Теперь приведем пример программы, которая приветствует пользователя уже известного ей и сохраненного в файле:
with open (filename) as f :
name = json.load ( f )
print(f"С возвращением
Программа читает информация из файла 'name.json' и сохраняет в переменную name. После этого программы выводит приветствие на экран:
С возвращением Артур!
Теперь эти две программы можно объединить в одну. Когда программа будет запускаться, Python должен взять имя из файла, если это возможно, если файла 'name.json' не существует, запросить имя и сохранить на будущее. Так как в случае отсутствия файла будет возникать ошибка, воспользуемся блоком try-except.
filename = 'name.json'
try:
with open (filename) as f :
name = json.load ( f )
except FileNotFoundError:
name = input ("Введите ваше имя: ")
with open (filename, 'w') as f :
json.dump (numbers, f )
print(f"Добро пожаловать на сайт
else:
print(f"С возвращением
В начале программа пытается открыть файл 'name.json'. Если файл существует и не возникает ошибка FileNotFoundError , то выводится сообщение из блока else. Если программа запускается впервые и файла не существует, возникает ошибка и пользователю предлагают ввести имя. При первом выполнение программы результат выглядит так:
Введите ваше имя: Жак
Добро пожаловать на сайт Жак!
Keep persistent variables in memory between runs of Python script
Is there any way of keeping a result variable in memory so I don’t have to recalculate it each time I run the beginning of my script? I am doing a long (5-10 sec) series of the exact operations on a data set (which I am reading from disk) every time I run my script. This wouldn’t be too much of a problem since I’m pretty good at using the interactive editor to debug my code in between runs; however sometimes the interactive capabilities just don’t cut it.
I know I could write my results to a file on disk, but I’d like to avoid doing so if at all possible. This should be a solution which generates a variable the first time I run the script, and keeps it in memory until the shell itself is closed or until I explicitly tell it to fizzle out. Something like this:
I’ve an inkling that the shelve module might be what I’m looking for here, but looks like in order to open a shelve variable I would have to specify a file name for the persistent object, and so I’m not sure if it’s quite what I’m looking for.
Any tips on getting shelve to do what I want it to do? Any alternative ideas?
8 Answers 8
You can achieve something like this using the reload global function to re-execute your main script’s code. You will need to write a wrapper script that imports your main script, asks it for the variable it wants to cache, caches a copy of that within the wrapper script’s module scope, and then when you want (when you hit ENTER on stdin or whatever), it calls reload(yourscriptmodule) but this time passes it the cached object such that yourscript can bypass the expensive computation. Here’s a quick example.
wrapper.py
mainscript.py
While wrapper.py is running, you can edit mainscript.py , add new code to the part2 function and be able to run your new code against the pre-computed part1Cache.
To keep data in memory, the process must keep running. Memory belongs to the process running the script, NOT to the shell. The shell cannot hold memory for you.
So if you want to change your code and keep your process running, you’ll have to reload the modules when they’re changed. If any of the data in memory is an instance of a class that changes, you’ll have to find a way to convert it to an instance of the new class. It’s a bit of a mess. Not many languages were ever any good at this kind of hot patching (Common Lisp comes to mind), and there are a lot of chances for things to go wrong.
If you only want to persist one object (or object graph) for future sessions, the shelve module probably is overkill. Just pickle the object you care about. Do the work and save the pickle if you have no pickle-file, or load the pickle-file if you have one.
Python’s shelve is a persistence solution for pickled (serialized) objects and is file-based. The advantage is that it stores Python objects directly, meaning the API is pretty simple.
If you really want to avoid the disk, the technology you are looking for is a «in-memory database.» Several alternatives exist, see this SO question: in-memory database in Python.
Weirdly, none of the earlier answers here mention simple text files. The OP says they don’t like the idea, but as this is becoming a canonical for duplicates which might not have that constraint, this alternative deserves a mention. If all you need is for some text to survive between invocations of your script, save it in a regular text file.
This easily extends to more complex data structures, though then you’ll probably need to use a standard structured format like JSON or YAML (for serializing data with tree-like structures into text) or CSV (for a matrix of columns and rows containing text and/or numbers).
Ultimately, shelve and pickle are just glorified generalized versions of the same idea; but if your needs are modest, the benefits of a simple textual format which you can inspect and update in a regular text editor, and read and manipulate with ubiquitous standard tools, and easily copy and share between different Python versions and even other programming languages as well as version control systems etc, are quite compelling.
As an aside, character encoding issues are a complication which you need to plan for; but in this day and age, just use UTF-8 for all your text files.
Another caveat is that beginners are often confused about where to save the file. A common convention is to save it in the invoking user’s home directory, though that obviously means multiple users cannot share this data. Another is to save it in a shared location, but this then requires an administrator to separately grant write access to this location (except I guess on Windows; but that then comes with its own tectonic plate of other problems).
The main drawback is that text is brittle if you need multiple processes to update the file in rapid succession, and slow to handle if you have lots of data and need to update parts of it frequently. For these use cases, maybe look at a database (probably start with SQLite which is robust and nimble, and included in the Python standard library; scale up to Postgres or etc if you have entrerprise-grade needs).
And, of course, if you need to store native Python structures, shelve and pickle are still there.
Решено: как сохранить переменные локально
В мире программирования одной из важнейших задач является работа с переменными и возможность локального хранения их данных в системе. Этот процесс имеет множество применений, таких как хранение информации о конфигурации и пользовательского контента. Имея это в виду, мы углубимся в тему локального сохранения переменных с помощью Python, популярного и универсального языка программирования. В этой статье мы рассмотрим шаги, необходимые для локального хранения данных с помощью Python, изучим соответствующие библиотеки и обсудим их функции. Давайте погрузимся в эффективный и удобный мир Python для локального сохранения переменных.
Локальное хранение переменных в Python может быть выполнено с использованием многих подходов, таких как запись в файл, использование библиотеки pickle или json или через базу данных. В этой статье мы сосредоточимся на записи переменных в файл и использовании pickle и json в качестве методов сериализации. Это решение простое и может быть легко использовано в большинстве приложений.
Пошаговое объяснение кода
Чтобы сохранить переменную локально, мы создадим простую функцию для сохранения переменной в файле. Давайте сначала посмотрим на код, а затем разберем каждый шаг.
1. Во-первых, мы определяем функцию с именем `save_variable`, которая принимает два аргумента – переменную, которую вы хотите сохранить, и имя файла, в котором вы хотите ее сохранить.
2. Затем мы используем оператор `with open`, чтобы открыть файл в режиме записи (‘w’). Если файл не существует, он будет создан.
3. Внутри блока with мы преобразуем переменную в строку (если это уже не строка) с помощью функции str() и затем записываем ее в файл с помощью метода write().
4. Наконец, мы можем вызвать функцию `save_variable` с нашей переменной и именем файла в качестве аргументов, и она сохранит содержимое переменной в указанный файл.
Использование библиотеки рассола
Pickle — это удобная библиотека для сериализации и десериализации объектов Python с использованием двоичного формата. Это может быть особенно полезно при работе со сложными объектами, такими как словари или списки. Давайте рассмотрим процесс локального сохранения переменных с помощью pickle:
В этом примере нам нужно сначала импортировать библиотеку pickle. Затем мы создаем новую функцию с именем `save_with_pickle`, которая снова принимает переменную и имя файла в качестве аргументов. Основное отличие в этом примере заключается в том, что мы открываем файл в двоичном режиме (`’wb’`) и используем функцию pickle.dump() для сохранения содержимого переменной в файле.
Использование библиотеки JSON
JSON (JavaScript Object Notation) — популярный формат обмена данными, часто используемый для сохранения и передачи данных между приложениями. Библиотека JSON в Python позволяет нам кодировать объекты Python, такие как словари, списки или другие сложные структуры, в строку в формате JSON. Давайте посмотрим, как сохранить переменные локально с помощью JSON:
Здесь мы импортируем библиотеку JSON и создаем функцию с именем save_with_json. Эта функция похожа на наши предыдущие примеры, но она использует функцию `json.dump()` для сохранения содержимого переменной в строке в формате JSON в файле.
В заключение мы рассмотрели три различных метода локального сохранения переменных в Python, каждый из которых имеет свои преимущества в зависимости от конкретного варианта использования и хранимых данных. Поняв эти методы, вы сможете легко и эффективно хранить данные и управлять ими в своих проектах Python.
Лучшие способы сохранения данных в Python
Привет читатели! В этом руководстве мы будем иметь дело с тем, как мы можем эффективно сохранять данные в Python.
- Автор записи
Привет читатели! В этом руководстве мы будем иметь дело с тем, как мы можем эффективно сохранять данные в Python.
Как сохранить данные в Python?
Когда мы работаем над приложениями Python, мы будем иметь дело с объектами Python напрямую, так как все является объектом в Python. Давайте посмотрим на некоторые способы, которыми мы можем легко хранить их!
1. Использование сочинения для хранения объектов Python
Если мы хотим держать вещи простыми, мы можем использовать модуль сортировки, который является частью стандартной библиотеки для сохранения данных в Python.
Мы можем «сортировать» объекты Python в пиловый файл, который мы можем использовать для сохранения данных/загрузки данных.
Поэтому, если у вас есть пользовательский объект, который вам может потребоваться хранить/извлекать, вы можете использовать этот формат:
Если вы запускаете этот скрипт, вы заметите файл под названием data.pickle , который содержит сохраненные данные.
Чтобы снова загрузить один и тот же объект, мы могли бы использовать Pickle.Load () используя аналогичную логику.
Мы только что успешно восстановили наши старые данные!
2. Использование SQLite3 для постоянного сохранения данных в Python
Если вы хотите использовать постоянную базу данных для сохранения данных в Python, вы можете использовать SQLite3 Библиотека, которая предоставляет вам API для использования баз данных SQLite.
Опять же, это часть стандартной библиотеки, поэтому нет необходимости устанавливать ничего!
Однако, поскольку это реляционная база данных, вы не можете напрямую давить объекты Python, как в Парил Отказ
Вам придется сериализовать и десериализировать их в соответствующие типы баз данных.
Посмотрите на некоторые примеры, вы можете обратиться к этой статье на использовании SQLite в Python.
3. Использование SQLICENCT в качестве постоянного кэша
Если вы найдете использование SQLite3 Слишком утомительно, есть гораздо лучшее решение! Вы можете использовать sqlized Для хранения постоянных данных, и это внутренне использует SQLite3 база данных для обработки хранилища.
Вы должны установить этот пакет, используя PIP:
Единственное, что вы должны иметь в виду, это то, что вам нужно использовать Ключ: значение отображения для хранения/извлечения данных, как и словарь!
Вот очень простой пример, используя MyClass пример.
Действительно, мы просто загрузили наш объект Python! Если вы заметите, sqlized создаст базу данных cache.sqlite3 автоматически, если оно не существует, а затем используйте его для хранения/загрузки данных.
Заключение
В этой статье мы смотрели, как мы можем использовать Python для хранения данных по-разному.