Python初学者疑问：property的fget方法作用解析及property常见应用示例

我是一名Python初学者，在理解property（属性）的用法时遇到了困惑。参考代码如下：

class Weapon:
    def __init__(self, name, damages, sell_price):
        self.name = name
        self.damages = damages
        self.sell_price = sell_price

class Player:
    def __init__(self, name, level=1, golds=5, HP=100, MP=100, EXP=0, weapon=Weapon("Epee en bois", 32, 1)):
        self._name = name
        self.level = level
        self.golds = golds
        self.HP = HP
        self.maxHP = HP
        self.MP = MP
        self.maxMP = MP
        self.EXP = EXP
        self.next_level_EXP = 100
        self.weapon = weapon

    def get_name(self):
        return self._name

    def set_name(self, name):
        if len(name) > 16:
            raise Exception("name should have less than 16 character.")
        self._name = name
        print("your name is changed to: -> {}".format(self.name))

name = property(fget=get_name, fset=set_name)

ask_player_name = True
while ask_player_name:
    try:
        player_name = input("Choisir un nom (16 caracteres max.) : ")
        hero.name = player_name
        ask_player_name = False
    except Exception as message:
        print(message)

我理解上述代码中set_name方法的作用是限制玩家名称长度不超过16个字符，但完全无法理解get_name方法的意义，感觉它似乎没有实际作用。恳请解释property中fget参数对应的get方法的作用，并提供property的常见应用场景示例。

Great question! At first glance, that get_name method feels totally unnecessary—why not just access hero._name directly? But that misses the core point of using property in Python. Let's break down why the fget (getter) matters:

Why We Need the get_name Method (the fget Parameter) #

1. Encapsulation & Interface Consistency
   The underscore in _name is a Python convention that signals "this is a private internal variable—don't touch it directly". By using a getter, you provide a stable, public interface (hero.name) for accessing the name. Later, if you need to modify how the name is returned (say, add a title like "Hero: " or normalize all letters to uppercase), you can update the get_name method without changing any code that uses hero.name.

2. Hiding Implementation Details
   _name is just how you're storing the name right now. If you later decide to store it in a dictionary (like self.data["name"]) or fetch it from a cache, the getter lets you abstract that change away. Any code using hero.name will keep working, no tweaks required.

3. The Property Contract
   A property is meant to behave like a regular attribute but with custom logic. If you only define a setter (fset) without a getter (fget), you can write to the property but not read it—which would break your existing code! In your example, the line print("your name is changed to: -> {}".format(self.name)) would throw an error if there was no getter.

Common Use Cases for property #

Let's walk through practical examples where property adds real value:

1. Input Validation (Your Name Example, Cleaned Up) #

This is the use case you already saw—using a setter to enforce rules before assigning a value. Here's the more modern decorator-based syntax for this:

class Player:
    def __init__(self, name):
        self._name = name

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        if len(value) > 16:
            raise ValueError("Name must be 16 characters or less.")
        self._name = value
        print(f"Your name has been updated to: {self.name}")

2. Computed Attributes #

Sometimes you want an attribute that's calculated on the fly instead of stored. For example, calculating a player's total damage based on their level and weapon:

class Player:
    def __init__(self, level, weapon_damage):
        self.level = level
        self.weapon_damage = weapon_damage

    @property
    def total_damage(self):
        # Total damage = weapon damage × level scaling factor
        return self.weapon_damage * (1 + self.level * 0.1)

# Usage
hero = Player(5, 32)
print(hero.total_damage)  # Output: 48.0
hero.level = 10
print(hero.total_damage)  # Output: 57.6

You can't assign to total_damage here (no setter defined), but it acts like a regular attribute when you read it.

3. Lazy Loading #

For expensive operations (like fetching data from a database), use a getter to load the value only when it's first accessed:

class Player:
    def __init__(self, player_id):
        self.player_id = player_id
        self._inventory = None  # Not loaded yet

    @property
    def inventory(self):
        if self._inventory is None:
            # Simulate fetching inventory from a database
            print("Loading inventory from database...")
            self._inventory = ["Potion", "Iron Sword", "Shield"]
        return self._inventory

# Usage
hero = Player(123)
print(hero.inventory)  # Prints loading message + inventory
print(hero.inventory)  # Uses cached value, no loading message

4. Read-Only Attributes #

If you want an attribute that can't be modified after initialization, define a getter without a setter:

class Player:
    def __init__(self, player_id):
        self._player_id = player_id

    @property
    def player_id(self):
        return self._player_id

# Usage
hero = Player(123)
print(hero.player_id)  # 123
hero.player_id = 456  # Raises AttributeError: can't set attribute

内容的提问来源于stack exchange，提问作者adel shabez