Կարող եք ձեր կոդը փորձարկել այստեղ
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 օբյեկտի կյանքը սահմանափակվում է այդ ֆունկցիայի շրջանակով: Համապատասխանաբար, երբ ֆունկցիան ավարտի իր կատարումը, կկանչվի Անձի օբյեկտի կործանիչը:
Մեկնաբանություն գրելու համար խնդրում ենք մուտք լինել