Si punojnë klasat dhe objektet në Python?

Question

Accepted Answer

Një **klasë** është një skicim për të krijuar **objekte** (instanca) që grumbullojnë të dhëna (atribute) dhe sjellje (metoda). Python OOP është fleksibël dhe ka disa konvenciona të dallueshme, veçanërisht `self` eksplicit.

## Pse kjo është e rëndësishme

Klasat janë si modelon entitete dhe organizon kodin në Python të orientuar në objekte — duke bashkuar të dhënat dhe sjelljen përkatëse, të përdorura gjerësisht në korniza, modelimin e fushës dhe aplikacionet e mëdha.

Përkuptimi i konvencionave të dallueshme të Python — `self` eksplicit, konstruktori `__init__`, atribute të klasës vs instancës, tre llojet e metodave (`instance`/`@classmethod`/`@staticmethod`) dhe konvencionat e privatësisë me nënshkresë — është i domosdoshëm për të shkruar dhe lexuar Python të orientuar në objekte.

Ato ndryshojnë mjaftueshëm nga gjuhët e tjera (self eksplicit, privatësia e bazuar në konventa) saqë dijeninë e tyre mirë parandalon ngatërrimin e zakonshëm.

## Përcaktimi i një klase

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

## Self-i eksplicit

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

Ndryshe nga shumë gjuhë me një `this` implicit, Python kërkon **`self`** si parametri i parë eksplicit i çdo metode instance — ai i referohet instancës në të cilën metoda quhet. Nuk e kaloni atë manualisht; `d.bark()` kalon `d` si `self` automatikisht.

## Atribute të klasës vs atribute të instancës

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

Atributet e klasës ndahen në të gjitha instancat; atributet e instancës (të vendosura përmes `self.x =`) janë për objekt.

## Llojet e metodave

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

## Konvencionat e enkapsulimit

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

Python nuk ka anëtarë të vërtetë privatë — nënshkresat kryesore janë konvencione që sinjalizojnë qëllimin ("mos e preke këtë"), jo zbatim i fortë.