‫‪Python Basics‬‬

‫‪ -1‬ﺟﻤﻞ اﻟﻄﺒﺎﻋﺔ ‪print‬‬

‫ان ﺷﺎء ا رح ﻧﺘﻌﺮف ﻋﻠﻰ‬

‫ﺟﻤﻞ اﻟﻄﺒﺎﻋﺔ واﻟﻠﻲ ﻫﻴﺔ‪print :‬‬
‫اذا ﺑﺪي اﻃﺒﻊ ﻧﺺ )رﺳﺎﻟﺔ( او اﻃﺒﻊ ﻗﻴﻤﺔ ﻣﺨﺰﻧﺔ ﺑﻤﺘﻐﻴﺮ او اﻃﺒﻊ‬
‫ﻣﺠﻤﻮﻋﺔ ارﻗﺎم او اﻃﺒﻊ ﺗﻌﺒﻴﺮات ﺣﺴﺎﺑﻴﺔ ‪expressions‬‬
‫ﻛﻞ ﻫﺎد ﺑﺘﻘﺪر ﺗﻄﺒﻌﻮ وﺗﻌﺮﺿﻮ ﻟﻠﻤﺴﺘﺨﺪم‪...‬‬

‫واﻟﺴﺆال ‪ :‬ﻛﻴﻒ ﻳﺘﻢ ﻛﺘﺎﺑﺔ اﻣﺮ اﻟﻄﺒﺎﻋﺔ ﺑﺎﻟﺒﺎﻳﺜﻮن؟‬

‫ﺑﺒﺴﺎﻃﺔ اﻣﺮ اﻟﻄﺒﺎﻋﺔ ﻫﻮ‪:‬‬
‫) (‪print‬‬

‫ﺑﻘﻠﺐ ﻫﻲ اﻻﻗﻮاس ﺑﻜﺘﺐ اي ﻧﺺ او رﻗﻢ او ﻋﻤﻠﻴﺔ‬

‫ﺣﺴﺎﺑﻴﺔ‬
‫و ﻻزم اذا ﺑﺪي اﻛﺘﺐ اﻟﻨﺼﻮص ف ﻻزم اﻛﺘﺒﻦ ﺑﻴﻦ " " او ' '‬

‫ﻣﺜﺎل ‪ :‬اذا ﺑﺪي اﻛﺘﺐ ﻛﻮد ﻟﻄﺒﺎﻋﺔ ﻋﺒﺎرة‬

‫‪welcome to python‬‬
‫ف ﺑﻜﺘﺐ‪:‬‬
‫)" ‪print("welcome to python‬‬
‫‪or‬‬
‫)'‪print('welcome to python‬‬

‫ﻃﺐ ﺑﺎﻟﻨﺴﺒﺔ ﻟﻼرﻗﺎم او اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺑﻴﺔ‬

‫ﺗﻜﺘﺐ ﺑﺪون ‪.. double code or single code‬‬
‫ﺑﺲ ﻓﻲ ﻣﻼﺣﻈﺔ ﺻﻐﻴﺮة ﻟﻮ اﺳﺘﺨﺪﻣﺖ ‪double code or single‬‬
‫‪ code‬ﻣﻊ اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺑﻴﺔ رح ﻳﺘﻌﺎﻣﻞ ﻣﻌﺎ ﻛﺎﻧﻬﺎ ﻧﺺ ﻳﻌﻨﻲ ﺑﺘﻨﻌﺮض‬
 ‫ﺑﺸﻜﻠﻬﺎ اﻟﻤﻜﺘﻮب ﺑﺪون ﺗﻨﻔﻴﺬ اﻟﻌﻤﻠﻴﺔ اﻟﺤﺴﺎﺑﻴﺔ‪..‬‬
‫ﻣﺜﺎل ‪:‬‬
‫)"‪print("2*4‬‬
‫رح ﻳﻄﺒﻊ ‪4*2‬‬
‫اﻣﺎ اذا ﺑﺪي اﻟﻨﺎﺗﺞ ﻣﻦ ﻋﻤﻠﻴﺔ ﺣﺴﺎﺑﻴﺔ ‪ 2*4‬ف ﺑﻜﺘﺐ‪:‬‬
‫)‪print(2*4‬‬
‫رح ﻳﻄﺒﻊ ‪8‬‬

‫ﻃﻴﺐ اذا ﺑﺪي اﻃﺒﻊ ﻧﺺ ﻣﻊ ﺟﻤﻠﺔ ﺣﺴﺎﺑﻴﺔ‬

‫ﻣﺜﺎل‪:‬‬
‫‪2*4=8‬‬
‫ﺑﻜﻮن اﻟﺤﻞ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫)‪print("2*4=",2*4‬‬

‫‪DONE..‬‬
‫======================================‬
‫======================================‬

‫‪ -2‬داﻟﺔ اﻻدﺧﺎل ‪input‬‬

‫ﻣﻮﺿﻮﻋﻨﺎ ﻫﻮو اﻟـ ‪User input in python‬‬

‫اﻟﺪرس اﻻول ﻛﺎن ﻋﻦ ﺟﻤﻠﺔ اﻟﻄﺒﺎﻋﺔ ‪print‬‬

‫ﻫﻠﻖ رح ﻧﺘﻌﻠﻢ ﻃﺮﻳﻘﺔ ادﺧﺎل ﺑﻴﺎﻧﺎت ﻟﻠﻜﻮد ﻋﻦ ﻃﺮﻳﻖ اﻟﻤﺴﺘﺨﺪم‪...‬‬

‫وﻫﻴﺔ ﺑﺎﺳﺘﺨﺪام اﻟﺪاﻟﺔ )(‪input‬‬

 ‫ﺑﺒﺴﺎﻃﺔ اﻳﺎ ﻛﺎن اﻟﻜﻮد اﻟﻠﻲ ﻧﺤﻨﺎ ﺷﻐﺎﻟﻴﻦ ﻋﻠﻴﻪ‬
‫ﻓﺎﻟﻜﻮد ﺑﻴﺘﻜﻮن ﻣﻦ ﺟﺰء ﻟﻜﺘﺎﺑﺔ اﻟﻜﻮد وﺟﺰء ﻟﻌﺮض اﻟﻨﺘﻴﺠﺔ )‪(output‬‬
‫وﺣﻂ ﻋﻠﻰ ﻋﺒﺎرة ﻋﺮض اﻟﻨﺘﻴﺠﺔ اﻛﺘﺮ ﻣﻦ ﺧﻂ‪...‬‬

‫ﻳﻌﻨﻲ ﻧﺤﻨﺎ ﻟﻬﻠﻖ ﺑﺲ ﻣﻨﻜﺘﺐ ﻛﻮد وﻣﻨﻌﺮض اﻟﻨﺘﻴﺠﺔ ﺑﺎﻟـ ‪...output‬‬

‫اﻟﺴﺆال‪ :‬ﺑﻴﻘﺪر اﻟﻜﻮد ﻳﺴﺘﻘﺒﻞ اﻟﺒﻴﺎﻧﺎت اذا ﻗﻤﻨﺎ ﺑﻜﺘﺎﺑﺘﻬﺎ ﺑﺠﺰء اﻟـ‬
‫‪ output‬؟‬
‫ﻃﺒﻌﺎ ﻻ ﻣﺎ رح ﻳﺴﺘﻘﺒﻞ اي ﺑﻴﺎﻧﺎت‪...‬‬

‫ﺳﺆال ﻛﻴﻒ ﺑﻘﺪر ﻗﻮل ﻟﻠﻜﻮد ﺑﺎﻧﻮ ﺑﺪي دﺧﻞ ﺑﻴﺎﻧﺎت وﻟﻴﺲ ﻃﺒﺎﻋﺔ‬
‫ﺑﻴﺎﻧﺎت ؟‬
‫ﺑﺎﺳﺘﺨﺪم اﻟﺪاﻟﺔ ) (‪ input‬وﻫﻴﺔ اﻟﻤﺴﺆوﻟﺔ ﻋﻦ اﺳﺘﻘﺒﺎل اﻟﺒﻴﺎﻧﺎت ﻣﻦ‬
‫اﻟﻤﺴﺘﺨﺪم‪..‬‬

‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ‬
‫)'‪variableName=input('Message‬‬

‫ﻣﺜﺎل ﻟﻠﺘﻮﺿﻴﺢ اذا ﺑﺪي اﻛﺘﺐ ﻛﻮد ﻟﺤﻔﻆ وﻃﺒﺎﻋﺔ اﺳﻢ اﻟﻤﺴﺘﺨﺪم‬

‫اﻧﺎ رح اﻛﺘﺐ اﻟﻜﻮد واﺷﺮﺣﻮ ﺳﻄﺮ ﺳﻄﺮ‪...‬‬

‫'‪name='Test‬‬
‫)‪print(name‬‬
‫ﻫﻮن ﻋﺮﻓﺖ ﻣﺘﻐﻴﺮ ﻟﺤﻔﻆ اﺳﻢ اﻟﻤﺴﺘﺨﺪم‬
‫وﺑﺎﻟﺴﻄﺮ اﻟﺘﺎﻧﻲ رح ﻳﻄﺒﻊ ﻗﻴﻤﺔ ﻫﺎد اﻟﻤﺘﻐﻴﺮ‬

‫اﻣﺎ اذا ﺑﺪﻧﺎ ﻧﺨﻠﻲ اﻟﻤﺴﺘﺨﺪم ﻫﻮو اﻟﻠﻲ ﻳﻜﺘﺐ اﻻﺳﻢ وﺑﻌﺪﻳﻦ ﻧﻄﺒﻊ ﻫﺎد‬
‫اﻻﺳﻢ ف ﺑﻜﻮن اﻟﻜﻮد ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫)'‪name=input('enter the name‬‬
‫)‪print(name‬‬

‫ﻫﻮن ﺑﺲ اﺳﺘﺨﺪﻣﻨﺎ داﻟﺔ اﻻدﺧﺎل ‪ input‬ﻻﺳﺘﻘﺒﺎل اﻟﺒﻴﺎﻧﺎت ﻣﻦ‬

‫اﻟﻤﺴﺘﺨﺪم و ﺧﺰﻧﺎﻫﺎ ﺑﺎﻟﻤﺘﻐﻴﺮ‪..‬‬

‫ﻫﺎد ﺑﺎﻟﻨﺴﺒﺔ ﻻﺳﺘﻘﺒﺎل ﺑﻴﺎﻧﺎت ﻧﺼﻴﺔ ﻣﻦ اﻟﻤﺴﺘﺨﺪم‬

‫اﻣﺎ اذا ﺑﺪﻧﺎ ﻧﻌﻤﻞ ﺳﻜﺮﺑﺖ ﻟﺠﻤﻊ رﻗﻤﻴﻦ ﺑﻜﻮن اﻟﻜﻮد ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫‪num1=10‬‬
‫‪num2=20‬‬
‫)‪print(num1+num2‬‬

‫ﻫﻮن ﻋﺮﻓﺖ ﻋﺪدﻳﻦ ﻣﻦ اﻟﻤﺘﻐﻴﺮات وﺧﺰﻧﺖ اﻟﻘﻴﻢ ﺗﺒﻌﻦ‪.‬‬

‫وﺑﺎﻟﺴﻄﺮ اﻟﺘﺎﻧﻲ رح ﻳﻄﺒﻊ ﻧﺎﺗﺞ اﻟﺠﻤﻊ ﺗﺒﻊ ﻫﻲ اﻟﻤﺘﻐﻴﺮات‬
‫اﻣﺎ اذا ﺑﺪي اﺳﺘﻘﺒﻞ ﻫﻲ اﻻرﻗﺎم ﻣﻦ اﻟﻤﺴﺘﺨﺪم وﺑﻌﺪﻳﻦ اﻃﺒﻊ ﻧﺎﺗﺞ ﺟﻤﻊ‬
‫ﻫﻲ اﻟﻤﺘﻐﻴﺮات ﺑﻜﻮن اﻟﻜﻮد ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫)'‪num1=input('enter number 1‬‬

‫)'‪num2=input('enter number 2‬‬
‫)‪print(num1+num2‬‬

‫ﺑﺎﻓﺘﺮاض اﺛﻨﺎء اﻟﺘﻨﻔﻴﺬ ﺗﻢ ادﺧﺎل ﻛﻼ ﻣﻦ اﻟﺮﻗﻢ ‪10‬واﻟﺮﻗﻢ ‪20‬‬

‫رح ﻳﻄﺒﻊ ‪1020‬‬
‫وﻫﻲ ﻣﻮ اﻟﻨﺘﻴﺠﺔ اﻟﻠﻲ ﺑﺪﻧﺎ ﻳﺎﻫﺎ‪..‬‬

‫وﻟﻜﻦ ﺑﺪﻧﺎ ﻧﻄﺒﻊ ﻧﺎﺗﺞ ﺟﻤﻊ ﻫﻲ اﻟﻤﺘﻐﻴﺮات ﻓﺸﻮ اﻟﺴﺒﺐ ﺑﻌﺮض ﻫﻲ‬
‫اﻟﻨﺘﻴﺠﺔ ؟‬
‫اﻟﺴﺒﺐ ﺑﻴﺮﺟﻊ ﻻﻧﻮ داﻟﺔ ‪ input‬ﺗﺴﺘﻘﺒﻞ اﻟﻘﻴﻢ ﺑﺸﻜﻞ ‪string‬‬
‫وﺑﺎﻟﺘﺎﻟﻲ ﺗﻢ ﻓﻘﻂ دﻣﺞ ﻗﻴﻢ ﻫﻲ اﻟﻤﺘﻐﻴﺮات‪..‬‬
 ‫ﻫﻮن ﻻزم ﻧﺤﻮل اﻟﻘﻴﻤﺔ اﻟﻤﺨﺰﻧﺔ ﺑﺪاﻟﺔ ‪ input‬ﻻرﻗﺎم‬
‫ﻓﻠﻮ ﺑﺪﻧﺎ ﻧﺴﺘﻘﺒﻞ ارﻗﺎم ﺻﺤﻴﺤﺔ ﻧﺴﺘﺨﺪم ﻟﻠﺘﺤﻮﻳﻞ ﻧﻮع اﻟﺒﻴﺎﻧﺎت ‪int‬‬
‫اﻣﺎ ﻟﻮ ﺑﺪﻧﺎ ﻧﺴﺘﻘﺒﻞ ارﻗﺎم ﻋﺸﺮﻳﺔ ﻧﺴﺘﺨﺪم ﻟﻠﺘﺤﻮﻳﻞ ﻧﻮع اﻟﺒﻴﺎﻧﺎت‬
‫‪. float‬‬

‫ﻣﺜﺎل‪:‬‬

‫))'‪num1=int(input('enter number 1‬‬

‫))'‪num2=int(input('enter number 2‬‬
‫)‪print(num1+num2‬‬

‫ﺑﺎﻓﺘﺮاض اﺛﻨﺎء اﻟﺘﻨﻔﻴﺬ ﺗﻢ ادﺧﺎل ﻛﻼ ﻣﻦ اﻟﺮﻗﻢ ‪ 10‬واﻟﺮﻗﻢ ‪20‬‬

‫رح ﻳﻄﺒﻊ اﻟﻨﺘﻴﺠﺔ اﻟﻤﻄﻠﻮﺑﺔ ‪30‬‬

‫‪DONE..‬‬
‫======================================‬
‫======================================‬

‫‪ -3‬اﻟﻤﺘﻐﻴﺮات ‪Variables‬‬

‫ﻣﻮﺿﻮﻋﻨﺎ ﻫﻮو اﻟـ‪ Variables :‬او اﻟﻤﺘﻐﻴﺮات‬

‫اﻟﻤﺘﻐﻴﺮ ات ﺑﺒﺴﺎﻃﺔ ﻫﻴﺔ ﻣﺨﺎزن ﻟﻠﺒﻴﺎﻧﺎت وﻃﺎﻟﻤﺎ اﻧﻬﺎ ﻣﺨﺎزن ﻟﻠﺒﻴﺎﻧﺎت‬

‫ﺑﺎﻟﺘﺎﻟﻲ رح اﻗﺪر اﻧﻲ ﺧﺰن ﺑﻘﻠﺒﺎ ﺑﻴﺎﻧﺎت وﻛﻤﺎن ﺑﻘﺪر اﻧﻲ اﺳﺘﺮﺟﻊ ﻣﻨﻬﺎ‬
‫ﻫﻲ اﻟﺒﻴﺎﻧﺎت‪..‬‬

‫ﻃﺮﻳﻘﺔ ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮات ﺑﺒﺴﺎﻃﺔ ﺑﺎﻟﺼﻴﻐﺔ اﻟﺘﺎﻟﻴﺔ‪:‬‬

‫‪varibleName=value‬‬
 ‫ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮ ﺑﺒﻠﺶ ﺑﺎﺳﻢ اﻟﻤﺘﻐﻴﺮ ﺑﻌﺪﻳﻦ ﻣﻜﺘﺐ ‪ equal‬ﺑﻌﺪﻳﻦ اﻟﻘﻴﻤﺔ‬
‫اﻟﻤﺮاد ﺗﺨﺰﻳﻨﻬﺎ ﺑﺪاﺧﻞ اﻟﻤﺘﻐﻴﺮ‪..‬‬

‫ﻋﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜﺎل‪:‬‬

‫‪num1=5‬‬
‫‪num2=1.5‬‬
‫'‪name='python‬‬

‫وﻫﻲ اﻟﻘﻴﻤﺔ اﻟﻠﻲ ﺗﺨﺰﻧﺖ ﺑﻘﻠﺐ اﻟﻤﺘﻐﻴﺮ ﻫﻴﺔ اﻟﻠﻲ ﺑﺘﺤﺪد ﻧﻮع اﻟﻤﺘﻐﻴﺮ‪..‬‬
‫وﻳﺘﻢ اﺳﻨﺎد ﻫﻲ اﻟﻘﻴﻤﺔ ﻟﻠﻤﺘﻐﻴﺮ اﻣﺎ ﻋﻦ ﻃﺮﻳﻖ اﺳﻨﺎد اﻟﻘﻴﻤﺔ ﻣﺒﺎﺷﺮة او‬
‫ﻋﻦ ﻃﺮﻳﻖ اﻟﻤﺴﺘﺨﺪم ﻣﻦ ﺧﻼل اﺳﺘﺨﺪام داﻟﺔ اﻻدﺧﺎل اﻟﺴﺎﺑﻖ ﺷﺮﺣﻬﺎ‬
‫) ( ‪..input‬‬

‫واول ﺷﻲ ﻻزم ﻧﻌﺮﻓﻮ اﻧﻮ ﺑﺎﻳﺜﻮن ﻣﻮﻓﺮة ﻋﺪة اﻧﻮاع ﻣﻦ اﻟﻤﺘﻐﻴﺮات ﻣﻨﻬﺎ‪:‬‬
‫‪number‬‬
‫‪String‬‬
‫‪List‬‬
‫‪Tuple‬‬
‫‪Dictionary‬‬

‫اوﻻ ‪:‬ﻧﻮع اﻟﺒﻴﺎﻧﺎت رﻗﻤﻲ ‪number‬‬

‫ﻋﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜﺎل‪:‬‬

‫‪num1=5‬‬

‫اﻟﻤﺘﻐﻴﺮ ‪ num1‬ﻣﻦ اﻟﻨﻮع ‪ int‬ﻻن اﻟﻘﻴﻤﺔ اﻟﻤﺨﺰﻧﺔ ﻓﻴﻪ رﻗﻢ ﺻﺤﻴﺢ‬

‫‪num2=1.5‬‬
‫اﻟﻤﺘﻐﻴﺮ ‪ num2‬ﻣﻦ اﻟﻨﻮع ‪ float‬ﻻن اﻟﻘﻴﻤﺔ اﻟﻤﺨﺰﻧﺔ ﻓﻴﻪ رﻗﻢ ﻋﺸﺮي‬
 ‫ﺛﺎﻧﻴﺎ ‪ :‬ﻧﻮع اﻟﺒﻴﺎﻧﺎت ﻧﺼﻲ ‪string‬‬

‫'‪name='python‬‬

‫اﻟﻤﺘﻐﻴﺮ ‪ name‬ﻣﻦ اﻟﻨﻮع ‪ string‬ﻻن اﻟﻘﻴﻤﺔ اﻟﻤﺨﺰﻧﺔ ﻓﻴﻪ ﻧﺼﻴﺔ‬

‫ﻣﻼﺣﻈﺔ‪:‬‬
‫ﻣﻨﺤﻂ ﻗﻴﻢ اﻟﻤﺘﻐﻴﺮات اﻟﻨﺼﻴﺔ ﺑﻴﻦ‬
‫‪single quote or double quote‬‬
‫ﻳﻌﻨﻲ ﻫﺪول " " او ' '‬
‫اﻣﺎ ﺑﺎﻗﻲ اﻻﻧﻮاع ﻣﻦ اﻟﻤﺘﻐﻴﺮات ﻣﺸﺮوﺣﺎ ﻻﺣﻘﺎ‪..‬‬

‫وﻓﻲ ﺷﺮوط ﻟﺘﺴﻤﻴﺔ اﻟﻤﺘﻐﻴﺮات‪:‬‬

‫‪ _١‬ﻻزم ﻳﺒﻠﺶ ﺑﺤﺮف‪.‬‬
‫‪ _٢‬ﻣﺎ ﻳﺰﻳﺪ ﻃﻮل اﻟﻤﺘﻐﻴﺮ ﻋﻦ ‪.٣٠‬‬
‫‪ _٣‬ﻣﺎ ﻣﻨﻘﺪر ﻧﺴﺘﺨﺪم ﻛﻠﻤﺔ ﻣﻦ اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزة ﺑﺘﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮ‪.‬‬
‫ﺑﻤﻌﻨﻰ اﻧﻮ ﻻ ﻳﻤﻜﻦ ﺗﺴﻤﻴﺔ اﻟﻤﺘﻐﻴﺮ ﺑﺎﺳﻢ ‪ if‬ﻣﺜﻼ‪..‬‬

‫ﻃﺒﺎﻋﺔ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ‪:‬‬

‫اﻟﻬﺪف اﻻﺳﺎﺳﻲ ﻣﻦ اﻧﺸﺎء اﻟﻤﺘﻐﻴﺮات ﻣﻮ ﻫﻮ ﺗﺨﺰﻳﻦ ﻗﻴﻤﺔ وﻃﺒﺎﻋﺘﻬﺎ‬
‫ﻓﻘﻂ‬
‫واﻧﻤﺎ ﻣﻨﻘﺪر ﻧﺴﺘﺨﺪم ﻫﻲ اﻟﻘﻴﻤﺔ ﺑﺎﺟﺮاء اﻛﺜﺮ ﻣﻦ اﺟﺮاء داﺧﻞ اﻟﺴﻜﺮﺑﺖ‪..‬‬

‫وﻟﻄﺒﺎﻋﺔ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ﻣﻨﺴﺘﺨﺪم ﺟﻤﻠﺔ اﻟﻄﺒﺎﻋﺔ ‪print‬‬

‫)‪print(variableName‬‬

‫ﻟﻄﺒﺎﻋﺔ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ‪ num1‬ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫)‪print(num1‬‬
 ‫رح ﻳﻄﺒﻊ ‪5‬‬
‫ﻣﻨﻼﺣﻆ اﻧﻮ اﻟﻤﺘﻐﻴﺮ ﻛﺘﺒﺘﻮ ﻣﺒﺎﺷﺮة ﺑﺪون اﺳﺘﺨﺪام ‪single or double‬‬
‫‪..code‬‬

‫ﺑﻌﺾ اﻻﺳﺌﻠﺔ اﻟﺸﺎﺋﻌﺔ‪:‬‬

‫ﻣﻨﻘﺪر ﻧﻌﺮف ﻧﻮع اﻟﻤﺘﻐﻴﺮ ﻣﻦ ﺧﻼل داﻟﺔ ﻣﻌﻴﻨﺔ ؟‬
‫ﺑﺒﺴﺎﻃﺔ اي ﻋﻦ ﻃﺮﻳﻖ اﻟﺪاﻟﺔ ) ( ‪type‬‬
‫ﻋﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜﺎل اذا ﺑﺪﻧﺎ ﻧﻌﺮف ﻧﻮع اﻟﻤﺘﻐﻴﺮ ‪num1‬‬
‫ف ﻣﻨﻜﺘﺐ اﻟﻜﻮد اﻟﺘﺎﻟﻲ‪:‬‬
‫)‪type(num1‬‬
‫رح ﻳﻄﺒﻊ ‪..int‬‬

‫ﻣﻨﻘﺪر ﻧﺤﻮل ﻧﻮع اﻟﺒﻴﺎﻧﺎت ﻟﻨﻮع ﺗﺎﻧﻲ؟‬

‫ﺑﺒﺴﺎﻃﺔ اي ﻋﻦ ﻃﺮﻳﻖ ﻋﻤﻞ ‪casting‬‬
‫وﻫﻮ ﻛﺘﺎﺑﺔ اﻟﻨﻮع اﻟﻤﻄﻠﻮب اﻟﺘﺤﻮﻳﻞ ﻟﻪ ﻗﺒﻞ اﺳﻢ اﻟﻤﺘﻐﻴﺮ‬
‫ﻋﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜﺎل اذا ﺑﺪﻧﺎ ﻧﺤﻮل ﻧﻮع اﻟﻤﺘﻐﻴﺮ ‪ num1‬ﻣﻦ اﻟﻨﻮع ‪int‬‬
‫ﻟﻠﻨﻮع ‪ float‬ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫)‪float(num1‬‬

‫رح ﻳﺒﻄﻊ ‪..5.0‬‬

‫ﻣﻨﻘﺪر ﻧﻐﻴﺮ اﻟﻘﻴﻤﺔ اﻟﻤﺨﺰﻧﺔ ﺑﺎﻟﻤﺘﻐﻴﺮ؟‬

‫ﺑﺒﺴﺎﻃﺔ اي ﻋﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜﺎل‪:‬‬
‫‪num1=5‬‬
‫‪num1=10‬‬
‫)‪print(num1‬‬

‫رح ﻳﻄﺒﻊ ‪ 10‬ﻻﻧﻮ اﻟﻘﻴﻤﺔ ‪ 5‬ﺗﻐﻴﺮت وﺻﺎرت ‪10‬‬

 ‫واﺧﻴﺮا اﻟﻤﺘﻐﻴﺮ ‪ num1‬ﻣﻮ ﻫﻮ ‪ Num1‬ﻻن ﺑﺎﻳﺜﻮن ﺣﺴﺎﺳﺔ ﻟﻠﺤﺮوف‬
‫‪ case sensitive‬وﺑﺎﻟﺘﺎﻟﻲ ﻓﻜﻼﻫﻤﺎ ﻣﺘﻐﻴﺮﻳﻦ ﻣﺨﺘﻠﻔﻴﻦ‪..‬‬

‫‪DONE..‬‬
‫======================================‬
‫======================================‬

‫‪ -4‬اﻟـ ‪operators‬‬

‫ﻣﻮﺿﻮﻋﻨﺎ ﻫﻮو‪:‬‬
‫‪Python operators‬‬
‫او اﻟﻌﻤﻠﻴﺎت ﺑﺎﻟﺒﺎﻳﺜﻮن ﺑﺘﻨﻘﺴﻢ ﻟـ ‪:‬‬
‫‪- Arithmetic operators‬‬
‫‪ -‬اﻟﻤﻌﺎﻣﻼت اﻟﺤﺴﺎﺑﻴﺔ‬
‫‪- Assignment operators.‬‬
‫‪ -‬ﻣﻌﺎﻣﻼت اﺳﻨﺎد اﻟﻘﻴﻢ‬
‫‪- Comparison operators‬‬
‫‪ -‬ﻣﻌﺎﻣﻼت اﻟﻤﻘﺎرﻧﺔ‬
‫‪- Logical operators.‬‬
‫‪ -‬اﻟﻤﻌﺎﻣﻼت اﻟﻤﻨﻄﻘﻴﺔ‬

‫رح ﻧﺪرﺳﻦ ﺑﺎﻟﺘﻔﺼﻴﻞ ان ﺷﺎء ا ‪..‬‬

‫اوﻻ ‪ :‬اﻟﻤﻌﺎﻣﻼت اﻟﺤﺴﺎﺑﻴﺔ ‪Arithmetic operators‬‬

‫اﻟﺠﻤﻊ ‪+‬‬
‫اﻟﻄﺮح ‪-‬‬
‫اﻟﻀﺮب *‬
‫اﻟﻘﺴﻤﺔ ‪/‬‬
‫ﺑﺎﻗﻰ اﻟﻘﺴﻤﺔ ‪%‬‬
‫اﻷس **‬
 ‫اﻟﻘﺴﻤﺔ اﻟﺼﺤﻴﺤﺔ ‪//‬‬
‫ورح ﻧﻮﺿﺤﺎ ﺑﻤﺜﺎل‪:‬‬

‫‪num1=6‬‬
‫‪num2=2‬‬
‫)‪print(num1+num2‬‬

‫رح ﻳﻄﺒﻊ ‪8‬‬

‫)‪print(num1-num2‬‬
‫رح ﻳﻄﺒﻊ ‪4‬‬
‫)‪print(num1*num2‬‬
‫رح ﻳﻄﺒﻊ ‪12‬‬
‫)‪print(num1/num2‬‬
‫رح ﻳﻄﺒﻊ ‪3‬‬
‫)‪print(num1%num2‬‬
‫رح ﻳﻄﺒﻊ ‪0‬‬
‫)‪print(num1**num2‬‬
‫رح ﻳﻄﺒﻊ ‪36‬‬
‫)‪print(num1//num2‬‬
‫رح ﻳﻄﺒﻊ ‪3‬‬

‫رح وﺿﺢ ﻋﻼﻣﺔ ‪ %‬او ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫ﻧﺎﺗﺞ ﻗﺴﻤﺔ ‪ 6/2‬ﻫﻮ ‪ ( 2*3=6) 3‬اﻣﺎ ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ ﺑﻜﻮن ﺻﻔﺮ‪..‬‬

‫اوﻟﻮﻳﺎت اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺑﻴﺔ‬

‫اﻧﺎ ﻋﺮﺿﺘﻬﺎ ﺑﺤﺴﺐ اوﻟﻮﻳﺔ اﻟﺘﻨﻔﻴﺬ‬
‫)(‬
‫**‬
‫‪*/‬‬
‫‪+-‬‬
 ‫ﻣﺜﺎل ﻟﻠﺘﻮﺿﻴﺢ‪:‬‬
‫‪num1=10‬‬
‫‪num2=5‬‬
‫‪num3=4‬‬
‫)‪print(num1+num2*num3‬‬

‫ﻳﻜﻤﻦ ﻳﻔﻜﺮ اﻟﺒﻌﺾ ﻣﻨﻜﻦ اﻧﻮ اﻟﻨﺎﺗﺞ ﻣﻦ ﻫﻲ اﻟﻌﻤﻠﻴﺔ ﺑﻜﻮن ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬

‫ﻫﻮ ﺟﻤﻊ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ‪ num1‬ﻣﻊ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ‪ num2‬ﺑﻌﺪﻳﻦ ﺑﻴﻀﺮب‬
‫ﻫﺎد اﻟﻨﺎﺗﺞ ﺑﻘﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ‪num3‬‬
‫اﻻ او ﻫﺎد ﻏﻴﺮ ﺻﺤﻴﺢ راﺟﻊ اوﻟﻮﻳﺎت ﺗﻨﻔﻴﺬ اﻟﻤﻌﺎﻣﻼت اﻟﺤﺴﺎﺑﻴﺔ اﻟﺘﻰ ﺗﻢ‬
‫ﺷﺮﺣﻬﺎ‪..‬‬
‫ﻣﻨﻼﻗﻲ اﻟﻜﻮد رح ﻳﻀﺮب ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ‪ num2‬ﻓﻰ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ‪num3‬‬
‫وﺑﻌﺪﻳﻦ رح ﻳﺠﻤﻊ ﻫﺎد اﻟﻨﺎﺗﺞ ﻣﻊ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ‪ num3‬ﻓﺒﻜﻮن اﻟﻨﺎﺗﺞ ﻫﻮ‬
‫‪..30‬‬

‫ﺑﻌﺾ اﻟﻤﻼﺣﻈﺎت ‪:‬‬

‫‪ -‬ﺑﺤﺎﻟﺔ وﺟﻮد اﻛﺘﺮ ﻣﻦ ﻣﻌﺎﻣﻞ اﻟﻮ ﻧﻔﺲ اوﻟﻮﻳﺔ اﻟﺘﻨﻔﻴﺬ ﻓـ ﺑﺘﻢ اﻟﺘﻨﻔﻴﺬ ﻣﻦ‬
‫اﻟﻴﺴﺎر ﻟﻠﻴﻤﻴﻦ‪..‬‬
‫‪ -‬ﺑﺤﺎﻟﺔ اﻟﺮﻏﺒﺔ ﺑﺎﻋﻄﺎء اي ﻋﻤﻠﻴﺔ اوﻟﻮﻳﺔ اﻟﺘﻨﻔﻴﺬ ﻣﻨﺤﻄﻬﺎ ﺑﻘﻠﺐ اﻻﻗﻮاس‬
‫) (‪..‬‬

‫‪DONE..‬‬
‫======================================‬
‫======================================‬

‫ﺛﺎﻧﻴﺎ‪ :‬اﻟﻨﻮع اﻟﺘﺎﻧﻲ ﻣﻦ اﻟﻤﻌﺎﻣﻼت اﻟﺤﺴﺎﺑﻴﺔ‪:‬‬

‫‪- Assignment operators..‬‬

‫او ﻣﻌﺎﻣﻼت اﺳﻨﺎد اﻟﻘﻴﻢ‬
 ‫وﻫﻮ اﻟﻤﻌﺎﻣﻞ =‬
‫وﻫﻮ ﺑﻘﻮم ﺑﺎاﺿﺎﻓﺔ ﻗﻴﻤﺔ ﻣﻌﻴﻨﺔ ﻟﻠﻤﺘﻐﻴﺮ‪..‬‬
‫ورح ﻧﻮﺿﺤﻬﺎ ﺑﻤﺜﺎل‪:‬‬
‫‪num1=20‬‬
‫)‪print(num1‬‬
‫رح ﻳﻄﺒﻊ ‪20‬‬

‫ﻫﻮن ﺿﻔﺖ او ﺧﺰﻧﺖ اﻟﻘﻴﻤﺔ اﻟﻤﻮﺟﻮدة ﺑﻌﺪ ﻣﻌﺎﻣﻞ = ﺑﺎﻟﻤﺘﻐﻴﺮ‪..‬‬

‫‪ -‬ﻣﻨﻘﺪر ﻛﻤﺎن ﺑﺪل ﻣﺎ ﻧﻌﻄﻲ اﻟﻘﻴﻤﺔ ﻣﺒﺎﺷﺮة ﻣﻨﻌﻄﻴﻬﺎ اﻟﻘﻴﻤﺔ ﺑﺼﻮرة‬

‫ﻋﻤﻠﻴﺔ ﺣﺴﺎﺑﻴﺔ ﻛﻤﺎ ﺗﻢ ﺷﺮﺣﻬﺎ ﻓﻰ اﻟﺪرس اﻟﺴﺎﺑﻖ‪..‬‬

‫‪num1=2*3+5‬‬
‫)‪print(num1‬‬

‫رح ﻳﻄﺒﻊ ‪..11‬‬

‫واﻳﻀﺎ ﻣﻨﻘﺪر اﻧﻮ ﻧﺴﺘﺨﺪم ﻻﺳﻨﺎد ﻗﻴﻤﺔ ﻣﺘﻐﻴﺮ ﻟﻤﺘﻐﻴﺮ اﺧﺮ‪:‬‬
‫‪num1=2‬‬
‫‪num2=num1‬‬
‫)‪print(num2‬‬
‫رح ﻳﻄﺒﻊ ‪2‬‬
‫وﻓﻲ ﺑﻌﺾ اﻟﻤﻌﺎﻣﻼت اﻟﻠﻲ ﺑﺘﺘﻔﺮع ﻣﻦ ﻣﻌﺎﻣﻞ = وﻫﻴﺔ‪:‬‬
‫=‪+‬‬
‫=‪-‬‬
‫=*‬
‫=‪/‬‬
‫=℅‬
‫=**‬
‫=‪//‬‬
‫اﻟﻐﺮض ﻣﻨﻬﺎ ﻓﻘﻂ ﻫﻮ اﺧﺘﺼﺎر اﻟﻜﻮد‬
 ‫ﻣﺜﺎل ﻟﻠﺘﻮﺿﻴﺢ‪:‬‬
‫‪num1=2‬‬

‫اذا ﺑﺪﻧﺎ ﻧﺰﻳﺪ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ‪ num1‬ب ‪ 2‬ف ﻣﻨﻜﺘﺐ‪:‬‬

‫‪num1=num1+2‬‬
‫ﻣﻨﻘﺪر ﻛﻤﺎن ﻧﻌﺒﺮ ﻋﻨﻬﺎ ﺑﺎﻟﺼﻮرة ﺗﺎﻧﻴﺔ‪:‬‬
‫‪num1+=2‬‬

‫وﻋﻨﺪ اﻟﻄﺒﺎﻋﺔ ﻟﻘﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ‪ num1‬ﺑﺎﻟﺤﺎﻟﺘﻴﻦ‬

‫رح ﺗﻜﻮن اﻟﻨﺘﻴﺤﺔ وﺣﺪة وﻫﻴﺔ ‪..4‬‬
‫ﻓﻘﻂ اﺳﺘﺨﺪﻣﻨﺎﻫﺎ ﻻﺧﺘﺼﺎر اﻟﻜﻮد‪..‬‬
‫ﻓﻘﻤﻨﺎ ﺑﺎاﺧﺘﺼﺎر اﻟﻜﻮد ﻛﺎﻟﺘﺎﻟﻲ‪:‬‬
‫‪num1=num1+2‬‬

‫ﻣﻨﺤﺬف اﺳﻢ اﻟﻤﺘﻐﻴﺮ اﻟﻤﻮﺟﻮد ﺑﺎﻟﻄﺮف اﻟﻴﻤﻴﻦ ﺑﻌﺪ ﻣﻌﺎﻣﻞ ‪equal‬‬

‫وﻣﻨﺮﺳﻞ ﻫﻲ اﻟﻤﻌﺎﻣﻠﺔ اﻟﺤﺴﺎﺑﻴﺔ ﻟﻠﻄﺮف اﻟﺘﺎﻧﻲ ﻗﺒﻞ ﻣﻌﺎﻣﻞ ‪..equal‬‬

‫وﻫﻜﺬا ﺑﺘﻢ ﺗﻄﺒﻴﻖ ﺑﺎﻗﻲ اﻟﻤﻌﺎﻣﻼت‪..‬‬

‫‪DONE..‬‬
‫======================================‬
‫======================================‬

‫ﺛﺎﻟﺜﺎ‪ :‬اﻟﻨﻮع اﻟﺘﺎﻟﺖ ﻣﻦ اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺑﻴﺔ‪:‬‬

‫‪comparsion operators‬‬

‫ﻣﻨﺴﺘﺨﺪم ﻫﻲ اﻟﻤﻌﺎﻣﻼت ﻟﻠﻤﻘﺎرﻧﺔ ﺑﻴﻦ ﻗﻴﻤﺘﻴﻦ وﺗﻜﻮن اﻟﻨﺘﻴﺠﺔ اﻟﻤﺮﺟﻌﺔ‬

‫اﻣﺎ ‪true or false‬‬
‫وﻫﻤﺎ =!‪>.>=,<,<=,==,‬‬
 ‫ورح وﺿﺤﺎ ﺑﻤﺜﺎل‪:‬‬
‫ﺣﺘﻰ ﻧﻘﺪر ﻧﻌﺮض اﻟﻨﺘﻴﺠﺔ ﻟﻬﻲ اﻟﻤﻌﺎﻣﻼت ﻓـ ﻻزم ﻋﺮف ﻋﺪدﻳﻦ ﻣﻦ‬
‫ﻣﺘﻐﻴﺮ ﻣﻦ اﻟﻨﻮع اﻟﺮﻗﻤﻲ اﻟﺼﺤﻴﺢ ‪ int‬وﻣﺘﻐﻴﺮ ﻣﻦ اﻟﻨﻮع ‪ boolean‬وﻫﺎد‬
‫اﻟﻤﺘﻐﻴﺮ ﻳﻘﺒﻞ اﻣﺎ ‪:true or false‬‬

‫‪num1=20‬‬
‫‪num2=10‬‬
‫‪result=num1>num2‬‬
‫)‪print(result‬‬

‫ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ‪ result‬ﺑﺘﻌﺘﻤﺪ ع اﻟﻨﺘﻴﺠﺔ اﻟﻤﺮﺟﻌﺔ ﻣﻦ ﻫﺎد اﻟﺴﺆال‬

‫‪ num1>num2‬ﻫﻞ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ‪ num1‬وﻫﻴﺔ ‪ 20‬اﻛﺒﺮ ﻣﻦ ﻗﻴﻤﺔ‬
‫اﻟﻤﺘﻐﻴﺮ ‪ num2‬وﻫﻴﺔ ‪!10‬؟‬

‫اﻻﺟﺎﺑﺔ ‪..true‬‬
‫وﺑﺎﻟﺘﺎﻟﻲ رح ﻳﻄﺒﻊ ‪..true‬‬
‫وﻫﻴﻚ ﺑﺎﻟﻨﺴﺒﺔ ﻟﺒﺎﻗﻲ اﻟﻤﻌﺎﻣﻼت‪..‬‬

‫=>اﻛﺒﺮ ﻣﻦ او ﻳﺴﺎوى‪true .‬‬

‫‪false‬‬ ‫< اﺻﻐﺮ ﻣﻦ‬
‫=<ﺻﻐﺮ ﻣﻦ او ﻳﺴﺎوى ‪false‬‬
‫‪false‬‬ ‫== ﻳﺴﺎوى‬
‫‪true‬‬ ‫=! ﻻ ﻳﺴﺎوى‬

‫واﻟﺴﺆال اذا ﺑﺪﻧﺎ ﻧﺴﺘﺨﺪم اﻛﺘﺮ ﻣﻦ ﻣﻌﺎﻣﻞ ﻣﻦ اﻟﻤﻌﺎﻣﻼت اﻟﺴﺎﺑﻘﺔ ﻫﻮن‬

‫رح ﻳﻈﻬﺮ دور ‪..logical operators‬‬

‫وﻫﻴﺔ ﺗﺴﺘﺨﺪم ﻟﻠﺘﺤﻘﻖ ﻣﻦ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻌﺒﺎرات وﻫﻲ اﻟﻌﺒﺎرات ﺗﻘﻮم‬

‫ﺑﺎرﺟﺎع ﻗﻴﻤﺔ ﻣﻨﻄﻘﻴﺔ اﻣﺎ ‪..true or false‬‬
‫وﻫﻨﻦ‪:‬‬
‫‪and‬‬
‫‪or‬‬
‫‪not‬‬

‫اوﻻ‪and :‬‬
‫ﺣﺘﻰ ﺗﺮﺟﻌﻠﻨﺎ اﻟﻘﻴﻤﺔ ‪ true‬ﻻزم اﻧﻮ ﻳﻜﻮن ﺟﻤﻴﻊ اﻃﺮاف اﻟﻤﻘﺎرﻧﺔ ﺑﺘﺮﺟﻊ‬
‫‪..true‬‬

‫اﻣﺎ ﺑﺤﺎﻟﺔ اﻧﻮ ﻳﻜﻮن اﺣﺪ اﻃﺮاف اﻟﻤﻘﺎرﻧﺔ ﺑﺮﺟﻊ ﻗﻴﻤﺔ ‪ false‬ﻓﺎﻟﻨﺘﻴﺠﺔ‬
‫اﻟﻨﻬﺎﺋﻴﺔ ﻟﻠﻤﻘﺎرﻧﺔ ﺗﻜﻮن ‪..false‬‬

‫ﺗﺎﻧﻴﺎ‪or :‬‬
‫ﺣﺘﻰ ﻧﻘﺪر ﻧﺮﺟﻊ اﻟﻘﻴﻤﺔ ‪ true‬ﻻزم ﻳﻜﻮن اﺣﺪ اﻃﺮاف اﻟﻤﻘﺎرﻧﺔ ﺑﺮﺟﻊ‬
‫‪ true‬وﻟﻴﺲ ﺟﻤﻴﻊ اﻻﻃﺮاف ﺑﻌﻜﺲ اﻟـ ‪..and‬‬

‫اﻣﺎﺑﺤﺎﻟﺔ اﻧﻮ ﻛﻞ اﻃﺮاف اﻟﻤﻘﺎرﻧﺔ ﺑﺮﺟﻌﻮ اﻟﻘﻴﻤﺔ ‪ false‬ﻓـ ﺑﺘﻜﻮن اﻟﻨﺘﻴﺠﺔ‬

‫اﻟﻨﻬﺎﺋﻴﺔ ﻟﻠﻤﻘﺎرﻧﺔ ‪..false‬‬

‫ﺛﺎﻟﺜﺎ‪not :‬‬
‫وﻫﻴﺔ ﺑﺘﻌﻜﺲ ﻧﺎﺗﺢ ﻋﻤﻠﻴﺔ اﻟﻤﻘﺎرﻧﺔ‬
‫ﻣﺜﺎل ﻟﻠﺘﻮﺿﻴﺢ‪:‬‬
‫‪n1=10‬‬
‫‪n2=20‬‬
‫‪result=not n1>n2‬‬
‫)‪print(result‬‬
‫رح ﻳﻄﺒﻊ ‪..true‬‬

‫ﻫﻮن اﻟﻘﺼﺪ ﻣﻦ ‪ not‬اﻧﻮ اﻟﻤﺘﻐﻴﺮ ‪ n1‬ﻟﻴﺲ اﻛﺒﺮ ﻣﻦ ‪n2‬‬

‫او ﺑﻄﺮﻳﻘﺔ اﺧﺮى‪:‬‬
‫‪n1>n2‬‬
 ‫اﻻﺟﺎﺑﺔ ‪ false‬ﺑﻴﻨﻤﺎ ﺗﻘﻮم ‪ not‬ﺑﻌﻜﺲ ﻫﻲ اﻟﻤﻘﺎرﻧﺔ ﻓﺘﺼﺒﺢ ‪..true‬‬
‫ﻣﺜﺎل ﺗﺎﻧﻲ‪:‬‬
‫‪n=4‬‬
‫)‪print(n>=1 and n<=10‬‬
‫ﻫﻮن ﻋﻤﻠﺖ ﻣﺘﻐﻴﺮ ﻳﺤﻤﻞ اﻟﻘﻴﻤﺔ ‪4‬‬
‫واﺳﺘﺨﺪﻣﺖ ﻣﻌﺎﻣﻼت اﻟﻤﻘﺎرﻧﺔ اﻟﺴﺎﺑﻖ ﺷﺮﺣﻬﺎ ودﻣﺠﺘﺎ ﺑﺎﺳﺘﺨﺪام ﻋﺒﺎرة‬
‫‪and‬‬
‫‪n>=1 true‬‬
‫‪n<=10 true‬‬
‫وﻃﺎﻟﻤﺎ اﻧﻮ ﻛﻞ اﻃﺮاف اﻟﻤﻘﺎرﻧﺔ ﺑﺘﺮﺟﻊ ‪ true‬وﺑﺎﻟﺘﺎﻟﻲ ﻓـ ﻋﺒﺎرة ‪ and‬رح‬
‫ﺗﺮﺟﻊ ‪..true‬‬

‫‪DONE..‬‬
‫======================================‬
‫======================================‬

‫‪ -5‬اﻟﺠﻤﻞ اﻟﺸﺮﻃﻴﺔ ‪if statment‬‬

‫رح اﺣﻜﻲ ﻋﻦ ﻣﻘﺪﻣﺔ ﺑﺴﻴﻄﺔ ﺑﺘﻮﺿﺢ اﻳﻤﺘﻰ ﻣﻨﺴﺘﺨﺪم اﻟﺠﻤﻞ‬

‫اﻟﺸﺮﻃﻴﺔ‪..‬‬

‫ﺑﺒﺴﺎﻃﺔ اي ﺳﻜﺮﺑﺖ ﺑﺄي ﻟﻐﺔ ﺑﺮﻣﺠﺔ ﺑﻴﺘﻨﻔﺬ ﺑﺼﻮرة ﻣﺘﺘﺎﻟﻴﺔ ﻳﻌﻨﻲ ﺑﻴﺘﻨﻔﺬ‬
‫ﺳﻄﺮ ﺳﻄﺮ ﺣﺴﺐ ﺗﺮﺗﻴﺐ اﻟﻜﻮد‪..‬‬

‫ﻣﺎذا ﻟﻮ ﻛﻨﺎ ﺑﺪﻧﺎ ﻧﻨﻔﺬ اﺣﺪ ﻫﻲ اﻻﺳﻄﺮ وﻓﻘﺎ ﻟﺘﺤﻘﻖ ﺷﺮط ﻣﻌﻴﻦ ﻣﻦ ﺧﻼل‬
‫ﻣﺎﺗﻢ دراﺳﺘﺔ ﺳﺎﺑﻘﺎ ﻣﺎرح ﻳﻤﺸﻲ اﻟﺤﺎل‪..‬‬

‫ﻟﻜﻦ رح ﻧﺘﻌﻠﻢ ﻫﻲ اﻟﺠﻤﻞ اﻟﻠﻲ رح ﻧﺘﺤﻜﻢ ﺑﻤﺴﺎر اﻟﺴﻜﺮﺑﺖ‪..‬‬

 ‫وﺑﺎﻟﺘﺎﻟﻲ ﻣﻨﻘﺪر ﻧﻌﺮف اﻟﺠﻤﻞ اﻟﺸﺮﻃﻴﺔ ﺑﺎﻧﻬﺎ ﻋﺒﺎرة ﻋﻦ ﺑﻠﻮك او ‪block‬‬
‫ﻣﻦ اﻻﻛﻮاد ﺑﻴﺮﺗﺒﻂ ﺗﻨﻔﻴﺬﻫﺎ ﺑﺘﺤﻘﻖ ﺷﺮط ﻣﻌﻴﻦ‪.‬‬

‫ﻋﺒﺎرة ‪if‬‬
‫واﻟﻬﺎ ﻋﺪة ﺣﺎﻻت‪:‬‬
‫‪1- simple if‬‬
‫اﻟﺤﺎﻟﺔ اﻻوﻟﻰ وﻫﻴﺔ اﺑﺴﻂ ﺻﻮرة ﻟﺠﻤﻠﺔ ‪if‬‬

‫وﺗﺎﺧﺬ اﻟﺼﻴﻐﺔ اﻟﺘﺎﻟﻴﺔ‪:‬‬

‫‪if(condition):‬‬
‫‪statements‬‬

‫ﻣﻨﻜﺘﺐ ﺟﻤﻠﺔ اﻟﺸﺮط ﺑﺎﺳﺘﺨﺪام ﻋﺒﺎرة ‪ if‬ﻛﺎﻟﺘﺎﻟﻲ ‪:‬‬

‫ﻣﻨﻜﺘﺐ اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ if‬وﺑﻌﺪﻫﺎ ﻣﻨﻔﺘﺢ ﻗﻮﺳﻴﻦ وﻫﻲ اﺧﺘﻴﺎرﻳﺔ‬

‫وﻣﻨﻜﺘﺐ ﺑﻘﻠﺒﻦ اﻟﻌﺒﺎرة او اﻟﻌﺒﺎرات اﻟﻠﻲ ﺑﺪﻧﺎ ﻧﺘﺤﻘﻖ ﻣﻦ ﺻﺤﺘﻬﺎ وﻻزم‬
‫اﻧﻮ ﺗﻜﻮن اﻟﻨﺘﻴﺠﺔ اﻟﻤﺮﺟﻌﺔ‪:‬‬
‫)‪boolean (true or false‬‬

‫وﻫﺎﻟﺸﻲ ﺑﺎﺳﺘﺨﺪام اﺣﺪ ﻣﻌﺎﻣﻼت اﻟﻤﻘﺎرﻧﺔ اﻟﺴﺎﺑﻖ ﺷﺮﺣﻬﻢ‬

‫‪.comparison operators‬‬
‫واﻟﺪﻣﺞ ﺑﻴﻨﻬﻢ ﻋﻨﺪ وﺟﻮد اﻛﺜﺮ ﻣﻦ ﺷﺮط او ﻋﺒﺎرة ﺑﺎﺳﺘﺨﺪام‬
‫‪and‬‬
‫‪or‬‬

‫وﺑﻌﺪﻳﻦ ﻣﻨﻜﺘﺐ اﻟﺠﻤﻠﺔ او اﻟﺠﻤﻞ اﻟﻤﺮاد ﺗﻨﻔﻴﺬﻫﺎ‬

‫ﺑﺤﺎﻟﺔ ﺗﺤﻘﻖ اﻟﺸﺮط‬
‫وﻣﻨﻼﺣﻆ اﻻﺗﻲ ‪:‬‬
‫_ ﺑﺤﺎﻟﺔ ﺗﺤﻘﻖ اﻟﺸﺮط ) ﻧﺘﻴﺠﺔ اﻟﺸﺮط ‪ ( true‬رح ﻳﻨﻔﺬ ﻫﻲ اﻟﺠﻤﻠﺔ‪..‬‬
‫اﻣﺎ ﺑﺤﺎﻟﺔ ﻋﺪم ﺗﺤﻘﻖ اﻟﺸﺮط )ﻧﺘﻴﺠﺔ اﻟﺸﺮط ‪ ( false‬ﻣﺎرح ﻳﻨﻔﺬ اي ﺷﻲ‬
‫واﻧﻤﺎ ﻳﻜﻤﻞ ﺗﻨﻔﻴﺬ ﺑﺎﻗﻲ اﻻﻛﻮاد اﻟﻤﻮﺟﻮدة ﺑﻘﻠﺐ اﻟﺴﻜﺮﺑﺖ‪..‬‬

‫ﻣﺜﺎل ﻟﻠﺘﻮﺿﻴﺢ‪:‬‬
‫اذا ﺑﺪي اﻛﺘﺐ ﺳﻜﺮﻳﺖ ﻳﺎﺧﺬ درﺟﺔ اﻟﻄﺎﻟﺐ ﻟﻮ اﻟﻄﺎﻟﺐ ﻧﺎﺟﺢ رح ﺗﻨﻄﺒﻊ‬
‫اﻧﻮ ﻧﺎﺟﺢ‪:‬‬
‫‪degree =90‬‬
‫‪if (degree >80):‬‬
‫)"‪print("success‬‬

‫ﻫﻮن ﻋﺮﻓﺖ ﻣﺘﻐﻴﺮ ﺑﻴﺤﻤﻞ ﻗﻴﻤﺔ درﺟﺔ اﻟﻄﺎﻟﺐ‬

‫وﻣﻨﻘﺪر ﻧﺴﺘﺨﺪم داﻟﺔ اﻻدﺧﺎل اﻟﺴﺎﺑﻖ ﺷﺮﺣﻬﺎ )( ‪ input‬ﻣﺸﺎن ﻧﺪﺧﻞ‬
‫ﻧﺘﻴﺠﺔ اﻟﻄﺎﻟﺐ‪..‬‬
‫ﺑﻌﺪﻳﻦ ﻣﺎرخ ﻧﻄﺒﻊ ﻣﺒﺎﺷﺮة واﻧﻤﺎ رح ﻧﺴﺘﺨﺪم اﻟﻌﺒﺎرة اﻟﺸﺮﻃﻴﺔ ‪if‬‬
‫ﺑﻌﺪﻳﻦ ﻣﻨﻔﺘﺢ ﻗﻮﺳﻴﻦ وﻧﻜﺘﺐ ﺑﻘﻠﺒﻦ اﻟﺸﺮط وﻫﻮ ﺑﻜﻮن ﺑﺼﻮرة ﺳﺆال ﻫﻞ‬
‫درﺟﺔ اﻟﻄﺎﻟﺐ اﻛﺒﺮ ﻣﻦ ‪80‬؟‬

‫ﻃﺒﻌﺎ ﻧﺤﻨﺎ ﻗﻠﻨﺎ اﻧﻮ اﻟﻨﺘﻴﺠﺔ اﻟﻤﺮﺟﻌﺔ ﻣﻦ اﻟﺸﺮط ‪comparison‬‬

‫‪ operators‬اﻣﺎ ‪ true or false‬وﺑﺎﻟﻤﺜﺎل رح ﺗﻜﻮن اﻟﻨﺘﻴﺠﺔ ‪ true‬وﺑﻤﺎ‬
‫اﻧﻮ ﻧﺘﻴﺠﺔ اﻟﺸﺮط ‪ true‬ﻓـ رح ﻳﻨﻔﺬ ﺟﻤﻠﺔ اﻟﻄﺒﺎﻋﺔ‪..‬‬

‫‪DONE..‬‬
‫======================================‬
‫======================================‬

‫‪ -2‬اﻟﺠﻤﻞ اﻟﺸﺮﻃﻴﺔ ‪conditional statements‬‬

‫ﻋﺮﻓﻨﺎ اﻧﻮ اﻟﻬﺪف ﻣﻦ ﻛﺘﺎﺑﺘﻬﺎ ﻫﻮ اﻟﺘﺤﻜﻢ ﺑﻤﺴﺎر اﻟﺒﺮﻧﺎﻣﺞ‪..‬‬

‫اﻟﺤﺎﻟﺔ اﻟﺘﺎﻧﻴﺔ ﻣﻦ ﺣﺎﻻت ‪ if‬وﻫﻴﺔ ‪..if else‬‬

 ‫وﻫﻴﺔ ﺗﺴﺘﺨﺪم ﺑﺤﺎﻟﺔ وﺟﻮد اﺣﺘﻤﺎﻟﻴﻦ‪.‬‬
‫وﺻﻴﻐﺘﺎ اﻟﻌﺎﻣﺔ‪:‬‬
‫‪if(condition):‬‬
‫‪statements1‬‬
‫‪else:‬‬
‫‪statements2‬‬

‫ﻣﻨﻜﺘﺐ ﺟﻤﻠﺔ اﻟﺸﺮط ﺑﺎﺳﺘﺨﺪام ﻋﺒﺎرة ‪ if else‬ﻛﺎﻟﺘﺎﻟﻲ ‪:‬‬

‫ﻣﻨﻜﺘﺐ اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ if‬وﺑﻌﺪﻫﺎ ﻣﻨﻔﺘﺢ ﻗﻮﺳﻴﻦ وﻣﻨﻜﺘﺐ ﺑﻘﻠﺒﻦ‬
‫اﻟﻌﺒﺎرة او اﻟﻌﺒﺎرات اﻟﻠﻲ ﺑﺪﻧﺎ ﻧﺘﺤﻘﻖ ﻣﻦ ﺻﺤﺘﻬﺎ‪..‬‬
‫وﻻزم ﺗﻜﻮن اﻟﻨﺘﻴﺠﺔ اﻟﻤﺮﺟﻌﺔ‪:‬‬
‫)‪boolean (true or false‬‬

‫وﻫﺎﻟﺸﻲ ﺑﺎﺳﺘﺨﺪام اﺣﺪ ﻣﻌﺎﻣﻼت اﻟﻤﻘﺎرﻧﺔ اﻟﺴﺎﺑﻖ ﺷﺮﺣﻬﻢ‬

‫‪.comparison operators‬‬
‫واﻟﺪﻣﺞ ﺑﻴﻨﻬﻢ ﻋﻨﺪ وﺟﻮد اﻛﺜﺮ ﻣﻦ ﺷﺮط او ﻋﺒﺎرة ﺑﺎﺳﺘﺨﺪام‬
‫‪and‬‬
‫‪or‬‬

‫وﺑﻌﺪﻳﻦ ﻣﻨﻜﺘﺐ اﻟﺠﻤﻠﺔ اﻟﻠﻲ ﺑﺪﻧﺎ ﻧﻨﻔﺬﻫﺎ ﺑﺤﺎﻟﺔ ﺗﺤﻘﻖ اﻟﺸﺮط‬

‫ﺑﻌﺪﻳﻦ ﻣﻨﻜﺘﺐ ﻋﺒﺎرة ‪ else‬ﺑﻌﺪﻫﺎ ﻣﻨﻜﺘﺐ اﻟﺠﻤﻠﺔ اﻟﻠﻲ ﺑﺪﻧﺎ ﻧﻨﻔﺬﻫﺎ ﺑﺤﺎﻟﺔ‬
‫ﻋﺪم ﺗﺤﻘﻖ اﻟﺸﺮط‪..‬‬

‫وﻣﻨﻼﺣﻆ ‪:‬‬
‫_ ﺑﺤﺎﻟﺔ ﺗﺤﻘﻖ اﻟﺸﺮط ) ﻧﺘﻴﺠﺔ اﻟﺸﺮط ‪ ( true‬رح ﻳﻨﻔﺬ ‪..statement1‬‬
‫اﻣﺎ ﺑﺤﺎﻟﺔ ﻋﺪم ﺗﺤﻘﻖ اﻟﺸﺮط )ﻧﺘﻴﺠﺔ اﻟﺸﺮط ‪ ( false‬رح ﻳﻨﻔﺬ‬
‫‪..statement2‬‬

‫ﻣﺜﺎل‪:‬‬
 ‫ﻟﻮ ﺑﺪي اﻛﺘﺐ ﺳﻜﺮﺑﺖ ﻳﺎﺧﺬ درﺟﺔ اﻟﻄﺎﻟﺐ ﻟﻮ درﺟﺔ اﻟﻄﺎﻟﺐ اﻛﺒﺮ ﻣﻦ او‬
‫ﻳﺴﺎوى ‪ ٨٠‬ﻣﻨﻘﻠﻮ ﻧﺎﺟﺢ وﻟﻮ اﻗﻞ ﻣﻦ ‪ ٨٠‬ﻣﻨﻘﻠﻮ راﺳﺐ‪:‬‬
‫‪degree =90‬‬
‫‪if (degree >=80):‬‬
‫)"‪print("success‬‬
‫‪else :‬‬
‫)"‪print("fail‬‬

‫‪DONE..‬‬
‫======================================‬
‫======================================‬

‫‪ -3‬اﻟﺠﻤﻞ اﻟﺸﺮﻃﻴﺔ ‪Condition statment‬‬

‫ﺑﻌﺪ ﻣﺎ اﺧﺪﻧﺎ اﻟﺤﺎﻟﺔ اﻻوﻟﻰ ﻣﻦ ﻋﺒﺎرة ‪if‬‬

‫‪- simple if‬‬
‫و اﻟﺤﺎﻟﺔ اﻟﺘﺎﻧﻴﺔ وﻫﻴﺔ‪:‬‬
‫‪- if else‬‬

‫ف رح اﺣﻜﻲ ﻋﻦ اﻟﺤﺎﻟﺔ اﻟﺘﺎﻟﺘﺔ ﻣﻦ ﺣﺎﻻت ‪ if‬وﻫﻴﺔ ‪..if else if‬‬

‫وﻫﻴﺔ ﺗﻜﺘﺐ ﺑﺎﻟﺼﻮرة اﻟﺘﺎﻟﻴﺔ ‪..elif‬‬

‫وﺗﺴﺘﺨﺪم ﺑﺤﺎﻟﺔ وﺟﻮد اﻛﺘﺮ ﻣﻦ ﺷﺮط او اﺣﺘﻤﺎل‪..‬‬
‫وﺻﻴﻐﺘﺎ اﻟﻌﺎﻣﺔ‪:‬‬
‫‪if condition:‬‬
‫‪statements1‬‬
‫‪elif condition:‬‬
‫‪statements2‬‬
‫‪elif condition:‬‬
 ‫‪statements3‬‬

‫‪else :‬‬
‫‪statements‬‬

‫ﻣﺘﻞ ﻣﺎﺷﺮﺣﺖ ﺳﺎﺑﻘﺎ ﻛﻴﻒ ﻣﻨﻜﺘﺐ اﻟـ ‪ if‬ف ﺑﻌﺪ ﻣﺎ ﻧﻜﺘﺐ اﻟـ ‪if‬‬
‫ﻣﻨﻜﺘﺐ ﻋﺒﺎرة ‪ elif‬وﻣﻨﻜﺘﺐ اﻟﻌﺒﺎرة اﻟﻠﻲ ﺑﺪﻧﺎ ﻧﺘﺤﻘﻖ ﻣﻦ ﺻﺤﺘﻬﺎ‪..‬‬

‫وﺑﻌﺪﻫﺎ ﻣﻨﻜﺘﺐ اﻟﺠﻤﻠﺔ اﻟﻠﻲ ﺑﺪﻧﺎ ﻧﻨﻔﺬﻫﺎ ﺑﺤﺎﻟﺔ ﺗﺤﻘﻖ اﻟﺸﺮط‪..‬‬

‫ﺑﻌﺪﻫﺎ رح ﻳﻜﺮر ﻋﺒﺎرة ‪ elif‬ﺑﻌﺪد اﻻﺣﺘﻤﺎﻻت او اﻟﺸﺮوط اﻟﻤﺘﻮﻗﻌﺔ‪..‬‬
‫ﺑﻌﺪﻳﻦ ﻣﻨﻜﺘﺐ ﻋﺒﺎرة ‪ else‬وﻣﻨﻜﺘﺐ ﺑﻘﻠﺒﺎ اﻟﺠﻤﻠﺔ اﻟﻠﻲ ﺑﺪﻧﺎ ﻧﻨﻔﺬﻫﺎ ﺑﺤﺎﻟﺔ‬
‫ﻋﺪم ﺗﺤﻘﻖ اي ﺷﺮط ﻣﻦ اﻟﺸﺮوط اﻟﺴﺎﺑﻘﺔ‪..‬‬

‫وﻣﻨﻼﺣﻆ ‪:‬‬
‫_ ﺑﺤﺎﻟﺔ ﺗﺤﻘﻖ اﻟﺸﺮط ) ﻧﺘﻴﺠﺔ اﻟﺸﺮط ‪ ( true‬رح ﻳﻨﻔﺬ اﻟﺠﻤﻠﺔ اﻟﺨﺎﺻﺔ‬
‫ﺑﻬﺎد اﻟﺸﺮط وﺑﻌﺪﻫﺎ رح ﻳﺨﺮج ﻣﺒﺎﺷﺮة ﻣﻦ ﺟﻤﻠﺔ ‪ if‬دون اﺧﺘﺒﺎر ﺑﺎﻗﻲ‬
‫اﻟﺸﺮوط‪..‬‬

‫اﻣﺎ ﺑﺤﺎﻟﺔ ﻋﺪم ﺗﺤﻘﻖ اﻟﺸﺮط )ﻧﺘﻴﺠﺔ اﻟﺸﺮط ‪ ( false‬رح ﻳﻨﺘﻘﻞ ﻣﺒﺎﺷﺮة‬
‫ﻟﻠﺸﺮط اﻟﻠﻲ ﺑﻌﺪو ﻟﺤﺘﻰ ﻣﺎ ﻳﺘﺤﻘﻖ اﻟﺸﺮط‪..‬‬
‫ﺑﻌﺪﻳﻦ ﺑﻜﻤﻞ ﺗﻨﻔﻴﺬ ﺑﺎﻗﻲ اﻻﻛﻮاد اﻟﻤﻮﺟﻮدة ﺑﺎﻟﺴﻜﺮﺑﺖ‪..‬‬

‫ﻣﺜﺎل‪:‬‬
‫ﺑﺎﻓﺘﺮاض ﻃﻠﺐ ﻣﻨﻚ اﻟﻘﻴﺎم ﺑﻌﻤﻞ ﺗﻄﺒﻴﻖ ﻟﻠﺘﺤﻘﻖ ﻣﻦ اﻟﻌﻤﺮ ﻟﻠﻤﺘﻘﺪﻣﻴﻦ‬
‫ﻋﻠﻰ ﻣﻨﺢ ﻣﻘﺪﻣﺔ ﻣﻦ اﻟﺪوﻟﺔ‬
‫ﺑﺤﻴﺚ ﻳﻘﺒﻞ ﻓﻘﻂ اﻟﺸﺨﺺ ﻣﻦ ﻋﻤﺮ ‪ ١٨‬و ‪ ٢٢‬ﺳﻨﺔ‬

‫ﻣﻨﻌﺮف اﻟﻤﺘﻐﻴﺮات‬
‫ﺑﻌﺪﻳﻦ رح ﻳﺒﻠﺶ ﻳﺨﺘﺒﺮ اﻟﺸﺮط اﻻول ﻓﺎذا ﻛﺎﻧﺖ ﻧﺘﻴﺠﺔ اﻟﺸﺮط ‪true‬‬
‫رح ﻳﻄﺒﻊ اﻟﺠﻤﻠﺔ اﻟﻠﻲ ﺑﻘﻠﺐ اﻟﺸﺮط‪..‬‬
 ‫وﺑﺎﻟﺘﺎﻟﻲ رح ﻳﻄﻠﻊ ﻣﺒﺎﺷﺮة ﻣﻦ ﺟﻤﻠﺔ ‪ if‬دون ﺗﻨﻔﻴﺬ ﺑﺎﻗﻲ ﺟﻤﻞ اﻟﺸﺮط‪..‬‬

‫اﻣﺎ اذا ﻛﺎﻧﺖ ﻧﺘﻴﺠﺔ اﻟﺸﺮط ‪false‬‬

‫رح ﻳﻨﺘﻘﻞ اﻟﺴﻜﺮﺑﺖ ﻣﺒﺎﺷﺮة ﻟﻠﺸﺮط اﻟﻠﻲ ﺑﻌﺪو وﻫﻜﺬا ﺑﻀﻞ ﻳﻨﺘﻘﻞ ﻟﻠﺸﺮط‬
‫اﻟﻠﻲ ﺑﻌﺪو ﻃﺎﻟﻤﺎ اﻧﻮ ﻧﺘﻴﺠﺔ اﻟﺸﺮط ‪false‬‬
‫‪age=20‬‬
‫‪if age <18:‬‬
‫)'‪print('you are too young‬‬
‫‪elif age>22:‬‬
‫)'‪print('you are too old‬‬
‫‪else:‬‬
‫)'‪print('welcome‬‬

‫‪DONE..‬‬
‫======================================‬
‫======================================‬

‫‪ -6‬اﻟـ ‪While loop‬‬

‫ﻣﻨﺴﺘﺨﺪﻣﺎ ﻟﺘﻜﺮار اﻟﻜﻮد ﻋﺪد ﻣﺤﺪد ﻣﻦ اﻟﻤﺮات وﻓﻘﺎ ﻟﺸﺮط ﻣﻌﻴﻦ‪..‬‬

‫ﺑﺤﻴﺚ ﻻ ﻳﺘﻢ ﺗﻨﻔﻴﺬ اﻟﻜﻮد اﻻ ﺑﺤﺎﻟﺔ ﺗﺤﻘﻖ اﻟﺸﺮط‪..‬‬
‫اﻣﺎ ﺑﺤﺎﻟﺔ ﻋﺪم ﺗﺤﻘﻖ اﻟﺸﺮط ﻓـ ﻣﺎرح ﻳﻨﻔﺬ اﻟﻜﻮد وﻟﻮ ﻟﻤﺮة وﺣﺪة‪..‬‬
‫وﻗﺒﻞ اﺳﺘﺨﺪام اداة ‪ while‬ﻻزم ﻧﺤﺪد ارﺑﻌﺔ ﻋﻨﺎﺻﺮ وﻫﻴﺔ ‪:‬‬
‫‪1- initial value‬‬
‫وﻫﻴﺔ اﻟﻘﻴﻤﺔ اﻻﺑﺘﺪاﺋﻴﺔ ﻟﻠﻤﺘﻐﻴﺮ‪..‬‬

‫‪2-statements‬‬
‫وﻫﻮ اﻟﻜﻮد اﻟﺒﺮﻣﺠﻲ‪..‬‬
‫‪3-condition‬‬
‫وﻫﻮ اﻟﺸﺮط اﻟﻠﻲ رح ﻧﺤﻄﻮ ﻟﺪﺧﻮل ‪ loop‬ﺑﺤﺎﻟﺔ ﺗﺤﻘﻘﻮ )‪..( true‬‬
‫اﻣﺎ ﺑﺤﺎﻟﺔ ﻋﺪم ﺗﺤﻘﻘﻮ )‪ ( false‬رح ﻳﺨﺮج ﻣﻦ ‪loop‬‬

‫‪4- incremental step‬‬

‫ﻣﺜﺎل‪:‬‬
‫ﺣﺘﻰ ﻧﻘﺪر ﻣﻦ اﻧﻮ ﻧﻄﺒﻊ اﻻﻋﺪاد ﻣﻦ ‪ ١‬ﺣﺘﻰ ‪ ٥‬ﺑﺎﺳﺘﺨﺪام ‪:while‬‬
‫‪counter=1‬‬
‫‪while counter<=5:‬‬
‫)‪print(counter‬‬
‫‪counter=counter+1‬‬

‫ﻫﻮن ﻣﻨﻼﺣﻆ ‪:‬‬

‫‪ -‬اﻟﻌﻨﺎﺻﺮ اﻻرﺑﻌﺔ اﻟﺴﺎﺑﻖ ﺷﺮﺣﻬﻢ ﻣﻮﺟﻮدﻳﻦ‪:‬‬

‫‪counter=1‬‬ ‫‪initial value‬‬

‫)‪print(counter‬‬ ‫‪statements‬‬
‫‪counter<=5‬‬ ‫‪condition‬‬
‫‪counter=counter+1‬‬ ‫‪incremental‬‬

‫اﻣﺎ ﻃﺮﻳﻘﺔ ﻋﻤﻞ ‪ while‬ﻣﻨﻘﺪر ﻧﻠﺨﺼﻬﺎ ‪:‬‬

‫ﺑﺎﻟﺒﺪاﻳﺔ ﻣﻨﻌﺮف ﻣﺘﻐﻴﺮ ﻣﺎ ‪ ...‬اﻧﺎ ﺑﺎﻟﻤﺜﺎل ﻋﺮﻓﺖ اﺳﻤﻮ ‪ counter‬وﻋﻄﻴﺘﻮ‬
‫ﻗﻴﻤﺔ اﺑﺘﺪاﺋﻴﺔ ‪ 1‬ﺑﻌﺪﻳﻦ رح ﻳﺮوح ﻟﻠﺸﺮط وﻳﺴﺄل ﻫﻞ ‪ 1‬اﻗﻞ ﻣﻦ او‬
‫ﺗﺴﺎوي ‪5‬؟‬
‫اﻻﺟﺎﺑﺔ رح ﺗﻜﻮن ‪ true‬وﺑﺎﻟﺘﺎﻟﻲ رح ﻳﺪﺧﻞ ﻟﻠـ ‪ loop‬ورح ﻳﻄﻴﻊ ﻗﻴﻤﺔ‬
‫‪ counter‬وﻫﻴﺔ ‪..1‬‬

‫ﺑﻌﺪﻳﻦ رح ﻳﺮوح ﻟﻠـ ‪ incremental step‬ورح ﻳﺰﻳﺪ ﻗﻴﻤﺔ ‪counter‬‬

 ‫ﺑﻮاﺣﺪ ﻟﺘﺼﺒﺢ اﻟﻘﻴﻤﺔ اﻟﻤﺨﺰﻧﺔ ﺑﺎﻟـ ‪ counter‬ﻫﻴﺔ ‪2‬‬
‫ﺑﻌﺪﻳﻦ رح ﻳﺮوح ﻟﻠﺸﺮط وﻳﺴﺄل ﻫﻞ ‪ 2‬اﻗﻞ ﻣﻦ او ﺗﺴﺎوي ‪ 5‬؟‬
‫اﻻﺟﺎﺑﺔ رح ﺗﻜﻮن ‪ true‬وﺑﺎﻟﺘﺎﻟﻲ رح ﻳﺪﺧﻞ ﻟﻠـ ‪ loop‬ورح ﻳﻄﺒﻊ ﻗﻴﻤﺔ‬
‫‪ counter‬وﻫﻴﺔ ‪..2‬‬

‫وﻫﻜﺬا ﺣﺘﻰ ﺗﺼﻴﺮ ﻗﻴﻤﺔ ‪ counter‬ﺗﺴﺎوي ‪ 6‬ﻓﺒﺮوح ﻟﻠﺸﺮط وﺑﻴﺴﺄل ﻫﻞ‬

‫‪ 6‬اﻗﻞ ﻣﻦ او ﺗﺴﺎوي ‪5‬؟‬
‫اﻻﺟﺎﺑﺔ رح ﺗﻜﻮن ‪ false‬وﺑﺎﻟﺘﺎﻟﻲ رح ﻳﺨﺮج ﻣﻦ ‪..loop‬‬

‫‪DONE..‬‬
‫======================================‬
‫======================================‬

‫‪ -7‬اﻟـ ‪for loop‬‬

‫وﻫﻴﺔ ﺗﺴﺘﺨﺪم ﻟﺘﻜﺮار اﻟﻜﻮد ﻋﺪد ﻣﺤﺪد ﻣﻦ اﻟﻤﺮات وﻣﺎرح ﻳﺘﻮﻗﻒ ‪loop‬‬
‫ﺣﺘﻰ ﻳﻨﺘﻬﻲ ﻣﻦ اﻟﻌﺪد اﻟﻤﺤﺪد ﺑﺎﻟﺘﻜﺮار‪..‬‬

‫و ‪ for loop‬اﻟﻬﺎ ﻋﺪة اﺳﺘﺨﺪاﻣﺎت ﻣﻊ اﻟﻤﺘﻐﻴﺮات واﻟﻘﻮاﺋﻢ وﺧﻼﻓﻮ‪..‬‬

‫رح وﺿﺤﻬﺎ ﻛﺎﻟﺘﺎﻟﻲ ‪:‬‬

‫ﻣﺜﺎل ﻻﺳﺘﺨﺪام ‪ for‬ﻣﻊ اﻟﻤﺘﻐﻴﺮات ‪:‬‬

‫ﻟﻮ ﺑﺪي اﻃﺒﻊ ﺣﺮوف اﺳﻤﻚ ﺑﺎﺳﺘﺨﺪام ‪:for‬‬

‫'‪name='karam‬‬
‫‪for i in name :‬‬
‫)‪print(i‬‬
‫ﺑﺎﻟﺒﺪاﻳﺔ ﻋﺮﻓﺖ ﻣﺘﻐﻴﺮ ﻳﺤﻤﻞ اﻻﺳﻢ‬
‫ﺑﻌﺪﻳﻦ ﻛﺘﺒﺖ ‪ for‬ﻳﻠﻴﻬﺎ اﺳﻢ اﻟﻤﺘﻐﻴﺮ اﻟﺨﺎص ‪for‬‬
‫اﻟﻠﻲ رح ﻳﺤﻤﻞ اﻟﻘﻴﻤﺔ اﻟﺠﺎﻳﺔ اﻟﻮ ﻣﻦ اﻟﻤﺘﻐﻴﺮ‪..‬‬
 ‫ﺑﻌﺪﻳﻦ ﻣﻨﻜﺘﺐ اﻟﻜﻠﻤﺔ اﻟﻤﺤﺠﻮزة ‪ in‬ﺑﻌﺪﻫﺎ ﺑﻜﺘﺐ اﺳﻢ اﻟﻤﺘﻐﻴﺮ اﻟﻠﻲ رح‬
‫ﻳﺤﻤﻞ اﻻﺳﻢ‪..‬‬

‫وﺑﺎﻟﻨﻬﺎﻳﺔ رح ﻧﻄﺒﻊ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ اﻟﺨﺎص ب ‪for‬‬

‫ﻣﻦ ﺧﻼل ﻋﻤﻞ ‪ loop‬ﻋﻠﻰ ﺣﺮف ﺣﺮف ﻣﻦ ﺣﺮوف اﻟﻤﺘﻐﻴﺮ ‪name‬‬
‫وادﺧﺎﻟﻬﺎ ﺑﺎﻟﻤﺘﻐﻴﺮ ‪ i‬وﺑﻌﺪﻳﻦ ﻃﺒﺎﻋﺘﻮ‪..‬‬

‫ﻣﺜﺎل‪:‬‬
‫رح اﺳﺘﺨﺪم ‪ for‬ﻣﻊ اﻟﺪاﻟﺔ ‪:range‬‬

‫ﺣﺘﻰ ﺗﻘﺪر ﻣﻦ ﻃﺒﺎﻋﺔ اﺳﻤﻚ ﺧﻤﺴﺔ ﻣﺮات‪:‬‬

‫‪for i in range(5) :‬‬

‫)'‪print('fawzy‬‬

‫ﻫﻮن داﻟﺔ ‪ range‬رح ﺗﻌﻄﻴﻨﺎ ﻣﻌﺪل ﻟﻠﺘﻜﺮار وﻫﻮ ﺧﻤﺴﺔ ﺗﻜﺮارات ﺣﺴﺐ‬
‫ﻃﺒﻌﺎ اﻟﺒﺮاﻣﻴﺘﺮ اﻟﻤﻌﻄﻰ ﻟﻬﺎ‪..‬‬
‫وﺑﺎﻟﺘﺎﻟﻲ رح ﺗﺘﻢ اﻟﻄﺒﺎﻋﺔ ﺧﻤﺴﺔ ﻣﺮات‪..‬‬

‫داﻟﺔ ‪ range‬ﻟﻮ ﻋﻄﻴﺘﺎ ﻟﻬﺎ ﺑﺮاﻣﻴﺘﺮ واﺣﺪ ﺑﺲ رح ﻳﺒﺪء ﻣﻦ ‪ 0‬وﻳﺘﻮﻗﻒ‬

‫ﻋﻨﺪ اﻟﺒﺮاﻣﻴﺘﺮ اﻟﻤﻌﻄﻰ‪.‬‬
‫ﺑﻤﻌﻨﻰ اﺧﺮ‬
‫)‪range(5)=range(0,5‬‬

‫ﻣﺜﺎل اﺧﺮ رح وﺿﺢ اﺳﺘﺨﺪام اﺧﺮ ﻟﻠﺪاﻟﺔ ‪:range‬‬

‫ﺣﺘﻰ ﻧﻘﺪر ﻧﻄﺒﻊ اﻻﻋﺪاد ﻣﻦ ‪ 0‬ﺣﺘﻰ ‪ 10‬ﺑﺎﺳﺘﺨﺪام ‪for‬‬

‫‪for i in range(1,11):‬‬
‫)‪print(i‬‬
 ‫ﻫﻮن ﻣﻨﻼﺣﻆ ‪:‬‬
‫اﻧﻮ اﻟﺒﺮاﻣﻴﺘﺮ اﻻول ﻟﻠﺪاﻟﺔ ‪ range‬ﺑﻮﺿﺢ ﺑﺪاﻳﺔ اﻟـ ‪.loop‬‬
‫ﺑﻴﻨﻤﺎ اﻟﺒﺮاﻣﻴﺘﺮ اﻟﺘﺎﻧﻲ ﻓﻬﻮ ﺑﻮﺿﺢ اﻧﻮ اﻟﻠﻮب رح ﻳﺘﻮﻗﻒ او ﻳﻨﺘﻬﻲ وﻗﺖ‬
‫ﺗﺼﻴﺮ ﻗﻴﻤﺔ ‪ i‬ﺑـ ‪ 11‬دون ﻃﺒﺎﻋﺔ ﻫﻲ اﻟﻘﻴﻤﺔ‪..‬‬

‫وﺑﺎﻟﺘﺎﻟﻲ رح ﻳﻄﺒﻊ ﻗﻴﻤﺔ ‪ i‬وﻫﻴﺔ ﺑﺎﻟﺒﺪاﻳﺔ ‪ 1‬ﺑﻌﺪﻳﻦ ﺑﺎﻗﻲ اﻻرﻗﺎم ﺣﺘﻰ‬

‫ﻳﻮﺻﻞ ﻟﻠـ ‪ 11‬وﻳﺘﻮﻗﻒ اﻟﻠﻮب دون ﻃﺒﺎﻋﺔ ﻫﻲ اﻟﻘﻴﻤﺔ‪..‬‬

‫‪DONE..‬‬
‫======================================‬
‫======================================‬

‫‪ -8‬اﻟـ ‪Functions‬‬

‫ﺑﺄي ﺳﻜﺮﺑﺖ رح ﺗﺸﻮﻓﻮه ﻋﺎﻟﻨﺖ رح ﺗﻼﻗﻮ ﻣﺴﺘﺨﺪﻣﻴﻦ ﻫﺎﻟﺸﻜﻞ‪:‬‬

‫‪def function():‬‬
‫‪pass‬‬
‫ﻫﻮن ﻋﺮﻓﺖ اﻟـ ‪ function‬ﺑﻘﺪر ﺣﻂ اي ﺷﻲ ﺑﺪي ﻳﺎه ﺑﺪل اﺳﻢ‬
‫‪function‬‬
‫ﻣﺜﺎل‪:‬‬
‫‪def test():‬‬
‫‪pass‬‬
‫ﻋﺮﻓﺖ اﻟـ ‪ function‬ﺑﺎﺳﻢ ‪test‬‬
‫ﻫﻠﻖ اﻟـ ‪ pass‬اﻟﻠﻲ ﻛﺎﺗﺒﺎ ﺑﺘﻌﻨﻲ اﻧﻮ ﻳﺘﺨﻄﺎﻫﺎ ﻟﻠـ ‪ function‬ﻛﻼ‪..‬‬

‫ﻣﺜﺎل ﻟﻠﺘﻮﺿﻴﺢ‪:‬‬
‫‪def test():‬‬
‫‪pass‬‬
‫)"‪print("Test‬‬
‫)"‪print("Hello‬‬

‫ﻫﻮن رح ﻳﻄﺒﻊ ‪ Hello‬ﻓﻘﻂ‪..‬‬

‫اﻣﺎ اﻟـ ‪ Test‬ف ﻣﺎﻃﺒﻌﻬﺎ ﻻﻧﻲ ﺣﺎﻃﻂ ‪ pass‬ﻟﻠـ ‪..function‬‬

‫ﻓﻲ ﺷﻐﻠﺔ ﻣﻬﻤﺔ وﻛﺘﻴﺮ ﻻزم ﻧﻌﺮﻓﻬﺎ واﻟﻠﻲ ﻫﻴﺔ اﻧﻮ اﻟﺒﺎﻳﺜﻮن ﺣﺴﺎﺳﺔ‬
‫ﻟﻠﻤﺴﺎﻓﺎت ﻛﺘﻴﻴﺮ‪..‬‬
‫ﻳﻌﻨﻲ ﺑﺎﻟﻤﺜﺎل ﺣﺎﻃﻂ اﻧﻮ ﻳﻄﺒﻊ اﻟـ ‪ Test‬ﺿﻤﻦ اﻟـ ‪function‬‬
‫اﻣﺎ ﻃﺒﺎﻋﺔ اﻟـ ‪ Hello‬ف ﻻﺣﻈﻮ ﻣﻮﺟﻮدة ﺧﺎاارج اﻟـ ‪ function‬ﻣﺸﺎن‬
‫ﻫﻴﻚ ﻃﺒﻊ اﻟـ ‪ Hello‬وﻣﺎﻃﺒﻊ ﺷﻲ ﻏﻴﺮﻫﺎ‪..‬‬

‫ﻫﻠﻖ ﺑﻘﺎ ﻓﺮﺿﺎ اﻧﺎ ﺑﺪي اﻃﺒﻊ ‪ hello‬ﺑﺎﺳﺘﺨﺪام ‪ function‬ﻓـ ﻻزم اﻛﺘﺐ‬
‫ﺳﻄﺮ ﺑﺮﻣﺠﻲ ﻟﺘﺸﺘﻐﻞ اﻟـ ‪ function‬واﻟﻠﻲ ﻫﻮو‪:‬‬

‫‪if __name__ == '__main__':‬‬

‫)(‪functionName‬‬

‫ﻣﺜﺎل‪:‬‬
‫‪def test():‬‬
‫)"‪print("Hello‬‬

‫‪if __name__ == '__main__':‬‬

‫)(‪test‬‬

‫ﻫﻮن رح ﻳﻄﺒﻊ ‪.. Hello‬اﻣﺎا اذا ﺷﻐﻠﻨﺎ اﻟـ ‪ function‬ﺑﺪون ﻫﺎﻟﺴﻄﺮ‬

‫اﻟﺒﺮﻣﺠﻲ ف رح ﻳﻘﻠﻚ ﻓﻲ ﺧﻄﺎ‪..‬وﻣﺎرح ﻳﺸﺘﻐﻞ ﺷﻲ‪..‬‬

‫‪DONE..‬‬
‫======================================‬
‫======================================‬
 ‫‪ -9‬اﻟـ ‪class‬‬

‫اﻟﻜﻼس ﻋﺒﺎرة ﻋﻦ ﺣﺎوﻳﺔ ﺑﺘﻘﺪر اﻧﻮ ﺗﺤﻂ ﺑﻘﻠﺒﻬﺎ ﻣﺘﻐﻴﺮات‪ ..‬ﻣﺼﻔﻮﻓﺎت‪..‬‬

‫دوال إﻟﺦ‪..‬‬
‫ﻟﺘﻌﺮﻳﻒ ﻛﻼس ﺟﺪﻳﺪ ﻣﻨﻜﺘﺐ ‪ class‬و ﻣﻨﺤﻄﻠﻮ اﺳﻢ‪..‬وﺑﻌﺪﻳﻦ ﻣﻨﺤﻂ‬
‫ﻧﻘﻄﺘﻴﻦ‪..‬‬

‫ﻣﺜﺎل‪:‬‬
‫ﻋﻤﻠﺖ ﻛﻼس اﺳﻤﻮ ‪ MyClass‬وﺣﻄﻴﺖ ﻓﻴﻪ ﻣﺘﻐﻴﺮ اﺳﻤﻮ ‪x‬‬

‫‪class MyClass:‬‬
‫‪x=3‬‬

‫اول ﺷﻐﻠﺔ‪:‬‬
‫اي ﻣﺘﻐﻴﺮ ﺑﺪﻧﺎ ﻧﻌﺮﻓﻮ ﺑﺸﻜﻞ ﻣﺒﺎﺷﺮ ﺑﺎﻟـ ‪ Class‬ﻓـ ﻣﻨﻄﻠﻖ ﻋﻠﻴﻪ اﺳﻢ‬
‫‪property‬‬
‫اﻟﺴﺒﺐ اﻧﻮ ﻛﻞ ﻧﺴﺨﺔ ﺑﺘﻌﻤﻼ ﻣﻦ اﻟﻜﻼس ﺑﻜﻮن اﻟﻬﺎ ﻧﺴﺨﺘﻬﺎ اﻟﺨﺎﺻﺔ ﻣﻦ‬
‫اﻟﻤﺘﻐﻴﺮ‬

‫ﺗﺎﻧﻲ ﺷﻐﻠﺔ‪:‬‬
‫ﻋﻨﺎ ﻳﺎﻫﺎ ﺑﺎﻟﻜﻼس ﻫﻲ اﻟـ ‪object‬‬
‫اﻟـ ‪ object‬ﻋﺒﺎرة ﻋﻦ ﻧﺴﺨﺔ ﻣﻦ اﻟﻜﻼس‪..‬‬
‫ﻟﻌﻤﻞ ﻧﺴﺨﺔ ﻣﻦ ﻛﻼس ﻣﻌﻴﻦ ﻣﻨﻌﺮف ﻣﺘﻐﻴﺮ ﻗﻴﻤﺘﻪ ﺗﺴﺎوي اﺳﻢ اﻟﻜﻼس‪..‬‬
‫وﻣﻨﺤﻂ ﻗﻮﺳﻴﻦ‪..‬‬

‫ﻣﺜﺎل‪:‬‬
‫‪class MyClass:‬‬
‫‪x=0‬‬
‫‪obj = MyClass‬‬

‫‪obj.x = 10‬‬

‫)‪print('obj.x =', obj.x‬‬

‫ﻋﺮﻓﺖ ﻛﻼس اﺳﻤﻮ ‪ ..MyClass‬وﺣﻄﻴﺖ ﻓﻴﻪ ﻣﺘﻐﻴﺮ اﺳﻤﻮ ‪ ..x‬ﺑﻌﺪﻳﻦ‬

‫ﻋﻤﻠﺖ ﻛﺎﺋﻦ ﻣﻦ ﻫﺎد اﻟﻜﻼس اﺳﻤﻮ ‪..obj‬‬
‫اﻟـ ‪ output‬رح ﻳﻜﻮن‬
‫‪obj.x = 10‬‬

‫ﺗﺎﻟﺖ ﺷﻐﻠﺔ‪:‬‬
‫ﺑﺎﻟﻜﻼس ﻣﻨﺴﺘﺨﺪم ﺑﺎراﻣﻴﺘﺮ ‪..self‬‬
‫وﻗﺖ ﺑﺪي ﻋﺮف داﻟﺔ ﺑﺪاﺧﻞ ﻛﻼس‪..‬‬
‫ﺑﺎﻳﺜﻮن ﺑﺘﺠﺒﺮك ع وﺿﻊ اﻟﻜﻠﻤﺔ ‪ self‬او اي ﻛﻠﻤﺔ ﺗﺎﻧﻴﺔ ﻛﺎول ﺑﺎراﻣﻴﺘﺮ ﻓﻴﻬﺎ‬
‫و ﻣﻦ ﺛﻢ وﺿﻊ اﻟﻌﺪد اﻟﻠﻲ ﺑﺪك ﻳﺎه ﻣﻦ اﻟﺒﺎراﻣﻴﺘﺮات‪...‬‬

‫اﻟﺨﻼﺻﺔ‪ :‬ﺣﺘﻰ ﻟﻮ ﻣﺎ ﺑﺪك ﺗﺤﻂ ﺑﺎﻟﺪاﻟﺔ اب ﺑﺎراﻣﻴﺘﺮ ﻓـ رح ﺗﻜﻮن ﻣﺠﺒﺮ ع‬

‫وﺿﻊ اﻟﻜﻠﻤﺔ ‪ self‬او اي ﻛﻠﻤﺔ ﺗﺎﻧﻴﺔ ﻛﺒﺎراﻣﻴﺘﺮ ﻓﻴﻬﺎ‪..‬‬

‫ﺳﺒﺐ وﺿﻊ اﻟﻜﻠﻤﺔ ‪ self‬ﻛﺎول ﺑﺎراﻣﻴﺘﺮ ﺑﺎﻟﺪاﻟﺔ‪:‬‬

‫وﺿﻊ اﻟﻜﻠﻤﺔ ‪ self‬ﻛﺎول ﺑﺎراﻣﻴﺘﺮ ﺑﺎﻟﺪاﻟﺔ ﺑﺨﻠﻲ اﻟﺒﺎﻳﺜﻮن ﻗﺎدرة ع‬

‫اﻟﻮﺻﻮل ﻟﻠﺨﺼﺎﺋﺺ اﻟﻤﻮﺟﻮدة ﺑﻨﻔﺲ اﻟﻜﻼس‪..‬‬
‫ﻳﻌﻨﻲ وﻗﺖ ﺑﺪي ﺣﻂ ﻫﻲ اﻟﻜﻠﻤﺔ ﻛﺒﺎراﻣﺘﻴﺮ ﺑﺎﻟﺪاﻟﺔ ﺑﺘﺼﻴﺮ ﻫﻲ اﻟﻜﻠﻤﺔ‬
‫ﺑﻤﺜﺎﺑﺔ ﻣﺆﺷﺮ ﻟﻠﻜﻼس ﻧﻔﺴﻮ اﻟﺸﻲ اﻟﻠﻲ ﺑﺨﻠﻴﻚ ﻗﺎدر ع اﻟﻮﺻﻮل ﻻي ﺷﻲ‬
‫ﺗﻢ ﺗﻌﺮﻳﻔﻮ داﺧﻞ اﻟﻜﻼس ﻋﻦ ﻃﺮﻳﻘﻬﺎ‪..‬‬
 :‫ﻣﺜﺎل‬
class Comparator:
def print_max(self, a, b):
if a > b:
print(a, 'is bigger')
elif a < b:
print(b, 'is bigger')
else:
print('They are equal')

comparator = Comparator()

comparator.print_max(2, 6)

..Comparator ‫ﻫﻮن ﻋﻤﻠﺖ ﻛﻼس اﺳﻤﻮ‬

..( b ‫ و‬a ) ‫ ﻓﻴﻬﺎ ﺑﺎراﻣﻴﺘﺮﻳﻦ ﻓﻘﻂ‬print_max ‫وﺣﻄﻴﺖ ﻓﻴﻪ داﻟﺔ اﺳﻤﺎ‬
‫ ﻛﺎول ﺑﺎراﻣﻴﺘﺮ ﺑﺎﻟﺪاﻟﺔ ﺣﺘﻰ‬self ‫ﻻﺣﻈﻮ اﻧﻮ ﻣﺠﺒﺮﻳﻦ ع اﻧﻮ ﻧﺤﻂ اﻟﻜﻠﻤﺔ‬
..‫وﻟﻮ ﻣﺎﻧﺎ ﺑﺤﺎﺟﺘﻬﺎ‬

‫ رح ﻳﻜﻮن‬output ‫اﻟـ‬
6 is bigger

DONE..
======================================
======================================

Й Basics ‫ﻫﻴﻚ ﻣﻨﻜﻮن ﺧﻠﺼﻨﺎ اﻟـ‬

======================================

Author: The Fiend

Copyright: The Fiend ®™
Version: Not available

Last modified: 12:27 PM