Փոփոխական ֆունկցիայի արգումենտներ

Python-ն ունի տվյալների մի շարք տեսակներ: Դրանցից որոշներն ստեղծումից հետո կարող են փոփոխվել, իսկ մյուսները՝ ոչ: Այն տեսակները, որոնք կարող են փոփոխվել, կոչվում են "mutable", մինչդեռ փոփոխման չենթարկվողները կոչվում են "immutable" տեսակներ։

Փոփոխական (mutable) տեսակներ

Ամենատարածված փոփոխվող տեսակներն են list-երը, dict-երը և set-երը: Ահա list-ի օրինակ.
fruits = ['apple', 'banana', 'cherry']
print(fruits, type(fruits))  # ['apple', 'banana', 'cherry'] <class 'list'>
Զանգվածի մեջ կարող եք փոխել դրա տարրերը, ավելացնել նորերը կամ հեռացնել գոյություն ունեցողները.
fruits[1] = 'blueberry'       # Change 'banana' to 'blueberry'
fruits.append('dragonfruit')  # Add 'dragonfruit' to the end of the list
print(fruits)                 # ['apple', 'blueberry', 'cherry', 'dragonfruit']

Անփոփոխ (immutable) տեսակներ

Անփոփոխ տեսակների օրինակներ են int-երը, float-երը, string-երը և tuple-ները: Ստեղծելուց հետո դուք չեք կարող փոխել դրանց պարունակությունը: Ահա string-ի օրինակ.
message = 'hello'
print(message, type(message))  # hello <class 'str'>
Եթե փորձեք փոխել տողի (string) մի մասը, Python-ը դա թույլ չի տա.
message[0] = 'H'  # Trying to change 'h' to 'H' will give you a TypeError
Ինչպե՞ս է ստացվում, որ int-ն անփոփոխ է: Չե՞նք կարող փոխել արժեքը += կամ -=-ով:
Երբ խոսում ենք Python-ում փոփոխականության մասին, նկատի ունենք, որ հիշողության մեջ պահվող իրական արժեքը կարող է փոփոխվել: Օրինակ, երբ ունենք զանգված, կարող ենք փոխել որևէ տարր, և այն ծրագրի հիշողության մեջ կմնա նույն զանգվածը:
Python-ում ամբողջ թվերն անփոփոխ են: Սա նշանակում է, որ հիշողության մեջ պահվող արժեքը չի կարող փոխվել: Եթե ունենք ամբողջ թիվ՝ a = 5, և կատարում ենք += 2-ի նման գործողություն, կարող է թվալ, թե մենք փոխեցինք a-ն: Սակայն Python-ն իրականում հիշողության մեջ ստեղծում է նոր օբյեկտ՝ 7 արժեքով, և թարմացնում է a-ն՝ այս նոր օբյեկտին մատնանշելու համար: Սկզբնական 5-ը չի փոխվել հիշողության մեջ, այդ իսկ պատճառով int-երը համարվում են անփոփոխ:
a = 5
print(id(a))  # This prints the memory location of a. Let's say it's 1001

a += 2
print(a)      # This prints 7
print(id(a))  # This will print a different memory location, let's say 1002
Python-ում id ֆունկցիան վերադարձնում է օբյեկտի իդենտիֆիկատորը, որն այդ օբյեկտի համար եզակի է և հաստատուն: Այսպիսով, երբ մենք տեսնում ենք, որ a-ի իդենտիֆիկատորը փոխվել է a += 2 գործողությունից հետո, դա հստակ նշան է, որ a-ն հիմա ցույց է տալիս հիշողության մեջ գտնվող նոր օբյեկտ: Բնօրինակ ամբողջ թիվ 5-ը չփոխվեց, ուստի Python-ում ամբողջ թվերն իսկապես անփոփոխ են:

Փոփոխական (mutable) արգումենտները ֆունկցիաներում

Երբ մենք փոփոխվող օբյեկտը (ինչպիսին է զանգվածը) փոխանցում ենք ֆունկցիային, Python-ը ֆունկցիային հղում է տալիս՝ դեպի այդ օբյեկտը: Սա նշանակում է, որ եթե ֆունկցիան փոխում է փոփոխվող օբյեկտը, ապա այդ փոփոխությունը նկատվում է նաև ֆունկցիայից դուրս:
Եկեք օգտագործենք մի ֆունկցիա, որը ստանում է զանգված և դրան նոր տարր է ավելացնում.
def add_item(my_list):
    my_list.append('added item')  # Append a new item to the list

shopping_list = ['apples', 'bananas', 'cherries']
print(shopping_list)  # Prints: ['apples', 'bananas', 'cherries']

# Now we use the function to add an item to our shopping list
add_item(shopping_list)
print(shopping_list)  # Prints: ['apples', 'bananas', 'cherries', 'added item']
Ինչպես տեսնում եք, երբ add_item ֆունկցիան կանչելուց հետո տպում ենք shopping_list-ը, զանգվածում հայտնվում է նոր տարր, թեև մենք ուղղակիորեն չենք փոփոխել shopping_list-ը ֆունկցիայից դուրս:
Սակայն կարևոր է հասկանալ, որ եթե ֆունկցիայի ներսում փոփոխվող ամբողջ օբյեկտին նոր արժեք վերագրեք, դա չի ազդի սկզբնական օբյեկտի վրա: Սա պայմանավորված է նրանով, որ դուք ֆունկցիայի local (տեղային) փոփոխականին տալիս եք նոր հղում՝ չփոփոխելով սկզբնական օբյեկտը: Ահա մեկ օրինակ.
def change_list(my_list):
    my_list = ['entirely', 'new', 'list']  # This won't affect the original list

shopping_list = ['apples', 'bananas', 'cherries']
change_list(shopping_list)
print(shopping_list)  # Still prints: ['apples', 'bananas', 'cherries']
Թեև մենք կանչել ենք change_list ֆունկցիան և փոխանցել shopping_list-ը որպես արգումենտ, shopping_list-ի բովանդակությունը չի փոխվել: Դա պայմանավորված է նրանով, որ ֆունկցիայի ներսում my_list-ին տրվել է նոր հղում (բոլորովին նոր զանգվածի), մինչդեռ shopping_list հղումը մնացել է անփոփոխ:
Երբ Python-ի ֆունկցիային փոփոխվող օբյեկտ եք փոխանցում, հիշեք հետևյալը․ եթե ֆունկցիան փոխում է օբյեկտը (ինչպես, օրինակ, զանգվածում որևէ տարր ավելացնելը), փոփոխությունը երևում է ֆունկցիայից դուրս: Բայց եթե դուք նոր արժեք եք տալիս ֆունկցիայի ներսում գտնվող ամբողջ օբյեկտին, դա չի ազդում սկզբնական օբյեկտի վրա:
 
To check your solution you need to sign in
Sign in to continue