Pythonのlen関数を使って配列のサイズを確認する方法と活用例12選

message = "Hello, Python!"
print(len(message))

fruits = ["apple", "banana", "cherry", "date"]
print(len(fruits))

person = {"name": "Alice", "age": 30, "city": "New York"}
print(len(person))

# 文字列
text = "Python"
print(len(text))  # 出力: 6

# リスト
numbers = [1, 2, 3, 4, 5]
print(len(numbers))  # 出力: 5

# タプル
coordinates = (10, 20, 30)
print(len(coordinates))  # 出力: 3

# 辞書
user = {"name": "Bob", "age": 25}
print(len(user))  # 出力: 2

# セット
unique_numbers = {1, 2, 3, 3, 4, 4, 5}
print(len(unique_numbers))  # 出力: 5

# バイト列
data = b"Hello"
print(len(data))  # 出力: 5

# range オブジェクト
number_range = range(0, 10, 2)
print(len(number_range))  # 出力: 5

fruits = ["りんご", "バナナ", "オレンジ", "ぶどう", "メロン"]
fruit_count = len(fruits)
print(f"果物リストの要素数: {fruit_count}")

message = "こんにちは、Pythonの世界へようこそ！"
message_length = len(message)
print(f"メッセージの長さ: {message_length}文字")

coordinates = (35.6895, 139.6917, "東京タワー")
coord_count = len(coordinates)
print(f"座標データの要素数: {coord_count}")

user_info = {
    "name": "山田太郎",
    "age": 30,
    "email": "yamada@example.com",
    "city": "東京"
}
key_count = len(user_info)
print(f"ユーザー情報の項目数: {key_count}")

unique_visitors = {"Alice", "Bob", "Charlie", "Alice", "David", "Bob"}
visitor_count = len(unique_visitors)
print(f"ユニークな訪問者数: {visitor_count}")

# 生徒の名前と点数を含む2次元リスト
student_scores = [
    ["太郎", 85, 90, 78],
    ["花子", 92, 88, 96],
    ["次郎", 78, 85, 80],
    ["美香", 95, 92, 88]
]

row_count = len(student_scores)
print(f"生徒の人数: {row_count}人")

# 各生徒の点数を表示
for i, student in enumerate(student_scores, 1):
    name = student[0]
    average_score = sum(student[1:]) / len(student[1:])
    print(f"生徒{i}: {name}, 平均点: {average_score:.2f}")

生徒の人数: 4人
生徒1: 太郎, 平均点: 84.33
生徒2: 花子, 平均点: 92.00
生徒3: 次郎, 平均点: 81.00
生徒4: 美香, 平均点: 91.67

# UTF-8エンコードされた日本語文字列をバイト列に変換
japanese_bytes = "こんにちは、世界！".encode('utf-8')
byte_length = len(japanese_bytes)
print(f"バイト列の長さ: {byte_length} バイト")

# バイト列を16進数で表示
hex_representation = ' '.join([f'{byte:02x}' for byte in japanese_bytes])
print(f"16進数表現: {hex_representation}")

バイト列の長さ: 22 バイト
16進数表現: e3 81 93 e3 82 93 e3 81 ab e3 81 a1 e3 81 af e3 80 81 e4 b8 96 e7 95 8c 21

# 0から9までの範囲を作成
number_range = range(10)
range_size = len(number_range)
print(f"range(10)のサイズ: {range_size}")

# 1から20まで、2つおきの範囲を作成
step_range = range(1, 21, 2)
step_range_size = len(step_range)
print(f"range(1, 21, 2)のサイズ: {step_range_size}")

# 実際の要素を表示
print("range(1, 21, 2)の要素:")
for num in step_range:
    print(num, end=' ')

range(10)のサイズ: 10
range(1, 21, 2)のサイズ: 10
range(1, 21, 2)の要素:
1 3 5 7 9 11 13 15 17 19 

class Bookshelf:
    def __init__(self):
        self.books = []

    def add_book(self, title):
        self.books.append(title)

    def __len__(self):
        return len(self.books)

# 本棚を作成し、本を追加
my_shelf = Bookshelf()
my_shelf.add_book("Python入門")
my_shelf.add_book("データ構造とアルゴリズム")
my_shelf.add_book("機械学習の基礎")

# len()関数で本の数を取得
book_count = len(my_shelf)
print(f"本棚の本の数: {book_count}")

def number_generator(n):
    for i in range(n):
        yield i

# ジェネレータを作成
gen = number_generator(1000000)

# len()関数は直接使えない
try:
    print(len(gen))
except TypeError as e:
    print(f"エラー: {e}")

# 要素数を数える関数
def count_generator(generator):
    return sum(1 for _ in generator)

# 要素数を数える（注意：ジェネレータを消費します）
count = count_generator(gen)
print(f"ジェネレータの要素数: {count}")

# ジェネレータは消費済み
print("ジェネレータの残りの要素:")
for num in gen:
    print(num, end=' ')

エラー: object of type 'generator' has no len()
ジェネレータの要素数: 1000000
ジェネレータの残りの要素:

def process_data(data):
    if len(data) == 0:
        return "データが空です"
    elif len(data) < 5:
        return f"データが少ないです: {data}"
    elif len(data) < 10:
        return f"適度なデータ量です: {data}"
    else:
        return f"データが多いです。先頭5要素: {data[:5]}"

# 異なる長さのデータでテスト
print(process_data([]))
print(process_data([1, 2, 3]))
print(process_data([1, 2, 3, 4, 5, 6, 7]))
print(process_data([i for i in range(20)]))

データが空です
データが少ないです: [1, 2, 3]
適度なデータ量です: [1, 2, 3, 4, 5, 6, 7]
データが多いです。先頭5要素: [0, 1, 2, 3, 4]

# 名前のリスト
names = ["太郎", "花子", "次郎", "美香", "健太"]

# 名前の数だけ0で初期化されたスコアリストを作成
scores = [0] * len(names)

print("初期スコア:")
for name, score in zip(names, scores):
    print(f"{name}: {score}")

# ランダムにスコアを更新
import random
for i in range(len(scores)):
    scores[i] = random.randint(0, 100)

print("\n更新後のスコア:")
for name, score in zip(names, scores):
    print(f"{name}: {score}")

# 平均点を計算
average_score = sum(scores) / len(scores)
print(f"\n平均点: {average_score:.2f}")

初期スコア:
太郎: 0
花子: 0
次郎: 0
美香: 0
健太: 0

更新後のスコア:
太郎: 73
花子: 45
次郎: 92
美香: 18
健太: 61

平均点: 57.80

import random

# 大規模なデータセットを模擬的に作成
big_data = [random.randint(1, 1000) for _ in range(1000000)]

# データの分割処理
chunk_size = 100000
num_chunks = len(big_data) // chunk_size

for i in range(num_chunks):
    start = i * chunk_size
    end = (i + 1) * chunk_size
    chunk = big_data[start:end]

    # チャンクごとの処理（ここでは平均値を計算）
    avg = sum(chunk) / len(chunk)
    print(f"チャンク {i+1} の平均値: {avg:.2f}")

# 残りのデータを処理
if len(big_data) % chunk_size != 0:
    last_chunk = big_data[num_chunks*chunk_size:]
    avg = sum(last_chunk) / len(last_chunk)
    print(f"最後のチャンクの平均値: {avg:.2f}")

チャンク 1 の平均値: 500.51
チャンク 2 の平均値: 500.76
チャンク 3 の平均値: 500.30
チャンク 4 の平均値: 500.54
チャンク 5 の平均値: 499.74
チャンク 6 の平均値: 500.24
チャンク 7 の平均値: 500.12
チャンク 8 の平均値: 500.39
チャンク 9 の平均値: 500.09
チャンク 10 の平均値: 500.24

import time

# 大きなリストを作成
big_list = list(range(10000000))

# 悪い例：ループの度にlen()を呼び出す
start_time = time.time()
sum_bad = 0
for i in range(len(big_list)):
    sum_bad += big_list[i]
end_time = time.time()
print(f"悪い例の実行時間: {end_time - start_time:.4f}秒")

# 良い例：len()の結果を変数に格納
start_time = time.time()
sum_good = 0
length = len(big_list)
for i in range(length):
    sum_good += big_list[i]
end_time = time.time()
print(f"良い例の実行時間: {end_time - start_time:.4f}秒")

# もっと良い例：Pythonのイテレーションを活用
start_time = time.time()
sum_best = sum(big_list)
end_time = time.time()
print(f"最良の例の実行時間: {end_time - start_time:.4f}秒")

悪い例の実行時間: 1.5632秒
良い例の実行時間: 1.4821秒
最良の例の実行時間: 0.1253秒

# 文字列のリスト
words = ["Python", "プログラミング", "データサイエンス", "AI", "機械学習"]

# 最長の単語を見つける
longest_word = max(words, key=len)
print(f"最長の単語: {longest_word}")

# 最短の単語を見つける
shortest_word = min(words, key=len)
print(f"最短の単語: {shortest_word}")

# 単語の長さでソート
sorted_words = sorted(words, key=len)
print("長さでソートした単語:", sorted_words)

# 単語の長さの合計を計算
total_length = sum(map(len, words))
print(f"全単語の長さの合計: {total_length}")

最長の単語: プログラミング
最短の単語: AI
長さでソートした単語: ['AI', 'Python', '機械学習', 'データサイエンス', 'プログラミング']
全単語の長さの合計: 31

number = 12345
try:
    length = len(number)
except TypeError as e:
    print(f"エラー: {e}")

# 対処法：文字列に変換してから長さを取得
length = len(str(number))
print(f"数字の桁数: {length}")

エラー: object of type 'int' has no len()
数字の桁数: 5

def get_data():
    # データを取得する処理（ここでは簡略化のためNoneを返す）
    return None

data = get_data()

try:
    length = len(data)
except AttributeError as e:
    print(f"エラー: {e}")

# 対処法：Noneチェックを行う
if data is not None:
    length = len(data)
    print(f"データの長さ: {length}")
else:
    print("データがありません")

エラー: 'NoneType' object has no len()
データがありません

# 正しい使用例と誤った使用例を示す
valid_objects = [
    "Hello",  # 文字列
    b"Hello",  # バイト列
    (1, 2, 3),  # タプル
    [1, 2, 3],  # リスト
    {1, 2, 3},  # セット
    {"a": 1, "b": 2}  # 辞書
]

invalid_objects = [
    42,  # 整数
    3.14,  # 浮動小数点数
    True,  # ブール値
    len  # 関数オブジェクト
]

print("正しい使用例:")
for obj in valid_objects:
    print(f"type: {type(obj).__name__}, len: {len(obj)}")

print("\n誤った使用例:")
for obj in invalid_objects:
    try:
        length = len(obj)
    except TypeError as e:
        print(f"type: {type(obj).__name__}, エラー: {e}")

正しい使用例:
type: str, len: 5
type: bytes, len: 5
type: tuple, len: 3
type: list, len: 3
type: set, len: 3
type: dict, len: 2

誤った使用例:
type: int, エラー: object of type 'int' has no len()
type: float, エラー: object of type 'float' has no len()
type: bool, エラー: object of type 'bool' has no len()
type: builtin_function_or_method, エラー: object of type 'builtin_function_or_method' has no len()

number = 12345
digit_count = len(str(number))
print(f"{number}の桁数: {digit_count}")

class MyList:
    def __init__(self):
        self.data = []

    def append(self, item):
        self.data.append(item)

    def __len__(self):
        print("__len__メソッドが呼び出されました")
        return len(self.data)

my_list = MyList()
my_list.append(1)
my_list.append(2)
my_list.append(3)

print(f"リストの長さ: {len(my_list)}")

__len__メソッドが呼び出されました
リストの長さ: 3

import time

# 大きなリストを作成
big_list = list(range(10000000))

# len関数の実行時間を計測
start_time = time.time()
length = len(big_list)
end_time = time.time()

print(f"リストの長さ: {length}")
print(f"len関数の実行時間: {end_time - start_time:.8f}秒")

リストの長さ: 10000000
len関数の実行時間: 0.00000095秒

class OptimizedList:
    def __init__(self):
        self.data = []
        self._length = 0  # 長さをキャッシュ

    def append(self, item):
        self.data.append(item)
        self._length += 1  # 要素追加時に長さを更新

    def pop(self):
        if self._length > 0:
            self._length -= 1  # 要素削除時に長さを更新
            return self.data.pop()
        raise IndexError("リストが空です")

    def __len__(self):
        return self._length  # キャッシュした長さを返す

# 性能テスト
import time

optimized_list = OptimizedList()
normal_list = []

# 要素を追加
for i in range(1000000):
    optimized_list.append(i)
    normal_list.append(i)

# OptimizedListのlen関数の実行時間を計測
start_time = time.time()
optimized_length = len(optimized_list)
optimized_time = time.time() - start_time

# 通常のリストのlen関数の実行時間を計測
start_time = time.time()
normal_length = len(normal_list)
normal_time = time.time() - start_time

print(f"OptimizedList長さ: {optimized_length}, 実行時間: {optimized_time:.8f}秒")
print(f"通常のリスト長さ: {normal_length}, 実行時間: {normal_time:.8f}秒")

OptimizedList長さ: 1000000, 実行時間: 0.00000095秒
通常のリスト長さ: 1000000, 実行時間: 0.00000072秒