Կախարդական մեթոդներ

Python-ում կախարդական մեթոդները հատուկ մեթոդներ են, որոնք կարող եք սահմանել՝ ձեր class-ները ֆունկցիոնալ դարձնելու համար: Դրանք նաև հայտնի են որպես dunder մեթոդներ՝ իրենց անուններին նախորդող և հաջորդող կրկնակի __ տակի գծիկների շնորհիվ: Դուք արդեն հանդիպել եք այս մեթոդներից երկուսին` __init__ և __str__: Ահա մեկ պարզ օրինակ.

class Circle:
    def __init__(self, radius):                     # Initialize the object
        self.radius = radius

    def __str__(self):                              # Represent as a string
        return f'Circle with radius {self.radius}'

c = Circle(5)    # Create a Circle object named c
print(c)         # Circle with radius 5

Օրինակում մենք սահմանել ենք երկու կախարդական մեթոդներ.

  • __init__-ը կոնստրուկտորական մեթոդ է, որը կանչում ենք class-ի օբյեկտը ստեղծելու ժամանակ։ Այստեղ այն սահմանում է Circle-ի շառավիղը:

  • __str__-ն սահմանում է, թե ինչպես class-ի օբյեկտը պետք է փոխարկվի տողի, երբ օգտագործվում է այնպիսի համատեքստերում, ինչպիսին է print():

Բայց սրանք միակ կախարդական մեթոդները չեն Python-ում: Կան շատ ուրիշները: Ստորև ներկայացված են մի քանիսը, որոնք թույլ են տալիս մեզ այնպես անել, որ class-ի օբյեկտները կարողանան գումարվել +-ի միջոցով կամ համեմատվել < կամ >-ի միջոցով:

class Circle:
    def __init__(self, radius):                     # Initialize the object
        self.radius = radius

    def __str__(self):                              # Represent as a string
        return f'Circle with radius {self.radius}'

    def __add__(self, other):                       # Add two circles
        return Circle(self.radius + other.radius)   # Return a new circle

    def __lt__(self, other):                        # Less than comparison of two circles
        return self.radius < other.radius           # Compare radiuses

c1 = Circle(5)
c2 = Circle(7)
c3 = c1 + c2     # This would create a new Circle with radius 12
print(c3)        # Circle with radius 12
print(c1 < c2)   # True

Այս դեպքում․

  • __add__-ը թույլ է տալիս մեզ օգտագործել + օպերատորը Circle-ի օբյեկտների վրա: Այն գումարում է շրջանագծերի շառավիղները և վերադարձնում նոր Circle:

  • __lt__ (փոքր քան) թույլ է տալիս համեմատել երկու Circle օբյեկտներ < օպերատորի միջոցով: Այն ստուգում է, թե արդյո՞ք առաջին շրջանագծի շառավիղը փոքր է երկրորդի շառավղից:

Կախարդական մեթոդները մեր Python class-ները դարձնում են ավելի արտահայտիչ և ինտուիտիվ՝ նմանվելով Python-ի ներկառուցված օբյեկտներին:

Հիշեք, որ կարևոր է պահպանել կրկնակի տակի գծիկի անվանումը, քանի որ որոշակի գործողություններ կատարելու համար Python-ի թարգմանիչը փնտրում է այս հատուկ անուններով մեթոդները։ Python-ում առկա բոլոր կախարդական մեթոդների ցանկը կարող եք գտնել՝ հետևելով այս հղմանը։ Ստորև ներկայացված են կախարդական մեթոդներից մի քանիսը.

Կախարդական մեթոդ

Օպերատոր

Նկարագրություն

__eq__

==

Վերադարձնում է True, եթե self-ը հավասար է other-ին:

__lt__

<

Վերադարձնում է True, եթե self-ը փոքր է other-ից:

__le__

<=

Վերադարձնում է True, եթե self-ը փոքր է կամ հավասար other-ին:

__gt__

>

Վերադարձնում է True, եթե self-ը ավելի մեծ է, քան other-ը:

__ge__

>=

Վերադարձնում է True, եթե self-ը մեծ է կամ հավասար other-ին:

__add__(self, other)

+

Իրականացնում է գումարում` + օպերատորի միջոցով:

__sub__(self, other)

-

Իրականացնում է հանում` - օպերատորի միջոցով:

__mul__(self, other)

*

Իրականացնում է բազմապատկում` * օպերատորի միջոցով:

__truediv__(self, other)

/

Իրականացնում է բաժանում` / օպերատորի միջոցով:

__floordiv__(self, other)

//

Իրականացնում է ամբողջ մասի բաժանում` // օպերատորի միջոցով:

__mod__(self, other)

%

Իրականացնում է մոդուլը՝ % օպերատորի միջոցով:

__pow__(self, other)

**

Իրականացնում է աստիճանը՝ ** օպերատորի միջոցով:

__abs__(self)

abs()

Իրականացնում է վարքագիծը՝ ներկառուցված abs() ֆունկցիայի համար:

__round__(self, n)

round()

Իրականացնում է վարքագիծը՝ ներկառուցված round() ֆունկցիայի համար:

__neg__(self)

-

Վերադարձնում է բացասական տարբերակը՝ - օպերատորի միջոցով։

Առաջադրանք․ ստեղծեք Vector class

Ձեզանից պահանջվում է սահմանել class՝ Vector, որը ներկայացնում է x, y և z ատրիբուտներով եռաչափ վեկտոր:

Class-ը պետք է գործարկի հատուկ մեթոդներ՝ __add__, __sub__ և __mul__ վեկտորի գումարման, հանման և կետային արտադրյալի համար համապատասխանաբար:

Սրանցից բացի, դուք պետք է կիրառեք magnitude մեթոդը՝ վեկտորի մեծությունը հաշվարկելու համար:

3d-vector.webp

Պահանջվող մեթոդները.

  • __add__ - Այս մեթոդը պետք է ընդունի մեկ այլ Vector օբյեկտ և վերադարձնի նոր Vector, որը երկու վեկտորների՝ x, y և z բաղադրիչների գումարն է:

  • __sub__ - Այս մեթոդը պետք է ընդունի մեկ այլ Vector օբյեկտ և վերադարձնի նոր Vector, որը երկրորդ վեկտորի՝ x, y և z բաղադրիչներն առաջինից հանելու արդյունք է:

  • __mul__ - Այս մեթոդը պետք է ընդունի մեկ այլ Vector օբյեկտ և վերադարձնի երկու վեկտորների կետային արտադրյալը (որը հաշվարկվում է հետևյալ կերպ՝ .

  • magnitude - Այս մեթոդը պետք է վերադարձնի վեկտորի մեծությունը (երկարությունը), որը հաշվարկվում է հետևյալ կերպ՝.

Մուտք

Ելք

v1 = Vector(1, 2, 3); v2 = Vector(4, 5, 6); v3 = v1 + v2; v4 = v1 - v2; print(v1 * v2); print(v1.magnitude()); v4 = Vector(-3, -3, -3)

32 3.74165

Constraints

Time limit: 2 seconds

Memory limit: 512 MB

Output limit: 1 MB

To check your solution you need to sign in
Sign in to continue