Kuinka luokat ja objektit toimivat Pythonissa?

Question

Accepted Answer

**Luokka** on suunnitelma **objektien** (instanssien) luomiseen, jotka yhdistävät tiedot (attribuutit) ja käyttäytymisen (metodit). Pythonin OOP on joustava ja sillä on joitakin erityisiä käytäntöjä, erityisesti eksplisiittinen `self`.

## Luokan määrittäminen

```python
class Dog:
    species = "Canis familiaris"     # CLASS attribute (shared by all instances)

def __init__(self, name, age):   # the constructor — runs on creation
        self.name = name              # INSTANCE attributes (per object)
        self.age = age

def bark(self):                   # a method — `self` is the instance
        return f"{self.name} says woof"

d = Dog("Rex", 3)        # create an instance (calls __init__)
d.name                   # "Rex"
d.bark()                 # "Rex says woof"
```

## Eksplisiittinen self

```python
def bark(self):          # `self` is ALWAYS the first parameter of a method
    return self.name      # access instance data through self
```

Toisin kuin monissa kielissä, joissa on implisiittinen `this`, Python vaatii **`self`**:n näkyvänä ensimmäisenä parametrina jokaisessa ilmentymän metodissa — se viittaa ilmentymään, johon metodia kutsutaan. Et välitä sitä manuaalisesti; `d.bark()` välittää `d`:n `self`iksi automaattisesti.

## Luokan attribuutit verrattuna ilmentymän attribuutteihin

```python
Dog.species          # "Canis familiaris" — shared by all dogs
d.species            # also accessible from an instance
d.name               # "Rex" — unique to this instance
```

Luokan attribuutit jaetaan kaikkien ilmentymien kesken; ilmentymän attribuutit (asetettu `self.x =` kautta) ovat objektikohtaisia.

## Metodin tyypit

```python
class Circle:
    def area(self): ...                    # instance method — needs self

@classmethod
    def from_diameter(cls, d):             # class method — receives the CLASS (cls)
        return cls(d / 2)                   # often used as alternative constructors

@staticmethod
    def pi(): return 3.14159               # static — no self/cls, just namespaced
```

## Kapseloinnin käytäntöjä

```python
self.public                # public
self._protected            # "internal use" by convention (not enforced)
self.__private             # name-mangled to _ClassName__private (stronger hiding)
```

Pythonissa ei ole todella yksityisiä jäseniä — johtavat alaviivat ovat käytäntöjä, jotka ilmaisevat tarkoitusta ("älä kosketa tätä"), ei kovaa täytäntöönpanoa.

## Miksi sillä on merkitystä

Luokat ovat tapa, jolla mallinnatte entiteetin ja järjestätte koodia olio-orientoidussa Pythonissa — yhdistämällä toisiinsa liittyviä tietoja ja käyttäytymistä, joita käytetään laajalti kehyksissä, domain-mallinnuksessa ja suurissa sovelluksissa.

Ymmärtäminen Pythonin erityisistä käytäntöistä — eksplisiittinen `self`, `__init__`-konstruktori, luokan attribuutit verrattuna ilmentymän attribuutteihin, kolme metodityyppiä (`instance`/`@classmethod`/`@staticmethod`) ja alaviivan yksityisyysperiaatteet — on olennaista olio-orientoidun Pythonin kirjoittamiseen ja lukemiseen.

Nämä poikkeavat tarpeeksi muista kielistä (eksplisiittinen self, käytäntöpohjainen yksityisyys), joten niiden hyvä tuntemus estää yleisiä sekaannuksia.