Сохранение данных Python - Краткое руководство

Обзор Python - сохранение данных

В процессе использования любого программного приложения пользователь предоставляет некоторые данные для обработки. Данные могут быть введены с использованием стандартного устройства ввода (клавиатуры) или других устройств, таких как дисковый файл, сканер, камера, сетевой кабель, соединение WiFi и т. Д.

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

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

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

В этом руководстве мы рассмотрим различные встроенные и сторонние модули Python для хранения и извлечения данных в / из различных форматов, таких как текстовый файл, файлы CSV, JSON и XML, а также реляционные и нереляционные базы данных.

Используя встроенный в Python объект File, можно записывать строковые данные в файл на диске и читать из него. Стандартная библиотека Python предоставляет модули для хранения и извлечения сериализованных данных в различных структурах данных, таких как JSON и XML.

DB-API Python предоставляет стандартный способ взаимодействия с реляционными базами данных. Другие сторонние пакеты Python предоставляют функциональные возможности взаимодействия с базами данных NOSQL, такими как MongoDB и Cassandra.

В этом руководстве также представлена ​​база данных ZODB, которая представляет собой постоянный API для объектов Python. Формат Microsoft Excel - очень популярный формат файлов данных. В этом руководстве мы узнаем, как работать с файлом .xlsx через Python.

Python использует встроенный input() и print()функции для выполнения стандартных операций ввода / вывода. Функция input () считывает байты из устройства стандартного потока ввода, то есть клавиатуры.

В print()функция, с другой стороны, отправляет данные на устройство стандартного потока вывода, то есть на монитор дисплея. Программа Python взаимодействует с этими устройствами ввода-вывода через стандартные объекты потока.stdin и stdout определен в модуле sys.

В input()функция фактически является оболочкой вокруг метода readline () объекта sys.stdin. Все нажатия клавиш из входного потока принимаются до нажатия клавиши «Enter».

>>> import sys
>>> x=sys.stdin.readline()
Welcome to TutorialsPoint
>>> x
'Welcome to TutorialsPoint\n'

Обратите внимание, что, readline()функция оставляет в конце символ '\ n'. Существует также метод read (), который считывает данные из стандартного входного потока до тех пор, пока он не будет завершенCtrl+D персонаж.

>>> x=sys.stdin.read()
Hello
Welcome to TutorialsPoint
>>> x
'Hello\nWelcome to TutorialsPoint\n'

Так же, print() это удобная функция, имитирующая метод write () объекта stdout.

>>> x='Welcome to TutorialsPoint\n'
>>> sys.stdout.write(x)
Welcome to TutorialsPoint
26

Так же, как стандартные объекты потока stdin и stdout, программа Python может считывать данные и отправлять данные в файл на диске или сетевой сокет. Они тоже ручьи. Любой объект, у которого есть метод read (), является входным потоком. Любой объект, у которого есть метод write (), является потоком вывода. Связь с потоком устанавливается путем получения ссылки на объект потока с помощью встроенной функции open ().

функция open ()

Эта встроенная функция использует следующие аргументы -

f=open(name, mode, buffering)

Параметр имени - это имя файла на диске или байтовая строка, режим - необязательная односимвольная строка для указания типа выполняемой операции (чтение, запись, добавление и т. Д.), А параметр буферизации - 0, 1 или -1, указывающий Буферизация выключена, включена или по умолчанию.

Режим открытия файла пронумерован в соответствии с таблицей ниже. Режим по умолчанию - 'r'

Старший Нет	Параметры и описание
1	R Открыть для чтения (по умолчанию)
2	W Открыть для записи, сначала обрезая файл
3	X Создайте новый файл и откройте его для записи
4	A Открыто для записи, добавляется в конец файла, если он существует
5	B Двоичный режим
6	T Текстовый режим (по умолчанию)
7	+ Откройте файл на диске для обновления (чтения и записи)

Чтобы сохранить данные в файл, он должен быть открыт в режиме 'w'.

f=open('test.txt','w')

Этот файловый объект действует как выходной поток и имеет доступ к методу write (). Метод write () отправляет строку этому объекту и сохраняется в файле, лежащем в ее основе.

string="Hello TutorialsPoint\n"
f.write(string)

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

file.close()

Попробуйте открыть test.txt с помощью любого редактора тестов (например, блокнота), чтобы подтвердить успешное создание файла.

Чтобы программно прочитать содержимое test.txt, его необходимо открыть в режиме «r».

f=open('test.txt','r')

Этот объект ведет себя как входной поток. Python может извлекать данные из потока, используяread() метод.

string=f.read()
print (string)

Содержимое файла отображается на консоли Python. Объект File также поддерживаетreadline() метод, который может читать строку, пока не встретит символ EOF.

Однако, если тот же файл открывается в режиме 'w' для хранения в нем дополнительного текста, более раннее содержимое стирается. Каждый раз, когда файл открывается с разрешением на запись, он обрабатывается как новый файл. Чтобы добавить данные в существующий файл, используйте "a" для режима добавления.

f=open('test.txt','a')
f.write('Python Tutorials\n')

Теперь в файле есть как ранее, так и недавно добавленная строка. Файловый объект также поддерживаетwritelines() для записи каждой строки в объекте списка в файл.

f=open('test.txt','a')
lines=['Java Tutorials\n', 'DBMS tutorials\n', 'Mobile development tutorials\n']
f.writelines(lines)
f.close()

пример

В readlines()Метод возвращает список строк, каждая из которых представляет строку в файле. Также возможно читать файл построчно, пока не будет достигнут конец файла.

f=open('test.txt','r')
while True:
   line=f.readline()
   if line=='' : break
   print (line, end='')
f.close()

Вывод

Hello TutorialsPoint
Python Tutorials
Java Tutorials
DBMS tutorials
Mobile development tutorials

Двоичный режим

По умолчанию операции чтения / записи файлового объекта выполняются с данными текстовой строки. Если мы хотим обрабатывать файлы разных других типов, такие как мультимедиа (mp3), исполняемые файлы (exe), изображения (jpg) и т. Д., Нам нужно добавить префикс «b» для режима чтения / записи.

Следующий оператор преобразует строку в байты и запишет в файл.

f=open('test.bin', 'wb')
data=b"Hello World"
f.write(data)
f.close()

Преобразование текстовой строки в байты также возможно с помощью функции encode ().

data="Hello World".encode('utf-8')

Нам нужно использовать ‘rb’режим чтения двоичного файла. Возвращаемое значение метода read () сначала декодируется перед печатью.

f=open('test.bin', 'rb')
data=f.read()
print (data.decode(encoding='utf-8'))

Чтобы записать целые данные в двоичный файл, целочисленный объект должен быть преобразован в байты с помощью to_bytes() метод.

n=25
n.to_bytes(8,'big')
f=open('test.bin', 'wb')
data=n.to_bytes(8,'big')
f.write(data)

Для обратного чтения из двоичного файла преобразуйте вывод функции read () в целое число с помощью функции from_bytes ().

f=open('test.bin', 'rb')
data=f.read()
n=int.from_bytes(data, 'big')
print (n)

Для данных с плавающей запятой нам нужно использовать struct модуль из стандартной библиотеки Python.

import struct
x=23.50
data=struct.pack('f',x)
f=open('test.bin', 'wb')
f.write(data)

Распаковка строки из функции read () для извлечения данных с плавающей запятой из двоичного файла.

f=open('test.bin', 'rb')
data=f.read()
x=struct.unpack('f', data)
print (x)

Одновременное чтение / запись

Когда файл открыт для записи (с 'w' или 'a'), чтение из него невозможно, и наоборот. Это вызывает ошибку UnSupportedOperation. Перед выполнением другой операции нам нужно закрыть файл.

Чтобы выполнить обе операции одновременно, мы должны добавить символ «+» в параметр режима. Следовательно, режим 'w +' или 'r +' позволяет использовать методы write (), а также read () без закрытия файла. Объект File также поддерживает функцию seek () для перемотки потока в любую желаемую позицию байта.

f=open('test.txt','w+')
f.write('Hello world')
f.seek(0,0)
data=f.read()
print (data)
f.close()

В следующей таблице перечислены все методы, доступные для файлового объекта.

Старший Нет	Метод и описание
1	close() Закрывает файл. Закрытый файл больше не может быть прочитан или записан.
2	flush() Промойте внутренний буфер.
3	fileno() Возвращает целочисленный дескриптор файла.
4	next() Возвращает следующую строку из файла каждый раз при его вызове. Используйте итератор next () в Python 3.
5	read([size]) Считывает из файла не более байтов размера (меньше, если чтение попадает в EOF до получения байтов размера).
6	readline([size]) Читает одну строку из файла. Завершающий символ новой строки сохраняется в строке.
7	readlines([sizehint]) Читает до EOF с помощью readline () и возвращает список, содержащий строки.
8	seek(offset[, whence]) Устанавливает текущую позицию файла. 0-начало 1-текущий 2-конец.
9	seek(offset[, whence]) Устанавливает текущую позицию файла. 0-начало 1-текущий 2-конец.
10	tell() Возвращает текущую позицию файла
11	truncate([size]) Обрезает размер файла.
12	write(str) Записывает строку в файл. Нет возвращаемого значения.

В дополнение к объекту File, возвращаемому open()функции, операции ввода-вывода файлов также могут выполняться с использованием встроенной библиотеки Python, имеющей модуль os, который предоставляет полезные функции, зависимые от операционной системы. Эти функции выполняют операции чтения / записи низкого уровня в файле.

В open()Функция из модуля os аналогична встроенной функции open (). Однако он возвращает не файловый объект, а файловый дескриптор, уникальное целое число, соответствующее открытому файлу. Значения 0, 1 и 2 дескриптора файла представляют потоки stdin, stdout и stderr. Остальным файлам будет назначен инкрементный файловый дескриптор, начиная с 2-го.

Как и в случае с open() встроенная функция, os.open()функция также должна указать режим доступа к файлу. В следующей таблице перечислены различные режимы, определенные в модуле os.

Sr.No.	Модуль ОС и описание
1	os.O_RDONLY Только для чтения
2	os.O_WRONLY Открыт только для записи
3	os.O_RDWR Открыт для чтения и письма
4	os.O_NONBLOCK Не блокировать при открытии
5	os.O_APPEND Добавлять при каждой записи
6	os.O_CREAT Создать файл, если он не существует
7	os.O_TRUNC Обрезать размер до 0
8	os.O_EXCL Ошибка, если создать и файл существует

Чтобы открыть новый файл для записи в него данных, укажите O_WRONLY так же как O_CREATрежимы, вставив оператор вертикальной черты (|). Функция os.open () возвращает дескриптор файла.

f=os.open("test.dat", os.O_WRONLY|os.O_CREAT)

Обратите внимание, что данные записываются в файл на диске в виде байтовой строки. Следовательно, обычная строка преобразуется в байтовую строку с помощью функции encode (), как раньше.

data="Hello World".encode('utf-8')

Функция write () в модуле os принимает эту байтовую строку и файловый дескриптор.

os.write(f,data)

Не забудьте закрыть файл с помощью функции close ().

os.close(f)

Чтобы прочитать содержимое файла с помощью функции os.read (), используйте следующие операторы:

f=os.open("test.dat", os.O_RDONLY)
data=os.read(f,20)
print (data.decode('utf-8'))

Обратите внимание, что функции os.read () требуется дескриптор файла и количество байтов для чтения (длина байтовой строки).

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

Старший Нет	Функции и описание
1	os.close(fd) Закройте дескриптор файла.
2	os.open(file, flags[, mode]) Откройте файл и установите различные флаги в соответствии с флагами и, возможно, его режим в соответствии с режимом.
3	os.read(fd, n) Прочтите не более n байтов из файлового дескриптора fd. Вернуть строку, содержащую прочитанные байты. Если достигнут конец файла, на который указывает fd, возвращается пустая строка.
4	os.write(fd, str) Запишите строку str в файловый дескриптор fd. Возвращает количество фактически записанных байтов.

Встроенный файловый объект Python, возвращаемый встроенной функцией Python open (), имеет один важный недостаток. При открытии в режиме 'w' метод write () принимает только строковый объект.

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

numbers=[10,20,30,40]
   file=open('numbers.txt','w')
   file.write(str(numbers))
   file.close()

Для двоичного файла аргумент write()Метод должен быть байтовым объектом. Например, список целых чисел преобразуется в байты с помощьюbytearray() функция, а затем записывается в файл.

numbers=[10,20,30,40]
   data=bytearray(numbers)
   file.write(data)
   file.close()

Чтобы прочитать данные из файла соответствующего типа, необходимо выполнить обратное преобразование.

file=open('numbers.txt','rb')
   data=file.read()
   print (list(data))

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

Встроенная библиотека Python содержит различные модули для процесса сериализации и десериализации.

Sr.No.	Имя и описание
1	pickle Библиотека сериализации для Python
2	marshal Библиотека, используемая внутри для сериализации
3	shelve Сохранение питонического объекта
4	dbm библиотека, предлагающая интерфейс к базе данных Unix
5	csv библиотека для хранения и извлечения данных Python в формат CSV
6	json Библиотека для сериализации в универсальный формат JSON

Терминология Python для сериализации и десериализации - соответственно «травление» и «распаковка». Модуль pickle в библиотеке Python использует очень специфичный для Python формат данных. Следовательно, приложения, отличные от Python, могут быть не в состоянии правильно десериализовать консервированные данные. Также не рекомендуется извлекать данные из неаутентифицированного источника.

Сериализованные (маринованные) данные могут храниться в байтовой строке или двоичном файле. Этот модуль определяетdumps() и loads()функции для сбора и извлечения данных с помощью байтовой строки. Для файлового процесса в модуле естьdump() и load() функция.

Протоколы pickle Python - это соглашения, используемые при построении и деконструкции объектов Python в / из двоичных данных. В настоящее время модуль pickle определяет 5 различных протоколов, перечисленных ниже -

Sr.No.	Имена и описание
1	Protocol version 0 Оригинальный «удобочитаемый» протокол обратно совместим с более ранними версиями.
2	Protocol version 1 Старый двоичный формат также совместим с более ранними версиями Python.
3	Protocol version 2 Представленный в Python 2.3 обеспечивает эффективное использование классов нового стиля.
4	Protocol version 3 Добавлено в Python 3.0. рекомендуется, когда требуется совместимость с другими версиями Python 3.
5	Protocol version 4 был добавлен в Python 3.4. Добавлена ​​поддержка очень больших объектов.

пример

Модуль pickle состоит из функции dumps (), которая возвращает строковое представление обработанных данных.

from pickle import dump
dct={"name":"Ravi", "age":23, "Gender":"M","marks":75}
dctstring=dumps(dct)
print (dctstring)

Вывод

b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x04\x00\x00\x00Raviq\x02X\x03\x00\x00\x00ageq\x03K\x17X\x06\x00\x00\x00Genderq\x04X\x01\x00\x00\x00Mq\x05X\x05\x00\x00\x00marksq\x06KKu.

пример

Используйте функцию load (), чтобы распаковать строку и получить исходный объект словаря.

from pickle import load
dct=loads(dctstring)
print (dct)

Вывод

{'name': 'Ravi', 'age': 23, 'Gender': 'M', 'marks': 75}

Маринованные объекты также могут быть постоянно сохранены в файле на диске с помощью функции dump () и извлечены с помощью функции load ().

import pickle
f=open("data.txt","wb")
dct={"name":"Ravi", "age":23, "Gender":"M","marks":75}
pickle.dump(dct,f)
f.close()

#to read
import pickle
f=open("data.txt","rb")
d=pickle.load(f)
print (d)
f.close()

Модуль pickle также предоставляет объектно-ориентированный API для механизма сериализации в виде Pickler и Unpickler классы.

Как упоминалось выше, как и встроенные объекты в Python, объекты определяемых пользователем классов также могут быть постоянно сериализованы в файле на диске. В следующей программе мы определяем класс User с именем и номером мобильного телефона в качестве атрибутов экземпляра. В дополнение к конструктору __init __ () класс переопределяет метод __str __ (), который возвращает строковое представление своего объекта.

class User:
   def __init__(self,name, mob):
      self.name=name
      self.mobile=mob
   def __str__(self):
return ('Name: {} mobile: {} '. format(self.name, self.mobile))

Чтобы сохранить объект вышеуказанного класса в файле, мы используем класс pickler и его метод dump ().

from pickle import Pickler
user1=User('Rajani', '[email protected]', '1234567890')
file=open('userdata','wb')
Pickler(file).dump(user1)
Pickler(file).dump(user2)
file.close()

И наоборот, класс Unpickler имеет метод load () для получения сериализованного объекта следующим образом:

from pickle import Unpickler
file=open('usersdata','rb')
user1=Unpickler(file).load()
print (user1)

Функции сериализации объектов модуля marshal в стандартной библиотеке Python аналогичны модулю pickle. Однако этот модуль не используется для данных общего назначения. С другой стороны, он используется самим Python для внутренней сериализации объектов Python для поддержки операций чтения / записи в скомпилированных версиях модулей Python (файлы .pyc).

Формат данных, используемый модулем marshal, несовместим с версиями Python. Следовательно, скомпилированный скрипт Python (файл .pyc) одной версии, скорее всего, не будет выполняться в другой.

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

дамп ()

Эта функция записывает байтовое представление поддерживаемого объекта Python в файл. Сам файл является двоичным файлом с разрешением на запись

load ()

Эта функция считывает байтовые данные из двоичного файла и преобразует их в объект Python.

В следующем примере демонстрируется использование функций dump () и load () для обработки объектов кода Python, которые используются для хранения предварительно скомпилированных модулей Python.

В коде используется встроенный compile() функция для создания объекта кода из исходной строки, которая включает инструкции Python.

compile(source, file, mode)

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

Параметр режима - «exec», если источник содержит последовательность операторов, «eval», если есть одно выражение, или «single», если он содержит единственный интерактивный оператор.

Затем объект кода компиляции сохраняется в файле .pyc с помощью функции dump ().

import marshal
script = """
a=10
b=20
print ('addition=',a+b)
"""
code = compile(script, "script", "exec")
f=open("a.pyc","wb")
marshal.dump(code, f)
f.close()

Для десериализации объект из файла .pyc использует функцию load (). Поскольку он возвращает объект кода, его можно запустить с помощью другой встроенной функции exec ().

import marshal
f=open("a.pyc","rb")
data=marshal.load(f)
exec (data)

Модуль полки в стандартной библиотеке Python предоставляет простой, но эффективный механизм сохранения объектов. Объект полки, определенный в этом модуле, представляет собой подобный словарю объект, который постоянно хранится в файле на диске. Это создает файл, похожий на базу данных dbm в UNIX-подобных системах.

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

Модуль полки определяет три класса следующим образом:

Старший Нет	Модуль полки и описание
1	Shelf Это базовый класс для реализации на полках. Он инициализируется dict-подобным объектом.
2	BsdDbShelf Это подкласс класса Shelf. Объект dict, переданный его конструктору, должен поддерживать методы first (), next (), previous (), last () и set_location ().
3	DbfilenameShelf Это также подкласс Shelf, но он принимает имя файла в качестве параметра своего конструктора, а не объект dict.

Функция open (), определенная в модуле полки, которая возвращает DbfilenameShelf объект.

open(filename, flag='c', protocol=None, writeback=False)

Параметр имени файла присваивается созданной базе данных. Значение по умолчанию для параметра flag - "c" для доступа для чтения / записи. Другие флаги - «w» (только запись), «r» (только чтение) и «n» (новые с чтением / записью).

Сама сериализация регулируется протоколом pickle, по умолчанию нет. Параметр обратной записи последнего параметра по умолчанию равен false. Если установлено значение true, записи кэшируются. Каждый доступ вызывает операции sync () и close (), поэтому процесс может быть медленным.

Следующий код создает базу данных и сохраняет в ней словарные статьи.

import shelve
s=shelve.open("test")
s['name']="Ajay"
s['age']=23
s['marks']=75
s.close()

Это создаст файл test.dir в текущем каталоге и сохранит данные ключ-значение в хешированной форме. У объекта Shelf доступны следующие методы:

Sr.No.	Методы и описание
1	close() синхронизировать и закрыть постоянный объект dict.
2	sync() Запишите обратно все записи в кеш, если полка была открыта с обратной записью, установленной на True.
3	get() возвращает значение, связанное с ключом
4	items() список кортежей - каждый кортеж представляет собой пару ключ-значение
5	keys() список ключей полки
6	pop() удалить указанный ключ и вернуть соответствующее значение.
7	update() Обновить полку из другого словаря / итерации
8	values() список ценностей на полке

Чтобы получить доступ к значению определенного ключа на полке -

s=shelve.open('test')
print (s['age']) #this will print 23
   s['age']=25
print (s.get('age')) #this will print 25
s.pop('marks') #this will remove corresponding k-v pair

Как и во встроенном объекте словаря, методы items (), keys () и values ​​() возвращают объекты представления.

print (list(s.items()))
[('name', 'Ajay'), ('age', 25), ('marks', 75)]  

print (list(s.keys()))
['name', 'age', 'marks']

print (list(s.values()))
['Ajay', 25, 75]

Чтобы объединить элементы другого словаря с полкой, используйте метод update ().

d={'salary':10000, 'designation':'manager'}
s.update(d)
print (list(s.items()))

[('name', 'Ajay'), ('age', 25), ('salary', 10000), ('designation', 'manager')]

Пакет dbm представляет словарь, подобный интерфейсным базам данных в стиле DBM. DBM stands for DataBase Manager. Это используется операционной системой UNIX (и подобной UNIX). Библиотека dbbm - это простой движок базы данных, написанный Кеном Томпсоном. Эти базы данных используют строковые объекты в двоичной кодировке как ключ, так и значение.

База данных хранит данные с использованием одного ключа (первичного ключа) в сегментах фиксированного размера и использует методы хеширования, чтобы обеспечить быстрое извлечение данных по ключу.

Пакет dbm содержит следующие модули -

• dbm.gnu module - это интерфейс к версии библиотеки DBM, реализованной в проекте GNU.

• dbm.ndbm модуль предоставляет интерфейс к реализации nbdm UNIX.

• dbm.dumbиспользуется как резервный вариант в случае, если другие реализации dbm не найдены. Это не требует внешних зависимостей, но работает медленнее, чем другие.

>>> dbm.whichdb('mydbm.db')
'dbm.dumb'
>>> import dbm
>>> db=dbm.open('mydbm.db','n')
>>> db['name']=Raj Deshmane'
>>> db['address']='Kirtinagar Pune'
>>> db['PIN']='431101'
>>> db.close()

Функция open () позволяет использовать эти флаги -

Sr.No.	Ценность и значение
1	'r' Открыть существующую базу данных только для чтения (по умолчанию)
2	'w' Открыть существующую базу данных для чтения и записи
3	'c' Открыть базу данных для чтения и записи, создать ее, если ее нет
4	'n' Всегда создавайте новую пустую базу данных, открытую для чтения и записи

Объект dbm - это объект, подобный словарю, так же как объект полки. Следовательно, все словарные операции могут быть выполнены. Объект dbm может вызывать методы get (), pop (), append () и update (). Следующий код открывает mydbm.db с флагом r и выполняет итерацию по коллекции пар ключ-значение.

>>> db=dbm.open('mydbm.db','r')
>>> for k,v in db.items():
   print (k,v)
b'name' : b'Raj Deshmane'
b'address' : b'Kirtinagar Pune'
b'PIN' : b'431101'

CSV stands for comma separated values. Этот формат файла является широко используемым форматом данных при экспорте / импорте данных в / из электронных таблиц и таблиц данных в базах данных. Модуль csv был включен в стандартную библиотеку Python в результате PEP 305. Он представляет классы и методы для выполнения операций чтения / записи в файле CSV в соответствии с рекомендациями PEP 305.

CSV - это предпочтительный формат данных для экспорта в программе электронных таблиц Microsoft Excel. Однако модуль csv также может обрабатывать данные, представленные другими диалектами.

Интерфейс CSV API состоит из следующих классов писателя и читателя:

писатель ()

Эта функция в модуле csv возвращает объект записи, который преобразует данные в строку с разделителями и сохраняет их в файловом объекте. Функция нуждается в файловом объекте с разрешением на запись в качестве параметра. Каждая строка, записанная в файле, выдает символ новой строки. Чтобы предотвратить появление дополнительных пробелов между строками, параметр новой строки установлен в «».

Класс писателя имеет следующие методы -

writerow ()

Этот метод записывает элементы в итерацию (список, кортеж или строку), разделяя их запятыми.

writerows ()

Этот метод принимает список итераций в качестве параметра и записывает каждый элемент как строку элементов, разделенных запятыми, в файл.

Example

В следующем примере показано использование функции writer (). Сначала файл открывается в режиме 'w'. Этот файл используется для получения объекта записи. Затем каждый кортеж в списке кортежей записывается в файл с помощью метода writerow ().

import csv
   persons=[('Lata',22,45),('Anil',21,56),('John',20,60)]
   csvfile=open('persons.csv','w', newline='')
   obj=csv.writer(csvfile)
   for person in persons:
      obj.writerow(person)
csvfile.close()

Output

В текущем каталоге будет создан файл person.csv. Он покажет следующие данные.

Lata,22,45
Anil,21,56
John,20,60

Вместо того, чтобы перебирать список для записи каждой строки отдельно, мы можем использовать метод writerows ().

csvfile=open('persons.csv','w', newline='')
persons=[('Lata',22,45),('Anil',21,56),('John',20,60)]
   obj=csv.writer(csvfile)
   obj.writerows(persons)
   obj.close()

читатель ()

Эта функция возвращает объект чтения, который возвращает итератор строк в csv file. Используя обычный цикл for, все строки в файле отображаются в следующем примере:

пример

csvfile=open('persons.csv','r', newline='')
   obj=csv.reader(csvfile)
   for row in obj:
      print (row)

Вывод

['Lata', '22', '45']
['Anil', '21', '56']
['John', '20', '60']

Объект-читатель - это итератор. Следовательно, он поддерживает функцию next (), которая также может использоваться для отображения всех строк в файле csv вместоfor loop.

csvfile=open('persons.csv','r', newline='')
   obj=csv.reader(csvfile)
   while True:
   try:
      row=next(obj)
      print (row)
   except StopIteration:
      break

Как упоминалось ранее, модуль csv использует Excel в качестве диалекта по умолчанию. Модуль csv также определяет класс диалекта. Диалект - это набор стандартов, используемых для реализации протокола CSV. Список доступных диалектов можно получить с помощью функции list_dialects ().

>>> csv.list_dialects()
['excel', 'excel-tab', 'unix']

В дополнение к итерациям модуль csv может экспортировать объект словаря в файл CSV и читать его для заполнения объекта словаря Python. Для этого этот модуль определяет следующие классы -

DictWriter ()

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

writeheader ()

Этот метод записывает список ключей в словаре в виде строки, разделенной запятыми, в качестве первой строки в файле.

В следующем примере определяется список элементов словаря. Каждый элемент в списке - это словарь. Используя метод Writrows (), они записываются в файл через запятую.

persons=[
   {'name':'Lata', 'age':22, 'marks':45}, 
   {'name':'Anil', 'age':21, 'marks':56}, 
   {'name':'John', 'age':20, 'marks':60}
]
csvfile=open('persons.csv','w', newline='')
fields=list(persons[0].keys())
obj=csv.DictWriter(csvfile, fieldnames=fields)
obj.writeheader()
obj.writerows(persons)
csvfile.close()

Файл person.csv показывает следующее содержимое -

name,age,marks
Lata,22,45
Anil,21,56
John,20,60

DictReader ()

Эта функция возвращает объект DictReader из базового файла CSV. Как и в случае с объектом-читателем, этот объект также является итератором, с помощью которого извлекается содержимое файла.

csvfile=open('persons.csv','r', newline='')
obj=csv.DictReader(csvfile)

Класс предоставляет атрибут fieldnames, возвращающий ключи словаря, используемые в качестве заголовка файла.

print (obj.fieldnames)
['name', 'age', 'marks']

Используйте цикл над объектом DictReader для извлечения отдельных объектов словаря.

for row in obj:
   print (row)

Это приводит к следующему выводу -

OrderedDict([('name', 'Lata'), ('age', '22'), ('marks', '45')])
OrderedDict([('name', 'Anil'), ('age', '21'), ('marks', '56')])
OrderedDict([('name', 'John'), ('age', '20'), ('marks', '60')])

Чтобы преобразовать объект OrderedDict в обычный словарь, мы должны сначала импортировать OrderedDict из модуля коллекций.

from collections import OrderedDict
   r=OrderedDict([('name', 'Lata'), ('age', '22'), ('marks', '45')])
   dict(r)
{'name': 'Lata', 'age': '22', 'marks': '45'}

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

Формат JSON похож на pickle. Однако сериализация pickle специфична для Python, тогда как формат JSON реализован во многих языках, поэтому стал универсальным стандартом. Функциональность и интерфейс модуля json в стандартной библиотеке Python аналогичны модулям pickle и marshal.

Как и в модуле pickle, модуль json также предоставляет dumps() и loads() функция для сериализации объекта Python в закодированную строку JSON, и dump() и load() функции записывают и читают сериализованные объекты Python в / из файла.

• dumps() - Эта функция конвертирует объект в формат JSON.

• loads() - Эта функция преобразует строку JSON обратно в объект Python.

Следующий пример демонстрирует базовое использование этих функций -

import json
   data=['Rakesh',{'marks':(50,60,70)}]
   s=json.dumps(data)
json.loads(s)

Функция dumps () может принимать необязательный аргумент sort_keys. По умолчанию это False. Если установлено значение True, ключи словаря отображаются в отсортированном порядке в строке JSON.

У функции dumps () есть еще один необязательный параметр, называемый indent, который принимает число в качестве значения. Он определяет длину каждого сегмента форматированного представления строки json, как при выводе на печать.

Модуль json также имеет объектно-ориентированный API, соответствующий вышеуказанным функциям. В модуле определены два класса - JSONEncoder и JSONDecoder.

JSONEncoder класс

Объект этого класса - кодировщик структур данных Python. Каждый тип данных Python преобразуется в соответствующий тип JSON, как показано в следующей таблице:

Python	JSON
Диктовать	объект
список, кортеж	массив
Ул.	строка
Перечисления, производные от int, float, int и float	количество
Правда	правда
Ложь	ложный
Никто	ноль

Класс JSONEncoder создается конструктором JSONEncoder (). Следующие важные методы определены в классе кодировщика -

Sr.No.	Методы и описание
1	encode() сериализует объект Python в формат JSON
2	iterencode() Кодирует объект и возвращает итератор, дающий закодированную форму каждого элемента в объекте.
3	indent Определяет уровень отступа закодированной строки
4	sort_keys имеет значение true или false, чтобы ключи отображались в отсортированном порядке или нет.
5	Check_circular если True, проверьте круговую ссылку в объекте типа контейнера

В следующем примере кодируется объект списка Python.

e=json.JSONEncoder()
e.encode(data)

JSONDecoder класс

Объект этого класса помогает в декодировании строки json обратно в структуру данных Python. Главный метод в этом классе - decode (). В следующем примере кода объект списка Python извлекается из закодированной строки на предыдущем шаге.

d=json.JSONDecoder()
d.decode(s)

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

дамп ()

Эта функция записывает данные объекта Python в формате JSON в файл. Файл должен быть открыт в режиме 'w'.

import json
data=['Rakesh', {'marks': (50, 60, 70)}]
   fp=open('json.txt','w')
   json.dump(data,fp)
   fp.close()

Этот код создаст json.txt в текущем каталоге. Он показывает содержимое следующим образом -

["Rakesh", {"marks": [50, 60, 70]}]

load ()

Эта функция загружает данные JSON из файла и возвращает из него объект Python. Файл должен быть открыт с разрешением на чтение (должен иметь режим «r»).

Example

fp=open('json.txt','r')
   ret=json.load(fp)
   print (ret)
   fp.close()

Output

['Rakesh', {'marks': [50, 60, 70]}]

В json.tool модуль также имеет интерфейс командной строки, который проверяет данные в файле и печатает объект JSON в довольно отформатированном виде.

C:\python37>python -m json.tool json.txt
[
   "Rakesh",   
   {
      "marks": [
         50,
         60,
         70
      ]
   }
]

XML - это аббревиатура от eXtensible Markup Language. Это переносимый кроссплатформенный язык с открытым исходным кодом, очень похожий на HTML или SGML и рекомендованный консорциумом World Wide Web.

Это хорошо известный формат обмена данными, используемый большим количеством приложений, таких как веб-службы, офисные инструменты и Service Oriented Architectures(SOA). Формат XML является как машиночитаемым, так и человеческим.

Пакет xml стандартной библиотеки Python состоит из следующих модулей для обработки XML:

Sr.No.	Модули и описание
1	xml.etree.ElementTree API ElementTree, простой и легкий XML-процессор
2	xml.dom определение DOM API
3	xml.dom.minidom минимальная реализация DOM
4	xml.sax Реализация интерфейса SAX2
5	xml.parsers.expat привязка парсера Expat

Данные в XML-документе организованы в древовидном иерархическом формате, начиная с корня и элементов. Каждый элемент представляет собой отдельный узел в дереве и имеет атрибут, заключенный в теги <> и </>. Каждому элементу может быть назначен один или несколько подэлементов.

Ниже приведен типичный пример XML-документа -

<?xml version = "1.0" encoding = "iso-8859-1"?>
<studentlist>
   <student>
      <name>Ratna</name>
      <subject>Physics</subject>
      <marks>85</marks>
   </student>
   <student>
      <name>Kiran</name>
      <subject>Maths</subject>
      <marks>100</marks>
   </student>
   <student>
      <name>Mohit</name>
      <subject>Biology</subject>
      <marks>92</marks>
   </student>
</studentlist>

При использовании ElementTreeмодуль, первый шаг - настроить корневой элемент дерева. У каждого элемента есть тег и атрибут, который является объектом dict. Для корневого элемента атрибутом является пустой словарь.

import xml.etree.ElementTree as xmlobj
root=xmlobj.Element('studentList')

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

student=xmlobj.Element('student')
   nm=xmlobj.SubElement(student, 'name')
   nm.text='name'
   subject=xmlobj.SubElement(student, 'subject')
   nm.text='Ratna'
   subject.text='Physics'
   marks=xmlobj.SubElement(student, 'marks')
   marks.text='85'

Этот новый элемент добавляется к корню с помощью метода append ().

root.append(student)

Добавьте столько элементов, сколько хотите, используя вышеуказанный метод. Наконец, объект корневого элемента записывается в файл.

tree = xmlobj.ElementTree(root)
   file = open('studentlist.xml','wb')
   tree.write(file)
   file.close()

Теперь мы видим, как разбирать XML-файл. Для этого постройте дерево документа, указав его имя в качестве параметра файла в конструкторе ElementTree.

tree = xmlobj.ElementTree(file='studentlist.xml')

Объект дерева имеет getroot() для получения корневого элемента, а getchildren () возвращает список элементов под ним.

root = tree.getroot()
children = root.getchildren()

Объект словаря, соответствующий каждому подэлементу, создается путем перебора коллекции подэлементов каждого дочернего узла.

for child in children:
   student={}
   pairs = child.getchildren()
   for pair in pairs:
      product[pair.tag]=pair.text

Затем каждый словарь добавляется к списку, возвращающему исходный список объектов словаря.

SAX- это стандартный интерфейс для анализа XML, управляемого событиями. Для синтаксического анализа XML с помощью SAX требуется ContentHandler путем создания подкласса xml.sax.ContentHandler. Вы регистрируете обратные вызовы для интересующих событий, а затем позволяете синтаксическому анализатору пройти через документ.

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

Объектная модель документа

(DOM) API - это рекомендация консорциума World Wide Web. В этом случае весь файл считывается в память и сохраняется в иерархической (древовидной) форме для представления всех функций XML-документа.

SAX, не такой быстрый, как DOM, с большими файлами. С другой стороны, DOM может уничтожить ресурсы, если используется для множества небольших файлов. SAX доступен только для чтения, а DOM позволяет вносить изменения в XML-файл.

Формат plist в основном используется MAC OS X. Эти файлы в основном представляют собой XML-документы. Они хранят и извлекают свойства объекта. Библиотека Python содержит модуль plist, который используется для чтения и записи файлов «списка свойств» (обычно они имеют расширение .plist).

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

Следующий объект словаря поддерживает свойство (ключ) и соответствующее значение -

proplist = {
   "name" : "Ganesh",
   "designation":"manager",
   "dept":"accts",
   "salary" : {"basic":12000, "da":4000, "hra":800}
}

Чтобы записать эти свойства в файл на диске, мы вызываем функцию dump () в модуле plist.

import plistlib
fileName=open('salary.plist','wb')
plistlib.dump(proplist, fileName)
fileName.close()

И наоборот, чтобы прочитать значения свойств, используйте функцию load () следующим образом:

fp= open('salary.plist', 'rb')
pl = plistlib.load(fp)
print(pl)

Одним из основных недостатков файлов CSV, JSON, XML и т. Д. Является то, что они не очень полезны для произвольного доступа и обработки транзакций, поскольку они в значительной степени неструктурированы по своей природе. Следовательно, становится очень трудно изменить содержимое.

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

Эти проблемы можно преодолеть с помощью реляционной базы данных. База данных - это организованный набор данных для устранения избыточности и несогласованности и поддержания целостности данных. Модель реляционной базы данных очень популярна.

Его основная идея - упорядочить данные в таблице сущностей (называемой отношением). Структура таблицы сущностей предоставляет один атрибут, значение которого уникально для каждой строки. Такой атрибут называется'primary key'.

Когда первичный ключ одной таблицы появляется в структуре других таблиц, он называется 'Foreign key'и это составляет основу отношений между ними. На основе этой модели в настоящее время доступно множество популярных продуктов РСУБД -

• GadFly
• mSQL
• MySQL
• PostgreSQL
• Microsoft SQL Server 2000
• Informix
• Interbase
• Oracle
• Sybase
• SQLite

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

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

Следовательно, между ними отсутствовала совместимость. Если бы пользователь захотел перейти на другой продукт базы данных, это было бы сложно. Эта проблема несовместимости была решена путем поднятия «предложения по расширению Python (PEP 248)», чтобы рекомендовать согласованный интерфейс для реляционных баз данных, известный как DB-API. Последние рекомендации называютсяDB-APIВерсия 2.0. (PEP 249)

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

Как упоминалось ранее, Python имеет встроенную поддержку базы данных SQLite в виде модуля sqlite3. Для других баз данных соответствующий модуль Python, совместимый с DB-API, должен быть установлен с помощью утилиты pip. Например, чтобы использовать базу данных MySQL, нам необходимо установить модуль PyMySQL.

pip install pymysql

В DB-API рекомендуются следующие шаги -

• Установите соединение с базой данных, используя connect() функция и получить объект подключения.

• Вызов cursor() метод объекта подключения для получения объекта курсора.

• Сформируйте строку запроса, состоящую из выполняемого оператора SQL.

• Выполните желаемый запрос, вызвав execute() метод.

• Закройте соединение.

import sqlite3
db=sqlite3.connect('test.db')

Здесь db - это объект подключения, представляющий test.db. Обратите внимание: эта база данных будет создана, если она еще не существует. Объект подключения db имеет следующие методы -

Sr.No.	Методы и описание
1	cursor(): Возвращает объект Cursor, который использует это соединение.
2	commit(): Явно фиксирует любые ожидающие транзакции в базе данных.
3	rollback(): Этот необязательный метод вызывает откат транзакции до начальной точки.
4	close(): Закрывает соединение с базой данных навсегда.

Курсор действует как дескриптор для данного SQL-запроса, позволяя получить одну или несколько строк результата. Объект курсора получается из соединения для выполнения SQL-запросов с использованием следующего оператора -

cur=db.cursor()

Для объекта курсора определены следующие методы:

Старший Нет	Методы и описание
1	execute() Выполняет SQL-запрос в строковом параметре.
2	executemany() Выполняет SQL-запрос, используя набор параметров в списке кортежей.
3	fetchone() Выбирает следующую строку из набора результатов запроса.
4	fetchall() Выбирает все оставшиеся строки из набора результатов запроса.
5	callproc() Вызывает хранимую процедуру.
6	close() Закрывает объект курсора.

Следующий код создает таблицу в test.db: -

import sqlite3
db=sqlite3.connect('test.db')
cur =db.cursor()
cur.execute('''CREATE TABLE student (
StudentID INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT (20) NOT NULL,
age INTEGER,
marks REAL);''')
print ('table created successfully')
db.close()

Желаемая целостность данных в базе данных достигается за счет commit() и rollback()методы объекта подключения. Строка SQL-запроса может содержать неверный SQL-запрос, который может вызвать исключение, которое необходимо правильно обработать. Для этого оператор execute () помещается в блок try. В случае успеха результат постоянно сохраняется с помощью метода commit (). Если запрос не выполняется, транзакция отменяется с помощью метода rollback ().

Следующий код выполняет запрос INSERT к таблице учеников в test.db.

import sqlite3
db=sqlite3.connect('test.db')
qry="insert into student (name, age, marks) values('Abbas', 20, 80);"
try:
   cur=db.cursor()
   cur.execute(qry)
   db.commit()
print ("record added successfully")
except:
   print ("error in query")
   db.rollback()
db.close()

Если вы хотите, чтобы данные в предложении значений запроса INSERT были динамически предоставлены пользователем, используйте подстановку параметров, как рекомендовано в Python DB-API. ? символ используется в качестве заполнителя в строке запроса и предоставляет значения в виде кортежа в методе execute (). В следующем примере выполняется вставка записи с использованием метода подстановки параметров. В качестве входных данных принимаются имя, возраст и оценки.

import sqlite3
db=sqlite3.connect('test.db')
nm=input('enter name')
a=int(input('enter age'))
m=int(input('enter marks'))
qry="insert into student (name, age, marks) values(?,?,?);"
try:
   cur=db.cursor()
   cur.execute(qry, (nm,a,m))
   db.commit()
   print ("one record added successfully")
except:
   print("error in operation")
   db.rollback()
db.close()

Модуль sqlite3 определяет executemany()метод, который может добавлять сразу несколько записей. Добавляемые данные должны быть представлены в виде списка кортежей, каждый кортеж должен содержать одну запись. Объект списка - это параметр метода executemany () вместе со строкой запроса. Однако метод executemany () не поддерживается некоторыми другими модулями.

В UPDATEзапрос обычно содержит логическое выражение, указанное в предложении WHERE. Строка запроса в методе execute () должна содержать синтаксис запроса UPDATE. Чтобы обновить значение 'age' до 23 для name = 'Anil', определите строку, как показано ниже:

qry="update student set age=23 where name='Anil';"

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

import sqlite3
db=sqlite3.connect('test.db')
nm=input(‘enter name’)
a=int(input(‘enter age’))
qry="update student set age=? where name=?;"
try:
   cur=db.cursor()
   cur.execute(qry, (a, nm))
   db.commit()
   print("record updated successfully")
except:
   print("error in query")
   db.rollback()
db.close()

Аналогичным образом операция DELETE выполняется путем вызова метода execute () со строкой, имеющей синтаксис запроса SQL DELETE. Кстати,DELETE запрос также обычно содержит WHERE пункт.

import sqlite3
db=sqlite3.connect('test.db')
nm=input(‘enter name’)
qry="DELETE from student where name=?;"
try:
   cur=db.cursor()
   cur.execute(qry, (nm,))
   db.commit()
   print("record deleted successfully")
except:
   print("error in operation")
   db.rollback()
db.close()

Одна из важных операций с таблицей базы данных - извлечение из нее записей. SQL предоставляетSELECTзапрос для этой цели. Когда в метод execute () передается строка, содержащая синтаксис запроса SELECT, возвращается объект набора результатов. Есть два важных метода с объектом курсора, с помощью которых можно получить одну или несколько записей из набора результатов.

fetchone ()

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

fetchall ()

Выбирает все оставшиеся записи в виде списка кортежей. Каждый кортеж соответствует одной записи и содержит значения каждого столбца в таблице.

В следующем примере перечислены все записи в таблице студентов.

import sqlite3
db=sqlite3.connect('test.db')
37
sql="SELECT * from student;"
cur=db.cursor()
cur.execute(sql)
while True:
   record=cur.fetchone()
   if record==None:
      break
   print (record)
db.close()

Если вы планируете использовать базу данных MySQL вместо базы данных SQLite, вам необходимо установить PyMySQLмодуль, как описано выше. Все шаги в процессе подключения к базе данных одинаковы, поскольку база данных MySQL установлена ​​на сервере, функции connect () требуются URL-адрес и учетные данные для входа.

import pymysql
con=pymysql.connect('localhost', 'root', '***')

Единственное, что может отличаться от SQLite, - это специфические типы данных MySQL. Точно так же любую ODBC-совместимую базу данных можно использовать с Python, установив модуль pyodbc.

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

Это несоответствие между типами SQL и объектно-ориентированными языками программирования, такими как Python. SQL не имеет эквивалентного типа данных для других типов данных, таких как dict, tuple, list или любого определенного пользователем класса.

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

Сопоставитель отношений объектов (ORM)

An Object Relation Mapper(ORM) - это интерфейс между классом и таблицей SQL. Класс Python сопоставляется с определенной таблицей в базе данных, поэтому преобразование между объектами и типами SQL выполняется автоматически.

Класс «Студенты», написанный на языке Python, сопоставляется с таблицей «Студенты» в базе данных. В результате все операции CRUD выполняются путем вызова соответствующих методов класса. Это избавляет от необходимости выполнять жестко запрограммированные SQL-запросы в скрипте Python.

Таким образом, библиотека ORM действует как слой абстракции над необработанными SQL-запросами и может помочь в быстрой разработке приложений. SQLAlchemy- популярный объектно-реляционный картограф для Python. Любые манипуляции с состоянием объекта модели синхронизируются с соответствующей строкой в ​​таблице базы данных.

Библиотека SQLALchemy включает ORM API и язык выражений SQL (SQLAlchemy Core). Язык выражений напрямую выполняет примитивные конструкции реляционной базы данных.

ORM - это абстрактный шаблон использования высокого уровня, построенный на основе языка выражений SQL. Можно сказать, что ORM - это прикладное использование языка выражений. В этой теме мы обсудим SQLAlchemy ORM API и будем использовать базу данных SQLite.

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

• Firebird
• Microsoft SQL Server
• MySQL
• Oracle
• PostgreSQL
• SQLite
• Sybase

Установка SQLAlchemy проста и понятна с помощью утилиты pip.

pip install sqlalchemy

Чтобы проверить, правильно ли установлена ​​SQLalchemy и ее версия, введите в командной строке Python следующее:

>>> import sqlalchemy
>>>sqlalchemy.__version__
'1.3.11'

Взаимодействие с базой данных осуществляется через объект Engine, полученный как возвращаемое значение create_engine() функция.

engine =create_engine('sqlite:///mydb.sqlite')

SQLite позволяет создавать базу данных в памяти. Механизм SQLAlchemy для базы данных в памяти создается следующим образом:

from sqlalchemy import create_engine
engine=create_engine('sqlite:///:memory:')

Если вы собираетесь использовать базу данных MySQL, используйте ее модуль DB-API - pymysql и соответствующий драйвер диалекта.

engine = create_engine('mysql+pymydsql://root@localhost/mydb')

Create_engine имеет необязательный аргумент эха. Если установлено значение true, запросы SQL, сгенерированные движком, будут отображаться на терминале.

SQLAlchemy содержит declarative baseкласс. Он действует как каталог классов моделей и сопоставленных таблиц.

from sqlalchemy.ext.declarative import declarative_base
base=declarative_base()

Следующим шагом является определение класса модели. Он должен быть производным от базового объекта класса declarative_base, как указано выше.

Набор __tablename__ для имени таблицы, которую вы хотите создать в базе данных. Остальные атрибуты соответствуют полям. Каждый из них является объектом столбца в SQLAlchemy, а его тип данных - из одного из списка ниже -

• BigInteger
• Boolean
• Date
• DateTime
• Float
• Integer
• Numeric
• SmallInteger
• String
• Text
• Time

Следующий код - это класс модели с именем Student, который сопоставлен с таблицей Student.

#myclasses.py
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, Numeric
base=declarative_base()
class Student(base):
   __tablename__='Students'
   StudentID=Column(Integer, primary_key=True)
   name=Column(String)
   age=Column(Integer)
   marks=Column(Numeric)

Чтобы создать таблицу студентов с соответствующей структурой, выполните метод create_all (), определенный для базового класса.

base.metadata.create_all(engine)

Теперь нам нужно объявить объект нашего класса Student. Все транзакции базы данных, такие как добавление, удаление или извлечение данных из базы данных и т. Д., Обрабатываются объектом Session.

from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)
sessionobj = Session()

Данные, хранящиеся в объекте Student, физически добавляются в базовую таблицу методом сеанса add ().

s1 = Student(name='Juhi', age=25, marks=200)
sessionobj.add(s1)
sessionobj.commit()

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

from sqlalchemy import Column, Integer, String
from sqlalchemy import create_engine
from myclasses import Student, base
engine = create_engine('sqlite:///college.db', echo=True)
base.metadata.create_all(engine)

from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)
sessionobj = Session()
s1 = Student(name='Juhi', age=25, marks=200)
sessionobj.add(s1)
sessionobj.commit()

Консольный вывод

CREATE TABLE "Students" (
   "StudentID" INTEGER NOT NULL,
   name VARCHAR,
   age INTEGER,
   marks NUMERIC,
   PRIMARY KEY ("StudentID")
)
INFO sqlalchemy.engine.base.Engine ()
INFO sqlalchemy.engine.base.Engine COMMIT
INFO sqlalchemy.engine.base.Engine BEGIN (implicit)
INFO sqlalchemy.engine.base.Engine INSERT INTO "Students" (name, age, marks) VALUES (?, ?, ?)
INFO sqlalchemy.engine.base.Engine ('Juhi', 25, 200.0)
INFO sqlalchemy.engine.base.Engine COMMIT

В session object также предоставляет метод add_all () для вставки более одного объекта в одну транзакцию.

sessionobj.add_all([s2,s3,s4,s5])
sessionobj.commit()

Теперь, когда в таблицу добавлены записи, мы хотели бы получать данные из нее так же, как это делает запрос SELECT. У объекта сеанса есть метод query () для выполнения задачи. Объект запроса возвращается методом query () в нашей модели Student.

qry=seesionobj.query(Student)

Используйте метод get () этого объекта Query для извлечения объекта, соответствующего данному первичному ключу.

S1=qry.get(1)

Пока этот оператор выполняется, соответствующий ему оператор SQL, отображаемый на консоли, будет следующим:

BEGIN (implicit)
SELECT "Students"."StudentID" AS "Students_StudentID", "Students".name AS 
   "Students_name", "Students".age AS "Students_age", 
   "Students".marks AS "Students_marks"
FROM "Students"
WHERE "Products"."Students" = ?
sqlalchemy.engine.base.Engine (1,)

Метод query.all () возвращает список всех объектов, по которым можно пройти с помощью цикла.

from sqlalchemy import Column, Integer, String, Numeric
from sqlalchemy import create_engine
from myclasses import Student,base
engine = create_engine('sqlite:///college.db', echo=True)
base.metadata.create_all(engine)
from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)
sessionobj = Session()
qry=sessionobj.query(Students)
rows=qry.all()
for row in rows:
   print (row)

Обновить запись в сопоставленной таблице очень просто. Все, что вам нужно сделать, это получить запись с помощью метода get (), присвоить новое значение желаемому атрибуту и ​​затем зафиксировать изменения с помощью объекта сеанса. Ниже мы меняем оценки ученика Джухи на 100.

S1=qry.get(1)
S1.marks=100
sessionobj.commit()

Удалить запись так же просто, удалив нужный объект из сеанса.

S1=qry.get(1)
Sessionobj.delete(S1)
sessionobj.commit()

MongoDB ориентирована на документы NoSQLбаза данных. Это кроссплатформенная база данных, распространяемая по публичной лицензии на стороне сервера. Он использует JSON-подобные документы в качестве схемы.

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

Документ аналогичен строке в таблице реляционной базы данных. Однако у него нет конкретной схемы. Документ представляет собой набор пар ключ-значение, аналогичный словарю. Однако количество пар квантовых напряжений в каждом документе может отличаться. Так же, как таблица в реляционной базе данных имеет первичный ключ, документ в базе данных MongoDB имеет специальный ключ, называемый"_id".

Прежде чем мы увидим, как база данных MongoDB используется с Python, давайте вкратце разберемся, как установить и запустить MongoDB. Доступна общественная и коммерческая версия MongoDB. Версию сообщества можно загрузить с сайта www.mongodb.com/download-center/community .

Предполагая, что MongoDB установлен в c: \ mongodb, сервер можно вызвать с помощью следующей команды.

c:\mongodb\bin>mongod

По умолчанию сервер MongoDB активен на порту 22017. Базы данных по умолчанию хранятся в папке data / bin, хотя расположение можно изменить с помощью опции –dbpath.

MongoDB имеет собственный набор команд для использования в оболочке MongoDB. Чтобы вызвать оболочку, используйтеMongo команда.

x:\mongodb\bin>mongo

Подсказка оболочки, аналогичная подсказке оболочки MySQL или SQLite, перед которой могут быть выполнены собственные команды NoSQL. Однако нас интересует подключение базы данных MongoDB к Python.

PyMongoМодуль был разработан самой MongoDB Inc для обеспечения интерфейса программирования Python. Используйте известную утилиту pip для установки PyMongo.

pip3 install pymongo

Предполагая, что сервер MongoDB запущен и работает (с mongod команда) и прослушивает порт 22017, нам сначала нужно объявить MongoClientобъект. Он контролирует все транзакции между сеансом Python и базой данных.

from pymongo import MongoClient
client=MongoClient()

Используйте этот клиентский объект, чтобы установить соединение с сервером MongoDB.

client = MongoClient('localhost', 27017)

Новая база данных создается с помощью следующей команды.

db=client.newdb

База данных MongoDB может иметь множество коллекций, похожих на таблицы в реляционной базе данных. Объект Collection создаетсяCreate_collection() функция.

db.create_collection('students')

Now, we can add one or more documents in the collection as follows −

from pymongo import MongoClient
client=MongoClient()
db=client.newdb
db.create_collection("students")
student=db['students']
studentlist=[{'studentID':1,'Name':'Juhi','age':20, 'marks'=100},
{'studentID':2,'Name':'dilip','age':20, 'marks'=110},
{'studentID':3,'Name':'jeevan','age':24, 'marks'=145}]
student.insert_many(studentlist)
client.close()

To retrieve the documents (similar to SELECT query), we should use find() method. It returns a cursor with the help of which all documents can be obtained.

students=db['students']
docs=students.find()
for doc in docs:
   print (doc['Name'], doc['age'], doc['marks'] )

To find a particular document instead of all of them in a collection, we need to apply filter to find() method. The filter uses logical operators. MongoDB has its own set of logical operators as below −

Sr.No	MongoDB operator & Traditional logical operator
1	$eq equal to (==)
2	$gt greater than (>)
3	$gte greater than or equal to (>=)
4	$in if equal to any value in array
5	$lt less than (<)
6	$lte less than or equal to (<=)
7	$ne not equal to (!=)
8	$nin if not equal to any value in array

For example, we are interested in obtaining list of students older than 21 years. Using $gt operator in the filter for find() method as follows −

students=db['students']
docs=students.find({'age':{'$gt':21}})
for doc in docs:
   print (doc.get('Name'), doc.get('age'), doc.get('marks'))

PyMongo module provides update_one() and update_many() methods for modifying one document or more than one documents satisfying a specific filter expression.

Let us update marks attribute of a document in which name is Juhi.

from pymongo import MongoClient
client=MongoClient()
db=client.newdb
doc=db.students.find_one({'Name': 'Juhi'})
db['students'].update_one({'Name': 'Juhi'},{"$set":{'marks':150}})
client.close()

Cassandra is another popular NoSQL database. High scalability, consistency, and fault-tolerance - these are some of the important features of Cassandra. This is Column store database. The data is stored across many commodity servers. As a result, data highly available.

Cassandra is a product from Apache Software foundation. Data is stored in distributed manner across multiple nodes. Each node is a single server consisting of keyspaces. Fundamental building block of Cassandra database is keyspace which can be considered analogous to a database.

Data in one node of Cassandra, is replicated in other nodes over a peer-to-peer network of nodes. That makes Cassandra a foolproof database. The network is called a data center. Multiple data centers may be interconnected to form a cluster. Nature of replication is configured by setting Replication strategy and replication factor at the time of the creation of a keyspace.

One keyspace may have more than one Column families – just as one database may contain multiple tables. Cassandra’s keyspace doesn’t have a predefined schema. It is possible that each row in a Cassandra table may have columns with different names and in variable numbers.

Cassandra software is also available in two versions: community and enterprise. The latest enterprise version of Cassandra is available for download at https://cassandra.apache.org/download/. Community edition is found at https://academy.datastax.com/planet-cassandra/cassandra.

Cassandra has its own query language called Cassandra Query Language (CQL). CQL queries can be executed from inside a CQLASH shell – similar to MySQL or SQLite shell. The CQL syntax appears similar to standard SQL.

The Datastax community edition, also comes with a Develcenter IDE shown in following figure −

Python module for working with Cassandra database is called Cassandra Driver. It is also developed by Apache foundation. This module contains an ORM API, as well as a core API similar in nature to DB-API for relational databases.

Installation of Cassandra driver is easily done using pip utility.

pip3 install cassandra-driver

Interaction with Cassandra database, is done through Cluster object. Cassandra.cluster module defines Cluster class. We first need to declare Cluster object.

from cassandra.cluster import Cluster
clstr=Cluster()

All transactions such as insert/update, etc., are performed by starting a session with a keyspace.

session=clstr.connect()

To create a new keyspace, use execute() method of session object. The execute() method takes a string argument which must be a query string. The CQL has CREATE KEYSPACE statement as follows. The complete code is as below −

from cassandra.cluster import Cluster
clstr=Cluster()
session=clstr.connect()
session.execute(“create keyspace mykeyspace with replication={
   'class': 'SimpleStrategy', 'replication_factor' : 3
};”

Here, SimpleStrategy is a value for replication strategy and replication factor is set to 3. As mentioned earlier, a keyspace contains one or more tables. Each table is characterized by it data type. Python data types are automatically parsed with corresponding CQL data types according to following table −

Python Type	CQL Type
None	NULL
Bool	Boolean
Float	float, double
int, long	int, bigint, varint, smallint, tinyint, counter
decimal.Decimal	Decimal
str, Unicode	ascii, varchar, text
buffer, bytearray	Blob
Date	Date
Datetime	Timestamp
Time	Time
list, tuple, generator	List
set, frozenset	Set
dict, OrderedDict	Map
uuid.UUID	timeuuid, uuid

To create a table, use session object to execute CQL query for creating a table.

from cassandra.cluster import Cluster
clstr=Cluster()
session=clstr.connect('mykeyspace')
qry= '''
create table students (
   studentID int,
   name text,
   age int,
   marks int,
   primary key(studentID)
);'''
session.execute(qry)

The keyspace so created can be further used to insert rows. The CQL version of INSERT query is similar to SQL Insert statement. Following code inserts a row in students table.

from cassandra.cluster import Cluster
clstr=Cluster()
session=clstr.connect('mykeyspace')
session.execute("insert into students (studentID, name, age, marks) values 
   (1, 'Juhi',20, 200);"

As you would expect, SELECT statement is also used with Cassandra. In case of execute() method containing SELECT query string, it returns a result set object which can be traversed using a loop.

from cassandra.cluster import Cluster
clstr=Cluster()
session=clstr.connect('mykeyspace')
rows=session.execute("select * from students;")
for row in rows:
print (StudentID: {} Name:{} Age:{} price:{} Marks:{}'
   .format(row[0],row[1], row[2], row[3]))

Cassandra’s SELECT query supports use of WHERE clause to apply filter on result set to be fetched. Traditional logical operators like <, > == etc. are recognized. To retrieve, only those rows from students table for names with age>20, the query string in execute() method should be as follows −

rows=session.execute("select * from students WHERE age>20 allow filtering;")

Note, the use of ALLOW FILTERING. The ALLOW FILTERING part of this statement allows to explicitly allow (some) queries that require filtering.

Cassandra driver API defines following classes of Statement type in its cassendra.query module.

SimpleStatement

A simple, unprepared CQL query contained in a query string. All examples above are examples of SimpleStatement.

BatchStatement

Multiple queries (such as INSERT, UPDATE, and DELETE) are put in a batch and executed at once. Each row is first converted as a SimpleStatement and then added in a batch.

Let us put rows to be added in Students table in the form of list of tuples as follows −

studentlist=[(1,'Juhi',20,100), ('2,'dilip',20, 110),(3,'jeevan',24,145)]

To add above rows using BathStatement, run following script −

from cassandra.query import SimpleStatement, BatchStatement
batch=BatchStatement()
for student in studentlist:
   batch.add(SimpleStatement("INSERT INTO students 
      (studentID, name, age, marks) VALUES
      (%s, %s, %s %s)"), (student[0], student[1],student[2], student[3]))
session.execute(batch)

PreparedStatement

Prepared statement is like a parameterized query in DB-API. Its query string is saved by Cassandra for later use. The Session.prepare() method returns a PreparedStatement instance.

For our students table, a PreparedStatement for INSERT query is as follows −

stmt=session.prepare("INSERT INTO students (studentID, name, age, marks) VALUES (?,?,?)")

Subsequently, it only needs to send the values of parameters to bind. For example −

qry=stmt.bind([1,'Ram', 23,175])

Finally, execute the bound statement above.

session.execute(qry)

This reduces network traffic and CPU utilization because Cassandra does not have to re-parse the query each time.

ZODB (Zope object Database) is database for storing Python objects. It is ACID compliant - feature not found in NOSQL databases. The ZODB is also open source, horizontally scalable and schema-free, like many NoSQL databases. However, it is not distributed and does not offer easy replication. It provides persistence mechanism for Python objects. It is a part of Zope Application server, but can also be independently used.

ZODB was created by Jim Fulton of Zope Corporation. It started as simple Persistent Object System. Its current version is 5.5.0 and is written completely in Python. using an extended version of Python's built-in object persistence (pickle).

Some of the main features of ZODB are −

• transactions
• history/undo
• transparently pluggable storage
• built-in caching
• multiversion concurrency control (MVCC)
• scalability across a network

The ZODB is a hierarchical database. There is a root object, initialized when a database is created. The root object is used like a Python dictionary and it can contain other objects (which can be dictionary-like themselves). To store an object in the database, it’s enough to assign it to a new key inside its container.

ZODB is useful for applications where data is hierarchical and there are likely to be more reads than writes. ZODB is an extension of pickle object. That's why it can be processed through Python script only.

To install latest version of ZODB let use pip utility −

pip install zodb

Following dependencies are also installed −

• BTrees==4.6.1
• cffi==1.13.2
• persistent==4.5.1
• pycparser==2.19
• six==1.13.0
• transaction==2.4.0

ZODB provides following storage options −

FileStorage

This is the default. Everything stored in one big Data.fs file, which is essentially a transaction log.

DirectoryStorage

This stores one file per object revision. In this case, it does not require the Data.fs.index to be rebuilt on an unclean shutdown.

RelStorage

This stores pickles in a relational database. PostgreSQL, MySQL and Oracle are supported.

To create ZODB database we need a storage, a database and finally a connection.

First step is to have storage object.

import ZODB, ZODB.FileStorage
storage = ZODB.FileStorage.FileStorage('mydata.fs')

DB class uses this storage object to obtain database object.

db = ZODB.DB(storage)

Pass None to DB constructor to create in-memory database.

Db=ZODB.DB(None)

Finally, we establish connection with the database.

conn=db.open()

The connection object then gives you access to the ‘root’ of the database with the ‘root()’ method. The ‘root’ object is the dictionary that holds all of your persistent objects.

root = conn.root()

For example, we add a list of students to the root object as follows −

root['students'] = ['Mary', 'Maya', 'Meet']

This change is not permanently saved in the database till we commit the transaction.

import transaction
transaction.commit()

To store object of a user defined class, the class must be inherited from persistent.Persistent parent class.

Advantages of Subclassing

Subclassing Persistent class has its advantages as follows −

• The database will automatically track object changes made by setting attributes.

• Data will be saved in its own database record.

• You can save data that doesn’t subclass Persistent, but it will be stored in the database record of whatever persistent object references it. Non-persistent objects are owned by their containing persistent object and if multiple persistent objects refer to the same non-persistent subobject, they’ll get their own copies.

Let use define a student class subclassing Persistent class as under −

import persistent
   class student(persistent.Persistent):
   def __init__(self, name):
      self.name = name
   def __repr__(self):
      return str(self.name)

To add object of this class, let us first set up the connection as described above.

import ZODB, ZODB.FileStorage
storage = ZODB.FileStorage.FileStorage('studentdata.fs')
db = ZODB.DB(storage)
conn=db.open()
root = conn.root()

Declare object an add to root and then commit the transaction

s1=student("Akash")
root['s1']=s1
import transaction
transaction.commit()
conn.close()

List of all objects added to root can be retrieved as a view object with the help of items() method since root object is similar to built in dictionary.

print (root.items())
ItemsView({'s1': Akash})

To fetch attribute of specific object from root,

print (root['s1'].name)
Akash

The object can be easily updated. Since the ZODB API is a pure Python package, it doesn’t require any external SQL type language to be used.

root['s1'].name='Abhishek'
import transaction
transaction.commit()

The database will be updated instantly. Note that transaction class also defines abort() function which is similar to rollback() transaction control in SQL.

Microsoft’s Excel is the most popular spreadsheet application. It has been in use since last more than 25 years. Later versions of Excel use Office Open XML (OOXML) file format. Hence, it has been possible to access spreadsheet files through other programming environments.

OOXML is an ECMA standard file format. Python’s openpyxl package provides functionality to read/write Excel files with .xlsx extension.

The openpyxl package uses class nomenclature that is similar to Microsoft Excel terminology. An Excel document is called as workbook and is saved with .xlsx extension in the file system. A workbook may have multiple worksheets. A worksheet presents a large grid of cells, each one of them can store either value or formula. Rows and columns that form the grid are numbered. Columns are identified by alphabets, A, B, C, …., Z, AA, AB, and so on. Rows are numbered starting from 1.

A typical Excel worksheet appears as follows −

The pip utility is good enough to install openpyxl package.

pip install openpyxl

The Workbook class represents an empty workbook with one blank worksheet. We need to activate it so that some data can be added to the worksheet.

from openpyxl import Workbook
wb=Workbook()
sheet1=wb.active
sheet1.title='StudentList'

As we know, a cell in worksheet is named as ColumnNameRownumber format. Accordingly, top left cell is A1. We assign a string to this cell as −

sheet1['A1']= 'Student List'

Alternately, use worksheet’s cell() method which uses row and column number to identify a cell. Call value property to cell object to assign a value.

cell1=sheet1.cell(row=1, column=1)
cell1.value='Student List'

After populating worksheet with data, the workbook is saved by calling save() method of workbook object.

wb.save('Student.xlsx')

This workbook file is created in current working directory.

Following Python script writes a list of tuples into a workbook document. Each tuple stores roll number, age and marks of student.

from openpyxl import Workbook
wb = Workbook()
sheet1 = wb.active
sheet1.title='Student List'
sheet1.cell(column=1, row=1).value='Student List'
studentlist=[('RollNo','Name', 'age', 'marks'),(1,'Juhi',20,100), 
   (2,'dilip',20, 110) , (3,'jeevan',24,145)]
for col in range(1,5):
   for row in range(1,5):
      sheet1.cell(column=col, row=1+row).value=studentlist[row-1][col-1]
wb.save('students.xlsx')

The workbook students.xlsx is saved in current working directory. If opened using Excel application, it appears as below −

The openpyxl module offers load_workbook() function that helps in reading back data in the workbook document.

from openpyxl import load_workbook
wb=load_workbook('students.xlsx')

You can now access value of any cell specified by row and column number.

cell1=sheet1.cell(row=1, column=1)
print (cell1.value)
Student List

Example

Following code populates a list with work sheet data.

from openpyxl import load_workbook
wb=load_workbook('students.xlsx')
sheet1 = wb['Student List']
studentlist=[]
for row in range(1,5):
   stud=[]
for col in range(1,5):
   val=sheet1.cell(column=col, row=1+row).value
stud.append(val)
studentlist.append(tuple(stud))
print (studentlist)

Output

[('RollNo', 'Name', 'age', 'marks'), (1, 'Juhi', 20, 100), (2, 'dilip', 20, 110), (3, 'jeevan', 24, 145)]

One very important feature of Excel application is the formula. To assign formula to a cell, assign it to a string containing Excel’s formula syntax. Assign AVERAGE function to c6 cell having age.

sheet1['C6']= 'AVERAGE(C3:C5)'

Openpyxl module has Translate_formula() function to copy the formula across a range. Following program defines AVERAGE function in C6 and copies it to C7 that calculates average of marks.

from openpyxl import load_workbook
wb=load_workbook('students.xlsx')

sheet1 = wb['Student List']
from openpyxl.formula.translate import Translator#copy formula
sheet1['B6']='Average'
sheet1['C6']='=AVERAGE(C3:C5)'
sheet1['D6'] = Translator('=AVERAGE(C3:C5)', origin="C6").translate_formula("D6")
wb.save('students.xlsx')

The changed worksheet now appears as follows −