Pythonのcasefoldを利用した大小文字無視の比較方法と実践例10選

text = "Straße"  # ドイツ語で「通り」の意味
print(text.casefold())

text = "HELLO WORLD"
print(text.lower())

text = "HELLO WORLD"
print(text.casefold())

german_text = "GROẞE"  # ドイツ語で「大きい」の意味
print(german_text.lower())
print(german_text.casefold())

groẞe
grosse

text1 = "  HELLO WORLD  "
text2 = "hello world"
print(text1.strip().casefold() == text2.strip().casefold())

def compare_strings(str1, str2):
    return str1.casefold() == str2.casefold()

print(compare_strings("Hello", "hello"))
print(compare_strings("WORLD", "world"))
print(compare_strings("Python", "PYTHON"))

True
True
True

def check_fruit(fruit_name, fruit_list):
    return any(fruit.casefold() == fruit_name.casefold() for fruit in fruit_list)

fruits = ["Apple", "Banana", "Cherry", "Date"]
user_input = input("フルーツの名前を入力してください: ")

if check_fruit(user_input, fruits):
    print(f"{user_input}はリストに含まれています。")
else:
    print(f"{user_input}はリストに含まれていません。")

フルーツの名前を入力してください: banana
bananaはリストに含まれています。

フルーツの名前を入力してください: CHERRY
CHERRYはリストに含まれています。

import timeit

def test_lower(text):
    return text.lower()

def test_casefold(text):
    return text.casefold()

text = "HELLO WORLD" * 1000000

lower_time = timeit.timeit(lambda: test_lower(text), number=10)
casefold_time = timeit.timeit(lambda: test_casefold(text), number=10)

print(f"lower処理時間: {lower_time:.6f}秒")
print(f"casefold処理時間: {casefold_time:.6f}秒")

lower処理時間: 0.235678秒
casefold処理時間: 0.267890秒

# string型
text_string = "Hello, World!"
print(type(text_string))

# bytes型
text_bytes = b"Hello, World!"
print(type(text_bytes))

<class 'str'>
<class 'bytes'>

def compare_bytes_and_string(bytes_data, string_data):
    decoded_bytes = bytes_data.decode('utf-8')
    return decoded_bytes.casefold() == string_data.casefold()

bytes_data = b"PYTHON"
string_data = "python"

print(compare_bytes_and_string(bytes_data, string_data))

import io

def compare_binary_data(data1, data2):
    str1 = io.BytesIO(data1).read().decode('utf-8')
    str2 = io.BytesIO(data2).read().decode('utf-8')
    return str1.casefold() == str2.casefold()

# バイナリデータをシミュレート
binary_data1 = b"HELLO WORLD"
binary_data2 = b"hello world"

print(compare_binary_data(binary_data1, binary_data2))

def case_insensitive_sort(string_list):
    return sorted(string_list, key=str.casefold)

mixed_case_list = ["apple", "Banana", "CHERRY", "Date", "elderberry"]
sorted_list = case_insensitive_sort(mixed_case_list)

print(sorted_list)

def case_insensitive_search(search_term, string_list):
    return [s for s in string_list if search_term.casefold() in s.casefold()]

fruit_list = ["Apple", "BANANA", "Cherry", "DATE", "Elderberry"]
search_result = case_insensitive_search("be", fruit_list)

print(search_result)

def validate_user_input(user_input, valid_options):
    return user_input.casefold() in [option.casefold() for option in valid_options]

valid_options = ["Yes", "No", "Maybe"]
user_input = input("選択してください (Yes/No/Maybe): ")

if validate_user_input(user_input, valid_options):
    print("有効な選択です")
else:
    print("無効な選択です")

選択してください (Yes/No/Maybe): yEs
有効な選択です

def remove_case_insensitive_duplicates(input_list):
    seen = set()
    return [x for x in input_list if not (x.casefold() in seen or seen.add(x.casefold()))]

original_list = ["Apple", "banana", "APPLE", "Cherry", "BANANA", "Date"]
result = remove_case_insensitive_duplicates(original_list)
print(result)

class CaseInsensitiveDict(dict):
    def __setitem__(self, key, value):
        super().__setitem__(key.casefold(), value)

    def __getitem__(self, key):
        return super().__getitem__(key.casefold())

my_dict = CaseInsensitiveDict()
my_dict["Hello"] = "World"
print(my_dict["hello"])  # 大文字小文字を区別せずにアクセス可能

import memoryview

def compare_memory_views(view1, view2):
    str1 = view1.tobytes().decode('utf-8')
    str2 = view2.tobytes().decode('utf-8')
    return str1.casefold() == str2.casefold()

data1 = memoryview(b"HELLO")
data2 = memoryview(b"hello")

print(compare_memory_views(data1, data2))

def normalize_url(url):
    return url.casefold().replace("http://", "").replace("https://", "").rstrip("/")

url1 = "HTTPS://www.Example.com/"
url2 = "http://www.example.com"

print(normalize_url(url1) == normalize_url(url2))

import collections

def analyze_text(text):
    words = text.split()
    word_counts = collections.Counter(word.casefold() for word in words)
    return word_counts.most_common(5)

text = "The quick Brown fox jumps over the Lazy Dog. THE DOG stays Lazy."
print(analyze_text(text))

def find_matching_strings(target, string_list):
    target_casefold = target.casefold()
    return [s for s in string_list if s.casefold() == target_casefold]

strings = ["Hello", "HELLO", "hello", "Hola", "BONJOUR"]
target = "HeLLo"

print(find_matching_strings(target, strings))

def optimize_string_list(string_list):
    casefold_dict = {}
    for s in string_list:
        casefold_key = s.casefold()
        if casefold_key not in casefold_dict or len(s) < len(casefold_dict[casefold_key]):
            casefold_dict[casefold_key] = s
    return list(casefold_dict.values())

original_list = ["Apple", "APPLE", "apple", "Banana", "BANANA", "Cherry"]
optimized_list = optimize_string_list(original_list)
print(optimized_list)

text = "Große"  # ドイツ語で「大きい」という意味

print(text.upper())
print(text.lower())
print(text.casefold())

GROẞE
große
grosse

def is_all_lowercase(text):
    return text.islower()

def compare_case_insensitive(text1, text2):
    return text1.casefold() == text2.casefold()

print(is_all_lowercase("hello"))
print(is_all_lowercase("Hello"))
print(compare_case_insensitive("Hello", "hElLo"))

True
False
True

def case_insensitive_startswith(text, prefix):
    return text.casefold().startswith(prefix.casefold())

def case_insensitive_endswith(text, suffix):
    return text.casefold().endswith(suffix.casefold())

print(case_insensitive_startswith("Hello World", "hello"))
print(case_insensitive_endswith("Python Programming", "PROGRAMMING"))

True
True

import sys

print(sys.version)  # Pythonのバージョンを確認

text = "Straße"  # ドイツ語で「通り」という意味
print(text.casefold())

3.7.X (default, Mon DD YYYY, HH:MM:SS) 
[GCC X.X.X] on linux
strasse

def safe_casefold(text):
    if hasattr(text, 'casefold'):
        return text.casefold()
    else:
        return text.lower()

print(safe_casefold("HELLO"))
print(safe_casefold(u"STRAÃE"))  # Unicodeで「STRASSE」を表現

hello
straÃe

from dataclasses import dataclass, field

@dataclass
class CaseInsensitiveString:
    text: str
    _lowercase: str = field(init=False, repr=False)

    def __post_init__(self):
        self._lowercase = self.text.casefold()

    def __eq__(self, other):
        if isinstance(other, CaseInsensitiveString):
            return self._lowercase == other._lowercase
        return self._lowercase == other.casefold()

ci_str1 = CaseInsensitiveString("Hello")
ci_str2 = CaseInsensitiveString("hElLo")
ci_str3 = CaseInsensitiveString("World")

print(ci_str1 == ci_str2)
print(ci_str1 == ci_str3)
print(ci_str1 == "HELLO")

True
False
True

def process_string(text):
    return text.casefold()

result = process_string(None)
print(result)

def process_string(text):
    if text is None:
        return None
    return text.casefold()

result = process_string(None)
print(result)  # None
result = process_string("Hello")
print(result)  # hello

text = "Hello"
result = text.casefold("argument")
print(result)

text = "Hello"
result = text.casefold()
print(result)  # hello

def compare_strings(str1, str2):
    return str1.casefold() == str2.casefold()

print(compare_strings("Hello", "hello"))  # True
print(compare_strings("WORLD", "world"))  # True

def is_equal_ignore_case(str1, str2):
    return str1.casefold() == str2.casefold()

print(is_equal_ignore_case("Straße", "STRASSE"))  # True
print(is_equal_ignore_case("İstanbul", "istanbul"))  # True

class CaseInsensitiveString:
    def __init__(self, text):
        self.original = text
        self.folded = text.casefold()

    def __eq__(self, other):
        if isinstance(other, CaseInsensitiveString):
            return self.folded == other.folded
        return self.folded == other.casefold()

ci_str1 = CaseInsensitiveString("Hello")
ci_str2 = CaseInsensitiveString("hello")
print(ci_str1 == ci_str2)  # True
print(ci_str1 == "HELLO")  # True

def find_case_insensitive(needle, haystack):
    needle_folded = needle.casefold()
    return [item for item in haystack if item.casefold() == needle_folded]

haystack = ["Apple", "Banana", "Cherry", "Date", "APPLE", "banana"]
print(find_case_insensitive("apple", haystack))  # ['Apple', 'APPLE']

def case_insensitive_filter(iterable, target):
    target_folded = target.casefold()
    for item in iterable:
        if item.casefold() == target_folded:
            yield item

large_list = ["Apple", "Banana", "Cherry", "Date", "APPLE", "banana"] * 1000000
for match in case_insensitive_filter(large_list, "apple"):
    print(match)
    break  # 最初の一致のみを表示

import re

def case_insensitive_search(pattern, text):
    return re.findall(pattern, text, re.IGNORECASE)

text = "The Quick Brown Fox Jumps Over The Lazy Dog"
pattern = r"the.*?dog"

print(case_insensitive_search(pattern, text))
# ['The Quick Brown Fox Jumps Over The Lazy Dog']