In this tutorial, we will build an end-to-end Python pipeline using SearchApi (specifically the Google Maps and Google Place engines) to achieve two high-value outcomes simultaneously:

1. Commercial Use Case: Automatically generate a premium, corporate-styled Excel spreadsheet (.xlsx) containing deeply enriched B2B sales leads (Names, Addresses, Phone Numbers, Websites, and Pricing Tiers).

2. Analytical Use Case: Automatically render a fully interactive HTML spatial map (folium), dynamic and color-coded based on local price levels ($, $$, $$$).

Why SearchApi? Bypassing Infrastructure Hurdles

Extracting high-quality, high-frequency location data directly from mapping platforms is notoriously difficult. Sophisticated anti-bot protections, aggressive IP rate-limiting, and sudden CAPTCHAs can easily break custom-built web scrapers, leading to high maintenance costs and incomplete datasets.

This is where SearchApi serves as the critical infrastructure for our project. By handling real-time proxy rotation, CAPTCHA solving, and data retrieval under the hood, it returns clean, structured JSON instantly. Instead of wasting dozens of hours battling infrastructure hurdles and managing headless browsers, this API-first approach allows us to focus 100% of our energy on the core logic of data interpretation, commercial structuring, and visual mapping.

1. Architecture Overview: The Power of Multi-Engine Data Enrichment

Standard web scraping tools easily break due to Google’s robust anti-bot infrastructure. By treating SearchApi as our critical infrastructure, we bypass proxy management and headless browser configurations entirely, allowing us to focus 100% on data structure and analysis.

Our script utilizes a two-tier data enrichment pipeline:

• Tier 1 (google_maps): Sweeps a targeted geographic coordinate and radius based on your industry query (e.g., “steakhouse”, “dentist”, “coffee shop”) to compile a comprehensive local business registry.

• Tier 2 (google_place): Sequentially takes the unique identifiers (kgmid or place_id) from Tier 1 to fetch deep-layer operational metadata, such as exact pricing details and missing contact points.

2. Complete Python Script (sales_and_map_pipeline.py)

This production-grade script features defensive type-checking and exponential backoff retry logic to handle unexpected API structures flawlessly without crashing.

import requests
import time
import logging
import os
import math
from datetime import datetime
from collections import Counter
from typing import List, Dict, Tuple

import pandas as pd
from openpyxl import Workbook
from openpyxl.styles import Font, PatternFill, Alignment
from openpyxl.utils.dataframe import dataframe_to_rows
from openpyxl.utils import get_column_letter

try:
    import folium
    from folium import FeatureGroup, LayerControl
    FOLIUM_AVAILABLE = True
except ImportError:
    FOLIUM_AVAILABLE = False

logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s", datefmt="%H:%M:%S")
logger = logging.getLogger(__name__)

# ============================================================
# ====================== CONFIGURATION =======================
# ============================================================

API_KEY = os.getenv("SEARCHAPI_KEY") or "YOUR_SEARCHAPI_KEY_HERE"

# === Search Settings ===
SEARCH_QUERY = "steakhouse"                    # Target industry (e.g. "coffee shop", "dentist", "sushi")
LOCATION = "@40.7128,-74.0060,14z"             # Coordinates + zoom level (e.g., New York City)
LANGUAGE = "en"                                # "en", "ja", "es", etc.
COUNTRY = "us"                                 # Country code

MAX_PAGES = 3
SEARCH_SLEEP = 1.8

# === Detail Enrichment (Price + Contact Info) ===
ENRICH_DETAILS = False                         # Set True to fetch deep price/contact details via google_place
DETAIL_TOP_N = 0                               # 0 = all results, or limit number to control costs

# === Output Files ===
TIMESTAMP = datetime.now().strftime('%Y%m%d_%H%M')
EXCEL_FILENAME = f"business_analysis_{TIMESTAMP}.xlsx"
CSV_FILENAME = f"business_analysis_{TIMESTAMP}.csv"
MAP_FILENAME = f"business_map_{TIMESTAMP}.html"

# ============================================================
# ====================== HELPER FUNCTIONS ====================
# ============================================================

def normalize_price_band(price_str: str) -> str:
    if not price_str:
        return "Unknown"
    price_str = str(price_str).strip().lower()
    if "¥¥¥¥" in price_str or "$$$$" in price_str:
        return "Very Expensive"
    elif "¥¥¥" in price_str or "$$$" in price_str:
        return "Expensive"
    elif "¥¥" in price_str or "$$" in price_str:
        return "Moderate"
    elif "¥" in price_str or "$" in price_str:
        return "Inexpensive"
    return "Unknown"

def get_price_color(price_level: str) -> str:
    colors = {
        "Inexpensive": "green",
        "Moderate": "blue",
        "Expensive": "orange",
        "Very Expensive": "red",
        "Unknown": "gray"
    }
    return colors.get(price_level, "gray")

def parse_gps(place: dict) -> Tuple[float, float]:
    gps = place.get("gps_coordinates", {})
    if isinstance(gps, dict):
        try:
            return float(gps.get("latitude", 0)), float(gps.get("longitude", 0))
        except:
            pass
    return 0.0, 0.0

def calculate_popularity_score(rating: float, reviews: int) -> float:
    if not rating or not reviews:
        return 0.0
    return round(rating * math.log(reviews + 1), 2)

def extract_base_info(place: dict) -> dict:
    lat, lng = parse_gps(place)
    rating = float(place.get("rating", 0) or 0)
    reviews = int(place.get("reviews", 0) or 0)
    raw_price = place.get("price", "") or place.get("price_description", "")

    return {
        "Name": place.get("title", ""),
        "Address": place.get("address", ""),
        "Phone": place.get("phone", ""),
        "Website": place.get("website", ""),
        "Latitude": lat,
        "Longitude": lng,
        "Rating": rating,
        "Review Count": reviews,
        "Category": ", ".join(place.get("types", [])) if isinstance(place.get("types"), list) else place.get("type", ""),
        "Price Level": normalize_price_band(raw_price),
        "Raw Price": raw_price,
        "Business Status": place.get("open_state", ""),
        "Popularity Score": calculate_popularity_score(rating, reviews),
        "kgmid": place.get("kgmid", ""),
        "Place ID": place.get("place_id", ""),
        "Price Min": None,
        "Price Max": None,
        "Price Range Text": "",
        "Typical Spend": "",
        "Scraped At": datetime.now().isoformat()
    }

def get_place_details(kgmid: str = None, place_id: str = None) -> dict:
    if not (kgmid or place_id):
        return {}

    identifier = kgmid or place_id
    param_name = "kgmid" if kgmid else "place_id"

    try:
        params = {
            "engine": "google_place",
            param_name: identifier,
            "hl": LANGUAGE,
            "gl": COUNTRY
        }
        data = requests.get(
            "https://www.searchapi.io/api/v1/search",
            params={"api_key": API_KEY, **params},
            timeout=25
        ).json()

        place = data.get("place_result") or data.get("place_results", {})
        if not isinstance(place, dict):
            return {}

        price_info = place.get("price", {})
        if isinstance(price_info, dict):
            price_min = price_info.get("min")
            price_max = price_info.get("max")
            price_text = price_info.get("text", "")
        else:
            price_min = price_max = None
            price_text = str(price_info) if price_info else ""

        return {
            "Phone": place.get("phone", ""),
            "Website": place.get("website", ""),
            "Price Min": price_min,
            "Price Max": price_max,
            "Price Range Text": price_text,
            "Typical Spend": place.get("people_typically_spend", "")
        }
    except Exception as e:
        logger.warning(f"Detail fetch error: {e}")
        return {}

def extract_and_enrich_stores(data: dict) -> List[Dict]:
    stores = [extract_base_info(place) for place in data.get("local_results", []) if isinstance(place, dict)]

    if ENRICH_DETAILS and stores:
        sorted_stores = sorted(stores, key=lambda x: x.get("Popularity Score", 0), reverse=True)
        target_stores = sorted_stores[:DETAIL_TOP_N] if DETAIL_TOP_N > 0 else stores

        for store in target_stores:
            if store.get("kgmid") or store.get("Place ID"):
                detail = get_place_details(store.get("kgmid"), store.get("Place ID"))
                if detail:
                    for key in ["Phone", "Website", "Price Min", "Price Max", "Price Range Text", "Typical Spend"]:
                        if detail.get(key):
                            store[key] = detail[key]
                time.sleep(DETAIL_SLEEP)

    return stores

# ================== ANALYSIS ==================
def analyze_businesses(stores: List[Dict]):
    if not stores:
        return

    print("\n" + "="*80)
    print("📊 Local Business Analysis Report")
    print("="*80)

    total = len(stores)
    price_counts = Counter(s.get("Price Level", "Unknown") for s in stores)

    print(f"Total Businesses Found: {total}")
    print("\n【Price Level Distribution】")
    for level in ["Inexpensive", "Moderate", "Expensive", "Very Expensive", "Unknown"]:
        count = price_counts.get(level, 0)
        if count > 0:
            print(f"  {level:15} : {count:3} businesses ({count/total*100:5.1f}%)")

    has_phone = sum(1 for s in stores if s.get("Phone"))
    print(f"\nBusinesses with Phone Number: {has_phone}/{total}")
    print("="*80 + "\n")

# ================== EXPORT ==================
def save_to_excel(stores: List[Dict], filename: str):
    if not stores:
        return

    df = pd.DataFrame(stores)
    columns_order = [
        "Name", "Address", "Phone", "Website", "Rating", "Review Count",
        "Price Level", "Price Min", "Price Max", "Popularity Score",
        "Latitude", "Longitude", "Category", "Business Status", "Scraped At"
    ]
    df = df[[col for col in columns_order if col in df.columns]]

    wb = Workbook()
    ws = wb.active
    ws.title = "Business Data"

    for r_idx, row in enumerate(dataframe_to_rows(df, index=False, header=True), 1):
        for c_idx, value in enumerate(row, 1):
            ws.cell(row=r_idx, column=c_idx, value=value)

    # Corporate Header Styling (Navy / White)
    header_fill = PatternFill(start_color="1F4E79", end_color="1F4E79", fill_type="solid")
    header_font = Font(bold=True, color="FFFFFF", size=11)
    for cell in ws[1]:
        cell.fill = header_fill
        cell.font = header_font
        cell.alignment = Alignment(horizontal='center', vertical='center')

    # Auto-fit Column Widths
    for col_idx in range(1, ws.max_column + 1):
        ws.column_dimensions[get_column_letter(col_idx)].width = 18

    ws.freeze_panes = 'A2'
    wb.save(filename)
    logger.info(f"✅ Excel report saved: {filename}")

def save_to_csv(stores: List[Dict], filename: str):
    if stores:
        pd.DataFrame(stores).to_csv(filename, index=False, encoding="utf-8-sig")
        logger.info(f"✅ CSV saved: {filename}")

# ================== INTERACTIVE MAP ==================
def generate_map(stores: List[Dict], filename: str):
    if not FOLIUM_AVAILABLE or not stores:
        return

    valid_coords = [(s["Latitude"], s["Longitude"]) for s in stores if s.get("Latitude") and s.get("Longitude")]
    if valid_coords:
        center_lat = sum(lat for lat, _ in valid_coords) / len(valid_coords)
        center_lng = sum(lng for _, lng in valid_coords) / len(valid_coords)
        center = [center_lat, center_lng]
    else:
        center = [40.7128, -74.0060]

    m = folium.Map(location=center, zoom_start=13, tiles="cartodbpositron")
    price_layer = FeatureGroup(name="By Price Level", show=True)

    for store in stores:
        if not store.get("Latitude") or not store.get("Longitude"):
            continue

        color = get_price_color(store.get("Price Level", "Unknown"))
        popup_html = f"""
        {store['Name']}
        Phone: {store.get('Phone', 'N/A')}
        Website
        Price Level: {store.get('Price Level')}
        """

        folium.Marker(
            location=[store["Latitude"], store["Longitude"]],
            popup=folium.Popup(popup_html, max_width=300),
            tooltip=store['Name'],
            icon=folium.Icon(color=color, icon="info-sign")
        ).add_to(price_layer)

    price_layer.add_to(m)
    LayerControl(collapsed=False).add_to(m)
    m.save(filename)
    logger.info(f"🗺️ Interactive map saved: {filename}")

# ================== MAIN ==================
def main():
    target_params = {
        "engine": "google_maps",
        "q": SEARCH_QUERY,
        "ll": LOCATION,
        "hl": LANGUAGE,
        "gl": COUNTRY
    }

    logger.info(f"🚀 Starting analysis → Query: '{SEARCH_QUERY}' | Location: {LOCATION}")

    all_stores = []
    for page in range(1, MAX_PAGES + 1):
        target_params["page"] = page
        logger.info(f"📄 Fetching page {page}...")
        try:
            response = requests.get(
                "https://www.searchapi.io/api/v1/search",
                params={"api_key": API_KEY, **target_params},
                timeout=30
            )
            data = response.json()
            all_stores.extend(extract_and_enrich_stores(data))

            if page < MAX_PAGES:
                time.sleep(SEARCH_SLEEP)
        except Exception as e:
            logger.error(f"Error on page {page}: {e}")
            break

    analyze_businesses(all_stores)
    save_to_excel(all_stores, EXCEL_FILENAME)
    save_to_csv(all_stores, CSV_FILENAME)

    if FOLIUM_AVAILABLE:
        generate_map(all_stores, MAP_FILENAME)

    logger.info(f"🎉 Analysis complete! Processed {len(all_stores)} businesses.")

if __name__ == "__main__":
    main()

3. Core Highlights of the Script

3.1. Instant Premium B2B Lead List (Commercial Value)

Instead of outputting an unstyled, raw text file, the script integrates openpyxl to build an execution-ready corporate directory.

• Freeze Panes: Keeps the header visible while scrolling through hundreds of entries.

• Auto-Fit Layout: Calculates optimal column widths dynamically so strings like addresses and domain names don’t get clipped.

• Rich Fields: Extracts telephone contacts and websites directly, providing an instant directory for sales teams or outreach automation tools.

3.2. Macroeconomic Spatial Profiling (Analytical Value)

By taking advantage of folium (a Python wrapper for the powerful Leaflet.js library), the data pipeline parses incoming JSON GPS coordinates on the fly.

• Marker icons are evaluated dynamically based on parsed market values.

• It generates an standalone interactive HTML file containing a map overlay, grouping targets into distinct pricing sub-layers (Inexpensive, Moderate, Expensive, Very Expensive). This visually highlights local inflation density, high-end commercial hubs, or market gaps in target metropolitan areas.

4. Conclusion & Next Steps

By combining SearchApi’s robust mapping extraction capabilities with smart Python styling and geographic rendering, we transformed raw location records into highly structured commercial intelligence.

Whether you are seeking to automate cold outreach lead generation or map out the socio-economic topography of a city, this script serves as your robust foundation. In a future post, we will explore turning this static mapping pipeline into a dynamic, real-time web application dashboard.

What industry or region are you planning to map out first? Let us know in the comments below!

Official economic metrics, such as the Consumer Price Index (CPI), are foundational to understanding macro trends. However, they suffer from a structural defect: latency. By the time government statistics are officially released, the market has already moved on.

For developers and analysts, bridging this informational gap requires a proactive engineering approach to data collection. This project aims to build a Real-time Economic Indicator (REI) Tracker. By monitoring the digital shelf prices of essential goods in a specific metropolitan area (Osaka, Japan), we can identify inflationary or deflationary trends weeks before they appear in official reports.

2. Bypassing Infrastructure Hurdles with SearchApi

Extracting high-quality, high-frequency data from search engines and shopping platforms is notoriously difficult due to sophisticated anti-bot protections, IP blocks, and CAPTCHAs.

SearchApi serves as the critical infrastructure for this project. By handling real-time data retrieval and returning it as clean JSON, it allows us to bypass issues we would otherwise face if we were to try to scrape data ourselves and focus entirely on the logic of data interpretation.

3. Complete Source Code

Below is the robust Python implementation that covers everything from data extraction via SearchApi to data persistence in CSV format using Pandas, featuring duplication prevention for same-day runs.

import requests
import statistics
import pandas as pd
from datetime import datetime, date
import os
import re
import logging
from pathlib import Path
from dataclasses import dataclass
from typing import List, Dict, Optional
from dotenv import load_dotenv

# ====================== setting ======================
load_dotenv()

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s | %(levelname)s | %(message)s',
    datefmt='%H:%M:%S'
)
logger = logging.getLogger(__name__)

API_KEY = os.getenv("SEARCHAPI_API_KEY")
if not API_KEY:
    raise ValueError("SEARCHAPI_API_KEY is not set in the .env file!")

@dataclass
class Config:
    target_items: List[str] = None
    location: str = "Osaka, Osaka, Japan"
    gl: str = "jp"
    hl: str = "ja"
    num_results: int = 20
    min_samples: int = 3

# Tracked products
config = Config(
    target_items=[
        "Egg 10-pack",
        "Rice 5kg",
        "Tissue paper 5-pack",
        "Gasoline price",
        "iPhone 15 128GB",
    ]
)

class EconomicIndicatorTracker:
    def __init__(self, api_key: str, config: Config):
        self.api_key = api_key
        self.config = config
        self.endpoint = "https://www.searchapi.io/api/v1/search"
        self.session = requests.Session()

    @staticmethod
    def parse_price(price_str: str) -> Optional[int]:
        """Securely convert price strings to numbers"""
        if not price_str:
            return None
        cleaned = str(price_str).replace('円', '').replace('¥', '').replace(' ', '')
        cleaned = re.sub(r'[^\d.,]', '', cleaned)
        cleaned = cleaned.replace(',', '')
        try:
            return int(float(cleaned))
        except ValueError:
            return None

    def get_market_price(self, query: str) -> Optional[Dict]:
        """Price data is retrieved from Google Shopping"""
        params = {
            "engine": "google_shopping",
            "q": query,
            "location": self.config.location,
            "api_key": self.api_key,
            "gl": self.config.gl,
            "hl": self.config.hl,
            "num": self.config.num_results,
        }

        try:
            response = self.session.get(self.endpoint, params=params, timeout=20)
            response.raise_for_status()
            data = response.json()

            prices = []
            for item in data.get("shopping_results", []):
                price_str = item.get("price") or item.get("extracted_price")
                if price_str:
                    parsed = self.parse_price(price_str)
                    if parsed and parsed > 0:
                        prices.append(parsed)

            if len(prices) < self.config.min_samples:
                logger.warning(f"There are too few valid samples for {query} ({len(prices)} items).")
                return None

            return {
                "item": query,
                "date": date.today().isoformat(),
                "timestamp": datetime.now().isoformat(),
                "median_price": round(statistics.median(prices)),
                "sample_count": len(prices),
                "min_price": min(prices),
                "max_price": max(prices)
            }
        except Exception as e:
            logger.error(f"Data acquisition error {query}: {e}")
        return None

def main():
    tracker = EconomicIndicatorTracker(API_KEY, config)
    results = []

    print(f"--- Real-world economic survey begins in the Osaka area ({date.today().isoformat()}) ---")
    
    for item in config.target_items:
        logger.info(f"Fetching: {item}...")
        stats = tracker.get_market_price(item)
        if stats:
            results.append(stats)
            logger.info(f"   → median: ¥{stats['median_price']:,} ({stats['sample_count']} 件)")

    if results:
        df_new = pd.DataFrame(results)
        csv_file = f"economic_indicator_{datetime.now().strftime('%Y%m')}.csv"
        
        # CSV persistence logic (preventing duplicate entries for the same day)
        if Path(csv_file).exists():
            df_existing = pd.read_csv(csv_file)
            df_existing = df_existing[df_existing['date'] != date.today().isoformat()]
            df_combined = pd.concat([df_existing, df_new], ignore_index=True)
        else:
            df_combined = df_new

        df_combined.to_csv(csv_file, index=False)
        logger.info(f"💾 Saved to CSV: {csv_file}")
        
        print("\n" + "="*50)
        print("### Market Price Summary ###")
        print(df_new[['item', 'median_price', 'sample_count']].to_string(index=False))
        print("="*50)
    else:
        logger.error("No data was collected.")

if __name__ == "__main__":
    main()

4. Analytical Methodology

• Median Pricing: By prioritizing the Median over the Mean, we effectively eliminate the noise of extreme outliers (such as steep discounts, used items, or shipping entry errors) to find the true “market middle”.

• Localized Context: Setting the geo-location specifically to Osaka allows the script to capture regional supply chain shifts and local logistics impacts.

• Data Persistence: Automated monthly CSV updates generate a clean, reliable historical baseline for robust Month-over-Month (MoM) and Year-over-Year (YoY) economic analysis.

5. Open Source Repository & Quick Start

The complete project files and deployment guide are available on GitHub.

1. Clone & Install: Clone the repository and run pip install -r requirements.txt.

2. Get SearchApi Key: Sign up at SearchApi.io and copy your API key from the developer dashboard.

3. Environment Setup: Create a .env file in the root folder and add your key: SEARCHAPI_API_KEY=your_api_key_here.

4. Run: Execute python rei_tracker.py to start collecting real-time market insights and generating your localized CSV datasets.

👉 https://github.com/kobayashikazu/rei-tracker-osaka

なお、初速度 v0 が 0 m/s で、地上から自由落下する物体が 10 秒後にどのくらいの速度に達するかを計算し、結果を表示するPythonプログラムを作ります。

■今回の環境（Python）

今回のPythonは、バージョン3.10.12を用いる。（なお、Google Colaboratory(Google Colab)を使用。）

■結果を表示するPythonプログラム

■コード

# 重力加速度 (m/s²)
g = 9.81

# 初速度 (m/s)
v0 = 0

# 時間 (秒)
t = 10

# 速度を計算
v = v0 + g * t

# 結果を表示
print("10 秒後の速度は {:.2f} m/s です。".format(v))

■検証、確認

作成したコードは、Google Colaboratoryの新しいノートブック上のセルにコードを記述します。その後「セルを実行」ボタンをクリックします。

先に計算した結果を書くと「98.10 m/s」となります。クリックすると、Google Colaboratory上で処理された結果を確認すると「10 秒後の速度は 98.10 m/s です。」と出力させることができました。

■補足

※速度の時間変化をアニメーションとして描画するためのコード

import matplotlib.pyplot as plt

import numpy as np
from matplotlib.animation import FuncAnimation

# 重力加速度 (m/s²)
g = 9.81

# 初速度 (m/s)
v0 = 0

# 時間 (秒)
t = 10

# 時間の配列を作成（0からtまで0.1秒刻み）
time = np.arange(0, t, 0.1)

# 速度の配列を計算
velocity = v0 + g * time

# グラフの初期設定
fig, ax = plt.subplots()
ax.set_xlim(0, t)
ax.set_ylim(0, max(velocity) + 1)
line, = ax.plot([], [], lw=2)

# アニメーションの初期化
def init():
    line.set_data([], [])
    return line,

# アニメーションのフレーム更新
def update(frame):
    x_data = time[:frame]
    y_data = velocity[:frame]
    line.set_data(x_data, y_data)
    return line,

# アニメーションの作成
ani = FuncAnimation(fig, update, frames=len(time), init_func=init, blit=True)

# アニメーションの表示
plt.xlabel('Time (s)')
plt.ylabel('Velocity (m/s)')
plt.title('Velocity vs. Time')
plt.show()

■今回の環境（Python）

今回のPythonは、バージョン3.10.12を用いる。（なお、Google Colaboratory(Google Colab)を使用。）

■結果を表示するPythonプログラム

■コード

import matplotlib.pyplot as plt
import numpy as np

# 円の中心座標
center = (0, 0)

# 円の半径
radius = 2

# 角度の範囲を指定（0から360度まで）
theta = np.linspace(0, 2*np.pi, 100)

# 円の座標を計算
x = center[0] + radius * np.cos(theta)
y = center[1] + radius * np.sin(theta)

# プロット
plt.plot(x, y)
plt.title('円の描画')
plt.xlabel('X軸')
plt.ylabel('Y軸')
plt.grid(True)
plt.show()

円の中心座標と半径を指定し、それを用いて円の座標を計算します。最後に、matplotlibのplot関数を使用して円をプロットし、show関数で表示します。

■検証、確認

作成したコードは、Google Colaboratoryの新しいノートブック上のセルにコードを記述します。その後「セルを実行」ボタンをクリックします。

クリックすると、matplotlibを用いて数学を使った図形を出力させることができました。

物体が斜めに投げられる場合、水平方向と鉛直方向の速度が影響します。水平方向の速度を Vx ​ 、鉛直方向の速度を Vy ​ とし、初速度 V0 ​ の物体が角度 θ で斜めに投げられるとします。以下の式を使用して、物体の位置を時間と共に計算します。

ここで、x は水平方向の位置（メートル）、 y は鉛直方向の位置（メートル）、 t は時間（秒）です。

■今回の環境（Python）

今回のPythonは、バージョン3.10.12を用いる。（なお、Google Colaboratory(Google Colab)を使用。）

■斜めに投げられた物体に関するpythonプログラム

今回は初速度 v0​=20 m/s で、角度 θ=30∘ で斜めに投げられた物体の高度を時間と共に計算し、0 になる時間を求めるプログラムを作ってみます。プログラムを実行後、物体が地上に戻る時間を計算します。

■コード

import math

# 初速度 (m/s)
v0 = 20

# 投げる角度 (度)
theta = 30

# 重力加速度 (m/s²)
g = 9.81

# 角度をラジアンに変換
theta = math.radians(theta)

# 初速度を水平方向と鉛直方向の速度に分解
vx = v0 * math.cos(theta)
vy = v0 * math.sin(theta)

# 物体が地上に戻る時間を計算
t = (2 * vy) / g

# 結果を表示
print("物体が地上に戻る時間は {:.2f} 秒です。".format(t))

■検証、確認

作成したコードは、Google Colaboratoryの新しいノートブック上のセルにコードを記述します。その後「セルを実行」ボタンをクリックします。

先に答えを書くと「2.04 秒」となります。クリック後、Google Colaboratory上で処理された計算結果を確認すると「物体が地上に戻る時間は 2.04 秒です。」と出力させることができました。

今回は代数方程式を解くためにSymPyを使用します。Google ColaboratoryではSympyがすでにインストールされた状態となっています。

■今回の環境（Python）

今回のPythonは、バージョン3.10.12を用いる。（なお、Google Colaboratory(Google Colab)を使用。）

■簡単な代数の問題を解く

以下の代数方程式を解く

3x−5=10

■コード

import sympy as sp

# 未知数を定義
x = sp.symbols('x')

# 代数方程式を定義
equation = 3*x - 5 - 10

# 方程式を解く
solution = sp.solve(equation, x)

print("方程式の解は x =", solution[0])

■検証、確認

作成したコードは、Google Colaboratoryの新しいノートブック上のセルにコードを記述します。その後「セルを実行」ボタンをクリックします。

クリックすると、代数方程式の答えは「x=5」となりますので、Google Colaboratory上で処理された結果を確認すると「方程式の解は x = 5」と出力されていますので、代数の問題を解くことができました。

■今回の環境（Python）

今回のPythonは、バージョン3.10.12を用いる。（なお、Google Colaboratory(Google Colab)を使用。）

■フィボナッチ数列を使って三角形を出力する

では、フィボナッチ数列を使って三角形を出力するPythonコードを書いていきます。

def generate_fibonacci_triangle(rows):
    fibonacci_numbers = [1, 1]
    fibonacci_triangle = [[1], [1, 1]]

    for n in range(2, rows):
        fibonacci_n = fibonacci_numbers[n - 1] + fibonacci_numbers[n - 2]
        fibonacci_numbers.append(fibonacci_n)

        row = [1]
        for i in range(1, n):
            row.append(fibonacci_numbers[i])
        fibonacci_triangle.append(row)

    return fibonacci_triangle

def print_fibonacci_triangle(triangle):
    max_width = len(' '.join(map(str, triangle[-1])))

    for row in triangle:
        row_str = ' '.join(map(str, row))
        print(row_str.center(max_width))

if __name__ == "__main__":
    num_rows = 15  # 任意の行数を指定できます
    triangle = generate_fibonacci_triangle(num_rows)
    print_fibonacci_triangle(triangle)

このコードでは、指定した行数（num_rows）のフィボナッチ数列の三角形を生成し、それを表示します。print_fibonacci_triangle関数は、各行の要素を適切に中央揃えして表示します。必要に応じて、num_rowsを調整して三角形の高さを変更できます。

■検証、確認

作成したコードは、Google Colaboratoryの新しいノートブック上のセルにコードを記述します。その後「セルを実行」ボタンをクリックします。

クリックすると、セル上のコードが読み込まれ処理が実行となり、出力が表示されます。出力結果を確認すると、フィボナッチ数列を使って三角形を出力することができました。

「python-Levenshtein（https://github.com/maxbachmann/python-Levenshtein）」は、レーベンシュタイン距離と文字列の類似性を高速に計算する関数が含まれたPythonライブラリです。

■Python

今回のPythonのバージョンは、「3.10.9」を使用しています。（Windows11）（pythonランチャーでの確認）

■python-Levenshteinをインストールする

python-Levenshteinをインストールを行いますが、今回はpipを経由してインストールを行うので、まずWindowsのコマンドプロンプトを起動します。

pip install python-Levenshtein

起動後、上記のコマンドを入力し、Enterキーを押します。

なお、今回は、pythonランチャーを使用しており、Python Version 3.10.9にインストールを行うために、バージョンの切り替えを行います。

py -3.10 -m pip install python-Levenshtein

切り替えるために、上記のコマンドを入力し、Enterキーを押します。

Defaulting to user installation because normal site-packages is not writeable
Collecting python-Levenshtein
  Using cached python_Levenshtein-0.22.0-py3-none-any.whl (9.4 kB)
Collecting Levenshtein==0.22.0
  Using cached Levenshtein-0.22.0-cp310-cp310-win_amd64.whl (100 kB)
Collecting rapidfuzz<4.0.0,>=2.3.0
  Using cached rapidfuzz-3.3.1-cp310-cp310-win_amd64.whl (1.8 MB)
Installing collected packages: rapidfuzz, Levenshtein, python-Levenshtein
Successfully installed Levenshtein-0.22.0 python-Levenshtein-0.22.0 rapidfuzz-3.3.1

Enterキーを押すと、インストールが開始され、上記のように「Successfully installed」と表示されます。これが表示されれば、python-Levenshteinが正常にインストールされたことになります。

なお、今回はpython-Levenshteinのバージョン0.22.0をインストールしました。

「medium-api（https://github.com/weeping-angel/medium-api）」は、Medium API上の Python ラッパーにより、MediumのWeb サイト（https://medium.com）からデータを抽出できる。なお、これはMediumが公式で配布しているものではなく、非公式であることを理解しておく必要があります。

■Python

今回のPythonのバージョンは、「3.9.9」を使用しています。（Windows11）（pythonランチャーでの確認）

■medium-apiをインストールする

medium-apiをインストールを行いますが、今回はpipを経由してインストールを行うので、まずWindowsのコマンドプロンプトを起動します。

pip install medium-api

起動後、上記のコマンドを入力し、Enterキーを押します。

なお、今回は、pythonランチャーを使用しており、Python Version 3.9.9にインストールを行うために、バージョンの切り替えを行います。

py -3.9 -m pip install medium-api

切り替えるために、上記のコマンドを入力し、Enterキーを押します。

Defaulting to user installation because normal site-packages is not writeable
Collecting medium-api
  Downloading medium_api-0.5.4-py3-none-any.whl (23 kB)
Installing collected packages: medium-api
Successfully installed medium-api-0.5.4
WARNING: You are using pip version 21.2.4; however, version 23.2.1 is available.
You should consider upgrading via the 'C:\Program Files\Python39\python.exe -m pip install --upgrade pip' command.

Enterキーを押すと、インストールが開始され、上記のように「Successfully installed」と表示されます。これが表示されれば、medium-apiが正常にインストールされたことになりますが、「WARNING」と表示されました。「WARNING」はエラーではなく警告で、インストールは行われているので、今回は一旦無視しています。

なお、今回はmedium-apiのバージョン0.5.4をインストールしました。