Pythonにおけるstr関数の使い方と基本的な活用方法10選

age = 25
age_str = str(age)
print(type(age))    # <class 'int'>
print(type(age_str))    # <class 'str'>

fruits = ['apple', 'banana', 'cherry']
fruits_str = str(fruits)
print(fruits_str)    # "['apple', 'banana', 'cherry']"
print(type(fruits_str))    # <class 'str'>

# 整数を文字列に変換
integer_num = 42
str_integer = str(integer_num)
print(f"元の型: {type(integer_num)}, 変換後の型: {type(str_integer)}")
print(f"元の値: {integer_num}, 変換後の値: {str_integer}")

# 浮動小数点数を文字列に変換
float_num = 3.14159
str_float = str(float_num)
print(f"元の型: {type(float_num)}, 変換後の型: {type(str_float)}")
print(f"元の値: {float_num}, 変換後の値: {str_float}")

元の型: <class 'int'>, 変換後の型: <class 'str'>
元の値: 42, 変換後の値: 42
元の型: <class 'float'>, 変換後の型: <class 'str'>
元の値: 3.14159, 変換後の値: 3.14159

# リスト全体を文字列化
fruits = ['apple', 'banana', 'cherry']
str_fruits = str(fruits)
print(f"元のリスト: {fruits}")
print(f"文字列化したリスト: {str_fruits}")

# リストの各要素を個別に文字列化
numbers = [1, 2, 3, 4, 5]
str_numbers = [str(num) for num in numbers]
print(f"元のリスト: {numbers}")
print(f"各要素を文字列化したリスト: {str_numbers}")

元のリスト: ['apple', 'banana', 'cherry']
文字列化したリスト: ['apple', 'banana', 'cherry']
元のリスト: [1, 2, 3, 4, 5]
各要素を文字列化したリスト: ['1', '2', '3', '4', '5']

# 辞書全体を文字列化
person = {'name': 'John', 'age': 30, 'city': 'New York'}
str_person = str(person)
print(f"元の辞書: {person}")
print(f"文字列化した辞書: {str_person}")

# 辞書のキーと値を個別に文字列化
numeric_dict = {1: 100, 2: 200, 3: 300}
str_dict = {str(key): str(value) for key, value in numeric_dict.items()}
print(f"元の辞書: {numeric_dict}")
print(f"キーと値を文字列化した辞書: {str_dict}")

元の辞書: {'name': 'John', 'age': 30, 'city': 'New York'}
文字列化した辞書: {'name': 'John', 'age': 30, 'city': 'New York'}
元の辞書: {1: 100, 2: 200, 3: 300}
キーと値を文字列化した辞書: {'1': '100', '2': '200', '3': '300'}

# 複素数を文字列に変換
complex_num = 3 + 4j
str_complex = str(complex_num)
print(f"元の複素数: {complex_num}")
print(f"文字列化した複素数: {str_complex}")
print(f"元の型: {type(complex_num)}, 変換後の型: {type(str_complex)}")

元の複素数: (3+4j)
文字列化した複素数: (3+4j)
元の型: <class 'complex'>, 変換後の型: <class 'str'>

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"Person(name={self.name}, age={self.age})"

# カスタムオブジェクトを文字列化
person = Person("Alice", 25)
str_person = str(person)
print(f"元のオブジェクト: {person}")
print(f"文字列化したオブジェクト: {str_person}")
print(f"元の型: {type(person)}, 変換後の型: {type(str_person)}")

元のオブジェクト: Person(name=Alice, age=25)
文字列化したオブジェクト: Person(name=Alice, age=25)
元の型: <class '__main__.Person'>, 変換後の型: <class 'str'>

# 基本的な数値のフォーマット
num = 42
formatted_str = "The answer is {:d}".format(num)
print(str(formatted_str))

# 小数点以下の桁数を指定
pi = 3.14159
formatted_pi = "Pi is approximately {:.2f}".format(pi)
print(str(formatted_pi))

# 幅と埋め文字の指定
for i in range(1, 11):
    formatted_num = "{:03d}".format(i)
    print(str(formatted_num))

# 左寄せ、中央寄せ、右寄せ
left = "{:<10}".format("left")
center = "{:^10}".format("center")
right = "{:>10}".format("right")
print(str(left))
print(str(center))
print(str(right))

The answer is 42
Pi is approximately 3.14
001
002
003
004
005
006
007
008
009
010
left      
  center  
     right

# バイト列を文字列に変換（デフォルトはUTF-8）
byte_string = b'Hello, World!'
str_utf8 = str(byte_string, 'utf-8')
print(str_utf8)

# 異なるエンコーディングを指定
byte_string_sjis = b'\x82\xb1\x82\xf1\x82\xc9\x82\xbf\x82\xcd'  # "こんにちは" in Shift-JIS
str_sjis = str(byte_string_sjis, 'shift-jis')
print(str_sjis)

# エラー処理の指定
byte_string_with_error = b'Hello, \xff World!'
str_ignore = str(byte_string_with_error, 'utf-8', errors='ignore')
str_replace = str(byte_string_with_error, 'utf-8', errors='replace')
print(str_ignore)
print(str_replace)

Hello, World!
こんにちは
Hello,  World!
Hello, � World!

# 異なる言語の文字列を用意
english = "Hello, World!"
japanese = "こんにちは、世界！"
chinese = "你好，世界！"
russian = "Привет, мир!"

# それぞれの文字列をUTF-8でエンコード
encoded_english = english.encode('utf-8')
encoded_japanese = japanese.encode('utf-8')
encoded_chinese = chinese.encode('utf-8')
encoded_russian = russian.encode('utf-8')

# エンコードされた文字列をstr関数で元に戻す
decoded_english = str(encoded_english, 'utf-8')
decoded_japanese = str(encoded_japanese, 'utf-8')
decoded_chinese = str(encoded_chinese, 'utf-8')
decoded_russian = str(encoded_russian, 'utf-8')

# 結果を表示
print(f"English: {decoded_english}")
print(f"Japanese: {decoded_japanese}")
print(f"Chinese: {decoded_chinese}")
print(f"Russian: {decoded_russian}")

# バイト列の長さも表示してみる
print(f"\nLength of encoded strings:")
print(f"English: {len(encoded_english)} bytes")
print(f"Japanese: {len(encoded_japanese)} bytes")
print(f"Chinese: {len(encoded_chinese)} bytes")
print(f"Russian: {len(encoded_russian)} bytes")

English: Hello, World!
Japanese: こんにちは、世界！
Chinese: 你好，世界！
Russian: Привет, мир!

Length of encoded strings:
English: 13 bytes
Japanese: 22 bytes
Chinese: 16 bytes
Russian: 21 bytes

import timeit

# str関数を使用した場合
def use_str(name, age):
    return str(name) + " is " + str(age) + " years old."

# f文字列を使用した場合
def use_f_string(name, age):
    return f"{name} is {age} years old."

# パフォーマンス測定
str_time = timeit.timeit('use_str("Alice", 30)', globals=globals(), number=1000000)
f_string_time = timeit.timeit('use_f_string("Alice", 30)', globals=globals(), number=1000000)

print(f"str関数の実行時間: {str_time:.6f} 秒")
print(f"f文字列の実行時間: {f_string_time:.6f} 秒")
print(f"f文字列の方が {(str_time - f_string_time) / str_time * 100:.2f}% 高速")

str関数の実行時間: 0.365842 秒
f文字列の実行時間: 0.276121 秒
f文字列の方が 24.52% 高速

name = "Alice"
age = 30
height = 165.5

# str関数を使用した場合
str_result = str(name) + " is " + str(age) + " years old and " + str(height) + " cm tall."

# f文字列を使用した場合
f_string_result = f"{name} is {age} years old and {height} cm tall."

print("str関数の結果:", str_result)
print("f文字列の結果:", f_string_result)

str関数の結果: Alice is 30 years old and 165.5 cm tall.
f文字列の結果: Alice is 30 years old and 165.5 cm tall.

x = 10
y = 20

# 計算結果を直接f文字列内に記述
result = f"The sum of {x} and {y} is {x + y}."
print(result)

# 条件分岐もf文字列内に記述可能
status = "adult" if age >= 18 else "minor"
result = f"{name} is {status}."
print(result)

The sum of 10 and 20 is 30.
Alice is adult.

# エラーを引き起こすコード
str = "Hello, World!"
print(str("Python"))

# 修正後のコード
greeting = "Hello, World!"
print(str("Python"))

# エラーを引き起こすコード
text = "こんにちは、世界！🌍"
encoded_text = text.encode('ascii')

# 修正後のコード
text = "こんにちは、世界！🌍"
encoded_text = text.encode('utf-8')
print(encoded_text)
print(encoded_text.decode('utf-8'))

b'\xe3\x81\x93\xe3\x82\x93\xe3\x81\xab\xe3\x81\xa1\xe3\x81\xaf\xe3\x80\x81\xe4\xb8\x96\xe7\x95\x8c\xef\xbc\x81\xf0\x9f\x8c\x8d'
こんにちは、世界！🌍

# エラーハンドリングを行うコード
text = "こんにちは、世界！🌍"
try:
    encoded_text = text.encode('ascii', errors='ignore')
    print(encoded_text.decode('ascii'))
except UnicodeEncodeError as e:
    print(f"エンコードエラーが発生しました: {e}")
    print("UTF-8を使用します。")
    encoded_text = text.encode('utf-8')
    print(encoded_text.decode('utf-8'))

, !
エンコードエラーが発生しました: 'ascii' codec can't encode characters in position 0-4: ordinal not in range(128)
UTF-8を使用します。
こんにちは、世界！🌍

# メモリ効率の悪いコード
def build_large_string(n):
    result = ""
    for i in range(n):
        result += str(i)
    return result

large_string = build_large_string(100000)
print(f"文字列の長さ: {len(large_string)}")

# メモリ効率の良いコード
def build_large_string_optimized(n):
    result = []
    for i in range(n):
        result.append(str(i))
    return ''.join(result)

large_string = build_large_string_optimized(100000)
print(f"文字列の長さ: {len(large_string)}")

# ジェネレータを使用したメモリ効率の良いコード
def number_generator(n):
    for i in range(n):
        yield str(i)

# ジェネレータを使用して大きな文字列を構築
large_string = ''.join(number_generator(100000))
print(f"文字列の長さ: {len(large_string)}")

import time
import random

def log_event(event_type, message):
    timestamp = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
    log_id = str(random.randint(1000, 9999))
    formatted_log = f"[{timestamp}] [{log_id}] [{event_type.upper()}] {message}"
    print(formatted_log)

# ログ出力の例
log_event("info", "アプリケーションが起動しました")
log_event("warning", "メモリ使用量が80%を超えています")
log_event("error", "データベース接続に失敗しました")

[2023-06-23 15:30:45] [3721] [INFO] アプリケーションが起動しました
[2023-06-23 15:30:45] [5892] [WARNING] メモリ使用量が80%を超えています
[2023-06-23 15:30:45] [1234] [ERROR] データベース接続に失敗しました

import csv

def create_csv(filename, data):
    with open(filename, 'w', newline='', encoding='utf-8') as file:
        writer = csv.writer(file)
        for row in data:
            # 各要素をstr関数で文字列に変換
            writer.writerow([str(item) for item in row])

# サンプルデータ
data = [
    ["名前", "年齢", "職業"],
    ["山田太郎", 28, "エンジニア"],
    ["佐藤花子", 35, "デザイナー"],
    ["鈴木一郎", 42, "マネージャー"]
]

create_csv("employees.csv", data)
print("CSVファイルが作成されました。")

# 作成されたCSVファイルの内容を表示
with open("employees.csv", 'r', encoding='utf-8') as file:
    print(file.read())

CSVファイルが作成されました。
名前,年齢,職業
山田太郎,28,エンジニア
佐藤花子,35,デザイナー
鈴木一郎,42,マネージャー

import json

class Employee:
    def __init__(self, name, age, position):
        self.name = name
        self.age = age
        self.position = position

    def __str__(self):
        return f"{self.name} ({self.age}): {self.position}"

def employee_to_dict(emp):
    return {
        "name": str(emp.name),
        "age": str(emp.age),
        "position": str(emp.position)
    }

# 従業員データの作成
employees = [
    Employee("山田太郎", 28, "エンジニア"),
    Employee("佐藤花子", 35, "デザイナー"),
    Employee("鈴木一郎", 42, "マネージャー")
]

# JSONデータの生成
json_data = json.dumps([employee_to_dict(emp) for emp in employees], ensure_ascii=False, indent=2)

print("生成されたJSONデータ:")
print(json_data)

# JSONデータをファイルに保存
with open("employees.json", "w", encoding="utf-8") as file:
    file.write(json_data)

print("\nJSONファイルが作成されました。")

生成されたJSONデータ:
[
  {
    "name": "山田太郎",
    "age": "28",
    "position": "エンジニア"
  },
  {
    "name": "佐藤花子",
    "age": "35",
    "position": "デザイナー"
  },
  {
    "name": "鈴木一郎",
    "age": "42",
    "position": "マネージャー"
  }
]

JSONファイルが作成されました。

def create_menu(title, options):
    menu_width = max(len(title), max(len(option) for option in options)) + 4
    menu = f"{'-' * menu_width}\n"
    menu += f"|{title.center(menu_width - 2)}|\n"
    menu += f"{'-' * menu_width}\n"
    for i, option in enumerate(options, 1):
        menu += f"| {str(i)}. {option.ljust(menu_width - 6)}|\n"
    menu += f"{'-' * menu_width}\n"
    return menu

def get_user_choice(options):
    while True:
        try:
            choice = int(input("選択してください (数字): "))
            if 1 <= choice <= len(options):
                return choice
            print("無効な選択です。もう一度試してください。")
        except ValueError:
            print("数字を入力してください。")

# メインメニューの作成と表示
main_menu_options = ["新規タスクの追加", "タスク一覧の表示", "タスクの完了", "アプリケーションの終了"]
main_menu = create_menu("タスク管理アプリ", main_menu_options)
print(main_menu)

# ユーザーの選択を取得
choice = get_user_choice(main_menu_options)
print(f"選択されたオプション: {main_menu_options[choice - 1]}")

------------------------
|    タスク管理アプリ    |
------------------------
| 1. 新規タスクの追加    |
| 2. タスク一覧の表示    |
| 3. タスクの完了        |
| 4. アプリケーションの終了|
------------------------
選択してください (数字): 2
選択されたオプション: タスク一覧の表示

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"{self.name} (年齢: {self.age})"

    def __repr__(self):
        return f"Person(name='{self.name}', age={self.age})"

# Personオブジェクトの作成
person = Person("山田太郎", 30)

# str関数を使用
print("str関数の結果:", str(person))

# print関数を使用（内部でstr関数を呼び出す）
print("print関数の結果:", person)

# repr関数を使用
print("repr関数の結果:", repr(person))

str関数の結果: 山田太郎 (年齢: 30)
print関数の結果: 山田太郎 (年齢: 30)
repr関数の結果: Person(name='山田太郎', age=30)

# 同じ内容の文字列を複数回作成
s1 = str("hello")
s2 = str("hello")
s3 = "hello"

# オブジェクトのIDを確認
print("s1のID:", id(s1))
print("s2のID:", id(s2))
print("s3のID:", id(s3))

# 同一性の確認
print("s1 is s2:", s1 is s2)
print("s1 is s3:", s1 is s3)

s1のID: 140712434911600
s2のID: 140712434911600
s3のID: 140712434911600
s1 is s2: True
s1 is s3: True

# 小さな整数の文字列化
small_int = str(42)
pre_created = "42"

print("small_intのID:", id(small_int))
print("pre_createdのID:", id(pre_created))
print("small_int is pre_created:", small_int is pre_created)

# 大きな整数の文字列化
large_int = str(1000000)
manually_created = "1000000"

print("large_intのID:", id(large_int))
print("manually_createdのID:", id(manually_created))
print("large_int is manually_created:", large_int is manually_created)

small_intのID: 140712434908144
pre_createdのID: 140712434908144
small_int is pre_created: True
large_intのID: 140712434453104
manually_createdのID: 140712434453168
large_int is manually_created: False