Python f-string：フォーマット済み文字列リテラルの完全ガイド

name = "Alice"
age = 30
 
# Basic f-string
message = f"My name is {name} and I am {age} years old"
print(message)
# Output: My name is Alice and I am 30 years old
 
# Using uppercase F
greeting = F"Hello, {name}!"
print(greeting)
# Output: Hello, Alice!

name = "Bob"
score = 95.5
 
# Old style % formatting
old_way = "Student: %s, Score: %.1f" % (name, score)
 
# str.format() method
format_way = "Student: {}, Score: {:.1f}".format(name, score)
 
# Modern f-string
f_string_way = f"Student: {name}, Score: {score:.1f}"
 
print(f_string_way)
# Output: Student: Bob, Score: 95.5

# Arithmetic expressions
x = 10
y = 5
result = f"{x} + {y} = {x + y}"
print(result)
# Output: 10 + 5 = 15
 
# String methods
text = "python"
formatted = f"Language: {text.upper()}, Length: {len(text)}"
print(formatted)
# Output: Language: PYTHON, Length: 6
 
# Dictionary and list access
user = {"name": "Charlie", "role": "developer"}
scores = [88, 92, 95]
info = f"{user['name']} is a {user['role']} with average score {sum(scores)/len(scores):.1f}"
print(info)
# Output: Charlie is a developer with average score 91.7

def calculate_discount(price, discount_percent):
    return price * (1 - discount_percent / 100)
 
price = 100
discount = 20
 
message = f"Original: ${price}, Final: ${calculate_discount(price, discount):.2f}"
print(message)
# Output: Original: $100, Final: $80.00
 
# List comprehension inside f-string
numbers = [1, 2, 3, 4, 5]
result = f"Squares: {[n**2 for n in numbers]}"
print(result)
# Output: Squares: [1, 4, 9, 16, 25]

pi = 3.14159265359
 
# Different decimal places
print(f"2 decimals: {pi:.2f}")
print(f"4 decimals: {pi:.4f}")
print(f"0 decimals: {pi:.0f}")
 
# Output:
# 2 decimals: 3.14
# 4 decimals: 3.1416
# 0 decimals: 3

large_number = 1234567890
 
# Comma separator
print(f"With commas: {large_number:,}")
# Output: With commas: 1,234,567,890
 
# Underscore separator (Python 3.6+)
print(f"With underscores: {large_number:_}")
# Output: With underscores: 1_234_567_890
 
# Combining separators with decimal places
revenue = 1234567.89
print(f"Revenue: ${revenue:,.2f}")
# Output: Revenue: $1,234,567.89

ratio = 0.456
 
# Percentage formatting
print(f"Completion: {ratio:.1%}")
# Output: Completion: 45.6%
 
# Scientific notation
big_num = 1234567890
print(f"Scientific: {big_num:.2e}")
# Output: Scientific: 1.23e+09
 
# Precision with scientific notation
small_num = 0.000000123
print(f"Small: {small_num:.2e}")
# Output: Small: 1.23e-07

number = 255
 
# Binary
print(f"Binary: {number:b}")
# Output: Binary: 11111111
 
# Octal
print(f"Octal: {number:o}")
# Output: Octal: 377
 
# Hexadecimal (lowercase)
print(f"Hex: {number:x}")
# Output: Hex: ff
 
# Hexadecimal (uppercase)
print(f"Hex: {number:X}")
# Output: Hex: FF
 
# With prefix
print(f"Binary: {number:#b}, Hex: {number:#x}")
# Output: Binary: 0b11111111, Hex: 0xff

# Basic alignment
name = "Python"
 
# Left align (default for strings)
print(f"|{name:<15}|")
# Output: |Python         |
 
# Right align
print(f"|{name:>15}|")
# Output: |         Python|
 
# Center align
print(f"|{name:^15}|")
# Output: |    Python     |
 
# Custom fill character
print(f"|{name:*<15}|")
print(f"|{name:*>15}|")
print(f"|{name:*^15}|")
# Output:
# |Python*********|
# |*********Python|
# |****Python*****|

# Creating aligned tables
products = [
    ("Apple", 1.50, 10),
    ("Banana", 0.75, 25),
    ("Orange", 2.00, 15)
]
 
print(f"{'Product':<12} {'Price':>8} {'Qty':>6}")
print("-" * 28)
for product, price, qty in products:
    print(f"{product:<12} ${price:>7.2f} {qty:>6}")
 
# Output:
# Product         Price    Qty
# ----------------------------
# Apple          $   1.50     10
# Banana         $   0.75     25
# Orange         $   2.00     15

# Financial report formatting
transactions = [
    ("Sales", 12500.50),
    ("Returns", -350.25),
    ("Shipping", -125.00),
    ("Tax", 1200.00)
]
 
print(f"{'Category':<15} {'Amount':>12}")
print("=" * 29)
total = 0
for category, amount in transactions:
    total += amount
    sign = "+" if amount >= 0 else ""
    print(f"{category:<15} {sign}{amount:>11,.2f}")
print("=" * 29)
print(f"{'Total':<15} {total:>12,.2f}")
 
# Output:
# Category             Amount
# =============================
# Sales              +12,500.50
# Returns               -350.25
# Shipping              -125.00
# Tax                 +1,200.00
# =============================
# Total               13,225.25

from datetime import datetime, timedelta
 
now = datetime.now()
 
# Basic date formatting
print(f"Date: {now:%Y-%m-%d}")
# Output: Date: 2026-02-11
 
# Full datetime
print(f"DateTime: {now:%Y-%m-%d %H:%M:%S}")
# Output: DateTime: 2026-02-11 14:30:45
 
# Custom formats
print(f"Formatted: {now:%B %d, %Y at %I:%M %p}")
# Output: Formatted: February 11, 2026 at 02:30 PM
 
# Day of week
print(f"Today is {now:%A}")
# Output: Today is Tuesday
 
# Combining with other formatting
duration = timedelta(hours=2, minutes=30)
start_time = datetime(2026, 2, 11, 14, 0)
end_time = start_time + duration
 
print(f"Meeting: {start_time:%I:%M %p} - {end_time:%I:%M %p} ({duration.total_seconds()/3600:.1f} hours)")
# Output: Meeting: 02:00 PM - 04:30 PM (2.5 hours)

# Multiline f-string
name = "Data Science Team"
members = 12
budget = 150000
 
report = f"""
Project Report
{'=' * 40}
Team Name: {name}
Members: {members}
Budget: ${budget:,}
Per Member: ${budget/members:,.2f}
"""
 
print(report)
# Output:
# Project Report
# ========================================
# Team Name: Data Science Team
# Members: 12
# Budget: $150,000
# Per Member: $12,500.00

# Template generation (for display, not execution)
table_name = "users"
columns = ["id", "name", "email"]
conditions = {"status": "active", "age": 25}
 
query = f"""
SELECT {', '.join(columns)}
FROM {table_name}
WHERE status = '{conditions['status']}'
  AND age >= {conditions['age']}
ORDER BY name;
"""
 
print(query)
# Output:
# SELECT id, name, email
# FROM users
# WHERE status = 'active'
#   AND age >= 25
# ORDER BY name;

# Basic debugging
x = 10
y = 20
 
print(f"{x=}, {y=}, {x+y=}")
# Output: x=10, y=20, x+y=30
 
# With formatting
pi = 3.14159
print(f"{pi=:.2f}")
# Output: pi=3.14
 
# Function calls
def calculate_total(items):
    return sum(items)
 
prices = [10.99, 25.50, 8.75]
print(f"{calculate_total(prices)=:.2f}")
# Output: calculate_total(prices)=45.24
 
# Complex expressions
data = [1, 2, 3, 4, 5]
print(f"{len(data)=}, {sum(data)=}, {sum(data)/len(data)=:.2f}")
# Output: len(data)=5, sum(data)=15, sum(data)/len(data)=3.00

# Data analysis debugging
dataset = [45, 52, 48, 61, 55, 49, 58]
 
mean = sum(dataset) / len(dataset)
variance = sum((x - mean) ** 2 for x in dataset) / len(dataset)
std_dev = variance ** 0.5
 
print(f"""
Statistics:
{len(dataset)=}
{mean=:.2f}
{variance=:.2f}
{std_dev=:.2f}
""")
# Output:
# Statistics:
# len(dataset)=7
# mean=52.57
# variance=28.53
# std_dev=5.34

# Dynamic precision
value = 3.14159265
precision = 3
 
result = f"{value:.{precision}f}"
print(result)
# Output: 3.142
 
# Dynamic width and alignment
text = "Python"
width = 12
align = "^"
 
formatted = f"{text:{align}{width}}"
print(f"|{formatted}|")
# Output: |   Python   |
 
# Complex nesting
values = [1.23456, 7.89012, 3.45678]
decimals = 2
 
formatted_values = f"Values: {', '.join([f'{v:.{decimals}f}' for v in values])}"
print(formatted_values)
# Output: Values: 1.23, 7.89, 3.46

# Regular f-string (backslash escaping active)
path = "Documents"
regular = f"C:\Users\{path}\file.txt"  # Would cause issues with \U and \f
# This might not work as expected due to escape sequences
 
# Raw f-string
raw = rf"C:\Users\{path}\file.txt"
print(raw)
# Output: C:\Users\Documents\file.txt
 
# Useful for regex patterns
import re
 
pattern_part = r"\d+"
full_pattern = rf"User ID: {pattern_part}"
print(full_pattern)
# Output: User ID: \d+
 
# Windows file paths
folder = "Projects"
file = "data.csv"
full_path = rf"C:\Users\Admin\{folder}\{file}"
print(full_path)
# Output: C:\Users\Admin\Projects\data.csv

import timeit
 
name = "Alice"
age = 30
 
# f-string
fstring_time = timeit.timeit(
    'f"{name} is {age} years old"',
    globals=globals(),
    number=1000000
)
 
# str.format()
format_time = timeit.timeit(
    '"{} is {} years old".format(name, age)',
    globals=globals(),
    number=1000000
)
 
# % formatting
percent_time = timeit.timeit(
    '"%s is %d" years old" % (name, age)',
    globals=globals(),
    number=1000000
)
 
# Concatenation
concat_time = timeit.timeit(
    'name + " is " + str(age) + " years old"',
    globals=globals(),
    number=1000000
)
 
print(f"f-string: {fstring_time:.4f}s")
print(f"format(): {format_time:.4f}s ({format_time/fstring_time:.2f}x)")
print(f"% format: {percent_time:.4f}s ({percent_time/fstring_time:.2f}x)")
print(f"concat: {concat_time:.4f}s ({concat_time/fstring_time:.2f}x)")
 
# Typical output:
# f-string: 0.0523s
# format(): 0.0891s (1.70x)
# % format: 0.0734s (1.40x)
# concat: 0.0612s (1.17x)

# Same output, different approaches
name = "Bob"
score = 95.5
rank = 3
 
# f-string (modern, recommended)
f_result = f"{name} scored {score:.1f} and ranked #{rank}"
 
# str.format() (good for templates)
format_result = "{} scored {:.1f} and ranked #{}".format(name, score, rank)
 
# % formatting (legacy)
percent_result = "%s scored %.1f and ranked #%d" % (name, score, rank)
 
# All produce: "Bob scored 95.5 and ranked #3"
 
# Where format() excels: reusable templates
template = "Student: {name}, Score: {score:.1f}, Rank: {rank}"
result1 = template.format(name="Alice", score=92.3, rank=5)
result2 = template.format(name="Charlie", score=88.7, rank=8)

# Wrong - causes SyntaxError
# result = f"Use {curly braces} in f-strings"
 
# Correct - double the braces
result = f"Use {{curly braces}} in f-strings"
print(result)
# Output: Use {curly braces} in f-strings
 
# Mixing escaped and interpolated
value = 42
formatted = f"Set value: {{{value}}}"
print(formatted)
# Output: Set value: {42}

# Wrong - causes SyntaxError
# result = f"{'\n'.join(items)}"
 
# Correct - use a variable
newline = '\n'
items = ["apple", "banana", "orange"]
result = f"{newline.join(items)}"
print(result)
 
# Or use a function/method outside the f-string
result = '\n'.join(items)
final = f"Items:\n{result}"

# Wrong - quote mismatch
# message = f"{"key": "value"}"
 
# Correct - use different quote types
message = f'{{"key": "value"}}'
print(message)
# Output: {"key": "value"}
 
# Or escape inner quotes
message = f"{\"key\": \"value\"}"
print(message)
# Output: "key": "value"

data = {"name": "Alice", "score": 95}
 
# Wrong - quote conflict
# result = f"{data["name"]}"
 
# Correct - use different quotes
result = f"{data['name']} scored {data['score']}"
print(result)
# Output: Alice scored 95
 
# Alternative - use get() method
result = f"{data.get('name')} scored {data.get('score')}"

import logging
from datetime import datetime
 
logging.basicConfig(level=logging.INFO)
 
def process_data(filename, records):
    start_time = datetime.now()
 
    logging.info(f"Starting processing: {filename}")
 
    # Simulate processing
    success = records * 0.95
    failed = records - success
 
    duration = (datetime.now() - start_time).total_seconds()
 
    logging.info(
        f"Completed {filename}: "
        f"{success:.0f} successful, {failed:.0f} failed "
        f"in {duration:.2f}s "
        f"({records/duration:.0f} records/sec)"
    )
 
process_data("data.csv", 10000)
# Output: INFO:root:Completed data.csv: 9500 successful, 500 failed in 0.05s (200000 records/sec)

import os
 
def create_report_path(base_dir, project, date, extension="csv"):
    filename = f"{project}_{date:%Y%m%d}_report.{extension}"
    return os.path.join(base_dir, filename)
 
from datetime import date
 
path = create_report_path(
    "/data/reports",
    "sales",
    date.today()
)
print(path)
# Output: /data/reports/sales_20260211_report.csv

import pandas as pd
import pygwalker as pyg
 
# Create sample data with formatted column names
categories = ["Electronics", "Clothing", "Food"]
months = ["Jan", "Feb", "Mar"]
 
data = []
for category in categories:
    for month in months:
        revenue = __import__('random').randint(1000, 5000)
        data.append({
            f"{month}_Revenue": revenue,
            f"{month}_Category": category,
            f"{month}_Growth": f"{__import__('random').uniform(-10, 30):.1f}%"
        })
 
df = pd.DataFrame(data)
 
# Generate dynamic summary
total_revenue = sum([df[f"{m}_Revenue"].sum() for m in months])
summary = f"""
Sales Dashboard Summary
{'=' * 40}
Period: {months[0]} - {months[-1]} 2026
Categories: {len(categories)}
Total Revenue: ${total_revenue:,}
Average per Category: ${total_revenue/len(categories):,.2f}
"""
 
print(summary)
 
# PyGWalker can then visualize this formatted data
# pyg.walk(df)

def generate_performance_report(team_data):
    report_lines = [
        "Team Performance Report",
        "=" * 50,
        ""
    ]
 
    total_score = 0
    for member in team_data:
        name = member["name"]
        score = member["score"]
        tasks = member["tasks_completed"]
        total_score += score
 
        status = "Outstanding" if score >= 90 else "Good" if score >= 75 else "Needs Improvement"
 
        report_lines.append(
            f"{name:<20} | Score: {score:>5.1f} | Tasks: {tasks:>3} | {status}"
        )
 
    avg_score = total_score / len(team_data)
 
    report_lines.extend([
        "",
        "=" * 50,
        f"Team Average: {avg_score:.1f} | Total Members: {len(team_data)}"
    ])
 
    return "\n".join(report_lines)
 
team = [
    {"name": "Alice Johnson", "score": 94.5, "tasks_completed": 28},
    {"name": "Bob Smith", "score": 87.2, "tasks_completed": 25},
    {"name": "Charlie Davis", "score": 78.9, "tasks_completed": 22},
]
 
print(generate_performance_report(team))
 
# Output:
# Team Performance Report
# ==================================================
#
# Alice Johnson        | Score:  94.5 | Tasks:  28 | Outstanding
# Bob Smith            | Score:  87.2 | Tasks:  25 | Good
# Charlie Davis        | Score:  78.9 | Tasks:  22 | Good
#
# ==================================================
# Team Average: 86.9 | Total Members: 3

def format_api_response(endpoint, status_code, response_time, data_size):
    status_emoji = "✓" if status_code == 200 else "✗"
 
    message = f"""
API Call Summary:
  Endpoint: {endpoint}
  Status: {status_code} {status_emoji}
  Response Time: {response_time*1000:.0f}ms
  Data Size: {data_size:,} bytes ({data_size/1024:.1f} KB)
  Throughput: {data_size/response_time/1024:.2f} KB/s
"""
    return message
 
print(format_api_response(
    "/api/v2/users",
    200,
    0.245,
    15680
))
 
# Output:
# API Call Summary:
#   Endpoint: /api/v2/users
#   Status: 200 ✓
#   Response Time: 245ms
#   Data Size: 15,680 bytes (15.3 KB)
#   Throughput: 62.53 KB/s