Pythonにおけるキャメルケースの特徴と使い方・実践例8選

●Pythonのキャメルケースとは？
- ○キャメルケースの特徴と利点
- ○Pythonでの使用例と注意点
●Pythonキャメルケースの基本ルール
●実践例8選でPythonでキャメルケースを使いこなそう
●キャメルケースvsスネークケース
- ○PEP 8ガイドラインとの整合性
- ○可読性と保守性の観点から
●よくあるキャメルケースのミスと対処法
●Pythonキャメルケースの応用テクニック
●プロも実践！キャメルケースで可読性を高める5つのコツ
まとめ

●Pythonのキャメルケースとは？

プログラミングで重要な役割を果たす命名規則。

その中でも注目を集めているのがキャメルケースです。

Pythonを学び始めた方々にとって、キャメルケースは馴染みが薄いかもしれません。でも、心配する必要はありません。

この記事を読めば、キャメルケースの魅力と重要性がきっと分かるはずです。

キャメルケースとは、複数の単語を連結して一つの識別子を作る際に用いられる命名規則です。

単語の境目を大文字で表現するため、ラクダ（キャメル）のこぶのように見えることからこの名前が付きました。

例えば、「hello world」という二つの単語をキャメルケースで表現すると「helloWorld」となります。

○キャメルケースの特徴と利点

キャメルケースは、可読性と簡潔さを兼ね備えた命名規則です。

その特徴は次の通りです。

単語の区切りが一目で分かる
スペースを使わずに複数の単語を結合できる
短く簡潔な識別子を作成できる

キャメルケースを使用することで、コードの可読性が格段に向上します。

長い名前の変数や関数でも、一目で内容を理解できるようになります。

また、タイピング量も減少するため、コーディング効率も上がります。

○Pythonでの使用例と注意点

Pythonでは、クラス名にキャメルケースを使用するのが一般的です。

例えば、「UserAccount」や「DataProcessor」といった具合です。

一方で、関数名や変数名には通常スネークケース（単語をアンダースコアで区切る方法）を使用します。

class UserAccount:
    def __init__(self, username):
        self.username = username

    def get_account_info(self):
        return f"ユーザー名: {self.username}"

user_account = UserAccount("python_lover")
print(user_account.get_account_info())

出力結果

ユーザー名: python_lover

Pythonでキャメルケースを使用する際は、PEP 8（Pythonのコーディング規約）に従うことが重要です。

クラス名以外でキャメルケースを使用すると、コードの一貫性が損なわれる可能性があります。チーム開発では特に注意が必要です。

●Pythonキャメルケースの基本ルール

キャメルケースを使いこなすには、いくつかの基本ルールを押さえておく必要があります。

ここでは、大文字と小文字の使い分け方、複合語の結合テクニック、そして数字や記号の扱い方について詳しく見ていきましょう。

○大文字小文字の使い分け方

キャメルケースには、「ローワーキャメルケース」と「アッパーキャメルケース」の2種類があります。

ローワーキャメルケース（lowerCamelCase）
最初の単語は小文字で始まり、それ以降の単語の先頭を大文字にします。
例：firstName, lastName, emailAddress
アッパーキャメルケース（UpperCamelCase）
全ての単語の先頭を大文字にします。これは「パスカルケース」とも呼ばれます。
例：FirstName, LastName, EmailAddress

Pythonでは、クラス名にアッパーキャメルケースを使用するのが一般的です。

メソッド名や変数名には通常スネークケースを使いますが、他の言語からの移植やライブラリの使用時にローワーキャメルケースを見かけることもあります。

class PersonalInfo:
    def __init__(self, first_name, last_name):
        self.firstName = first_name  # ローワーキャメルケース
        self.lastName = last_name    # ローワーキャメルケース

    def getFullName(self):  # メソッド名もローワーキャメルケース（ただしPythonの慣習では推奨されません）
        return f"{self.firstName} {self.lastName}"

person = PersonalInfo("太郎", "山田")
print(person.getFullName())

出力結果

太郎 山田

○複合語の結合テクニック

複合語を結合する際は、各単語の意味が明確に伝わるように注意しましょう。

長すぎる名前は避け、かといって省略しすぎて意味が分からなくなるのも問題です。

明確で簡潔な単語を選ぶ
例：userInputString （良い） vs inputStr （あまり良くない）
一般的な略語は許容する
例：htmlParser （OK） vs hyperTextMarkupLanguageParser （長すぎ）
数字を含む場合は、単語の後ろに付ける
例：column1Width （良い） vs 1ColumnWidth （良くない）

class HtmlParser:
    def __init__(self):
        self.parseResult = None

    def parseDocument(self, htmlString):
        # HTMLの解析処理（ここでは省略）
        self.parseResult = "解析結果"
        return self.parseResult

parser = HtmlParser()
result = parser.parseDocument("<html><body>Hello, World!</body></html>")
print(result)

出力結果

解析結果

○数字や記号の扱い方

キャメルケースで数字や記号を使用する場合、いくつかルールがあります。

数字は単語の後ろに付ける
例：section1, column2Width
アンダースコアは通常使用しない
例：firstName （良い） vs first_Name （良くない）
特殊文字（$, @など）は避ける
例：userEmail （良い） vs user$Email （良くない）
頭字語（略語）は大文字のままにする
例：parseHTML, getXMLHttpRequest

class DataProcessor:
    def __init__(self):
        self.section1Data = None
        self.section2Data = None

    def processXMLData(self, xmlString):
        # XML処理のロジック（ここでは省略）
        return "XML処理結果"

    def processJSONData(self, jsonString):
        # JSON処理のロジック（ここでは省略）
        return "JSON処理結果"

processor = DataProcessor()
xml_result = processor.processXMLData("<data>サンプル</data>")
json_result = processor.processJSONData('{"key": "値"}')
print(f"XML結果: {xml_result}")
print(f"JSON結果: {json_result}")

出力結果

XML結果: XML処理結果
JSON結果: JSON処理結果

キャメルケースの基本ルールを押さえることで、コードの可読性と一貫性が大幅に向上します。

ただし、Pythonでは関数名や変数名にスネークケースを使用するのが一般的なので、チームの規約やプロジェクトの方針に従うことが重要です。

キャメルケースを適切に使いこなすことで、より洗練されたPythonコードを書くことができるでしょう。

●実践例8選でPythonでキャメルケースを使いこなそう

キャメルケースの基本ルールを理解したところで、実際のPythonコードでどのように活用されているか見ていきましょう。

8つの実践例を通じて、キャメルケースの使い方をマスターしていきます。

各例では、コードとその説明、そして実行結果を丁寧に解説していきます。

○サンプルコード1：変数名のキャメルケース

変数名にキャメルケースを使用する場合、通常はローワーキャメルケースを採用します。

ただし、Pythonでは一般的にスネークケースが推奨されるため、特別な理由がない限りはスネークケースを使用するのがよいでしょう。

# キャメルケースを使用した変数名の例
firstName = "太郎"
lastName = "山田"
fullName = firstName + " " + lastName

print(f"フルネーム: {fullName}")

実行結果

フルネーム: 太郎 山田

変数名にキャメルケースを使用すると、単語の区切りが一目で分かりやすくなります。

ただし、Pythonのコーディング規約であるPEP 8では、変数名にはスネークケースの使用が推奨されています。

チーム開発では、一貫性を保つためにスネークケースを使用することが多いでしょう。

○サンプルコード2：関数名のキャメルケース

関数名にもローワーキャメルケースを使用することができます。

ただし、Pythonの慣習では関数名にもスネークケースが推奨されています。

def calculateArea(width, height):
    return width * height

rectangleArea = calculateArea(5, 3)
print(f"長方形の面積: {rectangleArea}")

実行結果

長方形の面積: 15

関数名にキャメルケースを使用すると、関数の目的が明確になります。

calculateAreaという名前から、面積を計算する関数であることが一目で分かります。

ただし、Pythonのコミュニティではcalculate_areaのようなスネークケースが一般的です。

○サンプルコード3：クラス名のキャメルケース

クラス名には、アッパーキャメルケース（パスカルケース）を使用するのが一般的です。

大文字で始まることで、クラスであることが一目で分かります。

class BankAccount:
    def __init__(self, accountNumber, balance):
        self.accountNumber = accountNumber
        self.balance = balance

    def getBalance(self):
        return self.balance

myAccount = BankAccount("1234567890", 10000)
print(f"口座残高: {myAccount.getBalance()}円")

実行結果

口座残高: 10000円

クラス名にアッパーキャメルケースを使用すると、コード内でクラスを簡単に識別できます。

BankAccountというクラス名から、銀行口座を表すクラスであることが明確です。

○サンプルコード4：メソッド名のキャメルケース

クラス内のメソッド名にもローワーキャメルケースを使用できますが、Pythonではスネークケースが推奨されています。

class ShapeCalculator:
    def calculateCircleArea(self, radius):
        return 3.14 * radius ** 2

    def calculateRectangleArea(self, width, height):
        return width * height

calculator = ShapeCalculator()
circleArea = calculator.calculateCircleArea(5)
rectangleArea = calculator.calculateRectangleArea(4, 6)

print(f"円の面積: {circleArea}")
print(f"長方形の面積: {rectangleArea}")

実行結果

円の面積: 78.5
長方形の面積: 24

メソッド名にキャメルケースを使用すると、メソッドの機能が明確になります。

ただし、Pythonの慣習に従うならcalculate_circle_areaのようなスネークケースを使用するのがよいでしょう。

○サンプルコード5：定数名のキャメルケース

定数名には通常、すべて大文字のスネークケースを使用しますが、キャメルケースを使用する場合もあります。

class MathConstants:
    Pi = 3.14159
    GoldenRatio = 1.61803

print(f"円周率: {MathConstants.Pi}")
print(f"黄金比: {MathConstants.GoldenRatio}")

実行結果

円周率: 3.14159
黄金比: 1.61803

定数名にキャメルケースを使用する場合、アッパーキャメルケースを採用することが多いです。

ただし、Pythonでは定数名に大文字のスネークケース（例: PI、GOLDEN_RATIO）を使用するのが一般的です。

○サンプルコード6：モジュール名のキャメルケース

モジュール名にキャメルケースを使用することはあまり一般的ではありませんが、可能です。

ただし、Pythonでは小文字のスネークケースが推奨されています。

# ファイル名: MathUtils.py
def addNumbers(a, b):
    return a + b

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

# 別のファイルでモジュールを使用する場合
import MathUtils

result = MathUtils.addNumbers(5, 3)
print(f"加算結果: {result}")

実行結果

加算結果: 8

モジュール名にキャメルケースを使用すると、モジュールの目的が明確になります。

ただし、Pythonの慣習ではmath_utils.pyのような小文字のスネークケースが推奨されています。

○サンプルコード7：パッケージ名のキャメルケース

パッケージ名にもキャメルケースを使用できますが、Pythonでは小文字のスネークケースが推奨されています。

MyProject/
    DataProcessing/
        __init__.py
        FileReader.py
        DataCleaner.py
    Analysis/
        __init__.py
        StatisticalAnalysis.py
        Visualization.py

パッケージ構造の例を紹介しました。

キャメルケースを使用すると、各パッケージやモジュールの役割が明確になります。

ただし、Pythonの慣習ではdata_processingやfile_reader.pyのように、小文字のスネークケースを使用するのが一般的です。

○サンプルコード8：テスト関数名のキャメルケース

テスト関数名にキャメルケースを使用することもできますが、Pythonではスネークケースが推奨されています。

import unittest

class TestStringMethods(unittest.TestCase):
    def testUpperCase(self):
        self.assertEqual('foo'.upper(), 'FOO')

    def testIsupper(self):
        self.assertTrue('FOO'.isupper())
        self.assertFalse('Foo'.isupper())

if __name__ == '__main__':
    unittest.main()

実行結果

..
----------------------------------------------------------------------
Ran 2 tests in 0.001s

OK

テスト関数名にキャメルケースを使用すると、テストの目的が明確になります。

ただし、Pythonのユニットテストフレームワークではtest_upper_caseのようなスネークケースが一般的です。

●キャメルケースvsスネークケース

Pythonでは、命名規則をめぐって熱い議論が繰り広げられることがあります。

特に注目を集めるのが、キャメルケースとスネークケースの対決です。

両者には一長一短があり、状況に応じて使い分けることが重要です。

ここでは、両者の特徴を比較し、Pythonにおけるベストプラクティスを探ってみましょう。

○PEP 8ガイドラインとの整合性

PEP 8は、Pythonコードのスタイルガイドとして広く認知されています。

コーディングスタイルの統一を図り、可読性を高めることが目的です。

PEP 8では、変数名や関数名にはスネークケースを推奨しています。

一方、クラス名にはキャメルケース（正確にはパスカルケース）を使用することを勧めています。

例えば、変数名はuser_nameのように、関数名はcalculate_areaのようにスネークケースで書きます。

クラス名はUserAccountのようにキャメルケースで書きます。

# PEP 8に準拠した命名例
user_name = "山田太郎"
def calculate_area(width, height):
    return width * height

class UserAccount:
    def __init__(self, username):
        self.username = username

# 使用例
area = calculate_area(5, 3)
account = UserAccount(user_name)
print(f"面積: {area}, ユーザー名: {account.username}")

実行結果

面積: 15, ユーザー名: 山田太郎

PEP 8に従うことで、他の多くのPythonプログラマーと同じスタイルでコードを書くことができます。

結果として、コードの可読性が向上し、チーム内でのコードレビューもスムーズに進むでしょう。

○可読性と保守性の観点から

可読性と保守性は、プログラミングにおいて非常に重要な要素です。

キャメルケースとスネークケースは、どちらもこの点で長所と短所があります。

キャメルケースの長所

単語の区切りが視覚的に分かりやすい
タイピングが速い（アンダースコアを打つ必要がない）
長い名前でもコンパクトに表現できる

スネークケースの長所

単語の区切りが明確（アンダースコアで区切られている）
大文字と小文字の区別がないため、タイプミスが少ない
Pythonの標準ライブラリや多くのフレームワークで採用されている

実際のコードで比較してみましょう。

# キャメルケース
def calculateTotalPrice(basePrice, taxRate, discountPercentage):
    return basePrice * (1 + taxRate) * (1 - discountPercentage)

# スネークケース
def calculate_total_price(base_price, tax_rate, discount_percentage):
    return base_price * (1 + tax_rate) * (1 - discount_percentage)

# 使用例
camel_result = calculateTotalPrice(1000, 0.1, 0.05)
snake_result = calculate_total_price(1000, 0.1, 0.05)

print(f"キャメルケース結果: {camel_result}")
print(f"スネークケース結果: {snake_result}")

実行結果

キャメルケース結果: 1045.0
スネークケース結果: 1045.0

どちらの方法も結果は同じですが、Pythonコミュニティでは一般的にスネークケースが好まれます。

スネークケースを使用することで、標準ライブラリや他の開発者のコードとの一貫性が保たれ、コードの可読性と保守性が向上します。

●よくあるキャメルケースのミスと対処法

キャメルケースを使用する際、いくつかの一般的なミスが発生することがあります。

ここでは、よくあるミスとその対処法を紹介します。

○大文字小文字の誤用を防ぐコツ

大文字と小文字の使い分けは、キャメルケースの根幹を成す重要な要素です。

しかし、誤って使用してしまうケースが少なくありません。

よくあるミス

クラス名を小文字で始める（例: userAccount）
変数名や関数名を大文字で始める（例: UserName）
略語の扱いを間違える（例: HTMLParser vs HtmlParser）

対処法

クラス名は必ず大文字で始める
変数名や関数名は小文字で始める
略語は2文字の場合は全て大文字、それ以外は先頭のみ大文字にする

# 正しい使用例
class UserAccount:
    def __init__(self, userName):
        self.userName = userName

    def getHTMLContent(self):
        return f"<p>{self.userName}</p>"

# 使用例
user = UserAccount("山田太郎")
html = user.getHTMLContent()
print(html)

実行結果

<p>山田太郎</p>

このように、一貫性のある大文字小文字の使用がコードの可読性を大きく向上させます。

○複合語の区切り方のベストプラクティス

複合語を使う際、単語の区切り方に悩むことがあります。

特に、3つ以上の単語を組み合わせる場合は注意が必要です。

よくあるミス

単語の区切りが不明確（例: getnextpage）
過度に長い名前（例: calculateTotalPriceIncludingTaxAndDiscount）
意味不明な省略（例: gtNxtPg）

ベストプラクティス

各単語の先頭を大文字にして区切りを明確にする
長すぎる名前は避け、必要に応じて分割する
略語は一般的なものを除いて避ける

# 改善前
def getnextpageurl(currentpage, totalpages):
    if currentpage < totalpages:
        return f"page_{currentpage + 1}"
    return None

# 改善後
def getNextPageUrl(currentPage, totalPages):
    if currentPage < totalPages:
        return f"page_{currentPage + 1}"
    return None

# 使用例
url = getNextPageUrl(2, 5)
print(f"次のページURL: {url}")

実行結果

次のページURL: page_3

複合語を適切に区切ることで、コードの意図が明確になり、他の開発者が理解しやすくなります。

また、自分自身が後でコードを見直す際にも役立ちます。

○略語やアクロニムの扱い方

略語やアクロニム（頭字語）の扱いは、キャメルケースを使用する上で悩ましい問題の一つです。

一貫性のない使用は、コードの可読性を損なう原因となります。

一般的なガイドライン

2文字の略語は全て大文字にする（例: IO, DB）
3文字以上の略語は先頭のみ大文字にする（例: Html, Xml）
よく知られた略語以外は、できるだけ使用を避ける

class IOHandler:
    def readXmlFile(self, fileName):
        # ファイル読み込みの処理（省略）
        pass

    def writeJsonData(self, data):
        # JSON書き込みの処理（省略）
        pass

# 使用例
handler = IOHandler()
handler.readXmlFile("data.xml")
handler.writeJsonData({"key": "value"})

このように略語を扱うことで、コードの一貫性が保たれ、可読性が向上します。

ただし、チーム内で合意された規則がある場合は、それに従うことが重要です。

●Pythonキャメルケースの応用テクニック

キャメルケースの基本を押さえたら、次は応用編に進みましょう。

Pythonの高度な機能を使う際にも、キャメルケースは活躍します。

ジェネレータ関数、デコレータ、例外クラス、型ヒントなど、様々な場面でキャメルケースを適切に使うことで、コードの可読性と保守性が向上します。

○サンプルコード9：ジェネレータ関数名のキャメルケース

ジェネレータ関数は、大量のデータを扱う際に非常に便利です。

キャメルケースを使って命名することで、通常の関数との区別がつきやすくなります。

def fibonacciGenerator(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

# 使用例
for num in fibonacciGenerator(10):
    print(num, end=" ")

実行結果

0 1 1 2 3 5 8 13 21 34

fibonacciGeneratorという名前から、フィボナッチ数列を生成するジェネレータ関数であることが一目で分かります。

yieldキーワードを使用することで、メモリ効率の良い実装が可能です。

○サンプルコード10：デコレータ名のキャメルケース

デコレータは、関数やクラスの動作を変更するための強力な機能です。

キャメルケースを使用することで、デコレータであることを明確に表すことができます。

import time

def timeMeasureDecorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__}の実行時間: {end_time - start_time:.4f}秒")
        return result
    return wrapper

@timeMeasureDecorator
def slowFunction():
    time.sleep(2)
    print("処理完了")

# 使用例
slowFunction()

実行結果

処理完了
slowFunctionの実行時間: 2.0017秒

timeMeasureDecoratorという名前から、時間測定を行うデコレータであることが分かります。

デコレータを使用することで、既存の関数に機能を追加する際にコードの重複を避けることができます。

○サンプルコード11：例外クラス名のキャメルケース

例外クラスの名前には、通常アッパーキャメルケース（パスカルケース）を使用します。

クラス名の最後に「Error」や「Exception」を付けるのが一般的です。

class InvalidInputError(Exception):
    def __init__(self, message):
        self.message = message

def validateInput(input_string):
    if not input_string.isalpha():
        raise InvalidInputError("入力は英字のみ許可されています。")
    print("入力は有効です。")

# 使用例
try:
    validateInput("Hello123")
except InvalidInputError as e:
    print(f"エラー: {e.message}")

try:
    validateInput("Hello")
except InvalidInputError as e:
    print(f"エラー: {e.message}")

実行結果

エラー: 入力は英字のみ許可されています。
入力は有効です。

InvalidInputErrorという名前から、無効な入力に関する例外であることが明確です。

カスタム例外を定義することで、エラーハンドリングがより具体的かつ効果的になります。

○サンプルコード12：型ヒントでのキャメルケース

Python 3.5以降で導入された型ヒントでも、キャメルケースを活用できます。

特にカスタム型を定義する際に有効です。

from typing import List, Dict, Union

UserID = int
Username = str
UserData = Dict[str, Union[int, str]]

def getUserInfo(user_id: UserID) -> UserData:
    # ユーザー情報を取得する処理（省略）
    return {"id": user_id, "name": "山田太郎", "age": 30}

def processUsers(users: List[Username]) -> None:
    for user in users:
        print(f"処理中のユーザー: {user}")

# 使用例
user_info = getUserInfo(12345)
print(user_info)

processUsers(["user1", "user2", "user3"])

実行結果

{'id': 12345, 'name': '山田太郎', 'age': 30}
処理中のユーザー: user1
処理中のユーザー: user2
処理中のユーザー: user3

UserID、Username、UserDataなどのカスタム型を定義することで、コードの意図がより明確になります。

型ヒントを使用することで、IDEの支援機能が向上し、バグの早期発見にも役立ちます。

●プロも実践！キャメルケースで可読性を高める5つのコツ

キャメルケースを効果的に使いこなすには、単に規則を覚えるだけでなく、実践的なコツを押さえることが大切です。

ここでは、プロの開発者も実践している5つのコツを紹介します。

○一貫性のある命名規則の適用

プロジェクト全体で一貫した命名規則を適用することが、可読性向上の鍵となります。

例えば、クラス名には必ずアッパーキャメルケースを、メソッド名にはローワーキャメルケースを使用するといった具合です。

class BankAccount:
    def __init__(self, accountNumber, balance):
        self.accountNumber = accountNumber
        self.balance = balance

    def depositMoney(self, amount):
        self.balance += amount

    def withdrawMoney(self, amount):
        if self.balance >= amount:
            self.balance -= amount
            return True
        return False

# 使用例
myAccount = BankAccount("1234567890", 1000)
myAccount.depositMoney(500)
success = myAccount.withdrawMoney(200)
print(f"残高: {myAccount.balance}円, 引き出し成功: {success}")

○適切な単語の選択と組み合わせ

単語の選択と組み合わせは、コードの意図を正確に伝える上で重要です。

抽象的な名前ではなく、具体的で描写的な名前を選びましょう。

# 良い例
def calculateTotalPrice(basePrice, taxRate, discountRate):
    return basePrice * (1 + taxRate) * (1 - discountRate)

# 悪い例
def calc(p, t, d):
    return p * (1 + t) * (1 - d)

# 使用例
total = calculateTotalPrice(1000, 0.1, 0.05)
print(f"合計金額: {total}円")

○略語の使用を最小限に抑える

略語は、コードの可読性を損なう恐れがあります。

一般的に知られている略語以外は、フルネームを使用することをお勧めします。

# 良い例
class HTMLParser:
    def parseDocument(self, document):
        # HTMLのパース処理（省略）
        pass

# 悪い例
class HTMLPrsr:
    def prsDcmnt(self, dcmnt):
        # HTMLのパース処理（省略）
        pass

# 使用例
parser = HTMLParser()
parser.parseDocument("<html><body>Hello, World!</body></html>")

○コンテキストを考慮した命名

変数や関数の名前は、それが使用される文脈（コンテキスト）を考慮して決めましょう。

同じ概念でも、使用される場所によって適切な名前が変わることがあります。

class ShoppingCart:
    def __init__(self):
        self.items = []

    def addItem(self, item):
        self.items.append(item)

    def removeItem(self, item):
        self.items.remove(item)

    def getTotalPrice(self):
        return sum(item.price for item in self.items)

class Item:
    def __init__(self, name, price):
        self.name = name
        self.price = price

# 使用例
cart = ShoppingCart()
cart.addItem(Item("リンゴ", 100))
cart.addItem(Item("バナナ", 80))
print(f"合計金額: {cart.getTotalPrice()}円")

○チーム内でのコーディング規約の統一

チーム開発では、コーディング規約を統一することが不可欠です。

キャメルケースの使用方法についても、チーム内で合意を形成しましょう。

# チーム内規約の例
# 1. クラス名はアッパーキャメルケース
# 2. メソッド名と変数名はローワーキャメルケース
# 3. 定数名は大文字のスネークケース

class UserManager:
    MAX_USERS = 100

    def __init__(self):
        self.userList = []

    def addUser(self, username):
        if len(self.userList) < self.MAX_USERS:
            self.userList.append(username)
            return True
        return False

# 使用例
manager = UserManager()
success = manager.addUser("新しいユーザー")
print(f"ユーザー追加成功: {success}")