Python 데이터 지속성-빠른 가이드

Python 개요-데이터 지속성

소프트웨어 응용 프로그램을 사용하는 동안 사용자는 처리 할 일부 데이터를 제공합니다. 데이터는 표준 입력 장치 (키보드) 또는 디스크 파일, 스캐너, 카메라, 네트워크 케이블, WiFi 연결 등과 같은 기타 장치를 사용하여 입력 할 수 있습니다.

이렇게 수신 된 데이터는 응용 프로그램이 실행될 때까지 변수 및 개체와 같은 다양한 데이터 구조의 형태로 컴퓨터의 주 메모리 (RAM)에 저장됩니다. 그 후 RAM의 메모리 내용이 삭제됩니다.

그러나 종종 동일한 데이터를 다시 입력하는 대신 필요할 때마다 검색 할 수 있도록 변수 및 / 또는 개체의 값을 저장하는 것이 바람직합니다.

'지속성'이라는 단어는 "원인이 제거 된 후에도 효과의 지속"을 의미합니다. 데이터 지속성이라는 용어는 애플리케이션이 종료 된 후에도 계속 존재 함을 의미합니다. 따라서 디스크 파일과 같은 비 휘발성 저장 매체에 저장된 데이터는 영구 데이터 저장소입니다.

이 튜토리얼에서는 텍스트 파일, CSV, JSON 및 XML 파일은 물론 관계형 및 비 관계형 데이터베이스와 같은 다양한 형식으로 데이터를 저장하고 검색하기 위해 다양한 내장 및 타사 Python 모듈을 탐색합니다.

Python의 내장 File 객체를 사용하면 문자열 데이터를 디스크 파일에 쓰고 읽을 수 있습니다. Python의 표준 라이브러리는 JSON 및 XML과 같은 다양한 데이터 구조로 직렬화 된 데이터를 저장하고 검색하는 모듈을 제공합니다.

Python의 DB-API는 관계형 데이터베이스와 상호 작용하는 표준 방식을 제공합니다. 다른 타사 Python 패키지는 MongoDB 및 Cassandra와 같은 NOSQL 데이터베이스와의 인터페이스 기능을 제공합니다.

이 튜토리얼은 또한 Python 객체를위한 지속성 API 인 ZODB 데이터베이스를 소개합니다. Microsoft Excel 형식은 매우 널리 사용되는 데이터 파일 형식입니다. 이 튜토리얼에서는 Python을 통해 .xlsx 파일을 처리하는 방법을 배웁니다.

파이썬은 내장을 사용합니다 input() 과 print()표준 입력 / 출력 작업을 수행하는 기능. input () 함수는 표준 입력 스트림 장치, 즉 키보드에서 바이트를 읽습니다.

그만큼 print()반면에 기능은 표준 출력 스트림 장치 즉, 디스플레이 모니터로 데이터를 보냅니다. Python 프로그램은 표준 스트림 객체를 통해 이러한 IO 장치와 상호 작용합니다.stdin 과 stdout sys 모듈에 정의되어 있습니다.

그만큼 input()함수는 실제로 sys.stdin 객체의 readline () 메서드를 둘러싼 래퍼입니다. 입력 스트림의 모든 키 입력은 '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() stdout 객체의 write () 메서드를 에뮬레이트하는 편리한 함수입니다.

>>> 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)

name 매개 변수는 디스크 파일의 이름 또는 바이트 문자열이고, mode는 수행 할 작업 유형 (읽기, 쓰기, 추가 등)을 지정하는 선택적 한 문자 문자열이며 버퍼링 매개 변수는 0, 1 또는 -1입니다. 버퍼링은 해제, 설정 또는 시스템 기본값입니다.

파일 열기 모드는 아래 표에 따라 열거됩니다. 기본 모드는 'r'입니다.

Sr. 아니요	매개 변수 및 설명
1	R 읽기 위해 열기 (기본값)
2	W 쓰기 위해 열기, 먼저 파일 잘라 내기
삼	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)

바이너리 파일에서 다시 읽으려면 from_bytes () 함수를 사용하여 read () 함수의 출력을 정수로 변환하십시오.

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 오류가 발생합니다. 다른 작업을 수행하기 전에 파일을 닫아야합니다.

두 작업을 동시에 수행하려면 mode 매개 변수에 '+'문자를 추가해야합니다. 따라서 '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()

다음 표는 객체와 같은 파일에 사용할 수있는 모든 방법을 요약합니다.

Sr. 아니요	방법 및 설명
1	close() 파일을 닫습니다. 닫힌 파일은 더 이상 읽거나 쓸 수 없습니다.
2	flush() 내부 버퍼를 플러시합니다.
삼	fileno() 정수 파일 설명자를 반환합니다.
4	next() 호출 될 때마다 파일에서 다음 줄을 반환합니다. Python 3에서 next () 반복자를 사용합니다.
5	read([size]) 파일에서 최대 size 바이트를 읽습니다 (크기 바이트를 얻기 전에 읽기가 EOF에 도달하는 경우 더 적음).
6	readline([size]) 파일에서 한 줄 전체를 읽습니다. 후행 개행 문자는 문자열에 유지됩니다.
7	readlines([sizehint]) readline ()을 사용하여 EOF까지 읽고 행을 포함하는 목록을 반환합니다.
8	seek(offset[, whence]) 파일의 현재 위치를 설정합니다. 0 시작 1 현재 2 끝.
9	seek(offset[, whence]) 파일의 현재 위치를 설정합니다. 0 시작 1 현재 2 끝.
10	tell() 파일의 현재 위치를 반환합니다.
11	truncate([size]) 파일 크기를 자릅니다.
12	write(str) 파일에 문자열을 씁니다. 반환 값이 없습니다.

에 의해 반환 된 File 객체 외에 open()함수, 파일 IO 작업은 Python의 내장 라이브러리를 사용하여 수행 할 수도 있습니다. OS 모듈에는 유용한 운영 체제 종속 함수를 제공합니다. 이 함수는 파일에 대해 낮은 수준의 읽기 / 쓰기 작업을 수행합니다.

그만큼 open()os 모듈의 함수는 내장 open ()과 유사합니다. 그러나 파일 객체가 아니라 파일 설명자, 열린 파일에 해당하는 고유 한 정수를 반환합니다. 파일 설명 자의 값 0, 1 및 2는 stdin, stdout 및 stderr 스트림을 나타냅니다. 다른 파일에는 2부터 증분 파일 설명자가 제공됩니다.

의 경우와 같이 open() 내장 기능, os.open()함수는 파일 액세스 모드도 지정해야합니다. 다음 표는 os 모듈에 정의 된 다양한 모드를 나열합니다.

Sr. 아니.	OS 모듈 및 설명
1	os.O_RDONLY 읽기 전용
2	os.O_WRONLY 쓰기 전용으로 열기
삼	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')

os 모듈의 write () 함수는이 바이트 문자열과 파일 설명자를받습니다.

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 모드를 사용하십시오. 다음 표는 os 모듈에서 중요한 파일 동작 관련 기능을 보여줍니다.

Sr. 아니요	기능 및 설명
1	os.close(fd) 파일 설명자를 닫습니다.
2	os.open(file, flags[, mode]) 파일을 열고 플래그에 따라 다양한 플래그를 설정하고 모드에 따라 모드를 설정합니다.
삼	os.read(fd, n) 파일 설명자 fd에서 최대 n 바이트를 읽습니다. 읽은 바이트를 포함하는 문자열을 반환합니다. fd가 참조하는 파일의 끝에 도달하면 빈 문자열이 반환됩니다.
4	os.write(fd, str) 문자열 str을 파일 설명자 fd에 씁니다. 실제로 쓴 바이트 수를 반환합니다.

Python의 내장 open () 함수가 반환하는 Python의 내장 파일 객체에는 한 가지 중요한 단점이 있습니다. '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의 내장 라이브러리에는 직렬화 및 역 직렬화 프로세스를위한 다양한 모듈이 포함되어 있습니다.

Sr. 아니.	이름 및 설명
1	pickle Python 특정 직렬화 라이브러리
2	marshal 직렬화를 위해 내부적으로 사용되는 라이브러리
삼	shelve Pythonic 객체 지속성
4	dbm Unix 데이터베이스에 대한 인터페이스를 제공하는 라이브러리
5	csv Python 데이터를 CSV 형식으로 저장 및 검색하기위한 라이브러리
6	json 범용 JSON 형식으로 직렬화하기위한 라이브러리

직렬화 및 역 직렬화에 대한 Python의 용어는 각각 피클 링 및 언 피클 링입니다. Python 라이브러리의 pickle 모듈은 매우 Python 특정 데이터 형식을 사용합니다. 따라서 비 Python 애플리케이션은 피클 된 데이터를 올바르게 역 직렬화하지 못할 수 있습니다. 또한 인증되지 않은 소스에서 데이터를 제거하지 않는 것이 좋습니다.

직렬화 된 (피클 된) 데이터는 바이트 문자열 또는 이진 파일에 저장할 수 있습니다. 이 모듈은dumps() 과 loads()바이트 문자열을 사용하여 데이터를 피클 및 언 피클하는 함수. 파일 기반 프로세스의 경우 모듈은dump() 과 load() 함수.

Python의 피클 프로토콜은 이진 데이터로 /에서 Python 객체를 구성하고 분해하는 데 사용되는 규칙입니다. 현재 pickle 모듈은 아래 나열된 5 가지 프로토콜을 정의합니다.

Sr. 아니.	이름 및 설명
1	Protocol version 0 원래의 "사람이 읽을 수있는"프로토콜은 이전 버전과 역 호환됩니다.
2	Protocol version 1 이전 바이너리 형식은 이전 버전의 Python 과도 호환됩니다.
삼	Protocol version 2 Python 2.3에 도입되어 새로운 스타일의 클래스를 효율적으로 피클 링 할 수 있습니다.
4	Protocol version 3 Python 3.0에 추가되었습니다. 다른 Python 3 버전과의 호환성이 필요한 경우 권장됩니다.
5	Protocol version 4 Python 3.4에 추가되었습니다. 매우 큰 개체에 대한 지원을 추가합니다.

예

pickle 모듈은 pickled 데이터의 문자열 표현을 반환하는 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.

예

loads () 함수를 사용하여 문자열을 언 피클하고 원래 사전 객체를 얻습니다.

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)

Python의 표준 라이브러리에있는 marshal 모듈의 객체 직렬화 기능은 pickle 모듈과 유사합니다. 그러나이 모듈은 범용 데이터에는 사용되지 않습니다. 반면에, 파이썬 자체에서 파이썬 모듈 (.pyc 파일)의 컴파일 된 버전에 대한 읽기 / 쓰기 작업을 지원하기 위해 파이썬의 내부 객체 직렬화에 사용됩니다.

marshal 모듈에서 사용하는 데이터 형식은 Python 버전간에 호환되지 않습니다. 따라서 한 버전의 컴파일 된 Python 스크립트 (.pyc 파일)는 아마도 다른 버전에서 실행되지 않을 것입니다.

pickle 모듈과 마찬가지로 marshal 모듈은 /에서 파일로 마샬링 된 객체를 읽고 쓰기 위해 load () 및 dump () 함수를 정의했습니다.

덤프()

이 함수는 지원되는 Python 객체의 바이트 표현을 파일에 씁니다. 파일 자체는 쓰기 권한이있는 이진 파일입니다.

하중()

이 함수는 바이너리 파일에서 바이트 데이터를 읽고이를 Python 객체로 변환합니다.

다음 예제는 미리 컴파일 된 Python 모듈을 저장하는 데 사용되는 Python의 코드 객체를 처리하기 위해 dump () 및 load () 함수를 사용하는 방법을 보여줍니다.

코드는 기본 제공 compile() Python 명령어를 포함하는 소스 문자열에서 코드 객체를 빌드하는 함수입니다.

compile(source, file, mode)

파일 매개 변수는 코드를 읽은 파일이어야합니다. 파일에서 읽지 않은 경우 임의의 문자열을 전달하십시오.

mode 매개 변수는 소스에 일련의 명령문이 포함 된 경우 'exec', 단일 표현식이있는 경우 'eval', 단일 대화 형 명령문이 포함 된 경우 'single'입니다.

컴파일 코드 객체는 dump () 함수를 사용하여 .pyc 파일에 저장됩니다.

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()

deserialize하려면 .pyc 파일의 객체가 load () 함수를 사용합니다. 코드 객체를 반환하기 때문에 다른 내장 함수 인 exec ()를 사용하여 실행할 수 있습니다.

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

Python 표준 라이브러리의 shelve 모듈은 간단하면서도 효과적인 객체 지속성 메커니즘을 제공합니다. 이 모듈에 정의 된 선반 객체는 디스크 파일에 지속적으로 저장되는 사전과 유사한 객체입니다. 이렇게하면 UNIX와 유사한 시스템에서 dbm 데이터베이스와 유사한 파일이 생성됩니다.

선반 사전에는 특정 제한 사항이 있습니다. 이 특수 딕셔너리 객체에서는 문자열 데이터 유형 만 키로 사용할 수있는 반면, picklable Python 객체는 값으로 사용할 수 있습니다.

shelve 모듈은 다음과 같이 세 가지 클래스를 정의합니다.

Sr. 아니요	선반 모듈 및 설명
1	Shelf 선반 구현을위한 기본 클래스입니다. dict-like 객체로 초기화됩니다.
2	BsdDbShelf Shelf 클래스의 하위 클래스입니다. 생성자에 전달 된 dict 객체는 first (), next (), previous (), last () 및 set_location () 메서드를 지원해야합니다.
삼	DbfilenameShelf 이것은 또한 Shelf의 하위 클래스이지만 dict 객체가 아닌 생성자에 대한 매개 변수로 파일 이름을받습니다.

shelve 모듈에 정의 된 open () 함수는 DbfilenameShelf 목적.

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

파일 이름 매개 변수는 생성 된 데이터베이스에 할당됩니다. 플래그 매개 변수의 기본값은 읽기 / 쓰기 액세스의 경우 '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 파일이 생성되고 키-값 데이터가 해시 형식으로 저장됩니다. 선반 객체는 다음과 같은 방법을 사용할 수 있습니다.

Sr. 아니.	방법 및 설명
1	close() 영구 dict 개체를 동기화하고 닫습니다.
2	sync() 쓰기 저장이 True로 설정된 선반이 열린 경우 캐시의 모든 항목을 다시 씁니다.
삼	get() 키와 관련된 값을 반환합니다.
4	items() 튜플 목록 – 각 튜플은 키 값 쌍입니다.
5	keys() 선반 키 목록
6	pop() 지정된 키를 제거하고 해당 값을 반환합니다.
7	update() 다른 dict / iterable에서 선반 업데이트
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 라이브러리는 Ken Thompson이 작성한 간단한 데이터베이스 엔진입니다. 이러한 데이터베이스는 이진 인코딩 문자열 객체를 키와 값으로 사용합니다.

데이터베이스는 고정 된 크기의 버킷에 단일 키 (기본 키)를 사용하여 데이터를 저장하고 해싱 기술을 사용하여 키별로 데이터를 빠르게 검색 할 수 있습니다.

dbm 패키지에는 다음 모듈이 포함되어 있습니다.

dbm.gnu 모듈은 GNU 프로젝트에 의해 구현 된 DBM 라이브러리 버전에 대한 인터페이스입니다.
dbm.ndbm 모듈은 UNIX nbdm 구현에 대한 인터페이스를 제공합니다.
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. 아니.	가치 및 의미
1	'r' 읽기 전용으로 기존 데이터베이스 열기 (기본값)
2	'w' 읽기 및 쓰기를 위해 기존 데이터베이스 열기
삼	'c' 읽고 쓰기 위해 데이터베이스를 열고 존재하지 않는 경우 생성
4	'n' 항상 비어있는 새 데이터베이스를 만들고 읽고 쓰기 위해 엽니 다.

dbm 객체는 선반 객체와 마찬가지로 객체와 같은 사전입니다. 따라서 모든 사전 작업을 수행 할 수 있습니다. dbm 객체는 get (), pop (), append () 및 update () 메서드를 호출 할 수 있습니다. 다음 코드는 'r'플래그와 함께 'mydbm.db'를 열고 키-값 쌍의 수집을 반복합니다.

>>> 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 모듈은 PEP 305의 결과로 Python의 표준 라이브러리에 통합되었습니다. PEP 305의 권장 사항에 따라 CSV 파일에 대한 읽기 / 쓰기 작업을 수행하는 클래스와 메서드를 제공합니다.

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

현재 디렉토리에 'persons.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']

판독기 개체는 반복기입니다. 따라서 csv 파일의 모든 행을 표시하는 데 사용할 수있는 next () 함수를 지원합니다.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 모듈은 또한 dialect 클래스를 정의합니다. Dialect는 CSV 프로토콜을 구현하는 데 사용되는 표준 집합입니다. 사용 가능한 방언 목록은 list_dialects () 함수로 얻을 수 있습니다.

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

iterables 외에도 csv 모듈은 사전 객체를 CSV 파일로 내보내고 읽어서 Python 사전 객체를 채울 수 있습니다. 이를 위해이 모듈은 다음 클래스를 정의합니다.

DictWriter ()

이 함수는 DictWriter 개체를 반환합니다. writer 개체와 비슷하지만 행이 사전 개체에 매핑됩니다. 이 함수에는 쓰기 권한이있는 파일 개체와 사전에 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()

persons.csv 파일은 다음 내용을 보여줍니다-

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

DictReader ()

이 함수는 기본 CSV 파일에서 DictReader 개체를 반환합니다. 리더 객체의 경우이 객체도 파일의 내용을 검색하는 반복자입니다.

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과 유사합니다. 그러나 피클 직렬화는 Python에 따라 다르지만 JSON 형식은 여러 언어로 구현되어 범용 표준이되었습니다. Python의 표준 라이브러리에있는 json 모듈의 기능 및 인터페이스는 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 유형으로 변환됩니다.

파이썬	JSON
딕트	목적
목록, 튜플	정렬
Str	끈
int, float, int- 및 float 파생 열거 형	번호
진실	진실
그릇된	그릇된
없음	없는

JSONEncoder 클래스는 JSONEncoder () 생성자에 의해 인스턴스화됩니다. 인코더 클래스에 다음과 같은 중요한 방법이 정의되어 있습니다.

Sr. 아니.	방법 및 설명
1	encode() Python 객체를 JSON 형식으로 직렬화합니다.
2	iterencode() 개체를 인코딩하고 개체에있는 각 항목의 인코딩 된 형식을 생성하는 반복기를 반환합니다.
삼	indent 인코딩 된 문자열의 들여 쓰기 수준을 결정합니다.
4	sort_keys 키가 정렬 된 순서로 표시되도록하려면 true 또는 false입니다.
5	Check_circular True이면 컨테이너 유형 객체에서 순환 참조를 확인합니다.

다음 예제는 Python 목록 객체를 인코딩합니다.

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

JSONDecoder 클래스

이 클래스의 객체는 파이썬 데이터 구조로 다시 json 문자열로 디코딩하는 데 도움이됩니다. 이 클래스의 주요 메서드는 decode ()입니다. 다음 예제 코드는 이전 단계에서 인코딩 된 문자열에서 Python 목록 객체를 검색합니다.

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

json 모듈은 load() 과 dump() 객체와 같은 파일에 JSON 데이터를 쓰는 함수 – 디스크 파일 또는 바이트 스트림 일 수 있으며 데이터를 다시 읽을 수 있습니다.

덤프()

이 함수는 JSON 형식의 Python 개체 데이터를 파일에 씁니다. 파일은 '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]}]

하중()

이 함수는 파일에서 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 Consortium에서 권장합니다.

웹 서비스, 오피스 도구 및 웹 서비스와 같은 많은 애플리케이션에서 사용되는 잘 알려진 데이터 교환 형식입니다. Service Oriented Architectures(SOA). XML 형식은 기계와 사람이 모두 읽을 수 있습니다.

표준 Python 라이브러리의 xml 패키지는 XML 처리를위한 다음 모듈로 구성됩니다.

Sr. 아니.	모듈 및 설명
1	xml.etree.ElementTree 간단하고 가벼운 XML 프로세서 인 ElementTree API
2	xml.dom DOM API 정의
삼	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 구문 분석을위한 표준 인터페이스입니다. SAX로 XML을 구문 분석하려면 xml.sax.ContentHandler를 서브 클래 싱하여 ContentHandler가 필요합니다. 관심있는 이벤트에 대한 콜백을 등록한 다음 파서가 문서를 진행하도록합니다.

SAX는 문서가 크거나 전체 파일이 메모리에 저장되지 않으므로 디스크에서 파일을 읽을 때 파일을 구문 분석하므로 메모리 제한이있을 때 유용합니다.

문서 개체 모델

(DOM) API는 World Wide Web Consortium 권장 사항입니다. 이 경우 전체 파일을 메모리로 읽어 들이고 계층 적 (트리 기반) 형식으로 저장하여 XML 문서의 모든 기능을 나타냅니다.

DOM만큼 빠르지 않은 SAX, 대용량 파일. 반면에 DOM은 많은 작은 파일에 사용되는 경우 리소스를 죽일 수 있습니다. SAX는 읽기 전용이지만 DOM은 XML 파일 변경을 허용합니다.

plist 형식은 주로 MAC OS X에서 사용됩니다. 이러한 파일은 기본적으로 XML 문서입니다. 객체의 속성을 저장하고 검색합니다. 파이썬 라이브러리에는 '속성 목록'파일 (보통 .plist '확장자를 가짐)을 읽고 쓰는 데 사용되는 plist 모듈이 포함되어 있습니다.

그만큼 plistlib 모듈은 의미에서 다른 직렬화 라이브러리와 다소 유사하며 Python 객체의 문자열 표현을위한 dumps () 및 loads () 함수와 디스크 작업을위한 load () 및 dump () 함수를 제공합니다.

다음 사전 객체는 속성 (키) 및 해당 값을 유지합니다.

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

이러한 속성을 디스크 파일에 쓰기 위해 plist 모듈에서 dump () 함수를 호출합니다.

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'그리고 이것은 둘 사이의 관계의 기초를 형성합니다. 이 모델을 기반으로 현재 사용 가능한 인기있는 RDBMS 제품이 많이 있습니다.

GadFly
mSQL
MySQL
PostgreSQL
마이크로 소프트 SQL 서버 2000
Informix
Interbase
Oracle
Sybase
SQLite

SQLite는 다양한 애플리케이션에서 사용되는 경량 관계형 데이터베이스입니다. 자체 포함, 서버리스, 구성이 필요없는 트랜잭션 SQL 데이터베이스 엔진입니다. 전체 데이터베이스는 파일 시스템의 어느 곳에 나 배치 할 수있는 단일 파일입니다. 풋 프린트가 매우 작고 구성이없는 오픈 소스 소프트웨어입니다. 임베디드 장치, IOT 및 모바일 앱에서 널리 사용됩니다.

모든 관계형 데이터베이스는 테이블의 데이터를 처리하기 위해 SQL을 사용합니다. 그러나 이전에는 이러한 각 데이터베이스를 데이터베이스 유형에 맞는 Python 모듈의 도움으로 Python 응용 프로그램과 연결했습니다.

따라서 그들 사이에는 호환성이 부족했습니다. 사용자가 다른 데이터베이스 제품으로 변경하고 싶다면 어려울 수 있습니다. 이 비 호환성 문제는 'Python Enhancement Proposal (PEP 248)'을 제기하여 DB-API로 알려진 관계형 데이터베이스에 대한 일관된 인터페이스를 권장함으로써 해결되었습니다. 최신 권장 사항이 호출됩니다.DB-API버전 2.0. (PEP 249)

Python의 표준 라이브러리는 Python 프로그램을 통해 SQLite 데이터베이스를 처리하기위한 DB-API 호환 모듈 인 sqlite3 모듈로 구성됩니다. 이 장에서는 SQLite 데이터베이스와 Python의 연결에 대해 설명합니다.

앞서 언급했듯이 Python은 sqlite3 모듈의 형태로 SQLite 데이터베이스에 대한 지원을 내장하고 있습니다. 다른 데이터베이스의 경우 각각의 DB-API 호환 Python 모듈은 pip 유틸리티를 사용하여 설치해야합니다. 예를 들어 MySQL 데이터베이스를 사용하려면 PyMySQL 모듈을 설치해야합니다.

pip install pymysql

다음 단계는 DB-API에서 권장됩니다-

다음을 사용하여 데이터베이스와의 연결 설정 connect() 기능을 수행하고 연결 개체를 얻습니다.
요구 cursor() 커서 객체를 얻기위한 연결 객체의 메소드.
실행할 SQL 문으로 구성된 쿼리 문자열을 구성합니다.
다음을 호출하여 원하는 쿼리를 실행합니다. execute() 방법.
연결을 닫습니다.

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

여기서 db는 test.db를 나타내는 연결 개체입니다. 데이터베이스가 아직 없으면 생성됩니다. 연결 개체 db에는 다음과 같은 방법이 있습니다.

Sr. 아니.	방법 및 설명
1	cursor(): 이 Connection을 사용하는 Cursor 객체를 반환합니다.
2	commit(): 보류중인 트랜잭션을 데이터베이스에 명시 적으로 커밋합니다.
삼	rollback(): 이 선택적 메서드는 트랜잭션이 시작 지점으로 롤백되도록합니다.
4	close(): 데이터베이스에 대한 연결을 영구적으로 닫습니다.

커서는 주어진 SQL 쿼리에 대한 핸들 역할을하여 하나 이상의 결과 행을 검색 할 수 있도록합니다. Cursor 객체는 다음 명령문을 사용하여 SQL 쿼리를 실행하기 위해 연결에서 얻습니다.

cur=db.cursor()

커서 객체에는 다음과 같은 방법이 정의되어 있습니다.

Sr. 아니요	방법 및 설명
1	execute() 문자열 매개 변수에서 SQL 쿼리를 실행합니다.
2	executemany() 튜플 목록의 매개 변수 집합을 사용하여 SQL 쿼리를 실행합니다.
삼	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 () 메서드를 사용하여 트랜잭션이 취소됩니다.

다음 코드는 test.db의 student 테이블에 대해 INSERT 쿼리를 실행합니다.

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 쿼리의 values 절에있는 데이터를 원하면 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 쿼리 구문이 포함되어야합니다. name = 'Anil'의 'age'값을 23으로 업데이트하려면 다음과 같이 문자열을 정의합니다.

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()

마찬가지로, SQL의 DELETE 쿼리 구문이있는 문자열로 execute () 메서드를 호출하여 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목적에 대한 쿼리. SELECT 쿼리 구문이 포함 된 문자열이 execute () 메서드에 제공되면 결과 집합 개체가 반환됩니다. 결과 집합에서 하나 이상의 레코드를 검색 할 수있는 커서 개체를 사용하는 두 가지 중요한 메서드가 있습니다.

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()

SQLite 데이터베이스 대신 MySQL 데이터베이스를 사용하려면 다음을 설치해야합니다. PyMySQL위에서 설명한대로 모듈. 데이터베이스 연결 프로세스의 모든 단계는 동일합니다. MySQL 데이터베이스가 서버에 설치되어 있으므로 connect () 함수에는 URL과 로그인 자격 증명이 필요합니다.

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

SQLite와 다를 수있는 유일한 것은 MySQL 특정 데이터 유형입니다. 마찬가지로 pyodbc 모듈을 설치하여 모든 ODBC 호환 데이터베이스를 Python과 함께 사용할 수 있습니다.

모든 관계형 데이터베이스는 테이블에 데이터를 보유합니다. 테이블 구조는 기본적으로 기본 데이터 유형으로 만 구성된 속성의 데이터 유형을 정의하며 해당하는 Python 내장 데이터 유형에 매핑됩니다. 그러나 Python의 사용자 정의 객체는 SQL 테이블에 영구적으로 저장 및 검색 할 수 없습니다.

이것은 SQL 유형과 Python과 같은 객체 지향 프로그래밍 언어 간의 차이입니다. SQL에는 dict, tuple, list 또는 사용자 정의 클래스와 같은 다른 데이터 유형에 해당하는 데이터 유형이 없습니다.

관계형 데이터베이스에 개체를 저장해야하는 경우 INSERT 쿼리를 실행하기 전에 먼저 인스턴스 속성을 SQL 데이터 유형으로 분해해야합니다. 반면에 SQL 테이블에서 검색된 데이터는 기본 유형입니다. 원하는 유형의 Python 객체는 Python 스크립트에서 사용하기 위해를 사용하여 구성해야합니다. 이것이 Object Relational Mapper가 유용한 곳입니다.

개체 관계 매퍼 (ORM)

안 Object Relation Mapper(ORM)은 클래스와 SQL 테이블 간의 인터페이스입니다. Python 클래스는 데이터베이스의 특정 테이블에 매핑되므로 객체 유형과 SQL 유형 간의 변환이 자동으로 수행됩니다.

Python 코드로 작성된 Students 클래스는 데이터베이스의 Students 테이블에 매핑됩니다. 결과적으로 모든 CRUD 작업은 클래스의 각 메서드를 호출하여 수행됩니다. 따라서 Python 스크립트에서 하드 코딩 된 SQL 쿼리를 실행할 필요가 없습니다.

따라서 ORM 라이브러리는 원시 SQL 쿼리에 대한 추상화 계층 역할을하며 신속한 애플리케이션 개발에 도움이 될 수 있습니다. SQLAlchemyPython에서 널리 사용되는 객체 관계형 매퍼입니다. 모델 객체의 상태 조작은 데이터베이스 테이블의 관련 행과 동기화됩니다.

SQLALchemy 라이브러리에는 다음이 포함됩니다. ORM API 및 SQL 표현식 언어 (SQLAlchemy Core). 표현 언어는 관계형 데이터베이스의 기본 구조를 직접 실행합니다.

ORM은 SQL Expression Language 위에 구축 된 높은 수준의 추상화 된 사용 패턴입니다. ORM은 Expression Language의 적용 용도라고 할 수 있습니다. 이 주제에서는 SQLAlchemy ORM API에 대해 논의하고 SQLite 데이터베이스를 사용합니다.

SQLAlchemy는 dialect 시스템을 사용하는 각각의 DBAPI 구현을 통해 다양한 유형의 데이터베이스와 통신합니다. 모든 언어를 사용하려면 적절한 DBAPI 드라이버가 설치되어 있어야합니다. 다음 유형의 데이터베이스에 대한 방언이 포함되어 있습니다.

Firebird
마이크로 소프트 SQL 서버
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 및 각 dialect 드라이버를 사용하십시오.

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

create_engine에는 선택적 echo 인수가 있습니다. true로 설정하면 엔진에서 생성 된 SQL 쿼리가 터미널에 반영됩니다.

SQLAlchemy는 다음을 포함합니다. declarative base수업. 모델 클래스 및 매핑 된 테이블의 카탈로그 역할을합니다.

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

다음 단계는 모델 클래스를 정의하는 것입니다. 위와 같이 declarative_base 클래스의 기본 객체에서 파생되어야합니다.

__ 설정tablename__ 속성을 데이터베이스에 만들려는 테이블의 이름으로 변경합니다. 다른 속성은 필드에 해당합니다. 각각은 SQLAlchemy의 Column 객체이며 데이터 유형은 아래 목록 중 하나입니다-

BigInteger
Boolean
Date
DateTime
Float
Integer
Numeric
SmallInteger
String
Text
Time

다음 코드는 Students 테이블에 매핑 된 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)

해당 구조의 Students 테이블을 생성하려면 기본 클래스에 대해 정의 된 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()

다음은 students 테이블에 레코드를 추가하는 전체 코드입니다. 실행되면 해당 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 모델에서 query () 메서드에 의해 반환됩니다.

qry=seesionobj.query(Student)

이 Query 객체의 get () 메소드를 사용하여 주어진 기본 키에 해당하는 객체를 가져옵니다.

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 () 메서드를 사용하여 레코드를 가져오고 원하는 속성에 새 값을 할당 한 다음 세션 개체를 사용하여 변경 사항을 커밋하기 만하면됩니다. 아래에서 Juhi 학생의 점수를 100으로 변경합니다.

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

레코드를 삭제하는 것은 세션에서 원하는 객체를 삭제하는 것만 큼 쉽습니다.

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

MongoDB는 문서 지향적입니다. NoSQL데이터 베이스. 서버 측 공개 라이센스에 따라 배포되는 크로스 플랫폼 데이터베이스입니다. 문서와 같은 JSON을 스키마로 사용합니다.

방대한 데이터를 저장할 수있는 기능을 제공하기 위해 둘 이상의 물리적 서버 (샤드라고 함)가 상호 연결되어 수평 적 확장 성이 달성됩니다. MongoDB 데이터베이스는 문서로 구성됩니다.

문서는 관계형 데이터베이스 테이블의 행과 유사합니다. 그러나 특정 스키마가 없습니다. 문서는 사전과 유사한 키-값 쌍의 모음입니다. 그러나 각 문서의 kv 쌍 수는 다를 수 있습니다. 관계형 데이터베이스의 테이블에 기본 키가있는 것처럼 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모듈은 Python 프로그래밍 인터페이스를 제공하기 위해 MongoDB Inc에서 자체적으로 개발했습니다. 잘 알려진 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')

이제 다음과 같이 컬렉션에 하나 이상의 문서를 추가 할 수 있습니다.

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()

문서를 검색하려면 (SELECT 쿼리와 유사) 다음을 사용해야합니다. find()방법. 모든 문서를 얻을 수있는 도움으로 커서를 반환합니다.

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

컬렉션에서 모든 문서 대신 특정 문서를 찾으려면 find () 메서드에 필터를 적용해야합니다. 필터는 논리 연산자를 사용합니다. MongoDB에는 아래와 같은 논리 연산자가 있습니다.

Sr. 아니요	MongoDB 연산자 및 기존 논리 연산자
1	$eq 같음 (==)
2	$gt 보다 큼 (>)
삼	$gte 보다 크거나 같음 (> =)
4	$in 배열의 값과 같으면
5	$lt 보다 작음 (<)
6	$lte 보다 작거나 같음 (<=)
7	$ne 같지 않음 (! =)
8	$nin 배열의 값과 같지 않은 경우

예를 들어, 우리는 21 세 이상의 학생 목록을 얻는 데 관심이 있습니다. 필터에서 $ gt 연산자 사용find() 다음과 같이 방법-

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

PyMongo 모듈은 update_one() 과 update_many() 특정 필터 표현식을 만족하는 하나 이상의 문서를 수정하는 방법.

이름이 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는 또 다른 인기있는 NoSQL 데이터베이스입니다. 높은 확장 성, 일관성 및 내결함성-이들은 Cassandra의 중요한 기능 중 일부입니다. 이것은Column store데이터 베이스. 데이터는 여러 상용 서버에 저장됩니다. 결과적으로 데이터의 가용성이 높아집니다.

Cassandra는 Apache Software Foundation의 제품입니다. 데이터는 여러 노드에 분산 방식으로 저장됩니다. 각 노드는 키 스페이스로 구성된 단일 서버입니다. Cassandra 데이터베이스의 기본 구성 요소는keyspace 데이터베이스와 유사한 것으로 간주 될 수 있습니다.

Cassandra의 한 노드에있는 데이터는 피어-투-피어 노드 네트워크를 통해 다른 노드에 복제됩니다. 그것은 Cassandra를 완벽한 데이터베이스로 만듭니다. 네트워크를 데이터 센터라고합니다. 여러 데이터 센터를 상호 연결하여 클러스터를 형성 할 수 있습니다. 복제 특성은 키 스페이스 생성시 복제 전략 및 복제 요소를 설정하여 구성됩니다.

하나의 데이터베이스에 여러 테이블이 포함될 수있는 것처럼 하나의 키 스페이스에는 둘 이상의 Column family가있을 수 있습니다. Cassandra의 키 스페이스에는 미리 정의 된 스키마가 없습니다. Cassandra 테이블의 각 행에는 이름과 변수 번호가 다른 열이있을 수 있습니다.

Cassandra 소프트웨어는 커뮤니티와 엔터프라이즈의 두 가지 버전으로도 제공됩니다. 최신 엔터프라이즈 버전의 Cassandra는 다음 사이트에서 다운로드 할 수 있습니다.https://cassandra.apache.org/download/. 커뮤니티 에디션은https://academy.datastax.com/planet-cassandra/cassandra.

Cassandra에는 자체 쿼리 언어가 있습니다. Cassandra Query Language (CQL). CQL 쿼리는 MySQL 또는 SQLite 셸과 유사한 CQLASH 셸 내부에서 실행할 수 있습니다. CQL 구문은 표준 SQL과 유사합니다.

Datastax 커뮤니티 에디션은 다음 그림에 표시된 Develcenter IDE와 함께 제공됩니다.

Cassandra 데이터베이스 작업을위한 Python 모듈이 호출됩니다. Cassandra Driver. 또한 Apache 재단에서 개발했습니다. 이 모듈에는 ORM API는 물론 관계형 데이터베이스 용 DB-API와 본질적으로 유사한 핵심 API가 포함되어 있습니다.

Cassandra 드라이버 설치는 다음을 사용하여 쉽게 수행됩니다. pip utility.

pip3 install cassandra-driver

Cassandra 데이터베이스와의 상호 작용은 Cluster 개체를 통해 수행됩니다. Cassandra.cluster 모듈은 Cluster 클래스를 정의합니다. 먼저 Cluster 객체를 선언해야합니다.

from cassandra.cluster import Cluster
clstr=Cluster()

삽입 / 업데이트 등과 같은 모든 트랜잭션은 키 스페이스로 세션을 시작하여 수행됩니다.

session=clstr.connect()

새 키 스페이스를 생성하려면 execute()세션 개체의 메서드. execute () 메서드는 쿼리 문자열이어야하는 문자열 인수를 사용합니다. CQL에는 다음과 같은 CREATE KEYSPACE 문이 있습니다. 전체 코드는 다음과 같습니다.

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

여기, SimpleStrategy 값입니다 replication strategy 과 replication factor앞에서 언급했듯이 키 스페이스에는 하나 이상의 테이블이 포함됩니다. 각 테이블은 데이터 유형이 특징입니다. Python 데이터 유형은 다음 표에 따라 해당 CQL 데이터 유형으로 자동 구문 분석됩니다.

파이썬 유형	CQL 유형
없음	없는
부울	부울
흙손	float, double
int, long	int, bigint, varint, smallint, tinyint, 카운터
decimal.Decimal	소수
str, 유니 코드	ascii, varchar, 텍스트
버퍼, 바이트 배열	얼룩
데이트	데이트
날짜 시간	타임 스탬프
시각	시각
목록, 튜플, 생성기	명부
set, frozenset	세트
dict, OrderedDict	지도
uuid.UUID	timeuuid, uuid

테이블을 생성하려면 세션 객체를 사용하여 테이블 생성을위한 CQL 쿼리를 실행합니다.

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)

이렇게 생성 된 키 스페이스는 행을 삽입하는 데 사용할 수 있습니다. INSERT 쿼리의 CQL 버전은 SQL Insert 문과 유사합니다. 다음 코드는 students 테이블에 행을 삽입합니다.

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);"

예상대로 SELECT 문은 Cassandra에서도 사용됩니다. SELECT 쿼리 문자열이 포함 된 execute () 메서드의 경우 루프를 사용하여 순회 할 수있는 결과 집합 객체를 반환합니다.

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의 SELECT 쿼리는 가져올 결과 집합에 필터를 적용하기 위해 WHERE 절 사용을 지원합니다. <,> == 등과 같은 전통적인 논리 연산자가 인식됩니다. 검색하려면 학생 테이블에서 나이가 20 세 이상인 이름에 대한 행만 실행 () 메서드의 쿼리 문자열은 다음과 같아야합니다.

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

참고, 사용 ALLOW FILTERING. 이 문의 ALLOW FILTERING 부분은 필터링이 필요한 (일부) 쿼리를 명시 적으로 허용 할 수 있습니다.

Cassandra 드라이버 API는 cassendra.query 모듈에서 다음과 같은 Statement 유형 클래스를 정의합니다.

SimpleStatement

쿼리 문자열에 포함 된 단순하고 준비되지 않은 CQL 쿼리입니다. 위의 모든 예는 SimpleStatement의 예입니다.

BatchStatement

여러 쿼리 (예 : INSERT, UPDATE 및 DELETE)가 일괄 처리되어 한 번에 실행됩니다. 각 행은 먼저 SimpleStatement로 변환 된 다음 일괄 처리에 추가됩니다.

다음과 같이 튜플 목록의 형태로 Students 테이블에 추가 할 행을 입력합니다.

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

BathStatement를 사용하여 위의 행을 추가하려면 다음 스크립트를 실행하십시오.

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

준비된 문은 DB-API의 매개 변수화 된 쿼리와 같습니다. 쿼리 문자열은 나중에 사용하기 위해 Cassandra에 의해 저장됩니다. Session.prepare () 메서드는 PreparedStatement 인스턴스를 반환합니다.

학생 테이블의 경우 INSERT 쿼리에 대한 PreparedStatement는 다음과 같습니다.

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

이후에는 바인딩 할 매개 변수 값만 보내면됩니다. 예를 들면-

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

마지막으로 위의 바인딩 된 문을 실행합니다.

session.execute(qry)

이렇게하면 Cassandra가 매번 쿼리를 다시 구문 분석 할 필요가 없기 때문에 네트워크 트래픽과 CPU 사용률이 감소합니다.

ZODB (Zope object Database)는 Python 객체를 저장하기위한 데이터베이스입니다. ACID를 준수합니다. NOSQL 데이터베이스에는없는 기능입니다. ZODB는 또한 많은 NoSQL 데이터베이스와 같이 수평 확장 가능하고 스키마가없는 오픈 소스입니다. 그러나 배포되지 않고 쉽게 복제 할 수 없습니다. Python 객체에 대한 지속성 메커니즘을 제공합니다. Zope Application 서버의 일부이지만 독립적으로 사용할 수도 있습니다.

ZODB는 Zope Corporation의 Jim Fulton이 만들었습니다. 단순한 Persistent Object System으로 시작되었습니다. 현재 버전은 5.5.0이며 완전히 Python으로 작성되었습니다. 확장 된 버전의 Python 내장 객체 지속성 (pickle)을 사용합니다.

ZODB의 주요 기능 중 일부는-

transactions
history/undo
투명한 플러그 형 스토리지
내장 캐싱
MVCC (Multiversion Concurrency Control)
네트워크를 통한 확장 성

ZODB는 hierarchical데이터 베이스. 데이터베이스가 생성 될 때 초기화되는 루트 개체가 있습니다. 루트 객체는 Python 사전처럼 사용되며 다른 객체 (사전과 유사 할 수 있음)를 포함 할 수 있습니다. 데이터베이스에 개체를 저장하려면 컨테이너 내부의 새 키에 할당하는 것으로 충분합니다.

ZODB는 데이터가 계층적이고 쓰기보다 읽기가 더 많은 애플리케이션에 유용합니다. ZODB는 pickle 객체의 확장입니다. 그렇기 때문에 Python 스크립트를 통해서만 처리 할 수 있습니다.

최신 버전의 ZODB를 설치하려면 pip 유틸리티를 사용하십시오-

pip install zodb

다음 종속성도 설치됩니다.

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

ZODB는 다음과 같은 저장 옵션을 제공합니다.

FileStorage

이것이 기본값입니다. 본질적으로 트랜잭션 로그인 하나의 big Data.fs 파일에 저장된 모든 것.

DirectoryStorage

이것은 객체 개 정당 하나의 파일을 저장합니다. 이 경우 불완전한 종료시 Data.fs.index를 다시 빌드 할 필요가 없습니다.

RelStorage

이것은 관계형 데이터베이스에 피클을 저장합니다. PostgreSQL, MySQL 및 Oracle이 지원됩니다.

ZODB 데이터베이스를 생성하려면 스토리지, 데이터베이스, 마지막으로 연결이 필요합니다.

첫 번째 단계는 저장 개체를 갖는 것입니다.

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

DB 클래스는이 저장소 개체를 사용하여 데이터베이스 개체를 가져옵니다.

db = ZODB.DB(storage)

DB 생성자에 None을 전달하여 메모리 내 데이터베이스를 만듭니다.

Db=ZODB.DB(None)

마지막으로 데이터베이스와의 연결을 설정합니다.

conn=db.open()

그런 다음 연결 개체는 'root ()'메서드를 사용하여 데이터베이스의 '루트'에 대한 액세스를 제공합니다. '루트'개체는 모든 영구 개체를 보유하는 사전입니다.

root = conn.root()

예를 들어, 다음과 같이 루트 객체에 학생 목록을 추가합니다.

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

이 변경 사항은 트랜잭션을 커밋 할 때까지 데이터베이스에 영구적으로 저장되지 않습니다.

import transaction
transaction.commit()

사용자 정의 클래스의 객체를 저장하려면 해당 클래스가 persist.Persistent 상위 클래스에서 상속되어야합니다.

서브 클래 싱의 장점

Persistent 클래스를 서브 클래 싱하면 다음과 같은 장점이 있습니다.

데이터베이스는 속성을 설정하여 변경된 개체를 자동으로 추적합니다.
데이터는 자체 데이터베이스 레코드에 저장됩니다.
Persistent 하위 클래스가 아닌 데이터를 저장할 수 있지만 영구 개체가 참조하는 모든 데이터베이스 레코드에 저장됩니다. 비 영구 객체는 포함 된 영구 객체가 소유하며 여러 영구 객체가 동일한 비 영구 하위 객체를 참조하는 경우 자체 복사본을 얻습니다.

아래 에서처럼 영구 클래스를 하위 클래스로 정의하는 학생 클래스를 사용하자-

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

이 클래스의 객체를 추가하려면 먼저 위에서 설명한대로 연결을 설정합니다.

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

객체를 루트에 추가하도록 선언 한 다음 트랜잭션을 커밋합니다.

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

root 객체는 내장 된 사전과 유사하기 때문에, root에 추가 된 모든 객체의 목록은 items () 메서드를 사용하여 뷰 객체로 검색 할 수 있습니다.

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

루트에서 특정 개체의 속성을 가져 오려면

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

개체를 쉽게 업데이트 할 수 있습니다. ZODB API는 순수한 Python 패키지이므로 외부 SQL 유형 언어를 사용할 필요가 없습니다.

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

데이터베이스는 즉시 업데이트됩니다. 트랜잭션 클래스는 SQL의 rollback () 트랜잭션 제어와 유사한 abort () 함수도 정의합니다.

Microsoft의 Excel은 가장 널리 사용되는 스프레드 시트 응용 프로그램입니다. 지난 25 년 이상 사용되었습니다. 최신 버전의 Excel 사용Office Open XML (OOXML) 파일 형식. 따라서 다른 프로그래밍 환경을 통해 스프레드 시트 파일에 액세스 할 수있었습니다.

OOXMLECMA 표준 파일 형식입니다. 파이썬openpyxl 패키지는 확장명이 .xlsx 인 Excel 파일을 읽고 쓰는 기능을 제공합니다.

openpyxl 패키지는 Microsoft Excel 용어와 유사한 클래스 명명법을 사용합니다. Excel 문서는 통합 문서라고하며 파일 시스템에 .xlsx 확장자로 저장됩니다. 통합 문서에는 여러 워크 시트가있을 수 있습니다. 워크 시트는 큰 셀 격자를 표시하며 각 셀은 값이나 수식을 저장할 수 있습니다. 그리드를 구성하는 행과 열은 번호가 매겨집니다. 열은 알파벳, A, B, C,…., Z, AA, AB 등으로 식별됩니다. 행은 1부터 번호가 매겨집니다.

일반적인 Excel 워크 시트는 다음과 같이 나타납니다.

pip 유틸리티는 openpyxl 패키지를 설치하기에 충분합니다.

pip install openpyxl

Workbook 클래스는 하나의 빈 워크 시트가있는 빈 통합 문서를 나타냅니다. 워크 시트에 일부 데이터를 추가 할 수 있도록 활성화해야합니다.

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

아시다시피 워크 시트의 셀 이름은 ColumnNameRownumber 형식으로 지정됩니다. 따라서 왼쪽 상단 셀은 A1입니다. 이 셀에 문자열을 다음과 같이 할당합니다.

sheet1['A1']= 'Student List'

또는 워크 시트의 cell()행과 열 번호를 사용하여 셀을 식별하는 방법. 값 속성을 셀 개체에 호출하여 값을 할당합니다.

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

워크 시트를 데이터로 채운 후 워크 북 객체의 save () 메서드를 호출하여 워크 북을 저장합니다.

wb.save('Student.xlsx')

이 통합 문서 파일은 현재 작업 디렉터리에 생성됩니다.

다음 Python 스크립트는 통합 문서에 튜플 목록을 작성합니다. 각 튜플은 학생의 롤 번호, 나이 및 점수를 저장합니다.

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')

워크 북 students.xlsx는 현재 작업 디렉토리에 저장됩니다. Excel 응용 프로그램을 사용하여 열면 다음과 같이 나타납니다.

openpyxl 모듈은 load_workbook() 통합 문서 문서의 데이터를 다시 읽는 데 도움이되는 기능입니다.

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

이제 행 및 열 번호로 지정된 모든 셀의 값에 액세스 할 수 있습니다.

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

예

다음 코드는 목록을 워크 시트 데이터로 채 웁니다.

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)

산출

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

Excel 응용 프로그램의 매우 중요한 기능 중 하나는 수식입니다. 셀에 수식을 지정하려면 Excel의 수식 구문이 포함 된 문자열에 지정하십시오. 나이가있는 c6 셀에 AVERAGE 함수를 할당합니다.

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

Openpyxl 모듈에는 Translate_formula()함수를 사용하여 범위에서 수식을 복사합니다. 다음 프로그램은 C6에서 AVERAGE 함수를 정의하고 마크 평균을 계산하는 C7에 복사합니다.

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')

이제 변경된 워크 시트가 다음과 같이 나타납니다.