Reading and Writing Filesخوێندنەوە و نووسینی فایلەکان

Every program so far forgot everything when it ended. Its variables live in memory (RAM) only while the program runs. Run this tea counter twice: the second run starts from zero again.

هەموو بەرنامەکانی تا ئێستا کاتێک کۆتاییان هات هەموو شتێکیان لەبیر کرد. گۆڕاوەکانیان (Variable) تەنها لە کاتی کارکردنی بەرنامەکەدا لە بیرگە (Memory) ⁦(RAM)⁩ـدا دەژین. ئەم ژمێرەری (Counter) چایە دوو جار کار پێ بکە: جاری دووەم دیسان لە سفرەوە دەست پێ دەکاتەوە.

To keep data for the next run, for tomorrow or for another program, a program saves it in a file on secondary storage: a hard disk, an SSD or a flash drive. A file stays after the program ends and after the computer is switched off (Switch off: what stays and what goes explains why). This is how a shop keeps its stock, a school its marks and an office its staff list.

بۆ پاراستنی دراوە بۆ جاری داهاتوو، بۆ سبەی یان بۆ بەرنامەیەکی تر، بەرنامەکە لە فایلێکدا لەسەر بیرگەی دووەکی (Secondary storage) هەڵی دەگرێت: هارد دیسک (Hard disk drive)، SSD یان بیرگەی فلاش (USB flash drive). فایلەکە دوای کۆتایی هاتنی بەرنامەکە و دوای کوژاندنەوەی (Shut down) کۆمپیوتەرەکەش (Computer) دەمێنێتەوە (کوژاندنەوە: چی دەمێنێت و چی دەڕوات هۆکارەکەی ڕوون دەکاتەوە). دوکانێک کاڵاکانی، قوتابخانەیەک نمرەکان و فەرمانگەیەک ناوی کارمەندەکانی بەم شێوەیە هەڵدەگرێت.

Here is the same counter with a file. It reads the old total from tea_total.txt, adds the new teas and writes the new total back. Now the second run continues from the first. Do not worry about the details yet: by the end of this lesson you can explain every line.

ئەمە هەمان ژمێرەرە بە فایلێک. کۆی کۆن لە tea_total.txt دەخوێنێتەوە، چا نوێیەکان زیاد دەکات و کۆ نوێیەکە دەنووسێتەوە. ئێستا جاری دووەم لە شوێنی جاری یەکەمەوە بەردەوام دەبێت. ئێستا خەمی وردەکارییەکان مەخۆ: لە کۆتایی ئەم وانەیەدا دەتوانیت هەموو دێڕێک ڕوون بکەیتەوە.

Your .py programs are files too. The editor saves your code on the disk, and Python reads it from there every time you run it. The data a program works with can be kept in the same way.

بەرنامەکانی .pyـی خۆشت فایلن. دەستکاریکەری دەقەکە (Text editor) کۆدەکەت لەسەر دیسک هەڵدەگرێت و Python هەر جارێک کاری پێ دەکەیت لەوێوە دەیخوێنێتەوە. ئەو دراوەیەی بەرنامەیەک کاری لەگەڵ دەکات دەکرێت بە هەمان شێوە هەڵبگیرێت.

Inside the computer every file is a row of bytes, one after another. What those bytes mean decides the kind of file. There are two kinds of data files:

لەناو کۆمپیوتەردا هەموو فایلێک ڕیزێک بایتە (Byte)، یەک لە دوای یەک. مانای بایتەکان جۆری فایلەکە دیاری دەکات. دوو جۆر فایلی دراوە هەن:

In a text file each character is stored as its number in a character encoding. With UTF-8, English letters take one byte and Kurdish letters two (UTF-8: one to four bytes, Kurdish letters in a database). The end of a line is one more character, the newline \n. This program writes two short lines and then reads the file back as raw bytes:

لە فایلێکی دەقیدا هەر نووسەیەک وەک ژمارەکەی لە ئینکۆدینگێکدا (Character encoding) هەڵدەگیرێت. بە ⁦UTF-8⁩ پیتە ئینگلیزییەکان یەک بایت و پیتە کوردییەکان دوو بایت دەگرن (⁦UTF-8⁩: یەک تا چوار بایت، پیتە کوردییەکان لە بنکەدراوەدا). کۆتایی دێڕ نووسەیەکی ترە، دێڕی نوێ \n. ئەم بەرنامەیە دوو دێڕی کورت دەنووسێت و پاشان فایلەکە وەک بایتەکانی خاو دەخوێنێتەوە:

72, 105 are H and i; 10 is \n. Each Kurdish letter took two bytes: 216, 179 is «س». A text editor does the opposite: it turns the codes back into letters and starts a new line at every 10.

72, 105 بریتین لە H و i؛ 10 بریتییە لە \n. هەر پیتێکی کوردی دوو بایتی گرت: 216, 179 بریتییە لە «س». دەستکاریکەرێکی دەق پێچەوانەکەی دەکات: کۆدەکان دەکاتەوە بە پیت و لە هەر 10ـێکدا دێڕێکی نوێ دەست پێ دەکات.

In a binary file the bytes are not character codes, so they do not make sense as text. A text editor shows strange symbols, and Python refuses to read them as UTF-8. The first 8 bytes of every PNG picture show it:

لە فایلێکی دووانیدا بایتەکان کۆدی نووسە نین، بۆیە وەک دەق مانایان نییە. دەستکاریکەرێکی دەق هێمای سەیر پیشان دەدات و Python ڕازی نابێت وەک ⁦UTF-8⁩ بیانخوێنێتەوە. یەکەم 8 بایتی هەموو وێنەیەکی PNG ئەمە پیشان دەدەن:

Binary files are also fragile: change a single bit of a picture or a program and it may not open at all. A text file with one wrong letter can still be read and corrected by a person. Python can read and write both kinds; the mode you open the file with decides which.

فایلە دووانییەکان ناسکیشن: تەنها یەک بیت (Bit) لە وێنەیەک یان بەرنامەیەکدا بگۆڕە، لەوانەیە هەر نەکرێتەوە. فایلێکی دەقی کە یەک پیتی هەڵەی تێدایە هێشتا مرۆڤ دەتوانێت بیخوێنێتەوە و ڕاستی بکاتەوە. Python دەتوانێت هەردوو جۆر بخوێنێتەوە و بنووسێت؛ ئەو دۆخەی فایلەکەی پێ دەکەیتەوە بڕیار دەدات کامیان.

Save just one name, Shilan, in a text file and in a Word document, then compare the sizes. We did it on a computer (macOS):

تەنها یەک ناو، Shilan، لە فایلێکی دەقی و لە بەڵگەنامەیەکی Word هەڵبگرە، پاشان قەبارەکانیان بەراورد بکە. ئێمە لەسەر کۆمپیوتەرێک ⁦(macOS)⁩ کردمان:

A .docx file is a binary file: a zip package. Most of it is not your text but formatting and information about the document, such as the author, the dates and the page settings. A .txt file holds only the characters, so its size is counted in bytes while the .docx needs kilobytes. (File extensions and file types lists more file types.)

فایلی .docx فایلی دووانییە: پاکەتێکی zip. زۆربەی ناوەڕۆکەکەی دەقەکەی تۆ نییە، بەڵکو ڕێکخستنی شێوە و زانیاری دەربارەی بەڵگەنامەکەیە، وەک نووسەر، بەروارەکان و ڕێکخستنی پەڕە. فایلی .txt تەنها نووسەکان هەڵدەگرێت، بۆیە قەبارەکەی بە بایت دەژمێردرێت، لە کاتێکدا .docx کیلۆبایتی (Kilobyte) پێویستە. (پاشگرەکانی فایل و جۆرەکانی فایل جۆری زیاتر دەناسێنێت.)

To work with a file, a program first opens it with the built-in function open(). It needs the file's name, a mode that says what you want to do, and for a text file the encoding:

بۆ کارکردن لەگەڵ فایلێک، بەرنامەکە سەرەتا بە کرداری ئامادەی (Built-in function) open() دەیکاتەوە. ناوی فایلەکە، دۆخێک کە دەڵێت دەتەوێت چی بکەیت و بۆ فایلێکی دەقی ئینکۆدینگەکەی پێویستە:

open() returns a file object (also called a file handle). The variable f is now your link to the file on the disk: everything you do with the file goes through f's methods (f.write(), f.read(), f.close()…), and its attributes f.name, f.mode and f.closed tell you about it.

open() ئۆبجێکتێکی فایل دەگەڕێنێتەوە (هەروەها پێی دەڵێن ⁦file handle⁩). گۆڕاوی f ئێستا بەستەری تۆیە بە فایلەکەی سەر دیسکەکەوە: هەر شتێک بە فایلەکە بکەیت بە میتۆدەکانی (Method) fـدا تێدەپەڕێت (f.write()، f.read()، f.close()…) و تایبەتمەندییەکانی f.name، f.mode و f.closed زانیاریت دەربارەی پێ دەدەن.

If you give no mode, open() uses "r": read a text file. Reading a file that does not exist is an error:

ئەگەر هیچ دۆخێک نەدەیت، open() "r" بەکار دەهێنێت: خوێندنەوەی فایلێکی دەقی. خوێندنەوەی فایلێک کە بوونی نییە هەڵەیە:

Later in this lesson you will catch this error instead of crashing (Errors you will meet).

دواتر لەم وانەیەدا ئەم هەڵەیە دەگریت لەبری ئەوەی بەرنامەکە بکەوێت (چەند هەڵەیەک کە تووشیان دەبیت).

A plain name like "notes.txt" means the file in the current working directory: the folder Python was started in (when you press Run in an editor, usually your project folder). For a file somewhere else, give its path. Paths: a file's full address explains relative and absolute paths; in Python they look like this:

ناوێکی سادەی وەک "notes.txt" واتە ئەو فایلەی لە فۆڵدەری (Directory) کاری ئێستادایە: ئەو فۆڵدەرەی Pythonـی تێدا دەستی پێکرد (کاتێک لە دەستکاریکەرێکی دەقدا Run دەکەیت، زۆرجار فۆڵدەری پڕۆژەکەت). بۆ فایلێک لە شوێنێکی تر، ڕێڕەوەکەی بدە. ڕێڕەوەکان: ناونیشانی تەواوی فایلێک ڕێڕەوی ڕێژەیی (Relative path) و ڕێڕەوی ڕەها (Absolute path) ڕوون دەکاتەوە؛ لە Pythonـدا بەم شێوەیەن:

A writing mode can create a missing file, but not a missing folder. The same program fails while there is no data folder and works once the folder exists:

دۆخێکی نووسین دەتوانێت فایلێکی نەبوو دروست بکات، بەڵام فۆڵدەرێکی نەبوو نا. هەمان بەرنامە تا فۆڵدەری data نەبێت سەرناکەوێت و کاتێک فۆڵدەرەکە هەبوو کار دەکات:

On Windows, paths use backslashes (\). Inside a string a backslash starts an escape sequence, so in "C:\new\marks.txt" the \n becomes a new line: the trap shown in Special characters. Write Windows paths with forward slashes, "C:/new/marks.txt" (Windows accepts them), or as a raw string, r"C:\new\marks.txt".

لە Windowsـدا ڕێڕەوەکان هێمای \ (backslash) بەکار دەهێنن. لەناو زنجیرەنووسەیەکدا (String) ئەم هێمایە و پیتی دوای خۆی هێمایەکی تایبەت (Escape sequence) پێک دەهێنن، بۆیە لە "C:\new\marks.txt"ـدا \n دەبێتە دێڕی نوێ: ئەو تەڵەیەی لە بەشی نووسە تایبەتەکان بینیت. ڕێڕەوەکانی Windows بە هێمای / بنووسە، "C:/new/marks.txt" (Windows وەریان دەگرێت)، یان وەک زنجیرەنووسەیەکی خاو: r"C:\new\marks.txt".

The mode is the second argument of open(). One letter says the main job, + adds the other job (reading and writing) and b switches from text to binary. Before you open a file, ask three questions: Is a missing file created? Is the old content erased? Where does reading or writing start?

دۆخ ئارگیومێنتی (Argument) دووەمی open()ـە. یەک پیت کارە سەرەکییەکە دەڵێت، + کارەکەی تر زیاد دەکات (خوێندنەوە و نووسین) و b لە دەقەوە دەیگۆڕێت بۆ دووانی. پێش ئەوەی فایلێک بکەیتەوە، سێ پرسیار بکە: ئایا فایلێکی نەبوو دروست دەکرێت؟ ئایا ناوەڕۆکی کۆن دەسڕدرێتەوە؟ خوێندنەوە یان نووسین لە کوێوە دەست پێ دەکات؟

The t for text is the default, so "r" means "rt". The three questions of the table describe every mode. Here are the five that the textbook's activity asks about:

t بۆ دەق بنەڕەتە، بۆیە "r" واتە "rt". سێ پرسیارەکەی خشتەکە باسی هەموو دۆخێک دەکەن. ئەمە ئەو پێنج دۆخەن کە چالاکییەکەی کتێبەکە پرسیاریان لێ دەکات:

A table in a book can be wrong, so we checked every row. This program opens a missing file and a file that holds OLD in each mode and reports what happened:

خشتەیەک لە کتێبێکدا دەکرێت هەڵە بێت، بۆیە هەموو ڕیزێکمان پشکنی. ئەم بەرنامەیە فایلێکی نەبوو و فایلێک کە OLDـی تێدایە بە هەر دۆخێک دەکاتەوە و ڕایدەگەیەنێت چی ڕووی دا:

A mode also limits what you may do. Reading from a file opened with w or a, or writing to one opened with r, raises io.UnsupportedOperation:

دۆخ ئەوەش سنووردار دەکات کە بۆت هەیە بیکەیت. خوێندنەوە لە فایلێک کە بە w یان a کراوەتەوە، یان نووسین لە فایلێک کە بە r کراوەتەوە، io.UnsupportedOperation دروست دەکات:

When you have finished, close the file with f.close(). Closing does two jobs. It writes out everything that is still waiting in the file's buffer, and it frees the file for other programs. Python does not send every write() to the disk at once: it collects the text in a buffer in memory and writes bigger pieces, which is much faster. You can see it happen:

کاتێک تەواو بوویت، فایلەکە بە f.close() دابخە. داخستن دوو کار دەکات. هەموو ئەوەی هێشتا لە بافەری (Buffer) فایلەکەدا چاوەڕێ دەکات دەینووسێت، هەروەها فایلەکە بۆ بەرنامەکانی تر ئازاد دەکات. Python هەموو write()ـێک یەکسەر نانێرێت بۆ دیسک: دەقەکە لە بافەرێکدا لە بیرگەدا کۆ دەکاتەوە و پارچەی گەورەتر دەنووسێت، کە زۆر خێراترە. دەتوانیت ببینیت چۆن ڕوو دەدات:

So if a program crashes, or the power goes off, before the file is closed, the last writes can be lost. There is no error message: the data are simply missing. f.flush() writes the buffer out without closing, for a program that keeps a file open for a long time.

کەواتە ئەگەر بەرنامەیەک بکەوێت یان کارەبا ببڕێت پێش داخستنی فایلەکە، دوایین نووسینەکان دەکرێت ون ببن. هیچ پەیامێکی هەڵە نییە: دراوەکە بە سادەیی ون دەبێت. f.flush() بافەرەکە دەنووسێت بەبێ داخستن، بۆ بەرنامەیەک کە فایلێک بۆ کاتێکی درێژ کراوە دەهێڵێتەوە.

Forgetting close() is easy, and an exception between open() and close() skips it. The with statement closes the file for you when its block ends, even when an exception happens inside it. It is the recommended way, and every example from now on uses it.

لەبیرکردنی close() ئاسانە و هەڵاوێردەیەک (Exception) لە نێوان open() و close()ـدا بازی بەسەردا دەدات. ڕستەی with کاتێک بلۆکەکەی کۆتایی دێت فایلەکە بۆت دادەخات، تەنانەت کاتێک هەڵاوێردەیەک لەناویدا ڕوو دەدات. ئەمە ڕێگا پێشنیارکراوەکەیە و هەموو نموونەیەک لێرە بەدواوە بەکاری دەهێنێت.

with does the same job as try … finally with close() in the finally block (else and finally), in fewer lines:

with هەمان کاری try … finally دەکات کە close() لە بلۆکی finallyـدایە (else و finally)، بە دێڕی کەمتر:

To write, open the file with w, a, x or a + mode. write() takes one string, writes it and returns the number of characters it wrote. It adds nothing of its own: no space and no newline. Put \n into the string yourself where a line must end, and turn numbers into strings with str().

بۆ نووسین، فایلەکە بە w، a، x یان دۆخێکی + بکەرەوە. write() یەک زنجیرەنووسە وەردەگرێت، دەینووسێت و ژمارەی نووسە نووسراوەکان دەگەڕێنێتەوە. هیچ شتێک لە خۆیەوە زیاد ناکات: نە بۆشایی و نە دێڕی نوێ. خۆت \n بخەرە ناو زنجیرەنووسەکە لەو شوێنەی دێڕ دەبێت کۆتایی بێت و ژمارەکان بە str() بکە بە زنجیرەنووسە.

Forget str() and Python stops you:

ئەگەر str() لەبیر بکەیت، Python ڕێگەت پێ نادات:

writelines() writes many strings at once, from a list, a tuple or any other sequence of strings. It is the same as calling write() for each item: it adds no newlines, and it returns None, not a count.

writelines() چەند زنجیرەنووسەیەک پێکەوە دەنووسێت، لە لیستێک (List)، تاپڵێک (Tuple) یان هەر زنجیرەیەکی تری زنجیرەنووسە. وەک ئەوەیە بۆ هەر دانەیەک write() بانگ بکەیت: هیچ دێڕێکی نوێ زیاد ناکات و None دەگەڕێنێتەوە، نەک ژمارە.

Without the \n the cities run together: writelines(["Erbil", "Sulaymaniyah", "Duhok"]) writes ErbilSulaymaniyahDuhok on one line. The textbook also asks two questions. Can writelines() take a tuple of numbers? No, every item must be a string:

بەبێ \n شارەکان دەچنە ناو یەکتر: writelines(["Erbil", "Sulaymaniyah", "Duhok"]) ErbilSulaymaniyahDuhok لە یەک دێڕدا دەنووسێت. کتێبەکە دوو پرسیاری تریش دەکات. ئایا writelines() دەتوانێت تاپڵێک ژمارە وەربگرێت؟ نەخێر، دەبێت هەموو دانەیەک زنجیرەنووسە بێت:

And can write() take the whole list instead? Also no: f.write(["Erbil\n", "Duhok\n"]) raises TypeError: write() argument must be str, not list. To save numbers, turn each one into a line of text yourself:

ئایا write() دەتوانێت هەموو لیستەکە وەربگرێت؟ ئەویش نەخێر: f.write(["Erbil\n", "Duhok\n"]) TypeError: write() argument must be str, not list دروست دەکات. بۆ هەڵگرتنی ژمارەکان، خۆت هەر یەکێکیان بکە بە دێڕێکی دەق:

Mode a (append) writes at the end and keeps everything that is already there. Mode w starts again from an empty file every time. Here are two small programs, each run twice. The first appends:

دۆخی a (زیادکردن) لە کۆتاییدا دەنووسێت و هەموو ئەوەی پێشتر هەیە دەیهێڵێتەوە. دۆخی w هەر جارێک لە فایلێکی بەتاڵەوە دەست پێ دەکاتەوە. ئەمە دوو بەرنامەی بچووکن، هەر یەکەیان دوو جار کاری پێکراوە. یەکەمیان زیاد دەکات:

The second is the same program with "w" in line 1. The second run erased the first visitor:

دووەمیان هەمان بەرنامەیە بە "w" لە دێڕی 1ـدا. جاری دووەم یەکەم سەردانکەری سڕییەوە:

To read, open the file in a mode that reads: r (the default), r+, w+ or a+. The reading examples use this small file of marks, marks.txt:

بۆ خوێندنەوە، فایلەکە بە دۆخێک بکەرەوە کە دەخوێنێتەوە: r (بنەڕەت)، r+، w+ یان a+. نموونەکانی خوێندنەوە ئەم فایلە بچووکەی نمرە بەکار دەهێنن، marks.txt:

read(n) reads the next n characters; read() with no number reads everything that is left as one string. At the end of the file it returns the empty string ''. (repr() shows the hidden \n characters.)

read(n) n نووسەی داهاتوو دەخوێنێتەوە؛ read() بەبێ ژمارە هەموو پاشماوەکە وەک یەک زنجیرەنووسە دەخوێنێتەوە. لە کۆتایی فایلەکەدا زنجیرەنووسەی بەتاڵ '' دەگەڕێنێتەوە. (repr() نووسەکانی شاراوەی \n پیشان دەدات.)

readline() reads one line, including its \n. Each call continues where the last one stopped. At the end of the file it returns '': an empty string, not an error. A blank line in the middle of a file comes back as '\n', so '' can only mean the end.

readline() یەک دێڕ دەخوێنێتەوە، لەگەڵ \nـەکەی. هەر بانگکردنێک لەو شوێنەوە بەردەوام دەبێت کە پێشووەکە وەستا. لە کۆتایی فایلەکەدا '' دەگەڕێنێتەوە: زنجیرەنووسەیەکی بەتاڵ، نەک هەڵە. دێڕێکی بەتاڵ لە ناوەڕاستی فایلێکدا وەک '\n' دەگەڕێتەوە، بۆیە '' تەنها دەتوانێت مانای کۆتایی بێت.

readline(n) reads at most n characters, and never past the end of the line: readline(4) gives 'Aram', the next readline() gives the rest of that line, ' 17\n'. To read a whole file with readline(), repeat it in a loop that stops at '':

readline(n) زۆرترین n نووسە دەخوێنێتەوە و هەرگیز لە کۆتایی دێڕەکە تێناپەڕێت: readline(4) 'Aram' دەدات، readline()ـی دواتر پاشماوەی هەمان دێڕ دەدات، ' 17\n'. بۆ خوێندنەوەی هەموو فایلێک بە readline()، لە خولێکدا (Loop) دووبارەی بکەرەوە کە لە ''ـدا دەوەستێت:

readlines() reads all the lines into a list of strings. Each string still ends with \n:

readlines() هەموو دێڕەکان دەخوێنێتەوە بۆ ناو لیستێک لە زنجیرەنووسە. هەر زنجیرەنووسەیەک هێشتا بە \n کۆتایی دێت:

The best way for most programs is a for loop over the file object itself. It reads one line on each turn, uses little memory even for a huge file and needs no '' test:

باشترین ڕێگا بۆ زۆربەی بەرنامەکان خولێکی for بەسەر خودی ئۆبجێکتی فایلەکەدا. لە هەر خولانەوەیەکدا یەک دێڕ دەخوێنێتەوە، تەنانەت بۆ فایلێکی زۆر گەورەش بیرگەی کەم بەکار دەهێنێت و پێویستی بە تاقیکردنەوەی '' نییە:

A line is a string, so every string method works on it. split() cuts a line into words (split() and join()), and the newline disappears with the spaces. splitlines() gives the line without its \n, in a one-item list:

دێڕ زنجیرەنووسەیە، بۆیە هەموو میتۆدێکی زنجیرەنووسە لەسەری کار دەکات. split() دێڕێک دەکات بە وشە (⁦split()⁩ و ⁦join()⁩) و دێڕە نوێکە لەگەڵ بۆشاییەکان لادەچێت. splitlines() دێڕەکە بەبێ \nـەکەی دەدات، لە لیستێکی یەک دانەییدا:

Everything read from a text file is text. To calculate with it, convert it: int("17") is the number 17.

هەموو ئەوەی لە فایلێکی دەقی دەخوێنرێتەوە دەقە. بۆ ژماردن پێی، بیگۆڕە: int("17") ژمارە ⁦17⁩ـە.

A CSV file (comma-separated values) is a text file that holds a table: one row on each line, the values separated by commas. Spreadsheet programs open and save it. Read it into a list of lists, one inner list for each row (Lists inside a list). Here is marks.csv:

فایلێکی CSV ⁦(comma-separated values)⁩ فایلێکی دەقییە کە خشتەیەک هەڵدەگرێت: هەر ڕیزێک لە دێڕێکدا و نرخەکان بە کۆما جیا کراونەتەوە. بەرنامە خشتەییەکان (Spreadsheet) دەیکەنەوە و هەڵی دەگرن. بیخوێنەوە بۆ ناو لیستێک لە لیستەکان، بۆ هەر ڕیزێک لیستێکی ناوەکی (لیستە دووڕەهەندەکان). ئەمە marks.csvـە:

Now everything together. The user types sentences until they type END. The program saves them in a file, one per line, then reads the file back and shows only the sentences that begin with a capital letter.

ئێستا هەموو شتێک پێکەوە. بەکارهێنەرەکە (User) ڕستە دەنووسێت تا END دەنووسێت. بەرنامەکە لە فایلێکدا هەڵیان دەگرێت، هەر یەکەیان لە دێڕێکدا، پاشان فایلەکە دەخوێنێتەوە و تەنها ئەو ڕستانە پیشان دەدات کە بە پیتی گەورە دەست پێ دەکەن.

The Kurdish sentence was saved but not shown. Arabic-script letters have no capital and small forms, so "ک".isupper() is False, and so is "ک".islower() (More case methods).

ڕستە کوردییەکە هەڵگیرا بەڵام پیشان نەدرا. پیتەکانی ئەلفوبێی عەرەبی شێوەی گەورە و بچووکیان نییە، بۆیە "ک".isupper() Falseـە و "ک".islower()ـیش هەروەها (پیتی گەورە و بچووک).

Files live outside your program, so many things can go wrong that your code cannot prevent: the file was deleted, the name is misspelt, the name belongs to a folder, or another user owns the file. Python raises an exception for each case, and they are all kinds of OSError:

فایلەکان لە دەرەوەی بەرنامەکەت دەژین، بۆیە زۆر شت دەکرێت هەڵە بچێت کە کۆدەکەت ناتوانێت ڕێگری لێ بکات: فایلەکە سڕاوەتەوە، ناوەکە بە هەڵە نووسراوە، ناوەکە هی فۆڵدەرێکە یان بەکارهێنەرێکی تر خاوەنی فایلەکەیە. Python بۆ هەر حاڵەتێک هەڵاوێردەیەک دروست دەکات و هەموویان جۆرێکن لە OSError:

Catch the error you expect with try and except (Catch the exceptions you expect) and the program can ask again instead of crashing:

ئەو هەڵەیەی چاوەڕێی دەکەیت بە try و except بگرە (هەڵاوێردەکانی چاوەڕوانکراو بگرە) و بەرنامەکە دەتوانێت دیسان بپرسێت لەبری ئەوەی بکەوێت:

One more error: a file closed by with cannot be read after the block. Indent the reading lines inside the with block, or Python raises ValueError: I/O operation on closed file.

هەڵەیەکی تر: فایلێک کە with دایخستووە دوای بلۆکەکە ناخوێنرێتەوە. دێڕەکانی خوێندنەوە لەناو بلۆکی withـدا بە بۆشایی بخەرە ژوورەوە، ئەگینا Python ValueError: I/O operation on closed file. دروست دەکات.

Next, Moving in a File and Saving Python Objects shows how to move the file position with tell() and seek() and how to save whole lists and dictionaries with pickle or JSON. Files are the first step in keeping data. When many programs and many users must share large amounts of data safely, files are not enough, and a database takes over (The file-based approach shows why). Other technologies handle files too: a web server receives uploaded files in PHP file uploads, and a phone app keeps its data with local storage in Flutter.

دواتر، وانەی جووڵە لەناو فایلێکدا و هەڵگرتنی ئۆبجێکتەکانی Python فێرت دەکات چۆن شوێنی فایلەکە بە tell() و seek() بجووڵێنیت و چۆن لیستەکان و فەرهەنگەکان (Dictionary) بە pickle یان JSON هەڵبگریت. فایلەکان یەکەم هەنگاون بۆ پاراستنی دراوە. کاتێک زۆر بەرنامە و زۆر بەکارهێنەر دەبێت بڕێکی زۆر دراوە بە سەلامەتی هاوبەش بکەن، فایلەکان بەس نین و بنکەدراوەیەک جێیان دەگرێتەوە (سیستەمی پشتبەستوو بە فایل پیشان دەدات بۆچی). تەکنەلۆجیاکانی تریش مامەڵە لەگەڵ فایل دەکەن: ڕاژەکارێکی وێب (Web server) فایلەکانی بارکراو وەردەگرێت لە بارکردنی فایل لە PHPـدا و ئەپێکی مۆبایل دراوەکانی خۆی دەپارێزێت بە خەزنکردنی ناوخۆیی لە Flutterـدا.