py_note
Uploaded by
amir1384amir1396py_note
Uploaded by
amir1384amir1396ﺑﻪ ﻧﺎﻡ ﺧﺪﺍ
ﺯﺑﺎﻥ ﺑﺮﻧﺎﻣەﻧﻮﯾﺴ ﭘﺎﯾﺘﻮﻥ
)ﻣﻘﺪﻣﺎﺗ (
ﺗﻬﻴﻪﻛﻨﻨﺪﻩ :ﺱ .ﻣﻮﺳﻮﯼ
[email protected]
۱۳ﺁﺑﺎﻥ ۱۴۰۳
ﭘﻴﺶﮔﻔﺘﺎﺭ
ﺗﺎﺭﻳﺨﭽﻪ ﺯﺑﺎﻥ ﭘﺎﻳﺘﻮﻥ
ﺍﮔﺮ ﺑﺨﻮﺍﻫﻴﻢ ﻧﮕﺎﻫی ﺑﻪ ﺳﻴﺮ ﺗﺎﺭﻳﺨی ﺷﻜﻞﮔﻴﺮﯼ ﺯﺑﺎﻥ ﺑﺮﻧﺎﻣﻪ ﻧﻮﻳﺴی Pythonﺑﻴﺎﻧﺪﺍﺯﻳﻢ ﺷﺎﻳﺪ ﺑﺎﻳﺪ ﺑﻪ ﺳﺎﻝ ۱۹۸۲
ﺑﺎﺯﮔﺮﺩﻳﻢ ،ﺯﻣﺎﻧی ﻛﻪ Guido Van Rossumﺧﺎﻟﻖ ﺯﺑﺎﻥ ﺑﺮﻧﺎﻣﻪﻧﻮﻳﺴی ﭘﺎﻳﺘﻮﻥ ﻓﻌﺎﻟﻴﺖ ﺧﻮﺩ ﺭﺍ ﺩﺭ ﻣﺆﺳﺴﻪﯼ
ﺗﺤﻘﻴﻘﺎﺗی ﻣﺮﻛﺰ ﺭﻳﺎﺿﻴﺎﺕ ﻭ ﻋﻠﻮﻡ ﻛﺎﻣﭙﻴﻮﺗﺮﯼ CWIﺩﺭ ﺁﻣﺴﺘﺮﺩﺍﻡ ﻫﻠﻨﺪ ﺁﻏﺎﺯ ﻛﺮﺩ ﻭ ﺩﺭ ﺳﺎﻝ ۱۹۹۱ﺍﻭﻟﻴﻦ ﻧﺴﺨﻪ
ﺯﺑﺎﻥ ﭘﺎﻳﺘﻮﻥ ﺍﺭﺍﺋﻪ ﺩﺍﺩ.
ﺩﺍﺳﺘﺎﻥ ﻧﺎﻣﮕﺬﺍﺭﯼ:
ﻭﻥ ﺭﻭﺳﻮﻡ ﭘﻴﺶ ﺍﺯ ﻫﺮ ﭼﻴﺰ ،ﺗلاﺵ ﻛﺮﺩ ﻧﺎﻣی ﻣﻨﺎﺳﺐ ﺑﺮﺍﯼ ﺯﺑﺎﻥ ﺟﺪﻳﺪﯼ ﻛﻪ ﺩﺭ ﺻﺪﺩ ﻃﺮﺍﺣی ﺁﻥ ﺑﻮﺩ ﭘﻴﺪﺍ ﻛﻨﺪ ﻭ
ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺍﻳﻦ ﻛﻪ ﺍﻳﻦ ﺯﺑﺎﻥ ﺟﺪﻳﺪ ﺍﺯ ﺩﻝ ﭘﺮﻭﮊﻩﯼ ABCﺑﻴﺮﻭﻥ ﻣیﺁﻣﺪ ،ﺩﺭ ﺍﺑﺘﺪﺍ ﻗﺼﺪ ﺩﺍﺷﺖ ﺁﻥ ﺭﺍ Bﺑﻨﺎﻣﺪ ،ﺍﻣﺎ
ﻣﺘﻮﺟﻪ ﺷﺪ ﺯﺑﺎﻧی ﺑﻪ ﻫﻤﻴﻦ ﻧﺎﻡ ﻭﺟﻮﺩ ﺩﺍﺭﺩ .ﭘﺲ ﺍﺯ ﺁﻥ ﻛﻪ ﺭﻭﺳﻮﻡ ﺑﺴﻴﺎﺭﯼ ﺍﺯ ﭘﻴﺸﻨﻬﺎﺩﺍﺕ ﺍﻋﻀﺎﯼ ﮔﺮﻭﻩ ﺭﺍ ﺩﺭ ﻣﻮﺭﺩ
ﻧﺎﻡ ﺯﺑﺎﻥ ﺟﺪﻳﺪ ﺭﺩ ﻛﺮﺩ ﺗﺼﻤﻴﻢ ﮔﺮﻓﺖ ﺍﻭﻟﻴﻦ ﻧﺎﻣی ﺭﺍ ﻛﻪ ﺑﻪ ﺫﻫﻨﺶ ﺭﺳﻴﺪ ﺍﻧﺘﺨﺎﺏ ﻛﻨﺪ ،ﻛﻪ ﺑﻪ ﻃﻮﺭ ﺍﺗﻔﺎﻗی ﺑﻪ ﻳﺎﺩ
ﻛﻤﺪﯼ ﻣﺤﺒﻮﺑﺶ ﻛﻪ ﺁﻥ ﺭﻭﺯﻫﺎ ﺍﺯ ﺷﺒﻜﻪﯼ BBCﺑﺎ ﻧﺎﻡ Monty Python’s Flying Circusﭘﺨﺶ ﻣیﺷﺪ
ﺍﻓﺘﺎﺩ ﻭ ﺑﻪ ﺍﻳﻦ ﺗﺮﺗﻴﺐ ﻧﺎﻡ ﭘﺎﻳﺘﻮﻥ ﺭﺍ ﺑﺮﺍﯼ ﭘﺮﻭﮊﻩﯼ ﺟﺪﻳﺪ ﺧﻮﺩ ﺍﻧﺘﺨﺎﺏ ﻛﺮﺩ.
ﺗﺎ ﻣﺪﺕﻫﺎ ﺭﻭﺳﻮﻡ ﺍﺟﺎﺯﻩ ﻧﻤیﺩﺍﺩ ﻛﻪ ﺍﺯ ﺗﺼﻮﻳﺮ ﭘﺎﻳﺘﻮﻥ ﻛﻪ ﮔﻮﻧﻪﺍﯼ ﻣﺎﺭ ﺍﺳﺖ ﺑﻪ ﻋﻨﻮﺍﻥ ﻧﻤﺎﺩ ﺍﻳﻦ ﺯﺑﺎﻥ ﺍﺳﺘﻔﺎﺩﻩ ﺷﻮﺩ
ﻭ ﺍﻭﻟﻴﻦ ﺑﺎﺭ ﺍﻧﺘﺸﺎﺭﺍﺕ O’Reillyﻛﻪ ﻫﻤﻴﺸﻪ ﺗﺼﻮﻳﺮ ﻳﮏ ﺟﺎﻧﻮﺭ ﺭﺍ ﺭﻭﯼ ﻛﺘﺎﺏﻫﺎﯼ ﺧﻮﺩ ﻗﺮﺍﺭ ﻣیﺩﻫﺪ ،ﺍﺯ ﺗﺼﻮﻳﺮ
ﻳﮏ ﻣﺎﺭ ﺭﻭﯼ ﻛﺘﺎﺏ ﺁﻣﻮﺯﺵ ﺑﺮﻧﺎﻣﻪﻧﻮﻳﺴی ﺑﻪ ﺯﺑﺎﻥ ﭘﺎﻳﺘﻮﻥ ﺍﺳﺘﻔﺎﺩﻩ ﻛﺮﺩ ﻭ ﺑﻌﺪﻫﺎ ﻧﻴﺰ ﺍﻏﻠﺐ ﺍﺯ ﺗﺼﻮﻳﺮ ﻳﮏ ﻣﺎﺭ ﺑﻪ
ﻋﻨﻮﺍﻥ ﻧﻤﺎﺩ ﭘﺎﻳﺘﻮﻥ ﺍﺳﺘﻔﺎﺩﻩ ﺷﺪ.
ﻧﺴﺨﻪﻫﺎﯼ ﺯﺑﺎﻥ ﭘﺎﻳﺘﻮﻥ
• ﺩﺭ ﺣﺎﻝ ﺣﺎﺿﺮ ﭘﺎﻳﺘﻮﻥ ﺩﻭ ﻧﺴﺨﻪ ﺩﺍﺭﺩ .ﻧﺴﺨﻪ 2.xﻭ ﻧﺴﺨﻪ 3.x
ﺁ
ﺏ
• ﭘﺸﺘﻴﺒﺎﻧی ﺍﺯ ﺩﻭ ﻧﺴﺨﻪﯼ 2ﻭ 3ﺑﻪ ﺻﻮﺭﺕ ﻣﻮﺍﺯﯼ ﺩﺭ ﻛﻨﺎﺭ ﻫﻢ ﺍﺩﺍﻣﻪ ﺩﺍﺭﺩ ،ﺑﺎ ﺍﻳﻦ ﺣﺎﻝ ﺑﺮ ﺍﺳﺎﺱ ﻗﺮﺍﺭﺩﺍﺩﻫﺎﯼ
ﺻﻮﺭﺕ ﮔﺮﻓﺘﻪ ﺗﻮﺳﻌﻪ ﻧﺴﺨﻪﯼ 2ﺗﻨﻬﺎ ﺗﺎ ﺷﻤﺎﺭﻩﯼ 2.7ﺍﺩﺍﻣﻪ ﻣیﻳﺎﺑﺪ ﻭ ﭘﺸﺘﻴﺒﺎﻧی ﺍﺯ ﺁﻥ ﻓﻘﻂ ﺗﺎ ﺳﺎﻝ ۲۰۲۰
ﺍﺩﺍﻣﻪ ﺩﺍﺷﺖ.
• ﻗﺎﻋﺪﺗ ًﺎ ﭘﺲ ﺍﺯ ﺍﻧﺘﺸﺎﺭ ﻧﺴﺨﻪﯼ 3ﭘﺎﻳﺘﻮﻥ ﺗﻤﺎﻡ ﺑﺮﻧﺎﻣﻪﻫﺎ ﻭ ﻛﺘﺎﺑﺨﺎﻧﻪﻫﺎﯼ ﻧﺴﺨﻪﯼ ﻗﺒﻠی ﺑﺎﻳﺪ ﺑﻪ ﻧﺴﺨﻪﯼ ﺟﺪﻳﺪ
ﺍﺭﺗﻘﺎ ﻣیﻳﺎﻓﺘﻨﺪ ،ﺑﺎ ﺍﻳﻦ ﺣﺎﻝ ِﺍﻋﻤﺎﻝ ﻗﺎﺑﻠﻴﺖﻫﺎ ﻭ ﮔﺮﺍﻣﺮ ﺟﺪﻳﺪ ﺩﺭ ﻧﺴﺨﻪﻫﺎﯼ ﻗﺒﻠی ﻭ ﻣﻬﺎﺟﺮﺕ ﺷﺮﻛﺖﻫﺎﯼ
ﺑﺰﺭﮒ ﺑﻪ ﻧﺴﺨﻪﯼ ﺟﺪﻳﺪ ﺑﺴﻴﺎﺭ ﺯﻣﺎﻥ ﺑﺮ ﺑﻮﺩ .ﺍﺯ ﻃﺮﻓی ﻧﺴﺨﻪﯼ ﺟﺪﻳﺪ ﻫﻢ ﻗﺎﺑﻠﻴﺖ Backward Com-
patibilityﻳﺎ ﺳﺎﺯﮔﺎﺭﯼ ﺑﺎ ﻧﺴﺨﻪﻫﺎﯼ ﭘﻴﺸﻴﻦ ﺭﺍ ﻧﺪﺍﺷﺖ ﻭ ﺩﺭ ﺻﻮﺭﺗی ﻛﻪ ﺍﻳﺮﺍﺩﯼ ﺩﺭ ﻧﺴﺨﻪﻫﺎﯼ 2ﻭﺟﻮﺩ
ﺩﺍﺷﺖ ،ﻛﺎﺭﺑﺮﺍﻥ ﻧﻤیﺗﻮﺍﻧﺴﺘﻨﺪ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻧﺴﺨﻪﯼ ﺟﺪﻳﺪ ﺑﺮ ﺁﻥ ﺍﻳﺮﺍﺩﺍﺕ ﻓﺎﺋﻖ ﺁﻳﻨﺪ .ﺑﺮ ﻫﻤﻴﻦ ﺍﺳﺎﺱ ﺗﻴﻢ
ﺗﻮﺳﻌﻪﯼ ﺯﺑﺎﻥ ﺑﺮﻧﺎﻣﻪﻧﻮﻳﺴی ﭘﺎﻳﺘﻮﻥ ﺗﺼﻤﻴﻢ ﮔﺮﻓﺖ ﺩﺭ ﻳﮏ ﺩﻭﺭﻩﯼ ﺯﻣﺎﻧی ﻣﺤﺪﻭﺩ ﺗﻮﺳﻌﻪﯼ ﻧﺴﺨﻪﯼ 2ﺭﺍ
ﺍﺩﺍﻣﻪ ﺩﻫﺪ.
ﭼﺮﺍ ﺯﺑﺎﻥ ﺑﺮﻧﺎﻣﻪﻧﻮﻳﺴی ﭘﺎﻳﺘﻮﻥ؟
ﺯﺑﺎﻥ ﺑﺮﻧﺎﻣﻪﻧﻮﻳﺴی ﭘﺎﻳﺘﻮﻥ ﺑﻪ ﺩلاﻳﻞ ﺯﻳﺮ ﺍﻧﺘﺨﺎﺏ ﺷﺪﻩ ﺍﺳﺖ.
.۱ﻳﺎﺩﮔﻴﺮﯼ ﺁﻥ ﻧﺴﺒﺘ ًﺎ ﺳﺎﺩﻩ ﺍﺳﺖ ،ﭼﺮﺍ ﻛﻪ ﮔﺮﺍﻣﺮ ﺁﻥ ﺑﻪ ﺯﺑﺎﻥ ﻣﺤﺎﻭﺭﻩ )ﺍﻧﮕﻠﻴﺴی( ﻧﺰﺩﻳﮏ ﺍﺳﺖ.
.۲ﺩﺍﺭﺍﯼ ﻛﺎﺭﺑﺮﺩﻫﺎﯼ ﻣﺘﻨﻮع ﺍﺳﺖ.
.۳ﻣﺘﻦ ﺑﺎﺯ ﻭ ﺭﺍﻳﮕﺎﻥ ﺍﺳﺖ.
.۴ﺩﺍﺭﺍﯼ ﻛﺘﺎﺑﺨﺎﻧﻪﻫﺎﯼ ﻭﺳﻴع ﻭ ﻣﺘﻨﻮﻋی ﺍﺳﺖ.
.۵ﺭﻭﯼ ﻫﻤﻪﯼ ﺳﻴﺴﺘﻢ ﻋﺎﻣﻞﻫﺎ ﻧﻈﻴﺮ Windowsﻭ Mac.Osﻭ Linuxﻛﺎﺭ ﻣیﻛﻨﺪ.
ُ .۶ﻛﺪﻫﺎﯼ ﺁﻥ ﺍﺯ ﻳﮏ ﺳﻴﺴﺘﻢ ﺑﻪ ﺳﻴﺴﺘﻢ ﺩﻳﮕﺮ ﻗﺎﺑﻞ ﺣﻤﻞ ﺍﺳﺖ.
.۷ﺧﺎﺻﻴﺖ ﺷیﮔﺮﺍﻳﯽ ۱ﺩﺍﺭﺩ.
.۸ﺭﺷﺪ ﺳﺮﻳع ﻭ ﺍﺳﺘﻔﺎﺩﻩ ﺁﻥ ﺩﺭ ﺩﻧﻴﺎ
ﺗﻤﺎﻡ ُﻛﺪﻫﺎﯼ ﺍﻳﻦ ﺟﺰﻭﻩ ﺩﺭ ﻣﺤﻴﻂ JupyterLabﻧﻮﺷﺘﻪ ﻭ ﺍﺟﺮﺍ ﺷﺪﻩ ﺍﺳﺖ .ﻭ ﺩﺭج ﺁﻧﻬﺎ ﺩﺭ ﺟﺰﻭﻩ ﻫﻢ ﺑﻪ ﻫﻤﺎﻥ
ﺻﻮﺭﺕ ﻣﺤﻴﻂ ﻳﺎﺩ ﺷﺪﻩ ﺣﺮﻭﻑﻧﮕﺎﺭﯼ ﺷﺪﻩ ﺍﺳﺖ .ﺑﻨﺎﺑﺮﺍﻳﻦ ﺍﺟﺮﺍﯼ ﭘﺎﺭﻩﺍﯼ ﺍﺯ ﺳﻠﻮﻝ ۲ﻫﺎ ﻧﻴﺎﺯﻣﻨﺪ ﺍﺟﺮﺍﯼ ﺳﻠﻮﻝ]ﻫﺎﯼ[
ﭘﻴﺸﻴﻦ ﺍﺳﺖ.
ﺩﺭ ﺧﺎﺗﻤﻪ ﺑﺮ ﺑﻨﺪﻩ ﻓﺮﺽ ﺍﺳﺖ ﻛﻪ ﺍﺯ ﺁﻗﺎﯼ ﻭﻓﺎ ﺧﻠﻴﻘی ﺑﺨﺎﻃﺮ ﻓﺮﺍﻫﻢ ﻧﻤﻮﺩﻥ ﺑﺴﺘﻪﯼ ﺯﯼﭘﺮﺷﻴﻦ ۳ﻛﻪ ﺍﻣﻜﺎﻥ ﻧﻮﺷﺘﻦ
ﻣﺘﻮﻥ ﻓﺎﺭﺳی ﺩﺭ ﻣﺤﻴﻂ لاﺗﮏ ۴ﺭﺍ ﺍﻳﺠﺎﺩ ﻧﻤﻮﺩﻩ ﺍﺳﺖ ،ﺻﻤﻴﻤﺎﻧﻪ ﺳﭙﺎﺳﮕﺰﺍﺭﯼ ﻛﻨﻢ.
1. Object Oriented
2. Cell
3. XEPersian
4. LATEX
ﭖ
ﻣﺴﻠﻤ ًﺎ ﻧﻮﺷﺘﻪ ﺣﺎﺿﺮ ﺧﺎﻟی ﺍﺯ ﺧﻠﻞ ﻧﻴﺴﺖ ،ﻧﻮﻳﺴﻨﺪﻩ ﺍﺯ ﻫﺮ ﮔﻮﻧﻪ ﺍﻇﻬﺎﺭ ﻧﻈﺮ ﻭ ﭘﻴﺸﻨﻬﺎﺩﯼ ﺑﺮﺍﯼ ﺍﺻلاﺡ ﻭ ﺍﺭﺗﻘﺎﺀ ﺁﻥ
ﺍﺳﺘﻘﺒﺎﻝ ﻭ ﺍﺳﺘﻔﺎﺩﻩ ﺧﻮﺍﻫﺪ ﻧﻤﻮﺩ.
ﻓﻬﺮﺳﺖ ﻣﻄﺎﻟﺐ
ﺡ ﭘﻴﺶﮔﻔﺘﺎﺭ
۱ ۱ﻛﻠﻴﺎﺕ ﺯﺑﺎﻥ
۱ ۱-۱ﻣﻘﺪﻣﻪ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۱ ۱-۱-۱ﻣﺤﺎﺳﺒﺎﺕ ﺍﻭﻟﻴﻪ ﺭﻳﺎﺿی . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۲ ۲-۱-۱ﺍﻧﻮﺍﻉ ﺩﺍﺩﻩﻫﺎ ﻳﺎ ﻣﻘﺎﺩﻳﺮ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۳ ۱-۲-۱-۱ﺍﻭﻟﻮﻳﺖ ﺍﺟﺮﺍﯼ ﻋﻤﻠﻴﺎﺕ . . . . . . . . . . . . . . . . . . . . . .
۴ ۳-۱-۱ﻣﺘﻐﻴﺮ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۶ ۴-۱-۱ﻋﻤﻠﮕﺮﻫﺎ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۶ ۱-۴-۱-۱ﻋﻤﻠﮕﺮﻫﺎﯼ ﺣﺴﺎﺑﯽ . . . . . . . . . . . . . . . . . . . . . . . .
۷ ۲-۴-۱-۱ﻋﻤﻠﮕﺮﻫﺎﯼ ﻣﻘﺎﻳﺴﻪﺍﯼ . . . . . . . . . . . . . . . . . . . . . .
۷ ۳-۴-۱-۱ﻋﻤﻠﮕﺮﻫﺎﯼ ﺑﻮﻟی . . . . . . . . . . . . . . . . . . . . . . . . .
۹ ۵-۱-۱ﺗﺎﺑع )(. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . input
۱۰ ۶-۱-۱ﻧﻮﺷﺘﻦ ﻳﺎﺩﺩﺍﺷﺖ ﺑﺮﺍﯼ ﺗﻮﺿﻴح . . . . . . . . . . . . . . . . . . . . . . . . .
۱۲ ۲ﻣﺤﻴﻂﻫﺎﯼ ﻛﻨﺘﺮﻟی
۱۲ ۱-۲ﻣﻘﺪﻣﻪ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۱۲ ۲-۲ﺷﺮﻁ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۱۴ ۱-۲-۲ﺷﺮﻁﻫﺎﯼ ﺗﻮ ﺩﺭ ﺗﻮ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۱۵ ۲-۲-۲ﺩﺳﺘﻮﺭ ﺷﺮﻁﻫﺎﯼ ﻣﻔﺼﻞ . . . . . . . . . . . . . . . . . . . . . . . . . . .
ﺕ
ﺙ
۱۶ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ۳-۲ﺣﻠﻘﻪ . .
ﺣﻠﻘﻪ ﺑﺎ ﺩﺳﺘﻮﺭ ۱۶ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . while ۱-۳-۲
ﺩﻭ ﻛﻠﻴﺪ ﻭﺍﮊﻩ breakﻭ ۱۹ . . . . . . . . . . . . . . . . . . . . . . . continue ۲-۳-۲
ﺑﻠﻮﮎ elseﺩﺭ ﺣﻠﻘﻪ ۲۰ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ۳-۳-۲
ﻣﻔﻬﻮﻡ flagﺩﺭ ﺣﻠﻘﻪ ۲۱ . . . . . . . . . . . . . . . . . . . . . . . . . . while ۴-۳-۲
ﺣﻠﻘﻪ ﺑﺎ ﺩﺳﺘﻮﺭ ۲۱ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . for ۵-۳-۲
۱-۵-۳-۲ﺗﺎﺑع )(۲۲ . . . . . . . . . . . . . . . . . . . . . . . . . . range
ﺣﻠﻘﻪﻫﺎﯼ ﺗﻮ ﺩﺭ ﺗﻮ ۲۴ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ۶-۳-۲
۱-۶-۳-۲ﻓﺮﻣﺖﻫﺎ ۲۵ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۲-۶-۳-۲ﻭﺍﺭﺩ ﻛﺮﺩﻥ ﻣﺎﮊﻭﻝ ﺩﺭ ﭘﺎﻳﺘﻮﻥ ۲۸ . . . . . . . . . . . . . . . . . . . .
۳۰ ۳ﺗﻮﺍﺑع ﺩﺭ ﭘﺎﻳﺘﻮﻥ
۱-۳ﻣﻘﺪﻣﻪ ۳۰ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۲-۳ﺗﻮﺍﺑع ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﻛﺎﺭﺑﺮ ۳۱ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۱-۲-۳ﻣﻘﺪﺍﺭ ۳۲ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . None
۱-۱-۲-۳ﻛﻠﻴﺪ ﻭﺍﮊﻩ ۳۳ . . . . . . . . . . . . . . . . . . . . . . . . . return
۲-۱-۲-۳ﻓﺮﺍﺧﻮﺍﻧی ﻳﮏ ﺗﺎﺑع ﺩﺍﺧﻞ ﺗﺎﺑع ﺩﻳﮕﺮ ۳۴ . . . . . . . . . . . . . . . .
۲-۲-۳ﻧﺤﻮﻩ ﻗﺮﺍﺭ ﮔﺮﻓﺘﻦ ﻭ ﺗﺮﺗﻴﺐ ﺁﺭﮔﻮﻣﺎﻥﻫﺎ ۳۵ . . . . . . . . . . . . . . . . . . . . .
۳-۲-۳ﻧﺤﻮﻩ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻣﻘﺎﺩﻳﺮ ﭘﻴﺶﻓﺮﺽ ﺩﺭ ﺁﺭﮔﻮﻣﺎﻥ ﺗﻮﺍﺑع ۳۵ . . . . . . . . . . . . . .
۱-۳-۲-۳ﺁﺭﮔﻮﻣﺎﻥﻫﺎﯼ ﺍﺧﺘﻴﺎﺭﯼ ﺗﺎﺑع ۳۸ . . . . . . . . . . . . . . . . . print
۴-۲-۳ﻣﺘﻐﻴﺮﻫﺎﯼ ﻣﺤﻠی ﻭ ﺟﻬﺎﻧی ۳۹ . . . . . . . . . . . . . . . . . . . . . . . . . .
۴۳ ۴ﺩﺍﺩﻩ ﺳﺎﺧﺘﺎﺭﻫﺎ
۴۳ ۱-۴ﻣﻘﺪﻣﻪ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۴۴ ۲-۴ﻟﻴﺴﺖ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۴۴ ۱-۲-۴ﺩﺳﺘﺮﺳی ﺑﻪ ﻣﻘﺎﺩﻳﺮ ﻟﻴﺴﺖ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺍﻧﺪﻳﺲ . . . . . . . . . . . . . . . . .
۴۶ ۱-۱-۲-۴ﺍﻧﺪﻳﺲ ﻣﻨﻔی . . . . . . . . . . . . . . . . . . . . . . . . . . .
۴۶ ۲-۱-۲-۴ﺯﻳﺮﻟﻴﺴﺖﻫﺎ ﻭ ﺑﺮﺵ . . . . . . . . . . . . . . . . . . . . . . . .
۴۷ ۳-۱-۲-۴ﺗﻐﻴﻴﺮ ﻣﻘﺎﺩﻳﺮ ﻟﻴﺴﺖ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺍﻧﺪﻳﺲﻫﺎ . . . . . . . . . . . . .
۴۸ ۴-۱-۲-۴ﺟﻤﻊ ﻭ ﺿﺮﺏ ﺩﺭ ﻟﻴﺴﺖﻫﺎ . . . . . . . . . . . . . . . . . . . . .
۴۸ ۲-۲-۴ﺍﻓﺰﻭﺩﻥ ﻋﻨﺎﺻﺮ ﺟﺪﻳﺪ ﺑﻪ ﻟﻴﺴﺖ . . . . . . . . . . . . . . . . . . . . . . . .
۴۹ ۳-۲-۴ﺣﺬﻑ ﺍﻋﻀﺎﯼ ﻟﻴﺴﺖ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۵۱ ۴-۲-۴ﺳﺎﻣﺎﻥ ﺩﺍﺩﻥ ﺑﻪ ﻟﻴﺴﺖ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۵۲ ۵-۲-۴ﺩﺭﺳﺖ ﻛﺮﺩﻥ ﻟﻴﺴﺖ ﺑﺎ ﺗﺎﺑع . . . . . . . . . . . . . . . . . . . . . . . range
ﺝ
۵۲ ۶-۲-۴ﻛﭙﯽ ﻛﺮﺩﻥ ﻟﻴﺴﺖ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۵۴ ۱-۶-۲-۴ﭘﻴﻤﺎﻳﺶ ﻟﻴﺴﺖ ﺗﻮﺳﻂ ﺣﻠﻘﻪ . . . . . . . . . . . . . . . . . . . .
۵۴ ﭼﻨﺪﺗﺎﻳﯽ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ۳-۴
۵۴ ۱-۳-۴ﺗﻌﺮﻳﻒ ﭼﻨﺪﺗﺎﻳﯽ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۵۵ ﺭﺷﺘﻪﻫﺎ ﻭ ﺭﻭﺵﻫﺎ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ۴-۴
۵۶ ۱-۴-۴ﺭﻭﺵﻫﺎ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۵۸ ۲-۴-۴ﺗﺒﺪﻳﻞ ﺭﺷﺘﻪ ﺑﻪ ﻟﻴﺴﺖ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۵۹ ﺩﻳﻜﺸﻨﺮﯼ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ۵-۴
۵۹ ۱-۵-۴ﺗﺮﺗﻴﺐ ﺩﺭ ﻟﻴﺴﺖ ﻭ ﺩﻳﻜﺸﻨﺮﯼ . . . . . . . . . . . . . . . . . . . . . . . . .
۶۰ ۲-۵-۴ﻭﻳﺮﺍﻳﺶ ﺩﺭ ﺩﻳﻜﺸﻨﺮﯼ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۶۱ ۳-۵-۴ﺯﻭجﻫﺎﯼ ﻛﻠﻴﺪ-ﻣﻘﺪﺍﺭ ﺩﺭ ﺣﻠﻘﻪ . . . . . . . . . . . . . . . . . . . . . . . .
۶۳ ۴-۵-۴ﺍﻳﺠﺎﺩ ﺩﻳﻜﺸﻨﺮﯼ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺗﺎﺑع )(. . . . . . . . . . . . . . . . . . . dict
۶۳ ۵-۵-۴ﺩﺭﻫﻢ ﺷﺪﮔی . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۶۳ ۱-۵-۵-۴ﻟﻴﺴﺘی ﺍﺯ ﺩﻳﻜﺸﻨﺮﯼﻫﺎ . . . . . . . . . . . . . . . . . . . . . .
۶۴ ۲-۵-۵-۴ﻟﻴﺴﺖ ﺩﺭ ﺩﻳﻜﺸﻨﺮﯼ . . . . . . . . . . . . . . . . . . . . . . .
۶۵ ۳-۵-۵-۴ﺩﻳﻜﺸﻨﺮﯼ ﺩﺭ ﺩﻳﻜﺸﻨﺮﯼ . . . . . . . . . . . . . . . . . . . . .
۶۷ ﻣﺠﻤﻮﻋﻪ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ۶-۴
۶۹ ۵ﻋﻤﻠﻴﺎﺕ ﺭﻭﯼ ﻓﺎﻳﻞﻫﺎ ﻭ ﻣﺪﻳﺮﻳﺖ ﺧﻄﺎﻫﺎ
۶۹ ۱-۵ﻣﻘﺪﻣﻪ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۶۹ ۲-۵ﻧﺤﻮﮤ ﺩﺳﺘﺮﺳی ﺑﻪ ﻓﺎﻳﻞﻫﺎ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۷۰ ۳-۵ﺧﻮﺍﻧﺪﻥ ﻓﺎﻳﻞ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۷۰ ۱-۳-۵ﺧﻮﺍﻧﺪﻥ ﻓﺎﻳﻞ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺭﻭﺵ . . . . . . . . . . . . . . . . . . . . . read
۷۱ ۲-۳-۵ﺧﻮﺍﻧﺪﻥ ﻓﺎﻳﻞ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺭﻭﺵ . . . . . . . . . . . . . . . . . . . readline
۷۳ ۳-۳-۵ﺧﻮﺍﻧﺪﻥ ﻓﺎﻳﻞ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺭﻭﺵ . . . . . . . . . . . . . . . . . . readlines
۷۴ ۴-۳-۵ﻣﺤﻴﻂ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . with
۷۵ ۵-۳-۵ﻧﺴﺒﺖ ﺩﺍﺩﻥ ﻣﺤﺘﻮﯼ ﻓﺎﻳﻞ ﺑﻪ ﻳﮏ ﻣﺘﻐﻴﺮ . . . . . . . . . . . . . . . . . . . .
۷۶ ۴-۵ﻧﻮﺷﺘﻦ ﺭﻭﯼ ﻓﺎﻳﻞ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۷۷ ۵-۵ﺍﺿﺎﻓﻪ ﻛﺮﺩﻥ ﺍﻃلاﻋﺎﺕ ﺑﻪ ﺍﻧﺘﻬﺎﯼ ﻳﮏ ﻓﺎﻳﻞ . . . . . . . . . . . . . . . . . . . . . . .
۷۸ ۶-۵ﺣﺎﻟﺖﻫﺎﯼ ﺗﺮﻛﻴﺒﯽ ﺧﻮﺍﻧﺪﻥ ﻭ ﻧﻮﺷﺘﻦ ﻭ ﺍﺿﺎﻓﻪ ﻛﺮﺩﻥ . . . . . . . . . . . . . . . . . . .
۸۱ ۷-۵ﻋﻤﻠﻴﺎﺕ ﺑﺎ ﻓﺎﻳﻞﻫﺎ ﺑﺎ ﭘﺴﻮﻧﺪ . . . . . . . . . . . . . . . . . . . . . . . . . . . . CSV
ﻓﻬﺮﺳﺖ ﺷﻜﻞﻫﺎ
۱۳ . . . . . . . . . . . . . . . . . . . . . . . . . . . . ﺭﻭﻧﺪﻧﻤﺎﯼ ﺑﻠﻮﮎ . . . . if-else ۱-۲
۱۴ . . . . . . . . . . . . . . . . . . . . . . . . . . . . ﺭﻭﻧﺪﻧﻤﺎﯼ ﺷﺮﻁ ﺗﻮ ﺩﺭ ﺗﻮ if-else ۲-۲
۱۵ . . . . . . . . . . . . . . . . . . . . . . . . . . . . ﺭﻭﻧﺪﻧﻤﺎﯼ ﺷﺮﻁ . . . . . . elif ۳-۲
۱۶ . . . . . . . . . . . . . . . . . . . . . . . . . . . . ﺭﻭﻧﺪﻧﻤﺎﯼ ﺣﻠﻘﻪ . . . . . . . . ۴-۲
ﭺ
ﻓﻬﺮﺳﺖ ﺟﺪﻭﻝﻫﺎ
۷ ۱-۱ﻋﻤﻠﮕﺮﻫﺎﯼ ﻣﻘﺎﻳﺴﻪﺍﯼ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
۷۸ ۱-۵ﺣﺎلاﺕ ﻣﺨﺘﻠﻒ ﺑﺎﺯ ﻛﺮﺩﻥ ﻓﺎﻳﻞﻫﺎ . . . . . . . . . . . . . . . . . . . . . . . . . . . .
ﺡ
���
۱
ﻛﻠﻴﺎﺕ ﺯﺑﺎﻥ
ﻣﻘﺪﻣﻪ ۱-۱
ﺩﺭ ﺍﻳﻦ ﻓﺼﻞ ﻣﻮﺍﺭﺩ ﺍﻭﻟﻴﻪ ﺯﺑﺎﻥ ﺁﻭﺭﺩﻩ ﻣیﺷﻮﺩ .ﻛﻪ ﻋﺒﺎﺭﺗﻨﺪ ﺍﺯ:
• ﻣﺤﺎﺳﺒﺎﺕ ﺍﻭﻟﻴﻪ ﺭﻳﺎﺿی
• ﺍﻧﻮﺍﻉ ﺩﺍﺩﻩﻫﺎ ﻳﺎ ﻣﻘﺎﺩﻳﺮ
• ﻣﻌﺮﻓی ﻣﺘﻐﻴﺮ ،ﻋﺒﺎﺭﺕ
• ﻣﻌﺮﻓی ﻋﻤﻠﮕﺮﻫﺎ
ﻣﺤﺎﺳﺒﺎﺕ ﺍﻭﻟﻴﻪ ﺭﻳﺎﺿی ۱-۱-۱
ﺩﺭ ﭘﺎﻳﺘﻮﻥ ﻣیﺗﻮﺍﻥ ﭼﻬﺎﺭ ﻋﻤﻞ ﺍﺻﻠی ﻭ ﺗﻮﺍﻥ ﺭﺍ ﻣﺜﻞ ﻳﮏ ﻣﺎﺷﻴﻦ ﺣﺴﺎﺏ ﻣﺤﺎﺳﺒﻪ ﻧﻤﻮﺩ .ﺑﺮﺍﯼ ﺟﻤﻊ ﺍﺯ ﻋلاﻣﺖ )،(+
ﺑﺮﺍﯼ ﺗﻔﺮﻳﻖ ﺍﺯ ﻋلاﻣﺖ ) ،(-ﺑﺮﺍﯼ ﻋﻤﻞ ﺿﺮﺏ ﺍﺯ ﻋلاﻣﺖ )∗( ﻭ ﺑﺮﺍﯼ ﺗﻘﺴﻴﻢ ﺍﺯ ﻋلاﻣﺖ ) (/ﺍﺳﺘﻔﺎﺩﻩ ﻣیﺷﻮﺩ .ﺑﻪ
ﭼﻨﺪ ﻣﺜﺎﻝ ﺯﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ.
In [1]: 4+5
5 -7
3*5
5/4
9/3
۱
.۱-۱ﻣﻘﺪﻣﻪ ۲
Out[1]: 9
-2
15
1.25
3.0
ﺗﻮﺟﻪ :ﺣﺎﺻﻞ ﺗﻘﺴﻴﻢ ﺩﺭ ﻫﻤﻪ ﺣﺎﻟﺖﻫﺎ ،ﻋﺪﺩ ﺍﻋﺸﺎﺭﯼ ﺍﺳﺖ.
ﺑﺮﺍﯼ ﻧﺸﺎﻥ ﺩﺍﺩﻥ ﻧﺘﻴﺠﻪ ﺍﺟﺮﺍﯼ ُﻛﺪﻫﺎ ﺭﻭﯼ ﺻﻔﺤﮥ ﻧﻤﺎﻳﺶ ﻣیﺗﻮﺍﻥ ﺍﺯ ﺗﺎﺑع )( printﺍﺳﺘﻔﺎﺩﻩ ﻧﻤﻮﺩ.
ﺩﺭ ﻣﻮﺭﺩ ﺗﻘﺴﻴﻢ ﺩﻭ ﻋﻤﻠﮕﺮ ) (//ﻭ ) (%ﻫﻢ ﻭﺟﻮﺩ ﺩﺍﺭﺩ .ﺍﻭﻟی ﻗﺴﻤﺖ ﺻﺤﻴح ﻋﻤﻞ ﺗﻘﺴﻴﻢ ﻭ ﺩﻭﻣی ﺑﺎﻗﻴﻤﺎﻧﺪﻩ ﺗﻘﺴﻴﻢ
ﺭﺍ ﺑﺪﺳﺖ ﻣیﺩﻫﺪ .ﻣﺘﺎﻝ:
In [1]: )print (17/5
)print (17//5
)print (17%5
Out[1]: 3.4
3
2
ﻭ ﺍﮔﺮ ﻣﻘﺪﺍﺭ −۱۷٫۵ﺭﺍ ﻗﺮﺍﺭ ﺩﻫﻴﻢ ،ﻧﺘﻴﺠﻪ ﻣیﺷﻮﺩ.
In [2]: )print ( -17/5
)print ( -17//5
)print ( -17%5
Out[2]: -3.4
-4
3
ﺑﺮﺍﯼ ﻋلاﻣﺖ ﺗﻮﺍﻥ ﺍﺯ )∗∗( ﺍﺳﺘﻔﺎﺩﻩ ﻣیﺷﻮﺩ.
In [3]: 5**3
Out[3]: 125
۲-۱-۱ﺍﻧﻮﺍﻉ ﺩﺍﺩﻩﻫﺎ ﻳﺎ ﻣﻘﺎﺩﻳﺮ
ﺩﺭ ﭘﺎﻳﺘﻮﻥ ﺩﻭ ﺩﺳﺘﻪ ﺩﺍﺩﻩ ﺩﺍﺭﻳﻢ .ﺩﺍﺩﻩﻫﺎﯼ ﻋﺪﺩﯼ ﻭ ﺩﺍﺩﻩﻫﺎﯼ ﻏﻴﺮ ﻋﺪﺩﯼ .ﺩﺍﺩﻩﻫﺎﯼ ﻋﺪﺩﯼ ﺳﻪ ﻧﻮع ۱ﻫﺴﺘﻨﺪ.
ﺻﺤﻴح ۲ •
• ﺍﻋﺸﺎﺭﯼ ۳ﻳﺎ ﺩﺍﺭﺍﯼ ﻧﻘﻄﻪ ﺍﻋﺸﺎﺭ
1. type
2. integer
3. float
۳ ﻓﺼﻞ .۱ﻛﻠﻴﺎﺕ ﺯﺑﺎﻥ
• ﻣﺨﺘﻠﻂ ۱
ﻭ ﺩﺍﺩﻩﻫﺎﯼ ﻏﻴﺮ ﻋﺪﺩﯼ
ﺭﺷﺘﻪ ۲ •
ﺑﻮﻟی ۳ •
ﺩﺭ ﻣﻮﺭﺩ ﺩﺍﺩﻩﻫﺎﯼ ﻋﺪﺩﯼ ،ﺑﻪ ﻋﻨﻮﺍﻥ ﻣﺜﺎﻝ ۲۳ﻳﮏ ﻋﺪﺩ ﺻﺤﻴح ﻭ ۷٫۷ﻳﮏ ﻋﺪﺩ ﺍﻋﺸﺎﺭﯼ ﺍﺳﺖ .ﻋﺪﺩ ۵.ﺩﺍﺭﺍﯼ
ﻧﻘﻄﻪ ﺍﻋﺸﺎﺭ ﺍﺳﺖ ،ﺑﻨﺎﺑﺮﺍﻳﻦ ﻋﺪﺩ ﺍﻋﺸﺎﺭﯼ ﻣﺤﺴﻮﺏ ﻣیﺷﻮﺩ.
ﻓﺮﻡ ﻛﻠی ﻋﺪﺩ ﻣﺨﺘﻠﻂ ﺑﻪ ﺻﻮﺭﺕ x + y jﺍﺳﺖ .ﻗﺴﻤﺖ ﻣﻮﻫﻮﻣی ﻋﺪﺩ ﻫﻤﺎﻥ ﻣﺆﻟﻔﻪﺍﯼ ﺍﺳﺖ ﺣﺮﻑ jﺭﺍ ﺩﺍﺭﺩ.
ﺩﺭ ﭘﺎﻳﺘﻮﻥ ﺗﺎﺑﻌی ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﻛﻪ ﻧﻮع ﺩﺍﺩﻩﻫﺎ ﺭﺍ ﻣﺸﺨﺺ ﻣیﻛﻨﺪ .ﺍﻳﻦ ﺗﺎﺑع ﺑﻪ ﺻﻮﺭﺕ )( typeﺍﺳﺖ .ﺍﻛﻨﻮﻥ ﺑﻪ ﭼﻨﺪ
ﻣﺜﺎﻝ ﺗﻮﺟﻪ ﻛﻨﻴﺪ.
In [1]: ))print ( type (5
Out[1]: >' <class 'int
In [2]: ))print ( type (7.7
Out[2]: >' <class 'float
In [3]: ))print ( type (2+3 j
Out[3]: >' <class ' complex
۱-۲-۱-۱ﺍﻭﻟﻮﻳﺖ ﺍﺟﺮﺍﯼ ﻋﻤﻠﻴﺎﺕ
ﺍﻭﻟﻮﻳﺖ ﺍﻭﻝ ﺍﻧﺠﺎﻡ ﻋﻤﻠﻴﺎﺕ ﭘﺮﺍﻧﺘﺰ ﺍﺳﺖ .ﺳﭙﺲ ﺗﻮﺍﻥ ﻭ ﺑﻌﺪ ﺿﺮﺏ ﻭ ﺗﻘﺴﻴﻢ ﻭ ﺳﺮﺍﻧﺠﺎﻡ ﺟﻤﻊ ﻭ ﺗﻔﺮﻳﻖ ﺍﺳﺖ .ﺑﻪ
ﭼﻨﺪ ﻣﺜﺎﻝ ﺯﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ.
In [4]: 3+26 -2*3**2
Out[4]: 11
In [5]: )print (4+12/2+3
))print (4+12/(2+3
Out[5]: 13.0
6.4
1. complex
2. string
3. boolean
.۱-۱ﻣﻘﺪﻣﻪ ۴
ﺩﺭ ﻣﻮﺭﺩ ﺩﺍﺩﻩﻫﺎﯼ ﻏﻴﺮ ﻋﺪﺩﯼ ﺑﺎﻳﺪ ﺑﻪ ﺭﺷﺘﻪ ﺍﺷﺎﺭﻩ ﻧﻤﻮﺩ .ﺭﺷﺘﻪﻫﺎ ﻣﺠﻤﻮﻋﻪﺍﯼ ﺍﺯ ﻛﺎﺭﺍﻛﺘﺮﻫﺎ ﻫﺴﺘﻨﺪ ﻛﻪ ﺩﺍﺧﻞ )' '(
ﻭ ﻳﺎ )" "( ﻗﺮﺍﺭ ﻣیﮔﻴﺮﻧﺪ .ﻣﺜﺎﻝ:
In [1]: )"! print (" Hello world
)'print (' welcome to python learning .
Out[1]: ! Hello world
welcome to python learning .
ﺗﻮﺟﻪ :ﺍﮔﺮ ﺩﺍﺧﻞ ﻛﺎﺭﺍﻛﺘﺮﻫﺎﯼ ﺭﺷﺘﻪ ﻋلاﻣﺖ ﺁﺳﭙﺎﺳﺘﺮﻑ ﺑﻮﺩ ،ﺑﺎﻳﺪ ﺍﺯ ﻛﻮﺗﻴﺸﻦ ﺩﻭﺗﺎﻳﯽ ﺍﺳﺘﻔﺎﺩﻩ ﻧﻤﻮﺩ .ﻭ ﻳﺎ ﺍﮔﺮ
ﺩﺍﺧﻞ ﻛﺎﺭﺍﻛﺘﺮﻫﺎﯼ ﺩﺍﺧﻞ ﺭﺷﺘﻪ ﻋلاﻣﺖ )"( ﺑﻮﺩ ،ﺑﺎﻳﺪ ﺍﺯ ﻳﮏ ﻛﻮﺗﻴﺸﻦ ﺍﺳﺘﻔﺎﺩﻩ ﻛﺮﺩ .ﻣﺜﺎﻝ:
In [2]: )"print ("I'm student .
)'print ('It is the " special " book .
Out[2]: I'm student .
It is the " special " book .
ﻣﻮﺭﺩ ﺩﻭﻡ ﺩﺍﺩﻩﻫﺎﯼ ﻏﻴﺮ ﻋﺪﺩﯼ ،ﺩﺍﺩﻩﻫﺎﯼ ﺑﻮﻟی ﺍﺳﺖ ﻛﻪ ﻓﻘﻂ ﺩﻭ ﻣﻘﺪﺍﺭ ﻣیﭘﺬﻳﺮﺩ ،ﺩﺭﺳﺖ ) (Trueﻭ ﻳﺎ ﻏﻠﻂ
) (Falseﺣﺮﻑ ﺍﻭﻝ ﺁﻧﻬﺎ ﺣﺘﻤ ًﺎ ﺑﺎﻳﺪ ﺑﺰﺭﮒ ﺑﺎﺷﺪ .ﻣﺜﺎﻝ ﺁﻧﻬﺎ ﺭﺍ ﺩﺭ ﺍﺩﺍﻣﻪ ﻣﺸﺎﻫﺪﻩ ﺧﻮﺍﻫﻴﺪ ﻧﻤﻮﺩ.
ﻣﺘﻐﻴﺮ ۳-۱-۱
ﺩﺭ ﺍﺟﺮﺍﯼ ﻋﻤﻠﻴﺎﺕ ﻧﺘﺎﺑج ﺩﺭ ﺟﺎﻳﯽ ﺫﺧﻴﺮﻩ ﻧﻤیﺷﻮﺩ ﻭ ﭼﻨﺎﻧﭽﻪ ﺑﻌﺪ ًﺍ ﺑﻪ ﺁﻧﻬﺎ ﻧﻴﺎﺯ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﻢ ﻣﺠﺪﺩﺍ ﺑﺎﻳﺪ ﻋﻤﻠﻴﺎﺕ
ﺭﺍ ﺗﻜﺮﺍﺭ ﻧﻤﻮﺩ ﻭ ﺍﻳﻦ ﻋﻤل ًا ﺍﺩﺍﻣﻪ ﻛﺎﺭ ﺭﺍ ﻧﺎ ﻣﻤﻜﻦ ﻣیﺳﺎﺯﺩ ﻣﮕﺮ ﺁﻥ ﻛﻪ ﺑﺘﻮﺍﻧﻴﻢ ﺁﻧﻬﺎ ﺭﺍ ﺩﺭ ﺣﺎﻓﻈﻪ ﺩﺧﻴﺮﻩ ﻛﻨﻴﻢ .ﺑﺮﺍﯼ
ﺍﻳﻦ ﻛﺎﺭ ﺑﺎﻳﺪ ﺍﺯ ﻣﺘﻐﻴﺮ ۱ﻫﺎ ﺍﺳﺘﻔﺎﺩﻩ ﻛﺮﺩ .ﺑﻪ ﻃﻮﺭ ﺳﺎﺩﻩ ﻣﺘﻐﻴﺮ ،ﻣﺤﻠی ﺍﺯ ﺣﺎﻓﻈﻪ ﺍﺳﺖ ﻛﻪ ﻧﺘﺎﻳح ﻣﻮﺭﺩ ﻧﻄﺮ ﺩﺭ ﺁﻥ
ﺫﺧﻴﺮﻩ ﻣیﺷﻮﺩ.
ﻣﺘﻐﻴﺮﻫﺎ ﺳﻪ ﻭﻳﮋﮔی ﺩﺍﺭﻧﺪ .ﻧﺎﻡ ،ﻣﻘﺪﺍﺭ ﻭ ﻧﻮع .ﻧﺎﻡﮔﺬﺍﺭﯼ ﺁﻧﻬﺎ ﺍﺯ ﻗﻮﺍﻋﺪ ﺯﻳﺮ ﭘﻴﺮﻭﯼ ﻣیﻛﻨﺪ.
.۱ﺍﺯ ﺣﺮﻭﻑ ﺍﻟﻔﺒﺎﯼ ﺑﺰﺭﮒ ﺍﻧﮕﻠﻴﺴی Aﺗﺎ Zﺍﺳﺘﻔﺎﺩﻩ ﻣیﺷﻮﺩ .ﻫﻤﭽﻨﻴﻦ ﻣیﺗﻮﺍﻥ ﺣﺮﻭﻑ ﻛﻮﭼﮏ ﺍﻧﮕﻠﻴﺴی ﺍﺯ
aﺗﺎ zﺭﺍ ﻧﻴﺰ ﺑﻪ ﻛﺎﺭ ﮔﺮﻓﺖ.
.۲ﻣیﺗﻮﺍﻥ ﺍﺯ ﺍﺭﻗﺎﻡ 0ﺗﺎ 9ﺍﺳﺘﻔﺎﺩﻩ ﻧﻤﻮﺩ.
.۳ﺍﺯ ﺑﻴﻦ ﻛﺎﺭﺍﻛﺘﺮﻫﺎﯼ ﺧﺎﺹ ﻣﺜﻞ ﻋلاﻣﺖﻫﺎﯼ ? $ ،@ ،! ،ﻭ … ﺗﻨﻬﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻋلاﻣﺖ ﺯﻳﺮﺧﻂ (_) ۲ﻣﺠﺎﺯ
ﺍﺳﺖ.
.۴ﺍﻭﻟﻴﻦ ﻛﺎﺭﺍﻛﺘﺮ ﻧﺎﻡ ﻳﮏ ﻣﺘﻐﻴﺮ ﻧﻤیﺗﻮﺍﻧﺪ ﺍﺯ ﺍﺭﻗﺎﻡ 0ﺗﺎ 9ﺑﺎﺷﺪ.
.۵ﺍﺯ ﺍﺳﺎﻣی ﺭﺯﺭﻭ ﺷﺪﻩ ﺩﺭ ﭘﺎﻳﺘﻮﻥ ) (print, type, int, float, str,...ﺑﺮﺍﯼ ﻧﺎﻡ ﻣﺘﻐﻴﺮﻫﺎ ﺍﺳﺘﻔﺎﺩﻩ ﻧﻜﻨﻴﺪ.
1.
2. underscore
۵ ﻓﺼﻞ .۱ﻛﻠﻴﺎﺕ ﺯﺑﺎﻥ
ﭼﻨﺪ ﻣﺜﺎﻝ ﺩﺭﺳﺖ ﺍﺯ ﻧﺎﻡ ﻣﺘﻐﻴﺮstr_ ،_List ،var_1 ،var1 :
ﭼﻨﺪ ﻣﺜﺎﻝ ﻏﻠﻂ ﺍﺯ ﻧﺎﻡ ﻣﺘﻐﻴﺮX3(y) ،y X2 ،2X :
ﺗﻮﺟﻪ :ﭘﺎﻳﺘﻮﻥ ﻧﺴﺒﺖ ﺑﻪ ﺣﺮﻭﻑ ﻛﻮﭼﮏ ﻭ ﺑﺰﺭﮒ ﺣﺴﺎﺱ ﺍﺳﺖ .ﺑﻪ ﻋﻨﻮﺍﻥ ﻣﺜﺎﻝ ﻣﺘﻐﻴﺮ Texﺑﺎ ﻣﺘﻐﻴﺮ texﻳﻜﺴﺎﻥ
ﻧﻴﺴﺖ.
ﻣﺸﺨﺼﻪ ﺩﻭﻡ ﻣﺘﻐﻴﺮ ﻣﻘﺪﺍﺭﯼ ﻳﺎ ﻣﻘﺎﺩﻳﺮﯼ ﺍﺳﺖ ﻛﻪ ﺩﺭﻭﻥ ﺁﻥ ﺫﺧﻴﺮﻩ ﻣیﺷﻮﺩ .ﺑﺮﺍﯼ ﻧﺴﺒﺖ ﺩﺍﺩﻥ ۱ﻳﮏ ﻳﺎ ﭼﻨﺪ ﻣﻘﺪﺍﺭ
ﺑﻪ ﻳﮏ ﻣﺘﻐﻴﺮ ﺍﺯ ﻋلاﻣﺖ )=( ﺍﺳﺘﻔﺎﺩﻩ ﻣیﺷﻮﺩ .ﻭ ﺑﺎلاﺧﺮﻩ ﻧﻮع ﻣﺘﻐﻴﺮ ﺑﺴﺘﮕی ﺑﻪ ﻣﻘﺪﺍﺭﯼ ﺩﺍﺭﺩ ﻛﻪ ﺩﺭ ﺁﻥ ﺟﺎﯼ
ﻣیﮔﻴﺮﺩ .ﻳﻌﻨی ﺍﮔﺮ ﻣﻘﺪﺍﺭ ﺫﺧﻴﺮﻩ ﺷﺪﻩ ﻋﺪﺩ ﺻﺤﻴح ﺑﺎﺷﺪ ،ﻣﺘﻐﻴﺮ ﻫﻢ ﺻﺤﻴح ﺍﺳﺖ ﻭ ﺍﮔﺮ ﻣﻘﺪﺍﺭ ﺫﺧﻴﺮﻩ ﺷﺪﻩ ﺭﺷﺘﻪ
ﺑﺎﺷﺪ ،ﺁﻧﮕﺎﻩ ﻣﺘﻐﻴﺮ ﺍﺯ ﻧﻮع ﺭﺷﺘﻪﺍﯼ ﺍﺳﺖ .ﺑﻪ ﭼﻨﺪ ﻣﺜﺎﻝ ﺯﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ.
In [1]: x=4
)print (x
))print ( type (x
Out[1]: 4
>' <class 'int
intﻛﻮﺗﺎ ﺷﺪﻩ ﻛﻠﻤﻪ integerﺑﻪ ﻣﻌﻨﺎﯼ ﺻﺤﻴح ﺍﺳﺖ.
In [2]: ' z= 'zahra
)print (z
))print ( type (z
Out[2]: zahra
>' <class 'str
strﻛﻮﺗﺎ ﺷﺪﻩ ﻛﻠﻤﻪ stringﺑﻪ ﻣﻌﻨﺎﯼ ﺭﺷﺘﻪ ﺍﺳﺖ.
ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﻣﺸﺎﻫﺪﻩ ﻣیﺷﻮﺩ ﻋلاﻣﺖ ﺗﺴﺎﻭﯼ )=( ﺩﺭ ﺍﻳﻨﺠﺎ ﻣﻔﻬﻮﻡ ﺭﻳﺎﺿﻴﺎﺕ ﺭﺍ ﻧﺪﺍﺭﺩ .ﺑﺮﺍﯼ ﺭﻭﺷﻦ ﺷﺪﻥ ﺑﻪ ﻣﺜﺎﻝ
ﺯﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ.
In [3]: y =4.5
y=y +1
)print (y
Out[3]: 5.5
ﺍﻣﺎ ﺩﺭ ﺭﻳﺎﺿﻴﺎﺕ ﻧﻤیﺗﻮﺍﻥ ﺗﺴﺎﻭﯼ y = y+1ﺭﺍ ﺩﺍﺷﺖ ،ﭼﺮﺍ ﻛﻪ yﺍﺯ ﻃﺮﻓﻴﻦ ﺗﺴﺎﻭﯼ ﺣﺬﻑ ﻣیﺷﻮﺩ ﻭ ﻣﻘﺪﺍﺭ ﻳﮏ
ﺑﺮﺍﺑﺮ ﺻﻔﺮ ﻣیﺷﻮﺩ ﻛﻪ ﻧﺎﺩﺭﺳﺖ ﺍﺳﺖ .ﺍﻣﺎ ﺩﺭ ﻛﺪ ،ﺑﺪﻳﻦ ﻣﻌﻨی ﺍﺳﺖ ﻳﮏ ﻭﺍﺣﺪ ﺑﻪ yﻗﺒﻠی ﺍﺿﺎﻓﻪ ﻛﻦ .ﺑﻨﺎﺑﺮﺍﻳﻦ ﻣﻘﺪﺍﺭ
ﻣﺘﻐﻴﺮ yﺗﻐﻴﻴﺮ ﻣیﻛﻨﺪ .ﻫﻤﭽﻨﻴﻦ ﺩﺭ ﺭﻳﺎﺿﻴﺎﺕ ﻣیﺗﻮﺍﻥ ﺭﺍﺑﻄﻪﺍﯼ ﺑﻪ ﺻﻮﺭﺕ x+1=6-xﺩﺍﺷﺖ .ﺩﺭ ﺑﺮﻧﺎﻣﻪﻧﻮﻳﺴی
ﺍﻳﻦ ﺭﺍﺑﻄﻪ ﻧﺎﺩﺭﺳﺖ ﺍﺳﺖ ،ﭼﺮﺍ ﻛﻪ ﻃﺮﻑ ﭼﭗ ﺗﺴﺎﻭﯼ ﺑﺎﻳﺪ ﻣﺘﻐﻴﺮ ﺑﺎﺷﺪ .ﻭ x+1ﻣﺘﻐﻴﺮ ﻧﻴﺴﺖ ﭼﻮﻥ ﻋلاﻣﺖ )(+
ﺟﺰﺀ ﻋلاﺋﻢ ﻣﺠﺎﺯ ﻧﺎﻡ ﻣﺘﻐﻴﺮ ﻧﻴﺴﺖ.
1. assign
.۱-۱ﻣﻘﺪﻣﻪ ۶
ﺩﺭ ﻃﻮﻝ ﻳﮏ ﺑﺮﻧﺎﻣﻪ ﻣﻤﻜﻦ ﺍﺳﺖ ﭼﻨﺪﻳﻦ ﻭ ﭼﻨﺪ ﺑﺎﺭ ﻣﻘﺪﺍﺭ ﻳﮏ ﻣﺘﻐﻴﺮ ﺗﻐﻴﻴﺮ ﻛﻨﺪ.
ﻣﺜﺎﻝ:
In [1]: r=5
pi =3.14
area =pi*r*r
) print ( area
pi =3.14159
area =pi*r*r
) print ( area
Out[1]: 78.5
78.53975
ﻋﺒﺎﺭﺕ ۱ﺗﺮﻛﻴﺒﯽ ﺍﺯ ﻣﺘﻐﻴﺮ ،ﻋﺪﺩ ﻭ ﻋﻤﻠﮕﺮ ﺍﺳﺖ .ﺑﻪ ﻋﻨﻮﺍﻥ ﻣﺜﺎﻝ y+z ،2∗xﻭ s/tﻋﺒﺎﺭﺕ ﻫﺴﺘﻨﺪ .ﻣﺜﺎﻝ:
In [2]: x=4
y=5
z=x+y
)print (z,x/y
Out[2]: 9 0.8
ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﺩﺭ ﻣﺜﺎﻝ ﺑﺎلا ﻣلاﺣﻈﻪ ﻣیﻛﻨﻴﺪ ،ﺍﻭﻝ ﺍﻳﻦ ﻛﻪ ﺗﺎﺑع )( printﻣیﺗﻮﺍﻧﺪ ﺑﻴﺶ ﺍﺯ ﻳﮏ ﭘﺎﺭﺍﻣﺘﺮ ﺑﮕﻴﺮﺩ ﻛﻪ
ﺑﺎﻳﺪ ﺁﻧﻬﺎ ﺭﺍ ﺑﺎ ﻛﺎﻣﺎ ﺍﺯ ﻫﻢ ﺟﺪﺍ ﻧﻤﻮﺩ .ﺩﻳﮕﺮ ﺁﻥ ﻛﻪ ﻋلاﻭﻩ ﺑﺮ ﻣﺘﻐﻴﺮ ﻣیﺗﻮﺍﻧﺪ ﭘﺬﻳﺮﺍﯼ ﻋﺒﺎﺭﺕ ﻫﻢ ﺑﺎﺷﺪ .ﺍﻣﺎ ﺍﺳﺘﻔﺎﺩﻩ
ﺍﺯ ﻧﺴﺒﺖ ﺩﺍﺩﻥ ﺩﺭ ﺁﻥ ،ﺑﺎﻋﺚ ﺧﻄﺎ ﻣیﺷﻮﺩ.
۴-۱-۱ﻋﻤﻠﮕﺮﻫﺎ
ﺩﺭ ﺭﻳﺎﺿﻴﺎﺕ ﻭ ﻫﻤﭽﻨﻴﻦ ﺩﺭ ﺑﺮﻧﺎﻣﻪﻧﻮﻳﺴی ﻛﺎﻣﭙﻴﻮﺗﺮﯼ ،ﻋﻤﻠﮕﺮ ﻧﻮﻋی ﻛﺎﺭﺍﻛﺘﺮ ﺑﻪ ﺣﺴﺎﺏ ﻣیﺁﻳﺪ ﻛﻪ ﻧﺸﺎﻥ ﺩﻫﻨﺪﻩ
ﻳﮏ ﻋﻤﻞ ﺍﺳﺖ .ﻋﻤﻠﮕﺮ ۲ﻫﺎ ﺑﻪ ﺩﺳﺘﻪ ﺭﺍﻳج ﺗﻘﺴﻴﻢ ﻣیﺷﻮﺩ.
.۱ﺣﺴﺎﺑﯽ ﻳﺎ ﺭﻳﺎﺿی
.۲ﻧﺴﺒﯽ ﻳﺎ ﻣﻘﺎﻳﺴﻪﺍﯼ
.۳ﺑﻮﻟی
۱-۴-۱-۱ﻋﻤﻠﮕﺮﻫﺎﯼ ﺣﺴﺎﺑﯽ
ﺍﻳﻦ ﻋﻤﻠﮕﺮﻫﺎ )ﺟﻤﻊ ،ﺗﻔﺮﻳﻖ ،ﺿﺮﺏ ،ﺗﻘﻴﺴﻢ ﻭ ﺗﻮﺍﻥ( ﻣﺤﺎﺳﺒﺎﺕ ﻣﻌﻤﻮﻝ ﺭﻳﺎﺿی ﺭﺍ ﻧﺸﺎﻥ ﻣیﺩﻫﻨﺪ .ﻣﺜﻞ∗∗, /, ∗, −, + :
ﻛﻪ ﻗﺒل ًا ﺷﺮح ﺁﻧﻬﺎ ﺁﻣﺪ.
1. experssion
2. operator
۷ ﻓﺼﻞ .۱ﻛﻠﻴﺎﺕ ﺯﺑﺎﻥ
۲-۴-۱-۱ﻋﻤﻠﮕﺮﻫﺎﯼ ﻣﻘﺎﻳﺴﻪﺍﯼ
ﺷﺮح ﺍﻳﻦ ﻋﻤﻠﮕﺮﻫﺎ ﺩﺭ ﺟﺪﻭﻝ ﺯﻳﺮ ﻣﺸﺎﻫﺪﻩ ﻣیﺷﻮﺩ .ﻣﺜﺎﻝ:
ﺟﺪﻭﻝ :۱-۱ﻋﻤﻠﮕﺮﻫﺎﯼ ﻣﻘﺎﻳﺴﻪﺍﯼ
ﻋلاﻣﺖ ﺩﺭ ﭘﺎﻳﺘﻮﻥ ﻋلاﻣﺖ ﺩﺭ ﺭﻳﺎﺿﻴﺎﺕ
> >
≥ =>
< <
≤ =<
= ==
≠ =!
In [1]: x= -3
y=1
z=x>y
)print (x ==7
)print (y>x
)print (z
)print (y !=x
Out[1]: False
True
False
True
ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﻣلاﺣﻈﻪ ﻣیﺷﻮﺩ .ﭘﺎﺳﺦ ﻋﻤﻠﮕﺮﻫﺎﯼ ﻣﻘﺎﻳﺴﻪﺍﯼ ﻋﺪﺩ ﻧﻴﺴﺖ ،ﺑﻠﻜﻪ ﻣﻘﺎﺩﻳﺮ ﺑﻮﻟی ﻳﻌﻨی Trueﻭ ﻳﺎ
Falseﺍﺳﺖ.
۳-۴-۱-۱ﻋﻤﻠﮕﺮﻫﺎﯼ ﺑﻮﻟی
ﺍﻳﻦ ﻋﻤﻠﮕﺮﻫﺎ ﺩﺭ ﻣﻮﺭﺩ ﻣﻘﺎﺩﻳﺮ ﻳﺎ ﻣﺘﻐﻴﺮﻫﺎﯼ ﺑﻮﻟی ﺑﻪ ﻛﺎﺭ ﮔﺮﻓﺘﻪ ﻣیﺷﻮﺩ .ﻭ ﺁﻧﻬﺎ ﻋﺒﺎﺭﺗﻨﺪ ﺍﺯ and, or, not :ﻫﺴﺘﻨﺪ.
ﻣﺜﺎﻝ:
In [2]: )print (z or y!=x
)print (z and y!=x
)print ( not z and y!=x
Out[2]: True
False
True
ﻣﻘﺪﻣﻪ.۱-۱ ۸
. ﻋﻤﻠﮕﺮ ﺟﻤﻊ ﺩﻭ ﺭﺷﺘﻪ ﺭﺍ ﺑﻪ ﺍﺗﺼﺎﻝ ﻣیﺩﻫﺪ.ﺩﺭ ﻣﻮﺭﺩ ﺭﺷﺘﻪﻫﺎ ﺩﻭ ﻋﻤﻠﮕﺮ ﺟﻤﻊ ﻭ ﺿﺮﺏ ﺭﺍ ﻣیﺗﻮﺍﻥ ﺩﺭ ﻧﻈﺮ ﮔﺮﻗﺖ
.ﺩﺭ ﻣﻮﺭﺩ ﺿﺮﺏ ﺭﺷﺘﻪ ﺭﺍ ﺑﻪ ﺍﻧﺪﺍﺯﻩ ﻣﻀﺮﺏ ﺗﻜﺮﺍﺭ ﻣیﻛﻨﺪ
:۱ ﻣﺜﺎﻝ
In [1]: print ('Hello '+'World !')
print ('='*12)
Out[1]: Hello World !
============
:۲ ﻣﺜﺎﻝ
In [2]: a= 'TeX '
b= ' typesetting '
print (a+b)
c= '._'
print (c *10)
Out[2]: TeX typesetting
._._._._._._._._._._
. ﺭﺍ ﺑﻪ ﺭﺷﺘﻪ ﺗﺒﺪﻳﻞ ﻧﻤﻮﺩTrue, False ﻣیﺗﻮﺍﻥ ﺍﻋﺪﺍﺩ )ﺻﺤﻴح ﻭ ﺍﻋﺸﺎﺭﯼ( ﻭ ﻳﺎstr() ﺑﺎ ﺗﺎﺑع:۳ ﻣﺜﺎﻝ
In [3]: a= True
b= ' typesetting '
print ( str (a)+ ' '+b+ str (1234))
print ( str ( False )+ ' '+ str (3.14))
c= '._'
print (c *10)
Out[3]: True typesetting1234
False 3.14
._._._._._._._._._._
: ﻣﺜﺎﻝ. ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﻛﻪ ﻃﻮﻝ ﺭﺷﺘﻪ ﺭﺍ ﺑﺮﻣیﮔﺮﺩﺍﻧﺪlen() ﺩﺭ ﺭﺷﺘﻪﻫﺎ ﺗﺎﺑﻌی ﺑﻪ ﻧﺎﻡ
In [4]: print ( len (a))
print ( len (b))
print ( len (c))
print ( len ('test str '))
Out[4]: 4
11
2
8
۹ ﻓﺼﻞ .۱ﻛﻠﻴﺎﺕ ﺯﺑﺎﻥ
ﺗﺎﺑع )(input ۵-۱-۱
ﺗﺎﻛﻨﻮﻥ ﻣﻘﺎﺩﻳﺮ ﻣﺘﻐﻴﺮ ﻗﺒﻞ ﺍﺯ ﺍﺟﺮﺍﯼ ﺁﻥ ﺩﺭ ﺩﺍﺧﻞ ﺑﺮﻧﺎﻣﻪ ﺁﻣﺪﻩ ﺑﻮﺩ .ﻣﺜﻞ ﺑﺮﻧﺎﻣﻪ ﺯﻳﺮ:
In [1]: ' Name ='ava
' City ='yazd
) print ('Hello , My name is ',Name
) print ('I am from ',City
Out[1]: Hello , My name is ava
I am from yazd
ﻫﺮ ﮔﺎﻩ ﻛﻪ ﺑﺨﻮﺍﻫﻴﻢ ﻧﺎﻡ ﺷﺨﺺ ﻭ ﻳﺎ ﺍﺳﻢ ﺷﻬﺮ ﺭﺍ ﻋﻮﺽ ﻛﻨﻴﻢ ،ﺑﺎﻳﺪ ﺩﺍﺧﻞ ﺑﺮﻧﺎﻣﻪ ﺭﺍ ﻭﻳﺮﺍﻳﺶ ﻧﻤﻮﺩ ﻭ ﻣﺠﺪﺩ ًﺍ ﺑﺮﻧﺎﻣﻪ
ﺭﺍ ﺍﺟﺮﺍ ﻛﺮﺩ .ﺍﻛﻨﻮﻥ ﻫﻤﻴﻦ ﺑﺮﻧﺎﻣﻪ ﻣیﺗﻮﺍﻥ ﺑﺎ ﺗﺎﺑع )( inputﺑﺎﺯﻧﻮﻳﺴی ﻛﺮﺩ.
In [2]: )'print ('Enter your name :
)( Name = input
)'print ('Enter your city :
)( City = input
) print ('Hello , My name is ',Name
) print ('I am from ',City
Out[2]: Enter your name : ava
Enter your city : yazd
Hello , My name is ava
I am from yazd
ﺍﺟﺮﺍﯼ ﺑﺮﻧﺎﻣﻪ ﻫﻨﮕﺎﻣی ﻛﻪ ﺑﻪ ﺗﺎﺑع )( inputﻣیﺭﺳﺪ ﻣﻮﻗﺘ ًﺎ ﻣﻨﺘﻈﺮ ﻣیﻣﺎﻧﺪ ﺗﺎ ﺷﻤﺎ ﻣﻘﺪﺍﺭ ﻣﻮﺭﺩ ﻧﻈﺮ ﺭﺍ ﻭﺍﺭﺩ ﻧﻤﻮﺩﻩ ﻭ
ﻛﻠﻴﺪ Enterﺑﺰﻧﻴﺪ ﺗﺎ ﺍﺟﺮﺍﯼ ﺑﺮﻧﺎﻣﻪ ﺩﻧﺒﺎﻝ ﺷﻮﺩ .ﻭ ﻫﻤﻴﻦ ﺭﻭﺵ ﻳﺮﺍﯼ ﺩﻭﻣﻴﻦ ﺗﺎﺑع )( inputﻧﻴﺰ ﺗﻜﺮﺍﺭ ﻣیﺷﻮﺩ .ﺿﻤﻨ ًﺎ
ﺍﻳﻦ ﺑﺮﻧﺎﻣﻪ ﺑﺪﻭﻥ ﻓﺮﻣﺎﻥ printﻗﺒﻞ ﺍﺯ )( inputﻫﻢ ﺍﺟﺮﺍ ﻣیﺷﻮﺩ ﻭ ﻓﺮﻣﺎﻥﻫﺎﯼ ﭼﺎﭖ ﺻﺮﻓ ًﺎ ﺑﺮﺍﯼ ﺭﺍﻫﻨﻤﺎﻳﯽ ﺑﻴﺸﺘﺮ
ﻛﺎﺭﺑﺮ ﺑﻪ ﻛﺎﺭ ﻣیﺭﻭﺩ.
ﻣیﺗﻮﺍﻥ ﺩﺳﺘﻮﺭﺍﺕ ﭼﺎﭖ ﺭﺍ ﺑﻪ ﻃﻮﺭ ﺿﻤﻨی ﺩﺭ ﺩﺍﺧﻞ ﺗﺎﺑع )( inputﻧﻴﺰ ﮔﻨﺠﺎﻧﺪ ﻭ ﺑﺮﻧﺎﻣﮥ ﺑﺎلا ﺭﺍ ﺧلاﺻﻪﺗﺮ ﻧﻤﻮﺩ .ﺑﻪ
ﻛﺪ ﺯﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ.
In [3]: )'Name = input ('Enter your name :
)'City = input ('Enter your city :
) print ('Hello , My name is ',Name
) print ('I am from ',City
Out[3]: Enter your name : ava
Enter your city : yazd
Hello , My name is ava
I am from yazd
ﺗﻮﺟﻪ :ﻭﺭﻭﺩﯼ ﺗﺎﺑع )( inputﻫﺮ ﻧﻮع ﻛﻪ ﺑﺎﺷﺪ ﺧﺮﻭﺟی ﻳﻪ ﺻﻮﺭﺕ ﺭﺷﺘﻪ ﺧﻮﺍﻫﺪ ﺑﻮﺩ .ﺑﻪ ﻣﺜﺎﻝ ﺯﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ.
.۱-۱ﻣﻘﺪﻣﻪ ۱۰
In [1]: )'age = input ('enter your age :
)'tall = input ('enter your tall :
)) print ( type ( age
)) print ( type ( tall
Out[1]: enter your age : 30
enter your tall : 171.5
>' <class 'str
>' <class 'str
ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﻣﺸﺎﻫﺪﻩ ﻣیﻛﻨﻴﺪ ﻣﻘﺪﺍﺭ 30ﻋﺪﺩ ﺻﺤﻴح ﻭ ﻋﺪﺩ 171.5ﺍﻋﺸﺎﺭﯼ ﺍﺳﺖ .ﺩﺭ ﺻﻮﺭﺗی ﻛﻪ ﻣﺘﻐﻴﺮﻫﺎﯼ
ageﻭ tallﺍﺯ ﻧﻮع ﺭﺷﺘﻪ ﻫﺴﺘﻨﺪ .ﺑﻨﺎﺑﺮﺍﻳﻦ ﻧﻤیﺗﻮﺍﻥ ﺑﺎ ﺁﻧﻬﺎ ﻋﻤﻠﻴﺎﺕ ﺭﻳﺎﺿی ﺍﻧﺠﺎﻡ ﺩﺍﺩ.
ﺑﺮﺍﯼ ﺗﺒﺪﻳﻞ ﺭﺷﺘﮥ ﻋﺪﺩﯼ ﺑﻪ ﻋﺪﺩ ﺭﻳﺎﺿی ،ﺍﺯ ﺗﺎﺑع )( intﺑﺮﺍﯼ ﻋﺪﺩ ﺻﺤﻴح ﻭ ﺑﺮﺍﯼ ﻋﺪﺩ ﺍﻋﺸﺎﺭﯼ ﺍﺯ ﺗﺎﺑع )(float
ﺍﺳﺘﻔﺎﺩﻩ ﻣیﺷﻮﺩ .ﻣﺜﺎﻝ ﺑﺎلا ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺩﻭ ﺗﺎﺑع ﺍﺧﻴﺮ ﺗﻜﺮﺍﺭ ﻣیﺷﻮﺩ.
In [2]: )'age = input ('enter your age :
) age = int ( age
)'tall = input ('enter your tall :
) tall = float ( tall
)) print ( type ( age
)) print ( type ( tall
Out[2]: enter your age : 30
enter your tall : 171.5
>' <class 'int
>' <class 'float
ﺗﻮﺟﻪ :ﺍﮔﺮ ﺩﺭ ﺭﺷﺘﮥ ﻋﺪﺩﯼ ،ﻛﺎﺭﺍﻛﺘﺮﯼ ﻏﻴﺮ ﺍﺯ ﻋﺪﺩ ﺑﺎﺷﺪ .ﺗﺒﺪﻳلاﺕ ﺍﺧﻴﺮ ﻋﻤﻞ ﻧﻤیﻛﻨﻨﺪ.
۶-۱-۱ﻧﻮﺷﺘﻦ ﻳﺎﺩﺩﺍﺷﺖ ﺑﺮﺍﯼ ﺗﻮﺿﻴح
ﻣﻌﻤﻮل ًا ﺑﺮﺍﯼ ﺗﻮﺿﻴح ۱ﻗﺴﻤﺖﻫﺎﯼ ﻣﺨﺘﻠﻒ ﻳﮏ ُﻛﺪ ﺍﺯ ﻳﺎﺩﺩﺍﺷﺖﻫﺎﻳﯽ ﺍﺳﺘﻔﺎﺩﻩ ﻣیﺷﻮﺩ ،ﻛﻪ ﺑﻪ ﺯﺑﺎﻥ ﺍﻧﮕﻠﻴﺴی
ﺍﺳﺖ.
ﺑﺮﺍﯼ ﺍﻳﻦ ﻛﻪ ﭘﺎﻳﺘﻮﻥ ﻳﺎﺩﺩﺍﺷﺖﻫﺎ ﺭﺍ ﺗﺸﺨﻴﺺ ﺩﻫﺪ ،لاﺯﻡ ﺍﺳﺖ ﻛﻪ ﺩﺭ ﺍﺑﺘﺪﺍﯼ ﺁﻧﻬﺎ ﺍﺯ ﻋلاﻣﺖ ) (#ﺍﺳﺘﻔﺎﺩﻩ ﺷﻮﺩ .ﺑﻪ
ﺍﻳﻦ ﺗﺮﺗﻴﺐ ﭘﺎﻳﺘﻮﻥ ﺟﻤلاﺕ ﭘﺲ ﺍﺯ ﺍﻳﻦ ﻋلاﻣﺖ ﺭﺍ ﻧﺎﺩﻳﺪﻩ ﻣیﮔﻴﺮﺩ.
ﻣﺜﺎﻝ:
1. Comment
۱۱ ﻛﻠﻴﺎﺕ ﺯﺑﺎﻥ.۱ ﻓﺼﻞ
In [1]: # Prints 7.
print (3 + 4)
# Prints “Hello World”! in two lines.
print (" Hello ")
print (" World !")
# Prints multiple values with a single print function call.
print ("My favorite numbers are ", 3 + 4, " and ", 3 + 10)
14
# Prints three lines of text with a blank line.
print (" Goodbye ")
print ()
print (" Hope to see you again ")
Out[1]: 7
Hello
World !
My favorite numbers are 7 and 13
Goodbye
Hope to see you again
���
۲
ﻣﺤﻴﻂﻫﺎﯼ ﻛﻨﺘﺮﻟی
ﻣﻘﺪﻣﻪ ۱-۲
ﺩﺭ ﻳﮏ ﻣﺠﻤﻮﻋﻪ ُﻛﺪ ﺍﺯ ﭘﺎﻳﺘﻮﻥ ،ﻗﻮﺍﻋﺪ ﺍﺟﺮﺍﯼ ﺁﻥ ﺑﻪ ﺷﺮح ﺯﻳﺮ ﺍﺳﺖ.
.۱ﺩﺳﺘﻮﺭﺍﺕ ﺍﺯ ﺑﺎلا ﺑﻪ ﭘﺎﻳﻴﻦ ﺍﺟﺮﺍ ﻣیﺷﻮﺩ ،ﺗﺎ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﭘﺎﻳﺎﻥ ﺑﺮﺳﺪ.
.۲ﻫﺮ ﺩﺳﺘﻮﺭ ﻓﻘﻂ ﻳﻜﺒﺎﺭ ﺍﺟﺮﺍ ﻣیﺷﻮﺩ.
.۳ﺍﺟﺮﺍ ﺑﻪ ﺩﺳﺘﻮﺭﺍﺕ ﻗﺒﻞ ﺍﺯ ﺧﻮﺩ ﺑﺎﺯ ﻧﻤیﮔﺮﺩﺩ.
ﺩﺭ ﭘﺎﺭﻩﺍﯼ ﺍﻭﻗﺎﺕ لاﺯﻡ ﺍﺳﺖ ﻛﻪ ﺑﺮ ﺍﺳﺎﺱ ﺗﺼﻤﻴﻤی ﻳﮏ ﻭ ﻳﺎ ﭼﻨﺪ ﺩﺳﺘﻮﺭ ﺍﺟﺮﺍ ﻧﮕﺮﺩﺩ ﻭ ﺍﺯ ﺭﻭﯼ ﺁﻧﻬﺎ ﻋﺒﻮﺭ ﻛﻨﻴﻢ.
ﺩﺭ ﺑﺮﺧی ﺍﺯ ﺯﻣﺎﻥﻫﺎ لاﺯﻡ ﺍﺳﺖ ﻛﻪ ﻳﮏ ﻭ ﻳﺎ ﭼﻨﺪ ﺩﺳﺘﻮﺭ ﺑﻴﺶ ﺍﺯ ﻳﻜﺒﺎﺭ ﺍﺟﺮﺍ ﺷﻮﺩ .ﺑﻪ ﻋﺒﺎﺭﺕ ﺩﻳﮕﺮ لاﺯﻡ ﺍﺳﺖ ﻛﻪ
ﺑﻪ ﺩﺳﺘﻮﺭﺍﺕ ﻗﺒﻠی ﻣﺮﺍﺟﻌﻪ ﮔﺮﺩﺩ.
ﺑﻨﺎﺑﺮﺍﻳﻦ ﺳﺎﺯ ﻭ ﻛﺎﺭﻫﺎﻳﯽ لاﺯﻡ ﺍﺳﺖ ﻛﻪ ﭘﻴﺶﻓﺮﺽﻫﺎﯼ ﺑﺎلا ﺭﺍ ﺗﻐﻴﻴﺮ ﺩﻫﺪ .ﺩﺭ ﺯﺑﺎﻥﻫﺎﯼ ﺑﺮﻧﺎﻣﻪﻧﻮﻳﺴی ﺩﻭ ﻣﻜﺎﻧﻴﺰﻡ
ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﻛﻪ ﺧﻮﺍﺳﺘﻪ ﻣﺎ ﺭﺍ ﺗﺎﻣﻴﻦ ﻣیﻛﻨﻨﺪ.
ﺍﮔﺮ ﺑﺨﻮﺍﻫﻴﻢ ﺗﺤﺖ ﺷﺮﺍﻳﻄی ﻳﮏ ﻳﺎ ﭼﻨﺪ ﺳﻄﺮ ﺍﺟﺮﺍ ﻧﺸﻮﺩ ﺍﺯ ﻣﺤﻴﻂ ﺷﺮﻁ ﺍﺳﺘﻔﺎﺩﻩ ﻣیﺷﻮﺩ ﻭ ﺍﮔﺮ ﻗﺮﺍﺭ ﺑﺎﺷﺪ ﻛﻪ
ﻳﮏ ﻳﺎ ﭼﻨﺪ ﺳﻄﺮ ﺑﻴﺶ ﺍﺯ ﻳﮏ ﺑﺎﺭ ﺍﺟﺮﺍ ﺷﻮﺩ ﺍﺯ ﻣﺤﻴﻂ ﺣﻠﻘﻪ ﺍﺳﺘﻔﺎﺩﻩ ﻣیﻛﻨﻴﻢ.
۲-۲ﺷﺮﻁ
ﺑﻪ ﺭﻭﻧﺪﻧﻤﺎﯼ ﺯﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ ﮔﺮﺍﻣﺮ ﻭ ﻳﺎ syntaxﺷﺮﻁ ﺑﻪﺻﻮﺭﺕ ﺯﻳﺮ ﺍﺳﺖ .ﺑﻪﻋﻨﻮﺍﻥ ﻣﺜﺎﻝ:
۱۲
۱۳ ﻓﺼﻞ .۲ﻣﺤﻴﻂﻫﺎﯼ ﻛﻨﺘﺮﻟی
In [1]: # python program to illustrate If statement
i = 10
if (i >15):
)"print ("10 is less than 15
)"print ("I am Not in if
Out[1]: I am Not in if
ﺳﺎﺧﺘﺎﺭ ﺷﺮﻁ ﺑﻪ ﺷﺮح ﺯﻳﺮ ﺍﺳﺖ.
.۱ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻛﻠﻴﺪ ﻭﺍﮊﻩ if
.۲ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻳﮏ ﻋﺒﺎﺭﺕ booleanﻣﺜﻞ x > yﻛﻪ ﻧﺘﻴﺠﻪ ﺁﻥ ﺩﺭﺳﺖ ﻳﺎ ﻏﻠﻂ ﺍﺳﺖ ﻭ ﺑﺮ ﺍﺳﺎﺱ ﺁﻥ ﺗﺼﻤﻴﻢﮔﻴﺮﯼ
ﺻﻮﺭﺕ ﻣیﮔﻴﺮﺩ.
.۳ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻧﻤﺎﺩ » ۱ «:ﺿﺮﻭﺭﯼ ﺍﺳﺖ ﻭﮔﺮﻧﻪ ﺑﺮﻧﺎﻣﻪ ﺧﻄﺎ ﻣیﺩﻫﺪ.
.۴ﺑﺪﻧﻪ ﺷﺮﻁ :ﻳﻌﻨی ﺩﺳﺘﻮﺭﺍﺗی ﻛﻪ ﺩﺍﺧﻞ ﺷﺮﻁ ﻗﺮﺍﺭ ﻣیﮔﻴﺮﻧﺪ ﻭ ﻛﻨﺘﺮﻝ ﺭﻭﯼ ﺁﻧﻬﺎ ﺍﻋﻤﺎﻝ ﻣیﺷﻮﺩ .ﺩﺳﺘﻮﺭﺍﺗی
ﻛﻪ ﺩﺭ ﺑﺪﻧﻪ ﺷﺮﻁ ﻗﺮﺍﺭ ﺩﺍﺭﻧﺪ ،ﺩﺍﺭﺍﯼ ﺗﻮﺭﻓﺘﮕی ۲ﻫﺴﺘﻨﺪ.
ﺗﻮﺟﻪ :ﻋلاﻣﺖ ) (#ﺑﺮﺍﯼ ﺍﺭﺍﻳﻪ ﺗﻮﺿﻴﺤﺎﺕ ﺑﻪ ﻛﺎﺭ ﻣیﺭﻭﺩ ﻛﻪ ﺍﺟﺮﺍﯼ ﺑﺮﻧﺎﻣﻪ ﺁﻥ ﺭﺍ ﻧﺎﺩﻳﺪﻩ ﻣیﮔﻴﺮﺩ.
ﻣیﺗﻮﺍﻥ ﺷﺮﻁ ﺭﺍ ﺑﺴﻂ ﺑﻴﺸﺘﺮﯼ ﺩﺍﺩ .ﺑﺪﻳﻦ ﻣﻌﻨی ﻛﻪ ﺍﮔﺮ ﻋﺒﺎﺭﺕ ﺷﺮﻃی ﺩﺭﺳﺖ ﻧﺒﻮﺩ ،ﻛﻨﺘﺮﻝ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﻛﺠﺎ ﻣﻨﺘﻘﻞ
ﻣیﺷﻮﺩ؟ ﺑﺮﺍﯼ ﻣﺪﻳﺮﻳﺖ ﺍﻳﻦ ﻛﺎﺭ ﺍﺯ elseﺍﺳﺘﻔﺎﺩﻩ ﻣیﺷﻮﺩ .ﺭﻭﻧﺪﻧﻤﺎﯼ ﺁﻥ ﺩﺭ ﻧﻤﻮﺩﺍﺭ ۳-۲ﺁﻣﺪﻩ ﺍﺳﺖ.
ﻋﺒﺎﺭﺕ ﺧﻴﺮ
ﺷﺮﻁ
ﺑﻠﻪ
ﺑﺪﻧﻪ if ﺑﺪﻧﻪ else
ﺩﺳﺘﻮﺭ ﺧﺎﺭج ﺍﺯ if
ﺷﻜﻞ :۱-۲ﺭﻭﻧﺪﻧﻤﺎﯼ ﺑﻠﻮﮎ if-else
1. colon
2. indentation
.۲-۲ﺷﺮﻁ ۱۴
ﻣﺜﺎﻝ:
In [1]: number =9
if number %2==0:
)"print (" The number is even .
else :
)"print (" The number is odd .
Out[1]: The number is odd .
۱-۲-۲ﺷﺮﻁﻫﺎﯼ ﺗﻮ ﺩﺭ ﺗﻮ
ﻣیﺗﻮﺍﻥ ﺩﺭ ﺩﺍﺧﻞ ﺑﺪﻧﻪ ﻳﮏ ﺷﺮﻁ ﺩﺳﺘﻮﺭﺍﺕ ﻣﺨﺘﻠﻔی ﺭﺍ ﺩﺍﺷﺖ .ﺍﺯ ﺟﻤﻠﻪ ﻳﮏ ﺷﺮﻁ ﻣیﺗﻮﺍﻧﺪ ﺩﺭﻭﻥ ﺑﺪﻧﻪ ﻳﮏ
ﺷﺮﻁ ﺩﻳﮕﺮ ﻭﺍﻗﻊ ﺷﻮﺩ .ﺑﻪ ﺍﻳﻦ ﺷﺮﻁﻫﺎ ﺍﺻﻄلاﺣﺎ ﺷﺮﻁﻫﺎﯼ ﺗﻮ ﺩﺭ ﺗﻮ ۱ﮔﻮﻳﻨﺪ.
ﻋﺒﺎﺭﺕ ﺧﻴﺮ ﻋﺒﺎﺭﺕ ﺧﻴﺮ
ﺷﺮﻁ ﺷﺮﻁ
ﺑﻠﻪ ﺑﻠﻪ
ﺑﺪﻧﻪ if ﺑﺪﻧﻪ ifﺩﺍﺧﻠی ﺑﺪﻧﻪ elseﺩﺍﺧﻠی
ﺩﺳﺘﻮﺭ ﺧﺎﺭج ﺍﺯ if
ﺷﻜﻞ :۲-۲ﺭﻭﻧﺪﻧﻤﺎﯼ ﺷﺮﻁ ﺗﻮ ﺩﺭ ﺗﻮ if-else
ﻣﺜﺎﻝ:
In [2]: i, j, k = 7, 5, 3
if i > k:
if j > k:
)'print ('i and j are greater than k
else :
)'print ('i is less than or equal to k
Out[2]: i and j are greater than k
ﻣﺜﺎﻝ ﺩﻳﮕﺮ:
1. nested conditions
۱۵ ﻓﺼﻞ .۲ﻣﺤﻴﻂﻫﺎﯼ ﻛﻨﺘﺮﻟی
In [1]: # if .. else chain statement
"letter = "A
if letter == "B":
)"print (" letter is B
else :
if letter == "C":
)"print (" letter is C
else :
if letter == "A":
)"print (" letter is A
else :
)"print (" letter isn 't A, B and C
Out[1]: letter is A
ﺩﺳﺘﻮﺭ ﺷﺮﻁﻫﺎﯼ ﻣﻔﺼﻞ ۲-۲-۲
ﺩﺭ ﺷﺮﻁﻫﺎﻳﯽ ﻛﻪ ﺗﻌﺪﺍﺩ ﺗﺼﻤﻴﻢﻫﺎ ﻧﺴﺒﺘﺎ ﺯﻳﺎﺩ ﺍﺳﺖ ﻣیﺗﻮﺍﻥ ﺍﺯ ﺩﺳﺘﻮﺭ elifﺍﺳﺘﻔﺎﺩﻩ ﻧﻤﻮﺩ.
ﻋﺒﺎﺭﺕ ﺑﻠﻪ
ﺷﺮﻁ ﺑﻠﻮﮎ ۱
ﺧﻴﺮ
ﻋﺒﺎﺭﺕ ﺑﻠﻪ
ﺷﺮﻁ ﺑﻠﻮﮎ ۲
ﺧﻴﺮ
ﻋﺒﺎﺭﺕ ﺑﻠﻪ
ﺷﺮﻁ ﺑﻠﻮﮎ ۳
ﺧﻴﺮ ﺑﺪﻧﻪ else
ﺩﺳﺘﻮﺭ ﺧﺎﺭج ﺍﺯ if
ﺷﻜﻞ :۳-۲ﺭﻭﻧﺪﻧﻤﺎﯼ ﺷﺮﻁ elif
.۳-۲ﺣﻠﻘﻪ ۱۶
ﻣﺜﺎﻝ:
In [1]: a = 7
b = 9
c = 3
if ((a>b and a>c) and (a != b and a != c )):
)" print (a , " is the largest
elif ((b>a and b>c) and (b != a and b != c )):
)" print (b , " is the largest
elif ((c>a and c>b) and (c != a and c != b )):
)" print (c , " is the largest
else :
)" print (" entered numbers are equal
Out[1]: 9 is the largest
۳-۲ﺣﻠﻘﻪ
ﻓﺮﺽ ﻛﻨﻴﺪ ﻣیﺧﻮﺍﻫﻴﻢ ۲۰ﺑﺎﺭ ﺟﻤﻠﻪ programming is funﺭﺍ ﺑﻨﻮﻳﺴﻴﻢ .ﻳﮏ ﺭﺍﻩ ﺣﻞ ﺍﻳﻦ ﺍﺳﺖ ﻛﻪ ۲۰ﺑﺎﺭ
ﺩﺳﺘﻮﺭ ﭼﺎﭖ ﺁﻥ ﺭﺍ ﺑﻨﻮﻳﺴﻴﻢ ﻛﻪ ﺭﻭﺷی ﺧﺴﺘﻪ ﻛﻨﻨﺪﻩ ﻭ ﻏﻴﺮ ﺍﺻﻮﻟی ﺍﺳﺖ .ﺍﮔﺮ ﺗﻌﺪﺍﺩ ﺗﻜﺮﺍﺭ ﺯﻳﺎﺩ ﺑﺎﺷﺪ ﺍﻋﻤﺎﻝ ﺍﻳﻦ
ﺭﻭﺵ ﻋﻤلا ﻧﺎﻣﻤﻜﻦ ﺑﻪ ﻧﻈﺮ ﻣیﺭﺳﺪ .ﺭﺍﻩ ﺣﻞ ﺑﻌﺪﯼ ﺁﻥ ﺍﺳﺖ ﻛﻪ ﺍﺯ ﺣﻠﻘﻪ ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﻴﻢ .ﺑﻪ ﻓﻠﻮﭼﺎﺭﺕ ﺯﻳﺮ ﺗﻮﺟﻪ
ﻛﻨﻴﺪ.
ﻋﺒﺎﺭﺕ ﺧﻴﺮ
ﺷﺮﻁ
ﺑﻠﻪ
ﺑﺪﻧﻪ ﺣﻠﻘﻪ ﺩﺳﺘﻮﺭ ﺧﺎﺭج ﺍﺯ ﺣﻠﻘﻪ
ﺷﻜﻞ :۴-۲ﺭﻭﻧﺪﻧﻤﺎﯼ ﺣﻠﻘﻪ
ﺣﻠﻘﻪ ﺑﺎ ﺩﺳﺘﻮﺭ while ۱-۳-۲
ﺩﺭ ﺍﻳﻦ ﻧﻮع ﺣﻠﻘﻪ ،ﻋﻤﻠﻴﺎﺕ ﺁﻧﻘﺪﺭ ﺗﻜﺮﺍﺭ ﻣیﺷﻮﺩ ﺗﺎ ﺑﻪ ﻫﺪﻑ ﺗﻌﻴﻴﻦ ﺷﺪﻩ ﺑﺮﺳﻴﻢ.
۱۷ ﻓﺼﻞ .۲ﻣﺤﻴﻂﻫﺎﯼ ﻛﻨﺘﺮﻟی
In [1]: i=1
while i <=3:
)' print (' programming is fun
)' print ('End of loop
Out[1]: ' ' programming is fun
' ' programming is fun
' ' programming is fun
.
.
.
ﺳﺎﺧﺘﺎﺭ ﺣﻠﻘﻪ ﺑﺎلا ﺑﻪ ﺷﺮح ﺯﻳﺮ ﺍﺳﺖ.
.۱ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻛﻠﻴﺪ ﻭﺍﮊﻩ while
.۲ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻳﮏ ﻋﺒﺎﺭﺕ booleanﻣﺜﻞ i<=2ﻛﻪ ﻧﺘﻴﺠﻪ ﺁﻥ ﺩﺭﺳﺖ ﻳﺎ ﻏﻠﻂ ﺍﺳﺖ ﻭ ﺑﺮ ﺍﺳﺎﺱ ﺁﻥ ﺗﺼﻤﻴﻢﮔﻴﺮﯼ
ﺻﻮﺭﺕ ﻣیﮔﻴﺮﺩ.
.۳ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻧﻤﺎﺩ » «:ﺿﺮﻭﺭﯼ ﺍﺳﺖ ﻭﮔﺮﻧﻪ ﺑﺮﻧﺎﻣﻪ ﺧﻄﺎ ﻣیﺩﻫﺪ.
.۴ﺑﺪﻧﻪ ﺣﻠﻘﻪ :ﻳﻌﻨی ﺩﺳﺘﻮﺭﺍﺗی ﻛﻪ ﺩﺍﺧﻞ ﺣﻠﻘﻪ ﻗﺮﺍﺭ ﻣیﮔﻴﺮﻧﺪ ﻭ ﻛﻨﺘﺮﻝ ﺭﻭﯼ ﺁﻧﻬﺎ ﺍﻋﻤﺎﻝ ﻣیﺷﻮﺩ .ﺩﺳﺘﻮﺭﺍﺗی
ﻛﻪ ﺩﺭ ﺑﺪﻧﻪ ﺣﻠﻘﻪ ﻗﺮﺍﺭ ﺩﺍﺭﻧﺪ ،ﺩﺍﺭﺍﯼ ﺗﻮﺭﻓﺘﮕی ﻫﺴﺘﻨﺪ .ﺩﺭ ُﻛﺪ ﺑﺎلا ﺩﺳﺘﻮﺭ ﺳﻄﺮ ۳ﺩﺍﺭﺍﯼ ﺍﻳﻦ ﻭﻳﮋﮔی ﺍﺳﺖ.
ﻛﻨﺘﺮﻝ ﺑﺮﻧﺎﻣﻪ ﻫﻴچ ﮔﺎﻩ ﺍﺯ ﺩﺍﺧﻞ ﺣﻠﻘﻪ ﺧﺎﺭج ﻧﻤیﺷﻮﺩ ،ﻳﻌﻨی ﻣﺎ ﺧﺮﻭﺟی End of loopﺭﺍ ﻧﺨﻮﺍﻫﻴﻢ ﺩﺍﺷﺖ ،ﭼﺮﺍ
ﻛﻪ ﻣﻜﺎﻧﻴﺰﻣی ﺑﺮﺍﯼ ﺑﺮﻭﻥﺭﻓﺖ ﻭﺟﻮﺩ ﻧﺪﺍﺭﺩ .ﭼﻮﻥ ﻋﺒﺎﺭﺕ ﻣﻨﻄﻘی i<=2ﻫﻤﻴﺸﻪ ﺩﺭﺳﺖ ﺍﺳﺖ .ﺑﻨﺎﺑﺮﺍﻳﻦ ﺑﺎﻳﺪ ﺳﺎﺯ
ﻭ ﻛﺎﺭﯼ ﺑﺮﺍﯼ ﺑﺮﻭﻥﺭﻓﺖ ﺍﺯ ﺣﻠﻘﻪ ﺗﻌﺒﻴﻪ ﻧﻤﻮﺩُ .ﻛﺪ ﺍﺳلاﻳﺪ ﻗﺒﻞ ﺭﺍ ﺑﻪﺻﻮﺭﺕ ﺯﻳﺮ ﺗﻐﻴﻴﺮ ﻣیﺩﻫﻴﻢ.
In [2]: i=1
while i <=2:
)' print (' programming is fun
i=i+1
)' print ('End of loop
Out[2]: programming is fun
programming is fun
programming is fun
End of loop
ﺩﺭ ﺍﻳﻨﺠﺎ ﻫﺮ ﺑﺎﺭ ﻛﻪ ﺣﻠﻘﻪ ﺍﺟﺮﺍ ﻣیﺷﻮﺩ ،ﻳﮏ ﻭﺍﺣﺪ ﺑﻪ ﻣﻘﺪﺍﺭ iﺍﻓﺰﻭﺩﻩ ﻣیﺷﻮﺩ ،ﻟﺬﺍ ﭘﺲ ﺑﺎﺭ ﺩﻭﻡ ﮔﺮﺩﺵ ﺣﻠﻘﻪ،
ﻋﺒﺎﺭﺕ ﺑﻮﻟی i <= 2ﻏﻠﻂ ﻣیﺷﻮﺩ ﻭ ﺣﻠﻘﻪ ﺍﺯ ﮔﺮﺩﺵ ﺑﺎﺯ ﻣیﻣﺎﻧﺪ ﻭ ﻛﻨﺘﺮﻝ ﺑﺮﻧﺎﻣﻪ ﺑﻪ ﺳﺮ ﻭﻗﺖ ﺭﺷﺘﻪﯼ End of
loopﺭﻓﺘﻪ ﻭ ﺁﻥ ﺭﺍ ﭼﺎﭖ ﻣیﻛﻨﺪ .ﺑﻪ ﺍﻳﻦ ﺗﺮﺗﻴﺐ ﺑﻪ ﻓﺮﺟﺎﻡ ﻛﺎﺭ ﻣیﺭﺳﻴﻢ.
ﻣﺜﺎﻝ:
ﺣﻠﻘﻪ.۳-۲ ۱۸
In [1]: n = 5
while n > 0:
n=n -1
print (n)
Out[1]: 4
3
2
1
0
ﭼﻨﺪ ﺳﺎﻝ. ﺩﺭﺻﺪ ﺍﺳﺖ۲۰ ﻓﺮﺽ ﻛﻨﻴﺪ ﻛﻪ ﻳﮏ ﻣﻴﻠﻴﻮﻥ ﺗﻮﻣﺎﻥ ﺩﺭ ﺑﺎﻧﮏ ﻣی ﮔﺬﺍﺭﻳﺪ ﻭ ﻣﻘﺪﺍﺭ ﺑﻬﺮﻩ ﺳﺎلاﻧﻪ:ﻣﺜﺎﻝ
.ﻃﻮﻝ ﻣیﻛﺸﺪ ﻛﻪ ﻣﻘﺪﺍﺭ ﺳﺮﻣﺎﻳﻪ ﺷﻤﺎ ﺩﻭ ﺑﺮﺍﺑﺮ ﻣﻘﺪﺍﺭ ﺍﻭﻟﻴﻪ ﻣیﺷﻮﺩ
In [2]: # Create constant variables .
RATE = 0.20
INITIAL_BALANCE = 10000000
TARGET = 2 * INITIAL_BALANCE
# Initialize variables used with the loop.
balance = INITIAL_BALANCE
year = 0
# Count the years required for the investment to double .
while balance < TARGET :
year = year + 1
interest = balance * RATE
balance = balance + interest
# Print the results .
print (" The investment doubled after ", year , " years .")
Out[2]: The investment doubled after 4 years .
. ﺑﺮﻧﺎﻣﻪ ﺯﻳﺮ ﻋﺪﺩﯼ ﺭﺍ ﺩﺭﻳﺎﻓﺖ ﻧﻤﻮﺩﻩ ﻭ ﻣﺠﻤﻮع ﺍﺭﻗﺎﻡ ﺁﻥ ﺭﺍ ﺑﺪﺳﺖ ﺁﻭﺭﺩﻩ ﻭ ﭼﺎﭖ ﻣیﻛﻨﺪ:ﻣﺜﺎﻝ
In [3]: n = 1729
total = 0
while n > 0 :
digit = n % 10
total = total + digit
n = n // 10
print ( total )
Out[3]: 19
۱۹ ﻓﺼﻞ .۲ﻣﺤﻴﻂﻫﺎﯼ ﻛﻨﺘﺮﻟی
ﺩﻭ ﻛﻠﻴﺪ ﻭﺍﮊﻩ breakﻭ continue ۲-۳-۲
ﺍﻭﻟی ) (breakﻣیﺗﻮﺍﻧﺪ ﺗﺤﺖ ﺷﺮﺍﻳﻄی ﮔﺮﺩﺵ ﺣﻠﻘﻪ ﺭﺍ ﻗﺒﻞ ﺍﺯ ﺧﺎﺗﻤﻪ ﮔﺮﺩﺵﻫﺎﯼ ﺁﻥ ﻣﺘﻮﻗﻒ ﻧﻤﻮﺩﻩ ﻭ ﻛﻨﺘﺮﻝ ﺑﺮﻧﺎﻣﻪ
ﺭﺍ ﺍﺯ ﺣﻠﻘﻪ ﺧﺎﺭج ﻛﺮﺩﻩ ﻭ ﺑﻘﻴﻪ ﺑﺮﻧﺎﻣﻪ ﺭﺍ ﺍﺩﺍﻣﻪ ﺩﻫﺪ.
ﺩﻭﻣی ) (continueﻣیﺗﻮﺍﻧﺪ ﺗﺤﺖ ﺷﺮﺍﻳﻄی ﮔﺮﺩﺵ ﺣﻠﻘﻪ ﺭﺍ ﺩﺭ ﺑﻴﻦ ﺭﺍﻩ ﻣﺘﻮﻗﻒ ﻧﻤﻮﺩﻩ ﻭ ﻛﻨﺘﺮﻝ ﺭﺍ ﺑﻪ ﺍﺑﺘﺪﺍﯼ ﺣﻠﻘﻪ
ﻣﻨﺘﻘﻞ ﻛﻨﺪ.
ﻣﺜﺎﻝ:
In [1]: n = 5
while n > 0:
n -=1 # n=n-1
if n == 2:
break
)print (n
)'print ('Loop ended .
Out[1]: 4
3
Loop ended .
ﻣﺜﺎﻝ ﺩﻳﮕﺮ:
In [2]: n = 5
while n > 0:
n -= 1 # n=n-1
if n == 2:
continue
)print (n
)'print ('Loop ended .
Out[2]: 4
3
1
0
Loop ended .
ﻣﺜﺎﻝ ﺯﻳﺮ ﺍﻋﺪﺍﺩ ﻣﻀﺮﺏ ۳ﺭﺍ ﭼﺎﭖ ﻣیﻛﻨﺪ ﻭ ﻣﺠﻤﻮع ﺁﻧﻬﺎ ﺭﺍ ﻧﻴﺰ ﺑﺪﺳﺖ ﻣیﺩﻫﺪ.
ﺣﻠﻘﻪ.۳-۲ ۲۰
In [1]: total = 0
number = 0
while number <15:
number +=1 # number = number +1
if number %3!=0:
continue
print ( number )
total += number #total=total+ number
print (" The total is:",total )
Out[1]: 3
6
9
12
15
The total is: 45
ﻭﻗﺘی ﺍﻋﺪﺍﺩ ﻭﺭﻭﺩﯼ ﺧﺎﺗﻤﻪ ﻳﺎﻓﺖ ﻛﻠﻴﺪ. ﺑﺮﻧﺎﻣﻪﺍﯼ ﺑﻨﻮﻳﺴﻴﺪ ﻛﻪ ﻣﻴﺎﻧﮕﻴﻦ ﺗﻌﺪﺍﺩﯼ ﺍﻋﺪﺍﺩ ﺭﺍ ﻣﺤﺎﺳﺒﻪ ﻛﻨﺪ:ﻣﺜﺎﻝ
. ﺭﺍ ﻓﺸﺎﺭ ﺩﻫﻴﺪEnter
In [2]: # compute an average several numbers .
total = 0
count =0
inputStr = input (" Enter value : ")
while inputStr != '' :
value = float ( inputStr )
total = total + value
count = count + 1
inputStr = input (" Enter value : ")
if count > 0 :
average = total / count
else :
average = 0.0
print (' average is:', average )
Out[2]: Enter value : 1
Enter value : 2
Enter value : 3
Enter value :
average is: 2.0
ﺩﺭ ﺣﻠﻘﻪelse ﺑﻠﻮﮎ۳-۳-۲
: ﻣﺜﺎﻝ. ﺍﺟﺮﺍ ﻣیﺷﻮﺩelse ﺁﻧﮕﺎﻩ ﺑﻠﻮﮎ،ﻫﻨﮕﺎﻣی ﻛﻪ ﺷﺮﻁ ﺣﻠﻘﻪ ﺩﺭﺳﺖ ﻧﺒﺎﺷﺪ
۲۱ ﻓﺼﻞ .۲ﻣﺤﻴﻂﻫﺎﯼ ﻛﻨﺘﺮﻟی
In [1]: i=0
while i <5:
i +=1
)print ("i =",i
else :
)" print (" else block is executed
Out[1]: i = 1
i = 2
i = 3
i = 4
i = 5
else block is executed
۴-۳-۲ﻣﻔﻬﻮﻡ flagﺩﺭ ﺣﻠﻘﻪ while
ﺩﺭ ﺑﺮﻧﺎﻣﻪﻫﺎﻳﯽ ﻛﻪ ﺩﺭ ﺑﺴﻴﺎﺭﯼ ﺍﺯ ﺷﺮﺍﻳﻂ ﺩﺭﺳﺖ ﻫﺴﺘﻨﺪ ،ﺷﻤﺎ ﻣیﺗﻮﺍﻧﻴﺪ ﻳﮏ ﻣﺘﻐﻴﺮ ﻓﻌﺎﻝ ﻭ ﻳﺎ ﻏﻴﺮ ﻓﻌﺎﻝ ﺑﺮﺍﯼ ﻛﻨﺘﺮﻝ
ﺣﻠﻘﻪ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﺪ ،ﻛﻪ ﺍﺻﻄلاﺣ ًﺎ ﺑﻪ ﺁﻥ flagﮔﻮﻳﻨﺪ .ﺩﺭ ﺻﻮﺭﺗی ﻛﻪ ﺷﺮﺍﻳﻂ ﺑﺮﻗﺮﺍﺭ ﺑﺎﺷﺪ flag ،ﻓﺮﻣﺎﻥ ﺍﺟﺮﺍ ﺭﺍ
ﺻﺎﺩﺭ ﻣیﻛﻨﺪ ﻭ ﺩﺭ ﺣﺎﻟﺘی ﻛﻪ ﺷﺮﺍﻳﻂ ﺑﺮﻗﺮﺍﺭ ﻧﻴﺴﺖ ،ﺍﺟﺮﺍﯼ ﺑﺮﻧﺎﻣﻪ ﻣﺘﻮﻗﻒ ﺭﺍ ﻣیﺳﺎﺯﺩ.
In [2]: active = True
active = True
while active :
)'message = input ('Tell me yout message :
if message == 'quit ':
active = False
else :
) print ( message
Out[2]: Tell me yout message : hi
hi
Tell me yout message : hello
hello
Tell me yout message : hey
hey
Tell me yout message : quit
ﺣﻠﻘﻪ ﺑﺎ ﺩﺳﺘﻮﺭ for ۵-۳-۲
ﺩﺭ ﺣﺎﻟﺘی ﻛﻪ ﺍﺯ ﻗﺒﻞ ﻣیﺩﺍﻧﻴﻢ ﭼﻨﺪ ﺑﺎﺭ ﺍﺟﺮﺍﯼ ﺣﻠﻘﻪ ﻣﻮﺭﺩ ﻧﻴﺎﺯ ﺍﺳﺖ ،ﻣیﺗﻮﺍﻥ ﺍﺯ ﺣﻠﻘﻪ ﺑﺎ ﺩﺳﺘﻮﺭ forﺍﺳﺘﻔﺎﺩﻩ ﻧﻤﻮﺩ.
ﺍﻟﺒﺘﻪ ﭘﺎﺭﻩﺍﯼ ﺍﺯ ﻣﺴﺎﻳﻞ ﺭﺍ ﻣیﺗﻮﺍﻥ ﺑﻪ ﻫﺮ ﺩﻭ ﺻﻮﺭﺕ whileﻭ ُ forﻛﺪﻧﻮﻳﺴی ﻧﻤﻮﺩ.
for i t e r a t o r _ v a r in sequence :
) statements ( s
ﺳﺎﺧﺘﺎﺭ ﺣﻠﻘﻪ ﺑﺎلا ﺑﻪ ﺷﺮح ﺯﻳﺮ ﺍﺳﺖ.
.۳-۲ﺣﻠﻘﻪ ۲۲
.۱ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻛﻠﻴﺪ ﻭﺍﮊﻩﻫﺎﯼ forﻭ in
.۲ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻳﮏ ﻣﺘﻐﻴﺮ ﭘﻴﻤﺎﻳﺶ iterator_vari
.۳ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻳﮏ ﺩﻧﺒﺎﻟﻪ ) (sequenceﻛﻪ ﺗﻮﺳﻂ ﻣﺘﻐﻴﺮ ﭘﻴﻤﺎﻳﺶ ﭘﻴﻤﻮﺩﻩ ﻣیﺷﻮﺩ.
.۴ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻧﻤﺎﺩ » «:ﺿﺮﻭﺭﯼ ﺍﺳﺖ ﻭﮔﺮﻧﻪ ﺑﺮﻧﺎﻣﻪ ﺧﻄﺎ ﻣیﺩﻫﺪ.
.۵ﺑﺪﻧﻪ ﺣﻠﻘﻪ :ﻳﻌﻨی ﺩﺳﺘﻮﺭﺍﺗی )) (statements(sﻛﻪ ﺩﺍﺧﻞ ﺣﻠﻘﻪ ﻗﺮﺍﺭ ﻣیﮔﻴﺮﻧﺪ ﻭ ﻛﻨﺘﺮﻝ ﺭﻭﯼ ﺁﻧﻬﺎ ﺍﻋﻤﺎﻝ
ﻣیﺷﻮﺩ .ﺩﺳﺘﻮﺭﺍﺗی ﻛﻪ ﺩﺭ ﺑﺪﻧﻪ ﺣﻠﻘﻪ ﻗﺮﺍﺭ ﺩﺍﺭﻧﺪ ،ﺩﺍﺭﺍﯼ ﺗﻮﺭﻓﺘﮕی ﻫﺴﺘﻨﺪ.
ﻣﺜﺎﻝ:
In [1]: '! language = 'Hello
# iterate over each character in language
for x in language :
)'*'print (x+
Out[1]: *H
*e
*l
*l
*o
*!
ﺩﺭ ﻣﺜﺎﻝ ﺑﺎلا ﻣﺘﻐﻴﺮ languageﺩﻧﺒﺎﻟﻪﺍﯼ ﺍﺯ ﻛﺎﺭﺍﻛﺘﺮﻫﺎ ﺍﺳﺖ ﻭ ﻣﺘﻐﻴﺮ xﺩﻧﺒﺎﻟﻪ ﺭﺍ ﻣیﭘﻴﻤﺎﻳﺪ ﻭ ﺩﺭ ﻫﺮ ﺑﺎﺭ ﭘﻴﻤﺎﻳﺶ
ﻳﮏ ﻛﺎﺭﺍﻛﺘﺮ ﺭﺍ ﺑﻪ ﺧﻮﺩ ﻧﺴﺒﺖ ﻣیﺩﻫﺪ ﻭ ﺑﺎ ﺩﺳﺘﻮﺭ ﺩﺍﺧﻞ ﺑﺪﻧﻪ ﺣﻠﻘﻪ ،ﻋﻤﻞ ﭼﺎﭖ ﺍﻧﺠﺎﻡ ﻣیﺷﻮﺩ.
ﻣﻘﺪﺍﺭ xﭼﺎﭖ ﺁﺧﺮﻳﻦ ﻣﻘﺪﺍﺭ ﺩﻧﺒﺎﻟﻪ ﺭخ ﺩﺍﺩﻩ؟ ﭘﻴﻤﺎﻳﺶ
ﺧﻴﺮ ∗H H ﺍﻭﻟﻴﻦ
ﺧﻴﺮ ∗e e ﺩﻭﻣﻴﻦ
ﺧﻴﺮ ∗l l ﺳﻮﻣﻴﻦ
ﺧﻴﺮ ∗l l ﭼﻬﺎﺭﻣﻴﻦ
ﺧﻴﺮ ∗o o ﭘﻨﺠﻤﻴﻦ
ﺑﻠﻪ ∗! ! ﺷﺸﻤﻴﻦ
ﺩﺭ ﭘﺎﻳﺘﻮﻥ ﺗﺎﺑﻌی ﺑﻪ ﻧﺎﻡ )( rangeﻭﺟﻮﺩ ﺩﺍﺭﺩ ﻛﻪ ﻳﮏ ﺩﻧﺒﺎﻟﻪ ﻋﺪﺩﯼ ﺗﻮﻟﻴﺪ ﻣیﻛﻨﺪ.
۱-۵-۳-۲ﺗﺎﺑع )(range
ﺗﺎﺑع ) ،range(nﺩﻧﺒﺎﻟﻪﺍﯼ ﺍﺯ ﺍﻋﺪﺍﺩ ﺻﺤﻴح ﺍﺯ ﺻﻔﺮ ﺗﺎ n-1ﺗﻮﻟﻴﺪ ﻣیﻛﻨﺪ .ﮔﺎﻡﻫﺎﯼ ﺑﻴﻦ ﻣﻘﺎﺩﻳﺮ ﺷﺮﻭع ﻭ ﺧﺎﺗﻤﻪ
ﻭﺍﺣﺪ ﺍﺳﺖ .ﻳﻌﻨی 0,1,2,3,...,n-1
ﺩﺳﺘﻮﺭ ﻛﻠی ﺁﻥ ﺑﻪﺻﻮﺭﺕ ﺯﻳﺮ ﺍﺳﺖ.
۲۳ ﻓﺼﻞ .۲ﻣﺤﻴﻂﻫﺎﯼ ﻛﻨﺘﺮﻟی
)range(FirstValue, EndValue, Step
ﻣﺜﺎﻝ:
range(5) ⇒ 0,1,2,3,4
range(1, 5) ⇒ 1,2,3,4
range(1, 5, 2) ⇒ 1,3
range(5, 1) ⇒ no output
range(5, 1, -1) ⇒ 5,4,3,2
range(k, k) ⇒ k
ﻣلاﺣﻈﺎﺕ:
.۱ﭘﻴﺶﻓﺮﺽ FirstValue = 0ﺍﺳﺖ ،ﻛﻪ ﻣیﺗﻮﺍﻥ ﺁﻥ ﺭﺍ ﺗﻐﻴﻴﺮ ﺩﺍﺩ.
.۲ﻣﻘﺪﺍﺭ ﻧﻬﺎﻳﯽ ﻫﻤﻴﺸﻪ EndValue - 1ﺍﺳﺖ.
.۳ﭘﻴﺶﻓﺮﺽ step = 1ﺍﺳﺖ ،ﻛﻪ ﻣیﺗﻮﺍﻥ ﺁﻥ ﺭﺍ ﺗﻐﻴﻴﺮ ﺩﺍﺩ.
.۴ﻫﻤﻴﺸﻪ FirstValue ≤ EndValueﺍﺳﺖ ،ﻣﮕﺮ ﺍﻳﻦ ﻛﻪ ﻣﻘﺪﺍﺭ ﮔﺎﻡ ﻣﻨﻔی ﺑﺎﺷﺪ.
.۵ﻣﻘﺎﺩﻳﺮ FirstValue, EndValue, Stepﻫﻤﻴﺸﻪ ﺍﻋﺪﺍﺩ ﺻﺤﻴح ﻫﺴﺘﻨﺪ ،.ﭼﺮﺍ ﻛﻪ ﺗﻌﺪﺍﺩ ﺩﻓﻌﺎﺕ ﺗﻜﺮﺍﺭ
ﻧﻤیﺗﻮﺍﻧﺪ ﻏﻴﺮ ﺻﺤﻴح ﺑﺎﺷﺪ.
ﻣﺜﺎﻝ:
In [1]: # iterate from k= 0 to k=4
for k in range (5):
)print (k*k
Out[1]: 0
1
4
9
16
ﺷﺮخ ﻋﻤﻠﻴﺎﺕ ﻛﺪ ﺑﺎلا ﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﺍﺳﺖ.
ﻣﻘﺪﺍﺭ kﭼﺎﭖ ﺁﺧﺮﻳﻦ ﻣﻘﺪﺍﺭ ﺩﻧﺒﺎﻟﻪ ﺭخ ﺩﺍﺩﻩ؟ ﭘﻴﻤﺎﻳﺶ
ﺧﻴﺮ ۰ ۰ ﺍﻭﻟﻴﻦ
ﺧﻴﺮ ۱ ۱ ﺩﻭﻣﻴﻦ
ﺧﻴﺮ ۴ ۲ ﺳﻮﻣﻴﻦ
ﺧﻴﺮ ۹ ۳ ﭼﻬﺎﺭﻣﻴﻦ
ﺑﻠﻪ ۱۶ ۴ ﭘﻨﺠﻤﻴﻦ
ﺣﻠﻘﻪ.۳-۲ ۲۴
. ﻣﻘﺪﺍﺭ ﻓﺎﻛﺘﻮﺭﻳﻞ ﻳﮏ ﻋﺪﺩ ﺻﺤﻴح ﻣﺤﺎﺳﺒﻪ ﻣیﮔﺮﺩﺩfor ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺣﻠﻘﻪ:ﻣﺜﺎﻝ
In [1]: n= int ( input ('Enter number :'))
factorial =1
if n ==0 or n ==1:
print (' factorial =', factorial )
else :
for i in range (2 ,n +1):
factorial *=i
print (' factorial =', factorial )
Out[1]: Enter number : 4
factorial = 24
:ﻣلاﺣﻈﺎﺕ
ﭼﺮﺍ ﻛﻪ ﻓﺎﻛﺘﻮﺭﻳﻞ ﺍﻋﺪﺍﺩ ﺻﻔﺮ ﻭ ﻳﮏ ﺑﻪ ﻣﺤﺎﺳﺒﻪ ﻧﻴﺎﺯ ﻧﺪﺍﺭﺩ ﻭ ﻣﻘﺎﺩﺭ ﺁﻥ ﻳﮏ، ﺍﺳﺖ۲ ﺍﺯrange ﺷﺮﻭع ﺗﺎﺑع.۱
.ﺍﺳﺖ
. ﺧﺘﻢ ﺷﻮﺩn ﺧﻨﺜی ﺷﻮﺩ ﻭ ﺍﻧﺘﻬﺎﯼ ﺣﻠﻘﻪ ﺑﻪn-1 ﻳﻜی ﺍﺿﺎﻓﻪ ﻣیﮔﺮﺩﺩ ﺗﺎ ﺍﺛﺮrange ﺩﺭ ﺗﺎﺑعn ﺑﻪ ﻣﺘﻐﻴﺮ.۲
ﺣﻠﻘﻪﻫﺎﯼ ﺗﻮ ﺩﺭ ﺗﻮ۶-۳-۲
. ﻳﻌﻨی ﻳﮏ ﺣﻠﻘﻪ ﺩﺭ ﺣﻠﻘﻪﺍﯼ ﺩﻳﮕﺮ.ﺑﻌﻀی ﺍﺯ ﺗﻜﺮﺍﺭﻫﺎﯼ ﭘﻴﭽﻴﺪﻩ ﻧﻴﺎﺯ ﺑﻪ ﺣﻠﻘﻪﻫﺎﯼ ﺗﻮ ﺩﺭ ﺗﻮ ﺩﺍﺭﻧﺪ
In [2]: # Initialize constant variables for the max ranges .
NMAX = 4
XMAX = 10
# Print table header .
for n in range (1 , NMAX + 1) :
print (" %10 s" % "x^", n, end ="")
print ("\n", " ", "-" * 45)
# Print table body.
for x in range (1 , XMAX + 1) :
# Print the x row in the table.
for n in range (1 , NMAX + 1) :
print (" %10.0 f" % x ** n, end ="")
print ()
۲۵ ﻓﺼﻞ .۲ﻣﺤﻴﻂﻫﺎﯼ ﻛﻨﺘﺮﻟی
Out[2]: x^ 1 x^ 2 x^ 3 x^ 4
-----------------------------------------
1 1 1 1
2 4 8 16
3 9 27 81
4 16 64 256
5 25 125 625
6 36 216 1296
7 49 343 2401
8 64 512 4096
9 81 729 6561
10 100 1000 10000
۱-۶-۳-۲ﻓﺮﻣﺖﻫﺎ
ﺑﻪ ﻃﻮﺭ ﻋﺎﺩﯼ ﻣﺎ ﻛﻨﺘﺮﻟی ﺭﻭﯼ ﻧﺤﻮﻩ ﺧﺮﻭﺟی ﺑﺮﻧﺎﻣﻪ ﻧﺪﺍﺭﻳﻢ ﻳﺎ ﺍﮔﺮ ﻫﺴﺖ ﺍﻧﺪﮎ ﺍﺳﺖ .ﻣﺜل ًا ﻛﻨﺘﺮﻝ ﺭﻭﯼ ﺗﻌﺪﺍﺩ
ﺍﻋﺸﺎﺭ ﻳﮏ ﻋﺪﺩ ﺍﻋﺸﺎﺭﯼ ،ﻳﺎ ﻛﻨﺘﺮﻝ ﺟﺎﯼ ﺧﺎﻟی ﻗﺒﻞ ﻳﺎ ﺑﻌﺪ ﺍﺯ ﺍﻋﺪﺍﺩ ﻭ ﺭﺷﺘﻪﻫﺎ ،ﻳﺎ ﻧﻮع ﭼﻴﺪﻣﺎﻥ )ﺭﺍﺳﺖﭼﻴﻦ،
ﻭﺳﻂﭼﻴﻦ ﻭ ﭼﭗﭼﻴﻦ( ﺁﻧﻬﺎ ﺩﺭ ﺍﺧﺘﻴﺎﺭ ﻣﺎ ﻧﻴﺴﺖ .ﺩﺭ ﺍﻳﻨﺠﺎ ﻣیﺧﻮﺍﻫﻴﻢ ﺑﺎ ﺍﺑﺰﺍﺭﯼﻫﺎﻳﯽ ﺁﺷﻨﺎ ﺷﻮﻳﻢ ﻛﻪ ﺍﻣﻜﺎﻧﺎﺕ
ﺑﻴﺸﺘﺮﯼ ﺑﺮﺍﯼ ﻛﻨﺘﺮﻝ ﺁﻧﻬﺎ ﺩﺭ ﺍﺧﺘﻴﺎﺭ ﻣﺎ ﺑﮕﺬﺍﺭﺩ ،ﻛﻪ ﺑﻪ ﺁﻧﻬﺎ ﺍﺻﻄلاﺣ ًﺎ ﻓﺮﻣﺖ ﮔﻮﻳﻨﺪ .ﺍﻧﻮﺍﻉ ﺁﻧﻬﺎ ﺭﺍ ﺩﺭ ﻣﺜﺎﻝﻫﺎﯼ ﺯﻳﺮ
ﻣلاﺣﻈﻪ ﻣیﻛﻨﻴﺪ.
ﻣﺜﺎﻝ :۱ﺧﺮﻭﺟی ﺩﺭ ﺣﺎﻟﺖ ﻋﺎﺩﯼ ﺍﺳﺖ ،ﺯﻳﺮﺍ ﺩﺭ ﺁﻛﻮلاﺩ ﭼﺎﭖ ،ﭼﻴﺰﯼ ﺩﺭج ﻧﺸﺪﻩ ﺍﺳﺖ.
In [1]: for i in range (15):
) )print ("{}". format (i
Out[1]: 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
ﻣﺜﺎﻝ :۲
In [2]: for i in range (15):
))print (" {:2} ". format (i
.۳-۲ﺣﻠﻘﻪ ۲۶
Out[2]: 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
ﻳﻌﻨی ﺑﺮﺍﯼ ﺍﻋﺪﺍﺩ ﺧﺮﻭﺟی ﻓﺮﻣﺖ } {:2ﻣﺸﺨﺺ ﺷﺪﻩ ﺍﺳﺖ .ﭘﺲ ﺩﻭ ﻣﺤﻞ ﺑﺮﺍﯼ ﺁﻧﻬﺎ ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣیﺷﻮﺩ ﻭ
ﺍﻋﺪﺍﺩ ﻫﻢ ﺭﺍﺳﺖﭼﻴﻦ ﻣیﺷﻮﻧﺪ .ﺑﻪ ﺍﻳﻦ ﺗﺮﺗﻴﺐ ﺭﻗﻢ ﻳﻜﺎﻥ ﺍﻋﺪﺍﺩ ﺩﺭ ﻳﮏ ﺳﺘﻮﻥ ﻗﺮﺍﺭ ﻣیﮔﻴﺮﻧﺪ.
In [1]: x,y,z =1234 ,1367 ,3345
) )print (" {:4 ,} ". format (x
) )print (" {:4 ,} ". format (y
) )print (" {:4 ,} ". format (z
Out[1]: 1 ,234
1 ,367
3 ,345
ﻣﺜﺎﻝ :۳ﻣﺜﺎﻝ ۲ﺭﺍ ﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﻣیﺗﻮﺍﻥ ﻧﻮﺷﺖ:
In [2]: x,y,z =1234 ,1367 ,3345
) )print (" {:4 ,}\ n {:4 ,}\ n {:4 ,} ". format (x,y,z
Out[2]: 1 ,234
1 ,367
3 ,345
ﻣﺜﺎﻝ :۴ﺣﻠﻘﻪﻫﺎﯼ ﺗﻮ ﺩﺭ ﺗﻮ ﺑﺎ ﺧﺮﻭﺟی ﻓﺮﻣﺖﺩﺍﺭ
In [3]: for hours in range (1 ,2):
for minutes in range (0 ,11):
)) print (" Time {:02}:{:02} ". format ( hours , minutes
۲۷ ﻣﺤﻴﻂﻫﺎﯼ ﻛﻨﺘﺮﻟی.۲ ﻓﺼﻞ
Out[3]: Time 01:00
Time 01:01
Time 01:02
Time 01:03
Time 01:04
Time 01:05
Time 01:06
Time 01:07
Time 01:08
Time 01:09
Time 01:10
ﻓﺮﻣﺖ ﺍﻋﺪﺍﺩ ﺍﻋﺸﺎﺭﯼ:۵ ﻣﺜﺎﻝ
In [1]: x = 0.1
y = 123.456789
print (" {:.1 f} {:.1 f}". format (x,y) )
print (" {:.2 f} {:.2 f}". format (x,y) )
print (" {:.3 f} {:.3 f}". format (x,y) )
print (" {:.4 f} {:.4 f}". format (x,y) )
print (" {:.5 f} {:.5 f}". format (x,y) )
print (" {:.6 f} {:.6 f}". format (x,y) )
Out[1]: 0.1 123.5
0.10 123.46
0.100 123.457
0.1000 123.4568
0.10000 123.45679
0.100000 123.456789
:۶ ﻣﺜﺎﻝ
In [2]: x = 0.1
y = 123.456789
print (" |{:10.1 f}| |{:10.1 f}|". format (x,y) )
print (" |{:10.2 f}| |{:10.2 f}|". format (x,y) )
print (" |{:10.3 f}| |{:10.3 f}|". format (x,y) )
print (" |{:10.4 f}| |{:10.4 f}|". format (x,y) )
print (" |{:10.5 f}| |{:10.5 f}|". format (x,y) )
print (" |{:10.6 f}| |{:10.6 f}|". format (x,y) )
Out[2]: | 0.1| | 123.5|
| 0.10| | 123.46|
| 0.100| | 123.457|
| 0.1000| | 123.4568|
| 0.10000| | 123.45679|
| 0.100000| |123.456789|
.۳-۲ﺣﻠﻘﻪ ۲۸
ﻣﺜﺎﻝ :۷
In [1]: cost = 3.07
tax = cost * 0.06
total = cost + tax
)) print (" Cost : $ {:5.2 f}". format ( cost
print (" Tax : )) {:5.2 f}". format ( tax
)"print (" ------------
)) print (" Total : $ {:5.2 f}". format ( total
Out[1]: Cost : $ 3.07
Tax : 0.18
------------
Total : $ 3.25
۲-۶-۳-۲ﻭﺍﺭﺩ ﻛﺮﺩﻥ ﻣﺎﮊﻭﻝ ﺩﺭ ﭘﺎﻳﺘﻮﻥ
ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﻗﺒل ًا ﺩﻳﺪﻳﻢ ﻳﮏ ﺗﻌﺪﺍﺩ ﺗﻮﺍﺑع ﭘﻴﺶﺳﺎﺧﺘﻪ ﺩﺭ ﭘﺎﻳﺘﻮﻥ ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﻛﻪ ﺍﺯ ﺁﻧﻬﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺷﺪ .ﻣﺜﻞ،print() :
)( inputﻭ )( .lenﭘﺎﻳﺘﻮﻥ ﺑﻪ ﺗﻌﺪﺍﺩﯼ ﻛﺘﺎﺑﺨﺎﻧﻪ ﺍﺳﺘﺎﻧﺪﺍﺭﺩ ﻣﺘﺼﺪﻝ ﻣیﺷﻮﺩ ﻛﻪ ﻣﺎﮊﻭﻝ ۱ﻧﺎﻣﻴﺪﻩ ﻣیﺷﻮﺩ.
ﻫﺮ ﻣﺎﮊﻭﻝ ﻳﮏ ﮔﺮﻭﻩ ﺍﺯ ﺗﻮﺍﺑع ﺭﺍ ﺩﺭ ﺑﺮﻣی ﮔﻴﺮﺩ ﻛﻪ ﻣیﺗﻮﺍﻥ ﺍﺯ ﺁﻧﻬﺎ ﺩﺭ ﺑﺮﻧﺎﻣﻪﻫﺎ ﺍﺳﺘﻔﺎﺩﻩ ﻧﻤﻮﺩ .ﺑﺮﺍﯼ ﻣﺜﺎﻝ ﻣﺎﮊﻭﻝ
mathﻛﻪ ﺷﺎﻣﻞ ﺗﻮﺍﺑع ﺭﻳﺎﺿی ﺍﺳﺖ .ﻣﺎﮊﻭﻝ ﺩﻳﮕﺮﯼ ﺗﺤﺖ ﻋﻨﻮﺍﻥ randomﻭﺟﻮﺩ ﺩﺍﺭﺩ ﻛﻪ ﺷﺎﻣﻞ ﺗﻮﺍﺑع ﻣﺮﺗﺒﻂ ﺑﻪ
ﺍﻋﺪﺍﺩ ﺗﺼﺎﺩﻓی ﺍﺳﺖ.
ﻗﺒﻞ ﺍﺯ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺗﻮﺍﺑع ﺩﺭﻭﻥ ﻣﺎﮊﻭﻝ ﺑﺎﻳﺪ ﺍﺗﺼﺎﻝ ﺁﻥ ﺭﺍ ﺑﺎ ﺑﺮﻧﺎﻣﻪﻫﺎ ﺑﺮﻗﺮﺍﺭ ﻧﻤﻮﺩ .ﺑﺮﺍﯼ ﺍﻳﻦ ﻛﺎﺭ ﺍﺯ ﻓﺮﻣﺎﻥ import
ﺍﺳﺘﻔﺎﺩﻩ ﻣیﺷﻮﺩ .ﻣﺜل ًا ﺩﺭ ﻣﻮﺭﺩ ﻣﺎﮊﻭﻝ randomﻣیﻧﻮﻳﺴﻴﻢ import randomﻛﻪ ﺍﺯ ﻃﺮﻳﻖ ﺁﻥ ﻣیﺗﻮﺍﻥ ﺑﻪ ﺗﺎﺑع
)( random.ranintﺩﺳﺖ ﻳﺎﻓﺖ.
In [2]: import random
for i in range (5):
))print ( random . randint (1 , 10
Out[2]: 9
2
9
1
8
ﺗﻮﺟﻪ ﺩﺍﺷﺖ ﺑﺎﺷﻴﺪ ﻛﻪ ﺑﺎ ﺍﺟﺮﺍﯼ ﻫﺮ ﺑﺎﺭ ﺍﻳﻦ ﺑﺮﻧﺎﻣﻪ ،ﭘﻨﺞ ﻋﺪﺩ ﺗﻮﻟﻴﺪ ﺷﺪﻩ ﺗﻐﻴﻴﺮ ﻣیﻛﻨﺪ .ﺍﮔﺮ ﺑﺨﻮﺍﻫﻴﻢ ﭘﻨﺞ ﻋﺪﺩ ﺗﻮﻟﻴﺪ
ﺩﺭ ﻫﺮ ﺑﺎﺭ ﺍﺟﺮﺍ ﻣﻘﺎﺩﻳﺮ ﺛﺎﺑﺘی ﺑﻤﺎﻧﻨﺪ ،ﺑﺎﻳﺪ ﺍﺯ ﺗﺎﺑع )( seedﺍﺳﺘﻔﺎﺩﻩ ﻣیﺷﻮﺩ .ﻣﺜﺎﻝ:
1. module
۲۹ ﻓﺼﻞ .۲ﻣﺤﻴﻂﻫﺎﯼ ﻛﻨﺘﺮﻟی
In [1]: # random module is imported
import random
# Any number can be used in place of zero.
)random . seed (0
for i in range (5):
# Generated random number will be between 1 to 5.
))print ( random . randint (1 ,5
Out[1]: 4
4
1
3
5
ﺍﮔﺮ ﺩﺭ ﻳﮏ ﺑﺮﻧﺎﻣﻪ ﺍﺯ ﭼﻨﺪﻳﻦ ﻣﺎﮊﻭﻝ ﺍﺳﺘﻔﺎﺩﻩ ﺷﻮﺩ ،ﺑﺎﻳﺪ ﻧﺎﻡ ﻣﺎﮊﻭﻝﻫﺎ ﺑﺎ ﻋلاﻣﺖ ﻛﺎﻣﻨﺖ ﺍﺯ ﻫﻢ ﺟﺪﺍ ﺷﻮﻧﺪ .ﻣﺜﺎﻝ:
import random , math , s y s , o s
ﺍﻟﺒﺘﻪ ﺑﺮﺍﯼ ﺧﻮﺍﻧﺶ ﺑﻬﺘﺮ ُﻛﺪﻫﺎ ،ﺭﺳﻢ ﺑﺮ ﺍﻳﻦ ﺍﺳﺖ ﻛﻪ ﻫﺮ ﻣﺎﮊﻭﻝ ﺭﺍ ﺩﺭ ﺳﻄﺮ ﺟﺪﺍﮔﺎﻧﻪ ﺑﻨﻮﻳﺴﻨﺪ.
import random
import math
import sys
import os
ﻓﺮﻡ ﺩﻳﮕﺮﯼ ﺍﺯ ﺍﺗﺼﺎﻝ ﻣﺎﮊﻭﻝ ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﻛﻪ ﺩﺭ ﺁﻥ ﺍﺯ ﻛﻠﻴﺪ ﻭﺍﮊﮤ fromﺍﺳﺘﻔﺎﺩﻩ ﻣیﺷﻮﺩ .ﺩﺭ ﺍﻳﻦ ﺣﺎﻟﺖ ﻧﺎﻡ
ﻣﺎﮊﻭﻝ ﺩﺭ ﺍﺩﺍﻣﻪ fromﻣیﺁﻳﺪ .ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ importﻭ ﻋلاﻣﺖ ﺳﺘﺎﺭﻩ ،ﻣیﺗﻮﺍﻥ ﺍﺗﺼﺎﻝ ﺭﺍ ﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﻧﻮﺷﺖ:
∗ from random import
ﺩﺭ ﺍﻳﻦ ﺻﻮﺭﺕ ﺑﺮﺍﯼ ﺗﻮﺍﺑع ﺩﺭﻭﻥ ﻣﺎﮊﻭﻝ randomﺩﻳﮕﺮ ﻧﻴﺎﺯﯼ ﺑﻪ ﭘﻴﺸﻮﻧﺪ random ۱ﻧﻴﺴﺖ .ﺍﻣﺎ ﺑﺮﺍﯼ ﺧﻮﺍﻧﺶ
ﺑﻬﺘﺮ ،ﺑﺮﻧﺎﻣﻪﻧﻮﻳﺲﻫﺎ ﺗﺮﺟﻴح ﻣیﺩﻫﻨﺪ ﻛﻪ ﻧﺎﻡ ﻣﺎﮊﻭﻝ ﺑﻪ ﮔﻮﻧﻪﺍﯼ ﺑﻪ ﺑﺮﻧﺎﻣﻪ ﺍﺗﺼﺎﻝ ﭘﻴﺪﺍ ﻛﻨﺪ ﻛﻪ ﺍﺯ ﭘﻴﺸﻮﻧﺪ ﻧﺎﻡ
ﻣﺎﮊﻭﻝ ﺍﺳﺘﻔﺎﺩﻩ ﺷﻮﺩ.
ﮔﺎﻫی ﺍﻭﻗﺎﺕ ﻣﺎﮊﻭﻝﻫﺎﻳﯽ ﻛﻪ ﻧﺎﻡ ﻃﻮلاﻧی ﺩﺍﺭﻧﺪ ﺭﺍ ﺑﻪ ﺻﻮﺭﺕ ﻣﺨﺘﺼﺮ ﻣیﻧﻮﻳﺴﻨﺪ .ﺑﻪ ﻋﻨﻮﺍﻥ ﻣﺜﺎﻝ ،ﻧﺎﻡ ﻣﺨﺘﺼﺮ
ﺷﺪﻩ ﭼﻨﺪ ﻣﺎﮊﻭﻝ ﺭﺍ ﺫﻳل ًا ﻣلاﺣﻈﻪ ﻣیﻛﻨﻴﺪ.
import numpy a s np
import m a t p l o t l i b . p y p l o t a s p l t
import P a n d a s a s pd
ﻣﻮﺭﺩ ﺩﻭﻡ ﺍﺯ ﻣﺜﺎﻝ ﺍﺧﻴﺮ ﺭﺍ ﻣیﺗﻮﺍﻥ ﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﻧﻴﺰ ﻣیﺗﻮﺍﻥ ﻧﻮﺷﺖ:
from m a t p l o t l i b import p y p l o t
ﺩﺭ ﺍﻳﻦ ﺻﻮﺭﺕ ﺑﺠﺎﯼ ﭘﺴﻮﻧﺪ pltﺍﺯ ﭘﺴﻮﻧﺪ pyplotﺍﺳﺘﻔﺎﺩﻩ ﻣیﺷﻮﺩ.
1. prefix
���
۳
ﺗﻮﺍﺑع ﺩﺭ ﭘﺎﻳﺘﻮﻥ
ﻣﻘﺪﻣﻪ ۱-۳
ﺩﺭ ﺯﺑﺎﻥﻫﺎﯼ ﺑﺮﻧﺎﻣﻪﻧﻮﻳﺴی ﻣیﺗﻮﺍﻥ ﺗﺎﺑع ﺍﻳﺠﺎﺩ ﻧﻤﻮﺩ .ﺍﻣﺎ ﭼﺮﺍ ﺍﻳﻦ ﺷی ﻣﻔﻴﺪ ﺍﺳﺖ؟
• ﺟﻠﻮﮔﻴﺮﯼ ﺍﺯ ﺗﻜﺮﺍﺭ ُﻛﺪﻫﺎﯼ ﻏﻴﺮ ﺿﺮﻭﺭﯼ ﻭ ﻛﻮﭼﻜﺘﺮ ﺷﺪﻥ ﺑﺮﻧﺎﻣﻪﻫﺎ .ﺑﻪﻋﻨﻮﺍﻥ ﻣﺜﺎﻝ ﻣﺤﺎﺳﺒﻪ ﺗﺮﻛﻴﺐ mﺍﺯ
) ( nﺭﺍ ﺩﺭ ﻧﻈﺮ ﺑﮕﻴﺮﻳﺪ.
n !n
=
m !)m!(n − m
ﻣﺎ ﺑﺮﺍﯼ ﻣﺤﺎﺳﺒﻪ ﺟﻤلاﺕ ﺍﻳﻦ ﺭﺍﺑﻄﻪ ﻧﻴﺎﺯ ﺑﻪ ﻣﺤﺎﺳﺒﻪ ﻓﺎﻛﺘﻮﺭﻳﻞ ﺩﺍﺭﻳﻢ .ﺍﮔﺮ ﺑﺨﻮﺍﻫﻴﻢ ﺑﺮﺍﯼ ﻣﺤﺎﺳﺒﻪ ﺁﻥ
ﻫﺮ ﺑﺎﺭ ُﻛﺪ ﺑﻨﻮﻳﺴﻴﻢ ﺍﻳﻦ ﻛﺎﺭ ﺑﺴﻴﺎﺭ ﻃﻮلاﻧی ﻭ ﺧﺴﺘﻪﻛﻨﻨﺪﻩ ﺧﻮﺍﻫﺪ ﺑﻮﺩ .ﺩﺭ ﺻﻮﺭﺗی ﻛﻪ ﻣیﺗﻮﺍﻥ ﺍﺯ ﻳﮏ ﺗﺎﺑع
ﺍﺳﺘﻔﺎﺩﻩ ﻧﻤﻮﺩ ﻛﻪ ﻭﻇﻴﻔﻪ ﺁﻥ ﻣﺤﺎﺳﺒﻪ ﻓﺎﻛﺘﻮﺭﻳﻞ ﻳﮏ ﻋﺪﺩ ﺍﺳﺖ .ﺑﻪ ﺍﻳﻦ ﺗﺮﺗﻴﺐ ﻳﮏ ﺑﺎﺭ ﺍﻳﻦ ﺗﺎﺑع ﻧﻮﺷﺘﻪ
ﻣیﺷﻮﺩ ﻭ ﺳﭙﺲ ﺑﻪ ﺩﻓﻌﺎﺕ ﺍﺯ ﺁﻥ ﺍﺳﺘﻔﺎﺩﻩ ﻣیﮔﺮﺩﺩ.
• ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺗﺎﺑع ،ﻣﻮﺟﺐ ﺳﺎﺧﺘﺎﺭﻳﺎﻓﺘﮕی ﺑﺮﻧﺎﻣﻪﻫﺎ ﻣیﮔﺮﺩﺩ .ﻳﻌﻨی ﻣیﺗﻮﺍﻥ ﻳﮏ ﺑﺮﻧﺎﻣﻪ ﺑﺰﺭﮒ ﺭﺍ ﺑﻪ ﺍﺟﺰﺍ
ﻛﻮﭼﻜﺘﺮ ﺗﻘﺴﻴﻢ ﻧﻤﻮﺩ ﺑﻪ ﻧﺤﻮﯼ ﻛﻪ ﻫﺮ ُﺟﺰ ﻳﮏ ﻭﻇﻴﻔﻪ ﺭﺍ ﺑﻪ ﻋﻬﺪﻩ ﻣیﮔﻴﺮﺩ .ﺑﻪ ﺍﻳﻦ ﺗﺮﺗﻴﺐ ﻧﮕﻪﺩﺍﺭﯼ
ﻭ ﺗﻮﺳﻌﻪ ﺑﺮﻧﺎﻣﻪﻫﺎ ﺑﺴﻴﺎﺭ ﺳﺎﺩﻩﺗﺮ ﻭ ﻋﻤﻠیﺗﺮ ﺧﻮﺍﻫﺪ ﺑﻮﺩ .ﺩﺭ ﻣﺜﺎﻝ ﺑﺎلا ﻳﮏ ُﺟﺰ ﺍﺯ ﺍﺟﺰﺍ ﺑﺮﻧﺎﻣﻪ ،ﻣﺤﺎﺳﺒﻪ
ﻓﺎﻛﺘﻮﺭﻳﻞ ﻳﮏ ﻋﺪﺩ ﺍﺳﺖ ﻛﻪ ﺑﺮﻧﺎﻣﻪ ﺍﺻﻠی ﺍﺯ ﺁﻥ ﺍﺳﺘﻔﺎﺩﻩ ﻣیﻛﻨﺪ.
ﻛﺎﺭﺑﺮ ۲ ﺩﺭ ﭘﺎﻳﺘﻮﻥ ﺩﻭ ﻧﻮع ﺗﺎﺑع ﻭﺟﻮﺩ ﺩﺍﺭﺩ .ﺗﻮﺍﺑع ﭘﻴﺶﺳﺎﺧﺘﻪ ۱ﻭ ﺗﻮﺍﺑع ﺗﻌﺮﻳﻒ ﺷﺪﻩ
ﺗﻮﺍﺑع ﭘﻴﺶﺳﺎﺧﺘﻪ ،ﺁﻥ ﺩﺳﺘﻪ ﺗﻮﺍﺑﻌی ﻫﺴﺘﻨﺪ ﻛﻪ ﺍﺯ ﻗﺒﻞ ﺳﺎﺧﺘﻪ ﺷﺪﻩ ﻭ ﺩﺭ ﭘﺎﻳﺘﻮﻥ ﻗﺮﺍﺭ ﺩﺍﺭﻧﺪ .ﻣﺜﻞ،len() ،print() :
)( typeﻭ … ﻛﻪ ﺑﺮﺍﯼ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺭ ﺁﻧﻬﺎ ﻛﺎﻓی ﺍﺳﺖ ﻛﻪ ﻓﺮﺍﺧﻮﺍﺩﻩ ﺷﻮﻧﺪ .ﺻﺪﺍ ﺯﺩﻥ ﻭ ﻳﺎ ﻓﺮﺍﺧﻮﺍﻧی ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻧﺎﻡ
1. Built_in functions
2. user defined functions
۳۰
۳۱ ﻓﺼﻞ .۳ﺗﻮﺍﺑع ﺩﺭ ﭘﺎﻳﺘﻮﻥ
ﺁﻧﻬﺎ ﺻﻮﺭﺕ ﻣیﮔﻴﺮﺩ .ﺍﻣﺎ ﺩﺭ ﺗﻮﺍﺑع ﻧﻮع ﺩﻭﻡ ،ﺍﺑﺘﺪﺍ ﺑﺎﻳﺪ ﺗﺎﺑع ﺗﻌﺮﻳﻒ ﺷﻮﺩ ﻭ ﺳﭙﺲ ﺑﺮﺍﯼ ﺍﻋﻤﺎﻝ ﺗﺎﺑع ،ﻧﺎﻡ ﺁﻥ ﺭﺍ ﺻﺪﺍ
ﻣیﺯﻧﻴﻢ .ﺗﻮﺿﻴح ﺑﻴﺸﺘﺮ ﺭﺍ ﺩﺭ ﺍﺩﺍﻣﻪ ﻣلاﺣﻈﻪ ﺧﻮﺍﻫﻴﺪ ﻧﻤﻮﺩ.
۲-۳ﺗﻮﺍﺑع ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﻛﺎﺭﺑﺮ
ﺗﺎﺑع ﮔﺮﻭﻫی ﺍﺯ ﺩﺳﺘﻮﺭﺍﺕ ﺍﺳﺖ ﻛﻪ ﺑﺎ ﻫﻢ ﻋﻤﻠی ﺭﺍ ﺳﺎﻣﺎﻥ ﻣیﺩﻫﻨﺪ .ﺻﻮﺭﺕ ﻛﻠی ﺗﺎﺑع ﺑﻪ ﺷﺮح ﺯﻳﺮ ﺍﺳﺖ.
d e f f u n c t i o n _ n a m e ( a r g 1 , a r g 2 , . . . , argN ) :
body o f f u n c t i o n
ﺳﺎﺧﺘﺎﺭ ﺗﺎﺑع ﺑﻪ ﺷﺮح ﺯﻳﺮ ﺍﺳﺖ.
.۱ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻛﻠﻴﺪ ﻭﺍﮊﻩ ،defﺍﻳﻦ ﻣﺨﻔﻒ ﺑﻪ ﻣﻌﻨﺎﯼ ﺗﻌﺮﻳﻒ ) ۱ﺗﺎﺑع( ﻣیﺑﺎﺷﺪ.
.۲ﺗﺎﺑع ﻧﻴﺎﺯﻣﻨﺪ ﻳﮏ ﻧﺎﻡ ) (function_nameﺍﺳﺖ.
.۳ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﭘﺮﺍﻧﺘﺰ ﺑﺎﺯ ﻭ ﺑﺴﺘﻪ ﺿﺮﻭﺭﯼ ﺍﺳﺖ ﻭﮔﺮﻧﻪ ﺑﺮﻧﺎﻣﻪ ﺧﻄﺎ ﻣیﺩﻫﺪ .ﺩﺍﺧﻞ ﭘﺮﺍﻧﺘﺰ ﻋﻨﺎﺻﺮﯼ ﺑﻪ ﻧﺎﻡ
ﺁﺭﮔﻮﻣﺎﻥ ۲ﻗﺮﺍﺭ ﺩﺍﺭﺩ ﻛﻪ ﺍﺧﺘﻴﺎﺭﯼ ﺍﺳﺖ .ﺑﻨﺎﺑﺮﺍﻳﻦ ﻣیﺗﻮﺍﻥ ﺗﺎﺑﻌی ﺩﺍﺷﺖ ﻛﻪ ﺁﺭﮔﻮﻣﺎﻥ ﻧﺪﺍﺷﺘﻪ ﺑﺎﺷﺪ.
.۴ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻧﻤﺎﺩ » ۳ «:ﺿﺮﻭﺭﯼ ﺍﺳﺖ ﻭﮔﺮﻧﻪ ﺑﺮﻧﺎﻣﻪ ﺧﻄﺎ ﻣیﺩﻫﺪ.
.۵ﺑﺪﻧﻪ ﺗﺎﺑع :ﻳﻌﻨی ﺩﺳﺘﻮﺭﺍﺗی ﻛﻪ ﺩﺍﺧﻞ ﺗﺎﺑع ﻗﺮﺍﺭ ﻣیﮔﻴﺮﻧﺪ ﻭ ﻛﻨﺘﺮﻝ ﺭﻭﯼ ﺁﻧﻬﺎ ﺍﻋﻤﺎﻝ ﻣیﺷﻮﺩ .ﺩﺳﺘﻮﺭﺍﺗی ﻛﻪ
ﺩﺭ ﺑﺪﻧﻪ ﺗﺎﺑع ﻗﺮﺍﺭ ﺩﺍﺭﻧﺪ ،ﺩﺍﺭﺍﯼ ﺗﻮﺭﻓﺘﮕی ۴ﻫﺴﺘﻨﺪ.
ﻣﺜﺎﻝ :۱
In [1]: def foo ():
)' print ('Hello ','Reza
)( foo
Out[1]: Hello Reza
ﻣﺜﺎﻝ :۲
In [2]: def foo ():
)' print ('Hello ','Reza
)( foo
)( foo
Out[2]: Hello Reza
Hello Reza
1. definition
2. Argument
3. colon
4. indentation
.۲-۳ﺗﻮﺍﺑع ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﻛﺎﺭﺑﺮ ۳۲
ﻣیﺗﻮﺍﻧﻴﻢ ﻛﻪ ﺑﺮﺍﯼ ﺗﺎﺑع ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺩﺳﺘﻮﺭ )( inputﻫﺮ ﺍﺳﻤی ﺭﺍ ﻭﺍﺭﺩ ﻧﻤﻮﺩﻩ ﻭ ﺳﭙﺲ ﺁﻧﺮﺍ ﭼﺎﭖ ﻛﻨﻴﻢ .ﻣﺜﺎﻝ :۳
In [1]: def foo ():
)'name = input ('Enter your name :
) print ('Hello ',name
)( foo
Out[1]: Enter your name : Reza
Hello Reza
ﺩﺭ ﺳﻪ ﻣﺜﺎﻝ ﺍﺧﻴﺮ ﺗﺎﺑع )( fooﺑﺪﻭﻥ ﺁﺭﮔﻮﻣﺎﻥ ﺑﻮﺩ .ﺑﻨﺎﺑﺮﺍﻳﻦ ﻳﺎ ﻳﮏ ﻧﺎﻡ ﻣﺸﺨﺺ ﺗﻜﺮﺍﺭ ﻣیﺷﺪ ﻭ ﻳﺎ ﺍﺳﻢ ﺭﺍ ﺍﺯ ﻃﺮﻳﻖ
inputﻭﺍﺭﺩ ﻣیﻛﺮﺩﻳﻢ .ﺍﻣﺎ ﺭﻭﺵ ﻣﻨﺎﺳﺐﺗﺮ ﺍﻳﻦ ﺍﺳﺖ ﻛﻪ ﺑﺠﺎﯼ ﺗﻜﺮﺍﺭ ﻭ ﻭﺍﺭﺩ ﻧﻤﻮﺩﻥ ﺍﺳﺎﻣی ﺩﺭ ﺑﺪﻧﻪ ﺗﺎﺑع ﺍﺯ ﺍﻣﻜﺎﻥ
ﺁﺭﮔﻮﻣﺎﻥ ﺗﺎﺑع ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﻴﻢ .ﻣﺜﺎﻝ:
In [2]: def foo ( name ):
) print ('Hello ',name
)' foo ('ava
)' foo ('ali
)' foo ('hamed
Out[2]: Hello ava
Hello ali
Hello hamed
ﺩﺭ ﺗﺎﺑع ﺑﺎلا ﺩﻭ ﻣﺮﺣﻠﻪ ﺭﺍ ﻣیﺗﻮﺍﻥ ﺍﺯ ﻫﻢ ﺟﺪﺍ ﻧﻤﻮﺩ .ﺳﻄﺮﻫﺎﯼ ۱ﻭ ۲ﺑﺮﻧﺎﻣﻪ ،ﺗﻌﺮﻳﻒ ﺗﺎﺑع ﻫﺴﺘﻨﺪ ﻭ ﺳﻄﺮﻫﺎﯼ ،۳
۴ﻭ ۵ﺗﺎﺑع ﺭﺍ ﺍﺣﻀﺎﺭ ۱ﻣیﻛﻨﺪ .ﺑﻪ ﻣﺤﺾ ﺍﺣﻀﺎﺭ ﻳﺎ ﻓﺮﺍﺧﻮﺍﻧی ﺗﺎﺑع ،ﻧﺘﻴﺠﻪ ﺁﻥ ﻇﺎﻫﺮ ﻣیﮔﺮﺩﺩ.
ﻣﻘﺪﺍﺭ None ۱-۲-۳
ﺩﺭ ﭘﺎﻳﺘﻮﻥ ﻣﻘﺪﺍﺭﯼ ﺑﻪ ﻧﺎﻡ Noneﻭﺟﻮﺩ ﺩﺍﺭﺩ ﻛﻪ ﻫﻴچ ﻣﻘﺪﺍﺭﯼ ﻧﺪﺍﺭﺩ ﻭ ﺣﺮﻑ ﺍﻭﻝ ﺁﻥ ﻧﻴﺰ ﺑﻪ ﺻﻮﺭﺕ ﺑﺰﺭﮒ ﻧﻮﺷﺘﻪ
ﻣیﺷﻮﺩ .ﻳﻜی ﺍﺯ ﺟﺎﻫﺎﻳﯽ ﻛﻪ ﺍﺯ ﺁﻥ ﺍﺳﺘﻔﺎﺩﻩ ﻣیﺷﻮﺩ ﺩﺭ ﻣﻮﺭﺩ ﺗﺎﺑع )( printﺍﺳﺖ .ﻋﻤﻞ ﺍﻳﻦ ﺗﺎﺑع ﻧﻤﺎﻳﺶ ﻣﺘﻦ ﺭﻭﯼ
ﺻﻔﺤﻪ ﻧﻤﺎﻳﺶ ﺍﺳﺖ .ﻭ ﭼﻴﺰﯼ ﺑﻪ ﻋﻨﻮﺍﻥ ﭘﺎﺳﺦ ،ﻣﺜﻞ ﺗﻮﺍﺑع )( lenﻭ )( inputﺑﺪﺳﺖ ﻧﻤیﺩﻫﺪ ﻭ ﺧﺮﻭﺟی ﻧﺪﺍﺭﺩ.
ﻳﺎ ﺍﺻﻄلاﺣ ًﺎ ﭼﻴﺰﯼ ﺑﺮﻧﻤیﮔﺮﺩﺍﻧﺪ .ﺩﺭ ﻭﺍﻗﻊ ﺗﺎﺑع )( printﻳﮏ ﻣﻘﺪﺍﺭ ﺑﯽﻣﻘﺪﺍﺭ Noneﺭﺍ ﺑﺮﻣیﮔﺮﺩﺍﻧﺪ .ﺑﻪ ﻣﺜﺎﻝ ﺯﻳﺮ
ﺗﻮﺟﻪ ﻛﻨﻴﺪ.
In [3]: )'! spam = print ('Hello
)) print ( type ( spam
None == spam
Out[3]: ! Hello
>' <class ' NoneType
True
1. invoke
۳۳ ﺗﻮﺍﺑع ﺩﺭ ﭘﺎﻳﺘﻮﻥ.۳ ﻓﺼﻞ
return ﻛﻠﻴﺪ ﻭﺍﮊﻩ۱-۱-۲-۳
print() ﻛﺎﺭﯼ ﻛﻪ ﺗﺎﺑع. ﺍﺳﺘﻔﺎﺩﻩ ﺷﻮﺩretuen ﺑﺮﺍﯼ ﺍﻳﻦ ﻛﻪ ﺗﺎﺑع ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﺧﺮﻭﺟی ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ ﺑﺎﻳﺪ ﺍﺯ ﻛﻠﻴﺪ ﻭﺍﮊﻩ
. ﻣیﺗﻮﺍﻧﺪ ﻣﻘﺪﺍﺭ ﻳﮏ ﻣﺘﻐﻴﺮ ﻭ ﻳﺎ ﻋﺒﺎﺭﺕ ﺭﺍ ﺑﻪ ﻋﻨﻮﺍﻥ ﺧﺮﻭﺟی ﺑﺮﮔﺮﺩﺍﻧﺪreturn ﻓﺮﻣﺎﻥ.ﻗﺎﺩﺭ ﺑﻪ ﺍﻧﺠﺎﻡ ﺁﻥ ﻧﻴﺴﺖ
:۱ ﻣﺜﺎﻝ
In [1]: def divNum (a, b):
if b !=0:
return a//b
else :
return 0
print ( divNum (4 ,2))
print ( divNum (2 ,0))
Out[1]: 2
0
. ﻛﻨﺘﺮﻝ ﺍﺯ ﺗﺎﺑع ﺧﺎﺭج ﻣیﺷﻮﺩreturn ﺑﺎ ﻫﺮ ﺑﺎﺭ ﺍﺟﺮﺍﯼ ﻓﺮﻣﺎﻥ،ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﺩﺭ ﻣﺜﺎﻝ ﺑﺎلا ﻣﺸﺎﻫﺪﻩ ﻣیﺷﻮﺩ
:۲ ﻣﺜﺎﻝ
In [2]: def statFun (a , b):
difference =a-b
percent_diff =( difference /a )*100
return difference , percent_diff
difference , percent_diff = statFun (20 ,8)
print ( difference )
print ( percent_diff )
Out[2]: 12
60.0
ﺑﺮﮔﺮﺩﺍﻧﺪﻩ ﺷﺪﻩreturn ( ﺍﺯ ﺗﺎﺑع ﻧﺘﻴﺠﻪ ﺷﺪﻩ ﻛﻪ ﺗﻮﺳﻂdifference, percent_diff) ﺩﺭ ﻣﺜﺎﻝ ﺑﺎلا ﺩﻭ ﻣﻘﺪﺍﺭ
.ﺍﺳﺖ
:۳ ﻣﺜﺎﻝ
In [3]: def function ( inter ):
inter +=100
print (" Inside function call ",inter )
inter =100
print (" Before function call ",inter )
function ( inter )
print (" After function call ",inter )
.۲-۳ﺗﻮﺍﺑع ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﻛﺎﺭﺑﺮ ۳۴
Out[3]: Before function call 100
Inside function call 200
After function call 100
ﻓﺮﺍﺧﻮﺍﻧی ﻳﮏ ﺗﺎﺑع ﺩﺍﺧﻞ ﺗﺎﺑع ﺩﻳﮕﺮ ۲-۱-۲-۳
ﻣﺎ ﻣیﺗﻮﺍﻧﻴﻢ ﻛﻪ ﺩﺭ ﺩﺍﺧﻞ ﺗﻌﺮﻳﻒ ﻳﮏ ﺗﺎﺑع ،ﺗﺎﺑع ﻭ ﺗﻮﺍﺑع ﺩﻳﮕﺮﯼ ﺭﺍ ﻓﺮﺍﺧﻮﺍﻧی ﻛﻨﻴﻢ.
ﻣﺜﺎﻝ:۱
In [1]: def main () :
)result = cubeVolume (2
) print ("A cube with side length 2 has volume ", result
def cubeVolume ( sideLength ) :
volume = sideLength ** 3
return volume
)( main
Out[1]: A cube with side length 2 has volume 8
ﺩﺭ ﻣﺜﺎﻝ ﺑﺎلا ﺩﻭ ﺗﺎﺑع )( mainﻭ )( cubeVolumeﺗﻌﺮﻳﻒ ﺷﺪﻩ ﺍﺳﺖ .ﺩﺭ ﺳﻄﺮ ﺁﺧﺮ ﺑﺮﻧﺎﻣﻪ ،ﺗﺎﺑع ﺍﻭﻟی ﻓﺮﺧﻮﺍﻧﺪﻩ
ﻣیﺷﻮﺩ .ﺑﺮﺍﯼ ﺍﺟﺮﺍﯼ ﺁﻥ ﺑﻪ ﺗﻌﺮﻳﻔﺶ ﻣﺮﺍﺟﻌﻪ ﻣیﻛﻨﺪ .ﺍﻣﺎ ﺩﺭ ﺩﺍﺧﻞ ﺗﺎﺑع ،mainﺗﺎﺑع cubeVolumeﻓﺮﺍﺧﻮﺍﻧﺪﻩ
ﺷﺪﻩ ﻭ ﻣﻘﺪﺍﺭ ﺁﺭﮔﻮﻣﺎﻥ ﺁﻥ ﺑﺮﺍﺑﺮ ۲ﺍﺳﺖ .ﭘﺲ ﺣﺠﻢ ﺑﻪ ﺍﺯﺍﯼ ﻋﺪﺩ ۲ﻣﺤﺎﺳﺒﻪ ﻣیﺷﻮﺩ .ﻭ ﺳﭙﺲ ﻋﻤﻞ ﭼﺎﭖ ﺍﻧﺠﺎﻡ
ﻣیﮔﺮﺩﺩ.
ﻣﺜﺎﻝ :۲
In [2]: def large (num1 , num2 ):
if num1 > num2 :
result = num1
else :
result = num2
return result
def main ():
))' x= float ( input (' number1 :
))' y= float ( input (' number2 :
))print (' Bigger is:',large (x,y
)( main
Out[2]: number1 : 4.5
number2 : 7.3
Bigger is: 7.3
ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﻣﺸﺎﻫﺪﻩ ﻣیﺷﻮﺩ .ﺩﺭ ﺗﺎﺑع )( mainﺗﺎﺑع ) large(x,yﻓﺮﺍﺧﻮﺍﻧی ﺷﺪﻩ ﺍﺳﺖ ،ﻛﻨﺘﺮﻝ ﺑﻪ ﺩﻧﺒﺎﻝ ﺗﺎﺑﻌی
ﺑﻪ ﻧﺎﻡ largeﻣیﮔﺮﺩﺩ ﻭ ﺁﻥ ﺭﺍ ﺗﻮﺳﻂ ﻧﺎﻣﺶ ﭘﻴﺪﺍ ﻣیﻛﻨﺪ ﻭ ﺍﺟﺮﺍ ﻣیﻧﻤﺎﻳﺪ .ﺗﻮﺟﻪ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ ﻣﺤﻞ ﻗﺮﺍﺭ ﮔﺮﻓﺘﻦ
۳۵ ﻓﺼﻞ .۳ﺗﻮﺍﺑع ﺩﺭ ﭘﺎﻳﺘﻮﻥ
ﺗﻌﺮﻳﻒ ﺗﺎﺑع largeﻣﻬﻢ ﻧﻴﺴﺖ ،ﺑﺪﻳﻦ ﻣﻌﻨی ﻛﻪ ﺍﻳﻦ ﺗﺎﺑع ﻣیﺗﻮﺍﻧﺪ ﻗﺒﻞ ﻳﺎ ﺑﻌﺪ ﺍﺯ ﺗﺎﺑع mainﺗﻌﺮﻳﻒ ﺷﻮﺩ.
۲-۲-۳ﻧﺤﻮﻩ ﻗﺮﺍﺭ ﮔﺮﻓﺘﻦ ﻭ ﺗﺮﺗﻴﺐ ﺁﺭﮔﻮﻣﺎﻥﻫﺎ
ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﻗﺒل ًا ﻣﺸﺎﻫﺪﻩ ﺷﺪ ،ﻣﻘﺎﺩﻳﺮ ﺁﺭﮔﻮﻣﺎﻥﻫﺎﯼ ﺗﻮﺍﺑع ﺩﺭ ﺣﻴﻦ ﺍﺟﺮﺍ ﺑﻪ ﺁﺭﮔﻮﻣﺎﻥﻫﺎﯼ ﺗﻮﺍﺑع ﺩﺭ ﺗﻌﺮﻳﻒ ﺁﻧﻬﺎ
ﻣﻨﺘﻘﻞ ﻣیﺷﻮﺩ .ﻭ ﺑﻪ ﺗﺮﺗﻴﺐ ﻣﻘﺪﺍﺭ ﺍﻭﻝ ﺑﻪ ﺟﺎﯼ ﺁﺭﮔﻮﻣﺎﻥ ﺍﻭﻟی ﻭ ﻣﻘﺪﺍﺭ ﺩﻭﻡ ﺑﻪ ﺟﺎﯼ ﺁﺭﮔﻮﻣﺎﻥ ﺩﻭﻡ ﻭ ﺍﻟی ﺁﺧﺮ .ﺍﮔﺮ ﺍﻳﻦ
ﺗﺮﺗﻴﺐ ﺭﻋﺎﻳﺖ ﻧﺸﻮﺩ ،ﺁﻧﮕﺎﻩ ﻣﺤﺎﺳﺒﺎﺕ ﺍﻧﺠﺎﻡ ﺷﺪﻩ ﺩﺭﺳﺖ ﻧﻴﺴﺖ ﻭ ﺣﺘی ﻣﻤﻜﻦ ﺍﺳﺖ ﺑﺮﻧﺎﻣﻪ ﺷﻤﺎ ﺑﺎ ﺧﻄﺎ ﻣﻮﺍﺟﻪ
ﺷﻮﺩ.
)mass (kg
ﻣﺜﺎﻝ :ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺯﻳﺮ ﺍﻧﺪﻳﺲ ﺗﻮﺩﻩ ﺑﺪﻥ ۱ﺑﺎ ﻓﺮﻣﻮﻝ ) BMI = height۲ (meterﻣﺤﺎﺳﺒﻪ ﻣیﺷﻮﺩ .ﻓﺮﺽ ﻛﻨﻴﺪ ﻛﻪ ﻭﺯﻥ
ﺷﺨﺼی ۷۲ﻛﻴﻠﻮﮔﺮﻡ ﻭ ﻗﺪﺵ ۱٫۷۰ﻣﺘﺮ ﺍﺳﺖ.
In [1]: def BMI (mass , height ):
return mass / height **2
)ans = BMI (72 ,1.70
)) print ('{:.2 f}'. format ( ans
Out[1]: 24.91
ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﻣﺸﺎﻫﺪﻩ ﻣیﺷﻮﺩ .ﭼﻮﻥ ﺍﻭﻟﻴﻦ ﺁﺭﮔﻮﻣﺎﻥ ﺩﺭ ﺗﻌﺮﻳﻒ ﺗﺎﺑع mass ،ﻭ ﺩﻭﻣی heightﺍﺳﺖ ،ﻫﻤﻴﻦ ﺗﺮﺗﻴﺐ
ﻧﻴﺰ ﺑﺎﻳﺪ ﺩﺭ ﻓﺮﺍﺧﻮﺍﻧی ﺗﺎﺑع ﻣﺮﺍﻋﺎﺕ ﮔﺮﺩﺩ .ﺍﻭﻝ ﻣﻘﺪﺍﺭ ﻭﺯﻥ ﻳﻌﻨی ۷۲ﻛﻴﻠﻮ ﻭ ﺩﻭﻡ ﺍﻧﺪﺍﺯﻩ ﻗﺪ ﻳﻌﻨی ۱٫۷۰ﻣﻨﻈﻮﺭ ﮔﺮﺩﺩ.
ﺍﻣﺎ ﺍﮔﺮ ﺩﺭ ﻓﺮﺍﺧﻮﺍﻧی ﺗﺎﺑع ﺍﺯ ﻛﻠﻴﺪ ﻭﺍﮊﻩﻫﺎ ،۲ﻳﺎ ﺑﻪ ﻋﺒﺎﺭﺕ ﺩﻳﮕﺮ ﺍﺯ ﺍﺳﺎﻣی ﺁﺭﮔﻮﻣﺎﻥﻫﺎ ﺍﺳﺘﻔﺎﺩﻩ ﻛﻨﻴﺪ ،ﻣیﺗﻮﺍﻧﻴﺪ ﺗﺮﺗﻴﺐ
ﺁﺭﮔﻮﻣﺎﻥﻫﺎ ﺭﺍ ﺭﻋﺎﻳﺖ ﻧﻜﻨﻴﺪ .ﺑﻪ ﻣﺜﺎﻝ ﺯﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ.
In [2]: def BMI (mass , height ):
return mass / height **2
)ans = BMI ( height =1.70 , mass =72
)) print ('{:.2 f}'. format ( ans
Out[2]: 24.91
ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﻣﺸﺎﻫﺪﻩ ﻣیﺷﻮﺩ .ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻛﻠﻴﺪ ﻭﺍﮊﻩﻫﺎ ،ﺍﻭﻝ ﺍﻧﺪﺍﺯﻩ ﻗﺪ ﻣﻨﻈﻮﺭ ﺷﺪﻩ ﻭ ﺩﻭﻡ ﻣﻘﺪﺍﺭ ﻭﺯﻥ ﺁﻣﺪﻩ ﺍﺳﺖ
ﻛﻪ ﺍﻳﻦ ﺧلاﻑ ﺗﺮﺗﻴﺐ ﺁﺭﮔﻮﻣﺎﻥﻫﺎ ﺩﺭ ﺗﻌﺮﻳﻒ ﺗﺎﺑع ﺍﺳﺖ.
۳-۲-۳ﻧﺤﻮﻩ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻣﻘﺎﺩﻳﺮ ﭘﻴﺶﻓﺮﺽ ﺩﺭ ﺁﺭﮔﻮﻣﺎﻥ ﺗﻮﺍﺑع
ﺩﺭ ﭘﺎﻳﺘﻮﻥ ،ﻣیﺗﻮﺍﻥ ﺗﻮﺍﺑﻌی ﺑﺎ ﻣﻘﺪﺍﺭ ﻳﺎ ﻣﻘﺎﺩﻳﺮ ﭘﻴﺶﻓﺮﺽ ﺑﺮﺍﯼ ﺑﺮﺧی ﺍﺯ ﺁﺭﮔﻮﻣﺎﻥ ﻳﺎ ﺁﺭﮔﻮﻣﺎﻥﻫﺎﯼ ﺁﻧﻬﺎ ﺗﻌﺮﻳﻒ ﻧﻤﻮﺩ،
ﻛﻪ ﺗﻮﺳﻂ ﻛﺎﺭﺑﺮ ﺗﻨﻈﻴﻢ ﻣیﺷﻮﻧﺪ .ﺑﺮﺍﯼ ﺍﻳﻦ ﻛﺎﺭ ﺩﻭ ﺭﻭﺵ ﭘﻴﺶ ﺭﻭﯼ ﺩﺍﺭﻳﻢ.
1. Body Mass Index
2. keywords
.۲-۳ﺗﻮﺍﺑع ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﻛﺎﺭﺑﺮ ۳۶
• ﺑﺪﻭﻥ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻛﻠﻴﺪ ﻭﺍﮊﻩﻫﺎ ﺩﺭ ﺁﺭﮔﻮﻣﺎﻥﻫﺎ
• ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻛﻠﻴﺪ ﻭﺍﮊﻩﻫﺎ ﺑﺮﺍﯼ ﺁﺭﮔﻮﻣﺎﻥﻫﺎ
ﻣﺜﺎﻝ :۱ﺑﺪﻭﻥ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻛﻠﻴﺪ ﻭﺍﮊﻩﻫﺎ
In [1]: def fun1 (a,b =199):
return a+b
))print ( fun1 (2 ,2
Out[1]: 4
ﺯﻣﺎﻧی ﻛﻪ ﺑﺮﺍﯼ ﺁﺭﮔﻮﻣﺎﻥ bﺩﺭ ﻓﺮﺍﺧﻮﺍﻧی ﺗﺎﺑع ﻣﻘﺪﺍﺭ ﺗﻌﻴﻴﻦ ﺷﺪﻩ ﺍﺳﺖ ،ﻣﻘﺪﺍﺭ ﭘﻴﺶﻓﺮﺽ ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻧﻤیﺷﻮﺩ.
ﺑﻨﺎﺑﺮﺍﻳﻦ a + b = ۲ + ۲ = ۴ﺍﺳﺖ.
ﻣﺜﺎﻝ :۲ﺑﺪﻭﻥ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻛﻠﻴﺪ ﻭﺍﮊﻩﻫﺎ
In [2]: def fun1 (a,b =199):
return a+b
))print ( fun1 (1
Out[2]: 200
ﺩﺭ ﺍﻳﻦ ﻣﺜﺎﻝ ﻣﻘﺪﺍﺭ ﺑﺮﺍﯼ ﺁﺭﮔﻮﻣﺎﻥ bﺩﺭ ﻓﺮﺧﻮﺍﻧی ﺗﺎﺑع ﻣﻨﻈﻮﺭ ﻧﺸﺪﻩ ﺍﺳﺖ .ﺑﻨﺎﺑﺮﺍﻳﻦ ﺁﺭﮔﻮﻣﺎﻥ bﺍﺯ ﻣﻘﺪﺍﺭ ﭘﻴﺶﻓﺮﺽ
ﺍﺳﺘﻔﺎﺩﻩ ﻣیﻛﻨﺪ .ﻳﻌﻨی a + b = ۱ + ۱۹۹ = ۲۰۰ﺍﺳﺖ.
ﻣﺜﺎﻝ :۳ﺑﺪﻭﻥ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻛﻠﻴﺪ ﻭﺍﮊﻩﻫﺎ ﺑﺮﺍﯼ ﺭﺷﺘﻪ
In [3]: def fun2 ( string1 , string2 =' shirazi '):
) print ( string1 + string2
)' fun2 ('ava ', ' karimi
)' fun2 ('ava
Out[3]: ava karimi
ava shirazi
ﺩﺭ ﺍﻳﻦ ﻣﺜﺎﻝ ﺑﺮﺍﯼ ﺁﺭﮔﻮﻣﺎﻥ string2ﺩﺭ ﻓﺮﺍﺧﻮﺍﻧی ﺍﻭﻝ ﺗﺎﺑع ،ﻣﻘﺪﺍﺭ ﺗﻌﻴﻴﻦ ﺷﺪﻩ ﺍﺳﺖ ،ﺑﻨﺎﺑﺮﺍﻳﻦ ﻣﻘﺪﺍﺭ ﭘﻴﺶﻓﺮﺽ
ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻧﻤیﺷﻮﺩ .ﻭ ﻋﺒﺎﺭﺕ »ﺁﻭﺍ ﻛﺮﻳﻤی« ﭼﺎﭖ ﺷﺪﻩ ﺍﺳﺖ .ﺩﺭ ﻓﺮﺍﺧﻮﺍﻥ ﺩﻭﻡ ﺗﺎﺑع ،ﺑﺮﺍﯼ ﺁﺭﮔﻮﻣﺎﻥ string2
ﻣﻘﺪﺍﺭ ﺗﻌﻴﻴﻦ ﻧﺸﺪﻩ ﺍﺳﺖ ،ﺑﻨﺎﺑﺮﺍﻳﻦ ﻣﻘﺪﺍﺭ ﭘﻴﺶﻓﺮﺽ ﺩﺭ ﻧﻈﺮ ﮔﺮﻓﺘﻪ ﻣیﺷﻮﺩ .ﻭ ﻋﺒﺎﺭﺕ »ﺁﻭﺍ ﺷﻴﺮﺍﺯﯼ« ﭼﺎﭖ ﺷﺪﻩ
ﺍﺳﺖ.
ﻣﺜﺎﻝ :۱ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻛﻠﻴﺪ ﻭﺍﮊﻩﻫﺎ
۳۷ ﺗﻮﺍﺑع ﺩﺭ ﭘﺎﻳﺘﻮﻥ.۳ ﻓﺼﻞ
In [1]: def student ( firstname , lastname ='Amini ', grade = 'Fifth '):
print ( firstname , lastname ,' studies in ',grade , 'Grade ')
# 1 keyword argument
student ( firstname ='Javad ')
# 2 keyword arguments
student ( firstname ='Javad ', grade =' Seventh ')
# 2 keyword arguments
student ( lastname =' Naseri ', firstname = 'Javad ')
Out[1]: Javad Amini studies in Fifth Grade
Javad Amini studies in Seventh Grade
Javad Naseri studies in Fifth Grade
. ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻛﻠﻴﺪ ﻭﺍﮊﻩﻫﺎ ﺑﻪ ﻧﺤﻮﻩ ﺍﺷﺘﺒﺎﻩ:۲ ﻣﺜﺎﻝ
In [2]: def student ( firstname , lastname ='Amini ', grade = 'Fifth '):
print ( firstname , lastname ,' studies in ',grade , 'Grade ')
# required argument missing
student ()
# 2 keyword arguments
student ( firstname ='Javad ', grade =' Seventh ')
# 2 keyword arguments
student ( lastname =' Naseri ', firstname = 'Javad ')
Out[2]: --------------------------------------------------------------------
TypeError
Traceback ( most recent call last )
Cell In [5] , line 5
2 print ( firstname , lastname , ' studies in ', grade , 'Grade ')
4 # 1 keyword argument
----> 5 student ()
7 # 2 keyword arguments
8 student ( firstname ='Javad ', grade =' Seventh ')
TypeError : student () missing 1 requiredpositionalargument :' firstname '
.۲-۳ﺗﻮﺍﺑع ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﻛﺎﺭﺑﺮ ۳۸
In [1]: def student ( firstname , lastname ='Amini ', grade = 'Fifth '):
)' print ( firstname , lastname ,' studies in ',grade , 'Grade
# 1 keyword argument
)' student ( firstname ='Javad
# non keyword argument after a keyword argument
)' student ( firstname ='Javad ', ' Seventh
# 2 keyword arguments
)' student ( lastname =' Naseri ', firstname = 'Javad
Out[1]: Cell In [7] , line 8
)' student ( firstname ='Javad ', ' Seventh
^
SyntaxError : positional argument follows keyword argument
ﺧﻄﺎﯼ ﻣﻮﺭﺩ ﺍﻭﻝ ﺍﻳﻦ ﺍﺳﺖ ﻛﻪ ﺗﺎﺑع ﺩﺭ ﺣﻴﻦ ﻓﺮﺍﺧﻮﺍﻧی ،ﻫﻴچ ﺁﺭﮔﻮﻣﺎﻧی ﻧﺪﺍﺭﺩ .ﻭ ﺑﺮﺍﯼ ﺁﺭﮔﻮﻣﺎﻥ firstnameﻧﻴﺰ ﺩﺭ
ﺗﻌﺮﻳﻒ ﺗﺎﺑع ﻣﻘﺪﺍﺭ ﭘﻴﺶﻓﺮﺽ ﻭﺟﻮﺩ ﻧﺪﺍﺭﺩ .ﺑﻨﺎﺑﺮﺍﻳﻦ ﺑﺎﻳﺪ ﺩﺭ ﻓﺮﺧﻮﺍﻧی ﺗﺎﺑع ،ﺑﺮﺍﯼ ﺁﻥ ﻣﻘﺪﺍﺭ ﻣﻌﻴﻦ ﻣیﺷﺪ.
ﺧﻄﺎﯼ ﻣﻮﺭﺩ ﺩﻭﻡ ﺍﻳﻦ ﺍﺳﺖ ﻛﻪ ﺗﺎﺑع ﺩﺭ ﺣﻴﻦ ﻓﺮﺍﺧﻮﺍﻧی ،ﺑﺎﻳﺪ ﻛﻠﻴﺪ ﻭﺍﮊﻩ gradeﺫﻛﺮ ﻣیﺷﺪ ،ﭼﺮﺍ ﻛﻪ ﺩﺭ ﺗﻌﺮﻳﻒ
ﺗﺎﺑع ،ﺁﺭﮔﻮﻣﺎﻥ ﺳﻮﻡ ﺩﺍﺭﺍﯼ ﻛﻠﻴﺪ ﻭﺍﮊﻩ ﺍﺳﺖ .ﻭ ﻧﻤیﺗﻮﺍﻥ ﺻﺮﻓ ًﺎ ﺑﻪ ﻣﻘﺪﺍﺭ ،ﺑﺴﻨﺪﻩ ﻧﻤﻮﺩ.
۱-۳-۲-۳ﺁﺭﮔﻮﻣﺎﻥﻫﺎﯼ ﺍﺧﺘﻴﺎﺭﯼ ﺗﺎﺑع print
ﺗﺎﺑع printﺩﺍﺭﺍﯼ ﺩﻭ ﺁﺭﮔﻮﻣﺎﻥ ﺍﺧﺘﻴﺎﺭﯼ ' '= sepﻭ ' end='\nﺍﺳﺖ .ﺁﺭﮔﻮﻣﺎﻥ ﺍﻭﻟی ﻋلاﻣﺘی ﺑﻴﻦ ﻋﻨﺎﺻﺮﯼ ﻛﻪ ﭼﺎﭖ
ﻣیﻛﻨﺪ ،ﻧﻤیﮔﺬﺍﺭﺩ .ﻳﻌﻨی ﭘﻴﺶﻓﺮﺽ ﺁﻥ ﺗﻬی ﺍﺳﺖ .ﺁﺭﮔﻮﻣﺎﻥ ﺩﻭﻣی ﻫﺮ ﺑﺎﺭ ﻛﻪ ﺗﺎﺑع printﻓﺮﺍﺧﻮﺍﻧﺪﻩ ﻣیﺷﻮﺩ ﻳﮏ
ﺳﻄﺮ ﺗﻌﻮﻳﺾ ﻣیﮔﺮﺩﺩ .ﻳﻌﻨی ﭘﻴﺶﻓﺮﺽ ﺁﻥ '\n' =new lineﺍﺳﺖ.
ﻣﺜﺎﻝ :۱
In [2]: )' print (' notebook ', ' pencil
)' print (' eraser
)print ('-'*25
)'' = print (' notebook ', ' pencil ',end
)' print (' eraser
Out[2]: notebook pencil
eraser
-------------------------
notebook pencil eraser
ﺩﺭ ﻗﺴﻤﺖ ﺩﻭﻡ ﻣﺜﺎﻝ ﺑﺎلا ﻫﺮ ﺳﻪ ﻭﺍﮊﻩ ﺩﺭ ﻳﮏ ﺳﻄﺮ ﻧﻮﺷﺘﻪ ﻣیﺷﻮﺩ ،ﺯﻳﺮﺍ ﻛﻨﺘﺮﻝ ﺑﻪ ﺳﻄﺮ ﺑﻌﺪﯼ ﻧﻤیﺭﻭﺩ .ﭼﺮﺍ ﻛﻪ
ﭘﻴﺶﻓﺮﺽ ﺁﺭﮔﻮﻣﺎﻥ endﺗﻐﻴﻴﺮ ﻛﺮﺩﻩ ﺍﺳﺖ.
ﻣﺜﺎﻝ :۲ﻋلاﻣﺖ ) ،(-ﺭﺷﺘﻪﻫﺎ ﺭﺍ ﺍﺯ ﻫﻢ ﻣﺠﺰﺍ ﻣیﻛﻨﺪ.
۳۹ ﻓﺼﻞ .۳ﺗﻮﺍﺑع ﺩﺭ ﭘﺎﻳﺘﻮﻥ
In [1]: )'print ('09 ','12 ','2021 ',sep = '-
Out[1]: 09 -12 -2021
ﻣﺜﺎﻝ :۳
In [2]: )'@' = print ('ava_ ', ' saremi ', sep = '' ,end
)' print ('gmail . com
Out[2]: ava_saremi@gmail . com
ﺁﺧﺮ ﭼﺎﭖ ﺳﻄﺮ ﺍﻭﻝ ﻋلاﻣﺖ @ ﻗﺮﺍﺭ ﻣیﮔﻴﺮﺩ ﻭ ﺳﭙﺲ ﺑﺪﻭﻥ ﺗﻌﻮﻳﺾ ﺳﻄﺮ ،ﺭﺷﺘﻪ ﺧﻂ ﺑﻌﺪﯼ ﻛﻨﺎﺭ ﺳﻄﺮ ﺍﻭﻝ ﭼﺎﭖ
ﻣیﺷﻮﺩ.
۴-۲-۳ﻣﺘﻐﻴﺮﻫﺎﯼ ﻣﺤﻠی ﻭ ﺟﻬﺎﻧی
ﺩﺭ ﺑﺪﻧﻪ ﺗﺎﺑع ﻣیﺗﻮﺍﻥ ﺳﻪ ﻧﻮع ﻣﺘﻐﻴﺮ ﺩﺍﺷﺖ.
.۱ﻣﺘﻐﻴﺮﻫﺎﻳﯽ ﻛﻪ ﺍﺯ ﻃﺮﻳﻖ ﺁﺭﮔﻮﻣﺎﻥﻫﺎ ﺑﻪ ﺗﺎﺑع ﻭﺭﻭﺩ ﭘﻴﺪﺍ ﻛﺮﺩﻩﺍﻧﺪ.
.۲ﻣﺘﻐﻴﺮﻫﺎﻳﯽ ﻛﻪ ﺩﺭﻭﻥ ﺗﺎﺑع ﻭﺟﻮﺩ ﺩﺍﺭﻧﺪ ﻭ ﺑﻴﺮﻭﻥ ﺍﺯ ﺁﻥ ﻣﻮﺟﻮﺩﻳﺘی ﻧﺪﺍﺭﻧﺪ ،ﻭ ﺑﻪ ﺁﻧﻬﺎ ﻣﺘﻐﻴﺮﻫﺎﯼ ﻣﺤﻠی ۱ﮔﻮﻳﻨﺪ.
.۳ﻣﺘﻐﻴﺮﻫﺎﻳﯽ ﻛﻪ ﺩﺭﻭﻥ ﺗﺎﺑع ﻭﺟﻮﺩ ﺩﺍﺭﻧﺪ ﻭ ﺑﻴﺮﻭﻥ ﺍﺯ ﺁﻥ ﻧﻴﺰ ﻣﻮﺟﻮﺩﻳﺖ ﺧﻮﺩ ﺭﺍ ﺣﻔﻆ ﻣی ﻛﻨﻨﺪ .ﺑﻪ ﺁﻧﻬﺎ ﻣﺘﻐﻴﺮﻫﺎﯼ
ﻛﻠی ،ﻋﻤﻮﻣی ﻭ ﻳﺎ ﺟﻬﺎﻧی ۲ﮔﻮﻳﻨﺪ.
لاﺯﻡ ﺑﻪ ﻳﺎﺩﺍﻭﺭﯼ ﺍﺳﺖ ﻛﻪ ﻫﺮ ﺗﺎﺑع ﻧﺒﺎﻳﺪ ﻟﺰﻭﻣﺎ ﺷﺎﻣﻞ ﻫﺮ ﺳﻪ ﻧﻮع ﻣﺘﻐﻴﺮ ﺑﺎﺷﺪ.
ﻣﺜﺎﻝ :۱
In [3]: x = 2
def g1(a ):
x1 = 3*a
)print ('x1:', x1
return x1
))print (g1 (1
)print (x
)print ('x1:', x1
1. local
2. global
.۲-۳ﺗﻮﺍﺑع ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﻛﺎﺭﺑﺮ ۴۰
Out[3]: x1: 3
3
2
--------------------------------------------------------------------
NameError
) Traceback ( most recent call last
Cell In [75] , line 8
))6 print (g1 (1
)7 print (x
)----> 8 print ('x1:', x1
NameError : name 'x1 ' is not defined
ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﻣﺸﺎﻫﺪﻩ ﻣیﺷﻮﺩ ﻣﺘﻐﻴﺮ ،x1ﻳﮏ ﻣﺘﻐﻴﺮ ﻣﺤﻠی ﺍﺳﺖ ﻭ ﻓﻘﻂ ﺩﺭﻭﻥ ﺗﺎﺑع g1ﻣﻘﺪﺍﺭ ﺩﺍﺭﺩ .ﺍﻣﺎ ﺑﻴﺮﻭﻥ
ﺍﺯ ﺁﻥ ﺩﺍﺭﺍﯼ ﻣﻘﺪﺍﺭﯼ ﻧﻴﺴﺖ ﻭ ﺑﻪ ﻫﻤﻴﻦ ﺳﺒﺐ ﺑﺮﻧﺎﻣﻪ ﺧﻄﺎ ﻣیﺩﻫﺪ .ﻣﺘﻐﻴﺮ aﺍﺯ ﻃﺮﻳﻖ ﺁﺭﮔﻮﻣﺎﻥ ﻭﺍﺭﺩ ﺑﺪﻧﻪ ﺗﺎﺑع ﺷﺪﻩ
ﺍﺳﺖ.
ﻣﺜﺎﻝ :۲
In [1]: x = 10
def f1 ():
x = 2
)print ('x in f1 ()= ', x
)( f1
)print (x
def f2 ():
x=3
)print ('x in f2 ()= ', x
)( f2
)print (x
Out[1]: x in f1 (): 2
10
x in f2 (): 3
10
ﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮ xﺍﺯ ﺗﺎﺑع )( f1ﺑﺮﺍﺑﺮ ۲ﺍﺳﺖ ﻭ ﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮ xﺍﺯ ﺗﺎﺑع )( f2ﺑﺮﺍﺑﺮ ۳ﺍﺳﺖ .ﺍﻣﺎ ﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮ ﺑﻪ ﺻﻮﺭﺕ
ﻋﻤﻮﻣی ﺩﺭ ﺳﺮﺍﺳﺮ ﺑﺮﻧﺎﻣﻪ ﺑﺮﺍﺑﺮ ۱۰ﺍﺳﺖ.
ﻣﺜﺎﻝ :۳
۴۱ ﻓﺼﻞ .۳ﺗﻮﺍﺑع ﺩﺭ ﭘﺎﻳﺘﻮﻥ
In [1]: x = 10
def f1 ():
global x
x = 2
)print ('x in f1 ()= ', x
)( f1
)print (x
def f2 ():
x=3
)print ('x in f2 ()= ', x
)( f2
)print (x
Out[1]: x in f1 ()= 2
2
x in f2 ()= 3
2
ﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮ ﻋﻤﻮﻣی xﺑﺮﺍﺑﺮ ۱۰ﺍﺳﺖ .ﺍﻣﺎ ﺩﺭ ﺩﺭﻭﻥ ﺗﺎﺑع )( f1ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻛﻠﻴﺪ ﻭﺍﮊﻩ globalﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮ
ﻋﻤﻮﻣی xﺑﺮﺍﺑﺮ ۲ﻣیﺷﻮﺩ.
ﻣﺜﺎﻝ :۴
In [2]: x = 10
def f1 ():
x = 2
)print ('x in f1 ()= ', x
)( f1
)print (x
def f2 ():
global x
x=3
)print ('x in f2 ()= ', x
)( f2
)print (x
Out[2]: x in f1 ()= 2
10
x in f2 ()= 3
3
ﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮ ﻋﻤﻮﻣی xﺑﺮﺍﺑﺮ ۱۰ﺍﺳﺖ .ﺍﻣﺎ ﺩﺭ ﺩﺭﻭﻥ ﺗﺎﺑع )( f1ﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮ ﻋﻤﻮﻣی ﻋﻮﺽ ﻧﻤیﺷﻮﺩ .ﭘﺲ ﺳﻄﺮ
ﺩﻭﻡ ﺧﺮﻭﺟی ﺑﺮﺍﺑﺮ ۱۰ﺍﺳﺖ .ﺍﻣﺎ ﺩﺭ ﺗﺎﺑع )( f2ﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮ ﻋﻤﻮﻣی ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻛﻠﻴﺪ ﻭﺍﮊﻩ globalﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮ
ﻋﻤﻮﻣی xﺑﺮﺍﺑﺮ ۳ﻣیﺷﻮﺩ.
ﻣﺜﺎﻝ :۵
.۲-۳ﺗﻮﺍﺑع ﺗﻌﺮﻳﻒ ﺷﺪﻩ ﻛﺎﺭﺑﺮ ۴۲
In [1]: x = 10
def f1 ():
global x
x = 2
)print ('x in f1 ()= ', x
)( f1
)print (x
def f2 ():
global x
x=3
)print ('x in f2 ()= ', x
)( f2
)print (x
Out[1]: x in f1 ()= 2
2
x in f2 ()= 3
3
ﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮ ﻋﻤﻮﻣی xﺑﺮﺍﺑﺮ ۱۰ﺍﺳﺖ .ﺍﻣﺎ ﺩﺭ ﺩﺭﻭﻥ ﺗﺎﺑع )( f1ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻛﻠﻴﺪ ﻭﺍﮊﻩ globalﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮ
ﻋﻤﻮﻣی xﺑﺮﺍﺑﺮ ۲ﻣیﺷﻮﺩ .ﺳﭙﺲ ﺩﺭ ﺩﺭﻭﻥ ﺗﺎﺑع )( f2ﻣﺠﺪﺩ ًﺍ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻛﻠﻴﺪ ﻭﺍﮊﻩ globalﻣﻘﺪﺍﺭ ﻣﺘﻐﻴﺮ ﻋﻤﻮﻣی
xﻋﻮﺽ ﺷﺪﻩ ﻭ ﺑﺮﺍﺑﺮ ۳ﻣیﺷﻮﺩ.
���
۴
ﺩﺍﺩﻩ ﺳﺎﺧﺘﺎﺭﻫﺎ
۱-۴ﻣﻘﺪﻣﻪ
ﺩﺭ ﻓﺼﻞ ﺍﻭﻝ ﺩﻳﺪﻳﻢ ﻛﻪ ﺩﺍﺩﻩﻫﺎ ﺍﻧﻮﺍﻉ ﮔﻮﻧﺎﮔﻮﻥ ﺩﺍﺭﻧﺪ .ﻋﺪﺩﯼ ﻭ ﻏﻴﺮ ﻋﺪﺩﯼ .ﻫﺮ ﻳﮏ ﺍﺯ ﺁﻧﻬﺎ ﻧﻴﺰ ﺑﻪ ﺍﻧﻮﺍﻉ ﻛﻮﭼﻜﺘﺮﯼ
ﺗﻘﺴﻴﻢ ﻣیﺷﺪﻧﺪ.
ﺩﺍﺩﻩﻫﺎ ﺑﺎ ﻫﻢ ﻭ ﺩﺭ ﻛﻨﺎﺭ ﻫﻢ ،ﻣیﺗﻮﺍﻧﻨﺪ ﺳﺎﺧﺘﺎﺭﻫﺎ ﻭ ﻳﺎ ﺳﺎﺧﺘﻤﺎﻥﻫﺎﯼ ﻣﺘﻔﺎﻭﺗی ﺭﺍ ﺗﺸﻜﻴﻞ ﺩﻫﻨﺪ .ﺍﻧﻮﺍﻉ ﺁﻧﻬﺎ ﺑﻪ ﺷﺮح
ﺯﻳﺮ ﺍﺳﺖ.
ﻟﻴﺴﺖ ۱ .۱
ﺭﺷﺘﻪ ۲ .۲
ﺗﺎﭘﻞ ۳ .۳
ﺩﻳﻜﺸﻨﺮﯼ ۴ .۴
ﻣﺠﻤﻮﻋﻪ ۵ .۵
ﺩﺭ ﺍﻳﻦ ﻓﺼﻞ ﺑﻪ ﺗﻔﺼﻴﻞ ﺁﻧﻮﺍﻉ ﺑﺎلا ﭘﺮﺩﺍﺧﺘﻪ ﻣیﺷﻮﺩ.
1. List
2. String
3. Tuple
4. Dictionary
5. Set
۴۳
.۲-۴ﻟﻴﺴﺖ ۴۴
۲-۴ﻟﻴﺴﺖ
ﻟﻴﺴﺖ ،ﺩﺍﺩﻩﺍﯼ ﺍﺳﺖ ﻛﻪ ﺷﺎﻣﻞ ﺩﻧﺒﺎﻟﻪﺍﯼ ﺍﺯ ﭼﻨﺪ ﺩﺍﺩﮤ ﻣﺮﺗﺐ ﺷﺪﻩ ﺍﺳﺖ .ﻟﻴﺴﺖ ﺑﺎ ﺑﺮﺍﻛﺖ ﺑﺎﺯ ،ﺷﺮﻭع ﻣیﺷﻮﺩ ﻭ ﺑﺎ
ﺑﺮﺍﻛﺖ ﺑﺴﺘﻪ ،ﺧﺎﺗﻤﻪ ﻣیﻳﺎﺑﺪ .ﻣﻘﺎﺩﻳﺮ ﻣﻮﺭﺩ ﻧﻈﺮ ﺩﺭﻭﻥ ﺑﺮﺍﻛﺖﻫﺎ ﻗﺮﺍﺭ ﻣیﮔﻴﺮﻧﺪ ﻭ ﺑﺎ ﻛﺎﻣﺎ ﺍﺯ ﻳﻜﺪﻳﮕﺮ ﺟﺪﺍ ﻣیﺷﻮﻧﺪ.
ﺑﺮﺍﯼ ﻣﺜﺎﻝ ﺑﻪ ﻣﻮﺍﺭﺩ ﺯﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ.
][1 ,2 ,3
] ' [ ' cat ' , ' bat ' , ' rat ' , ' elephant
] [ ' h e l l o ' , 3 . 1 4 , True , None , 4 2
ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﻣﺸﺎﻫﺪﻩ ﺷﺪ ،ﻟﻴﺴﺖ ﺩﺭﺑﺮﮔﻴﺮﻧﺪﻩ ﺍﻧﻮﺍﻉ ﻣﻘﺎﺩﻳﺮ ﺍﺳﺖ ﻭ ﺩﺭ ﺍﻳﻦ ﺧﺼﻮﺹ ﻣﺤﺪﻭﺩﻳﺘی ﻧﺪﺍﺭﺩ.
۱-۲-۴ﺩﺳﺘﺮﺳی ﺑﻪ ﻣﻘﺎﺩﻳﺮ ﻟﻴﺴﺖ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺍﻧﺪﻳﺲ
ﺑﺮﺍﯼ ﺩﺳﺘﺮﺳی ﺑﻪ ﻣﻘﺎﺩﻳﺮ ﻳﮏ ﻟﻴﺴﺖ ﻣیﺗﻮﺍﻥ ﺍﺯ ﺷﻤﺎﺭﻩ ﻳﺎ ﺍﻧﺪﻳﺲ ۱ﺁﻥ ﺍﺳﺘﻔﺎﺩﻩ ﻧﻤﻮﺩ ﻛﻪ ﻣﻮﻗﻌﻴﺖ ﺁﻧﻬﺎ ﺭﺍ ﺩﺭ ﻟﻴﺴﺖ
ﻧﺸﺎﻥ ﻣیﺩﻫﺪ .ﺑﻪ ﺷﻜﻞ ﺯﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ.
9 5 'cat' 19 12 8 True 4 21 4.2
][0 ][1 ][2 ][3 ][4 ][5 ][6 ][7 ][8 ][9
ﺍﮔﺮ ﻟﻴﺴﺖ ﺑﺎلا ﺭﺍ ﺑﻪ ﻣﺘﻐﻴﺮﯼ ﺑﻪ ﻧﺎﻡ Xﻧﺴﺒﺖ ﺩﻫﻴﻢ ،ﺧﻮﺍﻫﻴﻢ ﺩﺍﺷﺖ.
In [1]: ]X=[9 ,5 , 'cat ' ,19 ,12 ,8 , True ,4 ,21 ,4.2
)]print (X [0] ,X[2] ,X[6] ,X [9
Out[1]: 9 cat True 4.2
ﺍﻛﻨﻮﻥ ﻣﻘﺪﺍﺭ ] X[10ﺭﺍ ﻣﺤﺎﺳﺒﻪ ﻣیﻛﻨﻴﻢ.
In [2]: ]X=[9 ,5 , 'cat ' ,19 ,12 ,8 , True ,4 ,21 ,4.2
)]print (X [0] ,X[2] ,X[6] ,X [9
)]print (X [10
1. Index
۴۵ ﺩﺍﺩﻩ ﺳﺎﺧﺘﺎﺭﻫﺎ.۴ ﻓﺼﻞ
Out[2]: 9 cat True 4.2
---------------------------------------------------------
IndexError Traceback ( most recent call last )
Cell In [2] , line 3
1 X=[9 ,5 , 'cat ' ,19 ,12 ,8 , True ,4 ,21 ,4.2]
2 print (X[0] ,X[2] ,X[6] ,X [9])
----> 3 print (X [10])
IndexError : list index out of range
ﭼﻮﻥ ﺍﻧﺪﻳﺲ ﺩﻫﻢ ﺧﺎﺭج ﺍﺯ ﻣﺤﺪﻭﺩﻩ، ﺧﻄﺎ ﻣیﺩﻫﺪX[10] ﺍﺟﺮﺍﯼ ﺑﺮﻧﺎﻣﻪ ﺯﻭﯼ،ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﻣﺸﺎﻫﺪﻩ ﻣیﺷﻮﺩ
.ﺍﻧﺪﻳﺲﻫﺎ ﺍﺳﺖ
ﺍﺟﺮﺍﯼ ﺑﺮﻧﺎﻣﻪ ﺑﺎ،ﺍﻧﺪﻳﺲﻫﺎ ﺑﺎﻳﺪ ﺗﻨﻬﺎ ﻋﺪﺩ ﺻﺤﻴح ﺑﺎﺷﻨﺪ ﻭ ﭼﻨﺎﻧﭽﻪ ﺍﺯ ﺍﻋﺪﺍﺩ ﺍﻋﺸﺎﺭﯼ ﻳﺎ ﻫﺮ ﻧﻮع ﺩﻳﮕﺮ ﺍﺳﺘﻔﺎﺩﻩ ﺷﻮﺩ
.ﺧﻄﺎ ﺗﻮﺍﻡ ﺍﺳﺖ
In [1]: X=[9 ,5 , 'cat ' ,19 ,12 ,8 , True ,4 ,21 ,4.2]
print (X [0] ,X[2] ,X[6] ,X [9])
print (X [1.0])
Out[1]: 9 cat True 4.2
---------------------------------------------------------
IndexError Traceback ( most recent call last )
Cell In [1] , line 3
1 X=[9 ,5 , 'cat ' ,19 ,12 ,8 , True ,4 ,21 ,4.2]
2 print (X[0] ,X[2] ,X[6] ,X [9])
----> 3 print (X [1.0])
TypeError : list indices must be integers or slices , not float
. ﻣیﺗﻮﺍﻥ ﺧﻄﺎﯼ ﺑﺎلا ﺭﺍ ﺍﺻلاﺡ ﻛﺮﺩint() ﺑﺎ ﺗﺎﺑع
In [2]: X=[9 ,5 , 'cat ' ,19 ,12 ,8 , True ,4 ,21 ,4.2]
print (X [0] ,X[2] ,X[6] ,X [9])
print (X[ int (1.0)])
Out[2]: 9 cat True 4.2
5
.ﻋﻨﺎﺻﺮ ﻳﮏ ﻟﻴﺴﺖ ﺧﻮﺩ ﻣیﺗﻮﺍﻧﺪ ﻟﻴﺴﺖ ﺑﺎﺷﻨﺪ
In [3]: spam =[[ 'cat ','bat '] ,[10 ,20 ,30 ,40 ,50]]
print ( spam [0])
print ( spam [0][1])
print ( spam [1][4])
.۲-۴ﻟﻴﺴﺖ ۴۶
Out[3]: ]' ['cat ','bat
bat
50
ﺍﮔﺮ ﺍﺯ ﻳﮏ ﺍﻧﺪﻳﺲ ﺍﺳﺘﻔﺎﺩﻩ ﺷﻮﺩ ،ﻛﻞ ﻳﮏ ﻟﻴﺴﺖ ﺩﺍﺧﻠی ﺭﺍ ﻧﺸﺎﻥ ﻣیﺩﻫﺪ .ﻭ ﺍﮔﺮ ﺍﺯ ﺩﻭ ﺍﻧﺪﻳﺲ ﺍﺳﺘﻔﺎﺩﻩ ﺷﻮﺩ ﺍﻭﻟی
ﻟﻴﺴﺖ ﺩﺍﺧﻠی ﺭﺍ ﻧﺸﺎﻥ ﻣیﺩﻫﺪ ﻭ ﺩﻭﻣی ﻋﻨﺼﺮ ﺩﺍﺧﻞ ﺁﻥ ﺭﺍ ﻧﺸﺎﻥ ﻣیﺩﻫﺪ.
ﺍﻧﺪﻳﺲ ﻣﻨﻔی ۱-۱-۲-۴
ﺑﻪ ﻃﻮﺭ ﻛﻠی ﺍﻧﺪﻳﺲ ﺍﺯ ﺻﻔﺮ ﺷﺮﻭع ﺷﺪﻩ ﻭ ﺍﻓﺰﺍﻳﺶ ﻣیﻳﺎﺑﺪ .ﺍﮔﺮ ﺍﺯ ﺍﻋﺪﺍﺩ ﺻﺤﻴح ﻣﻨﻔی ﺍﺳﺘﻔﺎﺩﻩ ﺷﻮﺩ ،ﻣﻘﺪﺍﺭ ﺍﻧﺪﻳﺲ
،-1ﺁﺧﺮﻳﻦ ﻋﻨﻀﺮ ﻟﻴﺴﺖ ﺭﺍ ﻧﺸﺎﻥ ﻣیﺩﻫﺪ ﻭ ﺍﻧﺪﻳﺲ ،-2ﻋﻨﺼﺮ ﻳﻜی ﻣﺎﻧﺪﻩ ﺑﻪ ﺁﺧﺮ ،ﻗﺎﺑﻞ ﺩﺳﺘﺮﺳی ﺍﺳﺖ .ﺑﻪ ﺷﻜﻞ
ﺯﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ.
9 5 13 19 12 8 7 4 21 2
][−10] [−9 ][−8 ][−7 ][−6 ][−5 ][−4 ][−3 ][−2 ][−1
][0 ][1 ][2 ][3 ][4 ][5 ][6 ][7 ][8 ][9
ﻣﺜﺎﻝ:
In [1]: ]' spam =[ 'cat ','bat ','rat ',' elephant
)]print ( spam [ -1
)]print ( spam [ -3
Out[1]: elephant
bat
ﺯﻳﺮﻟﻴﺴﺖﻫﺎ ﻭ ﺑﺮﺵ ۲-۱-۲-۴
ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻳﮏ ﺍﻧﺪﻳﺲ ﺩﺳﺘﺮﺳی ﺑﻪ ﻳﮏ ﻣﻘﺪﺍﺭ ﺍﺯ ﻟﻴﺴﺖ ﺭﺍ ﺍﻳﺠﺎﺩ ﻣیﻛﻨﺪ .ﺑﺮﺵ ۱ﺩﺳﺘﺮﺳی ﺑﻪ ﭼﻨﺪ ﻣﻘﺪﺍﺭ ﺍﺯ ﻳﮏ
ﻟﻴﺴﺖ ﺭﺍ ﻓﺮﺍﻫﻢ ﻣیﺳﺎﺯﺩ ،ﻛﻪ ﺑﻪ ﺁﻥ ﺯﻳﺮﻟﻴﺴﺖ ﻫﻢ ﻣی ﮔﻮﻳﻨﺪ .ﺑﺮﺵﻫﺎ ﺩﺭﻭﻥ ﺑﺮﺍﻛﺖ ﻧﻮﺷﺘﻪ ﻣیﺷﻮﻧﺪ ﻭ ﺑﺎ ﺩﻭ ﻣﻘﺪﺍﺭ
ﺻﺤﻴح ﻛﻪ ﺑﺎ ﻋلاﻣﺖ ) (:ﺍﺯ ﻫﻢ ﺟﺪﺍ ﻣیﺷﻮﻧﺪ ،ﻣﺸﺨﺺ ﻣیﮔﺮﺩﺩ .ﻣﺜﺎﻝ:
In [2]: ]' spam =[ 'cat ','bat ','rat ',' elephant
)]print ( spam [0:4
)]print ( spam [1:3
)]print ( spam [0: -1
Out[2]: ]' ['cat ','bat ','rat ',' elephant
]' ['bat ','rat
]' ['cat ','bat ','rat
1. slice
۴۷ ﻓﺼﻞ .۴ﺩﺍﺩﻩ ﺳﺎﺧﺘﺎﺭﻫﺎ
ﻗﺮﻣﻮﻝ ﻛﻠی ﺑﺮﺵ ﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﺍﺳﺖ:
] [ s t a r t : end : s t e p
ﺷﺮﻭع ﺑﺮﺵ ﺑﺎ startﻭ ﺧﺎﺗﻤﻪ ﺁﻥ ﺑﺎ endﺍﺳﺖ .ﮔﺎﻡ ﺭﻓﺘﻦ ﺍﺯ ﺷﺮﻭع ﺗﺎ ﺧﺎﺗﻤﻪ ﺑﺎ ﺍﻧﺪﺍﺯﻩ stepﺭﻗﻢ ﻣیﺧﻮﺭﺩ .ﻣﻘﺎﺩﻳﺮ
ﭘﻴﺶﻓﺮﺽ ﻫﺮ ﻳﮏ ﺍﺯ ﺍﺟﺮﺍﺀ ﺑﺎلا ﻳﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﺍﺳﺖ.
• ﺷﺮﻭع ﺑﺮﺵ ،ﻋﻨﺼﺮ ﺍﻭﻝ ﻟﻴﺴﺖ ﺍﺳﺖ.
• ﺧﺎﺗﻤﻪ ﺑﺮﺵ ،ﻋﻨﺼﺮ ﭘﺎﻳﺎﻧی ﻟﻴﺴﺖ ﺍﺳﺖ.
• ﮔﺎﻡ ﺑﺮﺵ ،ﺑﺮﺍﺑﺮ ﻭﺍﺣﺪ ﺍﺳﺖ.
ﻣﺜﺎﻝ:
In [1]: ]lst =[5.5 ,2 ,3 ,10 ,1.5
)]print ( lst [:2
)]print ( lst [1:
)]print ( lst [:4:2
)]print ( lst [::2
)]print ( lst [4:1: -1
)]print ( lst [1: -1:2
Out[1]: ][5.5 , 2
][2 , 3, 10 , 1.5
][5.5 , 3
][5.5 , 3, 1.5
][1.5 , 10 , 3
][2 , 10
ﺗﻐﻴﻴﺮ ﻣﻘﺎﺩﻳﺮ ﻟﻴﺴﺖ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺍﻧﺪﻳﺲﻫﺎ ۳-۱-۲-۴
ﻫﺮ ﺩﺍﺩﻩ ﻳﮏ ﻟﻴﺴﺖ ﺭﺍ ﻣیﺗﻮﺍﻥ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺍﻧﺪﻳﺲ ﺁﻥ ﺩﺍﺩﻩ ﺗﻐﻴﻴﺮ ﺩﺍﺩ .ﻣﺜل ًا ’ spam[1]=’dogﺑﻨﺎﺑﺮﺍﻳﻦ ﻋﻀﻮ
ﺍﻭﻝ ﻟﻴﺴﺖ ﺗﻐﻴﻴﺮ ﻣﻘﺪﺍﺭ ﭘﻴﺪﺍ ﻣیﻛﻨﺪ .ﻣﺜﺎﻝ:
In [2]: ]' spam =[ 'cat ','bat ','rat ',' elephant
' spam [1]= 'dog
) print ( spam
]spam [2]= spam [1
) print ( spam
spam [ -1]=12.5
) print ( spam
Out[2]: ]' ['cat ', 'dog ', 'rat ', ' elephant
]' ['cat ', 'dog ', 'dog ', ' elephant
]['cat ', 'dog ', 'dog ', 12.5
.۲-۴ﻟﻴﺴﺖ ۴۸
ﺟﻤﻊ ﻭ ﺿﺮﺏ ﺩﺭ ﻟﻴﺴﺖﻫﺎ ۴-۱-۲-۴
ﻋﻤﻠﮕﺮ ) (+ﺑﻴﻦ ﺩﻭ ﻟﻴﺴﺖ ،ﻟﻴﺴﺖ ﺟﺪﻳﺪﯼ ﺍﺯ ﺗﺮﻛﻴﺐ ﺩﻭ ﻟﻴﺴﺖ ﺑﺪﺳﺖ ﻣیﺩﻫﺪ .ﻋﻤﻠﮕﺮ )∗( ﺑﻴﻦ ﻳﮏ ﻟﻴﺴﺖ ﻭ
ﻳﮏ ﻋﺪﺩ ﺻﺤﻴح ﺑﺎﻋﺚ ﻣیﺷﻮﺩ ﻛﻪ ﻟﻴﺴﺖ ﺟﺪﻳﺪﯼ ﺑﺎ ﺗﻜﺮﺍﺭ ﺑﺪﺳﺖ ﺁﻳﺪ .ﻣﺜﺎﻝ:
In [1]: )]'print ([1 ,2 ,3]+[ 'A','B','c
)print ([ 'x','y','z']*3
Out[1]: ]'[1 , 2, 3, 'A', 'B', 'c
]'['x ', 'y', 'z', 'x', 'y', 'z', 'x', 'y', 'z
۲-۲-۴ﺍﻓﺰﻭﺩﻥ ﻋﻨﺎﺻﺮ ﺟﺪﻳﺪ ﺑﻪ ﻟﻴﺴﺖ
ﻟﻴﺴﺘی ﺭﺍ ﺳﺎﺧﺘﻪ ﺷﺪﻩ ﺍﺳﺖ .ﺍﻛﻨﻮﻥ ﻗﺼﺪ ﺩﺍﺭﻳﻢ ﻛﻪ ﻋﻀﻮﻫﺎﯼ ﺟﺪﻳﺪﯼ ﺭﺍ ﺑﻪ ﺁﻥ ﺍﺿﺎﻓﻪ ﻛﻨﻴﻢ .ﻣﺜلا ﻟﻴﺴﺖ ﺍﺳﺎﻣی
ﺩﺍﻧﺸﺠﻮﻳﺎﻥ ﻳﮏ ﻛلاﺱ ﺭﺍ ﺩﺍﺭﻳﻢ ،ﺍﻣﺎ ﭼﻨﺪ ﺩﺍﻧﺸﺠﻮ ﺑﺎ ﺗﺎﺧﻴﺮ ﺛﺒﺖﻧﺎﻡ ﻛﺮﺩﻩﺍﻧﺪ .ﺑﺮﺍﯼ ﺍﻓﺰﻭﺩﻥ ﭼﻨﺪ ﻧﻔﺮ لاﺯﻡ ﻧﻴﺴﺖ
ﻛﻪ ﺍﺯ ﻧﻮ ﻟﻴﺴﺖ ﺩﺍﻧﺸﺠﻮﻳﺎﻥ ﺭﺍ ﺑﺴﺎﺯﻳﻢ ،ﺑﻠﻜﻪ ﺍﺳﺎﻣی ﻫﻤﺎﻥ ﭼﻨﺪ ﻧﻔﺮ ﺭﺍ ﺑﻪ ﻟﻴﺴﺖ ﻣﻮﺟﻮﺩ ﺍﺿﺎﻓﻪ ﻣیﻛﻨﻴﻢ.
ﺑﺮﺍﯼ ﺍﺿﺎﻓﻪ ﻧﻤﻮﺩﻥ ﺍﻋﻀﺎﯼ ﺟﺪﻳﺪ ﺑﻪ ﻳﮏ ﻟﻴﺴﺖ ﺭﺍﻩﻫﺎﯼ ﮔﻮﻧﺎﮔﻮﻧی ﻭﺟﻮﺩ ﺩﺍﺭﺩ.
.۱ﺭﻭﺵ :appendﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﻋﻀﻮ ﺟﺪﻳﺪ ﻓﻘﻂ ﺑﻪ ﺍﻧﺘﻬﺎﯼ ﻟﻴﺴﺖ ﺍﺿﺎﻓﻪ ﻣیﺷﻮﺩ ﻭ ﺿﻤﻨ ًﺎ ﻫﺮ ﺑﺎﺭ ﺍﺳﺘﻔﺎﺩﻩ
ﺍﺯ ﺍﻳﻦ ﺭﻭﺵ ﺗﻨﻬﺎ ﻳﮏ ﻋﻀﻮ ﺍﺿﺎﻓﻪ ﻣیﺷﻮﺩ .ﻣﺜﺎﻝ:
In [2]: ][= lst
)' lst . append ('hadi
)'&'( lst . append
)' lst . append ('hoda
) print ( lst
Out[2]: ]' ['ava ', 'ali ', 'reza ','shiva
ﺭﻭﺵ appendﻣیﺗﻮﺍﻧﺪ ﻳﮏ ﻟﻴﺴﺖ ﻛﺎﻣل ًا ﭘﻮﻳﺎ ﺍﻳﺠﺎﺩ ﻛﻨﺪ .ﺑﻪ ﻋﻨﻮﺍﻥ ﻣﺜﺎﻝ ﺍﺯ ﻳﮏ ﻟﻴﺴﺖ ﺧﺎﻟی ﺷﺮﻭع ﻣی
ﻛﻨﻴﻢ ﻭ ﺍﻋﻀﺎﯼ ﻟﻴﺴﺖ ﺭﺍ ﻛﻨﺎﺭ ﻫﻢ ﻣیﭼﻴﻨﻴﻢ.
In [3]: ][= lst
)' lst . append ('hadi
)'&'( lst . append
)' lst . append ('hoda
) print ( lst
Out[3]: ]' ['hadi ', '&', 'hoda
ﺍﻓﺰﻭﺩﻥ ﺑﻪ ﺷﻜﻞ ﺑﺎلا ﺑﻮﺳﻴﻠﻪ ﺣﻠﻘﻪ whileﻫﻢ ﺍﻣﻜﺎﻥ ﭘﺬﻳﺮ ﺍﺳﺖ .ﻳﻌﻨی ﻳﮏ ﺗﻌﺪﺍﺩ ﺍﺳﻢ ﺑﻪ ﻟﻴﺴﺖ ﺍﺿﺎﻓﻪ
ﻣیﺷﻮﺩ .ﻭ ﺑﻪ ﻣﺤﺾ ﺍﻳﻦ ﻛﻪ ﻭﺭﻭﺩ ﺍﺳﺎﻣی ﭘﺎﻳﺎﻥ ﻳﺎﻓﺖ .ﻛﻠﻴﺪ Enterﺯﺩﻩ ﻣیﺷﻮﺩ ،ﻛﻪ ﺩﺭ ﻭﺍﻗﻊ ﻳﮏ ﺭﺷﺘﻪ
ﺧﺎﻟی ﻭﺍﺭﺩ ﻣیﮔﺮﺩﺩ ﻛﻪ ﺧﺘﻢ ﺣﻠﻘﻪ ﺭﺍ ﺑﺎﻋﺚ ﻣیﺷﻮﺩ.
۴۹ ﻓﺼﻞ .۴ﺩﺍﺩﻩ ﺳﺎﺧﺘﺎﺭﻫﺎ
In [1]: ][= lst
name =0
while name != '':
)'name = input ('Enter name :
if name == '':
break
) lst . append ( name
) print ( lst
Out[1]: Enter name : ava
Enter name : hoda
Enter name : hadi
Enter name : reza
Enter name :
]' ['ava ', 'hoda ', 'hadi ', 'reza
.۲ﺭﻭﺵ insertﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﻳﮏ ﻋﻀﻮ ﻣیﺗﻮﺍﻧﺪ ﻛﻪ ﺩﺭ ﻣﺤﻞ ﺩﻟﺨﻮﺍﻩ ﺑﻪ ﻟﻴﺴﺖ ﺷﻤﺎ ﺍﺿﺎﻓﻪ ﻣیﺷﻮﺩ .ﺩﺭ
ﺍﻳﻨﺠﺎ ﺍﺯ ﺩﻭ ﭘﺎﺭﺍﻣﺘﺮ ﺍﺳﺘﻔﺎﺩﻩ ﻣیﺷﻮﺩ .ﺍﻭﻟی ﺍﻧﺪﻳﺲ ﻣﺤﻞ ﺍﺳﺖ ﻭ ﺩﻳﮕﺮﯼ ﻧﺎﻡ ﻋﻀﻮﯼ ﺍﺳﺖ ﻛﻪ ﻣیﺧﻮﺍﻫﻴﺪ
ﺍﺿﺎﻓﻪ ﺷﻮﺩ .ﺑﻪ ﻋﻨﻮﺍﻥ ﻣﺜﺎﻝ ﻣیﺧﻮﺍﻫﻴﻢ ﺑﻪ ﻟﻴﺴﺖ ﻣﺜﺎﻝ ﻗﺒﻞ ﻧﺎﻡ shivaﺩﺭ ﺍﻧﺪﻳﺲ ﻳﮏ ﻗﺮﺍﺭ ﮔﻴﺮﺩ.
In [2]: ]' students =[ 'ava ','ali ','reza
)' students . insert (1 , 'shiva
) print ( students
Out[2]: ]' ['ava ', 'shiva ', 'ali ', 'reza
ﺣﺬﻑ ﺍﻋﻀﺎﯼ ﻟﻴﺴﺖ ۳-۲-۴
ﮔﺎﻫی ﺍﻭﻗﺎﺕ لاﺯﻡ ﺍﺳﺖ ﻛﻪ ﻋﻨﺎﺻﺮﯼ ﺍﺯ ﻟﻴﺴﺘی ﺣﺬﻑ ﺷﻮﺩ .ﺑﻪ ﻋﻨﻮﺍﻥ ﻣﺜﺎﻝ ﻳﮏ ﻳﺎ ﭼﻨﺪ ﺩﺍﻧﺸﺠﻮ ،ﻣیﺧﻮﺍﻫﻨﺪ
ﺩﺭﺱ ﺧﺎﺻی ﺭﺍ ﺣﺬﻑ ﻛﻨﻨﺪ .ﺑﻨﺎﺑﺮﺍﻳﻦ ﺑﺎﻳﺪ ﺑﺪﻭﻥ ﺑﺎﺯﻧﻮﻳﺴی ﻟﻴﺴﺖ ﻣﻮﺟﻮﺩ ﺑﺘﻮﺍﻥ ﺍﺳﺎﻣی ﻳﮏ ﻳﺎ ﺟﻨﺪ ﻧﻔﺮ ﺭﺍ ﺍﺯ ﻟﻴﺴﺖ
ﺁﻥ ﻛلاﺱ ﺣﺬﻑ ﻛﺮﺩ.
ﺑﺮﺍﯼ ﺣﺬﻑ ﻧﻤﻮﺩﻥ ﺍﻋﻀﺎﯼ ﻳﮏ ﻟﻴﺴﺖ ﺭﺍﻩﻫﺎﯼ ﮔﻮﻧﺎﮔﻮﻧی ﻭﺟﻮﺩ ﺩﺍﺭﺩ.
.۱ﻓﺮﻣﺎﻥ :delﺑﺎ ﺍﻳﻦ ﻣیﺗﻮﺍﻥ ﻳﮏ ﻋﻀﻮ ﻟﻴﺴﺖ ﻳﺎ ﺑﺮﺷی ﺍﺯ ﺁﻥ ﺭﺍ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺍﻧﺪﻳﺲ)ﻫﺎ( ،ﺣﺬﻑ ﻧﻤﻮﺩ .ﻣﺜﺎﻝ:
In [3]: ]' students =[ 'ava ','ali ','reza ', 'hoda ',' hooman ','hadi
]del students [2
) print ( students
Out[3]: ]' ['ava ', 'ali ', 'hoda ', ' hooman ', 'hadi
ﻣیﺗﻮﺍﻥ ﻳﮏ ﺑﺮﺷی ﺍﺯ ﻟﻴﺴﺖ ﺭﺍ ﺣﺬﻑ ﻛﺮﺩ.
ﻟﻴﺴﺖ.۲-۴ ۵۰
In [1]: students =[ 'ava ','ali ','reza ', 'hoda ',' hooman ','hadi ']
del students [1:4]
print ( students )
Out[1]: ['ava ', ' hooman ', 'hadi ']
. ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﺑﺎﻳﺪ ﺍﺯ ﻣﻘﺪﺍﺭ ﻋﻀﻮ ﺑﺮﺍﯼ ﭘﺎﺭﺍﻣﺘﺮ ﺍﺳﺘﻔﺎﺩﻩ ﻧﻤﻮﺩ:remove ﺭﻭﺵ.۲
In [2]: students =[ 'ava ','ali ','reza ', 'hoda ',' hooman ','hadi ']
students . remove ('hoda ')
print ( students )
Out[2]: ['ava ', 'ali ', 'reza ', ' hooman ', 'hadi ']
ﺿﻤﻨ ًﺎ ﺍﮔﺮ ﺩﺭ ﻟﻴﺴﺖ ﺑﺎلا. ﻗﻘﻂ ﻳﮏ ﻋﻀﻮ ﺭﺍ ﻣیﺗﻮﺍﻥ ﺣﺬﻑ ﻛﺮﺩ، ﺩﺭ ﻫﺮ ﺑﺎﺭ ﺍﺳﺘﻔﺎﺩﻩ، ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ:ﺗﻮﺟﻪ
. ﻓﻘﻂ ﺍﻭﻟﻴﻦ ﺁﻧﻬﺎ ﺣﺬﻑ ﻣیﺷﻮﺩ ﻭ ﺑﻘﻴﻪ ﻣﻮﺭﺩ ﻭ ﻳﺎ ﻣﻮﺍﺭﺩ ﻣﺸﺎﺑﻪ ﺑﺎﻗی ﻣیﻣﺎﻧﺪ. ﺑﻮﺩhoda ﺩﻭ ﺗﺎ ﻧﺎﻡ
ﺑﻪ ﺷﺮﻁ ﺁﻥ ﻛﻪ ﭘﺎﺭﺍﻣﺘﺮﯼ )ﺑﺪﻭﻥ ﺫﻛﺮ. ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﺁﺧﺮﻳﻦ ﻋﻀﻮ ﻟﻴﺴﺖ ﺣﺬﻑ ﻣیﺷﻮﺩ:pop ﺭﻭﺵ.۳
: ﻣﺜﺎﻝ. ﺿﻤﻨ ًﺎ ﺍﻳﻦ ﺭﻭﺵ ﻣﻘﺪﺍﺭ ﻋﻀﻮ ﺣﺬﻑ ﺷﺪﻩ ﺭﺍ ﺑﺮﮔﺮﺩﺍﻧﺪﻩ ﻣیﺷﻮﺩ.ﺍﻧﺪﻳﺲ( ﻭﺟﻮﺩ ﻧﺪﺍﺷﺘﻪ ﺑﺎﺷﺪ
In [3]: students =[ 'ava ','ali ','reza ', 'hoda ',' hooman ','hadi ']
print ( students )
rm_stustudent = students . pop ()
print ( students )
print ( rm_stustudent )
Out[3]: ['ava ', 'ali ', 'reza ', 'hoda ', ' hooman ', 'hadi ']
['ava ', 'ali ', 'reza ', 'hoda ', ' hooman ']
hadi
.ﺍﻛﻨﻮﻥ ﻓﺮﺽ ﻛﻨﻴﺪ ﻛﻪ ﻣیﺧﻮﺍﻫﻴﺪ ﻋﻀﻮ ﺩﻭﻡ ﻟﻴﺴﺖ ﺭﺍ ﺣﺬﻑ ﻛﻨﻴﺪ
In [4]: students =[ 'ava ','ali ','reza ', 'hoda ',' hooman ','hadi ']
print ( students )
rm_stustudent = students . pop (2)
print ( students )
print ( rm_stustudent )
Out[4]: ['ava ', 'ali ', 'reza ', 'hoda ', ' hooman ', 'hadi ']
['ava ', 'ali ', 'hoda ', ' hooman ', 'hadi ']
reza
۵۱ ﻓﺼﻞ .۴ﺩﺍﺩﻩ ﺳﺎﺧﺘﺎﺭﻫﺎ
ﺳﺎﻣﺎﻥ ﺩﺍﺩﻥ ﺑﻪ ﻟﻴﺴﺖ ۴-۲-۴
ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﻣﺸﺎﻫﺪﻩ ﺷﺪ ﻟﻴﺴﺖ ،ﻳﮏ ﺩﻧﺒﺎﻟﻪﺍﯼ ﺍﺯ ﺩﺍﺩﻩﻫﺎﺳﺖ ﻛﻪ ﻟﺰﻭﻣ ًﺎ ﺗﺮﺗﻴﺐ ﺍﻟﻔﺒﺎﻳﯽ ﻳﺎ ﺗﺮﺗﻴﺐ ﻋﺪﺩﯼ ﻧﺪﺍﺭﻧﺪ.
ﺍﻛﻨﻮﻥ ﺳﻮﺍﻝ ﺍﻳﻦ ﺍﺳﺖ ﻛﻪ ﺁﻳﺎ ﻣیﺗﻮﺍﻥ ﺑﻪ ﺗﺮﺗﻴﺒﯽ ﻛﻪ ﺫﻛﺮ ﺷﺪ ﺁﻧﻬﺎ ﺭﺍ ﻣﺮﺗﺐ ﻧﻤﻮﺩ .ﺑﺮﺍﯼ ﺍﻳﻦ ﻛﺎﺭ ﺭﺍﻩﻫﺎﯼ ﻣﺨﺘﻠﻔی
ﻭﺟﻮﺩ ﺩﺍﺭﺩ.
.۱ﺭﻭﺵ :sortﺍﻳﻦ ﺭﻭﺵ ﻗﺎﺩﺭ ﺑﻪ ﻣﺮﺗﺐ ﻛﺮﺩﻥ ﻋﺪﺩﯼ ﻳﺎ ﺭﺷﺘﻪﺍﯼ ﻳﮏ ﻟﻴﺴﺖ ﻫﺴﺖ .ﻣﺜﺎﻝ:
In [1]: ]' students =[ 'ava ','ali ','reza ', 'hoda ',' hooman ','hadi
)( students . sort
) print ( students
Out[1]: ]' ['ali ', 'ava ', 'hadi ', 'hoda ', ' hooman ', 'reza
ﻣﺜﺎﻝ ﻋﺪﺩﯼ:
In [2]: ]num =[4 ,8 ,1 ,2.2 ,9 ,5 ,10 ,7.5
)( num . sort
) print ( num
Out[2]: ][1 , 2.2 , 4, 5, 7.5 , 8, 9, 10
ﺩﺭ ﺍﻳﻨﺠﺎ ﺑﺎﻳﺪ ﺑﻪ ﺳﻪ ﻧﻜﺘﻪ ﺗﻮﺟﻪ ﻛﺮﺩ .ﺍﻭﻝ ﺍﻳﻦ ﻛﻪ ﺍﮔﺮ ﺩﺭ ﻣﻴﺎﻥ ﺍﺳﺎﻣی ﺣﺮﻑ ﻳﺎ ﺣﺮﻭﻑ ﺑﺰﺭﮒ ﻭﺟﻮﺩ ﺩﺍﺷﺘﻪ
ﺑﺎﺷﺪ ﺗﺮﺗﻴﺐ ﺭﺍ ﺑﻪ ﻫﻢ ﻣیﺯﻧﺪ .ﻣﮕﺮ ﺁﻥ ﻛﻪ ﺗﻤﺎﻡ ﺣﺮﻭﻑ ﺑﺪﻭﻥ ﺍﺳﺘﺜﻨﺎ ﺑﺰﺭﮒ ﺑﺎﺷﻨﺪ .ﺩﻭﻡ ﺍﻳﻦ ﻛﻪ ﻟﻴﺴﺘی
ﻣﺮﻛﺐ ﺍﺯ ﺭﺷﺘﻪ ﻭ ﻋﺪﺩ ،ﻗﺎﺑﻞ ﻣﺮﺗﺐ ﻛﺮﺩﻥ ﻧﻴﺴﺖ .ﺳﻮﻡ ﺍﻳﻦ ﻛﻪ ﭘﺲ ﺍﺯ ﻣﺮﺗﺐ ﻛﺮﺩﻥ ﻟﻴﺴﺖ ﺩﻳﮕﺮ ﻧﻤیﺗﻮﺍﻥ
ﺑﻪ ﻟﻴﺴﺖ ﺍﻭﻟﻴﻪ ﺑﺎﺯﮔﺸﺖ.
.۲ﺗﺎﺑع :sortedﺑﺎ ﺍﻳﻦ ﺗﺎﺑع ﺿﻤﻦ ﺍﻳﻦ ﻛﻪ ﺩﺍﺩﻩﻫﺎﯼ ﻟﻴﺴﺖ ﻣﺮﺗﺐ ﻣیﺷﻮﻧﺪ ﻟﻴﺴﺖ ﺍﻭﻟﻴﻪ ﺣﻔﻆ ﻣیﺷﻮﺩ ﻭ ﺩﺳﺖ
ﻧﺨﻮﺭﺩﻩ ﺑﺎﻗی ﻣیﻣﺎﻧﺪ ..ﻣﺜﺎﻝ:
In [3]: ]' students =[ 'ava ','ali ','reza ', 'hoda ','hadi
)) print (' sorted list :', sorted ( students
) print (' original list :', students
Out[3]: ]' sorted list :[ 'ali ', 'ava ', 'hadi ', 'hoda ', 'reza
]' original list :[ 'ava ', 'ali ', 'reza ', 'hoda ', 'hadi
ﻣﺜﺎﻝ ﻋﺪﺩﯼ:
In [4]: ]num =[4 ,8 ,1 ,2.2 ,9 ,5 ,10 ,7.5
)) print (' sorted list :', sorted ( num
) print (' original list :',num
Out[4]: ]sorted list : [1 , 2.2 , 4, 5, 7.5 , 8, 9, 10
]original list : [4 , 8, 1, 2.2 , 9, 5, 10 , 7.5
.۲-۴ﻟﻴﺴﺖ ۵۲
۵-۲-۴ﺩﺭﺳﺖ ﻛﺮﺩﻥ ﻟﻴﺴﺖ ﺑﺎ ﺗﺎﺑع range
ﺍﮔﺮ ﺗﺎﺑع rangeﺩﺭﻭﻥ ﺗﺎﺑع )( rangeﻗﺮﺍﺭ ﮔﻴﺮﺩ ﻳﮏ ﻟﻴﺴﺖ ﺍﻳﺠﺎﺩ ﻣیﺷﻮﺩ .ﻣﺜﺎﻝ:
In [1]: ))lst = list ( range (1 ,6
) print ( lst
Out[1]: ][1 , 2, 3, 4, 5
ﻣیﺗﻮﺍﻥ ﺍﺯ ﺁﺭﮔﻮﻣﺎﻥ ﺳﻮﻡ ﺗﺎﺑع rangeﺍﺳﺘﻔﺎﺩﻩ ﻛﺮﺩ ﻭ ﻳﮏ ﻟﻴﺴﺖ ﺍﺯ ﺍﻋﺪﺍﺩ ﺯﻭج ﺳﺎﺧﺖ.
In [2]: ))lst = list ( range (2 ,11 ,2
) print ( lst
Out[2]: ][2 , 4, 6, 8, 10
ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺗﺎﺑع rangeﻣیﺗﻮﺍﻥ ﻟﻴﺴﺖﻫﺎﯼ ﻣﺘﻔﺎﻭﺗی ﺭﺍ ﺍﻳﺠﺎﺩ ﻧﻤﻮﺩ .ﻣﺜل ًا ﻟﻴﺴﺘی ﺍﺯ ﻣﺮﺑع ﺍﻋﺪﺍﺩ ۱ﺗﺎ ۱۰
In [3]: ][= squares
for value in range (1 ,11):
square = value **2
) squares . append ( square
) print ( squares
Out[3]: ][1 , 4, 9, 16 , 25 , 36 , 49 , 64 , 81 , 100
ﺍﻟﺒﺘﻪ ﻛﺪ ﺑﺎلا ﺭﺍ ﻣیﺗﻮﺍﻥ ﻛﻮﺗﺎﻩﺗﺮ ﻫﻢ ﻧﻮﺷﺖ:
In [4]: ][= squares
for value in range (1 , 11):
)squares . append ( value **2
) print ( squares
Out[4]: ][1 , 4, 9, 16 , 25 , 36 , 49 , 64 , 81 , 100
ﺣﺘی ﻣیﺗﻮﺍﻥ ﻛﺪ ﺑﺎلا ﺭﺍ ﻓﺸﺮﺩﻩﺗﺮ ﻫﻢ ﻧﻮﺷﺖ.
In [5]: ][= squares
])[x **2 for x in range (1 ,11
Out[5]: ][1 , 4, 9, 16 , 25 , 36 , 49 , 64 , 81 , 100
ﻛﭙﯽ ﻛﺮﺩﻥ ﻟﻴﺴﺖ ۶-۲-۴
ﺩﺭ ﭘﺎﺭﻩﺍﯼ ﺍﻭﻗﺎﺕ لاﺯﻡ ﺍﺳﺖ ﻛﻪ ﺍﺯ ﻳﮏ ﻟﻴﺴﺖ ﻛﭙﯽ ﺗﻬﻴﻪ ﺷﻮﺩ .ﺍﻳﻦ ﻛﺎﺭ ﺭﺍ ﻣیﺗﻮﺍﻥ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺑﺮﺵ ﺍﻧﺠﺎﻡ ﺩﺍﺩ
ﻛﻪ ﻋﻀﻮ ﺍﺑﺘﺪﺍ ﻭ ﺍﻧﺘﻬﺎﯼ ﺁﻥ ﻣﺸﺨﺺ ﻧﻴﺴﺖ ،ﺑﻨﺎﺑﺮﺍﻳﻦ ﺷﺎﻣﻞ ﺗﻤﺎﻡ ﺍﻋﻀﺎﯼ ﻟﻴﺴﺖ ﺍﻭﻟﻴﻪ ﻣیﺷﻮﺩ .ﻣﺜﺎﻝ:
۵۳ ﺩﺍﺩﻩ ﺳﺎﺧﺘﺎﺭﻫﺎ.۴ ﻓﺼﻞ
In [1]: my_foods = ['pizza ',' falafel ',' carrot cake ']
friend_foods = my_foods [:]
print ("My favorite foods are :")
print ( my_foods )
print ("\ nMy friend 's favorite foods are :")
print ( friend_foods )
Out[1]: My favorite foods are :
['pizza ', ' falafel ', ' carrot cake ']
My friend 's favorite foods are :
['pizza ', ' falafel ', ' carrot cake ']
ﺍﻛﻨﻮﻥ ﺑﺮﺍﯼ ﺍﻳﻦ ﻛﻪ ﻧﺸﺎﻥ ﺩﻫﻴﻢ ﻛﻪ ﻭﺍﻗﻌ ًﺎ ﺩﻭ ﻟﻴﺴﺖ ﻣﺠﺰﺍ ﺍﺯ ﻫﻢ ﺩﺍﺭﻳﻢ ﺑﻪ ﻫﺮ ﻛﺪﺍﻡ ﺍﺯ ﺁﻧﻬﺎ ﻳﮏ ﻏﺬﺍﯼ ﺟﺪﻳﺪ ﺍﺿﺎﻓﻪ
.ﻣیﻛﻨﻴﻢ
In [2]: my_foods = ['pizza ',' falafel ',' carrot cake ']
friend_foods = my_foods [:]
my_foods . append (' hummus ')
friend_foods . append ('ice cream ')
print ("My favorite foods are :")
print ( my_foods )
print ("\ nMy friend 's favorite foods are :")
print ( friend_foods )
Out[2]: My favorite foods are :
['pizza ', ' falafel ', ' carrot cake ', ' hummus ']
My friend 's favorite foods are :
['pizza ', ' falafel ', ' carrot cake ', 'ice cream ']
.ﺍﻛﻨﻮﻥ ﺑﺮﺍﯼ ﻛﭙﯽ ﻛﺮﺩﻥ ﺍﺯ ﻃﺮﻳﻖ ﺑﺮﺵ ﻟﻴﺴﺖ ﺍﺳﺘﻔﺎﺩﻩ ﻧﻤیﺷﻮﺩ
In [3]: my_foods = ['pizza ', ' falafel ', ' carrot cake ']
friend_foods = my_foods
my_foods . append (' hummus ')
friend_foods . append ('ice cream ')
print ("My favorite foods are :")
print ( my_foods )
print ("\ nMy friend 's favorite foods are :")
print ( friend_foods )
.۳-۴ﭼﻨﺪﺗﺎﻳﯽ ۵۴
Out[3]: My favorite foods are :
]' ['pizza ',' falafel ',' carrot cake ',' hummus ','ice cream
My friend 's favorite foods are :
]' ['pizza ',' falafel ',' carrot cake ',' hummus ','ice cream
ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﻣﺸﺎﻫﺪﻩ ﻣیﺷﻮﺩ ،ﻫﺮ ﺩﺍﺩﻩﺍﯼ ﻛﻪ ﺑﻪ ﻟﻴﺴﺖ my_foodsﺍﺿﺎﻓﻪ ﻣیﺷﻮﺩ ،ﻋﻴﻨ ًﺎ ﺑﻪ ﻟﻴﺴﺖ friend_foods
ﺭﺍﻩ ﻣیﻳﺎﺑﺪ ﻭ ﺑﺎﻟﻌﻜﺲ .ﭼﺮﺍ ﻛﻪ ﺍﺯ ﺍﻳﻦ ﻃﺮﻳﻖ ،ﺁﺩﺭﺱ ﺣﺎﻓﻈﻪ ﺩﺭ ﺩﻭ ﻟﻴﺴﺖ ﻳﺎﺩ ﺷﺪﻩ ﻳﻜﺴﺎﻥ ﺍﺳﺖ.
ﭘﻴﻤﺎﻳﺶ ﻟﻴﺴﺖ ﺗﻮﺳﻂ ﺣﻠﻘﻪ ۱-۶-۲-۴
ﺩﺭ ﺣﻴﻦ ﺍﺟﺮﺍﯼ ﺣﻠﻘﻪ ﻣیﺗﻮﺍﻥ ﺑﻪ ﺍﻋﻀﺎﯼ ﻟﻴﺴﺖ ﺩﺳﺖ ﻳﺎﻓﺖ .ﺑﻪ ﻋﺒﺎﺭﺕ ﺩﻳﮕﺮ ﻣیﺗﻮﺍﻥ ﺗﻮﺳﻂ ﺣﻠﻘﻪ ﻋﻨﺎﺻﺮ ﻟﻴﺴﺖ
ﺭﺍ ﭘﻴﻤﻮﺩ .ﻣﺜﺎﻝ:
In [1]: ]'vowels = ['a', 'e', 'i', 'o', 'u
" word = " Melli_bank
for letter in word :
if letter in vowels :
) print ( letter
Out[1]: e
i
a
ﭼﻨﺪﺗﺎﻳﯽ ۳-۴
ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﺩﺭ ﻟﺴﺖﻫﺎ ﻣلاﺣﻈﻪ ﺷﺪ ،ﺁﻧﻬﺎ ﻧﺴﺒﺖ ﺑﻪ ﺗﻐﻴﻴﺮﺍﺕ ﻛﺎﻣل ًا ﺍﻧﻌﻄﺎﻑ ﺩﺍﺭﻧﺪ .ﻭ ﺗﻐﻴﻴﺮﺍﺕ ﺭﺍ ﺑﺨﻮﺑﯽ
ﻣیﭘﺬﻳﺮﻧﺪ .ﺍﻣﺎ ﺩﺭ ﭘﺎﺭﻩﺍﯼ ﺍﺯ ﻛﺎﺭﺑﺮﺩﻫﺎ لاﺯﻡ ﺍﺳﺖ ﺩﻧﺒﺎﻟﻪ ﺩﺍﺩﻩﻫﺎ ﺗﻐﻴﻴﺮ ﻧﻜﻨﻨﺪ .ﻭ ﺩﺭ ﻃﻮﻝ ﺑﺮﻧﺎﻣﻪ ﺛﺎﺑﺖ ﺑﻤﺎﻧﻨﺪ.
ﺗﻌﺮﻳﻒ ﭼﻨﺪﺗﺎﻳﯽ ۱-۳-۴
ﺩﺭ ﭼﻨﺪﺗﺎﻳﯽ ،ﺩﻧﺒﺎﻟﻪ ﺩﺍﺩﻩﻫﺎ ﻣﺎﻧﻨﺪ ﻟﻴﺴﺖ ﻫﺴﺘﻨﺪ ﺑﺎ ﺍﻳﻦ ﺗﻔﺎﻭﺕ ﻛﻪ ﺑﺠﺎﯼ ﻋلاﻣﺖ ﺑﺮﺍﻛﺖ ﺍﺯ ﻋلاﻣﺖ ﭘﺮﺍﻧﺘﺰ ﺍﺳﺘﻔﺎﺩﻩ
ﻣیﺷﻮﺩ .ﻭ ﺑﺎ ﺍﻧﺪﻳﺲ ﻣیﺗﻮﺍﻥ ﺑﻪ ﺍﻋﻀﺎﯼ ﺁﻥ ﺩﺳﺘﺮﺳی ﺩﺍﺷﺖ .ﻣﺜﺎﻝ:
In [2]: )dimensions =(3 ,4 ,5
)]print ( dimensions [0
)]print ( dimensions [2
Out[2]: 3
5
ﺍﻛﻨﻮﻥ ﺳﻌی ﻛﻨﻴﻢ ﻛﻪ ﻣﻘﺪﺍﺭ ﻳﮏ ﻋﻀﻮ ﭼﻨﺪﺗﺎﻳﯽ ﺭﺍ ﺗﻐﻴﻴﺮ ﺩﻫﻴﻢ.
۵۵ ﻓﺼﻞ .۴ﺩﺍﺩﻩ ﺳﺎﺧﺘﺎﺭﻫﺎ
In [1]: )dimensions =(3 ,4 ,5
dimensions [1]=7
Out[1]: ---------------------------------------------------------
IndexError ) Traceback ( most recent call last
Cell In [2] , line 2
)1 dimensions =(3 ,4 ,5
----> 2 dimensions [1]=7
TypeError : 'tuple ' object does not support item assignment
ﺍﮔﺮ ﺍﺣﻴﺎﻧ ًﺎ ﭼﻨﺪﺗﺎﻳﯽ ﺩﺍﺭﺍﯼ ﻳﮏ ﻋﻀﻮ ﺑﻮﺩ ،ﺑﺎﻳﺪ ﻛﺎﻣﺎﯼ ﺑﻌﺪ ﺍﺯ ﺁﻥ ﮔﺬﺍﺷﺘﻪ ﺷﻮﺩ ،ﺩﺭ ﻏﻴﺮ ﺍﻳﻦ ﺻﻮﺭﺕ ﭼﻨﺪﺗﺎﻳﯽ
ﻣﺤﺴﻮﺏ ﻧﻤیﺷﻮﺩ .ﻣﺜﺎﻝ:
In [2]: )tp0 =(5.5
)tp1 =(5.5 ,
)) print ( type ( tp0
)) print ( type ( tp1
Out[2]: >' <class 'float
>' <class 'tuple
ﺍﮔﺮ ﭼﻨﺪ ﻣﻔﺪﺍﺭ ﺭﺍ ﺑﻪ ﻣﺘﻐﻴﺮ ﻧﺴﺒﺖ ﺩﻫﻴﻢ ،ﺩﺭ ﻭﺍﻗﻊ ﻳﮏ ﭼﻨﺪﺗﺎﻳﯽ ﺳﺎﺧﺘﻪ ﻣیﺷﻮﺩ .ﻣﺜﺎﻝ:
In [3]: tup ='3D' ,3 ,5.5 ,8
) print ( tup
)]print ( tup [1:3
Out[3]: )('3D ', 3, 5.5 , 8
)(3 , 5.5
۴-۴ﺭﺷﺘﻪﻫﺎ ﻭ ﺭﻭﺵﻫﺎ
ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﻗﺒل ًا ﻣﺸﺎﻫﺪﻩ ﺷﺪ ،ﺭﺷﺘﻪ ﻳﮏ ﺩﻧﺒﺎﻟﻪ ﺍﺯ ﻛﺎﺭﺍﻛﺘﺮﻫﺎ ﺍﺳﺖ .ﻛﻪ ﻣیﺗﻮﺍﻥ ﺑﻪ ﻫﺮ ﻳﮏ ﺍﺯ ﻛﺎﺭﺍﻛﺘﺮﻫﺎ ﺑﺎ
ﺍﻧﺪﻳﺲ ﺑﻪ ﺁﻧﻬﺎ ﺩﺳﺘﺮﺳی ﭘﻴﺪﺍ ﻛﺮﺩ .ﺿﻤﻨ ًﺎ ﺩﺭ ﺍﻳﻦ ﻧﻮع ﺩﺍﺩﻩ ﻣیﺗﻮﺍﻥ ﺑﺮﺵ ﻧﻴﺰ ﺍﻳﺠﺎﺩ ﻧﻤﻮﺩ.
In [4]: ' name =' hooman
) print ( name
)]print ( name [1
)]print ( name [2:5
)]print ( name [ -1
ﺭﺷﺘﻪﻫﺎ ﻭ ﺭﻭﺵﻫﺎ.۴-۴ ۵۶
Out[4]: hooman
o
oma
n
: ﻣﺜﺎﻝ.ﺍﻛﻨﻮﻥ ﺳﻌی ﻛﻨﻴﻢ ﻛﻪ ﻛﺎﺭﺍﻛﺘﺮ ﺭﺷﺘﻪ ﺭﺍ ﺗﻐﻴﻴﺮ ﺩﻫﻴﻢ
In [1]: name =' hooman '
name [2]= 'u'
Out[1]: ---------------------------------------------------------
IndexError Traceback ( most recent call last )
Cell In [4] , line 2
1 name =' hooman '
----> 2 name [2]= 'u'
TypeError : 'str ' object does not support item assignment
ﺭﻭﺵﻫﺎ۱-۴-۴
: ﻣﺜﺎﻝ. ﺑﺎ ﺍﻳﻦ ﻣیﺗﻮﺍﻥ ﺷﺮﻭع ﻳﮏ ﺯﻳﺮﺭﺷﺘﻪ ﺭﺍ ﺩﺭ ﺩﺍﺧﻞ ﻳﮏ ﺭﺷﺘﻪ ﻣﺸﺨﺺ ﻛﺮﺩ:find ﺭﻭﺵ.۱
In [2]: str =' hooman '
str . find ('oo ')
Out[2]: 1
: ﻣﺜﺎﻝ. ﺑﺎ ﺍﻳﻦ ﺭﻭﺵ ﺗﻤﺎﻡ ﺣﺮﻭﻑ ﺑﺰﺭﮒ ﺑﻪ ﺣﺮﻭﻑ ﻛﻮﭼﮏ ﺗﺒﺪﻳﻞ ﻣیﺷﻮﺩ:lower ﺭﻭﺵ.۲
In [3]: 'i Enjoy traveling . Do you ?'. lower ()
Out[3]: 'i enjoy traveling . do you ?'
: ﻣﺜﺎﻝ. ﺑﺎ ﺍﻳﻦ ﺭﻭﺵ ﺗﻤﺎﻡ ﺣﺮﻭﻑ ﻛﻮﭼﮏ ﺑﻪ ﺣﺮﻭﻑ ﻛﻮﭼﮏ ﺗﺒﺪﻳﻞ ﻣیﺷﻮﺩ:upper ﺭﻭﺵ.۳
In [4]: 'i Enjoy traveling . Do you ?'. upper ()
Out[4]: 'I ENJOY TRAVELING . DO YOU ?'
: ﻣﺜﺎﻝ. ﺑﺎ ﺍﻳﻦ ﺭﻭﺵ ﺗﻤﺎﻡ ﺣﺮﻭﻑ ﻛﻮﭼﮏ ﺍﻭﻝ ﻫﺮ ﻛﻠﻤﻪ ﺑﻪ ﺣﺮﻭﻑ ﺑﺰﺭﮒ ﺗﺒﺪﻳﻞ ﻣیﺷﻮﺩ:title ﺭﻭﺵ.۴
In [5]: 'i Enjoy traveling . do you ?'. title ()
Out[5]: 'I Enjoy Traveling . Do You ?'
۵۷ ﺩﺍﺩﻩ ﺳﺎﺧﺘﺎﺭﻫﺎ.۴ ﻓﺼﻞ
: ﻣﺜﺎﻝ. ﺑﺎ ﺍﻳﻦ ﺭﻭﺵ ﻣیﺗﻮﺍﻥ ﻳﮏ ﻟﻴﺴﺖ ﺍﺯ ﺭﺷﺘﻪﻫﺎ ﺭﺍ ﺑﻪ ﻳﮏ ﺭﺷﺘﻪ ﻭﺍﺣﺪ ﺗﺒﺪﻳﻞ ﻧﻤﻮﺩ:join ﺭﻭﺵ.۵
In [1]: ', '. join ([ 'cats ', 'rats ', 'bats '])
Out[1]: 'cats , rats , bats '
:ﻣﺜﺎﻝ ﺩﻳﮕﺮ
In [2]: ' '. join ([ 'My ', 'name ', 'is ', 'Saeed '])
Out[2]: 'My name is Saeed '
ﻳﻌﻨی ﻳﮏ ﺭﺷﺘﻪ ﺭﺍ ﺑﻪ ﻳﮏ ﻟﻴﺴﺖ ﺍﺯ ﺭﺷﺘﻪ ﻳﺎ. ﻋﻤﻞ ﻣیﻛﻨﺪjoin ﺍﻳﻦ ﺭﻭﺵ ﻋﻜﺲ ﺭﻭﺵ:split ﺭﻭﺵ.۶
: ﻣﺜﺎﻝ.ﺭﺷﺘﻪﻫﺎ ﺗﺒﺪﻳﻞ ﻣیﻛﻨﺪ
In [3]: 'My name is Saeed .'. split ()
Out[3]: ['My ', 'name ', 'is ', 'Saeed .']
ﭼﭗﭼﻴﻦ ﻭ ﻭﺳﻂﭼﻴﻦ، ﺩﺭ ﻳﮏ ﺑﺎﺯﻩ ﻣیﺗﻮﺍﻥ ﻳﮏ ﻣﺘﻦ ﺭﺍ ﺭﺍﺳﺖﭼﻴﻦ:rjust, ljust, center ﺭﻭﺵ.۷
: ﻣﺜﺎﻝ ﺭﺍﺳﺖﭼﻴﻦ.ﻧﻤﻮﺩ
In [4]: 'Hello '. rjust (10)
Out[4]: ' Hello '
In [5]: 'Hello '. rjust (20 , '*')
Out[5]: ' *************** Hello '
:ﻣﺜﺎﻝ ﭼﭗﭼﻴﻦ
In [6]: 'Hello '. ljust (10)
Out[6]: 'Hello '
In [7]: 'Hello '. ljust (20 , '-')
Out[7]: 'Hello ---------------'
:ﻣﺜﺎﻝ ﻭﺳﻂﭼﻴﻦ
In [8]: 'Hello '. center (20)
Out[8]: ' Hello '
.۴-۴ﺭﺷﺘﻪﻫﺎ ﻭ ﺭﻭﺵﻫﺎ ۵۸
In [1]: )'=' 'Hello '. center (20 ,
Out[1]: ' ======== ' ======= Hello
ﺭﻭﺵ :rstrip, lstrip, stripﺍﮔﺰ ﺍﻃﺮﺍﻑ ﺭﺷﺘﻪﻫﺎ ﺍﺯ ﺭﺍﺳﺖ ﻳﺎ ﭼﭗ ﻭ ﻳﺎ ﺍﺯ ﻃﺮﻓﻴﻦ ﺟﺎﯼ ﺧﺎﻟی ﻭﺟﻮﺩ
ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ ،ﻣیﺗﻮﺍﻥ ﺑﺎ ﺍﻳﻦ ﺭﻭﺵﻫﺎ ﺁﻧﻬﺎ ﺭﺍ ﺣﺬﻑ ﻧﻤﻮﺩ .ﻣﺜﺎﻝ ﺟﺎﯼ ﺧﺎﻟی ﺭﺍﺳﺖ:
In [2]: ' = spam Hello World '
)( spam . rstrip
Out[2]: ' ' Hello World
ﻣﺜﺎﻝ ﺟﺎﯼ ﺧﺎﻟی ﭼﭗ:
In [3]: ' = spam Hello World '
)( spam . lstrip
Out[3]: 'Hello World '
ﻣﺜﺎﻝ ﺑﺪﻭﻥ ﺟﺎﯼ ﺧﺎﻟی:
In [4]: ' = spam Hello World '
)( spam . strip
Out[4]: ' 'Hello World
ﺍﮔﺮ ﺑﺨﻮﺍﻫﻴﻢ ﺟﺎﯼ ﺧﺎﻟی ﺑﻴﻦ ﻛﺎﺭﺍﻛﺘﺮﻫﺎ ﺩﺭ ﻳﮏ ﺭﺷﺘﻪ ﺭﺍ ﺣﺬﻑ ﻛﻨﻴﻢ .ﻣیﺗﻮﺍﻥ ﺍﺯ ﺭﻭﺵ replaceﺍﺳﺘﻔﺎﺩﻩ
ﻧﻤﻮﺩ .ﻣﺜﺎﻝ:
In [5]: 's= 'p y t h o n
)''s_mod =s. replace (' ',
s_mod
Out[5]: ' ' python
ﺗﺒﺪﻳﻞ ﺭﺷﺘﻪ ﺑﻪ ﻟﻴﺴﺖ ۲-۴-۴
ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺍﻣﻜﺎﻧﺎﺕ ﺗﻐﻴﻴﺮ ﺑﻴﺸﺘﺮ ﺩﺭ ﺳﺎﺧﺘﺎﺭ ﻟﻴﺴﺖ ﻣیﺗﻮﺍﻥ ﻳﮏ ﺭﺷﺘﻪ ﺭﺍ ﺑﺎ ﺗﺎﺑع )( listﺑﻪ ﻳﮏ ﻟﻴﺴﺖ ﺗﺒﺪﻳﻞ ﻧﻤﻮﺩ.
ﻭ ﺳﭙﺲ ﺑﻌﺪ ﺍﺯ ﺍﻋﻤﺎﻝ ﺗﻐﻴﻴﺮﺍﺕ ،ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺭﻭﺵ )( joinﺑﻪ ﺳﺎﺧﺘﺎﺭ ﺭﺷﺘﻪ ﺑﺎﺯ ﮔﺮﺩﻳﻢ.
ﻣﺜﺎﻝ:
۵۹ ﻓﺼﻞ .۴ﺩﺍﺩﻩ ﺳﺎﺧﺘﺎﺭﻫﺎ
In [1]: ' S= ' hamidian
)L= list (S
)print (L
'L [3]= 'e
'L [5]= 'a
'L [ -2]= 'n
'L [ -1]= 'i
)print (L
)S= ''. join (L
)print (S
Out[1]: ]'['h ', 'a', 'm', 'i', 'd', 'i', 'a', 'n
]'['h ', 'a', 'm', 'e', 'd', 'a', 'n', 'i
hamedani
۵-۴ﺩﻳﻜﺸﻨﺮﯼ
ﺩﻳﻜﺸﻨﺮﯼ ﻣﺎﻧﻨﺪ ﻟﻴﺴﺖ ﻣیﺗﻮﺍﻧﺪ ﺷﺎﻣﻞ ﺗﻌﺪﺍﺩ ﺯﻳﺎﺩﯼ ﻣﻘﺪﺍﺭ ﺑﺎﺷﺪ .ﺍﻣﺎ ﺑﺮ ﺧلاﻑ ﻟﻴﺴﺖ ﺑﺎ ﺍﻧﺪﻳﺲ ﻛﺎﺭ ﻧﻤیﻛﻨﺪ.
ﺑﻠﻜﻪ ﺑﺎ ﺁﻳﺘﻤی ﺑﻪ ﻧﺎﻡ ﻛﻠﻴﺪ ﻛﺎﺭ ﻣیﻛﻨﺪ ،ﻛﻪ ﻣیﺗﻮﺍﻧﺪ ﺩﺍﺩﻩﻫﺎﯼ ﻣﺘﻨﻮﻋی ﺑﺎﺷﺪ .ﻭ ﻣﺤﺪﻭﺩ ﺑﻪ ﺍﻋﺪﺍﺩ ﺻﺤﻴح ﻣﺜﻞ ﺍﻧﺪﻳﺲ
ﻟﻴﺴﺖ ﻧﻴﺴﺖ .ﻭ ﻣیﺗﻮﺍﻧﺪ ﻋﺪﺩ ،ﺭﺷﺘﻪ ،ﻟﻴﺴﺖ ﻭ ﻳﺎ ﺣﺘی ﻳﮏ ﺩﻳﻜﺸﻨﺮﯼ ﺩﻳﮕﺮ ﺑﺎﺷﺪ .ﺍﺯ ﻛﻠﻴﺪﻫﺎ ﺑﺮﺍﯼ ﺩﺳﺘﺮﺳی ﺑﻪ
ﻣﻘﺎﺩﻳﺮ ﺍﺳﺘﻔﺎﺩﻩ ﻣیﺷﻮﺩ.
ﺑﻄﻮﺭ ﻛﻠی ﺩﻳﻜﺸﻨﺮﯼﻫﺎ ﺷﺎﻣﻞ ﺗﻌﺪﺍﺩﯼ ﺯﻭج ﻛﻠﻴﺪ-ﻣﻘﺪﺍﺭ ﻫﺴﺘﻨﺪ ،ﻛﻪ ﺗﻮﺳﻂ ﻋلاﻣﺖ }{ ﻣﺤﺼﻮﺭ ﻣیﺷﻮﻧﺪ .ﻣﺜﺎﻝ:
In [2]: }kid ={ 'name ':'reza ',' family ':'shams ','age ':7
kid
Out[2]: }{'name ':'reza ',' family ':'shams ','age ':7
ﺩﻳﻜﺸﻨﺮﯼ ﺑﺎلا ﺷﺎﻣﻞ ﺳﻪ ﺯﻭج ﺍﺳﺖ ،ﻛﻪ ﺗﻮﺳﻂ ﻋلاﻣﺖ ﻛﺎﻣﺎ ﺍﺯ ﻳﻜﺪﻳﮕﺮ ﻣﺠﺰﺍ ﺷﺪﻩﺍﻧﺪ .ﺿﻤﻨ ًﺎ ﻛﻠﻴﺪ ﻭ ﻣﻘﺪﺍﺭ
ﻣﺘﻨﺎﻇﺮﺵ ﺑﺎ ﻋلاﻣﺖ ) (:ﺑﻪ ﻫﻢ ﺭﺑﻂ ﭘﻴﺪﺍ ﻣیﻛﻨﻨﺪ .ﺍﺳﺎﻣی ' 'family' ،'nameﻭ ' 'ageﻛﻠﻴﺪﻫﺎ ﻭ ''shams' ،'reza
ﻭ 7ﻣﻘﺪﺍﺭﻫﺎ ﻫﺴﺘﻨﺪ .ﺑﺮﺍﯼ ﺩﺳﺘﺮﺳی ﺑﻪ ﻣﻘﺎﺩﻳﺮ ﺩﻳﻜﺸﺘﺮﯼ ﺑﺎﻳﺪ ﺍﺯ ﻃﺮﻳﻖ ﻛﻠﻴﺪﻫﺎ ﻋﻤﻞ ﻧﻤﻮﺩ .ﻣﺜﺎﻝ:
In [3]: }kid ={ 'name ':'reza ',' family ':'shams ','age ':7
]' kid [' family
Out[3]: ' 'shams
۱-۵-۴ﺗﺮﺗﻴﺐ ﺩﺭ ﻟﻴﺴﺖ ﻭ ﺩﻳﻜﺸﻨﺮﯼ
ﺩﺭ ﻟﻴﺴﺖﻫﺎ ﺗﺮﺗﻴﺐ ﻭﺟﻮﺩ ﺩﺍﺭﺩ ،ﻳﻌﻨی ﻋﻀﻮ ﺍﻭﻝ ،ﺩﻭﻡ ﻭ … ﻭ ﺍﮔﺮ ﻋﻨﺎﺻﺮ ﺁﻧﻬﺎ ﺟﺎﺑﺠﺎ ﺷﻮﻧﺪ ﺩﻭ ﻟﻴﺴﺖ ﻣﺘﻔﺎﻭﺕ ﺍﻳﺠﺎﺩ
ﻣیﺷﻮﺩ .ﺍﻣﺎ ﺩﺭ ﺩﻳﻜﺸﻨﺮﯼ ﺗﺮﺗﻴﺐ ﺭﻋﺎﻳﺖ ﻧﻤیﺷﻮﺩ .ﺑﺮﺍﯼ ﺩﺭﮎ ﺑﻬﺘﺮ ﺑﻪ ﻣﺜﺎﻝ ﻳﮏ ﻟﻴﺴﺖ ﺗﻮﺟﻪ ﻛﻨﻴﺪ.
ﺩﻳﻜﺸﻨﺮﯼ.۵-۴ ۶۰
In [1]: list1 =[5 ,1.5 , 'ali ',True ]
list2 =[ 'ali ' ,5 ,1.5 , True ]
list1 == list2
Out[1]: False
:ﺍﻛﻨﻮﻥ ﺩﺭ ﺩﻳﻜﺸﻨﺮﯼ
In [2]: kid1 ={ 'name ':'reza ',' family ':'shams ','age ':7}
kid2 ={ 'name ':'reza ','age ':7 , ' family ':'shams '}
kid1 == kid2
Out[2]: True
.ﺑﻪ ﻫﻤﻴﻦ ﺟﻬﺖ ﻣﻔﻬﻮﻡ ﺑﺮﺵ ﺩﺭ ﺩﻳﻜﺸﻨﺮﯼ ﻭﺟﻮﺩ ﻧﺪﺍﺭﺩ
ﻭﻳﺮﺍﻳﺶ ﺩﺭ ﺩﻳﻜﺸﻨﺮﯼ۲-۵-۴
ﺯﻭﺟی ﺭﺍ ﺣﺬﻑ ﻧﻤﻮﺩ ﻭ ﻳﺎ ﻛﻠﻴﺪﻫﺎ ﻳﺎ، ﻳﻌﻨی ﺯﻭﺟی ﺭﺍ ﺍﺿﺎﻓﻪ ﻛﺮﺩ.ﺩﺭ ﺩﻳﻜﺸﻨﺮﯼ ﻣیﺗﻮﺍﻥ ﺗﻐﻴﻴﺮﺍﺗی ﺭﺍ ﺍﻋﻤﺎﻝ ﻧﻤﻮﺩ
.ﻣﻘﺪﺍﺭﻫﺎ ﺭﺍ ﻭﻳﺮﺍﻳﺶ ﻛﺮﺩ
:ﺍﺿﺎﻓﻪ ﻛﺮﺩﻥ ﺯﻭج ﺟﺪﻳﺪ ﺑﻪ ﺩﻳﻜﺸﻨﺮﯼ
.ﻣیﺗﻮﺍﻥ ﺯﻭجﻫﺎﯼ ﻣﺘﻌﺪﺩﯼ ﺑﻪ ﺩﻳﻜﺸﻨﺮﯼ ﺍﺿﺎﻓﻪ ﻧﻤﻮﺩ
In [3]: birthdays = {'Ava ': 'Apr 1', 'Reza ': 'Dec 5'}
birthdays ['Ali ']= 'Sep 2'
print ( birthdays )
Out[3]: {'Ava ':'Apr 1','Reza ':'Dec 5','Ali ':'Sep 2'}
: ﺍﺿﺎﻓﻪ ﻛﺮﺩﻥ ﺯﻭج ﺑﻪ ﺩﻳﻜﺸﻨﺮﯼ ﺧﺎﻟی:ﻣﺜﺎﻝ
In [4]: birthdays ={}
birthdays ['Homa ']= 'Jan 7'
birthdays ['Hoda ']= 'Nov 9'
print ( birthdays )
Out[4]: {'Homa ':'Jan 7','Hoda ':'Nov 9'}
:ﺗﻐﻴﻴﺮ ﻣﻘﺪﺍﺭ ﻳﮏ ﺯﻭج
In [5]: birthdays = {'Ava ': 'Apr 1', 'Reza ': 'Dec 12 '}
birthdays ['Ava ']= 'Mar 5'
print ( birthdays )
Out[5]: {'Ava ':'Mar 5','Reza ':'Dec 12 '}
۶۱ ﺩﺍﺩﻩ ﺳﺎﺧﺘﺎﺭﻫﺎ.۴ ﻓﺼﻞ
:ﺗﻐﻴﻴﺮ ﻛﻠﻴﺪ ﻳﮏ ﺯﻭج
: ﻣﺜﺎﻝ. ﺍﺳﺘﻔﺎﺩﻩ ﻣیﻛﻨﻴﻢpop() ﺍﺯ ﺭﻭﺵ،ﺑﺮﺍﯼ ﺗﻐﻴﻴﺮ ﻧﺎﻡ ﻳﮏ ﻛﻠﻴﺪ
In [1]: di ={1: 'ava ', 2: True }
print (di)
di[ 'bool ']= di. pop (2)
print (di)
Out[1]: {1: 'ava ', 2: True }
{1: 'ava ', 'bool ': True }
: ﻣﺜﺎﻝ. ﻣیﺗﻮﺍﻥ ﻳﮏ ﺯﻭج ﺭﺍ ﺍﺯ ﺩﻳﻜﺸﻨﺮﯼ ﺣﺬﻑ ﻧﻤﻮﺩdel ﺑﺎ ﻓﺮﻣﺎﻥ:ﺣﺬﻑ ﻛﺮﺩﻥ ﻳﮏ ﺯﻭج ﺍﺯ ﺩﻳﻜﺸﻨﺮﯼ
In [2]: birthdays ={ 'Ava ':'Apr 1','Reza ':'Dec 12 ',' Rezvan ':'Jun 8'}
del birthdays ['Reza ']
print ( birthdays )
Out[2]: {'Ava ':'Apr 1',' Rezvan ':'Jun 8'}
ﻣﻘﺪﺍﺭ ﺩﺭ ﺣﻠﻘﻪ- ﺯﻭجﻫﺎﯼ ﻛﻠﻴﺪ۳-۵-۴
: ﻣﺘﺎﻝ. ﻣیﺗﻮﺍﻥ ﺯﻭجﻫﺎﯼ ﺩﻳﻜﺸﻨﺮﯼ ﺭﺍ ﺑﻪ ﺻﻮﺭﺕ ﺟﺪﻳﺪﯼ ﻧﻮﺷﺖ،ﻗﺒﻞ ﺍﺯ ﺍﺟﺮﺍﯼ ﺭﻭﻳﻜﺮﺩ ﺩﻳﻜﺸﻨﺮﯼ ﺩﺭ ﺣﻠﻘﻪ
In [3]: user_0 = {
" username ": " Skarimi ",
" first ": " saeed ",
" last ": " karimi "
}
x = user_0 [" first "]
print (x)
print ( user_0 . keys ())
print ( user_0 . values ())
print ( user_0 . items ())
Out[3]: saeed
dict_keys ([ ' username ', 'first ', 'last '])
dict_values ([ ' Skarimi ', 'saeed ', ' karimi '])
dict_items ([( ' username ', ' Skarimi '), ('first ', 'saeed '),
('last ', ' karimi ')])
: ﻣﺜﺎﻝ. ﻛﻠﻴﺪﻫﺎ ﻭ ﻣﻘﺎﺩﻳﺮ ﺭﺍ ﺑﺪﺳﺖ ﺁﻭﺭﺩitems() ﻣیﺗﻮﺍﻥ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺩﺭ ﺣﻠﻘﻪ ﺑﺎ ﺭﻭﺵ
ﺩﻳﻜﺸﻨﺮﯼ.۵-۴ ۶۲
In [1]: user_0 = {
" username ": " Skarimi ",
" first ": " saeed ",
" last ": " karimi "
}
for key , value in user_0 . items ():
print ('\ nKey : '+ key )
print ('Value : '+ value )
Out[1]: Key : username
Value : Skarimi
Key : first
Value : saeed
Key : last
Value : karimi
: ﻣﺜﺎﻝ.ﻫﻤﻴﻦﻃﻮﺭ ﻣیﺗﻮﺍﻥ ﻛﻠﻴﺪﻫﺎ ﻭ ﻳﺎ ﻣﻘﺎﺩﻳﺮ ﺭﺍ ﺑﻪ ﺻﻮﺭﺕ ﻣﺠﺰﺍ ﻧﻮﺷﺖ
In [2]: favorite_languages = {
'ali ': ' python ',
'ava ': 'c',
'rahim ': 'ruby ',
'zahra ': ' python ',
}
for name in favorite_languages . keys ():
print ( name . title ())
Out[2]: Ali
Ava
Rahim
Zahra
In [3]: favorite_languages = {
'ali ': ' python ',
'ava ': 'c',
'rahim ': 'ruby ',
'zahra ': ' python ',
}
for name in favorite_languages . values ():
print ( name . title ())
Out[3]: Python
C
Ruby
Python
۶۳ ﻓﺼﻞ .۴ﺩﺍﺩﻩ ﺳﺎﺧﺘﺎﺭﻫﺎ
ﺍﻳﺠﺎﺩ ﺩﻳﻜﺸﻨﺮﯼ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺗﺎﺑع )(dict ۴-۵-۴
ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺗﺎﺑع )( dictﻣیﺗﻮﺍﻥ ﺩﻳﻜﺸﻨﺮﯼ ﺳﺎﺧﺖ.
ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻛﻠﻴﺪ ﻭﺍﮊﻩ ﺑﻪ ﻋﻨﻮﺍﻥ ﺁﺭﮔﻮﻣﺎﻥ
ﻳﮏ ﺩﻳﻜﺸﻨﺮﯼ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺗﺎﺑع )( dictﻭ ﺁﺭﮔﻮﻣﺎﻥ ﻛﻠﻴﺪ ﻭﺍﮊﻩ ﺳﺎﺧﺘﻪ ﻣیﺷﻮﺩ .ﻣﺜﺎﻝ:
In [1]: )d = dict (k1 =1 , k2 =2 , k3 =3
)print (d
Out[1]: }{'k1 ': 1, 'k2 ': 2, 'k3 ': 3
ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻟﻴﺴﺖ ﺑﻪ ﻋﻨﻮﺍﻥ ﺁﺭﮔﻮﻣﺎﻥ
ﺩﺭ ﺁﺭﮔﻮﻣﺎﻥ ﺗﺎﺑع ،ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﻳﮏ ﻟﻴﺴﺖ ﻛﻪ ﻫﺮ ﻳﮏ ﺍﺯ ﭘﺮﺍﻧﺘﺰﻫﺎ ﺑﻪ ﻋﻨﻮﺍﻥ ﻳﮏ ﺯﻭج ﺩﻳﻜﺸﻨﺮﯼ ﻣﺤﺴﻮﺏ ﻣیﺷﻮﺩ.
ﻣﺜﺎﻝ:
In [2]: )])d = dict ([( 'k1 ', 1) , ( 'k2 ', 2) , ( 'k3 ', 3
)print (d
Out[2]: }{'k1 ': 1, 'k2 ': 2, 'k3 ': 3
ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺩﻭ ﻟﻴﺴﺖ ﺑﻪ ﻋﻨﻮﺍﻥ ﺁﺭﮔﻮﻣﺎﻥ
ﺩﺭ ﺁﺭﮔﻮﻣﺎﻥ ﺗﺎﺑع ،ﻣیﺗﻮﺍﻥ ﺍﺯ ﺩﻭ ﻟﻴﺴﺖ ﺍﺳﺘﻔﺎﺩﻩ ﻛﺮﺩ .ﻳﻜی ﺍﺯ ﺁﻧﻬﺎ ﺷﺎﻣﻞ ﻛﻠﻴﺪﻫﺎ ﻭ ﺩﻳﮕﺮﯼ ﺷﺎﻣﻞ ﻣﻘﺎﺩﻳﺮ ﺍﺳﺖ.
ﻣﺜﺎﻝ:
In [3]: ]' keys = ['k1 ', 'k2 ', 'k3
]values = [1 , 2, 3
)) d = dict ( zip (keys , values
)print (d
Out[3]: }{'k1 ': 1, 'k2 ': 2, 'k3 ': 3
۵-۵-۴ﺩﺭﻫﻢ ﺷﺪﮔی
ﺑﻌﻀی ﺍﻭﻗﺎﺕ ﻣیﺧﻮﺍﻫﻴﺪ ﻛﻪ ﻳﮏ ﻣﺠﻤﻮﻋﻪﺍﯼ ﺍﺯ ﺩﻳﻜﺸﻨﺮﯼﻫﺎ ﺩﺭ ﻟﻴﺴﺖ ﻇﺎﻫﺮ ﺷﻮﺩ ﻭ ﻳﺎ ﻟﻴﺴﺖﻫﺎ ﺩﺭ ﺩﻳﻜﺸﻨﺮﯼ
ﻗﺮﺍﺭ ﮔﻴﺮﺩ .ﺑﻪ ﻣﻮﺍﺭﺩ ﺫﻛﺮ ﺷﺪﻩ ﺩﺭﻫﻢ ﺷﺪﮔی ۱ﮔﻮﻳﻨﺪ .ﺣﺘی ﻣیﺷﻮﺩ ﻛﻪ ﺩﻳﻜﺸﻨﺮﯼ ﺩﺍﺧﻞ ﺩﻳﻜﺸﻨﺮﯼ ﺩﻳﮕﺮ ﻭﺍﻗﻊ
ﺷﻮﺩ.
ﻟﻴﺴﺘی ﺍﺯ ﺩﻳﻜﺸﻨﺮﯼﻫﺎ ۱-۵-۵-۴
ﺑﻪ ﻣﺜﺎﻝ ﺯﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ.
1. nesting
ﺩﻳﻜﺸﻨﺮﯼ.۵-۴ ۶۴
In [1]: list_0 ={ 'color ':'green ',' points ':5}
list_1 ={ 'color ':' yellow ',' points ':10}
list_2 ={ 'color ':'red ',' points ':15}
lists =[ list_0 , list_1 , list_2 ]
for list in lists :
print ( list )
Out[1]: {'color ': 'green ', ' points ': 5}
{'color ': ' yellow ', ' points ': 10}
{'color ': 'red ', ' points ': 15}
ﻟﻴﺴﺖ ﺩﺭ ﺩﻳﻜﺸﻨﺮﯼ ۲-۵-۵-۴
، ﻟﻴﺴﺖ ﻣﻮﺍﺩ ﺭﻭ. ﻧﻮع ﭘﺎﻳﻪ )ﻧﺎﻥ ﻭ…( ﻭ ﻣﻮﺍﺩ ﺭﻭﯼ ﭘﻴﺘﺰﺍ.ﺩﺭ ﻣﺜﺎﻝ ﺯﻳﺮ ﺩﻭ ﻧﻮع ﺍﻃلاﻉ ﺩﺭ ﻫﺮ ﭘﻴﺘﺰﺍﻳﯽ ﺫﺧﻴﺮﻩ ﻣیﺷﻮﺩ
. ﺑﻪ ﻛﺪ ﺯﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ. ﻣﺮﺗﺒﻂ ﻣیﺷﻮﺩtoppings ﺑﻪ ﻛﻠﻴﺪ
In [2]: # Store information about a pizza being ordered .
pizza = {
'crust ': 'thick ',
' toppings ': [' mushrooms ', 'extra cheese '],
}
# Summarize the order.
print (" You ordered a " + pizza ['crust '] + "-crust pizza " +
" with the following toppings :")
for topping in pizza [' toppings ']:
print ("\t" + topping )
Out[2]: You ordered a thick - crust pizza with the following toppings :
mushrooms
extra cheese
:ﻣﺜﺎﻝ ﺩﺍﺷﺘﻦ ﭼﻨﺪﻳﻦ ﻟﻴﺴﺖ ﺩﺭ ﺩﻳﻜﺸﻨﺮﯼ
In [3]: favorite_languages = {
'ava ': [ ' python ', 'ruby '],
'sarah ': ['c'],
'amir ': [ 'ruby ', 'go '],
'emad ': [ ' python ', 'java '],
}
for name , languages in favorite_languages . items ():
print ("\n"+ name . title ()+ "'s favorite languages are :")
for language in languages :
print ("\t" + language . title ())
۶۵ ﺩﺍﺩﻩ ﺳﺎﺧﺘﺎﺭﻫﺎ.۴ ﻓﺼﻞ
Out[3]: Ava 's favorite languages are :
Python
Ruby
Sarah 's favorite languages are :
C
Ami r's favorite languages are :
Ruby
Go
Emad 's favorite languages are :
Python
Java
ﺩﻳﻜﺸﻨﺮﯼ ﺩﺭ ﺩﻳﻜﺸﻨﺮﯼ ۳-۵-۵-۴
ﺍﻟﺒﺘﻪ ُﻛﺪﻫﺎ ﻣیﺗﻮﺍﻧﺪ ﺍﻧﺪﻛی ﭘﻴﭽﻴﺪﻩ. ﺩﻳﻜﺸﻨﺮﯼ ﺩﻳﮕﺮﯼ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﺪ،ﺷﻤﺎ ﻣیﺗﻮﺍﻧﻴﺪ ﻛﻪ ﺩﺭ ﺩﺍﺧﻞ ﻳﮏ ﺩﻳﻜﺸﻨﺮﯼ
ﻛﺎﺭﺑﺮﻫﺎ. ﺑﺮﺍﯼ ﻫﺮ ﻛﺎﺭﺑﺮ ﻳﮏ ﺷﻨﺎﺳﻪ ﻛﺎﺭﺑﺮﯼ ﻣﻨﺤﺼﺮ ﺑﻔﺮﺩ ﺩﺍﺭﻳﻢ. ﺑﺮﺍﯼ ﻣﺜﺎﻝ ﭼﻨﺪ ﺷﻨﺎﺳﻪ ﻛﺎﺭﺑﺮﯼ ﺩﺍﺭﻳﻢ.ﺷﻮﺩ
ﺳﻪ. ﻣیﺗﻮﺍﻥ ﺍﻃلاﻋﺎﺕ ﻫﺮ ﻛﺎﺭﺑﺮ ﺭﺍ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺩﻳﻜﺸﻨﺮﯼ ﺫﺧﻴﺮﻩ ﻧﻤﻮﺩ.ﺩﺭ ﺣﻜﻢ ﻛﻠﻴﺪﻫﺎ ﺩﺭ ﺩﻳﻜﺸﻨﺮﯼ ﻫﺴﺘﻨﺪ
ﻭ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺣﻠﻘﻪ ﻭ ﺩﻳﻜﺸﻨﺮﯼ.ﺍﻃلاﻉ ﻫﺮ ﻛﺎﺭﺑﺮ ﺑﻪ ﺻﻮﺭﺕ ﻧﺎﻡ ﻭ ﻧﺎﻡﺧﺎﻧﻮﺍﺩﮔی ﻭ ﻣﺤﻞ ﺁﻧﻬﺎ ﺫﺧﻴﺮﻩ ﻣیﺷﻮﺩ
.ﻣیﺗﻮﺍﻥ ﺑﻪ ﺍﻃلاﻋﺎﺕ ﻫﺮ ﻛﺎﺭﺑﺮ ﺩﺳﺖ ﻳﺎﻓﺖ
:۱ ﻣﺜﺎﻝ
In [1]: users = {
' mmirzakhani ': {
'first ': ' maryam ',
'last ': ' mirzakhani ',
' location ': ' stanford ',
},
' mcurie ': {
'first ': 'marie ',
'last ': 'curie ',
' location ': 'paris ',
},
}
for username , user_info in users . items ():
print ("\ nUsername : " + username )
full_name = user_info ['first ']+" "+ user_info ['last ']
location = user_info [' location ']
print ("\ tFull name : " + full_name . title ())
print ("\ tLocation : " + location . title ())
ﺩﻳﻜﺸﻨﺮﯼ.۵-۴ ۶۶
Out[1]: Username : mmirzakhani
Full name : Maryam Mirzakhani
Location : Stanford
Username : mcurie
Full name : Marie Curie
Location : Paris
:۲ ﻣﺜﺎﻝ
In [1]: rec = {'name ': {'first ': 'Bob ', 'last ': 'Smith '},
'job ': [ 'dev ', 'mgr '],
'age ': 40}
print ( rec )
print ( rec [ 'name '])
print ( rec [ 'job '])
print ( rec [ 'job '][ -1])
Out[1]: {'name ':{ 'first ':'Bob ','last ':'Smith '},'job ':[ 'dev ','mgr '],
'age ':40}
{'first ':'Bob ','last ':'Smith '}
['dev ','mgr ']
mgr
ﭘﻴﺪﺍ ﻛﺮﺩﻥ ﻓﺮﺍﻭﺍﻧی ﻫﺮ ﻳﮏ ﺍﺯ ﺣﺮﻭﻑ ﺻﺪﺍﺩﺍﺭ ﺩﺭ ﻳﮏ ﻭﺍﮊﻩ:۳ ﻣﺜﺎﻝ
In [2]: vowels = ['a', 'e', 'i', 'o', 'u']
word = input (' provide a word to search for vowels ')
found ={}
found ['a']=0
found ['e']=0
found ['i']=0
found ['o']=0
found ['u']=0
for letter in word :
if letter in vowels :
found [ letter ] +=1
for k,v in sorted ( found . items ()):
print (k , 'was found ',v, 'time (s)')
۶۷ ﻓﺼﻞ .۴ﺩﺍﺩﻩ ﺳﺎﺧﺘﺎﺭﻫﺎ
Out[2]: provide a word to search for vowels afternoon
a was found 1 )time (s
e was found 1 )time (s
i was found 0 )time (s
o was found 2 )time (s
u was found 0 )time (s
۶-۴ﻣﺠﻤﻮﻋﻪ
ﻣﺠﻤﻮﻋﻪﺍﯼ ﺍﺯ ﻋﻨﺎﺻﺮ ﺭﺍ setﮔﻮﻳﻨﺪ ﻛﻪ ﺩﺭ ﺩﺍﺧﻞ ﺁﻛﻮلاﺩ ﻗﺮﺍﺭ ﻣیﮔﻴﺮﻧﺪ .ﺑﻴﺸﺘﺮ ﺷﺒﻴﻪ ﺩﻳﻜﺸﻨﺮﯼ ﺍﺳﺖ ﻛﻪ ﺻﺮﻓ ًﺎ
ﺩﺍﺭﺍﯼ ﻛﻠﻴﺪ ﺍﺳﺖ ﻭ ﻣﻘﺪﺍﺭ ﻧﺪﺍﺭﺩ .ﻧﺎﻣﺮﺗﺐ ﺍﺳﺖ ﻭ ﺗﻜﺮﺍﺭ ﻋﻨﺎﺻﺮ ﺭﺍ ﻧﻤیﭘﺬﻳﺮﺩ.
ﻣﺜﺎﻝ :۱
In [1]: )]x1= set ([1 ,2 ,3 ,4
)' x2= set ('spam
)print (x1
)print (x2
Out[1]: }{1 , 2, 3, 4
}'{'a ', 'p', 'm', 's
ﻣﺜﺎﻝ :۲ﺍﺷﺘﺮﺍﮎ ﺩﻭ ﻣﺠﻤﻮﻋﻪ
In [2]: }s1 ={1 ,2 ,3 ,4
}s1 &{1 ,3
Out[2]: }{1 , 3
ﻣﺜﺎﻝ :۳ﺍﺟﺘﻤﺎﻉ ﺩﻭ ﻣﺠﻤﻮﻋﻪ
In [3]: }s1 ={1 ,2 ,3 ,4
{1 ,5 ,3 ,6}| s1
Out[3]: }{1 , 2, 3, 4, 5, 6
ﻣﺜﺎﻝ :۴ﺗﻔﺎﺿﻞ ﺩﻭ ﻣﺠﻤﻮﻋﻪ
In [4]: }s1 -{1 ,3 ,4
Out[4]: }{2
ﻣﺜﺎﻝ :۵ﺗﻔﺎﺿﻞ ﺩﻭ ﻣﺠﻤﻮﻋﻪ
.۶-۴ﻣﺠﻤﻮﻋﻪ ۶۸
In [1]: )}print (s1 -{1 ,2 ,3 ,4
))}{( print ( type
Out[1]: )( set
>' <class 'dict
ﺗﻮﺟﻪ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ ﻧﻤﺎﻳﺶ ﻣﺠﻤﻮﻋﻪ ﺗﻬی ﺑﻪ ﺻﻮﺭﺕ }{ ﻧﻴﺴﺖ ،ﺯﻳﺮﺍ ﻋلاﻣﺖ ﺍﺧﻴﺮ ﻧﺸﺎﻥﺩﻫﻨﺪﻩ ﺩﻳﻜﺸﻨﺮﯼ
ﺧﺎﻟی ﺍﺳﺖ .ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﺩﺭ ﻛﺪ ﺑﺎلا ﻫﻢ ﻣﺸﺎﻫﺪﻩ ﻣیﺷﻮﺩ ،ﺗﺎﺑع )( typeﻫﻢ ﻧﻮع ﺁﻛﻮلاﺩ ﺑﺎﺯ ﻭ ﺑﺴﺘﻪ ﺭﺍ ﺩﻳﻜﺸﻨﺮﯼ
ﻣﻌﺮﻓی ﻣیﻛﻨﺪ.
���
۵
ﻋﻤﻠﻴﺎﺕ ﺭﻭﯼ ﻓﺎﻳﻞﻫﺎ ﻭ
ﻣﺪﻳﺮﻳﺖ ﺧﻄﺎﻫﺎ
۱-۵ﻣﻘﺪﻣﻪ
ﺑﺴﻴﺎﺭﯼ ﺍﺯ ﺍﻃلاﻋﺎﺕ ﻣﻮﺭﺩ ﻧﻈﺮ ﻣﺎ ﺩﺍﺧﻞ ﻓﺎﻳﻠی ﻛﻪ ﻛﺪﻫﺎﯼ ﻣﺎ ﺩﺭ ﺁﻥ ﻗﺮﺍﺭ ﺩﺍﺭﺩ ﻭﺟﻮﺩ ﻧﺪﺍﺭﺩ ،ﻭ ﺑﺮ ﺭﻭﯼ ﻓﺎﻳﻞﻫﺎﻳﯽ
ﺑﺎ ﭘﺴﻮﻧﺪ txtﻭ csvﻭ… ﺫﺧﻴﺮﻩ ﺷﺪﻩ ﺍﺳﺖ .ﻭ ﺩﺭ ﻭﺍﻗﻊ ﻧﺴﺒﺖ ﺑﻪ ﻓﺎﻳﻞ ﻛﺪﻫﺎ ،ﻓﺎﻳﻞ ﺧﺎﺭﺟی ﻣﺤﺴﻮﺏ ﻣیﺷﻮﻧﺪ .ﻳﺎ
ﺩﺍﺩﻩﻫﺎ ﺩﺭ ﺑﺮﻧﺎﻣﻪﻫﺎ ﺑﻪﺻﻮﺭﺕ ﻣﻮﻗﺖ ﻫﺴﺘﻨﺪ ،ﻣﮕﺮ ﺍﻳﻦ ﻛﻪ ﺁﻧﻬﺎ ﺭﺍ ﻣﺸﺨﺼﺎ ﺫﺧﻴﺮﻩ ﻛﻨﻴﻢ .ﺩﺭ ﻏﻴﺮ ﺍﻳﻨﺼﻮﺭﺕ ،ﺩﺭ
ﺍﻧﺘﻬﺎﯼ ﺑﺮﻧﺎﻣﻪ ﺍﺯ ﺩﺳﺖ ﺧﻮﺍﻫﻨﺪ ﺭﻓﺖ .ﺑﺮﺍﯼ ﺍﻳﻦ ﻛﻪ ﺩﺍﺩﻩﻫﺎﯼ ﺍﻳﺠﺎﺩ ﺷﺪﻩ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺑﻪﺻﻮﺭﺕ ﺩﺍﺋﻤی ﺑﺎﻗی ﺑﻤﺎﻧﻨﺪ،
لاﺯﻡ ﺍﺳﺖ ﻛﻪ ﺁﻧﻬﺎ ﺭﻭﯼ ﻓﺎﻳﻞ ﺩﺭ ﺍﺑﺰﺍﺭﯼ ﺫﺧﻴﺮﻩ ﺷﻮﻧﺪ.
ﺩﺭ ﺍﻳﻦ ﻓﺼﻞ ﻣیﺧﻮﺍﻫﻴﻢ ﻧﺤﻮﻩ ﺩﺳﺘﺮﺳی ﺑﻪ ﻓﺎﻳﻞﻫﺎﯼ ﺍﻃلاﻋﺎﺕ ﻭ ﻧﺤﻮﮤ ﭘﺮﺩﺍﺯﺵ ﺁﻧﻬﺎ ﺭﺍ ﺑﺮﺭﺳی ﻛﻨﻴﻢ.
۲-۵ﻧﺤﻮﮤ ﺩﺳﺘﺮﺳی ﺑﻪ ﻓﺎﻳﻞﻫﺎ
ﺑﺮﺍﯼ ﺩﺳﺘﺮﺳی ﺑﻪ ﻓﺎﻳﻞﻫﺎﯼ ﺩﺍﺩﻩﻫﺎ ،ﻧﺨﺴﺖ ﺑﺎﻳﺪ ﺁﻧﻬﺎ ﺭﺍ ﺑﺎﺯ ﻧﻤﻮﺩ .ﺍﻳﻦ ﻛﺎﺭ ﺗﻮﺳﻂ ﺗﺎﺑع )( openﺻﻮﺭﺕ ﻣیﮔﻴﺮﻳﺪ.
ﺩﺭ ﺍﻳﻦ ﺗﺎﺑع ﺩﻭ ﺁﺭﮔﻮﻣﺎﻥ ﻭﺟﻮﺩ ﺩﺍﺭﺩ .ﺍﻭﻝ ﻧﺎﻡ ﻓﺎﻳﻞ ﻭ ﺩﺭ ﺻﻮﺭﺕ ﻟﺰﻭﻡ ﺁﺩﺭﺱ ﻣﺤﻞ ﺫﺧﻴﺮﻩ ﻓﺎﻳﻞ ﻭ ﺩﻭﻡ ﺣﺎﻟﺖ ﺍﺳﺘﻔﺎﺩﻩ
ﺍﺯ ﺁﻧﻬﺎ ،ﺑﻪ ﻋﺒﺎﺭﺕ ﺩﻳﮕﺮ ﻣیﺧﻮﺍﻫﻴﻢ ﺩﺍﺩﻩﻫﺎﯼ ﺁﻥ ﺭﺍ ﺑﺨﻮﺍﻧﻴﻢ ﻳﺎ ﺭﻭﯼ ﻳﮏ ﻓﺎﻳﻞ ﺍﻃلاﻋﺎﺕ ﻣﻮﺭﺩ ﻧﻈﺮ ﺭﺍ ﺑﻨﻮﻳﺴﻴﻢ ﻭ ﻳﺎ
ﻳﮏ ﻓﺎﻳﻞ ﺑﺮﻭﺯ ﺭﺳﺎﻧی ﻛﻨﻴﻢ .ﺗﻮﺟﻪ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ ﺍﻳﻦ ﺩﻭ ﺁﺭﮔﻮﻣﺎﻥ ﺑﺎﻳﺪ ﺑﻪ ﺻﻮﺭﺕ ﺭﺷﺘﻪ ﺩﺍﺧﻞ ﺗﺎﺑع openﻗﺮﺍﺭ
ﮔﻴﺮﻧﺪ .ﺩﺳﺘﻮﺭ ﻛﻠی ﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﺍﺳﺖ.
)'file_variable=open('filename','mode
ﺩﺭ ﭘﺎﻳﺘﻮﻥ ﺳﻪ ﺗﺎ ﺣﺎﻟﺖ ﺍﺻﻠی ﺩﺭ ﻣﻮﺭﺩ ﻓﺎﻳﻞﻫﺎ ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﻛﻪ ﺷﺮح ﺁﻧﻬﺎ ﺩﺭ ﺍﺩﺍﻣﻪ ﺍﺭﺍﺋﻪ ﻣیﮔﺮﺩﺩ.
۶۹
.۳-۵ﺧﻮﺍﻧﺪﻥ ﻓﺎﻳﻞ ۷۰
۳-۵ﺧﻮﺍﻧﺪﻥ ﻓﺎﻳﻞ
ﭘﺲ ﺍﺯ ﺑﺎﺯ ﺷﺪﻥ ﻓﺎﻳﻞ ﺩﺍﺩﻩﻫﺎ ،ﺳﻴﺴﺘﻢ ﺑﺮﺍﯼ ﺣﺎﻟﺖ ﻣﻮﺭﺩ ﻧﻈﺮ ﻛﻪ ﺩﺭ ﺍﻳﻨﺠﺎ ﺧﻮﺍﻧﺪﻥ ﺍﺳﺖ ،ﻣیﺗﻮﺍﻥ ﻣﺤﺘﻮﻳﺎﺕ ﻓﺎﻳﻞ
ﺭﺍ ﺧﻮﺍﻧﺪ .ﺑﺮﺍﯼ ﺧﻮﺍﻧﺪﻥ ﻓﺎﻳﻞ ﺭﻭﺵﻫﺎﯼ ﮔﻮﻧﺎﮔﻮﻧی ﻭﺟﻮﺩ ﺩﺍﺭﺩ .ﻛﻪ ﺫﻳل ًا ﺑﻪ ﺁﻥ ﭘﺮﺩﺍﺧﺘﻪ ﻣیﺷﻮﺩ.
۱-۳-۵ﺧﻮﺍﻧﺪﻥ ﻓﺎﻳﻞ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺭﻭﺵ read
ﻓﺮﺽ ﻛﻨﻴﺪ ﻛﻪ ﻧﺎﻡ ﻓﺎﻳﻞ ﻭﺭﻭﺩﯼ input.txtﺑﺎﺷﺪ ﻭ ﻗﺮﺍﺭ ﺍﺳﺖ ﻛﻪ ﺁﻥ ﺭﺍ ﺑﺨﻮﺍﻧﻴﻢ.
)'infile=open('input.txt','r
ﺁﺭﮔﻮﻣﺎﻥ ' (read) 'rﻧﺸﺎﻥ ﻣیﺩﻫﺪ ﻛﻪ ﻓﺎﻳﻞ ﺑﺮﺍﯼ ﺧﻮﺍﻧﺪﻥ ﺑﺎﺯ ﺷﺪﻩ ﺍﺳﺖ .ﺍﮔﺮ ﺁﺭﮔﻮﻣﺎﻥ ﺩﻭﻡ ﮔﺬﺍﺷﺘﻪ ﻧﺸﻮﺩ ،ﭘﻴﺶﻓﺮﺽ
ﺑﺎﺯ ﺷﺪﻥ ﻓﺎﻳﻞ ﺩﺍﺩﻩﻫﺎ ' 'rﺧﻮﺍﻫﺪ ﺑﻮﺩ.
لاﺯﻡ ﺑﻪ ﻳﺎﺩﺁﻭﺭﯼ ﺍﺳﺖ ﻛﻪ ﻓﺎﻳﻞ ﺩﺍﺩﻩﻫﺎ ﺑﺎﻳﺪ ﺍﺯ ﻗﺒﻞ ﻭﺟﻮﺩ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ ﻭﮔﺮﻧﻪ ﺑﺮﻧﺎﻣﻪ ﺧﻄﺎ ﻣیﺩﻫﺪ .ﺿﻤﻨ ًﺎ ﻓﺎﻳﻠی ﻛﻪ
ﺑﻪ ﺣﺎﻟﺖ ﺧﻮﺍﻧﺪﻥ ﺑﺎﺯ ﻣیﺷﻮﺩ ،ﻧﻤیﺗﻮﺍﻥ ﺭﻭﯼ ﺁﻥ ﻧﻮﺷﺖ.
ﺍﮔﺮ ﻓﺎﻳﻞ ﺩﺍﺩﻩ ﺩﺭ ﭘﻮﺷﻪ ﺟﺎﺭﯼ ﻧﺒﺎﺷﺪ ﺑﺎﻳﺪ ﻣﺴﻴﺮ ﻗﺮﺍﺭ ﮔﺮﻓﺘﻦ ﻓﺎﻳﻞ ﻫﻢ ﮔﻔﺘﻪ ﺷﻮﺩ .ﻭﮔﺮﻧﻪ ﺑﺮﻧﺎﻣﻪ ﻓﺎﻳﻞ ﻣﻮﺭﺩ ﻧﻈﺮ ﺷﻤﺎ
ﺭﺍ ﭘﻴﺪﺍ ﻧﻤیﻛﻨﺪ ﻭ ﺧﻄﺎ ﻣیﺩﻫﺪ .ﻓﺮﺽ ﻛﻨﻴﺪ ﻛﻪ ﻓﺎﻳﻞ ﺷﻤﺎ ﺩﺭ ﺩﺍﻳﺮﻛﺘﻮﺭﯼ Eﻭ ﺩﺭ ﭘﻮﺷﮥ py_courseﺑﺎﺷﺪ ،ﺁﻧﮕﺎﻩ
ﺁﺭﮔﻮﻣﺎﻥ ﺍﻭﻝ openﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﺍﺳﺖ:
''E:/py_course/input.txt
ﺭﻭﺵ )( readﻛﻞ ﻣﺤﺘﻮﻳﺎﺕ ﻓﺎﻳﻞ ﺭﺍ ﻳﻜﺠﺎ ﻣیﺧﻮﺍﻧﺪ ﻭ ﺩﺭ ﺣﺎﻓﻈﻪ ﻣیﻧﺸﺎﻧﺪ .ﻓﺮﺽ ﻛﻨﻴﺪ ﻛﻪ ﻓﺎﻳﻞ ﻭﺭﻭﺩﯼ ﺑﻪ ﻧﺎﻡ
text.txtﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﺑﺎﺷﺪ.
Flight
No . 1 0
I r a n Air
ﺍﻛﻨﻮﻥ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﺯﻳﺮ ،ﻓﺎﻳﻞ ﺑﺎلا ﺧﻮﺍﻧﺪﻩ ﻣیﺷﻮﺩ.
In [1]: # Read a file with read () method
)' infile = open ('text . txt
))( print ( infile . read
Out[1]: Flight
No .10
Iran Air
ﺍﻛﻨﻮﻥ ﺍﮔﺮ ﺭﻭﺵ )( readﻣﻘﺪﺍﺭ ﺑﮕﻴﺮﺩ ﭼﻪ ﺍﺗﻔﺎﻗی ﺭخ ﻣیﺩﻫﺪ .ﺑﻪ ﻣﺜﺎﻝ ﺯﻳﺮ ﺗﻮﺟﻪ ﻛﻨﻴﺪ .ﻓﺮﺽ ﻛﻨﻴﺪ ﻛﻪ ﻣﺤﺘﻮﻳﺎﺕ
ﻓﺎﻳﻞ toto.txtﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﺑﺎﺷﺪ.
Hello , world .
welcome .
In [2]: )' infile = open ('toto . txt
))line = print ( infile . read (4
۷۱ ﻓﺼﻞ .۵ﻋﻤﻠﻴﺎﺕ ﺭﻭﯼ ﻓﺎﻳﻞﻫﺎ ﻭ ﻣﺪﻳﺮﻳﺖ ﺧﻄﺎﻫﺎ
Out[2]: Hell
ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﻣﺸﺎﻫﺪﻩ ﻣیﺷﻮﺩ ،ﻓﻘﻂ ﭼﻬﺎﺭ ﻛﺎﺭﺍﻛﺘﺮ ﺧﻮﺍﻧﺪﻩ ﺷﺪﻩ ﺍﺳﺖ .ﻭ ﺩﺭ ﺍﺩﺍﻣﻪ ﺩﺍﺭﻳﻢ ﻛﻪ:
In [1]: ))print ( infile . read (2
Out[1]: o,
ﺩﺭ ﺍﺩﺍﻣﻪ ﺧﻮﺍﻧﺪﻥ ﻓﺎﻳﻞ ،ﺗﻨﻬﺎ ﺩﻭ ﻛﺎﺭﺍﻛﺘﺮ ﺧﻮﺍﻧﺪﻩ ﻣیﺷﻮﺩ .ﺍﻛﻨﻮﻥ ﺭﻭﺵ )( readﺭﺍ ﺑﺪﻭﻥ ﻋﺪﺩ ﺑﻪ ﻛﺎﺭ ﻣیﮔﻴﺮﻳﻢ.
In [2]: ))( print ( infile . read
Out[2]: world .
welcome .
ﺑﻪ ﺍﻳﻦ ﺗﺮﺗﻴﺐ ﺑﻘﻴﻪ ﻓﺎﻳﻞ ﺗﺎ ﭘﺎﻳﺎﻥ ﺁﻥ ﺧﻮﺍﻧﺪﻩ ﻣیﺷﻮﺩ.
ﺍﮔﺮ ﺑﺨﻮﺍﻫﻴﻢ ﻧﺸﺎﻧﮕﺮ ﻓﺎﻳﻞ ﺭﺍ ﺑﻪ ﻧﻘﻄﻪ ﻣﻮﺭﺩ ﻧﻈﺮ ﻣﻨﺘﻘﻞ ﻛﻨﻴﻢ ،ﺍﺯ ﺭﻭﺵ )( seekﺍﺳﺘﻔﺎﺩﻩ ﻣیﺷﻮﺩ .ﺩﺭ ﻣﺜﺎﻝ ﺯﻳﺮ
ﻗﺮﺍﺭ ﺍﺳﺖ ﻛﻪ ﺑﻪ ﺍﺑﺘﺪﺍﯼ ﻓﺎﻳﻞ ﺩﺍﺩﻩ ﺑﺮﻭﻳﻢ .ﺑﺮﺍﯼ ﺍﻳﻦ ﻛﺎﺭ ﺩﺭ ﺭﻭﺵ ﺍﺧﻴﺮ ،ﻋﺪﺩ ﺻﻔﺮ ﺭﺍ ﻭﺍﺭﺩ ﻣیﻛﻨﻴﻢ.
In [3]: )infile . seek (0
Out[3]: 0
ﺍﻛﻨﻮﻥ ﺑﺮﺍﯼ ﺍﻳﻦ ﻛﻪ ﻣﻄﻤﺌﻦ ﺷﻮﻳﻢ ﻛﻪ ﻧﺸﺎﻧﮕﺮ ﺑﻪ ﺟﺎﯼ ﻣﻮﺭﺩ ﻧﻈﺮ ﻣﻨﺘﻘﻞ ﺷﺪﻩ ﺍﺳﺖ .ﻳﮏ ﺑﺎﺭ ﺩﻳﮕﺮ ﻓﺎﻳﻞ ﺭﺍ ﺑﻪ
ﺻﻮﺭﺕ ﻛﺎﻣﻞ ﻣیﺧﻮﺍﻧﻴﻢ.
In [4]: ))( print ( infile . read
Out[4]: Hello , world .
welcome .
ﺧﻮﺍﻧﺶ ﺑﺎلا ﻧﺸﺎﻥ ﻣیﺩﻫﺪ ﻛﻪ ﻧﺸﺎﻧﮕﺮ ﺑﻪ ﻣﺤﻞ ﺻﻔﺮ ،ﻳﻌﻨی ﺑﻪ ﺍﺑﺘﺪﺍﯼ ﻓﺎﻳﻞ ﻣﻨﺘﻘﻞ ﺷﺪﻩ ﺍﺳﺖ .ﭼﺮﺍ ﻛﻪ ﺗﻤﺎﻡ
ﻣﺤﺘﻮﻳﺎﺕ ﻓﺎﻳﻞ ﺧﻮﺍﻧﺪﻩ ﺷﺪﻩ ﺍﺳﺖ.
۲-۳-۵ﺧﻮﺍﻧﺪﻥ ﻓﺎﻳﻞ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺭﻭﺵ readline
ﺭﻭﺵ ﺩﻭﻡ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ )( readlineﺍﺳﺖ .ﻭﻗﺘی ﻛﻪ ﻓﺎﻳﻞ ﺑﺎﺯ ﺷﺪ .ﻧﺸﺎﻧﮕﺮ ﺳﻴﺴﺘﻢ ﺩﺭ ﺳﻄﺮ ﻧﺨﺴﺖ ﻭ ﺩﺭ ﺍﺑﺘﺪﺍﯼ ﺁﻥ
ﻗﺮﺍﺭ ﻣیﮔﻴﺮﺩ .ﺭﻭﺵ )( readlineﺍﺯ ﻣﺤﻞ ﻗﺮﺍﺭﮔﻴﺮﯼ ﻧﺸﺎﻧﮕﺮ ﺗﺎ ﺁﺧﺮ ﺳﻄﺮ ﺟﺎﺭﯼ ﺭﺍ ﻣیﺧﻮﺍﻧﺪ .ﻭ ﺳﭙﺲ ﻧﺸﺎﻧﮕﺮ ﺑﻪ
ﺳﻄﺮ ﺑﻌﺪﯼ ﻣﻨﺘﻘﻞ ﻣیﺷﻮﺩ .ﺑﻨﺎﺑﺮﺍﻳﻦ ﻓﺎﻳﻞ ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﺳﻄﺮ ﺑﻪ ﺳﻄﺮ ﺧﻮﺍﻧﺪﻩ ﻣیﺷﻮﺩ ﻭ ﻧﻪ ﻳﮏ ﺑﺎﺭﻩ.
ﻓﺮﺽ ﻛﻨﻴﺪ ﻛﻪ ﻓﺎﻳﻞ ﻭﺭﻭﺩﯼ ﺷﺎﻣﻞ ﺳﻪ ﺳﻄﺮ ﺍﺳﺖ.
flight
No . 1 0
I r a n Air
.۳-۵ﺧﻮﺍﻧﺪﻥ ﻓﺎﻳﻞ ۷۲
ﺩﺭ ﻧﺨﺴﺘﻴﻦ ﻓﺮﺍﺧﻮﺍﻥ ﻓﺎﻳﻞ ،ﺭﺷﺘﮥ ' 'flight\nﺧﻮﺍﻧﺪﻩ ﻣیﺷﻮﺩ .ﻳﺎﺩﺁﻭﺭﯼ ﻣیﮔﺮﺩﺩ ﻛﻪ )' '( ﺑﻪ ﻣﻌﻨی ﺳﻄﺮ ﺟﺪﻳﺪ ﺍﺳﺖ.
ﻭ ﺍﮔﺮ ﺩﻭﺑﺎﺭﻩ )( readlineﻓﺮﺍﺧﻮﺍﻧی ﺷﻮﺩ ﺭﺷﺘﮥ ' 'No.10\nﺧﻮﺍﻧﺪﻩ ﻣیﺷﻮﺩ .ﻭ ﺍﮔﺮ ﺑﺮﺍﯼ ﺑﺎﺭ ﺳﻮﻡ )(readline
ﻓﺮﺍﺧﻮﺍﻧی ﺷﻮﺩ ﺭﺷﺘﮥ ' 'Iran Airﺧﻮﺍﻧﺪﻩ ﻣیﺷﻮﺩ .ﻭ ﺍﮔﺮ ﺑﺮﺍﯼ ﺑﺎﺭ ﭼﻬﺎﺭﻡ ﺗﻜﺮﺍﺭ ﮔﺮﺩﺩ ،ﺁﻧﮕﺎﻩ ﻓﻘﻂ ﺭﺷﺘﮥ )' '( ﺭﺍ
ﺑﺪﺳﺖ ﻣیﺩﻫﺪ .ﻛﻪ ﺑﻪ ﻣﻌﻨﺎﯼ ﭘﺎﻳﺎﻥ ﻓﺎﻳﻞ ﺍﺳﺖ .ﺍﮔﺮ ﻓﺎﻳﻞ ﺷﺎﻣﻞ ﺳﻄﺮ ﺧﺎﻟی ﺑﺎﺷﺪ ،ﺭﺷﺘﮥ ﺣﺎﺻﻞ ﺷﺎﻣﻞ ' '\nﺍﺳﺖ.
ﻛﻪ ﺑﻪ ﻣﻌﻨﺎﯼ ﺳﻄﺮ ﺧﺎﻟی ﺍﺳﺖ.
ﻣﺜﺎﻝ:
In [1]: )' infile = open ('text . txt
))( print ( infile . readline
))( print ( infile . readline
))( print ( infile . readline
Out[1]: Flight
No .10
Iran Air
ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﻣﺸﺎﻫﺪﻩ ﻣیﺷﻮﺩ .ﺑﻴﻦ ﻣﻮﺍﺭﺩ ﭼﺎﭖ ﺷﺪﻩ ﺳﻄﺮﻫﺎﯼ ﺧﺎﻟی ﺍﻳﺠﺎﺩ ﻣیﺷﻮﺩ .ﭼﺮﺍ ﻫﺮ ' '\nﻳﮏ ﺳﻄﺮ
ﻋﻮﺽ ﻣیﻛﻨﺪ ﻭ ﻫﻢ ﻓﺮﺍﺧﻮﺍﻧی ﺩﺳﺘﻮﺭ printﻧﻴﺰ ﻛﻨﺘﺮﻝ ﺭﺍ ﺑﻪ ﺳﻄﺮ ﺑﻌﺪﯼ ﻣیﺑﺮﺩ .ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺭﻭﺵ )(rstrip
ﻣیﺗﻮﺍﻥ ' '\nﺭﺍ ﺣﺬﻑ ﻧﻤﻮﺩ.
In [2]: )' infile = open ('text . txt
))( print ( infile . readline (). rstrip
))( print ( infile . readline (). rstrip
))( print ( infile . readline
Out[2]: Flight
No .10
Iran Air
ﺍﻛﻨﻮﻥ ﻣیﺧﻮﺍﻫﻴﻢ ﺑﻪ ﺭﻭﺵ )( readlineﻣﻘﺪﺍﺭ ﺑﺪﻫﻴﻢ .ﺑﻪ ﻋﻨﻮﺍﻥ ﻣﺜﺎﻝ ﻣﻘﺪﺍﺭ ۳ﺍﺧﺘﻴﺎﺭ ﻣیﺷﻮﺩ.
In [3]: )'infile = open ('text . txt ','r
))print ( infile . read (3
Out[3]: Fli
ﭘﺲ ﺳﻪ ﻛﺎﺭﺍﻛﺘﺮ ﺧﻮﺍﻧﺪﻩ ﺷﺪ .ﺍﻣﺎ ﺍلاﻥ ﻧﺸﺎﻧﮕﺮ ﻓﺎﻳﻞ ﻛﺠﺎﺳﺖ؟ ﺑﺮﺍﯼ ﻳﺎﻓﺘﻦ ﻣﻜﺎﻥ ﻧﺸﺎﻧﮕﺮ ﺍﺯ ﺭﻭﺵ )( tellﺍﺳﺘﻔﺎﺩﻩ
ﻣیﺷﻮﺩ .ﭘﺲ ﺁﻥ ﺭﺍ ﺍﺟﺮﺍ ﻣیﻛﻨﻴﻢ.
In [4]: )( infile . tell
Out[4]: 3
۷۳ ﻓﺼﻞ .۵ﻋﻤﻠﻴﺎﺕ ﺭﻭﯼ ﻓﺎﻳﻞﻫﺎ ﻭ ﻣﺪﻳﺮﻳﺖ ﺧﻄﺎﻫﺎ
ﻳﻌﻨی ﻧﺸﺎﻧﮕﺮ ﺍﺯ ﻣﺤﻞﻫﺎﯼ ۱ ،۰ﻭ ۲ﻋﺒﻮﺭ ﻛﺮﺩﻩ ﺩﺭ ﻣﻜﺎﻥ ۳ﻗﺮﺍﺭ ﺩﺍﺭﺩ .ﺣﺎلا ﻣﻘﺪﺍﺭ ۶ﺭﺍ ﺑﻪ ﺭﻭﺵ )(readline
ﻣیﺩﻫﻴﻢ.
In [1]: ))print ( infile . read (6
Out[1]: ght
No
ﺍلاﻥ ﻣﻜﺎﻥ ﻗﺮﺍﺭ ﮔﺮﻓﺘﻦ ﻧﺸﺎﻧﮕﺮ ﺩﺭ ﺣﺎﻝ ﺣﺎﺿﺮ ﻛﺠﺎﺳﺖ؟
In [2]: )( infile . tell
Out[2]: 9
ﺗﻮﺟﻪ ﺩﺍﺷﺘﻪ ﺑﺎﺷﻴﺪ ﻛﻪ ﺍﻧﺪﻳﺲ ﻣﻜﺎﻥﻫﺎ ﺍﺯ ﺻﻔﺮ ﺷﺮﻭع ﻣیﺷﻮﺩ .ﺿﻤﻨ ًﺎ ﺍﻧﺘﻬﺎﯼ ﻫﺮ ﺳﻄﺮ ﻫﻢ ﻳﮏ ﺟﺎﯼ ﺧﺎﻟی ﺍﺳﺖ
) \nﺷﻤﺎﺭﺵ ﻧﻤیﺷﻮﺩ (.ﻛﻪ ﺁﻥ ﻫﻢ ﺷﻤﺮﺩﻩ ﻣیﺷﻮﺩ .ﭘﺲ ﻣﻜﺎﻥ ﻧﺸﺎﻧﮕﺮ ﻓﺎﻳﻞ ﺩﺭ ﻣﻘﺎﺑﻞ ﻛﺎﺭﺍﻛﺘﺮ ) (.ﺩﺭ ﺳﻄﺮ ﺩﻭﻡ
ﻗﺮﺍﺭ ﺩﺍﺭﺩ.
۳-۳-۵ﺧﻮﺍﻧﺪﻥ ﻓﺎﻳﻞ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺭﻭﺵ readlines
ﺩﺭ ﺍﻳﻦ ﺭﻭﺵ ﻛﻞ ﻓﺎﻳﻞ ﺧﻮﺍﻧﺪﻩ ﻣیﺷﻮﺩ .ﻣﻨﺘﻬﺎ ﺧﺮﻭﺟی ﺑﻪ ﺻﻮﺭﺕ ﻟﻴﺴﺖ ﺍﺳﺖ .ﻭ ﻫﺮ ﺳﻄﺮ ﻓﺎﻳﻞ ﻳﮏ ﻋﻀﻮ ﻟﻴﺴﺖ
ﺭﺍ ﺗﺸﻜﻴﻞ ﻣیﺩﻫﺪ .ﻣﺜﺎﻝ:
In [3]: )'infile = open ('text . txt ','r
))( print ( infile . readlines
Out[3]: ]' [' Flight \n', 'No .10\ n', 'Iran Air
ﺩﺭ ﺣﺎﻝ ﺣﺎﺿﺮ ﻧﺸﺎﻧﮕﺮ ﻓﺎﻳﻞ ﻛﺠﺎﺳﺖ؟
In [4]: )( infile . tell
Out[4]: 21
ﺑﻴﺎﻳﻢ ﺩﻭﺑﺎﺭﻩ ﺑﻪ ﺍﺑﺘﺪﺍﯼ ﻓﺎﻳﻞ ﺑﺮﮔﺮﺩﻳﻢ.
In [5]: )infile . seek (0
Out[5]: 0
ﺣﺎلا ﺑﻪ ﺭﻭﺵ readlinesﻣﻘﺪﺍﺭ ﺑﺪﻫﻴﻢ .ﺑﻪ ﻋﻨﻮﺍﻥ ﻣﺜﺎﻝ ﻣﻘﺪﺍﺭ ۳ﺭﺍ ﺍﺧﺘﻴﺎﺭ ﻣیﺷﻮﺩ.
In [6]: ))print ( infile . readlines (3
Out[6]: ]'[' Flight \n
.۳-۵ﺧﻮﺍﻧﺪﻥ ﻓﺎﻳﻞ ۷۴
ﻫﻤﺎﻥﻃﻮﺭ ﻛﻪ ﻣلاﺣﻈﻪ ﻣیﻛﻨﻴﺪ ،ﺍﻳﻦ ﺭﻭﺵ ﺑﻪ ﻣﻘﺪﺍﺭ ﺩﺍﺩﻩ ﺷﺪﻩ ﺗﻮﺟﻪ ﻧﺪﺍﺭﺩ .ﻭ ﺗﻨﻬﺎ ﺗﻔﺎﻭﺕ ﺍﻳﻦ ﺍﺳﺖ ﻛﻪ ﺳﻄﺮ ﺍﻭﻝ
ﻓﺎﻳﻞ ﺭﺍ ﺗﺎ ﺍﻧﺘﻬﺎ ﺩﺭ ﻟﻴﺴﺖ ﺧﺮﻭﺟی ﻧﺸﺎﻥ ﻣیﺩﻫﺪ.
ﺍﻛﻨﻮﻥ ﺑﺒﻴﻨﻴﻢ ﻛﻪ ﻣﻜﺎﻥ ﻧﺸﺎﻧﮕﺮ ﺩﺭ ﻓﺎﻳﻞ ﻛﺠﺎﺳﺖ؟
In [1]: )( infile . tell
Out[1]: -----------------------------------------------------------
OSError
) Traceback ( most recent call last
Cell In [32] , line 1
)( ----> 1 infile . tell
OSError : telling position disabled by next () call
ﺑﺎ ﻣﺸﺨﺺ ﻛﺮﺩﻥ ﻣﻘﺪﺍﺭ ﺑﺮﺍﯼ ﺭﻭﺵ )( readlinesﺩﻳﮕﺮ ﻧﻤیﺗﻮﺍﻥ ﻣﻜﺎﻥ ﻧﺸﺎﻧﮕﺮ ﺭﺍ ﻣﻌﻴﻦ ﻧﻤﻮﺩ ﻭ ﺑﺮﻧﺎﻣﻪ ﻣﻮﺍﺟﻪ ﺑﺎ
ﺧﻄﺎ ﻣیﺷﻮﺩ .ﺑﻨﺎﺑﺮﺍﻳﻦ ﺩﺭ ﺭﻭﺵ ﻳﺎﺩ ﺷﺪﻩ ﻧﺒﺎﻳﺪ ﻣﻘﺪﺍﺭﯼ ﺭﺍ ﺑﺮﺍﯼ ﺁﻥ ﺗﻌﻴﻴﻦ ﻧﻤﻮﺩ.
ﻣﺤﻴﻂ with ۴-۳-۵
ﺷﻤﺎ ﻭﻗﺘی ﻛﻪ ﺩﺭ ﺑﺮﻧﺎﻣﻪ ﻳﮏ ﻓﺎﻳﻞ ﺑﺎﺯ ﻣیﻛﻨﻴﺪ .ﺑﺮﻧﺎﻣﻪﻫﺎﯼ ﺩﻳﮕﺮ ﻧﻤیﺗﻮﺍﻧﻨﺪ ﺍﺯ ﺁﻥ ﭼﻴﺰﯼ ﺑﺨﻮﺍﻧﻨﺪ ﻳﺎ ﺭﻭﯼ ﺁﻥ ﭼﻴﺰﯼ
ﺑﻨﻮﻳﺴﻨﺪ .ﭘﺲ ﺑﻌﺪ ﺍﺯ ﺍﻳﻦ ﻛﻪ ﻛﺎﺭ ﺑﺎ ﻓﺎﻳﻞ ﻣﻮﺭﺩ ﻧﻈﺮ ﺷﺪ ،ﺑﺎﻳﺪ ﺁﻥ ﺭﺍ ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺭﻭﺵ )( closeﺑﺒﻨﺪﻳﺪ .ﺣﺎﻝ ﻣﻤﻜﻦ
ﺍﺳﺖ ﻛﻪ ﺍﺣﻴﺎﻧ ًﺎ ﻓﺮﺍﻣﻮﺵ ﺷﻮﺩ ﻛﻪ ﻓﺎﻳﻞ ﺑﺴﺘﻪ ﺷﻮﺩ .ﺑﺮﺍﯼ ﺍﻳﻦ ﻛﻪ ﺑﺮﻧﺎﻣﻪ ﺧﻮﺩ ﺑﺨﻮﺩ ﺍﻳﻦ ﻛﺎﺭ ﺍﻧﺠﺎﻡ ﺷﻮﺩ ،ﺍﺯ ﻣﺤﻴﻄی
ﺑﻪ ﻧﺎﻡ withﺍﺳﺘﻔﺎﺩﻩ ﻣیﺷﻮﺩ .ﺑﻪ ﻋﻨﻮﺍﻥ ﻣﺜﺎﻝ:
In [2]: with open ('toto . txt ','r') as infile :
))print ( infile . read (5
))print ( infile . read (3
Out[2]: Hello
-----------------------------------------------------------
ValueError
) Traceback ( most recent call last
Cell In [47] , line 4
1 with open ('toto . txt ','r') as infile :
2 ))print ( infile . read (5
))----> 4 print ( infile . read (3
ValueError : I/O operation on closed file .
ﺑﺮﺍﯼ ﺩﺳﺘﻮﺭ printﺍﻭﻟی ﻛﻪ ﺩﺍﺧﻞ ﻣﺤﻴﻂ withﺍﺳﺖ .ﺑﺮﻧﺎﻣﻪ ﺍﺟﺮﺍ ﻣیﺷﻮﺩ ﻭ ﺣﺎﺻﻞ Helloﺍﺳﺖ .ﺍﻣﺎ ﺑﻪ ﻣﺤﺾ
ﺧﺎﺭج ﺷﺪﻥ ﺍﺯ ﻣﺤﻴﻂ ﻳﺎﺩ ﺷﺪﻩ ،ﻓﺎﻳﻞ ﺧﻮﺩ ﺑﺨﻮﺩ ﺑﺴﺘﻪ ﻣیﺷﻮﺩ .ﺑﻨﺎﺑﺮﺍﻳﻦ ﻧﻤیﺗﻮﺍﻥ ﻋﻤﻠﻴﺎﺗی ﺭﻭﯼ ﺁﻥ ﺍﻧﺠﺎﻡ ﺩﺍﺩ ﻭ
ﺑﺮﺍﯼ ﻫﻤﻴﻦ ﺍﺳﺖ ﻛﻪ ﺑﺮﻧﺎﻣﻪ ﺑﺮﺍﯼ ﺩﻭﻣﻴﻦ printﺑﺎ ﺧﻄﺎ ﻣﻮﺍﺟﻪ ﻣیﺷﻮﺩ .ﺑﺎ ﺍﻳﻦ ﻣﺤﻴﻂ ﻣیﺗﻮﺍﻥ ﺳﻄﺮ ﺑﻪ ﺳﻄﺮ ﻓﺎﻳﻞ
۷۵ ﻓﺼﻞ .۵ﻋﻤﻠﻴﺎﺕ ﺭﻭﯼ ﻓﺎﻳﻞﻫﺎ ﻭ ﻣﺪﻳﺮﻳﺖ ﺧﻄﺎﻫﺎ
ﺭﺍ ﭘﻴﻤﺎﻳﺶ ﻧﻤﻮﺩ .ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺍﻳﻦ ﺧﺎﺻﻴﺖ ﻣیﺗﻮﺍﻥ ﺳﻄﺮﻫﺎﯼ ﻓﺎﻳﻠی ﻛﻪ ﺧﺎﻟی ﺍﺳﺖ ﺭﺍ ﺣﺬﻑ ﻧﻤﻮﺩ ﻭ ﻣﺤﺘﻮﺍﯼ
ﺳﻄﺮﻫﺎﯼ ﻏﻴﺮ ﺧﺎﻟی ﺩﺭﻭﻥ ﻳﮏ ﻓﺎﻳﻞ ﺧﺮﻭﺟی ﻧﻮﺷﺖ .ﻓﺎﻳﻞ b_linesﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﺍﺳﺖ.
? Hey , how a r e you
f i n e , t h a n k you .
s e e you l a t e r .
ﻓﺎﻳﻞ ﺑﺎلا ﺩﻭ ﺳﻄﺮ ﺧﺎﻟی ﺩﺍﺭﺩ ﻛﻪ ﺑﺎﻳﺪ ﺣﺬﻑ ﺷﻮﺩ.
In [1]: )'with open (' b_lines . txt ') as infile , open (' output . txt ', 'w
as outfile :
for line in infile :
if not line . strip ():
continue # skip the empty line.
outfile . write ( line ) #otherwise ,write it to output .
ﺍﻛﻨﻮﻥ ﻓﺎﻳﻞ ﺧﺮﻭﺟی ﺭﺍ ﻣیﺧﻮﺍﻧﻴﻢ.
In [2]: )' f= open (' output . txt
))( print (f. read
Out[2]: ? Hey , how are you
fine , thank you .
see you later .
ﻧﺴﺒﺖ ﺩﺍﺩﻥ ﻣﺤﺘﻮﯼ ﻓﺎﻳﻞ ﺑﻪ ﻳﮏ ﻣﺘﻐﻴﺮ ۵-۳-۵
ﻗﺒل ًا ﺩﻳﺪﻳﻢ ﻛﻪ ﺑﺎ ﺩﺳﺘﻮﺭ readﻳﮏ ﻓﺎﻳﻞ ﺑﻪﻃﻮﺭ ﻛﺎﻣﻞ ﺧﻮﺍﻧﺪﻩ ﻣیﺷﻮﺩ .ﺍﻣﺎ ﺍﮔﺮ ﻋﻤﻞ ﺧﻮﺍﻧﺪﻥ ﺭﺍ ﺗﻜﺮﺍﺭ ﻛﻨﻴﺪ ﭼﻴﺰﯼ
ﭼﺎﭖ ﻧﻤیﺷﻮﺩ ،ﭼﺮﺍ ﻛﻪ ﻧﺸﺎﻧﮕﺮ ﺩﺭ ﭘﺎﻳﺎﻥ ﻓﺎﻳﻞ ﻗﺮﺍﺭ ﺩﺍﺭﺩ .ﻣﮕﺮ ﺍﻳﻦ ﻛﻪ ﭘﻴﺶ ﺍﺯ ﺧﻮﺍﻧﺪﻥ ﻣﺠﺪﺩ ،ﺑﺎ ﺩﺳﺘﻮﺭ seek
ﻧﺸﺎﻧﮕﺮ ﺑﻪ ﺍﺑﺘﺪﺍﯼ ﻓﺎﻳﻞ ﺑﺮﻭﺩ ،ﺳﭙﺲ ﻣﺠﺪﺩﺍ ﻓﺎﻳﻞ ﺭﺍ ﺧﻮﺍﻧﺪﻩ ،ﺗﺎ ﻛﻞ ﻣﺤﺘﻮﯼ ﻓﺎﻳﻞ ﺑﺪﺳﺖ ﺁﻳﺪ .ﺍﻣﺎ ﺍﮔﺮ ﻣﺤﺘﻮﯼ ﺭﺍ
ﺑﻪ ﻣﺘﻐﻴﺮﯼ ﻧﺴﺒﺖ ﺩﻫﻴﻢ ،ﻫﺮ ﭼﻨﺪ ﺑﺎﺭ ﻛﻪ ﺑﺨﻮﺍﻫﻴﻢ ﺑﻪ ﻣﺤﺘﻮﯼ ﻓﺎﻳﻞ ﺑﺪﻭﻥ ﺗﻐﻴﻴﺮ ﻣﻜﺎﻥ ﻧﺸﺎﻧﮕﺮ ﺩﺳﺘﺮﺳی ﺩﺍﺭﻳﻢ.
ﻣﺜﺎﻝ:
In [3]: )'infile = open ('toto . txt ','r
)( fi= infile . read
)print (fi
Out[3]: Hello , world .
welcome .
ﺣﺎلا ﺑﺪﻭﻥ ﻫﻴچ ﮔﻮﻧﻪ ﻋﻤﻠی ﺩﻭﺑﺎﺭﻩ ﻣﺘﻐﻴﺮ fiﺭﺍ ﭼﺎﭖ ﻣیﻛﻨﻴﻢ.
In [4]: )print (fi
.۴-۵ﻧﻮﺷﺘﻦ ﺭﻭﯼ ﻓﺎﻳﻞ ۷۶
Out[4]: Hello , world .
welcome .
ﻣﺸﺎﻫﺪﻩ ﻣیﺷﻮﺩ ﻛﻪ ﻛﻞ ﻣﺠﺘﻮﻳﺎﺕ ﻓﺎﻳﻞ ﭼﺎﭖ ﺷﺪﻩ ﺍﺳﺖ.
۴-۵ﻧﻮﺷﺘﻦ ﺭﻭﯼ ﻓﺎﻳﻞ
ﺍﮔﺮ ﺑﺨﻮﺍﻫﻴﻢ ﺩﺭﻭﻥ ﻓﺎﻳﻠی ﺑﻨﻮﻳﺴﻴﻢ (write).ﺑﺎﻳﺪ ﺁﺭﮔﻮﻣﺎﻥ ﺩﻭﻡ ﺑﻪ ﺻﻮﺭﺕ ' 'wﺑﺎﺷﺪ .ﺍﮔﺮ ﻓﺎﻳﻠی ﺑﺎ ﺍﻳﻦ ﺣﺎﻟﺖ ﺑﺎﺷﺪ،
ﺩﻳﮕﺮ ﻗﺎﺑﻞ ﺧﻮﺍﻧﺪﻥ ﻧﻴﺴﺖ.
ﺍﮔﺮ ﻓﺎﻳﻞ ﺧﺮﻭﺟی ﻗﺒل ًا ﻭﺟﻮﺩ ﺩﺍﺷﺘﻪ ﺑﺎﺷﺪ ،ﻧﺨﺴﺖ ﻣﺤﺘﻮﻳﺎﺕ ﺁﻥ ﺣﺬﻑ ﻣیﺷﻮﺩ ﻭ ﺳﭙﺲ ﺩﺍﺩﻩﻫﺎﯼ ﺟﺪﻳﺪ ﺩﺭ ﺁﻥ
ﻧﻮﺷﺘﻪ ﻣیﺷﻮﺩ .ﺍﺯ ﺍﻳﻦ ﺭﻭ ﺑﺎﻳﺪ ﺧﻴﻠی ﻣﺮﺍﻗﺐ ﺑﻮﺩ ،ﭼﺮﺍ ﻛﻪ ﺩﺍﺩﻩﻫﺎﯼ ﻗﺒﻠی ﻣﺎ ﺍﺯ ﺩﺳﺖ ﻣیﺭﻭﺩ .ﺍﻣﺎ ﺍﮔﺮ ﻓﺎﻳﻞ ﺧﺮﻭﺟی
ﺍﺯ ﻗﺒﻞ ﻭﺟﻮﺩ ﻧﺪﺍﺷﺘﻪ ﺑﺎﺷﺪ ،ﻳﮏ ﻓﺎﻳﻞ ﺧﺎﻟی ﺳﺎﺧﺘﻪ ﻣیﺷﻮﺩ.
ﻣﺜﺎﻝ:
In [1]: )'f= open ('text . txt ','w
)'! f. write ('Hello , world
Out[1]: 13
ﺧﺮﻭﺟی ﺑﺮﻧﺎﻣﻪ ﺗﻌﺪﺍﺩ ﻛﺎﺭﺍﻛﺘﺮﻫﺎﻳﯽ ﺍﺳﺖ ﻛﻪ ﺩﺍﺧﻞ ﻓﺎﻳﻞ text.txtﻧﻮﺷﺘﻪ ﻣیﺷﻮﺩ .ﺍﻛﻨﻮﻥ ﺍﮔﺮ ﻓﺎﻳﻞ ﺧﺮﻭﺟی ﺭﺍ
ﺑﺎﺯ ﻛﻨﻴﻢ ،ﭼﻴﺰﯼ ﺩﺍﺧﻞ ﺁﻥ ﻧﻮﺷﺘﻪ ﻧﺸﺪﻩ ﺍﺳﺖ .ﭼﺮﺍ ﻛﻪ ﻫﻨﻮﺯ ﻓﺎﻳﻞ ﺑﺎﺯ ﺍﺳﺖ ﻭ ﺑﺎﻳﺪ ﺁﻥ ﺭﺍ ﺑﺴﺖ .ﺑﻨﺎﺑﺮﺍﻳﻦ ﺑﺎ ﺭﻭﺵ
)( closeﻋﻤﻞ ﺑﺴﺘﻦ ﻓﺎﻳﻞ ﺍﻧﺠﺎﻡ ﻣیﺷﻮﺩ.
In [2]: )( f. close
ﺍﮔﺮ ﭼﻨﺪ ﺁﻳﺘﻢ ﺭﺍ ﺑﺨﻮﺍﻫﻴﻢ ﺩﺭ ﻳﮏ ﻓﺎﻳﻞ ﺑﻨﻮﻳﺴﻴﻢ .ﺭﻭﺵ )( writeﻣﺜﻞ ﺗﺎﻳع )( printﺳﻄﺮ ﻋﻮﺽ ﻧﻤیﻛﻨﺪ .ﭼﺮﺍ ﻛﻪ
ﺁﺭﮔﻮﻣﺎﻧﺎﺧﺘﻴﺎﺭﯼ ' '\nﺭﺍ ﻧﺪﺍﺭﺩ .ﺑﻨﺎﺑﺮﺍﻳﻦ ﺑﺎﻳﺪ ﺑﻪ ﺻﻮﺭﺕ ﺩﺳﺘی ﻭﺍﺭﺩ ﺑﺮﻧﺎﻣﻪ ﻧﻤﻮﺩ .ﺗﻔﺎﻭﺗی ﺩﻳﮕﺮﯼ ﻛﻪ ﺍﻳﻦ ﺩﻭ ﺑﺎ ﻫﻢ
ﺩﺍﺭﻧﺪ ﺍﻳﻦ ﺍﺳﺖ ﻛﻪ writeﺍﻃلاﻋﺎﺕ ﺭﺍ ﺩﺭﻭﻥ ﻓﺎﻳﻞ ﻣیﻧﻮﻳﺴﺪ ،ﺍﻣﺎ printﺍﻃلاﻋﺎﺕ ﺭﺍ ﺭﻭﯼ ﺻﻔﺤﮥ ﻧﻤﺎﻳﺶ ﭼﺎﭖ
ﻣیﻛﻨﺪ.
ﻣﺜﺎﻝ:
In [3]: )"file = open (" Employees . txt ", "w
for i in range (3):
)" name = input (" Enter the name of the employee :
) file . write ( name
)"file . write ("\n
)( file . close
)"print (" Data is written into the file .
۷۷ ﻓﺼﻞ .۵ﻋﻤﻠﻴﺎﺕ ﺭﻭﯼ ﻓﺎﻳﻞﻫﺎ ﻭ ﻣﺪﻳﺮﻳﺖ ﺧﻄﺎﻫﺎ
Out[3]: Enter the name of the employee : ali
Enter the name of the employee : ava
Enter the name of the employee : reza
Data is written into the file .
ﺩﺭ ﺍﻳﻨﺠﺎ ﻓﺎﻳﻠی ﺑﻪ ﻧﺎﻡ Employees.txtﺳﺎﺧﺘﻪ ﻣیﺷﻮﺩ ﻭ ﺍﺳﺎﻣی ali,ava,rezaﺩﺭ ﺳﻪ ﺳﻄﺮ ﻣﺠﺰﺍ ﻧﻮﺷﺘﻪ
ﻣیﺷﻮﺩ .ﺑﺮﺍﯼ ﻣﺸﺎﻫﺪﻩ ﻭ ﺍﻃﻤﻴﻨﺎﻥ ،ﻓﺎﻳﻞ ﺍﻳﺠﺎﺩ ﺷﺪﻩ ﺭﺍ ﻣیﺧﻮﺍﻧﻴﻢ.
In [1]: )"f= open (" Employees . txt ", "r
))( print (f. read
Out[1]: ali
ava
reza
ﺍﺿﺎﻓﻪ ﻛﺮﺩﻥ ﺍﻃلاﻋﺎﺕ ﺑﻪ ﺍﻧﺘﻬﺎﯼ ﻳﮏ ﻓﺎﻳﻞ ۵-۵
ﺑﺮﺍﯼ ﺍﺿﺎﻓﻪ ﻧﻤﻮﺩﻥ ﺍﻃلاﻋﺎﺕ ﺑﻪ ﺍﻧﺘﻬﺎﯼ ﻳﮏ ﻓﺎﻳﻞ ﺍﺯ ﺭﻭﺵ ) (appendﺍﺳﺘﻔﺎﺩﻩ ﻣیﺷﻮﺩ .ﺑﻨﺎﺑﺮﺍﻳﻦ ﺑﺎﻳﺪ ﺁﺭﮔﻮﻣﺎﻥ ﺩﻭﻡ
)( openﺑﻪ ﺻﻮﺭﺕ ' 'aﺑﺎﺷﺪ .ﺩﺭ ﺍﻳﻦ ﺣﺎﻟﺖ ﻧﻴﺰ ﻧﻤیﺗﻮﺍﻥ ﺍﻃلاﻋﺎﺕ ﻓﺎﻳﻞ ﺭﺍ ﺧﻮﺍﻧﺪ.
ﻣﺜﺎﻝ:
In [2]: )'f= open (' Employees . txt ','a
)'f. write ('Last name .
Out[2]: 10
ﻋﺪﺩ ۱۰ﺗﻌﺪﺍﺩ ﻛﺎﺭﺍﻛﺘﺮﯼ ) (Last name.ﺍﺳﺖ ﻛﻪ ﺑﻪ ﺍﻧﺘﻬﺎﯼ ﻓﺎﻳﻞ Employees.txtﺍﺿﺎﻓﻪ ﻣیﺷﻮﺩ .ﺑﺮﺍﯼ ﺍﻳﻦ
ﻛﻪ ﺧﺮﻭﺟی ﺑﺮﻭﺯ ﺭﺳﺎﻧی ﺷﻮﺩ .ﻓﺎﻳﻞ ﻣﻮﺭﺩ ﻧﻈﺮ ﺭﺍ ﻣیﺑﻨﺪﻳﻢ.
In [3]: )( f. close
ﺍﻛﻨﻮﻥ ﺑﺮﺍﯼ ﻣﺸﺎﻫﺪﻩ ﺗﻐﻴﻴﺮ ﻓﺎﻳﻞ ﺧﺮﻭﺟی ،ﺁﻥ ﺭﺍ ﻣیﺧﻮﺍﻧﻴﻢ.
In [4]: )'f= open (' Employees . txt ', 'r
))( print (f. read
Out[4]: ali
ava
rezaLast name .
ﭼﻮﻥ writeﭘﻴﺶﻓﺮﺽ ﺗﻌﻮﻳﺾ ﺳﻄﺮ ﺭﺍ ﻧﺪﺍﺭﺩ .ﺑﻨﺎﺑﺮﺍﻳﻦ ﺁﻳﺘﻢ ﺍﺿﺎﻓﻪ ﺷﺪﻩ ﺩﺭ ﺍﺩﺍﻣﻪ ﺳﻄﺮ ﺳﻮﻡ ﺁﻣﺪﻩ ﺍﺳﺖ .ﺑﺮﺍﯼ ﺍﻳﻦ
ﻛﻪ ﺳﻄﺮ ﻋﻮﺽ ﺷﻮﺩ ﻭ ﺁﻳﺘﻢ ﺍﺿﺎﻓﻪ ﺷﺪﻩ ﺩﺭ ﺳﻄﺮ ﭼﻬﺎﺭﻡ ﻧﻮﺷﺘﻪ ﺷﻮﺩ .ﺑﺎ ﺗﻐﻴﻴﺮ ﺟﺰﻳﯽ ﻛﺪﻫﺎﯼ ﺑﺎلا ﺭﺍ ﺗﻜﺮﺍﺭ ﻣیﻛﻨﻴﻢ.
.۶-۵ﺣﺎﻟﺖﻫﺎﯼ ﺗﺮﻛﻴﺒﯽ ﺧﻮﺍﻧﺪﻥ ﻭ ﻧﻮﺷﺘﻦ ﻭ ﺍﺿﺎﻓﻪ ﻛﺮﺩﻥ ۷۸
In [1]: )'f= open (' Employees . txt ','a
)'f. write ('\n
)'f. write ('Last name .
Out[1]: 10
In [2]: )( f. close
In [3]: )'f= open (' Employees . txt ', 'r
))( print (f. read
Out[3]: ali
ava
reza
Last name .
۶-۵ﺣﺎﻟﺖﻫﺎﯼ ﺗﺮﻛﻴﺒﯽ ﺧﻮﺍﻧﺪﻥ ﻭ ﻧﻮﺷﺘﻦ ﻭ ﺍﺿﺎﻓﻪ ﻛﺮﺩﻥ
ﻫﻤﺎﻧﻄﻮﺭ ﻛﻪ ﻗﺒل ًا ﻣﺸﺎﻫﺪﻩ ﺷﺪ ،ﺳﻪ ﺣﺎﻟﺖ ﺍﺻﻠی r, w, aﺑﺮﺍﯼ ﺑﺎﺯ ﻛﺮﺩﻥ ﻓﺎﻳﻞ ﻭﺟﻮﺩ ﺩﺍﺭﺩ .ﻭ ﻫﻤﭽﻨﻴﻦ ﺳﻪ ﺣﺎﻟﺖ
ﺗﺮﻛﻴﺒﯽ ﻧﻴﺰ ﻭﺟﻮﺩ ﺩﺍﺭﺩ ﻛﻪ ﻋﺒﺎﺭﺗﻨﺪ ﺍﺯ r+, w+, a+ :ﻣیﺑﺎﺷﻨﺪ.
ﺟﺪﻭﻝ :۱-۵ﺣﺎلاﺕ ﻣﺨﺘﻠﻒ ﺑﺎﺯ ﻛﺮﺩﻥ ﻓﺎﻳﻞﻫﺎ
Mode Description handle file Position
r Read B.o.F
w Write B.o.F
a Append E.o.F
r+ Write & Read B.o.F
w+ Read & Write B.o.F
a+ Read & Append E.o.F
• ﺑﺎ ﺣﺎﻟﺖ ) (r+ﻣیﺗﻮﺍﻥ ﻓﺎﻳﻞ ﺭﺍ ﺧﻮﺍﻧﺪ ﻭ ﺭﻭﯼ ﺁﻥ ﻧﻮﺷﺖ .ﻣﺜﺎﻝ:
In [4]: )'f= open ('toto . txt ','r+
)( f. tell
Out[4]: 0
ﭘﺲ ﻣﻜﺎﻥ ﻧﺸﺎﻧﮕﺮ ﺩﺭ ﺍﺑﺘﺪﺍﯼ ﻓﺎﻳﻞ ﺍﺳﺖ .ﺍﻛﻨﻮﻥ ﻓﺎﻳﻞ ﺭﺍ ﻣیﺧﻮﺍﻧﻴﻢ.
In [5]: ))( print (f. read
Out[5]: Hello , world .
welcome .
۷۹ ﻓﺼﻞ .۵ﻋﻤﻠﻴﺎﺕ ﺭﻭﯼ ﻓﺎﻳﻞﻫﺎ ﻭ ﻣﺪﻳﺮﻳﺖ ﺧﻄﺎﻫﺎ
ﻧﺸﺎﻧﮕﺮ ﺩﺭ ﺣﺎﻝ ﺣﺎﺿﺮ ﺩﺭ ﺍﻧﺘﻬﺎﯼ ﻓﺎﻳﻞ ﺍﺳﺖ .ﺍﻛﻨﻮﻥ ﻣیﺧﻮﺍﻫﻴﻢ ﻳﮏ ﺍﻃلاﻉ ﺟﺪﻳﺪ ﺑﻪ ﻓﺎﻳﻞ ﻣﻮﺭﺩ ﻧﻈﺮ
ﺍﺿﺎﻓﻪ ﻛﻨﻴﻢ.
In [1]: )'! f. write (' something new
Out[1]: 14
ﺗﻌﺪﺍﺩ ﻛﺎﺭﺍﻛﺘﺮﻫﺎ ،ﺑﺮﺍﯼ ﻧﻮﺷﺘﻦ ﺩﺭ ﻓﺎﻳﻞ ﺑﺮﺍﺑﺮ ﺑﺎ ۱۴ﺍﺳﺖ .ﺍﻛﻨﻮﻥ ﻓﺎﻳﻞ ﺭﺍ ﻣیﺑﻨﺪﻳﻢ.
In [2]: )( f. close
ﻣﺤﺘﻮﻳﺎﺕ ﻓﺎﻳﻞ ﺑﻪ ﺻﻮﺭﺕ ﺯﻳﺮ ﺗﻐﻴﻴﺮ ﻛﺮﺩﻩ ﺍﺳﺖ.
Out[2]: Hello , world .
! welcomesomething new
ﻋﻤﻠﻴﺎﺕ ﺍﺧﻴﺮ ﺭﺍ ﺗﻜﺮﺍﺭ ﻣیﻛﻨﻴﻢ ،ﻣﻨﺘﻬﺎ ﺍﻳﻦ ﺑﺎﺭ ﻓﺎﻳﻞ ﺭﺍ ﻧﻤیﺧﻮﺍﻧﻴﻢ.
In [3]: )'f= open ('toto . txt ','r+
)( f. tell
Out[3]: 0
ﻣﻜﺎﻥ ﻧﺸﺎﻧﮕﺮ ﺭﻭﯼ ﺻﻔﺮ ﺍﺳﺖ .ﺣﺎلا ﺁﻳﺘﻢ ﻣﻮﺭﺩ ﻧﻈﺮ ﺭﺍ ﺩﺭ ﻓﺎﻳﻞ ﻣیﻧﻮﻳﺴﻴﻢ.
In [4]: )' f. write ('OkOk
Out[4]: 4
ﺗﻌﺪﺍﺩ ﻛﺎﺭﺍﻛﺘﺮﻫﺎﯼ ﺩﺍﺩﻩ ﺷﺪﻩ ﺭﺍ ﺑﺮﻣیﮔﺮﺩﺍﻧﺪ ،ﻛﻪ ﺑﺮﺍﺑﺮ ۴ﺍﺳﺖ .ﻓﺎﻳﻞ ﺭﺍ ﻣیﺑﻨﺪﻳﻢ ﻭ ﺳﭙﺲ ﻣﺤﺘﻮﯼ ﺭﺍ ﻣﺸﺎﻫﺪﻩ
ﻣیﻛﻨﻴﻢ.
In [5]: )( f. close
Out[5]: OkOko , world .
welcome
ﻣﺸﺎﻫﺪﻩ ﻣیﺷﻮﺩ ﻛﻪ ۴ﺣﺮﻑ ﻣﻮﺭﺩ ﻧﻈﺮ ﻳﻌﻨی OkOkﺭﻭﯼ Hellﻧﺸﺴﺘﻪ ﻭ ﺁﻥ ﺭﺍ ﭘﺎﮎ ﻛﺮﺩﻩ ﺍﺳﺖ.
• ﺑﺎ ﺣﺎﻟﺖ ) (w+ﻣیﺗﻮﺍﻥ ﺭﻭﯼ ﻓﺎﻳﻞ ﻧﻮﺷﺖ ﻭ ﺳﭙﺲ ﺁﻥ ﺭﺍ ﺧﻮﺍﻧﺪ .ﻣﺜﺎﻝ:
In [6]: )'f= open ('toto . txt ','w+
)( f. tell
Out[6]: 4
.۶-۵ﺣﺎﻟﺖﻫﺎﯼ ﺗﺮﻛﻴﺒﯽ ﺧﻮﺍﻧﺪﻥ ﻭ ﻧﻮﺷﺘﻦ ﻭ ﺍﺿﺎﻓﻪ ﻛﺮﺩﻥ ۸۰
ﺣﺎلا ﺑﺎ ﺭﻭﺵ )( seekﻣﻜﺎﻥ ﻧﺸﺎﻧﮕﺮ ﺭﺍ ﺑﻪ ﺍﺑﺘﺪﺍﯼ ﻓﺎﻳﻞ ﻣﻨﺘﻘﻞ ﻣیﻛﻨﻴﻢ .ﻭ ﻓﺎﻳﻞ ﺭﺍ ﻣیﺧﻮﺍﻧﻴﻢ .ﺗﻮﺟﻪ ﺩﺍﺷﺘﻪ
ﺑﺎﺷﻴﺪ ﻛﻪ ﺩﺭ ﺣﺎﻟﺖ wﻧﻤیﺗﻮﺍﻥ ﻣﺤﺘﻮﻳﺎﺕ ﻓﺎﻳﻞ ﺭﺍ ﺧﻮﺍﻧﺪ.
In [1]: ))( print (f. read
Out[1]: Hey , how are you
• ﺑﺎ ﺣﺎﻟﺖ ) (a+ﻣیﺗﻮﺍﻥ ﺁﺧﺮ ﻓﺎﻳﻞ ﻧﻮﺷﺖ ﻭ ﺳﭙﺲ ﺁﻥ ﺭﺍ ﺧﻮﺍﻧﺪ .ﻣﺜﺎﻝ:
In [2]: )'f= open ('toto . txt ','a+
)( f. tell
Out[2]: 16
ﻣﻘﺪﺍﺭ ۱۶ﺍﻧﺘﻬﺎﯼ ﻓﺎﻳﻞ ﺭﺍ ﻧﺸﺎﻥ ﻣیﺩﻫﺪ.
In [3]: ))( print (f. read
ﺑﻨﺎﺑﺮﺍﻳﻦ ﭼﻴﺰﯼ ﭼﺎﭖ ﻧﻤیﺷﻮﺩ .ﺣﺎلا ﺑﺎ ﺍﺳﺘﻔﺎﺩﻩ ﺍﺯ ﺭﻭﺵ )( seekﻣﻜﺎﻥ ﻧﺸﺎﻧﮕﺮ ﺭﺍ ﺑﻪ ﺍﺑﺘﺪﺍﯼ ﻓﺎﻳﻞ ﻣیﺍﻭﺭﻳﻢ.
In [4]: )f. seek (0
Out[4]: 0
ﺍﻛﻨﻮﻥ ﻓﺎﻳﻞ ﺭﺍ ﻣیﺧﻮﺍﻧﻴﻢ.
In [5]: ))( print (f. read
Out[5]: Hey , how are you
ﺣﺎلا ﻳﮏ ﺁﻳﺘﻢ ﺭﻭﯼ ﻓﺎﻳﻞ ﻣیﻧﻮﻳﺴﻴﻢ.
In [6]: )' f. write ('Ok
Out[6]: 2
In [7]: )( f. tell
Out[7]: 18
ﻣﻜﺎﻥ ﻧﺸﺎﻧﮕﺮ ﺭﺍ ﺑﻪ ﺍﻭﻝ ﻓﺎﻳﻞ ﻣﻨﺘﻘﻞ ﻣیﻛﻨﻴﻢ.
In [8]: )f. seek (0
Out[8]: 0
ﺍﻛﻨﻮﻥ ﻓﺎﻳﻞ ﺧﻮﺍﻧﺪﻩ ﻣیﺷﻮﺩ.
۸۱ ﻓﺼﻞ .۵ﻋﻤﻠﻴﺎﺕ ﺭﻭﯼ ﻓﺎﻳﻞﻫﺎ ﻭ ﻣﺪﻳﺮﻳﺖ ﺧﻄﺎﻫﺎ
In [1]: ))( print (f. read
Out[1]: Hey , how are youOk
ﺣﺎلا ﻳﮏ ﺗﻔﺎﻭﺕ ﺭﺍ ﻣﺸﺎﻫﺪﻩ ﺧﻮﺍﻫﻴﻢ ﻧﻤﻮﺩ.
In [2]: )f. seek (0
Out[2]: 0
ﺍﻛﻨﻮﻥ ﺁﻳﺘﻤی ﺭﺍ ﺭﻭﯼ ﻓﺎﻳﻞ ﺑﺎ ﺗﻮﺟﻪ ﺑﻪ ﺍﻳﻦ ﻛﻪ ﻣﻜﺎﻥ ﻧﺸﺎﻧﮕﺮ ﺩﺭ ﺍﺑﺘﺪﺍﯼ ﻓﺎﻳﻞ ﺍﺳﺖ ،ﻣیﻧﻮﻳﺴﻴﻢ
In [3]: )' f. write (' GoodBy
Out[3]: 6
ﺩﻭﺑﺎﺭﻩ ﻣﻜﺎﻥ ﻧﺸﺎﻧﮕﺮ ﺑﻪ ﺍﺑﺘﺪﺍﯼ ﻓﺎﻳﻞ ﻣﻨﺘﻘﻞ ﻣیﺷﻮﺩ.
In [4]: )f. seek (0
Out[4]: 0
ﺳﭙﺲ ﻓﺎﻳﻞ ﺧﻮﺍﻧﺪﻩ ﻣیﺷﻮﺩ.
In [5]: ))( print (f. read
Out[5]: Hey , how are youOkGoodBy
ﺑﺎ ﺍﻳﻦ ﻛﻪ ﻣﻜﺎﻥ ﻧﺸﺎﻧﮕﺮ ﺍﻭﻝ ﻓﺎﻳﻞ ﺑﻮﺩ .ﺍﻣﺎ ﺁﻳﺘﻢ ﻧﻮﺷﺘﻪ ﺷﺪﻩ ﺩﺭ ﭘﺎﻳﺎﻥ ﻓﺎﻳﻞ ﻗﺮﺍﺭ ﮔﺮﻓﺖ .ﻭ ﺍﻳﻦ ﺗﻔﺎﻭﺕ ﺣﺎﻟﺖ
) (a+ﺑﺎ ﺳﺎﻳﺮ ﺣﺎلاﺕ ﺍﺳﺖ.
ﻋﻤﻠﻴﺎﺕ ﺑﺎ ﻓﺎﻳﻞﻫﺎ ﺑﺎ ﭘﺴﻮﻧﺪ CSV ۷-۵
ﻓﺎﻳﻞ ﺩﺍﺩﻩﻫﺎﻳﯽ ﻭﺟﻮﺩ ﺩﺍﺭﻧﺪ ﻛﻪ ﭘﺴﻮﻧﺪ ۱ﺁﻥ ۲ CSVﻫﺴﺘﻨﺪ .ﻓﻴﻠﺪﻫﺎﯼ ﺍﻳﻦ ﻓﺎﻳﻞ ﺑﺎ ﻛﺎﻣﺎ ﺍﺯ ﻫﻢ ﺟﺪﺍ ﻣیﺷﻮﻧﺪ ﻭ ﺑﺎ
ﺻﻔﺤﻪ ﮔﺴﺘﺮﺩﻩﺍﯼ ﻣﺎﻧﻨﺪ Excelﺳﺎﺯﮔﺎﺭ ﻫﺴﺘﻨﺪ .ﺍﻣﺎ ﻓﺮﻕ ﺁﻥ ﺑﺎ ﻓﺎﻳﻞﻫﺎﯼ ﺍﻛﺴﻞ ﺍﻳﻦ ﺍﺳﺖ ﻛﻪ ﻣﺜﻞ ﻓﺎﻳﻞﻫﺎﯼ ﻣﺘﻨی
ﻗﺎﺑﻞ ﻭﻳﺮﺍﻳﺶ ﺍﺳﺖ ﺍﻣﺎ ﻓﺎﻳﻞﻫﺎﯼ ﺍﻛﺴﻞ ﺍﻳﻦ ﺧﺎﺻﻴﺖ ﺭﺍ ﻧﺪﺍﺭﺩ .ﺍﺯ ﻃﺮﻓی ﻣیﺗﻮﺍﻥ ﺁﻧﻬﺎ ﺭﺍ ﺑﺎ ﺍﻛﺴﻞ ﺑﺎﺯ ﻧﻤﻮﺩ.
ﭘﺎﻳﺘﻮﻥ ﻣیﺗﻮﺍﻧﺪ ﺍﻳﻦ ﻧﻮع ﻓﺎﻳﻞﻫﺎ ﺭﺍ ﺑﺨﻮﺍﻧﺪ ﻭ ﻫﻢ ﺭﻭﯼ ﺁﻥ ﺑﻨﻮﻳﺴﺪ .ﻣﺜﺎﻝ :ﻳﮏ ﻓﺎﻳﻞ csvﺑﻪ ﻧﺎﻡ data.csvﺑﻪ
ﺻﻮﺭﺕ ﺯﻳﺮ ﺍﺳﺖ.
name , age , E _ m a i l
a l i , 3 0 , a l i @ y a h o o . com
r e z a , 2 5 , r e z a @ h o t m a i l . com
1. Extension
2. Comma Seperated Values
CSV ﻋﻤﻠﻴﺎﺕ ﺑﺎ ﻓﺎﻳﻞﻫﺎ ﺑﺎ ﭘﺴﻮﻧﺪ.۷-۵ ۸۲
ava , 2 0 , ava@gmail . com
. ﺭﺍ ﺩﺭ ﭘﺎﻳﺘﻮﻥ ﺑﺨﻮﺍﻧﻴﻢdata.csv ﻣیﺧﻮﺍﻫﻴﻢ ﺍﻳﻦ ﻓﺎﻳﻞ
In [1]: f_in = open ('data . csv ')
for line in f_in :
print (line , end ='')
f_in . close ()
Out[1]: name ,age , E_mail
ali ,30 , ali@yahoo . com
reza ,25 , reza@hotmail . com
ava ,20 , ava@gmail . com
csv ﺧﻮﺍﻧﺪﻥ ﻭ ﻧﻮﺷﺘﻦ ﻓﺎﻳﻞ ﺑﺎ ﭘﺴﻮﻧﺪ:ﻣﺜﺎﻝ
In [2]: f_in = open ('data . csv ')
f_out = open (' outdata . txt ', 'w')
for line in f_in :
fields = line . split (',')
field1 = fields [0]
field2 = fields [1]
field3 = fields [2]
print ( field1 +' '+ field2 +' '+ field3 , end ='')
f_out . write ( field1 +' '+ field2 +' '+ field3 )
f_in . close ()
f_out . close ()
Out[2]: name age E_mail
ali 30 ali@yahoo . com
reza 25 reza@hotmail . com
ava 20 ava@gmail . com
You might also like
- آ ﻣ ﻮ ز ش ﭘ ﯿ ﺸ ﺮ ﻓ ﺘ ﻪ ﺑ ﺮﻧ ﺎ ﻣ ﻪ ﻧ ﻮ ﯾ ﺴ ﯽ ﺑ ﻪ ز ﺑﺎ ن ﭘ ﺎﯾ ﺘ ﻮ ن Python ۱۴۰۱No ratings yetآ ﻣ ﻮ ز ش ﭘ ﯿ ﺸ ﺮ ﻓ ﺘ ﻪ ﺑ ﺮﻧ ﺎ ﻣ ﻪ ﻧ ﻮ ﯾ ﺴ ﯽ ﺑ ﻪ ز ﺑﺎ ن ﭘ ﺎﯾ ﺘ ﻮ ن Python ۱۴۰۱68 pages
- Jozveban - Ir Elegram - Me/jozveban T Ir/sopnuu App. SNo ratings yetJozveban - Ir Elegram - Me/jozveban T Ir/sopnuu App. S41 pages
- @jozvehjo خلاصه ساختمان داده موسسه نصیرNo ratings yet@jozvehjo خلاصه ساختمان داده موسسه نصیر26 pages
- PL_assignment_4_Semantic-DueDate 1402-02-26No ratings yetPL_assignment_4_Semantic-DueDate 1402-02-262 pages
- Answer-Assignment3- Data Structure and Algorithm DesignNo ratings yetAnswer-Assignment3- Data Structure and Algorithm Design3 pages
