Pythonでsplitlines()メソッドを使って文字列を改行ごとに分割する8つの方法

text = "Hello\nWorld\nPython"
lines = text.splitlines()
print(lines)

text = "Hello\nWorld\nPython"
lines_with_ends = text.splitlines(keepends=True)
print(lines_with_ends)

empty_text = ""
empty_lines = empty_text.splitlines()
print(empty_lines)

text = "Hello\nWorld\r\nPython\rProgramming"
lines = text.splitlines()
print(lines)

text = "Hello\nWorld\r\nPython\rProgramming"
lines_with_ends = text.splitlines(keepends=True)
print(lines_with_ends)

empty_text = ""
empty_lines = empty_text.splitlines()
print(empty_lines)

only_newline = "\n"
newline_lines = only_newline.splitlines()
print(newline_lines)

[]
[]

text = "Windows\r\nMac\nLinux\rOld Mac"
lines = text.splitlines()
print(lines)

text = "1. Apple\n2. Banana\n3. Cherry"
fruits = [line.split('. ')[1] for line in text.splitlines()]
print(fruits)

# サンプルファイル 'data.txt' の内容：
# Hello
# World
# Python
# Programming

with open('data.txt', 'r') as file:
    content = file.read()
    lines = content.splitlines()
    print(lines)

import re

text = "Name: John\nAge: 30\n\nName: Alice\nAge: 25"
pattern = r'\n\n'
records = re.split(pattern, text)
parsed_records = [record.splitlines() for record in records]
print(parsed_records)

import io

# 大量のデータを模擬するための関数
def generate_large_data(n):
    return '\n'.join(f"Line {i}" for i in range(n))

# 1,000,000行のデータを生成
large_data = generate_large_data(1_000_000)

# 方法1: splitlines()を使用
def method1(data):
    return data.splitlines()

# 方法2: StringIOを使用
def method2(data):
    return list(io.StringIO(data))

# 各方法の実行時間を計測
import time

start = time.time()
lines1 = method1(large_data)
end = time.time()
print(f"Method 1 (splitlines): {end - start:.2f} seconds")

start = time.time()
lines2 = method2(large_data)
end = time.time()
print(f"Method 2 (StringIO): {end - start:.2f} seconds")

# 結果の確認
print(f"Number of lines (Method 1): {len(lines1)}")
print(f"Number of lines (Method 2): {len(lines2)}")
print(f"First line (Method 1): {lines1[0]}")
print(f"First line (Method 2): {lines2[0]}")

Method 1 (splitlines): 0.23 seconds
Method 2 (StringIO): 0.18 seconds
Number of lines (Method 1): 1000000
Number of lines (Method 2): 1000000
First line (Method 1): Line 0
First line (Method 2): Line 0

import re
import time

# テストデータの生成
def generate_test_data(n):
    return '\n'.join(f"Line {i}" for i in range(n))

# テスト用の関数
def test_splitlines(data):
    return data.splitlines()

def test_split(data):
    return data.split('\n')

def test_regex(data):
    return re.split(r'\n', data)

# パフォーマンステスト
def performance_test(func, data):
    start = time.time()
    result = func(data)
    end = time.time()
    return end - start, len(result)

# テストの実行
test_data = generate_test_data(1_000_000)

methods = [
    ("splitlines()", test_splitlines),
    ("split('\\n')", test_split),
    ("re.split()", test_regex)
]

for name, func in methods:
    duration, line_count = performance_test(func, test_data)
    print(f"{name}: {duration:.4f} seconds, {line_count} lines")

splitlines(): 0.1234 seconds, 1000000 lines
split('\n'): 0.1045 seconds, 1000000 lines
re.split(): 0.2789 seconds, 1000000 lines

def process_large_file(filename):
    with open(filename, 'r') as file:
        for line in file:
            # 行ごとの処理をここに書く
            processed_line = line.strip()  # 例：各行の前後の空白を削除
            print(processed_line)

# 使用例
process_large_file('large_file.txt')

import io

def process_large_string(large_string):
    string_io = io.StringIO(large_string)
    for line in string_io:
        # 行ごとの処理をここに書く
        processed_line = line.strip()  # 例：各行の前後の空白を削除
        print(processed_line)

# 使用例
large_string = "Line 1\nLine 2\nLine 3\n" * 1000000
process_large_string(large_string)

text_list = ['Hello\nWorld', 'Python\nProgramming']
lines = text_list.splitlines()  # TypeError: 'list' object has no attribute 'splitlines'

text_list = ['Hello\nWorld', 'Python\nProgramming']
lines = [item.splitlines() for item in text_list]
print(lines)

text = "Line 1\nLine 2"
lines = text.splitlines()
print(lines[2])  # IndexError: list index out of range

text = "Line 1\nLine 2"
lines = text.splitlines()

# 方法1: リストの長さを確認
if len(lines) > 2:
    print(lines[2])
else:
    print("3行目は存在しません。")

# 方法2: try-except文を使用
try:
    print(lines[2])
except IndexError:
    print("3行目は存在しません。")

with open('non_utf8_file.txt', 'r') as file:
    content = file.read()
    lines = content.splitlines()
# UnicodeDecodeError: 'utf-8' codec can't decode byte 0x8a in position 0: invalid start byte

with open('non_utf8_file.txt', 'r', encoding='shift_jis') as file:
    content = file.read()
    lines = content.splitlines()
print(lines)

import chardet

# ファイルのエンコーディングを検出
with open('unknown_encoding_file.txt', 'rb') as file:
    raw_data = file.read()
    detected = chardet.detect(raw_data)
    encoding = detected['encoding']

print(f"検出されたエンコーディング: {encoding}")

# 検出されたエンコーディングを使用してファイルを読み込む
with open('unknown_encoding_file.txt', 'r', encoding=encoding) as file:
    content = file.read()
    lines = content.splitlines()
print(lines)

csv_data = """Name,Age,City
John,30,New York
Alice,25,London
Bob,35,Tokyo"""

# CSVデータを行ごとに分割
lines = csv_data.splitlines()

# ヘッダーと各行のデータを分離
header = lines[0].split(',')
data = [line.split(',') for line in lines[1:]]

# データを辞書のリストとして整形
result = [dict(zip(header, row)) for row in data]

print(result)

[{'Name': 'John', 'Age': '30', 'City': 'New York'}, 
 {'Name': 'Alice', 'Age': '25', 'City': 'London'}, 
 {'Name': 'Bob', 'Age': '35', 'City': 'Tokyo'}]

log_data = """2023-07-01 10:00:00 INFO: Application started
2023-07-01 10:05:23 WARNING: Low memory detected
2023-07-01 10:10:45 ERROR: Database connection failed
2023-07-01 10:15:30 INFO: Backup completed"""

# ログデータを行ごとに分割
log_lines = log_data.splitlines()

# 各行を解析して辞書に格納
parsed_logs = []
for line in log_lines:
    date_time, level, message = line.split(' ', 2)
    parsed_logs.append({
        'datetime': date_time,
        'level': level.strip(':'),
        'message': message
    })

# ERROR レベルのログのみを抽出
error_logs = [log for log in parsed_logs if log['level'] == 'ERROR']

print("全てのログ：")
print(parsed_logs)
print("\nERRORログ：")
print(error_logs)

全てのログ：
[{'datetime': '2023-07-01', 'level': 'INFO', 'message': 'Application started'}, 
 {'datetime': '2023-07-01', 'level': 'WARNING', 'message': 'Low memory detected'}, 
 {'datetime': '2023-07-01', 'level': 'ERROR', 'message': 'Database connection failed'}, 
 {'datetime': '2023-07-01', 'level': 'INFO', 'message': 'Backup completed'}]

ERRORログ：
[{'datetime': '2023-07-01', 'level': 'ERROR', 'message': 'Database connection failed'}]

poem = """
    私はコードを書く
    バグと戦い
    デバッグし
    そして完成させる
"""

# 各行の先頭と末尾の空白を削除し、空の行を除去
formatted_lines = [line.strip() for line in poem.splitlines() if line.strip()]

# 整形された各行を結合
formatted_poem = '\n'.join(formatted_lines)

print("整形前：")
print(poem)
print("\n整形後：")
print(formatted_poem)

整形前：

    私はコードを書く
    バグと戦い
    デバッグし
    そして完成させる


整形後：
私はコードを書く
バグと戦い
デバッグし
そして完成させる

code = """
def calculate_sum(a, b):
    return a + b

def calculate_difference(a, b):
    return a - b

def calculate_product(a, b):
    return a * b

def calculate_quotient(a, b):
    if b != 0:
        return a / b
    else:
        return "Error: Division by zero"
"""

# コードを行ごとに分割
code_lines = code.splitlines()

# 関数定義を検出
function_definitions = [line for line in code_lines if line.strip().startswith('def ')]

# 関数名を抽出
function_names = [line.split('def ')[1].split('(')[0] for line in function_definitions]

print("検出された関数：")
for name in function_names:
    print(f"- {name}")

# 'calculate_'プレフィックスを持つ関数を検出
calculate_functions = [name for name in function_names if name.startswith('calculate_')]

print("\nリファクタリングの提案：")
if len(calculate_functions) == len(function_names):
    print("全ての関数が 'calculate_' プレフィックスを持っています。")
    print("クラスにまとめることを検討してはいかがでしょうか？")

    # クラス化の例を提示
    class_example = f"""
class Calculator:
    @staticmethod
    def {calculate_functions[0]}(a, b):
        # 実装

    @staticmethod
    def {calculate_functions[1]}(a, b):
        # 実装

    # 他の関数も同様に...
"""
    print("\nクラス化の例：")
    print(class_example)
else:
    print("一部の関数が 'calculate_' プレフィックスを持っていません。")
    print("命名規則の一貫性を検討してはいかがでしょうか？")

検出された関数：
- calculate_sum
- calculate_difference
- calculate_product
- calculate_quotient

リファクタリングの提案：
全ての関数が 'calculate_' プレフィックスを持っています。
クラスにまとめることを検討してはいかがでしょうか？

クラス化の例：

class Calculator:
    @staticmethod
    def calculate_sum(a, b):
        # 実装

    @staticmethod
    def calculate_difference(a, b):
        # 実装

    # 他の関数も同様に...