الإملاء والملف في بايثون
تنظيم صفحاتك في مجموعات
يمكنك حفظ المحتوى وتصنيفه حسب إعداداتك المفضّلة.
جدول تجزئة الإملاء
يُطلق على بنية جدول تجزئة المفتاح/القيمة الفعّالة في بايثون اسم "dict". يمكن كتابة محتوى الأمر كسلسلة من أزواج المفتاح/القيمة داخل الأقواس { }، على سبيل المثال dict = {key1:value1, key2:value2, ... }. "الإملاء الفارغ" هو مجرد زوج فارغ من الأقواس المعقوفة {}.
يمكن استخدام أقواس مربّعة للبحث عن قيمة أو ضبطها في القاموس، على سبيل المثال. يبحث الأمر dict['foo'] عن القيمة ضمن المفتاح 'foo'. تعمل السلاسل والأرقام والصفوف كمفاتيح، ويمكن أن يكون أي نوع قيمة. قد تعمل الأنواع الأخرى أو لا تعمل بشكل صحيح كمفاتيح (تعمل السلاسل والصفوف بسلاسة لأنها غير قابلة للتغيير). يؤدي البحث عن قيمة ليست في القاموس إلى عرض خطأ KeyError -- استخدام "in" للتحقق مما إذا كان المفتاح في القاموس، أو استخدم dict.get(key) التي تعرض القيمة أو None إذا كان المفتاح غير موجود (أو يسمح لك get(key, not-found) بتحديد القيمة التي تريد عرضها في حالة عدم العثور عليها).
## Can build up a dict by starting with the empty dict {}
## and storing key/value pairs into the dict like this:
## dict[key] = value-for-that-key
dict = {}
dict['a'] = 'alpha'
dict['g'] = 'gamma'
dict['o'] = 'omega'
print(dict) ## {'a': 'alpha', 'o': 'omega', 'g': 'gamma'}
print(dict['a']) ## Simple lookup, returns 'alpha'
dict['a'] = 6 ## Put new key/value into dict
'a' in dict ## True
## print(dict['z']) ## Throws KeyError
if 'z' in dict: print(dict['z']) ## Avoid KeyError
print(dict.get('z')) ## None (instead of KeyError)
يتكرر التكرار الحلقي for في القاموس على مفاتيحه افتراضيًا. ستظهر المفاتيح بترتيب عشوائي. تُرجع الطريقتان dict.keys() وdict.values() قوائم بالمفاتيح أو القيم بشكل صريح. هناك أيضًا items() التي تُرجع قائمة بالصفوف (المفتاح، القيمة)، وهي الطريقة الأكثر فاعلية لفحص جميع بيانات القيمة الرئيسية في القاموس. يمكن تمرير جميع هذه القوائم إلى الدالة sorted().
## By default, iterating over a dict iterates over its keys.
## Note that the keys are in a random order.
for key in dict:
print(key)
## prints a g o
## Exactly the same as above
for key in dict.keys():
print(key)
## Get the .keys() list:
print(dict.keys()) ## dict_keys(['a', 'o', 'g'])
## Likewise, there's a .values() list of values
print(dict.values()) ## dict_values(['alpha', 'omega', 'gamma'])
## Common case -- loop over the keys in sorted order,
## accessing each key/value
for key in sorted(dict.keys()):
print(key, dict[key])
## .items() is the dict expressed as (key, value) tuples
print(dict.items()) ## dict_items([('a', 'alpha'), ('o', 'omega'), ('g', 'gamma')])
## This loop syntax accesses the whole dict by looping
## over the .items() tuple list, accessing one (key, value)
## pair on each iteration.
for k, v in dict.items(): print(k, '>', v)
## a > alpha o > omega g > gamma
ملاحظة حول الإستراتيجية: من منظور الأداء، يُعد القاموس أحد أعظم أدواتك، ويجب استخدامه حيث يمكنك استخدامه كطريقة سهلة لتنظيم البيانات. على سبيل المثال، قد تقرأ ملف سجلّ يبدأ فيه كل سطر بعنوان IP، وتخزن البيانات في إملاء باستخدام عنوان IP كمفتاح، وقائمة الأسطر التي يظهر فيها كقيمة. بمجرد قراءة الملف بأكمله، يمكنك البحث عن أي عنوان IP وعرض قائمة السطور الخاصة به على الفور. يأخذ القاموس البيانات المبعثرة ويجعلها شيئًا مترابطًا.
يعمل عامل التشغيل % بشكل ملائم لاستبدال القيم من الإملاء في سلسلة بالاسم:
h = {}
h['word'] = 'garfield'
h['count'] = 42
s = 'I want %(count)d copies of %(word)s' % h # %d for int, %s for string
# 'I want 42 copies of garfield'
# You can also use str.format().
s = 'I want {count:d} copies of {word}'.format(h)
حذف
إن "ديل" عمليات الحذف. في أبسط الحالات، يمكنه إزالة تعريف متغير، كما لو لم يتم تحديد ذلك المتغير. يمكن أيضًا استخدام ديل في عناصر القائمة أو الشرائح لحذف هذا الجزء من القائمة وحذف الإدخالات من القاموس.
var = 6
del var # var no more!
list = ['a', 'b', 'c', 'd']
del list[0] ## Delete first element
del list[-2:] ## Delete last two elements
print(list) ## ['b']
dict = {'a':1, 'b':2, 'c':3}
del dict['b'] ## Delete 'b' entry
print(dict) ## {'a':1, 'c':3}
الملفات
تفتح الدالة open() وترجع مؤشر ملف يمكن استخدامه لقراءة ملف أو كتابته بالطريقة المعتادة. التعليمة البرمجية f = open('name', 'r') تفتح الملف في المتغير f، جاهزًا لعمليات القراءة، ويستخدم f.Close() عند الانتهاء. بدلاً من "r"، استخدِم "w" للكتابة، و"a" من أجل append. تعمل الحلقة القياسية للملفات النصية، وتتكرر عبر أسطر الملف (هذا يعمل فقط مع الملفات النصية، وليس الملفات الثنائية). أسلوب التكرار الحلقي هو طريقة بسيطة وفعالة للنظر في جميع الأسطر في ملف نصي:
# Echo the contents of a text file
f = open('foo.txt', 'rt', encoding='utf-8')
for line in f: ## iterates over the lines of the file
print(line, end='') ## end='' so print does not add an end-of-line char
## since 'line' already includes the end-of-line.
f.close()
تتمتع قراءة سطر واحد في كل مرة بجودة جيدة لا يحتاج كل الملف إلى استخدامها في الذاكرة في وقت واحد -- وهو أمر مفيد إذا كنت تريد الاطلاع على كل سطر في ملف 10 غيغابايت دون استخدام 10 غيغابايت من الذاكرة. تقرأ الطريقة f.readlines() الملف بأكمله في الذاكرة وتعرض محتوياته كقائمة سطوره. تقرأ الطريقة f.read() الملف بأكمله في سلسلة واحدة، والتي يمكن أن تكون طريقة سهلة للتعامل مع النص مرة واحدة، كما هو الحال مع التعبيرات العادية التي ستراها لاحقًا.
للكتابة، تعد طريقة f.write(string) أسهل طريقة لكتابة البيانات في ملف إخراج مفتوح. أو يمكنك استخدام "الطباعة" بملف مفتوح مثل "print(string, file=f)".
يونيكود للملفات
لقراءة وكتابة الملفات بترميز يونيكود، يجب استخدام وضع "'t" وتحديد الترميز بشكل صريح:
with open('foo.txt', 'rt', encoding='utf-8') as f:
for line in f:
# here line is a *unicode* string
with open('write_test', encoding='utf-8', mode='wt') as f:
f.write('\u20ACunicode\u20AC\n') # €unicode€
# AKA print('\u20ACunicode\u20AC', file=f) ## which auto-adds end='\n'
التنمية التزايدية في التمارين
عند إنشاء برنامج بايثون، لا تكتب كل شيء في خطوة واحدة. بدلاً من ذلك، حدد المعلم الرئيسي الأول فقط، على سبيل المثال "حسنًا، الخطوة الأولى هي استخراج قائمة الكلمات". اكتب التعليمة البرمجية للوصول إلى هذا المعلم الرئيسي، واطبع فقط هياكل البيانات في هذه المرحلة، ثم يمكنك إجراء sys.exit(0) حتى لا يبدأ البرنامج في العمل إلى أجزائه غير المكتملة. بمجرد عمل رمز المعلم الرئيسي، يمكنك العمل على رمز المعلم الرئيسي التالي. يمكن أن تساعدك القدرة على إلقاء نظرة على النسخة المطبوعة من المتغيرات الخاصة بك في حالة واحدة في التفكير في كيفية تحويل هذه المتغيرات للوصول إلى الحالة التالية. تتميز بايثون بسرعة كبيرة باستخدام هذا النمط، فهي تتيح لك إجراء تغيير بسيط وتشغيل البرنامج للتعرف على طريقة عمله. استفد من هذا التحول السريع لبناء برنامجك بخطوات بسيطة.
تمرين: wordcount.py
عند الجمع بين جميع مواد بايثون الأساسية، مثل السلاسل، والقوائم، والإملاء، والصفوف، والملفات -- جرّب تمرين الملخص wordcount.py في التمارين الأساسية.
إنّ محتوى هذه الصفحة مرخّص بموجب ترخيص Creative Commons Attribution 4.0 ما لم يُنصّ على خلاف ذلك، ونماذج الرموز مرخّصة بموجب ترخيص Apache 2.0. للاطّلاع على التفاصيل، يُرجى مراجعة سياسات موقع Google Developers. إنّ Java هي علامة تجارية مسجَّلة لشركة Oracle و/أو شركائها التابعين.
تاريخ التعديل الأخير: 2025-07-24 (حسب التوقيت العالمي المتفَّق عليه)
[[["يسهُل فهم المحتوى.","easyToUnderstand","thumb-up"],["ساعَدني المحتوى في حلّ مشكلتي.","solvedMyProblem","thumb-up"],["غير ذلك","otherUp","thumb-up"]],[["لا يحتوي على المعلومات التي أحتاج إليها.","missingTheInformationINeed","thumb-down"],["الخطوات معقدة للغاية / كثيرة جدًا.","tooComplicatedTooManySteps","thumb-down"],["المحتوى قديم.","outOfDate","thumb-down"],["ثمة مشكلة في الترجمة.","translationIssue","thumb-down"],["مشكلة في العيّنات / التعليمات البرمجية","samplesCodeIssue","thumb-down"],["غير ذلك","otherDown","thumb-down"]],["تاريخ التعديل الأخير: 2025-07-24 (حسب التوقيت العالمي المتفَّق عليه)"],[[["\u003cp\u003ePython uses a "dict" to store key-value pairs, supporting lookups, insertions, and deletions using brackets and built-in methods.\u003c/p\u003e\n"],["\u003cp\u003eIteration over a dict's keys, values, or items is facilitated by methods like \u003ccode\u003ekeys()\u003c/code\u003e, \u003ccode\u003evalues()\u003c/code\u003e, and \u003ccode\u003eitems()\u003c/code\u003e, enabling flexible data processing.\u003c/p\u003e\n"],["\u003cp\u003eFiles in Python are accessed using \u003ccode\u003eopen()\u003c/code\u003e, with modes for reading, writing, and appending, and can be iterated line by line for efficient processing.\u003c/p\u003e\n"],["\u003cp\u003eUnicode files should be opened with the 't' mode and encoding explicitly specified for proper handling of characters.\u003c/p\u003e\n"],["\u003cp\u003eIncremental development is encouraged, where programs are built in stages, focusing on individual milestones and data structure verification.\u003c/p\u003e\n"]]],[],null,["# Python Dict and File\n\nDict Hash Table\n---------------\n\nPython's efficient key/value hash table structure is called a \"dict\". The contents of a dict can be written as a series of key:value pairs within braces { }, e.g. dict = {key1:value1, key2:value2, ... }. The \"empty dict\" is just an empty pair of curly braces {}.\n\nLooking up or setting a value in a dict uses square brackets, e.g. dict\\['foo'\\] looks up the value under the key 'foo'. Strings, numbers, and tuples work as keys, and any type can be a value. Other types may or may not work correctly as keys (strings and tuples work cleanly since they are immutable). Looking up a value which is not in the dict throws a KeyError -- use \"in\" to check if the key is in the dict, or use dict.get(key) which returns the value or None if the key is not present (or get(key, not-found) allows you to specify what value to return in the not-found case). \n\n```python\n ## Can build up a dict by starting with the empty dict {}\n ## and storing key/value pairs into the dict like this:\n ## dict[key] = value-for-that-key\n dict = {}\n dict['a'] = 'alpha'\n dict['g'] = 'gamma'\n dict['o'] = 'omega'\n\n print(dict) ## {'a': 'alpha', 'o': 'omega', 'g': 'gamma'}\n\n print(dict['a']) ## Simple lookup, returns 'alpha'\n dict['a'] = 6 ## Put new key/value into dict\n 'a' in dict ## True\n ## print(dict['z']) ## Throws KeyError\n if 'z' in dict: print(dict['z']) ## Avoid KeyError\n print(dict.get('z')) ## None (instead of KeyError)\n```\n\n\nA for loop on a dictionary iterates over its keys by default. The keys will appear in an arbitrary order. The methods dict.keys() and dict.values() return lists of the keys or values explicitly. There's also an items() which returns a list of (key, value) tuples, which is the most efficient way to examine all the key value data in the dictionary. All of these lists can be passed to the sorted() function. \n\n```python\n ## By default, iterating over a dict iterates over its keys.\n ## Note that the keys are in a random order.\n for key in dict:\n print(key)\n ## prints a g o\n\n ## Exactly the same as above\n for key in dict.keys():\n print(key)\n\n ## Get the .keys() list:\n print(dict.keys()) ## dict_keys(['a', 'o', 'g'])\n\n ## Likewise, there's a .values() list of values\n print(dict.values()) ## dict_values(['alpha', 'omega', 'gamma'])\n\n ## Common case -- loop over the keys in sorted order,\n ## accessing each key/value\n for key in sorted(dict.keys()):\n print(key, dict[key])\n\n ## .items() is the dict expressed as (key, value) tuples\n print(dict.items()) ## dict_items([('a', 'alpha'), ('o', 'omega'), ('g', 'gamma')])\n\n ## This loop syntax accesses the whole dict by looping\n ## over the .items() tuple list, accessing one (key, value)\n ## pair on each iteration.\n for k, v in dict.items(): print(k, '\u003e', v)\n ## a \u003e alpha o \u003e omega g \u003e gamma\n```\n\nStrategy note: from a performance point of view, the dictionary is one of your greatest tools, and you should use it where you can as an easy way to organize data. For example, you might read a log file where each line begins with an IP address, and store the data into a dict using the IP address as the key, and the list of lines where it appears as the value. Once you've read in the whole file, you can look up any IP address and instantly see its list of lines. The dictionary takes in scattered data and makes it into something coherent.\n\nDict Formatting\n---------------\n\nThe % operator works conveniently to substitute values from a dict into a string by name: \n\n```python\n h = {}\n h['word'] = 'garfield'\n h['count'] = 42\n s = 'I want %(count)d copies of %(word)s' % h # %d for int, %s for string\n # 'I want 42 copies of garfield'\n\n # You can also use str.format().\n s = 'I want {count:d} copies of {word}'.format(h)\n```\n\nDel\n---\n\nThe \"del\" operator does deletions. In the simplest case, it can remove the definition of a variable, as if that variable had not been defined. Del can also be used on list elements or slices to delete that part of the list and to delete entries from a dictionary. \n\n```python\n var = 6\n del var # var no more!\n\n list = ['a', 'b', 'c', 'd']\n del list[0] ## Delete first element\n del list[-2:] ## Delete last two elements\n print(list) ## ['b']\n\n dict = {'a':1, 'b':2, 'c':3}\n del dict['b'] ## Delete 'b' entry\n print(dict) ## {'a':1, 'c':3}\n```\n\nFiles\n-----\n\nThe open() function opens and returns a file handle that can be used to read or write a file in the usual way. The code f = open('name', 'r') opens the file into the variable f, ready for reading operations, and use f.close() when finished. Instead of 'r', use 'w' for writing, and 'a' for append. The standard for-loop works for text files, iterating through the lines of the file (this works only for text files, not binary files). The for-loop technique is a simple and efficient way to look at all the lines in a text file: \n\n```python\n # Echo the contents of a text file\n f = open('foo.txt', 'rt', encoding='utf-8')\n for line in f: ## iterates over the lines of the file\n print(line, end='') ## end='' so print does not add an end-of-line char\n ## since 'line' already includes the end-of-line.\n f.close()\n```\n\nReading one line at a time has the nice quality that not all the file needs to fit in memory at one time -- handy if you want to look at every line in a 10 gigabyte file without using 10 gigabytes of memory. The f.readlines() method reads the whole file into memory and returns its contents as a list of its lines. The f.read() method reads the whole file into a single string, which can be a handy way to deal with the text all at once, such as with regular expressions we'll see later.\n\nFor writing, f.write(string) method is the easiest way to write data to an open output file. Or you can use \"print\" with an open file like \"print(string, file=f)\".\n\nFiles Unicode\n-------------\n\nTo read and write unicode encoded files use a \\`'t'\\` mode and explicitly specify an encoding: \n\n```python\nwith open('foo.txt', 'rt', encoding='utf-8') as f:\n for line in f:\n # here line is a *unicode* string\n\nwith open('write_test', encoding='utf-8', mode='wt') as f:\n f.write('\\u20ACunicode\\u20AC\\n') # €unicode€\n # AKA print('\\u20ACunicode\\u20AC', file=f) ## which auto-adds end='\\n'\n```\n\nExercise Incremental Development\n--------------------------------\n\nBuilding a Python program, don't write the whole thing in one step. Instead identify just a first milestone, e.g. \"well the first step is to extract the list of words.\" Write the code to get to that milestone, and just print your data structures at that point, and then you can do a sys.exit(0) so the program does not run ahead into its not-done parts. Once the milestone code is working, you can work on code for the next milestone. Being able to look at the printout of your variables at one state can help you think about how you need to transform those variables to get to the next state. Python is very quick with this pattern, allowing you to make a little change and run the program to see how it works. Take advantage of that quick turnaround to build your program in little steps.\n\nExercise: wordcount.py\n----------------------\n\nCombining all the basic Python material -- strings, lists, dicts, tuples, files -- try the summary **wordcount.py** exercise in the [Basic Exercises](/edu/python/exercises/basic)."]]
