Sina.com, Китай

Метод соления продуктов стал настоящим открытием, поскольку позволил увеличить время их хранения. А еще такие продукты очень вкусные и пробуждают аппетит одним своим видом, отмечает пользователь «Сины». Засаливают их не только в Китае. Например, Россия славится своими солеными огурцами, пишет он.

Летом весьма жарко, поэтому у многих пропадает аппетит. Но если говорить о соленых овощах, то их можно назвать отличным дополнением к рису. Соленья невероятно стимулируют аппетит. Когда я был маленьким, я очень любил добавлять в рис соленый тофу, получалось очень вкусно и пробуждало аппетит. Соленья — это засоленные овощи. В прежние времена, поскольку не существовало нынешних условий для хранения продуктов, срок хранения овощей был небольшим, и они очень быстро портились. В результате кто-то догадался использовать соль для обработки продуктов, что приводило к снижению активности воды внутри овощей и повышению осмотического давления, тем самым подавлялись процессы ферментации и развития микроорганизмов. Это позволило хранить овощи намного дольше.

Позже, поскольку обнаружилось, что засоленные продукты очень вкусные и повышают аппетит, они стали важной составляющей каждого обеденного стола. Такой процесс обработки продуктов на самом деле позволяет большому количеству соли проникать в их структуру, благодаря чему становится возможным увеличить их срок хранения. Засаливают не только овощи, но и мясо, яйца и другие продукты. Многие знают, что в засоленных яйцах, особенно в утиных, именно желток и желтое масло пробуждают аппетит у людей, как только они их увидят. Засаливают продукты не только в Китае, в зарубежных странах также имеются собственные соленья. Пробовали ли вы их? Сегодня я познакомлю вас с соленьями нескольких стран: русскими солеными огурцами, корейским кимчи и другими соленьями.

Русские соленые огурцы: по мнению многих, русские — это «воинственный народ», они очень сильные, и с ними невозможно справиться. Но на самом деле русские очень мягкие и очень требовательны к еде. В России также есть свои соленья — соленые огурцы. Русские очень ими гордятся. Когда кто-нибудь приходит к ним в гости домой, они непременно с гордостью говорят: «Вы наверняка никогда в жизни не пробовали таких вкусных солений». Те, кто хоть однажды попробовал русские соленые огурцы, отзываются о них очень хорошо: они и кислые, и пряные, и очень ароматные, и соленые, а сами по себе хрустящие и нежные, поэтому не только изумительно вкусные и освежающие, но и питательные вещества в огурцах таким образом намного лучше усваиваются организмом. Они — обязательное украшение для многих холодных блюд.

Южнокорейское кимчи: говоря о Южной Корее, все мы знаем, что она — «королевство кимчи». Не важно, что вы едите, все равно в вашем блюде будет присутствовать кимчи.

Когда мы смотрим корейские дорамы, наиболее часто на экране мы видим как раз кимчи. Корейское кимчи в основном делается из овощей, различных фруктов, морепродуктов и мяса, и к ним добавляется рыбный соус для ферментации ингредиентов. Кимчи имеет высокую пищевую ценность и богато витаминами, кальцием, фосфором и другими неорганическими веществами и минералами, а также содержит более десяти видов аминокислот, необходимых организму человека. Кимчи отлично подходит к рису, а также в качестве закуски к выпивке, не только легко усваивается, но и освежает. Зимний сезон в Южной Корее очень холодный и продолжительный, а кимчи — это лучший выбор для зимы.

Немецкая кисло-сладкая квашеная капуста: пища иностранцев, в отличие от китайской еды, она не такая соленая, острая и тяжелая для желудка, но они тоже любят есть кисло-сладкую еду. Как все мы знаем, капуста — это очень распространенный овощ, который обычно используется в салатах и холодных закусках. В Германии немцы очень любят засаливать краснокочанную капусту — это и есть их знаменитая квашеная капуста. Вареная капуста более эффективна при раковых заболеваниях, чем сырая, к тому же выделяется еще больше защитных антиоксидантов. Немцы едят кисло-сладкую капусту вместе с их известными жирными колбасами или свиной рулькой, что не только смягчает жирность, но и невероятно вкусно само по себе. Кисло-сладкая квашеная капуста в Германии присутствует на столе почти при каждом приеме пищи.

Материалы ИноСМИ содержат оценки исключительно зарубежных СМИ и не отражают позицию редакции ИноСМИ.

соление — Викисловарь

Морфологические и синтаксические свойства[править]

со-ле́-ни·е

Существительное, неодушевлённое, средний род, 2-е склонение (тип склонения 7a по классификации А. А. Зализняка).

Корень: -сол-; суффикс: -ениj; окончание: -е ^{[Тихонов, 1996]}.

Произношение[править]

• МФА: [sɐˈlʲenʲɪɪ̯ə]

Семантические свойства[править]

Значение[править]

1. Действие по глаголу солить ◆ им прежде всего хотелось насолить начальству, не обращая внимания на то, что за это соление будет расплачиваться их собственная шкура Д. И. Писарев, «Погибшие и погибающие» ◆ Что касается соления, то белые грибы практически не солят В. А. Солоухин, «Третья охота»
2. (также соле́нье) Пищевой продукт, засоленный впрок ◆ Какие запасы там были варений, солений, печений И. А. Гончаров, «Обломов»

Синонимы[править]

1. засолка

Антонимы[править]

Гиперонимы[править]

Гипонимы[править]

Родственные слова[править]

Этимология[править]

Происходит от ??

Фразеологизмы и устойчивые сочетания[править]

Перевод[править]

Анаграммы[править]

Библиография[править]

солить — Викисловарь

Морфологические и синтаксические свойства[править]

со-ли́ть

Глагол, несовершенный вид, переходный, тип спряжения по классификации А. Зализняка — 4c. Соответствующие глаголы совершенного вида — приставочные типа посолить, засолить. Встречается также вариант спряжения по схеме 4b: формы наст. вр. — соли́шь, соли́т, соли́м, соли́те, соля́т.

Корень: -сол-; суффикс: -и; глагольное окончание: -ть ^{[Тихонов, 1996]}.

Произношение[править]

Семантические свойства[править]

Значение[править]

1. посыпа́ть, добавлять поваренную соль (в пищу) ◆ ― Солите, солите, батюшка, ― сказала хозяйка, придвигая солонку. М. М. Зощенко, «Хозрасчет», 1924 г. (цитата из Национального корпуса русского языка, см. Список литературы) ◆ Потом сыр формуют, прессуют, солят и оставляют созревать. О. Либкин, «Вы любите ли сыр?» // «Химия и жизнь», 1968 г. (цитата из Национального корпуса русского языка, см. Список литературы) ◆ Мы хлеб солили крупной солью, // и на ходу, легко дыша, // мы с этим хлебом ели сою // и пили воду из ковша. Б. П. Корнилов, «Мы хлеб солили крупной солью…», 1933 г. (цитата из Национального корпуса русского языка, см. Список литературы)
2. консервировать, заготовлять впрок с солью, в солёном растворе ◆ Она езжала по работам, // Солила на зиму грибы, // Вела расходы, брила лбы, // Ходила в баню по субботам… А. С. Пушкин, «Евгений Онегин», Глава вторая, 1823 г. (цитата из Национального корпуса русского языка, см. Список литературы) ◆ Он варил варенье и солил на зиму огурцы. И. Меттер, «Пятый угол», 1967 г. (цитата из Национального корпуса русского языка, см. Список литературы)
3. перен., разг. вредить ◆ ― Брешет Степка! Это он за Гришку мне солит. М. А. Шолохов, «Тихий Дон», Книга вторая, 1928-1940 г. (цитата из Национального корпуса русского языка, см. Список литературы)

Синонимы[править]

Антонимы[править]

1. —
2. —

Гиперонимы[править]

1. добавлять
2. консервировать
3. вредить

Гипонимы[править]

Родственные слова[править]

Этимология[править]

Происходит от сущ. соль, далее из праслав. *solь, от кот. в числе прочего произошли: др.-русск., ст.-слав. соль (др.-греч. ἅλς), русск. соль, укр. сіль (род. п. со́ли), болг. сол, сербохорв. со̑ (род. п. со̏ли), словенск. sọ̑l (род. п. solȋ), чешск. sůl, словацк. sоľ, польск. sól (род. п. soli), в.-луж. sól, sel, н.-луж. sol; восходит к праиндоевр. *sal-. Отсюда же др.-лат. sаlе, арм. аɫ, тв. ед. aɫiw. Родственно др.-прусск. sаl (по мнению Брюкнера, заимств. из слав.), латышск. sā̀ls «соль», лит. sólymas «рассол», латышск. местн. н. Sаlасе, лат. sāl (род. п. salis ср. р., греч. ἅλς м. «соль», ж. «море», др.-ирл. salann, готск. salt «соль», тохар. А sāle, В salyi, далее сюда же соло́дкий, со́лоть. Сюда же Хюбшман относит название реки Ώ ́Аʎυς (Малая Азия). В составе местн. нн. обозначало первонач. «солёный источник», ср. Солига́лич, Солика́мск, Сольвычего́дск. Отсюда же прагерманск. *saltan (ср.: др.-англ. sealt, англ. salt, нем. Salz и т. п. Использованы данные словаря М. Фасмера. См. Список литературы.

Фразеологизмы и устойчивые сочетания[править]

Перевод[править]

Анаграммы[править]

Библиография[править]

pickle и cPickle — сериализация объектов Python

Модуль рассола реализует алгоритм поворота произвольный объект Python в серию байтов. Этот процесс также называется сериализации »объекта. Поток байтов, представляющий объект может быть передан или сохранен, а затем реконструирован в создать новый объект с такими же характеристиками.

Модуль cPickle реализует тот же алгоритм, вместо C Python. Это во много раз быстрее, чем реализация Python, но не позволяет пользователю создавать подклассы из Pickle. Если подклассы не важно для вашего использования, вы, вероятно, хотите использовать cPickle.

Предупреждение

Документация на рассол дает понять, что он не обеспечивает безопасность гарантии. Будьте осторожны, если вы используете рассол для межпроцессного взаимодействия или хранилище данных. Не доверяйте данным, которые не можете подтвердить как безопасные.

Импорт

Обычно сначала пытаются импортировать cPickle, давая псевдоним «соленый огурец». Если этот импорт не удастся по какой-либо причине, вы можете отступить на нативной реализации Python в модуле pickle. Это дает Вы более быстрое внедрение, если оно доступно, и портативный реализация в противном случае.

 попробуй:
   импорт cPickle как рассол
Кроме:
   импортный рассол
 

Кодирование и декодирование данных в строках

Этот первый пример кодирует структуру данных в виде строки, а затем печатает строка в консоль.Он использует структуру данных, состоящую из полностью родные типы. Экземпляры любого класса можно мариновать, так как быть проиллюстрировано в следующем примере. Используйте pickle.dumps (), чтобы создать строковое представление значения объекта.

 попробуй:
    импорт cPickle как рассол
Кроме:
    импортный рассол
импортировать отпечаток

data = [{'a': 'A', 'b': 2, 'c': 3.0}]
выведите «DATA:»,
pprint.pprint (данные)

data_string = pickle.dumps (data)
выведите 'PICKLE:', data_string
 

По умолчанию, рассол будет содержать только символы ASCII.Еще эффективный двоичный формат также доступен, но все примеры здесь используется вывод ASCII, потому что это легче понять при печати.

 $ python pickle_string.py

ДАННЫЕ: [{'a': 'A', 'b': 2, 'c': 3.0}]
PICKLE: (lp1
(DP2
S'A»
S'A»
sS'c»
F3
sS'b»
I2
подлежит утверждению
 

После сериализации данных вы можете записать их в файл, сокет, канал и т. Д. Затем вы можете прочитать файл и распаковать данные, чтобы создать новый объект с одинаковыми значениями.

 попробуй:
    импорт cPickle как рассол
Кроме:
    импортный рассол
импортировать отпечаток

data1 = [{'a': 'A', 'b': 2, 'c': 3.0}]
напечатайте «ДО:»,
pprint.pprint (data1)

data1_string = pickle.dumps (data1)

data2 = pickle.loads (data1_string)
распечатать «ПОСЛЕ:»,
pprint.pprint (data2)

выведите «SAME ?:», (data1 - data2)
выведите «EQUAL ?:», (data1 == data2)
 

Как видите, вновь построенный объект равен, но не одинаков объект как оригинал. Там нет ничего удивительного.

 $ питон pickle_unpickle.py

ДО: [{'a': 'A', 'b': 2, 'c': 3.0}]
ПОСЛЕ: [{'a': 'A', 'b': 2, 'c': 3.0}]
ЖЕ? Ложь
РАВНО ?: Правда
 

Работа с потоками

В дополнение к dumps () и load (), pickle предоставляет пару удобных функций для работы с файловыми потоками.это можно записать несколько объектов в поток, а затем прочитать их из потока, не зная заранее, сколько объектов написано или насколько они велики.

 попробуй:
    импорт cPickle как рассол
Кроме:
    импортный рассол
импортировать отпечаток
из StringIO импортировать StringIO

Класс SimpleObject (объект):

    def __init __ (self, name):
        self.name = имя
        l = список (имя)
        l.reverse ()
        self.name_backwards = '' .join (l)
        возвращение

данные = []
data.append (SimpleObject ( 'рассол'))
данные.Append (SimpleObject ( 'cPickle'))
data.append (SimpleObject ( 'последний'))

# Имитация файла с помощью StringIO
out_s = StringIO ()

# Запись в поток
для o в данных:
    выведите «WRITING:% s (% s)»% (o.name, o.name_backwards)
    pickle.dump (o, out_s)
    out_s.flush ()

# Настройка читаемого потока
in_s = StringIO (out_s.getvalue ())

# Читайте данные
пока верно:
    пытаться:
        o = pickle.load (in_s)
    кроме EOFError:
        перерыв
    еще:
        выведите «READ:% s (% s)»% (o.name, o.name_backwards)
 

Пример имитирует потоки с использованием буферов StringIO, поэтому мы должны поиграйте в хитрость, чтобы установить читаемый поток.Простой формат базы данных может также использовать соленья для хранения объектов, хотя с полкой было бы легче работать.

 $ python pickle_stream.py

ПИСЬМО: маринованные (elkcip)
ПИСЬМО: cPickle (elkciPc)
ПИСЬМО: последнее (цал)
ЧИТАЙТЕ: рассол (elkcip)
ЧИТАЙТЕ: cPickle (elkciPc)
ЧИТАЙТЕ: последний (ЦАЛ)
 

Помимо хранения данных, соленья очень удобны для межпроцессного коммуникации. Например, используя os.fork () и os.pipe (), один может установить рабочие процессы, которые читают рабочие инструкции из одного труба и записать результаты в другой трубе.Основной код для управления рабочий пул и отправка заданий и получение ответов могут быть повторное использование, поскольку объекты задания и ответа не обязательно должны быть особый класс. Если вы используете трубы или розетки, не забудьте очистить после сброса каждого объекта, чтобы протолкнуть данные через подключение к другому концу. Смотрите многопроцессорность, если вы не хочу написать свой собственный менеджер пула рабочих.

Проблемы реконструкции объектов

При работе с собственными классами вы должны убедиться, что Маринованный появляется в пространстве имен процесса чтения рассола.Только данные для экземпляра засолены, а не определение класса. Имя класса используется, чтобы найти конструктор для создания нового объекта при расслоении. принимать этот пример, который записывает экземпляры класса в файл:

 попробуй:
    импорт cPickle как рассол
Кроме:
    импортный рассол
импорт системы

Класс SimpleObject (объект):

    def __init __ (self, name):
        self.name = имя
        l = список (имя)
        l.reverse ()
        self.name_backwards = '' .join (l)
        возвращение

если __name__ == '__main__':
    данные = []
    данные.Append (SimpleObject ( 'рассол'))
    data.append (SimpleObject ( 'cPickle'))
    data.append (SimpleObject ( 'последний'))

    пытаться:
        filename = sys.argv [1]
    кроме IndexError:
        поднять RuntimeError ('Пожалуйста, укажите имя файла в качестве аргумента для% s'% sys.argv [0])

    out_s = open (имя файла, 'wb')
    пытаться:
        # Запись в поток
        для o в данных:
            выведите «WRITING:% s (% s)»% (o.name, o.name_backwards)
            pickle.dump (o, out_s)
    Ну наконец то:
        out_s.close ()
 

При запуске сценарий создает файл на основе имени, заданного как аргумент в командной строке:

 $ питон pickle_dump_to_file_1.py test.dat

ПИСЬМО: маринованные (elkcip)
ПИСЬМО: cPickle (elkciPc)
ПИСЬМО: последнее (цал)
 

Упрощенная попытка загрузить полученные маринованные объекты не удалась:

 попробуй:
    импорт cPickle как рассол
Кроме:
    импортный рассол
импортировать отпечаток
из StringIO импортировать StringIO
импорт системы


пытаться:
    filename = sys.argv [1]
кроме IndexError:
    поднять RuntimeError ('Пожалуйста, укажите имя файла в качестве аргумента для% s'% sys.argv [0])

in_s = open (имя файла, 'rb')
пытаться:
    # Читайте данные
    пока верно:
        пытаться:
            o = рассол.нагрузка (in_s)
        кроме EOFError:
            перерыв
        еще:
            выведите «READ:% s (% s)»% (o.name, o.name_backwards)
Ну наконец то:
    in_s.close ()
 

Эта версия завершается сбоем из-за отсутствия класса SimpleObject:

 $ python pickle_load_from_file_1.py test.dat

Traceback (последний вызов был последним):
  Файл "pickle_load_from_file_1.py", строка 52, в 
    o = pickle.load (in_s)
AttributeError: у объекта 'module' нет атрибута 'SimpleObject'
 

Исправленная версия, которая импортирует SimpleObject из оригинала сценарий, успешно.

добавить:

 из pickle_dump_to_file_1 import SimpleObject
 

до конца списка импорта, затем повторно запустите сценарий:

 $ python pickle_load_from_file_2.py test.dat

ЧИТАЙТЕ: рассол (elkcip)
ЧИТАЙТЕ: cPickle (elkciPc)
ЧИТАЙТЕ: последний (ЦАЛ)
 

При выборе типов данных с значения, которые нельзя выбрать (сокеты, дескрипторы файлов, база данных соединения и т. д.). Классы, которые используют значения, которые не могут быть выбраны можно определить __getstate __ () и __setstate __ () для возврата подмножество состояния экземпляра, подлежащего травлению.Уроки нового стиля также может определять __getnewargs __ (), который должен возвращать аргументы передаваться распределителю памяти класса (C .__ new __ ()). Использование эти функции более подробно описаны в стандартной библиотеке документация.

Циркулярные ссылки

Протокол рассола автоматически обрабатывает циклические ссылки между объекты, поэтому вам не нужно делать ничего особенного со сложными данными структур. Рассмотрим орграф:

Несмотря на то, что график включает в себя несколько циклов, правильная структура можно мариновать, а затем перезагрузить.

 импортный рассол

Класс Node (объект):
    "" "Простой орграф, где каждый узел знает о других узлах
    Это ведет к.
    «»»
    def __init __ (self, name):
        self.name = имя
        self.connections = []
        возвращение

    def add_edge (self, node):
        «Создать грань между этим узлом и другим».
        self.connections.append (узел)
        возвращение

    def __iter __ (self):
        вернуть iter (self.connections)

def preorder_traversal (корень, видел = нет, родитель = нет):
    "" "Функция генератора для выдачи ребер с помощью обхода предварительного заказа.«»»
    если видно нет:
        seen = set ()
    yield (родитель, корень)
    если root виден:
        возвращение
    seen.add (корень)
    для узла в корне:
        for (родитель, подузел) в preorder_traversal (узел, видимый, корень):
            yield (родитель, подузел)
    возвращение
    
def show_edges (root):
    «Распечатать все ребра на графике».
    для родителя, потомка в preorder_traversal (root):
        если не родитель:
            Продолжать
        напечатать "% 5s ->% 2s (% s)"% (имя-родителя, имя-ребенка, идентификатор (потомок))

# Настройте узлы.root = Node ('root')
a = узел ('a')
b = узел ('b')
c = узел ('c')

# Добавить ребра между ними.
root.add_edge (а)
root.add_edge (б)
a.add_edge (б)
b.add_edge (а)
b.add_edge (с)
a.add_edge (а)

печать "ОРИГИНАЛЬНЫЙ ГРАФ:"
show_edges (корень)

# Pickle и распаковать график для создания
# новый набор узлов.
dumped = pickle.dumps (root)
reloaded = pickle.loads (сброшено)

Распечатать
печать «Перезаписанный граф:»
show_edges (перезагружается)
 

Перезагруженные узлы — это не один и тот же объект, но отношение между узлами поддерживается и только одна копия объекта с множественная ссылка перезагружена.Оба эти утверждения могут быть проверяется путем изучения значений id () для узлов до и после прохождения через рассол.

 $ python pickle_cycle.py

ОРИГИНАЛЬНЫЙ ГРАФ:
 root -> a (4299721744)
    а -> б (4299721808)
    b -> a (4299721744)
    b -> c (4299721872)
    а -> а (4299721744)
 корень -> b (4299721808)

ПЕРЕГРУЖЕННЫЙ ГРАФ:
 root -> a (4299722000)
    а -> б (4299722064)
    b -> a (4299722000)
    b -> c (4299722128)
    а -> а (4299722000)
 root -> b (4299722064)
 

Python Pickle Tutorial — DataCamp

Как специалист по данным, вы будете использовать наборы данных в виде словарей, фреймов данных или любых других типов данных. При работе с ними вы, возможно, захотите сохранить их в файл, чтобы потом их можно было использовать или отправить кому-то еще. Для этого и предназначен модуль Python pickle : он сериализует объекты, чтобы их можно было сохранить в файл и затем снова загрузить в программу.

В этом уроке вы затронете следующие темы:

Если вы хотите узнать больше о том, как импортировать данные в Python, обязательно ознакомьтесь с нашим курсом «Импорт данных в Python» и соответствующей шпаргалкой.

Что такое травление?

Pickle используется для сериализации и десериализации структур объектов Python, также называемых сортировкой или выравниванием. Сериализация относится к процессу преобразования объекта в памяти в поток байтов, который можно сохранить на диске или отправить по сети. Позже этот поток символов можно затем извлечь и десериализовать обратно в объект Python. Травление не следует путать со сжатием! Первый — это преобразование объекта из одного представления (данные в оперативной памяти (ОЗУ)) в другое (текст на диске), а второй — это процесс кодирования данных с меньшим количеством битов, чтобы сэкономить место на диске.

Что можно делать с маринованными огурцами?

Pickling полезен для приложений, где вам нужна некоторая степень сохранности ваших данных. Данные о состоянии вашей программы могут быть сохранены на диск, чтобы вы могли продолжить работу с ними позже. Его также можно использовать для отправки данных по протоколу управления передачей (TCP) или через сокет или для хранения объектов python в базе данных. Pickle очень полезен, когда вы работаете с алгоритмами машинного обучения, где вы хотите сохранить их, чтобы иметь возможность делать новые прогнозы позднее, без необходимости переписывать все или тренировать модель заново.

Когда не использовать мариновать

Если вы хотите использовать данные на разных языках программирования, мариновать не рекомендуется. Его протокол специфичен для Python, поэтому совместимость между языками не гарантируется. То же самое верно для разных версий самого Python. Отмена выбора файла, который был выбран в другой версии Python, может не всегда работать должным образом, поэтому вы должны убедиться, что вы используете ту же версию и выполнить обновление, если это необходимо. Вы также должны стараться не извлекать данные из ненадежного источника.Вредоносный код внутри файла может быть выполнен после удаления.

Хранение данных с рассолом

Что можно мариновать?

Можно выбирать объекты со следующими типами данных:

• Booleans,
• целых числа,
• Поплавки,
• Комплексные числа,
• (обычный и Unicode) строки,
• Кортежи,
• списков,
• комплектов и
• Словари, которые содержат кражи объектов.

Все вышеперечисленное может быть рассмотрено, но вы также можете сделать то же самое для классов и функций, например, если они определены на верхнем уровне модуля.

Однако не все может быть легко (легко) рассмотрено: примерами этого являются генераторы, внутренние классы, лямбда-функции и defaultdicts. В случае лямбда-функций вам необходимо использовать дополнительный пакет с именем и . С defaultdicts вам нужно создать их с помощью функции уровня модуля.

Пикл против JSON

JSON означает JavaScript Object Notation. Это легкий формат для обмена данными, который легко читается человеком. Хотя он был создан на основе JavaScript, JSON стандартизирован и не зависит от языка.Это серьезное преимущество перед рассолом. Это также более безопасно и намного быстрее чем рассол.

Однако, если вам нужно только использовать Python, то модуль pickle по-прежнему является хорошим выбором благодаря простоте использования и возможности восстановления завершенных объектов Python.

Альтернативой является cPickle. Он почти идентичен Pickle , но написан на C, что делает его в 1000 раз быстрее. Для небольших файлов, однако, вы не заметите разницу в скорости. Оба генерируют одинаковые потоки данных, что означает, что Pickle и cPickle могут использовать одни и те же файлы.

Файлы травления

Чтобы использовать pickle, начните с импорта его в Python.

  импортный рассол
  

Для этого урока вы выберете простой словарь. Словарь представляет собой список из ключей: значение элементов. Вы сохраните его в файл, а затем загрузите снова. Объявить словарь таким:

  dogs_dict = {'Оззи': 3, 'Филу': 8, 'Луна': 5, 'Скиппи': 10, 'Барко': 12, 'Балу': 9, 'Лайка': 16}
  

Чтобы выбрать этот словарь, сначала нужно указать имя файла, в который вы его запишите, в данном случае это собак .

Обратите внимание, , что файл не имеет расширения.

Чтобы открыть файл для записи, просто используйте функцию open () . Первым аргументом должно быть имя вашего файла. Второй аргумент — 'wb' . w означает, что вы будете записывать в файл, а b относится к двоичному режиму. Это означает, что данные будут записаны в виде байтовых объектов. Если вы забудете b , то ошибка TypeError: должна быть str, а не байтов.Иногда вы можете встретить немного другое обозначение; w + b , но не волнуйтесь, он обеспечивает ту же функциональность.

  filename = 'dogs'
outfile = open (имя файла, 'wb')
  

После того, как файл открыт для записи, вы можете использовать pickle.dump () , который принимает два аргумента: объект, который вы хотите выбрать, и файл, в который объект должен быть сохранен. В этом случае первый будет dogs_dict , а второй будет outfile .

Не забудьте закрыть файл с close () !

  pickle.dump (dogs_dict, outfile)
outfile.close ()
  

Теперь новый файл с именем dogs должен появиться в том же каталоге, что и ваш скрипт Python (если вы не указали путь к файлу в качестве имени файла).

Распыление файлов

Процесс загрузки маринованного файла обратно в программу Python похож на тот, который вы видели ранее: снова используйте функцию open () , но на этот раз с 'rb' в качестве второго аргумента (вместо wb ) ). r обозначает режим чтения, а b обозначает двоичный режим. Вы будете читать бинарный файл. Назначьте это infile . Затем используйте pickle.load () , с infile в качестве аргумента и присвойте его new_dict . Содержимое файла теперь присвоено этой новой переменной. Опять же, вам нужно закрыть файл в конце.

  infile = open (имя файла, 'rb')
new_dict = pickle.load (infile)
infile.close ()
  

Чтобы убедиться, что вы успешно удалили его, вы можете напечатать словарь, сравнить его с предыдущим словарем и проверить его тип с помощью type () .

  печать (new_dict)
печать (new_dict == dogs_dict)
печать (тип (new_dict))
  

  {'Оззи': 3, 'Филу': 8, 'Луна': 5, 'Скиппи': 10, 'Барко': 12, 'Балу': 9, 'Лайка': 16}
Правда
<класс 'dict'>
  

Сжатие маринованных файлов

Если вы сохраняете большой набор данных и ваш маринованный файл занимает много места, вы можете сжать его. Это можно сделать с помощью bzip2 или gzip . Они оба сжимают файлы, но bzip2 немного медленнее. gzip , однако, создает файлы примерно в два раза больше, чем bzip2 . В этом уроке вы будете использовать bzip2 .

Помните, , что сжатие и сериализация не то же самое! Вы можете вернуться к началу урока, чтобы обновить память, если это необходимо.

Начните с импорта bzip2 с импортом bz2 . Импорт маринованных огурцов выполняется так же, как и в начале этого урока.

  импорт bz2
импортный рассол

sfile = bz2.BZ2File ('smallfile', 'w')
pickle.dump (dogs_dict, sfile)
  

Должен появиться новый файл с именем smallfile . Имейте в виду, что разница в размере файла по сравнению с несжатой версией не будет заметна с небольшими объектными структурами.

Открепление объектов Python 2 в Python 3

Иногда вы можете столкнуться с объектами, которые были протравлены в Python 2 во время работы с Python 3. Это может быть проблемой, чтобы расчесать.

Вы можете либо распаковать его, запустив Python 2, либо сделать это в Python 3 с кодировкой = 'latin1' в функции load () .

  infile = open (имя файла, 'rb')
new_dict = pickle.load (infile, encoding = 'latin1')
  

Это не будет работать, если ваши объекты содержат массивы NumPy. В этом случае вы также можете попробовать использовать encoding = 'bytes' :

  infile = open (имя файла, 'rb')
new_dict = pickle.load (infile, encoding = 'bytes')
  

Рассол и многопроцессорная обработка

Когда необходимо выполнить очень сложные вычисления, обычно распределяют эту задачу по нескольким процессам.Многопроцессорная обработка означает, что несколько процессов выполняются одновременно, обычно над несколькими центральными процессорами (ЦП) или ядрами ЦП, что экономит время. Примером является обучение моделей машинного обучения или нейронных сетей, которые являются интенсивными и трудоемкими процессами. Распределяя их по большому количеству единиц обработки, можно сэкономить много времени. В Python это делается с помощью многопроцессорного пакета .

Адаптировано из графики, представленной здесь.

Когда задача разделена на несколько процессов, им может потребоваться обмен данными. Процессы не разделяют пространство памяти, поэтому, когда им приходится отправлять информацию друг другу, они используют сериализацию, которая выполняется с использованием модуля Pickle .

В следующем примере мой импорт с многопроцессорной обработкой начинается с mp и cos с по математике . Затем создайте абстракцию Pool , где вы можете указать количество используемых процессоров. Pool будет обрабатывать многопроцессорность в фоновом режиме. Затем вы можете отобразить функцию cos в диапазоне от 10 до пула , чтобы ее можно было выполнить.

  импорт многопроцессорной как MP
из математического импорта, потому что

p = mp.Pool (2)

p.map (cos, range (10))
  

  [1,0,
 +0,5403023058681398,
 -0,4161468365471424,
 -0,9899924966004454,
 -0,6536436208636119,
 +0,2836621854632263,
 +0,9601702866503661,
 +0,75343433046,
 -0,14550003380861354,
 -0.9111302618846769]
  

Как видите, функция cos отлично выполнена. Однако это не всегда будет работать. Помните, что лямбда-функции нельзя мариновать. Поэтому, если вы попытаетесь применить многопроцессорную обработку к лямбда-функции, она потерпит неудачу.

  p.map (лямбда х: 2 ** х, диапазон (10))
  

  PicklingError: Невозможно засечь  в 0x111d0a7b8>: поиск атрибута  в __main__ не выполнен
  

Для этого есть решение. Укроп представляет собой пакет, аналогичный Pickle , который может, помимо прочего, сериализовать лямбда-функции. Его использование практически идентично маринованному .

  импортный укроп

dill.dump (lambda x: x ** 2, open ('dillfile', 'wb'))
  

Чтобы использовать многопроцессорную обработку с лямбда-функцией или другими типами данных, не поддерживаемыми pickle, вам придется использовать форк многопроцессорной обработки , называемый pathos.multiprocessing . Этот пакет использует укроп для сериализации вместо рассола .Создание пула и привязка к нему лямбда-функции выполняется точно так же, как вы видели ранее.

  импортировать pathos.multiprocessing as mp

p = mp.Pool (2)

p.map (лямбда x: 2 ** x, диапазон (10))
  

  [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
  

На этот раз нет PicklingError !

Заключение

Поздравляем! Теперь вы готовы начать выбор файлов с помощью Python. Вы сможете сохранить свои модели машинного обучения и продолжить работу над ними позже.Если вы хотите узнать больше о том, как создавать такие прогностические модели в Python, вам обязательно стоит взглянуть на наш курс обучения под наблюдением с scikit-learn. Он научит вас всем основам машинного обучения на Python.

Введение в модуль Python Pickle

Введение

Соление — это популярный метод консервирования продуктов. Согласно Википедии, это также довольно древняя процедура — хотя происхождение травления неизвестно, древние месопотамцы, вероятно, использовали этот процесс 4400 лет назад. Поместив продукт в конкретное решение, можно резко увеличить срок его годности. Другими словами, это метод, который позволяет нам хранить продукты для последующего потребления.

Если вы разработчик Python, однажды вам может понадобиться способ хранения ваших объектов Python для дальнейшего использования. Что ж, если я скажу вам, вы тоже можете засолить объекты Python?

Сериализация

Сериализация — это процесс преобразования объектов или структур данных в байтовых потоков или строк. Поток байтов, ну, в общем, поток байтов — один байт состоит из 8 битов нулей и единиц. Эти байтовые потоки могут быть легко сохранены или переданы.Это позволяет разработчикам сохранять, например, данные конфигурации или пользовательский прогресс, а затем сохранять их (на диске или в базе данных) или отправлять их в другое место.

Объекты Python также можно сериализовать с помощью модуля Pickle.

Одним из основных отличий между маринованными объектами Python и маринованными овощами является неизбежное и необратимое изменение вкуса и текстуры маринованной пищи. Между тем, засоленные объекты Python могут быть легко возвращены в исходное состояние.Этот процесс, кстати, повсеместно известен как десериализация .

(или сериализация в целом) не следует путать со сжатием. Целью травления является перевод данных в формат, который можно перенести из ОЗУ на диск. Сжатие, с другой стороны, представляет собой процесс кодирования данных с использованием меньшего количества битов (для экономии места на диске).

Сериализация особенно полезна в любом программном обеспечении, где важно иметь возможность сохранить некоторый прогресс на диске, выйти из программы и затем загрузить прогресс после повторного открытия программы.Видеоигры могут быть наиболее интуитивно понятным примером полезности сериализации, но есть много других программ, где сохранение и загрузка пользовательского прогресса или данных имеет решающее значение.

Пикл против JSON

Существует вероятность того, что вы слышали о JSON (JavaScript Object Notation), который является популярным форматом, который также позволяет разработчикам сохранять и передавать объекты, закодированные в виде строк. Этот метод сериализации имеет некоторые преимущества перед травлением. Формат JSON удобочитаем, не зависит от языка и работает быстрее, чем маринованный.

Однако у него есть и некоторые важные ограничения. Наиболее важно, что по умолчанию только JSON может представлять только ограниченное подмножество встроенных типов Python. С помощью Pickle мы можем легко сериализовать очень большой спектр типов Python и, что важно, пользовательские классы. Это означает, что нам не нужно создавать собственную схему (как мы делаем для JSON) и писать подверженные ошибкам сериализаторы и парсеры. Все тяжелые работы сделаны для вас с Pickle.

Что можно мариновать и мариновать

С помощью модуля Pickle можно сериализовать и десериализовать следующие типы:

• Все собственные типы данных, поддерживаемые Python (логические значения, Нет, целые числа, числа с плавающей запятой, комплексные числа, строки, байты, байтовые массивы)
• Словари, наборы, списки и кортежи — если они содержат маринованные объекты
• Функции и классы, определенные на верхнем уровне модуля

Важно помнить, что засолка не является независимым от языка методом сериализации, поэтому ваши засоленные данные можно извлечь только с помощью Python.Более того, важно , чтобы убедиться, что объекты травятся с использованием той же версии Python, которая будет использоваться для их засолки . Смешивание версий Python в этом случае может вызвать много проблем.

Кроме того, функции выбираются по именам, а не по значению. Результирующий рассол не содержит информации о коде или атрибутах функции. Следовательно, вы должны убедиться, что среда, в которой функция не выбрана, способна импортировать функцию.Другими словами, если мы выбираем функцию, а затем отключаем ее в среде, где она либо не определена, либо не импортирована, возникнет исключение.

Также очень важно отметить, что маринованные предметы можно использовать недоброжелательно. Например, удаление данных из ненадежного источника может привести к выполнению вредоносного фрагмента кода.

маринование списка Python

Следующий очень простой пример показывает основы использования модуля Pickle в Python 3:

  импортных солений

test_list = ['огурец', 'тыква', 'морковь']

с открытым ('test_pickle.pkl ',' wb ') as pickle_out:
    pickle.dump (test_list, pickle_out)
  

Во-первых, нам нужно импортировать модуль

  импортных солений

с открытым ('test_pickle.pkl', 'rb') в качестве pickle_in:
    unpickled_list = pickle.load (pickle_in)

печать (unpickled_list)
  

  $ python unpickle.py
[огурец, тыква, морковь]
  

  импортных солений

класс Veggy ():
    def __init __ (self):
        самостоятельно.цвет = ''
    def set_color (self, color):
        self.color = color

огурец = вегетарианец ()
cucumber.set_color ( 'зеленый')

с открытым ('test_pickle.pkl', 'wb') в качестве pickle_out:
    pickle.dump (огурец, pickle_out)

с открытым ('test_pickle.pkl', 'rb') в качестве pickle_in:
    unpic  

  импортный рассол

# сделать пример объекта для засолки
some_obj = {'x': [4,2,1.5,1], 'y': [32, [101], 17], 'foo': True, 'spam': False}
  

  с открытым ('mypickle.pickle', 'wb') как f:
    pickle.dump (some_obj, f)

# обратите внимание, что это перезапишет любой существующий файл
# в текущем рабочем каталоге с именем 'mypickle.соленый огурец'
  

  del some_obj

распечатать some_obj
  

  ------------------------------------------------ ---------------------------

NameError Traceback (последний вызов последним)

 в  ()
      1 del some_obj
      2
----> 3 распечатать some_obj


NameError: имя 'some_obj' не определено
  

  с открытым ('mypickle.pickle') как f:
    Загруженный_объект = pickle.load (f)

выведите «Загружен_объект
  

  Загруженный_обзор: {'y': [32, [101], 17], 'x': [4, 2, 1.5, 1], 'foo': True, 'spam': False}
  

  импорт панд в качестве pd

df = pd.DataFrame ([диапазон (11), диапазон (100,110)], столбцы = список ('abcdefghijk'))

Д.Ф.
  

  df.to_pickle ('my_df.pickle')

Del DF
  

  df2 = pd.read_pickle ('my_df.pickle')

df2