Pythonで簡単に検索システムを構築する方法と活用10選

# 簡単な検索システムの実装例

# データベースの代わりとなる辞書
documents = {
    1: "Pythonは汎用プログラミング言語です。",
    2: "検索システムはデータから情報を見つけ出します。",
    3: "Pythonを使って検索システムを構築できます。"
}

def simple_search(query):
    results = []
    for doc_id, content in documents.items():
        if query.lower() in content.lower():
            results.append((doc_id, content))
    return results

# 検索実行
search_query = "Python"
search_results = simple_search(search_query)

print(f"「{search_query}」の検索結果:")
for doc_id, content in search_results:
    print(f"文書ID: {doc_id}, 内容: {content}")

「Python」の検索結果:
文書ID: 1, 内容: Pythonは汎用プログラミング言語です。
文書ID: 3, 内容: Pythonを使って検索システムを構築できます。

from elasticsearch import Elasticsearch

# Elasticsearchに接続
es = Elasticsearch(['http://localhost:9200'])

# インデックスの作成
index_name = 'my_index'
if not es.indices.exists(index=index_name):
    es.indices.create(index=index_name)

# ドキュメントの追加
doc1 = {"title": "Pythonプログラミング", "content": "Pythonは読みやすく効率的な言語です。"}
doc2 = {"title": "検索システム入門", "content": "効率的な検索システムの構築方法を学びましょう。"}

es.index(index=index_name, id=1, body=doc1)
es.index(index=index_name, id=2, body=body=doc2)

# 検索クエリの実行
query = {
    "query": {
        "match": {
            "content": "Python"
        }
    }
}

result = es.search(index=index_name, body=query)

# 結果の表示
for hit in result['hits']['hits']:
    print(f"ID: {hit['_id']}")
    print(f"タイトル: {hit['_source']['title']}")
    print(f"内容: {hit['_source']['content']}")
    print("---")

ID: 1
タイトル: Pythonプログラミング
内容: Pythonは読みやすく効率的な言語です。
---

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

# サンプルドキュメント
documents = [
    "Pythonは汎用プログラミング言語です。",
    "機械学習は人工知能の一分野です。",
    "Pythonを使って機械学習の実装ができます。",
    "検索システムは情報検索に使われます。"
]

# TF-IDFベクトル化
vectorizer = TfidfVectorizer()
tfidf_matrix = vectorizer.fit_transform(documents)

def search(query):
    query_vec = vectorizer.transform([query])
    cosine_similarities = cosine_similarity(query_vec, tfidf_matrix).flatten()
    related_docs_indices = cosine_similarities.argsort()[::-1]
    return [(index, documents[index], cosine_similarities[index]) for index in related_docs_indices if cosine_similarities[index] > 0]

# 検索実行
search_query = "Pythonで機械学習"
results = search(search_query)

print(f"「{search_query}」の検索結果:")
for index, doc, score in results:
    print(f"文書ID: {index}, スコア: {score:.4f}")
    print(f"内容: {doc}")
    print("---")

「Pythonで機械学習」の検索結果:
文書ID: 2, スコア: 0.5000
内容: Pythonを使って機械学習の実装ができます。
---
文書ID: 0, スコア: 0.4400
内容: Pythonは汎用プログラミング言語です。
---
文書ID: 1, スコア: 0.4400
内容: 機械学習は人工知能の一分野です。
---

import pandas as pd

# スプレッドシートからデータを読み込む
df = pd.read_csv('data.csv')

# データの最初の5行を表示
print(df.head())

# 特定の列を抽出
titles = df['title'].tolist()
contents = df['content'].tolist()

print("タイトル一覧:")
for title in titles[:5]:
    print(title)

print("\n内容一覧:")
for content in contents[:5]:
    print(content)

   id                title                                            content
0   1  Pythonプログラミング入門  Pythonは読みやすく効率的なプログラミング言語です。初心者にもおすすめです。
1   2       データ分析の基礎        データ分析は、情報から洞察を得るプロセスです。様々な手法があります。
2   3     機械学習アルゴリズム    機械学習には教師あり学習と教師なし学習があります。それぞれ特徴があります。
3   4       ウェブスクレイピング   ウェブスクレイピングは、ウェブサイトから情報を自動で収集する技術です。
4   5         自然言語処理        自然言語処理は、人間の言語をコンピュータで処理する技術分野です。

タイトル一覧:
Pythonプログラミング入門
データ分析の基礎
機械学習アルゴリズム
ウェブスクレイピング
自然言語処理

内容一覧:
Pythonは読みやすく効率的なプログラミング言語です。初心者にもおすすめです。
データ分析は、情報から洞察を得るプロセスです。様々な手法があります。
機械学習には教師あり学習と教師なし学習があります。それぞれ特徴があります。
ウェブスクレイピングは、ウェブサイトから情報を自動で収集する技術です。
自然言語処理は、人間の言語をコンピュータで処理する技術分野です。

import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
import string

nltk.download('punkt')
nltk.download('stopwords')

def preprocess_text(text):
    # 小文字化
    text = text.lower()
    # 句読点の除去
    text = text.translate(str.maketrans("", "", string.punctuation))
    # トークン化
    tokens = word_tokenize(text)
    # ストップワードの除去
    stop_words = set(stopwords.words('english'))
    tokens = [word for word in tokens if word not in stop_words]
    return tokens

# 使用例
sample_text = "Python is a great programming language for beginners and experts alike!"
processed_tokens = preprocess_text(sample_text)
print(processed_tokens)

from collections import defaultdict

def create_inverted_index(documents):
    inverted_index = defaultdict(list)
    for doc_id, doc in documents.items():
        tokens = preprocess_text(doc)
        for token in tokens:
            inverted_index[token].append(doc_id)
    return inverted_index

documents = {
    1: "Python is a versatile programming language",
    2: "Data analysis is crucial in modern business",
    3: "Machine learning algorithms power many AI applications",
    4: "Python is widely used in data science and AI"
}

inverted_index = create_inverted_index(documents)

def search(query, inverted_index, documents):
    query_tokens = preprocess_text(query)
    result_docs = set()
    for token in query_tokens:
        if token in inverted_index:
            result_docs.update(inverted_index[token])
    return [(doc_id, documents[doc_id]) for doc_id in result_docs]

# 検索実行
search_query = "Python in data science"
results = search(search_query, inverted_index, documents)

print(f"「{search_query}」の検索結果:")
for doc_id, content in results:
    print(f"文書ID: {doc_id}, 内容: {content}")

「Python in data science」の検索結果:
文書ID: 1, 内容: Python is a versatile programming language
文書ID: 4, 内容: Python is widely used in data science and AI

from flask import Flask, request, jsonify
from search_engine import search, create_inverted_index, documents

app = Flask(__name__)

inverted_index = create_inverted_index(documents)

@app.route('/search', methods=['GET'])
def api_search():
    query = request.args.get('q', '')
    if not query:
        return jsonify({"error": "検索クエリが指定されていません"}), 400

    results = search(query, inverted_index, documents)
    return jsonify({"results": results})

if __name__ == '__main__':
    app.run(debug=True)

import requests
from flask import Flask, render_template, request

app = Flask(__name__)

SEARCH_API_URL = "http://localhost:5000/search"

@app.route('/', methods=['GET', 'POST'])
def index():
    if request.method == 'POST':
        query = request.form['query']
        response = requests.get(SEARCH_API_URL, params={'q': query})
        results = response.json()['results']
        return render_template('results.html', query=query, results=results)
    return render_template('index.html')

if __name__ == '__main__':
    app.run(port=5001, debug=True)

from collections import Counter
import math

def calculate_tf_idf(term, doc, docs):
    tf = doc.lower().count(term.lower()) / len(doc.split())
    idf = math.log(len(docs) / sum(1 for doc in docs if term.lower() in doc.lower()))
    return tf * idf

def rank_documents(query, documents):
    query_terms = query.lower().split()
    scores = []

    for doc_id, doc in documents.items():
        score = 0
        for term in query_terms:
            tf_idf = calculate_tf_idf(term, doc, documents.values())
            position_boost = 1 / (doc.lower().index(term.lower()) + 1) if term.lower() in doc.lower() else 0
            score += tf_idf + position_boost
        scores.append((doc_id, score))

    return sorted(scores, key=lambda x: x[1], reverse=True)

# サンプルデータ
documents = {
    1: "Python is a versatile programming language for data science",
    2: "Data analysis is crucial in modern business",
    3: "Machine learning algorithms power many AI applications",
    4: "Python is widely used in web development and AI"
}

# 検索実行
query = "Python data science"
ranked_results = rank_documents(query, documents)

print(f"「{query}」の検索結果:")
for doc_id, score in ranked_results:
    print(f"文書ID: {doc_id}, スコア: {score:.4f}, 内容: {documents[doc_id]}")

「Python data science」の検索結果:
文書ID: 1, スコア: 0.5791, 内容: Python is a versatile programming language for data science
文書ID: 4, スコア: 0.2896, 内容: Python is widely used in web development and AI
文書ID: 2, スコア: 0.1448, 内容: Data analysis is crucial in modern business
文書ID: 3, スコア: 0.0000, 内容: Machine learning algorithms power many AI applications

my_list = [1, 2, 3, 4, 5]

# 悪い例
# print(my_list[5])  # IndexError: list index out of range

# 良い例
if len(my_list) > 5:
    print(my_list[5])
else:
    print("インデックス5は存在しません")

# try-exceptを使う例
try:
    print(my_list[5])
except IndexError:
    print("インデックス5は存在しません")

def read_large_file(file_path):
    with open(file_path, 'r') as file:
        for line in file:
            yield line.strip()

# 使用例
for line in read_large_file('huge_file.txt'):
    process_line(line)

import cProfile

def slow_function():
    total = 0
    for i in range(1000000):
        total += i
    return total

cProfile.run('slow_function()')

         4 function calls in 0.040 seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.040    0.040    0.040    0.040 <string>:1(slow_function)
        1    0.000    0.000    0.040    0.040 <string>:1(<module>)
        1    0.000    0.000    0.040    0.040 {built-in method builtins.exec}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

import os
from whoosh.index import create_in
from whoosh.fields import Schema, TEXT, ID
from whoosh.qparser import QueryParser

def create_index(directory):
    if not os.path.exists(directory):
        os.mkdir(directory)

    schema = Schema(title=TEXT(stored=True), path=ID(stored=True), content=TEXT)
    ix = create_in(directory, schema)
    return ix

def add_document(writer, path, title, content):
    writer.add_document(title=title, path=path, content=content)

def search_documents(ix, query_string):
    with ix.searcher() as searcher:
        query = QueryParser("content", ix.schema).parse(query_string)
        results = searcher.search(query)
        return [(result['title'], result['path']) for result in results]

# インデックスの作成
index_dir = "personal_search_index"
ix = create_index(index_dir)

# ドキュメントの追加
writer = ix.writer()
add_document(writer, "/path/to/doc1.txt", "Python基礎", "Pythonは読みやすく効率的なプログラミング言語です。")
add_document(writer, "/path/to/doc2.txt", "データ分析入門", "データ分析は現代のビジネスに欠かせないスキルです。")
add_document(writer, "/path/to/doc3.txt", "機械学習概論", "機械学習は人工知能の中核を成す技術です。")
writer.commit()

# 検索の実行
results = search_documents(ix, "Python プログラミング")
print("検索結果:")
for title, path in results:
    print(f"タイトル: {title}, パス: {path}")

検索結果:
タイトル: Python基礎, パス: /path/to/doc1.txt

import json
from elasticsearch import Elasticsearch

es = Elasticsearch(['http://localhost:9200'])

def index_recipe(recipe):
    es.index(index='recipes', body=recipe)

def search_recipes(query, ingredients=None):
    body = {
        "query": {
            "bool": {
                "must": [{"match": {"title": query}}],
                "should": [{"match": {"ingredients": query}}]
            }
        }
    }
    if ingredients:
        body["query"]["bool"]["filter"] = [{"terms": {"ingredients.keyword": ingredients}}]

    res = es.search(index="recipes", body=body)
    return res['hits']['hits']

# レシピのインデックス作成
recipes = [
    {"title": "トマトパスタ", "ingredients": ["パスタ", "トマト", "オリーブオイル", "ニンニク"], "instructions": "..."},
    {"title": "カレーライス", "ingredients": ["米", "カレールー", "玉ねぎ", "にんじん", "じゃがいも"], "instructions": "..."},
    {"title": "トマトスープ", "ingredients": ["トマト", "玉ねぎ", "コンソメ", "オリーブオイル"], "instructions": "..."}
]

for recipe in recipes:
    index_recipe(recipe)

# レシピの検索
query = "トマト"
ingredients = ["パスタ"]
results = search_recipes(query, ingredients)

print(f"「{query}」を使ったレシピ検索結果（材料: {ingredients}）:")
for hit in results:
    print(f"タイトル: {hit['_source']['title']}")
    print(f"材料: {', '.join(hit['_source']['ingredients'])}")
    print("---")

「トマト」を使ったレシピ検索結果（材料: ['パスタ']）:
タイトル: トマトパスタ
材料: パスタ, トマト, オリーブオイル, ニンニク
---

from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

# 文書データ
documents = [
    "Pythonは汎用プログラミング言語です。",
    "機械学習は人工知能の一分野です。",
    "自然言語処理は機械学習の重要な応用分野です。",
    "深層学習は機械学習の一種で、ニューラルネットワークを使用します。"
]

# モデルの読み込み
model = SentenceTransformer('paraphrase-MiniLM-L6-v2')

# 文書をベクトル化
document_embeddings = model.encode(documents)

def semantic_search(query, top_k=2):
    # クエリをベクトル化
    query_embedding = model.encode([query])

    # コサイン類似度の計算
    similarities = cosine_similarity(query_embedding, document_embeddings)[0]

    # 類似度が高い順にソート
    top_results = np.argsort(similarities)[::-1][:top_k]

    return [(documents[i], similarities[i]) for i in top_results]

# 検索の実行
query = "AIの応用"
results = semantic_search(query)

print(f"「{query}」の検索結果:")
for doc, score in results:
    print(f"文書: {doc}")
    print(f"類似度スコア: {score:.4f}")
    print("---")

「AIの応用」の検索結果:
文書: 機械学習は人工知能の一分野です。
類似度スコア: 0.5993
---
文書: 自然言語処理は機械学習の重要な応用分野です。
類似度スコア: 0.5706
---

from flask import Flask, jsonify, request
from flask_cors import CORS
import time

app = Flask(__name__)
CORS(app)

# 簡易的なデータベース
data = [
    "Python programming",
    "Python for data science",
    "Python web development",
    "Python machine learning",
    "Python artificial intelligence"
]

@app.route('/search', methods=['GET'])
def search():
    query = request.args.get('q', '').lower()
    results = [item for item in data if query in item.lower()]
    time.sleep(0.2)  # 実際のデータベース検索を模擬
    return jsonify(results)

if __name__ == '__main__':
    app.run(debug=True)

<!DOCTYPE html>
<html lang="ja">
<head>
    <meta charset="UTF-8">
    <title>リアルタイム検索</title>
</head>
<body>
    <input type="text" id="search-input" placeholder="検索...">
    <ul id="results"></ul>

    <script>
        const searchInput = document.getElementById('search-input');
        const resultsList = document.getElementById('results');
        let timeoutId;

        searchInput.addEventListener('input', function() {
            clearTimeout(timeoutId);
            timeoutId = setTimeout(() => {
                const query = this.value;
                fetch(`http://localhost:5000/search?q=${query}`)
                    .then(response => response.json())
                    .then(data => {
                        resultsList.innerHTML = '';
                        data.forEach(item => {
                            const li = document.createElement('li');
                            li.textContent = item;
                            resultsList.appendChild(li);
                        });
                    });
            }, 300);
        });
    </script>
</body>
</html>