‫ﻤﻪ‬

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

‫ﻣﻘﺪﻣﺎت و ﻣﺒﺎﻧﯽ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﭘﺎﯾﺘﻮن‬

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

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

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

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

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

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

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

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

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

‫ﺗﻮﺻﯿﻪ ﻫﺎی ﺷﺨﺼﯽ در ﮐﻨﺎر آﻣﻮزش‪:‬‬ ‫•‬

‫• ارﺗﺒﺎط ﻣﺴﺘﻘﯿﻢ ﺑﺎ ﻣﺪرس‪:‬‬
‫ﺻﺒﺮ و ﺣﻮﺻﻠﻪ‬ ‫‪ü‬‬
‫‪ Ø‬وﺑﺴﺎﯾﺖ ﺷﺨﺼﯽ ‪amirkho.ir‬‬
‫ﯾﺎدﮔﯿﺮی زﺑﺎن ﺗﺨﺼﺼﯽ ﮐﺎﻣﭙﯿﻮﺗﺮ‬ ‫‪ü‬‬
‫‪ Ø‬اﯾﻤﯿﻞ ‪[email protected]‬‬

‫ﻣﺒﺎﻧﯽ و ﻣﻘﺪﻣﺎت اﻟﮕﻮرﯾﺘﻢ‬ ‫‪ü‬‬

‫ﻋﺪم ﺟﺎ ﺑﻪ ﺟﺎﯾﯽ در ﻣﺒﺎﺣﺚ و ﺣﻮزه ﻫﺎی ﺗﺨﺼﺼﯽ دﯾﮕﺮ‬ ‫‪ü‬‬

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

‫ﺗﻌﺮﯾﻒ ﺳﺎده ﺗﺎﺑﻊ )‪(Function‬‬ ‫‪9‬‬ ‫ﻣﻘﺪﻣﻪ و ﺳﺨﻦ ﻣﺪرس‬ ‫‪1‬‬

‫ﮐﻠﻤﺎت ﮐﻠﯿﺪی و رزرو ﺷﺪه ﭘﺎﯾﺘﻮن‬ ‫‪10‬‬ ‫ﺗﻌﺮﯾﻒ ﺑﺮﻧﺎﻣﻪ )‪(Program‬‬ ‫‪2‬‬

‫ﮐﺎﻣﻨﺖ‪/‬ﻧﺸﺎﻧﻪ ﮔﺬاری‬ ‫‪11‬‬ ‫ﻣﻌﺮﻓﯽ ﺑﺮﺧﯽ از زﺑﺎن ﻫﺎی ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ‬ ‫‪3‬‬

‫ﻣﺘﻐﯿﯿﺮ )‪(Variables‬‬ ‫‪12‬‬ ‫ﻣﻌﺮﻓﯽ زﺑﺎن ‪Python‬‬ ‫‪4‬‬

‫اﻧﻮاع داده در ﭘﺎﯾﺘﻮن )‪(Data types‬‬ ‫‪13‬‬ ‫‪ IDE‬ﭼﯿﺴﺖ؟‬ ‫‪5‬‬

‫داده ﻫﺎی ﻋﺪدی )‪(Numeric types‬‬ ‫‪14‬‬ ‫ﻣﻌﺮﻓﯽ ﺑﺮﺧﯽ از ‪ IDE‬ﻫﺎ‬ ‫‪6‬‬

‫ﺗﺼﺨﯿﺺ ﭼﻨﺪﮔﺎﻧﻪ )‪(Multiple assignment‬‬ ‫‪15‬‬ ‫ﻧﺼﺐ ﭘﺎﯾﺘﻮن و ‪Python IDLE‬‬ ‫‪7‬‬

‫رﺷﺘﻪ ﻫﺎ )‪ (Strings‬ﺑﺨﺶ ‪۱‬‬ ‫‪16‬‬ ‫ﻧﻮﺷﺘﻦ اوﻟﯿﻦ ﺑﺮﻧﺎﻣﻪ !‪ – Hello,World‬ﺗﺎﺑﻊ ‪print‬‬ ‫‪8‬‬

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

 ‫ﻋﻤﻠﮕﺮﻫﺎی ﻣﻨﻄﻘﯽ ‪logical operators‬‬ ‫‪27‬‬ ‫ﻗﻮاﻧﯿﻦ ﻧﺎم ﮔﺬاری ﻣﺘﻐﯿﯿﺮ ﻫﺎ‬ ‫‪17‬‬

‫ﻋﻤﻠﮕﺮﻫﺎی ﻋﻀﻮﯾﺖ ‪membership operators‬‬ ‫‪28‬‬ ‫ﺗﺒﺪﯾﻞ ﻧﻮع داده ﻫﺎ )‪(Data type conversation‬‬ ‫‪18‬‬

‫ﻋﻤﻠﮕﺮﻫﺎی ﺷﻨﺎﺳﺎﯾﯽ ‪identify operators‬‬ ‫‪29‬‬ ‫ﺗﺎﺑﻊ ‪input‬‬ ‫‪19‬‬

‫ﺷﺮط ﻫﺎ و ﺗﺼﻤﯿﻢ ﮔﯿﺮی ‪Conditions and Decision‬‬ ‫‪30‬‬ ‫ﭘﺎراﻣﺘﺮ ﻫﺎی ﺗﺎﺑﻊ ‪print‬‬ ‫‪20‬‬

‫ﺳﺎﺧﺘﺎر ﺷﺮط ﻫﺎ و ﺗﺼﻤﯿﻢ ﮔﯿﺮی‬ ‫‪31‬‬ ‫‪Escape Sequences‬‬ ‫‪21‬‬

‫ﻋﺒﺎرات ﺷﺮﻃﯽ‬ ‫‪32‬‬ ‫ﻗﺎﻟﺐ ﺑﻨﺪی ﺧﺮوﺟﯽ ‪output formatting‬‬ ‫‪22‬‬

‫ﻋﺒﺎرت ﺷﺮﻃﯽ ‪if‬‬ ‫‪33‬‬ ‫ﻋﻤﻠﮕﺮﻫﺎ ‪operators‬‬ ‫‪23‬‬

‫ﻋﺒﺎرت ﺷﺮﻃﯽ ‪elif‬‬ ‫‪34‬‬ ‫ﻋﻤﻠﮕﺮﻫﺎی ﺣﺴﺎﺑﯽ ‪arithmetic operators‬‬ ‫‪24‬‬

‫ﻋﺒﺎرت ﺷﺮﻃﯽ ‪else‬‬ ‫‪35‬‬ ‫ﻋﻤﻠﮕﺮﻫﺎی ﻣﻘﺎﯾﺴﻪ ای ‪comparison operators‬‬ ‫‪25‬‬

‫ﭘﺮوژه ﻣﺎﺷﯿﻦ ﺣﺴﺎب ﺳﺎده‬ ‫‪36‬‬ ‫ﻋﻤﻠﮕﺮﻫﺎی ﺗﺼﺨﯿﺼﯽ ‪assignment operators‬‬ ‫‪26‬‬
‫ﺗﺸﺨﯿﺺ اﻋﺪاد زوج و ﻓﺮد ﺑﻪ ﮐﻤﮏ ﺣﻠﻘﻪ ‪while‬‬ ‫‪47‬‬ ‫ﻋﻤﻠﮕﺮﻫﺎی ﻣﻨﻄﻘﯽ در ﺷﺮط ﻫﺎ‬ ‫‪37‬‬

‫ﭘﺮوژه ﺗﺸﺨﯿﺺ رﻣﺰ ﻋﺒﻮر ﺑﻪ ﮐﻤﮏ ﺣﻠﻘﻪ ‪while‬‬ ‫‪48‬‬ ‫ﻋﺒﺎرات ﺷﺮﻃﯽ ﮐﻮﺗﺎه ‪Short condition statements‬‬ ‫‪38‬‬

‫ﺣﻠﻘﻪ ﺗﮑﺮار ﻣﻌﯿﯿﻦ ‪for‬‬ ‫‪49‬‬ ‫ﻋﺒﺎرات ﺷﺮﻃﯽ ﺗﻮ در ﺗﻮ ‪Nested if‬‬ ‫‪39‬‬

‫ﺗﺎﺑﻊ ‪ range‬در ﺣﻠﻘﻪ ‪for‬‬ ‫‪50‬‬ ‫اﺳﺘﻔﺎده از ﻋﺒﺎرات ﺷﺮﻃﯽ ﺗﻮ در ﺗﻮ در ﻣﺎﺷﯿﻦ ﺣﺴﺎب‬ ‫‪40‬‬

‫ﻋﺒﺎرت ﺷﺮﻃﯽ ‪ else‬در ﺣﻠﻘﻪ ‪for‬‬ ‫‪51‬‬ ‫ﭘﺮوژه ﺑﺮرﺳﯽ دﻣﺎی ﻫﻮا ﺑﻪ ﮐﻤﮏ ﻋﺒﺎرات ﺷﺮﻃﯽ‬ ‫‪41‬‬

‫ﻋﺒﺎرت ﻫﺎی ﮐﻨﺘﺮﻟﯽ‬ ‫‪52‬‬ ‫ﺣﻠﻘﻪ ﻫﺎ ‪Loops‬‬ ‫‪42‬‬

‫ﻋﺒﺎرت ﮐﻨﺘﺮﻟﯽ ‪break‬‬ ‫‪53‬‬ ‫ﺣﻠﻘﻪ ﺗﮑﺮار ﻧﺎﻣﻌﯿﯿﻦ ‪while‬‬ ‫‪43‬‬

‫ﻋﺒﺎرت ﮐﻨﺘﺮﻟﯽ ‪pass‬‬ ‫‪54‬‬ ‫ﺣﻠﻘﻪ ‪ while‬ﺗﮏ ﺧﻄﯽ‬ ‫‪44‬‬

‫ﻋﺒﺎرت ﮐﻨﺘﺮﻟﯽ ‪continue‬‬ ‫‪55‬‬ ‫ﻋﺒﺎرت ﺷﺮﻃﯽ ‪ else‬در ﺣﻠﻘﻪ ‪while‬‬ ‫‪45‬‬

‫ﺣﻠﻘﻪ ﻫﺎی ﺗﻮ در ﺗﻮ ‪Nested loops‬‬ ‫‪56‬‬ ‫اداﻣﻪ ﭘﺮوژه ﺑﺮرﺳﯽ دﻣﺎ ﺑﻪ ﮐﻤﮏ ﺣﻠﻘﻪ ‪while‬‬ ‫‪46‬‬
‫ﻣﺘﺪ ﻫﺎی ﺣﺬف ﮐﺮدن آﯾﺘﻢ ﻫﺎ در ﻟﯿﺴﺖ‬ ‫‪67‬‬ ‫ﺟﺪول ﺿﺮب ﺑﻪ ﮐﻤﮏ ﺣﻠﻘﻪ ﻫﺎی ﺗﻮ در ﺗﻮ‬ ‫‪57‬‬

‫ﻣﺘﺪ ﻫﺎی ﻣﺮﺗﺐ ﺳﺎزی ﻟﯿﺴﺖ‬ ‫‪68‬‬ ‫رﺷﺘﻪ ﻫﺎ )‪ (Strings‬ﺑﺨﺶ ‪ ۲‬ﺗﮑﻤﯿﻠﯽ‬ ‫‪58‬‬

‫ﻣﺘﺪ ﮐﭙﯽ ﮐﺮدن ﻟﯿﺴﺖ‬ ‫‪69‬‬ ‫ﻣﺘﺪﻫﺎ ‪Methods‬‬ ‫‪59‬‬

‫اﻟﺤﺎق ﻟﯿﺴﺖ ﻫﺎ‬ ‫‪70‬‬ ‫ﻣﺘﺪ ﻫﺎی رﺷﺘﻪ‬ ‫‪60‬‬

‫ﻣﺘﺪ ﻫﺎی ﻟﯿﺴﺖ‬ ‫‪71‬‬ ‫ﻣﺮور اﻧﻮاع داده‬ ‫‪61‬‬

‫ﺗﺎﭘﻞ ﻫﺎ ‪Tuples‬‬ ‫‪72‬‬ ‫ﻟﯿﺴﺖ ﻫﺎ ‪Lists‬‬ ‫‪62‬‬

‫دﺳﺘﺮﺳﯽ ﺑﻪ آﯾﺘﻢ ﻫﺎی ﺗﺎﭘﻞ‬ ‫‪73‬‬ ‫ﺗﻐﯿﯿﺮ آﯾﺘﻢ ﻫﺎی ﻟﯿﺴﺖ‬ ‫‪63‬‬

‫ﺑﺮوزرﺳﺎﻧﯽ ﺗﺎﭘﻞ‬ ‫‪74‬‬ ‫ﻣﺘﺪ ﻫﺎی اﺿﺎﻓﻪ ﮐﺮدن آﯾﺘﻢ ﺑﻪ ﻟﯿﺴﺖ‬ ‫‪64‬‬

‫‪Packing & Unpacking Tuple‬‬ ‫‪75‬‬ ‫ﭘﺮوژه ذﺧﯿﺮه ﻣﺨﺎﻃﺐ در ﻟﯿﺴﺖ‬ ‫‪65‬‬

‫ﺣﻠﻘﻪ زدن در ﺗﺎﭘﻞ ﻫﺎ‬ ‫‪76‬‬ ‫ﺣﻠﻘﻪ زدن در ﻟﯿﺴﺖ ﻫﺎ‬ ‫‪66‬‬
‫دﺳﺘﺮﺳﯽ ﺑﻪ آﯾﺘﻢ ﻫﺎی دﯾﮑﺸﻨﺮی‬ ‫‪87‬‬ ‫اﻟﺤﺎق ﺗﺎﭘﻞ ﻫﺎ ‪join‬‬ ‫‪77‬‬

‫ﺗﻐﯿﯿﺮ آﯾﺘﻢ ﻫﺎی دﯾﮑﺸﻨﺮی‬ ‫‪88‬‬ ‫ﻣﺘﺪ ﻫﺎی ﺗﺎﭘﻞ‬ ‫‪78‬‬

‫اﺿﺎﻓﻪ ﮐﺮدن آﯾﺘﻢ ﺑﻪ دﯾﮑﺸﻨﺮی‬ ‫‪89‬‬ ‫ﺳﺖ ﻫﺎ ‪Set‬‬ ‫‪79‬‬

‫ﺣﺬف آﯾﺘﻢ از دﯾﮑﺸﻨﺮی‬ ‫‪90‬‬ ‫اﯾﺠﺎد ﺳﺖ‬ ‫‪80‬‬

‫ﺣﻠﻘﻪ زدن در دﯾﮑﺸﻨﺮی ﻫﺎ‬ ‫‪91‬‬ ‫دﺳﺘﺮﺳﯽ ﺑﻪ آﯾﺘﻢ ﻫﺎی ﺳﺖ‬ ‫‪81‬‬

‫ﮐﭙﯽ ﮐﺮدن دﯾﮑﺸﻨﺮی ﻫﺎ‬ ‫‪92‬‬ ‫اﺿﺎﻓﻪ ﮐﺮدن آﯾﺘﻢ ﺑﻪ ﺳﺖ‬ ‫‪82‬‬

‫دﯾﮑﺸﻨﺮی ﻫﺎی ﺗﻮ در ﺗﻮ‬ ‫‪93‬‬ ‫ﺣﺬف ﮐﺮدن آﯾﺘﻢ از ﺳﺖ‬ ‫‪83‬‬

‫ﻣﺘﺪ ﻫﺎی دﯾﮑﺸﻨﺮی‬ ‫‪94‬‬ ‫اﻟﺤﺎق ﺳﺖ ﻫﺎ ﻫﺎ‬ ‫‪84‬‬

‫ﺗﻮاﺑﻊ ‪Functions‬‬ ‫‪95‬‬ ‫ﻣﺘﺪ ﻫﺎی ﺳﺖ‬ ‫‪85‬‬

‫ﺳﺎﺧﺖ ﺗﺎﺑﻊ و ﺳﺎﺧﺘﺎر آن‬ ‫‪96‬‬ ‫دﯾﮑﺸﻨﺮی ﻫﺎ ‪Dictionary‬‬ ‫‪86‬‬

 ‫اﺳﮑﻮپ ‪scope‬‬ ‫‪107‬‬ ‫ﺻﺪا زدن ﺗﻮاﺑﻊ‬ ‫‪97‬‬

‫ﻣﺎژول ‪Module‬‬ ‫‪108‬‬ ‫آرﮔﻮﻣﺎن ﻫﺎ در ﺗﺎﺑﻊ ‪Arguments‬‬ ‫‪98‬‬

‫دﻟﯿﻞ اﺳﺘﻔﺎده از ﻣﺎژول و ﻧﺤﻮه ﺳﺎﺧﺖ‬ ‫‪109‬‬ ‫آرﮔﻮﻣﺎن ﻫﺎ و ﭘﺎراﻣﺘﺮ‬ ‫‪99‬‬

‫ﻧﺎم ﮔﺬاری دﻟﺨﻮاه ﻣﺎژول ﻫﺎ ‪Re-Naming‬‬ ‫‪110‬‬ ‫ﻧﺎ ﻣﺸﺨﺺ ﮐﺮدن ﺗﻌﺪاد آرﮔﻮﻣﺎن ﻫﺎی ﺗﺎﺑﻊ‬ ‫‪100‬‬

‫‪from & import‬‬ ‫‪111‬‬ ‫‪Keyword Arguments‬‬ ‫‪101‬‬

‫ﻣﺎژول ﻫﺎی ﭘﯿﺶ ﺳﺎﺧﺘﻪ ‪Built-in modules‬‬ ‫‪112‬‬ ‫ﭘﺎراﻣﺘﺮ ﻫﺎی ﭘﯿﺸﻔﺮض‬ ‫‪102‬‬

‫ﺑﺮرﺳﯽ ﻣﺎژول ﻫﺎی ﭘﯿﺶ ﺳﺎﺧﺘﻪ‬ ‫‪113‬‬ ‫اﻧﻮاع داده در ﺑﻪ ﻋﻨﻮان آرﮔﻮﻣﺎن‬ ‫‪103‬‬

‫ﻣﺎژول ‪random‬‬ ‫‪114‬‬ ‫ﺗﺎﺑﻊ ﻣﺤﺎﺳﺒﻪ ﻣﺴﺎﺣﺖ داﯾﺮه‬ ‫‪104‬‬

‫ﭘﺮوژه ﺑﺎزی ﺣﺪس ﺗﺎس‬ ‫‪115‬‬ ‫ﻣﻘﺎدﯾﺮ ﺑﺎزﮔﺸﺘﯽ )‪ (Return values‬در ﺗﺎﺑﻊ‬ ‫‪105‬‬

‫ﭘﺮوژه ﺑﺮﻧﺎﻣﻪ رﻣﺰ ﺳﺎز‬ ‫‪116‬‬ ‫ﻻﻣﺒﺪا ‪Lambda‬‬ ‫‪106‬‬

 ‫ﮐﺎر ﺑﺎ ﻓﺎﯾﻞ ﻫﺎ ‪PYTHON I/O‬‬ ‫‪127‬‬ ‫ﻣﺎژول ‪math‬‬ ‫‪117‬‬

‫ﺑﺎز ﮐﺮدن ﻓﺎﯾﻞ ‪txt‬‬ ‫‪128‬‬ ‫ﻣﺎژول ‪platform‬‬ ‫‪118‬‬

‫ﺣﺎﻟﺖ ﻫﺎی ﺑﺎز ﮐﺮدن ﻓﺎﯾﻞ‬ ‫‪129‬‬ ‫ﺑﺮرﺳﯽ ﺟﺰﺋﯽ ﻣﺎژول ‪tkinter‬‬ ‫‪119‬‬

‫ﺑﺴﺘﻦ ﻓﺎﯾﻞ – ﻋﺒﺎرت ‪with & open‬‬ ‫‪130‬‬ ‫ﻣﺪﯾﺮﯾﺖ ﺑﺴﺘﻪ ﭘﺎﯾﺘﻮن ‪pip‬‬ ‫‪120‬‬

‫ﺧﻮاﻧﺪن ﯾﮏ ﻓﺎﯾﻞ‬ ‫‪131‬‬ ‫ﻧﺼﺐ ﭘﮑﯿﺞ‪/‬ﺑﺴﺘﻪ ﺑﻪ ﮐﻤﮏ ‪pip‬‬ ‫‪121‬‬

‫ﻧﻮﺷﺘﻦ )ﺗﻐﯿﯿﺮ ﻣﺤﺘﻮا( در ﯾﮏ ﻓﺎﯾﻞ‬ ‫‪132‬‬ ‫اﺳﺘﻔﺎده از ﺑﺴﺘﻪ ﻧﺼﺐ ﺷﺪه ‪deep-translator‬‬ ‫‪122‬‬

‫ﭘﺮوژه ذﺧﯿﺮه ﻣﺨﺎﻃﺐ در ﻓﺎﯾﻞ ‪txt‬‬ ‫‪133‬‬ ‫ﺗﺮﮐﯿﺐ ﭼﻨﺪ ﺑﺴﺘﻪ و ﻣﺎژول – ﺑﺮﻧﺎﻣﻪ ﻣﺘﺮﺟﻢ‬ ‫‪123‬‬

‫‪134‬‬ ‫ﻣﺪﯾﺮﯾﺖ اﺳﺘﺜﻨﺎء ‪exception‬‬ ‫‪124‬‬

‫‪135‬‬ ‫ﻋﺒﺎرت ‪ try & except‬در ﻣﺪﯾﺮﯾﺖ اﺳﺘﺜﻨﺎء‬ ‫‪125‬‬

‫‪136‬‬ ‫ﻋﺒﺎرت ‪ finally & raise‬در ﻣﺪﯾﺮﯾﺖ اﺳﺘﺜﻨﺎء‬ ‫‪126‬‬

 ‫ﺑﺮﻧﺎﻣﻪ )‪ (PROGRAM‬ﭼﯿﺴﺖ؟‬

‫• ﻣﺠﻤﻮﻋﻪای از دﺳﺘﻮراﻟﻌﻤﻞ ﻫﺎ ﯾﺎ اﻟﮕﻮرﯾﺘﻢ )‪ (Algorithms‬اﺳﺖ ﮐﻪ راﯾﺎﻧﻪ )دﺳﮑﺘﺎپ و ﻣﻮﺑﺎﯾﻞ و‪ (...‬ﺑﺮای اﻧﺠﺎم‬

‫ﯾﮏ ﮐﺎر ﻣﺸﺨ ّﺺ آن را اﺟﺮا ﻣﯽﮐﻨﺪ‪ .‬ﺧﻮد راﯾﺎﻧﻪ ﺑﺮای اﻧﺠﺎم ﮐﺎرﻫﺎﯾﺶ ﺑﻪ ﺑﺮﻧﺎﻣﻪﻫﺎ ﻧﯿﺎز دارد و ﻣﻌﻤﻮﻻ ً ﻫﺮ ﺑﺮﻧﺎﻣﻪ را‬
‫در ﯾﮏ واﺣﺪ ﭘﺮدازش ﻣﺮﮐﺰی )‪ (CPU‬اﺟﺮا ﻣﯽﮐﻨﺪ‪.‬‬

‫• ﻣﻌﻤﻮﻻ ً ﺑﺮﻧﺎﻣﻪﻫﺎی راﯾﺎﻧﻪای ﺗﻮﺳﻂ ﯾﮏ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺲ )‪ (Programmer‬و ﺗﺤﺖ ﯾﮏ ﯾﺎ ﭼﻨﺪ زﺑﺎن ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ‬
‫ﻧﻮﺷﺘﻪ ﻣﯽﺷﻮﻧﺪ‪.‬‬

‫ﺑﻪ ﻣﺠﻤﻮﻋﻪای از ﺑﺮﻧﺎﻣﻪﻫﺎ‪ ،‬ﻣﺎژول )‪ / (Module‬ﭘﮑﯿﺞ )‪ (Package‬و ﭼﻬﺎرﭼﻮب ﻫﺎ )‪ (Framework‬و داده ﻫﺎی‬ ‫•‬
‫)‪ (Data‬ﻣﺮﺗﺒﻂ ﺑﺎ آنﻫﺎ ﻧﺮم اﻓﺰار )‪ (Software‬ﻣﯽﮔﻮﯾﻨﺪ‬
 ‫ﻣﻌﺮﻓﯽ ﺑﺮﺧﯽ از زﺑﺎن ﻫﺎی ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ‬

‫وﯾﮋﮔﯽ ﻫﺎ‬ ‫ﺣﻮزه ﮐﺎرﺑﺮدی‬ ‫ﻧ ﺎم‬ ‫ﻧﻤ ﺎد‬

‫ﻣﺘﻦ ﺑﺎز )‪ – (open source‬ﭼﻨﺪ ﺳﮑﻮﯾﯽ‬ ‫ﺗﻮﺳﻌﻪ ﻧﺮم اﻓﺮار ﻫﺎی ﺗﺤﺖ دﺳﮑﺘﺎپ ‪ -‬ﻫﻮش‬
‫)‪ – (Cross-Platform‬ﺷﺊ ﮔﺮا )‪–(O.O‬‬
‫ﺗﻔﺴﯿﺮی )‪ – (Interpret‬ﺳﻄﺢ ﺑﺎﻻ ‪ -‬ﺳﺎﺧﺘﻤﺎن‬ ‫ﻣﺼﻨﻮﻋﯽ – رﯾﺎﺿﯿﺎت و آﻣﺎر – ﺗﺤﻠﯿﻞ داده –‬ ‫‪Python‬‬
‫داده ﭘﻮﯾﺎ )‪(Dynamic D.S‬‬ ‫ﺗﻮﺳﻌﻪ وب و ﻋﻠﻮم ﭘﺰﺷﮑﯽ و‪...‬‬

‫ﺗﻮﺳﻌﻪ ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ – ﺗﻮﺳﻌﻪ دﺳﮑﺘﺎپ – ﭘﮑﯿﺞ‬

‫ﺗﺎﺑﻌﯽ )‪ – (Functional‬ﺳﻄﺢ ﻣﯿﺎﻧﯽ ‪-‬‬
‫ﮐﺎﻣﭙﺎﯾﻠﺮی )‪(Compile‬‬
‫ﺳﺎزی ﭘﺎﯾﻪ و ﻣﺎدر ﺑﺮای ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ ﻫﺎ – ﺑﺮﻧﺎﻣﻪ‬ ‫‪C‬‬
‫ﻧﻮﯾﺴﯽ ﺳﺨﺖ اﻓﺰار‬

‫ﻣﺘﻦ ﺑﺎز )‪ – (open source‬ﭼﻨﺪ ﺳﮑﻮﯾﯽ‬

‫)‪ – (Cross-Platform‬ﺷﺊ ﮔﺮا )‪ – (O.O‬ﺳﻄﺢ‬ ‫ﺗﻮﺳﻌﻪ وب – ﺗﻮﺳﻌﻪ ﻣﻮﺑﺎﯾﻞ – اﻓﺰوﻧﻪ ﻫﺎی ﻣﺮورﮔﺮ‬ ‫‪JS‬‬
‫ﺑﺎﻻ – ﺗﻔﺴﯿﺮی‬

‫ﻣﺘﻦ ﺑﺎز )‪ – (open source‬ﭼﻨﺪ ﺳﮑﻮﯾﯽ‬

‫)‪ – (Cross-Platform‬ﺷﺊ ﮔﺮا )‪- –(O.O‬‬ ‫ﺗﻮﺳﻌﻪ ﻣﻮﺑﺎﯾﻞ – ﺗﻮﺳﻌﻪ وب‬ ‫‪Dart‬‬
‫ﺳﺎﺧﺘﻤﺎن داده ﭘﻮﯾﺎ )‪(Dynamic D.S‬‬

‫دوﺳﺖ ﻋﺰﯾﺰم ﻋﺒﺎرت ﻫﺎی ﺗﺨﺼﺼﯽ اﺷﺎره ﺷﺪه ﺻﺮﻓﺎ ﺟﻬﺖ آﺷﻨﺎﯾﯽ و ﻓﺎل ﮐﺮدن ﺣﺲ ﮐﻨﺠﮑﺎوی ﺷﻤﺎ اﺳﺖ‪ .‬ﺑﻨﺎﺑﺮﯾﻦ اﺻﻼ ﻧﮕﺮان ﻧﺒﺎﺷﯿﺪ ﭼﻮن ﺑﻪ زودی آﺷﻨﺎ ﻣﯿﺸﻮﯾﺪ‬
 ‫ﻣﻌﺮﻓﯽ ﻣﺨﺘﺼﺮ زﺑﺎن ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ‪PYTHON‬‬

‫• در ﺳﺎل ‪ ۱۹۸۹‬ﺗﻮﺳﻂ آﻗﺎی ‪ Guido van Rossum‬ﺷﺮوع ﺑﻪ ﻃﺮاﺣﯽ و در ﺳﺎل ‪ ۱۹۹۱‬ﻣﻨﺘﺸﺮ ﺷﺪ‪.‬‬

‫• ﺳﻄﺢ ﺑﺎﻻ اﺳﺖ‪ .‬ﺑﻨﺎﺑﺮﯾﻦ ﺗﻮﺳﻌﻪ و ﺧﻮاﻧﺎﯾﯽ و درک آن آﺳﺎن اﺳﺖ‪.‬‬

‫• ﮐﺪ ﻫﺎی آن ﺑﻪ ﺻﻮرت ﺗﻔﺴﯿﺮی )‪ (Interpreting‬اﺟﺮا ﻣﯿﺸﻮد‪.‬‬

‫• دارای ﻣﺎژول ﻫﺎ و ﭼﺎرﭼﻮب ﻫﺎی ﮔﺴﺘﺮده و ﻣﺘﻨﻮع ﺑﺮای ﺣﻮزه ﻫﺎی ﻣﺨﺘﻠﻒ‪.‬‬

‫• ﭘﺴﻮﻧﺪ ﻫﺎی آن ‪py – pyc – pyo - pyd‬‬

‫• آﺧﺮﯾﻦ ﻧﺴﺨﻪ ﻣﻨﺘﺸﺮ ﺷﺪه آن ﺗﺎ اﯾﻦ ﻟﺤﻈﻪ ‪ 3.10‬اﺳﺖ‪ ۱۴) .‬ژاﻧﻮﯾﻪ ‪(۲۰۲۲‬‬

‫• ﺑﮑﺎر ﮔﺮﻓﺘﻪ ﺷﺪه در ‪:‬‬

 ‫ﺑﺮﻧﺎﻣﻪ را ﮐﺠﺎ ﻣﯿﻨﻮﯾﺴﻢ؟ آﺷﻨﺎﯾﯽ ﺑﺎ ‪ IDE‬ﻫﺎ‬

‫• ﺑﺎ ﻣﻔﻬﻮم ﺑﺮﻧﺎﻣﻪ و ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ آﺷﻨﺎ ﺷﺪﯾﻢ‪ .‬ﺣﺎل ﮐﺠﺎ ﺑﺎﯾﺪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﮐﻨﯿﻢ و ﺑﺮﻧﺎﻣﻪ ﺧﻮد را ﺑﺴﺎزﯾﻢ؟‬

‫• ﺑﺮای ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﻧﯿﺎز ﺑﻪ ﻧﺮم اﻓﺰار ﻫﺎی ﻣﺤﯿﻂ ﺗﻮﺳﻌﻪ ﯾﮑﭙﺎرﭼﻪ ﯾﺎ ﺑﻪ اﺧﺘﺼﺎر ‪IDE (integrated development‬‬

‫)‪ environment‬ﯾﺎ وﯾﺮاﯾﺶ ﮐﻨﻨﺪه ﮐ ٌﺪ ‪ Code Editor‬دارﯾﻢ‪.‬‬

‫• ﺗﻔﺎوت ‪ IDE‬و ‪ Code Editor‬ﭼﯿﺴﺖ؟ ‪ IDE‬ﻫﺎ ﻣﺤﯿﻂ ﻫﺎی ﺗﻮﺳﻌﻪ ﮐﺎﻣﻠﯽ ﻫﺴﺘﻨﺪ ﺟﺪای از اﻣﮑﺎن ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ‬

‫ﻣﺠﻤﻮﻋﻪ ای از اﺑﺰار ﻫﺎی ﻣﻔﯿﺪ ﺑﺮای ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﺎن را در اﺧﺘﯿﺎرﻣﺎن ﻗﺮار ﻣﯿﺪﻫﺪ و درون اﯾﻦ ﻣﺤﯿﻂ ﻣﺴﺘﻘﯿﻢ‬

‫ﺑﺮﻧﺎﻣﻪ ﻣﺎ اﺟﺮا ﻣﯿﺸﻮد ‪ .‬اﻣﺎ وﯾﺮاﯾﺸﮕﺮ ﻫﺎی ﮐ ٌﺪ ﻣﺎ ﻓﻘﻂ اﻣﮑﺎن ﻧﻮﺷﺘﻦ ﮐﺪ ﻫﺎی ﺑﺮﻧﺎﻣﻪ را ﻣﯿﺪﻫﺪ و ﺑﺮای اﺟﺮا ﻧﯿﺎز ﺑﻪ‬

‫اﺑﺰار ﻫﺎی ﺟﺎﻧﺒﯽ دارﯾﻢ‪ .‬ﻗﺎﻋﺪﺗﺎ ً وﯾﺮاﯾﺸﮕﺮ ﻫﺎی ﮐﺪ ﺑﺴﯿﺎر ﺳﺒﮑﺘﺮ ﻫﺴﺘﻨﺪ‪.‬‬
 ‫ﻣﻌﺮﻓﯽ ﺑﺮﺧﯽ ‪ IDE‬و ‪ CODE EDITOR‬ﻫﺎ‬

‫وﯾﮋﮔﯽ ﻫﺎ‬ ‫ﻧ ﺎم‬ ‫ﻧﻤ ﺎد‬

‫راﯾﮕﺎن ‪ -‬اراﺋﻪ ﺷﺪه ﺗﻮﺳﻂ ﺟﺎﻣﻌﻪ ﺗﻮﺳﻌﻪ دﻫﻨﺪﮔﺎن ﭘﺎﯾﺘﻮن – ﺻﺮﻓﺎ‬

‫ﭘﺸﺘﯿﺒﺎﻧﯽ از زﺑﺎن ﭘﺎﯾﺘﻮن – ﺑﺴﯿﺎر ﺳﺒﮏ – ﻋﺪم ﻫﻮﺷﻤﻨﺪی ﮐﺎﻓﯽ در‬ ‫‪Python IDLE‬‬
‫ﺗﮑﻤﯿﻞ ﮐﺪ‬

‫ﻏﯿﺮ راﯾﮕﺎن – ﭘﺸﺘﯿﺒﺎﻧﯽ از ‪ - python , html , css , js‬ﻫﻮش ﻗﻮی در‬

‫‪PyCharm‬‬
‫ﺗﮑﻤﯿﻞ ﮐﺪ ﻫﺎ‬

‫ﻏﯿﺮ راﯾﮕﺎن – ﭘﺸﺘﯿﺒﺎﻧﯽ از زﺑﺎن ﻫﺎی ﻣﺘﻌﺪد – ﺑﺴﯿﺎر ﺳﺒﮏ‬ ‫‪Sublime Text‬‬

‫راﯾﮕﺎن – ﺑﺴﯿﺎر ﺳﺒﮏ – ﻗﺎﺑﻠﯿﺖ ﭘﺸﺘﯿﺒﺎﻧﯽ از ﺣﺪود ‪ ۵۰‬زﺑﺎن ﺑﺮﻧﺎﻣﻪ‬

‫‪VS CODE‬‬
‫ﻧﻮﯾﺴﯽ – دارای اﻓﺰوﻧﻪ ﻫﺎی ﻣﺘﻌﺪد – ﺗﺮﻣﯿﻨﺎل ﻗﻮی و‪...‬‬

‫راﯾﮕﺎن ‪ -‬ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﭘﺎﯾﺘﻮن در ﻣﻮﺑﺎﯾﻞ ﻫﺎی ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ اﻧﺪروﯾﺪ‬ ‫‪PyDroid‬‬
 ‫ﻧﺼﺐ ‪PYTHON‬‬

‫• ﺟﻬﺖ ﻧﻮﺷﺘﻦ ﺑﺮﻧﺎﻣﻪ ﺑﻪ زﺑﺎن ﭘﺎﯾﺘﻮن ﻧﯿﺎز ﺑﻪ ﻧﺼﺐ آن و ﻫﻤﭽﻨﯿﻦ ﻧﺼﺐ ﯾﮑﯽ از ‪ IDE‬ﻫﺎی ﻣﻌﺮﻓﯽ ﺷﺪه دارﯾﻢ‪.‬‬

‫• ﺑﺮای ﻧﺼﺐ ﻣﻄﻤﺌﻦ ﺑﻬﺘﺮ اﺳﺖ ﭘﺎﯾﺘﻮن را از ﺳﺎﯾﺖ رﺳﻤﯽ آن ﺑﻪ آدرس ‪ python.org‬ﻣﺮاﺟﻌﻪ ﮐﺮده و از آﻧﺠﺎ اﻗﺪام ﺑﻪ داﻧﻠﻮد و‬

‫ﻧﺼﺐ ﮐﻨﯿﻢ‪.‬‬

‫• در ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ ﻟﯿﻨﻮﮐﺲ )‪ (Linux‬و ﻣﮑﯿﻨﺘﺎش )‪ (Mac os‬ﭘﺎﯾﺘﻮن ﺑﻪ ﻃﻮر ﭘﯿﺸﻔﺮض ﻧﺼﺐ اﺳﺖ ‪.‬‬

‫• ﺟﻬﺖ اﻃﻤﯿﻨﺎن از ﻧﺼﺐ ﺑﻮدن ﻣﯿﺒﺎﯾﺴﺖ در ﯾﮑﯽ از ﻣﺤﯿﻂ ﻫﺎی ‪ CMD/Terminal‬ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻧﻮع ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ دﺳﺘﻮر‬

‫‪ python‬ﯾﺎ ‪ python3‬وارد ﮐﻨﯿﻢ‪ .‬ﺧﺮوﺟﯽ ﻣﯿﺒﺎﯾﺴﺖ در ﺗﻤﺎم ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ ﻫﺎ ﻣﻄﺎﺑﻖ‪/‬ﻣﺸﺎﺑﻪ ﺗﺼﻮﯾﺮ زﯾﺮ ﺑﺎﺷﺪ‪:‬‬
 ‫‪PYTHON IDLE‬‬

‫ﭘﺲ از ﻧﺼﺐ ﭘﺎﯾﺘﻮن از ﻣﺮﺟﻊ رﺳﻤﯽ در واﻗﻊ دو ﻧﺮم اﻓﺰار ‪ IDLE‬و ‪ Python Launcher‬در ﮐﺎﻣﭙﯿﻮﺗﺮ ﻣﺎ ﻧﺼﺐ ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫ﻫﻤﭽﻨﯿﻦ ﺑﻪ ﻃﻮر ﺧﻮدﮐﺎر در رﯾﺸﻪ )‪ (root‬ﻧﯿﺰ ﻧﺼﺐ ﻣﯿﺸﻮد و از ﻃﺮﯾﻖ ﻣﺤﯿﻂ ﻫﺎی ‪ CMD/Terminal‬ﺑﺎ دﺳﺘﻮر ‪ python/python3‬در دﺳﺘﺮس ﻗﺮار ﺧﻮاﻫﺪ‬ ‫•‬

‫ﮔﺮﻓﺖ‪.‬‬

‫ﺗﻔﺎوت اﺟﺮای ﭘﺎﯾﺘﻮن از ﻃﺮﯾﻖ ‪ CMD/Terminal‬ﺑﺎ ‪ IDLE‬ﯾﺎ ﺑﻘﯿﻪ ﻣﺤﯿﻂ ﻫﺎی ﺗﻮﺳﻌﻪ در ﭼﯿﺴﺖ؟‬ ‫•‬

‫ﺑﻪ ﻃﻮر ﺧﯿﻠﯽ ﺳﺎده و ﺧﻼﺻﻪ ﺗﻔﺎوت در ذﺧﯿﺮه ﺷﺪن ﮐ ٌﺪ ﻫﺎی ﺑﺮﻧﺎﻣﻪ اﺳﺖ‪ .‬اﮔﺮ ﻣﺤﯿﻂ ﻫﺎی ﮐﻨﺴﻮل ‪ CMD/Terminal‬ﮐ ٌﺪﻣﺎن را ﺑﻨﻮﯾﺴﯿﻢ ﻓﻘﻂ در ﻟﺤﻈﻪ و‬ ‫•‬

‫ﻫﻤﺎﻧﺠﺎ ﻣﯿﺘﻮان ﻧﺘﯿﺠﻪ‪/‬ﺧﺮوﺟﯽ ﺧﻮد را ﺑﺒﯿﻨﯿﻢ‪ .‬اﻣﺎ اﮔﺮ در ﻣﺤﯿﻂ ﻫﺎی ﺗﻮﺳﻌﻪ اﯾﻦ ﮐﺎر را اﻧﺠﺎم دﻫﯿﻢ ﻣﯿﺘﻮاﻧﯿﻢ ﭘﺮوژه ﺧﻮد را در ﻗﺎﻟﺐ ﻓﺎﯾﻞ ﻫﺎی ‪ .py‬ذﺧﯿﺮه‬

‫ﮐﻨﯿﻢ و ﻫﺮ زﻣﺎن ﮐﻪ ﻧﯿﺎز داﺷﺘﻪ ﺑﺎﺷﯿﻢ ﺑﻪ آن دﺳﺘﺮﺳﯽ ﭘﯿﺪا ﮐﻨﯿﻢ و وﯾﺮاﯾﺶ اﻧﺠﺎم دﻫﯿﻢ‪.‬‬
 ‫اوﻟﯿﻦ ﺑﺮﻧﺎﻣﻪ‬

‫ﭘﺲ از ﻧﺼﺐ و ﺗﺴﺖ اﺑﺰارﻫﺎی ﻻزم ﺟﻬﺖ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﭘﺎﯾﺘﻮن وﻗﺖ آن اﺳﺖ ﮐﻪ اوﻟﯿﻦ ﺑﺮﻧﺎﻣﻪ ﺧﻮد را ﺑﻨﻮﯾﺴﯿﻢ‪.‬‬ ‫•‬

‫‪ (1‬در ﻣﺤﯿﻂ ‪ CMD/Terminal‬ﭘﺎﯾﺘﻮن را ﻓﺮاﺧﻮاﻧﯽ ﮐﻨﯿﺪ‬

‫‪ (2‬اﯾﻦ دﺳﺘﻮر را ﻣﻄﺎﺑﻖ ﺗﺼﻮﯾﺮ وارد ﮐﻨﯿﺪ ﮐﻨﯿﺪ‪print(”Hello,World!”) :‬‬

‫‪ (3‬ﻧﺘﯿﺠﻪ‪/‬ﺧﺮوﺟﯽ ﺑﺮاﺑﺮ !‪ Hello,World‬اﺳﺖ‪.‬‬

‫‪ (4‬ﻣﺎ ﺑﺎ اﺳﺘﻔﺎده ﺗﺎﺑﻌﯽ )‪ (Function‬ﺑﻪ ﻧﺎم ‪ print‬اﯾﻦ ﮐﺎر را اﻧﺠﺎم دادﯾﻢ!‬

‫‪ (5‬ﺣﺎﻻ ﺳﻌﯽ ﮐﻨﯿﺪ ﻧﺎم ﺧﻮدﺗﺎن را ﻧﻤﺎﯾﺶ دﻫﯿﺪ‪.‬‬

‫‪ (6‬ﻋﺪم رﻋﺎﯾﺖ ﻓﺎﺻﻠﻪ ﻫﺎ و ﭘﺮاﻧﺘﺰ و ﺑﻘﯿﻪ ﻋﻼﻣﺖ ﻫﺎ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﻣﺸﮑﻞ ﻣﯿﺨﻮرد و ﺧﻄﺎی ‪ syntax error‬ﻣﯿﺪﻫﺪ!‬

‫‪ (7‬اﯾﻦ اوﻟﯿﻦ ﺑﺮﻧﺎﻣﻪ ﻣﺎ ﺑﻮد ﮐﻪ ﻫﻤﭽﻨﯿﻦ ﻣﯿﺘﻮاﻧﯿﺪ در ﯾﮑﯽ از ﻣﺤﯿﻂ ﻫﺎی ﺗﻮﺳﻪ آن را ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﺑﺘﻮاﻧﯿﺪ ذﺧﯿﺮه ﮐﻨﯿﺪ و وﯾﺮاﯾﺶ!‬
 ‫ﺗﻌﺮﯾﻒ ﺳﺎده ﺗﺎﺑﻊ )‪(FUNCTION‬‬
‫• ﺟﻬﺖ درک ﻣﻔﻬﻮﻣﯽ ﺗﺎﺑﻊ ﻋﻤﻠﮑﺮد ﯾﮏ ﻣﺎﺷﯿﻦ ﺑﺴﺘﻨﯽ ﺳﺎز را در ﻧﻈﺮ ﺑﮕﯿﺮﯾﺪ‪:‬‬

‫‪ (1‬ﺷﯿﺮ را داﺧﻞ آن ﻣﯿﺮﯾﺰﯾﻢ‪.‬‬

‫‪ (2‬ﯾﮑﺴﺮی ﻋﻤﻠﯿﺎت اﻧﺠﺎم ﻣﯿﺪﻫﺪ‪.‬‬

‫‪input‬‬ ‫‪Function‬‬ ‫‪output‬‬

‫‪ (3‬در ﻧﻬﺎﯾﺖ ﺑﺴﺘﻨﯽ ﺑﻪ ﻣﺎ ﺗﺤﻮﯾﻞ ﻣﯿﺪﻫﺪ!‬
‫ﺷﯿ ﺮ‬ ‫ﺑﺴﺘﻨﯽ‬
‫ﺗﺎﺑﻊ )ﻋﻤﻠﯿﺎت(‬

‫• ‪ print‬ﻧﯿﺰ ﯾﮑﯽ از ﺗﻮاﺑﻌﯽ اﺳﺖ ﮐﻪ در ﺑﺴﯿﺎری از زﺑﺎن ﻫﺎی ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺑﻪ ﻃﻮر ﭘﯿﺸﻔﺮض وﺟﻮد دارد )‪ (Built in Functions‬و‬

‫ﺑﺮای ﻧﻤﺎﯾﺶ ﯾﮏ ﻣﻘﺪار )اﻃﻼﻋﺎت‪ (Data/‬در ﺧﺮوﺟﯽ ﮐﻨﺴﻮل ﮐﺎرﺑﺮد دارد‬

‫)‪FunctionName (Data‬‬ ‫• ﻧﺤﻮه اﺳﺘﻔﺎده از ﺗﺎﺑﻊ در زﺑﺎن ﭘﺎﯾﺘﻮن ﺑﻪ اﯾﻦ ﺷﮑﻞ اﺳﺖ‪:‬‬

‫ﻧﺎم ﺗﺎﺑﻊ‬ ‫ﻣﻘﺪار ورودی‬ ‫• ﺗﺎﺑﻊ ﺧﺮوج ﺑﺮای ﺧﺎرج ﺷﺪن از ﺑﺮﻧﺎﻣﻪ ﻓﻌﻠﯽ ﯾﺎ ﺧﺮوج ﮐﻠﯽ از ﭘﺎﯾﺘﻮن‪exit() :‬‬
‫ﻣﯿﺘﻮاﻧﯿﺪ اﻟﺰاﻣﯽ ﺑﺎﺷﺪ ﯾﺎ ﻧﺒﺎﺷﯿﺪ‬
 ‫‪PYTHON KEYWORDS‬‬

‫ﻫﻤﻪ زﺑﺎن ﻫﺎی ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺷﺎﻣﻞ ﯾﮑﺴﺮی ﮐﻠﻤﺎت ﻫﺴﺘﻨﺪ ﺑﻪ ﻃﻮر وﯾﮋه ﺑﺮای ﻓﻘﻂ ﺑﺮای ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺑﻪ آن زﺑﺎن ﺗﻌﺮﯾﻒ و رزرو ﺷﺪه اﻧﺪ ﮐﻪ دارای‬ ‫•‬

‫وﯾﮋﮔﯽ ﻫﺎی زﯾﺮ ﻣﯿﺒﺎﺷﻨﺪ‪:‬‬

‫ﻧﻤﯿﺘﻮاﻧﻨﺪ ﺑﻪ ﻋﻨﻮان ﻧﺎم ﻣﺘﻐﯿﯿﺮ )‪ (Variable‬اﺳﺘﻔﺎده ﺷﻮﻧﺪ‬ ‫‪(1‬‬

‫ﻧﻤﯿﺘﻮاﻧﻨﺪ ﺑﻪ ﻋﻨﻮان ﻧﺎم ﺗﻮاﺑﻊ )‪ (Function‬اﺳﺘﻔﺎده ﺷﻮﻧﺪ‪.‬‬ ‫‪(2‬‬

‫ﺑﻪ ﻃﻮر ﺧﻼﺻﻪ و ﺳﺎده اﯾﻨﮑﻪ ﻧﻤﯿﺘﻮاﻧﯿﻢ از آﻧﻬﺎ اﺳﺘﻔﺎده ﺷﺨﺼﯽ در ﻧﺎم ﮔﺬاری ﻫﺎ داﺷﺘﻪ ﺑﺎﺷﯿﻢ!‬ ‫‪(3‬‬

‫ﻟﯿﺴﺖ ﺗﻤﺎﻣﯽ ﮐﻠﻤﺎت ﮐﻠﯿﺪی زﺑﺎن ﭘﺎﯾﺘﻮن‬

 ‫‪COMMENT‬‬
‫ﮐﺎﻣﻨﺖ ﮔﺬاری ﻣﻨﺎﺳﺐ ﻧﺸﺎﻧﻪ ﮔﺬاﺷﺘﻦ در ﮐﺪ ﻫﺎی ﺑﺮﻧﺎﻣﻪ اﺳﺖ و ﺑﯿﺸﺘﺮﯾﻦ ﮐﺎرﺑﺮد آن ﺑﺮای درک ﮐﺪ ﻫﺎ در ﺗﻮﺳﻌﻪ ﻫﺎی ﺑﻌﺪی اﺳﺖ‪.‬‬ ‫•‬

‫ﮐﺎﻣﻨﺖ را ﺻﺮﻓﺎ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺲ ﻣﯿﻨﻮﯾﺴﺪ و ﺗﻨﻬﺎ ﺧﻮدش ﺑﻪ آن دﺳﺘﺮﺳﯽ دارد‪.‬‬ ‫•‬

‫ﻣﻔﺴﺮ ﭘﺎﯾﺘﻮن ﮐﺎﻣﻨﺖ ﻫﺎ را ﺑﻪ ﻋﻨﻮان دﺳﺘﻮر ﯾﺎ‪ ...‬در ﻧﻈﺮ ﻧﻤﯿﮕﯿﺮد و اﺟﺮا ﻧﻤﯿﮑﻨﺪ‪.‬‬ ‫•‬

‫ﺑﺮای ﮐﺎﻣﻨﺖ ﮔﺬاﺷﺘﻦ ﺗﮏ ﺧﻄﯽ در ﺑﺮﻧﺎﻣﻪ از ﻋﻼﻣﺖ )‪ Hash sign (#‬اﺳﺘﻔﺎده ﻣﯿﮑﻨﯿﻢ و ﺑﻌﺪ از آن ﭘﯿﺎم‪/‬ﻣﺘﻦ ﺧﻮد را ﻣﯿﻨﻮﯾﺴﻢ‪.‬‬ ‫•‬

‫ﺑﺮای ﮐﺎﻣﻨﺖ ﮔﺬاﺷﺘﻦ ﭼﻨﺪ ﺧﻄﯽ ﺑﻪ ﻗﺒﻞ و ﺑﻌﺪ از ﭘﯿﺎم‪/‬ﻣﺘﻦ ﺧﻮد ‪ ۳‬ﺑﺎر از ﻋﻼﻣﺖ )’( ‪ Quotaion‬اﺳﺘﻔﺎده ﻣﯿﮑﻨﯿﻢ‪.‬‬ ‫•‬

‫‪ ü‬ﺟﻬﺖ درک ﺑﺮﻧﺎﻣﻪ زﯾﺮ را در ﻣﺤﯿﻂ ‪ IDEL‬ﺑﻨﻮﯾﺴﯿﺪ و ذﺧﯿﺮه و اﺟﺮا ﮐﻨﯿﺪ‪:‬‬

‫ﻫﻤﺎﻧﻄﻮر ﮐﻪ ﻣﺸﺎﻫﺪه ﮐﺮدﯾﺪ ﻣﻔﺴﺮ ﭘﺎﯾﺘﻮن ﮐﺎﻣﻨﺖ ﻫﺎ را در ﻧﻈﺮ ﻧﮕﺮﻓﺖ و ﺗﻨﻬﺎ ﺗﺎﺑﻊ ‪ print‬اﺟﺮا ﺷﺪ‬
 ‫‪VARIABLES‬‬ ‫‪Part 1‬‬

‫ﻣﺘﻐﯿﯿﺮ )‪ (Variables‬ﯾﮏ ﻓﻀﺎی ذﺧﯿﺮه ﺳﺎزی ﻣﻮﻗﺖ اﻃﻼﻋﺎت در ﺣﺎﻓﻈﻪ ‪ RAM‬اﺳﺖ‪.‬‬ ‫•‬

‫از آﻧﺠﺎ ﮐﻪ اﻃﻼﻋﺎت ﻣﺘﻐﯿﯿﺮ در ﺣﺎﻓﻈﻪ ‪ RAM‬ذﺧﯿﺮه ﻣﯿﺸﻮد ﺑﺎ ﺑﺴﺘﻪ ﺷﺪن ﯾﺎ ﺧﺎﻣﻮش ﺷﺪن ﺳﯿﺴﺘﻢ اﻃﻼﻋﺎت ﻣﺘﻐﯿﯿﺮ ﻫﺎ ﺣﺬف‬ ‫•‬

‫ﻣ ﯿ ﺸ ﻮد ‪.‬‬

‫ﻣﺘﻐﯿﯿﺮ ﻫﺎ ﻧﻮع )‪ (type‬ﻫﺎی ﻣﺨﺘﻠﻔﯽ دارﻧﺪ و ﻫﺮ ﮐﺪام ﺑﺮای ذﺧﯿﺮه ﺳﺎزی ﯾﮏ ﻧﻮع داده ﮐﺎرﺑﺮد دارد‪.‬‬ ‫•‬

‫ﺑﺮای درک ﺳﺎده اﻧﻮاع ﻣﺘﻐﯿﯿﺮ ﻇﺮف ﻫﺎی ﻏﺬا را در ﻧﻈﺮ ﺑﮕﯿﺮﯾﺪ ﮐﻪ ﻫﺮ ﮐﺪام ﻣﻨﺎﺳﺐ ﻧﻮﻋﯽ از ﻏﺬا ﻫﺴﺘﻨﺪ ﺑﺮای ﻣﺜﺎل‪ :‬دﯾﺲ ﻣﺨﺼﻮص‬ ‫•‬

‫ﺑﺮﻧﺞ اﺳﺖ و ﮐﺎﺳﻪ ﻣﺨﺼﻮص آش و ﻏﺬا ﻫﺎی آﺑﮑﯽ!‬

‫از آﻧﺠﺎ ﮐﻪ زﺑﺎن ﭘﺎﯾﺘﻮن از ﻧﻈﺮ ﺳﺎﺧﺘﻤﺎن داده ﭘﻮﯾﺎ اﺳﺖ ﻣﺎ ﻧﻮع ﻣﺘﻐﯿﯿﺮ ﻫﺎ را ﺑﻪ ﻃﻮر ﭘﯿﺸﻔﺮض ﺗﻌﺮﯾﻒ ﻧﻤﯿﮑﻨﯿﻢ و ﺧﻮد ﻣﻔﺴﺮ ﭘﺎﯾﺘﻮن‬ ‫•‬

‫ﻧﻮع آن را از روی اﻃﻼﻋﺎت ﻣﻮﺟﻮد در آن ﺗﺸﺨﯿﺺ ﻣﯿﺪﻫﺪ ﺑﺮ ﺧﻼف ﺑﺴﯿﺎری از زﺑﺎن ﻫﺎی ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ دﯾﮕﺮ ﮐﻪ ﻣﯿﺒﺎﺳﺖ ﻧﻮع ﻣﺘﻐﯿﯿﺮ‬

‫را ﻧﯿﺰ ﺗﻌﺮﯾﻒ ﮐﻨﯿﻢ!‬

 ‫‪VARIABLES‬‬ ‫‪Part 2‬‬ ‫‪Data Types‬‬
‫ﻣﻘﺪار ﺑﻌﺪ از ﻋﻼﻣﺖ ﻣﺴﺎوی ﺑﻪ ﻣﺘﻐﯿﯿﺮ اﺧﺘﺼﺎص داده ﻣﯿﺸﻮد‬

‫ﺑﺮای ﺗﻌﺮﯾﻒ ﻣﺘﻐﯿﯿﺮ ﺑﻪ ﺷﮑﻞ ﻣﻘﺎﺑﻞ ﻋﻤﻞ ﻣﯿﮑﻨﯿﻢ‪:‬‬ ‫•‬

‫‪VarName = DATA‬‬

‫ﻣﻘﺪار ﻣﺘﻐﯿﯿﺮ ﻧﺎم ﻣﺘﻐﯿﯿﺮ‬

‫ﺗﺼﻮﯾﺮ زﯾﺮ ﻣﺮﺑﻮط ﺑﻪ ﺗﻤﺎﻣﯽ اﻧﻮاع داده )‪ (Data Types‬در زﺑﺎن ﭘﺎﯾﺘﻮن اﺳﺖ‪:‬‬ ‫•‬

‫ﻧ ﻮ ع د اد ه ﻋ ﺪد ی‬ ‫ﻧﻮع داده ﻣﻨﻄﻘﯽ‬

‫اﻋﺪاد ﺻﺤﯿﺢ‬ ‫اﻋﺸﺎر‬ ‫ﻣﺨﺘﻠﻂ‬ ‫رﺷﺘﻪ ﻣﺘﻦ‬

 ‫‪VARIABLES‬‬ ‫‪Part 3‬‬ ‫‪Numeric types‬‬

‫• ﭼﻨﺪ ﻣﺜﺎل ﺳﺎده ﺑﺮای ﺗﻌﺮﯾﻒ و درک ﻣﺘﻐﯿﯿﺮ‪:‬‬

‫• در ﮐﺪ زﯾﺮ ﺳﻪ ﻣﺘﻐﯿﯿﺮ ﺑﺎ ﻧﺎم ﻫﺎی ‪ x,y,z‬ﺗﻌﺮﯾﻒ ﮐﺮدﯾﻢ و آن ﻫﺎ را ﻣﻘﺪار دﻫﯽ ﮐﺮدﯾﻢ‪.‬‬

‫• ﻧﺎم ﻣﺘﻐﯿﯿﺮ را ﻣﯿﺘﻮان ﺑﻪ ﻋﻨﻮان ورودی ﺗﺎﺑﻊ ‪ print‬در ﻧﻈﺮ ﮔﺮﻓﺖ ﺗﺎ آن را ﭼﺎپ‪/‬ﻧﻤﺎﯾﺶ دﻫﺪ‬

‫• ﺗﻤﺎﻣﯽ ﻣﺘﻐﯿﯿﺮ ﻫﺎ از ﻧﻮع ‪ Numeric‬ﻫﺴﺘﻨﺪ‪.‬‬

 ‫‪VARIABLES‬‬ ‫‪Part 4‬‬ ‫‪Multiple Assignment‬‬

‫• در ﯾﮏ ﺧﻂ ﻧﯿﺰ ﻣﯿﺘﻮان ﭼﻨﺪ ﻣﺘﻐﯿﯿﺮ ﺗﻌﺮﯾﻒ ﮐﺮد و آن ﻫﺎ را ﻣﻘﺪار دﻫﯽ ﮐﺮد‪.‬‬

‫• ﻫﻤﭽﻨﯿﻦ ﻣﯿﺘﻮاﻧﯿﻢ ﺧﻮد ﻣﺘﻐﯿﯿﺮ ﻫﺎ را ﺑﻪ ﯾﮑﺪﯾﮕﺮ اﺧﺘﺼﺎص دﻫﯿﻢ‪.‬‬

‫ﻫﻤﭽﻨﯿﻦ ﻣﯿﺘﻮان ﺑﻪ ﺗﺎﺑﻊ ‪ print‬ﭼﻨﺪ آرﮔﻮﻣﺎن )ورودی از ﻧﻮع ﻣﻘﺪار( داد ﮐﻪ ﺑﺎ ﻋﻼﻣﺖ ‪ ,‬از ﯾﮑﺪﯾﮕﺮ ﺟﺪا ﻣﯿﺸﻮﻧﺪ‪.‬‬ ‫•‬
 ‫‪VARIABLES‬‬ ‫‪Part 5‬‬ ‫‪Strings‬‬

‫• داده ﻫﺎی رﺷﺘﻪ ای ‪) Strings‬ﻣﺘﻨﯽ‪/‬ﻏﯿﺮ ﻣﺤﺎﺳﺒﻪ( ﺣﺘﻤﺎ ﺑﺎﯾﺪ درون دو ﻋﻼﻣﺖ “ ” ﯾﺎ ‘ ’ ﻗﺮار ﮔﯿﺮﻧﺪ و از اﯾﻦ ﺣﯿﺚ ﺑﺎ داده ﻫﺎی‬

‫ﻋﺪدی ﻣﺘﻔﺎوت ﻫﺴﺘﻨﺪ‪.‬‬

‫””” ﻗﺮار ﻣﯿﺪﻫﯿﻢ‪.‬‬ ‫• در ﺻﻮرت ﭼﻨﺪ ﺧﻄﯽ ﺑﻮدن رﺷﺘﻪ آن را ﺑﯿﻦ ﻋﻼﻣﺖ ﻫﺎی ‪“”” three quotes‬‬

‫• رﺷﺘﻪ ﻫﺎی ﺑﻪ ﺧﻮدی ﺧﻮد آراﯾﻪ ﻫﺴﺘﻨﺪ‪ .‬ﯾﻌﻨﯽ اﯾﻨﮑﻪ از ﺑﻪ ﻫﻢ ﭘﯿﻮﺳﺘﻦ ﻫﺎی ﮐﺎراﮐﺘﺮ ﺑﻪ وﺟﻮد‬

‫ﻣﯿﺎﯾﺪ و ﻋﻤﻠﯿﺎت ﻫﺎی ﻣﺘﻌﺪدی ﻣﺜﻞ ﺟﺴﺘﺠﻮ و‪ ...‬روی آن اﻧﺠﺎم داد‬

‫‪ ü‬ﻣﻘﺪار ﻣﺘﻨﯽ داﺧﻞ ﻣﺘﻐﯿﯿﺮ را ﺧﺎرج از ﻋﻼﻣﺖ “ “ ﯾﺎ ‘ ‘ﻗﺮار دﻫﯿﺪ و ﺑﺮﻧﺎﻣﻪ را اﺟﺮا ﮐﻨﯿﺪ‪.‬‬

‫• ﻣﻘﺎدﯾﺮ رﺷﺘﻪ ای ﻧﻤﯿﺘﻮاﻧﻨﺪ ﺧﺎرج از اﺳﺘﺎﻧﺪارد ﺗﻌﺮﯾﻒ ﺷﻮﻧﺪ‪.‬‬

 ‫‪VARIABLES‬‬ ‫‪Part 6‬‬ ‫‪Var name rules‬‬

‫ﻣﻮارد زﯾﺮ ﻗﻮاﻧﯿﻦ ﻧﺎﻣﮕﺬاری ﻣﺘﻐﯿﺮﻫﺎ ‪ ،‬ﺗﻮاﺑﻊ و ﮐﻼس ﻫﺎ ﻫﺴﺘﻨﺪ ﮐﻪ ﺑﺎﯾﺪ آﻧﻬﺎ را رﻋﺎﯾﺖ ﮐﻨﯿﻢ‪:‬‬ ‫•‬

‫ﻧﺎم ﻫﺎ ﺑﻪ ﺣﺮوف ﮐﻮﭼﮏ و ﺑﺰرگ ﺣﺴﺎس ﻫﺴﺘﻨﺪ )‪ . (Case-sensetive‬ﻣﺘﻐﯿﯿﺮ ‪ age‬و ‪ Age‬دو ﻣﺘﻐﯿﯿﺮ ﻣﺠﺰا ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫ﻧﺎم ﻫﺎ ﻣﯽ ﺗﻮاﻧﻨﺪ ﺷﺎﻣﻞ ﺣﺮوف ﮐﻮﭼﮏ و ﺑﺰرگ‪ ،‬ﻫﻤﭽﻨﯿﻦ اﻋﺪاد و _‪ underscore‬ﺑﺎﺷﻨﺪ‪[ A-z , 0-9 , _ ] .‬‬ ‫•‬

‫ﻧﺎم ﻫﺎ ﻧﻤﯽﺗﻮاﻧﻨﺪ ﺷﺎﻣﻞ ﮐﺎراﮐﺘﺮﻫﺎی ﺧﺎص ﻣﺎﻧﻨﺪ ‪ *&^%$#@! :‬ﺑﺎﺷﻨﺪ‪.‬‬ ‫•‬

‫ﻧﺎم ﻫﺎ ﻧﻤﯽ ﺗﻮاﻧﻨﺪ ﺑﺎ ﻋﺪد ﺷﺮوع ﺷﺪه و ﯾﺎ دارای ﻓﺎﺻﻠﻪ ﺑﺎﺷﻨﺪ‪.‬‬ ‫•‬

‫ﻧﺎم ﻫﺎ ﻧﻤﯽ ﺗﻮاﻧﻨﺪ اﺳﺎﻣﯽ رزرو ﺷﺪه در ﭘﺎﯾﺘﻮن ﺑﺎﺷﻨﺪ‪ ،‬ﻣﺎﻧﻨﺪ ‪int :‬‬ ‫•‬

‫ﻧﺎم ﻣﺘﻐﯿﺮ ﻫﺎ ﻧﻤﯽﺗﻮاﻧﺪ ﺑﻪ _‪ underscore‬ﺧﺘﻢ ﺷﻮد‪.‬‬ ‫•‬

 ‫‪VARIABLES‬‬ ‫‪Part 7‬‬ ‫‪Data type conversation‬‬

‫ﺗﺒﺪﯾﻞ ﻧﻮع داده ﻫﺎ‪:‬‬ ‫•‬

‫ﺗﻮاﺑﻌﯽ ﺑﺮای ﺗﺒﺪﯾﻞ ﻧﻮع داده وﺟﻮد دارﻧﺪ ﮐﻪ ﺗﻨﻬﺎ ﺑﺮﺧﯽ از آن ﻫﺎ ﺑﻪ ﺷﺮح ﺟﺪول زﯾﺮ ﻫﺴﺘﻨﺪ‪:‬‬ ‫•‬

‫‪Function‬‬ ‫‪Description‬‬

‫)‪int(x‬‬ ‫ﻣﻘﺪار ورودی ‪ x‬را ﺑﻪ ﻋﺪد ﺻﺤﯿﺢ ﺗﺒﺪﯾﻞ ﻣﯿﮑﻨﺪ‪ .‬ﻣﻘﺎدﯾﺮ رﺷﺘﻪ ای و اﻋﺸﺎری را ﻗﺒﻮل ﻣﯿﮑﻨﺪ‪.‬‬

‫)‪float(x‬‬ ‫ﻣﻘﺪار ورودی ‪ x‬را ﺑﻪ ﻋﺪد اﻋﺸﺎری ﺗﺒﺪﯾﻞ ﻣﯿﮑﻨﺪ‪ .‬ﻣﻘﺎدﯾﺮ رﺷﺘﻪ ای و ﻋﺪد ﺻﺤﯿﺢ را ﻗﺒﻮل ﻣﯿﮑﻨﺪ‪.‬‬

‫)‪str(x‬‬ ‫ﻣﻘﺪار ورودی ‪ x‬را ﺑﻪ رﺷﺘﻪ ﻣﺘﻨﯽ ﺗﺒﺪﯾﻞ ﻣﯿﮑﻨﺪ‪.‬‬

‫)‪hex(x‬‬ ‫ﻣﻘﺪار ورودی ‪ x‬را ﺑﻪ رﺷﺘﻪ ای ﺑﺮ ﻣﺒﻨﺎی ‪ ۱۶‬ﺗﺒﺪﯾﻞ ﻣﯿﮑﻨﺪ‪ .‬ﺗﻨﻬﺎ ﻋﺪد ﺻﺤﯿﺢ را ﻗﺒﻮل ﻣﯿﮑﻨﺪ‪.‬‬

‫ﻣﻘﺪار ورودی ‪ x‬را ﺑﻪ رﺷﺘﻪ ای ﺑﺮ ﻣﺒﻨﺎی ‪ ۱۶‬ﺗﺒﺪﯾﻞ ﻣﯿﮑﻨﺪ‪ .‬ﺗﻨﻬﺎ ﻋﺪد ﺻﺤﯿﺢ را ﻗﺒﻮل ﻣﯿﮑﻨﺪ‪.‬‬
‫)‪oct(x‬‬
 ‫‪VARIABLES‬‬ ‫‪Part 8‬‬ ‫‪Data type conversation‬‬

‫‪ ü‬ﻣﻘﺪار ﻣﺘﻐﯿﯿﺮ ‪ pi‬ﺑﻪ ﻧﻮع داده ﻋﺪد ﺻﺤﯿﺢ ﺗﺒﺪﯾﻞ ﮐﻨﯿﺪ‪.‬‬

‫‪ ü‬ﻣﻘﺪار ﻣﺘﻐﯿﯿﺮ ‪ score‬را ﺑﻪ ﻧﻮع داده ﻋﺪد ﺻﺤﯿﺢ ﺗﺒﺪﯾﻞ ﮐﻨﯿﺪ‪.‬‬

‫‪ ü‬ﻣﻘﺎدﯾﺮ ﭘﯿﺸﻔﺮض و ﻣﻘﺎدﯾﺮ ﻧﻬﺎﯾﯽ ﺗﺒﺪﯾﻞ ﺷﺪه را ﻧﻤﺎﯾﺶ دﻫﯿﺪ‪.‬‬

‫• ﻫﻤﭽﻨﯿﻦ ﻣﯿﺘﻮان ﺧﺮوﺟﯽ ﻧﻬﺎﯾﯽ ﺗﻮاﺑﻊ را در ﯾﮏ ﻣﺘﻐﯿﯿﺮ ذﺧﯿﺮه ﮐﺮد‬

‫ﻫﻤﭽﻨﯿﻦ ﻣﯿﺘﻮاﻧﯿﻢ ﺑﻌﻀﺎ ﺗﻮاﺑﻊ را در ﺑﺮﺧﯽ ﺗﻮاﺑﻊ دﯾﮕﺮ ﺑﻪ ﮐﺎر ﮔﯿﺮﯾﻢ‪ .‬ﻣﺜﻼ ﺗﺎﺑﻊ ‪ float‬در ‪print‬‬ ‫•‬
 ‫‪INPUT FUNCTION‬‬

‫از ﺗﺎﺑﻊ ‪ input‬ﺑﺮای ﮔﺮﻓﺘﻦ ورودی اﻃﻼﻋﺎت از ﮐﺎرﺑﺮ در ﻣﺤﯿﻂ ﮐﻨﺴﻮل ‪ CMD/Terminal‬اﺳﺘﻔﺎده ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫ﺧﺮوﺟﯽ ﺗﺎﺑﻊ ‪ input‬داﺧﻞ ﻣﺘﻐﯿﯿﺮ ذﺧﯿﺮه ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫ﺑﻪ ﻃﻮر ﭘﯿﺸﻔﺮض ﻣﯿﺘﻮاﻧﺪ ﯾﮏ ورودی رﺷﺘﻪ ای ‪ string‬داﺷﺘﻪ ﺑﺎﺷﺪ ﮐﻪ ﯾﮏ ﭘﯿﺎم ﺑﺮای ﮐﺎرﺑﺮ و ﮔﺮﻓﺘﻦ ورودی اﺳﺖ‪.‬‬ ‫•‬

‫ﻧﻮع داده اﯾﻦ ﺗﺎﺑﻊ ﺑﻪ ﻃﻮر ﭘﯿﺸﻔﺮض رﺷﺘﻪ ای اﺳﺖ‪ .‬ﭘﺲ اﮔﺮ ﻗﺼﺪ ﮔﺮﻓﺘﻦ ﻋﺪد از ﮐﺎرﺑﺮ را دارﯾﺪ ﺣﺘﻤﺎ ﻣﯿﺒﺎﯾﺴﺖ ﻧﻮع آن را ﺗﺒﺪﯾﻞ ﺑﻪ‬ ‫•‬

‫ﯾﮑﯽ از اﻧﻮاع ‪ numeric‬ﮐﻨﯿﺪ‪ .‬در ﻏﯿﺮ اﯾﻨﺼﻮرت اﮔﺮ ﻧﯿﺎز ﺑﻪ ﭘﺮدازش و ﻣﺤﺎﺳﺒﻪ آن ﻋﺪد داﺷﺘﻪ ﺑﺎﺷﯿﻢ ﺑﺎ ﻣﺸﮑﻞ ﻣﻮاﺟﻪ ﺧﻮاﻫﯿﻢ ﺷﺪ‪.‬‬
 PRINT PARAMETERS

‫ دارای ﭼﻨﺪ ﭘﺎراﻣﺘﺮ )ورودی اﺟﺒﺎری ﯾﺎ ﻏﯿﺮ اﺟﺒﺎری( ﺑﺮای ﻧﺤﻮه ﻧﻤﺎﯾﺶ ﻣﯿﺒﺎﺷﺪ‬print ‫ﺗﺎﺑﻊ‬ •

Parameters Description
You can end a print statement with any character/string using this
end
parameter.
The separator between the arguments to print() function in Python is space by
sep default (softspace feature) , which can be modified and can be made to any
character, integer or string as per our choice

‫\ اﺳﺖ ﮐﻪ ﺑﺎﻋﺚ ﻣﯿﺸﻮد ﺧﺮوﺟﯽ در ﯾﮏ‬n ‫ ﺑﻪ ﻃﻮر ﭘﯿﺸﻔﺮض‬end ‫ﻣﻘﺪار ﭘﺎراﻣﺘﺮ‬

.‫ﺧﻂ ﺟﺪﯾﺪ ﭼﺎپ ﺑﺸﻮد‬
‫ﻫﻤﭽﻨﯿﻦ ﻣﯿﺘﻮان از اﯾﻦ ﻋﻼﻣﺖ در ﺑﯿﻦ رﺷﺘﻪ ﻫﺎ ﻧﯿﺰ ﺟﻬﺖ اﯾﺠﺎد ﻓﺎﺻﻠﻪ ﺑﺎ ﺧﻂ‬
.‫ﺟﺪﯾﺪ اﺳﺘﻔﺎده ﮐﺮد‬
.‫ اﺳﺖ‬Escape sequence ‫\ ﯾﮑﯽ اﻧﻮاع‬n
 ESCAPE SEQUENCE

Escape ‫ ﺑﻪ اﯾﻦ ﮐﺎراﮐﺘﺮ ﻫﺎ‬.‫ﻣﯽ ﺗﻮاﻧﯿﺪ از ﯾﮏ ﯾﺎ ﭼﻨﺪ ﮐﺎراﮐﺘﺮ وﯾﮋه در رﺷﺘﻪ ﺑﺮای ﻗﺎﻟﺐ ﺑﻨﺪی ﯾﺎ اﺟﺮای ﯾﮏ دﺳﺘﻮر اﺳﺘﻔﺎده ﮐﻨﯿﺪ‬ •

.‫ در ﭘﺎﯾﺘﻮن ﺑﺎ ﺑﮏ اﺳﻠﺶ )\( ﺷﺮوع ﻣﯽ ﺷﻮد‬Escape ‫ ﯾﮏ دﻧﺒﺎﻟﻪ‬.‫ ﻣﯽ ﮔﻮﯾﻨﺪ‬sequence

Escape sequence Description

\n Breaks the string into a new line

\t Adds a horizontal tab

\\ Prints a backslash
\’ Prints a single quote
\” Prints a double quote
\a makes a sound like a bell
 ‫‪OUTPUT FORMATTING‬‬
‫راهﻫﺎی ﻣﺨﺘﻠﻔﯽ ﺑﺮای اراﺋﻪ ﺧﺮوﺟﯽ وﺟﻮد دارد‪ ،‬ﮐﻪ ﺑﺮای ﺑﺎﻻ ﺑﺮدن ﺧﻮاﻧﺎﯾﯽ داده ﻫﺎ در ﻣﺤﯿﻂ ﮐﻨﺴﻮل اﺳﺘﻔﺎده ﻣﯿﮑﻨﯿﻢ‪.‬‬ ‫•‬

‫‪ formatted string literals‬ﯾﮑﯽ از روش ﻫﺎی ﻗﺎﻟﺐ ﺑﻨﺪی ﺧﺮوﺟﯽ ﻣﺘﻦ در ﺗﺎﺑﻊ ‪ print‬اﺳﺖ ﮐﻪ ﺑﺎ ﻋﻼﻣﺖ ‪ f‬ﻗﺒﻞ از ﻣﺤﺘﻮا ﺗﻌﺮﯾﻒ ﻣﯿﺸﻮد و اﺟﺎزه ﻣﯿﺪه‬ ‫•‬

‫ﻣﻘﺎدﯾﺮ ﻣﺘﻐﯿﯿﺮ ﻫﺎی دﯾﮕﺮ را ﺑﯿﻦ ﻫﻤﺎن رﺷﺘﻪ از ﻃﺮﯾﻖ ﺻﺪا زدن ﻧﺎم ﻣﺘﻐﯿﯿﺮ ﻣﺎﺑﯿﻦ ﻋﻼﻣﺖ }{ ‪ Bracket‬ﻧﻤﺎﯾﺶ دﻫﯿﻢ‪.‬‬
 ‫‪OPERATORS‬‬ ‫‪Part 1‬‬

‫ﻋﻤﻠﮕﺮﻫﺎ )‪ (operators‬ﺳﺎزه ﻫﺎﯾﯽ ﻫﺴﺘﻨﺪ ﮐﻪ ﻣﯽ ﺗﻮاﻧﻨﺪ ﻣﻘﺪار ﻋﻤﻠﻮﻧﺪﻫﺎ )‪) (operands‬ﻣﻘﺎدﯾﺮی ﮐﻪ روی آن ﻫﺎ ﻋﻤﻠﯿﺎت اﻧﺠﺎم‬ ‫•‬

‫ﻣﯿﺸﻮد( را دﺳﺘﮑﺎری ﮐﻨﻨﺪ‪.‬‬

‫ﻋﺒﺎرت ‪ 3 + 6 = 9‬را در ﻧﻈﺮ ﺑﮕﯿﺮﯾﺪ‪ .‬در اﯾﻨﺠﺎ ‪ 3‬و ‪ 6‬ﻋﻤﻠﻮﻧﺪ و ‪ +‬ﻋﻤﻠﮕﺮ ﻧﺎﻣﯿﺪه ﻣﯽ ﺷﻮﻧﺪ‪.‬‬ ‫•‬

‫زﺑﺎن ﭘﺎﯾﺘﻮن از اﻧﻮاع ﻋﻤﻠﮕﺮﻫﺎی زﯾﺮ ﭘﺸﺘﯿﺒﺎﻧﯽ ﻣﯽ ﮐﻨﺪ‪:‬‬ ‫•‬

‫‪Arithmetic Operators‬‬ ‫ﻋﻤﻠﮕﺮﻫﺎی ﺣﺴﺎﺑﯽ‬

‫‪Comparison (Relational) Operators‬‬ ‫ﻋﻤﻠﮕﺮﻫﺎی ﻣﻘﺎﯾﺴﻪ )راﺑﻄﻪ ای(‬

‫‪Assignment Operators‬‬ ‫ﻋﻤﻠﮕﺮﻫﺎی ﺗﺼﺨﯿﺼﯽ‬

‫‪Logical Operators‬‬ ‫ﻋﻤﻠﮕﺮﻫﺎی ﻣﻨﻄﻘﯽ‬

‫‪Bitwise Operators‬‬ ‫ﻋﻤﻠﮕﺮﻫﺎی ﺑﯿﺘﯽ‬

‫‪Membership Operators‬‬ ‫ﻋﻤﻠﮕﺮﻫﺎی ﻋﻀﻮﯾﺖ‬

‫‪Identity Operators‬‬ ‫ﻋﻤﻠﮕﺮﻫﺎی ﻫﻮﯾﺖ‬

 OPERATORS Part 2 Arithmetic Operators

.‫ﺣﺴﺎﺑﯽ اﻧﺠﺎم ﻣﯿﺪﻫﻨﺪ‬/‫ﻋﻤﻠﮕﺮﻫﺎﯾﯽ ﮐﻪ ﻋﻤﻠﯿﺎت رﯾﺎﺿﯽ‬ •

:‫ در ﻧﻈﺮ ﺑﮕﯿﺮﯾﺪ‬۲۰ ‫ و‬۱۰ ‫ را ﺑﺎ ﻣﻘﺎدﯾﺮ‬y ‫ و‬x ‫دو ﻣﺘﻐﯿﯿﺮ‬ •

Operators Description Example

+ Addition Adds values on either side of the operator. x + y = 30
Subtracts right hand operand from left hand
- Subtraction operand. x – y = -10

* Multiplication Multiplies values on either side of the operator x * y = 200

/ Division Divides left hand operand by right hand operand x / y = 0.5
Divides left hand operand by right hand operand
% Modulus and returns remainder y%x=0
Performs exponential (power) calculation on
** Exponent operators x ** y = 10 to the power 20
The division of operands where the result is the
quotient in which the digits after the decimal point 7 // 2 = 3
// Floor Division are removed. But if one of the operands is -9 // 2 = -5
negative, the result is floored, i.e., rounded away 11//3 = 3
from zero (towards negative infinity)
 ‫‪OPERATORS‬‬ ‫‪Part 3‬‬ ‫‪Arithmetic Operators‬‬

‫ﭼﻨﺪ ﻣﺜﺎل از ﻋﻤﻠﮕﺮ ﻫﺎی ﺣﺴﺎﺑﯽ‪:‬‬ ‫•‬

‫درون ﺗﺎﺑﻊ ‪ print‬ﻣﯿﺘﻮاﻧﯿﻢ ﺑﻪ ﺷﮑﻞ ﻣﺴﺘﻘﯿﻢ ﻣﺤﺎﺳﺒﺎت اﻧﺠﺎم دﻫﯿﻢ‪.‬‬ ‫•‬

‫ﻣﺤﺎﺳﺒﺎت را ﻣﯿﺘﻮان درون ﻣﺘﻐﯿﯿﺮ ذﺧﯿﺮه ﮐﺮد‪.‬‬ ‫•‬

‫ﺧﺮوﺟﯽ ﻣﺤﺎﺳﺒﺎﺗﯽ ﮐﻪ ﺷﺎﻣﻞ ﺑﯿﺶ از ﯾﮏ ﻋﻤﻠﮕﺮ ﻫﺴﺘﻨﺪ ﺣﺘﻤﺎ ﻧﻮع داده آن ‪ float‬ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬ ‫•‬
 OPERATORS Part 4 Comparison (Relational) Operators

.‫ ﺑﻪ آﻧﻬﺎ ﻋﻤﻠﮕﺮﻫﺎی راﺑﻄﻪ ای ﻧﯿﺰ ﮔﻔﺘﻪ ﻣﯽ ﺷﻮد‬.‫اﯾﻦ ﻋﻤﻠﮕﺮﻫﺎ ﻣﻘﺎدﯾﺮ دو ﻃﺮف آﻧﻬﺎ را ﻣﻘﺎﯾﺴﻪ ﮐﺮده و راﺑﻄﻪ ﺑﯿﻦ آﻧﻬﺎ را ﺗﻌﯿﯿﻦ ﻣﯽ ﮐﻨﻨﺪ‬ •

False ‫ ﻫﺴﺘﻨﺪ ﯾﺎ‬True ‫ﻧﺘﯿﺠﻪ ﯾﺎ‬ •

a , b = 10 , 20 Operators Description Example

If the values of two operands are equal, then the
== condition becomes true.
(a == b) is not true >>> False

If values of two operands are not equal, then

!= condition becomes true.
(a != b) is true >>> True

If values of two operands are not equal, then (a <> b) is true. This is similar to !=
<> condition becomes true. operator
If the value of left operand is greater than the
> value of right operand, then condition becomes (a > b) is not true >>> False
true.
If the value of left operand is less than the value
< of right operand, then condition becomes true.
(a < b) is true >>> True

If the value of left operand is greater than or

>= equal to the value of right operand, then (a >= b) is not true >>> False
condition becomes true.

If the value of left operand is less than or equal to

<= the value of right operand, then condition (a <= b) is true >>> True
becomes true
OPERATORS Part 5 Comparison (Relational) Operators

:‫ﭼﻨﺪ ﻣﺜﺎل از ﻋﻤﻠﮕﺮ ﻫﺎی ﻣﻘﺎﯾﺴﻪ ای راﺑﻄﻪ ای‬ •

 OPERATORS Part 6 Assignment Operators

‫ﺑﻪ اﯾﻦ ﻋﻤﻠﮕﺮ ﻫﺎ ﺗﺼﺨﯿﺼﯽ ﯾﺎ واﮔﺬاری ﻧﯿﺰ ﮔﻔﺘﻪ ﻣﯿﺸﻮد‬ •

Operators Description Example

Assigns values from right side operands to left
= side operand
c = a + b assigns value of a + b into c

It adds right operand to the left operand and

+= ADD AND assign the result to left operand
c += a is equivalent to c = c + a

It subtracts right operand from the left operand

-= Subtract AND and assign the result to left operand
c -= a is equivalent to c = c - a

It multiplies right operand with the left operand

*= Multiply AND and assign the result to left operand.
c *= a is equivalent to c = c * a

It divides left operand with the right operand and

/= Divide AND assign the result to left operand
(a < b) is true >>> True

If the value of left operand is greater than or

%= Modulus AND equal to the value of right operand, then c %= a is equivalent to c = c % a
condition becomes true.

Performs exponential (power) calculation on

**= Exponent AND operators and assign value to the left operand
c **= a is equivalent to c = c ** a
 ‫‪OPERATORS‬‬ ‫‪Part 7‬‬ ‫‪Assignment Operators‬‬

‫ﭼﻨﺪ ﻣﺜﺎل از ﻋﻤﻠﮕﺮ ﻫﺎی ﺗﺼﺨﯿﺼﯽ‪:‬‬ ‫•‬

‫در ﺻﻮرت ﺗﮑﺮار ﻧﺎم ﻣﺘﻐﯿﺮ و اﺳﺘﻔﺎده ﻣﺠﺪد از آن ﻫﻤﯿﺸﻪ ﻣﻘﺪار آن ﺑﺮاﺑﺮ آﺧﺮﯾﻦ ﻣﻘﺪار ﺗﻌﺮﯾﻒ ﺷﺪه اﺳﺖ‬ ‫•‬
 OPERATORS Part 8 Logical Operators

‫ﻋﻤﻠﮕﺮ ﻫﺎی ﻣﻨﻄﻘﯽ‬ •

a , b = True , False

Operators Description Example

If both the operands are true then condition
and Logical AND becomes true.
(a and b) is true

If any of the two operands are non-zero then

or Logical OR condition becomes true.
(a or b) is true

not Logical NOT Used to reverse the logical state of its operand. Not(a and b) is false.
 OPERATORS Part 9 Membership Operators

‫ﻋﻤﻠﮕﺮ ﻫﺎی ﻋﻀﻮﯾﺖ‬ •

.‫( در دﻧﺒﺎﻟﻪ دﯾﮕﺮ ﺑﺮرﺳﯽ ﻣﯿﮑﻨﺪ‬String , List , Tuples)‫ﻋﻀﻮﯾﺖ ﯾﮏ دﻧﺒﺎﻟﻪ‬ •

Operators Description Example

Evaluates to true if it finds a variable in the x in y, here in results in a True if x is a
in specified sequence and false otherwise. member of sequence y.
If any of the two operands are non-zero then x not in y, here not in results in a True
not in condition becomes true. if x is not a member of sequence y.

‫( ﭘﺮداﺧﺘﻪ ﻣﯿﺸﻮد‬sequences) ‫در ﺑﺨﺶ ﻫﺎی ﺟﻠﻮﺗﺮ ﺑﻪ ﻣﺒﺎﺣﺚ اﻧﻮاع داده دﻧﺒﺎﻟﻪ دار‬
 OPERATORS Part 10 Identify Operators

‫ﻋﻤﻠﮕﺮ ﻫﺎی ﺷﻨﺎﺳﺎﯾﯽ‬ •

.‫ ﻣﮑﺎن ﻫﺎی ﺣﺎﻓﻈﻪ دو ﺷﺊ )ﺷﺎﻣﻞ ﻣﺘﻐﯿﯿﺮ ﻧﯿﺰ ﻣﯿﺸﻮد( را ﺑﺎ ﻫﻢ ﻣﻘﺎﯾﺴﻪ ﻣﯽ ﮐﻨﻨﺪ‬،‫ﺷﻨﺎﺳﺎﯾﯽ‬/‫ﻋﻤﻠﮕﺮﻫﺎی ﻫﻮﯾﺖ‬ •

.‫ ﻣﯿﺘﻮان اﺳﺘﻔﺎده ﮐﺮد‬id ‫ از ﺗﺎﺑﻊ‬RAM ‫ﻣﺘﻐﯿﯿﺮ در ﺣﺎﻓﻈﻪ‬/‫ﺑﺮای ﻣﺸﺨﺺ ﮐﺮدن ﻣﮑﺎن ﺷﺊ‬ •

.‫ ﻣﺮاﺟﻌﻪ ﻣﯿﮑﻨﺪ ﺳﺮﻋﺖ ﺑﯿﺸﺘﺮی دارد‬RAM ‫ﮔﺎﻫﺎ ﻣﯿﺘﻮان ﺑﻪ ﺟﺎی ﻋﻤﻠﮕﺮ ﻣﻘﺎﯾﺴﻪ ای == ﯾﺎ =! اﺳﺘﻔﺎده ﺷﻮد و ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ اﯾﻨﮑﻪ ﻣﺴﺘﻘﯿﻢ ﺑﻪ‬ •

Operators Description Example

Evaluates to true if the variables on either side of
x is y, here is results in True if id(x)
is the operator point to the same object and false
equals id(y)
otherwise.
Evaluates to false if the variables on either side of
x is not y, here is not results in True if
is not the operator point to the same object and true
id(x) is not equal to id(y)
otherwise.
‫ﺗﺼﻤﯿﻢ ﮔﯿﺮی و ﺷﺮط ﻫﺎ ‪DECISION AND CONDITIONS‬‬ ‫‪Part 1‬‬

‫ﮔﺎﻫﯽ ﻣﺎ در ﺑﺮﻧﺎﻣﻪ ﻣﺎن ﻧﯿﺎز دارﯾﻢ ﺷﺮاﯾﻂ را ﺑﺮرﺳﯽ ﮐﻨﯿﻢ و ﻣﻄﺎﺑﻖ آن ﺗﺼﻤﯿﻢ ﮔﯿﺮی ﮐﻨﯿﻢ ﮐﻪ ﺑﺮﻧﺎﻣﻪ ﻣﯿﺨﻮاﻫﺪ ﭼﻪ ﮐﺎری اﻧﺠﺎم دﻫﺪ‪.‬‬ ‫•‬

‫ﻣﺜﺎل‪:‬‬ ‫•‬

‫‪ ü‬ﺑﺮرﺳﯽ ﻣﯿﮑﻨﯿﻢ ﮐﻪ آﯾﺎ ‪ ۲‬از ‪ ۳‬ﮐﻮﭼﮑﺘﺮ اﺳﺖ؟‬

‫‪ ü‬ﺣﺎﻻ ﺗﺼﻤﯿﻢ ﮔﯿﺮی ﻣﯿﮑﻨﯿﻢ ﮐﻪ اﮔﺮ ﮐﻮﭼﮑﺘﺮ ﺑﻮد ﯾﺎ اﮔﺮ ﻧﺘﯿﺠﻪ ‪True‬ﺑﻮد )ﺷﺮط( ﭘﯿﺎم ﺑﺪه و ﺑﮕﻮ ﮐﻮﭼﮑﺘﺮ اﺳﺖ )ﺗﺼﻤﯿﻢ ﮔﯿﺮی(‬

‫در ﻏﯿﺮ اﯾﻨﺼﻮرت )ﯾﻌﻨﯽ ﺧﻼف ﺷﺮط ﺑﺎﻻ( ﯾﺎ اﯾﻨﮑﻪ ‪ False‬ﺑﻮد ﭘﯿﺎم ﺑﺪه ﺑﮕﻮ ﺑﺰرﮔﺘﺮ اﺳﺖ!‬ ‫‪ü‬‬

‫‪ ü‬ﺗﻤﺎم‪.‬‬

‫اﯾﻦ ﯾﮏ ﻣﺜﺎل ﺳﺎده و ﺗﻮﺿﯿﺢ از ﺷﺮط ﻫﺎ در ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ اﺳﺖ‪.‬‬ ‫•‬

‫ﺗﻮﺿﯿﺤﺎت ﺑﺎﻻ و ﻣﺮﺣﻠﻪ ﺑﻪ ﻣﺮﺣﻠﻪ ﮐﺮدن ﮐﺎر ﻫﺎ را ﻫﻢ اﻟﮕﻮرﯾﺘﻢ ﻣﯿﮕﻮﯾﻨﺪ‪.‬‬ ‫•‬

 ‫ﺗﺼﻤﯿﻢ ﮔﯿﺮی و ﺷﺮط ﻫﺎ ‪DECISION AND CONDITIONS‬‬ ‫‪Part 2‬‬

‫ﺷﺮوع ﺑﺮﻧﺎﻣﻪ‬
‫ﺳﺎﺧﺘﺎر ﺑﺮرﺳﯽ ﺷﺮط و ﺗﺼﻤﯿﻢ ﮔﯿﺮی در ﺗﻤﺎم زﺑﺎن ﻫﺎی ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺑﻪ ﺷﮑﻞ ﻣﻘﺎﺑﻞ اﺳﺖ‪:‬‬ ‫•‬

‫ﺳﺎﺧﺘﺎرﻫﺎی ﺷﺮط و ﺗﺼﻤﯿﻢ ﮔﯿﺮی‪ ،‬ﺷﺮاﯾﻂ ﻣﺘﻌﺪدی را ارزﯾﺎﺑﯽ ﻣﯽ ﮐﻨﻨﺪ و ﺑﻪ ﻋﻨﻮان ﻧﺘﯿﺠﻪ‪ TRUE ،‬ﯾﺎ ‪ FALSE‬اﯾﺠﺎد ﻣﯽ ﮐﻨﻨﺪ‪.‬‬ ‫•‬

‫ﺑﺮرﺳﯽ ﺷﺮط‬ ‫‪condition‬‬ ‫ﺷﻤﺎ ﺑﺎﯾﺪ ﺗﻌﯿﯿﻦ ﮐﻨﯿﺪ ﮐﻪ در ﺻﻮرت درﺳﺖ ﯾﺎ ﻧﺎدرﺳﺖ ﺑﻮدن ﻧﺘﯿﺠﻪ‪ ،‬ﮐﺪام ﮐﺎر‪/‬ﻋﻤﻠﯿﺎت را اﻧﺠﺎم دﻫﺪ‪.‬‬ ‫•‬

‫ﻋﻤﻠﮕﺮ ﻫﺎی راﺑﻄﻪ ای‪/‬ﻣﻘﺎﯾﺴﻪ ای )‪ (Comparison‬ﻧﯿﺰ ﻧﻮﻋﯽ و ﺑﺨﺸﯽ از ﺳﺎﺧﺘﺎر ﺷﺮط ﻫﺎ ﻫﺴﺘﻨﺪ!‬ ‫•‬

‫اﮔﺮ ﺷﺮط ﺑﺮﻗﺮار ﯾﺎ ﻫﻤﺎن ‪ True‬ﺑﻮد‬

‫اﮔﺮ ﺷﺮط ﺑﺮﻗﺮار ﻧﺒﻮد ﯾﺎ ﻫﻤﺎن ‪ False‬ﺑﻮد‬

‫اﻧﺠﺎم ﻋﻤﻠﯿﺎت‬ ‫‪operations‬‬

‫اﺷﮑﺎل اﺳﺘﻔﺎده در ﻣﺜﺎل ﺑﺎﻻ را ﻓﻠﻮﭼﺎرت ﻣﯿﮕﻮﯾﻨﺪ و ﯾﮏ روش ﺗﺮﺳﯿﻢ اﻟﮕﻮرﯾﺘﻢ اﺳﺖ‬
‫ﭘﺎﯾﺎن‬
statements ‫ﻋﺒﺎرات ﺷﺮﻃﯽ‬ DECISION AND CONDITIONS ‫ﺗﺼﻤﯿﻢ ﮔﯿﺮی و ﺷﺮط ﻫﺎ‬ Part 3

:‫ﺟﻬﺖ ﺑﺮرﺳﯽ ﺷﺮط ﻫﺎ در ﺑﺮﻧﺎﻣﻪ ﻫﺎﯾﯽ ﮐﻪ ﺑﻪ زﺑﺎن ﭘﺎﯾﺘﻮن ﻧﻮﺷﺘﻪ ﻣﯿﺸﻮﻧﺪ ﺑﺎﯾﺪ ﻋﺒﺎرات زﯾﺮ اﺳﺘﻔﺎده ﮐﻨﯿﻢ‬ •

.‫( و رزرو ﺷﺪه در ﭘﺎﯾﺘﻮن ﻫﺴﺘﻨﺪ‬keywords) ‫اﯾﻦ ﻋﺒﺎرات ﺑﺨﺸﯽ از ﮐﻠﻤﺎت ﮐﻠﯿﺪی‬ •

statements Description

if If keyword Checks the basic and basic conditions.

The elif keyword is using for: if the previous conditions were not true, then try this
elif condition.

else The else keyword catches anything which isn't caught by the preceding conditions.
 ‫ﺗﺼﻤﯿﻢ ﮔﯿﺮی و ﺷﺮط ﻫﺎ ‪DECISION AND CONDITIONS‬‬ ‫‪Part 4‬‬

‫ﻋﺒﺎرت ﺷﺮﻃﯽ ‪ if‬و ﺗﻮ رﻓﺘﮕﯽ )‪(Indentation‬‬

‫ﺟﻬﺖ ﺑﺮرﺳﯽ ﺷﺮاﯾﻂ در ﺑﺮﻧﺎﻣﻪ ﻧﯿﺎز ﺑﻪ ﻧﻮﺷﺘﻦ ﻋﺒﺎرت ﺷﺮﻃﯽ و رﻋﺎﯾﺖ ﺗﻮ رﻓﺘﮕﯽ دارﯾﻢ‪.‬‬ ‫•‬

‫در ﺧﻂ اول ﺑﺮرﺳﯽ ﺷﺮط اﺑﺘﺪا ﻋﺒﺎرت ﺷﺮﻃﯽ را ﻣﯿﻨﻮﯾﺴﯿﻢ و ﺷﺮاﯾﻂ را ﺑﺮرﺳﯽ ﻣﯿﮑﻨﯿﻢ و آﺧﺮ آن ﻣﯿﺒﺎﯾﺴﺖ ﻋﻼﻣﺖ )‪ (:‬ﻗﺮار دﻫﯿﻢ‪.‬‬ ‫•‬

‫ﺳﭙﺲ ﻋﻤﻠﯿﺎت ﻫﺎ ﺑﻌﺪ از ﺻﺤﯿﺢ ﺑﻮدن ﺷﺮط را زﯾﺮ آن و ﺑﻌﺪ از ﯾﮏ ﻓﺎﺻﻠﻪ ‪ tab‬ﻣﯿﻨﻮﯾﺴﯿﻢ‪.‬‬ ‫•‬

‫در اﯾﻦ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﮐﻤﮏ ﻋﺒﺎرت ‪ if‬و ﻋﻤﻠﮕﺮ ﻫﺎی ﻣﻘﺎﯾﺴﻪ ای ﮔﻔﺘﯿﻢ اﮔﺮ ‪ x‬ﮐﻮﭼﮑﺘﺮ ‪ y‬ﺑﻮد )ﺷﺮط ‪ True‬ﺑﻮد( ﭼﺎپ ﮐﻦ ‪Yeesss, x < y‬‬ ‫•‬

‫در ﻋﺒﺎرت ﺷﺮﻃﯽ از ﻋﻤﻠﮕﺮﻫﺎی ﻣﻘﺎﯾﺴﻪ ای و ﻣﻨﻄﻘﯽ و ﺷﻨﺎﺳﺎﯾﯽ و ﻋﻀﻮﯾﺖ و ﺣﺴﺎﺑﯽ اﺳﺘﻔﺎده ﻣﯿﮑﻨﯿﻢ‪.‬‬ ‫•‬
 ‫ﺗﺼﻤﯿﻢ ﮔﯿﺮی و ﺷﺮط ﻫﺎ ‪DECISION AND CONDITIONS‬‬ ‫‪Part 5‬‬
‫ﻋﺒﺎرت ﺷﺮﻃﯽ ‪elif‬‬

‫اﯾﻦ ﻋﺒﺎرت ﺑﺮای ﺑﺮرﺳﯽ درﺳﺖ ﻧﺒﻮدن ﺷﺮط ﻗﺒﻠﯽ )ﺷﺮﻃﯽ ﮐﻪ دﻗﯿﻘﺎ ﻗﺒﻞ ﺧﻮدش ﺗﻌﺮﯾﻒ ﺷﺪه ﺑﺎﺷﺪ( اﺳﺘﻔﺎده ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫ﺑﻪ ﺷﮑﻞ ﺧﯿﻠﯽ ﺳﺎده وﻇﯿﻔﻪ اش اﯾﻦ اﺳﺖ ﮐﻪ اﮔﺮ ﺷﺮط ﻗﺒﻠﯽ درﺳﺖ ﻧﺒﻮد‪/‬ﺑﺮﻗﺮار ﻧﺒﻮد‪ False/‬ﺑﻮد ﻋﻤﻠﯿﺎت ﺗﻌﺮﯾﻒ ﺷﺪه داﺧﻞ ﺧﻮدش را اﻧﺠﺎم‬ ‫•‬

‫ﻣﯿﺪﻫﺪ‪.‬‬

‫ﺑﻌﺪ از ﺷﺮط ﻗﺒﻠﯽ ﺧﻮدش و ﺧﺎرج از ﺗﻮ رﻓﺘﮕﯽ )‪ (Indent‬ﻧﻮﺷﺘﻪ ﻣﯿﺸﻮد‪.‬‬ ‫•‬

 ‫ﺗﺼﻤﯿﻢ ﮔﯿﺮی و ﺷﺮط ﻫﺎ ‪DECISION AND CONDITIONS‬‬ ‫‪Part 6‬‬
‫ﻋﺒﺎرت ﺷﺮﻃﯽ ‪else‬‬

‫در ﺻﻮرﺗﯽ ﮐﻪ ﻫﯿﭻ ﮐﺪام از ﺷﺮط ﻫﺎی ﻗﺒﻞ ﺧﻮدش ﺑﺮ ﻗﺮار ﻧﺒﺎﺷﺪ ﻋﻤﻠﯿﺎت ﺗﻌﺮﯾﻒ ﺷﺪه درون ﺧﻮدش را اﻧﺠﺎم ﻣﯿﺪﻫﺪ‪.‬‬ ‫•‬

‫ﺑﺮ ﺧﻼف ‪ if‬و ‪ elif‬ﻧﯿﺎز ﺑﻪ ﺗﻌﺮﯾﻒ ﺷﺮط ﻧﺪارد و ﺧﻮدش ﺷﺮط ﻫﺎی ﻗﺒﻠﺶ را ﺑﺮرﺳﯽ ﻣﯿﮑﻨﺪ‪.‬‬ ‫•‬

‫در ﺑﺮﻧﺎﻣﻪ ﻣﻘﺎﺑﻞ‪:‬‬ ‫•‬

‫‪ (1‬ﻣﺘﻐﯿﯿﺮ ‪ a‬و ‪ b‬ﻫﺮ دو دارای ﻣﻘﺪار ‪ 10‬ﻫﺴﺘﻨﺪ‪.‬‬

‫‪ (2‬در ﺷﺮط ﭘﺎﯾﻪ ﺑﺮرﺳﯽ ﻣﯿﺸﻮد آﯾﺎ ‪ a‬ﺑﺰرﮔﺘﺮ از ‪ b‬اﺳﺖ؟ ﭼﻮن اﯾﻦ ﺷﺮط ﺑﺮﻗﺮار‪ True/‬ﻧﯿﺴﺖ ﺑﻪ ﻣﺮﺣﻠﻪ ﺑﻌﺪ ﻣﯿﺮود‪.‬‬

‫‪ (3‬ﺳﭙﺲ ﺑﺮرﺳﯽ ﻣﯿﺸﻮد آﯾﺎ ‪ b‬از ‪ a‬ﺑﺰرﮔﺘﺮ اﺳﺖ؟ اﯾﻦ ﺷﺮط ﻧﯿﺰ ﻧﻘﺾ ﻣﯿﺸﻮد‪.False/‬‬

‫‪ (4‬ﭼﻮن ﻫﯿﭻ ﮐﺪام از دو ﺷﺮط ﺗﻌﺮﯾﻒ ﺷﺪه ﺑﺮﻗﺮار ﻧﯿﺴﺘﻨﺪ ﭘﺲ ﺗﺎﺑﻊ ‪ print‬درون ‪ else‬اﺟﺮا ﻣﯿﺸﻮد‪.‬‬
 ‫ﭘﺮوژه ﻣﺎﺷﯿﻦ ﺣﺴﺎب در ﻣﺤﯿﻂ ‪CMD/SHELL/TERMINAL‬‬

‫ﺣﺎل ﮐﻪ ﺑﺎ ﻋﻤﻠﮕﺮﻫﺎ و ﻋﺒﺎرات ﺷﺮﻃﯽ آﺷﻨﺎ ﺷﺪﯾﻢ ﺑﻪ راﺣﺘﯽ ﻣﯿﺘﻮاﻧﯿﻢ ﯾﮏ ﺑﺮﻧﺎﻣﻪ ﯾﮏ ﻣﺎﺷﯿﻦ ﺣﺴﺎب ﺳﺎده را ﺑﻨﻮﯾﺴﯿﻢ‪.‬‬ ‫•‬

‫‪ (1‬ﻣﻘﺪار ﻋﻤﻠﻮﻧﺪ اول را از ﮐﺎرﺑﺮ ﺑﮕﯿﺮﯾﺪ‪.‬‬

‫‪ (2‬ﻧﻮع داده را رﻋﺎﯾﺖ ﮐﻨﯿﺪ‪.‬‬

‫‪ (3‬ﻧﻮع ﻋﻤﻠﮕﺮ ﺣﺴﺎﺑﯽ را از ﮐﺎرﺑﺮ ﺑﮕﯿﺮﯾﺪ‪.‬‬

‫‪ (4‬ﻣﻘﺪار ﻋﻤﻠﻮﻧﺪ دوم را از ﮐﺎرﺑﺮ ﺑﮕﯿﺮﯾﺪ‪.‬‬

‫‪ (5‬ﻋﻤﻠﮕﺮ ﺣﺴﺎﺑﯽ را ﺑﺮرﺳﯽ ﮐﻨﯿﺪ ﮐﻪ ﭼﻪ اﺳﺖ ﺳﭙﺲ ﻣﻄﺎﺑﻖ آن ﻋﻤﻠﯿﺎت ﺣﺴﺎب را اﻧﺠﺎم دﻫﯿﺪ‬
 ‫ﺗﺼﻤﯿﻢ ﮔﯿﺮی و ﺷﺮط ﻫﺎ ‪DECISION AND CONDITIONS‬‬ ‫‪Part 7‬‬
‫ﻋﻤﻠﮕﺮﻫﺎی ﻣﻨﻄﻘﯽ در ﻋﺒﺎرات ﺷﺮﻃﯽ ‪Logical operators in conditions‬‬

‫در ﻧﻮﺷﺘﻦ ﺷﺮط ﻫﺎ ﻣﯿﺘﻮاﻧﯿﻢ از ﻋﻤﻠﮕﺮﻫﺎی ﻣﻘﺎﯾﺴﻪ ای و ﻣﻨﻄﻘﯽ و ﺷﻨﺎﺳﺎﯾﯽ و ﻋﻀﻮﯾﺖ اﺳﺘﻔﺎده ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻋﻤﻠﮕﺮﻫﺎی ﻣﻨﻄﻘﯽ ﻣﯿﺘﻮان ﻫﻤﺰﻣﺎن ﭼﻨﺪ ﺷﺮط را ﺑﺮرﺳﯽ ﮐﺮد‪.‬‬ ‫•‬

‫ﻣﺜﺎل اول ﺑﺮﻧﺎﻣﻪ ﺑﺮرﺳﯽ ﻣﯿﮑﻨﺪ ﮐﻪ اﮔﺮ ﺷﺮط اول ‪ True‬ﺑﻮد ﺳﭙﺲ ﺷﺮط دوم ﻧﯿﺰ ‪ True‬ﺑﻮد آﻧﮕﺎه ﻋﻤﻠﯿﺎت ﻣﺪ ﻧﻈﺮ را اﻧﺠﺎم ﻣﯿﺪﻫﺪ‪.‬‬ ‫•‬

‫ﻣﺜﺎل دوم ﺑﺮﻧﺎﻣﻪ ﺗﻨﻬﺎ اﮔﺮ ﯾﮑﯽ از ﺷﺮط ﻫﺎ ‪ True‬ﺑﺎﺷﺪ ﻋﻤﻠﯿﺎت ﺗﻌﺮﯾﻒ ﺷﺪه را اﻧﺠﺎم ﻣﯿﺪﻫﺪ‪.‬‬ ‫•‬

‫ﻣﺜﺎل اول‬ ‫ﻣﺜﺎل دوم‬

 ‫ﺗﺼﻤﯿﻢ ﮔﯿﺮی و ﺷﺮط ﻫﺎ ‪DECISION AND CONDITIONS‬‬ ‫‪Part 8‬‬
‫ﻋﺒﺎرات ﺷﺮﻃﯽ ﮐﻮﺗﺎه ‪Short Hands conditions statements‬‬

‫در ﺻﻮرﺗﯽ ﮐﻪ ﻓﻘﻂ ﯾﮏ ﺷﺮط و ﯾﮏ دﺳﺘﻮر ﺑﺮای اﺟﺮا دارﯾﻢ ﻣﯿﺘﻮاﻧﯿﻢ آن را در ﯾﮏ ﺧﻂ ﺑﻨﻮﯾﺴﯿﻢ‪.‬‬ ‫•‬

‫در ﻋﺒﺎرات ﺷﺮﻃﯽ ﮐﻮﺗﺎه ﺧﺒﺮی از رﻋﺎﯾﺖ ﺗﻮ رﻓﺘﮕﯽ و‪ ...‬ﻧﯿﺴﺖ‪.‬‬ ‫•‬

 ‫ﺗﺼﻤﯿﻢ ﮔﯿﺮی و ﺷﺮط ﻫﺎ ‪DECISION AND CONDITIONS‬‬ ‫‪Part 9‬‬
‫ﻋﺒﺎرات ﺷﺮﻃﯽ ﺗﻮ در ﺗﻮ ‪Nested conditions statements‬‬

‫ﻣﺎ ﻣﯿﺘﻮاﻧﯿﻢ ﻋﺒﺎرات ﺷﺮﻃﯽ را درون دﺳﺘﻮرات ﯾﮏ ﺷﺮط دﯾﮕﺮ اﺳﺘﻔﺎده ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﯾﻌﻨﯽ ﺷﺮط ﺗﻮ در ﺗﻮ‪.‬‬ ‫•‬

‫ﯾﻌﻨﯽ ﺷﺮﻃﯽ ﮐﻪ واﺑﺴﺘﻪ ﺑﻪ ﺷﺮط ﺑﺎﻻﯾﯽ ﺧﻮدش ﺑﺎﺷﺪ‪.‬‬ ‫•‬

‫ﻫﺮ ﻋﺒﺎرت ﺷﺮﻃﯽ دارای ﺑﺨﺶ ﺷﺮوع و اﻧﺘﻬﺎ اﺳﺖ ﮐﻪ ﺑﻪ آن ‪ Block‬ﻣﯿﮕﻮﯾﯿﻢ‪.‬‬ ‫•‬

‫ﺑﻼک ﻫﺎ ﻫﻤﺎن ﻓﺎﺻﻠﻪ ﻫﺎ و ﻣﺤﺘﻮﯾﺎت و دﺳﺘﻮرات درون ﺷﺮط اﺳﺖ‪.‬‬ ‫•‬

‫رﻋﺎﯾﺖ ﺑﻼک ﻫﺎ در دﺳﺘﻮرات ﺷﺮﻃﯽ ﺗﻮ در ﺗﻮ اﻟﺰاﻣﯽ اﺳﺖ‪.‬‬ ‫•‬

‫ﻋﺪم رﻋﺎﯾﺖ و درک ﺑﻼک ﻫﺎی در دﺳﺘﻮرات ﺷﺮﻃﯽ ﺑﺎﻋﺚ ﻣﯿﺸﻮد ﺷﺮط ﻫﺎی ﺑﻪ ﺧﻮﺑﯽ ﺑﺮرﺳﯽ ﻧﺸﻮد و ﮔﺎﻫﺎ ﺑﺮﻧﺎﻣﻪ ﺑﺎ ﺧﻄﺎ ﻣﻮاﺟﻪ ﺷﻮد‪.‬‬ ‫•‬

‫در آﺧﺮ ﺑﻼک ﻫﺮ ﺷﺮط ﻋﻤﻠﯿﺎت آن ﺷﺮط ﻣﺘﻮﻗﻒ ﻣﯿﺸﻮد ﺑﻨﺎﺑﺮاﯾﻦ ﮔﺎﻫﺎ ﻧﯿﺎز دارﯾﻢ ﺷﺮط ﻫﺎی ﺗﻮ در ﺗﻮ و واﺑﺴﺘﻪ ﺑﻪ ﺷﺮط ﻫﺎی دﯾﮕﺮ را ﺑﻨﻮﯾﺴﯿﻢ‬ ‫•‬
 ‫ﺗﺼﻤﯿﻢ ﮔﯿﺮی و ﺷﺮط ﻫﺎ ‪DECISION AND CONDITIONS‬‬ ‫‪Part 10‬‬
‫ﻋﺒﺎرات ﺷﺮﻃﯽ ﺗﻮ در ﺗﻮ ‪Nested conditions statements‬‬

‫ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﻧﻮﺷﺘﻪ ﺷﺪه دﻗﺖ ﮐﻨﯿﺪ‪:‬‬ ‫•‬

‫‪ (1‬اﺑﺘﺪا ﯾﮏ ﻣﺘﻐﯿﯿﺮ ﺑﻪ ﻧﺎم ‪ x‬ﺗﻌﺮﯾﻒ ﮐﺮده اﯾﻢ ﮐﻪ ﻣﻘﺪارش را ‪ ۱۰‬داده اﯾﻢ‪.‬‬

‫‪ (2‬ﺳﭙﺲ ﭼﮏ ﻣﯿﮑﻨﯿﻢ آﯾﺎ ﻣﻘﺪار ﻣﺘﻐﯿﯿﺮ ‪ x‬ﺑﺮاﺑﺮ ‪ ۱۰‬اﺳﺖ؟‬

‫‪ (3‬اﮔﺮ ﺷﺮط ﭘﺎﯾﻪ ‪ True‬ﺑﻮد ﺷﺮط ﻫﺎی داﺧﻠﺶ را ﭼﮏ ﻣﯿﮑﻨﺪ‪.‬‬

‫‪ (4‬آﯾﺎ ‪ x‬از ‪ ۱۵‬ﮐﻮﭼﮑﺘﺮ اﺳﺖ؟‬

‫‪ (5‬ﺧﺐ ﻃﺒﯿﻌﺘﺎ وﻗﺘﯽ ﮐﻪ در ﺷﺮط اول ﺑﺮاﺑﺮ ‪ ۱۰‬ﺑﻮد و ﺷﺮط ‪ True‬ﺷﺪ ﻗﻄﻌﺎ از ‪ ۱۵‬ﻧﯿﺰ ﮐﻮﭼﮑﺘﺮ اﺳﺖ!‬
 ‫ﺗﺼﻤﯿﻢ ﮔﯿﺮی و ﺷﺮط ﻫﺎ ‪DECISION AND CONDITIONS‬‬ ‫‪Part 11‬‬
‫ﻋﺒﺎرات ﺷﺮﻃﯽ ﺗﻮ در ﺗﻮ ‪Nested conditions statements‬‬

‫ﺑﯿﺎﯾﺪ ﭘﺮوژه ﺑﺮﻧﺎﻣﻪ ﻣﺎﺷﯿﻦ ﺣﺴﺎب را ﺑﻪ ﮐﻤﮏ ﻋﺒﺎرات ﺷﺮﻃﯽ ﺗﻮ در ﺗﻮ ﮐﻤﯽ ﺗﮑﻤﯿﻞ ﺗﺮ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫‪ (1‬ﮐﺎرﺑﺮ ﮐﻪ ﻣﻘﺪار اول را وارد ﻣﯿﮑﻨﺪ‪.‬‬

‫‪ (2‬ﺳﭙﺲ ﺑﺎﯾﺪ ﻧﻮع ﻋﻤﻠﮕﺮ ﺣﺴﺎﺑﯽ را از ﮐﺎرﺑﺮ درﯾﺎﻓﺖ ﮐﻨﯿﺪ‪.‬‬

‫‪ (3‬ﺣﺎﻻ ﭼﮏ ﮐﻨﯿﺪ ﮐﻪ ﺑﻪ ﺟﺎی ﻋﻤﻠﮕﺮ ﻣﻘﺪار ﺧﺎﻟﯽ وارد ﻧﮑﻨﺪ‪.‬‬

‫‪ (4‬در ﺻﻮرت ﺧﺎﻟﯽ ﻧﺒﻮدن ﻣﻘﺪار ﻋﻤﻠﮕﺮ ﺑﻘﯿﻪ ﻋﻤﻠﯿﺎت ﺣﺴﺎب اﻧﺠﺎم ﺷﻮد!‬

‫‪ ü‬در ﺑﺨﺶ ﻫﺎی ﺑﻌﺪی ﺧﺎﻟﯽ ﻧﺒﻮدن ﻣﻘﺪار ﺧﻮد ﻋﻤﻠﻮﻧﺪ ﻫﺎ ﻧﯿﺰ ﭼﮏ ﻣﯿﮑﻨﯿﻢ و ﭘﺮوژه را ﮐﺎﻣﻞ ﺗﺮ ﻣﯿﮑﻨﯿﻢ‪.‬‬
‫ﭘﺮوژه ﺑﺮرﺳﯽ دﻣﺎ در ﻣﺤﯿﻂ ‪CMD/SHELL/TERMINAL‬‬

‫ﺑﻪ ﮐﻤﮏ ﻋﻤﻠﮕﺮ ﻫﺎ و ﻋﺒﺎرات ﺷﺮﻃﯽ ﻣﯿﺘﻮاﻧﯿﻢ ﺧﯿﻠﯽ ﺳﺎده دﻣﺎی ﻫﻮا را ﺑﺮرﺳﯽ ﮐﻨﯿﻢ‬ ‫•‬

‫‪ (1‬ﻣﻘﺪار دﻣﺎی ﻫﻮا ﺑﺮ اﺳﺎس درﺟﻪ ﺳﻠﺴﯿﻮس از ﮐﺎرﺑﺮ ﺑﮕﯿﺮﯾﺪ‪.‬‬

‫‪ (2‬ﺑﺮرﺳﯽ ﮐﻨﯿﺪ ﮐﻪ ﺧﺎﻟﯽ وارد ﻧﮑﻨﺪ‪.‬‬

‫‪ (3‬اﮔﺮ ﺧﺎﻟﯽ وارد ﮐﺮده ﺑﻮد ﺧﻄﺎ ﺑﺪﻫﺪ و ﺑﮕﻮﯾﯿﺪ ﻟﻄﻔﺎ ﻣﻘﺪار را ﺑﺮ اﺳﺎس درﺟﻪ وارد ﮐﻨﯿﺪ‪.‬‬

‫‪ (4‬در ﺻﻮرت ﻋﺪم ﺧﺎﻟﯽ ﻧﺒﻮدن ورودی ﺣﺎﻻ ﭼﮏ ﮐﻨﺪ وﺿﻌﯿﺖ ﮐﯿﻔﯽ ﻫﻮا را‪.‬‬
 ‫ﺣﻠﻘﻪ ﻫﺎ ‪LOOPS‬‬ ‫‪Part 1‬‬

‫ﯾﮑﯽ از اﺟﺰای ﭘﺎﯾﻪ در اﮐﺜﺮ زﺑﺎن ﻫﺎی ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ اﺳﺖ‪.‬‬ ‫•‬

‫ﺑﺮای ﺗﮑﺮار ﯾﮏ ﺳﺮی ﻋﻤﻠﯿﺎت ﺗﻌﺮﯾﻒ ﺷﺪه ﺗﻮﺳﻂ ﺑﺮﻧﻤﻪ ﻧﻮﯾﺲ اﺳﺘﻔﺎده ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫دارای دو ﻧﻮع ﻧﺎ ﻣﻌﯿﯿﻦ و ﻣﻌﯿﻦ ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫ﻣﯿﺘﻮان ﺑﺮای آن ﻫﺎ ﺷﺮط و ﺗﻌﺪاد ﺗﮑﺮار ﻋﻤﻠﯿﺎت ﺗﻌﺮﯾﻒ ﮐﺮد‪.‬‬ ‫•‬

‫در ﻧﻮع ﻧﺎ ﻣﻌﯿﯿﻦ )‪ (while‬ﮐﺎر ﻫﺎ ﺗﮑﺮار ﻣﯿﺸﻮﻧﺪ ﺗﺎ زﻣﺎﻧﯽ ﮐﻪ ﺷﺮط آن ‪ False‬ﺷﻮد‪.‬‬ ‫•‬

‫در ﻧﻮع ﻣﻌﯿﯿﻦ )‪ (for‬ﮐﺎر ﻫﺎی ﺑﺮ اﺳﺎس ﺗﻌﺪادی ﮐﻪ ﻣﺎ ﺗﻌﺮﯾﻒ ﮐﺮده اﯾﻢ ﺗﮑﺮار ﻣﯿﺸﻮد‪.‬‬ ‫•‬
‫‪while loops‬‬ ‫ﺣﻠﻘﻪ ﻫﺎ ‪LOOPS‬‬ ‫‪Part 2‬‬

‫ﺣﻠﻘﻪ ‪ while‬ﺑﺮای اﺟﺮای ﻣﮑﺮر ﯾﮏ ﺑﻠﻮک از دﺳﺘﻮرات ﺗﺎ زﻣﺎﻧﯽ ﮐﻪ ﯾﮏ ﺷﺮط داده ﺷﺪه ﺑﺮآورده ﺷﻮد‪ ،‬اﺳﺘﻔﺎده ﻣﯽ ﺷﻮد‪.‬‬ ‫•‬

‫وﻗﺘﯽ ﺷﺮط ‪ False‬ﺷﺪ ﺑﻼﻓﺎﺻﻠﻪ ﺧﻄﻮط ﺑﻌﺪی ﺧﺎرج از ﺑﻼک ﺣﻠﻘﻪ در ﺑﺮﻧﺎﻣﻪ اﺟﺮا ﻣﯽ ﺷﻮد‪.‬‬ ‫•‬

‫ﺳﺎﺧﺘﺎر ﺣﻠﻘﻪ ‪:while‬‬ ‫•‬

‫‪ (1‬ﮐﻠﻤﻪ ﮐﻠﯿﺪی ‪ while‬را ﻣﯿﻨﻮﯾﺴﯿﻢ‪.‬‬

‫‪ (2‬ﺷﺮط ﺗﮑﺮار ﺣﻠﻘﻪ را ﺑﺎ ﯾﮏ ﻓﺎﺻﻠﻪ ﺑﻌﺪ از ‪ while‬ﻣﯿﻨﻮﯾﺴﯿﻢ و در اﻧﺘﻬﺎی ﺷﺮط ﻣﯿﺒﺎﺳﺖ ﻋﻼﻣﺖ دو ﻧﻘﻄﻪ )‪ (:‬ﻗﺮار دﻫﯿﻢ‪.‬‬

‫‪ (3‬ﺗﺎ زﻣﺎﻧﯽ ﮐﻪ ﺷﺮط ﺑﺮﻗﺮار ﺑﺎﺷﺪ ﻋﻤﻠﯿﺎت‪/‬ﮐﺎرﻫﺎ‪ /‬دﺳﺘﻮرات داﺧﻞ ﺣﻠﻘﻪ اﺟﺮا ﻣﯿﺸﻮد‪.‬‬

‫‪ (4‬رﻋﺎﯾﺖ ﺗﻮرﻓﺘﮕﯽ ‪ Indention‬دﻗﯿﻘﺎ ﻣﺸﺎﺑﻪ ﻋﺒﺎرات ﺷﺮﻃﯽ اﻟﺰاﻣﯽ ﻣﯿﺒﺎﺷﺪ‪.‬‬

‫‪while loops‬‬ ‫ﺣﻠﻘﻪ ﻫﺎ ‪LOOPS‬‬ ‫‪Part 3‬‬

‫ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﻣﻘﺎﺑﻞ دﻗﺖ ﮐﻨﯿﺪ‪:‬‬ ‫•‬

‫‪ (1‬اﺑﺘﺪا ﯾﮏ ﻣﺘﻐﯿﯿﺮ ﺑﺎ ﻧﺎم ‪ x‬و ﻣﻘﺪار ‪ 0‬ﺗﻌﺮﯾﻒ ﮐﺮده اﯾﻢ‪.‬‬

‫‪ (2‬ﺳﭙﺲ در ﺷﺮط ﺣﻠﻘﻪ ﮔﻔﺘﻪ اﯾﻢ ﺗﺎ زﻣﺎﻧﯽ ﮐﻪ ‪ x‬از ‪ 3‬ﮐﻮﭼﮑﺘﺮ اﺳﺖ ﻋﻤﻠﯿﺎت زﯾﺮ را اﻧﺠﺎم ﺑﺪه‪:‬‬

‫‪ (3‬در ﻫﺮ ﻣﺮﺣﻠﻪ ‪ 1‬واﺣﺪ ﺑﻪ ‪ X‬اﺿﺎﻓﻪ ﻣﯿﺸﻮد‪) .‬ﺑﻪ اﯾﻦ ﻧﻮع ﻋﻤﻠﯿﺎت ‪ / counter‬ﺷﻤﺎرﻧﺪه ﻣﯿﮕﻮﯾﻨﺪ(‬

‫‪ (4‬ﭘﺮﯾﻨﺖ ﻣﯿﮑﻨﺪ !‪Hello‬‬

‫‪ (5‬زﻣﺎﻧﯽ ﮐﻪ ﻣﻘﺪار ‪ X‬ﺑﺮاﺑﺮ ‪ 3‬ﺷﻮد ﺣﻠﻘﻪ ﻣﯽ اﯾﺴﺘﺪ‪.‬‬

‫ﺣﺎﻻ ﺑﺮﻧﺎﻣﻪ ﻣﻘﺎﺑﻞ را ﺑﻨﻮﯾﺴﯿﺪ و ﺧﺮوﺟﯽ را ﻣﺸﺎﻫﺪه ﮐﻨﯿﺪ و دﻻﯾﻞ آن را ﺷﺮح دﻫﯿﺪ‪.‬‬ ‫•‬

‫ﺑﻪ اﯾﻦ ﻧﻮع ﺣﻠﻘﻪ ﻫﺎ ‪ infinite loops‬ﯾﺎ ‪ unlimited loops‬ﻣﯿﮕﻮﯾﻨﺪ‪.‬‬ ‫•‬

‫‪Single statement while block‬‬ ‫ﺣﻠﻘﻪ ﻫﺎ ‪LOOPS‬‬ ‫‪Part 4‬‬

‫ﻣﺸﺎﺑﻪ ﻋﺒﺎرات ﺷﺮﻃﯽ ﮐﻮﺗﺎه ﻣﯿﺘﻮان از ﺣﻠﻘﻪ ﺗﮑﺮار ﻧﺎﻣﻌﯿﯿﻦ ﻧﯿﺰ ﺑﻪ ﺻﻮرت ﮐﻮﺗﺎه اﺳﺘﻔﺎده ﮐﺮد‪.‬‬ ‫•‬

‫ﭘﯿﺸﻨﻬﺎد ﻣﯽ ﺷﻮد از اﯾﻦ ﻧﻮع ﺣﻠﻘﻪ ﻫﺎ اﺳﺘﻔﺎده ﻧﮑﻨﯿﺪ زﯾﺮا اﯾﻦ ﯾﮏ ﺣﻠﻘﻪ ﺑﯽ ﻧﻬﺎﯾﺖ ﺑﯽ ﭘﺎﯾﺎن اﺳﺖ ﮐﻪ در آن ﺷﺮط ﻫﻤﯿﺸﻪ درﺳﺖ اﺳﺖ و ﺑﺎﯾﺪ‬ ‫•‬

‫ﺑﺮﻧﺎﻣﻪ را ﺑﻪ زور ﺧﺎﺗﻤﻪ دﻫﯿﺪ‪.‬‬

‫‪else statement in while‬‬ ‫ﺣﻠﻘﻪ ﻫﺎ ‪LOOPS‬‬ ‫‪Part 5‬‬

‫از ﻋﺒﺎرات ﺷﺮﻃﯽ ‪ else‬ﻧﯿﺰ در ﺣﻠﻘﻪ ‪ while‬ﻣﯿﺘﻮان اﺳﺘﻔﺎده ﮐﺮد‪.‬‬ ‫•‬

‫ﻋﻤﻠﮑﺮدش ﺑﺪﯾﻦ ﺻﻮرت اﺳﺖ‪:‬‬ ‫•‬

‫در ﺻﻮرﺗﯽ ﮐﻪ ﺷﺮط ﺣﻠﻘﻪ ‪ False‬ﺷﻮد دﺳﺘﻮرات داﺧﻞ ﺑﻼک ‪ else‬اﺟﺮا ﻣﯿﺸﻮد‪.‬‬ ‫•‬
 ‫ﺣﻠﻘﻪ ﻫﺎ ‪LOOPS‬‬ ‫‪Part 6‬‬

‫ﭘﺮوژه ﺗﺸﺨﯿﺺ دﻣﺎ را ﺑﻪ ﮐﻤﮏ ﺣﻠﻘﻪ ‪ while‬ﻃﻮری ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ‪:‬‬ ‫•‬

‫‪ (1‬ﺗﺎ زﻣﺎﻧﯽ ﮐﻪ ﮐﺎرﺑﺮ ﺧﺎﻟﯽ وارد ﮐﻨﺪ داﺋﻤﺎ ﻣﻘﺪار دﻣﺎ را از او ﺑﺨﻮاﻫﺪ و از ﺑﺮﻧﺎﻣﻪ ﺧﺎرج ﻧﺸﻮد‪.‬‬

‫‪ (2‬اﮔﺮ ﻣﻘﺪار ورودی ﺧﺎﻟﯽ ﻧﺒﻮد ﻣﻘﺪار درﯾﺎﻓﺖ ﺷﺪه را ﺗﺒﺪﯾﻞ ﺑﻪ ﻧﻮع ﻋﺪدی ﮐﻨﺪ‪.‬‬

‫‪ (3‬ﺳﭙﺲ وﺿﻌﯿﺖ ﺳﺮدی و ﮔﺮﻣﯽ و ﻧﺮﻣﺎل ﺑﻮدن ﻫﻮا را ﺑﺮرﺳﯽ ﮐﻨﺪ‪.‬‬

‫‪Recognize even and odd numbers with while‬‬ ‫ﺣﻠﻘﻪ ﻫﺎ ‪LOOPS‬‬ ‫‪Part 7‬‬

‫ﺑﻪ ﮐﻤﮏ ﺣﻠﻘﻪ ‪ while‬اﻋﺪاد زوج و ﻓﺮد ﺑﯿﻦ ‪ ۰‬ﺗﺎ ‪ ۱۰۰‬را ﭘﯿﺪا ﮐﻨﯿﻢ‪:‬‬ ‫•‬

‫‪ (1‬ﺑﺎزه ﺟﺴﺘﺠﻮ و ﺷﻤﺎرﻧﺪه را ﻧﯿﺎز دارﯾﻢ‬

‫‪ (2‬ﺳﭙﺲ درون ﺣﻠﻘﻪ ﺷﺮﻃﯽ ﻣﯿﻨﻮﯾﺴﻢ ﻫﺮ ﺑﺎر ﭼﮏ ﮐﻨﺪ آﯾﺎ ﻋﺪد زﻣﺎﻧﯽ ﮐﻪ ﺑﺮ ‪ ۲‬ﺗﻘﺴﯿﻢ ﺷﻮد ﺑﺎﻗﯽ ﻣﺎﻧﺪه ‪ ۰‬ﻣﯿﺸﻮد؟ )ﺷﺮط ﺑﺮرﺳﯽ اﻋﺪاد زوج(‬

‫‪ (3‬در ﺻﻮرﺗﯽ ﮐﻪ ﺑﺎﻗﯽ ‪ ۰‬ﻧﺸﻮد ﻋﺪد ﻓﺮد اﺳﺖ‪.‬‬

‫ﺗﺸﺨﯿﺺ اﻋﺪاد زوج در ﺑﺎزه ‪ ۰‬ﺗﺎ ‪۱۰۰‬‬ ‫ﺗﺸﺨﯿﺺ اﻋﺪاد ﻓﺮد در ﺑﺎزه ‪ ۰‬ﺗﺎ ‪۱۰۰‬‬
 ‫ﺣﻠﻘﻪ ﻫﺎ ‪LOOPS‬‬ ‫‪Part 8‬‬

‫• ﭘﺮوژه ﺗﺸﺨﯿﺺ رﻣﺰ ﻋﺒﻮر‪:‬‬

‫‪ (1‬اﺑﺘﺪا رﻣﺰ ﻋﺒﻮر را در ﯾﮏ ﻣﺘﻐﯿﯿﺮ ﻧﮕﻪ داری ﻣﯿﮑﻨﯿﻢ‪.‬‬

‫‪ (2‬ﺳﭙﺲ ﯾﮏ ﻣﺘﻐﯿﯿﺮ ﺑﺮای ﻧﮕﻪ داری ﺗﻌﺪاد دﻓﻌﺎت اﺷﺘﺒﺎه ﺑﺎ ﻣﻘﺪار ‪ ۰‬ﺗﻌﺮﯾﻒ ﻣﯿﮑﻨﯿﻢ‪.‬‬

‫‪ (3‬از ﮐﺎرﺑﺮ رﻣﺰ ﻋﺒﻮر را ﻣﯿﺨﻮاﻫﯿﻢ‪.‬‬

‫‪ (4‬در ﺻﻮرﺗﯽ ﮐﻪ اﺷﺘﺒﺎه وارد ﮐﺮد اﺑﺘﺪا ﺑﻪ اون ﺧﻄﺎ ﺑﺪﻫﺪ و ﻣﺘﻐﯿﯿﺮ ﺗﻌﺪاد اﺷﺘﺒﺎه را ‪ ۱‬واﺣﺪ اﺿﺎﻓﻪ ﮐﻨﺪ‪.‬‬

‫‪ (5‬ﺳﭙﺲ ﺑﺮرﺳﯽ ﺷﻮد ﮐﻪ ﺗﻌﺪاد اﺷﺘﺒﺎه ﺑﻪ ‪ ۳‬رﺳﯿﺪه اﺳﺖ ﯾﺎ ﺧﯿﺮ در ﺻﻮرﺗﯽ ﮐﻪ اﯾﻦ ﺷﺮط ‪ True‬ﺑﺎﺷﺪ ﺧﻄﺎ ﺑﺪﻫﺪ و ﺑﺮﻧﺎﻣﻪ ﺑﺴﺘﻪ ﺷﻮد‪.‬‬

‫‪ (6‬در ﺻﻮرﺗﯽ ﮐﻪ ﮔﺬرواژه ﺻﺤﯿﺢ ﺑﻮد ﭘﯿﺎم ‪ Welcome‬ﺑﺪﻫﺪ‪.‬‬

‫‪For loops‬‬ ‫ﺣﻠﻘﻪ ﻫﺎ ‪LOOPS‬‬ ‫‪Part 9‬‬

‫• ﺣﻠﻘﻪ ﺗﮑﺮار ﻣﻌﯿﻦ ‪:for‬‬

‫ﺟﻬﺖ اﺳﺘﻔﺎده از اﯾﻦ ﻧﻮع ﺣﻠﻘﻪ از ﮐﻠﻤﻪ ﮐﻠﯿﺪی ‪ for‬و ‪ in‬اﺳﺘﻔﺎده ﻣﯿﮑﻨﯿﻢ‪.‬‬ ‫•‬

‫در ﺻﻮرﺗﯽ ﮐﻪ ﻣﺪ ﻧﻈﺮ داﺷﺘﻪ دﺳﺘﻮرات را ﺑﻪ ﺗﻌﺪاد ﻣﺤﺪودی اﺟﺮا ﮐﻨﯿﻢ از ﺣﻠﻘﻪ ‪ for‬اﺳﺘﻔﺎده ﻣﯿﮑﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺷﺮط در ﺣﻠﻘﻪ ‪ for‬ﺗﻌﺪاد ﺗﮑﺮار اﺳﺖ‪.‬‬ ‫•‬

‫ﺑﺮ ﺧﻼف ‪ while‬ﮐﻪ زﻣﺎﻧﯽ ﺷﺮط ‪ True‬ﺑﺎﺷﺪ ﻋﻤﻠﯿﺎت را ﺗﮑﺮار ﻣﯿﮑﻨﺪ‪.‬‬ ‫•‬

‫ﺑﻪ ﺟﺰ ﺗﻌﺪاد ﺗﮑﺮار ﻣﯿﺘﻮاﻧﯿﻢ در ﻋﺒﺎرات دﻧﺒﺎﻟﻪ دار)‪ (String,List,Tuple,etc‬ﭼﺮﺧﺶ ﺑﺰﻧﯿﻢ‪.‬‬ ‫•‬

‫در ﺣﻠﻘﻪ ‪ for‬ﻧﯿﺎز دارﯾﻢ ﯾﮏ ﻣﺘﻐﯿﯿﺮ ﭘﺎﯾﻪ و ﺳﭙﺲ ﺑﺮ اﺳﺎس ﭼﯿﺰی ﮐﻪ ﻗﺼﺪ دارﯾﻢ ﺣﻠﻘﻪ ﺑﺰﻧﯿﻢ ﺗﻌﺮﯾﻒ ﮐﻨﯿﻢ‪.‬‬ ‫•‬
 ‫‪The range() Function in For loops‬‬ ‫ﺣﻠﻘﻪ ﻫﺎ ‪LOOPS‬‬ ‫‪Part 10‬‬

‫ﺗﺎﺑﻊ ‪: range‬‬ ‫•‬

‫اﯾﻦ ﺗﺎﺑﻊ دﻧﺒﺎﻟﻪ ای از اﻋﺪاد را در ﺑﺮ ﻣﯿﮕﯿﺮﯾﺪ و ﺑﻪ ﻃﻮر ﭘﯿﺶ ﻓﺮض از ‪ ۰‬ﺷﺮوع ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ اﯾﻦ ﺗﺎﺑﻊ ﻣﯿﺘﻮاﻧﯿﻢ ﺑﮕﻮﯾﯿﻢ ﮐﻪ ﺣﻠﻘﻪ ﻣﺎ در ﭼﻪ ﺑﺎزه ﯾﺎ داﻣﻨﻪ از اﻋﺪاد ﮐﺎر ﮐﻨﺪ‪.‬‬ ‫•‬

‫در ﻣﺜﺎل ﻣﻘﺎﺑﻞ اﻋﺪاد ﺑﯿﻦ ‪ ۰‬ﺗﺎ ‪ ۱۰۰‬را ﺑﻪ ﮐﻤﮏ ﺣﻠﻘﻪ ‪ for‬و ﺗﺎﺑﻊ ‪ range‬ﻧﻤﺎﯾﺶ ﻣﯿﺪﻫﯿﻢ‪.‬‬ ‫•‬

‫در ﺻﻮرﺗﯽ دو آرﮔﻮﻣﺎن ﺑﻪ ﺗﺎﺑﻊ ‪ range‬ﺑﺪﻫﯿﻢ اﯾﻦ ﺗﺎﺑﻊ ﺑﺎزه را ﺑﯿﻦ دو ﻋﺪدی ﮐﻪ ﺗﻌﺮﯾﻒ ﮐﺮدﯾﻢ در ﻧﻈﺮ ﻣﯿﮕﯿﺮﯾﺪ‪.‬‬ ‫•‬

‫ﺗﺎﺑﻊ ‪ range‬ﻣﯿﺘﻮاﻧﺪ ﺳﻪ آرﮔﻮﻣﺎن ﻧﯿﺰ داﺷﺘﻪ ﺑﺎﺷﺪ‪ .‬آرﮔﻮﻣﺎن اول و دوم ﺑﺎزه ﻫﺴﺘﻨﺪ و آرﮔﻮﻣﺎن ﺳﻮم ﺗﻌﺪاد ﭘﺮش اﺳﺖ‪ .‬ﯾﻌﻨﯽ ﺑﯿﻦ ﺑﺎزه ﺗﻌﺮﯾﻒ‬ ‫•‬

‫ﺷﺪه ﭼﻨﺪ ﻋﺪد ﭼﻨﺪ ﻋﺪد ﭘﺮش داﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬

‫اﻋﺪاد ﺑﯿﻦ ‪ ۵۰‬ﺗﺎ ‪۵۰۰‬‬ ‫اﻋﺪاد ﺑﯿﻦ ‪ ۲‬ﺗﺎ ‪ ۳۰‬ﺑﺎ ﺟﻬﺶ ‪ ۳‬ﺗﺎﯾﯽ‬
 ‫‪for loops structure‬‬ ‫ﺣﻠﻘﻪ ﻫﺎ ‪LOOPS‬‬ ‫‪Part 11‬‬

‫ﻧﺤﻮه ﻋﻤﻠﮑﺮد و ﺳﺎﺧﺘﺎر ﺣﻠﻘﻪ ‪:for‬‬ ‫•‬

‫ﻫﻤﺎﻧﻄﻮر ﮐﻪ در ﺑﺨﺶ ﻣﺘﻮﺟﻪ ﺷﺪﯾﺪ ﺑﺮای اﺳﺘﻔﺎده از اﯾﻦ ﻧﻮع ﺣﻠﻘﻪ ﻧﯿﺎز ﺑﻪ ﯾﮏ ﻣﺘﻐﯿﯿﺮ ﭘﺎﯾﻪ دارﯾﻢ و ﮐﻠﻤﻪ ﮐﻠﯿﺪی ‪ in‬ﺳﭙﺲ در آن ﭼﯿﺰی ﮐﻪ‬ ‫•‬

‫ﻗﺼﺪ دارﯾﻢ ﺣﻠﻘﻪ ﺑﺰﻧﯿﻢ ﺗﻌﺮﯾﻒ ﮐﻨﯿﻢ‪.‬‬

‫در ﻫﺮ ﺑﺎر اﺟﺮا ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺗﻌﺪاد ﭼﺮﺧﺶ ﺣﻠﻘﻪ ﻫﺮ ﺑﺎر ﻣﻘﺪار ﻣﺘﻐﯿﯿﺮ ﭘﺎﯾﻪ ﺗﻐﯿﯿﺮ ﻣﯿﮑﻨﺪ و ﻫﻢ ﺑﻪ ﻋﻨﻮان ﺷﻤﺎرﻧﺪه ﻋﻤﻞ ﻣﯿﮑﻨﺪ ﻫﻢ ﻣﻘﺎدﯾﺮ ﺣﻠﻘﻪ‬ ‫•‬

‫را درون ﺧﻮد ذﺧﯿﺮه ﻣﯿﮑﻨﺪ‬

‫ﻣﺘﻐﯿﯿﺮ ﭘﺎﯾﻪ و ﺷﻤﺎرﻧﺪه ﻫﺮ ﺑﺎر ‪ ۱ +‬ﻣﯿﺸﻮد‬

‫ﺗﻌﺪاد ﭼﺮﺧﺸﯽ ﮐﻪ ﻣﺪ ﻧﻈﺮ دارﯾﻢ‬

‫‪for x in range(10):‬‬
‫)‪print(x‬‬ ‫در ﻫﺮ ﺑﺎر ﭼﺮﺧﺶ ﻣﻘﺪارش ﺑﺎ ﺗﻮﺣﻪ ﺑﻪ ﺗﻌﺪاد ﻣﺪ ﻧﻈﺮ ﻫﺮ ﺳﺮی ‪ ۱ +‬ﻣﯿﺸﻮد و ﭼﺎپ ﻣﯿﺸﻮد‬
‫‪else in for loops‬‬ ‫ﺣﻠﻘﻪ ﻫﺎ ‪LOOPS‬‬ ‫‪Part 12‬‬

‫ﻋﺒﺎرات ﺷﺮﻃﯽ ‪ else‬در ﺣﻠﻘﻪ ‪:for‬‬ ‫•‬

‫از اﯾﻦ ﻋﺒﺎرت ﻧﯿﺰ ﻣﯿﺘﻮان در ﺣﻠﻘﻪ ‪ for‬اﺳﺘﻔﺎده ﮐﺮد‪.‬‬ ‫•‬

‫ﻋﻤﻠﮑﺮدش ﻣﺎﻧﻨﺪ اﺳﺘﻔﺎده در ‪ while‬ﻧﯿﺴﺖ و ﺑﺮای ﺧﻼف ﺷﺮط ﻧﯿﺴﺖ‪.‬‬ ‫•‬

‫ﺑﻠﮑﻪ ﻣﯿﺘﻮان در اﻧﺘﻬﺎی ﺣﻠﻘﻪ و ﭘﺲ از اﺟﺮای ﮐﺎﻣﻞ ﺣﻠﻘﻪ و اﺗﻤﺎم آن ﻣﯿﺘﻮان ﺑﺎ ﻋﺒﺎرت ‪ else‬ﺑﮕﻮﯾﯿﻢ ﭼﮑﺎری اﻧﺠﺎم دﻫﺪ‪.‬‬ ‫•‬
 Control statement in loops LOOPS ‫ﺣﻠﻘﻪ ﻫﺎ‬ Part 13

.‫در ﺣﻠﻘﻪ ﻫﺎ از ﯾﮏ ﺳﺮی ﻋﺒﺎرات ﺟﻬﺖ ﮐﻨﺘﺮل ﺣﻠﻘﻪ اﺳﺘﻔﺎده ﮐﺮد‬ •

:‫ﻋﺒﺎرات ﮐﻨﺘﺮﻟﯽ در ﭘﺎﯾﺘﻮن‬ •

Control statements Description
Break statement in Python is used to bring the control out of the loop when
break some external condition is triggered. Break statement is put inside the loop
body (generally after if condition).
The pass statement is a null statement. But the difference between pass and
pass comment is that comment is ignored by the interpreter whereas pass is not
ignored.
Continue statement is a loop control statement that forces to
execute the next iteration of the loop while skipping the rest
of the code inside the loop for the current iteration only i.e.
continue when the continue statement is executed in the loop, the
code inside the loop following the continue statement will be
skipped for the current iteration and the next iteration of the
loop will begin.
‫‪break statement in loops‬‬ ‫ﺣﻠﻘﻪ ﻫﺎ ‪LOOPS‬‬ ‫‪Part 14‬‬

‫ﻋﻤﻠﮑﺮد اﯾﻦ ﻋﺒﺎرت ﺑﻪ اﯾﻦ ﺷﮑﻞ اﺳﺖ ﮐﻪ ﺣﻠﻘﻪ را ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺷﺮاﯾﻄﯽ ﮐﻪ ﺗﻌﺮﯾﻒ ﻣﯿﮑﻨﯿﻢ ﻣﺘﻮﻗﻒ ﻣﯿﮑﻨﺪ‪.‬‬ ‫•‬

‫ﻣﺜﺎل‪:‬‬ ‫•‬

‫اﮔﺮ در ﻣﺘﻐﯿﯿﺮ ‪ name‬ﺣﺮف ‪ m‬را ﭘﯿﺪا ﮐﺮدی ﻣﺘﻮﻗﻒ ﺷﻮ و ﺣﻠﻘﻪ اداﻣﻪ ﭘﯿﺪا ﻧﮑﻨﺪ‪.‬‬ ‫•‬
‫‪pass statement in loops‬‬ ‫ﺣﻠﻘﻪ ﻫﺎ ‪LOOPS‬‬ ‫‪Part 15‬‬

‫اﯾﻦ ﻋﺒﺎرت ﻋﻤﻠﯿﺎت ﺧﺎﺻﯽ اﻧﺠﺎم ﻧﻤﯿﺪﻫﺪ‪.‬‬ ‫•‬

‫اﻣﺎ ﺑﺎ ﮐﺎﻣﻨﺖ ﮔﺬاری ﻣﺘﻔﺎوت اﺳﺖ‪.‬‬ ‫•‬

‫از اﯾﻦ ﻋﺒﺎرات ﺟﻬﺖ ﺗﺴﺖ ﺣﻠﻘﻪ و‪ ...‬اﺳﺘﻔﺎده ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫‪continue statement in loops‬‬ ‫ﺣﻠﻘﻪ ﻫﺎ ‪LOOPS‬‬ ‫‪Part 16‬‬

‫ﺑﺮ ﺧﻼف ‪ break‬زﻣﺎﻧﯽ ﮐﻪ ﺷﺮط ﺧﺎﺻﯽ ‪ True‬ﺷﻮد اداﻣﻪ ﻣﯿﺪﻫﺪ و دﺳﺘﻮرات ﺑﻌﺪی اﺟﺮا ﻣﯿﺸﻮد‪.‬‬ ‫•‬
‫‪Nested Loops‬‬ ‫ﺣﻠﻘﻪ ﻫﺎ ‪LOOPS‬‬ ‫‪Part 17‬‬

‫دﻗﯿﻘﺎ ﻣﺸﺎﺑﻪ ﺷﺮط ﻫﺎی ﺗﻮ در ﺗﻮ از ﺣﻠﻘﻪ ﻫﺎ ﻧﯿﺰ ﺑﻪ ﺷﮑﻞ ﺗﻮ در ﺗﻮ ﻣﯿﺘﻮان اﺳﺘﻔﺎده ﮐﺮد‪.‬‬ ‫•‬

‫زﻣﺎﻧﯽ ﮐﻪ ﻣﻘﺪار ﺷﻤﺎرﻧﺪه ﺣﻠﻘﻪ اول ‪ ۱‬ﻣﯿﺸﻮد ﺣﻠﻘﻪ زﯾﺮﯾﻦ ﺑﻪ ﺻﻮرت ﮐﺎﻣﻞ اﺟﺮا ﻣﯿﺸﻮد‬ ‫•‬

‫ﺳﭙﺲ دوﺑﺎره ﺑﺮ ﻣﯿﮕﺮدد ﺑﻪ ﺣﻠﻘﻪ ﺑﺎﻻﯾﯽ و ﻣﻘﺪار ﺑﺎﻻﯾﯽ ‪ ۲‬ﻣﯿﺸﻮد و ﻣﺠﺪدا ﺣﻠﻘﻪ زﯾﺮﯾﻦ ﯾﮑﺒﺎر دﯾﮕﺮ ﮐﺎﻣﻞ اﺟﺮا ﻣﯿﺸﻮد‬ ‫•‬

‫ﺗﺎ زﻣﺎﻧﯽ ﮐﻪ ﺣﻠﻘﻪ ﺑﺎﻻﯾﯽ ﺑﻪ ﭘﺎﯾﺎن ﻧﺮﺳﯿﺪ ﺣﻠﻘﻪ دروﻧﯽ داﺋﻢ اﺟﺮا ﻣﯿﺸﻮد‪.‬‬ ‫•‬
‫ﺟﺪول ﺿﺮب ﺑﻪ ﮐﻤﮏ ‪Nested Loops‬‬ ‫ﺣﻠﻘﻪ ﻫﺎ ‪LOOPS‬‬ ‫‪Part 18‬‬

‫‪ (1‬در ﺣﻠﻘﻪ اول اﺑﺘﺪا ﻣﻘﺪار ‪ ۱ i‬ﻣﯿﺸﻮد‪.‬‬

‫‪ (2‬ﺳﭙﺲ در ﺣﻠﻘﻪ زﯾﺮ از ‪ ۱‬ﺗﺎ ‪ ۱۰‬ﻣﯿﺸﻮد ﻣﻘﺪار ﻣﺘﻐﯿﯿﺮ‪.‬‬

‫‪ (3‬ﺳﭙﺲ ﻣﻘﺪار ‪ i‬در ‪ x‬ﺿﺮب ﻣﯿﺸﻮد‪.‬‬

‫‪ (4‬دوﺑﺎره ﺑﻪ ﺣﻠﻘﻪ اول ﺑﺮﻣﯿﮕﺮدد و ﻣﺮاﺣﻞ از اﺑﺘﺪا اﺟﺮا ﻣﯿﺸﻮد ﺗﺎ زﻣﺎﻧﯽ ﮐﻪ ﺑﺎزه ﺣﻠﻘﻪ اول ﺑﻪ اﻧﺘﻬﺎ ﺑﺮﺳﺪ‪.‬‬
‫ﺟﺰﺋﯿﺎت رﺷﺘﻪ ﻫﺎی ﻣﺘﻨﯽ ‪String‬‬ ‫‪STRINGS‬‬ ‫‪Part 2‬‬

‫در ﺑﺨﺶ ﭘﻨﭽﻢ ﻣﺘﻐﯿﯿﺮ ﻫﺎ ﺑﺎ ﻋﺒﺎرات رﺷﺘﻪ ای آﺷﻨﺎ ﺷﺪﯾﻢ‪.‬‬ ‫•‬

‫ﺑﺎ ﻧﺤﻮه ﺗﻌﺮﯾﻒ و ﻧﺤﻮه اﺳﺘﻔﺎده از آﻧﻬﺎ ﻧﯿﺰ آﺷﻨﺎ ﺷﺪﯾﻢ‪.‬‬ ‫•‬

‫اﻣﺎ ﭼﻨﺪ وﯾﮋﮔﯽ ﻣﻬﻢ دﯾﮕﺮ از رﺷﺘﻪ ﻫﺎ‪:‬‬ ‫•‬

‫‪ (1‬رﺷﺘﻪ ﻫﺎی ﻣﺘﻨﯽ )‪ (strings‬ﺟﺰ داده ﻫﺎی دﻧﺒﺎﻟﻪ دار ﻫﺴﺘﻨﺪ‪.‬‬

‫‪ (2‬ﯾﻌﻨﯽ از ﭼﻨﺪ ﺑﺨﺶ ﯾﺎ ﭼﻨﺪ ﮐﺎراﮐﺘﺮ اﯾﺠﺎد ﺷﺪه اﻧﺪ‪.‬‬

‫‪ (3‬ﺳﺎﺧﺘﺎر آﻧﻬﺎ ﻣﺸﺎﺑﻪ ﻟﯿﺴﺖ ﻫﺎ اﺳﺖ‪.‬‬

‫‪ (4‬ﺑﻪ ﮐﻤﮏ ﻋﻼﻣﺖ ﺑﺮاﮐﺖ ] [ ﻣﯿﺘﻮان ﺑﻪ ﺗﮏ ﺗﮏ ﻋﻨﺼﺮ ﻫﺎ‪/‬اﻧﺪﯾﺲ ﻫﺎی رﺷﺘﻪ دﺳﺖ ﭘﯿﺪا ﮐﺮد‪.‬‬

‫‪ (5‬ﻫﻤﯿﺸﻪ اوﻟﯿﻦ اﻧﺪﯾﺲ )‪ (index‬ﺷﻤﺎره ‪ ۰‬اﺳﺖ‪.‬‬

‫‪ (6‬از ﺗﺎﺑﻊ ‪ len‬ﻣﯿﺘﻮان ﺑﺮای ﺑﻪ دﺳﺖ آوردن ﻃﻮل ﻣﺘﻐﯿﯿﺮ ﻫﺎی ﻧﻮع ‪ string‬اﺳﺘﻔﺎده ﮐﺮد‪.‬‬
‫‪String Slicing‬‬ ‫‪STRINGS‬‬ ‫‪Part 3‬‬

‫ﺑﻪ ﮐﻤﮏ ﺑﺮاﮐﺖ ﻫﺎ ﻣﯿﺘﻮاﻧﯿﻢ ﺑﺎزه ﯾﮏ رﺷﺘﻪ را ﺟﻬﺖ اﺳﺘﻔﺎده ﻣﺸﺨﺺ ﻧﻤﺎﯾﯿﻢ‪.‬‬ ‫•‬

‫در ﺻﻮرﺗﯽ ﮐﻪ ﺑﺎزه اول را ﻣﺸﺨﺾ ﻧﮑﻨﯿﻢ از ‪ ۰‬ﺷﺮوع ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫در ﺻﻮرﺗﯽ ﮐﻪ ﺑﺎزه دوم را ﻣﺸﺨﺺ ﻧﮑﻨﯿﻢ آﺧﺮش را در ﻧﻈﺮ ﻣﯿﮕﯿﺮد‪.‬‬ ‫•‬

‫ﺗﮑﻨﯿﮏ ﻫﺎی زﯾﺎدی ﻣﯿﺘﻮان ﺑﺎ ‪ string slicing‬اﻧﺠﺎم داد ﻣﺜﻼ ﻋﻤﻠﯿﺎت ﺑﺮﻋﮑﺲ ﮐﺮدن‬ ‫•‬

‫ﻣﺘﻦ ﺑﺪون اﺳﺘﻔﺎده از ﺗﺎﺑﻊ و‪...‬‬

 ‫ﻣﺘﺪ ﻫﺎ ‪METHODS‬‬

‫ﻋﻤﻠﮑﺮد ﻣﺘﺪ ﻫﺎ دﻗﯿﻘﺎ ﻣﺸﺎﺑﻪ ﺗﺎﺑﻊ اﺳﺖ‪.‬‬ ‫•‬

‫ﻧﺤﻮه اﺳﺘﻔﺎده از آﻧﻬﺎ ﻧﺴﺒﺖ ﺑﻪ ﺗﺎﺑﻊ ﮐﻤﯽ ﻣﺘﻔﺎوت اﺳﺖ‪.‬‬ ‫•‬

‫ﻣﺘﺪ ﻫﺎ در واﻗﻊ ﺧﻮدﺷﺎن ﺗﻮاﺑﻌﯽ ﻫﺴﺘﻨﺪ ﮐﻪ در ﺑﺮﺧﯽ ﮐﻼس ﻫﺎ ﺗﻌﺮﯾﻒ ﺷﺪه اﻧﺪ‪.‬‬ ‫•‬

‫ﺑﻪ زﺑﺎن ﺳﺎده ﯾﻌﻨﯽ ﺗﻨﻬﺎ روی داده ﻫﺎی ﺧﺎﺻﯽ ﻋﻤﻞ ﻣﯿﮑﻨﻨﺪ‪.‬‬ ‫•‬
‫ﻧﺤﻮه اﺳﺘﻔﺎده از ﻣﺘﺪ‬

‫ﻣﺜﻼ ﻣﺘﺪ ﻫﺎی ﻣﺮﺑﻮط ﺑﻪ ‪ string‬ﻫﺎ ﻓﻘﻂ ﻣﺨﺼﻮص اﯾﻦ ﻧﻮع اﺳﺖ‪.‬‬ ‫•‬

‫در ﭘﺎﯾﺘﻮن ﺑﻪ ﻃﻮر ﭘﯿﺸﻔﺮض ﺗﻮاﺑﻊ و ﻣﺘﺪ ﻫﺎی ﻣﺘﻌﺪدی وﺟﻮد دارد‪.‬‬ ‫•‬

‫ﺧﻮدﻣﺎن ﻧﯿﺰ در ﺑﺨﺶ ﻫﺎی ﺟﻠﻮﺗﺮ ﻣﯿﺘﻮاﻧﯿﻢ ﺗﻮاﺑﻊ و ﻣﺘﺪ ﻫﺎی ﻣﻮرد ﻧﻈﺮ ﺧﻮ را اﯾﺠﺎد ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﻣﺘﺪ را ﻣﯿﺘﻮاﻧﯿﻢ روی ﯾﮏ ﻣﺘﻐﯿﯿﺮ اﻋﻤﺎل ﮐﻨﯿﻢ و ﻧﺘﯿﺠﻪ را داﺧﻞ ﯾﮏ ﻣﺘﻐﯿﯿﺮ دﯾﮕﺮ ذﺧﯿﺮه ﮐﻨﯿﻢ‪.‬‬ ‫•‬
 ‫‪String Methods‬‬ ‫‪STRINGS‬‬ ‫‪Part 4‬‬

‫ﻧﻮع داده ‪ string‬ﺷﺎﻣﻞ ﻣﺘﺪ ﻫﺎی ﻣﻨﺤﺼﺮ ﺑﻪ ﻓﺮد ﺧﻮدش اﺳﺖ‪.‬‬ ‫•‬

‫ﻟﯿﺴﺖ ﺑﺮﺧﯽ از ﻣﺘﺪ ﻫﺎی ﮐﺎرﺑﺮدی رﺷﺘﻪ ﻫﺎ ﺑﻪ ﺷﺮح زﯾﺮ اﺳﺖ‪:‬‬ ‫•‬

‫‪Methods‬‬ ‫‪Description‬‬
‫)(‪captalize‬‬ ‫اوﻟﯿﻦ ﺣﺮف رﺷﺘﻪ را ﺑﺰرگ ﻣﯿﮑﻨﺪ‬

‫)(‪upper‬‬ ‫ﺗﻤﺎم رﺷﺘﻪ را ﺑﻪ ﻧﻮﯾﺴﻪ ﺑﺰرگ ﺗﺒﺪﯾﻞ ﻣﮑﯿﻨﺪ‬

‫)(‪lower‬‬ ‫ﺗﻤﺎم رﺷﺘﻪ را ﺑﻪ ﻧﻮﯾﺴﻪ ﮐﻮﭼﮏ ﺗﺒﺪﯾﻞ ﻣﮑﯿﻨﺪ‬

‫)(‪strip‬‬ ‫ﻓﻀﺎی ﻓﺎﺻﻠﻪ ﺧﺎﻟﯽ را ﺣﺬف ﻣﯿﮑﻨﺪ‬

‫)(‪replace‬‬ ‫دو ورودی ﻣﺘﻨﯽ ﻣﯿﮕﯿﺮد و ورودی دوم را در رﺷﺘﻪ ﺟﺎﯾﮕﺰﯾﻦ اوﻟﯽ ﻣﯿﮑﻨﺪ‬

‫)(‪split‬‬ ‫ﺑﺮ اﺳﺎس ﯾﮏ ﮐﺎراﮐﺘﺮ ﮐﻠﻤﺎت را از ﻫﻢ ﺟﺪا ﻣﯿﮑﻨﺪ و ﺗﺒﺪﯾﻞ ﺑﻪ ﻟﯿﺴﺖ ﻣﯿﮑﻨﺪ‬
‫ﺟﺎﯾﮕﺎه ﯾﮏ رﺷﺘﻪ را ﭘﯿﺪا ﻣﯿﮑﻨﺪ و ﭘﺎراﻣﺘﺮ دوم و ﺳﻮم ﻫﻢ ﺑﻪ ﻋﻨﻮان ﺑﺎزه ﺟﺴﺘﺠﻮ‬
‫)(‪find‬‬ ‫ﻋﻤﻞ ﻣﯿﮑﻨﺪ‬
‫ﺗﻌﺪاد ﺗﮑﺮار ﯾﮏ ﮐﻠﻤﻪ ﯾﺎ ‪ ...‬در رﺷﺘﻪ را ﺑﺮﻣﮕﯿﺮداﻧﺪ و ﭘﺎراﻣﺘﺮ دوم و ﺳﻮم ﻫﻢ ﺑﻪ‬
‫)(‪count‬‬ ‫ﻋﻨﻮان ﺑﺎزه ﺟﺴﺘﺠﻮ ﻋﻤﻞ ﻣﯿﮑﻨﺪ‪.‬‬
 ‫‪Data types review‬‬ ‫ﻣﺮور اﻧﻮاع داده‬

‫ﺗﺎ ﮐﻨﻮن ﺑﺎ اﻧﻮع داده ﻫﺎی ﻋﺪدی آﺷﻨﺎ ﺷﺪﯾﻢ‪.‬‬ ‫•‬

‫ﺑﺎ داده ﻫﺎی رﺷﺘﻪ ای )‪ (strings‬ﻧﯿﺰ آﺷﻨﺎ ﺷﺪﯾﻢ‪.‬‬ ‫•‬

‫از اﯾﻦ ﭘﺲ ﺑﺎ اﻧﻮاع داده ﺟﺪﯾﺪی و ﻣﺘﺪ ﻫﺎی ﻣﻨﺤﺼﺮ ﺑﻪ ﻓﺮد ﺧﻮدﺷﺎن آﺷﻨﺎ ﻣﯿﺸﻮﯾﻢ‪.‬‬ ‫•‬

‫ﻧ ﻮ ع د اد ه ﻋ ﺪد ی‬ ‫ﻧﻮع داده ﻣﻨﻄﻘﯽ‬ ‫داده ﻫﺎی دﻧﺒﺎﻟﻪ دار‬

‫اﻋﺪاد ﺻﺤﯿﺢ‬ ‫اﻋﺸﺎر‬ ‫ﻣﺨﺘﻠﻂ‬ ‫رﺷﺘﻪ ﻣﺘﻦ‬ ‫ﻟﯿﺴﺖ‬ ‫ﺗﺎﭘﻞ‬

 ‫‪LISTS‬‬ ‫‪Part 1‬‬

‫ﻟﯿﺴﺖ ﻫﺎ ﯾﮑﯽ از اﻧﻮاع داده دﻧﺒﺎﻟﻪ دار ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫ﻟﯿﺴﺖ ﻫﺎ ﺑﺮای ذﺧﯿﺮه ﭼﻨﺪﯾﻦ ﻣﻮرد داده در ﯾﮏ ﻣﺘﻐﯿﺮ اﺳﺘﻔﺎده ﻣﯽ ﺷﻮﻧﺪ‪.‬‬ ‫•‬

‫ﻟﯿﺴﺖ ﻫﺎ ﮐﻤﮏ ﻋﻼﻣﺖ ﺑﺮاﮐﺖ ] [ و ﻣﻘﺎدﯾﺮ آن ﺑﺎ وﯾﺮﮔﻮل از ﻫﻢ ﺟﺪا ﻣﯿﺸﻮﻧﺪ‪.‬‬ ‫•‬

‫ﻧﺤﻮه دﺳﺘﺮﺳﯽ ﺑﻪ اﻧﺪﯾﺲ ﻫﺎی آن ﻣﺸﺎﺑﻪ رﺷﺘﻪ ﻣﺘﻦ ﻫﺎ اﺳﺖ‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻋﻤﻠﮕﺮ ﻋﻀﻮﯾﺖ ‪ in‬ﻣﯿﺘﻮاﻧﯿﻢ ﺑﺮرﺳﯽ ﮐﻨﯿﻢ آﯾﺎ ﻣﻘﺪار ﺧﺎﺻﯽ در آن وﺟﻮد‬ ‫•‬

‫دارد ﯾﺎ ﺧﯿﺮ‪.‬‬

‫ﻟﯿﺴﺖ ﻫﺎ ﻧﯿﺰ دارای ﻣﺘﺪ ﻫﺎی ﺧﻮدﺷﺎن ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫‪Change list items‬‬ ‫‪LISTS‬‬ ‫‪Part 2‬‬

‫دﻗﯿﻘﺎ ﻣﺎﻧﻨﺪ ﻣﺘﻐﯿﯿﺮ ﻫﺎی ﻋﺎدی ﻣﯿﺘﻮاﻧﯿﻢ ﻣﻘﺎدﯾﺮ ﻟﯿﺴﺖ ﻫﺎ را ﻧﯿﺰ ﺗﻐﯿﯿﺮ دﻫﯿﻢ‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﺑﺎزه ﻧﯿﺰ ﻣﯿﺘﻮان ﻫﻤﺰﻣﺎن ﭼﻨﺪ ﻣﻘﺪار در ﻟﯿﺴﺖ را ﺗﻐﯿﯿﺮ داد‪.‬‬ ‫•‬
‫‪Add List Items‬‬ ‫‪LISTS‬‬ ‫‪Part 3‬‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ append‬ﻣﯿﺘﻮاﻧﯿﻢ ﯾﮏ ﻣﻘﺪار ﺑﻪ ﻟﯿﺴﺖ اﺿﺎﻓﻪ ﮐﻨﯿﻢ‪) .‬ﺑﻪ آﺧﺮ ﻟﯿﺴﺖ اﺿﺎﻓﻪ ﻣﯿﺸﻮد(‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ insert‬ﻣﯿﺘﻮاﻧﯿﻢ ﺑﮕﻮﯾﯿﻢ ﮐﻪ ﻣﻘﺪار در ﮐﺪام ﻋﻨﺼﺮ ﻟﯿﺴﺖ اﺿﺎﻓﻪ ﺑﺸﻮد‪.‬‬ ‫•‬
‫ﭘﺮوژه ذﺧﯿﺮه ﻣﺨﺎﻃﺐ در ﻟﯿﺴﺖ‬ ‫‪LISTS‬‬ ‫‪Part 4‬‬

‫ﺑﻪ ﮐﻤﮏ ﺣﻠﻘﻪ ﻫﺎ و ﻟﯿﺴﺖ ﻫﺎ و ﻣﺘﺪ اﺿﺎﻓﻪ ﮐﺮدن آﯾﺘﻢ ﺑﻪ ﻟﯿﺴﺖ ﻣﯿﺨﻮاﻫﯿﻢ ﺑﻪ ﺗﻌﺪاد دﻟﺨﻮاه اﻃﻼﻋﺎت در ﻟﯿﺴﺖ ذﺧﯿﺮه ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫‪ (1‬اﺑﺘﺪا ﺗﻌﺪاد اﻃﻼﻋﺎﺗﯽ ﮐﻪ ﮐﺎرﺑﺮ ﻣﺪ ﻧﻈﺮ دارد در ﻟﯿﺴﺖ اﺿﺎﻓﻪ ﮐﻨﺪ را از او ﻣﯿﮕﯿﺮﯾﻢ و در ﯾﮏ ﻣﺘﻐﯿﺮ ذﺧﯿﺮه ﻣﯿﮑﻨﯿﻢ‪.‬‬

‫‪ (2‬ﺳﭙﺲ ﯾﮏ ﻟﯿﺴﺖ ﺧﺎﻟﯽ ﺗﻌﺮﯾﻒ ﻣﯿﮑﻨﯿﻢ ﮐﻪ ﻣﯿﺨﻮاﻫﯿﻢ اﻃﻼﻋﺎﺗﻤﺎن را ﺑﻪ داﺧﻞ آن اﺿﺎﻓﻪ ﮐﻨﯿﻢ‪.‬‬

‫‪ (3‬ﯾﮏ ﺣﻠﻘﻪ ﺑﻪ ﺗﻌﺪادی ﮐﻪ ﻣﺪ ﻧﻈﺮ ﮐﺎرﺑﺮ ﺑﻮد اﺳﺖ ﻣﯿﺰﻧﯿﻢ‪.‬‬

‫‪ (4‬ﻫﺮ ﺑﺎر از او اﻃﻼﻋﺎت ﻣﯿﺨﻮاﻫﯿﻢ و ﺑﺎ ﻫﺮ ﺑﺎر وارد ﮐﺮدن ﺑﺎ ﻣﺘﺪ ‪ append‬ﺑﻪ ﻟﯿﺴﺖ اﺿﺎﻓﻪ ﻣﯿﺸﻮد‪.‬‬

‫‪ (5‬در ﺧﺎرج از ﺑﻠﻮک ﺣﻠﻘﻪ ﻣﻘﺪار ﻟﯿﺴﺖ را ﻧﻤﺎﯾﺶ ﻣﯿﺪﻫﯿﻢ‪.‬‬

‫‪for loops in lists‬‬ ‫‪LISTS‬‬ ‫‪Part 5‬‬

‫ﺑﻪ ﮐﻤﮏ ﺣﻠﻘﻪ ‪ for‬ﺑﻪ راﺣﺘﯽ ﻣﯿﺘﻮاﻧﯿﻢ ﺑﻪ ﺗﮏ ﺗﮏ ﻋﻨﺼﺮ ﻫﺎی ﻟﯿﺴﺖ دﺳﺘﺮﺳﯽ ﭘﯿﺪا ﮐﻨﯿﻢ‪.‬‬ ‫•‬
 ‫‪Remove Specified Item‬‬ ‫‪LISTS‬‬ ‫‪Part 6‬‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ remove‬ﻣﯿﺘﻮاﻧﯿﻢ ﯾﮏ آﯾﺘﻢ ﺧﺎص را از ﻟﯿﺴﺖ ﺣﺬف ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ورودی ﻣﺘﺪ ‪ remove‬ﻣﯿﺒﺎﺳﺖ دﻗﯿﻘﺎ ﻣﻘﺪاری ﺑﺎﺷﺪ ﮐﻪ ﻣﺪ ﻧﻈﺮ اﺳﺖ ﺣﺬف ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ pop‬ﻣﯿﺘﻮاﻧﯿﻢ ﯾﮏ آﯾﺘﻢ را از ﻃﺮﯾﻖ ﺷﻤﺎره اﻧﺪﯾﺲ ﯾﺎ ﻫﻤﺎن ﺟﺎﯾﮕﺎﻫﺶ در ﻟﯿﺴﺖ ﺣﺬف ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫در ﺻﻮرﺗﯽ ﮐﻪ ورودی ﻣﺘﺪ ‪ pop‬ﺧﺎﻟﯽ ﺑﺎﺷﺪ آﺧﺮﯾﻦ آﯾﺘﻢ ﭘﺎک ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﮐﻠﻤﻪ ﮐﻠﯿﺪی ‪ del‬ﻣﯿﺘﻮاﻧﯿﻢ ﯾﮏ آﯾﺘﻢ ﻟﯿﺴﺖ را ﺣﺬف ﮐﻨﯿﻢ‪ .‬در ﺻﻮرﺗﯽ ﮐﻪ ﺑﻪ ﺷﻤﺎره اﻧﺪﯾﺲ آﯾﺘﻢ اﺷﺎره ﻧﺸﻮد ﺧﻮد ﻟﯿﺴﺖ ﭘﺎک‬ ‫•‬

‫ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬

‫ﺑﺎ اﺳﺘﻔﺎده از ﻣﺘﺪ )(‪ clear‬ﻟﯿﺴﺖ ﻣﺎ ﻧﮕﻪ داﺷﺘﻪ ﻣﯿﻮﺷﺪ اﻣﺎ آﯾﺘﻢ ﻫﺎی آن ﺧﺎﻟﯽ ﻣﯿﺸﻮﻧﺪ‪.‬‬ ‫•‬
‫‪List sorting‬‬ ‫‪LISTS‬‬ ‫‪Part 7‬‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ sort‬ﻟﯿﺴﺘﻤﺎن را ﻣﺮﺗﺐ ﺳﺎزی ﺑﮑﻨﯿﻢ‪.‬‬ ‫•‬

‫در ﺻﻮرﺗﯽ ﮐﻪ آﯾﺘﻢ ﻫﺎ ﻫﻤﮕﯽ رﺷﺘﻪ ﺑﺎﺷﻨﺪ ﺑﺮ اﺳﺎس ﺣﺮوف اﻟﻔﺒﺎی اﻧﮕﻠﯿﺴﯽ و ﺻﻌﻮدی ﻣﺮﺗﺐ ﺧﻮاﻫﻨﺪ ﺷﺪ‪.‬‬ ‫•‬

‫در ﺻﻮرﺗﯽ ﮐﻪ آﯾﺘﻢ ﻫﺎ ﻫﻤﮕﯽ ﻋﺪدی ﺑﺎﺷﻨﺪ ﺻﻌﻮدی ﻣﺮﺗﺐ ﺧﻮاﻫﻨﺪ ﺷﺪ‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ آرﮔﻮﻣﺎن ‪ reverse‬ﻣﯿﺘﻮان ﻧﺤﻮه ﻣﺮﺗﺐ ﺳﺎزی ﭘﯿﺸﻔﺮص را ﺑﺮﻋﮑﺲ ﮐﺮد‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ آرﮔﻮﻣﺎن ‪ key‬ﻣﯿﺘﻮاﻧﯿﻢ ﻣﺮﺗﺐ ﺳﺎزی را ﺑﺮ اﺳﺎس ﺗﺎﺑﻊ ﺷﺨﺼﯽ ﺧﻮدﻣﺎن اﻧﺠﺎم دﻫﯿﻢ‪.‬‬ ‫•‬

‫ﺗﻤﺮﯾﻦ‪ :‬ﺗﻌﺪادی ﻋﺪد از ﮐﺎرﺑﺮ ﺑﮕﯿﺮﯾﺪ و در ﻧﻬﺎﯾﺖ آن ﻫﺎ ﺑﻪ ﺻﻮرت ﺻﻌﻮدی و ﻧﺰوﻟﯽ ﻧﻤﺎﯾﺶ دﻫﯿﺪ‪.‬‬ ‫•‬
‫‪Copy a list‬‬ ‫‪LISTS‬‬ ‫‪Part 8‬‬

‫ﺑﻪ راﺣﺘﯽ ﻣﯿﺘﻮاﻧﯿﻢ ﯾﮏ ﻣﺘﻐﯿﯿﺮ را ﺑﻪ ﯾﮏ ﻣﺘﻐﯿﯿﺮ دﯾﮕﺮ اﺧﺘﺼﺎﺻﯽ دﻫﯿﻢ‪.‬‬ ‫•‬

‫اﻣﺎ ﻣﺎﻧﻨﺪ اﺧﺘﺼﺎص دادن ﻣﺘﻐﯿﯿﺮ ﻫﺎ ﻧﻤﯿﺘﻮاﻧﯿﻢ ﻟﯿﺴﺖ ﻫﺎ را ﺑﻪ ﻫﻢ اﺧﺘﺼﺎﺻﯽ دﻫﯿﻢ‪.‬‬ ‫•‬

‫ﻣﯿﺒﺎﯾﺴﺖ از ﻣﺘﺪ )(‪ copy‬ﺟﻬﺖ ﮐﭙﯽ ﮐﺮدن ﯾﮏ ﻟﯿﺴﺖ در ﻗﺎﻟﺐ ﻣﺘﻐﯿﯿﺮ در ﯾﮏ ﻣﺘﻐﯿﯿﺮ دﯾﮕﺮ اﺳﺘﻔﺎده ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺑﺮای اﯾﻦ ﮐﺎر دو روش دارﯾﻢ‪ .‬ﻣﺘﺪ ‪ copy‬و ﺗﺎﺑﻊ ‪list‬‬ ‫•‬
‫‪Join two list‬‬ ‫‪LISTS‬‬ ‫‪Part 9‬‬

‫ﻟﯿﺴﺖ ﻫﺎ ﻣﯿﺘﻮان ﺑﻪ روش ﻫﺎی ﻣﺨﺘﻠﻒ ﺑﻪ ﯾﮑﺪﯾﮕﺮ اﻟﺤﺎق ﮐﺮد‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻋﻤﻠﮕﺮ ﺣﺴﺎﺑﯽ ‪ +‬ﻣﯿﺘﻮان دو ﻟﯿﺴﺖ را ﺑﻪ ﯾﮑﺪﯾﮕﺮ ﻣﻠﺤﻖ ﮐﺮد‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﺣﻠﻘﻪ ‪ for‬ﻧﯿﺰ ﻣﯿﺘﻮاﻧﯿﻢ اﯾﻦ ﻋﻤﻞ را اﻧﺠﺎم دﻫﯿﻢ‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ extend‬ﻧﯿﺰ ﻣﯿﺘﻮان ﻟﯿﺴﺖ ﻫﺎ را ﺑﻪ ﯾﮑﺪﯾﮕﺮ ﻣﻠﺤﻖ ﮐﺮد‪.‬‬ ‫•‬
 ‫‪List methods‬‬ ‫‪LISTS‬‬ ‫‪Part 10‬‬

‫ﺟﺪول ﮐﺎﻣﻞ ﻣﺘﺪ ﻫﺎی ﻧﻮع داده ﻟﯿﺴﺖ‪.‬‬ ‫•‬

‫‪Methods‬‬ ‫‪Description‬‬
‫)(‪append‬‬ ‫ﯾﮏ آﯾﺘﻢ ﺑﻪ اﻧﺘﻬﺎی ﻟﯿﺴﺖ اﺿﺎﻓﻪ ﻣﯿﮑﻨﺪ‬

‫)(‪clear‬‬ ‫ﻟﯿﺴﺖ را ﺧﺎﻟﯽ ﻣﯿﮑﻨﺪ‬

‫)(‪copy‬‬ ‫ﻟﯿﺴﺖ را ﮐﭙﯽ ﻣﯿﮑﻨﺪ‬

‫)(‪extend‬‬ ‫آﯾﺘﻢ ﻫﺎی ﯾﮏ ﻟﯿﺴﺖ را ﺑﻪ ﻟﯿﺴﺖ دﯾﮕﺮی اﺿﺎﻓﻪ ﻣﯿﮑﻨﺪ‬

‫)(‪index‬‬ ‫ﺟﺎﯾﮕﺎه آﯾﺘﻢ را در ﻟﯿﺴﺖ ﻣﺸﺨﺺ ﻣﯿﮑﻨﺪ )اوﻟﯿﻦ آﯾﺘﻤﯽ ﮐﻪ ﭘﯿﺪا ﮐﻨﺪ(‬

‫)(‪insert‬‬ ‫ﯾﮏ آﯾﺘﻢ ﺑﻪ ﺟﺎﯾﮕﺎه ﻣﻮرد ﻧﻈﺮ اﺿﺎﻓﻪ ﻣﯿﮑﻨﺪ‪.‬‬

‫)(‪pop‬‬ ‫ﯾﮏ آﯾﺘﻢ را ﺑﺮ اﺳﺎس ﺟﺎﯾﮕﺎﻫﺶ ﺣﺬف ﻣﯿﮑﻨﺪ‬

‫)(‪remove‬‬ ‫ﯾﮏ آﯾﺘﻢ را ﺑﺮ اﺳﺎس ﻣﻘﺪارش ﺣﺬف ﻣﯿﮑﻨﺪ‪.‬‬

‫)(‪reverse‬‬ ‫ﻟﯿﺴﺖ را ﻣﻌﮑﻮس ﻣﯿﮑﻨﺪ‬

‫)(‪sort‬‬ ‫ﻟﯿﺴﺖ را ﻣﺮﺗﺐ ﻣﯿﮑﻨﺪ‬

 ‫‪TUPLES‬‬ ‫‪Part 1‬‬

‫ﯾﮑﯽ دﯾﮕﺮ از اﻧﻮاع داده دﻧﺒﺎﻟﻪ دار ﺗﺎﭘﻞ ﻫﺎ )‪ (Tuple‬ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫ﮐﺎرﺑﺮد آﻧﻬﺎ ﻣﺸﺎﺑﻪ ﻟﯿﺴﺖ ﻫﺎ اﺳﺖ و ﺑﺮای ذﺧﯿﺮه ﭼﻨﺪ ﻣﻘﺪار در ﯾﮏ ﻣﺘﻐﯿﯿﺮ اﺳﺘﻔﺎده ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫ﺗﻔﺎوت ﺑﺎ ﻟﯿﺴﺖ در آن اﺳﺖ ﮐﻪ ﺗﺎﭘﻞ ﻣﻨﻈﻢ ﺗﺮ اﺳﺖ و ﻏﯿﺮ ﻗﺎﺑﻞ ﺗﻐﯿﯿﺮ!‬ ‫•‬

‫ﺗﺎﭘﻞ ﻫﺎ ﺑﻪ ﮐﻤﮏ ﻋﻼﻣﺖ ﭘﺮاﻧﺘﺰ )( ﺗﻌﺮﯾﻒ ﻣﯿﺸﻮﻧﺪ‪.‬‬ ‫•‬

‫ﻣﻮﻗﻌﯿﺖ اوﻟﯿﻦ آﯾﺘﻢ ‪ ۰‬اﺳﺖ‪.‬‬ ‫•‬

‫ﻫﯿﭻ ﯾﮏ از ﻋﻤﻠﯿﺎت ﻫﺎی ﺗﻐﯿﯿﺮ و ﺣﺬف و اﺿﺎﻓﻪ ﮐﺮدن آﯾﺘﻢ را در ﺗﺎﭘﻞ ﻫﺎ ﻧﻤﯿﺘﻮان اﻧﺠﺎم داد‪.‬‬ ‫•‬

‫در ﺻﻮرت ﻧﯿﺎز ﺑﻪ ﺗﺎﭘﻞ ﺑﺎ ﯾﮏ آﯾﺘﻢ ﺣﺘﻤﺎ ﺑﺎﯾﺪ آن را ﺑﺎ ﻋﻼﻣﺖ ‪ ,‬ﺟﺪا ﺳﺎزی ﮐﻨﯿﻢ در ﻏﯿﺮ اﯾﻨﺼﻮرت ﯾﮏ رﺷﺘﻪ ﻣﺘﻨﯽ اﺳﺖ‪.‬‬ ‫•‬

‫ﺗﺎﭘﻞ ﻧﯿﺰ اﻧﻮاع داده ﻣﺨﺘﻠﻒ را ﭘﺸﺘﯿﺒﺎﻧﯽ ﻣﯿﮑﻨﺪ‪.‬‬ ‫•‬

‫‪Access tuple items‬‬ ‫‪TUPLES‬‬ ‫‪Part 2‬‬

‫ﻣﺸﺎﺑﻪ ﻟﯿﺴﺖ ﻫﺎ ﻣﯿﺘﻮان ﺑﻪ آﯾﺘﻢ ﻫﺎی ﺗﺎﭘﻞ دﺳﺘﺮﺳﯽ ﭘﯿﺪا ﮐﺮد‪.‬‬ ‫•‬

‫ﺟﻬﺖ دﺳﺘﺮﺳﯽ ﻣﻨﻔﯽ آﯾﺘﻢ ﻫﺎ از ﻋﻼﻣﺖ – اﺳﺘﻔﺎده ﻣﯿﮑﻨﯿﻢ و اوﻟﯿﻦ آﯾﺘﻢ از ‪ -1‬ﺷﺮوع ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫ﺑﻪ رﻧﺞ آﯾﺘﻢ ﻫﺎی ﺗﺎﭘﻞ ﻣﯿﺘﻮان دﺳﺘﺮﺳﯽ ﭘﯿﺪا ﮐﺮد‪ .‬آﯾﺘﻢ ﻫﺎ از ﺧﻮد ﺑﺎزه اول ﺗﺎ ﻗﺒﻞ ﺑﺎزه آﺧﺮ در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫ﺑﺎ ﻋﻤﻠﮕﺮ ﻫﺎی ﻋﻀﻮﯾﺖ ﻣﯿﺘﻮان وﺟﻮد ﯾﮏ آﯾﺘﻢ ﺧﺎص را ﻧﯿﺰ ﺑﺮرﺳﯽ ﮐﺮد‪.‬‬ ‫•‬
‫‪Update Tuples‬‬ ‫‪TUPLES‬‬ ‫‪Part 3‬‬

‫ﺗﺎﭘﻞ ﻫﺎ ﻏﯿﺮﻗﺎﺑﻞ ﺗﻐﯿﯿﺮ ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫اﻣﺎ ﻣﻤﮑﻦ اﺳﺖ ﮔﺎﻫﯽ ﻧﯿﺎز ﺑﺎﺷﺪ ﺗﻐﯿﯿﺮاﺗﯽ در آن ﻫﺎ اﻋﻤﺎل ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺑﺮای اﯾﻦ ﮐﺎر اﺑﺘﺪا آن ﻫﺎ را ﺑﻪ ﻟﯿﺴﺖ ﺗﺒﺪﯾﻞ ﻣﯿﮑﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺳﭙﺲ ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ ﻫﺎی ﻟﯿﺴﺖ ﺗﻐﯿﯿﺮات ﺧﻮد را اﻋﻤﺎل ﻣﯿﮑﻨﯿﻢ‪.‬‬ ‫•‬

‫و در ﻧﻬﺎﯾﺖ دوﺑﺎره ﺗﺒﺪﯾﻞ ﺑﻪ ﺗﺎﭘﻞ ﻣﯿﮑﻨﯿﻢ‪.‬‬ ‫•‬

‫‪Packing and Unpacking tuples‬‬ ‫‪TUPLES‬‬ ‫‪Part 4‬‬

‫زﻣﺎﻧﯽ ﮐﻪ ﻣﺎ ﯾﮏ ﺗﺎﭘﻞ ﺗﻌﺮﯾﻒ ﻣﯿﮑﻨﯿﻢ ﺑﻪ اﺻﻄﻼح ﺑﻪ اﯾﻦ ﻋﻤﻞ ‪ tuple packing‬ﻣﯿﮕﻮﯾﻨﺪ‪.‬‬ ‫•‬

‫ﻫﻤﭽﻨﯿﻦ ﻣﯿﺘﻮاﻧﯿﻢ ﺗﻤﺎم آﯾﺘﻢ ﻫﺎی ﺗﺎﭘﻞ را ﺑﻪ ﻣﺘﻐﯿﯿﺮ ﺗﺒﺪﯾﻞ ﮐﻨﯿﻢ‪ .‬اﯾﻦ ﻋﻤﻞ را ‪ unpacking‬ﻣﯿﮕﻮﯾﻨﺪ‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻋﻼﻣﺖ * ﻣﯿﺘﻮاﻧﯿﻢ ﭼﻨﺪ ﻣﻘﺪار ﺑﺎﻗﯽ ﻣﺎﻧﺪه از ﺗﺎﭘﻞ را در ﻗﺎﻟﺐ ﯾﮏ ﻟﯿﺴﺖ در ﻣﺘﻐﯿﯿﺮ ذﺧﯿﺮه ﮐﻨﯿﻢ‪.‬‬ ‫•‬
‫‪Loop In tuple‬‬ ‫‪TUPLES‬‬ ‫‪Part 5‬‬

‫دﻗﯿﻘﺎ ﻣﺸﺎﺑﻪ دﯾﮕﺮ داده ﻫﺎی دﻧﺒﺎﻟﻪ دار ﻣﯿﺘﻮاﻧﯿﻢ درون ﺗﺎﭘﻞ ﻫﺎ ﻧﯿﺰ ﺣﻠﻘﻪ ﺑﺰﻧﯿﻢ‪.‬‬ ‫•‬

‫در ﺻﻮرت اﺳﺘﻔﺎده از ﺣﻠﻘﻪ ‪ while‬ﻧﯿﺎز ﺑﻪ ﺗﻌﺮﯾﻒ ﺷﻤﺎرﻧﺪه و اﺳﺘﻔﺎده از ﺗﺎﺑﻊ )(‪ len‬دارﯾﻢ‪.‬‬ ‫•‬
‫‪Join two tuples‬‬ ‫‪TUPLES‬‬ ‫‪Part 6‬‬

‫ﺗﺎﭘﻞ ﻫﺎ ﻧﯿﺰ ﻣﯿﺘﻮاﻧﯿﻢ ﺑﻪ ﯾﮏ دﯾﮕﺮ ﻣﻠﺤﻖ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫در ﺻﻮرت ﻧﯿﺎز ﺑﻪ ﺗﮑﺮار ﻣﻘﺎدﯾﺮ ﺗﺎﭘﻞ ﻫﺎ ﻣﯿﺘﻮاﻧﯿﻢ ﺗﺎﭘﻞ را ﺿﺮب ﮐﻨﯿﻢ‪.‬‬ ‫•‬
‫‪Tuple Methods‬‬ ‫‪TUPLES‬‬ ‫‪Part 7‬‬

‫دو ﻣﺘﺪ ﺑﯿﺸﺘﺮ ﺟﻬﺖ اﺳﺘﻔﺎده در ﺗﺎﭘﻞ ﻫﺎ ﻧﺪارﯾﻢ‪.‬‬ ‫•‬

‫‪Methods‬‬ ‫‪Description‬‬
‫)(‪count‬‬ ‫ﺗﻌﺪاد وﺟﻮد ﯾﮏ آﯾﺘﻢ را در ﺗﺎﭘﻞ ﺷﻤﺎرش ﻣﯿﮑﻨﺪ‬

‫)(‪index‬‬ ‫ﺟﺎﯾﮕﺎه ﯾﮏ آﯾﺘﻢ در ﺗﺎﭘﻞ را ﻣﺸﺨﺺ ﻣﯿﮑﻨﺪ‪.‬‬

 ‫‪SETS‬‬ ‫‪Part 1‬‬

‫ﯾﮑﯽ دﯾﮕﺮ از اﻧﻮاع داده در زﺑﺎن ﭘﺎﯾﺘﻮن ﺳﺖ ﻫﺎ )‪ (Set‬ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫ﺑﺮﺧﯽ از وﯾﮋﮔﯽ ﻫﺎی ﺳﺖ‪:‬‬ ‫•‬

‫ﻧﺎ ﻣﺮﺗﺐ ﻫﺴﺘﻨﺪ‪ .‬ﯾﻌﻨﯽ ﻗﺎﺑﻠﯿﺖ ﻣﺮﺗﺐ ﺳﺎزی ﻧﺪارﻧﺪ‪.‬‬ ‫•‬

‫آﯾﺘﻢ ﻫﺎ ﻏﯿﺮ ﻗﺎﺑﻞ ﺗﻐﯿﯿﺮ ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫اﻣﺎ اﻣﮑﺎن ﺣﺬف و اﺿﺎﻓﻪ ﮐﺮدن ﻣﻮارد ﺟﺪﯾﺪ وﺟﻮد دارد‪) .‬ﺑﺮ ﺧﻼف ﺗﺎﭘﻞ ﻫﺎ(‬ ‫•‬

‫ﻓﺎﻗﺪ ﻧﻤﺎﯾﻪ )‪ (index‬ﻫﺴﺘﻨﺪ‪ .‬ﯾﻌﻨﯽ ﺑﺎ ﺷﻤﺎره آﯾﺘﻢ‪/‬اﻧﺪﯾﺲ ﻧﻤﯿﺘﻮان ﺑﻪ آﯾﺘﻢ ﻫﺎ دﺳﺘﺮﺳﯽ ﭘﯿﺪا ﮐﺮد‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻋﻼﻣﺖ }{ ﻧﻌﺮﯾﻒ ﻣﯿﺸﻮﻧﺪ‪.‬‬ ‫•‬

‫ﺗﮑﺮار ﻣﻘﺎدﯾﺮ اﻣﮑﺎن ﭘﺬﯾﺮ ﻧﯿﺴﺖ‪.‬‬ ‫•‬

‫‪Make a set‬‬ ‫‪SETS‬‬ ‫‪Part 2‬‬

‫ﺑﻪ دو ﺷﮑﻞ ﻣﯿﺘﻮان ﺳﺖ ﻫﺎ را ﺗﻌﺮﯾﻒ ﮐﺮد‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻋﻼﻣﺖ } { و وارد ﮐﺮدن ﻣﺴﺘﻘﯿﻢ آﯾﺘﻢ ﻫﺎ‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﺗﻮاﺑﻊ ﺳﺎزﻧﺪه )‪ (constructor‬ﻫﺎ‪.‬‬ ‫•‬

‫‪Access set items‬‬ ‫‪SETS‬‬ ‫‪Part 3‬‬

‫دﻗﯿﻘﺎ ﻣﺸﺎﺑﻪ ﻟﯿﺴﺖ ﻫﺎ و ﺗﺎﭘﻞ ﻫﺎ ﻣﯿﺘﻮان در ﺳﺖ ﻫﺎ ﻧﯿﺰ ﺣﻠﻘﻪ زد و ﺑﻪ آﯾﺘﻢ ﻫﺎی دﺳﺘﺮﺳﯽ ﭘﯿﺪا ﮐﺮد‪.‬‬ ‫•‬

‫اﻣﺎ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﻧﺪاﺷﺘﻦ ﻧﻤﺎﯾﻪ )‪ (index‬ﻧﻤﯿﺘﻮان ﺑﺮ اﺳﺎس ﻣﻮﻗﻌﯿﺖ آﯾﺘﻢ ﺑﻪ آن دﺳﺘﺮﺳﯽ ﭘﯿﺪا ﮐﺮد‪.‬‬ ‫•‬
‫‪Add items to set‬‬ ‫‪SETS‬‬ ‫‪Part 4‬‬

‫ﻫﻤﺎﻧﻄﻮر ﮐﻪ ﮔﻔﺘﯿﻢ ﺳﺖ ﻫﺎ ﻏﯿﺮ ﻗﺎﺑﻞ ﺗﻐﯿﯿﺮ ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫اﻣﺎ ﻣﯿﺘﻮان ﺑﻪ آن ﻫﺎ آﯾﺘﻢ اﺿﺎﻓﻪ ﯾﺎ ﺣﺬف ﮐﺮد‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ add‬ﻣﯿﺘﻮاﻧﯿﻢ ﺑﻪ ﺳﺖ آﯾﺘﻢ اﺿﺎﻓﻪ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﻫﻤﭽﻨﯿﻦ ﻣﯿﺘﻮان ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ update‬ﻫﺮ داده دﻧﺒﺎﻟﻪ دار دﯾﮕﺮی ﻧﯿﺰ‬ ‫•‬

‫ﺑﻪ ﺳﺖ ﻫﺎ اﺿﺎﻓﻪ ﮐﺮد‪.‬‬

‫‪Remove set Item‬‬ ‫‪SETS‬‬ ‫‪Part 5‬‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ ﻫﺎی )(‪ remove‬و )(‪ discard‬ﻣﯿﺘﻮان آﯾﺘﻢ ﻫﺎی ﺳﺖ را ﺣﺬف ﮐﺮد‪.‬‬ ‫•‬

‫در ﺻﻮرﺗﯽ ﮐﻪ از ﻣﺘﺪ ‪ remove‬اﺳﺘﻔﺎده ﮐﻨﯿﻢ و آﯾﺘﻢ ﻣﺪ ﻧﻈﺮ ﺑﺮای ﺣﺬف وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ ﺑﺎ ﺧﻄﺎ ﻣﻮاﺟﻪ ﺧﻮاﻫﯿﻢ ﺷﺪ‪.‬‬ ‫•‬

‫اﻣﺎ ﻣﺘﺪ ‪ discard‬ﻋﻼرﻏﻢ وﺣﻮد ﻧﺪاﺷﺘﻦ آﯾﺘﻢ ﺧﻄﺎﯾﯽ ﺑﻪ وﺟﻮد ﻧﺨﻮاﻫﺪ آورد‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ pop‬ﻣﯿﺘﻮان اﺧﺮﯾﻦ آﯾﺘﻢ ﺳﺖ را ﺣﺬف ﮐﺮد‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ clear‬ﻣﯿﺘﻮان ﺳﺖ را ﺧﺎﻟﯽ ﮐﺮد‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﮐﻠﻤﻪ ﮐﻠﯿﺪی ‪ del‬ﺑﻪ ﮐﻞ ﺳﺖ را ﺣﺬف ﮐﺮد‪.‬‬ ‫•‬

‫‪Join sets‬‬ ‫‪SETS‬‬ ‫‪Part 6‬‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ ﻫﺎی ‪ update‬و ‪ union‬ﻣﯿﺘﻮاﻧﯿﻢ ﺳﺖ ﻫﺎ را ﺑﻪ ﯾﮑﺪﯾﮕﺮ ﻣﻠﺤﻖ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﻫﺮ دوی اﯾﻦ ﻣﺘﺪ ﻫﺎ داده ﻫﺎی ﺗﮑﺮاری را ﺣﺬف ﻣﯿﮑﻨﻨﺪ‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ ‪ intersection_update‬ﻣﯿﺘﻮاﻧﯿﻢ ﻓﻘﻂ داده ﻫﺎی ﺗﮑﺮاری ﺑﯿﻦ دو ﺳﺖ را ﻧﮕﻪ داری ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ ‪ symmetric_difference_update‬ﻫﻤﻪ داده ﻫﺎ ﻧﮕﻪ داری ﻣﯿﺸﻮﻧﺪ ﺑﻪ ﺟﺰ ﺗﮑﺮاری ﻫﺎ‪.‬‬ ‫•‬

‫ﺟﻬﺖ اﺳﺘﻔﺎده از دو ﻣﺘﺪ ﺑﺎﻻ و ذﺧﯿﺮه ﺗﻐﯿﯿﺮات در ﻗﺎﻟﺐ ﯾﮏ ﻣﺘﻐﯿﯿﺮ دﯾﮕﻪ ﻣﯿﺒﺎﺳﺖ ﻋﺒﺎرت ‪update‬‬ ‫•‬

‫را از آﺧﺮ آﻧﻬﺎ ﺣﺬف ﮐﻨﯿﺪ‪.‬‬

 ‫‪Set methods‬‬ ‫‪SETS‬‬ ‫‪Part 7‬‬

‫ﮐﺎرﺑﺮدی ﺗﺮﯾﻦ ﻣﺘﺪ ﻫﺎی ﺳﺖ ﻣﺜﺎل زده ﺷﺪ‪.‬‬ ‫•‬

‫اﻣﺎ ﺟﺪول ﺑﺮﺧﯽ دﯾﮕﺮ از ﻣﺘﺪ ﻫﺎی ﺳﺖ ﺑﻪ ﺷﺮح زﯾﺮ ﻣﯿﺒﺎﺷﺪ‪.‬‬ ‫•‬

‫‪Methods‬‬ ‫‪Description‬‬
‫)(‪difference‬‬ ‫ﻣﺠﻤﻮﻋﻪ ای ﺣﺎوی ﺗﻔﺎوت ﺑﯿﻦ دو ﯾﺎ ﭼﻨﺪ ﺳﺖ را ﺑﺮ ﻣﯽ ﮔﺮداﻧﺪ‪.‬‬

‫ﻣﻮارد ﻣﻮﺟﻮد در ﺳﺖ را ﮐﻪ در ﻣﺠﻤﻮﻋﻪ ﻣﺸﺨﺺ دﯾﮕﺮی ﻧﯿﺰ ﮔﻨﺠﺎﻧﺪه ﺷﺪه اﻧﺪ‪ ،‬ﺣﺬف‬
‫)(‪difference_update‬‬ ‫ﻣﯽ ﮐﻨﺪ‬

‫)(‪Isdisjoint‬‬ ‫ﺑﺮرﺳﯽ ﻣﯿﮑﻨﺪ آﯾﺎ دو ﺳﺖ ﻋﻀﻮ ﻣﺸﺘﺮک ﺗﻘﺎﻃﻊ دارﻧﺪ ﯾﺎ ﺧﯿﺮ‪.‬‬

‫)(‪Issubset‬‬ ‫ﺑﺮرﺳﯽ ﻣﯿﮑﻨﺪ آﯾﺎ ﯾﮏ ﺳﺖ دﯾﮕﺮ ﺣﺎوی آﯾﺘﻢ ﻫﺎی اﯾﻦ ﺳﺖ ﻣﯿﺒﺎﺷﺪ ﯾﺎ ﺧﯿﺮ‪.‬‬

‫)(‪Issuperset‬‬ ‫ﺑﺮرﺳﯽ ﻣﯿﮑﻨﺪ ﮐﻪ آﯾﺎ اﯾﻦ ﺳﺖ ﺷﺎﻣﻞ آﯾﺘﻢ ﻫﺎی ﺳﺖ دﯾﮕﺮی اﺳﺖ ﯾﺎ ﺧﯿﺮ‪.‬‬
 ‫‪DICTIONARIES‬‬ ‫‪Part 1‬‬

‫ﯾﮑﯽ دﯾﮕﺮ از اﻧﻮاع داده در ﭘﺎﯾﺘﻮن دﯾﮑﺸﻨﺮی ﻫﺎ ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫ﻧﺤﻮه ﻗﺮار ﮔﺮﻓﺘﻦ داده ﻫﺎ در دﯾﮑﺸﺮی ﺑﻪ ﺻﻮرت ‪ key : value‬ﻫﺴﺘﻨﺪ‪.‬‬ ‫•‬

‫ﯾﻌﻨﯽ ﻫﺮ داده ﯾﮏ ﮐﻠﯿﺪ )ﻋﻨﻮان( ﺑﺮای دﺳﺘﺮﺳﯽ دارد‪.‬‬ ‫•‬

‫ﻓﺮض ﮐﻨﯿﺪ ﻣﺎ ﺗﻨﻬﺎ در ﻗﺎﻟﺐ ﯾﮏ ﻣﺘﻐﯿﯿﺮ ﻣﯿﺨﻮاﻫﯿﻢ اﻃﻼﻋﺎت ﯾﮏ ﺧﻮدرو را ذﺧﯿﺮه ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﻧﺤﻮه ﺗﻌﺮﯾﻒ دﯾﮑﺸﻨﺮی ﻫﺎ ﺑﻪ ﮐﻤﮏ ﻋﻼﻣﺖ } { و ﺗﻌﺮﯾﻒ ﮐﻠﯿﺪ و ﻣﻘﺪار اﺳﺖ‪ .‬ﺳﻤﺖ ﭼﭗ ‪ :‬ﮐﻠﯿﺪ اﺳﺖ و ﺳﻤﺖ راﺳﺖ ‪ :‬ﻣﻘﺪار اﺳﺖ‪.‬‬ ‫•‬
 ‫‪DICTIONARIES‬‬ ‫‪Part 2‬‬

‫از ﻧﺴﺨﻪ ‪ 3.7‬ﺑﻪ ﺑﻌﺪ ﭘﺎﯾﺘﻮن دﯾﮑﺸﻨﺮی ﻫﺎ ﻣﺮﺗﺐ ﻫﺴﺘﻨﺪ )‪ (Ordered‬ﯾﻌﻨﯽ دارای ﺗﺮﻧﯿﺐ ﻣﺸﺨﺺ ﻫﺴﺘﻨﺪ و ﺟﺎﯾﮕﺎه ﺗﺮﺗﯿﺐ ﻫﺎ ﺗﻐﯿﯿﺮ ﻧﺨﻮاﻫﺪ ﮐﺮد‪.‬‬ ‫•‬

‫دﯾﮑﺸﻨﺮی ﻫﺎ ﻗﺎﺑﻞ ﺗﻐﯿﯿﺮ ﻫﺴﺘﻨﺪ )‪ (Changeable‬ﯾﻌﻨﯽ ﻣﯿﺘﻮاﻧﯿﻢ ﻣﻘﺎدﯾﺮ را ﺗﻐﯿﯿﺮ دﻫﯿﻢ و ﻋﻤﻠﯿﺎت ﺣﺬف و اﺿﺎﻓﻪ را ﻧﯿﺰ اﻧﺠﺎم دﻫﯿﻢ ﺑﻌﺪ از ﺳﺎﺧﺖ‪.‬‬ ‫•‬

‫ﺗﮑﺮار ﮐﻠﯿﺪ ﻫﺎ در دﯾﮑﺸﻨﺮی ﻗﺎﺑﻞ ﻗﺒﻮل ﻧﯿﺴﺖ و آﺧﺮﯾﻦ ﻣﻘﺪار در ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﺗﺎﺑﻊ )(‪ len‬ﻣﯿﺘﻮاﻧﯿﻢ ﻃﻮل دﯾﮑﺸﻨﺮی را ﺑﻪ دﺳﺖ آورﯾﻢ‪.‬‬ ‫•‬

‫ﻣﻘﺎدﯾﺮ ﻣﻮﺟﻮد در دﯾﮑﺸﻨﺮی ﻫﺎ ﻣﯿﺘﻮاﻧﻨﺪ از ﻫﺮ ﻧﻮع داده ای ﺑﺎﺷﻨﺪ‪.‬‬ ‫•‬

‫‪Access item‬‬ ‫‪DICTIONARIES‬‬ ‫‪Part 3‬‬

‫ﺑﻪ ﮐﻤﮏ ﻧﺎم ﮐﻠﯿﺪ در ﻋﻼﻣﺖ ﺑﺮاﮐﺖ ] [ ﻣﯿﺘﻮان ﺑﻪ ﻣﻘﺎدﯾﺮ آﯾﺘﻢ ﻫﺎ دﺳﺘﺮﺳﯽ ﭘﯿﺪا ﮐﺮد‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ get‬ﻧﯿﺰ ﻣﯿﺘﻮان ﺑﻪ ﻣﻘﺎدﯾﺮ آﯾﺘﻢ ﻫﺎی دﯾﮑﺸﻨﺮی دﺳﺘﺮﺳﯽ ﭘﯿﺪا ﮐﺮد‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ key‬در ﻗﺎﻟﺐ ﯾﮏ ﻣﺘﻐﯿﯿﺮ ﻣﯿﺘﻮان ﮐﻠﯿﺪ ﻫﺎی ﯾﮏ دﯾﮑﺸﻨﺮی را ﺑﻪ دﺳﺖ آورد‪.‬‬ ‫•‬
‫‪change item‬‬ ‫‪DICTIONARIES‬‬ ‫‪Part 4‬‬

‫ﺑﻪ ﮐﻤﮏ ﻧﺎم ﮐﻠﯿﺪ ﻣﯿﺘﻮان ﺑﻪ راﺣﺘﯽ ﻣﻘﺪار آن ﮐﻠﯿﺪ را ﺗﻐﯿﯿﺮ داد‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ update‬ﻧﯿﺰ ﻣﯿﺘﻮان ﻣﻘﺎدﯾﺮ را ﺗﻐﯿﯿﺮ داد‪.‬‬ ‫•‬
‫‪add item‬‬ ‫‪DICTIONARIES‬‬ ‫‪Part 5‬‬

‫ﺑﻪ ﮐﻤﮏ ﺗﻌﺮﯾﻒ ﯾﮏ ﮐﻠﯿﺪ ﺟﺪﯾﺪ و اﺧﺘﺼﺎص داده ﻣﻘﺪار ﺑﻪ آن ﻣﯿﺘﻮان ﺑﻪ دﯾﮑﺸﻨﺮی آﯾﺘﻢ اﺿﺎﻓﻪ ﮐﺮد‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ update‬ﻧﯿﺰ ﻣﯿﺘﻮان اﯾﻨﮑﺎر را اﻧﺠﺎم داد‪.‬‬ ‫•‬
‫‪Remove item‬‬ ‫‪DICTIONARIES‬‬ ‫‪Part 6‬‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ pop‬و دادن ﻧﺎم ﮐﻠﯿﺪ ﺑﻪ ﻋﻨﻮان ورودی ان ﻣﯿﺘﻮان آن آﯾﺘﻢ را ﺣﺬف ﮐﺮد‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ popitem‬ﻧﯿﺰ ﻣﯿﺘﻮان آﺧﺮﯾﻦ آﯾﺘﻢ را ﺣﺬف ﻧﻤﻮد‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﮐﻠﻤﻪ ﮐﻠﯿﺪی ‪ del‬و ﻧﺎم دﯾﮑﺸﻨﺮی و ﻧﺎم ﮐﻠﯿﺪ درون ﺑﺮاﮐﺖ ﻣﯿﺘﻮان آﯾﺘﻢ را ﺣﺬف ﮐﺮد‪.‬‬ ‫•‬

‫در ﺻﻮرت اﺳﺘﻔﺎده از ﻋﺒﺎرت ‪ del‬و ﺗﻌﺮﯾﻒ ﻧﮑﺮدن ﻧﺎم ﮐﻠﯿﺪ ﮐﻞ دﯾﮑﺸﻨﺮی ﺣﺬف ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ clear‬دﯾﮑﺸﻨﺮی ﺧﺎﻟﯽ ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬ ‫•‬

‫‪Loop in dicts‬‬ ‫‪DICTIONARIES‬‬ ‫‪Part 7‬‬

‫در ﺻﻮرت ﺣﻠﻘﻪ زدن در دﯾﮑﺸﻨﺮی ﺗﻨﻬﺎ ﺑﻪ ﮐﻠﯿﺪ ﻫﺎ دﺳﺘﺮﺳﯽ ﭘﯿﺪا ﻣﯿﮑﻨﯿﻢ‪.‬‬ ‫•‬

‫در ﺻﻮرت ﻧﯿﺎز ﺑﻪ دﺳﺘﺮﺳﯽ ﺑﻪ ﻣﻘﺎدﯾﺮ ﮐﻠﯿﺪ ﻫﺎ ﻣﯿﺒﺎﺳﺖ ﻧﺎم دﯾﮑﺸﻨﺮی و آﯾﺘﻢ آن ﺑﺎ ﻋﻨﻮان ﻣﺘﻐﯿﯿﺮ ﭘﺎﯾﻪ ﻣﯿﺘﻮان دﺳﺘﺮﺳﯽ ﭘﯿﺪا ﮐﺮد‪.‬‬ ‫•‬

‫روش دﯾﮕﺮ ﺑﺮای دﺳﺘﺮﺳﯽ ﺑﻪ ﻣﻘﺎدﯾﺮ آﯾﺘﻢ ﻫﺎ ﻣﯿﺘﻮان از ﻣﺘﺪ ‪ value‬ﻫﻨﮕﺎم ﺣﻠﻘﻪ زدن اﺳﺘﻔﺎده ﮐﺮد‪.‬‬ ‫•‬
‫‪Copy dicts‬‬ ‫‪DICTIONARIES‬‬ ‫‪Part 8‬‬

‫در ﺣﺎﻟﺖ ﻋﺎدی ﺑﻪ ﮐﻤﮏ ﻋﻤﻠﮕﺮ اﺧﺘﺼﺎص = ﻧﻤﯿﺘﻮان دﯾﮑﺸﻨﺮی ﻫﺎ را ﺑﻪ ﯾﮑﺪﯾﮕﺮ اﺧﺘﺼﺎص داد‪.‬‬ ‫•‬

‫ﺑﺮای اﯾﻨﮑﺎر از ﻣﺘﺪ )(‪ copy‬اﺳﺘﻔﺎده ﻣﯿﮑﻨﯿﻢ‪.‬‬ ‫•‬

‫ﯾﮏ روش دﯾﮕﺮ ﺑﺮای ﮐﭙﯽ ﮐﺮدن دﯾﮑﺸﻨﺮی اﺳﺘﻔﺎده از ﺗﺎﺑﻊ )(‪ dict‬اﺳﺖ‪.‬‬ ‫•‬
‫‪Nested dicts‬‬ ‫‪DICTIONARIES‬‬ ‫‪Part 9‬‬

‫ﯾﮏ دﯾﮑﺸﻨﺮی ﻣﯿﺘﻮاﻧﺪ ﺧﻮدش ﻧﯿﺰ ﺷﺎﻣﻞ دﯾﮑﺸﻨﺮی ﺑﺎﺷﺪ‪.‬‬ ‫•‬

‫ﺑﻪ ﭼﻨﯿﻦ داده ﻫﺎﯾﯽ دﯾﮑﺸﻨﺮی ﻫﺎی ﺗﻮ در ﺗﻮر ﮔﻔﺘﻪ ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫ﻧﺤﻮه دﺳﺘﺮﺳﯽ ﺑﻪ ﻣﻘﺎدﯾﺮ ﺑﻪ ﺷﮑﻞ ﻓﺮاﺧﻮاﻧﯽ ﭼﻨﺪ ﮐﻠﯿﺪ ﻣﺮﺗﺒﻂ ﺑﺎ ﻫﻢ اﺳﺖ‪.‬‬ ‫•‬

‫ﺑﯿﺸﺘﺮﯾﻦ ﮐﺎرﺑﺮد ﭼﻨﯿﻦ داده ای ﺑﺤﺚ وب ﺳﺮوﯾﺲ ﻫﺎ و اﭘﻠﯿﮑﯿﺸﻦ ﻫﺎی ﻣﻮﺑﺎﯾﻠﯽ اﺳﺖ‪.‬‬ ‫•‬

‫ﺗﻤﺮﯾﻦ‪ :‬اﻃﻼﻋﺎت ﻫﻮﯾﺘﯽ ‪ ۳‬ﮐﺎرﺑﺮ را ﺑﮕﯿﺮﯾﺪ و در ﻗﺎﻟﺐ ﯾﮏ دﯾﮑﺸﻨﺮی ذﺧﯿﺮه ﮐﻨﯿﺪ‪.‬‬ ‫•‬
 ‫‪Dict methods‬‬ ‫‪DICTIONARIES‬‬ ‫‪Part 10‬‬

‫ﻟﯿﺴﺖ ﻣﺘﺪ ﻫﺎی دﯾﮑﺸﻨﺮی ﺑﻪ ﺷﺮح زﯾﺮ اﺳﺖ‪:‬‬ ‫•‬

‫‪Methods‬‬ ‫‪Description‬‬
‫)(‪clear‬‬ ‫ﻫﻤﻪ ﻣﻘﺎدﯾﺮ دﯾﮑﺸﻨﺮی را ﭘﺎک ﻣﯿﮑﻨﺪ )ﮐﻠﯿﺪ و ﻣﻘﺪار(‬

‫)(‪copy‬‬ ‫ﯾﮏ ﮐﭙﯽ از دﯾﮑﺸﻨﺮی ﺑﺮﻣﯿﮕﺮداﻧﺪ‪.‬‬

‫)(‪fromkeys‬‬ ‫دﯾﮑﺸﻨﺮی را ﺑﺎ ﮐﻠﯿﺪﻫﺎ و ﻣﻘﺪار ﻣﺸﺨﺺ ﺷﺪه ﺑﺮﻣﯽ ﮔﺮداﻧﺪ‬

‫)(‪get‬‬ ‫ﯾﮏ ﻣﻘﺪار را ﺑﺮ اﺳﺎس ﮐﻠﯿﺪش ﺑﺮﻣﯿﮕﺮداﻧﺪ‪.‬‬

‫)(‪items‬‬ ‫ﯾﮏ ﻟﯿﺴﺖ ﺷﺎﻣﻞ ﺗﺎﭘﻞ ﻫﺎی ﮐﻠﯿﺪ و ﻣﻘﺎدﯾﺮ ﺑﺮﻣﮕﯿﺮداﻧﺪ‪.‬‬

‫)(‪keys‬‬ ‫ﯾﮏ ﻟﯿﺴﺖ ﺷﺎﻣﻞ ﮐﻠﯿﺪ ﻫﺎ ﺑﺮ ﻣﯿﮕﺮداﻧﺪ‪.‬‬

‫)(‪pop‬‬ ‫ﯾﮏ ﻣﻘﺪار ﻣﺸﺨﺺ ﺑﺮ اﺳﺎس ﮐﻠﯿﺪش ﺣﺬف ﻣﯿﮑﻨﺪ‪.‬‬

‫)(‪popitem‬‬ ‫آﺧﺮﯾﻦ آﯾﺘﻢ ﻟﯿﺴﺖ را ﺣﺬف ﻣﯿﮑﻨﺪ‪.‬‬

‫ﻣﻘﺪار ﮐﻠﯿﺪ ﻣﺸﺨﺺ ﺷﺪه را ﺑﺮﻣﯽ ﮔﺮداﻧﺪ‪ .‬اﮔﺮ ﮐﻠﯿﺪ وﺟﻮد ﻧﺪارد‪ :‬ﮐﻠﯿﺪ را ﺑﺎ‬
‫)(‪setdefault‬‬
‫ﻣﻘﺪار ﻣﺸﺨﺺ ﺷﺪه وارد ﮐﻨﯿﺪ‬
‫)(‪update‬‬ ‫دﯾﮑﺸﻨﺮی را ﺑﺮاﺳﺎس ﮐﻠﯿﺪ و ﻣﻘﺪار ﺑﺮوز ﻣﯿﮑﻨﺪ‪.‬‬

‫)(‪values‬‬ ‫ﻟﯿﺴﺖ ﻣﻘﺎدﯾﺮ دﯾﮑﺸﻨﺮی را ﺑﺮﻣﯿﮕﺮداﻧﺪ‪.‬‬

 ‫‪FUNCTIONS‬‬ ‫‪Part 1‬‬

‫در ﺑﺨﺶ ﻫﺎی ﮔﺬﺷﺘﻪ ﺑﺎ ﻧﺤﻮه ﻋﻤﻠﮑﺮد ﺳﺎده ﺗﻮاﺑﻊ آﺷﻨﺎ ﺷﺪﯾﻢ‪.‬‬ ‫•‬

‫ﻧﺤﻮه اﺳﺘﻔﺎده از ﺗﻮاﺑﻊ را ﯾﺎد ﮔﺮﻓﺘﯿﻢ‪.‬‬ ‫•‬

‫ﺑﺎ ﺗﻮاﺑﻌﯽ ﻣﺎﻧﻨﺪ ‪ print‬و ‪ input‬و ﺗﻮاﺑﻊ ﺗﺒﺪﯾﻞ ﻧﻮع و‪ ...‬آﺷﻨﺎ ﺷﺪﯾﻢ‪.‬‬ ‫•‬

‫ﺑﺎ ﭘﺎراﻣﺘﺮ ﻫﺎی ﺗﻮاﺑﻊ آﺷﻨﺎ ﺷﺪﯾﻢ ﮐﻪ ﺑﺎﻋﺚ ﯾﮑﺴﺮی ﺗﻨﻈﯿﻤﺎت روی ﺗﺎﺑﻊ ﺑﻮد‪.‬‬ ‫•‬

‫ﭘﺎﯾﺘﻮن دارای ﺗﻮاﺑﻊ ﭘﯿﺸﻔﺮض ﻣﺘﻌﺪدی اﺳﺖ‪.‬‬ ‫•‬

‫ﮔﺎﻫﯽ ﻣﺎ ﻧﯿﺎز دارﯾﻢ ﺗﻮاﺑﻊ ﺷﺨﺼﯽ ﺧﻮد را داﺷﺘﻪ ﺑﺎﺷﯿﻢ‪.‬‬ ‫•‬

‫در ﺣﻘﯿﻘﺖ ﺗﻮاﺑﻊ ﺑﺮای آﺳﺎن ﺗﺮ ﺷﺪن ﯾﮑﺴﺮی ﮐﺎر ﻫﺎ اﯾﺠﺎد ﺷﺪه اﻧﺪ‪.‬‬ ‫•‬

‫ﺑﺎ اﯾﺠﺎد ﺗﻮاﺑﻊ ﺷﺨﺼﯽ ﺧﻮد ﻣﯿﺘﻮاﻧﯿﻢ از ﻧﻮﺷﺘﻦ ﮐﺪ ﻫﺎی ﺗﮑﺮاری ﺟﻠﻮﮔﯿﺮی ﮐﻨﯿﻢ ‪.‬‬ ‫•‬

‫ﺣﺘﯽ ﻣﯿﺘﻮان ﺗﻮاﺑﻊ ﺧﻮد را ﺑﺎ دﯾﮕﺮ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﺎن ﺳﺮاﺳﺮ ﺟﻬﺎن ﺑﺮای اﺳﺘﻔﺎده ﺑﻪ اﺷﺘﺮاک ﺑﮕﺬارﯾﻢ‪.‬‬ ‫•‬
 ‫‪Create a function‬‬ ‫‪FUNCTIONS‬‬ ‫‪Part 2‬‬

‫ﻧﺤﻮه اﯾﺠﺎد ﺗﺎﺑﻊ ﺑﻪ ﮐﻤﮏ ﮐﻠﻤﻪ ﮐﯿﻠﺪی ‪ def‬اﺳﺖ‪.‬‬ ‫•‬

‫ﺗﻮاﺑﻊ ﻣﺸﺎﺑﻪ ﺣﻠﻘﻪ ﻫﺎ و ﺷﺮط ﻫﺎ دارای ﺑﺪﻧﻪ‪/‬ﺑﻼک ﻫﺴﺘﻨﺪ ﮐﻪ ﻣﺎ ﻧﺤﻮه ﻋﻤﻠﮑﺮد و ﺧﺮوﺟﯽ ﺗﺎﺑﻊ را در آﻧﺠﺎ ﻣﯿﻨﻮﯾﺴﯿﻢ‪.‬‬ ‫•‬

‫ﭘﺲ از ﮐﻠﻤﻪ ﮐﯿﻠﺪی ‪ def‬ﻧﺎم ﻣﺪ ﻧﻈﺮ ﺑﺮای ﺗﺎﺑﻊ ﺧﻮد را ﻣﯿﻨﻮﯾﺴﯿﻢ و ﭘﺲ از آن ﭘﺮاﻧﺘﺰ ﺑﺎز و ﺑﺴﺘﻪ و ﺳﭙﺲ ﻋﻼﻣﺖ دو ﻧﻘﻄﻪ ‪:‬‬ ‫•‬

‫ﺗﻮ رﻓﺘﮕﯽ را ﻣﺸﺎﺑﻪ ﺣﻠﻘﻪ ﻫﺎ رﻋﺎﯾﺖ ﻣﯿﮑﻨﯿﻢ و دﺳﺘﻮرات ﺧﻮد را در آﻧﺠﺎ ﻣﯿﻨﻮﯾﺴﯿﻢ‪.‬‬ ‫•‬
‫ﻧﺎم ﻣﺪ ﻧﻈﺮ ﺑﺮای ﻓﺮاﺧﻮاﻧﯽ ﺗﺎﺑﻌﺒﺎ رﻋﺎﯾﺖ ﻗﻮاﻧﯿﻦ ﻧﺎم ﮔﺬاری در ﭘﺎﯾﺘﻮن‬

‫‪def my_func():‬‬
‫‪pass‬‬

‫ﺑﺪﻧﻪ دﺳﺘﻮرات و ﻋﻤﻠﮑﺮد ﻣﻮرد ﻧﻈﺮ‬

‫‪Calling a function‬‬ ‫‪FUNCTIONS‬‬ ‫‪Part 3‬‬

‫اﺳﺘﻔﺎده از ﺗﻮاﺑﻊ را ‪ calling function‬ﻣﯿﮕﻮﯾﻨﺪ‪.‬‬ ‫•‬

‫ﺑﻪ ﻋﺒﺎرﺗﯽ ﯾﻌﻨﯽ ﺗﺎﺑﻊ را ﺻﺪا ﻣﯿﺰﻧﯿﻢ )ﻓﺮاﺧﻮاﻧﯽ ﻣﯿﮑﻨﯿﻢ(‬ ‫•‬

‫در ﻣﺜﺎل ﻣﻔﺎﺑﻞ ﻣﺎ ﯾﮏ ﺗﺎﺑﻊ ﺑﺎ ﻧﺎم ‪ amir‬اﯾﺠﺎد ﮐﺮدﯾﻢ‪.‬‬ ‫•‬

‫اﮐﻨﻮن در ﻫﺮ ﮐﺠﺎی ﺑﺮﻧﺎﻣﻪ اﯾﻦ ﺗﺎﺑﻊ را ﻓﺮاﺧﻮاﻧﯽ ﮐﻨﯿﻢ ﻋﺒﺎرت ‪ Hi. I’m Amir‬ﭼﺎپ ﻣﯿﺸﻮد‬ ‫•‬

‫ﺑﺪون اﯾﻨﮑﻪ ﻻزم ﺑﺎﺷﺪ ﻫﺮ ﺳﺮی ﭘﯿﺎم ﺧﻮد را ﺑﻨﻮﯾﺴﯿﻢ‪.‬‬

‫ﭘﺲ دﻟﯿﻞ اﯾﺠﺎد ﺗﻮاﺑﻊ را ﻣﺘﻮﺟﻪ ﺷﺪﯾﻢ‪.‬‬ ‫•‬

 ‫‪Arguments‬‬ ‫‪FUNCTIONS‬‬ ‫‪Part 4‬‬

‫در ﺑﺨﺶ ﻗﺒﻠﯽ ﻣﺸﺎﻫﺪه ﮐﺮدﯾﺪ ﮐﻪ ﻫﺮ ﺟﺎ ﻧﺎم ﺗﺎﺑﻊ را ﺻﺪا ﺑﺰﻧﯿﻢ ﻋﻤﻠﯿﺎت ﺗﺎﺑﻊ را ﮐﻪ از ﻗﺒﻞ ﻧﻮﺷﺘﻪ اﯾﻢ اﻧﺠﺎم ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫اﮔﺮ دﻗﺖ ﮐﺮده ﺑﺎﺷﯿﺪ ﻣﺜﻼ در ﺗﺎﺑﻊ ‪ print‬ﻣﺎ ﺑﺎﯾﺪ ﺣﺘﻤﺎ ﯾﮏ ورودی ﺑﻪ آن ﺑﺪﻫﯿﻢ اﻣﺎ در ﺗﺎﺑﻌﯽ ﮐﻪ ﻣﺎ اﯾﺠﺎد ﮐﺮدﯾﻢ ﻧﯿﺎز ﺑﻪ ورودی ﻧﺒﻮد‪.‬‬ ‫•‬

‫ﻣﺎ ﻣﯿﺘﻮاﻧﯿﻢ ﺑﺮای ﺗﺎﺑﻊ ﺧﻮد ورودی ﻣﺸﺨﺺ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫اﯾﻦ ورودی ﻫﺎی ﺗﺎﺑﻊ را آرﮔﻮﻣﺎن ﻣﯿﮕﻮﯾﻨﺪ‪.‬‬ ‫•‬

‫آرﮔﻮﻣﺎن ﻫﺎ اﻏﻠﺐ ﯾﮏ ﻣﺘﻐﯿﯿﺮ ﻫﺴﺘﻨﺪ ﮐﻪ ورودی ﺗﺎﺑﻊ را در ﺧﻮد ذﺧﯿﺮه ﻣﯿﮑﻨﻨﺪ و در ﺑﻼک‪/‬درون ﺗﺎﺑﻊ ﻣﯿﺘﻮاﻧﯿﻢ آن ورودی را اﺳﺘﻔﺎده و ﭘﺮدازش ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﯾﮏ ﺗﺎﺑﻊ ﻣﯿﺘﻮاﻧﺪ ﭼﻨﺪﯾﻦ آرﮔﻮﻣﺎن داﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬ ‫•‬

 ‫‪Arguments & Parameters‬‬ ‫‪FUNCTIONS‬‬ ‫‪Part 5‬‬

‫آرﮔﻮﻣﺎن ﻫﺎ ﻣﻘﺎدﯾﺮی ﻫﺴﺘﻨﺪ ﮐﻪ ﻫﻨﮕﺎم ﻓﺮاﺧﻮاﻧﯽ ﺗﺎﺑﻊ ﺑﻪ آن ارﺳﺎل ﻣﯿﺸﻮد و ﺗﺎﺑﻊ روی آﻧﻬﺎ ﭘﺮدازش اﻧﺠﺎم ﻣﯿﺪﻫﺪ‪.‬‬ ‫•‬

‫ﭘﺎراﻣﺘﺮ ﻫﺎ ﻣﺘﻐﯿﯿﺮ ﻫﺎﯾﯽ ﻫﺴﺘﻨﺪ ﮐﻪ ﻫﻨﮕﺎم اﯾﺠﺎد ﺗﺎﺑﻊ درون ﺧﻮد ﭘﺮاﻧﺘﺰ ﻫﺎی ﺗﺎﺑﻊ ﻟﯿﺴﺖ ﻣﯿﺸﻮﻧﺪ و ﺑﯿﺸﺘﺮ ﺑﺮای ﺗﻨﻈﯿﻤﺎت ﺧﻮد ﺗﺎﺑﻌﻤﺎن از‬ ‫•‬

‫آﻧﻬﺎ اﺳﺘﻔﺎده ﻣﯿﮑﻨﯿﻢ‪.‬‬

‫در ﻣﺜﺎل زﯾﺮ ﺗﺎﺑﻌﯽ اﯾﺠﺎد ﮐﺮده اﯾﻢ ﮐﻪ دو آرﮔﻮﻣﺎن دارد‪:‬‬ ‫•‬

‫آرﮔﻮﻣﺎن ﻫﺎ ﺑﺎ ﻋﻼﻣﺖ ‪ ,‬وﯾﺮﮔﻮل ﯾﺎ ﮐﺎﻣﺎ از ﻫﻢ ﺟﺪا ﻣﯿﺸﻮﻧﺪ‪.‬‬ ‫•‬

‫در ﻫﻨﮕﺎم ﻓﺮاﺧﻮاﻧﯽ در ﺻﻮرﺗﯽ ﮐﻪ آرﮔﻮﻣﺎن ﻫﺎی ورودی دﻗﯿﻘﺎ ﺗﻌﺪادﺷﺎن ‪ ۲‬ﻧﺒﺎﺷﺪ ﺑﺮﻧﺎﻣﻪ ﺑﺎ ﺧﻄﺎ ﻣﻮاﺟﻪ ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬ ‫•‬
 ‫‪Arbitrary Arguments, *args‬‬ ‫‪FUNCTIONS‬‬ ‫‪Part 6‬‬

‫در ﻣﺜﺎل ﻗﺒﻠﯽ ﻣﺸﺎﻫﺪه ﮐﺮدﯾﺪ ﮐﻪ در ﺣﺎﻟﺖ ﻋﺎدی ﯾﮏ ﺗﺎﺑﻊ ﺑﺎﯾﺪ ﺑﻪ ﺗﻌﺪاد ارﮔﻮﻣﺎن ﻫﺎی ﭘﯿﺸﻔﺮض ﺗﻌﺮﯾﻒ ﺷﺪه ورودی ﻧﯿﺰ ﺑﻪ ﻫﻤﺎن ﺗﻌﺪاد داد‪.‬‬ ‫•‬

‫در ﺻﻮرﺗﯽ ﮐﻪ ﻧﻤﯿﺪاﻧﯿﺪ ﯾﺎ ﻧﻤﯿﺨﻮاﻫﯿﺪ دﻗﯿﻘﺎ ﺑﻪ ﺗﻌﺪاد ﻣﺪ ﻧﻈﺮ ورودی داﺷﺘﻪ ﺑﺎﺷﯿﺪ و ﺑﺮ ﻋﻬﺪه ﮐﺎرﺑﺮ ﺑﮕﺬارﯾﺪ ﮐﺎﻓﯽ اﺳﺖ ﺑﻪ ﻫﻨﮕﺎم اﯾﺠﺎد ﺗﺎﺑﻊ‬ ‫•‬

‫ﻗﺒﻞ از آرﮔﻮﻣﺎن ﻣﺪ ﻧﻈﺮ ﻋﻼﻣﺖ * ﻗﺮار دﻫﯿﺪ‪.‬‬

‫ﺑﻪ ﮐﻤﮏ اﯾﻦ وﯾﮋﮔﯽ ﺗﺎﺑﻊ ﻣﯿﺘﻮاﻧﺪ ﺗﻌﺪاد ورودی ﻫﺎی ﻧﺎ ﻣﺸﺨﺼﯽ داﺷﺘﻪ ﺑﺎﺷﺪ‪.‬‬ ‫•‬

‫در ﺣﻘﯿﻘﺖ ورودی ﻫﺎ ﺑﻪ ﺷﮑﻞ ﺗﺎﭘﻞ درﯾﺎﻓﺖ ﻣﯿﺸﻮﻧﺪ!‬ ‫•‬

‫ﻣﺎﻧﻨﺪ ﺗﺎﺑﻊ ‪ print‬ﮐﻪ ﺗﻌﺪاد ورودی آن ﻣﺸﺨﺺ ﻧﺸﺪه اﺳﺖ و ﻣﯿﺘﻮان ﻫﺮ ﭼﻨﺪ ﺗﻌﺪاد ﮐﻪ ﻣﯿﺨﻮاﻫﯿﻢ ﺑﻪ آن ورودی ﺑﺪﻫﯿﻢ و ﺑﺎ ﻋﻼﻣﺖ ‪ ,‬از ﻫﻢ‬ ‫•‬

‫ﺟ ﺪ ا ﮐ ﻨ ﯿ ﻢ‪.‬‬

‫در ﺻﻮرت اﺳﺘﻔﺎده از دو ﻋﻼﻣﺖ ** ﻗﺒﻞ از آرﮔﻮﻣﺎن ﺗﺎﺑﻊ ورودی ﻫﺎ را ﺑﻪ ﺷﮑﻞ دﯾﮑﺸﻨﺮی درﯾﺎﻓﺖ ﻣﯿﮑﻨﺪ‪.‬‬ ‫•‬
‫‪Keyword Arguments‬‬ ‫‪FUNCTIONS‬‬ ‫‪Part 7‬‬

‫ﺷﻤﺎ ﻫﻤﭽﻨﯿﻦ ﻣﯿﺘﻮاﻧﯿﺪ ﻣﻘﺎدﯾﺮ آرﮔﻮﻣﺎن ﻫﺎ را ﺑﺎ ﮐﻠﯿﺪ‪/‬ﻧﺎم ﻣﺘﻐﯿﯿﺮ آﻧﻬﺎ ﺑﻪ ﺗﺎﺑﻊ ارﺳﺎل ﮐﻨﯿﺪ‪.‬‬ ‫•‬
‫‪Default Parameter Value‬‬ ‫‪FUNCTIONS‬‬ ‫‪Part 8‬‬

‫در ﺻﻮرﺗﯽ ﮐﻪ ﯾﮏ آرﮔﻮﻣﺎن را ﺑﻪ ﻃﻮر آن ﭘﯿﺸﻔﺮض ﺑﻪ آن ﻣﻘﺪار ﺑﺪﻫﯿﻢ ﺗﺒﺪﯾﻞ ﺑﻪ ﭘﺎراﻣﺘﺮ ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬ ‫•‬

‫ﻣﯿﺘﻮان ﻣﻘﺪار ﭘﯿﺸﻔﺮض ﭘﺎراﻣﺘﺮ را ﭘﺮدازش ﮐﺮد‪.‬‬ ‫•‬

‫ﻫﻤﭽﻨﯿﻦ اﮔﺮ ﺗﺎﺑﻊ ورودی ﻧﺪاﺷﺘﻪ ﺑﺎﺷﻪ ﺑﻪ ﻃﻮر ﺧﻮدﮐﺎر از ﻣﻘﺪار ﭘﯿﺸﻔﺮض ﭘﺎراﻣﺘﺮ اﺳﺘﻔﺎده ﻣﯿﮑﻨﺪ‪.‬‬ ‫•‬
‫‪Passing a List as an Argument‬‬ ‫‪FUNCTIONS‬‬ ‫‪Part 9‬‬

‫ﺷﻤﺎ ﻣﯿﺘﻮاﻧﯿﺪ ﻫﺮ ﻧﻮﻋﯽ از داده را ﺑﻪ ﺗﻮاﺑﻊ ارﺳﺎل ﮐﻨﯿﺪ ‪.‬‬ ‫•‬

‫اﻧﻮاع داده ﻫﺎی ﭘﺎﯾﺘﻮن را در ﺗﻮاﺑﻊ ﻣﯿﺘﻮان ﭘﺮدازش ﮐﺮد‪.‬‬ ‫•‬

‫اﯾﺠﺎد ﺗﺎﺑﻊ ﻣﺤﺎﺳﺒﻪ ﻣﺴﺎﺣﺖ داﯾﺮه‬ ‫‪FUNCTIONS‬‬ ‫‪Part 10‬‬

‫ﺑﺎ ﻧﺤﻮه اﯾﺠﺎد ﺗﻮاﺑﻊ آﺷﻨﺎ ﺷﺪﯾﻢ‪.‬‬ ‫•‬

‫ﺑﺎ آرﮔﻮﻣﺎن ﻫﺎ و ﭘﺮدازش آﻧﻬﺎ آﺷﻨﺎ ﺷﺪﯾﻢ‪.‬‬ ‫•‬

‫ﻣﯿﺨﻮاﻫﯿﻢ ﯾﮏ ﺗﺎﺑﻊ اﯾﺠﺎد ﮐﻨﯿﻢ ﮐﻪ ﻣﺴﺎﺣﺖ داﯾﺮه را ﺣﺴﺎب ﮐﻨﺪ‪.‬‬ ‫•‬

‫ﻧﺤﻮه ﻣﺤﺎﺳﺒﻪ ﻣﺴﺎﺣﺖ داﯾﺮه ﺑﺮاﺑﺮ اﺳﺖ ﺑﺎ ﺷﻌﺎع * ﺷﻌﺎع * ﻋﺪد ‪pi‬‬ ‫•‬

‫ﺑﻨﺎﺑﺮ ﻓﺮﻣﻮل ﺗﻨﻬﺎ ﮐﺎﻓﯽ اﺳﺖ ﺷﻌﺎع را ﺑﻪ ﻋﻨﻮان آرﮔﻮﻣﺎن ﺑﻪ ﺗﺎﺑﻊ ﺑﺪﻫﯿﻢ و ﺑﺎﻗﯽ ﭘﺮدازش ﻫﺎ را درون ﺗﺎﺑﻊ اﻧﺠﺎم دﻫﯿﻢ‪.‬‬ ‫•‬
 ‫‪Return Values‬‬ ‫‪FUNCTIONS‬‬ ‫‪Part 11‬‬

‫ﺗﺎ ﮐﻨﻮن ﺗﻮاﺑﻌﯽ ﮐﻪ اﯾﺠﺎد ﮐﺮدﯾﻢ ﯾﮏ ﺳﺮی ورودی درﯾﺎﻓﺖ ﻣﯿﮑﺮد و ﭘﺮدازش ﻫﺎﯾﯽ اﻧﺠﺎم ﻣﯿﺪاد و در ﻧﻬﺎﯾﺖ ﯾﮏ ﺧﺮوﺟﯽ ﺑﻪ ﻣﺎ ﻧﻤﺎﯾﺶ ﻣﯿﺪاد‪.‬‬ ‫•‬

‫ﻣﺎ ﻣﯿﺘﻮاﻧﻢ از ﺧﺮوﺟﯽ ﺗﻮاﺑﻊ ﺑﻪ ﻋﻨﻮان ﯾﮏ ﻣﻘﺪار در ﺟﺎ ﻫﺎی ﻣﺨﺘﻠﻒ ﺑﺮﻧﺎﻣﻪ اﺳﺘﻔﺎده ﮐﻨﯿﻢ ﻣﺜﻼ درون ﯾﮏ ﻣﺘﻐﯿﯿﺮ ﯾﺎ ﯾﮏ ﺗﺎﺑﻊ دﯾﮕﺮ‪.‬‬ ‫•‬

‫ﺑﺮای اﯾﻦ ﮐﺎر از ﻋﺒﺎرت ‪ return‬اﺳﺘﻔﺎده ﻣﯿﮑﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺑﺮای ﻣﺜﺎل ﻣﯿﺨﻮاﻫﯿﻢ ﺗﺎﺑﻌﯽ اﯾﺠﺎد ﮐﻨﯿﻢ ﮐﻪ ﺳﻦ ﻣﺎ را ﺑﺮ اﺳﺎس ﺳﺎل ﺑﮕﯿﺮﯾﺪ و ﺧﺮوﺟﯽ آن ﺗﻌﺪاد روز ﻫﺎی ﻋﻤﺮﻣﺎن ﺑﺎﺷﺪ ﻫﻤﭽﻨﯿﻦ ﺗﻮاﻧﯿﻢ‬ ‫•‬

‫ﺧﺮوﺟﯽ را در ﺑﺨﺶ ﻫﺎی ﻣﺨﺘﻠﻒ اﺳﺘﻔﺎده ﮐﻨﯿﻢ‪.‬‬

‫‪Python Lambda‬‬ ‫‪FUNCTIONS‬‬ ‫‪Part 12‬‬

‫ﻣﺎ ﻣﯿﺘﻮاﻧﯿﻢ ﺗﻮاﺑﻊ ﺧﻮد را ﮐﻮﺗﺎه ﻧﻮﯾﺴﯽ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺑﻪ ﺗﻮاﺑﻊ ﮐﻮﺗﺎه ‪ Lambda‬ﻣﯿﮕﻮﯾﻨﺪ‪.‬‬ ‫•‬

‫ﻻﻣﺒﺪا ﻫﺎ ﻣﯿﺘﻮاﻧﻨﺪ ﻫﺮ ﺗﻌﺪادی آرﮔﻮﻣﺎن ﺑﮕﯿﺮﯾﺪ اﻣﺎ ﻓﻘﻂ ﯾﮏ ﭘﺮدازش ﻣﯿﺘﻮاﻧﺪ اﻧﺠﺎم دﻫﺪ‪.‬‬ ‫•‬

‫در ﻣﺜﺎل زﯾﺮ ﻻﻣﺒﺪا دو آرﮔﻮﻣﺎن ﻣﯿﮕﯿﺮﯾﺪ اﻣﺎ ﻓﻘﻂ ﯾﮏ ﻋﻤﻠﯿﺎت ﺿﺮب اﻧﺠﺎم ﻣﯿﺪﻫﺪ‪.‬‬ ‫•‬
 ‫‪Python Scope‬‬ ‫‪FUNCTIONS‬‬ ‫‪Part 13‬‬

‫ﯾﮏ ﻣﺘﻐﯿﯿﺮ ﻓﻘﻂ در ﻣﺤﺪوده اﯾﺠﺎد ﺷﺪه ﺧﻮدش در دﺳﺘﺮس اﺳﺖ‪.‬‬ ‫•‬

‫ﺑﻪ اﯾﻦ ﻗﻀﯿﻪ اﺳﮑﻮپ ﻣﯿﮕﻮﯾﻨﺪ‪.‬‬ ‫•‬

‫در زﺑﺎن ﭘﺎﯾﺘﻮن دو ﻧﻮع اﺳﮑﻮپ دارﯾﻢ‪:‬‬ ‫•‬

‫‪ :Local scope‬ﻣﺘﻐﯿﯿﺮی ﮐﻪ درون ﺗﺎﺑﻊ اﯾﺠﺎد ﺷﺪه اﺳﺖ و ﺗﻨﻬﺎ در آﻧﺠﺎ ﻗﺎﺑﻞ اﺳﺘﻔﺎده اﺳﺖ‪.‬‬ ‫•‬

‫‪ :Global scope‬ﻣﺘﻐﯿﯿﺮی ﮐﻪ در ﺑﺪﻧﻪ اﺻﻠﯽ ﺑﺮﻧﺎﻣﻪ ﺗﻌﺮﯾﻒ ﺷﺪه اﺳﺖ و در ﻫﺮ ﺟﺎﯾﯽ ﻗﺎﺑﻞ اﺳﺘﻔﺎده اﺳﺖ‪.‬‬ ‫•‬

‫ﻫﻤﭽﻨﯿﻦ ﺑﻪ ﮐﻤﮏ ﮐﻠﻤﻪ ﮐﻠﯿﺪی ‪ global‬ﻗﺒﻞ از ﻧﺎم ﻣﺘﻐﯿﯿﺮ آن ﻣﺘﻐﯿﯿﺮ را ﻣﯿﺘﻮان در ﻫﺮ ﺟﺎﯾﯽ از ﺑﺮﻧﺎﻣﻪ اﺳﺘﻔﺎده ﮐﺮد ﺣﺘﯽ اﮔﺮ درون ﺗﺎﺑﻊ ﺑﺎﺷﺪ‪.‬‬ ‫•‬
‫‪Python modules‬‬ ‫‪MODULES‬‬ ‫‪Part 1‬‬

‫در اﯾﻦ ﺑﺨﺶ ﺑﻪ ﻣﺎژول ﻫﺎ ﻣﯿﭙﺮدازﯾﻢ‪.‬‬ ‫•‬

‫ﻣﺎژول ﻫﺎ در ﺣﻘﯿﻘﺖ ﯾﮏ ﻓﺎﯾﻞ ﻫﺴﺘﻨﺪ ﺷﺎﻣﻞ اﻧﻮاع ﺗﻮاﺑﻊ ﮐﻪ ﻣﺎ ﻣﯿﺘﻮاﻧﯿﻢ از آﻧﻬﺎ در ﺑﺮﻧﺎﻣﻪ ﺧﻮد اﺳﺘﻔﺎده ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫در زﺑﺎن ﻫﺎی دﯾﮕﺮ ﺑﻪ ﻣﺎژول ﻫﺎ ﮐﺘﺎﺑﺨﺎﻧﻪ ﯾﺎ ﭘﮑﯿﺞ ﻧﯿﺰ ﻣﯿﮕﻮﯾﻨﺪ‪.‬‬ ‫•‬

‫ﻧﺤﻮه اﯾﺠﺎد و اﺳﺘﻔﺎده از ﻣﺎژول‪:‬‬ ‫•‬

‫ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ اﯾﻨﮑﻪ ﺑﻪ ﻃﻮل ﮐﺎﻣﻞ ﺑﺎ ﺗﻮاﺑﻊ آﺷﻨﺎ ﺷﺪﯾﻢ ﻣﺘﻮاﻧﯿﻢ ﻣﺎژول ﻫﺎی ﺧﻮد را ﺑﻨﻮﯾﺴﯿﻢ و اﺳﺘﻔﺎده ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﯾﮏ ﻓﺎﯾﻞ ﭘﺎﯾﺘﻮﻧﯽ اﯾﺠﺎد ﮐﻨﯿﺪ و ﺗﻮاﺑﻊ ﻣﺪ ﻧﻈﺮ ﺧﻮد را در آن ﺑﻨﻮﯾﺴﯿﺪ‪.‬‬ ‫•‬

‫اﯾﻦ ﻓﺎﯾﻠﯽ ﮐﻪ اﯾﺠﺎد ﮐﺮدﯾﺪ ﯾﮏ ﻣﺎژول اﺳﺖ‪ .‬ﺣﺎﻻ ﭼﮕﻮﻧﻪ از آن اﺳﺘﻔﺎده ﮐﻨﯿﻢ؟‬ ‫•‬

‫ﮐﺎﻓﯽ اﺳﺖ ﯾﮏ ﻓﺎﯾﻞ ﭘﺎﯾﺘﻮﻧﯽ دﯾﮕﺮ اﯾﺠﺎد ﮐﻨﯿﻢ و در ﺧﻂ اول آن از ﻋﺒﺎرت ‪ import‬ﺳﭙﺲ ﻧﺎم ﻓﺎﯾﻞ ﻣﺎژوﻟﯽ ﮐﻪ ﺳﺎﺧﺘﻢ ﺑﻨﻮﯾﺴﯿﻢ‪.‬‬ ‫•‬

‫ﻣﺎزول ﻣﺎ ﮐﻪ ﺷﺎﻣﻞ ﯾﮑﺴﺮی ﺗﻮاﺑﻊ اﺳﺖ ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﺟﺪﯾﺪ ﻣﺎ اﺿﺎﻓﻪ ﺷﺪ‪.‬‬ ‫•‬
 ‫‪Using modules‬‬ ‫‪MODULES‬‬ ‫‪Part 2‬‬

‫دﻟﯿﻞ اﺳﺘﻔﺎده از ﻣﺎژول ﮐﻤﺘﺮ ﺷﺪن ﮐﺪ ﻫﺎ و اﺳﺘﻔﺎده از ﺗﻮﺑﻊ آﻣﺎده و‪ ...‬اﺳﺖ‪.‬‬ ‫•‬

‫دﻗﺖ ﮐﻨﯿﺪ ﺑﻌﺪ از اﯾﻨﮑﻪ ﻣﺎژول ﺧﻮد را اﯾﺠﺎد ﮐﺮدﯾﺪ ﺑﺮای اﺳﺘﻔﺎده در ﺑﺮﻧﺎﻣﻪ دﯾﮕﺮ ﺣﺘﻤﺎ ﻓﺎﯾﻞ ﻣﺎژول ﻣﯿﺒﺎﯾﺴﺖ ﮐﻨﺎر ﺑﺮﻧﺎﻣﻪ ﺑﺎﺷﺪ‪.‬‬ ‫•‬

‫در ﻣﺜﺎل زﯾﺮ ﯾﮏ ﻣﺎژول ﺳﺎﺧﺘﯿﻢ ﮐﻪ درون آن دو ﺗﺎﺑﻊ ﺿﺮب و ﻣﺴﺎﺣﺖ داﯾﺮه وﺟﻮد دارد‪.‬‬ ‫•‬

‫در ﺑﺮﻧﺎﻣﻪ دﯾﮕﺮ آن ﻣﺎژول را اﺿﺎﻓﻪ ﮐﺮدﯾﻢ از ﺗﻮاﺑﻊ دورن آن اﺳﺘﻔﺎده ﮐﺮدﯾﻢ‪.‬‬ ‫•‬

‫ﺑﺮای اﺳﺘﻔﺎده از ﺗﻮاﺑﻊ درون ﯾﮏ ﻣﺎژول ﻧﺎم ﻣﺎژول ﺳﭙﺲ ﻋﻼﻣﺖ ‪ .‬ﺳﭙﺲ ﻧﺎم ﺗﺎﺑﻊ را ﻣﯿﻨﻮﯾﺴﯿﻢ و ﻣﻘﺪار ورودی را ﺑﻪ آن ﻣﯿﺪﻫﯿﻢ‪.‬‬ ‫•‬

‫و از ﻣﺎژول ﺳﺎﺧﺘﻪ ﺷﺪه در ﺑﺮﻧﺎﻣﻪ ﺟﺪﯾﺪﻣﺎن اﺳﺘﻔﺎده ﮐﺮدﯾﻢ ﺑﻪ راﺣﺘﯽ‪.‬‬ ‫•‬

‫ﻣﺎژول ﺧﻮد را ﻣﯿﺘﻮاﻧﯿﻢ ﺑﺎ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺲ ﻫﺎی ﻣﺨﺘﻠﻒ ﺑﻪ اﺷﺘﺮاک ﺑﮕﺬارﯾﻢ‪.‬‬ ‫•‬
 ‫‪Using modules‬‬ ‫‪MODULES‬‬ ‫‪Part 3‬‬

‫ﻫﻤﺎﻧﻄﻮر ﮐﻪ ﮔﻔﺘﻪ ﺷﺪ ﻣﺎ ﺑﺮای راﺣﺘﯽ ﮐﺎرﻣﺎن از ﻣﺎژول ﻫﺎ اﺳﺘﻔﺎده ﻣﯿﮑﻨﯿﻢ‪.‬‬ ‫•‬

‫ﻫﻤﯿﺸﻪ ﻧﯿﺎز ﻧﯿﺴﺖ ﺗﻤﺎﻣﯽ ﺑﺮﻧﺎﻣﻪ را ﺧﻮدﺗﺎن ﺑﻨﻮﯾﺴﯿﺪ‪.‬‬ ‫•‬

‫ﺑﻌﻀﺎ ﻣﯿﺒﺎﯾﺴﺖ ﻣﺎ ﺑﺮای رﺳﯿﺪن ﺑﻪ اﻫﺪاف ﺧﻮد در ﺑﺮﻧﺎﻣﻪ از ﻣﺎژول ﻫﺎ اﺳﺘﻔﺎده ﮐﻨﯿﻢ‪ .‬ﭼﺮا؟‬ ‫•‬

‫ﭼﻮن زﻣﺎن ﮐﺎﻓﯽ ﻧﺪارﯾﻢ !‬ ‫•‬

‫ﭼﻮن ﺑﺮ ﻣﺒﺎﺣﺚ اﻟﮕﻮرﯾﺘﻤﯽ ﻣﺴﻠﻂ ﻧﯿﺴﺘﯿﻢ !‬ ‫•‬

‫ﻓﺮض ﮐﻨﯿﺪ ﻧﯿﺎز ﺑﻪ ﺗﺎﺑﻊ ﯾﺎ ﻗﻄﻌﻪ ﮐﺪی دارﯾﺪ ﮐﻪ ﺑﯽ ﻧﻬﺎﯾﺖ از ﺷﻤﺎ ﻋﺪد ﺑﮕﯿﺮد و آﻧﻬﺎ را در ﻫﻢ ﺿﺮب ﮐﻨﺪ‪ .‬ﺧﺐ ﺷﻤﺎ ﻓﺮﺿﺎ ﻣﯿﺘﻮاﻧﺪ ﺗﺎﺑﻊ ﺑﺴﺎزﯾﺪ ﮐﻪ دو ﻋﺪد ﺑﮕﯿﺮﯾﺪ‬ ‫•‬

‫او اﻧﻬﺎ را در ﻫﻢ ﺿﺮب ﮐﻨﺪ‪ .‬اﻣﺎ ﻧﻤﺘﻮاﻧﯿﺪ ﯾﺎ وﻗﺖ ﻧﺪارﯾﺪ ﭼﻨﯿﻦ ﺑﺮﻧﺎﻣﻪ ﺑﺮﻧﺎﻣﻪ ای ﺑﻨﻮﯾﺴﯿﺪ ﮐﻪ ﭼﻨﺪﯾﻦ ﻋﺪد را در ﻫﻢ ﺿﺮب ﮐﻨﺪ‪ .‬اﯾﻨﺠﺎ اﺳﺖ ﮐﻪ ﺳﺮاغ ﻣﺎژول ﻫﺎی‬

‫ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺲ ﻫﺎی دﯾﮕﺮ ﻣﯿﺮوﯾﺪ‪.‬‬

‫ﻣﺎژول ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺲ دﯾﮕﺮ‬ ‫اﺳﺘﻔﺎده از ﻣﺎژول در ﺑﺮﻧﺎﻣﻪ ﺧﻮدﻣﺎن‬

‫‪Renaming a module‬‬ ‫‪MODULES‬‬ ‫‪Part 4‬‬

‫ﮔﺎﻫﺎ ﻧﺎم ﺑﺮﺧﯽ از ﻣﺎژول ﻫﺎ ﻃﻮﻻﻧﯽ اﺳﺖ و ﺑﻪ ﻫﻨﮕﺎم اﺳﺘﻔﺎده از ﺗﻮاﺑﻊ و ﻣﺘﺪ ﻫﺎی آن ﮐﺪ ﻣﺎ ﮐﻤﯽ ﺑﯿﺸﺘﺮ ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬ ‫•‬

‫ﻣﺎ ﻣﯿﺘﻮاﻧﯿﻢ ﻫﺮ ﻣﺎژوﻟﯽ ﮐﻪ ﺑﻪ ﺑﺮﻧﺎﻣﻪ اﺿﺎﻓﻪ ﮐﺮدﯾﻢ را ﻧﺎم دﻫﯽ ﮐﻨﯿﻢ و ﻧﺎم اﺧﺘﺼﺎری ﺑﻪ آن ﺑﺪﻫﯿﻢ ﮐﻪ ﺣﯿﻦ اﺳﺘﻔﺎده دﺳﺘﺮﺳﯽ ﺑﻪ آن آﺳﺎن ﺗﺮ ﺑﺎﺷﺪ‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﮐﻠﻤﻪ ﮐﻠﯿﺪی ‪ as‬اﯾﻨﮑﺎر را اﻧﺠﺎم ﻣﯿﺪﻫﯿﻢ‪.‬‬ ‫•‬

 ‫‪import from module‬‬ ‫‪MODULES‬‬ ‫‪Part 5‬‬

‫زﻣﺎﻧﯽ ﮐﻪ ﺑﻪ ﮐﻤﮏ ﻋﺒﺎرت ‪ import‬ﯾﮏ ﻣﺎژول را ﺑﻪ ﺑﺮﻧﺎﻣﻪ اﺿﺎﻓﻪ ﻣﯿﮑﻨﯿﻢ ﺗﻤﺎم ﺗﻮاﺑﻊ و ﻣﺘﺪ و ﻣﺘﻐﯿﯿﺮ ﻫﺎ و‪ ...‬آن ﻣﺎژول ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﻣﺎ اﺿﺎﻓﻪ ﺧﻮاﻫﻨﺪ ﺷﺪ‪.‬‬ ‫•‬

‫ﯾﮏ ﻣﺎژول ﻣﻤﮑﻦ اﺳﺖ ﺷﺎﻣﻞ ‪ ۱۰۰‬ﻫﺎ ﺗﺎﺑﻊ و‪ ...‬ﺑﺎﺷﺪ ﮐﻪ ﻫﻤﮕﯽ ان ﻫﺎ ﺑﺮای ﻣﺎ ﮐﺎرﺑﺮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ و ‪ import‬ﮐﺮدن آن ﻣﺎزول ﺑﺎﻋﺚ ﺳﻨﮕﯿﻨﯽ ﺑﺮﻧﺎﻣﻪ ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﮐﻠﻤﻪ ﮐﻠﯿﺪی ‪ from‬ﻣﯿﺘﻮاﻧﯿﻢ ﺑﮕﻮﯾﯿﻢ دﻗﯿﻘﺎ از ﯾﮏ ﻣﺎژول ﭼﻪ ﺑﺨﺶ ﻫﺎﯾﯽ ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﻣﺎ اﺿﺎﻓﻪ ﺷﻮد‪.‬‬ ‫•‬

‫ﺑﺮای ﻣﺜﺎل در ﺑﺮﻧﺎﻣﻪ ﻣﻘﺎﺑﻞ ﻓﻘﻂ ﻧﯿﺎز ﺑﻪ ﺗﺎﺑﻊ ‪ c_area‬دارﯾﻢ و ﻧﺨﻮاﻫﯿﻢ ﺑﻘﯿﻪ ﻣﻮارد ﻣﺎژول ‪ mymodule‬ﺑﻪ ﺑﺮﻧﺎﻣﻪ اﺿﺎﻓﻪ ﺷﻮد‪.‬‬ ‫•‬

‫ﻫﻤﭽﻨﯿﻦ در ﺻﻮرت اﺳﺘﻔﺎده از اﯾﻦ روش دﯾﮕﺮی ﻧﯿﺎزی ﺑﻪ ﻧﻮﺷﺘﻦ ﻧﺎم ﻣﺎژول ﻗﺒﻞ از ﺗﺎﺑﻊ ﯾﺎ‪ ...‬ﻣﺪ ﻧﻈﺮ ﻧﯿﺴﺖ‪.‬‬ ‫•‬
 ‫‪Built-In modules‬‬ ‫‪MODULES‬‬ ‫‪Part 6‬‬

‫در ﺑﺨﺶ ﻫﺎی اﺑﺘﺪای ﮔﻔﺘﻪ ﺷﺪ ﮐﻪ زﺑﺎن ﭘﺎﯾﺘﻮن دارای ﺗﻮاﺑﻊ ﭘﯿﺸﻔﺮض ﻣﺘﻌﺪدی اﺳﺖ ﮐﻪ ﻣﺎ ﺑﺎ ﺻﺪا زدن آﻧﻬﺎ ﻣﯿﺘﻮاﻧﯿﻢ آﻧﻬﺎ را ﺑﻪ ﮐﺎر ﮔﯿﺮﯾﻢ‪.‬‬ ‫•‬

‫ﻫﻤﭽﻨﯿﻦ ﭘﺎﯾﺘﻮن دارای ﻣﺎژول ﻫﺎی ﭘﯿﺸﻔﺮض ﻧﯿﺰ ﻣﯿﺒﺎﺷﺪ ﮐﻪ ﺑﻪ ﻫﻨﮕﺎم ﻧﺼﺐ ﭘﺎﯾﺘﻮن آن ﻣﺎژول ﻫﺎ ﻧﯿﺰ در ﮐﻨﺎر ﭘﺎﯾﺘﻮن ﻧﺼﺐ ﻣﯿﺸﻮﻧﺪ‪.‬‬ ‫•‬

‫ﻣﺎژول ﻫﺎ ﻣﻌﻤﻮﻻ در ﻣﺤﻞ ﻧﺼﺐ ﭘﺎﯾﺘﻮن در رﯾﺸﻪ آن در داﯾﺮﮐﺘﻮری ‪ lib‬ﻗﺮار دارﻧﺪ‪.‬‬ ‫•‬

‫اﻟﺒﺘﻪ ﺑﺴﺘﻪ ﺑﻪ ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ ﻣﻮرد اﺳﺘﻔﺎده ﻣﻤﮑﻦ اﺳﺖ ﻣﺤﻞ ﻣﺎژول ﻫﺎ و ﺧﻮد ﻣﺤﻞ ﻧﺼﺐ ﺷﺪه ﭘﺎﯾﺘﻮن ﻣﺘﻔﺎوت ﺑﺎﺷﺪ‪.‬‬ ‫•‬

‫در ﺑﺨﺶ ﻗﺒﻠﯽ ﻣﺘﻮﺟﻪ ﺷﺪﯾﻢ ﮐﻪ اﮔﺮ ﻣﺎژوﻟﯽ را ﺧﻮدﻣﺎن ﺑﺴﺎزﯾﻢ و ﻗﺼﺪ اﺳﺘﻔﺎده از آن را داﺷﺘﻪ ﺑﺎﺷﯿﻢ ﺣﺘﻤﺎ ﺑﺎﯾﺪ ﻓﺎﯾﻞ ﻣﺎژول در ﮐﻨﺎر ﺑﺮﻧﺎﻣﻪ ﺟﺪﯾﺪ ﺑﺎﺷﺪ‪.‬‬ ‫•‬

‫در ﺣﺎل ﺣﺎﺿﺮ ﻧﯿﺎزی ﻧﯿﺴﺖ ﺑﻪ دﻧﺒﺎل ﻣﺴﯿﺮ ﻣﺎژول ﻫﺎی ﭘﯿﺸﻔﺮض ﭘﺎﯾﺘﻮن ﺑﺎﺷﯿﻢ ﭼﺮاﮐﻪ ﺑﺎ ﻋﺒﺎرت ‪ import‬و ﻧﺎم آن ﻣﺎژول ﺑﻪ راﺣﺘﯽ ﻣﯿﺘﻮاﻧﯿﻢ ﻣﺎژول را ﺑﻪ ﺑﺮﻧﺎﻣﻪ‬ ‫•‬

‫ﺧﻮد اﺿﺎﻓﻪ ﮐﻨﯿﻢ‪.‬‬

‫‪Built-In modules‬‬ ‫‪MODULES‬‬ ‫‪Part 7‬‬

‫ﻣﺎژول ﻫﺎی ﭘﯿﺸﻔﺮض ﻧﺼﺐ ﺷﺪه در ﮐﻨﺎر ﭘﺎﯾﺘﻮن ﭼﻪ ﻫﺴﺘﻨﺪ؟‬ ‫•‬

‫ﺑﺮای دﯾﺪن ﻟﯿﺴﺖ ﻣﺎژول ﻫﺎی ﻧﺼﺐ ﺷﺪه ﻧﯿﺎزی ﺑﻪ رﻓﺘﻦ ﺑﻪ داﯾﺮﮐﺘﻮری ﭘﺎﯾﺘﻮن ﻧﯿﺴﺖ‪.‬‬ ‫•‬

‫ﺑﺮای اﯾﻨﮑﺎر ﻣﺤﯿﻂ ‪ CMD/Terminal‬را ﺑﺎز ﮐﻨﯿﺪ و ﭘﺎﯾﺘﻮن را اﺟﺮا ﮐﻨﯿﺪ‪.‬‬ ‫•‬

‫ﺳﭙﺲ ﺗﺎﺑﻊ ‪ help‬را ﻓﺮاﺧﻮاﻧﯽ ﮐﻨﯿﺪ و آرﮔﻮﻣﺎن ورودی آن را ’‪ ‘modules‬ﻗﺮار دﻫﯿﺪ‪.‬‬ ‫•‬

‫ﻟﯿﺴﺖ ﻣﺎژول ﻫﺎی ﭘﯿﺸﻔﺮض را ﻣﺸﺎﻫﺪه ﺧﻮاﻫﯿﺪ ﮐﺮد‪.‬‬ ‫•‬

‫ﺳﻮال‪ :‬آﯾﺎ ﻧﯿﺎز اﺳﺖ ﺗﻤﺎم ﻣﺎژول ﻫﺎی ﭘﯿﺸﻔﺮض ﭘﺎﯾﺘﻮن را ﺑﻠﺪ ﺑﺎﺷﯿﻢ؟‬ ‫•‬

‫ﺧﯿﺮ ﺑﻪ ﻫﯿﭻ ﻋﻨﻮان ﻧﯿﺎز ﺑﻪ ﭼﻨﯿﻦ ﮐﺎری ﻧﯿﺴﺖ‪ .‬ﻣﺎ ﺑﺴﺘﻪ ﺑﻪ ﻧﯿﺎز ﺧﻮد در ﭘﺮژوه از ﻣﺎژول ﻫﺎی‬ ‫•‬

‫ﻣﺨﺘﻠﻒ در ﺑﺮﻧﺎﻣﻪ ﺧﻮد اﺳﺘﻔﺎده ﻣﯿﮑﻨﯿﻢ و ﺑﺎ ﻓﺮاﮔﺮﻓﺘﻦ ﻣﺒﺎﻧﯽ ﭘﺎﯾﺘﻮن ﺳﭙﺲ ﻧﺤﻮه ﺟﺴﺘﺠﻮی ﺻﺤﯿﺢ‬

‫ﻣﯿﺘﻮاﻧﯿﻢ اﻧﻮاع ﻣﺎژول‪/‬ﭘﮑﯿﭻ ﻣﻮرد ﻧﯿﺎز را از ﻃﺮﯾﻖ ‪ Document‬ﻫﺎی اﺻﻠﯽ ﯾﺎد ﺑﮕﯿﺮﯾﻢ و اﺳﺘﻔﺎده ﮐﻨﯿﻢ‪.‬‬

‫در ﺑﺨﺶ ﻫﺎی ﺑﻌﺪی ﭼﻨﺪ ﻣﺎژول ﭘﯿﺸﻔﺮض ﮐﺎرﺑﺮدی را ﮐﺎر ﺧﻮاﻫﯿﻢ ﮐﺮد‪.‬‬ ‫•‬
‫‪Random module‬‬ ‫‪MODULES‬‬ ‫‪Part 8‬‬

‫ﯾﮑﯽ از ﻣﺎژول ﻫﺎی ﭘﯿﺸﻔﺮض ﻧﺼﺐ ﺷﺪه ‪ random‬اﺳﺖ‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ اﯾﻦ ﻣﺎژول و ﺗﻮاﺑﻊ و ﻣﺘﺪ ﻫﺎی آن ﻣﯿﺘﻮاﻧﯿﻢ ﻣﻘﺎدﯾﺮ ﺗﺼﺎدﻓﯽ )ﺷﺎﻣﻞ ﻫﺮ ﻧﻮع داده ای ﻋﺪدی و رﺷﺘﻪ و‪ (...‬ﺗﻮﻟﯿﺪ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ random‬ﯾﮏ ﻣﻘﺪار ﻋﺪد ﺻﺤﯿﺢ ﺗﺼﺎدﻓﯽ ﺑﯿﻦ ‪ ۰‬ﺗﺎ ‪ ۱‬اﯾﺠﺎد ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ randint‬ﯾﮏ ﻋﺪد ﺻﺤﯿﺢ ﺗﺼﺎدﻓﯽ اﯾﺠﺎد ﻣﯿﺸﻮد و ﻣﯿﺘﻮاﻧﯿﻢ ﺑﺎزه اﯾﺠﺎد ﻋﺪد را ﻧﯿﺰ در دو آرﮔﻮﻣﺎن ﻣﺸﺨﺺ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ choice‬ﯾﮏ ﻣﻘﺪار ﺗﺼﺎدﻓﯽ از آرﮔﻮﻣﺎن ورودی ﺳﺎﺧﺘﻪ ﻣﯿﺸﻮد‪ .‬ارﮔﻮﻣﺎن ورودی ﻣﯿﺘﻮاﻧﺪ ﯾﮑﯽ‬ ‫•‬

‫از داده ﻫﺎی دﻧﺒﺎﻟﻪ دار ﺑﺎﺷﺪ‪.‬‬

‫ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ )(‪ shuffle‬ﻣﻘﺎدﯾﺮ آرﮔﻮﻣﺎن ورودی در ﻫﻢ ﻣﯿﺸﻮﻧﺪ )ﻣﺨﻠﻮط(‪.‬‬

‫ﺑﺎزی ﺣﺪس ﺗﺎس‬ ‫‪MODULES‬‬ ‫‪Part 9‬‬

‫ﻣﯿﺨﻮاﻫﯿﻢ ﯾﮏ ﺑﺎزی ﺗﺸﺨﯿﺺ ﺗﺎس ﺑﻪ ﮐﻤﮏ ﻣﺎژول ‪ random‬ﺑﻨﻮﯾﺴﯿﻢ‪:‬‬ ‫•‬

‫‪ (1‬اﺑﺘﺪا ﻣﺎژول ‪ random‬را در ﺑﺮﻧﺎﻣﻪ اﺿﺎﻓﻪ ﻣﯿﮑﻨﯿﻢ‪.‬‬

‫‪ (2‬ﺳﭙﺲ ﯾﮏ ﻣﺘﻐﯿﯿﺮ ﺗﻌﺮﯾﻒ ﻣﯿﮑﻨﯿﻢ ﮐﻪ اﻣﺘﯿﺎزات را درون ﺧﻮد ذﺧﯿﺮه ﮐﻨﺪ‪ .‬ﻣﻘﺪار ﭘﯿﺸﻔﺮض ‪ ۰‬اﺳﺖ‪.‬‬

‫‪ (3‬ﺣﺎﻻ ﻣﯿﺨﻮاﻫﯿﻢ ﺑﺎزی ‪ ۱۰‬دﺳﺖ ﺑﺎﺷﺪ ﺑﻨﺎﺑﺮاﯾﻦ ﯾﮏ ﺣﻠﻘﻪ ﺑﺎ رﻧﺞ ‪ ۱۰‬اﯾﺠﺎد ﻣﯿﮑﻨﯿﻢ‪.‬‬

‫‪ (4‬در ﻫﺮ ﺑﺎر اﺟﺮای ﺣﻠﻘﻪ ﯾﮏ ﻋﺪد ﺗﺼﺎدﻓﯽ ﺑﯿﻦ ‪ ۱‬ﺗﺎ ‪ ۶‬ﺗﻮﻟﯿﺪ ﻣﯿﺸﻮد و درون ﻣﺘﻐﯿﯿﺮ ذﺧﯿﺮه ﻣﯿﺸﻮد‪.‬‬

‫‪ (5‬ﺳﭙﺲ ﺣﺪس ﮐﺎرﺑﺮ را ﻣﯿﮕﯿﺮﯾﻢ‪.‬‬

‫‪ (6‬اﮔﺮ ﻣﻘﺪار ﻋﺪد ﺗﺼﺎدﻓﯽ ﺑﺮاﺑﺮ ﺣﺪس ﮐﺎرﺑﺮ ﺑﺎﺷﺪ اﻣﺘﯿﺎز ‪ ۱+‬ﻣﯿﺸﻮد ﻫﺮ ﺑﺎر‪.‬‬

‫‪ (7‬اﯾﻦ ﮐﺎر ﺗﺎ اﻧﺘﻬﺎی ﺣﻠﻘﻪ اﻧﺠﺎم ﻣﯿﺸﻮد‪.‬‬

‫‪ (8‬در ﻧﻬﺎﯾﺖ ﺗﻌﺪاد اﻣﺘﯿﺎز ﯾﺎ ﺣﺪس ﻫﺎی درﺳﺖ ﮐﺎرﺑﺮ را ﻧﻤﺎﯾﺶ ﻣﯿﺪﻫﯿﻢ‪.‬‬
‫‪Password generator‬‬ ‫‪MODULES‬‬ ‫‪Part 10‬‬

‫ﻣﯿﺨﻮاﻫﯿﻢ ﯾﮏ ﺑﺮﻧﺎﻣﻪ رﻣﺰ ﺳﺎز ﺑﺴﺎزﯾﻢ‪:‬‬ ‫•‬

‫‪ (1‬اﺑﺘﺪا ﻣﺎژول ‪ random‬را ﺑﻪ ﺑﺮﻧﺎﻣﻪ اﺿﺎﻓﻪ ﻣﯿﮑﻨﯿﻢ‪.‬‬

‫‪ (2‬ﺳﭙﺲ ﻃﻮل رﻣﺰ را از ﮐﺎرﺑﺮ ﻣﯿﮕﯿﺮﯾﻢ‪.‬‬

‫‪ (3‬ﯾﮏ ﻟﯿﺴﺖ ﺧﺎﻟﯽ ﺑﺮای ﻧﮕﻪ داری ﮐﺎرﮐﺘﺮ ﻫﺎی ﺗﺼﺎدﻓﯽ اﯾﺠﺎد ﺷﺪه ﺗﻌﺮﯾﻒ ﻣﯿﮑﻨﯿﻢ‪.‬‬

‫‪ (4‬ﯾﮏ ﻣﺘﻐﯿﯿﺮ از ﻧﻮع رﺷﺘﻪ ﺧﺎﻟﯽ اﯾﺠﺎد ﻣﯿﮑﻨﯿﻢ ﮐﻪ رﻣﺰ ﻧﻬﺎﯾﯽ را داﺧﻞ آن ذﺧﯿﺮه ﮐﻨﯿﻢ‪.‬‬

‫‪ (5‬ﺳﭙﺲ ﯾﮏ ﺣﻠﻘﻪ اﯾﺠﺎد ﻣﯿﮑﻨﯿﻢ ﮐﻪ ﺗﻌﺪاد ﭼﺮﺧﺶ آن ﺑﻪ اﻧﺪازه ﻃﻮل ﻣﺪ ﻧﻈﺮ رﻣﺰ ﺑﺎﺷﺪ‪.‬‬

‫‪ (6‬ﯾﮏ ﻟﯿﺴﺖ درون ﺣﻠﻘﻪ اﯾﺠﺎد ﻣﯿﮑﻨﯿﻢ و ﮐﺎراﮐﺘﺮ ﻫﺎی ﻣﺪ ﻧﻈﺮ را ﺑﺮای رﻣﺰ در آن ﻗﺮار ﻣﯿﺪﻫﯿﻢ‪) .‬ﻫﻤﮕﯽ از ﻧﻮع رﺷﺘﻪ ﺑﺎﺷﻨﺪ(‬

‫‪ (7‬ﺳﭙﺲ درون ﯾﮏ ﻣﺘﻐﯿﯿﺮ ﻣﺘﺪ ‪ choice‬را ﻗﺮار ﻣﯿﺪﻫﯿﻢ و ورودی ان ﻟﯿﺴﺖ ﻗﺒﻠﯽ ﺑﺎﺷﺪ ﺗﺎ ﯾﮏ ﮐﺎراﮐﺘﺮ ﺗﺼﺎدﻓﯽ اﯾﺠﺎد ﺷﻮد‪.‬‬

‫‪ (8‬ﺳﭙﺲ آن ﻣﺘﻐﯿﯿﺮ را ﺑﻪ ﻟﯿﺴﺖ ﺧﺎﻟﯽ ﻧﻬﺎﯾﯽ ﻣﺎن اﺿﺎﻓﻪ ﻣﯿﮑﻨﯿﻢ‪.‬‬

‫‪ (9‬اﯾﻦ ﻋﻤﻠﯿﺎت ﺗﺎ زﻣﺎﻧﯽ ﮐﻪ ﺣﻠﻘﻪ اداﻣﻪ داﺷﺘﻪ ﺑﺎﺷﺪ اﻧﺠﺎم ﻣﯿﺸﻮد‪.‬‬

‫‪ (10‬در ﻧﻬﺎﯾﺖ ﺑﻪ ﮐﻤﮏ ﯾﮏ ﺣﻠﻘﻪ دﯾﮕﺮ ﻟﯿﺴﺖ ﻧﻬﺎﯾﯽ را ﺑﻪ رﺷﺘﻪ ﺗﺒﺪﯾﻞ ﻣﯿﮑﻨﯿﻢ‪.‬‬

‫‪ (11‬ﻣﯿﺘﻮاﻧﯿﻢ ﮐﻞ اﯾﻦ ﻋﻤﻠﯿﺎت را ﺑﻪ ﯾﮏ ﺗﺎﺑﻊ و ﻣﺎژول ﺗﺒﺪﯾﻞ ﮐﻨﯿﻢ ﮐﻪ دﯾﮕﺮان ﻧﯿﺰ ﺑﻪ راﺣﺘﯽ اﺳﺘﻔﺎده ﮐﻨﻨﺪ‪.‬‬
Password generator MODULES

:‫ﺑﺮﻧﺎﻣﻪ رﻣﺰ ﺳﺎز‬ •

 ‫‪Math module‬‬ ‫‪MODULES‬‬ ‫‪Part 11‬‬

‫ﺑﻪ ﮐﻤﮏ ﻋﻤﻠﮕﺮ ﻫﺎی ﺣﺴﺎﺑﯽ ﯾﮑﺴﺮی ﻋﻤﻠﯿﺎت ﭘﺎﯾﻪ رﯾﺎﺿﯽ را ﻣﯿﺘﻮاﻧﯿﻢ اﻧﺠﺎم دﻫﯿﻢ‪.‬‬ ‫•‬

‫در ﺻﻮرﺗﯽ ﮐﻪ ﺧﺎرج از آن ﻋﻤﻠﮕﺮ ﻫﺎی ﻧﯿﺎز ﺑﻪ ﻋﻤﻠﯿﺎت رﯾﺎﺿﯽ ﺧﺎﺻﯽ ﺑﺎﺷﯿﻢ ﻣﯿﺘﻮاﻧﯿﻢ از ﻣﺎژول ‪ math‬و ﻣﺘﺪ ﻫﺎی آن ﺑﻬﺮه ﺑﺒﺮﯾﻢ‪.‬‬ ‫•‬

‫اﯾﻦ ﻣﺎژول ﯾﮑﯽ از ﭘﯿﺸﻔﺮض ﻫﺎی ﭘﺎﯾﺘﻮن ﻣﯿﺒﺎﺷﺪ ﮐﻪ ﻧﯿﺎزی ﺑﻪ ﻧﺼﺐ ﻧﺪارد‪.‬‬ ‫•‬

‫ﻣﺘﺪ )(‪ sqrt‬ﺑﺮای ﺑﻪ دﺳﺖ آوردن ﺟﺬر اﺳﺘﻔﺎده ﻣﯿﺸﻮد‪.‬‬ ‫•‬

‫ﻣﺘﺪ )(‪ ceil‬رو ﺑﻪ ﺑﺎﻻ ﮔﺮد ﻣﯿﮑﻨﺪ‪.‬‬ ‫•‬

‫ﻣﺘﺪ )(‪ floor‬رو ﺑﻪ ﭘﺎﯾﯿﻦ ﮔﺮد ﻣﯿﮑﻨﺪ‪.‬‬ ‫•‬

‫ﻣﺘﺪ )(‪ pi‬ﻣﻘﺪار دﻗﯿﻖ ﻋﺪد ﭘﯽ را ﺑﺮﻣﮕﯿﺮداﻧﺪ و ﻓﺎﻗﺪ ورودی اﺳﺖ‪.‬‬ ‫•‬

‫ﻣﺘﺪ )(‪ radians‬ﻣﻘﺪار درﺟﻪ ﺑﻪ رادﯾﺎن ﺗﺒﺪﯾﻞ ﻣﯿﮑﻨﺪ‪.‬‬ ‫•‬

‫ﻣﺘﺪ )(‪ factorial‬ﻓﮑﺘﻮرﯾﻞ ﯾﮏ ﻋﺪد را ﺑﺮﻣﯿﮕﺮداﻧﺪ‪.‬‬ ‫•‬

‫اﯾﻦ ﻣﺎژول دارای ﻣﺘﺪ ﻫﺎی دﯾﮕﺮی ﻧﯿﺰ ﻣﯿﺒﺎﺷﺪ و ﺗﻨﻬﺎ ﭼﻨﺪ ﻣﺘﺪ از آن ﻣﺜﺎل ﺷﺪه ﺷﺪ‪ .‬ﺟﻬﺖ دﺳﺘﺮﺳﯽ ﺑﻪ ﻣﺘﺪ ﻫﺎی ﺑﯿﺸﺘﺮ اﯾﻦ ﻣﺎژول روی ﻟﯿﻨﮏ زﯾﺮ ﮐﻠﯿﮏ ﮐﻨﯿﺪ‪.‬‬ ‫•‬

‫‪https://www.w3schools.com/python/module_math.asp‬‬
‫‪Platform module‬‬ ‫‪MODULES‬‬ ‫‪Part 12‬‬

‫ﯾﮑﯽ دﯾﮕﺮ از ﻣﺎژول ﻫﺎی ﭘﯿﺸﻔﺮض ﭘﺎﯾﺘﻮن ‪ platform‬ﻣﯿﺒﺎﺷﺪ‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ اﯾﻦ ﻣﺎژول ﻣﯿﺘﻮاﻧﯿﻢ اﻃﻼﻋﺎت ﮔﺴﺘﺮده ای در ﺧﺼﻮص ﺳﯿﺴﺘﻢ ﻣﻮرد اﺳﺘﻔﺎده ﺑﻪ دﺳﺖ آورﯾﻢ‪.‬‬ ‫•‬

‫ﻣﺘﺪ )(‪ processor‬اﻃﻼﻋﺎت ﭘﺮدازﻧﺪه ﮐﺎﻣﯿﭙﻮﺗﺮ را ﺑﻪ ﻣﺎ ﻧﻤﺎﯾﺶ ﻣﯿﺪﻫﺪ‪.‬‬ ‫•‬

‫ﻣﺘﺪ )(‪ architecture‬ﻣﻌﻤﺎری ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ را ﺑﻪ ﻣﺎ ﻧﻤﺎﯾﺶ ﻣﯿﺪﻫﺪ‪.‬‬ ‫•‬

‫ﻣﺘﺪ )(‪ system‬ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ را ﺑﺮﻣﯿﮕﺮداﻧﺪ‪.‬‬ ‫•‬

‫ﻣﺘﺪ )(‪ uname‬اﻃﻼﻋﺎت ﮐﺎﻣﻠﯽ از ﺳﯿﺴﺘﻢ ﺑﺮﻣﮕﯿﺮداﻧﺪ‪.‬‬ ‫•‬

‫اﻃﻼﻋﺎت در ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ ﻫﺎی ﻣﺨﺘﻠﻒ ﻣﺘﻔﺎوت ﺧﻮاﻫﺪ ﺑﻮد‪.‬‬ ‫•‬

‫‪Tkinter module - GUI‬‬ ‫‪MODULES‬‬ ‫‪Part 13‬‬

‫ﯾﮑﯽ دﯾﮕﺮ از ﻣﺎژول ﭘﯿﺸﻔﺮض ﻧﺼﺐ ﺷﺪه ﻫﻤﺮاه ﭘﺎﯾﺘﻮن ‪ Tkinter‬اﺳﺖ‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ اﯾﻦ ﻣﺎژول ﻣﯿﺘﻮاﻧﯿﻢ ﺑﺮﻧﺎﻣﻪ ﻫﺎی ﺧﻮد را ﺑﻪ ﺻﻮرت ﮔﺮاﻓﯿﮑﯽ ﺑﺮای ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ ﻫﺎی ‪ Linux , Mac , Windows‬اﯾﺠﺎد ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺗﻤﺎﻣﯽ ﺷﺊ ﻫﺎی داﺧﻞ اﯾﻦ ﻣﺎژول را ‪ widget‬ﻣﯿﮕﻮﯾﻨﺪ ﺑﺮای ﻣﺜﺎل ‪ Labels , Button , Input :‬و‪...‬‬ ‫•‬

‫ﺟﺪای از ﻣﻨﻈﻖ ﺑﺮﻧﺎﻣﻪ ﻧﯿﺎز اﺳﺖ ﺗﻤﺎﻣﯽ ﺷﺊ ﻫﺎ ﻧﯿﺰ ﺑﺎ ﺑﺮﻧﺎﻣﻪ ﻧﻮﯾﺴﯽ ﺳﺎﺧﺘﻪ ﺷﻮد‪.‬‬ ‫•‬

‫اﺑﺰار ﻫﺎﯾﯽ ﻣﺜﻞ ‪ Tkinter Designer‬وﺟﻮد دارﻧﺪ ﮐﻪ ﺑﺮای ﻃﺮاﺣﯽ ﮔﺮاﻓﯿﮑﯽ ﻧﯿﺎز ﺑﻪ ﮐﺪ ﻧﻮﯾﺴﯽ ‪ ٪۱۰۰‬ﻧﯿﺴﺖ و ﻓﻘﻂ ﻧﯿﺎز ﺑﻪ اﯾﺠﺎد ﻣﻨﻄﻖ ﺑﺮﻧﺎﻣﻪ اﺳﺖ‪.‬‬ ‫•‬

‫ﺟﻬﺖ دﺳﺘﺮﺳﯽ ﺑﻪ ﻣﺴﺘﻨﺪات ﻓﺎرﺳﯽ اﯾﻦ ﻣﺎژول ﻣﯿﺘﻮاﻧﯿﺪ ﺑﻪ ﺳﺎﯾﺖ ‪ https://www.w3-farsi.com/posts/category/python/tkinter-in-python‬ﻣﺮاﺟﻌﻪ ﮐﻨﯿﺪ‪.‬‬ ‫•‬

‫ﯾﮏ ﻧﻤﻮﻧﻪ ﻧﺮم اﻓﺰار ﻃﺮاﺣﯽ ﺷﺪه ﺑﻪ ﮐﻤﮏ ‪Tkinter‬‬

‫‪PIP‬‬ ‫‪PYTHON PACKAGE MANAGER‬‬ ‫‪Part 1‬‬

‫در ﺻﻮرﺗﯽ ﮐﻪ ﻧﯿﺎز ﺑﻪ ﻣﺎژول ﺧﺎﺻﯽ داﺷﺘﻪ ﺑﺎﺷﯿﺪ و ﺑﻪ ﺻﻮرت ﭘﯿﺸﻔﺮض ﻧﺼﺐ ﻧﺒﺎﺷﯿﺪ ﭼﻪ ﺑﺎﯾﺪ ﮐﺮد؟‬ ‫•‬

‫ﯾﺎ ﺑﺎﯾﺪ در اﯾﻨﺘﺮﻧﺖ ﺑﻪ دﻧﺒﺎل آن ﻣﺎژول ﺑﮕﺮدﯾﺪ و ﺳﭙﺲ ﮐﺪ ﻫﺎی آن را در ﮐﻨﺎر ﭘﺮوژه ﺧﻮد ﻗﺮار دﻫﯿﺪ و اﺳﺘﻔﺎده ﮐﻨﯿﺪ‪.‬‬ ‫•‬

‫ﺑﻪ ﮐﻤﮏ اﺑﺰار ﻣﺪﯾﺮﯾﺖ ﺑﺴﺘﻪ ﭘﺎﯾﺘﻮن ﻧﯿﺰ ﻣﯿﺘﻮان ﻣﺎژول ﻫﺎی ﻣﺨﺘﻠﻔﯽ در ﺳﯿﺴﺘﻢ ﻧﺼﺐ ﮐﺮد‪.‬‬ ‫•‬

‫اﯾﻦ اﺑﺰار ‪ pip‬ﻧﺎم دارد و ﺑﻪ ﺻﻮرت ﭘﯿﺸﻔﺮض در ﮐﻨﺎر ﭘﺎﯾﺘﻮن ﻧﺼﺐ اﺳﺖ‪.‬‬ ‫•‬

‫‪ pip‬ﺑﻪ وﺑﺴﺎﯾﺖ ‪ pypi.org‬ﻣﺘﺼﻞ اﺳﺖ و ﻣﺎژول ﻫﺎ را از آﻧﺠﺎ درﯾﺎﻓﺖ ﻣﯿﮑﻨﺪ‪.‬‬ ‫•‬

‫ﺷﻤﺎ ﻫﻢ ﻣﯿﺘﻮاﻧﯿﺪ ﺑﺎ ﻧﺎم ﺧﻮدﺗﺎن در ﺳﺎﯾﺖ ‪ pypi‬اﻗﺪام ﺑﻪ ﭘﮑﯿﺞ ﺳﺎزی ﮐﻨﯿﺪ و اﯾﻦ اﻣﺮ رزوﻣﻪ ﺧﻮﺑﯽ ﺑﺮای ﺷﻤﺎ ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬ ‫•‬

‫ﺟﻬﺖ اﻃﻤﯿﻨﺎن از ﻧﺼﺐ ﺑﻮدن ‪ pip‬در ﻣﺤﯿﻂ ‪ CMD/Terminal‬دﺳﺘﻮر ‪ pip‬را وارد ﮐﻨﯿﺪ‪.‬‬ ‫•‬

‫ﻣﻤﮑﻦ اﺳﺖ ﻋﻤﻠﮑﺮد اﯾﻦ دﺳﺘﻮر در ﺳﯿﺴﺘﻢ ﻋﺎﻣﻞ ﻫﺎی ﻣﺨﺘﻠﻒ ﻣﺘﻔﺎوت ﺑﺎﺷﺪ‪ .‬در ﺻﻮرت داﺷﺘﻦ ﺧﻄﺎ ﯾﮑﯽ از دﺳﺘﻮرات زﯾﺮ را اﻣﺘﺤﺎن ﮐﻨﯿﺪ‪.‬‬ ‫•‬

‫‪python3 pip‬‬ ‫•‬

‫‪python pip‬‬ ‫•‬

‫‪Pyhton3 –m pip‬‬ ‫•‬

‫‪Installing packages using pip‬‬ ‫‪PYTHON PACKAGE MANAGER‬‬ ‫‪Part 2‬‬

‫ﺑﺮای ﻧﺼﺐ ﭘﮑﯿﺞ ﻣﺮاﺣﻞ زﯾﺮ را دﻧﺒﺎل ﮐﻨﯿﺪ‪:‬‬ ‫•‬

‫‪ (1‬اﺑﺘﺪا ﺑﻪ ﮐﻤﮏ دﺳﺘﻮر ‪ python3 -m pip install --upgrade pip‬ﯾﺎ ‪ pip install –upgrade pip‬ﭘﯿﭗ را ﺑﻪ آﺧﺮﯾﻦ ﻧﺴﺨﻪ ارﺗﻘﺎء دﻫﯿﺪ‪.‬‬

‫ﺳﭙﺲ دﺳﺘﻮر ‪ pip install packagename‬را وارد ﮐﻨﯿﺪ‪ .‬ﺑﻌﺪ از ‪ install‬ﻣﯿﺒﺎﯾﺴﺖ ﻧﺎم ﭘﮑﯿﺞ ﻣﺪ ﻧﻈﺮ را وارد ﮐﻨﯿﺪ‪.‬‬ ‫‪(2‬‬

‫‪ (3‬ﺑﺮای ﻣﺜﺎل ﻣﯿﺨﻮاﻫﯿﻢ ﯾﮏ ﭘﮑﯿﺞ ﺑﺮای ﺗﺮﺟﻤﻪ ﻣﺘﻦ ﺑﻪ ﭘﺮوژه ﻣﺎن اﺿﺎﻓﻪ ﮐﻨﯿﻢ‬

‫‪pip install deep-translator (4‬‬

‫‪Using installed package‬‬ ‫‪PYTHON PACKAGE MANAGER‬‬ ‫‪Part 3‬‬

‫ﭘﺲ از ﻧﺼﺐ ﭘﮑﯿﺞ ﻣﻮرد ﻧﻈﺮ اﯾﻦ ﭘﮑﯿﺞ در ﻣﺤﻞ ‪ lib‬ﭘﺎﯾﺘﻮن ﻗﺮار ﻣﯿﮕﯿﺮد‪.‬‬ ‫•‬

‫ﯾﻌﻨﯽ ﻧﯿﺎزی ﻧﯿﺴﺖ ﻓﺎﯾﻠﯽ در ﮐﻨﺎر ﭘﺮوژه ﺧﻮد ﻗﺮار دﻫﯿﻢ‪.‬‬ ‫•‬

‫ﮐﺎﻓﯽ اﺳﺖ ﺑﺎ ﻋﺒﺎرت ‪ import‬و ﻧﺎم ﭘﮑﯿﺞ آن را ﭘﺮوژه ﺧﻮدﻣﺎن اﺿﺎﻓﻪ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺑﺮای اﻃﻼع دﻗﯿﻖ ﻧﺤﻮه اﺳﺘﻔﺎده از ﯾﮏ ﭘﮑﯿﺞ ﯾﺎ ﻣﺎژول ﺑﺎﯾﺪ ﺑﻪ ﺳﺎﯾﺖ ‪ pypi.org‬و ﺻﻔﺤﻪ آن ﭘﮑﯿﺞ ﻣﺮاﺟﻌﻪ ﮐﺮد و اﻃﻼﻋﺎت آن را ﻣﻄﺎﻟﻌﻪ و ﺗﺴﺖ ﮐﺮد‪.‬‬ ‫•‬
‫‪Tkinter Designer & deep-translator‬‬ ‫‪PYTHON PACKAGE MANAGER‬‬ ‫‪Part 4‬‬

‫ﺑﺮای ﻣﺜﺎل ﺑﻪ ﮐﻤﮏ ﻣﺎژول ﻫﺎی ﻣﻌﺮﻓﯽ ﺷﺪه ﻗﺒﻠﯽ و ﺗﺮﮐﯿﺐ آﻧﻬﺎ ﺑﺎ ﯾﮑﺪﯾﮕﺮ ﯾﮏ ﺑﺮﻧﺎﻣﻪ ﻣﺘﺮﺟﻢ دﻗﯿﻖ ﺑﺎ ﻣﺎژول ‪ deep-translator‬و ‪ Tkinter-Designer‬ﺳﺎﺧﺘﻪ ﺷﺪه اﺳﺖ‪.‬‬ ‫•‬

‫ﻣﺒﺤﺚ راﺑﻂ ﮔﺮاﻓﯿﮑﯽ )‪ (GUI‬در ﭘﺎﯾﺘﻮن در دوره ﭘﯿﺸﺮﻓﺘﻪ ﺑﺮرﺳﯽ ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬ ‫•‬

‫ﻟﯿﻨﮏ ﮐﺪ ﻣﻨﺒﻊ اﯾﻦ ﭘﺮوژه و ﭘﺮوژه ﻫﺎی دﯾﮕﺮ ﺑﺮ روی ﮔﯿﺖ ﻫﺎب ‪https://github.com/amirkho-py‬‬
‫‪try and except statement‬‬ ‫‪EXCEPTION HANDLING‬‬ ‫‪Part 1‬‬

‫ﻫﻨﮕﺎﻣﯽ ﮐﻪ در ﺑﺮﻧﺎﻣﻪ ﻫﺎی ﭘﺎﯾﺘﻮن ﺧﻄﺎﯾﯽ رخ ﻣﯿﺪﻫﺪ ﺑﺮﻧﺎﻣﻪ ﻣﺘﻮﻗﻒ ﻣﯿﺸﻮد و ﭘﯿﺎم ﺧﻄﺎ را ﺑﻪ ﻣﺎ ﻧﺸﺎن ﻣﯿﺪﻫﺪ‪ .‬ﺑﻪ اﯾﻦ ﮔﻮﻧﻪ ﺧﻄﺎ ﻫﺎ اﺳﺘﺜﻨﺎء ﻣﯿﮕﻮﯾﻨﺪ‪.‬‬ ‫•‬

‫اﯾﻦ اﺳﺘﺜﻨﺎء ﻫﺎ را ﺧﻮدﻣﺎن ﻣﯿﺘﻮان ﻣﺪﯾﺮﯾﺖ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﯾﻌﻨﯽ از ﺧﻄﺎ ﻫﺎی ﭘﯿﺸﻔﺮض ﭘﺎﯾﺘﻮن ﺟﻠﻮﮔﯿﺮی ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫و ﻣﯿﺘﻮان ﭘﯿﺎم ﺧﻄﺎی دﻟﺨﻮاه ﺧﻮدﻣﺎن را ﺗﻌﺮﯾﻒ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﻣﻘﺎﺑﻞ دﻗﺖ ﮐﻨﯿﺪ‪.‬‬ ‫•‬

‫‪ (1‬در ﺑﻠﻮک ‪ try‬ﺑﺮﻧﺎﻣﻪ ﺗﻼش ﻣﯿﮑﻨﺪ ﻣﻘﺪار ﻣﺘﻐﯿﯿﺮ ‪ x‬را ﻧﻤﺎﯾﺶ دﻫﺪ‪.‬‬

‫‪ (2‬ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ اﯾﻦ ﻣﺘﻐﯿﯿﺮ ‪ x‬وﺟﻮد ﻧﺪارد ﻗﺎﻋﺪﺗﺎ ﺑﺎﯾﺪ ﺑﺎ ﺧﻄﺎی ‪ x is not defined‬ﻣﻮاﺟﻪ ﺷﻮﯾﻢ!‬

‫‪ (3‬اﻣﺎ اﯾﻦ اﺗﻔﺎق رخ ﻧﺨﻮاﻫﺪ داد ﭼﻮن در ﺑﻼک ‪ except‬اﺳﺘﺜﻨﺎء ﺧﻮدﻣﺎن را ﺗﻌﺮﯾﻒ ﮐﺮده و در ﺻﻮرت ﺧﻄﺎ آن اﺟﺮا ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬

‫‪ (4‬از ﻋﺒﺎرت ‪ else‬ﻧﯿﺰ ﻣﯿﺘﻮان اﺳﺘﻔﺎده ﮐﺮد و در ﺻﻮرﺗﯽ ﮐﻪ ﺑﻼک ‪ except‬اﺟﺮا ﻧﺸﻮد ﯾﻌﻨﯽ ﺑﻼک ‪try‬‬

‫ﻣﺸﮑﻞ ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ ﺑﻼک ‪ else‬اﺟﺮا ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬

‫‪try and except statement‬‬ ‫‪EXCEPTION HANDLING‬‬ ‫‪Part 2‬‬

‫ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﻣﻘﺎﺑﻞ دﻗﺖ ﮐﻨﯿﺪ‪:‬‬ ‫•‬

‫‪ (1‬در ﺧﻂ اول و دوم دو ﻣﺎژول ‪ deep-translator‬و ‪ text_to_speech‬را ﻧﺼﺐ و ﺑﻪ ﺑﺮﻧﺎﻣﻪ اﺿﺎﻓﻪ ﮐﺮده اﯾﻢ‪.‬‬

‫‪ (2‬در ﺧﻂ ﺷﺸﻢ ﯾﮏ ﺗﺎﺑﻊ اﯾﺠﺎد ﮐﺮده اﯾﻢ ﮐﻪ دو ﭘﺎراﻣﺘﺮ ‪ source‬و ‪ target‬دارد‪.‬‬

‫‪ (3‬ﺳﭙﺲ در ﺧﻂ ﻫﺸﺘﻢ درون ﯾﮏ ﻣﺘﻐﯿﯿﺮ از ﻣﺘﺪ ﻫﺎی ﻣﺎژول ﺗﺮﺟﻤﻪ ﺑﺮای ﺗﺮﺟﻤﻪ ورودی ﺑﻪ زﺑﺎن ﻣﻘﺼﺪ‬

‫‪ (4‬ﯾﻌﻨﯽ ‪ target‬ﺧﺮوﺟﯽ را ذﺧﯿﺮه ﮐﺮده اﯾﻢ و ﻧﻤﺎﯾﺶ ﻣﯿﺪﻫﯿﻢ‪.‬‬

‫‪ (5‬ﺳﭙﺲ در ﺧﻂ ﯾﺎزدﻫﻢ ﮔﻔﺘﯿﻢ ﺗﻼش ﮐﻦ ﮐﻪ ﻣﻘﺪار ﻧﻬﺎﯾﯽ ﺗﺮﺟﻤﻪ ﺷﺪه را ﺑﻪ ﺻﻮت ﺗﺒﺪﯾﻞ ﮐﻨﯽ‪.‬‬

‫‪ (6‬ﭘﺎراﻣﺘﺮ اول ﻣﺘﻦ ﻣﻮرد ﻧﻈﺮ ﺑﺮای ﺗﺒﺪﯾﻞ ﺑﻪ ﺻﻮرت اﺳﺖ‪.‬‬

‫‪ (7‬ﭘﺎرﻣﺘﺮ دوم زﺑﺎن ﻣﺪ ﻧﻈﺮ اﺳﺖ و‪...‬‬

‫‪ (8‬در ﺻﻮرﺗﯽ ﮐﻪ ﺧﻄﺎﯾﯽ در ﻫﻨﮕﺎم ﺗﺒﺪﯾﻞ ﻣﺘﻦ ﺑﻪ ﺻﺪا رخ دﻫﺪ اﺳﺘﺜﻨﺎء ﻣﺎ اﺟﺮا ﺧﻮاﻫﺪ ﺷﺪ‬

‫‪ (9‬در ﻧﻬﺎی ﺧﻂ ﻫﻔﺪﻫﻢ ﺗﺎﺑﻌﯽ ﮐﻪ ﺳﺎﺧﺘﯿﻢ را ﺻﺪا زدﯾﻢ و ﺑﻪ آن ورودی ﻣﺘﻦ و زﺑﺎن ﻣﻘﺼﺪ را داده اﯾﻢ‪.‬‬
‫‪finally and raise in exceptions‬‬ ‫‪EXCEPTION HANDLING‬‬ ‫‪Part 3‬‬

‫ﺑﻪ ﮐﻤﮏ ﻋﺒﺎرت ‪ finally‬ﻣﯿﺘﻮان ﺗﻌﺮﯾﻒ ﮐﺮد ﮐﻪ در اﻧﺘﻬﺎی ﻣﺪﯾﺮﯾﺖ اﺳﺘﺜﻨﺎء ﭼﻪ ﮐﺎری اﻧﺠﺎم ﺷﻮد‪.‬‬ ‫•‬

‫اﯾﻦ ﻋﺒﺎرت ﮐﺎری ﺑﻪ رﺧﺪاد ﺧﻄﺎ ﻧﺪارد و ﻧﻬﺎﯾﺘﺎ اﺟﺮا ﺧﻮاﻫﺪ ﺷﺪ‪.‬‬ ‫•‬

‫ﻫﻤﭽﻨﯿﻦ ﻣﺎ ﻣﯿﺘﻮاﻧﯿﻢ ﻣﻄﺎﺑﻖ ﯾﮏ ﺷﺮاﯾﻂ ﺧﺎص ﯾﮏ اﺳﺘﺜﻨﺎء ﺧﺎص ﺗﻌﺮﯾﻒ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﻧﺤﻮه ﺗﻌﺮﯾﻒ ﺑﻪ ﮐﻤﮏ ﻋﺒﺎرت ‪ raise‬ﺳﭙﺲ ﻋﻨﻮان و ﭘﯿﺎم ﺧﻄﺎ ﺑﻪ ﺷﮑﻞ ﻣﻘﺎﺑﻞ اﺳﺖ‪.‬‬ ‫•‬

‫در ﻗﻄﻌﻪ ﮐﺪ ﻣﻘﺎﺑﻞ ﺗﻌﺮﯾﻒ ﮐﺮده اﯾﻢ در ﺻﻮرﺗﯽ ﮐﻪ ﻧﻮع ﻣﻘﺪار ‪ x‬ﻋﺪد ﺻﺤﯿﺢ ﻧﺒﻮد ﺧﻄﺎی ‪ TypeError‬را اﺟﺮا ﮐﻦ‪.‬‬ ‫•‬
 ‫‪Files‬‬ ‫‪PYTHON FILE I/O‬‬ ‫‪Part 1‬‬

‫ﻓﺎﯾﻞ ﻫﺎ ﻣﮑﺎن ﻫﺎﯾﯽ روی دﯾﺴﮏ ﻫﺴﺘﻨﺪ ﮐﻪ ﺑﺮای ذﺧﯿﺮه اﻃﻼﻋﺎت ﻣﺮﺗﺒﻂ ﺑﺎ ﻫﻢ ﻧﺎﻣﮕﺬاری و اﺳﺘﻔﺎده ﻣﯽ ﺷﻮﻧﺪ‪.‬‬ ‫•‬

‫آﻧﻬﺎ ﺑﺮای ذﺧﯿﺮه داﺋﻤﯽ داده ﻫﺎ در ﯾﮏ ﺣﺎﻓﻈﻪ ﻏﯿﺮ ﻓﺮار )ﺑﻪ ﻋﻨﻮان ﻣﺜﺎل ﻫﺎرد دﯾﺴﮏ( اﺳﺘﻔﺎده ﻣﯽ ﺷﻮﻧﺪ‪) .‬ﺧﻼف ﻧﺤﻮه ﻋﻤﻠﮑﺮد ﻣﺘﻐﯿﯿﺮ(‬ ‫•‬

‫از آﻧﺠﺎﯾﯽ ﮐﻪ ﺣﺎﻓﻈﻪ دﺳﺘﺮﺳﯽ ﺗﺼﺎدﻓﯽ )‪ (RAM‬ﻓﺮار اﺳﺖ داده ﻫﺎی ﺧﻮد را ﺑﺎ ﺧﺎﻣﻮش ﮐﺮدن راﯾﺎﻧﻪ از دﺳﺖ ﻣﯽ دﻫﺪ‪ ،‬ﻣﺎ از ﻓﺎﯾﻞ ﻫﺎ ﺑﺮای اﺳﺘﻔﺎده در آﯾﻨﺪه از داده ﻫﺎ ﺑﺎ ذﺧﯿﺮه داﺋﻤﯽ آﻧﻬﺎ‬ ‫•‬

‫اﺳﺘﻔﺎده ﻣﯽ ﮐﻨﯿﻢ‪.‬‬

‫وﻗﺘﯽ ﻣﯽ ﺧﻮاﻫﯿﻢ از ﻓﺎﯾﻠﯽ ﺑﺨﻮاﻧﯿﻢ ﯾﺎ روی آن ﺑﻨﻮﯾﺴﯿﻢ)ﻫﺮ ﻧﻮع ﻓﺎﯾﻠﯽ(‪ ،‬اﺑﺘﺪا ﺑﺎﯾﺪ آن را ﺑﺎز ﮐﻨﯿﻢ‪ .‬وﻗﺘﯽ ﮐﺎرﻣﺎن ﺗﻤﺎم ﺷﺪ‪ ،‬ﺑﺎﯾﺪ ﺑﺴﺘﻪ ﺷﻮد ﺗﺎ ﻣﻨﺎﺑﻌﯽ ﮐﻪ ﺑﺎ ﻓﺎﯾﻞ ﻣﺮﺗﺒﻂ ﻫﺴﺘﻨﺪ آزاد ﺷﻮﻧﺪ‪.‬‬ ‫•‬

‫ﺑﻨﺎﺑﺮاﯾﻦ‪ ،‬در ﭘﺎﯾﺘﻮن‪ ،‬ﻋﻤﻠﯿﺎت ﻓﺎﯾﻞ ﺑﻪ ﺗﺮﺗﯿﺐ زﯾﺮ اﻧﺠﺎم ﻣﯽ ﺷﻮد‪:‬‬ ‫•‬

‫‪ (1‬ﺑﺎز ﮐﺮدن ﯾﮏ ﻓﺎﯾﻞ‬

‫‪ (2‬ﺧﻮاﻧﺪن ﯾﺎ ﻧﻮﺷﺘﻦ )اﻧﺠﺎم ﻋﻤﻠﯿﺎت‪/‬ﺗﻐﯿﯿﺮات(‬

‫‪ (3‬ﺑﺴﺘﻦ ﻓﺎﯾﻞ‬
 ‫‪Opening Files‬‬ ‫‪PYTHON FILE I/O‬‬ ‫‪Part 2‬‬

‫در ﭘﺎﯾﺘﻮن ﺑﻪ روش ﻫﺎی ﻣﺨﺘﻠﻔﯽ ﻣﯿﺘﻮان ﻓﺎﯾﻞ ﻫﺎ را ﺑﺎز ﮐﺮد‪.‬‬ ‫•‬

‫ﭘﺎﯾﺘﻮن دارای ﯾﮏ ﺗﺎﺑﻊ ﭘﯿﺸﻔﺮض‪/‬ﭘﯿﺶ ﺳﺎﺧﺘﻪ ﺑﺎ ﻋﻨﻮان )(‪ open‬اﺳﺖ‪.‬‬ ‫•‬

‫ﺧﺮوﺟﯽ اﯾﻦ ﺗﺎﺑﻊ ﯾﮏ ﺷﺊ )‪ (object‬از ﻧﻮع ﻓﺎﯾﻞ اﺳﺖ‪.‬‬ ‫•‬

‫در اﯾﻦ ﻣﺒﺤﺚ ﻣﺎ ﺑﺎ ﻓﺎﯾﻞ ﻫﺎ ﺳﺎده ‪ txt‬ﮐﺎر ﺧﻮاﻫﯿﻢ ﮐﺮد و روی آن ﻫﺎ ﯾﮑﺴﺮی ﭘﺮدازش و ذﺧﯿﺮه اﻃﻼﻋﺎت را اﻧﺠﺎم ﻣﯿﺪﻫﯿﻢ‪.‬‬ ‫•‬

‫ﻣﯿﺘﻮان ﻫﺮ ﻧﻮع ﻓﺎﯾﻠﯽ را در ﭘﺎﯾﺘﻮن اﺳﺘﻔﺎده و ﭘﺮدازش و‪ ...‬ﮐﺮد و اﻏﻠﺐ ﻧﯿﺎز ﺑﻪ ﻧﺼﺐ ﻣﺎژول ﻫﺎی ﺧﺎﺻﯽ اﺳﺖ ﺑﺮای ﻣﺜﺎل ﺑﺮای ﮐﺎر ﺑﺮ روی ﺗﺼﺎوﯾﺮ و وﯾﺪﯾﻮ ﻫﺎ از ‪ openCV‬اﺳﺘﻔﺎده ﻣﯿﮑﻨﯿﻢ‪.‬‬ ‫•‬

‫ﻫﻨﮕﺎم ﺑﺎز ﮐﺮدن ﯾﮏ ﻓﺎﯾﻞ ﻣﯽ ﺗﻮاﻧﯿﻢ ﺣﺎﻟﺖ را ﻣﺸﺨﺺ ﮐﻨﯿﻢ‪ .‬در ﺣﺎﻟﺖ ﻣﺸﺨﺺ ﻣﯽ ﮐﻨﯿﻢ ﮐﻪ ﺑﺨﻮاﻫﯿﻢ ﺻﺮﻓﺎ آن را ﺑﺨﻮاﻧﯿﻢ‪ ،‬ﺑﻨﻮﯾﺴﯿﻢ ﯾﺎ‪...‬‬ ‫•‬

‫ﻫﻤﭽﻨﯿﻦ ﻣﯽ ﺗﻮاﻧﯿﻢ ﺗﻌﯿﯿﻦ ﮐﻨﯿﻢ ﮐﻪ آﯾﺎ ﻣﯽ ﺧﻮاﻫﯿﻢ ﻓﺎﯾﻞ را در ﺣﺎﻟﺖ ﻣﺘﻨﯽ ﯾﺎ ﺑﺎﯾﻨﺮی ﺑﺎز ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﭘﯿﺶ ﻓﺮض ﺧﻮاﻧﺪن در ﺣﺎﻟﺖ ﻣﺘﻦ اﺳﺖ‪ .‬در اﯾﻦ ﺣﺎﻟﺖ‪ ،‬ﻫﻨﮕﺎم ﺧﻮاﻧﺪن از ﻓﺎﯾﻞ‪ ،‬رﺷﺘﻪ ﻫﺎﯾﯽ درﯾﺎﻓﺖ ﻣﯽ ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫از ﺳﻮی دﯾﮕﺮ‪ ،‬ﺣﺎﻟﺖ ﺑﺎﯾﻨﺮی ﺑﺎﯾﺖﻫﺎ را ﺑﺮﻣﯽﮔﺮداﻧﺪ و اﯾﻦ ﺣﺎﻟﺘﯽ اﺳﺖ ﮐﻪ ﺑﺎﯾﺪ ﻫﻨﮕﺎم ﮐﺎر ﺑﺎ ﻓﺎﯾﻞﻫﺎی ﻏﯿﺮ ﻣﺘﻨﯽ ﻣﺎﻧﻨﺪ ﺗﺼﺎوﯾﺮ ﯾﺎ ﻓﺎﯾﻞﻫﺎی اﺟﺮاﯾﯽ اﺳﺘﻔﺎده ﺷﻮد‪.‬‬ ‫•‬
‫‪Opening File Modes‬‬ ‫‪PYTHON FILE I/O‬‬ ‫‪Part 3‬‬

‫در ﻫﻤﺎن ﺗﺎﺑﻊ )(‪ open‬ﻣﯿﺘﻮان ﺑﻪ ﻋﻨﻮان ﭘﺎراﻣﺘﺮ دوم ﻣﺸﺨﺺ ﻧﻤﻮد در ﭼﻪ ﺣﺎﻟﯽ ﻓﺎﯾﻞ ﺑﺎز ﺷﻮد‪.‬‬ ‫•‬

‫اﻧﻮاع ﺣﺎﻟﺖ ﻫﺎی ﺑﺎز ﮐﺮدن ﻓﺎﯾﻞ ﺑﻪ ﺷﺮح ﺟﺪول زﯾﺮ اﺳﺖ‪:‬‬ ‫•‬
‫‪Mode‬‬ ‫‪Description‬‬

‫‪r‬‬ ‫ﺑﺎز ﮐﺮدن ﻓﺎﯾﻞ در ﺣﺎﻟﺖ ﺧﻮاﻧﺪن )اﯾﻦ ﺣﺎﻟﺖ ﺑﻪ ﺻﻮرت ﭘﯿﺸﻔﺮض ﻓﻌﺎل اﺳﺖ و ﻧﯿﺎز ﺑﻪ ﺗﻨﻈﯿﻢ ﻧﺪارد(‬

‫‪w‬‬ ‫ﻓﺎﯾﻠﯽ را ﺑﺮای ﻧﻮﺷﺘﻦ ﺑﺎز ﻣﯽ ﮐﻨﺪ‪ .‬اﮔﺮ ﻓﺎﯾﻞ وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ‪ ،‬ﻓﺎﯾﻞ ﺟﺪﯾﺪی اﯾﺠﺎد ﻣﯿﮑﻨﺪ‪.‬‬

‫‪x‬‬ ‫ﻓﺎﯾﻠﯽ را ﺑﺮای اﯾﺠﺎد اﻧﺤﺼﺎری ﺑﺎز ﻣﯽ ﮐﻨﺪ‪ .‬اﮔﺮ ﻓﺎﯾﻞ از ﻗﺒﻞ وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﺪ‪ ،‬ﻋﻤﻠﯿﺎت ﺑﺎ ﺷﮑﺴﺖ ﻣﻮاﺟﻪ ﻣﯽ ﺷﻮد‪.‬‬

‫‪a‬‬ ‫ﻓﺎﯾﻠﯽ را ﺑﺮای اﻓﺰودن در اﻧﺘﻬﺎی ﻓﺎﯾﻞ ﺑﺪون ﮐﻮﺗﺎه ﮐﺮدن آن ﺑﺎز ﻣﯽ ﮐﻨﺪ‪ .‬اﮔﺮ ﻓﺎﯾﻞ ﺟﺪﯾﺪی وﺟﻮد ﻧﺪاﺷﺘﻪ ﺑﺎﺷﺪ‪ ،‬اﯾﺠﺎد ﻣﯽ ﮐﻨﺪ‪.‬‬

‫‪t‬‬ ‫در ﺣﺎﻟﺖ ‪ text‬ﻓﺎﯾﻞ را ﺑﺎز ﻣﯿﮑﻨﺪ‪.‬‬

‫‪b‬‬ ‫ﻓﺎﯾﻞ را در ﺣﺎﻟﺖ ‪ binary‬ﺑﺎز ﻣﯿﮑﻨﺪ‪.‬‬

‫‪+‬‬ ‫ﻓﺎﯾﻠﯽ را ﺑﺮای ﺑﻪ روزرﺳﺎﻧﯽ )ﺧﻮاﻧﺪن و ﻧﻮﺷﺘﻦ( ﺑﺎز ﻣﯽ ﮐﻨﺪ‪.‬‬

‫‪Opening File Modes‬‬ ‫‪PYTHON FILE I/O‬‬ ‫‪Part 4‬‬

‫ﺑﺮﺧﻼف ﺳﺎﯾﺮ زﺑﺎنﻫﺎ‪ ،‬ﮐﺎراﮐﺘﺮ ‪ a‬ﺗﺎ زﻣﺎﻧﯽ ﮐﻪ ﺑﺎ اﺳﺘﻔﺎده از )‪ (ASCII‬ﯾﺎ دﯾﮕﺮ رﻣﺰﮔﺬاریﻫﺎی ﻣﻌﺎدل ﮐﺪﮔﺬاری ﻧﺸﻮد‪ ،‬ﺑﻪ ﻋﺪد ‪ 97‬دﻻﻟﺖ ﻧﻤﯽﮐﻨﺪ‪.‬‬ ‫•‬

‫ﻋﻼوه ﺑﺮ اﯾﻦ‪ ،‬رﻣﺰﮔﺬاری ﭘﯿﺶﻓﺮض واﺑﺴﺘﻪ ﺑﻪ ﭘﻠﺘﻔﺮم اﺳﺖ‪ .‬در وﯾﻨﺪوز ) ‪ (cp1252‬اﻣﺎ در ﻟﯿﻨﻮﮐﺲ )‪ (utf-8‬اﺳﺖ‪.‬‬ ‫•‬

‫ﺑﻨﺎﺑﺮاﯾﻦ‪ ،‬ﻣﺎ ﻫﻤﭽﻨﯿﻦ ﻧﺒﺎﯾﺪ ﺑﻪ رﻣﺰﮔﺬاری ﭘﯿﺶ ﻓﺮض ﺗﮑﯿﻪ ﮐﻨﯿﻢ‪ ،‬در ﻏﯿﺮ اﯾﻦ ﺻﻮرت ﮐﺪ ﻣﺎ در ﭘﻠﺘﻔﺮم ﻫﺎی ﻣﺨﺘﻠﻒ رﻓﺘﺎر ﻣﺘﻔﺎوﺗﯽ ﺧﻮاﻫﺪ داﺷﺖ‪.‬‬ ‫•‬

‫از اﯾﻦ رو‪ ،‬ﻫﻨﮕﺎم ﮐﺎر ﺑﺎ ﻓﺎﯾﻞ ﻫﺎ در ﺣﺎﻟﺖ ﻣﺘﻨﯽ‪ ،‬ﺑﻪ ﺷﺪت ﺗﻮﺻﯿﻪ ﻣﯽ ﺷﻮد ﮐﻪ ﻧﻮع رﻣﺰﻧﮕﺎری را ﻣﺸﺨﺺ ﮐﻨﯿﺪ‪.‬‬ ‫•‬

‫ﺑﺮای ﻣﺸﺨﺺ ﮐﺮدن ﻧﻮع رﻣﺰﻧﮕﺎری از ﭘﺎراﻣﺘﺮ ‪ encoding‬در ﺗﺎﺑﻊ ‪ open‬اﺳﺘﻔﺎده ﻣﯿﺸﻮد‪.‬‬ ‫•‬
‫‪Closing Files‬‬ ‫‪PYTHON FILE I/O‬‬ ‫‪Part 5‬‬

‫ﭘﺲ از اﺗﻤﺎم ﻋﻤﻠﯿﺎت روی ﻓﺎﯾﻞ‪ ،‬ﺑﺎﯾﺪ ﻓﺎﯾﻞ را ﺑﻪ درﺳﺘﯽ ﺑﺒﻨﺪﯾﻢ‪.‬‬ ‫•‬

‫ﺑﺴﺘﻦ ﯾﮏ ﻓﺎﯾﻞ‪ ،‬ﻣﻨﺎﺑﻊ ﻣﺮﺗﺒﻂ ﺑﺎ ﻓﺎﯾﻞ را آزاد ﻣﯽ ﮐﻨﺪ‪ .‬اﯾﻦ ﮐﺎر ﺑﺎ اﺳﺘﻔﺎده از ﻣﺘﺪ )‪ (close‬ﻣﻮﺟﻮد در ﭘﺎﯾﺘﻮن اﻧﺠﺎم ﻣﯽ ﺷﻮد‪.‬‬ ‫•‬

‫اﯾﻦ روش ﮐﺎﻣﻼ ً اﯾﻤﻦ ﻧﯿﺴﺖ‪ .‬اﮔﺮ زﻣﺎﻧﯽ ﮐﻪ ﻣﺎ در ﺣﺎل اﻧﺠﺎم ﻋﻤﻠﯿﺎﺗﯽ ﺑﺎ ﻓﺎﯾﻞ ﻫﺴﺘﯿﻢ‪ ،‬اﺳﺘﺜﻨﺎ رخ دﻫﺪ‪ ،‬ﮐﺪ ﺑﺪون ﺑﺴﺘﻦ ﻓﺎﯾﻞ ﺧﺎرج ﻣﯽ ﺷﻮد‪.‬‬ ‫•‬

‫ﯾﮏ راه اﻣﻦ ﺗﺮ‪ ،‬اﺳﺘﻔﺎده از ﯾﮏ ‪ try‬و ‪ finally‬و در ﻧﻬﺎﯾﺖ ﻣﺴﺪود ﮐﺮدن اﺳﺖ‪.‬‬ ‫•‬

‫ﺑﻪ اﯾﻦ ﺗﺮﺗﯿﺐ‪ ،‬ﻣﺎ ﺗﻀﻤﯿﻦ ﻣﯽﮐﻨﯿﻢ ﮐﻪ ﻓﺎﯾﻞ ﺑﻪ درﺳﺘﯽ ﺑﺴﺘﻪ ﺷﺪه اﺳﺖ‪ ،‬ﺣﺘﯽ اﮔﺮ اﺳﺘﺜﻨﺎﯾﯽ اﯾﺠﺎد ﺷﻮد ﮐﻪ ﺑﺎﻋﺚ ﺗﻮﻗﻒ ﺟﺮﯾﺎن ﺑﺮﻧﺎﻣﻪ ﺷﻮد‪.‬‬ ‫•‬

‫ﺑﻬﺘﺮﯾﻦ راه ﺑﺮای ﺑﺴﺘﻦ ﻓﺎﯾﻞ اﺳﺘﻔﺎده از ﻋﺒﺎرت ‪ with‬اﺳﺖ‪ .‬اﯾﻦ ﺗﻀﻤﯿﻦ ﻣﯽ ﮐﻨﺪ ﮐﻪ ﻓﺎﯾﻞ ﻫﻨﮕﺎم ﺧﺮوج از ﺑﻠﻮک داﺧﻞ دﺳﺘﻮر ‪ with‬ﺑﺴﺘﻪ ﻣﯽ ﺷﻮد‪.‬‬ ‫•‬

‫ﻣﺎ ﻧﯿﺎزی ﺑﻪ ﻓﺮاﺧﻮاﻧﯽ ﺻﺮﯾﺢ ﻣﺘﺪ )(‪ close‬ﻧﺪارﯾﻢ‪ .‬ﺑﻪ ﺻﻮرت داﺧﻠﯽ اﻧﺠﺎم ﻣﯽ ﺷﻮد‪.‬‬ ‫•‬
‫‪Reding Files‬‬ ‫‪PYTHON FILE I/O‬‬ ‫‪Part 6‬‬

‫ﺑﺮای ﺧﻮاﻧﺪن ﯾﮏ ﻓﺎﯾﻞ در ﭘﺎﯾﺘﻮن‪ ،‬ﺑﺎﯾﺪ ﻓﺎﯾﻞ را در ﺣﺎﻟﺖ ﺧﻮاﻧﺪن ‪ r‬ﺑﺎز ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺑﺮای اﯾﻦ ﻣﻨﻈﻮر روش ﻫﺎی ﻣﺨﺘﻠﻔﯽ وﺟﻮد دارد‪ .‬ﻣﺎ ﻣﯽ ﺗﻮاﻧﯿﻢ از روش )‪ read(size‬ﺑﺮای ﺧﻮاﻧﺪن ﺗﻌﺪاد اﻧﺪازه داده ﻫﺎ اﺳﺘﻔﺎده ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫اﮔﺮ ﭘﺎراﻣﺘﺮ اﻧﺪازه ﻣﺸﺨﺺ ﻧﺸﺪه ﺑﺎﺷﺪ‪ ،‬آن را ﺧﻮاﻧﺪه و ﺗﺎ اﻧﺘﻬﺎی ﻓﺎﯾﻞ ﺑﺮﻣﯽﮔﺮداﻧﺪ‪.‬‬ ‫•‬

‫ﻓﺎﯾﻞ ‪ text.txt‬ﮐﻪ آن را ﺑﺎز ﮐﺮده اﯾﻢ ﻣﯽ ﺗﻮاﻧﯿﻢ ﺑﻪ ﺻﻮرت زﯾﺮ ﺑﺨﻮاﻧﯿﻢ‪:‬‬ ‫•‬
‫‪Writing in Files‬‬ ‫‪PYTHON FILE I/O‬‬ ‫‪Part 7‬‬

‫ﺑﺮای ﻧﻮﺷﺘﻦ در ﯾﮏ ﻓﺎﯾﻞ در ﭘﺎﯾﺘﻮن‪ ،‬ﺑﺎﯾﺪ آن را در ﺣﺎﻟﺖ ‪ w‬ﯾﺎ ‪ x‬ﯾﺎ ‪ a‬ﺑﺎز ﮐﻨﯿﻢ‪.‬‬ ‫•‬

‫ﺑﺎﯾﺪ ﻣﺮاﻗﺐ ﺣﺎﻟﺖ ‪ w‬ﺑﺎﺷﯿﻢ‪ ،‬زﯾﺮا اﮔﺮ از ﻗﺒﻞ وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﺪ در ﻓﺎﯾﻞ ﺑﺎزﻧﻮﯾﺴﯽ ﻣﯽ ﺷﻮد‪ .‬ﺑﻪ ﻫﻤﯿﻦ دﻟﯿﻞ ﺗﻤﺎم داده ﻫﺎی ﻗﺒﻠﯽ ﭘﺎک ﻣﯽ ﺷﻮﻧﺪ‪.‬‬ ‫•‬

‫اﯾﻦ ﺑﺮﻧﺎﻣﻪ در ﺻﻮرت ﻋﺪم وﺟﻮد ﻓﺎﯾﻞ ﺟﺪﯾﺪی ﺑﻪ ﻧﺎم ‪ test.txt‬در داﯾﺮﮐﺘﻮری ﻓﻌﻠﯽ اﯾﺠﺎد ﻣﯽ ﮐﻨﺪ‪ .‬اﮔﺮ وﺟﻮد داﺷﺘﻪ ﺑﺎﺷﺪ‪ ،‬ﺑﺎزﻧﻮﯾﺴﯽ ﻣﯽ ﺷﻮد‪.‬‬ ‫•‬

‫ﻫﻤﭽﻨﯿﻦ ﻣﺎ ﺑﺎﯾﺪ ﺧﻮد ﮐﺎراﮐﺘﺮﻫﺎی ﺧﻂ ﺟﺪﯾﺪ را وارد ﮐﻨﯿﻢ ﺗﺎ ﺧﻄﻮط ﻣﺨﺘﻠﻒ را ﺗﺸﺨﯿﺺ دﻫﯿﻢ‪.‬‬ ‫•‬
‫ﭘﺮوژه ذﺧﯿﺮه ﻣﺨﺎﻃﺐ در ﻓﺎﯾﻞ ‪txt‬‬
‫‪PYTHON FILE I/O‬‬ ‫‪Part 8‬‬

‫ﻣﯿﺨﻮاﻫﯿﻢ ﯾﮏ ﺑﺮﻧﺎﻣﻪ ذﺧﯿﺮه ﻣﺨﺎﻃﺐ در ﻓﺎﯾﻞ ‪ txt‬ﺑﻨﻮﯾﺴﯿﻢ‪.‬‬ ‫•‬

‫‪ (1‬اﺑﺘﺪا ﺗﻌﺪاد ﻣﺨﺎﻃﺐ ﻣﺪ ﻧﻈﺮ را از ﮐﺎرﺑﺮ ﻣﯿﺨﻮاﻫﯿﻢ‪.‬‬

‫‪ (2‬ﺳﭙﺲ ﯾﮏ دﯾﮑﺸﻨﺮی ﺑﺮای ذﺧﯿﺮه اﻃﻼﻋﺎت ﺑﻪ ﺻﻮرت ‪ key:value‬اﯾﺠﺎد ﻣﯿﮑﻨﯿﻢ ﭼﻮن ﻧﯿﺎز ﺑﻪ ذﺧﯿﺮه ﻧﺎم و ﺷﻤﺎره ﺗﻠﻔﻦ دارﯾﻢ‪.‬‬

‫‪ (3‬ﯾﮏ ﺣﻠﻘﻪ ﺑﻪ ﺗﻌﺪاد ﻣﺨﺎﻃﺐ ﻣﺪ ﻧﻈﺮ اﯾﺠﺎد ﻣﯿﮑﻨﯿﻢ‪.‬‬

‫‪ (4‬در ﻫﺮ ﺑﺎر اﺟﺮای ﺣﻠﻘﻪ ﻧﺎم و ﺷﻤﺎره ﺗﻠﻔﻦ را ﻣﯿﮕﯿﺮﯾﻢ و ﻧﺎم را ﺑﻪ ﻋﻨﻮان ﮐﻠﯿﺪ و ﺷﻤﺎره ﺗﻠﻔﻦ را ﺑﻪ ﻋﻨﻮان ﻣﻘﺪار ذﺧﯿﺮه ﻣﯿﮑﻨﯿﻢ‪.‬‬

‫‪ (5‬ﺣﺎﻻ ﺑﻪ ﮐﻤﮏ ﻋﺒﺎرت ‪ with‬و ﺗﺎﺑﻊ ‪ open‬ﯾﮏ ﻓﺎﯾﻞ ‪ txt‬ﺑﺎز ﯾﺎ اﯾﺠﺎد ﻣﯿﮑﻨﯿﻢ ﺑﺎ ﺣﺎﻟﺖ ‪append‬‬

‫‪ (6‬در ﺑﺨﺶ ﻋﻤﻠﯿﺎﺗﯽ ﻓﺎﯾﻞ ﯾﮏ ﺣﻠﻘﻪ در ﮐﻠﯿﺪ ﻫﺎی دﯾﮑﺸﻨﺮی ﻣﯿﺰﻧﯿﻢ ‪.‬‬

‫‪ (7‬ﺑﻪ ﮐﻤﮏ ﻣﺘﺪ ‪ write‬در ﻫﺮ ﺧﻂ از ﻓﺎﯾﻞ ‪ txt‬ﻧﺎم ﻣﺨﺎﻃﺐ ﮐﻪ ﻫﻤﺎن ﮐﻠﯿﺪ در دﯾﮑﺸﻨﺮی اﺳﺖ و ﺳﭙﺲ ﻋﻼﻣﺖ دو ﻧﻘﻄﻪ ‪ :‬و ﻣﻘﺪار ﮐﻠﯿﺪ‬

‫‪ (8‬را ﮐﻪ ﺷﻤﺎره ﺗﻠﻔﻦ اﺳﺖ و ﯾﮏ ﮐﺎراﮐﺘﺮ ﻓﺮار ‪ \n‬ﺑﺮای اﯾﺠﺎد ﺧﻂ ﺟﺪﯾﺪ ﻣﯿﻨﻮﯾﺴﯿﻢ‪.‬‬

‫‪ (9‬ﭘﺎﯾﺎن‪.‬‬
‫ﭘﺮوژه ذﺧﯿﺮه ﻣﺨﺎﻃﺐ در ﻓﺎﯾﻞ ‪txt‬‬
‫‪PYTHON FILE I/O‬‬ ‫‪Part 9‬‬

‫ﺳﻮرس ﮐﺪ ﻣﺮﺑﻮط ﺑﻪ ﺗﻤﺮﯾﻦ ﻗﺒﻠﯽ‬ ‫•‬