‫ﻤﻪ‬

‫ﻫ‬
‫ی‬
‫ﺑﺮا‬
‫ن‬ ‫ﺘﻮ‬
‫ﭘﺎﯾ‬

‫ﻣﺒﺎﺣﺚ ﭘﯿﺸﺮﻓﺘﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﭘﺎﯾﺘﻮن‬

‫آﻣﻮزش ﭘﯿﺸﺮﻓﺘﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺑﻪ زﺑﺎن ﭘﺎﯾﺘﻮن ‪PYTHON‬‬

‫‪۱۴۰۱‬‬
‫اﻣﯿﺮﺣﺴﯿﻦ ﺧﺴﺮوی‬
‫‪2022‬‬

‫‪amirkho.ir‬‬
 ‫ﻣ ﻘ ﺪﻣ ﻪ‬

‫اﻣﯿﺮﺣﺴﯿﻦ ﺧﺴﺮوی ﻫﺴﺘﻢ ﮐﺎرﺷﻨﺎﺳﯽ ﻣﻬﻨﺪﺳﯽ ﻧﺮم اﻓﺰار )ﺗﺎ ﺑﻪ اﯾﻨﺠﺎی دوره ﺳﺎل ‪ .(۱۴۰۱‬در دوره ﻫﺎی ﻣﺘﻌﺪد و ﻣﻌﺘﺒﺮ ﺑﯿﻦ اﻟﻤﻠﻠﯽ در زﻣﯿﻨﻪ ﻧﺮم اﻓﺰار ﺷﺮﮐﺖ ﮐﺮده ام و دارای ﭼﻨﺪ ﮔﻮاﻫﯿﻨﺎﻣﻪ ﺑﯿﻦ اﻟﻤﻠﻠﯽ و‬ ‫•‬

‫ﮔﻮاﻫﯽ ﻣﺪرس از ﺳﺎزﻣﺎن ﻓﻨﯽ و ﺣﺮﻓﻪ ای ﮐﺸﻮر ﻫﺴﺘﻢ و ﺳﺎﺑﻘﻪ ﺗﺪرﯾﺲ در آﻣﻮزﺷﮕﺎه ﻫﺎی ﻣﻌﺘﺒﺮ ﮐﺸﻮر و آﻣﻮزش ﻫﺎی آزاد در ﺑﺮﺗﺮﯾﻦ داﻧﺸﮕﺎه ﻫﺎی ﮐﺸﻮر دارم‪.‬‬

‫ﺑﺴﯿﺎر ﺧﻮﺷﺤﺎل ﻫﺴﺘﻢ ﮐﻪ اﯾﻦ دوره را ﺑﺮای ﺷﺮوع ﯾﺎدﮔﯿﺮی اﻧﺘﺨﺎب ﮐﺮده اﯾﺪ ﭼﺮاﮐﻪ در ﻣﺴﯿﺮ درﺳﺘﯽ ﺟﻬﺖ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﻗﺮار ﮔﺮﻓﺘﻪ اﯾﺪ‪.‬‬ ‫•‬

‫از ‪ ۱۲‬دوازده ﺳﺎﻟﮕﯽ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ را ﺷﺮوع ﮐﺮده ام و ﺣﺪودا ﺗﺎ اﻻن ‪ 6‬ﺳﺎل اﺳﺖ ﮐﻪ ﺑﻪ زﺑﺎن ﭘﺎﯾﺘﻮن ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﻣﯿﮑﻨﻢ و ﭘﺮوژه ﻫﺎی ﻣﺘﻌﻌﺪی اﻧﺠﺎم داده ام‪.‬‬ ‫•‬

‫در اﯾﻦ آﻣﻮزش ﺳﻌﯽ ﺷﺪه از ﺑﺮوزﺗﺮﯾﻦ ﻣﺘﺪ ﻫﺎی آﻣﻮزﺷﯽ و ﺗﺠﺮﺑﻪ ﺷﺨﺼﯽ ‪ ۵‬ﺳﺎﻟﻪ در زﻣﯿﻨﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﭘﺎﯾﺘﻮن اﺳﺘﻔﺎده ﺑﺸﻮد ﮐﻪ ﺷﻤﺎ ﻋﺰﯾﺰان ﺑﯿﺸﺘﺮﯾﻦ ﺑﻬﺮه را ﺑﺒﺮﯾﺪ‪.‬‬ ‫•‬

‫در ﺑﺨﺶ ﻫﺎﯾﯽ از آﻣﻮزش ﭘﺮوژه ﻫﺎی ﻋﻤﻠﯽ را اﻧﺠﺎم ﻣﯿﺪﻫﯿﻢ‪ .‬در ﻫﺮ ﺑﺨﺸﯽ ﮐﻪ ﺑﻪ ﻣﺸﮑﻞ ﺧﻮردﯾﺪ ﻣﯿﺘﻮاﻧﯿﺪ از ﻃﺮﯾﻖ ﺳﺎﯾﺖ ﯾﺎ اﯾﻤﯿﻞ ﻣﺪرس ﺳﻮاﻻت ﺧﻮد را ﻣﻄﺮح ﮐﻨﯿﺪ‪.‬‬ ‫•‬

‫در اﯾﻦ دوره ﻣﺒﺎﺣﺚ ﺗﮑﻤﯿﻠﯽ دوره ﻣﻘﺪﻣﺎﺗﯽ ﺑﺮرﺳﯽ ﺧﻮاﻫﺪ ﺷﺪ ‪ +‬ﻣﺒﺎﺣﺚ ﻣﻌﻤﺎری ﻧﺮم اﻓﺰار و اﻧﻮاع روش ﻫﺎی ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ‪ +‬ﭼﻨﺪﯾﻦ اﺑﺰار ‪ /‬ﻣﺎژول ‪ /‬ﭼﺎرﭼﻮب ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﮐﺎرﺑﺮدی‪.‬‬ ‫•‬

‫• ارﺗﺒﺎط ﻣﺴﺘﻘﯿﻢ ﺑﺎ ﻣﺪرس‪:‬‬ ‫ﺗﻮﺻﯿﻪ ﻫﺎی ﺷﺨﺼﯽ در ﮐﻨﺎر آﻣﻮزش اﯾﻦ دوره‪:‬‬ ‫•‬

‫‪ Ø‬وﺑﺴﺎﯾﺖ ﺷﺨﺼﯽ ‪amirkho.ir‬‬ ‫ﺻﺒﺮ و ﺣﻮﺻﻠﻪ‬ ‫‪ü‬‬

‫‪ Ø‬اﯾﻤﯿﻞ ‪[email protected]‬‬ ‫ﺗﺴﻠﻂ ﮐﺎﻣﻞ ﺑﻪ دوره ﻣﻘﺪﻣﺎﺗﯽ‬ ‫‪ü‬‬

‫ﺳﻌﯽ ﺑﺮ درک ﻣﻔﻬﻮﻣﯽ ﺑﺮﻧﺎﻣﻪ ﻧﻪ ﺣﻔﻆ ﮐﺮدن ﮐﺪ‬ ‫‪ü‬‬

‫ﺗﻤﺮﯾﻦ ﻫﺎی ﻣﺘﻌﺪد‬ ‫‪ü‬‬

 ‫ﻓﻬﺮﺳﺖ ﻣﺤﺘﻮا‬

‫‪9‬‬ ‫ﻣﻘﺪﻣﻪ و ﺳﺨﻦ ﻣﺪرس‬ ‫‪1‬‬

‫‪10‬‬ ‫اﻫﺪاف دوره ﭘﯿﺸﺮﻓﺘﻪ‬ ‫‪2‬‬

‫‪11‬‬ ‫ﺷﯿﻮه ﻫﺎی ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ‪Programming Paradigm‬‬ ‫‪3‬‬

‫‪12‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ دﺳﺘﻮری ‪imperative programming‬‬ ‫‪4‬‬

‫‪13‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ اﻋﻼﻧﯽ ‪Declarative programming‬‬ ‫‪5‬‬

‫‪14‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺗﺎﺑﻌﯽ ‪Functional programming‬‬ ‫‪6‬‬

‫‪15‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪O.O.P‬‬ ‫‪7‬‬

‫‪16‬‬ ‫‪8‬‬

‫ﺟﻬﺖ دﺳﺘﺮﺳﯽ ﺑﻪ ﻫﺮ ﺑﺨﺶ روی ﺷﻤﺎره ﺑﺨﺶ آن ﮐﻠﯿﮏ ﮐﻨﯿﺪ‬

27 17

28 18

29 19

30 20

31 21

32 22

33 23

34 24

35 25

36 26
47 37

48 38

49 39

50 40

51 41

52 42

53 43

54 44

55 45

56 46
67 57

68 58

69 59

70 60

71 61

72 62

73 63

74 64

75 65

76 66
87 77

88 78

89 79

90 80

91 81

92 82

93 83

94 84

95 85

96 86
107 97

108 98

109 99

110 100

111 101

112 102

113 103

114 104

115 105

116 106
127 117

128 118

129 119

130 120

131 121

132 122

133 123

134 124

135 125

136 126
 ‫اﻫﺪاف اﯾﻦ دوره؟‬
‫در اﯾﻦ دوره ﺑﻪ ﻣﺒﺎﺣﺚ ﺗﮑﻤﯿﻠﯽ دوره ﻣﻘﺪﻣﺎﺗﯽ ﻣﯿﭙﺮدازﯾﻢ‪.‬‬ ‫•‬

‫ﺑﺎ اﻃﻼﻋﺎت ﻋﻤﻮﻣﯽ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺑﯿﺸﺘﺮی آﺷﻨﺎ ﺧﻮاﻫﯿﻢ ﺷﺪ‪.‬‬ ‫•‬

‫ﺗﻐﯿﯿﺮات و اﻣﮑﺎﻧﺎت ﺟﺪﯾﺪ ﭘﺎﯾﺘﻮن از ﻧﺴﺨﻪ ‪ ۳.۱۰‬را ﺑﺮرﺳﯽ و اﺳﺘﻔﺎده ﺧﻮاﻫﯿﻢ ﮐﺮد‪.‬‬ ‫•‬

‫روش ﻫﺎی ﻣﺨﺘﻠﻒ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ را ﺑﺮرﺳﯽ ﻣﯿﮑﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺑﻪ ﻣﺒﺎﺣﺚ ﻣﻌﻤﺎری ﻧﺮم اﻓﺰار ﺧﻮاﻫﯿﻢ ﭘﺮداﺧﺖ‪.‬‬ ‫•‬

‫از اﺑﺰار ﻫﺎی ﮐﻤﮑﯽ ﺑﯿﺸﺘﺮی اﺳﺘﻔﺎده ﺧﻮاﻫﯿﻢ ﮐﺮد‪.‬‬ ‫•‬

‫ﭘﺲ از ﺗﺴﻠﻂ ﺑﺮ ﻣﺒﺎﺣﺚ ﻣﻘﺪﻣﺎﺗﯽ و ﻣﻌﻤﺎری ﻧﺮم اﻓﺰار و‪ ...‬ﺑﻪ ﺣﻮزه ﻫﺎی ﻣﺨﺘﻠﻒ ﺗﻮﺳﻌﻪ ﺑﺮﻧﺎﻣﻪ ﻫﺎی دﺳﮑﺘﺎپ و وب و ﻫﻮش‬ ‫•‬

‫ﻣﺼﻨﻮﻋﯽ و‪ ...‬وارد ﺧﻮاﻫﯿﻢ ﺷﺪ و از ﺑﺨﺶ ﻣﺒﺎﺣﺚ ﮐﺎرﺑﺮدی را ﻓﺮا ﺧﻮاﻫﯿﻢ ﮔﺮﻓﺖ‪.‬‬

‫روش ﻫﺎی اﯾﺪه ﭘﺮدازش و اﻧﺘﺸﺎر ﻣﺤﺼﻮل را ﻓﺮا ﺧﻮاﻫﯿﻢ ﮔﺮﻓﺖ‪.‬‬ ‫•‬

‫ﭼﻨﺪ ﻧﺮم اﻓﺰار ﮐﺎرﺑﺮدی در ﺣﻮزه ﻫﺎی ﻣﺨﺘﻠﻒ اﻧﺘﺸﺎر ﺧﻮاﻫﯿﻢ داد‪.‬‬ ‫•‬
 ‫‪ PEP‬ﭼﯿﺴﺖ؟‬

‫‪ PEP‬ﻣﺨﻔﻒ ﻋﺒﺎرت ‪ Python Enhancement Proposal‬اﺳﺖ‪.‬‬ ‫•‬

‫ﯾﮏ ﺳﻨﺪ اﺳﺖ ﮐﻪ اﻃﻼﻋﺎﺗﯽ را در اﺧﺘﯿﺎر ﺟﺎﻣﻌﻪ ﭘﺎﯾﺘﻮن ﻗﺮار ﻣﯿﺪﻫﺪ‪.‬‬ ‫•‬

‫وﯾﮋﮔﯽ ﻫﺎی ﺟﺪﯾﺪ ﭘﺎﯾﺘﻮن در ﻫﺮ ﻧﺴﺨﻪ را ﺗﻮﺻﯿﻒ ﻣﯿﮑﻨﺪ و ﻣﺸﺨﺼﺎت ﻓﻨﯽ از ﻫﺮ وﯾﮋﮔﯽ اراﺋﻪ ﻣﯿﺪﻫﺪ‪.‬‬ ‫•‬

‫ﻫﺮ ‪ PEP‬دارای ﻣﺸﺨﺼﺎﺗﯽ ﻣﺎﻧﻨﺪ ﺷﻤﺎره ‪ PEP‬و ﻧﻮﯾﺴﻨﺪﮔﺎن و ﺗﺎرﯾﺦ و… اﺳﺖ‪.‬‬ ‫•‬

‫ﻣﺨﺎﻃﺒﺎن اﺻﻠﯽ ‪ PEP‬ﺗﻮﺳﻌﻪ دﻫﻨﺪﮔﺎن اﺻﻠﯽ ﭘﺎﯾﺘﻮن ﻫﺴﺘﻨﺪ ﺑﺎ اﯾﻦ ﺣﺎل ﻣﺴﺘﻨﺪات ‪ PEP‬ﻣﯿﺘﻮاﻧﻨﺪ ﺑﺮای دﯾﮕﺮ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﺎن‬ ‫•‬

‫ﺑﺴﯿﺎر ﮐﺎرﺑﺮدی ﺑﺎﺷﻨﺪ‪.‬‬

‫ﻫﻤﭽﻨﯿﻦ دارای ﯾﮑﺴﺮی اﺳﺘﺎﻧﺪرد ﻫﺎ ﻣﯿﺒﺎﺷﻨﺪ ﮐﻪ اﮔﺮ رﻋﺎﯾﺖ ﺷﻮﻧﺪ ﻣﯿﺘﻮاﻧﻨﺪ ﻣﺸﮑﻼت ﭘﯿﭽﯿﺪه را در ﻗﺎﻟﺐ ﯾﮏ ﺗﯿﻢ ﻣﺪﯾﺮﯾﺖ ﮐﻨﺪ‪.‬‬ ‫•‬

‫ﺟﻬﺖ دﺳﺘﺮﺳﯽ ﺑﻪ اﺳﻨﺎد ‪ PEP‬ﺑﻪ آدرس ‪ peps.python.org‬ﺑﺎﯾﺪ ﻣﺮاﺟﻌﻪ ﮐﺮد‪.‬‬ ‫•‬

‫ﭘﺲ از ﻣﺮاﺟﻌﻪ ﺳﺎﯾﺖ رﺳﻤﯽ ﺟﺪاول ‪ PEP‬را ﻣﺸﺎﻫﺪه ﻣﯿﮑﻨﯿﻢ ﮐﻪ ﻫﺮ ﮐﺪام دارای ﺷﻤﺎره و ﻋﻨﻮان ﻣﯿﺒﺎﺷﻨﺪ‪.‬‬ ‫•‬
 ‫‪PEP 8‬‬ ‫‪PART 1‬‬

‫ﻗﺼﺪ دارﯾﻢ ﺑﺮﺧﯽ از ‪ PEP‬ﻫﺎ را ﺑﺮرﺳﯽ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﻣﺤﺘﻮای ﻗﺒﻠﯽ ﺑﺨﺸﯽ از ﺳﻨﺪ‪/‬ﺑﻨﺪ ‪ PEP1‬ﺑﻮدﻧﺪ‪.‬‬ ‫•‬

‫ﺑﻨﺪ ‪ ۸‬از ‪ PEP‬ﺗﻮﺳﻂ ﺧﻮد آﻗﺎی ‪ GvR‬ﺗﻌﺮﯾﻒ ﺷﺪه اﺳﺖ‪.‬‬ ‫•‬

‫ﺑﻨﺪ ‪ ۸‬از ‪ PEP‬ﯾﮏ ﺳﻨﺪ‪/‬ﺑﻨﺪ ﻋﻤﻮﻣﯽ ﻣﯿﺒﺎﺷﺪ ﮐﻪ ﯾﮑﺴﺮی اﺳﺘﺎﻧﺪارد ﻫﺎی ﮐﺪ ﻧﻮﯾﺴﯽ را ﺷﺮح ﻣﯿﺪﻫﺪ‪ .‬ﺑﺮﺧﯽ از آﻧﻬﺎ‪:‬‬ ‫•‬

‫ﻗﺒﻞ و ﺑﻌﺪ از ﺗﺎﺑﻊ ﺑﺎﯾﺪ دو ﺧﻂ ﻓﻀﺎی ﺧﺎﻟﯽ وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﻪ‪.‬‬ ‫•‬

‫ﻧﺎم ﯾﮏ ﺗﺎﺑﻊ ﺑﺎ ﺣﺮوف ﮐﻮﭼﮏ ﺑﺎﺷﺪ‪(my_function or lower_case_with_underscores ).‬‬ ‫•‬

‫ﻗﺒﻞ و ﺑﻌﺪ از ﮐﻼس ﺑﺎﯾﺪ دو ﺧﻂ ﻓﻀﺎی ﺧﺎﻟﯽ وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﻪ‪.‬‬ ‫•‬

‫ﻧﺎم ﯾﮏ ﮐﻼس ﺑﺎ ﺣﺮف ﺑﺰرگ ﺷﺮوع ﺷﻮد‪(MyClass) .‬‬ ‫•‬

 ‫‪PEP 8‬‬ ‫‪PART 2‬‬

‫ﺑﺮای ﻧﺎﻣﮕﺬاری ﺛﻮاﺑﺖ در ﺑﺮﻧﺎﻣﻪ از ﺣﺮوف ﺑﺰرگ اﺳﺘﻔﺎده ﺑﺸﻪ‪(MAX_OVERFLOW, TOTAL ) .‬‬ ‫•‬

‫ﻗﺒﻞ و ﺑﻌﺪ از ﺗﺎﺑﻊ و ﮐﻼس‪ ،‬در داﺧﻞ ﯾﮏ ﮐﻼس‪ ،‬ﺑﺎﯾﺪ ﯾﮏ ﺧﻂ ﻓﻀﺎی ﺧﺎﻟﯽ وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﻪ‪.‬‬ ‫•‬

‫در ﻫﻨﮕﺎم ﺗﻌﺮﯾﻒ ﻣﺘﻐﯿﺮ ﺑﺎﯾﺪ از ﯾﮏ ﻓﺎﺻﻠﻪ اﺳﺘﻔﺎده ﮐﺮد‪.‬‬ ‫•‬

‫ﺗﻌﺪاد ﮐﺎراﮐﺘﺮﻫﺎ در ﻫﺮ ﺧﻂ‪ ،‬ﻧﺒﺎﯾﺪ ﺑﯿﺸﺘﺮ از ‪ 79‬ﮐﺎراﮐﺘﺮ ﺷﻮد‪.‬‬ ‫•‬

‫ﻓﺮاﺧﻮاﻧﯽ ﻣﺎژوﻟﻬﺎی ﻣﺨﺘﻠﻒ )ﻣﺜﻼ ﻣﺎژول ‪ os‬و ‪ sys‬ﺑﺎﯾﺪ در ﺧﻄﻮط ﻣﺨﺘﻠﻒ و ﺟﺪاﮔﺎﻧﻪ اﻧﺠﺎم ﺷﻮد(‬ ‫•‬

‫رﻋﺎﯾﺖ اﺻﻮل ﺑﻨﺪ ‪ PEP ۸‬ﺑﺎﻋﺚ ﻣﯿﺸﻮد ﮐﺪ ﻣﺎ ﮐﻤﯽ ﺗﻤﯿﺰ ﺗﺮ ﺑﺎﺷﺪ‪.‬‬ ‫•‬

‫در ﻧﺘﯿﺠﻪ دﯾﺒﺎگ)رﻓﻊ ﺧﻄﺎﻫﺎی ﭘﺮوژه( ﺳﺎده ﺗﺮ ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬ ‫•‬

‫ﻫﻤﭽﻨﯿﻦ در ﮐﺎر ﮔﺮوﻫﯽ ﺧﻮاﻧﺎ ﺑﻮدن ﮐﺪ ﻫﺎی ﺑﺮﻧﺎﻣﻪ ﺑﺴﯿﺎر ﻣﻬﻢ اﺳﺖ‪.‬‬ ‫•‬

‫ﻣﺒﺎﺣﺚ ﮐﻼس و …در ﺑﺨﺶ ﻫﺎی ﺑﻌﺪی ﮐﺎر ﺧﻮاﻫﺪ ﺷﺪ‬

‫ﺗﻐﯿﯿﺮات ﭘﺎﯾﺘﻮن در ﻧﺴﺨﻪ ‪ 3.10‬و ‪3.11‬‬ ‫‪PART 1‬‬

‫ﯾﮑﺴﺮی اﻣﮑﺎﻧﺎت ﺑﺴﯿﺎر ﮐﺎرﺑﺮدی در اﯾﻦ ﻧﺴﺨﻪ ﻫﺎ ﺑﻪ ﭘﺎﯾﺘﻮن اﺿﺎﻓﻪ ﺷﺪه اﺳﺖ‪.‬‬ ‫•‬

‫اﯾﻦ ﺗﻐﯿﯿﺮات در ﻗﺎﻟﺐ ﺑﻨﺪ ﻫﺎی ‪ PEP 634,635,636‬و… ﺷﺮح داده ﺷﺪه اﺳﺖ‪.‬‬ ‫•‬

‫ﻣﻌﻤﻮﻻ در اﭘﺪﯾﺖ ﻫﺎ ﯾﮑﺴﺮی ﺗﻐﯿﯿﺮات ﻗﺎﻋﺪه ﮐﺪ ﻧﻮﯾﺴﯽ )‪ (syntax‬اﻧﺠﺎم ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫ﮔﺎﻫﯽ ﻧﯿﺰ اﻣﮑﺎﻧﺎت ﺟﺪﯾﺪی اﺿﺎﻓﻪ ﻣﯿﺸﻮد‪.‬‬ ‫•‬

 ‫روش ﻫﺎی ﻣﺨﺘﻠﻒ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ )‪(PROGRAMMING PARADIGM‬‬

‫ﺑﻪ روش ﻫﺎی ﻣﺨﺘﻠﻒ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ‪ Programming Paradigm‬ﮔﻔﺘﻪ ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫ﯾﮏ زﺑﺎن ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﻣﯿﺘﻮاﻧﺪ از ﯾﮏ ﯾﺎ ﭼﻨﺪ ﺷﯿﻮه ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﭘﺸﺘﯿﺒﺎﻧﯽ ﻧﻤﺎﯾﺪ‪.‬‬ ‫•‬

‫ﻫﺪف اﻧﻮاع روش ﻫﺎی ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﮐﺪ ﻧﻮﯾﺴﯽ ﺑﻬﯿﻨﻪ ﺗﺮ و ﻗﺎﺑﻠﯿﺖ ﺧﻮاﻧﺎﯾﯽ ﺑﺎﻻ در ﺗﻮﺳﻌﻪ ﻫﺎی ﺑﻌﺪی و ﮐﺎر ﺗﯿﻤﯽ ﻣﯿﺒﺎﺷﺪ‪.‬‬ ‫•‬

‫ﺑﺎ اﻧﺘﺨﺎب ﺷﯿﻮه درﺳﺖ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﻣﺤﺼﻮل ﻧﻬﺎﯾﯽ ﻋﻤﻠﮑﺮد ﻓﻨﯽ ﺑﺎﻻﺗﺮی ﺧﻮاﻫﺪ داﺷﺖ‪.‬‬ ‫•‬

‫ﻗﺒﻞ از ﺑﺮرﺳﯽ ﻓﻨﯽ روش ﻫﺎی ﻣﺨﺘﻠﻒ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ و ﺷﺮوع ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﻣﯿﺒﺎﯾﺴﺖ روش ﻫﺎ را ﺑﻪ درﺳﺘﯽ درک ﮐﺮد ﭘﺲ‬ ‫•‬

‫ﺑﺮای اﯾﻦ ﻣﺮﺣﻠﻪ ﺻﺒﺮ و ﺣﻮﺻﻠﻪ داﺷﺘﻪ ﺑﺎﺷﯿﺪ‪.‬‬

‫در ﺑﺨﺶ ﻫﺎی ﺑﻌﺪی اﻧﻮاع روش ﻫﺎی ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺑﺮرﺳﯽ ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬ ‫•‬
 ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ دﺳﺘﻮری ‪IMPERATIVE PROGRAMMING‬‬

‫ﯾﮑﯽ از ﺷﯿﻮه ﻫﺎی ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ اﺳﺖ ﮐﻪ در آن ﻣﺮاﺣﻞ اﺟﺮای ﯾﮏ ﺑﺮﻧﺎﻣﻪ ﮐﺎﻣﭙﯿﻮﺗﺮی ﻗﺪم ﺑﻪ ﻗﺪم ﺗﻮﺳﻂ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺲ ﺑﯿﺎن ﻣﯽ ﺷﻮد‪.‬‬ ‫•‬

‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل اﮔﺮ ﻗﺼﺪ ﺑﺎزﮐﺮدن درﺑﯽ را داﺷﺘﻪ ﺑﺎﺷﯿﻢ و ﺑﺎ زﺑﺎن دﺳﺘﻮری ﻗﺼﺪ ﺑﯿﺎن آن را داﺷﺘﻪ ﺑﺎﺷﯿﻢ ﺧﻮاﻫﯿﻢ ﮔﻔﺖ ﺑﻠﻨﺪ‬ ‫•‬

‫ﺷﻮ ‪،‬ﺑﻪ ﻃﺮف درب ﻧﺰدﯾﮏ ﺷﻮ‪ ،‬دﺳﺘﮕﯿﺮه را ﺑﮕﯿﺮ و درب را ﺑﻪ ﻃﺮف ﺑﯿﺮون ﻫﻞ ﺑﺪه‪.‬‬

‫زﺑﺎن ﻣﺎﺷﯿﻦ و ‪ c‬و ‪ shell‬و ‪ COBOL‬و ‪ Pascal‬از روش ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ دﺳﺘﻮری اﺳﺘﻔﺎده ﻣﯿﮑﻨﻨﺪ‪.‬‬ ‫•‬
 ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ اﻋﻼﻧﯽ ‪DECLARATIVE PROGRAMMING‬‬

‫در اﯾﻦ روش ﻣﻨﻄﻖ و ﻫﺪف ﻣﺤﺎﺳﺒﺎت ﺑﺪون ﺷﺮح ِ ﭼﮕﻮﻧﮕﯽ اﻧﺠﺎم آﻧﻬﺎ ﺑﯿﺎن ﻣﯽ ﺷﻮد‪.‬‬ ‫•‬

‫اﯾﻦ روش ﻣﻄﺎﺑﻘﺖ ﮐﺎﻣﻞ و واﺿﺢ ﺑﺎ ﻣﻨﻄﻖ رﯾﺎﺿﯿﺎت دارد‪.‬‬ ‫•‬

‫ﺑﺮﺧﻼف زﺑﺎن ﻫﺎی دﺳﺘﻮری‪ ،‬زﺑﺎن ﻫﺎی اﻋﻼﻧﯽ ﺑﻪ ﺟﺎی ﺗﺄﮐﯿﺪ ﺑﺮ ﭼﮕﻮﻧﮕﯽ اﻧﺠﺎم ﯾﮏ ﻋﻤﻞ روی اﯾﻨﮑﻪ ﭼﻪ ﮐﺎری ﻣﯿﺨﻮاﻫﯿﻢ اﻧﺠﺎم‬ ‫•‬

‫دﻫﯿﻢ ﺗﺎﮐﯿﺪ ﻣﯿﮑﻨﯿﻢ‪.‬‬

‫ﺑﺮای ﻣﺜﺎل در ﭘﺎﯾﮕﺎه ﻫﺎی داده ﻣﺒﺘﻨﯽ ﺑﺮ زﺑﺎن ‪ SQL‬ﻓﻘﻂ ﻣﯿﮕﻮﯾﯿﻢ ﭼﻪ ﭼﯿﺰی ﻧﯿﺎز دارﯾﻢ و ﮐﺎر ﺑﺎ ﭼﮕﻮﻧﮕﯽ آن ﻋﻤﻞ ﻧﺪارﯾﻢ و ﺧﻮد‬ ‫•‬

‫آن زﺑﺎن آن ﻣﻮارد را ﻫﻨﺪل ﻣﯿﮑﻨﺪ‪.‬‬

‫ﺑﺮﺧﯽ از زﺑﺎن ﻫﺎی اﻋﻼﻧﯽ ‪ SQL , Prolog‬و‪...‬‬ ‫•‬

‫در اﯾﻦ دوره از زﺑﺎن ‪ SQL‬ﮐﻨﺎر ﭘﺎﯾﺘﻮن در ﭼﻨﺪ ﺑﺮﻧﺎﻣﻪ ﮐﺎرﺑﺮدی اﺳﺘﻔﺎده ﺧﻮاﻫﯿﻢ ﮐﺮد‪.‬‬ ‫•‬
 ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺗﺎﺑﻌﯽ ‪FUNCTIONAL PROGRAMMING‬‬

‫در دوره ﻣﻘﺪﻣﺎﺗﯽ ﺷﯿﻮه ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﻣﺎ ﻫﻤﯿﻦ ﺷﯿﻮه ﺗﺎﺑﻌﯽ ﺑﻮد‪.‬‬ ‫•‬

‫در اﯾﻦ روش ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﻣﺮاﺣﻞ اﺟﺮای ﺑﺮﻧﺎﻣﻪ در ﻗﺎﻟﺐ ﺗﺮﮐﯿﺐ ﺗﻮاﺑﻊ و ﻓﺮاﺧﻮاﻧﯽ آﻧﻬﺎ ﺗﻮﺳﻂ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺲ اﺳﺖ‪.‬‬ ‫•‬

‫در اﯾﻦ روش ﺑﺨﺶ ﻫﺎی ﻣﺨﺘﻠﻒ ﯾﮏ ﺑﺮﻧﺎﻣﻪ را ﺟﺪاﮔﺎﻧﻪ ﺑﻪ ﺻﻮرت ﺗﺎﺑﻊ اﯾﺠﺎد ﻣﯿﮑﻨﯿﻢ و ﻫﺮ ﺟﺎ ﮐﻪ ﺑﻪ آﻧﻬﺎ ﻧﯿﺎز داﺷﺘﻪ ﺑﺎﺷﯿﻢ ﻓﺮاﺧﻮاﻧﯽ ﯾﺎ‬ ‫•‬

‫در ﺻﻮرت ﻧﯿﺎز آﻧﻬﺎ را ﺗﺮﮐﯿﺐ ﻣﯿﮑﻨﯿﻢ‪.‬‬

‫ﺑﺮ ﺧﻼف زﺑﺎن ﻫﺎی دﺳﺘﻮری در روش ﺗﺎﺑﻌﯽ ﺧﻮد ﺗﻮاﺑﻊ ﻧﻮع داده ای اوﻟﯿﻪ ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫ﺑﺪﯾﻦ ﻣﻌﻨﯽ ﮐﻪ از ﺧﺮوﺟﯽ ﺗﻮاﺑﻊ ﺑﻪ ﻋﻨﻮان ﻣﻘﺪار ﺑﺎزﮔﺸﺘﯽ در ﻣﺘﻐﯿﯿﺮ ﻫﺎ و‪ ...‬ﻣﯿﺘﻮاﻧﯿﻢ اﺳﺘﻔﺎده ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫در ﭘﺎﯾﺘﻮن از اﯾﻦ روش ﺑﻪ ﺧﻮﺑﯽ ﻣﯿﺘﻮاﻧﯿﻢ اﺳﺘﻔﺎده ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫اﻟﺒﺘﻪ ﭘﺎﯾﺘﻮن ﻣﺤﺪود ﺑﻪ اﯾﻦ روش ﻧﯿﺴﺖ و ﻣﯿﺘﻮان روش ﻫﺎی ﻣﺨﺘﻠﻔﯽ و ﺗﺮﮐﯿﺒﯽ از آﻧﻬﺎ در ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﮐﺎر ﮔﺮﻓﺖ‪.‬‬ ‫•‬
 ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 1‬‬

‫ﭘﺎﯾﺘﻮن ﯾﮏ زﺑﺎن ‪ Multi-Paradigm‬اﺳﺖ‪.‬‬ ‫•‬

‫ﺷﺊ ﮔﺮاﯾﯽ ﯾﮑﯽ از ﺷﯿﻮه ﻫﺎی ﭘﺮﻃﺮﻓﺪار ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ اﺳﺖ‪.‬‬ ‫•‬

‫اﺧﺘﺼﺎرا ﺑﻪ آن ‪ OOP‬ﻧﯿﺰ ﻣﯿﮕﻮﯾﻨﺪ‪.‬‬ ‫•‬

‫ﻫﻤﭽﻨﯿﻦ ﯾﮏ اﻟﮕﻮ ‪/‬ﺷﯿﻮه ﺗﻔﮑﺮ اﺳﺖ ﮐﻪ ﺑﺮﮔﺮﻓﺘﻪ از دﻧﯿﺎی واﻗﻌﯽ اﺳﺖ ﯾﻌﻨﯽ ﻧﺤﻮه ﻣﺪﯾﺮﯾﺖ اﻃﻼﻋﺎت و ﻋﻤﻠﮑﺮد ﻫﺎ و‪ ...‬ﺷﺒﯿﻪ ﺑﻪ دﻧﯿﺎی‬ ‫•‬

‫واﻗﻌﯽ اﺳﺖ‪.‬‬

‫ﻫﻤﻪ ﭼﯿﺰ از ﺟﻤﻠﻪ ﺗﻮاﺑﻊ و داده ﻫﺎ در ﻗﺎﻟﺒﯽ ﺑﻪ ﻧﺎم ﺷﺊ در ﮐﻨﺎر ﻫﻢ ﻗﺮار دارﻧﺪ‪.‬‬ ‫•‬

‫ﭘﺲ ﺧﻮد ﺗﻮاﺑﻊ ﻧﯿﺰ در روش ﺑﻪ ﮐﺎر ﮔﺮﻓﺘﻪ ﺧﻮاﻫﻨﺪ ﺷﺪ‪.‬‬ ‫•‬

‫در اﯾﻦ روش ﺗﻤﺮﮐﺰ اﺻﻠﯽ ﺑﺮ اﯾﻦ ﻧﯿﺴﺖ ﮐﻪ ﭼﻪ ﮐﺎری اﻧﺠﺎم دﻫﯿﻢ‪.‬‬ ‫•‬

‫ﺑﻠﮑﻪ ﺗﻤﺮﮐﺰ اﺻﻠﯽ ﺑﺮ روی داده ﻫﺎ و وﯾﮋﮔﯽ ﻫﺎی آﻧﻬﺎﺳﺖ ﺳﭙﺲ ﻋﻤﻠﯿﺎت ﻣﺪ ﻧﻈﺮ)ﺗﻮاﺑﻊ(‪.‬‬ ‫•‬

‫ﺑﺮﺧﯽ از زﺑﺎن ﻫﺎی ﺷﺊ ﮔﺮا‪PHP,PYTHON,DART :‬‬ ‫•‬

 ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 2‬‬

‫در ﭘﺎﯾﺘﻮن ﻫﻤﻪ ﭼﯿﺰ ﺑﻪ ﻧﻮﻋﯽ ﯾﮏ ﻧﻮع ﺷﺊ اﺳﺖ‪.‬‬ ‫•‬

‫ﻣﻨﻈﻮر از ﻫﻤﻪ ﭼﯿﺰ داده ﻫﺎ در ﻗﺎﻟﺐ ﻣﺘﻐﯿﯿﺮ و ﺗﻮاﺑﻊ در ﻗﺎﻟﺐ ﻣﺘﺪ ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫ﻫﺮ ﺷﺊ ﻧﯿﺰ ﯾﮑﺴﺮی وﯾﮋﮔﯽ و ﯾﮑﺴﺮی ﻋﻤﻠﮑﺮد دارد‪.‬‬ ‫•‬

‫وﯾﮋﮔﯽ ﻫﺎ ‪ /‬ﺻﻔﺖ ﻫﺎ دﻗﯿﻘﺎ ﻣﺘﻐﯿﯿﺮ ﻫﺎﯾﯽ ﻫﺴﺘﻨﺪ ﮐﻪ ﻣﺸﺨﺼﺎت و ﻣﻘﺎدﯾﺮ آن ﺷﺊ را ﻣﺸﺨﺺ ﻣﯿﮑﻨﺪ‪.‬‬ ‫•‬

‫ﺗﻮاﺑﻊ ﯾﮏ ﺷﺊ ﻧﯿﺰ ﻫﻤﺎن ﻋﻤﻠﮑﺮد آن اﺳﺖ‪.‬‬ ‫•‬

‫زﻣﺎﻧﯽ ﮐﻪ ﯾﮏ ﺗﺎﺑﻊ ﺻﺮﻓﺎ ﺑﺮای ﺷﺊ ﺧﺎﺻﯽ اﺳﺖ ﺑﻪ آن ‪ Method‬ﻣﯿﮕﻮﯾﯿﻢ‪.‬‬ ‫•‬

‫ﺑﺮای ﻣﺜﺎل ﻧﻮع داده ﻟﯿﺴﺖ ﯾﮏ ﺷﺊ اﺳﺖ ﮐﻪ دارای ﻣﻘﺪار و ﯾﮏ ﺳﺮی ﻣﺘﺪ ﻣﻨﺤﺼﺮ ﺑﻪ ﻓﺮد ﺧﻮدش اﺳﺖ ﻣﺜﻞ )(‪append‬‬ ‫•‬
 ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 3‬‬

‫ﯾﮑﯽ دﯾﮕﺮ از اﻫﺪاف ﻋﺪم ﺗﮑﺮار اﺳﺖ‪.‬‬ ‫•‬

‫ﺑﺮای ﻣﺜﺎل در ﺧﺼﻮص ﯾﮏ ﺷﺨﺺ ﻣﯿﺨﻮاﻫﯿﻢ اﻃﻼﻋﺎﺗﯽ را ﺗﻌﺮﯾﻒ ﮐﻨﯿﻢ ﯾﺎ داﺷﺘﻪ ﺑﺎﺷﯿﻢ ﻧﯿﺎزی ﻧﯿﺴﺖ ﺑﺮای ﻫﺮ ﺷﺨﺺ ﻣﺘﻐﯿﯿﺮ و ﺗﺎﺑﻊ‬ ‫•‬

‫ﺗﻌﺮﯾﻒ ﮐﻨﯿﻢ‪.‬‬

‫ﺑﻠﮑﻪ ﯾﮏ ﺷﺊ از ﻧﻮع ﻣﺜﻼ ‪ Person‬ﺗﻌﺮﯾﻒ ﻣﯿﮑﻨﯿﻢ و ﻫﺮﺟﺎ ﻧﯿﺎز داﺷﺘﻪ ﺑﺎﺷﯿﻢ از آن اﺳﺘﻔﺎده ﻣﯿﮑﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺑﺴﯿﺎری از اﻧﻮاع داده در ﭘﺎﯾﺘﻮن ﺧﻮدﺷﺎن ﺷﺊ ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫ﮐﻪ آن ﺷﺊ ﻫﺎ ﻣﯿﺘﻮاﻧﻨﺪ دارای ﻣﻘﺪار و رﻓﺘﺎر )ﻣﺘﺪ( ﺑﺎﺷﻨﺪ‪.‬‬ ‫•‬

‫ﺑﺮای ﻣﺜﺎل اﮔﺮ در ﻗﺎﻟﺐ ﯾﮏ ﻣﺘﻐﯿﯿﺮ ﯾﮏ ﺗﺎﭘﻞ ﺗﻌﺮﯾﻒ ﮐﻨﯿﻢ و آن ﻣﺘﻐﯿﯿﺮ را ﺑﻪ ﺗﺎﯾﻊ ‪ type‬ﺑﺪﻫﯿﻢ ﻧﻮع ﺷﺊ آن ﻫﻤﺎن ﺗﺎﭘﻞ اﺳﺖ و دارای‬ ‫•‬

‫ﯾﮑﺴﺮی رﻓﺘﺎر ﻫﺎی ﻣﻨﺤﺼﺮ ﺑﻪ ﻓﺮد ﺧﻮدش اﺳﺖ ﮐﻪ ﻫﻤﺎن ﻣﺘﺪ ﻫﺎی آن ﻣﯿﺒﺎﺷﺪ‪.‬‬

‫ﻣﺎ ﻧﯿﺰ ﻗﺼﺪ دارﯾﻢ ﭼﻨﯿﻦ اﺷﯿﺎﺋﯽ را اﯾﺠﺎد ﮐﻨﯿﻢ ﮐﻪ دارای ﻣﻘﺎدﯾﺮ و رﻓﺘﺎر ﻫﺎی ﻣﺨﺘﺺ ﺑﻪ ﺧﻮدﺷﺎن ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬
 ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 4‬‬

‫ﻓﺮض ﮐﻨﯿﺪ در ﺑﺮﻧﺎﻣﻪ ای ﻣﯿﻨﻮﯾﺴﯿﻢ ﺑﺎ ﺧﺼﻮﺻﯿﺎت ﯾﮏ اﻧﺴﺎن و رﻓﺘﺎر ﻫﺎﯾﺶ ﺳﺮ و ﮐﺎر زﯾﺎدی دارﯾﻢ‪.‬‬ ‫•‬

‫در اﯾﻨﺠﺎ اﻧﺴﺎن‪/‬ﺷﺨﺺ ﺷﺊ ﻣﺎ اﺳﺖ‪.‬‬ ‫•‬

‫دارای ﯾﮏ ﺳﺮی وﯾﮋﮔﯽ‪/‬ﺧﺼﻮﺻﯿﺖ اﺳﺖ و رﻓﺘﺎر اﺳﺖ‪.‬‬ ‫•‬

‫ﺑﯿﻦ ﻫﻤﻪ ﺷﺨﺺ ﻫﺎﯾﯽ ﮐﻪ ﻗﺼﺪ دارﯾﻢ ﺗﻌﺮﯾﻒ ﮐﻨﯿﻢ اﯾﻦ وﯾﮋﮔﯽ ﻫﺎ و رﻓﺘﺎر ﻫﺎ ﻣﺸﺘﺮک اﺳﺖ‪.‬‬ ‫•‬

‫ﻣﺜﻼ ﻫﻤﻪ اﺷﺨﺎص ﻧﺎم دارﻧﺪ و رﻧﮓ ﭼﺸﻢ دارﻧﺪ و‪...‬‬ ‫•‬
‫ﮐﻼس ‪class /‬‬ ‫ﺷﺨﺺ‬

‫”‪Name = “Amir‬‬

‫‪Age = 21‬‬ ‫ﺧﺼﻮﺻﯿﺖ ﻫﺎ ‪Attributes /‬‬

‫”‪EyeColor = “Brown‬‬

‫)(‪speak‬‬
‫رﻓﺘﺎر ﻫﺎ ‪Methods /‬‬
‫ﺷﺊ ‪object /‬‬ ‫)(‪sleep‬‬
‫‪class‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 5‬‬

‫ﭘﺲ ﺑﺎ ﻣﻔﻬﻮم ﺷﺊ ﮔﺮاﯾﯽ آﺷﻨﺎ ﺷﺪﯾﻢ‪.‬‬ ‫•‬

‫ﺟﻬﺖ اﯾﺠﺎد ﯾﮏ ﺷﯽ ﺑﺎﯾﺪ از ﮐﻠﻤﻪ ﮐﻠﯿﺪی ‪ class‬اﺳﺘﻔﺎده ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﯾﮏ ﮐﻼس ﻣﺤﯿﻄﯽ اﺳﺖ ﮐﻪ ﺧﺼﻮﺻﯿﺎت و رﻓﺘﺎر ﻫﺎی ﺷﺊ ﮐﻪ ﻣﺪ ﻧﻈﺮ دارﯾﻢ اﯾﺠﺎد ﮐﻨﯿﻢ را ﻧﮕﻪ دارای ﻣﯿﮑﻨﺪ‪.‬‬ ‫•‬

‫ﮐﻠﻤﻪ ﮐﻠﯿﺪی ‪ class‬را ﻣﯿﻨﻮﯾﺴﯿﻢ ﺳﭙﺲ ﺑﻌﺪ از ان ﻧﺎم ﮐﻼس ﺑﺎ رﻋﺎﯾﺖ اﺳﺘﺎﻧﺪارد ‪ PEP8‬و ﺳﭙﺲ ﻋﻼﻣﺖ دو ﻧﻘﻄﻪ )‪(:‬‬ ‫•‬

‫رﻋﺎﯾﺖ ﺗﻮ رﻓﺘﮕﯽ )‪ (indention‬ﻣﺸﺎﺑﻪ ﺷﺮط ﻫﺎ و ﺣﻠﻘﻪ ﻫﺎ اﻟﺰاﻣﯽ ﻣﯿﺒﺎﺷﺪ‪.‬‬ ‫•‬

‫اﮐﻨﻮن ﮐﻼس ﻣﺎ ﺑﺎ ﻋﻨﻮان ‪ Person‬اﯾﺠﺎد ﺷﺪ‪.‬‬ ‫•‬

‫ﻧﯿﺎز اﺳﺖ در ﻣﺮاﺣﻞ ﺑﻌﺪ وﯾﮋﮔﯽ ﻫﺎ ‪ /‬ﺧﺼﻮﺻﯿﺖ ‪ attrib /‬ﻫﺎ را ﺗﻌﺮﯾﻒ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺑﻌﺪ از آن ﻧﯿﺎز ﺑﻪ ﺗﻌﺮﯾﻒ رﻓﺘﺎر ﻫﺎ ‪ methods /‬دارﯾﻢ‪.‬‬ ‫•‬

‫‪class – attrib -methods‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 6‬‬

‫در اﯾﻦ ﻣﺮﺣﻠﻪ ﺧﺼﻮﺻﯿﺎت‪ attribs/‬و رﻓﺘﺎر ﻫﺎ‪ methods/‬ﻫﺎ را ﺗﻌﺮﯾﻒ ﻣﯿﮑﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺧﺼﻮﺻﯿﺎت در ﻗﺎﻟﺐ ﻣﺘﻐﯿﯿﺮ ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫و رﻓﺘﺎر ﻫﺎی در ﻗﺎﻟﺐ ﺗﺎﺑﻊ‪.‬‬ ‫•‬

‫‪attributes‬‬

‫‪methods‬‬
‫‪class – attrib -methods‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 7‬‬

‫اﮐﻨﻮن ﻣﺎ ﯾﮏ ﺷﺊ در ﻗﺎﻟﺐ ﮐﻼﺳﯽ ﺑﻪ ﻧﺎم ‪ Person‬ﺗﻌﺮﯾﻒ ﮐﺮدﯾﻢ‪.‬‬ ‫•‬

‫ﻫﺮ ﮐﺠﺎی ﺑﺮﻧﺎﻣﻪ ﻧﯿﺎز ﺑﻪ اﯾﻦ ﺷﺊ ﺑﺎﺷﺪ ﻣﯿﺒﺎﺳﺖ ﯾﮏ ﻧﻤﻮﻧﻪ از آن را درون ﯾﮏ ﻣﺘﻐﯿﯿﺮ اﯾﺠﺎد ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺷﺊ ﺳﺎﺧﺘﻪ ﺷﺪه ﻣﺎ دﻗﯿﻘﺎ ﻣﺸﺎﺑﻪ ﺷﺊ ﻫﺎی دﯾﮕﺮ ﭘﺎﯾﺘﻮن اﺳﺖ‪.‬‬ ‫•‬

‫ﺗﻨﻬﺎ ﺗﻔﺎوت ﻣﯿﺎن اﺷﯿﺎء ﺧﺼﻮﺻﯿﺎت ﻣﺘﺪ ﻫﺎی آﻧﺎن اﺳﺖ‪.‬‬ ‫•‬

‫ﺑﺮای ﻣﺜﺎل ﺑﺎ ﺗﺎﺑﻊ )(‪ type‬ﺷﺊ داده ‪ list‬و ﺷﺊ ‪ Person‬را ﺑﺮرﺳﯽ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫در ﺧﺮوﺟﯽ ﺑﺮﻧﺎﻣﻪ ﻣﯿﺒﯿﻨﯿﻢ ﮐﻪ دﻗﯿﻘﺎ ﺷﺊ ﻣﺎ ﻣﺸﺎﺑﻪ ﯾﮑﯽ از اﺷﯿﺎء ﭘﺎﯾﺘﻮن اﺳﺖ‪.‬‬ ‫•‬
‫‪class – attrib -methods‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 8‬‬

‫زﻣﺎﻧﯽ ﮐﻪ ﻣﺜﻼ ﺷﺊ داده ﻟﯿﺴﺖ را اﯾﺠﺎد ﻣﯿﮑﻨﯿﻢ ﻣﯿﺘﻮاﻧﯿﻢ آن را ﻣﻘﺪار دﻫﯽ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫اﻣﺎ ﺷﺊ ‪ Person‬ﮐﻪ ﻣﺎ اﯾﺠﺎد ﮐﺮدﯾﻢ ﻗﺎﺑﻠﯿﺖ ﻣﻘﺪار دﻫﯽ ﺑﻪ ﺧﺼﻮﺻﯿﺎت را ﻧﺪارد و ﺧﺼﻮﺻﯿﺎت ﺛﺎﺑﺖ ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫ﺑﻪ ﺷﮑﻞ ﻣﻘﺎﺑﻞ ﻣﯿﺘﻮاﻧﯿﻢ از ﺧﺼﻮﺻﯿﺎت و ﻣﺘﺪ ﻫﺎی ﺷﺊ اﺳﺘﻔﺎده ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﯾﮏ ﺷﺊ از ﻧﻮع ‪ Person‬درون ﻣﺘﻐﯿﯿﺮ ‪ user1‬ﺗﻌﺮﯾﻒ ﮐﺮدﯾﻢ‪.‬‬ ‫•‬

‫اﮐﻨﻮن دﻗﯿﻘﺎ ﻣﺸﺎﺑﻪ ﺑﻘﯿﻪ اﺷﯿﺎء ﻣﯿﺘﻮان ﺑﻪ ﻣﺘﺪ ﻫﺎی آن دﺳﺘﺮﺳﯽ ﭘﯿﺪا ﮐﺮد‪.‬‬ ‫•‬

‫ﻣﺘﺪ )(‪ register‬را از ‪ user1‬ﻓﺮاﺧﻮاﻧﯽ ﮐﺮدﯾﻢ‪.‬‬ ‫•‬

‫ﭼﻮن ﮐﻪ ﺗﻌﺮﯾﻒ ﮐﺮدﯾﻢ ﻧﻮع ﺷﺊ ﻣﺘﻐﯿﯿﺮ ‪ Person , user1‬اﺳﺖ ﯾﺎ اﯾﻨﮑﻪ ‪ user1‬ﯾﮏ ﻧﻤﻮﻧﻪ از ‪ Person‬اﺳﺖ‬ ‫•‬

‫ﺑﻨﺎﺑﺮاﯾﻦ ﻣﯿﺘﻮان ﺑﻪ ﺧﺼﻮﺻﯿﺎت ﺛﺎﺑﺖ و ﻣﺘﺪ ﻫﺎی آن دﺳﺘﺮﺳﯽ ﭘﯿﺪا ﮐﺮد‪.‬‬

‫در آﺧﺮ ﺧﺼﻮﺻﯿﺖ ‪ Fname‬ﮐﻪ ﺑﻪ ﺻﻮرت ﺛﺎﺑﺖ در ﺷﺊ ‪ Person‬ﺗﻌﺮﯾﻒ ﺷﺪه اﺳﺖ را ﭼﺎپ ﮐﺮدﯾﻢ‪.‬‬ ‫•‬
‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 9‬‬

‫اﺷﯿﺎء در ﭘﺎﯾﺘﻮن )ﻣﺜﻼ داده ‪ (list‬ﺑﻪ ﻃﻮر ﭘﯿﺸﻔﺮض ﺧﺎﻟﯽ ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫ﺑﺎﯾﺪ اﺑﺘﺪا ﯾﮏ ﻧﻤﻮﻧﻪ از آﻧﻬﺎ در ﯾﮏ ﻣﺘﻐﯿﯿﺮ اﯾﺠﺎد ﮐﺮد‪.‬‬ ‫•‬

‫ﺳﭙﺲ آن ﻧﻤﻮﻧﻪ را ﻣﻘﺪار دﻫﯽ ﮐﺮد‪.‬‬ ‫•‬

‫ﻣﯿﺘﻮان از ﻣﺘﺪ ﻫﺎی آن ﺷﺊ ﻧﯿﺰ اﺳﺘﻔﺎده ﮐﺮد‪.‬‬ ‫•‬

‫ﻣﺎ ﻧﯿﺰ ﺑﺎﯾﺪ ﺷﺊ ﺧﻮد را ﺑﻪ ﮔﻮﻧﻪ ای اﯾﺠﺎد ﮐﻨﯿﻢ ﮐﻪ ﻗﺎﺑﻠﯿﺖ ﻣﻘﺪار دﻫﯽ داﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬ ‫•‬

‫ﻫﻤﭽﻨﯿﻦ ﺷﺎﻣﻞ ﻣﺘﺪ ﻫﺎﯾﯽ ﺑﺎﺷﺪ ﮐﻪ ﻋﻤﻼ آﻧﻬﺎ را ﺑﻪ ﮐﺎر ﮔﯿﺮﯾﻢ‪.‬‬ ‫•‬
‫‪constructor‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 10‬‬

‫ﺑﻪ ﺟﻬﺖ رﻓﻊ ﻣﺸﮑﻼت ﻗﺒﻠﯽ )ﺧﺼﻮﺻﯿﺎت ﺛﺎﺑﺖ و ﻋﺪم اﺳﺘﻔﺎده از ﻣﺘﺪ ﻫﺎ( ﻧﯿﺎز اﺳﺖ ﮐﻪ ﯾﮏ ﺳﺎزﻧﺪه‪ constructor/‬ﺗﻌﺮﯾﻒ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺳﺎزﻧﺪه ﻫﺎ ﻣﺘﺪ ﻫﺎی ﺧﺎﺻﯽ ﻫﺴﺘﻨﺪ و زﻣﺎﻧﯽ ﮐﻪ آﻧﻬﺎ را درون ﮐﻼس ﺗﻌﺮﯾﻒ ﮐﻨﯿﻢ ﮐﻼس ﻣﺎ اﯾﻦ اﺟﺎزه را ﻣﯿﺪﻫﺪ ﮐﻪ ﺧﺼﻮﺻﯿﺖ‬ ‫•‬

‫اﺷﯿﺎﺋﯽ ﮐﻪ از روی آن ﺳﺎﺧﺘﯿﻢ را ﻣﻘﺪار دﻫﯿﻢ ﮐﻨﯿﻢ‪.‬‬

‫ﯾﮏ ﻋﻨﻮان ﺧﺎص ﺑﺮای ﺳﺎﺧﺖ ‪ constructor‬دارﯾﻢ‪.‬‬ ‫•‬

‫اﯾﻦ ﻋﻨﻮان ﺧﺎص __‪ __init‬اﺳﺖ و ﻣﯿﺒﺎﯾﺴﺖ در ﻗﺎﻟﺐ ﯾﮏ ﺗﺎﺑﻊ درون ﮐﻼس ﺗﻌﺮﯾﻒ ﺷﻮد‪.‬‬ ‫•‬

‫در واﻗﻊ اﯾﻦ ﯾﮏ ﻣﺘﺪ ﺧﺎص اﺳﺖ ﮐﻪ اﺟﺎزه ﻣﻘﺪار دﻫﯽ ﺧﺼﻮﺻﯿﺎت را ﺑﻪ ﻣﺎ ﻣﯿﺪﻫﺪ‪.‬‬ ‫•‬

‫ﻧﺤﻮه ﺗﻌﺮﯾﻒ ﮐﻠﯽ ﻣﺘﺪ __‪__init‬‬ ‫اﯾﻦ ‪ constructor‬ﯾﮏ ورودی ﺧﺎص ﺑﺎ ﻋﻨﻮان ‪ self‬ﻧﯿﺰ ﺑﺎﯾﺪ داﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬ ‫•‬

‫اوﻟﯿﻦ ﭘﺎراﻣﺘﺮ ﻫﺮ ﻣﺘﺪ در ﯾﮏ ﮐﻼس ﺑﺎﯾﺪ ‪ self‬ﺑﺎﺷﺪ ﮐﻪ ﺑﻪ ﺷﺊ ﻓﺮاﺧﻮاﻧﯽ ﺷﺪه اﺷﺎره دارد‪.‬‬ ‫•‬

‫ﻣﺘﺪ __‪ __init‬ﻫﻤﯿﺸﻪ ﺑﻪ ﻃﻮر ﺧﻮدﮐﺎر ﻫﻨﮕﺎم اﯾﺠﺎد ﺷﺊ اﺟﺮا ﻣﯿﺸﻮد‪.‬‬ ‫•‬
‫‪Instance Attributes‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 11‬‬

‫در ﺑﺨﺶ ﻗﺒﻞ ﻣﺘﻮﺟﻪ ﺷﺪﯾﻢ ﮐﻪ اﮔﺮ ﻗﺼﺪ داﺷﺘﻪ ﺑﺎﺷﯿﻢ ﺧﺼﻮﺻﯿﺎت را ﻣﻘﺪار دﻫﯽ ﮐﻨﯿﻢ ﻣﯿﺒﺎﺳﺖ ﯾﮏ ﺗﺎﺑﻊ ﺑﺎ ﻋﻨﻮان __‪ __init‬درون‬ ‫•‬

‫ﮐﻼس اﯾﺠﺎد ﮐﻨﯿﻢ و ﺑﻪ ﻋﻨﻮان ورودی ‪ self‬را ﺑﻪ آن ﺑﻪ دﻫﯿﻢ‪.‬‬

‫ﻋﺒﺎرت ‪ self‬اﺷﺎره ﺑﻪ ﺧﻮد ﻣﺘﻐﯿﯿﺮﻫﺎ‪/‬ﺧﺼﻮﺻﯿﺖ ﻫﺎی آن ﮐﻼس دارد‪.‬‬ ‫•‬

‫وﻗﺖ آن اﺳﺖ ﺧﻮد ﺧﺼﻮﺻﯿﺎت را ﻧﯿﺰ ﺗﻌﺮﯾﻒ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺧﺼﻮﺻﯿﺎﺗﯽ ﮐﻪ ﻗﺮار اﺳﺖ ﻫﺮ ﺳﺮی ﻣﻘﺪار دﻫﯽ ﺷﻮﻧﺪ را ﺧﺼﻮﺻﯿﺎت ﻧﻤﻮﻧﻪ ﻣﯿﮕﻮﯾﯿﻢ‪.‬‬ ‫•‬

‫ﺧﺼﻮﺻﯿﺖ ﺛﺎﺑﺖ ﮐﻼس‬

‫ﻣﺘﺪ ﺳﺎزﻧﺪه‬

‫ﺧﺼﻮﺻﯿﺖ ﻫﺎی ﻧﻤﻮﻧﻪ‬

‫‪Instance Attributes‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 12‬‬

‫ﺷﺊ ﻣﺎ اﮐﻨﻮن دارای ﺧﺼﻮﺻﯿﺖ ﻫﺎی ﻧﻤﻮﻧﻪ اﺳﺖ ﮐﻪ ﺣﯿﻦ اﯾﺠﺎد ﯾﮏ ﻧﻤﻮﻧﻪ از ﺷﺊ درون ﻣﺘﻐﯿﯿﺮ ﮐﻪ ﻣﯿﺘﻮان اﻫﺎ را ﻣﻘﺪار دﻫﯽ ﮐﺮد‪.‬‬ ‫•‬

‫در ﻣﺜﺎل ﻣﻘﺎﺑﻞ ﻣﺘﻐﯿﯿﺮ ‪ p1‬را ﺑﺎ ﮐﻼس ‪ Person‬ﻣﻘﺪار دﻫﯽ ﮐﺮدﯾﻢ‪.‬‬ ‫•‬

‫در واﻗﻊ ﯾﻌﻨﯽ اﯾﻨﮑﻪ ﻧﻮع ﻣﺘﻐﯿﯿﺮ ﯾﮏ ﻧﻤﻮﻧﻪ از ‪ Person‬اﺳﺖ‪.‬‬ ‫•‬

‫ﺳﭙﺲ ﺧﺼﻮﺻﯿﺖ ﻫﺎی ﻧﻤﻮﻧﻪ ﺷﺊ را ﻣﻘﺪار دﻫﯽ ﮐﺮدﯾﻢ و در آﺧﺮ ﭼﺎپ ﮐﺮدﯾﻢ‪.‬‬ ‫•‬
‫‪Instance Attributes‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 13‬‬

‫ﺷﻤﺎ ﻣﯽ ﺗﻮاﻧﯿﺪ ﻣﻘﺎدﯾﺮ وﯾﮋﮔﯽ ﻫﺎی ﺷﺊ ﻧﻤﻮﻧﻪ را از ﻃﺮﯾﻖ ﻣﺘﺪ ﺳﺎزﻧﺪه ﺗﻌﯿﯿﻦ ﮐﻨﯿﺪ‪.‬‬ ‫•‬

‫ﺳﺎزﻧﺪه زﯾﺮ ﺷﺎﻣﻞ ﭘﺎراﻣﺘﺮﻫﺎی ﻧﺎم و ﺳﻦ‪ ،‬ﺑﻪ ﻏﯿﺮ از ﭘﺎراﻣﺘﺮ ‪ self‬اﺳﺖ‪.‬‬ ‫•‬

‫در واﻗﻊ ﺑﺎ اﯾﻦ ﮐﺎر ﺑﻪ ﺻﻮرت ﻣﺴﺘﻘﯿﻢ ﻣﯿﺘﻮاﻧﯿﻢ ﺧﺼﻮﺻﯿﺖ ﻫﺎ را ﻣﻘﺪار دﻫﯽ ﮐﻨﯿﻢ‪.‬‬ ‫•‬
‫‪Instance Attributes‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 14‬‬

‫ﻫﻤﭽﻨﯿﻦ ﻫﻨﮕﺎم ﻣﻘﺪار دﻫﯽ ﺧﺼﻮﺻﯿﺖ ﻫﺎ دﻗﯿﻘﺎ ﻋﻨﻮان ﻣﺘﻐﯿﯿﺮ ﺧﺼﻮﺻﯿﺖ را ﻧﯿﺰ ﻧﻮﺷﺖ و آن را ﻣﻘﺪار دﻫﯽ ﮐﺮد‪.‬‬ ‫•‬

‫در ﻣﺜﺎل زﯾﺮ دو ﻣﺘﻐﯿﯿﺮ ﺑﺎ ﻧﺎم ‪ p1‬و ‪ p2‬ﺗﻌﺮﯾﻒ ﮐﺮده اﯾﻢ‪.‬‬ ‫•‬

‫ﻫﺮ دوی اﯾﻦ ﻣﺘﻐﯿﯿﺮ ﻫﺎ ﯾﮏ ﻧﻤﻮﻧﻪ از ﺷﺊ ‪ Person‬ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫ﻓﺮض ﮐﻨﯿﺪ ﻫﺮ دو ﯾﮏ ﺷﺨﺺ ﺟﺪاﮔﺎﻧﻪ ﮐﻪ دارای ﺧﺼﻮﺻﯿﺖ ﻫﺎی ﻣﺸﺘﺮک ﺑﺎ ﻣﻘﺎدﯾﺮ ﻣﺘﻔﺎوت ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫ﺧﺐ ﺑﻪ ﻃﻮر ﻗﻄﻊ ﻫﻤﻪ اﻧﺴﺎن ﻫﺎ ﻗﻄﻌﺎ ﻧﺎم و ﺳﻦ دارﻧﺪ اﻣﺎ ﻣﻘﺪار آﻧﻬﺎ ﻣﺘﻔﺎوت اﺳﺖ‪.‬‬ ‫•‬
‫‪Instance Attribute Default Value‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 15‬‬

‫ﻣﯿﺘﻮان ﺑﺮای ﺧﺼﻮﺻﯿﺖ ﻫﺎی ﻧﻤﻮﻧﻪ ﻣﻘﺎدﯾﺮ ﭘﯿﺸﻔﺮض ﺗﻌﺮﯾﻒ ﮐﺮد‪.‬‬ ‫•‬

‫ﺑﺮای ﻣﺜﺎل ﺷﺨﺼﯽ ﮐﻪ وارد ﺑﺮﻧﺎﻣﻪ ﻣﯿﺸﻮد و اﻃﻼﻋﺎت ﺧﻮد را وارد ﻧﻤﯿﮑﻨﺪ را ﻣﯿﮕﻮﯾﯿﻢ ﻧﺎﻣﺶ ﻣﻬﻤﺎن اﺳﺖ‪.‬‬ ‫•‬
‫‪Class Methods‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 16‬‬

‫ﻣﺎ ﻣﯿﺘﻮاﻧﯿﻢ ﻣﺘﺪ ﻫﺎی ﮔﻮﻧﺎﻧﯽ ﺑﺮای ﺷﺊﻣﺎن در ﻧﻈﺮ ﺑﮕﯿﺮم ﮐﻪ ﻫﺮ ﮔﺎه ﻧﯿﺎز ﺷﺪ آﻧﻬﺎ را ﻓﺮاﺧﻮاﻧﯽ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﻣﺜﻼ ﻗﺼﺪ دارﯾﻢ ﺷﺊ ﻣﺎن ﻋﻤﻠﯿﺎت ﺧﺎﺻﯽ را اﻧﺠﺎم دﻫﺪ‪.‬‬ ‫•‬

‫ﯾﺎ ﺑﺮای ﻣﺜﺎل ﺗﻐﯿﯿﺮاﺗﯽ در ﺧﺼﻮﺻﯿﺎت اﻋﻤﺎل ﮐﻨﯿﻢ و‪...‬‬ ‫•‬

‫ﻓﺮض ﮐﻨﯿﺪ ﻣﺘﺪی ﻧﯿﺎز دارﯾﻢ ﮐﻪ ﻫﻨﮕﺎم ﻓﺮاﺧﻮاﻧﯽ ﺧﺼﻮﺻﯿﺖ ﻫﺎی ﺗﻌﺮﯾﻒ ﺷﺪه را ﭼﺎپ ﮐﻨﺪ و ﻧﯿﺎزی ﺑﻪ ﺗﺎﺑﻊ ﺟﺪاﮔﺎﻧﻪ ‪ print‬ﻧﺒﺎﺷﺪ‪.‬‬ ‫•‬

‫در ﺻﻮرﺗﯽ ﮐﻪ ﻗﺼﺪ دارﯾﻢ از ﻣﻘﺎدﯾﺮ ﺧﺼﻮﺻﯿﺖ ﻫﺎ در ﻣﺘﺪ ﻫﺎ اﺳﺘﻔﺎده ﮐﻨﯿﻢ ﻣﯿﺒﺎﯾﺴﺖ ورودی ‪ self‬را ﻧﯿﺰ ﺑﻪ ﻣﺘﺪ ﻣﺪ ﻧﻈﺮ ﺑﺪﻫﯿﻢ‪.‬‬ ‫•‬
‫‪Class Methods‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 17‬‬

‫اﻟﺒﺘﻪ ﻣﯿﺘﻮان ﺑﻪ ﺟﺎی ﻋﺒﺎرت ‪ self‬ﺑﻪ ﻋﻨﻮان ورودی ﻫﺮ ﭼﯿﺰ دﯾﮕﺮی ﻧﯿﺰ ﺑﻪ ﻣﺘﺪ داد‪.‬‬ ‫•‬

‫ﺗﻨﻬﺎ ﻧﮑﺘﻪ در ﺧﺼﻮص ﺗﻌﺮﯾﻒ ﻣﺘﺪ اﯾﻦ اﺳﺖ ﮐﻪ ﺣﺘﻤﺎ ﯾﮏ ورودی داﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬ ‫•‬

‫در ﻏﯿﺮ اﯾﻨﺼﻮرت ﺑﺎ ﺧﻄﺎی آرﮔﻮﻣﺎن ورودی ﻣﻮاﺟﻪ ﺧﻮاﻫﯿﻢ ﺷﺪ‪.‬‬ ‫•‬
‫‪Deleting Attribute, Object, Class‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 18‬‬

‫دﻗﯿﻘﺎ ﻣﺸﺎﺑﻪ اﺷﯿﺎء دﯾﮕﺮ در زﺑﺎن ﭘﺎﯾﺘﻮن ﻣﯿﺘﻮان از ﻋﺒﺎرت ‪ del‬ﺑﺮای ﺣﺬف ﺷﺊ اﯾﺠﺎد ﺷﺪه و ﮐﻼس و ﺧﺼﻮﺻﯿﺖ ﻫﺎ اﺳﺘﻔﺎده ﮐﺮد‪.‬‬ ‫•‬

‫ﺑﺮای ﺣﺬف ﺷﺊ ﮐﺎﻓﯽ اﺳﺖ ﭘﺲ از ﻋﺒﺎرت ‪ del‬ﻧﺎم ﻣﺘﻐﯿﯿﺮی ﮐﻪ ﺷﺊ در ان اﯾﺠﺎد ﺷﺪه اﺳﺖ را ﺑﻨﻮﯾﺴﯿﻢ‪.‬‬ ‫•‬
‫ﺗﻤﺮﯾﻦ ‪۱‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 19‬‬

‫ﺗﻤﺮﯾﻦ‪:‬‬ ‫•‬

‫ﻗﺼﺪ دارﯾﻢ ﯾﮏ ﺑﺮﻧﺎﻣﻪ ﺑﺮای ﻣﺤﯿﻂ ﻋﻤﻠﯿﺎﺗﯽ ﻣﺪرﺳﻪ ﺑﻨﻮﯾﺴﯿﻢ‪.‬‬ ‫•‬

‫در اﯾﻦ ﻣﺤﯿﻂ ﻋﻤﻠﯿﺎﺗﯽ ﺷﺊ ﻫﺎی ﻣﺘﻔﺎوﺗﯽ ﻣﺜﻞ داﻧﺶ آﻣﻮزش و‪ ...‬وﺟﻮد دارﻧﺪ‪.‬‬ ‫•‬

‫ﯾﮏ ﺷﺊ ﺑﺮای داﻧﺶ اﻣﻮزش اﯾﺠﺎد ﮐﻨﯿﺪ و ﺧﺼﻮﺻﯿﺎت آن را ﺗﻌﺮﯾﻒ ﮐﻨﯿﺪ‪) .‬ﺷﺎﻣﻞ ﻧﺎم و ﻧﺎم ﺧﺎﻧﻮادﮔﯽ و ﮐﺪ ﻣﻠﯽ و‪(...‬‬ ‫•‬

‫ﯾﮏ ﻣﺘﺪ ﺑﺮای ﺷﺊ داﻧﺶ آﻣﻮز اﯾﺠﺎد ﮐﻨﯿﺪ ﮐﻪ ﻋﻤﻠﯿﺎت ﺛﺒﺖ ﻧﺎم را اﻧﺠﺎم دﻫﺪ و وﻗﺘﯽ ﮐﻪ ﮐﻪ ﻓﺮاﺧﻮاﻧﯽ ﻣﯿﺸﻮد اﻃﻼﻋﺎت داﻧﺶ آﻣﻮزش را‬ ‫•‬

‫درون ﯾﮏ ﻓﺎﯾﻞ ‪ txt‬ذﺧﯿﺮه ﮐﻨﺪ‪.‬‬

‫ﺳﻮرس ﮐﺪ ﺗﻤﺮﯾﻦ ‪۱‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 20‬‬

‫ﮐﺪ ﻣﻨﺒﻊ ﺑﺮ روی ﮔﯿﺖ ﻫﺎب‪:‬‬

‫ﺗﻤﺮﯾﻦ ‪۲‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 21‬‬

‫ﺗﻤﺮﯾﻦ‪:‬‬ ‫•‬

‫‪ ü‬ﻗﺼﺪ دارﯾﻢ ﻣﺎژول ﺑﻪ روش ﺷﺊﮔﺮاﯾﯽ اﯾﺠﺎد ﮐﻨﯿﻢ ﮐﻪ ﺧﻮدرو ﻫﺎی ﻣﺘﻔﺎوﺗﯽ را ﺑﻪ ﻋﻨﻮان ﺷﺊ اﯾﺠﺎد ﮐﻨﯿﻢ و ﺧﺼﻮﺻﯿﺎت ﻫﺮ ﺷﺊ ﺷﺎﻣﻞ ﻧﺎم‬

‫ﺧﻮدرو و ﺳﺮﻋﺖ آن ﺑﺮ ﺣﺴﺐ ‪ km/h‬اﺳﺖ ﺑﻪ ﻃﻮر ﭘﯿﺸﻔﺮض‪.‬‬

‫‪ ü‬ﻧﮑﺘﻪ ‪ :۱‬ﺣﺘﻤﺎ از روش ﺷﺊﮔﺮاﯾﯽ اﺳﺘﻔﺎده ﺷﻮد‪.‬‬

‫‪ ü‬ﻧﮑﺘﻪ ‪ :۲‬ﺧﺼﻮﺻﯿﺎت ﺧﻮدرو ﻫﺎ ﻣﺎﻧﻨﺪ ﻧﺎم و ﺳﺮﻋﺖ و‪ ...‬ﻣﺸﺘﺮک اﺳﺖ‪ .‬ﻓﻘﻂ ﻣﻘﺎدﯾﺮ ﺑﺎ ﻫﻢ ﻣﺘﻔﺎوت ﻫﺴﺘﻨﺪ‪.‬‬

‫‪ ü‬ﺷﺊ ﺧﻮدرو دارای ﯾﮏ ﻣﺘﺪ ﺑﺮای ﺗﺒﺪﯾﻞ وﯾﮋﮔﯽ ﺳﺮﻋﺖ ﺑﺮﺣﺴﺐ ‪) m/s‬ﻣﺘﺮ ﺑﺮ ﺛﺎﻧﯿﻪ( ﺑﺎﺷﺪ‪.‬‬

‫‪ ü‬ﺷﺊ ﺧﻮدرو دارای ﯾﮏ ﻣﺘﺪ ﺑﺎﺷﺪ ﮐﻪ ﻫﻨﮕﺎم ﻓﺮاﺧﻮاﻧﯽ اﻃﻼﻋﺎت ﺧﻮدرو ﺷﺎﻣﻞ ﻧﺎم و ﺳﺮﻋﺖ آن را ﻧﻤﺎﯾﺶ دﻫﺪ‪.‬‬
‫ﺳﻮرس ﮐﺪ ﺗﻤﺮﯾﻦ ‪۲‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 22‬‬

‫ﮐﺪ ﻣﻨﺒﻊ ﺑﺮ روی ﮔﯿﺖ ﻫﺎب‪:‬‬

 ‫‪Inheritance‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 23‬‬

‫ﻣﺎ اﻏﻠﺐ ﺑﺎ ﻣﺤﺼﻮﻻت ﻣﺨﺘﻠﻔﯽ ﻣﻮاﺟﻪ ﻣﯽ ﺷﻮﯾﻢ ﮐﻪ دارای ﯾﮏ ﻣﺪل ﭘﺎﯾﻪ و ﯾﮏ ﻣﺪل ﭘﯿﺸﺮﻓﺘﻪ ﺑﺎ وﯾﮋﮔﯽ ﻫﺎی اﺿﺎﻓﯽ ﺑﯿﺶ از ﻣﺪل ﭘﺎﯾﻪ ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫ﯾﮏ روﯾﮑﺮد ﻣﺪلﺳﺎزی ﻧﺮماﻓﺰاری‪) OOP‬ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺑﻪ ﺳﺒﮏ ﺷﺊ ﮔﺮا( ﺑﻪ ﺟﺎی ﺳﺎﺧﺘﻦ از اﺑﺘﺪا‪ ،‬ﻗﺎﺑﻠﯿﺖ ﯾﮏ ﮐﻼس ﻣﻮﺟﻮد را ﺑﺮای اﯾﺠﺎد ﯾﮏ ﮐﻼس‬ ‫•‬
‫ﺟﺪﯾﺪ ﮔﺴﺘﺮش ﻣﯽدﻫﺪ‪.‬‬

‫در اﺻﻄﻼح ‪ OOP،‬اﯾﻦ ﻋﻤﻠﮑﺮد وراﺛﺖ ﻧﺎﻣﯿﺪه ﻣﯽ ﺷﻮد‪.‬‬ ‫•‬

‫ﮐﻼس ﻣﻮﺟﻮد ﭘﺎﯾﻪ ﯾﺎ ﮐﻼس واﻟﺪ ﻧﺎﻣﯿﺪه ﻣﯽ ﺷﻮد‪ ،‬در ﺣﺎﻟﯽ ﮐﻪ ﮐﻼس ﺟﺪﯾﺪ ﻓﺮزﻧﺪ ﯾﺎ ﮐﻼس ﻓﺮﻋﯽ ﻧﺎﻣﯿﺪه ﻣﯽ ﺷﻮد‪.‬‬ ‫•‬

‫وراﺛﺖ زﻣﺎﻧﯽ ﻇﺎﻫﺮ ﻣﯽ ﺷﻮد ﮐﻪ ﯾﮏ ﮐﻼس ﺟﺪﯾﺪ دارای راﺑﻄﻪ ”‪ ”is a‬ﺑﺎ ﯾﮏ ﮐﻼس ﻣﻮﺟﻮد‪/‬ﻗﺪﯾﻤﯽ ﺑﺎﺷﺪ‪.‬‬ ‫•‬

‫ﺳﮓ ﯾﮏ ﺣﯿﻮان اﺳﺖ ﻫﻤﭽﻨﯿﻦ ﮔﺮﺑﻪ ﻧﯿﺰ ﯾﮏ ﺣﯿﻮان اﺳﺖ‪ .‬ﺑﻨﺎﺑﺮاﯾﻦ‪ ،‬ﺣﯿﻮان ﻃﺒﻘﻪ‪/‬ﮐﻼس ﭘﺎﯾﻪ اﺳﺖ‪ ،‬در ﺣﺎﻟﯽ ﮐﻪ ﺳﮓ و ﮔﺮﺑﻪ ﻃﺒﻘﺎت ارﺛﯽ ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫ﮐﻼس ﻓﺮزﻧﺪ ﺗﻌﺎرﯾﻒ و ﻣﺘﺪﻫﺎ را از ﮐﻼس واﻟﺪ ﺑﻪ ارث ﻣﯽ ﺑﺮد‪.‬‬ ‫•‬

‫اﯾﻦ اﻣﺮ اﺳﺘﻔﺎده ﻣﺠﺪد از وﯾﮋﮔﯽ ﻫﺎی ﻣﻮﺟﻮد را ﺗﺴﻬﯿﻞ ﻣﯽ ﮐﻨﺪ‪.‬‬ ‫•‬

‫ﮐﻼس ﻓﺮزﻧﺪ ﻣﯽ ﺗﻮاﻧﺪ ﭼﻨﺪ ﺗﻌﺮﯾﻒ دﯾﮕﺮ اﺿﺎﻓﻪ ﮐﻨﺪ ﯾﺎ ﯾﮏ ﻣﺘﺪ ﮐﻼس ﭘﺎﯾﻪ را دوﺑﺎره ﺗﻌﺮﯾﻒ ﮐﻨﺪ‪.‬‬ ‫•‬
‫‪Inheritance‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 24‬‬

‫اﯾﻦ وﯾﮋﮔﯽ در اﯾﺠﺎد ﺳﻠﺴﻠﻪ ﻣﺮاﺗﺒﯽ از ﮐﻼس ﻫﺎ ﺑﺮای اﺷﯿﺎء در ﯾﮏ ﺳﯿﺴﺘﻢ اﻃﻼﻋﺎﺗﯽ ﭘﯿﭽﯿﺪه ﺑﺴﯿﺎر ﻣﻔﯿﺪ اﺳﺖ‪.‬‬ ‫•‬

‫ﻫﻤﭽﻨﯿﻦ اﻣﮑﺎن ﻃﺮاﺣﯽ ﯾﮏ ﮐﻼس ﺟﺪﯾﺪ ﺑﺮ اﺳﺎس ﺑﯿﺶ از ﯾﮏ ﮐﻼس ﻣﻮﺟﻮد وﺟﻮد دارد‪.‬‬ ‫•‬

‫اﯾﻦ وﯾﮋﮔﯽ وراﺛﺖ ﭼﻨﺪﮔﺎﻧﻪ ﻧﺎﻣﯿﺪه ﻣﯽ ﺷﻮد‪.‬‬ ‫•‬

‫ﻣﮑﺎﻧﯿﺴﻢ ﮐﻠﯽ اﯾﺠﺎد وراﺛﺖ در ﺷﮑﻞ ﻣﻘﺎﺑﻞ ﻧﺸﺎن داده ﺷﺪه اﺳﺖ‪:‬‬ ‫•‬

‫ﻫﻨﮕﺎم ﺗﻌﺮﯾﻒ ﮐﻼس ﻓﺮزﻧﺪ‪ ،‬ﻧﺎم ﮐﻼس واﻟﺪ در داﺧﻞ ﭘﺮاﻧﺘﺰ ﺟﻠﻮی آن ﻗﺮار ﻣﯽ ﮔﯿﺮد‪.‬‬ ‫•‬

‫ﮐﻪ ﻧﺸﺎن دﻫﻨﺪه راﺑﻄﻪ ﺑﯿﻦ اﯾﻦ دو اﺳﺖ‪.‬‬ ‫•‬

‫ﺧﺼﻮﺻﯿﺖ ﻫﺎ ‪ /‬وﯾﮋﮔﯽ ﻫﺎ و ﻣﺘﺪﻫﺎی ﻧﻤﻮﻧﻪ ﺗﻌﺮﯾﻒ ﺷﺪه در ﮐﻼس واﻟﺪ ﺗﻮﺳﻂ ﺷﯽ ﮐﻼس ﻓﺮزﻧﺪ ﺑﻪ ارث ﻣﯽ رﺳﺪ‪.‬‬ ‫•‬
 ‫‪Inheritance‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 25‬‬
‫ﺑﺮای درک ﺑﻬﺘﺮ ﻣﺜﺎل زﯾﺮ را در ﻧﻈﺮ ﺑﮕﯿﺮﯾﺪ‪:‬‬ ‫•‬

‫ﻣﺴﺘﻄﯿﻞ و ﻣﺮﺑﻊ ﻫﺮ دو دارای ﭼﻬﺎر ﺿﻠﻊ ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫اﯾﻦ دو ﺷﮑﻞ‪/‬ﺷﺊ ﻫﺮ دو ﭼﻬﺎرﺿﻠﻌﯽ ﻫﺴﺘﻨﺪ اﻣﺎ ﻧﺤﻮه ﻣﺤﺎﺳﺒﻪ ﻣﺴﺎﺣﺖ و ﻣﺤﯿﻂ آﻧﻬﺎ ﺑﺎ ﯾﮏ دﯾﮕﺮ ﻣﺘﻔﺎوت اﺳﺖ‪.‬‬ ‫•‬

‫ﭘﺲ ﻫﺮ دو از ﺷﺊ ﭼﻬﺎرﺿﻠﻌﯽ ارث ﺑﺮی ﻣﯿﮑﻨﻨﺪ وﯾﮋﮔﯽ ﭼﺎر ﺿﻠﻊ داﺷﺘﻦ را‪.‬‬ ‫•‬

‫اﺑﺘﺪا ﯾﮏ ﮐﻼس ﭼﻬﺎر ﺿﻠﻌﯽ ﺗﻌﺮﯾﻒ ﻣﯽ ﺷﻮد و ﺑﻪ ﻋﻨﻮان ﯾﮏ ﮐﻼس ﭘﺎﯾﻪ‪/‬واﻟﺪ ﺑﺮای ﮐﻼس ﻣﺴﺘﻄﯿﻞ و ﻣﺮﺑﻊ اﺳﺘﻔﺎده ﻣﯽ ﺷﻮد‪.‬‬ ‫•‬

‫اﯾﻦ ﮐﻼس دارای ﯾﮏ ﻣﺘﺪ ﺑﺮای ﻣﺤﺎﺳﺒﻪ ﻣﺤﯿﻂ اﺳﺖ‪) .‬ﻧﺤﻮه ﻣﺤﺎﺳﺒﻪ در ﻫﻤﻪ ﭼﻬﺎر ﺿﻠﻌﯽ ﻫﺎ ﻣﺸﺘﺮک اﺳﺖ‪(.‬‬ ‫•‬

‫ﺳﭙﺲ ﯾﮏ ﮐﻼس ﺑﺮای ﻣﺴﺘﻄﯿﻞ ﺗﻌﺮﯾﻒ ﻣﯿﮑﻨﯿﻢ و ﻃﺒﻖ ﻗﻮاﺋﺪ ﺗﻌﺮﯾﻒ ﺷﺪه ﻣﯿﺒﺎﺳﺖ از ﺧﺼﻮﺻﯿﺖ ﻫﺎی ﮐﻼس واﻟﺪ ﭼﻬﺎر ﺿﻠﻌﯽ ارث ﺑﺮی ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺑﺮای اﺳﺘﻔﺎده از ﺧﺼﻮﺻﯿﺖ ﻫﺎی ﮐﻼس ﭘﺎﯾﻪ ﺑﺎﯾﺪ از ﺗﺎﺑﻊ )(‪ super‬اﺳﺘﻔﺎده ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫از آﻧﺠﺎ ﮐﻪ ﮐﻼس ﭼﻬﺎر ﺿﻠﻌﯽ دارای ﭼﻬﺎر آرﮔﻮﻣﺎن ﻣﯿﺒﺎﺷﺪ ﻣﯿﺒﺎﺳﺖ در ﮐﻼس ﻓﺮزﻧﺪ ﻧﯿﺰ ﭼﻬﺎر آرﮔﻮﻣﺎن ارث ﺑﺮی ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﻓﺮض ﮐﻨﯿﺪ ﻣﯿﺨﻮاﻫﯿﻢ ﯾﻢ ﻣﺘﺪ ﻣﯿﺨﻮاﻫﯿﻢ ﺑﻨﻮﯾﺴﯿﻢ ﮐﻪ ﻣﺴﺎﺣﺖ ﻣﺴﺘﻄﯿﻞ را ﺑﺮای ﻣﺎ ﺣﺴﺎب ﮐﻨﺪ‪.‬‬ ‫•‬

‫ﻓﻘﻂ ﺑﻪ ﻧﯿﺎز ﺑﻪ داﺷﺘﻦ اﻧﺪاز دو ﺿﻠﻊ ﻣﺠﺎور ﻫﻢ دارﯾﻢ‪.‬‬ ‫•‬

‫‪Inheritance‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 26‬‬

‫ﮐﻼس ﭼﻬﺎر ﺿﻠﻌﯽ ﮐﻪ دارای ‪ ۴‬آرﮔﻮﻣﺎن ﺑﺮای اﻧﺪازه ‪ ۴‬ﺿﻠﻊ آن اﺳﺖ‬

‫ﻣﺘﺪ ﻣﺤﺎﺳﺒﻪ ﻣﺤﯿﻂ ﭼﻬﺎر ﺿﻠﻌﯽ ﻫﺎ ﮐﻪ ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ ﺟﻤﻊ ﭼﻬﺎر ﺿﻠﻊ‬
‫‪Inheritance‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 27‬‬

‫اﮐﻨﻮن ﮐﻼس ﻣﺴﺘﻄﯿﻞ را اﯾﺠﺎد ﻣﯿﮑﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺿﻠﻊ ﻫﺎی رو ﺑﻪ روی ﻫﻢ ﻣﺴﺘﻄﯿﻞ ﻫﻢ اﻧﺪازه ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬
‫ﺑﻨﺎﺑﺮاﯾﻦ ﻣﺴﺘﻄﯿﻞ ﺗﻨﻬﺎ دو آرﮔﻮﻣﺎن ﺑﻪ ﻋﻨﻮان ﻃﻮل و ﻋﺮض دارد‪.‬‬ ‫•‬
‫اﻣﺎ ﺑﺮای ارث ﺑﺮی از ﮐﻼس ﭼﺎر ﺿﻠﻌﯽ و ﻣﺘﺪ ﻫﺎی آن ﻧﯿﺎز اﺳﺖ ﮐﻪ ﭼﻬﺎر آرﮔﻮﻣﺎن ارﺳﺎل ﮐﻨﯿﻢ‪.‬‬ ‫•‬
‫ﺑﻪ ﮐﻤﮏ ﺗﺎﺑﻊ )(‪ super‬آرﮔﻮﻣﺎن ﻫﺎی ﺧﻮد را ﺑﻪ ﮐﻼس واﻟﺪ ارﺳﺎل ﻣﯿﮑﻨﯿﻢ‪.‬‬ ‫•‬
‫اﮐﻨﻮن ﻣﯿﺨﻮاﻫﯿﻢ ﻣﺤﯿﻂ اﯾﻦ ﻣﺴﺘﻄﯿﻞ را ﺑﻪ دﺳﺖ آورﯾﻢ ﻣﻄﺎﺑﻖ ﺗﺼﻮﯾﺮ ﺑﺨﺶ ﺑﻌﺪی ﻋﻤﻞ ﻣﯿﮑﻨﯿﻢ‪.‬‬ ‫•‬
‫‪Inheritance‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 28‬‬

‫دﯾﺪﯾﺪ ﮐﻪ ﺑﺮای ﺑﻪ دﺳﺖ آوردن ﻣﺤﯿﻂ ﻣﺴﺘﻄﯿﻞ‬ ‫•‬

‫ﻣﺘﺪ ﺟﺪاﮔﺎﻧﻪ ﺑﺮای ﮐﻼس ﻣﺴﺘﻄﯿﻞ ﺗﻌﺮﯾﻒ ﻧﮑﺮدﯾﻢ‪.‬‬

‫ﭼﻮن ﭼﻨﯿﻦ ﻣﺘﺪی در ﮐﻼس واﻟﺪ وﺟﻮد دارد و ﺑﺮای‬ ‫•‬

‫ﻫﻤﻪ اﺷﮑﺎل ﭼﻬﺎر ﺿﻠﻌﯽ ﻣﺸﺘﺮک اﺳﺖ‪.‬‬

‫ﺗﻤﺮﯾﻦ‪:‬‬ ‫•‬
‫ﻣﺘﺪی ﺑﺮای ﻣﺤﺎﺳﺒﻪ ﻣﺴﺎﺣﺖ ﺷﺊ ﻣﺴﺘﻄﯿﻞ اﯾﺠﺎد ﮐﻨﯿﺪ‪.‬‬
‫‪Overriding‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 29‬‬

‫در ﺑﺤﺚ ارث ﺑﺮی دﯾﺪﯾﻢ ﮐﻪ ﻫﺮ ﺷﺊ ﻣﯿﺘﻮاﻧﺪ ﺧﻮﺻﯿﺖ ﻫﺎ و رﻓﺘﺎرﻫﺎ‪/‬ﻣﺘﺪﻫﺎی ﺑﻪ ارث ﺑﺒﺮد‪.‬‬ ‫•‬

‫اﮐﻨﻮن ﻣﯿﺨﻮاﻫﯿﻢ ﺟﺪای از ﺧﺼﻮﺻﯿﺖ و ﻣﺘﺪ ﻫﺎی ﺑﺮ ارث ﺑﺮده ﺷﺪه ﺑﺮای ﻓﺮزﻧﺪ ﺧﺼﻮﺻﯿﺖ ﻫﺎ و ﻣﺘﺪ ﻫﺎی ﺧﺎص ﺧﻮدش را ﺗﻌﺮﯾﻒ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﻣﺜﻼ دﯾﺪﯾﻢ ﮐﻪ ﻫﻤﻪ اﺷﮑﺎل ﭼﻬﺎرﺿﻠﻌﯽ ﻧﺤﻮه ﻣﺤﺎﺳﺒﻪ ﻣﺤﯿﻄﺸﺎن ﻣﺜﻞ ﻫﻢ اﺳﺖ اﻣﺎ اﺷﮑﺎﻟﯽ ﻣﺎﻧﻨﺪ ﻣﺴﺘﻄﯿﻞ و ﻣﺮﺑﻊ ﻧﺤﻮه ﻣﺤﺎﺳﺒﻪ ﻣﺴﺎﺣﺘﺸﺎن ﻣﺘﻔﺎوت‬ ‫•‬
‫اﺳﺖ ﺑﻨﺎﺑﺮاﯾﻦ ﺑﺎﺑﺖ اﯾﻦ ﻗﻀﯿﻪ ﺑﺎﯾﺪ ﻣﺘﺪ ﻫﺎی اﺧﺘﺼﺎﺻﯽ ﺧﻮدﺷﺎن را داﺷﺘﻪ ﺑﺎﺷﻨﺪ‪.‬‬

‫ﺑﻪ اﯾﻦ روش ‪ overriding‬ﻣﯿﮕﻮﯾﻨﺪ‪.‬‬ ‫•‬

‫در ﻣﺜﺎل زﯾﺮ ﯾﮏ ﻣﺘﺪ اﺧﺘﺼﺎﺻﯽ ﺑﺮای ﻣﺴﺎﺣﺖ ﻣﺴﺘﻄﯿﻞ اﯾﺠﺎد ﮐﺮدﯾﻢ‪.‬‬ ‫•‬

‫ﻣﻘﺎدﯾﺮ ﻃﻮل و ﻋﺮض را از ﺧﺼﻮﺻﯿﺖ ﮐﻼس واﻟﺪ ﮔﺮﻓﺘﯿﻢ!‬ ‫•‬

‫ﺗﻤﺮﯾﻦ‪ :‬اﮐﻨﻮن ﺷﺊ ﻣﺮﺑﻊ را اﯾﺠﺎد ﮐﻨﯿﺪ ﮐﻪ ﻗﺎﺑﻠﯿﺖ ﺑﺮرﺳﯽ ﻣﺤﯿﻂ و ﻣﺴﺎﺣﺖ را داﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬ ‫•‬
‫‪Public, Protected, Private Members‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 30‬‬

‫اﻋﻀﺎی ‪ :public‬اﻋﻀﺎی ﻋﻤﻮﻣﯽ )ﻣﻌﻤﻮﻻ ً ﻣﺘﺪﻫﺎی اﻋﻼم ﺷﺪه در ﯾﮏ ﮐﻼس( از ﺧﺎرج از ﮐﻼس ﻗﺎﺑﻞ دﺳﺘﺮﺳﯽ ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫ﻫﻤﻪ اﻋﻀﺎی ﯾﮏ ﮐﻼس ﭘﺎﯾﺘﻮن ﺑﻪ ﻃﻮر ﭘﯿﺶ ﻓﺮض ﻋﻤﻮﻣﯽ ﻫﺴﺘﻨﺪ‪ .‬ﻫﺮ ﻋﻀﻮی از ﺧﺎرج از ﻣﺤﯿﻂ ﮐﻼس ﻗﺎﺑﻞ دﺳﺘﺮﺳﯽ اﺳﺖ‪.‬‬ ‫•‬

‫اﻋﻀﺎی ‪ :Protected‬اﻋﻀﺎی ﻣﺤﺎﻓﻈﺖ ﺷﺪه ﯾﮏ ﮐﻼس از داﺧﻞ ﮐﻼس ﻗﺎﺑﻞ دﺳﺘﺮﺳﯽ ﻫﺴﺘﻨﺪ و ﺑﺮای زﯾﺮ ﮐﻼس ﻫﺎی آن ﻧﯿﺰ در دﺳﺘﺮس‬ ‫•‬
‫ﻫﺴﺘﻨﺪ‪.‬‬

‫ﻫﯿﭻ ﻣﺤﯿﻂ دﯾﮕﺮی اﺟﺎزه دﺳﺘﺮﺳﯽ ﺑﻪ آن را ﻧﺪارد و اﯾﻦ ﺑﺎﻋﺚ ﻣﯽ ﺷﻮد ﻣﻨﺎﺑﻊ ﺧﺎﺻﯽ از ﮐﻼس واﻟﺪ ﺗﻮﺳﻂ ﮐﻼس ﻓﺮزﻧﺪ ﺑﻪ ارث ﺑﺮده ﺷﻮد‪.‬‬ ‫•‬

‫ﺑﺮای ﺗﻌﺮﯾﻒ ﯾﮏ ﻋﻀﻮ ﻣﺤﺎﻓﻈﺖ ﺷﺪه ﻗﺒﻞ از ﻧﺎم آن ﯾﮏ ﻋﻼﻣﺖ زﯾﺮ ﻗﺮار ﻣﯿﺪﻫﯿﻢ‪.‬‬ ‫•‬

‫زﻣﺎﻧﯽ ﮐﻪ از ﺗﺎﺑﻊ ‪ property‬اﺳﺘﻔﺎده ﻣﯿﮑﻨﯿﻢ اﻋﻀﺎ ﻣﺤﺎﻓﻈﺖ ﺷﺪه ﻣﯿﺸﻮﻧﺪ‪.‬‬ ‫•‬

‫اﻋﻀﺎی ‪ :private‬زﯾﺮﺧﻂ دوﮔﺎﻧﻪ __ ﮐﻪ ﭘﯿﺸﻮﻧﺪ ﯾﮏ ﻣﺘﻐﯿﺮ اﺳﺖ آن را ﺧﺼﻮﺻﯽ ﻣﯽ ﮐﻨﺪ‪ .‬ﭘﯿﺸﻨﻬﺎد ﻗﻮی ﻣﯽ دﻫﺪ ﮐﻪ از ﺑﯿﺮون ﮐﻼس ﺑﻪ آن‬ ‫•‬
‫دﺳﺖ ﻧﺰﻧﯿﺪ‪ .‬ﻫﺮ ﺗﻼﺷﯽ ﺑﺮای اﻧﺠﺎم اﯾﻦ ﮐﺎر ﻣﻨﺠﺮ ﺑﻪ ﯾﮏ ‪ AttributeError‬ﻣﯽ ﺷﻮد‪.‬‬
Public, Protected, Private Members OBJECT ORIENTED PROGRAMMING ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا‬ PART 31

Public members Protected members

Private members
‫‪Class Properties‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 32‬‬

‫ﯾﮏ وﯾﮋﮔﯽ ﺷﺊ در ﮐﻼس را ﻣﯿﺘﻮان ﺑﻪ ﮐﻤﮏ ﺗﺎﺑﻊ )(‪ property‬ﺗﻌﺮﯾﻒ ﮐﺮد‪.‬‬ ‫•‬

‫اﯾﻦ ﺗﺎﺑﻊ ﯾﮏ راﺑﻂ ﺑﺮای ﺧﺼﻮﺻﯿﺖ ﻫﺎی ﻧﻤﻮﻧﻪ اﯾﺠﺎد ﻣﯿﮑﻨﺪ‪.‬‬ ‫•‬

‫ﺧﺼﻮﺻﯿﺖﻫﺎی ﻧﻤﻮﻧﻪ را ﮐﭙﺴﻮﻟﻪ ﻣﯽﮐﻨﺪ و ﯾﮏ وﯾﮋﮔﯽ ﮐﻠﯽ اراﺋﻪ ﻣﯽﮐﻨﺪ‪.‬‬ ‫•‬

‫ﺗﺎﺑﻊ )(‪ property‬ﻣﺘﺪﻫﺎی ‪ get,set,delete‬را ﺑﻪ ﻋﻨﻮان آرﮔﻮﻣﺎن ﻣﯽ ﮔﯿﺮد‪.‬‬ ‫•‬

‫ﻣﺜﺎل زﯾﺮ ﻧﺤﻮه اﯾﺠﺎد ﯾﮏ وﯾﮋﮔﯽ در ﭘﺎﯾﺘﻮن ﺑﺎ اﺳﺘﻔﺎده از ﺗﺎﺑﻊ )(‪ property‬را ﻧﺸﺎن ﻣﯽ دﻫﺪ‪.‬‬ ‫•‬

‫در ﻣﺜﺎل زﯾﺮ ﺧﺼﻮﺻﯿﺖ ‪ __name‬ﯾﮏ ﺧﺼﻮﺻﯿﺖ ﭘﻨﻬﺎن اﺳﺖ ﮐﻪ ﺑﻪ ﻃﻮر ﻣﺴﺘﻘﯿﻢ اﻣﮑﺎن ﻣﻘﺪار دﻫﯽ ﻧﺪارد در ﺣﺎﻟﺖ ﻋﺎدی‪.‬‬ ‫•‬

‫در ﻗﺴﻤﺖ ﻫﺎی ﺟﻠﻮﺗﺮ ﻧﺤﻮه ﺗﻌﺮﯾﻒ ﻫﺎی ﻣﺨﺘﻠﻒ ﺧﺼﻮﺻﯿﺖ ﻫﺎ را ﺑﺮرﺳﯽ ﻣﯿﮑﻨﯿﻢ‪.‬‬ ‫•‬

‫اﮐﻨﻮن ﺧﺼﻮﺻﯿﺖ ‪ __name‬ﻓﻘﻂ از ﻃﺮﯾﻖ ﻣﺘﺪ )(‪ setname‬ﻣﻘﺪار دﻫﯽ ﻣﯿﺸﻮدو در ﻣﺘﺪ )(‪getname‬‬ ‫•‬
‫در دﺳﺘﺮس اﺳﺖ‪.‬‬

‫ﻫﺮ دوی اﯾﻦ ﻣﺘﺪ ﻫﺎ ﺑﺮای ﺗﻌﺮﯾﻒ ﯾﮏ ﺧﺼﻮﺻﯿﺖ ﮐﻼس ‪ Student‬ﺑﻪ ﻧﺎم ‪ name‬اﺳﺖ ﮐﻪ ﺑﻪ ﻃﻮر ﻣﺴﺘﻘﯿﻢ‬ ‫•‬
‫اﻣﮑﺎن ﻣﻘﺪار دﻫﯽ ﻧﺪارد‪.‬‬

‫در واﻗﻊ ﻫﺪف اﯾﻦ اﺳﺖ ﮐﻪ ﻧﺤﻮه ﻣﻘﺪار دﻫﯽ را ﻣﺤﺪود و ﺑﺮای ﻣﻘﺪار دﻫﯽ از ﻣﺘﺪ اﺳﺘﻔﺎده ﮐﻨﯿﻢ!‬ ‫•‬

‫روش ﺳﺎده ﺗﺮی ﺑﺮای اﯾﻦ ﮐﺎر وﺟﻮد دارد ﮐﻪ در ﺑﺨﺶ ﻫﺎی ﺑﻌﺪی ﺑﺮرﺳﯽ ﺧﻮاﻫﯿﻢ ﮐﺮد‪.‬‬ ‫•‬
‫‪Decorators‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 33‬‬

‫در ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ‪ ،‬دﮐﻮراﺗﻮر ﯾﮏ اﻟﮕﻮی ﻃﺮاﺣﯽ اﺳﺖ ﮐﻪ ﻣﺴﺌﻮﻟﯿﺖ ﻫﺎی اﺿﺎﻓﯽ را ﺑﻪ ﺻﻮرت ﭘﻮﯾﺎ ﺑﻪ ﯾﮏ ﺷﺊ اﺿﺎﻓﻪ ﻣﯽ ﮐﻨﺪ‪.‬‬ ‫•‬

‫در ﭘﺎﯾﺘﻮن‪ ،‬ﯾﮏ ﺗﺎﺑﻊ ﺷﯽ ﻣﺮﺗﺒﻪ اول اﺳﺖ‪.‬‬ ‫•‬

‫ﺑﻨﺎﺑﺮاﯾﻦ‪ ،‬ﯾﮏ دﮐﻮراﺗﻮر در ﭘﺎﯾﺘﻮن ﻣﺴﺌﻮﻟﯿﺖﻫﺎ‪/‬ﻋﻤﻠﮑﺮدﻫﺎی اﺿﺎﻓﯽ را ﺑﻪ ﺻﻮرت ﭘﻮﯾﺎ و ﺑﺪون ﺗﻐﯿﯿﺮ ﯾﮏ ﺗﺎﺑﻊ ﺑﻪ ﯾﮏ ﺗﺎﺑﻊ دﯾﮕﺮ اﺿﺎﻓﻪ ﻣﯽ ﮐﻨﺪ‪.‬‬ ‫•‬

‫در ﭘﺎﯾﺘﻮن‪ ،‬ﯾﮏ ﺗﺎﺑﻊ را ﻣﯽ ﺗﻮان ﺑﻪ ﻋﻨﻮان آرﮔﻮﻣﺎن ﺑﻪ ﺗﺎﺑﻊ دﯾﮕﺮی ارﺳﺎل ﮐﺮد‪.‬‬ ‫•‬

‫ﻫﻤﭽﻨﯿﻦ ﻣﯽ ﺗﻮان ﯾﮏ ﺗﺎﺑﻊ را در داﺧﻞ ﺗﺎﺑﻊ دﯾﮕﺮی ﺗﻌﺮﯾﻒ ﮐﺮد و ﯾﮏ ﺗﺎﺑﻊ ﻣﯽ ﺗﻮاﻧﺪ ﺗﺎﺑﻊ دﯾﮕﺮی را ﺑﺮﮔﺮداﻧﺪ‪.‬‬ ‫•‬

‫ﺑﻨﺎﺑﺮاﯾﻦ‪ ،‬دﮐﻮراﺗﻮر در ﭘﺎﯾﺘﻮن ﺗﺎﺑﻌﯽ اﺳﺖ ﮐﻪ ﺗﺎﺑﻊ دﯾﮕﺮی را ﺑﻪ ﻋﻨﻮان آرﮔﻮﻣﺎن درﯾﺎﻓﺖ ﻣﯽ ﮐﻨﺪ‪.‬‬ ‫•‬

‫رﻓﺘﺎر ﺗﺎﺑﻊ آرﮔﻮﻣﺎن ﺗﻮﺳﻂ دﮐﻮراﺗﻮر ﺑﺪون ﺗﻐﯿﯿﺮ واﻗﻌﯽ آن ﮔﺴﺘﺮش ﻣﯽ ﯾﺎﺑﺪ‪.‬‬ ‫•‬

‫ﺗﺎﺑﻊ ‪ decorator‬را ﻣﯽ ﺗﻮان ﺑﺎ اﺳﺘﻔﺎده از دﺳﺘﻮر @ و ﺑﻌﺪ از آن ﻧﺎم ﺗﺎﺑﻊ روی ﯾﮏ ﺗﺎﺑﻊ اﻋﻤﺎل ﮐﺮد‪.‬‬ ‫•‬
‫‪Decorators‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 34‬‬

‫ﺗﺎﺑﻊ ﻣﻘﺎﺑﻞ را در ﻧﻈﺮ ﺑﮕﯿﺮﯾﺪ‪:‬‬ ‫•‬

‫اﮐﻨﻮن‪ ،‬ﻣﯽﺗﻮاﻧﯿﻢ ﻋﻤﻠﮑﺮد ﺗﺎﺑﻊ ﻓﻮق را ﺑﺪون ﺗﻐﯿﯿﺮ‪ ،‬ﺑﺎ اﻧﺘﻘﺎل آن ﺑﻪ ﺗﺎﺑﻌﯽ دﯾﮕﺮ‪ ،‬ﻣﺎﻧﻨﺪ ﺷﮑﻞ زﯾﺮ‪ ،‬ﮔﺴﺘﺮش دﻫﯿﻢ‪.‬‬ ‫•‬

‫در ﺑﺎﻻ‪ ،‬ﺗﺎﺑﻊ )(‪ mydecorator‬ﯾﮏ ﺗﺎﺑﻊ را ﺑﻪ ﻋﻨﻮان آرﮔﻮﻣﺎن ﻣﯽ ﮔﯿﺮد‪.‬‬ ‫•‬

‫ﺗﺎﺑﻊ آرﮔﻮﻣﺎن را ﻓﺮاﺧﻮاﻧﯽ ﻣﯽ ﮐﻨﺪ‪.‬‬ ‫•‬

‫ﺑﻨﺎﺑﺮاﯾﻦ‪ ،‬ﻋﻤﻠﮑﺮد ﺗﺎﺑﻊ )(‪ hi‬را ﺑﺪون ﺗﻐﯿﯿﺮ آن ﮔﺴﺘﺮش ﻣﯽ دﻫﺪ‪.‬‬ ‫•‬

‫ﺑﺎ اﯾﻦ ﺣﺎل‪ ،‬اﯾﻦ ﯾﮏ دﮐﻮراﺗﻮر درﺳﺖ و ﺣﺴﺎﺑﯽ و اﺻﻮﻟﯽ ﻧﯿﺴﺖ!‬ ‫•‬
 ‫‪Decorators‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 35‬‬

‫)(‪ mydecorator‬ﯾﮏ دﮐﻮراﺗﻮر در ﭘﺎﯾﺘﻮن ﻧﯿﺴﺖ‪.‬‬ ‫•‬

‫دﮐﻮراﺗﻮر در ﭘﺎﯾﺘﻮن را ﻣﯽ ﺗﻮان ﺑﺮ روی ﻫﺮ ﺗﺎﺑﻊ ﻣﻨﺎﺳﺐ ﺑﺎ اﺳﺘﻔﺎده از ﻧﺤﻮ ‪ @decorator_name‬ﺑﺮای ﮔﺴﺘﺮش ﻋﻤﻠﮑﺮد ﺗﺎﺑﻊ زﯾﺮﯾﻦ ﺗﻌﺮﯾﻒ ﮐﺮد‪.‬‬ ‫•‬

‫اﮐﻨﻮن‪ ،‬ﻣﯽﺗﻮاﻧﯿﻢ از ‪ mydecorator‬ﺑﻪﻋﻨﻮان دﮐﻮراﺗﻮر ﺑﺮای اﻋﻤﺎل روی ﺗﺎﺑﻌﯽ اﺳﺘﻔﺎده ﮐﻨﯿﻢ ﮐﻪ ﻫﯿﭻ آرﮔﻮﻣﺎﻧﯽ ﻧﺪارد‪ ،‬ﻫﻤﺎﻧﻄﻮر ﮐﻪ در زﯾﺮ ﻧﺸﺎن‬ ‫•‬

‫داده ﺷﺪه اﺳﺖ‪.‬‬

‫اﮐﻨﻮن ﺑﺎ ﻓﺮاﺧﻮاﻧﯽ ﺗﺎﺑﻊ )(‪ hi‬ﻋﻤﻠﯿﺎت ﻫﺎی ﺗﺎﺑﻊ دﮐﻮراﺗﻮر ﻧﯿﺰ اﻧﺠﺎم ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫ﭘﺎﯾﺘﻮن دارای ﭼﻨﺪ ﺗﺎﺑﻊ دﮐﻮراﺗﻮر ﮐﺎرﺑﺮدی اﺳﺖ ﮐﻪ ﻣﺎ ﻣﯿﺘﻮاﻧﯿﻢ در ﺟﺎﻫﺎی ﻣﺨﺘﻠﻒ اﻟﺨﺼﻮص ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا از آﻧﻬﺎ اﺳﺘﻔﺎده ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫‪@property‬‬ ‫ﯾﮏ ﻣﺘﺪ را ﺑﻪ ﻋﻨﻮان ﻣﺘﺪﻫﺎی ﺗﻨﻈﯿﻢ ﮐﻨﻨﺪه ﯾﺎ ﮔﯿﺮﻧﺪه ﯾﮏ وﯾﮋﮔﯽ اﻋﻼم ﻣﯽ ﮐﻨﺪ‪.‬‬

‫‪@classmethod‬‬ ‫ﻣﺘﺪی را ﺑﻪ ﻋﻨﻮان ﻣﺘﺪ ﮐﻼس اﻋﻼم ﻣﯽ ﮐﻨﺪ ﮐﻪ ﻣﯽ ﺗﻮان ﺑﺎ اﺳﺘﻔﺎده از ﻧﺎم ﮐﻼس ﻓﺮاﺧﻮاﻧﯽ ﮐﺮد‪.‬‬

‫‪@staticmethod‬‬ ‫ﯾﮏ روش را ﺑﻪ ﻋﻨﻮان روش اﯾﺴﺘﺎ اﻋﻼم ﻣﯽ ﮐﻨﺪ‪.‬‬

‫‪@property Decorator‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 36‬‬

‫دﮐﻮراﺗﻮر ‪ @property‬ﯾﮏ دﮐﻮراﺗﻮر داﺧﻠﯽ در ﭘﺎﯾﺘﻮن ﺑﺮای ﺗﺎﺑﻊ )(‪ property‬اﺳﺖ‪.‬‬ ‫•‬

‫از ‪ @property‬در ﻫﺮ ﻣﺘﺪ ﯾﮏ ﮐﻼس ﺑﺮای اﺳﺘﻔﺎده از ﯾﮏ ﻣﺘﺪ ﺑﻪ ﻋﻨﻮان ﯾﮏ وﯾﮋﮔﯽ ﻣﯿﺘﻮاﻧﯿﺪ اﺳﺘﻔﺎده ﮐﻨﯿﺪ‪.‬‬ ‫•‬

‫ﺑﺮای ﺗﻌﺮﯾﻒ ﯾﮏ وﯾﮋﮔﯽ ﻣﯽ ﺗﻮاﻧﯿﺪ از ﺳﻪ دﮐﻮراﺗﻮر زﯾﺮ اﺳﺘﻔﺎده ﮐﻨﯿﺪ‪:‬‬ ‫•‬

‫‪ :@property (1‬ﻣﺘﺪ را ﺑﻪ ﻋﻨﻮان ﯾﮏ وﯾﮋﮔﯽ اﻋﻼم ﻣﯽ ﮐﻨﺪ‪.‬‬

‫‪ :@<property-name>.setter (2‬ﻣﺘﺪ ‪ setter‬را ﺑﺮای ﺧﺎﺻﯿﺖ ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﺪ ﮐﻪ ﻣﻘﺪار ﯾﮏ وﯾﮋﮔﯽ را ﺗﻨﻈﯿﻢ ﮐﻨﺪ‪.‬‬

‫‪ :@<property-name>.deleter (3‬ﻣﺘﺪ ﺣﺬف را ﺑﻪ ﻋﻨﻮان ﺧﺎﺻﯿﺘﯽ ﮐﻪ ﯾﮏ ﺧﺎﺻﯿﺖ را ﺣﺬف ﻣﯽ ﮐﻨﺪ‪ ،‬ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﺪ‪.‬‬
‫‪Declare a Property‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 37‬‬

‫در ﻗﻄﻌﻪ زﯾﺮ ﻣﺘﺪ ﺑﻪ ﻋﻨﻮان ﯾﮏ وﯾﮋﮔﯽ اﻋﻼم ﻣﯽ ﺷﻮد‪.‬‬ ‫•‬

‫اﯾﻦ روش ﻣﯿﺒﺎﯾﺴﺖ ﻣﻘﺪار ﺧﺎﺻﯿﺖ را ﺑﺮﮔﺮداﻧﺪ‪.‬‬ ‫•‬

‫در ﻗﻄﻌﻪ ﮐﺪ زﯾﺮ دﮐﻮراﺗﻮر ‪ @property‬روی ﻣﺘﺪ )(‪ name‬اﻋﻤﺎل ﺷﺪ‪.‬‬ ‫•‬

‫ﻣﺘﺪ )(‪ name‬ﻣﻘﺪار ﺧﺼﻮﺻﯽ ‪ __name‬را ﺑﺮﻣﯿﮕﺮداﻧﺪ‪.‬‬ ‫•‬

‫اﮐﻨﻮن ﺑﺎ ﻣﺘﺪ )(‪ name‬ﺑﻪ ﻋﻨﻮان ﯾﮏ وﯾﮋﮔﯽ ﻣﯿﺘﻮاﻧﯿﻢ ﻣﻘﺪار ‪ __name‬را ﺑﻪ دﺳﺖ آورﯾﻢ‪.‬‬ ‫•‬

‫ﻫﻤﭽﻨﯿﻦ ﻣﻘﺪاردﻫﯽ وﯾﮋﮔﯽ ‪ name‬ﺑﺮای ﮐﻼس ‪ Student‬اﺟﺒﺎری ﺧﻮاﻫﺪ ﺑﻮد!‬ ‫•‬

‫‪Property setter‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 38‬‬

‫در ﺑﺨﺶ ﻗﺒﻠﯽ ﻣﺘﺪ )(‪ name‬ﺑﻪ ﻋﻨﻮان ﯾﮏ وﯾﮋﮔﯽ ﺗﻌﺮﯾﻒ ﮐﺮدﯾﻢ‪.‬‬ ‫•‬

‫ﻣﺎ ﻓﻘﻂ ﻣﯽ ﺗﻮاﻧﯿﻢ ﺑﻪ ﻣﻘﺪار وﯾﮋﮔﯽ ‪ name‬دﺳﺘﺮﺳﯽ داﺷﺘﻪ ﺑﺎﺷﯿﻢ اﻣﺎ ﻧﻤﯽ ﺗﻮاﻧﯿﻢ آن را ﺗﻐﯿﯿﺮ دﻫﯿﻢ‪.‬‬ ‫•‬

‫ﺑﺮای ﺗﻐﯿﯿﺮ ﻣﻘﺪار وﯾﮋﮔﯽ‪ ،‬ﺑﺎﯾﺪ ﻣﺘﺪ ‪ setter‬را ﺑﺮای وﯾﮋﮔﯽ ‪ name‬ﺑﺎ اﺳﺘﻔﺎده از ‪ @property-name.setter‬ﺗﻌﺮﯾﻒ ﮐﻨﯿﻢ‪ ،‬ﻣﺎﻧﻨﺪ ﺷﮑﻞ زﯾﺮ‪:‬‬ ‫•‬

‫اﮐﻨﻮن ﻣﯿﺘﻮان ﻣﻘﺪار ﺧﺎﺻﯿﺖ‪/‬وﯾﮋﮔﯽ ‪ name‬ﺗﻐﯿﯿﺮ داد‪.‬‬ ‫•‬

‫‪Property Deleter‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 39‬‬

‫ﺑﻪ ﮐﻤﮏ دﮐﻮراﺗﻮر ‪ @property-name.deleter‬ﻣﯿﺘﻮان ﻣﺘﺪی ﺗﻌﺮﯾﻒ ﮐﺮد ﮐﻪ وﯾﮋﮔﯽ ﯾﺎ ﺧﺎﺻﯿﺖ را ﺣﺬف ﻣﯿﮑﻨﺪ‪.‬‬ ‫•‬

‫ﺳﭙﺲ ﻣﯿﺘﻮان ﺑﻪ ﮐﻠﻤﻪ ﮐﻠﯿﺪی ‪ del‬ﺑﻪ ﮐﻞ وﯾﮋﮔﯽ‪/‬ﺧﺎﺻﯿﺖ را ﺣﺬف ﻧﻤﻮد‪.‬‬ ‫•‬

‫‪@classmethod decorator‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 40‬‬

‫دﮐﻮراﺗﻮر ‪ @classmethod‬ﺑﺮای اﻋﻼم ﻣﺘﺪی در ﮐﻼس اﺳﺘﻔﺎده ﻣﯽﺷﻮد ﮐﻪ ﻣﯽﺗﻮان ﺑﺎ اﺳﺘﻔﺎده از )(‪ ClassName.MethodName‬ﻓﺮاﺧﻮاﻧﯽ ﮐﺮد‪.‬‬ ‫•‬

‫ﻫﻤﭽﻨﯿﻦ ﺑﺎ اﺳﺘﻔﺎده از ﯾﮏ ﺷﯽ از ﮐﻼس ﻓﺮاﺧﻮاﻧﯽ ﺷﻮد‪.‬‬ ‫•‬

‫‪ @classmethod‬ﺟﺎﯾﮕﺰﯾﻦ ﺗﺎﺑﻊ )(‪ classmethod‬اﺳﺖ‪.‬‬ ‫•‬

‫وﯾﮋﮔﯽ ﻫﺎی دﮐﻮراﺗﻮر ‪:@classmethod‬‬ ‫•‬

‫ﯾﮏ ﻣﺘﺪ از ﮐﻼس را اﻋﻼم ﻣﯿﮑﻨﺪ‪.‬‬ ‫‪(1‬‬

‫اوﻟﯿﻦ ﭘﺎراﻣﺘﺮ ﺑﺎﯾﺪ ‪ cls‬ﺑﺎﺷﺪ ﮐﻪ ﻣﯽ ﺗﻮان از آن ﺑﺮای دﺳﺘﺮﺳﯽ ﺑﻪ وﯾﮋﮔﯽ ﻫﺎی ﮐﻼس اﺳﺘﻔﺎده ﮐﺮد‪.‬‬ ‫‪(2‬‬

‫ﻣﺘﺪ ﮐﻼس ﻓﻘﻂ ﻣﯽ ﺗﻮاﻧﺪ ﺑﻪ وﯾﮋﮔﯽ ﻫﺎی ﮐﻼس دﺳﺘﺮﺳﯽ داﺷﺘﻪ ﺑﺎﺷﺪ اﻣﺎ ﺑﻪ وﯾﮋﮔﯽ ﻫﺎی ﻧﻤﻮﻧﻪ دﺳﺘﺮﺳﯽ ﻧﺪارد‪.‬‬ ‫‪(3‬‬

‫ﻣﺘﺪ ﮐﻼس را ﻣﯽ ﺗﻮان ﺑﺎ اﺳﺘﻔﺎده از )(‪ ClassName.MethodName‬و ﻫﻤﭽﻨﯿﻦ ﺑﺎ اﺳﺘﻔﺎده از ﺷﯽء ﻓﺮاﺧﻮاﻧﯽ ﮐﺮد‪.‬‬ ‫‪(4‬‬

‫ﻣﯽ ﺗﻮاﻧﺪ ﯾﮏ ﺷﯽ از ﮐﻼس را ﺑﺮﮔﺮداﻧﺪ‪.‬‬ ‫‪(5‬‬

‫‪@classmethod decorator‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 41‬‬

‫در ﻣﺜﺎل ﻣﻘﺎﺑﻞ ﮐﻼس ‪ Student‬دارای ﯾﮏ وﯾﮋﮔﯽ ﺑﺮای ﺧﻮد ﮐﻼس و ﯾﮏ وﯾﮋﮔﯽ ﻧﻤﻮﻧﻪ اﺳﺖ‪.‬‬ ‫•‬

‫ﯾﮏ ﻣﺘﺪ ﺑﺎ ﻋﻨﻮان ‪ tostring‬ﺑﻪ ﮐﻤﮏ دﮐﻮراﺗﻮر ‪ @classmethod‬ﺗﻌﺮﯾﻒ ﮐﺮده اﯾﻢ‪.‬‬ ‫•‬

‫ﻣﺘﺪ ‪ tostring‬ﻣﯿﺘﻮاﻧﺪ ﺑﻪ ﺷﮑﻞ )(‪ Student.tostring‬ﻓﺮاﺧﻮاﻧﯽ ﺷﻮد‪.‬‬ ‫•‬

‫ﺗﻮﺟﻪ داﺷﺘﻪ ﺑﺎﺷﯿﺪ ﮐﻪ اوﻟﯿﻦ ﭘﺎراﻣﺘﺮ ﻫﺮ ‪ @classmethod‬ﺑﺎﯾﺪ ‪ cls‬ﺑﺎﺷﺪ ﮐﻪ ﺑﺘﻮان از آن ﺑﺮای دﺳﺘﺮﺳﯽ ﺑﻪ وﯾﮋﮔﯽ ﻫﺎی ﮐﻼس اﺳﺘﻔﺎده ﮐﺮد‪.‬‬ ‫•‬
‫‪@staticmethod decorator‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 42‬‬

‫‪ @staticmethod‬ﯾﮏ دﮐﻮراﺗﻮر داﺧﻠﯽ اﺳﺖ ﮐﻪ ﯾﮏ ﻣﺘﺪ اﺳﺘﺎﺗﯿﮏ را در ﮐﻼس در ﭘﺎﯾﺘﻮن ﺗﻌﺮﯾﻒ ﻣﯽ ﮐﻨﺪ‪.‬‬ ‫•‬

‫وﯾﮋﮔﯽ ﻫﺎی دﮐﻮراﺗﻮر ‪:@staticmethod‬‬ ‫•‬

‫اﻋﻼم ﯾﮏ ﻣﺘﺪ اﺳﺘﺎﺗﯿﮏ‪/‬ﺛﺎﺑﺖ ﻧﻪ ﭘﻮﯾﺎ!‬ ‫•‬

‫ﻧﻤﯽ ﺗﻮاﻧﺪ ﭘﺎراﻣﺘﺮ ‪ cls‬ﯾﺎ ‪ self‬داﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬ ‫•‬

‫ﻣﺘﺪ اﺳﺘﺎﺗﯿﮏ ﻧﻤﯽ ﺗﻮاﻧﺪ ﺑﻪ وﯾﮋﮔﯽ‪/‬ﺧﺼﻮﺻﯿﺖ ﻫﺎی ﮐﻼس ﯾﺎ وﯾﮋﮔﯽ‪/‬ﺧﺼﻮﺻﯿﺖ ﻫﺎی ﻧﻤﻮﻧﻪ دﺳﺘﺮﺳﯽ داﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬ ‫•‬

‫ﻣﺘﺪ اﺳﺘﺎﺗﯿﮏ را ﻣﯽ ﺗﻮان ﺑﺎ اﺳﺘﻔﺎده از )(‪ ClassName.MethodName‬و ﻫﻤﭽﻨﯿﻦ ﺑﺎ اﺳﺘﻔﺎده از )( ‪ object.MethodName‬ﻓﺮاﺧﻮاﻧﯽ ﮐﺮد‪.‬‬ ‫•‬

‫ﻣﯽ ﺗﻮاﻧﺪ ﯾﮏ ﺷﯽ از ﮐﻼس را ﺑﺮﮔﺮداﻧﺪ‪.‬‬ ‫•‬

‫در ﺑﺮﻧﺎﻣﻪ ﻫﺎی ﮐﺎرﺑﺮدی ﻣﯿﺘﻮان از آن در ﮐﻼس ﺑﻪ ﻋﻨﻮان ﯾﮏ راﻫﻨﻤﺎ ﯾﺎ ﻣﺘﺪی ﮐﻪ ورژن ﺑﺮﻧﺎﻣﻪ را ﺑﮕﻮﯾﺪ اﺳﺘﻔﺎده ﮐﺮد‪.‬‬ ‫•‬
‫‪Magic or Dunder Methods‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 43‬‬

‫ﻣﺘﺪﻫﺎی ﺟﺎدوﯾﯽ در ﭘﺎﯾﺘﻮن ﻣﺘﺪﻫﺎی ﺧﺎﺻﯽ ﻫﺴﺘﻨﺪ ﮐﻪ ﺑﺎ زﯾﺮﺧﻂ دوﺗﺎﯾﯽ __ ﺷﺮوع و ﺧﺘﻢ ﻣﯽ ﺷﻮﻧﺪ‪.‬‬ ‫•‬

‫ﻣﺘﺪﻫﺎی ﺟﺎدوﯾﯽ ﻗﺮار ﻧﯿﺴﺖ ﻣﺴﺘﻘﯿﻤﺎ ً ﺗﻮﺳﻂ ﺷﻤﺎ ﻓﺮاﺧﻮاﻧﯽ ﺷﻮﻧﺪ‪ ،‬اﻣﺎ ﻓﺮاﺧﻮاﻧﯽ ﺑﻪ ﺻﻮرت داﺧﻠﯽ از ﮐﻼس در ﯾﮏ ﻋﻤﻞ ﺧﺎص اﻧﺠﺎم ﻣﯽ ﺷﻮد‪.‬‬ ‫•‬

‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪ ،‬ﻫﻨﮕﺎﻣﯽ ﮐﻪ دو ﻋﺪد را ﺑﺎ اﺳﺘﻔﺎده از ﻋﻤﻠﮕﺮ ‪ +‬اﺿﺎﻓﻪ ﻣﯽ ﮐﻨﯿﺪ‪ ،‬ﺑﻪ ﺻﻮرت داﺧﻠﯽ‪ ،‬ﻣﺘﺪ )(__‪ __add‬ﻓﺮاﺧﻮاﻧﯽ ﻣﯽ ﺷﻮد‪.‬‬ ‫•‬

‫ﮐﻼس ﻫﺎی داﺧﻠﯽ در ﭘﺎﯾﺘﻮن روش ﻫﺎی ﺟﺎدوﯾﯽ زﯾﺎدی را ﺗﻌﺮﯾﻒ ﮐﺮدهاﻧﺪ‪.‬‬ ‫•‬

‫از ﺗﺎﺑﻊ )(‪ dir‬ﺑﺮای ﻣﺸﺎﻫﺪه ﺗﻌﺪاد ﻣﺘﺪﻫﺎی ﺟﺎدوﯾﯽ ﮐﻪ ﺗﻮﺳﻂ ﯾﮏ ﮐﻼس ﺑﻪ ارث ﺑﺮده ﺷﺪه اﺳﺖ اﺳﺘﻔﺎده ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫ﺑﺮای ﻣﺜﺎل‪ ،‬ﺗﻤﺎم وﯾﮋﮔﯽ ﻫﺎ و ﻣﺘﺪﻫﺎی ﺗﻌﺮﯾﻒ ﺷﺪه در ﮐﻼس ‪ float‬را ﻓﻬﺮﺳﺖ ﻣﯽ ﮐﻨﺪ‪.‬‬ ‫•‬

‫اﮔﺮ اﯾﻦ ﺗﺎﺑﻊ ﺑﺪون آرﮔﻮﻣﺎن ﻓﺮاﺧﻮاﻧﯽ ﺷﻮد اﺳﺎﻣﯽ ﻣﺘﺪ ﻫﺎی اﺟﺮاﯾﯽ ﺑﺮﻧﺎﻣﻪ را در اﺳﮑﻮپ ﻓﻌﻠﯽ )ﺑﺮﻧﺎﻣﻪ ﭘﯿﺶ رو(‬ ‫•‬

‫ﺑﺮ ﻣﯿﮕﺮداﻧﺪ!‬
‫‪Magic or Dunder Methods‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 44‬‬

‫ﻫﻤﺎﻧﻄﻮر ﮐﻪ در ﺑﺨﺶ ﻗﺒﻞ دﯾﺪﯾﺪ‪ ،‬ﮐﻼس ‪ float‬ﺷﺎﻣﻞ ﻣﺘﺪﻫﺎی ﺟﺎدوﯾﯽ ﻣﺨﺘﻠﻔﯽ اﺳﺖ ﮐﻪ ﺑﺎ زﯾﺮﺧﻂ ﻫﺎی دوﺗﺎﯾﯽ ﺗﻌﺮﯾﻒ ﺷﺪه اﻧﺪ‪.‬‬ ‫•‬

‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪ ،‬ﻣﺘﺪ __‪ __add‬ﯾﮏ ﻣﺘﺪ ﺟﺎدوﯾﯽ اﺳﺖ ﮐﻪ زﻣﺎﻧﯽ ﻓﺮاﺧﻮاﻧﯽ ﻣﯽ ﺷﻮد ﮐﻪ دو ﻋﺪد را ﺑﺎ اﺳﺘﻔﺎده از ﻋﻤﻠﮕﺮ ‪ +‬اﺿﺎﻓﻪ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺑﺎ اﯾﻦ ﺣﺎل‪ ،‬ﻫﻤﺎﻧﻄﻮر ﮐﻪ ﻗﺒﻼ ً ذﮐﺮ ﺷﺪ‪ ،‬روشﻫﺎی ﺟﺎدوﯾﯽ ﺑﻪ اﯾﻦ ﻣﻌﻨﺎ ﻧﯿﺴﺖ ﮐﻪ ﻣﺴﺘﻘﯿﻤﺎ ً اﺳﺘﻔﺎده ﺷﻮﻧﺪ‪ ،‬ﺑﻠﮑﻪ ﺑﻪ ﺻﻮرت دروﻧﯽ از ﻃﺮﯾﻖ‬ ‫•‬

‫ﺑﺮﺧﯽ روشﻫﺎ ﯾﺎ اﻗﺪاﻣﺎت دﯾﮕﺮ ﻓﺮاﺧﻮاﻧﯽ ﻣﯽﺷﻮﻧﺪ‪.‬‬

‫ﻣﺘﺪﻫﺎی ﺟﺎدوﯾﯽ اﻏﻠﺐ ﺑﺮای ﺗﻌﺮﯾﻒ رﻓﺘﺎرﻫﺎی ﺑﺎرﮔﺬاری ﺷﺪه اﭘﺮاﺗﻮرﻫﺎی از ﭘﯿﺶ ﺗﻌﺮﯾﻒ ﺷﺪه در ﭘﺎﯾﺘﻮن اﺳﺘﻔﺎده ﻣﯽ ﺷﻮﻧﺪ‪.‬‬ ‫•‬

‫ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪ ،‬ﻋﻤﻠﮕﺮﻫﺎی ﺣﺴﺎﺑﯽ ﺑﻪ ﻃﻮر ﭘﯿﺶ ﻓﺮض ﺑﺮ اﺳﺎس ﻋﻤﻠﻮﻧﺪﻫﺎی ﻋﺪدی ﻋﻤﻞ ﻣﯽ ﮐﻨﻨﺪ‪.‬‬ ‫•‬

‫اﯾﻦ ﺑﺪان ﻣﻌﻨﯽ اﺳﺖ ﮐﻪ اﺷﯿﺎء ﻋﺪدی ﺑﺎﯾﺪ ﻫﻤﺮاه ﺑﺎ ﻋﻤﻠﮕﺮﻫﺎﯾﯽ ﻣﺎﻧﻨﺪ ‪ / ،* ،- ،+‬و ﻏﯿﺮه اﺳﺘﻔﺎده ﺷﻮﻧﺪ‪.‬‬ ‫•‬

‫ﻋﻤﻠﮕﺮ ‪ +‬ﻧﯿﺰ ﺑﻪ ﻋﻨﻮان ﯾﮏ ﻋﻤﻠﮕﺮ اﻟﺤﺎق در ﮐﻼس ﻫﺎی ‪ list ،string‬و ‪ tuple‬اﺳﺘﻔﺎده ﻣﯽ ﺷﻮد‪.‬‬ ‫•‬

‫در ﺑﺨﺶ ﻫﺎی ﺑﻌﺪی ﭼﻨﺪ ﻣﺘﺪ ﺟﺎدوﯾﯽ ﻣﻬﻢ ﺑﺮرﺳﯽ ﻣﯿﺸﻮد‪.‬‬ ‫•‬
‫‪__new__() method‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 45‬‬

‫در ﭘﺎﯾﺘﻮن ﻣﺘﺪ ﺟﺎدوﯾﯽ )(__‪ __new‬ﺣﺘﻤﺎ ﻗﺒﻞ از ﻣﺘﺪ )(__‪ __init‬ﻓﺮاﺧﻮاﻧﯽ ﻣﯽ ﺷﻮد‪.‬‬ ‫•‬

‫ﻣﺘﺪ )(__‪ __new‬ﯾﮏ ﺷﯽ ﺟﺪﯾﺪ ﺑﺮﻣﯽ ﮔﺮداﻧﺪ ﮐﻪ ﺳﭙﺲ ﺑﺎ )(__‪ __init‬ﻣﻘﺪاردﻫﯽ اوﻟﯿﻪ ﻣﯽ ﺷﻮد‪.‬‬ ‫•‬
‫‪__str__() method‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 46‬‬

‫ﯾﮑﯽ دﯾﮕﺮ از ﻣﺘﺪ ﻫﺎی ﺟﺎدوﯾﯽ ﻣﻔﯿﺪ‪__str__() ،‬اﺳﺖ‪.‬‬ ‫•‬

‫ﺑﺮای ﺑﺎزﮔﺮداﻧﺪن ﯾﮏ ﻧﻤﺎﯾﺶ رﺷﺘﻪ ﻗﺎﺑﻞ ﭼﺎپ از ﻫﺮ ﮐﻼس ﺗﻌﺮﯾﻒ ﺷﺪه ﺗﻮﺳﻂ ﮐﺎرﺑﺮ اﺳﺘﻔﺎده ﻣﯽ ﺷﻮد‪.‬‬ ‫•‬

‫ﺑﺮای ﻣﺜﺎل ﻋﺪد ‪ ۱۲‬را ﺑﻪ ﻋﻨﻮان ورودی ﺑﻪ ﺗﺎﺑﻊ )(‪ str‬ﻣﯿﺪﻫﯿﺪ‪.‬‬ ‫•‬

‫ﺧﺮوﺟﯽ ﺑﺮاﺑﺮ ’‪ ’۱۲‬ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬ ‫•‬

‫ﭼﻮن در ﮐﻼس ﺷﺊ ‪ int‬ﻣﺘﺪ __‪ __str‬ﺗﻌﺮﯾﻒ ﺷﺪه اﺳﺖ ﻣﯿﺘﻮان ﻣﻘﺪار ﻋﺪد ﺻﺤﯿﺢ را ﺑﻪ ﻣﺘﻦ ﺗﺒﺪﯾﻞ ﮐﺮد!‬ ‫•‬

‫در ﺣﺎﻟﺖ ﻋﺎدی اﮔﺮ ﯾﮏ ﺷﺊ ﺳﺎﺧﺘﻪ ﺷﺪه از ﮐﻼس را ﺑﻪ ﺗﺎﺑﻊ آن ﭼﯿﺰی اﺳﺖ ﮐﻪ دﻟﺨﻮاه ﻣﺎ اﺳﺖ‪.‬‬ ‫•‬
‫‪__add__() method‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 47‬‬

‫ﺑﺎ ﺗﻌﺮﯾﻒ اﯾﻦ ﻣﺘﺪ ﺑﺮای ﮐﻼس ﻣﯿﺘﻮان ﻗﺎﺑﻠﯿﺘﯽ ﺑﻪ ﺷﺊ ﻫﺎی ﺳﺎﺧﺘﻪ ﺷﺪه از ﮐﻼس داد ﮐﻪ ﺑﺘﻮان ﺑﺎ ﻋﻤﻠﮕﺮ ‪ +‬ﺧﺮوﺟﯽ ﻫﺎی ﺷﺊ را ﺟﻤﻊ ﮐﺮد‪.‬‬ ‫•‬
‫‪Magic methods‬‬ ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 48‬‬

‫ﺑﺎ ﮐﺎرﮐﺮد ﻣﺘﺪ ﻫﺎی ﺟﺎدوﯾﯽ آﺷﻨﺎ ﺷﺪﯾﻢ‪.‬‬ ‫•‬

‫ﺗﻌﺪاد زﯾﺎدی ﻣﺘﺪ ﺟﺎدوﯾﯽ وﺟﻮد دارد‪.‬‬ ‫•‬

‫داﻧﺴﺘﯿﻢ ﮐﻪ ﻫﺪف اﺳﺘﻔﺎده از آﻧﻬﺎ در ﮐﻼس دادن ﺑﺮﺧﯽ ﻗﺎﺑﻠﯿﺖ ﻫﺎ ﺑﻪ ﮐﻼس اﺳﺖ‪.‬‬ ‫•‬

‫ﻣﺜﻼ ﻣﯿﺘﻮان ﺑﺎ ﻣﺘﺪ __‪ __str‬ﻗﺎﺑﻠﯿﺘﯽ ﺑﻪ ﮐﻼس داد ﮐﻪ زﻣﺎﻧﯽ ﮐﻪ آن را ﭘﺮﯾﻨﺖ ﻣﯿﮑﻨﯿﻢ ﺧﺮوﺟﯽ دﻟﺨﻮاه ﻣﺎ ﺑﺎﺷﺪ‪.‬‬ ‫•‬

‫ﯾﺎ ﺑﺎ ﻣﺘﺪ __‪ __add‬ﻣﯿﺘﻮان ﻗﺎﺑﻠﯿﺘﯽ ﺑﻪ ﮐﻼس داد ﮐﻪ ﺷﺊ ﻫﺎی ﺳﺎﺧﺘﻪ ﺷﺪه آن ﮐﻼس را ﺑﺘﻮان ﺑﺎ ﻣﻘﺎدﯾﺮ دﯾﮕﺮ ﺟﻤﻊ ﮐﺮد‪.‬‬ ‫•‬

‫ﺟﺪول ﻣﺘﺪ ﻫﺎی ﺟﺎدوﯾﯽ ﮐﺎرﺑﺮدی در ﺑﺨﺶ ﻫﺎی ﺑﻌﺪی آﻣﺪه اﺳﺖ‪.‬‬ ‫•‬
 ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 49‬‬

‫‪Magic methods - Initialization and Construction‬‬

‫ﻣﺘﺪ ﻫﺎی ﺳﺎﺧﺖ و اوﻟﯿﻪ ﺳﺎزی‬ ‫ﺗﻮﺿﯿﺤﺎت‬

‫)‪__new__(cls, other‬‬ ‫ﺑﺮای ﻓﺮاﺧﻮاﻧﯽ‪/‬ﺗﻌﺮﯾﻒ ﮐﻼس در ﻧﻤﻮﻧﻪ ﯾﮏ ﺷﺊ‬

‫)‪__init__(self, other‬‬ ‫ﻣﺘﺪ ﺳﺎزﻧﺪه – ﺑﺮای ﻣﻘﺪار دﻫﯽ اوﻟﯿﻪ ﯾﮏ ﺷﺊ‬

‫)‪__del__(self‬‬ ‫ﻣﺘﺪ ﺗﺨﺮﯾﺒﮕﺮ – ﺑﺮای ﺣﺬف ﺷﺊ‬

 ‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺊ ﮔﺮا ‪OBJECT ORIENTED PROGRAMMING‬‬ ‫‪PART 50‬‬

‫‪Magic methods - Unary operators and functions‬‬

‫ﻋﻤﻠﮕﺮﻫﺎ و ﺗﻮاﺑﻊ ‪Unary‬‬ ‫ﺗﻮﺿﯿﺤﺎت‬

‫)‪__pos__(self‬‬ ‫ﺑﺮای ﻓﺮاﺧﻮاﻧﯽ ﻣﺜﺒﺖ ﯾﮑﻨﻮاﺧﺘﯽ ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪+object :‬‬

‫)‪__neg__(self‬‬ ‫ﺑﺮای ﻓﺮاﺧﻮاﻧﯽ ﻣﻨﻔﯽ ﯾﮑﻨﻮاﺧﺘﯽ ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل‪-object :‬‬

‫)‪__abs__(self‬‬ ‫ﺑﺮای ﻓﺮاﺧﻮاﻧﯽ ﺗﻮﺳﻂ ﺗﺎﺑﻊ داﺧﻠﯽ )(‪abs‬‬

‫)‪__invert__(self‬‬ ‫ﺑﺮای ﻓﺮاﺧﻮاﻧﯽ واروﻧﮕﯽ ﺑﺎ اﺳﺘﻔﺎده از ﻋﻤﻠﮕﺮ ~‬

‫)‪__round__(self,n‬‬ ‫ﺑﺮای ﻓﺮاﺧﻮاﻧﯽ ﺗﻮﺳﻂ ﺗﺎﺑﻊ داﺧﻠﯽ )(‪round‬‬

‫)‪__floor__(self‬‬ ‫ﺑﺮای ﻓﺮاﺧﻮاﻧﯽ ﺗﻮﺳﻂ ﺗﺎﺑﻊ داﺧﻠﯽ )(‪math.floor‬‬

‫ﺑﺮای ﻓﺮاﺧﻮاﻧﯽ ﺗﻮﺳﻂ ﺗﺎﺑﻊ داﺧﻠﯽ )(‪math.ceil‬‬

‫)‪__ceil__(self‬‬

‫)‪__trunc__(self‬‬ ‫ﺑﺮای ﻓﺮاﺧﻮاﻧﯽ ﺗﻮﺳﻂ ﺗﺎﺑﻊ داﺧﻠﯽ )(‪math.trunc‬‬