Lists, References, Copies and Functionsلیستەکان، ئاماژەکان، کۆپی و کردارەکان

In Python a variable does not keep a list inside itself. The list is an object that lives in the computer's memory, and the variable is only a name that refers to it — the name-tag picture from Variables and data types. This lesson is about what that means in practice: why a change made through one name can appear under another name, how to make a real copy, and what happens when a list goes into a function or comes out of one.

لە Pythonـدا گۆڕاوێک (Variable) لیستێک لەناو خۆیدا هەڵناگرێت. لیستەکە ئۆبجێکتێکە کە لە بیرگەی (Memory) کۆمپیوتەردا دەژی و گۆڕاوەکە تەنها ناوێکە کە ئاماژەی پێ دەکات — هەمان وێنەی کارتی ناو کە لە گۆڕاوەکان و جۆرەکانی دراوە بینیت. ئەم وانەیە باسی ئەوە دەکات کە ئەمە لە ڕاستیدا چی دەگەیەنێت: بۆچی گۆڕانێک کە بە ناوێک دەکرێت لەژێر ناوێکی تریشدا دەردەکەوێت، چۆن کۆپییەکی ڕاستەقینە دروست دەکەیت و چی ڕوو دەدات کاتێک لیستێک دەچێتە ناو کردارێکەوە یان لێی دێتە دەرەوە.

Start with the course's own example. mylist = thislist looks like "make mylist a copy of thislist". Then one item is added through thislist only. Read the output: mylist has the new item too.

بە نموونەکەی خودی کۆرسەکە دەست پێ بکە. mylist = thislist وەک ئەوە دەردەکەوێت کە «mylist بکە بە کۆپییەکی thislist». پاشان تەنها بە thislist دانەیەک (Element) زیاد دەکرێت. سەیری دەرخستەکە (Output) بکە: mylistـیش دانە نوێیەکەی تێدایە.

The course slides say that to copy a list you write list2 = list1. Look at what really happens. Before the line, list2 names its own list [7, 8]. After the line, list2 names the same list as list1, and the old list [7, 8] has no name left.

سلایدەکانی کۆرس دەڵێن بۆ کۆپیکردنی لیستێک دەنووسیت list2 = list1. سەیر بکە بە ڕاستی چی ڕوو دەدات. پێش ئەو دێڕە، list2 ناوی لیستێک تایبەت بە خۆیەتی: [7, 8]. دوای دێڕەکە، list2 ناوی هەمان ئەو لیستەیە کە list1 ناویەتی و لیستە کۆنەکە [7, 8] هیچ ناوێکی بۆ نامێنێتەوە.

Two different things can happen to a name. Changing the object — list2[0] = 111, append, remove, sort — changes the one list, and every name that refers to it sees the change. Re-binding the name — list2 = [7, 8] — ties that one name to another object; the other names stay where they were.

دوو شتی جیاواز دەکرێت بە ناوێک بکرێت. گۆڕینی ئۆبجێکتەکە — list2[0] = 111، append، remove، sort — هەمان یەک لیست دەگۆڕێت و هەموو ئەو ناوانەی ئاماژەی پێ دەکەن گۆڕانەکە دەبینن. بەستنەوەی ناوەکە بە شتێکی تر — list2 = [7, 8] — تەنها ئەو ناوە بە ئۆبجێکتێکی ترەوە دەبەستێت؛ ناوەکانی تر لە شوێنی خۆیان دەمێننەوە.

Numbers, strings and tuples are immutable: they can never be changed, only replaced by a new value. So sharing them between names is always safe — a = a + 1 makes a new number and moves a to it. Lists are mutable: they can be changed in place. Sharing is only a surprise for mutable objects.

ژمارەکان، زنجیرەنووسەکان (String) و تاپڵەکان (Tuple) گۆڕانهەڵنەگرن (Immutable): هەرگیز ناگۆڕدرێن، تەنها نرخێکی (Value) نوێ جێگەیان دەگرێتەوە. بۆیە هاوبەشکردنیان لە نێوان چەند ناوێکدا هەمیشە بێ مەترسییە — a = a + 1 ژمارەیەکی نوێ دروست دەکات و a دەگوازێتەوە بۆ لای. لیستەکان گۆڕانهەڵگرن (Mutable): دەکرێت لە شوێنی خۆیاندا بگۆڕدرێن. هاوبەشکردن تەنها بۆ ئۆبجێکتەکانی گۆڕانهەڵگر سەرسوڕهێنەرە.

Python gives you two different questions. == asks "do these two lists hold the same items in the same order?" is asks "are these two names the very same object?" The built-in function id() shows an object's identity number — every value has one, as Every value is an object with an id showed. Two names are the same object exactly when their id() numbers are equal.

Python دوو پرسیاری جیاوازت پێ دەدات. == دەپرسێت «ئایا ئەم دوو لیستە هەمان دانەکان بە هەمان ڕیزبەندییان تێدایە؟» is دەپرسێت «ئایا ئەم دوو ناوە ڕێک هەمان ئۆبجێکتن؟» کردارە ئامادەکە (Built-in function) id() ژمارەی ناسنامەی ئۆبجێکتێک پیشان دەدات — هەموو نرخێک ناسنامەی هەیە، وەک لە هەموو نرخێک ئۆبجێکتێکە و ناسنامەی هەیە بینیت. دوو ناو تەنها کاتێک هەمان ئۆبجێکتن کە ژمارەی id()ـیان یەکسان بێت.

To get a second, independent list you must ask Python to build a new list with the same items. Each of these four lines does that. The course slides show the first two; the slice [:] and [] + list are the same idea in other forms.

بۆ ئەوەی لیستێکی دووەمی سەربەخۆت هەبێت، دەبێت داوا لە Python بکەیت لیستێکی نوێ دروست بکات کە هەمان دانەکانی تێدابێت. هەریەک لەم چوار دێڕە ئەوە دەکات. سلایدەکانی کۆرس دووانی یەکەمیان پیشان دەدەن؛ لەتکردن (Slicing) بە [:] و [] + list هەمان بیرۆکەن بە شێوەیەکی تر.

The two exercises from the slides differ in one line only. Predict the output before you open the answer. list(range(1, 10, 2)) is [1, 3, 5, 7, 9].

دوو ڕاهێنانەکەی سلایدەکان تەنها لە یەک دێڕدا جیاوازن. پێش کردنەوەی وەڵامەکە دەرخستەکە پێشبینی بکە. list(range(1, 10, 2)) بریتییە لە [1, 3, 5, 7, 9].

copy(), list(), [:] and [] + list all make a shallow copy: a new outer list whose items are the same objects as in the old list. For numbers and strings that is fine. But when the items are themselves lists — a table stored as rows — the two outer lists share the rows.

copy()، list()، [:] و [] + list هەموویان کۆپییەکی ڕووکەش دروست دەکەن: لیستێکی نوێی دەرەوە کە دانەکانی هەمان ئۆبجێکتەکانن وەک لە لیستە کۆنەکەدا. بۆ ژمارە و زنجیرەنووسە ئەمە کێشە نییە. بەڵام کاتێک دانەکان خۆیان لیستن — خشتەیەک کە وەک ڕیزەکان (Table row) هەڵگیراوە — هەردوو لیستی دەرەوە هەمان ڕیزەکان بەیەکەوە بەکار دەهێنن.

A list can be an argument like any other value. When you call print_list([3, 1, 2, 6, 4, 2]), Python does something like lst = [3, 1, 2, 6, 4, 2] behind the scenes: the parameter lst becomes one more name for the caller's list. Nothing is copied.

لیستێک دەتوانێت وەک هەر نرخێکی تر ئارگیومێنتێک (Argument) بێت. کاتێک print_list([3, 1, 2, 6, 4, 2]) بانگ دەکەیت، Python لە پشتەوە شتێکی وەک lst = [3, 1, 2, 6, 4, 2] دەکات: پارامیتەرەکە (Parameter) lst دەبێتە ناوێکی تر بۆ لیستی بانگکەرەکە. هیچ شتێک کۆپی ناکرێت.

This function only reads the list. But because the parameter and the caller's variable are two names for one mutable list, a function can also change it — and the change is still there after the call. The next screen shows exactly that.

ئەم کردارە تەنها لیستەکە دەخوێنێتەوە. بەڵام لەبەر ئەوەی پارامیتەرەکە و گۆڕاوەکەی بانگکەرەکە دوو ناون بۆ یەک لیستی گۆڕانهەڵگر، کردارێک دەشتوانێت بیگۆڕێت — و گۆڕانەکە دوای بانگکردنی کردارەکە (Function call) دەمێنێتەوە. پەڕەی داهاتوو ڕێک ئەوە پیشان دەدات.

This classic example passes a number x and a list y to a function m. Inside, m gives its parameter number a new value and changes the first item of numbers. After the call, main prints both. Here is the program as the slide has it:

ئەم نموونە ناودارە ژمارەیەک x و لیستێک y دەنێرێت بۆ کردارەکە m. لە ناوەوە، m نرخێکی نوێ دەدات بە پارامیتەرەکەی number و یەکەم دانەی numbers دەگۆڕێت. دوای بانگکردنی کردارەکە، main هەردووکیان چاپ دەکات. ئەمە بەرنامەکەیە (Program) وەک لە سلایدەکەدایە:

The example worked this way because a list is mutable and a number is immutable. Every built-in type of Python is one or the other. You know lists, numbers and strings already; tuples, sets and dictionaries come later in Tuples, sets and dictionaries.

نموونەکە بەم شێوەیە کاری کرد چونکە لیست گۆڕانهەڵگرە و ژمارە گۆڕانهەڵنەگرە. هەر جۆرێکی ئامادەی Python یان گۆڕانهەڵگرە یان گۆڕانهەڵنەگر. لیستەکان، ژمارەکان و زنجیرەنووسەکان دەناسیت؛ تاپڵەکان، کۆمەڵەکان (Set) و فەرهەنگەکان (Dictionary) دواتر لە تاپڵەکان، کۆمەڵەکان و فەرهەنگەکان دێن.

A function can also return a list. What comes back is a reference to the list the function built. This reverse function makes an empty list result, puts every element of lst at the front of it with insert(0, …), and returns it. The list you passed in is not touched.

کردارێک دەتوانێت لیستێکیش بگەڕێنێتەوە. ئەوەی دەگەڕێتەوە ئاماژەیەکە بۆ ئەو لیستەی کە کردارەکە دروستی کرد. ئەم کردارە reverseـە لیستێکی بەتاڵی result دروست دەکات، هەموو دانەیەکی lst بە insert(0, …) دەخاتە سەرەتای result و دەیگەڕێنێتەوە. ئەو لیستەی ناردت دەستی لێ نادرێت.

Writing reverse yourself is good practice with loops. In real programs Python already has three tools — two give a new list, one changes the list in place:

نووسینی reverse بە دەستی خۆت ڕاهێنانێکی باشە لەسەر خولەکان (Loop). لە بەرنامەکانی ڕاستەقینەدا Python پێشتر سێ ئامرازی هەیە — دووانیان لیستێکی نوێ دەدەن و یەکێکیان لیستەکە لە شوێنی خۆیدا دەگۆڕێت:

Why? A default value is worked out once, when Python runs the def line — not every time the function is called. So every call that uses the default shares one list. For numbers and strings that never matters, because they cannot change. For a list it does.

بۆچی؟ نرخی بنەڕەتی تەنها یەکجار هەژمار دەکرێت، کاتێک Python دێڕی def جێبەجێ دەکات — نەک هەر جارێک کردارەکە بانگ بکرێت. بۆیە هەموو ئەو بانگکردنانەی نرخە بنەڕەتییەکە بەکار دەهێنن یەک لیست هاوبەش دەکەن. بۆ ژمارە و زنجیرەنووسە ئەمە هەرگیز گرنگ نییە، چونکە ناگۆڕدرێن. بۆ لیستێک گرنگە.

"Swap" in this task means reverse the order. The function changes the caller's list in place and returns it. That has a trap: if you saved the list with before = languages and print before afterwards, you see the reversed list, because before is only another name.

«ئاڵوگۆڕ» لەم ئەرکەدا واتە پێچەوانەکردنەوەی ڕیزبەندی. کردارەکە لیستی بانگکەرەکە لە شوێنی خۆیدا دەگۆڕێت و دەیگەڕێنێتەوە. ئەمە داوێکی هەیە: ئەگەر لیستەکەت بە before = languages هەڵگرتبێت و دواتر before چاپ بکەیت، لیستە پێچەوانەکراوەکە دەبینیت، چونکە before تەنها ناوێکی ترە.

Next: the built-in tools for lists of numbers — sum, max, min — and sorting, in sum, max, min and Sorting.

داهاتوو: ئامرازە ئامادەکان بۆ لیستەکانی ژمارە — sum، max، min — و ڕیزکردن (Sorting)، لە sum، max، min و ڕیزکردن.