Python 은 TXT 파일 데 이 터 를 읽 고 내 장 된 데이터베이스 SQLite 3 에 저장 하 는 방법 을 실현 합 니 다.
TXT 파일 이 너무 크 고 컴퓨터 메모리 가 부족 할 때 우 리 는 줄 별로 TXT 파일 을 읽 고 Python 에 경량급 splite 데이터 베 이 스 를 저장 할 수 있 습 니 다.그러면 데이터 의 읽 기 속 도 를 가속 화 할 수 있 습 니 다.우리 가 데 이 터 를 반복 적 으로 읽 어야 할 때 이런 속도 가 빨 라 지면 가 져 오 는 시간 을 절약 하 는 것 이 매우 좋 습 니 다.예 를 들 어 우리 가 데 이 터 를 훈련 할 때 10 만 번 을 교체 해 야 합 니 다.파일 에서 10 만 번 을 읽 어야 한 다 는 것 이다.매번 0.1 초 만 속 도 를 내 더 라 도 몇 시간 은 절약 할 수 있다.
# txt
import sqlite3 # sqlite3
cx = sqlite3.connect('./train.db') # ， ， ； ， ， 。
cu = cx.cursor() # ， 。
cu.execute('create table if not exists train4 (id integer primary key,name text)') #
fr = open('data_sample.txt') # txt
i = 0
for line in fr.readlines(): # train4 。
cu.execute('insert into train4 values(?,?)',(i,line))
i +=1
cu.close() #
cx.commit() #
cx.close() #
cu.execute('select * from train4 where id = ?',(i,)) #i train4
result = cu.fetchall()
전체 검색 프로그램 은 다음 과 같 습 니 다.
import sqlite3
cx = sqlite3.connect('./train.db')
cu = cx.cursor()
for i in range(5):
cu.execute('select * from train4 where id = ?',(i,))
result = cu.fetchall()
cx.commit()
cu.close()
cx.close()
import sqlite3
# ***************************************************
# *
# * Description: Python SQLite3 ( )
# * Author: wangye
# *
# ***************************************************
def _wrap_value(value):
return repr(value)
def _wrap_values(values):
return list(map(_wrap_value, values))
def _wrap_fields(fields):
for key,value in fields.items():
fields[key] = _wrap_value(value)
return fields
def _concat_keys(keys):
return "[" + "],[".join(keys) + "]"
def _concat_values(values):
return ",".join(values)
def _concat_fields(fields, operator = (None, ",")):
if operator:
unit_operator, group_operator = operator
# fields = _wrap_fields(fields)
compiled = []
for key,value in fields.items():
compiled.append("[" + key + "]")
if unit_operator:
compiled.append(unit_operator)
compiled.append(value)
compiled.append(group_operator)
compiled.pop() # pop last group_operator
return " ".join(compiled)
class DataCondition(object):
"""
SQL
:
DataCondition(("=", "AND"), id = 26)
DataCondition(("=", "AND"), True, id = 26)
"""
def __init__(self, operator = ("=", "AND"), ingroup = True, **kwargs):
"""
:
operator ， ( , )
ingroup ， ，
kwargs ，
SQL
operator[0]
:
DataCondition(("=", "AND"), id = 26)
(id=26)
DataCondition((">", "OR"), id = 26, age = 35)
(id>26 OR age>35)
DataCondition(("LIKE", "OR"), False, name = "John", company = "Google")
name LIKE 'John' OR company LIKE "Google"
"""
self.ingroup = ingroup
self.fields = kwargs
self.operator = operator
def __unicode__(self):
self.fields = _wrap_fields(self.fields)
result = _concat_fields(self.fields, self.operator)
if self.ingroup:
return "(" + result + ")"
return result
def __str__(self):
return self.__unicode__()
def toString(self):
return self.__unicode__()
class DataHelper(object):
"""
SQLite3
"""
def __init__(self, filename):
"""
: filename SQLite3
"""
self.file_name = filename
def open(self):
"""
"""
self.connection = sqlite3.connect(self.file_name)
self.cursor = self.connection.cursor()
return self
def close(self):
"""
， ，
"""
if hasattr(self, "connection") and self.connection:
self.connection.close()
def __del__(self):
"""
，
"""
self.close()
def commit(self):
"""
SELECT ， execute
commit_at_once True ，
。
"""
self.connection.commit()
def execute(self, sql = None, commit_at_once = True):
"""
SQL
:
sql SQL ， None， SQL 。
commit_at_once ， ，
， commit 。
"""
if not sql:
sql = self.sql
self.cursor.execute(sql)
if commit_at_once:
self.commit()
def fetchone(self, sql = None):
"""
"""
self.execute(sql, False)
return self.cursor.fetchone()
def fetchall(self, sql = None):
"""
"""
self.execute(sql, False)
return self.cursor.fetchall()
def __concat_keys(self, keys):
return _concat_keys(keys)
def __concat_values(self, values):
return _concat_values(values)
def table(self, *args):
"""
，
"""
self.tables = args
self.tables_snippet = self.__concat_keys(self.tables)
return self
def __wrap_value(self, value):
return _wrap_value(value)
def __wrap_values(self, values):
return _wrap_values(values)
def __wrap_fields(self, fields):
return _wrap_fields(fields)
def __where(self):
# self.condition_snippet
if hasattr(self, "condition_snippet"):
self.where_snippet = " WHERE " + self.condition_snippet
def __select(self):
template = "SELECT %(keys)s FROM %(tables)s"
body_snippet_fields = {
"tables" : self.tables_snippet,
"keys" : self.__concat_keys(self.body_keys),
}
self.sql = template % body_snippet_fields
def __insert(self):
template = "INSERT INTO %(tables)s (%(keys)s) VALUES (%(values)s)"
body_snippet_fields = {
"tables" : self.tables_snippet,
"keys" : self.__concat_keys(list(self.body_fields.keys())),
"values" : self.__concat_values(list(self.body_fields.values()))
}
self.sql = template % body_snippet_fields
def __update(self):
template = "UPDATE %(tables)s SET %(fields)s"
body_snippet_fields = {
"tables" : self.tables_snippet,
"fields" : _concat_fields(self.body_fields, ("=",","))
}
self.sql = template % body_snippet_fields
def __delete(self):
template = "DELETE FROM %(tables)s"
body_snippet_fields = {
"tables" : self.tables_snippet
}
self.sql = template % body_snippet_fields
def __build(self):
{
"SELECT": self.__select,
"INSERT": self.__insert,
"UPDATE": self.__update,
"DELETE": self.__delete
}[self.current_token]()
def __unicode__(self):
return self.sql
def __str__(self):
return self.__unicode__()
def select(self, *args):
self.current_token = "SELECT"
self.body_keys = args
self.__build()
return self
def insert(self, **kwargs):
self.current_token = "INSERT"
self.body_fields = self.__wrap_fields(kwargs)
self.__build()
return self
def update(self, **kwargs):
self.current_token = "UPDATE"
self.body_fields = self.__wrap_fields(kwargs)
self.__build()
return self
def delete(self, *conditions):
self.current_token = "DELETE"
self.__build()
#if *conditions:
self.where(*conditions)
return self
def where(self, *conditions):
conditions = list(map(str, conditions))
self.condition_snippet = " AND ".join(conditions)
self.__where()
if hasattr(self, "where_snippet"):
self.sql += self.where_snippet
return self본 논문 에서 말 한 것 이 여러분 의 Python 프로 그래 밍 에 도움 이 되 기 를 바 랍 니 다.
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
Python의 None과 NULL의 차이점 상세 정보그래서 대상 = 속성 + 방법 (사실 방법도 하나의 속성, 데이터 속성과 구별되는 호출 가능한 속성 같은 속성과 방법을 가진 대상을 클래스, 즉 Classl로 분류할 수 있다.클래스는 하나의 청사진과 같아서 하나의 ...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
