Advanced Python Material PDF

‫‪Machine Translated by Google‬‬
‫ﺑ ﺲ‬ ‫ُ‬
‫أوو‬
‫اﻟﺠﺰء ‪- 1‬‬
‫ﺜﺎﻧﻴ ﺔ ‪040 - 64 51 27 86، 80 96 96 96 96، 92 46 21 21 43 | www.durgasoft.com‬‬ ‫اﻟ‬
‫‪1‬‬
‫‪ ،DURGASOFT،‬ﺣﻴﺪر أ‬
‫ﺑﺎد ‪- 500038 ،‬‬ ‫ﺑﻴ ﺖ‬ ‫ﺘﺮ‪#‬‬
‫ﻳﻔﺎﻧﺎم ‪ ،‬أﻣﻴﺮ‬ ‫‪202،‬‬ ‫ﺑﻖ ‪2 ،‬‬
‫ﻫﺪى ﻣﺎﻳ‬ ‫اﻟﻄﺎ‬
‫ﺒﻘ ﺔ‪:‬‬
‫ﻣﺎ ﻫ ﻲ اﻟﻄ‬
‫ﺒﺎﻋ ﺔ زرﻗﺎء ‪ ،‬و ﻫ ﻲ ﻟﻴ ﺴ ﺖﺳﻮى ﻓﺌ ﺔ‪.‬‬

‫ﺟﺎ أو ﺧﻄ ﺔ أو ﻃ‬
‫ﺒﻨﺎ ﻧﻤﻮذ ً‬
‫ﺜﻮن ﻛﻞ ﺷ ﻲء ﻫﻮ ﻛﺎﺋﻦ‪ .‬ﻹﻧﺸﺎء ﻛﺎﺋﻨﺎ ت ‪ ،‬ﻃﻠ‬
‫ﺑﺎﻳ‬‫ﻓﻲ‬
‫ﺜﻴﻞ ﺧﺼﺎﺋﺺ )ﺳﻤﺎ ت( وأﻓﻌﺎل )ﺳﻠﻮك(‬

‫ﺘﻤ‬‫ﺑ ﺔ ﻓﺌ ﺔ ﻟ‬
‫ﺘﺎ‬
‫ﻳﻤﻜﻨﻨﺎ ﻛ‬
‫ﻫﺪف‪.‬‬
‫ﺘﻐﻴﺮا ت‬
‫ﺑﺎﻟﻤ‬‫ﺜﻴﻞ اﻟﺨﺼﺎﺋﺺ‬
‫ﻳﻤﻜﻦﺗﻤ‬
‫ﺑﺎﻟﻄﺮق ‪.‬‬‫ﺜﻴﻞ اﻹﺟﺮاءا ت‬
‫ﻳﻤﻜﻦﺗﻤ‬
‫ﺘﻐﻴﺮا ت واﻟﻄﺮق‪.‬‬
‫ﺘﻮي اﻟﻔﺌ ﺔ ﻋﲆ ﻛﻞ ﻣﻦ اﻟﻤ‬
‫ﺛﻢﺗﺤ‬‫وﻣﻦ‬
‫ﻛﻴﻒﺗﺤﺪد ﻓﺌ ﺔ؟‬
‫ﺘﺨﺪام اﻟﻜﻠﻤ ﺔ اﻷﺳﺎﺳﻴ ﺔ ﻟﻠﻔﺼﻞ‪.‬‬
‫ﺑﺎﺳ‬‫ﻳﻤﻜﻨﻨﺎﺗﺤﺪﻳﺪ ﻓﺌ ﺔ‬
‫ﺑﻨﺎء اﻟﺠﻤﻠ ﺔ‪:‬‬

‫ﻓﺌ ﺔ اﻻﺳﻢ‪:‬‬
‫""‬ ‫""‬
‫ﺘ ﺔ واﻟﻤﺤﻠﻴ ﺔ‬
‫ﺑ‬‫ﺜﺎ‬
‫ﺘﻐﻴﺮا ت اﻟ‬
‫ﺘﻐﻴﺮا ت اﻟﺤﺎﻟ ﺔ ‪ ،‬اﻟﻤ‬
‫ﺛﻴﻖ‪ :‬ﻣ‬
‫ﺘﻮ‬‫ﺘﻐﻴﺮا تﺳﻠ ﺴﻠ ﺔ اﻟ‬
‫ﻣ‬
‫ﺘ ﺔ ‪ ،‬ﻃﺮق اﻟﻔﺼﻞ‬
‫ﺜﻴﻞ ‪ ،‬اﻟﻄﺮق اﻟ‬
‫اﻟﻄﺮق‪ :‬ﻃﺮق اﻟﻤ‬
‫ﺘﻴﻦ‬
‫ﺘﺨﺪام اﻟﻄﺮﻳﻘ‬
‫ﺑﺎﺳ‬
‫ﺋﻤﺎ‪.‬ﻳﻤﻜﻨﻨﺎ اﻟﺤﺼﻮل ﻋﲆﺳﻠ ﺴﻠ ﺔ ‪doc‬‬ ‫ﺛﺎﺋﻖ وﺻ ًﻔﺎ ﻟﻠﻔﺌ ﺔ‪ .‬ﺿﻤﻦﺳﻠ ﺴﻠ ﺔ ‪doc‬ﻟﻠﻔﺌ ﺔ اﺧ‬
‫ﺘﻴﺎرﻳ ﺔ دا ً‬ ‫ﺜﻞﺳﻠ ﺴﻠ ﺔ اﻟﻮ‬
‫ﺗﻤ‬
‫ﺘﻴﻦ‪.‬‬
‫ﺘﺎﻟﻴ‬
‫اﻟ‬
‫ﺒﺎﻋ ﺔ )__‪(classname .__ doc‬‬

‫)‪1‬ﻃ‬
‫)‪2‬ﻣ ﺴﺎﻋﺪة )‪(classname‬‬
‫ﺜﺎل‪:‬‬
‫ﻣ‬
‫ﺒﻊ )اﻟﻄﺎﻟ ﺐ ‪__.‬‬

‫)‪1‬ﻃﺎﻟ ﺐ اﻟﻔﺼﻞ ‪2) 3) :‬اﻃ‬
‫'' ''‬
‫ﺘﻨﺪ )‪_) 4‬اﻟﻤ ﺴﺎﻋﺪة )اﻟﻄﺎﻟ ﺐ(‬
‫ﺴ ""‬
‫ﺑﺔ‬‫اﻟﻤ‬
‫ﺒﻴﺎﻧﺎ ت اﻟﻤﻄﻠﻮ‬
‫ﻫﺬا ﺻﻒ اﻟﻄﺎﻟ ﺐ ﻣﻊ اﻟ‬
‫ﺘﻐﻴﺮا ت‪.‬‬
‫ﺘﺨﺪام اﻟﻤ‬
‫ﺑﺎﺳ‬‫ﺒﻴﺎﻧﺎ ت‬
‫ﺜﻴﻞ اﻟ‬
‫ﺜﻮنﻳﻤﻜﻨﻨﺎﺗﻤ‬
‫ﺑﺎﻳ‬‫ﺿﻤﻦ ﻓﺌ ﺔ‬
‫ﺑﻬﺎ‪.‬‬‫ﺘﻐﻴﺮا ت ﻣ ﺴﻤﻮح‬
‫ﻫﻨﺎك ‪3‬أﻧﻮاع ﻣﻦ اﻟﻤ‬
‫ﺘﻮى اﻟﻜﺎﺋﻦ(‬
‫ﺘﻐﻴﺮا ت ﻣ ﺴ‬
‫ﺜﻴﻞ )ﻣ‬
‫ﺘﻐﻴﺮا ت اﻟﻤ‬
‫)‪1‬ﻣ‬
‫ﺘﻮى اﻟﻔﺌ ﺔ(‬
‫ﺘ ﺔ )ﻣ‬
‫)‪2‬اﻟﻤ‬
‫ﺘﻮى اﻟﻄﺮﻳﻘ ﺔ(‬
‫ﺘﻐﻴﺮا ت اﻟﻤﺤﻠﻴ ﺔ )ﻣ‬
‫)‪3‬اﻟﻤ‬
‫ﺜﺎﻧﻴ ﺔ دورﺟﺎﺳﻮﻓ ﺖ ‪ ،‬رﻗﻢ ‪202 ، 2‬‬‫اﻟ‬
‫‪2‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫ﺑﻴ ﺖ ‪ ،‬ﺣﻴﺪر أ‬
‫ﺘﺮﻳﻔﺎﻧﺎم ‪ ،‬أﻣﻴﺮ‬
‫ﺑﻖ ‪ ،‬ﻫﺪى ﻣﺎﻳ‬
‫اﻟﻄﺎ‬
‫‪040-64 51 27 86 ، 80 96 96 96 96 ، 92 46 21 21 43 | www.durgasoft.com‬‬
‫ﺑﻬﺎ‬‫ﺘﻠﻔ ﺔ ﻣﻦ اﻟﻄﺮق اﻟﻤ ﺴﻤﻮح‬

‫ﺘﺨﺪام اﻟﻄﺮق‪ .‬ﻓﻴﻤﺎﻳﻠ ﻲ أﻧﻮاع ﻣﺨ‬
‫ﺑﺎﺳ‬‫ﺜﻴﻞ اﻟﻌﻤﻠﻴﺎ ت‬
‫ﺿﻤﻦ ﻓﺌ ﺔ ‪Python ،‬ﻳﻤﻜﻨﻨﺎﺗﻤ‬
‫ﺜﻴﻞ‬
‫)‪1‬ﻃﺮق اﻟﻤ‬
‫)‪2‬ﻃﺮق اﻟﻔﺼﻞ‬
‫ﺘﺔ‬
‫)‪3‬اﻟﻄﺮق اﻟ‬
‫ﺜﺎل ﻟﻠﻔﺼﻞ‪:‬‬
‫ﻣ‬
‫)‪1‬ﻃﺎﻟ ﺐ ﻓﺌ ﺔ ‪2) :‬‬

‫ﺑﻮاﺳﻄ ﺔ ‪durga‬ﻟـ ‪self.marks = 80 7) 8) def‬‬‫ﺗﻢﺗﻄﻮﻳﺮه‬
‫'' ''‬
‫)‪__init __ (self): 4) self.name = 'durga' 5) self.age = 40 6‬‬
‫ﺗ ﻲ(‪9) 10) 11) :‬‬
‫‪python demo '' 3) def‬ﺣﺪﻳ ﺚ )ذا‬
‫)‪print ("My Marks are:"، self.marks‬‬

‫)‪self.name) print ("My Age is:"، self.age‬‬
‫‪print ("Hello I am :"،‬‬
‫ﻣﺎ ﻫﻮ اﻟﻜﺎﺋﻦ‪:‬‬
‫ﺒﻘ ﺔ ﻣﺎ ﻫﻮ إﻻ ﻛﺎﺋﻦ‪.‬ﻳﻤﻜﻨﻨﺎ إﻧﺸﺎء أي ﻋﺪد ﻣﻦ اﻟﻌﻨﺎﺻﺮ ﻟﻠﻔﺼﻞ‪.‬‬
‫إن اﻟﻮﺟﻮد اﻟﻤﺎدي ﻟﻠﻄ‬
‫ﺑﻨﺎء اﻟﺠﻤﻠ ﺔ ﻹﻧﺸﺎء ﻛﺎﺋﻦ‪Referencevariable = classname () :‬‬
‫ﺜﺎل‪s = Student () :‬‬

‫ﻣ‬
‫ﺘﻐﻴﺮ اﻟﻤﺮﺟﻌ ﻲ؟‬

‫ﻣﺎ ﻫﻮ اﻟﻤ‬
‫ﺘﻐﻴﺮ اﻟﻤﺮﺟﻌ ﻲ‪.‬‬
‫ﺘﺨﺪاﻣﻪ ﻟﻺﺷﺎرة إﱃ اﻟﻜﺎﺋﻦﻳ ﺴﻤﻰ اﻟﻤ‬
‫ﺘﻐﻴﺮ اﻟﺬيﻳﻤﻜﻦ اﺳ‬
‫اﻟﻤ‬
‫ﺘﻐﻴﺮ اﻟﻤﺮﺟﻌ ﻲ ‪،‬ﻳﻤﻜﻨﻨﺎ اﻟﻮﺻﻮل إﱃ ﺧﺼﺎﺋﺺ وأﺳﺎﻟﻴ ﺐ اﻟﻜﺎﺋﻦ‪.‬‬
‫ﺑﺎﺳ‬
‫ﺑﺮﻧﺎﻣﺞ ‪Python‬ﻹﻧﺸﺎء ﻓﺼﻞ دراﺳ ﻲ ﻟﻠﻄﻼ ب وإﻧﺸﺎء ﻛﺎﺋﻦ ﻟﻪ‪.‬‬‫ﺘﺐ‬

‫ﺒﺮﻧﺎﻣﺞ‪ :‬اﻛ‬
‫اﻟ‬
‫ﺑﻄﺮﻳﻘ ﺔ )( ‪talk‬ﻟﻌﺮضﺗﻔﺎﺻﻴﻞ اﻟﻄﺎﻟ ﺐ‬‫ﺗﺼﻞ‬
‫ا‬
‫‪class Student: 2) 3) def __init __ (self، name، rollno،‬‬

‫)‪1‬اﻟﻌﻼﻣﺎ ت(‪4) 5) 6) 7) :‬‬
‫= ‪self.name‬اﻻﺳﻢ =‬
‫‪= rollno self.marks‬‬
‫‪self.rollno‬اﻟﻌﻼﻣﺎ ت‬
‫‪3‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫= ‪8) def talk (self): 9) 10) 11) 12) 13) s1‬‬

‫)‪101،80)self.rollno‬‬
‫‪14) s1.talkprint‬‬
‫)"دورﺟﺎ"‪() ،‬‬ ‫)‪ are:"، self.marks‬اﻟﻄﺎﻟ ﺐ‬
‫‪("My Marks‬‬
‫‪My Name is:"، self.name) print ("My Rollno is:"،‬‬
‫‪print ("Hello‬‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫‪D: \ durgaclasses> py test.py‬‬
‫ﺒﺎ اﺳﻤ ﻲ‪ :‬دورﺟﺎ‬
‫ﻣﺮﺣ‬
‫ﺑ ﻲ ﻫﻮ‪101 :‬‬‫روﻟﻨﻮ اﻟﺨﺎص‬
‫ﺗ ﻲ ﻫ ﻲ‪80 :‬‬
‫ﻋﻼﻣﺎ‬
‫ﺗ ﻲ‪:‬‬
‫ﺘﻐﻴﺮ اﻟﺬا‬
‫اﻟﻤ‬
‫ﺜﻞ ﻫﺬه اﻟﻜﻠﻤ ﺔ اﻷﺳﺎﺳﻴ ﺔ‬
‫ﺋﻤﺎ إﱃ اﻟﻜﺎﺋﻦ اﻟﺤﺎﻟ ﻲ )ﻣ‬
‫ﺘﺮاﺿ ﻲ اﻟﺬيﻳﺸﻴﺮ دا ً‬
‫ﺘﻐﻴﺮ اﻻﻓ‬
‫‪ • self‬ﻫﻮ اﻟﻤ‬
‫ﻓ ﻲ ﺟﺎﻓﺎ(‬
‫ﺜﻴﻞ ﻟﻠﻜﺎﺋﻦ‪.‬‬
‫ﺘﻐﻴﺮا ت اﻟﺤﺎﻟ ﺔ وﻃﺮق اﻟﻤ‬
‫ﺘﺨﺪام اﻟﺬا تﻳﻤﻜﻨﻨﺎ اﻟﻮﺻﻮل إﱃ ﻣ‬
‫ﺑﺎﺳ‬
‫•‬
‫ﻣﻠﺤﻮﻇ ﺔ‪:‬‬
‫اﻟﻤﻨﺸ ﺊ ‪def __init __ (self):‬‬
‫)‪1‬ﻳﺠ ﺐ أنﺗﻜﻮن ‪self‬اﻟﻤﻌﻠﻤ ﺔ اﻷوﱃ داﺧﻞ ُ‬
‫ﺜﻴﻞ‬
‫)‪2‬ﻳﺠ ﺐ أنﺗﻜﻮن ‪self‬اﻟﻤﻌﻠﻤ ﺔ اﻷوﱃ داﺧﻞ ﻃﺮق اﻟﻤ‬
‫ﺗﺤﺪ ث ﻣﻮاﻃﻨﻪ )اﻟﺬا ت(‪:‬‬
‫ﻣﻔﻬﻮم اﻟﻤﻨﺸ ﺊ‪:‬‬

‫ﺜﻮن‪.‬‬
‫ﺑﻴ‬‫ﻣﻨﺸ ﺊ ﻃﺮﻳﻘ ﺔ ﺧﺎﺻ ﺔ ﻓ ﻲ‬
‫ﺗ ًﻴﺎ(‬
‫اﻟﻤﻨﺸ ﺊ __ ‪)__init‬ذا‬
‫ﻳﺠ ﺐ أنﻳﻜﻮن اﺳﻢ ُ‬
‫اﻟﻤﻨﺸ ﺊﺗﻠﻘﺎﺋ ًﻴﺎ ﻓ ﻲ وﻗ ﺖ إﻧﺸﺎء اﻟﻜﺎﺋﻦ‪.‬‬
‫ﺘﻢﺗﻨﻔﻴﺬ ُ‬
‫ﺳﻴ‬
‫ﺘﻬﺎ‪.‬‬
‫ﺗﻬﻴﺌ‬
‫ﺘﻐﻴﺮا ت اﻟﺤﺎﻟ ﺔ و‬
‫ﺘﺼﺮﻳﺢ ﻋﻦ ﻣ‬
‫ﺋﻴ ﺴ ﻲ ﻟﻠﻤﻨﺸ ﺊ ﻫﻮ اﻟ‬
‫اﻟﻐﺮض اﻟﺮ‬
‫ﺘﻢ إﺧﺮاجُﻣﻨﺸ ﺊ ﻛﻞ ﻛﺎﺋﻦ ﻣﺮة واﺣﺪة ﻓﻘﻂ‪.‬‬

‫ﺳﻴ‬
‫ﺗ ًﻴﺎ(‬
‫ﻟﻠﻤﻨﺸ ﺊ أنﻳﺄﺧﺬ ﺣﺠ ﺔ واﺣﺪة ﻋﲆ اﻷﻗﻞ )ﻋﲆ اﻷﻗﻞ ذا‬
‫ﻳﻤﻜﻦ ُ‬
‫ﺑﺬﻟﻚ‬‫ﺜﻮن‬
‫ﺑﻴ‬‫ﺘﻴﺎري وإذا ﻟﻢ ﻧﻮﻓﺮ أيُﻣﻨﺸ ﺊ ‪ ،‬ﻓ ﺴﻴﻘﻮم‬
‫اﻟﻤﻨﺸ ﺊ اﺧ‬
‫ُ‬
‫ﺘﺮاﺿ ﻲ‪.‬‬
‫اﻟﻤﻨﺸ ﺊ اﻻﻓ‬
‫ﺗﻮﻓﺮ ُ‬
‫ﺜﺎل‪:‬‬
‫ﻣ‬
‫= ‪= name 3) self.rollno = rollno 4) self.marks‬‬

‫‪def __init __ (self، name، rollno، mark): 2) self.name‬‬
‫)‪1‬ﻋﻼﻣﺎ ت‬
‫‪4‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫اﻟﻤﻨﺸ ﺊ ﻣﺮة واﺣﺪة ﻓﻘﻂ ﻟﻜﻞ ﻛﺎﺋﻦ‪:‬‬

‫ﺑﺮﻧﺎﻣﺞ ﺷﻴﻄﺎﻧﻴ ﺔ ُ‬‫ﺘﻢﺗﻨﻔﻴﺬ‬
‫ﺳﻴ‬
‫ﺒﺎر اﻟﺼﻨﻒ ‪def m1 (self): 7) print ("Method :‬‬

‫ﺘ‬‫)‪1‬اﺧ‬
‫)‪(self): 4) print ("Constructor exeuction ...") 5) 6‬‬
‫ﺒﺎر = ‪t2‬‬
‫ﺘ‬‫ﺘﻨﻔﻴﺬي ‪8 ) 9) t1 = ("...‬اﺧ‬
‫__ ‪2) 3) def __init‬اﻟ‬
‫ﺒﺎر )( ‪() 12) t1.m1‬‬
‫ﺘ‬‫ﺒﺎر = ‪() 11) t3‬اﺧ‬
‫ﺘ‬‫)‪() 10‬اﺧ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫اﻟﻤﻨﺸ ﺊ ‪...‬‬
‫ﺗﻨﻔﻴﺬ ُ‬
‫ﺘﻨﻔﻴﺬ ‪...‬‬
‫ﻃﺮﻳﻘ ﺔ اﻟ‬
‫ﺑﺮﻧﺎﻣﺞ‪:‬‬
‫)‪1‬ﻓﺌ ﺔ اﻟﻄﺎﻟ ﺐ‪2) 3) "" " :‬‬
‫ﺑ ﺔ ‪= z 8) 9) def display (self): 10) print ("Student Name: {} \ nRollno: {} \ n‬‬

‫ﺒﻴﺎﻧﺎ ت اﻟﻤﻄﻠﻮ‬
‫ﻫﺬه ﻓﺌ ﺔ اﻟﻄﺎﻟ ﺐ ﻣﻊ اﻟ‬
‫‪'' 4) def __init __ (self، x، y، z): 5) self.name = x 6) self.rollno = y 7) self.marks‬اﻟﻌﻼﻣﺎ ت‪format (self.name، self.rollno، self :‬‬
‫‪{}".‬‬
‫)‪.marks)) 11‬‬
‫= ‪12) s1‬ﻃﺎﻟ ﺐ )"دورﺟﺎ"‪s1.display () 14) s2 = ،‬‬

‫)‪101،80) 13‬ﻃﺎﻟ ﺐ )"ﻣﺸﻤ ﺲ"‪15) s2.display () ،‬‬
‫)‪102،100‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫اﺳﻢ اﻟﻄﺎﻟ ﺐ‪ :‬دورﺟﺎ‬
‫روﻟﻨﻮ‪101 :‬‬
‫ﻋﻼﻣﺎ ت‪80 :‬‬
‫‪5‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫اﺳﻢ اﻟﻄﺎﻟ ﺐ‪ :‬ﺻﻨ ﻲ‬

‫روﻟﻨﻮ‪102 :‬‬
‫اﻟﻌﻼﻣﺎ ت‪100 :‬‬
‫ﺑﻴﻦ اﻟﻄﺮق واﻟﻤﻨﺸﺌﺎ ت‬‫ﺘﻼﻓﺎ ت‬

‫اﻻﺧ‬
‫ﺒﻨﺎء‬
‫ﻃﺮﻳﻘ ﺔ اﻟ‬
‫)‪1‬ﻳﻤﻜﻦ أنﻳﻜﻮن اﺳﻢ اﻟﻄﺮﻳﻘ ﺔ أي اﺳﻢ‬ ‫ﺋﻤﺎ __‪__init‬‬
‫اﻟﻤﻨﺸ ﺊ دا ً‬
‫)‪1‬ﻳﺠ ﺐ أنﻳﻜﻮن اﺳﻢ ُ‬
‫ﺘﺪﻋﺎء ﻫﺬه اﻟﻄﺮﻳﻘ ﺔ‬

‫ﺑﺎﺳ‬‫ﺘﻢﺗﻨﻔﻴﺬ اﻟﻄﺮﻳﻘ ﺔ إذا ﻗﻤﻨﺎ‬
‫)‪2‬ﺳﻴ‬ ‫اﻟﻤﻨﺸ ﺊﺗﻠﻘﺎﺋ ًﻴﺎ ﻓ ﻲ وﻗ ﺖ إﻧﺸﺎء اﻟﻜﺎﺋﻦ‪.‬‬
‫ﺘﻢﺗﻨﻔﻴﺬ ُ‬
‫)‪2‬ﺳﻴ‬
‫ﻓﻘﻂأي رﻗﻢ‬
‫ﺳﻠﻮ ب‬
‫ﻨﺸ ﺊ‬
‫اﻟﻤاﻷ‬
‫ﺘﺪﻋﺎء‬
‫ُ‬ ‫ﺗﻨﻔﻴﺬ‬
‫ﻳﻤﻜﻦ اﺳ‬
‫ﺘﻢ‬
‫)‪3‬ﻟﻜﻞ ﻛﺎﺋﻦ ‪،‬ﺳﻴ‬
‫اﻟﻤﺮا ت‪.‬‬
‫ﻣﻦواﺣﺪة‬
‫ﻣﺮة‬
‫ﺘﻬﺎ‬
‫ﺗﻬﻴﺌ‬
‫ﺜﻴﻞ و‬
‫ﻷﻋﻤﺎل ﻣ‬
‫اﻹﻋﻼن ﻋﻦ‬ ‫ﺑ ﺔﻋﻠﻴﻨﺎ‬
‫ﻣﻨﻄﻖ ا‬ ‫ﺘﻌﻴﻦ‬
‫ﺘﺎ‬ ‫ﻨﺸ ﺊ ‪،‬ﻳ‬
‫ﻳﻤﻜﻨﻨﺎ ﻛ‬ ‫اﻟﻤ‬
‫داﺧﻞ ُ‬
‫اﻟﺪاﺧﻠﻴ ﺔ‬ ‫)‪4‬‬
‫ﻳﻘ ﺔ‬
‫)‪4‬اﻟﻄﺮ‬
‫ﺘﻐﻴﺮا ت‪:‬‬
‫أﻧﻮاع اﻟﻤ‬
‫ﺜﻮن ‪3.‬‬
‫ﺑﺎﻳ‬‫ﺘﻐﻴﺮا ت داﺧﻞ ﻓﺌ ﺔ‬
‫ﺑﺄﻧﻮاع اﻟﻤ‬‫ُﺴﻤﺢ‬
‫ﻳ‬
‫ﺘﻮى اﻟﻜﺎﺋﻦ(‬
‫ﺜﻴﻞ )ﻣ‬
‫)‪1‬ﻣ‬
‫ﺘﻮى اﻟﻔﺌ ﺔ(‬
‫ﺘ ﺔ )ﻣ‬
‫)‪2‬اﻟﻤ‬
‫ﺘﻮى اﻟﻄﺮﻳﻘ ﺔ(‬
‫ﺘﻐﻴﺮا ت اﻟﻤﺤﻠﻴ ﺔ )ﻣ‬
‫)‪3‬اﻟﻤ‬
‫ﺜﻴﻞ‪:‬‬
‫)‪1‬ﻣ‬
‫ﺘﻐﻴﺮا ت اﻟﺤﺎﻟ ﺔ‪.‬‬
‫ﺘﻐﻴﺮا تﻳ ﺴﻤﻰ ﻣ‬
‫ﺘﻐﻴﺮ ﻣﻦ ﻛﺎﺋﻦ إﱃ ﻛﺎﺋﻦ ‪ ،‬ﻓﺈن ﻫﺬا اﻟﻨﻮع ﻣﻦ اﻟﻤ‬
‫ﺘﻠﻔ ﺖ ﻗﻴﻤ ﺔ اﻟﻤ‬
‫•إذا اﺧ‬
‫ﺘﻐﻴﺮا ت اﻟﺤﺎﻟ ﺔ ﻟﻜﻞ ﻛﺎﺋﻦ‪.‬‬

‫ﺘﻢ إﻧﺸﺎء ﻧ ﺴﺨ ﺔ ﻣﻨﻔﺼﻠ ﺔ ﻣﻦ ﻣ‬
‫•ﺳﻴ‬
‫ﺜﻴﻞ‪:‬‬
‫ﺣﻴ ﺚﻳﻤﻜﻨﻨﺎ اﻹﻋﻼن ﻋﻦ ﻣ‬
‫ﺗﻲ‬
‫ﺑﺎﺳ‬‫)‪1‬ﻣﻨﺸ ﺊ داﺧﻠ ﻲ‬
‫ﺗﻲ‬
‫ﺑﺎﺳ‬‫ﺜﻴﻞ اﻟﺪاﺧﻠ ﻲ‬
‫)‪2‬ﻃﺮﻳﻘ ﺔ اﻟﻤ‬
‫ﺘﻐﻴﺮ ﻣﺮﺟﻊ اﻟﻜﺎﺋﻦ‬
‫ﺘﺨﺪام ﻣ‬
‫ﺑﺎﺳ‬‫)‪3‬ﺧﺎرج اﻟﻔﺌ ﺔ‬
‫ﺗ ﻲ‪:‬‬
‫ﺘﻐﻴﺮا تﺗﻠﻘﺎﺋ ًﻴﺎ‬
‫ﺘﻢ إﺿﺎﻓ ﺔ ﻫﺬه اﻟﻤ‬
‫ﺘ‬‫ﺑﻤﺠﺮد إﻧﺸﺎء اﻟﻜﺎﺋﻦ ‪،‬ﺳ‬‫ﺗﻴ ﺔ‪.‬‬
‫ﺘﺨﺪام اﻟﻜﻠﻤ ﺔ اﻷﺳﺎﺳﻴ ﺔ اﻟﺬا‬
‫ﺑﺎﺳ‬‫اﻟﻤﻨﺸ ﺊ‬
‫ﺘﻐﻴﺮا ت اﻟﺤﺎﻟ ﺔ داﺧﻞ ُ‬
‫ﻳﻤﻜﻨﻨﺎ اﻹﻋﻼن ﻋﻦ ﻣ‬
‫إﱃ اﻟﻜﺎﺋﻦ‪.‬‬
‫)‪1‬ﻣﻮﻇﻒ اﻟﻔﺌ ﺔ ‪self.ename = 'Durga' :‬‬

‫)‪__init __ (self): 4) self.eno = 100 5‬‬
‫‪2) 3) def‬‬
‫‪6‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫‪self.esal‬‬
‫اﻟﻤﻮﻇﻒ )‪() 9‬‬ ‫‪ 6) =7)10000‬ﻫـ =‬
‫)‪8‬‬
‫ﺜﺎل ‪ ،‬دﻳﻜ ﺖ‬
‫ﺒﻴﻞ اﻟﻤ‬
‫ﺒﺎﻋ ﺔ )ﻋﲆﺳ‬
‫ﻃ‬
‫)_‬
‫اﻹﺧﺮاج‪{'eno': 100، 'ename': 'Durga'، 'esal': 10000} :‬‬
‫ﺗ ﻲ‪:‬‬
‫ﺑﺎﺳ‬‫ﺜﻴﻞ اﻟﺪاﺧﻠ ﻲ‬
‫)‪2‬ﻃﺮﻳﻘ ﺔ اﻟﻤ‬
‫ﺘﻢ‬
‫ﺜﻴﻞ ‪ ،‬ﻓ ﺴﻴ‬
‫ﺘﻐﻴﺮ ﺣﺎﻟ ﺔ داﺧﻞ ﻃﺮﻳﻘ ﺔ اﻟﻤ‬
‫ﺗ ﻲ‪ .‬إذاﺗﻢ اﻹﻋﻼن ﻋﻦ أي ﻣ‬
‫ﺑﺎﺳ‬‫ﺜﻴﻞ‬
‫ﺘﻐﻴﺮا ت اﻟﺤﺎﻟ ﺔ داﺧﻞ ﻃﺮﻳﻘ ﺔ اﻟﻤ‬ ‫ﻳﻤﻜﻨﻨﺎ أ ً‬
‫ﻳﻀﺎ إﻋﻼن ﻣ‬
‫ﺑﻤﺠﺮد أن ﻧ ﺴﻤ ﻲ ﻃﺮﻳﻘ ﺔﺗﺎه‪.‬‬‫ﺘﻐﻴﺮ اﻟﺤﺎﻟ ﺔ ﻫﺬا‬
‫إﺿﺎﻓ ﺔ ﻣ‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪12) print (t .__ict__) :‬‬

‫ﺘ‬‫)‪1‬اﺧ‬
‫)( ‪= 30 9) 10) t = Test () 11) t.m1‬‬
‫‪= 20 6) 7) def m1 (self): 8) self.c‬‬
‫)‪__ (self): 4) self.a2)= 3‬‬
‫‪10def‬‬
‫‪5) self.b‬‬
‫‪__init‬‬
‫اﻹﺧﺮاج‪{'a': 10، 'b': 20، 'c': 30} :‬‬
‫ﺘﻐﻴﺮ ﻣﺮﺟﻊ اﻟﻜﺎﺋﻦ‪:‬‬

‫ﺑﺎﺳ‬‫)‪3‬ﺧﺎرج اﻟﻔﺼﻞ اﻟﺪراﺳ ﻲ‬
‫ﺘﻐﻴﺮا ت ﺣﺎﻟ ﺔ ﺧﺎرج ﻓﺌ ﺔ إﱃ ﻛﺎﺋﻦ ﻣﻌﻴﻦ‪.‬‬ ‫ﻳﻤﻜﻨﻨﺎ أ ً‬
‫ﻳﻀﺎ إﺿﺎﻓ ﺔ ﻣ‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪12) print (t .__ict__) :‬‬

‫ﺘ‬‫)‪1‬اﺧ‬
‫‪t = Test () 10) t.m1 () 11) td = 40‬‬
‫)‪def m1 (self): 7) self.c = 30 8) 9‬‬
‫)‪__init __ (self): 4) self.a =2‬‬
‫‪103)5)def‬‬
‫)‪6‬‬
‫اﻟﻨﻔ ﺲ ب ‪= 20‬‬
‫اﻹﺧﺮاج }‪{'a': 10، 'b': 20، 'c': 30، 'd': 40‬‬
‫‪7‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺜﻴﻞ‪:‬‬
‫ﻛﻴﻔﻴ ﺔ اﻟﻮﺻﻮل إﱃ ﻣ‬
‫ﺘﺨﺪام ﻣﺮﺟﻊ اﻟﻜﺎﺋﻦ‪.‬‬
‫ﺑﺎﺳ‬‫ﺗ ﻲ وﺧﺎرج اﻟﻔﺌ ﺔ‬
‫ﺑﺎﺳ‬‫ﺘﻐﻴﺮا ت اﻟﺤﺎﻟ ﺔ ﻓ ﻲ اﻟﻔﺌ ﺔ‬
‫ﻳﻤﻜﻨﻨﺎ اﻟﻮﺻﻮل إﱃ ﻣ‬
‫ﺒﺎر اﻟﺼﻨﻒ ‪9) 10) t = :‬‬

‫ﺘ‬‫)‪1‬اﺧ‬
‫)‪print (self.a) 8) print (self. .b‬‬
‫)‪= 20 6) def display (self): 7‬‬
‫‪(self):‬‬
‫ﺒﺎر )‪tb‬‬
‫)‪4‬‬
‫ﺘ‬‫اﻻﺧ‬
‫‪self.a‬‬
‫‪2) 3)=def‬‬
‫)‪10 5‬‬
‫‪__init‬‬
‫‪self.b‬‬
‫__‬
‫‪11) t.display () 12) print (ta،‬‬
‫)(‬
‫ﺘﺎج |‬
‫اﻧ‬
‫‪10‬‬
‫‪20‬‬
‫‪10 20‬‬
‫ﺜﻴﻞ ﻣﻦ اﻟﻜﺎﺋﻦ‪:‬‬
‫ﺘﻐﻴﺮ ﻣ‬
‫ﻛﻴﻔﻴ ﺔ ﺣﺬف ﻣ‬
‫ﺘﺎﻟ ﻲ‬
‫ﺘﻐﻴﺮ اﻟﺤﺎﻟ ﺔ ﻋﲆ اﻟﻨﺤﻮ اﻟ‬
‫)‪1‬داﺧﻞ اﻟﻔﺼﻞﻳﻤﻜﻨﻨﺎ ﺣﺬف ﻣ‬
‫‪del self.variableName‬‬
‫ﺘﺎﻟ ﻲ ‪objectreference.variableName‬‬
‫ﺘﻐﻴﺮا ت اﻟﺤﺎﻟ ﺔ ﻋﲆ اﻟﻨﺤﻮ اﻟ‬
‫)‪2‬ﻣﻦ ﺧﺎرج اﻟﻔﺼﻞﻳﻤﻜﻨﻨﺎ ﺣﺬف ﻣ‬
‫‪del‬‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪t = Test () 11) :‬‬

‫ﺘ‬‫)‪1‬اﺧ‬
‫)‪6) 7) def m1 (self): 8) 9) 10‬‬
‫‪3) self.a‬‬
‫ﺒﺎﻋ ﺔ‬
‫)‪2‬ﻃ‬
‫‪= 10‬‬
‫‪def4)__init‬‬
‫‪self.b__=(self):‬‬
‫)‪20 5‬‬
‫‪14)t.m1‬‬
‫)( ‪del‬‬
‫)‪tc13‬‬
‫‪15)print‬‬
‫)__‪print(t(t.__ict‬‬
‫)__‪.__ict‬‬
‫ﺗ ﻲ‪.‬‬
‫)__‪=.__dict‬ذا‬
‫‪(t‬‬ ‫ج ‪30‬‬ ‫)‪12‬‬
‫د ‪= 40‬‬
‫دﻳﻞ اﻟﻨﻔ ﺲ د‬
‫‪8‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫}'أ'‪ '10 ، :‬ب'‪'20 ، :‬ج'‪'30 ، :‬د'‪40} :‬‬
‫}'أ'‪ '10 ، :‬ب'‪'20 ، :‬ج'‪30} :‬‬
‫}"أ"‪ "10 ، :‬ب"‪20} :‬‬
‫ﺘ ﻲﺗﻢ ﺣﺬﻓﻬﺎ ﻣﻦ ﻛﺎﺋﻦ واﺣﺪ ﻣﻦ اﻟﻜﺎﺋﻨﺎ ت اﻷﺧﺮى‪.‬‬

‫ﺘﻐﻴﺮا ت اﻟﺤﺎﻟ ﺔ اﻟ‬
‫ﺘﻢ ﺣﺬف ﻣ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬ﻟﻦﻳ‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪12) print (t2 .__ict__) :‬‬

‫ﺘ‬‫)‪1‬اﺧ‬
‫)__‪10) del t1.a 11) print (t1 .__ict‬‬
‫)‪6) 7‬‬
‫)‪3) 8‬‬
‫‪self.a‬‬
‫‪t1 ==Test‬‬
‫)‪10 4‬‬
‫)‪() 9‬‬
‫‪self.b‬‬
‫‪t2 ==Test‬‬
‫)‪20 5‬‬
‫)(‬
‫‪2) def __init __ (self):‬‬

‫ﺗ ﻲ‪.‬‬
‫ج ‪= 30‬ذا‬
‫د ‪= 40‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫}' ب'‪'20 ، :‬ج'‪'30 ، :‬د'‪40} :‬‬
‫}'أ'‪ '10 ، :‬ب'‪'20 ، :‬ج'‪'30 ، :‬د'‪40} :‬‬
‫ﺘﻐﻴﺮا ت اﻟﺤﺎﻟ ﺔ‬
‫ﺒﻘﻴ ﺔ ‪،‬ﻷﻧﻨﺎ ﻟﻜﻞ ﻛﺎﺋﻦ ﻧ ﺴﺨ ﺔ ﻣﻨﻔﺼﻠ ﺔ ﻣﻦ ﻣ‬
‫ﺘ‬‫ﺘﻐﻴﻴﺮا ت ﻋﲆ اﻟﻜﺎﺋﻨﺎ ت اﻟﻤ‬
‫ﺜﻴﻞ ﻟﻜﺎﺋﻦ واﺣﺪ ‪ ،‬ﻓﻠﻦﺗﻨﻌﻜ ﺲ ﻫﺬه اﻟ‬
‫ﺘﻐﻴﻴﺮ ﻗﻴﻢ ﻣ‬
‫ﺑ‬‫إذا ﻗﻤﻨﺎ‬
‫ﺘﺎﺣ ﺔ‪.‬‬
‫اﻟﻤ‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪print ('t2:'، t2.a، t2.b) :‬‬

‫ﺘ‬‫)‪1‬اﺧ‬
‫)‪() 10) print ('t1:'، t1.a، t1.b) 11‬‬
‫‪self.b‬‬
‫‪= 888‬‬
‫‪= 20‬‬
‫)‪8)5‬‬
‫‪t1.b‬‬
‫‪6) t1‬‬
‫‪= 999‬‬
‫‪= Test‬‬
‫‪9) t2‬‬
‫)‪() 7‬‬
‫‪= Test‬‬
‫‪t1.a‬‬
‫)‪def __init __ (self): 3) self.a = 10 2‬‬

‫)‪4‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫‪t1: 888999‬‬
‫ر ‪2: 10 20‬‬
‫‪9‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘ ﺔ‪:‬‬
‫)‪2‬اﻟﻤ‬
‫ﺒﺎﺷﺮة وﻟﻜﻦ ﺧﺎرج‬
‫ﺘﻐﻴﺮا تﻳﺠ ﺐ أن ﻧﻌﻠﻦ ﻋﻨﻪ ﻓ ﻲ اﻟﻔﺼﻞ ﻣ‬
‫ﺜﻞ ﻫﺬا اﻟﻨﻮع ﻣﻦ اﻟﻤ‬
‫ﺘﻠﻒ ﻣﻦ ﻛﺎﺋﻦ إﱃ ﻛﺎﺋﻦ ‪ ،‬ﻓﺈن ﻣ‬
‫ﺘﻐﻴﺮ ﻻﺗﺨ‬
‫إذا ﻛﺎﻧ ﺖ ﻗﻴﻤ ﺔ اﻟﻤ‬
‫ﺘ ﺔ‪.‬‬
‫اﻷﺳﺎﻟﻴ ﺐ‪.‬ﺗ ﺴﻤﻰ ﻫﺬه اﻷﻧﻮاع ﻣﻦ اﻟﻤ‬
‫ﺑﻮاﺳﻄ ﺔ ﺟﻤﻴﻊ اﻟﻜﺎﺋﻨﺎ ت‬‫ﺘﻬﺎ‬

‫ﺑ ﺖ وﻣﺸﺎرﻛ‬
‫ﺜﺎ‬
‫ﺘﻐﻴﺮ اﻟ‬
‫ﺘﻢ إﻧﺸﺎء ﻧ ﺴﺨ ﺔ واﺣﺪة ﻓﻘﻂ ﻣﻦ اﻟﻤ‬
‫ﺒ ﺔ ﻟﻠﻔﺌ ﺔ اﻹﺟﻤﺎﻟﻴ ﺔ ‪،‬ﺳﻴ‬
‫ﺑﺎﻟﻨ ﺴ‬
‫ﻣﻦﺗﻠﻚ اﻟﻔﺌ ﺔ‪.‬‬
‫ﺘﺨﺪام اﺳﻢ اﻟﻔﺌ ﺔ‪.‬‬

‫ﺑﺎﺳ‬‫ﺘ ﺔ إﻣﺎ ﻋﻦ ﻃﺮﻳﻖ اﺳﻢ اﻟﻔﺌ ﺔ أو ﻋﻦ ﻃﺮﻳﻖ ﻣﺮﺟﻊ اﻟﻜﺎﺋﻦ‪ .‬ﻟﻜﻦﻳﻮﺻﻰ‬
‫ﻳﻤﻜﻨﻨﺎ اﻟﻮﺻﻮل إﱃ اﻟﻤ‬
‫ﺑ ﺖ‪:‬‬
‫ﺛﺎ‬‫ﺘﻐﻴﺮ‬
‫ﺑﻞ ﻣ‬
‫ﺜﻴﻞ ﻣﻘﺎ‬
‫ﺘﻐﻴﺮ ﻣ‬
‫ﻣ‬
‫ﺘﻜﻮن ﻧ ﺴﺨ ﺔ ﻣﻨﻔﺼﻠ ﺔ‬
‫ﺘﻐﻴﺮا ت اﻟﺤﺎﻟ ﺔ ﻟﻜﻞ ﻛﺎﺋﻦ ‪،‬ﺳ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬ﻓ ﻲ ﺣﺎﻟ ﺔ ﻣ‬
‫ﺑﻮاﺳﻄ ﺔ ﻛﻞ ﻛﺎﺋﻦ ﻣﻦﺗﻠﻚ اﻟﻔﺌ ﺔ‪.‬‬‫ﺘﻬﺎ‬
‫ﺘﻢ إﻧﺸﺎء ﻧ ﺴﺨ ﺔ واﺣﺪة ﻓﻘﻂ وﻣﺸﺎرﻛ‬
‫ﺘ ﺔ ﻟﻠﻔﺌ ﺔ اﻹﺟﻤﺎﻟﻴ ﺔ ‪،‬ﺳﻴ‬
‫ﺗﻢ إﻧﺸﺎؤه ‪ ،‬وﻟﻜﻦ ﻓ ﻲ ﺣﺎﻟ ﺔ اﻟﻤ‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪('t2:'، t2.x، t2.y) :‬‬

‫ﺘ‬‫)‪1‬اﺧ‬
‫‪8) print ('t1:'، t1.x، t1.y) 9) print‬‬
‫)( ‪5) 6) t1 = Test () 7) t2 = Test‬‬
‫‪def __init __ (self): 4)2)self.y‬‬
‫‪x = 10‬‬‫‪= 20‬‬
‫)‪3‬‬
‫)‪t1.y) 13) print ('t2:'، t2.x، t2.y‬‬

‫‪t1.y = 999 12) print ('t1:'، t1.x،‬‬
‫)‪10) Test.x = 888 11‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ر ‪1: 10 20‬‬
‫ر ‪2: 10 20‬‬
‫‪t1: 888999‬‬
‫ﺗ ﻲ ‪2: 888 20‬‬
‫ﺘ ﺔ‪:‬‬
‫ﺘﻠﻔ ﺔ ﻟﻺﻋﻼن ﻋﻦ اﻟﻤ‬
‫أﻣﺎﻛﻦ ﻣﺨ‬
‫ﺒﺎﺷﺮة وﻟﻜﻦ ﻣﻦ ﺧﺎرج أي ﻃﺮﻳﻘ ﺔ‬
‫ﺘﺼﺮﻳﺢ داﺧﻞ اﻟﻔﺼﻞ ﻣ‬
‫ﺑﺸﻜﻞ ﻋﺎمﻳﻤﻜﻨﻨﺎ اﻟ‬
‫)‪1‬‬
‫ﺘﺨﺪام اﺳﻢ اﻟﻔﺌ ﺔ‬
‫)‪3‬داﺧﻞ أﺳﻠﻮ ب اﻟﻤ‬
‫ﺘﻐﻴﺮ ‪cls‬‬
‫ﺘﺨﺪام اﺳﻢ اﻟﻔﺌ ﺔ أو ﻣ‬
‫ﺑﺎﺳ‬
‫)‪4‬داﺧﻞ ‪classmethod‬‬
‫ﺑﺎﺳ‬‫ﺑ ﺖ اﻟﺪاﺧﻠ ﻲ‬
‫ﺜﺎ‬
‫)‪5‬اﻷﺳﻠﻮ ب اﻟ‬
‫‪10‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺗﻌﺮﻳﻒ‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪2) :‬أ )‪= 10 3‬‬
‫ﺘ‬‫)‪1‬اﺧ‬
‫ﺗ ﻲ(‪:‬‬
‫__ ‪)__init‬ذا‬
‫‪Test.b = 20 5) def m1‬‬

‫)‪4‬‬
‫ﺗ ﻲ(‪6) :‬‬
‫)ذا‬
‫)‪9) cls.d1 = 40 10‬‬
‫‪7) classmethod 8) def m2 (cls):‬‬

‫‪Test.c = 30‬‬
‫)‪12) def m3 (): 13‬‬
‫‪Test.d2 = 400 11) staticmethod‬‬
‫)__‪print (Test .__ict‬‬
‫)‪(Test .__ict__) 17) t.m1 () 18‬‬

‫‪15) t = Test () 16) print‬‬
‫)__‪= 50 14) print (Test .__ict‬‬
‫‪Test.e‬‬
‫ﺒﺎﻋ ﺔ‬
‫)‪19) Test.m2 () 20‬ﻃ‬
‫)__‪(Test .__ict‬‬
‫ﺒﻊ‬
‫)‪21) Test.m3 () 22‬اﻃ‬
‫)__‪(Test .__ict‬‬
‫ﺒﻊ‬
‫)‪23) Test.f = 60 24‬اﻃ‬
‫)__‪(Test .__ict‬‬
‫ﺘ ﺔ‪:‬‬
‫ﻛﻴﻔﻴ ﺔ اﻟﻮﺻﻮل إﱃ اﻟﻤ‬
‫ﺘﺨﺪام إﻣﺎ ‪self‬أو ‪classname‬‬
‫ﺑﺎﺳ‬‫اﻟﻤﻨﺸ ﺊ‪:‬‬
‫)‪1‬داﺧﻞ ُ‬
‫ﺘﺨﺪام إﻣﺎ ‪self‬أو ‪classname‬‬
‫ﺑﺎﺳ‬‫ﺜﻴﻞ‪:‬‬
‫)‪2‬داﺧﻞ أﺳﻠﻮ ب اﻟﻤ‬
‫ﺘﻐﻴﺮ ‪cls‬أو اﺳﻢ اﻟﻔﺌ ﺔ‬
‫ﺑﺎﺳ‬‫)‪3‬ﻃﺮﻳﻘ ﺔ داﺧﻞ اﻟﺼﻨﻒ‪:‬‬
‫ﺘﺨﺪام ‪classname‬‬
‫ﺑﺎﺳ‬‫ﺑ ﺖ اﻟﺪاﺧﻠ ﻲ‪:‬‬
‫ﺜﺎ‬
‫)‪4‬اﻷﺳﻠﻮ ب اﻟ‬
‫ﺘﺨﺪام إﻣﺎ ﻣﺮﺟﻊ اﻟﻜﺎﺋﻦ أو اﺳﻢ اﻟﻔﺌ ﺔ‬
‫ﺑﺎﺳ‬‫)‪5‬ﻣﻦ ﺧﺎرج اﻟﻔﺼﻞ اﻟﺪراﺳ ﻲ‪:‬‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪2) :‬أ )‪= 10 3‬‬
‫ﺘ‬‫)‪1‬اﺧ‬
‫ﺒﺎﻋ ﺔ )‪(self.a) 5‬‬
‫ﺗ ﻲ(‪4) :‬ﻃ‬
‫__ ‪)__init‬ذا‬
‫ﺗ ﻲ(‪:‬‬
‫ﺒﺎر أ( ‪)6) def m1‬ذا‬
‫ﺘ‬‫ﺒﺎﻋ ﺔ )اﺧ‬
‫ﻃ‬
‫)‪(cls.a)10‬‬
‫‪12)def‬‬
‫‪print‬‬
‫)‪m2(Test.a‬‬ ‫ﺒﺎﻋ ﺔ‬
‫)‪(cls): 11‬‬ ‫)‪7‬ﻃ‬
‫‪print‬‬
‫‪8) print (Test.a) 9) classmethod‬‬
‫)‪(self.a‬‬
‫‪11‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫)( ‪() 20) t .m2 () 21) t.m3‬‬

‫‪18) print (ta) 19) t.m1‬‬
‫‪=():Test‬‬
‫‪15) ()print‬‬
‫‪17) print‬‬ ‫)‪(Test.a‬‬
‫)‪(Test.a‬‬ ‫‪16) t‬‬
‫‪staticmethod 14) def m3‬‬
‫)‪13‬‬
‫ﺑ ﺖ‪:‬‬
‫ﺜﺎ‬
‫ﺣﻴ ﺚﻳﻤﻜﻨﻨﺎﺗﻌﺪﻳﻞ ﻗﻴﻤ ﺔ اﻟﻤ‬
‫ﺘﺨﺪام ‪classname.‬‬
‫ﺑﺎﺳ‬‫ﺘﻌﺪﻳﻞ‬
‫ﻓ ﻲ أي ﻣﻜﺎنﺳﻮاء ﻓ ﻲ اﻟﻔﺼﻞ أو ﺧﺎرج اﻟﻔﺼﻞ ‪،‬ﻳﻤﻜﻨﻨﺎ اﻟ‬
‫ﺘﻐﻴﺮ ‪cls.‬‬
‫ﺑﺎﺳ‬‫وﻟﻜﻦ داﺧﻞ ﻃﺮﻳﻘ ﺔ اﻟﺼﻨﻒ ‪،‬‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪def m2 (): 8) :‬‬

‫ﺘ‬‫)‪1‬اﺧ‬
‫)‪= 888 6) staticmethod 7‬‬
‫‪4) def m1 (cls): 5) cls.a‬‬
‫‪2) a = 777 3) classmethod‬‬
‫) ‪Test.a = 9999‬‬
‫ﺒﺎﻋ ﺔ )‪(Test.a‬‬
‫ﻃ‬
‫ﺒﺎﻋ ﺔ‬
‫)‪10) Test.m1 () 11‬ﻃ‬
‫)‪(Test.a‬‬
‫ﺒﺎﻋ ﺔ‬
‫)‪12) Test.m2 () 13‬ﻃ‬
‫)‪(Test.a‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫‪777‬‬
‫‪888‬‬
‫‪999‬‬
‫*****‬
‫ﺘﻐﻴﺮ ﻣﺮﺟﻌ ﻲ ﻟﻠﻜﺎﺋﻦ‪:‬‬

‫ﺗ ﻲ أو ﻣ‬
‫ﺘﺨﺪام إﻣﺎ ذا‬
‫ﺑﺎﺳ‬‫ﺑﺖ‬
‫ﺜﺎ‬
‫ﺘﻐﻴﻴﺮ ﻗﻴﻤ ﺔ اﻟﻤ‬
‫ﺑﻬﺬا اﻻﺳﻢ‬‫ﺘﻐﻴﺮ ﺣﺎﻟ ﺔ ﺟﺪﻳﺪ‬

‫ﺑ ﺖ ‪ ،‬ﻓﻘﻂ ﻣ‬
‫ﺜﺎ‬
‫ﺘﻐﻴﺮ ﻗﻴﻤ ﺔ اﻟﻤ‬
‫ﺗ ﻲ أو ﻛﺎﺋﻦ ‪ ،‬ﻓﻠﻦﺗ‬
‫ﺘﻐﻴﺮ ﻣﺮﺟﻌ ﻲ ذا‬
‫ﺘﺨﺪام إﻣﺎ ﻣ‬
‫ﺑﺎﺳ‬‫ﺑﺖ‬
‫ﺜﺎ‬
‫ﺘﻐﻴﻴﺮ ﻗﻴﻤ ﺔ اﻟﻤ‬
‫ﺘﻪ إﱃ ﻫﺬا اﻟﻜﺎﺋﻦ اﻟﻤﺤﺪد‪.‬‬
‫ﺘﻢ إﺿﺎﻓ‬
‫ﺳﻴ‬
‫ﺗ ﻲ(‪4) self.a = 888 :‬‬

‫ﺒﺎر اﻟﻔﺌ ﺔ ‪2) :‬أ ‪)= 10 3) def m1‬ذا‬
‫ﺘ‬‫)‪1‬اﺧ‬

‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫‪12‬‬ ‫‪040-64 51 27 86 ، 80 96 96 96 96 ، 92 46 21 21 43 | www.durgasoft.com‬‬
Machine Translated by Google
(Test.a) 8) print (t1.a)

() 6) t1.m1 () 7) print
5) t1 = Test
| ‫ﺘﺎج‬
‫اﻧ‬
10
888
('t2:'، t2.x، t2.y) : ‫ﺒﺎر اﻟﻔﺌ ﺔ‬

‫ﺘ‬‫اﺧ‬1)
print ('t1:'، t1. x، t1.y) 13) print
10) t1.x = 888 11) t1.y = 999 12)
7) t2t1.y) 9) print
= Test ('t2:'،('t1:'،
() 8) print t2.x، t1.x،
t2.y)
4) self.y = 20 5) 6) t1 = Test ()
2) x = 10 3) def __init __ (self):
| ‫ﺘﺎج‬
‫اﻧ‬
1: 10 20 ‫ر‬
2: 10 20 ‫ر‬
t1: 888999
2: 10 20 ‫ر‬
= 10 3) ‫أ‬2) : ‫ﺒﺎر اﻟﻔﺌ ﺔ‬
‫ﺘ‬‫اﺧ‬1)
self.b = 20 5) t1 = :(‫ﺗ ﻲ‬
‫__)ذا‬init __
() ‫ﺒﺎر‬
‫ﺘ‬‫ )(اﺧ‬6) t2 = ‫ﺒﺎر‬
‫ﺘ‬‫اﺧ‬4)
(t1.a، t1.b) 10) print (t2.a، t2.b)

= 888 8) t1.b = 999 9) print
7) Test.a
| ‫ﺘﺎج‬
‫اﻧ‬
888999
888 20
202 ، 2 ‫ رﻗﻢ‬، ‫ﺜﺎﻧﻴ ﺔ دورﺟﺎﺳﻮﻓ ﺖ‬‫اﻟ‬
13
- 500038 ، ‫ﺑﺎد‬
‫ ﺣﻴﺪر أ‬، ‫ﺑﻴ ﺖ‬
‫ أﻣﻴﺮ‬، ‫ﺘﺮﻳﻔﺎﻧﺎم‬
‫ ﻫﺪى ﻣﺎﻳ‬، ‫ﺑﻖ‬
‫اﻟﻄﺎ‬
040-64 51 27 86 ، 80 96 96 96 96 ، 92 46 21 21 43 | www.durgasoft.com
__ ‫ﺗﻌﺮﻳﻒ‬
= 10 3) ‫أ‬2) : ‫ﺒﺎر اﻟﻔﺌ ﺔ‬
‫ﺘ‬‫اﺧ‬1)
self.b = 20 5) def m1 :(‫ﺗ ﻲ‬
‫__)ذا‬init
t1.b) 13) print (t2.a، t2.b) :(‫ﺗ ﻲ‬
‫)ذا‬4)
Test
= ()
99911)8)t1.m1
9 ) t1 ()= 12)
Testprint
() 10)(t1.a،
t2 =
6) self.a = 888 7) self.b
| ‫ﺘﺎج‬
‫اﻧ‬
888999
10 20
3) def __init __ ‫أ‬2) : ‫ﺒﺎر اﻟﻔﺌ ﺔ‬

‫ﺘ‬‫اﺧ‬1)
= 999 9) 10) t1 = :(‫ﺗ ﻲ‬
‫ =)ذا‬10
m1 (cls): 7) cls.a = 888 8) cls.b
‫ﺒﺎر‬
=‫ﺘ‬
‫اﺧ‬
20() 5)
11)classmethod
t2 = ‫ﺒﺎر‬
‫ﺘ‬‫اﺧ‬4) 6)
self.b
def
t1.b) 14) ‫ﺒﺎﻋ ﺔ‬
‫ )(ﻃ‬12) t1.m1 () 13)
‫ﺒﺎﻋ ﺔ‬
‫(ﻃ‬t2.a، t2.b) 15) ‫ﺒﺎﻋ ﺔ‬
‫(ﻃ‬t1.a،
(Test.a، Test.b)
| ‫ﺘﺎج‬
‫اﻧ‬
888 20
888 20
888999
14
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
:‫ﺘ ﺔ ﻟﻠﻔﺼﻞ‬
‫ﻛﻴﻔﻴ ﺔ ﺣﺬف اﻟﻤ‬
‫ﺘﺎﻟﻴ ﺔ‬
‫ﺘﺨﺪام اﻟﺼﻴﻐ ﺔ اﻟ‬
‫ﺑﺎﺳ‬‫ﺘ ﺔ ﻣﻦ أي ﻣﻜﺎن‬
‫ﻳﻤﻜﻨﻨﺎ ﺣﺬف اﻟﻤ‬1)
del classname.variablename
cls ‫ﺘﻐﻴﺮ‬
‫ﺘﺨﺪام ﻣ‬ ً ‫ﻳﻤﻜﻨﻨﺎ أ‬classmethod ‫وﻟﻜﻦ داﺧﻞ‬2)
‫ﻳﻀﺎ اﺳ‬
del cls.variablename
(Test .__ict__) ‫أ‬2) : ‫ﺒﺎر اﻟﺼﻨﻒ‬

‫ﺘ‬‫اﺧ‬1)
5) del cls.a 6) Test.m1 () 7) print
3) classmethod 4) def m1 (cls):
= 10
:‫ﺜﺎل‬
‫ﻣ‬
= 10 3) ‫أ‬2) : ‫ﺒﺎر اﻟﻔﺌ ﺔ‬
‫ﺘ‬‫اﺧ‬1)
4) :(‫ﺗ ﻲ‬
‫__)ذا‬init __
14) def m3 (): 15)

‫ﺴﺖ‬
12) del Test.c 13) ‫دﻳﻞﺗ‬
staticmethod
10) def m2 (cls): 11) cls.d = 40
Test.c
7) 8) del Test.b = 30
9) classmethod
Test.b = 20 5) 6) def m1 (self):
print (Test .__ict__)
(Test 18)
.__ict__)
t = Test
20) ()t.m1
19) ()
print
21)
Test.d 17) print (Test .__ict__)
Test.e = 50 16) del
‫ﺒﻊ‬
‫اﻃ‬22) Test.m2 () 23)
(Test .__ict__)
‫ﺒﻊ‬
‫اﻃ‬24) Test.m3 () 25)
(Test .__ict__)
_ ‫ﺒﺎر‬
‫ﺘ‬‫ﺒﻊ )اﺧ‬
‫اﻃ‬26) Test.f = 60 27)
_) ‫دﻳﻜ ﺖ‬
15
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﺒﻊ‬
‫)‪28) del Test.e 29‬اﻃ‬
‫)__‪(Test .__ict‬‬
‫****ﻣﻠﺤﻮﻇ ﺔ‪:‬‬
‫ﺘ ﺔ ‪ ،‬ﻟﻜﻦ ﻻﻳﻤﻜﻨﻨﺎﺗﻌﺪﻳﻠﻬﺎ أو ﺣﺬﻓﻬﺎ‪.‬‬
‫ﺘﻐﻴﺮ ﻣﺮﺟﻊ اﻟﻜﺎﺋﻦ ‪ /‬اﻟﺬا ت ‪،‬ﻳﻤﻜﻨﻨﺎ ﻗﺮاءة اﻟﻤ‬
‫ﺑﺎﺳ‬
‫ﺘﻐﻴﺮ ﺣﺎﻟ ﺔ ﺟﺪﻳﺪ إﱃ ﻫﺬا اﻟﻜﺎﺋﻦ اﻟﻤﺤﺪد‪.‬‬

‫ﺘﻢ إﺿﺎﻓ ﺔ ﻣ‬
‫ﺘﻌﺪﻳﻞ ‪ ،‬ﻓ ﺴﻴ‬
‫إذا ﻛﻨﺎ ﻧﺤﺎول اﻟ‬
‫‪t1.a = 70‬‬
‫إذا ﻛﻨﺎ ﻧﺤﺎول اﻟﺤﺬف ‪ ،‬ﻓ ﺴﻨﺤﺼﻞ ﻋﲆ ﺧﻄﺄ‪.‬‬
‫ﺜﺎل‪:‬‬
‫ﻣ‬
‫ﺒﺎر ‪a‬‬
‫ﺘ‬‫ﺒﺎر اﻟﻔﺌ ﺔ ‪2) :‬أ = ‪= 10 3) 4) t1‬اﺧ‬
‫ﺘ‬‫)‪1‬اﺧ‬
‫‪() 5) del t1.a ===> AttributeError:‬‬
‫ﺘﻐﻴﺮ ‪cls.‬‬
‫ﺘﺨﺪام ‪classname‬أو ﻣ‬
‫ﺑﺎﺳ‬‫ﺘ ﺔ إﻻ‬
‫ﻻﻳﻤﻜﻨﻨﺎﺗﻌﺪﻳﻞ أو ﺣﺬف اﻟﻤ‬
‫ﺘﻴﺮاد اﻟﻨﻈﺎم )‪2‬ﻓﺌ ﺔ اﻟﻌﻤﻼء‪3) :‬‬

‫)‪1‬اﺳ‬
‫'' ''‬ ‫""‬

‫ﻓﺌ ﺔ اﻟﻌﻤﻴﻞ ﻣﻊ اﻟﻌﻤﻠﻴﺎ ت اﻟﻤﺼﺮﻓﻴ ﺔ ‪name 7) self.balance = ..‬‬
‫= ‪5) def __init __ (self، name، Balance = 0.0): 6) self.name‬‬
‫'‪4) bankname = 'DURGABANK‬اﻟﺮﺻﻴﺪ )‪8‬إﻳﺪاع )‪def (self، amt ): 9) 10‬‬
‫)‪19‬‬
‫‪13)name‬‬
‫)‪14) 15)= 16‬‬
‫‪input‬‬
‫ﺐ)‪17‬‬
‫)‪18‬‬
‫ﺳﺤ‬‫‪print‬‬
‫)‪self.balance‬‬
‫‪('Welcome‬‬‫‪11)to'،‬‬
‫ﻳﺪاع‪،":‬‬
‫)‪Customer.bankname‬‬
‫ﺑﻌﺪ اﻹ‬‫ﺒﺎﻋ ﺔ )"اﻟﺮﺻﻴﺪ‬
‫ﻃ‬
‫‪input‬‬
‫)‪(name‬‬
‫‪(' Choose‬‬
‫ﺳﻤﻚ‪21) (':‬‬
‫)'أدﺧﻞ ا‪your‬‬
‫‪option:‬‬‫‪def') (self،‬‬
‫ﺒﻊ‬
‫‪True:‬اﻃ‬
‫)‪amt):22‬‬
‫ﺑﻴﻨﻤﺎ)‪12‬‬
‫>‪if amt‬‬
‫‪20) cself.balance:‬‬
‫‪= Customer‬‬
‫= ‪('d-Deposit \ nw-Withdraw \ ne-exit ') 23) option‬‬
‫ﺗ ﻲ ‪+ amt‬‬
‫ﺘﻮازن اﻟﺬا‬
‫ﺗ ﻲ =اﻟ‬
‫اﻟ‬
‫ﺒﺎﻋ ﺔ )"أﻣﻮال ﻏﻴﺮ ﻛﺎﻓﻴ ﺔ ‪ ..‬ﻻﻳﻤﻜﻦﺗﻨﻔﻴﺬ ﻫﺬه اﻟﻌﻤﻠﻴ ﺔ"( ‪self.balance = self.balance-amt‬‬
‫ﻃ‬
‫)( ‪sys.exit‬‬
‫ﺑﻌﺪ اﻟ ﺴﺤ ﺐ‪self.balance) ، ":‬‬‫‪")print‬اﻟﺮﺻﻴﺪ‬
‫‪16‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺒﻠﻎ‪27) ((':‬‬
‫)‪24‬إذا ﻛﺎن اﻟﺨﻴﺎر '‪== 'd‬أو اﻟﺨﻴﺎر ‪)== 'D': 25) amt = float‬اﻹدﺧﺎل )'أدﺧﻞ اﻟﻤ‬
‫)'أدﺧﻞ‬
‫)اﻹدﺧﺎل)‪() 33‬‬
‫ﺒﺎﻋ ﺔ‬
‫==ﻃ‬‫‪== 'E':‬‬
‫)‪'W':31‬‬
‫اﻟﺨﻴﺎر)‪28‬‬
‫= ‪amt‬‬ ‫‪float‬‬
‫‪elif‬أو‬ ‫اﻟﺨﻴﺎر==‬ ‫‪elif‬أو‬
‫ﺧﻴﺎر '‪'e‬‬ ‫==)‪29‬‬ ‫)‪26‬ﺧﻴﺎر '‪'w‬‬
‫‪c.withdraw‬‬ ‫‪c.deposit‬‬
‫)‪(amt‬‬ ‫)‪(amt‬‬
‫ﺒﻠﻎ‪30) ((':‬‬
‫اﻟﻤ‬
‫ﺘﻴﺎر ﺧﻴﺎر‬
‫ﺒﻊ )"ﺧﻴﺎر ﻏﻴﺮ ﺻﺎﻟﺢ ‪ ..‬اﻟﺮﺟﺎء اﺧ‬
‫‪('Thanks for Banking') 32) sys.exit‬وإﻻ‪34) :‬اﻃ‬
‫ﺻﺎﻟﺢ"(‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫د‪\ durga_classes> py test.py :‬‬

‫ﺑﺎﻧﻚ‬
‫ﺑﻜﻢ ﻓ ﻲ دورﺟﺎ‬‫ﺒﺎ‬
‫ﻣﺮﺣ‬
‫أدﺧﻞ اﺳﻤﻚ‪ :‬دورﺟﺎ‬
‫د‪ -‬اﻹﻳﺪاع‬
‫ث‪-‬ﺳﺤ ﺐ‬
‫ﺘﺮوﻧ ﻲ‬
‫اﻟﻤﺨﺮج اﻹﻟﻜ‬
‫ﺘﺮ ﺧﻴﺎرك‪ :‬د‬

‫اﺧ‬
‫ﺒﻠﻎ‪10000 :‬‬
‫أدﺧﻞ اﻟﻤ‬
‫ﺑﻌﺪ اﻹﻳﺪاع‪10000.0 :‬‬‫اﻟﺮﺻﻴﺪ‬
‫ﺘﺮ ﺧﻴﺎرك‪ :‬د‬

‫اﺧ‬
‫ﺒﻠﻎ‪20000 :‬‬
‫ﺑﻌﺪ اﻹﻳﺪاع‪30000.0 :‬‬‫اﻟﺮﺻﻴﺪ‬
‫ﺘﺮ ﺧﻴﺎرك‪w :‬‬

‫اﺧ‬
‫ﺒﻠﻎ‪2000 :‬‬
‫ﺑﻌﺪ اﻟ ﺴﺤ ﺐ‪28000.0 :‬‬‫اﻟﺮﺻﻴﺪ‬
‫ﺘﺮ ﺧﻴﺎرك‪r :‬‬

‫اﺧ‬
‫ﺘﻴﺎر ﺧﻴﺎر ﺻﺎﻟﺢ‬

‫ﺧﻴﺎر ﻏﻴﺮ ﺻﺎﻟﺢ ‪ ..‬اﻟﺮﺟﺎء اﺧ‬
‫‪17‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﺮ ﺧﻴﺎرك‪e :‬‬

‫اﺧ‬
‫ﺷﻜﺮا ﻋﲆ اﻟﺨﺪﻣﺎ ت اﻟﻤﺼﺮﻓﻴ ﺔ‬
‫ﺘﻐﻴﺮا ت اﻟﻤﺤﻠﻴ ﺔ‪:‬‬

‫)‪3‬اﻟﻤ‬
‫ﺒﺎﺷﺮة ‪ ،‬وﻳ ﺴﻤﻰ ﻫﺬا اﻟﻨﻮع ﻣﻦ‬
‫ﺘﻐﻴﺮا ت داﺧﻞ ﻃﺮﻳﻘ ﺔ ﻣ‬
‫ﺒﺮﻣﺞ ‪،‬ﻳﻤﻜﻨﻨﺎ أن ﻧﻌﻠﻦ ﻋﻦ اﻟﻤ‬
‫ﺘ ﺔ ﻟﻠﻤ‬
‫ﺒﺎ ت اﻟﻤﺆﻗ‬
‫ﺘﻄﻠ‬
‫ﺒﻴ ﺔ اﻟﻤ‬
‫ﺘﻠ‬‫ﺑﻌﺾ اﻷﺣﻴﺎن ﻟ‬‫ﻓﻲ‬
‫ﺘ ﺔ‪.‬‬
‫ﺘﻐﻴﺮا ت اﻟﻤﺆﻗ‬
‫ﺘﻐﻴﺮا ت اﻟﻤﺤﻠﻴ ﺔ أو اﻟﻤ‬
‫اﻟﻤ‬
‫ﺘﻤﺎل اﻟﻄﺮﻳﻘ ﺔ‪.‬‬

‫ﺑﻤﺠﺮد اﻛ‬‫ﺗﻼﻓﻬﺎ‬
‫ﺘﻐﻴﺮا ت اﻟﻤﺤﻠﻴ ﺔ ﻓ ﻲ وﻗ ﺖﺗﻨﻔﻴﺬ اﻟﻄﺮﻳﻘ ﺔ وإ‬
‫ﺘﻢ إﻧﺸﺎء اﻟﻤ‬
‫ﺳﻴ‬
‫ﺘﻐﻴﺮا ت اﻟﻤﺤﻠﻴ ﺔ ﻟﻠﻄﺮﻳﻘ ﺔ ﻣﻦ ﺧﺎرج اﻟﻄﺮﻳﻘ ﺔ‪.‬‬

‫ﻻﻳﻤﻜﻦ اﻟﻮﺻﻮل إﱃ اﻟﻤ‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪10) t.m2 () :‬‬

‫ﺘ‬‫)‪1‬اﺧ‬
‫)( ‪8) t = Test () 9) t .m1‬‬
‫‪6) b = 2000=7)1000‬‬
‫)‪ (b‬أ‪print‬‬
‫‪(a) (self):‬‬
‫‪m1‬‬ ‫)‪5) def 3‬‬
‫‪m2‬‬‫‪4)(self):‬‬
‫‪print‬‬
‫‪2) def‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫‪1000‬‬
‫‪2000‬‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪m2 (self): 6) b = 2000 7) print (a) #NameError: name 'a' :‬‬
‫ﺘ‬‫)‪1‬اﺧ‬
‫ﺘﻢﺗﻌﺮﻳﻔﻪ )( ‪11) t.m2‬‬
‫‪2) def m1 (self): 3) a = 1000 4) print (a) 5) def‬ﻟﻢﻳ‬
‫)( ‪8) print (b) 9) t = Test () 10) t.m1‬‬
‫‪18‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫أﻧﻮاع اﻟﻄﺮق‪:‬‬
‫ﺜﻮن ﻣﻦ اﻟﻔﺌ ﺔ ‪3‬‬
‫ﺑﺎﻳ‬‫ﺑﺄﻧﻮاع ﻣﻦ اﻟﻄﺮق داﺧﻞ‬‫ُﺴﻤﺢ‬
‫ﻳ‬
‫ﺜﻴﻞ‬
‫)‪2‬ﻃﺮق اﻟﻔﺼﻞ‬
‫ﺘﺔ‬
‫ﺜﻴﻞ‪:‬‬
‫ﺘﻐﻴﺮا ت اﻟﺤﺎﻟ ﺔ ‪ ،‬ﻓﻬﺬا اﻟﻨﻮع ﻣﻦ‬
‫ﺘﺨﺪم ﻣ‬
‫ﺗﻨﻔﻴﺬ اﻷﺳﻠﻮ ب اﻟﺪاﺧﻠ ﻲ إذا ﻛﻨﺎ ﻧ ﺴ‬
‫ﺜﻴﻞ‪.‬‬
‫ﺗ ﺴﻤﻰ اﻷﺳﺎﻟﻴ ﺐ أﺳﺎﻟﻴ ﺐ اﻟﻤ‬
‫ﺗ ﻲ(‪:‬‬
‫ﺗ ﻲ‪)def m1 .‬ذا‬
‫ﺜﻴﻞ ‪ ،‬ﻋﻠﻴﻨﺎﺗﻤﺮﻳﺮ اﻟﻤ‬
‫ﺘﺼﺮﻳﺢ ﻋﻦ ﻃﺮﻳﻘ ﺔ اﻟﻤ‬
‫داﺧﻞ اﻟ‬
‫ﺘﻐﻴﺮا ت اﻟﺤﺎﻟ ﺔ‪.‬‬

‫ﺗ ﻲ ‪،‬ﻳﻤﻜﻨﻨﺎ اﻟﻮﺻﻮل إﱃ ﻣ‬
‫ﺘﺨﺪام ﻃﺮﻳﻘ ﺔ اﻟﻤ‬
‫ﺑﺎﺳ‬
‫ﺗ ﻲ وﻣﻦ ﺧﺎرج‬
‫ﺘﺪﻋﺎء ﻃﺮﻳﻘ ﺔ اﻟﻤ‬
‫داﺧﻞ اﻟﻔﺼﻞﻳﻤﻜﻨﻨﺎ اﺳ‬
‫ﺘﺨﺪام ﻣﺮﺟﻊ اﻟﻜﺎﺋﻦ‪.‬‬
‫ﺑﺎﺳ‬‫ﺘﺪﻋﺎؤ ﻫﺎ‬
‫ﺘ ﻲﻳﻤﻜﻨﻨﺎ اﺳ‬
‫اﻟﻔﺌ ﺔ اﻟ‬
‫‪1) class Student: 2) def __init __ (self، name،‬اﻟﻌﻼﻣﺎ ت(‪= :‬‬

‫‪3) self.name = name 4) self.marks‬اﻟﻌﻼﻣﺎ ت )‪5‬ﻋﺮض )‪7‬‬
‫ﻋﻼﻣﺎ ت‬
‫‪= 60:‬‬
‫ﻲ‪، ':‬‬
‫ﺗﻚ ﻫ)‪10‬‬
‫ﺗﻴ ﺔ<‬
‫ﻋﻼﻣﺎ‬
‫ﺒﻊ ت'( اﻟﺬا‬
‫اﻟﻌﻼﻣﺎ‬
‫‪(self):‬ﺖ‪def‬اﻃ‬
‫)‪9‬إذا ﻛﺎﻧ‬
‫ﺔ(‪6) :‬‬
‫‪print‬‬
‫ﺗﻴ‬
‫‪)('Hi'،‬ذا‬
‫‪self.name‬ﺔ ‪def‬‬
‫ﺗﻴ ﺔ( )‪8‬درﺟ‬
‫ذا‬
‫)‬
‫‪== 50:12‬‬
‫ت< )) ‪35:14‬‬
‫ﺗﻴ ﺔ<‬
‫اﻟﻌﻼﻣﺎ‬
‫‪elif‬اﻟﺬا‬
‫‪ elif‬ت)‪11‬‬
‫ﻋﻼﻣﺎ‬‫‪self.‬‬
‫ﻷوﱃ'( )‪13‬‬
‫ﺜﺎﻧﻴ ﺔ'(‬
‫اﻟﺪرﺟﺔﺔاﻟا‬
‫ﻋﲆاﻟﺪرﺟ‬
‫ﺖﻋﲆ‬
‫ﺣﺼﻠﺖ‬
‫)'ﺣﺼﻠ‬
‫ﺒﻊ '(‬
‫اﻃ‬
‫ﺒﻊ )"ﻟﻘﺪ ﻓﺸﻠ ﺖ" (‬
‫ﺜ ﺔ'( )‪15‬وإﻻ‪16) :‬اﻃ‬
‫ﺜﺎﻟ‬
‫ﺒﻊ '(ﺣﺼﻠ ﺖ ﻋﲆ اﻟﺪرﺟ ﺔ اﻟ‬
‫اﻃ‬
‫)'أدﺧﻞ‪(n):‬‬
‫اﻟﻨﻄﺎق )‪19‬‬ ‫=ﻲ‬
‫)اﻹدﺧﺎل‬ ‫‪i int‬ﻓ‬
‫)‪18‬ﻟـ‬ ‫اﻟﻄﻼ ب‪((':‬‬
‫اﻟﻌﻼﻣﺎ ت‬ ‫ﻋﺪد )‪20‬‬ ‫)'أدﺧﻞ‬
‫ﺳﻢ‪(':‬‬ ‫‪17) n‬‬
‫)'أدﺧﻞ اﻻ‬ ‫‪= int =(input‬‬
‫اﻹدﺧﺎل‬ ‫اﻻﺳﻢ‬
‫اﻟﻄﺎﻟ ﺐ )اﻻﺳﻢ ‪ ،‬اﻟﻌﻼﻣﺎ ت( )‪() 23) s.grade () 24‬‬
‫))' )(‬ ‫)‪21‬‬
‫ﺒﺎﻋ ﺔ‬ ‫‪s =s.display‬‬
‫)‪22‬ﻃ‬ ‫اﻟﻌﻼﻣﺎ ت‪:‬‬
‫‪Ouput:‬‬
‫أدﺧﻞ ﻋﺪد اﻟﻄﻼ ب‪2 :‬‬
‫‪19‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫أدﺧﻞ اﻻﺳﻢ‪ :‬دورﺟﺎ‬

‫أدﺧﻞ اﻟﻌﻼﻣﺎ ت‪90 :‬‬
‫ﺒﺎ دورﺟﺎ‬
‫ﻣﺮﺣ‬
‫ﺗﻚ ﻫ ﻲ‪90 :‬‬
‫ﻋﻼﻣﺎ‬
‫ﻟﻘﺪ ﺣﺼﻠ ﺖ ﻋﲆ اﻟﺪرﺟ ﺔ اﻷوﱃ‬
‫أدﺧﻞ اﻻﺳﻢ‪ :‬راﻓ ﻲ‬
‫ﺒﺎ راﻓ ﻲ‬
‫ﻣﺮﺣ‬
‫ﺗﻚ ﻫ ﻲ‪12 :‬‬

‫ﻋﻼﻣﺎ‬
‫أﻧ ﺖ ﻓﺎﺷﻞ‬
‫ﻃﺮق ‪Setter‬و ‪Getter:‬‬

‫ﺘﺨﺪام ﻃﺮق ‪getter‬و ‪setter.‬‬
‫ﺑﺎﺳ‬‫ﺘﻐﻴﺮا ت اﻟﺤﺎﻟ ﺔ واﻟﺤﺼﻮل ﻋﻠﻴﻬﺎ‬
‫ﻳﻤﻜﻨﻨﺎﺗﻌﻴﻴﻦ ﻗﻴﻢ ﻣ‬
‫ﻃﺮﻳﻘ ﺔ اﻟﻮاﺿﻊ‪:‬‬
‫ﺑﺎﺳﻢ ﻃﺮق اﻟﻄﻔﺮا ت‪.‬‬ ‫ُﻌﺮف ﻃﺮق اﻟﻮاﺿﻊ أ ً‬
‫ﻳﻀﺎ‬ ‫ﺘﻐﻴﺮا ت اﻟﺤﺎﻟ ﺔ‪.‬ﺗ‬
‫ﺘﻌﻴﻴﻦ اﻟﻘﻴﻢ إﱃ ﻣ‬
‫ﺘﺨﺪام ﻃﺮق ‪setter‬ﻟ‬
‫ﺘﻐﻴﺮ‬
‫ﺑﻨﺎء اﻟﺠﻤﻠ ﺔ‪def setVariable (self، variable): self.variable = :‬ﻣ‬
‫ﺜﺎل‪def setName (self، name): self.name = name :‬‬

‫ﻣ‬
‫ﺑﺎﺳﻢ ﻃﺮق اﻟﻮﺻﻮل‪.‬‬ ‫ُﻌﺮف ﻃﺮق ‪Getter‬أ ً‬

‫ﻳﻀﺎ‬ ‫ﺘﻐﻴﺮا ت اﻟﺤﺎﻟ ﺔ‪.‬ﺗ‬
‫ﺘﺨﺪام ﻃﺮق ‪Getter‬ﻟﻠﺤﺼﻮل ﻋﲆ ﻗﻴﻢ ﻣ‬
‫ﻃﺮﻳﻘ ﺔ ‪Getter:‬ﻳﻤﻜﻦ اﺳ‬
‫ﺑﻨﺎء اﻟﺠﻤﻠ ﺔ‪def getVariable (self): :‬‬
‫ﺘﻐﻴﺮ‬
‫ﺗﻴ ﺔ ﻣ‬
‫اﻟﻌﻮدة اﻟﺬا‬
‫ﺜﺎل‪def getName (self): return self.name :‬‬

‫ﻣ‬
‫ﺗ ﻲ ‪ ،‬اﻻﺳﻢ(‪:‬‬
‫‪)1) class Student: 2) def setName‬ذا‬
‫)‪3) self.name = name 4‬‬
‫‪20‬‬
‫ﺑﺎد ‪- 500038 ،‬‬ ‫ﺑﻴ ﺖ‬ ‫ﺘﺮ‪#‬‬
‫ﻳﻔﺎﻧﺎم ‪ ،‬أﻣﻴﺮ‬ ‫‪202،‬‬ ‫ﺑﻖ ‪2 ،‬‬
‫‪def getMarks (self): 12) return self.marks 13 ) 14) n = int (input‬‬
‫ب‪15) ((':‬‬
‫اﻟﻄﻼ )‪7) 8‬‬
‫‪def setMarks‬‬
‫)‪')5‬أدﺧﻞ ﻋﺪد‬
‫‪(self،‬‬
‫‪defmarks):‬‬
‫‪getName‬‬‫‪9) (self):‬‬
‫‪self.marks‬‬
‫‪6) return‬‬
‫‪= Mark‬‬
‫‪self.name‬‬
‫)‪10) 11‬‬
‫ﻟـ ‪i‬ﻓ ﻲ اﻟﻨﻄﺎق ‪() 17) name = input ('Enter Name:') 18) s .setName‬‬
‫‪)(n): 16) s = Student‬اﻻﺳﻢ( )‪19‬اﻟﻌﻼﻣﺎ ت ‪s.getName ()) 23) print ('Your‬‬
‫))'‪(input ('Enter Marks:‬‬

‫)‪20‬ﺔ )(‬
‫ﺒﺎﻋ‬‫‪s.setMarks‬ﻃ‬
‫‪'، s.getMarks‬‬
‫)‪(Marks‬‬
‫)‪()) 24)21‬‬
‫)‪22‬ﻫ ﻲ‪:‬‬
‫‪ print‬ت‬
‫‪('Hi'،‬اﻟﻌﻼﻣﺎ‬
‫‪= int‬‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫د‪\ python_classes> py test.py :‬‬

‫أدﺧﻞ ﻋﺪد اﻟﻄﻼ ب‪2 :‬‬
‫أدﺧﻞ اﻻﺳﻢ‪ :‬دورﺟﺎ‬

‫ﺒﺎ دورﺟﺎ‬
‫ﻣﺮﺣ‬
‫ﺗﻚ ﻫ ﻲ‪100 :‬‬
‫ﻋﻼﻣﺎ‬
‫أدﺧﻞ اﻻﺳﻢ‪ :‬راﻓ ﻲ‬
‫ﺒﺎ راﻓ ﻲ‬
‫ﻣﺮﺣ‬
‫ﺗﻚ ﻫ ﻲ‪80 :‬‬

‫ﻋﻼﻣﺎ‬
‫)‪2‬ﻃﺮق اﻟﻔﺼﻞ‪:‬‬
‫ﺘ ﺔ( ‪ ،‬ﻓﺈن ﻫﺬا اﻟﻨﻮع ﻣﻦ اﻷﺳﺎﻟﻴ ﺐﻳﺠ ﺐ أن ﻧﻌﻠﻦ ﻋﻨﻪ ﻛﻄﺮﻳﻘ ﺔ ﺻﻨﻔﻴ ﺔ‪.‬‬
‫ﺘﻐﻴﺮا ت اﻟﺼﻨﻒ )اﻟﻤ‬
‫ﺘﺨﺪم ﻓﻘﻂ ﻣ‬
‫ﺗﻨﻔﻴﺬ اﻷﺳﻠﻮ ب اﻟﺪاﺧﻠ ﻲ إذا ﻛﻨﺎ ﻧ ﺴ‬
‫ﺘﻐﻴﺮ ‪cls‬ﻓ ﻲ وﻗ ﺖ اﻹﻋﻼن‬

‫ﺒ ﺔ ﻟﻄﺮﻳﻘ ﺔ اﻟﻔﺌ ﺔ ‪،‬ﻳﺠ ﺐﺗﻮﻓﻴﺮ ﻣ‬
‫‪decorator.‬‬ ‫ﺘﺨﺪام‪dohtemssalc‬‬
‫ﺑﺎﺳ‬‫ﺑﺸﻜﻞ ﺻﺮﻳﺢ‬‫ﺘﺼﺮﻳﺢ ﻋﻦ ﻃﺮﻳﻘ ﺔ اﻟﺼﻨﻒ‬
‫ﻳﻤﻜﻨﻨﺎ اﻟ‬
‫ﺘﻐﻴﺮ ﻣﺮﺟﻊ اﻟﻜﺎﺋﻦ‪.‬‬

‫ﺘﺨﺪام اﺳﻢ اﻟﻔﺌ ﺔ أو ﻣ‬
‫ﺑﺎﺳ‬
‫ﺘﺪﻋﺎء ‪classmethod‬‬
‫ﻳﻤﻜﻨﻨﺎ اﺳ‬
‫‪21‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫)‪1‬ﻓﺌ ﺔ اﻟﺤﻴﻮان‪(cls، name): 5) :‬‬

‫‪= 4 3) classmethod 4) def walk‬‬
‫‪2) lEgs‬‬
‫ﺗﻨ ﺴﻴﻖ )اﻻﺳﻢ ‪cls.lEgs)) ،‬‬

‫ﺒﺎﻋ ﺔ }{"(ﻳﻤﺸ ﻲ ﻣﻊ ‪{} lEgs ...".‬‬
‫ﻃ‬
‫‪")6) Animal.walk‬ﻛﻠ ﺐ"(‬
‫)'‪7) Animal.walk ('Cat‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﻛﻠ ﺐﻳﻤﺸ ﻲ ب ‪4‬أرﻃﺎل ‪...‬‬
‫ﻗﻄ ﺔﺗﻤﺸ ﻲ ب ‪4‬أرﻃﺎل ‪...‬‬
‫ﺘ ﻲﺗﻢ إﻧﺸﺎؤ ﻫﺎ ﻟﻠﻔﺼﻞ‪:‬‬

‫ﺒﻊ ﻋﺪد اﻟﻜﺎﺋﻨﺎ ت اﻟ‬
‫ﺘ‬‫ﺘ‬‫ﺑﺮﻧﺎﻣﺞ ﻟ‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪2) :‬اﻟﻌﺪ __ ‪= 0 3) def __init‬‬

‫ﺘ‬‫)‪1‬اﺧ‬
‫ﺗ ﻲ(‪4) :‬‬
‫)ذا‬
‫)( ‪8) 9) t1 = Test () 10) t2 = Test‬‬
‫)‪classmethod 6) def noOfObjects (cls): 7‬‬

‫)‪Test.count = Test.count + 1 5‬‬
‫ﺒﺎر‪cls.count) ، ":‬‬
‫ﺘ‬‫ﺘ ﻲﺗﻢ إﻧﺸﺎؤ ﻫﺎ ﻟﻔﺌ ﺔ اﻻﺧ‬
‫"( ‪print‬ﻋﺪد اﻟﻌﻨﺎﺻﺮ اﻟ‬
‫)( ‪t3 = Test () 13) t4 = Test () 14) t5 = Test‬‬

‫)‪11) Test.noOfObjects () 12‬‬
‫)( ‪15) Test.noOfObjects‬‬
‫ﺘ ﺔ‪:‬‬
‫ﺑﺸﻜﻞ ﻋﺎم ‪ ،‬ﻫﺬه اﻟﻄﺮق ﻫ ﻲ ﻃﺮق اﻟﻤﻨﻔﻌ ﺔ اﻟﻌﺎﻣ ﺔ‪.‬‬
‫ﺘﻐﻴﺮا ت ﻓﺌ ﺔ‪.‬‬
‫ﺜﻴﻞ أو ﻣ‬
‫ﺘﺨﺪم أي ﻣ‬
‫داﺧﻞ ﻫﺬه اﻟﻄﺮق ‪ ،‬ﻟﻦ ﻧ ﺴ‬
‫ﺗﻴ ﺔ أو ‪cls‬ﻓ ﻲ وﻗ ﺖ اﻹﻋﻼن‪.‬‬
‫ﻫﻨﺎ ﻟﻦ ﻧﻘﺪم اﻟﺤﺠﺞ اﻟﺬا‬
‫ﺘﺨﺪام‪decorator dohtemcitats‬‬
‫ﺑﺎﺳ‬‫ﺑﺸﻜﻞ ﺻﺮﻳﺢ‬‫ﺘﺔ‬
‫ﺘﺼﺮﻳﺢ ﻋﻦ اﻟﻄﺮﻳﻘ ﺔ اﻟ‬
‫ﻳﻤﻜﻨﻨﺎ اﻟ‬
‫ﺘﺨﺪام اﺳﻢ اﻟﻔﺌ ﺔ أو ﻣﺮﺟﻊ اﻟﻜﺎﺋﻦ‬
‫ﺑﺎﺳ‬‫ﺘﺔ‬
‫ﻳﻤﻜﻨﻨﺎ اﻟﻮﺻﻮل إﱃ اﻷﺳﺎﻟﻴ ﺐ اﻟ‬
‫)‪1) class DurgaMath: 2) 3) staticmethod 4) def add (x، y): 5) print ('The Sum:'، x + y) 6‬‬

‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫)‪def product (x، y): 9) 10) 11) staticmethod 12‬‬

‫ﺘﻮﺳﻂ )‪(x + y) / 2) 13) 14‬‬
‫)‪7) staticmethod 8‬ﻣ‬
‫‪def‬‬
‫ص(‬ ‫‪(x،‬‬
‫‪* y):‬‬
‫‪print‬س‬ ‫‪('The‬‬
‫‪(" average:'،‬اﻟﻤﻨ‬
‫ﺘﺞ‪، ":‬‬ ‫ﺒﺎﻋ ﺔ‬
‫ﻃ‬
‫)‪15) DurgaMath.add (10،20‬‬

‫)‪16) DurgaMath.product (10،20‬‬
‫)‪17) DurgaMath.average (10،20‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫اﻟﻤﺠﻤﻮع‪30 :‬‬
‫ﺘﺞ‪200 :‬‬
‫اﻟﻤﻨ‬
‫ﺘﻮﺳﻂ‪15.0 :‬‬
‫اﻟﻤ‬
‫ﺘﺔ‬
‫ﺘ ﺔ ﻓﻘﻂ ‪ ،‬وﻳﻤﻜﻨﻨﺎ ذﻟﻚ داﺧﻞ اﻟﻄﺮﻳﻘ ﺔ اﻟ‬
‫ﺜﻴﻞ واﻟﻄﺮق اﻟ‬
‫ﺘﺨﺪام ﻃﺮق اﻟﻤ‬
‫ﺑﺸﻜﻞ ﻋﺎم ‪،‬ﻳﻤﻜﻨﻨﺎ اﺳ‬
‫•‬
‫ﺘﺨﺪام اﺳﻢ اﻟﻔﺌ ﺔ‪.‬‬
‫ﺑﺎﺳ‬‫ﺘﻮى اﻟﻔﺌ ﺔ‬
‫اﻟﻮﺻﻮل إﱃ ﻣ‬
‫ﺜﻮن‪.‬‬
‫ﺒﺎﻳ‬
‫ﺘﺨﺪاﻣﺎ ﻓ ﻲ ﻟﻐ ﺔ اﻟ‬
‫ً‬ ‫ﺜﺮ اﺳ‬
‫ﺘﺼﻨﻴﻒ ﻫ ﻲ اﻷﺳﺎﻟﻴ ﺐ اﻷﻛ‬
‫ﺒﺮ ﻃﺮق اﻟ‬
‫ﺘ‬‫ﺗﻌ‬
‫•‬
‫ﺗﻤﺮﻳﺮ أﻋﻀﺎء ﻓﺼﻞ دراﺳ ﻲ إﱃ ﻓﺼﻞ آﺧﺮ‪:‬‬

‫ﻳﻤﻜﻨﻨﺎ اﻟﻮﺻﻮل إﱃ أﻋﻀﺎء ﻓﺼﻞ واﺣﺪ داﺧﻞ ﻓﺼﻞ آﺧﺮ‪.‬‬
‫)‪display (self): 7) print ('Employee Number:'، self.eno) 8‬‬

‫‪2) def __init __ (self، eno، ename، esal): 3) 4) 5) 6) def‬‬
‫‪= ename‬‬
‫)‪self.ename‬‬ ‫ﺳﻢ‪self.esal‬‬
‫اﻟﻤﻮﻇﻒ‪9) ،':‬‬ ‫‪esal‬ا =‬
‫ﺒﺎﻋ ﺔ '(‬
‫‪1) class Employee:‬ﻃ‬
‫ﺗﻌﺪﻳﻞ =‬‫‪self.eno‬‬
‫)‪11‬‬ ‫ﺒﺎر=اﻟﻔﺌ ﺔ ‪:‬‬
‫‪eno‬‬
‫ﺘ‬ ‫‪self.ename‬‬
‫)‪self.esal‬اﺧ‬ ‫ﺗ ﺐ اﻟﻤﻮﻇﻒ‪10) ،':‬‬
‫ﺒﺎﻋ ﺔ '(را‬
‫ﻃ‬
‫‪12) emp.esal = emp.esal + 10000 13 ) emp.display () 14) e‬‬
‫‪def (emp):‬اﻟﻤﻮﻇﻒ ‪"(100،‬دورﺟﺎ"‪10000) 15) ،‬‬
‫‪ )Test.modify‬ﻫـ(‬
‫‪23‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫رﻗﻢ اﻟﻤﻮﻇﻒ‪100 :‬‬
‫اﺳﻢ اﻟﻤﻮﻇﻒ‪ :‬دورﺟﺎ‬
‫ﺗ ﺐ اﻟﻤﻮﻇﻒ‪20000 :‬‬
‫را‬
‫ﺒﺎر‪.‬‬
‫ﺘ‬‫ﺘﺎﺣﻮن ﻟﻔﺌ ﺔ اﻻﺧ‬
‫ﺒﻴﻖ أﻋﻼه ‪ ،‬أﻋﻀﺎء ﻓﺌ ﺔ اﻟﻤﻮﻇﻒ ﻣ‬
‫ﺘﻄ‬‫ﻓ ﻲ اﻟ‬
‫ﺒﻘﺎ ت اﻟﺪاﺧﻠﻴ ﺔ‬
‫اﻟﻄ‬
‫ﺑﺎﻟﻔﺌﺎ ت اﻟﺪاﺧﻠﻴ ﺔ‪.‬‬‫ﺑﻌﺾ اﻷﺣﻴﺎنﻳﻤﻜﻨﻨﺎ اﻹﻋﻼن ﻋﻦ ﻓﺌ ﺔ داﺧﻞ ﻓﺌ ﺔ أﺧﺮى ‪،‬ﻳ ﺴﻤﻰ ﻫﺬا اﻟﻨﻮع ﻣﻦ اﻟﻔﺌﺎ ت‬‫ﻓﻲ‬
‫ﺑﺪون وﺟﻮد ﻧﻮع واﺣﺪ ﻣﻦ اﻟﻌﻨﺎﺻﺮ إذا ﻟﻢﺗﻜﻦ ﻫﻨﺎك ﻓﺮﺻ ﺔ ﻟﻮﺟﻮد ﻧﻮع آﺧﺮ ﻣﻦ اﻟﻜﺎﺋﻨﺎ ت ‪،‬‬
‫ﺛﻢﻳﺠ ﺐ أن ﻧﺬ ﻫ ﺐ ﻟﻠﻔﺼﻮل اﻟﺪاﺧﻠﻴ ﺔ‪.‬‬
‫ﺛﻢﻳﺠ ﺐ أنﺗﻜﻮن ﻓﺌ ﺔ اﻟﻤﺤﺮك ﺟﺰءًا ﻣﻦ ﻓﺌ ﺔ اﻟ ﺴﻴﺎرة‪.‬‬‫ﺑﺪون ﻛﺎﺋﻦ اﻟ ﺴﻴﺎرة اﻟﻤﻮﺟﻮد ﻻﺗﻮﺟﺪ ﻓﺮﺻ ﺔ ﻟﻮﺟﻮد ﻛﺎﺋﻦ اﻟﻤﺤﺮك‪ .‬وﻣﻦ‬‫ﺜﺎل‪:‬‬
‫ﻣ‬
‫ﻓﺌ ﺔ اﻟ ﺴﻴﺎرة‪:‬‬
‫‪.....‬‬
‫ﻓﺌ ﺔ اﻟﻤﺤﺮك‪:‬‬
‫‪......‬‬
‫ﺑﺪون ﻛﺎﺋﻦ ﺟﺎﻣﻌ ﻲ ﻣﻮﺟﻮد ‪ ،‬ﻻﺗﻮﺟﺪ ﻓﺮﺻ ﺔ ﻟﻮﺟﻮد ﻛﺎﺋﻦ ﻗ ﺴﻢ ﻣﻮﺟﻮد‬‫ﺜﺎل‪:‬‬

‫ﻣ‬
‫ﻓﺌ ﺔ اﻟﺠﺎﻣﻌ ﺔ‪:‬‬

‫‪.....‬‬
‫ﻗ ﺴﻢ اﻟﻔﺼﻞ‪:‬‬
‫‪......‬‬
‫ﺛﻢﻳﺠ ﺐ أنﻳﻜﻮن اﻟﺮأس ﺟﺰءًا ﻣﻦ اﻹﻧ ﺴﺎن‪.‬‬‫ﺑﺪون وﺟﻮد اﻹﻧ ﺴﺎن ﻻﺗﻮﺟﺪ ﻓﺮﺻ ﺔ ﻟﻮﺟﻮد اﻟﺮأس‪ .‬وﻣﻦ‬‫ﺜﺎل‪:‬‬
‫ﻣ‬
‫ﻓﺌ ﺔ اﻹﻧ ﺴﺎن‪:‬‬

‫ﺋﻴ ﺲ اﻟﻔﺼﻞ‪:‬‬
‫ر‬
‫ﺑﺪون ﻛﺎﺋﻦ ﻓﺌ ﺔ ﺧﺎرﺟ ﻲ ﻻﺗﻮﺟﺪ ﻓﺮﺻ ﺔ ﻟﻮﺟﻮد ﻛﺎﺋﻦ ﻓﺌ ﺔ داﺧﻠ ﻲ‪.‬‬‫ﻣﻼﺣﻈ ﺔ‪:‬‬
‫ﺑﻜﺎﺋﻦ اﻟﻔﺌ ﺔ اﻟﺨﺎرﺟﻴ ﺔ‪.‬‬‫ﺋﻤﺎ‬
‫ﺒﻂ ﻛﺎﺋﻦ اﻟﻔﺌ ﺔ اﻟﺪاﺧﻠﻴ ﺔ دا ً‬
‫ﺗ‬‫ﺛﻢﻳﺮ‬‫وﻣﻦ‬
‫‪24‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺒ ﻲ ‪-1:‬‬
‫ﺘﺠﺮﻳ‬
‫ﺒﺮﻧﺎﻣﺞ اﻟ‬
‫اﻟ‬
‫‪Inner: 5) def __init __ (self): 6) print ("inter class object‬‬

‫‪(self): 3) print ("external class object create") 4) class‬‬
‫‪m1‬‬ ‫‪(self):‬‬
‫)‪() 11‬‬ ‫‪i.m18)()print‬‬ ‫إﻧﺸﺎء"(‬
‫اﻟﺨﺎرﺟ ﻲ‬ ‫ﺔ"( )‪9) o =1‬‬
‫‪class‬‬
‫‪ Outer:‬ﻟﻠﻔﺌ‬
‫)‪ 2‬اﻟﺪاﺧﻠﻴ ﺔ‬ ‫‪def‬‬
‫ﻳﻘ ﺔ‬ ‫‪__init‬‬
‫)"اﻟﻄﺮ‬ ‫__‬
‫‪7) def‬‬
‫‪() 10) i = o.Inner‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﺒﻘ ﺔ اﻟﺨﺎرﺟﻴ ﺔ‬
‫إﻧﺸﺎء ﻛﺎﺋﻦ اﻟﻄ‬
‫ﺒﻘ ﺔ اﻟﺪاﺧﻠﻴ ﺔ‬‫إﻧﺸﺎء ﻛﺎﺋﻦ اﻟﻄ‬
‫ﺒﻘ ﺔ اﻟﺪاﺧﻠﻴ ﺔ‬
‫ﻃﺮﻳﻘ ﺔ اﻟﻄ‬
‫ﺒﻘ ﺔ اﻟﺪاﺧﻠﻴ ﺔ‬
‫ﺘﺪﻋﺎء ﻃﺮﻳﻘ ﺔ اﻟﻄ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬ﻓﻴﻤﺎﻳﻠ ﻲ اﻟﻌﺪﻳﺪ ﻣﻦ اﻟﺼﻴﻎ اﻟﻤﻤﻜﻨ ﺔ ﻻﺳ‬
‫)‪ 1‬س =اﻟﺨﺎرﺟ ﻲ )(‬

‫أﻧﺎ = س اﻟﺪاﺧﻠﻴ ﺔ )(‬
‫)( ‪i.m1‬‬
‫)‪2‬أﻧﺎ =ﺧﺎرﺟ ﻲ ‪().‬داﺧﻠ ﻲ )(‬

‫)( ‪i.m1‬‬
‫)‪3‬اﻟﺨﺎرﺟ ﻲ ‪().‬اﻟﺪاﺧﻠ ﻲ ‪().‬م )( ‪1‬‬
‫ﺒ ﻲ ‪-2:‬‬
‫ﺘﺠﺮﻳ‬
‫اﻟ‬
‫)‪(self): 6) 7) 8) 9) 10 ) 11) 12) 13‬‬

‫‪= self.Dob () 5) def display‬‬
‫‪Person:‬‬ ‫'‪= 'durga‬‬
‫‪2) def‬‬ ‫‪__init __4)(self):‬‬
‫‪self.db‬‬
‫)‪3‬‬
‫‪1) class‬‬
‫‪(self): self.dd = 10 self.mm = 5‬‬

‫__ ‪self.name) class Dob: def __init‬‬
‫‪print ('Name:'،‬‬
‫= ‪self.yy‬ﻋﺮض ‪def‬‬
‫ﺗ ﻲ(‪:‬‬
‫‪)1947‬ذا‬
‫ﺗﻨ ﺴﻴﻖ ))‪(self.dd، self.mm، self.yy‬‬
‫ﺒﺎﻋ ﺔ ‪('Dob = {} / {} / {}'.‬‬
‫ﻃ‬
‫‪25‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫اﻟﺸﺨﺺ‬14) p =
17) x.display ()
() 16) x = p.db
() 15) p.display
| ‫ﺘﺎج‬
‫اﻧ‬
‫ دورﺟﺎ‬:‫اﻻﺳﻢ‬
= 10/5/1947 ‫دو ب‬
-3: ‫ﺒ ﻲ‬
‫ﺘﺠﺮﻳ‬
‫اﻟ‬
.‫ﺒﻘﺎ ت اﻟﺪاﺧﻠﻴ ﺔ‬
‫داﺧﻞ اﻟﻔﺼﻞﻳﻤﻜﻨﻨﺎ أن ﻧﻌﻠﻦ ﻋﻦ أي ﻋﺪد ﻣﻦ اﻟﻄ‬
= self.Brain () 7) def :‫ﻓﺌ ﺔ اﻹﻧ ﺴﺎن‬1)

self.head = self.Head () 6) self.brain
__ (self): 4) self.name = 'Sunny' 5)
(self):
13) 16)
14) print ‫ﻋﺮض‬2)15)
class Brain: 3) def think
__init
(self):
talk 8)
(self):
9) 10)
12)
class
print
Head:
('Talking
11) def
...')
19) h. ()‫ﺴﺎن‬
21)‫اﻹﻧ‬
h.brain.think
17) 18) h = ('...
() ‫اﻟﻌﺮض‬
‫ﺘﻔﻜﻴﺮ‬
‫)'اﻟ‬
()
() 20) h.head.talk
print ("Hello .." ، self.name)
| ‫ﺘﺎج‬
‫اﻧ‬
‫ ﻣﺸﻤ ﺲ‬.. ‫ﺒﺎ‬
‫ﻣﺮﺣ‬
...‫ﺘﺤﺪ ث‬
‫ﺗ‬
... ‫ﺘﻔﻜﻴﺮ‬
‫اﻟ‬
26
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﺟﻤﻊ اﻟﻘﻤﺎﻣ ﺔ‬
‫ﺛﻨﺎء إﻧﺸﺎء ﻛﺎﺋﻦ ‪ ،‬وﻟﻜﻨﻪ‬
‫ﺜﻴ ﺮًا أ‬
‫ﺒﺮﻣﺞ ﻛ‬
‫ﺘﻢ اﻟﻤ‬ ‫ً‬
‫وﻋﺎدة ﻣﺎﻳﻬ‬ ‫ﺒﺮﻣﺞ ﻣ ﺴﺆوﻻ ً ﻋﻦ ﻛﻞ ﻣﻦ إﻧﺸﺎء اﻟﻜﺎﺋﻨﺎ ت و‬
‫ﺗﺪﻣﻴﺮ ﻫﺎ ‪،‬‬ ‫ﺜﻞ ‪C ++ ،‬ﻳﻜﻮن اﻟﻤ‬
‫ﻓ ﻲ اﻟﻠﻐﺎ ت اﻟﻘﺪﻳﻤ ﺔ ﻣ‬
‫ﺑﺄﺷﻴﺎء ﻋﺪﻳﻤ ﺔ اﻟﻔﺎﺋﺪة ﻣﻤﺎﻳﺆدي إﱃ ﻣﺸﺎﻛﻞ ﻓ ﻲ اﻟﺬاﻛﺮة‬‫ﺒ ﺐ ‪nEglectance ،‬ﻳﻤﻜﻦ ﻣﻞء اﻟﺬاﻛﺮة اﻹﺟﻤﺎﻟﻴ ﺔ‬
‫ﺑﺴ‬‫ﺘﺨﻠﺺ ﻣﻦﺗﺪﻣﻴﺮ اﻟﻜﺎﺋﻨﺎ ت ﻋﺪﻳﻤ ﺔ اﻟﻔﺎﺋﺪة‪.‬‬
‫ﻳ‬
‫ﺒﻴﻖ اﻟﻜﻠ ﻲ ﻣﻊ ﺧﻄﺄ ﻧﻔﺎد اﻟﺬاﻛﺮة‪.‬‬
‫ﺘﻄ‬‫وﺳﻮفﻳﻨﺨﻔﺾ اﻟ‬
‫ﺜﻮن ﻣﻊ ﻣﺸﺎﻛﻞ اﻟﺬاﻛﺮة‬

‫ﺑﺎﻳ‬‫ﺑﺮﻧﺎﻣﺞ‬‫ﺘﺪﻣﻴﺮ اﻷﺷﻴﺎء ﻏﻴﺮ اﻟﻤﻔﻴﺪة ‪،‬ﻷن ﻓﺮﺻ ﺔ ﻓﺸﻞ‬
‫ﺋﻤﺎ ﻓ ﻲ اﻟﺨﻠﻔﻴ ﺔ ﻟ‬
‫ﺑﻌﺾ اﻟﻤ ﺴﺎﻋﺪ اﻟﺬيﻳﻌﻤﻞ دا ً‬‫ﺜﻮن ‪ ،‬ﻟﺪﻳﻨﺎ‬
‫ﺑﺎﻳ‬‫ﻟﻜﻦ ﻓ ﻲ‬
‫أﻗﻞ ﺟﺪًا‪ .‬ﻫﺬا اﻟﻤ ﺴﺎﻋﺪ ﻟﻴ ﺲﺳﻮى ﺟﺎﻣﻊ اﻟﻘﻤﺎﻣ ﺔ‪.‬‬
‫ﺋﻴ ﺴ ﻲ ﻟﻤﺠﻤﻊ اﻟﻘﻤﺎﻣ ﺔ ﻫﻮﺗﺪﻣﻴﺮ اﻷﺷﻴﺎء ﻋﺪﻳﻤ ﺔ اﻟﻔﺎﺋﺪة‪.‬‬

‫ﺛﻢ ﻓﺈن اﻟﻬﺪف اﻟﺮ‬‫وﻣﻦ‬
‫ﺘﻐﻴﺮ ﻣﺮﺟﻌ ﻲ ‪ ،‬ﻓﺈن ﻫﺬا اﻟﻜﺎﺋﻦ ﻣﺆ ﻫﻞ ﻟﻠﻘﻤﺎﻣ ﺔ‬

‫ﺘﻮي ﻋﲆ أي ﻣ‬
‫إذا ﻛﺎن اﻟﻜﺎﺋﻦ ﻻﻳﺤ‬
‫ﻣﺠﻤﻮﻋ ﺔ‪.‬‬
‫ﺑﺮﻧﺎﻣﺠﻨﺎ‪:‬‬‫ﺗﻌﻄﻴﻞ ﺟﺎﻣﻊ اﻟﻘﻤﺎﻣ ﺔ ﻓ ﻲ‬

‫ﻛﻴﻔﻴ ﺔﺗﻤﻜﻴﻦ و‬
‫ﺘﺎﻟﻴ ﺔ ﻟﻮﺣﺪة ‪gc.‬‬

‫ﺘﺨﺪام اﻟﻮﻇﺎﺋﻒ اﻟ‬
‫ﺗﻨﺎ‪ .‬ﻓ ﻲ ﻫﺬا اﻟ ﺴﻴﺎق ‪،‬ﻳﻤﻜﻨﻨﺎ اﺳ‬
‫ﺒﺎ‬
‫ﺘﻄﻠ‬
‫ﺑﻨﺎ ًء ﻋﲆ ﻣ‬‫ﺘﺮاﺿ ًﻴﺎ ‪ ،‬وﻟﻜﻦﻳﻤﻜﻨﻨﺎﺗﻌﻄﻴﻠﻬﺎ‬
‫ﺘﻢﺗﻤﻜﻴﻦ أداةﺗﺠﻤﻴﻊ ‪Gargbage‬اﻓ‬
‫ﻳ‬
‫)( ‪1) gc.isenabled‬إرﺟﺎع ﺻﺤﻴﺢ إذاﺗﻢﺗﻤﻜﻴﻦ ‪GC‬‬
‫ﺑﺸﻜﻞ ﺻﺮﻳﺢ‬
‫ﺘﻌﻄﻴﻞ ‪GC‬‬
‫)( ‪2) gc.disable‬ﻟ‬
‫ﺘﻤﻜﻴﻦ ‪GC‬‬
‫)( ‪3) gc.enable‬ﻟ‬
‫ﺘﻴﺮاد ))( ‪6) print (gc.isenabled‬‬

‫)‪1‬اﺳ‬
‫)( ‪(gc.isenabled ()) 5) gc.enable‬‬
‫‪()) 3) gc.disable () 4) print‬‬

‫‪gc 2) print (gc.isenabled‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﺣﻘﻴﻘ ﻲ‬
‫ﺧﻄﺄ ﺷﻨﻴﻊ‬
‫ﺣﻘﻴﻘ ﻲ‬
‫‪27‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫اﻟﻤﺪﻣﺮا ت‪:‬‬
‫ﺘﺪﻣﻴﺮ ﻃﺮﻳﻘ ﺔ ﺧﺎﺻ ﺔ وﻳﺠ ﺐ أنﻳﻜﻮن اﻻﺳﻢ __‪__del‬‬
‫اﻟ‬
‫ﺘﺪﻣﻴﺮ‬
‫ﺘﺪﻋﺎء أداة اﻟ‬
‫ﺑﺎﺳ‬‫ﺋﻤﺎ‬
‫ﺑﺮﻧﺎﻣﺞ ‪Garbage Collector‬دا ً‬‫ﺒﻞﺗﺪﻣﻴﺮ ﻛﺎﺋﻦ ‪،‬ﻳﻘﻮم‬
‫ﻗ‬
‫ﺛﻴﻖ ‪ ،‬إﻟﺦ(‪.‬‬
‫ﺒﻴﺎﻧﺎ ت اﻟﻮ‬
‫ﺗﺼﺎل ﻗﺎﻋﺪة اﻟ‬
‫ﺜﻞ ا‬
‫ﺘﻨﻈﻴﻒ )أﻧﺸﻄ ﺔ إﻟﻐﺎءﺗﺨﺼﻴﺺ اﻟﻤﻮارد ﻣ‬
‫أﻧﺸﻄ ﺔ اﻟ‬
‫ﺘﺪﻣﻴﺮ‬
‫ﺑﺎﻟ‬‫ﺗﻠﻘﺎﺋ ًﻴﺎ‬
‫ﺑﺮﻧﺎﻣﺞ ‪Garbage Collector‬‬‫ﺘﺪﻣﻴﺮ ‪،‬ﻳﻘﻮم‬
‫ﺘﻤﺎلﺗﻨﻔﻴﺬ اﻟ‬
‫ﺑﻤﺠﺮد اﻛ‬
‫ﻫﺬا اﻟﻜﺎﺋﻦ‪.‬‬
‫ﺘﻨﻈﻴﻒ‪.‬‬
‫ﺑﺄﻧﺸﻄ ﺔ اﻟ‬‫ﺘﺪﻣﻴﺮ ﻟﻴ ﺴ ﺖﺗﺪﻣﻴﺮ اﻷﺷﻴﺎء وإﻧﻤﺎ ﻫ ﻲ ﻓﻘﻂ اﻟﻘﻴﺎم‬
‫ﻣﻠﺤﻮﻇ ﺔ‪ :‬وﻇﻴﻔ ﺔ اﻟ‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪Initialization ...") 5) def __del __ (self): 6) print ("Fulfilling Last Wish :‬‬
‫ﺘ‬‫ﺘﻴﺮاد )‪2‬اﺧ‬
‫)‪1‬وﻗ ﺖ اﻻﺳ‬
‫ﺒﺎر = ‪() 9) t1‬ﻻ ﺷ ﻲء )"‬
‫ﺘ‬‫ﺘﻨﻈﻴﻒ ‪") 7) 8) t1 = ...‬اﺧ‬
‫‪3) def __init __ (self): 4) print ("Object‬وأداء أﻧﺸﻄ ﺔ اﻟ‬
‫‪10) time.sleep (5) 11) print (" End of application‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﺗﻬﻴﺌ ﺔ اﻟﻜﺎﺋﻦ ‪...‬‬
‫ﺘﻨﻈﻴﻒ ‪...‬‬
‫ﺒﺎ ت وأداء أﻧﺸﻄ ﺔ اﻟ‬
‫ﺑﺂﺧﺮ اﻟﺮﻏ‬‫اﻟﻮﻓﺎء‬
‫ﺒﻴﻖ‬
‫ﺘﻄ‬‫ﻧﻬﺎﻳ ﺔ اﻟ‬
‫ﺜﺎل ‪ ،‬إذا ﻛﺎن اﻟﻌﺪد اﻟﻤﺮﺟﻌ ﻲ ﺻﻔ ﺮًا ‪،‬‬ ‫ﺘﻐﻴﺮ ﻣﺮﺟﻌ ﻲ ‪ ،‬ﻓﺈﻧﻪﻳﻜﻮن ﻣﺆ ﻫ ﻼ ً ﻟـ ‪GC‬ﻓﻘﻂ‪ .‬ﻋﲆﺳ‬
‫ﺒﻴﻞ اﻟﻤ‬ ‫ﺘﻮي ﻋﲆ أي ﻣ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬إذا ﻛﺎن اﻟﻜﺎﺋﻦ ﻻﻳﺤ‬
‫ﺬﻳﻜﻮن اﻟﻌﻨﺼﺮ اﻟﻮﺣﻴﺪ اﻟﻤﺆ ﻫﻞ ﻟﻠﺤﺼﻮل ﻋﲆ ‪GC.‬‬
‫ﻓﻌﻨﺪﺋ ٍ‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪print ("Destructor Execution ...") 7 ) 8) t1 = :‬‬

‫ﺘ‬‫ﺘﻴﺮاد )‪2‬اﺧ‬
‫)‪1‬وﻗ ﺖ اﻻﺳ‬
‫)‪__ (self): 4) print ("Constructor Execution ...") 5) def __del __ (self): 6‬‬
‫ﺒﺎر ‪t2 = t1 10) t3 = t2 11) del t1 12) time.sleep (5) 13) print‬‬
‫ﺘ‬‫‪3) def __init‬اﺧ‬
‫ﺑﻌﺪ ﺣﺬف ‪t1") 14) del t2‬‬‫ﺗﻼﻓﻪ‬
‫ﺘﻢ إ‬
‫)‪")() 9‬اﻟﻜﺎﺋﻦ ﻟﻢﻳ‬
‫‪28‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺑﻌﺪ ﺣﺬف ‪")t2") 17) print‬أﻧﺎ‬‫ﺘﻰ‬

‫ﺑﻌﺪ ﺣ‬‫ﺗﻼﻓﻪ‬
‫ﺘﻢ إ‬
‫‪")15) time.sleep (5) 16) print‬اﻟﻜﺎﺋﻦ ﻟﻢﻳ‬
‫ﺘﻐﻴﺮ ﻣﺮﺟﻌ ﻲ ‪18) del t3 ("...‬‬
‫أﺣﺎول ﺣﺬف آﺧﺮ ﻣ‬
‫ﺜﺎل‪:‬‬
‫ﻣ‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪application") :‬‬‫ﺘ‬‫ﺘﻴﺮاد )‪2‬اﺧ‬ ‫)‪1‬وﻗ ﺖ اﻻﺳ‬

‫‪list 10) time.sleep (5) 11) print ("End of‬‬
‫‪7 ) 8) list = [Test ()، Test ()، Test ()] 9) del‬‬
‫‪(self): 6) printExecution‬‬
‫‪("Constructor‬‬ ‫‪("Destructor‬‬ ‫‪Execution‬‬
‫)‪...") 5‬‬ ‫)"‪def __del...‬‬
‫__‬
‫‪3) def __init __ (self): 4) print‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﺗﻨﻔﻴﺬ اﻟﻤﺪﻣﺮ ‪...‬‬
‫ﺒﻴﻖ‬
‫ﺘﻄ‬‫ﻧﻬﺎﻳ ﺔ اﻟ‬
‫ﺜﻮر ﻋﲆ ﻋﺪد ﻣﺮاﺟﻊ ﻛﺎﺋﻦ‪:‬‬

‫ﻛﻴﻔﻴ ﺔ اﻟﻌ‬
‫ﺘﻮي وﺣﺪة ‪sys‬ﻋﲆ داﻟ ﺔ )( ‪getrefcount‬ﻟﻬﺬا اﻟﻐﺮض‪)sys.getrefcount .‬ﻣﺮﺟﻊ اﻟﻜﺎﺋﻦ(‬
‫ﺗﺤ‬
‫ﺘﻴﺮاد )‪sys 2) class Test: 3‬‬ ‫)‪1‬اﺳ‬

‫ﺘﻴﺎز ))‪(sys.getrefcount (t1‬‬ ‫اﺟ‬
‫‪t1 6) t3 = t1 7) t4 = t1 8) print‬‬
‫= ‪4) t1 = Test () 5) t2‬‬
‫اﻹﺧﺮاج ‪5‬‬
‫ﺘﺮاﺿ ﻲ واﺣﺪ‪.‬‬
‫ﺘﻐﻴﺮ ﻣﺮﺟﻌ ﻲ اﻓ‬
‫ﺑﻤ‬‫ﺘﻔﻆ ‪Python‬داﺧﻠ ًﻴﺎ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬ﻟﻜﻞ ﻛﺎﺋﻦ ‪،‬ﺗﺤ‬
‫‪29‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺑ ﺲ‬ ‫ُ‬
‫أوو‬
‫اﻟﺠﺰء ‪2‬‬
‫‪30‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺟﺪول أﻋﻤﺎل‬
‫اﻟﻤﻴﺮا ث _‬
‫ﻟﻪ ﻋﻼﻗ ﺔ‬
‫‪ IS-A‬اﻟﻌﻼﻗ ﺔ‬
‫ﺑﻞ ‪HAS-A‬‬
‫ﻋﻼﻗ ﺔ ‪IS-A‬ﻣﻘﺎ‬
‫ﺘﺠﻤﻴﻊ‬
‫ﺑﻞ اﻟ‬
‫ﺘﺮﻛﻴ ﺐ ﻣﻘﺎ‬
‫اﻟ‬
‫أﻧﻮاع اﻟﻤﻴﺮا ث‬
‫ﺛ ﺔ واﺣﺪة‬
‫ورا‬
‫ﺘﻮﻳﺎ ت‬
‫ﺘﻌﺪدة اﻟﻤ ﺴ‬
‫ﺛﺔ ﻣ‬
‫•اﻟﻮرا‬
‫•اﻟﻤﻴﺮا ث اﻟﻬﺮﻣ ﻲ‬
‫ﺗﻌﺪد اﻟﻤﻴﺮا ث‬
‫ﺛ ﺔ اﻟﻬﺠﻴﻨ ﺔ‬
‫ﺛ ﺔ اﻟﺪورﻳ ﺔ‬
‫أﻣﺮ ﻗﺮار اﻷﺳﻠﻮ ب )‪(MRO‬‬

‫ﻃﺮﻳﻘ ﺔ )(ﻓﺎﺋﻘ ﺔ‬
‫ﺘﺨﺪام أﻋﻀﺎء ﻓﺼﻞ واﺣﺪ داﺧﻞ ﻓﺼﻞ آﺧﺮ‪:‬‬

‫اﺳ‬
‫ﺘﺨﺪام اﻟﻄﺮق اﻟ‬
‫ﺑﺎﺳ‬‫ﺘﺨﺪام أﻋﻀﺎء ﻓﺼﻞ دراﺳ ﻲ داﺧﻞ ﻓﺼﻞ آﺧﺮ‬
‫ﺘﺮﻛﻴ ﺐ )ﻋﻼﻗ ﺔ ﻟﻬﺎ‪A) -‬‬

‫)‪1‬ﺣ ﺴ ﺐ اﻟ‬
‫ﺑﺎﻟﻤﻴﺮا ث )ﻋﻼﻗ ﺔ )‪IS-A‬‬
‫)‪2‬‬
‫ﺘﺮﻛﻴ ﺐ )ﻋﻼﻗ ﺔ ﻟﻬﺎ‪A): -‬‬

‫)‪1‬ﺣ ﺴ ﺐ اﻟ‬
‫ﺘﺨﺪام اﺳﻢ اﻟﻔﺼﻞ أو ﻋﻦ ﻃﺮﻳﻖ إﻧﺸﺎء ﻛﺎﺋﻦﻳﻤﻜﻨﻨﺎ اﻟﻮﺻﻮل إﱃ أﻋﻀﺎء ﻣﻦ ﻓﺌ ﺔ واﺣﺪة داﺧﻞ ﻓﺌ ﺔ أﺧﺮى ﻟﻴ ﺲﺳﻮىﺗﻜﻮﻳﻦ )ﻋﻼﻗ ﺔ ‪Has-A).‬‬
‫ﺑﺎﺳ‬
‫•‬
‫ﺘﺨﺪام اﻟﻜﻮد‪.‬‬
‫ﺑﻠﻴ ﺔ إﻋﺎدة اﺳ‬
‫ﺋﻴ ﺴﻴ ﺔ ﻟﻌﻼﻗ ﺔ ‪ Has-A‬ﻫ ﻲ ﻗﺎ‬
‫اﻟﻤﻴﺰة اﻟﺮ‬
‫ﺒ ﻲ ‪-1:‬‬
‫ﺘﺠﺮﻳ‬
‫اﻟ‬
‫)‪1‬ﻓﺌ ﺔ اﻟﻤﺤﺮك‪2) :‬أ __ ‪3) def __init‬‬

‫ﺗ ﻲ(‪self.b = 20 5) def m1 :‬‬
‫‪)= 10‬ذا‬
‫ﺗ ﻲ(‪:‬‬
‫)‪)4‬ذا‬
‫‪31‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
("‫ﺑﺎﻟﻤﺤﺮك‬
11) print ('Car using Engine ‫اﻟﺨﺎﺻ ﺔ‬
Class ‫)"اﻟﻮﻇﺎﺋﻒ‬
Functional') 12)print
:‫ﻓﺌ ﺔ اﻟ ﺴﻴﺎرة‬6) 7)
‫ﺒﺎﻋ ﺔ‬
‫ﻃ‬8) def __init __ (self): 9) self.engine = Engine () 10) def m2 (self):
= ‫ج‬m1 () 15) .‫ﺗ ﻲ‬
‫ﻣﺤﺮك ذا‬14) (‫ ب‬.‫ﺗ ﻲ‬
‫ﺒﺎﻋ ﺔ )ﻣﺤﺮك ذا‬
‫ﻃ‬13) (‫ اﻟﻤﺤﺮك أ‬.‫ﺗ ﻲ‬
‫)ذا‬
2 () ‫ )(ﺳﻢ‬16) ‫ﺳﻴﺎرة‬
:‫ﺘﺎج‬
‫اﻧ‬
‫ﺘﺨﺪم وﻇﻴﻔ ﺔ ﻓﺌ ﺔ اﻟﻤﺤﺮك‬
‫ﺘ ﻲﺗ ﺴ‬
‫اﻟ ﺴﻴﺎرة اﻟ‬
10
20
‫ﺑﺎﻟﻤﺤﺮك‬‫اﻟﻮﻇﺎﺋﻒ اﻟﺨﺎﺻ ﺔ‬
-2: ‫ﺒ ﻲ‬
‫ﺘﺠﺮﻳ‬
‫اﻟ‬
color): 3) 4) 5) 6) def getinfo (self): 7) :‫ﻓﺌ ﺔ اﻟ ﺴﻴﺎرة‬1)

2) def __init __ (self، name، model،
self.name = name self.model = model self.color = color
(self.name ، self.model ، self.c ‫ﺗﻨ ﺴﻴﻖ‬

{}". : ‫ }{واﻟﻠﻮن‬:‫ }{اﻟﻄﺮاز‬، :‫اﺳﻢ اﻟ ﺴﻴﺎرة‬print ("
olor))
(self): 15) print ("Employee Name:"، self.ename) 16 )
(self، ename، eno، car): 11) 12) 13) 14) def empinfo
‫ﺒﺎﻋ ﺔ "(رﻗﻢ‬
‫ﻃ‬8) 9) class Employee: 10) def __init __
ename
(":‫ﺳﻴﺎرة اﻟﻤﻮﻇﻒ‬ self.eno‫ﺒﺎﻋ ﺔ‬
‫)"ﻣﻌﻠﻮﻣﺎ ت‬ = eno
‫ﻃ‬self.eno) 17) ، ":‫اﻟﻤﻮﻇﻒ‬
() 19) c = Carself.ename =
("Innova"، "2.5V"، "Gray ") 20) e =
10000، c) 21)
‫اﻟ ﺴﻴﺎرة‬e.empinfo
‫اﻟﻤﻮﻇﻒ )( اﻟ ﺴﻴﺎرة اﻟﺬا‬18) self.car.getinfo
= ‫ﺗﻴ ﺔ‬
('Durga'،
32
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫ﻣﻌﻠﻮﻣﺎ تﺳﻴﺎرة اﻟﻤﻮﻇﻒ‪:‬‬
‫اﺳﻢ اﻟ ﺴﻴﺎرة‪ :‬إﻳﻨﻮﻓﺎ ‪ ،‬اﻟﻤﻮدﻳﻞ‪2.5 :‬ﻓﻮﻟ ﺖ ‪ ،‬واﻟﻠﻮن‪ :‬رﻣﺎدي‬
‫ﺛﻢﻳﻤﻜﻦ ﻟﻔﺌ ﺔ اﻟﻤﻮﻇﻒ اﻟﻮﺻﻮل إﱃ ﺟﻤﻴﻊ أﻋﻀﺎء ﻓﺌ ﺔ اﻟ ﺴﻴﺎرة‪.‬‬‫ﻓ ﻲ ﻓﺌ ﺔ اﻟﻤﻮﻇﻒ أﻋﻼه ‪،‬ﻳﻤﻜﻦ ﻟﻤﺮﺟﻊ ‪Has-A Car‬وﻣﻦ‬
‫ﺒ ﻲ ‪-3:‬‬
‫ﺘﺠﺮﻳ‬
‫اﻟ‬
‫)‪1‬اﻟﻔﺌ ﺔ "( ‪4) self.b = 20 5) def m1 (self): 6) print‬‬

‫‪X: 2) a = 10 3) def __init __ (self):‬ﻃﺮﻳﻘ ﺔ ‪m1‬ﻣﻦ ﻓﺌ ﺔ‬
‫)‪X") 7‬‬
‫ﺗ ﻲ(‪print :‬‬
‫)‪8‬اﻟﻔﺌ ﺔ __ ‪)Y: 9) c = 30 10) def __init‬ذا‬
‫)‪")11) self.d = 40 12) def m2 (self): 13‬ﻃﺮﻳﻘ ﺔ ‪m2‬‬
‫ﻣﻦ ﻓﺌ ﺔ )‪Y") 14‬‬
‫‪(x1.b) 19) x1.m1 () 20) print (Yc) 21) print (self.‬‬

‫ﻣﻦ‬
‫‪m3m3‬‬
‫‪(self):‬‬
‫ﻃﺮﻳﻘ ﺔ‬
‫)‪16‬‬
‫)‪22‬‬
‫‪x1self.m2‬‬
‫)‪= X () 17‬‬
‫)‪() 23‬‬
‫‪print‬‬
‫‪print‬‬
‫)‪(x1.a‬‬
‫د( "(‬
‫)‪18‬‬‫‪15)print‬‬
‫‪def‬‬
‫ﻓﺌ ﺔ )( ‪Y") 24) y1 = Y () 25) y1.m3‬‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫‪10‬‬
‫‪20‬‬
‫ﻃﺮﻳﻘ ﺔ ‪m1‬ﻣﻦ ﻓﺌ ﺔ ‪X‬‬
‫‪30‬‬
‫‪40‬‬
‫ﻃﺮﻳﻘ ﺔ ‪m2‬ﻣﻦ ﺻﻨﻒ‬
‫ﻃﺮﻳﻘ ﺔ ‪m3‬ﻣﻦ ﺻﻨﻒ‬
‫‪33‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺑﺎﻟﻤﻴﺮا ث )ﻋﻼﻗ ﺔ ‪IS-A):‬‬

‫)‪2‬‬
‫ﺛﻢ‬‫ﺘﻬﺎ‪ .‬وﻣﻦ‬
‫ﺑ‬‫ﺘﺎ‬
‫ﺘﺎﺣ ﺔ ﻟﻠﻔﺌﺎ ت اﻟﻔﺮﻋﻴ ﺔ وﻻﻳﻠﺰﻣﻨﺎ إﻋﺎدة ﻛ‬
‫ﺘﺮاﺿ ﻲ اﻟﻤ‬
‫ﺑﺸﻜﻞ اﻓ‬‫ﺘﻮﻓﺮة ﻓ ﻲ اﻟﻔﺌ ﺔ اﻷﺻﻠﻴ ﺔ‬
‫ﺘﻐﻴﺮا ت واﻟﻄﺮق واﻟﻤﻨﺸﺂ ت اﻟﻤ‬
‫ﻣﺎ ﻫ ﻲ اﻟﻤ‬
‫ﺒﻌﺾ اﻟﻮﻇﺎﺋﻒ اﻹﺿﺎﻓﻴ ﺔ‪.‬‬
‫ﺑ‬‫ﺘﺨﺪام اﻟﻜﻮد وﻳﻤﻜﻨﻨﺎﺗﻮﺳﻴﻊ اﻟﻮﻇﺎﺋﻒ اﻟﺤﺎﻟﻴ ﺔ‬
‫ﺑﻠﻴ ﺔ إﻋﺎدة اﺳ‬
‫ﺛ ﺔ ﻫ ﻲ ﻗﺎ‬
‫ﺋﻴ ﺴﻴ ﺔ ﻟﻠﻮرا‬
‫ﻓﺈن اﻟﻤﻴﺰة اﻟﺮ‬
‫ﺑﻨﺎء اﻟﺠﻤﻠ ﺔ‪class childclass (parentclass) :‬‬
‫)‪1‬اﻟﻔﺌ ﺔ )‪static method') 13) 14) class C (P): 15‬‬

‫‪10) staticmethod 11) def m3 (): 12) print ('Parent‬‬
‫)'‪8) def m2 (cls): 9) print ('Parent class method‬‬
‫‪6)3)print‬‬
‫‪def __init‬‬
‫‪('Parent‬‬
‫‪__ (self):‬‬
‫‪example‬‬‫‪4) self.b‬‬
‫)'‪method‬‬
‫)‪= 10 5‬‬
‫‪7) def‬‬
‫‪classmethod‬‬
‫‪m1 (self):‬‬
‫ﺘﻴﺎز )( ‪20) c.m1 () 21) c.m2 () 22) c.m3‬‬
‫‪P: 2) a = 10‬اﺟ‬
‫)‪16 ) 17) c = C () 18) print (ca) 19) print (cb‬‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫‪10‬‬
‫‪10‬‬
‫ﺜﻴﻞ اﻷﺻﻞ‬
‫ﻃﺮﻳﻘ ﺔ اﻟﻤ‬
‫ﻃﺮﻳﻘ ﺔ ﻓﺌ ﺔ اﻟﻮاﻟﺪﻳﻦ‬
‫ﺑﺖ‬
‫ﺜﺎ‬
‫ﻃﺮﻳﻘ ﺔ اﻷﺻﻞ اﻟ‬
‫)‪1‬اﻟﻔﺌ ﺔ ‪P: 10‬ﻃﺮق )‪2) 3‬اﻟﻔﺌ ﺔ‬

‫‪C (P): 4) 5‬ﻃﺮق‬
‫‪34‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺑ ﺔ ﻫﺬه اﻟﻄﺮق )‪(Code Reusability‬‬

‫ﺘﺎ‬
‫ﺑﺈﻋﺎدة ﻛ‬‫ﺒﻴﻦ‬
‫ﺘﺎﺣ ﺔﺗﻠﻘﺎﺋ ًﻴﺎ ﻟﻠﻔﺌ ﺔ اﻟﻔﺮﻋﻴ ﺔ وﻟ ﺴﻨﺎ ﻣﻄﺎﻟ‬
‫ﺘﻮي ﻓﺌ ﺔ ‪Parent‬ﻋﲆ ‪10‬ﻃﺮق و ﻫﺬه اﻟﻄﺮق ﻣ‬
‫ﺜﺎل أﻋﻼه ‪،‬ﺗﺤ‬
‫ﻓ ﻲ اﻟﻤ‬
‫ﺘﻮي ﻓﺌ ﺔ اﻷﻃﻔﺎل ﻋﲆ ‪15‬ﻃﺮﻳﻘ ﺔ‪.‬‬

‫ﺛﻢﺗﺤ‬‫وﻣﻦ‬
‫ﺘﺮاﺿ ًﻴﺎ ﻟﻠﻔﺌ ﺔ اﻟﻔﺮﻋﻴ ﺔ ﻣﻦ ﺧﻼل اﻟﻤﻴﺮا ث‪.‬‬

‫ﺘﺎح اﻓ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬ﻣﺎ ﻫﻮ أي ﻋﻀﻮ ﻣﻮﺟﻮد ﻓ ﻲ ﻓﺌ ﺔ اﻟﻮاﻟﺪﻳﻦ ﻣ‬
‫)‪1‬اﻟﻔﺌ ﺔ )‪m2 (self): 6) print ("child class method") 7 ) 8‬‬
‫‪3) print ("Parent class method") 4) class C (P): 5) def‬‬
‫‪P: 2) def m1 (self):‬ج =ج )‪ 9‬؛ )(ﺳﻢ )‪1 () 10‬ﺳﻢ )( ‪2‬‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫ﻃﺮﻳﻘ ﺔ ﻓﺌ ﺔ اﻟﻄﻔﻞ‬
‫ﺋﻴ ﺴ ﻲ وﻃﺮق‬
‫ﺘﺪﻋﺎء ﻛﻞ ﻣﻦ ﻃﺮق اﻟﻔﺼﻞ اﻟﺮ‬
‫ﺘﺎﻟ ﻲ ﻓ ﻲ ﻣﺮﺟﻊ ﻓﺌ ﺔ اﻟﻄﻔﻞ ‪،‬ﻳﻤﻜﻨﻨﺎ اﺳ‬
‫ﺑﺎﻟ‬
‫ﺘﺎﺣ ﺔﺗﻠﻘﺎﺋ ًﻴﺎ ﻟﻠﻔﺌ ﺔ اﻟﻔﺮﻋﻴ ﺔ ‪ ،‬و‬
‫ﻣﺎ ﻫ ﻲ اﻟﻄﺮق اﻟﻤﻮﺟﻮدة ﻓ ﻲ ﻓﺌ ﺔ اﻟﻮاﻟﺪﻳﻦ ﻣ‬
‫اﻟﻔﺼﻞ اﻟﻔﺮﻋ ﻲ‪.‬‬
‫ﺛﻠ ﺔ أﻳﻀﺎ‬
‫ﺘﻐﻴﺮا ت ﻣﻤﺎ‬
‫ﻣ‬
‫)‪1‬اﻟﻔﺌ ﺔ )‪11) c1 = C () 12) print (c1.a، c1.b، c1.c، c1.d‬‬
‫)‪8) super ( ) .__ init __ () ===> Line-1 9) self.d = 30 10‬‬
‫‪= 20 5) class C (P): 6) c = 30 7) def __init __ (self):‬‬
‫‪P: 2) a = 10 3) def __init __ (self): 4) self.b‬‬
‫ﺘﺎح ﻟﻠﻔﺌ ﺔ اﻟﻔﺮﻋﻴ ﺔ‪.‬‬

‫ﺘﻐﻴﺮ ‪b‬ﻏﻴﺮ ﻣ‬
‫إذا ﻋﻠﻘﻨﺎ ﻋﲆ اﻟ ﺴﻄﺮ ‪1 ،‬ﻓﺈن اﻟﻤ‬
‫‪35‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺒ ﻲ ﻟﻠﻤﻴﺮا ث‪:‬‬
‫ﺑﺮﻧﺎﻣﺞﺗﺠﺮﻳ‬
‫)‪1‬ﻓﺌ ﺔ اﻟﺸﺨﺺ‪)2) def __init __ :‬اﻟﺬا ت ‪ ،‬اﻻﺳﻢ ‪ ،‬اﻟﻌﻤﺮ(‪Biryani and Drink Beer' ' ) 7) 8) :‬‬
‫‪3) self.name = name 4) self.age = age 5) def eatndrink (self): 6) print ('Eat‬ﻓﺌ ﺔ اﻟﻤﻮﻇﻒ‬
‫)‪)eno ، esal): 11‬اﻻﺳﻢ ‪،‬‬
‫‪10) self.eno‬‬
‫__‪super () .‬‬
‫‪= eno‬‬
‫)‪init 12‬‬
‫‪__ ،self.‬‬
‫‪esal‬اﻟﻌﻤﺮ‬
‫ﺳﻢ ‪،‬‬‫‪esal‬اﻻ=‬
‫)‪ 13‬ت ‪،‬‬
‫)‪)14‬اﻟﺬا‬
‫‪9) def‬‬
‫‪def__init‬‬
‫‪work__(self):‬‬
‫)اﻟﺸﺨﺺ(‪:‬‬
‫اﻟﻌﻤﺮ(‬
‫‪("Employee‬‬ ‫‪Age:"،‬‬
‫‪20) print‬‬ ‫)‪self .age‬‬
‫اﻟﻤﻮﻇﻒ‪":‬‬ ‫‪19) def‬‬
‫)‪16‬رﻗﻢ‬ ‫‪print‬‬ ‫ﺒﺮدة"( "(‬
‫‪empinfo‬‬ ‫ﺒﻴﺮة اﻟﻤ‬
‫‪(self):‬‬ ‫‪ print‬ب اﻟ‬
‫)‪17‬‬ ‫ﺜﻞ ﺷﺮ‬ ‫ﺗﻤﺎﻣﺎ ﻣ‬‫ﺳﻬﻞ ﺟﺪًا‬
‫‪("Employee‬‬
‫ً‬ ‫‪15) print‬‬
‫‪Name:"،‬‬ ‫)‪("Coding18‬‬
‫)‪self.name‬‬ ‫‪Python‬‬
‫‪print‬‬
‫ﺗ ﺐ اﻟﻤﻮﻇﻒ ‪self.esal) 21) 22) e = ":‬اﻟﻤﻮﻇﻒ )( ‪23 ) e.eatndrink () 24) e.work () 25) e.empinfo‬‬
‫)‪")self.eno‬را‬
‫)‪('Durga'، 48، 100، 10000‬‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫ﺒﻴﺮة‬
‫ﺒﺮﻳﺎﻧ ﻲ واﺷﺮ ب اﻟ‬
‫أﻛﻞ اﻟ‬
‫ﺜﻠﺠ ﺔ‬
‫ﺒﻴﺮة اﻟﻤ‬ ‫ﻳﻌﺪﺗﺮﻣﻴﺰ ‪Python‬أﻣ ﺮًاﺳﻬ ﻼ ً ﻟﻠﻐﺎﻳ ﺔ ﻣ‬
‫ﺜﻞ ﺷﺮ ب اﻟ‬
‫ﻋﻤﺮ اﻟﻤﻮﻇﻒ‪48 :‬‬
‫ﺗ ﺐ اﻟﻤﻮﻇﻒ‪10000 :‬‬
‫را‬
‫ﺑﻞ ‪HAS-A:‬‬
‫ﻋﻼﻗ ﺔ ‪IS-A‬ﻣﻘﺎ‬
‫ﺑﺬﻟﻚ‬‫ﺒﻌﺾ اﻟﻮﻇﺎﺋﻒ اﻹﺿﺎﻓﻴ ﺔ ‪ ،‬ﻓﺈﻧﻨﺎ ﻧﻘﻮم‬
‫ﺑ‬‫•إذا أردﻧﺎﺗﻮﺳﻴﻊ اﻟﻮﻇﺎﺋﻒ اﻟﺤﺎﻟﻴ ﺔ‬
‫ﻳﺠ ﺐ أنﺗﺬ ﻫ ﺐ ﻟﻌﻼﻗ ﺔ ‪IS-A.‬‬
‫ﺘﺎر ﻋﻼﻗ ﺔ ‪HAS-A.‬‬
‫ﺘﺨﺪام اﻟﻮﻇﺎﺋﻒ اﻟﺤﺎﻟﻴ ﺔ ‪ ،‬ﻓﻌﻠﻴﻨﺎ أن ﻧﺨ‬
‫ﺘﻤﺪﻳﺪ وﻋﻠﻴﻨﺎ ﻓﻘﻂ اﺳ‬
‫•إذا ﻟﻢ ﻧﺮﻏ ﺐ ﻓ ﻲ اﻟ‬
‫ﺘﺨﺪم اﻟ ﺴﻴﺎرة ﻓﻘﻂ‬

‫ﺜﺎل‪:‬ﺗﻮﺳﻊ ﻓﺌ ﺔ اﻟﻤﻮﻇﻒ وﻇﺎﺋﻒ ﻓﺌ ﺔ اﻟﺸﺨﺺ وﻟﻜﻦ ﻓﺌ ﺔ اﻟﻤﻮﻇﻒﺗ ﺴ‬
‫•ﻋﲆﺳ‬
‫ﺘﺪ‬
‫وﻇﻴﻔ ﺔ وﻟﻜﻦ ﻻﺗﻤ‬
‫‪36‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺷﺨﺺ‬
‫ﻫﻮ‬
‫أ‬HAS -
‫ﻣﻮﻇﻒ‬ ‫ﺳﻴﺎرة‬
color): 3) 4) 5) 6) def getinfo (self): 7) :‫ﻓﺌ ﺔ اﻟ ﺴﻴﺎرة‬1)

2) def __init __ (self، name، model،
= ‫اﺳﻢ‬self.name =
‫ﻧﻤﻮذج‬self.model
self.color = color
(self.name، self.model، ‫ﺗﻨ ﺴﻴﻖ‬

{}". :‫ \ }{اﻟﻠﻮن‬n \ t :‫ \ }{اﻟﻄﺮاز‬n \ t :‫اﺳﻢ اﻟ ﺴﻴﺎرة‬print ("\ t
self.color))
('Eat Biryani and Drink) Beer ') 15) 16) :(‫ اﻟﻌﻤﺮ‬، ‫ اﻻﺳﻢ‬، ‫)اﻟﻨﻔ ﺲ‬10) def __init __ :‫ﻓﺌ ﺔ اﻟﺸﺨﺺ‬8) 9)
‫ﻓﺌ ﺔ اﻟﻤﻮﻇﻒ‬11) self.name = name 12) self.age = Age 13) def eatndrink (self): 14) print
، ‫)اﻻﺳﻢ‬18) super () .__ init __ :(‫اﻟ ﺴﻴﺎرة‬eno ، esal ، ، ‫ اﻟﻌﻤﺮ‬، ‫ اﻻﺳﻢ‬، ‫)اﻟﺬا ت‬17) def __init __ :(‫)اﻟﺸﺨﺺ‬
28)
19)print
self.eno
(" :‫اﻟﻤﻮﻇﻒ‬
= eno 20)
‫اﺳﻢ‬self.esal
24) def empinfo
= esal 21)
(self):
22) def
25)work
print (self):
(" ("‫ﺒﺮدة‬
23)
‫اﻟﻤ‬print
‫ﺒﻴﺮة‬
‫"( اﻟ‬Coding
‫ﺜﻞ ﺷﺮ ب‬‫ ﻣ‬Python
‫ﺗﻤﺎﻣﺎ‬
ً ‫اﻟﻌﻤﺮ(ﺟﺪًا‬
‫ﺳﻬﻞ‬
self.name)
("Innova"، 26) print
"2.5V"، (" Employee
"Gray") Age: "، self.age)
33) e = (":‫اﻟﻤﻮﻇﻒ‬ 27) print
‫)"ﻣﻌﻠﻮﻣﺎ تﺳﻴﺎرة‬ (" Employee
"، self.esal) 29) Number: "،
print :‫ﺗ ﺐ‬ self.eno)
‫اﻟﻤﻮﻇﻒ را‬ "،
34) e.eatndrink () (‫'(ج‬Durga'، 48،100 ، 10000، ‫اﻟﻤﻮﻇﻒ‬30) self.car.getinfo () 31) 32) c = Car
‫ﺗﻴ ﺔ =اﻟ ﺴﻴﺎرة‬

‫اﻟ ﺴﻴﺎرة اﻟﺬا‬
37
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫)( ‪36) e.empinfo‬‬

‫)( ‪35) e.work‬‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫ﺒﻴﺮة‬
‫ﺒﺮﻳﺎﻧ ﻲ واﺷﺮ ب اﻟ‬
‫أﻛﻞ اﻟ‬
‫ﺜﻠﺠ ﺔ‬
‫ﺒﻴﺮة اﻟﻤ‬ ‫ﻳﻌﺪﺗﺮﻣﻴﺰ ‪Python‬أﻣ ﺮًاﺳﻬ ﻼ ً ﻟﻠﻐﺎﻳ ﺔ ﻣ‬
‫ﺜﻞ ﺷﺮ ب اﻟ‬
‫ﻋﻤﺮ اﻟﻤﻮﻇﻒ‪48 :‬‬
‫ﺗ ﺐ اﻟﻤﻮﻇﻒ‪10000 :‬‬
‫را‬
‫ﻣﻌﻠﻮﻣﺎ تﺳﻴﺎرة اﻟﻤﻮﻇﻒ‪:‬‬
‫اﺳﻢ اﻟ ﺴﻴﺎرة‪ :‬إﻳﻨﻮﻓﺎ‬
‫اﻟﻤﻮدﻳﻞ‪2.5 :‬ﻓﻮﻟ ﺖ‬
‫اﻟﻠﻮن‪ :‬رﻣﺎدي‬
‫ﺘﺨﺪم وﻇﺎﺋﻒ ﻓﺌ ﺔ اﻟ ﺴﻴﺎرة ﻓﻘﻂ‪.‬‬

‫ﺜﺎل أﻋﻼه ‪،‬ﺗﻮﺳﻊ ﻓﺌ ﺔ اﻟﻤﻮﻇﻒ وﻇﺎﺋﻒ ﻓﺌ ﺔ اﻟﺸﺨﺺ وﻟﻜﻨﻬﺎﺗ ﺴ‬
‫ﺘﺠﻤﻴﻊ‪:‬‬
‫ﺑﻞ اﻟ‬
‫ﺘﺮﻛﻴ ﺐ ﻣﻘﺎ‬
‫اﻟ‬
‫ﺒﻴﺮ‪:‬‬
‫ﺗﻌ‬
‫ﺒﺎط اﻟﻘﻮي‬
‫ﺗ‬‫ﺑﻘﻮة وأن ﻫﺬا اﻻر‬‫ﺒﻄ ﺔ‬
‫ﺗ‬‫ﺘﻮاة ﻣﺮ‬
‫ﺘﻮي ﻣﻮﺟﻮد ‪ ،‬ﻓﺈن اﻟﺤﺎوﻳ ﺔ واﻟﻜﺎﺋﻨﺎ ت اﻟﻤﺤ‬
‫ﺑﺪون ﻛﺎﺋﻦ اﻟﺤﺎوﻳ ﺔ اﻟﻤﻮﺟﻮد إذا ﻟﻢﺗﻜﻦ ﻫﻨﺎك ﻓﺮﺻ ﺔ ﻟﻮﺟﻮد ﻛﺎﺋﻦ ﻣﺤ‬
‫ﻟﻴ ﺲﺳﻮىﺗﻜﻮﻳﻦ‪.‬‬
‫ﺒﻂ ﻛﺎﺋﻨﺎ ت اﻟﺠﺎﻣﻌ ﺔ‬

‫ﺗ‬‫ﺛﻢﺗﺮ‬‫ﺑﺪون وﺟﻮد ﻛﺎﺋﻦ ﺟﺎﻣﻌ ﻲ ﻻﺗﻮﺟﺪ ﻓﺮﺻ ﺔ ﻟﻮﺟﻮد ﻛﺎﺋﻦ ﻗ ﺴﻢ ﻣﻮﺟﻮد‪ .‬وﻣﻦ‬
‫ﺘﻮي اﻟﺠﺎﻣﻌ ﺔ ﻋﲆ ﻋﺪة أﻗ ﺴﺎم و‬
‫ﺜﺎل‪:‬ﺗﺤ‬
‫ﻋﲆﺳ‬
‫ﺘﻜﻮﻳﻦ‪.‬‬
‫ﺒﺎط اﻟﻘﻮي ﻟﻴ ﺲﺳﻮى اﻟ‬
‫ﺗ‬‫ﺛﻴ ًﻘﺎ و ﻫﺬا اﻻر‬
‫ﺒﺎﻃﺎ و‬
‫ﺗ ً‬‫واﻟﻘ ﺴﻢ ار‬
‫ﻛﺎﺋﻦ اﻟﻘ ﺴﻢ‬

‫)ﻛﺎﺋﻦ ﻣﻀﻤﻦ(‬
‫ﻛﺎﺋﻦ اﻟﺠﺎﻣﻌ ﺔ‬
‫)ﻛﺎﺋﻦ اﻟﺤﺎوﻳ ﺔ(‬
‫‪38‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺗﺠﻤﻴﻊ‪:‬‬
‫ﺒﺎط‬
‫ﺗ‬‫ﺑﺸﻜﻞ ﺿﻌﻴﻒ وأن ﻫﺬا اﻻر‬‫ﺒﻄ ﺔ‬
‫ﺗ‬‫ﺘﻮاة ﻣﺮ‬
‫ﺘﻮي ﻣﻮﺟﻮد ‪ ،‬ﻓﺈن اﻟﺤﺎوﻳ ﺔ واﻟﻜﺎﺋﻨﺎ ت اﻟﻤﺤ‬
‫ﺑﺪون ﻛﺎﺋﻦ ﺣﺎوﻳ ﺔ ﻣﻮﺟﻮد إذا ﻛﺎﻧ ﺖ ﻫﻨﺎك ﻓﺮﺻ ﺔ ﻟﻮﺟﻮد ﻛﺎﺋﻦ ﻣﺤ‬
‫اﻟﻀﻌﻴﻒ ﻟﻴ ﺲﺳﻮىﺗﺠﻤﻴﻊ‪.‬‬
‫ﺒﺮوﻓﻴ ﺴﻮر‬
‫ﺛﻢ ﻓﺈن ﻛﺎﺋﻨﺎ ت اﻟﻘ ﺴﻢ واﻟ‬‫ﺘﺎذ ﻣﻮﺟﻮد‪ .‬وﻣﻦ‬
‫ﺑﺪون اﻟﻘ ﺴﻢ اﻟﺤﺎﻟ ﻲ ‪ ،‬ﻗﺪﺗﻜﻮن ﻫﻨﺎك ﻓﺮﺻ ﺔﻷﺳ‬‫ﺗﺬة‪.‬‬
‫ﺘﻮي اﻟﻘ ﺴﻢ ﻋﲆ ﻋﺪة أﺳﺎ‬
‫ﺜﺎل‪:‬ﻳﺤ‬
‫ﻋﲆﺳ‬
‫ﺘﺠﻤﻴﻊ‪.‬‬
‫ﺑﺸﻜﻞ ﺿﻌﻴﻒ ‪ ،‬و ﻫﺬا ﻟﻴ ﺲﺳﻮى اﻟ‬‫ﺒﻄ ﺔ‬
‫ﺗ‬‫ﻣﺮ‬
‫‪x‬‬
‫‪x‬‬
‫‪:‬‬ ‫‪:‬‬
‫‪:‬‬ ‫‪:‬‬ ‫ﻛﺎﺋﻦ اﻷﺳ‬
‫ﺘﺎذ‬
‫‪:‬‬
‫)ﻛﺎﺋﻦ ﻣﻀﻤﻦ(‬
‫‪:‬‬
‫‪x‬‬
‫ﻛﺎﺋﻦ اﻟﻘ ﺴﻢ‬

‫)ﻛﺎﺋﻦ اﻟﺤﺎوﻳ ﺔ(‬
‫ﺘﺮﻣﻴﺰ‪:‬‬
‫ﺜﺎل اﻟ‬
‫ﻣ‬
‫)‪6) s = Student ('Durga') 7‬‬

‫)‪5) print (Student.collegeName‬‬
‫‪(self، name): 4) self.name = name‬‬
‫'‪= 'DURGASOFT‬‬
‫)‪Student: 2)3‬‬‫‪collegeName‬‬
‫__ ‪def __init‬‬
‫ﺒﺎﻋ ﺔ )‪(s.name‬‬ ‫ﻃ‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫دورﺟﺎﺳﻮﻓ ﺖ‬
‫دورﺟﺎ‬
‫ﺑﻘﻮة و ﻫﻮ ﻟﻴ ﺲﺳﻮىﺗﻜﻮﻳﻦ‪.‬‬‫ﺒﻄﺎن‬
‫ﺗ‬‫ﺛﻢ ﻓﺈن ﻛﺎﺋﻦ اﻟﻄﺎﻟ ﺐ واﺳﻤﻪ ﻣﺮ‬‫ﺑﺪون ﻛﺎﺋﻦ اﻟﻄﺎﻟ ﺐ اﻟﻤﻮﺟﻮد ﻻﺗﻮﺟﺪ ﻓﺮﺻ ﺔ ﻟﻮﺟﻮد اﺳﻤﻪ‪ .‬وﻣﻦ‬‫ﺜﺎل أﻋﻼه‬
‫ﺒﺎﻃﺎ ﺿﻌﻴ ًﻔﺎ‬

‫ﺗ ً‬‫ﺒﻄﺎن ار‬
‫ﺗ‬‫ﺛﻢ ﻓﺈن ﻛﺎﺋﻦ اﻟﻄﺎﻟ ﺐ واﺳﻢ اﻟﻜﻠﻴ ﺔ ﻣﺮ‬‫ﺑﺪون ﻛﺎﺋﻦ اﻟﻄﺎﻟ ﺐ اﻟﺤﺎﻟ ﻲ ‪ ،‬ﻗﺪﺗﻜﻮن ﻫﻨﺎك ﻓﺮﺻ ﺔ ﻟﻮﺟﻮد ‪collegeName‬اﻟﺤﺎﻟ ﻲ‪ .‬وﻣﻦ‬‫وﻟﻜﻦ‬
‫و ﻫﻮ ﻟﻴ ﺲﺳﻮىﺗﺠﻤﻴﻊ‪.‬‬
‫ﺜﺎﻧﻴ ﺔ دورﺟﺎﺳﻮﻓ ﺖ ‪ ،‬رﻗﻢ ‪202 ، 2‬‬

‫اﻟ‬
‫‪39‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫ﺑﻖ ‪ ،‬ﻫﺪى ﻣﺎﻳ‬‫اﻟﻄﺎ‬
‫ﺗﻤ ﺔ‪:‬‬
‫ﺧﺎ‬
‫ﺘﺠﻤﻴﻊ‪.‬‬
‫ﺘ ﺔ واﻟﻜﺎﺋﻦ ﻫ ﻲ اﻟ‬
‫ﺑﻴﻦ اﻟﻤ‬‫ﺘﺮﻛﻴ ﺐ ﺣﻴ ﺚﺗﻜﻮن اﻟﻌﻼﻗ ﺔ‬
‫ﺜﻴﻠﻪ ﻫ ﻲ اﻟ‬
‫ﺘﻐﻴﺮا ت ﻣ‬
‫ﺑﻴﻦ اﻟﻜﺎﺋﻦ وﻣ‬‫ﺋﻤﺎ ﻣﺎﺗﻜﻮن اﻟﻌﻼﻗ ﺔ‬
‫دا ً‬
‫ﺘﻢﺗﻨﻔﻴﺬ‬
‫ﺘﻮي ﻋﲆُﻣﻨﺸ ﺊ ‪ ،‬ﻓ ﺴﻴ‬
‫ﺘﻢﺗﻨﻔﻴﺬُﻣﻨﺸ ﺊ اﻟﻔﺌ ﺔ اﻟﻔﺮﻋﻴ ﺔ‪ .‬إذا ﻛﺎﻧ ﺖ اﻟﻔﺌ ﺔ اﻟﻔﺮﻋﻴ ﺔ ﻻﺗﺤ‬
‫ﺑﺈﻧﺸﺎء ﻛﺎﺋﻦ ﻓﺌ ﺔ ﻓﺮﻋﻴ ﺔ ‪،‬ﺳﻴ‬‫ﻣﻼﺣﻈ ﺔ‪ :‬ﻋﻨﺪﻣﺎ ﻧﻘﻮم‬
‫ﺘﻢ إﻧﺸﺎء اﻟﻜﺎﺋﻦ اﻷﺻﻞ‪.‬‬
‫ُﻣﻨﺸ ﺊ اﻟﻔﺌ ﺔ اﻷﺻﻞ ‪ ،‬وﻟﻜﻦ ﻟﻦﻳ‬
‫)‪1‬اﻟﻔﺌ ﺔ ))‪c = C () 7) print (id (c‬‬

‫)‪(self)) 4) class C (P): 5) pass 6‬‬
‫‪def __init __ (self): 3) print‬‬
‫‪P:(id‬‬
‫)‪2‬‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫‪6207088‬‬
‫‪6207088‬‬
‫)‪1‬ﻓﺌ ﺔ اﻟﺸﺨﺺ‪)2) def __init __ :‬اﻟﺬا ت ‪ ،‬اﻻﺳﻢ ‪ ،‬اﻟﻌﻤﺮ(‪name 4) self.age = age 5) class Student (Person): 6) def __init __ :‬‬
‫= ‪)3) self.name‬اﻟﺬا ت ‪ ،‬اﻻﺳﻢ ‪ ،‬اﻟﻌﻤﺮ ‪rollno ، ،‬اﻟﻌﻼﻣﺎ ت(‪)7) super () .__ init __ :‬اﻻﺳﻢ ‪ ،‬اﻟﻌﻤﺮ( )‪9) 10) def __str __ (self): 11‬‬
‫ﺗﻨ ﺴﻴﻖ ‪(self.name، self.age، sel‬‬
‫‪8) self.rollno = rollno‬إرﺟﺎع ‪'Name = {} \ nAge = {} \ nRollno = {} \ n‬اﻟﻌﻼﻣﺎ ت ‪= {} '.‬‬
‫ﻋﻼﻣﺎ ت = ‪self.marks‬ﻋﻼﻣﺎ ت‬
‫)‪f.rollno، self.marks) 12) s1 = Student ('durga'، 48،101،90) 13) print (s1‬‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫اﻻﺳﻢ =دورﺟﺎ‬
‫اﻟﻌﻤﺮ ‪= 48‬‬
‫‪Rollno = 101‬‬
‫ﻋﻼﻣﺎ ت ‪= 90‬‬
‫ﺑﺈﻧﺸﺎء ﻛﺎﺋﻦ ﻓﺌ ﺔ ﻓﺮﻋ ﻲ ‪،‬ﺗﻢﺗﻨﻔﻴﺬ ﻛﻞ ﻣﻦُﻣﻨﺸﺌ ﻲ اﻟﻔﺌ ﺔ اﻷ ب واﻷمﻷداءﺗﻬﻴﺌ ﺔ اﻟﻜﺎﺋﻦ اﻟﻔﺮﻋ ﻲ‪.‬‬‫ﺜﺎل أﻋﻼه ‪ ،‬ﻋﻨﺪﻣﺎ ﻧﻘﻮم‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬ﻓ ﻲ اﻟﻤ‬

‫اﻟ‬
‫‪40‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫أﻧﻮاع اﻹر ث‪:‬‬
‫)‪1‬اﻟﻤﻴﺮا ث اﻟﻮﺣﻴﺪ‪:‬‬
‫ﺑﺎﺳﻢ اﻟﻤﻴﺮا ث اﻟﻔﺮدي‪.‬‬‫ﺛ ﺔ اﻟﺨﺼﺎﺋﺺ ﻣﻦ ﻓﺌ ﺔ إﱃ ﻓﺌ ﺔ أﺧﺮى‬
‫ُﻌﺮف ﻣﻔﻬﻮم ورا‬
‫ﻳ‬
‫)‪1‬اﻟﻔﺌ ﺔ )‪print ("Child Method") 7) c = C () 8‬‬

‫)‪Method") 4) class C (P): 5) def m2 (self): 6‬‬
‫‪P: 2) def m1 (self): 3) print ("Parent‬ﺳﻢ )‪() 9‬‬
‫‪1‬ﺳﻢ )( ‪2‬‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫ﻃﺮﻳﻘ ﺔ اﻟﻮاﻟﺪﻳﻦ‬
‫ﻃﺮﻳﻘ ﺔ اﻟﻄﻔﻞ‬
‫ص‬
‫اﻟﻤﻴﺮا ث اﻟﻮاﺣﺪ‬
‫ج‬
‫ﺘﻮﻳﺎ ت‪:‬‬
‫ﺛﺔ ﻣ‬
‫)‪2‬اﻟﻮرا‬
‫ﺘﻮﻳﺎ ت‪.‬‬
‫ﺛﺔ ﻣ‬
‫ﺑﺎﺳﻢ اﻟﻮرا‬‫ﺑﻤﻔﻬﻮم واﺣﺪﺗﻠﻮ اﻵﺧﺮ‬‫ﺘﻌﺪدة إﱃ ﻓﺌ ﺔ واﺣﺪة‬
‫ﺛ ﺔ اﻟﺨﺼﺎﺋﺺ ﻣﻦ ﻓﺌﺎ ت ﻣ‬
‫ﻳ‬
‫)‪1‬اﻟﻔﺌ ﺔ )"‪m3 (self): 9) print ("Sub Child Method‬‬

‫‪6) print ("Child Method") 7) class CC (C): 8) def‬‬
‫‪("Parent Method") 4) class‬‬
‫‪P: 2) C‬‬ ‫‪(P):m1‬‬
‫‪def‬‬ ‫‪5) (self):‬‬
‫‪def m2‬‬ ‫‪3)(self):‬‬
‫‪print‬‬
‫)‪10‬ج )( ‪= CC‬‬
‫‪41‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫)( ‪() 13) c.m3‬‬

‫‪() 12) c.m2‬‬
‫‪11) c.m1‬‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫ﻃﺮﻳﻘ ﺔ اﻟﻄﻔﻞ اﻟﻔﺮﻋﻴ ﺔ‬
‫ص‬
‫ج‬ ‫ﺘﻮﻳﺎ ت‬
‫ﺛﺔ ﻣ‬
‫اﻟﻮرا‬
‫ﻧ ﺴﺨ ﺔ‬
‫)‪3‬اﻟﻤﻴﺮا ث اﻟﻬﺮﻣ ﻲ‪:‬‬

‫ﺛ ﺔ اﻟﻬﺮﻣﻴ ﺔ‬
‫ﺑﺎﻟﻮرا‬‫ﺘﻮى‬
‫ﺘﻌﺪدة ﻣﻮﺟﻮدة ﻓ ﻲ ﻧﻔ ﺲ اﻟﻤ ﺴ‬
‫ﺛ ﺔ اﻟﺨﺼﺎﺋﺺ ﻣﻦ ﻓﺌ ﺔ واﺣﺪة إﱃ ﻓﺌﺎ ت ﻣ‬
‫ﻳ‬
‫ص‬
‫‪C1‬‬ ‫‪C2‬‬
‫اﻟﻬﺮﻣﻴ ﺔ‬
‫ﻣﻴﺮا ث‬
‫)‪1‬اﻟﻔﺌ ﺔ ‪("Parent Method") 4) class C1 (P):‬‬

‫‪P: 2) def m1 (self): 3) print‬‬
‫‪42‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
() 13) c2 = C2 () 14) c2.m1 () 15) c2.m3 ()

10)
m3 c1 = C19)()print
(self): 11 ) c1.m1 () 12)
("Child2 c1.m2
Method")
("Child1 Method") 7) class C2 (P): 8) def
5) def m2 (self): 6) print
:‫ﺘﺎج‬
‫اﻧ‬
1 ‫ﻃﺮﻳﻘ ﺔ اﻟﻄﻔﻞ‬
Child2 ‫ﻃﺮﻳﻘ ﺔ‬
:‫ﺗﻌﺪد اﻟﻤﻴﺮا ث‬
4)
.‫ﺘﻌﺪد‬
‫ﺑﺎﺳﻢ اﻟﻤﻴﺮا ث اﻟﻤ‬‫ﺘﻌﺪدة إﱃ ﻓﺌ ﺔ واﺣﺪة ﻓ ﻲ وﻗ ﺖ واﺣﺪ‬
‫ﺛ ﺔ اﻟﺨﺼﺎﺋﺺ ﻣﻦ ﻓﺌﺎ ت ﻣ‬
‫ﻳ‬
P1 P2
‫ج‬
‫ﻋﺪﻳﺪ‬
‫ﻣﻴﺮا ث‬
m3 (self): 9) print ("Child2 Method") ‫ﻓﺌ ﺔ‬1)

Method") 7) class C (P1) ، P2): 8) def
P2:
(self): 3)5) def ("Parent1
print m2 (self): 6) print ("Parent2
Method") 4) class
P1: 2) def m1
43
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫)( ‪() 13) c.m3‬‬

‫‪() 12) c.m2‬‬
‫‪C () 11) c.m1‬‬
‫= ‪10) c‬‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫ﻃﺮﻳﻘ ﺔ ‪Parent1‬‬
‫ﻃﺮﻳﻘ ﺔ ‪Child2‬‬
‫ﺑﺎء ﻓ ﻲ إﻋﻼن اﻟﻔﺌ ﺔ اﻟﻔﺮﻋﻴ ﺔ‪.‬‬

‫ﺗﻴ ﺐ ﻓﺌﺎ ت اﻵ‬
‫ﺒﺎرﺗﺮ‬
‫ﺘ‬‫ﺋﻤﺎ ﻓ ﻲ اﻻﻋ‬
‫ﺘﺄﺧﺬ ‪Python‬دا ً‬
‫ﺘﻴﻦ اﻷم ‪ ،‬ﻓ ﺴ‬
‫إذاﺗﻢﺗﻮرﻳ ﺚ ﻧﻔ ﺲ اﻟﻄﺮﻳﻘ ﺔ ﻣﻦ ﻛﻼ اﻟﻔﺌ‬
‫ﺘﻢ اﻟﻨﻈﺮ ﻓ ﻲ ﻃﺮﻳﻘ ﺔ ‪P1‬‬

‫‪C (P1 ، P2):‬ﺳﻴ‬ ‫اﻟﻔﺌ ﺔ‬
‫ﺘﻢ اﻟﻨﻈﺮ ﻓ ﻲ ﻃﺮﻳﻘ ﺔ ‪P2‬‬
‫اﻟﻔﺌ ﺔ ‪C (P2 ، P1):‬ﺳﻴ‬
‫)‪1‬ﻓﺌ ﺔ )( ‪9) print ("Child Method") 10) c = C‬‬

‫‪Method") 7) class C (P1) ، P2): 8) def m2 (self):‬‬
‫‪class‬‬
‫‪def‬‬ ‫‪m1P2:‬‬ ‫‪5) def‬‬
‫‪(self):‬‬ ‫‪m1 (self):‬‬
‫‪3) print‬‬ ‫‪6) print‬‬
‫‪("Parent1‬‬ ‫‪("Parent2‬‬
‫)"‪Method‬‬ ‫)‪4‬‬
‫)‪P1: 2‬‬
‫)‪11‬ﺳﻢ )‪1 () 12‬ﺳﻢ )( ‪2‬‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫‪44‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺛ ﺔ اﻟﻬﺠﻴﻨ ﺔ‪:‬‬
‫)‪5‬اﻟﻮرا‬
‫ﺛ ﺔ اﻟﻬﺠﻴﻨ ﺔ‪.‬‬
‫ﺑﺎﺳﻢ اﻟﻮرا‬‫ﺘ ﺴﻠ ﺴﻞ اﻟﻬﺮﻣ ﻲ‬
‫ﺘﻌﺪد واﻟ‬
‫ﺘﻮﻳﺎ ت واﻟﻤ‬
‫ﺘﻌﺪد اﻟﻤ ﺴ‬
‫ﺑﻴﻦ اﻟﻤﻴﺮا ث اﻟﻔﺮدي واﻟﻤ‬‫ُﻌﺮف اﻟﺠﻤﻊ‬
‫ﻳ‬
‫أ‬ ‫ب‬ ‫ج‬
‫د‬
‫ه‬
‫‪F‬‬
‫ﺟﻲ‬ ‫ح‬
‫)‪6‬اﻟﻤﻴﺮا ث اﻟﺪوري‪:‬‬
‫ﺒﻊ ﻓﻬﻮ ﻏﻴﺮ ﻣﻄﻠﻮ ب‬
‫ﺑﺎﻟﻄ‬‫ﺜﻮن اﻟﻤﻴﺮا ث اﻟﺪوري‬
‫ﺑﺎﻳ‬‫ﺑﻄﺮﻳﻘ ﺔ دورﻳ ﺔ اﺳﻢ اﻟﻤﻴﺮا ث اﻟﺪوري ‪ ،‬وﻟﻦﻳﺪﻋﻢ‬‫ﺛ ﺔ اﻟﺨﺼﺎﺋﺺ ﻣﻦ ﻓﺌ ﺔ إﱃ ﻓﺌ ﺔ أﺧﺮى‬
‫ُﻄﻠﻖ ﻋﲆ ﻣﻔﻬﻮم ورا‬
‫ﻳ‬
‫ﺣ ًﻘﺎ‪.‬‬
‫ﺘﻴﺎز‬
‫ﺜﺎل ‪- 1:‬اﻟﻔﺌ ﺔ أ )أ(‪ :‬اﺟ‬
‫ﻋﲆﺳ‬
‫ّف‬
‫‪NameError:‬اﻻﺳﻢ "‪"A‬ﻏﻴﺮ ﻣﻌ ﺮ‬
‫أ‬
‫ﺜﺎل ‪- 2:‬‬
‫ﻋﲆﺳ‬
‫ﺘﻴﺎز‬
‫)‪1‬اﻟﻔﺌ ﺔ أ ) ب(‪2) :‬اﺟ‬
‫)‪3‬اﻟﻔﺌ ﺔ ب )أ(‪4) :‬‬
‫ﻳﻤﺮ‬
‫ﺘﻢﺗﻌﺮﻳﻒ اﻻﺳﻢ " ب"‬

‫ﺧﻄﺄ ﻓ ﻲ اﻻﺳﻢ‪ :‬ﻟﻢﻳ‬

‫‪45‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫أ‬
‫ب‬
‫ﺗﻴ ﺐ ﻗﺮار اﻟﻄﺮﻳﻘ ﺔ ‪(MRO):‬‬

‫ﺗﺮ‬
‫ﺑﻨﺎ ًء ﻋﲆ ‪MRO‬‬‫ﺘﻢﺗﺤﺪﻳﺪ أﻣﺮ ﺣﻞ اﻟﻄﺮﻳﻘ ﺔ‬
‫ﺛ ﺔ اﻟﻬﺠﻴﻨ ﺔ ‪،‬ﻳ‬
‫•ﻓ ﻲ اﻟﻮرا‬
‫اﻟﺨﻮارزﻣﻴ ﺔ‪.‬‬
‫ﺑﺎﺳﻢ ﺧﻮارزﻣﻴ ﺔ ‪C3.‬‬ ‫ُﻌﺮف ﻫﺬه اﻟﺨﻮارزﻣﻴ ﺔ أ ً‬

‫ﻳﻀﺎ‬ ‫ﺗ‬
‫•‬
‫ﺑﻴﺪروﻧ ﻲ ﻫﺬه اﻟﺨﻮارزﻣﻴ ﺔ‪.‬‬‫ﺘﺮح ﺻﺎﻣﻮﻳﻞ‬

‫•اﻗ‬
‫ﺜﺮ ﻣﻦ اﻟﻮاﻟﺪ اﻷﻳﻤﻦ‪.‬‬

‫ﺒﺮ ﻣﻦ اﻷ ب‪• .‬اﻟﻮاﻟﺪﻳﻦ اﻷﻳ ﺴﺮﺳﻴﺤﺼﻼن ﻋﲆ أوﻟﻮﻳ ﺔ أﻛ‬ ‫ﺒﻊ ‪)DLR‬اﻟﻌﻤﻖ ً‬
‫أوﻻ ﻣﻦ اﻟﻴ ﺴﺎر إﱃ اﻟﻴﻤﻴﻦ( أي اﻟﻄﻔﻞﺳﻴﺤﺼﻞ ﻋﲆ أوﻟﻮﻳ ﺔ أﻛ‬ ‫ﺘ‬‫•ﻳ‬
‫‪• MRO (X) = X +‬دﻣﺞ ‪(MRO (P1) ، MRO (P2) ، ... ،‬ﻗﺎﺋﻤ ﺔ اﻟﻮاﻟﺪﻳﻦ(‬
‫ﺑﻞ اﻟﻤﺼﻄﻠﺤﺎ ت اﻟﺨﻠﻔﻴ ﺔ‪:‬‬

‫ﻋﻨﺼﺮ اﻟﺮأس ﻣﻘﺎ‬
‫ﺘﺮض أن ‪ C1 ، C2 ، C3 ، ...‬ﻫ ﻲ ﻓﺌﺎ ت‪.‬‬
‫•اﻓ‬
‫•ﻓ ﻲ اﻟﻘﺎﺋﻤ ﺔ‪C1C2C3C4C5 .... :‬‬
‫ﺑ ﺔ ذﻳﻞ‪.‬‬
‫ﺜﺎ‬
‫ﺑﻤ‬‫ﺒﻘ ﻲ‬
‫ﺘ‬‫ﺒﺮ اﻟﻤ‬
‫ﺘ‬‫ﺋﻴ ﺴ ًﻴﺎ وﻳﻌ‬
‫ﺒﺮ ‪C1‬ﻋﻨﺼ ﺮًا ر‬
‫ﺘ‬‫•ﻳﻌ‬
‫ﻛﻴﻒﺗﺠﺪ دﻣﺞ‪:‬‬
‫•ﺧﺬ رأس اﻟﻘﺎﺋﻤ ﺔ اﻷوﱃ‬
‫ﺘﻪ ﻣﻦ اﻟﻘﻮاﺋﻢ ﻓ ﻲ اﻟﺪﻣﺞ‪.‬‬

‫ﺘﻴﺠ ﺔ وإزاﻟ‬
‫ﺑﺈﺿﺎﻓ ﺔ ﻫﺬا اﻟﺮأس إﱃ اﻟﻨ‬‫•إذا ﻟﻢﻳﻜﻦ اﻟﺮأس ﻓ ﻲ اﻟﺠﺰء اﻟﺨﻠﻔ ﻲ ﻣﻦ أي ﻗﺎﺋﻤ ﺔ أﺧﺮى ‪ ،‬ﻓﻘﻢ‬
‫•إذا ﻛﺎن اﻟﺮأس ﻣﻮﺟﻮدًا ﻓ ﻲ اﻟﺠﺰء اﻟﺨﻠﻔ ﻲ ﻣﻦ أي ﻗﺎﺋﻤ ﺔ أﺧﺮى ‪ ،‬ﻓﻔﻜﺮ ﻓ ﻲ ﻋﻨﺼﺮ اﻟﺮأس‬
‫ﺑﻌ ﺔ ﻧﻔ ﺲ اﻟﻌﻤﻠﻴ ﺔ‪.‬‬

‫ﺘﺎ‬
‫ﺘﺎﻟﻴ ﺔ وﻣ‬
‫ﻣﻦ اﻟﻘﺎﺋﻤ ﺔ اﻟ‬
‫ﺘﺨﺪام وﻇﻴﻔ ﺔ ‪mro ().‬‬

‫ﺑﺎﺳ‬‫ﺜﻮر ﻋﲆ ‪MRO‬ﻣﻦ أي ﻓﺌ ﺔ‬
‫ﻣﻼﺣﻈ ﺔ‪:‬ﻳﻤﻜﻨﻨﺎ اﻟﻌ‬
‫ﺒﺎﻋ ﺔ ))( ‪(ClassName.mro‬‬
‫ﻃ‬
‫‪46‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
:‫ﻷﻣﺮ ﺣﻞ اﻟﻄﺮﻳﻘ ﺔ‬-1 ‫ﺒ ﻲ‬

‫ﺘﺠﺮﻳ‬
‫اﻟ‬
‫أ‬
‫ج‬
‫ب‬
‫د‬
‫ ﻛﺎﺋﻦ‬، ‫ﻣﺮو )أ( =أ‬

‫ ﻛﺎﺋﻦ‬، ‫ أ‬، ‫ﻣﺮو ) ب( = ب‬
‫ ﻛﺎﺋﻦ‬، ‫ أ‬، ‫ﻣﺮو )ج( =ج‬
‫ ﻛﺎﺋﻦ‬، ‫ أ‬، ‫ ج‬، ‫ ب‬، ‫ﻣﺮو )د( =د‬
test.py
(D.mro ()) ‫ﺒﺎﻋ ﺔ‬

‫(ﻃ‬A.mro ()) 6) ‫ﺒﺎﻋ ﺔ‬
‫ﻃ‬5) ‫ﺘﻴﺎز‬
‫اﺟ‬D (B ، C): ‫اﻟﻔﺌ ﺔ‬4) ‫ﺘﻴﺎز‬
‫اﺟ‬C (A): ‫اﻟﻔﺌ ﺔ‬3) ‫ﺘﻴﺎز‬
‫اﺟ‬B (A): ‫اﻟﻔﺌ ﺔ‬2) ‫ﺘﻴﺎز‬
‫اﺟ‬A: ‫اﻟﻔﺌ ﺔ‬1)
(B .mro ()) 7) print (C.mro ()) 8) print
:‫ﺘﺎج‬
‫اﻧ‬
[<class '__main __. A'>، <class 'object'>]
[<class '__main __. B'>، <class '__main __. A'>، <class 'object'>]
[<class '__main __. C'>، <class '__main __. A'>، <class 'object'>]
[<class '__main __. D'> ، <class '__main __. B'> ، <class '__main __. C'> ، <class '__main __. A'> ، <class 'object'>]
47
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﺒ ﻲ ‪-2‬ﻷﻣﺮ ﺣﻞ اﻟﻄﺮﻳﻘ ﺔ‪:‬‬

‫ﺘﺠﺮﻳ‬
‫اﻟ‬
‫ﻫﺪف‬
‫ج‬
‫أ‬ ‫ب‬
‫‪X‬‬ ‫ص‬
‫ﻣﺮو )أ( =أ ‪ ،‬ﻛﺎﺋﻦ‬ ‫ص‬
‫ﻣﺮو ) ب( = ب ‪ ،‬ﻛﺎﺋﻦ‬
‫ﺑﻪ‬‫ﻣﺮو )ج( =ج ‪ ،‬ﻣﻔﻌﻮل‬
‫‪mro (X) = X ، A ، B ،‬ﻛﺎﺋﻦ‬
‫‪mro (Y) = Y ، B ، C ،‬ﻛﺎﺋﻦ‬
‫‪mro (P) = P ، X ، A ، Y ، B ، C ،‬ﻛﺎﺋﻦ‬
‫ﺘﺨﺪام ﺧﻮارزﻣﻴ ﺔ ‪C3:‬‬

‫ﺑﺎﺳ‬
‫إﻳﺠﺎد )‪mro (P‬‬
‫اﻟﺼﻴﻐ ﺔ‪MRO (X) = X + :‬دﻣﺞ ‪(MRO (P1) ، MRO (P2) ، ... ،‬ﻗﺎﺋﻤ ﺔ اﻟﻮاﻟﺪﻳﻦ(‬
‫‪mro (p) = P +‬دﻣﺞ )‪(mro (X) ، mro (Y) ، mro (C) ، XYC‬‬
‫‪= P +‬دﻣﺞ )‪(XABO، YBCO، CO، XYC‬‬
‫‪= P + X +‬دﻣﺞ )‪(ABO، YBCO، CO، YC‬‬
‫‪= P + X + A +‬دﻣﺞ )‪(BO، YBCO، CO، YC‬‬
‫‪= P + X + A + Y +‬دﻣﺞ )‪(BO ، BCO ، CO ، C‬‬
‫‪= P + X + A + Y + B +‬دﻣﺞ )‪(O ، CO ، CO ، C‬‬
‫‪= P + X + A + Y + B + C +‬دﻣﺞ )‪(O ، O ، O‬‬
‫‪=P+X+A+Y+B+C+O‬‬
‫‪test.py‬‬
‫ﺘﻴﺎز )‪2‬اﻟﻔﺌ ﺔ ‪B:‬‬

‫)‪1‬اﻟﻔﺌ ﺔ ‪A:‬اﺟ‬
‫ﺗﻤﺮﻳﺮ )‪4‬اﻟﻔﺌ ﺔ‬
‫ﺘﻴﺎز )‪3‬اﻟﻔﺌ ﺔ ‪C:‬‬
‫اﺟ‬
‫ﺘﻴﺎز )‪5‬اﻟﻔﺌ ﺔ ‪C):‬‬
‫‪X (A ، B):‬اﺟ‬
‫ﺘﻴﺎز )‪6‬اﻟﻔﺌ ﺔ ‪P (X ، Y ،‬‬
‫‪Y (B ،‬اﺟ‬
‫‪:( (C‬ﻳﻤﺮ‬
‫‪48‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
(P.mro ()) # PXAYBCO ‫ﺒﺎﻋ ﺔ‬ ‫ﻃ‬7)

(Y.mro ()) # YBCO 10) print
(X.mro ()) # XABO 9) print
(A.mro ()) # AO 8) print
:‫ﺘﺎج‬
‫اﻧ‬
[<class '__main __. A'>، <class 'object'>]
[<class '__main __. X'> ، <class '__main __. A'> ، <class '__main __. B'> ، <class 'object'>]
[<class '__main __. Y'> ، <class '__main __. B'> ، <class '__main __. C'> ، <class 'object'>]
<class '__main __. X'> ، <class '__main __. A'> ، <class '__main __. Y'> ، <class '__main __. B'> ،
[<class '__main __. P'> ،
<class '__main __. C'>، <class 'object'>]
test.py
def m1 (self): 18) print (' ‫اﻟﻔﺌ ﺔ‬1)

Method') 16) class P (X، Y، C): 17)
def m1 (self):
Method') 13) 15) print
class Y (B،('YC):
class
14)
def m1 (self): 12) print ('X class
Method') 10) class X (A، B): 11)
def
('B m1 Method')
class (self): 9) print ('C C
7) class class
: 8)
class B: 5) def m1 (self): 6) print
3) print ('A class Method') 4)
() ‫ ﻓﺌ ﺔ‬P‫ﻳﻘ ﺔ‬
')‫ﻃﺮ‬ A:p2)=def
19) P () m1
20) (self):
p.m1
P ‫ ﻃﺮﻳﻘ ﺔ ﻓﺌ ﺔ‬:‫اﻹﺧﺮاج‬
‫إذا‬MRO. ‫وﻓ ًﻘﺎ ﻟـ‬X ‫ﺒﺎر ﻃﺮﻳﻘ ﺔ اﻟﻔﺌ ﺔ‬

‫ﺘ‬‫ﺘﻢ اﻋ‬
‫ﻓ ﺴﻴ‬m1 () ، ‫ﻋﲆ ﻃﺮﻳﻘ ﺔ‬P ‫ﺘﻮي اﻟﻔﺌ ﺔ‬
‫إذا ﻟﻢﺗﺤ‬P m1 (). ‫ﺘﻢ اﻟﻨﻈﺮ ﻓ ﻲ ﻃﺮﻳﻘ ﺔ اﻟﻔﺌ ﺔ‬
‫ﺳﻴ‬، ‫ﺜﺎل أﻋﻼه‬
.‫ﺘﻤﺮ ﻫﺬه اﻟﻌﻤﻠﻴ ﺔ‬
‫ﺘﺴ‬‫ﺘﻢ اﻟﻨﻈﺮ ﻓ ﻲ ﻃﺮﻳﻘ ﺔ اﻟﻔﺌ ﺔ وﺳ‬
‫ﻓ ﺴﻴ‬X ، ‫ﺘﻮي اﻟﻔﺌ ﺔ‬
‫ﻟﻢﺗﺤ‬
PXAYBCO :‫ﺘﺎﻟ ﻲ‬
‫ﺗﻴ ﺐ اﻟ‬
‫ﺘﺮ‬‫ﺑﺎﻟ‬‫ﺣﻞ اﻷﺳﻠﻮ ب‬
49
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﺒ ﻲ ‪-3‬ﻷﻣﺮ ﺣﻞ اﻟﻄﺮﻳﻘ ﺔ‪:‬‬

‫ﺘﺠﺮﻳ‬
‫اﻟ‬
‫ﻫﺪف‬
‫د‬ ‫ه‬ ‫‪F‬‬
‫ب‬
‫ج‬
‫أ‬
‫ﺑﻪ‬‫ﻣﺮو )س( =ﻣﻔﻌﻮل‬

‫ﻣﺮو )د( =د ‪ ،‬ﻛﺎﺋﻦ‬
‫‪mro (E) = E ،‬ﻛﺎﺋﻦ‬
‫ﻣﺮو ‪(F) = F ،‬ﻛﺎﺋﻦ‬
‫ﻣﺮو ) ب( = ب ‪ ،‬د ‪ ،‬ﻫـ ‪ ،‬ﻛﺎﺋﻦ‬
‫‪mro (C) = C ، D ، F ،‬ﻛﺎﺋﻦ‬
‫‪mro (A) = A +‬دﻣﺞ )‪(mro (B) ، mro (C) ، BC‬‬
‫‪= A +‬دﻣﺞ )‪(BDEO ، CDFO ، BC‬‬
‫‪= A + B +‬دﻣﺞ )‪(DEO ، CDFO ، C‬‬
‫‪= A + B + C +‬دﻣﺞ )‪(DEO ، DFO‬‬
‫‪= A + B + C + D +‬دﻣﺞ )‪(EO ، FO‬‬
‫‪= A + B + C + D + E +‬دﻣﺞ )‪(O ، FO‬‬
‫‪= A + B + C + D + E + F +‬دﻣﺞ )‪(O ، O‬‬
‫‪=A+B+C+D+E+F+O‬‬
‫‪test.py‬‬
‫ﺘﻴﺎز )‪2‬اﻟﻔﺌ ﺔ‬
‫)‪1‬اﻟﻔﺌ ﺔ ‪D:‬اﺟ‬
‫ﺘﻴﺎز‬
‫ﺘﻴﺎز )‪3‬اﻟﻔﺌ ﺔ ‪F:‬اﺟ‬
‫‪E:‬اﺟ‬
‫ﺘﻴﺎز‬
‫)‪4‬اﻟﻔﺌ ﺔ ‪B (D ، E):‬اﺟ‬
‫ﺘﻴﺎز‬
‫)‪5‬اﻟﻔﺌ ﺔ ‪C (D ، F):‬اﺟ‬
‫ﺘﻴﺎز‬
‫)‪6‬اﻟﻔﺌ ﺔ ‪A (B ، C):‬اﺟ‬
‫ﺒﺎﻋ ﺔ )‪(D.mro ()) 8‬‬
‫)‪7‬ﻃ‬
‫ﺒﺎﻋ ﺔ ))( ‪(B.mro‬‬
‫ﻃ‬
‫‪50‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
print (A.mro ()) ‫ﺒﺎﻋ ﺔ‬

‫ﻃ‬9)
(C.mro ()) 10)
:‫ﺘﺎج‬
‫اﻧ‬
[<class '__main __. D'>، <class 'object'>]
[<class '__main __. B'> ، <class '__main __. D'> ، <class '__main __. E'> ، <class 'object'>]
[<class '__main __. C'> ، <class '__main __. D'> ، <class '__main __. F'> ، <class 'object'>]
'__main __. A'> ، <class '__main __. B'> ، <class '__main __. C'> ، <class '__main __. D'> ، <class '__main __. E'> ،
[<class
<class '__main __. F'>، <class 'object'>]
:‫اﻟﻄﺮﻳﻘ ﺔ اﻟﻔﺎﺋﻘ ﺔ‬
.‫ﺘﻐﻴﺮا ت واﻟﻄﺮق ﻣﻦ اﻟﻔﺌ ﺔ اﻟﻔﺮﻋﻴ ﺔ‬
‫ﺒﻘ ﺔ اﻟﻔﺎﺋﻘ ﺔ واﻟﻤ‬
‫ﺘﺪﻋﺎءُﻣﻨﺸﺌﺎ ت اﻟﻄ‬
‫ ﻫ ﻲ ﻃﺮﻳﻘ ﺔ ﻣﻀﻤﻨ ﺔ ﻣﻔﻴﺪة ﻻﺳ‬super ()
(): ‫ﺑﺮ‬
‫ﻟﻠ ﺴﻮ‬-1 ‫ﺒ ﻲ‬
‫ﺘﺠﺮﻳ‬
‫اﻟ‬
self.age = age 5) def display (self): 6) 7) 8) 9) class Student

2) def __init __ (self، name، age): 3) self.name = name 4)
__init __
19)(self،
(‫اﻟﻌﻤﺮ‬name،
،‫)اﻻﺳﻢ‬age،
11) super
rollno،() .__
:(‫اﻟﺸﺨﺺ‬
init __ ):(‫ت‬
1) class
‫اﻟﻌﻼﻣﺎ‬Person:
10) def
print ('Roll
13) No:'،
14) 15) defself.rollno) 18) print
display (self): ('Marks:'،
16) super self.marks)
(). display () 17)
12) self.rollno = rollno
self.name) print ('Age:'، self.age)
print ('Name:'،
‫ﻋﻼﻣﺎ ت‬self.marks = ‫ﻋﻼﻣﺎ ت‬
22،101،90) 21) s1.display () ، '‫اﻟﻄﺎﻟ ﺐ )'دورﺟﺎ‬20) s1 =
:‫ﺘﺎج‬
‫اﻧ‬
‫ دورﺟﺎ‬:‫اﻻﺳﻢ‬
22 :‫اﻟﻌﻤﺮ‬
101 :‫رﻗﻢ اﻟﻠﻔ ﺔ‬
90 :‫ﻋﻼﻣﺎ ت‬
51
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
() ‫ﺘﺪﻋﺎءُﻣﻨﺸ ﺊ اﻟﺼﻨﻒ اﻷﺻﻞ وﻃﺮﻳﻘ ﺔ اﻟﻌﺮض‬

‫ﻻﺳ‬super () ‫ﺘﺨﺪم ﻃﺮﻳﻘ ﺔ‬
‫ ﻧ ﺴ‬، ‫ﺒﺮﻧﺎﻣﺞ أﻋﻼه‬
‫ﻓ ﻲ اﻟ‬
Super (): ‫ﻟـ‬-2 ‫ﺒ ﻲ‬

‫ﺘﺠﺮﻳ‬
‫اﻟ‬
17) self.b = 999 18) 19) 20) 21) 22) 23) 24) c = C () ‫اﻟﻔﺌ ﺔ‬1)
13) 14) class C (P): 15) a = 888 16) def __init __ (self):
11) def m3 (): 12) print ('Parent static method')
(cls):
('Parent
9) print
example
('Parent
method')
class method')
7) classmethod
10) staticmethod
8) def m2
def __init __ (self): 4) self.b = 10 5) def m1 (self): 6) print
P: 2) a = 10 3)
(). m2 () super (). m3 ()

a) super (). m1 () super
init __ () print (super ().
super () .__
:‫ﺘﺎج‬
‫اﻧ‬
10
‫ﺑﺖ‬
‫ﺜﺎ‬
.‫ﺑﺎء‬
‫ﺑﺎﻟﻌﺪﻳﺪ ﻣﻦ أﻋﻀﺎء ﻓﺌ ﺔ اﻵ‬‫ﺗﺼﺎل‬
‫ﻟﻼ‬super () ‫ﺘﺨﺪم‬
‫ ﻧ ﺴ‬، ‫ﺜﺎل أﻋﻼه‬
52
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﺑﺮ ﻣﻌﻴﻨ ﺔ‪:‬‬

‫ﺑﻔﺌ ﺔﺳﻮ‬‫ﺘﺪﻋﺎء ﻃﺮﻳﻘ ﺔ ﺧﺎﺻ ﺔ‬
‫ﻛﻴﻔﻴ ﺔ اﺳ‬
‫ﺘﺨﺪام اﻷﺳﺎﻟﻴ ﺐ اﻟ‬
‫ﺗ ﻲ(‪ .‬م )( ‪1‬‬

‫ﺑﺮ )د ‪ ،‬ذا‬
‫)‪1‬ﺳﻮ‬
‫ﺒﻘ ﺔ اﻟﻔﺎﺋﻘ ﺔ ﻟـ ‪D.‬‬
‫ﺘﺪﻋ ﻲ ﻃﺮﻳﻘ ﺔ )( ‪m1‬ﻟﻠﻄ‬
‫ﺳﻮفﺗ ﺴ‬
‫ﺗ ﻲ(‬
‫‪)2) A.m1‬ذا‬
‫ﺘﺪﻋ ﻲ ﻃﺮﻳﻘ ﺔ )( ‪A class m1‬‬
‫ﺳﻮفﺗ ﺴ‬
‫)'‪Method‬‬
‫‪6) print‬‬
‫‪4)('B‬‬
‫‪class‬‬
‫‪class‬‬
‫‪B (A):‬‬
‫)'‪Method‬‬
‫‪5) def 7‬‬
‫‪m1‬‬‫‪(self):‬ﺔ )‬
‫)‪1‬اﻟﻔﺌ‬
‫‪A: 2) def m1 (self): 3) print ('A class‬اﻟﻔﺌ ﺔ‬
‫‪(self):‬‬ ‫‪12) print‬‬
‫)'‪Method‬‬ ‫‪('D class‬‬
‫‪10) class‬‬ ‫'‪Method‬‬
‫‪D (C):‬‬ ‫‪11) def) m1‬‬
‫)‪13‬‬
‫‪C (B): 8) def m1 (self): 9) print ('C class‬‬
‫ﺗ ﻲ(‪15) :‬‬
‫اﻟﻔﺌ ﺔ ‪)E (D): 14) def m1‬ذا‬
‫ﺗ ﻲ( )( ‪e = E () 18) e.m1‬‬
‫‪)A.m1‬ذا‬
‫)‪16) 17‬‬
‫اﻟﻤﺨﺮﺟﺎ ت‪ :‬ﻃﺮﻳﻘ ﺔ ﺻﻨﻔﻴ ﺔ‬
‫ﺑﺮ ‪():‬‬
‫ﺘﻠﻔ ﺔ ﺣﻮلﺳﻮ‬
‫ﻧﻘﺎط ﻣﻬﻤ ﺔ ﻣﺨ‬
‫ﺘﺨﺪام‬
‫ﺘﺨﺪام ‪super () ،‬إﻟﺰاﻣ ﻲﻳﺠ ﺐ ﻋﻠﻴﻨﺎ اﺳ‬
‫ﺑﺎﺳ‬‫ﺜﻴﻞ اﻟﻔﺌ ﺔ اﻷﺻﻠﻴ ﺔ‬
‫ﺘﻐﻴﺮا ت ﻣ‬
‫ﺑﺎﻟﻮﺻﻮل إﱃ ﻣ‬‫ُﺴﻤﺢ ﻟﻨﺎ‬
‫اﻟﺤﺎﻟ ﺔ ‪1:‬ﻣﻦ ﻓﺌ ﺔ اﻷﻃﻔﺎل ‪ ،‬ﻻﻳ‬
‫اﻟﺬا ت ﻓﻘﻂ‪.‬‬
‫ﺘﺨﺪام ‪super ().‬‬
‫ﺑﺎﺳ‬‫ﺘ ﺔ ﻟﻠﻔﺌ ﺔ اﻷﺻﻞ‬
‫ﻟﻜﻦﻳﻤﻜﻨﻨﺎ اﻟﻮﺻﻮل إﱃ اﻟﻤ‬
‫)‪1‬اﻟﻔﺌ ﺔ ‪C (P): 7) def m1 (self):‬‬

‫‪(self): 4) self.b = 20 5) 6) class‬‬
‫__ ‪P: 2) a = 10 3) def __init‬‬
‫‪53‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
(). b) (self.b)
print #invalid#valid
11) c 10)
= C print
() 12) (super
c.m1 ()
8) print (super (). a) #valid 9)
:‫ﺘﺎج‬
‫اﻧ‬
10
20
"b" ‫"ﻟﻴ ﺲ ﻟﻪﺳﻤ ﺔ‬super" ‫اﻟﻜﺎﺋﻦ‬AttributeError:
‫ﺘ ﺔ وﻃﺮﻳﻘ ﺔ‬
‫ﺜﻴﻞ اﻟﻔﺌ ﺔ اﻷﺻﻞ واﻟﻄﺮﻳﻘ ﺔ اﻟ‬
‫ﻳﻤﻜﻨﻨﺎ اﻟﻮﺻﻮل إﱃ ﻃﺮﻳﻘ ﺔ ﻣ‬، ‫ﺜﻴﻞ‬
‫ﻣﻦُﻣﻨﺸ ﺊ اﻟﻔﺌ ﺔ اﻟﻔﺮﻋﻴ ﺔ وﻃﺮﻳﻘ ﺔ اﻟﻤ‬2: ‫اﻟﺤﺎﻟ ﺔ‬
super () ‫ﺘﺨﺪام‬
‫ﺑﺎﺳ‬‫اﻟﻔﺌ ﺔ‬
() 23) super (). m2 () 24) super (). m3 () ‫اﻟﻔﺌ ﺔ‬1)

(self): 21) super () .__ init __ () 22) super (). m1
super
15) (). m2 () 18)
super super
.__ init __ ()().16)
m3super
() 19) ().
20) def
m1 () m1
17)
12) 13) class C (P): 14) def __init __ (self) :
10) def ('Parent
print m3 (): 11) print
class ('Parent9)
method') static method')
staticmethod
method') 6) classmethod 7) def m2 (cls ): 8)
4) def m1 (self): 5) print ('Parent example
__init __ (self): 3) print ('Parent Constructor')
P: 2) def
1 () ‫ =ﺳﻢ‬C () 27) ‫ج‬25) 26)
54
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫اﻟﻤﻨﺸ ﺊ اﻷﺻﻞ‬
‫ﺑﺖ‬
‫ﺜﺎ‬
‫ﺑﺖ‬
‫ﺜﺎ‬
‫ﺑﺸﻜﻞ‬
‫ﺘﺨﺪام )( ‪super‬‬
‫ﺑﺎﺳ‬‫ﺜﻴﻞ اﻟﻔﺌ ﺔ اﻷﺻﻠﻴ ﺔ واﻟﻤﻨﺸﺌﺎ ت‬
‫اﻟﺤﺎﻟ ﺔ ‪3:‬ﻣﻦ اﻟﻔﺌ ﺔ اﻟﻔﺮﻋﻴ ﺔ ‪ ،‬ﻃﺮﻳﻘ ﺔ اﻟﻔﺌ ﺔ ﻻﻳﻤﻜﻨﻨﺎ اﻟﻮﺻﻮل إﱃ ﻃﺮق ﻣ‬
‫ﺘ ﺔ وﻃﺮق ﻓﺌ ﺔ اﻟﻮاﻟﺪﻳﻦ‪.‬‬
‫ﺑ‬‫ﺛﺎ‬‫ﺒﺎﺷﺮ(‪ .‬وﻟﻜﻦﻳﻤﻜﻨﻨﺎ اﻟﻮﺻﻮل إﱃ ﻃﺮق‬
‫ﺑﺸﻜﻞ ﻏﻴﺮ ﻣ‬‫ﺒﺎﺷﺮ )وﻟﻜﻦ ﻣﻤﻜﻦ‬
‫ﻣ‬
‫)‪1‬اﻟﻔﺌ ﺔ >‪15) def m1 (cls): 16) #super () .__ init __ () ---‬‬
‫‪static method') 12) 13) class C (P): 14) classmethod‬‬
‫)'‪method‬‬ ‫‪9) staticmethod‬‬

‫‪6) classmethod‬‬ ‫)‪7) def 10‬‬
‫‪m2 def‬‬
‫‪(cls m3‬‬
‫‪): 8)():‬‬ ‫‪11) print‬‬
‫‪print‬‬ ‫‪('Parent‬‬
‫‪('Parent‬‬ ‫‪class‬‬
‫)'‪4) def m1 (self): 5) print ('Parent example method‬‬
‫)(ﻏﻴﺮ‬
‫‪m2‬‬ ‫)‪P:19‬‬
‫‪2) def‬‬ ‫‪__init‬‬
‫‪super‬‬ ‫__ ‪().‬‬ ‫‪(self):‬‬
‫ﺻﺎﻟﺤ ﺔ‬ ‫)‪3‬ﻏﻴﺮ‬
‫)‪17‬‬‫‪print‬‬ ‫‪('Parent‬‬
‫‪#super‬‬ ‫)'‪Constructor‬‬
‫‪(). m1‬‬ ‫ﺻﺎﻟﺤ ﺔ >‪() ---‬‬
‫‪18) super ().‬م )‪3 () 20‬‬
‫)‪21‬م )( ‪1‬‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫ﺑﺖ‬
‫ﺜﺎ‬
‫‪55‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
:‫واﻟﻤﻨﺸﺌﻴﻦ‬
ُ ‫ﺑﺎء‬‫ﺜﻴﻞ ﻓﺌ ﺔ اﻵ‬
‫ﺘﺪﻋﺎء ﻃﺮق ﻣ‬
‫ ﻛﻴﻔﻴ ﺔ اﺳ‬، ‫ﻣﻦ ﻃﺮﻳﻘ ﺔ اﻟﻔﺼﻞ اﻟﺪراﺳ ﻲ ﻟﻔﺌ ﺔ اﻟﻄﻔﻞ‬
cls) .__ init __ (cls) 12) super (B، cls) .m1 (cls) 13) ‫اﻟﻔﺌ ﺔ‬1)
B (A): 9) classmethod 10 ) def m2 (cls): 11) super (B،
m1 (self): 6) print ('Parent example
("‫ ﺊ اﻷﺻﻞ‬method') 7) 8) class
‫)"اﻟﻤﻨﺸ‬print
A: 2) def __init __ (self): 3) 4) 5) def
14) B.m2 ()
:‫ﺘﺎج‬
‫اﻧ‬
(‫ﺘﺨﺪاﻣﻬﺎ‬
‫ﺑﻄﺮﻳﻘ ﺔ ﺧﺎﺻ ﺔﻳﻤﻜﻨﻨﺎ اﺳ‬‫ﺑﺸﻜﻞ ﻋﺎم )وﻟﻜﻦ‬
super () ‫ﺘﺨﺪام‬
‫ﺑﺎﺳ‬‫ُﺴﻤﺢ ﻟﻨﺎ‬
‫ ﻻﻳ‬، ‫ﺘ ﺔ ﻟﻔﺌ ﺔ اﻷﻃﻔﺎل‬
‫ﻓ ﻲ اﻟﻄﺮﻳﻘ ﺔ اﻟ‬4: ‫اﻟﺤﺎﻟ ﺔ‬
staticmethod 15) def m1 (): 16) super (). m1 () -> ‫اﻟﻔﺌ ﺔ‬1)
11) print ('Parent static method') 12) 13) class C (P): 14)
('Parent class method')
method') 9) staticmethod
6) classmethod 7) def m2 10)
(cls def
): 8)m3 ():
print
Constructor') 4) def m1 (self): 5) print ('Parent example
() --->
‫ﺻﺎﻟﺢ‬ ‫ﺻﺎﻟﺢﻏﻴﺮ‬ ‫ﻏﻴﺮ‬P: 2)
18) super (). def
m3 __init
() ---> __ (self):
‫ﺻﺎﻟﺢ‬ 3) print
‫ﻏﻴﺮ‬17) super('Parent
(). m2
19)
1 () ‫م‬20)
56 - 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﺘﺸﻐﻴﻞ‪super (): :‬ﻻﺗﻮﺟﺪ وﺳﻴﻄﺎ ت‬

‫ﺧﻄﺄ وﻗ ﺖ اﻟ‬
‫ﺑ ﺖ ﻟﻔﺌ ﺔ اﻟﻮاﻟﺪﻳﻦ ﻣﻦ ﻓﺌ ﺔ اﻷﻃﻔﺎل ‪Static‬‬

‫ﺜﺎ‬
‫ﺘﺪﻋﺎء اﻷﺳﻠﻮ ب اﻟ‬
‫ﺘﺨﺪام ‪super ():‬‬

‫ﺑﺎﺳ‬‫اﻟﻄﺮﻳﻘ ﺔ‬
‫ﺒﺎﻋ ﺔ‬
‫)‪1‬اﻟﻔﺌ ﺔ أ‪2) 3) staticmethod 4) def m1 (): 5) :‬ﻃ‬
‫ﺘ ﺔ"( )‪6) 7‬اﻟﻔﺌ ﺔ ) ‪9) def m2 (): 10‬‬
‫)"اﻟﻄﺮﻳﻘ ﺔ اﻷﺻﻠﻴ ﺔ اﻟ‬
‫ﺑﺮ ) ب ‪ ،‬ب(‪ .‬م )‪1 () 11‬‬
‫‪B (A): 8) staticmethod‬ﺳﻮ‬
‫)( ‪12) B.m2‬‬
‫ﺑﺖ‬
‫ﺜﺎ‬
‫اﻹﺧﺮاج‪ :‬اﻟﻄﺮﻳﻘ ﺔ اﻷﺻﻞ اﻟ‬

‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺑ ﺲ‬ ‫ُ‬
‫أوو‬
‫اﻟﺠﺰء ‪- 3‬‬
‫‪58‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺗﻌﺪد اﻷﺷﻜﺎل‬
‫ﺗﻌﻨ ﻲ اﻷﺷﻜﺎل‪.‬‬
‫ﺜﻴﺮ‪Morphs .‬‬
‫ﺑﻮﻟ ﻲﻳﻌﻨ ﻲ اﻟﻜ‬
‫ﺗﻌﺪد اﻷﺷﻜﺎلﻳﻌﻨ ﻲ "اﻟﻌﺪﻳﺪ ﻣﻦ اﻷﺷﻜﺎل"‪.‬‬
‫ﺜﺎل ﻋﲆﺗﻌﺪد اﻷﺷﻜﺎل‪ .‬أﻣﺎم واﻟﺪﻳﻚﺳﻴﻜﻮن ﻟﺪﻳﻚ ﻧﻮع واﺣﺪ ﻣﻦ اﻟ ﺴﻠﻮك وﻣﻊ اﻷﺻﺪﻗﺎء ﻧﻮع آﺧﺮ ﻣﻦ اﻟ ﺴﻠﻮك ‪ ،‬ﺷﺨﺺ‬
‫ﺜﺎل ‪1:‬ﻧﻔ ﺴﻚ ﻫﻮ أﻓﻀﻞ ﻣ‬
‫ﻣ‬
‫ﺘﻠﻔ ﺔ ‪ ،‬و ﻫﺬا ﻟﻴ ﺲﺳﻮىﺗﻌﺪد اﻷﺷﻜﺎل‪.‬‬
‫ﺘﻠﻔ ﺔ ﻓ ﻲ أﻣﺎﻛﻦ ﻣﺨ‬
‫واﺣﺪ وﻟﻜﻦﺳﻠﻮﻛﻴﺎ ت ﻣﺨ‬
‫ﺑﻴ ﺔ‬
‫ﺘﺸﻐﻴﻞ ‪Eg2: +‬ﻳﻌﻤﻞ ﻛ ﺴﻠ ﺴﻠ ﺔ وإﺿﺎﻓ ﺔ ﺣ ﺴﺎ‬
‫ﻋﺎﻣﻞ اﻟ‬
‫*‬
‫ﺘﻜﺮار‬
‫ﻋﺎﻣﻞﻳﻌﻤﻞ ﻛﻌﺎﻣﻞ اﻟﻀﺮ ب واﻟ‬
‫‪Eg3:‬‬
‫ﺗﺠﺎوز(‬
‫ﺘﻠﻔ ﺔ ﻓ ﻲ ﻓﺼﻮل اﻟﻮاﻟﺪﻳﻦ واﻟﻔﺼﻮل اﻟﻔﺮﻋﻴ ﺔ‪) .‬‬
‫ﺒﻴﻘﺎ ت ﻣﺨ‬
‫ﺜﺎل ‪4:‬ﻧﻔ ﺲ اﻟﻄﺮﻳﻘ ﺔ ﻣﻊﺗﻄ‬
‫ﻣ‬
‫ﺘﺎﻟﻴ ﺔ ﻣﻬﻤ ﺔ‬
‫ﺑﻌ ﺔ اﻟ‬
‫ﺘﻌﺪد اﻷﺷﻜﺎل ‪ ،‬ﻓﺈن اﻟﻤﻮﺿﻮﻋﺎ ت اﻷر‬
‫ﺑ‬‫ﺘﻌﻠﻖ‬
‫ﻓﻴﻤﺎﻳ‬
‫ﺜﻮن‬
‫ﺑﺎﻳ‬‫ﺒﻄ ﺔ ﻓ ﻲ‬
‫ﺒﺎﻋ ﺔ اﻟ‬
‫)‪1‬ﻓﻠ ﺴﻔ ﺔ ﻃ‬
‫ﺘﺤﻤﻴﻞ اﻟﺰاﺋﺪ‬
‫)‪2‬اﻟ‬
‫)‪1‬اﻟﺤﻤﻮﻟ ﺔ اﻟﺰاﺋﺪة ﻋﲆ اﻟﻤﺸﻐﻞ‬
‫)‪2‬ﻃﺮﻳﻘ ﺔ اﻟ‬
‫)‪3‬اﻟﺤﻤﻮﻟ ﺔ اﻟﺰاﺋﺪة ﻟﻠﻤﻨﺸ ﺊ‬
‫ﺗﺠﺎوز‬
‫)‪3‬‬
‫)‪1‬ﻃﺮﻳﻘ ﺔﺗﺠﺎوز‬
‫ﺗﺠﺎوز اﻟﻤﻨﺸ ﺊ‬
‫)‪2‬‬
‫ﺜﻮن‪:‬‬
‫ﺑﺎﻳ‬‫ﺒﻂ ﻓ ﻲ‬
‫ﺑ ﺔ اﻟ‬
‫ﺘﺎ‬
‫)‪1‬ﻓﻠ ﺴﻔ ﺔ ﻛ‬
‫ﺛﻢ‬‫ﺒﺎر اﻟﻨﻮعﺗﻠﻘﺎﺋ ًﻴﺎ‪ .‬وﻣﻦ‬
‫ﺘﺸﻐﻴﻞ ‪،‬ﺳﻴ‬
‫ﺑﻨﺎ ًء ﻋﲆ اﻟﻘﻴﻤ ﺔ اﻟﻤﻘﺪﻣ ﺔ ﻓ ﻲ وﻗ ﺖ اﻟ‬‫ﺑﺸﻜﻞ ﺻﺮﻳﺢ‪.‬‬‫ﺜﻮن ﻻﻳﻤﻜﻨﻨﺎﺗﺤﺪﻳﺪ اﻟﻨﻮع‬
‫ﺒﻮﻋ ﺔ دﻳﻨﺎﻣﻴﻜ ًﻴﺎ‪.‬‬
‫ﺑﺮﻣﺠ ﺔ ﻣﻄ‬‫ﺜﻮن ﻟﻐ ﺔ‬
‫ﺑﺎﻳ‬‫ﺒﺮ‬
‫‪def f1 (obj):‬‬
‫)( ‪obj.talk‬‬
‫ﺛﻢ ﻛﻴﻒﻳﻤﻜﻨﻨﺎﺗﺤﺪﻳﺪ اﻟﻨﻮع؟‬‫ﺘﺸﻐﻴﻞﻳﻤﻜﻨﻨﺎﺗﻤﺮﻳﺮ أي ﻧﻮع‪.‬‬

‫ﺒﺪاﻳ ﺔ‪ .‬ﻓ ﻲ وﻗ ﺖ اﻟ‬
‫ﻣﺎ ﻫﻮ ﻧﻮع اﻟﻬﺪف؟ ﻻﻳﻤﻜﻨﻨﺎ أن ﻧﻘﺮر ﻓ ﻲ اﻟ‬
‫ﺒﻄ ﺔ‬
‫ﺒﺎﻋ ﺔ اﻟ‬
‫ﺑﻔﻠ ﺴﻔ ﺔ ﻃ‬‫ﺒﺪأ‪ .‬و ﻫﺬا ﻣﺎﻳ ﺴﻤﻰ‬
‫ﺜﻮن ﻫﺬا اﻟﻤ‬
‫ﺑﺎﻳ‬‫ﺒﻊ‬
‫ﺘ‬‫ﺑﻄ ﺔ"‪.‬ﺗ‬‫ﺒﻄ ﺔ ‪،‬ﻳﺠ ﺐ أنﻳﻜﻮن‬
‫ﺜﻞ اﻟ‬
‫ﺘﺤﺪ ث ﻣ‬
‫ﺒﻄ ﺔ وﻳ‬
‫ﺜﻞ اﻟ‬
‫ﺘﺸﻐﻴﻞ ‪ ،‬إذا ﻛﺎن "ﻳ ﺴﻴﺮ ﻣ‬
‫ﻓ ﻲ وﻗ ﺖ اﻟ‬
‫ﺜﻮن‪.‬‬
‫‪59‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
() ، Cat () ، Dog () ، Goat ()] 21)

18) obj.talk () 19) 20) l = [Duck
Myaah
14) def..')talk
15)(self):
16) 17)print
def ('Myaah
f1 (obj):
Moew ..') 11) 12) 13) class Goat:
10) def talk (self): print ('Moew
def talk (self): 7) 8) 9) class Cat:
Quack ("Bow
..') 3) 4)
Bow5) class Dog:
..") ‫ﺒﺎﻋ ﺔ‬‫ﻃ‬ 6)
2) def talk (self): print ('Quack ..
in l: 22) f1 (obj) ‫ﻟـ‬1) class Duck:
obj
:‫ﺘﺎج‬
‫اﻧ‬
.. ‫ دﺟﺎل‬.. ‫دﺟﺎل‬
.. ‫ﻣﻮ ﻣﻮ‬
..‫اﻟﻘﻮس اﻟﻘﻮس‬
.. ‫ﻣﻴ ﺔ ﻣﻴ ﺔ‬
AttributeError. ‫ﻓ ﺴﻨﺤﺼﻞ ﻋﲆ‬talk () ، ‫ﺘﻮي ﻋﲆ ﻃﺮﻳﻘ ﺔ‬

‫ﻻﻳﺤ‬obj ‫اﻟﻤﺸﻜﻠ ﺔ ﻓ ﻲ ﻫﺬا اﻟﻨﻬﺞ ﻫ ﻲ أﻧﻪ إذا ﻛﺎن‬
10) 11) d = Duck () 12) f1 (d) 13)

') 8) def f1 (obj): 9) obj.talk ()
defQuack
bark (self): 7) class
..') 4) 5) print Dog:
('Bow6)
..
talk (self): 3) print ('Quack ..
1) class Duck: 2) def
60
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫د =اﻟﻜﻠ ﺐ‬14)
(‫ )()د‬15) f1
:‫ﺘﺎج‬
‫اﻧ‬
\ durga_classes> py test.py :‫د‬
.. ‫ دﺟﺎل‬.. ‫دﺟﺎل‬
:(‫)أﺣﺪ ث ﻣﻜﺎﻟﻤ ﺔ أﺧﻴﺮة‬Traceback
<module> ‫ﻓ ﻲ‬22 ، ‫"اﻟ ﺴﻄﺮ‬test.py" ، ‫ﻣﻠﻒ‬
(‫)د‬1 ‫و‬
f1 ‫ﻓ ﻲ‬13 ، ‫"اﻟ ﺴﻄﺮ‬test.py" ، ‫ﻣﻠﻒ‬
obj.talk ()
"talk" ‫اﻟﻜﺎﺋﻦ "اﻟﻜﻠ ﺐ" ﻟﻴ ﺲ ﻟﻪﺳﻤ ﺔ‬AttributeError:
hasattr (). ‫ﺘﺨﺪام داﻟ ﺔ‬

‫ﺑﺎﺳ‬‫ﻟﻜﻦﻳﻤﻜﻨﻨﺎ ﺣﻞ ﻫﺬه اﻟﻤﺸﻜﻠ ﺔ‬
‫ﺘﻐﻴﺮ‬
‫ﻳﻤﻜﻦ أنﺗﻜﻮن اﻟ ﺴﻤ ﺔ اﺳﻢ اﻟﻄﺮﻳﻘ ﺔ أو اﺳﻢ اﻟﻤ‬hasattr (obj، 'attributename')
hasattr (): ‫ﺑﻮﻇﻴﻔ ﺔ‬‫ﺒﻲ‬

18) 19) d = Duck () 20) f1 (d) 21) 22) h =

elif hasattr (obj، 'bark') : 17) obj.bark ()
ifbark
hasattr (obj،
(self): 11)'talk'):
12) 13)15)
defobj.talk () 14)
f1 (obj): 16)
def talk (self): 7) 8) 9) class Dog: 10) def
('Quack .. Quack ..') 4) 5) class Human: 6)
1) class Duck: 2) def talk (self): 3) print
f1 ‫ )(اﻟﻜﻠ ﺐ‬23)
("...f1
‫ﺒﺎ‬ (h) ‫ﺒﺎ‬
‫ﻣﺮﺣ‬ 24) 25)‫ﺒﺎﻋ ﺔ‬
‫)"ﻣﺮﺣ‬ d‫ﻃ‬
= ‫اﻹﻧ ﺴﺎن‬
(‫ )()د‬26)
("Bow Bow ..") ‫ﺒﺎﻋ ﺔ‬

‫ﻃ‬
61
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫)‪27‬ﻣﻴﺎ ﻣﻴ ﺔ ﻣﻴ ﺔ ‪...‬‬
‫)‪2‬اﻟ‬
‫ﺘﻠﻔ ﺔ‪.‬‬
‫ﺘﺨﺪام ﻧﻔ ﺲ اﻟﻤﺸﻐﻞ أو اﻷﺳﺎﻟﻴ ﺐﻷﻏﺮاض ﻣﺨ‬
‫ﺗ ﺴﻠ ﺴﻞ اﻟ ﺴﻠ ﺴﻠ ﺔ‬
‫ﺑ ﻲو‬
‫ﺘﺸﻐﻴﻞ ‪1: +‬ﻟﻠﺠﻤﻊ اﻟﺤ ﺴﺎ‬
‫ﺘﺨﺪام ﻋﺎﻣﻞ اﻟ‬
‫ﺜﺎل ‪،‬ﻳﻤﻜﻦ اﺳ‬
‫ﻋﲆﺳ‬
‫‪print (10 + 20) # 30‬‬
‫‪print ('durga' + 'soft') #‬دورﺟﺎﺳﻮﻓ ﺖ‬
‫ﺗﻜﺮار اﻟ ﺴﻠ ﺴﻠ ﺔ‪.‬‬
‫ﺘﺸﻐﻴﻞﻷﻏﺮاض اﻟﻀﺮ ب و‬
‫ﺜﺎل * ‪2:‬ﻳﻤﻜﻦ اﺳ‬
‫ﻣ‬
‫ﺒﺎﻋ ﺔ ‪(10 * 20) # 200‬‬
‫ﻃ‬
‫‪print ('durga' * 3) #durgadurgadurga‬‬
‫ﺘﺨﺪام ﻃﺮﻳﻘ ﺔ اﻹﻳﺪاع )(ﻟﻺﻳﺪاع اﻟﻨﻘﺪي أو اﻟﺸﻴﻚ أو اﻟﻴﻮم‬

‫ﺜﺎل ‪3:‬ﻳﻤﻜﻨﻨﺎ اﺳ‬
‫ﻣ‬
‫إﻳﺪاع ﻧﻘﺪي(‬
‫إﻳﺪاع )ﺷﻴﻚ(‬
‫إﻳﺪاع )ﻳﻮم(‬
‫ﻫﻨﺎك ‪3‬أﻧﻮاع ﻣﻦ اﻟ‬
‫)‪1‬اﻟﺤﻤﻮﻟ ﺔ اﻟﺰاﺋﺪة ﻋﲆ اﻟﻤﺸﻐﻞ‬
‫)‪3‬اﻟﺤﻤﻮﻟ ﺔ اﻟﺰاﺋﺪة ﻟﻠﻤﻨﺸ ﺊ‬
‫)‪1‬اﻟﺤﻤﻮﻟ ﺔ اﻟﺰاﺋﺪة ﻟﻠﻤﺸﻐﻞ‪:‬‬

‫ﺘﺸﻐﻴﻞ‬
‫ﺘ ﻲ ﻟﻴ ﺴ ﺖﺳﻮى ﻋﺎﻣﻞ اﻟ‬
‫ﺘﻌﺪدة ‪ ،‬واﻟ‬
‫ﺘﺨﺪام ﻧﻔ ﺲ اﻟﻤﺸﻐﻞﻷﻏﺮاض ﻣ‬
‫•ﻳﻤﻜﻨﻨﺎ اﺳ‬
‫اﻟﺰاﺋﺪ‪.‬‬
‫ﺘﺤﻤﻴﻞ اﻟﺰاﺋﺪ ﻋﲆ اﻟﻤﺸﻐﻞ‪.‬‬
‫ﺗﺪﻋﻢ ‪Python‬اﻟ‬
‫•‬
‫ﺗ ﺴﻠ ﺴﻞ اﻟ ﺴﻠ ﺴﻠ ﺔ‬
‫ﺑ ﻲو‬
‫ﺘﺸﻐﻴﻞ ‪1: +‬ﻟﻠﺠﻤﻊ اﻟﺤ ﺴﺎ‬
‫ﺜﺎل ‪،‬ﻳﻤﻜﻦ اﺳ‬
‫ﻋﲆﺳ‬
‫‪print (10 + 20) # 30‬‬
‫‪print ('durga' + 'soft') #‬دورﺟﺎﺳﻮﻓ ﺖ‬
‫ﺗﻜﺮار اﻟ ﺴﻠ ﺴﻠ ﺔ‪.‬‬
‫ﺘﺸﻐﻴﻞﻷﻏﺮاض اﻟﻀﺮ ب و‬
‫ﺜﺎل * ‪2:‬ﻳﻤﻜﻦ اﺳ‬
‫ﻣ‬
‫ﺒﺎﻋ ﺔ ‪(10 * 20) # 200‬‬
‫ﻃ‬
‫‪print ('durga' * 3) #durgadurgadurga‬‬
‫ﺘﺨﺪام ‪+‬ﻋﺎﻣﻞﺗﺸﻐﻴﻞ ﻟﻜﺎﺋﻨﺎ ت اﻟﻔﺼﻞ ﻟﺪﻳﻨﺎ‪:‬‬

‫ﺒ ﻲ ﻻﺳ‬
‫ﺘﺎ ب اﻟﻔﺼﻞ ‪pages): 3) self.pages = :‬‬

‫)‪1‬ﻛ‬
‫‪ 2) def __init __ (self،‬ﺻﻔﺤﺎ ت = ‪4) 5) b1‬‬
‫ﺘﺎ ب )‪(100‬‬
‫ﻛ‬
‫‪62‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﺎ ب )‪7‬‬‫)‪ 6‬ب = ‪2‬ﻛ‬

‫ﺒﺎﻋ ﺔ ) ب ‪ 1 +‬ب )‪2‬‬
‫)‪(200‬ﻃ‬

‫‪)Traceback‬أﺣﺪ ث ﻣﻜﺎﻟﻤ ﺔ أﺧﻴﺮة(‪:‬‬
‫ﻣﻠﻒ ‪"test.py" ،‬اﻟ ﺴﻄﺮ ‪7 ،‬ﻓ ﻲ >‪<module‬‬
‫ﺒﺎﻋ ﺔ ) ب ‪ 1 +‬ب )‪2‬‬
‫ﻃ‬
‫‪TypeError:‬ﻧﻮع )أﻧﻮاع( اﻟﻤﻌﺎﻣﻞ ﻏﻴﺮ اﻟﻤﺪﻋﻮم ﻟـ "‪+: "Book‬و "‪"Book‬‬
‫ﺜﺎل ‪،‬ﺗﺪﻋﻢ ‪Python‬اﻟ‬
‫ﺒﻴﻞ اﻟﻤ‬ ‫ﺘﺎ ب أ ً‬
‫ﻳﻀﺎ‪ .‬ﻋﲆﺳ‬ ‫ﺘﺸﻐﻴﻞ ﻟﻠﻌﻤﻞ ﻣﻊ ﻛﺎﺋﻨﺎ ت اﻟﻜ‬
‫ﺘﺤﻤﻴﻞ ‪+‬ﻋﺎﻣﻞ اﻟ‬
‫ﻳﻤﻜﻨﻨﺎ زﻳﺎدة اﻟ‬
‫ﻋﲆ اﻟﻤﺸﻐﻞ‪.‬‬
‫ﺘﺎﺣ ﺔ‪ .‬ﻟﺰﻳﺎدةﺗﺤﻤﻴﻞ أي ﻋﺎﻣﻞ ﻋﻠﻴﻨﺎ‬
‫ﻟﻜﻞ ﻋﺎﻣﻞ ﻃﺮق اﻟ ﺴﺤﺮ اﻟﻤ‬
‫ﺗﺠﺎوزﺗﻠﻚ اﻟﻄﺮﻳﻘ ﺔ ﻓ ﻲ ﺻﻔﻨﺎ‪.‬‬
‫ﺗ ﺴﻤﻰ ﻫﺬه اﻟﻄﺮﻳﻘ ﺔ اﻟﻄﺮﻳﻘ ﺔ اﻟ ﺴﺤﺮﻳ ﺔ ﻟﻤﺸﻐﻞ ‪+.‬ﻋﻠﻴﻨﺎﺗﺠﺎوز ﻫﺬه‬

‫ﺘﺨﺪام ﻃﺮﻳﻘ ﺔ ‪__add __ () ،‬و‬
‫ﺑﺎﺳ‬‫ﺘﺸﻐﻴﻞ‬
‫ﺘﻢﺗﻨﻔﻴﺬ ﻋﺎﻣﻞ اﻟ‬
‫داﺧﻠ ًﻴﺎ ‪+‬ﻳ‬
‫اﻟﻄﺮﻳﻘ ﺔ ﻓ ﻲ ﺻﻔﻨﺎ‪.‬‬
‫ﺘﺎ ب ﻟﺪﻳﻨﺎ‪:‬‬
‫ﺘﺤﻤﻴﻞ اﻟﺰاﺋﺪ ‪+‬اﻟﻤﺸﻐﻞ ﻟﻜﺎﺋﻨﺎ ت ﻓﺌ ﺔ اﻟﻜ‬
‫ﺒ ﻲ ﻟﻠ‬
‫ﺘﺎ ب اﻟﻔﺼﻞ ‪__init __ (self، pages): 3) self.pages = :‬‬

‫)‪1‬ﻛ‬
‫‪ 2) def‬ﺻﻔﺤﺎ ت = ‪self.pages + other.pages 7) 8) b1‬‬
‫)‪+(100‬‬ ‫اﻟﺼﻔﺤﺎب )‪9‬‬
‫ت‪ ، ':‬ب‬ ‫ﺘﺎ‬
‫ﻋﺪد )‪4‬ﻛ‬
‫‪5) def‬‬ ‫‪__add‬‬
‫إﺟﻤﺎﻟ ﻲ‬ ‫__ﺔ '(‬
‫ﺒﺎﻋ‬‫‪(self،‬‬
‫)‪(200‬ﻃ‬ ‫‪other):‬‬
‫)‪ 6‬ب )‪10‬‬
‫ﺘﺎ‬‫‪return‬ﻛ‬
‫ب =‪2‬‬
‫‪ 1‬ب )‪2‬‬
‫اﻟﻤﺨﺮﺟﺎ ت‪ :‬اﻟﻌﺪد اﻹﺟﻤﺎﻟ ﻲ ﻟﻠﺼﻔﺤﺎ ت‪300 :‬‬
‫ﺑﻠ ﺔ‪.‬‬
‫ﻓﻴﻤﺎﻳﻠ ﻲ ﻗﺎﺋﻤ ﺔ اﻟﻌﻮاﻣﻞ واﻟﻄﺮق اﻟ ﺴﺤﺮﻳ ﺔ اﻟﻤﻘﺎ‬
‫= ‪= 12) //‬‬ ‫ﻛﺎﺋﻦ ‪ __.‬إﺿﺎﻓ ﺔ __)اﻟﻨﻔ ﺲ ‪ ،‬أﺧﺮى(‬

‫‪* = 11) /‬‬ ‫اﻟﻜﺎﺋﻦ‪_ .‬اﻟﻔﺮﻋﻴ ﺔ __)اﻟﻨﻔ ﺲ ‪ ،‬أﺧﺮى(‬
‫*‬
‫)‪= 9) - = 10‬‬ ‫ﻛﺎﺋﻦ ‪)mul __ __.‬اﻟﻨﻔ ﺲ ‪ ،‬أﺧﺮى(‬
‫‪6)٪ 7) 8) +‬‬ ‫اﻟﻜﺎﺋﻦ ‪)div __ __.‬اﻟﻨﻔ ﺲ ‪ ،‬أﺧﺮى(‬
‫‪3) 4) / 5) //‬‬ ‫اﻟﻜﺎﺋﻦ ‪)floordiv __ __.‬اﻟﻨﻔ ﺲ ‪ ،‬أﺧﺮى(‬
‫‪1) + 2) -‬‬ ‫اﻟﻜﺎﺋﻦ ‪)mod __ __.‬اﻟﻨﻔ ﺲ ‪ ،‬أﺧﺮى(‬
‫**‬ ‫اﻟﻜﺎﺋﻦ ‪ __.‬اﻷﺳﺮى __)اﻟﻨﻔ ﺲ ‪ ،‬أﺧﺮى(‬
‫ﻛﺎﺋﻦ ‪)iadd __ __.‬ﻧﻔ ﺴﻴ ﺔ ‪ ،‬أﺧﺮى(‬
‫اﻟﻜﺎﺋﻦ ‪)isub __ __.‬اﻟﻨﻔ ﺲ ‪ ،‬أﺧﺮى(‬
‫ﻛﺎﺋﻦ ‪)imul __ __.‬اﻟﻨﻔ ﺲ ‪ ،‬أﺧﺮى(‬
‫اﻟﻜﺎﺋﻦ ‪)idiv __ __.‬اﻟﻨﻔ ﺲ ‪ ،‬أﺧﺮى(‬
‫اﻟﻜﺎﺋﻦ ‪)ifloordiv __ __.‬اﻟﻨﻔ ﺲ ‪ ،‬أﺧﺮى(‬
‫‪63‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫= !)‪19) == 20‬‬ ‫اﻟﻜﺎﺋﻦ ‪)imod __ __.‬اﻟﻨﻔ ﺲ ‪ ،‬أﺧﺮى(‬

‫= >)‪17)> 18‬‬ ‫اﻟﻜﺎﺋﻦ ‪)ipow __ __.‬اﻟﻨﻔ ﺲ ‪ ،‬أﺧﺮى(‬
‫=< )‪15) <16‬‬ ‫اﻟﻜﺎﺋﻦ‪)_ lt __ .‬اﻟﻨﻔ ﺲ ‪ ،‬أﺧﺮى(‬
‫= ** )‪= 14‬‬ ‫اﻟﻜﺎﺋﻦ ‪)le __ __.‬اﻟﻨﻔ ﺲ ‪ ،‬أﺧﺮى(‬
‫‪13)٪‬‬ ‫اﻟﻜﺎﺋﻦ ‪)gt __ __.‬اﻟﻨﻔ ﺲ ‪ ،‬أﺧﺮى(‬
‫اﻟﻜﺎﺋﻦ ‪)ge __ __.‬اﻟﻨﻔ ﺲ ‪ ،‬وﻏﻴﺮ ذﻟﻚ(‬
‫ﻛﺎﺋﻦ ‪ __.‬ﻣﻜﺎﻓ ﺊ __)ﻧﻔ ﺴﻴ ﺔ ‪ ،‬أﺧﺮى(‬
‫اﻟﻜﺎﺋﻦ ‪)ne __ __.‬اﻟﻨﻔ ﺲ ‪ ،‬أﺧﺮى(‬
‫ﺘﺤﻤﻴﻞ اﻟﺰاﺋﺪ< و =<ﻋﻮاﻣﻞﺗﺸﻐﻴﻞ ﻛﺎﺋﻨﺎ ت ﻓﺼﻞ اﻟﻄﻼ ب‪:‬‬

‫اﻟ‬
‫ﺗﻌﺮﻳﻒ __ ‪)__init‬اﻟﺬا ت ‪ ،‬اﻻﺳﻢ ‪،‬‬

‫)‪1‬ﻓﺌ ﺔ اﻟﻄﺎﻟ ﺐ‪2) :‬‬
‫ﺗﻴ ﺔ =اﻟﻌﻼﻣﺎ ت __ ‪def __gt‬‬
‫اﻟﻌﻼﻣﺎ ت(‪3) 4) :‬اﻟﻌﻼﻣﺎ ت اﻟﺬا‬
‫ﺳﻢ)‪)6‬اﻟﺬا ت ‪ ،‬أﺧﺮى(‪s2) :‬‬
‫‪def‬اﻻ)‪7‬‬
‫)‪)5‬اﻟﻨﻔ ﺲ ‪ ،‬أﺧﺮى(‪__le __= :‬‬
‫)‪14‬‬
‫‪s2 print‬‬
‫=<"(‪= "، s1‬‬
‫)‪s1s2‬‬
‫)‪<s216‬‬
‫‪= "،print‬‬
‫)‪s1 <s2‬‬
‫>‪(" s1‬‬
‫‪15)=print‬‬
‫‪s2 = "،‬‬
‫‪(" s1‬‬
‫=<>‪s1‬‬
‫=‬
‫)‪("Ravi"، 200) 13) print ("s1> s2 = "، s1> s2‬‬
‫‪other.marks‬‬
‫‪11) s1 = Student ("Durga"،‬‬ ‫‪s2‬ﺔ<)‪100) 12‬‬
‫ﺗﻴ‬
‫ﺬا‬
‫‪ Student‬اﻟ=‬
‫إرﺟﺎع اﻟﻌﻼﻣﺎ ت‬
‫)‪8) 9) 10) print ("10> 20 ="، 10> 20‬‬

‫ﺗﻴ ﺔ ‪<= other.marks‬‬
‫إرﺟﺎع اﻟﻌﻼﻣﺎ ت اﻟﺬا‬
‫ﺘﺎج |‬
‫اﻧ‬
‫= ‪10> 20‬ﺧﻄﺄ‬
‫= ‪s1> s2‬ﺧﻄﺄ‬
‫= ‪ s1 <s2‬ﺻﺤﻴﺢ‬
‫= ‪ s1 <= s2‬ﺻﺤﻴﺢ‬
‫= ‪s1> = s2‬ﺧﻄﺄ‬
‫ﺑﺮﻧﺎﻣﺞ ﻟﺰﻳﺎدةﺗﺤﻤﻴﻞ ﻣﺸﻐﻞ اﻟﻀﺮ ب ﻟﻠﻌﻤﻞ ﻋﲆ ﻛﺎﺋﻨﺎ ت اﻟﻤﻮﻇﻒ‪:‬‬
‫ﺗﻌﺮﻳﻒ __ ‪)__init‬اﻟﺬا ت ‪ ،‬اﻻﺳﻢ ‪،‬‬

‫)‪1‬ﻓﺌ ﺔ اﻟﻤﻮﻇﻒ‪2) :‬‬
‫ﺗﺐ‬
‫ﺗ ﺐ(‪3) self.name = :‬اﻻﺳﻢ = ‪4) self.salary‬اﻟﺮا‬
‫اﻟﺮا‬
‫‪5) def __mul __ (self ،7)other):‬إرﺟﺎع * ‪self.salary‬‬
‫أﺧﺮى‪ .‬أﻳﺎم‬
‫)‪6‬‬
‫‪64‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫= ‪days): 10) self.name = name 11) 12) 13) e‬‬

‫‪8) class TimeSheet: 9) def __init __ (self، name،‬‬
‫‪500) 14) te=*TimeSheet‬‬
‫ﺬا اﻟﺸﻬﺮ‪t) ، ":‬‬
‫‪('Durga'،‬‬
‫ﺗﺐ ﻫ‬‫)‪(" 25‬را‬
‫ﺒﺎﻋ ﺔ‬
‫)‪15‬‬
‫‪('Durga'،‬ﻃ‬
‫اﻟﻤﻮﻇﻒ‬
‫= ‪self.days‬أﻳﺎم‬
‫ﺗ ﺐ ﻫﺬا اﻟﺸﻬﺮ‪12500 :‬‬

‫اﻟﻤﺨﺮﺟﺎ ت‪ :‬اﻟﺮا‬
‫ﺘﺤﻤﻴﻞ اﻟﺰاﺋﺪ‪:‬‬
‫ﺑﺸﻜﻞ زاﺋﺪ‪.‬‬‫ﺒﺎرة ﻋﻦ ﻃﺮق ﻣﺤﻤﻠ ﺔ‬ ‫ﺘﻠ ًﻔﺎ ﻣﻦ اﻟﻮﺳﻴﻄﺎ ت ‪ ،‬ﻓ‬
‫ُﻴﻘﺎل إن ﻫﺬه اﻟﻄﺮق ﻋ‬ ‫ﺘﺎن ﻟﻬﻤﺎ ﻧﻔ ﺲ اﻻﺳﻢ وﻟﻜﻦ ﻧﻮﻋً ﺎ ﻣﺨ‬
‫•إذا ﻛﺎﻧ ﺖ ﻫﻨﺎك ﻃﺮﻳﻘ‬
‫ﺜﺎل‪m1 (int a) :‬‬

‫ﻋﲆﺳ‬
‫م ‪)1‬ﻣﺰدوج د(‬
‫ﺘﺤﻤﻴﻞ اﻟﺰاﺋﺪ‪.‬‬
‫•ﻟﻜﻦ ﻓ ﻲ ﻃﺮﻳﻘ ﺔ ‪Python ،‬ﻻﻳﻤﻜﻦ اﻟ‬
‫ﺋﻤﺎ ﻓ ﻲ اﻟﻄﺮﻳﻘ ﺔ اﻷﺧﻴﺮة ﻓﻘﻂ‪.‬‬

‫ﺘﻨﻈﺮ ‪Python‬دا ً‬
‫ﺘﻠﻒ ﻣﻦ اﻟﻮﺳﻴﻄﺎ ت ‪ ،‬ﻓ ﺴ‬
‫ﺑﻨﻔ ﺲ اﻻﺳﻢ وﻋﺪد ﻣﺨ‬‫ﺘﻌﺪدة‬
‫•إذا ﻛﻨﺎ ﻧﺤﺎول اﻹﻋﻼن ﻋﻦ ﻃﺮق ﻣ‬
‫ﺒ ﻲ‪:‬‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪('one-arg method') 6) def m1 :‬‬

‫ﺘ‬‫)‪1‬اﺧ‬
‫‪arg method') 4) def m1 (self، a): 5) print‬‬
‫ب(‪:‬‬ ‫)‪(10‬أ ‪،‬‬
‫‪t.m1‬‬ ‫)‪ 12‬ﺲ ‪،‬‬
‫‪ t.m1‬اﻟﻨﻔ‬
‫‪)2) def‬‬ ‫‪m1 (self):‬‬
‫)‪(10،20‬‬ ‫ﺒﺎر‬
‫ﺘ‬ ‫)‪3)7‬‬
‫اﻻﺧ‬ ‫‪print‬‬
‫‪8) 9)('no-‬‬
‫=‪t‬‬
‫‪() 10) # t.m1 () 11) #‬‬
‫ﺛﻨﺎﺋﻴ ﺔ اﻟﺤﺠﺞ"(‬‫ﺒﺎﻋ ﺔ )"ﻃﺮﻳﻘ ﺔ‬

‫ﻃ‬
‫ﺛﻨﺎﺋﻴ ﺔ اﻟﺤﺠﺞ‬‫اﻹﺧﺮاج‪ :‬ﻃﺮﻳﻘ ﺔ‬
‫ﺜﻮن ﻓﻘﻂ ﻓ ﻲ اﻟﻄﺮﻳﻘ ﺔ اﻷﺧﻴﺮة‪.‬‬

‫ﺑﻴ‬‫ﺘﻨﻈﺮ‬
‫ﺒﺮﻧﺎﻣﺞ أﻋﻼه ‪،‬ﺳ‬
‫ﻓ ﻲ اﻟ‬
‫ﺜﻮن‪:‬‬
‫ﺑﺎﻳ‬‫ﺘﺤﻤﻴﻞ اﻟﺰاﺋﺪ ﻓ ﻲ‬
‫ﺒﺎ ت ﻃﺮﻳﻘ ﺔ اﻟ‬
‫ﺘﻄﻠ‬
‫ﺘﻌﺎﻣﻞ ﻣﻊ ﻣ‬
‫ﻛﻴﻒﻳﻤﻜﻨﻨﺎ اﻟ‬
‫ﺘﻐﻴﺮ ﻣﻦ أﺳﺎﻟﻴ ﺐ‬
‫ﺘﺮاﺿﻴ ﺔ أو ﻣﻊ ﻋﺪد ﻣ‬
‫ﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻮﺳﻴﻄﺎ ت اﻻﻓ‬
‫ﺑ ﺔ ‪ ،‬ﻓﻴﻤﻜﻨﻨﺎ اﻟ‬
‫ﺘﻐﻴﺮ ﻣﻦ اﻟﻮﺳﺎﺋﻂ ﻣﻄﻠﻮ‬
‫ﻓ ﻲ ﻣﻌﻈﻢ اﻷﺣﻴﺎن ‪ ،‬إذا ﻛﺎﻧ ﺖ اﻟﻄﺮﻳﻘ ﺔ ﻣﻊ ﻋﺪد ﻣ‬
‫اﻟﻮﺳﻴﻄﺎ ت‪.‬‬

‫‪65‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﺮاﺿﻴ ﺔ‪:‬‬
‫ﺑﺎﻟﺤﺠﺞ اﻻﻓ‬‫ﺒﻲ‬
‫ﺒﺎر اﻟﺼﻨﻒ ‪print ('The Sum of 3 Numbers:'، a + b + c) 5) elif a ! = :‬‬

‫ﺘ‬‫)‪1‬اﺧ‬
‫ﺑﻼ‪6) :‬‬
‫ﺑﻼ و ب! =‬
‫)‪2) def sum (self، a = None، b = None، c = None): 3) 4‬‬
‫ﺛﻼ ث'(‬‫ﺘﻴﻦ أو‬
‫ُﺮﺟﻰﺗﻘﺪﻳﻢ وﺳﻴﻄ‬ ‫ﺑﻼ‪7):‬آﺧﺮ‪8) :‬ﻃ‬
‫ﺒﺎﻋ ﺔ )'ﻳ‬ ‫‪= +‬ب(‬
‫ﺑﻼ‪ ،‬أو ج!‬‫ﺑﻼ و ب! =‬
‫رﻗﻤﻴﻦ‪':‬‬ ‫ﻛﺎن أ! =‬
‫ﻣﺠﻤﻮع‬ ‫ﺒﺎﻋ ﺔإذا '(‬
‫ﻃ‬
‫ﺒﺎر )‪() 10) t.sum (10،20) 11) t.sum (10،20،30) 12) t.sum (10‬‬
‫ﺘ‬‫= ‪9) t‬اﺧ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﻣﺠﻤﻮع ﻋﺪدﻳﻦ‪30 :‬‬
‫ﻣﺠﻤﻮع ‪3‬أﻋﺪاد‪60 :‬‬
‫ﺛﻼ ث ﺣﺠﺞ‬‫ﺘﻴﻦ أو‬

‫ﻳﺮﺟﻰﺗﻘﺪﻳﻢ ﺣﺠ‬
‫ﺘﻐﻴﺮ ﻣﻦ اﻟﺤﺠﺞ‪:‬‬
‫ﺒ ﻲ ﻣﻊ ﻋﺪد ﻣ‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪t.sum () :‬‬ ‫ﺘ‬ ‫)‪1‬اﺧ‬

‫)‪11) t.sum (10) 12‬‬
‫‪Test‬‬
‫)‪10‬‬‫‪() t.sum‬‬
‫‪9) t.sum‬‬ ‫)‪(10،20،30‬‬
‫) ‪(10،20‬‬
‫‪(self،‬‬
‫)‪for x*ina):a:3‬‬‫‪5)total‬‬
‫)‪6) 7) =8)0t4‬‬
‫=‬
‫)‪2‬‬
‫ﺒﺎﻋ ﺔ‬‫‪def‬اﻟﻄ‬ ‫= ‪sum‬‬
‫اﻟﻤﺠﻤﻮع ‪+ x‬‬ ‫اﻟﻤﺠﻤﻮع‬
‫"(اﻟﻤﺠﻤﻮع‪ ، ":‬اﻹﺟﻤﺎﻟ ﻲ(‬
‫)‪3‬اﻟﺤﻤﻮﻟ ﺔ اﻟﺰاﺋﺪة ﻟﻠﻤﻨﺸ ﺊ‪:‬‬

‫ﺘﺤﻤﻴﻞ اﻟﺰاﺋﺪ ﻟﻠﻤﻨﺸ ﺊ ﻏﻴﺮ ﻣﻤﻜﻦ ﻓ ﻲ ‪Python.‬‬
‫اﻟ‬
‫ﺒﺎر اﻟﻤﻨﺸ ﺊ اﻷﺧﻴﺮ‪.‬‬

‫إذا ﺣﺪدﻧﺎ ﻋﺪة ﻣﻨﺸﺌﺎ ت ‪ ،‬ﻓ ﺴﻴ‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪__init __ (self): 3) 4) :‬‬

‫ﺘ‬‫)‪1‬اﺧ‬
‫‪2) def‬‬
‫ﺒﺎﻋ ﺔ )"‪("No-Arg Constructor‬‬
‫ﻃ‬
‫‪66‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫= ‪constructor') 10) # t1 = Test () 11) # t1‬‬

‫)‪__init __ (self، a، b): 9‬‬ ‫‪print‬‬
‫أرﺟﻞ"(‬ ‫‪('Two-‬واﺣﺪ‬
‫‪ُ Arg‬‬
‫)"ﻣﻨﺸ ﺊ‬ ‫ﺒﺎﻋ ﺔ‬
‫ﻃ‬
‫‪5) def __init __ (self، a): 6) 7) 8) def‬‬
‫ﺒﺎر )‪(10،20‬‬
‫ﺘ‬‫ﺒﺎر = ‪(10) 12) t1‬اﺧ‬
‫ﺘ‬‫اﺧ‬
‫ﺛﻨﺎﺋ ﻲ اﻷرﺟﻞ‬‫اﻹﺧﺮاج‪ُ:‬ﻣﻨﺸ ﺊ‬
‫ﺘﻮﻓﺮﺳﻮى ‪Two-Arg Constructor.‬‬

‫ﺒﺮﻧﺎﻣﺞ أﻋﻼه ‪ ،‬ﻻﻳ‬
‫•ﻓ ﻲ اﻟ‬
‫ﺘﺮاﺿﻴ ﺔ و‬
‫ﺑﺤﺠﺞ اﻓ‬‫اﻟﻤﻨﺸ ﺊ‬
‫ﺗﻨﺎ ‪،‬ﻳﻤﻜﻨﻨﺎ أن ﻧﻌﻠﻦ ﻋﻦ ُ‬
‫ﺒﺎ‬
‫ﺘﻄﻠ‬
‫ﺑﻨﺎ ًء ﻋﲆ ﻣ‬‫•وﻟﻜﻦ‬
‫ﺘﻐﻴﺮ ﻣﻦ اﻟﺤﺠﺞ‪.‬‬
‫ﻋﺪد ﻣ‬
‫اﻟﻤﻨﺸ ﺊ ﻣﻊ اﻟﻮﺳﻴﻄﺎ ت اﻻﻓ‬
‫ُ‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪with 0 | 1 | 2 | 3 number ofuments') 4) 5) t1 = :‬‬

‫ﺘ‬‫)‪1‬اﺧ‬
‫‪__init __ (self، a = None، b = None، c = None): 3) print ('Constructor‬‬
‫ﺒﺎر‬
‫ﺘ‬‫ﺒﺎر = ‪(10،20) 8) t4‬اﺧ‬
‫ﺘ‬‫ﺒﺎر = ‪(10) 7) t3‬اﺧ‬
‫ﺘ‬‫ﺒﺎر = ‪() 6) t2‬اﺧ‬
‫ﺘ‬‫‪2) def‬اﺧ‬
‫)‪(10،20،30‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ُﻣﻨﺸ ﺊ ﻣﻊ ﻋﺪد ‪0 | 1 | 2 | 3‬ﻣﻦ اﻟﻮﺳﻴﻄﺎ ت‬
‫ﺘﻐﻴﺮ ﻣﻦ اﻟﺤﺠﺞ‪:‬‬
‫اﻟﻤﻨﺸ ﺊ ﻣﻊ ﻋﺪد ﻣ‬
‫ُ‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪(10،20،30) 9) t5 = :‬‬‫ﺘ‬‫)‪1‬اﺧ‬

‫‪7) t3 = Test (10،20) 8) t4 = Test‬‬
‫)‪4) 5) t1 = Test () 6) t2 = Test (10‬‬ ‫ﺘﻐﻴﺮ ﻣﻦ اﻟﻮﺳﺎﺋﻂ"(‬
‫)"ﻣﻨﺸ ﺊ ﻣﻊ ﻋﺪد ﻣ‬
‫‪ُ print‬‬
‫)‪2) def __init __ (self، * a): 3‬‬
‫ﺒﺎر )‪(10،20،30،40،50،60‬‬ ‫ﺘ‬‫اﺧ‬
‫‪67‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫ﺘﻐﻴﺮ ﻣﻦ اﻟﻮﺳﺎﺋﻂ‬
‫ﻣﻨﺸ ﺊ ﻣﻊ ﻋﺪد ﻣ‬
‫ﺗﺠﺎوز‬
‫)‪3‬‬
‫ﺘﺠﺎوز‬
‫أﺳﻠﻮ ب اﻟ‬
‫ﺘﺮاﺿ ًﻴﺎ ﻟﻠﻔﺌ ﺔ اﻟﻔﺮﻋﻴ ﺔ ﻣﻦ ﺧﻼل اﻟﻤﻴﺮا ث‪ .‬إذا ﻟﻢﺗﻜﻦ اﻟﻔﺌ ﺔ اﻟﻔﺮﻋﻴ ﺔ راﺿﻴ ﺔ ﻋﻦ‬
‫ﺣﺎ اﻓ‬
‫ﺘﺎ ً‬
‫ﺘﺎح ﻣﻦ أي وﻗ ﺖ ﻣﻀﻰ اﻷﻋﻀﺎء ﻓ ﻲ ﻓﺌ ﺔ اﻷﺻﻞ ﻣ‬
‫ﻣﺎ ﻫﻮ ﻣ‬
‫ﺘﺠﺎوز‪.‬‬
‫ﺗﻬﺎ‪ .‬ﻫﺬا اﻟﻤﻔﻬﻮمﻳ ﺴﻤﻰ اﻟ‬
‫ﺒﺎ‬
‫ﺘﻄﻠ‬
‫ﺑﻨﺎ ًء ﻋﲆ ﻣ‬‫ﺑﺈﻋﺎدةﺗﻌﺮﻳﻒﺗﻠﻚ اﻟﻄﺮﻳﻘ ﺔ ﻓ ﻲ اﻟﻔﺼﻞ اﻟﻔﺮﻋ ﻲ‬‫ُﻴ ﺴﻤﺢ ﻟﻠﻔﺌ ﺔ اﻟﻔﺮﻋﻴ ﺔ‬
‫ﺋﻴ ﺴ ﻲ ‪ ،‬ﻓ‬
‫ﺒﻴﻖ اﻟﻔﺼﻞ اﻟﺮ‬
‫ﺗﻄ‬
‫ﺒﻖ ﻟﻜﻞ ﻣﻦ اﻟﻄﺮق واﻟﻤﻨﺸﺌﺎ ت‪.‬‬

‫ﺒ ﺔ اﻟﻤﻄ‬
‫ﻣﻔﻬﻮم اﻟﻐﻠ‬
‫ﺘﺠﺎوز اﻟﻄﺮﻳﻘ ﺔ‪:‬‬

‫ﺒ ﻲﻟ‬
‫)‪1‬ﻓﺌ ﺔ ‪P: 2) def‬ﺧﺎﺻﻴ ﺔ ‪() 12) c.marry ():‬‬

‫‪Kaif') 9) 10) c = C () 11) c.property‬‬
‫‪5)7)print‬‬
‫‪def marry‬‬ ‫‪(self): 8) print‬‬
‫)'‪('Appalamma‬‬ ‫‪('Katrina‬‬
‫‪6) class‬‬ ‫‪C (P) :‬‬
‫‪+ Cash + Power') 4) def marry (self):‬‬
‫‪(self): 3) print ('Gold + Land‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ذ ﻫ ﺐ ‪+‬أرض ‪+‬ﻧﻘﺪ ‪+‬ﻗﻮة‬
‫ﺗﺮﻳﻨﺎ ﻛﻴﻒ‬
‫ﻛﺎ‬
‫ﺘﺨﺪام ﻃﺮﻳﻘ ﺔ ‪super ().‬‬

‫ﺑﺎﺳ‬ ‫ﺘﺪﻋﺎء ﻃﺮﻳﻘ ﺔ ﻓﺌ ﺔ اﻷﺻﻞ أ ً‬
‫ﻳﻀﺎ‬ ‫ﻣﻦ ﻃﺮﻳﻘ ﺔﺗﺠﺎوز ﻓﺌ ﺔ اﻟﻄﻔﻞ ‪،‬ﻳﻤﻜﻨﻨﺎ اﺳ‬
‫ﺒﺎﻋ ﺔ‬
‫)‪1‬ﻓﺌ ﺔ )‪P: 2‬ﺧﺎﺻﻴ ﺔ )‪def (self): 3‬ﻃ‬
‫)'‪('Gold + Land + Cash + Power‬‬
‫‪68‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫)( ‪c = C () 12) c.property () 13) c.marry‬‬

‫‪marry‬‬
‫)‪C (P):() 7‬‬
‫‪9) def‬‬
‫‪print‬‬ ‫‪('Katrina‬‬
‫‪marry‬‬ ‫)'‪Kaif‬‬
‫‪(self):‬‬ ‫)‪10) 11‬‬
‫‪8) super‬‬ ‫‪().‬‬
‫‪(self): 5) print ('Appalamma') 6) class‬‬
‫‪4) def marry‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ذ ﻫ ﺐ ‪+‬أرض ‪+‬ﻧﻘﺪ ‪+‬ﻗﻮة‬
‫ﺑﺎﻻﻣﺎ‬
‫أ‬
‫ﺗﺮﻳﻨﺎ ﻛﻴﻒ‬
‫ﻛﺎ‬
‫ﺘﺠﺎوز اﻟﻤﻨﺸ ﺊ‪:‬‬

‫ﺒ ﻲﻟ‬
‫)‪1‬اﻟﻔﺌ ﺔ )( ‪__ (self): 7) 8) 9) c = C‬‬

‫‪3) 4) 5) class C (P): 6) def __init‬‬
‫‪P: 2) def __init‬‬
‫‪print__("Parent‬‬
‫)"‪(self): Constructor‬‬
‫ﺒﺎﻋ ﺔ )"‪("Child Constructor‬‬

‫ﻃ‬
‫اﻹﺧﺮاج‪ :‬ﻣﻨﺸ ﺊ اﻟﻄﻔﻞ‬

‫ﺘﻢﺗﻨﻔﻴﺬُﻣﻨﺸ ﺊ اﻟﻔﺌ ﺔ اﻷﺻﻞ‬
‫ﺘﻮي ﻋﲆُﻣﻨﺸ ﺊ ‪ ،‬ﻓ ﺴﻴ‬
‫ﺜﺎل أﻋﻼه ‪ ،‬إذا ﻛﺎﻧ ﺖ اﻟﻔﺌ ﺔ اﻟﻔﺮﻋﻴ ﺔ ﻻﺗﺤ‬
‫ﺘﺨﺪام ﻃﺮﻳﻘ ﺔ ‪super ().‬‬

‫ﺑﺎﺳ‬‫ﺘﺪﻋﺎءُﻣﻨﺸ ﺊ اﻟﺼﻨﻒ اﻷﺻﻞ‬
‫ﻣﻦُﻣ ﺼﻨﱢﻊ اﻟﻔﺌ ﺔ اﻟﻔﺮﻋﻴ ﺔﻳﻤﻜﻨﻨﺎ اﺳ‬
‫ﺘﺨﺪام ‪super ():‬‬

‫ﺑﺎﺳ‬
‫ﺑـ ‪Parent Class Constructor‬‬‫ﺗﺼﺎل‬
‫ﺒ ﻲ ﻟﻼ‬
‫)‪(Person): 7) def __init __ (self، name، age، eno، esal ): 8‬‬

‫‪name، age): 3) self.name = name 4) 5) 6) class Employee‬‬
‫ﺑﺮ __‪() .‬اﻟﺤﺮف اﻷول __‬
‫‪1) class Person: 2) def __init‬ﺳﻮ‬
‫واﻟﻌﻤﺮ(‬
‫‪__ (self،‬‬
‫)اﻻﺳﻢ‬
‫ﺗ ﻲ =اﻟﻌﻤﺮ‬
‫اﻟﻌﻤﺮ اﻟﺬا‬

‫‪69‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
self.eno'،=self.eno)
Number: eno 16) ‫ﻋﺮض‬9) 10) 11) 12)
self.esal
('Employee = esal
Age:'، self.age) 15) print ('Employee
13) print ('Employee Name:'، self.name) 14) print
self.esal) 17) 18) e1 = :‫ﺗ ﺐ اﻟﻤﻮﻇﻒ‬
‫ﺒﻊ '(را‬
‫اﻃ‬def (self):
48،872425،26000)
39،872426،36000)19)
21)e1.display
e2.display() ()20) e2 = ('‫اﻟﻤﻮﻇﻒ‬
‫اﻟﻤﻮﻇﻒ‬ Durga،'،
('Sunny'،
| ‫ﺘﺎج‬
‫اﻧ‬
‫ دورﺟﺎ‬:‫اﺳﻢ اﻟﻤﻮﻇﻒ‬
48 :‫ﻋﻤﺮ اﻟﻤﻮﻇﻒ‬
٨٧٢٤٢٥ :‫رﻗﻢ اﻟﻤﻮﻇﻒ‬
26000 :‫ﺗ ﺐ اﻟﻤﻮﻇﻒ‬
‫را‬
‫ ﺻﻨ ﻲ‬:‫اﺳﻢ اﻟﻤﻮﻇﻒ‬
39 :‫ﻋﻤﺮ اﻟﻤﻮﻇﻒ‬
٨٧٢٤٢٦ :‫رﻗﻢ اﻟﻤﻮﻇﻒ‬
36000 :‫ﺗ ﺐ اﻟﻤﻮﻇﻒ‬
‫را‬
70
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﺑ ﺲ‬ ‫ُ‬
‫أوو‬
‫اﻟﺠﺰء ‪- 4‬‬
‫‪71‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺟﺪول أﻋﻤﺎل‬
‫)‪1‬ﻃﺮﻳﻘ ﺔ ﻣﺠﺮدة‬
‫)‪2‬ﻓﺌ ﺔ اﻟﻤﻠﺨﺺ‬
‫)‪3‬اﻟﻮاﺟﻬ ﺔ‬
‫)‪4‬اﻷﻋﻀﺎء اﻟﻌﺎم واﻟﺨﺎص واﻟﻤﺤﻤ ﻲ‬
‫)( __ ‪5) __str‬اﻟﻄﺮﻳﻘ ﺔ‬
‫ﺘﻴﻦ )( ‪str‬و )( ‪repr‬‬ ‫ﺑﻴﻦ اﻟﺪاﻟ‬‫)‪6‬اﻟﻔﺮق‬
‫ﺒﻴﻖ اﻟﺨﺪﻣﺎ ت اﻟﻤﺼﺮﻓﻴ ﺔ اﻟﺼﻐﻴﺮة‬
‫ﺗﻄ‬‫)‪7‬‬
‫ﻃﺮﻳﻘ ﺔ ﻣﺠﺮدة‪:‬‬
‫ﺑﺎﻷﺳﺎﻟﻴ ﺐ اﻟﻤﺠﺮدة ‪ ،‬واﻟﻄﺮﻳﻘ ﺔ اﻟﻤﺠﺮدة‬‫ﺑﺈﻣﻜﺎﻧﻨﺎ اﻹﻋﻼن ﻋﻦ ﻃﺮﻳﻘ ﺔ‪.‬ﺗ ﺴﻤﻰ ﻫﺬه اﻷﻧﻮاع ﻣﻦ اﻷﺳﺎﻟﻴ ﺐ‬ ‫ﺑﻌﺾ اﻷﺣﻴﺎن ﻻ ﻧﻌﺮف ﺷﻴ ًﺌﺎ ﻋﻦ اﻟ‬
‫ﺘﻨﻔﻴﺬ ‪ ،‬ﻻﻳﺰال‬ ‫•ﻓ ﻲ‬
‫ﻟﻬﺎﺗﺼﺮﻳﺢ ﻓﻘﻂ وﻟﻜﻦ ﻟﻴ ﺲﺗﻨﻔﻴ ً‬
‫ﺬا‪.‬‬
‫ﺘﺨﺪام‪decorator as dohtemtcartsba‬‬
‫ﺑﺎﺳ‬‫ﺜﻮنﻳﻤﻜﻨﻨﺎ أن ﻧﻌﻠﻦ ﻋﻦ ﻃﺮﻳﻘ ﺔ ﻣﺠﺮدة‬
‫ﺑﻴ‬‫•ﻓ ﻲ‬
‫ﺒﻊ‪.‬‬
‫ﺘ‬‫ﻳ‬
‫_ ‪abstractmethod‬‬
‫ﺗ ﻲ(‪:‬ﺗﻤﺮﻳﺮ‬
‫‪)• def m1‬ذا‬
‫ﺛﻢﻳﺠ ﺐ ﻋﻠﻴﻨﺎ إﻟﺰاﻣ ﻲ‬‫‪•abstractmethod decorator‬ﻣﻮﺟﻮد ﻓ ﻲ وﺣﺪة ‪abc.‬وﻣﻦ‬

‫ﺘﻴﺮاد وﺣﺪة ‪abc ،‬وإﻻ ﻓﺈﻧﻨﺎﺳﻮفﺗﺤﺼﻞ ﻋﲆ ﺧﻄﺄ‪.‬‬
‫اﺳ‬
‫‪• abc‬وﺣﺪة ﻓﺌ ﺔ أﺳﺎﺳﻴ ﺔ ﻣﺠﺮدة‬
‫ﺒﺎر اﻟﺼﻨﻒ ‪def m1 (self): 4) :‬‬

‫ﺘ‬‫)‪1‬اﺧ‬
‫)‪2) abstractmethod 3‬‬
‫ﻳﻤﺮ‬
‫‪NameError:‬اﻻﺳﻢ "‪"abstractmethod‬ﻏﻴﺮ ﻣﺤﺪد‬
‫ﺜﺎل‪:‬‬
‫ﻋﲆﺳ‬
‫*‬
‫)‪1‬ﻣﻦ )‪4) def m1 (self): 5‬‬
‫‪2) class Test: 3) abstractmethod‬‬
‫‪abc import‬‬
‫ﻳﻤﺮ‬
‫‪72‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺜﺎل‪:‬‬
‫ﻋﲆﺳ‬
‫*‬
‫)‪1‬ﻣﻦ ‪3) abstractmethod 4) def‬‬
‫‪abc import 2) class Fruit:‬اﻟﺬوق‬
‫)‪(self): 5‬‬
‫ﻳﻤﺮ‬
‫ﺘﻨﻔﻴﺬ ﻟﻠﻄﺮق اﻟﻤﺠﺮدة ﻟﻠﻔﺌ ﺔ اﻷﺻﻠﻴ ﺔ‪.‬‬

‫ﺒﺮ اﻟﻔﺼﻮل اﻟﻔﺮﻋﻴ ﺔ ﻣ ﺴﺆوﻟ ﺔ ﻋﻦﺗﻮﻓﻴﺮ اﻟ‬
‫ﻓﺌ ﺔ اﻟﻤﻠﺨﺺ‪:‬‬
‫ﺘﻘﺎق ﻛﻞ ﻓﺌ ﺔ ﻣﺠﺮدة ﻓ ﻲ‬
‫ﺋ ﻲ ﻓﺌﺎ ت ﻣﺠﺮدة‪.‬ﻳﺠ ﺐ اﺷ‬
‫ﺘﻨﻔﻴﺬ اﻟﺠﺰ‬
‫ُﻄﻠﻖ ﻋﲆ ﻫﺬا اﻟﻨﻮع ﻣﻦ ﻓﺌﺎ ت اﻟ‬
‫ﺘﻤﻞﺗﻨﻔﻴﺬ ﻓﺌ ﺔ ﻣﺎ ‪،‬ﻳ‬
‫ﺑﻌﺾ اﻷﺣﻴﺎن ﻻﻳﻜ‬‫ﻓﻲ‬
‫‪Python‬ﻣﻦ ﻓﺌ ﺔ ‪ABC‬اﻟﻤﻮﺟﻮدة ﻓ ﻲ وﺣﺪة ‪abc.‬‬
‫ﺣﺎﻟ ﺔ ‪1:‬‬
‫*‬
‫)‪1‬ﻣﻦ )( ‪pass 4) 5) t = Test‬‬
‫)‪import 2) class Test: 3‬‬
‫‪abc‬‬
‫ﺘﻮي ﻋﲆ أي ﻃﺮﻳﻘ ﺔ ﻣﺠﺮدة‪.‬‬

‫ﺒﺎر ‪b'z ،‬و ﻫ ﻲ ﻓﺌ ﺔ ﻣﺤﺪدة وﻻﺗﺤ‬
‫ﺘ‬‫ﻓ ﻲ اﻟﻜﻮد أﻋﻼه ‪،‬ﻳﻤﻜﻨﻨﺎ إﻧﺸﺎء ﻛﺎﺋﻦ ﻟﻔﺌ ﺔ اﻻﺧ‬
‫اﻟﺤﺎﻟ ﺔ ‪2:‬‬
‫*‬
‫)‪1‬ﻣﻦ )( ‪pass 4) 5) t = Test‬‬
‫)‪2) class Test (ABC): 3‬‬
‫ﺘﻮي ‪b'z‬ﻋﲆ أي ﻃﺮﻳﻘ ﺔ ﻣﺠﺮدة‪.‬‬

‫ﺘﻖ ﻣﻦ ﻓﺌ ﺔ ‪ABC ،‬ﻻﻳﺤ‬
‫ﺘﻰ أﻧﻪ ﻣﺸ‬
‫ﻓ ﻲ اﻟﻜﻮد أﻋﻼهﻳﻤﻜﻨﻨﺎ إﻧﺸﺎء ﻛﺎﺋﻦ ‪ ،‬ﺣ‬
‫*‬
‫)‪1‬ﻣﻦ )‪4) def m1 (self): 5‬‬
‫‪Test (ABC): 3) abstractmethod‬‬
‫‪abc import 2) class‬‬
‫ﻳﻤﺮ‬
‫‪73‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺒﺎر‬
‫ﺘ‬‫)‪6) 7‬ر =اﺧ‬
‫)(‬
‫ﺘﺨﺪام أﺳﺎﻟﻴ ﺐ ﻣﺠﺮدة ‪m1‬‬

‫ﺑﺎﺳ‬‫ﺒﺎر ﻓﺌ ﺔ ﻣﺠﺮدة‬
‫ﺘ‬‫ﺜﻴﻞ اﺧ‬
‫‪TypeError:‬ﻻﻳﻤﻜﻦ إﻧﺸﺎء ﻣ‬
‫*‬
‫)‪1‬ﻣﻦ )( ‪5) pass 6) 7) t = Test‬‬
‫‪abstractmethod 4) def m1 (self):‬‬
‫)‪abc import 2) class Test: 3‬‬
‫ﺘﻮﺳﻴﻊ ﻓﺌ ﺔ ‪ABC.‬‬
‫ﺑ‬‫ﺘﻮي ﻋﲆ ﻃﺮﻳﻘ ﺔ ﻣﺠﺮدة ‪b'z‬ﻧﺤﻦ ﻻ ﻧﻘﻮم‬
‫ﺘﻰ ﻓﺌ ﺔﺗﺤ‬
‫ﻳﻤﻜﻨﻨﺎ إﻧﺸﺎء ﻛﺎﺋﻦ ﺣ‬
‫*‬
‫)‪1‬ﻣﻦ )( ‪6) 7) t = Test () 8) t.m1‬‬
‫)'‪4) def m1 (self): 5) print ('Hello‬‬
‫‪2) class Test: 3) abstractmethod‬‬
‫ﺒﺎ‬
‫اﻹﺧﺮاج‪ :‬ﻣﺮﺣ ً‬
‫ﺜﻴﻞ ﻣﻤﻜﻨًﺎ‪.‬‬
‫ﺘﻮﺳﻴﻊ ﻓﺌ ﺔ ‪ABC ،‬ﻓﻠﻦﻳﻜﻮن إﻧﺸﺎء ﻣ‬
‫ﺑ‬‫ﺘﻮى اﻟﻔﺼﻞ ﻋﲆ ﻃﺮﻳﻘ ﺔ ﻣﺠﺮدة واﺣﺪة ﻋﲆ اﻷﻗﻞ وإذا ﻛﻨﺎ ﻧﻘﻮم‬
‫اﻟﺨﻼﺻ ﺔ‪ :‬إذا اﺣ‬
‫ﺜﻴﻞ أﺳﻠﻮ ب ﻣﺠﺮدة ﻏﻴﺮ ﻣﻤﻜﻦ"‬

‫"ﻓﺌ ﺔ ﻣﺠﺮدة ﻣﻊ إﻧﺸﺎء ﻣ‬
‫ﺜﻴﻞ ﻓﺌ ﺔ اﻟﻄﻔﻞ‪ .‬إذا ﻟﻢ ﻧﻨﺸ ﺊ ﻛﺎﺋﻦ ﻓﺌ ﺔ ﻓﺮﻋﻴ ﺔ ﻓﻠﻦ‬

‫ﻳﺠ ﺐﺗﻨﻔﻴﺬ اﻷﺳﺎﻟﻴ ﺐ اﻟﻤﺠﺮدة ﻟﻔﺌ ﺔ اﻟﻮاﻟﺪﻳﻦ ﻓ ﻲ اﻟﻔﺼﻮل اﻟﻔﺮﻋﻴ ﺔ‪ .‬ﺧﻼف ذﻟﻚ ﻻﻳﻤﻜﻨﻨﺎ إﻧﺸﺎء ﻣ‬
‫ﻧﺤﺼﻞ ﻋﻠﻴﻪ‬
‫أي ﺧﻄﺄ‪.‬‬
‫ﺣﺎﻟ ﺔ ‪1:‬‬
‫*‬
‫)‪1‬ﻣﻦ ‪(ABC): 3) abstractmethod‬‬
‫‪abc import 2) class Vehicle‬‬
‫‪74‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺗ ﻲ(‪5) 6) :‬‬
‫‪)4) def noofwheels‬ذا‬
‫ﻳﻤﺮ‬
‫ﺒ ﺔ(‪:‬ﺗﻤﺮ‬
‫)‪7‬ﺣﺎﻓﻼ ت ﻓﺌ ﺔ )ﻣﺮﻛ‬
‫إﻧﻪ ﺻﺎﻟﺢﻷﻧﻨﺎ ﻻ ﻧﻨﺸ ﺊ ﻛﺎﺋﻦ ﻓﺌ ﺔ ﻓﺮﻋﻴ ﺔ‪.‬‬
‫*‬
‫)‪1‬ﻣﻦ )( ‪(Vehicle): pass 8) b = Bus‬‬
‫‪noofwheels (self): 5) 6) 7) class Bus‬‬
‫‪(ABC): 3) abstractmethod 4) def‬‬
‫‪abc import 2) class Vehicle‬‬
‫ﻳﻤﺮ‬
‫ﺜﻴﻞ ﻓﺌ ﺔ ﻣﺠﺮدة ‪Bus‬ﻣﻊ ‪noofwheels‬اﻷﺳﺎﻟﻴ ﺐ اﻟﻤﺠﺮدة‬

‫‪TypeError:‬ﻻﻳﻤﻜﻦ إﻧﺸﺎء ﻣ‬
‫ﺑﻬﺎ ‪ ،‬ﻓﺈن اﻟﻔﺌ ﺔ اﻟﻔﺮﻋﻴ ﺔﺗﻜﻮن أ ً‬

‫ﻳﻀﺎ ﻣﺠﺮدة وﻻﻳﻤﻜﻦ إﻧﺸﺎء‬ ‫ﺘﺠﺎوز اﻟﻄﺮﻳﻘ ﺔ اﻟﻤﺠﺮدة اﻟﺨﺎﺻ ﺔ‬
‫ﺘﻮﺳﻴﻊ ﻓﺌ ﺔ ‪abstract‬وﻟﻢ ﻧ‬
‫ﺑ‬‫ﻣﻼﺣﻈ ﺔ‪ :‬إذا ﻗﻤﻨﺎ‬
‫ﺜﻴﻞ ﻟﻬﺎ‪.‬‬
‫ﻣ‬
‫*‬
‫)‪1‬ﻣﻦ ) ‪noofwheels (self): 9) 10) 11‬‬
‫‪5) 6) 7) class Bus (Vehicle): 8) def‬‬
‫‪4) def noofwheels (self):‬‬
‫‪Vehicle (ABC): 3) abstractmethod‬‬
‫ﺒ ﺔ(‪:‬‬
‫اﻟﻔﺌ ﺔ ‪)Auto‬ﻣﺮﻛ‬
‫‪abc import 2) class‬ﻳﻤﺮ‬
‫‪() 18) print (a.noofwheels ()) # 3‬‬
‫‪(b.noofwheels ()) # 7 16) 17) a = Auto‬‬
‫‪13) return 3 14) b = Bus () 15) print‬‬
‫اﻟﻌﻮدة ‪7‬‬
‫‪12) def‬‬ ‫‪noofwheels (self):‬‬
‫ﺘﻮي ﻓﺌ ﺔ اﻟﻤﻠﺨﺺ ﻋﲆ ﻛﻞ ﻣﻦ اﻟﻄﺮق اﻟﻤﺠﺮدة وﻏﻴﺮ اﻟﻤﺠﺮدة أ ً‬

‫ﻳﻀﺎ‪.‬‬ ‫ﻣﻼﺣﻈ ﺔ‪:‬ﻳﻤﻜﻦ أنﺗﺤ‬
‫‪75‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
:‫ﺜﻮن‬
‫ﺑﺎﻳ‬‫واﺟﻬﺎ ت ﻓ ﻲ‬
.‫ﺒﺮ واﺟﻬ ﺔ‬
‫ﺘ‬‫ ﻓﺈن ﻫﺬا اﻟﻨﻮع ﻣﻦ ﻓﺌ ﺔ اﻟﻤﻠﺨﺺﻳﻌ‬، ‫ﺘﻮ ت ﻓﺌ ﺔ ﻣﺠﺮدة ﻋﲆ ﻃﺮق ﻣﺠﺮدة ﻓﻘﻂ‬
‫ إذا اﺣ‬، ‫ﺑﺸﻜﻞ ﻋﺎم‬
*
(ABC): 3) abstractmethod 4) def connect (self): pass 5) ‫ﻣﻦ‬1)
abc import 2) class DBInterface
connect (self): 11) print ('Connecting to Oracle Database ...') 12) def
7) def disconnect (self): pass 8) 9) class Oracle (DBInterface): 10) def
22) classname = globals () [dbname] 23) x = ‫ﻓﺼﻞ‬6) abstractmethod
Sybase Database ...') 20) 21) dbname = input ('Enter Database Name:')
Database ...') 18 ) def disconnect (self): 19) print ('Disconnecting to
(DBInterface): 16) def connect
13) print ('Disconnecting (self):Database
to Oracle 17) print ...')
('Connecting to Sybase
14) 15) class
() 24) x.connect () 25) x.disconnect () ‫ (اﺳﻢ اﻟﻔﺌ ﺔ‬self):

Oracle :‫ﺒﻴﺎﻧﺎ ت‬
‫أدﺧﻞ اﺳﻢ ﻗﺎﻋﺪة اﻟ‬
Oracle ... ‫ﺑﻴﺎﻧﺎ ت‬‫ﺑﻘﺎﻋﺪة‬‫ﺗﺼﺎل‬

‫ﺟﺎري اﻻ‬
Oracle ... ‫ﺑﻴﺎﻧﺎ ت‬‫ﺑﻘﺎﻋﺪة‬‫ﺗﺼﺎل‬
‫ﺟﺎري ﻗﻄﻊ اﻻ‬

Sybase :‫ﺒﻴﺎﻧﺎ ت‬
‫أدﺧﻞ اﺳﻢ ﻗﺎﻋﺪة اﻟ‬
Sybase ... ‫ﺑﻴﺎﻧﺎ ت‬‫ﺑﻘﺎﻋﺪة‬‫ﺗﺼﺎل‬
‫ﺟﺎري اﻻ‬
Sybase ... ‫ﺑﻴﺎﻧﺎ ت‬‫ﺑﻘﺎﻋﺪة‬‫ﺗﺼﺎل‬
‫ﺟﺎري ﻗﻄﻊ اﻻ‬
.‫ﺗﻌﻴﺪ اﺳﻢ اﻟﻔﺌ ﺔ‬

‫'إﱃ اﺳﻢ ﻓﺌ ﺔ و‬str' ‫ﺗﺤﻮل اﻟ ﺴﻠ ﺴﻠ ﺔ‬
globals () [str] ‫ اﻟﺪاﻟ ﺔ اﻟﻤﻀﻤﻨ ﺔ‬:‫ﻣﻼﺣﻈ ﺔ‬
76
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﻗﺮاءة اﺳﻢ اﻟﻔﺼﻞ ﻣﻦ اﻟﻤﻠﻒ‬-2: ‫ﺒ ﻲ‬

‫ﺘﺠﺮﻳ‬
‫اﻟ‬
config.txt
‫ﺑ ﺴﻮن‬
‫إ‬
test.py
*
(ABC): 3) abstractmethod 4) def printit (self، text): pass 5) ‫ﻣﻦ‬1)
abc import 2) class Printer
printit (self، text): 11) print ('Printing from EPSON Printer ...') 12)
7) def disconnect (self): pass 8) 9) class EPSON (Printer): 10) def
13) def disconnect (self): 14) print (‫ﺒﺎﻋ ﺔ )ﻧﺺ‬
‫ﻃ‬6) abstractmethod
HP (Printer): 17) def printit (self، text): 18) print ‫ﺒﺎﻋ ﺔ ﻋﲆ‬
‫ﺗﻢ اﻟﻄ‬
")
HP ...") 19) ‫ﺑﻌ ﺔ‬
‫ﺒﺎﻋ ﺔ ﻣﻦ ﻃﺎ‬
‫) "اﻟﻄ‬EPSON Printer ...") 15) 16) class
() ‫ﻋﲆ‬
28) ‫ﺔ‬x.printit
‫ﺒﺎﻋ‬
‫ﺘﻤﻠ'(ﺖ اﻟﻄ‬
‫)"اﻛﻛـ‬ ‫ﺒﺎﻋ ﺔ‬
‫ﻃ‬21) '،'
("config.txt :(‫ﻲ‬r ‫ﺗ‬
')‫ﺘﺢ)ذا‬
‫ﺗﺼﺎل‬
‫اﻻﻣﻊ ﻓ‬
HP‫ﻗﻄﻊ‬ 20)
...") 22)(‫)ﻧﺺ‬
23) ‫ﺒﺎﻋ ﺔ‬
‫ﺑﻌ‬ ‫ﻃ‬
‫ﻃﺎ‬
() 25) 26)() classname
x.disconnect .. .‫ﺘﻬﺎ‬ ‫ﻳﺠ=ﺐ ﻃ‬
‫ﺒﺎﻋ‬ globals ‫ﺬه)(اﻟ‬
‫ﺒﻴﺎﻧﺎ ت‬ [pname] 27) x ==classname
‫ ﻫ‬f: 24) pname f.readline
') 29)
:‫ﺘﺎج‬
‫اﻧ‬
EPSON ... ‫ﺑﻌ ﺔ‬
‫ﺒﺎﻋ ﺔ ﻣﻦ ﻃﺎ‬
‫اﻟﻄ‬
... ‫ﺒﻴﺎﻧﺎ ت‬
‫ﺒﺎﻋ ﺔ ﻫﺬه اﻟ‬
‫ﻳﺠ ﺐ ﻃ‬
EPSON ... ‫ﺑﻌ ﺔ‬
‫ﺒﺎﻋ ﺔ ﻋﲆ ﻃﺎ‬
‫ﺘﻤﻠ ﺖ اﻟﻄ‬
‫اﻛ‬
77
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﻓﺌ ﺔ ‪Concreate vs Abstract Class vs Inteface:‬‬

‫ﺒﺎ ت‬
‫ﺘﻄﻠ‬
‫ﺘﻨﻔﻴﺬ ﻓﻘﻂ ﻓﻠﺪﻳﻨﺎ ﻣ‬
‫)‪1‬إذا ﻟﻢ ﻧﻜﻦ ﻧﻌﺮف أي ﺷ ﻲء ﻋﻦ اﻟ‬
‫ﺛﻢﻳﺠ ﺐ أن ﻧﺬ ﻫ ﺐ ﻟﻠﻮاﺟﻬ ﺔ‪.‬‬
‫ﺒﺪأ‬
‫ﺑﺸﻜﻞ ﻛﺎﻣﻞ ﻓﻌﻠﻴﻨﺎ أن ﻧ‬‫ﺘﻨﻔﻴﺬ وﻟﻜﻦ ﻟﻴ ﺲ‬
‫ﺘﺤﺪ ث ﻋﻦ اﻟ‬
‫)‪2‬إذا ﻛﻨﺎ ﻧ‬
‫ﺋ ًﻴﺎ(‪.‬‬
‫ﺒﻘ ﺔ ﺟﺰ‬
‫ﻓﺌ ﺔ ﻣﺠﺮدة‪) .‬ﻓﺌ ﺔ ﻣﻄ‬
‫ﺘﻘﺪﻳﻢ اﻟﺨﺪﻣ ﺔ إذن‬
‫ﺑﺸﻜﻞ ﻛﺎﻣﻞ وﺟﺎ ﻫﺰ ﻟ‬‫ﺘﻨﻔﻴﺬ‬
‫ﺘﺤﺪ ث ﻋﻦ اﻟ‬
‫)‪3‬إذا ﻛﻨﺎ ﻧ‬
‫ﻳﺠ ﺐ أن ﻧﺬ ﻫ ﺐ إﱃ ﻓﺌ ﺔ ﻣﻠﻤﻮﺳ ﺔ‪.‬‬
‫*‬
‫ﺘﻴﺮاد ‪pass 7) abstractmethod 8) def m3 (self) :‬‬
‫)‪1‬ﻣﻦ اﺳ‬
‫‪4) def m1 (self): pass 5) abstractmethod 6) def m2 (self):‬‬
‫‪2) class CollegeAutomation (ABC): 3) abstractmethod‬‬
‫ﺘﻴﺎز ‪10) def m1 (self): 11) print ('m1 method‬‬
‫‪abc‬اﺟ‬
‫ﺗﻨﻔﻴﺬ'( ‪('m2 method‬‬
‫‪9) class AbsCls (CollegeAutomation):‬‬
‫ﺗﻨﻔﻴﺬ'( )‪14) 15‬ﻓﺌ ﺔ )( ‪ .m3‬ج )‪() 22‬‬
‫‪12) def m2 (self): 13) print‬‬
‫‪18) 19) c = ConcreteCls () 20) c.m1 () 21) c.m2‬‬
‫)'‪def m3 (self): 17) print ('m3 method implemnentation‬‬
‫)‪ConcreteCls (AbsCls): 16‬‬
‫اﻟ ﺴﻤﺎ ت اﻟﻌﺎﻣ ﺔ واﻟﻤﺤﻤﻴ ﺔ واﻟﺨﺎﺻ ﺔ‪:‬‬

‫ﺘﺮاﺿ ﻲ ‪،‬ﺗﻜﻮن ﻛﻞﺳﻤ ﺔ ﻋﺎﻣ ﺔ‪.‬ﻳﻤﻜﻨﻨﺎ اﻟﻮﺻﻮل ﻣﻦ أي ﻣﻜﺎنﺳﻮاء داﺧﻞ اﻟﻔﺼﻞ أو ﻣﻦ ﺧﺎرج اﻟﻔﺼﻞ‪.‬‬
‫ﺑﺸﻜﻞ اﻓ‬
‫ﺜﺎل‪ :‬اﻻﺳﻢ ="دورﺟﺎ"‬

‫ﻋﲆﺳ‬
‫ﻳﻤﻜﻦ اﻟﻮﺻﻮل إﱃ اﻟ ﺴﻤﺎ ت اﻟﻤﺤﻤﻴ ﺔ داﺧﻞ اﻟﻔﺼﻞ اﻟﺪراﺳ ﻲ ﻓ ﻲ أي ﻣﻜﺎن وﻟﻜﻦ ﻣﻦ ﺧﺎرج اﻟﻔﺼﻞ ﻓﻘﻂ ﻓ ﻲ اﻟﻔﺼﻮل اﻟﻔﺮﻋﻴ ﺔ‪.‬ﻳﻤﻜﻨﻨﺎﺗﺤﺪﻳﺪﺳﻤ ﺔ ﻋﲆ‬
‫ﺑﺎﻟﺮﻣﺰ‪.‬‬‫ﺒﻘ ﺔ‬
‫ﺘﻬﻴﺌ ﺔ اﻟﻤ ﺴ‬ ‫_‬
‫أﻧﻬﺎ ﻣﺤﻤﻴ ﺔ ﻋﻦ ﻃﺮﻳﻖ اﻟ‬
‫ﺑﻨﺎء اﻟﺠﻤﻠ ﺔ‪_variablename = :‬اﻟﻘﻴﻤ ﺔ‬
‫ﺜﺎل‪_name = 'durga' :‬‬

‫ﻋﲆﺳ‬

‫اﻟ‬
‫‪78‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺑﻞ ﻫ ﻲ ﻣﺠﺮد اﺻﻄﻼح وﻓ ﻲ اﻟﻮاﻗﻊ ﻻﺗﻮﺟﺪ ﺻﻔﺎ ت ﻣﺤﻤﻴ ﺔ‪.‬‬
‫ﺑﺸﻜﻞ‬‫ﺘﻐﻴﺮ ﺧﺎص‬
‫ﻳﻤﻜﻦ اﻟﻮﺻﻮل إﱃ اﻟ ﺴﻤﺎ ت اﻟﺨﺎﺻ ﺔ ﻓﻘﻂ داﺧﻞ ‪class.ie‬ﻣﻦ ﺧﺎرج اﻟﻔﺼﻞ اﻟﺬي ﻻﻳﻤﻜﻨﻨﺎ اﻟﻮﺻﻮل إﻟﻴﻪ‪.‬ﻳﻤﻜﻨﻨﺎ أن ﻧﻌﻠﻦ أن اﻟﻤ‬
‫ﺑﺮﻣﺰﻳﻦ ﺷﺮﻃ ﺔﺳﻔﻠﻴ ﺔ‪.‬‬‫ﺑﺎدﺋ ﺔ‬‫ﺑﺔ‬
‫ﺘﺎ‬
‫ﺻﺮﻳﺢ ﻋﻦ ﻃﺮﻳﻖ ﻛ‬
‫ﺑﻨﺎء اﻟﺠﻤﻠ ﺔ‪__variablename = :‬اﻟﻘﻴﻤ ﺔ‬
‫ﺜﺎل‪__name = 'durga' :‬‬

‫ﻋﲆﺳ‬
‫)‪(Test._y) 14) print (Test .__ z‬‬

‫‪12) print (Test.x) 13) print‬‬
‫)( ‪9) 10) t = Test () 11) t.m1‬‬
‫)‪(Test._y) 8) print (Test. __z‬‬
‫‪6) print (Test.x) 7) print‬‬
‫‪4) __z‬‬ ‫‪= 30‬‬
‫‪Test:‬‬ ‫‪2) x5)=def‬‬ ‫‪m1_y(self):‬‬
‫)‪10 3‬‬ ‫‪= 20‬‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫‪10‬‬
‫‪20‬‬
‫‪30‬‬
‫‪10‬‬
‫‪20‬‬
‫ﺒﺎر ‪z) __.‬‬
‫ﺘ‬‫ﺒﺎﻋ ﺔ )اﺧ‬
‫ﻃ‬
‫ﺒﺎر" ﻟﻴ ﺲ ﻟﻪﺳﻤ ﺔ "‪"__z‬‬
‫ﺘ‬‫‪AttributeError:‬ﻧﻮع اﻟﻜﺎﺋﻦ "اﺧ‬
‫ﺘﻐﻴﺮا ت اﻟﺨﺎﺻ ﺔ ﻣﻦ ﺧﺎرج اﻟﻔﺼﻞ اﻟﺪراﺳ ﻲ‪:‬‬

‫ﻛﻴﻔﻴ ﺔ اﻟﻮﺻﻮل إﱃ اﻟﻤ‬
‫ﺒﺎﺷﺮة ﻣﻦ ﺧﺎرج اﻟﻔﺼﻞ‪.‬‬

‫ﺘﻐﻴﺮا ت اﻟﺨﺎﺻ ﺔ ﻣ‬
‫ﻻﻳﻤﻜﻨﻨﺎ اﻟﻮﺻﻮل إﱃ اﻟﻤ‬
‫‪object._classname__variablename‬‬
‫ﺘﺎﻟ ﻲ‬
‫ﺒﺎﺷﺮ ﻋﲆ اﻟﻨﺤﻮ اﻟ‬
‫ﺑﺸﻜﻞ ﻏﻴﺮ ﻣ‬ ‫ﻣﺮﺟﻊ‬
‫ﻳﻤﻜﻨﻨﺎ اﻟﻮﺻﻮل‬‫ﻟﻜﻦ‬
‫ﺒﺎر اﻟﻔﺌ ﺔ ‪2) def __init __ (self): 3) self .__ x = 10 4) :‬‬

‫ﺘ‬‫)‪1‬اﺧ‬
‫‪79‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫‪5) t = Test () 6) print (t._Test__x) # 10‬‬
‫ﻃﺮﻳﻘ ﺔ ‪__str __ ():‬‬

‫ﺘﺎﻟ ﻲ‬
‫ﺘﻨ ﺴﻴﻖ اﻟ‬
‫ﺑﺎﻟ‬‫ﺑﺈرﺟﺎعﺳﻠ ﺴﻠ ﺔ‬‫ﺘ ﻲﺗﻘﻮم‬
‫ﺘﺪﻋﺎء ﻃﺮﻳﻘ ﺔ )( __ ‪__str‬واﻟ‬
‫ﺘﻢ اﺳ‬
‫ﺒﺎﻋ ﺔ أي ﻣﺮﺟﻊ ﻛﺎﺋﻦ داﺧﻠ ًﻴﺎ ‪،‬ﺳﻴ‬
‫ﺑﻄ‬‫•ﻓ ﻲ أي وﻗ ﺖ ﻧﻘﻮم ﻓﻴﻪ‬
‫>‪<__ main __. classname object at 0x022144B0‬‬
‫ﺘﻌﻴﻦ ﻋﻠﻴﻨﺎﺗﺠﺎوز ﻃﺮﻳﻘ ﺔ ‪__str __ ().‬‬

‫ﺜﻴﻞﺳﻠ ﺴﻠ ﺔ ذي ﻣﻌﻨﻰ ‪،‬ﻳ‬
‫•ﻹرﺟﺎعﺗﻤ‬
‫)‪= Student ('Ravi'، 102) 11) print (s1) 12) print (s2‬‬
‫‪(self): 7) 8) 9) s1 = Student ('Durga'، 101) 10) s2‬‬
‫‪rollno):‬‬
‫‪3) self.name‬‬
‫)‪Student: 2‬‬
‫‪= name‬‬
‫‪def __init‬‬
‫‪4) 5)__6)(self،‬‬
‫‪def __str‬‬
‫‪name،‬‬
‫__‬
‫‪self.rollno = rollno‬‬
‫إرﺟﺎع )‪'This is Student with Name: {} and Rollno: {}'. format (self.name، self.rollno‬‬
‫اﻹﺧﺮاج دونﺗﺠﺎوز ‪str ():‬‬

‫‪<__ main __.‬ﻛﺎﺋﻦ اﻟﻄﺎﻟ ﺐ ﻋﻨﺪ >‪0x022144B0‬‬
‫‪<__ main __.‬ﻛﺎﺋﻦ اﻟﻄﺎﻟ ﺐ ﻋﻨﺪ >‪0x022144D0‬‬
‫ﺘﺠﺎوز ‪():‬‬
‫اﻹﺧﺮاج ﻣﻊ اﻟ‬
‫ﺑﺎﻻﺳﻢ‪ :‬دورﺟﺎ وروﻟﻨﻮ‪101 :‬‬‫ﻫﺬا ﻃﺎﻟ ﺐ‬
‫ﺑﺎﻻﺳﻢ‪ :‬راﻓ ﻲ وروﻟﻨﻮ‪102 :‬‬‫ﻫﺬا ﻃﺎﻟ ﺐ‬
‫ﺑﻴﻦ )( ‪str‬و )( ‪repr‬‬‫اﻟﻔﺮق‬

‫أو‬
‫ﺑﻴﻦ )( __ ‪__str‬و )( __ ‪__repr‬‬‫اﻟﻔﺮق‬

‫ﺘﺎﻟ ﻲ ﻓﺈن وﻇﻴﻔ ﺔ ﻛﻠﻴﻬﻤﺎ ﻫ ﻲ ﻧﻔ ﺴﻬﺎ‪.‬‬
‫ﺑﺎﻟ‬
‫ﺘﺪﻋ ﻲ )( ‪• str‬داﺧﻠ ًﻴﺎ وﻇﻴﻔ ﺔ )( __ ‪__str‬و‬
‫ﺗﺴ‬
‫ﺘﺎﻟ ﻲ وﻇﻴﻔ ﺔ ﻛﻼ ﻫﻤﺎ‬

‫ﺑﺎﻟ‬
‫ﺘﺪﻋ ﻲ )( ‪repr‬داﺧﻠ ًﻴﺎ وﻇﻴﻔ ﺔ )( __ ‪__repr‬و‬
‫ﺜﻞ ‪،‬ﻳ ﺴ‬
‫ﺑﺎﻟﻤ‬
‫•و‬
‫ﻧﻔ ﺲ‪.‬‬
‫ﺒﺎﻋ ﺔ‪.‬‬
‫ﺜﻴﻞ ﺟﻴﺪ ﻟﻠﻄ‬
‫ﺘﻮي ﻋﲆ ﻛﺎﺋﻦﺗﻤ‬
‫ﺗﻌﻴﺪﺳﻠ ﺴﻠ ﺔﺗﺤ‬
‫)( ‪• str‬‬
‫ﺘﻴﺠ ﺔ إﱃ اﻟﻜﺎﺋﻦ اﻷﺻﻠ ﻲ‪.‬‬

‫ﺋﻴ ﺴ ﻲ ﻣﻦ )( ‪ str‬ﻫﻮﺳﻬﻮﻟ ﺔ اﻟﻘﺮاءة ‪ ،‬وﻗﺪ ﻻﻳﻜﻮن ﻣﻦ اﻟﻤﻤﻜﻦﺗﺤﻮﻳﻞﺳﻠ ﺴﻠ ﺔ اﻟﻨ‬
‫•اﻟﻐﺮض اﻟﺮ‬
‫‪80‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﺎرﻳﺦ واﻟﻮﻗ ﺖ ‪.‬‬

‫ﺘﺎرﻳﺦ واﻟﻮﻗ ﺖ ) ‪2‬اﻟﻴﻮم =اﻟ‬
‫ﺘﻴﺮاد اﻟ‬
‫) ‪1‬اﺳ‬

‫‪2018-05-18 22: 48: 19.890888‬‬

‫‪d = Eval (s) #converting str‬ﻛﺎﺋﻦ إﱃﺗﺎرﻳﺦ ووﻗ ﺖ‬
‫ﻣﻠﻒ ‪"<string>" ،‬اﻟ ﺴﻄﺮ اﻷول‬
‫‪2018-05-18 22: 48: 19.890888‬‬
‫^‬
‫ﺑﻨﺎء اﻟﺠﻤﻠ ﺔ‪ :‬رﻣﺰ ﻣﻤﻴﺰ ﻏﻴﺮ ﺻﺎﻟﺢ‬‫ﺧﻄﺄ ﻓ ﻲ‬
‫ﺒﺎﻋ ﺔ ﻟﻠﻜﺎﺋﻦ‪.‬‬
‫ﺑﻞ ﻟﻠﻄ‬
‫ﺜﻴﻞ ﻗﺎ‬
‫ﺘﻮي ﻋﲆﺗﻤ‬
‫ﻟﻜﻦ )( ‪repr‬ﻳﻌﻴﺪﺳﻠ ﺴﻠ ﺔﺗﺤ‬
‫ﺘ ﻲ ﻗﺪ ﻻﺗﻜﻮن ﻣﻤﻜﻨ ﺔ ﻓ ﻲ داﻟ ﺔ ‪().‬‬
‫ﺘﺨﺪام وﻇﻴﻔ ﺔ ‪Eval () ،‬واﻟ‬
‫ﺑﺎﺳ‬‫ﺘﻴﺠ ﺔ إﱃ ﻛﺎﺋﻦ أﺻﻠ ﻲ‬
‫ﺋﻴ ﺴ ﻲ ﻣﻦ )( ‪ repr‬ﻫﻮ واﺿﺢ‪.‬ﻳﻤﻜﻨﻨﺎﺗﺤﻮﻳﻞﺳﻠ ﺴﻠ ﺔ اﻟﻨ‬
‫اﻟﻬﺪف اﻟﺮ‬
‫‪str‬‬
‫ﺘﺎرﻳﺦ واﻟﻮﻗ ﺖ )‪2‬اﻟﻴﻮم ) ‪(s) #converting str object to datetime 6‬‬

‫)‪1‬اﺳ‬
‫‪repr (today) #converting datetime object to str 4) print (s) 5) d = Eval‬‬
‫ﺒﺎﻋ ﺔ )د(‬
‫= ‪= datetime.datetime.now () 3) s‬ﻃ‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫)‪datetime.datetime (2018، 5، 18، 22، 51، 10، 875838‬‬
‫‪2018-05-18 22: 51: 10.875838‬‬
‫ﺑﺪﻻ ﻣﻦ )( ‪str‬‬
‫ﺘﺨﺪام )( ‪repr‬‬
‫ﺑﺎﺳ‬‫ﻣﻼﺣﻈ ﺔ‪:‬ﻳﻮﺻﻰ‬
‫ﺒﻴﻖ ﻣﺼﺮﻓ ﻲ‬
‫ﻣﺸﺮوع ﺻﻐﻴﺮ‪:‬ﺗﻄ‬
‫)‪1‬ﺣ ﺴﺎ ب اﻟﻔﺌ ﺔ ‪5) 6) 7) def Deposit (self، amount): 8) self.balance + = :‬‬

‫)‪__init __ (self، name، Balance، min_balance): 3) self.name = name 4‬‬
‫ﺒﻠﻎ(‪:‬‬
‫ﺗ ﻲ ‪ ،‬اﻟﻤ‬
‫ﺒﻠﻎ )‪9) 10‬ﺳﺤ ﺐ ﻧﻘﺎط )ذا‬
‫‪2) def‬اﻟﻤ‬
‫ﺗ ﻲ ‪= min_balance‬‬
‫= ‪self.balance‬اﻟ‬
‫‪min_balance‬‬

‫‪81‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
18) 19) class Current if(Account):

self.balance-20) def __init
amount> __ (self، name)
= self.min_balance:
printStatement (self): :‫آﺧﺮ‬

17)‫ﺒﻠﻎ‬
print ("Account
‫ﻣ‬self.balance -= Balance:"، self.balance)
27) super () .__ init __ :(‫ اﻟﺮﺻﻴﺪ‬، ‫اﻻﺳﻢ‬11) 12) 13) 14) 15) 16) def
class Savings (Account): 26) def‫__ﻏﻴﺮ‬init
("‫ﻛﺎﻓﻴ ﺔ‬ ‫ أﻣﻮال‬،__ (self،
‫ﺬرة‬ name،
‫ﺒﺎﻋ ﺔ )"ﻣﻌ‬
‫ﻃ‬ Balance):
() 35 ) c. ، ‫ اﻟﺮﺻﻴﺪ‬، ‫)اﻻﺳﻢ‬21) 22) def __str __ (self): 23) 24) 25)
10000) 32) print (c) 33) c.deposit (5000) 34) c.printStatement
41) =print
0) 28) def
(c2) 42__str __ (self): 29)
) c2.withdraw 30) 31)43)
(27000) c =‫ﺐ‬
Savings ("Durga"،
‫ﺳﺤ‬min_balance
(c) 38) 39) c2 = Current ('Ravi'، 20000) 40) c2.deposit (6000)
(c2) ‫ﺒﺎﻋ ﺔ‬
‫(ﻃ‬16000) 36) c.withdraw (15000) 37) print
= 1000) ‫ﺘﻮازن‬
‫ اﻟﺤﺪ اﻷدﻧﻰ ﻟﻠ‬، ‫ اﻟﺮﺻﻴﺪ‬، ‫)اﻻﺳﻢ‬super () .__ init __
(self.name ، self.balance) ‫ﺗﻨ ﺴﻴﻖ‬

{}". : ‫ﺑﺎﻟﺮﺻﻴﺪ‬
"{} ‫إرﺟﺎع اﻟﺤ ﺴﺎ ب اﻟﺠﺎري ﻟـ‬
(self.name ، self.balance) ‫ﺗﻨ ﺴﻴﻖ‬

{}". : ‫ﺑﺮﺻﻴﺪ‬
"{} ‫ﺘﻮﻓﻴﺮ‬
‫إرﺟﺎع ﺣ ﺴﺎ ب اﻟ‬
:‫ﺘﺎج‬
‫اﻧ‬
D: \ durgaclasses> py test.py
10000 :‫ﺑﺮﺻﻴﺪ‬‫ﺣ ﺴﺎ بﺗﻮﻓﻴﺮ دورﺟﺎ‬
15000 :‫رﺻﻴﺪ اﻟﺤ ﺴﺎ ب‬
‫ أﻣﻮال ﻏﻴﺮ ﻛﺎﻓﻴ ﺔ‬، ‫ﻋﺬرا‬
0 :‫ﺑﺮﺻﻴﺪ‬‫ﺣ ﺴﺎ بﺗﻮﻓﻴﺮ دورﺟﺎ‬

26000 :‫ﺑﺮﺻﻴﺪ‬‫ﺣ ﺴﺎ ب راﻓ ﻲ اﻟﺠﺎري‬
-1000 :‫ﺑﺮﺻﻴﺪ‬‫ﺣ ﺴﺎ ب راﻓ ﻲ اﻟﺠﺎري‬
82
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﺜﻨﺎء‬
‫ﺘ‬‫اﺳ‬
‫ﻣﻌﺎﻟﺠ ﺔ‬
‫‪83‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺑﺮﻣﺠ ﺔ‪.‬‬‫ﻳﻮﺟﺪ ﻧﻮﻋﺎن ﻣﻦ اﻷﺧﻄﺎء ﻓ ﻲ أي ﻟﻐ ﺔ‬
‫)‪1‬أﺧﻄﺎء ﻧﺤﻮﻳ ﺔ‬
‫)‪2‬أﺧﻄﺎء وﻗ ﺖ اﻟ‬
‫)‪1‬أﺧﻄﺎء ﻧﺤﻮﻳ ﺔ‪:‬‬

‫ﺑﻨﺎء اﻟﺠﻤﻠ ﺔ‪.‬‬‫ﺑﺄﺧﻄﺎء‬‫ﺑﻨﺎء اﻟﺠﻤﻠ ﺔ‬‫ﺒﺐ‬
‫ﺑﺴ‬‫ﺘ ﻲﺗﺤﺪ ث‬
‫ﺗ ﺴﻤﻰ اﻷﺧﻄﺎء اﻟ‬
‫ﺜﺎل ‪ 1: ،‬س ‪= 10‬‬

‫ﻋﲆﺳ‬
‫ﺒﺎﻋ ﺔ‬
‫إذا ﻛﺎﻧ ﺖ ‪x == 10‬ﻃ‬
‫ﺒﺎ"(‬
‫)"ﻣﺮﺣ ً‬
‫ﺑﻨﺎء ﺟﻤﻠ ﺔ ﻏﻴﺮ ﺻﺎﻟﺢ‬‫ﺧﻄﺄ ﻗﻮاﻋﺪي‪:‬‬
‫ﺒﺎ"‬
‫ﺒﺎﻋ ﺔ "ﻣﺮﺣ ً‬
‫ﺜﺎل ‪2:‬ﻃ‬
‫ﻋﲆﺳ‬
‫ﺒﺎﻋ ﺔ"‬
‫ﺘﺪﻋﺎء "ﻃ‬
‫ﺘﺮﻛﻴ ﺐ‪ :‬أﻗﻮاس ﻣﻔﻘﻮدة ﻓ ﻲ اﺳ‬
‫ﺧﻄﺄ ﻓ ﻲ اﻟ‬
‫ﺒﺮﻧﺎﻣﺞ ﻓﻘﻂ‪.‬‬
‫ﺒﺪأﺗﻨﻔﻴﺬ اﻟ‬
‫ﺑﻤﺠﺮدﺗﺼﺤﻴﺢ ﺟﻤﻴﻊ اﻷﺧﻄﺎء اﻟﻨﺤﻮﻳ ﺔ ‪،‬ﺳﻴ‬‫ﺒﺮﻣﺞ ﻣ ﺴﺆول ﻋﻦﺗﺼﺤﻴﺢ ﻫﺬه اﻷﺧﻄﺎء اﻟﻨﺤﻮﻳ ﺔ‪.‬‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬اﻟﻤ‬
‫ﺘﺸﻐﻴﻞ‪:‬‬
‫)‪2‬أﺧﻄﺎء وﻗ ﺖ اﻟ‬
‫ﺒﺮﻣﺠ ﺔ أو ﻣﺸﺎﻛﻞ اﻟﺬاﻛﺮة وﻣﺎ‬
‫ﺘﺨﺪم اﻟﻨﻬﺎﺋ ﻲ أو ﻣﻨﻄﻖ اﻟ‬
‫ﺒ ﺐ إدﺧﺎل اﻟﻤ ﺴ‬
‫ﺑﺴ‬‫ﺒﺮﻧﺎﻣﺞ إذا ﺣﺪ ث ﺧﻄﺄ ﻣﺎ‬
‫ﺛﻨﺎءﺗﻨﻔﻴﺬ اﻟ‬
‫ﺜﻨﺎءا ت‪• .‬أ‬
‫ﺘ‬‫ﺑﺎﺳﻢ اﻻﺳ‬ ‫ُﻌﺮف أ ً‬
‫•‬
‫ﺘﺸﻐﻴﻞ‪.‬‬
‫إﱃ ذﻟﻚ ‪ ،‬ﻓ ﺴﻨﺤﺼﻞ ﻋﲆ أﺧﻄﺎء وﻗ ﺖ اﻟ‬
‫)‪1) print (10/0‬اﻟﻘ ﺴﻤ ﺔ ﻋﲆ ﺻﻔﺮ ‪2) print (10 / "ten") TypeError :‬ﻧﻮع )أﻧﻮاع( اﻟﻤﻌﺎﻣﻞ ﻏﻴﺮ‬ ‫ﺜﺎل‪ZeroDivisionError: :‬‬
‫ﻋﲆﺳ‬
‫اﻟﻤﺪﻋﻮم ﻟـ ‪'int' :/‬و '‪'str‬‬
‫)‪3) x = int (input ("Enter Number:")) print (x‬‬
‫‪D: \ Python_classes> py test.py‬أدﺧﻞ اﻟﺮﻗﻢ‪ :‬ﻋﺸﺮة ‪ValueError:‬ﺣﺮﻓﻴ ﺔ ﻏﻴﺮ‬

‫ﺻﺎﻟﺤ ﺔ ﻟـ )( ‪int‬ﻣﻊ اﻷﺳﺎس '‪10: 'ten‬‬
‫ﺑﻨﺎء اﻟﺠﻤﻠ ﺔ‬‫ﺘﺸﻐﻴﻞ وﻟﻜﻦ ﻟﻴ ﺲﻷﺧﻄﺎء‬

‫ﺜﻨﺎءا ت ﻋﲆ أﺧﻄﺎء وﻗ ﺖ اﻟ‬
‫ﺘ‬‫ﺒﻖ ﻣﻔﻬﻮم ﻣﻌﺎﻟﺠ ﺔ اﻻﺳ‬
‫ﻣﻼﺣﻈ ﺔ‪:‬ﻳﻨﻄ‬
‫‪84‬‬
‫ﺑﺎد ‪- 500038 ،‬‬ ‫ﺑﻴ ﺖ‬ ‫ﺘﺮ‪#‬‬
‫ﻳﻔﺎﻧﺎم ‪ ،‬أﻣﻴﺮ‬ ‫‪202،‬‬ ‫ﺑﻖ ‪2 ،‬‬
‫ﺜﻨﺎء؟‬
‫ﺘ‬‫ﻣﺎ ﻫﻮ اﻻﺳ‬
‫ﺜﻨﺎء‪.‬‬
‫ﺘ‬‫ﺒﺮﻧﺎﻣﺞ اﺳ‬
‫ﺒﻴﻌ ﻲ ﻟﻠ‬
‫ﺘﺪﻓﻖ اﻟﻄ‬
‫ﺘﻮﻗﻊ اﻟﺬيﻳﺰﻋﺞ اﻟ‬
‫ﻳ ﺴﻤﻰ اﻟﺤﺪ ث ﻏﻴﺮ اﻟﻤﺮﻏﻮ ب ﻓﻴﻪ وﻏﻴﺮ اﻟﻤ‬
‫ﺜﺎل‪:‬‬
‫ﻋﲆﺳ‬
‫‪• ZeroDivisionError‬‬
‫‪• TypeError‬‬
‫•ﺧﻄﺄ اﻟﻘﻴﻤ ﺔ‬
‫‪• FileNotFoundError‬‬
‫‪• EOFError‬‬
‫‪• SleepingError‬‬
‫‪• TyrePuncturedError‬‬
‫ﺜﺎل ‪،‬ﻳﺠ ﺐ أﻻ ﻧﺤﺠ ﺐ ﻣﻮاردﻧﺎ‬

‫ﺒﺮﻧﺎﻣﺞ )ﻋﲆﺳ‬
‫ﺜﻨﺎءا ت ﻫﻮ اﻹﻧﻬﺎء اﻟﺮﺷﻴﻖ ﻟﻠ‬
‫ﺘ‬‫ﺋﻴ ﺴ ﻲ ﻣﻦ ﻣﻌﺎﻟﺠ ﺔ اﻻﺳ‬
‫ﺜﻨﺎءا ت‪ .‬اﻟﻬﺪف اﻟﺮ‬
‫ﺘ‬‫ﺑﻤﻌﺎﻟﺠ ﺔ اﻻﺳ‬‫ﺑﺸﺪة‬‫ﻳﻮﺻﻰ‬
‫ﺗﻨﺎ أي ﺷ ﻲء(‬
‫وﻳﺠ ﺐ أﻻﻳﻔﻮ‬
‫ﺒﻴﻌ ﻲ‪.‬‬
‫ﺑﺸﻜﻞ ﻃ‬‫ﺒﺮﻧﺎﻣﺞ‬
‫ﺑﻘﻴ ﺔ اﻟ‬‫ﺑﺪﻳﻠ ﺔ ﻟﻤﻮاﺻﻠ ﺔ‬‫ﺜﻨﺎء‪ .‬ﻋﻠﻴﻨﺎﺗﺤﺪﻳﺪ ﻃﺮﻳﻘ ﺔ‬
‫ﺘ‬‫ﺜﻨﺎءا ت ﻻﺗﻌﻨ ﻲ إﺻﻼح اﻻﺳ‬
‫ﺘ‬‫ﻣﻌﺎﻟﺠ ﺔ اﻻﺳ‬
‫ﺣﺎ ‪،‬‬
‫ﺘﺎ ً‬
‫ﺘﺸﻐﻴﻞ إذا ﻟﻢﻳﻜﻦ ﻣﻠﻒ ‪London‬ﻣ‬
‫ﺑﻌﻴﺪ ﻣﺤﺪد ﻓ ﻲ ﻟﻨﺪن‪ .‬ﻓ ﻲ وﻗ ﺖ اﻟ‬‫ﺒﻴﺎﻧﺎ ت ﻣﻦ ﻣﻠﻒ‬
‫ﺒﺮﻣﺠ ﺔ ﻟﺪﻳﻨﺎ ﻫ ﻲ ﻗﺮاءة اﻟ‬
‫ﺒﺎ ت اﻟ‬
‫ﺘﻄﻠ‬
‫ﺜﺎل‪ :‬ﻣ‬
‫ﻋﲆﺳ‬
‫ﺒﺪﻳﻞ ﻟﻴ ﺴ ﺖ‬
‫ﺒﻴﻌ ﻲ‪ .‬ﻫﺬه اﻟﻄﺮﻳﻘ ﺔ ﻓ ﻲﺗﻌﺮﻳﻒ اﻟ‬
‫ﺑﻘﻴ ﺔ اﻟ‬‫ﺘﻌﻴﻦ ﻋﻠﻴﻨﺎﺗﻮﻓﻴﺮ ﻣﻠﻒ ﻣﺤﻠ ﻲ ﻟﻤﻮاﺻﻠ ﺔ‬
‫ﺒﻴﻌ ﻲ‪.‬ﻳ‬
‫ﺑﺸﻜﻞ ﻏﻴﺮ ﻃ‬‫ﺒﺮﻧﺎﻣﺞ‬
‫ﻓﻼﻳﺠ ﺐ إﻧﻬﺎء اﻟ‬
‫ﺜﻨﺎﺋﻴ ﺔ‪.‬‬
‫ﺘ‬‫ﺳﻮى ﻣﻌﺎﻟﺠ ﺔ اﺳ‬
‫ﻳﺤﺎول‪:‬‬
‫ﺑﻌﻴﺪ ﻣﺤﺪد ﻓ ﻲ ﻟﻨﺪن‪.‬‬‫ﺒﻴﺎﻧﺎ ت ﻣﻦ ﻣﻠﻒ‬
‫اﻗﺮأ اﻟ‬
‫ﺜﻨﺎء ‪FileNotFoundError:‬‬
‫ﺘ‬‫ﺑﺎﺳ‬
‫ﺒﻴﻌ ﻲ‬
‫ﺑﻘﻴ ﺔ اﻟ‬‫ﺑﻊ‬
‫ﺗﺎ‬
‫ﺘﺨﺪم اﻟﻤﻠﻒ اﻟﻤﺤﻠ ﻲ و‬
‫اﺳ‬
‫ﺜﻨﺎء؟‬
‫ﺘ‬‫س‪ :‬ﻣﺎ ﻫﻮ اﻻﺳ‬
‫ﺜﻨﺎءا ت؟‬
‫ﺘ‬‫س‪ :‬ﻣﺎ ﻫﻮ اﻟﻐﺮض ﻣﻦ ﻣﻌﺎﻟﺠ ﺔ اﻻﺳ‬
‫ﺜﻨﺎءا ت؟‬
‫ﺘ‬‫س‪ :‬ﻣﺎ ﻣﻌﻨﻰ ﻣﻌﺎﻟﺠ ﺔ اﻻﺳ‬
‫ﺜﻮن‪:‬‬
‫ﺑﺎﻳ‬‫ﺘﺮاﺿ ﻲ ﻓ ﻲ‬
‫ﺜﻨﺎءا ت اﻻﻓ‬
‫ﺘ‬‫ﺗ ﺴﻠﻴﻢ اﻻﺳ‬
‫ﺑﻞ‬
‫ﺜﻨﺎء اﻟﻤﻘﺎ‬
‫ﺘ‬‫ﺜﻮن ﻫﻮ ﻛﺎﺋﻦ‪ .‬ﻟﻜﻞ ﻧﻮع اﻻﺳ‬
‫ﺑﺎﻳ‬‫ﺜﻨﺎء ﻓ ﻲ‬
‫ﺘ‬‫•ﻛﻞ اﺳ‬
‫ﺘﻮﻓﺮة‪.‬‬
‫اﻟﻔﺼﻮل اﻟﺪراﺳﻴ ﺔ ﻣ‬
‫ﺣﺎ ‪ ،‬ﻓﺈن ‪Python‬‬

‫ﺘﺎ ً‬
‫ﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻜﻮد ﻣ‬
‫ﺘﺤﻘﻖ ﻣﻦ ﻣﻌﺎﻟﺠ ﺔ اﻟﻜﻮد‪ .‬إذا ﻟﻢﻳﻜﻦ اﻟ‬
‫ﺘ‬‫ﺑﻞ وﺳ‬
‫ﺘ‬‫ﺘﻨﺸ ﺊ ‪PVM‬ﻛﺎﺋﻦ اﻻﺳ‬
‫ﺜﻨﺎء ‪،‬ﺳ‬
‫ﺘ‬‫•ﻓ ﻲ ﺣﺎﻟ ﺔ ﺣﺪو ث اﺳ‬
‫ﺘﺤﻜﻢ‪.‬‬
‫ﺑﻠ ﺔ إﱃ وﺣﺪة اﻟ‬
‫ﺘ‬‫ﺒﻊ ﻣﻌﻠﻮﻣﺎ ت اﻻﺳ‬
‫ﺒﻴﻌ ﻲ وﻳﻄ‬
‫ﺑﺸﻜﻞ ﻏﻴﺮ ﻃ‬‫ﺒﺮﻧﺎﻣﺞ‬
‫ﺑﺈﻧﻬﺎء اﻟ‬‫ﺘﺮﺟﻢ اﻟﻔﻮري‬
‫ﻳﻘﻮم اﻟﻤ‬
‫ﺒﺮﻧﺎﻣﺞ‪.‬‬
‫ﺑﺎﻗ ﻲ اﻟ‬‫ﺘﻢﺗﻨﻔﻴﺬ‬
‫•ﻟﻦﻳ‬

‫‪85‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺒﺎﻋ ﺔ )‪2‬‬
‫)‪1‬ﻃ‬
‫ﺒﺎﻋ ﺔ )‪3‬‬ ‫)"‪("Hello‬ﻃ‬
‫ﺒﺎﻋ ﺔ )"‪("Hi‬‬
‫)‪(10/0‬ﻃ‬
‫‪Python_classes> py test.py Hello Traceback‬‬

‫\ ‪)D:‬آﺧﺮ ﻣﻜﺎﻟﻤ ﺔ أﺧﻴﺮة(‪ :‬ﻣﻠﻒ ‪"test.py" ،‬اﻟ ﺴﻄﺮ ‪2 ،‬‬
‫ﺒﺎﻋ ﺔ )‪<module> (10/0‬‬

‫ﻓ ﻲﻃ‬
‫‪ZeroDivisionError:‬اﻟﻘ ﺴﻤ ﺔ ﻋﲆ ﺻﻔﺮ‬
‫ﺜﻮن‬
‫ﺑﺎﻳ‬‫ﺜﻨﺎء‬
‫ﺘ‬‫ﺘ ﺴﻠ ﺴﻞ اﻟﻬﺮﻣ ﻲ ﻻﺳ‬
‫اﻟ‬
‫‪BaseException‬‬
‫ﺜﻨﺎء‬
‫ﺘ‬‫اﺳ‬ ‫‪SystemExit‬‬ ‫اﻟﻤﻮﻟﺪ‬ ‫ﺗﻴﺢ اﻟﻤﻘﺎﻃﻌ ﺔ‬
‫ﻟﻮﺣ ﺔ اﻟﻤﻔﺎ‬
‫ﻳﺼﻒ‬ ‫ﻋﻠﻢ اﻟﺤ ﺴﺎ ب‬ ‫‪EOF‬‬ ‫اﺳﻢ‬ ‫ﺑﺤ ﺚ ﻋﻦ‬

‫ا‬ ‫ﺘﺸﻐﻴﻞ‬
‫ﻧﻈﺎم اﻟ‬
‫ﺘﺐ‬
‫ﻳﻜ‬ ‫ﻗﻴﻤ ﺔ‬
‫ﺧﻄﺄ‬ ‫ﺧﻄﺄ‬ ‫ﺧﻄﺄ‬ ‫ﺧﻄﺄ‬ ‫ﺧﻄﺄ‬ ‫ﺧﻄﺄ‬ ‫ﺧﻄﺄ‬ ‫ﺧﻄﺄ‬
‫ﺗﻘ ﺴﻴﻢ اﻟﺼﻔﺮي‬ ‫ِس‬

‫ِﻬﺮ‬
‫ﻓ‬ ‫ﺜﻮر ﻋﲆ اﻟﻤﻠﻒ‬
‫ﺘﻢ اﻟﻌ‬
‫ﻟﻢﻳ‬
‫ﺧﻄﺄ‬ ‫ﺧﻄﺄ‬ ‫ﺧﻄﺄ‬
‫اﻟﻨﻘﻄ ﺔ اﻟﻌﺎﺋﻤ ﺔ‬ ‫ﺘﺎح‬

‫ﻣﻔ‬ ‫ﺗﻮﻗﻒ‬
‫ﺧﻄﺄ‬ ‫ﺧﻄﺄ‬ ‫ﺧﻄﺄ‬
‫ﺗﺠﺎوز‬ ‫إذن‬
‫ﺧﻄﺄ‬ ‫ﺧﻄﺄ‬
‫ﻧﻔﺬ اﻟﻮﻗ ﺖ‬
‫ﺧﻄﺄ‬
‫ﺜﻨﺎء‬
‫ﺘ‬‫ﺜﻨﺎءا ت ﻫ ﻲ ﻓﺌﺎ ت ﻓﺮﻋﻴ ﺔ ﻣﻦ ‪BaseException.ie‬ﻛﻞ ﻓﺌ ﺔ اﺳ‬
‫ﺘ‬‫ﺜﻮن ﻫﻮ ﻓﺌ ﺔ‪• .‬ﺟﻤﻴﻊ ﻓﺌﺎ ت اﻻﺳ‬
‫ﺑﺎﻳ‬‫ﺜﻨﺎء ﻓ ﻲ‬
‫ﺘ‬‫•ﻛﻞ اﺳ‬
‫ﺘ ﺴﻠ ﺴﻞ ‪Python Exception.‬‬
‫ﺛﻢ ‪،‬ﻳﻌﻤﻞ ‪BaseException‬ﻛﺠﺬر ﻟ‬‫ﺒﺎﺷﺮ‪ .‬وﻣﻦ‬
‫ﺒﺎﺷﺮ أو ﻏﻴﺮ ﻣ‬
‫ﺑﺸﻜﻞ ﻣ‬‫ﺘﺪ ‪BaseException‬إﻣﺎ‬
‫ﻳﻤ‬
‫ﺘﺮﻛﻴﺰ ﻋﲆ ‪Exception‬وﻃﻔﻠﻪ‬
‫ﺘﻌﻴﻦ ﻋﻠﻴﻨﺎ اﻟ‬
‫ﺒﺮﻣﺠﻴﻦ ﻓ ﻲ ﻣﻌﻈﻢ اﻷﺣﻴﺎن ‪،‬ﻳ‬
‫•ﻟﻜﻮﻧﻨﺎ ﻣ‬
‫ﺒﻘﺎ ت‪.‬‬
‫اﻟﻄ‬
‫‪86‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺜﻨﺎء‪:‬‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺘﺨﺪام اﻟﻤﺤﺎوﻟ ﺔ‬
‫ﺑﺎﺳ‬‫ﺜﻨﺎءا ت اﻟﻤﺨﺼﺼ ﺔ‬
‫ﺘ‬‫ﻣﻌﺎﻟﺠ ﺔ اﻻﺳ‬
‫ﺜﻨﺎءا ت‪.‬‬
‫ﺘ‬‫ﺑﻤﻌﺎﻟﺠ ﺔ اﻻﺳ‬‫ﺑﺸﺪة‬‫•ﻳﻮﺻﻰ‬
‫ﺘﻠ ﺔ ‪try.‬رﻣﺰ اﻟﻤﻨﺎوﻟ ﺔ‬
‫ﺑﺎﻟﻤﺨﺎﻃﺮ داﺧﻞ ﻛ‬‫ﺑﺮﻣﺠﻴ ﺔ ﻣﺤﻔﻮﻓ ﺔ‬‫ﺘﻌﺎﻣﻞ ﻣﻊﺗﻌﻠﻴﻤﺎ ت‬
‫ﺑﺎﻟﻤﺨﺎﻃﺮ وﻋﻠﻴﻨﺎ أن ﻧ‬ ‫ً‬
‫ﻣﺤﻔﻮﻓﺎ‬ ‫ﺜﻨﺎء رﻣ ًﺰا‬
‫ﺘ‬‫ﺜﻴﺮ اﻻﺳ‬
‫ُﻄﻠﻖ ﻋﲆ اﻟﻜﻮد اﻟﺬي ﻗﺪﻳ‬
‫•ﻳ‬
‫ﺘﻠ ﺔ‪.‬‬
‫ﺜﻨﺎء اﻟﻜ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺑﻞ اﻟﺬيﻳﺠ ﺐ أن ﻧﺄﺧﺬه ﻓ ﻲ اﻟﺪاﺧﻞ‬
‫اﻟﻤﻘﺎ‬
‫ﺑﺎﻟﻤﺨﺎﻃﺮ‬‫رﻣﺰ ﻣﺤﻔﻮف‬
‫ﺜﻨﺎء ‪XXX:‬‬
‫ﺑﺪﻳﻞ‬‫ﺘﻌﺎﻣﻞ ﻣﻊ رﻣﺰ ‪ /‬رﻣﺰ‬
‫اﻟ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺑﺪون ﻣﺤﺎوﻟ ﺔ‬
‫ﺒﺎﻋ ﺔ )‪("stmt-1") 2‬‬

‫)‪1‬ﻃ‬
‫ﺒﺎﻋ ﺔ‬
‫ﺒﺎﻋ ﺔ )‪(10/0) 3‬ﻃ‬
‫ﻃ‬
‫)"‪("stmt-3‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫‪stmt-1‬‬
‫ﺒﻴﻌ ﻲ ‪ /‬إﻧﻬﺎء ﻏﻴﺮ رﺷﻴﻖ‬
‫إﻧﻬﺎء ﻏﻴﺮ ﻃ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﻣﻊ اﻟﻤﺤﺎوﻟ ﺔ‬
‫)‪1) print ("stmt-1") 2‬ﺟﺮ ب‪3) 4) :‬‬

‫ﺜﻨﺎء )"‪("stmt-3‬‬
‫)‪print (10/0‬‬
‫‪ZeroDivisionError:‬‬
‫‪(10/2) 6) print‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫‪stmt-1‬‬
‫‪5.0 stmt-3‬إﻧﻬﺎء ﻋﺎدي ‪ /‬إﻧﻬﺎء ﻟﻄﻴﻒ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺘﺪﻓﻖ ﻓ ﻲ اﻟﻤﺤﺎوﻟ ﺔ‬
‫ﺘﺤﻜﻢ ﻓ ﻲ اﻟ‬
‫اﻟ‬
‫‪stmt-1‬‬
‫‪stmt-2‬‬
‫‪stmt-3‬‬
‫ﺜﻨﺎء ‪XXX:‬‬
‫‪stmt-4‬‬
‫‪stmt-5‬‬
‫‪87‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺜﻨﺎء‬
‫ﺘ‬‫اﻟﺤﺎﻟ ﺔ ‪1:‬إذا ﻟﻢﻳﻜﻦ ﻫﻨﺎك اﺳ‬
‫‪1 ، 2 ، 3 ، 5‬واﻹﻧﻬﺎء اﻟﻌﺎدي‬
‫ﺑﻘ ﺔ‬
‫ﺘﻄﺎ‬
‫ﺘﻠ ﺔ اﻟﻤ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺑﻠﻬﺎ‬
‫ﺜﻨﺎء ﻓ ﻲ ‪stmt-2‬وﻣﺎﻳﻘﺎ‬
‫ﺘ‬‫ﺛﻴﺮ اﺳ‬
‫اﻟﺤﺎﻟ ﺔ ‪2:‬إذا أ‬
‫‪1،4،5‬اﻹﻧﻬﺎء اﻟﻌﺎدي‬
‫ﺑﻘ ﺔ‬
‫ﺘﻄﺎ‬
‫ﺘﻠ ﺔ ﻏﻴﺮ ﻣ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺑﻠ ﺔ‬
‫ﺘﻠ ﺔ اﻟﻤﻘﺎ‬
‫ﺜﻨﺎء ﻋﻨﺪ ‪stmt-2‬وﻛﺎﻧ ﺖ اﻟﻜ‬
‫ﺘ‬‫اﻟﺤﺎﻟ ﺔ ‪3:‬إذا ﻇﻬﺮ اﺳ‬
‫ﺒﻴﻌ ﻲ‬
‫‪1 ،‬إﻧﻬﺎء ﻏﻴﺮ ﻃ‬
‫ﺋﻤﺎ إﻧﻬﺎء ﻏﻴﺮ ﻃ‬
‫ﺜﻨﺎء ﻓ ﻲ ‪stmt-4‬أو ‪stmt-5 ،‬ﻓﻬﺬاﻳﻌﻨ ﻲ دا ً‬
‫ﺘ‬‫اﻟﺤﺎﻟ ﺔ ‪4:‬إذا ﻇﻬﺮ اﺳ‬
‫ﺘﺎﺟﺎ ت‪:‬‬
‫ﺘﻨ‬‫اﻻﺳ‬
‫ﺘﻌﻴﻦ ﻋﻠﻴﻨﺎ‬
‫ﺛﻢﻳ‬‫ﺜﻨﺎء‪ .‬وﻣﻦ‬
‫ﺘ‬‫ﺘﻠ ﺔ ‪try‬ﻋﲆ اﻟﺮﻏﻢ ﻣﻦ أﻧﻨﺎﺗﻌﺎﻣﻠﻨﺎ ﻣﻊ ﻫﺬا اﻻﺳ‬
‫ﺑﻘﻴ ﺔ ﻛ‬‫ﺘﻢﺗﻨﻔﻴﺬ‬
‫ﺜﻨﺎء ﻓ ﻲ أي ﻣﻜﺎن ‪ ،‬ﻓﻠﻦﻳ‬
‫ﺘ‬‫ﺘﻠ ﺔ ‪try‬ﻓ ﻲ ﺣﺎﻟ ﺔ ﻇﻬﻮر اﺳ‬
‫)‪1‬داﺧﻞ ﻛ‬
‫ﺘﻠ ﺔ اﻟﻤﺤﺎوﻟ ﺔ أﻗﻞ ﻣﺎﻳﻤﻜﻦ‪.‬‬
‫ﺘﻠ ﺔ اﻟﻤﺤﺎوﻟ ﺔ وﻳﺠ ﺐ أنﻳﻜﻮن ﻃﻮل ﻛ‬
‫ﺑﺎﻟﻤﺨﺎﻃﺮ ﻓﻘﻂ داﺧﻞ ﻛ‬ ‫ً‬
‫ﻣﺤﻔﻮﻓﺎ‬ ‫أن ﻧﺄﺧﺬ رﻣ ًﺰا‬
‫ﺘﻞ أ ً‬
‫ﻳﻀﺎ‪.‬‬ ‫ﺜﻨﺎء اﻟﻜ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺜﻨﺎءا ت ﻓ ﻲ اﻟﺪاﺧﻞ‬
‫ﺘ‬‫ﺘﻠ ﺔ اﻟﻤﺤﺎوﻟ ﺔ ‪ ،‬ﻗﺪﺗﻜﻮن ﻫﻨﺎك ﻓﺮﺻ ﺔ ﻟﺮﻓﻊ اﻻﺳ‬
‫ﺑﺎﻹﺿﺎﻓ ﺔ إﱃ ﻛ‬
‫)‪2‬‬
‫ﺋﻤﺎ‬
‫ﺜﻨﺎ ًء ‪ ،‬ﻓﻬ ﻲ دا ً‬
‫ﺘ‬‫ﺘﻠ ﺔ ‪try‬اﺳ‬
‫ﺒﺎرة ﻟﻴ ﺴ ﺖ ﺟﺰءًا ﻣﻦ ﻛ‬
‫ﺛﺎر ت أي ﻋ‬
‫)‪3‬إذا أ‬
‫إﻧﻬﺎء ﻏﻴﺮ ﻃ‬
‫ﺘ‬‫ﺒﺎﻋ ﺔ ﻣﻌﻠﻮﻣﺎ ت اﻻﺳ‬
‫ﻛﻴﻔﻴ ﺔ ﻃ‬
‫ﺜﻨﺎء‬
‫ﺘ‬‫ﺜﻨﺎء ‪ZeroDivisionError‬ﻛـ ‪")msg: 3) print‬اﺳ‬
‫)‪1) print (10/0) 2‬‬
‫ﺜﺎر ووﺻﻔﻪ ﻫﻮ‪msg) ،":‬‬
‫ُﻣ‬
‫ﺗﺞ ووﺻﻔﻪ ﻫﻮ ‪ :‬اﻟﻘ ﺴﻤ ﺔ ﻋﲆ ﺻﻔﺮ‬

‫ﺜﻨﺎء اﻟﻨﺎ‬
‫أ‬
‫ﺘﻞ‪:‬‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺘﻌﺪدة‬
‫ﺘﻞ اﻟﻤ‬
‫ﺟﺮ ب ﻣﻊ اﻟﻜ‬
‫ﺘﻌﻴﻦ ﻋﻠﻴﻨﺎ‬
‫ﺘ ﻲﻳ‬
‫ﺘﻠ ﺔ اﻟ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺜﻨﺎءا ت ﻣﻨﻔﺼﻠ ﺔ‬
‫ﺘ‬‫ﺜﻨﺎء ‪ ،‬ﻟﺬﻟﻚ ﻓﻠﻜﻞ ﻧﻮع ﻣﻦ أﻧﻮاع اﻻﺳ‬
‫ﺘ‬‫ﺜﻨﺎء إﱃ اﺳ‬
‫ﺘ‬‫ﺜﻨﺎء ﻣﻦ اﺳ‬
‫ﺘ‬‫ﺘﻌﺎﻣﻞ ﻣﻊ اﻻﺳ‬
‫ﺘﻨﻮع ﻃﺮﻳﻘ ﺔ اﻟ‬
‫ﺗ‬
‫ﺘﺨﺪاﻣﻪ‪.‬‬
‫ﺑﺎﺳ‬‫ﺜﻨﺎء أﻣﺮ ﻣﻤﻜﻦ وﻳﻮﺻﻰ‬
‫ﺘﻞ ﻣ‬
‫ﺜﺎل ‪ ،‬ﺣﺎول ﻣﻊ ﻛ‬
‫ﺗﻮﻓﻴﺮ ﻫﺎ‪ .‬ﻋﲆﺳ‬
‫ﺜﺎل‪:‬‬
‫ﻋﲆﺳ‬
‫‪-------‬‬
‫‪-------‬‬
‫‪-------‬‬
‫ﺜﻨﺎء ‪ZeroDivisionError:‬‬
‫ﺑﺪﻳﻠ ﺔ‬‫ﺑﻴ ﺔ‬
‫إﺟﺮاء ﻋﻤﻠﻴﺎ ت ﺣ ﺴﺎ‬
‫‪88‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺜﻨﺎء ‪FileNotFoundError:‬‬
‫ﺒﻌﻴﺪ‬
‫ﺑﺪﻻ ﻣﻦ اﻟﻤﻠﻒ اﻟ‬‫ﺘﺨﺪام اﻟﻤﻠﻒ اﻟﻤﺤﻠ ﻲ‬
‫اﺳ‬
‫ﺑﻘ ﺔ‪.‬‬
‫ﺜﻨﺎء اﻟﻤﻄﺎ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺘﻠ ﺔ‬
‫ﺘﻢﺗﻨﻔﻴﺬ اﻟﻜ‬
‫ﺑﺎرز ‪،‬ﺳﻴ‬‫ﺜﻨﺎء‬
‫ﺘ‬‫ﺑﻨﺎ ًء ﻋﲆ اﺳ‬‫ﺬ‬
‫ﺘﺎﺣ ﺔ ‪ ،‬ﻓﺤﻴﻨﺌ ٍ‬
‫ﺜﻨﺎء اﻟﻤ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺘﻞ‬
‫إذا ﺣﺎوﻟ ﺖ ﻣﻊ ﻋﺪة ﻛ‬
‫)‪1‬ﺟﺮ ب‪(input ("Enter Second Number: ")) 4) print (x / y) 5) :‬‬

‫ﺜﻨﺎء )‪7‬‬
‫‪2) x = int (input ("Enter First Number: ")) 3) y = int‬‬
‫ﺜﻨﺎء‬
‫)"‪ZeroDivisionError: 6 ) print ("Can't Divide with Zero‬‬
‫)"‪ValueError: 8) print ("please provide int value only‬‬
‫‪D: \ Python_classes> py test.py‬أدﺧﻞ اﻟﺮﻗﻢ‬

‫اﻷول‪10 :‬‬
‫ﺜﺎﻧ ﻲ‪2 :‬‬
‫أدﺧﻞ اﻟﺮﻗﻢ اﻟ‬
‫‪5.0‬‬

‫ﺜﺎﻧ ﻲ‪0 :‬‬
‫اﻷول‪10 :‬أدﺧﻞ اﻟﺮﻗﻢ اﻟ‬
‫ﻻﻳﻤﻜﻦ اﻟﻘ ﺴﻤ ﺔ ﻋﲆ اﻟﺼﻔﺮ‬

‫ﺜﺎﻧ ﻲ‪ :‬ﻋﺸﺮة‬
‫اﻷول‪10 :‬أدﺧﻞ اﻟﺮﻗﻢ اﻟ‬
‫ﻳﺮﺟﻰﺗﻘﺪﻳﻢ ﻗﻴﻤ ﺔ ‪int‬ﻓﻘﻂ‬
‫ﺋﻤﺎ ﻣﻦ أﻋﲆ‬
‫ﺒﺎر دا ً‬
‫ﺘ‬‫ﺜﻮن ﻓ ﻲ اﻻﻋ‬
‫ﺑﺎﻳ‬‫ﺘﺮﺟﻢ‬
‫ﺘﻞ ﻣﻬﻢ‪.‬ﺳﻴﺄﺧﺬ ﻣ‬
‫ﺗﻴ ﺐ ﻫﺬه اﻟﻜ‬
‫ﺘﺎﺣ ﺔ ‪ ،‬ﻓﺈنﺗﺮ‬
‫ﺘﻞ اﻟﻤ‬
‫إذا ﺣﺎوﻟ ﺖ ﻣﻊ اﻟﻜ‬
‫ﺘﻠ ﺔ اﻟﻤﺤﺪدة‪.‬‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺑﻖ‬
‫ﺘﻄﺎ‬
‫ﺘﻢ اﻟ‬
‫ﺘﻰﻳ‬
‫إﱃ أﺳﻔﻞ ﺣ‬
‫)‪1‬ﺟﺮ ب‪(input ("Enter Second Number: ")) 4) print (x / y) 5) :‬‬

‫ﺜﻨﺎء )‪7‬‬
‫‪2) x = int (input ("Enter First Number: ")) 3) y = int‬‬
‫ﺜﻨﺎء‬
‫)"‪ArithmeticError: 6 ) print ("ArithmeticError‬‬
‫)"‪ZeroDivisionError: 8) print ("ZeroDivisionError‬‬
‫‪D: \ Python_classes> py test.py‬أدﺧﻞ اﻟﺮﻗﻢ اﻷول‪10 :‬‬
‫‪89‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺜﺎﻧ ﻲ‪0 :‬‬

‫ﺑﻲ‬
‫ﺧﻄﺄ ﺣ ﺴﺎ‬
‫ﺘﻌﺪدة‪:‬‬
‫ﺜﻨﺎءا ت ﻣ‬
‫ﺘ‬‫ﺘﻌﺎﻣﻞ ﻣﻊ اﺳ‬
‫ﺘ ﻲﻳﻤﻜﻨﻬﺎ اﻟ‬
‫ﺘﻠ ﺔ اﻟ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫واﺣﺪ‬
‫ﺘ‬‫ﺘﻠﻔ ﺔ ﻣﻦ اﻻﺳ‬
‫ﺘﻌﺎﻣﻞ ﻣﻊ ﻋﺪة أﻧﻮاع ﻣﺨ‬
‫ﺘ ﻲﻳﻤﻜﻨﻬﺎ اﻟ‬
‫ﺜﻨﺎء اﻟ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺘﻠ ﺔ واﺣﺪة‬
‫ﺑﺔ ﻛ‬
‫ﺘﺎ‬
‫ﺜﻨﺎء ‪3 ، ..):‬أو‬
‫ﺘ‬‫ﺜﻨﺎء ‪2 ،‬اﺳ‬
‫ﺘ‬‫ﺜﻨﺎء )اﺳ‬
‫ﺜﻨﺎء )‪3 ، ..‬ﻛﺮﺳﺎﻟ ﺔ‪:‬‬
‫ﺘ‬‫ﺜﻨﺎء )اﺳ‬
‫ﺜﻨﺎءا ت داﺧﻠ ًﻴﺎ ﻋﲆ أﻧﻬﺎ ‪tuple.‬‬

‫ﺘ‬‫ﺒﺮ ﻫﺬه اﻟﻤﺠﻤﻮﻋ ﺔ ﻣﻦ اﻻﺳ‬
‫اﻷﻗﻮاس إﻟﺰاﻣﻴ ﺔ و‬
‫)‪1‬ﺟﺮ ب‪("Enter First Number: ")) 3) y = int (input ("Enter Second Number: ")) 4) print (x / y) 5) :‬‬
‫ﺒﺎﻋ ﺔ )"اﻟﺮﺟﺎءﺗﻘﺪﻳﻢ أرﻗﺎم‬
‫ﺜﻨﺎء )‪(ZeroDivisionError ، ValueError‬ﻛـ )‪msg: 6‬ﻃ‬
‫‪2) x = int (input‬‬
‫ﺻﺎﻟﺤ ﺔ ﻓﻘﻂ واﻟﻤﺸﻜﻠ ﺔ ﻫ ﻲ‪" ، msg) :‬‬
‫ﺜﺎﻧ ﻲ‪0 :‬‬

‫اﻟﺮﺟﺎءﺗﻘﺪﻳﻢ أرﻗﺎم ﺻﺎﻟﺤ ﺔ ﻓﻘﻂ واﻟﻤﺸﻜﻠ ﺔ ﻫ ﻲ ‪ :‬اﻟﻘ ﺴﻤ ﺔ ﻋﲆ ﺻﻔﺮ‬
‫ﺜﺎﻧ ﻲ‪ :‬ﻋﺸﺮة اﻟﺮﺟﺎءﺗﻘﺪﻳﻢ أرﻗﺎم ﺻﺎﻟﺤ ﺔ ﻓﻘﻂ واﻟﻤﺸﻜﻠ ﺔ ﻫ ﻲ‪ :‬ﺣﺮﻓﻴ ﺔ ﻏﻴﺮ ﺻﺎﻟﺤ ﺔ‬
‫‪D: \ Python_classes> py test.py‬أدﺧﻞ اﻟﺮﻗﻢ اﻷول‪10 :‬أدﺧﻞ اﻟﺮﻗﻢ اﻟ‬
‫ﻟـ )( ‪int‬ﻣﻊ ‪ b‬ﻫ ﻲ '‪10: 'ten‬‬
‫ﺜﻨﺎء اﻟﺤﻈﺮ‪:‬‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺘﺮاﺿ ﻲ‬
‫اﻻﻓ‬
‫ﺘ‬‫ﺘﻌﺎﻣﻞ ﻣﻊ أي ﻧﻮع ﻣﻦ اﻻﺳ‬
‫ﺘﺮاﺿﻴ ﺔ ﻟﻠ‬
‫ﺜﻨﺎء اﻻﻓ‬
‫ﺘ‬‫ﺘﻠ ﺔ اﻻﺳ‬
‫ﺘﺨﺪام ﻛ‬
‫ﺒﺎﻋ ﺔ رﺳﺎﺋﻞ اﻟﺨﻄﺄ اﻟﻌﺎدﻳ ﺔ‪.‬‬
‫ﺘﻠ ﺔ ‪،‬ﻳﻤﻜﻨﻨﺎ ﻃ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺑﻨﺎء اﻟﺠﻤﻠ ﺔ‪:‬‬
‫ﺻﻴﺎﻏﺎ ت‬
‫)‪1‬ﺟﺮ ب‪")) 3) y = int (input ("Enter Second Number: ")) 4) print (x / y) 5) :‬‬
‫ﺜﻨﺎء ‪6 ) print ("ZeroDivisionError:‬‬
‫‪2) x = int (input ("Enter First Number:‬‬
‫ﺜﻨﺎء‪Plz :‬‬
‫ﺜﻨﺎء‪")8) print :‬اﻓ‬
‫ﺑﺼﻔﺮ"( )‪7‬‬‫‪ZeroDivisionError:‬ﻻﻳﻤﻜﻦ اﻟﻘ ﺴﻤ ﺔ‬
‫ً‬
‫إدﺧﺎﻻ ﺻﺎﻟﺤًﺎ ﻓﻘﻂ"(‬ ‫ﺗﻮﻓﺮ‬
‫‪90‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫‪D: \ Python_classes> py test.py‬أدﺧﻞ‬

‫ﺜﺎﻧ ﻲ‪0 :‬‬
‫اﻟﺮﻗﻢ اﻷول‪10 :‬أدﺧﻞ اﻟﺮﻗﻢ اﻟ‬
‫‪ZeroDivisionError:‬ﻻﻳﻤﻜﻦ اﻟﻘ ﺴﻤ ﺔ ﻋﲆ ﺻﻔﺮ‬
‫ﺜﺎﻧ ﻲ‪ :‬ﻋﺸﺮة‬
‫ﺗﻮﻓﻴﺮ ﻣﺪﺧﻼ ت ﺻﺎﻟﺤ ﺔ ﻓﻘﻂ‬

‫ﺜﻨﺎء‪Plz :‬‬
‫اﻻﻓ‬
‫ﺜﻨﺎء اﻟﺤﻈﺮ‬
‫ﺘﺎﺣ ﺔ ‪ ،‬ﻓﻴﺠ ﺐ أنﻳﻜﻮن اﻟﻮﺿﻊ اﻻﻓ‬
‫***ﻣﻼﺣﻈ ﺔ‪ :‬إذا ﺣﺎوﻟ ﺖ ﻣﻊ اﻟﻌﺪﻳﺪ ﻣﻦ اﻟﻜ‬
‫ﺑﻨﺎء اﻟﺠﻤﻠ ﺔ‪.‬‬‫أﺧﻴ ﺮًا ‪ ،‬وإﻻ ﻓ ﺴﻨﺤﺼﻞ ﻋﲆ ﺧﻄﺄ ﻓ ﻲ‬
‫ﺜﻨﺎء‪5) :‬‬
‫)‪1‬ﺟﺮ ب‪print (10/0) 2) 3) :‬‬
‫ﺜﻨﺎء‬
‫ﺘ‬‫ﺳ‬
‫ﺑﺎ)‪6‬‬
‫‪print‬‬
‫)"‪("ZeroDivisionError‬‬
‫)"‪("Default except‬‬
‫‪ZeroDivisionError:‬‬
‫ﺜﻨﺎء‪':‬ﻳﺠ ﺐ أنﻳﻜﻮن اﻷﺧﻴﺮ‬

‫ﺘﺮاﺿ ﻲ '‬
‫‪SyntaxError:‬اﻻﻓ‬
‫ﺘﻞ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺘﻨﻮﻋ ﺔ ﻣﻦ اﻟﻤﺠﻤﻮﻋﺎ ت اﻟﻤﻤﻜﻨ ﺔ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬ﻓﻴﻤﺎﻳﻠ ﻲ ﻣﺠﻤﻮﻋ ﺔ ﻣ‬
‫ﺜﻨﺎء ‪ZeroDivisionError:‬‬
‫)‪1‬‬
‫ﺜﻨﺎء ‪ZeroDivisionError‬ﻛـ ‪msg:‬‬
‫)‪2‬‬
‫ﺜﻨﺎء ‪(ZeroDivisionError، ValueError):‬‬
‫)‪3‬‬
‫ﺜﻨﺎء )‪(ZeroDivisionError، ValueError‬ﻛـ ‪msg:‬‬
‫)‪4‬‬
‫)‪5‬‬
‫أﺧﻴ ﺮًا ﺣﻈﺮ‪:‬‬

‫ﺘﻨﻔﻴﺬ‬
‫ﺘﻠ ﺔ اﻟﻤﺤﺎوﻟ ﺔﻷﻧﻪ ﻻﻳﻮﺟﺪ ﺿﺎﻣﻦ ﻟ‬
‫ﺘﻨﻈﻴﻒ )ﻛﻮد إﻟﻐﺎءﺗﺨﺼﻴﺺ اﻟﻤﻮرد أو ﻛﻮدﺗﺤﺮﻳﺮ اﻟﻤﻮرد( داﺧﻞ ﻛ‬
‫ﺑﺎﻟﺤﻔﺎظ ﻋﲆ ﻛﻮد اﻟ‬‫ﻻﻳﻮﺻﻰ‬
‫ﺋﻤﺎ‪.‬‬
‫ﺘﻠ ﺔ ‪try‬دا ً‬
‫ﻛﻞ ﺟﻤﻠ ﺔ داﺧﻞ ﻛ‬
‫ﺘﻠ ﺔ ‪،‬ﻷﻧﻪ إذا ﻛﺎن ﻫﻨﺎك‬

‫ﺘ‬‫ﺑﺎﺳ‬‫ﺑﺎﻟﺪاﺧﻞ‬‫ﺘﻨﻈﻴﻒ‬
‫ﺑﺎﻟﺤﻔﺎظ ﻋﲆ ﻛﻮد اﻟ‬‫ﻻﻳﻮﺻﻰ‬
‫ﺘﻢﺗﻨﻔﻴﺬ ﻫﺎ‪.‬‬
‫ﺘﻠ ﺔ ﻟﻦﻳ‬
‫ﺜﻨﺎء ﻛ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺛﻢ‬‫ﺜﻨﺎء‬
‫ﺘ‬‫ﻟﻴ ﺴ ﺖ اﺳ‬
‫ﺛﻴﺮ أم ﻻ وﻣﺎ إذا ﻛﺎن‬

‫ﺜﻨﺎء ﻗﺪ أ‬
‫ﺘ‬‫ﺑﻐﺾ اﻟﻨﻈﺮ ﻋﻤﺎ إذا ﻛﺎن اﻻﺳ‬‫ﺋﻤﺎ‬ ‫ﺒﻨﺎ ﻣﻜﺎﻧًﺎ ﻣﺎ ﻟﻠﺤﻔﺎظ ﻋﲆ رﻣﺰ اﻟ‬
‫ﺘﻨﻈﻴﻒ اﻟﺬيﻳﺠ ﺐﺗﻨﻔﻴﺬه دا ً‬ ‫ﺛﻢ ﻓﻘﺪ ﻃﻠ‬‫وﻣﻦ‬
‫ﺘﻠ ﺔ أﺧﻴ ﺮًا‪.‬‬
‫ﺜﻞ ﻫﺬا اﻟﻨﻮع ﻣﻦ أﻓﻀﻞ اﻷﻣﺎﻛﻦ ﻟﻴ ﺲﺳﻮى ﻛ‬
‫ﺘﻌﺎﻣﻞ ﻣﻌﻪ أم ﻻ‪ .‬ﻣ‬
‫ﺜﻨﺎءﺗﻢ اﻟ‬
‫ﺘ‬‫اﻻﺳ‬
‫ﺘﻨﻈﻴﻒ‪.‬‬
‫ﺘﻠ ﺔ اﻟﻨﻬﺎﺋﻴ ﺔ ﻫﻮ اﻟﺤﻔﺎظ ﻋﲆ رﻣﺰ اﻟ‬
‫ﺋﻴ ﺴ ﻲ ﻣﻦ اﻟﻜ‬
‫ﺛﻢ ﻓﺈن اﻟﻐﺮض اﻟﺮ‬‫وﻣﻦ‬
‫ﺑﺎﻟﻤﺨﺎﻃﺮ‬‫رﻣﺰ ﻣﺤﻔﻮف‬
‫ﺜﻨ ﻲ‪:‬‬
‫ﺘ‬‫ﻳﺴ‬
‫رﻣﺰ اﻟﻤﻨﺎوﻟ ﺔ‬
‫‪91‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫أﺧﻴﺮاً‪:‬‬
‫ﺘﻨﻈﻴﻒ‬
‫ﻛﻮد اﻟ‬
‫ﺜﻨﺎء أم ﻻ‪.‬‬
‫ﺜﻨﺎء أم ﻻ وﺳﻮاءﺗﻢ اﻟ‬
‫ﺘ‬‫ﺋﻤﺎﺳﻮاءﺗﻢ رﻓﻊ اﻻﺳ‬
‫ﺘﻢﺗﻨﻔﻴﺬ ﻫﺎ دا ً‬
‫ﺘﻠ ﺔ اﻟﻨﻬﺎﺋﻴ ﺔ ﻫﻮ أﻧﻪﺳﻴ‬
‫ﺗﺨﺼﺺ اﻟﻜ‬
‫ﺜﻨﺎء‬
‫ﺒﺎﻋ ﺔ )"ﺟﺮ ب"( )‪3‬‬

‫)‪1‬ﺟﺮ ب‪2) :‬ﻃ‬
‫ﺜﻨﺎء"(‬
‫ﺘا"(‬
‫ﺳﺮً‬‫ﺑﺎ‬
‫ﺒﺎﻋﺔﺔ )"‬
‫)"أﺧﻴ‬ ‫)‪4‬ﻃﻃ‬
‫ﺒﺎﻋ‬ ‫ﺜﻨﺎء‪6) :‬‬ ‫ﺘ‬‫ﺳ‬
‫أﺧﻴ ًﺮا‪:‬‬ ‫ﺑﺎ)‪5‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﺣﺎول ﻓ ﻲ‬
‫اﻟﻨﻬﺎﻳ ﺔ‬
‫ﺘﻌﺎﻣﻞ ﻣﻌﻪ‬
‫ﺜﻨﺎء وﻟﻜﻦﺗﻢ اﻟ‬
‫ﺘ‬‫اﻟﺤﺎﻟ ﺔ ‪-2:‬إذاﺗﻢ ﻃﺮح اﺳ‬
‫ﺒﺎﻋ ﺔ )‪4‬‬
‫ﺒﺎﻋ ﺔ )"ﺟﺮ ب"( )‪3‬ﻃ‬
‫)‪1‬ﺟﺮ ب‪2) :‬ﻃ‬
‫ﺒﺎﻋ ﺔ‬
‫‪ZeroDivision:‬ﻃ‬
‫ﺒﺎﻋ ﺔ )"أﺧﻴ ﺮًا"(‬ ‫ﺧﻄﺄا‪5) :‬‬
‫)‪7‬ﻃ‬ ‫ﺜﻨﺎءأﺧﻴ ﺮً‬
‫ﺘ )‪6‬‬ ‫ﺑﺎﺳ‬ ‫)‪(10/0‬‬
‫ﺜﻨﺎء"(‬‫ﺘ‬‫ﺑﺎﺳ‬‫)"‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﺣﺎول إﻻ ﻓ ﻲ‬
‫اﻟﻨﻬﺎﻳ ﺔ‬
‫ﺘﻌﺎﻣﻞ ﻣﻌﻪ‬
‫ﺘﻢ اﻟ‬
‫ﺜﻨﺎء وﻟﻜﻦ ﻟﻢﻳ‬
‫ﺘ‬‫اﻟﺤﺎﻟ ﺔ ‪3:‬إذاﺗﻢ ﻃﺮح اﺳ‬
‫ﺒﺎﻋ ﺔ )"ﺟﺮ ب"( )‪3‬‬

‫)‪1‬ﺟﺮ ب‪2) :‬ﻃ‬
‫ﺧﻄﺄ)‪6‬‬ ‫ﺜﻨﺎء‬
‫ﺜﻨﺎء"(‬‫ﺘ‬
‫ﺘ‬
‫ﺳ‬‫ﺳ‬ ‫ﺑﺎ‬
‫)‪")(10/0‬‬
‫ﺑﺎ‬ ‫ﺒﺎﻋ ﺔ‬ ‫ﺳﻢ‪4) :‬‬
‫)‪5‬ﻃ‬ ‫ﺒﺎﻋ ﺔ‬
‫ﻃ‬
‫اﻻ‬
‫ﺒﺎﻋ ﺔ )"أﺧﻴ ﺮًا"(‬
‫أﺧﻴ ﺮًا‪7) :‬ﻃ‬
‫‪92‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﺣﺎول ﻓ ﻲ اﻟﻨﻬﺎﻳ ﺔ‬
‫ﺒﻴﻌ ﻲ(‬
‫‪ZeroDivisionError:‬اﻟﻘ ﺴﻤ ﺔ ﻋﲆ ﺻﻔﺮ )إﻧﻬﺎء ﻏﻴﺮ ﻃ‬
‫ﺘﺨﺪم اﻟﺪاﻟ ﺔ ‪os._exit (0).‬‬

‫ﺘﻢﺗﻨﻔﻴﺬ اﻟﺤﻈﺮ اﻟﻨﻬﺎﺋ ﻲ ‪ ،‬أي ﻋﻨﺪﻣﺎ ﻧ ﺴ‬
‫***ﻣﻼﺣﻈ ﺔ‪ :‬ﻫﻨﺎك ﻣﻮﻗﻒ واﺣﺪ ﻓﻘﻂ ﺣﻴ ﺚ ﻟﻦﻳ‬
‫ﺘﻢﺗﻨﻔﻴﺬ أﺧﻴ ﺮًا‪.‬‬

‫ﺑﺎﻟﺬا ت ﻟﻦﻳ‬‫ﺘﻢ إﻏﻼق ‪Python Virtual Machine‬ﻧﻔ ﺴﻬﺎ ‪ ،‬وﻓ ﻲ ﻫﺬه اﻟﺤﺎﻟ ﺔ‬
‫ﺘﺨﺪم اﻟﺪاﻟ ﺔ ‪os._exit (0) ،‬ﻓ ﺴﻴ‬
‫ﻋﻨﺪﻣﺎ ﻧ ﺴ‬
‫ﺒﺎﻋ ﺔ‬
‫ﺘﻮرد )‪2‬ﺣﺎول‪3) :‬ﻃ‬
‫ﺗﺴ‬‫)‪1‬‬
‫)"ﺟﺮ ب"( )‪4) os._exit (0) 5‬‬
‫ﺒﺎﻋﺔﺔ‬
‫ﺒﺎﻋ‬
‫)‪8‬ﻃﻃ‬
‫ﺳﻢ‪:‬ا‪6) :‬‬
‫اﻻأﺧﻴ ًﺮ‬
‫ﺧﻄﺄ )‪7‬‬ ‫ﺜﻨﺎء‬
‫ﺜﻨﺎء"(‬‫ﺘ‬‫ﺘ‬
‫ﺳ‬‫ﺳ‬‫ﺑﺎ‬
‫ﺑﺎ‬
‫)"‬
‫)"أﺧﻴ ﺮًا"(‬
‫اﻹﺧﺮاج‪ :‬ﺣﺎول‬
‫)‪os._exit (0‬‬
‫ﺜﻞ ‪0‬رﻣﺰ اﻟﺤﺎﻟ ﺔ وﻳﺸﻴﺮ إﱃ اﻹﻧﻬﺎء اﻟﻌﺎدي‬
‫ﺣﻴ ﺚﻳﻤ‬
‫ﻫﻨﺎك اﻟﻌﺪﻳﺪ ﻣﻦ رﻣﻮز اﻟﺤﺎﻟ ﺔ اﻟﻤﻤﻜﻨ ﺔ‪.‬‬
‫ﺜﻨﺎء اﻟﻨﻬﺎﻳ ﺔ‪:‬‬

‫ﺘ‬‫ﺑﺎﺳ‬‫ﺘﺪﻓﻖ ﻓ ﻲ اﻟﻤﺤﺎوﻟ ﺔ‬
‫اﻟ‬
‫‪stmt-1‬‬
‫‪stmt-2‬‬
‫‪stmt-3‬‬
‫ﺜﻨ ﻲ‪:‬‬
‫‪stmt-4‬‬
‫‪stmt-5‬‬
‫‪stmt-6‬‬
‫ﺜﻨﺎء‬
‫‪1،2،3،5،6‬اﻹﻧﻬﺎء اﻟﻌﺎدي‬
‫ﺜﻨﺎء‬
‫ﺜﻨﺎء ﻛ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺑﻘ ﺔ‬
‫ﺜﻨﺎء ﻓ ﻲ ‪stmt2‬واﻟﻤﻄﺎ‬
‫‪1،4،5،6‬اﻹﻧﻬﺎء اﻟﻌﺎدي‬
‫‪93‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺑﻘ ﺔ‬
‫ﺘﻄﺎ‬
‫ﺑﻠ ﺔ ﻏﻴﺮ ﻣ‬
‫ﺘ‬‫ﺘﻠ ﺔ اﻻﺳ‬
‫ﺜﻨﺎء ﻋﻨﺪ ‪stmt2‬ﻟﻜﻦ ﻛ‬
‫ﺘ‬‫اﻟﺤﺎﻟ ﺔ ‪3:‬ﻓ ﻲ ﺣﺎﻟ ﺔ ﻇﻬﻮر اﺳ‬
‫ﺒﻴﻌ ﻲ‬
‫‪1،5‬إﻧﻬﺎء ﻏﻴﺮ ﻃ‬
‫ﺘﻠ ﺔ اﻟﻨﻬﺎﺋﻴ ﺔ‪.‬‬

‫ﺘﻢﺗﻨﻔﻴﺬ اﻟﻜ‬
‫ﺒﻞ أنﻳ‬
‫ﺒﻴﻌ ﻲ وﻟﻜﻦ ﻗ‬
‫ﺜﻨﺎء ﻋﻨﺪ ‪stmt4 ،‬ﻓ ﺴﻴﻜﻮن دا ً‬
‫ﺘ‬‫اﻟﺤﺎﻟ ﺔ ‪4:‬إذاﺗﻢ ﻃﺮح اﺳ‬
‫ﺒﻴﻌ ﻲ‬
‫ﺜﻨﺎء ﻓ ﻲ ‪stmt-5‬أو ‪stmt-6 ،‬ﻓﻬﻮ دا ً‬
‫ﺘﺪاﺧﻠ ﺔ‪:‬‬
‫ﺜﻨﺎء اﻟﻨﻬﺎﻳ ﺔ اﻟﻤ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺘﻞ اﻟﻤﺤﺎوﻟ ﺔ‬
‫ﻛ‬
‫ﺜﻨﺎء ‪block‬أو أﺧﻴ ﺮًا‪.‬‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺘﻞ ‪try-except-finally‬داﺧﻞ ‪try‬أو‬
‫ﻳﻤﻜﻨﻨﺎ أﺧﺬ اﻟﻜ‬
‫‪----------‬‬
‫‪----------‬‬
‫‪----------‬‬
‫‪-------------‬‬
‫‪--------------‬‬
‫‪--------------‬‬
‫ﺜﻨ ﻲ‪:‬‬
‫‪--------------‬‬
‫‪--------------‬‬
‫‪--------------‬‬
‫‪------------‬‬
‫ﺜﻨ ﻲ‪:‬‬
‫‪-----------‬‬
‫‪-----------‬‬
‫‪-----------‬‬
‫ﺘﻌﻴﻦ ﻋﻠﻴﻨﺎ أﺧﺬ ﻫﺎ‬

‫ﺘ ﻲﻳ‬
‫ﺑﺎﻟﻤﺨﺎﻃﺮ اﻟ‬‫ﺒﺮﻣﺠﻴ ﺔ اﻟﻤﺤﻔﻮﻓ ﺔ‬
‫ﺘﻌﻠﻴﻤﺎ ت اﻟ‬
‫ﺜﻴﺮ ﻣﻦ اﻟ‬
‫ﺘﻠ ﺔ اﻟﻤﺤﺎوﻟ ﺔ اﻟﺨﺎرﺟﻴ ﺔ واﻟﻜ‬
‫ﺘﻌﻴﻦ ﻋﻠﻴﻨﺎ أﺧﺬه داﺧﻞ ﻛ‬
‫ﺑﺎﻟﻤﺨﺎﻃﺮﻳ‬‫رﻣﺰ ﻋﺎم ﻣﺤﻔﻮف‬
‫ﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ‪ .‬إذا‬
‫ﺘﻠ ﺔ ﻫ ﻲ اﻟﻤ ﺴﺆوﻟ ﺔ ﻋﻦ اﻟ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺘﻠ ﺔ اﻟﺪاﺧﻠﻴ ﺔ‬
‫ﺜﻨﺎء ‪ ،‬ﻓﺈن اﻟﻜ‬
‫ﺘ‬‫ﺘﻠ ﺔ اﻟﻤﺤﺎوﻟ ﺔ اﻟﺪاﺧﻠﻴ ﺔ إذاﺗﻢ رﻓﻊ اﺳ‬
‫ﺘﻠ ﺔ اﻟﻤﺤﺎوﻟ ﺔ اﻟﺪاﺧﻠﻴ ﺔ‪ .‬داﺧﻞ ﻛ‬
‫داﺧﻞ ﻛ‬
‫ﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ‪.‬‬
‫ﺘﻠ ﺔ ﻫ ﻲ اﻟﻤ ﺴﺆوﻟ ﺔ ﻋﻦ اﻟ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺘﻠ ﺔ اﻟﺨﺎرﺟﻴ ﺔ‬
‫ﺘﻌﺎﻣﻞ ‪ ،‬ﻓﺈن اﻟﻜ‬
‫ﻛﺎن ﻏﻴﺮ ﻗﺎدر ﻋﲆ اﻟ‬
‫ﺘﻠ ﺔ اﻟﻤﺤﺎوﻟ ﺔ اﻟﺨﺎرﺟﻴ ﺔ"( )‪3‬ﺟﺮ ب‪:‬‬

‫ﺒﺎﻋ ﺔ )"ﻛ‬
‫)‪1‬ﺟﺮ ب‪2) :‬ﻃ‬
‫ﺒﺎﻋ ﺔ )‪(10/0) 5) 6‬‬
‫ﺘﻠ ﺔ اﻟﻤﺤﺎوﻟ ﺔ اﻟﺪاﺧﻠﻴ ﺔ"( ﻃ‬
‫)‪4‬ﻃ‬
‫)"اﻟﺠﺰء‬
‫)"اﻟﺠﺰء‬ ‫ﻃﺔ‬
‫ﺒﺎﻋ ﺔ‬‫ﺒﺎﻋ‬
‫‪ZeroDivisionError:‬ﻃ)‪9‬‬
‫ﺘﻠ ﺔ" ( )‪8‬أﺧﻴ ﺮًا‪:‬‬
‫ﺘ‬‫)‪7‬‬
‫ﺑﺎﺳ‬‫ﺜﻨﺎء‬‫ﺘ‬‫ﺑﺎﺳ‬
‫اﻟﺪاﺧﻠ ﻲ‬
‫اﻟﺪاﺧﻠ ﻲ أﺧﻴ ًﺮا"(‬
‫‪94‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺜﻨﺎء‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺒﺎﻋ ﺔ )"اﻟﺠﺰء اﻟﺨﺎرﺟ ﻲ‬
‫ﺜﻨﺎء‪11) :‬ﻃ‬
‫)‪10‬‬
‫ﺘﻠ ﺔ اﻟﺨﺎرﺟﻴ ﺔ‬
‫ﺒﺎﻋ ﺔ )"اﻟﻜ‬
‫ﺘﻠ ﺔ"( )‪12‬أﺧﻴ ﺮًا‪13) :‬ﻃ‬
‫اﻟﻜ‬
‫اﻟﻨﻬﺎﺋﻴ ﺔ"(‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﺘﻠ ﺔ اﻟﻤﺤﺎوﻟ ﺔ اﻟﺨﺎرﺟﻴ ﺔ‬
‫ﻛ‬
‫ﺘﻠ ﺔ اﻟﻤﺤﺎوﻟ ﺔ اﻟﺪاﺧﻠﻴ ﺔ‬
‫ﻛ‬
‫ﺘﻠ ﺔ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫اﻟﺪاﺧﻠﻴ ﺔ‬
‫ﺘﻠ ﺔ‬
‫ﺘﻠ ﺔ اﻟﺪاﺧﻠﻴ ﺔ أﺧﻴ ًﺮا اﻟﻜ‬
‫اﻟﻜ‬
‫اﻟﺨﺎرﺟﻴ ﺔ أﺧﻴ ﺮًا‬
‫ﺜﻨﺎء اﻟﻨﻬﺎﻳ ﺔ‪:‬‬

‫ﺘ‬‫ﺑﺎﺳ‬‫ﺘﺪاﺧﻠ ﺔ‬
‫ﺘﺪﻓﻖ ﻓ ﻲ اﻟﻤﺤﺎوﻟ ﺔ اﻟﻤ‬
‫اﻟ‬
‫‪stmt-1‬‬
‫‪stmt-2‬‬
‫‪stmt-3‬‬
‫‪stmt-4‬‬
‫‪stmt-5‬‬
‫‪stmt-6‬‬
‫ﺜﻨﺎء ‪X:‬‬
‫‪stmt-7‬‬
‫‪stmt-8‬‬
‫‪stmt-9‬‬
‫ﺜﻨﺎء ص‪:‬‬
‫‪stmt-10‬‬
‫‪stmt-11‬‬
‫‪stmt-12‬‬
‫ﺜﻨﺎء‬
‫‪1،2،3،4،5،6،8،9،11،12‬اﻹﻧﻬﺎء اﻟﻌﺎدي‬
‫ﺜﻨﺎء‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺑﻘ ﺔ‬
‫ﺜﻨﺎء ﻓ ﻲ ‪stmt-2‬واﻟﻤﻄﺎ‬
‫‪1،10،11،12‬اﻹﻧﻬﺎء اﻟﻌﺎدي‬
‫ﺑﻘ ﺔ‬
‫ﺘﻄﺎ‬
‫ﺑﻠ ﺔ ﻏﻴﺮ ﻣ‬
‫ﺜﻨﺎء ﻋﻨﺪ ‪stmt-2‬وﻛ‬
‫ﺘ‬‫اﻟﺤﺎﻟ ﺔ ‪3:‬إذاﺗﻢ رﻓﻊ اﺳ‬
‫ﺒﻴﻌ ﻲ‬
‫‪1،11 ،‬إﻧﻬﺎء ﻏﻴﺮ ﻃ‬
‫ﺑﻘ ﺔ‬
‫ﺘﻄﺎ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺜﻨﺎء ﻋﻨﺪ ‪stmt-5‬وداﺧﻠ ﻲ‬
‫‪1،2،3،4،7،8،9،11،12‬اﻹﻧﻬﺎء اﻟﻌﺎدي‬
‫‪95‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺑﻘ ﺔ‬
‫ﺘﻄﺎ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺑﻘ ﺔ وﻟﻜﻦ ﺧﺎرﺟﻴ ﺔ‬
‫ﺘﻄﺎ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺜﻨﺎء ﻋﻨﺪ ‪stmt-5‬وداﺧﻠ ﻲ‬
‫‪1،2،3،4،8،10،11،12 ،‬اﻹﻧﻬﺎء اﻟﻌﺎدي‬
‫ﺘﻞ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺘﻞ اﻟﺪاﺧﻠﻴ ﺔ واﻟﺨﺎرﺟﻴ ﺔ‬
‫ﺑﻘ ﺔ اﻟﻜ‬
‫ﺘﻢ ﻣﻄﺎ‬
‫ﺜﻨﺎء ﻋﻨﺪ ‪stmt-5‬وﻟﻢﺗ‬
‫ﺘ‬‫اﻟﺤﺎﻟ ﺔ ‪6:‬ﻓ ﻲ ﺣﺎﻟ ﺔ ﻇﻬﻮر اﺳ‬
‫ﺒﻴﻌ ﻲ‬
‫‪1،2،3،4،8،11 ،‬إﻧﻬﺎء ﻏﻴﺮ ﻃ‬
‫ﺑﻘ ﺔ‬
‫ﺘﻄﺎ‬
‫‪1،2،3 ،. ،. ،. ، 8،10،11،12 ،‬اﻹﻧﻬﺎء اﻟﻌﺎدي‬
‫ﺑﻘ ﺔ‬
‫ﺘﻄﺎ‬
‫ﺒﻴﻌ ﻲ‬
‫‪1،2،3 ،. ،. ،. ، 8،11 ،‬إﻧﻬﺎء ﻏﻴﺮ ﻃ‬
‫ﺑﻘ ﺔ‬
‫ﺘﻄﺎ‬
‫‪1،2،3 ،. ،. ،. ،. ، 10،11،12‬اﻹﻧﻬﺎء اﻟﻌﺎدي‬
‫ﺑﻘ ﺔ‬
‫ﺘﻄﺎ‬
‫ﺒﻴﻌ ﻲ‬
‫‪1،2،3 ،. ،. ،. ،. ، 11 ،‬إﻧﻬﺎء ﻏﻴﺮ ﻃ‬
‫ﺑﻘ ﺔ ‪1،2،3 ،. ،. ،. ،. ، 8،10،11،12 ،‬إﻧﻬﺎء ﻋﺎدي‬

‫ﺘﻠ ﺔ اﻟﻤﻄﺎ‬
‫ﺑﻘ ﺔ‬
‫ﺘﻄﺎ‬
‫ﺒﻴﻌ ﻲ‬
‫‪1،2،3 ،. ،. ،. ،. ، 8،11 ،‬إﻧﻬﺎء ﻏﻴﺮ ﻃ‬
‫ﺘﻢﺗﻨﻔﻴﺬ اﻟﺤﻈﺮ اﻟﻨﻬﺎﺋ ﻲ ‪(stmt-11).‬‬

‫ﺒﻴﻌ ﻲ ‪،‬ﺳﻴ‬
‫ﺒﻞ إﻧﻬﺎء ﻏﻴﺮ ﻃ‬
‫ﺒﻴﻌ ﻲ وﻟﻜﻦ ﻗ‬
‫ﺜﻨﺎء ﻓ ﻲ ‪stmt-10 ،‬ﻓﻬﻮ دا ً‬
‫ﺜﻨﺎء ﻓ ﻲ ‪stmt-11‬أو ‪stmt-12 ،‬ﻓﻬﻮ دا ً‬
‫ﺒﺎري ﻓ ﻲ اﻟﻨﻬﺎﻳ ﺔ‪.‬‬

‫ﺘﻢﺗﻨﻔﻴﺬ اﻟﺤﻈﺮ اﻹﺟ‬
‫ﺘﻠ ﺔ ‪try ،‬ﻓ ﺴﻴ‬
‫ﺘﺤﻜﻢ ﻓ ﻲ ﻛ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬إذاﺗﻢ إدﺧﺎل ﻋﻨﺼﺮ اﻟ‬
‫ﺘﻢﺗﻨﻔﻴﺬ اﻟﺤﻈﺮ ﻓ ﻲ اﻟﻨﻬﺎﻳ ﺔ‪.‬‬
‫ﺘﻠ ﺔ اﻟﻤﺤﺎوﻟ ﺔ ‪ ،‬ﻓﻠﻦﻳ‬
‫ﺘﺤﻜﻢ ﻓ ﻲ ﻛ‬
‫ﺘﻢ إدﺧﺎل ﻋﻨﺼﺮ اﻟ‬
‫إذا ﻟﻢﻳ‬
‫ﺜﻨﺎء‪-‬أﺧﻴ ﺮًا‪:‬‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺘﺨﺪام اﻟﻤﺤﺎوﻟ ﺔ‬
‫ﺑﺎﺳ‬‫آﺧﺮ ﺣﻈﺮ‬
‫ﺜﻨﺎءا ت‬
‫ﺘ‬‫ﺘﻠ ﺔ ‪else‬إذا وﻓﻘﻂ ﻓ ﻲ ﺣﺎﻟ ﺔ ﻋﺪم وﺟﻮد اﺳ‬
‫ﺘﻢﺗﻨﻔﻴﺬ ﻛ‬
‫ﺘﻞ ‪try-except-final block.‬ﺳﻴ‬
‫ﺘﺨﺪام ‪else‬ﻣﻊ ﻛ‬
‫ﺘﻠ ﺔ ‪try.‬‬
‫داﺧﻞ ﻛ‬
‫ﺘﻢﺗﻨﻔﻴﺬه إذا ﻛﺎن ﻫﻨﺎك‬

‫ﺜﻨﺎء‪:‬ﺳﻴ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺑﺎﻟﻤﺨﺎﻃﺮ‬‫رﻣﺰ ﻣﺤﻔﻮف‬
‫ﺜﻨﺎء داﺧﻞ اﻟﻤﺤﺎوﻟ ﺔ‬
‫‪96‬‬
‫ﺑﺎد ‪- 500038 ،‬‬ ‫ﺑﻴ ﺖ‬ ‫ﺘﺮ‪#‬‬
‫ﻳﻔﺎﻧﺎم ‪ ،‬أﻣﻴﺮ‬ ‫‪202،‬‬ ‫ﺑﻖ ‪2 ،‬‬
‫آﺧﺮ‪:‬‬
‫ﺜﻨﺎء داﺧﻞ اﻟﻤﺤﺎوﻟ ﺔ‬

‫ﺘ‬‫ﺘﻢﺗﻨﻔﻴﺬه إذا ﻟﻢﻳﻜﻦ ﻫﻨﺎك اﺳ‬
‫ﺳﻴ‬
‫ﺘﻪ‬
‫ﺘﻪ أو ﻋﺪم ﻣﻌﺎﻟﺠ‬
‫ﺜﻨﺎء أو ﻋﺪم رﻓﻌﻪ وﻣﻌﺎﻟﺠ‬
‫ﺘ‬‫ﺘﻢﺗﻨﻔﻴﺬهﺳﻮاءﺗﻢ رﻓﻊ اﻻﺳ‬
‫ﺳﻴ‬
‫ﺜﺎل‪:‬‬
‫ﻋﲆﺳ‬
‫ﺒﺎﻋ ﺔ )"ﺟﺮ ب"(‬

‫ﻃ‬
‫)‪(10/0‬‬ ‫ﺒﺎﻋ ﺔ ‪1‬‬
‫ﻃ‬
‫ﺜﻨ ﻲ‪:‬‬
‫ﺜﻨﺎء"(‬
‫ﺒﺎﻋ ﺔ )"‬
‫ﻃ‬
‫آﺧﺮ‪:‬‬
‫ﺒﺎﻋ ﺔ )"آﺧﺮ"(‬
‫ﻃ‬
‫ﻃ‬
‫ﺜﻨﺎء داﺧﻞ اﻟﻤﺤﺎوﻟ ﺔ‪.‬‬

‫ﺘ‬‫ﺘﻠ ﺔ وإﻻ ﻓﻠﻦﻳﻜﻮن ﻫﻨﺎك اﺳ‬
‫ﺘﻢﺗﻨﻔﻴﺬ ﻛ‬
‫ﺘﻌﻠﻴﻖ ﻋﲆ اﻟ ﺴﻄﺮ ‪1 ،‬ﻓ ﺴﻴ‬
‫ﺑﺎﻟ‬‫إذا ﻗﻤﻨﺎ‬
‫ﺗﺞ‪:‬‬
‫ﻓ ﻲ ﻫﺬه اﻟﺤﺎﻟ ﺔﻳﻜﻮن اﻟﻨﺎ‬
‫ﻳﺤﺎول‬
‫آﺧﺮ‬
‫أﺧﻴﺮا ً‬
‫ﺗﺞ‪:‬‬
‫ﺘﻠ ﺔ ‪try.‬ﻓ ﻲ ﻫﺬه اﻟﺤﺎﻟ ﺔﻳﻜﻮن اﻟﻨﺎ‬
‫ﺜﻨﺎء داﺧﻞ ﻛ‬
‫ﺘ‬‫ﺘﻢﺗﻨﻔﻴﺬ اﻟﺤﻈﺮ وإﻻ ﻓ ﺴﻴﻜﻮن ﻫﻨﺎك اﺳ‬
‫ﺘﻌﻠﻴﻖ ﻋﲆ اﻟ ﺴﻄﺮ اﻷول ‪ ،‬ﻓﻠﻦﻳ‬
‫ﺑﺎﻟ‬‫إذا ﻟﻢ ﻧﻘﻢ‬
‫ﻳﺤﺎول‬
‫ﺜﻨ ﻲ‬
‫أﺧﻴﺮا ً‬
‫ﺘﻠﻔ ﺔ ﻣﻤﻜﻨ ﺔ ﻣﻦ ‪try-except-else-finally:‬‬

‫ﻣﺠﻤﻮﻋﺎ ت ﻣﺨ‬
‫ﺑ ﺔ ‪try block.‬‬
‫ﺘﺎ‬
‫ﺜﻨﺎء أو ﻓ ﻲ اﻟﻨﻬﺎﻳ ﺔ ﻻﻳﻤﻜﻨﻨﺎ ﻛ‬
‫ﺘ‬‫ﺘ ﺐ ﻣﺎ ﻋﺪا أو ‪block.ie‬ﻓ ﻲ اﻟﻨﻬﺎﻳ ﺔ دون اﺳ‬
‫ﺘﻠ ﺔ ‪try ،‬ﻳﺠ ﺐ أن ﻧﻜ‬
‫ﺘﺐ ﻛ‬
‫)‪1‬ﻋﻨﺪﻣﺎ ﻧﻜ‬
‫ﺑﺪون ﻣﺤﺎوﻟ ﺔ ﻫﻮ داﺋﻤﺎ ﻏﻴﺮ ﺻﺎﻟﺢ‪.‬‬‫ﺘﻠ ﺔ ‪try.‬أي ﻣﺎ ﻋﺪا‬

‫ﺘﺐ ﻛ‬
‫ﺘﻠ ﺔ ‪،‬ﻳﺠ ﺐ أن ﻧﻜ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺘ ﺐ ﻓﻴﻪ‬
‫)‪2‬ﻓ ﻲ أي وﻗ ﺖ ﻧﻜ‬
‫ﺘﻠ ﺔ ‪try.‬أي أﺧﻴﺮا دون ﻣﺤﺎوﻟ ﺔ ﻫﻮ داﺋﻤﺎ ﻏﻴﺮ ﺻﺎﻟﺢ‪.‬‬

‫ﺘﺐ ﻛ‬
‫ﺑﺸﻜﻞ ﻧﻬﺎﺋ ﻲ ‪،‬ﻳﺠ ﺐ أن ﻧﻜ‬‫ﺘﺐ‬
‫)‪3‬ﻋﻨﺪﻣﺎ ﻧﻜ‬
‫ﺘﻞ‬
‫ﺑ ﺔ ﻋﺪة ﻛ‬
‫ﺘﺎ‬
‫ﺜﻨﺎء ﻧﻔ ﺲ اﻟﻤﺤﺎوﻟ ﺔ ‪ ،‬ﻟﻜﻦ ﻻﻳﻤﻜﻨﻨﺎ ﻛ‬
‫ﺘﻞ ﻣ‬
‫ﺑﺔ ﻛ‬
‫ﺘﺎ‬
‫)‪4‬ﻳﻤﻜﻨﻨﺎ ﻛ‬
‫ﺘﻞ ﻟﻨﻔ ﺲ اﻟﻤﺤﺎوﻟ ﺔ‬
‫أﺧﻴ ﺮًا ﻛ‬
‫ﺘﻠ ﺔ‪ .‬أي‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺘﻠ ﺔ إﻟﺰاﻣﻴ ﺔ‬
‫ﺘﻠ ﺔ أﺧﺮىﻳﺠ ﺐ أنﺗﻜﻮن ﻫﻨﺎك ﻛ‬
‫ﺘ ﺐ ﻓﻴﻪ ﻛ‬
‫)‪5‬ﻓ ﻲ أي وﻗ ﺖ ﻧﻜ‬
‫ﺘﻠ ﺔ أﺧﺮى‪.‬‬
‫ﺑﺔ ﻛ‬
‫ﺘﺎ‬
‫ﺑﺪون إﻻ ﻻﻳﻤﻜﻨﻨﺎ ﻛ‬
‫ﺗﻴ ﺐ ﻣﺤﺎوﻟ ﺔ ﻣﺎ ﻋﺪا آﺧﺮ أﺧﻴ ﺮًا‪.‬‬
‫)‪6‬ﻣﻦ اﻟﻤﻬﻢﺗﺮ‬
‫ﺋﻤﺎﺗﺪاﺧﻞ ﻣﺤﺎوﻟ ﺔ ﻣﺎ‬
‫ﺜﺎل ‪ ،‬ﻣﻦ اﻟﻤﻤﻜﻦ دا ً‬
‫ﺘﻞ‪ .‬ﻋﲆﺳ‬
‫ﺜﻨﺎء ‪else ، ،‬وأﺧﻴ ﺮًا اﻟﻜ‬
‫)‪7‬ﻳﻤﻜﻨﻨﺎﺗﺤﺪﻳﺪ ‪try-except-else-‬أﺧﻴ ﺮًا داﺧﻞ ‪try ،‬‬
‫ﻋﺪا ‪ ،‬آﺧﺮ ‪ ،‬أﺧﻴ ًﺮا‪.‬‬
‫‪97‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫‪1‬‬
‫ﻃ‬
‫ﺒﺎ"(‬
‫ﺒﺎﻋ ﺔ )"ﻣﺮﺣ ً‬
‫ﺜﻨﺎء‪ :‬ﻃ‬
‫‪2‬‬
‫آﺧﺮ‪:‬‬
‫‪3‬‬
‫ﺒﺎ"(‬
‫ﻃ‬
‫ﺒﺎ"(‬
‫أﺧﻴ ﺮًا‪ :‬ﻃ‬
‫‪4‬‬
‫)"‪print ("try‬‬
‫‪5‬‬
‫ﺜﻨﺎء‪print ("except") :‬‬

‫ﻃ‬
‫‪6‬‬
‫ﺒﺎﻋ ﺔ )"أﺧﻴ ًﺮا"(‬
‫أﺧﻴ ًﺮا‪ :‬ﻃ‬
‫‪7‬‬
‫آﺧﺮ‪:‬‬
‫ﻃ‬

‫ﻃ‬
‫‪8‬‬
‫آﺧﺮ‪:‬‬
‫ﻃ‬

‫ﻃ‬
‫آﺧﺮ‪:‬‬
‫‪9‬‬
‫ﺒﺎﻋ ﺔ )"آﺧﺮ"( أﺧﻴ ﺮًا‪:‬‬
‫ﻃ‬
‫ﻃ‬
‫ﺜﻨﺎء‬
‫ﺜﻨﺎء‬
‫)"‪XXX: print ("except-1‬‬
‫‪10‬‬
‫)"‪YYY: print ("except-2‬‬
‫ﺒﺎﻋ ﺔ )"ﺟﺮ ب"(‬‫ﻃ‬

‫‪11‬‬
‫ﺜﻨ ﻲ ‪:‬‬‫ﺘ‬‫ﻳﺴ‬
‫ﺜﻨﺎء )"‪-1‬‬
‫ﻃ‬
‫‪98‬‬
‫ﺑﺎد ‪- 500038 ،‬‬ ‫ﺑﻴ ﺖ‬ ‫ﺘﺮ‪#‬‬
‫ﻳﻔﺎﻧﺎم ‪ ،‬أﻣﻴﺮ‬ ‫‪202،‬‬ ‫ﺑﻖ ‪2 ،‬‬
‫آﺧﺮ‪:‬‬
‫ﻃ‬
‫آﺧﺮ‪:‬‬
‫ﻃ‬
‫ﺒﺎﻋ ﺔ‬
‫)"‪print ("except-1‬أﺧﻴ ﺮًا‪ :‬ﻃ‬
‫)"أﺧﻴ ﺮًا"( أﺧﻴ ﺮًا‪ :‬ﻃ‬
‫‪12‬‬
‫)"‪print ("Hello‬‬
‫‪13‬‬ ‫ﺜﻨﺎء‪:‬‬
‫)"‪print ("except‬‬
‫ﺜﻨﺎء‪print ("Hello") :‬‬
‫‪14‬‬ ‫ﺜﻨﺎء‪:‬‬

‫ﻃ‬
‫ﺜﻨﺎء"(‬
‫‪15‬‬ ‫ﺒﺎﻋ ﺔ‬
‫ﺒﺎ"( أﺧﻴ ﺮًا‪ :‬ﻃ‬
‫ﻃ‬
‫)"أﺧﻴ ًﺮا"(‬
‫ﺜﻨﺎء‪print ("Hello") :‬‬
‫‪16‬‬ ‫)"‪print ("except‬وإﻻ‪:‬‬
‫ﻃ‬
‫‪17‬‬

‫ﻃ‬
‫‪99‬‬
‫ﺑﺎد ‪- 500038 ،‬‬ ‫ﺑﻴ ﺖ‬ ‫ﺘﺮ‪#‬‬
‫ﻳﻔﺎﻧﺎم ‪ ،‬أﻣﻴﺮ‬ ‫‪202،‬‬ ‫ﺑﻖ ‪2 ،‬‬
‫ﺜﻨﺎء"(‬
‫‪18‬‬

‫ﻃ‬
‫أﺧﻴ ﺮًا‪ :‬ﻃ‬
‫‪19‬‬
‫إذا ﻛﺎن ‪10> 20:‬‬
‫ﺒﺎﻋ ﺔ )"إذا"(‬
‫ﻃ‬
‫آﺧﺮ‪:‬‬
‫ﻃ‬
‫)"‪print ("try") try: print ("inner try‬‬
‫ﺒﺎﻋ ﺔ‬
‫)"‪print ("inner except block‬أﺧﻴ ﺮًا‪ :‬ﻃ‬
‫)"اﻟﺠﺰء اﻟﺪاﺧﻠ ﻲ أﺧﻴ ﺮًا"(‬
‫‪20‬‬
‫ﺜﻨﺎء"(‬

‫ﻃ‬
‫ﺜﻨﺎء"( ﺣﺎول‪:‬‬
‫‪21‬‬
‫ﺒﺎﻋ ﺔ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺒﺎﻋ ﺔ )"ﻣﺤﺎوﻟ ﺔ داﺧﻠﻴ ﺔ"(‬
‫ﻃ‬
‫ﺘﻠ ﺔ‬
‫ﺘﻠ ﺔ"( أﺧﻴ ًﺮا‪ :‬ﻃ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫)"داﺧﻠ ﻲ‬
‫داﺧﻠﻴ ﺔ أﺧﻴ ﺮًا"(‬

‫‪22‬‬ ‫أﺧﻴ ﺮًا‪:‬‬
‫‪100‬‬
‫ﺑﺎد ‪- 500038 ،‬‬ ‫ﺑﻴ ﺖ‬ ‫ﺘﺮ‪#‬‬
‫ﻳﻔﺎﻧﺎم ‪ ،‬أﻣﻴﺮ‬ ‫‪202،‬‬ ‫ﺑﻖ ‪2 ،‬‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺒﺎﻋ ﺔ )"ﻣﺤﺎوﻟ ﺔ داﺧﻠﻴ ﺔ"(‬
‫ﻃ‬
‫ﺒﺎﻋ ﺔ‬
‫ﺘﻠ ﺔ"( أﺧﻴ ﺮًا‪ :‬ﻃ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺒﺎﻋ ﺔ )"داﺧﻠ ﻲ‬
‫ﻃ‬
‫ﺘﻠ ﺔ داﺧﻠﻴ ﺔ أﺧﻴ ﺮًا"(‬
‫)"ﻛ‬
‫‪23‬‬

‫ﻃ‬
‫آﺧﺮ‪:‬‬
‫ﻃ‬
‫ﺒﻊ )"ﺟﺮ ب"(‬

‫اﻃ‬
‫ﺟﺮ ب‪:‬‬
‫‪24‬‬
‫ﺒﺎﻋ ﺔ )"ﻣﺤﺎوﻟ ﺔ داﺧﻠﻴ ﺔ"(‬
‫ﻃ‬
‫ﺜﻨﺎء"(‬

‫ﻃ‬
‫آﺧﺮ‪:‬‬
‫ﺘ‬‫ﺑﺎﺳ‬‫ﺒﺎﻋ ﺔ )"آﺧﺮ"(‬
‫ﻃ‬
‫‪25‬‬
‫ﺒﺎﻋ ﺔ‬
‫ﺜﻨﺎء"( أﺧﻴ ًﺮا‪ :‬ﻃ‬
‫ﻃ‬
‫)"أﺧﻴ ﺮًا"(‬
‫ﺜﻨﺎءا ت‪:‬‬
‫ﺘ‬‫أﻧﻮاع اﻻﺳ‬
‫ﺜﻨﺎءا ت اﻟﻤﻤﻜﻨ ﺔ‪.‬‬
‫ﺘ‬‫ﺜﻮن ﻫﻨﺎك ﻧﻮﻋﺎن ﻣﻦ اﻻﺳ‬
‫ﺒ ًﻘﺎ‬
‫ﺜﻨﺎءا ت ﻣﺤﺪدة ﻣ ﺴ‬
‫ﺘ‬‫)‪1‬اﺳ‬
‫ﺘﺨﺪم‬
‫ﺘ ﻲﻳﺤﺪد ﻫﺎ اﻟﻤ ﺴ‬
‫ﺜﻨﺎءا ت اﻟ‬
‫ﺘ‬‫)‪2‬اﻻﺳ‬
‫ﺒ ًﻘﺎ‪:‬‬
‫ﺘ‬‫)‪1‬اﺳ‬
‫ﺑﻮاﺳﻄ ﺔ ﺟﻬﺎز ‪Python‬اﻟﻈﺎ ﻫﺮي ﻋﻨﺪﻣﺎﻳﻜﻮن ﻣﻠﻒ‬‫ﺘﻢ رﻓﻌﻬﺎﺗﻠﻘﺎﺋ ًﻴﺎ‬
‫ﺘ ﻲﻳ‬
‫ﺘ‬‫ﺜﻨﺎءا ت اﻟﺪاﺧﻠﻴ ﺔ‪ .‬اﻻﺳ‬
‫•‬
‫ﺒ ًﻘﺎ‪.‬‬
‫ﺘ‬‫ﻳ ﺴﻤﻰ ﺣﺪ ث ﻣﻌﻴﻦﻳﺤﺪ ث اﺳ‬
‫ﺒﺎﻋ ﺔ )‪(10/0‬‬
‫ﺗﻠﻘﺎﺋ ًﻴﺎ ‪ZeroDivisionError.‬ﻃ‬
‫ﺘﺮﻓﻊ ‪Python‬‬
‫ﺜﺎل ‪1:‬ﻋﻨﺪﻣﺎ ﻧﺤﺎولﺗﻨﻔﻴﺬ اﻟﻘ ﺴﻤ ﺔ ﻋﲆ اﻟﺼﻔﺮ ‪،‬ﺳ‬
‫ﻣ‬
‫‪101‬‬
‫ﺑﺎد ‪- 500038 ،‬‬ ‫ﺑﻴ ﺖ‬ ‫ﺘﺮ‪#‬‬
‫ﻳﻔﺎﻧﺎم ‪ ،‬أﻣﻴﺮ‬ ‫‪202،‬‬ ‫ﺑﻖ ‪2 ،‬‬
‫ﺘﺮﻓﻊ‬
‫ﺜﺎل ‪2:‬ﻋﻨﺪﻣﺎ ﻧﺤﺎولﺗﺤﻮﻳﻞ ﻗﻴﻤ ﺔ اﻹدﺧﺎل إﱃ ﻧﻮع ‪int‬وإذا ﻛﺎﻧ ﺖ ﻗﻴﻤ ﺔ اﻹدﺧﺎل ﻟﻴ ﺴ ﺖ ﻗﻴﻤ ﺔ ‪int ،‬ﻓﺈن ‪Python‬ﺳ‬
‫ﻣ‬
‫ﺗﻠﻘﺎﺋ ًﻴﺎ‬
‫‪ValueError‬‬
‫)"‪x = int ("ten‬‬ ‫‪ValueError‬‬
‫ﺘﺨﺪم‪:‬‬
‫ﺜﻨﺎءا ت ﻣﻦﺗﺤﺪﻳﺪ اﻟﻤ ﺴ‬
‫ﺘ‬‫)‪2‬اﺳ‬
‫ﺒﺮﻧﺎﻣﺠﻴ ﺔ‬
‫ﺘ‬‫ﺜﻨﺎءا ت اﻟﻤﺨﺼﺼ ﺔ أو اﻻﺳ‬
‫•‬
‫ﺘ‬‫ﺜﻨﺎءا ت اﻻﺳ‬
‫ﺘ‬‫ُﻄﻠﻖ ﻋﲆ ﻫﺬا اﻟﻨﻮع ﻣﻦ اﻻﺳ‬
‫ﺑﺸﻜﻞ ﺻﺮﻳﺢ ﻟﻺﺷﺎرة إﱃ ﺣﺪو ث ﺧﻄﺄ ﻣﺎ ‪،‬ﻳ‬‫ﺜﻨﺎءا ت ورﻓﻌﻬﺎ‬
‫ﺘ‬‫ﺘﻌﻴﻦ ﻋﻠﻴﻨﺎﺗﺤﺪﻳﺪ اﻻﺳ‬
‫ﺑﻌﺾ اﻟﻮﻗ ﺖ ‪،‬ﻳ‬‫•ﻓ ﻲ‬
‫ﺘﺨﺪم أو اﻟﻤﺨﺼﺼ ﺔ‬
‫ﺑﻮاﺳﻄ ﺔ اﻟﻤ ﺴ‬‫اﻟﻤﺤﺪدة‬
‫ﺘﺨﺪام‬
‫ﺑﺎﺳ‬‫ﺗﻨﺎ‬
‫ﺒﺎ‬
‫ﺘﻄﻠ‬
‫ﺑﻨﺎ ًء ﻋﲆ ﻣ‬‫ﺑﺸﻜﻞ ﺻﺮﻳﺢ‬‫ﺛﻢ ﻋﻠﻴﻨﺎ أن ﻧﺮﻓﻊ‬‫ﺜﻨﺎءا ت وﻟﻴ ﺲ ﻟﺪى ‪Python‬أي ﻓﻜﺮة ﻋﻨﻬﺎ‪ .‬وﻣﻦ‬
‫ﺘ‬‫ﺒﺮﻣﺞ ﻣ ﺴﺆول ﻋﻦﺗﺤﺪﻳﺪ ﻫﺬه اﻻﺳ‬
‫•اﻟﻤ‬
‫ﻛﻠﻤ ﺔ "رﻓﻊ"‪.‬‬
‫ﺜﺎل‪:‬‬
‫ﻋﲆﺳ‬
‫‪InSufficientFundsException‬‬
‫‪InvalidInputException‬‬
‫‪TooYoungException‬‬
‫‪TooOldException‬‬
‫ﺜﻨﺎءا ت اﻟﻤﺨﺼﺼ ﺔ ورﻓﻌﻬﺎ‪:‬‬

‫ﺘ‬‫ﻛﻴﻔﻴ ﺔﺗﺤﺪﻳﺪ اﻻﺳ‬
‫ﺒﺎﺷﺮ‪.‬‬
‫ﺒﺎﺷﺮ أو ﻏﻴﺮ ﻣ‬
‫ﺑﺸﻜﻞ ﻣ‬‫ﺜﻨﺎء ﻓ ﻲ ‪ Python‬ﻫﻮ ﻓﺌ ﺔﺗﻮﺳﻊ ﻓﺌ ﺔ ‪Exception‬إﻣﺎ‬
‫ﺘ‬‫ﻛﻞ اﺳ‬
‫ﺑﻨﺎء اﻟﺠﻤﻠ ﺔ‪:‬‬

‫ﺒ ًﻘﺎ(‪:‬‬
‫ﺜﻨﺎء اﻟﻤﺤﺪد ﻣ ﺴ‬
‫ﺘ‬‫اﺳﻢ ﻓﺌ ﺔ اﻟﻔﺌ ﺔ )اﺳﻢ ﻓﺌ ﺔ اﻻﺳ‬
‫‪def __init __ (self، arg):‬‬
‫‪self.msg = arg‬‬
‫ﺜﻨﺎء(‪arg): 3) self.msg = arg :‬‬

‫ﺘ‬‫)‪1‬ﻓﺌ ﺔ ‪)TooYoungException‬اﺳ‬
‫‪2) def __init __ (self،‬‬
‫‪ TooYoungException‬ﻫﻮ اﺳﻢ ﺻﻨﻔﻨﺎ و ﻫﻮ ﻓﺌ ﺔ ﻓﺮﻋﻴ ﺔ ﻣﻦ ‪Exception‬‬
‫ﺘﺎﻟ ﻲ‬
‫ﺋﻴ ﺴﻴ ﺔ ﻋﲆ اﻟﻨﺤﻮ اﻟ‬
‫ﺘﺨﺪام رﻓﻊ اﻟﻜﻠﻤﺎ ت اﻟﺮ‬
‫ﺑﺎﺳ‬‫ﺜﻨﺎء‬
‫ﺘ‬‫ﻳﻤﻜﻨﻨﺎ رﻓﻊ اﺳ‬
‫رﻓﻊ )"‪TooYoungException ("message‬‬
‫ﺜﻨﺎء(‪TooOldException :‬‬
‫ﺘ‬‫)‪1‬ﻓﺌ ﺔ ‪)TooYoungException‬اﺳ‬
‫‪def __init __ (self، arg): 3) self.msg = arg 4) 5) class‬‬
‫ﺜﻨﺎء(‪__init __ (self، arg): 7) self.msg = arg 8) :‬‬
‫ﺘ‬‫ﺳ‬
‫)‪6‬‬ ‫)‪)2‬ا‬
‫‪def‬‬
‫‪102‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺑﻌﺾ اﻟﻮﻗ ﺖ‬‫ﺘﻈﺮ‬

‫)‪9‬اﻟﻌﻤﺮ ‪)= int‬اﻹدﺧﺎل )"أدﺧﻞ اﻟﻌﻤﺮ‪10) ((":‬إذا ﻛﺎن اﻟﻌﻤﺮ< ) ‪60:11‬ارﻓﻊ ‪")TooYoungException‬ﻣﻦ ﻓﻀﻠﻚ اﻧ‬
‫ﺒﺎ !!!"(‬
‫ﺑﻖ ﻗﺮﻳ ً‬
‫ﺘﺤﺼﻞ ﻋﲆ أﻓﻀﻞﺗﻄﺎ‬
‫ﺳ‬
‫ﺑﺎﻟﻔﻌﻞﺳﻦ اﻟﺰواج ‪...‬‬‫ﺜﻨﺎء "( ‪TooOldException‬ﻟﻘﺪﺗﺠﺎوز ﻋﻤﺮك‬

‫ﺘ‬‫)‪12‬ﻋﻤﺮ ‪elif‬أﻗﻞ ﻣﻦ ) ‪18:13‬رﻓﻊ اﺳ‬
‫ﺘﺮوﻧ ﻲ !!! )"‬

‫ﺒﺮﻳﺪ اﻹﻟﻜ‬
‫ﺒﺮ اﻟ‬
‫ﺒﺎ ﻋ‬
‫ﺒﺎراة ﻗﺮﻳ ً‬
‫ﺘﺤﺼﻞ ﻋﲆﺗﻔﺎﺻﻴﻞ اﻟﻤ‬
‫ﺒﻊ "(ﺳ‬
‫اﻟﺰواج )‪") 14‬وإﻻ‪15) :‬اﻃ‬
‫ﺘﺤﺼﻞ ﻋﲆ‬
‫ﺑﻌﺾ اﻟﻮﻗ ﺖ وﺳ‬‫ﺘﻈﺮ‬
‫‪D: \ Python_classes> py test.py‬أدﺧﻞ اﻟﻌﻤﺮ‪90 __main __. TooYoungException: :‬ﻣﻦ ﻓﻀﻠﻚ اﻧ‬
‫ﺒﺎ !!!‬
‫ﺑﻖ ﻗﺮﻳ ً‬
‫أﻓﻀﻞﺗﻄﺎ‬
‫ﺑﺎﻟﻔﻌﻞﺳﻦ اﻟﺰواج ‪ ...‬ﻻﺗﻮﺟﺪ ﻓﺮﺻ ﺔ ﻟﻠﺰواج‬‫ﺜﻨﺎء ﺟﺪًا‪:‬ﺗﺠﺎوز ﻋﻤﺮك‬

‫ﺘ‬‫‪D: \ Python_classes> py test.py‬أدﺧﻞ اﻟﻌﻤﺮ‪12 __main __. :‬اﺳ‬
‫ﺘﺮوﻧ ﻲ !!!‬
‫ﺒﺮﻳﺪ اﻹﻟﻜ‬
‫ﺒﺮ اﻟ‬
‫ﺒﺎ ﻋ‬
‫ﺒﺎراة ﻗﺮﻳ ً‬
‫ﺘﺤﺼﻞ ﻋﲆﺗﻔﺎﺻﻴﻞ اﻟﻤ‬
‫‪D: \ Python_classes> py test.py‬أدﺧﻞ اﻟﻌﻤﺮ‪27 :‬ﺳ‬
‫ﺒ ًﻘﺎ‬
‫ﺜﻨﺎءا ت اﻟﻤﺤﺪدة ﻣ ﺴ‬
‫ﺘ‬‫ﺜﻨﺎءا ت اﻟﻤﺨﺼﺼ ﺔ وﻟﻜﻦ ﻟﻴ ﺲ ﻟﻼﺳ‬
‫ﺘ‬‫ﺋﻴ ﺴﻴ ﺔ ﻫ ﻲ اﻷﻧ ﺴ ﺐ ﻟﻼﺳ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬زﻳﺎدة اﻟﻜﻠﻤﺎ ت اﻟﺮ‬
‫‪103‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﻣﻠﻒ‬
‫ﻣﻌﺎﻟﺠ ﺔ‬
‫‪104‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺑﺸﻜﻞ داﺋﻢ ﻣﻦ أﺟﻞ‬‫ﺗﻨﺎ‬

‫ﺑﻴﺎﻧﺎ‬‫ﺘﻌﻴﻦ ﻋﻠﻴﻨﺎﺗﺨﺰﻳﻦ‬
‫ﺒﺮﻣﺠ ﺔ ‪،‬ﻳ‬
‫ﺘﻄﻠ‬
‫•ﻛﺠﺰء ﻣﻦ ﻣ‬
‫ﺒﻠ ﻲ‪ .‬ﻟﻬﺬا اﻟﻤﻄﻠ ﺐﻳﺠ ﺐ أن ﻧﺬ ﻫ ﺐ ﻟﻠﻤﻠﻔﺎ ت‪.‬‬
‫ﺘﻘ‬‫اﻟﻐﺮض اﻟﻤ ﺴ‬
‫ﺗﻨﺎ‪.‬‬
‫ﺑﻴﺎﻧﺎ‬‫ﺘﺨﺰﻳﻦ‬
‫ﺗﻌﺪ اﻟﻤﻠﻔﺎ ت ﻣﻨﺎﻃﻖﺗﺨﺰﻳﻦ داﺋﻤ ﺔ ﺷﺎﺋﻌ ﺔ ﺟﺪًا ﻟ‬
‫•‬
‫أﻧﻮاع اﻟﻤﻠﻔﺎ ت‪:‬‬

‫ﻫﻨﺎك ﻧﻮﻋﺎن ﻣﻦ اﻟﻤﻠﻔﺎ ت‬
‫)‪1‬ﻣﻠﻔﺎ ت ﻧﺼﻴ ﺔ‪:‬‬

‫ﺑﻴﺎﻧﺎ ت اﻟﺸﺨﺼﻴ ﺔ‬‫ﺘﺨﺰﻳﻦ‬
‫ﺘﺨﺪام اﻟﻤﻠﻔﺎ ت اﻟﻨﺼﻴ ﺔ ﻟ‬
‫ﻋﺎدةﻳﻤﻜﻨﻨﺎ اﺳ‬
‫ﺜﺎل‪abc.txt :‬‬
‫ﻋﲆﺳ‬
‫ﺜﻨﺎﺋﻴ ﺔ‪:‬‬
‫)‪2‬اﻟﻤﻠﻔﺎ ت اﻟ‬
‫ﺜﻞ اﻟﺼﻮر وﻣﻠﻔﺎ ت اﻟﻔﻴﺪﻳﻮ وﻣﻠﻔﺎ ت اﻟﺼﻮ ت وﻣﺎ إﱃ‬
‫ﺜﻨﺎﺋﻴ ﺔ ﻣ‬
‫ﺒﻴﺎﻧﺎ ت اﻟ‬
‫ﺘﺨﺰﻳﻦ اﻟ‬
‫ﺜﻨﺎﺋﻴ ﺔ ﻟ‬
‫ﺘﺨﺪام اﻟﻤﻠﻔﺎ ت اﻟ‬
‫ﻋﺎدةﻳﻤﻜﻨﻨﺎ اﺳ‬
‫ذﻟﻚ ‪...‬‬
‫ﺘﺢ ﻣﻠﻒ‪:‬‬
‫ﻓ‬
‫ﺜﻮن اﻟﺪاﺧﻠﻴ ﺔ )( ‪open‬‬
‫ﺑﺎﻳ‬‫ﺘﺨﺪام داﻟ ﺔ‬ ‫ﺑ ﺔ( ﻋﲆ اﻟﻤﻠﻒ ‪،‬ﻳﺠ ﺐ أوﻻ ً ﻓ‬
‫ﺘﺢ ﻫﺬا اﻟﻤﻠﻒ ‪ ،‬ﻟﺬﻟﻚﻳﺠ ﺐ اﺳ‬ ‫ﺘﺎ‬
‫ﺜﻞ اﻟﻘﺮاءة أو اﻟﻜ‬
‫ﺒﻞ إﺟﺮاء أي ﻋﻤﻠﻴ ﺔ )ﻣ‬
‫•ﻗ‬
‫ﺜﻞ اﻟﻐﺮض ﻣﻦ‬

‫ﺘﻌﻴﻦ ﻋﻠﻴﻨﺎﺗﺤﺪﻳﺪ اﻟﻮﺿﻊ اﻟﺬيﻳﻤ‬
‫ﺘﺢ ‪،‬ﻳ‬
‫•وﻟﻜﻦ ﻓ ﻲ وﻗ ﺖ اﻟﻔ‬
‫ﺘﺢ اﻟﻤﻠﻒ‪.‬‬
‫ﻓ‬
‫‪)f = open‬اﺳﻢ اﻟﻤﻠﻒ ‪ ،‬اﻟﻮﺿﻊ(‬
‫ﺜﻮن ﻫ ﻲ‬
‫ﺑﺎﻳ‬‫ﺑﻬﺎ ﻓ ﻲ‬‫اﻷوﺿﺎع اﻟﻤ ﺴﻤﻮح‬
‫ﺑﺪاﻳ ﺔ اﻟﻤﻠﻒ ‪ ،‬وإذا ﻟﻢﻳﻜﻦ اﻟﻤﻠﻒ اﻟﻤﺤﺪد ﻣﻮﺟﻮدًا ‪ ،‬ﻓ ﺴﻨﺤﺼﻞ ﻋﲆ‬‫ﺘﻢ وﺿﻊ ﻣﺆﺷﺮ اﻟﻤﻠﻒ ﻓ ﻲ‬
‫ﺘﺢ ﻣﻠﻒ ﻣﻮﺟﻮد ﻟﻌﻤﻠﻴ ﺔ اﻟﻘﺮاءة‪.‬ﻳ‬
‫ﻓ‬ ‫)‪ 1‬ص‬
‫‪FileNotFoundError ،‬و ﻫﺬا ﻫﻮ اﻟﻮﺿﻊ اﻻﻓ‬
‫ﺑﺎﻟﻔﻌﻞ ‪،‬‬‫ﺣﺎ‬
‫ﺘﺎ ً‬
‫ﺘﻢﺗﺠﺎوزه‪ .‬إذا ﻟﻢﻳﻜﻦ اﻟﻤﻠﻒ اﻟﻤﺤﺪد ﻣ‬
‫ﺒﻴﺎﻧﺎ ت ‪ ،‬ﻓ ﺴﻴ‬
‫ﺑﻌﺾ اﻟ‬‫ﺑﺎﻟﻔﻌﻞ ﻋﲆ‬‫ﺘﻮي‬
‫ﺑ ﺔ‪ .‬إذا ﻛﺎن اﻟﻤﻠﻒﻳﺤ‬
‫ﺘﺎ‬
‫ﺘﺢ ﻣﻠﻒ ﻣﻮﺟﻮد ﻟﻌﻤﻠﻴ ﺔ اﻟﻜ‬
‫)‪2‬ﻓ‬
‫ﺑﺈﻧﺸﺎء ﻫﺬا اﻟﻤﻠﻒ‪.‬‬‫ﻓ ﺴﻴﻘﻮم ﻫﺬا اﻟﻮﺿﻊ‬
‫ﺑﺈﻧﺸﺎء ﻣﻠﻒ‬‫ﺑﺎﻟﻔﻌﻞ ‪ ،‬ﻓ ﺴﻴﻘﻮم ﻫﺬا اﻟﻮﺿﻊ‬‫ﺣﺎ‬

‫ﺘﺎ ً‬
‫ﺒﻴﺎﻧﺎ ت اﻟﻤﻮﺟﻮدة ‪ ،‬إذا ﻟﻢﻳﻜﻦ اﻟﻤﻠﻒ اﻟﻤﺤﺪد ﻣ‬
‫ﺘﺠﺎوز اﻟ‬
‫ﺘﺢ ﻣﻠﻒ ﻣﻮﺟﻮد ﻹﻟﺤﺎق اﻟﻌﻤﻠﻴ ﺔ‪ .‬ﻟﻦﻳ‬
‫ﻓ‬ ‫)‪3‬أ‬
‫ﺟﺪﻳﺪ‪.‬‬
‫ﺑﺪاﻳ ﺔ اﻟﻤﻠﻒ‪.‬‬‫ﺘﻢ وﺿﻊ ﻣﺆﺷﺮ اﻟﻤﻠﻒ ﻓ ﻲ‬

‫ﺑﻘ ﺔ ﻓ ﻲ اﻟﻤﻠﻒ ‪ ،‬ﺣﻴ ﺚﻳ‬
‫ﺒﻴﺎﻧﺎ ت اﻟ ﺴﺎ‬
‫ﺘﻢ ﺣﺬف اﻟ‬
‫ﺘﻬﺎ ﻓ ﻲ اﻟﻤﻠﻒ‪ .‬ﻟﻦﻳ‬
‫ﺑ‬‫ﺘﺎ‬
‫ﺒﻴﺎﻧﺎ ت وﻛ‬
‫‪4) r +‬ﻟﻘﺮاءة اﻟ‬
‫ﺒﻴﺎﻧﺎ ت اﻟﻤﻮﺟﻮدة‪.‬‬
‫ﺒﻴﺎﻧﺎ ت‪.‬ﺳﻮفﻳ‬
‫ﺑ ﺔ وﻗﺮاءة اﻟ‬
‫ﺘﺎ‬
‫‪5) w +‬ﻟﻜ‬
‫ﺒﻴﺎﻧﺎ ت اﻟﻤﻮﺟﻮدة‪.‬‬
‫ﺒﻴﺎﻧﺎ ت ﻣﻦ اﻟﻤﻠﻒ‪ .‬ﻟﻦﺗ‬
‫‪6) a +‬ﻹﻟﺤﺎق وﻗﺮاءة اﻟ‬
‫ﺑﺎﻟﻔﻌﻞ ‪ ،‬ﻓ ﺴﻨﺤﺼﻞ ﻋﲆ ‪FileExistsError.‬‬‫ﺑ ﺔ‪ .‬إذا ﻛﺎن اﻟﻤﻠﻒ ﻣﻮﺟﻮدًا‬

‫ﺘﺎ‬
‫ﺘﺢ ﻣﻠﻒ ﻓ ﻲ وﺿﻊ اﻹﻧﺸﺎء اﻟﺤﺼﺮي ﻟﻌﻤﻠﻴ ﺔ اﻟﻜ‬
‫‪7) x‬ﻟﻔ‬

‫اﻟ‬
‫‪105‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺜﻨﺎﺋﻴ ﺔ‪.‬‬
‫ﺜﻞ اﻟﻤﻠﻔﺎ ت اﻟ‬
‫ﺑـ ‪"b" ،‬ﻓﻬﺬهﺗﻤ‬‫ﺒﻴﻖ ﻋﲆ اﻟﻤﻠﻔﺎ ت اﻟﻨﺼﻴ ﺔ‪ .‬إذا ﻛﺎﻧ ﺖ اﻷوﺿﺎع اﻟﻤﺬﻛﻮرة أﻋﻼه ﻣﻠﺤﻘ ﺔ‬
‫ﺘﻄ‬‫ﺑﻠ ﺔ ﻟﻠ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬ﺟﻤﻴﻊ اﻷوﺿﺎع اﻟﻤﺬﻛﻮرة أﻋﻼه ﻗﺎ‬
‫ﺜﺎل‪rb ، wb ، ab ، r + b ، w + b ، a + b ، xb :‬‬
‫ﻋﲆﺳ‬
‫)"‪f = open ("abc.txt"، "w‬‬

‫ﺒﻴﺎﻧﺎ ت‪.‬‬
‫ﺑ ﺔ اﻟ‬
‫ﺘﺎ‬
‫ﺘﺢ ﻣﻠﻒ ‪abc.txt‬ﻟﻜ‬
‫ﺑﻔ‬‫ﻧﻘﻮم‬
‫إﻏﻼق ﻣﻠﻒ‪:‬‬
‫ﺑﺈﻏﻼق اﻟﻤﻠﻒ‪.‬‬‫ﺑﺸﺪة‬‫ﺗﻨﺎ ﻋﲆ اﻟﻤﻠﻒ ‪،‬ﻳﻮﺻﻰ‬
‫ﺘﻬﺎء ﻣﻦ ﻋﻤﻠﻴﺎ‬
‫ﺑﻌﺪ اﻻﻧ‬
‫ﺘﺨﺪام داﻟ ﺔ ‪close ().‬‬

‫ﻟﻬﺬا ﻋﻠﻴﻨﺎ اﺳ‬
‫)( ‪f.close‬‬
‫ﺘﻠﻔ ﺔ ﻟﻜﺎﺋﻦ اﻟﻤﻠﻒ‪:‬‬

‫اﻟﺨﺼﺎﺋﺺ اﻟﻤﺨ‬
‫ﺘﺨﺪام ﺧﺼﺎﺋﺼﻪ‪.‬‬
‫ﺑﺎﺳ‬‫ﺑﻬﺬا اﻟﻤﻠﻒ‬‫ﺘﻌﻠﻘ ﺔ‬
‫ﺘﻠﻔ ﺔ ﻣ‬
‫ﺘﺢ ﻣﻠﻒ وﺣﺼﻠﻨﺎ ﻋﲆ ﻛﺎﺋﻦ ﻣﻠﻒ ‪،‬ﻳﻤﻜﻨﻨﺎ اﻟﺤﺼﻮل ﻋﲆﺗﻔﺎﺻﻴﻞ ﻣﺨ‬
‫ﺑﻤﺠﺮد ﻓ‬
‫ﺘﻮح‬
‫اﺳﻢ اﻟﻤﻠﻒ اﻟﻤﻔ‬ ‫•اﺳﻢ‬
‫ﺘﺢ اﻟﻤﻠﻒ‬
‫ﺘﻢ ﻓﻴﻪ ﻓ‬
‫اﻟﻮﺿﻊ اﻟﺬيﻳ‬ ‫•اﻟﻮﺿﻊ‬
‫•ﻣﻐﻠﻖ إرﺟﺎع اﻟﻘﻴﻤ ﺔ اﻟﻤﻨﻄﻘﻴ ﺔﺗﺸﻴﺮ إﱃ أن اﻟﻤﻠﻒ ﻣﻐﻠﻖ أم ﻻ‬
‫ﺑ ﻼ ً ﻟﻠﻘﺮاءة أم ﻻ‬
‫ﺗﺸﻴﺮ اﻟﻘﻴﻤ ﺔ اﻟﻤﻨﻄﻘﻴ ﺔ ‪Retruns‬إﱃ ﻣﺎ إذا ﻛﺎن اﻟﻤﻠﻒ ﻗﺎ‬
‫ﺑﻞ ﻟﻠﻘﺮاءة )(‬
‫•ﻗﺎ‬
‫ﺑ ﺔ أم ﻻ‪.‬‬‫ﺑ ﻼ ً ﻟﻠﻜ‬
‫ﺘﺎ‬ ‫)( ‪• writable‬إرﺟﺎع اﻟﻘﻴﻤ ﺔ اﻟﻤﻨﻄﻘﻴ ﺔﺗﺸﻴﺮ إﱃ ﻣﺎ إذا ﻛﺎن اﻟﻤﻠﻒ ﻗﺎ‬
‫‪1) f = open ("abc.txt"، 'w') 2) print ("File Name: "، f.name) 3) print ("File Mode: "، f.mode) 4) print ("Is‬ﻳﻤﻜﻦ ﻗﺮاءة اﻟﻤﻠﻒ‪7) f.close () 8) :‬‬
‫ﺒﺎﻋ ﺔ )" ﻫﻞ اﻟﻤﻠﻒ ﻣﻐﻠﻖ‪" ، f.closed) :‬‬

‫)‪"، f.readable ()) 5) print (" Is File Writable: "، f.writable ()) 6) print (" Is File Closed: "، f.closed‬ﻃ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫‪D: \ Python_classes> py test.py‬اﺳﻢ اﻟﻤﻠﻒ‪:‬‬
‫‪abc.txt‬‬
‫وﺿﻊ اﻟﻤﻠﻒ‪w :‬‬
‫ﺑﻞ ﻟﻠﻘﺮاءة‪ :‬ﺧﻄﺄ‬

‫ﻫﻞ اﻟﻤﻠﻒ ﻗﺎ‬
‫ﺑ ﺔ‪ :‬ﺻﺤﻴﺢ‬
‫ﺘﺎ‬
‫ﺑﻞ ﻟﻠﻜ‬
‫ﻫﻞ اﻟﻤﻠﻒ ﻗﺎ‬
‫ﻫﻞ اﻟﻤﻠﻒ ﻣﻐﻠﻖ‪ :‬ﺧﻄﺄ‬
‫ﻫﻞ اﻟﻤﻠﻒ ﻣﻐﻠﻖ‪ :‬ﺻﺤﻴﺢ‬
‫‪106‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺒﻴﺎﻧﺎ ت إﱃ ﻣﻠﻔﺎ ت ﻧﺼﻴ ﺔ‪:‬‬

‫ﺑ ﺔ اﻟ‬
‫ﺘﺎ‬
‫ﻛ‬
‫ﺘﻴﻦ‪.‬‬
‫ﺘﺎﻟﻴ‬
‫ﺘﻴﻦ اﻟ‬
‫ﺘﺨﺪام اﻟﻄﺮﻳﻘ‬
‫ﺑﺎﺳ‬‫ﺑﻴﺎﻧﺎ ت اﻷﺣﺮف إﱃ اﻟﻤﻠﻔﺎ ت اﻟﻨﺼﻴ ﺔ‬‫ﺑﺔ‬
‫ﺘﺎ‬
‫ﺘ ﺐ )‪(str‬‬
‫)‪1‬اﻛ‬
‫‪)2) Writelines‬ﻗﺎﺋﻤ ﺔ اﻷﺳﻄﺮ(‬
‫)‪\ n") 3) f.write ("Software \ n") 4) f.write ("Solutions \ n ") 5‬‬

‫ﺒﻴﺎﻧﺎ ت‬
‫ﺒﺎﻋ ﺔ "(اﻟ‬
‫‪1) f = open ("abcd.txt"، 'w') 2) f.write ("Durga‬ﻃ‬
‫ﺑﻨﺠﺎح )( ‪") 6) f.close‬‬‫ﺑ ﺔ إﱃ اﻟﻤﻠﻒ‬
‫ﺘﻮ‬‫اﻟﻤﻜ‬
‫‪abcd.txt:‬‬
‫دورﺟﺎ‬
‫ﺑﺮﻣﺠ ﺔ‬
‫ﺣﻠﻮل‬
‫ﺑﺪﻻ ً ﻣﻦﺗﺠﺎوز ﻣﺎ إذا ﻛﻨﺎ ﻧﺮﻳﺪ‬‫ﺒﺮﻧﺎﻣﺞ‪.‬‬

‫ﺘﺸﻐﻴﻞ اﻟ‬
‫ﺑ‬‫ﺒﻴﺎﻧﺎ ت اﻟﻤﻮﺟﻮدة ﻓ ﻲ اﻟﻤﻠﻒ ﻓ ﻲ ﻛﻞ ﻣﺮة إذا ﻗﻤﻨﺎ‬
‫ﺘﻢﺗﺠﺎوز اﻟ‬
‫ﺒﺮﻧﺎﻣﺞ أﻋﻼه ‪،‬ﺳﻴ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬ﻓ ﻲ اﻟ‬
‫ﺘﺎﻟ ﻲ‪.‬‬
‫ﺘﺢ اﻟﻤﻠﻒ ﻋﲆ اﻟﻨﺤﻮ اﻟ‬
‫ﻋﻤﻠﻴ ﺔ اﻹﻟﺤﺎق ‪،‬ﻳﺠ ﺐ أن ﻧﻔ‬
‫‪"f = open ("abcd.txt"،‬أ"(‬

‫ﺜﺎل ‪2:‬‬
‫ﻋﲆﺳ‬
‫)‪\ n"، "bunny \ n"، "vinny \ n"، "chinny"] 3) f.writelines (list ) 4‬‬
‫ﺒﺎﻋ ﺔ )"ﻗﺎﺋﻤ ﺔ اﻷﺳﻄﺮ‬
‫‪1) f = open ("abcd.txt"، 'w') 2) list = ["sunny‬ﻃ‬
‫ﺑﻨﺠﺎح"( )( ‪5) f.close‬‬‫ﺑ ﺔ إﱃ اﻟﻤﻠﻒ‬
‫ﺘﻮ‬‫اﻟﻤﻜ‬
‫‪abcd.txt:‬‬
‫ﻣﺸﻤ ﺲ‬
‫اﻻرﻧ ﺐ‬
‫ﻓﻴﻨ ﻲ‬
‫ذﻗﻦ‬
‫ﺒﻴﺎﻧﺎ ت اﻹﺟﻤﺎﻟﻴ ﺔ ﻓ ﻲﺳﻄﺮ‬

‫ﺑ ﺔ اﻟ‬
‫ﺘﺎ‬
‫ﺑ ﺔ ‪() ،‬ﻳﺠ ﺐ ﻋﻠﻴﻨﺎﺗﻮﻓﻴﺮ ﻓﺎﺻﻞﺳﻄﺮ ‪(\ n) ،‬وإﻻﻳﺠ ﺐ ﻛ‬
‫ﺘﺎ‬
‫ﺘﺨﺪام ﻃﺮق اﻟﻜ‬
‫ﺑ ﺔ اﻟ‬
‫ﺘﺎ‬
‫ﺛﻨﺎء ﻛ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬أ‬
‫واﺣﺪ‪.‬‬
‫‪107‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺑﻴﺎﻧﺎ ت اﻷﺣﺮف ﻣﻦ ﻣﻠﻔﺎ ت ﻧﺼﻴ ﺔ‪:‬‬‫ﻗﺮاءة‬

‫ﺘﺎﻟﻴ ﺔ‪.‬‬
‫ﺘﺨﺪام ﻃﺮق اﻟﻘﺮاءة اﻟ‬
‫ﺑﺎﺳ‬‫ﺑﻴﺎﻧﺎ ت اﻷﺣﺮف ﻣﻦ ﻣﻠﻒ ﻧﺼ ﻲ‬‫ﻳﻤﻜﻨﻨﺎ ﻗﺮاءة‬
‫ﺒﻴﺎﻧﺎ ت اﻹﺟﻤﺎﻟﻴ ﺔ ﻣﻦ اﻟﻤﻠﻒ‬

‫)(ﻟﻘﺮاءة اﻟ‬ ‫•ﻗﺮاءة‬
‫ﻟﻘﺮاءة اﻷﺣﺮف '‪'n‬ﻣﻦ اﻟﻤﻠﻒ‬ ‫•ﻗﺮاءة )اﺳﻢ(‬
‫)( ‪• readline‬ﻟﻘﺮاءةﺳﻄﺮ واﺣﺪ ﻓﻘﻂ‬
‫)( ‪• readlines‬ﻟﻘﺮاءة ﻛﻞ اﻟ ﺴﻄﻮر ﻓ ﻲ ﻗﺎﺋﻤ ﺔ‬
‫ﺒﻴﺎﻧﺎ ت اﻹﺟﻤﺎﻟﻴ ﺔ ﻣﻦ اﻟﻤﻠﻒ‬

‫ﺜﺎل ‪1:‬ﻟﻘﺮاءة اﻟ‬
‫ﻣ‬
‫)‪1) f = open ("abc.txt"، 'r') 2‬‬

‫ﺒﺎﻋ ﺔ‬
‫ﺒﻴﺎﻧﺎ ت )‪= f.read () 3‬ﻃ‬
‫اﻟ‬
‫ﺑﻴﺎﻧﺎ ت( )( ‪4) f.close‬‬
‫)‬
‫ﺘﺎج |‬
‫اﻧ‬
‫اﻟﻤﺸﻤ ﺲ‬
‫‪chinny‬‬
‫ﻓﻴﻨ ﻲ‬
‫ﺜﺎل ‪2:‬ﻟﻘﺮاءة أول ‪10‬أﺣﺮف ﻓﻘﻂ‪:‬‬

‫ﻣ‬
‫)‪1) f = open ("abc.txt"، 'r') 2‬‬

‫ﺒﺎﻋ ﺔ‬
‫ﺒﻴﺎﻧﺎ ت )‪= f.read (10) 3‬ﻃ‬
‫اﻟ‬
‫ﺑﻴﺎﻧﺎ ت( )( ‪4) f.close‬‬
‫)‬
‫ﺘﺎج |‬
‫اﻧ‬
‫اﻷرﻧ ﺐ‬
‫ﺑ ﺴﻄﺮ‪:‬‬‫ﺒﻴﺎﻧﺎ تﺳﻄ ﺮًا‬

‫ﺜﺎل ‪3:‬ﻟﻘﺮاءة اﻟ‬
‫ﻋﲆﺳ‬
‫‪= f.readline () 5) print (line2) ،‬‬

‫‪3) print (line1، end = ") 4) line2‬‬
‫)( ‪'r') 2) line1 = f.readline‬‬
‫‪1) f = open ("abc.txt"،‬اﻟﻨﻬﺎﻳ ﺔ )(‬
‫‪print (line3، end =") 8) f.close‬‬
‫)‪= ") 6) line3 = f.readline () 7‬‬
‫‪108‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﺻﻨ ﻲ‬
‫‪chinny‬‬
‫ﺜﺎل ‪4:‬ﻟﻘﺮاءة ﺟﻤﻴﻊ اﻷﺳﻄﺮ ﻓ ﻲ اﻟﻘﺎﺋﻤ ﺔ‪:‬‬

‫ﻋﲆﺳ‬
‫)‪1) f = open ("abc.txt"، 'r') 2‬‬

‫اﻷﺳﻄﺮ )‪= f.readlines () 3‬ﻟﻠﺨﻂ ﻓ ﻲ‬
‫ﺒﺎﻋ ﺔ )ﺳﻄﺮ ‪ ،‬ﻧﻬﺎﻳ ﺔ )(‬
‫اﻟ ﺴﻄﻮر ‪4) :‬ﻃ‬
‫‪= ") 5) f.close‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫‪chinny‬‬
‫ﻓﻴﻨ ﻲ‬
‫ﺜﺎل ‪5:‬‬
‫ﻋﲆﺳ‬
‫ﺒﺎﻋ ﺔ )‪3‬‬
‫)‪1) f = open ("abc.txt"، "r") 2‬ﻃ‬
‫ﺒﺎﻋ ﺔ‬
‫ﺒﺎﻋ ﺔ )‪(f.readline ()) 4‬ﻃ‬
‫))‪(f.read (3‬ﻃ‬
‫ﺒﻘﻴ ﺔ"(‬
‫ﺘ‬‫ﺒﻴﺎﻧﺎ ت اﻟﻤ‬
‫ﺒﺎﻋ ﺔ )"اﻟ‬
‫)‪(f.read (4)) 5‬ﻃ‬
‫ﺒﺎﻋ ﺔ ))( ‪(f.read‬‬
‫)‪6‬ﻃ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﺷﻤ ﺲ‬
‫ﻧﻴﻮﻳﻮرك‬
‫ﻛﻌﻜ ﺔ‬
‫ﺒﻘﻴ ﺔ‬
‫ﺘ‬‫ﺒﻴﺎﻧﺎ ت اﻟﻤ‬
‫اﻟ‬
‫ذ ‪chinny‬‬
‫ﻓﻴﻨ ﻲ‬
‫ﺒﻴﺎن‪:‬‬
‫ﻣﻊ اﻟ‬
‫ﺘﻠ ﺔ‪.‬‬
‫ﺒﺎرا تﺗﺸﻐﻴﻞ اﻟﻤﻠﻒ داﺧﻞ ﻛ‬
‫ﺘﺠﻤﻴﻊ ﻋ‬
‫ﺘﺨﺪاﻣﻬﺎ ﻟ‬
‫ﺘﺢ ﻣﻠﻒ ‪ ،‬وﻳﻤﻜﻨﻨﺎ اﺳ‬
‫ﺛﻨﺎء ﻓ‬
‫ﺘﺨﺪامﺗﻌﻠﻴﻤ ﺔ ‪with‬أ‬
‫•ﻳﻤﻜﻦ اﺳ‬
‫ﺑﺈﻏﻼق‬‫ﺒﻴﻦ‬ ‫ﺜﻨﺎءا ت أ ً‬
‫ﻳﻀﺎ ‪ ،‬وﻟ ﺴﻨﺎ ﻣﻄﺎﻟ‬ ‫ﺘ‬‫ﺘﻰ ﻓ ﻲ ﺣﺎﻟ ﺔ اﻻﺳ‬
‫ﺘﻜﻤﺎل ﺟﻤﻴﻊ اﻟﻌﻤﻠﻴﺎ تﺗﻠﻘﺎﺋ ًﻴﺎ ﺣ‬
‫ﺑﻌﺪ اﺳ‬‫ﺑﺈﻏﻼق اﻟﻤﻠﻒ ‪،‬‬‫ﺘﻢ‬
‫•ﻣﻴﺰة ‪ with statement‬ﻫ ﻲ أﻧﻪﺳﻴﻬ‬
‫ﺑﺸﻜﻞ ﺻﺮﻳﺢ‪.‬‬‫اﻟﻤﻠﻒ‬
‫‪109‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺜﻞ )‪Closed: "، f.closed‬‬

‫ﺘﺢ )"‪("abc.txt"، "w‬ﻣ‬
‫ﺑﻔ‬‫)‪1‬‬
‫‪(" Is File Closed: "، f.closed) 6) print (" Is File‬‬
‫‪\ n") 4) f.write ("Solutions \ n ") 5) print‬‬
‫‪f: 2) f.write ("Durga \ n") 3) f.write ("Software‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﻫﻞ اﻟﻤﻠﻒ ﻣﻐﻠﻖ‪ :‬ﺧﻄﺄ‬
‫ﻫﻞ اﻟﻤﻠﻒ ﻣﻐﻠﻖ‪ :‬ﺻﺤﻴﺢ‬
‫ﺒﺎر ‪():‬‬
‫ﺘﻤﺎس )(وإﺧ‬
‫ﻃﺮق اﻟ‬
‫ﺒﺮ)(‪:‬‬
‫ﻳﺨ‬
‫ﺘﺨﺪام ﻃﺮﻳﻘ ﺔ )( ‪tell‬ﻹرﺟﺎع اﻟﻤﻮﺿﻊ اﻟﺤﺎﻟ ﻲ ﻟﻠﻤﺆﺷﺮ )ﻣﺆﺷﺮ اﻟﻤﻠﻒ( ﻣﻦ‬
‫ﺒﺎر ﻣﻮﺿﻊ اﻟﻤﺆﺷﺮ اﻟﺤﺎﻟ ﻲ[‬
‫ﺑﺪاﻳ ﺔ اﻟﻤﻠﻒ‪ ] .‬ﻫﻞﻳﻤﻜﻨﻚ إﺧ‬
‫ﺜﻞ ﻓﻬﺮس اﻟ ﺴﻠ ﺴﻠ ﺔ‪.‬‬
‫ﺗﻤﺎﻣﺎ ﻣ‬
‫ً‬ ‫•ﻣﻮﺿﻊ )ﻓﻬﺮس( اﻟﺤﺮف اﻷول ﻓ ﻲ اﻟﻤﻠﻔﺎ ت ﻫﻮ ﺻﻔﺮ‬
‫)‪1) f = open ("abc.txt"، "r") 2‬‬

‫ﺒﺎﻋ ﺔ )‪(2)) 4‬‬
‫ﺒﺎﻋ ﺔ )‪(f.tell ()) 3‬ﻃ‬
‫ﻃ‬
‫ﺒﺎﻋ ﺔ ))(‬
‫ﺒﺎﻋ ﺔ )‪(f.tell ()) 5‬ﻃ‬
‫‪(f.read‬ﻃ‬
‫‪(f.read (3)) 6) print (f.tell‬‬
‫‪abc.txt:‬‬
‫ﻣﺸﻤ ﺲ‬
‫ذﻗﻦ‬
‫ﻓﻴﻨ ﻲ‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫‪0‬‬
‫ﺳﻮ‬
‫‪2‬‬
‫‪nny‬‬
‫‪5‬‬
‫ﻳﻄﻠ ﺐ)(‪:‬‬
‫ﺘﺤﺮﻳﻚ اﻟﻤﺆﺷﺮ )ﻣﺆﺷﺮ اﻟﻤﻠﻒ( إﱃ اﻟﻤﻮﻗﻊ اﻟﻤﺤﺪد‪.‬‬
‫ﺘﺨﺪام ﻃﺮﻳﻘ ﺔ )‪() (See‬ﻟ‬
‫ﺒﺤ ﺚ ﻋﻦ اﻟﻤﺆﺷﺮ إﱃ ﻣﻮﻗﻊ ﻣﻌﻴﻦ[‬
‫] ﻫﻞﻳﻤﻜﻨﻚ ﻣﻦ ﻓﻀﻠﻚ اﻟ‬
‫ﺜﻞ ﻋﺪد اﻟﻤﻮاﺿﻊ‬
‫)‪f.seek (offset، fromwhere‬ﻳﻤ‬ ‫‪offset‬‬
‫‪110‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺑﻬﺎ ﻟـ ‪2‬‬‫اﻟﻘﻴﻢ اﻟﻤ ﺴﻤﻮح‬ ‫اﻟ ﺴﻤ ﺔ )ﻣﻦ أﻳﻦ(‬

‫ﺜﺎﻧ ﻲ‬
‫ﺘﺼﺎر اﻟ‬
‫اﺧ‬
‫ﺘﺮاﺿﻴ ﺔ(‬
‫ﺑﺪاﻳ ﺔ اﻟﻤﻠﻒ )اﻟﻘﻴﻤ ﺔ اﻻﻓ‬‫‪0‬ﻣﻦ‬
‫‪1‬ﻣﻦ اﻟﻮﺿﻊ اﻟﺤﺎﻟ ﻲ‬
‫‪2‬ﻣﻦ ﻧﻬﺎﻳ ﺔ اﻟﻤﻠﻒ‬
‫ﺜﻼ ث ﻟﻜﻦ ‪Python 3‬ﻳﺪﻋﻢ اﻟﺼﻔﺮ ﻓﻘﻂ‪.‬‬

‫ﻣﻼﺣﻈ ﺔ‪:‬ﻳﺪﻋﻢ ‪Python 2‬ﺟﻤﻴﻊ اﻟﻘﻴﻢ اﻟ‬
‫ﺒﻴﺎﻧﺎ ت ="ﻛﻞ اﻟﻄﻼ ب ‪STUPIDS" 2) f = open ("abc.txt"، "w") 3) f.write‬‬

‫)‪1‬اﻟ‬
‫ﺘﺢ )"‪("abc.txt"، "r +‬ﻛـ ‪f.seek (17) 9) print ("The Current‬‬

‫ﺒﻴﺎﻧﺎ ت( )‪4‬ﻣﻊ اﻟﻔ‬
‫)اﻟ‬
‫)‪f.read () 6) print (text) 7) print ("The Current Cursor Position: "، f.tell ()) 8‬‬
‫= ‪f: 5) text‬ﻣﻮﺿﻊ اﻟﻤﺆﺷﺮ‪() 13) print (" Data After Modification: ") 14) :‬‬
‫ﺒﺎﻋ ﺔ‬
‫‪"، f.tell ()) 10) f.write (" GEMS !!! ") 11) f.seek (0) 12) text = f.read‬ﻃ‬
‫)ﻧﺺ(‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﺒﻴﺎء‬
‫ﺟﻤﻴﻊ اﻟﻄﻼ ب أﻏ‬
‫وﺿﻊ اﻟﻤﺆﺷﺮ اﻟﺤﺎﻟ ﻲ‪24 :‬‬
‫ﺘﻌﺪﻳﻞ‪ :‬ﺟﻤﻴﻊ‬
‫ﺑﻌﺪ اﻟ‬‫ﺒﻴﺎﻧﺎ ت‬
‫وﺿﻊ اﻟﻤﺆﺷﺮ اﻟﺤﺎﻟ ﻲ‪17 :‬اﻟ‬
‫اﻟﻄﻼ ب ﻫﻢ !!! ‪GEMS‬‬
‫ﺘﺤﻘﻖ ﻣﻦ وﺟﻮد ﻣﻠﻒ ﻣﻌﻴﻦ أم ﻻ؟‬

‫ﻛﻴﻔﻴ ﺔ اﻟ‬
‫ﺑﻨﺎ‪.‬‬‫ﺗﺮ اﻟﺨﺎص‬
‫ﺒﻴﻮ‬
‫ﺘﺸﻐﻴﻞ ﻟﻠﺤﺼﻮل ﻋﲆ ﻣﻌﻠﻮﻣﺎ ت ﺣﻮل اﻟﻤﻠﻔﺎ ت اﻟﻤﻮﺟﻮدة ﻋﲆ ﺟﻬﺎز اﻟﻜﻤ‬
‫ﺒ ﺔ ﻧﻈﺎم اﻟ‬
‫ﺘ‬‫ﺘﺨﺪام ﻣﻜ‬
‫ﺘﺤﻘﻖ ﻣﻤﺎ إذا ﻛﺎن ﻣﻠﻒ ﻣﻌﻴﻦ ﻣﻮﺟﻮدًا‬

‫ﺘﻮي ﻋﲆ وﻇﻴﻔ ﺔ )( ‪isFile‬ﻟﻠ‬
‫ﺘ ﻲﺗﺤ‬
‫ﺘﺸﻐﻴﻞ ﻋﲆ وﺣﺪة ﻣ ﺴﺎر ﻓﺮﻋﻴ ﺔ ‪ ،‬واﻟ‬
‫ﺘﻮي اﻟﻮﺣﺪة اﻟﻨﻤﻄﻴ ﺔ ﻟﻨﻈﺎم اﻟ‬
‫ﺗﺤ‬
‫أم ﻻ؟‬
‫)‪os.path.isfile (fname‬‬
‫ﺘﻮاه؟‬
‫ﺒﺎﻋ ﺔ ﻣﺤ‬
‫ﺑﻄ‬‫ﺣﺎ ‪ ،‬ﻓﻘﻢ‬
‫ﺘﺎ ً‬
‫ﺘﺤﻘﻖ ﻣﻤﺎ إذا ﻛﺎن اﻟﻤﻠﻒ اﻟﻤﺤﺪد ﻣﻮﺟﻮدًا أم ﻻ‪ .‬إذا ﻛﺎن ﻣ‬
‫ﺑﺮﻧﺎﻣﺠًﺎ ﻟﻠ‬‫ﺘﺐ‬
‫س( اﻛ‬
‫ﺘﺸﻐﻴﻞ ‪sys 2) fname = ،‬إدﺧﺎل )"أدﺧﻞ‬

‫ﺘﻴﺮاد ﻧﻈﺎم اﻟ‬
‫)‪1‬اﺳ‬
‫اﺳﻢ اﻟﻤﻠﻒ‪") 3) :‬إذا ﻛﺎن )‪os.path.isfile (fname): 4‬‬
‫ﺘﺢ )‪"r") 6‬‬
‫ﺒﺎﻋ ﺔ )"اﻟﻤﻠﻒ ﻣﻮﺟﻮد‪fname) 5) f = ، ":‬ﻓ‬
‫ﻃ‬
‫‪(fname ،‬وإﻻ‪:‬‬
‫‪111‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺒﺎﻋ ﺔ "(‬
‫ﺑﻴﺎﻧﺎﻃ ت(‬
‫)‪fname‬‬ ‫‪8)=sys.exit‬‬
‫ﺒﺎﻋ ﺔ )‬
‫ﻃ‬ ‫)‪f.read ()(0‬‬
‫)‪11‬‬‫ﻣﻮﺟﻮد‪، ":‬ت )‪9‬‬
‫ﻏﻴﺮ)‪10‬اﻟ‬
‫ﺒﻴﺎﻧﺎ‬ ‫)"اﻟﻤﻠﻒ‬
‫ﻫﻮ‪(":‬‬ ‫ﺒﺎﻋ ﺔاﻟﻤﻠﻒ‬
‫ﻣﺤﻃ‬
‫ﺘﻮى‬ ‫)‪7‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫‪D: \ Python_classes> py test.py‬أدﺧﻞ اﺳﻢ اﻟﻤﻠﻒ‪durga.txt :‬اﻟﻤﻠﻒ ﻏﻴﺮ‬
‫ﻣﻮﺟﻮد ‪durga.txt D: \ Python_classes> py test.py :‬أدﺧﻞ اﺳﻢ اﻟﻤﻠﻒ‪:‬‬
‫‪abc.txt‬‬
‫ﺘﻮى اﻟﻤﻠﻒ‬
‫اﻟﻤﻠﻒ ﻣﻮﺟﻮد‪abc.txt :‬ﻣﺤ‬
‫ﻫﻮ‪:‬‬
‫ﺟﻤﻴﻊ اﻟﻄﻼ ب ﻫﻢ ﻣﻦ اﻷﺣﺠﺎر اﻟﻜﺮﻳﻤ ﺔ !!!‬
‫ﺒﺮﻧﺎﻣﺞ‪.‬‬
‫ﺑﺎﻗ ﻲ اﻟ‬‫ﺑﺪونﺗﻨﻔﻴﺬ‬‫)‪sys.exit (0‬ﻟﻠﺨﺮوج ﻣﻦ اﻟﻨﻈﺎم‬
‫ﺘﺮاﺿﻴ ﺔ‪.‬‬
‫ﺗﻌﻨ ﻲ اﻹﻧﻬﺎء اﻟﻌﺎدي و ﻫ ﻲ اﻟﻘﻴﻤ ﺔ اﻻﻓ‬
‫ﺜﻞ اﻟﻮﺳﻴﻄ ﺔ رﻣﺰ اﻟﺤﺎﻟ ﺔ‪0 .‬‬
‫ﺗﻤ‬
‫ﺒﺎﻋ ﺔ ﻋﺪد اﻷﺳﻄﺮ واﻟﻜﻠﻤﺎ ت واﻷﺣﺮف‬

‫ﺑﺮﻧﺎﻣﺞ ﻟﻄ‬‫س(‬
‫ﻣﻮﺟﻮد ﻓ ﻲ اﻟﻤﻠﻒ اﻟﻤﺤﺪد؟‬
‫ﺘﺸﻐﻴﻞ ‪sys 2) fname = ،‬اﻹدﺧﺎل )"أدﺧﻞ اﺳﻢ اﻟﻤﻠﻒ‪") 3) :‬‬

‫)‪1‬اﺳ‬
‫ﺒﺎﻋ ﺔ )"اﻟﻤﻠﻒ ﻣﻮﺟﻮد‪fname) 5) f = ، ":‬‬

‫إذا ﻛﺎن )‪os.path.isfile (fname): 4‬ﻃ‬
‫ﺒﺎﻋ ﺔ )"اﻟﻤﻠﻒ ﻏﻴﺮ ﻣﻮﺟﻮد‪= ccount = 0 10) ،":‬‬

‫ﺘﺢ )‪(fname ، "r") 6) else: 7‬ﻃ‬
‫ﻓ‬
‫)‪lcount‬‬
‫‪wcount‬‬‫‪16)=print‬‬
‫‪wcount‬‬‫‪len‬ﻓ‪+‬ﻲ "(‬
‫ﺴﻄﺮ‬ ‫)‪fname‬ﻟﻠ‬
‫)‪(Words‬‬ ‫‪8)print‬‬
‫)‪15‬‬ ‫‪sys.exit‬‬ ‫‪(0) Number‬‬
‫‪("The‬‬ ‫‪9) lcountof‬‬
‫‪= wcount‬‬
‫‪Lines:"،‬‬
‫)‪lcount + 1 12) ccount = ccount + len (line) 13) Words = line.split () 14‬‬
‫= ‪f: 11) lcount‬ﻋﺪد اﻟﻜﻠﻤﺎ ت‪wcount) ،":‬‬

‫‪112‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫)‪17) print ("The Number of Characters:"، ccount‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫‪D: \ Python_classes> py test.py‬أدﺧﻞ اﺳﻢ‬
‫اﻟﻤﻠﻒ‪durga.txt :‬اﻟﻤﻠﻒ ﻏﻴﺮ ﻣﻮﺟﻮد ‪durga.txt :‬‬
‫‪D: \ Python_classes> py test.py‬أدﺧﻞ اﺳﻢ‬

‫اﻟﻤﻠﻒ‪abc.txt :‬‬
‫اﻟﻤﻠﻒ ﻣﻮﺟﻮد‪abc.txt :‬ﻋﺪد اﻷﺳﻄﺮ‪6 :‬‬
‫ﻋﺪد اﻟﻜﻠﻤﺎ ت‪24 :‬‬
‫ﻋﺪد اﻷﺣﺮف‪149 :‬‬
‫‪abc.txt‬‬
‫ﺜﻨﺎﺋﻴ ﺔ‪:‬‬
‫ﻣﻌﺎﻟﺠ ﺔ اﻟ‬
‫ﺗﻴ ﺔ وﻣﺎ إﱃ ذﻟﻚ‪.‬‬
‫ﺜﻞ اﻟﺼﻮر وﻣﻠﻔﺎ ت اﻟﻔﻴﺪﻳﻮ واﻟﻤﻠﻔﺎ ت اﻟﺼﻮ‬
‫ﺜﻨﺎﺋﻴ ﺔ ﻣ‬
‫ﺑ ﺔ اﻟ‬
‫ﺘﺎ‬
‫ﻣﻦ اﻟﺸﺎﺋﻊ ﺟﺪًا ﻗﺮاءة أو ﻛ‬
‫ﺑ ﺔ إﱃ ﻣﻠﻒ ﺻﻮرة ﺟﺪﻳﺪ؟‬

‫ﺘﺎ‬
‫ﺑﺮﻧﺎﻣﺞ ﻟﻘﺮاءة ﻣﻠﻒ اﻟﺼﻮرة واﻟﻜ‬‫س(‬
‫ﺑﺎﻳ ﺖ ‪() 4) f2.write‬‬

‫)‪1) f1 = open ("rossum.jpg"، "rb") 2) f2 = open ("newpic.jpg"، "wb") 3‬‬
‫ﺑﺎﻻﺳﻢ‪newpic.jpg") :‬‬‫ﺘﻮﻓﺮة‬
‫ﺒﺎﻋ ﺔ "(اﻟﺼﻮرة اﻟﺠﺪﻳﺪة ﻣ‬
‫ﺑﺎﻳ ﺖ( ) ‪5‬ﻃ‬
‫‪)= f1.read‬‬
‫ﺘﻌﺎﻣﻞ ﻣﻊ ﻣﻠﻔﺎ ت ‪CSV:‬‬

‫اﻟ‬
‫ﺑﻔﻮاﺻﻞ‬‫‪ CSV‬ﻗﻴﻢ ﻣﻔﺼﻮﻟ ﺔ‬
‫ﺘﻌﺎﻣﻞ ﻣﻊ ﻣﻠﻔﺎ ت ‪csv.‬‬

‫ﺒﻴﺎﻧﺎ ت‪.‬ﻳﻮﻓﺮ ‪Python‬وﺣﺪة ‪csv‬ﻟﻠ‬
‫ﺑ ﺔ وﻗﺮاءة ﻣﻠﻔﺎ ت ‪wrt csv‬ﻟﻠ‬
‫ﺘﺎ‬
‫ﺒﺮﻣﺠ ﺔ ‪ ،‬ﻣﻦ اﻟﺸﺎﺋﻊ ﺟﺪًا ﻛ‬
‫ﻛﺠﺰء ﻣﻦ اﻟ‬
‫‪113‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺒﻴﺎﻧﺎ ت إﱃ ﻣﻠﻒ ‪CSV:‬‬

‫ﺑ ﺔ اﻟ‬
‫ﺘﺎ‬
‫ﻛ‬
‫ﺗ ﺐ "(‬
‫ﺘﺢ )'' = ‪("emp.csv"، "w"، newline‬ﻛـ ‪f: 3) w = csv.writer (f) #‬إرﺟﺎع ﻛﺎﺋﻦ ﻛﺎ‬
‫ﺑﻔ‬‫ﺘﻴﺮاد )‪csv 2‬‬
‫)‪1‬اﺳ‬
‫‪csv 4) w.writerow ([" ENO "،" ENAME "،" ESAL "،" EADDR "]) 5) n = int‬إدﺧﺎل ﻋﺪد اﻟﻤﻮﻇﻔﻴﻦ‪")) 6) :‬‬
‫اﻟﻤﻮﻇﻒ‪(" :‬‬
‫‪esal،‬‬ ‫ﺳﻢ )]‪eaddr‬‬
‫أدﺧﻞ ا)‪12‬‬ ‫ﻋﻨﻮان )‪") 8‬‬
‫اﻟﻤﻮﻇﻒ‪:‬‬ ‫‪ename‬‬ ‫‪= input‬‬
‫أدﺧﻞ‬ ‫"( )‪") 10‬‬ ‫اﻟﻤﻮﻇﻒ‪:‬‬
‫‪eaddr‬‬ ‫"( رﻗﻢ‬
‫‪= input‬‬ ‫أدﺧﻞ‬ ‫‪(n): 7) eno‬‬
‫اﻟﻤﻮﻇﻒ‪:‬‬ ‫ﺗﺐ‬ ‫أدﺧﻞ=را‬
‫‪input‬‬ ‫‪(" esal‬‬
‫)‪") 9‬‬ ‫اﻟﻨﻄﺎق‬ ‫ﻟـ ‪i‬ﻓ ﻲ‬
‫‪= input‬‬
‫ﺑﻨﺠﺎح"(‬
‫ﺑﻴﺎﻧﺎ ت اﻟﻤﻮﻇﻔﻴﻦ اﻹﺟﻤﺎﻟﻴ ﺔ إﱃ ﻣﻠﻒ ‪csv‬‬‫ﺑﺔ‬
‫ﺘﺎ‬
‫ﺗﻤ ﺖ ﻛ‬
‫‪") 11) w.writerow ([eno، ename،‬ﻃ‬
‫ﺑﺪوﻧﻬﺎ‬
‫ﺘﺨﺪامﺳﻤ ﺔ اﻟ ﺴﻄﺮ اﻟﺠﺪﻳﺪ و‬
‫ﺑﺎﺳ‬‫ﺘﻼف‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬ﻻﺣﻆ اﻻﺧ‬
‫ﻣﻊ )'' = ‪open ("emp.csv"، "w"، newline‬ﻛـ ‪f:‬‬
‫ﺜﻞ ‪f:‬‬
‫ﻣﻊ )"‪open ("emp.csv"، "w‬ﻣ‬
‫ﺒﻴﺎﻧﺎ ت‪ .‬ﻟﻤﻨﻊ ﻫﺬه اﻷﺳﻄﺮ اﻟﻔﺎرﻏ ﺔ ‪ ،‬ﻓﺈنﺳﻤ ﺔ اﻟ ﺴﻄﺮ اﻟﺠﺪﻳﺪ‬

‫ﺑﻴﻦ اﻟ‬
‫ﺘﻢﺗﻀﻤﻴﻦ اﻷﺳﻄﺮ اﻟﻔﺎرﻏ ﺔ ﻓ ﻲ ﻣﻠﻒ ‪csv‬‬
‫ﺘﺨﺪمﺳﻤ ﺔ اﻟ ﺴﻄﺮ اﻟﺠﺪﻳﺪ ‪ ،‬ﻓ ﺴﻴ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬إذا ﻟﻢ ﻧ ﺴ‬
‫ﺘﺨﺪامﺳﻤ ﺔﺳﻄﺮ ﺟﺪﻳﺪ‪.‬‬

‫ﺑﺎﺳ‬‫ﺒﻴﻦ‬
‫ﺑ ﺔ ﻓ ﻲ ‪Python-3 ،‬وﻟﻜﻦ ﻓ ﻲ ‪Python-2‬ﻓﻘﻂﻳﻤﻜﻨﻨﺎﺗﺤﺪﻳﺪ اﻟﻮﺿﻊ ﻛـ '‪'wb‬وﻟ ﺴﻨﺎ ﻣﻄﺎﻟ‬
‫ﻣﻄﻠﻮ‬
‫ﺒﻴﺎﻧﺎ ت ﻣﻦ ﻣﻠﻒ ‪CSV:‬‬

‫ﻗﺮاءة اﻟ‬
‫ﺘﻴﺮاد )‪object 4) data = list (r) 5) #print (data) 6‬‬
‫)‪1‬اﺳ‬
‫‪'r') 3) r = csv.reader (f) #returns csv reader‬‬
‫ﺒ ﺔ إﱃ اﻟ ﺴﻄﺮ ﻓ ﻲ‬
‫‪csv 2) f = open ("emp.csv"،‬‬
‫ﺒﺎﻋ ﺔ ‪(word ، "\ t" ،‬اﻟﻨﻬﺎﻳ ﺔ‬
‫ﺒﻴﺎﻧﺎ ت‪7) :‬ﻟﻠﻜﻠﻤ ﺔ ﻓ ﻲ اﻟ ﺴﻄﺮ‪8) :‬ﻃ‬
‫اﻟ‬
‫ﺒﺎﻋ ﺔ )(‬
‫)‪= '') 9‬ﻃ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫‪D: \ Python_classes> py test.py‬‬
‫‪ENO ENAME ESAL EADDR‬‬
‫‪100‬دورﺟﺎ ‪ 1000‬ﻫﻴﺪ‬
‫ﺒﺎي‬
‫‪200‬ﺳﺎﺷﻴﻦ ‪2000‬ﻣﻮﻣ‬
‫‪300‬دوﻧ ﻲ ‪3000‬راﻧﺸ ﻲ‬
‫‪114‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺿﻐﻂ اﻟﻤﻠﻔﺎ ت وﻓﻚ ﺿﻐﻄﻬﺎ‪:‬‬

‫ﻣﻦ اﻟﺸﺎﺋﻊ ﺟﺪًا ﺿﻐﻂ اﻟﻤﻠﻔﺎ ت وﻓﻚ ﺿﻐﻄﻬﺎ‪.‬‬
‫ﺋﻴ ﺴﻴ ﺔ ﻫ ﻲ‪:‬‬
‫اﻟﻤﺰاﻳﺎ اﻟﺮ‬
‫ﺘﺨﺪام اﻟﺬاﻛﺮة‬
‫ﺘﺤ ﺴﻴﻦ اﺳ‬
‫)‪1‬ﻟ‬
‫)‪2‬ﻳﻤﻜﻨﻨﺎﺗﻘﻠﻴﻞ وﻗ ﺖ اﻟﻨﻘﻞ‬
‫)‪3‬ﻳﻤﻜﻨﻨﺎﺗﺤ ﺴﻴﻦ اﻷداء‪.‬‬
‫ﺘﻮي ‪Python‬ﻋﲆ ﻣﻠﻒ ﻣﻀﻐﻮط واﺣﺪ ﻣﺪﻣﺞ‪.‬‬

‫ﺗﺤ‬‫ﻹﺟﺮاء ﻋﻤﻠﻴﺎ ت ‪zip‬و ‪unzip ،‬‬
‫ﺘﻮي ﻫﺬه اﻟﻮﺣﺪة ﻋﲆ ﻓﺌ ﺔ‪ZipFile :‬‬
‫ﺗﺤ‬
‫ﻹﻧﺸﺎء ﻣﻠﻒ ﻣﻀﻐﻮط‪:‬‬

‫ﺑﺈﻧﺸﺎء ﻣﻠﻒ ﻣﻀﻐﻮط‪.‬‬‫ﺑ ﺖ أﻧﻨﺎ ﻧﻘﻮم‬
‫ﺜﺎ‬
‫ﺜﻞ ﻫﺬا اﻟ‬
‫ﺑ ﺖ‪.‬ﻳﻤ‬
‫ﺜﺎ‬
‫ﺑﺎﺳﻢ ﻣﻠﻒ ‪zip ،‬ووﺿﻊ ‪ZIP_DEFLATED‬اﻟ‬
‫ﺘﻌﻴﻦ ﻋﻠﻴﻨﺎ إﻧﺸﺎء ﻛﺎﺋﻦ ﻓﺌ ﺔ ‪ZipFile‬‬
‫ﻳ‬
‫)"‪f = ZipFile ("files.zip"، "w"، "ZIP_DEFLATED‬‬
‫ﺘﺨﺪام ﻃﺮﻳﻘ ﺔ ‪write ().‬‬

‫ﺑﺎﺳ‬‫ﺑﻤﺠﺮد إﻧﺸﺎء ﻛﺎﺋﻦ ‪ZipFile ،‬ﻳﻤﻜﻨﻨﺎ إﺿﺎﻓ ﺔ ﻣﻠﻔﺎ ت‬
‫‪)f.write‬اﺳﻢ اﻟﻤﻠﻒ(‬
‫*‬
‫ﺘﻴﺮاد ﻣﻠﻒ )‪5) f .write ("file3.txt") 6) f.close () 7‬‬
‫)‪1‬ﻣﻦ اﺳ‬
‫)"‪ZIP_DEFLATED) 3) f.write ("file1.txt") 4) f.write ("file2.txt‬‬
‫ﺗﻢ إﻧﺸﺎء ﻣﻠﻒ ‪files.zip‬‬
‫‪zip 2) f = ZipFile ("files.zip"، 'w'،‬ﻃ‬
‫ﺑﻨﺠﺎح"(‬
‫ﻹﺟﺮاء ﻋﻤﻠﻴ ﺔ ﻓﻚ اﻟﻀﻐﻂ‪:‬‬

‫ﺘﺎﻟ ﻲ‬
‫ﻋﻠﻴﻨﺎ إﻧﺸﺎء ﻛﺎﺋﻦ ‪ZipFile‬ﻋﲆ اﻟﻨﺤﻮ اﻟ‬
‫)‪f = ZipFile ("files.zip" ، "r" ، ZIP_STORED‬‬
‫ﺘﺤﺪﻳﺪ ﻫﺎ‪.‬‬
‫ﺑ‬‫ﺒﻴﻦ‬
‫ﺘﺎﻟ ﻲ ﻟ ﺴﻨﺎ ﻣﻄﺎﻟ‬
‫ﺑﺎﻟ‬
‫ﺘﺮاﺿﻴ ﺔ و‬
‫ﺜﻞ ‪ZIP_STORED‬ﻋﻤﻠﻴ ﺔ ﻓﻚ اﻟﻀﻐﻂ‪ .‬ﻫﺬه ﻫ ﻲ اﻟﻘﻴﻤ ﺔ اﻻﻓ‬
‫ﻳﻤ‬
‫ﺘﺨﺪام ﻃﺮﻳﻘ ﺔ‬
‫ﺑﺎﺳ‬‫ﺑﻤﺠﺮد إﻧﺸﺎء ﻛﺎﺋﻦ ‪ZipFile‬ﻟﻌﻤﻠﻴ ﺔ ﻓﻚ اﻟﻀﻐﻂ ‪،‬ﻳﻤﻜﻨﻨﺎ اﻟﺤﺼﻮل ﻋﲆ ﺟﻤﻴﻊ أﺳﻤﺎء اﻟﻤﻠﻔﺎ ت اﻟﻤﻮﺟﻮدة ﻓ ﻲ ﻫﺬا اﻟﻤﻠﻒ اﻟﻤﻀﻐﻮط‬
‫‪namelist ().‬‬
‫أﺳﻤﺎء )( ‪= f.namelist‬‬
‫*‬
‫ﺘﻴﺮاد ﻣﻠﻒ )‪zip 2) f = ZipFile ("files.zip"، 'r'، ZIP_STORED) 3 ) names = f.namelist () 4‬ﻟﻼﺳﻢ ﻓ ﻲ اﻷﺳﻤﺎء‪name) 5 ) :‬‬
‫)‪1‬ﻣﻦ اﺳ‬
‫‪print ( "File Name: "،‬‬
‫‪115‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺘﻮى ﻫﺬا اﻟﻤﻠﻒ ﻫﻮ‪()) print () (":‬‬‫‪6)print‬‬

‫ﻣﺤ‬ ‫"( )‪7) 8‬‬
‫)‪9‬‬
‫‪f1 = open (name، 'r') print (f1.read‬‬
‫اﻟﻌﻤﻞ ﻣﻊ اﻟﺪﻻﺋﻞ‪:‬‬
‫ﺜﻞ‬
‫ﻣﻦ اﻟﺸﺎﺋﻊ ﺟﺪًا إﺟﺮاء ﻋﻤﻠﻴﺎ تﻷدﻟ ﺔ ﻣ‬
‫)‪1‬ﻟﻤﻌﺮﻓ ﺔ دﻟﻴﻞ اﻟﻌﻤﻞ اﻟﺤﺎﻟ ﻲ‬
‫)‪2‬ﻹﻧﺸﺎء دﻟﻴﻞ ﺟﺪﻳﺪ‬
‫)‪3‬ﻹزاﻟ ﺔ دﻟﻴﻞ ﻣﻮﺟﻮد‬
‫)‪4‬ﻹﻋﺎدةﺗ ﺴﻤﻴ ﺔ دﻟﻴﻞ‬
‫ﺘﻮﻳﺎ ت اﻟﺪﻟﻴﻞ‬
‫)‪5‬ﻟ ﺴﺮد ﻣﺤ‬
‫إﻟﺦ‪...‬‬
‫ﺘﻮي ﻋﲆ اﻟﻌﺪﻳﺪ ﻣﻦ اﻟﻮﻇﺎﺋﻒ ﻹﺟﺮاء اﻟﻌﻤﻠﻴﺎ ت‬

‫ﺛﻨﺎﻳﺎه ﻋﻮاﻣﻞ ‪ ،‬واﻟﺬيﻳﺤ‬‫ﺘﻨﻔﻴﺬ ﻫﺬه اﻟﻌﻤﻠﻴﺎ ت ‪،‬ﺗﻮﻓﺮ ‪Python‬ﻧﻈﺎمﺗﺸﻐﻴﻞ وﺣﺪةﻳﺤﻤﻞ ﻓ ﻲ‬
‫ﻟ‬
‫ﺑﺎﻟﺪﻟﻴﻞ‪.‬‬‫ﺘﻌﻠﻘ ﺔ‬
‫اﻟﻤ‬
‫س )‪1‬ﻟﻤﻌﺮﻓ ﺔ دﻟﻴﻞ اﻟﻌﻤﻞ اﻟﺤﺎﻟ ﻲ‬

‫اﺳ‬
‫)( ‪cwd = os.getcwd‬‬

‫ﺒﺎﻋ ﺔ )"دﻟﻴﻞ اﻟﻌﻤﻞ اﻟﺤﺎﻟ ﻲ‪cwd) ، ":‬‬
‫ﻃ‬
‫)‪Q2‬ﻹﻧﺸﺎء دﻟﻴﻞ ﻓﺮﻋ ﻲ ﻓ ﻲ دﻟﻴﻞ اﻟﻌﻤﻞ اﻟﺤﺎﻟ ﻲ‬

‫اﺳ‬
‫)"‪os.mkdir ("mysub‬‬
‫ﺒﺎﻋ ﺔ )"دﻟﻴﻞ ‪mysub‬اﻟﺬيﺗﻢ إﻧﺸﺎؤه ﻓ ﻲ )"‪cwd‬‬
‫ﻃ‬
‫س )‪3‬ﻹﻧﺸﺎء دﻟﻴﻞ ﻓﺮﻋ ﻲ ﻓ ﻲ دﻟﻴﻞ ‪mysub‬‬

‫‪cwd‬‬
‫‪| -Mysub‬‬
‫‪| -Mysub2‬‬
‫اﺳ‬
‫)"‪os.mkdir ("mysub / mysub2‬‬

‫ﺗﻢ إﻧﺸﺎء ‪mysub2‬داﺧﻞ )"‪mysub‬‬
‫ﻃ‬
‫ﺑﺎﻟﻔﻌﻞ ﻓ ﻲ ‪cwd.‬‬‫ﺘﺮض أن ‪mysub‬ﻣﻮﺟﻮد‬

‫ﻣﻼﺣﻈ ﺔ‪ :‬اﻓ‬
‫ﺜﻞ ‪sub1‬ﻓ ﻲ ذﻟﻚ ‪sub2‬ﻓ ﻲ ذﻟﻚ‬

‫ﺘﻌﺪدة ﻣ‬
‫)‪Q4‬ﻹﻧﺸﺎء أدﻟ ﺔ ﻣ‬
‫‪sub3‬‬
‫اﺳ‬
‫)"‪os.makedirs ("sub1 / sub2 / sub3‬‬

‫ﺘ ﻲﺗﻢ إﻧﺸﺎؤ ﻫﺎ"(‬
‫‪print ("sub1‬وﻓ ﻲ ذﻟﻚ ‪sub2‬وﻓ ﻲﺗﻠﻚ اﻟﺪﻻﺋﻞ اﻟﻔﺮﻋﻴ ﺔ ‪3‬اﻟ‬
‫‪116‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫س )‪5‬ﻹزاﻟ ﺔ دﻟﻴﻞ‬
‫اﺳ‬
‫)"‪os.rmdir ("mysub / mysub2‬‬

‫ﺗﻢ ﺣﺬف دﻟﻴﻞ )"‪mysub2‬‬
‫ﻃ‬
‫ﺘﻌﺪدة ﻓ ﻲ اﻟﻤ ﺴﺎر‬

‫)‪Q6‬ﻹزاﻟ ﺔ أدﻟ ﺔ ﻣ‬
‫اﺳ‬
‫)"‪os.removedirs ("sub1 / sub2 / sub3‬‬

‫ﺛ ﺔ ‪sub1‬و ‪sub2‬و )"‪sub3‬‬
‫ﺜﻼ‬‫ﺗﻤ ﺖ إزاﻟ ﺔ ﺟﻤﻴﻊ اﻟﺪﻻﺋﻞ اﻟ‬
‫‪")print‬‬
‫س )‪7‬ﻹﻋﺎدةﺗ ﺴﻤﻴ ﺔ دﻟﻴﻞ‬

‫اﺳ‬
‫)"‪os.rename ("mysub"، "newdir‬‬

‫ﺗﻤ ﺖ إﻋﺎدةﺗ ﺴﻤﻴ ﺔ دﻟﻴﻞ ‪mysub‬إﱃ )"‪newdir‬‬
‫‪")print‬‬
‫ﺘﻮﻳﺎ ت اﻟﺪﻟﻴﻞ‬
‫س )‪8‬ﻟﻤﻌﺮﻓ ﺔ ﻣﺤ‬
‫ﺘﻮﻳﺎ ت اﻟﺪﻟﻴﻞ اﻟﻔﺮﻋ ﻲ‪.‬‬
‫ﺘﻮﻳﺎ ت اﻟﺪﻟﻴﻞ اﻟﻤﺤﺪد‪ .‬ﻟﻦﻳﻌﺮض ﻣﺤ‬
‫ﺗﻮﻓﺮ وﺣﺪة )( ‪OS Module listdir‬ﻟ ﺴﺮد ﻣﺤ‬
‫ﺘﺸﻐﻴﻞ ))"‪2) print (os.listdir (".‬‬

‫)‪1‬اﺳ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫]' __‪'module1.py' ، 'myl og.txt' ، 'newdir' ، 'newpic. jpg '، ' pack1 '، ' rossum.jpg '، ' test.py '، ' __pycache‬‬
‫‪'com'، 'demo.py'، 'durgamath.py'، 'emp.csv'، 'file1.txt' ، 'file2.txt' ، 'file3.txt' ، 'files.zip' ، 'log.txt' ،‬‬
‫‪D: \ Python_classes> py test.py ['abc.py'، 'abc.txt'، 'abcd.txt'،‬‬
‫ﺘﻮﻳﺎ ت‬
‫ﺘﻮﻳﺎ ت دﻟﻴﻞ اﻟﻌﻤﻞ اﻟﺤﺎﻟ ﻲ وﻟﻜﻦ ﻟﻴ ﺲ ﻣﺤ‬
‫ﺒﺮﻧﺎﻣﺞ أﻋﻼه ﻣﺤ‬
‫•ﻳﻌﺮض اﻟ‬
‫اﻟﺪﻻﺋﻞ اﻟﻔﺮﻋﻴ ﺔ‪.‬‬
‫ﺒﺤ ﺚ ﻋﻨﻪ‬
‫ﺑﻤﺎ ﻓ ﻲ ذﻟﻚ اﻷدﻟ ﺔ اﻟﻔﺮﻋﻴ ﺔ ‪ ،‬ﻓﻌﻠﻴﻨﺎ اﻟ‬‫ﺘﻮﻳﺎ ت دﻟﻴﻞ‬
‫•إذا أردﻧﺎ ﻣﺤ‬
‫اﻟﻤﺸ ﻲ )(وﻇﻴﻔ ﺔ‪.‬‬
‫ﺑﻤﺎ ﻓ ﻲ ذﻟﻚ اﻷدﻟ ﺔ اﻟﻔﺮﻋﻴ ﺔ‬‫ﺘﻮﻳﺎ ت اﻟﺪﻟﻴﻞ‬

‫س )‪9‬ﻟﻤﻌﺮﻓ ﺔ ﻣﺤ‬
‫ﺘﺨﺪام وﻇﻴﻔ ﺔ )( ‪walk‬‬
‫•ﻋﻠﻴﻨﺎ اﺳ‬
‫ﺘﻮﻳﺎ ت ذﻟﻚ‬
‫ﺘﻤﻜﻦ ﻣﻦ ﻣﻌﺮﻓ ﺔ ﺟﻤﻴﻊ ﻣﺤ‬
‫ﺘﻰ ﻧ‬
‫•] ﻫﻞﻳﻤﻜﻨﻚ اﻟﺪﺧﻮل ﻓ ﻲ اﻟﺪﻟﻴﻞ ﺣ‬
‫اﻟﺪﻟﻴﻞ[‬
‫ﺑﺈرﺟﺎع ﻛﺎﺋﻦ ‪Iterator‬اﻟﺬيﻳﻤﻜﻦ ﻋﺮض‬‫ﺗﻘﻮم‬

‫)‪• os.walk (path، topdown = True، onerror = None، followlinks = False‬‬
‫ﺘﺨﺪام ﺣﻠﻘ ﺔ ‪for‬‬

‫ﺑﺎﺳ‬‫ﺗﻪ‬
‫ﺘﻮﻳﺎ‬
‫ﻣﺤ‬
‫ﻣ ﺴﺎر اﻟﺪﻟﻴﻞ‪cwd .‬ﻳﻌﻨ ﻲ‪.‬‬ ‫•اﻟﻤ ﺴﺎر‬
‫•ﻣﻦ أﻋﲆ إﱃ أﺳﻔﻞ = ﺻﺤﻴﺢ ﺳﺎﻓﺮ ﻣﻦ أﻋﲆ إﱃ أﺳﻔﻞ‬
‫‪117‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫ﺑﻖ ‪ ،‬ﻫﺪى ﻣﺎﻳ‬‫اﻟﻄﺎ‬
‫ﺘ ﻲﻳﺠ ﺐﺗﻨﻔﻴﺬ ﻫﺎ‪.‬‬

‫ﺘﺸﺎف اﻟﺨﻄﺄ ‪ ،‬اﻟﻮﻇﻴﻔ ﺔ اﻟ‬
‫•ﻋﻨﺪ اﻟﺨﻄﺄ =ﻻ ﺷ ﻲء ﻋﻨﺪ اﻛ‬
‫ﺑﻂ رﻣﺰﻳ ﺔ‬
‫ﺑﺮوا‬‫‪• followlinks = True‬ﻟﺰﻳﺎرة اﻟﺪﻻﺋﻞ اﻟﻤﺸﺎر إﻟﻴﻬﺎ‬
‫ﺑﻤﺎ ﻓ ﻲ ذﻟﻚ اﻷدﻟ ﺔ اﻟﻔﺮﻋﻴ ﺔ‪:‬‬‫ﺘﻮﻳﺎ ت دﻟﻴﻞ اﻟﻌﻤﻞ اﻟﺤﺎﻟ ﻲ‬

‫ﺜﺎل‪ :‬ﻟﻌﺮض ﻛﺎﻓ ﺔ ﻣﺤ‬
‫ﻋﲆﺳ‬
‫ﺘﺸﻐﻴﻞ )‪2‬ﻟـ ‪dirpath‬و ‪dirnames‬و ‪filenames‬ﻓ ﻲ )‪4) 5) 6‬‬

‫)‪1‬اﺳ‬
‫)‪os.walk ('.'): 3) print ("Current Directory Path:"، dirpath‬‬
‫ﺒﺎﻋ ﺔ )"اﻟﺪﻻﺋﻞ‪ ، ":‬أﺳﻤﺎء اﻟﻤ ﺴﺎرا ت(‬

‫ﻃ‬
‫ﺒﺎﻋ ﺔ )"اﻟﻤﻠﻔﺎ ت‪ ، ":‬أﺳﻤﺎء اﻟﻤﻠﻔﺎ ت(‬
‫ﻃ‬
‫ﺒﺎﻋ ﺔ )(‬
‫ﻃ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﻣ ﺴﺎر اﻟﺪﻟﻴﻞ اﻟﺤﺎﻟ ﻲ‪.:‬‬
‫اﻟﺪﻻﺋﻞ‪['com'، 'newdir'، 'pack1'، '__pycache__'] :‬‬
‫اﻟﻤﻠﻔﺎ ت‪['abc.txt'، 'abcd.txt'، 'demo.py'، 'durgamath.py'، 'emp.csv'، 'file1.txt'، 'file2.txt'، 'file3. :‬‬
‫]' ‪txt '، ' files.zip '، ' log.txt '، ' module1.py '، ' mylog.txt '، ' newpic.jpg '، ' rossum.jpg '، ' test.py‬‬
‫ﻣ ﺴﺎر اﻟﺪﻟﻴﻞ اﻟﺤﺎﻟ ﻲ‪\ com .:‬اﻟﺪﻻﺋﻞ‪'__pycache__'] :‬‬

‫‪['durgasoft'،‬‬
‫اﻟﻤﻠﻔﺎ ت‪['module1.py'، '__init__.py'] :‬‬
‫‪...‬‬
‫ﺘﻌﻴﻦ ﻋﻠﻴﻨﺎﺗﻮﻓﻴﺮ اﺳﻢ اﻟﺪﻟﻴﻞ ﻫﺬا ﻛﻮﺳﻴﻄ ﺔ ‪to walk () function.‬‬

‫ﺘﻮﻳﺎ ت دﻟﻴﻞ ﻣﻌﻴﻦ ‪،‬ﻳ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬ﻟﻌﺮض ﻣﺤ‬
‫‪")os.walk‬اﺳﻢ اﻟﺪﻟﻴﻞ"(‬
‫ﺑﻴﻦ وﻇﺎﺋﻒ )( ‪listdir‬و ؟)( ‪walk‬‬‫س( ﻣﺎ اﻟﻔﺮق‬

‫ﺘﻮﻳﺎ ت اﻟﺪﻟﻴﻞ اﻟﻔﺮﻋ ﻲ‪ .‬وﻟﻜﻦ ﻓ ﻲ ﺣﺎﻟ ﺔ وﻇﻴﻔ ﺔ ‪walk () ،‬ﺳﻨﺤﺼﻞ ﻋﲆ‬
‫ﺘﻮﻳﺎ ت اﻟﺪﻟﻴﻞ اﻟﻤﺤﺪد وﻟﻜﻦ ﻟﻴ ﺲ ﻣﺤ‬
‫ﻓ ﻲ ﺣﺎﻟ ﺔ ‪listdir () ،‬ﺳﻨﺤﺼﻞ ﻋﲆ ﻣﺤ‬
‫ﺑﻪ أ ً‬
‫ﻳﻀﺎ‪.‬‬ ‫ﺘﻮﻳﺎ ت اﻟﺪﻟﻴﻞ اﻟﻤﺤﺪد واﻷدﻟ ﺔ اﻟﻔﺮﻋﻴ ﺔ اﻟﺨﺎﺻ ﺔ‬
‫ﻣﺤ‬
‫ﺑﺮﻧﺎﻣﺞ ‪Python:‬‬‫ﺑﺮاﻣﺞ أﺧﺮى ﻣﻦ‬‫ﺗﺸﻐﻴﻞ‬

‫ﺒﺮاﻣﺞ واﻷواﻣﺮ‪.‬‬
‫ﺘﺸﻐﻴﻞ اﻟ‬
‫ﺘﻮي وﺣﺪة ‪OS Module‬ﻋﲆ وﻇﻴﻔ ﺔ )( ‪system‬ﻟ‬
‫ﺗﺤ‬
‫ﺒﻂ ﻧﻔ ﺲ وﻇﻴﻔ ﺔ )( ‪system‬ﻓ ﻲ ﻟﻐ ﺔ ‪C.‬‬
‫ﺑﺎﻟﻀ‬‫إﻧﻬﺎ‬
‫‪")os.system‬ﺳﻠ ﺴﻠ ﺔ أواﻣﺮ"(‬
‫ﺘﻢﺗﻨﻔﻴﺬه ﻣﻦ ‪DOS.‬‬
‫اﻟﺤﺠ ﺔ ﻫ ﻲ أي أﻣﺮﻳ‬
‫ﺜﺎل‪:‬‬
‫ﻋﲆﺳ‬
‫اﺳ‬
‫)"‪os.system ("dir * .py‬‬

‫)"‪os.system ("py abc.py‬‬
‫‪118‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﻛﻴﻔﻴ ﺔ اﻟﺤﺼﻮل ﻋﲆ ﻣﻌﻠﻮﻣﺎ ت ﺣﻮل ﻣﻠﻒ‪:‬‬

‫ﺘﺨﺪام وﻇﻴﻔ ﺔ‬
‫ﺑﺎﺳ‬‫ﺜﻞ اﻟﺤﺠﻢ وآﺧﺮ وﻗ ﺖﺗﻢ اﻟﻮﺻﻮل إﻟﻴﻪ وآﺧﺮ وﻗ ﺖﺗﻢﺗﻌﺪﻳﻠﻪ وﻣﺎ إﱃ ذﻟﻚ‬
‫ﻳﻤﻜﻨﻨﺎ اﻟﺤﺼﻮل ﻋﲆ إﺣﺼﺎﺋﻴﺎ ت ﻋﻦ ﻣﻠﻒ ﻣ‬
‫)( ‪stat‬ﻟﻮﺣﺪة ﻧﻈﺎم اﻟ‬
‫)"‪stats = os.stat ("abc.txt‬‬
‫ﺘﺎﻟﻴ ﺔ‪:‬‬
‫ﺘﻀﻤﻦ إﺣﺼﺎﺋﻴﺎ ت اﻟﻤﻠﻒ اﻟﻤﻌﻠﻤﺎ ت اﻟ‬
‫ﺗ‬
‫ﺑ ﺖ اﻟﺤﻤﺎﻳ ﺔ‬
‫‪1) st_mode‬‬
‫‪2) st_ino‬رﻗﻢ ‪Inode‬‬
‫)‪3‬ﺟﻬﺎز ‪st_dev‬‬
‫ﺒﺔ‬
‫ﺑﻂ اﻟﺼﻠ‬
‫‪4) st_nlink‬ﻋﺪد اﻟﺮوا‬
‫ﺑﺎﻟﻤﺎﻟﻚ‬‫ﺘﺨﺪم اﻟﺨﺎص‬
‫‪5) st_uid‬ﻣﻌﺮف اﻟﻤ ﺴ‬
‫‪6) st_gid‬ﻣﻌﺮف اﻟﻤﺠﻤﻮﻋ ﺔ اﻟﻤﺎﻟﻚ‬
‫ﺒﺎﻳ ﺖ‬
‫ﺑﺎﻟ‬‫‪7) st_size‬ﺣﺠﻢ اﻟﻤﻠﻒ‬
‫‪8) st_atime‬وﻗ ﺖ أﺣﺪ ث وﺻﻮل‬
‫ﺘﻌﺪﻳﻞ اﻷﺧﻴﺮ‬
‫‪9) st_mtime‬وﻗ ﺖ اﻟ‬
‫ﺒﻴﺎﻧﺎ ت اﻟﻮﺻﻔﻴ ﺔ‬
‫‪10) st_ctime‬وﻗ ﺖ أﺣﺪ ثﺗﻐﻴﻴﺮ ﻓ ﻲ اﻟ‬
‫ﺘﺨﺪام وﺣﺪة‬
‫ﺑﺎﺳ‬‫ﺣﺎ‪.‬‬
‫ﺒﺎ ً‬
‫ﺛﺎﻧﻴ ﺔ ﻣﻨﺬ اﻷول ﻣﻦﻳﻨﺎﻳﺮ ‪1970 ،‬اﻟ ﺴﺎﻋ ﺔ ‪ 12:00‬ﺻ‬‫ُﺮﺟﻊ ‪st_atime‬و ‪st_mtime‬و ‪st_ctime‬اﻟﻮﻗ ﺖ ﻛﺮﻗﻢ ﻣﻠ ﻲ‬
‫ﻣﻼﺣﻈ ﺔ‪:‬ﺗ‬
‫ﺒﻂ‪.‬‬
‫ﺑﺎﻟﻀ‬‫ﺘﺎرﻳﺦ واﻟﻮﻗ ﺖ‬
‫ﺑﻊ اﻟﺰﻣﻨ ﻲ ‪() ،‬ﻳﻤﻜﻨﻨﺎ اﻟﺤﺼﻮل ﻋﲆ اﻟ‬
‫ﺘﺎرﻳﺦ واﻟﻮﻗ ﺖ ﻣﻦ وﻇﻴﻔ ﺔ اﻟﻄﺎ‬
‫اﻟ‬
‫ﺒﺎﻋ ﺔ ﻛﺎﻓ ﺔ إﺣﺼﺎﺋﻴﺎ ت ﻣﻠﻒ ‪abc.txt‬‬

‫س( ﻟﻄ‬
‫ﺒﺎﻋ ﺔ )إﺣﺼﺎﺋﻴﺎ ت(‬

‫ﺘﺸﻐﻴﻞ )‪2) stats = os.stat ("abc.txt") 3‬ﻃ‬
‫)‪1‬اﺳ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫‪st_nlin k = 1 ، st_uid = 0 ، st_gid = 0 ، st_size = 22410 ، st_atime = 1505451446 ، st_mtime = 1505538999 ، st_1446‬‬
‫‪os.stat_result (st_mode = 33206 ، st_ino = 844424930132788 ، st_dev = 2657980798 ،‬‬
‫ﺒﺎﻋ ﺔ اﻟﺨﺼﺎﺋﺺ اﻟﻤﺤﺪدة‬

‫س( ﻟﻄ‬
‫ﺒﺎﻋ ﺔ "(ﺣﺠﻢ اﻟﻤﻠﻒ‬

‫ﺘﺎرﻳﺦ واﻟﻮﻗ ﺖ )‪3) stats = os.stat ("abc.txt") 4‬ﻃ‬
‫ﺘﺸﻐﻴﻞ )‪2‬ﻣﻦ اﺳ‬
‫)‪1‬اﺳ‬
‫*‬
‫ﺒﺎﻋ ﺔ "(آﺧﺮ وﻗ ﺖﺗﻢ اﻟﻮﺻﻮل إﻟﻴﻪ ﻟﻠﻤﻠﻒ‪(stats.st_mtime)) ، ":‬‬
‫ﺒﺎﻳ ﺖ‪stats.st_size) 5) ،":‬ﻃ‬
‫ﺑﺎﻟ‬
‫‪(stats.st_atime)) 6) print ("File Last Modified Time:"، datetime.fromtimestamp‬‬
‫‪datetime.fromtimestamp‬‬
‫‪119‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﺒﺎﻳ ﺖ ‪22410 :‬وﻗ ﺖ آﺧﺮ وﺻﻮل ﻟﻠﻤﻠﻒ‪10: 27: 26.599490 :‬‬
‫ﺑﺎﻟ‬‫ﺣﺠﻢ اﻟﻤﻠﻒ‬
‫‪2017-09-15‬وﻗ ﺖ آﺧﺮﺗﻌﺪﻳﻞ ﻟﻠﻤﻠﻒ‪2017-09-16 10: 46: 39.245394 :‬‬
‫ﺘﺤﻬﺎ‪:‬‬
‫ﺗﺨﻠﻴﻞ اﻷﺷﻴﺎء وﻓ‬
‫ﺑ ﺔ اﻟﺤﺎﻟ ﺔ اﻟﻜﻠﻴ ﺔ ﻟﻠﻜﺎﺋﻦ إﱃ اﻟﻤﻠﻒ وﻋﻠﻴﻨﺎ ﻗﺮاءة اﻟﻜﺎﺋﻦ اﻟﻜﻠ ﻲ ﻣﻦ اﻟﻤﻠﻒ‪.‬‬
‫ﺘﺎ‬
‫ﺘﻌﻴﻦ ﻋﻠﻴﻨﺎ ﻛ‬
‫ﺑﻌﺾ اﻷﺣﻴﺎنﻳ‬‫•ﻓ ﻲ‬
‫ﺘﺨﻠﻴﻞ وﻋﻤﻠﻴ ﺔ‬
‫ﺑ ﺔ ﺣﺎﻟ ﺔ اﻟﻜﺎﺋﻦ إﱃ اﻟﻤﻠﻒ ﻋﻤﻠﻴ ﺔ اﻟ‬
‫ﺘﺎ‬
‫ﺗ ﺴﻤﻰ ﻋﻤﻠﻴ ﺔ ﻛ‬
‫•‬
‫ﻗﺮاءة ﺣﺎﻟ ﺔ ﻛﺎﺋﻦ ﻣﻦ اﻟﻤﻠﻒﺗ ﺴﻤﻰ ‪unpickling.‬‬
‫ﺘﺨﺪام وﺣﺪة ‪pickle‬ﻣﻦ ‪Python.‬‬
‫ﺑﺎﺳ‬
‫ﺘﺨﻠﻴﻞ و ‪unpickling‬‬
‫•ﻳﻤﻜﻨﻨﺎﺗﻨﻔﻴﺬ اﻟ‬
‫ﺘﺨﻠﻴﻞ‪)pickle.dump .‬ﻛﺎﺋﻦ ‪ ،‬ﻣﻠﻒ(‬
‫ﺘﻔﺮﻳﻎ )(ﻷداء اﻟ‬
‫ﺘﻮي وﺣﺪة اﻟﻤﺨﻠﻞ ﻋﲆ وﻇﻴﻔ ﺔ اﻟ‬
‫ﺗﺤ‬
‫ﺘﻮي وﺣﺪة ‪pickle‬ﻋﲆ وﻇﻴﻔ ﺔ )( ‪load‬ﻷداء ‪)unpickling obj = pickle.load‬ﻣﻠﻒ(‬
‫ﺗﺤ‬
‫ﺗﺨﻠﻴﻞ‬
‫ﻣﺨﻠﻞ‬
‫إﻧﻮ‪100 :‬‬ ‫) ﻫـ ‪1 ،‬و(‬
‫‪ename:‬دورﺟﺎ‬
‫إﻳﺼﺎل‪10000 :‬‬
‫ﻣﺪﻳﺮ‪HYD :‬‬
‫ه‪1‬‬ ‫إﻧﻮ‪100 :‬‬
‫‪ename:‬دورﺟﺎ‬
‫إﻳﺼﺎل‪10000 :‬‬
‫ﻣﺪﻳﺮ‪HYD :‬‬
‫إﻧﻮ‪100 :‬‬ ‫‪abc.txt‬‬

‫‪ename:‬دورﺟﺎ‬ ‫ﺗﺤﻤﻴﻞ اﻟﻤﺨﻠﻞ )و(‬
‫إﻳﺼﺎل‪10000 :‬‬
‫ﻣﺪﻳﺮ‪HYD :‬‬ ‫ﺘﺸﺮ‬
‫ﻏﻴﺮ ﻣﻨ‬
‫ه‪2‬‬
‫ﺘﺨﺪام وﺣﺪة ‪pickle:‬‬

‫ﺑﺎﺳ‬‫ﺗﻬﺎ‬
‫ﺑ ﺔ ﺣﺎﻟ ﺔ اﻟﻜﺎﺋﻦ وﻗﺮاء‬
‫ﺘﺎ‬
‫ﻛ‬
‫ﺘﻴﺮاد اﻟﻤﺨﻠﻞ )‪2‬ﻓﺌ ﺔ اﻟﻤﻮﻇﻒ‪"\ t"، self.ename، "\ t"، self.esal، "\ t"، self.eaddr) 10) :‬‬
‫)‪1‬اﺳ‬
‫‪ 8) def display (self): 9) print (self.eno،‬؛ ‪ 7) self.eaddr = eaddr‬؛ ‪ 6) self.esal = esal‬؛ ‪ename‬‬
‫= ‪ 5) self.ename‬؛‪3) def __init __ (self، eno، ename، esal، eaddr): 4) self.eno = eno‬ﻣﻊ )"‬
‫‪open ("emp .dat "،" wb‬ﻛـ = ‪f: 11) e‬اﻟﻤﻮﻇﻒ )" ‪(100،" Durga "، 1000،" Hyd‬‬
‫‪120‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﻣﻊ‬14) 15) ("... ‫ﺘﻤﻞ‬

‫ﻣﻜ‬12) pickle.dump (e، f) 13) print ("Pickle of Employee Object
‫ﺒﺎﻋ ﺔ ﻣﻌﻠﻮﻣﺎ ت اﻟﻤﻮﻇﻒ‬
‫)"ﻃ‬f: 16) obj = pickle .load (f) 17) print ‫ﻛـ‬open ("emp.dat"، "rb")
18) obj.display () ("‫ﺘﺤﺪﻳﺪ‬
‫ﺑﻌﺪ إﻟﻐﺎء اﻟ‬
:‫ﺘﻌﺪدة ﻟﻠﻤﻮﻇﻔﻴﻦ ﻓ ﻲ اﻟﻤﻠﻒ‬

‫ﺑ ﺔ ﻛﺎﺋﻨﺎ ت ﻣ‬
‫ﺘﺎ‬
‫ﻛ‬
emp.py:
= ename ‫ ؛‬5) self.esal = esal ‫ ؛‬6) self.eaddr = eaddr ‫ ؛‬7)

eno، ename، esal، eaddr): 3) self.eno = eno‫ ؛‬4) self.ename
8) 9) :(‫ﺗ ﻲ‬
‫ﻋﺮض ﻣﻮاﻃﻨﻪ )ذا‬1) class Employee: 2) def __init __ (self،
(self.eno، "\ t"، self.ename، "\ t"، self.esal، "\ t"، self.eaddr) ‫ﺒﺎﻋ ﺔ‬
‫ﻃ‬
pick.py:
‫)"إدﺧﺎل‬emp ، pickle 2) f = open ("emp.dat"، "wb") 3) n = int ‫ﺘﻴﺮاد‬

‫اﺳ‬1)
‫()"أدﺧﻞ رﻗﻢ‬n): 5) eno = int (input ‫ﻓ ﻲ اﻟﻨﻄﺎق‬i ‫ﻟـ‬4) ((":‫ﻋﺪد اﻟﻤﻮﻇﻔﻴﻦ‬
7) 8) eaddr = input (":‫)"أدﺧﻞ اﺳﻢ اﻟﻤﻮﻇﻒ‬6) ename = input ((":‫اﻟﻤﻮﻇﻒ‬
Objects pickled Success") ‫اﻟﻤﻮﻇﻒ‬9) e = emp. (":‫)"أدﺧﻞ ﻋﻨﻮان اﻟﻤﻮﻇﻒ‬
(eno، ename، esal، eaddr) 10) pickle.dump (e، f) 11) print ("Employee
((":‫ﺗ ﺐ اﻟﻤﻮﻇﻒ‬
‫)"أدﺧﻞ را‬esal = float (input
unpick.py:
2) f = open ("emp.dat"، "rb") 3) ‫ﺘﻴﺮاد‬

‫اﺳ‬1)
4) (":‫ﺗﻔﺎﺻﻴﻞ اﻟﻤﻮﻇﻒ‬
") ‫ﺒﺎﻋ ﺔ‬
‫ﻃ‬emp ، pickle
obj = pickle.load (f ) :‫ﺣﺎول‬5) :‫ﺑﻴﻨﻤﺎ ﺻﺤﻴﺢ‬
6)
121
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﺗﻢ إﻛﻤﺎل‬
‫ﻃ‬ ‫‪EOF:‬‬
‫)‪11‬‬ ‫ﺧﻄﺄ )‪9‬‬
‫‪f.close‬‬ ‫ﺜﻨﺎءﺔ )(‬
‫ﺘ‬
‫ﺘﺮاﺣ‬‫ﺑﺎاﺳ‬‫‪7) obj.display‬‬
‫)‪10‬‬ ‫)‪() 8‬‬
‫ﺟﻤﻴﻊ اﻟﻤﻮﻇﻔﻴﻦ"(‬
‫‪122‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﻌﺪد‬
‫ﻣ‬
‫ﺧﻴﻮط‬
‫‪123‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺘﻌﺪد اﻟﻤﻬﺎم‪:‬‬
‫ﻣ‬
‫ﺗﻨﻔﻴﺬ ﻋﺪة ﻣﻬﺎم ﻓ ﻲ وﻗ ﺖ واﺣﺪ ﻫﻮ ﻣﻔﻬﻮمﺗﻌﺪد اﻟﻤﻬﺎم‪.‬‬
‫ﺘﻌﺪدة‬
‫ﻫﻨﺎك ﻧﻮﻋﺎن ﻣﻦ اﻟﻤﻬﺎم اﻟﻤ‬
‫ﺗﻌﺪد اﻟﻤﻬﺎم اﻟﻘﺎﺋﻢ ﻋﲆ اﻟﻌﻤﻠﻴﺎ ت‬

‫)‪1‬‬
‫ﺘﻌﺪد اﻟﻤﻬﺎم ﻋﲆ أﺳﺎس‬

‫)‪2‬ﻣﻮﺿﻮع ﻣ‬
‫ﺗﻌﺪد اﻟﻤﻬﺎم اﻟﻘﺎﺋﻢ ﻋﲆ اﻟﻌﻤﻠﻴﺎ ت‪:‬‬

‫)‪1‬‬
‫ﺘﻌﺪدة اﻟﻤﻬﺎم ﻗﺎﺋﻤ ﺔ ﻋﲆ اﻟﻌﻤﻠﻴﺎ ت‪.‬‬
‫ﺘﻘﻠ ﺔ ﻣﻨﻔﺼﻠ ﺔ ‪ ،‬ﻋﻤﻠﻴ ﺔ ﻣ‬
‫ُﻄﻠﻖ ﻋﲆﺗﻨﻔﻴﺬ اﻟﻌﺪﻳﺪ ﻣﻦ اﻟﻤﻬﺎم ﻓ ﻲ وﻗ ﺖ واﺣﺪ ﺣﻴ ﺚﺗﻜﻮن ﻛﻞ ﻣﻬﻤ ﺔ ﻋﻤﻠﻴ ﺔ ﻣ ﺴ‬
‫ﻳ‬
‫ﺘﻨ ﺴﻴﻖ ‪mp3‬ﻣﻦ ﻧﻔ ﺲ اﻟﻨﻈﺎم‪ .‬ﻓ ﻲ ﻧﻔ ﺲ اﻟﻮﻗ ﺖﻳﻤﻜﻨﻨﺎ‬

‫ﺑ‬‫ﺗﻴ ﺔ‬
‫ﺘﻤﺎع إﱃ اﻷﻏﺎﻧ ﻲ اﻟﺼﻮ‬
‫ﺑﺮﻧﺎﻣﺞ ‪python‬ﻓ ﻲ اﻟﻤﺤﺮر ‪،‬ﻳﻤﻜﻨﻨﺎ اﻻﺳ‬‫ﺑﺔ‬
‫ﺘﺎ‬
‫ﺛﻨﺎء ﻛ‬
‫ﺜﺎل‪ :‬أ‬
‫ﻋﲆﺳ‬
‫ﺘﻌﺪدة اﻟﻤﻬﺎم ﻋﲆ أﺳﺎس اﻟﻌﻤﻠﻴ ﺔ‪.‬‬

‫ﺛﻢ ﻓﻬ ﻲ ﻣ‬‫ﺒﻌﺾ‪ .‬وﻣﻦ‬
‫ﺑﻌﻀﻬﺎ اﻟ‬‫ﺘﻘﻞ ﻋﻦ‬
‫ﺑﺸﻜﻞ ﻣ ﺴ‬
‫ﺘﻢﺗﻨﻔﻴﺬ ﻫﺎ ﻓ ﻲ وﻗ ﺖ واﺣﺪ و‬
‫ﺘﺮﻧ ﺖ‪ .‬ﻛﻞ ﻫﺬه اﻹﺟﺮاءا تﻳ‬
‫ﺗﻨﺰﻳﻞ ﻣﻠﻒ ﻣﻦ اﻹﻧ‬
‫ﺘﻮى ﻧﻈﺎم اﻟ‬
‫ﺘﻌﺪدة ﻫﻮ اﻷﻧ ﺴ ﺐ ﻟﻤ ﺴ‬
‫ﻫﺬا اﻟﻨﻮع ﻣﻦ اﻟﻤﻬﺎم اﻟﻤ‬
‫ﺗﻌﺪد اﻟﻤﻬﺎم ﻋﲆ أﺳﺎس اﻟﻤﻮﺿﻮع‪:‬‬

‫)‪2‬‬
‫ﺘﻌﺪدة اﻟﻘﺎﺋﻤ ﺔ ﻋﲆ اﻟﺨﻴﻂ ‪ ،‬وﻳﻄﻠﻖ ﻋﲆ ﻛﻞ ﺟﺰء‬
‫ﺗ ﺴﻤﻰ اﻟﻤﻬﺎم اﻟﻤ‬
‫ﺒﺮﻧﺎﻣﺞ ‪ ،‬و‬ ‫ﺗﻨﻔﻴﺬ اﻟﻌﺪﻳﺪ ﻣﻦ اﻟﻤﻬﺎم ﻓ ﻲ وﻗ ﺖ واﺣﺪ ﺣﻴ ﺚﺗﻜﻮن ﻛﻞ ﻣﻬﻤ ﺔ ﺟﺰءًا ﻣ ﺴ ً‬
‫ﺘﻘﻼ ﻣﻦ ﻧﻔ ﺲ اﻟ‬ ‫•‬
‫ﺘﻘﻞ اﺳﻢ ‪Thread.‬‬

‫ﻣﺴ‬
‫ﺒﺮﻧﺎﻣﺠ ﻲ‪.‬‬
‫ﺘﻮى اﻟ‬
‫ﺘﻌﺪدة ﻫﻮ اﻷﻧ ﺴ ﺐ ﻋﲆ اﻟﻤ ﺴ‬
‫• ﻫﺬا اﻟﻨﻮع ﻣﻦ اﻟﻤﻬﺎم اﻟﻤ‬
‫ﺑ ﺔ‪.‬‬
‫ﺘﺠﺎ‬
‫ﺘﻌﺪد اﻟﻤﻬﺎم ﻫ ﻲﺗﺤ ﺴﻴﻦ أداء اﻟﻨﻈﺎم ﻋﻦ ﻃﺮﻳﻖﺗﻘﻠﻴﻞ وﻗ ﺖ اﻻﺳ‬
‫ﺋﻴ ﺴﻴ ﺔ ﻟ‬
‫ﺘﻤﺪ ﻋﲆ اﻟﻌﻤﻠﻴ ﺔ أو ﻋﲆ اﻟﺨﻴﻂ ‪ ،‬ﻓﺈن اﻟﻤﻴﺰة اﻟﺮ‬
‫ﻣﻼﺣﻈ ﺔ‪:‬ﺳﻮاء ﻛﺎنﻳﻌ‬
‫ﺘﻌﺪدة ﻫ ﻲ‪:‬‬
‫ﺋﻴ ﺴﻴ ﺔ ﻟﻠﺨﻴﻮط اﻟﻤ‬
‫ﺒﻴﻖ اﻟﻤﻬﻤ ﺔ اﻟﺮ‬
‫ﺘﻄ‬‫ﻣﺠﺎﻻ ت اﻟ‬
‫ﺘﻌﺪدة‬
‫ﺘﻨﻔﻴﺬ رﺳﻮﻣﺎ ت اﻟﻮﺳﺎﺋﻂ اﻟﻤ‬
‫)‪1‬ﻟ‬
‫ﺘﺤﺮﻛ ﺔ‬
‫ﺘﻄﻮﻳﺮ اﻟﺮﺳﻮم اﻟﻤ‬
‫)‪2‬ﻟ‬
‫ﺗﻄﻮﻳﺮ أﻟﻌﺎ ب اﻟﻔﻴﺪﻳﻮ‬

‫)‪3‬‬
‫ﺒﻴﻘﺎ ت‬
‫ﺘﻄ‬‫ﺗﻄﻮﻳﺮ ﺧﻮادم اﻟﻮﻳ ﺐ واﻟ‬
‫)‪4‬‬
‫إﻟﺦ‪...‬‬
‫ﺜﻞ ﻫﺬا اﻟﻨﻮع ﻣﻦ‬ ‫ﺑﺪﻻ ً ﻣﻦ اﻟ‬

‫ﺘﻨﻔﻴﺬ واﺣﺪًاﺗﻠﻮ اﻵﺧﺮ‪ .‬ﻓ ﻲ ﻣ‬ ‫ﺘﻨﻔﻴﺬ ﻓ ﻲ وﻗ ﺖ واﺣﺪ‬
‫ﺑﺎﻟ‬‫ﺑﺸﺪة‬‫ﺘﻘﻠ ﺔ ‪،‬ﻳﻮﺻﻰ‬
‫ﺘﻮاﻓﺮ ﻓﻴﻪ ﻣﺠﻤﻮﻋ ﺔ ﻣﻦ اﻟﻮﻇﺎﺋﻒ اﻟﻤ ﺴ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬ﻓ ﻲ أي وﻗ ﺖﺗ‬
‫اﻟﺤﺎﻻ ت ‪،‬ﻳﺠ ﺐ أن ﻧﺬ ﻫ ﺐ إﱃ ‪Multi Threading.‬‬
‫ﺘﻌﺪدة اﻟﺨﻴﻮط أﻣﺮﺳﻬﻞ‬

‫ﺑﺮاﻣﺞ ﻣ‬‫ﺛﻢ ﻓﺈنﺗﻄﻮﻳﺮ‬‫ﺘﻄﻮﻳﺮ اﻟﺨﻴﻮط‪ .‬وﻣﻦ‬
‫ﺘﻮﻓﻴﺮ اﻟﺪﻋﻢ ﻟ‬
‫ﺑﻂ" ﻟ‬
‫ﺘﺮا‬
‫ﺛﻨﺎﻳﺎه ﻋﻮاﻣﻞ "ﻣﺆﺷﺮا ت اﻟ‬‫ﺗﻮﻓﺮ ‪Python‬وﺣﺪة ﻧﻤﻄﻴ ﺔ واﺣﺪةﺗﺤﻤﻞ ﻓ ﻲ‬
‫•‬
‫ﺜﻮن‪.‬‬
‫ﺑﺎﻳ‬‫ﻟﻠﻐﺎﻳ ﺔ ﻓ ﻲ‬
‫ﺑﻂ واﺣﺪ ﻻﻳﻌﺪو أنﻳﻜﻮن‬

‫ﺘﺮاﺿ ًﻴﺎ ﻋﲆ ﻣﺆﺷﺮﺗﺮا‬
‫ﺑﺮﻧﺎﻣﺞ ‪Python‬اﻓ‬‫ﺘﻮي ﻛﻞ‬
‫•ﻳﺤ‬
‫ﺋﻴ ﺴ ﻲ‪.‬‬
‫ﻣﻮﺿﻮع اﻟﺮ‬
‫‪124‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﻨﻔﻴﺬ اﻟﺤﺎﻟﻴ ﺔ‬
‫ﺒﺎﻋ ﺔ اﺳﻢﺳﻠ ﺴﻠ ﺔ اﻟ‬
‫ﺑﺮﻧﺎﻣﺞ ﻟﻄ‬‫س(‬
‫ﺒﺎﻋ ﺔ ))( ‪("Current Executing Thread:"، threading.current_thread (). getName‬‬

‫ﺘﻴﺮاد ﺧﻴﻮط )‪2‬ﻃ‬
‫)‪1‬اﺳ‬
‫اﻹﺧﺮاج‪:‬ﺗﻨﻔﻴﺬ اﻟﺤﺎﻟ ﻲ اﻟﻤﻮﺿﻮع‪MainThread :‬‬
‫ﺘﺪﻋﻴﻨﺎ ﻃﺮﻳﻘ ﺔ ‪() ،‬‬ ‫ُﺮﺟﻊ ﻛﺎﺋﻦﺳﻠ ﺴﻠ ﺔ اﻟ‬

‫ﺘﻨﻔﻴﺬ اﻟﺤﺎﻟ ﻲ‪ .‬ﻓ ﻲ ﻫﺬا اﻟﻜﺎﺋﻦ ‪ ،‬إذا اﺳ‬ ‫ﺘ ﻲﺗ‬
‫ﺑﻂ ﻋﲆ اﻟﻮﻇﻴﻔ ﺔ )( ‪current_thread‬اﻟ‬
‫ﺘﺮا‬
‫ﺘﻮي وﺣﺪة اﻟ‬
‫ﻣﻼﺣﻈ ﺔ‪:‬ﺗﺤ‬
‫ﺘﻨﻔﻴﺬ اﻟﺤﺎﻟ ﻲ‪.‬‬

‫‪getName‬ﻓ ﺴﻨﺤﺼﻞ ﻋﲆ اﺳﻢﺳﻠ ﺴﻠ ﺔ اﻟ‬
‫ﺜﻮن‪:‬‬
‫ﺑﺎﻳ‬‫ﺑﻂ ﻓ ﻲ‬
‫ﻃﺮق إﻧﺸﺎء ﻣﺆﺷﺮﺗﺮا‬
‫ﺘﺨﺪام ‪3‬ﻃﺮق‬
‫ﺑﺎﺳ‬‫ﺜﻮن‬
‫ﺑﺎﻳ‬‫ﻳﻤﻜﻨﻨﺎ إﻧﺸﺎء ﺧﻴﻂ ﻓ ﻲ‬
‫ﺘﺨﺪام أي ﻓﺌ ﺔ‬
‫)‪1‬إﻧﺸﺎء ﻣﻮﺿﻮع دون اﺳ‬
‫)‪2‬إﻧﺸﺎء ﻣﻮﺿﻮع ﻋﻦ ﻃﺮﻳﻖﺗﻤﺪﻳﺪ ﻓﺌ ﺔ اﻟﻤﻮﺿﻮع‬
‫ﺑﺪونﺗﻤﺪﻳﺪ ﻓﺌ ﺔ اﻟﻤﻮﺿﻮع‬‫)‪3‬إﻧﺸﺎءﺳﻠ ﺴﻠ ﺔ رﺳﺎﺋﻞ‬
‫ﺘﺨﺪام أي ﻓﺌ ﺔ‬
‫)‪1‬إﻧﺸﺎءﺳﻠ ﺴﻠ ﺔ رﺳﺎﺋﻞ دون اﺳ‬
‫*‬
‫ﺒﺎﻋ ﺔ )‪Thread 7‬‬
‫ﺘﻴﺮاد اﻟﺨﻴﻂ )‪2‬ﻋﺮض )‪def (): 3‬ﻟـ ‪i‬ﻓ ﻲ اﻟﻨﻄﺎق )‪(1،11): 4‬ﻃ‬
‫)‪1‬ﻣﻦ اﺳ‬
‫‪(target = display) #creating Thread object 6) t .start () #starting of‬‬
‫‪("Child Thread") 5) t = Thread‬ﻟـ )"‪i in range (1،11): 8) print ("Main Thread‬‬
‫ﺘﻌﺪدة اﻟﺨﻴﻮط‪.‬‬
‫ﺒﺮاﻣﺞ ﻣ‬
‫ﺘﺎﻟ ﻲ ﻻﻳﻤﻜﻨﻨﺎﺗﻮﻗﻊ إﺧﺮاج دﻗﻴﻖ ﻟﻠ‬
‫ﺑﺎﻟ‬
‫ﺘﻨﻔﻴﺬ ‪ ،‬و‬
‫ﺗﻴ ﺐ اﻟ‬
‫ﺑﺮﻧﺎﻣﺠﻨﺎ ‪ ،‬ﻓﻼﻳﻤﻜﻨﻨﺎﺗﻮﻗﻊﺗﺮ‬‫ﻓ ﻲ ﺣﺎﻟ ﺔ وﺟﻮد اﻟﻌﺪﻳﺪ ﻣﻦﺳﻼﺳﻞ اﻟﺮﺳﺎﺋﻞ ﻓ ﻲ‬
‫ﺘﻢﺗﺸﻐﻴﻠﻪ ﻟﻠ‬
‫ﺘﻠﻒ ﻣﻦ آﻟ ﺔ إﱃ أﺧﺮى وﻳ‬
‫ﺒﺮﻧﺎﻣﺞ أﻋﻼه ‪ ،‬ﻓﻬﻮﻳﺨ‬
‫‪B'z‬ﻣﻦ ﻫﺬا ﻻﻳﻤﻜﻨﻨﺎﺗﻮﻓﻴﺮ ﻣﺨﺮﺟﺎ ت دﻗﻴﻘ ﺔ ﻟﻠ‬
‫ﺑﻨﺎ‪.‬‬‫ﺘﺨﺪاﻣﻬﺎ ﻹﻧﺸﺎءﺳﻼﺳﻞ اﻟﺮﺳﺎﺋﻞ اﻟﺨﺎﺻ ﺔ‬

‫ﺘ ﻲﻳﻤﻜﻦ اﺳ‬
‫ﺑﻂ واﻟ‬ ‫ﺒ ًﻘﺎ ﻣﻮﺟﻮدة ﻓ ﻲ وﺣﺪة ﻣﺆﺷﺮا ت اﻟ‬
‫ﺘﺮا‬ ‫ﻣﻼﺣﻈ ﺔ‪ :‬اﻟﻤﻮﺿﻮع ﻫﻮ ﻓﺌ ﺔ ﻣﺤﺪدة ﻣ ﺴ‬
‫ﺘﻮﺳﻴﻊ ﻓﺌ ﺔ اﻟﻤﻮﺿﻮع‬
‫ﺑ‬‫ﺑﻂ‬
‫)‪2‬إﻧﺸﺎء ﻣﺆﺷﺮﺗﺮا‬
‫ﺑ ﺔ‪ .‬ﻋﻨﺪﻣﺎ ﻧﻄﻠﻖ ﻋﲆ ﻃﺮﻳﻘ ﺔ ‪() ،‬‬
‫ﺘﻨﺎ اﻟﻤﻄﻠﻮ‬
‫ﺑﻮﻇﻴﻔ‬
‫ﺘﻌﻴﻦ ﻋﻠﻴﻨﺎﺗﺠﺎوز ﻃﺮﻳﻘ ﺔ )( ‪run‬‬
‫ﻋﻠﻴﻨﺎ إﻧﺸﺎء ﻓﺌ ﺔ ﻓﺮﻋﻴ ﺔ ﻟﻔﺌ ﺔ اﻟﻤﻮﺿﻮع‪ .‬ﻓ ﻲﺗﻠﻚ اﻟﻔﺌ ﺔ اﻟﻔﺮﻋﻴ ﺔ ‪،‬ﻳ‬
‫ﺘﻨﺎ‪.‬‬
‫ﺗﺆدي وﻇﻴﻔ‬
‫ﺗﻠﻘﺎﺋ ًﻴﺎ و‬
‫ﺘﻢﺗﻨﻔﻴﺬ ﻃﺮﻳﻘ ﺔ )( ‪run‬‬
‫‪start‬ﺳﻴ‬
‫‪125‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫*‬
‫ﺘﻴﺮاد اﻟﺨﻴﻂ )‪2‬ﻓﺌ ﺔ )‪() 7 ) t.start () 8‬‬‫)‪1‬ﻣﻦ اﺳ‬
‫‪5) print ("Child Thread-1") 6) t = MyThread‬‬
‫‪3) def run (self): 4) for i in range (10):‬‬
‫ﺒﺎﻋ ﺔ‬
‫‪MyThread‬ﻟـ ‪i‬ﻓ ﻲ اﻟﻨﻄﺎق )‪(10): 9‬ﻃ‬ ‫‪(Thread):‬‬
‫)"‪("Main Thread-1‬‬
‫)‪3‬إﻧﺸﺎءﺳﻠ ﺴﻠ ﺔ اﻟﺮﺳﺎﺋﻞ دونﺗﻤﺪﻳﺪ ﻓﺌ ﺔ اﻟﻤﻮﺿﻮع‬
‫*‬
‫ﺒﺎر‪3) :‬ﻋﺮض ‪def‬‬
‫ﺘ‬‫ﺘﻴﺮاد اﻟﺨﻴﻂ )‪2‬ﻓﺌ ﺔ اﻻﺧ‬‫)‪1‬ﻣﻦ اﺳ‬
‫ﺗ ﻲ(‪4) :‬ﻟـ ‪i‬ﻓ ﻲ اﻟﻨﻄﺎق )‪obj.display) 8) t.start () 9‬‬
‫)ذا‬
‫= ‪6) obj = Test () 7) t = Thread (target‬‬
‫‪i(10):‬ﻟـ )"‪Thread-2‬‬ ‫‪5) print‬‬
‫‪in range‬‬ ‫‪("Child‬‬
‫‪(10):‬‬ ‫)"‪Thread-2‬‬
‫‪10) print‬‬ ‫‪("Main‬‬
‫ﺘﻌﺪدة‬
‫ﺑﺪون ﺧﻴﻮط ﻣ‬
‫*‬
‫ﺑﺎﻷرﻗﺎم ‪7) def :‬‬
‫ﺘﻴﺮاد )‪3‬ﻣﻀﺎﻋﻔﺎ ت ‪)def‬أرﻗﺎم(‪4) :‬ﻟـ ‪n‬‬
‫ﺘﻴﺮاد اﻟﺨﻴﻂ )‪2‬وﻗ ﺖ اﻻﺳ‬
‫)‪1‬ﻣﻦ اﺳ‬
‫ﺑﺎﻷرﻗﺎم ‪11) :‬‬
‫ﺑﻌﺎ ت ) اﻷرﻗﺎم(‪8) :‬ﻟـ ‪n‬‬
‫)‪5) time.sleep (1) 6) print ("Double:"، 2 * n‬اﻟﻤﺮ‬
‫)‪9) time.sleep (1) 10) print ("Square:"، n * n‬اﻷرﻗﺎم )‪begintime = time.time () 13‬‬
‫ﺒﺎﻋ ﺔ "(إﺟﻤﺎﻟ ﻲ اﻟﻮﻗ ﺖ‬
‫ﺑﻌﺎ ت )أرﻗﺎم( )‪15‬ﻃ‬
‫)‪14‬ﻣﺮ‬
‫ﺒﺪء(‬
‫)أرﻗﺎم(‬
‫ﺘﻀﺎﻋﻒوﻗ ﺖ اﻟ‬
‫‪time.time‬‬
‫]‪= [1،2،3،4،5،6‬ﻳ‬
‫ﺘﻐﺮق‪() - ، ":‬‬
‫ﺴ‬‫)‪12‬‬
‫اﻟﻤ‬
‫‪126‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﻌﺪدة‬
‫ﻣﻊ ﺧﻴﻮط ﻣ‬
‫*‬
‫ﺑﺎﻷرﻗﺎم ‪7) def :‬‬
‫ﺘﻴﺮاد )‪3‬ﻣﻀﺎﻋﻔﺎ ت ‪)def‬أرﻗﺎم(‪4) :‬ﻟـ ‪n‬‬
‫)‪1‬ﻣﻦ اﺳ‬
‫ﺑﺎﻷرﻗﺎم ‪:‬‬
‫ﺑﻌﺎ ت ) اﻷرﻗﺎم(‪8) :‬ﻟـ ‪n‬‬
‫)‪5) time.sleep (1) 6) print ("Double:"، 2 * n‬اﻟﻤﺮ‬
‫‪11) 12) number = [1،2،3،4،5،6] 13) Begintime = time.time () 14) t1 = Thread‬‬
‫‪t1.join‬‬
‫ﻷرﻗﺎم ‪= ((،‬‬
‫)‪() 19‬‬
‫‪)args‬ا‬
‫‪t2.join‬‬
‫)‪20‬ﻲ)(‪= ،‬‬
‫اﻟﺰوﺟ‬
‫‪print‬‬
‫)اﻟﻬﺪف =‬
‫‪(" ((،time.sleep‬‬
‫)‪)args(1‬اﻷرﻗﺎم‬
‫)‪ 10‬ت)‪= ،9‬‬
‫ﺑﻌﺎ‬‫اﻟﻤﺮ‬
‫‪print‬‬
‫)اﻟﻬﺪف =‬
‫‪("Square:"،‬‬
‫)‪15‬اﻟﺨﻴﻂ‬
‫‪n * t2‬‬
‫)‪n‬‬
‫ﺘﻐﺮق‪() - Begintime) ، ":‬‬
‫‪16) t1.start () 17) t2.start‬إﺟﻤﺎﻟ ﻲ اﻟﻮﻗ ﺖ اﻟﻤ ﺴ‬ ‫)‪() 18‬‬
‫‪time.time‬‬
‫ﺗﻌﻴﻴﻦ واﻟﺤﺼﻮل ﻋﲆ اﺳﻢﺳﻠ ﺴﻠ ﺔ اﻟﺮﺳﺎﺋﻞ‪:‬‬

‫ﺒﺮﻣﺞ‪.‬‬
‫ﺒﻞ اﻟﻤ‬
‫ﺑﻮاﺳﻄ ﺔ ‪Python‬أو اﻻﺳﻢ اﻟﻤﺨﺼﺺ اﻟﻤﻘﺪم ﻣﻦ ﻗ‬‫ﺘﺮاﺿ ﻲ اﻟﺬيﺗﻢ إﻧﺸﺎؤه‬
‫ﺜﻮن ﻟﻪ اﺳﻢ‪ .‬ﻗﺪﻳﻜﻮن اﻻﺳﻢ اﻻﻓ‬
‫ﺑﻴ‬‫ﻛﻞ ﺧﻴﻂ ﻓ ﻲ‬
‫ﺑﻂ اﻟ‬
‫ﺘﺮا‬
‫ﺘﺨﺪام ﻃﺮق ﻓﺌ ﺔ ﻣﺆﺷﺮ اﻟ‬
‫ﺑﺎﺳ‬‫ﺗﻌﻴﻴﻨﻪ‬
‫ﻳﻤﻜﻨﻨﺎ اﻟﺤﺼﻮل ﻋﲆ اﺳﻢ اﻟﻤﻮﺿﻮع و‬
‫)( ‪t.getName‬إرﺟﺎع اﺳﻢ اﻟﻤﻮﺿﻮع‬
‫ﺑﻨﺎ‬‫ﺘﻌﻴﻴﻦ اﻻﺳﻢ اﻟﺨﺎص‬
‫)‪t.setName (newName‬ﻟ‬
‫ﺜﻴﻞ اﺳﻢ اﻟﻤﻮﺿﻮع‪.‬‬

‫ﺘﻤ‬‫ﺘﻐﻴﺮ ﺿﻤﻨ ﻲ ﻟ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬ﻛﻞﺳﻠ ﺴﻠ ﺔ ﻟﻬﺎ "اﺳﻢ" ﻣ‬
‫*‬
‫ﺒﺎﻋ ﺔ ‪getName ()) 5) print (current_thread ().‬‬
‫ﺑﻂ )‪2‬ﻃ‬
‫ﺘﺮا‬
‫)‪1‬ﻣﻦ اﺳ‬
‫‪(). setName ("Pawan Kalyan") 4) print (current_thread ().‬‬
‫‪(current_thread (). getName ()) 3) current_thread‬اﺳﻢ(‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﺋﻴ ﺴ ﻲ‬
‫ﻣﻮﺿﻮع اﻟﺮ‬
‫ﺑﺎوان ﻛﺎﻟﻴﺎن‬
‫ﺑﺎوان ﻛﺎﻟﻴﺎن‬

‫‪127‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
:(‫رﻗﻢﺗﻌﺮﻳﻒ اﻟﺨﻴﻂ )ﻣﻌﺮف‬

"ident" ‫ﺘﻐﻴﺮ اﻟﻀﻤﻨ ﻲ‬
‫ﺑﺎﺳ‬‫ﻳﻤﻜﻨﻨﺎ اﻟﻮﺻﻮل إﱃ ﻫﺬا اﻟﻤﻌﺮف‬.‫ﺘﻮﻓﺮ رﻗﻢﺗﻌﺮﻳﻒ ﻓﺮﻳﺪ‬
‫ﻳ‬، ‫ﻟﻜﻞ ﺧﻴﻂ داﺧﻠ ًﻴﺎ‬
*
Thread Identification Number:"، current_thread (). ident) 7) ‫ﺒﺎﻋ ﺔ‬
‫ﻃ‬def (): 3) ‫ﺒﺎر‬
‫ﺘ‬‫اﺧ‬2) ‫ﺘﻴﺮاد اﻟﺨﻴﻂ‬
‫ﻣﻦ اﺳ‬1)
، ":‫ﺒﺎﻋ ﺔ "(رﻗﻢﺗﻌﺮﻳﻒ اﻟﺨﻴﻂ اﻟﻔﺮﻋ ﻲ‬

‫"(ﻃ‬Child Thread") 4) t = Thread (target = test) 5) t.start () 6) print ("Main
t.ident)
:‫ﺘﺎج‬
‫اﻧ‬
‫ﺧﻴﻂ اﻟﻄﻔﻞ‬
2492 :‫ﺋﻴ ﺴ ﻲ‬
‫رﻗﻢﺗﻌﺮﻳﻒ اﻟﺨﻴﻂ اﻟﺮ‬
2768 :‫رﻗﻢﺗﻌﺮﻳﻒ اﻟﺨﻴﻂ اﻟﻄﻔﻞ‬
active_count ():
.‫ﺘﺸﻐﻴﻞ ﺣﺎﻟ ًﻴﺎ‬
‫ﺑﺈرﺟﺎع ﻋﺪدﺳﻼﺳﻞ اﻟﺮﺳﺎﺋﻞ اﻟﻨﺸﻄ ﺔ ﻗﻴﺪ اﻟ‬‫ﺗﻘﻮم ﻫﺬه اﻟﻮﻇﻴﻔ ﺔ‬
*
(). getName ()، "... ‫ﺒﺎﻋ ﺔ‬
‫ﻃ‬def (): 4) ‫ﻋﺮض‬3) ‫ﺘﻴﺮاد‬
‫وﻗ ﺖ اﻻﺳ‬2) ‫ﺘﻴﺮاد اﻟﺨﻴﻮط‬
Thread (target = display، name = "ChildThread1") 9) t2 = Thread ("‫ﺑﺪأ‬

(current_thread
()، "... ended") 7) print ("The Number of active Threads:"، active_count ()) 8) t1 =
10)t2.start
12) t3 = ‫ﺳﻢ‬ ()‫اﻻ‬13)
، ‫اﻟﻌﺮض‬ = ‫)اﻟﻬﺪف‬
t3.start () 14) 5) time.sleep
print (" ‫( اﻻﺳﻢ‬3) 6) print
، ‫اﻟﻌﺮض‬ (current_thread
= ‫)اﻟﻬﺪف‬ () .getName
‫" =اﻟﺨﻴﻂ‬ChildThread2")
active Threads:"، active_count ()) ،": ‫" =ﻋﺪد اﻟﺨﻴﻮط اﻟﻨﺸﻄ ﺔ‬ChildThread3") 11) t1.start ()
active_count ()) 15) time.sleep (5) 16) print ("The Number of
:‫ﺘﺎج‬
‫اﻧ‬
\ python_classes> py test.py :‫د‬
1 :‫ﻋﺪد اﻟﺨﻴﻮط اﻟﻨﺸﻄ ﺔ‬
‫ﺑﺪأ‬
ChildThread1 ...
‫ﺑﺪأ ت‬
ChildThread2 ...
‫ﺑﺪأ‬
ChildThread3 ...
128
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﺘﻬﻰ‬
‫اﻧ‬ChildThread1 ...
‫ﺘﻬﻰ‬
‫ﺘﻬﻰ‬
:‫ّد )(اﻟﻮﻇﻴﻔ ﺔ‬
‫ﻋﺪ‬
.‫ﺘﺸﻐﻴﻞ ﺣﺎﻟ ًﻴﺎ‬
‫ﺑﺠﻤﻴﻊ اﻟﻤﻮاﺿﻴﻊ اﻟﻨﺸﻄ ﺔ ﻗﻴﺪ اﻟ‬‫ﺑﺈرﺟﺎع ﻗﺎﺋﻤ ﺔ‬‫ﺗﻘﻮم ﻫﺬه اﻟﻮﻇﻴﻔ ﺔ‬
*
(). getName ()، "... ‫ﺒﺎﻋ ﺔ‬
time.sleep (3) 6) print (current_thread () .getName ()، "... ("‫ﺑﺪأ‬

(current_thread
‫" =اﻟﺨﻴﻂ‬ChildThread1") 8) t2 = ‫ اﻻﺳﻢ‬، ‫اﻟﻤﻮﺿﻮع )اﻟﻬﺪف =اﻟﻌﺮض‬7) t1 = ("‫ﺘﻬ ﺖ‬

‫اﻧ‬5)
for t in l: 15)
10)print (" ‫اﻟﻤﻮﺿﻮع‬
t1.start = "ChildThread2")
() 11) t2.start 9) t3
() 12) t3.start = ‫ﺳﻢ‬
() 13) l =‫اﻻ‬ ، ‫)اﻟﻬﺪف =اﻟﻌﺮض‬
enumerate () 14)
Name: "، t.name) : ‫ (اﺳﻢ اﻟﻤﻮﺿﻮع‬target = display، name = "ChildThread3")
16) time.sleep (5) 17) l = enumerate () 18) for t in l: 19) print (" Thread
"، t.name)
:‫ﺘﺎج‬
‫اﻧ‬

‫ﺑﺪأ‬
ChildThread1 ...
‫ﺑﺪأ ت‬
ChildThread2 ...
‫ﺑﺪأ‬
ChildThread3 ...
MainThread :‫اﺳﻢ اﻟﻤﻮﺿﻮع‬
ChildThread1 :‫اﺳﻢ اﻟﻤﻮﺿﻮع‬
‫ﺘﻬﻰ‬
‫ﺘﻬﻰ‬
‫ﺘﻬﻰ‬
MainThread :‫اﺳﻢ اﻟﻤﻮﺿﻮع‬
129
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
isAlive (): ‫ﻃﺮﻳﻘ ﺔ‬

.‫ﺘﻨﻔﻴﺬ أم ﻻ‬
‫ﺑﻂ ﻻﻳﺰال ﻗﻴﺪ اﻟ‬
‫ﺘﺮا‬
‫ﺘﺤﻘﻖ ﻣﻤﺎ إذا ﻛﺎن ﻣﺆﺷﺮ اﻟ‬
‫ﻳ‬isAlive () ‫أﺳﻠﻮ ب‬
*
(). getName ()، "... ‫ﺒﺎﻋ ﺔ‬
time.sleep (3) 6) print (current_thread () .getName ()، "... ("‫ﺑﺪأ‬

(current_thread
‫" =اﻟﺨﻴﻂ‬ChildThread1") 8) t2 = ‫ اﻻﺳﻢ‬، ‫اﻟﻤﻮﺿﻮع )اﻟﻬﺪف =اﻟﻌﺮض‬7) t1 = ("‫ﺘﻬ ﺖ‬

‫اﻧ‬5)
t1.isAlive ()) 16)

"is Alive print (t2.name،
:"، t2.isAlive "is Alive :"،(5)
()) 14) time.sleep t2.isAlive ())(t1.name،
15) print ‫ اﻻﺳﻢ‬، ‫اﻟﻌﺮض‬
"is =Alive
‫)اﻟﻬﺪف‬
:"،
t2.start () 11) 12) print (t1.name، "is Alive :"، t1.isAlive ()) 13) print (t2.name،
= "ChildThread2") 9) t1.start ( ) 10)
:‫ﺘﺎج‬
‫اﻧ‬
‫ﺑﺪأ‬
ChildThread1 ...
‫ﺑﺪأ ت‬
ChildThread2 ...
‫ ﺻﺤﻴﺢ‬:‫ﺣ ﻲ‬ChildThread1
‫ ﺻﺤﻴﺢ‬:‫ﻋﲆ ﻗﻴﺪ اﻟﺤﻴﺎة‬ChildThread2
‫ﺘﻬﻰ‬
‫ﺘﻬﻰ‬
‫ ﺧﻄﺄ‬:‫ﺣ ﻲ‬ChildThread1
‫ ﺧﻄﺄ‬:‫ﺣ ﻲ‬ChildThread2
(): ‫ﻃﺮﻳﻘ ﺔ اﻻﻧﻀﻤﺎم‬

(). ‫ ﻓﻴﺠ ﺐ أن ﻧﺬ ﻫ ﺐ إﱃ ﻃﺮﻳﻘ ﺔ اﻻﻧﻀﻤﺎم‬، ‫ﺘﻬﺎء ﻣﻦﺳﻠ ﺴﻠ ﺔ أﺧﺮى‬
‫ﺘﻰ اﻻﻧ‬
‫ﺘﻈﺎر ﺣ‬
‫إذا أراد أﺣﺪ اﻟﺨﻴﻮط اﻻﻧ‬
*
‫ﻋﺮض‬3) ‫ﺘﻴﺮاد‬
= ‫اﻟﻤﻮﺿﻮع )اﻟﻬﺪف‬def (): 4) 5) 6) 7) 8) t =
9) t.start () (‫اﻟﻌﺮض‬
time.sleep (2) ‫ﻓ ﻲ اﻟﻨﻄﺎق‬i ‫ﺒ ﺔ ﻟـ‬

(10): print ("Seetha Thread")
130
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﺒﺎﻋ ﺔ )"‪("Rama Thread‬‬

‫ﺑﻮاﺳﻄ ﺔ )‪Main Thread 11‬ﻟـ ‪i‬ﻓ ﻲ اﻟﻨﻄﺎق )‪(10): 12‬ﻃ‬‫ﺗﻢﺗﻨﻔﻴﺬ ﻫﺬا اﻟﺨﻂ‬
‫‪10) t.join () #‬‬
‫ﺗﺞ‪:‬‬
‫ﺘﻤﻞ اﻟﺨﻴﻂ اﻟﻔﺮﻋ ﻲ‪ .‬ﻓ ﻲ ﻫﺬه اﻟﺤﺎﻟ ﺔﻳﻜﻮن اﻟﻨﺎ‬
‫ﺘﻰﻳﻜ‬
‫ﺋﻴ ﺴ ﻲ ﺣ‬
‫ﺘﻈﺮ اﻟﺨﻴﻂ اﻟﺮ‬
‫ﺜﺎل أﻋﻼه ‪ ،‬اﻧ‬
‫ﻣﻮﺿﻮع ‪Seetha‬‬
‫راﻣﺎ اﻟﻤﻮﺿﻮع‬
‫ﺘﺮة اﻟﺰﻣﻨﻴ ﺔ أ ً‬
‫ﻳﻀﺎ‪.‬‬ ‫ﺘﺪﻋﺎء ﻃﺮﻳﻘ ﺔ اﻻﻧﻀﻤﺎم )(ﻣﻊ اﻟﻔ‬
‫ﻣﻼﺣﻈ ﺔ‪:‬ﻳﻤﻜﻨﻨﺎ اﺳ‬
‫ﺜﻮاﻧ ﻲ(‬
‫ﺑﺎﻟ‬
‫‪t.‬اﻻﻧﻀﻤﺎم )‬
‫ﺘﻈﺮ اﻟﺨﻴﻂ ﻣﻘﺪا ًرا ﻣﺤﺪدًا ﻣﻦ اﻟﻮﻗ ﺖ ﻓﻘﻂ‪.‬‬
‫ﻓ ﻲ ﻫﺬه اﻟﺤﺎﻟ ﺔ ‪،‬ﺳﻴﻨ‬
‫*‬
‫ﺘﻴﺮاد )‪3‬ﻋﺮض = ‪def (): 4) 5) 6) 7) 8) t‬‬‫ﺘﻴﺮاد اﻟﺨﻴﻂ )‪2‬وﻗ ﺖ اﻻﺳ‬
‫)‪1‬ﻣﻦ اﺳ‬
‫ﺗﻢﺗﻨﻔﻴﺬ ﻫﺬا اﻟﺨﻂ‬

‫اﻟﻤﻮﺿﻮع )اﻟﻬﺪف =اﻟﻌﺮض( ‪9) t.start () 10) t.join (5) #‬‬
‫ﺒﺎﻋ ﺔ )"‪("Rama Thread‬‬

‫ﺑﻮاﺳﻄ ﺔ )‪Main Thread 11‬ﻟـ ‪i‬ﻓ ﻲ اﻟﻨﻄﺎق )‪(10): 12‬ﻃ‬
‫ﺒ ﺔ ﻟـ ‪i‬ﻓ ﻲ اﻟﻨﻄﺎق )‪(2‬‬

‫‪("Seetha Thread") time.sleep‬‬
‫‪(10): print‬‬
‫‪131‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺛﻮان ﻓﻘﻂ‪.‬‬
‫ٍ‬ ‫ﺋﻴ ﺴ ﻲ ‪5‬‬
‫ﺘﻈﺮ اﻟﺨﻴﻂ اﻟﺮ‬
‫ﻓ ﻲ ﻫﺬه اﻟﺤﺎﻟ ﺔ ‪ ،‬اﻧ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﺑﻂ و ‪Thread‬‬
‫ﺘﺮا‬
‫ﺑﻮﺣﺪة اﻟ‬‫ﺘﻌﻠﻘ ﺔ‬
‫ﻣﻠﺨﺺ ﻟﺠﻤﻴﻊ اﻟﻄﺮق اﻟﻤ‬
‫ﺧﻴﻮط اﻟﺸﻴﻄﺎن‪:‬‬
‫ﺘ ﻲﺗﻌﻤﻞ ﻓ ﻲ اﻟﺨﻠﻔﻴ ﺔ ﺧﻴﻮط اﻟﺸﻴﻄﺎن‪.‬‬
‫ﺗ ﺴﻤﻰ اﻟﺨﻴﻮط اﻟ‬
‫•‬
‫ﺋﻴ ﺴ ﻲ ﻣﻦ ‪ Daemon Threads‬ﻫﻮﺗﻘﺪﻳﻢ اﻟﺪﻋﻢ ﻟـ ‪Non Daemon‬‬

‫•اﻟﻬﺪف اﻟﺮ‬
‫ﺋﻴ ﺴ ﻲ(‬
‫ﺜﻞ اﻟﺨﻴﻂ اﻟﺮ‬
‫اﻟﺨﻴﻮط )ﻣ‬
‫ﺜﺎل‪ :‬ﺟﺎﻣﻊ اﻟﻘﻤﺎﻣ ﺔ‬

‫ﻋﲆﺳ‬
‫ﺘﺸﻐﻴﻞ ‪Garbage‬‬
‫ﺑ‬‫ﺑﺬاﻛﺮة ﻣﻨﺨﻔﻀ ﺔ ‪،‬ﻳﻘﻮم ‪PVM‬ﻋﲆ اﻟﻔﻮر‬
‫ﺘﻢﺗﺸﻐﻴﻞ ‪Main Thread‬‬
‫•ﻋﻨﺪﻣﺎﻳ‬
‫ﺘﻌﺮضﻷي ﻣﺸﺎﻛﻞ ﻓ ﻲ اﻟﺬاﻛﺮة‪.‬‬

‫ﺑﻌ ﺔﺗﻨﻔﻴﺬه دون اﻟ‬
‫ﺘﺎ‬
‫ﺋﻴ ﺴ ﻲ ﻣ‬
‫ﺑﺤﻴ ﺚﻳﻤﻜﻦ ﻟﻠﺨﻴﻂ اﻟﺮ‬‫ﺗﻮﻓﻴﺮ ذاﻛﺮة ﺧﺎﻟﻴ ﺔ ‪،‬‬
‫ﺘﺪﻣﻴﺮ اﻷﺷﻴﺎء ﻏﻴﺮ اﻟﻤﻔﻴﺪة و‬
‫ﺘﺠﻤﻴﻊ ﻟ‬
‫أداة اﻟ‬
‫ﺘﺨﺪام ﻃﺮﻳﻘ ﺔ )( ‪t.isDaemon‬‬

‫ﺑﺎﺳ‬‫ﺘﺤﻘﻖ ﻣﻤﺎ إذا ﻛﺎن اﻟﺨﻴﻂ ﻫﻮ ‪Daemon‬أم ﻻ‬
‫•ﻳﻤﻜﻨﻨﺎ اﻟ‬
‫ﺒﺮﻧﺎﻣﺞ اﻟﺨﻔ ﻲ‪.‬‬

‫ﺘﺨﺪام ﺧﺎﺻﻴ ﺔ اﻟ‬
‫ﺑﺎﺳ‬‫ﺑﻂ أو‬
‫ﺘﺮا‬
‫ﻓﺌ ﺔ ﻣﺆﺷﺮ اﻟ‬
‫*‬
‫ﺒﺎﻋ ﺔ ‪print (current_thread (). daemon) #False‬‬
‫ﺑﻂ )‪2‬ﻃ‬
‫ﺘﺮا‬
‫)‪1‬ﻣﻦ اﺳ‬
‫)‪(current_thread (). isDaemon ()) #False 3‬‬
‫ﺘﺨﺪام ﻃﺮﻳﻘ ﺔ )( ‪setDaemon‬ﻟﻔﺌ ﺔ ‪Thread.‬‬

‫ﺑﺎﺳ‬
‫ﺒﻴﻌ ﺔ اﻟـ ‪Daemon‬‬
‫•ﻳﻤﻜﻨﻨﺎﺗﻐﻴﻴﺮ ﻃ‬
‫‪)t.setDaemon‬ﺻﺤﻴﺢ(‬
‫‪132‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺑﺪء ﻣﻮﺿﻮع ‪ ،‬ﻧﺤﻦ‬‫ﺑﻤﺠﺮد‬

‫ﺑﺪء ‪Thread.ie‬‬‫ﺒﻞ‬
‫ﺘﺨﺪام ﻫﺬه اﻟﻄﺮﻳﻘ ﺔ ﻗ‬
‫•وﻟﻜﻦﻳﻤﻜﻨﻨﺎ اﺳ‬
‫ﺒﺮﻧﺎﻣﺞ اﻟﺨﻔ ﻲ ‪ ،‬وإﻻ ﻓ ﺴﻨﺤﺼﻞ ﻋﲆ ‪• RuntimeException:‬ﻻﻳﻤﻜﻦﺗﻌﻴﻴﻦ ﺣﺎﻟ ﺔ‬

‫ﺒﻴﻌ ﺔ اﻟ‬
‫ﻻﻳﻤﻜﻦﺗﻐﻴﻴﺮ ﻃ‬
‫ﺑﻂ اﻟﻨﺸﻂ‪.‬‬
‫ﺘﺮا‬
‫ﺒﺮﻧﺎﻣﺞ اﻟﺨﻔ ﻲ ﻟﻤﺆﺷﺮ اﻟ‬
‫اﻟ‬
‫*‬
‫ﺒﺎﻋ ﺔ )‪(). setDaemon (True‬‬
‫ﺑﻂ )‪2‬ﻃ‬‫ﺘﺮا‬
‫)‪1‬ﻣﻦ اﺳ‬
‫‪(current_thread (). isDaemon ()) 3) current_thread‬‬
‫ﺑﻂ اﻟﻨﺸﻂ‬
‫ﺘﺮا‬
‫ّﻴ ﺔ ﻟﻤﺆﺷﺮ اﻟ‬
‫‪RuntimeError:‬ﻻﻳﻤﻜﻦﺗﻌﻴﻴﻦ اﻟﺤﺎﻟ ﺔ اﻟﺨﻔ‬
‫ﺒﻴﻌ ﺔ اﻻﻓ‬
‫اﻟﻄ‬
‫ﺒﻴﻌ ﺔ اﻟﺨﻔﻴ ﺔ ﻣﻦ اﻷ ب إﱃ اﻟﻄﻔﻞ‪ .‬أي إذا ﻛﺎن‬
‫ﺘﻢﺗﻮرﻳ ﺚ اﻟﻄ‬
‫ﺒﻘﻴ ﺔ ‪،‬ﺳﻴ‬
‫ﺘ‬‫ﺒ ﺔ ﻟﻠﺨﻴﻮط اﻟﻤ‬
‫ﺑﺎﻟﻨ ﺴ‬‫ﺋﻤﺎ ﻏﻴﺮ ﺧﻔ ﻲ ‪ ،‬وﻟﻜﻦ‬
‫ﺋﻴ ﺴ ﻲ دا ً‬
‫ﺑﻂ اﻟﺮ‬
‫ﺘﺮا‬
‫ﺘﺮاﺿ ًﻴﺎ ‪،‬ﻳﻜﻮن ﻣﺆﺷﺮ اﻟ‬
‫اﻓ‬
‫ﺋﻴ ﺴ ﻲ ﻟﻴ ﺲ ﺧﻔ ًﻴﺎ ‪ ،‬ﻓ ﺴﻴﻜﻮن ‪ChildThread‬‬
‫ﺑﻂ اﻟﺮ‬
‫ﺘﺮا‬ ‫ﺋﻴ ﺴ ﻲ ﻫﻮ ‪Daemon ،‬ﻓﺈن اﻟﺨﻴﻂ اﻟﻔﺮﻋ ﻲ ﻫﻮ أ ً‬
‫ﻳﻀﺎ ‪Daemon‬وإذا ﻛﺎن ﻣﺆﺷﺮ اﻟ‬ ‫ﺑﻂ اﻟﺮ‬
‫ﺘﺮا‬
‫ﻣﺆﺷﺮ اﻟ‬
‫أ ً‬
‫ﻳﻀﺎ‬
‫ﻏﻴﺮ اﻟﺸﻴﻄﺎن‪.‬‬
‫*‬
‫ﺘﻴﺮاد اﻟﺨﻴﻂ ‪False 6) t.setDaemon‬‬
‫)‪1‬ﻣﻦ اﺳ‬
‫‪(target = job) 5) print (t.isDaemon ()) #‬‬
‫‪(): 3) (t.isDaemon‬‬
‫‪print‬‬ ‫)"‪print ("Child Thread‬‬ ‫)‪4) t2‬‬
‫)ﺻﺤﻴﺢ ( ‪()) #‬‬ ‫‪= Thread‬‬
‫‪def job‬‬
‫)‪ 7‬ﺻﺤﻴﺢ‬
‫ﺒﺪاﻳ ﺔ ﻓﻘﻂ‪.‬‬
‫ﺑﺎﻟﻔﻌﻞ ﻓ ﻲ اﻟ‬‫ﺑﺪأ‬‫ﺋﻤﺎ ﻏﻴﺮ ﺧﻔ ﻲ وﻻﻳﻤﻜﻨﻨﺎﺗﻐﻴﻴﺮ ‪Daemon Nature‬ﻷﻧﻪ‬
‫ﺋﻴ ﺴ ﻲ دا ً‬
‫ﻣﻠﺤﻮﻇ ﺔ‪ :‬اﻟﺨﻴﻂ اﻟﺮ‬
‫ﺘﻢ إﻧﻬﺎء ﺟﻤﻴﻊﺳﻼﺳﻞ ﻋﻤﻠﻴﺎ ت ‪Daemon.‬‬

‫ﻋﻨﺪ إﻧﻬﺎء آﺧﺮﺳﻠ ﺴﻠ ﺔ رﺳﺎﺋﻞ ﻏﻴﺮ ﺧﺎﺿﻌ ﺔ ﻟﻠﺨﺪﻣ ﺔﺗﻠﻘﺎﺋ ًﻴﺎ ‪،‬ﺳﻴ‬
‫*‬
‫ﺘﻴﺮاد )‪3‬ﻣﻬﻤ ﺔ )‪(): 4‬‬
‫)‪1‬ﻣﻦ اﺳ‬
‫ﺒﺎﻋ ﺔ ‪(2) 7) 8) t = Thread‬‬
‫‪def‬ﻟـ ‪i‬ﻓ ﻲ اﻟﻨﻄﺎق )‪(10): 5‬ﻃ‬
‫‪)("Lazy Thread") 6) time.sleep‬اﻟﻬﺪف =اﻟﻤﻬﻤ ﺔ(‬
‫)‪time.sleep (5‬‬
‫‪t.setDaemon‬‬ ‫‪12) print‬‬
‫)‪(True‬‬ ‫‪===>("End‬‬
‫)‪Line-1Of10‬‬
‫‪Main‬‬ ‫)"‪Thread‬‬
‫‪t.start‬‬ ‫)‪() 11‬‬
‫‪9) #‬‬
‫‪133‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﻰ‬
‫ﺘﻢﺗﻨﻔﻴﺬ ﻛﻼ ﻫﻤﺎ ﺣ‬
‫ﺘﺎﻟ ﻲﺳﻴ‬
‫ﺑﺎﻟ‬
‫ﺋﻴ ﺴ ﻲ واﻟﺨﻴﻮط اﻟﻔﺮﻋﻴ ﺔ ﻏﻴﺮ ﺷﻴﻄﺎن ‪ ،‬و‬
‫ﺒﺮﻧﺎﻣﺞ أﻋﻼه ‪ ،‬إذا ﻋﻠﻘﻨﺎ ﻋﲆ اﻟ ﺴﻄﺮ اﻷول ‪ ،‬ﻓ ﺴﻴﻜﻮن ﻛﻞ ﻣﻦ اﻟﺨﻴﻂ اﻟﺮ‬
‫ﻓ ﻲ اﻟ‬
‫ﺘﻤﺎﻟﻬﻤﺎ‪.‬‬
‫اﻛ‬
‫ﺗﺞ‪:‬‬
‫ﺧﻴﻂ ﻛ ﺴﻮل‬
‫ﻧﻬﺎﻳ ﺔ اﻟﺨﻴﻂ اﻟﺮ‬
‫ﺛﻢ ﻋﻨﺪ‬‫ﺛﺎ ت اﻟﻔﺮﻋﻴ ﺔ ﻫ ﻲ اﻟﺨﻴﻂ اﻟﺨﻔ ﻲ‪ .‬وﻣﻦ‬

‫ﺋﻴ ﺴﻴ ﺔﺗﻜﻮن ﻏﻴﺮ ﺧﻔﻴ ﺔ وأنﺳﻠ ﺴﻠ ﺔ اﻟﻤﺤﺎد‬
‫ﺛﺎ ت اﻟﺮ‬
‫إذا ﻟﻢ ﻧﻜﻦ ﻧﻌﻠﻖ ﻋﲆ اﻟ ﺴﻄﺮ ‪1 ،‬ﻓﺈنﺳﻠ ﺴﻠ ﺔ اﻟﻤﺤﺎد‬
‫ﺑﻂ اﻟﻔﺮﻋ ﻲ‪ .‬ﻓ ﻲ ﻫﺬه اﻟﺤﺎﻟ ﺔ اﻹﺧﺮاج ﻫﻮ‬
‫ﺘﺮا‬
‫ﺘﻢ إﻧﻬﺎء ﻣﺆﺷﺮ اﻟ‬
‫ﺗﻠﻘﺎﺋ ًﻴﺎ ‪،‬ﺳﻴ‬
‫إﻧﻬﺎء ‪MainThread‬‬
‫ﻧﻬﺎﻳ ﺔ اﻟﺨﻴﻂ اﻟﺮ‬
‫ﺘﺰاﻣﻦ‪:‬‬
‫اﻟ‬
‫إذاﺗﻢﺗﻨﻔﻴﺬ اﻟﻌﺪﻳﺪ ﻣﻦﺳﻼﺳﻞ اﻟﺮﺳﺎﺋﻞ ﻓ ﻲ وﻗ ﺖ واﺣﺪ ‪ ،‬ﻓﻘﺪﺗﻜﻮن ﻫﻨﺎك ﻓﺮﺻ ﺔ ﻟﺤﺪو ث ﻣﺸﺎﻛﻞ ﻋﺪمﺗﻨﺎﺳﻖ اﻟ‬
‫*‬
‫ﺘﻌﺮﻳﻒ‬
‫ﺒ ﺔ اﻟ‬
‫ﺘﻴﺮاد )‪3‬رﻏ‬
‫ﺘﻴﺮاد اﻟﺨﻴﻮط )‪2‬وﻗ ﺖ اﻻﺳ‬
‫)‪1‬ﻣﻦ اﺳ‬
‫ﺒﺎﻋ ﺔ ‪("Good Evening:" ،‬‬
‫)اﻻﺳﻢ(‪4) :‬ﻟـ ‪i‬ﻓ ﻲ اﻟﻨﻄﺎق ‪(10):‬ﻃ‬
‫اﻟﻨﻬﺎﻳ ﺔ )( ‪args = ("Yuvraj"،)) 10) t1.start ( ) 11) t2.start‬‬
‫‪args‬‬
‫)‪(2) 6‬‬ ‫))‪= ("Dhoni"،‬‬
‫‪7) print‬‬ ‫‪9) t1‬‬
‫)‪(name) 8‬‬ ‫‪t2 = Thread (target = wish،‬‬
‫‪= ") 5) time.sleep‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﻣ ﺴﺎء اﻟﺨﻴﺮ‪ :‬ﻣ ﺴﺎء اﻟﺨﻴﺮﻳﻮﻓﺮاج‬
‫دوﻧ ﻲ‬
‫‪134‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﻣ ﺴﺎء اﻟﺨﻴﺮ‪ :‬ﻣ ﺴﺎء اﻟﺨﻴﺮﻳﻮﻓﺮاج‬

‫دوﻧ ﻲ‬
‫‪....‬‬
‫ﺘﺰاﻣﻨ ﺔ )(‬
‫ﺒﺔ ﻣ‬
‫ﺘﻈﻢ ‪b'z‬ﻛﻼ اﻟﺨﻴﻮطﻳﻨﻔﺬان رﻏ‬
‫•ﻧﺤﺼﻞ ﻋﲆ إﺧﺮاج ﻏﻴﺮ ﻣﻨ‬
‫وﻇﻴﻔ ﺔ‪.‬‬
‫ﺘﻐﻠ ﺐ ﻋﻠﻴﻬﺎ‬
‫ﺘﻤﻜﻦ ﻣﻦ اﻟ‬
‫ﺘﻰ ﻧ‬
‫ﺘﻢﺗﻨﻔﻴﺬ اﻟﺨﻴﻮط واﺣﺪةﺗﻠﻮ اﻷﺧﺮى ﺣ‬
‫ﺘﺰاﻣﻦ ‪،‬ﺳﻴ‬
‫ﺘﺰاﻣﻦ‪• .‬ﻓ ﻲ ﺣﺎﻟ ﺔ اﻟ‬
‫ﺘﻐﻠ ﺐ ﻋﲆ ﻫﺬه اﻟﻤﺸﻜﻠ ﺔﻳﺠ ﺐ أن ﻧﺬ ﻫ ﺐ إﱃ اﻟ‬
‫•ﻟﻠ‬
‫ﺘﺰاﻣﻦﻳﻌﻨ ﻲ ﻓ ﻲ وﻗ ﺖ واﺣﺪ ﻣﻮﺿﻮع واﺣﺪ ﻓﻘﻂ‬

‫ﺒﻴﺎﻧﺎ ت‪• .‬اﻟ‬
‫ﻣﺸﺎﻛﻞ ﻋﺪمﺗﻨﺎﺳﻖ اﻟ‬
‫ﺘﺰاﻣﻦ ﻫ ﻲ‬
‫ﺋﻴ ﺴﻴ ﺔ ﻟﻠ‬
‫ﺒﻴﻖ اﻟﺮ‬
‫ﺘﺮﻧ ﺖ‬
‫ﺒﺮ اﻹﻧ‬
‫)‪1‬ﻧﻈﺎم اﻟﺤﺠﺰ ﻋ‬
‫ﺘﺮﻛ ﺔ‬
‫ﺑﺎ ت اﻟﻤﺸ‬
‫ﺗﺤﻮﻳﻞ اﻷﻣﻮال ﻣﻦ اﻟﺤ ﺴﺎ‬
‫)‪2‬‬
‫إﻟﺦ‬
‫ﺘﺨﺪام ﻣﺎﻳﻠ ﻲ‬
‫ﺑﺎﺳ‬‫ﻓ ﻲ ‪Python ،‬ﻳﻤﻜﻨﻨﺎﺗﻨﻔﻴﺬ اﻟﻤﺰاﻣﻨ ﺔ‬
‫)‪1‬ﻗﻔﻞ‬
‫‪2) RLock‬‬
‫)‪3‬ﺳﻴﻤﺎﻓﻮر‬
‫ﺘﺨﺪام ﻣﻔﻬﻮم اﻟﻘﻔﻞ‪:‬‬

‫ﺑﺎﺳ‬‫ﺘﺰاﻣﻦ‬
‫اﻟ‬
‫ﺑﻂ‬
‫ﺘﺮا‬
‫ﺘ ﻲﻳﻮﻓﺮ ﻫﺎ اﻟ‬
‫•اﻷﻗﻔﺎل ﻫ ﻲ آﻟﻴ ﺔ اﻟﻤﺰاﻣﻨ ﺔ اﻷﺳﺎﺳﻴ ﺔ اﻟ‬
‫وﺣﺪة‪.‬‬
‫•ﻳﻤﻜﻨﻨﺎ إﻧﺸﺎء ﻛﺎﺋﻦ ‪Lock‬ﻛﻤﺎﻳﻠ ﻲ )( ‪l = Lock‬‬
‫ﺘﺤﺮﻳﺮ اﻟﻘﻔﻞ‪) .‬ﻋﲆ ﻏﺮار‬

‫ﺑ‬‫ﺘﻰﻳﻘﻮم اﻟﺨﻴﻂ‬
‫ﺘﻈﺮ ﺣ‬
‫ﺑﺨﻴﻂ واﺣﺪ ﻓﻘﻂ ﻓ ﻲ ﻛﻞ ﻣﺮة ‪ ،‬وإذاﺗﻄﻠ ﺐ أي ﺧﻴﻂ آﺧﺮ ﻧﻔ ﺲ اﻟﻘﻔﻞ ﻓﺈﻧﻪﺳﻴﻨ‬‫ﺒﻴ ﺖ ﻛﺎﺋﻦ اﻟﻘﻔﻞ‬
‫ﺜ‬‫•ﻳﻤﻜﻦﺗ‬
‫ﺗﻒ اﻟﻌﺎﻣ ﺔ وﻣﺎ إﱃ ذﻟﻚ(‬
‫ﺑﻴﻨ ﺔ اﻟﻬﺎ‬
‫ﺘﺮﻛ ﺔ وﻛﺎ‬
‫ﻏﺮف اﻟﻐ ﺴﻴﻞ اﻟﻤﺸ‬
‫ﺘ ﺴﺎ ب )( ‪() l.acquire‬‬
‫ﺘﺨﺪام ﻃﺮﻳﻘ ﺔ اﻻﻛ‬
‫ﺑﺎﺳ‬‫•ﻳﻤﻜﻦ ﻟﻠﺨﻴﻂ اﻟﺤﺼﻮل ﻋﲆ اﻟﻘﻔﻞ‬
‫ﺘﺨﺪام اﻹﺻﺪار )(اﻟﻄﺮﻳﻘ ﺔ )( ‪l.release‬‬

‫ﺑﺎﺳ‬‫ﺑﻂﺗﺤﺮﻳﺮ اﻟﻘﻔﻞ‬
‫ﺘﺮا‬
‫•ﻳﻤﻜﻦ ﻟﻤﺆﺷﺮ اﻟ‬
‫ﺜﻨﺎء‬
‫ﺘ‬‫ﺑﺎﻟﻔﻌﻞ ‪ ،‬وإﻻﺳﻨﺤﺼﻞ ﻋﲆ اﺳ‬‫ﺘﻮي اﻟﺨﻴﻂ ﻋﲆ اﻟﻘﻔﻞ‬
‫ﺘﺪﻋﺎء اﻹﺻﺪار ‪() ،‬ﻳﺠ ﺐ أنﻳﻜﻮن اﻟﺨﻴﻂ اﻹﻟﺰاﻣ ﻲ ﻫﻮ ﻣﺎﻟﻚ ﻫﺬا اﻟﻘﻔﻞ‪.‬ﻳﺠ ﺐ أنﻳﺤ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬ﻻﺳ‬
‫ﺘﺸﻐﻴﻞﻳﻘﻮل‬
‫وﻗ ﺖ اﻟ‬
‫ﺘﺸﻐﻴﻞ‪ :‬ﺣﺮر ﻗﻔﻞ ﻏﻴﺮ ﻣﻘﻔﻞ‪.‬‬
‫ﺧﻄﺄ وﻗ ﺖ اﻟ‬
‫*‬
‫)( ‪() 3) # l.acquire‬‬ ‫ﺘﻴﺮاد اﻟﺨﻴﻮط = ‪2) l‬ﻗﻔﻞ )( ‪1 4) l.release‬‬
‫)‪1‬ﻣﻦ اﺳ‬
‫اﻟﻤﺆﻣ ﻦ‬
‫ﱠ‬ ‫إذا ﻛﻨﺎ ﻧﻌﻠﻖ ﻋﲆ اﻟ ﺴﻄﺮ ‪1 ،‬ﻓ ﺴﻨﺤﺼﻞ ﻋﲆ ‪RuntimeError:‬ﺣﺮر اﻟﻘﻔﻞ ﻏﻴﺮ‬
‫*‬
‫ﺘﻴﺮاد‬
‫ﺘﻴﺮاد ﺧﻴﻮط )‪2‬وﻗ ﺖ اﻻﺳ‬
‫)‪1‬ﻣﻦ اﺳ‬
‫‪135‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫= ‪(target = wish، args = ("Yuvraj"،)) 14) t3‬‬

‫‪= wish، args = ("Dhoni"،)) 13) t2 = Thread‬‬
‫)‪10‬‬
‫‪endl.release‬‬ ‫)‪() 11‬‬
‫‪= ") 8) time‬‬ ‫‪12) t1‬‬
‫‪.sleep‬‬ ‫)‪(2)= 9‬‬
‫‪Thread‬‬ ‫‪(target‬‬
‫)‪print (name‬‬
‫‪l for‬‬ ‫‪i in range‬‬
‫‪= Lock‬‬ ‫‪(10):‬‬
‫‪() 4) def‬‬ ‫‪wish‬‬‫‪7) (name):‬‬
‫‪print ("Good‬‬ ‫‪Evening:"،‬‬
‫‪5) l.acquire‬‬ ‫)‪() 6‬‬
‫)‪t2.start () 17‬‬ ‫‪t3.start‬‬
‫‪args‬‬ ‫ﺒ ﺔ ‪() ،‬‬
‫)‪15‬اﻟﺮﻏ‬
‫))‪= ("Kohli"،‬‬ ‫)اﻟﻬﺪف =‬ ‫اﻟﺨﻴﻂ‬
‫‪t1.start‬‬ ‫)‪3‬‬
‫)‪() 16‬‬
‫ﺘﻈﻢ‪.‬‬
‫ﺘﺎﻟ ﻲﺳﻨﺤﺼﻞ ﻋﲆ إﺧﺮاج ﻣﻨ‬
‫ﺑﺎﻟ‬
‫ﺘﻨﻔﻴﺬ ﻃﺮﻳﻘ ﺔ ‪wish () ،‬و‬
‫ﺑ‬‫ﺑﺨﻴﻂ واﺣﺪ ﻓﻘﻂ‬‫ُﺴﻤﺢ‬
‫ﺒﺮﻧﺎﻣﺞ أﻋﻼه ‪ ،‬ﻓ ﻲ ﻛﻞ ﻣﺮة ‪،‬ﻳ‬
‫ﻓ ﻲ اﻟ‬
‫ﺒ ﺴﻴﻂ‪:‬‬
‫ﻣﺸﻜﻠ ﺔ اﻟﻘﻔﻞ اﻟ‬
‫ﺘﻰ أن‬
‫ﺘﻢ ﺣﻈﺮه ‪ ،‬ﺣ‬
‫ﺑﺎﻟﺨﻴﻂ اﻟﺬيﻳﺤﻤﻞ ﻫﺬا اﻟﻘﻔﻞ ﺣﺎﻟ ًﻴﺎ ‪ ،‬ﻓﺈذاﺗﻢﺗﻌﻠﻴﻖ اﻟﻘﻔﻞ وﻣﺤﺎوﻟ ﺔ أي ﺧﻴﻂ ﻟﻠﺤﺼﻮل ﻋﲆ اﻟﻘﻔﻞ ‪ ،‬ﻓ ﺴﻴ‬‫ﺘﻢ ﻛﺎﺋﻦ اﻟﻘﻔﻞ اﻟﻘﻴﺎﺳ ﻲ‬
‫ﻻﻳﻬ‬
‫ﺑﺎﻟﻔﻌﻞ‪.‬‬‫ﻧﻔ ﺲ اﻟﺨﻴﻂﻳﺤﻤﻞ ﻫﺬا اﻟﻘﻔﻞ‬
‫*‬
‫ﺘﻴﺮاد اﻟﺨﻴﻮط ‪2) l = Lock () 3) print ("Main Thread‬ﻳﺤﺎول اﻟﺤﺼﻮل ﻋﲆ‬
‫)‪1‬ﻣﻦ اﺳ‬
‫‪Lock") 4) l.acquire () 5) print ("Main Thread‬ﻳﺤﺎول اﻟﺤﺼﻮل ﻋﲆ ‪Again") 6) l.‬‬
‫ﺘ ﺴ ﺐ)(‬
‫‪Lock‬ﻳﻜ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﺋﻴ ﺴ ﻲﻳﺤﺎول اﻟﺤﺼﻮل ﻋﲆ اﻟﻘﻔﻞ‬
‫اﻟﻤﻮﺿﻮع اﻟﺮ‬
‫ﺋﻴ ﺴ ﻲﻳﺤﺎول اﻟﺤﺼﻮل ﻋﲆ ‪Lock‬ﻣﺮة أﺧﺮى‬
‫اﻟﻤﻮﺿﻮع اﻟﺮ‬
‫‪-‬‬
‫ﺛﺎﻧﻴ ﺔ‪.‬‬‫ﺋﻴ ﺴ ﻲ ‪b'z‬اﻟﺬيﻳﺤﺎول اﻟﺤﺼﻮل ﻋﲆ اﻟﻘﻔﻞ ﻣﺮة‬

‫ﺘﻢ ﺣﻈﺮ اﻟﺨﻴﻂ اﻟﺮ‬
‫ﻓ ﻲ اﻟ‬
‫ﺘﺨﺪام ‪ ctrl + break.‬ﻫﻨﺎ ﻟﻦﻳﻌﻤﻞ ‪ctrl + C.‬‬

‫ﺘﻌﻴﻦ ﻋﻠﻴﻨﺎ اﺳ‬
‫ﺑﻂ اﻟﺤﻈﺮ ﻣﻦ ﻣﻮﺟﻪ أواﻣﺮ ‪windows ،‬ﻳ‬
‫ﺘﻞ ﻣﺆﺷﺮﺗﺮا‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬ﻟﻘ‬
‫ﺗﻜﺮا ًرا ‪ ،‬ﻣﻤﺎ ﻗﺪ‬

‫ﺑﻂ اﻟﺤﺼﻮل ﻋﲆ ﻧﻔ ﺲ اﻟﻘﻔﻞ ﻣﺮا ًرا و‬
‫ﺘﺮا‬
‫ﺘﺪاﺧﻞ إﱃ اﻟﻤﻮارد ‪ ،‬ﻓﻘﺪﻳﺤﺎول ﻣﺆﺷﺮ اﻟ‬
‫ﺘﻜﺮرة أو وﺻﻮل ﻣ‬
‫ﺘﺪﻋ ﻲ وﻇﺎﺋﻒ ﻣ‬
‫ﺑﻂﻳ ﺴ‬
‫ﺘﺮا‬
‫إذا ﻛﺎن ﻣﺆﺷﺮ اﻟ‬
‫ﺑﻨﺎ‪.‬‬‫ﺑﻂ اﻟﺨﺎص‬
‫ﺘﺮا‬
‫ﻳﺤﻈﺮ ﻣﺆﺷﺮ اﻟ‬

‫اﻟ‬
‫‪136‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺘﻨﻔﻴﺬ اﻟﻮﻇﺎﺋﻒ اﻟﻌﻮدﻳ ﺔ‪.‬‬

‫ﺘﻘﻠﻴﺪﻳ ﺔ ﻟﻦﺗﻌﻤﻞ ﻟ‬
‫ﺛﻢ ﻓﺈن آﻟﻴ ﺔ اﻟﻘﻔﻞ اﻟ‬‫وﻣﻦ‬
‫ﺘﻐﻠ ﺐ ﻋﲆ ﻫﺬه اﻟﻤﺸﻜﻠ ﺔ ‪،‬ﻳﺠ ﺐ أن ﻧﺬ ﻫ ﺐ إﱃ ‪RLock (Reentrant Lock). Reentrant‬ﻳﻌﻨ ﻲ أن اﻟﺨﻴﻂﻳﻤﻜﻨﻪ اﻟﺤﺼﻮل ﻋﲆ ﻧﻔ ﺲ اﻟﻘﻔﻞ ﻣﺮا ًرا‬
‫ﻟﻠ‬
‫ﺘﻢ ﺣﻈﺮ اﻟﺨﻴﻂ ﻓﻘﻂ‪.‬‬
‫ﺑﻮاﺳﻄ ﺔ ﺧﻴﻮط أﺧﺮى ‪ ،‬ﻓ ﺴﻴ‬‫ﺗﻜﺮا ًرا ‪ ،‬إذاﺗﻢﺗﻌﻠﻴﻖ اﻟﻘﻔﻞ‬
‫و‬
‫ﺑﺎﻟﻤﺎﻟﻚ وﻟﻜﻦ ﻟﻴ ﺲ ﻟﻠﻤﻮاﺿﻴﻊ اﻷﺧﺮى‪.‬‬‫ﺑﻂ اﻟﺨﺎص‬

‫ﺘﺮا‬
‫ﺘﺎﺣ ﺔ ﻓﻘﻂ ﻟﻤﺆﺷﺮ اﻟ‬
‫ﻣﻴﺰة ‪Reentrant‬ﻣ‬
‫*‬
‫ﺋﻴ ﺴ ﻲﻳﺤﺎول اﻟﺤﺼﻮل‬
‫ﺒﺎﻋ ﺔ )"اﻟﺨﻴﻂ اﻟﺮ‬
‫ﺘﻴﺮاد اﻟﺨﻴﻮط )‪2) l = RLock () 3‬ﻃ‬
‫)‪1‬ﻣﻦ اﺳ‬
‫ﺋﻴ ﺴ ﻲﻳﺤﺎول اﻟﺤﺼﻮل ﻋﲆ ‪6) l.‬‬
‫ﺒﺎﻋ ﺔ )"اﻟﺨﻴﻂ اﻟﺮ‬
‫ﻋﲆ )‪Lock") 4) l.acquire () 5‬ﻃ‬
‫ﺘ ﺴ ﺐ)(‬
‫)"‪Lock Again‬ﻳﻜ‬
‫ﺋﻴ ﺴ ﻲ ‪،‬ﻳﻤﻜﻦ ﻟﺨﻴﻂ ‪b'z‬اﻟﺤﺼﻮل ﻋﲆ اﻟﻘﻔﻞ أي ﻋﺪد ﻣﻦ اﻟﻤﺮا ت‪.‬‬

‫ﺘﻢ ﻗﻔﻞ اﻟﺨﻴﻂ اﻟﺮ‬
‫ﻓ ﻲ ﻫﺬه اﻟﺤﺎﻟ ﺔ ‪ ،‬ﻟﻦﻳ‬
‫ﺜﺎل ‪،‬‬
‫ﺘﺎﺣ ﺔ‪ .‬ﻋﲆﺳ‬
‫ﺘ ﺴﺎ ب )(إﻃﻼق إﻟﺰاﻣ ﻲ ﻟﻠﻤﻜﺎﻟﻤ ﺔ )(ﻣ‬
‫ﺘﺎﻟ ﻲﻳﺠ ﺐ أنﺗﻜﻮن ﻛﻞ ﻣﻜﺎﻟﻤ ﺔ اﻛ‬
‫ﺑﺎﻟ‬
‫ﺘﻮى اﻟﻌﻮدﻳ ﺔ و‬
‫ﺒﻊ ﻣ ﺴ‬
‫ﺘ‬‫ﺘ‬‫ﺑ‬‫ﻳﻘﻮم ‪ RLock‬ﻫﺬا‬
‫ﺘﻢﺗﺤﺮﻳﺮ اﻟﻘﻔﻞ ﻓﻘﻂ‪.‬‬
‫ﺛﻢﻳ‬
‫ﺘﺤﺮﻳﺮ )(‬
‫ﺘﺤﻮاذ )(وﻣﻜﺎﻟﻤﺎ ت اﻟ‬
‫ﺑﻘ ﺔ ﻋﺪد ﻣﻜﺎﻟﻤﺎ ت اﻻﺳ‬
‫ﻳﺠ ﺐ ﻣﻄﺎ‬
‫ﺜﺎل‪:‬‬
‫ﻋﲆﺳ‬
‫)( ‪l = RLock‬‬
‫)( ‪l.acquire‬‬
‫)( ‪l.release‬‬
‫ﺘﻢﺗﺤﺮﻳﺮ اﻟﻘﻔﻞ ﻓﻘﻂ‪.‬‬

‫ﺗﻴﻦ )(ﺳﻴ‬
‫ﺑﻌﺪ ﻣﻜﺎﻟﻤﺎ ت اﻹﺻﺪار ﻣﺮ‬
‫)‪1‬ﻳﻤﻜﻦ ﻓﻘﻂ ﻟﻤﺎﻟﻚ اﻟﺨﻴﻂ اﻟﺤﺼﻮل ﻋﲆ اﻟﻘﻔﻞ ﻋﺪة ﻣﺮا ت‬

‫ﺘﺤﺮﻳﺮ ‪().‬‬
‫ﺘﺤﻮاذ )(وﻣﻜﺎﻟﻤﺎ ت اﻟ‬
‫ﺑﻘ ﺔ ﻋﺪد ﻣﻜﺎﻟﻤﺎ ت اﻻﺳ‬
‫)‪2‬ﻳﺠ ﺐ ﻣﻄﺎ‬
‫ﺘﺨﺪام ‪RLock:‬‬
‫ﺒ ﻲ ﻟﻠ‬
‫*‬
‫ﺘﻴﺮاد‬
‫)‪1‬ﻣﻦ اﺳ‬
‫ﺘﻌﺮﻳﻒ )‪() 6‬‬
‫)‪3) l = RLock () 4‬ﻋﺎﻣﻞ اﻟ‬
‫‪(n): 5) l.acquire‬إذا ﻛﺎن )‪n == 0: 7‬‬
‫ﺘﻴﺠ ﺔ ‪= 1‬‬
‫اﻟﻨ‬
‫‪137‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫‪t1‬‬
‫‪def‬‬
‫اﻟﻌﺎﻣﻞ =‬
‫ﺘﻴﺠ‪"،‬ﺔ إرﺟﺎع‬
‫ﻫﻮ‪:‬‬
‫)‪(n-1‬ﻧ‬
‫)‪(n): 14‬‬
‫‪10) print‬‬
‫‪l.release‬‬
‫‪("The‬‬
‫)‪() 11‬‬
‫‪Factorial‬‬
‫‪=of"،‬ﻋﺎﻣﻠ ﻲ‬
‫ﺘﻴﺠ ﺔ‪n *n،‬‬
‫ﺋﺞ "‬
‫ﺘﺎاﻟﻨ‬
‫‪else:‬اﻟﻨ)‪8‬‬
‫)‪12) 13‬‬
‫)‪9‬‬
‫‪args = args‬اﻟﺨﻴﻂ )اﻟﻬﺪف =‬
‫)‪(5،)) 17‬‬
‫‪= (9t2‬‬
‫)‪،))=18‬‬
‫ﺋﺞ ‪،‬‬
‫‪t1.start‬‬
‫ﺘﺎ‬‫)اﻟﻬﺪف =اﻟﻨ‬
‫اﻟﺨﻴﻂ )‪() 19‬‬
‫)‪(n))()15‬‬
‫ﺋﺞ ‪،‬‬
‫)‪16‬‬
‫ﺘﺎ‬‫اﻟﻨ‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫ﻣﻀﺮو ب اﻟﻌﺪد ‪ 5‬ﻫﻮ‪120 :‬‬
‫ﻣﻀﺮو ب اﻟﻌﺪد ‪ 9‬ﻫﻮ‪362880 :‬‬
‫ﺘﻢ ﺣﻈﺮ اﻟﺨﻴﻂ‪.‬‬ ‫ﺑﺪﻻ ً ﻣﻦ ‪RLock‬إذا اﺳ‬

‫ﺘﺨﺪﻣﻨﺎ ﻗﻔﻞ ﻋﺎدي ‪ ،‬ﻓ ﺴﻴ‬ ‫ﺒﺮﻧﺎﻣﺞ أﻋﻼه‬
‫ﻓ ﻲ اﻟ‬
‫ﺑﻴﻦ اﻟﻘﻔﻞ و ‪RLock‬‬‫اﻟﻔﺮق‬

‫ﻗﻔﻞ‬ ‫‪RLock‬‬
‫ﺑﻂ واﺣﺪ ﻓﻘﻂ‬

‫)‪1‬ﻳﻤﻜﻦ اﻟﺤﺼﻮل ﻋﲆ ﻛﺎﺋﻦ اﻟﻘﻔﻞ ﻣﻦ ﺧﻼل ﻣﺆﺷﺮﺗﺮا‬ ‫ﺑﻂ واﺣﺪ ﻓﻘﻂ ﻓ ﻲ‬
‫)‪1‬ﻳﻤﻜﻦ اﻟﺤﺼﻮل ﻋﲆ ﻛﺎﺋﻦ ‪RLock‬ﻣﻦ ﺧﻼل ﻣﺆﺷﺮﺗﺮا‬
‫ﺑﻂ اﻟﻤﺎﻟﻚ ﻻﻳﻤﻜﻦ أ ً‬
‫ﻳﻀﺎ اﻟﺤﺼﻮل ﻋﻠﻴﻪ ﻋﺪة‬ ‫ﺘﻰ ﻣﺆﺷﺮﺗﺮا‬
‫ﻓ ﻲ ﻛﻞ ﻣﺮة‪ .‬ﺣ‬ ‫ﻛﻞ ﻣﺮة ‪ ،‬وﻟﻜﻦﻳﻤﻜﻦ اﻟﺤﺼﻮل ﻋﲆ ﻛﺎﺋﻦ اﻟﻘﻔﻞ ﻧﻔ ﺴﻪ ﻋﺪة ﻣﺮا ت‪.‬‬
‫ﻣﺮا ت‪.‬‬
‫ﺘﺪاﺧﻠ ﺔ‪.‬‬
‫ﺘﻨﻔﻴﺬ اﻟﻮﻇﺎﺋﻒ اﻟﻌﻮدﻳ ﺔ وﻣﻜﺎﻟﻤﺎ ت اﻟﻮﺻﻮل اﻟﻤ‬
‫)‪2‬ﻏﻴﺮ ﻣﻨﺎﺳ ﺐ ﻟ‬ ‫ﺘﺪاﺧﻠ ﺔ‪.‬‬
‫ﺘﻨﻔﻴﺬ اﻟﻮﻇﺎﺋﻒ اﻟﻌﻮدﻳ ﺔ وﻣﻜﺎﻟﻤﺎ ت اﻟﻮﺻﻮل اﻟﻤ‬
‫)‪2‬اﻷﻧ ﺴ ﺐ ﻟ‬
‫ﺘﻜﺮار‬
‫ﺑﻂ اﻟﻤﺎﻟﻚ واﻟ‬
‫ﺑ ﺴﻠ ﺴﻠ ﺔﺗﺮا‬‫ﺑﺪًا‬
‫ﺘﻢ أ‬
‫اﻟﻤﺆﻣ ﻦ وﻟﻦﻳﻬ‬
‫ﻏﻴﺮأو ﻏﻴﺮ ﱠ‬
‫ﻣﺆﻣﻨًﺎ‬
‫ﺑﺎﻟﻘﻔﻞ أو‬
‫ﻓﻘﻂإذا ﻛﺎن‬
‫ﺑﻤﺎ‬
‫‪RLock‬‬
‫ﻋﻨﺼﺮ ‪Lock‬‬
‫ﺘﻢ ﻛﺎﺋﻦ‬
‫)‪3‬ﻓ ﻲ ﻫﺬه اﻟﺤﺎﻟ ﺔ ‪،‬ﺳﻴﻬ‬
‫ﺘﻮى اﻟﻌﻮدﻳ ﺔ‪.‬‬
‫ﺑﻂ اﻟﻤﺎﻟﻚ ‪ ،‬وﻣ ﺴ‬
‫ﻣﺆﻣﻦ وﻣﻌﻠﻮﻣﺎ ت ﻣﺆﺷﺮﺗﺮا‬
‫ﺘﻮى‪.‬‬
‫ﻣﺴ‬
‫ﺘﺨﺪامﺳﻴﻤﺎﻓﻮر‪:‬‬
‫اﻟ‬
‫ﺑﻂ واﺣﺪ ﻓﻘﻂ‪.‬‬
‫ﺘﻨﻔﻴﺬ ﻣﺆﺷﺮﺗﺮا‬
‫ﺑ‬‫ُﺴﻤﺢ‬
‫ﻓ ﻲ ﺣﺎﻟ ﺔ ‪Lock‬و ‪RLock ،‬ﻓ ﻲ ﻛﻞ ﻣﺮةﻳ‬
‫ﺑﺎﻟﻮﺻﻮل‬‫ُﺴﻤﺢ ﻓﻴﻪ ﻟـ ‪10‬أﻋﻀﺎء‬

‫ﺜﻞ ﻓ ﻲ اﻟﻮﻗ ﺖ اﻟﺬيﻳ‬
‫ﺑﺎﻟﻮﺻﻮل )ﻣ‬‫ﺒﻨﺎ ﻓ ﻲ وﻗ ﺖ ﻣﺎﻳ ﺴﻤﺢ ﻟﻌﺪد ﻣﻌﻴﻦ ﻣﻦﺳﻼﺳﻞ اﻟﺮﺳﺎﺋﻞ‬
‫ﺑﻌﺾ اﻷﺣﻴﺎنﻳﻜﻮن ﻣﻄﻠ‬‫ﻓﻲ‬
‫ﺘﺨﺪام ‪Lock‬وﻣﻔﺎ ﻫﻴﻢ‬
‫ﺘﻌﺎﻣﻞ ﻣﻊ ﻫﺬا اﻟﻤﻄﻠ ﺐ ﻻﻳﻤﻜﻨﻨﺎ اﺳ‬
‫ﺒﻜ ﺔ وﻣﺎ إﱃ ذﻟﻚ(‪ .‬ﻟﻠ‬
‫ﺗﺼﺎل اﻟﺸ‬
‫ﺑﺎﻟﻮﺻﻮل إﱃ ا‬‫ُﺴﻤﺢ ﻟـ ‪4‬أﻋﻀﺎء‬
‫ﺒﻴﺎﻧﺎ ت ‪،‬ﻳ‬
‫إﱃ ﺧﺎدم ﻗﺎﻋﺪة اﻟ‬
‫‪RLock‬وﻳﺠ ﺐ أن ﻧﺬ ﻫ ﺐ ﻟﻤﻔﻬﻮم ‪Semaphore.‬‬
‫ﺑﺸﻜﻞ ﻣﺤﺪود‬‫ﺘﺮﻛ ﺔ‬
‫ﺘﺨﺪام ‪Semaphore‬ﻟﻠﺤﺪ ﻣﻦ اﻟﻮﺻﻮل إﱃ اﻟﻤﻮارد اﻟﻤﺸ‬
‫ﺳﻌ ﺔ‪.‬‬
‫ﺘﻘﺪﻣ ﺔ‪.‬‬
‫ﻫ ﻲ آﻟﻴ ﺔﺗﺰاﻣﻦ ﻣ‬ ‫‪Semaphore‬‬
‫‪138‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﺎﻟ ﻲ )‪s = Semaphore (counter‬‬

‫ﻳﻤﻜﻨﻨﺎ إﻧﺸﺎء ﻛﺎﺋﻦ ‪Semaphore‬ﻋﲆ اﻟﻨﺤﻮ اﻟ‬
‫ﺘﺮاﺿﻴ ﺔ ﻟﻠﻌﺪاد ﻫ ﻲ ‪1.‬‬
‫ﺑﺎﻟﻮﺻﻮل إﻟﻴﻬﺎ ﻓ ﻲ وﻗ ﺖ واﺣﺪ‪ .‬اﻟﻘﻴﻤ ﺔ اﻻﻓ‬‫ﺜﻞ اﻟﻌﺪاد اﻟﺤﺪ اﻷﻗﺼﻰ ﻟﻌﺪد اﻟﺨﻴﻮط اﻟﻤ ﺴﻤﻮح‬
‫ﻫﻨﺎﻳﻤ‬
‫ﺘﻜﻮن ﻗﻴﻤ ﺔ اﻟﻌﺪاد‬

‫ﺘﺤﻮاذ ‪() ،‬ﺳ‬
‫ﻋﻨﺪﻣﺎﻳﻨﻔﺬ اﻟﺨﻴﻂ ﻃﺮﻳﻘ ﺔ اﻻﺳ‬
‫ﺑﻤﻘﺪار ‪1.‬‬‫ﺘﻢ زﻳﺎدة ﻗﻴﻤ ﺔ اﻟﻌﺪاد‬
‫ﺘ‬‫ﺑﻂ ﻃﺮﻳﻘ ﺔ اﻹﻃﻼق ‪() ،‬ﻓ ﺴ‬
‫ﺘﺮا‬
‫ﺑﻤﻘﺪار ‪1‬وإذا ﻧﻔﺬ ﻣﺆﺷﺮ اﻟ‬‫ﺗﻢﺗﻘﻠﻴﻠﻪ‬
‫ﺘ ﺴﺎ ب )(وﻟﻜﻞ إﺻﺪار )(‬

‫ﺘﺪﻋﺎء ﻟﻜﻞ ﻋﻤﻠﻴ ﺔ اﻛ‬
‫ﺘﻨﺨﻔﺾ ﻗﻴﻤ ﺔ ﻋﺪاد اﻻﺳ‬
‫ﺜﺎل ‪،‬ﺳ‬
‫ﻋﲆﺳ‬
‫ﺘﺪﻋﺎء‪.‬‬
‫ﺘﻢ زﻳﺎدة ﻗﻴﻤ ﺔ ﻋﺪاد اﻻﺳ‬
‫ﺳﻴ‬
‫ﺣﺎﻟ ﺔ ‪ -1:‬ق =ﺳﻴﻤﺎﻓﻮر )(‬

‫ﺒﻂ ﻧﻔ ﺲ ﻣﻔﻬﻮم اﻟﻘﻔﻞ‪.‬‬
‫ﺑﺎﻟﻀ‬‫ﺑﻂ واﺣﺪ ﻓﻘﻂ‪ .‬إﻧﻪ‬
‫ﺑﺎﻟﻮﺻﻮل إﱃ ﻣﺆﺷﺮﺗﺮا‬‫ُﺴﻤﺢ‬
‫ﻓ ﻲ ﻫﺬه اﻟﺤﺎﻟ ﺔ ‪،‬ﺗﻜﻮن ﻗﻴﻤ ﺔ اﻟﻌﺪاد ‪1‬وﻓ ﻲ ﻛﻞ ﻣﺮةﻳ‬
‫اﻟﺤﺎﻟ ﺔ = ‪2: s‬ﺳﻴﻤﺎﻓﻮر )‪(3‬‬

‫ﺘﻰﺗﺤﺮﻳﺮ اﻹﺷﺎرة‪.‬‬
‫ﺒﻘﻴ ﺔ ﺣ‬
‫ﺘ‬‫ﺘﻈﺮ اﻟﺨﻴﻮط اﻟﻤ‬
‫ﺑﻮاﺳﻄ ﺔ ‪3‬ﺧﻴﻮط ﻓ ﻲ وﻗ ﺖ واﺣﺪ‪.‬ﻳﺠ ﺐ أنﺗﻨ‬
‫ﻓ ﻲ ﻫﺬه اﻟﺤﺎﻟ ﺔ ‪،‬ﻳﻤﻜﻦ اﻟﻮﺻﻮل إﱃ ﻛﺎﺋﻦ ‪Semaphore‬‬
‫*‬
‫ﺘﻴﺮاد = ‪= ("Dhoni"،)) 13 ) t2‬‬
‫)‪1‬ﻣﻦ اﺳ‬
‫‪10) s.release () 11) 12) t1 = Thread (target = wish، args‬‬
‫)‪Evening: "، end =") 8) time.sleep (2) 9) print (name‬‬
‫‪5) s.acquire () 6) for i in range (10): 7) print ("Good‬‬
‫)اﻟﻬﺪف‪== ،‬‬
‫اﻟﺨﻴﻂ =اﻟﺮﻏ‬
‫ﺒﺔ‬ ‫اﻟﺨﻴﻂ‪3) s‬‬
‫)اﻟﻬﺪف‬ ‫‪= Semaphore‬‬ ‫‪(2) 4) def‬‬
‫"‪args = ("Yuvraj‬‬ ‫‪wish‬‬
‫)‪،)) 14‬‬ ‫‪t3 =(name):‬‬
‫ﺒﺔ ‪،‬‬
‫اﻟﺮﻏ‬
‫)‪16) t5()=20‬‬
‫‪t3.start‬‬ ‫‪ t4.‬ﺔ ‪،‬‬
‫ﺒ‬‫ﺒ ﺔ=‪،‬اﻟﺮﻏ‬
‫)اﻟﻬﺪف‬ ‫‪args‬اﻟﺨﻴﻂ‬
‫)اﻟﻬﺪف =اﻟﺮﻏ‬ ‫‪=args‬اﻟﺨﻴﻂ‬
‫"‪("Kohli‬‬ ‫‪،)) 15) t4‬‬
‫))‪= ( "Rohit"،‬‬
‫ﺑﺪأ )(‬
‫)( )‪args = ("Pandya" ،)) 17) t1.start () 18‬ا‬
‫‪t2.start‬‬ ‫)‪() 19‬‬
‫‪21) t5.start‬‬
‫ﺘﻨﻔﻴﺬ وﻇﻴﻔ ﺔ ‪wish ().‬‬

‫ﺑ‬‫ُﺴﻤﺢ ﻟﺨﻴﻮط ‪2‬‬
‫ﺛﻢﻳ‬‫ﺑﺎﻟﻮﺻﻮل إﱃ اﻟ ﺴﻴﻤﺎﻓﻮر وﻣﻦ‬‫ُﺴﻤﺢ ﻟـ ‪2‬ﺧﻴﻮط‬
‫ﺒﺮﻧﺎﻣﺞ أﻋﻼه ﻓ ﻲ وﻗ ﺖ واﺣﺪ ‪،‬ﻳ‬
‫ﻓ ﻲ اﻟ‬
‫‪139‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﻳﺤﺪ ﻫﺎﺳﻴﻤﺎﻓﻮر‪:‬‬
‫ﺘﺠﺎوز ﻋﺪد ﻣﻜﺎﻟﻤﺎ ت‬
‫ﺘﺪﻋﺎء ﻃﺮﻳﻘ ﺔ اﻹﻃﻼق )(أي ﻋﺪد ﻣﻦ اﻟﻤﺮا ت إﱃ ﻋﺪاد اﻟﺰﻳﺎدة‪.‬ﻳﻤﻜﻦ أنﻳ‬
‫ﺑﺎﺳ‬‫اﻹﺷﺎرة اﻟﻌﺎدﻳ ﺔ ﻫ ﻲ إﺷﺎرة ﻏﻴﺮ ﻣﺤﺪودةﺗ ﺴﻤﺢ ﻟﻨﺎ‬
‫ﺘﺤﻮاذ )(أ ً‬
‫ﻳﻀﺎ‪.‬‬ ‫اﻹﺻﺪار )(ﻋﺪد ﻣﻜﺎﻟﻤﺎ ت اﻻﺳ‬
‫*‬
‫ﺘﻴﺮاد اﻟﺨﻴﻮط ‪8) s.release () 9‬‬
‫)‪1‬ﻣﻦ اﺳ‬
‫)( ‪() 6) s.release () 7) s.release‬‬
‫‪() 4) s.acquire () 5) s.release‬‬
‫‪2) s = Semaphore (2) 3) s.acquire‬‬
‫ﺒﺎﻋ ﺔ )"‪("End‬‬
‫ﻃ‬
‫ﺘﺪﻋﺎء اﻹﺻﺪار )(أي ﻋﺪد ﻣﻦ اﻟﻤﺮا ت‪.‬‬

‫إﻧﻪ ﺻﺎﻟﺢﻷﻧﻪ ﻓ ﻲ اﻹﺷﺎرة اﻟﻌﺎدﻳ ﺔﻳﻤﻜﻨﻨﺎ اﺳ‬
‫ﺘﺤﻮاذ ‪() ،‬‬

‫ﺘﺠﺎوز ﻋﺪد ﻣﻜﺎﻟﻤﺎ ت اﻻﺳ‬
‫ﺜﻨﺎء أن ﻋﺪد ﻣﻜﺎﻟﻤﺎ ت اﻹﺻﺪار )(ﻳﺠ ﺐ أﻻﻳ‬
‫ﺜﻞ ‪Semaphore‬‬
‫ً‬ ‫ﻫﻮ ﻧﻔ ﺴﻪ‬ ‫‪BounedSemaphore‬‬
‫وإﻻﺳﻨﺤﺼﻞ‬
‫ﺗﻢ إﺻﺪار اﻹﺷﺎرة ﻋﺪة ﻣﺮا ت‬
‫‪ValueError:‬‬
‫*‬
‫ﺘﻴﺮاد اﻟﺨﻴﻮط ‪() 8) s.release () 9‬‬
‫)‪1‬ﻣﻦ اﺳ‬
‫‪5) s.release () 6) s.release () 7) s.release‬‬
‫)( ‪(2) 3) s.acquire () 4) s.acquire‬‬
‫ﺒﺎﻋ ﺔ )"‪("End‬‬
‫‪2) s = BoundedSemaphore‬ﻃ‬
‫ﺗﻢ إﺻﺪار اﻹﺷﺎرة ﻋﺪة ﻣﺮا ت‬

‫‪ValueError:‬‬
‫ﺘﺤﻮاذ )(ﻓ ﻲ ‪BoundedSemaphore.‬‬
‫ﺘﺠﺎوز ﻋﺪد ﻣﻜﺎﻟﻤﺎ ت اﻹﺻﺪار )(ﻋﺪد ﻣﻜﺎﻟﻤﺎ ت اﻻﺳ‬
‫إﻧﻪ ﻏﻴﺮ ﺻﺎﻟﺢ ‪b'z‬ﻳﺠ ﺐ أﻻﻳ‬
‫ﺘﺨﺪام ‪BoundedSemaphore‬ﻋﲆ ‪Semaphore‬اﻟﻌﺎدي‪.‬‬

‫ﺑﺎﺳ‬‫ﺒ ﺴﻴﻄ ﺔ ‪،‬ﻳﻮﺻﻰ‬
‫ﺒﺮﻣﺠ ﺔ اﻟ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬ﻟﻤﻨﻊ أﺧﻄﺎء اﻟ‬
‫ﺑﻴﻦ ﻟﻮك وﺳﻴﻤﺎﻓﻮر‪:‬‬‫اﻟﻔﺮق‬

‫ﺑﻂ واﺣﺪ ﻓﻘﻂ ‪ ،‬وﻟﻜﻦﻳﻤﻜﻦ اﻟﺤﺼﻮل ﻋﲆ ﻛﺎﺋﻦ ‪Semaphore‬‬
‫ﻓ ﻲ وﻗ ﺖ واﺣﺪ ‪،‬ﻳﻤﻜﻦ اﻟﺤﺼﻮل ﻋﲆ ﻛﺎﺋﻦ ‪Lock‬ﻣﻦ ﺧﻼل ﻣﺆﺷﺮﺗﺮا‬
‫ﺑﻮاﺳﻄ ﺔ ﻗﻴﻤ ﺔ اﻟﻌﺪاد‪.‬‬‫ﺑﻂ اﻟﻤﺤﺪدة‬
‫ﺘﺮا‬
‫ﺑ ﺖ ﻣﻦ ﻣﺆﺷﺮا ت اﻟ‬
‫ﺛﺎ‬‫ﺑﻮاﺳﻄ ﺔ ﻋﺪد‬
‫‪140‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺗﻤ ﺔ‪:‬‬
‫ﺧﺎ‬
‫ﺘﻈﺎر اﻟﺨﻴﻮط وﺧﻠﻖ‬
‫ﺋﻴ ﺴ ﻲ ﻟﻠﻤﺰاﻣﻨ ﺔ ﻫﻮ زﻳﺎدة وﻗ ﺖ اﻧ‬
‫ﺒﻴﺎﻧﺎ ت ‪ ،‬وﻟﻜﻦ اﻟﻌﻴ ﺐ اﻟﺮ‬
‫ﺘﻐﻠ ﺐ ﻋﲆ ﻣﺸﺎﻛﻞ ﻋﺪمﺗﻨﺎﺳﻖ اﻟ‬
‫ﺋﻴ ﺴﻴ ﺔ ﻟﻠﻤﺰاﻣﻨ ﺔ ﻫ ﻲ أﻧﻪﻳﻤﻜﻨﻨﺎ اﻟ‬
‫اﻟﻤﻴﺰة اﻟﺮ‬
‫ﺘﺰاﻣﻦ‪.‬‬
‫ﺘﺨﺪام اﻟ‬
‫ﺑﺎﺳ‬‫ﺛﻢ إذا ﻟﻢﻳﻜﻦ ﻫﻨﺎك ﺷﺮط ﻣﺤﺪد ﻓﻼﻳﻮﺻﻰ‬‫ﻣﺸﺎﻛﻞ ﻓ ﻲ اﻷداء‪ .‬وﻣﻦ‬
‫ﺑﻴﻦ اﻟﺨﻴﻂ‪:‬‬‫ﺘﻮاﺻﻞ‬
‫اﻟ‬
‫ﺑﺔ‬
‫ﺒﺮﻣﺠ ﺔ ‪،‬ﺗﻜﻮن اﻟﺨﻴﻮط ﻣﻄﻠﻮ‬
‫ﺘﻄﻠ‬
‫ﺑﻌﺾ اﻷﺣﻴﺎن ﻛﺠﺰء ﻣﻦ ﻣ‬‫ﻓﻲ‬
‫ﺑﻴﻦ اﻟﻤﻮاﺿﻴﻊ‪.‬‬‫ﺗﺼﺎل‬
‫ﺑﻌﺾ‪ .‬ﻫﺬا اﻟﻤﻔﻬﻮم ﻟﻴ ﺲﺳﻮى ا‬‫ﺗﻮاﺻﻠﻮا ﻣﻊ‬
‫ﺑﺎﻟﻌﻨﺼﺮ‬‫ﺘﻬﻠﻚ ﻹﺧﻄﺎره‬
‫ﺑﻂ اﻟﻤ ﺴ‬
‫ِﺞ ﻣﻊ ﻣﺆﺷﺮﺗﺮا‬
‫ﺘ‬
‫اﻟﻤﻨ‬
‫ﺑﻂ ُ‬‫ﺘﻮاﺻﻞ ﻣﺆﺷﺮﺗﺮا‬
‫ﺘﺎج اﻟﻌﻨﺎﺻﺮ ‪،‬ﻳﺠ ﺐ أنﻳ‬
‫ﺑﻌﺪ إﻧ‬‫ﺜﺎل‪:‬‬
‫ﻋﲆﺳ‬
‫ﺘﻬﻠﻚ ﻫﺬا اﻟﻌﻨﺼﺮ اﻟﺠﺪﻳﺪ‪.‬‬
‫ﺘﻬﻠﻚ أنﺗ ﺴ‬
‫ﺑﻴﺎﻧﺎ ت اﻟﻤ ﺴ‬‫ﺛﻢﻳﻤﻜﻦ ﻟ ﺴﻠ ﺴﻠ ﺔ‬‫اﻟﺠﺪﻳﺪ ‪،‬‬
‫ﺑﺎﺳ‬‫ﺑﻴﻦ اﻟﻤﻮاﺿﻴﻊ‬‫ﺗﺼﺎل‬
‫ﻓ ﻲ ‪Python ،‬ﻳﻤﻜﻨﻨﺎﺗﻨﻔﻴﺬ اﻻ‬
‫)‪1‬ﺣﺪ ث‬
‫)‪2‬اﻟﺸﺮط‬
‫ﺘﻈﺎر‬
‫)‪3‬ﻗﺎﺋﻤ ﺔ اﻻﻧ‬
‫إﻟﺦ‬
‫ﺘﺨﺪام ﻛﺎﺋﻨﺎ ت اﻷﺣﺪا ث‪:‬‬

‫ﺑﺎﺳ‬
‫‪Inter Thread Communication‬‬
‫ﺘﻈﺮه اﻟﺨﻴﻮط اﻷﺧﺮى‪.‬‬
‫ﺗﻨ‬‫ﺑﻴﻦ اﻟﺨﻴﻮط‪.‬ﻳﺸﻴﺮ أﺣﺪ اﻟﺨﻴﻮط إﱃ ﺣﺪ ث و‬‫ﺗﺼﺎل‬
‫ﺑ ﺴﻂ آﻟﻴ ﺔ ا‬
‫ﻛﺎﺋﻦ اﻟﺤﺪ ث ﻫﻮ أ‬
‫ﺘﺎﻟ ﻲ ‪...‬‬
‫ﻳﻤﻜﻨﻨﺎ إﻧﺸﺎء ﻛﺎﺋﻦ ﺣﺪ ث ﻋﲆ اﻟﻨﺤﻮ اﻟ‬
‫ﺑﻂ ‪() tnevE.‬‬

‫ﺘﺮا‬
‫اﻟﺤﺪ ث =ﻣﺆﺷﺮ اﻟ‬
‫ﻳﺪﻳﺮ اﻟﺤﺪ ث ﻋﻼﻣ ﺔ داﺧﻠﻴ ﺔﻳﻤﻜﻨﻬﺎﺗﻌﻴﻴﻦ )(أو ﻣ ﺴﺢ )(‬
‫ﺘﻢﺗﻌﻴﻴﻦ اﻟﺤﺪ ث‪.‬‬
‫ﺘﻰﻳ‬
‫ﺘﻈﺮ اﻟﻤﻮاﺿﻴﻊ ﺣ‬
‫ﻳﻤﻜﻦ أنﺗﻨ‬
‫ﻃﺮق ﻓﺌ ﺔ اﻟﺤﺪ ث‪:‬‬

‫ﺜﻞ إﺷﺎرة ﺧﻀﺮاء ﻟﻠﺠﻤﻴﻊ‬
‫ﺗﻤ‬‫ﺒﺢ ﻗﻴﻤ ﺔ اﻟﻌﻠﻢ اﻟﺪاﺧﻠ ﻲ ﺻﺤﻴﺤ ﺔ و‬
‫ﺘﺼ‬‫)( ‪1) set‬ﺳ‬
‫ﺘﻈﺎر‪.‬‬
‫ﺧﻴﻮط اﻻﻧ‬
‫ﺘﻈﺮة‪.‬‬
‫ﺜﻞ إﺷﺎرة ‪RED‬ﻟﺠﻤﻴﻊﺳﻼﺳﻞ اﻟﺮﺳﺎﺋﻞ اﻟﻤﻨ‬
‫ﺗﻤ‬‫ﺒﺢ ﻗﻴﻤ ﺔ اﻟﻌﻠﻢ اﻟﺪاﺧﻠ ﻲ ‪False‬و‬
‫ﺘﺼ‬‫)( ‪2) clear‬ﺳ‬
‫ﺘﺨﺪام ﻫﺬه اﻟﻄﺮﻳﻘ ﺔﺳﻮاءﺗﻢﺗﻌﻴﻴﻦ اﻟﺤﺪ ث أم ﻻ‬

‫)( ‪3) isSet‬ﻳﻤﻜﻦ اﺳ‬
‫ﺘﻢﺗﻌﻴﻴﻦ اﻟﺤﺪ ث‬
‫ﺘﻰﻳ‬
‫ﺘﻈﺮ اﻟﻤﻮﺿﻮع ﺣ‬
‫ﺛﻮان( ﻳﻤﻜﻦ أنﻳﻨ‬
‫ﺘﻈﺮ )‬
‫ﺘﻈﺮ | )(اﻧ‬
‫)‪4‬اﻧ‬
‫ﻛﻮد ﻣﺰﻳﻒ‪:‬‬
‫اﻟﺤﺪ ث )( ‪= threading.Event‬‬
‫ﺘﻢﺗﻌﻴﻴﻦ اﻟﺤﺪ ث‬
‫ﺘﻰﻳ‬
‫ﺘﻈﺮ ﺣ‬
‫‪#consumer thread‬ﻳﺠ ﺐ أنﺗﻨ‬
‫)( ‪event.wait‬‬
‫ﺘﺞﻳﻤﻜﻦﺗﻌﻴﻴﻦ أو ﻣ ﺴﺢ اﻟﺤﺪ ث‬
‫‪#‬اﻟﻤﻨ‬
‫)( ‪event.set‬‬
‫)( ‪event.clear‬‬
‫‪141‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺒ ﻲ ‪-1:‬‬
‫ﺘﺠﺮﻳ‬
‫اﻟ‬
‫*‬
‫ﺘﺎج‬
‫ﺒﺎﻋ ﺔ )"ﻋﻨﺎﺻﺮ إﻧ‬
‫ﺘﺞ )‪def (): time.sleep (5) 4‬ﻃ‬
‫ﺘﻴﺮاد )‪3‬اﻟﻤﻨ‬
‫)‪1‬ﻣﻦ اﺳ‬
‫ِﺞ ﻋﻦ ﻃﺮﻳﻖﺗﻌﻴﻴﻦ اﻟﺤﺪ ث"( ‪("Consumer thread‬‬
‫ﺘ‬
‫اﻟﻤﻨ‬
‫ﺑﻂ ُ‬‫ﺒﺎﻋ ﺔ )"إﺷﻌﺎر ﻣﺆﺷﺮﺗﺮا‬
‫ِﺞ‪5) (":‬ﻃ‬
‫ﺘ‬
‫اﻟﻤﻨ‬
‫ﺧﻴﻂ ُ‬
‫‪(): 9) print ("Consumer thread is waiting for update") 10) event.wait () 11) print‬‬
‫)‪16‬‬
‫‪t1 =t1.start‬‬
‫)‪=() 17‬اﻟﺤﺪ ث‬
‫اﻟﺤﺪ ث‬
‫)‪12) 13‬‬
‫ﺘﻬﻠﻚ( )(‬
‫ﺘﻬﻠﻜ ﺔ"(‬
‫ﺴﺴ‬‫اﻟﻤاﻟﻤ‬
‫واﻟﻌﻨﺎﺻﺮ =‬
‫اﻟﺨﻴﻂ )اﻟﻬﺪف‬
‫ﻟﻺﻋﻼم‬‫)‪15‬‬
‫)‪6) 7‬‬
‫‪t2 event.set‬‬
‫ﺘﺞ( =‬‫)اﻟﻬﺪف)( =اﻟﻤﻨ‬
‫اﻟﺨﻴﻂ ‪8) def‬‬
‫‪customer‬‬
‫)‪() 14‬‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫ﺘﺤﺪﻳ ﺚ‬
‫ﺘﻈﺮ اﻟ‬
‫ﺘﻬﻠﻚﻳﻨ‬
‫ﻣﻮﺿﻮع اﻟﻤ ﺴ‬
‫ﺘﺠ ﺔ‬
‫ﺒﻨﻮد اﻟﻤﻨ‬
‫ﺘﺞ اﻟﺨﻴﻂ اﻟ‬
‫اﻟﻤﻨ‬
‫ﺘﺞﻳﻌﻄ ﻲ إﺧﻄﺎرا ﻣﻦ ﺧﻼلﺗﺤﺪﻳﺪ اﻟﺤﺪ ث‬
‫ﻣﻮﺿﻮع اﻟﻤﻨ‬
‫ﺘﻬﻠﻜ ﺔ‬
‫ﺘﻬﻠﻚ إﺷﻌﺎ ًرا وﻋﻨﺎﺻﺮ ﻣ ﺴ‬
‫ﺗﻠﻘﻰ ﻣﻮﺿﻮع اﻟﻤ ﺴ‬
‫ﺒ ﻲ ‪-2:‬‬
‫ﺘﺠﺮﻳ‬
‫اﻟ‬
‫*‬
‫ﺘﻴﺮاد ‪True: 14) print ("Drivers waiting for‬‬
‫)‪1‬ﻣﻦ اﺳ‬
‫‪RED Signal") 10) event.clear () 11) def driver (): 12) num = 0 13) while‬‬
‫‪Signal") 7) event.set () 8) time.sleep (20) 9) print ("Traffic Police Giving‬‬
‫‪(): 4) while True: 5) time.sleep (10) 6) print ("Traffic Police Giving GREEN‬‬
‫‪") 15) event.wait‬إﺷﺎرة اﻟﻤﺮور‬ ‫)‪() 16‬‬
‫‪event.isSet‬‬ ‫‪print‬‬
‫"( )"‬
‫ﺑﻴﻨﻤﺎ ‪():‬‬ ‫ﺧﻀﺮاء)‪17‬‬
‫ﺘﺤﺮك‬‫إﺷﺎرة‬ ‫ﻟﻠﻤﺮﻛ)‪3‬‬
‫ﺒﺎ ت اﻟ‬ ‫ﻳﻤﻜﻦ ‪def‬‬
‫‪trafficpolice‬‬
‫ﺧﻀﺮاء ‪...‬‬
‫‪142‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫اﻟﺤﺪ ث = ‪t1‬‬
‫)‪(2) =21‬‬
‫‪ print‬ث‬
‫)‪22‬اﻟﺤﺪ‬
‫اﻹﺷﺎرة"(‬
‫ﺘﻈﺎر" (‬
‫ﺒﻮر‬
‫"ﻋاﻻﻧ‬
‫ﺋﻘﻴﻦ‬
‫‪num‬‬
‫ﻋﲆ ‪،‬اﻟ ﺴﺎ‬
‫ﺴﻴﺎرة‪، ":‬‬
‫ﺘﻌﻴﻦ‬ ‫‪...‬ﻳاﻟ‬
‫ﺣﻤﺮاءرﻗﻢ‬
‫‪18) num‬‬
‫)"إﺷﺎرة=اﻟﻤﺮور‬
‫‪num +‬‬ ‫)‪20‬‬
‫)‪1 19‬‬
‫‪time.sleep‬‬
‫"( ‪print‬‬
‫)‪() 25‬اﻟﺨﻴﻂ )اﻟﻬﺪف =ﺷﺮﻃ ﺔ اﻟﻤﺮور( = ‪24) t2‬اﻟﺨﻴﻂ )اﻟﻬﺪف =اﻟ ﺴﺎﺋﻖ( )( ‪t1.start () 26) t2.start‬‬
‫)‪23‬‬
‫ﺑﻤﺠﺮد أن‬
‫ﺘﻰﻳﻌﻄ ﻲ إﺷﺎرة ﺧﻀﺮاء ‪ ،‬و‬
‫ﺘﻌﻴﻴﻦ ‪event.ie‬ﺣ‬
‫ﺑ‬‫ﺑﻂ ﺷﺮﻃ ﺔ اﻟﻤﺮور‬
‫ﺘﻰﻳﻘﻮم ﻣﺆﺷﺮﺗﺮا‬
‫ﺘﻈﺮ ﺣ‬
‫ﺒﺮﻧﺎﻣﺞ أﻋﻼه ‪،‬ﻳﺠ ﺐ أنﻳﻨ‬
‫ﺑﺮﻧﺎﻣﺞﺗﺸﻐﻴﻞ اﻟ‬‫ﻓ ﻲ ﺧﻴﻂ‬
‫ﺑﻤﺠﺮد ﻣ ﺴﺢ ﺧﻴﻂ ﺷﺮﻃ ﺔ اﻟﻤﺮور ﻟﻠﺤﺪ ث )ﻳﻌﻄ ﻲ إﺷﺎرة‬‫ﺒﻮر اﻹﺷﺎرة‪.‬‬
‫ﺒﺎ ت ﻋ‬
‫ﺑﻂ ﺷﺮﻃ ﺔ اﻟﻤﺮور اﻟﺤﺪ ث )ﻳﻌﻄ ﻲ إﺷﺎرة ﺧﻀﺮاء( ‪،‬ﻳﻤﻜﻦ ﻟﻠﻤﺮﻛ‬
‫ﻳﺤﺪد ﻣﺆﺷﺮﺗﺮا‬
‫ﺑﻂ اﻟ ﺴﺎﺋﻖ‪.‬‬
‫ﺘﻈﺮ ﻣﺆﺷﺮﺗﺮا‬
‫ﺣﻤﺮاء( ‪،‬ﻳﺠ ﺐ أنﻳﻨ‬
‫ﺘﺨﺪام ﻛﺎﺋﻦ اﻟﺸﺮط‪:‬‬

‫ﺑﺎﺳ‬
‫‪Inter Thread Communication‬‬
‫ﺘﺪاﺧﻠ ﺔ‬
‫ﺗﻘﺪﻣﺎ ﻣﻦ ﻛﺎﺋﻦ اﻟﺤﺪ ث ﻟﻠﺨﻴﻮط اﻟﻤ‬
‫ً‬ ‫ﺜﺮ‬
‫اﻟﺸﺮط ﻫﻮ اﻹﺻﺪار اﻷﻛ‬
‫ﺘﻈﺮ اﻟﺨﻴﻮط ﻫﺬا اﻟﺸﺮط وﻳﻤﻜﻦ إﺧﻄﺎر‬

‫ﺘﻬﻠﻚ‪.‬ﻳﻤﻜﻦ أنﺗﻨ‬
‫ﺘﺎج ﻋﻨﺼﺮ أو ﻋﻨﺼﺮ ﻣ ﺴ‬
‫ﺜﻞ إﻧ‬
‫ﺒﻴﻖ ﻣ‬
‫ﺘﻄ‬‫ﺜﻞ اﻟﺸﺮط ﻧﻮﻋً ﺎ ﻣﻦﺗﻐﻴﻴﺮ اﻟﺤﺎﻟ ﺔ ﻓ ﻲ اﻟ‬
‫ﺗﺼﺎل‪:‬ﻳﻤ‬
‫اﻻ‬
‫ﺑﻂ آﺧﺮ‪.‬‬
‫ﺑﻮاﺳﻄ ﺔ ﻣﺆﺷﺮﺗﺮا‬‫ﺘﻢ إﺧﻄﺎره‬
‫ﺘﻰﻳ‬
‫ﺑﺎﻻﻧ‬‫ﺑﻂ‬
‫ﺘﺮا‬
‫ﺜﺮ ﻣﻦ ﻣﺆﺷﺮا ت اﻟ‬
‫ﺑﻤﺠﺮد ﺣﺪو ث اﻟﺸﺮط‪.‬ﻳ ﺴﻤﺢ ﻛﺎﺋﻦ اﻟﺸﺮط ﻟﻮاﺣﺪ أو أﻛ‬‫ﺳﻼﺳﻞ اﻟﺮﺳﺎﺋﻞ‬
‫ﺑﻘﻔﻞ ‪(ReentrantLock).‬‬‫ﺋﻤﺎ‬
‫ﺒﻂ اﻟﺸﺮط دا ً‬
‫ﺗ‬‫ﻳﺮ‬
‫ﺑﻠ ﺔ‬
‫ﺘﺪﻋ ﻲ اﻟﻄﺮق اﻟﻤﻘﺎ‬
‫ﺗﺴ‬‫ﺘﻴﻦ )(و )( ‪release‬‬
‫ﺘ ﺴ ﺐ اﻟﺸﺮط ﻃﺮﻳﻘ‬
‫ﻳﻜ‬
‫ﺒﻂ‪.‬‬
‫ﺗ‬‫ﻣﻦ اﻟﻘﻔﻞ اﻟﻤﺮ‬
‫ﺘﺎﻟ ﻲ اﻟﺸﺮط )( ‪= threading.Condition‬‬

‫ﻳﻤﻜﻨﻨﺎ إﻧﺸﺎء ﻛﺎﺋﻦ اﻟﺸﺮط ﻋﲆ اﻟﻨﺤﻮ اﻟ‬
‫ﻃﺮق اﻟﺸﺮط‪:‬‬
‫ﺘﻬﻼﻛﻬﺎ‬
‫ﺘﺎج اﻟﻌﻨﺎﺻﺮ أو اﺳ‬
‫ﺒﻞ إﻧ‬
‫)(ﻟﻠﺤﺼﻮل ﻋﲆ ﻛﺎﺋﻦ اﻟﺸﺮط ﻗ‬ ‫)‪1‬اﻟﺤﺼﻮل ﻋﲆ‬
‫ﻣﻮﺿﻮع اﻟﺤﺼﻮل ﻋﲆ ﻗﻔﻞ داﺧﻠ ﻲ‪.‬‬
‫ﺘﻬﻼك اﻟﻌﻨﺎﺻﺮ‪ .‬أي ﻣﻮﺿﻮع‬

‫ﺘﺎج أو اﺳ‬
‫ﺑﻌﺪ إﻧ‬‫ﺘﺤﺮﻳﺮ ﻛﺎﺋﻦ اﻟﺸﺮط‬
‫)‪2‬إﻃﻼق )(ﻟ‬
‫ﻳﻄﻠﻖ اﻟﻘﻔﻞ اﻟﺪاﺧﻠ ﻲ‬
‫ﺘﻬﺎء اﻟﻮﻗ ﺖ‬
‫ﺘﻼم اﻹﺧﻄﺎر أو اﻧ‬
‫ﺘﻰ اﺳ‬
‫ﻟﻼﻧ‬ ‫ﺘﻈﺮ )وﻗ ﺖ(‬
‫ﺘﻈﺮ | )(اﻧ‬
‫)‪3‬اﻧ‬
‫ﺘﻈﺎر واﺣﺪ‬
‫ﺑﻠﻎ )(ﻹﻋﻄﺎء إﺷﻌﺎر ﻟﺨﻴﻂ اﻧ‬
‫)‪4‬أ‬
‫ﺘﻈﺮة‬
‫)( ‪5) notifyAll‬ﻹﻋﻄﺎء إﺷﻌﺎر ﻟﺠﻤﻴﻊ اﻟﻤﻮاﺿﻴﻊ اﻟﻤﻨ‬
‫‪143‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫دراﺳ ﺔ اﻟﺤﺎﻟ ﺔ‪:‬‬

‫ﺘﻬﻠﻜﻴﻦ‪.‬‬
‫ﺘﺎج اﻟﻌﻨﺼﺮ ﻟﻠﻤﻮرد وإﺧﻄﺎر اﻟﻤ ﺴ‬
‫ﺒﻞ إﻧ‬
‫ﺘﺎج إﱃ اﻟﺤﺼﻮل ﻋﲆ اﻟﺤﺎﻟ ﺔ ﻗ‬
‫ﺘﺎج ﺧﻴﻂ اﻹﻧ‬
‫ﻳﺤ‬
‫ﺘﺞ اﻟﻤﻮﺿﻮع‬
‫‪#‬اﻟﻤﻨ‬
‫‪...‬إﻧﺸﺎء ﻋﻨﺼﺮ ‪..‬‬

‫)( ‪condition.acquire‬‬
‫‪...‬إﺿﺎﻓ ﺔ ﻋﻨﺼﺮ إﱃ اﻟﻤﻮرد ‪...‬‬
‫‪condition.notify () #‬إﺷﺎرة إﱃﺗﻮﻓﺮ ﻋﻨﺼﺮ ﺟﺪﻳﺪ ))( ‪(notifyAll‬‬

‫)( ‪condition.release‬‬
‫ﺘﻬﻼك اﻟﻌﻨﺎﺻﺮ ﻣﻦ‬

‫ﺛﻢﻳﻤﻜﻨﻪ اﺳ‬‫ﺘﻬﻠﻚ ﻋﲆ اﻟﺸﺮط وﻣﻦ‬
‫ﻳﺠ ﺐ أنﻳﺤﺼﻞ اﻟﻤ ﺴ‬
‫اﻟﻤﻮارد‬
‫ﺘﻬﻠﻚ‬
‫‪#‬ﻣﻮﺿﻮع اﻟﻤ ﺴ‬
‫)( ‪condition.acquire‬‬
‫ﺘﻈﺎر )(‬
‫ﺣﺎﻟ ﺔ اﻻﻧ‬
‫ﺒﻨﺪ‬
‫ﺘﻬﻠﻚ اﻟ‬
‫ﺗﺴ‬
‫)( ‪condition.release‬‬
‫ﺒ ﻲ ‪-1:‬‬
‫ﺘﺠﺮﻳ‬
‫اﻟ‬
‫*‬
‫ﺘﻈﺎر‬
‫ﺘﻬﻠﻚ ﻓ ﻲ اﻧ‬
‫ﺒﺎﻋ ﺔ )"اﻟﻤ ﺴ‬
‫ﺘﻬﻼك )‪(c): 3) c.acquire () 4‬اﻟﻄ‬
‫ﺘﻴﺮاد اﻟﺨﻴﻮط ‪2) def‬اﻻﺳ‬
‫)‪1‬ﻣﻦ اﺳ‬
‫ﺘﻬﻠﻚ اﻟﻌﻨﺼﺮ )‪") 7‬ج‪ .‬اﻹﺻﺪار = ‪17) t1‬‬
‫ﺘﻬﻠﻚ إﺷﻌﺎ ًرا واﺳ‬
‫ﺗﻠﻘﻰ اﻟﻤ ﺴ‬
‫ﺘﻈﺮ )‪() 6‬اﻟﻄ‬
‫ﺘﺤﺪﻳ ﺚ"( ‪5) c.‬اﻧ‬
‫اﻟ‬
‫‪print‬‬
‫‪("()Producer‬اﻟﺨﻴﻂ‬ ‫‪Im Notification‬‬
‫‪8) 9) def product‬‬ ‫‪") 13) c. notify‬‬
‫‪(c): 10) c.acquire‬‬ ‫‪() 11)()print‬‬
‫‪14) c.release‬‬ ‫)‪() 15‬‬
‫‪(" Producer‬‬ ‫‪16) c = Condition‬‬
‫‪Producer‬‬ ‫)(‬
‫)‪Items ") 12‬‬
‫ﺘﺎج ‪19) t1.start () 20) t2.start () ،‬‬
‫ﺘﻬﻼك ‪args = (c ،)) 18) t2 = ،‬اﻟﺨﻴﻂ )اﻟﻬﺪف =اﻹﻧ‬
‫)اﻟﻬﺪف =اﻻﺳ‬
‫))‪args = (c ،‬‬
‫‪144‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫اﻟﻤ ﺴ‬
‫ﺘﺠﻴﻦ‬
‫ﺘﺠ ﺔ ﻟﻠﻤﻨ‬
‫ﺘﺠﺎ ت اﻟﻤﻨ‬
‫اﻟﻤﻨ‬
‫ﺘﺞﻳﻌﻄ ﻲ اﻹﺧﻄﺎر‬
‫اﻟﻤﻨ‬
‫ﺘﻬﻠﻚ اﻟﻌﻨﺼﺮ‬
‫ﺘﻬﻠﻚ إﺷﻌﺎ ًرا واﺳ‬
‫ﺗﻠﻘﻰ اﻟﻤ ﺴ‬
‫ﺒ ﻲ ‪-2:‬‬
‫ﺘﺠﺮﻳ‬
‫اﻟ‬
‫*‬
‫ﺘﻴﺮاد ﻋﺸﻮاﺋ ﻲ )‪4‬اﻟﻌﻨﺎﺻﺮ ) ‪9‬‬
‫ﺘﻴﺮاد )‪3‬اﺳ‬
‫)‪1‬ﻣﻦ اﺳ‬
‫)‪(c): 6) while True: 7) c.acquire () 8) item = random.randint (1،100‬‬
‫ﺘﺞ ‪ ، ":‬اﻟﻌﻨﺼﺮ( ‪11) print ("Producer‬‬
‫ﺘﺞ اﻟﻤﻨ‬
‫ﺒﺎﻋ ﺔ )"اﻟﻤﻨ‬
‫‪= [] 5) def product‬ﻃ‬
‫ﺒﻠﻎ اﻹﺧﻄﺎر"( ‪time.sleep ( 5) 15) 16) def‬‬
‫)‪10) items.append (item‬اﻟﺬيﻳ‬
‫ﺑﻴﻨﻤﺎ ﺻﺤﻴﺢ‪:‬‬
‫ﺘﻬﻼك )‪(c): 17‬‬
‫)‪12) c.notify () 13) c.release () 14‬اﻻﺳ‬
‫‪("Consumer waiting for update") 20) c.wait () 21) print ("Consumer‬‬
‫‪(target‬‬ ‫‪= consume،‬‬
‫‪c.release‬‬ ‫))‪args = (c،‬‬
‫‪() 23) time.sleep‬‬ ‫)‪(5)27‬‬
‫)‪24)t225‬‬
‫ﺘﻬﻠﻚ‪= c‬‬‫‪18) c.acquire‬اﺳ‬
‫‪= Condition‬‬ ‫)‪() 26) t1() =19‬‬ ‫‪print‬‬
‫‪Thread‬‬
‫ﺘﺎج ‪t1.start () 29) t2.start () ،‬‬
‫‪item "، items.pop‬اﻟﺨﻴﻂ )اﻟﻬﺪف =اﻹﻧ‬
‫))‪args = (c،‬‬
‫)‪()) 28‬‬
‫)‪22‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫اﻟﻤ ﺴ‬
‫ﺘﺞ‪49 :‬‬
‫اﻟﻤﻨ‬
‫ﺘﺞﻳﻌﻄ ﻲ اﻹﺧﻄﺎر‬ ‫اﻟﻤﻨ‬
‫ﺒﻨﺪ ‪49‬‬
‫ﺘﻬﻠﻚ اﻟ‬‫ﺘﻬﻠﻚ اﻟﻤ ﺴ‬‫اﺳ‬
‫‪.....‬‬
‫‪145‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﻈﺎر )(ﻋﲆ ﻛﺎﺋﻦ اﻟﺸﺮط‪.‬‬

‫ﺘﺪﻋﺎء ﻃﺮﻳﻘ ﺔ اﻻﻧ‬
‫ﺘﺎﻟ ﻲ ﻓﻬﻮ ﻣ ﺴﺆول ﻋﻦ اﺳ‬
‫ﺑﺎﻟ‬
‫ﺘﺤﺪﻳ ﺚ ‪ ،‬و‬
‫ﺘﻬﻠﻚ اﻟ‬
‫ﺘﻮﻗﻊ ﻣﺆﺷﺮﺗﺮا‬
‫ﺒﺮﻧﺎﻣﺞ أﻋﻼه ‪،‬ﻳ‬
‫ﻓ ﻲ اﻟ‬
‫ﺘﺪﻋﺎء )( ‪notify‬أو )( ‪notifyAll‬ﻋﲆ ﻛﺎﺋﻦ اﻟﺸﺮط‪.‬‬

‫ﺘﺎﻟ ﻲ ﻓﻬﻮ ﻣ ﺴﺆول ﻋﻦ اﺳ‬
‫ﺑﺎﻟ‬
‫ﺘﺤﺪﻳ ﺚ ‪ ،‬و‬
‫ﺑﺈﺟﺮاء اﻟ‬‫ِﺞ‬
‫ﺘ‬
‫اﻟﻤﻨ‬
‫ﺑﻂ ُ‬‫ﻳﻘﻮم ﻣﺆﺷﺮﺗﺮا‬
‫ﺘﻈﺎر‪:‬‬
‫ﺘﺨﺪام ﻗﺎﺋﻤ ﺔ اﻻﻧ‬
‫ﺑﺎﺳ‬
‫‪Inter Tread Communication‬‬
‫ﺑﻴﻦ اﻟﻤﻮاﺿﻴﻊ و‬‫ﺗﺼﺎل‬
‫ﺴﻨ ﺔ ﻟﻼ‬
‫ﺜﺮ آﻟﻴ ﺔ ﻣﺤّ‬
‫ﺘﻈﺎر ﻫﻮ أﻛ‬
‫ﻣﻔﻬﻮم ﻗﻮاﺋﻢ اﻻﻧ‬
‫ﺑﻴﻦ اﻟﻤﻮاﺿﻴﻊ‪.‬‬‫ﺒﻴﺎﻧﺎ ت‬
‫ﺒﺎدل اﻟ‬
‫ﺘ‬‫ﻟ‬
‫ﺛﻢ ﻛﻠﻤﺎ ﻛﻨﺎ ﻛﺬﻟﻚ‬‫ﺑﻪ ﻗﻔﻞ ‪ ،‬وﻣﻦ‬‫ﺘﻈﺎر داﺧﻠ ًﻴﺎ ﻋﲆ ﺷﺮط و ﻫﺬا اﻟﺸﺮط‬
‫ﺘﻮي ﻗﺎﺋﻤ ﺔ اﻻﻧ‬
‫ﺗﺤ‬
‫ﺑﺸﺄن اﻟﻤﺰاﻣﻨ ﺔ‪.‬‬‫ﺘﻈﺎر ‪ ،‬ﻻ داﻋ ﻲ ﻟﻠﻘﻠﻖ‬
‫ﺘﺨﺪام ﻗﺎﺋﻤ ﺔ اﻻﻧ‬
‫ﺑﺎﺳ‬
‫ﺘﻈﺎر‬
‫ﺘﻴﺮاد وﺣﺪة ﻗﺎﺋﻤ ﺔ اﻻﻧ‬
‫ﺘﻈﺎر اﺳ‬ ‫ﺘﻈﺎر أوﻻ ً ‪ ،‬ﻓﻴﺠ ﺐ ﻋﻠﻴﻨﺎ اﺳ‬
‫ﺘﻴﺮاد ﻗﺎﺋﻤ ﺔ اﻧ‬ ‫ﺘﺨﺪام ﻗﻮاﺋﻢ اﻻﻧ‬
‫إذا أردﻧﺎ اﺳ‬
‫ﺘﻈﺎر ﻛﻤﺎﻳﻠ ﻲ‪q = queue.Queue () :‬‬
‫ﻳﻤﻜﻨﻨﺎ إﻧﺸﺎء ﻛﺎﺋﻦ ﻗﺎﺋﻤ ﺔ اﻻﻧ‬
‫ﻃﺮق ﻣﻬﻤ ﺔ ﻓ ﻲ ﻗﺎﺋﻤ ﺔ اﻻﻧ‬
‫)‪ 1‬ﺿﻊ ‪ ():‬ﺿﻊ ﻋﻨﺼ ﺮًا ﻓ ﻲ ﻗﺎﺋﻤ ﺔ اﻻﻧ‬
‫ﺗﻪ‪.‬‬
‫ﺘﻈﺎر وإﻋﺎد‬
‫‪2) get ():‬إزاﻟ ﺔ ﻋﻨﺼﺮ ﻣﻦ ﻗﺎﺋﻤ ﺔ اﻻﻧ‬
‫ﺒﻞ إدﺧﺎل‬
‫ﺘﻮي ﻫﺬه اﻟﻄﺮﻳﻘ ﺔ ﻋﲆ ﻣﻨﻄﻖ ﻟﻠﺤﺼﻮل ﻋﲆ اﻟﻘﻔﻞ ﻗ‬
‫ﺘﻈﺎر‪ .‬داﺧﻠ ًﻴﺎ ‪،‬ﺗﺤ‬
‫ﺒﻴﺎﻧﺎ ت ﻓ ﻲ ﻗﺎﺋﻤ ﺔ اﻻﻧ‬
‫ﺘﺨﺪم ‪Producer Thread‬ﻃﺮﻳﻘ ﺔ )( ‪put‬ﻹدراج اﻟ‬
‫ﻳﺴ‬
‫ﺘﻢﺗﺤﺮﻳﺮهﺗﻠﻘﺎﺋ ًﻴﺎ‪.‬‬
‫ﺒﻴﺎﻧﺎ تﺳﻴ‬
‫ﺑﻌﺪ إدﺧﺎل ﻗﻔﻞ اﻟ‬‫ﺘﻈﺎر‪.‬‬
‫ﺒﻴﺎﻧﺎ ت ﻓ ﻲ ﻗﺎﺋﻤ ﺔ اﻻﻧ‬
‫اﻟ‬
‫ِﺞ ﻓ ﻲ‬
‫ﺘ‬
‫اﻟﻤﻨ‬
‫ﺑﻂ ُ‬‫ﺘﻢ إدﺧﺎل ﻣﺆﺷﺮﺗﺮا‬
‫ﺘﻠﺌ ﺔ ‪ ،‬ﻓ ﺴﻴ‬
‫ﺘﻈﺎر ﻣﻤ‬
‫ﺘﻠﺌ ﺔ أم ﻻ ‪ ،‬وإذا ﻛﺎﻧ ﺖ ﻗﺎﺋﻤ ﺔ اﻻﻧ‬
‫ﺘﻈﺎر ﻣﻤ‬ ‫ﺘﺤﻘﻖ أﺳﻠﻮ ب )( ‪put‬أ ً‬
‫ﻳﻀﺎ ﻣﻤﺎ إذا ﻛﺎﻧ ﺖ ﻗﺎﺋﻤ ﺔ اﻻﻧ‬ ‫ﻳ‬
‫ﺘﺪﻋﺎء ﻃﺮﻳﻘ ﺔ )( ‪wait‬داﺧﻠ ًﻴﺎ‪.‬‬
‫ﺘﻈﺎر ﻋﻦ ﻃﺮﻳﻖ اﺳ‬
‫ﺣﺎﻟ ﺔ اﻻﻧ‬
‫ﺘﻮي ﻫﺬه اﻟﻄﺮﻳﻘ ﺔ ﻋﲆ ﻣﻨﻄﻖ ﻟﻠﺤﺼﻮل ﻋﲆ‬

‫ﺘﻈﺎر واﻟﺤﺼﻮل ﻋﻠﻴﻬﺎ‪ .‬داﺧﻠ ًﻴﺎ ‪،‬ﺗﺤ‬
‫ﺒﻴﺎﻧﺎ ت ﻣﻦ ﻗﺎﺋﻤ ﺔ اﻻﻧ‬
‫ﺘﺨﺪم ‪Consumer Thread‬ﻃﺮﻳﻘ ﺔ )( ‪get‬ﻹزاﻟ ﺔ اﻟ‬
‫ﻳﺴ‬
‫ﺘﻢﺗﺤﺮﻳﺮ اﻟﻘﻔﻞﺗﻠﻘﺎﺋ ًﻴﺎ‪.‬‬
‫ﺘﻤﺎل اﻹزاﻟ ﺔ ‪،‬ﺳﻴ‬
‫ﺑﻤﺠﺮد اﻛ‬‫ﺘﻈﺎر‪.‬‬
‫ﺒﻴﺎﻧﺎ ت ﻣﻦ ﻗﺎﺋﻤ ﺔ اﻻﻧ‬
‫ﺒﻞ إزاﻟ ﺔ اﻟ‬
‫اﻟﻘﻔﻞ ﻗ‬
‫ﺑﻤﺠﺮدﺗﺤﺪﻳ ﺚ ﻗﺎﺋﻤ ﺔ‬‫ﺘﻈﺎر )(داﺧﻠ ًﻴﺎ‪.‬‬

‫ﺘﺪﻋﺎء ﻃﺮﻳﻘ ﺔ اﻻﻧ‬
‫ﺘﻈﺎر ﻋﻦ ﻃﺮﻳﻖ اﺳ‬
‫ﺘﻬﻠﻚ ﻓ ﻲ ﺣﺎﻟ ﺔ اﻻﻧ‬
‫ﺘﻢ إدﺧﺎل ﻣﺆﺷﺮﺗﺮا‬
‫ﺘﻈﺎر ﻓﺎرﻏ ﺔ ‪ ،‬ﻓ ﺴﻴ‬
‫إذا ﻛﺎﻧ ﺖ ﻗﺎﺋﻤ ﺔ اﻻﻧ‬
‫ﺘﻢ إﺧﻄﺎرﺳﻠ ﺴﻠ ﺔ اﻟﺮﺳﺎﺋﻞﺗﻠﻘﺎﺋ ًﻴﺎ‪.‬‬
‫ﺒﻴﺎﻧﺎ ت ‪،‬ﺳﻴ‬
‫ﺑﺎﻟ‬‫ﺘﻈﺎر‬
‫اﻻﻧ‬
‫ﺒ ﺔ ﻟﻨﺎ و ﻫ ﻲ ﻣﻴﺰة ﻋﻈﻴﻤ ﺔ‪.‬‬

‫ﺑﺎﻟﻨ ﺴ‬‫ﺑﺎﻟﻘﻔﻞ‬‫ﺘﻢ‬
‫ﺑﻮرﺗﻬ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬وﺣﺪة اﻟﻄﺎ‬
‫*‬
‫ﺘﻴﺮاد ﻋﺸﻮاﺋ ﻲ )‪4‬ﻗﺎﺋﻤ ﺔ‬
‫ﺘﻴﺮاد )‪3‬اﺳ‬
‫ﺘﻴﺮاد ﺧﻴﻮط اﻟﻤﻌﺎﻟﺠ ﺔ )‪2‬وﻗ ﺖ اﻻﺳ‬
‫)‪1‬ﻣﻦ اﺳ‬
‫ﺑﻴﻨﻤﺎ ‪(1،100) 8) print‬‬
‫ﺘﻴﺮاد )‪5) def product (q): 6‬‬
‫ﺘﻈﺎر اﻻﺳ‬
‫اﻧ‬
‫ﺒﻨﺪ( ‪9) q.put‬‬
‫ﺘﺞ ‪ ، ":‬اﻟ‬
‫‪")True: 7) item = random.randint‬اﻟﻤﻨ‬
‫)ﻋﻨﺼﺮ(‬
‫‪146‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺑﻴﻨﻤﺎ‬
‫‪(q):‬‬ ‫أﻗﻞاﺳ)‪13‬‬
‫ﺘﻬﻠﻚ‬ ‫ﺘﻬﻼك‬
‫ﺘﻬﻠﻚ‬ ‫)‪11‬اﺳ‬
‫)"اﻟﻤ ﺴ‬ ‫‪time.sleep‬‬
‫ﺒﺎﻋ ﺔ‬ ‫)‪(5) 12‬‬
‫ﺘﺤﺪﻳ ﺚ"( )‪15‬ﻃ‬ ‫ﺘﺞ"(‬
‫ﺘﻈﺮ اﻟ‬ ‫ﺴ اﻟﻤﻨ‬
‫ﺘﻬﻠﻚﻳﻨ‬ ‫ﺑﺈﻋﻄﺎء‬
‫)"إﺧﻄﺎر )"اﻟﻤ‬
‫ﺒﺎﻋ ﺔ‬
‫)‪14‬ﻃ‬‫ﺒﺎﻋ ﺔ‬‫)‪10‬ﻃ‬
‫ﺻﺤﻴﺢ‪:‬‬
‫ﺘﺎج ‪،‬‬ ‫اﻟﺨﻴﻂ )‪() 19‬‬
‫)اﻟﻬﺪف =اﻹﻧ‬ ‫‪t1 = Thread‬‬
‫‪"، q.get (target‬‬ ‫‪= consume،‬‬
‫‪()) 16) time.sleep‬‬ ‫‪(5)args‬‬ ‫))‪= (q،‬‬
‫)‪17) 18‬‬ ‫)‪q =20‬‬ ‫اﻟﻌﻨﺼﺮ‪t2 = :‬‬
‫‪queue.Queue‬‬
‫)( ‪args = (q ،)) 21) t1.start () 22) t2.start‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫اﻟﻤ ﺴ‬
‫ﺘﺞ‪58 :‬‬
‫اﻟﻤﻨ‬
‫ﺘﺞﻳﻌﻄ ﻲ اﻹﺧﻄﺎر‬
‫اﻟﻤﻨ‬
‫ﺘﻬﻠﻚ ﻓ ﻲ اﻟﺼﻨﻒ‪58 :‬‬
‫ﺘﻬﻠﻚ اﻟﻤ ﺴ‬
‫اﻟﻤ ﺴ‬
‫أﻧﻮاع ﻗﻮاﺋﻢ اﻻﻧ‬
‫ﻳﺪﻋﻢ ‪Python 3‬أﻧﻮاع ﻣﻦ ﻗﻮاﺋﻢ اﻻﻧ‬
‫ﺘﻈﺎر ‪FIFO:‬‬
‫)‪1‬ﻗﺎﺋﻤ ﺔ اﻧ‬
‫= ‪q‬ﻗﺎﺋﻤ ﺔ اﻻﻧ‬
‫ﺘﺨﺮج اﻟﻌﻨﺎﺻﺮ ‪(FIFO-First In First Out).‬‬
‫ﺗﻴ ﺐﺳ‬
‫ﺘﺮ‬‫ﺑﻨﻔ ﺲ اﻟ‬
‫ﺘﻈﺎر ‪ ،‬و‬
‫ﺗﻴ ﺐ ﻧﻀﻊ اﻟﻌﻨﺎﺻﺮ ﻓ ﻲ ﻗﺎﺋﻤ ﺔ اﻻﻧ‬
‫ﺘﺮاﺿ ﻲ‪ .‬ﻓ ﻲ أيﺗﺮ‬
‫ﻫﺬا ﻫﻮ اﻟ ﺴﻠﻮك اﻻﻓ‬
‫ﺘﻈﺎر )‪(15) 7‬‬

‫ﺘﻴﺮاد ﻗﺎﺋﻤ ﺔ اﻻﻧ‬
‫)‪1‬اﺳ‬
‫‪(5) 5) q.put (20) 6) q.put‬‬
‫‪() 3) q.put (10) 4) q.put‬‬
‫‪2) q = queue.Queue‬‬
‫ﻟﻴ ﺲ ‪(): 8) print (q.get () ،‬‬
‫‪q .empty‬اﻟﻨﻬﺎﻳ ﺔ ) " =‬
‫اﻟﺨﺮج‪10 5 20 15 :‬‬
‫‪147‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﻈﺎر ‪LIFO:‬‬
‫ﺗﻴ ﺐ ﻋﻜ ﺴ ﻲ ﻟﻺدراج )آﺧﺮ ﻣﺎﻳﺮد أوﻻ ًﻳﺨﺮج(‬
‫ﺘﺮ‬‫ﺑ‬‫ﺘﻢ اﻹزاﻟ ﺔ‬
‫ﺘ‬‫ﺳ‬
‫ﺘﻈﺎر )‪(15) 7‬‬

‫)‪1‬اﺳ‬
‫‪(5) 5) q.put (20) 6) q.put‬‬
‫‪() 3) q.put (10) 4) q.put‬‬
‫‪2) q = queue.LifoQueue‬‬
‫ﻟﻴ ﺲ ‪(): 8) print (q.get () ،‬‬
‫اﻟﺨﺮج‪15 20 5 10 :‬‬
‫ﺘﻈﺎر اﻷوﻟﻮﻳ ﺔ‪:‬‬

‫ﺗﻴ ﺐ اﻷوﻟﻮﻳ ﺔ‪.‬‬
‫ﺑﻌﺾﺗﺮ‬‫ﺑﻨﺎ ًء ﻋﲆ‬‫ﺘﻢ إدراج اﻟﻌﻨﺎﺻﺮ‬
‫ﺳﻴ‬
‫ﺘﻈﺎر )‪(15) 7‬‬

‫)‪1‬اﺳ‬
‫‪q.put (5) 5) q.put (20) 6) q.put‬‬
‫)‪() 3) q.put (10) 4‬‬
‫‪2) q = queue.PriorityQueue‬‬
‫ﺑﻴﻨﻤﺎ ﻟﻴ ﺲ ‪(): 8) print (q.get () ،‬‬
‫اﻟﺨﺮج‪5 10 15 20 :‬‬
‫ﺗﻨﺎ ﻓ ﻲ ﺷﻜﻞ ‪tuple.‬‬

‫ﺑﻴﺎﻧﺎ‬‫ﺒﻴﺎﻧﺎ ت ﻏﻴﺮ رﻗﻤﻴ ﺔ ‪ ،‬ﻓﻌﻠﻴﻨﺎﺗﻘﺪﻳﻢ‬
‫ﺜﺎل ‪2:‬إذا ﻛﺎﻧ ﺖ اﻟ‬
‫ﻣ‬
‫)س ‪ ،‬ص( س ﻫ ﻲ اﻷوﻟﻮﻳ ﺔ‬
‫‪ y‬ﻫﻮ ﻋﻨﺼﺮﻧﺎ‬
‫ﺘﻈﺎر )‪"DDD")) 7‬‬ ‫ﺘﻴﺮاد ﻗﺎﺋﻤ ﺔ اﻻﻧ‬

‫)‪1‬اﺳ‬
‫‪q.put ((2، "BBB")) 6) q.put ((4،‬‬
‫)‪"AAA")) 4) q.put ((3، "CCC")) 5‬‬
‫‪() 3) q.put ((1،‬‬
‫‪2) q = queue.PriorityQueue‬‬
‫ﺑﻴﻨﻤﺎ ﻟﻴ ﺲ ) " = ‪(q.get () [1]، end‬‬
‫‪q.empty (): 8) print‬‬
‫اﻹﺧﺮاج‪AAA BBB CCC DDD :‬‬
‫‪148‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﺨﺪام اﻷﻗﻔﺎل‪:‬‬
‫ﺒﺮﻣﺠ ﺔ اﻟﺠﻴﺪة ﻣﻊ اﺳ‬
‫ﻣﻤﺎرﺳﺎ ت اﻟ‬
‫ﺣﺎﻟ ﺔ ‪1:‬‬
‫ﺘﻢ رﻓﻌﻪ وﺳﻮاء‬
‫ﺜﻨﺎء أم ﻟﻢﻳ‬
‫ﺘ‬‫ﺋﻤﺎﺳﻮاءﺗﻢ رﻓﻊ اﻻﺳ‬
‫ﺘﻢﺗﺤﺮﻳﺮه دا ً‬
‫ﺘﻠ ﺔ اﻟﻨﻬﺎﺋﻴ ﺔ‪ .‬اﻟﻤﻴﺰة ﻫ ﻲ أن اﻟﻘﻔﻞﺳﻴ‬
‫ﺑ ﺔ ﻛﻮدﺗﺤﺮﻳﺮ اﻷﻗﻔﺎل داﺧﻞ اﻟﻜ‬
‫ﺘﺎ‬
‫ﺑﻜ‬‫ﺑﺸﺪة‬‫ﻳﻮﺻﻰ‬
‫ﺘﻌﺎﻣﻞ ﻣﻌﻪ أم ﻻ‪.‬‬
‫ﺗﻢ اﻟ‬
‫ل =ﺧﻴﻮط‪ .‬ﻗﻔﻞ )(‬

‫ﺑﺔ‬
‫إﺟﺮاء اﻟﻌﻤﻠﻴﺎ ت اﻵﻣﻨ ﺔ اﻟﻤﻄﻠﻮ‬
‫ﺒ ﻲ‪:‬‬
‫*‬
‫ﺘﻴﺮاد )‪(name): 5) l.acquire () 6‬‬
‫)‪1‬ﻣﻦ اﺳ‬
‫‪3) l = Lock () 4) def wish‬ﺣﺎول‪7) :‬ﻟـ ‪i‬ﻓ ﻲ اﻟﻨﻄﺎق "( ‪(10): 8) print‬‬
‫ﺒﺎﻋ ﺔ )اﻻﺳﻢ( )‪11‬‬
‫ﻣ ﺴﺎء اﻟﺨﻴﺮ ‪"، :‬اﻟﻨﻬﺎﻳ ﺔ )‪=") 9‬وﻗ ﺖ اﻟﻨﻮم )‪(2) 10‬ﻃ‬
‫ﺒ ﺔ ‪ ،‬أرﻏ ﺲ = ‪t2‬‬
‫أﺧﻴ ﺮًا‪12) :‬اﻹﺻﺪار = ‪() 13) 14) t1‬اﻟﺨﻴﻂ )اﻟﻬﺪف =اﻟﺮﻏ‬
‫"‪= ("Yuvraj‬‬
‫))‪( ) 18) ،‬‬ ‫)‪16) t3()=19‬‬
‫‪t2.start‬‬ ‫ﺒﺔ ‪،‬‬‫)اﻟﻬﺪف =اﻟﺮﻏ‬
‫‪t3.start‬‬ ‫اﻟﺨﻴﻂ‬
‫)اﻟﻬﺪف= =اﻟﺮﻏ‬
‫ﺒ ﺔ ‪() ،‬‬ ‫))‪( "Dhoni"،‬‬ ‫)‪15‬‬
‫‪args‬اﻟﺨﻴﻂ‬
‫‪args = ("Kohli" ،)) 17) t1.start‬‬
‫ﺘﺤﻜﻢ‬
‫ﺑﻤﺠﺮد وﺻﻮل ﻋﻨﺼﺮ اﻟ‬‫ﺘﻢﺗﺤﺮﻳﺮهﺗﻠﻘﺎﺋ ًﻴﺎ‬
‫ﺋﻴ ﺴﻴ ﺔ ﻟـ ‪ with statement‬ﻫ ﻲ أن اﻟﻘﻔﻞﺳﻴ‬
‫ﺒﻴﺎن‪ .‬اﻟﻤﻴﺰة اﻟﺮ‬
‫ﺘﺨﺪام اﻟ‬
‫ﺑﺎﺳ‬‫ﺑﺎﻟﺤﺼﻮل ﻋﲆ اﻟﻘﻔﻞ‬‫ﺑﺸﺪة‬‫•ﻳﻮﺻﻰ‬
‫ﺑﺸﻜﻞ ﺻﺮﻳﺢ‪.‬‬‫ﺑﺎﻹﻓﺮاج‬‫ﺒﻴﻦ‬
‫ﺘﻠ ﺔ وﻟ ﺴﻨﺎ ﻣﻄﺎﻟ‬
‫إﱃ ﻧﻬﺎﻳ ﺔ اﻟﻜ‬
‫ﺑﻴﺎن ﻟﻠﻤﻠﻔﺎ ت‪.‬‬‫ﺘﺨﺪام ﻣﻊ‬

‫ﺒﻂ ﻧﻔ ﺲ اﺳ‬
‫ﺑﺎﻟﻀ‬‫• ﻫﺬا ﻫﻮ‬
‫‪149‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺜﺎل ﻋﻦ ﻣﻠﻒ‪:‬‬
‫ﻣ‬
‫ﺜﻞ ‪f:‬‬
‫ﻣﻊ )"‪open ("demo.txt"، "w‬ﻣ‬
‫ﺒﺎ ‪("...‬‬
‫‪")f.write‬ﻣﺮﺣ ً‬
‫ﺜﺎل ﻋﲆ اﻟﻘﻔﻞ‪:‬‬
‫ﻣ‬
‫ﻗﻔﻞ =ﺧﻴﻮط‪.‬‬
‫ﻣﻊ ﻗﻔﻞ‪:‬‬
‫ﺑﺔ‬
‫إﺟﺮاء اﻟﻌﻤﻠﻴﺎ ت اﻵﻣﻨ ﺔ اﻟﻤﻄﻠﻮ‬
‫ﺘﻢﺗﺤﺮﻳﺮ اﻟﻘﻔﻞﺗﻠﻘﺎﺋ ًﻴﺎ‬
‫ﺳﻴ‬
‫ﺒ ﻲ‪:‬‬
‫*‬
‫ﺘﻴﺮاد )‪3‬اﻟﻘﻔﻞ =اﻟﻘﻔﻞ )‪4‬‬
‫)‪1‬ﻣﻦ اﺳ‬
‫ﺘﻌﺮﻳﻒ )اﻻﺳﻢ(‪5) :‬ﻣﻊ اﻟﻘﻔﻞ‪6) :‬ﻟـ ‪i‬ﻓ ﻲ اﻟﻨﻄﺎق )‪7‬‬
‫ﺒ ﺔ اﻟ‬
‫)(رﻏ‬
‫ﺒﺎﻋ ﺔ ‪("Good Evening:" ،‬اﻟﻨﻬﺎﻳ ﺔ = ‪12) t3‬‬
‫‪(10):‬ﻃ‬
‫))‪11) t2 = Thread (target = wish، args = ( "Yuvraj"،‬‬
‫))‪10) t1 = Thread (target = wish، args = ("Dhoni"،‬‬
‫)اﻟﻬﺪف =‬ ‫)‪= ()'')14‬اﻟﺨﻴﻂ‬
‫‪13) t1.start‬‬ ‫‪8) time.sleep‬‬ ‫‪(2) t3.start‬‬
‫)‪t2.start () 15‬‬ ‫)‪9) print ()(name‬‬
‫ﺒﺔ ‪،‬‬
‫اﻟﺮﻏ‬
‫))‪args = ("Kohli"،‬‬
‫ﺒﻴﺎن ﻟﻠﺤﺼﻮل ﻋﲆﺗﺄﻣﻴﻦ‬

‫ﺘﺨﺪام ﻣﻊ اﻟ‬
‫س( ﻣﺎ ﻫ ﻲ ﻣﻴﺰة اﺳ‬
‫ﺧﻴﻮط؟‬
‫ﺑﺸﻜﻞ ﺻﺮﻳﺢ‪.‬‬‫ﺑﺎﻹﻓﺮاج ﻋﻨﻪ‬‫ﺒﻴﻦ‬
‫ﺘﻠ ﺔ وﻟ ﺴﻨﺎ ﻣﻄﺎﻟ‬
‫ﺘﺤﻜﻢ إﱃ ﻧﻬﺎﻳ ﺔ اﻟﻜ‬
‫ﺑﻤﺠﺮد وﺻﻮل ﻋﻨﺼﺮ اﻟ‬‫ﺘﻢﺗﺤﺮﻳﺮ اﻟﻘﻔﻞﺗﻠﻘﺎﺋ ًﻴﺎ‬
‫ﺳﻴ‬
‫ﺘﺎﻟﻴ ﺔ‪:‬‬
‫ﺒﺎرة ﻓ ﻲ ‪multithreading‬ﻟﻠﺤﺎﻻ ت اﻟ‬
‫ﺘﺨﺪاﻣﻬﺎ ﻣﻊ اﻟﻌ‬
‫ﻣﻼﺣﻈ ﺔ‪:‬ﻳﻤﻜﻨﻨﺎ اﺳ‬
‫)‪1‬ﻗﻔﻞ‬
‫‪2) RLock‬‬
‫)‪3‬ﺳﻴﻤﺎﻓﻮر‬
‫)‪4‬اﻟﺸﺮط‬

‫‪150‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺜﻮن‬
‫ﺑﺎﻳ‬
‫ﻗﺎﻋﺪة اﻟ‬
‫ﺑﺮﻣﺠ ﺔ‬
‫‪151‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﺨﺰﻳﻦ‬
‫ﻣﻨﺎﻃﻖ اﻟ‬
‫ﺗﻴﺮ وﻣﻌﻠﻮﻣﺎ ت اﻟﻤﻜﺎﻟﻤﺎ ت وﻣﺎ إﱃ ذﻟﻚ‪.‬‬
‫ﺜﻞ ﻣﻌﻠﻮﻣﺎ ت اﻟﻌﻤﻼء وﻣﻌﻠﻮﻣﺎ ت اﻟﻔﻮا‬
‫ﺗﻨﺎ ﻣ‬
‫ﺑﻴﺎﻧﺎ‬‫ﺒﻨﺎﺗﺨﺰﻳﻦ‬
‫ﺗﻨﺎ ‪ ،‬ﻓﻘﺪ ﻃﻠ‬
‫ﺒﻴﻘﺎ‬
‫ﻛﺠﺰء ﻣﻦﺗﻄ‬
‫ﺘﺨﺰﻳﻦ‪.‬‬
‫ﺒﻨﺎ ﻣﻨﺎﻃﻖﺗﺨﺰﻳﻦ‪ .‬ﻫﻨﺎك ﻧﻮﻋﺎن ﻣﻦ ﻣﻨﺎﻃﻖ اﻟ‬
‫ﺒﻴﺎﻧﺎ ت ‪ ،‬ﻃﻠ‬
‫ﺘﺨﺰﻳﻦ ﻫﺬه اﻟ‬
‫ﻟ‬
‫ﺘﺔ‬
‫ﺘﺨﺰﻳﻦ اﻟﻤﺆﻗ‬
‫)‪1‬ﻣﻨﺎﻃﻖ اﻟ‬
‫ﺘﺨﺰﻳﻦ اﻟﺪاﺋﻤ ﺔ‬
‫ﺘ ﺔ‪:‬‬
‫ﺘﺨﺰﻳﻦ اﻟﻤﺆﻗ‬
‫ﺘًﺎ‪.‬‬
‫ﺒﻴﺎﻧﺎ ت ﻣﺆﻗ‬
‫ﺘﻢﺗﺨﺰﻳﻦ اﻟ‬
‫• ﻫﺬه ﻫ ﻲ ﻣﻨﺎﻃﻖ اﻟﺬاﻛﺮة ﺣﻴ ﺚﺳﻴ‬
‫ﺜﻞ ‪List‬و ‪Tuple‬و ‪Dictionary.‬‬
‫ﺜﺎل‪ :‬ﻛﺎﺋﻨﺎ ت ‪Python‬ﻣ‬
‫ﻋﲆﺳ‬
‫ﺘﻔﻘﺪ اﻟ‬
‫ﺘﻢﺗﺪﻣﻴﺮ ﻫﺬه اﻟﻜﺎﺋﻨﺎ تﺗﻠﻘﺎﺋ ًﻴﺎ وﺳ‬
‫ﺗﻨﻔﻴﺬه ‪،‬ﺳﻴ‬
‫ﺑﺮﻧﺎﻣﺞ ‪Python‬‬‫ﺑﻤﺠﺮد أنﻳﻜﻤﻞ‬
‫•‬
‫ﺑﺸﻜﻞ داﺋﻢ‪.‬‬‫ﺒﻴﺎﻧﺎ ت‬
‫ﺘ ﺔ‪ .‬ﻫﻨﺎﻳﻤﻜﻨﻨﺎﺗﺨﺰﻳﻦ اﻟ‬
‫ﺘﺨﺰﻳﻦ اﻟ‬
‫ﺑﺎﺳﻢ ﻣﻨﺎﻃﻖ اﻟ‬ ‫ُﻌﺮف أ ً‬
‫ﺘﺨﺰﻳﻦ اﻟﺪاﺋﻤ ﺔ‪• :‬‬
‫ﺒﻴﺎﻧﺎ ت اﻟﻀﺨﻤ ﺔ وﻣﺎ إﱃ ذﻟﻚ‬

‫ﺗﻘﻨﻴﺎ ت اﻟ‬
‫ﺒﻴﺎﻧﺎ ت و‬
‫ﺘﻮدﻋﺎ ت اﻟ‬
‫ﺒﻴﺎﻧﺎ ت وﻣ ﺴ‬
‫ﺜﺎل‪ :‬أﻧﻈﻤ ﺔ اﻟﻤﻠﻔﺎ ت وﻗﻮاﻋﺪ اﻟ‬
‫ﻋﲆﺳ‬
‫أﻧﻈﻤ ﺔ اﻟﻤﻠﻔﺎ ت‪:‬‬

‫ﺘﺨﺰﻳﻦ ﻛﻤﻴ ﺔ أﻗﻞ ﻣﻦ اﻟﻤﻌﻠﻮﻣﺎ ت‪.‬‬
‫ﺘﺸﻐﻴﻞ اﻟﻤﺤﻠ ﻲ‪ .‬أﻧﻈﻤ ﺔ اﻟﻤﻠﻔﺎ ت ﻫ ﻲ اﻷﻧ ﺴ ﺐ ﻟ‬
‫ﺑﻮاﺳﻄ ﺔ ﻧﻈﺎم اﻟ‬‫ﻳﻤﻜﻦﺗﻮﻓﻴﺮ أﻧﻈﻤ ﺔ اﻟﻤﻠﻔﺎ ت‬
‫ﻣﺤﺪدا ت‪:‬‬
‫)‪1‬ﻻﻳﻤﻜﻨﻨﺎﺗﺨﺰﻳﻦ ﻛﻤﻴ ﺔ ﺿﺨﻤ ﺔ ﻣﻦ اﻟﻤﻌﻠﻮﻣﺎ ت‪.‬‬
‫ﺒﺢ اﻟﻌﻤﻠﻴﺎ ت ﻣﻌﻘﺪة ﻟﻠﻐﺎﻳ ﺔ‪.‬‬
‫ﺘﺼ‬‫ﺘﺎﻟ ﻲﺳ‬
‫ﺑﺎﻟ‬
‫ﺘﻌﻼم و‬
‫)‪2‬ﻻﻳﻮﺟﺪ دﻋﻢ ﻟﻠﻐ ﺔ اﻻﺳ‬
‫)‪3‬ﻻﻳﻮﺟﺪ أﻣﺎن ﻟﻠ‬
‫ﺛﻢ ﻗﺪﺗﻜﻮن ﻫﻨﺎك ﻓﺮﺻ ﺔ ﻟﻤﺸﺎﻛﻞ ﻋﺪمﺗﻨﺎﺳﻖ اﻟ‬‫ﺒﻴﺎﻧﺎ ت‪ .‬وﻣﻦ‬
‫)‪4‬ﻻﺗﻮﺟﺪ آﻟﻴ ﺔ ﻟﻤﻨﻊﺗﻜﺮار اﻟ‬
‫ﺘﻐﻠ ﺐ ﻋﲆ ﻣﺸﺎﻛﻞ أﻧﻈﻤ ﺔ اﻟﻤﻠﻔﺎ ت اﻟﻤﺬﻛﻮرة أﻋﻼه ‪،‬ﻳﺠ ﺐ أن ﻧﺬ ﻫ ﺐ إﱃ ﻗﻮاﻋﺪ اﻟ‬
‫ﻟﻠ‬
‫ﺑﻴﺎﻧﺎ ت‪:‬‬‫ﻗﻮاﻋﺪ‬
‫)‪1‬ﻳﻤﻜﻨﻨﺎﺗﺨﺰﻳﻦ ﻛﻤﻴ ﺔ ﻫﺎﺋﻠ ﺔ ﻣﻦ اﻟﻤﻌﻠﻮﻣﺎ ت ﻓ ﻲ ﻗﻮاﻋﺪ اﻟ‬
‫ﺑﺎﻟﻐ ﺔ‪.‬‬‫ﺑ ﺴﻬﻮﻟ ﺔ‬‫ﺒﻴﺎﻧﺎ ت‬
‫ﺘﺎﻟ ﻲﻳﻤﻜﻨﻨﺎ إﺟﺮاء ﻋﻤﻠﻴﺎ ت ﻗﺎﻋﺪة اﻟ‬
‫ﺑﺎﻟ‬
‫ﺑﻴﺎﻧﺎ ت و‬‫ﺘﺎح ﻟﻜﻞ ﻗﺎﻋﺪة‬
‫ﺘﻌﻼم ﻣ‬
‫)‪2‬دﻋﻢ ﻟﻐ ﺔ اﻻﺳ‬
‫ﺘﻢﺗﺄﻣﻴﻦ اﻟ‬
‫ﺛﻢﻳ‬‫ﺑﻴﻦ‪ .‬وﻣﻦ‬
‫ﺒﺎرﻳﻴﻦ ﻣﻄﻠﻮ‬
‫ﺘﺨﺪم و ‪pwd‬اﻹﺟ‬
‫ﺒﻴﺎﻧﺎ ت ‪،‬ﻳﺠ ﺐ أنﻳﻜﻮن اﺳﻢ اﻟﻤ ﺴ‬
‫ﺒﻴﺎﻧﺎ ت اﻟﻤﻮﺟﻮدة ﻓ ﻲ ﻗﺎﻋﺪة اﻟ‬
‫)‪3‬ﻟﻠﻮﺻﻮل إﱃ اﻟ‬
‫ﺒﻴﺎﻧﺎ تﺗﻘﻨﻴﺎ ت‬
‫ﺒﻊ ﻣ ﺴﺆول ﻗﺎﻋﺪة اﻟ‬
‫ﺘ‬‫ﺒﻴﺎﻧﺎ ت ‪،‬ﻳ‬
‫ﺛﻨﺎءﺗﻄﻮﻳﺮ ﻣﺨﻄﻄﺎ ت ﺟﺪول ﻗﺎﻋﺪة اﻟ‬
‫ﺒﻴﺎﻧﺎ ت اﻟﺪاﺧﻠﻴ ﺔ ﻓ ﻲ ﺷﻜﻞ ﺟﺪاول‪ .‬أ‬
‫ﺑﻴﺎﻧﺎ ت ﻗﺎﻋﺪة اﻟ‬‫ﺘﻢﺗﺨﺰﻳﻦ‬
‫)‪4‬ﺳﻴ‬
‫ﺛﻢ ﻻﺗﻮﺟﺪ‬‫ﺒﻴﺎﻧﺎ ت‪ .‬وﻣﻦ‬
‫ﺘ ﻲﺗﻤﻨﻊﺗﻜﺮار اﻟ‬
‫ﺘﺎح اﻷﺳﺎﺳ ﻲ وﻣﺎ إﱃ ذﻟﻚ واﻟ‬
‫ﺗﻴﺢ اﻟﻔﺮﻳﺪة وﻗﻴﻮد اﻟﻤﻔ‬
‫ﺜﻞ ﻗﻴﻮد اﻟﻤﻔﺎ‬
‫ﺘﻠﻔ ﺔ ﻣ‬
‫ﺘﻠﻔ ﺔ وﻳﻤﻜﻨﻪﺗﻨﻔﻴﺬ ﻗﻴﻮد ﻣﺨ‬
‫ﺗ ﺴﻮﻳ ﺔ ﻣﺨ‬
‫ﻓﺮﺻ ﺔ ﻟﻤﺸﺎﻛﻞ ﻋﺪمﺗﻨﺎﺳﻖ اﻟ‬
‫‪152‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺒﻴﺎﻧﺎ ت‪:‬‬
‫ﺣﺪود ﻗﻮاﻋﺪ اﻟ‬
‫ﺑﺎﻳ ﺖ ﻣﻦ اﻟ‬
‫ﺜﻞﺗﻴﺮا‬
‫ﺒﻴﺎﻧﺎ ت ﻋﲆ ﻛﻤﻴ ﺔ ﺿﺨﻤ ﺔ ﺟﺪًا ﻣﻦ اﻟﻤﻌﻠﻮﻣﺎ ت ﻣ‬
‫ﺘﻮي ﻗﺎﻋﺪة اﻟ‬
‫)‪1‬ﻻﻳﻤﻜﻦ أنﺗﺤ‬
‫ﺒﻪ‬
‫ﺒﻴﺎﻧﺎ ت ﺷ‬
‫ﺒﻴﺎﻧﺎ ت اﻟﻌﻼﺋﻘﻴ ﺔ( وﻻﻳﻤﻜﻨﻬﺎﺗﻘﺪﻳﻢ اﻟﺪﻋﻢ ﻟﻠ‬
‫ﺒﻴﺎﻧﺎ ت اﻟﺠﺪوﻟﻴ ﺔ أو اﻟ‬
‫ﺒﻴﺎﻧﺎ ت اﻟﻤﻬﻴﻜﻠ ﺔ )اﻟ‬
‫ﺒﻴﺎﻧﺎ ت اﻟﺪﻋﻢ ﻓﻘﻂ ﻟﻠ‬
‫)‪2‬ﻳﻤﻜﻦ أنﺗﻮﻓﺮ ﻗﺎﻋﺪة اﻟ‬
‫ﺜﻞ ﻣﻠﻔﺎ ت اﻟﻔﻴﺪﻳﻮ وﻣﻠﻔﺎ ت اﻟﺼﻮ ت واﻟﺼﻮر وﻣﺎ إﱃ ذﻟﻚ(‬
‫ﺒﻴﺎﻧﺎ ت ﻏﻴﺮ اﻟﻤﻨﻈﻤ ﺔ )ﻣ‬
‫ﺜﻞ ﻣﻠﻔﺎ ت )‪XML‬واﻟ‬
‫اﻟﻤﻨﻈﻤ ﺔ )ﻣ‬
‫ﺒﻴﺎﻧﺎ ت وﻣﺎ إﱃ‬

‫ﺘﻮدﻋﺎ ت اﻟ‬
‫ﺒﻴﺮة وﻣ ﺴ‬
‫ﺒﻴﺎﻧﺎ ت اﻟﻜ‬
‫ﺜﻞﺗﻘﻨﻴﺎ ت اﻟ‬
‫ﺘﻘﺪﻣ ﺔ ﻣ‬
‫ﺘﺨﺰﻳﻦ اﻟﻤ‬
‫ﺘﻘﻞ إﱃ اﻟﻤﺰﻳﺪ ﻣﻦ ﻣﻨﺎﻃﻖ اﻟ‬
‫ﺘﻐﻠ ﺐ ﻋﲆ ﻫﺬه اﻟﻤﺸﻜﻼ ت ‪،‬ﻳﺠ ﺐ أن ﻧﻨ‬
‫ﻟﻠ‬
‫ذﻟﻚ‪.‬‬
‫ﺜﻮن‪:‬‬
‫ﺑﺎﻳ‬‫ﺑﻴﺎﻧﺎ ت‬‫ﺑﺮﻣﺠ ﺔ ﻗﺎﻋﺪة‬
‫ﺑـ‬‫ﺗﺼﺎل‬
‫ﺘﻌﻴﻦ ﻋﻠﻴﻨﺎ اﻻ‬
‫ﺒﺮﻣﺠ ﺔ ‪،‬ﻳ‬
‫ﺘﻄﻠ‬
‫ﺑﻌﺾ اﻷﺣﻴﺎن ﻛﺠﺰء ﻣﻦ ﻣ‬‫•ﻓ ﻲ‬
‫ﺘﻴﺎر‬
‫ﺒﻴﺎﻧﺎ ت واﺧ‬
‫ﺒﻴﺎﻧﺎ ت وﺣﺬف اﻟ‬
‫ﺗﺤﺪﻳ ﺚ اﻟ‬
‫ﺒﻴﺎﻧﺎ ت و‬
‫ﺜﻞ إﻧﺸﺎء اﻟﺠﺪاول وإدﺧﺎل اﻟ‬
‫ﺒﻴﺎﻧﺎ ت وﻋﻠﻴﻨﺎ إﺟﺮاء اﻟﻌﺪﻳﺪ ﻣﻦ اﻟﻌﻤﻠﻴﺎ ت ﻣ‬
‫ﻗﺎﻋﺪة اﻟ‬
‫ﺒﻴﺎﻧﺎ ت وﻣﺎ إﱃ ذﻟﻚ‪.‬‬
‫اﻟ‬
‫ﺘﺨﺪام ‪Python‬ﻹرﺳﺎﻟﻬﺎ‬
‫ﺒﻴﺎﻧﺎ ت وﻳﻤﻜﻨﻨﺎ اﺳ‬
‫ﺘﺤﺪ ث إﱃ ﻗﺎﻋﺪة اﻟ‬
‫ﺘﺨﺪام ﻟﻐ ﺔ ‪SQL‬ﻟﻠ‬
‫أواﻣﺮ ‪SQL‬ﻟﻘﺎﻋﺪة اﻟ‬
‫ﺜﻞ ‪Oracle‬و ‪MySql‬و ‪SqlServer‬و‬

‫ﺒﻴﺎﻧﺎ ت ﻣ‬
‫ﺛﻨﺎﻳﺎه ﻋﻮاﻣﻞ ﻟﻠﻌﺪﻳﺪ ﻣﻦ ﻗﻮاﻋﺪ اﻟ‬‫دﻋﻤﺎﻳﺤﻤﻞ ﻓ ﻲ‬
‫ﺗﻮﻓﺮ ‪ً Python‬‬
‫•‬
‫‪GadFly‬و ‪sqlite‬وﻣﺎ إﱃ ذﻟﻚ‪.‬‬
‫ﺑﻴﺎﻧﺎ ت‪.‬‬‫•ﻟﺪى ‪Python‬وﺣﺪة ﻣﻨﻔﺼﻠ ﺔ ﻟﻜﻞ ﻗﺎﻋﺪة‬
‫ﺑﻴﺎﻧﺎ ت ‪Oracle‬‬‫ﺘﻮاﺻﻞ ﻣﻊ ﻗﺎﻋﺪة‬

‫ﺜﺎل‪ :‬وﺣﺪة ‪cx_Oralce‬ﻟﻠ‬
‫ﻋﲆﺳ‬
‫ﺘﻮاﺻﻞ ﻣﻊ ‪Microsoft Sql Server‬‬
‫وﺣﺪة ‪pymssql‬ﻟﻠ‬
‫ﺜﻮن‪:‬‬
‫ﺑﺎﻳ‬‫ﺑﻴﺎﻧﺎ ت‬‫ﺒﺮﻣﺠ ﺔ ﻗﺎﻋﺪة‬
‫اﻟﺨﻄﻮا ت اﻟﻘﻴﺎﺳﻴ ﺔ ﻟ‬
‫ﺑﻴﺎﻧﺎ ت ﻣﺤﺪدة‬‫ﺘﻴﺮاد وﺣﺪة ﻗﺎﻋﺪة‬
‫)‪1‬اﺳ‬
‫ﺘﻴﺮاد ‪cx_Oracle‬‬
‫ﺜﺎل‪ :‬اﺳ‬
‫ﻋﲆﺳ‬
‫ﺑﺮﻧﺎﻣﺞ ‪Python‬وﻗﺎﻋﺪة اﻟ‬‫ﺑﻴﻦ‬‫ﺗﺼﺎل‬
‫)‪2‬إﻧﺸﺎء ا‬
‫ﺘﺨﺪام وﻇﻴﻔ ﺔ )( ‪connect‬ﻟﻠﻮﺣﺪة اﻟﻨﻤﻄﻴ ﺔ‪.‬‬
‫ﺑﺎﺳ‬‫ﺗﺼﺎل ﻫﺬا‬
‫ﻳﻤﻜﻨﻨﺎ إﻧﺸﺎء ﻛﺎﺋﻦ اﻻ‬
‫ﺒﻴﺎﻧﺎ ت(‬
‫‪)con = cx_Oracle.connect‬ﻣﻌﻠﻮﻣﺎ ت ﻗﺎﻋﺪة اﻟ‬
‫ﺜﺎل‪con = cx_Oracle.connect ('scott / tiger @ localhost') :‬‬

‫ﻋﲆﺳ‬
‫ﺘ ﻲ ﻟﻴ ﺴ ﺖﺳﻮى ﻛﺎﺋﻦ اﻟﻤﺆﺷﺮ‪.‬ﻳﻤﻜﻨﻨﺎ‬

‫ﺑﻌﺾ اﻟﻌﻨﺎﺻﺮ اﻟﺨﺎﺻ ﺔ ‪ ،‬واﻟ‬‫ﺘﺎﺋﺞ ‪ ،‬ﻫﻨﺎك ﺣﺎﺟ ﺔ إﱃ‬
‫ﺑﻨﺎ وﻟﻠﺤﺼﻮل ﻋﲆ اﻟﻨ‬‫ﺘﻌﻼﻣﺎ ت ‪sql‬اﻟﺨﺎﺻ ﺔ‬
‫ﺘﻨﻔﻴﺬ اﺳ‬
‫)‪3‬ﻟ‬
‫ﺘﺨﺪام ﻃﺮﻳﻘ ﺔ اﻟﻤﺆﺷﺮ ‪().‬‬
‫ﺑﺎﺳ‬‫إﻧﺸﺎء ﻛﺎﺋﻦ اﻟﻤﺆﺷﺮ‬
‫اﻟﻤﺆﺷﺮ )( ‪= con.cursor‬‬
‫ﺘﺨﺪام ﻛﺎﺋﻦ اﻟﻤﺆﺷﺮ‪ .‬ﻟﻬﺬاﻳﻤﻜﻨﻨﺎ اﺳ‬
‫ﺑﺎﺳ‬
‫ﺘﻌﻼﻣﺎ ت ‪SQL‬‬
‫ﺗﻨﻔﻴﺬ اﺳ‬
‫)‪4‬‬
‫ﺘﻌﻼم ‪SQL‬ﻣﻔﺮد‬
‫)‪(sqlquery‬ﻟ‬ ‫ﺗﻨﻔﻴﺬ‬
‫ﺑﻨﺼﻒ‬‫ﺘﻌﻼﻣﺎ ت ‪SQL‬ﻣﻔﺼﻮﻟ ﺔ‬
‫ﺘﻨﻔﻴﺬﺳﻠ ﺴﻠ ﺔ ﻣﻦ اﺳ‬
‫)‪ executescript (sqlqueries‬ﻟ‬
‫اﻟﻘﻮﻟﻮن "؛"‬
‫ﺘﻌﻼم ذي ﻣﻌﻠﻤﺎ ت‪.‬‬
‫)(ﻟ‬ ‫ﺗﻨﻔﻴﺬي‬
‫ﺜﺎل‪")cursor.execute :‬ﺣﺪد *ﻣﻦ اﻟﻤﻮﻇﻔﻴﻦ"(‬

‫ﻋﲆﺳ‬
‫‪153‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺗﺤﺪﻳ ﺚ |ﺣﺬف(‬
‫ﺘﻌﻼﻣﺎ ت ‪)DML‬إدراج |‬
‫ﺗﻨﺎ ﻓ ﻲ ﺣﺎﻟ ﺔ اﺳ‬
‫ﺒﺎ‬
‫ﺘﻄﻠ‬
‫ﺑﻨﺎ ًء ﻋﲆ ﻣ‬‫ﺘﻐﻴﻴﺮا ت‬
‫ﺘﺮاﺟﻊ ﻋﻦ اﻟ‬
‫ﺘﺰام أو اﻟ‬
‫)‪5‬اﻻﻟ‬
‫ﺘﺔ‬
‫ﺘﻐﻴﻴﺮا ت اﻟﻤﺆﻗ‬
‫ﺘﺮاﺟﻊ ﻋﻦ ﺟﻤﻴﻊ اﻟ‬
‫)(ﻳ‬ ‫ﺒﻴﺎﻧﺎ ت‬
‫ﺘﺮاﺟﻊ ﻋﻦ ﻗﺎﻋﺪة اﻟ‬
‫ﺘﻐﻴﻴﺮا ت ﻋﲆ اﻟ‬
‫)(ﻳﺤﻔﻆ اﻟ‬ ‫ﺘﺰام‬
‫اﻻﻟ‬
‫ﺘﻌﻼﻣﺎ ت‬
‫ﺘﻴﺠ ﺔ ﻣﻦ ﻛﺎﺋﻦ اﻟﻤﺆﺷﺮ ﻓ ﻲ ﺣﺎﻟ ﺔﺗﺤﺪﻳﺪ اﻻﺳ‬
‫ﺑﺈﺣﻀﺎر اﻟﻨ‬‫)‪6‬ﻗﻢ‬
‫)( ‪fetchall‬ﻟﺠﻠ ﺐ ﻛﻞ اﻟﺼﻔﻮف وإرﺟﺎع ﻗﺎﺋﻤ ﺔ‬ ‫)( ‪fetchone‬ﻟﺠﻠ ﺐ ﺻﻒ واﺣﺪ ﻓﻘﻂ‬
‫)‪fecthmany (n‬ﻟﺠﻠ ﺐ أول ‪n‬ﻣﻦ اﻟﺼﻔﻮف‬ ‫اﻟﺼﻔﻮف‬
‫ﺜﺎل )‪() print (data‬‬

‫ﻋﲆﺳ‬
‫‪1: data = cursor.fetchone‬‬
‫ﺜﺎل )( ‪= cursor.fetchall‬‬
‫ﻋﲆﺳ‬
‫ﺒﻴﺎﻧﺎ ت‪print (row) :‬‬
‫‪2: data‬ﻟﻠﺼﻒ ﻓ ﻲ اﻟ‬
‫)‪7‬أﻏﻠﻖ اﻟﻤﻮارد‬
‫ﺘﺨﺪام ﻃﺮق اﻹﻏﻼق )( ‪(). cursor.close () con.close‬‬
‫ﺑﺎﺳ‬‫ﺘﺤﻬﺎ‬
‫ﺗﻴ ﺐ اﻟﻌﻜ ﺴ ﻲ ﻟﻔ‬
‫ﺘﺮ‬‫ﺑﺎﻟ‬‫ﺑﺈﻏﻼق اﻟﻤﻮارد‬‫ﺑﺸﺪة‬‫ﺗﻨﺎ ‪،‬ﻳﻮﺻﻰ‬
‫ﺘﻬﺎء ﻣﻦ ﻋﻤﻠﻴﺎ‬
‫ﺑﻌﺪ اﻻﻧ‬
‫ﺜﻮن‪.‬‬
‫ﺑﺎﻳ‬‫ﺑﻴﺎﻧﺎ ت‬‫ﺒﺮﻣﺠ ﺔ ﻗﺎﻋﺪة‬
‫ﺘﺨﺪاﻣﻬﺎ ﻟ‬
‫ﺘ ﻲﻳﻤﻜﻦ اﺳ‬
‫ﺑﺠﻤﻴﻊ اﻟﻄﺮق اﻟﻤﻬﻤ ﺔ اﻟ‬‫ﻣﻼﺣﻈ ﺔ‪ :‬ﻓﻴﻤﺎﻳﻠ ﻲ ﻗﺎﺋﻤ ﺔ‬
‫)( ‪connect‬‬ ‫)( ‪cursor‬‬
‫)( ‪executescript‬‬ ‫ﺗﻨﻔﻴﺬ‬
‫)(‬ ‫ﺘﺰام‬
‫)(اﻻﻟ‬ ‫ﺗﻨﻔﻴﺬي‬
‫)(‬
‫‪fetch‬‬ ‫ﺘﺮاﺟﻊ )( ‪close‬‬

‫اﻟ‬
‫)(‬ ‫)‪fetchmany (n‬‬
‫)( ‪fetchone‬‬ ‫‪fetchall‬‬
‫)(‬
‫ﺒ ﺔ ﻟﺠﻤﻴﻊ ﻗﻮاﻋﺪ اﻟ‬
‫ﺑﺎﻟﻨ ﺴ‬‫ﺑﻴﺎﻧﺎ ت وﻧﻔ ﺲ اﻟﺸ ﻲء‬‫ﺑﻴﺎﻧﺎ ت إﱃ ﻗﺎﻋﺪة‬‫ﺘﻢﺗﻐﻴﻴﺮ ﻫﺬه اﻷﺳﺎﻟﻴ ﺐ ﻣﻦ ﻗﺎﻋﺪة‬
‫ﻟﻦﻳ‬
‫‪154‬‬
‫ﺑﺎد ‪- 500038 ،‬‬ ‫ﺑﻴ ﺖ‬ ‫ﺘﺮ‪#‬‬
‫ﻳﻔﺎﻧﺎم ‪ ،‬أﻣﻴﺮ‬ ‫‪202،‬‬ ‫ﺑﻖ ‪2 ،‬‬
‫اﻟﻌﻤﻞ ﻣﻊ ‪Oracle Database:‬‬

‫ﺘﺮﺟﻤﻴﻦﺗﺮﺟﻤ ﺔ ﻣﻜﺎﻟﻤﺎ ت ‪Python‬إﱃ ﻣﻜﺎﻟﻤﺎ ت ﺧﺎﺻ ﺔ‬
‫ﺑﻌﺾ اﻟﻤ‬‫ُﻄﻠ ﺐ ﻣﻦ‬
‫ﺑﻴﺎﻧﺎ ت ‪،‬ﻳﺠ ﺐ أنﻳ‬‫ﺘﻮاﺻﻞ ﻣﻊ أي ﻗﺎﻋﺪة‬
‫ﺑﺮﻧﺎﻣﺞ ‪Python‬إذا أردﻧﺎ اﻟ‬‫ﻣﻦ‬
‫ﺑﺮﻧﺎﻣﺞﺗﺸﻐﻴﻞ ‪ /‬ﻣﻮﺻﻞ‪.‬‬‫ﺘﺮﺟﻢ ﻟﻴ ﺲﺳﻮى‬
‫ﺒﻴﺎﻧﺎ ت إﱃ ﻣﻜﺎﻟﻤﺎ ت ‪ Python.‬ﻫﺬا اﻟﻤ‬
‫ﺑﻘﺎﻋﺪة اﻟ‬‫ﺒﻴﺎﻧﺎ ت وﻣﻜﺎﻟﻤﺎ ت ﺧﺎﺻ ﺔ‬
‫ﺑﻘﺎﻋﺪة اﻟ‬
‫ﺑﻴﺎﻧ ﻲ‬‫رﺳﻢ‬
‫ﺘﻴﺢ اﻟﻮﺻﻮل إﱃ‬

‫ﺗ‬‫ﺘﺪاد ‪Python‬‬
‫ﺘﺸﻐﻴﻞ اﻟﻤﻄﻠﻮ ب ﻫﻮ ‪ cx_Oracle. cx_Oracle‬ﻫ ﻲ وﺣﺪة اﻣ‬
‫ﺑﺮﻧﺎﻣﺞ اﻟ‬‫ﺑﻴﺎﻧﺎ ت ‪Oracle ،‬اﺳﻢ‬‫ﺒ ﺔ ﻟﻘﺎﻋﺪة‬
‫ﺜﻞ ‪9،10،11‬و ‪12.‬‬
‫ﺑﻴﺎﻧﺎ ت ‪Oracle‬ﻣ‬‫ﺘﺨﺪاﻣﻬﺎ ﻟﻜﻞ ﻣﻦ ‪Python2‬و ‪Python3.‬ﻳﻤﻜﻨﻪ اﻟﻌﻤﻞ ﻣﻊ أي إﺻﺪار ﻣﻦ ﻗﺎﻋﺪة‬
‫‪Oracle Database ،‬وﻳﻤﻜﻦ اﺳ‬
‫ﺒﻴ ﺖ ‪cx_Oracle:‬‬
‫ﺜ‬‫ﺗ‬
‫ﺘﺎﻟ ﻲ‬
‫ﺘﻨﻔﻴﺬ اﻷﻣﺮ اﻟ‬
‫ﺑ‬‫ﻣﻦ ﻣﻮﺟﻪ اﻷواﻣﺮ اﻟﻌﺎدي )وﻟﻜﻦ ﻟﻴ ﺲ ﻣﻦ وﺣﺪةﺗﺤﻜﻢ ‪Python) ،‬ﻗﻢ‬
‫ﺒﻴ ﺖ ﻧﻘﻄ ﺔ ‪cx_Oracle‬‬

‫ﺜ‬‫ﺗ‬‫>‪D: \ python_classes‬‬
‫ﺟﻤﻊ ‪cx_Oracle‬‬
‫ﺗﺤﻤﻴﻞ )‪cx_Oracle-6.0.2-cp36-cp36m-win32.whl (100kB‬‬
‫ﺛﺎﻧﻴ ﺔ‬‫ﺑﺎﻳ ﺖ ‪/‬‬‫ﺑﺎﻳ ﺖ ‪256‬ﻛﻴﻠﻮ‬‫‪100٪ | ----------- | 102‬ﻛﻴﻠﻮ‬
‫ﺒﻴ ﺖ اﻟﺤﺰم اﻟﻤﺠﻤﻌ ﺔ‪cx-Oracle :‬‬

‫ﺜ‬‫ﺗ‬
‫ﺑﻨﺠﺎح‬
‫ﺒﻴ ﺖ ‪cx-Oracle-6.0.2‬‬
‫ﺜ‬‫ﺗﻢﺗ‬
‫ﺒﻴ ﺖ‪:‬‬
‫ﺜ‬‫ﺘ‬‫ﺒﺎر اﻟ‬
‫ﺘ‬‫ﻛﻴﻔﻴ ﺔ اﺧ‬
‫ﺘﺎﻟ ﻲ‪:‬‬
‫ﺘﻨﻔﻴﺬ اﻷﻣﺮ اﻟ‬
‫ﺑ‬‫ﻣﻦ وﺣﺪةﺗﺤﻜﻢ ‪Python ،‬ﻗﻢ‬
‫>>>ﻣ ﺴﺎﻋﺪة )"وﺣﺪا ت"(‬
‫ﻓ ﻲ اﻹﺧﺮاجﻳﻤﻜﻨﻨﺎ أن ﻧﺮى ‪cx_Oracle‬‬

‫‪....‬‬
‫‪_sha1 _sha256 _sha3 _sha512‬‬ ‫‪nturl2path‬‬ ‫اﻟﻮﻗ ﺖ ﻫﻮ‬

‫‪csv‬‬
‫‪_pickle _pydecimal _pyio _random‬‬ ‫‪ntpath‬أرﻗﺎم‬ ‫‪tkinter‬‬
‫‪csvr‬‬
‫‪_operator _osx_support _overlapped‬‬ ‫ﻣﺸﻐﻞ ﻛﻮد‬ ‫رﻣﺰ‬
‫‪csvw‬‬
‫‪_multiprocessing crypt _opcode‬‬ ‫ﺘﺸﻐﻴﻞ‬
‫اﻟ‬ ‫رﻣﺰا‬
‫اﻷﻧﻮاع‬ ‫‪optparse‬‬ ‫ﺘﻌﻘ ﺐ‬

‫ﻳ‬
‫اﻟﻠﻌﻨﺎ ت‬ ‫ﺛﺮ‬
‫ﺒﻊ اﻷ‬
‫ﺘ‬‫ﺗ‬
‫ﺜﻨﺎء‬
‫ﺘ‬‫ﺑﺎﺳ‬ ‫ﺘﺸﻐﻴﻞ‬
‫ﻧﻈﺎم اﻟ‬ ‫ﺗﺮاﻛﻴﻤﺎﻟﻮك‬
‫‪cx_Oracle‬‬ ‫ﺛﻠﻴ ﺐ ‪pdb‬‬

‫ﺑﺎ‬‫ﻣﺤﻠﻞ‬ ‫ﻳﺤﺎول‬
‫ﺗﺎرﻳﺦ ووﻗ ﺖ‬ ‫ﺘﻴﺎر ﻣﺨﻠﻞ‬

‫اﺧ‬ ‫‪tty‬‬
‫اﻟ‬ ‫‪pickletools‬‬ ‫ﺳﻠﺤﻔﺎة‬
‫ﺒﻞ‬
‫دﻳ ﺴﻴ‬ ‫اﻟ ﺴﻠﺤﻔﺎة‬
‫ﺒ ﻲ ﻋﺸﺮي‬
‫ﺗﺠﺮﻳ‬ ‫أﻧﻮاع‬
‫ﺑﺔ‬
‫ﺘﺎ‬
‫اﻟﻜ‬
‫‪155‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
_socket _sqlite3 difflib ‫ﻏﻴﺮ ﻣ‬unicodedata

‫ﺘﺠﺎﻧ ﺴ ﺔ‬ ‫ﺑﻴ ﺐ‬
‫اﻷﻧﺎ‬
_sitebuiltins ‫ﺗﻴﻠﻴ ﺲ‬
‫دﻳ ﺴﻮ‬
_signal pkg_resources unpick
‫ﻣﺬ ﻫ ﺐ‬ pkgutil ‫ﺗﺤﺪﻳ ﺚ‬
_sre _ssl _stat dummy_threading platform urllib
‫ﺘﻌﺪد اﻷﺷﻜﺎل‬
‫ﻣ‬easy_install ‫ﺘﻠﻴ ﺐ‬
‫ﺑﻠﻴ ﺴ‬‫دورﻏﺎﻣﺎ ت‬
‫ش‬
uuid
.....
‫ﺘﻪ‬
‫ﺒﺎﻋ ﺔ ﻧ ﺴﺨ‬
‫وﻃ‬Oracle Database ‫ﺘﻮاﺻﻞ ﻣﻊ‬
‫ﺑﺮﻧﺎﻣﺞ ﻟﻠ‬
1) ‫ﺒﻴﻖ‬
‫ﺘﻄ‬‫اﻟ‬
@ localhost') 3) print (con.version) 4) con.close () ‫ﺘﻴﺮاد‬

‫اﺳ‬1)
cx_Oracle 2) con = cx_Oracle.connect ('scott / tiger
| ‫ﺘﺎج‬
‫اﻧ‬
D: \ python_classes> py db1.py
11.2.0.2.0
‫ﺑﺮﻧﺎﻣﺠًﺎ ﻹﻧﺸﺎء ﺟﺪول ﻣﻮﻇﻔﻴﻦ ﻓ ﻲ‬‫ﺘﺐ‬

‫اﻛ‬2) ‫ﺒﻴﻖ‬
‫ﺑﻴﺎﻧﺎ ت أوراﻛﻞ‬‫ﻗﺎﻋﺪة‬
(eno، ename، esal، eaddr) ‫ﻣﻮﻇﻔﻴﻦ‬
('scott / tiger @ localhost') 4) cursor = con.cursor () 5) cursor.execute :‫ﺟﺮ ب‬cx_Oracle 2) ‫ﺘﻴﺮاد‬

‫اﺳ‬1)
(eno number، ename varchar2 () 10) ، esal n ‫)"إﻧﺸﺎء ﻣﻮﻇﻔ ﻲ اﻟﺠﺪول‬3) con = cx_Oracle.connect
e: 8) ‫ﻛـ‬cx_Oracle.DatabaseError ‫ﺜﻨﺎء‬
") 7) ‫ﺑﻨﺠﺎح‬‫ﺗﻢ إﻧﺸﺎء اﻟﺠﺪول‬
(" ‫ﺒﺎﻋ ﺔ‬
‫ﻃ‬umber (10،2)، eaddr varchar2 (10)) ") 6)
() :‫إذا ﻛﺎن‬13) cursor.close () 14) :‫إذا ﻛﺎن اﻟﻤﺆﺷﺮ‬12) :‫أﺧﻴ ًﺮا‬11) (‫ ﻫـ‬SQL" ، ‫) " ﻫﻨﺎك ﻣﺸﻜﻠ ﺔ ﻓ ﻲ‬9) con.rollback () 10) print :‫إذا ﻛﺎن‬
15) con.close
156
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﺑﺮﻧﺎﻣﺠًﺎ ﻹﺳﻘﺎط ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ ﻣﻨﻪ‬‫ﺘﺐ‬‫ﺒﻴﻖ )‪3‬اﻛ‬

‫؟‪Oracle Database‬‬
‫ﺘﻴﺮاد )‪cx_Oracle 2‬ﺟﺮ ب‪cursor.execute ("drop table staff") 6) print (" :‬‬
‫)‪1‬اﺳ‬
‫)‪cx_Oracle.connect ('scott / tiger @ localhost') 4) cursor = con.cursor () 5‬‬
‫ﺜﻞ‬
‫ﺜﻨﺎء ‪cx_Oracle.DatabaseError‬ﻣ‬
‫ﺑﻨﺠﺎح )‪") 7‬‬‫ﺗﻢ إﺳﻘﺎط اﻟﺠﺪول‬
‫= ‪3) con‬‬
‫)‪e: 8‬إذا ﻛﺎن‪ 9) con.rollback () 10) print (" :‬ﻫﻨﺎك ﻣﺸﻜﻠ ﺔ ﻓ ﻲ ‪ sql "،‬ﻫـ( )‪11‬أﺧﻴ ﺮًا‪:‬‬
‫ﺑﺈﻏﻼق )(‬‫)‪12‬إذا ﻛﺎن اﻟﻤﺆﺷﺮ‪13) cursor.close () 14) :‬إذا ﻛﺎن‪15) :‬ﻗﻢ‬
‫ﺑﺮﻧﺎﻣﺞ ﻹدراج ﺻﻒ واﺣﺪ ﻓ ﻲ ﻣﻠﻒ‬‫ﺘﺐ‬

‫ﺒﻴﻖ )‪3‬اﻛ‬
‫ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ‬
‫ﺘﻴﺮاد )‪cx_Oracle 2‬ﺟﺮ ب‪('scott / tiger @ localhost') 4) cursor = con.cursor () 5) cursor.execute :‬‬
‫)‪1‬اﺳ‬
‫‪")3) con = cx_Oracle.connect‬إدراج ﻓ ﻲ ﻗﻴﻢ اﻟﻤﻮﻇﻔﻴﻦ "‪(100 ،‬دورﺟﺎ "( ‪1000، 'Hyd') ") 6) con.commit () 7) print‬‬
‫ﺜﻨﺎء ‪cx_Oracle.DatabaseError‬ﻛـ )‪e: 9‬إذا ﻛﺎن‪:‬‬
‫ﺑﻨﺠﺎح )‪") 8‬‬‫ﺗﻢ إدراج اﻟ ﺴﺠﻞ‬
‫‪"،‬‬
‫‪ ")10) con.rollback‬ﻫﻨﺎك ﻣﺸﻜﻠ ﺔ ﻓ ﻲ ‪ sql" ،‬ﻫـ( )‪12‬أﺧﻴ ﺮًا‪13) :‬إذا ﻛﺎن اﻟﻤﺆﺷﺮ‪14) cursor.close () 15) :‬إذا‬
‫‪16) con.close‬‬
‫‪() 11) print‬‬
‫ﻛﺎن‪() :‬‬
‫ﺘﺎﺋﺞ ﻓﻘﻂ ﻓ ﻲ ﻗﺎﻋﺪة‬

‫ﺘﻨﻌﻜ ﺲ اﻟﻨ‬
‫ﺘﺰام ‪() ،‬ﻋﻨﺪ ﻫﺎﺳ‬
‫ﺘﺨﺪام ﻃﺮﻳﻘ ﺔ اﻻﻟ‬
‫ﺗﺤﺪﻳ ﺚ |ﺣﺬف( ‪ ،‬إﻟﺰاﻣ ﻲ ﻋﻠﻴﻨﺎ اﺳ‬
‫ﺛﻨﺎء إﺟﺮاء ﻋﻤﻠﻴﺎ ت ‪)DML‬إدراج |‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬أ‬
‫اﻟ‬
‫‪157‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﻌﺪدة ﻓ ﻲ ﻣﻠﻒ‬
‫ﺑﺮﻧﺎﻣﺠًﺎ ﻹدراج ﺻﻔﻮف ﻣ‬‫ﺘﺐ‬
() ‫ﺘﻨﻔﻴﺬﻳ ﺔ‬
‫ﺘﺨﺪام اﻟﻄﺮﻳﻘ ﺔ اﻟ‬
‫ﺑﺎﺳ‬‫ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ‬
('scott / tiger @ localhost') 4) cursor = con.cursor () 5) sql = :‫ﺟﺮ ب‬cx_Oracle 2) ‫ﺘﻴﺮاد‬

‫اﺳ‬1)
‫(اﻟ ﺴﺠﻼ ت‬: eno،: ename ،: esal،: eaddr) " 6) ‫"أدﺧﻞ ﻓ ﻲ ﻗﻴﻢ اﻟﻤﻮﻇﻔﻴﻦ‬3) con = cx_Oracle.connect
= [(200، 'Sunny'، 2000، 'Mumbai')، 7)
(300 ، "Chinny" ، 3000 ، "Hyd") ، 8)

10) con.commit () 11) print ("Records Inserted Successfully") 12)
‫ﺜﻨﺎء‬
(400، 'Bunny'، 4000، 'Hyd')] 9) cursor.executemany (sql، records)
sql" ، ‫)" ﻫﻨﺎك ﻣﺸﻜﻠ ﺔ ﻓ ﻲ‬e: 13) if con: 14) con.rollback () 15) print ‫ﺜﻞ‬
‫ﻣ‬cx_Oracle.DatabaseError
20) con.close () :‫إذا ﻛﺎن‬18) cursor.close () 19) :‫إذا ﻛﺎن اﻟﻤﺆﺷﺮ‬17) :‫أﺧﻴ ﺮًا‬16) (‫ﻫـ‬
‫ﺘﻌﺪدة ﻓ ﻲ اﻟﻤﻮﻇﻔﻴﻦ‬
‫ﺑﺮﻧﺎﻣﺞ ﻹدراج ﺻﻔﻮف ﻣ‬‫ﺘﺐ‬
‫ﺗﻴﺢ؟‬
‫ﻃﺎوﻟ ﺔ ﻣﻊ ﻣﺪﺧﻼ ت دﻳﻨﺎﻣﻴﻜﻴ ﺔ ﻣﻦ ﻟﻮﺣ ﺔ اﻟﻤﻔﺎ‬
tiger @ localhost') 4) cursor = con.cursor () 5) while True: 6) eno = int :‫ﺣﺎول‬cx_Oracle 2) ‫ﺘﻴﺮاد‬
‫اﺳ‬1)
float :‫ ))"أدﺧﻞ اﺳﻢ اﻟﻤﻮﻇﻒ‬7) ename = input (" : ‫)"أدﺧﻞ رﻗﻢ اﻟﻤﻮﻇﻒ‬3) con = cx_Oracle.connect ('scott /
‫ )""إدراج ﻓ ﻲ‬10) sql = :‫ ))"أدﺧﻞ ﻋﻨﻮان اﻟﻤﻮﻇﻒ‬9) eaddr = input (" :‫ﺗ ﺐ اﻟﻤﻮﻇﻒ‬
‫ )")اﻹدﺧﺎل "(أدﺧﻞ را‬8) esal =
‫ﺗﻢ إدراج‬
")(٪ d، '٪ s'،٪ f، '٪ s')" 11) cursor.execute (sql٪ (eno، ename، esal، eaddr)) 12) print ‫ﻗﻴﻢ اﻟﻤﻮﻇﻔﻴﻦ‬
() 16) :"‫إذا ﻛﺎن اﻟﺨﻴﺎر =="ﻻ‬13) 14) (":[‫)" ﻫﻞﺗﺮﻳﺪ إدراجﺳﺠﻞ آﺧﺮ ]ﻧﻌﻢ |ﻻ‬option = input ( "‫ﺑﻨﺠﺎح‬‫ﺘ ﺴﺠﻴﻞ‬
‫اﻟ‬
‫ﻓﺎﺻﻞ‬15) con.commit

158 - 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﺜﻞ )‪e: 18‬إذا ﻛﺎن‪20) print :‬‬

‫)‪17‬‬
‫)( ‪ ")19) con.rollback‬ﻫﻨﺎك ﻣﺸﻜﻠ ﺔ ﻓ ﻲ )‪sql :" ، e) 21‬أﺧﻴ ًﺮا‪22) :‬إذا ﻛﺎن‬
‫اﻟﻤﺆﺷﺮ‪23) :‬اﻟﻤﺆﺷﺮ‪ .‬أﻏﻠﻖ )‪() 24‬إذا ﻛﺎن‪25) con.close () :‬‬
‫ﺑﻪ‬‫ﺗ ﺐ اﻟﻤﻮﻇﻔﻴﻦ‬
‫ﺘﺤﺪﻳ ﺚ روا‬
‫ﺑﺮﻧﺎﻣﺞ ﻟ‬‫ﺘﺐ‬
‫زﻳﺎدة ﻟﻤﺪى ﻣﻌﻴﻦ ﻣﻊ إدﺧﺎل دﻳﻨﺎﻣﻴﻜ ﻲ‬
‫ﺗ ﺐ أﻗﻞ ﻣﻦ ‪5000‬‬
‫ﺑﻤﻘﺪار ‪500‬را‬‫ﺗ ﺐ ﺟﻤﻴﻊ اﻟﻤﻮﻇﻔﻴﻦ‬
‫ﺜﺎل‪ :‬زﻳﺎدة روا‬
‫ﻋﲆﺳ‬
‫ﺘﻴﺮاد )‪cx_Oracle 2‬ﺟﺮ ب‪4) cursor = con.cursor () 5) increment = float (input :‬‬
‫)‪1‬اﺳ‬
‫ﺗ ﺐ‪float (input ((":‬‬
‫)'‪")3) con = cx_Oracle.connect ('scott / tiger @ localhost‬أدﺧﻞ زﻳﺎدة اﻟﺮا‬
‫ﺗﺤﺪﻳ ﺚﺗﻌﻴﻴﻦ اﻟﻤﻮﻇﻔﻴﻦ ‪esal = esal +٪ f‬ﺣﻴ ﺚ‬
‫ﺗ ﺐ‪"7) sql = ((":‬‬
‫= ‪")6 ) salrange‬أدﺧﻞ ﻧﻄﺎق اﻟﺮا‬
‫ﺜﻬﺎ‬
‫‪")esal <٪ f" 8) cursor.execute (sql٪ (increment، salrange)) 9) print‬اﻟ ﺴﺠﻼ تﺗﻢﺗﺤﺪﻳ‬
‫ﺜﻞ )‪e: 12‬إذا ﻛﺎن ‪print :‬‬
‫ﺑﻨﺠﺎح"( )‪10) con.commit () 11‬‬
‫)‪ ")13) con.rollback () 14‬ﻫﻨﺎك ﻣﺸﻜﻠ ﺔ ﻓ ﻲ ‪ sql :" ،‬ﻫـ( )‪15‬أﺧﻴ ﺮًا‪16) :‬إذا ﻛﺎن اﻟﻤﺆﺷﺮ ‪17) :‬‬
‫ﺑﺈﻏﻼق )(‬‫)‪18‬إذا ﻛﺎنﻳﺨﺪع‪19) :‬ﻗﻢ‬
‫ﺒﺮ ﻛﻤﺪﺧﻼ ت دﻳﻨﺎﻣﻴﻜﻴ ﺔ؟‬

‫ﺒﻬﻢ أﻛ‬
‫ﺗ‬‫ﺑﺮﻧﺎﻣﺠًﺎ ﻟﺤﺬف اﻟﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ روا‬‫ﺘﺐ‬
‫ﺒﻬﻢ ﻋﻦ ‪5000‬‬
‫ﺗ‬‫ﺜﺎل‪ :‬ﺣﺬف ﺟﻤﻴﻊ اﻟﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦﺗﺰﻳﺪ روا‬
‫ﻋﲆﺳ‬
‫ﺘﻴﺮاد )‪cx_Oracle 2‬ﺣﺎول‪tiger @ localhost') 4) cursor = con.cursor () 5) cutoffsalary = float (input ("Enter CutOff :‬‬
‫)‪1‬اﺳ‬
‫ﺗ ﺐ‪((":‬‬
‫‪3) con = cx_Oracle.connect ('scott /‬اﻟﺮا‬
‫‪159‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
Successfully") 9) con.commit () 10) ‫"ﺣﺬف ﻣﻦ اﻟﻤﻮﻇﻔﻴﻦ ﺣﻴ ﺚ‬6) sql =

f" 7) cursor.execute (sql٪ (cutoffsalary)) 8) print ("Records Deleted
con.rollback () 13) print :‫ﻛـ ﻫـ‬cx_Oracle.DatabaseError ‫ﺜﻨﺎء‬
esal>٪
:‫إذا ﻛﺎن اﻟﻤﺆﺷﺮ‬15) :‫أﺧﻴ ﺮًا‬14) (‫ ﻫـ‬sql :" ، ‫)" ﻫﻨﺎك ﻣﺸﻜﻠ ﺔ ﻓ ﻲ‬11) if con: 12)
18) con.close () : ‫إذا ﻛﺎنﻳﺨﺪع‬16) cursor.close () 17)
‫ﺘﺨﺪام ﻃﺮﻳﻘ ﺔ‬
‫ﺑﺎﺳ‬‫ﺘﺤﺪﻳﺪ ﺟﻤﻴﻊ ﻣﻌﻠﻮﻣﺎ ت اﻟﻤﻮﻇﻔﻴﻦ‬
fetchone ()‫؟‬
4) cursor = con.cursor () 5) cursor.execute :‫ﺟﺮ ب‬cx_Oracle 2) ‫ﺘﻴﺮاد‬

‫اﺳ‬1)
‫)"ﺣﺪد *ﻣﻦ‬3) con = cx_Oracle.connect ('scott / tiger @ localhost')
(‫ﺒﺎﻋ ﺔ )ﺻﻒ‬
‫ﻃ‬8) :‫ﺑﻼ‬‫ﺑﻴﻨﻤﺎ اﻟﺼﻒ ﻟﻴ ﺲ‬
= cursor.fetchone () 7) ‫ ﺻﻒ‬6) ("‫اﻟﻤﻮﻇﻔﻴﻦ‬
11) ‫ﺜﻞ‬
‫ﻣ‬cx_Oracle.DatabaseError ‫ﺜﻨﺎء‬
9) row = cursor.fetchone () 10)
:‫أﺧﻴ ًﺮا‬14) (‫ﻫـ‬18)
sql con.close
:" ، ‫ﻣﺸﻜﻠ ﺔ ﻓ ﻲ‬ ‫ﻫﻨﺎك‬
() :‫ﻛﺎن‬ ‫)"إذا‬
16)‫ﺒﺎﻋ ﺔ‬
‫ﻃ‬12) con.rollback
cursor.close () 13 ) ‫ﻛﺎن‬
() 17) :‫اﻟﻤﺆﺷﺮ‬ :‫إذاإذاﻛﺎن‬
15)e:
()‫ﺘﺨﺪام ﻃﺮﻳﻘ ﺔ ؟‬
‫ﺑﺎﺳ‬‫ﺘﺤﺪﻳﺪ ﺟﻤﻴﻊ ﻣﻌﻠﻮﻣﺎ ت اﻟﻤﻮﻇﻔﻴﻦ‬
fetchall
3) con = cx_Oracle.connect ('scott / tiger @ localhost') 4) cursor = con.cursor () :‫ﺟﺮ ب‬cx_Oracle 2) ‫ﺘﻴﺮاد‬
‫اﺳ‬1)
160
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﺒﺎﻋ ﺔ= ‪data‬‬
‫‪cursor.fetchall‬‬
‫اﻟﺼﻒ )‪[0]) 9‬ﻃ‬ ‫اﻟﻤﻮﻇﻒ‪() ،7)":‬‬
‫اﻟﻤﻮﻇﻔﻴﻦ"(‬ ‫ﺒﻊﻣﻦ‬
‫"(رﻗﻢ‬ ‫اﻃ *‬
‫)"ﺣﺪد‬
‫ﺒﻴﺎﻧﺎ) ‪5‬ت‪8) :‬‬
‫‪cursor.execute‬‬
‫)‪6‬ﻟﻠﺼﻒ ﻓ ﻲ اﻟ‬
‫)‪[2]) 11‬‬
‫‪() 14‬‬
‫ﺻﻒ‬‫‪"،‬ﺔ )‬
‫ﺒﺎﻋ‬
‫اﻟﻤﻮﻇﻒ‪:‬‬
‫ﺐﺔ )‪() 13‬ﻃ‬
‫ﺒﺎﻋ‬
‫ﺗ‬
‫ﻃ‬
‫"(را‬
‫ﺒﺎﻋ ﺔ)]‪[3‬‬
‫)]‪[1‬ﻃ)‪12‬‬
‫اﻟﺼﻒ‬‫ﺻﻒ ‪10)"،‬‬
‫اﻟﻤﻮﻇﻒ‪:‬‬
‫ﺳﻢ‪"، :‬‬
‫ﻋﻨﻮان‬
‫)"اﻟﻤﻮﻇﻒ اﻻ‬
‫ﻃ‬
‫ﻛﺎن)(‬
‫‪print‬إذا)‪17‬‬
‫ﻛﺎن‪:‬ا‪19) :‬‬
‫‪sql‬أﺧﻴ ﺮً‬
‫)‪e::"15‬إذا‬
‫ﺜﻞ )‪، e‬‬
‫‪cx_Oracle.DatabaseError‬ﻣ)‪18‬‬
‫‪ ")16) con.rollback‬ﻫﻨﺎك ﻣﺸﻜﻠ ﺔ ﻓ ﻲ‬
‫ﺜﻨﺎء‬
‫ﺑﺈﻏﻼق )(‬‫اﻟﻤﺆﺷﺮ‪20) cursor.close () 21) :‬إذا ﻛﺎنﻳﺨﺪع‪22) :‬ﻗﻢ‬
‫ﺘﺨﺪام )( ‪fetchmany‬‬
‫ﺑﺎﺳ‬‫ﺘﺤﺪﻳﺪ ﻣﻌﻠﻮﻣﺎ ت اﻟﻤﻮﻇﻔﻴﻦ‬
‫ﺒﻴﻖ )‪10‬اﻛ‬
‫ﺘﻢﺗﻮﻓﻴﺮ اﻟﻄﺮﻳﻘ ﺔ واﻟﻌﺪد اﻟﻤﻄﻠﻮ ب ﻣﻦ اﻟﺼﻔﻮف ﻛﻤﺪﺧﻞ دﻳﻨﺎﻣﻴﻜ ﻲ؟‬
‫ﺳﻴ‬
‫ﺘﻴﺮاد )‪cx_Oracle 2‬ﺟﺮ ب‪4) cursor = con.cursor () 5) cursor.execute :‬‬

‫)‪1‬اﺳ‬
‫)'‪")3) con = cx_Oracle.connect ('scott / tiger @ localhost‬ﺣﺪد *ﻣﻦ اﻟﻤﻮﻇﻔﻴﻦ"(‬
‫ﺑ ﺔ‪7 ) data = cursor.fetchmany (n) 8) :‬‬
‫‪")6) n = int‬إدﺧﺎل "(أدﺧﻞ ﻋﺪد اﻟﺼﻔﻮف اﻟﻤﻄﻠﻮ‬
‫ﺜﻨﺎء ‪cx_Oracle.DatabaseError‬ﻛـ )‪11‬‬
‫ﺒﻴﺎﻧﺎ ت‪9) print (row) 10) :‬‬
‫))"ﻟﻠﺼﻒ ﻓ ﻲ اﻟ‬
‫ﻳﻐﻠﻖ)( )‪sql :"، e) 14‬أﺧﻴ ﺮًا‪15) :‬إذا‬
‫ﻣﺸﻜﻠ ﺔ ﻓ ﻲ‬ ‫)‪ ")con: 12‬ﻫﻨﺎك‬
‫‪16) cursor.close‬‬ ‫‪con.rollback‬‬
‫)‪() 17‬‬ ‫‪if con: 18)()con.‬‬
‫‪13) print‬‬
‫ﻛﺎنإذااﻟﻤﺆﺷﺮ‪:‬‬
‫‪e:‬‬
‫‪161‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺗﺞ د‪\ python_classes> py test.py :‬أدﺧﻞ ﻋﺪد‬

‫اﻟﻨﺎ‬
‫ﺑ ﺔ‪(100، 'Durga'، 1500.0، 'Hyd') :‬‬
‫اﻟﺼﻔﻮف اﻟﻤﻄﻠﻮ‬
‫‪3‬‬
‫ﺒﺎي"(‬
‫‪"(200 ،‬ﺻﻨ ﻲ" ‪"2500.0 ، ،‬ﻣﻮﻣ‬
‫)"‪(300، "Chinny"، 3500.0، "Hyd‬‬
‫‪D: \ python_classes> py test.py‬أدﺧﻞ ﻋﺪد اﻟﺼﻔﻮف‬

‫ﺑ ﺔ‪4 (100، 'Durga'، 1500.0، 'Hyd') :‬‬
‫اﻟﻤﻄﻠﻮ‬
‫ﺒﺎي"(‬
‫‪"(200 ،‬ﺻﻨ ﻲ" ‪"2500.0 ، ،‬ﻣﻮﻣ‬
‫)"‪(300، "Chinny"، 3500.0، "Hyd‬‬
‫)'‪(400، 'Bunny'، 4500.0، 'Hyd‬‬
‫ﺑﻴﺎﻧﺎ ت ‪MySQL:‬‬‫اﻟﻌﻤﻞ ﻣﻊ ﻗﺎﻋﺪة‬

‫اﻟﻤﻮرﱢد‪Corporation Open Source and Freeware :‬‬
‫اﻹﺻﺪار اﻟﺤﺎﻟ ﻲ‪ُ5.7.19 :‬‬
‫ﺘﺨﺪم‬
‫ﺘﺮاﺿ ﻲ‪3306 :‬اﻟﻤ ﺴ‬
‫‪SUN Micro Systems / Oracle‬اﻟﻤﻨﻔﺬ اﻻﻓ‬
‫ﺘﺮاﺿ ﻲ‪ :‬اﻟﺠﺬر‬
‫اﻻﻓ‬
‫ﺒﻴﺎﻧﺎ ت اﻟﻤﻨﻄﻘﻴ ﺔ‪.‬‬

‫ﺑﺎﺳﻢ ﻗﻮاﻋﺪ اﻟ‬ ‫ُﻌﺮف أ ً‬
‫ﻳﻀﺎ‬ ‫ﺘ ﻲﺗ‬
‫ﺑﻨﺎ ‪ ،‬واﻟ‬‫ﺒﻴﺎﻧﺎ ت اﻟﺨﺎﺻ ﺔ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬ﻓ ﻲ ‪MySQL ،‬ﻛﻞ ﻣﺎ ﻟﺪﻳﻨﺎ ﻟﻠﻌﻤﻞ ﻣﻊ ﻗﻮاﻋﺪ اﻟ‬
‫‪MySQL.‬ﻣﺨﻄﻂ اﻟﻤﻌﻠﻮﻣﺎ ت‬ ‫ﺘﻮﻓﺮة ﻓ ﻲ‬

‫ﺘﺮاﺿﻴ ﺔ ﻣ‬
‫ﺑﻴﺎﻧﺎ ت اﻓ‬‫ﻓﻴﻤﺎﻳﻠ ﻲ ‪4‬ﻗﻮاﻋﺪ‬
‫‪mysql‬‬ ‫‪Performance_schema‬‬
‫ﺒﺎر‬
‫ﺘ‬‫اﻻﺧ‬
‫ﺑﻴﺎﻧﺎ ت ﻣﻨﻄﻘﻴ ﺔ‪.‬‬‫ﺘﻮﻓﺮ ‪4‬ﻗﻮاﻋﺪ‬

‫ﺗ‬‫ﺑﻴﺎﻧﺎ ت ﻣﺎدﻳ ﺔ واﺣﺪة ﻓﻘﻂ و‬‫ﺘﻮﻓﺮ ﻗﺎﻋﺪة‬
‫ﺒﻴﺎﻧ ﻲ أﻋﻼه ‪،‬ﺗ‬
‫ﻓ ﻲ اﻟﺮﺳﻢ اﻟ‬
‫ﺘﺨﺪام ﻓ ﻲ ‪MySQL:‬‬
‫اﻷواﻣﺮ ﺷﺎﺋﻌ ﺔ اﻻﺳ‬
‫ﺒﻴﺎﻧﺎ ت ؛‬
‫ﺘﺎﺣ ﺔ >‪mysql‬إﻇﻬﺎر ﻗﻮاﻋﺪ اﻟ‬
‫ﺒﻴﺎﻧﺎ ت اﻟﻤ‬
‫)‪1‬ﻟﻤﻌﺮﻓ ﺔ ﻗﻮاﻋﺪ اﻟ‬
‫ﺑﻨﺎ >‪mysql‬إﻧﺸﺎء ﻗﺎﻋﺪة‬‫ﺑﻴﺎﻧﺎ ت ﻣﻨﻄﻘﻴ ﺔ ﺧﺎﺻ ﺔ‬‫)‪2‬ﻹﻧﺸﺎء ﻗﺎﻋﺪة‬

‫ﺑﻴﺎﻧﺎ ت ؛ ‪durgadb‬‬
‫ﺑﻨﺎ >‪mysql‬إﺳﻘﺎط ﻗﺎﻋﺪة‬‫ﺒﻴﺎﻧﺎ ت اﻟﺨﺎﺻ ﺔ‬

‫)‪3‬ﻹﺳﻘﺎط ﻗﺎﻋﺪة اﻟ‬
‫ﺒﻴﺎﻧﺎ ت ؛ ‪durgadb‬‬
‫اﻟ‬
‫‪162‬‬
‫ﺑﺎد ‪- 500038 ،‬‬ ‫ﺑﻴ ﺖ‬ ‫ﺘﺮ‪#‬‬
‫ﻳﻔﺎﻧﺎم ‪ ،‬أﻣﻴﺮ‬ ‫‪202،‬‬ ‫ﺑﻖ ‪2 ،‬‬
‫ﺘﺨﺪم ؛ ‪durgadb‬‬
‫ﺑﻴﺎﻧﺎ ت ﻣﻨﻄﻘﻴ ﺔ ﺧﺎﺻ ﺔ >‪mysql‬اﺳ‬‫ﺘﺨﺪام ﻗﺎﻋﺪة‬
‫)‪4‬ﻻﺳ‬
‫‪ OR mysql> connect‬؛ ‪durgadb‬‬
‫)‪5‬ﻹﻧﺸﺎء اﻟﺠﺪول‬
‫إﻧﺸﺎء ﻣﻮﻇﻔ ﻲ اﻟﺠﺪول ؛ ))‪(eno int (5) basic key، ename varchar (10)، esal double (10،2)، eaddr varchar (10‬‬
‫)‪6‬ﻹدﺧﺎل اﻟ‬
‫ﺗﻀﺎف إﱃ ﻗﻴﻢ اﻟﻤﻮﻇﻔﻴﻦ ‪"(100 ،‬دورﺟﺎ" ‪ "1000 ، ،‬ﻫﻴﺪرو"( ؛‬
‫ﺒﺎي"( ؛‬
‫إدراج ﻓ ﻲ ﻗﻴﻢ اﻟﻤﻮﻇﻔﻴﻦ ‪"(200 ،‬راﻓ ﻲ" ‪"2000 ، ،‬ﻣﻮﻣ‬
‫ﺒﺎس اﻟﻤﺰدوﺟ ﺔ‪.‬‬

‫ﺘ‬‫ﺘﺨﺪام ﻋﻼﻣﺎ ت اﻻﻗ‬ ‫ﺒﺎس اﻟﻤﻔﺮدة ‪،‬ﻳﻤﻜﻨﻨﺎ أ ً‬
‫ﻳﻀﺎ اﺳ‬ ‫ﺘ‬‫ﺑﺪﻻ ً ﻣﻦ ﻋﻼﻣﺎ ت اﻻﻗ‬
‫ﻓ ﻲ ‪MySQL‬‬
‫ﻣﻌﻠﻮﻣﺎ ت اﻟ ﺴﺎﺋﻖ ‪ /‬اﻟﻤﻮﺻﻞ‪:‬‬

‫ﺘﺪﻋﺎءا ت‬
‫ﺘﺪﻋﺎءا ت ‪Python‬اﻟﻤﺤﺪدة إﱃ اﺳ‬
‫ﺘﺤﻮﻳﻞ اﺳ‬
‫ﺒﺎري ﻟ‬
‫ﺘﺮﺟﻢ إﺟ‬
‫ﺑﻴﺎﻧﺎ ت ‪MySql ،‬ﻳﻠﺰم وﺟﻮد ﻣ‬‫ﺘﻮاﺻﻞ ﻣﻊ ﻗﺎﻋﺪة‬
‫ﺑﺮﻧﺎﻣﺞ ‪Python‬إذا أردﻧﺎ اﻟ‬‫ﻣﻦ‬
‫ﺘﺮﺟﻢ ﻟﻴ ﺲﺳﻮىﺳﺎﺋﻖ أو ﻣﻮﺻﻞ‪.‬‬
‫ﺜﻮن‪ .‬ﻫﺬا اﻟﻤ‬
‫ﺒﻴ‬‫ﺑ‬‫ﺑﻴﺎﻧﺎ ت ‪mysql‬إﱃ ﻣﻜﺎﻟﻤﺎ ت ﺧﺎﺻ ﺔ‬‫ﺑﻘﺎﻋﺪة‬‫ﺑﻴﺎﻧﺎ ت ‪mysql‬وﻣﻜﺎﻟﻤﺎ ت ﺧﺎﺻ ﺔ‬‫ﻣﺤﺪدة ﻟﻘﺎﻋﺪة‬
‫ﺑﻴﺎﻧﺎ ت ‪mysql.‬‬‫ﺑﺸﻜﻞ ﻣﻨﻔﺼﻞ ﻣﻦ ﻗﺎﻋﺪة‬‫ﺘﻌﻴﻦ ﻋﻠﻴﻨﺎﺗﻨﺰﻳﻞ اﻟﻤﻮﺻﻞ‬

‫ﻳ‬
‫‪https://dev.mysql.com/downloads/connector/python/2.1.html‬‬
‫ﺒﻴ ﺖ‪:‬‬
‫ﺜ‬‫ﺘ‬‫ﺘﺤﻘﻖ ﻣﻦ اﻟ‬
‫ﻛﻴﻔﻴ ﺔ اﻟ‬
‫ﺘﺨﺪام اﻟﻤ ﺴﺎﻋﺪة )"اﻟﻮﺣﺪا ت اﻟﻨﻤﻄﻴ ﺔ"(‬
‫ﻣﻦ وﺣﺪةﺗﺤﻜﻢ ‪Python ،‬ﻋﻠﻴﻨﺎ اﺳ‬
‫ﻓ ﻲ ﻗﺎﺋﻤ ﺔ اﻟﻮﺣﺪا ت ‪،‬ﻳﺠ ﺐ أنﺗﻜﻮن ‪MySQL‬اﻹﻟﺰاﻣﻴ ﺔ ﻣﻮﺟﻮدة‪.‬‬
‫ﺘﻌﻴﻦ ﻋﻠﻴﻨﺎﺗﻌﻴﻴﻦ ‪PATH‬و ‪PYTHONPATH‬‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬ﻓ ﻲ ﺣﺎﻟ ﺔ ‪Python3.4 ،‬ﻳ‬
‫اﻟﻤ ﺴﺎر ‪= C: \ Python34‬‬

‫‪PYTHONPATH = C: \ Python34 \ Lib \ site -packs‬‬
‫ﺒﻴﺎﻧﺎ ت واﻟﻌﺮض‬
‫ﺑﺮﻧﺎﻣﺠًﺎ ﻹﻧﺸﺎء ﺟﺪول وإدراج اﻟ‬‫ﺘﺐ‬
‫س( اﻛ‬
‫ﺑﻴﺎﻧﺎ ت ‪MySQL‬‬‫ﺘﺨﺪام ﻗﺎﻋﺪة‬
‫اﻟ‬
‫ﺘﻴﺮاد )‪mysql.connector 2‬ﺣﺎول‪= mysql.connector.connect (host = 'localhost'، database = 'durgadb'، user = 'root'، p :‬‬
‫)‪1‬اﺳ‬
‫‪3) con‬‬
‫‪")assword = 'root') 4) cursor = con.cursor () 5) cursor.execute‬إﻧﺸﺎء ﻣﻮﻇﻔ ﻲ اﻟﺠﺪول ‪(5) basic key، ename varchar) (1‬‬
‫‪(eno int‬‬
‫)" ))‪0) ، esal double (10،2) ، eaddr varchar (10‬‬
‫‪163‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
("Table Created ...") 7) 8) sql = "insert into staff (eno، ename، esal، eaddr) VALUES (٪ s،٪ s،٪ s،٪ s)" 9)
= [(100، 'Sachin'، 1000، 'Mumbai')، 10) ‫ﺳﺠﻼ ت‬6) print
(200 ، "Dhoni" ، 2000 ، "Ranchi") ، 11)

records) 13) con.commit () 14) print ("Records Inserted Successfully ...") 15) cursor.execute
= cursor.fetchall () 17) ‫ﺒﻴﺎﻧﺎ ت‬
‫اﻟ‬16) ("‫() "ﺣﺪد *ﻣﻦ اﻟﻤﻮﻇﻔﻴﻦ‬300، 'Kohli'، 3000، 'Delhi')] 12) cursor.executemany (sql،
، ":‫ﺗ ﺐ اﻟﻤﻮﻇﻒ‬
‫ﺒﻊ "(را‬
‫ [اﻃ‬1]) 20) ‫ اﻟﺼﻒ‬، ":‫ﺒﺎﻋ ﺔ "(اﺳﻢ اﻟﻤﻮﻇﻒ‬
‫[ﻃ‬0]) 19) ‫ اﻟﺼﻒ‬، ":‫ﺒﻊ "(رﻗﻢ اﻟﻤﻮﻇﻒ‬
‫اﻃ‬18) : ‫ﺒﻴﺎﻧﺎ ت‬
‫ﻟﻠﺼﻒ ﻓ ﻲ اﻟ‬
mysql.connector. DatabaseError ‫ﺜﻨﺎء‬
() 24) ‫ﺒﺎﻋ ﺔ‬
‫ )(ﻃ‬23) ‫ﺒﺎﻋ ﺔ‬
‫[ﻃ‬3]) 22) ‫ اﻟﺼﻒ‬، ":‫ﺒﺎﻋ ﺔ )"ﻋﻨﻮان اﻟﻤﻮﻇﻒ‬
‫[ﻃ‬2]) 21) ‫اﻟﺼﻒ‬
cursor.close () 31) :‫إذا ﻛﺎن اﻟﻤﺆﺷﺮ‬29) :‫أﺧﻴ ﺮًا‬sql :"، e) 28) ‫)" ﻫﻨﺎك ﻣﺸﻜﻠ ﺔ ﻓ ﻲ‬e: 25) if con: 26)
32)con.rollback
con.close () ():‫ﻳﺨﺪع‬
27) print ‫ﺜﻞ‬‫ﻣ‬
‫إذا ﻛﺎن‬30)
‫ﺒﻴﺎﻧﺎ ت اﻟﻤﻮﺟﻮدة ﻓ ﻲ اﻟﻤﻮﻇﻔﻴﻦ‬

‫ﺑﺮﻧﺎﻣﺠًﺎ ﻟﻨ ﺴﺦ اﻟ‬‫ﺘﺐ‬
‫س( اﻛ‬
Oracle Database ‫ﻓ ﻲ‬MySQL ‫ﺑﻴﺎﻧﺎ ت‬‫ﺟﺪول ﻗﺎﻋﺪة‬
'localhost'، database = 'durgadb'، user = 'root'، p :‫ﺣﺎول‬cx_Oracle 3) ‫ﺘﻴﺮاد‬

‫اﺳ‬mysql.connector 2) ‫ﺘﻴﺮاد‬
‫اﺳ‬1)
4) con = mysql.connector.connect (host =
= 'root') 5) cursor = con.cursor () 6) cursor.execute

cursor.fetchall () 8) list = [] 9) ("‫)"ﺣﺪد *ﻣﻦ اﻟﻤﻮﻇﻔﻴﻦ‬assword
row [3]) 11) list.append
‫ﺜﻨﺎء‬
‫ﺘ‬ (t)
‫ﺑﺎﺳ‬
10)12)
t =: (row
‫ﺒﻴﺎﻧﺎ ت‬‫ ﻲ اﻟ‬row
[0]، ‫ﻟﻠﺼﻒ ﻓ‬
[1]،7)row
data =
[2]،
e: ‫ﻛـ‬mysql.connector.DatabaseError
164
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫إذا‬18) cursor.close () 19) :‫إذا ﻛﺎن اﻟﻤﺆﺷﺮ‬17) :‫أﺧﻴ ﺮًا‬MySql :"، e) 16) ‫)" ﻫﻨﺎك ﻣﺸﻜﻠ ﺔ ﻓ ﻲ‬13) if con: 14) con.rollback () 15) print
27)
= cx_Oracle.connect
con.commit () 28) ('scott
print ("/ Records
tiger @ localhost')
Copy from24)
MySQL
cursor
Database
= con.cursor
to Oracle
() 25)Database
sql = :‫ﺣﺎول‬
‫اﻟﻤﻮﻇﻔﻴﻦ‬
20 ) con.close
‫)( ﻓ ﻲ ﻗﻴﻢ‬
‫"أدﺧﻞ‬
21) 23)
22) con
:‫ﻛﺎن‬
") ‫ﺑﻨﺠﺎح‬
(: eno، : ename،: esal،: eaddr) " 26) cursor.executemany (sql، list)
print :‫إذا ﻛﺎن‬e: 30) ‫ﺜﻞ‬

‫ﻣ‬cx_Oracle.DatabaseError ‫ﺜﻨﺎء‬
29)
34) :‫أﺧﻴ ﺮًا‬33) (‫ ﻫـ‬sql" ، ‫)" ﻫﻨﺎك ﻣﺸﻜﻠ ﺔ ﻓ ﻲ‬31) con.rollback () 32)
() ‫ﺑﺈﻏﻼق‬‫ﻗﻢ‬37) :‫إذا ﻛﺎنﻳﺨﺪع‬35) cursor.close () 36) :‫إذا ﻛﺎن اﻟﻤﺆﺷﺮ‬
https://dev.mysql.com/downloads/connector/python/2.1.html
(eno int (5) basic key، ename varchar (10)، esal double (10،2) ‫إﻧﺸﺎء ﻣﻮﻇﻔ ﻲ اﻟﺠﺪول‬1)
‫" ﻫﻴﺪرو"( ؛‬1000 ، ، "‫("دورﺟﺎ‬100 ، ‫ )أدﺧﻞ ﻓ ﻲ ﻗﻴﻢ اﻟﻤﻮﻇﻔﻴﻦ‬، eaddr varchar (10)) ‫ ؛‬2)
‫ﺗﻀﺎف إﱃ ﻗﻴﻢ اﻟﻤﻮﻇﻔﻴﻦ‬
4) ‫ﺒﺎي"( ؛‬
‫"ﻣﻮﻣ‬2000 ، ، "‫("راﻓ ﻲ‬200 ، ‫أدﺧﻞ ﻓ ﻲ ﻗﻴﻢ اﻟﻤﻮﻇﻔﻴﻦ‬3)
(300 ، "Shiva" ، 3000 ، "Hyd") ‫؛‬
165
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﻋﺎدي‬
‫ﺒﻴﺮا ت‬
‫ﺘﻌ‬‫اﻟ‬
‫&‬
‫ﺘﺮﻧ ﺖ‬
‫ﺒﻜ ﺔ اﻹﻧ‬
‫ﺗﺠﺮﻳﻒ ﻋﲆ ﺷ‬
‫‪166‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺜﻴﻞ ﻣﺠﻤﻮﻋ ﺔ ﻣﻦ اﻟ ﺴﻼﺳﻞ اﻟﻨﺼﻴ ﺔ وﻓ ًﻘﺎ ﻟﺸﻜﻞ ‪ /‬ﻧﻤﻂ ﻣﻌﻴﻦ‬

‫إذا أردﻧﺎﺗﻤ‬
‫ﺒﻴﺮا ت اﻟﻌﺎدﻳ ﺔ‪.‬‬
‫ﺘﻌ‬‫ﺘﻘﻞ إﱃ اﻟ‬
‫ﺛﻢ ﻋﻠﻴﻨﺎ أن ﻧﻨ‬
‫ﺘﺮاﻛﻤ ﺔ إﱃﺗﻨ ﺴﻴﻖ ‪ /‬ﻧﻤﻂ ﻣﻌﻴﻦ‪.‬‬

‫ﺜﻴﻞ ﻣﺠﻤﻮﻋ ﺔ ﻣﻦ اﻟ ﺴﻼﺳﻞ اﻟﻨﺼﻴ ﺔ اﻟﻤ‬
‫ﺘﻤ‬‫أي ‪ Regualr Expressions‬ﻫ ﻲ آﻟﻴ ﺔﺗﻌﺮﻳﻔﻴ ﺔ ﻟ‬
‫ﺗﻒ اﻟﻤﺤﻤﻮﻟ ﺔ‬
‫ﺜﻴﻞ ﺟﻤﻴﻊ أرﻗﺎم اﻟﻬﻮا‬
‫ﺘﻤ‬‫ﺒﻴﺮ ﻧﻤﻄ ﻲ ﻟ‬
‫ﺑ ﺔﺗﻌ‬
‫ﺘﺎ‬
‫ﺜﺎل ‪1:‬ﻳﻤﻜﻨﻨﺎ ﻛ‬
‫ﻣ‬
‫ﺒﺮﻳﺪ‪.‬‬
‫ﺜﻴﻞ ﺟﻤﻴﻊ ﻣﻌﺮﻓﺎ ت اﻟ‬
‫ﺘﻤ‬‫ﺒﻴﺮ ﻋﺎدي ﻟ‬
‫ﺑ ﺔﺗﻌ‬
‫ﺘﺎ‬
‫ﺜﺎل ‪2:‬ﻳﻤﻜﻨﻨﺎ ﻛ‬
‫ﻣ‬
‫ﺒﻴﺮا ت اﻟﻌﺎدﻳ ﺔ ﻫ ﻲ‬
‫ﺘﻌ‬‫ﺋﻴ ﺴﻴ ﺔ ﻟﻠ‬
‫ﺒﻴﻖ اﻟﻤﻬﻤ ﺔ اﻟﺮ‬
‫ﺘﺤﻘﻖ ﻣﻦ اﻟﺼﺤ ﺔ‬
‫ﺘﺤﻘﻖ ‪ /‬ﻣﻨﻄﻖ اﻟ‬
‫ﺘﻄﻮﻳﺮ أﻃﺮ اﻟ‬
‫)‪1‬ﻟ‬
‫ﺑﻘ ﺔ اﻷﻧﻤﺎط ‪(ctrl-f‬ﻓ ﻲ ‪windows ، grep‬ﻓ ﻲ ‪UNIX ،‬إﻟﺦ(‬
‫ﺒﻴﻘﺎ ت ﻣﻄﺎ‬
‫ﺘﻄﻮﻳﺮﺗﻄ‬
‫)‪2‬ﻟ‬
‫ﺘﺮﺟﻤﻴﻦ اﻟﻔﻮرﻳﻴﻦ وﻣﺎ إﱃ ذﻟﻚ‬
‫ﺘﺮﺟﻤﻴﻦ واﻟﻤ‬
‫ﺜﻞ اﻟﻤ‬
‫ﺘﺮﺟﻤﻴﻦ ﻣ‬
‫ﺘﻄﻮﻳﺮ اﻟﻤ‬
‫)‪3‬ﻟ‬
‫ﺗﻄﻮﻳﺮ اﻟﺪواﺋﺮ اﻟﺮﻗﻤﻴ ﺔ‬
‫)‪4‬‬
‫ﺜﻞ ‪TCP / IP‬و ‪UDP‬وﻣﺎ إﱃ ذﻟﻚ‪.‬‬
‫ﺗﺼﺎل ﻣ‬
‫ﺗﻮﻛﻮﻻ ت اﻻ‬
‫ﺑﺮو‬‫ﺘﻄﻮﻳﺮ‬
‫)‪5‬ﻟ‬
‫ﺘﺨﺪام وﺣﺪة ‪python: re‬‬

‫ﺑﺎﺳ‬‫ﺒﻴﺮ اﻟﻌﺎدي‬
‫ﺘﻌ‬‫ﺘﻨﺪة إﱃ اﻟ‬
‫ﺒﻴﻘﺎ ت اﻟﻤ ﺴ‬
‫ﺘﻄ‬‫ﻳﻤﻜﻨﻨﺎﺗﻄﻮﻳﺮ اﻟ‬
‫ﺑﺎﻟﻐ ﺔ‬‫ﺑ ﺴﻬﻮﻟ ﺔ‬‫ﺒﻴﺮا ت اﻟﻌﺎدﻳ ﺔ‬

‫ﺘﻌ‬‫ﺘﺨﺪام اﻟ‬
‫ﺘﻮي ﻫﺬه اﻟﻮﺣﺪة ﻋﲆ اﻟﻌﺪﻳﺪ ﻣﻦ اﻟﻮﻇﺎﺋﻒ اﻟﻤﺪﻣﺠ ﺔ ﻻﺳ‬
‫ﺗﺤ‬
‫ﺗﻨﺎ‪.‬‬
‫ﺒﻴﻘﺎ‬
‫ﺗﻄ‬
‫ﺗﺠﻤﻴﻊ )(‬
‫)‪1‬‬
‫ﺘﺮﺟﻤ ﺔ ﻧﻤﻂ إﱃ ‪RegexObject.‬‬
‫ﺘﻮي وﺣﺪة اﻹرﺟﺎع ﻋﲆ داﻟ ﺔ )( ‪compile‬ﻟ‬
‫ﺗﺤ‬
‫ﻧﻤﻂ )"‪= re.compile ("ab‬‬
‫ﺘﺸﻒ ‪():‬‬
‫)‪2‬ﻣﻜ‬
‫ﺒﺎراة‬
‫ﺑﻘ ﺔ ﻟﻜﻞ ﻣ‬
‫ﺘﺞ ﻋﻨﻪ ﻛﺎﺋﻦ ﻣﻄﺎ‬
‫إرﺟﺎع ﻛﺎﺋﻦﺗﻜﺮاريﻳﻨ‬
‫)"‪matcher = pattern.finditer ("abaababa‬‬
‫ﺘﺪﻋﺎء اﻟﻄﺮق اﻟ‬
‫ﻓ ﻲ ﻛﺎﺋﻦ ‪Match ،‬ﻳﻤﻜﻨﻨﺎ اﺳ‬
‫ﺒﺎراة‬
‫ﺑﺪاﻳ ﺔ اﻟﻤ‬‫)( ‪1) start‬إرﺟﺎع ﻓﻬﺮس‬
‫ﺒﺎراة‬
‫)( ‪2) end‬إرﺟﺎع ﻧﻬﺎﻳ ﺔ ‪+ 1‬ﻓﻬﺮس اﻟﻤ‬
‫ﺑﻘ ﺔ‬
‫ﺘﻄﺎ‬
‫)( ‪3) group‬إرﺟﺎع اﻟ ﺴﻠ ﺴﻠ ﺔ اﻟﻤ‬
‫)‪= 0 2) pattern = re.compile ("ab") 3) matcher = pattern.finditer ("abaababa") 4‬‬

‫ﺑﻖ ‪match.end () ، "..." ، match.group ()) 7) print (" :‬‬
‫ﺑﻘ ﺔ ﻓ ﻲ اﻟﻤﻄﺎ‬
‫‪1) import re count‬ﻟﻠﻤﻄﺎ‬
‫ﺘﻜﺮارا ت‪" ، count) :‬‬
‫‪5) count + = 1 6) print (match.start () ، "..." ،‬ﻋﺪد اﻟ‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫‪0 ... 2 ...‬أ ب‬
‫‪3 ... 5 ...‬أ ب‬
‫‪...7‬أ‪ ...‬ب‪5‬‬
‫‪167‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﻜﺮارا ت‪3 :‬‬

‫ﻋﺪد اﻟ‬
‫ﺒﺎﺷﺮة ﻛﻮﺳﻴﻄ ﺔ إﱃ داﻟ ﺔ ‪finditer ().‬‬

‫ﻣﻼﺣﻈ ﺔ‪:‬ﻳﻤﻜﻨﻨﺎﺗﻤﺮﻳﺮ اﻟﻨﻤﻂ ﻣ‬
‫ﺑﻘ ﺔ ﻓ ﻲ‬
‫ﺘﻴﺮاد )‪re 2) count = 0 3) matcher = re.finditer ("ab"، "abaababa") 4‬ﻟﻠﻤﻄﺎ‬
‫)‪1‬اﺳ‬
‫ﺑﻖ ‪print (match.start ()، ".. . "، match.end ()،" ... "، match.group ()) 7) print (" :‬‬
‫اﻟﻤﻄﺎ‬
‫ﺘﻜﺮارا ت‪"، count) :‬‬
‫)‪5) count + = 1 6‬ﻋﺪد اﻟ‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫‪0 ... 2 ...‬أ ب‬
‫‪3 ... 5 ...‬أ ب‬
‫‪...‬أ‪...‬ب ‪5‬ﻋﺪد ﻣﺮا ت اﻟﻈﻬﻮر‪3 :‬‬

‫‪7‬‬
‫ﻓﺌﺎ ت اﻷﺣﺮف‪:‬‬
‫ﺒﺤ ﺚ ﻓ ﻲ ﻣﺠﻤﻮﻋ ﺔ ﻣﻦ اﻟﺸﺨﺼﻴﺎ ت‬
‫ﺘﺨﺪام ﻓﺌﺎ ت اﻟﺸﺨﺼﻴﺎ ت ﻟﻠ‬
‫]‪1) [abc‬إﻣﺎ أ أو ب أو ج‬
‫ﺜﻨﺎء ‪a‬و ‪b‬و ‪c‬‬
‫]‪2) [^ abc‬‬
‫ﺑﺠﺪي ﺻﻐﻴﺮ‬
‫]‪3) [az‬أي رﻣﺰ أ‬
‫ﺒﻴﺮ‬
‫ﺑﺠﺪي ﻛ‬
‫أي رﻣﺰ أ‬ ‫)‪]4‬ﻣﻦ اﻷﻟﻒ إﱃ اﻟﻴﺎء[‬
‫ﺑﺠﺪي‬
‫]‪5) [a-zA-Z‬أي رﻣﺰ أ‬
‫]‪6) [0-9‬أي رﻗﻢ ﻣﻦ ‪0‬إﱃ ‪9‬‬
‫ﺑﺠﺪي رﻗﻤ ﻲ‬
‫]‪7) [a-zA-Z0-9‬أي ﺣﺮف أ‬
‫ﺑﺠﺪﻳ ﺔ اﻟﺮﻗﻤﻴ ﺔ )اﻷﺣﺮف اﻟﺨﺎﺻ ﺔ(‬
‫ﺜﻨﺎء اﻷﺣﺮف اﻷ‬
‫]‪8) [^ a-zA-Z0-9‬‬
‫ﺘﻴﺮاد )‪2) matcher = re.finditer ("x"، "a7b @ k9z") 3‬‬

‫)‪1‬اﺳ‬
‫ﺒﺎﻋ ﺔ ‪(match.start () ، "......" ،‬‬
‫ﺑﻖ ‪4) :‬ﻃ‬
‫‪re‬ﻟﻠﻤﻄﺎ‬
‫ﺑﻖ‪ .‬ﻣﺠﻤﻮﻋ ﺔ)((‬
‫ﺗﻄﺎ‬
‫]‪x = [abc‬‬ ‫]‪x = [^ abc‬‬ ‫س ]‪= [az‬‬ ‫‪= =[^[a-‬‬

‫‪a-zA-‬‬
‫]‪zA-=Z0-9‬‬
‫س ]‪[0-9‬‬
‫]‪Z0-9‬‬
‫‪0 ......‬أ‬ ‫‪...... 7‬‬ ‫‪1‬‬ ‫‪0 ......‬أ‬ ‫‪...... 1‬‬ ‫‪7‬‬
‫‪0 ......‬أ‬
‫‪3 ......‬‬ ‫@‬
‫‪ ......2‬ب‬ ‫@ ‪3 ......‬‬ ‫‪ 2 ......‬ب‬ ‫‪5 ...... 9‬‬ ‫‪1‬‬
‫‪...... 7‬‬
‫‪4 ......‬‬ ‫ك‬ ‫‪4 ......‬‬ ‫ك‬ ‫‪ ......2‬ب‬
‫‪5 ...... 9‬‬ ‫‪ 6 ......‬ض‬ ‫‪4‬‬
‫ك ‪......‬‬
‫‪ 6 ......‬ض‬ ‫‪5 ...... 9‬‬
‫‪ 6 ......‬ض‬
‫‪168‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺒ ًﻘﺎ‪:‬‬
‫ﻓﺌﺎ ت اﻷﺣﺮف اﻟﻤﺤﺪدة ﻣ ﺴ‬
‫‪1) \ s‬ﺣﺮف اﻟﻤ ﺴﺎﻓ ﺔ‬
‫ﺜﻨﺎء ﺣﺮف اﻟﻤ ﺴﺎﻓ ﺔ‬
‫ﺘ‬‫ﺑﺎﺳ‬‫‪2) \ S‬أي ﺣﺮف‬
‫أي رﻗﻢ ﻣﻦ ‪0‬إﱃ ‪9‬‬ ‫\ )‪3‬د‬
‫‪4) \ D‬أي ﺣﺮف ﻣﺎ ﻋﺪا اﻟﺮﻗﻢ‬
‫‪5) \ w‬أي ﺣﺮف ﻛﻠﻤ ﺔ ]‪[a-zA-Z0-9‬‬
‫‪6) \ W‬أي ﺣﺮف ﻣﺎ ﻋﺪا ﺣﺮف اﻟﻜﻠﻤ ﺔ )أﺣﺮف ﺧﺎﺻ ﺔ(‬
‫ﺑﻤﺎ ﻓ ﻲ ذﻟﻚ اﻷﺣﺮف اﻟﺨﺎﺻ ﺔ‬‫‪7).‬أي ﺷﺨﺼﻴ ﺔ‬
‫ﺑﻘ ﺔ‬
‫ﺘﻴﺮاد )‪re 2) matcher = re.finditer ("x"، "a7b k @ 9z") 3‬ﻟﻠﻤﻄﺎ‬
‫)‪1‬اﺳ‬
‫ﺑﻖ ‪. hctam 4) print (match.start ()، "......"، :‬ﻣﺠﻤﻮﻋ ﺔ)((‬
‫ﻓ ﻲ اﻟﻤﻄﺎ‬
‫س \ = ق‪:‬‬ ‫س ‪= \ S:‬‬ ‫س \ =د‪:‬‬ ‫س \ =د‪:‬‬ ‫‪\ W:‬ث‪=:‬‬

‫س \=‬
‫س‬ ‫س =‪.‬‬
‫‪3 ......‬‬ ‫‪0 ......‬أ‬ ‫‪1 ...... 7‬‬ ‫‪0 ......‬أ‬ ‫‪3‬‬
‫‪0 ......‬أ‬
‫‪......‬‬ ‫‪0 ......‬أ‬
‫‪1‬‬
‫‪...... 7‬‬ ‫‪6 ...... 9‬‬ ‫‪ 2 ......‬ب‬ ‫‪1‬‬
‫‪...... 7‬‬ ‫@ ‪5 ......‬‬ ‫‪1 ...... 7‬‬
‫‪ 2 ......‬ب‬ ‫‪3 ......‬‬ ‫‪ ......2‬ب‬ ‫‪ 2 ......‬ب‬
‫‪4 ......‬‬ ‫ك‬ ‫‪4‬‬
‫ك ‪......‬‬ ‫‪4‬‬
‫ك ‪......‬‬ ‫‪3 ......‬‬
‫@ ‪5 ......‬‬ ‫@ ‪5 ......‬‬ ‫‪6 ...... 9‬‬ ‫‪4‬‬
‫ك ‪......‬‬
‫‪6 ...... 9‬‬ ‫‪...... 7‬‬
‫ض‬ ‫‪...... 7‬‬
‫ض‬ ‫@ ‪5 ......‬‬
‫‪7 ......‬‬ ‫ض‬ ‫‪6 ...... 9‬‬
‫‪7 ......‬‬ ‫ض‬
‫ﺗﻴﺎ ت‪:‬‬
‫اﻟﻘﻨﺎ‬
‫ﺘﻬﺎ‪.‬‬
‫ﺑﻘ‬‫ﺘﻜﺮارا ت اﻟﻤﺮاد ﻣﻄﺎ‬
‫ﺘﺤﺪﻳﺪ ﻋﺪد اﻟ‬
‫ﺘﺨﺪام اﻟﻤﺤﺪدا ت اﻟﻜﻤﻴ ﺔ ﻟ‬
‫ﺒﻂ "أ"‬
‫ﺑﺎﻟﻀ‬‫واﺣﺪ‬ ‫)‪1‬أ‬
‫)‪2‬أ ‪+‬ﻋﲆ اﻷﻗﻞ واﺣﺪ "أ"‬
‫ﺑﻤﺎ ﻓ ﻲ ذﻟﻚ اﻟﺮﻗﻢ ﺻﻔﺮ‬
‫*أي رﻗﻢ ﻣﻦ ‪a‬‬ ‫)‪3‬أ‬
‫)‪4‬أ؟ واﺣﺪ ﻋﲆ اﻷﻗﻞ "أ" أي إﻣﺎ رﻗﻢ ﺻﻔﺮي أو رﻗﻢ واﺣﺪ‬
‫ﺒﻂ م ﻋﺪد ﻣﻦ أ‬
‫)‪5‬أ }م{ ﺑﺎﻟﻀ‬
‫}‪6) a {m، n‬اﻟﺤﺪ اﻷدﻧﻰ ﻟﻌﺪد ‪m‬ﻣﻦ ‪a's‬واﻟﺤﺪ اﻷﻗﺼﻰ ﻟﻌﺪد ‪n‬ﻟـ ‪a's.‬‬
‫ﺘﻴﺮاد )‪re 2) matcher = re.finditer ("x"، "abaabaaab") 3‬‬

‫)‪1‬اﺳ‬
‫ﺑﻖ ‪print (match.start ()، "......"، match.group ( )) :‬‬
‫ﻟﻠﻤﻄﺎ‬
‫)‪ 4‬س =أ ؟‪:‬‬
‫‪0 ......‬أ‬
‫س =أ‪:‬‬ ‫س =أ ‪+:‬‬ ‫س =أ ‪*:‬‬ ‫س =أ=أ ‪{3}:‬‬
‫‪{2،4}:‬‬ ‫س‬
‫‪...... 1‬‬
‫‪0 ......‬أ‬ ‫‪0 ......‬أ‬ ‫‪0 ......‬أ‬ ‫‪5 ......‬‬
‫‪2 aaa‬أأ‬
‫‪......‬‬
‫‪2 ......‬أ‬
‫‪2 ......‬أ‬ ‫‪2 ......‬أأ‬ ‫‪1 ......‬‬ ‫‪5 ...... aaa‬‬
‫‪3 ......‬أ‬
‫‪3 ......‬أ‬ ‫‪5 ...... aaa‬‬ ‫‪2 ......‬أأ‬
‫‪...... 4‬‬
‫‪5 ......‬أ‬ ‫‪...... 4‬‬
‫‪5 ......‬أ‬
‫‪6 ......‬أ‬ ‫‪5 ...... aaa‬‬
‫‪6 ......‬أ‬
‫‪7 ......‬أ‬ ‫‪8 ......‬‬
‫‪7 ......‬أ‬
‫‪9 ......‬‬
‫‪8 ......‬‬
‫‪9 ......‬‬
‫‪169‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺑـ ‪x‬أم ﻻ‪.‬‬‫ﺒﺪأ‬

‫ﺘﺤﻘﻖ ﻣﻤﺎ إذا ﻛﺎﻧ ﺖ اﻟ ﺴﻠ ﺴﻠ ﺔ اﻟﻬﺪفﺗ‬
‫‪1) ^ x‬ﺳﻴ‬
‫ﺑـ ‪x‬أم ﻻ‪.‬‬‫ﺘﻬ ﻲ‬
‫ﺘﺤﻘﻖ ﻣﻤﺎ إذا ﻛﺎﻧ ﺖ اﻟ ﺴﻠ ﺴﻠ ﺔ اﻟﻬﺪفﺗﻨ‬
‫‪2) x $‬ﺳﻴ‬
‫وﻇﺎﺋﻒ ﻣﻬﻤ ﺔ ﻣﻦ ‪Remodule:‬‬

‫ﺑﻖ )(‬
‫ﺗﻄﺎ‬
‫)‪1‬‬
‫ﺒﺎراة ﻛﺎﻣﻠ ﺔ )(‬
‫)‪2‬ﻣ‬
‫ﺑﺤ ﺚ )(‬
‫)‪3‬‬
‫)( ‪4) findall‬‬
‫ﺘﺸﻒ )(‬
‫)‪5‬ﻣﻜ‬
‫)‪6‬ﻓﺮﻋ ﻲ )(‬
‫)( ‪7) subn‬‬
‫)‪8‬اﻧﻘ ﺴﺎم )(‬
‫ﺗﺠﻤﻴﻊ )(‬
‫)‪9‬‬
‫ﺑﻖ ‪():‬‬
‫ﺗﻄﺎ‬
‫)‪1‬‬
‫ﺘﻬﺪﻓ ﺔ‪.‬‬
‫ﺑﺪاﻳ ﺔ اﻟ ﺴﻠ ﺴﻠ ﺔ اﻟﻤ ﺴ‬‫ﺘﺤﻘﻖ ﻣﻦ اﻟﻨﻤﻂ اﻟﻤﺤﺪد ﻓ ﻲ‬
‫ﺑﻘ ﺔ ﻟﻠ‬
‫ﺘﺨﺪام داﻟ ﺔ اﻟﻤﻄﺎ‬
‫ﺘﺎﺣ ﺔ ‪ ،‬ﻓ ﺴﻨﺤﺼﻞ ﻋﲆ ﻛﺎﺋﻦ ‪Match ،‬وإﻻ ﻓﻠﻦ ﻧﺤﺼﻞ ﻋﲆ ‪None.‬‬
‫ﺑﻘ ﺔ ﻣ‬
‫•إذا ﻛﺎﻧ ﺖ اﻟﻤﻄﺎ‬
‫ﺘﺤﻘﻖ‪"abcabdefg") 4) if m! = None: 5) print ("Match :‬‬

‫ﻧﻤﻄﺎ ﻟﻠ‬
‫ً‬ ‫‪")1) import re 2) s = input‬أدﺧﻞ‬
‫ﺑﺪاﻳ ﺔ اﻟ ﺴﻠ ﺴﻠ ﺔ ‪End Index: "، m.end ()) 7) else: 8) print (" Match‬‬‫ﺘﺎح ﻓ ﻲ‬
‫‪") 3) m = re.match (s،‬ﻣ‬
‫ﺑﺪاﻳ ﺔ اﻟ ﺴﻠ ﺴﻠ ﺔ )"‬‫ﺘﻮﻓﺮ ﻓ ﻲ‬
‫‪") 6) print (" Start Index: "، m.start ()، " and‬ﻏﻴﺮ ﻣ‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫ﺘﺤﻘﻖ ﻣﻨﻪ‪abc :‬‬
‫أدﺧﻞ اﻟﻨﻤﻂ اﻟﻤﺮاد اﻟ‬
‫ﺑﺪاﻳ ﺔ اﻟ ﺴﻠ ﺴﻠ ﺔ‬‫ﺘﺎح ﻓ ﻲ‬
‫ﺑﻖ ﻣ‬
‫ﺘﻄﺎ‬
‫اﻟ‬
‫ﺒﺪاﻳ ﺔ‪0 :‬وﻣﺆﺷﺮ اﻟﻨﻬﺎﻳ ﺔ‪3 :‬‬
‫ﻣﺆﺷﺮ اﻟ‬

‫ﺘﺤﻘﻖ‪bde :‬‬
‫أدﺧﻞ اﻟﻨﻤﻂ ﻟﻠ‬
‫ﺑﺪاﻳ ﺔ اﻟ ﺴﻠ ﺴﻠ ﺔ‬‫ﺘﺎح ﻓ ﻲ‬
‫ﺑﻖ ﻏﻴﺮ ﻣ‬
‫ﺘﻄﺎ‬
‫اﻟ‬
‫ﺒﺎراة ﻛﺎﻣﻠ ﺔ ‪():‬‬

‫)‪2‬ﻣ‬
‫ﺘﻬﺪﻓ ﺔ‪ .‬أي ﻛﺎﻣﻠ ﺔ‬
‫ﺑﻘ ﺔ ﻧﻤﻂ ﻣﻊ ﻛﻞ اﻟ ﺴﻠ ﺴﻠ ﺔ اﻟﻤ ﺴ‬
‫ﺘﺨﺪام وﻇﻴﻔ ﺔ )( ‪fullmatch‬ﻟﻤﻄﺎ‬
‫ﺑﻘ ﺔ اﻟ ﺴﻠ ﺴﻠ ﺔ وﻓ ًﻘﺎ ﻟﻠﻨﻤﻂ اﻟﻤﺤﺪد‪.‬‬
‫ﻳﺠ ﺐ ﻣﻄﺎ‬
‫ﺘﻢ ذﻟﻚ‬
‫ُﺮﺟﻊ ﻫﺬه اﻟﻮﻇﻴﻔ ﺔ ﻛﺎﺋﻦ ‪Match‬وإﻻ ﻓ ﺴﻴ‬
‫ﺘ‬
‫ﺑﻘ ﺖ اﻟ ﺴﻠ ﺴﻠ ﺔ اﻟﻜﺎﻣﻠ ﺔ ‪ ،‬ﻓ ﺴ‬
‫•إذاﺗﻄﺎ‬
‫ﺑﻼ‪.‬‬‫إرﺟﺎع‬
‫‪170‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﺤﻘﻖ‪") :‬‬
‫‪")1) import re 2) s = input‬أدﺧﻞ اﻟﻨﻤﻂ ﻟﻠ‬
‫‪("Full String matching") 6) else: 7) print ("Full String‬‬
‫‪= re.fullmatch (s، "ababab") 4) if m! = None: 5) print‬‬

‫ﺑﻘ ﺔ"(‬
‫ﺘﻄﺎ‬
‫‪3) m‬ﻏﻴﺮ ﻣ‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫ﺘﺤﻘﻖ‪ :‬أ ب‬
‫أدﺧﻞ ﻧﻤﻂ ﻟﻠ‬
‫ﺑﻘ ﺔ‬
‫ﺘﻄﺎ‬
‫اﻟ ﺴﻠ ﺴﻠ ﺔ اﻟﻜﺎﻣﻠ ﺔ ﻏﻴﺮ ﻣ‬

‫ﺘﺤﻘﻖ ﻣﻨﻪ‪ababab :‬‬
‫ﺑﻘ ﺔ‬
‫ﺘﻄﺎ‬
‫ﺳﻠ ﺴﻠ ﺔ ﻛﺎﻣﻠ ﺔ ﻣ‬
‫ﺒﺤ ﺚ ‪():‬‬
‫)‪3‬اﻟ‬
‫ﺘﻬﺪﻓ ﺔ‪.‬‬
‫ﺒﺤ ﺚ ﻋﻦ اﻟﻨﻤﻂ اﻟﻤﺤﺪد ﻓ ﻲ اﻟ ﺴﻠ ﺴﻠ ﺔ اﻟﻤ ﺴ‬
‫ﺘﺨﺪام وﻇﻴﻔ ﺔ )( ‪search‬ﻟﻠ‬
‫ﺜﻞ أوﻻ ً‬
‫ﺑﺈرﺟﺎع ﻛﺎﺋﻦ ‪Match‬اﻟﺬيﻳﻤ‬‫ﺣﺎ ‪ ،‬ﻓﺈﻧﻪﻳﻘﻮم‬
‫ﺘﺎ ً‬
‫ﺑﻖ ﻣ‬
‫ﺘﻄﺎ‬
‫•إذا ﻛﺎن اﻟ‬
‫ﺒﺎراة‪.‬‬
‫ﺣﺪو ث اﻟﻤ‬
‫ﺑﻼ‬‫ﺘﺎﺣ ﺔ ‪ ،‬ﻓﺈﻧﻬﺎﺗﺮﺟﻊ‬
‫ﺒﺎراة ﻣ‬
‫•إذا ﻟﻢﺗﻜﻦ اﻟﻤ‬
‫ﺘﺤﻘﻖ‪4) :‬‬
‫ﻧﻤﻄﺎ ﻟﻠ‬
‫ً‬ ‫ﺘﻴﺮاد ‪")re 2) s = input‬أدﺧﻞ‬
‫)‪1‬اﺳ‬
‫ﺑﻼ‪5) :‬‬
‫)"‪") 3) m = re.search (s، "abaaaba‬إذا ﻛﺎن = !‪m‬‬
‫ﺘﺎﺣ ﺔ"( )‪6‬‬
‫ﺑﻘ ﺔ ﻣ‬
‫ﺒﺎﻋ ﺔ )"اﻟﻤﻄﺎ‬
‫ﻃ‬
‫ﺒﺪاﻳ ﺔ‪"m.start () ، ، ":‬وﻣﺆﺷﺮ اﻟﻨﻬﺎﻳ ﺔ‪m. ، ":‬‬

‫ﺑﻘ ﺔ ﻣﻊ ﻓﻬﺮس اﻟ‬
‫‪")print‬أول ﻇﻬﻮر ﻟﻠﻤﻄﺎ‬
‫)"‪end ()) 7) else: 8) print ("Match is not available‬‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫ﺘﺤﻘﻖ ﻣﻨﻪ‪aaa :‬‬
‫ﺘﺎﺣ ﺔ‬
‫ﺒﺎراة ﻣ‬
‫اﻟﻤ‬
‫ﺒﺪاﻳ ﺔ‪2 :‬وﻣﺆﺷﺮ اﻟﻨﻬﺎﻳ ﺔ‪5 :‬‬
‫ﺑﻘ ﺔ ﻣﻊ ﻣﺆﺷﺮ اﻟ‬
‫أول ﻇﻬﻮر ﻟﻠﻤﻄﺎ‬

‫ﺘﺤﻘﻖ ﻣﻨﻪ‪bbb :‬‬
‫ﺘﻮﻓﺮة‬
‫ﺑﻘ ﺔ ﻏﻴﺮ ﻣ‬
‫اﻟﻤﻄﺎ‬
‫‪171‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫‪4) findall ():‬‬

‫ﺜﻮر ﻋﲆ ﺟﻤﻴﻊﺗﻜﺮارا ت اﻟﻤ‬
‫•ﻟﻠﻌ‬
‫ﺘﻜﺮارا ت‪.‬‬
‫ﺘﻮي ﻋﲆ ﺟﻤﻴﻊ اﻟ‬
‫ﺑﺈرﺟﺎع ﻛﺎﺋﻦ ﻗﺎﺋﻤ ﺔﻳﺤ‬‫ﺗﻘﻮم ﻫﺬه اﻟﻮﻇﻴﻔ ﺔ‬
‫•‬
‫ﺘﻴﺮاد )‪2) l = re.findall ("[0-9]"، "a7b9c5kz") 3‬‬

‫)‪1‬اﺳ‬
‫ﺒﺎﻋ ﺔ )‪(l‬‬
‫‪re‬ﻃ‬
‫اﻹﺧﺮاج‪['7'، '9'، '5'] :‬‬
‫ﺘﺸﻒ ‪():‬‬
‫)‪5‬ﻣﻜ‬
‫ﺑﻖ ﻟﻜﻞ ﻣ‬
‫ﺘﺞ ﻋﻨﻪ ﻛﺎﺋﻦﺗﻄﺎ‬
‫إرﺟﺎع اﻟﻤﻜﺮر اﻟﺬيﻳﻨ‬
‫ﺘﺪﻋﺎء وﻇﺎﺋﻒ )( ‪start‬و )( ‪end‬و ‪group ().‬‬

‫ﺑﻖﻳﻤﻜﻨﻨﺎ اﺳ‬
‫•ﻓ ﻲ ﻛﻞ ﻛﺎﺋﻦﺗﻄﺎ‬
‫ﺘﻴﺮاد )‪re 2) itr = re.finditer ("[az]"، "a7b9c5k8z") 3‬‬

‫)‪1‬اﺳ‬
‫ﻟـ )‪m in itr: 4‬‬
‫ﺒﺎﻋ ﺔ ))( ‪(m.start () ، "..." ، m.end () ، "..." ، m.group‬‬

‫ﻃ‬
‫اﻹﺧﺮاج‪D: \ python_classes> py test.py :‬‬

‫‪0 ... 1 ...‬أ‬
‫‪ 2 ... 3 ...‬ب‬
‫‪4 ... 5 ...‬ج‬
‫ك ‪6 ... 7 ...‬‬
‫‪ 8 ... 9 ...‬ض‬
‫)‪6‬ﻓﺮﻋ ﻲ ‪():‬‬
‫ﺒﺪال‪.‬‬
‫ﺘ‬‫ﺒﺪال أو اﻻﺳ‬
‫ﺘ‬‫ﺗﻌﻨ ﻲ اﻻﺳ‬
‫•‬
‫ﺒﺪال ‪targetstring) ،‬‬

‫ﺘ‬‫‪• re.sub (regex ،‬اﺳ‬
‫ﺒﺪال اﻟﻤﻘﺪم‪.‬‬
‫ﺘ‬‫ﺑﻖ ﻣﻊ اﻻﺳ‬
‫ﺘﻄﺎ‬
‫ﺒﺪال ﻛﻞ ﻧﻤﻂ ﻣ‬
‫ﺘ‬‫ﺘﻢ اﺳ‬
‫ﺘﻬﺪﻓ ﺔ ‪،‬ﺳﻴ‬
‫•ﻓ ﻲ اﻟ ﺴﻠ ﺴﻠ ﺔ اﻟﻤ ﺴ‬
‫ﺒﺎﻋ ﺔ )ﻧ ﺴﺦ(‬
‫ﺘﻴﺮاد )‪re 2) s = re.sub ("[az]"، "#"، "a7b9c5k8z") 3‬ﻃ‬
‫)‪1‬اﺳ‬
‫اﻹﺧﺮاج‪# 7 # 9 # 5 # 8 # :‬‬
‫ﺑﺮﻣﺰ ‪#‬‬‫ﺑﺠﺪي‬
‫ﺒﺪال ﻛﻞ رﻣﺰ أ‬
‫ﺘ‬‫ﺘﻢ اﺳ‬
‫ﻳ‬
‫‪7) subn ():‬‬

‫ﺒﺪاﻻ ت‪.‬‬
‫ﺘ‬ ‫ﺜﻞ ‪sub‬إﻻ أﻧﻪﻳﻤﻜﻨﻪ أ ً‬
‫ﻳﻀﺎ إرﺟﺎع ﻋﺪد اﻻﺳ‬ ‫ﺗﻤﺎﻣﺎ ﻣ‬
‫ً‬ ‫• ﻫﻮ ﻧﻔ ﺴﻪ‬
‫ﺒﺪاﻻ ت‪.‬‬
‫ﺘ‬‫ﺜﺎﻧ ﻲ ﻫﻮ ﻋﺪد اﻻﺳ‬
‫ﺘﻴﺠ ﺔ واﻟﻌﻨﺼﺮ اﻟ‬
‫ﺒﺎرة ﻋﻦﺳﻠ ﺴﻠ ﺔ ﻧ‬
‫ﺑﺈرﺟﺎع ﻣﺠﻤﻮﻋ ﺔ ﺣﻴ ﺚﻳﻜﻮن اﻟﻌﻨﺼﺮ اﻷول ﻋ‬‫ﺗﻘﻮم ﻫﺬه اﻟﻮﻇﻴﻔ ﺔ‬
‫ﺒﺪاﻻ ت(‬
‫ﺘ‬‫‪(resultstring،‬ﻋﺪد اﻻﺳ‬
‫‪172‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫"( ‪print (t) 4) print ("The Result String:"، t [0]) 5) print‬‬

‫)‪1) import re 2) t = re.subn ("[az]"، "#"، "a7b9c5k8z") 3‬‬
‫ﺒﺪاﻻ ت‪t [1]) ، ":‬‬
‫ﺘ‬‫ﻋﺪد اﻻﺳ‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫)‪('# 7 # 9 # 5 # 8 #'، 5‬‬
‫ﺘﻴﺠ ﺔ‪# 7 # 9 # 5 # 8 # :‬‬
‫ﺳﻠ ﺴﻠ ﺔ اﻟﻨ‬
‫ﺒﺪاﻻ ت‪5 :‬‬
‫ﺘ‬‫ﻋﺪد اﻻﺳ‬
‫)‪8‬اﻻﻧﻘ ﺴﺎم ‪():‬‬

‫ﺑﺬﻟﻚ‬‫ﺘﻬﺪﻓ ﺔ اﻟﻤﺤﺪدة وﻓ ًﻘﺎ ﻟﻨﻤﻂ ﻣﻌﻴﻦ ﻓﺈﻧﻨﺎ ﻧﻘﻮم‬
‫•إذا أردﻧﺎﺗﻘ ﺴﻴﻢ اﻟ ﺴﻠ ﺴﻠ ﺔ اﻟﻤ ﺴ‬
‫ﻳﺠ ﺐ أنﺗﺬ ﻫ ﺐ ﻟﻮﻇﻴﻔ ﺔ ‪Split ().‬‬
‫ﺑﺠﻤﻴﻊ اﻟﺮﻣﻮز اﻟﻤﻤﻴﺰة‪.‬‬‫ﺑﺈرﺟﺎع ﻗﺎﺋﻤ ﺔ‬‫ﺗﻘﻮم ﻫﺬه اﻟﻮﻇﻴﻔ ﺔ‬
‫•‬
‫ﺘﻴﺮاد )‪vinny، pinny") 3) print (l) 4) for t in l: 5) print (t‬‬

‫)‪1‬اﺳ‬
‫‪re 2) l = re.split ("،"، "sunny، bunny، chinny،‬‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫]'‪['sunny'، 'bunny'، 'chinny'، 'vinny'، 'pinny‬‬
‫ﻣﺸﻤ ﺲ‬
‫ذﻗﻦ‬
‫ﻓﻴﻨ ﻲ‬
‫ﻣﺌﺰر أﻃﻔﺎل‬
‫ﺘﻴﺮاد )‪re.split ("\."، "www.durgasoft.com") 3‬‬

‫)‪1‬اﺳ‬
‫= ‪re 2) l‬ﻟـ )‪t in l: 4) print (t‬‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫‪www‬‬
‫دورﺟﺎﺳﻮﻓ ﺖ‬
‫ﻛﻮم‬
‫‪173‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫^ )‪9‬اﻟﺮﻣﺰ‪:‬‬
‫ﺘﺨﺪاﻣﻬﺎ‬
‫ﺘﻮﻓﺮة ﻟﺪﻳﻨﺎ •ﻳﻤﻜﻨﻨﺎ اﺳ‬
‫ﺑﺎﻟﻘﻴﻤ ﺔ اﻟﻤ‬‫ﺒﺪأ‬
‫ﺘﺤﻘﻖ ﻣﻤﺎ إذا ﻛﺎﻧ ﺖ اﻟ ﺴﻠ ﺴﻠ ﺔ اﻟﻬﺪف اﻟﻤﺤﺪدةﺗ‬
‫^ﻟﻠ‬
‫ﻧﻤﻂ أم ﻻ‪.‬‬
‫ﺜﺎل‪res = re.search ("^ Learn"، s) :‬‬

‫•ﻋﲆﺳ‬
‫ﺘﻌﻮد‬
‫ﺘﻌﻴﺪ ﻛﺎﺋﻦ ‪Match ،‬وإﻻﺳ‬
‫ﺑـ ‪Learn ،‬ﻓ ﺴ‬‫ﺘﻬﺪﻓ ﺔ‬
‫ﺑﺪأ ت اﻟ ﺴﻠ ﺴﻠ ﺔ اﻟﻤ ﺴ‬‫•إذا‬
‫ﻻ أﺣﺪ‪.‬‬
‫‪test.py‬‬
‫ﺗﻌﻠﻢ ‪Python‬ﺳﻬﻞ ﺟﺪًا" ‪5) print ("Target String‬‬

‫= ‪"1) import re 2) s‬‬
‫ﺑـ )"‪with Learn‬‬‫ﺒﺪأ‬
‫ﺗ‬‫‪3) res = re.search ("^ Learn"، s) 4) if res! = None:‬‬
‫‪Learn") 6) else: 7) print ("Target String Not Start‬‬
‫ﺑـ ‪Learn‬‬‫ﺒﺪأ‬
‫ﺘﻬﺪﻓ ﺔﺗ‬
‫اﻹﺧﺮاج‪ :‬اﻟ ﺴﻠ ﺴﻠ ﺔ اﻟﻤ ﺴ‬
‫)‪10‬رﻣﺰ ‪$:‬‬
‫ﺑـ‬‫ﺘﻬ ﻲ‬
‫ﺘﺤﻘﻖ ﻣﻤﺎ إذا ﻛﺎﻧ ﺖ اﻟ ﺴﻠ ﺴﻠ ﺔ اﻟﻬﺪف اﻟﻤﺤﺪدةﺗﻨ‬
‫ﺘﺨﺪام اﻟﺮﻣﺰ ‪$‬ﻟﻠ‬
‫ﻗﺪﻣ ﺖ ﻧﻤﻂ أم ﻻ‪.‬‬
‫ﺜﺎل‪res = re.search ("Easy $"، s) :‬‬

‫•ﻋﲆﺳ‬
‫ﺘﻌﻴﺪ ﻛﺎﺋﻦ ‪Match ،‬وإﻻ‬

‫ﺑـ ‪Easy ،‬ﻓ ﺴ‬‫ﺘﻬﺪﻓ ﺔ‬
‫ﺘﻬ ﺖ اﻟ ﺴﻠ ﺴﻠ ﺔ اﻟﻤ ﺴ‬
‫•إذا اﻧ‬
‫ﺑﻼ‪.‬‬‫إرﺟﺎع‬
‫‪test.py‬‬
‫ﺗﻌﻠﻢ ‪Python‬ﺳﻬﻞ ﺟﺪًا" ‪print ("Target String‬‬

‫= ‪"1) import re 2) s‬‬
‫ﺑـ )‪7‬‬‫ﺘﻬ ﻲ‬
‫ﺗﻨ‬‫)‪3) res = re.search ("Easy $"، s) 4) if res! = None: 5‬‬
‫ﺑـ )"‪Easy‬‬‫ﺘﻬ ﻲ‬
‫ﺘﻬﺪﻓ ﺔ ﻻﺗﻨ‬
‫ﺒﺎﻋ ﺔ )"اﻟ ﺴﻠ ﺴﻠ ﺔ اﻟﻤ ﺴ‬
‫‪Easy") 6) else:‬ﻃ‬
‫ﺑـ "ﺳﻬﻞ"‬‫ﺘﻬ ﻲ‬
‫ﺘﻬﺪﻓ ﺔﺗﻨ‬
‫اﻹﺧﺮاج‪ :‬اﻟ ﺴﻠ ﺴﻠ ﺔ اﻟﻤ ﺴ‬
‫ﺜ ﺔ ‪re.IGNORECASE‬ﻟﻮﻇﻴﻔ ﺔ ‪search ().‬‬

‫ﺜﺎﻟ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬إذا أردﻧﺎﺗﺠﺎ ﻫﻞ اﻟﺤﺎﻟ ﺔ ‪ ،‬ﻓﻌﻠﻴﻨﺎﺗﻤﺮﻳﺮ اﻟﻮﺳﻴﻄ ﺔ اﻟ‬
‫ﺜﺎل‪res = re.search ("easy $"، s، re.IGNORECASE) :‬‬

‫ﻋﲆﺳ‬
‫‪174‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫‪test.py‬‬
‫ﺗﻌﻠﻢ ‪Python‬ﺳﻬﻞ ﺟﺪًا" )‪3) res = re.search ("easy $"، s، re.IGNORECASE) 4‬إذا‬
‫= ‪"1) import re 2) s‬‬
‫ﺘﻬﺪﻓ ﺔ ﻣﻊ ‪Easy‬ﻋﻦ ﻃﺮﻳﻖﺗﺠﺎ ﻫﻞ اﻟﺤﺎﻟ ﺔ )‪") 6‬وإﻻ‪7) :‬ﻃ‬
‫ﺘﻬ ﻲ اﻟ ﺴﻠ ﺴﻠ ﺔ اﻟﻤ ﺴ‬
‫ﺗﻨ‬‫ﺒﺎﻋ ﺔ )"‬
‫ﺑﻼ‪5) :‬ﻃ‬
‫اﻟﺪﻗ ﺔ! =‬
‫ﺘﺠﺎ ﻫﻞ اﻟﺤﺎﻟ ﺔ )"‬

‫ﺑ‬‫ﺑـ ‪Easy‬‬‫ﺘﻬ ﻲ‬
‫ﺘﻬﺪﻓ ﺔ ﻻﺗﻨ‬
‫اﻟ ﺴﻠ ﺴﻠ ﺔ اﻟﻤ ﺴ‬
‫ﺘﺠﺎ ﻫﻞ اﻟﺤﺎﻟ ﺔ‬
‫ﺑ‬‫ﺑـ ‪Easy‬‬‫ﺘﻬﺪﻓ ﺔ‬
‫ﺘﻬ ﻲ اﻟ ﺴﻠ ﺴﻠ ﺔ اﻟﻤ ﺴ‬
‫اﻹﺧﺮاج‪:‬ﺗﻨ‬
‫ﺜﻴﻞ ﻛﻞ ‪Yava‬‬
‫ﺘﻤ‬‫ﺒﻴ ﺮًا ﻋﺎدﻳًﺎ ﻟ‬
‫ﺘ ﺐﺗﻌ‬
‫ﻣﻌﺮﻓﺎ ت اﻟﻠﻐ ﺔ‬
‫ﻗﻮاﻋﺪ‪:‬‬
‫ﺑﻬﺎ ﻫ ﻲ ‪az ،‬و ‪AZ ،‬و‪ ، -0‬و ‪#‬‬‫)‪1‬اﻷﺣﺮف اﻟﻤ ﺴﻤﻮح‬
‫)‪2‬ﻳﺠ ﺐ أنﻳﻜﻮن اﻟﺤﺮف اﻷول رﻣ ًﺰا أ‬

‫ﺑﺠﺪﻳًﺎ ﺻﻐﻴ ﺮًا ﻣﻦ ‪a‬إﱃ ‪k‬‬
‫ﺒﻞ اﻟﻘ ﺴﻤ ﺔ ﻋﲆ ‪3‬‬

‫رﻗﻤﺎﻳﻘ‬
‫ً‬ ‫ﺜﺎﻧ ﻲ‬
‫)‪3‬ﻳﺠ ﺐ أنﻳﻜﻮن اﻟﺤﺮف اﻟ‬
‫)‪4‬ﻳﺠ ﺐ أنﻳﻜﻮن ﻃﻮل اﻟﻤﻌﺮف ﻋﲆ اﻷﻗﻞ ‪2.‬‬
‫* ]‪[ak] [0369] [a-zA-Z0-9 #‬‬
‫ﺘﺤﻘﻖ ﻣﻤﺎ إذا ﻛﺎن اﻟﻤﻌﻄﻰ‬

‫ﺑﺮﻧﺎﻣﺞ ‪Python‬ﻟﻠ‬‫ﺘﺐ‬
‫‪ String‬ﻫ ﻲ ﻣﻌﺮف ﻟﻐ ﺔ ‪Yava‬أم ﻻ؟‬
‫)‪("Enter Identifier:") 3) m = re.fullmatch ("[ak] [0369] [a-zA-Z0-9 #] *"، s) 4‬‬
‫‪1) import re 2) s = input‬إذا ﻛﺎن = ! ‪m‬ﻻ ﺷ ﻲء‪(s، "is valid Yava Identifier") :‬‬
‫‪5) print (s، "is valid Yava Identifier") 6) else: 7) print‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫أدﺧﻞ اﻟﻤﻌﺮف‪a6kk9z ## :‬‬
‫‪ a6kk9z ##‬ﻫﻮ ﻣﻌﺮف ‪ Yava‬ﺻﺎﻟﺢ‬

‫أدﺧﻞ اﻟﻤﻌﺮف‪k9b876 :‬‬
‫‪ k9b876‬ﻫﻮ ﻣﻌﺮف ‪ Yava‬ﺻﺎﻟﺢ‬

‫أدﺧﻞ اﻟﻤﻌﺮف‪k7b9 :‬‬
‫ّ ف ‪Yava‬‬
‫‪k7b9‬ﻏﻴﺮ ﺻﺎﻟﺢ ﻣﻌ ﺮ‬
‫‪175‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺜﻴﻞ ﻛﻞ ‪10‬أرﻗﺎم‬
‫ﺘﻤ‬‫ﺒﻴ ًﺮا ﻋﺎدﻳًﺎ ﻟ‬
‫ﺘ ﺐﺗﻌ‬
‫ﺗﻒ اﻟﻤﺤﻤﻮﻟ ﺔ‬
‫أرﻗﺎم اﻟﻬﻮا‬
‫ﻗﻮاﻋﺪ‪:‬‬
‫ﺒﻂ‬
‫ﺑﺎﻟﻀ‬‫ﺘﻮي ﻛﻞ رﻗﻢ ﻋﲆ ‪10‬أرﻗﺎم‬
‫)‪1‬ﻳﺠ ﺐ أنﻳﺤ‬
‫ﺷﺎرع‬
‫ﻳﺠ ﺐ أنﻳﻜﻮن اﻟﺮﻗﻢ ‪7‬أو ‪8‬أو ‪9‬‬ ‫‪2) 1‬‬
‫]‪[7-9] [0-9] [0-9] [0-9] [0-9] [0-9] [0-9] [0-9] [0-9] [0-9‬‬
‫أو‬
‫}‪[7-9] [0-9] {9‬‬

‫أو‬
‫}‪[7-9] \ d {9‬‬
‫ﺘﺤﻘﻖ ﻣﻤﺎ إذا ﻛﺎن اﻟﻤﻌﻄﻰ‬

‫ﺗﻒ ﺻﺤﻴﺢ أم ﻻ؟‬

‫رﻗﻢ اﻟﻬﺎ‬
‫ﺘﻴﺮاد = ‪re 2) n‬إدﺧﺎل )"أدﺧﻞ اﻟﺮﻗﻢ‪{9}" ، n) 4) (":‬‬

‫)‪1‬اﺳ‬
‫ﺑﻼ‪5) :‬‬
‫‪3) m = re.fullmatch ("[7-9] \ d‬إذا ﻛﺎن = !‪m‬‬
‫ﺒﻊ )"رﻗﻢ‬
‫ﺗﻒ ﻣﺤﻤﻮل ﺻﺎﻟﺢ"( )‪6‬وإﻻ‪7) :‬اﻃ‬
‫ﺒﻊ )"رﻗﻢ ﻫﺎ‬
‫اﻃ‬
‫ﺗﻒ اﻟﻤﺤﻤﻮل ﻏﻴﺮ ﺻﺎﻟﺢ"(‬
‫اﻟﻬﺎ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫أدﺧﻞ اﻟﺮﻗﻢ‪9898989898 :‬‬
‫رﻗﻢ ﺟﻮال ﺻﺎﻟﺢ‬

‫أدﺧﻞ اﻟﺮﻗﻢ‪6786786787 :‬‬
‫رﻗﻢ اﻟﺠﻮال ﻏﻴﺮ ﺻﺎﻟﺢ‬

‫أدﺧﻞ اﻟﺮﻗﻢ‪898989 :‬‬
‫رﻗﻢ اﻟﺠﻮال ﻏﻴﺮ ﺻﺎﻟﺢ‬
‫ﺘﻢ ﺧﻠﻂ‬
‫ﺗﻒ اﻟﻤﺤﻤﻮﻟ ﺔ اﻟﻤﻮﺟﻮدة ﻓ ﻲ ‪input.txt‬ﺣﻴ ﺚﻳ‬
‫ﺘﺨﺮاج ﺟﻤﻴﻊ أرﻗﺎم اﻟﻬﻮا‬
‫ﺑﺮﻧﺎﻣﺞ ‪Python‬ﻻﺳ‬‫ﺘﺐ‬
‫ﺒﻴﺎﻧﺎ ت اﻟﻨﺺ اﻟﻌﺎدي‬
‫ﺑ‬‫اﻷرﻗﺎم‬
‫ﺘﺢ )"‪("input.txt"، "r") 3) f2 = open ("output.txt"، "w‬‬

‫ﺘﻴﺮاد = ‪re 2) f1‬ﻓ‬
‫)‪1‬اﺳ‬
‫‪176‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
all Mobile Numbers into output.txt") 9) f1.close () 10) f2.close () ‫ﻟﻠ ﺴﻄﺮ ﻓ ﻲ‬4)
‫ﻓ ﻲ‬n ‫ﺳﻄﺮ( ﻟـ‬list = re.findall ("[7-9] \ d {9}"f1:
، 5) 6) 7) 8) print ("Extracted
:‫اﻟﻘﺎﺋﻤ ﺔ‬
f2.write (n + "\ n")
‫ﺒﻴﺮا ت اﻟﻌﺎدﻳ ﺔ‬
‫ﺑﺎﺳ‬‫ﺗﺠﺮﻳﻒ اﻟﻮﻳ ﺐ‬
‫ﺒﺮﻳﺪ وأرﻗﺎم‬
‫ﺜﻞ ﻣﻌﺮﻓﺎ ت اﻟ‬
‫ﺑ ﺔ ﻟﺪﻳﻨﺎ ﻣ‬
‫ﺑﻘ ﺔ اﻷﻧﻤﺎط اﻟﻤﻄﻠﻮ‬
‫ ﻓ ﻲﺗﺠﺮﻳﻒ اﻟﻮﻳ ﺐ ﻟﻤﻄﺎ‬.‫ﺗ ﺴﻤﻰ ﻋﻤﻠﻴ ﺔ ﺟﻤﻊ اﻟﻤﻌﻠﻮﻣﺎ ت ﻣﻦ ﺻﻔﺤﺎ ت اﻟﻮﻳ ﺐﺗﺠﺮﻳﻒ اﻟﻮﻳ ﺐ‬
.‫ﺒﻴﺮا ت اﻟﻌﺎدﻳ ﺔ‬
‫ﻳﻤﻜﻨﻨﺎ اﺳ‬، ‫اﻟﺠﻮال‬
title = re.findall ("<title>. * </title>"، str (text)، re.I) 9) 10) print (title [0])
s) 7) u = urllib.request.urlopen ("http: //" + s + ".com") 8) text = u.read ()
rediff" .split () 4) print (sites) 5) for s in sites: 6) print ("Searching ..."،
1) import re، urllib 2) import urllib.request 3) sites = "google
‫ﺒﻴﺮا ت اﻟﻌﺎدﻳ ﺔ‬
‫ﺘﻌ‬‫واﻟ‬Web Scraping ‫ﺘﺨﺪام‬
‫ﺑﺎﺳ‬
redbus.in ‫ﺗﻒ‬
‫ﺑﺮﻧﺎﻣﺞ ﻟﻠﺤﺼﻮل ﻋﲆ ﺟﻤﻴﻊ أرﻗﺎم ﻫﻮا‬
3) u = urllib.request.urlopen ("https://www.redbus.in/info/contactus") 4) text = u.read () 5)

re.I) 6) ، (‫ =)ﻧﺺ‬re.findall ("[0-9 -] {7} [0-9 -] +" ، str ‫أرﻗﺎم‬1) import re، urllib 2) import urllib.request
(n) ‫ﺒﺎﻋ ﺔ‬
‫ﻃ‬7) : ‫ﺑﺎﻷرﻗﺎم‬
n ‫ﻟـ‬
‫ ﺻﺎﻟﺢ أم ﻻ؟‬gmail ‫ﺒﺮﻳﺪ اﻟﻤﺤﺪد ﻫﻮ ﻣﻌﺮف‬

‫ﺘﺤﻘﻖ ﻣﻤﺎ إذا ﻛﺎن ﻣﻌﺮف اﻟ‬
‫ﻟﻠ‬Python ‫ﺑﺮﻧﺎﻣﺞ‬‫ﺘﺐ‬
‫اﻛ‬
Z0-9 _.] * @ gmail [.] com"، s) 4 ) (":‫ﺒﺮﻳﺪ‬

‫)"أدﺧﻞ ﻣﻌﺮف اﻟ‬re 2) s = input ‫ﺘﻴﺮاد‬
‫اﺳ‬1)
‫ﺑﺮﻳﺪ ﺻﺎﻟﺢ"( ؛‬‫ﺒﺎﻋ ﺔ )"ﻣﻌﺮف‬
‫ﻃ‬5) :‫ﻻ ﺷ ﻲء‬m! = ‫إذا ﻛﺎن‬3) m = re.fullmatch ("\ w [a-zA-

- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
177 040-64 51 27 86 ، 80 96 96 96 96 ، 92 46 21 21 43 | www.durgasoft.com
‫ﺒﺮﻳﺪ ﻏﻴﺮ ﺻﺎﻟﺢ"(‬

‫ﺒﺎﻋ ﺔ )"ﻣﻌﺮف اﻟ‬
‫)‪6‬وإﻻ‪7) :‬ﻃ‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫ﺒﺮﻳﺪ‪durgatoc@gmail.com :‬‬
‫أدﺧﻞ ﻣﻌﺮف اﻟ‬
‫ﺑﺮﻳﺪ ﺻﺎﻟﺢ‬‫ﻣﻌﺮف‬

‫ﺒﺮﻳﺪ‪durgatoc :‬‬
‫ﺒﺮﻳﺪ ﻏﻴﺮ ﺻﺎﻟﺢ‬
‫ﻣﻌﺮف اﻟ‬

‫ﺒﺮﻳﺪ‪durgatoc@yahoo.co.in :‬‬
‫ﺒﺮﻳﺪ ﻏﻴﺮ ﺻﺎﻟﺢ‬
‫ﻣﻌﺮف اﻟ‬
‫ﺘﺤﻘﻖ ﻣﻤﺎ إذا ﻛﺎن رﻗﻢﺗ ﺴﺠﻴﻞ اﻟ ﺴﻴﺎرة اﻟﻤﻘﺪم ﺻﺎﻟﺤًﺎ أم ﻻ؟‬
‫اﻛ‬
‫ﺒ ﺔ‪{2} \ d {4}" ، s ) 4) (":‬‬

‫‪")1) import re 2) s = input‬أدﺧﻞ رﻗﻢﺗ ﺴﺠﻴﻞ اﻟﻤﺮﻛ‬
‫ﺒﻊ‬
‫]‪3) m = re.fullmatch ("TS [012] [0-9] [AZ‬إذا ﻛﺎن = !‪m‬ﻻ ﺷ ﻲء‪5) :‬اﻃ‬
‫ﺒ ﺔ ﻏﻴﺮ ﺻﺎﻟﺢ"(‬
‫ﺒﻊ )"رﻗﻢﺗ ﺴﺠﻴﻞ اﻟﻤﺮﻛ‬
‫ﺒ ﺔ ﺻﺎﻟﺢ"( ؛ )‪6‬وإﻻ‪7) :‬اﻃ‬
‫)"رﻗﻢﺗ ﺴﺠﻴﻞ ﻣﺮﻛ‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫ﺒ ﺔ‪TS07EA7777 :‬‬
‫أدﺧﻞ رﻗﻢﺗ ﺴﺠﻴﻞ اﻟﻤﺮﻛ‬
‫ﺒ ﺔﺳﺎري اﻟﻤﻔﻌﻮل‬
‫رﻗﻢﺗ ﺴﺠﻴﻞ اﻟﻤﺮﻛ‬

‫ﺒ ﺔ‪TS07KF0786 :‬‬
‫ﺒ ﺔﺳﺎري اﻟﻤﻔﻌﻮل‬

‫ﺒ ﺔ‪AP07EA7898 :‬‬
‫ﺒ ﺔ ﻏﻴﺮ ﺻﺤﻴﺢ‬
‫‪178‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺗﻒ اﻟﻤﺤﻤﻮل اﻟﻤﺤﺪد ﺻﺎﻟﺤًﺎ‬

‫ﺘﺤﻘﻖ ﻣﻤﺎ إذا ﻛﺎن رﻗﻢ اﻟﻬﺎ‬
‫ﺑﺮﻧﺎﻣﺞ ‪Python‬ﻟﻠ‬
‫رﻗﻤﺎ(‬
‫رﻗﻤﺎ أو ‪ً 12‬‬
‫أو ﻟﻴ ﺲ ‪(10‬أرﻗﺎم أو ‪ً 11‬‬
‫‪")1) import re 2) s = input‬أدﺧﻞ رﻗﻢ اﻟﺠﻮال‪[7-9] [0-9] {9}" ، (":‬‬

‫؟)‪ 3) m = re.fullmatch ("(0 | 91‬ق( ) ‪4‬إذا ﻛﺎن = !‪m‬ﻻ ﺷ ﻲء‪5) :‬‬
‫ﺗﻒ‬
‫ﺒﻊ )"رﻗﻢ اﻟﻬﺎ‬
‫ﺗﻒ ﻣﺤﻤﻮل ﺻﺎﻟﺢ"( ؛ )‪6‬وإﻻ‪7) :‬اﻃ‬
‫ﺒﻊ )"رﻗﻢ ﻫﺎ‬
‫اﻃ‬
‫اﻟﻤﺤﻤﻮل ﻏﻴﺮ ﺻﺎﻟﺢ"(‬
‫ﺜﻠ ﺔ اﻷﺧﺮى‪.‬‬
‫ﺑﻌﺾ اﻷﻣ‬
‫ﺟﺪول ﻣﻠﺨﺺ و‬

‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫‪179‬‬
‫اﻟﺪﻳﻜﻮر‬
‫اﻟﻤﻬﺎم‬
‫‪180‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺑﻮﻇﺎﺋﻒ ﻣﻮﺳﻌ ﺔ‪.‬‬‫ﺗﻌﻴﺪ اﻟﻮﻇﻴﻔ ﺔ اﻟﻤﻌﺪﻟ ﺔ‬

‫ﺗﻮﺳﻊ وﻇﺎﺋﻔﻬﺎ و‬
‫‪ Decorator‬ﻫ ﻲ وﻇﻴﻔ ﺔﻳﻤﻜﻦ أنﺗﺄﺧﺬ وﻇﻴﻔ ﺔ ﻛﻮﺳﻴﻄ ﺔ و‬
‫ﺑﻌﺾ اﻟﻮﻇﺎﺋﻒ(‬‫ﺟﺪﻳﺪ )أﺿﻒ‬ ‫وﻇﻴﻔ ﺔ اﻹدﺧﺎل‬

‫ﻣﺼﻤﻢ‬
‫ﺘﻤﻨﻰ)(‬
‫ﻳ‬
‫داﺧﻠ ﻲ)(‬
‫ﻣﺼﻤﻢ‬ ‫وﻇﻴﻔ ﺔ اﻹﺧﺮاج ﻣﻊ وﻇﺎﺋﻒ ﻣﻮﺳﻌ ﺔ‬

‫وﻇﻴﻔ ﺔ اﻹدﺧﺎل‬
‫وﻇﻴﻔ ﺔ‬
‫ﺋﻴ ﺴ ﻲ ﻣﻦ وﻇﺎﺋﻒ اﻟﺪﻳﻜﻮر ﻫﻮ أﻧﻪﻳﻤﻜﻨﻨﺎﺗﻮﺳﻴﻊ وﻇﺎﺋﻒ اﻟﻮﻇﺎﺋﻒ اﻟﺤﺎﻟﻴ ﺔ دونﺗﻌﺪﻳﻞ ﻫﺬه اﻟﻮﻇﻴﻔ ﺔ‪.‬‬
‫اﻟﻬﺪف اﻟﺮ‬
‫ﺒﺎﻋ ﺔ ‪("Hello" ،‬اﻻﺳﻢ ‪"Good Morning") ،‬‬

‫‪)1) def wish‬اﻻﺳﻢ(‪2) :‬ﻃ‬
‫ﺒﺎﻋ ﺔ ﻧﻔ ﺲ اﻹﺧﺮاجﻷي اﺳﻢ‬

‫ﺋﻤﺎ ﻃ‬
‫ﻳﻤﻜﻦ ﻟﻬﺬه اﻟﻮﻇﻴﻔ ﺔ دا ً‬
‫ﺒﺎح اﻟﺨﻴﺮ‬
‫ﺒﺎ دورﺟﺎ ﺻ‬
‫ﻣﺮﺣ‬
‫ﺒﺎ راﻓ ﻲ ﺻ‬
‫ﻣﺮﺣ‬
‫ﺒﺎ ﺻﻨ ﻲ ﺻ‬
‫ﻣﺮﺣ‬
‫ﺴﺎ‪.‬‬
‫ﺘﻠﻔ ﺔ إذا ﻛﺎن اﻻﺳﻢ ﻣﺸﻤ ً‬
‫ﺘﻘﺪﻳﻢ رﺳﺎﻟ ﺔ ﻣﺨ‬
‫ﻟﻜﻨﻨﺎ ﻧﺮﻳﺪﺗﻌﺪﻳﻞ ﻫﺬه اﻟﻮﻇﻴﻔ ﺔ ﻟ‬
‫ﺘﺨﺪام اﻟﺰﺧﺮﻓ ﺔ‪.‬‬
‫ﺑﺎﺳ‬
‫ﺑﺬﻟﻚ دون ﻟﻤ ﺲ وﻇﻴﻔ ﺔ )( ‪Wish‬‬‫ﻳﻤﻜﻨﻨﺎ اﻟﻘﻴﺎم‬
‫)‪Sunny Bad Morning") 5) else: 6) func (name) 7‬‬

‫‪(name): 3) if name == "Sunny": 4) print ("Hello‬‬
‫‪1) def decor (func): 2) def inner‬إرﺟﺎع اﻟﺪاﺧﻠﻴ ﺔ )‪8‬‬
‫ﺒﺎﻋ ﺔ ‪("Hello" ،‬‬

‫‪)9) decor 10) def wish‬اﻻﺳﻢ(‪11) :‬ﻃ‬
‫اﻻﺳﻢ ‪wish ("Durga") 14) wish ("Ravi") 15) wish (" ،‬‬
‫)‪"Good Morning") 12) 13‬ﻣﺸﻤ ﺲ"(‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﻣﺮﺣ‬
‫ﺒﺎ راﻓ ﻲ ﺻ‬
‫ﻣﺮﺣ‬
‫‪181‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﻢﺗﻨﻔﻴﺬ وﻇﻴﻔ ﺔ اﻟﺪﻳﻜﻮرﺗﻠﻘﺎﺋ ًﻴﺎ‪.‬‬

‫ﺒﺮﻧﺎﻣﺞ أﻋﻼه ﻛﻠﻤﺎ ﻧ ﺴﻤ ﻲ وﻇﻴﻔ ﺔ )( ‪wish‬ﺳﻴ‬
‫‪Hello Sunny Bad Morning‬ﻓ ﻲ اﻟ‬
‫ﺑﺪون ﻣﺰﺧﺮف‪:‬‬
‫ﺘﺪﻋﺎء ﻧﻔ ﺲ اﻟﻮﻇﻴﻔ ﺔ ﻣﻊ ‪Decorator‬و‬
‫ﺘﺨﺪم‪roced‬‬
‫ﻳﺠ ﺐ أﻻ ﻧ ﺴ‬
‫)‪== "Sunny": 4) print ("Hello Sunny Bad Morning") 5) else: 6) func (name) 7‬‬
‫‪1) def decor (func): 2) def inner (name): 3) if name‬إرﺟﺎع ‪("Durga") #decorator‬‬
‫‪name،‬‬
‫)"ﺻﻨ ﻲ"(‬ ‫ﺒﺔ‬ ‫‪"Good‬‬
‫)‪15‬رﻏ‬ ‫)"‪Morning‬‬
‫)‪11‬ﻟﻦﻳﻜﻮنﺗﻢ اﻟ‬
‫ﺘﻨﻔﻴﺬ‬ ‫‪12) decorfunction‬‬
‫‪interior‬‬ ‫‪8) 9) def wish=(name):‬‬
‫)‪decor (wish‬‬ ‫‪13) ("Hello"،‬‬
‫‪10) print‬‬ ‫‪14) wish‬‬
‫ﺘﻢﺗﻨﻔﻴﺬ ‪#‬دﻳﻜﻮر )‪18‬وﻇﻴﻔ ﺔ دﻳﻜﻮر‬

‫)‪16‬وﻇﻴﻔ ﺔ دﻳﻜﻮر )"دورﺟﺎ"(ﺳﻴ‬ ‫)‪17‬‬
‫ﻳﻜﻮر‬ ‫ﺗﻨﻔﻴﻫﺎ‬
‫ﺬ اﻟﺪ‬ ‫ﺗﻨﻔﻴﺬ‬
‫ﺘﻢ‬‫ﺘﻢ‬
‫ﻲ"(ﻟﻦ‪#‬ﻳ‬
‫ﺳﻴ‬ ‫ﻳﻜﻮر‬‫‪#‬د‬
‫)"ﺻﻨ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﻣﺮﺣ‬
‫ﺒﺎ ﺻﻨ ﻲ ﺻ‬
‫ﻣﺮﺣ‬
‫ﻣﺮﺣ‬
‫ﺒﺎح‬
‫ﺒﺎ ﺻﻨ ﻲﺳ ﻲء اﻟﺼ‬
‫ﻣﺮﺣ‬
‫‪1) def smart_division (func): 2) def‬داﺧﻠﻴ ﺔ‬
‫)أ ‪ ،‬ب(‪3) 4) 5) 6) 7) 8) 9) 10) :‬‬
‫‪")print‬ﻧﺤﻦ ﻧﻘ ﺴﻢ ‪" ،‬أ ‪" ،‬ﻣﻊ" ‪ ،‬ب( إذا ب ‪== 0:‬‬
‫ﺒﺎﻋ ﺔ ‪("OOPS ...‬ﻻﻳﻤﻜﻦ اﻟﻘ ﺴﻤ ﺔ"(‬

‫ﻃ‬
‫ﻳﻌﻮد‬
‫آﺧﺮ‪:‬‬
‫ﻋﻮدة ‪)func‬أ ‪ ،‬ب( ﻋﻮدة‬

‫اﻟﺪاﺧﻠﻴ ﺔ‬
‫ﺗﻘ ﺴﻴﻢ )‪(a، b): 13‬‬

‫)‪11) smart_division 12‬‬
‫ﺑﺈرﺟﺎع ‪a / b‬‬‫‪def‬ﻗﻢ‬

‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺒﺎﻋ ﺔ‬
‫ﺒﺎﻋ ﺔ )ﻗ ﺴﻤ ﺔ )‪(20،2)) 15‬ﻃ‬
‫)‪14‬ﻃ‬
‫)ﻗ ﺴﻤ ﺔ ))‪(20،0‬‬
‫ﺗﺞ ﻓ ﻲ ﻫﺬه اﻟﺤﺎﻟ ﺔ ﻫﻮ‪:‬‬

‫ﺑﺪون ﻣﺰﺧﺮفﺳﻨﺤﺼﻞ ﻋﲆ ﺧﻄﺄ‪ .‬اﻟﻨﺎ‬
‫ﺒﻊ )آﺧﺮ ﻣﻜﺎﻟﻤ ﺔ أﺧﻴﺮة(‪ :‬ﻣﻠﻒ ‪"test.py" ،‬اﻟ ﺴﻄﺮ‬
‫ﺘ‬‫ﺘ‬‫‪10.0‬اﻟ‬
‫ﺘﻘ ﺴﻴﻢ ))‪(20،0‬‬

‫ﺒﺎﻋ ﺔ >‪)<module‬اﻟ‬
‫‪16 ،‬ﻓ ﻲ ﻃ‬
‫ﻣﻠﻒ ‪"test.py" ،‬اﻟ ﺴﻄﺮ ‪13 ،‬ﻓ ﻲ اﻟﻘ ﺴﻤ ﺔ إرﺟﺎع‬

‫‪a / b ZeroDivisionError:‬اﻟﻘ ﺴﻤ ﺔ ﻋﲆ ﺻﻔﺮ‬
‫ﺗﺞ ﻓ ﻲ ﻫﺬه اﻟﺤﺎﻟ ﺔ ﻫﻮ‪:‬‬

‫ﻣﻊ ‪Decorator‬ﻟﻦ ﻧﺤﺼﻞ ﻋﲆ أي ﺧﻄﺄ‪ .‬اﻟﻨﺎ‬
‫ﻧﻘ ﺴﻢ ‪20‬ﻋﲆ ‪2‬‬
‫‪10.0‬‬
‫ﻧﻘ ﺴﻢ ‪20‬ﻋﲆ ‪0‬‬

‫ﻋﻔ ًﻮا ‪ ...‬ﻻﻳﻤﻜﻦ اﻟﻘ ﺴﻤ ﺔ‬
‫ﻻ أﺣﺪ‬
‫ﺒﺎﻋ ﺔ "(زﺧﺮﻓ ﺔ اﻟﺸﻌﺮ ‪4) ("...‬‬

‫)‪1) def mariagedecor (func): 2) def inner (): 3‬ﻃ‬
‫ﺒﺎﻋ ﺔ ‪("Fair and Lovely‬إﻟﺦ ‪(): 10) ..‬‬
‫ﺗﻴﻨﻴ ﺔ"( )‪5‬ﻃ‬
‫ﺒﻼ‬‫ﺒﺎﻋ ﺔ "(زﺧﺮﻓ ﺔ اﻟﻮﺟﻪ ﻣﻊ اﻟﺤﺰﻣ ﺔ اﻟ‬
‫ﻃ‬
‫‪maragedecor‬ﺔ= '(ﺟﺎ ﻫﺰ ﻟﻠﺰواج )(‬
‫‪11) 12) decor_getready‬‬ ‫ﺒﺎﻋ‬
‫)‪') 6) func ()(getready‬ﻃ‬
‫‪7) return inner‬‬ ‫‪8) decor_getready‬‬
‫)‪13) 14‬‬ ‫‪9) def getready‬‬
‫)'‬
‫ﺗ ﺴﻠ ﺴﻞ اﻟﺪﻳﻜﻮر‬
‫ﻳﻤﻜﻨﻨﺎﺗﺤﺪﻳﺪ اﻟﻌﺪﻳﺪ ﻣﻦ اﻟﺪﻳﻜﻮرا ت ﻟﻨﻔ ﺲ اﻟﻮﻇﻴﻔ ﺔ وﺳﻮفﻳﺸﻜﻞ ﻛﻞ ﻫﺆﻻء اﻟﻤﺼﻤﻤﻴﻦﺳﻠ ﺴﻠ ﺔ اﻟﺪﻳﻜﻮر‪.‬‬
‫ﺜﺎل‪:‬‬
‫ﻋﲆﺳ‬
‫‪@ decor1‬‬
‫@دﻳﻜﻮر‬
‫‪def‬اﻷﺳﻄﻮاﻧﺎ ت ‪():‬‬
‫ﺛﻢ ﻣﺼﻤﻢ ﺧﺎرﺟ ﻲ‪.‬‬‫ﺘﻴﻦ ﻟﻠﺪﻳﻜﻮر‪.‬ﺳﻴﻌﻤﻞ أول ﻣﺼﻤﻢ داﺧﻠ ﻲ‬

‫ﺒﻴﻖ وﻇﻴﻔ‬
‫ﺘﻄ‬‫ﺑ‬‫ﺒ ﺔ ﻟﻮﻇﻴﻔ ﺔ ‪num () ،‬ﻧﻘﻮم‬

‫اﻟ‬
‫‪183‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
inner (): 9) x = func () 10)

7) def decor (func): 8) def
func2)()def
4) return
interior
x ():
* x3)5)x6)
=
‫إرﺟﺎع‬
12)1)‫ﻲ‬def
‫داﺧﻠ‬decor1
‫إرﺟﺎع‬2 *(func):
x 11)
‫اﻟﻌﻮدة اﻟﺪاﺧﻠﻴ ﺔ‬
10 17) 18) print (num ())

15) def num (): 16) return
13) @ decor1 14) decor
184
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﺑﺎء‬
‫ﻣﻮﻟﺪ ﻛﻬﺮ‬
‫اﻟﻤﻬﺎم‬
‫‪185‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫اﻟﻤﻮﻟﺪ ﻫﻮ وﻇﻴﻔ ﺔ ﻣ ﺴﺆوﻟ ﺔ ﻋﻦﺗﻮﻟﻴﺪﺳﻠ ﺴﻠ ﺔ ﻣﻦ اﻟﻘﻴﻢ‪.‬‬

‫ﺘﺠ ﺔ ﻹرﺟﺎع اﻟﻘﻴﻢ‪.‬‬
‫ﺋﻴ ﺴﻴ ﺔ اﻟﻤﻨ‬
‫ﺘﺨﺪم اﻟﻜﻠﻤﺎ ت اﻟﺮ‬
‫ﺜﻞ اﻟﻮﻇﺎﺋﻒ اﻟﻌﺎدﻳ ﺔ ‪ ،‬وﻟﻜﻨﻬﺎﺗ ﺴ‬
‫ً‬ ‫ﺑ ﺔ وﻇﺎﺋﻒ اﻟﻤﻮﻟﺪ‬
‫ﺘﺎ‬
‫ﺑﺎء‬
‫ﻣﻮﻟﺪ ﻛﻬﺮ‬
‫ﺗ ﺴﻠ ﺴﻞ اﻟﻘﻴﻢ‬
‫وﻇﻴﻔ ﺔ‬
‫أَ ْ‬
‫ﺛ َﻤ ﺮ‬
‫)‪1) def mygen (): 2‬‬

‫)‪'B' 4‬‬
‫‪print‬‬ ‫ﺘﺞ‬
‫‪(next‬‬‫ﻳﻨ‬‫ﺘﺞ )‪'A' 3‬‬
‫‪(next‬‬ ‫ﻳﻨ‬
‫‪print‬‬
‫‪6) g(type‬‬ ‫)‪(g)) 8‬‬
‫‪= mygen‬‬ ‫)‪9‬‬
‫)‪() 7‬‬
‫ﺒﺎﻋ ﺔ‬
‫ﺒﺎﻋ ﺔ‬‫ﻃﻃ‬ ‫)ز(()‪10‬‬
‫)‪11‬‬ ‫'‪)'C‬ز(‬ ‫)‪5‬‬
‫ﺘﺎﻟ ﻲ‬‫)اﻟ‬
‫ﺒﺎﻋ ﺔ‬
‫ﺘﺎﻟ ﻲ )ز(( )‪12‬ﻃ‬
‫)اﻟ‬
‫ﺘﺎﻟ ﻲ )ز((‬
‫)اﻟ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫>ﻓﺌ ﺔ "اﻟﻤﻮﻟﺪ"<‬
‫أ‬
‫ب‬
‫‪)C Traceback‬آﺧﺮ ﻣﻜﺎﻟﻤ ﺔ أﺧﻴﺮة(‪ :‬ﻣﻠﻒ ‪"test.py" ،‬‬
‫ﺘﺎﻟ ﻲ ))‪(g‬‬
‫ﺒﺎﻋ ﺔ >‪)<module‬اﻟ‬
‫اﻟ ﺴﻄﺮ ‪12 ،‬ﻓ ﻲ ﻃ‬
‫ﺗﻮﻗﻒ‬
‫)‪2) print ("Start Countdown") 3‬‬

‫‪=0):‬‬ ‫)‪4) 5‬‬
‫اﻟﻘﻴﻢ‬ ‫ﺑﻴﻨﻤﺎ‬‫‪1) def‬‬
‫‪num‬‬ ‫‪= 1 countdown‬‬
‫ﺘﺞ اﻟﻌﺪد )‪6‬‬ ‫‪(num):‬‬
‫>‪(num‬ﻳﻨ‬
‫ﺒﺎﻋ ﺔ‬
‫ﺘﻨﺎزﻟ ﻲ )‪(5) 7‬ﻟـ ‪x‬ﻓ ﻲ اﻟﻘﻴﻢ‪8) :‬ﻃ‬
‫اﻟﻌﺪ اﻟ‬
‫)‪(x‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﺘﻨﺎزﻟ ﻲ‬
‫ﺑﺪء اﻟﻌﺪ اﻟ‬
‫‪5‬‬
‫‪186‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫‪4‬‬
‫‪3‬‬
‫‪2‬‬
‫‪1‬‬
‫ﺘﻮﻟﻴﺪ اﻷرﻗﺎم ‪n‬اﻷوﱃ‬

‫ﺜﺎل ‪3:‬ﻟ‬
‫ﻋﲆﺳ‬
‫)‪firstn (num): 2) n = 1 3‬‬

‫ﺑﻴﻨﻤﺎ )‪n <= num: 4‬‬
‫‪1) def‬‬
‫ﺘﺎج )‪n 5) n = n + 1 6) 7‬‬
‫إﻧ‬
‫)‪=(x‬ﻟـ ‪x‬ﻓ ﻲ‬
‫‪firstn‬‬‫)‪(5‬ﻃ‬
‫ﺒﺎﻋ ﺔ‬ ‫اﻟﻘﻴﻢ‪9 )8):‬‬
‫ﻗﻴﻢ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫‪1‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4‬‬
‫‪5‬‬
‫ﺘﺎﻟ ﻲ‪:‬‬
‫ﻳﻤﻜﻨﻨﺎﺗﺤﻮﻳﻞ اﻟﻤﻮﻟﺪ إﱃ ﻗﺎﺋﻤ ﺔ ﻋﲆ اﻟﻨﺤﻮ اﻟ‬
‫اﻟﻘﻴﻢ )‪= firstn (10‬‬
‫= ‪l1‬ﻗﺎﺋﻤ ﺔ )ﻗﻴﻢ(‬
‫ﺒﺎﻋ ﺔ ]‪(l1) # [1 ، 2 ، 3 ، 4 ، 5 ، 6 ، 7 ، 8 ، 9 ، 10‬‬
‫ﻃ‬
‫ﺗﺸ ﻲ ‪...‬‬
‫ﺒﻮﻧﺎ‬
‫ﺘﻮﻟﻴﺪ أرﻗﺎم ﻓﻴ‬
‫ﺜﺎل ‪4:‬ﻟ‬
‫ﻣ‬
‫ﺑﻘﻴﻦ‬
‫ﺘﺎﻟ ﻲ ﻫﻮ ﻣﺠﻤﻮع اﻟﻌﺪدﻳﻦ اﻟ ﺴﺎ‬
‫اﻟ‬
‫ﺜﺎل‪0،1،1،2،3،5،8،13،21 ، ... :‬‬

‫ﻋﲆﺳ‬
‫)‪fib (): 2) a ، b = 0،1 3‬‬

‫ﺑﻴﻨﻤﺎ ﺻﺤﻴﺢ‪4) :‬‬
‫‪1) def‬‬
‫ﺘﺞ )‪a ، b = b ، a + b 6‬‬
‫ﻳﻨ‬
‫إذا‬
‫ﺘﺮاﺣ ﺔ‪9)fib‬‬
‫)‪(): 7‬‬ ‫‪100:‬ﻓ ﻲ‬
‫>‪f‬اﺳ‬ ‫)‪a 8‬ﻟـ ‪f‬‬
‫)‪5‬‬
‫ﺒﺎﻋ ﺔ )و(‬
‫ﻃ‬
‫‪187‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫‪0‬‬
‫‪1‬‬
‫‪2‬‬
‫‪1‬‬
‫‪3‬‬
‫‪8‬‬
‫‪5‬‬
‫‪13‬‬
‫‪21‬‬
‫‪34‬‬
‫‪55‬‬
‫‪89‬‬
‫ﻣﺰاﻳﺎ وﻇﺎﺋﻒ اﻟﻤﻮﻟﺪ‪:‬‬

‫ﺘﺨﺪام ﻟﻠﻐﺎﻳ ﺔ‪.‬‬
‫ﺘﻮى اﻟﻔﺼﻞ ‪ ،‬ﻓﺈن اﻟﻤﻮﻟﺪا تﺳﻬﻠ ﺔ اﻻﺳ‬
‫ﺘﻬﺎ ﻣﻊﺗﻜﺮارا ت ﻣ ﺴ‬
‫)‪1‬ﻋﻨﺪ ﻣﻘﺎرﻧ‬
‫ﺘﺨﺪام اﻟﺬاﻛﺮة واﻷداء‪.‬‬
‫)‪2‬ﻳﺤ ﺴﻦ اﺳ‬
‫ﺒﻴﺮة‪.‬‬
‫ﺒﻴﺮ ﻣﻦ اﻟﻤﻠﻔﺎ ت اﻟﻜ‬
‫ﺒﻴﺎﻧﺎ ت ﻣﻦ ﻋﺪد ﻛ‬
‫)‪3‬اﻟﻤﻮﻟﺪا ت ﻫ ﻲ اﻷﻧ ﺴ ﺐ ﻟﻘﺮاءة اﻟ‬
‫ﺑﺸﻜﻞ راﺋﻊ ﻓ ﻲﺗﺠﺮﻳﻒ اﻟﻮﻳ ﺐ واﻟﺰﺣﻒ‪.‬‬‫ﺗﻌﻤﻞ اﻟﻤﻮﻟﺪا ت‬
‫)‪4‬‬
‫ﺑﻞ أداء اﻟﻤﺠﻤﻮﻋﺎ ت اﻟﻌﺎدﻳ ﺔ ‪wrt:‬‬

‫اﻟﻤﻮﻟﺪا ت ﻣﻘﺎ‬
‫ﺘﻴﺮاد )‪3) 4‬أﺳﻤﺎء )‪'Chinny'، 'Vinny'] 5‬‬

‫ﺘﻴﺮاد ﻋﺸﻮاﺋ ﻲ )‪2‬وﻗ ﺖ اﻻﺳ‬
‫)‪1‬اﺳ‬
‫‪= ['Sunny'، 'Bunny'،‬اﻟﻤﻮﺿﻮﻋﺎ ت )‪def people_list (num_people): 8‬‬
‫ﺘﺎﺋﺞ )‪= [] 9‬ﻟـ ‪i‬ﻓ ﻲ اﻟﻨﻄﺎق‬
‫)‪= ['Python'، 'Java'، 'Blockchain'] 6) 7‬اﻟﻨ‬
‫‪10) person = { 11) 'id': i، 12) 'name': random.choice‬‬
‫ﺘﻴﺎر )اﻟﻤﻮﺿﻮﻋﺎ ت(‬
‫‪)(number_people):‬أﺳﻤﺎء( ‪'13) ،‬اﻟﻤﻮﺿﻮع'‪ :‬ﻋﺸﻮاﺋ ﻲ‪.‬اﺧ‬
‫ﺗﺤﺪﻳﺪ‬
‫ﺘﺎﺋﺞ )‪17) 18‬‬
‫ﺘﺎﺋﺞ‪.‬ﻟﺤﻖ )ﺷﺨﺺ( )‪16‬إرﺟﺎع اﻟﻨ‬
‫)‪14) } 15‬اﻟﻨ‬
‫ﺒ ﺔ ﻟـ ‪i‬ﻓ ﻲ اﻟﻨﻄﺎق )ﻋﺪد_اﻷﺷﺨﺎص(‪:‬‬
‫اﻷﺷﺨﺎص_اﻟﻤﻮﻟﺪ )ﻋﺪد_اﻷﺷﺨﺎص(‪19) :‬‬
‫)‪20‬ﺷﺨﺺ ‪)= { 21) 'id': i، 22) 'name': random.choice‬أﺳﻤﺎء( ‪،‬‬
‫‪188‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺴﻔﺮ)‪23‬‬
‫ﺗ)‪24‬‬
‫)‪25‬‬
‫)‪ 26‬ت({‬ ‫‪27) "" random.choice‬‬
‫)اﻟﻤﻮﺿﻮﻋﺎ‬ ‫ﺒﺮى'‪t1 = time.clock ():‬‬
‫'اﻟﻜ‬
‫ﻋﻦ ﺷﺨﺺ‬
‫)‪28‬اﻟﻨﺎس )‪= people_list (10000000‬‬

‫))‪t2 = time.clock () 34) 35) print ('Took {} '.format (t2-t1‬‬
‫)‪() 32) people = people_generator (10000000) 33‬‬
‫‪29) t2 = time.clock () "" 30) 31) t1 = time.clock‬‬
‫ﺘﺨﺪام اﻟﻘﺎﺋﻤ ﺔ واﻟﻤﻮﻟﺪا ت‬

‫ﺑﺎﺳ‬‫ﺘﻨﻔﻴﺬ‬
‫ﺘﻼف وﻗ ﺖ اﻟ‬
‫ﺒﺮﻧﺎﻣﺞ أﻋﻼه ‪ ،‬ﻻﺣﻆ اﺧ‬
‫ﺘﺨﺪام اﻟﺬاﻛﺮة‪:‬‬
‫ﺑﺎﺳ‬‫ﺑﻞ اﻟﻤﺠﻤﻮﻋﺎ ت اﻟﻌﺎدﻳ ﺔ‬
‫اﻟﻤﻮﻟﺪا ت ﻣﻘﺎ‬
‫اﻟﻤﺠﻤﻮﻋ ﺔ اﻟﻌﺎدﻳ ﺔ‪:‬‬

‫‪l = [x * x for x‬ﻓ ﻲ اﻟﻨﻄﺎق ])‪(10000000000000000‬‬
‫ﺒﺎﻋ ﺔ )ل )]‪[0‬‬
‫ﻃ‬
‫ﺘﺨﺰﻳﻦ ﻓ ﻲ اﻟﺬاﻛﺮة‪.‬‬
‫ﺑ ﺔ ﻟﻠ‬
‫ﺳﻨﺤﺼﻞ ﻋﲆ ‪MemoryError‬ﻓ ﻲ ﻫﺬه اﻟﺤﺎﻟ ﺔﻷن ﻛﻞ ﻫﺬه اﻟﻘﻴﻢ ﻣﻄﻠﻮ‬
‫ﺑﺎء‪:‬‬
‫ﻣﻮﻟﺪا ت ﻛﻬﺮ‬
‫‪g = (x * x for x‬ﻓ ﻲ اﻟﻨﻄﺎق ))‪(10000000000000000‬‬
‫ﺘﺎﻟ ﻲ )ز((‬
‫ﺒﺎﻋ ﺔ )اﻟ‬
‫ﻃ‬
‫اﻹﺧﺮاج‪0 :‬‬
‫ﺒﺪاﻳ ﺔ‬
‫ﺘﻢﺗﺨﺰﻳﻦ اﻟﻘﻴﻢ ﻓ ﻲ اﻟ‬
‫ﻟﻦ ﻧﺤﺼﻞ ﻋﲆ أي ﺧﻄﺄ ﻓ ﻲ ‪MemoryError‬ﻷﻧﻪ ﻟﻦﻳ‬

‫‪189‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺗﺄﻛﻴﺪا ت‬
‫‪190‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺘﺨﺪام ‪Assert Keyword:‬‬

‫ﺑﺎﺳ‬
‫ﺑﺮﻧﺎﻣﺞ ‪Python‬‬‫ﺗﺼﺤﻴﺢ أﺧﻄﺎء‬
‫ﺗ ﺴﻤﻰ ﻋﻤﻠﻴ ﺔﺗﺤﺪﻳﺪ اﻟﺨﻄﺄ وإﺻﻼﺣﻪﺗﺼﺤﻴﺢ اﻷﺧﻄﺎء‪.‬‬
‫ﺑﻴﺎﻧﺎ ت )(‬‫ﺑﻌﺪ إﺻﻼح اﻟﺨﻄﺄ ‪ ،‬إﻟﺰاﻣ ًﻴﺎ ﻋﻠﻴﻨﺎ ﺣﺬف‬‫ﺒﺎرة )( ‪ print‬ﻫ ﻲ‬

‫ﺒﺎرة ‪print ().‬ﻟﻜﻦ اﻟﻤﺸﻜﻠ ﺔ ﻓ ﻲ ﻋ‬
‫ﺘﺨﺪام ﻋ‬
‫ﺘﺼﺤﻴﺢ اﻷﺧﻄﺎء ﻫ ﻲ اﺳ‬
‫ﻃﺮﻳﻘ ﺔ ﺷﺎﺋﻌ ﺔ ﺟﺪًا ﻟ‬
‫ﺘﺸﻐﻴﻞ ﻣﻤﺎﻳﺆدي إﱃ ﺣﺪو ث ﻣﺸﻜﻼ ت ﻓ ﻲ اﻷداء وإزﻋﺎج إﺧﺮاج وﺣﺪة اﻟ‬
‫ﺘﻢﺗﻨﻔﻴﺬ ﻫﺎ ﻓ ﻲ وﻗ ﺖ اﻟ‬
‫‪print‬اﻹﺿﺎﻓﻴ ﺔ اﻟﻤﻀﺎﻓ ﺔ ‪ ،‬وإﻻ ﻓ ﺴﻴ‬
‫ﺒﻴﻦ‬
‫ﺑﻌﺪ إﺻﻼح اﻟﺨﻄﺄ ‪ ،‬ﻟ ﺴﻨﺎ ﻣﻄﺎﻟ‬‫ﺒﺎرة )( ‪ print‬ﻫ ﻲ‬
‫ﺒﺎرة ﻋﲆ ﻋ‬
‫ﺘﺄﻛﻴﺪ اﻟﻌ‬
‫ﺋﻴ ﺴﻴ ﺔ ﻟ‬
‫ﺘﺄﻛﻴﺪ‪ .‬اﻟﻤﻴﺰة اﻟﺮ‬
‫ﺑﻴﺎن اﻟ‬‫ﺘﻐﻠ ﺐ ﻋﲆ ﻫﺬه اﻟﻤﺸﻜﻠ ﺔﻳﺠ ﺐ أن ﻧﺬ ﻫ ﺐ إﱃ‬
‫ﻟﻠ‬
‫ﺘﺄﻛﻴﺪ‬
‫ﺗﻨﺎ ‪،‬ﻳﻤﻜﻨﻨﺎﺗﻤﻜﻴﻦ أوﺗﻌﻄﻴﻞ اﻟ‬
‫ﺒﺎ‬
‫ﺘﻄﻠ‬
‫ﺑﻨﺎ ًء ﻋﲆ ﻣ‬‫ﺘﺄﻛﻴﺪ‪.‬‬
‫ﺒﺎرا ت اﻟ‬
‫ﺑﺤﺬف ﻋ‬
‫ﺻﻴﺎﻏﺎ ت‪.‬‬
‫ﺒﺎر وﻟﻜﻦ‬
‫ﺘ‬‫ﺑﻴﺌﺎ ت اﻻﺧ‬‫ﺘﻄﻮﻳﺮ أو ﻓ ﻲ‬
‫ﺘﺄﻛﻴﺪا ت ﻫﻮ إﺟﺮاءﺗﺼﺤﻴﺢ اﻷﺧﻄﺎء‪ .‬ﻋﺎدةﻳﻤﻜﻨﻨﺎ إﺟﺮاءﺗﺼﺤﻴﺢ اﻷﺧﻄﺎء إﻣﺎ ﻓ ﻲ اﻟ‬
‫ﺋﻴ ﺴ ﻲ ﻣﻦ اﻟ‬
‫ﺛﻢ ﻓﺈن اﻟﻐﺮض اﻟﺮ‬‫وﻣﻦ‬
‫ﺘﺎج‪.‬‬
‫ﺒﻴﺌ ﺔ اﻹﻧ‬
‫ﺒﺎر وﻟﻜﻦ ﻟﻴ ﺲ ﻟ‬
‫ﺘ‬‫ﺘﻄﻮﻳﺮ واﻻﺧ‬
‫ﺑﻴﺌﺎ ت اﻟ‬‫ﺒﻖ ﻓﻘﻂ ﻋﲆ‬
‫ﺘﺄﻛﻴﺪا تﻳﻨﻄ‬
‫ﺛﻢ ﻓﺈن ﻣﻔﻬﻮم اﻟ‬‫ﺘﺎج‪ .‬وﻣﻦ‬
‫ﺑﻴﺌ ﺔ اﻹﻧ‬‫ﻟﻴ ﺲ ﻓ ﻲ‬
‫ﺘﺄﻛﻴﺪ‪:‬‬
‫أﻧﻮاع ﺟﻤﻞ اﻟ‬
‫ﺘﺄﻛﻴﺪ‬
‫ﺒﺎرا ت اﻟ‬
‫ﻫﻨﺎك ﻧﻮﻋﺎن ﻣﻦ ﻋ‬
‫ﺑ ﺴﻴﻄ ﺔ‬‫)‪1‬ﻧ ﺴﺨ ﺔ‬
‫)‪2‬اﻟﻨ ﺴﺨ ﺔ اﻟﻤﻌﺰزة‬
‫ﺑ ﺴﻴﻄ ﺔ‪:‬‬‫)‪1‬ﻧ ﺴﺨ ﺔ‬
‫ﺒﻴﺮ اﻟﺸﺮﻃ ﻲ‬
‫ﺘﻌ‬‫ﺗﺄﻛﻴﺪ اﻟ‬
‫)‪2‬اﻹﺻﺪار اﻟﻤﻌﺰز‪:‬‬
‫ﺒﻴﺮ اﻟﺸﺮﻃ ﻲ ‪ ،‬اﻟﺮﺳﺎﻟ ﺔ‬

‫ﺘﻌ‬‫ﺗﺄﻛﻴﺪ اﻟ‬
‫•‬
‫ﺒﺮﻧﺎﻣﺞ ﻛﺬﻟﻚ‬
‫ﺒﻴﺮ اﻟﺸﺮﻃ ﻲ وإذا ﻛﺎن ﺻﺤﻴﺤًﺎ ﻓ ﺴﻴﻜﻮن اﻟ‬
‫ﺘﻌ‬‫ﺘﻢﺗﻘﻴﻴﻢ اﻟ‬
‫•ﺳﻴ‬
‫واﺻﻠ ﺖ‪.‬‬
‫ﺒﺮﻣﺞﺗﺤﻠﻴﻞ اﻟﻜﻮد وﻳﻤﻜﻨﻪ إﺻﻼح‬

‫ﺑﺮﻓﻊ • ‪AssertionError.‬ﻣﻦ ﺧﻼل رؤﻳ ﺔ ‪AssertionError ،‬ﻳﻤﻜﻦ ﻟﻠﻤ‬‫ﺒﺮﻧﺎﻣﺞ‬
‫ﺘﻢ إﻧﻬﺎء اﻟ‬
‫•إذا ﻛﺎﻧ ﺖ ﺧﺎﻃﺌ ﺔ ‪ ،‬ﻓ ﺴﻴ‬
‫اﻟﻤﺸﻜﻠ ﺔ‪.‬‬
‫ﺑﻊ‬
‫ﺗﺄﻛﻴﺪ " ‪squareIt (2) == 4 ،‬ﻳﺠ ﺐ أنﻳﻜﻮن ﻣﺮ‬
‫)‪1) def squareIt (x): 2‬إرﺟﺎع )‪x ** x 3‬‬
‫‪16‬‬
‫ﺑﻊ‬‫)ﻣﺮ‬
‫ﺒﺎﻋ ﺎﺔ "‪،‬‬
‫))‪(3‬ﻃﻣﺮ‬
‫ﺑﻌً‬ ‫ﺗﺄﻛﻴﺪًا‬
‫ﺑﻊ‪8)3 9‬‬
‫)ﻣﺮ"‬
‫ﺒﺎﻋ ﺔ)‪5‬‬
‫اﻟﺮﻗﻢ‬
‫))‪(2‬ﻃ‬
‫ﻳﻜﻮن‬
‫ﺑﻊأن)‪7‬‬
‫ﺐ‬
‫ﻳﺠ)ﻣﺮ‬
‫ﺒﺎﻋ ﺔ‬
‫ﺑﻊ‬‫ﻣﺮ‬
‫‪4‬ﻃ‬ ‫‪squareIt‬‬
‫)‪16 " 6) (3‬‬
‫ﺑﻊ‬‫==ﻣﺮ‬
‫ﻳﻜﻮن‬
‫أن ‪9 ،‬‬
‫ﺗﺄﻛﻴﺪ "‬
‫ﻳﺠ ﺐ‬
‫)‪2(4‬‬
‫=="‪4‬‬
‫)‪4‬‬
‫)‪4) )) 9‬‬
‫‪)10) D: \ Python_classes> py test.py 11) Traceback‬آﺧﺮ ﻣﻜﺎﻟﻤ ﺔ أﺧﻴﺮة(‪12) :‬ﻣﻠﻒ‬

‫ﺑﻊ ‪3‬ﻳﺠ ﺐ‬
‫ﺑﻊ " ‪(3) == 9 ،‬ﻣﺮ‬
‫ﺘﺄﻛﻴﺪ ﻋﲆ اﻟﻤﺮ‬
‫‪"test.py" ،‬اﻟ ﺴﻄﺮ ‪4 ،‬ﻓ ﻲ )‪<module> 13‬اﻟ‬
‫أنﻳﻜﻮن " ‪9‬‬
‫‪191‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺑﻊ ‪ 3‬ﻫﻮ )‪9 15) 16) def squareIt (x): 17‬إرﺟﺎع‬

‫‪14) AssertionError:‬ﻳﺠ ﺐ أنﻳﻜﻮن ﻣﺮ‬
‫ﺗﺄﻛﻴﺪ " ‪squareIt (3) == 9 ،‬‬
‫ﺑﻊ )‪2 4" 19‬‬
‫ﺑﻊ " ‪(2) == 4 ،‬ﻳﺠ ﺐ أنﻳﻜﻮن ﻣﺮ‬
‫ﺗﺄﻛﻴﺪ اﻟﻤﺮ‬
‫)‪x * x 18‬‬
‫ﺑﻊ ))‪(squareIt (4‬‬
‫ﺑﻊ " ‪(4) == 16 ،‬ﻳﺠ ﺐ أنﻳﻜﻮن ﻣﺮ‬
‫ﺗﺄﻛﻴﺪ اﻟﻤﺮ‬
‫ﺑﻊ )‪3 9" 20‬‬
‫ﻳﺠ ﺐ أنﻳﻜﻮن ﻣﺮ‬
‫‪4 16" 21) print (squareIt (2)) 22) print ( SquareIt (3)) 23) print‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫‪4‬‬
‫‪9‬‬
‫‪16‬‬
‫ﺘﺄﻛﻴﺪا ت‪:‬‬
‫ﺑﻞ اﻟ‬
‫ﺜﻨﺎءا ت ﻣﻘﺎ‬
‫اﻟ‬
‫ﺘﻄﻮﻳﺮ‪.‬‬
‫ﺒﺮﻣﺞ ﻟﺤﻞ أﺧﻄﺎء وﻗ ﺖ اﻟ‬
‫ﺒﻴﻪ اﻟﻤ‬
‫ﺘﻨ‬‫ﺘﺄﻛﻴﺪا ت ﻟ‬
‫ﺘﺨﺪام ﻣﻔﻬﻮم اﻟ‬
‫ﺜﻨﺎءا ت ﻟﻤﻌﺎﻟﺠ ﺔ أﺧﻄﺎء وﻗ ﺖ اﻟ‬
‫ﺘ‬‫ﺘﺨﺪام ﻣﻌﺎﻟﺠ ﺔ اﻻﺳ‬
‫‪192‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺜﻮن‬
‫ﺑﺎﻳ‬
‫ﺗ ﺴﺠﻴﻞ‬
‫‪193‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘ ﺴﺠﻴﻞ‪.‬‬
‫ﺜﻨﺎءا ت ﻓ ﻲ ﻣﻠﻒ‪ .‬ﻫﺬه اﻟﻌﻤﻠﻴ ﺔﺗ ﺴﻤﻰ اﻟ‬
‫ﺘ‬‫ﺒﻴﻖ اﻟﻜﺎﻣﻞ وﻣﻌﻠﻮﻣﺎ ت اﻻﺳ‬
‫ﺘﻄ‬‫ﺘﺨﺰﻳﻦﺗﺪﻓﻖ اﻟ‬
‫ﺑ‬‫ﺑﺸﺪة‬‫ﻳﻮﺻﻰ‬
‫ﺘ ﺴﺠﻴﻞ ﻫ ﻲ‪:‬‬
‫ﺋﻴ ﺴﻴ ﺔ ﻟﻠ‬
‫اﻟﻤﺰاﻳﺎ اﻟﺮ‬
‫ﺘﺼﺤﻴﺢ‬
‫ﺛﻨﺎء إﺟﺮاء اﻟ‬
‫ﺘﺨﺪام ﻣﻠﻔﺎ ت اﻟ ﺴﺠﻞ أ‬
‫)‪1‬ﻳﻤﻜﻨﻨﺎ اﺳ‬
‫ﺒﺎ ت ﻓ ﻲ اﻟﻴﻮم وﻣﺎ إﱃ ذﻟﻚ‬
‫ﺜﻞ ﻋﺪد اﻟﻄﻠ‬
‫)‪2‬ﻳﻤﻜﻨﻨﺎﺗﻘﺪﻳﻢ إﺣﺼﺎءا ت ﻣ‬
‫ً‬
‫ﺴﺠﻴﻼ داﺧﻠ ًﻴﺎ ﻟﻠﻮﺣﺪة‪.‬‬ ‫ﺗ‬
‫ﺘ ﺴﺠﻴﻞ ‪،‬ﺗﻮﻓﺮ ‪Python‬‬
‫ﺘﻨﻔﻴﺬ اﻟ‬
‫ﻟ‬
‫ﺘ ﺴﺠﻴﻞ‪:‬‬
‫ﺘﻮﻳﺎ ت اﻟ‬
‫ﻣﺴ‬
‫ﺘﺎﻟﻴ ﺔ ﻓ ﻲ ‪Python‬‬
‫ﺘ ﺔ اﻟ‬ ‫ﺘ ﺴﺠﻴﻞ وﻓ ًﻘﺎ ﻟﻠﻤ ﺴ‬
‫ﺘﻮﻳﺎ ت اﻟ ﺴ‬ ‫ﺑﻴﺎﻧﺎ ت اﻟ‬‫ﺘﻢﺗﻘ ﺴﻴﻢ‬
‫ﺘﻤﺎدًا ﻋﲆ ﻧﻮع اﻟﻤﻌﻠﻮﻣﺎ ت ‪،‬ﻳ‬
‫اﻋ‬
‫)‪1‬اﻟﺤﺮﺟ ﺔ ‪50‬‬
‫ﺒﻴﺮ‬
‫ﺘﻤﺎم ﻛ‬
‫ﺘﺎج إﱃ ا ﻫ‬
‫ﺜﻞ ﻣﺸﻜﻠ ﺔ ﺧﻄﻴﺮة ﻟﻠﻐﺎﻳ ﺔﺗﺤ‬
‫ﻳﻤ‬
‫)‪2‬ﺧﻄﺄ ‪40‬‬
‫ﺜﻞ ﺧﻄﺄ ﺟ ﺴﻴﻢ‬
‫ﻳﻤ‬
‫ﺗﺤﺬﻳﺮ ‪30‬‬
‫)‪3‬‬
‫ﺒﺮﻣﺞ‪.‬‬
‫ﺑﻌﺾ اﻟﺤﺬر‪ .‬إﻧﻪ ﻓ ﻲ ﺣﺎﻟ ﺔﺗﺄ ﻫ ﺐ ﻟﻠﻤ‬‫ﺜﻞ رﺳﺎﻟ ﺔﺗﺤﺬﻳﺮ ‪،‬ﻳﻠﺰم‬
‫ﻳﻤ‬
‫‪4) INFO 20‬‬

‫ﺑﻌﺾ اﻟﻤﻌﻠﻮﻣﺎ ت اﻟﻬﺎﻣ ﺔ‬‫ﺜﻞ رﺳﺎﻟ ﺔ ﻣﻊ‬
‫ﻳﻤ‬
‫ﺗﺼﺤﻴﺢ ‪10‬‬
‫)‪5‬‬
‫ﺜﻞ رﺳﺎﻟ ﺔ ﻣﻊ ﻣﻌﻠﻮﻣﺎ ت اﻟ‬
‫ﻳﻤ‬
‫)‪6‬ﻣﺬﻛﺮة ‪0‬‬
‫ﺘﻢﺗﻌﻴﻴﻨﻪ‬
‫ﺘﻮى ﻟﻢﻳ‬
‫ﺜﻞ أن ﻫﺬا اﻟﻤ ﺴ‬
‫ﻳﻤ‬
‫ﺘﻮى اﻷﻋﲆ‪.‬‬
‫ﺘﻢ ﻋﺮضﺗﺤﺬﻳﺮ ﻓﻘﻂ ورﺳﺎﺋﻞ اﻟﻤ ﺴ‬
‫ﺑﺮﻧﺎﻣﺞ ‪Python ،‬ﺳﻴ‬‫ﺛﻨﺎءﺗﻨﻔﻴﺬ‬
‫ﺘﺮاﺿ ﻲ أ‬
‫ﺘ ﺴﺠﻴﻞ‪:‬‬
‫ﻛﻴﻔﻴ ﺔﺗﻨﻔﻴﺬ اﻟ‬
‫ﺘﻮى اﻟﺮﺳﺎﺋﻞ اﻟﻤﻄﻠﻮ بﺗﺨﺰﻳﻨﻬﺎ‪.‬‬ ‫ﺒﻨﺎ أوﻻ ً إﻧﺸﺎء ﻣﻠﻒ ﻟ‬
‫ﺘﺨﺰﻳﻦ اﻟﺮﺳﺎﺋﻞ وﻋﻠﻴﻨﺎﺗﺤﺪﻳﺪ ﻣ ﺴ‬ ‫ﺘ ﺴﺠﻴﻞ ‪ ،‬ﻃﻠ‬
‫ﻹﺟﺮاء اﻟ‬
‫ﺘﺨﺪام داﻟ ﺔ )( ‪basicConfig‬ﻟﻮﺣﺪة اﻟ‬
‫ﺑﺎﺳ‬‫ﺑﺬﻟﻚ‬‫ﻳﻤﻜﻨﻨﺎ اﻟﻘﻴﺎم‬
‫ﺘﻮى )‪= logging.WARNING‬‬
‫‪)logging.basicConfig‬اﺳﻢ اﻟﻤﻠﻒ ‪= 'log.txt' ،‬اﻟﻤ ﺴ‬
‫ﺘﻮى اﻷﻋﲆ ﻟﻬﺬا اﻟﻤﻠﻒ‪.‬‬

‫ﺘﺤﺬﻳﺮ أو اﻟﻤ ﺴ‬
‫ﺘﻮى اﻟ‬
‫ﺑﺈﻧﺸﺎء ﻣﻠﻒ ‪log.txt‬وﻳﻤﻜﻨﻨﺎﺗﺨﺰﻳﻦ رﺳﺎﺋﻞ ﻣ ﺴ‬‫ﺳﻴﻘﻮم اﻟ ﺴﻄﺮ أﻋﻼه‬

‫اﻟ‬
‫‪194‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫اﻟﻄﺎ‬
‫ﺑﺎﺳ‬‫ﺑ ﺔ اﻟﺮﺳﺎﺋﻞ إﱃ ﻫﺬا اﻟﻤﻠﻒ‬
‫ﺘﺎ‬
‫ﺑﻌﺪ إﻧﺸﺎء ﻣﻠﻒ اﻟ ﺴﺠﻞ ‪،‬ﻳﻤﻜﻨﻨﺎ ﻛ‬
‫‪) logging.debug‬رﺳﺎﻟ ﺔ(‬
‫‪) logging.info‬رﺳﺎﻟ ﺔ(‬
‫‪) logging. warning‬رﺳﺎﻟ ﺔ(‬
‫‪) logging. Error‬رﺳﺎﻟ ﺔ(‬
‫‪) logging.critical‬رﺳﺎﻟ ﺔ(‬
‫ﺘﻮى؟‬
‫ﺑ ﺔ رﺳﺎﺋﻞﺗﺤﺬﻳﺮ ورﺳﺎﺋﻞ أﻋﲆ ﻣ ﺴ‬
‫ﺘﺎ‬
‫ﺑﺮﻧﺎﻣﺞ ‪Python‬ﻹﻧﺸﺎء ﻣﻠﻒﺳﺠﻞ وﻛ‬‫ﺘﺐ‬
‫س( اﻛ‬
‫ﺘﻮى ‪5) logging.info‬‬

‫ﺘ ﺴﺠﻴﻞ ‪2) logging.basicConfig (filename = 'log.txt' ،‬اﻟﻤ ﺴ‬
‫)‪1‬اﺳ‬
‫)'‪= logging.WARNING) 3) print ('Logging Demo') 4) logging.debug ('Debug Information‬‬
‫ﺘ ﺴﺠﻴﻞ "(ﻣﻌﻠﻮﻣﺎ ت‬
‫ﺘﺤﺬﻳﺮ )‪") 7‬ﺧﻄﺄ ﻓ ﻲ اﻟ‬
‫) "ﻣﻌﻠﻮﻣﺎ ت اﻟﻤﻌﻠﻮﻣﺎ ت"( ‪")6) logging. warning‬ﻣﻌﻠﻮﻣﺎ ت اﻟ‬
‫اﻟﺨﻄﺄ"( ‪")8) logging.critical‬ﻣﻌﻠﻮﻣﺎ ت ﻣﻬﻤ ﺔ )"‬
‫‪log.txt:‬‬
‫ﺘﺤﺬﻳﺮ‬
‫ﺗﺤﺬﻳﺮ‪ :‬اﻟﺠﺬر‪ :‬ﻣﻌﻠﻮﻣﺎ ت اﻟ‬
‫ﺧﻄﺄ‪ :‬اﻟﺠﺬر‪ :‬ﻣﻌﻠﻮﻣﺎ ت اﻟﺨﻄﺄ‬
‫اﻟﺤﺮﺟ ﺔ‪ :‬اﻟﺠﺬر‪ :‬اﻟﻤﻌﻠﻮﻣﺎ ت اﻟﺤﺮﺟ ﺔ‬
‫ﺑﺔ‬
‫ﺘﺎ‬
‫ﺘﻢ ﻛ‬
‫ﺘﻮى ﻛـ ‪DEBUG ،‬ﻓ ﺴﻴ‬
‫ﺘﻮى اﻷﻋﲆ ﻓ ﻲ ﻣﻠﻒ اﻟ ﺴﺠﻞ‪ .‬إذا ﺣﺪدﻧﺎ اﻟﻤ ﺴ‬
‫ﺑ ﺔ رﺳﺎﺋﻞ اﻟﻤ ﺴ‬
‫ﺘﺎ‬
‫ﺘﻢ ﻛ‬
‫ﺘ‬‫ﺒﺮﻧﺎﻣﺞ أﻋﻼه ﻓﻘﻂﺗﺤﺬﻳﺮ وﺳ‬
‫ﺟﻤﻴﻊ اﻟﺮﺳﺎﺋﻞ ﻓ ﻲ ﻣﻠﻒ اﻟ ﺴﺠﻞ‪.‬‬
‫‪test.py‬‬
‫ﺘﻮى )‪3‬‬
‫ﺘ ﺴﺠﻴﻞ ‪)2) logging.basicConfig‬اﺳﻢ اﻟﻤﻠﻒ ‪= 'log.txt' ،‬اﻟﻤ ﺴ‬
‫)‪1‬اﺳ‬
‫ﺘﺼﺤﻴﺢ'(‬
‫ﺒﺎﻋ ﺔ '( ‪('Logging Demo') 4) logging.debug‬ﻣﻌﻠﻮﻣﺎ ت اﻟ‬
‫)‪= logging.DEBUG‬ﻃ‬
‫ﺘﺤﺬﻳﺮ )‪") 7‬ﺧﻄﺄ ﻓ ﻲ‬
‫‪" )5) logging.info‬ﻣﻌﻠﻮﻣﺎ ت اﻟﻤﻌﻠﻮﻣﺎ ت"( ‪")6) logging. warning‬ﻣﻌﻠﻮﻣﺎ ت اﻟ‬
‫ﺘ ﺴﺠﻴﻞ "(ﻣﻌﻠﻮﻣﺎ ت اﻟﺨﻄﺄ"( ‪")8) logging.critical‬ﻣﻌﻠﻮﻣﺎ ت ﻣﻬﻤ ﺔ )"‬
‫اﻟ‬
‫‪log.txt‬‬
‫ﺗﺼﺤﻴﺢ‪ :‬اﻟﺠﺬر‪ :‬ﻣﻌﻠﻮﻣﺎ ت اﻟ‬
‫‪INFO: root: info Information‬‬
‫‪195‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺑ ﺔ‪:‬‬
‫ﺘﺎ‬
‫ﻛﻴﻔﻴ ﺔﺗﻜﻮﻳﻦ ﻣﻠﻒ اﻟ ﺴﺠﻞ ﻓ ﻲ وﺿﻊ اﻟﻜ‬
‫ﺒﻴﺎﻧﺎ ت ‪،‬‬
‫ﺑ ﺔ ﻓﻮق اﻟ‬‫ﺑﺪﻻ ً ﻣﻦ إﻟﺤﺎﻗﻬﺎ إذا أردﻧﺎ اﻟﻜ‬
‫ﺘﺎ‬ ‫ﺘﺮاﺿ ﻲ‪.‬‬
‫ﺑﻤﻠﻒ اﻟ ﺴﺠﻞ‪ .‬إﻟﺤﺎق ﻫﻮ اﻟﻮﺿﻊ اﻻﻓ‬‫ﺘﺮاﺿﻴ ﺔ‬
‫ﺒﻴﺎﻧﺎ ت اﻻﻓ‬
‫ﺘﻢ إﻟﺤﺎق اﻟ‬
‫ﻓ ﻲ اﻟ‬
‫ﺘﺨﺪام ﺧﺎﺻﻴ ﺔ ‪filemode.‬‬
‫ﻓﻌﻠﻴﻨﺎ اﺳ‬
‫ﺘﻮى )‪= logging.WARNING‬‬

‫‪logging.basicConfig (filename = 'log786.txt' ،‬اﻟﻤ ﺴ‬
‫اﻟﻤﻘﺼﻮد ﻟﻺﻟﺤﺎق‬
‫ﺘﻮى )'‪= logging.WARNING ، filemode = 'a‬‬

‫ﺑﺼﺮاﺣ ﺔ ﻧﺤﺪد اﻹﻟﺤﺎق‪.‬‬‫ﻧﺤﻦ‬
‫ﺘﻮى )'‪= logging.WARNING ، filemode = 'w‬‬

‫ﺑﻘ ﺔ‪.‬‬
‫ﺒﻴﺎﻧﺎ ت اﻟ ﺴﺎ‬
‫ﺑ ﺔ اﻟ‬
‫ﺘﺎ‬
‫ﻳﻌﻨ ﻲ اﻹﻓﺮاط ﻓ ﻲ ﻛ‬
‫ﺘﻮى )‪= logging.DEBUG‬‬

‫‪)logging.basicConfig‬اﺳﻢ اﻟﻤﻠﻒ ‪= 'log.txt' ،‬اﻟﻤ ﺴ‬
‫ﺘﺮاﺿ ﻲ ﻫﻮﺗﺤﺬﻳﺮ )‪(30‬‬
‫ﺘﻮى اﻻﻓ‬
‫ﺘﻮى ‪ ،‬ﻓﺈن اﻟﻤ ﺴ‬
‫إذا ﻟﻢ ﻧﺤﺪد اﻟﻤ ﺴ‬
‫ﺒﺎﻋ ﺔ اﻟﺮﺳﺎﺋﻞ ﻋﲆ وﺣﺪة اﻟ‬
‫ﺘﻢ ﻃ‬
‫ﺘ‬‫إذا ﻟﻢ ﻧﺤﺪد اﺳﻢ اﻟﻤﻠﻒ ‪ ،‬ﻓ ﺴ‬
‫‪test.py‬‬
‫ﺘ ﺴﺠﻴﻞ ‪('info Information') 6) logging. warning‬‬

‫)‪1‬اﺳ‬
‫‪4) logging.debug ('Debug Information') 5) logging.info‬‬
‫ﺗﺤﺬﻳﺮ‬
‫)'‪')2) logging.basicConfig () 3) print ('Logging Demo‬‬
‫ﺘ ﺴﺠﻴﻞ "(ﻣﻌﻠﻮﻣﺎ ت اﻟﺨﻄﺄ"( )‪8‬اﻟ‬
‫اﻟﻤﻌﻠﻮﻣﺎ ت )‪') 7‬ﺧﻄﺄ ﻓ ﻲ اﻟ‬
‫ﺣﺮج )"اﻟﻤﻌﻠﻮﻣﺎ ت اﻟﻬﺎﻣ ﺔ )"‬

‫ﺒﻲ‬
‫ﺗ ﺴﺠﻴﻞﺗﺠﺮﻳ‬
‫ﻛﻴﻔﻴ ﺔﺗﻨ ﺴﻴﻖ رﺳﺎﺋﻞ اﻟ ﺴﺠﻞ‪:‬‬

‫ﺋﻴ ﺴﻴ ﺔ ‪،‬ﻳﻤﻜﻨﻨﺎﺗﻨ ﺴﻴﻖ اﻟﺮﺳﺎﺋﻞ‪.‬‬
‫ﺘﺨﺪام وﺳﻴﻄ ﺔﺗﻨ ﺴﻴﻖ اﻟﻜﻠﻤﺎ ت اﻟﺮ‬
‫ﺑﺎﺳ‬
‫ﺘﻮى ﻓﻘﻂ‪logging.basicConfig (format = '٪ (levelname) s') :‬‬

‫)‪1‬ﻟﻌﺮض اﺳﻢ اﻟﻤ ﺴ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﺗﺤﺬﻳﺮ‬
‫ﺧﻄﺄ‬
‫ﺷﺪﻳﺪ اﻷ ﻫﻤﻴ ﺔ‬
‫‪196‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺘﻮى واﻟﺮﺳﺎﻟ ﺔ‪:‬‬

‫)‪2‬ﻟﻌﺮض اﺳﻢ اﻟﻤ ﺴ‬
‫)'‪logging.basicConfig (format = '٪ (levelname) s:٪ (message) s‬‬
‫ﺗﺤﺬﻳﺮ اﻹﺧﺮاج ‪ :‬ﻣﻌﻠﻮﻣﺎ تﺗﺤﺬﻳﺮ ﺧﻄﺄ‪ :‬ﻣﻌﻠﻮﻣﺎ ت ﺧﻄﺄ‬
‫اﻟﺤﺮﺟ ﺔ‪ :‬اﻟﻤﻌﻠﻮﻣﺎ ت اﻟﻬﺎﻣ ﺔ‬
‫ﺑﻊ اﻟﺰﻣﻨ ﻲ ﻓ ﻲ رﺳﺎﺋﻞ اﻟ ﺴﺠﻞ‪:‬‬

‫ﻛﻴﻔﻴ ﺔ إﺿﺎﻓ ﺔ اﻟﻄﺎ‬
‫)'‪logging.basicConfig (format = '٪ (asctime) s:٪ (levelname) s:٪ (message) s‬‬
‫ﺘﺎج |‬
‫اﻧ‬
‫ﺗﺤﺬﻳﺮ‪ :‬ﻣﻌﻠﻮﻣﺎ تﺗﺤﺬﻳﺮ‬
‫‪2018-06-15 11: 50: 08،325:‬‬
‫‪2018-06-15 11: 50: 08،372:‬ﺧﻄﺄ‪ :‬ﻣﻌﻠﻮﻣﺎ ت اﻟﺨﻄﺄ‬
‫‪2018-06-15 11: 50: 08،372:‬ﺣ ﺴﺎﺳ ﺔ‪ :‬ﻣﻌﻠﻮﻣﺎ ت ﺣﺮﺟ ﺔ‬
‫ﺘﺎرﻳﺦ واﻟﻮﻗ ﺖ‪:‬‬

‫ﻛﻴﻔﻴ ﺔﺗﻐﻴﻴﺮﺗﻨ ﺴﻴﻖ اﻟ‬
‫ﺋﻴ ﺴﻴ ﺔ اﻟﺨﺎﺻ ﺔ‪datefmt :‬‬
‫ﺘﺨﺪام وﺳﻴﻄ ﺔ اﻟﻜﻠﻤﺎ ت اﻟﺮ‬
‫ﺘﻌﻴﻦ ﻋﻠﻴﻨﺎ اﺳ‬
‫ﻳ‬
‫'‪s:٪ (message) s'، datefmt = '٪ d /٪ m /٪ Y٪ I:٪ M:٪ S٪ p') datefmt = '٪ d /٪ m /٪ Y٪ I:٪ M:٪ S٪ p‬‬
‫)‪logging.basicConfig (format = '٪ (asctime) s:٪ (levelname‬اﻟﺤﺎﻟ ﺔ ﻣﻬﻤ ﺔ‬
‫ﺘﺎج |‬
‫اﻧ‬
‫‪15/06/2018 12:04:31‬م‪:‬ﺗﺤﺬﻳﺮ‪ :‬ﻣﻌﻠﻮﻣﺎ تﺗﺤﺬﻳﺮﻳ ﺔ‬
‫‪15/06/2018 12:04:31‬م‪ :‬ﺧﻄﺄ‪ :‬ﻣﻌﻠﻮﻣﺎ ت ﺧﻄﺄ‬
‫‪15/06/2018 12:04:31‬ﻣ ﺴﺎءً‪ :‬ﺣ ﺴﺎﺳ ﺔ‪ :‬ﻣﻌﻠﻮﻣﺎ ت ﺣﺮﺟ ﺔ‬
‫ﺗﻌﻨ ﻲ ﻣﻘﻴﺎس زﻣﻨ ﻲ ‪12‬ﺳﺎﻋ ﺔ‬
‫‪٪I‬‬
‫ﺗﻌﻨ ﻲ ﻣﻘﻴﺎس زﻣﻨ ﻲ ‪24‬ﺳﺎﻋ ﺔ‬
‫‪٪H‬‬
‫ﺜﺎل‪s:٪ (levelname) s:٪ (message) s'، datefmt = '٪ d /٪ m /٪ Y٪ H:٪ M:٪ S') :‬‬
‫ﻋﲆﺳ‬
‫)‪logging.basicConfig (format = '٪ (asctime‬‬
‫ﺘﺎج‪:‬‬
‫اﻧ‬
‫ﺗﺤﺬﻳﺮ‪ :‬ﻣﻌﻠﻮﻣﺎ تﺗﺤﺬﻳﺮ‬
‫‪15/06/2018 12: 06: 28:‬‬
‫‪15/06/2018 12: 06: 28:‬ﺧﻄﺄ‪ :‬ﻣﻌﻠﻮﻣﺎ ت ﺧﻄﺄ‬
‫‪15/06/2018 12: 06: 28:‬ﺣ ﺴﺎﺳ ﺔ‪ :‬ﻣﻌﻠﻮﻣﺎ ت ﺣﺮﺟ ﺔ‬
‫‪logging.html#logrecord-attributes https://docs.python.org/3/library/time.html#time.strftime‬‬
‫‪https://docs.python.org/3/library/‬‬
‫‪197‬‬
‫ﺑﺎد ‪- 500038 ،‬‬ ‫ﺑﻴ ﺖ‬ ‫ﺘﺮ‪#‬‬
‫ﻳﻔﺎﻧﺎم ‪ ،‬أﻣﻴﺮ‬ ‫‪202،‬‬ ‫ﺑﻖ ‪2 ،‬‬
‫ﺑﺮﻧﺎﻣﺞ ‪Python‬ﻓ ﻲ ﻣﻠﻒ اﻟ ﺴﺠﻞ‪:‬‬‫ﺜﻨﺎءا ت‬

‫ﺘ‬‫ﺑ ﺔ اﺳ‬
‫ﺘﺎ‬
‫ﻛﻴﻔﻴ ﺔ ﻛ‬
‫ﺜﻨﺎء إﱃ ﻣﻠﻒ اﻟ ﺴﺠﻞ‪.‬‬
‫ﺘ‬‫ﺑ ﺔ ﻣﻌﻠﻮﻣﺎ ت اﻻﺳ‬
‫ﺘﺎ‬
‫ﺘﺎﻟﻴ ﺔ ‪،‬ﻳﻤﻜﻨﻨﺎ ﻛ‬
‫ﺘﺨﺪام اﻟﻮﻇﻴﻔ ﺔ اﻟ‬
‫ﺑﺎﺳ‬
‫)‪logging.exception (msg‬‬
‫ﺜﻨﺎء إﱃ ﻣﻠﻒ اﻟ ﺴﺠﻞ‬

‫ﺘ‬‫ﺑ ﺔ ﻣﻌﻠﻮﻣﺎ ت اﻻﺳ‬
‫ﺘﺎ‬
‫ﺑﺮﻧﺎﻣﺞ ‪Python‬ﻟﻜ‬‫س(‬
‫ﺘﻨ ﺴﻴﻖ‬
‫ﺘﻮى ‪= logging.INFO ،‬اﻟ‬
‫ﺘ ﺴﺠﻴﻞ ‪)2) logging.basicConfig‬اﺳﻢ اﻟﻤﻠﻒ ‪= 'mylog.txt' ،‬اﻟﻤ ﺴ‬
‫)‪1‬اﺳ‬
‫‪= '٪ (asctime) s:‬‬
‫) ‪s:٪ (message) s '، datefmt ='٪ d /٪ m /٪ Y٪ I:٪ M:٪ S٪ p ') 3) logging.info (' A new Request Came ') 4‬‬
‫)‪٪ (levelname‬ﺟﺮ ب‪Number:')) 6) y = int (input ('Enter Second Number:')) print ('The Result:'، x / y) 7) 8 ) 9) :‬‬
‫ﺑﺼﻔﺮ'( )‪(msg) 12) 13‬‬‫ﺜﻨﺎء ‪')ZeroDivisionError as msg: 10) print‬ﻻﻳﻤﻜﻦ اﻟﻘ ﺴﻤ ﺔ‬
‫‪5) x = int (input ('Enter First‬‬
‫‪')msg: 14) print‬اﻟﺮﺟﺎءﺗﻮﻓﻴﺮ ﻗﻴﻢ ‪int‬ﻓﻘﻂ'( "( ‪16) 17) logging.info‬‬ ‫‪ValueError‬ﻛـ‬
‫اﻟﻄﻠ ﺐ"(‬ ‫ﺜﻨﺎءاﻛ‬
‫ﺘﻤﺎل ﻣﻌﺎﻟﺠ ﺔ‬ ‫ﺘ)‪15‬‬
‫ﺳ‬ ‫ﺑﺎ‬
‫‪11) logging.exception‬‬
‫‪logging.exception‬‬ ‫)‪(msg‬‬

‫أدﺧﻞ اﻟﺮﻗﻢ اﻷول‪10 :‬‬
‫ﺜﺎﻧ ﻲ‪2 :‬‬

‫ﺘﻴﺠ ﺔ‪5.0 :‬‬

‫اﻟﻨ‬

‫ﺜﺎﻧ ﻲ‪2 :‬‬

‫ﺘﻴﺠ ﺔ‪10.0 :‬‬

‫اﻟﻨ‬

‫ﺜﺎﻧ ﻲ‪0 :‬‬

‫ﻻﻳﻤﻜﻦ اﻟﻘ ﺴﻤ ﺔ ﻋﲆ اﻟﺼﻔﺮ‬

‫أدﺧﻞ اﻟﺮﻗﻢ اﻷول‪ :‬ﻋﺸﺮة‬
‫ﻳﺮﺟﻰﺗﻘﺪﻳﻢ ﻗﻴﻢ ‪int‬ﻓﻘﻂ‬
‫‪198‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫‪mylog.txt‬‬
‫‪15/06/2018 12:30:51 PM: INFO:‬وﺻﻞ ﻃﻠ ﺐ ﺟﺪﻳﺪ‬
‫ﺘﻤﻠ ﺖ ﻣﻌﺎﻟﺠ ﺔ اﻟﻄﻠ ﺐ‬
‫‪15/06/2018 12:30:53‬ﻣ ﺴﺎءً‪INFO: :‬اﻛ‬
‫‪15/06/2018 12:30:55‬ﻣ ﺴﺎءً‪INFO: :‬وﺻﻞ ﻃﻠ ﺐ ﺟﺪﻳﺪ‬
‫‪15/06/2018 12:31:00‬ﻣ ﺴﺎءً‪INFO: :‬اﻛ‬
‫‪15/06/2018 12:31:02‬م‪ :‬ﻣﻌﻠﻮﻣﺎ ت‪ :‬ﺟﺎء ﻃﻠ ﺐ ﺟﺪﻳﺪ‬
‫‪15/06/2018 12:31:05‬م‪ :‬ﺧﻄﺄ‪ :‬اﻟﻘ ﺴﻤ ﺔ ﻋﲆ ﺻﻔﺮ‬
‫ﺘﻴﺠ ﺔ‪ ، ":‬س ‪ /‬ص(‬
‫ﺒﺎﻋ ﺔ )"اﻟﻨ‬
‫ﻃ‬
‫‪15/06/2018 12:31:05‬ﻣ ﺴﺎءً‪INFO: :‬اﻛ‬
‫‪15/06/2018 12:31:06‬ﻣ ﺴﺎءً‪INFO: :‬ﺟﺎء ﻃﻠ ﺐ ﺟﺪﻳﺪ‬
‫ﺑﺎﻷﺳﺎس '‪10: 'ten‬‬
‫‪15/06/2018 12:31:10‬ﻣ ﺴﺎءً‪ :‬ﺧﻄﺄ‪ :‬ﺣﺮﻓ ﻲ ﻏﻴﺮ ﺻﺎﻟﺢ ﻟـ )( ‪int‬‬
‫‪')x = int (input‬أدﺧﻞ اﻟﺮﻗﻢ اﻷول‪((':‬‬
‫‪ValueError:‬ﺣﺮﻓﻴ ﺔ ﻏﻴﺮ ﺻﺎﻟﺤ ﺔ ﻟـ )( ‪int‬ذا ت اﻷﺳﺎس '‪10: 'ten‬‬
‫‪15/06/2018 12:31:10‬ﻣ ﺴﺎءً‪INFO: :‬اﻛ‬
‫ﻣﺸﺎﻛﻞ ﻣﻊ ‪Root Logger:‬‬

‫ﺒﺎر ﻣ ﺴﺠﻞ اﻟﺠﺬر اﻻﻓ‬
‫ﺑﻨﺎ ‪ ،‬ﻓ ﺴﻴ‬‫ﺘﻌﺮﻳﻒ اﻟﻤ ﺴﺠﻞ اﻟﺨﺎص‬
‫ﺑ‬‫إذا ﻟﻢ ﻧﻘﻢ‬
‫ﺘﻜﻮﻳﻨﺎ ت وﻻﻳﻤﻜﻨﻨﺎﺗﻐﻴﻴﺮ ﻫﺎ‪.‬‬
‫ﺘﻢ إﺻﻼح اﻟ‬
‫ﺘﻜﻮﻳﻦ اﻷﺳﺎﺳ ﻲ ﻟﻤ ﺴﺠﻞ اﻟﺠﺬر ‪،‬ﻳ‬
‫ﺑﻤﺠﺮد إﺟﺮاء اﻟ‬
‫ﺒ ﻲ‪:‬‬
‫ﺒﻴﻖﺗﺠﺮﻳ‬
‫ﺗﻄ‬
‫‪student.py:‬‬
‫ﺘ ﺴﺠﻴﻞ '( ‪(filename = 'student.log'، level = logging.INFO) 3) logging.info‬‬

‫)‪1‬اﺳ‬
‫‪2) logging.basicConfig‬رﺳﺎﻟ ﺔ ﻣﻌﻠﻮﻣﺎ ت ﻣﻦ وﺣﺪة اﻟﻄﺎﻟ ﺐ'(‬
‫‪test.py:‬‬
‫ﺘﻴﺮاد اﻟﻄﺎﻟ ﺐ '( ‪'test.log'، level = logging.DEBUG) 4) logging.debug‬‬

‫ﺘ ﺴﺠﻴﻞ )‪2‬اﺳ‬
‫)‪1‬اﺳ‬
‫ﺒﺎر'(‬
‫ﺘ‬‫ﺘﺼﺤﻴﺢ ﻣﻦ وﺣﺪة اﻻﺧ‬
‫= ‪3) logging.basicConfig (filename‬رﺳﺎﻟ ﺔ اﻟ‬
‫‪student.log:‬‬
‫‪INFO:‬اﻟﺠﺬر‪ :‬رﺳﺎﻟ ﺔ ﻣﻌﻠﻮﻣﺎ ت ﻣﻦ وﺣﺪة اﻟﻄﺎﻟ ﺐ‬
‫‪199‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
‫ﺑﺎﻟﻔﻌﻞ ﻓ ﻲ وﺣﺪة اﻟﻄﺎﻟ ﺐ‪.‬‬‫ﺒﺎر ‪،‬ﻷن ﻣ ﺴﺠﻞ اﻟﺠﺬر ﻗﺪﺗﻢﺗﻜﻮﻳﻨﻪ‬

‫ﺘ‬‫ﺘ ﻲﺗﻢ إﺟﺮاؤ ﻫﺎ ﻓ ﻲ وﺣﺪة اﻻﺧ‬
‫ﺘﻜﻮﻳﻨﺎ ت اﻟ‬
‫ﺒﻴﻖ أﻋﻼه ‪ ،‬ﻟﻦﺗﻨﻌﻜ ﺲ اﻟ‬
‫ﺘﻄ‬‫ﻓ ﻲ اﻟ‬
‫اﻟﺤﺎﺟ ﺔ إﱃ ﻣ ﺴﺠﻞ ﻟﺪﻳﻨﺎ ﻣﺨﺼﺺ‪:‬‬

‫ﻣﺸﺎﻛﻞ ﻣ ﺴﺠﻞ اﻟﺠﺬر ﻫ ﻲ‪:‬‬
‫ﺘﻜﻮﻳﻦ ﻧﻬﺎﺋ ًﻴﺎ وﻻﻳﻤﻜﻨﻨﺎﺗﻐﻴﻴﺮه‪.‬‬

‫ﺘﻜﻮﻳﻦ اﻷﺳﺎﺳ ﻲ ‪،‬ﻳﻜﻮن ﻫﺬا اﻟ‬
‫ﺑﻤﺠﺮدﺗﻌﻴﻴﻦ اﻟ‬
‫)‪1‬‬
‫ﺋﻤﺎ ﻣﻊ ﻣﻌﺎﻟﺞ واﺣﺪ ﻓﻘﻂ ﻓ ﻲ ﻛﻞ ﻣﺮة ‪ ،‬إﻣﺎ وﺣﺪةﺗﺤﻜﻢ أو ﻣﻠﻒ ‪ ،‬وﻟﻜﻦ ﻟﻴ ﺲ ﻛﻼ ﻫﻤﺎ‬
‫ﺘﻌﻤﻞ دا ً‬
‫)‪2‬ﺳ‬
‫ﻣﻌً ﺎ‪.‬‬
‫ﺘﻠﻔ ﺔ‪.‬‬
‫ﺘﻮﻳﺎ ت ﻣﺨ‬
‫ﺘﻠﻔ ﺔ ﻋﲆ ﻣ ﺴ‬
‫)‪3‬ﻻﻳﻤﻜﻦﺗﻜﻮﻳﻦ اﻟﻤ ﺴﺠﻞ ﻣﻊﺗﻜﻮﻳﻨﺎ ت ﻣﺨ‬
‫ﺘﻌﺪدة‪.‬‬
‫ﺘﻌﺪدة ﻟﻮﺣﺪا ت ‪ /‬ﻓﺌﺎ ت ‪ /‬ﻃﺮق ﻣ‬
‫)‪4‬ﻻﻳﻤﻜﻨﻨﺎﺗﺤﺪﻳﺪ ﻣﻠﻔﺎ تﺗ ﺴﺠﻴﻞ ﻣ‬
‫ﺑﻨﺎ‬‫ﺘﺎر أدوا ت ﻗﻄﻊ اﻷﺷﺠﺎر اﻟﻤﺨﺼﺼ ﺔ اﻟﺨﺎﺻ ﺔ‬

‫ﺘﻐﻠ ﺐ ﻋﲆ ﻫﺬه اﻟﻤﺸﺎﻛﻞ ‪،‬ﻳﺠ ﺐ أن ﻧﺨ‬
‫ﻟﻠ‬
‫ﺘﻘﺪﻣ ﺔ‪ :‬اﻟﻤ ﺴﺠﻞ‪:‬‬

‫ﺘ ﺴﺠﻴﻞ اﻟﻤ‬
‫ﻣﻴﺰا ت وﺣﺪة اﻟ‬
‫ﺘ ﺴﺠﻴﻞ اﻷﺳﺎﺳ ﻲ‪.‬‬
‫ﺗﻘﺪﻣﺎ ﻣﻦ اﻟ‬
‫ً‬ ‫ﺜﺮ‬
‫اﻟﻤ ﺴﺠﻞ أﻛ‬
‫ﺘﺨﺪاﻣﻪ وﻳﻮﻓﺮ اﻟﻌﺪﻳﺪ ﻣﻦ اﻟﻤﻴﺰا ت اﻹﺿﺎﻓﻴ ﺔ‪.‬‬
‫ﺑﺎﺳ‬‫ﺑﺸﺪة‬‫ﻳﻮﺻﻰ‬
‫ﺘﻘﺪم‪:‬‬
‫ﺘ ﺴﺠﻴﻞ اﻟﻤ‬
‫ﺧﻄﻮا ت اﻟ‬
‫ﺘﻮى اﻟ ﺴﺠﻞ‪.‬‬
‫ﺗﻌﻴﻴﻦ ﻣ ﺴ‬
‫)‪1‬إﻧﺸﺎء ﻛﺎﺋﻦ اﻟﻤ ﺴﺠﻞ و‬
‫)‪('demologger') logger.setLevel (logging.INFO‬‬
‫‪logger = logging.getLogger‬‬
‫ﺘﻮى اﻟ ﺴﺠﻞ‪.‬‬
‫ﺗﻌﻴﻴﻦ ﻣ ﺴ‬
‫)‪2‬إﻧﺸﺎء ﻛﺎﺋﻦ ﻣﻌﺎﻟﺞ و‬
‫ﺜﻞ ‪StreamHandler‬و ‪FileHandler‬وﻣﺎ إﱃ ذﻟﻚ‪.‬‬

‫)‪ 3‬ﻫﻨﺎك ﻋﺪة أﻧﻮاع ﻣﻦ اﻟﻤﻌﺎﻟﺠﺎ ت ﻣ‬
‫)‪() consoleHandler.setLevel (logging.INFO‬‬
‫‪ConsoleHandler = logging.StreamHandler‬‬
‫ﺒﺎﻋ ﺔ رﺳﺎﺋﻞ اﻟ ﺴﺠﻞ ﻋﲆ وﺣﺪة اﻟ‬
‫ﺘﻢ ﻃ‬
‫ﺘ‬‫ﺘﺨﺪﻣﻨﺎ ‪StreamHandler ،‬ﻓ ﺴ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬إذا اﺳ‬
‫ﺘ ﺴﺠﻴﻞ‪ .‬اﻟﻤﻨ ﺴﻖ )' ‪-٪ (name) s -٪ (levelname) s:٪ (message) s' ، datefmt = '٪ d /٪ m /٪ Y٪ I:٪ M:٪ S٪ p‬‬
‫)‪4‬إﻧﺸﺎء ﻛﺎﺋﻦ ﻣﻨ ﺴﻖ‪ .‬اﻟﻤﻨ ﺴﻖ =اﻟ‬
‫‪('٪ (asctime) s‬‬
‫)‪5‬إﺿﺎﻓ ﺔ اﻟﻤﻨ ﺴﻖ إﱃ اﻟﻤﻌﺎﻟﺞ ‪) consoleHandler.setFormatter‬اﻟﻤﻨ ﺴﻖ(‬
‫ﺘﺤﻜﻢ(‬
‫)‪6‬إﺿﺎﻓ ﺔ ﻣﻌﺎﻟﺞ إﱃ اﻟﻤ ﺴﺠﻞ ‪) logger.addHandler‬وﺣﺪة اﻟ‬
‫ﺘﺼﺤﻴﺢ'(‬
‫ﺘﺎﻟﻴ ﺔ ‪')logger.debug‬رﺳﺎﻟ ﺔ اﻟ‬
‫ﺘﺨﺪام ﻛﺎﺋﻦ اﻟﻤ ﺴﺠﻞ واﻷﺳﺎﻟﻴ ﺐ اﻟ‬
‫ﺑﺎﺳ‬‫ﺑ ﺔ اﻟﺮﺳﺎﺋﻞ‬
‫ﺘﺎ‬
‫)‪7‬ﻛ‬
‫‪')logger.info‬رﺳﺎﻟ ﺔ اﻟﻤﻌﻠﻮﻣﺎ ت'(‬
‫‪200‬‬
‫ﺑﺎد ‪- 500038 ،‬‬ ‫ﺑﻴ ﺖ‬ ‫ﺘﺮ‪#‬‬
‫ﻳﻔﺎﻧﺎم ‪ ،‬أﻣﻴﺮ‬ ‫‪202،‬‬ ‫ﺑﻖ ‪2 ،‬‬
‫ﺗﺤﺬﻳﺮ اﻟﺮﺳﺎﻟ ﺔ"(‬

‫‪")logger.warn‬‬
‫‪")logger.error‬رﺳﺎﻟ ﺔ ﺧﻄﺄ"(‬
‫‪")logger.critical‬رﺳﺎﻟ ﺔ ﺣﺮﺟ ﺔ"(‬
‫ﺗﻨﺎ‪.‬‬
‫ﺒﺎ‬
‫ﺘﻄﻠ‬
‫ﺑﻨﺎ ًء ﻋﲆ ﻣ‬‫ﺑﻨﺎ‬‫ﺘﻮى اﻟﺨﺎص‬
‫ﺘﻮى ‪WARNING.‬وﻟﻜﻦﻳﻤﻜﻨﻨﺎﺗﺤﺪﻳﺪ اﻟﻤ ﺴ‬
‫ﺘﻢﺗﻌﻴﻴﻨﻪ ﻋﲆ ﻣ ﺴ‬
‫ﻣﻼﺣﻈ ﺔ‪Bydefault logger :‬ﺳﻴ‬
‫)'‪logger = logging.getLogger ('demologger‬‬

‫)‪logger.setLevel (logging.INFO‬‬
‫ﺘﻮى‬
‫ﺘﻮى اﻟﻤ ﺴﺠﻞ ‪ ،‬ﻓﻴﻤﻜﻨﻨﺎﺗﻌﻴﻴﻦ ﻣ ﺴ‬
‫ﺘﺤﻜﻢ وﻣﻌﺎﻟﺠﺎ ت اﻟﻤﻠﻔﺎ ت‪ .‬إذا ﻟﻢ ﻧﻜﻦ راﺿﻴﻦ ﻋﻦ ﻣ ﺴ‬
‫ﺘﺮاﺿ ًﻴﺎ ﻟﻮﺣﺪة اﻟ‬
‫ﺘﻮىﺳﺠﻞ اﻟﻤ ﺴﺠﻞ اﻓ‬
‫ﺘﻮﻓﺮ ﻣ ﺴ‬
‫ﻳ‬
‫ﺘﻮﻳﺎ ت اﻟﻤﻠﻒ‪.‬‬
‫ﺘﺤﻜﻢ وﻣ ﺴ‬
‫ﺘﻮى وﺣﺪة اﻟ‬
‫ﺑﺸﻜﻞ ﺻﺮﻳﺢ ﻋﲆ ﻣ ﺴ‬‫اﻟ ﺴﺠﻞ‬
‫ﺘﺤﻜﻢ )( ‪= logging.StreamHandler‬‬
‫وﺣﺪة اﻟ‬
‫ﺗ ﺴﺠﻴﻞﺗﺤﺬﻳﺮ(‬
‫‪)consoleHandler.setLevel‬‬
‫‪fileHandler = logging.FileHandler ('abc.log' ،‬اﻟﻮﺿﻊ )'‪= 'a‬‬

‫)‪fileHandler.setLevel (logging.ERROR‬‬
‫ﺘﻮىﺳﺠﻞ اﻟﻤ ﺴﺠﻞ أﻗﻞ ﻣﻦ‬

‫ﺜﺎل ‪،‬ﻳﺠ ﺐ أنﻳﻜﻮن ﻣ ﺴ‬
‫ﺘﺤﻜﻢ وﺳﺠﻞ اﻟﻤﻠﻒ‪ .‬ﻋﲆﺳ‬
‫ﺘﻮﻳﺎ ت وﺣﺪة اﻟ‬
‫ﻣﻼﺣﻈ ﺔ‪:‬ﻳﺠ ﺐ أنﻳﺪﻋﻢ اﻟﻤ ﺴﺠﻞ ﻣ ﺴ‬
‫ﺘﻮىﺳﺠﻞ اﻟﻤ ﺴﺠﻞ‪.‬‬
‫ﺘﻢ اﻟﻨﻈﺮ ﻓﻘﻂ ﻓ ﻲ ﻣ ﺴ‬
‫ﺘﺤﻜﻢ واﻟﻤﻠﻒ‪ .‬ﺧﻼف ذﻟﻚ ‪،‬ﺳﻴ‬
‫ﺘﻮﻳﺎ ت وﺣﺪة اﻟ‬
‫ﻣﺴ‬
‫ﺒﺎر ‪INFO‬‬
‫‪ DEBUG‬ﺻﺎﻟﺢ وﺳﻴ‬ ‫ﺘﺤﻜﻢ ﻓ ﻲ ‪INFO‬‬
‫وﺣﺪة اﻟ‬ ‫ﺜﺎل‪ :‬اﻟﻤ ﺴﺠﻞ‬
‫ﻋﲆﺳ‬
‫ﺒﺎر ‪INFO‬ﻓﻘﻂ ﻟﻮﺣﺪة اﻟ‬
‫‪INFO‬ﻏﻴﺮ ﺻﺎﻟﺢ وﺳﻴ‬ ‫ﺘﺤﻜﻢ ‪DEBUG‬‬
‫وﺣﺪة اﻟ‬ ‫اﻟﻤ ﺴﺠﻞ‬
‫ﺘﺤﻜﻢ‪:‬‬
‫ﺒ ﻲ ﻟﻤﻌﺎﻟﺞ وﺣﺪة اﻟ‬
‫ﺘﻴﺮاد )‪2‬ﻓﺌ ﺔ )‪= '٪ m /٪ d /٪ Y٪ I:٪ M:٪ S٪ p') 13) 14) 15‬‬
‫ﺗ ﺴﺠﻴﻞ اﻻﺳ‬
‫)‪1‬‬
‫‪5) 6) 7) 8) 9) 10) 11) ٪ (levelname) s:٪ (message) s '، 12) datefmt‬‬
‫‪LoggerDemoConsole: 3) 4) def testLog (self):‬‬
‫)‪('demologger') logger.setLevel (logging.INFO‬‬

‫‪logger = logging.getLogger‬‬
‫)‪() consoleHandler.setLevel (logging.INFO‬‬

‫‪ConsoleHandler = logging.StreamHandler‬‬
‫ﺘ ﺴﺠﻴﻞ‪ .‬اﻟﻤﻨ ﺴﻖ ‪('٪ (asctime) s -٪ (name) s -‬‬

‫اﻟﻤﻨ ﺴﻖ =اﻟ‬
‫ﺘﺤﻜﻢ(‬
‫‪)consoleHandler.setFormatter‬اﻟﻤﻨ ﺴﻖ( اﻟﻤ ﺴﺠﻞ ‪) reldnaHdda.‬وﺣﺪة اﻟ‬
‫‪201‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
() ‫ﺘﻮﺿﻴﺤ ﻲ‬
‫اﻟﻌﺮض اﻟ‬16) ("‫ﺘﺼﺤﻴﺢ‬
17) 18) 19) 20)
‫ﺳﺎﻟ ﺔ اﻟ‬ 21) 22)
‫ر‬logger.debug ("
LoggerDemoConsole () 23)
Error (' ('‫ت‬ demo.testLog
‫اﻟﻤﻌﻠﻮﻣﺎ‬ ‫رﺳﺎﻟ ﺔ‬logger.info ('
= logger.
logger.warn ('warn message')
('‫رﺳﺎﻟ ﺔ ﺣﺮﺟ ﺔ‬logger.critical (' ('‫رﺳﺎﻟ ﺔ ﺧﻄﺄ‬
D: \ durgaclasses> py loggingdemo3.py
‫رﺳﺎﻟ ﺔ ﻣﻌﻠﻮﻣﺎ ت‬- demologger - INFO: ‫ﻣ ﺴﺎ ًء‬06/18/2018 12:14:15
‫ رﺳﺎﻟ ﺔﺗﺤﺬﻳﺮ‬:‫ﺗﺤﺬﻳﺮ‬
- demologger - ‫ﻣ ﺴﺎ ًء‬06/18/2018 12:14:15
‫ رﺳﺎﻟ ﺔ ﺧﻄﺄ‬:‫ﺧﻄﺄ‬- demologger - ‫ﻣ ﺴﺎ ًء‬06/18/2018 12:14:15
‫ رﺳﺎﻟ ﺔ ﺣﺮﺟ ﺔ‬:‫ﺣﺮج‬- demologger - ‫ﻣ ﺴﺎ ًء‬06/18/2018 12:14:15
(LoggerDemoConsole .__ name__) ‫ﺘﺎﻟ ﻲ‬

‫ ﻓﻌﻠﻴﻨﺎ إﻧﺸﺎء ﻛﺎﺋﻦ اﻟﻤ ﺴﺠﻞ ﻋﲆ اﻟﻨﺤﻮ اﻟ‬، ‫ﺘﺨﺪام اﺳﻢ اﻟﻔﺌ ﺔ ﻛﺎﺳﻢ اﻟﻤ ﺴﺠﻞ‬
‫ إذا أردﻧﺎ اﺳ‬:‫ﻣﻼﺣﻈ ﺔ‬
logger = logging.getLogger
:‫ﺗﺞ‬
D: \ durgaclasses> py loggingdemo3.py
‫رﺳﺎﻟ ﺔ ﻣﻌﻠﻮﻣﺎ ت‬- LoggerDemoConsole - INFO: ‫ﻣ ﺴﺎ ًء‬06/18/2018 12:21:00
‫ رﺳﺎﻟ ﺔﺗﺤﺬﻳﺮ‬:‫ﺗﺤﺬﻳﺮ‬
- LoggerDemoConsole - ‫ﻣ ﺴﺎ ًء‬06/18/2018 12:21:00
‫ رﺳﺎﻟ ﺔ ﺧﻄﺄ‬:‫ﺧﻄﺄ‬- LoggerDemoConsole - ‫ﻣ ﺴﺎ ًء‬06/18/2018 12:21:00
‫ رﺳﺎﻟ ﺔ ﺣﺮﺟ ﺔ‬:‫ﺣﺮﺟ ﺔ‬LoggerDemoConsole - ‫ﺘﺤﻜﻢ‬
‫وﺣﺪة اﻟ‬- ‫ﻣ ﺴﺎ ًء‬06/18/2018 12:21:00
:‫ﺒ ﻲ ﻟﻤﻌﺎﻟﺞ اﻟﻤﻠﻔﺎ ت‬

٪ (levelname) s:٪ (message) s '، datefmt ='٪ ‫ﻓﺌ ﺔ‬2) ‫ﺘﻴﺮاد‬

1)
LoggerDemoConsole: 3) 4) def testLog (self): 5) 6) 7) 8) 9) 10) 11)
٪ d /٪ Y٪ I:٪ M:٪ S٪ p ') 12) 13) 14) 15) 16)/ ‫م‬
= logging.getLogger ('demologger') logger.setLevel (logging.INFO)

logger
(logging.INFO) ‫اﻟﻮﺿﻊ‬fileHandler = logging.FileHandler ('abc.log' ،

= 'a') fileHandler.setLevel
('٪ (asctime) s -٪ (name) s - ‫ اﻟﻤﻨ ﺴﻖ‬.‫ﺘ ﺴﺠﻴﻞ‬

‫اﻟﻤﻨ ﺴﻖ =اﻟ‬
(fileHandler) (‫)اﻟﻤﻨ ﺴﻖ‬fileHandler.setFormatter

logger.addHandler

202 - 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﺘﻮﺿﻴﺤ ﻲ )(‬
‫اﻟﻌﺮض)'اﻟ‬ ‫ﺗﺼﺤﻴﺢ )‪17) 18‬‬
‫‪logger.info‬‬ ‫)‪21‬ﺔ)‪19) 20‬‬ ‫)‪22‬‬
‫)'رﺳﺎﻟ‬ ‫)‪23‬‬
‫‪logger.debug‬‬
‫‪= LoggerDemoConsole‬‬ ‫‪() 24) demo.testLog‬‬
‫‪') logger.warn‬رﺳﺎﻟ ﺔﺗﺤﺬﻳﺮ'(‬ ‫)'رﺳﺎﻟ ﺔ ﻣﻌﻠﻮﻣﺎ ت '(‬
‫'( ‪logger.errorn‬رﺳﺎﻟ ﺔ ﺧﻄﺄ'( '( ‪logger.critical‬‬
‫رﺳﺎﻟ ﺔ ﺣﺮﺟ ﺔ'(‬
‫‪abc.log:‬‬
‫‪07/05/2018 08:58:04 AM - demologger - INFO: info message‬‬
‫ﺗﺤﺬﻳﺮ‪ :‬رﺳﺎﻟ ﺔﺗﺤﺬﻳﺮ‬
‫‪07/05/2018 08:58:04 AM - demologger -‬‬
‫‪07/05/2018 08:58:04 AM - demologger -‬ﺧﻄﺄ‪ :‬رﺳﺎﻟ ﺔ ﺧﻄﺄ‬
‫‪07/05/2018 08:58:04 AM - demologger -‬ﺣﺮﺟ ﺔ‪ :‬رﺳﺎﻟ ﺔ ﺣﺮﺟ ﺔ‬
‫ﺘﻜﻮﻳﻦ‪:‬‬
‫اﻟﻤ ﺴﺠﻞ ﻣﻊ ﻣﻠﻒ اﻟ‬
‫ﺘﻜﻮﻳﻦ‬
‫ﺑ ﺔ داﺧﻞ ﻣﻠﻒ اﻟ‬
‫ﺘﻬﻴﺌ ﺔ ﺟﻤﻴﻊ اﻷﺷﻴﺎء اﻟﻤﻄﻠﻮ‬
‫ﺑ‬‫ﺑﺮﻣﺠ ﺔ ﺟﻴﺪة‪.‬ﺳﻨﻘﻮم‬‫ﺜﻮن‪ .‬إﻧﻬﺎ ﻟﻴ ﺴ ﺖ ﻣﻤﺎرﺳ ﺔ‬
‫ﺑﺎﻳ‬‫ﺘﺮﻣﻴﺰه ﻓ ﻲ ﻧﺺ‬
‫ﺑ‬‫ﺒﺮﻧﺎﻣﺞ أﻋﻼه ‪ ،‬ﻛﻞ ﺷ ﻲء ﻗﻤﻨﺎ‬
‫ﻓ ﻲ اﻟ‬
‫ﺑﺮﻧﺎﻣﺠﻨﺎ‪.‬‬‫ﺒﺎﺷﺮة ﻓ ﻲ‬
‫ﺘﺨﺪام ﻫﺬا اﻟﻤﻠﻒ ﻣ‬
‫وﻳﻤﻜﻨﻨﺎ اﺳ‬
‫)'‪logging.config.fileConfig ('logging.conf‬‬
‫)__‪logger = logging.getLogger (LoggerDemoConf .__ name‬‬
‫ﺜﻞ ‪txt‬أو ‪durga‬وﻣﺎ إﱃ ذﻟﻚ‪.‬‬

‫ﺘﺪاد ﻣ‬
‫ﺘﺨﺪام أي اﻣ‬
‫ﺘﺪاد اﻟﻤﻠﻒ ‪conf.‬ﻳﻤﻜﻨﻨﺎ اﺳ‬
‫ﻣﻼﺣﻈ ﺔ‪ :‬ﻻﻳﻠﺰم أنﻳﻜﻮن اﻣ‬
‫‪logging.conf‬‬
‫ﺑﻴﻦ[‬
‫]اﻟﺤﻄﺎ‬
‫ﺗﻴﺢ =اﻟﺠﺬر ‪LoggerDemoConf ،‬‬
‫ﻣﻔﺎ‬
‫]ﻣﻌﺎﻟﺠﺎ ت[‬
‫ﺗﻴﺢ ‪= fileHandler‬‬
‫ﻣﻔﺎ‬
‫]اﻟﻤﻨ ﺴﻘﻮن[‬
‫ﺑ ﺴﻴﻂ‬‫ﺗﻨ ﺴﻴﻖ‬
‫ﺗﻴﺢ =‬
‫ﻣﻔﺎ‬
‫]‪[logger_root‬‬
‫ﺗﺼﺤﻴﺢ‬
‫ﺘﻮى =‬
‫اﻟﻤ ﺴ‬
‫ﻣﻌﺎﻟﺠﺎ ت ‪= fileHandler‬‬
‫]‪[logger_LoggerDemoConf‬‬
‫ﺘﻮى =‬
‫اﻟﻤ ﺴ‬
‫ﻣﻌﺎﻟﺠﺎ ت ‪= fileHandler‬‬
‫‪Qualname = demoLogger‬‬
‫‪203‬‬
‫ﺑﺎد ‪- 500038 ،‬‬
‫اﻟﻄﺎ‬
[handler_fileHandler]
= FileHandler ‫ﻓﺌ ﺔ‬
= ‫ﺘﻮى‬
‫اﻟﻤ ﺴ‬
= ‫اﻟﻤﻨ ﺴﻖ‬
args = ('test.log'، 'w')
[‫ﺒ ﺴﻴﻂ‬
‫]ﻣﻨ ﺴﻖ_اﻟ‬
=٪ (asctime) s -٪ (name) s -٪ (levelname) s -٪ (message) s ‫ﺘﻨ ﺴﻴﻖ‬
‫اﻟ‬
datefmt =٪ m /٪ d /٪ Y٪ I:٪ M:٪ S٪ p
test.py
(LoggerDemoConf .__ name__ ) 7) 8) 9) 10) 11) 12) 13) 14) ‫ﺘ ﺴﺠﻴﻞ‬

‫اﺳ‬1)
(self): 5) logging.config.fileConfig ('logging.conf') 6) logger = logging.getLogger
‫اﻟﻌﺮض‬2) import logging.config 3) class LoggerDemoConf (): 4) def testLog
= LoggerDemoConf () 15) demo.testLog () ‫ﺘﻮﺿﻴﺤ ﻲ‬
‫اﻟ‬
') logger.info ‫)'رﺳﺎﻟ ﺔﺗﺼﺤﻴﺢ‬logger.debug

('‫ )'رﺳﺎﻟ ﺔﺗﺤﺬﻳﺮ‬logger.warn (' ‫)'رﺳﺎﻟ ﺔ ﻣﻌﻠﻮﻣﺎ ت‬
logger.critical (' ('‫رﺳﺎﻟ ﺔ ﺧﻄﺄ‬logger.errorn ('
('‫رﺳﺎﻟ ﺔ ﺣﺮﺟ ﺔ‬
test.log
‫رﺳﺎﻟ ﺔ اﻟ‬06/18/2018 12:40:05 PM - LoggerDemoConf - DEBUG -
‫رﺳﺎﻟ ﺔ ﻣﻌﻠﻮﻣﺎ ت‬- LoggerDemoConf - INFO - ‫ﻣ ﺴﺎ ًء‬06/18/2018 12:40:05
‫رﺳﺎﻟ ﺔﺗﺤﺬﻳﺮ‬- ‫ﺗﺤﺬﻳﺮ‬
06/18/2018 12:40:05 PM - LoggerDemoConf -
‫رﺳﺎﻟ ﺔ ﺧﻄﺄ‬- ‫ﺧﻄﺄ‬- LoggerDemoConf - ‫م‬06/18/2018 12:40:05
‫ﺣﺮﺟ ﺔ‬- ‫رﺳﺎﻟ ﺔ ﺣﺮﺟ ﺔ‬06/18/2018 12:40:05 PM - LoggerDemoConf -
‫ﺘﻮى اﻟ ﺴﺠﻞ ﻛﻤﻌﻠﻮﻣﺎ ت‬

‫ﺒﻂ ﻣ ﺴ‬
‫ﻟﻀ‬1: ‫اﻟﺤﺎﻟ ﺔ‬
= INFO ‫ﺘﻮى‬
‫اﻟﻤ ﺴ‬
args = ('test.log'، 'w')
204
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫ﺒﻂ وﺿﻊ اﻹﻟﺤﺎق‬

‫ﻟﻀ‬2: ‫اﻟﺤﺎﻟ ﺔ‬
= INFO ‫ﺘﻮى‬
‫اﻟﻤ ﺴ‬
args = ('test.log'، 'a')
:‫إﻧﺸﺎء ﻣ ﺴﺠﻞ ﻣﺨﺼﺺ‬
customlogger.py
4) :(‫ﺘﻮى‬
‫)اﻟﻤ ﺴ‬3) def getCustomLogger ‫ﺘﻴﺮاد‬
‫ﻓﺤﺺ اﻻﺳ‬2) ‫ﺘﻴﺮاد‬
1)
logger.setLevel ‫ اﻟﻄﺮﻳﻘ ﺔ ﻣﻦ ﺣﻴ ﺚﺗ ﺴﻤﻰ ﻫﺬه اﻟﻄﺮﻳﻘ ﺔ‬/ ‫اﺣﺼﻞ ﻋﲆ اﺳﻢ اﻟﻔﺌ ﺔ‬#
= inspect.stack () [1] [3] 6) logger = logging.getLogger (loggername) 7)
('abc.log'، mode = 'a') 10) fileHandler.setLevel (‫ﺘﻮى‬
‫)اﻟﻤ ﺴ‬5) loggername
s -٪ (name) s - ‫اﻟﻤﻨ ﺴﻖ‬11) 12) (‫ﺘﻮى‬
‫)اﻟﻤ ﺴ‬8) 9) fileHandler = logging.FileHandler
= logging.Formatter ('٪ (asctime)
s '، datefmt ='٪ m /٪ d /٪ Y ٪ I:٪ M:٪ S٪ p ') 13) fileHandler.setFormatter

14) logger.addHandler ( fileHandler) 15) 16) (‫)اﻟﻤﻨ ﺴﻖ‬٪ (levelname) s: ٪ (message)
‫ﻋﻮدة اﻟﻤ ﺴﺠﻞ‬
test.py
message') 7) ‫ﺘﻴﺮاد‬
‫اﺳ‬Customlogger ‫ﻣﻦ‬2) ‫ﺘ ﺴﺠﻴﻞ‬
‫اﺳ‬1)
(logging.DEBUG) 6) logger.debug ('m1: debug
LoggingDemo: 4) def m1 (self): 5) logger = getCustomLogger
getCustomLogger (logging. .‫اﻟﻤ ﺴﺠﻞ‬getCustomLogger 3) class
('m1 :itical message')
9) logger.error ('m1: error11) def m2 (self):
message') 12) logger =
10) logger.critical
('m1: info message') 8) logger.warn ('m1: warn message')
(‫ﺗﺤﺬﻳﺮ‬
info
205 - 500038 ، ‫ﺑﺎد‬

‫اﻟﻄﺎ‬
logger.warn
debug ('m2:14)
message') warn message')
logger.info 16)info
('m2: logger.error
message')('m2:
15)
17)logger.debug
20) logger.critical(' ('m3:
m2:debug
‫ﺳﺎﻟ ﺔ ﺧﻄﺄ‬‫ر‬13) logger.debug
message ') 21) ‫'( ﺔ ﺣﺮﺟ ﺔ‬m2:
‫)'رﺳﺎﻟ‬
(self):
28) 19)
l.m1logger = getCustomLogger
() 29) l.m2 (logging.ERROR)
() 30) l.m3 () .‫ﺴﺠﻞ‬ ‫ )'اﻟﻤ‬18) def m3
l = LoggingDemo
message') () 27) print
24) logger.critical ("Custom
('m3 Logger Demo")
:itical message') 25) 26)
('m3: warn
infomessage')
('m3: info 23) logger.error
message') ('m3: error
22) logger.warn
abc.log:
‫رﺳﺎﻟ ﺔ اﻟ‬- m1 - DEBUG: m1: ‫ﻣ ﺴﺎ ًء‬06/19/2018 12:17:19
‫رﺳﺎﻟ ﺔ ﻣﻌﻠﻮﻣﺎ ت‬- m1 - INFO: m1: ‫ﻣ ﺴﺎ ًء‬06/19/2018 12:17:19
‫رﺳﺎﻟ ﺔﺗﺤﺬﻳﺮ‬m1: :‫ﺗﺤﺬﻳﺮ‬
- m1 - ‫ﻣ ﺴﺎ ًء‬06/19/2018 12:17:19
‫رﺳﺎﻟ ﺔ ﺧﻄﺄ‬m1: :‫ﺧﻄﺄ‬- m1 - ‫ﻣ ﺴﺎ ًء‬06/19/2018 12:17:19
‫رﺳﺎﻟ ﺔ ﺣﺮﺟ ﺔ‬m1: :‫ﺣﺮج‬- m1 - ‫ﻣ ﺴﺎ ًء‬06/19/2018 12:17:19
- ‫ﺑﻊ‬
‫ﺘﺮ ﻣﺮ‬
‫ﻣ‬- ‫ﻣ ﺴﺎ ًء‬06/19/2018 12:17:19
‫ رﺳﺎﻟ ﺔ ﺣﺮﺟ ﺔ‬:‫ﺑﻊ‬
‫ﺘﺮ ﻣﺮ‬
‫ ﻣ‬:‫ﺣﺮج‬- ‫ﺑﻊ‬
‫ﺘﺮ ﻣﺮ‬
‫ﻣ‬- ‫ﻣ ﺴﺎ ًء‬06/19/2018 12:17:19
:‫ﺘﺼﻞ‬
‫ﺑﻨﺎ ًء ﻋﲆ اﻟﻤ‬‫ﻛﻴﻔﻴ ﺔ إﻧﺸﺎء ﻣﻠﻒﺳﺠﻞ ﻣﻨﻔﺼﻞ‬
6) logger.setLevel :(‫ﺘﻮى‬
‫ﻓﺤﺺ اﻻﺳ‬2) ‫ﺘ ﺴﺠﻴﻞ‬
‫اﺳ‬1)
4) loggername = inspect.stack () [1] [3] 5) logger = logging.getLogger (loggername)
('{}. log'.format (loggername) ، mode =' a ') 9) fileHandler.setLevel (‫ﺘﻮى‬
‫)اﻟﻤ ﺴ‬
10) (‫ﺘﻮى‬
‫)اﻟﻤ ﺴ‬7 ) 8) fileHandler = logging.FileHandler
206
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
('٪ (asctime) s -٪ (name) s - ‫ اﻟﻤﻨ ﺴﻖ‬.‫ﺘ ﺴﺠﻴﻞ‬

‫اﻟﻤﻨ ﺴﻖ =اﻟ‬11)
(message) s '، datefmt ='٪ m /٪ d /٪ Y ٪ I:٪ M:٪ S٪ p ') 12) fileHandler.setFormatter
‫ﻋﻮدة اﻟﻤ ﺴﺠﻞ‬13) logger.addHandler ( fileHandler) 14) 15) (‫)اﻟﻤﻨ ﺴﻖ‬٪ (levelname) s: ٪
test.py:
‫ﺑﻖ‬
‫ﻛﺎﻟ ﺴﺎ‬#
message') 7) ‫ﺘﻴﺮاد‬
‫اﺳ‬1)
(logging.DEBUG) 6) logger.debug ('m1: debug
LoggingDemo: 4) def m1 (self): 5) logger = getCustomLogger
') 17) logger.critical (' m2: .‫اﻟﻤ ﺴﺠﻞ‬getCustomLogger 3) class
('m2 : warn
message') 14) message ') 16)
logger.info logger.error
('m2: (' m2:15)
info message') error message
logger.warn
(logging.WARNING)
message') 13)logger
11) def m2 (self): 12) logger.debug ('m2: debug
= getCustomLogger
logger.error
('m1: info ('m1: error 8)
message') message') 10) logger.critical
logger.warn ('m1 :itical
('m1: warn message') 9)
('m3: error message') ) ('m3:
22) logger.warn 24) logger.critical
warn message')('m3:
23)‫ﺣﺮﺟ ﺔ‬ ‫رﺳﺎﻟ ﺔ‬info
logger.error
('m3: debug message') 21)
= getCustomLogger logger.info ('m3:
(logging.ERROR) 20 )info message')
logger.debug
LoggingDemo
() 30) ('‫)( ﻣﻨﻔﺼﻞ‬
‫ﺳﺠﻞ‬27) ‫ﻣﻠﻒ‬
('‫ﺣﺮﺟ ﺔ‬ ‫ﺳﺎﻟ ﺔ‬
‫ﺘﺨﺪام‬ ‫ﺳ‬‫ﺑﺎر‬
') ‫ﺴﺠﻴﻞ‬
18) def m3 (self):
‫)'ﻋﺮضﺗ‬ ‫ﻃ‬19)
‫ﺒﺎﻋ ﺔ‬ 25)logger
26) l =
m3 () .‫ﺘﺮ‬
‫ﻟ‬28) l.m1 () 29) l.m2
m1.log
‫رﺳﺎﻟ ﺔ اﻟ‬m1: :‫ﺗﺼﺤﻴﺢ‬
- m1 - ‫ﻣ ﺴﺎ ًء‬06/19/2018 12:26:04
‫رﺳﺎﻟ ﺔ ﻣﻌﻠﻮﻣﺎ ت‬- m1 - INFO: m1: ‫ﻣ ﺴﺎ ًء‬06/19/2018 12:26:04
- m1 - ‫م‬06/19/2018 12:26:04
207
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫رﺳﺎﻟ ﺔ ﺧﻄﺄ‬m1: :‫ﺧﻄﺄ‬- M1 - ‫م‬2018/06/19 12:26:04

m2.log
‫رﺳﺎﻟ ﺔﺗﺤﺬﻳﺮ‬2: ‫ م‬:‫ﺗﺤﺬﻳﺮ‬
- ‫م‬- ‫م‬2018/06/19 12:26:04
m3.log
‫رﺳﺎﻟ ﺔ ﺣﺮﺟ ﺔ‬3: ‫ م‬:‫ﺣﺮج‬3 - ‫م‬- ‫م‬06/19/2018 12:26:04
:‫ﻣﺰاﻳﺎ اﻟﻤ ﺴﺠﻞ اﻟﻤﺨﺼﺺ‬

.‫ﺘﻄﻠ ﺐ اﻟﻤ ﺴﺠﻞ‬
‫ﺣﻴ ﺚﻳ‬customlogger ‫ﺘﺨﺪام ﻧﻔ ﺲ ﻛﻮد‬
‫ﻳﻤﻜﻨﻨﺎ إﻋﺎدة اﺳ‬1)
‫ﺘﺼﻞﻳﻤﻜﻨﻨﺎ إﻧﺸﺎء ﻣﻠﻒﺳﺠﻞ ﻣﻨﻔﺼﻞ‬
‫ﻟﻜﻞ ﻣ‬2)
.‫ﺘﻠﻔ ﺔ ﻣﻦ اﻟ ﺴﺠﻞ‬
‫ﺘﻮﻳﺎ ت ﻣﺨ‬
‫ﻳﻤﻜﻨﻨﺎﺗﻌﻴﻴﻦ ﻣ ﺴ‬، ‫ﺘﻠﻔﻴﻦ‬
‫ﺒ ﺔ ﻟﻠﻤﻌﺎﻟﺠﻴﻦ اﻟﻤﺨ‬
3)
:‫ﺜﺎل آﺧﺮ ﻟﻠﻤﻌﺎﻟﺞ اﻟﻤﺨﺼﺺ‬

‫ﻣ‬
customlogger.py:
:(‫ﺘﻮى‬
‫ﻓﺤﺺ اﻻﺳ‬2) ‫ﺘ ﺴﺠﻴﻞ‬
‫اﺳ‬1)
() [1] [3] 5) 6) logger = logging.getLogger (loggername) 7) logger.setLevel
mode = 'a') 9) fileHandler.setLevel ( ‫ﺘﻮى‬
‫)ﻣ ﺴ‬4) loggername = inspect.stack
(name) s - ‫اﻟﻤﻨ ﺴﻖ‬10) (‫ﺘﻮى‬
‫)اﻟﻤ ﺴ‬8) fileHandler = logging.FileHandler ('test.log'،
= logging.Formatter ('٪ (asctime) s -٪
s: ٪ (message) s '، datefmt ='٪ m /٪ d /٪ Y ٪ I:٪ M:٪ S٪ p ') 11) fileHandler.setFormatter

‫ﻋﻮدة اﻟﻤ ﺴﺠﻞ‬12) logger.addHandler ( fileHandler) 13) (‫)اﻟﻤﻨ ﺴﻖ‬٪ (levelname)
test.py
3) class Test: 4) def logtest (self): 5) ‫ﻣﻦ‬2) ‫ﺘ ﺴﺠﻴﻞ‬

‫اﺳ‬1)
customlogger import getCustomLogger
= getCustomLogger (logging.DEBUG) ‫اﻟﻤ ﺴﺠﻞ‬
208
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬
‫رﺳﺎﻟ ﺔ‬7) logger.info

logger.error (' ('‫ﺘﺼﺤﻴﺢ‬
(' ('‫ﺳﺎﻟ ﺔﺗﺤﺬﻳﺮ‬ ‫رﺳﺎﻟ ﺔ اﻟ‬6) logger.debug
‫ر‬8) logger.warning ('
(' ('‫اﻟﻤﻌﻠﻮﻣﺎ ت‬
‫ﺒﺎر‬
‫ﺘ‬‫ )"اﺧ‬11) t = ‫) "رﺳﺎﻟ ﺔ ﺣﺮﺟ ﺔ‬10) logger.critical ('‫ﺧﻄﺄ‬
() 12) ‫رﺳﺎﻟ ﺔ‬9)()
t.logtest
student.py:
6) logger.info (' ‫ﺘﻴﺮاد‬

‫اﺳ‬1)
(logging.ERROR) 5) logger.debug ('debug message')
3) def studentfunction (): 4) logger = getCustomLogger
‫)'رﺳﺎﻟ ﺔ‬7 ) logger. warning ('‫رﺳﺎﻟ ﺔ ﻣﻌﻠﻮﻣﺎ ت‬getCustomLogger
('‫رﺳﺎﻟ ﺔ ﺣﺮﺟ ﺔ‬9) logger.critical (' ('‫ )'رﺳﺎﻟ ﺔ ﺧﻄﺄ‬8) logger.error (' ‫ﺗﺤﺬﻳﺮ‬
10) studentfunction ()
(logging.CRITICAL) :‫ﺘﺎﻟ ﻲ‬
‫ﺘ ﺴﺠﻴﻞ ﻋﲆ اﻟﻨﺤﻮ اﻟ‬
‫ﺋ ﻲ ﻣﻦ اﻟ‬
‫ﺘﻮى ﺟﺰ‬
‫ﻳﻤﻜﻨﻨﺎﺗﻌﻄﻴﻞ ﻣ ﺴ‬:‫ﻣﻼﺣﻈ ﺔ‬
logging.disable
209
- 500038 ، ‫ﺑﺎد‬
‫اﻟﻄﺎ‬

Advanced Python Material PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Advanced Python Material PDF

Uploaded by

Copyright:

Available Formats

‫‪Machine Translated by Google‬‬

‫ﺜﺎﻧﻴ ﺔ ‪040 - 64 51 27 86، 80 96 96 96 96، 92 46 21 21 43 | www.durgasoft.com‬‬ ‫اﻟ‬

‫ﺒﺎﻋ ﺔ زرﻗﺎء ‪ ،‬و ﻫ ﻲ ﻟﻴ ﺴ ﺖﺳﻮى ﻓﺌ ﺔ‪.‬‬

‫ﺜﻴﻞ ﺧﺼﺎﺋﺺ )ﺳﻤﺎ ت( وأﻓﻌﺎل )ﺳﻠﻮك(‬

‫ﺑﻨﺎء اﻟﺠﻤﻠ ﺔ‪:‬‬

‫ﺒﺎﻋ ﺔ )__‪(classname .__ doc‬‬

‫ﺒﻊ )اﻟﻄﺎﻟ ﺐ ‪__.‬‬

‫ﺜﺎﻧﻴ ﺔ دورﺟﺎﺳﻮﻓ ﺖ ‪ ،‬رﻗﻢ ‪202 ، 2‬‬‫اﻟ‬

‫ﺑﻬﺎ‬‫ﺘﻠﻔ ﺔ ﻣﻦ اﻟﻄﺮق اﻟﻤ ﺴﻤﻮح‬

‫)‪1‬ﻃﺎﻟ ﺐ ﻓﺌ ﺔ ‪2) :‬‬

‫)‪print ("My Marks are:"، self.marks‬‬

‫ﺑﻨﺎء اﻟﺠﻤﻠ ﺔ ﻹﻧﺸﺎء ﻛﺎﺋﻦ‪Referencevariable = classname () :‬‬

‫ﺜﺎل‪s = Student () :‬‬

‫ﺘﻐﻴﺮ اﻟﻤﺮﺟﻌ ﻲ؟‬

‫ﺑﺮﻧﺎﻣﺞ ‪Python‬ﻹﻧﺸﺎء ﻓﺼﻞ دراﺳ ﻲ ﻟﻠﻄﻼ ب وإﻧﺸﺎء ﻛﺎﺋﻦ ﻟﻪ‪.‬‬‫ﺘﺐ‬

‫‪class Student: 2) 3) def __init __ (self، name، rollno،‬‬

‫‪= rollno self.marks‬‬

‫ﺜﺎﻧﻴ ﺔ دورﺟﺎﺳﻮﻓ ﺖ ‪ ،‬رﻗﻢ ‪202 ، 2‬‬‫اﻟ‬

‫‪3‬‬ ‫ﺑﺎد ‪- 500038 ،‬‬

‫= ‪8) def talk (self): 9) 10) 11) 12) 13) s1‬‬

‫ﻣﻔﻬﻮم اﻟﻤﻨﺸ ﺊ‪:‬‬

‫ﺘﻢ إﺧﺮاجُﻣﻨﺸ ﺊ ﻛﻞ ﻛﺎﺋﻦ ﻣﺮة واﺣﺪة ﻓﻘﻂ‪.‬‬

‫= ‪= name 3) self.rollno = rollno 4) self.marks‬‬

‫ﺜﺎﻧﻴ ﺔ دورﺟﺎﺳﻮﻓ ﺖ ‪ ،‬رﻗﻢ ‪202 ، 2‬‬‫اﻟ‬

‫اﻟﻤﻨﺸ ﺊ ﻣﺮة واﺣﺪة ﻓﻘﻂ ﻟﻜﻞ ﻛﺎﺋﻦ‪:‬‬

‫ﺒﺎر اﻟﺼﻨﻒ ‪def m1 (self): 7) print ("Method :‬‬

‫)‪1‬ﻓﺌ ﺔ اﻟﻄﺎﻟ ﺐ‪2) 3) "" " :‬‬

‫ﺑ ﺔ ‪= z 8) 9) def display (self): 10) print ("Student Name: {} \ nRollno: {} \ n‬‬

‫= ‪12) s1‬ﻃﺎﻟ ﺐ )"دورﺟﺎ"‪s1.display () 14) s2 = ،‬‬

‫ﺜﺎﻧﻴ ﺔ دورﺟﺎﺳﻮﻓ ﺖ ‪ ،‬رﻗﻢ ‪202 ، 2‬‬‫اﻟ‬

‫اﺳﻢ اﻟﻄﺎﻟ ﺐ‪ :‬ﺻﻨ ﻲ‬

‫ﺑﻴﻦ اﻟﻄﺮق واﻟﻤﻨﺸﺌﺎ ت‬‫ﺘﻼﻓﺎ ت‬

‫ﺘﺪﻋﺎء ﻫﺬه اﻟﻄﺮﻳﻘ ﺔ‬

‫ﺘﻐﻴﺮا ت اﻟﺤﺎﻟ ﺔ ﻟﻜﻞ ﻛﺎﺋﻦ‪.‬‬

‫)‪1‬ﻣﻮﻇﻒ اﻟﻔﺌ ﺔ ‪self.ename = 'Durga' :‬‬

‫ﺜﺎﻧﻴ ﺔ دورﺟﺎﺳﻮﻓ ﺖ ‪ ،‬رﻗﻢ ‪202 ، 2‬‬‫اﻟ‬

‫اﻹﺧﺮاج‪{'eno': 100، 'ename': 'Durga'، 'esal': 10000} :‬‬

‫ﺒﺎر اﻟﻔﺌ ﺔ ‪12) print (t .__ict__) :‬‬

‫اﻹﺧﺮاج‪{'a': 10، 'b': 20، 'c': 30} :‬‬

‫ﺘﻐﻴﺮ ﻣﺮﺟﻊ اﻟﻜﺎﺋﻦ‪:‬‬

‫ﺒﺎر اﻟﻔﺌ ﺔ ‪12) print (t .__ict__) :‬‬

‫اﻹﺧﺮاج }‪{'a': 10، 'b': 20، 'c': 30، 'd': 40‬‬

‫ﺜﺎﻧﻴ ﺔ دورﺟﺎﺳﻮﻓ ﺖ ‪ ،‬رﻗﻢ ‪202 ، 2‬‬‫اﻟ‬

‫ﺒﺎر اﻟﺼﻨﻒ ‪9) 10) t = :‬‬

‫ﺒﺎر اﻟﻔﺌ ﺔ ‪t = Test () 11) :‬‬

‫ﺜﺎﻧﻴ ﺔ دورﺟﺎﺳﻮﻓ ﺖ ‪ ،‬رﻗﻢ ‪202 ، 2‬‬‫اﻟ‬

‫}'أ'‪ '10 ، :‬ب'‪'20 ، :‬ج'‪30} :‬‬

‫}"أ"‪ "10 ، :‬ب"‪20} :‬‬

‫ﺘ ﻲﺗﻢ ﺣﺬﻓﻬﺎ ﻣﻦ ﻛﺎﺋﻦ واﺣﺪ ﻣﻦ اﻟﻜﺎﺋﻨﺎ ت اﻷﺧﺮى‪.‬‬

‫ﺒﺎر اﻟﻔﺌ ﺔ ‪12) print (t2 .__ict__) :‬‬

‫)__‪10) del t1.a 11) print (t1 .__ict‬‬

‫‪2) def __init __ (self):‬‬

‫}' ب'‪'20 ، :‬ج'‪'30 ، :‬د'‪40} :‬‬

‫}'أ'‪ '10 ، :‬ب'‪'20 ، :‬ج'‪'30 ، :‬د'‪40} :‬‬

‫ﺒﺎر اﻟﻔﺌ ﺔ ‪print ('t2:'، t2.a، t2.b) :‬‬

‫)‪() 10) print ('t1:'، t1.a، t1.b) 11‬‬

‫)‪def __init __ (self): 3) self.a = 10 2‬‬

‫ﺜﺎﻧﻴ ﺔ دورﺟﺎﺳﻮﻓ ﺖ ‪ ،‬رﻗﻢ ‪202 ، 2‬‬‫اﻟ‬

‫ﺑﻮاﺳﻄ ﺔ ﺟﻤﻴﻊ اﻟﻜﺎﺋﻨﺎ ت‬‫ﺘﻬﺎ‬

‫ﺘﺨﺪام اﺳﻢ اﻟﻔﺌ ﺔ‪.‬‬

‫ﺒﺎر اﻟﻔﺌ ﺔ ‪('t2:'، t2.x، t2.y) :‬‬

‫)‪t1.y) 13) print ('t2:'، t2.x، t2.y‬‬

‫ﺜﺎﻧﻴ ﺔ دورﺟﺎﺳﻮﻓ ﺖ ‪ ،‬رﻗﻢ ‪202 ، 2‬‬‫اﻟ‬

‫ﺒﺎﻋ ﺔ )‪(classname . doc‬‬

‫‪class Student: 2) 3) def init (self، name، rollno،‬‬

‫ﺒﺎر اﻟﻔﺌ ﺔ ‪12) print (t .ict) :‬‬

‫ﺒﺎر اﻟﻔﺌ ﺔ ‪12) print (t .ict) :‬‬

‫ﺒﺎر اﻟﻔﺌ ﺔ ‪12) print (t2 .ict) :‬‬

‫)‪10) del t1.a 11) print (t1 .ict‬‬

‫‪2) def init (self):‬‬

‫)‪def init (self): 3) self.a = 10 2‬‬

‫)‪print (Test .ict‬‬

‫)‪(Test .ict) 17) t.m1 () 18‬‬

3) def init ‫أ‬2) : ‫ﺒﺎر اﻟﻔﺌ ﺔ‬

(Test .ict) ‫أ‬2) : ‫ﺒﺎر اﻟﺼﻨﻒ‬

print (Test .ict)

‫‪1) class Student: 2) def init (self، name،‬اﻟﻌﻼﻣﺎ ت(‪= :‬‬