Conas a oibríonn ranganna agus réada i Python?

Question

Accepted Answer

Is **rang** blueprint a bhíonn ann chun **réada** (cásanna) a chruthú agus a dhruideann siad sonraí (tréithe) agus iompar (modhanna) le chéile. Tá OOP Python solúbtha agus tá roinnt gnáthchleachtaí ar leith aici, go háirithe an `self` follasach.

## Rang a shainmhíniú

```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"
```

## An self follasach

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

Murab ionann agus go leor teangacha eile le `this` intuigthe, éilíonn Python **`self`** mar an chéad pharaiméadar follasach de gach modh cás — tagann sé ar an chás ar a dtugtar an modh air. Ní thugann tú go láimhseach é; cuireann `d.bark()` `d` ar `self` go huathoibríoch.

## Tréithe ranga vs tréithe cáis

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

Roinntear tréithe ranga ar fud gach cás; is de-réad a bhíonn tréithe cáis (socraithe trí `self.x =`) agus is le gach réad amháin iad.

## Cineálacha modhanna

```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
```

## Gnáthchleachtaí imfholúnta

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

Nilimid fíorbhall príobháideach ag Python — is gnáthchleachtaí iad fochuimhne tosaigh ag soláthar rúin ("ná bain do dhroim go fóill"), ní éafóir dhrochdheisceartúil.

## Cén fáth is fiúntach

Is é an bealach a shamhlaítear entití agus a eagraítear cód i Python ábhardhírithe iad ranganna — sonraí agus iompar ar bhaile a dhruideann, agus is iad is úsáidtear go fairsing i bhfhoghlareachtáinn, múnlúchán fearainn, agus faidhbanna mór.

Tá tuiscint ag gach duine ar na gnáthchleachtaí ar leith Python — an `self` follasach, tógálaí `__init__`, tréithe ranga vs tréithe cáis, na trí chineál modhanna (`instance`/`@classmethod`/`@staticmethod`), agus na gnáthchleachtaí príobháideachta underline — i riachtanais dhíreach do chód agus léamh réada Python-dírithe.

Tá difríochtaí sách fairsing ó theangacha eile orthu seo (self follasach, príobháideacht-bhunaithe-ar-ghnáthchleacht) agus má bhraistear iad go maith bíonn mearbhall coiteann á dhíbirt.