Գլուխ 3. Օբյեկտ-կողմնորոշված ծրագրավորում

Կլասներ և օբյեկտներ

Python-ն ունի բազմաթիվ ներկառուցված տեսակներ, ինչպիսիք են int, str և այլն, որոնք մենք կարող ենք օգտագործել ծրագրում: Բայց Python-ը նաև թույլ է տալիս կլասերի միջոցով սահմանել ձեր սեփական տեսակները : Կլասը ներկայացնում է որոշակի էություն: Կլասի կոնկրետ մարմնավորումը օբյեկտ է:

Կարող եք նաև նկարել հետևյալ անալոգիան. Մենք բոլորս որոշակի պատկերացում ունենք մի մարդու մասին, ով ունի անուն, տարիք և որոշ այլ հատկանիշներ: Մարդը կարող է կատարել որոշ գործողություններ՝ քայլել, վազել, մտածել և այլն։ Այսինքն, այս ներկայացումը, որը ներառում է բնութագրերի և գործողությունների մի շարք, կարելի է անվանել կլաս: Այս օրինակի կոնկրետ մարմնավորումը կարող է տարբեր լինել, օրինակ՝ որոշ մարդիկ ունեն մեկ անուն, մյուսները՝ այլ անուն: Իսկ իրական կյանքի մարդը կներկայացնի այս կլասի առարկան:

Python-ում կլասը սահմանվում է՝ օգտագործելով class բանալի բառը՝

class class_name:
    class_properties
    class_methods

կլասի ներսում սահմանվում են նրա ատրիբուտները, որոնք պահպանում են կլասի տարբեր բնութագրերը, իսկ մեթոդները կլասի գործառույթներն են։

Եկեք ստեղծենք ամենապարզ կլասը.

class Person:
    pass

Այս դեպքում սահմանվում է Անձի կլաս, որը պայմանականորեն ներկայացնում է անձին։ Այս դեպքում կլասում ոչ մի մեթոդ կամ հատկանիշ չի սահմանվում: Այնուամենայնիվ, քանի որ դրանում ինչ-որ բան պետք է սահմանվի, pass օպերատորն օգտագործվում է որպես կլասի ֆունկցիոնալության փոխարինող : Այս օպերատորն օգտագործվում է այն դեպքում, երբ շարահյուսորեն անհրաժեշտ է որոշ կոդ սահմանել, բայց առաջադրանքից ելնելով կոդը մեզ պետք չէ, և կոնկրետ կոդի փոխարեն տեղադրում ենք անցումային օպերատորը։

կլաս ստեղծելուց հետո կարող եք սահմանել այդ կլասի օբյեկտները: Օրինակ:

class Person:
    pass

tom = Person()
bob = Person()

Person կլասը սահմանելուց հետո ստեղծվում են Person կլասի երկու օբյեկտ՝ tom և bob։ Օբյեկտ ստեղծելու համար օգտագործվում է հատուկ ֆունկցիա՝ կոնստրուկտոր , որը կոչվում է կլասի անունով և որը վերադարձնում է կլասի օբյեկտը։ Այսինքն, այս դեպքում զանգը Person()ներկայացնում է զանգ կառուցողին: Յուրաքանչյուր կլաս ունի լռելյայն անպարամետր կոնստրուկտոր.

tom = Person()

Կոնստրուկտորներ

Այսպիսով, կոնստրուկտորն օգտագործվում է կլասի օբյեկտ ստեղծելու համար: Այսպիսով, վերևում, երբ մենք ստեղծում էինք Person կլասի օբյեկտներ, մենք օգտագործում էինք լռելյայն կոնստրուկտորը, որը ոչ մի պարամետր չի ընդունում և որը բոլոր կլասերը անուղղակիորեն ունեն: Այնուամենայնիվ, մենք կարող ենք հստակորեն սահմանել կոնստրուկտոր կլասերում՝ օգտագործելով հատուկ մեթոդ, որը կոչվում է __init__() (յուրաքանչյուր կողմում երկու գծիկ): Օրինակ՝ փոխենք Person կլասը՝ դրան ավելացնելով կոնստրուկտոր.

class Person:
    def __init__(self):
        print("Создание объекта Person")

tom = Person()

Այսպիսով, այստեղ Person կլասի կոդում սահմանվում է կոնստրուկտոր՝ __init__ ֆունկցիան : Կոնստրուկտորը պետք է վերցնի առնվազն մեկ պարամետր՝ հղում ընթացիկ օբյեկտին - ինքնակառավարման : Սովորաբար, կոնստրուկտորներն օգտագործվում են որոշելու այն գործողությունները, որոնք պետք է կատարվեն օբյեկտի ստեղծման ժամանակ:

Այժմ օբյեկտ ստեղծելիս.

tom = Person()

Person կլասից զանգ է կատարվում կոնստրուկտորին __init__(), որը վահանակում կտպագրի «Creating a Person object» տողը:

Հարկ է նշել, որ կոնստրուկտորը իրականում ներկայացնում է կանոնավոր ֆունկցիա, __init__կոնստրուկտորը կանչելու համար օգտագործվում է միայն կլասի անվանումը, այլ ոչ թե ։ Բացի այդ, երբ կոնստրուկտորը կանչվում է, ոչ մի արժեք բացահայտորեն չի փոխանցվում ինքնակառավարման պարամետրին: Երբ ծրագիրն աշխատում է, Python-ը դինամիկ կերպով կսահմանի ինքն իրեն:

Օբյեկտի հատկանիշներ

Հատկանիշները պահպանում են օբյեկտի վիճակը: Դուք կարող եք օգտագործել «self» բառը կլասի մեջ ատրիբուտներ սահմանելու և սահմանելու համար : Օրինակ, եկեք սահմանենք հետևյալ Person կլասը.

class Person:

    def __init__(self, name, age):
        self.name = name
        self.age = age


tom = Person("Tom", 22)

print(tom.name)     # Tom
print(tom.age)      # 22
tom.age = 37
print(tom.age)      # 37

Այժմ Person կլասի կոնստրուկտորը վերցնում է ևս երկու պարամետր՝ անուն և տարիք։ Այս պարամետրերի միջոցով ստեղծվող անձի անունը և տարիքը կփոխանցվի կոնստրուկտորին։

Կոնստրուկտորի ներսում դրված է երկու հատկանիշ՝ անուն և տարիք (պայմանականորեն՝ անձի անունն ու տարիքը).

def __init__(self, name, age):
    self.name = name
    self.age = age

self.name հատկանիշին վերագրվում է անուն փոփոխականի արժեքը: Տարիքի հատկանիշը ստանում է տարիքային պարամետրի արժեքը: Հատկանիշների անվանումը պարտադիր չէ, որ համապատասխանի պարամետրերի անվանումներին:

Եթե կլասում սահմանել ենք __init__ կոնստրուկտոր՝ պարամետրերով (բացի self-ից), ապա կոնստրուկտորը կանչելիս այս պարամետրերին պետք է փոխանցվեն արժեքներ.

tom = Person("Tom", 22)

Այսինքն՝ այս դեպքում «Tom» տողը փոխանցվում է անվան պարամետրին, իսկ 22 թիվը՝ տարիքային պարամետրին։

Հաջորդը, օգտագործելով օբյեկտի անունը, մենք կարող ենք մուտք գործել օբյեկտի ատրիբուտներ. ստանալ և փոխել դրանց արժեքները.

print(tom.name)
tom.age = 37

Նմանապես, մենք կարող ենք ստեղծել տարբեր Անձնական օբյեկտներ տարբեր արժեքներով ատրիբուտների համար.

class Person:

    def __init__(self, name, age):
        self.name = name
        self.age = age


tom = Person("Tom", 22)
bob = Person("Bob", 43)

print(tom.name)         # Tom
print(bob.name)         # Bob

Այստեղ ստեղծվում են Person կլասի երկու օբյեկտ՝ tom և bob։ Նրանք համապատասխանում են Person կլասի սահմանմանը, ունեն նույն ատրիբուտների շարքը, բայց նրանց վիճակը տարբեր կլինի: Եվ յուրաքանչյուր դեպքում Python-ը դինամիկ կերպով կսահմանի ինքնաօբյեկտը: Այսպիսով, հաջորդ դեպքում

tom = Person("Tom", 22)

Սա կլինի tom օբյեկտը

Իսկ երբ կանչում են

bob = Person("Bob", 43)

Սա կլինի bob օբյեկտը

Սկզբունքորեն, մենք պետք չէ կլասի ներսում ատրիբուտներ սահմանել. Python-ը մեզ թույլ է տալիս դա դինամիկ կերպով անել կոդից դուրս.

lass Person:

    def __init__(self, name, age):
        self.name = name
        self.age = age


tom = Person("Tom", 22)

tom.company = "Microsoft"
print(tom.company)  # Microsoft

Այստեղ դինամիկ կերպով դրված է ընկերության հատկանիշը, որը պահպանում է անձի աշխատանքի վայրը: Իսկ տեղադրումից հետո կարող ենք ստանալ նաև դրա արժեքը։ Միեւնույն ժամանակ, նման սահմանումը հղի է սխալներով: Օրինակ, եթե մենք փորձենք մուտք գործել հատկանիշ նախքան այն սահմանելը, ծրագիրը կստեղծի սխալ.

tom = Person("Tom", 22)
print(tom.company)

կլասի մեթոդներ

կլասի մեթոդները իրականում ներկայացնում են գործառույթներ, որոնք սահմանված են կլասի ներսում և սահմանում են նրա վարքագիծը: Օրինակ, եկեք սահմանենք Person կլասը մեկ մեթոդով.

class Person:
     def say_hello(self):
        print("Hello")

tom = Person()
tom.say_hello()    # Hello

Այստեղ սահմանվում է մի մեթոդ say_hello(), որը պայմանականորեն կատարում է ողջույնի խոսքը՝ լարը դուրս է բերում վահանակ: Ցանկացած կլասի մեթոդներ սահմանելիս, ինչպես կոնստրուկտորը, մեթոդի առաջին պարամետրը ներկայացնում է հղում ընթացիկ օբյեկտին, որը պայմանականորեն կոչվում է ինքնակառավարում : կլասի ներսում այս հղումի միջոցով մենք կարող ենք մուտք գործել ընթացիկ օբյեկտի ֆունկցիոնալությունը: Բայց մեթոդն ինքնին կանչելիս այս պարամետրը հաշվի չի առնվում:

Օգտագործելով օբյեկտի անունը, մենք կարող ենք մուտք գործել դրա մեթոդները: Մեթոդներ մուտք գործելու համար օգտագործվում է կետային նշում. կետը տեղադրվում է օբյեկտի անունից հետո և հաջորդում մեթոդի կանչը.

object.method([params])

Օրինակ՝ զանգահարեք մեթոդ՝ say_hello()վահանակին ողջույնի խոսքեր տպելու համար.

tom.say_hello() # Hello

Արդյունքում, այս ծրագիրը կտպագրի «Hello» տողը վահանակի վրա:

Եթե մեթոդը պետք է ընդունի այլ պարամետրեր, ապա դրանք սահմանվում են պարամետրից հետո self, և նմանատիպ մեթոդ կանչելիս դրանց համար պետք է փոխանցվեն արժեքներ.

class Person:
    def say(self, message):
        print(message)

tom = Person()
tom.say("Hello LearnProgramming")

Մեթոդը սահմանվում է այստեղ say(): Այն պահանջում է երկու պարամետր՝ ինքնակառավարման և հաղորդագրություն: Իսկ երկրորդ պարամետրի համար՝ հաղորդագրություն, մեթոդը կանչելիս պետք է արժեք փոխանցել։

կլասի մեջ օբյեկտի ատրիբուտներին և մեթոդներին մուտք գործելու համար իր մեթոդներում օգտագործվում է նաև «self» բառը.

self.property
self.method

Օրինակ՝ Անձի հետևյալ կլասը.

class Person:

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def display_info(self):
        print(f"Name: {self.name}  Age: {self.age}")


tom = Person("Tom", 22)
tom.display_info()      # Name: Tom  Age: 22

bob = Person("Bob", 43)
bob.display_info()      # Name: Bob  Age: 43

Սա սահմանում է display_info() մեթոդը, որը տեղեկատվություն է ցուցադրում վահանակին: Իսկ մեթոդի մեջ օբյեկտի ատրիբուտներին մուտք գործելու համար օգտագործվում է «self» բառը՝ self.name և self.age

Արդյունքում մենք կստանանք հետևյալ վահանակի ելքը.

Name՝ Tom Age՝ 22
Name՝ Bob Age՝ 43

Դեստրուկտորներ

Բացի կոնստրուկտորներից, Python-ի կլասերը կարող են սահմանել նաև հատուկ մեթոդներ՝ destructors , որոնք կանչվում են, երբ օբյեկտը ջնջվում է։ Destructor-ը __del__(self) մեթոդ է , որը, ինչպես կոնստրուկտորը, փոխանցվում է ընթացիկ օբյեկտին հղում: Դեստրուկտորը սահմանում է այն գործողությունները, որոնք պետք է կատարվեն, երբ օբյեկտը ջնջվում է, օրինակ՝ ազատելով կամ ջնջելով որոշ ռեսուրսներ, որոնք օգտագործում էր օբյեկտը:

Դեստրուկտորը ավտոմատ կերպով կանչվում է թարգմանչի կողմից, մենք կարիք չունենք այն հստակ անվանել: Ամենապարզ օրինակը.

class Person:

    def __init__(self, name):
        self.name = name
        print("Ստեղծվել է", self.name)

    def __del__(self):
        print("Ջնջվել է", self.name)

tom = Person("Tom")

Այստեղ կործանիչը պարզապես կցուցադրի ծանուցում այն մասին, որ Անձի օբյեկտը ջնջվել է: Ծրագիրը ստեղծում է մեկ Անձի օբյեկտ և պահպանում է հղումը tom փոփոխականում: Օբյեկտ ստեղծելը կհանգեցնի կոնստրուկտորի կատարմանը: Երբ ծրագիրը դուրս է գալիս, tom օբյեկտի կործանիչը ավտոմատ կերպով կկատարվի: Արդյունքում, ծրագրի վահանակի ելքը կլինի հետևյալը.

Ստեղծվել է
Ջնջվել է

Մեկ այլ օրինակ.

class Person:

    def __init__(self, name):
        self.name = name
        print("Ստեղծվել է", self.name)

    def __del__(self):
        print("Ջնջվել է", self.name)


def create_person():
    tom = Person("Tom")

create_person()
print("Конец программы")

Այստեղ Person օբյեկտը ստեղծվում և օգտագործվում է create_person ֆունկցիայի շրջանակներում, ուստի ստեղծված Person օբյեկտի կյանքը սահմանափակվում է այդ ֆունկցիայի շրջանակով: Համապատասխանաբար, երբ ֆունկցիան ավարտի իր կատարումը, կկանչվի Անձի օբյեկտի կործանիչը:

Python

Գլուխ 3. Օբյեկտ-կողմնորոշված ծրագրավորում

Կլասներ և օբյեկտներ

Արագ հղում

Կապ

Պատկերասրահ